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

   1 /* src/server/configfile.c */
   2
   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()
  12                                    */
  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_THING_TYPES,
  16                       * CLEANUP_THING_ACTIONS
  17                       */
  18 #include "thing_actions.h" /* ThingAction */
  19 #include "things.h" /* Thing, ThingType */
  20 #include "world.h" /* world global */
  21
  22
  23
  24 /* Flags defining state of thing type and action entry reading ((un-)finished /
  25  * ready for starting the reading of a new definition etc.)
  26  */
  27 enum flag
  28 {
  29     HEIGHT_SET     = 0x02,
  30     WIDTH_SET      = 0x04,
  31     NAME_SET       = 0x02,
  32     EFFORT_SET     = 0x04,
  33     CORPSE_ID_SET  = 0x04,
  34     SYMBOL_SET     = 0x08,
  35     LIFEPOINTS_SET = 0x10,
  36     CONSUMABLE_SET = 0x20,
  37     START_N_SET    = 0x40,
  38     READY_ACTION   = NAME_SET | EFFORT_SET,
  39     READY_THING    = NAME_SET | CORPSE_ID_SET | SYMBOL_SET | LIFEPOINTS_SET
  40                      | CONSUMABLE_SET | START_N_SET
  41 };
  42
  43
  44
  45 /* What ThingType and ThingAction structs have in common at their top. Use this
  46  * to allow same functions run over structs of both types.
  47  */
  48 struct EntryHead
  49 {
  50     uint8_t id;
  51     struct EntryHead * next;
  52 };
  53
  54
  55
  56 /* Interpret "token0" and "token1" as data to write into the ThingAction /
  57  * ThingType DB.
  58  *
  59  * Individual ThingType / ThingAction DB entries are put together line by line
  60  * before being written. Writing only happens after all necessary members of an
  61  * entry have been assembled, and when additionally a) a new entry is started by
  62  * a "token0" of "ACTION" or "THINGTYPE"; or b) "token0" is NULL.
  63  *
  64  * Also check against the line parse_file() read tokens from having more tokens.
  65  */
  66 static void tokens_into_entries(char * token0, char * token1);
  67
  68 /* Start reading a new DB entry of "size" from tokens if "token0" matches
  69  * "comparand". Set EDIT_STARTED in "flags" to mark beginning of new entry
  70  * reading. Check that "token1" id of new entry has not already been used in DB
  71  * starting at "entry_cmp".
  72  */
  73 static uint8_t start_entry(char * token0, char * token1, char * comparand,
  74                          uint8_t * flags, size_t size,
  75                          struct EntryHead ** entry,
  76                          struct EntryHead * entry_cmp);
  77
  78 /* Write DB entry pointed to by "entry" to its appropriate location. */
  79 static void write_if_entry(struct EntryHead ** entry,
  80                            struct EntryHead *** entry_p_p_p);
  81
  82 /* Ensure that all .corpse_id members in the ThingType DB fit .id members of
  83  * ThingType DB entries.
  84  */
  85 static void test_corpse_ids();
  86
  87 /* If "token0" matches "comparand", set world.player_type to int in "token1". */
  88 static uint8_t set_player_type(char * token0, char * comparand, char * token1);
  89
  90 /* If "token0" matches "comparand", set world.map.length to int in "token1". */
  91 static uint8_t set_map_length(char * token0, char * comparand, char * token1);
  92
  93 /* Try to read tokens as members for the definition currently edited, which may
  94  * be "tt" or "ta". What member of which of the two is set depends on which of
  95  * the flags has EDIT_STARTED set and on the key name in "token0". Return 1 if
  96  * interpretation succeeds, else 0.
  97  *
  98  * Note that ThingAction entries' .name also determines their .func.
  99  */
 100 static uint8_t set_members(char * token0, char * token1,
 101                            uint8_t * thing_flags, uint8_t * action_flags,
 102                            struct ThingType * tt, struct ThingAction * ta);
 103
 104 /* If "name" fits "ta"->name, set "ta"->func to "func". (Derives ThingAction
 105  * .func from .name for set_members().
 106  */
 107 static uint8_t try_func_name(struct ThingAction * ta,
 108                              char * name, void (* func) (struct Thing *));
 109
 110
 111
 112 static void tokens_into_entries(char * token0, char * token1)
 113 {
 114     char * str_action = "ACTION";
 115     char * str_thing = "THINGTYPE";
 116     char * str_player = "PLAYER_TYPE";
 117     char * str_map_length = "MAP_LENGTH";
 118     static struct ThingAction ** ta_p_p = &world.thing_actions;
 119     static struct ThingType ** tt_p_p = &world.thing_types;
 120     static uint8_t action_flags = READY_ACTION;
 121     static uint8_t thing_flags = READY_THING;
 122     static struct EntryHead * ta = NULL;
 123     static struct EntryHead * tt = NULL;
 124     if (!token0 || !strcmp(token0, str_action) || !strcmp(token0, str_thing)
 125                 || !strcmp(token0, str_player))
 126     {
 127         parse_and_reduce_to_readyflag(&action_flags, READY_ACTION);
 128         parse_and_reduce_to_readyflag(&thing_flags, READY_THING);
 129         write_if_entry(&ta, (struct EntryHead ***) &ta_p_p);
 130         write_if_entry(&tt, (struct EntryHead ***) &tt_p_p);
 131     }
 132     if (token0)
 133     {
 134         parsetest_too_many_values();
 135         if (start_entry(token0, token1, str_action, &action_flags,
 136                         sizeof(struct ThingAction), (struct EntryHead**) &ta,
 137                         (struct EntryHead *) world.thing_actions))
 138         {
 139             err_line(0 == atoi(token1), "Value must not be 0.");
 140         }
 141         else if (!(   start_entry(token0, token1, str_thing, &thing_flags,
 142                                   sizeof(struct ThingType),
 143                                   (struct EntryHead**) &tt,
 144                                   (struct EntryHead *) world.thing_types)
 145                    || set_player_type(token0, str_player, token1)
 146                    || set_map_length(token0, str_map_length, token1)
 147                    || set_members(token0, token1, &thing_flags, &action_flags,
 148                                   (struct ThingType *) tt,
 149                                   (struct ThingAction *) ta)))
 150         {
 151             parse_unknown_arg();
 152         }
 153     }
 154 }
 155
 156
 157
 158 static uint8_t start_entry(char * token0, char * token1, char * comparand,
 159                            uint8_t * flags, size_t size,
 160                            struct EntryHead ** entry,
 161                            struct EntryHead * entry_cmp)
 162 {
 163     if (strcmp(token0, comparand))
 164     {
 165         return 0;
 166     }
 167     *entry = (struct EntryHead *) parse_init_entry(flags, size);
 168     parsetest_int(token1, '8');
 169     (*entry)-> id = atoi(token1);
 170     for (; NULL != entry_cmp; entry_cmp = entry_cmp->next)
 171     {
 172         parse_id_uniq((*entry)->id == entry_cmp->id);
 173     }
 174     return 1;
 175 }
 176
 177
 178
 179 static void write_if_entry(struct EntryHead ** entry,
 180                            struct EntryHead *** entry_p_p_p)
 181 {
 182     if (*entry)
 183     {
 184         (*entry)->next = NULL;
 185         **entry_p_p_p = *entry;
 186         *entry_p_p_p = &((*entry)->next);
 187         *entry = NULL;   /* So later runs of this don't re-append same entry. */
 188     }
 189 }
 190
 191
 192
 193 static void test_corpse_ids()
 194 {
 195     char * f_name = "test_corpse_ids()";
 196     char * prefix = "In the thing types DB, one thing corpse ID does not "
 197                     "reference any known thing type in the DB. ID of "
 198                     "responsible thing type: ";
 199     size_t size = strlen(prefix) + 3 + 1; /* 3: uint8_t representation strlen */
 200     char * err_corpse = try_malloc(size, f_name);
 201     struct ThingType * test_entry_0 = world.thing_types;
 202     for (; test_entry_0; test_entry_0 = test_entry_0->next)
 203     {
 204         uint8_t corpse_id_found = 0;
 205         struct ThingType * test_entry_1 = world.thing_types;
 206         for (; test_entry_1; test_entry_1 = test_entry_1->next)
 207         {
 208             if (test_entry_0->corpse_id == test_entry_1->id)
 209             {
 210                 corpse_id_found = 1;
 211             }
 212         }
 213         int test = snprintf(err_corpse, size, "%s%d", prefix, test_entry_0->id);
 214         exit_trouble(test < 0, f_name, "snprintf()");
 215         exit_err(!corpse_id_found, err_corpse);
 216     }
 217     free(err_corpse);
 218 }
 219
 220
 221
 222 static uint8_t set_player_type(char * token0, char * comparand, char * token1)
 223 {
 224     if (strcmp(token0, comparand))
 225     {
 226         return 0;
 227     }
 228     parsetest_int(token1, '8');
 229     world.player_type = atoi(token1);
 230     return 1;
 231 }
 232
 233
 234
 235 static uint8_t set_map_length(char * token0, char * comparand, char * token1)
 236 {
 237     if (strcmp(token0, comparand))
 238     {
 239         return 0;
 240     }
 241     parsetest_int(token1, 'i');
 242     int test = atoi(token1) > 256 || atoi(token1) < 1;
 243     err_line(test, "Value must be >= 1 and <= 256.");
 244     world.map.length = atoi(token1);
 245     return 1;
 246 }
 247
 248
 249
 250 static uint8_t set_members(char * token0, char * token1, uint8_t * thing_flags,
 251                            uint8_t * action_flags,
 252                            struct ThingType * tt, struct ThingAction * ta)
 253 {
 254     if (   *action_flags & EDIT_STARTED
 255         && parse_val(token0, token1, "NAME", action_flags,
 256                      NAME_SET, 's', (char *) &ta->name))
 257     {
 258         if (!(   try_func_name(ta, "move", actor_move)
 259               || try_func_name(ta, "pick_up", actor_pick)
 260               || try_func_name(ta, "drop", actor_drop)
 261               || try_func_name(ta, "use", actor_use)))
 262         {
 263             ta->func = actor_wait;
 264         }
 265         *action_flags = *action_flags | NAME_SET;
 266         return 1;
 267     }
 268     else if (   parse_val(token0, token1, "NAME", thing_flags,
 269                           NAME_SET, 's', (char *) &tt->name)
 270              || parse_val(token0, token1, "SYMBOL", thing_flags,
 271                           SYMBOL_SET, 'c', (char *) &tt->char_on_map)
 272              || parse_val(token0, token1, "EFFORT", action_flags,
 273                           EFFORT_SET, '8', (char *) &ta->effort)
 274              || parse_val(token0, token1, "START_NUMBER", thing_flags,
 275                           START_N_SET, '8', (char *) &tt->start_n)
 276              || parse_val(token0, token1, "LIFEPOINTS", thing_flags,
 277                           LIFEPOINTS_SET, '8', (char *) &tt->lifepoints)
 278              || parse_val(token0, token1, "CONSUMABLE", thing_flags,
 279                           CONSUMABLE_SET, '8', (char *) &tt->consumable)
 280              || parse_val(token0, token1, "CORPSE_ID", thing_flags,
 281                           CORPSE_ID_SET, '8', (char *) &tt->corpse_id))
 282     {
 283         return 1;
 284     }
 285     return 0;
 286 }
 287
 288
 289
 290 static uint8_t try_func_name(struct ThingAction * ta, char * name,
 291                              void (* func) (struct Thing *))
 292 {
 293     if (0 == strcmp(ta->name, name))
 294     {
 295         ta->func = func;
 296         return 1;
 297     }
 298     return 0;
 299 }
 300
 301
 302
 303 extern void read_config_file()
 304 {
 305     parse_file(world.path_config, tokens_into_entries);
 306     exit_err(!world.map.length, "Map size not defined in config file.");
 307     uint8_t player_type_is_valid = 0;
 308     struct ThingType * tt;
 309     for (tt = world.thing_types; NULL != tt; tt = tt->next)
 310     {
 311         if (world.player_type == tt->id)
 312         {
 313             player_type_is_valid = 1;
 314             break;
 315         }
 316     }
 317     exit_err(!player_type_is_valid, "No valid thing type set for player.");
 318     set_cleanup_flag(CLEANUP_THING_ACTIONS | CLEANUP_THING_TYPES);
 319     test_corpse_ids();
 320 }