diff --git a/wmud/configuration.c b/wmud/configuration.c
index fd4ca1c..d9a7b88 100644
--- a/wmud/configuration.c
+++ b/wmud/configuration.c
@@ -96,13 +96,14 @@ wmud_configdata_free(ConfigData **config_data)
 gboolean
 wmud_config_init(ConfigData **config_data, GError **err)
 {
-    GString *config_file = g_string_new(WMUD_CONFDIR);
+    GString  *config_file = g_string_new(WMUD_CONFDIR);
     GKeyFile *config;
-    GError *in_err = NULL;
-    gchar *pos;
+    GError   *in_err = NULL;
+    gchar    *pos;
 
-    if (!config_data)
+    if (!config_data) {
         return FALSE;
+    }
 
     if (*config_data) {
         g_clear_error(err);
@@ -255,8 +256,8 @@ wmud_config_init(ConfigData **config_data, GError **err)
 
     if ((pos = g_strstr_len((*config_data)->database_dsn,
                             -1, "{statedir}")) != NULL) {
-        guint real_pos = pos - (*config_data)->database_dsn;
-        GString *tmp = g_string_new((*config_data)->database_dsn);
+        guint   real_pos = pos - (*config_data)->database_dsn;
+        GString *tmp     = g_string_new((*config_data)->database_dsn);
 
         g_string_erase(tmp, real_pos, 10);
         g_string_insert(tmp, real_pos, WMUD_STATEDIR);
diff --git a/wmud/db.c b/wmud/db.c
index 4b6ec28..e0d2670 100644
--- a/wmud/db.c
+++ b/wmud/db.c
@@ -39,8 +39,8 @@
  * different (e.g MySQL or PostgreSQL) database.
  */
 
-static GdaConnection *dbh = NULL;
-static GdaSqlParser *parser = NULL;
+static GdaConnection *dbh    = NULL;
+static GdaSqlParser  *parser = NULL;
 
 GQuark
 wmud_db_error_quark()
@@ -98,33 +98,34 @@ wmud_db_init(GError **err)
 gboolean
 wmud_db_load_players(GError **err)
 {
-    GdaStatement *sth = NULL;
-    GdaDataModel *res;
+    GdaStatement     *sth = NULL;
+    GdaDataModel     *res;
     GdaDataModelIter *iter;
-    GError *local_err = NULL;
+    GError           *local_err = NULL;
 
     g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "Loading players");
     if (dbh == NULL) {
-        if (err)
+        if (err) {
             g_set_error(err,
                         WMUD_DB_ERROR, WMUD_DB_ERROR_NOINIT,
                         "Database backend not initialized");
+        }
 
         return FALSE;
     }
 
     sth = gda_sql_parser_parse_string(
-            parser,
-            "SELECT id, login, password, email FROM players",
-            NULL,
-            NULL);
+        parser,
+        "SELECT id, login, password, email FROM players",
+        NULL,
+        NULL);
 
     /* TODO: error checking! */
     if ((res = gda_connection_statement_execute_select(
-                 dbh,
-                 sth,
-                 NULL,
-                 &local_err)) == NULL) {
+             dbh,
+             sth,
+             NULL,
+             &local_err)) == NULL) {
         g_log(G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
               "Unable to load players: %s",
               local_err->message);
@@ -141,7 +142,7 @@ wmud_db_load_players(GError **err)
 
     while (gda_data_model_iter_is_valid(iter)) {
         const GValue *val;
-        WmudPlayer *player;
+        WmudPlayer   *player;
 
         player = wmud_player_new();
 
@@ -192,20 +193,21 @@ wmud_db_save_player(WmudPlayer *player, GError **err)
 
     g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "Saving player");
     if (dbh == NULL) {
-        if (err)
+        if (err) {
             g_set_error(err,
                         WMUD_DB_ERROR, WMUD_DB_ERROR_NOINIT,
                         "Database backend not initialized");
+        }
 
         return FALSE;
     }
 
     login_value = gda_value_new_from_string(
-            wmud_player_get_player_name(player),
-            G_TYPE_STRING);
+        wmud_player_get_player_name(player),
+        G_TYPE_STRING);
     email_value = gda_value_new_from_string(
-            wmud_player_get_email(player),
-            G_TYPE_STRING);
+        wmud_player_get_email(player),
+        G_TYPE_STRING);
 
     if (!gda_connection_insert_row_into_table(dbh,
                                               "players",
@@ -228,8 +230,8 @@ wmud_db_save_player(WmudPlayer *player, GError **err)
 
 gboolean
 wmud_db_update_player_password(WmudPlayer *player,
-                               gchar *crypted_password,
-                               GError **err)
+                               gchar      *crypted_password,
+                               GError     **err)
 {
     GValue *cpw,
            *player_id;
@@ -271,16 +273,17 @@ wmud_db_update_player_password(WmudPlayer *player,
 gboolean
 wmud_db_load_planes(GSList **planes, GError **err)
 {
-    GdaStatement *sth = NULL;
-    GdaDataModel *res = NULL;
+    GdaStatement     *sth = NULL;
+    GdaDataModel     *res = NULL;
     GdaDataModelIter *iter;
 
     g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "Loading planes");
     if (dbh == NULL) {
-        if (err)
+        if (err) {
             g_set_error(err,
                         WMUD_DB_ERROR, WMUD_DB_ERROR_NOINIT,
                         "Database backend not initialized");
+        }
 
         return FALSE;
     }
@@ -289,20 +292,20 @@ wmud_db_load_planes(GSList **planes, GError **err)
                                       "SELECT id, name FROM planes",
                                       NULL,
                                       NULL);
-    res = gda_connection_statement_execute_select(dbh, sth, NULL, NULL);
+    res  = gda_connection_statement_execute_select(dbh, sth, NULL, NULL);
     iter = gda_data_model_create_iter(res);
     gda_data_model_iter_move_next(iter);
 
     while (gda_data_model_iter_is_valid(iter)) {
         const GValue *val;
-        wmudPlane *plane;
+        wmudPlane    *plane;
 
         plane = g_new0(wmudPlane, 1);
 
-        val = gda_data_model_iter_get_value_at(iter, 0);
+        val       = gda_data_model_iter_get_value_at(iter, 0);
         plane->id = g_value_get_int(val);
 
-        val = gda_data_model_iter_get_value_at(iter, 1);
+        val         = gda_data_model_iter_get_value_at(iter, 1);
         plane->name = g_strdup(g_value_get_string(val));
 
         g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG,
@@ -323,16 +326,17 @@ wmud_db_load_planes(GSList **planes, GError **err)
 gboolean
 wmud_db_load_planets(GSList **planets, GError **err)
 {
-    GdaStatement *sth = NULL;
-    GdaDataModel *res = NULL;
+    GdaStatement     *sth = NULL;
+    GdaDataModel     *res = NULL;
     GdaDataModelIter *iter;
 
     g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "Loading planets");
     if (dbh == NULL) {
-        if (err)
+        if (err) {
             g_set_error(err,
                         WMUD_DB_ERROR, WMUD_DB_ERROR_NOINIT,
                         "Database backend not initialized");
+        }
 
         return FALSE;
     }
@@ -341,20 +345,20 @@ wmud_db_load_planets(GSList **planets, GError **err)
                                       "SELECT id, name FROM planets",
                                       NULL,
                                       NULL);
-    res = gda_connection_statement_execute_select(dbh, sth, NULL, NULL);
+    res  = gda_connection_statement_execute_select(dbh, sth, NULL, NULL);
     iter = gda_data_model_create_iter(res);
     gda_data_model_iter_move_next(iter);
 
     while (gda_data_model_iter_is_valid(iter)) {
         const GValue *val;
-        wmudPlanet *planet;
+        wmudPlanet   *planet;
 
         planet = g_new0(wmudPlanet, 1);
 
-        val = gda_data_model_iter_get_value_at(iter, 0);
+        val        = gda_data_model_iter_get_value_at(iter, 0);
         planet->id = g_value_get_int(val);
 
-        val = gda_data_model_iter_get_value_at(iter, 1);
+        val          = gda_data_model_iter_get_value_at(iter, 1);
         planet->name = g_strdup(g_value_get_string(val));
 
         g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG,
@@ -375,31 +379,32 @@ wmud_db_load_planets(GSList **planets, GError **err)
 gboolean
 wmud_db_load_directions(GSList **directions, GError **err)
 {
-    GdaStatement *sth = NULL;
-    GdaDataModel *res = NULL;
+    GdaStatement     *sth = NULL;
+    GdaDataModel     *res = NULL;
     GdaDataModelIter *iter;
-    GError *local_err = NULL;
+    GError           *local_err = NULL;
 
     g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "Loading directions");
 
     if (dbh == NULL) {
-        if (err)
+        if (err) {
             g_set_error(err,
                         WMUD_DB_ERROR, WMUD_DB_ERROR_NOINIT,
                         "Database backend not initialized");
+        }
 
         return FALSE;
     }
 
     sth = gda_sql_parser_parse_string(
-            parser,
-            "SELECT id, short_name, name FROM directions",
-            NULL,
-            NULL);
+        parser,
+        "SELECT id, short_name, name FROM directions",
+        NULL,
+        NULL);
 
     if ((res = gda_connection_statement_execute_select(
-                 dbh, sth,
-                 NULL, &local_err)) == NULL) {
+             dbh, sth,
+             NULL, &local_err)) == NULL) {
         g_set_error(err,
                     WMUD_DB_ERROR, WMUD_DB_ERROR_SELECT_ERROR,
                     "Unable to load directions: %s",
@@ -412,18 +417,18 @@ wmud_db_load_directions(GSList **directions, GError **err)
     gda_data_model_iter_move_next(iter);
 
     while (gda_data_model_iter_is_valid(iter)) {
-        const GValue *val;
+        const GValue  *val;
         wmudDirection *dir;
 
         dir = g_new0(wmudDirection, 1);
 
-        val = gda_data_model_iter_get_value_at(iter, 0);
+        val     = gda_data_model_iter_get_value_at(iter, 0);
         dir->id = g_value_get_int(val);
 
-        val = gda_data_model_iter_get_value_at(iter, 1);
+        val             = gda_data_model_iter_get_value_at(iter, 1);
         dir->short_name = g_strdup(g_value_get_string(val));
 
-        val = gda_data_model_iter_get_value_at(iter, 2);
+        val       = gda_data_model_iter_get_value_at(iter, 2);
         dir->name = g_strdup(g_value_get_string(val));
 
         g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG,
@@ -444,39 +449,40 @@ wmud_db_load_directions(GSList **directions, GError **err)
 gboolean
 wmud_db_load_areas(GSList **areas, GError **err)
 {
-    GdaStatement *sth = NULL;
-    GdaDataModel *res = NULL;
+    GdaStatement     *sth = NULL;
+    GdaDataModel     *res = NULL;
     GdaDataModelIter *iter;
 
     g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "Loading areas");
     if (dbh == NULL) {
-        if (err)
+        if (err) {
             g_set_error(err,
                         WMUD_DB_ERROR, WMUD_DB_ERROR_NOINIT,
                         "Database backend not initialized");
+        }
 
         return FALSE;
     }
 
     sth = gda_sql_parser_parse_string(
-            parser,
-            "SELECT id, name FROM areas",
-            NULL,
-            NULL);
-    res = gda_connection_statement_execute_select(dbh, sth, NULL, NULL);
+        parser,
+        "SELECT id, name FROM areas",
+        NULL,
+        NULL);
+    res  = gda_connection_statement_execute_select(dbh, sth, NULL, NULL);
     iter = gda_data_model_create_iter(res);
     gda_data_model_iter_move_next(iter);
 
     while (gda_data_model_iter_is_valid(iter)) {
         const GValue *val;
-        wmudArea *area;
+        wmudArea     *area;
 
         area = g_new0(wmudArea, 1);
 
-        val = gda_data_model_iter_get_value_at(iter, 0);
+        val      = gda_data_model_iter_get_value_at(iter, 0);
         area->id = g_value_get_int(val);
 
-        val = gda_data_model_iter_get_value_at(iter, 1);
+        val        = gda_data_model_iter_get_value_at(iter, 1);
         area->name = g_strdup(g_value_get_string(val));
 
         g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "Loaded area _%s_", area->name);
@@ -495,48 +501,49 @@ wmud_db_load_areas(GSList **areas, GError **err)
 gboolean
 wmud_db_load_rooms(GSList **rooms, GError **err)
 {
-    GdaStatement *sth = NULL;
-    GdaDataModel *res = NULL;
+    GdaStatement     *sth = NULL;
+    GdaDataModel     *res = NULL;
     GdaDataModelIter *iter;
 
     g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "Loading rooms");
     if (dbh == NULL) {
-        if (err)
+        if (err) {
             g_set_error(err,
                         WMUD_DB_ERROR, WMUD_DB_ERROR_NOINIT,
                         "Database backend not initialized");
+        }
 
         return FALSE;
     }
 
     sth = gda_sql_parser_parse_string(
-            parser,
-            "SELECT id, area, name, distant_description, close_description FROM rooms",
-            NULL,
-            NULL);
-    res = gda_connection_statement_execute_select(dbh, sth, NULL, NULL);
+        parser,
+        "SELECT id, area, name, distant_description, close_description FROM rooms",
+        NULL,
+        NULL);
+    res  = gda_connection_statement_execute_select(dbh, sth, NULL, NULL);
     iter = gda_data_model_create_iter(res);
     gda_data_model_iter_move_next(iter);
 
     while (gda_data_model_iter_is_valid(iter)) {
         const GValue *val;
-        wmudRoom *room;
+        wmudRoom     *room;
 
         room = g_new0(wmudRoom, 1);
 
-        val = gda_data_model_iter_get_value_at(iter, 0);
+        val      = gda_data_model_iter_get_value_at(iter, 0);
         room->id = g_value_get_int(val);
 
-        val = gda_data_model_iter_get_value_at(iter, 1);
+        val           = gda_data_model_iter_get_value_at(iter, 1);
         room->area_id = g_value_get_int(val);
 
-        val = gda_data_model_iter_get_value_at(iter, 2);
+        val        = gda_data_model_iter_get_value_at(iter, 2);
         room->name = g_strdup(g_value_get_string(val));
 
-        val = gda_data_model_iter_get_value_at(iter, 3);
+        val                       = gda_data_model_iter_get_value_at(iter, 3);
         room->distant_description = g_strdup(g_value_get_string(val));
 
-        val = gda_data_model_iter_get_value_at(iter, 4);
+        val                     = gda_data_model_iter_get_value_at(iter, 4);
         room->close_description = g_strdup(g_value_get_string(val));
 
         g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG,
@@ -558,42 +565,43 @@ wmud_db_load_rooms(GSList **rooms, GError **err)
 gboolean
 wmud_db_load_exits(GSList **exits, GError **err)
 {
-    GdaStatement *sth = NULL;
-    GdaDataModel *res = NULL;
+    GdaStatement     *sth = NULL;
+    GdaDataModel     *res = NULL;
     GdaDataModelIter *iter;
 
     g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "Loading exits");
     if (dbh == NULL) {
-        if (err)
+        if (err) {
             g_set_error(err,
                         WMUD_DB_ERROR, WMUD_DB_ERROR_NOINIT,
                         "Database backend not initialized");
+        }
 
         return FALSE;
     }
 
     sth = gda_sql_parser_parse_string(
-            parser,
-            "SELECT room_id, direction, other_side FROM room_exits",
-            NULL,
-            NULL);
-    res = gda_connection_statement_execute_select(dbh, sth, NULL, NULL);
+        parser,
+        "SELECT room_id, direction, other_side FROM room_exits",
+        NULL,
+        NULL);
+    res  = gda_connection_statement_execute_select(dbh, sth, NULL, NULL);
     iter = gda_data_model_create_iter(res);
     gda_data_model_iter_move_next(iter);
 
     while (gda_data_model_iter_is_valid(iter)) {
         const GValue *val;
-        wmudExit *room_exit;
+        wmudExit     *room_exit;
 
         room_exit = g_new0(wmudExit, 1);
 
-        val = gda_data_model_iter_get_value_at(iter, 0);
+        val                       = gda_data_model_iter_get_value_at(iter, 0);
         room_exit->source_room_id = g_value_get_int(val);
 
-        val = gda_data_model_iter_get_value_at(iter, 1);
+        val                     = gda_data_model_iter_get_value_at(iter, 1);
         room_exit->direction_id = g_value_get_int(val);
 
-        val = gda_data_model_iter_get_value_at(iter, 2);
+        val                            = gda_data_model_iter_get_value_at(iter, 2);
         room_exit->destination_room_id = g_value_get_int(val);
 
         g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG,
@@ -616,40 +624,41 @@ wmud_db_load_exits(GSList **exits, GError **err)
 gboolean
 wmud_db_load_planet_planes(GSList **planet_planes, GError **err)
 {
-    GdaStatement *sth = NULL;
-    GdaDataModel *res = NULL;
+    GdaStatement     *sth = NULL;
+    GdaDataModel     *res = NULL;
     GdaDataModelIter *iter;
 
     g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG,
           "Loading planet<->plane associations");
     if (dbh == NULL) {
-        if (err)
+        if (err) {
             g_set_error(err,
                         WMUD_DB_ERROR, WMUD_DB_ERROR_NOINIT,
                         "Database backend not initialized");
+        }
 
         return FALSE;
     }
 
     sth = gda_sql_parser_parse_string(
-            parser,
-            "SELECT planet_id, plane_id FROM planet_planes",
-            NULL,
-            NULL);
-    res = gda_connection_statement_execute_select(dbh, sth, NULL, NULL);
+        parser,
+        "SELECT planet_id, plane_id FROM planet_planes",
+        NULL,
+        NULL);
+    res  = gda_connection_statement_execute_select(dbh, sth, NULL, NULL);
     iter = gda_data_model_create_iter(res);
     gda_data_model_iter_move_next(iter);
 
     while (gda_data_model_iter_is_valid(iter)) {
-        const GValue *val;
+        const GValue         *val;
         wmudPlanetPlaneAssoc *planet_plane;
 
         planet_plane = g_new0(wmudPlanetPlaneAssoc, 1);
 
-        val = gda_data_model_iter_get_value_at(iter, 0);
+        val                     = gda_data_model_iter_get_value_at(iter, 0);
         planet_plane->planet_id = g_value_get_int(val);
 
-        val = gda_data_model_iter_get_value_at(iter, 1);
+        val                    = gda_data_model_iter_get_value_at(iter, 1);
         planet_plane->plane_id = g_value_get_int(val);
 
         g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG,
@@ -671,51 +680,52 @@ wmud_db_load_planet_planes(GSList **planet_planes, GError **err)
 gboolean
 wmud_db_load_menu(GSList **menu_items, GError **err)
 {
-    GdaStatement *sth = NULL;
-    GdaDataModel *res = NULL;
+    GdaStatement     *sth = NULL;
+    GdaDataModel     *res = NULL;
     GdaDataModelIter *iter;
 
     g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "Loading menu items");
     if (dbh == NULL) {
-        if (err)
+        if (err) {
             g_set_error(err,
                         WMUD_DB_ERROR, WMUD_DB_ERROR_NOINIT,
                         "Database backend not initialized");
+        }
 
         return FALSE;
     }
 
     sth = gda_sql_parser_parse_string(
-            parser,
-            "SELECT id, menuchar, need_active_char, placement, display_text, fnctn FROM menu ORDER BY placement",
-            NULL,
-            NULL);
-    res = gda_connection_statement_execute_select(dbh, sth, NULL, NULL);
+        parser,
+        "SELECT id, menuchar, need_active_char, placement, display_text, fnctn FROM menu ORDER BY placement",
+        NULL,
+        NULL);
+    res  = gda_connection_statement_execute_select(dbh, sth, NULL, NULL);
     iter = gda_data_model_create_iter(res);
     gda_data_model_iter_move_next(iter);
 
     while (gda_data_model_iter_is_valid(iter)) {
         const GValue *val;
-        wmudMenu *menu_item;
+        wmudMenu     *menu_item;
 
         menu_item = g_new0(wmudMenu, 1);
 
-        val = gda_data_model_iter_get_value_at(iter, 0);
+        val           = gda_data_model_iter_get_value_at(iter, 0);
         menu_item->id = g_value_get_int(val);
 
-        val = gda_data_model_iter_get_value_at(iter, 1);
+        val                 = gda_data_model_iter_get_value_at(iter, 1);
         menu_item->menuchar = *(g_value_get_string(val));
 
-        val = gda_data_model_iter_get_value_at(iter, 2);
+        val                         = gda_data_model_iter_get_value_at(iter, 2);
         menu_item->need_active_char = g_value_get_boolean(val);
 
-        val = gda_data_model_iter_get_value_at(iter, 3);
+        val                  = gda_data_model_iter_get_value_at(iter, 3);
         menu_item->placement = g_value_get_int(val);
 
-        val = gda_data_model_iter_get_value_at(iter, 4);
+        val             = gda_data_model_iter_get_value_at(iter, 4);
         menu_item->text = g_strdup(g_value_get_string(val));
 
-        val = gda_data_model_iter_get_value_at(iter, 5);
+        val             = gda_data_model_iter_get_value_at(iter, 5);
         menu_item->func = g_strdup(g_value_get_string(val));
 
         g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG,
diff --git a/wmud/enumtypes.c b/wmud/enumtypes.c
index 54cdad4..e52e7a4 100644
--- a/wmud/enumtypes.c
+++ b/wmud/enumtypes.c
@@ -6,28 +6,28 @@
 
 /* enumerations from "wmudclientstate.h" */
 GType
-wmud_client_state_get_type (void)
+wmud_client_state_get_type(void)
 {
-	static volatile gsize g_define_type_id__volatile = 0;
+    static volatile gsize g_define_type_id__volatile = 0;
 
-	if (g_once_init_enter(&g_define_type_id__volatile)) {
-		static const GEnumValue values[] = {
-			{ WMUD_CLIENT_STATE_FRESH, "WMUD_CLIENT_STATE_FRESH", "fresh" },
-			{ WMUD_CLIENT_STATE_PASSWAIT, "WMUD_CLIENT_STATE_PASSWAIT", "passwait" },
-			{ WMUD_CLIENT_STATE_MENU, "WMUD_CLIENT_STATE_MENU", "menu" },
-			{ WMUD_CLIENT_STATE_INGAME, "WMUD_CLIENT_STATE_INGAME", "ingame" },
-			{ WMUD_CLIENT_STATE_YESNO, "WMUD_CLIENT_STATE_YESNO", "yesno" },
-			{ WMUD_CLIENT_STATE_REGISTERING, "WMUD_CLIENT_STATE_REGISTERING", "registering" },
-			{ WMUD_CLIENT_STATE_REGEMAIL_CONFIRM, "WMUD_CLIENT_STATE_REGEMAIL_CONFIRM", "regemail-confirm" },
-			{ 0, NULL, NULL }
-		};
+    if (g_once_init_enter(&g_define_type_id__volatile)) {
+        static const GEnumValue values[] = {
+            { WMUD_CLIENT_STATE_FRESH, "WMUD_CLIENT_STATE_FRESH", "fresh" },
+            { WMUD_CLIENT_STATE_PASSWAIT, "WMUD_CLIENT_STATE_PASSWAIT", "passwait" },
+            { WMUD_CLIENT_STATE_MENU, "WMUD_CLIENT_STATE_MENU", "menu" },
+            { WMUD_CLIENT_STATE_INGAME, "WMUD_CLIENT_STATE_INGAME", "ingame" },
+            { WMUD_CLIENT_STATE_YESNO, "WMUD_CLIENT_STATE_YESNO", "yesno" },
+            { WMUD_CLIENT_STATE_REGISTERING, "WMUD_CLIENT_STATE_REGISTERING", "registering" },
+            { WMUD_CLIENT_STATE_REGEMAIL_CONFIRM, "WMUD_CLIENT_STATE_REGEMAIL_CONFIRM", "regemail-confirm" },
+            { 0, NULL, NULL }
+        };
 
-		GType g_define_type_id = g_enum_register_static(g_intern_static_string("WmudClientState"), values);
+        GType                   g_define_type_id = g_enum_register_static(g_intern_static_string("WmudClientState"), values);
 
-		g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
-	}
+        g_once_init_leave(&g_define_type_id__volatile, g_define_type_id);
+    }
 
-	return g_define_type_id__volatile;
+    return g_define_type_id__volatile;
 }
 
 
diff --git a/wmud/game-networking.c b/wmud/game-networking.c
index e595b2c..10b0cca 100644
--- a/wmud/game-networking.c
+++ b/wmud/game-networking.c
@@ -45,7 +45,7 @@
  */
 
 struct AcceptData {
-    GMainContext *context;
+    GMainContext    *context;
     GSocketListener *listener;
 };
 
@@ -54,7 +54,7 @@ struct AcceptData {
  *
  * The full #GSList of the currently connected #WmudClient objects.
  */
-GSList *clients = NULL;
+GSList        *clients = NULL;
 
 static GRegex *email_regex = NULL;
 
@@ -91,11 +91,11 @@ hup_client(WmudClient *client)
 static void
 recv_client(WmudClient *client)
 {
-    GError *err = NULL;
+    GError  *err = NULL;
     GSocket *client_socket;
-    gssize len;
-    gchar *buf2;
-    gchar *buf = g_malloc0(sizeof(gchar) * (MAX_RECV_LEN + 1));
+    gssize  len;
+    gchar   *buf2;
+    gchar   *buf = g_malloc0(sizeof(gchar) * (MAX_RECV_LEN + 1));
 
     client_socket = wmud_client_get_socket(client);
 
@@ -120,29 +120,32 @@ recv_client(WmudClient *client)
                  sloc = -1;
 
             if ((r < n) && r) {
-                if (wmud_client_get_buffer_length(client) > 0)
+                if (wmud_client_get_buffer_length(client) > 0) {
                     g_string_append_len(wmud_client_get_buffer(client),
                                         buf2,
                                         (r - buf2));
-                else
+                } else {
                     g_string_overwrite_len(
-                            wmud_client_get_buffer(client),
-                            0,
-                            buf2,
-                            (r - buf2));
+                        wmud_client_get_buffer(client),
+                        0,
+                        buf2,
+                        (r - buf2));
+                }
+
                 buf2 = r;
             } else if (n) {
-                if (wmud_client_get_buffer_length(client) > 0)
+                if (wmud_client_get_buffer_length(client) > 0) {
                     g_string_append_len(
-                            wmud_client_get_buffer(client),
-                            buf2,
-                            (n - buf2));
-                else
+                        wmud_client_get_buffer(client),
+                        buf2,
+                        (n - buf2));
+                } else {
                     g_string_overwrite_len(
-                            wmud_client_get_buffer(client),
-                            0,
-                            buf2,
-                            (n - buf2));
+                        wmud_client_get_buffer(client),
+                        0,
+                        buf2,
+                        (n - buf2));
+                }
                 buf2 = n;
             }
 
@@ -151,57 +154,67 @@ recv_client(WmudClient *client)
                 guchar c = (wmud_client_get_buffer(client)->str)[i];
 
                 if ((c >= 240) || (c == 1)) {
-                    if (sloc == -1)
+                    if (sloc == -1) {
                         sloc = i;
+                    }
                 } else {
                     if (sloc != -1) {
                         g_string_erase(
-                                wmud_client_get_buffer(client),
-                                sloc,
-                                i - sloc);
+                            wmud_client_get_buffer(client),
+                            sloc,
+                            i - sloc);
                         sloc = -1;
                     }
                 }
             }
 
