git.zerfleddert.de Git - micropolis/blob - src/sim/g_bigmap.c

   1 /* g_bigmap.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 int dynamicFilter(int c, int r);
  66 int WireDrawBeegMapRect(SimView *view, short x, short y, short w, short h);
  67
  68 drawBeegMaps()
  69 {
  70   sim_update_editors();
  71 }
  72
  73
  74 MemDrawBeegMapRect(SimView *view, int x, int y, int w, int h)
  75 {
  76   int lineBytes = view->line_bytes;
  77   int pixelBytes = view->pixel_bytes;
  78   QUAD ii, mm;
  79   unsigned short *map;
  80   unsigned short tile;
  81   unsigned char blink = (flagBlink <= 0), *bt = view->bigtiles;
  82   short col, row;
  83   short **have, *ha;
  84
  85   if (x < view->tile_x) {
  86     if ((w -= (view->tile_x - x)) <= 0)
  87       return;
  88     x = view->tile_x;
  89   }
  90   if (y < view->tile_y) {
  91     if ((h -= (view->tile_y - y)) <= 0)
  92       return;
  93     y = view->tile_y;
  94   }
  95   if ((x + w) > (view->tile_x + view->tile_width)) {
  96     if ((w -= ((x + w) - (view->tile_x + view->tile_width))) <= 0)
  97       return;
  98   }
  99   if ((y + h) > (view->tile_y + view->tile_height)) {
 100     if ((h -= ((y + h) - (view->tile_y + view->tile_height))) <= 0)
 101       return;
 102   }
 103
 104   if (view->x->color) {
 105     register unsigned QUAD *image, *mem;
 106
 107     image = (unsigned QUAD *)view->data;
 108     ii = ((lineBytes * h * 16) - 16) / sizeof(unsigned QUAD);
 109     map = (unsigned short *)&Map[x][y];
 110     mm = WORLD_Y - h;
 111     have = view->tiles;
 112
 113     /*
 114      * Huge Berserk Rebel Warthog
 115      */
 116
 117     for (col = 0; col < w; col++) {
 118       ha = &have[col][0];
 119       image = (unsigned QUAD *)(view->data + (col * 16 * pixelBytes));
 120       for (row = 0; row < h; row++, ha++) {
 121         tile = *(map++);
 122         if ((tile & LOMASK) >= TILE_COUNT) tile -= TILE_COUNT;
 123
 124         /* Blink lightning bolt in unpowered zone center */
 125         if (blink && (tile & ZONEBIT) && !(tile & PWRBIT)) {
 126           tile = LIGHTNINGBOLT;
 127         } else {
 128           tile &= LOMASK;
 129         } // if
 130
 131         if (
 132             (tile > 63) &&
 133             (view->dynamic_filter != 0) &&
 134             (dynamicFilter(col + x, row + y) == 0)
 135             ) {
 136           tile = 0;
 137         } // if
 138
 139         /* XXX */
 140         if (tile == *ha) {
 141           image = (unsigned QUAD *)(((unsigned char *)image) +
 142                                     (lineBytes * 16));
 143         } else {
 144           *ha = tile;
 145           mem = (unsigned QUAD *)&(bt[tile * 256 * pixelBytes]);
 146
 147           /* XXX: handle depth for big tiles */
 148 #if 1
 149           /* Very un-rolled loop. */
 150
 151 #define ROW1_8(n) \
 152           image[0] = mem[0+n]; \
 153           image[1] = mem[1+n]; \
 154           image[2] = mem[2+n]; \
 155           image[3] = mem[3+n]; \
 156           image = (unsigned QUAD *)(((unsigned char *)image) + lineBytes);
 157
 158 #define ROW2_8(n) ROW1_8(n) ROW1_8(n+4)
 159 #define ROW4_8(n) ROW2_8(n) ROW2_8(n+8)
 160 #define ROW8_8(n) ROW4_8(n) ROW4_8(n+16)
 161 #define ROW16_8() ROW8_8(0) ROW8_8(32)
 162
 163 #define ROW1_16(n) \
 164       memcpy((char *)image, (char *)mem + (2 * 16 * (n)), 2 * 16); \
 165       image = (unsigned QUAD *)(((unsigned char *)image) + lineBytes);
 166
 167 #define ROW2_16(n) ROW1_16(n) ROW1_16(n+1)
 168 #define ROW4_16(n) ROW2_16(n) ROW2_16(n+2)
 169 #define ROW8_16(n) ROW4_16(n) ROW4_16(n+4)
 170 #define ROW16_16() ROW8_16(0) ROW8_16(8)
 171
 172 #define ROW1_32(n) \
 173       memcpy((char *)image, (char *)mem + (4 * 16 * (n)), 4 * 16); \
 174       image = (unsigned QUAD *)(((unsigned char *)image) + lineBytes);
 175
 176 #define ROW2_32(n) ROW1_32(n) ROW1_32(n+1)
 177 #define ROW4_32(n) ROW2_32(n) ROW2_32(n+2)
 178 #define ROW8_32(n) ROW4_32(n) ROW4_32(n+4)
 179 #define ROW16_32() ROW8_32(0) ROW8_32(8)
 180
 181           switch (view->x->depth) {
 182
 183           case 8:
 184             ROW16_8();
 185             break;
 186
 187           case 15:
 188           case 16:
 189             ROW16_16();
 190             break;
 191
 192           case 24:
 193           case 32:
 194             ROW16_32();
 195             break;
 196
 197           default:
 198             /* XXX: handle different depths */
 199             break;
 200
 201           } // switch
 202
 203 #else
 204           /* Not so un-rolled loop. */
 205
 206           { int i;
 207             for (i = 16; i > 0; i--) {
 208               image[0] = mem[0]; image[1] = mem[1];
 209               image[2] = mem[2]; image[3] = mem[3];
 210               image = (unsigned QUAD *)(((unsigned char *)image) + lineBytes);
 211               mem += 4;
 212             }
 213           } // scope
 214 #endif
 215
 216         } // if
 217
 218       } // for row
 219       image -= ii;
 220       map += mm;
 221     } // for col
 222   } else {
 223     register unsigned short *image, *mem;
 224
 225     image = (unsigned short *)view->data;
 226     ii = ((lineBytes * h * 16) - 2) / sizeof(unsigned short);
 227     map = (unsigned short *)&Map[x][y];
 228     mm = WORLD_Y - h;
 229     have = view->tiles;
 230
 231     for (col = 0; col < w; col++) {
 232       ha = &have[col][0];
 233       image = (unsigned short *)(view->data + (col * 2));
 234       for (row = 0; row < h; row++, ha++) {
 235         tile = *(map++);
 236         if ((tile & LOMASK) >= TILE_COUNT) tile -= TILE_COUNT;
 237
 238         /* Blink lightning bolt in unpowered zone center */
 239         if (blink && (tile & ZONEBIT) && !(tile & PWRBIT))
 240           tile = LIGHTNINGBOLT;
 241         else
 242           tile &= LOMASK;
 243
 244         if (tile == *ha) {
 245           image = (unsigned short *)
 246             (((unsigned char *)image) + (lineBytes * 16));
 247         } else {
 248           *ha = tile;
 249           mem = (unsigned short *)&(bt[tile * 32]);
 250
 251           { char i;
 252             for (i = 16; i > 0; i--) {
 253               *image = *mem;
 254               image = (unsigned short *)(((unsigned char *)image) + lineBytes);
 255               mem++;
 256             }
 257           }
 258         }
 259       }
 260       image -= ii;
 261       map += mm;
 262     }
 263   }
 264 }
 265
 266
 267 WireDrawBeegMapRect(SimView *view, short x, short y, short w, short h)
 268 {
 269   unsigned short *map;
 270   unsigned short tile;
 271   unsigned char blink = (flagBlink <= 0);
 272   short col, row;
 273   QUAD mm;
 274   short **have, *ha;
 275
 276   if (x < view->tile_x) {
 277     if ((w -= (view->tile_x - x)) <= 0)
 278       return;
 279     x = view->tile_x;
 280   }
 281   if (y < view->tile_y) {
 282     if ((h -= (view->tile_y - y)) <= 0)
 283       return;
 284     y = view->tile_y;
 285   }
 286   if ((x + w) > (view->tile_x + view->tile_width)) {
 287     if ((w -= ((x + w) - (view->tile_x + view->tile_width))) <= 0)
 288       return;
 289   }
 290   if ((y + h) > (view->tile_y + view->tile_height)) {
 291     if ((h -= ((y + h) - (view->tile_y + view->tile_height))) <= 0)
 292       return;
 293   }
 294
 295   map = (unsigned short *)&Map[x][y];
 296   mm = WORLD_Y - h;
 297   have = view->tiles;
 298
 299   for (col = 0; col < w; col++) {
 300     ha = &have[col][0];
 301     for (row = 0; row < h; row++, ha++) {
 302       tile = *(map++);
 303       if ((tile & LOMASK) >= TILE_COUNT) tile -= TILE_COUNT;
 304
 305       /* Blink lightning bolt in unpowered zone center */
 306       if (blink && (tile & ZONEBIT) && !(tile & PWRBIT))
 307         tile = LIGHTNINGBOLT;
 308       else
 309         tile &= LOMASK;
 310
 311       if (tile != *ha) {
 312         *ha = tile;
 313         if (view->x->big_tile_pixmap) {
 314           XCopyArea(view->x->dpy, view->x->big_tile_pixmap, view->pixmap,
 315                   view->x->gc, 0, tile * 16, 16, 16,
 316                   col * 16, row * 16);
 317         }
 318       }
 319     }
 320     map += mm;
 321   }
 322 }