[micropolis] / src / sim / terrain / terragen.c

/* terragen.c:  Terrain generator
 *
 * 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 */
/* modified by Paul Schmidt 10-89 to implement terrain editor quickly... - rax */

#include "..\sim\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

#define WATER_LOW	2		/* range for water */
#define WATER_HIGH	20
#define WOODS_LOW	21		/* range for woods */
#define WOODS_HIGH	39

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

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

extern int treeLevel;		/* level for tree creation (terra.c) */
extern int lakeLevel;		/* level for lake creation (terra.c) */
extern int curvLevel;		/* level for river curviness (terra.c) */

rax_ClearMap()
{
register int x, y;

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

rax_WaterEdges()		/* set water edges */
{
	register int x,y;		/* temporary counters */

	for(x=0;x < WORLD_X;x++) {
		for(y=0;y < WORLD_Y;y++) {
			if((Map[x][y]&LOMASK) >= WATER_LOW && (Map[x][y]&LOMASK) <= WATER_HIGH) {		/* if water */
				if(x > 0) {
					if((Map[x-1][y]&LOMASK) < WATER_LOW || (Map[x-1][y]&LOMASK) > WATER_HIGH) {		/* if nearest object is not water */
						goto edge;
					}
				}
				if(x < WORLD_X-1) {
					if((Map[x+1][y]&LOMASK) < WATER_LOW || (Map[x+1][y]&LOMASK) > WATER_HIGH) {		/* if nearest object is not water */
						goto edge;
					}
				}
				if(y > 0) {
					if((Map[x][y-1]&LOMASK) < WATER_LOW || (Map[x][y-1]&LOMASK) > WATER_HIGH) {		/* if nearest object is not water */
						goto edge;
					}
				}
				if(y < WORLD_Y-1) {
					if((Map[x][y+1]&LOMASK) < WATER_LOW || (Map[x][y+1]&LOMASK) > WATER_HIGH) {		/* if nearest object is not water */
edge:
						Map[x][y]=REDGE;		/* set river edge */
						continue;
					}
				}
			}
		}
	}
	for(x=0;x < WORLD_X;x++) {
		for(y=0;y < WORLD_Y;y++) {
			if((Map[x][y]&LOMASK) != CHANNEL && (Map[x][y]&LOMASK) >= WATER_LOW && (Map[x][y]&LOMASK) <= WATER_HIGH) {		/* if water which is not a channel */
				if(x > 0) {
					if((Map[x-1][y]&LOMASK) < WATER_LOW || (Map[x-1][y]&LOMASK) > WATER_HIGH) {		/* if nearest object is not water */
						continue;
					}
				}
				if(x < WORLD_X-1) {
					if((Map[x+1][y]&LOMASK) < WATER_LOW || (Map[x+1][y]&LOMASK) > WATER_HIGH) {		/* if nearest object is not water */
						continue;
					}
				}
				if(y > 0) {
					if((Map[x][y-1]&LOMASK) < WATER_LOW || (Map[x][y-1]&LOMASK) > WATER_HIGH) {		/* if nearest object is not water */
						continue;
					}
				}
				if(y < WORLD_Y-1) {
					if((Map[x][y+1]&LOMASK) < WATER_LOW || (Map[x][y+1]&LOMASK) > WATER_HIGH) {		/* if nearest object is not water */
						continue;
					}
				}
				Map[x][y]=RIVER;		/* make it a river */
			}
		}
	}
	for(x=0;x < WORLD_X;x++) {
		for(y=0;y < WORLD_Y;y++) {
			if((Map[x][y]&LOMASK) >= WOODS_LOW && (Map[x][y]&LOMASK) <= WOODS_HIGH) {		/* if woods */
				if(x > 0) {
					if(Map[x-1][y] == RIVER || Map[x-1][y] == CHANNEL) {		/* if nearest object is water */
						Map[x][y]=REDGE;		/* make it water's edge */
						continue;
					}
				}
				if(x < WORLD_X-1) {
					if(Map[x+1][y] == RIVER || Map[x+1][y] == CHANNEL) {		/* if nearest object is water */
						Map[x][y]=REDGE;		/* make it water's edge */
						continue;
					}
				}
				if(y > 0) {
					if(Map[x][y-1] == RIVER || Map[x][y-1] == CHANNEL) {		/* if nearest object is water */
						Map[x][y]=REDGE;		/* make it water's edge */
						continue;
					}
				}
				if(y < WORLD_Y-1) {
					if(Map[x][y+1] == RIVER || Map[x][y+1] == CHANNEL) {		/* if nearest object is water */
						Map[x][y]=REDGE;		/* make it water's edge */
						continue;
					}
				}
			}
		}
	}
}

#define RADIUS 18

rax_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= rax_EGRand(RADIUS);
		rax_BRivPlop();
		MapY= 90-rax_EGRand(RADIUS);
		rax_BRivPlop();
		MapY= 0;
		rax_SRivPlop();
		MapY= 94;
		rax_SRivPlop();
	}
	for (y=0; y<WORLD_Y-5; y+=2)	{
		MapY= y ;
		MapX= rax_EGRand(RADIUS);
		rax_BRivPlop();
		MapX= 110-rax_EGRand(RADIUS);
		rax_BRivPlop();
		MapX= 0;
		rax_SRivPlop();
		MapX= 114;
		rax_SRivPlop();
	}
}

