home · contact · privacy
Server: Minor optimization of pathfinding algorithm.
[plomrogue] / 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 }