1 /* src/server/configfile.c */
3 #include <stddef.h> /* size_t, NULL */
4 #include <stdio.h> /* snprintf() */
5 #include <stdint.h> /* uint8_t */
6 #include <stdlib.h> /* atoi(), free() */
7 #include <string.h> /* strcmp() */
8 #include "../common/parse_file.h" /* EDIT_STARTED, parsetest_int(),parse_file(),
9 * parsetest_too_many_values(),parse_id_uniq()
10 * parse_unknown_arg(), parse_init_entry(),
11 * parse_and_reduce_to_readyflag(),parse_val()
13 #include "../common/rexit.h" /* exit_err(), exit_trouble() */
14 #include "../common/try_malloc.h" /* try_malloc() */
15 #include "cleanup.h" /* set_cleanup_flag(), CLEANUP_MAP_OBJ_DEFS,
16 * CLEANUP_MAP_OBJ_ACTS
18 #include "map_object_actions.h" /* MapObjAct */
19 #include "map_objects.h" /* MapObj, MapObjDef, struct MapObjDef */
20 #include "world.h" /* world global */
24 /* Flags defining state of object and action entry reading ((un-)finished /
25 * ready for starting the reading of a new definition etc.)
37 LIFEPOINTS_SET = 0x10,
38 CONSUMABLE_SET = 0x20,
40 READY_ACT = NAME_SET | EFFORT_SET,
41 READY_OBJ = NAME_SET | CORPSE_ID_SET | SYMBOL_SET | LIFEPOINTS_SET
42 | CONSUMABLE_SET | START_N_SET,
43 READY_MAP = HEIGHT_SET | WIDTH_SET | ORTH_SET | DIAG_SET
48 /* What MapObjDef and MapObjAct structs have in common at their top. Use this to
49 * allow same functions run over structs of both types.
54 struct EntryHead * next;
59 /* Interpret "token0" and "token1" as data to write into the MapObjAct /
62 * Individual MapObjDef / MapObjAct DB entries are put together line by line
63 * before being written. Writing only happens after all necessary members of an
64 * entry have been assembled, and when additionally a) a new entry is started by
65 * a "token0" of "ACTION" or "OBJECT"; or b) "token0" is NULL.
67 * Also check against the line parse_file() read tokens from having more tokens.
69 static void tokens_into_entries(char * token0, char * token1);
71 /* Start reading a new DB entry of "size" from tokens if "token0" matches
72 * "comparand". Set EDIT_STARTED in "flags" to mark beginning of new entry
73 * reading. Check that "token1" id of new entry has not already been used in DB
74 * starting at "entry_cmp".
76 static uint8_t start_entry(char * token0, char * token1, char * comparand,
77 uint8_t * flags, size_t size,
78 struct EntryHead ** entry,
79 struct EntryHead * entry_cmp);
81 /* Start reading map definition if "token0" matches "comparand". Set "map_flags"
82 * to EDIT_STARTED to mark beginning of map definition reading.
84 static uint8_t start_map(char * token0, char * comparand, uint8_t * map_flags);
86 /* Write DB entry pointed to by "entry" to its appropriate location. */
87 static void write_if_entry(struct EntryHead ** entry,
88 struct EntryHead *** entry_p_p_p);
90 /* Ensure that all .corpse_id members in the MapObjDef DB fit .id members of
91 * MapObjDef DB entries.
93 static void test_corpse_ids();
95 /* If "token0" matches "comparand", set world.player_type to int in "token1". */
96 static uint8_t set_player_type(char * token0, char * comparand, char * token1);
98 /* Try to read tokens as members for the definition currently edited, which may
99 * be "mod" or "moa" or that of world.map. What member of which of the three is
100 * set depends on which of the flags has EDIT_STARTED set and on the key name in
101 * "token0". Return 1 if interpretation succeeds, else 0.
103 * Note that MapObjAct entries' .name also determines their .func.
105 static uint8_t set_members(char * token0, char * token1, uint8_t * object_flags,
106 uint8_t * action_flags, uint8_t * map_flags,
107 struct MapObjDef * mod, struct MapObjAct * moa);
109 /* set_members() helper specifically for editing world.map members. */
110 static uint8_t set_map_members(char * token0,char * token1,uint8_t * map_flags);
112 /* If "name" fits "moa"->name, set "moa"->func to "func". (Derives MapObjAct
113 * .func from .name for set_members().
115 static uint8_t try_func_name(struct MapObjAct * moa,
116 char * name, void (* func) (struct MapObj *));
120 static void tokens_into_entries(char * token0, char * token1)
122 char * str_act = "ACTION";
123 char * str_obj = "OBJECT";
124 char * str_map = "MAP_TYPE";
125 char * str_player = "PLAYER_TYPE";
126 static struct MapObjAct ** moa_p_p = &world.map_obj_acts;
127 static struct MapObjDef ** mod_p_p = &world.map_obj_defs;
128 static uint8_t action_flags = READY_ACT;
129 static uint8_t object_flags = READY_OBJ;
130 static uint8_t map_flags = READY_MAP;
131 static struct EntryHead * moa = NULL;
132 static struct EntryHead * mod = NULL;
133 if (!token0 || !strcmp(token0, str_act) || !strcmp(token0, str_obj)
134 || !strcmp(token0, str_map) || !strcmp(token0, str_player))
136 parse_and_reduce_to_readyflag(&action_flags, READY_ACT);
137 parse_and_reduce_to_readyflag(&object_flags, READY_OBJ);
138 parse_and_reduce_to_readyflag(&map_flags, READY_MAP);
139 write_if_entry(&moa, (struct EntryHead ***) &moa_p_p);
140 write_if_entry(&mod, (struct EntryHead ***) &mod_p_p);
144 parsetest_too_many_values();
145 if (!( start_entry(token0, token1, str_act, &action_flags,
146 sizeof(struct MapObjAct),(struct EntryHead**) &moa,
147 (struct EntryHead *) world.map_obj_acts)
148 || start_entry(token0, token1, str_obj, &object_flags,
149 sizeof(struct MapObjDef),(struct EntryHead**) &mod,
150 (struct EntryHead *) world.map_obj_defs)
151 || start_map(token0, str_map, &map_flags)
152 || set_player_type(token0, str_player, token1)
153 || set_members(token0, token1, &object_flags, &action_flags,
154 &map_flags, (struct MapObjDef *)mod,
155 (struct MapObjAct *) moa)))
164 static uint8_t start_entry(char * token0, char * token1, char * comparand,
165 uint8_t * flags, size_t size,
166 struct EntryHead ** entry,
167 struct EntryHead * entry_cmp)
169 if (strcmp(token0, comparand))
173 *entry = (struct EntryHead *) parse_init_entry(flags, size);
174 parsetest_int(token1, '8');
175 (*entry)-> id = atoi(token1);
176 for (; NULL != entry_cmp; entry_cmp = entry_cmp->next)
178 parse_id_uniq((*entry)->id == entry_cmp->id);
185 static uint8_t start_map(char * token0, char * comparand, uint8_t * map_flags)
187 if (strcmp(token0, comparand))
191 *map_flags = EDIT_STARTED;
197 static void write_if_entry(struct EntryHead ** entry,
198 struct EntryHead *** entry_p_p_p)
202 (*entry)->next = NULL;
203 **entry_p_p_p = *entry;
204 *entry_p_p_p = &((*entry)->next);
205 *entry = NULL; /* So later runs of this don't re-append same entry. */
211 static void test_corpse_ids()
213 char * f_name = "test_corpse_ids()";
214 char * prefix = "In the object definitions DB, one object corpse ID does "
215 "not reference any known object in the DB. ID of "
216 "responsible object: ";
217 size_t size = strlen(prefix) + 3 + 1; /* 3: uint8_t representation strlen */
218 char * err_corpse = try_malloc(size, f_name);
219 struct MapObjDef * test_entry_0 = world.map_obj_defs;
220 for (; test_entry_0; test_entry_0 = test_entry_0->next)
222 uint8_t corpse_id_found = 0;
223 struct MapObjDef * test_entry_1 = world.map_obj_defs;
224 for (; test_entry_1; test_entry_1 = test_entry_1->next)
226 if (test_entry_0->corpse_id == test_entry_1->id)
231 int test = snprintf(err_corpse, size, "%s%d", prefix, test_entry_0->id);
232 exit_trouble(test < 0, f_name, "snprintf()");
233 exit_err(!corpse_id_found, err_corpse);
240 static uint8_t set_map_members(char * token0, char * token1, uint8_t * map_flags)
242 if ( parse_val(token0, token1, "HEIGHT", map_flags,
243 HEIGHT_SET, 'i', (char *) &world.map.size.y)
244 || parse_val(token0, token1, "WIDTH", map_flags,
245 WIDTH_SET, 'i', (char *) &world.map.size.x))
247 int test = atoi(token1) > 256 || atoi(token1) < 1;
248 err_line(test, "Value must be >= 1 and <= 256.");
251 else if ( parse_val(token0, token1, "DIST_ORTHOGONAL", map_flags,
252 ORTH_SET, '8', (char *) &world.map.dist_orthogonal)
253 || parse_val(token0, token1, "DIST_DIAGONAL", map_flags,
254 DIAG_SET, '8', (char *) &world.map.dist_diagonal))
256 err_line(0 == atoi(token1), "Value must not be zero.");
264 static uint8_t set_player_type(char * token0, char * comparand, char * token1)
266 if (strcmp(token0, comparand))
270 parsetest_int(token1, '8');
271 world.player_type = atoi(token1);
277 static uint8_t set_members(char * token0, char * token1, uint8_t * object_flags,
278 uint8_t * action_flags, uint8_t * map_flags,
279 struct MapObjDef * mod, struct MapObjAct * moa)
281 if ( *action_flags & EDIT_STARTED
282 && parse_val(token0, token1, "NAME", action_flags,
283 NAME_SET, 's', (char *) &moa->name))
285 if (!( try_func_name(moa, "move", actor_move)
286 || try_func_name(moa, "pick_up", actor_pick)
287 || try_func_name(moa, "drop", actor_drop)
288 || try_func_name(moa, "use", actor_use)))
290 moa->func = actor_wait;
292 *action_flags = *action_flags | NAME_SET;
295 else if ( set_map_members(token0, token1, map_flags)
296 || parse_val(token0, token1, "NAME", object_flags,
297 NAME_SET, 's', (char *) &mod->name)
298 || parse_val(token0, token1, "SYMBOL", object_flags,
299 SYMBOL_SET, 'c', (char *) &mod->char_on_map)
300 || parse_val(token0, token1, "EFFORT", action_flags,
301 EFFORT_SET, '8', (char *) &moa->effort)
302 || parse_val(token0, token1, "START_NUMBER", object_flags,
303 START_N_SET, '8', (char *) &mod->start_n)
304 || parse_val(token0, token1, "LIFEPOINTS", object_flags,
305 LIFEPOINTS_SET, '8', (char *) &mod->lifepoints)
306 || parse_val(token0, token1, "CONSUMABLE", object_flags,
307 CONSUMABLE_SET, '8', (char *) &mod->consumable)
308 || parse_val(token0, token1, "CORPSE_ID", object_flags,
309 CORPSE_ID_SET, '8', (char *) &mod->corpse_id))
318 static uint8_t try_func_name(struct MapObjAct * moa, char * name,
319 void (* func) (struct MapObj *))
321 if (0 == strcmp(moa->name, name))
331 extern void read_config_file()
333 parse_file(world.path_config, tokens_into_entries);
334 exit_err(!world.map.size.y, "Map not defined in config file.");
335 uint8_t player_type_is_valid = 0;
336 struct MapObjDef * mod;
337 for (mod = world.map_obj_defs; NULL != mod; mod = mod->next)
339 if (world.player_type == mod->id)
341 player_type_is_valid = 1;
345 exit_err(!player_type_is_valid, "No valid map object type set for player.");
346 set_cleanup_flag(CLEANUP_MAP_OBJECT_ACTS | CLEANUP_MAP_OBJECT_DEFS);