[micropolis] / src / sim / s_zone.c

/* s_zone.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"


/* Zone Stuff */

void ZonePlop (int base);
void IndPlop (int Den, int Value);
void ComPlop (int Den, int Value);
void ResPlop (int Den, int Value);
int EvalLot (int x, int y);
void BuildHouse(int value);
void DoIndOut(int pop, int value);
void DoComOut(int pop, int value);
void DoResOut(int pop, int value);
void IncROG(int amount);
void DoIndIn(int pop, int value);
void DoComIn(int pop, int value);
void DoResIn(int pop, int value);
void MakeHosp(void);
void DoResidential(int ZonePwrFlg);
int EvalRes (int traf);
int EvalCom (int traf);
int GetCRVal(void);
void DoCommercial(int ZonePwrFlg);
void DoIndustrial(int ZonePwrFlg);
int EvalInd (int traf);
void DoHospChur(void);


void DoZone(void)
{
  short ZonePwrFlg;

  ZonePwrFlg = SetZPower();	/* Set Power Bit in Map from PowerMap */
  if (ZonePwrFlg) PwrdZCnt++;
  else unPwrdZCnt++;

  if (CChr9 > PORTBASE) {	/* do Special Zones  */
    DoSPZone(ZonePwrFlg);
    return;
  }
  if (CChr9 < HOSPITAL) {	
    DoResidential(ZonePwrFlg);
    return;
  }
  if (CChr9 < COMBASE) {
    DoHospChur();
    return;
  }
  if (CChr9 < INDBASE)  {
    DoCommercial(ZonePwrFlg);
    return;
  }
  DoIndustrial(ZonePwrFlg);
  return;
}


void
DoHospChur(void)
{
  if (CChr9 == HOSPITAL) {
    HospPop++;
    if (!(CityTime & 15)) RepairZone (HOSPITAL, 3); /*post*/
    if (NeedHosp == -1)
      if (!Rand(20))
	ZonePlop(RESBASE);
  }
  if (CChr9 == CHURCH) {
    ChurchPop++;
    if (!(CityTime & 15)) RepairZone (CHURCH, 3); /*post*/
    if (NeedChurch == -1)
      if (!Rand(20))
	ZonePlop(RESBASE);
  }
}


#define T 1
#define F 0
#define ASCBIT (ANIMBIT | CONDBIT | BURNBIT)
#define REGBIT (CONDBIT | BURNBIT)

void
SetSmoke(int ZonePower)
{
  static short AniThis[8] = {    T,    F,    T,    T,    F,    F,    T,    T };
  static short DX1[8]	  = {   -1,    0,    1,    0,    0,    0,    0,    1 };
  static short DY1[8]	  = {   -1,    0,   -1,   -1,    0,    0,   -1,   -1 };
#if 0
  static short DX2[8]	  = {   -1,    0,    1,    1,    0,    0,    1,    1 };
  static short DY2[8]	  = {   -1,    0,    0,   -1,    0,    0,   -1,    0 };
#endif
  static short AniTabA[8] = {    0,    0,   32,   40,    0,    0,   48,   56 };
  static short AniTabB[8] = {    0,    0,   36,   44,    0,    0,   52,   60 };
  static short AniTabC[8] = { IND1,    0, IND2, IND4,    0,    0, IND6, IND8 };
  static short AniTabD[8] = { IND1,    0, IND3, IND5,    0,    0, IND7, IND9 };
  register short z;

  if (CChr9 < IZB) return;
  z = (CChr9 - IZB) >>3;
  z = z & 7;
  if (AniThis[z]) {
    int xx = SMapX + DX1[z];
    int yy = SMapY + DY1[z];
    if (TestBounds(xx, yy)) {
      if (ZonePower) {
	if ((Map[xx][yy] & LOMASK) == AniTabC[z]) {
	  Map[xx][yy] =
	    ASCBIT | (SMOKEBASE + AniTabA[z]);
	  Map[xx][yy] =
	    ASCBIT | (SMOKEBASE + AniTabB[z]);
	}
      } else {
	if ((Map[xx][yy] & LOMASK) > AniTabC[z]) {
	  Map[xx][yy] =
	    REGBIT | AniTabC[z];
	  Map[xx][yy] =
	    REGBIT | AniTabD[z];
	}
      }
    }
  }
}


void
DoIndustrial(int ZonePwrFlg)
{
  short tpop, zscore, TrfGood;

  IndZPop++;
  SetSmoke(ZonePwrFlg);
  tpop = IZPop(CChr9);
  IndPop += tpop;
  if (tpop > Rand(5)) TrfGood = MakeTraf(2);
  else TrfGood = TRUE;

  if (TrfGood == -1) {
    DoIndOut(tpop, Rand16() & 1);
    return;
  }

  if (!(Rand16() & 7)) {
    zscore = IValve + EvalInd(TrfGood);
    if (!ZonePwrFlg) zscore = -500;
    if ((zscore > -350) &&
	(((short)(zscore - 26380)) > ((short)Rand16Signed()))) {
      DoIndIn(tpop, Rand16() & 1);
      return;
    }
    if ((zscore < 350) &&
	(((short)(zscore + 26380)) < ((short)Rand16Signed())))
      DoIndOut(tpop, Rand16() & 1);
  }
}


