/* misc.c */
#include "misc.h"
-#include <stdio.h> /* for rename() */
+#include <errno.h> /* for errno */
#include <unistd.h> /* for unlink(), acess() */
-#include <stdlib.h> /* for calloc(), free() */
+#include <stdlib.h> /* for size_t, calloc(), free() */
#include <string.h> /* for strlen(), strcmp(), memcpy() */
-#include <stdint.h> /* for uint8_t, uint16_t */
-#include "readwrite.h" /* for [read/write]_uint[8/16/32][_bigendian]() */
-#include "map_objects.h" /* for struct Monster, write_map_objects(), */
-#include "map_object_actions.h" /* for is_passable(), move_monster() */
-#include "map.h" /* for Map struct */
-#include "main.h" /* for World struct */
+#include <stdint.h> /* for uint8_t, uint16_t, uint32_t */
+#include "readwrite.h" /* for [read/write]_uint[8/16/32][_bigendian](),
+ * try_fopen(), try_fclose(), get_linemax()
+ */
+#include "map_objects.h" /* for struct MapObj, get_player(), read_map_objects(),
+ * write_map_objects()
+ */
+#include "map_object_actions.h" /* for struct MapObjAct */
+#include "ai.h" /* for pretty_dumb_ai() */
+#include "map.h" /* for Map struct, is_passable() */
+#include "main.h" /* for world global */
#include "yx_uint16.h" /* for yx_uint16 struct */
-#include "rrand.h" /* for rrand(), rrand_seed() */
-#include "rexit.h" /* for exit_err() */
+#include "rexit.h" /* for exit_err(), exit_trouble() */
+#include "wincontrol.h" /* for init_winconfs(), init_wins(), free_winconfs(),
+ * sorted_wintoggle_and_activate()
+ */
+#include "windows.h" /* for suspend_win() */
+#include "command_db.h" /* for is_command_id_shortdsc() */
-extern void update_log(struct World * world, char * text)
+extern uint16_t rrand()
{
+ /* Constants as recommended by POSIX.1-2001 (see man page rand(3)). */
+ world.seed = ((world.seed * 1103515245) + 12345) % 4294967296;
+ return (world.seed >> 16); /* Ignore less random least significant bits. */
+}
+
+
+
+extern void * try_malloc(size_t size, char * f)
+{
+ void * p = malloc(size);
+ exit_trouble(NULL == p, f, "malloc()");
+ return p;
+}
+
+
+
+extern void * try_calloc(size_t size1, size_t size2, char * f)
+{
+ void * p = calloc(size1, size2);
+ exit_trouble(NULL == p, f, "calloc()");
+ return p;
+}
+
+
+
+extern void check_files_xor(char * p1, char * p2)
+{
+ char * msg1 = "A file '";
+ char * msg2 = "' exists, but no file '";
+ char * msg3 = "'. If everything was in order, both or noe would exist. "
+ "The game won't start until this is corrected.";
+ uint16_t size = strlen(msg1) + strlen(p1) + strlen(msg2) + strlen(p2)
+ + strlen(msg3);
+ char msg[size];
+ if (!access(p1, F_OK) && access(p2, F_OK))
+ {
+ sprintf(msg, "%s%s%s%s%s", msg1, p1, msg2, p2, msg3);
+ errno = 0;
+ exit_err(1, msg);
+ }
+ else if (access(p1, F_OK) && !access(p2, F_OK))
+ {
+ sprintf(msg, "%s%s%s%s%s", msg1, p2, msg2, p1, msg3);
+ errno = 0;
+ exit_err(1, msg);
+ }
+}
+
+
+
+extern void check_tempfile(char * path)
+{
+ char * msg1 = "A file '";
+ char * msg2 = "' exists, probably from a corrupted previous file saving "
+ "process. To avoid corruption of game files, the game won't "
+ "start until it is removed or renamed.";
+ uint16_t size = strlen(msg1) + strlen(path) + strlen(msg2);
+ char msg[size];
+ sprintf(msg, "%s%s%s", msg1, path, msg2);
+ exit_err(!access(path, F_OK), msg);
+}
+
+
+
+extern void save_interface_conf()
+{
+ save_keybindings("config/keybindings_global", &world.kb_global);
+ save_keybindings("config/keybindings_wingeom", &world.kb_wingeom);
+ save_keybindings("config/keybindings_winkeys", &world.kb_winkeys);
+ save_win_configs();
+}
+
+
+
+extern void load_interface_conf()
+{
+ init_keybindings("config/keybindings_global", &world.kb_global);
+ init_keybindings("config/keybindings_wingeom", &world.kb_wingeom);
+ init_keybindings("config/keybindings_winkeys", &world.kb_winkeys);
+ init_winconfs();
+ init_wins();
+ sorted_wintoggle_and_activate();
+}
+
+
+
+extern void unload_interface_conf()
+{
+ free_keybindings(world.kb_global.kbs);
+ free_keybindings(world.kb_wingeom.kbs);
+ free_keybindings(world.kb_winkeys.kbs);
+ while (0 != world.wmeta->active)
+ {
+ suspend_win(world.wmeta->active);
+ }
+ free_winconfs();
+}
+
+
+
+extern void reload_interface_conf()
+{
+ unload_interface_conf();
+ load_interface_conf();
+}
+
+
+
+extern void update_log(char * text)
+{
+ char * f_name = "update_log()";
static char * last_msg; /* TODO: valgrind is dissatisfied */
- if (0 == last_msg) /* with this calloc'd pointer */
- { /* never being freed. */
- last_msg = calloc(1, sizeof(char)); /* Rectify this ? */
+ if (0 == last_msg) /* with this calloc'd pointer not */
+ { /* being freed. Rectify this? */
+ last_msg = try_calloc(1, sizeof(char), f_name);
}
char * new_text;
- uint16_t len_old = strlen(world->log);
+ uint16_t len_old = strlen(world.log);
if (0 == strcmp(last_msg, text))
{
uint16_t len_whole = len_old + 1;
- new_text = calloc(len_whole + 1, sizeof(char));
- memcpy(new_text, world->log, len_old);
+ new_text = try_calloc(len_whole + 1, sizeof(char), f_name);
+ memcpy(new_text, world.log, len_old);
memcpy(new_text + len_old, ".", 1);
}
else
{
uint16_t len_new = strlen(text);
uint16_t len_whole = len_old + len_new + 1;
- new_text = calloc(len_whole, sizeof(char));
- memcpy(new_text, world->log, len_old);
+ new_text = try_calloc(len_whole, sizeof(char), f_name);
+ memcpy(new_text, world.log, len_old);
memcpy(new_text + len_old, text, len_new);
- last_msg = calloc(len_new + 1, sizeof(char));
+ last_msg = try_calloc(len_new + 1, sizeof(char), f_name);
memcpy(last_msg, text, len_new);
}
- free(world->log);
- world->log = new_text;
+ free(world.log);
+ world.log = new_text;
}
-extern void turn_over(struct World * world, char action)
+extern void turn_over(char action)
{
- char * err_open = "Trouble in turn_over() with fopen() "
- "opening file 'record_tmp' for appending.";
+ char * f_name = "turn_over()";
char * err_write = "Trouble in turn_over() with write_uint8() "
"writing to opened file 'record_tmp'.";
- char * err_close = "Trouble in turn_over() with fclose() "
- "closing opened file 'record'.";
- char * err_unl = "Trouble in turn_over() with unlink() "
- "unlinking old file 'record'.";
- char * err_move = "Trouble in turn_over() with rename() "
- "renaming file 'record_tmp' to 'record'.";
+
char * recordfile_tmp = "record_tmp";
char * recordfile = "record";
- if (1 == world->interactive)
+ if (1 == world.interactive)
{
- FILE * file_old = fopen(recordfile, "r");
- FILE * file_new = fopen(recordfile_tmp, "w");
- exit_err(0 == file_old, world, err_open);
+ FILE * file_old = try_fopen(recordfile, "r", f_name);
+ FILE * file_new = try_fopen(recordfile_tmp, "w", f_name);
char c = fgetc(file_old);
while (EOF != c)
{
- exit_err(write_uint8(c, file_new), world, err_write);
+ exit_err(write_uint8(c, file_new), err_write);
c = fgetc(file_old);
}
- exit_err(fclose(file_old), world, err_close);
- exit_err(write_uint8(action, file_new), world, err_write);
- err_close = "Trouble in turn_over() with fclose() "
- "closing opened file 'record_tmp'.";
- exit_err(fclose(file_new), world, err_close);
- exit_err(unlink(recordfile), world, err_unl);
- exit_err(rename(recordfile_tmp, recordfile), world, err_move);
+ try_fclose(file_old, f_name);
+ exit_err(write_uint8(action, file_new), err_write);
+ if ( is_command_id_shortdsc(action, "drop")
+ || is_command_id_shortdsc(action, "use"))
+ {
+ exit_err(write_uint8(world.inventory_select, file_new), err_write);
+ }
+ try_fclose_unlink_rename(file_new, recordfile_tmp, recordfile, f_name);
}
- world->turn++;
- rrand_seed(world->seed * world->turn);
- struct Monster * monster;
- for (monster = world->monster;
- monster != 0;
- monster = monster->map_obj.next)
+
+ struct MapObj * player = get_player();
+ struct MapObj * map_object = player;
+ uint8_t first_round = 1;
+ while (0 < player->lifepoints)
{
- move_monster(world, monster);
+ if (NULL == map_object)
+ {
+ world.turn++;
+ map_object = world.map_objs;
+ }
+ if (0 < map_object->lifepoints) /* map_object is animate. */
+ {
+ if (0 == first_round && 0 == map_object->progress)
+ {
+ if (map_object == player)
+ {
+ break;
+ }
+ pretty_dumb_ai(map_object);
+ }
+ first_round = 0;
+ map_object->progress++;
+ struct MapObjAct * moa = world.map_obj_acts;
+ while (moa->id != map_object->command)
+ {
+ moa = moa->next;
+ }
+ if (map_object->progress == moa->effort)
+ {
+ moa->func(map_object);
+ map_object->progress = 0;
+ }
+ }
+ map_object = map_object->next;
}
}
-extern void save_game(struct World * world)
+extern void save_game()
{
- char * err_open = "Trouble in save_game() with fopen() "
- "opening file 'savefile_tmp' for writing.";
- char * err_write = "Trouble in save_game() "
- "writing to opened file 'savefile_tmp'.";
- char * err_close = "Trouble in save_game() with fclose() "
- "closing opened file 'savefile_tmp'.";
- char * err_unl = "Trouble in save_game() with unlink() "
- "unlinking old 'savefile' file.";
- char * err_move = "Trouble in save_game() with rename() "
- "renaming 'file savefile_tmp' to 'savefile'.";
+ char * f_name = "save_game()";
char * savefile_tmp = "savefile_tmp";
char * savefile = "savefile";
- FILE * file = fopen(savefile_tmp, "w");
- exit_err(0 == file, world, err_open);
- if ( write_uint32_bigendian(world->seed, file)
- || write_uint32_bigendian(world->turn, file)
- || write_uint16_bigendian(world->score, file)
- || write_uint16_bigendian(world->player->pos.y + 1, file)
- || write_uint16_bigendian(world->player->pos.x + 1, file)
- || write_uint8(world->player->hitpoints, file)
- || write_map_objects(world, world->monster, file)
- || write_map_objects(world, world->item, file))
- {
- exit_err(1, world, err_write);
- }
- exit_err(fclose(file), world, err_close);
- if (!access(savefile, F_OK))
- {
- exit_err(unlink(savefile), world, err_unl);
- }
- exit_err(rename(savefile_tmp, savefile), world, err_move);
+ FILE * file = try_fopen(savefile_tmp, "w", f_name);
+ char line[12];
+ sprintf(line, "%u\n", world.mapseed);
+ try_fwrite(line, strlen(line), 1, file, f_name);
+ sprintf(line, "%u\n", world.seed);
+ try_fwrite(line, strlen(line), 1, file, f_name);
+ sprintf(line, "%u\n", world.turn);
+ try_fwrite(line, strlen(line), 1, file, f_name);
+ sprintf(line, "%u\n", world.score);
+ try_fwrite(line, strlen(line), 1, file, f_name);
+ write_map_objects(file);
+ try_fclose_unlink_rename(file, savefile_tmp, savefile, f_name);
+}
+
+
+
+extern void load_game()
+{
+ char * f_name = "load_game2()";
+ char * filename = "savefile";
+ FILE * file = try_fopen(filename, "r", f_name);
+ uint16_t linemax = get_linemax(file, f_name);
+ char line[linemax + 1];
+ try_fgets(line, linemax + 1, file, f_name);
+ world.mapseed = atoi(line);
+ try_fgets(line, linemax + 1, file, f_name);
+ world.seed = atoi(line);
+ try_fgets(line, linemax + 1, file, f_name);
+ world.turn = atoi(line);
+ try_fgets(line, linemax + 1, file, f_name);
+ world.score = atoi(line);
+ read_map_objects(file, line, linemax);
+ try_fclose(file, f_name);
}
}
return pos;
}
+
+
+
+extern void nav_inventory(char dir)
+{
+ if ('u' == dir)
+ {
+ if (world.inventory_select > 0)
+ {
+ world.inventory_select--;
+ }
+ return;
+ }
+ struct MapObj * player = get_player();
+ struct MapObj * owned = player->owns;
+ if (NULL == owned)
+ {
+ return;
+ }
+ uint8_t n_owned = 0;
+ for (; NULL != owned->next; owned = owned->next, n_owned++);
+ if (world.inventory_select < n_owned)
+ {
+ world.inventory_select++;
+ }
+}