/* 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 "readwrite.h" /* for [read/write]_uint[8/16/32][_bigendian](),
+ * try_fopen(), try_fclose()
+ */
+#include "map_objects.h" /* for struct MapObj, get_player(), read_map_objects(),
+ * write_map_objects()
+ */
+#include "map_object_actions.h" /* for is_passable(), move_actor() */
#include "map.h" /* for Map struct */
#include "main.h" /* for World struct */
#include "yx_uint16.h" /* for yx_uint16 struct */
#include "rrand.h" /* for rrand(), rrand_seed() */
#include "rexit.h" /* for exit_err() */
+#include "wincontrol.h" /* for init_winconfs(), init_wins(), free_winconfs(),
+ * sorted_wintoggle_and_activate()
+ */
+#include "windows.h" /* for suspend_win() */
+
+
+extern char * trouble_msg(struct World * w, char * parent, char * child)
+{
+ char * p1 = "Trouble in ";
+ char * p2 = " with ";
+ char * p3 = ".";
+ uint16_t size = strlen(p1) + strlen(parent) + strlen(p2) + strlen(child)
+ + strlen(p3) + 1;
+ char * msg = malloc(size);
+ exit_err(NULL == msg, w, "malloc() in trouble_msg() failed.");
+ sprintf(msg, "%s%s%s%s%s", p1, parent, p2, child, p3);
+ return msg;
+}
+
+
+
+extern void * try_malloc(size_t size, struct World * w, char * f)
+{
+ char * msg = trouble_msg(w, f, "malloc()");
+ void * p = malloc(size);
+ exit_err(NULL == p, w, msg);
+ free(msg);
+ return p;
+}
-extern uint8_t textfile_sizes(FILE * file, uint16_t * linemax_p,
- uint16_t * n_lines_p)
+extern void * try_calloc(size_t size1, size_t size2, struct World * w, char * f)
{
- uint16_t n_lines = 0;
- int c = 0;
- uint16_t linemax = 0;
- uint16_t c_count = 0;
- while (EOF != c)
+ char * msg = trouble_msg(w, f, "calloc()");
+ void * p = calloc(size1, size2);
+ exit_err(NULL == p, w, msg);
+ free(msg);
+ return p;
+}
+
+
+
+extern void check_files_xor(char * p1, char * p2, struct World * w)
+{
+ 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))
{
- c_count++;
- c = getc(file);
- if ('\n' == c)
- {
- if (c_count > linemax)
- {
- linemax = c_count + 1;
- }
- c_count = 0;
- if (n_lines_p)
- {
- n_lines++;
- }
- }
+ sprintf(msg, "%s%s%s%s%s", msg1, p1, msg2, p2, msg3);
+ errno = 0;
+ exit_err(1, w, msg);
}
- if (-1 == fseek(file, 0, SEEK_SET))
+ else if (access(p1, F_OK) && !access(p2, F_OK))
{
- return 1;
+ sprintf(msg, "%s%s%s%s%s", msg1, p2, msg2, p1, msg3);
+ errno = 0;
+ exit_err(1, w, msg);
}
- * linemax_p = linemax;
- if (n_lines_p)
+}
+
+
+
+extern void check_tempfile(char * path, struct World * w)
+{
+ 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), w, msg);
+}
+
+
+
+extern void save_interface_conf(struct World * world)
+{
+ save_keybindings(world, "config/keybindings_global", &world->kb_global);
+ save_keybindings(world, "config/keybindings_wingeom", &world->kb_wingeom);
+ save_keybindings(world, "config/keybindings_winkeys", &world->kb_winkeys);
+ save_win_configs(world);
+}
+
+
+
+extern void load_interface_conf(struct World * world)
+{
+ init_keybindings(world, "config/keybindings_global", &world->kb_global);
+ init_keybindings(world, "config/keybindings_wingeom", &world->kb_wingeom);
+ init_keybindings(world, "config/keybindings_winkeys", &world->kb_winkeys);
+ init_winconfs(world);
+ init_wins(world);
+ sorted_wintoggle_and_activate(world);
+}
+
+
+
+extern void unload_interface_conf(struct World * world)
+{
+ free_keybindings(world->kb_global.kbs);
+ free_keybindings(world->kb_wingeom.kbs);
+ free_keybindings(world->kb_winkeys.kbs);
+ while (0 != world->wmeta->active)
{
- * n_lines_p = n_lines;
+ suspend_win(world->wmeta, world->wmeta->active);
}
- return 0;
+ free_winconfs(world);
}
extern void update_log(struct World * world, 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), world, f_name);
}
char * new_text;
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));
+ new_text = try_calloc(len_whole + 1, sizeof(char), world, f_name);
memcpy(new_text, world->log, len_old);
memcpy(new_text + len_old, ".", 1);
}
{
uint16_t len_new = strlen(text);
uint16_t len_whole = len_old + len_new + 1;
- new_text = calloc(len_whole, sizeof(char));
+ new_text = try_calloc(len_whole, sizeof(char), world, 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), world, f_name);
memcpy(last_msg, text, len_new);
}
free(world->log);
extern void turn_over(struct World * world, 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)
{
- 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", world, f_name);
+ FILE * file_new = try_fopen(recordfile_tmp, "w", world, f_name);
char c = fgetc(file_old);
while (EOF != c)
{
exit_err(write_uint8(c, file_new), world, err_write);
c = fgetc(file_old);
}
- exit_err(fclose(file_old), world, err_close);
+ try_fclose(file_old, world, f_name);
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_unlink_rename(file_new, recordfile_tmp, recordfile,
+ world, f_name);
}
world->turn++;
rrand_seed(world->seed * world->turn);
- struct Monster * monster;
- for (monster = world->monster;
+ struct MapObj * monster;
+ for (monster = world->map_objs;
monster != 0;
- monster = monster->map_obj.next)
+ monster = monster->next)
{
- move_monster(world, monster);
+ if (0 < monster->lifepoints && 0 != monster->id)
+ {
+ move_actor(world, monster, rrand() % 5);
+ }
}
}
extern void save_game(struct World * world)
{
- 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", world, f_name);
+ char line[12];
+ sprintf(line, "%d\n", world->seed);
+ try_fwrite(line, strlen(line), 1, file, world, f_name);
+ sprintf(line, "%d\n", world->turn);
+ try_fwrite(line, strlen(line), 1, file, world, f_name);
+ sprintf(line, "%d\n", world->score);
+ try_fwrite(line, strlen(line), 1, file, world, f_name);
+ write_map_objects(world, file);
+ try_fclose_unlink_rename(file, savefile_tmp, savefile, world, f_name);
+}
+
+
+
+extern void load_game(struct World * world)
+{
+ char * f_name = "load_game2()";
+ char * filename = "savefile";
+ FILE * file = try_fopen(filename, "r", world, f_name);
+ uint16_t linemax = get_linemax(file, world, f_name);
+ char line[linemax + 1];
+ try_fgets(line, linemax + 1, file, world, f_name);
+ world->seed = atoi(line);
+ try_fgets(line, linemax + 1, file, world, f_name);
+ world->turn = atoi(line);
+ try_fgets(line, linemax + 1, file, world, f_name);
+ world->score = atoi(line);
+ read_map_objects(world, file, line, linemax);
+ try_fclose(file, world, f_name);
}
}
return pos;
}
+
+
+
+extern void nav_inventory(struct World * world, char dir)
+{
+ if ('u' == dir)
+ {
+ if (world->inventory_select > 0)
+ {
+ world->inventory_select--;
+ }
+ return;
+ }
+ struct MapObj * player = get_player(world);
+ 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++;
+ }
+}