From: Christian Heller Date: Fri, 6 Mar 2015 14:01:53 +0000 (+0100) Subject: Server/py: Undummify build_fov_map(). X-Git-Tag: tce~406 X-Git-Url: https://plomlompom.com/repos/%7B%7Bprefix%7D%7D/%7B%7Bdb.prefix%7D%7D/process_efforts?a=commitdiff_plain;h=40ae39a7efa404ba4107b394c358fc7d38e9ec91;p=plomrogue Server/py: Undummify build_fov_map(). --- diff --git a/libplomrogue.c b/libplomrogue.c index 385eb71..fd66755 100644 --- a/libplomrogue.c +++ b/libplomrogue.c @@ -1,7 +1,24 @@ #include /* NULL */ -#include /* uint8_t, uint16_t, uint32_t, INT8_MIN, INT8_MAX */ +#include /* ?(u)int(8|16|32)_t, ?(U)INT8_(MIN|MAX) */ +#include /* free, malloc */ +#include /* memset */ +/* Number of degrees a circle is divided into. The greater it is, the greater + * the angle precision. But make it one whole zero larger and bizarre FOV bugs + * appear on large maps, probably due to value overflows (TODO: more research!). + */ +#define CIRCLE 3600000 +/* Angle of a shadow. */ +struct shadow_angle +{ + struct shadow_angle * next; + uint32_t left_angle; + uint32_t right_angle; +}; + +/* To be used as temporary storage for world map array. */ +static char * worldmap = NULL; /* Coordinate for maps of max. 256x256 cells. */ struct yx_uint8 @@ -17,13 +34,9 @@ extern void set_maplength(uint16_t maplength_input) maplength = maplength_input; } - - /* Pseudo-randomness seed for rrand(), set by seed_rrand(). */ static uint32_t seed = 0; - - /* Helper to mv_yx_in_dir_legal(). Move "yx" into hex direction "d". */ static void mv_yx_in_dir(char d, struct yx_uint8 * yx) { @@ -57,8 +70,6 @@ static void mv_yx_in_dir(char d, struct yx_uint8 * yx) } } - - /* Move "yx" into hex direction "dir". Available hex directions are: 'e' * (north-east), 'd' (east), 'c' (south-east), 'x' (south-west), 's' (west), 'w' * (north-west). Returns 1 if the move was legal, 0 if not, and -1 when internal @@ -113,8 +124,6 @@ static int8_t mv_yx_in_dir_legal(char dir, struct yx_uint8 * yx) return 0; } - - /* Wrapper around mv_yx_in_dir_legal() that stores new coordinate in res_y/x, * (return with result_y/x()), and immediately resets the wrapping. */ @@ -140,8 +149,6 @@ extern uint8_t result_x() return res_x; } - - /* With set_seed set, set seed global to seed_input. In any case, return it. */ extern uint32_t seed_rrand(uint8_t set_seed, uint32_t seed_input) { @@ -152,8 +159,6 @@ extern uint32_t seed_rrand(uint8_t set_seed, uint32_t seed_input) return seed; } - - /* Return 16-bit number pseudo-randomly generated via Linear Congruential * Generator algorithm with some proven constants. Use instead of any rand() to * ensure portability of the same pseudo-randomness across systems. @@ -163,3 +168,254 @@ extern uint16_t rrand() seed = ((seed * 1103515245) + 12345) % 4294967296; return (seed >> 16); /* Ignore less random least significant bits. */ } + +/* Free shadow angles list "angles". */ +static void free_angles(struct shadow_angle * angles) +{ + if (angles->next) + { + free_angles(angles->next); + } + free(angles); +} + +/* Recalculate angle < 0 or > CIRCLE to a value between these two limits. */ +static uint32_t correct_angle(int32_t angle) +{ + while (angle < 0) + { + angle = angle + CIRCLE; + } + while (angle > CIRCLE) + { + angle = angle - CIRCLE; + } + return angle; +} + +/* Try merging the angle between "left_angle" and "right_angle" to "shadow" if + * it meets the shadow from the right or the left. Returns 1 on success, else 0. + */ +static uint8_t try_merge(struct shadow_angle * shadow, + uint32_t left_angle, uint32_t right_angle) +{ + if ( shadow->right_angle <= left_angle + 1 + && shadow->right_angle >= right_angle) + { + shadow->right_angle = right_angle; + } + else if ( shadow->left_angle + 1 >= right_angle + && shadow->left_angle <= left_angle) + { + shadow->left_angle = left_angle; + } + else + { + return 0; + } + return 1; +} + +/* Try merging the shadow angle between "left_angle" and "right_angle" into an + * existing shadow angle in "shadows". On success, see if this leads to any + * additional shadow angle overlaps and merge these accordingly. Return 1 on + * success, else 0. + */ +static uint8_t try_merging_angles(uint32_t left_angle, uint32_t right_angle, + struct shadow_angle ** shadows) +{ + uint8_t angle_merge = 0; + struct shadow_angle * shadow; + for (shadow = *shadows; shadow; shadow = shadow->next) + { + if (try_merge(shadow, left_angle, right_angle)) + { + angle_merge = 1; + } + } + if (angle_merge) + { + struct shadow_angle * shadow1; + for (shadow1 = *shadows; shadow1; shadow1 = shadow1->next) + { + struct shadow_angle * last_shadow = NULL; + struct shadow_angle * shadow2; + for (shadow2 = *shadows; shadow2; shadow2 = shadow2->next) + { + if ( shadow1 != shadow2 + && try_merge(shadow1, shadow2->left_angle, + shadow2->right_angle)) + { + struct shadow_angle * to_free = shadow2; + if (last_shadow) + { + last_shadow->next = shadow2->next; + shadow2 = last_shadow; + } + else + { + *shadows = shadow2->next; + shadow2 = *shadows; + } + free(to_free); + } + last_shadow = shadow2; + } + } + } + return angle_merge; +} + +/* 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). + * Return 1 on malloc error, else 0. + */ +static uint8_t 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)) + { + struct shadow_angle * shadow; + shadow = malloc(sizeof(struct shadow_angle)); + if (!shadow) + { + return 1; + } + 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) + { + if (!shadow_i->next) + { + shadow_i->next = shadow; + return 0; + } + } + } + *shadows = shadow; + } + return 0; +} + +/* 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 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) +{ + struct shadow_angle * shadow_i; + 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] = 'H'; + return 1; + } + if ( middle_angle < shadow_i->left_angle + && middle_angle > shadow_i->right_angle) + { + fov_map[pos_in_map] = 'H'; + } + } + } + return 0; +} + +/* 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 hexes in "fov_map" and + * potentially adding a new shadow to linked shadow angle list "shadows". + * Return 1 on malloc error, else 0. + */ +static uint8_t 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); + 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; + uint32_t middle_angle = 0; + if (right_angle_1st) + { + middle_angle = right_angle + ((left_angle - right_angle) / 2); + } + uint16_t pos_in_map = test_pos->y * maplength + 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' == worldmap[pos_in_map]) + { + if (set_shadow(left_angle, right_angle_1st, shadows)) + { + return 1; + } + if (right_angle_1st != right_angle) + { + left_angle = CIRCLE; + if (set_shadow(left_angle, right_angle, shadows)) + { + return 1; + } + } + } + return 0; +} + +/* Update field of view in "fovmap" of "worldmap_input" as seen from "y"/"x". + * Return 1 on malloc error, else 0. + */ +extern uint8_t build_fov_map(uint8_t y, uint8_t x, + char * fovmap, char * worldmap_input) +{ + worldmap = worldmap_input; + struct shadow_angle * shadows = NULL; + struct yx_uint8 test_pos; + test_pos.y = y; + test_pos.x = x; + 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++) + { + 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 (circle_i < dist_i) + { + dist_i = 1; + dir_char=circledirs_string[++dir_char_pos_in_circledirs_string]; + } + if (mv_yx_in_dir_legal(dir_char, &test_pos)) + { + if (eval_position(circle_i, hex_i, fovmap, &test_pos, &shadows)) + { + return 1; + } + circle_is_on_map = 1; + } + } + } + mv_yx_in_dir_legal(0, NULL); + free_angles(shadows); + return 0; +} diff --git a/plomrogue-server.py b/plomrogue-server.py index 5fe5c26..0ba6c07 100755 --- a/plomrogue-server.py +++ b/plomrogue-server.py @@ -39,6 +39,9 @@ def prep_library(): libpr.result_y.restype = ctypes.c_uint8 libpr.result_x.restype = ctypes.c_uint8 libpr.set_maplength(world_db["MAP_LENGTH"]) + libpr.build_fov_map.argtypes = [ctypes.c_uint8, ctypes.c_uint8, + ctypes.c_char_p, ctypes.c_char_p] + libpr.build_fov_map.restype = ctypes.c_uint8 return libpr @@ -537,7 +540,12 @@ def setter(category, key, min, max): def build_fov_map(t): """Build Thing's FOV map.""" t["fovmap"] = bytearray(b'v' * (world_db["MAP_LENGTH"] ** 2)) - # DUMMY so far. Just builds an all-visible map. + maptype = ctypes.c_char * len(world_db["MAP"]) + test = libpr.build_fov_map(t["T_POSY"], t["T_POSX"], + maptype.from_buffer(t["fovmap"]), + maptype.from_buffer(world_db["MAP"])) + if test: + raise SystemExit("Malloc error in build_fov_Map().") def decrement_lifepoints(t):