rax_MakeLakes()
{
	int Lim1, Lim2, t, z;
	register int x, y;
	
/*	Lim1 = rax_GRand(10);		/**/
	Lim1=lakeLevel/2;
	for (t = 0; t < Lim1; t++)  {
		x = rax_GRand(99) + 10;
		y = rax_GRand(80) + 10;
		Lim2 = rax_GRand(12)+2;
		for (z = 0; z < Lim2; z++)  {
			MapX = x - 6 + rax_GRand(12);
			MapY = y - 6 + rax_GRand(12);
			if (rax_GRand(4))  rax_SRivPlop();
			else  rax_BRivPlop();
		}
	}
}

rax_GetRandStart()
{
	XStart = 40 + rax_GRand(40);
	YStart = 33 + rax_GRand(33);
	MapX = XStart;
	MapY = YStart;
}

rax_DoTrees()
{
	int x,xloc,yloc;

	for(x=0;x < (treeLevel*3);x++) {
		xloc=rax_GRand(119);
		yloc=rax_GRand(99);
		rax_TreeSplash(xloc,yloc);
	}
	rax_SmoothTrees();
	rax_SmoothTrees();
}

rax_TreeSplash(xloc,yloc)
int xloc,yloc;
{
	int  Dis, Dir;
	register int xoff, yoff,z;
	
	Dis = rax_GRand(100+(treeLevel*2))+50;
	MapX = xloc;
	MapY = yloc;
	for (z=0; z<Dis; z++)	{
		Dir = rax_GRand(7);
		rax_MoveMap(Dir);
		if (!(rax_TestBounds(MapX,MapY))) return;
		if (Map[MapX][MapY] == 0)  Map[MapX][MapY] = WOODS+ BLN;
	}
}
	
rax_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 (rax_TestBounds(Xtem, Ytem))
/* 					if(Map[Xtem][Ytem]) bitindex++;		/* original code */
 					if((Map[Xtem][Ytem]&LOMASK) && ((Map[Xtem][Ytem]&LOMASK) < WOODS_LOW || (Map[Xtem][Ytem]&LOMASK) > WOODS_HIGH)) bitindex++;		/* new code - rax */
 			}
 			temp = REdTab[bitindex & 15];
 			if ((temp != 2) && (rax_GRand(1))) temp++;
 			Map[MapX][MapY] = temp;
 		}
 }

IsTree(cell)		/* return TRUE or FALSE if cell value is a tree cell */
register int cell;
{
	if((cell&LOMASK) >= WOODS_LOW && (cell&LOMASK) <= WOODS_HIGH) return TRUE; else return FALSE;
}
 
rax_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 (IsTree(Map[MapX][MapY]))	{
 			bitindex = 0;
 			for (z=0; z<4; z++)	{
 				bitindex = bitindex << 1;
 				Xtem = MapX + DX[z];
 				Ytem = MapY + DY[z];
 				if (rax_TestBounds(Xtem, Ytem))		
 					if(IsTree(Map[Xtem][Ytem])) 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;
 		}
 }
 
rax_DoRivers()
{	
	LastDir = rax_GRand(3);
	Dir = LastDir;
	rax_DoBRiv();
	MapX = XStart;
	MapY = YStart;
	LastDir = LastDir ^ 4;
	Dir = LastDir;
	rax_DoBRiv();	
	MapX = XStart;
	MapY = YStart;
	LastDir = rax_GRand(3);
	rax_DoSRiv();
}

