home · contact · privacy
TCE: Prefix hole creation with crack hierarchy, fix some bugs.
[plomrogue] / libplomrogue.c
1 #include <math.h> /* pow() */
2 #include <stddef.h> /* NULL */
3 #include <stdint.h> /* ?(u)int(8|16|32)_t, ?(U)INT8_(MIN|MAX) */
4 #include <stdlib.h> /* free, malloc */
5 #include <string.h> /* memset */
6
7 /* Number of degrees a circle is divided into. The greater it is, the greater
8  * the angle precision. But make it one whole zero larger and bizarre FOV bugs
9  * appear on large maps, probably due to value overflows (TODO: more research!).
10  */
11 #define CIRCLE 3600000
12
13 /* Angle of a shadow. */
14 struct shadow_angle
15 {
16     struct shadow_angle * next;
17     uint32_t left_angle;
18     uint32_t right_angle;
19 };
20
21 /* To be used as temporary storage for world map array. */
22 static char * worldmap = NULL;
23
24 /* Coordinate for maps of max. 256x256 cells. */
25 struct yx_uint8
26 {
27     uint8_t y;
28     uint8_t x;
29 };
30
31 /* Storage for map_length, set by set_maplength(). */
32 static uint16_t maplength = 0;
33 extern void set_maplength(uint16_t maplength_input)
34 {
35     maplength = maplength_input;
36 }
37
38 /* Pseudo-randomness seed for rrand(), set by seed_rrand(). */
39 static uint32_t seed = 0;
40
41 /* Helper to mv_yx_in_dir_legal(). Move "yx" into hex direction "d". */
42 static void mv_yx_in_dir(char d, struct yx_uint8 * yx)
43 {
44     if      (d == 'e')
45     {
46         yx->x = yx->x + (yx->y % 2);
47         yx->y--;
48     }
49     else if (d == 'd')
50     {
51         yx->x++;
52     }
53     else if (d == 'c')
54     {
55         yx->x = yx->x + (yx->y % 2);
56         yx->y++;
57     }
58     else if (d == 'x')
59     {
60         yx->x = yx->x - !(yx->y % 2);
61         yx->y++;
62     }
63     else if (d == 's')
64     {
65         yx->x--;
66     }
67     else if (d == 'w')
68     {
69         yx->x = yx->x - !(yx->y % 2);
70         yx->y--;
71     }
72 }
73
74 /* Move "yx" into hex direction "dir". Available hex directions are: 'e'
75  * (north-east), 'd' (east), 'c' (south-east), 'x' (south-west), 's' (west), 'w'
76  * (north-west). Returns 1 if the move was legal, 0 if not, and -1 when internal
77  * wrapping limits were exceeded.
78  *
79  * A move is legal if "yx" ends up within the the map and the original wrap
80  * space. The latter is left to a neighbor wrap space if "yx" moves beyond the
81  * minimal (0) or maximal (UINT8_MAX) column or row of possible map space – in
82  * which case "yx".y or "yx".x will snap to the respective opposite side. The
83  * current wrapping state is kept between successive calls until a "yx" of NULL
84  * is passed, in which case the function does nothing but zero the wrap state.
85  * Successive wrapping may move "yx" several wrap spaces into either direction,
86  * or return it into the original wrap space.
87  */
88 static int8_t mv_yx_in_dir_legal(char dir, struct yx_uint8 * yx)
89 {
90     static int8_t wrap_west_east   = 0;
91     static int8_t wrap_north_south = 0;
92     if (!yx)
93     {
94         wrap_west_east = wrap_north_south = 0;
95         return 0;
96     }
97     if (   INT8_MIN == wrap_west_east || INT8_MIN == wrap_north_south
98         || INT8_MAX == wrap_west_east || INT8_MAX == wrap_north_south)
99     {
100         return -1;
101     }
102     struct yx_uint8 original = *yx;
103     mv_yx_in_dir(dir, yx);
104     if      (('e' == dir || 'd' == dir || 'c' == dir) && yx->x < original.x)
105     {
106         wrap_west_east++;
107     }
108     else if (('x' == dir || 's' == dir || 'w' == dir) && yx->x > original.x)
109     {
110         wrap_west_east--;
111     }
112     if      (('w' == dir || 'e' == dir)               && yx->y > original.y)
113     {
114         wrap_north_south--;
115     }
116     else if (('x' == dir || 'c' == dir)               && yx->y < original.y)
117     {
118         wrap_north_south++;
119     }
120     if (   !wrap_west_east && !wrap_north_south
121         && yx->x < maplength && yx->y < maplength)
122     {
123         return 1;
124     }
125     return 0;
126 }
127
128 /* Wrapper around mv_yx_in_dir_legal() that stores new coordinate in res_y/x,
129  * (return with result_y/x()), and immediately resets the wrapping.
130  */
131 static uint8_t res_y = 0;
132 static uint8_t res_x = 0;
133 extern uint8_t mv_yx_in_dir_legal_wrap(char dir, uint8_t y, uint8_t x)
134 {
135     struct yx_uint8 yx;
136     yx.y = y;
137     yx.x = x;
138     uint8_t result = mv_yx_in_dir_legal(dir, &yx);
139     mv_yx_in_dir_legal(0, NULL);
140     res_y = yx.y;
141     res_x = yx.x;
142     return result;
143 }
144 extern uint8_t result_y()
145 {
146     return res_y;
147 }
148 extern uint8_t result_x()
149 {
150     return res_x;
151 }
152
153 /* With set_seed set, set seed global to seed_input. In any case, return it. */
154 extern uint32_t seed_rrand(uint8_t set_seed, uint32_t seed_input)
155 {
156     if (set_seed)
157     {
158         seed = seed_input;
159     }
160     return seed;
161 }
162
163 /* Return 16-bit number pseudo-randomly generated via Linear Congruential
164  * Generator algorithm with some proven constants. Use instead of any rand() to
165   * ensure portability of the same pseudo-randomness across systems.
166  */
167 extern uint16_t rrand()
168 {   /* Constants as recommended by POSIX.1-2001 (see man page rand(3)). */
169     seed = ((seed * 1103515245) + 12345) % 4294967296;
170     return (seed >> 16); /* Ignore less random least significant bits. */
171 }
172
173 /* Free shadow angles list "angles". */
174 static void free_angles(struct shadow_angle * angles)
175 {
176     if (angles->next)
177     {
178         free_angles(angles->next);
179     }
180     free(angles);
181 }
182
183 /* Recalculate angle < 0 or > CIRCLE to a value between these two limits. */
184 static uint32_t correct_angle(int32_t angle)
185 {
186     while (angle < 0)
187     {
188         angle = angle + CIRCLE;
189     }
190     while (angle > CIRCLE)
191     {
192         angle = angle - CIRCLE;
193     }
194     return angle;
195 }
196
197 /* Try merging the angle between "left_angle" and "right_angle" to "shadow" if
198  * it meets the shadow from the right or the left. Returns 1 on success, else 0.
199  */
200 static uint8_t try_merge(struct shadow_angle * shadow,
201                          uint32_t left_angle, uint32_t right_angle)
202 {
203     if      (   shadow->right_angle <= left_angle + 1
204              && shadow->right_angle >= right_angle)
205     {
206         shadow->right_angle = right_angle;
207     }
208     else if (   shadow->left_angle + 1 >= right_angle
209              && shadow->left_angle     <= left_angle)
210     {
211         shadow->left_angle = left_angle;
212     }
213     else
214     {
215         return 0;
216     }
217     return 1;
218 }
219
220 /* Try merging the shadow angle between "left_angle" and "right_angle" into an
221  * existing shadow angle in "shadows". On success, see if this leads to any
222  * additional shadow angle overlaps and merge these accordingly. Return 1 on
223  * success, else 0.
224  */
225 static uint8_t try_merging_angles(uint32_t left_angle, uint32_t right_angle,
226                                   struct shadow_angle ** shadows)
227 {
228     uint8_t angle_merge = 0;
229     struct shadow_angle * shadow;
230     for (shadow = *shadows; shadow; shadow = shadow->next)
231     {
232         if (try_merge(shadow, left_angle, right_angle))
233         {
234             angle_merge = 1;
235         }
236     }
237     if (angle_merge)
238     {
239         struct shadow_angle * shadow1;
240         for (shadow1 = *shadows; shadow1; shadow1 = shadow1->next)
241         {
242             struct shadow_angle * last_shadow = NULL;
243             struct shadow_angle * shadow2;
244             for (shadow2 = *shadows; shadow2; shadow2 = shadow2->next)
245             {
246                 if (   shadow1 != shadow2
247                     && try_merge(shadow1, shadow2->left_angle,
248                                           shadow2->right_angle))
249                 {
250                     struct shadow_angle * to_free = shadow2;
251                     if (last_shadow)
252                     {
253                         last_shadow->next = shadow2->next;
254                         shadow2 = last_shadow;
255                     }
256                     else
257                     {
258                         *shadows = shadow2->next;
259                         shadow2 = *shadows;
260                     }
261                     free(to_free);
262                 }
263                 last_shadow = shadow2;
264             }
265         }
266     }
267     return angle_merge;
268 }
269
270 /* To "shadows", add shadow defined by "left_angle" and "right_angle", either as
271  * new entry or as part of an existing shadow (swallowed whole or extending it).
272  * Return 1 on malloc error, else 0.
273  */
274 static uint8_t set_shadow(uint32_t left_angle, uint32_t right_angle,
275                           struct shadow_angle ** shadows)
276 {
277     struct shadow_angle * shadow_i;
278     if (!try_merging_angles(left_angle, right_angle, shadows))
279     {
280         struct shadow_angle * shadow;
281         shadow = malloc(sizeof(struct shadow_angle));
282         if (!shadow)
283         {
284             return 1;
285         }
286         shadow->left_angle  = left_angle;
287         shadow->right_angle = right_angle;
288         shadow->next = NULL;
289         if (*shadows)
290         {
291             for (shadow_i = *shadows; shadow_i; shadow_i = shadow_i->next)
292             {
293                 if (!shadow_i->next)
294                 {
295                     shadow_i->next = shadow;
296                     return 0;
297                 }
298             }
299         }
300         *shadows = shadow;
301     }
302     return 0;
303 }
304
305 /* Test whether angle between "left_angle" and "right_angle", or at least
306  * "middle_angle", is captured inside one of the shadow angles in "shadows". If
307  * so, set hex in "fov_map" indexed by "pos_in_map" to 'H'. If the whole angle
308  * and not just "middle_angle" is captured, return 1. Any other case: 0.
309  */
310 static uint8_t shade_hex(uint32_t left_angle, uint32_t right_angle,
311                          uint32_t middle_angle, struct shadow_angle ** shadows,
312                          uint16_t pos_in_map, char * fov_map)
313 {
314     struct shadow_angle * shadow_i;
315     if (fov_map[pos_in_map] == 'v')
316     {
317         for (shadow_i = *shadows; shadow_i; shadow_i = shadow_i->next)
318         {
319             if (   left_angle <=  shadow_i->left_angle
320                 && right_angle >= shadow_i->right_angle)
321             {
322                 fov_map[pos_in_map] = 'H';
323                 return 1;
324             }
325             if (   middle_angle < shadow_i->left_angle
326                 && middle_angle > shadow_i->right_angle)
327             {
328                 fov_map[pos_in_map] = 'H';
329             }
330         }
331     }
332     return 0;
333 }
334
335 /* Evaluate map position "test_pos" in distance "dist" to the view origin, and
336  * on the circle of that distance to the origin on hex "hex_i" (as counted from
337  * the circle's rightmost point), for setting shaded hexes in "fov_map" and
338  * potentially adding a new shadow to linked shadow angle list "shadows".
339  * Return 1 on malloc error, else 0.
340  */
341 static uint8_t eval_position(uint16_t dist, uint16_t hex_i, char * fov_map,
342                              struct yx_uint8 * test_pos,
343                              struct shadow_angle ** shadows,
344                              const char * symbols_obstacle)
345 {
346     int32_t left_angle_uncorrected =   ((CIRCLE / 12) / dist)
347                                      - (hex_i * (CIRCLE / 6) / dist);
348     int32_t right_angle_uncorrected =   left_angle_uncorrected
349                                       - (CIRCLE / (6 * dist));
350     uint32_t left_angle  = correct_angle(left_angle_uncorrected);
351     uint32_t right_angle = correct_angle(right_angle_uncorrected);
352     uint32_t right_angle_1st = right_angle > left_angle ? 0 : right_angle;
353     uint32_t middle_angle = 0;
354     if (right_angle_1st)
355     {
356         middle_angle = right_angle + ((left_angle - right_angle) / 2);
357     }
358     uint16_t pos_in_map = test_pos->y * maplength + test_pos->x;
359     uint8_t all_shaded = shade_hex(left_angle, right_angle_1st, middle_angle,
360                                    shadows, pos_in_map, fov_map);
361     if (!all_shaded && NULL != strchr(symbols_obstacle, worldmap[pos_in_map]))
362     {
363         if (set_shadow(left_angle, right_angle_1st, shadows))
364         {
365             return 1;
366         }
367         if (right_angle_1st != right_angle)
368         {
369             left_angle = CIRCLE;
370             if (set_shadow(left_angle, right_angle, shadows))
371             {
372                 return 1;
373             }
374         }
375     }
376     return 0;
377 }
378
379 /* Update field of view in "fovmap" of "worldmap_input" as seen from "y"/"x".
380  * Return 1 on malloc error, else 0.
381  */
382 extern uint8_t build_fov_map(uint8_t y, uint8_t x, char * fovmap,
383                              char * worldmap_input,
384                              const char * symbols_obstacle)
385 {
386     worldmap = worldmap_input;
387     struct shadow_angle * shadows = NULL;
388     struct yx_uint8 test_pos;
389     test_pos.y = y;
390     test_pos.x = x;
391     char * circledirs_string = "xswedc";
392     uint16_t circle_i;
393     uint8_t circle_is_on_map;
394     for (circle_i = 1, circle_is_on_map = 1; circle_is_on_map; circle_i++)
395     {
396         circle_is_on_map = 0;
397         if (1 < circle_i)                      /* All circles but the 1st are */
398         {                                      /* moved into starting from a  */
399             mv_yx_in_dir_legal('c', &test_pos);/* previous circle's last hex, */
400         }                                      /* i.e. from the upper left.   */
401         char dir_char = 'd'; /* Circle's 1st hex is entered by rightward move.*/
402         uint8_t dir_char_pos_in_circledirs_string = UINT8_MAX;
403         uint16_t dist_i, hex_i;
404         for (hex_i=0, dist_i=circle_i; hex_i < 6 * circle_i; dist_i++, hex_i++)
405         {
406             if (circle_i < dist_i)
407             {
408                 dist_i = 1;
409                 dir_char=circledirs_string[++dir_char_pos_in_circledirs_string];
410             }
411             if (mv_yx_in_dir_legal(dir_char, &test_pos))
412             {
413                 if (eval_position(circle_i, hex_i, fovmap, &test_pos, &shadows,
414                                   symbols_obstacle))
415                 {
416                     return 1;
417                 }
418                 circle_is_on_map = 1;
419             }
420         }
421     }
422     mv_yx_in_dir_legal(0, NULL);
423     free_angles(shadows);
424     return 0;
425 }
426
427 static uint16_t * score_map = NULL;
428 static uint16_t neighbor_scores[6];
429
430 /* Init AI score map. Return 1 on failure, else 0. */
431 extern uint8_t init_score_map()
432 {
433     uint32_t map_size = maplength * maplength;
434     score_map = malloc(map_size * sizeof(uint16_t));
435     if (!score_map)
436     {
437         return 1;
438     }
439     uint32_t i = 0;
440     for (; i < map_size; i++)
441     {
442         score_map[i] = UINT16_MAX;
443     }
444     return 0;
445 }
446
447 /* Set score_map[pos] to score. Return 1 on failure, else 0. */
448 extern uint8_t set_map_score(uint16_t pos, uint16_t score)
449 {
450     if (!score_map)
451     {
452         return 1;
453     }
454     score_map[pos] = score;
455     return 0;
456 }
457
458 /* Get score_map[pos]. Return uint16_t value on success, -1 on failure. */
459 extern int32_t get_map_score(uint16_t pos)
460 {
461     if (!score_map)
462     {
463         return -1;
464     }
465     return score_map[pos];
466 }
467
468 /* Free score_map. */
469 extern void free_score_map()
470 {
471     free(score_map);
472     score_map = NULL;
473 }
474
475 /* Write into "neighbors" scores of the immediate neighbors of the score_map
476  * cell at pos_i (array index), as found in the directions north-east, east,
477  * south-east etc. (clockwise order). Use kill_score for illegal neighborhoods
478  * (i.e. if direction would lead beyond the map's border).
479  */
480 static void get_neighbor_scores(uint16_t pos_i, uint16_t kill_score,
481                                 uint16_t * neighbors)
482 {
483     uint32_t map_size = maplength * maplength;
484     uint8_t open_north     = pos_i >= maplength;
485     uint8_t open_east      = pos_i + 1 % maplength;
486     uint8_t open_south     = pos_i + maplength < map_size;
487     uint8_t open_west      = pos_i % maplength;
488     uint8_t is_indented    = (pos_i / maplength) % 2;
489     uint8_t open_diag_west = is_indented || open_west;
490     uint8_t open_diag_east = !is_indented || open_east;
491     neighbors[0] = !(open_north && open_diag_east) ? kill_score :
492                    score_map[pos_i - maplength + is_indented];
493     neighbors[1] = !(open_east) ? kill_score : score_map[pos_i + 1];
494     neighbors[2] = !(open_south && open_diag_east) ? kill_score :
495                    score_map[pos_i + maplength + is_indented];
496     neighbors[3] = !(open_south && open_diag_west) ? kill_score :
497                    score_map[pos_i + maplength - !is_indented];
498     neighbors[4] = !(open_west) ? kill_score : score_map[pos_i - 1];
499     neighbors[5] = !(open_north && open_diag_west) ? kill_score :
500                    score_map[pos_i - maplength - !is_indented];
501 }
502
503 /* Call get_neighbor_scores() on neighbor_scores buffer. Return 1 on error. */
504 extern uint8_t ready_neighbor_scores(uint16_t pos)
505 {
506     if (!score_map)
507     {
508         return 1;
509     }
510     get_neighbor_scores(pos, UINT16_MAX, neighbor_scores);
511     return 0;
512 }
513
514 /* Return i-th position from neighbor_scores buffer.*/
515 extern uint16_t get_neighbor_score(uint8_t i)
516 {
517     return neighbor_scores[i];
518 }
519
520 /* Iterate over scored cells in score_map geometry. Compare each cell's score
521  * against the score of its immediate neighbors in 6 directions. If any
522  * neighbor's score is at least two points lower than the current cell's score,
523  * re-set it to 1 point higher than its lowest-scored neighbor. Repeat this
524  * whole process until all cells have settled on their final score. Ignore cells
525  * whose score is greater than UINT16_MAX - 1 (treat those as unreachable). Also
526  * ignore cells whose score is smaller or equal the number of past iterations.
527  * Return 1 on error, else 0.
528  */
529 extern uint8_t dijkstra_map()
530 {
531     if (!score_map)
532     {
533         return 1;
534     }
535     uint16_t max_score = UINT16_MAX - 1;
536     uint32_t map_size = maplength * maplength;
537     uint32_t pos;
538     uint16_t i_scans, neighbors[6], min_neighbor;
539     uint8_t scores_still_changing = 1;
540     uint8_t i_dirs;
541     for (i_scans = 0; scores_still_changing; i_scans++)
542     {
543         scores_still_changing = 0;
544         for (pos = 0; pos < map_size; pos++)
545         {
546             uint16_t score = score_map[pos];
547             if (score <= max_score && score > i_scans)
548             {
549                 get_neighbor_scores(pos, max_score, neighbors);
550                 min_neighbor = max_score;
551                 for (i_dirs = 0; i_dirs < 6; i_dirs++)
552                 {
553                     if (min_neighbor > neighbors[i_dirs])
554                     {
555                         min_neighbor = neighbors[i_dirs];
556                     }
557                 }
558                 if (score_map[pos] > min_neighbor + 1)
559                 {
560                     score_map[pos] = min_neighbor + 1;
561                     scores_still_changing = 1;
562                 }
563             }
564         }
565     }
566     return 0;
567 }
568
569
570 /* 7DRL/TCE addition: Init AI score map to all-eatable unknown fields. */
571 extern uint8_t TCE_init_score_map()
572 {
573     uint32_t map_size = maplength * maplength;
574     score_map = malloc(map_size * sizeof(uint16_t));
575     if (!score_map)
576     {
577         return 1;
578     }
579     uint32_t i = 0;
580     for (; i < map_size; i++)
581     {
582         score_map[i] = UINT16_MAX - 1;
583     }
584     return 0;
585 }
586
587 /* 7DRL/TCE addition: movement cost map setting. */
588 static uint8_t * TCE_move_cost_map = NULL;
589 extern uint8_t TCE_set_movement_cost_map(char * mem_map)
590 {
591     uint32_t map_size = maplength * maplength;
592     free(TCE_move_cost_map);
593     TCE_move_cost_map = malloc(map_size * sizeof(uint8_t));
594     uint32_t pos = 0;
595     for (; pos < map_size; pos++)
596     {
597         TCE_move_cost_map[pos] = 0;
598     }
599     if (!TCE_move_cost_map)
600     {
601         return 1;
602     }
603     for (pos = 0; pos < map_size; pos++)
604     {
605         switch(mem_map[pos]) {
606             case '0':
607                 TCE_move_cost_map[pos] = 1;
608                 break;
609             case '1':
610                 TCE_move_cost_map[pos] = 2;
611                 break;
612             case '2':
613                 TCE_move_cost_map[pos] = 4;
614                 break;
615             case '3':
616                 TCE_move_cost_map[pos] = 3;
617                 break;
618             case '4':
619                 TCE_move_cost_map[pos] = 6;
620                 break;
621         }
622     }
623     return 0;
624 }
625
626
627 /* 7DRL/TCE addition: Like dijkstra_map(), but with movement costs applied. */
628 extern uint8_t TCE_dijkstra_map_with_movement_cost()
629 {
630     if (!score_map || !TCE_move_cost_map)
631     {
632         return 1;
633     }
634     uint16_t max_score = UINT16_MAX - 1;
635     uint32_t map_size = maplength * maplength;
636     uint32_t pos;
637     uint16_t i_scans, neighbors[6], min_neighbor;
638     uint8_t scores_still_changing = 1;
639     uint8_t i_dirs;
640     for (i_scans = 0; scores_still_changing; i_scans++)
641     {
642         scores_still_changing = 0;
643         for (pos = 0; pos < map_size; pos++)
644         {
645             uint16_t score = score_map[pos];
646             uint8_t mov_cost = TCE_move_cost_map[pos];
647             if (score <= max_score && mov_cost > 0 && score > i_scans)
648             {
649                 get_neighbor_scores(pos, max_score, neighbors);
650                 min_neighbor = max_score;
651                 for (i_dirs = 0; i_dirs < 6; i_dirs++)
652                 {
653                     if (min_neighbor > neighbors[i_dirs])
654                     {
655                         min_neighbor = neighbors[i_dirs];
656                     }
657                 }
658                 if (score_map[pos] > min_neighbor + mov_cost)
659                 {
660                     score_map[pos] = min_neighbor + mov_cost;
661                     scores_still_changing = 1;
662                 }
663             }
664         }
665     }
666     return 0;
667 }
668
669
670 extern uint8_t zero_score_map_where_char_on_memdepthmap(char c,
671                                                         char * memdepthmap)
672 {
673     if (!score_map)
674     {
675         return 1;
676     }
677     uint32_t map_size = maplength * maplength;
678     uint16_t pos;
679     for (pos = 0; pos < map_size; pos++)
680     {
681         if (c == memdepthmap[pos])
682         {
683             score_map[pos] = 0;
684         }
685     }
686     return 0;
687 }
688
689 extern void age_some_memdepthmap_on_nonfov_cells(char * memdepthmap,
690                                                  char * fovmap)
691 {
692     uint32_t map_size = maplength * maplength;
693     uint16_t pos;
694     for (pos = 0; pos < map_size; pos++)
695     {
696         if ('v' != fovmap[pos])
697         {
698             char c = memdepthmap[pos];
699             if( '0' <= c && '9' > c && !(rrand() % (uint16_t) pow(2, c - 48)))
700             {
701                 memdepthmap[pos]++;
702             }
703         }
704     }
705 }
706
707 extern uint8_t set_cells_passable_on_memmap_to_65534_on_scoremap(char * mem_map,
708                                                   const char * symbols_passable)
709 {
710     if (!score_map)
711     {
712         return 1;
713     }
714     uint32_t map_size = maplength * maplength;
715     uint16_t pos;
716     for (pos = 0; pos < map_size; pos++)
717     {
718         if (NULL != strchr(symbols_passable, mem_map[pos]))
719         {
720             score_map[pos] = 65534;
721         }
722     }
723     return 0;
724 }
725
726
727 extern void update_mem_and_memdepthmap_via_fovmap(char * map, char * fovmap,
728                                                   char * memdepthmap,
729                                                   char * memmap)
730 {
731     uint32_t map_size = maplength * maplength;
732     uint16_t pos;
733     for (pos = 0; pos < map_size; pos++)
734     {
735         if ('v' == fovmap[pos])
736         {
737             memdepthmap[pos] = '0';
738             memmap[pos] = map[pos];
739         }
740     }
741 }
742
743 /* USEFUL FOR DEBUGGING
744 #include <stdio.h>
745 extern void write_score_map()
746 {
747     FILE *f = fopen("score_map", "a");
748
749     fprintf(f, "\n---------------------------------------------------------\n");
750     uint32_t y, x;
751     for (y = 0; y < maplength; y++)
752     {
753         for (x = 0; x < maplength; x++)
754         {
755             uint32_t pos = y * maplength + x;
756             uint16_t val = score_map[pos];
757             if (val == UINT16_MAX)
758             {
759                 fprintf(f, " Z");
760             } else if (val == UINT16_MAX - 1) {
761                 fprintf(f, " Y");
762             } else {
763                 fprintf(f, "%2X", score_map[pos] % 256);
764             }
765         }
766         fprintf(f, "\n");
767     }
768     fclose(f);
769 }
770 */