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           default:
 196             /* XXX: handle different depths */
 197             break;
 198
 199           } // switch
 200
 201 #else
 202           /* Not so un-rolled loop. */
 203
 204           { int i;
 205             for (i = 16; i > 0; i--) {
 206               image[0] = mem[0]; image[1] = mem[1];
 207               image[2] = mem[2]; image[3] = mem[3];
 208               image = (unsigned QUAD *)(((unsigned char *)image) + lineBytes);
 209               mem += 4;
 210             }
 211           } // scope
 212 #endif
 213
 214         } // if
 215
 216       } // for row
 217       image -= ii;
 218       map += mm;
 219     } // for col
 220   } else {
 221     register unsigned short *image, *mem;
 222
 223     image = (unsigned short *)view->data;
 224     ii = ((lineBytes * h * 16) - 2) / sizeof(unsigned short);
 225     map = (unsigned short *)&Map[x][y];
 226     mm = WORLD_Y - h;
 227     have = view->tiles;
 228
 229     for (col = 0; col < w; col++) {
 230       ha = &have[col][0];
 231       image = (unsigned short *)(view->data + (col * 2));
 232       for (row = 0; row < h; row++, ha++) {
 233         tile = *(map++);
 234         if ((tile & LOMASK) >= TILE_COUNT) tile -= TILE_COUNT;
 235
 236         /* Blink lightning bolt in unpowered zone center */
 237         if (blink && (tile & ZONEBIT) && !(tile & PWRBIT))
 238           tile = LIGHTNINGBOLT;
 239         else
 240           tile &= LOMASK;
 241
 242         if (tile == *ha) {
 243           image = (unsigned short *)
 244             (((unsigned char *)image) + (lineBytes * 16));
 245         } else {
 246           *ha = tile;
 247           mem = (unsigned short *)&(bt[tile * 32]);
 248
 249           { char i;
 250             for (i = 16; i > 0; i--) {
 251               *image = *mem;
 252               image = (unsigned short *)(((unsigned char *)image) + lineBytes);
 253               mem++;
 254             }
 255           }
 256         }
 257       }
 258       image -= ii;
 259       map += mm;
 260     }
 261   }
 262 }
 263
 264
 265 WireDrawBeegMapRect(SimView *view, short x, short y, short w, short h)
 266 {
 267   unsigned short *map;
 268   unsigned short tile;
 269   unsigned char blink = (flagBlink <= 0);
 270   short col, row;
 271   QUAD mm;
 272   short **have, *ha;
 273
 274   if (x < view->tile_x) {
 275     if ((w -= (view->tile_x - x)) <= 0)
 276       return;
 277     x = view->tile_x;
 278   }
 279   if (y < view->tile_y) {
 280     if ((h -= (view->tile_y - y)) <= 0)
 281       return;
 282     y = view->tile_y;
 283   }
 284   if ((x + w) > (view->tile_x + view->tile_width)) {
 285     if ((w -= ((x + w) - (view->tile_x + view->tile_width))) <= 0)
 286       return;
 287   }
 288   if ((y + h) > (view->tile_y + view->tile_height)) {
 289     if ((h -= ((y + h) - (view->tile_y + view->tile_height))) <= 0)
 290       return;
 291   }
 292
 293   map = (unsigned short *)&Map[x][y];
 294   mm = WORLD_Y - h;
 295   have = view->tiles;
 296
 297   for (col = 0; col < w; col++) {
 298     ha = &have[col][0];
 299     for (row = 0; row < h; row++, ha++) {
 300       tile = *(map++);
 301       if ((tile & LOMASK) >= TILE_COUNT) tile -= TILE_COUNT;
 302
 303       /* Blink lightning bolt in unpowered zone center */
 304       if (blink && (tile & ZONEBIT) && !(tile & PWRBIT))
 305         tile = LIGHTNINGBOLT;
 306       else
 307         tile &= LOMASK;
 308
 309       if (tile != *ha) {
 310         *ha = tile;
 311         XCopyArea(view->x->dpy, view->x->big_tile_pixmap, view->pixmap,
 312                   view->x->gc, 0, tile * 16, 16, 16,
 313                   col * 16, row * 16);
 314       }
 315     }
 316     map += mm;
 317   }
 318 }