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