void
DoCommercial(int ZonePwrFlg)
{
  register short tpop, TrfGood;
  short zscore, locvalve,value;

  ComZPop++;
  tpop = CZPop(CChr9);
  ComPop += tpop;
  if (tpop > Rand(5)) TrfGood = MakeTraf(1);
  else TrfGood = TRUE;

  if (TrfGood == -1) {
    value = GetCRVal();
    DoComOut(tpop, value);
    return;
  }

  if (!(Rand16() & 7)) {
    locvalve = EvalCom(TrfGood);
    zscore = CValve + locvalve;
    if (!ZonePwrFlg) zscore = -500;

    if (TrfGood &&
	(zscore > -350) &&
	(((short)(zscore - 26380)) > ((short)Rand16Signed()))) {
      value = GetCRVal();
      DoComIn(tpop, value);
      return;
    }
    if ((zscore < 350) &&
	(((short)(zscore + 26380)) < ((short)Rand16Signed()))) {
      value = GetCRVal();
      DoComOut(tpop, value);
    }
  }
}


void
DoResidential(int ZonePwrFlg)
{
  short tpop, zscore, locvalve, value, TrfGood;

  ResZPop++;
  if (CChr9 == FREEZ) tpop = DoFreePop();
  else tpop = RZPop(CChr9);

  ResPop += tpop;
  if (tpop > Rand(35)) TrfGood = MakeTraf(0);
  else TrfGood = TRUE;

  if (TrfGood == -1) {
    value = GetCRVal();
    DoResOut(tpop, value);
    return;
  }

  if ((CChr9 == FREEZ) || (!(Rand16() & 7))) {
    locvalve = EvalRes(TrfGood);
    zscore = RValve + locvalve;
    if (!ZonePwrFlg) zscore = -500;

    if ((zscore > -350) &&
	(((short)(zscore - 26380)) > ((short)Rand16Signed()))) {
      if ((!tpop) && (!(Rand16() & 3))) {
	MakeHosp();
	return;
      }
      value = GetCRVal();
      DoResIn(tpop, value);
      return;
    }
    if ((zscore < 350) &&
	(((short)(zscore + 26380)) < ((short)Rand16Signed()))) {
	    value = GetCRVal();
	    DoResOut(tpop, value);
    }
  }
}


void
MakeHosp(void)
{
  if (NeedHosp > 0) {
    ZonePlop(HOSPITAL - 4);
    NeedHosp = FALSE;
    return;
  }
  if (NeedChurch > 0) {
    ZonePlop(CHURCH - 4);
    NeedChurch = FALSE;
    return;
  }
}


int
GetCRVal(void)
{
  register short LVal;

  LVal = LandValueMem[SMapX >>1][SMapY >>1];
  LVal -= PollutionMem[SMapX >>1][SMapY >>1];
  if (LVal < 30) return (0);
  if (LVal < 80) return (1);
  if (LVal < 150) return (2);
  return (3);
}


void
DoResIn(int pop, int value)
{
  short z;

  z = PollutionMem[SMapX >>1][SMapY >>1];
  if (z > 128) return;

  if (CChr9 == FREEZ) {
    if (pop < 8) {
      BuildHouse(value);
      IncROG(1);
      return;
    }
    if (PopDensity[SMapX >>1][SMapY >>1] > 64) {
      ResPlop(0, value);
      IncROG(8);
      return;
    }
    return;
  }
  if (pop < 40) {
    ResPlop((pop / 8) - 1, value);
    IncROG(8);
  }
}


void
DoComIn(int pop, int value)
{
  register short z;

  z = LandValueMem[SMapX >>1][SMapY >>1];
  z = z >>5;
  if (pop > z) return;

  if (pop < 5) {
    ComPlop(pop, value);
    IncROG(8);
  }
}


void
DoIndIn(int pop, int value)
{
  if (pop < 4) {
    IndPlop(pop, value);
    IncROG(8);
  }
}


void
IncROG(int amount)
{
  RateOGMem[SMapX>>3][SMapY>>3] += amount<<2;
}


void
DoResOut(int pop, int value)
{
  static short Brdr[9] = {0,3,6,1,4,7,2,5,8};
  register short x, y, loc, z;

  if (!pop) return;
  if (pop > 16) {
    ResPlop(((pop - 24) / 8), value);
    IncROG(-8);
    return;
  }
  if (pop == 16) {
    IncROG(-8);
    Map[SMapX][SMapY] = (FREEZ | BLBNCNBIT | ZONEBIT);
    for (x = SMapX - 1; x <= SMapX + 1; x++)
      for (y = SMapY - 1; y <= SMapY + 1; y++)
	if (x >= 0 && x < WORLD_X &&
	    y >= 0 && y < WORLD_Y) {
	  if ((Map[x][y] & LOMASK) != FREEZ)
	    Map[x][y] = LHTHR + value +
	      Rand(2) + BLBNCNBIT;
	}
  }
  if (pop < 16) {
    IncROG(-1);
    z = 0;
    for (x = SMapX - 1; x <= SMapX + 1; x++)
      for (y = SMapY - 1; y <= SMapY + 1; y++) {
	if (x >= 0 && x < WORLD_X &&
	    y >= 0 && y < WORLD_Y) {
	  loc = Map[x][y] & LOMASK;
	  if ((loc >= LHTHR) && (loc <= HHTHR)) {
	    Map[x][y] = Brdr[z] +
	      BLBNCNBIT + FREEZ - 4;
	    return;
	  }
	}
	z++;
      }
  }
}


