git.zerfleddert.de Git - micropolis/blob

1 /* g_smmaps.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

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"

65 int DynamicData[32];

68 #define DRAW_BEGIN \

69 int col, row; \

70 unsigned short tile; \

71 short *mp; \

72 unsigned char *imageBase; \

73 unsigned char *image; \

74 unsigned QUAD *mem; \

75 unsigned QUAD l; \

76 int lineBytes = view->line_bytes8; \

77 int pixelBytes = view->pixel_bytes; \

78 mp = &Map[0][0]; \

79 imageBase = view->x->color ? view->data : view->data8; \

80 for (col = 0; col < WORLD_X; col++) { \

81 image = imageBase + (3 * pixelBytes * col); \

82 for (row = 0; row < WORLD_Y; row++) { \

83 tile = *(mp++) & LOMASK; \

84 if (tile >= TILE_COUNT) tile -= TILE_COUNT;

87 #define LE_ROW1_8(n) \

88 l = mem[n]; \

89 image[0] = l; \

90 image[1] = l >>8; \

91 image[2] = l >>16; \

92 image += lineBytes;

94 #define LE_ROW1_16(n) \

95 memcpy((char *)image, ((char *)mem) + (n * 4 * 2), (3 * 2)); \

96 image += lineBytes;

98 #define LE_ROW1_24(n) \

99 memcpy((char *)image, ((char *)mem) + (n * 4 * 3), (3 * 3)); \

100 image += lineBytes;

101

102 #define LE_ROW1_32(n) \

103 memcpy((char *)image, ((char *)mem) + (n * 4 * 4), (3 * 4)); \

104 image += lineBytes;

105

106 #define BE_ROW1_8(n) \

107 l = mem[n]; \

108 image[0] = l >>24; \

109 image[1] = l >>16; \

110 image[2] = l >>8; \

111 image += lineBytes;

112

113 #define BE_ROW1_16(n) \

114 l = mem[n]; /* XXX: WRONG. handle depth */ \

115 image[0] = l >>24; \

116 image[1] = l >>16; \

117 image[2] = l >>8; \

118 image += lineBytes;

119

120 #define BE_ROW1_24(n) \

121 l = mem[n]; /* XXX: WRONG. handle depth */ \

122 image[0] = l >>24; \

123 image[1] = l >>16; \

124 image[2] = l >>8; \

125 image += lineBytes;

126

127 #define BE_ROW1_32(n) \

128 l = mem[n]; /* XXX: WRONG. handle depth */ \

129 image[0] = l >>24; \

130 image[1] = l >>16; \

131 image[2] = l >>8; \

132 image += lineBytes;

133

134 #define LE_ROW3_8 LE_ROW1_8(0) LE_ROW1_8(1) LE_ROW1_8(2)

135 #define LE_ROW3_16 LE_ROW1_16(0) LE_ROW1_16(1) LE_ROW1_16(2)

136 #define LE_ROW3_24 LE_ROW1_24(0) LE_ROW1_24(1) LE_ROW1_24(2)

137 #define LE_ROW3_32 LE_ROW1_32(0) LE_ROW1_32(1) LE_ROW1_32(2)

138

139 #define BE_ROW3_8 BE_ROW1_8(0) BE_ROW1_8(1) BE_ROW1_8(2)

140 #define BE_ROW3_16 BE_ROW1_16(0) BE_ROW1_16(1) BE_ROW1_16(2)

141 #define BE_ROW3_24 BE_ROW1_24(0) BE_ROW1_24(1) BE_ROW1_24(2)

142 #define BE_ROW3_32 BE_ROW1_32(0) BE_ROW1_32(1) BE_ROW1_32(2)

143

144 #define ROW3_8 if (view->x->needs_swap) { BE_ROW3_8 } else { LE_ROW3_8 }

145 #define ROW3_16 LE_ROW3_16

146 #define ROW3_24 LE_ROW3_24

147 #define ROW3_32 LE_ROW3_32

148

149 #define ROW3 \

