![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to sim.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 sim.c CVS log | Up to [Micropolis - Activity] / micropolis / src / sim |
1.1 root 1: /* sim.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: /* Sim City */
66:
67: char *MicropolisVersion = "4.0";
68: Sim *sim = NULL;
69: int sim_loops = 0;
70: int sim_delay = 50;
71: int sim_skips = 0;
72: int sim_skip = 0;
73: int sim_paused = 0;
74: int sim_paused_speed = 3;
75: int sim_tty = 0;
76: #ifdef CAM
77: int sim_just_cam = 0;
78: #endif
79: int heat_steps = 0;
80: int heat_flow = -7;
81: int heat_rule = 0;
82: int heat_wrap = 3;
83: struct timeval start_time, now_time, beat_time, last_now_time;
84: char *CityFileName = NULL;
85: int Startup = 0;
86: int StartupGameLevel = 0;
87: char *StartupName = NULL;
88: int WireMode = 0;
89: int MultiPlayerMode = 0;
90: int SugarMode = 0;
91: int TilesAnimated = 0;
92: int DoAnimation = 1;
93: int DoMessages = 1;
94: int DoNotices = 1;
95: char *Displays = NULL;
96: char *FirstDisplay = NULL;
97: int ExitReturn = 0;
98:
99:
100: sim_exit(int val)
101: {
102: tkMustExit = 1;
103: ExitReturn = val;
104: }
105:
106:
107: sim_really_exit(int val)
108: {
109: DoStopMicropolis();
110:
111: exit(val);
112: }
113:
114:
115: #define COPY(FROM, TO) \
116: TO = ckalloc(strlen(FROM) + 1); \
117: strcpy(TO, FROM);
118:
119:
120: #define TESTDIR(DIR, NAME) \
121: if ((stat(DIR, &statbuf) == -1) || \
122: !(S_ISDIR(statbuf.st_mode))) { \
123: fprintf(stderr, \
124: "Can't find the directory \"%s\"!\n", DIR); \
125: fprintf(stderr, \
126: "The environment variable \"%s\" should name a directory.\n", \
127: NAME); \
128: lost = 1; \
129: }
130:
131:
132: void
133: env_init(void)
134: {
135: char dir[256];
136: char *s;
137: struct stat statbuf;
138: int lost = 0;
139:
140: if ((s = getenv("SIMHOME")) == NULL) {
141: s = ".";
142: }
143: COPY(s, HomeDir);
144: TESTDIR(HomeDir, "$SIMHOME");
145:
146: sprintf(dir, "%s/res/", HomeDir);
147: COPY(dir, ResourceDir);
148: TESTDIR(ResourceDir, "$SIMHOME/res");
149:
150: { extern char *TCL_Library, *TK_Library;
151: TCL_Library = TK_Library = ResourceDir;
152: }
153:
154: if (lost) {
155: fprintf(stderr,
156: "Please check the environment or reinstall Micropolis and try again! Sorry!\n");
157: sim_exit(1); // Just sets tkMustExit and ExitReturn
158: return;
159: }
160:
161: gettimeofday(&now_time, NULL);
162: last_now_time = now_time;
163: }
164:
165:
166: void
167: sim_init(void)
168: {
169: gettimeofday(&start_time, NULL);
170: gettimeofday(&beat_time, NULL);
171:
172: signal_init();
173:
174: UserSoundOn = 1;
175: MustUpdateOptions = 1;
176: HaveLastMessage = 0;
177: ScenarioID = 0;
178: StartingYear = 1900;
179: tileSynch = 0x01;
180: sim_skips = sim_skip = 0;
181: autoGo = 1;
182: CityTax = 7;
183: CityTime = 50;
184: NoDisasters = 0;
185: PunishCnt = 0;
186: autoBulldoze = 1;
187: autoBudget = 1;
188: MesNum = 0;
189: LastMesTime = 0;
190: flagBlink = 1;
191: SimSpeed = 3;
192: ChangeEval();
193: MessagePort = 0;
194: MesX = 0;
195: MesY = 0;
196: sim_paused = 0;
197: sim_loops = 0;
198: InitSimLoad = 2;
199: tkMustExit = 0;
200: ExitReturn = 0;
201:
202: InitializeSound();
203: initMapArrays();
204: initGraphs();
205: InitFundingLevel();
206: #if 0
207: loadObjectData();
208: #endif
209: setUpMapProcs();
210: StopEarthquake();
211: ResetMapState();
212: ResetEditorState();
213: ClearMap();
214: InitWillStuff();
215: SetFunds(5000);
216: SetGameLevelFunds(StartupGameLevel);
217: setSpeed(0);
218: setSkips(0);
219: }
220:
221:
222: int triedToBailOnce = 0;
223:
224: void
225: SignalExitHandler()
226: {
227: if (triedToBailOnce) {
228: exit(-1);
229: } else {
230: triedToBailOnce = 1;
231: fprintf(stderr, "\nMicropolis has been terminated by a signal.\n");
232: fprintf(stderr, "Pick a window -- you're leaving!\n\n");
233: fflush(stderr);
234: sim_really_exit(-1);
235: }
236: }
237:
238:
239: signal_init()
240: {
241: signal(SIGHUP, (void (*)())SignalExitHandler);
242: signal(SIGINT, (void (*)())SignalExitHandler);
243: signal(SIGQUIT, (void (*)())SignalExitHandler);
244: signal(SIGTERM, (void (*)())SignalExitHandler);
245: }
246:
247:
248: void
249: sim_update()
250: {
251: gettimeofday(&now_time, NULL);
252:
253: flagBlink = (now_time.tv_usec < 500000) ? 1 : -1;
254:
255: if (SimSpeed && !heat_steps) {
256: TilesAnimated = 0;
257: }
258:
259: sim_update_editors();
260:
261: sim_update_maps();
262: sim_update_graphs();
263: sim_update_budgets();
264: sim_update_evaluations();
265:
266: UpdateFlush();
267: }
268:
269:
270: sim_update_editors(void)
271: {
272: SimView *view;
273:
274: for (view = sim->editor; view != NULL; view = view->next) {
275: #if 1
276: CancelRedrawView(view);
277: view->invalid = 1;
278: DoUpdateEditor(view);
279: #else
280: EventuallyRedrawView(view);
281: #endif
282: }
283:
284: DoUpdateHeads();
285: }
286:
287:
288: sim_update_maps(void)
289: {
290: SimView *view;
291: int i;
292:
293: for (view = sim->map; view != NULL; view = view->next) {
294: int mustUpdateMap =
295: NewMapFlags[view->map_state] || NewMap || ShakeNow;
296: if (mustUpdateMap) {
297: view->invalid = 1;
298: }
299: if (view->invalid) {
300: #if 1
301: if (mustUpdateMap) {
302: //fprintf(stderr, "sim_update_maps mustUpdateMap\n");
303: // view->skip = 0;
304: }
305: if (DoUpdateMap(view)) {
306: // CancelRedrawView(view);
307: // view->invalid = 1;
308: }
309: #else
310: EventuallyRedrawView(view);
311: #endif
312: }
313: }
314:
315: NewMap = 0;
316: for (i = 0; i < NMAPS; i++) {
317: NewMapFlags[i] = 0;
318: }
319: }
320:
321:
322: sim_update_graphs(void)
323: {
324: graphDoer();
325: }
326:
327:
328: sim_update_budgets(void)
329: {
330: if ((sim_skips != 0) &&
331: (sim_skip != 0)) {
332: return;
333: }
334:
335: UpdateBudgetWindow();
336: }
337:
338:
339: sim_update_evaluations(void)
340: {
341: if ((sim_skips != 0) &&
342: (sim_skip != 0)) {
343: return;
344: }
345:
346: scoreDoer();
347: }
348:
349:
350: #ifdef CAM
351:
352: sim_update_cams(void)
353: {
354: SimCam *scam;
355:
356: if ((sim_skips != 0) &&
357: (sim_skip != 0)) {
358: return;
359: }
360:
361: for (scam = sim->scam; scam != NULL; scam = scam->next) {
362: CancelRedrawView(scam);
363: scam->invalid = 1;
364: handle_scam(scam);
365: }
366: }
367:
368: #endif /* CAM */
369:
370:
371: short *CellSrc = NULL;
372: short *CellDst = NULL;
373:
374: #define SRCCOL (WORLD_Y + 2)
375: #define DSTCOL WORLD_Y
376:
377: #define CLIPPER_LOOP_BODY(CODE) \
378: src = CellSrc; dst = CellDst; \
379: for (x = 0; x < WORLD_X;) { \
380: short nw, n, ne, w, c, e, sw, s, se; \
381: \
382: src = CellSrc + (x * SRCCOL); dst = CellDst + (x * DSTCOL); \
383: w = src[0]; c = src[SRCCOL]; e = src[2 * SRCCOL]; \
384: sw = src[1]; s = src[SRCCOL + 1]; se = src[(2 * SRCCOL) + 1]; \
385: \
386: for (y = 0; y < WORLD_Y; y++) { \
387: nw = w; w = sw; sw = src[2]; \
388: n = c; c = s; s = src[SRCCOL + 2]; \
389: ne = e; e = se; se = src[(2 * SRCCOL) + 2]; \
390: { CODE } \
391: src++; dst++; \
392: } \
393: x++; /* src += SRCCOL - 3; dst += DSTCOL - 1; */ \
394: src = CellSrc + ((x + 1) * SRCCOL) - 3; dst = CellDst + ((x + 1) * DSTCOL) - 1; \
395: \
396: nw = src[1]; n = src[SRCCOL + 1]; ne = src[(2 * SRCCOL) + 1]; \
397: w = src[2]; c = src[SRCCOL + 2]; e = src[(2 * SRCCOL) + 2]; \
398: \
399: for (y = WORLD_Y - 1; y >= 0; y--) { \
400: sw = w; w = nw; nw = src[0]; \
401: s = c; c = n; n = src[SRCCOL]; \
402: se = e; e = ne; ne = src[2 * SRCCOL]; \
403: { CODE } \
404: src--; dst--; \
405: } \
406: x++; /* src += SRCCOL + 3; dst += DSTCOL + 1; */ \
407: }
408:
409: void
410: sim_heat(void)
411: {
412: int x, y, l, r, u, d;
413: static int a = 0;
414: short *src, *dst;
415: register int fl = heat_flow;
416:
417: if (CellSrc == NULL) {
418: CellSrc = (short *)ckalloc((WORLD_X + 2) * (WORLD_Y + 2) * sizeof (short));
419: CellDst = &Map[0][0];
420: }
421:
422: src = CellSrc + SRCCOL + 1;
423: dst = CellDst;
424:
425: /*
426: * Copy wrapping edges:
427: *
428: * 0 ff f0 f1 ... fe ff f0
429: *
430: * 1 0f 00 01 ... 0e 0f 00
431: * 2 1f 10 11 ... 1e 1f 10
432: * .. .. .. .. .. ..
433: * ef e0 e1 ... ee ef e0
434: * h ff f0 f1 ... fe ff f0
435: *
436: * h+1 0f 00 01 ... 0e 0f 00
437: *
438: * wrap value: effect:
439: * 0 no effect
440: * 1 copy future=>past, no wrap
441: * 2 no copy, wrap edges
442: * 3 copy future=>past, wrap edges
443: * 4 copy future=>past, same edges
444: */
445:
446: switch (heat_wrap) {
447: case 0:
448: break;
449: case 1:
450: for (x = 0; x < WORLD_X; x++) {
451: memcpy(src, dst, WORLD_Y * sizeof (short));
452: src += SRCCOL;
453: dst += DSTCOL;
454: }
455: break;
456: case 2:
457: for (x = 0; x < WORLD_X; x++) {
458: src[-1] = src[WORLD_Y - 1];
459: src[WORLD_Y] = src[0];
460: src += SRCCOL;
461: dst += DSTCOL;
462: }
463: memcpy(CellSrc,CellSrc + (SRCCOL * WORLD_X),
464: SRCCOL * sizeof (short));
465: memcpy(CellSrc + SRCCOL * (WORLD_X + 1), CellSrc + SRCCOL,
466: SRCCOL * sizeof (short));
467: break;
468: case 3:
469: for (x = 0; x < WORLD_X; x++) {
470: memcpy(src, dst, WORLD_Y * sizeof (short));
471: src[-1] = src[WORLD_Y - 1];
472: src[WORLD_Y] = src[0];
473: src += SRCCOL;
474: dst += DSTCOL;
475: }
476: memcpy(CellSrc, CellSrc + (SRCCOL * WORLD_X),
477: SRCCOL * sizeof (short));
478: memcpy(CellSrc + SRCCOL * (WORLD_X + 1), CellSrc + SRCCOL,
479: SRCCOL * sizeof (short));
480: break;
481: case 4:
482: src[0] = dst[0];
483: src[1 + WORLD_Y] = dst[WORLD_Y - 1];
484: src[(1 + WORLD_X) * SRCCOL] = dst[(WORLD_X - 1) * DSTCOL];
485: src[((2 + WORLD_X) * SRCCOL) - 1] = dst[(WORLD_X * WORLD_Y) - 1];
486: for (x = 0; x < WORLD_X; x++) {
487: memcpy(src, dst, WORLD_Y * sizeof (short));
488: src[-1] = src[0];
489: src[WORLD_Y] = src[WORLD_Y - 1];
490: src += SRCCOL;
491: dst += DSTCOL;
492: }
493: memcpy(CellSrc + (SRCCOL * (WORLD_X + 1)), CellSrc + (SRCCOL * WORLD_X),
494: SRCCOL * sizeof (short));
495: memcpy(CellSrc, CellSrc + SRCCOL,
496: SRCCOL * sizeof (short));
497: break;
498: }
499:
500:
501: switch (heat_rule) {
502:
503: case 0:
504: #define HEAT \
505: a += nw + n + ne + w + e + sw + s + se + fl; \
506: dst[0] = ((a >> 3) & LOMASK) | \
507: (ANIMBIT | BURNBIT | BULLBIT); \
508: a &= 7;
509:
510: CLIPPER_LOOP_BODY(HEAT);
511: break;
512:
513: case 1:
514: #define ECOMASK 0x3fc
515: #define ECO \
516: c -= fl; n -= fl; s -= fl; e -= fl; w -= fl; \
517: ne -= fl; nw -= fl; se -= fl; sw -= fl; \
518: \
519: /* anneal */ \
520: { int sum = (c&1) + (n&1) + (s&1) + (e&1) + (w&1) + \
521: (ne&1) + (nw&1) + (se&1) + (sw&1), cell; \
522: if (((sum > 5) || (sum == 4))) { \
523: /* brian's brain */ \
524: cell = ((c <<1) & (0x3fc)) | \
525: (((((c >>1)&3) == 0) && \
526: (((n&2) + (s&2) + (e&2) + (w&2) + \
527: (ne&2) + (nw&2) + (se&2) + (sw&2)) == (2 <<1)) \
528: ) ? 2 : 0) | \
529: 1; \
530: } else { \
531: /* anti-life */ \
532: sum = ((n&2) + (s&2) + (e&2) + (w&2) + \
533: (ne&2) + (nw&2) + (se&2) + (sw&2)) >>1; \
534: cell = (((c ^ 2) <<1) & ECOMASK) | \
535: ((c&2) ? ((sum != 5) ? 2 : 0) \
536: : (((sum != 5) && (sum != 6)) ? 2 : 0)); \
537: } \
538: dst[0] = ((fl + cell) & LOMASK) | \
539: (ANIMBIT | BURNBIT | BULLBIT); \
540: } \
541: c += fl; n += fl; s += fl; e += fl; w += fl; \
542: ne += fl; nw += fl; se += fl; sw += fl;
543:
544: CLIPPER_LOOP_BODY(ECO);
545: break;
546: }
547: }
548:
549:
550: void
551: sim_timeout_loop(short doSim)
552: {
553: if (SimSpeed) {
554: sim_loop(doSim);
555: }
556: DoTimeoutListen();
557: }
558:
559:
560: sim_loop(int doSim)
561: {
562: #ifdef CAM
563: if (!sim_just_cam) {
564: #endif
565: if (heat_steps) {
566: int j;
567:
568: for (j = 0; j < heat_steps; j++) {
569: sim_heat();
570: }
571:
572: MoveObjects();
573: /*
574: InvalidateMaps();
575: */
576: NewMap = 1;
577: } else {
578: if (doSim) {
579: SimFrame();
580: }
581: MoveObjects();
582: }
583:
584: sim_loops++;
585: sim_update();
586: #ifdef CAM
587: } else {
588: sim_update_cams();
589: UpdateFlush();
590: DoTimeoutListen();
591: }
592: #endif
593: }
594:
595:
596: int
597: MatchArg(char *arg, char *pat)
598: {
599: while (*pat && *arg) {
600: if (tolower(*arg) != tolower(*pat)) {
601: if (*pat == '_') {
602: pat++;
603: continue;
604: }
605: return (0);
606: }
607: arg++; pat++;
608: }
609: return (*arg == '\0');
610: }
611:
612:
613: int
614: main(int argc, char *argv[])
615: {
616: int c, errflg = 0;
617: extern int isatty();
618:
619: printf("Welcome to X11 Multi Player Micropolis version %s by Will Wright, Don Hopkins.\n",
620: MicropolisVersion);
621: printf("Copyright (C) 2002 by Electronic Arts, Maxis. All rights reserved.\n");
622:
623: while (!errflg &&
624: !tkMustExit &&
625: (c = getopt(argc, argv, "tcwmSR:gs:l:")) != -1) {
626: switch (c) {
627:
628: case 't': /* TTY mode */
629: sim_tty = isatty(0);
630: break;
631:
632: case 'c': /* Create Own Colormap */
633: { extern int TK_CreateColormap;
634: TK_CreateColormap = 1;
635: }
636: break;
637:
638: case 'w': /* Wire Mode (don't use shared memory) */
639: WireMode = 1;
640: break;
641:
642: case 'm': /* Multi Player Mode */
643: MultiPlayerMode = 1;
644: break;
645:
646: case 'S': /* Sugar Mode */
647: SugarMode = 1;
648: break;
649:
650: case 'R': /* Root Window ID */
651: c = atoi(optarg);
652: if (c) {
653: tk_RootWindow = c;
654: } else {
655: errflg = 1;
656: }
657: break;
658:
659: case 'g': /* Generate New Terrain */
660: if (Startup) {
661: errflg = 1;
662: } else {
663: Startup = -1;
664: }
665: break;
666:
667: case 'l': /* Level */
668: c = atoi(optarg);
669: if (!c) {
670: if (MatchArg(optarg, "easy")) {
671: c = 1;
672: } else if (MatchArg(optarg, "medium")) {
673: c = 2;
674: } else if (MatchArg(optarg, "hard")) {
675: c = 3;
676: }
677: }
678: if ((c < 1) || (c > 3)) {
679: errflg = 1;
680: } else {
681: StartupGameLevel = c - 1;
682: }
683: break;
684:
685: case 's': /* Scenario <name> */
686: if (Startup)
687: errflg++;
688: else {
689: c = atoi(optarg);
690: if (!c) {
691: if (MatchArg(optarg, "Dullsville")) {
692: c = 1;
693: } else if (MatchArg(optarg, "San_Francisco")) {
694: c = 2;
695: } else if (MatchArg(optarg, "Hamburg")) {
696: c = 3;
697: } else if (MatchArg(optarg, "Bern")) {
698: c = 4;
699: } else if (MatchArg(optarg, "Tokyo")) {
700: c = 5;
701: } else if (MatchArg(optarg, "Detroit")) {
702: c = 6;
703: } else if (MatchArg(optarg, "Boston")) {
704: c = 7;
705: } else if (MatchArg(optarg, "Rio_de_Janeiro")) {
706: c = 8;
707: }
708: }
709: if ((c < 1) || (c > 8)) {
710: errflg = 1;
711: } else {
712: Startup = c;
713: }
714: }
715: break;
716:
717: case 'd': /* Display <name> */
718: { char *d = Displays;
719:
720: if (d == NULL) {
721: Displays = malloc(strlen(optarg) + 3);
722: sprintf(Displays, "{%s}", optarg);
723:
724: if (strchr(optarg, ':') != NULL) {
725: FirstDisplay = malloc(strlen(optarg) + 1);
726: strcpy(FirstDisplay, optarg);
727: } else {
728: FirstDisplay = malloc(strlen(optarg) + 3);
729: sprintf(FirstDisplay, "%s:0", optarg);
730: }
731: } else {
732: /* Implicitly set multi player mode if multiple displays given. */
733: MultiPlayerMode = 1;
734: Displays = malloc(strlen(Displays) + strlen(optarg) + 4);
735: sprintf(Displays, "%s {%s}", d, optarg);
736: free(d);
737: }
738: }
739: break;
740:
741: case '?':
742: errflg++;
743: break;
744: }
745: }
746:
747: if (!errflg &&
748: !tkMustExit) {
749: if ((Startup == -1) ||
750: (Startup == -2)) {
751: /* Generate New City */
752: if ((optind != argc) && (optind != argc - 1)) {
753: errflg = 1;
754: } else {
755: if (optind == argc - 1)
756: StartupName = argv[optind];
757: }
758: } else if (Startup > 0) {
759: /* Scenario */
760: } else if (optind == argc - 1) {
761: /* Load City */
762: Startup = -2;
763: StartupName = argv[optind];
764: } else if (optind == argc) {
765: /* No arguments */
766: } else {
767: errflg = 1;
768: }
769: }
770:
771: if (errflg) {
772: fprintf(stderr,
773: "usage: %s\n", argv[0]);
774: fprintf(stderr,
775: " [-s(cenario) number|name]\n");
776: fprintf(stderr,
777: " [-g(enerate random map and start playing)\n");
778: fprintf(stderr,
779: " [-l(evel) number|name]\n");
780: fprintf(stderr,
781: " [-w(ire mode: use X11 networking without shared memory)]\n");
782: fprintf(stderr,
783: " [-t(ty mode: interactive TCL session on stdin/stdout)]\n");
784: fprintf(stderr,
785: " [-c(olormap mode: create own X11 colormap on 8 bit screens)]\n");
786: fprintf(stderr,
787: " [-S(ugar mode: enable OLPC Sugar user interface integration)]\n");
788: fprintf(stderr,
789: " [-m(ulti player mode: enable adding multiple players via X11)]\n");
790: fprintf(stderr,
791: " [NewCityName]\n");
792: fprintf(stderr,
793: " [SavedFileName.city]\n");
794: fprintf(stderr,
795: "The game level and NewCityName argument are optional, and only apply when\n");
796: fprintf(stderr,
797: "starting a new city or generating new terrain.\n");
798: fprintf(stderr,
799: "Game levels include: 1: Easy, 2: Medium, 3: Hard\n");
800: fprintf(stderr,
801: "Scenarios include: 1: Dullsville, 2: San_Francisco, 3: Hamburg, 4: Bern,\n");
802: fprintf(stderr,
803: " 5: Tokyo, 6: Detroit, 7: Boston, 8: Rio_de_Janeiro\n");
804: fflush(stderr);
805: sim_exit(0); // Just sets tkMustExit and ExitReturn
806: }
807:
808: if ((!tkMustExit) &&
809: (Displays == NULL)) {
810: char *d = getenv("DISPLAY");
811:
812: if (d == NULL) d = ":0";
813:
814: Displays = malloc(strlen(d) + 3);
815: sprintf(Displays, "{%s}", d);
816: if (strchr(d, ':') != NULL) {
817: FirstDisplay = malloc(strlen(d) + 1);
818: strcpy(FirstDisplay, d);
819: } else {
820: FirstDisplay = malloc(strlen(d) + 3);
821: sprintf(FirstDisplay, "%s:0", d);
822: }
823: }
824:
825: if (!tkMustExit) {
826: env_init();
827: }
828:
829: if (!tkMustExit) {
830: tk_main();
831: }
832:
833: exit (ExitReturn);
834: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.