git.zerfleddert.de Git - micropolis/blame_incremental - src/sim/terrain/mapgener.c

/* mapgener.c
 *
 * Micropolis, Unix Version.  This game was released for the Unix platform
 * in or about 1990 and has been modified for inclusion in the One Laptop
 * Per Child program.  Copyright (C) 1989 - 2007 Electronic Arts Inc.  If
 * you need assistance with this program, you may contact:
 *   http://wiki.laptop.org/go/Micropolis  or email  micropolis@laptop.org.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or (at
 * your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.  You should have received a
 * copy of the GNU General Public License along with this program.  If
 * not, see <http://www.gnu.org/licenses/>.
 *
 *             ADDITIONAL TERMS per GNU GPL Section 7
 *
 * No trademark or publicity rights are granted.  This license does NOT
 * give you any right, title or interest in the trademark SimCity or any
 * other Electronic Arts trademark.  You may not distribute any
 * modification of this program using the trademark SimCity or claim any
 * affliation or association with Electronic Arts Inc. or its employees.
 *
 * Any propagation or conveyance of this program must include this
 * copyright notice and these terms.
 *
 * If you convey this program (or any modifications of it) and assume
 * contractual liability for the program to recipients of it, you agree
 * to indemnify Electronic Arts for any liability that those contractual
 * assumptions impose on Electronic Arts.
 *
 * You may not misrepresent the origins of this program; modified
 * versions of the program must be marked as such and not identified as
 * the original program.
 *
 * This disclaimer supplements the one included in the General Public
 * License.  TO THE FULLEST EXTENT PERMISSIBLE UNDER APPLICABLE LAW, THIS
 * PROGRAM IS PROVIDED TO YOU "AS IS," WITH ALL FAULTS, WITHOUT WARRANTY
 * OF ANY KIND, AND YOUR USE IS AT YOUR SOLE RISK.  THE ENTIRE RISK OF
 * SATISFACTORY QUALITY AND PERFORMANCE RESIDES WITH YOU.  ELECTRONIC ARTS
 * DISCLAIMS ANY AND ALL EXPRESS, IMPLIED OR STATUTORY WARRANTIES,
 * INCLUDING IMPLIED WARRANTIES OF MERCHANTABILITY, SATISFACTORY QUALITY,
 * FITNESS FOR A PARTICULAR PURPOSE, NONINFRINGEMENT OF THIRD PARTY
 * RIGHTS, AND WARRANTIES (IF ANY) ARISING FROM A COURSE OF DEALING,
 * USAGE, OR TRADE PRACTICE.  ELECTRONIC ARTS DOES NOT WARRANT AGAINST
 * INTERFERENCE WITH YOUR ENJOYMENT OF THE PROGRAM; THAT THE PROGRAM WILL
 * MEET YOUR REQUIREMENTS; THAT OPERATION OF THE PROGRAM WILL BE
 * UNINTERRUPTED OR ERROR-FREE, OR THAT THE PROGRAM WILL BE COMPATIBLE
 * WITH THIRD PARTY SOFTWARE OR THAT ANY ERRORS IN THE PROGRAM WILL BE
 * CORRECTED.  NO ORAL OR WRITTEN ADVICE PROVIDED BY ELECTRONIC ARTS OR
 * ANY AUTHORIZED REPRESENTATIVE SHALL CREATE A WARRANTY.  SOME
 * JURISDICTIONS DO NOT ALLOW THE EXCLUSION OF OR LIMITATIONS ON IMPLIED
 * WARRANTIES OR THE LIMITATIONS ON THE APPLICABLE STATUTORY RIGHTS OF A
 * CONSUMER, SO SOME OR ALL OF THE ABOVE EXCLUSIONS AND LIMITATIONS MAY
 * NOT APPLY TO YOU.
 */

/* Micropolis simulator code.	Copyright 1988, 1989 Maxis, Will Wright */

#include "sim.h"

#define TRUE 1
#define FALSE 0
#define WORLD_X 120
#define WORLD_Y 100
#define RIVER 2
#define REDGE 3
#define CHANNEL 4
#define WOODS 37
#define BL 4096
#define BN 8192
#define BLN BL+BN

static int XStart, YStart;
static int  Dir, LastDir;

					/* trash values for GRand()  	*/
static int GRanArray[5] = { 1018,4521,202,419,3 };

