Server/py: Undummify build_fov_map().

diff --git a/libplomrogue.c b/libplomrogue.c
index 385eb713fa150b26bd57229e2af13fa498012b93..fd6675575567b019ec4f10595e8bfbd2b0e697c6 100644 (file)
--- a/libplomrogue.c
+++ b/libplomrogue.c
@@ -1,7 +1,24 @@
 #include <stddef.h> /* NULL */
 #include <stddef.h> /* NULL */

-#include <stdint.h> /* uint8_t, uint16_t, uint32_t, INT8_MIN, INT8_MAX */
+#include <stdint.h> /* ?(u)int(8|16|32)_t, ?(U)INT8_(MIN|MAX) */
+#include <stdlib.h> /* free, malloc */
+#include <string.h> /* 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
 
 /* 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;
 }
 
     maplength = maplength_input;
 }
 

-
-

 /* Pseudo-randomness seed for rrand(), set by seed_rrand(). */
 static uint32_t seed = 0;
 
 /* 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)
 {
 /* 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
 /* 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;
 }
 
     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.
  */
 /* 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;
 }
 
     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)
 {
 /* 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 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.
 /* 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. */
 }
     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 5fe5c26c89009f25428e49f9f0474b6c6ed9013e..0ba6c07a7f4a7c141f0561c590448ccfcc4e5be9 100755 (executable)
--- 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.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
 
 
     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))
 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):
 
 
 def decrement_lifepoints(t):