-            if (sloc != -1)
+            if (sloc != -1) {
                 g_string_erase(wmud_client_get_buffer(client), sloc, -1);
+            }
 
-            switch (wmud_client_get_state(client))
-            {
+            switch (wmud_client_get_state(client)) {
                 case WMUD_CLIENT_STATE_FRESH:
                     state_fresh(client);
+
                     break;
                 case WMUD_CLIENT_STATE_PASSWAIT:
                     state_passwait(client);
+
                     break;
                 case WMUD_CLIENT_STATE_MENU:
                     state_menu(client);
+
                     break;
                 case WMUD_CLIENT_STATE_INGAME:
                     wmud_interpret_game_command(client);
+
                     break;
                 case WMUD_CLIENT_STATE_YESNO:
                     state_yesno(client);
+
                     break;
                 case WMUD_CLIENT_STATE_REGISTERING:
                     state_registering(client);
+
                     break;
                 case WMUD_CLIENT_STATE_REGEMAIL_CONFIRM:
                     state_regemail_confirm(client);
+
                     break;
             }
             g_string_erase(wmud_client_get_buffer(client), 0, -1);
 
             for (; ((*buf2 == '\r') || (*buf2 == '\n')) && *buf2; buf2++);
 
-            if (!*buf2)
+            if (!*buf2) {
                 break;
+            }
         } else {
-            if (wmud_client_get_buffer_length(client) > 0)
+            if (wmud_client_get_buffer_length(client) > 0) {
                 g_string_append(wmud_client_get_buffer(client), buf2);
-            else
+            } else {
                 g_string_overwrite(wmud_client_get_buffer(client), 0, buf2);
+            }
 
             break;
         }
@@ -222,14 +235,14 @@ recv_client(WmudClient *client)
  * Return value: this function always returns %TRUE
  */
 gboolean
-game_source_callback(GSocket *socket,
-                     GIOCondition condition,
+game_source_callback(GSocket           *socket,
+                     GIOCondition      condition,
                      struct AcceptData *accept_data)
 {
-    GSocket *client_socket;
-    GError *err = NULL;
+    GSocket        *client_socket;
+    GError         *err = NULL;
     GSocketAddress *remote_addr;
-    WmudClient *client;
+    WmudClient     *client;
 
     /* This function should never return an error. If so, it is a huge bug,
      * and will trigger a higher level error. */
@@ -247,19 +260,20 @@ game_source_callback(GSocket *socket,
 
     if ((remote_addr = g_socket_get_remote_address(client_socket, &err)) != NULL) {
         GInetAddress *addr;
-        gchar *ip_addr;
+        gchar        *ip_addr;
 
-        addr = g_inet_socket_address_get_address(G_INET_SOCKET_ADDRESS(remote_addr));
+        addr    = g_inet_socket_address_get_address(G_INET_SOCKET_ADDRESS(remote_addr));
         ip_addr = g_inet_address_to_string(addr);
         g_log(G_LOG_DOMAIN, G_LOG_LEVEL_INFO, "New game connection from %s", ip_addr);
         g_free(ip_addr);
         g_object_unref(addr);
         g_object_unref(remote_addr);
     } else {
-        if (err)
+        if (err) {
             g_log(G_LOG_DOMAIN, G_LOG_LEVEL_WARNING, "New game connection. The remote address is unknown. This is a bug. Message from upper level: %s", err->message);
-        else
+        } else {
             g_log(G_LOG_DOMAIN, G_LOG_LEVEL_WARNING, "New game connection. The remote address is unknown. This is a bug.");
+        }
     }
 
     g_clear_error(&err);
@@ -284,34 +298,34 @@ gboolean
 wmud_networking_init(guint port_number, GMainContext *game_context, GSList *menu_items, GError **err)
 {
     struct AcceptData *accept_data;
-    GSocketListener *game_listener;
-    gboolean need_ipv4_socket = TRUE;
-    GSocket *game_socket6,
-            *game_socket4;
-    GError *in_err = NULL;
-    GSource *game_net_source4 = NULL,
-            *game_net_source6 = NULL;
+    GSocketListener   *game_listener;
+    gboolean          need_ipv4_socket = TRUE;
+    GSocket           *game_socket6,
+                      *game_socket4;
+    GError            *in_err           = NULL;
+    GSource           *game_net_source4 = NULL,
+                      *game_net_source6 = NULL;
 
-    clients = NULL;
+    clients       = NULL;
     game_listener = g_socket_listener_new();
 
     /* The following snippet is borrowed from GLib 2.30's gsocketlistener.c
      * code, to create the necessary sockets to listen on both IPv4 and
      * IPv6 address */
     if ((game_socket6 = g_socket_new(G_SOCKET_FAMILY_IPV6, G_SOCKET_TYPE_STREAM, G_SOCKET_PROTOCOL_DEFAULT, NULL)) != NULL) {
-        GInetAddress *inet_address;
+        GInetAddress   *inet_address;
         GSocketAddress *address;
-        gboolean result;
+        gboolean       result;
 
         inet_address = g_inet_address_new_any(G_SOCKET_FAMILY_IPV6);
-        address = g_inet_socket_address_new(inet_address, port_number);
+        address      = g_inet_socket_address_new(inet_address, port_number);
         g_object_unref(inet_address);
 
         g_socket_set_listen_backlog(game_socket6, 10);
 
         result =
-                 g_socket_bind(game_socket6, address, TRUE, NULL)
-                 && g_socket_listen(game_socket6, NULL);
+            g_socket_bind(game_socket6, address, TRUE, NULL) &&
+            g_socket_listen(game_socket6, NULL);
 
         g_object_unref(address);
 
@@ -322,8 +336,9 @@ wmud_networking_init(guint port_number, GMainContext *game_context, GSList *menu
             return FALSE;
         }
 
-        if (g_socket_speaks_ipv4(game_socket6))
+        if (g_socket_speaks_ipv4(game_socket6)) {
             need_ipv4_socket = FALSE;
+        }
 
         game_net_source6 = g_socket_create_source(game_socket6, G_IO_IN, NULL);
 
@@ -334,26 +349,27 @@ wmud_networking_init(guint port_number, GMainContext *game_context, GSList *menu
 
     if (need_ipv4_socket) {
         if ((game_socket4 = g_socket_new(G_SOCKET_FAMILY_IPV4, G_SOCKET_TYPE_STREAM, G_SOCKET_PROTOCOL_DEFAULT, NULL)) != NULL) {
-            GInetAddress *inet_address;
+            GInetAddress   *inet_address;
             GSocketAddress *address;
-            gboolean result;
+            gboolean       result;
 
             inet_address = g_inet_address_new_any(G_SOCKET_FAMILY_IPV4);
-            address = g_inet_socket_address_new(inet_address, port_number);
+            address      = g_inet_socket_address_new(inet_address, port_number);
             g_object_unref(inet_address);
 
             g_socket_set_listen_backlog(game_socket4, 10);
 
-            result = g_socket_bind(game_socket4, address, TRUE, NULL)
-                && g_socket_listen(game_socket4, NULL);
+            result = g_socket_bind(game_socket4, address, TRUE, NULL) &&
+                     g_socket_listen(game_socket4, NULL);
 
             g_object_unref(address);
 
             if (!result) {
                 g_object_unref(game_socket4);
 
-                if (!game_socket6)
+                if (!game_socket6) {
                     g_object_unref(game_socket6);
+                }
 
                 g_log(G_LOG_DOMAIN, G_LOG_LEVEL_WARNING, "Unable to create listener IPv4 socket!\n");
 
@@ -364,15 +380,16 @@ wmud_networking_init(guint port_number, GMainContext *game_context, GSList *menu
             g_socket_listener_add_socket(game_listener, game_socket4, NULL, NULL);
         }
     } else {
-        if (game_socket6 != NULL)
+        if (game_socket6 != NULL) {
             g_clear_error(&in_err);
-        else
+        } else {
             return FALSE;
+        }
     }
 
-    accept_data = g_new(struct AcceptData, 1);
+    accept_data           = g_new(struct AcceptData, 1);
     accept_data->listener = game_listener;
-    accept_data->context = game_context;
+    accept_data->context  = game_context;
 
     if (game_net_source6) {
         g_source_set_callback(game_net_source6, (GSourceFunc)game_source_callback, (gpointer)accept_data, NULL);
@@ -423,12 +440,12 @@ state_fresh(WmudClient *client)
 
         if ((player = wmud_player_exists(wmud_client_get_buffer(client)->str)) != NULL) {
             g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "Trying to"
-                      " login with playername '%s'",
-                      wmud_client_get_buffer(client)->str);
+                                                   " login with playername '%s'",
+                  wmud_client_get_buffer(client)->str);
 
             if (wmud_player_get_cpassword(player) == NULL) {
                 wmud_client_send(client, "Your registration is"
-                                 " not finished yet.\r\n");
+                                         " not finished yet.\r\n");
                 remove_client(client, TRUE);
             } else {
                 wmud_client_set_state(client, WMUD_CLIENT_STATE_PASSWAIT);
@@ -457,21 +474,21 @@ state_passwait(WmudClient *client)
         player = wmud_client_get_player(client);
 
         if (wmud_player_password_valid(player, wmud_client_get_buffer(client)->str)) {
-            gint fail_count;
+            gint           fail_count;
             GSocketAddress *socket_address;
-            GInetAddress *inet_address;
-            gchar *ip_addr;
-            GError *err = NULL;
+            GInetAddress   *inet_address;
+            gchar          *ip_addr;
+            GError         *err = NULL;
 
             wmud_client_send(client, "%c%c%c\r\nLogin successful."
-                     "\r\n", TELNET_IAC, TELNET_WONT,
+                                     "\r\n", TELNET_IAC, TELNET_WONT,
                              TELNET_ECHO);
             wmud_client_set_authenticated(client, TRUE);
 
             socket_address = g_socket_get_remote_address(wmud_client_get_socket(client), &err);
             g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "socket family: %d", g_socket_address_get_family(socket_address));
             inet_address = g_object_ref(g_inet_socket_address_get_address(G_INET_SOCKET_ADDRESS(socket_address)));
-            ip_addr = g_inet_address_to_string(inet_address);
+            ip_addr      = g_inet_address_to_string(inet_address);
 
             g_log(G_LOG_DOMAIN, G_LOG_LEVEL_INFO, "Login by %s from %s", wmud_player_get_player_name(player), ip_addr);
 
@@ -480,30 +497,30 @@ state_passwait(WmudClient *client)
 
             if ((fail_count = wmud_player_get_fail_count(player)) > 0) {
                 wmud_client_send(client, "There %s %d failed"
-                                 " login attempt%s with your"
-                                 " account since your last"
-                                 " visit\r\n",
-                         (fail_count == 1) ? "was" : "were",
-                         fail_count,
-                         (fail_count == 1) ? "" : "s");
+                                         " login attempt%s with your"
+                                         " account since your last"
+                                         " visit\r\n",
+                                 (fail_count == 1) ? "was" : "were",
+                                 fail_count,
+                                 (fail_count == 1) ? "" : "s");
             }
 
             wmud_text_send_to_client("motd", client);
             wmud_menu_present(client);
         } else {
             wmud_client_send(client, "%c%c%cThis password doesn't"
-                             " seem to be valid. Let's try it again..."
-                             " \r\nBy what name would you like to be"
-                     " be called? ", TELNET_IAC,
-                     TELNET_WONT, TELNET_ECHO);
+                                     " seem to be valid. Let's try it again..."
+                                     " \r\nBy what name would you like to be"
+                                     " be called? ", TELNET_IAC,
+                             TELNET_WONT, TELNET_ECHO);
             wmud_client_set_state(client, WMUD_CLIENT_STATE_FRESH);
             wmud_player_increase_fail_count(player);
             wmud_client_increase_login_fail_count(client);
             if (wmud_client_get_login_fail_count(client) == 3) {
                 wmud_client_send(client, "You are trying "
-                         " these bad passwords for"
-                         " too many times. Please"
-                         " stop that!\r\n");
+                                         " these bad passwords for"
+                                         " too many times. Please"
+                                         " stop that!\r\n");
                 remove_client(client, TRUE);
 
                 /* TODO: Increase IP fail count, and ban IP if it's too high */
@@ -515,7 +532,7 @@ state_passwait(WmudClient *client)
         }
     } else {
         wmud_client_send(client, "\r\nEmpty passwords are"
-                 " not valid.\r\nTry again: ");
+                                 " not valid.\r\nTry again: ");
     }
 }
 
@@ -524,51 +541,55 @@ state_menu(WmudClient *client)
 {
     gchar *menu_command;
 
-    if ((menu_command = wmud_menu_get_command_by_menuchar(*(wmud_client_get_buffer(client)->str), game_menu)) != NULL)
+    if ((menu_command = wmud_menu_get_command_by_menuchar(*(wmud_client_get_buffer(client)->str), game_menu)) != NULL) {
         wmud_menu_execute_command(client, menu_command);
-    else
+    } else {
         wmud_client_send(client, "Unknown menu command.\r\n");
+    }
 }
 
 static void
 state_yesno(WmudClient *client)
 {
-    if (g_ascii_strcasecmp(wmud_client_get_buffer(client)->str, "y") == 0)
+    if (g_ascii_strcasecmp(wmud_client_get_buffer(client)->str, "y") == 0) {
         (wmud_client_get_yesno_callback(client))(client, TRUE);
-    else if (g_ascii_strcasecmp(wmud_client_get_buffer(client)->str, "n") == 0)
+    } else if (g_ascii_strcasecmp(wmud_client_get_buffer(client)->str, "n") == 0) {
         (wmud_client_get_yesno_callback(client))(client, FALSE);
-    else
+    } else {
         wmud_client_send(client, "Please enter a 'Y' or 'N'"
-             " character: ");
+                                 " character: ");
+    }
 }
 
 static void
 state_registering(WmudClient *client)
 {
-    if (!*(wmud_client_get_buffer(client)->str) && (wmud_client_get_bademail(client) == TRUE))
+    if (!*(wmud_client_get_buffer(client)->str) && (wmud_client_get_bademail(client) == TRUE)) {
         remove_client(client, TRUE);
+    }
 
     if (g_regex_match(email_regex, wmud_client_get_buffer(client)->str, 0, NULL)) {
         wmud_player_set_email(wmud_client_get_player(client), wmud_client_get_buffer(client)->str);
         wmud_client_set_state(client, WMUD_CLIENT_STATE_REGEMAIL_CONFIRM);
         wmud_client_send(client, "It seems to be a valid"
-                 " address to me, but could you"
-                 " write it again? ");
+                                 " address to me, but could you"
+                                 " write it again? ");
     } else {
         wmud_client_send(client, "\r\nSorry, but this"
-                 "e-mail address doesn't seem to be"
-                 " valid to me.\r\n\r\nIf you think"
-                 " this is a valid address, simply"
-                 " press enter to quit, and send an"
-                 " e-mail to %s from that address,"
-                 " so we can fix our e-mail"
-                 " validation code.\r\n\r\nIf you"
-                 " just mistyped your address, type"
-                 " it now: ",
-                 active_config->admin_email);
+                                 "e-mail address doesn't seem to be"
+                                 " valid to me.\r\n\r\nIf you think"
+                                 " this is a valid address, simply"
+                                 " press enter to quit, and send an"
+                                 " e-mail to %s from that address,"
+                                 " so we can fix our e-mail"
+                                 " validation code.\r\n\r\nIf you"
+                                 " just mistyped your address, type"
+                                 " it now: ",
+                         active_config->admin_email);
 
-        if (*(wmud_client_get_buffer(client)->str))
+        if (*(wmud_client_get_buffer(client)->str)) {
             wmud_client_set_bademail(client, TRUE);
+        }
     }
 }
 