far GenerateMap()
{
	GRanArray[0] = TickCount();  /* This is the only machine-specific call  */
								 /* It inits GRand() w/ clockcount(long)	*/

	if (!(GRand(10)))  {			/* 1 in 3 chance that island is generated  	*/
		MakeIsland();
		return;
	}
	ClearMap();					/* else make river map						*/
	GetRandStart();
	DoRivers();
	MakeLakes();
	SmoothRiver();
	DoTrees();
}

near ClearMap()
{
register int x, y;

	for (x=0; x<WORLD_X; x++)
		for (y=0; y<WORLD_Y; y++)
			Map[x][y] = 0;
}

#define RADIUS 18

near MakeIsland()
{
	register int x,y,z;

	for (x=0; x<WORLD_X; x++)
		for (y=0; y<WORLD_Y; y++)
			Map[x][y] = RIVER;
	for (x=5; x<WORLD_X-5; x++)
		for (y=5; y<WORLD_Y-5; y++)
			Map[x][y] = 0;
	for (x=0; x<WORLD_X-5; x+=2)	{
		MapX= x ;
		MapY= EGRand(RADIUS);
		BRivPlop();
		MapY= 90-EGRand(RADIUS);
		BRivPlop();
		MapY= 0;
		SRivPlop();
		MapY= 94;
		SRivPlop();
	}
	for (y=0; y<WORLD_Y-5; y+=2)	{
		MapY= y ;
		MapX= EGRand(RADIUS);
		BRivPlop();
		MapX= 110-EGRand(RADIUS);
		BRivPlop();
		MapX= 0;
		SRivPlop();
		MapX= 114;
		SRivPlop();
	}
	SmoothRiver();
	DoTrees();
}

near MakeLakes()
{
	int Lim1, Lim2, t, z;
	register int x, y;

	Lim1 = GRand(10);
	for (t = 0; t < Lim1; t++)  {
		x = GRand(99) + 10;
		y = GRand(80) + 10;
		Lim2 = GRand(12)+2;
		for (z = 0; z < Lim2; z++)  {
			MapX = x - 6 + GRand(12);
			MapY = y - 6 + GRand(12);
			if (GRand(4))  SRivPlop();
			else  BRivPlop();
		}
	}
}

near GetRandStart()
{
	XStart = 40 + GRand(40);
	YStart = 33 + GRand(33);
	MapX = XStart;
	MapY = YStart;
}

near DoTrees()
{
	int Amount,x,xloc,yloc;

	Amount = GRand(100)+50;
	for (x=0; x<Amount; x++)  {
		xloc = GRand(119);
		yloc = GRand(99);
		TreeSplash(xloc,yloc);
	}
	SmoothTrees();
	SmoothTrees();
}

near TreeSplash(xloc,yloc)
int xloc,yloc;
{
	int  Dis, Dir;
	register int xoff, yoff,z;

	Dis = GRand(150)+50;
	MapX = xloc;
	MapY = yloc;
	for (z=0; z<Dis; z++)	{
		Dir = GRand(7);
		MoveMap(Dir);
		if (!(TestBounds(MapX,MapY))) return;
		if (Map[MapX][MapY] == 0)  Map[MapX][MapY] = WOODS+ BLN;
	}
}

far SmoothRiver()
{
 static int DX[4] = {-1, 0, 1, 0};
 static int DY[4] = { 0, 1, 0,-1};
 static int REdTab[16] = { 13+BL,13+BL,17+BL,15+BL,5+BL,2,19+BL,
 						   17+BL,9+BL,11+BL,2,13+BL,7+BL,9+BL,5+BL,2};
 int  bitindex, z,Xtem,Ytem;
 register int temp,MapX,MapY;

 for (MapX = 0; MapX < WORLD_X; MapX++)
 	for (MapY = 0; MapY < WORLD_Y; MapY++)
 		if (Map[MapX][MapY] == REDGE)	{
 			bitindex = 0;
 			for (z=0; z<4; z++)	{
 				bitindex = bitindex << 1;
 				Xtem = MapX + DX[z];
 				Ytem = MapY + DY[z];
 				if (TestBounds(Xtem, Ytem))
 					if ( Map[Xtem][Ytem]) bitindex++;
 			}
 			temp = REdTab[bitindex & 15];
 			if ((temp != 2) && (GRand(1))) temp++;
 			Map[MapX][MapY] = temp;
 		}
 }