void
DoComOut(int pop, int value)
{
  if (pop > 1) {
    ComPlop(pop - 2, value);
    IncROG(-8);
    return;
  }
  if (pop == 1) {
    ZonePlop(COMBASE);
    IncROG(-8);
  }
}


void
DoIndOut(int pop, int value)
{
  if (pop > 1) {
    IndPlop(pop - 2, value);
    IncROG(-8);
    return;
  }
  if (pop == 1) {
    ZonePlop(INDCLR - 4);
    IncROG(-8);
  }
}


int
RZPop(int Ch9)
{
  short CzDen;

  CzDen = (((Ch9 - RZB) / 9) % 4);
  return ((CzDen * 8) + 16);
}


int
CZPop(int Ch9)
{
  short CzDen;

  if (Ch9 == COMCLR) return (0);
  CzDen = (((Ch9 - CZB) / 9) % 5) + 1;
  return (CzDen);
}


int
IZPop(int Ch9)
{
  short CzDen;

  if (Ch9 == INDCLR) return (0);
  CzDen = (((Ch9 - IZB) / 9) % 4) + 1;
  return (CzDen);
}


void
BuildHouse(int value)
{
  short z, score, hscore, BestLoc;
  static short ZeX[9] = { 0,-1, 0, 1,-1, 1,-1, 0, 1};
  static short ZeY[9] = { 0,-1,-1,-1, 0, 0, 1, 1, 1};

  BestLoc = 0;
  hscore = 0;
  for (z = 1; z < 9; z++) {
    int xx = SMapX + ZeX[z];
    int yy = SMapY + ZeY[z];
    if (TestBounds(xx, yy)) {
      score = EvalLot(xx, yy);
      if (score != 0) {
	if (score > hscore) {
	  hscore = score;
	  BestLoc = z;
	}
	if ((score == hscore) && !(Rand16() & 7))
	  BestLoc = z;
      }
    }
  }
  if (BestLoc) {
    int xx = SMapX + ZeX[BestLoc];
    int yy = SMapY + ZeY[BestLoc];
    if (TestBounds(xx, yy)) {
      Map[xx][yy] = HOUSE + BLBNCNBIT + Rand(2) + (value * 3);
    }
  }
}


void
ResPlop (int Den, int Value)
{
  short base;

  base = (((Value * 4) + Den) * 9) + RZB - 4;
  ZonePlop(base);
}


void
ComPlop (int Den, int Value)
{
  short base;
	
  base = (((Value * 5) + Den) * 9) + CZB - 4;
  ZonePlop(base);
}


void
IndPlop (int Den, int Value)
{
  short base;
	
  base = (((Value * 4) + Den) * 9) + (IZB - 4);
  ZonePlop (base);
}


int
EvalLot (int x, int y)
{
  short z, score;
  static short DX[4] = { 0, 1, 0,-1};
  static short DY[4] = {-1, 0, 1, 0};

  /* test for clear lot */
  z = Map[x][y] & LOMASK;
  if (z && ((z < RESBASE) || (z > RESBASE + 8)))
    return (-1);
  score = 1;
  for (z = 0; z < 4; z++) {
    int xx = x + DX[z];
    int yy = y + DY[z];
    if (TestBounds(xx, yy) && 
	Map[xx][yy] &&
	((Map[xx][yy] & LOMASK) <= LASTROAD)) {
      score++;		/* look for road */
    }
  }
  return (score);
}


void
ZonePlop (int base)
{
  short z, x;
  static short Zx[9] = {-1, 0, 1,-1, 0, 1,-1, 0, 1};
  static short Zy[9] = {-1,-1,-1, 0, 0, 0, 1, 1, 1};

  for (z = 0; z < 9; z++) {		/* check for fire  */
    int xx = SMapX + Zx[z];
    int yy = SMapY + Zy[z];
    if (TestBounds(xx, yy)) {
      x = Map[xx][yy] & LOMASK;
      if ((x >= FLOOD) && (x < ROADBASE)) return;
    }
  }
  for (z = 0; z < 9; z++) {
    int xx = SMapX + Zx[z];
    int yy = SMapY + Zy[z];
    if (TestBounds(xx, yy)) {
      Map[xx][yy] = base + BNCNBIT;
    }
  base++;
  }
  CChr = Map[SMapX][SMapY];
  SetZPower();
  Map[SMapX][SMapY] |= ZONEBIT + BULLBIT;
}


