From: Christian Heller <c.heller@plomlompom.de>
Date: Sun, 13 Jul 2014 21:49:13 +0000 (+0200)
Subject: Server: Read in former "config" data as normal server god commands.
X-Git-Tag: tce~707
X-Git-Url: https://plomlompom.com/repos/%7B%7Bdb.prefix%7D%7D/%7B%7B%20web_path%20%7D%7D/static/%7B%7Bprefix%7D%7D/day?a=commitdiff_plain;h=891ba8fbca53d920f6b3704827fa6b8aee737de4;p=plomrogue

Server: Read in former "config" data as normal server god commands.

Re-wrote and re-factored lots of stuff to facilitate this.
---

diff --git a/confserver/world b/confserver/world
index 1bbb10c..a399aee 100644
--- a/confserver/world
+++ b/confserver/world
@@ -1,78 +1,86 @@
 MAP_LENGTH 64
 PLAYER_TYPE 0
 
-ACTION 1
-NAME wait
-EFFORT 1
+THING_ACTION 1
+TA_EFFORT 1
+TA_NAME wait
 
-ACTION 2
-NAME move
-EFFORT 5
+THING_ACTION 2
+TA_EFFORT 5
+TA_NAME move
 
-ACTION 3
-NAME pick_up
-EFFORT 15
+THING_ACTION 3
+TA_EFFORT 15
+TA_NAME pick_up
 
-ACTION 4
-NAME drop
-EFFORT 5
+THING_ACTION 4
+TA_EFFORT 5
+TA_NAME drop
 
-ACTION 5
-NAME use
-EFFORT 45
+THING_ACTION 5
+TA_EFFORT 45
+TA_NAME use
 
-THINGTYPE 0
-NAME HUMAN
-SYMBOL @
-LIFEPOINTS 5
-CORPSE_ID 5
-CONSUMABLE 0
-START_NUMBER 1
+THING_TYPE 0
+TT_START_NUMBER 1
+TT_LIFEPOINTS 5
+TT_SYMBOL @
+TT_NAME HUMAN
+TT_CONSUMABLE 0
 
-THINGTYPE 1
-NAME ANT
-SYMBOL a
-LIFEPOINTS 1
-CORPSE_ID 4
-CONSUMABLE 0
-START_NUMBER 27
+THING_TYPE 1
+TT_START_NUMBER 27
+TT_LIFEPOINTS 1
+TT_SYMBOL a
+TT_NAME ANT
+TT_CONSUMABLE 0
 
-THINGTYPE 2
-NAME ZOMBIE
-SYMBOL z
-LIFEPOINTS 3
-CORPSE_ID 5
-CONSUMABLE 0
-START_NUMBER 9
+THING_TYPE 2
+TT_START_NUMBER 9
+TT_LIFEPOINTS 3
+TT_SYMBOL z
+TT_NAME ZOMBIE
+TT_CONSUMABLE 0
 
-THINGTYPE 3
-NAME SHOGGOTH
-SYMBOL S
-LIFEPOINTS 9
-CORPSE_ID 6
-CONSUMABLE 0
-START_NUMBER 3
+THING_TYPE 3
+TT_START_NUMBER 3
+TT_LIFEPOINTS 9
+TT_SYMBOL S
+TT_NAME SHOGGOTH
+TT_CONSUMABLE 0
 
-THINGTYPE 4
-NAME DIRT
-SYMBOL #
-LIFEPOINTS 0
-CORPSE_ID 4
-CONSUMABLE 0
-START_NUMBER 9
+THING_TYPE 4
+TT_START_NUMBER 9
+TT_LIFEPOINTS 0
+TT_SYMBOL #
+TT_NAME DIRT
+TT_CONSUMABLE 0
 
-THINGTYPE 5
-NAME SKELETON
-SYMBOL %
-LIFEPOINTS 0
-CORPSE_ID 4
-CONSUMABLE 0
-START_NUMBER 9
+THING_TYPE 5
+TT_START_NUMBER 9
+TT_LIFEPOINTS 0
+TT_SYMBOL %
+TT_NAME SKELETON
+TT_CONSUMABLE 0
 
-THINGTYPE 6
-NAME 'MAGIC MEAT'
-SYMBOL m
-LIFEPOINTS 0
-CORPSE_ID 4
-CONSUMABLE 3
-START_NUMBER 1
+THING_TYPE 6
+TT_START_NUMBER 1
+TT_LIFEPOINTS 0
+TT_SYMBOL m
+TT_NAME 'MAGIC MEAT'
+TT_CONSUMABLE 3
+
+THING_TYPE 0
+TT_CORPSE_ID 5
+THING_TYPE 1
+TT_CORPSE_ID 4
+THING_TYPE 2
+TT_CORPSE_ID 5
+THING_TYPE 3
+TT_CORPSE_ID 6
+THING_TYPE 4
+TT_CORPSE_ID 4
+THING_TYPE 5
+TT_CORPSE_ID 4
+THING_TYPE 6
+TT_CORPSE_ID 4
diff --git a/src/client/command_db.c b/src/client/command_db.c
index b9d10a6..a7523b7 100644
--- a/src/client/command_db.c
+++ b/src/client/command_db.c
@@ -6,13 +6,12 @@
 #include <stdint.h> /* uint8_t */
 #include <stdlib.h> /* free() */
 #include <string.h> /* strcmp(), strdup() */
-#include "../common/parse_file.h" /* EDIT_STARTED,parse_init_entry(),
-                                   * parse_id_uniq(), parse_unknown_arg(),
-                                   * parsetest_too_many_values(), parse_file(),
-                                   * parse_and_reduce_to_readyflag(),
-                                   * parse_flagval()
-                                   */
 #include "array_append.h" /* array_append() */
+#include "parse.h" /* EDIT_STARTED, parse_init_entry(), parse_id_uniq(),
+                    * parse_unknown_arg(), parsetest_too_many_values(),
+                    * parse_file(), parse_and_reduce_to_readyflag(),
+                    * parse_flagval()
+                    */
 #include "world.h" /* global world */
 #include "cleanup.h" /* set_cleanup_flag() */
 
