home · contact · privacy
Replace uses of variable-length arrays with try_malloc()/free().
[plomrogue] / src / server / things.c
1 /* src/server/things.c */
2
3 #include "things.h"
4 #include <stddef.h> /* NULL */
5 #include <stdint.h> /* uint8_t, uint16_t, UINT8_MAX, 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 */
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
19 /* Return lowest unused id for new thing. */
20 static uint8_t get_lowest_unused_id();
21
22
23
24 static uint8_t get_lowest_unused_id()
25 {
26     uint8_t i = 0;
27     while (1)
28     {
29         if (!get_thing(world.things, i, 1))
30         {
31             return i;
32         }
33         exit_err(i == UINT8_MAX, "No unused ID available to add new thing.");
34         i++;
35     }
36 }
37
38
39
40 extern struct Thing * get_thing(struct Thing * ptr, uint8_t id, uint8_t deep)
41 {
42     while (1)
43     {
44         if (NULL == ptr || id == ptr->id)
45         {
46             return ptr;
47         }
48         if (deep)
49         {
50             struct Thing * owned_thing = get_thing(ptr->owns, id, 1);
51             if (NULL != owned_thing)
52             {
53                 return ptr;
54             }
55         }
56         ptr = ptr->next;
57     }
58 }
59
60
61
62 extern void free_thing_types(struct ThingType * tt_start)
63 {
64     if (NULL == tt_start)
65     {
66         return;
67     }
68     free_thing_types(tt_start->next);
69     free(tt_start->name);
70     free(tt_start);
71 }
72
73
74
75 extern struct Thing * add_thing(int16_t id, uint8_t type, uint8_t find_pos)
76 {
77     char * f_name = "add_thing()";
78     struct ThingType * tt = get_thing_type(type);
79     struct Thing *     t  = try_malloc(sizeof(struct Thing), f_name);
80     memset(t, 0, sizeof(struct Thing));
81     t->id = (0 <= id && id <= UINT8_MAX) ? id : get_lowest_unused_id();
82     t->type       = tt->id;
83     t->lifepoints = tt->lifepoints;
84     char * err = "Space to put thing on too hard to find. Map too small?";
85     uint16_t i = 0;
86     memset(&(t->pos), 0, sizeof(struct yx_uint8));
87     while (find_pos)
88     {
89         struct yx_uint8 pos;
90         for (pos.y = pos.x = 0; 0 == is_passable(pos); i++)
91         {
92             exit_err(UINT16_MAX == i, err);
93             pos.y = rrand() % world.map.length;
94             pos.x = rrand() % world.map.length;
95         }
96         struct Thing * t_ptr;
97         uint8_t clear = 1;
98         for (t_ptr = world.things; t_ptr != NULL; t_ptr = t_ptr->next)
99         {
100             if (yx_uint8_cmp(&pos, &t_ptr->pos) && 0 != t_ptr->lifepoints)
101             {
102                 clear = 0;
103                 break;
104             }
105         }
106         if (1 == clear)
107         {
108             t->pos = pos;
109             break;
110         }
111     }
112     struct Thing ** t_ptr_ptr = &world.things;
113     for (; NULL != * t_ptr_ptr; t_ptr_ptr = &(*t_ptr_ptr)->next);
114     * t_ptr_ptr = t;
115     return t;
116 }
117
118
119
120 extern void add_things(uint8_t type, uint8_t n)
121 {
122     uint8_t i;
123     for (i = 0; i < n; i++)
124     {
125         add_thing(-1, type, 1);
126     }
127 }
128
129
130
131 extern void free_things(struct Thing * t_start)
132 {
133     if (NULL == t_start)
134     {
135         return;
136     }
137     free_things(t_start->owns);
138     free_things(t_start->next);
139     free(t_start->fov_map);
140     free(t_start);
141     if (t_start == world.things)   /* So add_things()' NULL-delimited thing   */
142     {                              /* iteration loop does not iterate over    */
143         world.things = NULL;       /* freed memory when called the first time */
144     }                              /* after world re-seeding.                 */
145 }
146
147
148
149 extern void own_thing(struct Thing ** target, struct Thing ** source,
150                       uint8_t id)
151 {
152     struct Thing * t;
153     if (id == (*source)->id)
154     {
155         t = * source;
156         * source = t->next;
157     }
158     else
159     {
160         struct Thing * penult = * source;
161         while (1)
162         {
163             if (id == penult->next->id)
164             {
165                 break;
166             }
167             penult = penult->next;
168         }
169         t = penult->next;
170         penult->next = t->next;
171     }
172     struct Thing ** t_ptr_ptr = target;
173     for (; NULL != * t_ptr_ptr; t_ptr_ptr = &(*t_ptr_ptr)->next);
174     * t_ptr_ptr = t;
175     t->next = NULL;
176 }
177
178
179
180 extern struct Thing * get_player()
181 {
182     return get_thing(world.things, 0, 1);
183 }
184
185
186
187 extern struct ThingType * get_thing_type(uint8_t id)
188 {
189     char * f_name = "get_thing_type()";
190     struct ThingType * tt = world.thing_types;
191     for (; NULL != tt && id != tt->id; tt = tt->next);
192     char * err_intro = "Requested thing type of unused ID ";
193     uint16_t size = strlen(err_intro) + 3 + 1 + 1;
194     char * err = try_malloc(size, f_name);
195     sprintf(err, "%s%d.", err_intro, id);
196     exit_err(NULL == tt, err);
197     free(err);
198     return tt;
199 }
200
201
202
203 extern void set_thing_position(struct Thing * t, struct yx_uint8 pos)
204 {
205     t->pos = pos;
206     struct Thing * owned = t->owns;
207     for (; owned != NULL; set_thing_position(owned, pos), owned = owned->next);
208 }