int
EvalRes (int traf)
{
  register short Value;

  if (traf < 0) return (-3000);

  Value = LandValueMem[SMapX >>1][SMapY >>1];
  Value -= PollutionMem[SMapX >>1][SMapY >>1];

  if (Value < 0) Value = 0;		/* Cap at 0 */
  else Value = Value <<5;

  if (Value > 6000) Value = 6000;	/* Cap at 6000 */

  Value = Value - 3000;
  return (Value);
}


int
EvalCom (int traf)
{
  short Value;

  if (traf < 0) return (-3000);
  Value = ComRate[SMapX >>3][SMapY >>3];
  return (Value);
}


int
EvalInd (int traf)
{
  if (traf < 0) return (-1000);
  return (0);
}


int
DoFreePop (void)
{
  short count;
  register short loc, x, y;

  count = 0;
  for (x = SMapX - 1; x <= SMapX + 1; x++)
    for (y = SMapY - 1; y <= SMapY + 1; y++) {
      if (x >= 0 && x < WORLD_X &&
	  y >= 0 && y < WORLD_Y) {
	loc = Map[x][y] & LOMASK;
	if ((loc >= LHTHR) && (loc <= HHTHR))
	  count++;
      }
    }
  return (count);
}


int
SetZPower(void)		/* set bit in MapWord depending on powermap  */
{
#if 0
  short z;
#endif
  QUAD PowerWrd;

/* TestPowerBit was taking alot of time so I inlined it. -Don */

#if 0

  if (z = TestPowerBit())
    Map[SMapX][SMapY] = CChr | PWRBIT;
  else
    Map[SMapX][SMapY] = CChr & (~PWRBIT);
  return (z);

#else

  if ((CChr9 == NUCLEAR) ||
      (CChr9 == POWERPLANT) ||
      (
#if 1
       (PowerWrd = POWERWORD(SMapX, SMapY)),
#else
       (PowerWrd = (SMapX >>4) + (SMapY <<3)),
#endif
       ((PowerWrd < PWRMAPSIZE) &&
	(PowerMap[PowerWrd] & (1 << (SMapX & 15)))))) {
    Map[SMapX][SMapY] = CChr | PWRBIT;
    return 1;
  } else {
    Map[SMapX][SMapY] = CChr & (~PWRBIT);
    return 0;
  }

#endif
}
Commit	Line	Data
6a5fa4e0 MG	1	/* s_zone.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	/* Zone Stuff */
66
6f214ac0 MG	67	void ZonePlop (int base);
	68	void IndPlop (int Den, int Value);
	69	void ComPlop (int Den, int Value);
	70	void ResPlop (int Den, int Value);
	71	int EvalLot (int x, int y);
	72	void BuildHouse(int value);
	73	void DoIndOut(int pop, int value);
	74	void DoComOut(int pop, int value);
	75	void DoResOut(int pop, int value);
	76	void IncROG(int amount);
	77	void DoIndIn(int pop, int value);
	78	void DoComIn(int pop, int value);
	79	void DoResIn(int pop, int value);
	80	void MakeHosp(void);
	81	void DoResidential(int ZonePwrFlg);
	82	int EvalRes (int traf);
	83	int EvalCom (int traf);
	84	int GetCRVal(void);
	85	void DoCommercial(int ZonePwrFlg);
	86	void DoIndustrial(int ZonePwrFlg);
	87	int EvalInd (int traf);
	88	void DoHospChur(void);
	89
	90
	91	void DoZone(void)
6a5fa4e0 MG	92	{
	93	short ZonePwrFlg;
	94
	95	ZonePwrFlg = SetZPower(); /* Set Power Bit in Map from PowerMap */
	96	if (ZonePwrFlg) PwrdZCnt++;
	97	else unPwrdZCnt++;
	98
	99	if (CChr9 > PORTBASE) { /* do Special Zones */
	100	DoSPZone(ZonePwrFlg);
	101	return;
	102	}
	103	if (CChr9 < HOSPITAL) {
	104	DoResidential(ZonePwrFlg);
	105	return;
	106	}
	107	if (CChr9 < COMBASE) {
	108	DoHospChur();
	109	return;
	110	}
	111	if (CChr9 < INDBASE) {
	112	DoCommercial(ZonePwrFlg);
	113	return;
	114	}
	115	DoIndustrial(ZonePwrFlg);
	116	return;
	117	}
	118
	119
6f214ac0	120	void
6a5fa4e0 MG	121	DoHospChur(void)
	122	{
	123	if (CChr9 == HOSPITAL) {
	124	HospPop++;
	125	if (!(CityTime & 15)) RepairZone (HOSPITAL, 3); /post/
	126	if (NeedHosp == -1)
	127	if (!Rand(20))
	128	ZonePlop(RESBASE);
	129	}
	130	if (CChr9 == CHURCH) {
	131	ChurchPop++;
	132	if (!(CityTime & 15)) RepairZone (CHURCH, 3); /post/
	133	if (NeedChurch == -1)
	134	if (!Rand(20))
	135	ZonePlop(RESBASE);
	136	}
	137	}
	138
	139
	140	#define T 1
	141	#define F 0
	142	#define ASCBIT (ANIMBIT \| CONDBIT \| BURNBIT)
	143	#define REGBIT (CONDBIT \| BURNBIT)
	144
