#include <stdio.h> /* for FILE typedef, fgets() */
#include <stdint.h> /* for uint8_t */
#include <string.h> /* for strlen(), strtok() */
-#include "main.h" /* for World struct */
+#include "main.h" /* for world global */
#include "rexit.h" /* for exit_err() */
#include "readwrite.h" /* for textfile_sizes(), try_fopen(), try_fclose() */
#include "misc.h" /* for try_malloc() */
/* Build string pointed to by "ch_ptr" from next token delimited by "delim". */
-static void copy_tokenized_string(struct World * world, char ** ch_ptr,
- char * delim)
+static void copy_tokenized_string(char ** ch_ptr, char * delim);
+
+
+
+static void copy_tokenized_string(char ** ch_ptr, char * delim)
{
char * f_name = "copy_tokenized_string()";
char * dsc_ptr = strtok(NULL, delim);
- * ch_ptr = try_malloc(strlen(dsc_ptr) + 1, world, f_name);
+ * ch_ptr = try_malloc(strlen(dsc_ptr) + 1, f_name);
memcpy(* ch_ptr, dsc_ptr, strlen(dsc_ptr) + 1);
}
-extern uint8_t is_command_id_shortdsc(struct World * world,
- uint8_t id, char * shortdsc)
+extern uint8_t is_command_id_shortdsc(uint8_t id, char * shortdsc)
{
- struct Command * cmd_ptr = world->cmd_db->cmds;
+ struct Command * cmd_ptr = world.cmd_db->cmds;
while (1)
{
if (id == cmd_ptr->id)
-extern uint8_t get_command_id(struct World * world, char * dsc_short)
+extern uint8_t get_command_id(char * dsc_short)
{
- struct Command * cmd_ptr = world->cmd_db->cmds;
+ struct Command * cmd_ptr = world.cmd_db->cmds;
while (1)
{
if (0 == strcmp(dsc_short, cmd_ptr->dsc_short))
-extern char * get_command_longdsc(struct World * world, char * dsc_short)
+extern char * get_command_longdsc(char * dsc_short)
{
- struct Command * cmd_ptr = world->cmd_db->cmds;
+ struct Command * cmd_ptr = world.cmd_db->cmds;
while (1)
{
if (0 == strcmp(dsc_short, cmd_ptr->dsc_short))
-extern void init_command_db(struct World * world)
+extern void init_command_db()
{
char * f_name = "init_command_db()";
char * err_s = "Trouble in init_cmds() with textfile_sizes().";
char * path = "config/commands";
- FILE * file = try_fopen(path, "r", world, f_name);
+ FILE * file = try_fopen(path, "r", f_name);
uint16_t lines, linemax;
- exit_err(textfile_sizes(file, &linemax, &lines), world, err_s);
+ exit_err(textfile_sizes(file, &linemax, &lines), err_s);
char line[linemax + 1];
- struct Command * cmds = try_malloc(lines * sizeof(struct Command),
- world, f_name);
+ struct Command * cmds = try_malloc(lines * sizeof(struct Command), f_name);
uint8_t i = 0;
while (fgets(line, linemax + 1, file))
{
break;
}
cmds[i].id = atoi(strtok(line, " "));
- copy_tokenized_string(world, &cmds[i].dsc_short, " ");
- copy_tokenized_string(world, &cmds[i].dsc_long, "\n");
+ copy_tokenized_string(&cmds[i].dsc_short, " ");
+ copy_tokenized_string(&cmds[i].dsc_long, "\n");
i++;
}
- try_fclose(file, world, f_name);
+ try_fclose(file, f_name);
- world->cmd_db = try_malloc(sizeof(struct CommandDB), world, f_name);
- world->cmd_db->cmds = cmds;
- world->cmd_db->n = lines;
+ world.cmd_db = try_malloc(sizeof(struct CommandDB), f_name);
+ world.cmd_db->cmds = cmds;
+ world.cmd_db->n = lines;
}
-extern void free_command_db(struct World * world)
+extern void free_command_db()
{
uint8_t i = 0;
- while (i < world->cmd_db->n)
+ while (i < world.cmd_db->n)
{
- free(world->cmd_db->cmds[i].dsc_short);
- free(world->cmd_db->cmds[i].dsc_long);
+ free(world.cmd_db->cmds[i].dsc_short);
+ free(world.cmd_db->cmds[i].dsc_long);
i++;
}
- free(world->cmd_db->cmds);
- free(world->cmd_db);
+ free(world.cmd_db->cmds);
+ free(world.cmd_db);
}
#ifndef COMMAND_DB_H
#define COMMAND_DB_H
-
-
#include <stdint.h> /* for uint8_t */
-struct World;
/* Is "id" the ID of command whose dsc_short is "shortdsc"? Answer in binary. */
-extern uint8_t is_command_id_shortdsc(struct World * world,
- uint8_t id, char * shortdsc);
+extern uint8_t is_command_id_shortdsc(uint8_t id, char * shortdsc);
/* Give short description of command ("dsc_short"), get its ID. */
-extern uint8_t get_command_id(struct World * world, char * dsc_short);
+extern uint8_t get_command_id(char * dsc_short);
/* Give short description of command ("dsc_short"), get long description. */
-extern char * get_command_longdsc(struct World * world, char * dsc_short);
+extern char * get_command_longdsc(char * dsc_short);
/* Read in CommandDB from file "config/commands" to world.cmd_db. */
-extern void init_command_db(struct World * world);
+extern void init_command_db();
/* Free all memory allocated with init_command_db. */
-extern void free_command_db(struct World * world);
+extern void free_command_db();
* move_keyb_mod_selection()
*/
#include "map.h" /* for map_scroll() */
-#include "main.h" /* for World struct */
+#include "main.h" /* for world global */
#include "rexit.h" /* for exit_err() */
#include "wincontrol.h" /* for scroll_pad(), toggle_window(),
* growshrink_active_window(), toggle_winconfig(),
-extern uint16_t get_available_keycode_to_action(struct World * world,
- char * name)
+extern uint16_t get_available_keycode_to_action(char * name)
{
- uint16_t keycode = get_keycode_to_action(world->kb_global.kbs, name);
- if (0 != keycode || 0 == world->wmeta->active)
+ uint16_t keycode = get_keycode_to_action(world.kb_global.kbs, name);
+ if (0 != keycode || 0 == world.wmeta->active)
{
return keycode;
}
- struct WinConf * wc = get_winconf_by_win(world, world->wmeta->active);
+ struct WinConf * wc = get_winconf_by_win(world.wmeta->active);
if (0 == wc->view)
{
keycode = get_keycode_to_action(wc->kb.kbs, name);
}
else if (1 == wc->view)
{
- keycode = get_keycode_to_action(world->kb_wingeom.kbs, name);
+ keycode = get_keycode_to_action(world.kb_wingeom.kbs, name);
}
else if (2 == wc->view)
{
- keycode = get_keycode_to_action(world->kb_winkeys.kbs, name);
+ keycode = get_keycode_to_action(world.kb_winkeys.kbs, name);
}
return keycode;
}
-extern void record_control(int action, struct World * world)
+extern void record_control(int action)
{
- if (is_command_id_shortdsc(world, action, "wait"))
+ if (is_command_id_shortdsc(action, "wait"))
{
- player_wait(world);
+ player_wait();
}
- else if (is_command_id_shortdsc(world, action, "player_u"))
+ else if (is_command_id_shortdsc(action, "player_u"))
{
- move_player(world, NORTH);
+ move_player(NORTH);
}
- else if (is_command_id_shortdsc(world, action, "player_r"))
+ else if (is_command_id_shortdsc(action, "player_r"))
{
- move_player(world, EAST);
+ move_player(EAST);
}
- else if (is_command_id_shortdsc(world, action, "player_d"))
+ else if (is_command_id_shortdsc(action, "player_d"))
{
- move_player(world, SOUTH);
+ move_player(SOUTH);
}
- else if (is_command_id_shortdsc(world, action, "player_l"))
+ else if (is_command_id_shortdsc(action, "player_l"))
{
- move_player(world, WEST);
+ move_player(WEST);
}
- else if (is_command_id_shortdsc(world, action, "drop"))
+ else if (is_command_id_shortdsc(action, "drop"))
{
- player_drop(world);
+ player_drop();
}
- else if (is_command_id_shortdsc(world, action, "pick"))
+ else if (is_command_id_shortdsc(action, "pick"))
{
- player_pick(world);
+ player_pick();
}
}
-extern uint8_t player_control(int key, struct World * world)
+extern uint8_t player_control(int key)
{
- if (key == get_available_keycode_to_action(world, "wait"))
+ if (key == get_available_keycode_to_action("wait"))
{
- player_wait(world);
+ player_wait();
}
- else if (key == get_available_keycode_to_action(world, "player_u"))
+ else if (key == get_available_keycode_to_action("player_u"))
{
- move_player(world, NORTH);
+ move_player(NORTH);
}
- else if (key == get_available_keycode_to_action(world, "player_r"))
+ else if (key == get_available_keycode_to_action("player_r"))
{
- move_player(world, EAST);
+ move_player(EAST);
}
- else if (key == get_available_keycode_to_action(world, "player_d"))
+ else if (key == get_available_keycode_to_action("player_d"))
{
- move_player(world, SOUTH);
+ move_player(SOUTH);
}
- else if (key == get_available_keycode_to_action(world, "player_l"))
+ else if (key == get_available_keycode_to_action("player_l"))
{
- move_player(world, WEST);
+ move_player(WEST);
}
- else if (key == get_available_keycode_to_action(world, "drop"))
+ else if (key == get_available_keycode_to_action("drop"))
{
- player_drop(world);
+ player_drop();
}
- else if (key == get_available_keycode_to_action(world, "pick"))
+ else if (key == get_available_keycode_to_action("pick"))
{
- player_pick(world);
+ player_pick();
}
else
{
-extern uint8_t wingeom_control(int key, struct World * world)
+extern uint8_t wingeom_control(int key)
{
char * err_shift = "Trouble with shift_active_win() in wingeom_control().";
char * err_resize = "Trouble with growshrink_active_window() in "
"wingeom_control().";
- if (key == get_available_keycode_to_action(world, "to_height_t"))
+ if (key == get_available_keycode_to_action("to_height_t"))
{
- toggle_win_height_type(world, world->wmeta->active);
+ toggle_win_height_type(world.wmeta->active);
}
- else if (key == get_available_keycode_to_action(world, "to_width_t"))
+ else if (key == get_available_keycode_to_action("to_width_t"))
{
- toggle_win_width_type(world, world->wmeta->active);
+ toggle_win_width_type(world.wmeta->active);
}
- else if (key == get_available_keycode_to_action(world, "grow_h"))
+ else if (key == get_available_keycode_to_action("grow_h"))
{
- exit_err(growshrink_active_window(world, '*'), world, err_resize);
+ exit_err(growshrink_active_window('*'), err_resize);
}
- else if (key == get_available_keycode_to_action(world, "shri_h"))
+ else if (key == get_available_keycode_to_action("shri_h"))
{
- exit_err(growshrink_active_window(world, '_'), world, err_resize);
+ exit_err(growshrink_active_window('_'), err_resize);
}
- else if (key == get_available_keycode_to_action(world, "grow_v"))
+ else if (key == get_available_keycode_to_action("grow_v"))
{
- exit_err(growshrink_active_window(world, '+'), world, err_resize);
+ exit_err(growshrink_active_window('+'), err_resize);
}
- else if (key == get_available_keycode_to_action(world, "shri_v"))
+ else if (key == get_available_keycode_to_action("shri_v"))
{
- exit_err(growshrink_active_window(world, '-'), world, err_resize);
+ exit_err(growshrink_active_window('-'), err_resize);
}
- else if (key == get_available_keycode_to_action(world, "shift_f"))
+ else if (key == get_available_keycode_to_action("shift_f"))
{
- exit_err(shift_active_win(world->wmeta, 'f'), world, err_shift);
+ exit_err(shift_active_win(world.wmeta, 'f'), err_shift);
}
- else if (key == get_available_keycode_to_action(world, "shift_b"))
+ else if (key == get_available_keycode_to_action("shift_b"))
{
- exit_err(shift_active_win(world->wmeta, 'b'), world, err_shift);
+ exit_err(shift_active_win(world.wmeta, 'b'), err_shift);
}
else
{
-extern uint8_t winkeyb_control(int key, struct World * world)
+extern uint8_t winkeyb_control(int key)
{
- struct WinConf * wc = get_winconf_by_win(world, world->wmeta->active);
- if (key == get_available_keycode_to_action(world, "w_keys_u"))
+ struct WinConf * wc = get_winconf_by_win(world.wmeta->active);
+ if (key == get_available_keycode_to_action("w_keys_u"))
{
move_keyb_mod_selection(&wc->kb, 'u');
}
- else if (key == get_available_keycode_to_action(world, "w_keys_d"))
+ else if (key == get_available_keycode_to_action("w_keys_d"))
{
move_keyb_mod_selection(&wc->kb, 'd');
}
- else if (key == get_available_keycode_to_action(world, "w_keys_m"))
+ else if (key == get_available_keycode_to_action("w_keys_m"))
{
- mod_selected_keyb(world, &wc->kb);
+ mod_selected_keyb(&wc->kb);
}
else
{
-extern uint8_t meta_control(int key, struct World * world)
+extern uint8_t meta_control(int key)
{
- struct WinMeta * win_meta = world->wmeta;
- struct Win * win_map = get_win_by_id(world, 'm');
+ struct WinMeta * win_meta = world.wmeta;
+ struct Win * win_map = get_win_by_id('m');
char * err_toggle = "Trouble with toggle_window() in meta_control().";
- if (key == get_available_keycode_to_action(world, "quit"))
+ if (key == get_available_keycode_to_action("quit"))
{
return 1;
}
- else if (key == get_available_keycode_to_action(world, "winconf"))
+ else if (key == get_available_keycode_to_action("winconf"))
{
- toggle_winconfig(world, world->wmeta->active);
+ toggle_winconfig(world.wmeta->active);
}
- else if (key == get_available_keycode_to_action(world, "cyc_win_f"))
+ else if (key == get_available_keycode_to_action("cyc_win_f"))
{
- cycle_active_win(world->wmeta, 'f');
+ cycle_active_win(world.wmeta, 'f');
}
- else if (key == get_available_keycode_to_action(world, "cyc_win_b"))
+ else if (key == get_available_keycode_to_action("cyc_win_b"))
{
- cycle_active_win(world->wmeta, 'b');
+ cycle_active_win(world.wmeta, 'b');
}
- else if (key == get_available_keycode_to_action(world, "scrl_r"))
+ else if (key == get_available_keycode_to_action("scrl_r"))
{
scroll_pad(win_meta, '+');
}
- else if (key == get_available_keycode_to_action(world, "scrl_l"))
+ else if (key == get_available_keycode_to_action("scrl_l"))
{
scroll_pad(win_meta, '-');
}
- else if (key == get_available_keycode_to_action(world, "to_a_keywin"))
+ else if (key == get_available_keycode_to_action("to_a_keywin"))
{
- uint8_t test = toggle_window(win_meta, get_win_by_id(world, 'k'));
- exit_err(test, world, err_toggle);
+ exit_err(toggle_window(win_meta, get_win_by_id('k')), err_toggle);
}
- else if (key == get_available_keycode_to_action(world, "to_g_keywin"))
+ else if (key == get_available_keycode_to_action("to_g_keywin"))
{
- uint8_t test = toggle_window(win_meta, get_win_by_id(world, '0'));
- exit_err(test, world, err_toggle);
+ exit_err(toggle_window(win_meta, get_win_by_id('0')), err_toggle);
}
- else if (key == get_available_keycode_to_action(world, "to_wg_keywin"))
+ else if (key == get_available_keycode_to_action("to_wg_keywin"))
{
- uint8_t test = toggle_window(win_meta, get_win_by_id(world, '1'));
- exit_err(test, world, err_toggle);
+ exit_err(toggle_window(win_meta, get_win_by_id('1')), err_toggle);
}
- else if (key == get_available_keycode_to_action(world, "to_wk_keywin"))
+ else if (key == get_available_keycode_to_action("to_wk_keywin"))
{
- uint8_t test = toggle_window(win_meta, get_win_by_id(world, '2'));
- exit_err(test, world, err_toggle);
+ exit_err(toggle_window(win_meta, get_win_by_id('2')), err_toggle);
}
- else if (key == get_available_keycode_to_action(world, "to_mapwin"))
+ else if (key == get_available_keycode_to_action("to_mapwin"))
{
- exit_err(toggle_window(win_meta, win_map), world, err_toggle);
+ exit_err(toggle_window(win_meta, win_map), err_toggle);
}
- else if (key == get_available_keycode_to_action(world, "to_infowin"))
+ else if (key == get_available_keycode_to_action("to_infowin"))
{
- uint8_t test = toggle_window(win_meta, get_win_by_id(world, 'i'));
- exit_err(test, world, err_toggle);
+ exit_err(toggle_window(win_meta, get_win_by_id('i')), err_toggle);
}
- else if (key == get_available_keycode_to_action(world, "to_inv"))
+ else if (key == get_available_keycode_to_action("to_inv"))
{
- uint8_t test = toggle_window(win_meta, get_win_by_id(world, 'c'));
- exit_err(test, world, err_toggle);
+ exit_err(toggle_window(win_meta, get_win_by_id('c')), err_toggle);
}
- else if (key == get_available_keycode_to_action(world, "to_logwin"))
+ else if (key == get_available_keycode_to_action("to_logwin"))
{
- uint8_t test = toggle_window(win_meta, get_win_by_id(world, 'l'));
- exit_err(test, world, err_toggle);
+ exit_err(toggle_window(win_meta, get_win_by_id('l')), err_toggle);
}
- else if (key == get_available_keycode_to_action(world, "save_conf"))
+ else if (key == get_available_keycode_to_action("save_conf"))
{
- save_interface_conf(world);
+ save_interface_conf();
}
- else if (key == get_available_keycode_to_action(world, "g_keys_u"))
+ else if (key == get_available_keycode_to_action("g_keys_u"))
{
- move_keyb_mod_selection(&world->kb_global, 'u');
+ move_keyb_mod_selection(&world.kb_global, 'u');
}
- else if (key == get_available_keycode_to_action(world, "g_keys_d"))
+ else if (key == get_available_keycode_to_action("g_keys_d"))
{
- move_keyb_mod_selection(&world->kb_global, 'd');
+ move_keyb_mod_selection(&world.kb_global, 'd');
}
- else if (key == get_available_keycode_to_action(world, "g_keys_m"))
+ else if (key == get_available_keycode_to_action("g_keys_m"))
{
- mod_selected_keyb(world, &world->kb_global);
+ mod_selected_keyb(&world.kb_global);
}
- else if (key == get_available_keycode_to_action(world, "wg_keys_u"))
+ else if (key == get_available_keycode_to_action("wg_keys_u"))
{
- move_keyb_mod_selection(&world->kb_wingeom, 'u');
+ move_keyb_mod_selection(&world.kb_wingeom, 'u');
}
- else if (key == get_available_keycode_to_action(world, "wg_keys_d"))
+ else if (key == get_available_keycode_to_action("wg_keys_d"))
{
- move_keyb_mod_selection(&world->kb_wingeom, 'd');
+ move_keyb_mod_selection(&world.kb_wingeom, 'd');
}
- else if (key == get_available_keycode_to_action(world, "wg_keys_m"))
+ else if (key == get_available_keycode_to_action("wg_keys_m"))
{
- mod_selected_keyb(world, &world->kb_wingeom);
+ mod_selected_keyb(&world.kb_wingeom);
}
- else if (key == get_available_keycode_to_action(world, "wk_keys_u"))
+ else if (key == get_available_keycode_to_action("wk_keys_u"))
{
- move_keyb_mod_selection(&world->kb_winkeys, 'u');
+ move_keyb_mod_selection(&world.kb_winkeys, 'u');
}
- else if (key == get_available_keycode_to_action(world, "wk_keys_d"))
+ else if (key == get_available_keycode_to_action("wk_keys_d"))
{
- move_keyb_mod_selection(&world->kb_winkeys, 'd');
+ move_keyb_mod_selection(&world.kb_winkeys, 'd');
}
- else if (key == get_available_keycode_to_action(world, "wk_keys_m"))
+ else if (key == get_available_keycode_to_action("wk_keys_m"))
{
- mod_selected_keyb(world, &world->kb_winkeys);
+ mod_selected_keyb(&world.kb_winkeys);
}
- else if (key == get_available_keycode_to_action(world, "map_u"))
+ else if (key == get_available_keycode_to_action("map_u"))
{
- map_scroll(win_map, world->map->size, NORTH);
+ map_scroll(win_map, world.map->size, NORTH);
}
- else if (key == get_available_keycode_to_action(world, "map_d"))
+ else if (key == get_available_keycode_to_action("map_d"))
{
- map_scroll(win_map, world->map->size, SOUTH);
+ map_scroll(win_map, world.map->size, SOUTH);
}
- else if (key == get_available_keycode_to_action(world, "map_r"))
+ else if (key == get_available_keycode_to_action("map_r"))
{
- map_scroll(win_map, world->map->size, EAST);
+ map_scroll(win_map, world.map->size, EAST);
}
- else if (key == get_available_keycode_to_action(world, "map_l"))
+ else if (key == get_available_keycode_to_action("map_l"))
{
- map_scroll(win_map, world->map->size, WEST);
+ map_scroll(win_map, world.map->size, WEST);
}
- else if (key == get_available_keycode_to_action(world, "map_c"))
+ else if (key == get_available_keycode_to_action("map_c"))
{
- struct MapObj * player = get_player(world);
+ struct MapObj * player = get_player();
win_map->center = player->pos;
}
- else if (key == get_available_keycode_to_action(world, "inv_u"))
+ else if (key == get_available_keycode_to_action("inv_u"))
{
- nav_inventory(world, 'u');
+ nav_inventory('u');
}
- else if (key == get_available_keycode_to_action(world, "inv_d"))
+ else if (key == get_available_keycode_to_action("inv_d"))
{
- nav_inventory(world, 'd');
+ nav_inventory('d');
}
- else if (key == get_available_keycode_to_action(world, "reload_conf"))
+ else if (key == get_available_keycode_to_action("reload_conf"))
{
- unload_interface_conf(world);
- load_interface_conf(world);
+ unload_interface_conf();
+ load_interface_conf();
}
- else if (key == get_available_keycode_to_action(world, "winconf"))
+ else if (key == get_available_keycode_to_action("winconf"))
{
- toggle_winconfig(world, world->wmeta->active);
+ toggle_winconfig(world.wmeta->active);
}
return 0;
}
#ifndef CONTROL_H
#define CONTROL_H
-
-
#include <stdint.h> /* for uint8_t */
-struct World;
/* Return keycode to action of "name" if available in current window config. */
-extern uint16_t get_available_keycode_to_action(struct World * world,
- char * name);
+extern uint16_t get_available_keycode_to_action(char * name);
/* Control the player character, either via recorded "action" or pressed "key".
*/
-extern void record_control(int action, struct World * world);
-extern uint8_t player_control(int key, struct World * world);
+extern void record_control(int action);
+extern uint8_t player_control(int key);
/* Control via "key" active window's geometry / keybindings in respective config
* view.
*/
-extern uint8_t wingeom_control(int key, struct World * world);
-extern uint8_t winkeyb_control(int key, struct World * world);
+extern uint8_t wingeom_control(int key);
+extern uint8_t winkeyb_control(int key);
* the player character. If the "quit" action is called, return 1 (instead of
* exiting directly).
*/
-extern uint8_t meta_control(int key, struct World * world);
+extern uint8_t meta_control(int key);
* get_player()
*/
#include "map.h" /* for Map struct */
-#include "main.h" /* for World struct */
+#include "main.h" /* for world global */
#include "command_db.h" /* for get_command_longdesc() */
#include "wincontrol.h" /* for WinConf struct, get_winconf_by_win() */
/* Apply to the winmap of Win "w" the new sizes "new_size_y" and "new_size_x"
* to the degree that they extend it. Re-shape the window content accordingly.
*/
-static void try_resize_winmap(struct World * world, struct Win * w,
- int new_size_y, int new_size_x);
+static void try_resize_winmap(struct Win * w, int new_size_y, int new_size_x);
/* In Win "w", write "ch" to coordinate "y"/"x". */
static void set_ch_on_yx(struct Win * w, int y, int x, chtype ch);
/* Add "text" into window "win". Break text at right window edge. Also break at
* newlines.
*/
-static void add_text_with_linebreaks(struct World * world, struct Win * win,
- char * text);
+static void add_text_with_linebreaks(struct Win * win, char * text);
/* Add "line" into window "w". Apply ncurses attribute "attri" to all
* characters drawn. If "fill" is non-zero, fill the entire line until the
* right window edge with empty characters ("attri" also applied on these).
*/
-static void add_line(struct World * world, struct Win * w, char * line,
- attr_t attri, uint8_t fill);
+static void add_line(struct Win * w, char * line, attr_t attri, uint8_t fill);
/* Write "text" with add_text_with_linebreaks() as not starting from the top but
* from bottom of "win". Draw only what fits in window (avoid scroll hints).
*/
-static void draw_text_from_bottom(struct World * world, struct Win * win,
- char * text);
+static void draw_text_from_bottom(struct Win * win, char * text);
/* Draw onto "map" in "win" the objects in the chain at "start". */
-static void draw_map_objects(struct World * world, struct MapObj * start,
- struct Map * map, struct Win * win);
+static void draw_map_objects(struct MapObj * start, struct Map * map,
+ struct Win * win);
/* Return keybinding list line via "kb_pp", iterate pointer pointed to by it. */
-static char * get_kb_line_and_iterate(struct World * world,
- struct KeyBinding ** kb_pp);
+static char * get_kb_line_and_iterate(struct KeyBinding ** kb_pp);
/* Draw from line "start" on config view for keybindings defined at "kb". */
-static void draw_kb_view(struct World * world, struct Win * w,
- struct KeyBiData * kb, uint8_t start);
+static void draw_kb_view(struct Win * w, struct KeyBiData * kb, uint8_t start);
/* Draw into window "w" from line "start" on a "title" followed by an empty
* line followed by a list of all keybindings starting at kb_p.
*/
-static uint16_t draw_titled_keybinding_list(struct World * world, char * title,
- struct Win * w, uint16_t start,
+static uint16_t draw_titled_keybinding_list(char * title, struct Win * w,
+ uint16_t start,
struct KeyBinding * kb_p);
-static void try_resize_winmap(struct World * world, struct Win * w,
- int new_size_y, int new_size_x)
+static void try_resize_winmap(struct Win * w, int new_size_y, int new_size_x)
{
char * f_name = "try_resize_winmap()";
if (w->winmapsize.y >= new_size_y && w->winmapsize.x >= new_size_x)
}
chtype * old_winmap = w->winmap;
uint32_t new_size = sizeof(chtype) * new_size_y * new_size_x;
- w->winmap = try_malloc(new_size, world, f_name);
+ w->winmap = try_malloc(new_size, f_name);
uint16_t y, x;
for (y = 0; y < new_size_y; y++)
{
-static void add_text_with_linebreaks(struct World * world, struct Win * win,
- char * text)
+static void add_text_with_linebreaks(struct Win * win, char * text)
{
uint16_t x, y;
int16_t z = -1;
for (y = win->winmapsize.y; ; y++)
{
- try_resize_winmap(world, win, y + 1, win->framesize.x);
+ try_resize_winmap(win, y + 1, win->framesize.x);
for (x = 0; x < win->framesize.x; x++)
{
z++;
-static void add_line(struct World * world, struct Win * w, char * line,
- attr_t attri, uint8_t fill)
+static void add_line(struct Win * w, char * line, attr_t attri, uint8_t fill)
{
uint16_t y = w->winmapsize.y;
uint16_t len_line = strlen(line);
if (0 != fill
&& w->winmapsize.x < w->framesize.x && w->framesize.x > len_line)
{
- try_resize_winmap(world, w, y + 1, w->framesize.x);
+ try_resize_winmap(w, y + 1, w->framesize.x);
}
else
{
- try_resize_winmap(world, w, y + 1, strlen(line));
+ try_resize_winmap(w, y + 1, strlen(line));
}
uint16_t x = 0;
for (; x < len_line; x++)
-static void draw_text_from_bottom(struct World * world, struct Win * win,
- char * text)
+static void draw_text_from_bottom(struct Win * win, char * text)
{
/* Determine number of lines text would have in a window of win's width,
* but infinite height. Treat \n and \0 as control chars for incrementing
text = text + (sizeof(char) * (z + 1));
}
- try_resize_winmap(world, win, start_y, 1);
- add_text_with_linebreaks(world, win, text);
+ try_resize_winmap(win, start_y, 1);
+ add_text_with_linebreaks(win, text);
}
-static void draw_map_objects(struct World * world, struct MapObj * start,
- struct Map * map, struct Win * win)
+static void draw_map_objects(struct MapObj * start, struct Map * map,
+ struct Win * win)
{
struct MapObj * o;
struct MapObjDef * d;
if (( (0 == i && 0 == o->lifepoints) /* Draw in-animate */
|| (1 == i && 0 < o->lifepoints))) /* objects first. */
{
- d = get_map_object_def(world, o->type);
+ d = get_map_object_def(o->type);
c = d->char_on_map;
set_ch_on_yx(win, o->pos.y, o->pos.x, c);
}
-static char * get_kb_line_and_iterate(struct World * world,
- struct KeyBinding ** kb_pp)
+static char * get_kb_line_and_iterate(struct KeyBinding ** kb_pp)
{
char * f_name = "get_kb_line_and_iterate()";
struct KeyBinding * kb_p = * kb_pp;
- char * keyname = get_name_to_keycode(world, kb_p->key);
- char * cmd_dsc = get_command_longdsc(world, kb_p->name);
+ char * keyname = get_name_to_keycode(kb_p->key);
+ char * cmd_dsc = get_command_longdsc(kb_p->name);
uint16_t size = 9 + 1 + strlen(cmd_dsc) + 1;
- char * line = try_malloc(size, world, f_name);
+ char * line = try_malloc(size, f_name);
sprintf(line, "%-9s %s", keyname, cmd_dsc);
free(keyname);
* kb_pp = kb_p->next;
-static void draw_kb_view(struct World * world, struct Win * w,
- struct KeyBiData * kb, uint8_t start)
+static void draw_kb_view(struct Win * w, struct KeyBiData * kb, uint8_t start)
{
if (0 == kb->kbs)
{
- add_line(world, w, "(none)", 0, 0);
+ add_line(w, "(none)", 0, 0);
return;
}
struct KeyBinding * kb_p = kb->kbs;
attri = attri | A_BLINK;
}
}
- char * kb_line = get_kb_line_and_iterate(world, &kb_p);
- add_line(world, w, kb_line, attri, 1);
+ char * kb_line = get_kb_line_and_iterate(&kb_p);
+ add_line(w, kb_line, attri, 1);
free(kb_line);
}
}
-static uint16_t draw_titled_keybinding_list(struct World * world, char * title,
- struct Win * w, uint16_t start,
+static uint16_t draw_titled_keybinding_list(char * title, struct Win * w,
+ uint16_t start,
struct KeyBinding * kb_p)
{
uint16_t y;
{
if (0 == state)
{
- add_line(world, w, title, 0, 0);
+ add_line(w, title, 0, 0);
y++;
- add_line(world, w, " ", 0, 0);
+ add_line(w, " ", 0, 0);
state = 1 + (0 == kb_p);
continue;
}
- char * kb_line = get_kb_line_and_iterate(world, &kb_p);
- add_line(world, w, kb_line, 0, 0);
+ char * kb_line = get_kb_line_and_iterate(&kb_p);
+ add_line(w, kb_line, 0, 0);
free(kb_line);
}
if (2 == state)
{
char * none = "(none)";
- add_line(world, w, none, 0, 0);
+ add_line(w, none, 0, 0);
y++;
}
return y;
extern void draw_win_log(struct Win * win)
{
- struct World * world = (struct World *) win->data;
- draw_text_from_bottom(world, win, world->log);
+ draw_text_from_bottom(win, world.log);
}
extern void draw_win_map(struct Win * win)
{
- struct World * world = (struct World *) win->data;
- struct Map * map = world->map;
+ struct Map * map = world.map;
char * cells = map->cells;
- try_resize_winmap(world, win, map->size.y, map->size.x);
+ try_resize_winmap(win, map->size.y, map->size.x);
uint16_t z = 0;
uint16_t x, y;
for (y = 0; y < map->size.y; y++)
z++;
}
}
- draw_map_objects(world, world->map_objs, map, win);
+ draw_map_objects(world.map_objs, map, win);
}
extern void draw_win_info(struct Win * win)
{
- struct World * world = (struct World *) win->data;
char * dsc_turn = "Turn: ";
char * dsc_hitpoints = "\nHitpoints: ";
char * dsc_score = "\nScore: ";
uint16_t maxl = strlen(dsc_turn) + strlen(dsc_hitpoints) + strlen(dsc_score)
+ 10 + 5 + 10; /* max strlens of numbers to be used */
char text[maxl + 1];
- struct MapObj * player = get_player(world);
+ struct MapObj * player = get_player();
sprintf(text, "%s%d%s%d%s%d",
- dsc_turn, world->turn,
+ dsc_turn, world.turn,
dsc_hitpoints, player->lifepoints,
- dsc_score, world->score);
- add_text_with_linebreaks(world, win, text);
+ dsc_score, world.score);
+ add_text_with_linebreaks(win, text);
}
extern void draw_win_inventory(struct Win * win)
{
- struct World * world = (struct World *) win->data;
- struct MapObj * player = get_player(world);
+ struct MapObj * player = get_player();
if (NULL == player->owns)
{
- add_line(world, win, "(none)", 0, 0);
+ add_line(win, "(none)", 0, 0);
return;
}
- win->center.y = world->inventory_select;
+ win->center.y = world.inventory_select;
struct MapObj * owned = player->owns;
uint8_t y;
for (y = 0; NULL != owned; y++)
{
attr_t attri = 0;
- if (y == world->inventory_select)
+ if (y == world.inventory_select)
{
attri = A_REVERSE;
}
- struct MapObjDef * mod = get_map_object_def(world, owned->type);
- add_line(world, win, mod->name, attri, 0);
+ struct MapObjDef * mod = get_map_object_def(owned->type);
+ add_line(win, mod->name, attri, 0);
owned = owned->next;
}
}
extern void draw_win_available_keybindings(struct Win * win)
{
- struct World * world = (struct World *) win->data;
char * title = "Active window's keybindings:";
struct KeyBinding * kb_p;
- struct WinConf * wc = get_winconf_by_win(world, world->wmeta->active);
+ struct WinConf * wc = get_winconf_by_win(world.wmeta->active);
if (0 == wc->view)
{
kb_p = wc->kb.kbs;
}
else if (1 == wc->view)
{
- kb_p = world->kb_wingeom.kbs;
+ kb_p = world.kb_wingeom.kbs;
}
else if (2 == wc->view)
{
- kb_p = world->kb_winkeys.kbs;
+ kb_p = world.kb_winkeys.kbs;
}
- uint16_t offset = draw_titled_keybinding_list(world, title, win, 0, kb_p);
- add_line(world, win, " ", 0, 0);
- draw_titled_keybinding_list(world, "Global keybindings", win, offset + 1,
- world->kb_global.kbs);
+ uint16_t offset = draw_titled_keybinding_list(title, win, 0, kb_p);
+ add_line(win, " ", 0, 0);
+ struct KeyBinding * kbs_glo = world.kb_global.kbs;
+ draw_titled_keybinding_list("Global keybindings", win, offset + 1, kbs_glo);
}
extern void draw_win_keybindings_global(struct Win * win)
{
- struct World * world = (struct World *) win->data;
- win->center.y = world->kb_global.select;
- draw_kb_view(world, win, &world->kb_global, 0);
+ win->center.y = world.kb_global.select;
+ draw_kb_view(win, &world.kb_global, 0);
}
extern void draw_win_keybindings_winconf_geometry(struct Win * win)
{
- struct World * world = (struct World *) win->data;
- win->center.y = world->kb_wingeom.select;
- draw_kb_view(world, win, &world->kb_wingeom, 0);
+ win->center.y = world.kb_wingeom.select;
+ draw_kb_view(win, &world.kb_wingeom, 0);
}
extern void draw_win_keybindings_winconf_keybindings(struct Win * win)
{
- struct World * world = (struct World *) win->data;
- win->center.y = world->kb_winkeys.select;
- draw_kb_view(world, win, &world->kb_winkeys, 0);
+ win->center.y = world.kb_winkeys.select;
+ draw_kb_view(win, &world.kb_winkeys, 0);
}
extern void draw_winconf_keybindings(struct Win * win)
{
- struct World * world = (struct World *) win->data;
- struct WinConf * wc = get_winconf_by_win(world, win);
+ struct WinConf * wc = get_winconf_by_win(win);
char * title = "Window's keybindings:";
- add_line(world, win, title, 0, 0);
- add_line(world, win, " ", 0, 0);
- draw_kb_view(world, win, &wc->kb, 2);
+ add_line(win, title, 0, 0);
+ add_line(win, " ", 0, 0);
+ draw_kb_view(win, &wc->kb, 2);
win->center.y = wc->kb.select + 2;
}
extern void draw_winconf_geometry(struct Win * win)
{
- struct World * world = (struct World *) win->data;
- struct WinConf * wcp = get_winconf_by_win(world, win);
+ struct WinConf * wcp = get_winconf_by_win(/*&world, */win);
char * title = "Window's geometry:\n";
char * h_d = "\nHeight to save: ";
char * h_pos = " (width in cells)";
char text[maxl + 1];
sprintf(text, "%s%s%d%s%s%d%s", title, h_d, wcp->height, h_t,
w_d, wcp->width, w_t);
- add_text_with_linebreaks(world, win, text);
+ add_text_with_linebreaks(win, text);
}
#ifndef DRAW_WINS_H
#define DRAW_WINS_H
-
-
#include <stdint.h> /* for uint16_t */
struct Win;
#include "readwrite.h" /* for texfile_sizes(), try_fopen(), try_fclose()
* try_fclose_unlink_rename(), try_fwrite()
*/
-#include "main.h" /* for World struct */
+#include "main.h" /* for world global */
#include "rexit.h" /* for err_exit() */
#include "misc.h" /* for try_malloc() */
-extern char * get_name_to_keycode(struct World * world, uint16_t keycode)
+extern char * get_name_to_keycode(uint16_t keycode)
{
char * f_name = "get_name_to_keycode()";
- char * keyname = try_malloc(15, world, f_name);
+ char * keyname = try_malloc(15, f_name);
if (32 < keycode && keycode < 127)
{
sprintf(keyname, "%c", keycode);
-extern void init_keybindings(struct World * world, char * path,
- struct KeyBiData * kbd)
+extern void init_keybindings(char * path, struct KeyBiData * kbd)
{
char * f_name = "init_keybindings()";
- FILE * file = try_fopen(path, "r", world, f_name);
+ FILE * file = try_fopen(path, "r", f_name);
uint16_t lines, linemax;
char * err = "textfile_sizes() in init_keybindings() returns error.";
- exit_err(textfile_sizes(file, &linemax, &lines), world, err);
+ exit_err(textfile_sizes(file, &linemax, &lines), err);
char command[linemax + 1];
char * cmdptr;
{
break;
}
- * loc_last_ptr = try_malloc(sizeof(struct KeyBinding), world, f_name);
+ * loc_last_ptr = try_malloc(sizeof(struct KeyBinding), f_name);
struct KeyBinding * kb_p = * loc_last_ptr;
kb_p->next = 0;
kb_p->key = atoi(command);
cmdptr = strchr(command, ' ') + 1;
- kb_p->name = try_malloc(strlen(cmdptr), world, f_name);
+ kb_p->name = try_malloc(strlen(cmdptr), f_name);
memcpy(kb_p->name, cmdptr, strlen(cmdptr) - 1);
kb_p->name[strlen(cmdptr) - 1] = '\0';
loc_last_ptr = & kb_p->next;
}
- try_fclose(file, world, f_name);
+ try_fclose(file, f_name);
kbd->edit = 0;
kbd->select = 0;
-extern void save_keybindings(struct World * world, char * path,
- struct KeyBiData * kbd)
+extern void save_keybindings(char * path, struct KeyBiData * kbd)
{
char * f_name = "save_keybindings()";
char path_tmp[strlen(path) + 4 + 1];
sprintf(path_tmp, "%s_tmp", path);
- FILE * file = try_fopen(path_tmp, "w", world, f_name);
+ FILE * file = try_fopen(path_tmp, "w", f_name);
uint16_t linemax = 0;
struct KeyBinding * kb_p = kbd->kbs;
while (0 != kb_p)
{
snprintf(line, linemax, "%d %s\n", kb_p->key, kb_p->name);
- try_fwrite(line, sizeof(char), strlen(line), file, world, f_name);
+ try_fwrite(line, sizeof(char), strlen(line), file, f_name);
kb_p = kb_p->next;
}
- try_fclose_unlink_rename(file, path_tmp, path, world, f_name);
+ try_fclose_unlink_rename(file, path_tmp, path, f_name);
}
-extern void mod_selected_keyb(struct World * world, struct KeyBiData * kbd)
+extern void mod_selected_keyb(struct KeyBiData * kbd)
{
kbd->edit = 1;
- exit_err(draw_all_wins(world->wmeta), world,
- "Trouble with draw_all_wins() in mod_selected_keyb().");
+ char * err = "Trouble with draw_all_wins() in mod_selected_keyb().";
+ exit_err(draw_all_wins(world.wmeta), err);
int key = getch();
if (key < 1000)
{
#ifndef KEYBINDINGS_H
#define KEYBINDINGS_H
-
-
#include <stdint.h> /* for uint16_t */
-struct World;
/* Return human-readable name (of maximum 9 chars) for "keycode" as matched by
* ncurses.h; if none is found, return "UNKNOWN".
*/
-extern char * get_name_to_keycode(struct World * world, uint16_t keycode);
+extern char * get_name_to_keycode(uint16_t keycode);
/* Return number of keybindings in keybindings chain from "kb_p" on. */
extern uint16_t get_n_of_keybs(struct KeyBinding * kb_p);
/* Initialize/save keybindings data from/to file at "path" to/from keybindings
* data pointer "kbd".
*/
-extern void init_keybindings(struct World * world, char * path,
- struct KeyBiData * kbd);
-extern void save_keybindings(struct World * world, char * path,
- struct KeyBiData * kbd);
+extern void init_keybindings(char * path, struct KeyBiData * kbd);
+extern void save_keybindings(char * path, struct KeyBiData * kbd);
/* Free keybinding chain starting at "kb_start". */
extern void free_keybindings(struct KeyBinding * kb_start);
* modify it, then unmark it again. Ensure there are max. three digits in the
* keycode ASCII representation.
*/
-extern void mod_selected_keyb(struct World * world, struct KeyBiData * kbd);
+extern void mod_selected_keyb(struct KeyBiData * kbd);
/* Move keybinding modification selection upwards ("dir"=="u") or downwards
* ("dir"=="d") within the limits of the keybindings chain length.
/* main.c */
-#include "main.h"
+#include "main.h" /* for world global */
#include <stdlib.h> /* for atoi(), exit(), EXIT_FAILURE */
#include <stdio.h> /* for FILE typedef, F_OK */
#include <ncurses.h> /* for initscr(), noecho(), curs_set(), keypad(), raw() */
int main(int argc, char *argv[])
{
char * f_name = "main()";
- struct World world;
world.turn = 0; /* Turns to 1 when map and objects are initalized. */
- init_command_db(&world);
+ init_command_db();
set_cleanup_flag(CLEANUP_COMMAND_DB);
/* Check for corrupted savefile / recordfile savings. */
char * savefile = "savefile";
char * recordfile_tmp = "record_tmp";
char * savefile_tmp = "savefile_tmp";
- check_files_xor(savefile, recordfile, &world);
- check_tempfile(recordfile_tmp, &world);
- check_tempfile(savefile_tmp, &world);
- check_tempfile("config/windows/Win_tmp_k", &world);
- check_tempfile("config/windows/Win_tmp_m", &world);
- check_tempfile("config/windows/Win_tmp_i", &world);
- check_tempfile("config/windows/Win_tmp_l", &world);
- check_tempfile("config/windows/toggle_order_tmp", &world);
+ check_files_xor(savefile, recordfile);
+ check_tempfile(recordfile_tmp);
+ check_tempfile(savefile_tmp);
+ check_tempfile("config/windows/Win_tmp_k");
+ check_tempfile("config/windows/Win_tmp_m");
+ check_tempfile("config/windows/Win_tmp_i");
+ check_tempfile("config/windows/Win_tmp_l");
+ check_tempfile("config/windows/toggle_order_tmp");
/* Read in startup options (i.e. replay option and replay start turn). */
int opt;
/* Initialize log and map object definitions. */
world.score = 0;
- world.log = try_calloc(1, sizeof(char), &world, f_name);
+ world.log = try_calloc(1, sizeof(char), f_name);
set_cleanup_flag(CLEANUP_LOG);
- update_log(&world, " ");
- init_map_object_defs(&world, "config/defs");
+ update_log(" ");
+ init_map_object_defs("config/defs");
set_cleanup_flag(CLEANUP_MAP_OBJECT_DEFS);
world.map_obj_count = 0;
FILE * file;
if (1 == world.interactive && 0 == access(savefile, F_OK))
{
- load_game(&world);
+ load_game();
set_cleanup_flag(CLEANUP_MAP_OBJECTS);
}
"in main()).";
if (0 == world.interactive)
{
- file = try_fopen(recordfile, "r", &world, f_name);
- exit_err(read_uint32_bigendian(file, &world.seed), &world, err_r);
+ file = try_fopen(recordfile, "r", f_name);
+ exit_err(read_uint32_bigendian(file, &world.seed), err_r);
}
/* For interactive-mode in newly started world, generate a start seed
char * err_w = "Trouble recording new seed "
"(write_uint32_bigendian() in main()) / writing to "
"file 'record_tmp'.";
- file = try_fopen(recordfile_tmp, "w", &world, f_name);
- exit_err(write_uint32_bigendian(world.seed, file), &world, err_w);
- try_fclose_unlink_rename(file, recordfile_tmp, recordfile,
- &world, f_name);
+ file = try_fopen(recordfile_tmp, "w", f_name);
+ exit_err(write_uint32_bigendian(world.seed, file), err_w);
+ try_fclose_unlink_rename(file, recordfile_tmp, recordfile, f_name);
}
}
if (0 == world.turn)
{
world.map_objs = NULL;
- add_map_objects(&world, 0, 1);
- add_map_objects(&world, 1, 1 + rrand() % 27);
- add_map_objects(&world, 2, 1 + rrand() % 9);
- add_map_objects(&world, 3, 1 + rrand() % 3);
- add_map_objects(&world, 4, 1 + rrand() % 3);
- add_map_objects(&world, 5, 1 + rrand() % 3);
+ add_map_objects(0, 1);
+ add_map_objects(1, 1 + rrand() % 27);
+ add_map_objects(2, 1 + rrand() % 9);
+ add_map_objects(3, 1 + rrand() % 3);
+ add_map_objects(4, 1 + rrand() % 3);
+ add_map_objects(5, 1 + rrand() % 3);
set_cleanup_flag(CLEANUP_MAP_OBJECTS);
world.turn = 1;
}
keypad(screen, TRUE);
raw();
char * err_winmem = "Trouble with init_win_meta() in main ().";
- exit_err(init_win_meta(screen, &world.wmeta), &world, err_winmem);
+ exit_err(init_win_meta(screen, &world.wmeta), err_winmem);
set_cleanup_flag(CLEANUP_WIN_META);
- load_interface_conf(&world);
+ load_interface_conf(/*&world*/);
set_cleanup_flag(CLEANUP_INTERFACE_CONF);
err_winmem = "Trouble with draw_all_wins() in main().";
/* Focus map on player. */
- struct MapObj * player = get_player(&world);
- struct Win * win_map = get_win_by_id(&world, 'm');
+ struct MapObj * player = get_player();
+ struct Win * win_map = get_win_by_id('m');
win_map->center = player->pos;
/* Initialize player's inventory selection index to start position. */
{
break;
}
- if (is_command_id_shortdsc(&world, action, "drop"))
+ if (is_command_id_shortdsc(action, "drop"))
{
world.inventory_select = getc(file);
}
- record_control(action, &world);
+ record_control(action);
}
}
while (1)
{
draw_all_wins(world.wmeta);
key = getch();
- wc = get_winconf_by_win(&world, world.wmeta->active);
- if ( (1 == wc->view && wingeom_control(key, &world))
- || (2 == wc->view && winkeyb_control(key, &world)))
+ wc = get_winconf_by_win(world.wmeta->active);
+ if ( (1 == wc->view && wingeom_control(key))
+ || (2 == wc->view && winkeyb_control(key)))
{
continue;
}
if ( EOF != action
- && key == get_available_keycode_to_action(&world, "wait"))
+ && key == get_available_keycode_to_action("wait"))
{
action = getc(file);
if (EOF != action)
{
- if (is_command_id_shortdsc(&world, action, "drop"))
+ if (is_command_id_shortdsc(action, "drop"))
{
world.inventory_select = getc(file);
}
- record_control(action, &world);
+ record_control(action);
}
}
- else if (meta_control(key, &world))
+ else if (meta_control(key))
{
- try_fclose(file, &world, f_name);
- exit_game(&world);
+ try_fclose(file, f_name);
+ exit_game();
}
}
}
{
while (1)
{
- save_game(&world);
+ save_game();
draw_all_wins(world.wmeta);
key = getch();
- wc = get_winconf_by_win(&world, world.wmeta->active);
- if (1 == wc->view && wingeom_control(key, &world))
+ wc = get_winconf_by_win(world.wmeta->active);
+ if (1 == wc->view && wingeom_control(key))
{
continue;
}
- else if (2 == wc->view && winkeyb_control(key, &world))
+ else if (2 == wc->view && winkeyb_control(key))
{
continue;
}
- if ( (1 == wc->view && wingeom_control(key, &world))
- || (2 == wc->view && winkeyb_control(key, &world))
- || (0 != player->lifepoints && player_control(key, &world)))
+ if ( (1 == wc->view && wingeom_control(key))
+ || (2 == wc->view && winkeyb_control(key))
+ || (0 != player->lifepoints && player_control(key)))
{
continue;
}
- if (meta_control(key, &world))
+ if (meta_control(key))
{
- exit_game(&world);
+ exit_game();
}
}
}
#ifndef MAIN_H
#define MAIN_H
-
-
#include <stdint.h> /* for uint32_t*/
-#include "keybindings.h"
+#include "keybindings.h" /* for KeyBiData struct */
struct WinMeta;
struct WinConf;
struct Win;
struct MapObj * map_objs; /* Pointer to map objects chain start. */
uint8_t inventory_select; /* Player's inventory selection index. */
uint8_t old_inventory_select; /* Temporarily stores for recordfile */
-}; /* writing inventory selection index. */
+} world; /* writing inventory selection index. */
#include "yx_uint16.h" /* for yx_uint16 and dir enums */
#include "rrand.h" /* for rrand() */
#include "windows.h" /* for struct Win */
-struct World;
-struct Map init_map(struct World * world)
+extern struct Map init_map()
{
char * f_name = "init_map()";
struct Map map;
map.size.x = 64;
map.size.y = 64;
uint32_t size = map.size.x * map.size.y;
- map.cells = try_malloc(size, world, f_name);
+ map.cells = try_malloc(size, f_name);
uint16_t y, x;
for (y = 0; y < map.size.y; y++)
{
-void map_scroll(struct Win * win, struct yx_uint16 map_size, enum dir d)
+extern void map_scroll(struct Win * win, struct yx_uint16 map_size, enum dir d)
{
uint16_t offset;
if ((NORTH == d || SOUTH == d) && map_size.y > win->framesize.y)
#ifndef MAP_H
#define MAP_H
-
-
#include "yx_uint16.h" /* for yx_uint16 and dir enums */
-struct MapObj;
struct Win;
/* Try to change the view center of map "win" of "map_size" into dir "d". */
-void map_scroll(struct Win * win, struct yx_uint16 map_size, enum dir d);
+extern void map_scroll(struct Win * win, struct yx_uint16 map_size, enum dir d);
*/
#include "misc.h" /* for update_log(), turn_over() */
#include "map.h" /* for Map struct */
-#include "main.h" /* for World struct */
+#include "main.h" /* for world global */
#include "command_db.h" /* for get_command_id() */
/* One actor "wounds" another actor, decrementing his lifepoints and, if they
* reach zero in the process, killing it. Generates appropriate log message.
*/
-static void actor_hits_actor(struct World * world, struct MapObj * hitter,
- struct MapObj * hitted);
+static void actor_hits_actor(struct MapObj * hitter, struct MapObj * hitted);
-static void actor_hits_actor(struct World * world, struct MapObj * hitter,
- struct MapObj * hitted)
+static void actor_hits_actor(struct MapObj * hitter, struct MapObj * hitted)
{
- struct MapObjDef * mod_hitter = get_map_object_def(world, hitter->type);
- struct MapObjDef * mod_hitted = get_map_object_def(world, hitted->type);
- struct MapObj * player = get_player(world);
+ struct MapObjDef * mod_hitter = get_map_object_def(hitter->type);
+ struct MapObjDef * mod_hitted = get_map_object_def(hitted->type);
+ struct MapObj * player = get_player();
char * msg1 = "You";
char * msg2 = "wound";
char * msg3 = "you";
uint8_t len = 1 + strlen(msg1) + 1 + strlen(msg2) + 1 + strlen(msg3) + 2;
char msg[len];
sprintf(msg, "\n%s %s %s.", msg1, msg2, msg3);
- update_log(world, msg);
+ update_log(msg);
hitted->lifepoints--;
if (0 == hitted->lifepoints)
{
hitted->type = mod_hitted->corpse_id;
if (player == hitted)
{
- update_log(world, " You die.");
+ update_log(" You die.");
}
else
{
- update_log(world, " It dies.");
+ update_log(" It dies.");
if (player == hitter)
{
- world->score = world->score + mod_hitted->lifepoints;
+ world.score = world.score + mod_hitted->lifepoints;
}
}
}
-extern uint8_t move_actor(struct World * world, struct MapObj * actor,
- enum dir d)
+extern uint8_t move_actor(struct MapObj * actor, enum dir d)
{
struct yx_uint16 target = mv_yx_in_dir(d, actor->pos);
struct MapObj * other_actor;
- for (other_actor = world->map_objs;
+ for (other_actor = world.map_objs;
other_actor != 0;
other_actor = other_actor->next)
{
}
if (yx_uint16_cmp(&target, &other_actor->pos))
{
- actor_hits_actor(world, actor, other_actor);
+ actor_hits_actor(actor, other_actor);
return 2;
}
}
- if (is_passable(world->map, target))
+ if (is_passable(world.map, target))
{
set_object_position(actor, target);
return 0;
-extern void move_player(struct World * world, enum dir d)
+extern void move_player(enum dir d)
{
char * dsc_dir;
char * action_dsc_prototype = "player_";
action_dsc[len_action_dsc_prototype] = 'l';
}
action_dsc[len_action_dsc_prototype + 1] = '\0';
- uint8_t res = move_actor(world, get_player(world), d);
+ uint8_t res = move_actor(get_player(), d);
if (1 >= res)
{
char * dsc_move = "You fail to move ";
}
char msg[strlen(dsc_move) + strlen (dsc_dir) + 3];
sprintf(msg, "\n%s%s.", dsc_move, dsc_dir);
- update_log(world, msg);
+ update_log(msg);
}
- turn_over(world, get_command_id(world, action_dsc));
+ turn_over(get_command_id(action_dsc));
}
-extern void player_wait(struct World * world)
+extern void player_wait()
{
- update_log(world, "\nYou wait.");
- turn_over(world, get_command_id(world, "wait"));
+ update_log("\nYou wait.");
+ turn_over(get_command_id("wait"));
}
extern char is_passable(struct Map * map, struct yx_uint16 pos)
{
- char passable = 0;
+ uint8_t passable = 0;
if (0 <= pos.x && pos.x < map->size.x && 0 <= pos.y && pos.y < map->size.y)
{
- if ('.' == map->cells[pos.y * map->size.x + pos.x])
- {
- passable = 1;
- }
+ passable = (('.' == map->cells[pos.y * map->size.x + pos.x]));
}
return passable;
}
-extern void player_drop(struct World * world)
+extern void player_drop()
{
- struct MapObj * player = get_player(world);
+ struct MapObj * player = get_player();
if (NULL == player->owns)
{
- update_log(world, "\nYou try to drop an object, but you own none.");
- world->old_inventory_select = 0;
+ update_log("\nYou try to drop an object, but you own none.");
+ world.old_inventory_select = 0;
}
else
{
- world->old_inventory_select = world->inventory_select;
+ world.old_inventory_select = world.inventory_select;
struct MapObj * owned = player->owns;
uint8_t i = 0;
- for (; i != world->inventory_select; i++, owned = owned->next);
- if (0 < world->inventory_select)
+ for (; i != world.inventory_select; i++, owned = owned->next);
+ if (0 < world.inventory_select)
{
- world->inventory_select--;
+ world.inventory_select--;
}
- own_map_object(&world->map_objs, &player->owns, owned->id);
- update_log(world, "\nYou drop an object.");
+ own_map_object(&world.map_objs, &player->owns, owned->id);
+ update_log("\nYou drop an object.");
}
- turn_over(world, get_command_id(world, "drop"));
+ turn_over(get_command_id("drop"));
}
-extern void player_pick(struct World * world)
+extern void player_pick()
{
- struct MapObj * player = get_player(world);
+ struct MapObj * player = get_player();
struct MapObj * picked;
- for (picked = world->map_objs; NULL != picked; picked = picked->next)
+ for (picked = world.map_objs; NULL != picked; picked = picked->next)
{
if (picked != player && yx_uint16_cmp(&picked->pos, &player->pos))
{
}
if (NULL == picked)
{
- update_log(world, "\nYou try to pick up an object, but there is none.");
+ update_log("\nYou try to pick up an object, but there is none.");
}
else
{
- own_map_object(&player->owns, &world->map_objs, picked->id);
+ own_map_object(&player->owns, &world.map_objs, picked->id);
set_object_position(picked, player->pos);
- update_log(world, "\nYou pick up an object.");
+ update_log("\nYou pick up an object.");
}
- turn_over(world, get_command_id(world, "pick"));
+ turn_over(get_command_id("pick"));
}
#ifndef MAP_OBJECT_ACTIONS_H
#define MAP_OBJECT_ACTIONS_H
-
-
#include "yx_uint16.h" /* for yx_uint16 coordinates */
-struct World;
struct Map;
struct MapObj;
* leads to its lifepoint decreasing by one and potentially its death), or the
* target square is not passable and the move fails.
*/
-extern uint8_t move_actor(struct World * world, struct MapObj * actor,
- enum dir d);
+extern uint8_t move_actor(struct MapObj * actor, enum dir d);
* the game log with appropriate messages on the move attempt and its results;
* turns over to turn_over() when finished.
*/
-extern void move_player(struct World * world, enum dir d);
+extern void move_player(enum dir d);
/* Make player wait one turn, i.e. only update_log with a "you wait" message
* and turn control over to the enemy.
*/
-extern void player_wait(struct World * world);
+extern void player_wait();
/* Make player drop to ground map ojbect indexed by world.inventory_select. */
-extern void player_drop(struct World * world);
+extern void player_drop();
/* Make player pick up map object from ground. */
-extern void player_pick(struct World * world);
+extern void player_pick();
#include "readwrite.h" /* for get_linemax(), try_fopen(), try_fclose()
* [read/write]_uint[8/16/23][_bigendian]()
*/
-#include "misc.h" /* for try_malloc(), try_calloc(), find_passable_pos() */
-#include "main.h" /* for World struct */
+#include "misc.h" /* for try_malloc(), find_passable_pos() */
+#include "main.h" /* for world global */
#include "rexit.h" /* for err_exit() */
#include "yx_uint16.h" /* for yx_uint16 struct, yx_uint16_cmp() */
/* Write representation of "mo" and all of the map objects it owns to "file". */
-static void write_map_object(struct World * w, FILE * file, struct MapObj * mo);
+static void write_map_object(FILE * file, struct MapObj * mo);
-static void write_map_object(struct World * w, FILE * file, struct MapObj * mo)
+static void write_map_object(FILE * file, struct MapObj * mo)
{
char * f_name = "write_map_object()";
struct MapObj * mo_ptr = mo->owns;
}
line[strlen(line) + 1] = '\0';
line[strlen(line)] = '\n';
- try_fwrite(line, strlen(line), 1, file, w, f_name);
+ try_fwrite(line, strlen(line), 1, file, f_name);
for (mo_ptr = mo->owns; NULL != mo_ptr; mo_ptr = mo_ptr->next)
{
- write_map_object(w, file, mo_ptr);
+ write_map_object(file, mo_ptr);
}
}
-extern void init_map_object_defs(struct World * world, char * filename)
+extern void init_map_object_defs(char * filename)
{
char * f_name = "init_map_object_defs()";
- FILE * file = try_fopen(filename, "r", world, f_name);
- uint16_t linemax = get_linemax(file, world, f_name);
- struct MapObjDef ** last_mod_ptr_ptr = &world->map_obj_defs;
+ FILE * file = try_fopen(filename, "r", f_name);
+ uint16_t linemax = get_linemax(file, f_name);
+ struct MapObjDef ** last_mod_ptr_ptr = &world.map_obj_defs;
char * delim = " ";
char line[linemax + 1];
- while (try_fgets(line, linemax + 1, file, world, f_name))
+ while (try_fgets(line, linemax + 1, file, f_name))
{
struct MapObjDef * mod;
- mod = try_malloc(sizeof(struct MapObjDef), world, f_name);
+ mod = try_malloc(sizeof(struct MapObjDef), f_name);
mod->next = NULL;
mod->id = atoi(strtok(line, delim));
mod->corpse_id = atoi(strtok(NULL, delim));
mod->char_on_map = * strtok(NULL, delim);
mod->lifepoints = atoi(strtok(NULL, delim));
char * name = strtok(NULL, "\n");
- mod->name = try_malloc(strlen(name) + 1, world, f_name);
+ mod->name = try_malloc(strlen(name) + 1, f_name);
memcpy(mod->name, name, strlen(name) + 1);
* last_mod_ptr_ptr = mod;
last_mod_ptr_ptr = &mod->next;
}
- try_fclose(file, world, f_name);
+ try_fclose(file, f_name);
}
-extern void write_map_objects(struct World * world, FILE * file)
+extern void write_map_objects(FILE * file)
{
- struct MapObj * mo = world->map_objs;
+ struct MapObj * mo = world.map_objs;
while (NULL != mo)
{
- write_map_object(world, file, mo);
+ write_map_object(file, mo);
mo = mo->next;
}
}
-extern void read_map_objects(struct World * world, FILE * file, char * line,
- int linemax)
+extern void read_map_objects(FILE * file, char * line, int linemax)
{
char * f_name = "read_map_objects()";
- struct MapObj ** mo_ptr_ptr = &world->map_objs;
+ struct MapObj ** mo_ptr_ptr = &world.map_objs;
char * delim = " ";
struct MapObj * mo;
fpos_t pos;
- exit_err(-1 == fgetpos(file, &pos), world, f_name);
- while (try_fgets(line, linemax + 1, file, world, f_name))
+ exit_err(-1 == fgetpos(file, &pos), f_name);
+ while (try_fgets(line, linemax + 1, file, f_name))
{
mo = malloc(sizeof(struct MapObj));
mo->next = NULL;
mo->pos.y = atoi(strtok(NULL, delim));
mo->pos.x = atoi(strtok(NULL, delim));
mo->owns = NULL;
- if (mo->id > world->map_obj_count)
+ if (mo->id > world.map_obj_count)
{
- world->map_obj_count = mo->id;
+ world.map_obj_count = mo->id;
}
* mo_ptr_ptr = mo;
mo_ptr_ptr = &mo->next;
}
- exit_err(-1 == fsetpos(file, &pos), world, f_name);
- while (try_fgets(line, linemax + 1, file, world, f_name))
+ exit_err(-1 == fsetpos(file, &pos), f_name);
+ while (try_fgets(line, linemax + 1, file, f_name))
{
uint8_t id = atoi(strtok(line, delim));
strtok(NULL, delim);
char * owned = strtok(NULL, "\n");
if (NULL != owned)
{
- mo = get_map_object(world->map_objs, id);
+ mo = get_map_object(world.map_objs, id);
char * owned_id = "";
owned_id = strtok(owned, delim);
while (NULL != owned_id)
{
- own_map_object(&mo->owns, &world->map_objs,
+ own_map_object(&mo->owns, &world.map_objs,
(uint8_t) atoi(owned_id));
owned_id = strtok(NULL, delim);
}
-extern void add_map_object(struct World * world, uint8_t type)
+extern void add_map_object(uint8_t type)
{
char * f_name = "add_map_object()";
- struct MapObjDef * mod = get_map_object_def(world, type);
- struct MapObj * mo = try_malloc(sizeof(struct MapObj), world, f_name);
- mo->id = world->map_obj_count;
- world->map_obj_count++;
+ struct MapObjDef * mod = get_map_object_def(type);
+ struct MapObj * mo = try_malloc(sizeof(struct MapObj), f_name);
+ mo->id = world.map_obj_count;
+ world.map_obj_count++;
mo->type = mod->id;
mo->lifepoints = mod->lifepoints;
while (1)
{
- struct yx_uint16 pos = find_passable_pos(world->map);
+ struct yx_uint16 pos = find_passable_pos(world.map);
struct MapObj * mo_ptr;
uint8_t clear = 1;
- for (mo_ptr = world->map_objs;
- mo_ptr != NULL;
- mo_ptr = mo_ptr->next)
+ for (mo_ptr = world.map_objs; mo_ptr != NULL; mo_ptr = mo_ptr->next)
{
if (yx_uint16_cmp(&pos, &mo_ptr->pos) && 0 != mo_ptr->lifepoints)
{
}
mo->owns = NULL;
mo->next = NULL;
- struct MapObj ** last_ptr_ptr = &world->map_objs;
+ struct MapObj ** last_ptr_ptr = &world.map_objs;
struct MapObj * mo_ptr;
while (NULL != * last_ptr_ptr)
{
-extern void add_map_objects(struct World * world, uint8_t type, uint8_t n)
+extern void add_map_objects(uint8_t type, uint8_t n)
{
uint8_t i;
for (i = 0; i < n; i++)
{
- add_map_object(world, type);
+ add_map_object(type);
}
}
-extern struct MapObj * get_player(struct World * world)
+extern struct MapObj * get_player()
{
- return get_map_object(world->map_objs, 0);
+ return get_map_object(world.map_objs, 0);
}
-extern struct MapObjDef * get_map_object_def(struct World * w, uint8_t id)
+extern struct MapObjDef * get_map_object_def(uint8_t id)
{
- struct MapObjDef * mod = w->map_obj_defs;
+ struct MapObjDef * mod = world.map_obj_defs;
while (id != mod->id)
{
mod = mod->next;
#ifndef MAP_OBJECTS_H
#define MAP_OBJECTS_H
-
-
#include <stdio.h> /* for FILE typedef */
#include <stdint.h> /* for uint8_t */
#include "yx_uint16.h" /* for yx_uint16 coordinates */
-struct World;
/* Initialize map object defnitions chain from file at path "filename". */
-extern void init_map_object_defs(struct World * world, char * filename);
+extern void init_map_object_defs(char * filename);
* New animate objects are never placed in the same square with other animated
* ones.
*/
-extern void add_map_object(struct World * world, uint8_t type);
-extern void add_map_objects(struct World * world, uint8_t type, uint8_t n);
+extern void add_map_object(uint8_t type);
+extern void add_map_objects(uint8_t type, uint8_t n);
/* Write map objects chain to "file". */
-extern void write_map_objects(struct World * world, FILE * file);
+extern void write_map_objects(FILE * file);
/* Read from "file" map objects chain; use "line" as char array for fgets() and
* expect strings of max. "linemax" length.
*/
-extern void read_map_objects(struct World * world, FILE * file,
- char * line, int linemax);
+extern void read_map_objects(FILE * file, char * line, int linemax);
/* Get pointer to the MapObj struct that represents the player. */
-extern struct MapObj * get_player(struct World * world);
+extern struct MapObj * get_player();
/* Get pointer to the map object definition of identifier "def_id". */
-extern struct MapObjDef * get_map_object_def(struct World * w, uint8_t id);
+extern struct MapObjDef * get_map_object_def(uint8_t id);
#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](),
- * try_fopen(), try_fclose()
+ * 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 is_passable(), move_actor() */
#include "map.h" /* for Map struct */
-#include "main.h" /* for World struct */
+#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() */
-extern char * trouble_msg(struct World * w, char * parent, char * child)
+extern char * trouble_msg(char * parent, char * child)
{
char * p1 = "Trouble in ";
char * p2 = " with ";
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.");
+ exit_err(NULL == msg, "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)
+extern void * try_malloc(size_t size, char * f)
{
- char * msg = trouble_msg(w, f, "malloc()");
+ char * msg = trouble_msg(f, "malloc()");
void * p = malloc(size);
- exit_err(NULL == p, w, msg);
+ exit_err(NULL == p, msg);
free(msg);
return p;
}
-extern void * try_calloc(size_t size1, size_t size2, struct World * w, char * f)
+extern void * try_calloc(size_t size1, size_t size2, char * f)
{
- char * msg = trouble_msg(w, f, "calloc()");
+ char * msg = trouble_msg(f, "calloc()");
void * p = calloc(size1, size2);
- exit_err(NULL == p, w, msg);
+ exit_err(NULL == p, msg);
free(msg);
return p;
}
-extern void check_files_xor(char * p1, char * p2, struct World * w)
+extern void check_files_xor(char * p1, char * p2)
{
char * msg1 = "A file '";
char * msg2 = "' exists, but no file '";
{
sprintf(msg, "%s%s%s%s%s", msg1, p1, msg2, p2, msg3);
errno = 0;
- exit_err(1, w, msg);
+ 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, w, msg);
+ exit_err(1, msg);
}
}
-extern void check_tempfile(char * path, struct World * w)
+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.";
+ "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);
+ exit_err(!access(path, F_OK), msg);
}
-extern void save_interface_conf(struct World * world)
+extern void save_interface_conf()
{
- 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);
+ 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(struct World * world)
+extern void load_interface_conf()
{
- 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);
+ 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(struct World * world)
+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)
+ 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, world->wmeta->active);
+ suspend_win(world.wmeta, world.wmeta->active);
}
- free_winconfs(world);
+ free_winconfs();
}
-extern void update_log(struct World * world, char * text)
+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 not */
{ /* being freed. Rectify this? */
- last_msg = try_calloc(1, sizeof(char), world, f_name);
+ 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 = try_calloc(len_whole + 1, sizeof(char), world, f_name);
- 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 = try_calloc(len_whole, sizeof(char), world, f_name);
- 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 = try_calloc(len_new + 1, sizeof(char), world, f_name);
+ 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 * f_name = "turn_over()";
char * err_write = "Trouble in turn_over() with write_uint8() "
char * recordfile_tmp = "record_tmp";
char * recordfile = "record";
- if (1 == world->interactive)
+ if (1 == world.interactive)
{
- FILE * file_old = try_fopen(recordfile, "r", world, f_name);
- FILE * file_new = try_fopen(recordfile_tmp, "w", world, f_name);
+ 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);
}
- try_fclose(file_old, world, f_name);
- exit_err(write_uint8(action, file_new), world, err_write);
- if (is_command_id_shortdsc(world, action, "drop"))
+ try_fclose(file_old, f_name);
+ exit_err(write_uint8(action, file_new), err_write);
+ if (is_command_id_shortdsc(action, "drop"))
{
- uint8_t inventory_select = world->old_inventory_select;
- exit_err(write_uint8(inventory_select, file_new), world, err_write);
+ uint8_t inventory_select = world.old_inventory_select;
+ exit_err(write_uint8(inventory_select, file_new), err_write);
}
- try_fclose_unlink_rename(file_new, recordfile_tmp, recordfile,
- world, f_name);
+ try_fclose_unlink_rename(file_new, recordfile_tmp, recordfile, f_name);
}
- world->turn++;
- rrand_seed(world->seed * world->turn);
+ world.turn++;
+ rrand_seed(world.seed * world.turn);
struct MapObj * monster;
- for (monster = world->map_objs;
- monster != 0;
- monster = monster->next)
+ for (monster = world.map_objs; monster != 0; monster = monster->next)
{
if (0 < monster->lifepoints && 0 != monster->id)
{
- move_actor(world, monster, rrand() % 5);
+ move_actor(monster, rrand() % 5);
}
}
}
-extern void save_game(struct World * world)
+extern void save_game()
{
char * f_name = "save_game()";
char * savefile_tmp = "savefile_tmp";
char * savefile = "savefile";
- FILE * file = try_fopen(savefile_tmp, "w", world, f_name);
+ FILE * file = try_fopen(savefile_tmp, "w", 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);
+ sprintf(line, "%d\n", world.seed);
+ try_fwrite(line, strlen(line), 1, file, f_name);
+ sprintf(line, "%d\n", world.turn);
+ try_fwrite(line, strlen(line), 1, file, f_name);
+ sprintf(line, "%d\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(struct World * world)
+extern void load_game()
{
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);
+ 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, 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);
+ 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);
}
-extern void nav_inventory(struct World * world, char dir)
+extern void nav_inventory(char dir)
{
if ('u' == dir)
{
- if (world->inventory_select > 0)
+ if (world.inventory_select > 0)
{
- world->inventory_select--;
+ world.inventory_select--;
}
return;
}
- struct MapObj * player = get_player(world);
+ struct MapObj * player = get_player();
struct MapObj * owned = player->owns;
if (NULL == owned)
{
}
uint8_t n_owned = 0;
for (; NULL != owned->next; owned = owned->next, n_owned++);
- if (world->inventory_select < n_owned)
+ if (world.inventory_select < n_owned)
{
- world->inventory_select++;
+ world.inventory_select++;
}
}
#ifndef MISC_H
#define MISC_H
-
-
#include <stdlib.h> /* for size_t */
#include <stdint.h> /* for uint16_t */
#include "yx_uint16.h" /* for yx_uint16 coordinates */
-struct World;
struct Map;
/* Returns message: "Trouble in ".parent." with ".child."." (try_*() helper) */
-extern char * trouble_msg(struct World * w, char * parent, char * child);
+extern char * trouble_msg(char * parent, char * child);
/* Wrappers to malloc(), calloc() from function called "f" calling exit_err()
* with trouble_msg() error message if necessary.
*/
-extern void * try_malloc(size_t size, struct World * w, char * f);
-extern void * try_calloc(size_t nmemb, size_t size,
- struct World * w, char * f);
+extern void * try_malloc(size_t size, char * f);
+extern void * try_calloc(size_t nmemb, size_t size, char * f);
/* Check if tempfile "path" exists, and if so, exit with explanation that. */
-extern void check_tempfile(char * path, struct World * f);
+extern void check_tempfile(char * path);
/* If one and only one of files at "p1", "p2" exists, fail with explanation. */
-extern void check_files_xor(char * p1, char * p2, struct World * w);
+extern void check_files_xor(char * p1, char * p2);
/* Save / load / unload (free) interface configuration data. */
-extern void save_interface_conf(struct World * world);
-extern void load_interface_conf(struct World * world);
-extern void unload_interface_conf(struct World * world);
+extern void save_interface_conf();
+extern void load_interface_conf();
+extern void unload_interface_conf();
/* Update game log by appending "text", or by appending a "." if "text" is the
* same as the last one passed.
*/
-extern void update_log(struct World * world, char * text);
+extern void update_log(char * text);
/* Record last player "action" in game record file "record, increment the game
* turn and trigger enemy movement.
*/
-extern void turn_over(struct World * world, char action);
+extern void turn_over(char action);
/* Save or load current game data to / from file "savefile". */
-extern void save_game(struct World * world);
-extern void load_game(struct World * world);
+extern void save_game();
+extern void load_game();
/* Navigate (as far as possible) up (dir=='u') or (else) down in player's
* inventory selection.
*/
-extern void nav_inventory(struct World * world, char dir);
+extern void nav_inventory(char dir);
#include <unistd.h> /* for unlink() */
#include "rexit.h" /* for exit_err() */
#include "misc.h" /* for trouble_msg() */
-struct World;
+#include "main.h" /* for world global */
-extern FILE * try_fopen(char * path, char * mode, struct World * w, char * f)
+extern FILE * try_fopen(char * path, char * mode, char * f)
{
char * msg1 = "Trouble in ";
char * msg2 = " with fopen() (mode '";
char msg[size];
sprintf(msg, "%s%s%s%s%s%s%s", msg1, f, msg2, mode, msg3, path, msg4);
FILE * file_p = fopen(path, mode);
- exit_err(NULL == file_p, w, msg);
+ exit_err(NULL == file_p, msg);
return file_p;
}
-extern void try_fclose(FILE * file, struct World * w, char * f)
+extern void try_fclose(FILE * file, char * f)
{
- char * msg = trouble_msg(w, f, "fclose()");
- exit_err(fclose(file), w, msg);
+ char * msg = trouble_msg(f, "fclose()");
+ exit_err(fclose(file), msg);
free(msg);
}
-extern char * try_fgets(char * line, int linemax, FILE * file,
- struct World * w, char * f)
+extern char * try_fgets(char * line, int linemax, FILE * file, char * f)
{
- char * msg = trouble_msg(w, f, "fgets()");
+ char * msg = trouble_msg(f, "fgets()");
char * test = fgets(line, linemax, file);
- exit_err(NULL == test && ferror(file), w, msg);
+ exit_err(NULL == test && ferror(file), msg);
free(msg);
return test;
}
extern void try_fwrite(void * ptr, size_t size, size_t nmemb, FILE * stream,
- struct World * w, char * f)
+ char * f)
{
- char * msg = trouble_msg(w, f, "fwrite()");
- exit_err(0 == fwrite(ptr, size, nmemb, stream), w, msg);
+ char * msg = trouble_msg(f, "fwrite()");
+ exit_err(0 == fwrite(ptr, size, nmemb, stream), msg);
free(msg);
}
extern void try_fclose_unlink_rename(FILE * file, char * p1, char * p2,
- struct World * w, char * f)
+ char * f)
{
- try_fclose(file, w, f);
+ try_fclose(file, f);
char * msg1 = "Trouble in ";
char * msg4 = "'.";
if (!access(p2, F_OK))
+ strlen(f) + strlen(p2) + 1;
char msg[size];
sprintf(msg, "%s%s%s%s%s", msg1, f, msg2, p2, msg4);
- exit_err(unlink(p2), w, msg);
+ exit_err(unlink(p2), msg);
}
char * msg2 = " with rename() from '";
char * msg3 = "' to '";
+ strlen(msg3) + strlen(p2) + strlen(msg4) + 1;
char msg[size];
sprintf(msg, "%s%s%s%s%s%s%s", msg1, f, msg2, p1, msg3, p2, msg4);
- exit_err(rename(p1, p2), w, msg);
+ exit_err(rename(p1, p2), msg);
}
-extern uint16_t get_linemax(FILE * file, struct World * w, char * f)
+extern uint16_t get_linemax(FILE * file, char * f)
{
- char * msg = trouble_msg(w, f, "textfile_sizes()");
+ char * msg = trouble_msg(f, "textfile_sizes()");
uint16_t linemax;
- exit_err(textfile_sizes(file, &linemax, NULL), w, msg);
+ exit_err(textfile_sizes(file, &linemax, NULL), msg);
free(msg);
return linemax;
}
#ifndef READWRITE_H
#define READWRITE_H
-
-
#include <stdio.h> /* for FILE typedef */
#include <stdint.h> /* for uint8_t, uint16_t, uint32_t */
-struct World;
/* Wrappers to calling from function called "f" of fopen(), fclose(), fgets()
* and fwrite() and calling exit_err() with appropriate error messages.
*/
-extern FILE * try_fopen(char * path, char * mode, struct World * w, char * f);
-extern void try_fclose(FILE * file, struct World * w, char * f);
+extern FILE * try_fopen(char * path, char * mode, char * f);
+extern void try_fclose(FILE * file, char * f);
extern void try_fwrite(void * ptr, size_t size, size_t nmemb, FILE * stream,
- struct World * w, char * f);
+ char * f);
* fgets() is returned unless it is NULL *and* ferror() indicates that an error
* occured; otherwise end of file is assumed and NULL is returned properly.
*/
-extern char * try_fgets(char * line, int size, FILE * file,
- struct World * w, char * f);
+extern char * try_fgets(char * line, int size, FILE * file, char * f);
* Used for handling atomic saving of files via temp files.
*/
extern void try_fclose_unlink_rename(FILE * file, char * p1, char * p2,
- struct World * w, char * f);
+ char * f);
* length of "file", exit via exit_err() with trouble_msg()-generated error
* message on failure.
*/
-extern uint16_t get_linemax(FILE * file, struct World * w, char * f);
+extern uint16_t get_linemax(FILE * file, char * f);
extern uint8_t write_uint16_bigendian(uint16_t x, FILE * file);
extern uint8_t write_uint32_bigendian(uint32_t x, FILE * file);
+
+
#endif
#include <stdint.h> /* for uint8_t */
#include <ncurses.h> /* for endwin() */
#include <errno.h> /* for errno */
-#include "main.h" /* for World struct */
+#include "main.h" /* for world global */
#include "map.h" /* for Map struct */
#include "keybindings.h" /* for free_keybindings() */
#include "command_db.h" /* for free_command_db() */
#include "windows.h" /* for Win struct, free_win(), free_winmeta() */
#include "map_objects.h" /* for free_map_objects, free_map_object_defs() */
-#include "wincontrol.h" /* for free_winconfs() */
#include "misc.h" /* for unload_interface_conf() */
/* The clean-up routine and the flag resource by which it decides what to do. */
static uint32_t cleanup_flags = 0x0000;
-static void cleanup(struct World * world);
+static void cleanup();
-static void cleanup(struct World * world)
+static void cleanup()
{
if (cleanup_flags & CLEANUP_NCURSES)
{
}
if (cleanup_flags & CLEANUP_MAP_OBJECTS)
{
- free_map_objects(world->map_objs);
+ free_map_objects(world.map_objs);
}
if (cleanup_flags & CLEANUP_MAP_OBJECT_DEFS)
{
- free_map_object_defs(world->map_obj_defs);
+ free_map_object_defs(world.map_obj_defs);
}
if (cleanup_flags & CLEANUP_LOG)
{
- free(world->log);
+ free(world.log);
}
if (cleanup_flags & CLEANUP_COMMAND_DB)
{
- free_command_db(world);
+ free_command_db();
}
if (cleanup_flags & CLEANUP_MAP)
{
- free(world->map->cells);
+ free(world.map->cells);
}
if (cleanup_flags & CLEANUP_INTERFACE_CONF)
{
- unload_interface_conf(world);
+ unload_interface_conf(/*&world*/);
}
if (cleanup_flags & CLEANUP_WIN_META)
{
- free_winmeta(world->wmeta);
+ free_winmeta(world.wmeta);
}
}
-extern void exit_game(struct World * world)
+extern void exit_game()
{
- cleanup(world);
+ cleanup();
exit(EXIT_SUCCESS);
}
-extern void exit_err(uint8_t err, struct World * world, char * msg)
+extern void exit_err(uint8_t err, char * msg)
{
if (0 == err)
{
return;
}
- cleanup(world);
+ cleanup();
if (NULL == msg)
{
msg = "Details unknown.";
#include <stdint.h> /* for uint8_t */
-struct World;
/* Exit orderly, clean up. */
-extern void exit_game(struct World * world);
+extern void exit_game();
* unknown", secondly of "err" as the "internal error code", and thirdly of
* errno if it is non-zero.
*/
-extern void exit_err(uint8_t err, struct World * world, char * msg);
+extern void exit_err(uint8_t err, char * msg);
* srand() to ensure portable pseudo-randomness portability.
*/
-
-
#ifndef RRAND_H
#define RRAND_H
* try_fgets(), try_fclose_unlink_rename(), try_fwrite()
*/
#include "rexit.h" /* for exit_err() */
-#include "main.h" /* for World struct */
+#include "main.h" /* for world global */
#include "draw_wins.h" /* for draw_win_map(), draw_win_info(), draw_win_og(),
* draw_win_available_keybindings(),
* draw_win_keybindings_global(), draw_win_inventory(),
/* Return string "prefix" + "id"; malloc()'s string, remember to call free()! */
-static char * string_prefixed_id(struct World * world, char * prefix, char id);
+static char * string_prefixed_id(char * prefix, char id);
/* Create Winconf, init ->view/height_type/width_type to 0, ->id to "id". */
-static void create_winconf(struct World * world, char id, struct WinConf * wcp);
+static void create_winconf(char id, struct WinConf * wcp);
/* Initialize Winconf of "id" from appropriate config file.*/
-static void init_winconf_from_file(struct World * world, char id);
+static void init_winconf_from_file(char id);
/* Wrapper around init_win() called with values from Winconf of "id". */
-static void init_win_from_winconf(struct World * world, char id);
+static void init_win_from_winconf(char id);
/* Save title, draw function, size of window identified by "id" to conffile. */
-static void save_win_config(struct World * world, char id);
+static void save_win_config(char id);
/* Free data pointed to inside WinConf struct. */
-static void free_winconf_data(struct World * world, char id);
+static void free_winconf_data(char id);
/* Write geometry of a window to its WinConf, as positive or negative values
* (dependent on state ofWinConf->height_type / WinConf->width_type).
*/
-static void set_winconf_geometry(struct World * world, char id);
+static void set_winconf_geometry(char id);
/* Get WinConf by "id"; get id of WinConf mothering "win". */
-static struct WinConf * get_winconf_by_id(struct World * world, char id);
+static struct WinConf * get_winconf_by_id(char id);
/* Get (Win->draw) function identified by "c"; NULL if c not mapped to one. */
static void * get_drawfunc_by_char(char c);
-/* Iterate over bytes of world->winconf_ids array. Re-start after null byte. */
-static char get_next_winconf_id(struct World * world);
+/* Iterate over bytes of world.winconf_ids array. Re-start after null byte. */
+static char get_next_winconf_id();
-static char * string_prefixed_id(struct World * world, char * prefix, char id)
+static char * string_prefixed_id(char * prefix, char id)
{
uint8_t size = strlen(prefix) + 2;
- char * path = try_malloc(size, world, "string_prefixed_id()");
+ char * path = try_malloc(size, "string_prefixed_id()");
sprintf(path, "%s_", prefix);
path[size - 2] = id;
return path;
-static void create_winconf(struct World * world, char id, struct WinConf * wcp)
+static void create_winconf(char id, struct WinConf * wcp)
{
wcp->id = id;
wcp->view = 0;
-static void init_winconf_from_file(struct World * world, char id)
+static void init_winconf_from_file(char id)
{
char * tmp = "init_winconf_from_file() on window id '_'";
- char * context = try_malloc(strlen(tmp) + 1, world,
- "init_winconf_from_file()");
+ char * context = try_malloc(strlen(tmp) + 1, "init_winconf_from_file()");
memcpy(context, tmp, strlen(tmp) + 1);
context[strlen(tmp) - 2] = id;
- char * path = string_prefixed_id(world, "config/windows/Win_", id);
- FILE * file = try_fopen(path, "r", world, context);
+ char * path = string_prefixed_id("config/windows/Win_", id);
+ FILE * file = try_fopen(path, "r", context);
free(path);
- uint16_t linemax = get_linemax(file, world, context);
+ uint16_t linemax = get_linemax(file, context);
char line[linemax + 1];
- struct WinConf * winconf = get_winconf_by_id(world, id);
- try_fgets(line, linemax + 1, file, world, context);
- winconf->title = try_malloc(strlen(line), world, context);
+ struct WinConf * winconf = get_winconf_by_id(id);
+ try_fgets(line, linemax + 1, file, context);
+ winconf->title = try_malloc(strlen(line), context);
memcpy(winconf->title, line, strlen(line) - 1); /* Eliminate newline char */
winconf->title[strlen(line) - 1] = '\0'; /* char at end of string. */
- try_fgets(line, linemax + 1, file, world, context);
+ try_fgets(line, linemax + 1, file, context);
winconf->draw = line[0];
- try_fgets(line, linemax + 1, file, world, context);
+ try_fgets(line, linemax + 1, file, context);
winconf->height = atoi(line);
if (0 >= winconf->height)
{
winconf->height_type = 1;
}
- try_fgets(line, linemax + 1, file, world, context);
+ try_fgets(line, linemax + 1, file, context);
winconf->width = atoi(line);
if (0 >= winconf->width)
{
{
break;
}
- * loc_last_ptr = try_malloc(sizeof(struct KeyBinding), world, context);
+ * loc_last_ptr = try_malloc(sizeof(struct KeyBinding), context);
struct KeyBinding * kb_p = * loc_last_ptr;
kb_p->next = 0;
kb_p->key = atoi(command);
cmdptr = strchr(command, ' ') + 1;
- kb_p->name = try_malloc(strlen(cmdptr), world, context);
+ kb_p->name = try_malloc(strlen(cmdptr), context);
memcpy(kb_p->name, cmdptr, strlen(cmdptr) - 1);
kb_p->name[strlen(cmdptr) - 1] = '\0';
loc_last_ptr = & kb_p->next;
}
- try_fclose(file, world, context);
+ try_fclose(file, context);
free(context);
}
-static void init_win_from_winconf(struct World * world, char id)
+static void init_win_from_winconf(char id)
{
char * tmp = "Trouble in init_win_from_file() with init_win() (win id: _).";
- char * err = try_malloc(strlen(tmp) + 1, world, "init_win_from_file()");
+ char * err = try_malloc(strlen(tmp) + 1, "init_win_from_file()");
memcpy(err, tmp, strlen(tmp) + 1);
err[strlen(tmp) - 3] = id;
- struct WinConf * winconf = get_winconf_by_id(world, id);
+ struct WinConf * winconf = get_winconf_by_id(id);
void * f = get_drawfunc_by_char(winconf->draw);
- exit_err(NULL == f, world, err);
- exit_err(init_win(world->wmeta, &winconf->win, winconf->title,
- winconf->height, winconf->width, world, f),
- world, err);
+ exit_err(NULL == f, err);
+ uint8_t test = init_win(world.wmeta, &winconf->win, winconf->title,
+ winconf->height, winconf->width, f);
+ exit_err(test, err);
free(err);
}
-static void save_win_config(struct World * world, char id)
+static void save_win_config(char id)
{
char * f_name = "save_win_config()";
- char * path_tmp = string_prefixed_id(world, "config/windows/Win_tmp_", id);
- FILE * file = try_fopen(path_tmp, "w", world, f_name);
+ char * path_tmp = string_prefixed_id("config/windows/Win_tmp_", id);
+ FILE * file = try_fopen(path_tmp, "w", f_name);
- struct WinConf * wc = get_winconf_by_id(world, id);
+ struct WinConf * wc = get_winconf_by_id(id);
uint8_t size = strlen(wc->title) + 2;
if (size < 7)
{
}
char line[size];
sprintf(line, "%s\n", wc->title);
- try_fwrite(line, sizeof(char), strlen(line), file, world, f_name);
+ try_fwrite(line, sizeof(char), strlen(line), file, f_name);
sprintf(line, "%c\n", wc->draw);
- try_fwrite(line, sizeof(char), strlen(line), file, world, f_name);
+ try_fwrite(line, sizeof(char), strlen(line), file, f_name);
sprintf(line, "%d\n", wc->height);
- try_fwrite(line, sizeof(char), strlen(line), file, world, f_name);
+ try_fwrite(line, sizeof(char), strlen(line), file, f_name);
sprintf(line, "%d\n", wc->width);
- try_fwrite(line, sizeof(char), strlen(line), file, world, f_name);
+ try_fwrite(line, sizeof(char), strlen(line), file, f_name);
uint16_t linemax = 0;
struct KeyBinding * kb_p = wc->kb.kbs;
while (0 != kb_p)
{
snprintf(kb_line, linemax, "%d %s\n", kb_p->key, kb_p->name);
- try_fwrite(kb_line, sizeof(char), strlen(kb_line), file, world, f_name);
+ try_fwrite(kb_line, sizeof(char), strlen(kb_line), file, f_name);
kb_p = kb_p->next;
}
- char * path = string_prefixed_id(world, "config/windows/Win_", id);
- try_fclose_unlink_rename(file, path_tmp, path, world, f_name);
+ char * path = string_prefixed_id("config/windows/Win_", id);
+ try_fclose_unlink_rename(file, path_tmp, path, f_name);
free(path);
free(path_tmp);
}
-static void free_winconf_data(struct World * world, char id)
+static void free_winconf_data(char id)
{
- struct WinConf * wc = get_winconf_by_id(world, id);
+ struct WinConf * wc = get_winconf_by_id(id);
free(wc->title);
free_keybindings(wc->kb.kbs);
free_win(wc->win);
-static void set_winconf_geometry(struct World * world, char id)
+static void set_winconf_geometry(char id)
{
- struct WinConf * wcp = get_winconf_by_id(world, id);
+ struct WinConf * wcp = get_winconf_by_id(id);
if (0 == wcp->height_type)
{
wcp->height = wcp->win->framesize.y;
}
else if (1 == wcp->height_type)
{
- wcp->height = wcp->win->framesize.y - world->wmeta->padsize.y + 1;
+ wcp->height = wcp->win->framesize.y - world.wmeta->padsize.y + 1;
}
if (0 == wcp->width_type)
{
}
else if (1 == wcp->width_type)
{
- wcp->width = wcp->win->framesize.x - world->wmeta->padsize.x;
+ wcp->width = wcp->win->framesize.x - world.wmeta->padsize.x;
}
}
-static struct WinConf * get_winconf_by_id(struct World * world, char id)
+static struct WinConf * get_winconf_by_id(char id)
{
uint8_t i = 0;
while (1)
{
- if (id == world->winconfs[i].id)
+ if (id == world.winconfs[i].id)
{
- return &world->winconfs[i];
+ return &world.winconfs[i];
}
i++;
}
-static char get_next_winconf_id(struct World * world)
+static char get_next_winconf_id()
{
static uint8_t i = 0;
- char c = world->winconf_ids[i];
+ char c = world.winconf_ids[i];
if (0 == c)
{
i = 0;
-extern struct WinConf * get_winconf_by_win(struct World * world,
- struct Win * win)
+extern struct WinConf * get_winconf_by_win(struct Win * win)
{
uint8_t i = 0;
while (1)
{
- if (win == world->winconfs[i].win)
+ if (win == world.winconfs[i].win)
{
- return &world->winconfs[i];
+ return &world.winconfs[i];
}
i++;
}
-extern struct Win * get_win_by_id(struct World * world, char id)
+extern struct Win * get_win_by_id(char id)
{
- struct WinConf * wc = get_winconf_by_id(world, id);
+ struct WinConf * wc = get_winconf_by_id(id);
return wc->win;
}
-extern void init_winconfs(struct World * world)
+extern void init_winconfs()
{
char * f_name = "init_winconfs()";
char * err_o = "Trouble in init_winconfs() with opendir().";
char * err_c = "Trouble in init_winconfs() with closedir().";
DIR * dp = opendir("config/windows");
- exit_err(NULL == dp, world, err_o);
+ exit_err(NULL == dp, err_o);
struct dirent * fn;
errno = 0;
- char * winconf_ids = try_malloc(256, world, f_name);
+ char * winconf_ids = try_malloc(256, f_name);
uint8_t i = 0;
char id;
while (NULL != (fn = readdir(dp)))
{
- if ( 5 == strlen(fn->d_name)
- && fn->d_name == strstr(fn->d_name, "Win_"))
+ if (5 == strlen(fn->d_name) && fn->d_name == strstr(fn->d_name, "Win_"))
{
id = fn->d_name[4];
winconf_ids[i] = id;
}
}
winconf_ids[i] = '\0';
- exit_err(errno, world, err_r);
- exit_err(closedir(dp), world, err_c);
- world->winconf_ids = try_malloc(strlen(winconf_ids) + 1, world, f_name);
- memcpy(world->winconf_ids, winconf_ids, strlen(winconf_ids) + 1);
+ exit_err(errno, err_r);
+ exit_err(closedir(dp), err_c);
+ world.winconf_ids = try_malloc(strlen(winconf_ids) + 1, f_name);
+ memcpy(world.winconf_ids, winconf_ids, strlen(winconf_ids) + 1);
free(winconf_ids);
struct WinConf * winconfs;
- winconfs = try_malloc(strlen(world->winconf_ids) * sizeof(struct WinConf),
- world, f_name);
+ winconfs = try_malloc(strlen(world.winconf_ids) * sizeof(struct WinConf),
+ f_name);
i = 0;
- while (0 != (id = get_next_winconf_id(world)))
+ while (0 != (id = get_next_winconf_id()))
{
- create_winconf(world, id, &winconfs[i]);
+ create_winconf(id, &winconfs[i]);
i++;
}
- world->winconfs = winconfs;
- while (0 != (id = get_next_winconf_id(world)))
+ world.winconfs = winconfs;
+ while (0 != (id = get_next_winconf_id()))
{
- init_winconf_from_file(world, id);
+ init_winconf_from_file(id);
i++;
}
}
-extern void free_winconfs(struct World * world)
+extern void free_winconfs()
{
char id;
- while (0 != (id = get_next_winconf_id(world)))
+ while (0 != (id = get_next_winconf_id()))
{
- free_winconf_data(world, id);
+ free_winconf_data(id);
}
- free(world->winconf_ids);
- free(world->winconfs);
+ free(world.winconf_ids);
+ free(world.winconfs);
}
-extern void init_wins(struct World * world)
+extern void init_wins()
{
char id;
- while (0 != (id = get_next_winconf_id(world)))
+ while (0 != (id = get_next_winconf_id()))
{
- init_win_from_winconf(world, id);
+ init_win_from_winconf(id);
}
}
-extern void sorted_wintoggle_and_activate(struct World * world)
+extern void sorted_wintoggle_and_activate()
{
char * f_name = "sorted_wintoggle_and_activate()";
char * path = "config/windows/toggle_order_and_active";
- FILE * file = try_fopen(path, "r", world, f_name);
- uint16_t linemax = get_linemax(file, world, f_name);
+ FILE * file = try_fopen(path, "r", f_name);
+ uint16_t linemax = get_linemax(file, f_name);
char win_order[linemax + 1];
- try_fgets(win_order, linemax + 1, file, world, f_name);
+ try_fgets(win_order, linemax + 1, file, f_name);
uint8_t a = 0;
- char * err = trouble_msg(world, f_name, "read_uint8()");
- exit_err(read_uint8(file, &a), world, err);
+ char * err = trouble_msg(f_name, "read_uint8()");
+ exit_err(read_uint8(file, &a), err);
free(err);
- try_fclose(file, world, f_name);
+ try_fclose(file, f_name);
uint8_t i = 0;
for (; i < linemax - 1; i++)
{
- if (NULL == strchr(world->winconf_ids, win_order[i]))
+ if (NULL == strchr(world.winconf_ids, win_order[i]))
{
continue;
}
- struct Win * win = get_win_by_id(world, win_order[i]);
- toggle_window(world->wmeta, win);
+ struct Win * win = get_win_by_id(win_order[i]);
+ toggle_window(world.wmeta, win);
if (a == (uint8_t) win_order[i])
{
- world->wmeta->active = win;
+ world.wmeta->active = win;
}
}
}
-extern void save_win_configs(struct World * world)
+extern void save_win_configs()
{
char * f_name = "save_win_configs()";
char id;
- while (0 != (id = get_next_winconf_id(world)))
+ while (0 != (id = get_next_winconf_id()))
{
- save_win_config(world, id);
+ save_win_config(id);
}
char * path = "config/windows/toggle_order_and_active";
char * path_tmp = "config/windows/toggle_order_and_active_tmp";
- FILE * file = try_fopen(path_tmp, "w", world, f_name);
+ FILE * file = try_fopen(path_tmp, "w", f_name);
char line[6];
- struct Win * w_p = world->wmeta->chain_start;
+ struct Win * w_p = world.wmeta->chain_start;
uint8_t i = 0;
while (0 != w_p)
{
- struct WinConf * wc = get_winconf_by_win(world, w_p);
+ struct WinConf * wc = get_winconf_by_win(w_p);
line[i] = wc->id;
w_p = w_p->next;
i++;
}
line[i] = '\n';
- try_fwrite(line, sizeof(char), strlen(line), file, world, f_name);
- if (0 != world->wmeta->active)
+ try_fwrite(line, sizeof(char), strlen(line), file, f_name);
+ if (0 != world.wmeta->active)
{
- struct WinConf * wc = get_winconf_by_win(world, world->wmeta->active);
+ struct WinConf * wc = get_winconf_by_win(world.wmeta->active);
write_uint8(wc->id, file);
}
- try_fclose_unlink_rename(file, path_tmp, path, world, f_name);
+ try_fclose_unlink_rename(file, path_tmp, path, f_name);
}
-extern void toggle_winconfig(struct World * world, struct Win * win)
+extern void toggle_winconfig(struct Win * win)
{
- struct WinConf * wcp = get_winconf_by_win(world, win);
+ struct WinConf * wcp = get_winconf_by_win(win);
if (0 == wcp->view)
{
win->draw = draw_winconf_geometry;
-extern void toggle_win_height_type(struct World * world, struct Win * win)
+extern void toggle_win_height_type(struct Win * win)
{
- struct WinConf * wcp = get_winconf_by_win(world, win);
+ struct WinConf * wcp = get_winconf_by_win(win);
if (0 == wcp->height_type)
{
wcp->height_type = 1;
{
wcp->height_type = 0;
}
- set_winconf_geometry(world, wcp->id);
+ set_winconf_geometry(wcp->id);
}
-extern void toggle_win_width_type(struct World * world, struct Win * win)
+extern void toggle_win_width_type(struct Win * win)
{
- struct WinConf * wcp = get_winconf_by_win(world, win);
- if (0 == wcp->width_type && win->framesize.x <= world->wmeta->padsize.x)
+ struct WinConf * wcp = get_winconf_by_win(win);
+ if (0 == wcp->width_type && win->framesize.x <= world.wmeta->padsize.x)
{
wcp->width_type = 1;
}
{
wcp->width_type = 0;
}
- set_winconf_geometry(world, wcp->id);
+ set_winconf_geometry(wcp->id);
}
-extern uint8_t growshrink_active_window(struct World * world, char change)
+extern uint8_t growshrink_active_window(char change)
{
- if (0 != world->wmeta->active)
+ if (0 != world.wmeta->active)
{
- struct yx_uint16 size = world->wmeta->active->framesize;
+ struct yx_uint16 size = world.wmeta->active->framesize;
if (change == '-')
{
size.y--;
{
size.x++;
}
- uint8_t x = resize_active_win(world->wmeta, size);
- struct WinConf * wcp = get_winconf_by_win(world, world->wmeta->active);
+ uint8_t x = resize_active_win(world.wmeta, size);
+ struct WinConf * wcp = get_winconf_by_win(world.wmeta->active);
if ( 1 == wcp->width_type
- && world->wmeta->active->framesize.x > world->wmeta->padsize.x)
+ && world.wmeta->active->framesize.x > world.wmeta->padsize.x)
{
wcp->width_type = 0;
}
- set_winconf_geometry(world, wcp->id);
+ set_winconf_geometry(wcp->id);
return x;
}
return 0;
#ifndef WINCONTROL_H
#define WINCONTROL_H
-
-
#include <stdint.h> /* for uint8_t, int16_t */
#include "keybindings.h" /* for KeyBiData struct */
#include "yx_uint16.h" /* for yx_uint16 struct */
struct Win;
struct WinMeta;
-struct World;
/* Get WinConf fathering "win"; get Win of WinConf of "id". */
-extern struct WinConf * get_winconf_by_win(struct World * world,
- struct Win * win);
-extern struct Win * get_win_by_id(struct World * world, char id);
+extern struct WinConf * get_winconf_by_win(struct Win * win);
+extern struct Win * get_win_by_id(char id);
/* Create/initialize (from config files)/free Winconf structs. */
-extern void init_winconfs(struct World * world);
-extern void free_winconfs(struct World * world);
-extern void init_wins(struct World * world);
+extern void init_winconfs();
+extern void free_winconfs();
+extern void init_wins();
-/* Toggle windows in world->wins in the order desribed by the first line of
+/* Toggle windows in world.wins in the order desribed by the first line of
* config/windows/toggle_order_and_active, wherein each character should
- * correspond to one window whose ID is found in world->winconf_ids. Unknown
+ * correspond to one window whose ID is found in world.winconf_ids. Unknown
* characters are silently ignored. The first character of the second line of
* the file is also read to determine which window to focus as active (but only
* if it fits the ID of a window thus toggled visible).
*/
-extern void sorted_wintoggle_and_activate(struct World * world);
+extern void sorted_wintoggle_and_activate();
/* Save all window's configurations to their configuration files. */
-extern void save_win_configs(struct World * world);
+extern void save_win_configs();
* for win->center for the various configuration views (y=0, x=0 for
* winconf_geometry and x= for winconf_keys).
*/
-extern void toggle_winconfig(struct World * world, struct Win * win);
+extern void toggle_winconfig(struct Win * win);
/* Toggle interpretation type for Win's width/height of Win in WinConf. Width
* only toggles to 1 if terminal window is at least as wide as WinConf->width.
*/
-extern void toggle_win_height_type(struct World * world, struct Win * win);
-extern void toggle_win_width_type(struct World * world, struct Win * win);
+extern void toggle_win_height_type(struct Win * win);
+extern void toggle_win_width_type(struct Win * win);
*
* Return 0 on success, 1 on (ncurses pad/window memory allocation) error.
*/
-extern uint8_t growshrink_active_window(struct World * world, char change);
+extern uint8_t growshrink_active_window(char change);
extern uint8_t init_win(struct WinMeta * wmeta, struct Win ** wp, char * title,
- int16_t height, int16_t width,
- void * data, void * func)
+ int16_t height, int16_t width, void * func)
{
struct Win * w = malloc(sizeof(struct Win));
if (NULL == w)
return 1;
}
sprintf(w->title, "%s", title);
- w->data = data;
w->draw = func;
w->center.y = 0;
w->center.x = 0;
* 1 - memory allocation error
* 2 - would force virtual screen to grow beyond width or height of 2^16 cells
*
- * TODO: Expose less internals to the API.
- *
* TODO: Think up a more intuitive window positioning algorithm or at least make
* the chain that windows are positioned by visible.
*/
#ifndef WINDOWS_H
#define WINDOWS_H
-
-
#include <stdint.h> /* for uint8_t, uint16_t, uint32_t */
#include <ncurses.h> /* for the WINDOW and chtype typedefs */
#include "yx_uint16.h" /* for yx_uint16 struct */
struct yx_uint16 center; /* window content center to focus window on */
char * title; /* title to be used in window title bar */
void (* draw) (struct Win *); /* how to draw window content ("data") */
- void * data; /* window content to be drawn by _draw() */
chtype * winmap; /* sequence of cells, sorted into lines ... */
struct yx_uint16 winmapsize; /* ... with these geometry infos */
};
/* Initialize a window child of "wmeta" to "title", "height" and "width" and
- * appointing "func"() to interpret and draw the content stored at "data" when
- * the window is visible.
+ * appointing "func"() to interpret and draw the window when it's visible.
*
* Pass 0 for "width" to make the window as wide as the terminal screen. Pass
* negative values for "width" to make the width so many cells smaller than that
* Other members of the Win struct are initialized to 0.
*/
extern uint8_t init_win(struct WinMeta * wmeta, struct Win ** w, char * title,
- int16_t height, int16_t width,
- void * data, void * func);
+ int16_t height, int16_t width, void * func);
#ifndef YX_UINT16_H
#define YX_UINT16_H
-
-
#include <stdint.h> /* for uint8_t, uint16_t */
projects / plomrogue / commitdiff