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

   1 /* src/server/map_objects.c */
   2
   3 #include "map_objects.h"
   4 #include <stddef.h> /* NULL */
   5 #include <stdint.h> /* uint8_t, uint16_t, UINT16_MAX */
   6 #include <stdlib.h> /* free() */
   7 #include <string.h> /* memset(), strlen() */
   8 #include "../common/rexit.h" /* exit_err() */
   9 #include "../common/try_malloc.h" /* try_malloc() */
  10 #include "../common/yx_uint8.h" /* yx_uint8 struct */
  11 #include "map.h" /* is_passable() */
  12 #include "rrand.h" /* rrand() */
  13 #include "world.h" /* global world */
  14 #include "yx_uint8.h" /* yx_uint8_cmp() */
  15
  16
  17
  18 /* Return pointer to map object of "id" in chain starting at "ptr". */
  19 static struct MapObj * get_map_object(struct MapObj * ptr, uint8_t id);
  20
  21 /* Add object of "type" to map on passable position. Don't put actor on actor.*/
  22 static void add_map_object(uint8_t type);
  23
  24
  25
  26 static struct MapObj * get_map_object(struct MapObj * ptr, uint8_t id)
  27 {
  28     while (1)
  29     {
  30         if (NULL == ptr || id == ptr->id)
  31         {
  32             return ptr;
  33         }
  34         struct MapObj * owned_object = get_map_object(ptr->owns, id);
  35         if (NULL != owned_object)
  36         {
  37             return ptr;
  38         }
  39         ptr = ptr->next;
  40     }
  41 }
  42
  43
  44
  45 static void add_map_object(uint8_t type)
  46 {
  47     char * f_name = "add_map_object()";
  48     struct MapObjDef * mod = get_map_object_def(type);
  49     struct MapObj *    mo  = try_malloc(sizeof(struct MapObj), f_name);
  50     memset(mo, 0, sizeof(struct MapObj));
  51     mo->id         = world.map_obj_count++;
  52     mo->type       = mod->id;
  53     mo->lifepoints = mod->lifepoints;
  54     char * err = "Space to put map object on too hard to find. Map too small?";
  55     uint16_t i = 0;
  56     while (1)
  57     {
  58         struct yx_uint8 pos;
  59         for (pos.y = pos.x = 0; 0 == is_passable(pos); i++)
  60         {
  61             exit_err(UINT16_MAX == i, err);
  62             pos.y = rrand() % world.map.size.y;
  63             pos.x = rrand() % world.map.size.x;
  64         }
  65         struct MapObj * mo_ptr;
  66         uint8_t clear = 1;
  67         for (mo_ptr = world.map_objs; mo_ptr != NULL; mo_ptr = mo_ptr->next)
  68         {
  69             if (yx_uint8_cmp(&pos, &mo_ptr->pos) && 0 != mo_ptr->lifepoints)
  70             {
  71                 clear = 0;
  72                 break;
  73             }
  74         }
  75         if (1 == clear)
  76         {
  77             mo->pos = pos;
  78             break;
  79         }
  80     }
  81     struct MapObj ** mo_ptr_ptr = &world.map_objs;
  82     for (; NULL != * mo_ptr_ptr; mo_ptr_ptr = &(*mo_ptr_ptr)->next);
  83     * mo_ptr_ptr = mo;
  84 }
  85
  86
  87
  88 extern void free_map_object_defs(struct MapObjDef * mod_start)
  89 {
  90     if (NULL == mod_start)
  91     {
  92         return;
  93     }
  94     free_map_object_defs(mod_start->next);
  95     free(mod_start->name);
  96     free(mod_start);
  97 }
  98
  99
 100
 101 extern void add_map_objects(uint8_t type, uint8_t n)
 102 {
 103     uint8_t i;
 104     for (i = 0; i < n; i++)
 105     {
 106         add_map_object(type);
 107     }
 108 }
 109
 110
 111
 112 extern void free_map_objects(struct MapObj * mo_start)
 113 {
 114     if (NULL == mo_start)
 115     {
 116         return;
 117     }
 118     free_map_objects(mo_start->owns);
 119     free_map_objects(mo_start->next);
 120     free(mo_start);
 121     if (mo_start == world.map_objs)  /* So add_map_objects()' NULL-delimited  */
 122     {                                /* map object iteration loop does not    */
 123         world.map_objs = NULL;       /* iterate over freed memory when called */
 124     }                                /* the 1st time after world re-seeding.  */
 125 }
 126
 127
 128
 129 extern void own_map_object(struct MapObj ** target, struct MapObj ** source,
 130                            uint8_t id)
 131 {
 132     struct MapObj * mo;
 133     if (id == (*source)->id)
 134     {
 135         mo = * source;
 136         * source = mo->next;
 137     }
 138     else
 139     {
 140         struct MapObj * penult = * source;
 141         while (1)
 142         {
 143             if (id == penult->next->id)
 144             {
 145                 break;
 146             }
 147             penult = penult->next;
 148         }
 149         mo = penult->next;
 150         penult->next = mo->next;
 151     }
 152     struct MapObj ** mo_ptr_ptr = target;
 153     for (; NULL != * mo_ptr_ptr; mo_ptr_ptr = &(*mo_ptr_ptr)->next);
 154     * mo_ptr_ptr = mo;
 155     mo->next = NULL;
 156 }
 157
 158
 159
 160 extern struct MapObj * get_player()
 161 {
 162     return get_map_object(world.map_objs, 0);
 163 }
 164
 165
 166
 167 extern struct MapObjDef * get_map_object_def(uint8_t id)
 168 {
 169     struct MapObjDef * mod = world.map_obj_defs;
 170     for (; NULL != mod && id != mod->id; mod = mod->next);
 171     char * err_intro = "Requested map object definition of unused ID ";
 172     char err[strlen(err_intro) + 3 + 1 + 1];
 173     sprintf(err, "%s%d.", err_intro, id);
 174     exit_err(NULL == mod, err);
 175     return mod;
 176 }
 177
 178
 179
 180 extern void set_object_position(struct MapObj * mo, struct yx_uint8 pos)
 181 {
 182     mo->pos = pos;
 183     struct MapObj * owned = mo->owns;
 184     for (; owned != NULL; set_object_position(owned, pos), owned = owned->next);
 185 }