6f214ac0	145	void
6a5fa4e0 MG	146	SetSmoke(int ZonePower)
	147	{
	148	static short AniThis[8] = { T, F, T, T, F, F, T, T };
	149	static short DX1[8] = { -1, 0, 1, 0, 0, 0, 0, 1 };
	150	static short DY1[8] = { -1, 0, -1, -1, 0, 0, -1, -1 };
6f214ac0	151	#if 0
6a5fa4e0 MG	152	static short DX2[8] = { -1, 0, 1, 1, 0, 0, 1, 1 };
6a5fa4e0 MG	153	static short DY2[8] = { -1, 0, 0, -1, 0, 0, -1, 0 };
6f214ac0	154	#endif
6a5fa4e0 MG	155	static short AniTabA[8] = { 0, 0, 32, 40, 0, 0, 48, 56 };
	156	static short AniTabB[8] = { 0, 0, 36, 44, 0, 0, 52, 60 };
	157	static short AniTabC[8] = { IND1, 0, IND2, IND4, 0, 0, IND6, IND8 };
	158	static short AniTabD[8] = { IND1, 0, IND3, IND5, 0, 0, IND7, IND9 };
	159	register short z;
	160
	161	if (CChr9 < IZB) return;
	162	z = (CChr9 - IZB) >>3;
	163	z = z & 7;
	164	if (AniThis[z]) {
	165	int xx = SMapX + DX1[z];
	166	int yy = SMapY + DY1[z];
	167	if (TestBounds(xx, yy)) {
	168	if (ZonePower) {
	169	if ((Map[xx][yy] & LOMASK) == AniTabC[z]) {
	170	Map[xx][yy] =
	171	ASCBIT \| (SMOKEBASE + AniTabA[z]);
	172	Map[xx][yy] =
	173	ASCBIT \| (SMOKEBASE + AniTabB[z]);
	174	}
	175	} else {
	176	if ((Map[xx][yy] & LOMASK) > AniTabC[z]) {
	177	Map[xx][yy] =
	178	REGBIT \| AniTabC[z];
	179	Map[xx][yy] =
	180	REGBIT \| AniTabD[z];
	181	}
	182	}
	183	}
	184	}
	185	}
	186
	187
6f214ac0	188	void
6a5fa4e0 MG	189	DoIndustrial(int ZonePwrFlg)
	190	{
	191	short tpop, zscore, TrfGood;
	192
	193	IndZPop++;
	194	SetSmoke(ZonePwrFlg);
	195	tpop = IZPop(CChr9);
	196	IndPop += tpop;
	197	if (tpop > Rand(5)) TrfGood = MakeTraf(2);
	198	else TrfGood = TRUE;
	199
	200	if (TrfGood == -1) {
	201	DoIndOut(tpop, Rand16() & 1);
	202	return;
	203	}
	204
	205	if (!(Rand16() & 7)) {
	206	zscore = IValve + EvalInd(TrfGood);
	207	if (!ZonePwrFlg) zscore = -500;
	208	if ((zscore > -350) &&
	209	(((short)(zscore - 26380)) > ((short)Rand16Signed()))) {
	210	DoIndIn(tpop, Rand16() & 1);
	211	return;
	212	}
	213	if ((zscore < 350) &&
	214	(((short)(zscore + 26380)) < ((short)Rand16Signed())))
	215	DoIndOut(tpop, Rand16() & 1);
	216	}
	217	}
	218
	219
6f214ac0	220	void
6a5fa4e0 MG	221	DoCommercial(int ZonePwrFlg)
	222	{
	223	register short tpop, TrfGood;
	224	short zscore, locvalve,value;
	225
	226	ComZPop++;
	227	tpop = CZPop(CChr9);
	228	ComPop += tpop;
	229	if (tpop > Rand(5)) TrfGood = MakeTraf(1);
	230	else TrfGood = TRUE;
	231
	232	if (TrfGood == -1) {
	233	value = GetCRVal();
	234	DoComOut(tpop, value);
	235	return;
	236	}
	237
	238	if (!(Rand16() & 7)) {
	239	locvalve = EvalCom(TrfGood);
	240	zscore = CValve + locvalve;
	241	if (!ZonePwrFlg) zscore = -500;
	242
	243	if (TrfGood &&
	244	(zscore > -350) &&
	245	(((short)(zscore - 26380)) > ((short)Rand16Signed()))) {
	246	value = GetCRVal();
	247	DoComIn(tpop, value);
	248	return;
	249	}
	250	if ((zscore < 350) &&
	251	(((short)(zscore + 26380)) < ((short)Rand16Signed()))) {
	252	value = GetCRVal();
	253	DoComOut(tpop, value);
	254	}
	255	}
	256	}
	257
	258
