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

   1 /* w_con.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 void _FixSingle(int x, int y, short *TileAdrPtr);
  65 void _FixZone(int x, int y, short *TileAdrPtr);
  66 int _LayDoze(int x, int y, short *TileAdrPtr);
  67 int _LayRoad(int x, int y, short *TileAdrPtr);
  68 int _LayRail(int x, int y, short *TileAdrPtr);
  69 int _LayWire(int x, int y, short *TileAdrPtr);
  70
  71
  72 short _RoadTable[16] = {
  73   66, 67, 66, 68,
  74   67, 67, 69, 73,
  75   66, 71, 66, 72,
  76   70, 75, 74, 76
  77 };
  78
  79 short _RailTable[16] = {
  80   226, 227, 226, 228,
  81   227, 227, 229, 233,
  82   226, 231, 226, 232,
  83   230, 235, 234, 236
  84 };
  85
  86 short _WireTable[16] = {
  87   210, 211, 210, 212,
  88   211, 211, 213, 217,
  89   210, 215, 210, 216,
  90   214, 219, 218, 220
  91 };
  92
  93
  94 #define NeutralizeRoad(Tile) \
  95   if (((Tile &= LOMASK) >= 64) && \
  96       ((Tile & LOMASK) <= 207)) { \
  97     Tile = (Tile & 0x000F) + 64; \
  98   }
  99
 100
 101 /* comefrom: check3Border check4Border check5Border processWand */
 102 int
 103 ConnecTile(short x, short y, short *TileAdrPtr, short Command)
 104 {
 105   short Tile;
 106   int result = 1;
 107
 108   /* make sure the array subscripts are in bounds */
 109   if (!TestBounds(x, y)) {
 110     return (0);
 111   }
 112
 113   /* AutoDoze */
 114   if ((Command >= 2) && (Command <= 4)) {
 115
 116     if ((autoBulldoze != 0) &&
 117         (TotalFunds > 0) &&
 118         ((Tile = (*TileAdrPtr)) & BULLBIT)) {
 119       NeutralizeRoad(Tile);
 120       /* Maybe this should check BULLBIT instead of checking tile values? */
 121       if (((Tile >= TINYEXP) && (Tile <= LASTTINYEXP)) ||
 122           ((Tile < 64) && (Tile != 0))) {
 123         Spend(1);
 124         (*TileAdrPtr) = 0;
 125       }
 126     }
 127   }
 128
 129   switch (Command) {
 130
 131   case 0:       /* Fix zone */
 132     _FixZone(x, y, TileAdrPtr);
 133     break;
 134
 135   case 1:       /* Doze zone */
 136     result = _LayDoze(x, y, TileAdrPtr);
 137     _FixZone(x, y, TileAdrPtr);
 138     break;
 139
 140   case 2:       /* Lay Road */
 141     result = _LayRoad(x, y, TileAdrPtr);
 142     _FixZone(x, y, TileAdrPtr);
 143     break;
 144
 145   case 3:       /* Lay Rail */
 146     result = _LayRail(x, y, TileAdrPtr);
 147     _FixZone(x, y, TileAdrPtr);
 148     break;
 149
 150   case 4:       /* Lay Wire */
 151     result = _LayWire(x, y, TileAdrPtr);
 152     _FixZone(x, y, TileAdrPtr);
 153     break;
 154
 155   }
 156
 157   return result;
 158 }
 159
 160 /* comefrom: ConnecTile */
 161 int
 162 _LayDoze(int x, int y, short *TileAdrPtr)
 163 {
 164   short Tile;
 165
 166   if (!(TotalFunds)) {
 167     return -2;                  /* no mas dinero. */
 168   }
 169
 170   Tile = (*TileAdrPtr);
 171
 172   if (!(Tile & BULLBIT)) {
 173     return 0;                   /* Check dozeable bit. */
 174   }
 175
 176   NeutralizeRoad(Tile);
 177
 178   switch (Tile) {
 179   case HBRIDGE:
 180   case VBRIDGE:
 181   case BRWV:
 182   case BRWH:
 183   case HBRDG0:
 184   case HBRDG1:
 185   case HBRDG2:
 186   case HBRDG3:
 187   case VBRDG0:
 188   case VBRDG1:
 189   case VBRDG2:
 190   case VBRDG3:
 191   case HPOWER:
 192   case VPOWER:
 193   case HRAIL:
 194   case VRAIL:           /* Dozing over water, replace with water. */
 195     (*TileAdrPtr) = RIVER;
 196     break;
 197
 198   default:              /* Dozing on land, replace with land.  Simple, eh? */
 199     (*TileAdrPtr) = DIRT;
 200     break;
 201   }
 202
 203   Spend(1);                     /* Costs $1.00....*/
 204   return 1;
 205 }
 206
 207
 208 /* comefrom: ConnecTile */
 209 int
 210 _LayRoad(int x, int y, short *TileAdrPtr)
 211 {
 212   short Tile;
 213   int cost = 10;
 214
 215   if (TotalFunds < 10) {
 216     return -2;
 217   }
 218
 219   Tile = (*TileAdrPtr) & LOMASK;
 220
 221   switch (Tile) {
 222
 223   case DIRT:
 224     (*TileAdrPtr) = ROADS | BULLBIT | BURNBIT;
 225     break;
 226
 227   case RIVER:                   /* Road on Water */
 228   case REDGE:
 229   case CHANNEL:                 /* Check how to build bridges, if possible. */
 230     if (TotalFunds < 50) {
 231       return -2;
 232     }
 233
 234     cost = 50;
 235
 236     if (x < (WORLD_X - 1)) {
 237       Tile = TileAdrPtr[WORLD_Y];
 238       NeutralizeRoad(Tile);
 239       if ((Tile == VRAILROAD) ||
 240           (Tile == HBRIDGE) ||
 241           ((Tile >= ROADS) &&
 242            (Tile <= HROADPOWER))) {
 243         (*TileAdrPtr) = HBRIDGE | BULLBIT;
 244         break;
 245       }
 246     }
 247
 248     if (x > 0) {
 249       Tile = TileAdrPtr[-WORLD_Y];
 250       NeutralizeRoad(Tile);
 251       if ((Tile == VRAILROAD) ||
 252           (Tile == HBRIDGE) ||
 253           ((Tile >= ROADS) &&
 254            (Tile <= INTERSECTION))) {
 255         (*TileAdrPtr) = HBRIDGE | BULLBIT;
 256         break;
 257       }
 258     }
 259
 260     if (y < (WORLD_Y - 1)) {
 261       Tile = TileAdrPtr[1];
 262       NeutralizeRoad(Tile);
 263       if ((Tile == HRAILROAD) ||
 264           (Tile == VROADPOWER) ||
 265           ((Tile >= VBRIDGE) &&
 266            (Tile <= INTERSECTION))) {
 267         (*TileAdrPtr) = VBRIDGE | BULLBIT;
 268         break;
 269       }
 270     }
 271
 272     if (y > 0) {
 273       Tile = TileAdrPtr[-1];
 274       NeutralizeRoad(Tile);
 275       if ((Tile == HRAILROAD) ||
 276           (Tile == VROADPOWER) ||
 277           ((Tile >= VBRIDGE) &&
 278            (Tile <= INTERSECTION))) {
 279         (*TileAdrPtr) = VBRIDGE | BULLBIT;
 280         break;
 281       }
 282     }
 283
 284     /* Can't do road... */
 285     return 0;
 286
 287   case LHPOWER:         /* Road on power */
 288     (*TileAdrPtr) = VROADPOWER | CONDBIT | BURNBIT | BULLBIT;
 289     break;
 290
 291   case LVPOWER:         /* Road on power #2 */
 292     (*TileAdrPtr) = HROADPOWER | CONDBIT | BURNBIT | BULLBIT;
 293     break;
 294
 295   case LHRAIL:          /* Road on rail */
 296     (*TileAdrPtr) = HRAILROAD | BURNBIT | BULLBIT;
 297     break;
 298
 299   case LVRAIL:          /* Road on rail #2 */
 300     (*TileAdrPtr) = VRAILROAD | BURNBIT | BULLBIT;
 301     break;
 302
 303   default:              /* Can't do road */
 304     return 0;
 305
 306   }
 307
 308   Spend(cost);
 309
 310   return 1;
 311 }
 312
 313
 314 /* comefrom: ConnecTile */
 315 int
 316 _LayRail(int x, int y, short *TileAdrPtr)
 317 {
 318   short Tile;
 319   int cost = 20;
 320
 321   if (TotalFunds < 20) {
 322     return -2;
 323   }
 324
 325   Tile = (*TileAdrPtr) & LOMASK;
 326   NeutralizeRoad(Tile);
 327
 328   switch (Tile) {
 329   case 0:                       /* Rail on Dirt */
 330     (*TileAdrPtr) = 226 | BULLBIT | BURNBIT;
 331     break;
 332
 333   case 2:                       /* Rail on Water */
 334   case 3:
 335   case 4:                       /* Check how to build underwater tunnel, if possible. */
 336     if (TotalFunds < 100) {
 337       return -2;
 338     }
 339     cost = 100;
 340
 341     if (x < (WORLD_X - 1)) {
 342       Tile = TileAdrPtr[WORLD_Y];
 343       NeutralizeRoad(Tile);
 344       if ((Tile == 221) || (Tile == 224) || ((Tile >= 226) && (Tile <= 237))) {
 345         (*TileAdrPtr) = 224 | BULLBIT;
 346         break;
 347       }
 348     }
 349
 350     if (x > 0) {
 351       Tile = TileAdrPtr[-WORLD_Y];
 352       NeutralizeRoad(Tile);
 353       if ((Tile == 221) || (Tile == 224) || ((Tile > 225) && (Tile < 238))) {
 354         (*TileAdrPtr) = 224 | BULLBIT;
 355         break;
 356       }
 357     }
 358
 359     if (y < (WORLD_Y - 1)) {
 360       Tile = TileAdrPtr[1];
 361       NeutralizeRoad(Tile);
 362       if ((Tile == 222) || (Tile == 238) || ((Tile > 224) && (Tile < 237))) {
 363         (*TileAdrPtr) = 225 | BULLBIT;
 364         break;
 365       }
 366     }
 367
 368     if (y > 0) {
 369       Tile = TileAdrPtr[-1];
 370       NeutralizeRoad(Tile);
 371       if ((Tile == 222) || (Tile == 238) || ((Tile > 224) && (Tile < 237))) {
 372         (*TileAdrPtr) = 225 | BULLBIT;
 373         break;
 374       }
 375     }
 376
 377     /* Can't do rail... */
 378     return 0;
 379
 380   case 210:             /* Rail on power */
 381     (*TileAdrPtr) = 222 | CONDBIT | BURNBIT | BULLBIT;
 382     break;
 383
 384   case 211:             /* Rail on power #2 */
 385     (*TileAdrPtr) = 221 | CONDBIT | BURNBIT | BULLBIT;
 386     break;
 387
 388   case 66:              /* Rail on road */
 389     (*TileAdrPtr) = 238 | BURNBIT | BULLBIT;
 390     break;
 391
 392   case 67:              /* Rail on road #2 */
 393     (*TileAdrPtr) = 237 | BURNBIT | BULLBIT;
 394     break;
 395
 396   default:              /* Can't do rail */
 397     return 0;
 398   }
 399
 400   Spend(cost);
 401   return 1;
 402 }
 403
 404
 405 /* comefrom: ConnecTile */
 406 int
 407 _LayWire(int x, int y, short *TileAdrPtr)
 408 {
 409   short Tile;
 410   int cost = 5;
 411
 412   if (TotalFunds < 5) {
 413     return -2;
 414   }
 415
 416   Tile = (*TileAdrPtr) & LOMASK;
 417   NeutralizeRoad(Tile);
 418
 419   switch (Tile) {
 420   case 0:                       /* Wire on Dirt */
 421     (*TileAdrPtr) = 210 | CONDBIT | BURNBIT | BULLBIT;
 422     break;
 423
 424   case 2:                       /* Wire on Water */
 425   case 3:
 426   case 4:                       /* Check how to lay underwater wire, if possible. */
 427     if (TotalFunds < 25)
 428       return -2;
 429     cost = 25;
 430
 431     if (x < (WORLD_X - 1)) {
 432       Tile = TileAdrPtr[WORLD_Y];
 433       if (Tile & CONDBIT) {
 434         NeutralizeRoad(Tile);
 435         if ((Tile != 77) && (Tile != 221) && (Tile != 208)) {
 436           (*TileAdrPtr) = 209 | CONDBIT | BULLBIT;
 437           break;
 438         }
 439       }
 440     }
 441
 442     if (x > 0) {
 443       Tile = TileAdrPtr[-WORLD_Y];
 444       if (Tile & CONDBIT) {
 445         NeutralizeRoad(Tile);
 446         if ((Tile != 77) && (Tile != 221) && (Tile != 208)) {
 447           (*TileAdrPtr) = 209 | CONDBIT | BULLBIT;
 448           break;
 449         }
 450       }
 451     }
 452
 453     if (y < (WORLD_Y - 1)) {
 454       Tile = TileAdrPtr[1];
 455       if (Tile & CONDBIT) {
 456         NeutralizeRoad(Tile);
 457         if ((Tile != 78) && (Tile != 222) && (Tile != 209)) {
 458           (*TileAdrPtr) = 208 | CONDBIT | BULLBIT;
 459           break;
 460         }
 461       }
 462     }
 463
 464     if (y > 0) {
 465       Tile = TileAdrPtr[-1];
 466       if (Tile & CONDBIT) {
 467         NeutralizeRoad(Tile);
 468         if ((Tile != 78) && (Tile != 222) && (Tile != 209)) {
 469           (*TileAdrPtr) = 208 | CONDBIT | BULLBIT;
 470           break;
 471         }
 472       }
 473     }
 474
 475     /* Can't do wire... */
 476     return 0;
 477
 478   case 66:              /* Wire on Road */
 479     (*TileAdrPtr) = 77 | CONDBIT | BURNBIT | BULLBIT;
 480     break;
 481
 482   case 67:              /* Wire on Road #2 */
 483     (*TileAdrPtr) = 78 | CONDBIT | BURNBIT | BULLBIT;
 484                         break;
 485
 486   case 226:             /* Wire on rail */
 487     (*TileAdrPtr) = 221 | CONDBIT | BURNBIT | BULLBIT;
 488     break;
 489
 490   case 227:             /* Wire on rail #2 */
 491     (*TileAdrPtr) = 222 | CONDBIT | BURNBIT | BULLBIT;
 492     break;
 493
 494   default:              /* Can't do wire */
 495     return 0;
 496   }
 497
 498   Spend(cost);
 499   return 1;
 500 }
 501
 502
 503 /* comefrom: ConnecTile */
 504 void
 505 _FixZone(int x, int y, short *TileAdrPtr)
 506 {
 507   _FixSingle(x,y, &TileAdrPtr[0]);
 508
 509   if (y > 0) {
 510     _FixSingle(x, y-1, &TileAdrPtr[-1]);
 511   }
 512
 513   if (x < (WORLD_X - 1)) {
 514     _FixSingle(x+1, y, &TileAdrPtr[WORLD_Y]);
 515   }
 516
 517   if (y < (WORLD_Y - 1)) {
 518     _FixSingle(x, y+1, &TileAdrPtr[1]);
 519   }
 520
 521   if (x > 0) {
 522     _FixSingle(x-1, y, &TileAdrPtr[-WORLD_Y]);
 523   }
 524
 525 }
 526
 527
 528 /* comefrom: _FixZone */
 529 void
 530 _FixSingle(int x, int y, short *TileAdrPtr)
 531 {
 532   short Tile;
 533   short adjTile = 0;
 534
 535   Tile = (*TileAdrPtr) & LOMASK;
 536   NeutralizeRoad(Tile);
 537   if ((Tile >= 66) && (Tile <= 76)) {           /* Cleanup Road */
 538
 539     if (y > 0) {
 540       Tile = TileAdrPtr[-1];
 541       NeutralizeRoad(Tile);
 542       if (((Tile == 237) || ((Tile >= 64) && (Tile <= 78))) &&
 543           (Tile != 77) && (Tile != 238) && (Tile != 64))
 544         adjTile |= 0x0001;
 545     }
 546
 547     if (x < (WORLD_X - 1)) {
 548       Tile = TileAdrPtr[WORLD_Y];
 549       NeutralizeRoad(Tile);
 550       if (((Tile == 238) || ((Tile >= 64) && (Tile <= 78))) &&
 551           (Tile != 78) && (Tile != 237) && (Tile != 65))
 552         adjTile |= 0x0002;
 553     }
 554
 555     if (y < (WORLD_Y - 1)) {
 556       Tile = TileAdrPtr[1];
 557       NeutralizeRoad(Tile);
 558       if (((Tile == 237) || ((Tile >= 64) && (Tile <= 78))) &&
 559           (Tile != 77) && (Tile != 238) && (Tile != 64))
 560         adjTile |= 0x0004;
 561     }
 562
 563     if (x > 0) {
 564       Tile = TileAdrPtr[-WORLD_Y];
 565       NeutralizeRoad(Tile);
 566       if (((Tile == 238) || ((Tile >= 64) && (Tile <= 78))) &&
 567           (Tile != 78) && (Tile != 237) && (Tile != 65))
 568         adjTile |= 0x0008;
 569     }
 570
 571     (*TileAdrPtr) = _RoadTable[adjTile] | BULLBIT | BURNBIT;
 572     return;
 573   }
 574
 575   if ((Tile >= 226) && (Tile <= 236)) {         /* Cleanup Rail */
 576
 577     if (y > 0) {
 578       Tile = TileAdrPtr[-1];
 579       NeutralizeRoad(Tile);
 580       if ((Tile >= 221) && (Tile <= 238) &&
 581           (Tile != 221) && (Tile != 237) && (Tile != 224))
 582         adjTile |= 0x0001;
 583     }
 584
 585     if (x < (WORLD_X - 1)) {
 586       Tile = TileAdrPtr[WORLD_Y];
 587       NeutralizeRoad(Tile);
 588       if ((Tile >= 221) && (Tile <= 238) &&
 589           (Tile != 222) && (Tile != 238) && (Tile != 225))
 590         adjTile |= 0x0002;
 591     }
 592
 593     if (y < (WORLD_Y - 1)) {
 594       Tile = TileAdrPtr[1];
 595       NeutralizeRoad(Tile);
 596       if ((Tile >= 221) && (Tile <= 238) &&
 597           (Tile != 221) && (Tile != 237) && (Tile != 224))
 598         adjTile |= 0x0004;
 599     }
 600
 601     if (x > 0) {
 602       Tile = TileAdrPtr[-WORLD_Y];
 603       NeutralizeRoad(Tile);
 604       if ((Tile >= 221) && (Tile <= 238) &&
 605           (Tile != 222) && (Tile != 238) && (Tile != 225))
 606         adjTile |= 0x0008;
 607     }
 608
 609     (*TileAdrPtr) = _RailTable[adjTile] | BULLBIT | BURNBIT;
 610     return;
 611   }
 612
 613   if ((Tile >= 210) && (Tile <= 220)) {         /* Cleanup Wire */
 614
 615     if (y > 0) {
 616       Tile = TileAdrPtr[-1];
 617       if (Tile & CONDBIT) {
 618         NeutralizeRoad(Tile);
 619         if ((Tile != 209) && (Tile != 78) && (Tile != 222))
 620           adjTile |= 0x0001;
 621       }
 622     }
 623
 624     if (x < (WORLD_X - 1)) {
 625       Tile = TileAdrPtr[WORLD_Y];
 626       if (Tile & CONDBIT) {
 627         NeutralizeRoad(Tile);
 628         if ((Tile != 208) && (Tile != 77) && (Tile != 221))
 629           adjTile |= 0x0002;
 630       }
 631     }
 632
 633     if (y < (WORLD_Y - 1)) {
 634       Tile = TileAdrPtr[1];
 635       if (Tile & CONDBIT) {
 636         NeutralizeRoad(Tile);
 637         if ((Tile != 209) && (Tile != 78) && (Tile != 222))
 638           adjTile |= 0x0004;
 639       }
 640     }
 641
 642     if (x > 0) {
 643       Tile = TileAdrPtr[-WORLD_Y];
 644       if (Tile & CONDBIT) {
 645         NeutralizeRoad(Tile);
 646         if ((Tile != 208) && (Tile != 77) && (Tile != 221))
 647           adjTile |= 0x0008;
 648       }
 649     }
 650
 651     (*TileAdrPtr) = _WireTable[adjTile] | BULLBIT | BURNBIT | CONDBIT;
 652     return;
 653   }
 654 }
 655