X-Git-Url: https://plomlompom.com/repos/?a=blobdiff_plain;f=src%2Fserver%2Ffield_of_view.c;h=45c90e6c0a6f6dc7da76db9938c529f8124076b2;hb=1dc64ee46c2dcbd7eb8a6c4fcd27620dab7d7680;hp=ae8aa9cbaa0887dbde1478f07ac808f6bc525a1f;hpb=3cb6ed6453b22eba62f7c9186790813b0abebeb9;p=plomrogue diff --git a/src/server/field_of_view.c b/src/server/field_of_view.c index ae8aa9c..45c90e6 100644 --- a/src/server/field_of_view.c +++ b/src/server/field_of_view.c @@ -1,13 +1,22 @@ -/* src/server/field_of_view.c */ +/* src/server/field_of_view.c + * + * This file is part of PlomRogue. PlomRogue is licensed under the GPL version 3 + * or any later version. For details on its copyright, license, and warranties, + * see the file NOTICE in the root directory of the PlomRogue source package. + */ #include "field_of_view.h" -#include /* uint8_t, uint16_t, uint32_t, int32_t */ +#include /* pow() */ +#include /* NULL */ +#include /* uint8_t, uint16_t, uint32_t, int32_t, UINT8_MAX */ #include /* free() */ #include /* memset() */ #include "../common/rexit.h" /* exit_trouble() */ #include "../common/try_malloc.h" /* try_malloc() */ -#include "things.h" /* Thing */ -#include "yx_uint8.h" /* yx_uint8 */ +#include "../common/yx_uint8.h" /* yx_uint8 */ +#include "map.h" /* mv_yx_in_dir_legal(), init_empty_map() */ +#include "rrand.h" /* rrand() */ +#include "things.h" /* Thing, ThingInMemory, add_thing_to_memory_map() */ #include "world.h" /* world */ @@ -30,22 +39,6 @@ struct shadow_angle -/* Move "yx" into hex direction "d". */ -static void mv_yx_in_hex_dir(char d, struct yx_uint8 * yx); - -/* Move "yx" into hex direction "d". If this moves "yx" beyond the minimal (0) - * or maximal (UINT8_MAX) column or row, it wraps to the opposite side. Such - * wrapping is returned as a wraps enum value and stored, so that further calls - * to move "yx" back into the opposite direction may unwrap it again. Pass an - * "unwrap" of !0 to re-set the internal wrap memory to 0. - */ -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. - */ -static uint8_t mv_yx_in_dir_legal(char dir, struct yx_uint8 * yx); - /* Recalculate angle < 0 or > CIRCLE to a value between these two limits. */ static uint32_t correct_angle(int32_t angle); @@ -72,6 +65,12 @@ 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); +/* 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); + /* Free shadow angles list "angles". */ static void free_angles(struct shadow_angle * angles); @@ -84,88 +83,10 @@ 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 field of view. */ -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) -{ - if (d == 'e') - { - yx->x = yx->x + (yx->y % 2); - yx->y--; - } - else if (d == 'd') - { - yx->x++; - } - else if (d == 'c') - { - yx->x = yx->x + (yx->y % 2); - yx->y++; - } - else if (d == 'x') - { - yx->x = yx->x - !(yx->y % 2); - yx->y++; - } - else if (d == 's') - { - yx->x--; - } - else if (d == 'w') - { - yx->x = yx->x - !(yx->y % 2); - yx->y--; - } -} - - - -static uint8_t mv_yx_in_dir_wrap(char d, struct yx_uint8 * yx, uint8_t unwrap) -{ - static int8_t wrap_west_east = 0; - static int8_t wrap_north_south = 0; - if (unwrap) - { - wrap_west_east = wrap_north_south = 0; - return 0; - } - struct yx_uint8 original; - original.y = yx->y; - original.x = yx->x; - mv_yx_in_hex_dir(d, yx); - if (strchr("edc", d) && yx->x < original.x) - { - wrap_west_east++; - } - else if (strchr("xsw", d) && yx->x > original.x) - { - wrap_west_east--; - } - if (strchr("we", d) && yx->y > original.y) - { - wrap_north_south--; - } - else if (strchr("xc", d) && yx->y < original.y) - { - wrap_north_south++; - } - return (wrap_west_east != 0) + (wrap_north_south != 0); -} - - - -static uint8_t mv_yx_in_dir_legal(char dir, struct yx_uint8 * yx) -{ - uint8_t wraptest = mv_yx_in_dir_wrap(dir, yx, 0); - if (!wraptest && yx->x < world.map.length && yx->y < world.map.length) - { - return 1; - } - return 0; -} +/* Update "t_eye"'s things-on-map memory by removing from its .t_mem all + * memorized thing in FOV, and adding inanimate things in FOV to it. + */ +static void add_things_to_map_memory(struct Thing * t_eye); @@ -280,9 +201,6 @@ static uint8_t shade_hex(uint32_t left_angle, uint32_t right_angle, -/* 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) { @@ -354,21 +272,72 @@ static void eval_position(uint16_t dist, uint16_t hex_i, char * fov_map, -static void update_map_memory(struct Thing * t, uint32_t map_size) +static void add_things_to_map_memory(struct Thing * t_eye) { - if (!t->mem_map) + struct ThingInMemory * tm = t_eye->t_mem; + struct ThingInMemory * tm_prev = NULL; + struct ThingInMemory * tm_next = NULL; + for (; tm; tm = tm_next) { - t->mem_map = try_malloc(map_size, __func__); - memset(t->mem_map, ' ', map_size); + 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; 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 void update_map_memory(struct Thing * t_eye, uint8_t age_map) +{ + if (!t_eye->mem_map) + { + init_empty_map(&(t_eye->mem_map)); + } + if (!t_eye->mem_depth_map) + { + init_empty_map(&(t_eye->mem_depth_map)); } uint32_t i; - for (i = 0; i < map_size; i++) + for (i = 0; i < (uint32_t) (world.map.length * world.map.length); i++) { - if (' ' == t->mem_map[i] && t->fov_map[i] == 'v') + if ('v' == t_eye->fov_map[i]) + { + t_eye->mem_depth_map[i] = '0'; + if (' ' == t_eye->mem_map[i]) + { + t_eye->mem_map[i] = world.map.cells[i]; + } + continue; + } + if (age_map && + '0' <= t_eye->mem_depth_map[i] && '9' > t_eye->mem_depth_map[i] + && !(rrand() % (uint16_t) pow(2, t_eye->mem_depth_map[i] - 48))) { - t->mem_map[i] = world.map.cells[i]; + t_eye->mem_depth_map[i]++; } } + add_things_to_map_memory(t_eye); } @@ -378,36 +347,35 @@ extern void build_fov_map(struct Thing * t) uint32_t map_size = world.map.length * world.map.length; 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; - uint8_t first_round, circle_on_map; - for (first_round = 1, dist = 1, circle_on_map = 1; circle_on_map; dist++) + struct yx_uint8 test_pos = t->pos; + char * circledirs_string = "xswedc"; + uint16_t circle_i; + uint8_t circle_is_on_map; + for (circle_i = 1, circle_is_on_map = 1; circle_is_on_map; circle_i++) { - if (!first_round) - { - mv_yx_in_dir_legal('c', &test_pos); - } - char dir = 'd'; - uint8_t i_dir = first_round = circle_on_map = 0; - uint16_t i_dist, hex_i; - for (hex_i = 0, i_dist = 1; hex_i < 6 * dist; i_dist++, hex_i++) + circle_is_on_map = 0; + if (1 < circle_i) /* All circles but the 1st are */ + { /* moved into starting from a */ + mv_yx_in_dir_legal('c', &test_pos);/* previous circle's last hex, */ + } /* i.e. from the upper left. */ + char dir_char = 'd'; /* Circle's 1st hex is entered by rightward move.*/ + uint8_t dir_char_pos_in_circledirs_string = UINT8_MAX; + uint16_t dist_i, hex_i; + for (hex_i=0, dist_i=circle_i; hex_i < 6 * circle_i; dist_i++, hex_i++) { - if (mv_yx_in_dir_legal(dir, &test_pos)) + if (circle_i < dist_i) { - eval_position(dist, hex_i, t->fov_map, &test_pos, &shadows); - circle_on_map = 1; + dist_i = 1; + dir_char=circledirs_string[++dir_char_pos_in_circledirs_string]; } - dir = circle_dirs[i_dir]; - if (dist == i_dist) + if (mv_yx_in_dir_legal(dir_char, &test_pos)) { - i_dist = 0; - i_dir++; + eval_position(circle_i, hex_i, t->fov_map, &test_pos, &shadows); + circle_is_on_map = 1; } } } - mv_yx_in_dir_wrap(0, NULL, 1); + mv_yx_in_dir_legal(0, NULL); free_angles(shadows); - update_map_memory(t, map_size); }