X-Git-Url: https://plomlompom.com/repos/?a=blobdiff_plain;f=src%2Fmain.c;h=bd25c4fcdd840244a72577ce78e9c912a11880bc;hb=f8325a4ea617b15315183d7a8027c0b913c91034;hp=f7007b7d477232601ef065c8f27af0373ed93a75;hpb=7bebc9943d1648d56968146b17c9459affb183c6;p=plomrogue

diff --git a/src/main.c b/src/main.c
index f7007b7..bd25c4f 100644
--- a/src/main.c
+++ b/src/main.c
@@ -2,37 +2,71 @@
 
 #include "main.h"
 #include <stdlib.h> /* for atoi(), exit(), EXIT_FAILURE, calloc() */
-#include <stdio.h> /* for FILE typedef, F_OK */
+#include <stdio.h> /* for FILE typedef, F_OK, rename() */
 #include <ncurses.h> /* for initscr(), noecho(), curs_set(), keypad(), raw() */
 #include <time.h> /* for time() */
 #include <unistd.h> /* for getopt(), optarg */
+#include <stdint.h> /* for uint16_t, uint32_t */
+#include <errno.h> /* for errno */
 #include "windows.h" /* for structs WinMeta, Win, init_win(), init_win_meta(),
                       * draw_all_wins()
                       */
 #include "draw_wins.h" /* for draw_keys_win(), draw_map_win(), draw_info_win(),
                         * draw_log_win()
                         */
-#include "keybindings.h" /* for initkeybindings(), get_action_key() */
-#include "readwrite.h" /* for read_uint16_bigendian, read_uint32_bigendian,
-                        * write_uint32_bigendian
-                        */
+#include "keybindings.h" /* for init_keybindings(), get_action_key() */
+#include "readwrite.h" /* for [read/write]_uint[8/16/32][_bigendian]() */
 #include "map_objects.h" /* for structs Monster, Item, Player,
                           * init_map_object_defs(), read_map_objects(),
                           * build_map_objects()
                           */
-#include "map_object_actions.h" /* for player_wait(), move_player() */
 #include "map.h" /* for struct Map, init_map() */
-#include "misc.h" /* for update_log(), toggle_window(), find_passable_pos(),
-                   * meta_keys(), save_game()
-                   */
-#include "yx_uint16.h" /* for dir enum */
+#include "misc.h" /* for update_log(), find_passable_pos(), save_game() */
+#include "wincontrol.h" /* for toggle_window() */
 #include "rrand.h" /* for rrand(), rrand_seed() */
 #include "rexit.h" /* for exit_game() */
+#include "control.h" /* for meta_control() */
+#include "command_db.h" /* for init_command_db() */
+
+
 
 int main(int argc, char *argv[])
 {
     struct World world;
 
+    init_command_db(&world);
+    set_cleanup_flag(CLEANUP_COMMAND_DB);
+
+    /* Check for corrupted savefile / recordfile savings. */
+    char * recordfile = "record";
+    char * savefile = "savefile";
+    char * recordfile_tmp = "record_tmp";
+    char * savefile_tmp   = "savefile_tmp";
+    char * err_x = "A file 'record' exists, but no 'savefile'. If everything "
+                   "was in order, both or none would exist. I won't start "
+                   "until this is corrected.";
+    if (!access(recordfile, F_OK) && access(savefile, F_OK))
+    {
+        errno = 0;
+        exit_err(1, &world, err_x);
+    }
+    err_x        = "A 'savefile' exists, but no file 'record'. If everything "
+                   "was in order, both or none would exist. I won't start "
+                   "until this is corrected.";
+    if (!access(savefile, F_OK) && access(recordfile, F_OK))
+    {
+        errno = 0;
+        exit_err(1, &world, err_x);
+    }
+    err_x        = "A file 'recordfile_tmp' exists, probably from a corrupted "
+                   "previous record saving process. To avoid game record "
+                   "corruption, I won't start until it is removed or renamed.";
+    exit_err(!access(recordfile_tmp, F_OK), &world, err_x);
+    err_x        = "A file 'savefile_tmp' exists, probably from a corrupted "
+                   "previous game saving process. To avoid savegame "
+                   "corruption, I won't start until it is removed or renamed.";
+    exit_err(!access(savefile_tmp,   F_OK), &world, err_x);
+
     /* Read in startup options (i.e. replay option and replay start turn). */
     int opt;
     uint32_t start_turn;
@@ -42,17 +76,24 @@ int main(int argc, char *argv[])
         switch (opt)
         {
             case 's':
+            {
                 world.interactive = 0;
                 start_turn = 0;
                 if (optarg)
+                {
                     start_turn = atoi(optarg);
-                 break;
+                }
+                break;
+            }
             default:
+            {
                 exit(EXIT_FAILURE);
+            }
         }
     }
 
     /* Initialize log, player, monster/item definitions and monsters/items. */
+    world.score = 0;
     world.log = calloc(1, sizeof(char));
     set_cleanup_flag(CLEANUP_LOG);
     update_log (&world, " ");