far SmoothTrees()
{
 static int DX[4] = {-1, 0, 1, 0};
 static int DY[4] = { 0, 1, 0,-1};
 static int TEdTab[16] = {0,0,0,34,0,0,36,35,0,32,0,33,30,31,29,37};
 int   bitindex, z,Xtem,Ytem;
 register int temp,MapX,MapY;

 for (MapX = 0; MapX < WORLD_X; MapX++)
 	for (MapY = 0; MapY < WORLD_Y; MapY++)
 		if ((Map[MapX][MapY] & BLN) == BLN)	{
 			bitindex = 0;
 			for (z=0; z<4; z++)	{
 				bitindex = bitindex << 1;
 				Xtem = MapX + DX[z];
 				Ytem = MapY + DY[z];
 				if (TestBounds(Xtem, Ytem))
 					if (Map[Xtem][Ytem] & BN) bitindex++;

 			}
 			temp = TEdTab[bitindex & 15];
 			if (temp) {
 				if (temp != 37)
 					if ((MapX+MapY) & 1)
 						temp = temp-8;
 				Map[MapX][MapY] = temp+BLN;
 			}
 			else Map[MapX][MapY] = temp;
 		}
 }

near DoRivers()
{

	LastDir = GRand(3);
	Dir = LastDir;
	DoBRiv();
	MapX = XStart;
	MapY = YStart;
	LastDir = LastDir ^ 4;
	Dir = LastDir;
	DoBRiv();
	MapX = XStart;
	MapY = YStart;
	LastDir = GRand(3);
	DoSRiv();
}

near DoBRiv()
{
int temp, count;

	count = 0;
	while (TestBounds (MapX+4, MapY+4))		{
		BRivPlop();
		if (GRand(10) > 4) Dir++;
		if (GRand(10) > 4) Dir--;
		if (!(GRand(10))) Dir = LastDir;
		MoveMap (Dir);
	}
}

near DoSRiv()
{
int temp;

	while (TestBounds (MapX+3, MapY+3))		{
		SRivPlop();
		if (GRand(10) > 5) Dir++;
		if (GRand(10) > 5) Dir--;
		if (!(GRand(12))) Dir = LastDir;
		MoveMap (Dir);
	}
}

near MoveMap	(dir)
int dir;
{
static int DirTab[2][8] ={		{ 0, 1, 1, 1, 0, -1, -1, -1},
								{-1,-1, 0, 1, 1,  1,  0, -1}	};
	dir = dir & 7;
	MapX += DirTab[0][dir];
	MapY += DirTab[1][dir];
}


near BRivPlop()
{
static int BRMatrix[9][9] ={
		{0,0,0,3,3,3,0,0,0},
		{0,0,3,2,2,2,3,0,0},
		{0,3,2,2,2,2,2,3,0},
		{3,2,2,2,2,2,2,2,3},
		{3,2,2,2,4,2,2,2,3},
		{3,2,2,2,2,2,2,2,3},
		{0,3,2,2,2,2,2,3,0},
		{0,0,3,2,2,2,3,0,0},
		{0,0,0,3,3,3,0,0,0}		};
int x, y;

	for (x=0; x<9; x++)
		for (y=0; y<9; y++)
			PutOnMap (BRMatrix[y][x], x, y);
}

near SRivPlop()
{
static int SRMatrix[6][6] ={
		{0,0,3,3,0,0},
		{0,3,2,2,3,0},
		{3,2,2,2,2,3},
		{3,2,2,2,2,3},
		{0,3,2,2,3,0},
		{0,0,3,3,0,0}		};
int x, y;

	for (x=0; x<6; x++)
		for (y=0; y<6; y++)
			PutOnMap (SRMatrix[y][x], x, y);
}

near PutOnMap (Mchar, Xoff, Yoff)
int Mchar, Xoff, Yoff;
{
register int Xloc, Yloc, temp;

	if (Mchar == 0) return;
	Xloc = MapX + Xoff;
	Yloc = MapY + Yoff;
	if (TestBounds (Xloc, Yloc) == FALSE) return (FALSE);
	if (temp = Map [Xloc][Yloc])	{
		temp = temp & 1023;
		if (temp == RIVER)
			if (Mchar != CHANNEL)
				return (FALSE);
		if (temp == CHANNEL) return (FALSE);
	}
	Map [Xloc][Yloc] = Mchar;
}