150 switch (view->x->depth) { \

151 case 1: \

152 case 8: \

153 ROW3_8 \

154 break; \

155 case 15: \

156 case 16: \

157 ROW3_16 \

158 break; \

159 case 24: \

160 case 32: \

161 ROW3_32 \

162 break; \

163 default: \

164 assert(0); /* Undefined depth */ \

165 break; \

166 }

167

168 #define DRAW_END \

169 mem = (unsigned QUAD *)&view->smalltiles[tile * 4 * 4 * pixelBytes]; \

170 ROW3 \

171 } \

172 }

173

174

 void drawAll(SimView *view)

176 {

177 DRAW_BEGIN

178 DRAW_END

179 }

180

181

 void drawRes(SimView *view)

183 {

184 DRAW_BEGIN

     if (tile > 422)

186 tile = 0;

187 DRAW_END

188 }

189

190

 void drawCom(SimView *view)

192 {

193 DRAW_BEGIN

     if ((tile > 609) ||

         ((tile >= 232) && (tile < 423)))

196 tile = 0;

197 DRAW_END

198 }

199

200

 void drawInd(SimView *view)

202 {

203 DRAW_BEGIN

     if (((tile >= 240) && (tile <= 611)) ||

         ((tile >= 693) && (tile <= 851)) ||

         ((tile >= 860) && (tile <= 883)) ||

207 (tile >= 932))

208 tile = 0;

209 DRAW_END

210 }

211

212

 void drawLilTransMap(SimView *view)

214 {

215 DRAW_BEGIN

     if ((tile >= 240) ||

         ((tile >= 207) && tile <= 220) ||

218 (tile == 223))

219 tile = 0;

220 DRAW_END

221 }

222

223

224 /* color pixel values */

225 #define UNPOWERED COLOR_LIGHTBLUE

226 #define POWERED COLOR_RED

227 #define CONDUCTIVE COLOR_LIGHTGRAY

228

229

 void drawPower(SimView *view)

231 {

232 short col, row;

233 unsigned short tile;

234 short *mp;

235 unsigned char *image, *imageBase;

236 unsigned QUAD *mem;

237 unsigned QUAD l;

238 int lineBytes = view->line_bytes8;

239 int pixelBytes = view->pixel_bytes;

240

241 int pix;

242 int powered, unpowered, conductive;

243

   if (view->x->color) {

245 powered = view->pixels[POWERED];

246 unpowered = view->pixels[UNPOWERED];

247 conductive = view->pixels[CONDUCTIVE];

248 } else {

249 powered = 255;

250 unpowered = 0;

251 conductive = 127;

252 }

253

   mp = &Map[0][0];

   imageBase = view->x->color ? view->data : view->data8;

256

   for (col = 0; col < WORLD_X; col++) {

     image = imageBase + (3 * pixelBytes * col);

     for (row = 0; row < WORLD_Y; row++) {

260 tile = *(mp++);

261

       if ((tile & LOMASK) >= TILE_COUNT) tile -= TILE_COUNT;

263

       if ((unsigned short)(tile & LOMASK) <= (unsigned short)63) {

265 tile &= LOMASK;

266 pix = -1;

       } else if (tile & ZONEBIT) {

                 pix = (tile & PWRBIT) ? powered : unpowered;

269 } else {

270 if (tile & CONDBIT) {

271 pix = conductive;

272 } else {

273 tile = 0;

274 pix = -1;

275 }

276 }

277

       if (pix < 0) {

                 mem = (unsigned QUAD *)&view->smalltiles[tile * 4 * 4 * pixelBytes];

280 ROW3

281 } else {

                 switch (view->x->depth) {

283

284 case 1:

285 case 8:

                   image[0] = image[1] = image[2] = pix;

287 image += lineBytes;

                   image[0] = image[1] = image[2] = pix;

289 image += lineBytes;

                   image[0] = image[1] = image[2] = pix;

291 image += lineBytes;

292 break;

293

294 case 15:

295 case 16:

296 {

297 unsigned short *p;

298 p = (unsigned short *)image;

                         if (view->x->x_big_endian) {

                           p[0] = p[1] = p[2] = ((pix & 0xff) << 8) | ((pix & 0xff00) >> 8);

301 } else {

                           p[0] = p[1] = p[2] = pix;

303 }

304 image += lineBytes;

305 p = (unsigned short *)image;

                         if (view->x->x_big_endian) {

                           p[0] = p[1] = p[2] = ((pix & 0xff) << 8) | ((pix & 0xff00) >> 8);

308 } else {

                           p[0] = p[1] = p[2] = pix;

310 }

311 image += lineBytes;

312 p = (unsigned short *)image;

                         if (view->x->x_big_endian) {

                           p[0] = p[1] = p[2] = ((pix & 0xff) << 8) | ((pix & 0xff00) >> 8);

315 } else {

                           p[0] = p[1] = p[2] = pix;

317 }

318 image += lineBytes;

319 }

320 break;

321

322 case 24:

323 case 32:

324 {

325 int x, y;

                         for (y = 0; y < 3; y++) {

327 unsigned char *img =

328 image;

                           for (x = 0; x < 4; x++) {

                                 if (view->x->x_big_endian) {

                                   if (pixelBytes == 4) {

332 img++;

333 } // if

                                   *(img++) = (pix >> 16) & 0xff;

                                   *(img++) = (pix >> 8) & 0xff;

                                   *(img++) = (pix >> 0) & 0xff;

337 } else {

                                   *(img++) = (pix >> 0) & 0xff;

                                   *(img++) = (pix >> 8) & 0xff;

                                   *(img++) = (pix >> 16) & 0xff;

                                   if (pixelBytes == 4) {

342 img++;

343 } // if

344 }

345 } // for x

346 image += lineBytes;

347 } // for y

348 }

349 break;

350

351 default:

                   assert(0); /* Undefined depth */

353 break;

354

355 }

356 }

357 }

358 }

359 }

