]> git.zerfleddert.de Git - micropolis/blob - src/sim/g_cam.c
projects / micropolis / blob
? search:


139da469ed77d9c8e0a4615903509f9c73e15713
[micropolis] / src / sim / g_cam.c
1 /* g_cam.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 #ifdef CAM
66
67
68 Can *
69 new_can(int w, int h, Byte *mem, int line_bytes)
70 {
71 Can *can = (Can *)malloc(sizeof(Can));
72
73 can->width = w;
74 can->height = h;
75 can->line_bytes = line_bytes;
76 can->mem = mem;
77
78 return (can);
79 }
80
81
82 Cam *
83 new_cam(SimCam *scam, int x, int y, int w, int h, int dx, int dy, vf func)
84 {
85 Cam *cam = (Cam *)malloc(sizeof(Cam));
86 int ww, hh;
87
88 cam->x = x;
89 cam->y = y;
90 cam->ideal_width = w;
91 cam->ideal_height = h;
92 w = (w + 1) & ~1;
93 h = (h + 1) & ~1;
94 ww = w + 2;
95 hh = h + 2;
96 cam->width = w;
97 cam->height = h;
98 cam->back = new_can(ww, hh, (Byte *)malloc(ww * hh), ww);
99 cam->front = new_can(w, h,
100 (Byte *)scam->data + x + (y * scam->line_bytes),
101 scam->line_bytes);
102 cam->neighborhood = func;
103 cam->rule = NULL;
104 cam->rule_size = 0;
105 cam->phase = 0;
106 cam->wrap = 3;
107 cam->frob = -1;
108 cam->steps = 1;
109 cam->dx = dx;
110 cam->dy = dy;
111 cam->gx = 0;
112 cam->gy = 0;
113 cam->dragging = 0;
114 cam->set_x = -1;
115 cam->set_y = -1;
116 cam->set_width = -1;
117 cam->set_height = -1;
118 cam->set_x0 = -1;
119 cam->set_y0 = -1;
120 cam->set_x1 = -1;
121 cam->set_y1 = -1;
122 cam->name = NULL;
123 cam->next = scam->cam_list;
124 scam->cam_list = cam;
125 scam->cam_count++;
126
127 return (cam);
128 }
129
130
131 scam_randomize(SimCam *scam)
132 {
133 u_char *data = scam->data;
134 int line_bytes = scam->line_bytes;
135 int pixels = line_bytes * scam->w_height;
136 int i;
137
138 for (i = 0; i < pixels; i++) {
139 *data = (char)(Rand16() >>4);
140 data++;
141 }
142 }
143
144
145 cam_randomize(Cam *cam)
146 {
147 int x, y, w, h, lb;
148 Byte *image;
149
150 w = cam->width;
151 h = cam->height;
152 lb = cam->front->line_bytes;
153 image = cam->front->mem;
154
155 for (y = 0; y < h; y++, image += lb) {
156 for (x = 0; x < w; x++) {
157 image[x] = (char)(Rand16() >> 4);
158 }
159 }
160 }
161
162
163 cam_do_rule(SimCam *scam, Cam *cam)
164 {
165 Byte *back, *front;
166 int frontline, backline;
167 int w, h;
168 int steps = cam->steps;
169 int step;
170
171 back = cam->back->mem;
172 backline = cam->back->line_bytes;
173
174 front = cam->front->mem;
175 frontline = cam->front->line_bytes;
176
177 w = cam->width;
178 h = cam->height;
179
180 for (step=0; step < steps; step++) {
181 int x, y;
182 Byte *p = back + backline + 1,
183 *f = front;
184 /*
185 * Copy wrapping edges from front=>back:
186 *
187 * 0 ff f0 f1 ... fe ff f0
188 *
189 * 1 0f 00 01 ... 0e 0f 00
190 * 2 1f 10 11 ... 1e 1f 10
191 * .. .. .. .. .. ..
192 * ef e0 e1 ... ee ef e0
193 * h ff f0 f1 ... fe ff f0
194 *
195 * h+1 0f 00 01 ... 0e 0f 00
196 *
197 * wrap value: effect:
198 * 0 no effect
199 * 1 copy front=>back, no wrap
200 * 2 no copy, wrap edges
201 * 3 copy front=>back, wrap edges
202 * 4 copy front=>back, same edges
203 * 5 copy edges from screen
204 */
205
206 switch (cam->wrap) {
207
208 case 0:
209 break;
210
211 case 1:
212 for (y=0; y<h; y++) {
213 memcpy(p, f, w);
214 p += backline;
215 f += frontline;
216 }
217 break;
218
219 case 2:
220 for (y=0; y<h; y++) {
221 p[-1] = p[w-1];
222 p[w] = p[0];
223 p += backline;
224 f += frontline;
225 }
226 memcpy(back, back + backline*h, backline);
227 memcpy(back + backline*(h+1), back + backline, backline);
228 break;
229
230 case 3:
231 for (y=0; y<h; y++) {
232 memcpy(p, f, w);
233 p[-1] = p[w-1];
234 p[w] = p[0];
235 p += backline;
236 f += frontline;
237 }
238 memcpy(back, back + backline*h, backline);
239 memcpy(back + backline*(h+1), back + backline, backline);
240 break;
241
242 case 4:
243 for (y=0; y<h; y++) {
244 memcpy(p, f, w);
245 p[-1] = p[0];
246 p[w] = p[w-1];
247 p += backline;
248 f += frontline;
249 }
250 memcpy(back + (backline * (h + 1)), back + backline*h, backline);
251 memcpy(back, back + backline, backline);
252 break;
253
254 case 5:
255 { int left = (cam->x == 0) ? 1 : 0;
256 int right = (cam->x + cam->front->width == scam->w_width) ? 1 : 0;
257 int top = (cam->y == 0) ? 1 : 0;
258 int bottom = (cam->y + cam->front->height == scam->w_height) ? 1 : 0;
259
260 if (!left && !right && !top && !bottom) {
261 p = back;
262 f = front - 1 - frontline;
263 for (y=-1; y<=h; y++) {
264 memcpy(p, f, w + 2);
265 p += backline;
266 f += frontline;
267 }
268 } else {
269 p = back + backline + 1;
270 f = front;
271
272 p[-1 - backline] = f[left - 1 - (top ? 0 : frontline)];
273 memcpy(p - backline, f, w);
274 p[w - backline] = f[w - right - (top ? 0 : frontline)];
275
276 for (y=0; y<h; y++) {
277 p[-1] = f[left - 1];
278 memcpy(p, f, w);
279 p[w] = f[w - right];
280 p += backline;
281 f += frontline;
282 }
283 }
284 }
285 break;
286
287 }
288
289 cam_slide(scam, cam);
290
291 (*cam->neighborhood)(cam);
292 cam->phase = !cam->phase;
293
294 cam_update(scam, cam);
295
296 cam_adjust(scam, cam);
297 } /* for step */
298 }
299
300
301 cam_slide(SimCam *scam, Cam *cam)
302 {
303 int x = cam->x;
304 int y = cam->y;
305 int last_x = x;
306 int last_y = y;
307 int width = cam->width;
308 int height = cam->height;
309 int dx = cam->dx;
310 int dy = cam->dy;
311 int dragging = cam->dragging;
312 int bounce = 0;
313 int dagnabit = 0;
314
315 if (dragging ||
316 (cam->set_x >= 0) ||
317 (cam->set_y >= 0)) {
318 if (cam->set_x >= 0) {
319 x = cam->set_x;
320 cam->set_x = -1;
321 }
322 if (cam->set_y >= 0) {
323 y = cam->set_y;
324 cam->set_y = -1;
325 }
326 } else {
327 x += dx;
328 y += dy;
329 }
330
331 if (x < 0) {
332 x = 0;
333 if (!dragging) {
334 dx = ABS(dx);
335 bounce = 1;
336 }
337 } else if ((x + width) > scam->w_width) {
338 x = scam->w_width - width;
339 if (!dragging) {
340 dx = -ABS(dx);
341 bounce = 1;
342 }
343 }
344
345 if (y < 0) {
346 y = 0;
347 if (!dragging) {
348 dy = ABS(dy);
349 bounce = 1;
350 }
351 else {
352 dagnabit = 1;
353 printf("dagnabit\n");
354 }
355 } else if ((y + height) > scam->w_height) {
356 y = scam->w_height - height;
357 if (!dragging) {
358 dy = -ABS(dy);
359 bounce = 1;
360 }
361 }
362
363 if (dragging) {
364 dx = x - last_x;
365 dy = y - last_y;
366 } else {
367 if (bounce) {
368 cam->frob = (Rand16() & 15) * ((cam->frob > 0) ? -1 : 1);
369 }
370 }
371
372 cam->x = x;
373 cam->y = y;
374 cam->front->mem = (Byte *)scam->data + x + (scam->line_bytes * y);
375 cam->dx = dx + cam->gx;
376 cam->dy = dy + cam->gy;
377 if (dagnabit) {
378 printf("x %d y %d dx %d dy %d\n", cam->x, cam->y, cam->dx, cam->dy);
379 }
380 }
381
382
383 cam_update(SimCam *scam, Cam *cam)
384 {
385 if (scam->x->shared) {
386 XShmPutImage(scam->x->dpy, Tk_WindowId(scam->tkwin), scam->x->gc,
387 scam->image, cam->x, cam->y,
388 cam->x, cam->y, cam->width, cam->height,
389 False);
390 } else {
391 XPutImage(scam->x->dpy, Tk_WindowId(scam->tkwin), scam->x->gc,
392 scam->image, cam->x, cam->y,
393 cam->x, cam->y, cam->width, cam->height);
394 }
395 }
396
397
398 cam_adjust(SimCam *scam, Cam *cam)
399 {
400 int x0 = cam->set_x0;
401 int y0 = cam->set_y0;
402 int x1 = cam->set_x1;
403 int y1 = cam->set_y1;
404 int width = cam->set_width;
405 int height = cam->set_height;
406 int min_size = 8;
407 int tmp;
408
409 if ((x0 >= 0) ||
410 (y0 >= 0) ||
411 (x1 >= 0) ||
412 (y1 >= 0) ||
413 (width > 0) ||
414 (height > 0)) {
415 if (x0 < 0) x0 = cam->x;
416 if (y0 < 0) y0 = cam->y;
417 if (x1 < 0) x1 = cam->x + cam->ideal_width;
418 if (y1 < 0) y1 = cam->y + cam->ideal_height;
419 if (width > 0) x1 = x0 + width;
420 if (height > 0) y1 = y0 + height;
421
422 cam->set_width = cam->set_height =
423 cam->set_x0 = cam->set_y0 =
424 cam->set_x1 = cam->set_y1 = -1;
425
426 if (x0 > x1) {
427 tmp = x0; x0 = x1; x1 = tmp;
428 }
429
430 if (y0 > y1) {
431 tmp = y0; y0 = y1; y1 = tmp;
432 }
433
434 if (x0 < 0) x0 = 0;
435 if (y0 < 0) y0 = 0;
436 if (x0 > scam->w_width - min_size) x0 = scam->w_width - min_size;
437 if (y0 > scam->w_height - min_size) x0 = scam->w_height - min_size;
438 if (x1 < x0 + min_size) x1 = x0 + min_size;
439 if (y1 < y0 + min_size) y1 = y0 + min_size;
440 if (x1 > scam->w_width) x1 = scam->w_width;
441 if (y1 > scam->w_height) y1 = scam->w_height;
442
443 cam->x = x0;
444 cam->y = y0;
445 cam->ideal_width = x1 - x0;
446 cam->ideal_height = y1 - y0;
447 cam->width = cam->ideal_width & ~1;
448 cam->height = cam->ideal_height & ~1;
449 cam->front->mem = (Byte *)scam->data + x0 + (y0 * scam->line_bytes);
450 cam->front->width = cam->width;
451 cam->front->height = cam->height;
452 free(cam->back->mem);
453 cam->back->mem = (Byte *)malloc((cam->width + 2) * (cam->height + 2));
454 cam->back->width = cam->width + 2;
455 cam->back->height = cam->height + 2;
456 cam->back->line_bytes = cam->back->width;
457 }
458 }
459
460
461 void
462 n_moore_a(Cam *cam)
463 {
464 /* 0 1 2 3 4 5 6 7 8 9 */
465 /* c c' se sw ne nw e w s n */
466 /* 0x1 0x2 0x4 0x8 0x10 0x20 0x40 0x80 0x100 0x200 */
467
468 #define MOORE_A ( \
469 ((NORTHWEST&1)<<5) | ((NORTH&1)<<9) |((NORTHEAST&1)<<4) | \
470 ((WEST&1)<<7) | (CENTER&3) | ((EAST&1)<<6) | \
471 ((SOUTHWEST&1)<<3) | ((SOUTH&1)<<8) |((SOUTHEAST&1)<<2) \
472 )
473
474 CAM_TABLE_LOOP(MOORE_A)
475 }
476
477
478 void
479 n_moore_ab(Cam *cam)
480 {
481 /* 0 1 2 3 4 5 6 7 8 9 10 11 */
482 /* c c' se sw ne nw e w s n &c &c' */
483 /* 0x1 0x2 0x4 0x8 0x10 0x20 0x40 0x80 0x100 0x200 0x400 0x800 */
484
485 #define MOORE_AB (MOORE_A | ((CENTER&12)<<8))
486
487 CAM_TABLE_LOOP(MOORE_AB)
488 }
489
490
491 void
492 n_vonn_neumann(Cam *cam)
493 {
494 /* 0 1 2 3 4 5 6 7 8 9 */
495 /* c c' e' w' s' n' e w s n */
496 /* 0x1 0x2 0x4 0x8 0x10 0x20 0x40 0x80 0x100 0x200 */
497
498 #define VON_NEUMANN ( \
499 (CENTER&3) | \
500 ((EAST&1)<<6) | ((EAST&2)<<1) | \
501 ((WEST&1)<<7) | ((WEST&2)<<2) | \
502 ((SOUTH&1)<<8) | ((SOUTH&2)<<3) | \
503 ((NORTH&1)<<9) | ((NORTH&2)<<4) \
504 )
505
506 CAM_TABLE_LOOP(VON_NEUMANN)
507 }
508
509
510 void
511 n_margolis(Cam *cam)
512 {
513 register Byte i;
514
515 /* 0 1 2 3 4 5 6 7 8 9 */
516 /* c c' cw ccw opp cw' ccw' opp' */
517 /* 0x1 0x2 0x4 0x8 0x10 0x20 0x40 0x80 0x100 0x200 */
518
519 #define MARGOLIS_ODD ( \
520 (CENTER & 3) | \
521 (i=(x&1 ? (y&1 ? (EAST) : (NORTH)) \
522 : (y&1 ? (SOUTH) : (WEST))), \
523 (((i&1)<<2) | ((i&2)<<4))) | \
524 (i=(x&1 ? (y&1 ? (SOUTH) : (EAST)) \
525 : (y&1 ? (WEST) : (NORTH))), \
526 (((i&1)<<3) | ((i&2)<<5))) | \
527 (i=(x&1 ? (y&1 ? (SOUTHEAST):(NORTHEAST)) \
528 : (y&1 ? (SOUTHWEST):(NORTHWEST))), \
529 (((i&1)<<4) | ((i&2)<<6))) \
530 )
531
532 #define MARGOLIS_EVEN ( \
533 (CENTER & 3) | \
534 (i=(x&1 ? (y&1 ? (WEST) : (SOUTH)) \
535 : (y&1 ? (NORTH) : (EAST))), \
536 (((i&1)<<2) | ((i&2)<<4))) | \
537 (i=(x&1 ? (y&1 ? (NORTH) : (WEST)) \
538 : (y&1 ? (EAST) : (SOUTH))), \
539 (((i&1)<<3) | ((i&2)<<5))) | \
540 (i=(x&1 ? (y&1 ? (NORTHWEST) : (SOUTHWEST)) \
541 : (y&1 ? (NORTHEAST) : (SOUTHEAST))), \
542 (((i&1)<<4) | ((i&2)<<6))) \
543 )
544
545 if (cam->phase) {
546 CAM_TABLE_LOOP(MARGOLIS_ODD)
547 } else {
548 CAM_TABLE_LOOP(MARGOLIS_EVEN)
549 }
550 }
551
552
553 void
554 n_margolis_ph(Cam *cam)
555 {
556 register Byte i;
557
558 /* 0 1 2 3 4 5 6 7 8 9 */
559 /* c c' cw ccw opp cw' ccw' opp' pha pha' */
560 /* 0x1 0x2 0x4 0x8 0x10 0x20 0x40 0x80 0x100 0x200 */
561
562 #define MARGOLIS_ODD_PH (MARGOLIS_ODD | 0x100)
563 #define MARGOLIS_EVEN_PH (MARGOLIS_EVEN | 0x200)
564
565 if (cam->phase) {
566 CAM_TABLE_LOOP(MARGOLIS_ODD_PH)
567 } else {
568 CAM_TABLE_LOOP(MARGOLIS_EVEN_PH)
569 }
570 }
571
572
573 void
574 n_margolis_hv(Cam *cam)
575 {
576 register Byte i;
577
578 /* 0 1 2 3 4 5 6 7 8 9 */
579 /* c c' cw ccw opp cw' ccw' opp' horz vert */
580 /* 0x1 0x2 0x4 0x8 0x10 0x20 0x40 0x80 0x100 0x200 */
581
582 #define MARGOLIS_ODD_HV (MARGOLIS_ODD | ((x&1)<<8) | ((y&1)<<9))
583 #define MARGOLIS_EVEN_HV (MARGOLIS_EVEN | ((x&1)<<8) | ((y&1)<<9))
584
585 if (cam->phase) {
586 CAM_TABLE_LOOP(MARGOLIS_ODD_HV)
587 } else {
588 CAM_TABLE_LOOP(MARGOLIS_EVEN_HV)
589 }
590 }
591
592
593 void
594 n_life(Cam *cam)
595 {
596 int s;
597
598 #define LIFE ( \
599 ((CENTER&1) ? (((s = SUM8) == 2) || (s == 3)) \
600 : (SUM8 == 3)) | \
601 (CENTER<<1) \
602 )
603
604 CAM_LOOP(LIFE)
605 }
606
607
608 void
609 n_brain(Cam *cam)
610 {
611 int s;
612
613 #define BRAIN ( \
614 (((((s = CENTER)&3) == 0) && (SUM8 == 2)) ? 1 : 0) | \
615 (s<<1) \
616 )
617
618 CAM_LOOP(BRAIN)
619 }
620
621
622 void
623 n_heat(Cam *cam)
624 {
625 int frob = cam->frob;
626
627 #define HEAT ( \
628 ((QUAD)(NORTHWEST + NORTH + NORTHEAST + \
629 WEST + EAST + \
630 SOUTHWEST + SOUTH + SOUTHEAST + frob)) >> 3 \
631 )
632
633 CAM_LOOP(HEAT)
634 }
635
636
637 void
638 n_dheat(Cam *cam)
639 {
640 int frob = cam->frob;
641 int last = 0;
642
643 #define DHEAT \
644 last += NORTHWEST + NORTH + NORTHEAST + \
645 WEST + frob + EAST + \
646 SOUTHWEST + SOUTH + SOUTHEAST; \
647 *front = last >> 3; \
648 last &= 7;
649 CAM_LOOP_BODY(DHEAT)
650
651 }
652
653
654 void
655 n_lheat(Cam *cam)
656 {
657 int frob = cam->frob;
658
659 #define LHEAT ( \
660 ((QUAD)(NORTH + WEST + EAST + SOUTH + frob)) >> 2 \
661 )
662
663 CAM_LOOP(LHEAT)
664 }
665
666
667 void
668 n_ldheat(Cam *cam)
669 {
670 int frob = cam->frob;
671 int last; /* I meant to do that! */
672
673 #define LDHEAT ( \
674 ((last = (QUAD)(NORTH + WEST + EAST + SOUTH + frob \
675 + (last&0x03))), last >> 2) \
676 )
677
678 CAM_LOOP(LDHEAT)
679 }
680
681
682 void
683 n_abdheat(Cam *cam)
684 {
685 int frob = cam->frob;
686 int lasta = 0, lastb = 0; /* I meant to do that! */
687
688 #define YUM(x) (((QUAD)(x))&0x0f)
689 #define YUK(x) (((QUAD)(x))&0xf0)
690
691 #define ABDHEAT ( \
692 (lasta = (QUAD)(YUM(NORTHWEST) + YUM(NORTH) + YUM(NORTHEAST) + \
693 YUM(WEST) + YUM(EAST) + \
694 YUM(SOUTHWEST) + YUM(SOUTH) + YUM(SOUTHEAST) + \
695 frob + (lasta&0x07))), \
696 (lastb = (QUAD)(YUK(NORTHWEST) + YUK(NORTH) + YUK(NORTHEAST) + \
697 YUK(WEST) + YUK(EAST) + \
698 YUK(SOUTHWEST) + YUK(SOUTH) + YUK(SOUTHEAST) + \
699 (frob<<4) + (lastb&0x70))), \
700 (((lasta>>3)&0x0f) | ((lastb>>3)&0xf0)) \
701 )
702
703 CAM_LOOP(ABDHEAT)
704 }
705
706
707 void
708 n_abcdheat(Cam *cam)
709 {
710 int last;
711 int frob = cam->frob;
712
713 CAM_LOOP(HEAT)
714 }
715
716
717 void
718 n_edheat(Cam *cam)
719 {
720 int frob = cam->frob;
721 int last = 0;
722
723 #define EDHEAT ( \
724 (last = (QUAD)(YUM(NORTHWEST) + YUM(NORTH) + YUM(NORTHEAST) + \
725 YUM(WEST) + YUM(EAST) + \
726 YUM(SOUTHWEST) + YUM(SOUTH) + YUM(SOUTHEAST) + \
727 frob + (last&0x07))), \
728 (((last>>3)&0x0f) | ((CENTER<<4)&0xf0)) \
729 )
730
731 CAM_LOOP(EDHEAT)
732 }
733
734
735 int ranch(QUAD l0, QUAD l1, QUAD l2)
736 {
737 int s = SUM8;
738 int v = SUM9p(1);
739 int o = 0;
740
741 o = (CENTER&4)<<1;
742
743 if (v < 4 || v == 5) {
744 o |= 0x04;
745 } else {
746 }
747
748 return (o);
749 }
750
751
752 void
753 n_ranch(Cam *cam)
754 {
755 #define RANCH ranch(l0, l1, l2)
756
757 CAM_LOOP(RANCH)
758 }
759
760
761 void
762 n_anneal(Cam *cam)
763 {
764 int s;
765
766 #define ANNEAL ( \
767 ((s = SUM9) > 5) || (s == 4) \
768 )
769 CAM_LOOP(ANNEAL)
770 }
771
772
773 void
774 n_anneal4(Cam *cam)
775 {
776 int s;
777
778 #define ANNEAL4 ( \
779 ((((s = SUM9p(0)) > 5) || (s == 4)) ? 1 : 0) | \
780 ((((s = SUM9p(1)) > 5) || (s == 4)) ? 2 : 0) | \
781 ((((s = SUM9p(2)) > 5) || (s == 4)) ? 4 : 0) | \
782 ((((s = SUM9p(3)) > 5) || (s == 4)) ? 8 : 0) | \
783 (CENTER << 4) \
784 )
785 CAM_LOOP(ANNEAL4)
786 }
787
788
789 void
790 n_anneal8(Cam *cam)
791 {
792 int s;
793
794 #define ANNEAL8 ( \
795 ((((s = SUM9p(0)) > 5) || (s == 4)) ? 1 : 0) | \
796 ((((s = SUM9p(1)) > 5) || (s == 4)) ? 2 : 0) | \
797 ((((s = SUM9p(2)) > 5) || (s == 4)) ? 4 : 0) | \
798 ((((s = SUM9p(3)) > 5) || (s == 4)) ? 8 : 0) | \
799 ((((s = SUM9p(4)) > 5) || (s == 4)) ? 16 : 0) | \
800 ((((s = SUM9p(5)) > 5) || (s == 4)) ? 32 : 0) | \
801 ((((s = SUM9p(6)) > 5) || (s == 4)) ? 64 : 0) | \
802 ((((s = SUM9p(7)) > 5) || (s == 4)) ? 128 : 0) \
803 )
804 CAM_LOOP(ANNEAL8)
805 }
806
807
808 void
809 n_eco(Cam *cam)
810 {
811 int s;
812
813 #define ANTILIFE ( \
814 ((CENTER&1) ? (SUM8 != 5) \
815 : (((s = SUM8) != 5) && (s != 6))) | \
816 (CENTER<<1) \
817 )
818
819 #define ECO ( \
820 (((s = SUM9p(7)) > 5) || (s == 4) ? 128 : 0) | \
821 ((CENTER&128) ? ((ANTILIFE)&127) : ((BRAIN)&127)) \
822 )
823 CAM_LOOP(ECO)
824 }
825
826
827 void
828 n_torben(Cam *cam)
829 {
830 int s;
831
832 /* 0 0 0 1 0 1 0 1 1 1 */
833
834 #define TORBEN ( \
835 (CENTER << 1) | ((((s = SUM9) > 6) || (s == 5) || (s == 3)) ? 1 : 0) \
836 )
837 CAM_LOOP(TORBEN)
838 }
839
840
841 void
842 n_torben2(Cam *cam)
843 {
844 int s;
845
846
847 /* 0 0 0 1 0 1 0 1 1 1 */
848 /* 0 0 1 0 1 0 1 0 1 1 */
849 #define TORBEN2 ( \
850 TORBEN | (CENTER <<1) \
851 )
852 CAM_LOOP(TORBEN2)
853 }
854
855
856 void
857 n_torben3(Cam *cam)
858 {
859 int s;
860
861 /* 0 0 0 1 1 0 0 1 1 1 */
862
863 #define TORBEN3 ( \
864 ((s = SUM9) > 6) || (s == 3) || (s == 4) \
865 )
866 CAM_LOOP(TORBEN3)
867 }
868
869
870 void
871 n_torben4(Cam *cam)
872 {
873 int s;
874
875
876 /* 0 0 0 1 0 1 0 1 1 1 */
877 /* 0 0 1 0 1 0 1 0 1 1 */
878 #define TORBEN4 ( \
879 TORBEN3 | (CENTER <<1) \
880 )
881 CAM_LOOP(TORBEN4)
882 }
883
884
885 void
886 n_ball(Cam *cam)
887 {
888 char p = (cam->phase ? 1 : 0);
889 int x, y, r = Rand16();
890 int backline = cam->back->line_bytes,
891 frontline = cam->front->line_bytes;
892 Byte *back = cam->back->mem,
893 *front = cam->front->mem;
894
895 if (!p) {
896 back += 1 + backline;
897 }
898
899 for (y = p + (cam->height >>1); y > 0; y--) {
900 for (x = p + (cam->width >>1); x > 0; x--) {
901 Byte nw = back[0], ne = back[1],
902 sw = back[backline], se = back[backline+1];
903
904 r += nw + ne + sw + sw; r >>= 1;
905
906 switch ((nw&1) + (ne&1) + (sw&1) + (se&1)) {
907 case 0:
908 case 3:
909 case 4:
910 /* same */
911 back[0] = nw; back[1] = ne;
912 back[backline] = sw; back[backline+1] = se;
913 break;
914 case 1:
915 /* reflect */
916 back[0] = se; back[1] = sw;
917 back[backline] = ne; back[backline+1] = nw;
918 break;
919 case 2:
920 /* turn */
921 switch (((nw&1) <<3) | ((ne&1) <<2) | ((sw&1) <<1) | (se&1)) {
922 case 6:
923 case 9:
924 if (r&1) {
925 /* clockwise */
926 back[0] = sw; back[1] = nw;
927 back[backline] = se; back[backline+1] = ne;
928 } else {
929 /* counterclockwise */
930 back[0] = ne; back[1] = se;
931 back[backline] = nw; back[backline+1] = sw;
932 }
933 default:
934 back[0] = nw; back[1] = ne;
935 back[backline] = sw; back[backline+1] = se;
936 break;
937 }
938 break;
939 }
940
941 back += 2;
942 }
943 back += backline + backline - cam->width - (2*p);
944 }
945 back = cam->back->mem + backline + 1,
946 front = cam->front->mem;
947
948 for (y = cam->height; y > 0; y--) {
949 memcpy(front, back, cam->width);
950 back += backline;
951 front += frontline;
952 }
953 }
954
955
956 void
957 n_logic(Cam *cam)
958 {
959 char p = (cam->phase ? 1 : 0);
960 int x, y;
961 int backline = cam->back->line_bytes,
962 frontline = cam->front->line_bytes;
963 Byte tmp;
964 Byte *back = cam->back->mem,
965 *front = cam->front->mem;
966
967 /* bit 8 is center' */
968 /* bit 7 is center */
969
970 if (cam->phase) {
971 back += 1 + backline;
972 front += 1 + frontline;
973 }
974
975 for (y = cam->height >>1; y > 0; y--) {
976 for (x = cam->width >>1; x > 0; x--) {
977 Byte nw = back[0], ne = back[1],
978 sw = back[backline], se = back[backline+1];
979
980 switch (((nw&128) >>4) | ((ne&128) >>5) |
981 ((sw&128) >>6) | ((se&128) >>7)) {
982 case 0:
983 break;
984
985 case 1:
986 break;
987
988 case 2:
989 break;
990
991 case 3:
992 break;
993
994 case 4:
995 break;
996
997 case 5:
998 break;
999
1000 case 6:
1001 break;
1002
1003 case 7:
1004 break;
1005
1006 case 8:
1007 break;
1008
1009 case 9:
1010 break;
1011
1012 case 10:
1013 break;
1014
1015 case 11:
1016 break;
1017
1018 case 12:
1019 break;
1020
1021 case 13:
1022 break;
1023
1024 case 14:
1025 break;
1026
1027 case 15:
1028 tmp = nw; nw = se; se = tmp;
1029 tmp = sw; ne = sw; sw = tmp;
1030 break;
1031
1032 }
1033
1034 back += 2; front += 2;
1035 }
1036 back += backline + backline - cam->width;
1037 front += frontline + frontline - cam->width;
1038 }
1039
1040 back = cam->back->mem + backline + 1,
1041 front = cam->front->mem;
1042
1043 for (y = cam->height; y > 0; y--) {
1044 memcpy(front, back, cam->width);
1045 back += backline;
1046 front += frontline;
1047 }
1048 }
1049
1050
1051 void
1052 n_party(Cam *cam)
1053 {
1054 #define PARTY (CENTER ^ NORTH ^ SOUTH ^ EAST ^ WEST)
1055 CAM_LOOP(PARTY)
1056 }
1057
1058
1059 vf neighborhoods[] = {
1060 /* 0 1 2 3 */
1061 &n_moore_a, &n_moore_a, &n_moore_ab, &n_vonn_neumann,
1062 /* 4 5 6 */
1063 &n_margolis, &n_margolis_ph, &n_margolis_hv,
1064 /* 7 8 9 10 11 12 */
1065 &n_life, &n_brain, &n_heat, &n_dheat, &n_lheat, &n_ldheat,
1066 /* 13 14 15 16 17 */
1067 &n_ranch, &n_anneal, &n_anneal4, &n_anneal8, &n_eco,
1068 /* 18 19 20 21 22 */
1069 &n_abdheat, &n_edheat, &n_abcdheat, &n_torben, &n_torben2,
1070 /* 23 24 25 26 27 */
1071 &n_torben3, &n_torben4, &n_ball, &n_logic, &n_party
1072 };
1073
1074
1075 cam_set_neighborhood(Cam *cam, int code)
1076 {
1077 cam->neighborhood = neighborhoods[code];
1078 }
1079
1080
1081 cam_load_rule(Cam *cam, char *filename)
1082 {
1083 FILE *fp;
1084 QUAD magic, neighborhood, rule_size;
1085 Byte *rule;
1086 int test = 1;
1087
1088 if ((fp = fopen(filename, "r")) == NULL) {
1089 fprintf(stderr, "cam: Can't open rule file \"%s\"\n", filename);
1090 return;
1091 }
1092
1093
1094 #define SWAPQUAD(x) ((x = ((x <<24) & 0xff000000) | \
1095 ((x <<8) & 0x00ff0000) | \
1096 ((x >>8) & 0x0000ff00) | \
1097 ((x >>24) & 0x000000ff)), 0)
1098
1099 /* XXX: Make this byte order independent!!! */
1100 if ((*(unsigned char*) (&test))) {
1101 if ((fread(&magic, 1, sizeof(QUAD), fp) != sizeof(QUAD)) ||
1102 SWAPQUAD(magic) ||
1103 (magic != 0xcac0cac0) ||
1104 (fread(&neighborhood, 1, sizeof(QUAD), fp) != sizeof(QUAD)) ||
1105 SWAPQUAD(neighborhood) ||
1106 (fread(&rule_size, 1, sizeof(QUAD), fp) != sizeof(QUAD)) ||
1107 SWAPQUAD(rule_size) ||
1108 ((rule = (Byte *)malloc(rule_size)) == NULL) ||
1109 (fread(rule, 1, rule_size, fp) != rule_size)) {
1110 fprintf(stderr, "cam: Bad rule file \"%s\"\n", filename);
1111 fclose(fp);
1112 return;
1113 }
1114 } else {
1115 if ((fread(&magic, 1, sizeof(QUAD), fp) != sizeof(QUAD)) ||
1116 (magic != 0xcac0cac0) ||
1117 (fread(&neighborhood, 1, sizeof(QUAD), fp) != sizeof(QUAD)) ||
1118 (fread(&rule_size, 1, sizeof(QUAD), fp) != sizeof(QUAD)) ||
1119 ((rule = (Byte *)malloc(rule_size)) == NULL) ||
1120 (fread(rule, 1, rule_size, fp) != rule_size)) {
1121 fprintf(stderr, "cam: Bad rule file \"%s\"\n", filename);
1122 fclose(fp);
1123 return;
1124 }
1125 }
1126
1127 fclose(fp);
1128 if (cam->rule != NULL)
1129 free(cam->rule);
1130 cam->rule = rule;
1131 cam->rule_size = rule_size;
1132 cam_set_neighborhood(cam, neighborhood);
1133 }
1134
1135
1136 Cam *
1137 find_cam(SimCam *scam, int x, int y)
1138 {
1139 Cam *cam;
1140
1141 for (cam = scam->cam_list; cam != NULL; cam = cam->next) {
1142 if ((x >= cam->x) &&
1143 (y >= cam->y) &&
1144 (x < cam->x + cam->width) &&
1145 (y < cam->y + cam->height)) {
1146 break;
1147 }
1148 }
1149
1150 return cam;
1151 }
1152
1153
1154 Cam *
1155 find_cam_by_name(SimCam *scam, char *name)
1156 {
1157 Cam *cam;
1158
1159 for (cam = scam->cam_list; cam != NULL; cam = cam->next) {
1160 if ((cam->name != NULL) &&
1161 (strcmp(name, cam->name) == 0)) {
1162 return cam;
1163 }
1164 }
1165
1166 return NULL;
1167 }
1168
1169
1170 Cam *
1171 get_cam_number(SimCam *scam, int i)
1172 {
1173 Cam *cam;
1174
1175 for (cam = scam->cam_list;
1176 (i != 0) && (cam != NULL);
1177 (i--), (cam = cam->next)) ;
1178
1179 return cam;
1180 }
1181
1182
1183 cam_layout(SimCam *scam)
1184 {
1185 int x, y, gap, border, maxwidth, lastmax;
1186 Cam *cam;
1187
1188 border = 8;
1189 gap = 8;
1190 x = border; y = border;
1191 maxwidth = lastmax = gap;
1192
1193 for (cam = scam->cam_list; cam != NULL; cam = cam->next) {
1194 cam->dx = 0; cam->dy = 0;
1195 if (cam->width > maxwidth) {
1196 lastmax = maxwidth;
1197 maxwidth = cam->width;
1198 }
1199 if (y + cam->height + border > scam->w_height) {
1200 y = border; x = x + maxwidth + gap;
1201 maxwidth = lastmax = gap;
1202 }
1203 if ((x + cam->width > scam->w_width) ||
1204 (y + cam->height > scam->w_height)) {
1205 cam->x = 0; cam->y = 0;
1206 cam->front->mem = (Byte *)scam->data;
1207 maxwidth = lastmax;
1208 } else {
1209 cam->x = x; cam->y = y;
1210 cam->front->mem =
1211 scam->data + x + (scam->line_bytes * y);
1212 y = y + cam->height + gap;
1213 }
1214 }
1215 }
1216
1217
1218 init_scam(SimCam *scam)
1219 {
1220 scam_randomize(scam);
1221 }
1222
1223
1224 handle_scam(SimCam *scam)
1225 {
1226 Cam *cam;
1227
1228 for (cam = scam->cam_list; cam != NULL; cam = cam->next) {
1229 cam_do_rule(scam, cam);
1230 }
1231 }
1232
1233
1234 #endif /* CAM */
Micropolis
Impressum, Datenschutz