far TestBounds(x, y)
register int x, y;
{
	if ((( x >= 0) && (x < WORLD_X)) && (( y >= 0) && (y < WORLD_Y)))
		return (TRUE);
	return (FALSE);
}


near EGRand(limit)
int limit;
{
	int x,z;

	z= GRand(limit);
	x= GRand(limit);
	if (z < x) return(z);
	return(x);
}

#define RANMASK 32767

near GRand(range)			/* stupid but works  */
int range;
{
	register x, newv, divisor;

	divisor = RANMASK/ (range+1);
	newv = 0;
	for (x=4; x!=0; x--)
		newv += (GRanArray[x] = GRanArray[x-1]);
	GRanArray[0] = newv;
	x = (newv & RANMASK) / divisor;
	if (x > range)  return(range);
	return(x);
}
Commit	Line	Data
	1	/* mapgener.c
	2	*
	3	* Micropolis, Unix Version. This game was released for the Unix platform
	4	* in or about 1990 and has been modified for inclusion in the One Laptop
	5	* Per Child program. Copyright (C) 1989 - 2007 Electronic Arts Inc. If
	6	* you need assistance with this program, you may contact:
	7	* http://wiki.laptop.org/go/Micropolis or email micropolis@laptop.org.
	8	*
	9	* This program is free software: you can redistribute it and/or modify
	10	* it under the terms of the GNU General Public License as published by
	11	* the Free Software Foundation, either version 3 of the License, or (at
	12	* your option) any later version.
	13	*
	14	* This program is distributed in the hope that it will be useful, but
	15	* WITHOUT ANY WARRANTY; without even the implied warranty of
	16	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	17	* General Public License for more details. You should have received a
	18	* copy of the GNU General Public License along with this program. If
	19	* not, see <http://www.gnu.org/licenses/>.
	20	*
	21	* ADDITIONAL TERMS per GNU GPL Section 7
	22	*
	23	* No trademark or publicity rights are granted. This license does NOT
	24	* give you any right, title or interest in the trademark SimCity or any
	25	* other Electronic Arts trademark. You may not distribute any
	26	* modification of this program using the trademark SimCity or claim any
	27	* affliation or association with Electronic Arts Inc. or its employees.
	28	*
	29	* Any propagation or conveyance of this program must include this
	30	* copyright notice and these terms.
	31	*
	32	* If you convey this program (or any modifications of it) and assume
	33	* contractual liability for the program to recipients of it, you agree
	34	* to indemnify Electronic Arts for any liability that those contractual
	35	* assumptions impose on Electronic Arts.
	36	*
	37	* You may not misrepresent the origins of this program; modified
	38	* versions of the program must be marked as such and not identified as
	39	* the original program.
	40	*
	41	* This disclaimer supplements the one included in the General Public
	42	* License. TO THE FULLEST EXTENT PERMISSIBLE UNDER APPLICABLE LAW, THIS
	43	* PROGRAM IS PROVIDED TO YOU "AS IS," WITH ALL FAULTS, WITHOUT WARRANTY
	44	* OF ANY KIND, AND YOUR USE IS AT YOUR SOLE RISK. THE ENTIRE RISK OF
	45	* SATISFACTORY QUALITY AND PERFORMANCE RESIDES WITH YOU. ELECTRONIC ARTS
	46	* DISCLAIMS ANY AND ALL EXPRESS, IMPLIED OR STATUTORY WARRANTIES,
	47	* INCLUDING IMPLIED WARRANTIES OF MERCHANTABILITY, SATISFACTORY QUALITY,
	48	* FITNESS FOR A PARTICULAR PURPOSE, NONINFRINGEMENT OF THIRD PARTY
	49	* RIGHTS, AND WARRANTIES (IF ANY) ARISING FROM A COURSE OF DEALING,
	50	* USAGE, OR TRADE PRACTICE. ELECTRONIC ARTS DOES NOT WARRANT AGAINST
	51	* INTERFERENCE WITH YOUR ENJOYMENT OF THE PROGRAM; THAT THE PROGRAM WILL
	52	* MEET YOUR REQUIREMENTS; THAT OPERATION OF THE PROGRAM WILL BE
	53	* UNINTERRUPTED OR ERROR-FREE, OR THAT THE PROGRAM WILL BE COMPATIBLE
	54	* WITH THIRD PARTY SOFTWARE OR THAT ANY ERRORS IN THE PROGRAM WILL BE
	55	* CORRECTED. NO ORAL OR WRITTEN ADVICE PROVIDED BY ELECTRONIC ARTS OR
	56	* ANY AUTHORIZED REPRESENTATIVE SHALL CREATE A WARRANTY. SOME
	57	* JURISDICTIONS DO NOT ALLOW THE EXCLUSION OF OR LIMITATIONS ON IMPLIED
	58	* WARRANTIES OR THE LIMITATIONS ON THE APPLICABLE STATUTORY RIGHTS OF A
	59	* CONSUMER, SO SOME OR ALL OF THE ABOVE EXCLUSIONS AND LIMITATIONS MAY
	60	* NOT APPLY TO YOU.
	61	*/
	62
	63	/* Micropolis simulator code. Copyright 1988, 1989 Maxis, Will Wright */
	64
	65	#include "sim.h"
	66
	67	#define TRUE 1
	68	#define FALSE 0
	69	#define WORLD_X 120
	70	#define WORLD_Y 100
	71	#define RIVER 2
	72	#define REDGE 3
	73	#define CHANNEL 4
	74	#define WOODS 37
	75	#define BL 4096
	76	#define BN 8192
	77	#define BLN BL+BN
	78
	79	static int XStart, YStart;
	80	static int Dir, LastDir;
	81
	82	/* trash values for GRand() */
	83	static int GRanArray[5] = { 1018,4521,202,419,3 };
	84
	85	far GenerateMap()
	86	{
	87	GRanArray[0] = TickCount(); /* This is the only machine-specific call */
	88	/* It inits GRand() w/ clockcount(long) */
	89
	90	if (!(GRand(10))) { /* 1 in 3 chance that island is generated */
	91	MakeIsland();
	92	return;
	93	}
	94	ClearMap(); /* else make river map */
	95	GetRandStart();
	96	DoRivers();
	97	MakeLakes();
	98	SmoothRiver();
	99	DoTrees();
	100	}
	101
	102	near ClearMap()
	103	{
	104	register int x, y;
	105
	106	for (x=0; x<WORLD_X; x++)
	107	for (y=0; y<WORLD_Y; y++)
	108	Map[x][y] = 0;
	109	}
	110
	111	#define RADIUS 18
	112
	113	near MakeIsland()
	114	{
	115	register int x,y,z;
	116
	117	for (x=0; x<WORLD_X; x++)
	118	for (y=0; y<WORLD_Y; y++)
	119	Map[x][y] = RIVER;
	120	for (x=5; x<WORLD_X-5; x++)
	121	for (y=5; y<WORLD_Y-5; y++)
	122	Map[x][y] = 0;
	123	for (x=0; x<WORLD_X-5; x+=2) {
	124	MapX= x ;
	125	MapY= EGRand(RADIUS);
	126	BRivPlop();
	127	MapY= 90-EGRand(RADIUS);
	128	BRivPlop();
	129	MapY= 0;
	130	SRivPlop();
	131	MapY= 94;
	132	SRivPlop();
	133	}
	134	for (y=0; y<WORLD_Y-5; y+=2) {
	135	MapY= y ;
	136	MapX= EGRand(RADIUS);
	137	BRivPlop();
	138	MapX= 110-EGRand(RADIUS);
	139	BRivPlop();
	140	MapX= 0;
	141	SRivPlop();
	142	MapX= 114;
	143	SRivPlop();
	144	}
	145	SmoothRiver();
	146	DoTrees();
	147	}
	148
	149	near MakeLakes()
	150	{
	151	int Lim1, Lim2, t, z;
	152	register int x, y;
	153
	154	Lim1 = GRand(10);
	155	for (t = 0; t < Lim1; t++) {
	156	x = GRand(99) + 10;
	157	y = GRand(80) + 10;
	158	Lim2 = GRand(12)+2;
	159	for (z = 0; z < Lim2; z++) {
	160	MapX = x - 6 + GRand(12);
	161	MapY = y - 6 + GRand(12);
	162	if (GRand(4)) SRivPlop();
	163	else BRivPlop();
	164	}
	165	}
	166	}
	167
	168	near GetRandStart()
	169	{
	170	XStart = 40 + GRand(40);
	171	YStart = 33 + GRand(33);
	172	MapX = XStart;
	173	MapY = YStart;
	174	}
	175
	176	near DoTrees()
	177	{
	178	int Amount,x,xloc,yloc;
	179
	180	Amount = GRand(100)+50;
	181	for (x=0; x<Amount; x++) {
	182	xloc = GRand(119);
	183	yloc = GRand(99);
	184	TreeSplash(xloc,yloc);
	185	}
	186	SmoothTrees();
	187	SmoothTrees();
	188	}
	189
	190	near TreeSplash(xloc,yloc)
	191	int xloc,yloc;
	192	{
	193	int Dis, Dir;
	194	register int xoff, yoff,z;
	195
	196	Dis = GRand(150)+50;
	197	MapX = xloc;
	198	MapY = yloc;
	199	for (z=0; z<Dis; z++) {
	200	Dir = GRand(7);
	201	MoveMap(Dir);
	202	if (!(TestBounds(MapX,MapY))) return;
	203	if (Map[MapX][MapY] == 0) Map[MapX][MapY] = WOODS+ BLN;
	204	}
	205	}
	206
	207	far SmoothRiver()
	208	{
	209	static int DX[4] = {-1, 0, 1, 0};
	210	static int DY[4] = { 0, 1, 0,-1};
	211	static int REdTab[16] = { 13+BL,13+BL,17+BL,15+BL,5+BL,2,19+BL,
	212	17+BL,9+BL,11+BL,2,13+BL,7+BL,9+BL,5+BL,2};
	213	int bitindex, z,Xtem,Ytem;
	214	register int temp,MapX,MapY;
	215
	216	for (MapX = 0; MapX < WORLD_X; MapX++)
	217	for (MapY = 0; MapY < WORLD_Y; MapY++)
	218	if (Map[MapX][MapY] == REDGE) {
	219	bitindex = 0;
	220	for (z=0; z<4; z++) {
	221	bitindex = bitindex << 1;
	222	Xtem = MapX + DX[z];
	223	Ytem = MapY + DY[z];
	224	if (TestBounds(Xtem, Ytem))
	225	if ( Map[Xtem][Ytem]) bitindex++;
	226	}
	227	temp = REdTab[bitindex & 15];
	228	if ((temp != 2) && (GRand(1))) temp++;
	229	Map[MapX][MapY] = temp;
	230	}
	231	}
	232
	233	far SmoothTrees()
	234	{
	235	static int DX[4] = {-1, 0, 1, 0};
	236	static int DY[4] = { 0, 1, 0,-1};
	237	static int TEdTab[16] = {0,0,0,34,0,0,36,35,0,32,0,33,30,31,29,37};
	238	int bitindex, z,Xtem,Ytem;
	239	register int temp,MapX,MapY;
	240
	241	for (MapX = 0; MapX < WORLD_X; MapX++)
	242	for (MapY = 0; MapY < WORLD_Y; MapY++)
	243	if ((Map[MapX][MapY] & BLN) == BLN) {
	244	bitindex = 0;
	245	for (z=0; z<4; z++) {
	246	bitindex = bitindex << 1;
	247	Xtem = MapX + DX[z];
	248	Ytem = MapY + DY[z];
	249	if (TestBounds(Xtem, Ytem))
	250	if (Map[Xtem][Ytem] & BN) bitindex++;
	251
	252	}
	253	temp = TEdTab[bitindex & 15];
	254	if (temp) {
	255	if (temp != 37)
	256	if ((MapX+MapY) & 1)
	257	temp = temp-8;
	258	Map[MapX][MapY] = temp+BLN;
	259	}
	260	else Map[MapX][MapY] = temp;
	261	}
	262	}
	263
	264	near DoRivers()
	265	{
	266
	267	LastDir = GRand(3);
	268	Dir = LastDir;
	269	DoBRiv();
	270	MapX = XStart;
	271	MapY = YStart;
	272	LastDir = LastDir ^ 4;
	273	Dir = LastDir;
	274	DoBRiv();
	275	MapX = XStart;
	276	MapY = YStart;
	277	LastDir = GRand(3);
	278	DoSRiv();
	279	}
	280
	281	near DoBRiv()
	282	{
	283	int temp, count;
	284
	285	count = 0;
	286	while (TestBounds (MapX+4, MapY+4)) {
	287	BRivPlop();
	288	if (GRand(10) > 4) Dir++;
	289	if (GRand(10) > 4) Dir--;
	290	if (!(GRand(10))) Dir = LastDir;
	291	MoveMap (Dir);
	292	}
	293	}
	294
	295	near DoSRiv()
	296	{
	297	int temp;
	298
	299	while (TestBounds (MapX+3, MapY+3)) {
	300	SRivPlop();
	301	if (GRand(10) > 5) Dir++;
	302	if (GRand(10) > 5) Dir--;
	303	if (!(GRand(12))) Dir = LastDir;
	304	MoveMap (Dir);
	305	}
	306	}
	307
	308	near MoveMap (dir)
	309	int dir;
	310	{
	311	static int DirTab[2][8] ={ { 0, 1, 1, 1, 0, -1, -1, -1},
	312	{-1,-1, 0, 1, 1, 1, 0, -1} };
	313	dir = dir & 7;
	314	MapX += DirTab[0][dir];
	315	MapY += DirTab[1][dir];
	316	}
	317
	318
	319
	320
	321	near BRivPlop()
	322	{
	323	static int BRMatrix[9][9] ={
	324	{0,0,0,3,3,3,0,0,0},
	325	{0,0,3,2,2,2,3,0,0},
	326	{0,3,2,2,2,2,2,3,0},
	327	{3,2,2,2,2,2,2,2,3},
	328	{3,2,2,2,4,2,2,2,3},
	329	{3,2,2,2,2,2,2,2,3},
	330	{0,3,2,2,2,2,2,3,0},
	331	{0,0,3,2,2,2,3,0,0},
	332	{0,0,0,3,3,3,0,0,0} };
	333	int x, y;
	334
	335	for (x=0; x<9; x++)
	336	for (y=0; y<9; y++)
	337	PutOnMap (BRMatrix[y][x], x, y);
	338	}
	339
	340	near SRivPlop()
	341	{
	342	static int SRMatrix[6][6] ={
	343	{0,0,3,3,0,0},
	344	{0,3,2,2,3,0},
	345	{3,2,2,2,2,3},
	346	{3,2,2,2,2,3},
	347	{0,3,2,2,3,0},
	348	{0,0,3,3,0,0} };
	349	int x, y;
	350
	351	for (x=0; x<6; x++)
	352	for (y=0; y<6; y++)
	353	PutOnMap (SRMatrix[y][x], x, y);
	354	}
	355
	356	near PutOnMap (Mchar, Xoff, Yoff)
	357	int Mchar, Xoff, Yoff;
	358	{
	359	register int Xloc, Yloc, temp;
	360
	361	if (Mchar == 0) return;
	362	Xloc = MapX + Xoff;
	363	Yloc = MapY + Yoff;
	364	if (TestBounds (Xloc, Yloc) == FALSE) return (FALSE);
	365	if (temp = Map [Xloc][Yloc]) {
	366	temp = temp & 1023;
	367	if (temp == RIVER)
	368	if (Mchar != CHANNEL)
	369	return (FALSE);
	370	if (temp == CHANNEL) return (FALSE);
	371	}
	372	Map [Xloc][Yloc] = Mchar;
	373	}
	374
	375	far TestBounds(x, y)
	376	register int x, y;
	377	{
	378	if ((( x >= 0) && (x < WORLD_X)) && (( y >= 0) && (y < WORLD_Y)))
	379	return (TRUE);
	380	return (FALSE);
	381	}
	382
	383
	384
	385	near EGRand(limit)
	386	int limit;
	387	{
	388	int x,z;
	389
	390	z= GRand(limit);
	391	x= GRand(limit);
	392	if (z < x) return(z);
	393	return(x);
	394	}
	395
	396	#define RANMASK 32767
	397
	398	near GRand(range) /* stupid but works */
	399	int range;
	400	{
	401	register x, newv, divisor;
	402
	403	divisor = RANMASK/ (range+1);
	404	newv = 0;
	405	for (x=4; x!=0; x--)
	406	newv += (GRanArray[x] = GRanArray[x-1]);
	407	GRanArray[0] = newv;
	408	x = (newv & RANMASK) / divisor;
	409	if (x > range) return(range);
	410	return(x);
	411	}