]> git.zerfleddert.de Git - micropolis/blob - src/sim/g_setup.c
projects / micropolis / blob
? search:


8cd13bacef7e24add9b82ae36fcc3aac69a11b9c
[micropolis] / src / sim / g_setup.c
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 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
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 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 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 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 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 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 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 void
243 GetPixmaps(XDisplay *xd)
244 {
245 if (xd->gray25_stipple == None) {
246 xd->gray25_stipple =
247 XCreatePixmapFromBitmapData(xd->dpy, xd->root,
248 gray25_bits, gray25_width, gray25_height,
249 1, 0, 1);
250 xd->gray50_stipple =
251 XCreatePixmapFromBitmapData(xd->dpy, xd->root,
252 gray50_bits, gray50_width, gray50_height,
253 1, 0, 1);
254 xd->gray75_stipple =
255 XCreatePixmapFromBitmapData(xd->dpy, xd->root,
256 gray75_bits, gray75_width, gray75_height,
257 1, 0, 1);
258 xd->vert_stipple =
259 XCreatePixmapFromBitmapData(xd->dpy, xd->root,
260 vert_bits, vert_width, vert_height,
261 1, 0, 1);
262 xd->horiz_stipple =
263 XCreatePixmapFromBitmapData(xd->dpy, xd->root,
264 horiz_bits, horiz_width, horiz_height,
265 1, 0, 1);
266 xd->diag_stipple =
267 XCreatePixmapFromBitmapData(xd->dpy, xd->root,
268 diag_bits, diag_width, diag_height,
269 1, 0, 1);
270 }
271
272 if (xd->objects == NULL) {
273 Pixmap **pm;
274
275 xd->objects = pm = (Pixmap **)ckalloc(OBJN * sizeof (Pixmap *));
276
277 pm[0] = NULL; /* no object number 0 */
278 pm[TRA] = GetObjectXpms(xd, TRA, 5);
279 pm[COP] = GetObjectXpms(xd, COP, 8);
280 pm[AIR] = GetObjectXpms(xd, AIR, 11);
281 pm[SHI] = GetObjectXpms(xd, SHI, 8);
282 pm[GOD] = GetObjectXpms(xd, GOD, 16);
283 pm[TOR] = GetObjectXpms(xd, TOR, 3);
284 pm[EXP] = GetObjectXpms(xd, EXP, 6);
285 pm[BUS] = GetObjectXpms(xd, BUS, 4);
286 }
287 }
288
289
290 void
291 GetViewTiles(SimView *view)
292 {
293 char name[256];
294 XpmAttributes attributes;
295
296 attributes.visual = Tk_DefaultVisual(view->x->screen);
297 attributes.colormap = Tk_DefaultColormap(view->x->screen);
298 attributes.depth = Tk_DefaultDepth(view->x->screen);
299 attributes.valuemask = XpmVisual | XpmColormap | XpmDepth;
300
301 if (view->class == Editor_Class) {
302
303 sprintf(name, "%s/images/%s", HomeDir,
304 view->x->color ? "tiles.xpm" : "tilesbw.xpm");
305
306 switch (view->type) {
307
308 case X_Mem_View:
309 if (view->x->big_tile_image == NULL) {
310 if (XpmReadFileToImage(view->x->dpy, name,
311 &view->x->big_tile_image, NULL,
312 &attributes) < 0) {
313 fprintf(stderr,
314 "Uh oh, Micropolis couldn't read the pixmap file \"%s\".\n",
315 name);
316 sim_exit(1); // Just sets tkMustExit and ExitReturn
317 return;
318 }
319 }
320 view->bigtiles = (unsigned char *)view->x->big_tile_image->data;
321 break;
322
323 case X_Wire_View:
324 if (view->x->big_tile_pixmap == None) {
325 if (XpmReadFileToPixmap(view->x->dpy,
326 RootWindowOfScreen(view->x->screen),
327 name,
328 &view->x->big_tile_pixmap, NULL,
329 &attributes) < 0) {
330 fprintf(stderr,
331 "Uh oh, Micropolis couldn't read the pixmap file \"%s\".\n",
332 name);
333 sim_exit(1); // Just sets tkMustExit and ExitReturn
334 return;
335 }
336 }
337 break;
338
339 }
340
341 } else if (view->class == Map_Class) {
342
343 if (view->x->small_tile_image == NULL) {
344 if (view->x->color) {
345
346 sprintf(name, "%s/images/%s", HomeDir, "tilessm.xpm");
347 if (XpmReadFileToImage(view->x->dpy, name,
348 &view->x->small_tile_image, NULL,
349 &attributes) < 0) {
350 fprintf(stderr,
351 "Uh oh, Micropolis couldn't read the pixmap file \"%s\".\n",
352 name);
353 sim_exit(1); // Just sets tkMustExit and ExitReturn
354 return;
355 }
356
357 } else {
358
359 view->x->small_tile_image =
360 XCreateImage(view->x->dpy, view->x->visual, 8,
361 ZPixmap,
362 0, (char *)MickGetHexa(SIM_GSMTILE),
363 4, 3 * TILE_COUNT, 8, 4);
364
365 }
366 }
367
368 { int x, y, tile;
369 unsigned char *from, *to;
370 int pixelBytes = view->pixel_bytes;
371
372 if (pixelBytes == 0) {
373 /* handle the case of monochrome display (8 bit map) */
374 pixelBytes = 1;
375 }
376
377 /* from is 4 pixels wide per 3 pixel wide tile */
378 from = (unsigned char *)view->x->small_tile_image->data;
379 to = (unsigned char *)ckalloc(4 * 4 * TILE_COUNT * pixelBytes);
380 view->smalltiles = to;
381
382 switch (pixelBytes) {
383
384 case 1:
385 for (tile = 0; tile < TILE_COUNT; tile++) {
386 for (y = 0; y < 3; y++) {
387 for (x = 0; x < 4; x++) {
388 *to++ = *from++;
389 }
390 }
391 for (x = 0; x < 4; x++) {
392 *to++ = 0;
393 }
394 }
395 break;
396
397 case 2:
398 for (tile = 0; tile < TILE_COUNT; tile++) {
399 for (y = 0; y < 3; y++) {
400 for (x = 0; x < 4; x++) {
401 *to++ = *from++;
402 *to++ = *from++;
403 }
404 }
405 for (x = 0; x < 4; x++) {
406 *to++ = 0;
407 *to++ = 0;
408 }
409 }
410 break;
411
412 case 3:
413 case 4:
414 for (tile = 0; tile < TILE_COUNT; tile++) {
415 for (y = 0; y < 3; y++) {
416 for (x = 0; x < 4; x++) {
417 *to++ = *from++;
418 *to++ = *from++;
419 *to++ = *from++;
420 if (pixelBytes == 4) {
421 *to++ = *from++;
422 }
423 }
424 }
425 for (x = 0; x < 4; x++) {
426 *to++ = 0;
427 *to++ = 0;
428 *to++ = 0;
429 if (pixelBytes == 4) {
430 *to++ = 0;
431 }
432 }
433 }
434 break;
435
436 default:
437 assert(0); /* Undefined depth */
438 break;
439
440 }
441
442 }
443 }
444 }
Micropolis
Impressum, Datenschutz