diff --git a/src/client/control.c b/src/client/control.c
index 04f0c94..17a7632 100644
--- a/src/client/control.c
+++ b/src/client/control.c
@@ -181,8 +181,8 @@ static char * build_server_message_with_argument(struct Command * cmd)
 {
     char * f_name = "build_server_message_with_argument()";
     uint8_t command_size = strlen(cmd->server_msg);
-    char * arg_str;
-    uint8_t arg_size;
+    char * arg_str = "";
+    uint8_t arg_size = 0;
     if ('i' == cmd->arg)
     {
         arg_size = 3;
diff --git a/src/client/interface_conf.c b/src/client/interface_conf.c
index 853fdaa..aba5e3b 100644
--- a/src/client/interface_conf.c
+++ b/src/client/interface_conf.c
@@ -9,13 +9,7 @@
 #include <stdio.h> /* FILE, sprintf() */
 #include <string.h> /* strchr(), strcmp(), strdup(), strlen() */
 #include <unistd.h> /* optarg, getopt() */
-#include "../common/parse_file.h" /* EDIT_STARTED, parse_file(),parse_flagval(),
-                                   * token_from_line(), parsetest_singlechar(),
-                                   * parse_and_reduce_to_readyflag(),
-                                   * parsetest_defcontext(),parse_unknown_arg(),
-                                   * parsetest_too_many_values(),
-                                   * parse_id_uniq(), parse_init_entry()
-                                   */
+#include "../common/parse_file.h" /* token_from_line(),parsetset_singlechar() */
 #include "../common/readwrite.h" /* atomic_write_start(), atomic_write_finish(),
                                   * detect_atomic_leftover(), try_fwrite()
                                   */
@@ -26,6 +20,11 @@
 #include "command_db.h" /* get_command() */
 #include "keybindings.h" /* KeyBinding, KeyBindingDB, get_command_to_keycode()*/
 #include "map.h" /* map_center() */
+#include "parse.h" /* EDIT_STARTED, parse_file(), parse_flagval(),
+                    * parse_and_reduce_to_readyflag(), parse_id_uniq()
+                    * parsetest_defcontext(), parse_unknown_arg(),
+                    * parsetest_too_many_values(), parse_init_entry()
+                    */
 #include "wincontrol.h" /* toggle_window() */
 #include "windows.h" /* Win, free_winDB(), make_v_screen_and_init_win_sizes() */
 #include "world.h" /* global world */
diff --git a/src/client/parse.c b/src/client/parse.c
new file mode 100644
index 0000000..2767c46
--- /dev/null
+++ b/src/client/parse.c
@@ -0,0 +1,120 @@
+/* src/client/parse.c */
+
+#define _POSIX_C_SOURCE 200809L /* strdup() */
+#include "parse.h"
+#include <stddef.h> /* size_t, NULL */
+#include <stdio.h> /* FILE, snprintf() */
+#include <stdint.h> /* uint8_t, uint32_t */
+#include <stdlib.h> /* free() */
+#include <string.h> /* strdup(), strlen() */
+#include <unistd.h> /* access(), F_OK */
+#include "../common/parse_file.h" /* set_err_line_options(), err_line_inc(),
+                                   * err_line_zero(), token_from_line()
+                                   */
+#include "../common/readwrite.h" /* try_fopen(),try_fclose(),textfile_width() */
+#include "../common/rexit.h" /* exit_err(), exit_trouble() */
+#include "../common/try_malloc.h" /* try_malloc() */
+
+
+
+extern void parse_file(char * path, void (* token_to_entry) (char *, char *))
+{
+    char * f_name = "read_new_config_file()";
+    char * prefix = "Failed reading config file: \"";
+    char * affix = "\". ";
+    size_t size = strlen(prefix) + strlen(path) + strlen(affix) + 1;
+    char * errline_intro = try_malloc(size, f_name);
+    int test = snprintf(errline_intro, size, "%s%s%s", prefix, path, affix);
+    exit_trouble(test < 0, f_name, "snprintf()");
+    exit_err(access(path, F_OK), errline_intro);
+    FILE * file = try_fopen(path, "r", f_name);
+    uint32_t linemax = textfile_width(file);
+    char * errline_line = try_malloc(linemax + 1, f_name);
+    set_err_line_options(errline_intro, errline_line, 1);
+    err_line_zero();
+    err_line(0 == linemax, "File is empty.");
+    char * token0 = NULL; /* For final token_to_entry() if while() stagnates. */
+    char * token1 = NULL;
+    char * err_val = "No value given.";
+    while (try_fgets(errline_line, linemax + 1, file, f_name))
+    {
+        err_line_inc();
+        // err_line(UINT32_MAX == err_line_count, "Line reaches max lines limit.");
+        char * line_copy = strdup(errline_line);
+        token0 = token_from_line(line_copy);
+        if (token0)
+        {
+            err_line(0 == (token1 = token_from_line(NULL)), err_val);
+            token_to_entry(token0, token1);
+            token0 = NULL;
+        }
+        free(line_copy);
+    }
+    token_to_entry(token0, token1);
+    try_fclose(file, f_name);
+    free(errline_line);
+    free(errline_intro);
+}
+
+
+
+extern void parsetest_defcontext(uint8_t flags)
+{
+    err_line(!(flags & EDIT_STARTED),"Outside appropriate definition context.");
+}
+
+
+
+extern void parsetest_too_many_values()
+{
+    err_line(NULL != token_from_line(NULL), "Too many values.");
+}
+
+
+
+extern void parse_id_uniq(int test)
+{
+    err_line(0 != test, "Declaration of ID already used.");
+}
+
+
+
+extern void parse_unknown_arg()
+{
+    err_line(1, "Unknown argument.");
+}
+
+
+
+extern char * parse_init_entry(uint8_t * flags, size_t size)
+{
+    char * f_name = "parse_init_entry()";
+    *flags = EDIT_STARTED;
+    char * p = try_malloc(size, f_name);
+    memset(p, 0, size);
+    return p;
+}
+
+
+
+extern uint8_t parse_flagval(char * token0, char * token1, char * comparand,
+                             uint8_t * flags, uint8_t set_flag, char type,
+                             char * element)
+{
+    if (parse_val(token0, token1, comparand, type, element))
+    {
+        parsetest_defcontext(*flags);
+        *flags = *flags | set_flag;
+        return 1;
+    }
+    return 0;
+}
+
+
+
+extern void parse_and_reduce_to_readyflag(uint8_t * flags, uint8_t ready_flag)
+{
+    char * err_fin = "Last definition block not finished yet.";
+    err_line((*flags & ready_flag) ^ ready_flag, err_fin);
+    *flags = ready_flag;
+}
diff --git a/src/client/parse.h b/src/client/parse.h
new file mode 100644
index 0000000..33a9687
--- /dev/null
+++ b/src/client/parse.h
@@ -0,0 +1,55 @@
+/* src/client/parse.h
+ *
+ * Routines for file parsing.
+ */
+
+#ifndef PARSE_H
+#define PARSE_H
+
+#include <stddef.h> /* size_t */
+#include <stdint.h> /* uint8_t */
+
+
+
+enum parse_flags
+{
+    EDIT_STARTED  = 0x01
+};
+
+
+
+/* Parse file at "path" by passing each line's first two tokens to
+ * "token_to_entry". Ignore empty lines. Non-empty lines must feature at least
+ * two tokens as delimited either be whitespace or single quotes (to allow for
+ * tokens featuring whitespaces). When EOF is reached, token_to_entry() is
+ * called a last time with a first token of NULL.
+ */
+extern void parse_file(char * path, void ( *token_to_entry) (char *, char *));
+
+/* Calls err_line() with fitting message if EDIT_STARTED not set in "flags". */
+extern void parsetest_defcontext(uint8_t flags);
+
+/* Ensure token_from_line() does not find any more tokens on the line. */
+extern void parsetest_too_many_values();
+
+/* Trigger err_line() with "Unknown argument" message. */
+extern void parse_unknown_arg();
+
+/* If "test"!=0 call err_line() with "Declaration of ID already used" message.*/
+extern void parse_id_uniq(int test);
+
+/* Set "flags"=EDIT_STARTED and return pointer to new zeroed array of "size". */
+extern char * parse_init_entry(uint8_t * flags, size_t size);
+
+/* Wrapper to parse_val() that sets "flags" to "flags"|"set_flag" on success. */
+extern uint8_t parse_flagval(char * token0, char * token1, char * comparand,
+                             uint8_t * flags, uint8_t set_flag, char type,
+                             char * element);
+
+/* Check "ready_flag" is set in "flags", re-set "flags" to "ready_flag" only. */
+extern void parse_and_reduce_to_readyflag(uint8_t * flags, uint8_t ready_flag);
+
+
+
+#endif
+
diff --git a/src/common/parse_file.c b/src/common/parse_file.c
index 8ce20ad..82ba4e3 100644
--- a/src/common/parse_file.c
+++ b/src/common/parse_file.c
@@ -7,8 +7,6 @@
 #include <stdint.h> /* int16_t,uint8_t,uint32_t, INT16_MIN, UINT{8,16,32}_MAX */
 #include <stdlib.h> /* atoi(), free() */
 #include <string.h> /* strchr, strcmp(), strdup(), strlen() */
-#include <unistd.h> /* access(), F_OK */
-#include "readwrite.h" /* try_fopen(), try_fclose(), textfile_width() */
 #include "rexit.h" /* exit_err(), exit_trouble() */
 #include "try_malloc.h" /* try_malloc() */
 
@@ -49,53 +47,26 @@ static void set_token_end(char ** start, char ** limit_char)
 
 
 
-extern void parse_file(char * path, void (* token_to_entry) (char *, char *))
+extern void set_err_line_options(char * intro, char * line, uint8_t exit)
 {
-    char * f_name = "read_new_config_file()";
-    char * prefix = "Failed reading config file: \"";
-    char * affix = "\". ";
-    size_t size = strlen(prefix) + strlen(path) + strlen(affix) + 1;
-    char * errline_intro = try_malloc(size, f_name);
-    int test = snprintf(errline_intro, size, "%s%s%s", prefix, path, affix);
-    exit_trouble(test < 0, f_name, "snprintf()");
-    exit_err(access(path, F_OK), errline_intro);
-    FILE * file = try_fopen(path, "r", f_name);
-    uint32_t linemax = textfile_width(file);
-    char * errline_line = try_malloc(linemax + 1, f_name);
-    set_err_line_options(errline_intro, errline_line, 0, 1);
-    err_line(0 == linemax, "File is empty.");
-    char * token0 = NULL; /* For final token_to_entry() if while() stagnates. */
-    char * token1 = NULL;
-    char * err_val = "No value given.";
-    while (try_fgets(errline_line, linemax + 1, file, f_name))
-    {
-        err_line_count++;
-        err_line(UINT32_MAX == err_line_count, "Line reaches max lines limit.");
-        char * line_copy = strdup(errline_line);
-        token0 = token_from_line(line_copy);
-        if (token0)
-        {
-            err_line(0 == (token1 = token_from_line(NULL)), err_val);
-            token_to_entry(token0, token1);
-            token0 = NULL;
-        }
-        free(line_copy);
-    }
-    token_to_entry(token0, token1);
-    try_fclose(file, f_name);
-    free(errline_line);
-    free(errline_intro);
+    err_line_line = line;
+    err_line_intro = intro;
+    err_line_exit = exit;
 }
 
 
 
-extern void set_err_line_options(char * intro, char * line, uint32_t count,
-                                 uint8_t exit)
+extern void err_line_inc()
 {
-    err_line_count = count;
-    err_line_line = line;
-    err_line_intro = intro;
-    err_line_exit = exit;
+    err_line_count++;
+    err_line(UINT32_MAX == err_line_count, "Line reaches max lines limit.");
+}
+
+
+
+extern void err_line_zero()
+{
+    err_line_count = 0;
 }
 
 
@@ -108,7 +79,7 @@ extern uint8_t err_line(uint8_t test, char * msg)
     }
     char * f_name = "err_line()";
     char * prefix = " Offending line ";
-    char * affix = ":\n";
+    char * affix = ": ";
     size_t size =   strlen(err_line_intro) + strlen(msg) + strlen(prefix)
                   + 10                 /* strlen for uint32_t representations */
                   + strlen(affix) + strlen(err_line_line) + 1;
@@ -208,13 +179,6 @@ extern uint8_t parsetest_int(char * string, char type)
 
 
 
-extern void parsetest_defcontext(uint8_t flags)
-{
-    err_line(!(flags & EDIT_STARTED),"Outside appropriate definition context.");
-}
-
-
-
 extern uint8_t parsetest_singlechar(char * string)
 {
     return err_line(1 !=strlen(string),"Value must be single ASCII character.");
@@ -222,38 +186,6 @@ extern uint8_t parsetest_singlechar(char * string)
 
 
 
-extern void parsetest_too_many_values()
-{
-    err_line(NULL != token_from_line(NULL), "Too many values.");
-}
-
-
-
-extern void parse_id_uniq(int test)
-{
-    err_line(0 != test, "Declaration of ID already used.");
-}
-
-
-
-extern void parse_unknown_arg()
-{
-    err_line(1, "Unknown argument.");
-}
-
-
-
-extern char * parse_init_entry(uint8_t * flags, size_t size)
-{
-    char * f_name = "parse_init_entry()";
-    *flags = EDIT_STARTED;
-    char * p = try_malloc(size, f_name);
-    memset(p, 0, size);
-    return p;
-}
-
-
-
 extern uint8_t parse_val(char * token0, char * token1, char * comparand,
                          char type, char * element)
 {
@@ -261,11 +193,15 @@ extern uint8_t parse_val(char * token0, char * token1, char * comparand,
     {
         if      ('s' == type)
         {
+            free(* (char **) element);
             * (char **) element = strdup(token1);
         }
-        else if ('c' == type && !parsetest_singlechar(token1))
+        else if ('c' == type)
         {
-            *element = (token1)[0];
+            if (!parsetest_singlechar(token1))
+            {
+                *element = (token1)[0];
+            }
         }
         else if (!parsetest_int(token1, type))
         {
@@ -290,27 +226,3 @@ extern uint8_t parse_val(char * token0, char * token1, char * comparand,
     }
     return 0;
 }
-
-
-
-extern uint8_t parse_flagval(char * token0, char * token1, char * comparand,
-                             uint8_t * flags, uint8_t set_flag, char type,
-                             char * element)
-{
-    if (parse_val(token0, token1, comparand, type, element))
-    {
-        parsetest_defcontext(*flags);
-        *flags = *flags | set_flag;
-        return 1;
-    }
-    return 0;
-}
-
-
-
-extern void parse_and_reduce_to_readyflag(uint8_t * flags, uint8_t ready_flag)
-{
-    char * err_fin = "Last definition block not finished yet.";
-    err_line((*flags & ready_flag) ^ ready_flag, err_fin);
-    *flags = ready_flag;
-}
diff --git a/src/common/parse_file.h b/src/common/parse_file.h
index 4192dac..7d7cfbd 100644
--- a/src/common/parse_file.h
+++ b/src/common/parse_file.h
@@ -1,36 +1,23 @@
 /* src/common/parse_file.h
  *
- * Tools for parsing config files.
+ * Tools for parsing files.
  */
 
 #ifndef PARSE_FILE_H
 #define PARSE_FILE_H
 
-#include <stddef.h> /* size_t */
 #include <stdint.h> /* uint8_t */
 
 
 
-enum parse_flags
-{
-    EDIT_STARTED  = 0x01
-};
-
-
-
-/* Parse file at "path" by passing each line's first two tokens to
- * "token_to_entry". Ignore empty lines. Non-empty lines must feature at least
- * two tokens as delimited either be whitespace or single quotes (to allow for
- * tokens featuring whitespaces). When EOF is reached, token_to_entry() is
- * called a last time with a first token of NULL.
- */
-extern void parse_file(char * path, void ( *token_to_entry) (char *, char *));
-
 /* Set err_line() options: "intro" message, char array used to store analyzed
- * lines ("line"), line start "count", whether to "exit" on error message.
+ * lines ("line"), and whether to "exit" on error message.
  */
-extern void set_err_line_options(char * intro, char * line, uint32_t count,
-                                 uint8_t exit);
+extern void set_err_line_options(char * intro, char * line, uint8_t exit);
+
+/* Increment and reset (to zero) err_line() line counter. */
+extern void err_line_inc();
+extern void err_line_zero();
 
 /* If "test", output "msg", faulty line, its number and exit if so defined by
  * set_err_line_options(), else return 1 on "test" and 0 if "test" is 0.
@@ -56,21 +43,6 @@ extern uint8_t parsetest_int(char * string, char type);
 /* Test for "string" to be of length 1 (excluding "\0"). Return 1 on failure. */
 extern uint8_t parsetest_singlechar(char * string);
 
-/* Calls err_line() with fitting message if EDIT_STARTED not set in "flags". */
-extern void parsetest_defcontext(uint8_t flags);
-
-/* Ensure token_from_line() does not find any more tokens on the line. */
-extern void parsetest_too_many_values();
-
-/* Trigger err_line() with "Unknown argument" message. */
-extern void parse_unknown_arg();
-
-/* If "test"!=0 call err_line() with "Declaration of ID already used" message.*/
-extern void parse_id_uniq(int test);
-
-/* Set "flags"=EDIT_STARTED and return pointer to new zeroed array of "size". */
-extern char * parse_init_entry(uint8_t * flags, size_t size);
-
 /* If "token0" fits "comparand", set "element" to value read from "token1" as
  * string (type: "s"), char ("c") uint8 ("8"), uint16 ("u"), uint32 ("U") or
  * int16 ("i"), and return 1; else 0.
@@ -78,14 +50,6 @@ extern char * parse_init_entry(uint8_t * flags, size_t size);
 extern uint8_t parse_val(char * token0, char * token1, char * comparand,
                          char type, char * element);
 
-/* Wrapper to parse_val() that sets "flags" to "flags"|"set_flag" on success. */
-extern uint8_t parse_flagval(char * token0, char * token1, char * comparand,
-                             uint8_t * flags, uint8_t set_flag, char type,
-                             char * element);
-
-/* Check "ready_flag" is set in "flags", re-set "flags" to "ready_flag" only. */
-extern void parse_and_reduce_to_readyflag(uint8_t * flags, uint8_t ready_flag);
-
 
 
 #endif
diff --git a/src/server/configfile.c b/src/server/configfile.c
deleted file mode 100644
index ca1b07f..0000000
--- a/src/server/configfile.c
+++ /dev/null
@@ -1,322 +0,0 @@
-/* src/server/configfile.c */
-
-#include <stddef.h> /* size_t, NULL */
-#include <stdio.h> /* snprintf() */
-#include <stdint.h> /* uint8_t */
-#include <stdlib.h> /* atoi(), free() */
-#include <string.h> /* strcmp() */
-#include "../common/parse_file.h" /* EDIT_STARTED, parsetest_int(),parse_file(),
-                                   * parsetest_too_many_values(),parse_id_uniq()
-                                   * parse_unknown_arg(), parse_init_entry(),
-                                   * parse_and_reduce_to_readyflag(),
-                                   * parse_flagval()
-                                   */
-#include "../common/rexit.h" /* exit_err(), exit_trouble() */
-#include "../common/try_malloc.h" /* try_malloc() */
-#include "cleanup.h" /* set_cleanup_flag(), CLEANUP_THING_TYPES,
-                      * CLEANUP_THING_ACTIONS
-                      */
-#include "hardcoded_strings.h" /* s */
-#include "thing_actions.h" /* ThingAction */
-#include "things.h" /* Thing, ThingType */
-#include "world.h" /* world global */
-
-
-
-/* Flags defining state of thing type and action entry reading ((un-)finished /
- * ready for starting the reading of a new definition etc.)
- */
-enum flag
-{
-    HEIGHT_SET     = 0x02,
-    WIDTH_SET      = 0x04,
-    NAME_SET       = 0x02,
-    EFFORT_SET     = 0x04,
-    CORPSE_ID_SET  = 0x04,
-    SYMBOL_SET     = 0x08,
-    LIFEPOINTS_SET = 0x10,
-    CONSUMABLE_SET = 0x20,
-    START_N_SET    = 0x40,
-    READY_ACTION   = NAME_SET | EFFORT_SET,
-    READY_THING    = NAME_SET | CORPSE_ID_SET | SYMBOL_SET | LIFEPOINTS_SET
-                     | CONSUMABLE_SET | START_N_SET
-};
-
-
-
-/* What ThingType and ThingAction structs have in common at their top. Use this
- * to allow same functions run over structs of both types.
- */
-struct EntryHead
-{
-    uint8_t id;
-    struct EntryHead * next;
-};
-
-
-
-/* Interpret "token0" and "token1" as data to write into the ThingAction /
- * ThingType DB.
- *
- * Individual ThingType / ThingAction DB entries are put together line by line
- * before being written. Writing only happens after all necessary members of an
- * entry have been assembled, and when additionally a) a new entry is started by
- * a "token0" of "ACTION" or "THINGTYPE"; or b) "token0" is NULL.
- *
- * Also check against the line parse_file() read tokens from having more tokens.
- */
-static void tokens_into_entries(char * token0, char * token1);
-
-/* Start reading a new DB entry of "size" from tokens if "token0" matches
- * "comparand". Set EDIT_STARTED in "flags" to mark beginning of new entry
- * reading. Check that "token1" id of new entry has not already been used in DB
- * starting at "entry_cmp".
- */
-static uint8_t start_entry(char * token0, char * token1, char * comparand,
-                         uint8_t * flags, size_t size,
-                         struct EntryHead ** entry,
-                         struct EntryHead * entry_cmp);
-
-/* Write DB entry pointed to by "entry" to its appropriate location. */
-static void write_if_entry(struct EntryHead ** entry,
-                           struct EntryHead *** entry_p_p_p);
-
-/* Ensure that all .corpse_id members in the ThingType DB fit .id members of
- * ThingType DB entries.
- */
-static void test_corpse_ids();
-
-/* If "token0" matches "comparand", set world.player_type to int in "token1". */
-static uint8_t set_player_type(char * token0, char * comparand, char * token1);
-
-/* If "token0" matches "comparand", set world.map.length to int in "token1". */
-static uint8_t set_map_length(char * token0, char * comparand, char * token1);
-
-/* Try to read tokens as members for the definition currently edited, which may
- * be "tt" or "ta". What member of which of the two is set depends on which of
- * the flags has EDIT_STARTED set and on the key name in "token0". Return 1 if
- * interpretation succeeds, else 0.
- *
- * Note that ThingAction entries' .name also determines their .func.
- */
-static uint8_t set_members(char * token0, char * token1,
-                           uint8_t * thing_flags, uint8_t * action_flags,
-                           struct ThingType * tt, struct ThingAction * ta);
-
-/* If "name" fits "ta"->name, set "ta"->func to "func". (Derives ThingAction
- * .func from .name for set_members().
- */
-static uint8_t try_func_name(struct ThingAction * ta,
-                             char * name, void (* func) (struct Thing *));
-
-
-
-static void tokens_into_entries(char * token0, char * token1)
-{
-    char * str_action = "ACTION";
-    char * str_thing = "THINGTYPE";
-    char * str_player = "PLAYER_TYPE";
-    char * str_map_length = "MAP_LENGTH";
-    static struct ThingAction ** ta_p_p = &world.thing_actions;
-    static struct ThingType ** tt_p_p = &world.thing_types;
-    static uint8_t action_flags = READY_ACTION;
-    static uint8_t thing_flags = READY_THING;
-    static struct EntryHead * ta = NULL;
-    static struct EntryHead * tt = NULL;
-    if (!token0 || !strcmp(token0, str_action) || !strcmp(token0, str_thing)
-                || !strcmp(token0, str_player))
-    {
-        parse_and_reduce_to_readyflag(&action_flags, READY_ACTION);
-        parse_and_reduce_to_readyflag(&thing_flags, READY_THING);
-        write_if_entry(&ta, (struct EntryHead ***) &ta_p_p);
-        write_if_entry(&tt, (struct EntryHead ***) &tt_p_p);
-    }
-    if (token0)
-    {
-        parsetest_too_many_values();
-        if (start_entry(token0, token1, str_action, &action_flags,
-                        sizeof(struct ThingAction), (struct EntryHead**) &ta,
-                        (struct EntryHead *) world.thing_actions))
-        {
-            err_line(0 == atoi(token1), "Value must not be 0.");
-        }
-        else if (!(   start_entry(token0, token1, str_thing, &thing_flags,
-                                  sizeof(struct ThingType),
-                                  (struct EntryHead**) &tt,
-                                  (struct EntryHead *) world.thing_types)
-                   || set_player_type(token0, str_player, token1)
-                   || set_map_length(token0, str_map_length, token1)
-                   || set_members(token0, token1, &thing_flags, &action_flags,
-                                  (struct ThingType *) tt,
-                                  (struct ThingAction *) ta)))
-        {
-            parse_unknown_arg();
-        }
-    }
-}
-
-
-
-static uint8_t start_entry(char * token0, char * token1, char * comparand,
-                           uint8_t * flags, size_t size,
-                           struct EntryHead ** entry,
-                           struct EntryHead * entry_cmp)
-{
-    if (strcmp(token0, comparand))
-    {
-        return 0;
-    }
-    *entry = (struct EntryHead *) parse_init_entry(flags, size);
-    parsetest_int(token1, '8');
-    (*entry)-> id = atoi(token1);
-    for (; NULL != entry_cmp; entry_cmp = entry_cmp->next)
-    {
-        parse_id_uniq((*entry)->id == entry_cmp->id);
-    }
-    return 1;
-}
-
-
-
-static void write_if_entry(struct EntryHead ** entry,
-                           struct EntryHead *** entry_p_p_p)
-{
-    if (*entry)
-    {
-        (*entry)->next = NULL;
-        **entry_p_p_p = *entry;
-        *entry_p_p_p = &((*entry)->next);
-        *entry = NULL;   /* So later runs of this don't re-append same entry. */
-    }
-}
-
-
-
-static void test_corpse_ids()
-{
-    char * f_name = "test_corpse_ids()";
-    char * prefix = "In the thing types DB, one thing corpse ID does not "
-                    "reference any known thing type in the DB. ID of "
-                    "responsible thing type: ";
-    size_t size = strlen(prefix) + 3 + 1; /* 3: uint8_t representation strlen */
-    char * err_corpse = try_malloc(size, f_name);
-    struct ThingType * test_entry_0 = world.thing_types;
-    for (; test_entry_0; test_entry_0 = test_entry_0->next)
-    {
-        uint8_t corpse_id_found = 0;
-        struct ThingType * test_entry_1 = world.thing_types;
-        for (; test_entry_1; test_entry_1 = test_entry_1->next)
-        {
-            if (test_entry_0->corpse_id == test_entry_1->id)
-            {
-                corpse_id_found = 1;
-            }
-        }
-        int test = snprintf(err_corpse, size, "%s%d", prefix, test_entry_0->id);
-        exit_trouble(test < 0, f_name, "snprintf()");
-        exit_err(!corpse_id_found, err_corpse);
-    }
-    free(err_corpse);
-}
-
-
-
-static uint8_t set_player_type(char * token0, char * comparand, char * token1)
-{
-    if (strcmp(token0, comparand))
-    {
-        return 0;
-    }
-    parsetest_int(token1, '8');
-    world.player_type = atoi(token1);
-    return 1;
-}
-
-
-
-static uint8_t set_map_length(char * token0, char * comparand, char * token1)
-{
-    if (strcmp(token0, comparand))
-    {
-        return 0;
-    }
-    parsetest_int(token1, 'i');
-    int test = atoi(token1) > 256 || atoi(token1) < 1;
-    err_line(test, "Value must be >= 1 and <= 256.");
-    world.map.length = atoi(token1);
-    return 1;
-}
-
-
-
-static uint8_t set_members(char * token0, char * token1, uint8_t * thing_flags,
-                           uint8_t * action_flags,
-                           struct ThingType * tt, struct ThingAction * ta)
-{
-    if (   *action_flags & EDIT_STARTED
-        && parse_flagval(token0, token1, "NAME", action_flags,
-                         NAME_SET, 's', (char *) &ta->name))
-    {
-        if (!(   try_func_name(ta, s[S_CMD_MOVE], actor_move)
-              || try_func_name(ta, s[S_CMD_PICKUP], actor_pick)
-              || try_func_name(ta, s[S_CMD_DROP], actor_drop)
-              || try_func_name(ta, s[S_CMD_USE], actor_use)))
-        {
-            ta->func = actor_wait;
-        }
-        *action_flags = *action_flags | NAME_SET;
-        return 1;
-    }
-    else if (   parse_flagval(token0, token1, "NAME", thing_flags,
-                              NAME_SET, 's', (char *) &tt->name)
-             || parse_flagval(token0, token1, "SYMBOL", thing_flags,
-                              SYMBOL_SET, 'c', (char *) &tt->char_on_map)
-             || parse_flagval(token0, token1, "EFFORT", action_flags,
-                              EFFORT_SET, '8', (char *) &ta->effort)
-             || parse_flagval(token0, token1, "START_NUMBER", thing_flags,
-                              START_N_SET, '8', (char *) &tt->start_n)
-             || parse_flagval(token0, token1, "LIFEPOINTS", thing_flags,
-                              LIFEPOINTS_SET, '8', (char *) &tt->lifepoints)
-             || parse_flagval(token0, token1, "CONSUMABLE", thing_flags,
-                              CONSUMABLE_SET, '8', (char *) &tt->consumable)
-             || parse_flagval(token0, token1, "CORPSE_ID", thing_flags,
-                              CORPSE_ID_SET, '8', (char *) &tt->corpse_id))
-    {
-        return 1;
-    }
-    return 0;
-}
-
-
-
-static uint8_t try_func_name(struct ThingAction * ta, char * name,
-                             void (* func) (struct Thing *))
-{
-    if (0 == strcmp(ta->name, name))
-    {
-        ta->func = func;
-        return 1;
-    }
-    return 0;
-}
-
-
-
-extern void read_config_file()
-{
-    parse_file(s[S_PATH_CONFIG], tokens_into_entries);
-    exit_err(!world.map.length, "Map size not defined in config file.");
-    uint8_t player_type_is_valid = 0;
-    struct ThingType * tt;
-    for (tt = world.thing_types; NULL != tt; tt = tt->next)
-    {
-        if (world.player_type == tt->id)
-        {
-            player_type_is_valid = 1;
-            break;
-        }
-    }
-    exit_err(!player_type_is_valid, "No valid thing type set for player.");
-    set_cleanup_flag(CLEANUP_THING_ACTIONS | CLEANUP_THING_TYPES);
-    test_corpse_ids();
-}
diff --git a/src/server/configfile.h b/src/server/configfile.h
deleted file mode 100644
index d80a2ba..0000000
--- a/src/server/configfile.h
+++ /dev/null
@@ -1,18 +0,0 @@
-/* src/server/configfile.h
- *
- * Reading in the config file of thing types and thing actions.
- */
-
-#ifndef CONFIGFILE_H
-#define CONFIGFILE_H
-
-
-
-/* Parse thing type / action definitons file nto thing type and thing action
- * definitions at world.thing_types and world.thing_actions.
- */
-extern void read_config_file();
-
-
-
-#endif
diff --git a/src/server/god_commands.c b/src/server/god_commands.c
new file mode 100644
index 0000000..efb607d
--- /dev/null
+++ b/src/server/god_commands.c
@@ -0,0 +1,426 @@
+/* src/server/god_commands.c */
+
+#include "god_commands.h"
+#include <stddef.h> /* NULL */
+#include <stdint.h> /* uint8_t */
+#include <stdlib.h> /* atoi(), free() */
+#include <string.h> /* strcmp() */
+#include <unistd.h> /* F_OK, access(), unlink() */
+#include "../common/parse_file.h" /* err_line(), parse_val(), parsetest_int() */
+#include "../common/rexit.h" /* exit_trouble() */
+#include "cleanup.h" /* unset_cleanup_flag() */
+#include "field_of_view.h" /* build_fov_map() */
+#include "hardcoded_strings.h" /* s */
+#include "init.h" /* remake_world() */
+#include "map.h" /* remake_map() */
+#include "thing_actions.h" /* ThingAction, actor_wait(), actor_move(),
+                            * actor_use(), actor_pickup(), actor_drop()
+                            */
+#include "things.h" /* Thing, ThingType, add_thing(), get_thing(), own_thing(),
+                     * free_things()
+                     */
+#include "world.h" /* world */
+
+
+
+/* Parse/apply god command in "tok0"/tok1" to manipulate a ThingType*/
+static uint8_t parse_thingtype_manipulation(char * tok0, char * tok1);
+
+/* If "name" fits "ta"->name, set "ta"->func to "func". (Derives ThingAction
+ * .func from .name for set_members().
+ */
+static uint8_t try_func_name(struct ThingAction * ta, char * name,
+                             void (* func) (struct Thing *));
+
+/* Parse/apply god command in "tok0"/"tok1" to manipulate a ThingAction. */
+static uint8_t parse_thingaction_manipulation(char * tok0, char * tok1);
+
+/* Parse/apply god command in "tok0"/"tok1" oo setting "t"'s thing type. */
+static uint8_t parse_thing_type(char * tok0, char * tok1, struct Thing * t);
+
+/* Parse/apply god command in "tok0"/"tok1" on setting up thing "t". */
+static uint8_t parse_thing_command(char * tok0, char * tok1, struct Thing * t);
+
+/* Parse/apply god command in "tok0"/"tok1" on positioning a thing "t". */
+static uint8_t parse_position(char* tok0, char * tok1, struct Thing * t);
+
+/* Parse/apply god command in "tok0"/"tok1" on "t" owning another thing. */
+static uint8_t parse_carry(char * tok0, char * tok1, struct Thing * t);
+
+/* Parse/apply god command in "tok0"/"tok1" to manipulate a Thing. */
+static uint8_t parse_thing_manipulation(char * tok0, char * tok1);
+
+/* Performs parse_world_active()'s world activation legality tests. */
+static uint8_t world_may_be_set_active();
+
+/* Parse/apply god command in "tok0"/"tok1" on toggling world.exists. Unset if
+ * argument is 0 and unlink worldstate file, but only set it on positive
+ * argument if it is not already set and a thing action of name S_CMD_WAIT, a
+ * player thing and a map are defined. On setting it, rebuild all FOVs.
+ */
+static uint8_t parse_world_active(char * tok0, char * tok1);
+
+/* Parse/apply god command in "tok0"/"tok1" to reset world.map.length. On
+ * re-set, set world.exists to 0, remove all things and free world.map.cells
+ */
+static uint8_t set_map_length(char * tok0, char * tok1);
+
+
+
+static uint8_t parse_thingtype_manipulation(char * tok0, char * tok1)
+{
+    static struct ThingType * tt = NULL;
+    if (!tt &&
+        (   !strcmp(tok0, s[S_CMD_TT_CONSUM]) || !strcmp(tok0, s[S_CMD_TT_SYMB])
+         || !strcmp(tok0, s[S_CMD_TT_STARTN]) || !strcmp(tok0, s[S_CMD_TT_NAME])
+         || !strcmp(tok0, s[S_CMD_TT_CORPS]) || !strcmp(tok0, s[S_CMD_TT_HP])))
+    {
+        err_line(1, "No thing type defined to manipulate yet.");
+        return 1;
+    }
+    uint8_t id;
+    if (   parse_val(tok0,tok1,s[S_CMD_TT_CONSUM],'8',(char *) &tt->consumable)
+        || parse_val(tok0,tok1,s[S_CMD_TT_HP],'8',(char *) &tt->lifepoints)
+        || parse_val(tok0,tok1,s[S_CMD_TT_STARTN],'8',(char *) &tt->start_n)
+        || parse_val(tok0,tok1,s[S_CMD_TT_SYMB],'c',(char *) &tt->char_on_map)
+        || parse_val(tok0,tok1,s[S_CMD_TT_NAME],'s',(char *) &tt->name));
+    else if (parse_val(tok0, tok1, s[S_CMD_TT_CORPS],'8',(char *)&id))
+    {
+        if (!get_thing_type(id))
+        {
+            err_line(1, "Corpse ID belongs to no known thing type.");
+            return 1;
+        }
+        tt->corpse_id = id;
+    }
+    else if (parse_val(tok0, tok1, s[S_CMD_THINGTYPE], '8', (char *) &id))
+    {
+        tt = get_thing_type(id);
+        if (!tt)
+        {
+            tt = add_thing_type(id);
+        }
+    }
+    else
+    {
+        return 0;
+    }
+    return 1;
+}
+
+
+
+static uint8_t try_func_name(struct ThingAction * ta, char * name,
+                             void (* func) (struct Thing *))
+{
+    if (0 == strcmp(ta->name, name))
+    {
+        ta->func = func;
+        return 1;
+    }
+    return 0;
+}
+
+
+
+static uint8_t parse_thingaction_manipulation(char * tok0, char * tok1)
+{
+    static struct ThingAction * ta = NULL;
+    if (!ta &&
+        (!strcmp(tok0, s[S_CMD_TA_EFFORT]) || !strcmp(tok0, s[S_CMD_TA_NAME])))
+    {
+        err_line(1, "No thing action defined to manipulate yet.");
+        return 1;
+    }
+    uint8_t id;
+    if      (parse_val(tok0, tok1, s[S_CMD_TA_EFFORT],'8',(char *) &ta->effort));
+    else if (parse_val(tok0, tok1, s[S_CMD_TA_NAME], 's', (char *) &ta->name))
+    {
+        if (!(   try_func_name(ta, s[S_CMD_MOVE], actor_move)
+              || try_func_name(ta, s[S_CMD_PICKUP], actor_pick)
+              || try_func_name(ta, s[S_CMD_WAIT], actor_wait)
+              || try_func_name(ta, s[S_CMD_DROP], actor_drop)
+              || try_func_name(ta, s[S_CMD_USE], actor_use)))
+        {
+            err_line(1, "Invalid action function name.");
+            return 1;
+        }         /* Legal worlds have at least one thing action for waiting. */
+        if (world.exists)
+        {
+            world.exists = 0 != get_thing_action_id_by_name(s[S_CMD_WAIT]);
+        }
+    }
+    else if (parse_val(tok0, tok1, s[S_CMD_THINGACTION], '8', (char *) &id))
+    {
+        ta = get_thing_action(id);
+        if (!ta)
+        {
+            ta = add_thing_action(id);
+        }
+    }
+    else
+    {
+        return 0;
+    }
+    return 1;
+}
+
+
+
+static uint8_t parse_thing_type(char * tok0, char * tok1, struct Thing * t)
+{
+    uint8_t type;
+    if (parse_val(tok0, tok1, s[S_CMD_T_TYPE], '8', (char *) &type))
+    {
+        struct ThingType * tt = get_thing_type(type);
+        if (!err_line(!tt, "Thing type does not exist."))
+        {
+            t->type = type;
+        }
+        return 1;
+    }
+    return 0;
+}
+
+
+
+static uint8_t parse_thing_command(char * tok0, char * tok1, struct Thing * t)
+{
+    uint8_t command;
+    if (parse_val(tok0, tok1, s[S_CMD_T_COMMAND], '8', (char *) &command))
+    {
+        if (!command)
+        {
+            t->command = command;
+            return 1;
+        }
+        struct ThingAction * ta = world.thing_actions;
+        for (; ta && command != ta->id; ta = ta->next);
+        if (!err_line(!ta, "Thing action does not exist."))
+        {
+            t->command = command;
+        }
+        return 1;
+    }
+    return 0;
+}
+
+
+
+static uint8_t parse_position(char* tok0, char * tok1, struct Thing * t)
+{
+    char axis = 0;
+    if      (!strcmp(tok0, s[S_CMD_T_POSY]))
+    {
+        axis = 'y';
+    }
+    else if (!strcmp(tok0, s[S_CMD_T_POSX]))
+    {
+        axis = 'x';
+    }
+    if (axis && !parsetest_int(tok1, '8'))
+    {
+        uint8_t length = atoi(tok1);
+        char * err = "Position is outside of map.";
+        if (!err_line(length >= world.map.length, err))
+        {
+            if      ('y' == axis)
+            {
+                t->pos.y = length;
+            }
+            else if ('x' == axis)
+            {
+                t->pos.x = length;
+            }
+            free(t->fov_map);
+            if (world.exists && t->lifepoints)
+            {
+                t->fov_map = build_fov_map(t);
+            }
+        }
+        return 1;
+    }
+    return 0;
+}
+
+
+
+static uint8_t parse_carry(char * tok0, char * tok1, struct Thing * t)
+{
+    uint8_t id;
+    if (parse_val(tok0, tok1, s[S_CMD_T_CARRIES], '8', (char *) &id))
+    {
+        if (!err_line(id == t->id, "Thing cannot carry itself."))
+        {
+            struct Thing * o = get_thing(world.things, id, 0);
+            if (!err_line(!o, "Thing not available for carrying."))
+            {
+                own_thing(&(t->owns), &world.things, id);
+                o->pos = t->pos;
+            }
+        }
+        return 1;
+    }
+    return 0;
+}
+
+
+
+static uint8_t parse_thing_manipulation(char * tok0, char * tok1)
+{
+    static struct Thing * t = NULL;
+    if (!t &&
+        (   !strcmp(tok0, s[S_CMD_T_PROGRESS]) || !strcmp(tok0, s[S_CMD_T_TYPE])
+         || !strcmp(tok0, s[S_CMD_T_CARRIES]) || !strcmp(tok0, s[S_CMD_T_POSY])
+         || !strcmp(tok0, s[S_CMD_T_POSY]) || !strcmp(tok0, s[S_CMD_T_ARGUMENT])
+         || !strcmp(tok0, s[S_CMD_T_HP]) || !strcmp(tok0, s[S_CMD_T_COMMAND])))
+    {
+        err_line(1, "No thing defined to manipulate yet.");
+        return 1;
+    }
+    uint8_t id;
+    if (    parse_thing_type(tok0, tok1, t)
+        || parse_thing_command(tok0, tok1, t)
+        || parse_val(tok0,tok1, s[S_CMD_T_ARGUMENT], '8', (char *)&t->arg)
+        || parse_val(tok0,tok1, s[S_CMD_T_PROGRESS], '8', (char *)&t->progress)
+        || parse_val(tok0,tok1, s[S_CMD_T_HP], '8', (char *) &t->lifepoints)
+        || parse_position(tok0, tok1, t)
+        || parse_carry(tok0, tok1, t));
+    else if (parse_val(tok0, tok1, s[S_CMD_THING], 'i', (char *) &id))
+    {
+        t = get_thing(world.things, id, 1);
+        char * err = "No thing type found to initialize new thing.";
+        if (!t && !err_line(NULL == world.thing_types, err))
+        {
+            t = add_thing(id, world.thing_types->id, 0, 0);
+            if (world.exists && t->lifepoints)
+            {
+                t->fov_map = build_fov_map(t);
+            }
+        }
+    }
+    else
+    {
+        return 0;
+    }
+    return 1;
+}
+
+
+
+static uint8_t world_may_be_set_active()
+{
+    if (!get_thing_action_id_by_name(s[S_CMD_WAIT]))
+    {
+        err_line(1, "No thing action of name 'wait' found.");
+        return 0;
+    }
+    if (!get_player())
+    {
+        err_line(1, "No un-owned player thing (of id=0) found.");
+        return 0;
+    }
+    if (!world.map.cells)
+    {
+        err_line(1, "No map found.");
+        return 0;
+    }
+    return 1;
+}
+
+
+
+static uint8_t parse_world_active(char * tok0, char * tok1)
+{
+    char * f_name = "parse_world_active()";
+    if (!strcmp(tok0, s[S_CMD_WORLD_ACTIVE]) && !parsetest_int(tok1, '8'))
+    {
+        if (!parsetest_int(tok1, '8'))
+        {
+            uint8_t argument = atoi(tok1);
+            if (!argument)
+            {
+                if (!access(s[S_PATH_WORLDSTATE], F_OK))
+                {
+                    int test = unlink(s[S_PATH_WORLDSTATE]);
+                    exit_trouble(-1 == test, f_name, "unlink()");
+                }
+                world.exists = 0;
+            }
+            else if (world.exists)
+            {
+                err_line(1, "World already active.");
+            }
+            else if (world_may_be_set_active())
+            {
+                struct Thing * ti;
+                for (ti = world.things; ti; ti = ti->next)
+                {
+                    if (ti->lifepoints)
+                    {
+                        if (ti->fov_map)
+                        {
+                            free(ti->fov_map);
+                        }
+                        ti->fov_map = build_fov_map(ti);
+                    }
+                }
+                world.exists = 1;
+            }
+            return 1;
+        }
+    }
+    return 0;
+}
+
+
+
+static uint8_t set_map_length(char * tok0, char * tok1)
+{
+    if (!strcmp(tok0, s[S_CMD_MAPLENGTH]) && !parsetest_int(tok1, 'u'))
+    {
+        uint16_t argument = atoi(tok1);
+        if (argument < 1 || argument > 256)
+        {
+            err_line(1, "Value must be >= 1 and <= 256.");
+            return 1;
+        }
+        world.exists = 0;
+        free_things(world.things);
+        free(world.map.cells);
+        world.map.cells = NULL;    /* Since remake_map() runs free() on this. */
+        world.map.length = argument;
+        return 1;
+    }
+    return 0;
+}
+
+
+
+extern uint8_t parse_god_command_1arg(char * tok0, char * tok1)
+{
+    if (   parse_thingtype_manipulation(tok0, tok1)
+        || parse_thingaction_manipulation(tok0, tok1)
+        || parse_thing_manipulation(tok0, tok1)
+        || set_map_length(tok0,tok1)
+        || parse_val(tok0,tok1,s[S_CMD_SEED_RAND],'U', (char *)&world.seed)
+        || parse_val(tok0,tok1,s[S_CMD_TURN],'u',(char *)&world.turn)
+        || parse_val(tok0,tok1,s[S_CMD_PLAYTYPE],'8',(char *)&world.player_type)
+        || parse_world_active(tok0, tok1));
+    else if (parse_val(tok0,tok1,s[S_CMD_SEED_MAP],'U',(char *)&world.seed_map))
+
+    {
+        remake_map();
+    }
+    else if (parse_val(tok0, tok1, s[S_CMD_MAKE_WORLD],'U',(char *)&world.seed))
+    {
+        uint8_t test = remake_world();
+        err_line(1 == test, "No player type with start number of >0 defined.");
+        err_line(2 == test, "No thing action with name 'wait' defined.");
+    }
+    else
+    {
+        return 0;
+    }
+    return 1;
+}
diff --git a/src/server/god_commands.h b/src/server/god_commands.h
new file mode 100644
index 0000000..87af27e
--- /dev/null
+++ b/src/server/god_commands.h
@@ -0,0 +1,19 @@
+/* src/server/god_commands.h
+ *
+ * God commands and their interpretation by the server.
+ */
+
+
+
+#ifndef GOD_COMMANDS_H
+#define GOD_COMMANDS_H
+
+#include <stdint.h> /* uint8_t */
+
+
+/* Parse/apply god command "tok0" with argument "tok1". */
+extern uint8_t parse_god_command_1arg(char * tok1, char * tok2);
+
+
+
+#endif
diff --git a/src/server/hardcoded_strings.c b/src/server/hardcoded_strings.c
index e26264a..4094478 100644
--- a/src/server/hardcoded_strings.c
+++ b/src/server/hardcoded_strings.c
@@ -4,7 +4,7 @@
 
 
 
-char * s[26];
+char * s[38];
 
 
 
@@ -17,23 +17,35 @@ extern void init_strings()
     s[S_PATH_RECORD] = "record";
     s[S_PATH_SAVE] = "savefile";
     s[S_CMD_MAKE_WORLD] = "MAKE_WORLD";
-    s[S_CMD_DO_FOV] = "BUILD_FOVS";
+    s[S_CMD_WORLD_ACTIVE] = "WORLD_ACTIVE";
     s[S_CMD_SEED_MAP] = "SEED_MAP";
     s[S_CMD_SEED_RAND] = "SEED_RANDOMNESS";
     s[S_CMD_TURN] = "TURN";
     s[S_CMD_THING] = "THING";
-    s[S_CMD_TYPE] = "TYPE";
-    s[S_CMD_POS_Y] = "POS_Y";
-    s[S_CMD_POS_X] = "POS_X";
-    s[S_CMD_COMMAND] =  "COMMAND";
-    s[S_CMD_ARGUMENT] = "ARGUMENT";
-    s[S_CMD_PROGRESS] = "PROGRESS";
-    s[S_CMD_LIFEPOINTS] = "LIFEPOINTS";
-    s[S_CMD_CARRIES] = "CARRIES";
+    s[S_CMD_T_TYPE] = "T_TYPE";
+    s[S_CMD_T_POSY] = "T_POSY";
+    s[S_CMD_T_POSX] = "T_POSX";
+    s[S_CMD_T_COMMAND] =  "T_COMMAND";
+    s[S_CMD_T_ARGUMENT] = "T_ARGUMENT";
+    s[S_CMD_T_PROGRESS] = "T_PROGRESS";
+    s[S_CMD_T_HP] = "T_LIFEPOINTS";
+    s[S_CMD_T_CARRIES] = "T_CARRIES";
     s[S_CMD_WAIT] = "wait";
     s[S_CMD_MOVE] = "move";
     s[S_CMD_PICKUP] = "pick_up";
     s[S_CMD_DROP] = "drop";
     s[S_CMD_USE] = "use";
     s[S_FCN_SPRINTF] = "sprintf()";
+    s[S_CMD_THINGTYPE] = "THING_TYPE";
+    s[S_CMD_TT_CONSUM] = "TT_CONSUMABLE";
+    s[S_CMD_TT_STARTN] = "TT_START_NUMBER";
+    s[S_CMD_TT_HP] = "TT_LIFEPOINTS";
+    s[S_CMD_TT_SYMB] = "TT_SYMBOL";
+    s[S_CMD_TT_NAME] = "TT_NAME";
+    s[S_CMD_TT_CORPS] = "TT_CORPSE_ID";
+    s[S_CMD_THINGACTION] = "THING_ACTION";
+    s[S_CMD_TA_EFFORT] = "TA_EFFORT";
+    s[S_CMD_TA_NAME] = "TA_NAME";
+    s[S_CMD_MAPLENGTH] = "MAP_LENGTH";
+    s[S_CMD_PLAYTYPE] = "PLAYER_TYPE";
 }
diff --git a/src/server/hardcoded_strings.h b/src/server/hardcoded_strings.h
index db4be5a..fd9ceb8 100644
--- a/src/server/hardcoded_strings.h
+++ b/src/server/hardcoded_strings.h
@@ -17,30 +17,42 @@ enum string_num
     S_PATH_RECORD,
     S_PATH_SAVE,
     S_CMD_MAKE_WORLD,
-    S_CMD_DO_FOV,
+    S_CMD_WORLD_ACTIVE,
     S_CMD_SEED_MAP,
     S_CMD_SEED_RAND,
     S_CMD_TURN,
     S_CMD_THING,
-    S_CMD_TYPE,
-    S_CMD_POS_Y,
-    S_CMD_POS_X,
-    S_CMD_COMMAND,
-    S_CMD_ARGUMENT,
-    S_CMD_PROGRESS,
-    S_CMD_LIFEPOINTS,
-    S_CMD_CARRIES,
+    S_CMD_T_TYPE,
+    S_CMD_T_POSY,
+    S_CMD_T_POSX,
+    S_CMD_T_COMMAND,
+    S_CMD_T_ARGUMENT,
+    S_CMD_T_PROGRESS,
+    S_CMD_T_HP,
+    S_CMD_T_CARRIES,
     S_CMD_WAIT,
     S_CMD_MOVE,
     S_CMD_PICKUP,
     S_CMD_DROP,
     S_CMD_USE,
-    S_FCN_SPRINTF
+    S_FCN_SPRINTF,
+    S_CMD_THINGTYPE,
+    S_CMD_TT_CONSUM,
+    S_CMD_TT_STARTN,
+    S_CMD_TT_HP,
+    S_CMD_TT_SYMB,
+    S_CMD_TT_NAME,
+    S_CMD_TT_CORPS,
+    S_CMD_THINGACTION,
+    S_CMD_TA_EFFORT,
+    S_CMD_TA_NAME,
+    S_CMD_MAPLENGTH,
+    S_CMD_PLAYTYPE
 };
 
 extern void init_strings();
 
-extern char * s[26];
+extern char * s[38];
 
 
 
diff --git a/src/server/init.c b/src/server/init.c
index dd6ee15..16ab4df 100644
--- a/src/server/init.c
+++ b/src/server/init.c
@@ -11,7 +11,8 @@
 #include <sys/stat.h> /* mkdir() */
 #include <sys/types.h> /* defines pid_t, time_t */
 #include <time.h> /* time() */
-#include <unistd.h> /* optarg, getopt(), access(), unlink(), getpid() */
+#include <unistd.h> /* optarg, getopt(), access(), getpid() */
+#include "../common/parse_file.h" /* err_line_zero(), err_line_inc() */
 #include "../common/readwrite.h" /* try_fopen(), try_fclose(), textfile_width(),
                                   * try_fgets(), try_fwrite(),
                                   * detect_atomic_leftover()
@@ -23,7 +24,7 @@
 #include "hardcoded_strings.h" /* s */
 #include "map.h" /* remake_map() */
 #include "things.h" /* Thing, ThingType, free_things(), add_things(),
-                     * get_player()
+                     * get_thing_id_action_id_by_name()
                      */
 #include "run.h" /* obey_msg(), io_loop() */
 #include "world.h" /* global world */
@@ -31,11 +32,50 @@
 
 
 
+/* Pass to obey_msg() lines from file at "path", on "record" write to same. Do
+ * not pass lines that consist only of a newline character. Transform newline
+ * in the line passed to \0.
+ */
+static void obey_lines_from_file(char * path, uint8_t record);
+
 /* Replay game from record file up to the turn named in world.replay, then turn
  * over to manual replay via io_loop().
  */
 static void replay_game();
 
+/* Return 1 if the type defined by world.player_type has a .start_n of 0.
+ * Return 2 if no thing action with .name of s[S_CMD_WAIT] is defined.
+ * Else, return 0.
+ */
+static uint8_t world_cannot_be_made();
+
+
+static void obey_lines_from_file(char * path, uint8_t record)
+{
+    char * f_name = "obey_lines_from_file()";
+    FILE * file = try_fopen(path, "r", f_name);
+    uint32_t linemax = textfile_width(file);
+    char * line = try_malloc(linemax + 1, f_name);
+    while (NULL != try_fgets(line, linemax + 1, file, f_name))
+    {
+        if (strlen(line))
+        {
+            if (strcmp("\n", line))
+            {
+                char * nl = strchr(line, '\n');
+                if (nl)
+                {
+                    *nl = '\0';
+                }
+                obey_msg(line, record, 1);
+            }
+            err_line_inc();
+        }
+    }
+    free(line);
+    try_fclose(file, f_name);
+}
+
 
 
 static void replay_game()
@@ -48,7 +88,8 @@ static void replay_game()
     while (   world.turn < world.replay
            && NULL != try_fgets(line, linemax + 1, file, f_name))
     {
-        obey_msg(line, 0);
+        obey_msg(line, 0, 1);
+        err_line_inc();
     }
     uint8_t end = 0;
     while (!io_loop())
@@ -58,7 +99,8 @@ static void replay_game()
             end = (NULL == try_fgets(line, linemax + 1, file, f_name));
             if (!end)
             {
-                obey_msg(line, 0);
+                obey_msg(line, 0, 1);
+                err_line_inc();
             }
         }
     }
@@ -68,6 +110,31 @@ static void replay_game()
 
 
 
+static uint8_t world_cannot_be_made()
+{
+    uint8_t player_will_be_generated = 0;
+    struct ThingType * tt;
+    for (tt = world.thing_types; NULL != tt; tt = tt->next)
+    {
+        if (world.player_type == tt->id)
+        {
+            player_will_be_generated = 0 < tt->start_n;
+            break;
+        }
+    }
+    if (!player_will_be_generated)
+    {
+        return 1;
+    }
+    if (!get_thing_action_id_by_name(s[S_CMD_WAIT]))
+    {
+        return 2;
+    }
+    return 0;
+}
+
+
+
 extern void obey_argv(int argc, char * argv[])
 {
     int opt;
@@ -120,14 +187,17 @@ extern void setup_server_io()
 
 
 
-extern void remake_world()
+extern uint8_t remake_world()
 {
-    char * f_name = "remake_world()";
+    uint8_t test = world_cannot_be_made();
+    if (test)
+    {
+        return test;
+    }
     free(world.log);
     world.log = NULL;      /* thing_actions.c's update_log() checks for this. */
     world.seed_map = world.seed;
     free_things(world.things);
-    world.do_update = 1;
     remake_map();
     struct ThingType * tt;
     for (tt = world.thing_types; NULL != tt; tt = tt->next)
@@ -145,17 +215,15 @@ extern void remake_world()
             add_things(tt->id, tt->start_n);
         }
     }
-    set_cleanup_flag(CLEANUP_THINGS);
     struct Thing * t;
     for (t = world.things; NULL != t; t = t->next)
     {
         t->fov_map = t->lifepoints ? build_fov_map(t) : NULL;
     }
-    if (!world.replay && !access(s[S_PATH_RECORD], F_OK))
-    {
-        exit_trouble(unlink(s[S_PATH_RECORD]), f_name, "unlink()");
-    }
     world.turn = 1;
+    world.do_update = 1;
+    world.exists = 1;
+    return 0;
 }
 
 