6f214ac0	259	void
6a5fa4e0 MG	260	DoResidential(int ZonePwrFlg)
	261	{
	262	short tpop, zscore, locvalve, value, TrfGood;
	263
	264	ResZPop++;
	265	if (CChr9 == FREEZ) tpop = DoFreePop();
	266	else tpop = RZPop(CChr9);
	267
	268	ResPop += tpop;
	269	if (tpop > Rand(35)) TrfGood = MakeTraf(0);
	270	else TrfGood = TRUE;
	271
	272	if (TrfGood == -1) {
	273	value = GetCRVal();
	274	DoResOut(tpop, value);
	275	return;
	276	}
	277
	278	if ((CChr9 == FREEZ) \|\| (!(Rand16() & 7))) {
	279	locvalve = EvalRes(TrfGood);
	280	zscore = RValve + locvalve;
	281	if (!ZonePwrFlg) zscore = -500;
	282
	283	if ((zscore > -350) &&
	284	(((short)(zscore - 26380)) > ((short)Rand16Signed()))) {
	285	if ((!tpop) && (!(Rand16() & 3))) {
	286	MakeHosp();
	287	return;
	288	}
	289	value = GetCRVal();
	290	DoResIn(tpop, value);
	291	return;
	292	}
	293	if ((zscore < 350) &&
	294	(((short)(zscore + 26380)) < ((short)Rand16Signed()))) {
	295	value = GetCRVal();
	296	DoResOut(tpop, value);
	297	}
	298	}
	299	}
	300
	301
6f214ac0	302	void
6a5fa4e0 MG	303	MakeHosp(void)
	304	{
	305	if (NeedHosp > 0) {
	306	ZonePlop(HOSPITAL - 4);
	307	NeedHosp = FALSE;
	308	return;
	309	}
	310	if (NeedChurch > 0) {
	311	ZonePlop(CHURCH - 4);
	312	NeedChurch = FALSE;
	313	return;
	314	}
	315	}
	316
	317
6f214ac0	318	int
6a5fa4e0 MG	319	GetCRVal(void)
	320	{
	321	register short LVal;
	322
	323	LVal = LandValueMem[SMapX >>1][SMapY >>1];
	324	LVal -= PollutionMem[SMapX >>1][SMapY >>1];
	325	if (LVal < 30) return (0);
	326	if (LVal < 80) return (1);
	327	if (LVal < 150) return (2);
	328	return (3);
	329	}
	330
	331
6f214ac0	332	void
6a5fa4e0 MG	333	DoResIn(int pop, int value)
	334	{
	335	short z;
	336
	337	z = PollutionMem[SMapX >>1][SMapY >>1];
	338	if (z > 128) return;
	339
	340	if (CChr9 == FREEZ) {
	341	if (pop < 8) {
	342	BuildHouse(value);
	343	IncROG(1);
	344	return;
	345	}
	346	if (PopDensity[SMapX >>1][SMapY >>1] > 64) {
	347	ResPlop(0, value);
	348	IncROG(8);
	349	return;
	350	}
	351	return;
	352	}
	353	if (pop < 40) {
	354	ResPlop((pop / 8) - 1, value);
	355	IncROG(8);
	356	}
	357	}
	358
	359
6f214ac0	360	void
6a5fa4e0 MG	361	DoComIn(int pop, int value)
	362	{
	363	register short z;
	364
	365	z = LandValueMem[SMapX >>1][SMapY >>1];
	366	z = z >>5;
	367	if (pop > z) return;
	368
	369	if (pop < 5) {
	370	ComPlop(pop, value);
	371	IncROG(8);
	372	}
	373	}
	374
	375
6f214ac0	376	void
6a5fa4e0 MG	377	DoIndIn(int pop, int value)
	378	{
	379	if (pop < 4) {
	380	IndPlop(pop, value);
	381	IncROG(8);
	382	}
	383	}
	384
	385
6f214ac0	386	void
6a5fa4e0 MG	387	IncROG(int amount)
	388	{
	389	RateOGMem[SMapX>>3][SMapY>>3] += amount<<2;
	390	}
	391
	392
6f214ac0	393	void
6a5fa4e0 MG	394	DoResOut(int pop, int value)
	395	{
	396	static short Brdr[9] = {0,3,6,1,4,7,2,5,8};
	397	register short x, y, loc, z;
	398
	399	if (!pop) return;
	400	if (pop > 16) {
	401	ResPlop(((pop - 24) / 8), value);
	402	IncROG(-8);
	403	return;
	404	}
	405	if (pop == 16) {
	406	IncROG(-8);
	407	Map[SMapX][SMapY] = (FREEZ \| BLBNCNBIT \| ZONEBIT);
	408	for (x = SMapX - 1; x <= SMapX + 1; x++)
	409	for (y = SMapY - 1; y <= SMapY + 1; y++)
	410	if (x >= 0 && x < WORLD_X &&
	411	y >= 0 && y < WORLD_Y) {
	412	if ((Map[x][y] & LOMASK) != FREEZ)
	413	Map[x][y] = LHTHR + value +
	414	Rand(2) + BLBNCNBIT;
	415	}
	416	}
	417	if (pop < 16) {
	418	IncROG(-1);
	419	z = 0;
	420	for (x = SMapX - 1; x <= SMapX + 1; x++)
	421	for (y = SMapY - 1; y <= SMapY + 1; y++) {
	422	if (x >= 0 && x < WORLD_X &&
	423	y >= 0 && y < WORLD_Y) {
	424	loc = Map[x][y] & LOMASK;
	425	if ((loc >= LHTHR) && (loc <= HHTHR)) {
	426	Map[x][y] = Brdr[z] +
	427	BLBNCNBIT + FREEZ - 4;
	428	return;
	429	}
	430	}
	431	z++;
	432	}
	433	}
	434	}
	435
	436