@@ -594,4 +615,3 @@ state_regemail_confirm(WmudClient *client)
         wmud_client_set_state(client, WMUD_CLIENT_STATE_REGISTERING);
     }
 }
-
diff --git a/wmud/game.c b/wmud/game.c
index 97427e3..b4c0a03 100644
--- a/wmud/game.c
+++ b/wmud/game.c
@@ -106,12 +106,12 @@ gboolean
 wmud_game_init(GThread **game_thread, GMainContext **game_context)
 {
     GMainLoop *game_loop;
-    GSource *timeout_source;
-    GError *err = NULL;
+    GSource   *timeout_source;
+    GError    *err = NULL;
 
     /* Create the game context and main loop */
     *game_context = g_main_context_new();
-    game_loop = g_main_loop_new(*game_context, FALSE);
+    game_loop     = g_main_loop_new(*game_context, FALSE);
 
     /* Create the timeout source which keeps track of elapsed real-world
      * time */
diff --git a/wmud/interpreter.c b/wmud/interpreter.c
index e736c38..b964345 100644
--- a/wmud/interpreter.c
+++ b/wmud/interpreter.c
@@ -35,20 +35,20 @@
 WMUD_COMMAND(quit);
 
 struct findData {
-	GSList *list;
-	guint found;
-	gchar *last;
+    GSList *list;
+    guint  found;
+    gchar  *last;
 };
 
 static wmudCommand command_list[] = {
-	{ "quit", gcmd_quit },
-	{ NULL,   NULL },
+    { "quit", gcmd_quit },
+    { NULL,   NULL },
 };
 
 GQuark
 wmud_interpreter_error_quark()
 {
-	return g_quark_from_static_string("wmud-interpreter-error");
+    return g_quark_from_static_string("wmud-interpreter-error");
 }
 
 /**
@@ -60,56 +60,60 @@ wmud_interpreter_error_quark()
 static void
 destroy_string(GString *string)
 {
-	g_string_free(string, TRUE);
+    g_string_free(string, TRUE);
 }
 
 static gint
 check_direction_dups2(wmudDirection *dir1, wmudDirection *dir2)
 {
-	gint check;
+    gint check;
 
-	if ((check = g_ascii_strcasecmp(dir1->short_name, dir2->short_name)) != 0)
-		return check;
+    if ((check = g_ascii_strcasecmp(dir1->short_name, dir2->short_name)) != 0) {
+        return check;
+    }
 
-	if ((check = g_ascii_strcasecmp(dir1->name, dir2->name)) != 0)
-		return check;
+    if ((check = g_ascii_strcasecmp(dir1->name, dir2->name)) != 0) {
+        return check;
+    }
 
-	if ((check = g_ascii_strcasecmp(dir1->short_name, dir2->name)) != 0)
-		return check;
+    if ((check = g_ascii_strcasecmp(dir1->short_name, dir2->name)) != 0) {
+        return check;
+    }
 
-	return g_ascii_strcasecmp(dir1->name, dir2->short_name);
+    return g_ascii_strcasecmp(dir1->name, dir2->short_name);
 }
 
 static void
 check_direction_dups1(wmudDirection *dir, struct findData *find_data)
 {
-	if (find_data->last != dir->name) {
-		find_data->found = (find_data->found > 1) ? find_data->found : 0;
-		find_data->last = dir->name;
-	}
+    if (find_data->last != dir->name) {
+        find_data->found = (find_data->found > 1) ? find_data->found : 0;
+        find_data->last  = dir->name;
+    }
 
-	if (g_slist_find_custom(find_data->list, dir, (GCompareFunc)check_direction_dups2))
-		find_data->found++;
+    if (g_slist_find_custom(find_data->list, dir, (GCompareFunc)check_direction_dups2)) {
+        find_data->found++;
+    }
 }
 
 static void
 check_direction_command(wmudDirection *dir, gboolean *found)
 {
-	wmudCommand *cmd;
+    wmudCommand *cmd;
 
-	for (cmd = command_list; cmd->command; cmd++) {
-		if (g_ascii_strcasecmp(dir->short_name, cmd->command) == 0) {
-			*found = TRUE;
+    for (cmd = command_list; cmd->command; cmd++) {
+        if (g_ascii_strcasecmp(dir->short_name, cmd->command) == 0) {
+            *found = TRUE;
 
-			return;
-		}
+            return;
+        }
 
-		if (g_ascii_strcasecmp(dir->name, cmd->command) == 0) {
-			*found = TRUE;
+        if (g_ascii_strcasecmp(dir->name, cmd->command) == 0) {
+            *found = TRUE;
 
-			return;
-		}
-	}
+            return;
+        }
+    }
 }
 
 /**
@@ -119,31 +123,31 @@ check_direction_command(wmudDirection *dir, gboolean *found)
  *
  * Checks if the given directions are already registered commands.
  *
- * Return value: If the directions are acceptable at the time of the check, the function returns %TRUE. Otherwise %FALSE is returned, and 
+ * Return value: If the directions are acceptable at the time of the check, the function returns %TRUE. Otherwise %FALSE is returned, and
  */
 gboolean
 wmud_interpreter_check_directions(GSList *directions, GError **err)
 {
-	gboolean command_found = FALSE;
-	struct findData find_data = {directions, 0, NULL};
+    gboolean        command_found = FALSE;
+    struct findData find_data     = {directions, 0, NULL};
 
-	g_slist_foreach(directions, (GFunc)check_direction_command, &command_found);
+    g_slist_foreach(directions, (GFunc)check_direction_command, &command_found);
 
-	if (command_found) {
-		g_set_error(err, WMUD_INTERPRETER_ERROR, WMUD_INTERPRETER_ERROR_DUPCMD, "Direction commands are not unique. Please check the database!");
-		g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "Direction command are not unique. Please check the database!");
-	}
+    if (command_found) {
+        g_set_error(err, WMUD_INTERPRETER_ERROR, WMUD_INTERPRETER_ERROR_DUPCMD, "Direction commands are not unique. Please check the database!");
+        g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "Direction command are not unique. Please check the database!");
+    }
 
-	g_slist_foreach(directions, (GFunc)check_direction_dups1, &find_data);
+    g_slist_foreach(directions, (GFunc)check_direction_dups1, &find_data);
 
-	if (find_data.found > 1) {
-		g_set_error(err, WMUD_INTERPRETER_ERROR, WMUD_INTERPRETER_ERROR_DUPCMD, "Direction commands defined in the database are not unique!");
-		g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "Direction commands defined in the databsae are not unique.");
+    if (find_data.found > 1) {
+        g_set_error(err, WMUD_INTERPRETER_ERROR, WMUD_INTERPRETER_ERROR_DUPCMD, "Direction commands defined in the database are not unique!");
+        g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "Direction commands defined in the databsae are not unique.");
 
-		return FALSE;
-	}
+        return FALSE;
+    }
 
-	return !command_found;
+    return !command_found;
 }
 
 /**
@@ -156,132 +160,138 @@ wmud_interpreter_check_directions(GSList *directions, GError **err)
 void
 wmud_interpret_game_command(WmudClient *client)
 {
-	GSList *command_parts = NULL;
-	gchar *a,
-	      *start,
-	      *end;
-	gchar str_delim = 0;
-	wmudCommand *cmd;
-	int command_parts_count = 0,
-	    match_count = 0;
-	GSList *matches = NULL;
+    GSList *command_parts = NULL;
+    gchar  *a,
+           *start,
+           *end;
+    gchar       str_delim = 0;
+    wmudCommand *cmd;
+    int         command_parts_count = 0,
+                match_count         = 0;
+    GSList      *matches            = NULL;
 
-	if (strchr(wmud_client_get_buffer(client)->str, '\r') || strchr(wmud_client_get_buffer(client)->str, '\n')) {
-		/* We should NEVER reach this point! */
-		g_assert_not_reached();
+    if (strchr(wmud_client_get_buffer(client)->str, '\r') || strchr(wmud_client_get_buffer(client)->str, '\n')) {
+        /* We should NEVER reach this point! */
+        g_assert_not_reached();
 
-		return;
-	}
+        return;
+    }
 
-	a = wmud_client_get_buffer(client)->str;
+    a = wmud_client_get_buffer(client)->str;
 
-	GString *token;
+    GString *token;
 
-	while (*a) {
-		for (start = a; *start; start++) {
-			if (!str_delim) {
-				if ((*start == '"') || (*start == '\'')) {
-					str_delim = *start;
-					start++;
+    while (*a) {
+        for (start = a; *start; start++) {
+            if (!str_delim) {
+                if ((*start == '"') || (*start == '\'')) {
+                    str_delim = *start;
+                    start++;
 
-					break;
-				} else if (g_ascii_isspace(*start) || (!*start)) {
-					break;
-				}
-			}
-		}
+                    break;
+                } else if (g_ascii_isspace(*start) || (!*start)) {
+                    break;
+                }
+            }
+        }
 
-		for (end = start; *end; end++) {
-			if (!str_delim && strchr("'\" \t", *end)) {
-				break;
-			} else if (str_delim && (*end == str_delim)) {
-				str_delim = 0;
+        for (end = start; *end; end++) {
+            if (!str_delim && strchr("'\" \t", *end)) {
+                break;
+            } else if (str_delim && (*end == str_delim)) {
+                str_delim = 0;
 
-				break;
-			} else if (!*end) {
-				break;
-			}
-		}
+                break;
+            } else if (!*end) {
+                break;
+            }
+        }
 
-		if (*start) {
-			token = g_string_new_len(start, end - start);
-			command_parts = g_slist_prepend(command_parts, token);
-			command_parts_count++;
-		}
+        if (*start) {
+            token         = g_string_new_len(start, end - start);
+            command_parts = g_slist_prepend(command_parts, token);
+            command_parts_count++;
+        }
 
-		a = end;
-		if (((*a == '"') || (*a == '\'')) && str_delim)
-			a++;
-	}
+        a = end;
+        if (((*a == '"') || (*a == '\'')) && str_delim) {
+            a++;
+        }
+    }
 
-	if (str_delim) {
-		wmud_client_send(client, "You should close quotes of any kind, like %c, shouldn't you?\r\n", str_delim);
+    if (str_delim) {
+        wmud_client_send(client, "You should close quotes of any kind, like %c, shouldn't you?\r\n", str_delim);
 #if GLIB_CHECK_VERSION(2, 28, 0)
-		g_slist_free_full(command_parts, (GDestroyNotify)destroy_string);
+        g_slist_free_full(command_parts, (GDestroyNotify)destroy_string);
 #else
-		g_slist_foreach(command_parts, (GFunc)destroy_string, NULL);
-		g_slist_free(command_parts);
+        g_slist_foreach(command_parts, (GFunc)destroy_string, NULL);
+        g_slist_free(command_parts);
 #endif
-		return;
-	}
+        return;
+    }
 
-	if (command_parts_count == 0) {
-		/* TODO: handle empty command */
+    if (command_parts_count == 0) {
+        /* TODO: handle empty command */
 
-		return;
-	}
+        return;
+    }
 
-	command_parts = g_slist_reverse(command_parts);
+    command_parts = g_slist_reverse(command_parts);
 
-	for (cmd = command_list; cmd->command; cmd++) {
-		GString *input = (GString *)(command_parts->data);
-		gint cmp;
+    for (cmd = command_list; cmd->command; cmd++) {
+        GString *input = (GString *)(command_parts->data);
+        gint    cmp;
 
-		if (((cmp = g_ascii_strncasecmp(input->str, cmd->command, input->len)) == 0) && !cmd->command[input->len]) {
-			g_slist_free(matches);
-			match_count = 1;
-			matches = NULL;
-			matches = g_slist_prepend(matches, cmd);
+        if (((cmp = g_ascii_strncasecmp(input->str, cmd->command, input->len)) == 0) && !cmd->command[input->len]) {
+            g_slist_free(matches);
+            match_count = 1;
+            matches     = NULL;
+            matches     = g_slist_prepend(matches, cmd);
 
-			break;
-		} else if (cmp == 0) {
-			matches = g_slist_prepend(matches, cmd);
-			match_count++;
-		}
-	}
+            break;
+        } else if (cmp == 0) {
+            matches = g_slist_prepend(matches, cmd);
+            match_count++;
+        }
+    }
 
-	switch (match_count) {
-		case 0:
-			switch (random_number(1, 3)) {
-				case 1:
-					wmud_client_send(client, "Huh?\r\n");
-					break;
-				case 2:
-					wmud_client_send(client, "What?\r\n");
-					break;
-				case 3:
-					wmud_client_send(client, "I can hardly understand you...\r\n");
-					break;
-			}
-			break;
-		case 1:
-			((wmudCommand *)(matches->data))->commandFunc(client, ((GString *)(command_parts->data))->str, command_parts->next);
-			break;
-		default:
-			wmud_client_send(client, "This command could mean several things, please try a more exact form!\r\n");
-	}
+    switch (match_count) {
+        case 0:
+            switch (random_number(1, 3)) {
+                case 1:
+                    wmud_client_send(client, "Huh?\r\n");
 
-	g_slist_free(matches);
+                    break;
+                case 2:
+                    wmud_client_send(client, "What?\r\n");
+
+                    break;
+                case 3:
+                    wmud_client_send(client, "I can hardly understand you...\r\n");
+
+                    break;
+            }
+
+            break;
+        case 1:
+            ((wmudCommand *)(matches->data))->commandFunc(client, ((GString *)(command_parts->data))->str, command_parts->next);
+
+            break;
+        default:
+            wmud_client_send(client, "This command could mean several things, please try a more exact form!\r\n");
+    }
+
+    g_slist_free(matches);
 }
 
 /**
  * gcmd_quit:
- * 
+ *
  * The QUIT game command's handler
  */
 WMUD_COMMAND(quit)
 {
-	wmud_client_send(client, "Are you sure you want to get back to that freaky other reality? [y/N] ");
-	wmud_client_set_state(client, WMUD_CLIENT_STATE_YESNO);
-	wmud_client_set_yesno_callback(client, wmud_client_quitanswer);
+    wmud_client_send(client, "Are you sure you want to get back to that freaky other reality? [y/N] ");
+    wmud_client_set_state(client, WMUD_CLIENT_STATE_YESNO);
+    wmud_client_set_yesno_callback(client, wmud_client_quitanswer);
 }
diff --git a/wmud/main.c b/wmud/main.c
index bc78578..32c250a 100644
--- a/wmud/main.c
+++ b/wmud/main.c
@@ -53,7 +53,7 @@
  */
 struct {
     char *file;
-    int line;
+    int  line;
 } debug_context_loc = {NULL, 0};
 
 /**
@@ -66,15 +66,16 @@ gchar *
 wmud_random_string(gint len)
 {
     gchar *ret = g_malloc0(len + 1);
-    gint i;
+    gint  i;
 
     for (i = 0; i < len; i++) {
         gchar c = 0;
         /* Include only printable characters, but exclude $ because of
          * salt generation, and space to avoid misunderstanding in the
          * random generated passwords */
-        while (!g_ascii_isprint(c) || (c == '$') || (c == ' ') || (c == '\t'))
+        while (!g_ascii_isprint(c) || (c == '$') || (c == ' ') || (c == '\t')) {
             c = random_number(1, 127);
+        }
 
         ret[i] = c;
     }
