Return to g_setup.c CVS log

Up to [Micropolis - Activity] / micropolis / src / sim

Annotation of micropolis/src/sim/g_setup.c, revision 1.1

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.