home · contact · privacy
8bde74235a29e721e7c2afd3dcda2ac7713cafcf
[plomrogue] / src / server / god_commands.c
1 /* src/server/god_commands.c */
2
3 #include "god_commands.h"
4 #include <stddef.h> /* NULL */
5 #include <stdint.h> /* uint8_t */
6 #include <stdlib.h> /* atoi(), free() */
7 #include <string.h> /* strcmp() */
8 #include <unistd.h> /* F_OK, access(), unlink() */
9 #include "../common/parse_file.h" /* err_line(), parse_val(), parsetest_int() */
10 #include "../common/rexit.h" /* exit_trouble() */
11 #include "cleanup.h" /* unset_cleanup_flag() */
12 #include "field_of_view.h" /* build_fov_map() */
13 #include "hardcoded_strings.h" /* s */
14 #include "init.h" /* remake_world() */
15 #include "map.h" /* remake_map() */
16 #include "thing_actions.h" /* ThingAction, actor_wait(), actor_move(),
17                             * actor_use(), actor_pickup(), actor_drop()
18                             */
19 #include "things.h" /* Thing, ThingType, add_thing(), get_thing(), own_thing(),
20                      * free_things()
21                      */
22 #include "world.h" /* world */
23
24
25
26 /* Parse/apply god command in "tok0"/tok1" to manipulate a ThingType*/
27 static uint8_t parse_thingtype_manipulation(char * tok0, char * tok1);
28
29 /* If "name" fits "ta"->name, set "ta"->func to "func". (Derives ThingAction
30  * .func from .name for set_members().
31  */
32 static uint8_t try_func_name(struct ThingAction * ta, char * name,
33                              void (* func) (struct Thing *));
34
35 /* Parse/apply god command in "tok0"/"tok1" to manipulate a ThingAction. */
36 static uint8_t parse_thingaction_manipulation(char * tok0, char * tok1);
37
38 /* Parse/apply god command in "tok0"/"tok1" oo setting "t"'s thing type. */
39 static uint8_t parse_thing_type(char * tok0, char * tok1, struct Thing * t);
40
41 /* Parse/apply god command in "tok0"/"tok1" on setting up thing "t". */
42 static uint8_t parse_thing_command(char * tok0, char * tok1, struct Thing * t);
43
44 /* Parse/apply god command in "tok0"/"tok1" on positioning a thing "t". */
45 static uint8_t parse_position(char* tok0, char * tok1, struct Thing * t);
46
47 /* Parse/apply god command in "tok0"/"tok1" on "t" owning another thing. */
48 static uint8_t parse_carry(char * tok0, char * tok1, struct Thing * t);
49
50 /* Parse/apply god command in "tok0"/"tok1" to manipulate a Thing. */
51 static uint8_t parse_thing_manipulation(char * tok0, char * tok1);
52
53 /* Performs parse_world_active()'s world activation legality tests. */
54 static uint8_t world_may_be_set_active();
55
56 /* Unlink worldstate file if it exists. */
57 static void remove_worldstate_file();
58
59 /* Parse/apply god command in "tok0"/"tok1" on toggling world.exists. Unset if
60  * argument is 0 and unlink worldstate file, but only set it on positive
61  * argument if it is not already set and a thing action of name S_CMD_WAIT, a
62  * player thing and a map are defined. On setting it, rebuild all FOVs.
63  */
64 static uint8_t parse_world_active(char * tok0, char * tok1);
65
66 /* Parse/apply god command in "tok0"/"tok1" to reset world.map.length. On
67  * re-set, set world.exists to 0, remove all things and free world.map.cells
68  */
69 static uint8_t set_map_length(char * tok0, char * tok1);
70
71
72
73 static uint8_t parse_thingtype_manipulation(char * tok0, char * tok1)
74 {
75     static struct ThingType * tt = NULL;
76     if (!tt &&
77         (   !strcmp(tok0, s[S_CMD_TT_CONSUM]) || !strcmp(tok0, s[S_CMD_TT_SYMB])
78          || !strcmp(tok0, s[S_CMD_TT_STARTN]) || !strcmp(tok0, s[S_CMD_TT_NAME])
79          || !strcmp(tok0, s[S_CMD_TT_CORPS]) || !strcmp(tok0, s[S_CMD_TT_HP])))
80     {
81         err_line(1, "No thing type defined to manipulate yet.");
82         return 1;
83     }
84     uint8_t id;
85     if (   parse_val(tok0,tok1,s[S_CMD_TT_CONSUM],'8',(char *) &tt->consumable)
86         || parse_val(tok0,tok1,s[S_CMD_TT_HP],'8',(char *) &tt->lifepoints)
87         || parse_val(tok0,tok1,s[S_CMD_TT_STARTN],'8',(char *) &tt->start_n)
88         || parse_val(tok0,tok1,s[S_CMD_TT_SYMB],'c',(char *) &tt->char_on_map)
89         || parse_val(tok0,tok1,s[S_CMD_TT_NAME],'s',(char *) &tt->name));
90     else if (parse_val(tok0, tok1, s[S_CMD_TT_CORPS],'8',(char *)&id))
91     {
92         if (!get_thing_type(id))
93         {
94             err_line(1, "Corpse ID belongs to no known thing type.");
95             return 1;
96         }
97         tt->corpse_id = id;
98     }
99     else if (parse_val(tok0, tok1, s[S_CMD_THINGTYPE], '8', (char *) &id))
100     {
101         tt = get_thing_type(id);
102         if (!tt)
103         {
104             tt = add_thing_type(id);
105         }
106     }
107     else
108     {
109         return 0;
110     }
111     return 1;
112 }
113
114
115
116 static uint8_t try_func_name(struct ThingAction * ta, char * name,
117                              void (* func) (struct Thing *))
118 {
119     if (0 == strcmp(ta->name, name))
120     {
121         ta->func = func;
122         return 1;
123     }
124     return 0;
125 }
126
127
128
129 static uint8_t parse_thingaction_manipulation(char * tok0, char * tok1)
130 {
131     static struct ThingAction * ta = NULL;
132     if (!ta &&
133         (!strcmp(tok0, s[S_CMD_TA_EFFORT]) || !strcmp(tok0, s[S_CMD_TA_NAME])))
134     {
135         err_line(1, "No thing action defined to manipulate yet.");
136         return 1;
137     }
138     uint8_t id;
139     if      (parse_val(tok0, tok1, s[S_CMD_TA_EFFORT],'8',(char *)&ta->effort));
140     else if (parse_val(tok0, tok1, s[S_CMD_TA_NAME], 's', (char *)&ta->name))
141     {
142         if (!(   try_func_name(ta, s[S_CMD_MOVE], actor_move)
143               || try_func_name(ta, s[S_CMD_PICKUP], actor_pick)
144               || try_func_name(ta, s[S_CMD_WAIT], actor_wait)
145               || try_func_name(ta, s[S_CMD_DROP], actor_drop)
146               || try_func_name(ta, s[S_CMD_USE], actor_use)))
147         {
148             err_line(1, "Invalid action function name.");
149             return 1;
150         }         /* Legal worlds have at least one thing action for waiting. */
151         if (world.exists)
152         {
153             world.exists = 0 != get_thing_action_id_by_name(s[S_CMD_WAIT]);
154             if (!world.exists)
155             {
156                 remove_worldstate_file();
157             }
158         }
159     }
160     else if (parse_val(tok0, tok1, s[S_CMD_THINGACTION], '8', (char *) &id))
161     {
162         if (!id)
163         {
164             err_line(1, "Value must be >= 1 and <= 255.");
165             return 1;
166         }
167         ta = get_thing_action(id);
168         if (!ta)
169         {
170             ta = add_thing_action(id);
171         }
172     }
173     else
174     {
175         return 0;
176     }
177     return 1;
178 }
179
180
181
182 static uint8_t parse_thing_type(char * tok0, char * tok1, struct Thing * t)
183 {
184     uint8_t type;
185     if (parse_val(tok0, tok1, s[S_CMD_T_TYPE], '8', (char *) &type))
186     {
187         struct ThingType * tt = get_thing_type(type);
188         if (!err_line(!tt, "Thing type does not exist."))
189         {
190             t->type = type;
191         }
192         return 1;
193     }
194     return 0;
195 }
196
197
198
199 static uint8_t parse_thing_command(char * tok0, char * tok1, struct Thing * t)
200 {
201     uint8_t command;
202     if (parse_val(tok0, tok1, s[S_CMD_T_COMMAND], '8', (char *) &command))
203     {
204         if (!command)
205         {
206             t->command = command;
207             return 1;
208         }
209         struct ThingAction * ta = world.thing_actions;
210         for (; ta && command != ta->id; ta = ta->next);
211         if (!err_line(!ta, "Thing action does not exist."))
212         {
213             t->command = command;
214         }
215         return 1;
216     }
217     return 0;
218 }
219
220
221
222 static uint8_t parse_position(char* tok0, char * tok1, struct Thing * t)
223 {
224     char axis = 0;
225     if      (!strcmp(tok0, s[S_CMD_T_POSY]))
226     {
227         axis = 'y';
228     }
229     else if (!strcmp(tok0, s[S_CMD_T_POSX]))
230     {
231         axis = 'x';
232     }
233     if (axis && !parsetest_int(tok1, '8'))
234     {
235         uint8_t length = atoi(tok1);
236         char * err = "Position is outside of map.";
237         if (!err_line(length >= world.map.length, err))
238         {
239             if      ('y' == axis)
240             {
241                 t->pos.y = length;
242             }
243             else if ('x' == axis)
244             {
245                 t->pos.x = length;
246             }
247             free(t->fov_map);
248             if (world.exists && t->lifepoints)
249             {
250                 t->fov_map = build_fov_map(t);
251             }
252         }
253         return 1;
254     }
255     return 0;
256 }
257
258
259
260 static uint8_t parse_carry(char * tok0, char * tok1, struct Thing * t)
261 {
262     uint8_t id;
263     if (parse_val(tok0, tok1, s[S_CMD_T_CARRIES], '8', (char *) &id))
264     {
265         if (!err_line(id == t->id, "Thing cannot carry itself."))
266         {
267             struct Thing * o = get_thing(world.things, id, 0);
268             if (!err_line(!o, "Thing not available for carrying."))
269             {
270                 own_thing(&(t->owns), &world.things, id);
271                 o->pos = t->pos;
272             }
273         }
274         return 1;
275     }
276     return 0;
277 }
278
279
280
281 static uint8_t parse_thing_manipulation(char * tok0, char * tok1)
282 {
283     static struct Thing * t = NULL;
284     if (!t &&
285         (   !strcmp(tok0, s[S_CMD_T_PROGRESS]) || !strcmp(tok0, s[S_CMD_T_TYPE])
286          || !strcmp(tok0, s[S_CMD_T_CARRIES]) || !strcmp(tok0, s[S_CMD_T_POSY])
287          || !strcmp(tok0, s[S_CMD_T_POSY]) || !strcmp(tok0, s[S_CMD_T_ARGUMENT])
288          || !strcmp(tok0, s[S_CMD_T_HP]) || !strcmp(tok0, s[S_CMD_T_COMMAND])))
289     {
290         err_line(1, "No thing defined to manipulate yet.");
291         return 1;
292     }
293     uint8_t id;
294     if (    parse_thing_type(tok0, tok1, t)
295         || parse_thing_command(tok0, tok1, t)
296         || parse_val(tok0,tok1, s[S_CMD_T_ARGUMENT], '8', (char *)&t->arg)
297         || parse_val(tok0,tok1, s[S_CMD_T_PROGRESS], '8', (char *)&t->progress)
298         || parse_val(tok0,tok1, s[S_CMD_T_HP], '8', (char *) &t->lifepoints)
299         || parse_position(tok0, tok1, t)
300         || parse_carry(tok0, tok1, t));
301     else if (parse_val(tok0, tok1, s[S_CMD_THING], 'i', (char *) &id))
302     {
303         t = get_thing(world.things, id, 1);
304         char * err = "No thing type found to initialize new thing.";
305         if (!t && !err_line(NULL == world.thing_types, err))
306         {
307             t = add_thing(id, world.thing_types->id, 0, 0);
308             if (world.exists && t->lifepoints)
309             {
310                 t->fov_map = build_fov_map(t);
311             }
312         }
313     }
314     else
315     {
316         return 0;
317     }
318     return 1;
319 }
320
321
322
323 static uint8_t world_may_be_set_active()
324 {
325     if (!get_thing_action_id_by_name(s[S_CMD_WAIT]))
326     {
327         err_line(1, "No thing action of name 'wait' found.");
328         return 0;
329     }
330     if (!get_player())
331     {
332         err_line(1, "No un-owned player thing (of id=0) found.");
333         return 0;
334     }
335     if (!world.map.cells)
336     {
337         err_line(1, "No map found.");
338         return 0;
339     }
340     return 1;
341 }
342
343
344
345 static void remove_worldstate_file()
346 {
347     if (!access(s[S_PATH_WORLDSTATE], F_OK))
348     {
349         int test = unlink(s[S_PATH_WORLDSTATE]);
350         exit_trouble(-1 == test, __func__, "unlink");
351     }
352 }
353
354
355
356 static uint8_t parse_world_active(char * tok0, char * tok1)
357 {
358     if (!strcmp(tok0, s[S_CMD_WORLD_ACTIVE]) && !parsetest_int(tok1, '8'))
359     {
360         if (!parsetest_int(tok1, '8'))
361         {
362             uint8_t argument = atoi(tok1);
363             if (!argument)
364             {
365                 remove_worldstate_file();
366                 world.exists = 0;
367             }
368             else if (world.exists)
369             {
370                 err_line(1, "World already active.");
371             }
372             else if (world_may_be_set_active())
373             {
374                 struct Thing * ti;
375                 for (ti = world.things; ti; ti = ti->next)
376                 {
377                     if (ti->lifepoints)
378                     {
379                         if (ti->fov_map)
380                         {
381                             free(ti->fov_map);
382                         }
383                         ti->fov_map = build_fov_map(ti);
384                     }
385                 }
386                 world.exists = 1;
387             }
388             return 1;
389         }
390     }
391     return 0;
392 }
393
394
395
396 static uint8_t set_map_length(char * tok0, char * tok1)
397 {
398     if (!strcmp(tok0, s[S_CMD_MAPLENGTH]) && !parsetest_int(tok1, 'u'))
399     {
400         uint16_t argument = atoi(tok1);
401         if (argument < 1 || argument > 256)
402         {
403             err_line(1, "Value must be >= 1 and <= 256.");
404             return 1;
405         }
406         world.exists = 0;
407         remove_worldstate_file();
408         free_things(world.things);
409         free(world.map.cells);
410         world.map.cells = NULL;    /* Since remake_map() runs free() on this. */
411         world.map.length = argument;
412         return 1;
413     }
414     return 0;
415 }
416
417
418
419 extern uint8_t parse_god_command_1arg(char * tok0, char * tok1)
420 {
421     if (   parse_thingtype_manipulation(tok0, tok1)
422         || parse_thingaction_manipulation(tok0, tok1)
423         || parse_thing_manipulation(tok0, tok1)
424         || set_map_length(tok0,tok1)
425         || parse_val(tok0,tok1,s[S_CMD_SEED_RAND],'U', (char *)&world.seed)
426         || parse_val(tok0,tok1,s[S_CMD_TURN],'u',(char *)&world.turn)
427         || parse_val(tok0,tok1,s[S_CMD_PLAYTYPE],'8',(char *)&world.player_type)
428         || parse_world_active(tok0, tok1));
429     else if (parse_val(tok0,tok1,s[S_CMD_SEED_MAP],'U',(char *)&world.seed_map))
430
431     {
432         remake_map();
433     }
434     else if (parse_val(tok0, tok1, s[S_CMD_MAKE_WORLD],'U',(char *)&world.seed))
435     {
436         uint8_t test = remake_world();
437         err_line(1 == test, "No player type with start number of >0 defined.");
438         err_line(2 == test, "No thing action with name 'wait' defined.");
439     }
440     else
441     {
442         return 0;
443     }
444     return 1;
445 }