@@ -165,35 +233,29 @@ extern void run_game()
     char * f_name = "run_game()";
     detect_atomic_leftover(s[S_PATH_SAVE]);
     detect_atomic_leftover(s[S_PATH_RECORD]);
+    err_line_zero();
     if (world.replay)
     {
         replay_game();
         return;
     }
-    char * path_savefile = s[S_PATH_SAVE];
-    if (!access(path_savefile, F_OK))
+    if (!access(s[S_PATH_SAVE], F_OK))
     {
-        FILE * file = try_fopen(path_savefile, "r", f_name);
-        uint32_t linemax = textfile_width(file);
-        char * line = try_malloc(linemax + 1, f_name);
-        while (NULL != try_fgets(line, linemax + 1, file, f_name))
-        {
-            if (strlen(line) && strcmp("\n", line))
-            {
-                obey_msg(line, 0);
-            }
-        }
-        free(line);
-        try_fclose(file, f_name);
+        obey_lines_from_file(s[S_PATH_SAVE], 0);
     }
     else
     {
+        char * err = "No world config file from which to start a new world.";
+        exit_err(access(s[S_PATH_CONFIG], F_OK), err);
+        obey_lines_from_file(s[S_PATH_CONFIG], 1);
+        err_line_zero();
         char * command = s[S_CMD_MAKE_WORLD];
         char * msg = try_malloc(strlen(command) + 1 + 11 + 1, f_name);
         int test = sprintf(msg, "%s %d", command, (int) time(NULL));
         exit_trouble(test < 0, f_name, s[S_FCN_SPRINTF]);
-        obey_msg(msg, 1);
+        obey_msg(msg, 1, 1);
         free(msg);
     }
