Server/AI: Explore map for (long-time) unexplored cells.

[plomrogue] / src / server / things.c

diff --git a/src/server/things.c b/src/server/things.c
index 5a866bb2f35a7f6395b4b7d005b8dcece45507da..85503e9a8a874d556ae38a669945e5e819b36870 100644 (file)
--- a/src/server/things.c
+++ b/src/server/things.c
@@ -10,12 +10,14 @@
 #include <stddef.h> /* NULL, size_t */
 #include <stdint.h> /* uint8_t, uint16_t, int16_t, UINT8_MAX, UINT16_MAX */
 #include <stdlib.h> /* free() */
-#include <string.h> /* memset(), strcmp(), strdup() */
+#include <string.h> /* memset(), strcmp(), strdup(), strlen() */
 #include "../common/rexit.h" /* exit_err() */
 #include "../common/try_malloc.h" /* try_malloc() */
 #include "../common/yx_uint8.h" /* yx_uint8 */
 #include "cleanup.h" /* set_cleanup_flag() */
 #include "hardcoded_strings.h" /* s */
+#include "field_of_view.h" /* build_fov_map() */
+#include "map.h" /* mv_yx_in_dir_legal() */
 #include "rrand.h" /* rrand() */
 #include "thing_actions.h" /* actor_wait */
 #include "world.h" /* world */
@@ -41,6 +43,11 @@ static struct NextAndId * add_to_struct_list(size_t n_size, uint8_t start_id,
                                              int16_t id, uint8_t struct_id,
                                              struct NextAndId ** start);
 
+/* Return 1 if cell at "test_pos" is proliferable by "t", i.e. it is passable,
+ * it is not inhabited by another thing of "t"'s type, and, if "t" is animate,
+ * neither by any other animate thing; else return 0.
+ */
+static uint8_t cell_is_proliferable(struct yx_uint8 test_pos, struct Thing * t);
 
 
 static struct NextAndId * add_to_struct_list(size_t n_size, uint8_t start_id,
@@ -77,6 +84,32 @@ static struct NextAndId * add_to_struct_list(size_t n_size, uint8_t start_id,
 
 
 
+static uint8_t cell_is_proliferable(struct yx_uint8 test_pos, struct Thing * t)
+{
+    if ('.' == world.map.cells[test_pos.y * world.map.length + test_pos.x])
+    {
+        struct Thing * t_test;
+        for (t_test = world.things; t_test; t_test = t_test->next)
+        {
+            if (t_test->pos.y == test_pos.y && t_test->pos.x == test_pos.x)
+            {
+                if (t_test->type == t->type)
+                {
+                    return 0;
+                }
+                if (t_test->lifepoints && t->lifepoints)
+                {
+                    return 0;
+                }
+            }
+        }
+        return 1;
+    }
+    return 0;
+}
+
+
+
 extern struct ThingAction * add_thing_action(uint8_t id)
 {
     struct ThingAction * ta;
@@ -119,6 +152,10 @@ extern struct Thing * add_thing(int16_t id, uint8_t type, uint8_t y, uint8_t x)
     t->lifepoints = tt->lifepoints;
     t->pos.y      = y;
     t->pos.x      = x;
+    if (t->lifepoints && world.exists)
+    {
+        build_fov_map(t);
+    }
     return t;
 }
 
@@ -173,6 +210,7 @@ extern void free_things(struct Thing * t)
     free_things(t->next);
     free(t->fov_map);
     free(t->mem_map);
+    free(t->mem_depth_map);
     free_things_in_memory(t->t_mem);
     free(t);
     if (t == world.things)         /* So add_things()' NULL-delimited thing   */
@@ -262,6 +300,39 @@ extern struct Thing * get_player()
 
 
 
+extern void try_thing_proliferation(struct Thing * t)
+{
+    struct ThingType * tt = get_thing_type(t->type);
+    if (tt->proliferate)
+    {
+        if (1 == tt->proliferate || 1 == (rrand() % tt->proliferate))
+        {
+            struct yx_uint8 candidates[6];
+            uint8_t n_candidates = 0;
+            char dirs[7] = "dxswed";
+            struct yx_uint8 test = t->pos;
+            uint8_t i;
+            for (i = 0; i < strlen(dirs); i++)
+            {
+                if (   mv_yx_in_dir_legal(dirs[i], &test)
+                    && cell_is_proliferable(test, t))
+                {
+                        candidates[n_candidates] = test;
+                        n_candidates++;
+                }
+            }
+            if (!n_candidates)
+            {
+                return;
+            }
+            i = rrand() % n_candidates;
+            add_thing(-1, tt->id, candidates[i].y, candidates[i].x);
+        }
+    }
+}
+
+
+
 extern void add_things(uint8_t type, uint8_t n)
 {
     uint8_t i;