Server: New command TT_PROLIFERATE sets chance for thing proliferation.

[plomrogue] / src / server / things.c

diff --git a/src/server/things.c b/src/server/things.c
index bbe9dbffe39388399b741965c7ead8bb2aa61baa..eaeeb9ee8b9b09d9a5e511e6a082504e2a8b830d 100644 (file)
--- a/src/server/things.c
+++ b/src/server/things.c
@@ -1,21 +1,26 @@
-/* src/server/things.c */
+/* src/server/things.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.
+ */
 
 #define _POSIX_C_SOURCE 200809L /* strdup() */
 #include "things.h"
 #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 "map.h" /* is_passable() */
+#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 */
-#include "yx_uint8.h" /* yx_uint8_cmp() */
 
 
 
@@ -28,9 +33,6 @@ struct NextAndId
 
 
 
-/* Free ThingsInMemory chain starting at "tm". */
-static void free_things_in_memory(struct ThingInMemory * tm);
-
 /* To linked list of NextAndId structs (or rather structs whose start region is
  * compatible to it) starting at "start", add newly allocated element of
  * "n_size" and an ID that is either "id" or, if "id" is <= UINT8_MAX and >=
@@ -43,18 +45,6 @@ static struct NextAndId * add_to_struct_list(size_t n_size, uint8_t start_id,
 
 
 
-static void free_things_in_memory(struct ThingInMemory * tm)
-{
-    if (!tm)
-    {
-        return;
-    }
-    free_things_in_memory(tm->next);
-    free(tm);
-}
-
-
-
 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)
@@ -131,6 +121,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;
 }
 
@@ -195,6 +189,18 @@ extern void free_things(struct Thing * t)
 
 
 
+extern void free_things_in_memory(struct ThingInMemory * tm)
+{
+    if (!tm)
+    {
+        return;
+    }
+    free_things_in_memory(tm->next);
+    free(tm);
+}
+
+
+
 extern struct ThingAction * get_thing_action(uint8_t id)
 {
     struct ThingAction * ta = world.thing_actions;
@@ -262,6 +268,54 @@ 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 start = t->pos;
+            uint8_t i;
+            for (i = 0; i < strlen(dirs); i++)
+            {
+                if (   mv_yx_in_dir_legal(dirs[i], &start)
+                    && '.' == world.map.cells[start.y*world.map.length+start.x])
+                {
+                    uint8_t drop = 0;
+                    if (tt->lifepoints)
+                    {
+                        for (t = world.things; t; t = t->next)
+                        {
+                            if (   t->lifepoints
+                                && start.y == t->pos.y && start.x == t->pos.x)
+                            {
+                                drop = 1;
+                            }
+                        }
+                    }
+                    if (!drop)
+                    {
+                        candidates[n_candidates] = start;
+                        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;
@@ -270,10 +324,11 @@ extern void add_things(uint8_t type, uint8_t n)
         struct yx_uint8 pos;
         while (1)
         {
-            char * err = "Space to put thing on too hard to find."
-                         "Map too small?";
+            char * err="Space to put thing on too hard to find. Map too small?";
             uint16_t i_pos = 0;
-            for (pos.y = pos.x = 0; 0 == is_passable(pos); i_pos++)
+            for (pos.y = pos.x = 0;
+                 '.' != world.map.cells[pos.y * world.map.length + pos.x];
+                 i_pos++)
             {
                 exit_err(UINT16_MAX == i_pos, err);
                 pos.y = rrand() % world.map.length;
@@ -283,7 +338,7 @@ extern void add_things(uint8_t type, uint8_t n)
             uint8_t clear = 1;
             for (t = world.things; t; t = t->next)
             {
-                if (yx_uint8_cmp(&pos, &t->pos) && 0 != t->lifepoints)
+                if (0 != t->lifepoints && pos.y==t->pos.y && pos.x==t->pos.x)
                 {
                     clear = 0;
                     break;