+    err_line_zero();
     io_loop();
 }
diff --git a/src/server/init.h b/src/server/init.h
index cadacf3..e18b3bd 100644
--- a/src/server/init.h
+++ b/src/server/init.h
@@ -6,7 +6,7 @@
 #ifndef INIT_H
 #define INIT_H
 
-#include <stdint.h> /* uint32_t */
+#include <stdint.h> /* uint8_t */
 
 
 
@@ -17,22 +17,23 @@ extern void obey_argv(int argc, char * argv[]);
 extern void setup_server_io();
 
 /* Dissolves old game world if it exists, generates a new one from world.seed.
- * Unlinks any pre-existing record file.
- *
- * Thing (action) definitions read in from server config directory are not
- * affected. The map is populated accordingly. world.turn is set to 1, as is
- * world.do_update, so that io_round() is told to update the worldstate file.
+ * The map is populated according to world.thing_types start numbers. world.turn
+ * is set to 1, as is .exists and .do_update, so that io_round() is told to
+ * update the worldstate file. Returns 0 on success, and if the world cannot be
+ * generated 1 since there is no player type or it has .n_start of 0, 2 if no
+ * "wait" thing action is defined.
  */
-extern void remake_world();
+extern uint8_t remake_world();
 
 /* Create a game world state, then enter play or replay mode.
  *
  * If replay mode is called for, try for the record file and follow its commands
  + up to the turn specified by the user, then enter manual replay. Otherwise,
  * start into play mode after having either recreated a game world state from
- * the savefile, or, if none exists, having created a new world with the
- * MAKE_WORLD command. Manual replay as well as play mode take place inside
- * io_loop().
+ * the savefile, or, if none exists, having created a new world with first
+ * following the commands from the world config file, then running the
+ * MAKE_WORLD command. Manual replay as well as manual play mode take place
+ * inside io_loop().
  */
 extern void run_game();
 
