[micropolis] / src / sim / s_traf.c

/* s_traf.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.
 */
#include "sim.h"


/* Traffic Generation */


#define MAXDIS 30

short PosStackN, SMapXStack[MAXDIS+1], SMapYStack[MAXDIS+1];
short LDir;
short Zsource;
short TrafMaxX, TrafMaxY;


/* comefrom: DoIndustrial DoCommercial DoResidential */
MakeTraf(int Zt)
{
  short xtem, ytem;

  xtem = SMapX;
  ytem = SMapY;
  Zsource = Zt;
  PosStackN = 0;

#if 0
  if ((!Rand(2)) && FindPTele()) {
/* printf("Telecommute!\n"); */
    return (TRUE);
  }
#endif

  if (FindPRoad()) {		/* look for road on zone perimeter */
    if (TryDrive()) {		/* attempt to drive somewhere */
      SetTrafMem();		/* if sucessful, inc trafdensity */
      SMapX = xtem;
      SMapY = ytem;
      return (TRUE);		/* traffic passed */
    }
    SMapX = xtem;
    SMapY = ytem;
    return (FALSE);		/* traffic failed */
  }
  else return (-1);		/* no road found */
}


/* comefrom: MakeTraf */
SetTrafMem(void)
{
  register short x, z;

  for (x = PosStackN; x > 0; x--) {
    PullPos();
    if (TestBounds(SMapX, SMapY)) {
      z = Map[SMapX][SMapY] & LOMASK;
      if ((z >= ROADBASE) && (z < POWERBASE)) {
	SimSprite *sprite;

	/* check for rail */
	z = TrfDensity[SMapX >>1][SMapY >>1];
	z += 50;
	if ((z > 240) &&
	    (!Rand(5))) {
	  z = 240;
	  TrafMaxX = SMapX <<4;
	  TrafMaxY = SMapY <<4;
	  if (((sprite = GetSprite(COP)) != NULL) &&
	      (sprite->control == -1)) {
	    sprite->dest_x = TrafMaxX;
	    sprite->dest_y = TrafMaxY;
	  }
	}
	TrfDensity[SMapX >>1][SMapY >>1] = z;
      }
    }
  }
}


/* comefrom: TryGo */
PushPos(void)
{
  PosStackN++;
  SMapXStack[PosStackN] = SMapX;
  SMapYStack[PosStackN] = SMapY;
}


/* comefrom: SetTrafMem */
PullPos(void)
{
  SMapX = SMapXStack[PosStackN];
  SMapY = SMapYStack[PosStackN];
  PosStackN--;
}


/* comefrom: DoSPZone MakeTraf */
FindPRoad(void)		/* look for road on edges of zone   */
{
  static short PerimX[12] = {-1, 0, 1, 2, 2, 2, 1, 0,-1,-2,-2,-2};
  static short PerimY[12] = {-2,-2,-2,-1, 0, 1, 2, 2, 2, 1, 0,-1};
  register short tx, ty, z;

  for (z = 0; z < 12; z++) {
	  tx = SMapX + PerimX[z];
	  ty = SMapY + PerimY[z];
	  if (TestBounds(tx, ty)) {
		  if (RoadTest(Map[tx][ty])) {
			  SMapX = tx;
			  SMapY = ty;
			  return (TRUE);
		  }
	  }
  }
  return (FALSE);
}


FindPTele(void)		/* look for telecommunication on edges of zone */
{
  static short PerimX[12] = {-1, 0, 1, 2, 2, 2, 1, 0,-1,-2,-2,-2};
  static short PerimY[12] = {-2,-2,-2,-1, 0, 1, 2, 2, 2, 1, 0,-1};
  register short tx, ty, z, tile;

  for (z = 0; z < 12; z++) {
	  tx = SMapX + PerimX[z];
	  ty = SMapY + PerimY[z];
	  if (TestBounds(tx, ty)) {
	  	  tile = Map[tx][ty] & LOMASK;
		  if ((tile >= TELEBASE) && (tile <= TELELAST)) {
			  return (TRUE);
		  }
	  }
  }
  return (FALSE);
}


