plomlompom.com Git - plomrogue/blob - src/server/things.c

   1 /* src/server/things.c */
   2
   3 #define _POSIX_C_SOURCE 200809L /* strdup() */
   4 #include "things.h"
   5 #include <stddef.h> /* NULL, size_t */
   6 #include <stdint.h> /* uint8_t, uint16_t, int16_t, UINT8_MAX, UINT16_MAX */
   7 #include <stdlib.h> /* free() */
   8 #include <string.h> /* memset(), strcmp(), strdup() */
   9 #include "../common/rexit.h" /* exit_err() */
  10 #include "../common/try_malloc.h" /* try_malloc() */
  11 #include "../common/yx_uint8.h" /* yx_uint8 */
  12 #include "cleanup.h" /* set_cleanup_flag() */
  13 #include "hardcoded_strings.h" /* s */
  14 #include "map.h" /* is_passable() */
  15 #include "rrand.h" /* rrand() */
  16 #include "thing_actions.h" /* actor_wait */
  17 #include "world.h" /* world */
  18 #include "yx_uint8.h" /* yx_uint8_cmp() */
  19
  20
  21
  22 /* Used to treat structs Thing, ThingType and ThingAction the same. */
  23 struct NextAndId
  24 {
  25     struct NextAndId * next;
  26     uint8_t id;
  27 };
  28
  29
  30
  31 /* To linked list of NextAndId structs (or rather structs whose start region is
  32  * compatible to it) starting at "start", add newly allocated element of
  33  * "n_size" and an ID that is either "id" or, if "id" is <= UINT8_MAX and >=
  34  * "id_start", get lowest ID >= "start_id" and <= UINT8_MAX for new thing
  35  * ("struct_id"=0), thing type ("struct_id"=1) or thing action ("struct_id"=2).
  36  */
  37 static struct NextAndId * add_to_struct_list(size_t n_size, uint8_t start_id,
  38                                              int16_t id, uint8_t struct_id,
  39                                              struct NextAndId ** start);
  40
  41
  42
  43 static struct NextAndId * add_to_struct_list(size_t n_size, uint8_t start_id,
  44                                              int16_t id, uint8_t struct_id,
  45                                              struct NextAndId ** start)
  46 {
  47     struct NextAndId * nai  = try_malloc(n_size, __func__);
  48     memset(nai, 0, n_size);
  49     if (start_id <= id && id <= UINT8_MAX)
  50     {
  51         nai->id = id;
  52     }
  53     else
  54     {
  55         while (1)
  56         {
  57             if (   (0 == struct_id && !get_thing(world.things, start_id, 1))
  58                 || (1 == struct_id && !get_thing_type(start_id))
  59                 || (2 == struct_id && !get_thing_action(start_id)))
  60             {
  61                 nai->id = start_id;
  62                 break;
  63             }
  64             char * err =  "No unused ID available to add to ID list.";
  65             exit_err(start_id == UINT8_MAX, err);
  66             start_id++;
  67         }
  68     }
  69     struct NextAndId ** nai_ptr_ptr = start;
  70     for (; NULL != * nai_ptr_ptr; nai_ptr_ptr = &(*nai_ptr_ptr)->next);
  71     *nai_ptr_ptr = nai;
  72     return nai;
  73 }
  74
  75
  76
  77 extern struct ThingAction * add_thing_action(uint8_t id)
  78 {
  79     struct ThingAction * ta;
  80     ta = (struct ThingAction *) add_to_struct_list(sizeof(struct ThingAction),
  81                                                    1, (int16_t) id, 2,
  82                                                    (struct NextAndId **)
  83                                                    &world.thing_actions);
  84     set_cleanup_flag(CLEANUP_THING_ACTIONS);
  85     ta->name = strdup(s[S_CMD_WAIT]);
  86     ta->effort = 1;
  87     ta->func = actor_wait;
  88     return ta;
  89 }
  90
  91
  92
  93 extern struct ThingType * add_thing_type(int16_t id)
  94 {
  95     struct ThingType * tt;
  96     tt = (struct ThingType *) add_to_struct_list(sizeof(struct ThingType),
  97                                                  0, id, 1,
  98                                                  (struct NextAndId **)
  99                                                  &world.thing_types);
 100     set_cleanup_flag(CLEANUP_THING_TYPES);
 101     tt->name = strdup("(none)");
 102     tt->corpse_id = tt->id;
 103     return tt;
 104 }
 105
 106
 107
 108 extern struct Thing * add_thing(int16_t id, uint8_t type, uint8_t y, uint8_t x)
 109 {
 110     struct Thing * t;
 111     t = (struct Thing *) add_to_struct_list(sizeof(struct Thing), 0, id, 0,
 112                                             (struct NextAndId **)&world.things);
 113     struct ThingType * tt = get_thing_type(type);
 114     set_cleanup_flag(CLEANUP_THINGS);
 115     t->type       = tt->id;
 116     t->lifepoints = tt->lifepoints;
 117     t->pos.y      = y;
 118     t->pos.x      = x;
 119     return t;
 120 }
 121
 122
 123
 124 extern void free_thing_actions(struct ThingAction * ta)
 125 {
 126     if (NULL == ta)
 127     {
 128         return;
 129     }
 130     free_thing_actions(ta->next);
 131     free(ta->name);
 132     free(ta);
 133 }
 134
 135
 136
 137 extern void free_thing_types(struct ThingType * tt)
 138 {
 139     if (NULL == tt)
 140     {
 141         return;
 142     }
 143     free_thing_types(tt->next);
 144     free(tt->name);
 145     free(tt);
 146 }
 147
 148
 149
 150 extern void free_things(struct Thing * t)
 151 {
 152     if (NULL == t)
 153     {
 154         return;
 155     }
 156     free_things(t->owns);
 157     free_things(t->next);
 158     free(t->fov_map);
 159     free(t);
 160     if (t == world.things)         /* So add_things()' NULL-delimited thing   */
 161     {                              /* iteration loop does not iterate over    */
 162         world.things = NULL;       /* freed memory when called the first time */
 163     }                              /* after world re-seeding.                 */
 164 }
 165
 166
 167
 168 extern struct ThingAction * get_thing_action(uint8_t id)
 169 {
 170     struct ThingAction * ta = world.thing_actions;
 171     for (; NULL != ta && id != ta->id; ta = ta->next);
 172     return ta;
 173 }
 174
 175
 176
 177 extern struct ThingType * get_thing_type(uint8_t id)
 178 {
 179     struct ThingType * tt = world.thing_types;
 180     for (; NULL != tt && id != tt->id; tt = tt->next);
 181     return tt;
 182 }
 183
 184
 185
 186 extern uint8_t get_thing_action_id_by_name(char * name)
 187 {
 188     struct ThingAction * ta = world.thing_actions;
 189     while (NULL != ta)
 190     {
 191         if (0 == strcmp(ta->name, name))
 192         {
 193             break;
 194         }
 195         ta = ta->next;
 196     }
 197     if (!ta)
 198     {
 199         return 0;
 200     }
 201     return ta->id;
 202 }
 203
 204
 205
 206 extern struct Thing * get_thing(struct Thing * ptr, uint8_t id, uint8_t deep)
 207 {
 208     while (1)
 209     {
 210         if (NULL == ptr || id == ptr->id)
 211         {
 212             return ptr;
 213         }
 214         if (deep)
 215         {
 216             struct Thing * owned_thing = get_thing(ptr->owns, id, 1);
 217             if (NULL != owned_thing)
 218             {
 219                 return ptr;
 220             }
 221         }
 222         ptr = ptr->next;
 223     }
 224 }
 225
 226
 227
 228 extern struct Thing * get_player()
 229 {
 230     return get_thing(world.things, 0, 0);
 231 }
 232
 233
 234
 235 extern void add_things(uint8_t type, uint8_t n)
 236 {
 237     uint8_t i;
 238     for (i = 0; i < n; i++)
 239     {
 240         struct yx_uint8 pos;
 241         while (1)
 242         {
 243             char * err = "Space to put thing on too hard to find."
 244                          "Map too small?";
 245             uint16_t i_pos = 0;
 246             for (pos.y = pos.x = 0; 0 == is_passable(pos); i_pos++)
 247             {
 248                 exit_err(UINT16_MAX == i_pos, err);
 249                 pos.y = rrand() % world.map.length;
 250                 pos.x = rrand() % world.map.length;
 251             }
 252             struct Thing * t;
 253             uint8_t clear = 1;
 254             for (t = world.things; t; t = t->next)
 255             {
 256                 if (yx_uint8_cmp(&pos, &t->pos) && 0 != t->lifepoints)
 257                 {
 258                     clear = 0;
 259                     break;
 260                 }
 261             }
 262             if (1 == clear)
 263             {
 264                 break;
 265             }
 266         }
 267         add_thing(-1, type, pos.y, pos.x);
 268     }
 269 }
 270
 271
 272
 273 extern void own_thing(struct Thing ** target, struct Thing ** source,
 274                       uint8_t id)
 275 {
 276     struct Thing * t;
 277     if (id == (*source)->id)
 278     {
 279         t = * source;
 280         * source = t->next;
 281     }
 282     else
 283     {
 284         struct Thing * penult = * source;
 285         while (1)
 286         {
 287             if (id == penult->next->id)
 288             {
 289                 break;
 290             }
 291             penult = penult->next;
 292         }
 293         t = penult->next;
 294         penult->next = t->next;
 295     }
 296     struct Thing ** t_ptr_ptr = target;
 297     for (; NULL != * t_ptr_ptr; t_ptr_ptr = &(*t_ptr_ptr)->next);
 298     * t_ptr_ptr = t;
 299     t->next = NULL;
 300 }
 301
 302
 303
 304 extern void set_thing_position(struct Thing * t, struct yx_uint8 pos)
 305 {
 306     t->pos = pos;
 307     struct Thing * owned = t->owns;
 308     for (; owned != NULL; set_thing_position(owned, pos), owned = owned->next);
 309 }