X-Git-Url: https://plomlompom.com/repos/?a=blobdiff_plain;f=src%2Fserver%2Ffield_of_view.c;h=4b1ac00194d6a9498b2e3a5a3a8bba818bb147cd;hb=3dedf6344c941891491773d1cc5d647aa664b218;hp=177143a26389758d053f93d3121321f453eb29dc;hpb=b4e81c08c1b229cac545f38a8f1fc3c08da91d83;p=plomrogue diff --git a/src/server/field_of_view.c b/src/server/field_of_view.c index 177143a..4b1ac00 100644 --- a/src/server/field_of_view.c +++ b/src/server/field_of_view.c @@ -6,8 +6,7 @@ #include /* memset() */ #include "../common/rexit.h" /* exit_trouble() */ #include "../common/try_malloc.h" /* try_malloc() */ -#include "map.h" /* yx_to_map_pos() */ -#include "things.h" /* Thing */ +#include "things.h" /* Thing, ThingInMemory, add_thing_to_memory_map() */ #include "yx_uint8.h" /* yx_uint8 */ #include "world.h" /* world */ @@ -42,8 +41,8 @@ static void mv_yx_in_hex_dir(char d, struct yx_uint8 * yx); */ static uint8_t mv_yx_in_dir_wrap(char d, struct yx_uint8 * yx, uint8_t unwrap); -/* Wrapper to "mv_yx_in_dir_wrap()", returns 1 if the wrapped function moved - * "yx" within the wrap borders and the map size, else 0. +/* Wrapper to mv_yx_in_dir_wrap(), returns 1 if the wrapped function moved "yx" + * within the wrap borders and the map size, else 0. */ static uint8_t mv_yx_in_dir_legal(char dir, struct yx_uint8 * yx); @@ -64,27 +63,32 @@ static uint8_t try_merge(struct shadow_angle * shadow, static uint8_t try_merging_angles(uint32_t left_angle, uint32_t right_angle, struct shadow_angle ** shadows); -/* If "pos_in_map" in angle between"left_angle" to "right_angle" to the viewing - * actor is in a shadow from the shadow list "shadows", mark it as HIDDEN on the - * "fov_map"; else, if the world map features a viewing obstacle on the world - * map, calculate its shadow angle to the viewer and add it to "shadows". +/* Test whether angle between "left_angle" and "right_angle", or at least + * "middle_angle", is captured inside one of the shadow angles in "shadows". If + * so, set hex in "fov_map" indexed by "pos_in_map" to 'H'. If the whole angle + * and not just "middle_angle" is captured, return 1. Any other case: 0. */ -static void set_shadow(uint32_t left_angle, uint32_t right_angle, - struct shadow_angle ** shadows, uint16_t pos_in_map, - uint8_t * fov_map); +static uint8_t shade_hex(uint32_t left_angle, uint32_t right_angle, + uint32_t middle_angle, struct shadow_angle ** shadows, + uint16_t pos_in_map, char * fov_map); /* Free shadow angles list "angles". */ static void free_angles(struct shadow_angle * angles); /* Evaluate map position "test_pos" in distance "dist" to the view origin, and * on the circle of that distance to the origin on hex "hex_i" (as counted from - * the circle's rightmost point), for setting shaded cells in "fov_map" and + * the circle's rightmost point), for setting shaded hexes in "fov_map" and * potentially adding a new shadow to linked shadow angle list "shadows". */ -static void eval_position(uint16_t dist, uint16_t hex_i, uint8_t * fov_map, +static void eval_position(uint16_t dist, uint16_t hex_i, char * fov_map, struct yx_uint8 * test_pos, struct shadow_angle ** shadows); +/* Update "t"'s .mem_map memory with what's in its current FOV, remove from its + * .t_mem all memorized things in FOV and add inanimiate things in FOV to it. + */ +static void update_map_memory(struct Thing * t, uint32_t map_size); + static void mv_yx_in_hex_dir(char d, struct yx_uint8 * yx) @@ -251,46 +255,59 @@ static uint8_t try_merging_angles(uint32_t left_angle, uint32_t right_angle, -static void set_shadow(uint32_t left_angle, uint32_t right_angle, - struct shadow_angle ** shadows, uint16_t pos_in_map, - uint8_t * fov_map) +static uint8_t shade_hex(uint32_t left_angle, uint32_t right_angle, + uint32_t middle_angle, struct shadow_angle ** shadows, + uint16_t pos_in_map, char * fov_map) { - char * f_name = "set_shadow()"; struct shadow_angle * shadow_i; - if (fov_map[pos_in_map] & VISIBLE) + if (fov_map[pos_in_map] == 'v') { for (shadow_i = *shadows; shadow_i; shadow_i = shadow_i->next) { if ( left_angle <= shadow_i->left_angle && right_angle >= shadow_i->right_angle) { - fov_map[pos_in_map] = HIDDEN; - return; + fov_map[pos_in_map] = 'H'; + return 1; + } + if ( middle_angle < shadow_i->left_angle + && middle_angle > shadow_i->right_angle) + { + fov_map[pos_in_map] = 'H'; } } } - if ('X' == world.map.cells[pos_in_map]) + return 0; +} + + + +/* To "shadows", add shadow defined by "left_angle" and "right_angle", either as + * new entry or as part of an existing shadow (swallowed whole or extending it). + */ +static void set_shadow(uint32_t left_angle, uint32_t right_angle, + struct shadow_angle ** shadows) +{ + struct shadow_angle * shadow_i; + if (!try_merging_angles(left_angle, right_angle, shadows)) { - if (!try_merging_angles(left_angle, right_angle, shadows)) + struct shadow_angle * shadow; + shadow = try_malloc(sizeof(struct shadow_angle), __func__); + shadow->left_angle = left_angle; + shadow->right_angle = right_angle; + shadow->next = NULL; + if (*shadows) { - struct shadow_angle * shadow; - shadow = try_malloc(sizeof(struct shadow_angle), f_name); - shadow->left_angle = left_angle; - shadow->right_angle = right_angle; - shadow->next = NULL; - if (*shadows) + for (shadow_i = *shadows; shadow_i; shadow_i = shadow_i->next) { - for (shadow_i = *shadows; shadow_i; shadow_i = shadow_i->next) + if (!shadow_i->next) { - if (!shadow_i->next) - { - shadow_i->next = shadow; - return; - } + shadow_i->next = shadow; + return; } } - *shadows = shadow; } + *shadows = shadow; } } @@ -307,35 +324,93 @@ static void free_angles(struct shadow_angle * angles) -static void eval_position(uint16_t dist, uint16_t hex_i, uint8_t * fov_map, +static void eval_position(uint16_t dist, uint16_t hex_i, char * fov_map, struct yx_uint8 * test_pos, struct shadow_angle ** shadows) { int32_t left_angle_uncorrected = ((CIRCLE / 12) / dist) - - ((hex_i * (CIRCLE / 6)) / dist); + - (hex_i * (CIRCLE / 6) / dist); int32_t right_angle_uncorrected = left_angle_uncorrected - (CIRCLE / (6 * dist)); uint32_t left_angle = correct_angle(left_angle_uncorrected); uint32_t right_angle = correct_angle(right_angle_uncorrected); uint32_t right_angle_1st = right_angle > left_angle ? 0 : right_angle; - uint16_t pos_in_map = yx_to_map_pos(test_pos); - set_shadow(left_angle, right_angle_1st, shadows, pos_in_map, fov_map); - if (right_angle_1st != right_angle) + uint32_t middle_angle = 0; + if (right_angle_1st) { - left_angle = CIRCLE; - set_shadow(left_angle, right_angle, shadows, pos_in_map, fov_map); + middle_angle = right_angle + ((left_angle - right_angle) / 2); + } + uint16_t pos_in_map = test_pos->y * world.map.length + test_pos->x; + uint8_t all_shaded = shade_hex(left_angle, right_angle_1st, middle_angle, + shadows, pos_in_map, fov_map); + if (!all_shaded && 'X' == world.map.cells[pos_in_map]) + { + set_shadow(left_angle, right_angle_1st, shadows); + if (right_angle_1st != right_angle) + { + left_angle = CIRCLE; + set_shadow(left_angle, right_angle, shadows); + } + } +} + + + +static void update_map_memory(struct Thing * t_eye, uint32_t map_size) +{ + if (!t_eye->mem_map) + { + t_eye->mem_map = try_malloc(map_size, __func__); + memset(t_eye->mem_map, ' ', map_size); + } + uint32_t i; + for (i = 0; i < map_size; i++) + { + if (' ' == t_eye->mem_map[i] && t_eye->fov_map[i] == 'v') + { + t_eye->mem_map[i] = world.map.cells[i]; + } + } + struct ThingInMemory * tm = t_eye->t_mem; + struct ThingInMemory * tm_prev = NULL; + struct ThingInMemory * tm_next = NULL; + for (; tm != NULL; tm = tm_next) + { + tm_next = tm->next; + if ('v' == t_eye->fov_map[tm->pos.y * world.map.length + tm->pos.x]) + { + if (tm_prev) + { + tm_prev->next = tm->next; + } + else + { + t_eye->t_mem = tm->next; + } + free(tm); + continue; + } + tm_prev = tm; + } + struct Thing * t = world.things; + for (; t != NULL; t = t->next) + { + if ( !t->lifepoints + && 'v' == t_eye->fov_map[t->pos.y * world.map.length + t->pos.x]) + { + add_thing_to_memory_map(t_eye, t->type, t->pos.y, t->pos.x); + } } } -extern uint8_t * build_fov_map(struct Thing * eye) +extern void build_fov_map(struct Thing * t) { - char * f_name = "build_fov_map()"; uint32_t map_size = world.map.length * world.map.length; - uint8_t * fov_map = try_malloc(map_size, f_name); - memset(fov_map, VISIBLE, map_size); - struct yx_uint8 test_pos = eye->pos; + t->fov_map = t->fov_map ? t->fov_map : try_malloc(map_size, __func__); + memset(t->fov_map, 'v', map_size); + struct yx_uint8 test_pos = t->pos; struct shadow_angle * shadows = NULL; char * circle_dirs = "xswedc"; uint16_t dist; @@ -353,7 +428,7 @@ extern uint8_t * build_fov_map(struct Thing * eye) { if (mv_yx_in_dir_legal(dir, &test_pos)) { - eval_position(dist, hex_i, fov_map, &test_pos, &shadows); + eval_position(dist, hex_i, t->fov_map, &test_pos, &shadows); circle_on_map = 1; } dir = circle_dirs[i_dir]; @@ -366,5 +441,5 @@ extern uint8_t * build_fov_map(struct Thing * eye) } mv_yx_in_dir_wrap(0, NULL, 1); free_angles(shadows); - return fov_map; + update_map_memory(t, map_size); }