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


1143b06f94d1be81ab342dc34c2229c6e69b005a
[micropolis] / src / sim / w_tool.c
1 /* w_tool.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 short specialBase = CHURCH;
66 int OverRide = 0;
67 int Expensive = 1000;
68 int Players = 1;
69 int Votes = 0;
70 int PendingTool = -1;
71 int PendingX;
72 int PendingY;
73
74
75 QUAD CostOf[] = {
76 100, 100, 100, 500,
77 0, 500, 5, 1,
78 20, 10, 0, 0,
79 5000, 10, 3000, 3000,
80 5000, 10000, 100, 0,
81 };
82
83
84 short toolSize[] = {
85 3, 3, 3, 3,
86 1, 3, 1, 1,
87 1, 1, 0, 0,
88 4, 1, 4, 4,
89 4, 6, 1, 0,
90 };
91
92
93 short toolOffset[] = {
94 1, 1, 1, 1,
95 0, 1, 0, 0,
96 0, 0, 0, 0,
97 1, 0, 1, 1,
98 1, 1, 0, 0,
99 };
100
101
102 QUAD toolColors[] = {
103 COLOR_LIGHTGREEN | (COLOR_LIGHTGREEN << 8), /* residentialState */
104 COLOR_LIGHTBLUE | (COLOR_LIGHTBLUE << 8), /* commercialState */
105 COLOR_YELLOW | (COLOR_YELLOW << 8), /* industrialState */
106 COLOR_LIGHTGREEN | (COLOR_RED << 8), /* fireState */
107 COLOR_ORANGE | (COLOR_ORANGE << 8), /* queryState */
108 COLOR_LIGHTGREEN | (COLOR_LIGHTBLUE << 8), /* policeState */
109 COLOR_DARKGRAY | (COLOR_YELLOW << 8), /* wireState */
110 COLOR_LIGHTBROWN | (COLOR_LIGHTBROWN << 8), /* dozeState */
111 COLOR_DARKGRAY | (COLOR_OLIVE << 8), /* rrState */
112 COLOR_DARKGRAY | (COLOR_WHITE << 8), /* roadState */
113 COLOR_LIGHTGRAY | (COLOR_LIGHTGRAY << 8), /* chalkState */
114 COLOR_DARKGRAY | (COLOR_DARKGRAY << 8), /* eraserState */
115 COLOR_LIGHTGRAY | (COLOR_LIGHTGREEN << 8), /* stadiumState */
116 COLOR_LIGHTBROWN | (COLOR_LIGHTGREEN << 8), /* parkState */
117 COLOR_LIGHTGRAY | (COLOR_LIGHTBLUE << 8), /* seaportState */
118 COLOR_LIGHTGRAY | (COLOR_YELLOW << 8), /* powerState */
119 COLOR_LIGHTGRAY | (COLOR_YELLOW << 8), /* nuclearState */
120 COLOR_LIGHTGRAY | (COLOR_LIGHTBROWN << 8), /* airportState */
121 COLOR_LIGHTGRAY | (COLOR_RED << 8), /* networkState */
122 };
123
124
125 Ink *NewInk();
126
127 void DoSetWandState(SimView *view, short state);
128 void DoPendTool(SimView *view, int tool, int x, int y);
129 void EraserTo(SimView *view, int x, int y);
130 void EraserStart(SimView *view, int x, int y);
131 void DoShowZoneStatus(char *str, char *s0, char *s1, char *s2, char *s3, char *s4, int x, int y);
132
133
134 /*************************************************************************/
135 /* UTILITIES */
136
137
138 void
139 setWandState(SimView *view, short state)
140 {
141 #if 0
142 if (state < 0) {
143 specialBase = -state;
144 state = specialState;
145 }
146 #endif
147
148 view->tool_state = state;
149 DoUpdateHeads();
150 DoSetWandState(view, state);
151 }
152
153
154 int
155 putDownPark(SimView *view, short mapH, short mapV)
156 {
157 short value, tile;
158
159 if (TotalFunds - CostOf[parkState] >= 0) {
160 value = Rand(4);
161
162 if (value == 4)
163 tile = FOUNTAIN | BURNBIT | BULLBIT | ANIMBIT;
164 else
165 tile = (value + WOODS2) | BURNBIT | BULLBIT;
166
167 if (Map[mapH][mapV] == 0) {
168 Spend(CostOf[parkState]);
169 UpdateFunds();
170 Map[mapH][mapV] = tile;
171 return 1;
172 }
173 return -1;
174 }
175 return -2;
176 }
177
178
179 int
180 putDownNetwork(SimView *view, short mapH, short mapV)
181 {
182 int tile = Map[mapH][mapV] & LOMASK;
183
184 if ((TotalFunds > 0) && tally(tile)) {
185 Map[mapH][mapV] = tile = 0;
186 Spend(1);
187 }
188
189 if (tile == 0) {
190 if ((TotalFunds - CostOf[view->tool_state]) >= 0) {
191 Map[mapH][mapV] = TELEBASE | CONDBIT | BURNBIT | BULLBIT | ANIMBIT;
192 Spend(CostOf[view->tool_state]);
193 return 1;
194 } else {
195 return -2;
196 }
197 } else {
198 return -1;
199 }
200 }
201
202
203 short
204 checkBigZone(short id, short *deltaHPtr, short *deltaVPtr)
205 {
206 switch (id) {
207 case POWERPLANT: /* check coal plant */
208 case PORT: /* check sea port */
209 case NUCLEAR: /* check nuc plant */
210 case STADIUM: /* check stadium */
211 *deltaHPtr = 0; *deltaVPtr = 0; return (4);
212
213 case POWERPLANT + 1: /* check coal plant */
214 case COALSMOKE3: /* check coal plant, smoke */
215 case COALSMOKE3 + 1: /* check coal plant, smoke */
216 case COALSMOKE3 + 2: /* check coal plant, smoke */
217 case PORT + 1: /* check sea port */
218 case NUCLEAR + 1: /* check nuc plant */
219 case STADIUM + 1: /* check stadium */
220 *deltaHPtr = -1; *deltaVPtr = 0; return (4);
221
222 case POWERPLANT + 4: /* check coal plant */
223 case PORT + 4: /* check sea port */
224 case NUCLEAR + 4: /* check nuc plant */
225 case STADIUM + 4: /* check stadium */
226 *deltaHPtr = 0; *deltaVPtr = -1; return (4);
227
228 case POWERPLANT + 5: /* check coal plant */
229 case PORT + 5: /* check sea port */
230 case NUCLEAR + 5: /* check nuc plant */
231 case STADIUM + 5: /* check stadium */
232 *deltaHPtr = -1; *deltaVPtr = -1; return (4);
233
234 /* check airport */
235 /*** first row ***/
236 case AIRPORT:
237 *deltaHPtr = 0; *deltaVPtr = 0; return (6);
238 case AIRPORT + 1:
239 *deltaHPtr = -1; *deltaVPtr = 0; return (6);
240 case AIRPORT + 2:
241 *deltaHPtr = -2; *deltaVPtr = 0; return (6);
242 case AIRPORT + 3:
243 *deltaHPtr = -3; *deltaVPtr = 0; return (6);
244
245 /*** second row ***/
246 case AIRPORT + 6:
247 *deltaHPtr = 0; *deltaVPtr = -1; return (6);
248 case AIRPORT + 7:
249 *deltaHPtr = -1; *deltaVPtr = -1; return (6);
250 case AIRPORT + 8:
251 *deltaHPtr = -2; *deltaVPtr = -1; return (6);
252 case AIRPORT + 9:
253 *deltaHPtr = -3; *deltaVPtr = -1; return (6);
254
255 /*** third row ***/
256 case AIRPORT + 12:
257 *deltaHPtr = 0; *deltaVPtr = -2; return (6);
258 case AIRPORT + 13:
259 *deltaHPtr = -1; *deltaVPtr = -2; return (6);
260 case AIRPORT + 14:
261 *deltaHPtr = -2; *deltaVPtr = -2; return (6);
262 case AIRPORT + 15:
263 *deltaHPtr = -3; *deltaVPtr = -2; return (6);
264
265 /*** fourth row ***/
266 case AIRPORT + 18:
267 *deltaHPtr = 0; *deltaVPtr = -3; return (6);
268 case AIRPORT + 19:
269 *deltaHPtr = -1; *deltaVPtr = -3; return (6);
270 case AIRPORT + 20:
271 *deltaHPtr = -2; *deltaVPtr = -3; return (6);
272 case AIRPORT + 21:
273 *deltaHPtr = -3; *deltaVPtr = -3; return (6);
274
275 default:
276 *deltaHPtr = 0; *deltaVPtr = 0; return (0);
277 }
278 }
279
280
281 short
282 tally(short tileValue)
283 {
284 /* can we autobulldoze this tile? */
285 if (((tileValue >= FIRSTRIVEDGE) &&
286 (tileValue <= LASTRUBBLE)) ||
287 ((tileValue >= (POWERBASE + 2)) &&
288 (tileValue <= (POWERBASE + 12))) ||
289 ((tileValue >= TINYEXP) &&
290 (tileValue <= (LASTTINYEXP + 2)))) { /* ??? */
291 return (1);
292 } else {
293 return (0);
294 }
295 }
296
297
298 short
299 checkSize(short temp)
300 {
301 /* check for the normal com, resl, ind 3x3 zones & the fireDept & PoliceDept */
302 if (((temp >= (RESBASE - 1)) && (temp <= (PORTBASE - 1))) ||
303 ((temp >= (LASTPOWERPLANT + 1)) && (temp <= (POLICESTATION + 4)))) {
304 return (3);
305 } else if (((temp >= PORTBASE) && (temp <= LASTPORT)) ||
306 ((temp >= COALBASE) && (temp <= LASTPOWERPLANT)) ||
307 ((temp >= STADIUMBASE) && (temp <= LASTZONE))) {
308 return (4);
309 }
310 return (0);
311 }
312
313
314 /* 3x3 */
315
316
317 void
318 check3x3border(short xMap, short yMap)
319 {
320 short xPos, yPos;
321 short cnt;
322
323 xPos = xMap; yPos = yMap - 1;
324 for (cnt = 0; cnt < 3; cnt++) {
325 /*** this will do the upper bordering row ***/
326 ConnecTile(xPos, yPos, &Map[xPos][yPos], 0);
327 xPos++;
328 }
329
330 xPos = xMap - 1; yPos = yMap;
331 for (cnt = 0; cnt < 3; cnt++) {
332 /*** this will do the left bordering row ***/
333 ConnecTile(xPos, yPos, &Map[xPos][yPos], 0);
334 yPos++;
335 }
336
337 xPos = xMap; yPos = yMap + 3;
338 for (cnt = 0; cnt < 3; cnt++) {
339 /*** this will do the bottom bordering row ***/
340 ConnecTile(xPos, yPos, &Map[xPos][yPos], 0);
341 xPos++;
342 }
343
344 xPos = xMap + 3; yPos = yMap;
345 for (cnt = 0; cnt < 3; cnt++) {
346 /*** this will do the right bordering row ***/
347 ConnecTile(xPos, yPos, &Map[xPos][yPos], 0);
348 yPos++;
349 }
350 }
351
352
353 int
354 check3x3(SimView *view, short mapH, short mapV, short base, short tool)
355 {
356 register short rowNum, columnNum;
357 register short holdMapH, holdMapV;
358 short xPos, yPos;
359 short cost = 0;
360 short tileValue;
361 short flag;
362
363 mapH--; mapV--;
364 if ((mapH < 0) || (mapH > (WORLD_X - 3)) ||
365 (mapV < 0) || (mapV > (WORLD_Y - 3))) {
366 return -1;
367 }
368
369 xPos = holdMapH = mapH;
370 yPos = holdMapV = mapV;
371
372 flag = 1;
373
374 for (rowNum = 0; rowNum <= 2; rowNum++) {
375 mapH = holdMapH;
376
377 for (columnNum = 0; columnNum <= 2; columnNum++) {
378 tileValue = Map[mapH++][mapV] & LOMASK;
379
380 if (autoBulldoze) {
381 /* if autoDoze is enabled, add up the cost of bulldozed tiles */
382 if (tileValue != 0) {
383 if (tally(tileValue)) {
384 cost++;
385 } else {
386 flag = 0;
387 }
388 }
389 } else {
390 /* check and see if the tile is clear or not */
391 if (tileValue != 0) {
392 flag = 0;
393 }
394 }
395 }
396 mapV++;
397 }
398
399 if (flag == 0) {
400 return -1;
401 }
402
403 cost += CostOf[tool];
404
405 if ((TotalFunds - cost) < 0) {
406 return -2;
407 }
408
409 if ((Players > 1) &&
410 (OverRide == 0) &&
411 (cost >= Expensive) &&
412 (view != NULL) &&
413 (view->super_user == 0)) {
414 return -3;
415 }
416
417 /* take care of the money situtation here */
418 Spend(cost);
419 UpdateFunds();
420
421 mapV = holdMapV;
422
423 for (rowNum = 0; rowNum <= 2; rowNum++) {
424 mapH = holdMapH;
425
426 for (columnNum = 0; columnNum <= 2; columnNum++) {
427 if (columnNum == 1 && rowNum == 1) {
428 Map[mapH++][mapV] = base + BNCNBIT + ZONEBIT;
429 } else {
430 Map[mapH++][mapV] = base + BNCNBIT;
431 }
432 base++;
433 }
434 mapV++;
435 }
436 check3x3border(xPos, yPos);
437 return 1;
438 }
439
440
441 /* 4x4 */
442
443
444 void
445 check4x4border(short xMap, short yMap)
446 {
447 short *tilePtr;
448 short xPos, yPos;
449 short cnt;
450
451 xPos = xMap; yPos = yMap - 1;
452 for (cnt = 0; cnt < 4; cnt++) {
453 /* this will do the upper bordering row */
454 tilePtr = &Map[xPos][yPos];
455 ConnecTile(xPos, yPos, tilePtr, 0);
456 xPos++;
457 }
458
459 xPos = xMap - 1; yPos = yMap;
460 for (cnt = 0; cnt < 4; cnt++) {
461 /* this will do the left bordering row */
462 tilePtr = &Map[xPos][yPos];
463 ConnecTile(xPos, yPos, tilePtr, 0);
464 yPos++;
465 }
466
467 xPos = xMap; yPos = yMap + 4;
468 for (cnt = 0; cnt < 4;cnt++) {
469 /* this will do the bottom bordering row */
470 tilePtr = &Map[xPos][yPos];
471 ConnecTile(xPos, yPos, tilePtr, 0);
472 xPos++;
473 }
474
475 xPos = xMap + 4; yPos = yMap;
476 for (cnt = 0; cnt < 4; cnt++) {
477 /* this will do the right bordering row */
478 tilePtr = &Map[xPos][yPos];
479 ConnecTile(xPos, yPos, tilePtr, 0);
480 yPos++;
481 }
482 }
483
484
485 short
486 check4x4(SimView *view, short mapH, short mapV,
487 short base, short aniFlag, short tool)
488 {
489 register short rowNum, columnNum;
490 short h, v;
491 short holdMapH;
492 short xMap, yMap;
493 short tileValue;
494 short flag;
495 short cost = 0;
496
497 mapH--; mapV--;
498 if ((mapH < 0) || (mapH > (WORLD_X - 4)) ||
499 (mapV < 0) || (mapV > (WORLD_Y - 4))) {
500 return -1;
501 }
502
503 h = xMap = holdMapH = mapH;
504 v = yMap = mapV;
505
506 flag = 1;
507
508 for (rowNum = 0; rowNum <= 3; rowNum++) {
509 mapH = holdMapH;
510
511 for (columnNum = 0; columnNum <= 3; columnNum++) {
512 tileValue = Map[mapH++][mapV] & LOMASK;
513
514 if (autoBulldoze) {
515 /* if autoDoze is enabled, add up the cost of bulldozed tiles */
516 if (tileValue != 0) {
517 if (tally(tileValue)) {
518 cost++;
519 } else {
520 flag = 0;
521 }
522 }
523 } else {
524 /* check and see if the tile is clear or not */
525 if (tileValue != 0) {
526 flag = 0;
527 }
528 }
529 }
530 mapV++;
531 }
532
533 if (flag == 0) {
534 return -1;
535 }
536
537 cost += CostOf[tool];
538
539 if ((TotalFunds - cost) < 0) {
540 return -2;
541 }
542
543 if ((Players > 1) &&
544 (OverRide == 0) &&
545 (cost >= Expensive) &&
546 (view != NULL) &&
547 (view->super_user == 0)) {
548 return -3;
549 }
550
551 /* take care of the money situtation here */
552 Spend(cost);
553 UpdateFunds();
554
555 mapV = v; holdMapH = h;
556
557 for (rowNum = 0; rowNum <= 3; rowNum++) {
558 mapH = holdMapH;
559
560 for (columnNum = 0; columnNum <= 3; columnNum++) {
561 if (columnNum == 1 && rowNum == 1)
562 Map[mapH++][mapV] = base + BNCNBIT + ZONEBIT;
563 else if (columnNum == 1 && rowNum == 2 && aniFlag)
564 Map[mapH++][mapV] = base + BNCNBIT + ANIMBIT;
565 else
566 Map[mapH++][mapV] = base + BNCNBIT;
567 base++;
568 }
569 mapV++;
570 }
571 check4x4border(xMap, yMap);
572 return 1;
573 }
574
575
576 /* 6x6 */
577
578
579 void
580 check6x6border(short xMap, short yMap)
581 {
582 short xPos, yPos;
583 short cnt;
584
585 xPos = xMap; yPos = yMap - 1;
586 for (cnt = 0; cnt < 6; cnt++) {
587 /* this will do the upper bordering row */
588 ConnecTile(xPos, yPos, &Map[xPos][yPos], 0);
589 xPos++;
590 }
591
592 xPos = xMap - 1; yPos = yMap;
593 for (cnt=0; cnt < 6; cnt++) {
594 /* this will do the left bordering row */
595 ConnecTile(xPos, yPos, &Map[xPos][yPos], 0);
596 yPos++;
597 }
598
599 xPos = xMap; yPos = yMap + 6;
600 for (cnt = 0; cnt < 6; cnt++) {
601 /* this will do the bottom bordering row */
602 ConnecTile(xPos, yPos, &Map[xPos][yPos], 0);
603 xPos++;
604 }
605
606 xPos = xMap + 6; yPos = yMap;
607 for (cnt = 0; cnt < 6; cnt++) {
608 /* this will do the right bordering row */
609 ConnecTile(xPos, yPos, &Map[xPos][yPos], 0);
610 yPos++;
611 }
612 }
613
614
615 short
616 check6x6(SimView *view, short mapH, short mapV, short base, short tool)
617 {
618 register short rowNum, columnNum;
619 short h, v;
620 short holdMapH;
621 short xMap, yMap;
622 short flag;
623 short tileValue;
624 short cost = 0;
625
626 mapH--; mapV--;
627 if ((mapH < 0) || (mapH > (WORLD_X - 6)) ||
628 (mapV < 0) || (mapV > (WORLD_Y - 6)))
629 return -1;
630
631 h = xMap = holdMapH = mapH;
632 v = yMap = mapV;
633
634 flag = 1;
635
636 for (rowNum = 0; rowNum <= 5; rowNum++) {
637 mapH = holdMapH;
638
639 for (columnNum = 0; columnNum <= 5; columnNum++) {
640 tileValue = Map[mapH++][mapV] & LOMASK;
641
642 if (autoBulldoze) {
643 /* if autoDoze is enabled, add up the cost of bulldozed tiles */
644 if (tileValue != 0) {
645 if (tally(tileValue)) {
646 cost++;
647 } else {
648 flag = 0;
649 }
650 }
651 } else {
652 /* check and see if the tile is clear or not */
653 if (tileValue != 0) {
654 flag = 0;
655 }
656 }
657 }
658 mapV++;
659 }
660
661 if (flag == 0) {
662 return -1;
663 }
664
665 cost += CostOf[tool];
666
667 if ((TotalFunds - cost) < 0) {
668 return -2;
669 }
670
671 if ((Players > 1) &&
672 (OverRide == 0) &&
673 (cost >= Expensive) &&
674 (view != NULL) &&
675 (view->super_user == 0)) {
676 return -3;
677 }
678
679 /* take care of the money situtation here */
680 Spend(cost);
681 UpdateFunds();
682
683 mapV = v; holdMapH = h;
684
685 for (rowNum = 0; rowNum <= 5; rowNum++) {
686 mapH = holdMapH;
687
688 for (columnNum = 0; columnNum <= 5; columnNum++) {
689 if (columnNum == 1 && rowNum == 1) {
690 Map[mapH++][mapV] = base + BNCNBIT + ZONEBIT;
691 } else {
692 Map[mapH++][mapV] = base + BNCNBIT;
693 }
694 base++;
695 }
696 mapV++;
697 }
698 check6x6border(xMap, yMap);
699 return 1;
700 }
701
702
703 /* QUERY */
704
705
706 /* search table for zone status string match */
707 static short idArray[28] = {
708 DIRT, RIVER, TREEBASE, RUBBLE,
709 FLOOD, RADTILE, FIRE, ROADBASE,
710 POWERBASE, RAILBASE, RESBASE, COMBASE,
711 INDBASE, PORTBASE, AIRPORTBASE, COALBASE,
712 FIRESTBASE, POLICESTBASE, STADIUMBASE, NUCLEARBASE,
713 827, 832, FOUNTAIN, INDBASE2,
714 FOOTBALLGAME1, VBRDG0, 952, 956
715 };
716
717 /*
718 0, 2, 21, 44,
719 48, 52, 53, 64,
720 208, 224, 240, 423,
721 612, 693, 709, 745,
722 761, 770, 779, 811,
723 827, 832, 840, 844,
724 932, 948, 952, 956
725
726 Clear, Water, Trees, Rubble,
727 Flood, Radioactive Waste, Fire, Road,
728 Power, Rail, Residential, Commercial,
729 Industrial, Port, AirPort, Coal Power,
730 Fire Department, Police Department, Stadium, Nuclear Power,
731 Draw Bridge, Radar Dish, Fountain, Industrial,
732 49er's 38 Bears 3, Draw Bridge, Ur 238
733 */
734
735
736 int getDensityStr(short catNo, short mapH, short mapV)
737 {
738 int z;
739
740 switch(catNo) {
741 case 0:
742 z = PopDensity[mapH >>1][mapV >>1];
743 z = z >> 6;
744 z = z & 3;
745 return (z);
746 case 1:
747 z = LandValueMem[mapH >>1][mapV >>1];
748 if (z < 30) return (4);
749 if (z < 80) return (5);
750 if (z < 150) return (6);
751 return (7);
752 case 2:
753 z = CrimeMem[mapH >>1][mapV >>1];
754 z = z >> 6;
755 z = z & 3;
756 return (z + 8);
757 case 3:
758 z = PollutionMem[mapH >>1][mapV >>1];
759 if ((z < 64) && (z > 0)) return (13);
760 z = z >> 6;
761 z = z & 3;
762 return (z + 12);
763 case 4:
764 z = RateOGMem[mapH >>3][mapV >>3];
765 if (z < 0) return (16);
766 if (z == 0) return (17);
767 if (z > 100) return (19);
768 return (18);
769 }
770 return 0;
771 }
772
773
774 void
775 doZoneStatus(short mapH, short mapV)
776 {
777 char localStr[256];
778 char statusStr[5][256];
779 short id;
780 short x;
781 short tileNum;
782 short found;
783
784 tileNum = Map[mapH][mapV] & LOMASK;
785
786 if (tileNum >= COALSMOKE1 && tileNum < FOOTBALLGAME1)
787 tileNum = COALBASE;
788
789 found = 1;
790 for (x = 1; x < 29 && found; x++) {
791 if (tileNum < idArray[x]) {
792 found = 0;
793 }
794 }
795 x--;
796
797 if (x < 1 || x > 28)
798 x = 28;
799
800 GetIndString(localStr, 219, x);
801
802 for (x = 0; x < 5; x++) {
803 id = getDensityStr(x, mapH, mapV);
804 id++;
805 if (id <= 0) id = 1;
806 if (id > 20) id = 20;
807 GetIndString(statusStr[x], 202, id);
808 }
809
810 DoShowZoneStatus(localStr, statusStr[0], statusStr[1],
811 statusStr[2], statusStr[3], statusStr[4], mapH, mapV);
812 }
813
814
815 void
816 DoShowZoneStatus(char *str, char *s0, char *s1, char *s2, char *s3, char *s4,
817 int x, int y)
818 {
819 char buf[1024];
820
821 sprintf(buf, "UIShowZoneStatus {%s} {%s} {%s} {%s} {%s} {%s} %d %d",
822 str, s0, s1, s2, s3, s4, x, y);
823 Eval(buf);
824 }
825
826
827 /* comefrom: processWand */
828 void
829 put3x3Rubble(short x, short y)
830 {
831 register int xx, yy, zz;
832
833 for (xx = x - 1; xx < x + 2; xx++) {
834 for (yy = y - 1; yy < y + 2; yy++) {
835 if (TestBounds(xx, yy)) {
836 zz = Map[xx][yy] & LOMASK;
837 if ((zz != RADTILE) && (zz != 0)) {
838 Map[xx][yy] =
839 (DoAnimation
840 ? (TINYEXP + Rand(2))
841 : SOMETINYEXP)
842 | ANIMBIT | BULLBIT;
843 }
844 }
845 }
846 }
847 }
848
849
850 /* comefrom: processWand */
851 void
852 put4x4Rubble(short x, short y)
853 {
854 register int xx, yy, zz;
855
856 for (xx = x - 1; xx < x + 3; xx++) {
857 for (yy = y - 1; yy < y + 3; yy++) {
858 if (TestBounds(xx, yy)) {
859 zz = Map[xx][yy] & LOMASK;
860 if ((zz != RADTILE) && (zz != 0)) {
861 Map[xx][yy] =
862 (DoAnimation
863 ? (TINYEXP + Rand(2))
864 : SOMETINYEXP)
865 | ANIMBIT | BULLBIT;
866 }
867 }
868 }
869 }
870 }
871
872
873 /* comefrom: processWand */
874 void
875 put6x6Rubble(short x, short y)
876 {
877 register int xx, yy, zz;
878
879 for (xx = x - 1; xx < x + 5; xx++) {
880 for (yy = y - 1; yy < y + 5; yy++) {
881 if (TestBounds(xx, yy)) {
882 zz = Map[xx][yy] & LOMASK;
883 if ((zz != RADTILE) && (zz != 0)) {
884 Map[xx][yy] =
885 (DoAnimation
886 ? (TINYEXP + Rand(2))
887 : SOMETINYEXP)
888 | ANIMBIT | BULLBIT;
889 }
890 }
891 }
892 }
893 }
894
895
896 void
897 DidTool(SimView *view, char *name, short x, short y)
898 {
899 char buf[256];
900
901 if (view != NULL) {
902 sprintf(buf, "UIDidTool%s %s %d %d",
903 name, Tk_PathName(view->tkwin), x, y);
904 Eval(buf);
905 }
906 }
907
908
909 void
910 DoSetWandState(SimView *view, short state)
911 {
912 char buf[256];
913
914 sprintf(buf, "UISetToolState %s %d", Tk_PathName(view->tkwin), state);
915 Eval(buf);
916 }
917
918
919 /************************************************************************/
920 /* TOOLS */
921
922
923 int
924 query_tool(SimView *view, short x, short y)
925 {
926 if ((x < 0) || (x > (WORLD_X - 1)) ||
927 (y < 0) || (y > (WORLD_Y - 1))) {
928 return -1;
929 }
930
931 doZoneStatus(x, y);
932 DidTool(view, "Qry", x, y);
933 return 1;
934 }
935
936
937 int
938 bulldozer_tool(SimView *view, short x, short y)
939 {
940 unsigned short currTile, temp;
941 short zoneSize, deltaH, deltaV;
942 int result = 1;
943
944 if ((x < 0) || (x > (WORLD_X - 1)) ||
945 (y < 0) || (y > (WORLD_Y - 1))) {
946 return -1;
947 }
948
949 currTile = Map[x][y];
950 temp = currTile & LOMASK;
951
952 if (currTile & ZONEBIT) { /* zone center bit is set */
953 if (TotalFunds > 0) {
954 Spend(1);
955 switch (checkSize(temp)) {
956 case 3:
957 MakeSound("city", "Explosion-High");
958 put3x3Rubble(x, y);
959 break;
960
961 case 4:
962 put4x4Rubble(x, y);
963 MakeSound("city", "Explosion-Low");
964 break;
965
966 case 6:
967 MakeSound("city", "Explosion-High");
968 MakeSound("city", "Explosion-Low");
969 put6x6Rubble(x, y);
970 break;
971
972 default:
973 break;
974 }
975 }
976 } else if ((zoneSize = checkBigZone(temp, &deltaH, &deltaV))) {
977 if (TotalFunds > 0) {
978 Spend(1);
979 switch (zoneSize) {
980 case 3:
981 MakeSound("city", "Explosion-High");
982 break;
983
984 case 4:
985 MakeSound("city", "Explosion-Low");
986 put4x4Rubble(x + deltaH, y + deltaV);
987 break;
988
989 case 6:
990 MakeSound("city", "Explosion-High");
991 MakeSound("city", "Explosion-Low");
992 put6x6Rubble(x + deltaH, y + deltaV);
993 break;
994 }
995 }
996 } else {
997 if (temp == RIVER || temp == REDGE || temp == CHANNEL) {
998 if (TotalFunds >= 6) {
999 result = ConnecTile(x, y, &Map[x][y], 1);
1000 if (temp != (Map[x][y] & LOMASK)) {
1001 Spend(5);
1002 }
1003 } else {
1004 result = 0;
1005 }
1006 } else {
1007 result = ConnecTile(x, y, &Map[x][y], 1);
1008 }
1009 }
1010 UpdateFunds();
1011 if (result == 1) {
1012 DidTool(view, "Dozr", x, y);
1013 }
1014 return result;
1015 }
1016
1017
1018 int
1019 road_tool(SimView *view, short x, short y)
1020 {
1021 int result;
1022
1023 if ((x < 0) || (x > (WORLD_X - 1)) ||
1024 (y < 0) || (y > (WORLD_Y - 1))) {
1025 return -1;
1026 }
1027
1028 result = ConnecTile(x, y, &Map[x][y], 2);
1029 UpdateFunds();
1030 if (result == 1) {
1031 DidTool(view, "Road", x, y);
1032 }
1033 return result;
1034 }
1035
1036
1037 int
1038 rail_tool(SimView *view, short x, short y)
1039 {
1040 int result;
1041
1042 if ((x < 0) || (x > (WORLD_X - 1)) ||
1043 (y < 0) || (y > (WORLD_Y - 1))) {
1044 return -1;
1045 }
1046
1047 result = ConnecTile(x, y, &Map[x][y], 3);
1048 UpdateFunds();
1049 if (result == 1) {
1050 DidTool(view, "Rail", x, y);
1051 }
1052 return result;
1053 }
1054
1055
1056 int
1057 wire_tool(SimView *view, short x, short y)
1058 {
1059 int result;
1060
1061 if ((x < 0) || (x > (WORLD_X - 1)) ||
1062 (y < 0) || (y > (WORLD_Y - 1))) {
1063 return -1;
1064 }
1065
1066 result = ConnecTile(x, y, &Map[x][y], 4);
1067 UpdateFunds();
1068 if (result == 1) {
1069 DidTool(view, "Wire", x, y);
1070 }
1071 return result;
1072 }
1073
1074
1075 int
1076 park_tool(SimView *view, short x, short y)
1077 {
1078 int result;
1079
1080 if ((x < 0) || (x > (WORLD_X - 1)) ||
1081 (y < 0) || (y > (WORLD_Y - 1)))
1082 return -1;
1083
1084 result = putDownPark(view, x, y);
1085 if (result == 1) {
1086 DidTool(view, "Park", x, y);
1087 }
1088 return result;
1089 }
1090
1091
1092 int
1093 residential_tool(SimView *view, short x, short y)
1094 {
1095 int result;
1096
1097 if ((x < 0) || (x > (WORLD_X - 1)) ||
1098 (y < 0) || (y > (WORLD_Y - 1))) {
1099 return -1;
1100 }
1101
1102 result = check3x3(view, x, y, RESBASE, residentialState);
1103 if (result == 1) {
1104 DidTool(view, "Res", x, y);
1105 }
1106 return result;
1107 }
1108
1109
1110 int
1111 commercial_tool(SimView *view, short x, short y)
1112 {
1113 int result;
1114
1115 if ((x < 0) || (x > (WORLD_X - 1)) ||
1116 (y < 0) || (y > (WORLD_Y - 1))) {
1117 return -1;
1118 }
1119
1120 result = check3x3(view, x, y, COMBASE, commercialState);
1121 if (result == 1) {
1122 DidTool(view, "Com", x, y);
1123 }
1124 return result;
1125 }
1126
1127
1128 int
1129 industrial_tool(SimView *view, short x, short y)
1130 {
1131 int result;
1132
1133 if ((x < 0) || (x > (WORLD_X - 1)) ||
1134 (y < 0) || (y > (WORLD_Y - 1))) {
1135 return -1;
1136 }
1137
1138 result = check3x3(view, x, y, INDBASE, industrialState);
1139 if (result == 1) {
1140 DidTool(view, "Ind", x, y);
1141 }
1142 return result;
1143 }
1144
1145
1146 int
1147 police_dept_tool(SimView *view, short x, short y)
1148 {
1149 int result;
1150
1151 if ((x < 0) || (x > (WORLD_X - 1)) ||
1152 (y < 0) || (y > (WORLD_Y - 1))) {
1153 return -1;
1154 }
1155
1156 result = check3x3(view, x, y, POLICESTBASE, policeState);
1157 if (result == 1) {
1158 DidTool(view, "Pol", x, y);
1159 }
1160 return result;
1161 }
1162
1163
1164 int
1165 fire_dept_tool(SimView *view, short x, short y)
1166 {
1167 int result;
1168
1169 if ((x < 0) || (x > (WORLD_X - 1)) ||
1170 (y < 0) || (y > (WORLD_Y - 1))) {
1171 return -1;
1172 }
1173
1174 result = check3x3(view, x, y, FIRESTBASE, fireState);
1175 if (result == 1) {
1176 DidTool(view, "Fire", x, y);
1177 }
1178 return result;
1179 }
1180
1181
1182 int
1183 stadium_tool(SimView *view, short x, short y)
1184 {
1185 int result;
1186
1187 if ((x < 0) || (x > (WORLD_X - 1)) ||
1188 (y < 0) || (y > (WORLD_Y - 1))) {
1189 return -1;
1190 }
1191
1192 result = check4x4(view, x, y, STADIUMBASE, 0, stadiumState);
1193 if (result == 1) {
1194 DidTool(view, "Stad", x, y);
1195 }
1196 return result;
1197 }
1198
1199
1200 int
1201 coal_power_plant_tool(SimView *view, short x, short y)
1202 {
1203 int result;
1204
1205 if ((x < 0) || (x > (WORLD_X - 1)) ||
1206 (y < 0) || (y > (WORLD_Y - 1))) {
1207 return -1;
1208 }
1209
1210 result = check4x4(view, x, y, COALBASE, 1, powerState);
1211 if (result == 1) {
1212 DidTool(view, "Coal", x, y);
1213 }
1214 return result;
1215 }
1216
1217
1218 int
1219 nuclear_power_plant_tool(SimView *view, short x, short y)
1220 {
1221 int result;
1222
1223 if ((x < 0) || (x > (WORLD_X - 1)) ||
1224 (y < 0) || (y > (WORLD_Y - 1))) {
1225 return -1;
1226 }
1227
1228 result = check4x4(view, x, y, NUCLEARBASE, 1, nuclearState);
1229 if (result == 1) {
1230 DidTool(view, "Nuc", x, y);
1231 }
1232 return result;
1233 }
1234
1235
1236 int
1237 seaport_tool(SimView *view, short x, short y)
1238 {
1239 int result;
1240
1241 if ((x < 0) || (x > (WORLD_X - 1)) ||
1242 (y < 0) || (y > (WORLD_Y - 1))) {
1243 return -1;
1244 }
1245
1246 result = check4x4(view, x, y, PORTBASE, 0, seaportState);
1247 if (result == 1) {
1248 DidTool(view, "Seap", x, y);
1249 }
1250 return result;
1251 }
1252
1253
1254 int
1255 airport_tool(SimView *view, short x, short y)
1256 {
1257 int result;
1258
1259 if ((x < 0) || (x > (WORLD_X - 1)) ||
1260 (y < 0) || (y > (WORLD_Y - 1))) {
1261 return -1;
1262 }
1263
1264 result = check6x6(view, x, y, AIRPORTBASE, airportState);
1265 if (result == 1) {
1266 DidTool(view, "Airp", x, y);
1267 }
1268 return result;
1269 }
1270
1271
1272 int
1273 network_tool(SimView *view, short x, short y)
1274 {
1275 int result;
1276
1277 if ((x < 0) || (x > (WORLD_X - 1)) ||
1278 (y < 0) || (y > (WORLD_Y - 1))) {
1279 return -1;
1280 }
1281
1282 result = putDownNetwork(view, x, y);
1283 if (result == 1) {
1284 DidTool(view, "Net", x, y);
1285 }
1286 return result;
1287 }
1288
1289
1290 #if 0
1291 int
1292 special_tool(SimView *view, short x, short y)
1293 {
1294 int result;
1295
1296 if ((x < 0) || (x > (WORLD_X - 1)) ||
1297 (y < 0) || (y > (WORLD_Y - 1))) {
1298 return -1;
1299 }
1300
1301 result = check3x3(view, x, y, specialBase, specialState);
1302 if (result == 1) {
1303 DidTool(view, "Special", x, y);
1304 }
1305 return result;
1306 }
1307 #endif
1308
1309 int
1310 ChalkTool(SimView *view, short x, short y, short color, short first)
1311 {
1312 if (first) {
1313 ChalkStart(view, x, y, color);
1314 } else {
1315 ChalkTo(view, x, y);
1316 }
1317 DidTool(view, "Chlk", x, y);
1318 return 1;
1319 }
1320
1321
1322 void
1323 ChalkStart(SimView *view, int x, int y, int color)
1324 {
1325 Ink *ink;
1326 Ink **ip;
1327
1328 for (ip = &sim->overlay; *ip != NULL; ip = &((*ip)->next)) ;
1329
1330 *ip = ink = NewInk();
1331 ink->x = x; ink->y = y;
1332 ink->color = color;
1333 StartInk(ink, x, y);
1334 view->track_info = (char *)ink;
1335 view->last_x = x;
1336 view->last_y = y;
1337 view->tool_event_time = view->tool_last_event_time =
1338 ((TkWindow *)view->tkwin)->dispPtr->lastEventTime;
1339 }
1340
1341
1342 void
1343 ChalkTo(SimView *view, int x, int y)
1344 {
1345 #ifdef MOTIONBUFFER
1346 int x0, y0, lx, ly;
1347 #endif
1348 Ink *ink = (Ink *)view->track_info;
1349
1350 #ifdef MOTIONBUFFER
1351 if (view->x->dpy->motion_buffer) {
1352 XTimeCoord *coords = NULL, *coord;
1353 int n = 0, i;
1354
1355 view->tool_last_event_time = view->tool_event_time;
1356 view->tool_event_time =
1357 ((TkWindow *)view->tkwin)->dispPtr->lastEventTime;
1358
1359 coords = XGetMotionEvents(view->x->dpy,
1360 Tk_WindowId(view->tkwin),
1361 view->tool_last_event_time,
1362 view->tool_event_time,
1363 &n);
1364 #if 0
1365 printf("got %d events at %x from %d to %d (%d elapsed)\n",
1366 n, coords,
1367 view->tool_last_event_time, view->tool_event_time,
1368 view->tool_event_time - view->tool_last_event_time);
1369 #endif
1370 if (n) {
1371 lx = ink->last_x; ly = ink->last_y;
1372
1373 for (i = 0, coord = coords; i < n; i++, coord++) {
1374 ViewToPixelCoords(view, coord->x, coord->y, &x0, &y0);
1375 lx = (lx + lx + lx + x0) >>2;
1376 ly = (ly + ly + ly + y0) >>2;
1377 #if 0
1378 printf("adding %d %d => %d %d => %d %d\n",
1379 coord->x, coord->y, x0, y0, lx, ly);
1380 #endif
1381 AddInk(ink, lx, ly);
1382 }
1383 }
1384
1385 if (coords) {
1386 XFree((char *)coords);
1387 }
1388 }
1389 #endif
1390
1391 AddInk(ink, x, y);
1392 view->last_x = x;
1393 view->last_y = y;
1394 }
1395
1396
1397 int
1398 EraserTool(SimView *view, short x, short y, short first)
1399 {
1400 if (first) {
1401 EraserStart(view, x, y);
1402 } else {
1403 EraserTo(view, x, y);
1404 }
1405 DidTool(view, "Eraser", x, y);
1406 return 1;
1407 }
1408
1409
1410 int
1411 InkInBox(Ink *ink, int left, int top, int right, int bottom)
1412 {
1413 if ((left <= ink->right) &&
1414 (right >= ink->left) &&
1415 (top <= ink->bottom) &&
1416 (bottom >= ink->top)) {
1417 int x, y, lx, ly, i;
1418
1419 if (ink->length == 1) {
1420 return 1;
1421 }
1422
1423 x = ink->x; y = ink->y;
1424 for (i = 1; i < ink->length; i++) {
1425 int ileft, iright, itop, ibottom;
1426
1427 lx = x; ly = y;
1428 x += ink->points[i].x; y += ink->points[i].y;
1429 if (x < lx) { ileft = x; iright = lx; }
1430 else { ileft = lx; iright = x; }
1431 if (y < ly) { itop = y; ibottom = ly; }
1432 else { itop = ly; ibottom = y; }
1433 if ((left <= iright) &&
1434 (right >= ileft) &&
1435 (top <= ibottom) &&
1436 (bottom >= itop)) {
1437 return 1;
1438 }
1439 }
1440 }
1441 return 0;
1442 }
1443
1444
1445 void
1446 EraserStart(SimView *view, int x, int y)
1447 {
1448 EraserTo(view, x, y);
1449 }
1450
1451
1452 void
1453 EraserTo(SimView *view, int x, int y)
1454 {
1455 Ink **ip, *ink;
1456
1457 for (ip = &sim->overlay; *ip != NULL;) {
1458 ink = *ip;
1459 if (InkInBox(ink, x - 8, y - 8, x + 8, y + 8)) {
1460
1461 for (view = sim->editor; view != NULL; view = view->next) {
1462 int vleft, vtop;
1463
1464 if ((ink->right >= (vleft = (view->pan_x - (view->w_width / 2)))) &&
1465 (ink->left <= (vleft + view->w_width)) &&
1466 (ink->bottom >= (vtop = (view->pan_y - (view->w_height / 2)))) &&
1467 (ink->top <= (vtop + view->w_height))) {
1468 view->overlay_mode = 0;
1469 EventuallyRedrawView(view);
1470 }
1471 }
1472
1473 *ip = ink->next;
1474
1475 FreeInk(ink);
1476 } else {
1477 ip = &((*ip)->next);
1478 }
1479 }
1480 }
1481
1482
1483 int
1484 do_tool(SimView *view, short state, short x, short y, short first)
1485 {
1486 int result = 0;
1487
1488 switch (state) {
1489 case residentialState:
1490 result = residential_tool(view, x >>4, y >>4);
1491 break;
1492 case commercialState:
1493 result = commercial_tool(view, x >>4, y >>4);
1494 break;
1495 case industrialState:
1496 result = industrial_tool(view, x >>4, y >>4);
1497 break;
1498 case fireState:
1499 result = fire_dept_tool(view, x >>4, y >>4);
1500 break;
1501 case queryState:
1502 result = query_tool(view, x >>4, y >>4);
1503 break;
1504 case policeState:
1505 result = police_dept_tool(view, x >>4, y >>4);
1506 break;
1507 case wireState:
1508 result = wire_tool(view, x >>4, y >>4);
1509 break;
1510 case dozeState:
1511 result = bulldozer_tool(view, x >>4, y >>4);
1512 break;
1513 case rrState:
1514 result = rail_tool(view, x >>4, y >>4);
1515 break;
1516 case roadState:
1517 result = road_tool(view, x >>4, y >>4);
1518 break;
1519 case chalkState:
1520 result = ChalkTool(view, x - 5, y + 11, COLOR_WHITE, first);
1521 break;
1522 case eraserState:
1523 result = EraserTool(view, x, y, first);
1524 break;
1525 case stadiumState:
1526 result = stadium_tool(view, x >>4, y >>4);
1527 break;
1528 case parkState:
1529 result = park_tool(view, x >>4, y >>4);
1530 break;
1531 case seaportState:
1532 result = seaport_tool(view, x >>4, y >>4);
1533 break;
1534 case powerState:
1535 result = coal_power_plant_tool(view, x >>4, y >>4);
1536 break;
1537 case nuclearState:
1538 result = nuclear_power_plant_tool(view, x >>4, y >>4);
1539 break;
1540 case airportState:
1541 result = airport_tool(view, x >>4, y >>4);
1542 break;
1543 case networkState:
1544 result = network_tool(view, x >>4, y >>4);
1545 break;
1546
1547 default:
1548 result = 0;
1549 break;
1550 }
1551
1552 return result;
1553 }
1554
1555
1556 int
1557 current_tool(SimView *view, short x, short y, short first)
1558 {
1559 return do_tool(view, view->tool_state, x, y, first);
1560 }
1561
1562
1563 void
1564 DoTool(SimView *view, short tool, short x, short y)
1565 {
1566 int result;
1567
1568 result = do_tool(view, tool, x <<4, y <<4, 1);
1569
1570 if (result == -1) {
1571 ClearMes();
1572 SendMes(34);
1573 MakeSoundOn(view, "edit", "UhUh");
1574 } else if (result == -2) {
1575 ClearMes();
1576 SendMes(33);
1577 MakeSoundOn(view, "edit", "Sorry");
1578 }
1579
1580 sim_skip = 0;
1581 view->skip = 0;
1582 InvalidateEditors();
1583 }
1584
1585
1586 void
1587 ToolDown(SimView *view, int x, int y)
1588 {
1589 int result;
1590
1591 ViewToPixelCoords(view, x, y, &x, &y);
1592 view->last_x = x;
1593 view->last_y = y;
1594
1595 result = current_tool(view, x, y, 1);
1596
1597 if (result == -1) {
1598 ClearMes();
1599 SendMes(34);
1600 MakeSoundOn(view, "edit", "UhUh");
1601 } else if (result == -2) {
1602 ClearMes();
1603 SendMes(33);
1604 MakeSoundOn(view, "edit", "Sorry");
1605 } else if (result == -3) {
1606 DoPendTool(view, view->tool_state, x >>4, y >>4);
1607 }
1608
1609 sim_skip = 0;
1610 view->skip = 0;
1611 view->invalid = 1;
1612 }
1613
1614
1615 void
1616 ToolUp(SimView *view, int x, int y)
1617 {
1618 ToolDrag(view, x, y);
1619 }
1620
1621
1622 void
1623 ToolDrag(SimView *view, int px, int py)
1624 {
1625 int x, y, dx, dy, adx, ady, lx, ly, dist;
1626 float i, step, tx, ty, dtx, dty, rx, ry;
1627
1628 ViewToPixelCoords(view, px, py, &x, &y);
1629 view->tool_x = x; view->tool_y = y;
1630
1631 if ((view->tool_state == chalkState) ||
1632 (view->tool_state == eraserState)) {
1633
1634 current_tool(view, x, y, 0);
1635 view->last_x = x; view->last_y = y;
1636
1637 } else {
1638
1639 dist = toolSize[view->tool_state];
1640
1641 x >>= 4; y >>= 4;
1642 lx = view->last_x >> 4;
1643 ly = view->last_y >> 4;
1644
1645 dx = x - lx;
1646 dy = y - ly;
1647
1648 if (dx == 0 && dy == 0) {
1649 return;
1650 }
1651
1652 adx = ABS(dx); ady = ABS(dy);
1653
1654 if (adx > ady) {
1655 step = .3 / adx;
1656 } else {
1657 step = .3 / ady;
1658 }
1659
1660 rx = (dx < 0 ? 1 : 0);
1661 ry = (dy < 0 ? 1 : 0);
1662
1663 if (dist == 1) {
1664 for (i = 0.0; i <= 1 + step; i += step) {
1665 tx = (view->last_x >>4) + i * dx;
1666 ty = (view->last_y >>4) + i * dy;
1667 dtx = ABS(tx - lx);
1668 dty = ABS(ty - ly);
1669 if (dtx >= 1 || dty >= 1) {
1670 /* fill in corners */
1671 if ((dtx >= 1) && (dty >= 1)) {
1672 if (dtx > dty) {
1673 current_tool(view, ((int)(tx + rx)) <<4, ly <<4, 0);
1674 } else {
1675 current_tool(view, lx <<4, ((int)(ty + ry)) <<4, 0);
1676 }
1677 }
1678 lx = (int)(tx + rx);
1679 ly = (int)(ty + ry);
1680 current_tool(view, lx <<4, ly <<4, 0);
1681 }
1682 }
1683 } else {
1684 for (i = 0.0; i <= 1 + step; i += step) {
1685 tx = (view->last_x >>4) + i * dx;
1686 ty = (view->last_y >>4) + i * dy;
1687 dtx = ABS(tx - lx);
1688 dty = ABS(ty - ly);
1689 lx = (int)(tx + rx);
1690 ly = (int)(ty + ry);
1691 current_tool(view, lx <<4, ly <<4, 0);
1692 }
1693 }
1694
1695 view->last_x = (lx <<4) + 8;
1696 view->last_y = (ly <<4) + 8;
1697 }
1698 sim_skip = 0; /* update editors overlapping this one */
1699 view->skip = 0;
1700 view->invalid = 1;
1701 }
1702
1703
1704 void
1705 DoPendTool(SimView *view, int tool, int x, int y)
1706 {
1707 char buf[256];
1708
1709 sprintf(buf, "DoPendTool %s %d %d %d",
1710 Tk_PathName(view->tkwin), tool, x, y);
1711 Eval(buf);
1712 }
Micropolis
Impressum, Datenschutz