360

361

 int dynamicFilter(int col, int row)

363 {

364 int r, c, x;

365

366 r = row >>1;

367 c = col >>1;

368

   if (((DynamicData[0] > DynamicData[1]) ||

        (((x = PopDensity[c][r])                 >= DynamicData[0]) &&

        (x                                                               <= DynamicData[1]))) &&

       ((DynamicData[2] > DynamicData[3]) ||

        (((x = RateOGMem[c>>2][r>>2])            >= ((2 * DynamicData[2]) - 256)) &&

        (x                                                               <= ((2 * DynamicData[3]) - 256)))) &&

       ((DynamicData[4] > DynamicData[5]) ||

        (((x = TrfDensity[c][r])                 >= DynamicData[4]) &&

        (x                                                               <= DynamicData[5]))) &&

       ((DynamicData[6] > DynamicData[7]) ||

        (((x = PollutionMem[c][r])               >= DynamicData[6]) &&

        (x                                                               <= DynamicData[7]))) &&

       ((DynamicData[8] > DynamicData[9]) ||

        (((x = CrimeMem[c][r])                   >= DynamicData[8]) &&

        (x                                                               <= DynamicData[9]))) &&

       ((DynamicData[10] > DynamicData[11]) ||

        (((x = LandValueMem[c][r])               >= DynamicData[10]) &&

        (x                                                               <= DynamicData[11]))) &&

       ((DynamicData[12] > DynamicData[13]) ||

        (((x = PoliceMapEffect[c>>2][r>>2]) >= DynamicData[12]) &&

        (x                                                               <= DynamicData[13]))) &&

       ((DynamicData[14] > DynamicData[15]) ||

        (((x = FireRate[c>>2][r>>2])             >= DynamicData[14]) &&

        (x                                                               <= DynamicData[15])))) {

393 return 1;

394 } else {

395 return 0;

396 } // if

397 }

398

399

 void drawDynamic(SimView *view)

401 {

402 DRAW_BEGIN

     if (tile > 63) {

       if (!dynamicFilter(col, row)) {

405 tile = 0;

406 } // if

407 } // if

408 DRAW_END

409 }

410

411