diff --git a/src/server/io.c b/src/server/io.c
index 00afb3c..317c088 100644
--- a/src/server/io.c
+++ b/src/server/io.c
@@ -6,9 +6,9 @@
 #include <limits.h> /* PIPE_BUF */
 #include <stddef.h> /* size_t, NULL */
 #include <stdint.h> /* uint8_t, uint16_t, uint32_t */
-#include <stdio.h> /* defines EOF, FILE, sprintf() */
+#include <stdio.h> /* defines EOF, FILE, sprintf(), fprintf() */
 #include <stdlib.h> /* free() */
-#include <string.h> /* strlen(), memcpy(), memset() */
+#include <string.h> /* strlen(), memcpy(), memset(), strchr() */
 #include <sys/types.h> /* time_t */
 #include <time.h> /* time(), nanosleep() */
 #include "../common/readwrite.h" /* atomic_write_start(), atomic_write_finish(),
@@ -20,13 +20,16 @@
 #include "field_of_view.h" /* VISIBLE */
 #include "hardcoded_strings.h" /* s */
 #include "map.h" /* yx_to_map_pos() */
-#include "things.h" /* Thing, ThingType, get_thing_type(), get_player() */
+#include "things.h" /* Thing, ThingType, ThingAction, get_thing_type(),
+                     * get_player()
+                     */
 #include "world.h" /* global world  */
 
 
 
 /* Write to "file" god commands (one per line) to recreate thing "t". */
 static void write_key_value(FILE * file, char * key, uint32_t value);
+static void write_key_string(FILE * file, char * key, char * string);
 
 /* Write to "file" \n-delimited line of "key" + space + "value" as string. */
 static void write_thing(FILE * file, struct Thing * t);
@@ -80,6 +83,26 @@ static void write_key_value(FILE * file, char * key, uint32_t value)
 
 
 
+static void write_key_string(FILE * file, char * key, char * string)
+{
+    char * f_name = "write_key_string()";
+    try_fwrite(key, strlen(key), 1, file, f_name);
+    try_fputc(' ', file, f_name);
+    uint8_t contains_space = NULL != strchr(string, ' ');
+    if (contains_space)
+    {
+        try_fputc('\'', file, f_name);
+    }
+    try_fwrite(string, strlen(string), 1, file, f_name);
+    if (contains_space)
+    {
+        try_fputc('\'', file, f_name);
+    }
+    try_fputc('\n', file, f_name);
+}
+
+
+
 static void write_thing(FILE * file, struct Thing * t)
 {
     char * f_name = "write_thing()";
@@ -89,16 +112,16 @@ static void write_thing(FILE * file, struct Thing * t)
         write_thing(file, o);
     }
     write_key_value(file, s[S_CMD_THING], t->id);
