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