/* comefrom: MakeTraf */
TryDrive(void)
{
  short z;

  LDir = 5;
  for (z = 0; z < MAXDIS; z++) {	/* Maximum distance to try */
    if (TryGo(z)) {			/* if it got a road */
      if (DriveDone())			/* if destination is reached */
	return (TRUE);			/* pass */
    } else {
      if (PosStackN) {			/* deadend , backup */
	PosStackN--;
	z += 3;
      }
      else return (FALSE);		/* give up at start  */	
    }
  }
  return (FALSE);			/* gone maxdis */
}


/* comefrom: TryDrive */
TryGo(int z)
{
  short x, rdir, realdir;

#if 0
  rdir = Rand(3); /* XXX: Heaviest user of Rand */
#else
  rdir = Rand16() & 3;
#endif
  for (x = rdir; x < (rdir + 4); x++) {	/* for the 4 directions */
    realdir = x & 3;
    if (realdir == LDir) continue;	/* skip last direction */
    if (RoadTest(GetFromMap(realdir))) {
      MoveMapSim(realdir);
      LDir = (realdir + 2) & 3;
      if (z & 1)			/* save pos every other move */
	PushPos();
      return (TRUE);
    }
  }
  return (FALSE);
}


/* comefrom: TryGo DriveDone */
GetFromMap(int x)
{
  switch (x) {
  case 0:
    if (SMapY > 0)
      return (Map[SMapX][SMapY - 1] & LOMASK);
    return (FALSE);
  case 1:
    if (SMapX < (WORLD_X - 1))
      return (Map[SMapX + 1][SMapY] & LOMASK);
    return (FALSE);
  case 2:
    if (SMapY < (WORLD_Y - 1))
      return (Map[SMapX][SMapY + 1] & LOMASK);
    return (FALSE);
  case 3:
    if (SMapX > 0)
      return (Map[SMapX - 1][SMapY] & LOMASK);
    return (FALSE);
  default: 
    return (FALSE);
  }
}


/* comefrom: TryDrive */
DriveDone(void)
{
  static short TARGL[3] = {COMBASE, LHTHR, LHTHR};
  static short TARGH[3] = {NUCLEAR, PORT, COMBASE};	/* for destinations */
  register short x, z, l, h;

/* unwound -Don */
#if 0
  for (x = 0; x < 4; x++) {	/* R>C C>I I>R  */
    z = GetFromMap(x);
    if ((z >= TARGL[Zsource]) && (z <= TARGH[Zsource]))
      return (TRUE);
  }
#else
  l = TARGL[Zsource];
  h = TARGH[Zsource];

  if (SMapY > 0) {
    z = Map[SMapX][SMapY - 1] & LOMASK;
    if ((z >= l) && (z <= h))
      return (TRUE);
  }
  if (SMapX < (WORLD_X - 1)) {
    z = Map[SMapX + 1][SMapY] & LOMASK;
    if ((z >= l) && (z <= h))
      return (TRUE);
  }
  if (SMapY < (WORLD_Y - 1)) {
    z = Map[SMapX][SMapY + 1] & LOMASK;
    if ((z >= l) && (z <= h))
      return (TRUE);
  }
  if (SMapX > 0) {
    z = Map[SMapX - 1][SMapY] & LOMASK;
    if ((z >= l) && (z <= h))
      return (TRUE);
  }
#endif

  return (FALSE);
}