-    write_key_value(file, s[S_CMD_TYPE], t->type);
-    write_key_value(file, s[S_CMD_POS_Y], t->pos.y);
-    write_key_value(file, s[S_CMD_POS_X], t->pos.x);
-    write_key_value(file, s[S_CMD_COMMAND], t->command);
-    write_key_value(file, s[S_CMD_ARGUMENT], t->arg);
-    write_key_value(file, s[S_CMD_PROGRESS], t->progress);
-    write_key_value(file, s[S_CMD_LIFEPOINTS], t->lifepoints);
+    write_key_value(file, s[S_CMD_T_TYPE], t->type);
+    write_key_value(file, s[S_CMD_T_POSY], t->pos.y);
+    write_key_value(file, s[S_CMD_T_POSX], t->pos.x);
+    write_key_value(file, s[S_CMD_T_COMMAND], t->command);
+    write_key_value(file, s[S_CMD_T_ARGUMENT], t->arg);
+    write_key_value(file, s[S_CMD_T_PROGRESS], t->progress);
+    write_key_value(file, s[S_CMD_T_HP], t->lifepoints);
     for (o = t->owns; o; o = o->next)
     {
-        write_key_value(file, s[S_CMD_CARRIES], o->id);
+        write_key_value(file, s[S_CMD_T_CARRIES], o->id);
     }
     try_fputc('\n', file, f_name);
 }
@@ -196,7 +219,7 @@ static void update_worldstate_file()
     }
     atomic_write_finish(file, s[S_PATH_WORLDSTATE], path_tmp);
     set_cleanup_flag(CLEANUP_WORLDSTATE);
-    char * dot = ".\n";;
+    char * dot = ".\n";
     try_fwrite(dot, strlen(dot), 1, world.file_out, f_name);
     fflush(world.file_out);
 }
@@ -329,7 +352,34 @@ extern void save_world()
     char * f_name = "save_world()";
     char * path_tmp;
     FILE * file = atomic_write_start(s[S_PATH_SAVE], &path_tmp);
-    write_key_value(file, s[S_CMD_DO_FOV], 0);
+    write_key_value(file, s[S_CMD_MAPLENGTH], world.map.length);
+    write_key_value(file, s[S_CMD_PLAYTYPE], world.player_type);
+    try_fputc('\n', file, f_name);
+    struct ThingAction * ta;
+    for (ta = world.thing_actions; ta; ta = ta->next)
+    {
+        write_key_value(file, s[S_CMD_THINGACTION], ta->id);
+        write_key_value(file, s[S_CMD_TA_EFFORT], ta->effort);
+        write_key_string(file, s[S_CMD_TA_NAME], ta->name);
+        try_fputc('\n', file, f_name);
+    }
+    struct ThingType * tt;
+    for (tt = world.thing_types; tt; tt = tt->next)
+    {
+        write_key_value(file, s[S_CMD_THINGTYPE], tt->id);
+        write_key_value(file, s[S_CMD_TT_STARTN], tt->start_n);
+        write_key_value(file, s[S_CMD_TT_HP], tt->lifepoints);
+        int test = fprintf(file, "%s %c\n", s[S_CMD_TT_SYMB], tt->char_on_map);
+        exit_trouble(test < 0, f_name, "fprintf()");
+        write_key_string(file, s[S_CMD_TT_NAME], tt->name);
+        write_key_value(file, s[S_CMD_TT_CONSUM], tt->consumable);
+        try_fputc('\n', file, f_name);
+    }
+    for (tt = world.thing_types; tt; tt = tt->next)
+    {
+        write_key_value(file, s[S_CMD_THINGTYPE], tt->id);
+        write_key_value(file, s[S_CMD_TT_CORPS], tt->corpse_id);
+    }
     try_fputc('\n', file, f_name);
     write_key_value(file, s[S_CMD_SEED_MAP], world.seed_map);
     write_key_value(file, s[S_CMD_SEED_RAND], world.seed);
@@ -340,6 +390,6 @@ extern void save_world()
     {
         write_thing(file, t);
     }
-    write_key_value(file, s[S_CMD_DO_FOV], 1);
+    write_key_value(file, s[S_CMD_WORLD_ACTIVE], 1);
     atomic_write_finish(file, s[S_PATH_SAVE], path_tmp);
 }
diff --git a/src/server/main.c b/src/server/main.c
index 33e5391..c8ca499 100644
--- a/src/server/main.c
+++ b/src/server/main.c
@@ -4,7 +4,6 @@
 #include <stdlib.h> /* exit() */
 #include "../common/rexit.h" /* exit_err, set_cleanup_func() */
 #include "cleanup.h" /* set_cleanup_flag(), cleanup() */
-#include "configfile.h" /* read_config_file() */
 #include "hardcoded_strings.h" /* s */
 #include "init.h" /* run_game(), obey_argv(), obey_argv(), setup_server_io() */
 #include "world.h" /* struct World */
@@ -31,16 +30,14 @@ int main(int argc, char ** argv)
         if (world.replay)
         {
             test = printf("Replay mode. Auto-replaying up to turn %d.\n",
-                         world.replay);
+                          world.replay);
             exit_err(-1 == test, printf_err);
         }
     }
+    world.map.length = 64;                      /* Just a sane default value. */
 
-    /* Init config file and server i/o files. */
-    read_config_file();
+    /* Init server i/o, Enter play or replay mode loops, then leave properly. */
     setup_server_io();
-
-    /* Enter play or replay mode loops, then leave properly. */
     run_game();
     cleanup();
     exit(EXIT_SUCCESS);
diff --git a/src/server/run.c b/src/server/run.c
index 394081c..8251d06 100644
--- a/src/server/run.c
+++ b/src/server/run.c
@@ -5,11 +5,11 @@
 #include <stddef.h> /* NULL */
 #include <stdint.h> /* uint8_t, uint16_t, uint32_t */
 #include <stdio.h> /* FILE, printf(), fflush() */
-#include <stdlib.h> /* free(), atoi() */
-#include <string.h> /* strlen(), strcmp() strncmp(), strdup() */
+#include <stdlib.h> /* free() */
+#include <string.h> /* strlen(), strcmp(), strncmp(), strdup() */
 #include <unistd.h> /* access() */
 #include "../common/parse_file.h" /* set_err_line_options(), token_from_line(),
-                                   * err_line()
+                                   * err_line(), err_line_inc(), parse_val()
                                    */
 #include "../common/readwrite.h" /* try_fopen(), try_fcose(), try_fwrite(),
                                   * try_fgets(), textfile_width(), try_fputc()
@@ -17,55 +17,32 @@
 #include "../common/rexit.h" /* exit_trouble(), exit_err() */
 #include "../common/try_malloc.h" /* try_malloc() */
 #include "ai.h" /* ai() */
-#include "cleanup.h" /* set_cleanup_flag(), unset_cleanup_flag() */
-#include "field_of_view.h" /* build_fov_map() */
+#include "cleanup.h" /* unset_cleanup_flag() */
+#include "god_commands.h" /* parse_god_command_1arg() */
 #include "hardcoded_strings.h" /* s */
-#include "init.h" /* remake_world() */
 #include "io.h" /* io_round(), save_world() */
-#include "map.h" /* remake_map() */
-#include "thing_actions.h" /* ThingAction */
-#include "things.h" /* Thing, get_thing(), own_thing(), add_thing(),
-                     * get_thing_action_id_by_name(), get_player()
-                     */
+#include "things.h" /* Thing, get_thing_action_id_by_name(), get_player() */
 #include "world.h" /* world */
 
 
 
-/* Parse/apply god command in "tok0"/"tok1" on "t" owning another thing. */
-static uint8_t parse_carry(char * tok0, char * tok1, struct Thing * t);
-
-/* Parse/apply god commansd in "tok0"/"tok1" on positioning a thing "t". */
-static uint8_t parse_position(char* tok0, char * tok1, struct Thing * t);
-
-/* Parse/apply god command in "tok0"/"tok1" oo setting "t"'s thing type. */
-static uint8_t parse_thing_type(char * tok0, char * tok1, struct Thing * t);
-
-/* Parse/apply god command in "tok0"/"tok1" on setting up thing "t". */
-static uint8_t parse_thing_command(char * tok0, char * tok1, struct Thing * t);
-
-/* Parse/apply god command on enabling/disabling generation of fields of view on
- * god commands that may affect them, via static global "do_fov". On enabling,
- * (re-)generate all animate things' fields of view.
- */
-static uint8_t parse_do_fov(char * tok0, char * tok1);
+/* If "string" and "comparand" match in string, set "c_to_set" to value."  */
+static uint8_t set_char_by_string_comparison(char * string, char * comparand,
+                                             char * c_to_set, char value);
 
-/* Parse/apply god command in "tok0"/"tok1" manipulating a thing's state. */
-static uint8_t parse_thing_manipulation(char * tok0, char * tok1);
+/* Return 1 on world.exists, else 0 and err_line() appropriate error message. */
+static uint8_t player_commands_allowed();
 
 /* Parse player command "tok0" with no argument to player action, comment on
  * invalidity of non-zero "tok1" (but do not abort in that case).
  */
 static uint8_t parse_player_command_0arg(char * tok0, char * tok1);
 
-/* If "string" and "comparand" match in string, set "c_to_set" to value."  */
-static uint8_t set_char_by_string_comparison(char * string, char * comparand,
-                                             char * c_to_set, char value);
-
 /* Parse player command "tok0" with one argument "tok1" to player action. */
 static uint8_t parse_player_command_1arg(char * tok0, char * tok1);
 
-/* Parse/apply commadn "tok0" with argument "tok1" and test the line for further
- * tokens, commenting on their invalidity (but don't abort on findingthem).
+/* Parse/apply command "tok0" with argument "tok1" and test the line for further
+ * tokens, commenting on their invalidity (but don't abort on finding them).
  */
 static uint8_t parse_command_1arg(char * tok0, char * tok1);
 
@@ -84,120 +61,13 @@ static void turn_over();
 
 
 
-/* Do god commands to create / position things generate their fields of view? */
-static uint8_t do_fov = 0;
-
-
-
-static uint8_t parse_carry(char * tok0, char * tok1, struct Thing * t)
-{
-    uint8_t id;
-    if (parse_val(tok0, tok1, s[S_CMD_CARRIES], '8', (char *) &id))
-    {
-        if (!err_line(id == t->id, "Thing cannot carry itself."))
-        {
-            struct Thing * o = get_thing(world.things, id, 0);
-            if (!err_line(!o, "Thing cannot carry thing that does not exist."))
-            {
-                own_thing(&(t->owns), &world.things, id);
-                o->pos = t->pos;
-            }
-        }
-        return 1;
-    }
-    return 0;
-}
-
-
-
-static uint8_t parse_position(char* tok0, char * tok1, struct Thing * t)
-{
-    char axis = 0;
-    if      (!strcmp(tok0, s[S_CMD_POS_Y]))
-    {
-        axis = 'y';
-    }
-    else if (!strcmp(tok0, s[S_CMD_POS_X]))
-    {
-        axis = 'x';
-    }
-    if (axis && !parsetest_int(tok1, '8'))
-    {
-        uint8_t length = atoi(tok1);
-        char * err = "Position is outside of map.";
-        if (!err_line(length >= world.map.length, err))
-        {
-            if      ('y' == axis)
-            {
-                t->pos.y = length;
-            }
-            else if ('x' == axis)
-            {
-                t->pos.x = length;
-            }
-            free(t->fov_map);
-            t->fov_map= do_fov && t->lifepoints ? build_fov_map(t) : t->fov_map;
-        }
-        return 1;
-    }
-    return 0;
-}
-
-
-
-static uint8_t parse_thing_type(char * tok0, char * tok1, struct Thing * t)
-{
-    uint8_t type;
-    if (parse_val(tok0, tok1, s[S_CMD_TYPE], '8', (char *) &type))
-    {
-        struct ThingType * tt = world.thing_types;
-        for (; NULL != tt && type != tt->id; tt = tt->next);
-        if (!err_line(!tt, "Thing type does not exist."))
-        {
-            t->type = type;
-        }
-        return 1;
-    }
-    return 0;
-}
-
-
 
