![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to g_map.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_map.c CVS log | Up to [Micropolis - Activity] / micropolis / src / sim |
1.1 root 1: /* g_map.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 VAL_NONE 0
66: #define VAL_LOW 1
67: #define VAL_MEDIUM 2
68: #define VAL_HIGH 3
69: #define VAL_VERYHIGH 4
70: #define VAL_PLUS 5
71: #define VAL_VERYPLUS 6
72: #define VAL_MINUS 7
73: #define VAL_VERYMINUS 8
74:
75: short valMap[] = {
76: -1, COLOR_LIGHTGRAY, COLOR_YELLOW, COLOR_ORANGE, COLOR_RED,
77: COLOR_DARKGREEN, COLOR_LIGHTGREEN, COLOR_ORANGE, COLOR_YELLOW
78: };
79:
80: short valGrayMap[] = {
81: -1, 31, 127, 191, 255,
82: 223, 255, 31, 0
83: };
84:
85:
86: int (*mapProcs[NMAPS])();
87:
88: int drawAll(SimView *view);
89: int drawRes(SimView *view);
90: int drawCom(SimView *view);
91: int drawInd(SimView *view);
92: int drawPower(SimView *view);
93: int drawLilTransMap(SimView *view);
94: int drawPopDensity(SimView *view);
95: int drawRateOfGrowth(SimView *view);
96: int drawTrafMap(SimView *view);
97: int drawPolMap(SimView *view);
98: int drawCrimeMap(SimView *view);
99: int drawLandMap(SimView *view);
100: int drawFireRadius(SimView *view);
101: int drawPoliceRadius(SimView *view);
102: int drawDynamic(SimView *view);
103:
104:
105: short GetCI(short x)
106: {
107: if (x < 50) return(VAL_NONE);
108: if (x < 100) return(VAL_LOW);
109: if (x < 150) return(VAL_MEDIUM);
110: if (x < 200) return(VAL_HIGH);
111: return(VAL_VERYHIGH);
112: }
113:
114:
115: drawPopDensity(SimView *view)
116: {
117: short x, y;
118:
119: drawAll(view);
120: for (x = 0; x < HWLDX; x++) {
121: for (y = 0; y < HWLDY; y++) {
122: maybeDrawRect(view, GetCI(PopDensity[x][y]),
123: x * 6, y * 6, 6, 6);
124: }
125: }
126: }
127:
128:
129: drawRateOfGrowth(SimView *view)
130: {
131: short x, y;
132:
133: drawAll(view);
134: for (x = 0; x < SmX; x++) {
135: for (y = 0; y < SmY; y++) {
136: short val, z = RateOGMem[x][y];
137:
138: if (z > 100) val = VAL_VERYPLUS;
139: else {
140: if (z > 20) val = VAL_PLUS;
141: else {
142: if (z < -100) val = VAL_VERYMINUS;
143: else {
144: if (z < -20) val = VAL_MINUS;
145: else val = VAL_NONE;
146: }
147: }
148: }
149: maybeDrawRect(view, val,
150: x * 24, y * 24, 24, 24);
151: }
152: }
153: }
154:
155:
156: drawTrafMap(SimView *view)
157: {
158: short x;
159: short y;
160:
161: drawLilTransMap(view);
162:
163: for (x = 0; x < HWLDX; x++) {
164: for (y = 0; y < HWLDY; y++) {
165: maybeDrawRect(view, GetCI(TrfDensity[x][y]),
166: x * 6, y * 6, 6, 6);
167: }
168: }
169: }
170:
171:
172: drawPolMap(SimView *view)
173: {
174: short x, y;
175:
176: drawAll(view);
177:
178: for (x = 0; x < HWLDX; x++) {
179: for (y = 0; y < HWLDY; y++) {
180: maybeDrawRect(view, GetCI(10 + PollutionMem[x][y]),
181: x * 6, y * 6, 6, 6);
182: }
183: }
184: }
185:
186:
187: drawCrimeMap(SimView *view)
188: {
189: short x, y;
190:
191: drawAll(view);
192:
193: for (x = 0; x < HWLDX; x++) {
194: for (y = 0; y < HWLDY; y++) {
195: maybeDrawRect(view, GetCI(CrimeMem[x][y]),
196: x * 6, y * 6, 6, 6);
197: }
198: }
199: }
200:
201:
202: drawLandMap(SimView *view)
203: {
204: short x, y;
205:
206: drawAll(view);
207:
208: for (x = 0; x < HWLDX; x++) {
209: for (y = 0; y < HWLDY; y++) {
210: maybeDrawRect(view, GetCI(LandValueMem[x][y]),
211: x * 6, y * 6, 6, 6);
212: }
213: }
214: }
215:
216:
217: drawFireRadius(SimView *view)
218: {
219: short x, y;
220:
221: drawAll(view);
222: for (x = 0; x < SmY; x++) {
223: for (y = 0; y < SmY; y++) {
224: maybeDrawRect(view, GetCI(FireRate[x][y]),
225: x * 24, y * 24, 24, 24);
226: }
227: }
228: }
229:
230:
231: drawPoliceRadius(SimView *view)
232: {
233: short x, y;
234:
235: drawAll(view);
236: for (x = 0; x < SmX; x++) {
237: for (y = 0; y < SmY; y++) {
238: maybeDrawRect(view, GetCI(PoliceMapEffect[x][y]),
239: x * 24, y * 24, 24, 24);
240: }
241: }
242: }
243:
244:
245: setUpMapProcs(void)
246: {
247: mapProcs[ALMAP] = drawAll;
248: mapProcs[REMAP] = drawRes;
249: mapProcs[COMAP] = drawCom;
250: mapProcs[INMAP] = drawInd;
251: mapProcs[PRMAP] = drawPower;
252: mapProcs[RDMAP] = drawLilTransMap;
253: mapProcs[PDMAP] = drawPopDensity;
254: mapProcs[RGMAP] = drawRateOfGrowth;
255: mapProcs[TDMAP] = drawTrafMap;
256: mapProcs[PLMAP] = drawPolMap;
257: mapProcs[CRMAP] = drawCrimeMap;
258: mapProcs[LVMAP] = drawLandMap;
259: mapProcs[FIMAP] = drawFireRadius;
260: mapProcs[POMAP] = drawPoliceRadius;
261: mapProcs[DYMAP] = drawDynamic;
262: }
263:
264:
265: MemDrawMap(SimView *view)
266: {
267: (*mapProcs[view->map_state])(view);
268: if (!view->x->color) {
269: ditherMap(view);
270: XSetForeground(view->x->dpy, view->x->gc, view->pixels[COLOR_BLACK]);
271: XSetBackground(view->x->dpy, view->x->gc, view->pixels[COLOR_WHITE]);
272: XPutImage(view->x->dpy, view->pixmap, view->x->gc, view->image,
273: 0, 0, 0, 0, view->m_width, view->m_height);
274: }
275: }
276:
277:
278: ditherMap(SimView *view)
279: {
280: int i, x, y, width, height;
281: int err, pixel1, pixel8;
282: int line_bytes1 = view->line_bytes;
283: int line_bytes8 = view->line_bytes8;
284: unsigned char *image1 = view->data;
285: unsigned char *image8 = view->data8;
286: int *errors;
287:
288: width = view->m_width; height = view->m_height;
289:
290: errors = (int *)malloc(sizeof(int) * (width));
291:
292: for (i = 0; i < width; i++)
293: errors[i] = (Rand16() & 15) - 7;
294:
295: err = (Rand16() & 15) - 7;
296:
297: for (y = 0; y < height; y += 2) {
298: unsigned char *i1 = image1;
299: unsigned char *i8 = image8;
300:
301: image1 += line_bytes1;
302: image8 += line_bytes8;
303:
304: for (x = 0; x < width; x += 8) {
305: pixel1 = 0;
306: for (i = 0; i < 8; i++) {
307: pixel1 <<= 1;
308: pixel8 = *(i8++) + err + errors[x + i];
309: if (pixel8 > 127) {
310: err = pixel8 - 255;
311: } else {
312: pixel1 |= 1;
313: err = pixel8;
314: }
315: errors[x + i] = err/2;
316: err = err/2;
317: }
318: *(i1++) = pixel1;
319: }
320:
321: i1 = image1 + (width / 8) - 1;
322: i8 = image8 + width - 1;
323:
324: image1 += line_bytes1;
325: image8 += line_bytes8;
326:
327: for (x = width - 8; x >= 0; x -= 8) {
328: pixel1 = 0;
329: for (i = 7; i >= 0; i--) {
330: pixel1 >>= 1;
331: pixel8 = *(i8--) + err + errors[x + i];
332: if (pixel8 > 127) {
333: err = pixel8 - 255;
334: } else {
335: pixel1 |= 128;
336: err = pixel8;
337: }
338: errors[x + i] = err/2;
339: err = err/2;
340: }
341: *(i1--) = pixel1;
342: }
343: }
344:
345: free(errors);
346: }
347:
348:
349: maybeDrawRect(SimView *view, int val,
350: int x, int y, int w, int h)
351: {
352: if (val == VAL_NONE) return;
353:
354: if (view->x->color) {
355: drawRect(view, view->pixels[valMap[val]], 0, x, y, w, h);
356: } else {
357: drawRect(view, valGrayMap[val], 1, x, y, w, h);
358: }
359: }
360:
361:
362: drawRect(SimView *view, int pixel, int solid,
363: int x, int y, int w, int h)
364: {
365: int W = view->m_width, H = view->m_height;
366:
367: if (x < 0) {
368: if ((w += x) < 0) w = 0;
369: x = 0;
370: } else if (x > W) {
371: x = 0; w = 0;
372: }
373: if (x + w > W) {
374: w = W - x;
375: }
376: if (y < 0) {
377: if ((h += y) < 0) h = 0;
378: y = 0;
379: } else if (y > H) {
380: y = 0; h = 0;
381: }
382: if (y + h > H) {
383: h = H - y;
384: }
385:
386: if (w && h) {
387: int i, j, stipple = (x ^ y) & 1;
388: unsigned char *data =
389: view->x->color ? view->data : view->data8;
390:
391: /* In the case of black and white, we use an 8 bit buffer and dither it. */
392: int pixelBytes =
393: view->x->color ? view->pixel_bytes : 1;
394: QUAD line =
395: view->x->color ? view->line_bytes : view->line_bytes8;
396:
397: unsigned char *image =
398: &(data[(line * y) + (x * pixelBytes)]);
399:
400: switch (pixelBytes) {
401:
402: case 1:
403: {
404: unsigned char *data =
405: view->data8;
406: unsigned char *image =
407: &data[(line * y) + (x * pixelBytes)];
408:
409: if (solid) {
410: for (i = h; i > 0; i--) {
411: for (j = w; j > 0; j--) {
412: *image = pixel;
413: image++;
414: }
415: image += line - w;
416: }
417: } else {
418: for (i = h; i > 0; i--) {
419: for (j = w; j > 0; j--) {
420: if (stipple++ & 1)
421: *image = pixel;
422: image++;
423: }
424: if (!(w & 1))
425: stipple++;
426: image += line - w;
427: }
428: }
429: }
430: break;
431:
432: case 2:
433: {
434: unsigned short *data =
435: (unsigned short *)view->data;
436: unsigned short *image;
437: line >>= 1; /* Convert from byte offset to short offset */
438: image =
439: &data[(line * y) + x];
440:
441: if (solid) {
442: for (i = h; i > 0; i--) {
443: for (j = w; j > 0; j--) {
444: *image = pixel;
445: image++;
446: }
447: image += line - w;
448: }
449: } else {
450: for (i = h; i > 0; i--) {
451: for (j = w; j > 0; j--) {
452: if (stipple++ & 1)
453: *image = pixel;
454: image++;
455: }
456: if (!(w & 1))
457: stipple++;
458: image += line - w;
459: }
460: }
461: }
462: break;
463:
464: case 3:
465: case 4:
466: {
467: unsigned char *data =
468: (unsigned char *)view->data;
469: unsigned char *image;
470: int bitmapPad = view->x->small_tile_image->bitmap_pad;
471: int rowBytes = view->x->small_tile_image->bytes_per_line;
472: line = rowBytes >> 1; /* Convert from byte offset to short offset */
473: image =
474: &data[(line * y) + x];
475:
476: if (solid) {
477: for (i = h; i > 0; i--) {
478: for (j = w; j > 0; j--) {
479: *(image++) = (pixel >> 0) & 0xff;
480: *(image++) = (pixel >> 8) & 0xff;
481: *(image++) = (pixel >> 16) & 0xff;
482: if (bitmapPad == 32) {
483: image++;
484: }
485: }
486: image += line - w;
487: }
488: } else {
489: for (i = h; i > 0; i--) {
490: for (j = w; j > 0; j--) {
491: if (stipple++ & 1) {
492: *(image++) = (pixel >> 0) & 0xff;
493: *(image++) = (pixel >> 8) & 0xff;
494: *(image++) = (pixel >> 16) & 0xff;
495: if (bitmapPad == 32) {
496: image++;
497: }
498: }
499: }
500: if (!(w & 1)) {
501: stipple++;
502: }
503: image += line - w;
504: }
505: }
506: }
507: break;
508:
509: default:
510: assert(0); /* Undefined depth */
511: break;
512: }
513:
514: }
515: }
516:
517:
518:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.