@@ -97,8 +98,9 @@ void
  */
 debug_context(char *file, int line)
 {
-    if (debug_context_loc.file != NULL)
+    if (debug_context_loc.file != NULL) {
         g_free(debug_context_loc.file);
+    }
 
     debug_context_loc.file = g_strdup(file);
     debug_context_loc.line = line;
@@ -125,19 +127,19 @@ wmud_type_init(void)
 {}
 
 void
-wmud_logger(const gchar *log_domain,
+wmud_logger(const gchar    *log_domain,
             GLogLevelFlags log_level,
-            const gchar *message,
-            gpointer user_data)
+            const gchar    *message,
+            gpointer       user_data)
 {
     static char timestamp[20];
-    struct tm *tm;
-    time_t ts = time(NULL);
-    size_t last_char;
+    struct tm   *tm;
+    time_t      ts = time(NULL);
+    size_t      last_char;
 
     tm = localtime(&ts);
 
-    last_char = strftime((char *)&timestamp, 20, "%F %T", tm);
+    last_char            = strftime((char *)&timestamp, 20, "%F %T", tm);
     timestamp[last_char] = '\0';
 
     switch (log_level) {
@@ -200,12 +202,12 @@ wmud_logger(const gchar *log_domain,
 int
 main(int argc, char **argv)
 {
-    GError *err = NULL;
-    GThread *game_thread;
+    GError       *err = NULL;
+    GThread      *game_thread;
     GMainContext *game_context;
-    GSList *game_menu = NULL;
+    GSList       *game_menu = NULL;
 
-    g_log_set_handler(G_LOG_DOMAIN, G_LOG_LEVEL_MASK , wmud_logger, NULL);
+    g_log_set_handler(G_LOG_DOMAIN, G_LOG_LEVEL_MASK, wmud_logger, NULL);
     /* Initialize the thread and type system */
     wmud_type_init();
 
diff --git a/wmud/maintenance.c b/wmud/maintenance.c
index 4f26a3f..5fb3680 100644
--- a/wmud/maintenance.c
+++ b/wmud/maintenance.c
@@ -52,30 +52,30 @@
 void
 wmud_maintenance_check_players(WmudPlayer *player, gpointer user_data)
 {
-	if (wmud_player_get_cpassword(player) == NULL) {
-		gchar *pw,
-		      *salt,
-		      *cpw;
-		GString *full_salt;
+    if (wmud_player_get_cpassword(player) == NULL) {
+        gchar *pw,
+              *salt,
+              *cpw;
+        GString *full_salt;
 
-		pw = wmud_random_string(8);
-		salt = wmud_random_string(8);
-		full_salt = g_string_new("$1$");
-		g_string_append(full_salt, salt);
-		cpw = g_strdup(crypt(pw, full_salt->str));
+        pw        = wmud_random_string(8);
+        salt      = wmud_random_string(8);
+        full_salt = g_string_new("$1$");
+        g_string_append(full_salt, salt);
+        cpw = g_strdup(crypt(pw, full_salt->str));
 
-		g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "Player %s has no"
-				" password set", wmud_player_get_player_name(player));
-		g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "New password will be %s", pw);
-		wmud_player_set_cpassword(player, cpw);
-		/* TODO: Send e-mail about the new password. Upon completion, set it in
-		 * the database */
-		wmud_db_update_player_password(player, cpw, NULL);
+        g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "Player %s has no"
+                                               " password set", wmud_player_get_player_name(player));
+        g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "New password will be %s", pw);
+        wmud_player_set_cpassword(player, cpw);
+        /* TODO: Send e-mail about the new password. Upon completion, set it in
+         * the database */
+        wmud_db_update_player_password(player, cpw, NULL);
 
-		g_free(pw);
-		g_free(salt);
-		g_string_free(full_salt, TRUE);
-	}
+        g_free(pw);
+        g_free(salt);
+        g_string_free(full_salt, TRUE);
+    }
 }
 
 /**
@@ -87,14 +87,14 @@ wmud_maintenance_check_players(WmudPlayer *player, gpointer user_data)
 gboolean
 wmud_maintenance(gpointer user_data)
 {
-	g_log(G_LOG_DOMAIN, G_LOG_LEVEL_INFO, "Starting maintenance...");
-	/* Run through the player list, and generate a random password for each
-	 * newly registered player */
-	g_slist_foreach(players, (GFunc)wmud_maintenance_check_players, NULL);
+    g_log(G_LOG_DOMAIN, G_LOG_LEVEL_INFO, "Starting maintenance...");
+    /* Run through the player list, and generate a random password for each
+     * newly registered player */
+    g_slist_foreach(players, (GFunc)wmud_maintenance_check_players, NULL);
 
-	g_log(G_LOG_DOMAIN, G_LOG_LEVEL_INFO, "Finished maintenance...");
+    g_log(G_LOG_DOMAIN, G_LOG_LEVEL_INFO, "Finished maintenance...");
 
-	return TRUE;
+    return TRUE;
 }
 
 /**
@@ -108,102 +108,106 @@ wmud_maintenance(gpointer user_data)
 gpointer
 maint_thread_func(GMainLoop *maint_loop)
 {
-	g_main_loop_run(maint_loop);
+    g_main_loop_run(maint_loop);
 
-	return NULL;
+    return NULL;
 }
 
 const char *text[] = {
-	"To: Polonkai Gergely <polonkai.gergely@brokernet-group.com>\n",
-	"Subject: Teszt\n",
-	"\n",
-	"Hello!\n"
+    "To: Polonkai Gergely <polonkai.gergely@brokernet-group.com>\n",
+    "Subject: Teszt\n",
+    "\n",
+    "Hello!\n"
 };
 
 struct WriteThis {
-	int counter;
+    int counter;
 };
 
 static size_t
 wmud_smtp_read_callback(void *ptr, size_t size, size_t nmemb, void *userp)
 {
-	struct WriteThis *pooh = (struct WriteThis *)userp;
-	const char *data;
+    struct WriteThis *pooh = (struct WriteThis *)userp;
+    const char       *data;
 
-	if (size * nmemb < 1)
-		return 0;
+    if (size * nmemb < 1) {
+        return 0;
+    }
 
-	data = text[pooh->counter];
+    data = text[pooh->counter];
 
-	if (data) {
-		size_t len = strlen(data);
-		memcpy(ptr, data, len);
-		pooh->counter++;
-		return len;
-	}
+    if (data) {
+        size_t len = strlen(data);
+        memcpy(ptr, data, len);
+        pooh->counter++;
 
-	return 0;
+        return len;
+    }
+
+    return 0;
 }
 
 void
 wmud_maintenance_init(void)
 {
-	GSource *timeout_source;
-	GMainLoop *maint_loop;
-	GMainContext *maint_context;
-	CURL *curl;
-	CURLM *mcurl;
-	gchar *smtp_server_real;
-	struct WriteThis pooh = {0};
+    GSource          *timeout_source;
+    GMainLoop        *maint_loop;
+    GMainContext     *maint_context;
+    CURL             *curl;
+    CURLM            *mcurl;
+    gchar            *smtp_server_real;
+    struct WriteThis pooh = {0};
 
-	curl_global_init(CURL_GLOBAL_DEFAULT);
+    curl_global_init(CURL_GLOBAL_DEFAULT);
 
-	if (!(curl = curl_easy_init()))
-		g_error("Could not initialize the CURL library!");
+    if (!(curl = curl_easy_init())) {
+        g_error("Could not initialize the CURL library!");
+    }
 
-	if (!(mcurl = curl_multi_init()))
-		g_error("Could not initialize the CURL library!");
+    if (!(mcurl = curl_multi_init())) {
+        g_error("Could not initialize the CURL library!");
+    }
 
-	smtp_server_real = g_strconcat("smtp://", active_config->smtp_server, NULL);
-	curl_easy_setopt(curl, CURLOPT_URL, smtp_server_real);
-	g_free(smtp_server_real);
+    smtp_server_real = g_strconcat("smtp://", active_config->smtp_server, NULL);
+    curl_easy_setopt(curl, CURLOPT_URL, smtp_server_real);
+    g_free(smtp_server_real);
 
-	if (active_config->smtp_username && active_config->smtp_password) {
-		curl_easy_setopt(curl, CURLOPT_USERNAME, active_config->smtp_username);
-		curl_easy_setopt(curl, CURLOPT_PASSWORD, active_config->smtp_password);
-	}
+    if (active_config->smtp_username && active_config->smtp_password) {
+        curl_easy_setopt(curl, CURLOPT_USERNAME, active_config->smtp_username);
+        curl_easy_setopt(curl, CURLOPT_PASSWORD, active_config->smtp_password);
+    }
 
-	curl_easy_setopt(curl, CURLOPT_MAIL_FROM, active_config->smtp_sender);
-	curl_easy_setopt(curl, CURLOPT_USE_SSL, (CURLUSESSL_ALL && active_config->smtp_tls));
+    curl_easy_setopt(curl, CURLOPT_MAIL_FROM, active_config->smtp_sender);
+    curl_easy_setopt(curl, CURLOPT_USE_SSL, (CURLUSESSL_ALL && active_config->smtp_tls));
 
-	/* TODO: Maybe these could go into the configuration as well */
+    /* TODO: Maybe these could go into the configuration as well */
 
-	curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 0L);
-	curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, 0L);
-	curl_easy_setopt(curl, CURLOPT_SSLVERSION, 0L);
-	curl_easy_setopt(curl, CURLOPT_SSL_SESSIONID_CACHE, 0L);
+    curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 0L);
+    curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, 0L);
+    curl_easy_setopt(curl, CURLOPT_SSLVERSION, 0L);
+    curl_easy_setopt(curl, CURLOPT_SSL_SESSIONID_CACHE, 0L);
 #ifdef DEBUG
-	curl_easy_setopt(curl, CURLOPT_VERBOSE, 1L);
+    curl_easy_setopt(curl, CURLOPT_VERBOSE, 1L);
 #else
-	curl_easy_setopt(curl, CURLOPT_VERBOSE, 0L);
+    curl_easy_setopt(curl, CURLOPT_VERBOSE, 0L);
 #endif
-	curl_easy_setopt(curl, CURLOPT_READFUNCTION, wmud_smtp_read_callback);
-	curl_easy_setopt(curl, CURLOPT_READDATA, &pooh);
-	curl_multi_add_handle(mcurl, curl);
+    curl_easy_setopt(curl, CURLOPT_READFUNCTION, wmud_smtp_read_callback);
+    curl_easy_setopt(curl, CURLOPT_READDATA, &pooh);
+    curl_multi_add_handle(mcurl, curl);
 
-	/* Create the maintenance context and main loop */
-	maint_context = g_main_context_new();
-	maint_loop = g_main_loop_new(maint_context, FALSE);
+    /* Create the maintenance context and main loop */
+    maint_context = g_main_context_new();
+    maint_loop    = g_main_loop_new(maint_context, FALSE);
 
-	/* Create the timeout source which will do the maintenance tasks */
-	timeout_source = g_timeout_source_new_seconds(WMUD_MAINTENANCE_TIME);
-	g_source_set_callback(timeout_source, wmud_maintenance, NULL, NULL);
-	g_source_attach(timeout_source, maint_context);
-	g_source_unref(timeout_source);
+    /* Create the timeout source which will do the maintenance tasks */
+    timeout_source = g_timeout_source_new_seconds(WMUD_MAINTENANCE_TIME);
+    g_source_set_callback(timeout_source, wmud_maintenance, NULL, NULL);
+    g_source_attach(timeout_source, maint_context);
+    g_source_unref(timeout_source);
 
 #if GLIB_CHECK_VERSION(2, 32, 0)
-	g_thread_new("maintenance", (GThreadFunc)maint_thread_func, maint_loop);
+    g_thread_new("maintenance", (GThreadFunc)maint_thread_func, maint_loop);
 #else
-	g_thread_create((GThreadFunc)maint_thread_func, maint_loop, TRUE, NULL);
+    g_thread_create((GThreadFunc)maint_thread_func, maint_loop, TRUE, NULL);
 #endif
 }
diff --git a/wmud/menu.c b/wmud/menu.c
index 932bfb8..1ae7788 100644
--- a/wmud/menu.c
+++ b/wmud/menu.c
@@ -46,98 +46,103 @@ GSList *game_menu = NULL;
 GQuark
 wmud_menu_error_quark()
 {
-	return g_quark_from_static_string("wmud-menu-error");
+    return g_quark_from_static_string("wmud-menu-error");
 }
 
 gboolean
 wmud_menu_items_check(GSList *menu_items, GError **err)
 {
-	/* TODO: Check for duplicate menuchars */
-	/* TODO: Check for duplicate menu texts */
-	/* TODO: Check for duplicate placements */
+    /* TODO: Check for duplicate menuchars */
+    /* TODO: Check for duplicate menu texts */
+    /* TODO: Check for duplicate placements */
 
-	return TRUE;
+    return TRUE;
 }
 
 void
 menu_item_free(wmudMenu *menu_item)
 {
-	if (menu_item->text)
-		g_free(menu_item->text);
+    if (menu_item->text) {
+        g_free(menu_item->text);
+    }
 
-	if (menu_item->display_text)
-		g_free(menu_item->display_text);
+    if (menu_item->display_text) {
+        g_free(menu_item->display_text);
+    }
 
-	if (menu_item->display_text_ansi)
-		g_free(menu_item->display_text_ansi);
+    if (menu_item->display_text_ansi) {
+        g_free(menu_item->display_text_ansi);
+    }
 
-	if (menu_item->func)
-		g_free(menu_item->func);
+    if (menu_item->func) {
+        g_free(menu_item->func);
+    }
 
-	g_free(menu_item);
+    g_free(menu_item);
 }
 
 void
 wmud_menu_items_free(GSList **menu_items)
 {
-	if (menu_items)
-	{
+    if (menu_items) {
 #if GLIB_CHECK_VERSION(2, 28, 0)
-		g_slist_free_full(*menu_items, (GDestroyNotify)menu_item_free);
+        g_slist_free_full(*menu_items, (GDestroyNotify)menu_item_free);
 #else
-		g_slist_foreach(*menu_items, (GFunc)menu_item_free, NULL);
-		g_slist_free(*menu_items);
+        g_slist_foreach(*menu_items, (GFunc)menu_item_free, NULL);
+        g_slist_free(*menu_items);
 #endif
 
-		*menu_items = NULL;
-	}
+        *menu_items = NULL;
+    }
 }
 
 void
 menu_item_prepare(wmudMenu *item, GHashTable *cmdtable)
 {
-	gchar m1, m2;
-	gchar *a,
-	      *found = NULL;
-	GString *ds, *dsa;
+    gchar   m1, m2;
+    gchar   *a,
+            *found = NULL;
+    GString *ds, *dsa;
 
-	g_debug("Preparing menu item %s", item->text);
-	m1 = g_ascii_tolower(item->menuchar);
-	m2 = g_ascii_toupper(item->menuchar);
-	for (a = item->text; *a; a++)
-		if ((*a == m1) || (*a == m2)) {
-			found = a;
-			break;
-		}
+    g_debug("Preparing menu item %s", item->text);
+    m1 = g_ascii_tolower(item->menuchar);
+    m2 = g_ascii_toupper(item->menuchar);
+    for (a = item->text; *a; a++) {
+        if ((*a == m1) || (*a == m2)) {
+            found = a;
 
-	if (found) {
-		gchar *tmp;
+            break;
+        }
+    }
 
-		tmp = g_ascii_strdown(item->text, -1);
-		ds = g_string_new(tmp);
-		dsa = g_string_new(tmp);
-		g_free(tmp);
+    if (found) {
+        gchar *tmp;
 
-		ds->str[found - item->text] = g_ascii_toupper(item->menuchar);
-		dsa->str[found - item->text] = g_ascii_toupper(item->menuchar);
-	} else {
-		found = item->text;
-		ds = g_string_new(item->text);
-		dsa = g_string_new(item->text);
+        tmp = g_ascii_strdown(item->text, -1);
+        ds  = g_string_new(tmp);
+        dsa = g_string_new(tmp);
+        g_free(tmp);
 
-		g_string_prepend_c(ds, ' ');
-		g_string_prepend_c(ds, g_ascii_toupper(item->menuchar));
-		g_string_prepend_c(dsa, ' ');
-		g_string_prepend_c(dsa, g_ascii_toupper(item->menuchar));
-	}
+        ds->str[found - item->text]  = g_ascii_toupper(item->menuchar);
+        dsa->str[found - item->text] = g_ascii_toupper(item->menuchar);
+    } else {
+        found = item->text;
+        ds    = g_string_new(item->text);
+        dsa   = g_string_new(item->text);
 
-	g_string_insert_c(ds, found - item->text, '(');
-	g_string_insert_c(ds, found - item->text + 2, ')');
+        g_string_prepend_c(ds, ' ');
+        g_string_prepend_c(ds, g_ascii_toupper(item->menuchar));
+        g_string_prepend_c(dsa, ' ');
+        g_string_prepend_c(dsa, g_ascii_toupper(item->menuchar));
+    }
 
-	g_string_insert(dsa, found - item->text, "\x1b[31;1m");
-	g_string_insert(dsa, found - item->text + 8, "\x1b[0m");
-	item->display_text = g_string_free(ds, FALSE);
-	item->display_text_ansi = g_string_free(dsa, FALSE);
+    g_string_insert_c(ds, found - item->text, '(');
+    g_string_insert_c(ds, found - item->text + 2, ')');
+
+    g_string_insert(dsa, found - item->text, "\x1b[31;1m");
+    g_string_insert(dsa, found - item->text + 8, "\x1b[0m");
+    item->display_text      = g_string_free(ds, FALSE);
+    item->display_text_ansi = g_string_free(dsa, FALSE);
 }
 
 WMUD_MENU_COMMAND(enter_world)
@@ -190,117 +195,120 @@ WMUD_MENU_COMMAND(change_name)
 
 WMUD_MENU_COMMAND(quit)
 {
-	wmud_client_set_state(client, WMUD_CLIENT_STATE_YESNO);
-	wmud_client_set_yesno_callback(client, wmud_client_quitanswer);
-	wmud_client_send(client, "Are you sure you want to get back to the real world? [y/N] ");
+    wmud_client_set_state(client, WMUD_CLIENT_STATE_YESNO);
+    wmud_client_set_yesno_callback(client, wmud_client_quitanswer);
+    wmud_client_send(client, "Are you sure you want to get back to the real world? [y/N] ");
 }
 
 WMUD_MENU_COMMAND(redisplay_menu)
 {
-	wmud_menu_present(client);
+    wmud_menu_present(client);
 }
 
 gboolean
 wmud_menu_init(GSList **menu)
 {
-	GSList *menu_items = NULL;
-	GError *in_err = NULL;
-	GHashTable *cmdtable;
+    GSList     *menu_items = NULL;
+    GError     *in_err     = NULL;
+    GHashTable *cmdtable;
 
-	if (!wmud_db_load_menu(&menu_items, &in_err)) {
-		g_log(G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, "Unable to load menu items from the database: %s", in_err->message);
-		wmud_menu_items_free(&menu_items);
+    if (!wmud_db_load_menu(&menu_items, &in_err)) {
+        g_log(G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, "Unable to load menu items from the database: %s", in_err->message);
+        wmud_menu_items_free(&menu_items);
 
-		return FALSE;
-	}
+        return FALSE;
+    }
 
-	if (!menu_items) {
-		g_log(G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, "No menu items were found in the database!");
+    if (!menu_items) {
+        g_log(G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, "No menu items were found in the database!");
 
-		return FALSE;
-	}
+        return FALSE;
+    }
 
-	if (!wmud_menu_items_check(menu_items, &in_err)) {
-		g_log(G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, "Menu items pre-flight check error: %s", in_err->message);
-		wmud_menu_items_free(&menu_items);
+    if (!wmud_menu_items_check(menu_items, &in_err)) {
+        g_log(G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, "Menu items pre-flight check error: %s", in_err->message);
+        wmud_menu_items_free(&menu_items);
 
-		return FALSE;
-	}
+        return FALSE;
+    }
 
-	if (*menu)
-		wmud_menu_items_free(menu);
+    if (*menu) {
+        wmud_menu_items_free(menu);
+    }
 
-	*menu = menu_items;
+    *menu = menu_items;
 
-	cmdtable = g_hash_table_new(g_str_hash, g_str_equal);
+    cmdtable = g_hash_table_new(g_str_hash, g_str_equal);
 
-	g_slist_foreach(*menu, (GFunc)menu_item_prepare, cmdtable);
+    g_slist_foreach(*menu, (GFunc)menu_item_prepare, cmdtable);
 
-	g_hash_table_insert(cmdtable, "enter-world", wmud_mcmd_enter_world);
-	g_hash_table_insert(cmdtable, "change-password", wmud_mcmd_change_password);
-	g_hash_table_insert(cmdtable, "toggle-colour", wmud_mcmd_toggle_colour);
-	g_hash_table_insert(cmdtable, "documentation", wmud_mcmd_documentation);
-	g_hash_table_insert(cmdtable, "caracter-select", wmud_mcmd_character_select);
-	g_hash_table_insert(cmdtable, "character-create", wmud_mcmd_character_create);
-	g_hash_table_insert(cmdtable, "character-delete", wmud_mcmd_character_delete);
-	g_hash_table_insert(cmdtable, "chat", wmud_mcmd_chat);
-	g_hash_table_insert(cmdtable, "player-mail", wmud_mcmd_player_mail);
-	g_hash_table_insert(cmdtable, "colour-test", wmud_mcmd_colour_test);
-	g_hash_table_insert(cmdtable, "change-email", wmud_mcmd_change_email);
-	g_hash_table_insert(cmdtable, "change-name", wmud_mcmd_change_name);
-	g_hash_table_insert(cmdtable, "quit", wmud_mcmd_quit);
-	g_hash_table_insert(cmdtable, "redisplay-menu", wmud_mcmd_redisplay_menu);
+    g_hash_table_insert(cmdtable, "enter-world", wmud_mcmd_enter_world);
+    g_hash_table_insert(cmdtable, "change-password", wmud_mcmd_change_password);
+    g_hash_table_insert(cmdtable, "toggle-colour", wmud_mcmd_toggle_colour);
+    g_hash_table_insert(cmdtable, "documentation", wmud_mcmd_documentation);
+    g_hash_table_insert(cmdtable, "caracter-select", wmud_mcmd_character_select);
+    g_hash_table_insert(cmdtable, "character-create", wmud_mcmd_character_create);
+    g_hash_table_insert(cmdtable, "character-delete", wmud_mcmd_character_delete);
+    g_hash_table_insert(cmdtable, "chat", wmud_mcmd_chat);
+    g_hash_table_insert(cmdtable, "player-mail", wmud_mcmd_player_mail);
+    g_hash_table_insert(cmdtable, "colour-test", wmud_mcmd_colour_test);
+    g_hash_table_insert(cmdtable, "change-email", wmud_mcmd_change_email);
+    g_hash_table_insert(cmdtable, "change-name", wmud_mcmd_change_name);
+    g_hash_table_insert(cmdtable, "quit", wmud_mcmd_quit);
+    g_hash_table_insert(cmdtable, "redisplay-menu", wmud_mcmd_redisplay_menu);
 
-	/* TODO: Free previous hash table, if exists */
-	mcmd_table = cmdtable;
+    /* TODO: Free previous hash table, if exists */
+    mcmd_table = cmdtable;
 
-	return TRUE;
+    return TRUE;
 }
 
 static gint
 find_by_menuchar(wmudMenu *item, gchar *menuchar)
 {
-	if (g_ascii_toupper(*menuchar) == g_ascii_toupper(item->menuchar))
-		return 0;
+    if (g_ascii_toupper(*menuchar) == g_ascii_toupper(item->menuchar)) {
+        return 0;
+    }
 
-	return 1;
+    return 1;
 }
 
 gchar *
 wmud_menu_get_command_by_menuchar(gchar menuchar, GSList *game_menu)
 {
-	GSList *item;
+    GSList *item;
 
-	if ((item = g_slist_find_custom(game_menu, &menuchar, (GCompareFunc)find_by_menuchar)) != NULL)
-		return ((wmudMenu *)(item->data))->func;
+    if ((item = g_slist_find_custom(game_menu, &menuchar, (GCompareFunc)find_by_menuchar)) != NULL) {
+        return ((wmudMenu *)(item->data))->func;
+    }
 
-	return NULL;
+    return NULL;
 }
 
 void
 wmud_menu_execute_command(WmudClient *client, gchar *command)
 {
-	wmudMenuCommandFunc func;
+    wmudMenuCommandFunc func;
 
-	if ((func = g_hash_table_lookup(mcmd_table, command)) == NULL)
-		wmud_client_send(client, "Unknown menu command.\r\n");
-	else
-		func(client);
+    if ((func = g_hash_table_lookup(mcmd_table, command)) == NULL) {
+        wmud_client_send(client, "Unknown menu command.\r\n");
+    } else {
+        func(client);
+    }
 }
 
 void
 send_menu_item(wmudMenu *item, WmudClient *client)
 {
-	/* TODO: Send ANSI menu item only to ANSI players! */
-	wmud_client_send(client, "%s\r\n", item->display_text_ansi);
+    /* TODO: Send ANSI menu item only to ANSI players! */
+    wmud_client_send(client, "%s\r\n", item->display_text_ansi);
 }
 
 void
 wmud_menu_present(WmudClient *client)
 {
-	g_slist_foreach(game_menu, (GFunc)send_menu_item, client);
-	wmud_client_set_state(client, WMUD_CLIENT_STATE_MENU);
+    g_slist_foreach(game_menu, (GFunc)send_menu_item, client);
+    wmud_client_set_state(client, WMUD_CLIENT_STATE_MENU);
 
-	/* TODO: send menu prologue */
+    /* TODO: send menu prologue */
 }