-static uint8_t parse_thing_command(char * tok0, char * tok1, struct Thing * t)
-{
-    uint8_t command;
-    if (parse_val(tok0, tok1, s[S_CMD_COMMAND], '8', (char *) &command))
-    {
-        if (!command)
-        {
-            t->command = command;
-            return 1;
-        }
-        struct ThingAction * ta = world.thing_actions;
-        for (; NULL != ta && command != ta->id; ta = ta->next);
-        if (!err_line(!ta, "Thing action does not exist."))
-        {
-            t->command = command;
-        }
-        return 1;
-    }
-    return 0;
-}
-
-
-
-static uint8_t parse_do_fov(char * tok0, char * tok1)
+static uint8_t set_char_by_string_comparison(char * string, char * comparand,
+                                             char * c_to_set, char value)
 {
-    if (parse_val(tok0, tok1, s[S_CMD_DO_FOV], '8', (char *) &do_fov))
+    if (!strcmp(string, comparand))
     {
-        if (do_fov)
-        {
-            struct Thing * ti;
-            for (ti = world.things; ti; ti = ti->next)
-            {
-                ti->fov_map = ti->lifepoints ? build_fov_map(ti) : ti->fov_map;
-            }
-        }
+        * c_to_set = value;
         return 1;
     }
     return 0;
@@ -205,30 +75,11 @@ static uint8_t parse_do_fov(char * tok0, char * tok1)
 
 
 
-static uint8_t parse_thing_manipulation(char * tok0, char * tok1)
+static uint8_t player_commands_allowed()
 {
-    uint8_t id;
-    static struct Thing * t = NULL;
-    if (t && (   parse_thing_type(tok0, tok1, t)
-              || parse_thing_command(tok0, tok1, t)
-              || parse_val(tok0, tok1, s[S_CMD_ARGUMENT], '8', (char *)&t->arg)
-              || parse_val(tok0,tok1,s[S_CMD_PROGRESS],'8',(char *)&t->progress)
-              || parse_val(tok0, tok1, s[S_CMD_LIFEPOINTS], '8',
-                                                        (char *) &t->lifepoints)
-              || parse_position(tok0, tok1, t)
-              || parse_carry(tok0, tok1, t)));
-    else if (parse_val(tok0, tok1, s[S_CMD_THING], '8', (char *) &id))
-    {
-        t = get_thing(world.things, id, 1);
-        if (!t)
-        {
-            t = add_thing(id, 0, 0);
-            set_cleanup_flag(CLEANUP_THINGS);
-            t->fov_map= do_fov && t->lifepoints ? build_fov_map(t) : t->fov_map;
-        }
-    }
-    else
+    if (!world.exists)
     {
+        err_line(1, "No world exists in which to run player commands.");
         return 0;
     }
     return 1;
@@ -241,23 +92,13 @@ static uint8_t parse_player_command_0arg(char * tok0, char * tok1)
     struct Thing * player = get_player();
     if (!strcmp(tok0, s[S_CMD_WAIT]) || !strcmp(tok0, s[S_CMD_PICKUP]))
     {
-        player->command = get_thing_action_id_by_name(tok0);
-        player->arg = 0;
-        turn_over();
-        err_line (NULL != tok1, "No arguments expected, ignoring arguments.");
-        return 1;
-    }
-    return 0;
-}
-
-
-
-static uint8_t set_char_by_string_comparison(char * string, char * comparand,
-                                             char * c_to_set, char value)
-{
-    if (!strcmp(string, comparand))
-    {
-        * c_to_set = value;
+        if (player_commands_allowed())
+        {
+            player->command = get_thing_action_id_by_name(tok0);
+            player->arg = 0;
+            turn_over();
+            err_line (NULL != tok1, "No arguments expected, ignoring them.");
+        }
         return 1;
     }
     return 0;
@@ -268,14 +109,14 @@ static uint8_t set_char_by_string_comparison(char * string, char * comparand,
 static uint8_t parse_player_command_1arg(char * tok0, char * tok1)
 {
     struct Thing * player = get_player();
-    if (
-           parse_val(tok0, tok1, s[S_CMD_DROP], '8', (char *) &player->arg)
-        || parse_val(tok0, tok1, s[S_CMD_USE], '8', (char *) &player->arg))
+    if (   (   parse_val(tok0, tok1, s[S_CMD_DROP], '8', (char *) &player->arg)
+            || parse_val(tok0, tok1, s[S_CMD_USE], '8', (char *) &player->arg))
+        && player_commands_allowed())
     {
         player->command = get_thing_action_id_by_name(tok0);
         turn_over();
     }
-    else if (!strcmp(tok0, s[S_CMD_MOVE]))
+    else if (!strcmp(tok0, s[S_CMD_MOVE]) && player_commands_allowed())
     {
         char dir = '\0';
         if (!(   set_char_by_string_comparison(tok1, "east",       &dir, 'd')
@@ -303,20 +144,8 @@ static uint8_t parse_player_command_1arg(char * tok0, char * tok1)
 static uint8_t parse_command_1arg(char * tok0, char * tok1)
 {
     char * tok2 = token_from_line(NULL);
-    if (   parse_thing_manipulation(tok0, tok1)
-        || parse_player_command_1arg(tok0, tok1)
-        || parse_val(tok0, tok1, s[S_CMD_SEED_RAND], 'U', (char *) &world.seed)
-        || parse_val(tok0, tok1, s[S_CMD_TURN], 'u', (char *) &world.turn)
-        || parse_do_fov(tok0, tok1));
-    else if (parse_val(tok0,tok1,s[S_CMD_SEED_MAP],'U',(char *)&world.seed_map))
-
-    {
-        remake_map();
-    }
-    else if (parse_val(tok0, tok1, s[S_CMD_MAKE_WORLD],'U',(char *)&world.seed))
-    {
-        remake_world();
-    }
+    if (   parse_player_command_1arg(tok0, tok1)
+        || parse_god_command_1arg(tok0, tok1));
     else
     {
         return 0;
@@ -373,11 +202,8 @@ static void turn_over()
                 ai(thing);
             }
             thing->progress++;
-            struct ThingAction * ta = world.thing_actions;
-            while (ta->id != thing->command)
-            {
-                ta = ta->next;
-            }
+
+            struct ThingAction * ta = get_thing_action(thing->command);
             if (thing->progress == ta->effort)
             {
                 ta->func(thing);
@@ -415,10 +241,20 @@ static void record_msg(char * msg)
 
 
 
-extern void obey_msg(char * msg, uint8_t do_record)
+extern void obey_msg(char * msg, uint8_t do_record, uint8_t do_verbose)
 {
-    set_err_line_options("Trouble with message: ", msg, 0, 0);
+    char * f_name = "obey_msg()";
+    if (world.is_verbose && do_verbose)
+    {
+        exit_trouble(-1 == printf("Input: %s\n", msg), f_name, "printf()");
+    }
+    set_err_line_options("Trouble with message: ", msg, 0);
     char * msg_copy = strdup(msg);
+    if (msg[0] == 'm')
+    {
+        int a = 5;
+        a = a;
+    }
     char * tok0 = token_from_line(msg_copy);
     if (NULL != tok0)
     {
@@ -426,7 +262,10 @@ extern void obey_msg(char * msg, uint8_t do_record)
         if (    parse_player_command_0arg(tok0, tok1)
             || (tok1 && parse_command_1arg(tok0, tok1)))
         {
-            world.do_update = 1;
+            if (world.exists)
+            {
+                world.do_update = 1;
+            }
             if (do_record)
             {
                 save_world();
@@ -436,7 +275,7 @@ extern void obey_msg(char * msg, uint8_t do_record)
             return;
         }
     }
-    err_line(1, "Unknown command or bad number of tokens.");
+    err_line(1, "Unknown command/argument or bad number of tokens.");
     free(msg_copy);
 }
 
@@ -475,7 +314,7 @@ extern uint8_t io_loop()
             free(msg);
             return 0;
         }
-        obey_msg(msg, 1);
+        obey_msg(msg, 1, 0);
         free(msg);
     }
 }
diff --git a/src/server/run.h b/src/server/run.h
index 07ca902..400f079 100644
--- a/src/server/run.h
+++ b/src/server/run.h
@@ -11,9 +11,10 @@
 
 
 /* Try parsing "msg" into a command to apply, and apply it. Record commands to
- * the file at world.path_record if "do_record" is set.
+ * the file at world.path_record if "do_record" is set, and output them to
+ * stdout if "do_verbose" and world.is_verbose are set.
  */
-extern void obey_msg(char * msg, uint8_t do_record);
+extern void obey_msg(char * msg, uint8_t do_record, uint8_t do_verbose);
 
 /* Loop for receiving commands via io_round() and acting on them. Exits with 1
  * on "QUIT" command. In replay mode, exits with 0 on each non-"QUIT" command.
diff --git a/src/server/thing_actions.c b/src/server/thing_actions.c
index b153ff8..e91f576 100644
--- a/src/server/thing_actions.c
+++ b/src/server/thing_actions.c
@@ -5,13 +5,13 @@
 #include <stdint.h> /* uint8_t, uint16_t */
 #include <stdio.h> /* sprintf() */
 #include <stdlib.h> /* free() */
-#include <string.h> /* strlen(), strcmp(), memcpy(), strncmp() */
-#include "../common/rexit.h" /* exit_err(), exit_trouble() */
+#include <string.h> /* strlen(), memcpy(), strncmp() */
+#include "../common/rexit.h" /* exit_trouble() */
 #include "../common/try_malloc.h" /* try_malloc() */
 #include "../common/yx_uint8.h" /* struct yx_uint8 */
 #include "field_of_view.h" /* build_fov_map() */
 #include "hardcoded_strings.h" /* s */
-#include "things.h" /* structs Thing, ThingType, get_player(), own_thing(),
+#include "things.h" /* Thing, ThingType, get_player(), own_thing(),
                      * set_thing_position(), get_thing_type()
                      */
 #include "map.h" /* is_passable() */
@@ -238,36 +238,6 @@ static void playerbonus_use(uint8_t no_thing, uint8_t wrong_thing)
 
 
 
-extern void free_thing_actions(struct ThingAction * ta)
-{
-    if (NULL == ta)
-    {
-        return;
-    }
-    free(ta->name);
-    free_thing_actions(ta->next);
-    free(ta);
-}
-
-
-
-extern uint8_t get_thing_action_id_by_name(char * name)
-{
-    struct ThingAction * ta = world.thing_actions;
-    while (NULL != ta)
-    {
-        if (0 == strcmp(ta->name, name))
-        {
-            break;
-        }
-        ta = ta->next;
-    }
-    exit_err(NULL == ta, "get_thing_action_id_by_name() did not find action.");
-    return ta->id;
-}
-
-
-
 extern void actor_wait(struct Thing * t)
 {
     if (t == get_player())
diff --git a/src/server/thing_actions.h b/src/server/thing_actions.h
index 861f5c2..28857e7 100644
--- a/src/server/thing_actions.h
+++ b/src/server/thing_actions.h
@@ -8,28 +8,10 @@
 #ifndef THING_ACTIONS_H
 #define THING_ACTIONS_H
 
-#include <stdint.h> /* uint8_t */
 struct Thing;
 
 
 
-struct ThingAction
-{
-    uint8_t id; /* identifies action in Thing.command; therefore must be >0 */
-    struct ThingAction * next;
-    void (* func) (struct Thing *); /* function called after .effort turns */
-    char * name; /* human-readable identifier */
-    uint8_t effort; /* how many turns the action takes */
-};
-
-
-
-/* Free ThingAction * chain starting at "ta". */
-extern void free_thing_actions(struct ThingAction * ta);
-
-/* Return world.thing_actions ThingAction.id for "name". */
-extern uint8_t get_thing_action_id_by_name(char * name);
-
 /* Actor "t" does nothing. */
 extern void actor_wait(struct Thing * t);
 
diff --git a/src/server/things.c b/src/server/things.c
index 9425f9c..6df9b18 100644
--- a/src/server/things.c
+++ b/src/server/things.c
@@ -1,148 +1,274 @@
 /* src/server/things.c */
 
+#define _POSIX_C_SOURCE 200809L /* strdup() */
 #include "things.h"
-#include <stddef.h> /* NULL */
-#include <stdint.h> /* uint8_t, uint16_t, UINT8_MAX, UINT16_MAX */
+#include <stddef.h> /* NULL, size_t */
+#include <stdint.h> /* uint8_t, uint16_t, int16_t, UINT8_MAX, UINT16_MAX */
 #include <stdlib.h> /* free() */
-#include <string.h> /* memset(), strlen() */
-#include "../common/rexit.h" /* exit_err(), exit_trouble() */
+#include <string.h> /* memset(), strcmp(), strdup() */
+#include "../common/rexit.h" /* exit_err() */
 #include "../common/try_malloc.h" /* try_malloc() */
 #include "../common/yx_uint8.h" /* yx_uint8 */
+#include "cleanup.h" /* set_cleanup_flag() */
 #include "hardcoded_strings.h" /* s */
 #include "map.h" /* is_passable() */
 #include "rrand.h" /* rrand() */
-#include "world.h" /* global world */
+#include "thing_actions.h" /* actor_wait */
+#include "world.h" /* world */
 #include "yx_uint8.h" /* yx_uint8_cmp() */
 
 
 
+/* Used to treat structs Thing, ThingType and ThingAction the same. */
+struct NextAndId
+{
+    struct NextAndId * next;
+    uint8_t id;
+};
+
+
 
-/* Return lowest unused id for new thing. */
-static uint8_t get_lowest_unused_id();
+/* Return lowest unused id for new thing ("sel"==0), thing type ("sel"==1) or
+ * thing action ("sel"==2).
+ */
+static uint8_t get_unused_id(uint8_t sel);
 
+/* To linked list of NextAndId structs (or rather structs whose start region is
+ * compatible to it) starting at "start", add newly allocated element of
+ * "n_size" and an ID that is either "id" or, if "id" is <= UINT8_MAX and >=
+ * "id_start", get ID from get_unused_id("struct_id").
+ */
+static struct NextAndId * add_to_struct_list(size_t n_size, uint8_t start_id,
+                                             int16_t id, uint8_t struct_id,
+                                             struct NextAndId ** start);
 
 
-static uint8_t get_lowest_unused_id()
+
+static uint8_t get_unused_id(uint8_t sel)
 {
     uint8_t i = 0;
     while (1)
     {
-        if (!get_thing(world.things, i, 1))
+        if (   (0 == sel && !get_thing(world.things, i, 1))
+            || (1 == sel && !get_thing_type(i))
+            || (2 == sel && !get_thing_action(i)))
         {
             return i;
         }
-        exit_err(i == UINT8_MAX, "No unused ID available to add new thing.");
+        exit_err(i == UINT8_MAX, "No unused ID available to add to ID list.");
         i++;
     }
 }
 
 
 
-extern struct Thing * get_thing(struct Thing * ptr, uint8_t id, uint8_t deep)
+static struct NextAndId * add_to_struct_list(size_t n_size, uint8_t start_id,
+                                             int16_t id, uint8_t struct_id,
+                                             struct NextAndId ** start)
 {
-    while (1)
+    char * f_name = "add_to_struct_list()";
+    struct NextAndId * nai  = try_malloc(n_size, f_name);
+    memset(nai, 0, n_size);
+    nai->id = (start_id<=id && id<=UINT8_MAX) ? id : get_unused_id(struct_id);
+    struct NextAndId ** nai_ptr_ptr = start;
+    for (; NULL != * nai_ptr_ptr; nai_ptr_ptr = &(*nai_ptr_ptr)->next);
+    *nai_ptr_ptr = nai;
+    return nai;
+}
+
+
+
+extern struct ThingAction * add_thing_action(int16_t id)
+{
+    struct ThingAction * ta;
+    ta = (struct ThingAction *) add_to_struct_list(sizeof(struct ThingAction),
+                                                   1, id, 2,
+                                                   (struct NextAndId **)
+                                                   &world.thing_actions);
+    set_cleanup_flag(CLEANUP_THING_ACTIONS);
+    ta->name = strdup(s[S_CMD_WAIT]);
+    ta->effort = 1;
+    ta->func = actor_wait;
+    return ta;
+}
+
+
+
+extern struct ThingType * add_thing_type(int16_t id)
+{
+    struct ThingType * tt;
+    tt = (struct ThingType *) add_to_struct_list(sizeof(struct ThingType),
+                                                 0, id, 1,
+                                                 (struct NextAndId **)
+                                                 &world.thing_types);
+    set_cleanup_flag(CLEANUP_THING_TYPES);
+    tt->name = strdup("(none)");
+    return tt;
+}
+
+
+
+extern struct Thing * add_thing(int16_t id, uint8_t type, uint8_t y, uint8_t x)
+{
+    struct Thing * t;
+    t = (struct Thing *) add_to_struct_list(sizeof(struct Thing), 0, id, 0,
+                                            (struct NextAndId **) &world.things);
+    struct ThingType * tt = get_thing_type(type);
+    set_cleanup_flag(CLEANUP_THINGS);
+    t->type       = tt->id;
+    t->lifepoints = tt->lifepoints;
+    t->pos.y      = y;
+    t->pos.x      = x;
+    return t;
+}
+
+
+
+extern void free_thing_actions(struct ThingAction * ta)
+{
+    if (NULL == ta)
     {
-        if (NULL == ptr || id == ptr->id)
-        {
-            return ptr;
-        }
-        if (deep)
-        {
-            struct Thing * owned_thing = get_thing(ptr->owns, id, 1);
-            if (NULL != owned_thing)
-            {
-                return ptr;
-            }
-        }
-        ptr = ptr->next;
+        return;
     }
+    free_thing_actions(ta->next);
+    free(ta->name);
+    free(ta);
 }
 
 
 
-extern void free_thing_types(struct ThingType * tt_start)
+extern void free_thing_types(struct ThingType * tt)
 {
-    if (NULL == tt_start)
+    if (NULL == tt)
     {
         return;
     }
-    free_thing_types(tt_start->next);
-    free(tt_start->name);
-    free(tt_start);
+    free_thing_types(tt->next);
+    free(tt->name);
+    free(tt);
 }
 
 
 
-extern struct Thing * add_thing(int16_t id, uint8_t type, uint8_t find_pos)
+extern void free_things(struct Thing * t)
 {
-    char * f_name = "add_thing()";
-    struct ThingType * tt = get_thing_type(type);
-    struct Thing *     t  = try_malloc(sizeof(struct Thing), f_name);
-    memset(t, 0, sizeof(struct Thing));
-    t->id = (0 <= id && id <= UINT8_MAX) ? id : get_lowest_unused_id();
-    t->type       = tt->id;
-    t->lifepoints = tt->lifepoints;
-    char * err = "Space to put thing on too hard to find. Map too small?";
-    uint16_t i = 0;
-    memset(&(t->pos), 0, sizeof(struct yx_uint8));
-    while (find_pos)
+    if (NULL == t)
     {
-        struct yx_uint8 pos;
-        for (pos.y = pos.x = 0; 0 == is_passable(pos); i++)
+        return;
+    }
+    free_things(t->owns);
+    free_things(t->next);
+    free(t->fov_map);
+    free(t);
+    if (t == world.things)         /* So add_things()' NULL-delimited thing   */
+    {                              /* iteration loop does not iterate over    */
+        world.things = NULL;       /* freed memory when called the first time */
+    }                              /* after world re-seeding.                 */
+}
+
+
+
+extern struct ThingAction * get_thing_action(uint8_t id)
+{
+    struct ThingAction * ta = world.thing_actions;
+    for (; NULL != ta && id != ta->id; ta = ta->next);
+    return ta;
+}
+
+
+
+extern struct ThingType * get_thing_type(uint8_t id)
+{
+    struct ThingType * tt = world.thing_types;
+    for (; NULL != tt && id != tt->id; tt = tt->next);
+    return tt;
+}
+
+
+
+extern uint8_t get_thing_action_id_by_name(char * name)
+{
+    struct ThingAction * ta = world.thing_actions;
+    while (NULL != ta)
+    {
+        if (0 == strcmp(ta->name, name))
         {
-            exit_err(UINT16_MAX == i, err);
-            pos.y = rrand() % world.map.length;
-            pos.x = rrand() % world.map.length;
+            break;
         }
-        struct Thing * t_ptr;
-        uint8_t clear = 1;
-        for (t_ptr = world.things; t_ptr != NULL; t_ptr = t_ptr->next)
+        ta = ta->next;
+    }
+    if (!ta)
+    {
+        return 0;
+    }
+    return ta->id;
+}
+
+
+
+extern struct Thing * get_thing(struct Thing * ptr, uint8_t id, uint8_t deep)
+{
+    while (1)
+    {
+        if (NULL == ptr || id == ptr->id)
         {
-            if (yx_uint8_cmp(&pos, &t_ptr->pos) && 0 != t_ptr->lifepoints)
-            {
-                clear = 0;
-                break;
-            }
+            return ptr;
         }
-        if (1 == clear)
+        if (deep)
         {
-            t->pos = pos;
-            break;
+            struct Thing * owned_thing = get_thing(ptr->owns, id, 1);
+            if (NULL != owned_thing)
+            {
+                return ptr;
+            }
         }
+        ptr = ptr->next;
     }
-    struct Thing ** t_ptr_ptr = &world.things;
-    for (; NULL != * t_ptr_ptr; t_ptr_ptr = &(*t_ptr_ptr)->next);
-    * t_ptr_ptr = t;
-    return t;
 }
 
 
 
-extern void add_things(uint8_t type, uint8_t n)
+extern struct Thing * get_player()
 {
-    uint8_t i;
-    for (i = 0; i < n; i++)
-    {
-        add_thing(-1, type, 1);
-    }
+    return get_thing(world.things, 0, 0);
 }
 
 
 
-extern void free_things(struct Thing * t_start)
+extern void add_things(uint8_t type, uint8_t n)
 {
-    if (NULL == t_start)
+    uint8_t i;
+    for (i = 0; i < n; i++)
     {
-        return;
+        struct yx_uint8 pos;
+        while (1)
+        {
+            char * err = "Space to put thing on too hard to find."
+                         "Map too small?";
+            uint16_t i_pos = 0;
+            for (pos.y = pos.x = 0; 0 == is_passable(pos); i_pos++)
+            {
+                exit_err(UINT16_MAX == i_pos, err);
+                pos.y = rrand() % world.map.length;
+                pos.x = rrand() % world.map.length;
+            }
+            struct Thing * t;
+            uint8_t clear = 1;
+            for (t = world.things; t; t = t->next)
+            {
+                if (yx_uint8_cmp(&pos, &t->pos) && 0 != t->lifepoints)
+                {
+                    clear = 0;
+                    break;
+                }
+            }
+            if (1 == clear)
+            {
+                break;
+            }
+        }
+        add_thing(-1, type, pos.y, pos.x);
     }
-    free_things(t_start->owns);
-    free_things(t_start->next);
-    free(t_start->fov_map);
-    free(t_start);
-    if (t_start == world.things)   /* So add_things()' NULL-delimited thing   */
-    {                              /* iteration loop does not iterate over    */
-        world.things = NULL;       /* freed memory when called the first time */
-    }                              /* after world re-seeding.                 */
 }
 
 
@@ -178,29 +304,6 @@ extern void own_thing(struct Thing ** target, struct Thing ** source,
 
 
 
-extern struct Thing * get_player()
-{
-    return get_thing(world.things, 0, 1);
-}
-
-
-
-extern struct ThingType * get_thing_type(uint8_t id)
-{
-    char * f_name = "get_thing_type()";
-    struct ThingType * tt = world.thing_types;
-    for (; NULL != tt && id != tt->id; tt = tt->next);
-    char * err_intro = "Requested thing type of unused ID ";
-    uint16_t size = strlen(err_intro) + 3 + 1 + 1;
-    char * err = try_malloc(size, f_name);
-    exit_trouble(sprintf(err,"%s%d.",err_intro,id) < 0,f_name,s[S_FCN_SPRINTF]);
-    exit_err(NULL == tt, err);
-    free(err);
-    return tt;
-}
-
-
-
 extern void set_thing_position(struct Thing * t, struct yx_uint8 pos)
 {
     t->pos = pos;
diff --git a/src/server/things.h b/src/server/things.h
index 889374a..6f7d124 100644
--- a/src/server/things.h
+++ b/src/server/things.h
@@ -1,24 +1,24 @@
 /* src/server/things.h
  *
- * Structs for things and their type definitions, and routines to initialize
- * these and load and save them from/to files.
+ * Structs for things and their type and action definitions, and routines to
+ * initialize these.
  */
 
 #ifndef THINGS_H
 #define THINGS_H
 
-#include <stdint.h> /* uint8_t */
+#include <stdint.h> /* uint8_t, int16_t */
 #include "../common/yx_uint8.h" /* yx_uint8 structs */
 
 
 
 struct Thing
 {
-    struct Thing * next;         /* pointer to next one in things chain */
+    struct Thing * next;
+    uint8_t id;                  /* individual thing's unique identifier */
     struct Thing * owns;         /* chain of things owned / in inventory */
     struct yx_uint8 pos;         /* coordinate on map */
     uint8_t * fov_map;           /* map of the thing's field of view */
-    uint8_t id;                  /* individual thing's unique identifier */
     uint8_t type;                /* ID of appropriate thing definition */
     uint8_t lifepoints;          /* 0: thing is inanimate; >0: hitpoints */
     uint8_t command;             /* thing's current action; 0 if none */
@@ -28,8 +28,8 @@ struct Thing
 
 struct ThingType
 {
-    uint8_t id;         /* thing type identifier / sets .type */
     struct ThingType * next;
+    uint8_t id;         /* thing type identifier / sets .type */
     char char_on_map;   /* thing symbol to appear on map */
     char * name;        /* string to describe thing in game log */
     uint8_t corpse_id;  /* type to change thing into upon destruction */
@@ -38,37 +38,65 @@ struct ThingType
     uint8_t start_n;    /* how many of these does the map start with? */
 };
 
+struct ThingAction
+{
+    struct ThingAction * next;
+    uint8_t id;   /* identifies action in Thing.command; therefore must be >0 */
+    void (* func) (struct Thing *);    /* function called after .effort turns */
+    char * name;                       /* human-readable identifier */
+    uint8_t effort;                    /* how many turns the action takes */
+};
 
 
-/* Return thing of "id" in chain at "ptr", search inventories too if "deep". */
-extern struct Thing * get_thing(struct Thing * ptr, uint8_t id, uint8_t deep);
 
-/* Free thing types chain starting at "tt_start". */
-extern void free_thing_types(struct ThingType * tt_start);
+/* Add thing action of "id" to world.thing_actions, with .name defaulting to
+ * s[S_CMD_WAIT], .func to actor_wait() and .effort to 1. If "id" is not >= 1
+ * and <= UINT8_MAX, use lowest unused id. Return thing action.
+ */
+extern struct ThingAction * add_thing_action(int16_t id);
 
-/* Add thing of "id" and "type" to map on random passable position (positions
- * which contain an actor are not deemed passable) if "find_pos", else on y=0,
- * x=0. If "id" is >= 0 and <= UINT8_MAX, use lowest unused id. Return thing.
+/* Add thing type of "id", with .corpse_id defaulting to "id" to
+ * world.thing_types, .name to "(none)" and the remaining values to 0. If "id"
+ * is not >= 0 and <= UINT8_MAX, use lowest unused id. Return thing type.
  */
-extern struct Thing * add_thing(int16_t id, uint8_t type, uint8_t find_pos);
+extern struct ThingType * add_thing_type(int16_t id);
 
-/* Add thing(s) ("n": how many?) of "type" to map on random position(s). New
- * animate things are never placed in the same square with other animate ones.
+/* Add thing of "id" and "type" on position of "y"/x" to world.things.If "id" is
+ * not >= 0 and <= UINT8_MAX, use lowest unused id. Return thing.
  */
-extern void add_things(uint8_t type, uint8_t n);
+extern struct Thing * add_thing(int16_t id, uint8_t type, uint8_t y, uint8_t x);
 
-/* Free things in things chain starting at "t_start. */
-extern void free_things(struct Thing * t_start);
+/* Free ThingAction/ThingType/Thing * chain starting at "ta"/"tt"/"t". */
+extern void free_thing_actions(struct ThingAction * ta);
+extern void free_thing_types(struct ThingType * tt);
+extern void free_things(struct Thing * t);
 
-/* Move thing of "id" from "source" inventory to "target" inventory. */
-extern void own_thing(struct Thing ** target, struct Thing ** source,
-                      uint8_t id);
+/* Return pointer to ThingAction/ThingType of "id", or NULL if none found. */
+extern struct ThingAction * get_thing_action(uint8_t id);
+extern struct ThingType * get_thing_type(uint8_t id);
 
-/* Get pointer to the Thing struct that represents the player. */
+/* Return world.thing_actions ThingAction.id for "name" or 0 if none found. */
+extern uint8_t get_thing_action_id_by_name(char * name);
+
+/* Return thing of "id" in chain at "ptr", search inventories too if "deep".
+ * Return NULL if nothing found.
+ */
+extern struct Thing * get_thing(struct Thing * ptr, uint8_t id, uint8_t deep);
+
+/* Get pointer to the non-owend Thing struct that represents the player, or NULL
+ * if none found.
+ */
 extern struct Thing * get_player();
 
-/* Get pointer to the thing type of identifier "def_id". */
-extern struct ThingType * get_thing_type(uint8_t id);
+/* Add thing(s) ("n": how many?) of "type" to map on random passable
+ * position(s). New animate things are never placed in the same square with
+ * other animate ones.
+ */
+extern void add_things(uint8_t type, uint8_t n);
+
+/* Move thing of "id" from "source" inventory to "target" inventory. */
+extern void own_thing(struct Thing ** target, struct Thing ** source,
+                      uint8_t id);
 
 /* Move not only "t" to "pos", but also all things owned by it. */
 extern void set_thing_position(struct Thing * t, struct yx_uint8 pos);
diff --git a/src/server/world.h b/src/server/world.h
index 22af12c..6e941e6 100644
--- a/src/server/world.h
+++ b/src/server/world.h
@@ -31,7 +31,8 @@ struct World
     uint32_t seed_map; /* Map seed. */
     uint16_t replay; /* Turn up to which to replay game. No replay if zero. */
     uint16_t turn; /* Current game turn. */
-    uint16_t do_update; /* Update worldstate file if !0. */
+    uint8_t do_update; /* Update worldstate file if !0. */
+    uint8_t exists; /* If !0, remake_world() has been run successfully. */
     uint8_t player_type; /* Thing type that player will start as. */
     uint8_t is_verbose; /* Should server send debugging info to stdout? */
 };