rax_DoBRiv()
{
	while(rax_TestBounds (MapX+4, MapY+4)) {
		rax_BRivPlop();
		if(rax_GRand(curvLevel+10) < 10) {
			Dir=LastDir;
		} else {
			if(rax_GRand(curvLevel+100) > 90) {
				Dir++;
			}
			if(rax_GRand(curvLevel+100) > 90) {
				Dir--;
			}
		}
		rax_MoveMap(Dir);
	}
}

rax_DoSRiv()
{
	while(rax_TestBounds (MapX+3, MapY+3)) {
		rax_SRivPlop();
		if(rax_GRand(curvLevel+10) < 10) {
			Dir=LastDir;
		} else {
			if(rax_GRand(curvLevel+100) > 90) {
				Dir++;
			}
			if(rax_GRand(curvLevel+100) > 90) {
				Dir--;
			}
		}
		rax_MoveMap(Dir);
	}
}

rax_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];
}


rax_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++)
			rax_PutOnMap (BRMatrix[y][x], x, y);
}

rax_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++)
			rax_PutOnMap (SRMatrix[y][x], x, y);
}

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

	if (Mchar == 0) return;
	Xloc = MapX + Xoff;
	Yloc = MapY + Yoff;
	if (rax_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;	
}

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


rax_EGRand(limit)
int limit;
{
	int x,z;
	
	z= rax_GRand(limit);
	x= rax_GRand(limit);
	if (z < x) return(z);
	return(x);
}

#define RANMASK 32767

rax_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
6a5fa4e0 MG	1	/* terragen.c: Terrain generator
	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	/* modified by Paul Schmidt 10-89 to implement terrain editor quickly... - rax */
