git.zerfleddert.de Git - micropolis/blob - src/sim/s_eval.c

   1 /* s_eval.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 /* City Evaluation */
  66
  67
  68 short EvalValid;
  69 short CityYes, CityNo;
  70 short ProblemTable[PROBNUM];
  71 short ProblemTaken[PROBNUM];
  72 short ProblemVotes[PROBNUM];            /* these are the votes for each  */
  73 short ProblemOrder[4];                  /* sorted index to above  */
  74 QUAD CityPop, deltaCityPop;
  75 QUAD CityAssValue;
  76 short CityClass;                        /*  0..5  */
  77 short CityScore, deltaCityScore, AverageCityScore;
  78 short TrafficAverage;
  79
  80 void DoVotes(void);
  81 void GetScore(void);
  82 void VoteProblems(void);
  83 void DoProblems(void);
  84 void DoPopNum(void);
  85 void GetAssValue(void);
  86
  87
  88 /* comefrom: SpecialInit Simulate */
  89 void
  90 CityEvaluation(void)
  91 {
  92   EvalValid = 0;
  93   if (TotalPop) {
  94     GetAssValue();
  95     DoPopNum();
  96     DoProblems();
  97     GetScore();
  98     DoVotes();
  99     ChangeEval();
 100   } else {
 101     EvalInit();
 102     ChangeEval();
 103   }
 104   EvalValid = 1;
 105 }
 106
 107
 108 /* comefrom: CityEvaluation SetCommonInits */
 109 void
 110 EvalInit(void)
 111 {
 112   register short x, z;
 113
 114   z = 0;
 115   CityYes = z;
 116   CityNo = z;
 117   CityPop = z;
 118   deltaCityPop = z;
 119   CityAssValue = z;
 120   CityClass = z;
 121   CityScore = 500;
 122   deltaCityScore = z;
 123   EvalValid = 1;
 124   for (x = 0; x < PROBNUM; x++)
 125     ProblemVotes[x] = z;
 126   for (x = 0; x < 4; x++)
 127     ProblemOrder[x] = z;
 128 }
 129
 130
 131 /* comefrom: CityEvaluation */
 132 void
 133 GetAssValue(void)
 134 {
 135   QUAD z;
 136
 137   z = RoadTotal * 5;
 138   z += RailTotal * 10;
 139   z += PolicePop * 1000;
 140   z += FireStPop * 1000;
 141   z += HospPop * 400;
 142   z += StadiumPop * 3000;
 143   z += PortPop * 5000;
 144   z += APortPop * 10000;
 145   z += CoalPop * 3000;
 146   z += NuclearPop * 6000;
 147   CityAssValue = z * 1000;
 148 }
 149
 150
 151 /* comefrom: CityEvaluation */
 152 void
 153 DoPopNum(void)
 154 {
 155   QUAD OldCityPop;
 156
 157   OldCityPop = CityPop;
 158   CityPop = ((ResPop) + (ComPop * 8L) + (IndPop *8L)) * 20L;
 159   if (OldCityPop == -1) {
 160     OldCityPop = CityPop;
 161   }
 162   deltaCityPop = CityPop - OldCityPop;
 163
 164   CityClass = 0;                        /* village */
 165   if (CityPop > 2000)   CityClass++;    /* town */
 166   if (CityPop > 10000)  CityClass++;    /* city */
 167   if (CityPop > 50000)  CityClass++;    /* capital */
 168   if (CityPop > 100000) CityClass++;    /* metropolis */
 169   if (CityPop > 500000) CityClass++;    /* megalopolis */
 170 }
 171
 172
 173 /* comefrom: CityEvaluation */
 174 void
 175 DoProblems(void)
 176 {
 177   register short x, z;
 178   short ThisProb = 0, Max;
 179
 180   for (z = 0; z < PROBNUM; z++)
 181     ProblemTable[z] = 0;
 182   ProblemTable[0] = CrimeAverage;               /* Crime */
 183   ProblemTable[1] = PolluteAverage;             /* Pollution */
 184   ProblemTable[2] = LVAverage * .7;             /* Housing */
 185   ProblemTable[3] = CityTax * 10;               /* Taxes */
 186   ProblemTable[4] = AverageTrf();               /* Traffic */
 187   ProblemTable[5] = GetUnemployment();          /* Unemployment */
 188   ProblemTable[6] = GetFire();                  /* Fire */
 189   VoteProblems();
 190   for (z = 0; z < PROBNUM; z++)
 191     ProblemTaken[z] = 0;
 192   for (z = 0; z < 4; z++) {
 193     Max = 0;
 194     for (x = 0; x < 7; x++) {
 195       if ((ProblemVotes[x] > Max) && (!ProblemTaken[x])) {
 196         ThisProb = x;
 197         Max = ProblemVotes[x];
 198       }
 199     }
 200     if (Max) {
 201       ProblemTaken[ThisProb] = 1;
 202       ProblemOrder[z] = ThisProb;
 203     }
 204     else {
 205       ProblemOrder[z] = 7;
 206       ProblemTable[7] = 0;
 207     }
 208   }
 209 }
 210
 211
 212 /* comefrom: DoProblems */
 213 void
 214 VoteProblems(void)
 215 {
 216   register int x, z, count;
 217
 218   for (z = 0; z < PROBNUM; z++)
 219     ProblemVotes[z] = 0;
 220
 221   x = 0;
 222   z = 0;
 223   count = 0;
 224   while ((z < 100) && (count < 600)) {
 225     if (Rand(300) < ProblemTable[x]) {
 226       ProblemVotes[x]++;
 227       z++;
 228     }
 229     x++;
 230     if (x > PROBNUM) x = 0;
 231     count++;
 232   }
 233 }
 234
 235
 236 /* comefrom: DoProblems */
 237 int
 238 AverageTrf(void)
 239 {
 240   QUAD TrfTotal;
 241   register short x, y, count;
 242
 243   TrfTotal = 0;
 244   count = 1;
 245   for (x=0; x < HWLDX; x++)
 246     for (y=0; y < HWLDY; y++)
 247       if (LandValueMem[x][y]) {
 248         TrfTotal += TrfDensity[x][y];
 249         count++;
 250       }
 251
 252   TrafficAverage = (TrfTotal / count) * 2.4;
 253   return(TrafficAverage);
 254 }
 255
 256
 257 /* comefrom: DoProblems */
 258 int
 259 GetUnemployment(void)
 260 {
 261   float r;
 262   short b;
 263
 264   b = (ComPop + IndPop) << 3;
 265   if (b)
 266     r = ((float)ResPop) / b;
 267   else
 268     return(0);
 269
 270   b = (r - 1) * 255;
 271   if (b > 255)
 272     b = 255;
 273   return (b);
 274 }
 275
 276
 277 /* comefrom: DoProblems GetScore */
 278 int
 279 GetFire(void)
 280 {
 281   short z;
 282
 283   z = FirePop * 5;
 284   if (z > 255)
 285     return(255);
 286   else
 287     return(z);
 288 }
 289
 290
 291 /* comefrom: CityEvaluation */
 292 void
 293 GetScore(void)
 294 {
 295   register int x, z;
 296   short OldCityScore;
 297   float SM, TM;
 298
 299   OldCityScore = CityScore;
 300   x = 0;
 301   for (z = 0; z < 7; z++)
 302     x += ProblemTable[z];       /* add 7 probs */
 303
 304   x = x / 3;                    /* 7 + 2 average */
 305   if (x > 256) x = 256;
 306
 307   z = (256 - x) * 4;
 308   if (z > 1000) z = 1000;
 309   if (z < 0 ) z = 0;
 310
 311   if (ResCap) z = z * .85;
 312   if (ComCap) z = z * .85;
 313   if (IndCap) z = z * .85;
 314   if (RoadEffect < 32)  z = z - (32 - RoadEffect);
 315   if (PoliceEffect < 1000) z = z * (.9 + (PoliceEffect / 10000.1));
 316   if (FireEffect < 1000) z = z * (.9 + (FireEffect / 10000.1));
 317   if (RValve < -1000) z = z * .85;
 318   if (CValve < -1000) z = z * .85;
 319   if (IValve < -1000) z = z * .85;
 320
 321   SM = 1.0;
 322   if ((CityPop == 0) || (deltaCityPop == 0))
 323     SM = 1.0;
 324   else if (deltaCityPop == CityPop)
 325     SM = 1.0;
 326   else if (deltaCityPop > 0)
 327     SM = ((float)deltaCityPop/CityPop) + 1.0;
 328   else if (deltaCityPop < 0)
 329     SM = .95 + ((float) deltaCityPop/(CityPop - deltaCityPop));
 330   z = z * SM;
 331   z = z - GetFire();            /* dec score for fires */
 332   z = z - (CityTax);
 333
 334   TM = unPwrdZCnt + PwrdZCnt;   /* dec score for unpowered zones */
 335   if (TM) SM = PwrdZCnt / TM;
 336   else SM = 1.0;
 337   z = z * SM;
 338
 339   if (z > 1000) z = 1000;
 340   if (z < 0 ) z = 0;
 341
 342   CityScore = (CityScore + z) / 2;
 343
 344   deltaCityScore = CityScore - OldCityScore;
 345 }
 346
 347
 348 /* comefrom: CityEvaluation */
 349 void
 350 DoVotes(void)
 351 {
 352   register int z;
 353
 354   CityYes = 0;
 355   CityNo = 0;
 356   for (z = 0; z < 100; z++) {
 357     if (Rand(1000) < CityScore)
 358       CityYes++;
 359     else
 360       CityNo++;
 361   }
 362 }