-
diff --git a/wmud/players.c b/wmud/players.c
index eb312c2..5c7fcc2 100644
--- a/wmud/players.c
+++ b/wmud/players.c
@@ -45,7 +45,7 @@ GSList *players = NULL;
 static gint
 find_player_by_name(WmudPlayer *player, gchar *player_name)
 {
-	return g_ascii_strcasecmp(wmud_player_get_player_name(player), player_name);
+    return g_ascii_strcasecmp(wmud_player_get_player_name(player), player_name);
 }
 
 /**
@@ -60,12 +60,11 @@ find_player_by_name(WmudPlayer *player, gchar *player_name)
 WmudPlayer *
 wmud_player_exists(gchar *player_name)
 {
-	GSList *player_elem;
-	
-	if ((player_elem = g_slist_find_custom(players, player_name, (GCompareFunc)find_player_by_name)) == NULL)
-		return NULL;
+    GSList *player_elem;
 
-	return player_elem->data;
+    if ((player_elem = g_slist_find_custom(players, player_name, (GCompareFunc)find_player_by_name)) == NULL) {
+        return NULL;
+    }
 
+    return player_elem->data;
 }
-
diff --git a/wmud/texts.c b/wmud/texts.c
index 5b68ae3..ad2cb8d 100644
--- a/wmud/texts.c
+++ b/wmud/texts.c
@@ -24,62 +24,65 @@
 #include "wmudclient.h"
 
 static const gchar *text_files[] = {
-	"motd",
-	NULL
+    "motd",
+    NULL
 };
-GHashTable *text_table = NULL;
+GHashTable         *text_table = NULL;
 
 void
 wmud_texts_init(void)
 {
-	int i;
-	gchar *texts_dir = g_strconcat(WMUD_STATEDIR, "/texts/", NULL);
+    int   i;
+    gchar *texts_dir = g_strconcat(WMUD_STATEDIR, "/texts/", NULL);
 
-	text_table = g_hash_table_new(g_str_hash, g_str_equal);
+    text_table = g_hash_table_new(g_str_hash, g_str_equal);
 
-	for (i = 0; i < g_strv_length((gchar **)text_files); i++) {
-		GFile *tf;
-		GFileInfo *tfi;
-		GError *err = NULL;
-		guint64 tfs;
-		gchar *contents;
-		gsize length;
+    for (i = 0; i < g_strv_length((gchar **)text_files); i++) {
+        GFile     *tf;
+        GFileInfo *tfi;
+        GError    *err = NULL;
+        guint64   tfs;
+        gchar     *contents;
+        gsize     length;
+        gchar     *text_file = g_strconcat(texts_dir, text_files[i], NULL);
 
-		gchar *text_file = g_strconcat(texts_dir, text_files[i], NULL);
-		g_debug("Loading text file %s from %s", text_files[i], text_file);
-		tf = g_file_new_for_path(text_file);
-		tfi = g_file_query_info(tf, G_FILE_ATTRIBUTE_STANDARD_SIZE, G_FILE_QUERY_INFO_NONE, NULL, &err);
+        g_debug("Loading text file %s from %s", text_files[i], text_file);
+        tf  = g_file_new_for_path(text_file);
+        tfi = g_file_query_info(tf, G_FILE_ATTRIBUTE_STANDARD_SIZE, G_FILE_QUERY_INFO_NONE, NULL, &err);
 
-		if (err) {
-			g_warning("Error loading %s: %s", text_files[i], err->message);
-			continue;
-		}
+        if (err) {
+            g_warning("Error loading %s: %s", text_files[i], err->message);
 
-		tfs = g_file_info_get_attribute_uint64(tfi, G_FILE_ATTRIBUTE_STANDARD_SIZE);
+            continue;
+        }
 
-		contents = g_malloc0(tfs + 1);
+        tfs = g_file_info_get_attribute_uint64(tfi, G_FILE_ATTRIBUTE_STANDARD_SIZE);
 
-		g_clear_error(&err);
+        contents = g_malloc0(tfs + 1);
 
-		if (!g_file_load_contents(tf, NULL, &contents, &length, NULL, &err)) {
-			g_object_unref(tfi);
-			g_object_unref(tf);
-			continue;
-		}
+        g_clear_error(&err);
 
-		g_hash_table_insert(text_table, (char *)text_files[i], contents);
+        if (!g_file_load_contents(tf, NULL, &contents, &length, NULL, &err)) {
+            g_object_unref(tfi);
+            g_object_unref(tf);
 
-		g_object_unref(tfi);
-		g_object_unref(tf);
-		g_free(text_file);
-	}
+            continue;
+        }
 
-	g_free(texts_dir);
+        g_hash_table_insert(text_table, (char *)text_files[i], contents);
+
+        g_object_unref(tfi);
+        g_object_unref(tf);
+        g_free(text_file);
+    }
+
+    g_free(texts_dir);
 }
 
 void
 wmud_text_send_to_client(gchar *text_name, WmudClient *client)
 {
-	gchar *text = g_hash_table_lookup(text_table, text_name);
-	wmud_client_send(client, "%s\r\n", text);
+    gchar *text = g_hash_table_lookup(text_table, text_name);
+
+    wmud_client_send(client, "%s\r\n", text);
 }
diff --git a/wmud/wmudclient.c b/wmud/wmudclient.c
index 7b50d6d..8a15f6b 100644
--- a/wmud/wmudclient.c
+++ b/wmud/wmudclient.c
@@ -33,178 +33,179 @@
 G_DEFINE_TYPE(WmudClient, wmud_client, G_TYPE_OBJECT);
 
 enum {
-	SIG_CONNECTED,
-	SIG_NET_HUP,
-	SIG_NET_RECV,
-	SIG_STATE_CHANGE,
-	SIG_LAST
+    SIG_CONNECTED,
+    SIG_NET_HUP,
+    SIG_NET_RECV,
+    SIG_STATE_CHANGE,
+    SIG_LAST
 };
 
 static guint signals[SIG_LAST] = { 0 };
 
 #define WMUD_CLIENT_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE((obj), WMUD_TYPE_CLIENT, WmudClientPrivate))
 
-struct _WmudClientPrivate
-{
-	GSocket *socket;
-	GSource *socket_source;
-	GString *buffer;
-	WmudClientState state;
-	gboolean authenticated;
-	WmudPlayer *player;
-	gboolean bademail;
-	gint login_try_count;
-	WmudClientYesnoCallback yesno_callback;
-	time_t last_recv;
+struct _WmudClientPrivate {
+    GSocket                 *socket;
+    GSource                 *socket_source;
+    GString                 *buffer;
+    WmudClientState         state;
+    gboolean                authenticated;
+    WmudPlayer              *player;
+    gboolean                bademail;
+    gint                    login_try_count;
+    WmudClientYesnoCallback yesno_callback;
+    time_t                  last_recv;
 };
 
 static void
 wmud_client_dispose(GObject *gobject)
 {
-	WmudClient *self = WMUD_CLIENT(gobject);
+    WmudClient *self = WMUD_CLIENT(gobject);
 
-	if (self->priv->socket) {
-		g_object_unref(self->priv->socket);
+    if (self->priv->socket) {
+        g_object_unref(self->priv->socket);
 
-		self->priv->socket = NULL;
-	}
+        self->priv->socket = NULL;
+    }
 
-	G_OBJECT_CLASS(wmud_client_parent_class)->dispose(gobject);
+    G_OBJECT_CLASS(wmud_client_parent_class)->dispose(gobject);
 }
 
 static void
 wmud_client_finalize(GObject *gobject)
 {
-	WmudClient *self = WMUD_CLIENT(gobject);
+    WmudClient *self = WMUD_CLIENT(gobject);
 
-	g_string_free(self->priv->buffer, TRUE);
-	g_source_destroy(self->priv->socket_source);
+    g_string_free(self->priv->buffer, TRUE);
+    g_source_destroy(self->priv->socket_source);
 
-	G_OBJECT_CLASS(wmud_client_parent_class)->finalize(gobject);
+    G_OBJECT_CLASS(wmud_client_parent_class)->finalize(gobject);
 }
 
-static void net_recv(WmudClient *self)
+static void
+net_recv(WmudClient *self)
 {
-	self->priv->last_recv = time(NULL);
+    self->priv->last_recv = time(NULL);
 }
 
 static void
 wmud_client_class_init(WmudClientClass *klass)
 {
-	GObjectClass *gobject_class = G_OBJECT_CLASS(klass);
+    GObjectClass *gobject_class = G_OBJECT_CLASS(klass);
 
-	gobject_class->dispose = wmud_client_dispose;
-	gobject_class->finalize = wmud_client_finalize;
+    gobject_class->dispose  = wmud_client_dispose;
+    gobject_class->finalize = wmud_client_finalize;
 
-	/**
-	 * WmudClient::connected:
-	 * @client: The client emitting the signal
-	 *
-	 * Emitted when a new client connection is accepted
-	 **/
-	signals[SIG_CONNECTED] = g_signal_newv("connected",
-	                                       WMUD_TYPE_CLIENT,
-	                                       G_SIGNAL_RUN_LAST,
-	                                       NULL,
-	                                       NULL, NULL,
-	                                       NULL,
-	                                       G_TYPE_NONE, 0, NULL);
+    /**
+     * WmudClient::connected:
+     * @client: The client emitting the signal
+     *
+     * Emitted when a new client connection is accepted
+     **/
+    signals[SIG_CONNECTED] = g_signal_newv("connected",
+                                           WMUD_TYPE_CLIENT,
+                                           G_SIGNAL_RUN_LAST,
+                                           NULL,
+                                           NULL, NULL,
+                                           NULL,
+                                           G_TYPE_NONE, 0, NULL);
 
-	/**
-	 * WmudClient::net-hup:
-	 * @client: The client emitting the signal
-	 *
-	 * Emitted when the remote side closes the connection
-	 **/
-	signals[SIG_NET_HUP] = g_signal_newv("net-hup",
-			                     WMUD_TYPE_CLIENT,
-					     G_SIGNAL_RUN_LAST,
-					     NULL,
-					     NULL, NULL,
-					     NULL,
-					     G_TYPE_NONE, 0, NULL);
-	/**
-	 * WmudClient::net-recv:
-	 * @client: The client emitting the signal
-	 *
-	 * Emitted when data is received through the client socket
-	 **/
-	signals[SIG_NET_RECV] = g_signal_newv("net-recv",
-	                                      WMUD_TYPE_CLIENT,
-				              G_SIGNAL_RUN_LAST,
-					      g_cclosure_new(G_CALLBACK(net_recv), NULL, NULL),
-					      NULL, NULL,
-					      NULL,
-					      G_TYPE_NONE, 0, NULL);
+    /**
+     * WmudClient::net-hup:
+     * @client: The client emitting the signal
+     *
+     * Emitted when the remote side closes the connection
+     **/
+    signals[SIG_NET_HUP] = g_signal_newv("net-hup",
+                                         WMUD_TYPE_CLIENT,
+                                         G_SIGNAL_RUN_LAST,
+                                         NULL,
+                                         NULL, NULL,
+                                         NULL,
+                                         G_TYPE_NONE, 0, NULL);
+    /**
+     * WmudClient::net-recv:
+     * @client: The client emitting the signal
+     *
+     * Emitted when data is received through the client socket
+     **/
+    signals[SIG_NET_RECV] = g_signal_newv("net-recv",
+                                          WMUD_TYPE_CLIENT,
+                                          G_SIGNAL_RUN_LAST,
+                                          g_cclosure_new(G_CALLBACK(net_recv), NULL, NULL),
+                                          NULL, NULL,
+                                          NULL,
+                                          G_TYPE_NONE, 0, NULL);
 
-	/**
-	 * WmudClient::state-change:
-	 * @client: The client emitting the signal
-	 * @old_state: The state which we are changing from.
-	 * @new_state: The state which we are changing to.
-	 *
-	 * Emitted when the client changes state
-	 **/
-	signals[SIG_STATE_CHANGE] = g_signal_new("state-change",
-	                                          WMUD_TYPE_CLIENT,
-						  G_SIGNAL_RUN_LAST,
-						  0,
-						  NULL, NULL,
-						  NULL,
-						  G_TYPE_NONE, 2, WMUD_TYPE_CLIENT_STATE, WMUD_TYPE_CLIENT_STATE);
+    /**
+     * WmudClient::state-change:
+     * @client: The client emitting the signal
+     * @old_state: The state which we are changing from.
+     * @new_state: The state which we are changing to.
+     *
+     * Emitted when the client changes state
+     **/
+    signals[SIG_STATE_CHANGE] = g_signal_new("state-change",
+                                             WMUD_TYPE_CLIENT,
+                                             G_SIGNAL_RUN_LAST,
+                                             0,
+                                             NULL, NULL,
+                                             NULL,
+                                             G_TYPE_NONE, 2, WMUD_TYPE_CLIENT_STATE, WMUD_TYPE_CLIENT_STATE);
 
