From fd43399ecf1daa89986835a2940b0d4778a48c5e Mon Sep 17 00:00:00 2001 From: Christian Heller Date: Thu, 23 Oct 2014 23:54:39 +0200 Subject: [PATCH] Server: Don't proliferate things on map cells inhabited by same type. --- SERVER_COMMANDS | 4 ++-- src/server/things.c | 55 ++++++++++++++++++++++++++++----------------- 2 files changed, 37 insertions(+), 22 deletions(-) diff --git a/SERVER_COMMANDS b/SERVER_COMMANDS index 0a85cd3..a39cf72 100644 --- a/SERVER_COMMANDS +++ b/SERVER_COMMANDS @@ -201,5 +201,5 @@ transform into when their state changes from animate to inanimate. TT_PROLIFERATE [0-255] If non-zero, there is a chance of 1 divided by the given value each turn for any thing of the selected type to emit an offspring to a random neighbor cell if one -passable is available (and, if the thing is of an animate type, not inhabited by -another animate thing). +is available that is passable and not inhabited by a thing of the same same type +or, if the proliferating thing is animate, any other animate thing. diff --git a/src/server/things.c b/src/server/things.c index 3056322..d4db193 100644 --- a/src/server/things.c +++ b/src/server/things.c @@ -43,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, @@ -79,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; @@ -278,31 +309,15 @@ extern void try_thing_proliferation(struct Thing * t) struct yx_uint8 candidates[6]; uint8_t n_candidates = 0; char dirs[7] = "dxswed"; - struct yx_uint8 start = t->pos; + struct yx_uint8 test = 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]) + if ( mv_yx_in_dir_legal(dirs[i], &test) + && cell_is_proliferable(test, t)) { - 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; - break; - } - } - } - if (!drop) - { - candidates[n_candidates] = start; + candidates[n_candidates] = test; n_candidates++; - } } } if (!n_candidates) -- 2.30.2