6f214ac0	437	void
6a5fa4e0 MG	438	DoComOut(int pop, int value)
	439	{
	440	if (pop > 1) {
	441	ComPlop(pop - 2, value);
	442	IncROG(-8);
	443	return;
	444	}
	445	if (pop == 1) {
	446	ZonePlop(COMBASE);
	447	IncROG(-8);
	448	}
	449	}
	450
	451
6f214ac0	452	void
6a5fa4e0 MG	453	DoIndOut(int pop, int value)
	454	{
	455	if (pop > 1) {
	456	IndPlop(pop - 2, value);
	457	IncROG(-8);
	458	return;
	459	}
	460	if (pop == 1) {
	461	ZonePlop(INDCLR - 4);
	462	IncROG(-8);
	463	}
	464	}
	465
	466
6f214ac0	467	int
6a5fa4e0 MG	468	RZPop(int Ch9)
	469	{
	470	short CzDen;
	471
	472	CzDen = (((Ch9 - RZB) / 9) % 4);
	473	return ((CzDen * 8) + 16);
	474	}
	475
	476
6f214ac0	477	int
6a5fa4e0 MG	478	CZPop(int Ch9)
	479	{
	480	short CzDen;
	481
	482	if (Ch9 == COMCLR) return (0);
	483	CzDen = (((Ch9 - CZB) / 9) % 5) + 1;
	484	return (CzDen);
	485	}
	486
	487
6f214ac0	488	int
6a5fa4e0 MG	489	IZPop(int Ch9)
	490	{
	491	short CzDen;
	492
	493	if (Ch9 == INDCLR) return (0);
	494	CzDen = (((Ch9 - IZB) / 9) % 4) + 1;
	495	return (CzDen);
	496	}
	497
	498
6f214ac0	499	void
6a5fa4e0 MG	500	BuildHouse(int value)
	501	{
	502	short z, score, hscore, BestLoc;
	503	static short ZeX[9] = { 0,-1, 0, 1,-1, 1,-1, 0, 1};
	504	static short ZeY[9] = { 0,-1,-1,-1, 0, 0, 1, 1, 1};
	505
	506	BestLoc = 0;
	507	hscore = 0;
	508	for (z = 1; z < 9; z++) {
	509	int xx = SMapX + ZeX[z];
	510	int yy = SMapY + ZeY[z];
	511	if (TestBounds(xx, yy)) {
	512	score = EvalLot(xx, yy);
	513	if (score != 0) {
	514	if (score > hscore) {
	515	hscore = score;
	516	BestLoc = z;
	517	}
	518	if ((score == hscore) && !(Rand16() & 7))
	519	BestLoc = z;
	520	}
	521	}
	522	}
	523	if (BestLoc) {
	524	int xx = SMapX + ZeX[BestLoc];
	525	int yy = SMapY + ZeY[BestLoc];
	526	if (TestBounds(xx, yy)) {
	527	Map[xx][yy] = HOUSE + BLBNCNBIT + Rand(2) + (value * 3);
	528	}
	529	}
	530	}
	531
	532
6f214ac0	533	void
6a5fa4e0 MG	534	ResPlop (int Den, int Value)
	535	{
	536	short base;
	537
	538	base = (((Value * 4) + Den) * 9) + RZB - 4;
	539	ZonePlop(base);
	540	}
	541
	542
6f214ac0	543	void
6a5fa4e0 MG	544	ComPlop (int Den, int Value)
	545	{
	546	short base;
	547
	548	base = (((Value * 5) + Den) * 9) + CZB - 4;
	549	ZonePlop(base);
	550	}
	551
	552
6f214ac0	553	void
6a5fa4e0 MG	554	IndPlop (int Den, int Value)
	555	{
	556	short base;
	557
	558	base = (((Value * 4) + Den) * 9) + (IZB - 4);
	559	ZonePlop (base);
	560	}
	561
	562