65
66	#include "..\sim\sim.h"
67
68	#define TRUE 1
69	#define FALSE 0
70	#define WORLD_X 120
71	#define WORLD_Y 100
72	#define RIVER 2
73	#define REDGE 3
74	#define CHANNEL 4
75	#define WOODS 37
76	#define BL 4096
77	#define BN 8192
78	#define BLN BL+BN
79
80	#define WATER_LOW 2 /* range for water */
81	#define WATER_HIGH 20
82	#define WOODS_LOW 21 /* range for woods */
83	#define WOODS_HIGH 39
84
85	static int XStart, YStart;
86	static int Dir, LastDir;
87
88	/* trash values for GRand() */
89	static int GRanArray[5] = { 1018,4521,202,419,3 };
90
91	extern int treeLevel; /* level for tree creation (terra.c) */
92	extern int lakeLevel; /* level for lake creation (terra.c) */
93	extern int curvLevel; /* level for river curviness (terra.c) */
94
95	rax_ClearMap()
96	{
97	register int x, y;
98
99	for (x=0; x<WORLD_X; x++)
100	for (y=0; y<WORLD_Y; y++)
101	Map[x][y] = 0;
102	}
103
104	rax_WaterEdges() /* set water edges */
105	{
106	register int x,y; /* temporary counters */
107
108	for(x=0;x < WORLD_X;x++) {
109	for(y=0;y < WORLD_Y;y++) {
110	if((Map[x][y]&LOMASK) >= WATER_LOW && (Map[x][y]&LOMASK) <= WATER_HIGH) { /* if water */
111	if(x > 0) {
112	if((Map[x-1][y]&LOMASK) < WATER_LOW \|\| (Map[x-1][y]&LOMASK) > WATER_HIGH) { /* if nearest object is not water */
113	goto edge;
114	}
115	}
116	if(x < WORLD_X-1) {
117	if((Map[x+1][y]&LOMASK) < WATER_LOW \|\| (Map[x+1][y]&LOMASK) > WATER_HIGH) { /* if nearest object is not water */
118	goto edge;
119	}
120	}
121	if(y > 0) {
122	if((Map[x][y-1]&LOMASK) < WATER_LOW \|\| (Map[x][y-1]&LOMASK) > WATER_HIGH) { /* if nearest object is not water */
123	goto edge;
124	}
125	}
126	if(y < WORLD_Y-1) {
127	if((Map[x][y+1]&LOMASK) < WATER_LOW \|\| (Map[x][y+1]&LOMASK) > WATER_HIGH) { /* if nearest object is not water */
128	edge:
129	Map[x][y]=REDGE; /* set river edge */
130	continue;
131	}
132	}
133	}
134	}
135	}
136	for(x=0;x < WORLD_X;x++) {
137	for(y=0;y < WORLD_Y;y++) {
138	if((Map[x][y]&LOMASK) != CHANNEL && (Map[x][y]&LOMASK) >= WATER_LOW && (Map[x][y]&LOMASK) <= WATER_HIGH) { /* if water which is not a channel */
139	if(x > 0) {
140	if((Map[x-1][y]&LOMASK) < WATER_LOW \|\| (Map[x-1][y]&LOMASK) > WATER_HIGH) { /* if nearest object is not water */
141	continue;
142	}
143	}
144	if(x < WORLD_X-1) {
145	if((Map[x+1][y]&LOMASK) < WATER_LOW \|\| (Map[x+1][y]&LOMASK) > WATER_HIGH) { /* if nearest object is not water */
146	continue;
147	}
148	}
149	if(y > 0) {
150	if((Map[x][y-1]&LOMASK) < WATER_LOW \|\| (Map[x][y-1]&LOMASK) > WATER_HIGH) { /* if nearest object is not water */
151	continue;
152	}
153	}
154	if(y < WORLD_Y-1) {
155	if((Map[x][y+1]&LOMASK) < WATER_LOW \|\| (Map[x][y+1]&LOMASK) > WATER_HIGH) { /* if nearest object is not water */
156	continue;
157	}
158	}
159	Map[x][y]=RIVER; /* make it a river */
160	}
161	}
162	}
163	for(x=0;x < WORLD_X;x++) {
164	for(y=0;y < WORLD_Y;y++) {
165	if((Map[x][y]&LOMASK) >= WOODS_LOW && (Map[x][y]&LOMASK) <= WOODS_HIGH) { /* if woods */
166	if(x > 0) {
167	if(Map[x-1][y] == RIVER \|\| Map[x-1][y] == CHANNEL) { /* if nearest object is water */
168	Map[x][y]=REDGE; /* make it water's edge */
169	continue;
170	}
171	}
172	if(x < WORLD_X-1) {
173	if(Map[x+1][y] == RIVER \|\| Map[x+1][y] == CHANNEL) { /* if nearest object is water */
174	Map[x][y]=REDGE; /* make it water's edge */
175	continue;
176	}
177	}
178	if(y > 0) {
179	if(Map[x][y-1] == RIVER \|\| Map[x][y-1] == CHANNEL) { /* if nearest object is water */
180	Map[x][y]=REDGE; /* make it water's edge */
181	continue;
182	}
183	}
184	if(y < WORLD_Y-1) {
185	if(Map[x][y+1] == RIVER \|\| Map[x][y+1] == CHANNEL) { /* if nearest object is water */
186	Map[x][y]=REDGE; /* make it water's edge */
187	continue;
188	}
189	}
190	}
191	}
192	}
193	}
194
195	#define RADIUS 18
196
197	rax_MakeIsland()
198	{
199	register int x,y,z;
200
201	for (x=0; x<WORLD_X; x++)
202	for (y=0; y<WORLD_Y; y++)
203	Map[x][y] = RIVER;
204	for (x=5; x<WORLD_X-5; x++)
205	for (y=5; y<WORLD_Y-5; y++)
206	Map[x][y] = 0;
207	for (x=0; x<WORLD_X-5; x+=2) {
208	MapX= x ;
209	MapY= rax_EGRand(RADIUS);
210	rax_BRivPlop();
211	MapY= 90-rax_EGRand(RADIUS);
212	rax_BRivPlop();
213	MapY= 0;
214	rax_SRivPlop();
215	MapY= 94;
216	rax_SRivPlop();
217	}
218	for (y=0; y<WORLD_Y-5; y+=2) {
219	MapY= y ;
220	MapX= rax_EGRand(RADIUS);
221	rax_BRivPlop();
222	MapX= 110-rax_EGRand(RADIUS);
223	rax_BRivPlop();
224	MapX= 0;
225	rax_SRivPlop();
226	MapX= 114;
227	rax_SRivPlop();
228	}
229	}
230
231	rax_MakeLakes()
232	{
233	int Lim1, Lim2, t, z;
234	register int x, y;
235
236	/* Lim1 = rax_GRand(10); /**/
237	Lim1=lakeLevel/2;
238	for (t = 0; t < Lim1; t++) {
239	x = rax_GRand(99) + 10;
240	y = rax_GRand(80) + 10;
241	Lim2 = rax_GRand(12)+2;
242	for (z = 0; z < Lim2; z++) {
243	MapX = x - 6 + rax_GRand(12);
244	MapY = y - 6 + rax_GRand(12);
245	if (rax_GRand(4)) rax_SRivPlop();
246	else rax_BRivPlop();
247	}
248	}
249	}
250
251	rax_GetRandStart()
252	{
253	XStart = 40 + rax_GRand(40);
254	YStart = 33 + rax_GRand(33);
255	MapX = XStart;
256	MapY = YStart;
257	}
258
259	rax_DoTrees()
260	{
261	int x,xloc,yloc;
262
263	for(x=0;x < (treeLevel*3);x++) {
264	xloc=rax_GRand(119);
265	yloc=rax_GRand(99);
266	rax_TreeSplash(xloc,yloc);
267	}
268	rax_SmoothTrees();
269	rax_SmoothTrees();
270	}
271
272	rax_TreeSplash(xloc,yloc)
273	int xloc,yloc;
274	{
275	int Dis, Dir;
276	register int xoff, yoff,z;
277
278	Dis = rax_GRand(100+(treeLevel*2))+50;
279	MapX = xloc;
280	MapY = yloc;
281	for (z=0; z<Dis; z++) {
282	Dir = rax_GRand(7);
283	rax_MoveMap(Dir);
284	if (!(rax_TestBounds(MapX,MapY))) return;
285	if (Map[MapX][MapY] == 0) Map[MapX][MapY] = WOODS+ BLN;
286	}
287	}
288
289	rax_SmoothRiver()
290	{
291	static int DX[4] = {-1, 0, 1, 0};
292	static int DY[4] = { 0, 1, 0,-1};
293	static int REdTab[16] = { 13+BL,13+BL,17+BL,15+BL,5+BL,2,19+BL,
294	17+BL,9+BL,11+BL,2,13+BL,7+BL,9+BL,5+BL,2};
295	int bitindex, z,Xtem,Ytem;
296	register int temp,MapX,MapY;
297
298	for (MapX = 0; MapX < WORLD_X; MapX++)
299	for (MapY = 0; MapY < WORLD_Y; MapY++)
300	if (Map[MapX][MapY] == REDGE) {
301	bitindex = 0;
302	for (z=0; z<4; z++) {
303	bitindex = bitindex << 1;
304	Xtem = MapX + DX[z];
305	Ytem = MapY + DY[z];
306	if (rax_TestBounds(Xtem, Ytem))
307	/* if(Map[Xtem][Ytem]) bitindex++; /* original code */
308	if((Map[Xtem][Ytem]&LOMASK) && ((Map[Xtem][Ytem]&LOMASK) < WOODS_LOW \|\| (Map[Xtem][Ytem]&LOMASK) > WOODS_HIGH)) bitindex++; /* new code - rax */
309	}
310	temp = REdTab[bitindex & 15];
311	if ((temp != 2) && (rax_GRand(1))) temp++;
312	Map[MapX][MapY] = temp;
313	}
314	}
315
316	IsTree(cell) /* return TRUE or FALSE if cell value is a tree cell */
317	register int cell;
318	{
319	if((cell&LOMASK) >= WOODS_LOW && (cell&LOMASK) <= WOODS_HIGH) return TRUE; else return FALSE;
320	}
321
322	rax_SmoothTrees()
323	{
324	static int DX[4] = {-1, 0, 1, 0};
325	static int DY[4] = { 0, 1, 0,-1};
326	static int TEdTab[16] = {0,0,0,34,0,0,36,35,0,32,0,33,30,31,29,37};
327	int bitindex, z,Xtem,Ytem;
328	register int temp,MapX,MapY;
329
330	for (MapX = 0; MapX < WORLD_X; MapX++)
331	for (MapY = 0; MapY < WORLD_Y; MapY++)
332	if (IsTree(Map[MapX][MapY])) {
333	bitindex = 0;
334	for (z=0; z<4; z++) {
335	bitindex = bitindex << 1;
336	Xtem = MapX + DX[z];
337	Ytem = MapY + DY[z];
338	if (rax_TestBounds(Xtem, Ytem))
339	if(IsTree(Map[Xtem][Ytem])) bitindex++;
340
341	}
342	temp = TEdTab[bitindex & 15];
343	if (temp) {
344	if (temp != 37)
345	if ((MapX+MapY) & 1)
346	temp = temp-8;
347	Map[MapX][MapY] = temp+BLN;
348	}
349	else Map[MapX][MapY] = temp;
350	}
351	}
352
353	rax_DoRivers()
354	{
355	LastDir = rax_GRand(3);
356	Dir = LastDir;
357	rax_DoBRiv();
358	MapX = XStart;
359	MapY = YStart;
360	LastDir = LastDir ^ 4;
361	Dir = LastDir;
362	rax_DoBRiv();
363	MapX = XStart;
364	MapY = YStart;
365	LastDir = rax_GRand(3);
366	rax_DoSRiv();
367	}
368
369	rax_DoBRiv()
370	{
371	while(rax_TestBounds (MapX+4, MapY+4)) {
372	rax_BRivPlop();
373	if(rax_GRand(curvLevel+10) < 10) {
374	Dir=LastDir;
375	} else {
376	if(rax_GRand(curvLevel+100) > 90) {
377	Dir++;
378	}
379	if(rax_GRand(curvLevel+100) > 90) {
380	Dir--;
381	}
382	}
383	rax_MoveMap(Dir);
384	}
385	}
386
387	rax_DoSRiv()
388	{
389	while(rax_TestBounds (MapX+3, MapY+3)) {
390	rax_SRivPlop();
391	if(rax_GRand(curvLevel+10) < 10) {
392	Dir=LastDir;
393	} else {
394	if(rax_GRand(curvLevel+100) > 90) {
395	Dir++;
396	}
397	if(rax_GRand(curvLevel+100) > 90) {
398	Dir--;
399	}
400	}
401	rax_MoveMap(Dir);
402	}
403	}
404
405	rax_MoveMap (dir)
406	int dir;
407	{
408	static int DirTab[2][8] ={ { 0, 1, 1, 1, 0, -1, -1, -1},
409	{-1,-1, 0, 1, 1, 1, 0, -1} };
410	dir = dir & 7;
411	MapX += DirTab[0][dir];
412	MapY += DirTab[1][dir];
413	}
414
415
416
417
418	rax_BRivPlop()
419	{
420	static int BRMatrix[9][9] ={
421	{0,0,0,3,3,3,0,0,0},
422	{0,0,3,2,2,2,3,0,0},
423	{0,3,2,2,2,2,2,3,0},
424	{3,2,2,2,2,2,2,2,3},
425	{3,2,2,2,4,2,2,2,3},
426	{3,2,2,2,2,2,2,2,3},
427	{0,3,2,2,2,2,2,3,0},
428	{0,0,3,2,2,2,3,0,0},
429	{0,0,0,3,3,3,0,0,0} };
430	int x, y;
431
432	for (x=0; x<9; x++)
433	for (y=0; y<9; y++)
434	rax_PutOnMap (BRMatrix[y][x], x, y);
435	}
436
437	rax_SRivPlop()
438	{
439	static int SRMatrix[6][6] ={
440	{0,0,3,3,0,0},
441	{0,3,2,2,3,0},
442	{3,2,2,2,2,3},
443	{3,2,2,2,2,3},
444	{0,3,2,2,3,0},
445	{0,0,3,3,0,0} };
446	int x, y;
447
448	for (x=0; x<6; x++)
449	for (y=0; y<6; y++)
450	rax_PutOnMap (SRMatrix[y][x], x, y);
451	}
452
453	rax_PutOnMap (Mchar, Xoff, Yoff)
454	int Mchar, Xoff, Yoff;
455	{
456	register int Xloc, Yloc, temp;
457
458	if (Mchar == 0) return;
459	Xloc = MapX + Xoff;
460	Yloc = MapY + Yoff;
461	if (rax_TestBounds (Xloc, Yloc) == FALSE) return (FALSE);
462	if (temp = Map [Xloc][Yloc]) {
463	temp = temp & 1023;
464	if (temp == RIVER)
465	if (Mchar != CHANNEL)
466	return (FALSE);
467	if (temp == CHANNEL) return (FALSE);
468	}
469	Map [Xloc][Yloc] = Mchar;
470	}
471
472	rax_TestBounds(x, y)
473	register int x, y;
474	{
475	if ((( x >= 0) && (x < WORLD_X)) && (( y >= 0) && (y < WORLD_Y)))
476	return (TRUE);
477	return (FALSE);
478	}
479
480
481
482	rax_EGRand(limit)
483	int limit;
484	{
485	int x,z;
486
487	z= rax_GRand(limit);
488	x= rax_GRand(limit);
489	if (z < x) return(z);
490	return(x);
491	}
492
493	#define RANMASK 32767
494
495	rax_GRand(range) /* stupid but works */
496	int range;
497	{
498	register x, newv, divisor;
499
500	divisor = RANMASK/ (range+1);
501	newv = 0;
502	for (x=4; x!=0; x--)
503	newv += (GRanArray[x] = GRanArray[x-1]);
504	GRanArray[0] = newv;
505	x = (newv & RANMASK) / divisor;
506	if (x > range) return(range);
507	return(x);
508	}