![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to w_con.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Micropolis - Activity] / micropolis / src / sim|
Return to w_con.c CVS log | Up to [Micropolis - Activity] / micropolis / src / sim |
1.1 root 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 [email protected].
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: short _RoadTable[16] = {
66: 66, 67, 66, 68,
67: 67, 67, 69, 73,
68: 66, 71, 66, 72,
69: 70, 75, 74, 76
70: };
71:
72: short _RailTable[16] = {
73: 226, 227, 226, 228,
74: 227, 227, 229, 233,
75: 226, 231, 226, 232,
76: 230, 235, 234, 236
77: };
78:
79: short _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 */
95: int
96: ConnecTile(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 */
154: int
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 */
202: int
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 */
308: int
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 */
399: int
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:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.