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