![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to g_setup.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 g_setup.c CVS log | Up to [Micropolis - Activity] / micropolis / src / sim |
1.1 root 1: /* g_setup.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: #define SIM_SMTILE 385
66: #define SIM_BWTILE 386
67: #define SIM_GSMTILE 388
68: #define SIM_LGTILE 544
69:
70:
71: #define gray25_width 16
72: #define gray25_height 16
73: static unsigned char gray25_bits[] = {
74: 0x77, 0x77,
75: 0xdd, 0xdd,
76: 0x77, 0x77,
77: 0xdd, 0xdd,
78: 0x77, 0x77,
79: 0xdd, 0xdd,
80: 0x77, 0x77,
81: 0xdd, 0xdd,
82: 0x77, 0x77,
83: 0xdd, 0xdd,
84: 0x77, 0x77,
85: 0xdd, 0xdd,
86: 0x77, 0x77,
87: 0xdd, 0xdd,
88: 0x77, 0x77,
89: 0xdd, 0xdd,
90: };
91:
92:
93: #define gray50_width 16
94: #define gray50_height 16
95: static unsigned char gray50_bits[] = {
96: 0x55, 0x55,
97: 0xaa, 0xaa,
98: 0x55, 0x55,
99: 0xaa, 0xaa,
100: 0x55, 0x55,
101: 0xaa, 0xaa,
102: 0x55, 0x55,
103: 0xaa, 0xaa,
104: 0x55, 0x55,
105: 0xaa, 0xaa,
106: 0x55, 0x55,
107: 0xaa, 0xaa,
108: 0x55, 0x55,
109: 0xaa, 0xaa,
110: 0x55, 0x55,
111: 0xaa, 0xaa,
112: };
113:
114:
115: #define gray75_width 16
116: #define gray75_height 16
117: static unsigned char gray75_bits[] = {
118: 0x88, 0x88,
119: 0x22, 0x22,
120: 0x88, 0x88,
121: 0x22, 0x22,
122: 0x88, 0x88,
123: 0x22, 0x22,
124: 0x88, 0x88,
125: 0x22, 0x22,
126: 0x88, 0x88,
127: 0x22, 0x22,
128: 0x88, 0x88,
129: 0x22, 0x22,
130: 0x88, 0x88,
131: 0x22, 0x22,
132: 0x88, 0x88,
133: 0x22, 0x22,
134: };
135:
136: #define vert_width 16
137: #define vert_height 16
138: static unsigned char vert_bits[] = {
139: 0xaa, 0xaa,
140: 0xaa, 0xaa,
141: 0xaa, 0xaa,
142: 0xaa, 0xaa,
143: 0xaa, 0xaa,
144: 0xaa, 0xaa,
145: 0xaa, 0xaa,
146: 0xaa, 0xaa,
147: 0xaa, 0xaa,
148: 0xaa, 0xaa,
149: 0xaa, 0xaa,
150: 0xaa, 0xaa,
151: 0xaa, 0xaa,
152: 0xaa, 0xaa,
153: 0xaa, 0xaa,
154: 0xaa, 0xaa,
155: };
156:
157:
158: #define horiz_width 16
159: #define horiz_height 16
160: static unsigned char horiz_bits[] = {
161: 0xff, 0xff,
162: 0x00, 0x00,
163: 0xff, 0xff,
164: 0x00, 0x00,
165: 0xff, 0xff,
166: 0x00, 0x00,
167: 0xff, 0xff,
168: 0x00, 0x00,
169: 0xff, 0xff,
170: 0x00, 0x00,
171: 0xff, 0xff,
172: 0x00, 0x00,
173: 0xff, 0xff,
174: 0x00, 0x00,
175: 0xff, 0xff,
176: 0x00, 0x00,
177: };
178:
179:
180: #define diag_width 16
181: #define diag_height 16
182: static unsigned char diag_bits[] = {
183: 0x55, 0x55,
184: 0xee, 0xee,
185: 0x55, 0x55,
186: 0xba, 0xbb,
187: 0x55, 0x55,
188: 0xee, 0xee,
189: 0x55, 0x55,
190: 0xba, 0xbb,
191: 0x55, 0x55,
192: 0xee, 0xee,
193: 0x55, 0x55,
194: 0xba, 0xbb,
195: 0x55, 0x55,
196: 0xee, 0xee,
197: 0x55, 0x55,
198: 0xba, 0xbb,
199: };
200:
201:
202: Ptr MickGetHexa(short theID)
203: {
204: Handle theData;
205:
206: theData = GetResource("hexa", theID);
207: return ((Ptr)*theData);
208: }
209:
210:
211: Pixmap *
212: GetObjectXpms(XDisplay *xd, int id, int frames)
213: {
214: int i;
215: Pixmap *pixmaps = (Pixmap *)ckalloc(2 * frames * sizeof (Pixmap));
216: XpmAttributes attributes;
217: char name[256];
218:
219: attributes.visual = Tk_DefaultVisual(xd->screen);
220: attributes.colormap = Tk_DefaultColormap(xd->screen);
221: attributes.depth = Tk_DefaultDepth(xd->screen);
222: attributes.valuemask = XpmVisual | XpmColormap | XpmDepth;
223:
224: for (i = 0; i < frames; i++) {
225: sprintf(name, "%s/images/obj%d-%d.xpm", HomeDir, id, i);
226: if (XpmReadFileToPixmap(xd->dpy,
227: RootWindowOfScreen(xd->screen),
228: name,
229: &pixmaps[i + i], &pixmaps[i + i + 1],
230: &attributes) < 0) {
231: fprintf(stderr,
232: "Uh oh, Micropolis couldn't read the pixmap file \"%s\".\n",
233: name);
234: sim_exit(1); // Just sets tkMustExit and ExitReturn
235: return NULL;
236: }
237: }
238: return (pixmaps);
239: }
240:
241:
242: GetPixmaps(XDisplay *xd)
243: {
244: if (xd->gray25_stipple == None) {
245: xd->gray25_stipple =
246: XCreatePixmapFromBitmapData(xd->dpy, xd->root,
247: gray25_bits, gray25_width, gray25_height,
248: 1, 0, 1);
249: xd->gray50_stipple =
250: XCreatePixmapFromBitmapData(xd->dpy, xd->root,
251: gray50_bits, gray50_width, gray50_height,
252: 1, 0, 1);
253: xd->gray75_stipple =
254: XCreatePixmapFromBitmapData(xd->dpy, xd->root,
255: gray75_bits, gray75_width, gray75_height,
256: 1, 0, 1);
257: xd->vert_stipple =
258: XCreatePixmapFromBitmapData(xd->dpy, xd->root,
259: vert_bits, vert_width, vert_height,
260: 1, 0, 1);
261: xd->horiz_stipple =
262: XCreatePixmapFromBitmapData(xd->dpy, xd->root,
263: horiz_bits, horiz_width, horiz_height,
264: 1, 0, 1);
265: xd->diag_stipple =
266: XCreatePixmapFromBitmapData(xd->dpy, xd->root,
267: diag_bits, diag_width, diag_height,
268: 1, 0, 1);
269: }
270:
271: if (xd->objects == NULL) {
272: Pixmap **pm;
273:
274: xd->objects = pm = (Pixmap **)ckalloc(OBJN * sizeof (Pixmap *));
275:
276: pm[0] = NULL; /* no object number 0 */
277: pm[TRA] = GetObjectXpms(xd, TRA, 5);
278: pm[COP] = GetObjectXpms(xd, COP, 8);
279: pm[AIR] = GetObjectXpms(xd, AIR, 11);
280: pm[SHI] = GetObjectXpms(xd, SHI, 8);
281: pm[GOD] = GetObjectXpms(xd, GOD, 16);
282: pm[TOR] = GetObjectXpms(xd, TOR, 3);
283: pm[EXP] = GetObjectXpms(xd, EXP, 6);
284: pm[BUS] = GetObjectXpms(xd, BUS, 4);
285: }
286: }
287:
288:
289: GetViewTiles(SimView *view)
290: {
291: char name[256];
292: XpmAttributes attributes;
293:
294: attributes.visual = Tk_DefaultVisual(view->x->screen);
295: attributes.colormap = Tk_DefaultColormap(view->x->screen);
296: attributes.depth = Tk_DefaultDepth(view->x->screen);
297: attributes.valuemask = XpmVisual | XpmColormap | XpmDepth;
298:
299: if (view->class == Editor_Class) {
300:
301: sprintf(name, "%s/images/%s", HomeDir,
302: view->x->color ? "tiles.xpm" : "tilesbw.xpm");
303:
304: switch (view->type) {
305:
306: case X_Mem_View:
307: if (view->x->big_tile_image == NULL) {
308: if (XpmReadFileToImage(view->x->dpy, name,
309: &view->x->big_tile_image, NULL,
310: &attributes) < 0) {
311: fprintf(stderr,
312: "Uh oh, Micropolis couldn't read the pixmap file \"%s\".\n",
313: name);
314: sim_exit(1); // Just sets tkMustExit and ExitReturn
315: return;
316: }
317: }
318: view->bigtiles = (unsigned char *)view->x->big_tile_image->data;
319: break;
320:
321: case X_Wire_View:
322: if (view->x->big_tile_pixmap == None) {
323: if (XpmReadFileToPixmap(view->x->dpy,
324: RootWindowOfScreen(view->x->screen),
325: name,
326: &view->x->big_tile_pixmap, NULL,
327: &attributes) < 0) {
328: fprintf(stderr,
329: "Uh oh, Micropolis couldn't read the pixmap file \"%s\".\n",
330: name);
331: sim_exit(1); // Just sets tkMustExit and ExitReturn
332: return;
333: }
334: }
335: break;
336:
337: }
338:
339: } else if (view->class == Map_Class) {
340:
341: if (view->x->small_tile_image == NULL) {
342: if (view->x->color) {
343:
344: sprintf(name, "%s/images/%s", HomeDir, "tilessm.xpm");
345: if (XpmReadFileToImage(view->x->dpy, name,
346: &view->x->small_tile_image, NULL,
347: &attributes) < 0) {
348: fprintf(stderr,
349: "Uh oh, Micropolis couldn't read the pixmap file \"%s\".\n",
350: name);
351: sim_exit(1); // Just sets tkMustExit and ExitReturn
352: return;
353: }
354:
355: } else {
356:
357: view->x->small_tile_image =
358: XCreateImage(view->x->dpy, view->x->visual, 8,
359: ZPixmap,
360: 0, (char *)MickGetHexa(SIM_GSMTILE),
361: 4, 3 * TILE_COUNT, 8, 4);
362:
363: }
364: }
365:
366: { int x, y, b, tile;
367: unsigned char *from, *to;
368: int pixelBytes = view->pixel_bytes;
369: int rowBytes = view->x->small_tile_image->bytes_per_line;
370:
371: if (pixelBytes == 0) {
372: /* handle the case of monochrome display (8 bit map) */
373: pixelBytes = 1;
374: }
375:
376: /* from is 4 pixels wide per 3 pixel wide tile */
377: from = (unsigned char *)view->x->small_tile_image->data;
378: to = (unsigned char *)ckalloc(4 * 4 * TILE_COUNT * pixelBytes);
379: view->smalltiles = to;
380:
381: switch (pixelBytes) {
382:
383: case 1:
384: for (tile = 0; tile < TILE_COUNT; tile++) {
385: for (y = 0; y < 3; y++) {
386: for (x = 0; x < 4; x++) {
387: *to++ = *from++;
388: }
389: }
390: for (x = 0; x < 4; x++) {
391: *to++ = 0;
392: }
393: }
394: break;
395:
396: case 2:
397: for (tile = 0; tile < TILE_COUNT; tile++) {
398: for (y = 0; y < 3; y++) {
399: for (x = 0; x < 4; x++) {
400: *to++ = *from++;
401: *to++ = *from++;
402: }
403: }
404: for (x = 0; x < 4; x++) {
405: *to++ = 0;
406: *to++ = 0;
407: }
408: }
409: break;
410:
411: case 3:
412: case 4:
413: for (tile = 0; tile < TILE_COUNT; tile++) {
414: for (y = 0; y < 3; y++) {
415: for (x = 0; x < 4; x++) {
416: *to++ = *from++;
417: *to++ = *from++;
418: *to++ = *from++;
419: if (pixelBytes == 4) {
420: *to++ = *from++;
421: }
422: }
423: }
424: for (x = 0; x < 4; x++) {
425: *to++ = 0;
426: *to++ = 0;
427: *to++ = 0;
428: if (pixelBytes == 4) {
429: *to++ = 0;
430: }
431: }
432: }
433: break;
434:
435: default:
436: assert(0); /* Undefined depth */
437: break;
438:
439: }
440:
441: }
442: }
443: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.