@@ -61,44 +102,75 @@ int main(int argc, char *argv[])
     world.player = &player;
     world.monster = 0;
     world.item = 0;
-    init_map_object_defs(&world, "defs");
+    init_map_object_defs(&world, "config/defs");
 
     /* For interactive mode, try to load world state from savefile. */
+    char * err_o = "Trouble loading game (fopen() in main()) / "
+                   "opening 'savefile' for reading.";
+    char * err_r = "Trouble loading game (in main()) / "
+                   "reading from opened 'savefile'.";
+    char * err_c = "Trouble loading game (fclose() in main()) / "
+                   "closing opened 'savefile'.";
     FILE * file;
-    if (1 == world.interactive && 0 == access("savefile", F_OK))
+    if (1 == world.interactive && 0 == access(savefile, F_OK))
     {
-        file = fopen("savefile", "r");
-        world.seed = read_uint32_bigendian(file);
-        world.turn = read_uint32_bigendian(file);
-        player.pos.y = read_uint16_bigendian(file) - 1;
-        player.pos.x = read_uint16_bigendian(file) - 1;
-        player.hitpoints = fgetc(file);
-        read_map_objects(&world, &world.monster, file);
-        read_map_objects(&world, &world.item,    file);
-        fclose(file);
+        file = fopen(savefile, "r");
+        exit_err(0 == file, &world, err_o);
+        if (   read_uint32_bigendian(file, &world.seed)
+            || read_uint32_bigendian(file, &world.turn)
+            || read_uint16_bigendian(file, &world.score)
+            || read_uint16_bigendian(file, &player.pos.y)
+            || read_uint16_bigendian(file, &player.pos.x)
+            || read_uint8(file, &player.hitpoints)
+            || read_map_objects(&world, &world.monster, file)
+            || read_map_objects(&world, &world.item,    file))
+        {
+            exit_err(1, &world, err_r);
+        }
+        exit_err(fclose(file), &world, err_c);
+        player.pos.y--;
+        player.pos.x--;
     }
 
     /* For non-interactive mode, try to load world state from record file. */
     else
     {
+        err_o = "Trouble loading record file (fopen() in main()) / "
+                "opening file 'record' for reading.";
+        err_r = "Trouble loading record file (read_uint32_bigendian() in "
+                "main()) / reading from opened file 'record'.";
         world.turn = 1;
         if (0 == world.interactive)
         {
-            file = fopen("record", "r");
-            world.seed = read_uint32_bigendian(file);
+            file = fopen(recordfile, "r");
+            exit_err(NULL == file, &world, err_o);
+            exit_err(read_uint32_bigendian(file, &world.seed), &world, err_r);
+        }
+
+        /* For interactive-mode in newly started world, generate a start seed
+         * from the current time.
+         */
+        else
+        {
+            world.seed = time(NULL);
+
+            err_o        = "Trouble recording new seed (fopen() in main()) / "
+                           "opening 'record_tmp' file for writing.";
+            char * err_w = "Trouble recording new seed "
+                           "(write_uint32_bigendian() in main()) / writing to "
+                           "opened file 'record_tmp'.";
+            err_c        = "Trouble recording new seed (fclose() in main()) / "
+                           "closing opened file 'record_tmp'.";
+            char * err_m = "Trouble recording new seed (rename() in main()) : "
+                           "renaming file 'record_tmp' to 'record'.";
+            file = fopen(recordfile_tmp, "w");
+            exit_err(0 == file, &world, err_o);
+            exit_err(write_uint32_bigendian(world.seed, file), &world, err_w);
+            exit_err(fclose(file), &world, err_c);
+            exit_err(rename(recordfile_tmp, recordfile), &world, err_m);
         }
+    }
 
-      /* For interactive-mode in newly started world, generate a start seed
-       * from the current time.
-       */
-      else
-      {
-          file = fopen("record", "w");
-          world.seed = time(NULL);
-          write_uint32_bigendian(world.seed, file);
-          fclose(file);
-      }
-  }
 
     /* Generate map from seed and, if newly generated world, start positions of
      * actors.
@@ -109,7 +181,7 @@ int main(int argc, char *argv[])
     set_cleanup_flag(CLEANUP_MAP);
     if (1 == world.turn)
     {
-        player.pos = find_passable_pos(&map);
+        player.pos = find_passable_pos(world.map);
         void * foo;
         foo = build_map_objects(&world, &world.monster, 1, 1 + rrand() % 27);
         foo = build_map_objects(&world, foo, 2, 1 + rrand() % 9);
@@ -127,141 +199,75 @@ int main(int argc, char *argv[])
     raw();
     init_keybindings(&world);
     set_cleanup_flag(CLEANUP_KEYBINDINGS);
-    struct WinMeta win_meta = init_win_meta(screen);
-    struct Win win_keys = init_win(&win_meta, "Keys",
-                                   0, 29, &world, draw_keys_win);
-    struct Win win_info = init_win(&win_meta, "Info",
-                                   2, 20, &world, draw_info_win);
-    uint16_t height_logwin = win_meta.padframe.size.y
-                             - (2 + win_info.frame.size.y);
-    struct Win win_log = init_win(&win_meta, "Log",
-                                  height_logwin, 20, &world, draw_log_win);
-    uint16_t width_mapwin = win_meta.padframe.size.x - win_keys.frame.size.x
-                             - win_log.frame.size.x - 2;
-    struct Win win_map = init_win(&win_meta, "Map",
-                                  0, width_mapwin, &world, draw_map_win);
-    toggle_window(&win_meta, &win_keys);
-    toggle_window(&win_meta, &win_map);
-    toggle_window(&win_meta, &win_info);
-    toggle_window(&win_meta, &win_log);
+    struct WinMeta win_meta;
+    char * err_winmem = "Trouble with init_win_meta() or draw_all_wins() in "
+                        "main().";
+    exit_err(init_win_meta(screen, &win_meta), &world, err_winmem);
+    world.wins.meta = &win_meta;
+    struct Win win_keys = init_win_from_file(&world, "Keys", draw_keys_win);
+    struct Win win_info = init_win_from_file(&world, "Info", draw_info_win);
+    struct Win win_log  = init_win_from_file(&world, "Log",  draw_log_win);
+    struct Win win_map  = init_win_from_file(&world, "Map",  draw_map_win);
+    world.wins.keys = &win_keys;
+    world.wins.log  = &win_log;
+    world.wins.info = &win_info;
+    world.wins.map  = &win_map;
+    sorted_wintoggle(&world);
 
     /* Replay mode. */
     int key;