-	g_type_class_add_private(klass, sizeof(WmudClientPrivate));
+    g_type_class_add_private(klass, sizeof(WmudClientPrivate));
 }
 
 static void
 wmud_client_init(WmudClient *self)
 {
-	self->priv = WMUD_CLIENT_GET_PRIVATE(self);
-	self->priv->socket_source = NULL;
-	self->priv->state = WMUD_CLIENT_STATE_FRESH;
-	self->priv->buffer = g_string_new("");
-	self->priv->last_recv = time(NULL);
+    self->priv                = WMUD_CLIENT_GET_PRIVATE(self);
+    self->priv->socket_source = NULL;
+    self->priv->state         = WMUD_CLIENT_STATE_FRESH;
+    self->priv->buffer        = g_string_new("");
+    self->priv->last_recv     = time(NULL);
 
-	g_signal_emit_by_name(self, "connected", G_TYPE_NONE);
+    g_signal_emit_by_name(self, "connected", G_TYPE_NONE);
 }
 
 static gboolean
 net_emitter(GSocket *client_socket, GIOCondition condition, WmudClient *self)
 {
-	if (condition & G_IO_HUP)
-		g_signal_emit_by_name(self, "net-close", G_TYPE_NONE);
-	else if ((condition & G_IO_IN) || (condition & G_IO_PRI))
-		g_signal_emit_by_name(self, "net-recv", G_TYPE_NONE);
+    if (condition & G_IO_HUP) {
+        g_signal_emit_by_name(self, "net-close", G_TYPE_NONE);
+    } else if ((condition & G_IO_IN) || (condition & G_IO_PRI)) {
+        g_signal_emit_by_name(self, "net-recv", G_TYPE_NONE);
+    }
 
-	return TRUE;
+    return TRUE;
 }
 
 WmudClient *
 wmud_client_new(void)
 {
-	return g_object_new(WMUD_TYPE_CLIENT, NULL, NULL);
+    return g_object_new(WMUD_TYPE_CLIENT, NULL, NULL);
 }
 
 void
 wmud_client_set_socket(WmudClient *self, GSocket *socket)
 {
-	/* TODO: Check if a socket is already set! */
-	self->priv->socket = socket;
-	self->priv->socket_source = g_socket_create_source(socket, G_IO_IN | G_IO_OUT | G_IO_PRI | G_IO_ERR | G_IO_HUP | G_IO_NVAL, NULL);
+    /* TODO: Check if a socket is already set! */
+    self->priv->socket        = socket;
+    self->priv->socket_source = g_socket_create_source(socket, G_IO_IN | G_IO_OUT | G_IO_PRI | G_IO_ERR | G_IO_HUP | G_IO_NVAL, NULL);
 
-	g_source_set_callback(self->priv->socket_source, (GSourceFunc)net_emitter, self, NULL);
+    g_source_set_callback(self->priv->socket_source, (GSourceFunc)net_emitter, self, NULL);
 }
 
 GSocket *
 wmud_client_get_socket(WmudClient *self)
 {
-	return self->priv->socket;
+    return self->priv->socket;
 }
 
 GSource *
 wmud_client_get_socket_source(WmudClient *self)
 {
-	return self->priv->socket_source;
+    return self->priv->socket_source;
 }
 
 /**
@@ -218,16 +219,16 @@ wmud_client_get_socket_source(WmudClient *self)
 void
 wmud_client_send(WmudClient *self, const gchar *fmt, ...)
 {
-	va_list ap;
-	GString *buf = g_string_new("");
+    va_list ap;
+    GString *buf = g_string_new("");
 
-	va_start(ap, fmt);
-	g_string_vprintf(buf, fmt, ap);
-	va_end(ap);
+    va_start(ap, fmt);
+    g_string_vprintf(buf, fmt, ap);
+    va_end(ap);
 
-	/* TODO: error checking */
-	g_socket_send(self->priv->socket, buf->str, buf->len, NULL, NULL);
-	g_string_free(buf, TRUE);
+    /* TODO: error checking */
+    g_socket_send(self->priv->socket, buf->str, buf->len, NULL, NULL);
+    g_string_free(buf, TRUE);
 }
 
 /**
@@ -242,92 +243,94 @@ wmud_client_send(WmudClient *self, const gchar *fmt, ...)
 void
 wmud_client_close(WmudClient *self, gboolean send_goodbye)
 {
-	if (send_goodbye)
-		wmud_client_send(self, "\r\nHave a nice real-world day!\r\n\r\n");
+    if (send_goodbye) {
+        wmud_client_send(self, "\r\nHave a nice real-world day!\r\n\r\n");
+    }
 
-	g_socket_shutdown(self->priv->socket, TRUE, TRUE, NULL);
-	g_log(G_LOG_DOMAIN, G_LOG_LEVEL_INFO, "Connection closed.");
+    g_socket_shutdown(self->priv->socket, TRUE, TRUE, NULL);
+    g_log(G_LOG_DOMAIN, G_LOG_LEVEL_INFO, "Connection closed.");
 
-	if (self->priv->player && !wmud_player_get_registered(self->priv->player))
-		g_object_unref(self->priv->player);
+    if (self->priv->player && !wmud_player_get_registered(self->priv->player)) {
+        g_object_unref(self->priv->player);
+    }
 
-	g_object_unref(self);
+    g_object_unref(self);
 }
 
 gsize
 wmud_client_get_buffer_length(WmudClient *self)
 {
-	return self->priv->buffer->len;
+    return self->priv->buffer->len;
 }
 
 GString *
 wmud_client_get_buffer(WmudClient *self)
 {
-	return self->priv->buffer;
+    return self->priv->buffer;
 }
 
 WmudClientState
 wmud_client_get_state(WmudClient *self)
 {
-	return self->priv->state;
+    return self->priv->state;
 }
 
 void
 wmud_client_set_state(WmudClient *self, WmudClientState new_state)
 {
-	WmudClientState old_state = self->priv->state;
+    WmudClientState old_state = self->priv->state;
 
-	self->priv->state = new_state;
+    self->priv->state = new_state;
 
-	g_signal_emit_by_name(self, "state-change", old_state, new_state, G_TYPE_NONE);
+    g_signal_emit_by_name(self, "state-change", old_state, new_state, G_TYPE_NONE);
 }
 
 void
 wmud_client_set_player(WmudClient *self, WmudPlayer *player)
 {
-	self->priv->player = player;
+    self->priv->player = player;
 }
 
 WmudPlayer *
 wmud_client_get_player(WmudClient *self)
 {
-	return self->priv->player;
+    return self->priv->player;
 }
 
 void
 wmud_client_set_yesno_callback(WmudClient *self, WmudClientYesnoCallback yesno_callback)
 {
-	self->priv->yesno_callback = yesno_callback;
+    self->priv->yesno_callback = yesno_callback;
 }
 
 WmudClientYesnoCallback
 wmud_client_get_yesno_callback(WmudClient *self)
 {
-	return self->priv->yesno_callback;
+    return self->priv->yesno_callback;
 }
 
 void
 wmud_client_set_authenticated(WmudClient *self, gboolean authenticated)
 {
-	self->priv->authenticated = authenticated;
+    self->priv->authenticated = authenticated;
 }
 
 void
 wmud_client_increase_login_fail_count(WmudClient *self)
 {
-	self->priv->login_try_count++;
+    self->priv->login_try_count++;
 }
 
 gint
 wmud_client_get_login_fail_count(WmudClient *self)
 {
-	return self->priv->login_try_count;
+    return self->priv->login_try_count;
 }
 
 void
 wmud_client_set_bademail(WmudClient *self, gboolean bademail)
 {
-	self->priv->bademail = bademail;
+    self->priv->bademail = bademail;
 }
 
 /**
@@ -340,18 +343,17 @@ wmud_client_set_bademail(WmudClient *self, gboolean bademail)
 gboolean
 wmud_client_get_bademail(WmudClient *client)
 {
-	return client->priv->bademail;
+    return client->priv->bademail;
 }
 
 void
 wmud_client_set_context(WmudClient *self, GMainContext *context)
 {
-	g_source_attach(self->priv->socket_source, context);
+    g_source_attach(self->priv->socket_source, context);
 }
 
 guint32
 wmud_client_get_last_recv_age(WmudClient *self)
 {
-	return (time(NULL) - self->priv->last_recv);
+    return time(NULL) - self->priv->last_recv;
 }
-
diff --git a/wmud/wmudplayer.c b/wmud/wmudplayer.c
index b8d3411..9586f9a 100644
--- a/wmud/wmudplayer.c
+++ b/wmud/wmudplayer.c
@@ -24,14 +24,13 @@
 
 #define WMUD_PLAYER_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE((obj), WMUD_TYPE_PLAYER, WmudPlayerPrivate))
 
-struct _WmudPlayerPrivate
-{
-	guint32 id;
-	gchar *player_name;
-	gchar *cpassword;
-	gchar *email;
-	gint fail_count;
-	gboolean registered;
+struct _WmudPlayerPrivate {
+    guint32  id;
+    gchar    *player_name;
+    gchar    *cpassword;
+    gchar    *email;
+    gint     fail_count;
+    gboolean registered;
 };
 
 G_DEFINE_TYPE(WmudPlayer, wmud_player, G_TYPE_OBJECT);
@@ -39,133 +38,136 @@ G_DEFINE_TYPE(WmudPlayer, wmud_player, G_TYPE_OBJECT);
 static void
 wmud_player_dispose(GObject *gobject)
 {
-	//WmudPlayer *self = WMUD_PLAYER(gobject);
-
-	G_OBJECT_CLASS(wmud_player_parent_class)->dispose(gobject);
+    G_OBJECT_CLASS(wmud_player_parent_class)->dispose(gobject);
 }
 
 static void
 wmud_player_finalize(GObject *gobject)
 {
-	WmudPlayer *self = WMUD_PLAYER(gobject);
+    WmudPlayer *self = WMUD_PLAYER(gobject);
 
-	if (self->priv->player_name)
-		g_free(self->priv->player_name);
+    if (self->priv->player_name) {
+        g_free(self->priv->player_name);
+    }
 
-	if (self->priv->cpassword)
-		g_free(self->priv->cpassword);
+    if (self->priv->cpassword) {
+        g_free(self->priv->cpassword);
+    }
 
-	if (self->priv->email)
-		g_free(self->priv->email);
+    if (self->priv->email) {
+        g_free(self->priv->email);
+    }
 
-	G_OBJECT_CLASS(wmud_player_parent_class)->finalize(gobject);
+    G_OBJECT_CLASS(wmud_player_parent_class)->finalize(gobject);
 }
 
 static void
 wmud_player_class_init(WmudPlayerClass *klass)
 {
-	GObjectClass *gobject_class = G_OBJECT_CLASS(klass);
+    GObjectClass *gobject_class = G_OBJECT_CLASS(klass);
 
-	gobject_class->dispose = wmud_player_dispose;
-	gobject_class->finalize = wmud_player_finalize;
+    gobject_class->dispose  = wmud_player_dispose;
+    gobject_class->finalize = wmud_player_finalize;
 
-	g_type_class_add_private(klass, sizeof(WmudPlayerPrivate));
+    g_type_class_add_private(klass, sizeof(WmudPlayerPrivate));
 }
 
 static void
 wmud_player_init(WmudPlayer *self)
 {
-	self->priv = WMUD_PLAYER_GET_PRIVATE(self);
+    self->priv = WMUD_PLAYER_GET_PRIVATE(self);
 }
 
 WmudPlayer *
 wmud_player_new(void)
 {
-	return g_object_new(WMUD_TYPE_PLAYER, NULL, NULL);
+    return g_object_new(WMUD_TYPE_PLAYER, NULL, NULL);
 }
 
 void
 wmud_player_set_cpassword(WmudPlayer *self, const gchar *cpassword)
 {
-	if (self->priv->cpassword)
-		g_free(self->priv->cpassword);
+    if (self->priv->cpassword) {
+        g_free(self->priv->cpassword);
+    }
 
-	self->priv->cpassword = g_strdup(cpassword);
+    self->priv->cpassword = g_strdup(cpassword);
 }
 
 gchar *
 wmud_player_get_cpassword(WmudPlayer *self)
 {
-	return self->priv->cpassword;
+    return self->priv->cpassword;
 }
 
 void
 wmud_player_set_registered(WmudPlayer *self, gboolean registered)
 {
-	self->priv->registered = registered;
+    self->priv->registered = registered;
 }
 
 gboolean
 wmud_player_get_registered(WmudPlayer *self)
 {
-	return self->priv->registered;
+    return self->priv->registered;
 }
 
 void
 wmud_player_set_player_name(WmudPlayer *self, const gchar *name)
 {
-	self->priv->player_name = g_strdup(name);
+    self->priv->player_name = g_strdup(name);
 }
 
 gchar *
 wmud_player_get_player_name(WmudPlayer *self)
 {
-	return self->priv->player_name;
+    return self->priv->player_name;
 }
 
 void
 wmud_player_reset_fail_count(WmudPlayer *self)
 {
-	self->priv->fail_count = 0;
+    self->priv->fail_count = 0;
 }
 
 void
 wmud_player_increase_fail_count(WmudPlayer *self)
 {
-	self->priv->fail_count++;
+    self->priv->fail_count++;
 }
 
 gint
 wmud_player_get_fail_count(WmudPlayer *self)
 {
-	return self->priv->fail_count;
+    return self->priv->fail_count;
 }
 
 void
 wmud_player_set_email(WmudPlayer *self, const gchar *email)
 {
-	if (self->priv->email)
-		g_free(self->priv->email);
+    if (self->priv->email) {
+        g_free(self->priv->email);
+    }
 
-	self->priv->email = g_strdup(email);
+    self->priv->email = g_strdup(email);
 }
 
 gchar *
 wmud_player_get_email(WmudPlayer *self)
 {
-	return self->priv->email;
+    return self->priv->email;
 }
 
 void
 wmud_player_set_id(WmudPlayer *self, guint32 id)
 {
-	self->priv->id = id;
+    self->priv->id = id;
 }
 
 guint32
 wmud_player_get_id(WmudPlayer *self)
 {
-	return self->priv->id;
+    return self->priv->id;
 }
 
 /**
@@ -179,18 +181,19 @@ wmud_player_get_id(WmudPlayer *self)
 WmudPlayer *
 wmud_player_dup(WmudPlayer *self)
 {
-	WmudPlayer *new_player;
+    WmudPlayer *new_player;
 
-	if (!self)
-		return NULL;
+    if (!self) {
+        return NULL;
+    }
 
-	new_player = wmud_player_new();
-	new_player->priv->id = self->priv->id;
-	new_player->priv->player_name = g_strdup(self->priv->player_name);
-	new_player->priv->cpassword = g_strdup(self->priv->cpassword);
-	new_player->priv->email = g_strdup(self->priv->email);
+    new_player                    = wmud_player_new();
+    new_player->priv->id          = self->priv->id;
+    new_player->priv->player_name = g_strdup(self->priv->player_name);
+    new_player->priv->cpassword   = g_strdup(self->priv->cpassword);
+    new_player->priv->email       = g_strdup(self->priv->email);
 
-	return new_player;
+    return new_player;
 }
 
 /**
@@ -206,6 +209,5 @@ wmud_player_dup(WmudPlayer *self)
 gboolean
 wmud_player_password_valid(WmudPlayer *player, const gchar *password)
 {
-	return (g_strcmp0(crypt(password, player->priv->cpassword), player->priv->cpassword) == 0);
+    return g_strcmp0(crypt(password, player->priv->cpassword), player->priv->cpassword) == 0;
 }
-
diff --git a/wmud/wmudworld.c b/wmud/wmudworld.c
index 878e5f2..66b03ac 100644
--- a/wmud/wmudworld.c
+++ b/wmud/wmudworld.c
@@ -30,41 +30,40 @@ G_DEFINE_TYPE(WmudWorld, wmud_world, G_TYPE_OBJECT);
 
 #define WMUD_WORLD_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE((obj), WMUD_TYPE_WORLD, WmudWorldPrivate))
 
-struct _WmudWorldPrivate
-{
+struct _WmudWorldPrivate {
 };
 
 static void
 wmud_world_dispose(GObject *gobject)
 {
-	G_OBJECT_CLASS(wmud_world_parent_class)->dispose(gobject);
+    G_OBJECT_CLASS(wmud_world_parent_class)->dispose(gobject);
 }
 
 static void
 wmud_world_finalize(GObject *gobject)
 {
-	G_OBJECT_CLASS(wmud_world_parent_class)->finalize(gobject);
+    G_OBJECT_CLASS(wmud_world_parent_class)->finalize(gobject);
 }
 
 static void
 wmud_world_class_init(WmudWorldClass *klass)
 {
-	GObjectClass *gobject_class = G_OBJECT_CLASS(klass);
+    GObjectClass *gobject_class = G_OBJECT_CLASS(klass);
 
-	gobject_class->dispose = wmud_world_dispose;
-	gobject_class->finalize = wmud_world_finalize;
+    gobject_class->dispose  = wmud_world_dispose;
+    gobject_class->finalize = wmud_world_finalize;
 
-	g_type_class_add_private(klass, sizeof(WmudWorldPrivate));
+    g_type_class_add_private(klass, sizeof(WmudWorldPrivate));
 }
 
 static void
 wmud_world_init(WmudWorld *self)
 {
-	self->priv = WMUD_WORLD_GET_PRIVATE(self);
+    self->priv = WMUD_WORLD_GET_PRIVATE(self);
 }
 
 WmudWorld *
 wmud_world_new(void)
 {
-	return g_object_new(WMUD_TYPE_WORLD, NULL, NULL);
+    return g_object_new(WMUD_TYPE_WORLD, NULL, NULL);
 }
diff --git a/wmud/world.c b/wmud/world.c
index a8ee156..7631497 100644
--- a/wmud/world.c
+++ b/wmud/world.c
@@ -31,56 +31,57 @@
  */
 
 struct findData {
-	GSList *list;
-	guint found;
-	gchar *last;
+    GSList *list;
+    guint  found;
+    gchar  *last;
 };
 
 struct dirCheckData {
-	GSList *directions;
-	GSList *rooms;
-	gboolean sane;
+    GSList   *directions;
+    GSList   *rooms;
+    gboolean sane;
 };
 
 struct assocPlanetPlanes {
-	GSList *planets;
-	GSList *planes;
-	gboolean bad_planet;
-	gboolean bad_plane;
+    GSList   *planets;
+    GSList   *planes;
+    gboolean bad_planet;
+    gboolean bad_plane;
 };
 
 struct assocRoomAreas {
-	GSList *areas;
-	gboolean found;
+    GSList   *areas;
+    gboolean found;
 };
 
 struct assocExitRooms {
-	GSList *rooms;
-	GSList *directions;
+    GSList *rooms;
+    GSList *directions;
 };
 
 GQuark
 wmud_world_error_quark()
 {
-	return g_quark_from_static_string("wmud-world-error");
+    return g_quark_from_static_string("wmud-world-error");
 }
 
 static gint
 check_plane_dups2(wmudPlane *plane, gchar *name)
 {
-	return (g_ascii_strcasecmp(plane->name, name));
+    return g_ascii_strcasecmp(plane->name, name);
 }
 
 static void
 check_plane_dups1(wmudPlane *plane, struct findData *find_data)
 {
-	if (find_data->last != plane->name) {
-		find_data->last = plane->name;
-		find_data->found = (find_data->found > 1) ? find_data->found : 0;
-	}
+    if (find_data->last != plane->name) {
+        find_data->last  = plane->name;
+        find_data->found = (find_data->found > 1) ? find_data->found : 0;
+    }
 
-	if (g_slist_find_custom(find_data->list, plane->name, (GCompareFunc)check_plane_dups2))
-		find_data->found++;
+    if (g_slist_find_custom(find_data->list, plane->name, (GCompareFunc)check_plane_dups2)) {
+        find_data->found++;
+    }
 }
 
 /**
@@ -95,34 +96,36 @@ check_plane_dups1(wmudPlane *plane, struct findData *find_data)
 gboolean
 wmud_world_check_planes(GSList *planes, GError **err)
 {
-	struct findData find_data = {planes, 0, NULL};
+    struct findData find_data = {planes, 0, NULL};
 
-	g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "Checking plane names for duplicates");
+    g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "Checking plane names for duplicates");
 
-	g_slist_foreach(planes, (GFunc)check_plane_dups1, &find_data);
+    g_slist_foreach(planes, (GFunc)check_plane_dups1, &find_data);
 
-	if (find_data.found > 1)
-		g_set_error(err, WMUD_WORLD_ERROR, WMUD_WORLD_ERROR_DUPPLANE, "Duplicate plane names found. Please check your database!\n");
+    if (find_data.found > 1) {
+        g_set_error(err, WMUD_WORLD_ERROR, WMUD_WORLD_ERROR_DUPPLANE, "Duplicate plane names found. Please check your database!\n");
+    }
 
-	return (find_data.found < 2);
+    return find_data.found < 2;
 }
 
 static gint
 check_planet_dups2(wmudPlanet *planet, gchar *name)
 {
-	return (g_ascii_strcasecmp(planet->name, name));
+    return g_ascii_strcasecmp(planet->name, name);
 }
 
 static void
 check_planet_dups1(wmudPlanet *planet, struct findData *find_data)
 {
-	if (find_data->last != planet->name) {
-		find_data->last = planet->name;
-		find_data->found = (find_data->found > 1) ? find_data->found : 0;
-	}
+    if (find_data->last != planet->name) {
+        find_data->last  = planet->name;
+        find_data->found = (find_data->found > 1) ? find_data->found : 0;
+    }
 
-	if (g_slist_find_custom(find_data->list, planet->name, (GCompareFunc)check_planet_dups2))
-		find_data->found++;
+    if (g_slist_find_custom(find_data->list, planet->name, (GCompareFunc)check_planet_dups2)) {
+        find_data->found++;
+    }
 }
 
 /**
@@ -137,34 +140,36 @@ check_planet_dups1(wmudPlanet *planet, struct findData *find_data)
 gboolean
 wmud_world_check_planets(GSList *planets, GError **err)
 {
-	struct findData find_data = {planets, 0, NULL};
+    struct findData find_data = {planets, 0, NULL};
 
-	g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "Checking planet names for duplicates");
+    g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "Checking planet names for duplicates");
 
-	g_slist_foreach(planets, (GFunc)check_planet_dups1, &find_data);
+    g_slist_foreach(planets, (GFunc)check_planet_dups1, &find_data);
 
-	if (find_data.found > 1)
-		g_set_error(err, WMUD_WORLD_ERROR, WMUD_WORLD_ERROR_DUPPLANET, "Duplicate planet names found. Please check your database!\n");
+    if (find_data.found > 1) {
+        g_set_error(err, WMUD_WORLD_ERROR, WMUD_WORLD_ERROR_DUPPLANET, "Duplicate planet names found. Please check your database!\n");
+    }
 
-	return (find_data.found < 2);
+    return find_data.found < 2;
 }
 
 static gint
 check_area_dups2(wmudArea *area, gchar *name)
 {
-	return (g_ascii_strcasecmp(area->name, name));
+    return g_ascii_strcasecmp(area->name, name);
 }
 
 static void
 check_area_dups1(wmudArea *area, struct findData *find_data)
 {
-	if (find_data->last != area->name) {
-		find_data->last = area->name;
-		find_data->found = (find_data->found > 1) ? find_data->found : 0;
-	}
+    if (find_data->last != area->name) {
+        find_data->last  = area->name;
+        find_data->found = (find_data->found > 1) ? find_data->found : 0;
+    }
 
-	if (g_slist_find_custom(find_data->list, area->name, (GCompareFunc)check_area_dups2))
-		find_data->found++;
+    if (g_slist_find_custom(find_data->list, area->name, (GCompareFunc)check_area_dups2)) {
+        find_data->found++;
+    }
 }
 
 /**
@@ -179,38 +184,40 @@ check_area_dups1(wmudArea *area, struct findData *find_data)
 gboolean
 wmud_world_check_areas(GSList *areas, GError **err)
 {
-	struct findData find_data = {areas, 0, NULL};
+    struct findData find_data = {areas, 0, NULL};
 
-	g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "Checking area names for duplicates");
+    g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "Checking area names for duplicates");
 
-	g_slist_foreach(areas, (GFunc)check_area_dups1, &find_data);
+    g_slist_foreach(areas, (GFunc)check_area_dups1, &find_data);
 
-	if (find_data.found > 1)
-		g_set_error(err, WMUD_WORLD_ERROR, WMUD_WORLD_ERROR_DUPAREA, "Duplicate area names found. Please check your database!");
+    if (find_data.found > 1) {
+        g_set_error(err, WMUD_WORLD_ERROR, WMUD_WORLD_ERROR_DUPAREA, "Duplicate area names found. Please check your database!");
+    }
 
-	return (find_data.found < 2);
+    return find_data.found < 2;
 }
 
 static gint
 check_room_exit_room(wmudRoom *room, wmudExit *room_exit)
 {
-	return ((room->id == room_exit->source_room_id) || (room->id == room_exit->destination_room_id)) ? 0 : 1;
+    return ((room->id == room_exit->source_room_id) || (room->id == room_exit->destination_room_id)) ? 0 : 1;
 }
 
 static gint
 check_room_exit_dir(wmudDirection *dir, wmudExit *room_exit)
 {
-	return (dir->id == room_exit->direction_id) ? 0 : 1;
+    return (dir->id == room_exit->direction_id) ? 0 : 1;
 }
 
 static void
 exit_sanity_check(wmudExit *room_exit, struct dirCheckData *dir_check_data)
 {
-	if (
-		!g_slist_find_custom(dir_check_data->rooms, room_exit, (GCompareFunc)check_room_exit_room)
-		|| !g_slist_find_custom(dir_check_data->directions, room_exit, (GCompareFunc)check_room_exit_dir)
-	)
-		dir_check_data->sane = FALSE;
+    if (
+        !g_slist_find_custom(dir_check_data->rooms, room_exit, (GCompareFunc)check_room_exit_room) ||
+        !g_slist_find_custom(dir_check_data->directions, room_exit, (GCompareFunc)check_room_exit_dir)
+       ) {
+        dir_check_data->sane = FALSE;
+    }
 }
 
 /**
@@ -228,31 +235,32 @@ exit_sanity_check(wmudExit *room_exit, struct dirCheckData *dir_check_data)
 gboolean
 wmud_world_check_exits(GSList *exits, GSList *directions, GSList *rooms, GError **err)
 {
-	struct dirCheckData dir_check_data = {directions, rooms, TRUE};
+    struct dirCheckData dir_check_data = {directions, rooms, TRUE};
 
-	g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "Sanity checking on room exits");
+    g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "Sanity checking on room exits");
 
-	g_slist_foreach(exits, (GFunc)exit_sanity_check, &dir_check_data);
+    g_slist_foreach(exits, (GFunc)exit_sanity_check, &dir_check_data);
 
-	return dir_check_data.sane;
+    return dir_check_data.sane;
 }
 
 static gint
 check_room_dups2(wmudRoom *room1, wmudRoom *room2)
 {
-	return (room1->area_id == room2->area_id) ? g_ascii_strcasecmp(room1->name, room2->name) : 1;
+    return (room1->area_id == room2->area_id) ? g_ascii_strcasecmp(room1->name, room2->name) : 1;
 }
 
 static void
 check_room_dups1(wmudRoom *room, struct findData *find_data)
 {
-	if (find_data->last != (gchar *)room) {
-		find_data->last = (gchar *)room;
-		find_data->found = (find_data->found > 1) ? find_data->found : 0;
-	}
+    if (find_data->last != (gchar *)room) {
+        find_data->last  = (gchar *)room;
+        find_data->found = (find_data->found > 1) ? find_data->found : 0;
+    }
 
-	if (g_slist_find_custom(find_data->list, room, (GCompareFunc)check_room_dups2))
-		find_data->found++;
+    if (g_slist_find_custom(find_data->list, room, (GCompareFunc)check_room_dups2)) {
+        find_data->found++;
+    }
 }
 
 /**
@@ -267,66 +275,70 @@ check_room_dups1(wmudRoom *room, struct findData *find_data)
 gboolean
 wmud_world_check_rooms(GSList *rooms, GError **err)
 {
-	struct findData find_data = {rooms, 0, NULL};
+    struct findData find_data = {rooms, 0, NULL};
 
-	g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "Checking room consistency");
+    g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "Checking room consistency");
 
-	g_slist_foreach(rooms, (GFunc)check_room_dups1, &find_data);
+    g_slist_foreach(rooms, (GFunc)check_room_dups1, &find_data);
 
-	if (find_data.found > 1)
-		g_set_error(err, WMUD_WORLD_ERROR, WMUD_WORLD_ERROR_DUPROOM, "Duplicate room names found. Please check your database!");
+    if (find_data.found > 1) {
+        g_set_error(err, WMUD_WORLD_ERROR, WMUD_WORLD_ERROR_DUPROOM, "Duplicate room names found. Please check your database!");
+    }
 
-	return (find_data.found < 2);
+    return find_data.found < 2;
 }
 
 gint
 find_planet_by_id(wmudPlanet *planet, guint *planet_id)
 {
-	if (planet->id == *planet_id)
-		return 0;
+    if (planet->id == *planet_id) {
+        return 0;
+    }
 
-	return 1;
+    return 1;
 }
 
 gint
 find_plane_by_id(wmudPlane *plane, guint *plane_id)
 {
-	if (plane->id == *plane_id)
-		return 0;
+    if (plane->id == *plane_id) {
+        return 0;
+    }
 
-	return 1;
+    return 1;
 }
 
 void
 planet_plane_assoc(wmudPlanetPlaneAssoc *association, struct assocPlanetPlanes *assoc_data)
 {
-	GSList *planet,
-	       *plane;
+    GSList *planet,
+           *plane;
 
-	if ((planet = g_slist_find_custom(assoc_data->planets, &(association->planet_id), (GCompareFunc)find_planet_by_id)) == NULL) {
-		g_debug("Planet: %d", association->planet_id);
-		assoc_data->bad_planet = TRUE;
+    if ((planet = g_slist_find_custom(assoc_data->planets, &(association->planet_id), (GCompareFunc)find_planet_by_id)) == NULL) {
+        g_debug("Planet: %d", association->planet_id);
+        assoc_data->bad_planet = TRUE;
 
-		return;
-	}
+        return;
+    }
 
-	if ((plane = g_slist_find_custom(assoc_data->planes, &(association->plane_id), (GCompareFunc)find_plane_by_id)) == NULL) {
-		g_debug("Plane: %d", association->plane_id);
-		assoc_data->bad_plane = TRUE;
+    if ((plane = g_slist_find_custom(assoc_data->planes, &(association->plane_id), (GCompareFunc)find_plane_by_id)) == NULL) {
+        g_debug("Plane: %d", association->plane_id);
+        assoc_data->bad_plane = TRUE;
 
-		return;
-	}
+        return;
+    }
 
-	((wmudPlanet *)(planet->data))->planes = g_slist_prepend(((wmudPlanet *)(planet->data))->planes, (wmudPlane *)(plane->data));
+    ((wmudPlanet *)(planet->data))->planes = g_slist_prepend(((wmudPlanet *)(planet->data))->planes, (wmudPlane *)(plane->data));
 }
 
 gint
 find_noplane_planet(wmudPlanet *planet, gconstpointer data)
 {
-	if (planet->planes == NULL)
-		return 0;
+    if (planet->planes == NULL) {
+        return 0;
+    }
 
-	return 1;
+    return 1;
 }
 
 /**
@@ -345,46 +357,47 @@ find_noplane_planet(wmudPlanet *planet, gconstpointer data)
 gboolean
 wmud_world_assoc_planets_planes(GSList *planets, GSList *planes, GSList *planet_planes, GError **err)
 {
-	struct assocPlanetPlanes planet_plane_assoc_data = {planets, planes, FALSE, FALSE};
+    struct assocPlanetPlanes planet_plane_assoc_data = {planets, planes, FALSE, FALSE};
 
-	g_slist_foreach(planet_planes, (GFunc)planet_plane_assoc, &planet_plane_assoc_data);
+    g_slist_foreach(planet_planes, (GFunc)planet_plane_assoc, &planet_plane_assoc_data);
 
-	if (planet_plane_assoc_data.bad_planet || planet_plane_assoc_data.bad_plane) {
-		g_set_error(err, WMUD_WORLD_ERROR, WMUD_WORLD_ERROR_BADASSOC, "An illegal planet <-> plane association was found in the database!");
+    if (planet_plane_assoc_data.bad_planet || planet_plane_assoc_data.bad_plane) {
+        g_set_error(err, WMUD_WORLD_ERROR, WMUD_WORLD_ERROR_BADASSOC, "An illegal planet <-> plane association was found in the database!");
 
-		return FALSE;
-	}
+        return FALSE;
+    }
 
-	if (g_slist_find_custom(planets, NULL, (GCompareFunc)find_noplane_planet) != NULL) {
-		g_set_error(err, WMUD_WORLD_ERROR, WMUD_WORLD_ERROR_BADPLANET, "A planet with no planes associated was found in the database!");
+    if (g_slist_find_custom(planets, NULL, (GCompareFunc)find_noplane_planet) != NULL) {
+        g_set_error(err, WMUD_WORLD_ERROR, WMUD_WORLD_ERROR_BADPLANET, "A planet with no planes associated was found in the database!");
 
-		return FALSE;
-	}
+        return FALSE;
+    }
 
-	return TRUE;
+    return TRUE;
 }
 
 gint
 find_area_by_id(wmudArea *area, guint *id)
 {
-	if (area->id == *id)
-		return 0;
+    if (area->id == *id) {
+        return 0;
+    }
 
-	return 1;
+    return 1;
 }
 
 void
 assoc_room_area(wmudRoom *room, struct assocRoomAreas *find_data)
 {
-	GSList *area_item;
+    GSList *area_item;
 
-	if ((area_item = g_slist_find_custom(find_data->areas, &(room->area_id), (GCompareFunc)find_area_by_id)) == NULL) {
-		find_data->found = TRUE;
-	} else {
-		wmudArea *area = area_item->data;
-		g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "Associating room _%s_[%d] to area _%s_[%d]", room->name, room->id, area->name, area->id);
-		area->rooms = g_slist_append(area->rooms, room);
-	}
+    if ((area_item = g_slist_find_custom(find_data->areas, &(room->area_id), (GCompareFunc)find_area_by_id)) == NULL) {
+        find_data->found = TRUE;
+    } else {
+        wmudArea *area = area_item->data;
+        g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "Associating room _%s_[%d] to area _%s_[%d]", room->name, room->id, area->name, area->id);
+        area->rooms = g_slist_append(area->rooms, room);
+    }
 }
 
 /**
@@ -402,35 +415,35 @@ assoc_room_area(wmudRoom *room, struct assocRoomAreas *find_data)
 gboolean
 wmud_world_assoc_rooms_areas(GSList *rooms, GSList *areas, GError **err)
 {
-	struct assocRoomAreas find_data = {areas, FALSE};
+    struct assocRoomAreas find_data = {areas, FALSE};
 
-	g_slist_foreach(rooms, (GFunc)assoc_room_area, &find_data);
+    g_slist_foreach(rooms, (GFunc)assoc_room_area, &find_data);
 
-	if (find_data.found) {
-		g_set_error(err, WMUD_WORLD_ERROR, WMUD_WORLD_ERROR_BADASSOC, "Found a bad Area <-> Room association in the database!");
+    if (find_data.found) {
+        g_set_error(err, WMUD_WORLD_ERROR, WMUD_WORLD_ERROR_BADASSOC, "Found a bad Area <-> Room association in the database!");
 
-		return FALSE;
-	}
+        return FALSE;
+    }
 
-	return TRUE;
+    return TRUE;
 }
 
 void
 assoc_room_plane(wmudPlane *plane, wmudRoom *room)
 {
-	room->planes = g_slist_prepend(room->planes, plane);
+    room->planes = g_slist_prepend(room->planes, plane);
 }
 
 void
 assoc_room_planets(wmudRoom *room, GSList *planets)
 {
-	g_slist_foreach(((wmudPlanet *)(planets->data))->planes, (GFunc)assoc_room_plane, room);
+    g_slist_foreach(((wmudPlanet *)(planets->data))->planes, (GFunc)assoc_room_plane, room);
 }
 
 gint
 find_noplane_room(wmudRoom *room, gconstpointer notused)
 {
-	return (room->planes == NULL) ? 0 : 1;
+    return (room->planes == NULL) ? 0 : 1;
 }
 
 /**
@@ -447,41 +460,44 @@ find_noplane_room(wmudRoom *room, gconstpointer notused)
 gboolean
 wmud_world_assoc_rooms_planets(GSList *rooms, GSList *planets, GError **err)
 {
-	/* Do the associations */
-	g_slist_foreach(rooms, (GFunc)assoc_room_planets, planets);
+    /* Do the associations */
+    g_slist_foreach(rooms, (GFunc)assoc_room_planets, planets);
 
