plomlompom.com Git - plomrogue/blob - 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 }