-    unsigned char quit_called = 0;
-    unsigned char await_actions = 1;
     if (0 == world.interactive)
     {
-        int action;
-        while (1)
+        int action = 0;
+        if (0 != start_turn)
         {
-            if (start_turn == world.turn)
-            {
-                start_turn = 0;
-            }
-            if (0 == start_turn)
-            {
-                draw_all_wins (&win_meta);
-               key = getch();
-            }
-            if (1 == await_actions
-                && (world.turn < start_turn
-                    || key == get_action_key(world.keybindings,
-                                             "wait / next turn")) )
+            while (world.turn != start_turn)
             {
                 action = getc(file);
                 if (EOF == action)
                 {
-                    start_turn = 0;
-                    await_actions = 0;
-                }
-                else if (0 == action)
-                {
-                    player_wait (&world);
-                }
-                else if (NORTH == action)
-                {
-                    move_player(&world, NORTH);
-                }
-                else if (EAST  == action)
-                {
-                    move_player(&world, EAST);
-                }
-                else if (SOUTH == action)
-                {
-                    move_player(&world, SOUTH);
-                }
-                else if (WEST == action)
-                {
-                    move_player(&world, WEST);
+                    break;
                 }
+                record_control(action, &world);
             }
-            else
+        }
+        while (1)
+        {
+            draw_all_wins(&win_meta);
+            key = getch();
+            if (   EOF != action
+                && key == get_action_key(world.keybindings, "wait"))
             {
-                quit_called = meta_keys(key, &world, &win_meta, &win_keys,
-                                             &win_map, &win_info, &win_log);
-                if (1 == quit_called)
+                action = getc(file);
+                if (EOF != action)
                 {
-                    exit_game(&world);
+                    record_control(action, &world);
                 }
             }
+            else if (meta_control(key, &world))
+            {
+                err_c = "Trouble closing 'record' file (fclose() in main()).";
+                exit_err(fclose(file), &world, err_c);
+                exit_game(&world);
+            }
         }
     }
 
     /* Interactive mode. */
     else
     {
-        uint32_t last_turn = 0;
         while (1)
         {
-            if (last_turn != world.turn)
-            {
-                save_game(&world);
-                last_turn = world.turn;
-            }
-            if (1 == await_actions && 0 == player.hitpoints)
-            {
-                await_actions = 0;
-            }
-            draw_all_wins (&win_meta);
+            save_game(&world);
+            draw_all_wins(&win_meta);
             key = getch();
-            if      (1 == await_actions
-                     && key == get_action_key(world.keybindings,
-                                              "player up"))
-            {
-                move_player(&world, NORTH);
-            }
-            else if (1 == await_actions
-                     && key == get_action_key(world.keybindings,
-                                              "player right"))
-            {
-                move_player(&world, EAST);
-            }
-            else if (1 == await_actions
-                     && key == get_action_key(world.keybindings,
-                                              "player down"))
-            {
-                move_player(&world, SOUTH);
-            }
-            else if (1 == await_actions
-                     && key == get_action_key(world.keybindings,
-                                              "player left"))
+            if (0 != player.hitpoints && 0 == player_control(key, &world))
             {
-                move_player(&world, WEST);
+                continue;
             }
-            else if (1 == await_actions
-                     && key == get_action_key(world.keybindings,
-                                              "wait / next turn"))
+            if (meta_control(key, &world))
             {
-                player_wait (&world);
-            }
-            else
-            {
-                quit_called = meta_keys(key, &world, &win_meta, &win_keys,
-                                             &win_map, &win_info, &win_log);
-                if (1 == quit_called)
-                {
-                    exit_game(&world);
-                }
+                exit_game(&world);
             }
         }
     }