git.zerfleddert.de Git - micropolis/blame_incremental - 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
	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