-	/* Check the rooms */
-	return (g_slist_find_custom(rooms, NULL, (GCompareFunc)find_noplane_room) == NULL);
+    /* Check the rooms */
+    return g_slist_find_custom(rooms, NULL, (GCompareFunc)find_noplane_room) == NULL;
 }
 
 gint
 find_room_by_id(wmudRoom *room, guint *id)
 {
-	if (room->id == *id)
-		return 0;
+    if (room->id == *id) {
+        return 0;
+    }
 
-	return 1;
+    return 1;
 }
 
 gint
 find_direction_by_id(wmudDirection *dir, guint *id)
 {
-	if (dir->id == *id)
-		return 0;
+    if (dir->id == *id) {
+        return 0;
+    }
 
-	return 1;
+    return 1;
 }
 
 void
 assoc_room_exit(wmudExit *exit, struct assocExitRooms *assoc_data)
 {
-	wmudRoomExit *room_exit = g_new0(wmudRoomExit, 1);
+    wmudRoomExit *room_exit = g_new0(wmudRoomExit, 1);
 
-	wmudRoom *src_room = (wmudRoom *)(g_slist_find_custom(assoc_data->rooms, &(exit->source_room_id), (GCompareFunc)find_room_by_id)->data);
-	room_exit->other_side = (wmudRoom *)(g_slist_find_custom(assoc_data->rooms, &(exit->destination_room_id), (GCompareFunc)find_room_by_id)->data);
-	room_exit->direction = (wmudDirection *)(g_slist_find_custom(assoc_data->directions, &(exit->direction_id), (GCompareFunc)find_direction_by_id)->data);
+    wmudRoom     *src_room = (wmudRoom *)(g_slist_find_custom(assoc_data->rooms, &(exit->source_room_id), (GCompareFunc)find_room_by_id)->data);
 
-	src_room->exits = g_slist_prepend(src_room->exits, room_exit);
+    room_exit->other_side = (wmudRoom *)(g_slist_find_custom(assoc_data->rooms, &(exit->destination_room_id), (GCompareFunc)find_room_by_id)->data);
+    room_exit->direction  = (wmudDirection *)(g_slist_find_custom(assoc_data->directions, &(exit->direction_id), (GCompareFunc)find_direction_by_id)->data);
+
+    src_room->exits = g_slist_prepend(src_room->exits, room_exit);
 }
 
 /**
@@ -496,168 +512,176 @@ assoc_room_exit(wmudExit *exit, struct assocExitRooms *assoc_data)
 void
 wmud_world_assoc_exits_rooms(GSList *exits, GSList *directions, GSList *rooms, GError **err)
 {
-	struct assocExitRooms assoc_data = {rooms, directions};
+    struct assocExitRooms assoc_data = {rooms, directions};
 
-	g_slist_foreach(exits, (GFunc)assoc_room_exit, &assoc_data);
+    g_slist_foreach(exits, (GFunc)assoc_room_exit, &assoc_data);
 }
 
 static void
 free_direction(wmudDirection *dir)
 {
-	if (dir->short_name)
-		g_free(dir->short_name);
+    if (dir->short_name) {
+        g_free(dir->short_name);
+    }
 
-	if (dir->name)
-		g_free(dir->name);
+    if (dir->name) {
+        g_free(dir->name);
+    }
 
-	g_free(dir);
+    g_free(dir);
 }
 
 void
 wmud_world_free_directions(GSList *directions)
 {
-	g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "Freeing direction list");
+    g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "Freeing direction list");
 
-	if (directions) {
+    if (directions) {
 #if GLIB_CHECK_VERSION(2, 28, 0)
-		g_slist_free_full(directions, (GDestroyNotify)free_direction);
+        g_slist_free_full(directions, (GDestroyNotify)free_direction);
 #else
-		g_slist_foreach(directions, (GFunc)free_direction, NULL);
-		g_slist_free(directions);
+        g_slist_foreach(directions, (GFunc)free_direction, NULL);
+        g_slist_free(directions);
 #endif
-	}
+    }
 }
 
 static void
 free_plane(wmudPlane *plane)
 {
-	if (plane->name)
-		g_free(plane->name);
+    if (plane->name) {
+        g_free(plane->name);
+    }
 
-	g_free(plane);
+    g_free(plane);
 }
 
 void
 wmud_world_free_planes(GSList *planes)
 {
-	g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "Freeing planes list");
+    g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "Freeing planes list");
 
-	if (planes) {
+    if (planes) {
 #if GLIB_CHECK_VERSION(2, 28, 0)
-		g_slist_free_full(planes, (GDestroyNotify)free_plane);
+        g_slist_free_full(planes, (GDestroyNotify)free_plane);
 #else
-		g_slist_foreach(planes, (GFunc)free_plane, NULL);
-		g_slist_free(planes);
+        g_slist_foreach(planes, (GFunc)free_plane, NULL);
+        g_slist_free(planes);
 #endif
-	}
+    }
 }
 
 static void
 free_planet(wmudPlanet *planet)
 {
-	if (planet->name)
-		g_free(planet->name);
+    if (planet->name) {
+        g_free(planet->name);
+    }
 
-	g_free(planet);
+    g_free(planet);
 }
 
 void
 wmud_world_free_planets(GSList *planets)
 {
-	g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "Freeing planets list");
+    g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "Freeing planets list");
 
-	if (planets) {
+    if (planets) {
 #if GLIB_CHECK_VERSION(2, 28, 0)
-		g_slist_free_full(planets, (GDestroyNotify)free_planet);
+        g_slist_free_full(planets, (GDestroyNotify)free_planet);
 #else
-		g_slist_foreach(planets, (GFunc)free_planet, NULL);
-		g_slist_free(planets);
+        g_slist_foreach(planets, (GFunc)free_planet, NULL);
+        g_slist_free(planets);
 #endif
-	}
+    }
 }
 
 static void
 free_area(wmudArea *area)
 {
-	if (area->name)
-		g_free(area->name);
+    if (area->name) {
+        g_free(area->name);
+    }
 
-	g_free(area);
+    g_free(area);
 }
 
 void
 wmud_world_free_areas(GSList *areas)
 {
-	g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "Freeing areas list");
+    g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "Freeing areas list");
 
-	if (areas) {
+    if (areas) {
 #if GLIB_CHECK_VERSION(2, 28, 0)
-		g_slist_free_full(areas, (GDestroyNotify)free_area);
+        g_slist_free_full(areas, (GDestroyNotify)free_area);
 #else
-		g_slist_foreach(areas, (GFunc)free_area, NULL);
-		g_slist_free(areas);
+        g_slist_foreach(areas, (GFunc)free_area, NULL);
+        g_slist_free(areas);
 #endif
-	}
+    }
 }
 
 static void
 free_room(wmudRoom *room)
 {
-	if (room->name)
-		g_free(room->name);
+    if (room->name) {
+        g_free(room->name);
+    }
 
-	if (room->distant_description)
-		g_free(room->distant_description);
+    if (room->distant_description) {
+        g_free(room->distant_description);
+    }
 
-	if (room->close_description)
-		g_free(room->close_description);
+    if (room->close_description) {
+        g_free(room->close_description);
+    }
 
-	g_free(room);
+    g_free(room);
 }
 
 void
 wmud_world_free_rooms(GSList *rooms)
 {
-	g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "Freeing rooms list");
+    g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "Freeing rooms list");
 
-	if (rooms) {
+    if (rooms) {
 #if GLIB_CHECK_VERSION(2, 28, 0)
-		g_slist_free_full(rooms, (GDestroyNotify)free_room);
+        g_slist_free_full(rooms, (GDestroyNotify)free_room);
 #else
-		g_slist_foreach(rooms, (GFunc)free_room, NULL);
-		g_slist_free(rooms);
+        g_slist_foreach(rooms, (GFunc)free_room, NULL);
+        g_slist_free(rooms);
 #endif
-	}
+    }
 }
 
 void
 wmud_world_free_exits(GSList *exits)
 {
-	g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "Freeing exits list");
+    g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "Freeing exits list");
 
-	if (exits) {
+    if (exits) {
 #if GLIB_CHECK_VERSION(2, 28, 0)
-		g_slist_free_full(exits, (GDestroyNotify)g_free);
+        g_slist_free_full(exits, (GDestroyNotify)g_free);
 #else
-		g_slist_foreach(exits, (GFunc)g_free, NULL);
-		g_slist_free(exits);
+        g_slist_foreach(exits, (GFunc)g_free, NULL);
+        g_slist_free(exits);
 #endif
-	}
+    }
 }
 
 void
 wmud_world_free_planet_planes(GSList *planet_planes)
 {
-	g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "Freeing planet <-> plane associations list");
+    g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "Freeing planet <-> plane associations list");
 
-	if (planet_planes) {
+    if (planet_planes) {
 #if GLIB_CHECK_VERSION(2, 28, 0)
-		g_slist_free_full(planet_planes, (GDestroyNotify)g_free);
+        g_slist_free_full(planet_planes, (GDestroyNotify)g_free);
 #else
-		g_slist_foreach(planet_planes, (GFunc)g_free, NULL);
-		g_slist_free(planet_planes);
+        g_slist_foreach(planet_planes, (GFunc)g_free, NULL);
+        g_slist_free(planet_planes);
 #endif
-	}
+    }
 }
 
 /**
@@ -669,316 +693,316 @@ wmud_world_free_planet_planes(GSList *planet_planes)
 gboolean
 wmud_world_load(GError **err)
 {
-	GSList *planes = NULL,
-	       *planets = NULL,
-	       *directions = NULL,
-	       *areas = NULL,
-	       *rooms = NULL,
-	       *exits = NULL,
-	       *planet_planes = NULL;
-	GError *in_err = NULL;
-
-	/* Load directions from the database and check them */
-	if (!wmud_db_load_directions(&directions, &in_err)) {
-		g_log(G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, "Could not load directions from database: %s", in_err->message);
-		wmud_world_free_directions(directions);
-		g_clear_error(&in_err);
-
-		return FALSE;
-	}
-
-	if (!directions) {
-		g_log(G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, "No directions were found in the database!");
-		g_clear_error(&in_err);
-
-		return FALSE;
-	}
-
-	g_clear_error(&in_err);
-
-	if (!wmud_interpreter_check_directions(directions, &in_err)) {
-		g_log(G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, "Direction list pre-flight check error: %s", in_err->message);
-		wmud_world_free_directions(directions);
-		g_clear_error(&in_err);
-
-		return FALSE;
-	}
-
-	/* Load planes from the database and check them */
-	g_clear_error(&in_err);
-
-	if (!wmud_db_load_planes(&planes, &in_err)) {
-		g_log(G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, "Could not load planes from database: %s", in_err->message);
-		wmud_world_free_planes(planes);
-		wmud_world_free_directions(directions);
-		g_clear_error(&in_err);
-
-		return FALSE;
-	}
-
-	if (!planes) {
-		g_log(G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, "No planes were found in the database!");
-		wmud_world_free_directions(directions);
-		g_clear_error(&in_err);
-
-		return FALSE;
-	}
-
-	g_clear_error(&in_err);
-
-	if (!wmud_world_check_planes(planes, &in_err)) {
-		g_log(G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, "Plane list pre-flight check error: %s", in_err->message);
-		wmud_world_free_planes(planes);
-		wmud_world_free_directions(directions);
-		g_clear_error(&in_err);
-
-		return FALSE;
-	}
-
-	/* Load planets from the database and check them */
-	g_clear_error(&in_err);
-
-	if (!wmud_db_load_planets(&planets, &in_err)) {
-		g_log(G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, "Could not load planets from database: %s", in_err->message);
-		wmud_world_free_planets(planets);
-		wmud_world_free_planes(planes);
-		wmud_world_free_directions(directions);
-		g_clear_error(&in_err);
-
-		return FALSE;
-	}
-
-	if (!planets) {
-		g_log(G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, "No planets were found in the database!");
-		wmud_world_free_planes(planes);
-		wmud_world_free_directions(directions);
-		g_clear_error(&in_err);
-
-		return FALSE;
-	}
-
-	g_clear_error(&in_err);
-
-	if (!wmud_world_check_planets(planets, &in_err)) {
-		g_log(G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, "Planet list pre-flight check error: %s", in_err->message);
-		wmud_world_free_planets(planets);
-		wmud_world_free_planes(planes);
-		wmud_world_free_directions(directions);
-		g_clear_error(&in_err);
-
-		return FALSE;
-	}
-
-	/* Load areas from the database and check them */
-	g_clear_error(&in_err);
-
-	if (!wmud_db_load_areas(&areas, &in_err)) {
-		g_log(G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, "Could not load areas from database: %s", in_err->message);
-		wmud_world_free_areas(areas);
-		wmud_world_free_planets(planets);
-		wmud_world_free_planes(planes);
-		wmud_world_free_directions(directions);
-		g_clear_error(&in_err);
-
-		return FALSE;
-	}
-
-	if (!areas) {
-		g_log(G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, "No areas were found in the database!");
-		wmud_world_free_planets(planets);
-		wmud_world_free_planes(planes);
-		wmud_world_free_directions(directions);
-		g_clear_error(&in_err);
-
-		return FALSE;
-	}
-
-	g_clear_error(&in_err);
-
-	if (!wmud_world_check_areas(areas, &in_err)) {
-		g_log(G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, "Area list pre-flight check error: %s", in_err->message);
-		wmud_world_free_areas(areas);
-		wmud_world_free_planets(planets);
-		wmud_world_free_planes(planes);
-		wmud_world_free_directions(directions);
-		g_clear_error(&in_err);
-
-		return FALSE;
-	}
-
-	/* Load rooms from the database and check them */
-	g_clear_error(&in_err);
-
-	if (!wmud_db_load_rooms(&rooms, &in_err)) {
-		g_log(G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, "Could not load rooms from database: %s", in_err->message);
-		wmud_world_free_rooms(rooms);
-		wmud_world_free_areas(areas);
-		wmud_world_free_planets(planets);
-		wmud_world_free_planes(planes);
-		wmud_world_free_directions(directions);
-		g_clear_error(&in_err);
-
-		return FALSE;
-	}
-
-	if (!rooms) {
-		g_log(G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, "No rooms were found in the database!");
-		wmud_world_free_areas(areas);
-		wmud_world_free_planets(planets);
-		wmud_world_free_planes(planes);
-		wmud_world_free_directions(directions);
-		g_clear_error(&in_err);
-
-		return FALSE;
-	}
-
-	g_clear_error(&in_err);
-
-	if (!wmud_world_check_rooms(rooms, &in_err)) {
-		g_log(G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, "Room list pre-flight check error: %s", in_err->message);
-		wmud_world_free_rooms(rooms);
-		wmud_world_free_areas(areas);
-		wmud_world_free_planets(planets);
-		wmud_world_free_planes(planes);
-		wmud_world_free_directions(directions);
-		g_clear_error(&in_err);
-
-		return FALSE;
-	}
-
-	/* Load room exits from the database and check them */
-	g_clear_error(&in_err);
-
-	if (!wmud_db_load_exits(&exits, &in_err)) {
-		g_log(G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, "Could not load exits from database: %s", in_err->message);
-		wmud_world_free_exits(exits);
-		wmud_world_free_rooms(rooms);
-		wmud_world_free_areas(areas);
-		wmud_world_free_planets(planets);
-		wmud_world_free_planes(planes);
-		wmud_world_free_directions(directions);
-		g_clear_error(&in_err);
-
-		return FALSE;
-	}
-
-	if (!exits) {
-		g_log(G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, "No exits were found in the database!");
-		wmud_world_free_rooms(rooms);
-		wmud_world_free_areas(areas);
-		wmud_world_free_planets(planets);
-		wmud_world_free_planes(planes);
-		wmud_world_free_directions(directions);
-		g_clear_error(&in_err);
-
-		return FALSE;
-	}
-
-	g_clear_error(&in_err);
-
-	if (!wmud_world_check_exits(exits, directions, rooms, &in_err)) {
-		g_log(G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, "Exit list pre-flight check error: %s", in_err->message);
-		wmud_world_free_rooms(rooms);
-		wmud_world_free_areas(areas);
-		wmud_world_free_planets(planets);
-		wmud_world_free_planes(planes);
-		wmud_world_free_directions(directions);
-		g_clear_error(&in_err);
-
-		return FALSE;
-	}
-
-	/* Load planet-plane associations from the database */
-	g_clear_error(&in_err);
-
-	if (!wmud_db_load_planet_planes(&planet_planes, &in_err)) {
-		g_log(G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, "Could not load planet-plane associations from database: %s", in_err->message);
-		wmud_world_free_planet_planes(planet_planes);
-		wmud_world_free_exits(exits);
-		wmud_world_free_rooms(rooms);
-		wmud_world_free_areas(areas);
-		wmud_world_free_planets(planets);
-		wmud_world_free_planes(planes);
-		wmud_world_free_directions(directions);
-		g_clear_error(&in_err);
-
-		return FALSE;
-	}
-
-	if (!planet_planes) {
-		g_log(G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, "No planet-plane associations were found in the database!");
-		wmud_world_free_exits(exits);
-		wmud_world_free_rooms(rooms);
-		wmud_world_free_areas(areas);
-		wmud_world_free_planets(planets);
-		wmud_world_free_planes(planes);
-		wmud_world_free_directions(directions);
-		g_clear_error(&in_err);
-
-		return FALSE;
-	}
-
-	g_clear_error(&in_err);
-
-	/* World loading finished. Now let's tie the parts together... */
-
-	/* Put the planets on the planes */
-	g_clear_error(&in_err);
-
-	if (!wmud_world_assoc_planets_planes(planets, planes, planet_planes, &in_err)) {
-		g_log(G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, "Planets <-> Planes association error: %s", in_err->message);
-		wmud_world_free_planet_planes(planet_planes);
-		wmud_world_free_exits(exits);
-		wmud_world_free_rooms(rooms);
-		wmud_world_free_areas(areas);
-		wmud_world_free_planets(planets);
-		wmud_world_free_planes(planes);
-		wmud_world_free_directions(directions);
-
-		return FALSE;
-	}
-
-	/* Generate the areas */
-	g_clear_error(&in_err);
-	if (!wmud_world_assoc_rooms_areas(rooms, areas, &in_err)) {
-		g_log(G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, "Rooms <-> Areas association error: %s", in_err->message);
-		wmud_world_free_planet_planes(planet_planes);
-		wmud_world_free_exits(exits);
-		wmud_world_free_rooms(rooms);
-		wmud_world_free_areas(areas);
-		wmud_world_free_planets(planets);
-		wmud_world_free_planes(planes);
-		wmud_world_free_directions(directions);
-
-		return FALSE;
-	}
-
-	/* Teleport the previously built areas to the planets */
-	g_clear_error(&in_err);
-
-	if (!wmud_world_assoc_rooms_planets(rooms, planets, &in_err)) {
-		g_log(G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, "Rooms <-> Planets association error: %s", in_err->message);
-		wmud_world_free_planet_planes(planet_planes);
-		wmud_world_free_exits(exits);
-		wmud_world_free_rooms(rooms);
-		wmud_world_free_areas(areas);
-		wmud_world_free_planets(planets);
-		wmud_world_free_planes(planes);
-		wmud_world_free_directions(directions);
-
-		return FALSE;
-	}
-
-	/* And finally, create the doors between the rooms */
-	g_clear_error(&in_err);
-	wmud_world_assoc_exits_rooms(exits, directions, rooms, &in_err);
-
-	g_clear_error(&in_err);
-
-	wmud_world_free_planet_planes(planet_planes);
-	wmud_world_free_exits(exits);
-
-	g_log(G_LOG_DOMAIN, G_LOG_LEVEL_INFO, "World loading finished without any troubles.");
-
-	return TRUE;
+    GSList *planes        = NULL,
+           *planets       = NULL,
+           *directions    = NULL,
+           *areas         = NULL,
+           *rooms         = NULL,
+           *exits         = NULL,
+           *planet_planes = NULL;
+    GError *in_err        = NULL;
+
+    /* Load directions from the database and check them */
+    if (!wmud_db_load_directions(&directions, &in_err)) {
+        g_log(G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, "Could not load directions from database: %s", in_err->message);
+        wmud_world_free_directions(directions);
+        g_clear_error(&in_err);
+
+        return FALSE;
+    }
+
+    if (!directions) {
+        g_log(G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, "No directions were found in the database!");
+        g_clear_error(&in_err);
+
+        return FALSE;
+    }
+
+    g_clear_error(&in_err);
+
+    if (!wmud_interpreter_check_directions(directions, &in_err)) {
+        g_log(G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, "Direction list pre-flight check error: %s", in_err->message);
+        wmud_world_free_directions(directions);
+        g_clear_error(&in_err);
+
+        return FALSE;
+    }
+
+    /* Load planes from the database and check them */
+    g_clear_error(&in_err);
+
+    if (!wmud_db_load_planes(&planes, &in_err)) {
+        g_log(G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, "Could not load planes from database: %s", in_err->message);
+        wmud_world_free_planes(planes);
+        wmud_world_free_directions(directions);
+        g_clear_error(&in_err);
+
+        return FALSE;
+    }
+
+    if (!planes) {
+        g_log(G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, "No planes were found in the database!");
+        wmud_world_free_directions(directions);
+        g_clear_error(&in_err);
+
+        return FALSE;
+    }
+
+    g_clear_error(&in_err);
+
+    if (!wmud_world_check_planes(planes, &in_err)) {
+        g_log(G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, "Plane list pre-flight check error: %s", in_err->message);
+        wmud_world_free_planes(planes);
+        wmud_world_free_directions(directions);
+        g_clear_error(&in_err);
+
+        return FALSE;
+    }
+
+    /* Load planets from the database and check them */
+    g_clear_error(&in_err);
+
+    if (!wmud_db_load_planets(&planets, &in_err)) {
+        g_log(G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, "Could not load planets from database: %s", in_err->message);
+        wmud_world_free_planets(planets);
+        wmud_world_free_planes(planes);
+        wmud_world_free_directions(directions);
+        g_clear_error(&in_err);
+
+        return FALSE;
+    }
+
+    if (!planets) {
+        g_log(G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, "No planets were found in the database!");
+        wmud_world_free_planes(planes);
+        wmud_world_free_directions(directions);
+        g_clear_error(&in_err);
+
+        return FALSE;
+    }
+
+    g_clear_error(&in_err);
+
+    if (!wmud_world_check_planets(planets, &in_err)) {
+        g_log(G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, "Planet list pre-flight check error: %s", in_err->message);
+        wmud_world_free_planets(planets);
+        wmud_world_free_planes(planes);
+        wmud_world_free_directions(directions);
+        g_clear_error(&in_err);
+
+        return FALSE;
+    }
+
+    /* Load areas from the database and check them */
+    g_clear_error(&in_err);
+
+    if (!wmud_db_load_areas(&areas, &in_err)) {
+        g_log(G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, "Could not load areas from database: %s", in_err->message);
+        wmud_world_free_areas(areas);
+        wmud_world_free_planets(planets);
+        wmud_world_free_planes(planes);
+        wmud_world_free_directions(directions);
+        g_clear_error(&in_err);
+
+        return FALSE;
+    }
+
+    if (!areas) {
+        g_log(G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, "No areas were found in the database!");
+        wmud_world_free_planets(planets);
+        wmud_world_free_planes(planes);
+        wmud_world_free_directions(directions);
+        g_clear_error(&in_err);
+
+        return FALSE;
+    }
+
+    g_clear_error(&in_err);
+
+    if (!wmud_world_check_areas(areas, &in_err)) {
+        g_log(G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, "Area list pre-flight check error: %s", in_err->message);
+        wmud_world_free_areas(areas);
+        wmud_world_free_planets(planets);
+        wmud_world_free_planes(planes);
+        wmud_world_free_directions(directions);
+        g_clear_error(&in_err);
+
+        return FALSE;
+    }
+
+    /* Load rooms from the database and check them */
+    g_clear_error(&in_err);
+
+    if (!wmud_db_load_rooms(&rooms, &in_err)) {
+        g_log(G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, "Could not load rooms from database: %s", in_err->message);
+        wmud_world_free_rooms(rooms);
+        wmud_world_free_areas(areas);
+        wmud_world_free_planets(planets);
+        wmud_world_free_planes(planes);
+        wmud_world_free_directions(directions);
+        g_clear_error(&in_err);
+
+        return FALSE;
+    }
+
+    if (!rooms) {
+        g_log(G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, "No rooms were found in the database!");
+        wmud_world_free_areas(areas);
+        wmud_world_free_planets(planets);
+        wmud_world_free_planes(planes);
+        wmud_world_free_directions(directions);
+        g_clear_error(&in_err);
+
+        return FALSE;
+    }
+
+    g_clear_error(&in_err);
+
+    if (!wmud_world_check_rooms(rooms, &in_err)) {
+        g_log(G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, "Room list pre-flight check error: %s", in_err->message);
+        wmud_world_free_rooms(rooms);
+        wmud_world_free_areas(areas);
+        wmud_world_free_planets(planets);
+        wmud_world_free_planes(planes);
+        wmud_world_free_directions(directions);
+        g_clear_error(&in_err);
+
+        return FALSE;
+    }
+
+    /* Load room exits from the database and check them */
+    g_clear_error(&in_err);
+
+    if (!wmud_db_load_exits(&exits, &in_err)) {
+        g_log(G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, "Could not load exits from database: %s", in_err->message);
+        wmud_world_free_exits(exits);
+        wmud_world_free_rooms(rooms);
+        wmud_world_free_areas(areas);
+        wmud_world_free_planets(planets);
+        wmud_world_free_planes(planes);
+        wmud_world_free_directions(directions);
+        g_clear_error(&in_err);
+
+        return FALSE;
+    }
+
+    if (!exits) {
+        g_log(G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, "No exits were found in the database!");
+        wmud_world_free_rooms(rooms);
+        wmud_world_free_areas(areas);
+        wmud_world_free_planets(planets);
+        wmud_world_free_planes(planes);
+        wmud_world_free_directions(directions);
+        g_clear_error(&in_err);
+
+        return FALSE;
+    }
+
+    g_clear_error(&in_err);
+
+    if (!wmud_world_check_exits(exits, directions, rooms, &in_err)) {
+        g_log(G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, "Exit list pre-flight check error: %s", in_err->message);
+        wmud_world_free_rooms(rooms);
+        wmud_world_free_areas(areas);
+        wmud_world_free_planets(planets);
+        wmud_world_free_planes(planes);
+        wmud_world_free_directions(directions);
+        g_clear_error(&in_err);
+
+        return FALSE;
+    }
+
+    /* Load planet-plane associations from the database */
+    g_clear_error(&in_err);
+
+    if (!wmud_db_load_planet_planes(&planet_planes, &in_err)) {
+        g_log(G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, "Could not load planet-plane associations from database: %s", in_err->message);
+        wmud_world_free_planet_planes(planet_planes);
+        wmud_world_free_exits(exits);
+        wmud_world_free_rooms(rooms);
+        wmud_world_free_areas(areas);
+        wmud_world_free_planets(planets);
+        wmud_world_free_planes(planes);
+        wmud_world_free_directions(directions);
+        g_clear_error(&in_err);
+
+        return FALSE;
+    }
+
+    if (!planet_planes) {
+        g_log(G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, "No planet-plane associations were found in the database!");
+        wmud_world_free_exits(exits);
+        wmud_world_free_rooms(rooms);
+        wmud_world_free_areas(areas);
+        wmud_world_free_planets(planets);
+        wmud_world_free_planes(planes);
+        wmud_world_free_directions(directions);
+        g_clear_error(&in_err);
+
+        return FALSE;
+    }
+
+    g_clear_error(&in_err);
+
+    /* World loading finished. Now let's tie the parts together... */
+
+    /* Put the planets on the planes */
+    g_clear_error(&in_err);
+
+    if (!wmud_world_assoc_planets_planes(planets, planes, planet_planes, &in_err)) {
+        g_log(G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, "Planets <-> Planes association error: %s", in_err->message);
+        wmud_world_free_planet_planes(planet_planes);
+        wmud_world_free_exits(exits);
+        wmud_world_free_rooms(rooms);
+        wmud_world_free_areas(areas);
+        wmud_world_free_planets(planets);
+        wmud_world_free_planes(planes);
+        wmud_world_free_directions(directions);
+
+        return FALSE;
+    }
+
+    /* Generate the areas */
+    g_clear_error(&in_err);
+    if (!wmud_world_assoc_rooms_areas(rooms, areas, &in_err)) {
+        g_log(G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, "Rooms <-> Areas association error: %s", in_err->message);
+        wmud_world_free_planet_planes(planet_planes);
+        wmud_world_free_exits(exits);
+        wmud_world_free_rooms(rooms);
+        wmud_world_free_areas(areas);
+        wmud_world_free_planets(planets);
+        wmud_world_free_planes(planes);
+        wmud_world_free_directions(directions);
+
+        return FALSE;
+    }
+
+    /* Teleport the previously built areas to the planets */
+    g_clear_error(&in_err);
+
+    if (!wmud_world_assoc_rooms_planets(rooms, planets, &in_err)) {
+        g_log(G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, "Rooms <-> Planets association error: %s", in_err->message);
+        wmud_world_free_planet_planes(planet_planes);
+        wmud_world_free_exits(exits);
+        wmud_world_free_rooms(rooms);
+        wmud_world_free_areas(areas);
+        wmud_world_free_planets(planets);
+        wmud_world_free_planes(planes);
+        wmud_world_free_directions(directions);
+
+        return FALSE;
+    }
+
+    /* And finally, create the doors between the rooms */
+    g_clear_error(&in_err);
+    wmud_world_assoc_exits_rooms(exits, directions, rooms, &in_err);
+
+    g_clear_error(&in_err);
+
+    wmud_world_free_planet_planes(planet_planes);
+    wmud_world_free_exits(exits);
+
+    g_log(G_LOG_DOMAIN, G_LOG_LEVEL_INFO, "World loading finished without any troubles.");
+
+    return TRUE;
 }