6f214ac0	563	int
6a5fa4e0 MG	564	EvalLot (int x, int y)
	565	{
	566	short z, score;
	567	static short DX[4] = { 0, 1, 0,-1};
	568	static short DY[4] = {-1, 0, 1, 0};
	569
	570	/* test for clear lot */
	571	z = Map[x][y] & LOMASK;
	572	if (z && ((z < RESBASE) \|\| (z > RESBASE + 8)))
	573	return (-1);
	574	score = 1;
	575	for (z = 0; z < 4; z++) {
	576	int xx = x + DX[z];
	577	int yy = y + DY[z];
	578	if (TestBounds(xx, yy) &&
	579	Map[xx][yy] &&
	580	((Map[xx][yy] & LOMASK) <= LASTROAD)) {
	581	score++; /* look for road */
	582	}
	583	}
	584	return (score);
	585	}
	586
	587
6f214ac0	588	void
6a5fa4e0 MG	589	ZonePlop (int base)
	590	{
	591	short z, x;
	592	static short Zx[9] = {-1, 0, 1,-1, 0, 1,-1, 0, 1};
	593	static short Zy[9] = {-1,-1,-1, 0, 0, 0, 1, 1, 1};
	594
	595	for (z = 0; z < 9; z++) { /* check for fire */
	596	int xx = SMapX + Zx[z];
	597	int yy = SMapY + Zy[z];
	598	if (TestBounds(xx, yy)) {
	599	x = Map[xx][yy] & LOMASK;
6f214ac0	600	if ((x >= FLOOD) && (x < ROADBASE)) return;
6a5fa4e0 MG	601	}
	602	}
	603	for (z = 0; z < 9; z++) {
	604	int xx = SMapX + Zx[z];
	605	int yy = SMapY + Zy[z];
	606	if (TestBounds(xx, yy)) {
	607	Map[xx][yy] = base + BNCNBIT;
	608	}
	609	base++;
	610	}
	611	CChr = Map[SMapX][SMapY];
	612	SetZPower();
	613	Map[SMapX][SMapY] \|= ZONEBIT + BULLBIT;
	614	}
	615
	616
6f214ac0	617	int
6a5fa4e0 MG	618	EvalRes (int traf)
	619	{
	620	register short Value;
	621
	622	if (traf < 0) return (-3000);
	623
	624	Value = LandValueMem[SMapX >>1][SMapY >>1];
	625	Value -= PollutionMem[SMapX >>1][SMapY >>1];
	626
	627	if (Value < 0) Value = 0; /* Cap at 0 */
	628	else Value = Value <<5;
	629
	630	if (Value > 6000) Value = 6000; /* Cap at 6000 */
	631
	632	Value = Value - 3000;
	633	return (Value);
	634	}
	635
	636
6f214ac0	637	int
6a5fa4e0 MG	638	EvalCom (int traf)
	639	{
	640	short Value;
	641
	642	if (traf < 0) return (-3000);
	643	Value = ComRate[SMapX >>3][SMapY >>3];
	644	return (Value);
	645	}
	646
	647
6f214ac0	648	int
6a5fa4e0 MG	649	EvalInd (int traf)
	650	{
	651	if (traf < 0) return (-1000);
	652	return (0);
	653	}
	654
	655
6f214ac0	656	int
6a5fa4e0 MG	657	DoFreePop (void)
	658	{
	659	short count;
	660	register short loc, x, y;
	661
	662	count = 0;
	663	for (x = SMapX - 1; x <= SMapX + 1; x++)
	664	for (y = SMapY - 1; y <= SMapY + 1; y++) {
	665	if (x >= 0 && x < WORLD_X &&
	666	y >= 0 && y < WORLD_Y) {
	667	loc = Map[x][y] & LOMASK;
	668	if ((loc >= LHTHR) && (loc <= HHTHR))
	669	count++;
	670	}
	671	}
	672	return (count);
	673	}
	674
	675
6f214ac0	676	int
6a5fa4e0 MG	677	SetZPower(void) /* set bit in MapWord depending on powermap */
6a5fa4e0 MG	678	{
6f214ac0	679	#if 0
6a5fa4e0	680	short z;
6f214ac0	681	#endif
6a5fa4e0 MG	682	QUAD PowerWrd;
	683
	684	/* TestPowerBit was taking alot of time so I inlined it. -Don */
	685
	686	#if 0
	687
	688	if (z = TestPowerBit())
	689	Map[SMapX][SMapY] = CChr \| PWRBIT;
	690	else
	691	Map[SMapX][SMapY] = CChr & (~PWRBIT);
	692	return (z);
	693
	694	#else
	695
	696	if ((CChr9 == NUCLEAR) \|\|
	697	(CChr9 == POWERPLANT) \|\|
	698	(
	699	#if 1
	700	(PowerWrd = POWERWORD(SMapX, SMapY)),
	701	#else
	702	(PowerWrd = (SMapX >>4) + (SMapY <<3)),
	703	#endif
	704	((PowerWrd < PWRMAPSIZE) &&
	705	(PowerMap[PowerWrd] & (1 << (SMapX & 15)))))) {
	706	Map[SMapX][SMapY] = CChr \| PWRBIT;
	707	return 1;
	708	} else {
	709	Map[SMapX][SMapY] = CChr & (~PWRBIT);
	710	return 0;
	711	}
	712
	713	#endif
	714	}