/* comefrom: TryGo FindPRoad */
RoadTest(int x)
{
  x = x & LOMASK;
  if (x < ROADBASE)
    return (FALSE);
  if (x > LASTRAIL)
    return (FALSE);
  if ((x >= POWERBASE) && (x < RAILHPOWERV))
    return (FALSE);
  return (TRUE);
}
Commit	Line	Data
6a5fa4e0 MG	1	/* s_traf.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	#include "sim.h"
	63
	64
65	/* Traffic Generation */
66
67
68	#define MAXDIS 30
69
70	short PosStackN, SMapXStack[MAXDIS+1], SMapYStack[MAXDIS+1];
71	short LDir;
72	short Zsource;
73	short TrafMaxX, TrafMaxY;
74
75
76	/* comefrom: DoIndustrial DoCommercial DoResidential */
77	MakeTraf(int Zt)
78	{
79	short xtem, ytem;
80
81	xtem = SMapX;
82	ytem = SMapY;
83	Zsource = Zt;
84	PosStackN = 0;
85
86	#if 0
87	if ((!Rand(2)) && FindPTele()) {
88	/* printf("Telecommute!\n"); */
89	return (TRUE);
90	}
91	#endif
92
93	if (FindPRoad()) { /* look for road on zone perimeter */
94	if (TryDrive()) { /* attempt to drive somewhere */
95	SetTrafMem(); /* if sucessful, inc trafdensity */
96	SMapX = xtem;
97	SMapY = ytem;
98	return (TRUE); /* traffic passed */
99	}
100	SMapX = xtem;
101	SMapY = ytem;
102	return (FALSE); /* traffic failed */
103	}
104	else return (-1); /* no road found */
105	}
106
107
108	/* comefrom: MakeTraf */
109	SetTrafMem(void)
110	{
111	register short x, z;
112
113	for (x = PosStackN; x > 0; x--) {
114	PullPos();
115	if (TestBounds(SMapX, SMapY)) {
116	z = Map[SMapX][SMapY] & LOMASK;
117	if ((z >= ROADBASE) && (z < POWERBASE)) {
118	SimSprite *sprite;
119
120	/* check for rail */
121	z = TrfDensity[SMapX >>1][SMapY >>1];
122	z += 50;
123	if ((z > 240) &&
124	(!Rand(5))) {
125	z = 240;
126	TrafMaxX = SMapX <<4;
127	TrafMaxY = SMapY <<4;
128	if (((sprite = GetSprite(COP)) != NULL) &&
129	(sprite->control == -1)) {
130	sprite->dest_x = TrafMaxX;
131	sprite->dest_y = TrafMaxY;
132	}
133	}
134	TrfDensity[SMapX >>1][SMapY >>1] = z;
135	}
136	}
137	}
138	}
139
140
141	/* comefrom: TryGo */
142	PushPos(void)
143	{
144	PosStackN++;
145	SMapXStack[PosStackN] = SMapX;
146	SMapYStack[PosStackN] = SMapY;
147	}
148
149
150	/* comefrom: SetTrafMem */
151	PullPos(void)
152	{
153	SMapX = SMapXStack[PosStackN];
154	SMapY = SMapYStack[PosStackN];
155	PosStackN--;
156	}
157
158
159	/* comefrom: DoSPZone MakeTraf */
160	FindPRoad(void) /* look for road on edges of zone */
161	{
162	static short PerimX[12] = {-1, 0, 1, 2, 2, 2, 1, 0,-1,-2,-2,-2};
163	static short PerimY[12] = {-2,-2,-2,-1, 0, 1, 2, 2, 2, 1, 0,-1};
164	register short tx, ty, z;
165
166	for (z = 0; z < 12; z++) {
167	tx = SMapX + PerimX[z];
168	ty = SMapY + PerimY[z];
169	if (TestBounds(tx, ty)) {
170	if (RoadTest(Map[tx][ty])) {
171	SMapX = tx;
172	SMapY = ty;
173	return (TRUE);
174	}
175	}
176	}
177	return (FALSE);
178	}
179
180
181	FindPTele(void) /* look for telecommunication on edges of zone */
182	{
183	static short PerimX[12] = {-1, 0, 1, 2, 2, 2, 1, 0,-1,-2,-2,-2};
184	static short PerimY[12] = {-2,-2,-2,-1, 0, 1, 2, 2, 2, 1, 0,-1};
185	register short tx, ty, z, tile;
186
187	for (z = 0; z < 12; z++) {
188	tx = SMapX + PerimX[z];
189	ty = SMapY + PerimY[z];
190	if (TestBounds(tx, ty)) {
191	tile = Map[tx][ty] & LOMASK;
192	if ((tile >= TELEBASE) && (tile <= TELELAST)) {
193	return (TRUE);
194	}
195	}
196	}
197	return (FALSE);
198	}
199
200
201	/* comefrom: MakeTraf */
202	TryDrive(void)
203	{
204	short z;
205
206	LDir = 5;
207	for (z = 0; z < MAXDIS; z++) { /* Maximum distance to try */
208	if (TryGo(z)) { /* if it got a road */
209	if (DriveDone()) /* if destination is reached */
210	return (TRUE); /* pass */
211	} else {
212	if (PosStackN) { /* deadend , backup */
213	PosStackN--;
214	z += 3;
215	}
216	else return (FALSE); /* give up at start */
217	}
218	}
219	return (FALSE); /* gone maxdis */
220	}
221
222
223	/* comefrom: TryDrive */
224	TryGo(int z)
225	{
226	short x, rdir, realdir;
227
228	#if 0
229	rdir = Rand(3); /* XXX: Heaviest user of Rand */
230	#else
231	rdir = Rand16() & 3;
232	#endif
233	for (x = rdir; x < (rdir + 4); x++) { /* for the 4 directions */
234	realdir = x & 3;
235	if (realdir == LDir) continue; /* skip last direction */
236	if (RoadTest(GetFromMap(realdir))) {
237	MoveMapSim(realdir);
238	LDir = (realdir + 2) & 3;
239	if (z & 1) /* save pos every other move */
240	PushPos();
241	return (TRUE);
242	}
243	}
244	return (FALSE);
245	}
246
247
248	/* comefrom: TryGo DriveDone */
249	GetFromMap(int x)
250	{
251	switch (x) {
252	case 0:
253	if (SMapY > 0)
254	return (Map[SMapX][SMapY - 1] & LOMASK);
255	return (FALSE);
256	case 1:
257	if (SMapX < (WORLD_X - 1))
258	return (Map[SMapX + 1][SMapY] & LOMASK);
259	return (FALSE);
260	case 2:
261	if (SMapY < (WORLD_Y - 1))
262	return (Map[SMapX][SMapY + 1] & LOMASK);
263	return (FALSE);
264	case 3:
265	if (SMapX > 0)
266	return (Map[SMapX - 1][SMapY] & LOMASK);
267	return (FALSE);
268	default:
269	return (FALSE);
270	}
271	}
272
273
274	/* comefrom: TryDrive */
275	DriveDone(void)
276	{
277	static short TARGL[3] = {COMBASE, LHTHR, LHTHR};
278	static short TARGH[3] = {NUCLEAR, PORT, COMBASE}; /* for destinations */
279	register short x, z, l, h;
280
281	/* unwound -Don */
282	#if 0
283	for (x = 0; x < 4; x++) { /* R>C C>I I>R */
284	z = GetFromMap(x);
285	if ((z >= TARGL[Zsource]) && (z <= TARGH[Zsource]))
286	return (TRUE);
287	}
288	#else
289	l = TARGL[Zsource];
290	h = TARGH[Zsource];
291
292	if (SMapY > 0) {
293	z = Map[SMapX][SMapY - 1] & LOMASK;
294	if ((z >= l) && (z <= h))
295	return (TRUE);
296	}
297	if (SMapX < (WORLD_X - 1)) {
298	z = Map[SMapX + 1][SMapY] & LOMASK;
299	if ((z >= l) && (z <= h))
300	return (TRUE);
301	}
302	if (SMapY < (WORLD_Y - 1)) {
303	z = Map[SMapX][SMapY + 1] & LOMASK;
304	if ((z >= l) && (z <= h))
305	return (TRUE);
306	}
307	if (SMapX > 0) {
308	z = Map[SMapX - 1][SMapY] & LOMASK;
309	if ((z >= l) && (z <= h))
310	return (TRUE);
311	}
312	#endif
313
314	return (FALSE);
315	}
316
317
318	/* comefrom: TryGo FindPRoad */
319	RoadTest(int x)
320	{
321	x = x & LOMASK;
322	if (x < ROADBASE)
323	return (FALSE);
324	if (x > LASTRAIL)
325	return (FALSE);
326	if ((x >= POWERBASE) && (x < RAILHPOWERV))
327	return (FALSE);
328	return (TRUE);
329	}
330