X-Git-Url: https://plomlompom.com/repos/?a=blobdiff_plain;f=roguelike.c;h=9a1849caf3330de61599db861d4c3a133fad112e;hb=7f1b0fb8bbd4f8c4f07c7d86fb8de0050d925f46;hp=7d535bc9221b7ea446ad2f1128570ade548ad017;hpb=493ae380d5200e00b8648fcb334e39148126676f;p=plomrogue diff --git a/roguelike.c b/roguelike.c index 7d535bc..9a1849c 100644 --- a/roguelike.c +++ b/roguelike.c @@ -1,319 +1,333 @@ +#include +#include +#include #include #include -#include -#include -#include +#include +#include #include "windows.h" +#include "draw_wins.h" +#include "roguelike.h" +#include "keybindings.h" -struct Map { - int width; - int height; - int offset_x; - int offset_y; - int player_x; - int player_y; - char * cells; }; +uint16_t rrand(char use_seed, uint32_t new_seed) { +// Pseudo-random number generator (LGC algorithm). Use instead of rand() to ensure portable predictability. + static uint32_t seed; + if (0 != use_seed) + seed = new_seed; + seed = ((seed * 1103515245) + 12345) % 2147483648; // Values as recommended by POSIX.1-2001 (see rand(3)). + return (seed / 65536); } // Ignore least significant 16 bits (they are less random). -struct KeyBinding { - char * name; - int key; }; +uint16_t read_uint16_bigendian(FILE * file) { +// Read uint16 from file in big-endian order. + const uint16_t nchar = UCHAR_MAX + 1; + unsigned char a = fgetc(file); + unsigned char b = fgetc(file); + return (a * nchar) + b; } -struct KeysWinData { - int max; - char edit; - int select; }; +void write_uint16_bigendian(uint16_t x, FILE * file) { +// Write uint16 to file in beg-endian order. + const uint16_t nchar = UCHAR_MAX + 1; + unsigned char a = x / nchar; + unsigned char b = x % nchar; + fputc(a, file); + fputc(b, file); } -struct World { - struct KeyBinding * keybindings; - struct KeysWinData * keyswindata; }; +uint32_t read_uint32_bigendian(FILE * file) { +// Read uint32 from file in big-endian order. + const uint16_t nchar = UCHAR_MAX + 1; + unsigned char a = fgetc(file); + unsigned char b = fgetc(file); + unsigned char c = fgetc(file); + unsigned char d = fgetc(file); + return (a * nchar * nchar * nchar) + (b * nchar * nchar) + (c * nchar) + d; } -void draw_with_linebreaks (struct Win * win, char * text, int start_y) { -// Write text into window content space. Start on row start_y. Fill unused rows with whitespace. - int x, y; - char toggle; - char fin = 0; - int z = -1; - for (y = start_y; y < win->height; y++) { - if (0 == fin) - toggle = 0; - for (x = 0; x < win->width; x++) { - if (0 == toggle) { - z++; - if ('\n' == text[z]) { - toggle = 1; - continue; } - else - mvwaddch(win->curses_win, y, x, text[z]); - if ('\n' == text[z+1]) { - z++; - toggle = 1; } - else if (0 == text[z+1]) { - toggle = 1; - fin = 1; } } } } } - -void draw_text_from_bottom (struct Win * win) { -// Draw text in win->data from end/bottom to the top. - char * text = (char *) win->data; - char toggle = 0; - int x, y, offset; - int z = -1; - for (y = 0; 0 == toggle; y++) // Determine number of lines text would have in a window of - for (x = 0; x < win->width; x++) { // available width, but infinite height. - z++; - if ('\n' == text[z]) // Treat \n and \0 as control characters for incrementing y and - break; // stopping the loop. Make sure they don't count as cell space - if ('\n' == text[z+1]) { // themselves. - z++; - break; } - else if (0 == text[z+1]) { - toggle = 1; - break; } } - z = -1; - int start_y = 0; - if (y < win->height) // Depending on what is bigger, determine start point in window or in text. - start_y = win->height - y; - else if (y > win->height) { - offset = y - win->height; - for (y = 0; y < offset; y++) - for (x = 0; x < win->width; x++) { - z++; - if ('\n' == text[z]) - break; - if ('\n' == text[z+1]) { - z++; - break; } } - text = text + (sizeof(char) * (z + 1)); } - draw_with_linebreaks(win, text, start_y); } +void write_uint32_bigendian(uint32_t x, FILE * file) { +// Write uint32 to file in beg-endian order. + const uint16_t nchar = UCHAR_MAX + 1; + unsigned char a = x / (nchar * nchar * nchar); + unsigned char b = (x - (a * nchar * nchar * nchar)) / (nchar * nchar); + unsigned char c = (x - ((a * nchar * nchar * nchar) + (b * nchar * nchar))) / nchar; + unsigned char d = x % nchar; + fputc(a, file); + fputc(b, file); + fputc(c, file); + fputc(d, file); } -void draw_map (struct Win * win) { -// Draw map determined by win->data Map struct into window. Respect offset. - struct Map map = * (struct Map *) win->data; - char * cells = map.cells; - int width_map_av = map.width - map.offset_x; - int height_map_av = map.height - map.offset_y; - int x, y, z; - for (y = 0; y < win->height; y++) { - z = map.offset_x + (map.offset_y + y) * (map.width); - for (x = 0; x < win->width; x++) { - if (y < height_map_av && x < width_map_av) { - if (z == (map.width * map.player_y) + map.player_x) - mvwaddch(win->curses_win, y, x, '@'); - else - mvwaddch(win->curses_win, y, x, cells[z]); - z++; } } } } +void load_game(struct World * world) { +// Load game data from game file. + FILE * file = fopen("savefile", "r"); + world->seed = read_uint32_bigendian(file); + world->turn = read_uint32_bigendian(file); + world->player->y = read_uint16_bigendian(file); + world->player->x = read_uint16_bigendian(file); + world->monster->y = read_uint16_bigendian(file); + world->monster->x = read_uint16_bigendian(file); + fclose(file); } -void draw_info (struct Win * win) { -// Draw info window by appending win->data integer value to "Turn: " display. - int count = * (int *) win->data; - char text[100]; - snprintf(text, 100, "Turn: %d", count); - draw_with_linebreaks(win, text, 0); } +void save_game(struct World * world) { +// Save game data to game file. + FILE * file = fopen("savefile", "w"); + write_uint32_bigendian(world->seed, file); + write_uint32_bigendian(world->turn, file); + write_uint16_bigendian(world->player->y, file); + write_uint16_bigendian(world->player->x, file); + write_uint16_bigendian(world->monster->y, file); + write_uint16_bigendian(world->monster->x, file); + fclose(file); } void toggle_window (struct WinMeta * win_meta, struct Win * win) { // Toggle display of window win. - if (0 != win->curses_win) + if (0 != win->curses) suspend_window(win_meta, win); else append_window(win_meta, win); } +void growshrink_active_window (struct WinMeta * win_meta, char change) { +// Grow or shrink active window horizontally or vertically by one cell size. + if (0 != win_meta->active) { + uint16_t height = win_meta->active->height; + uint16_t width = win_meta->active->width; + if (change == '-') + height--; + else if (change == '+') + height++; + else if (change == '_') + width--; + else if (change == '*') + width++; + resize_active_window (win_meta, height, width); } } + struct Map init_map () { // Initialize map with some experimental start values. struct Map map; - map.width = 128; - map.height = 128; + map.width = 64; + map.height = 64; map.offset_x = 0; map.offset_y = 0; - map.player_x = 2; - map.player_y = 2; map.cells = malloc(map.width * map.height); - int x, y; + uint16_t x, y, ran; + char terrain; for (y = 0; y < map.height; y++) - for (x = 0; x < map.width; x++) - map.cells[(y * map.width) + x] = '.'; - map.cells[(5 * map.width) + 5] = 'X'; - map.cells[(3 * map.width) + 8] = 'X'; - map.cells[(8 * map.width) + 3] = 'X'; + for (x = 0; x < map.width; x++) { + terrain = '.'; + ran = rrand(0, 0); + if ( 0 == ran % ((x*x) / 3 + 1) + || 0 == ran % ((y*y) / 3 + 1) + || 0 == ran % ((map.width - x - 1) * (map.width - x - 1) / 3 + 1) + || 0 == ran %((map.height - y - 1) * (map.height - y - 1) / 3 + 1)) + terrain = ' '; + map.cells[(y * map.width) + x] = terrain; } return map; } -void update_info (struct Win * win) { -// Update info data by incrementing turn value. - * (int *) win->data = * (int *) win->data + 1; } +void map_scroll (struct Map * map, char dir) { +// Scroll map into direction dir if possible by changing the offset. + if ('n' == dir && map->offset_y > 0) + map->offset_y--; + else if ('s' == dir) + map->offset_y++; + else if ('w' == dir && map->offset_x > 0) + map->offset_x--; + else if ('e' == dir) + map->offset_x++; } + +void next_turn (struct World * world) { +// Increment turn and move enemy. + world->turn++; + rrand(1, world->seed * world->turn); + char d = rrand(0, 0) % 5; + uint16_t ty = world->monster->y; + uint16_t tx = world->monster->x; + if (1 == d) + ty++; + else if (2 == d) + ty--; + else if (3 == d) + tx++; + else if (4 == d) + tx--; + if (tx == world->player->x && ty == world->player->y) + update_log(world, "\nThe monster hits you."); + else if (is_passable(world, tx, ty)) { + world->monster->y = ty; + world->monster->x = tx; } } -void update_log (struct Win * win, char * text) { +void update_log (struct World * world, char * text) { // Update log with new text to be appended. char * new_text; - int len_old = strlen(win->data); - int len_new = strlen(text); - int len_whole = len_old + len_new + 1; + uint16_t len_old = strlen(world->log); + uint16_t len_new = strlen(text); + uint16_t len_whole = len_old + len_new + 1; new_text = calloc(len_whole, sizeof(char)); - memcpy(new_text, win->data, len_old); + memcpy(new_text, world->log, len_old); memcpy(new_text + len_old, text, len_new); - free(win->data); - win->data = new_text; } + free(world->log); + world->log = new_text; } -int get_action_key (struct KeyBinding * keybindings, char * name) { -// Return key matching name in keybindings. - int i = 0; - while (strcmp(keybindings[i].name, name) ) - i++; - return keybindings[i].key; } +char is_passable (struct World * world, uint16_t x, uint16_t y) { +// Check if coordinate on (or beyond) map is accessible to movement. + char passable = 0; + if (0 <= x && x < world->map->width && 0 <= y && y < world->map->height) + if ('.' == world->map->cells[y * world->map->width + x]) + passable = 1; + return passable; } -char * get_keyname(int keycode) { -// Translate some keycodes to readable names of max 9 chars. - char * keyname; - keyname = malloc(15); - if (32 < keycode && keycode < 127) - sprintf(keyname, "%c", keycode); - else if (keycode == 9) - sprintf(keyname, "TAB"); - else if (keycode == 10) - sprintf(keyname, "RETURN"); - else if (keycode == 27) - sprintf(keyname, "ESCAPE"); - else if (keycode == 32) - sprintf(keyname, "SPACE"); - else if (keycode == KEY_UP) - sprintf(keyname, "UP"); - else if (keycode == KEY_DOWN) - sprintf(keyname, "DOWN"); - else if (keycode == KEY_LEFT) - sprintf(keyname, "LEFT"); - else if (keycode == KEY_RIGHT) - sprintf(keyname, "RIGHT"); - else if (keycode == KEY_HOME) - sprintf(keyname, "HOME"); - else if (keycode == KEY_BACKSPACE) - sprintf(keyname, "BACKSPACE"); - else if (keycode >= KEY_F0 && keycode <= KEY_F(63)) { - int f = keycode - KEY_F0; - sprintf(keyname, "F%d", f); } - else if (keycode == KEY_DC) - sprintf(keyname, "DELETE"); - else if (keycode == KEY_IC) - sprintf(keyname, "INSERT"); - else if (keycode == KEY_NPAGE) - sprintf(keyname, "NEXT PAGE"); - else if (keycode == KEY_PPAGE) - sprintf(keyname, "PREV PAGE"); - else if (keycode == KEY_END) - sprintf(keyname, "END"); - else - sprintf(keyname, "(unknown)"); - return keyname; } - -void draw_keys_window (struct Win * win) { -// Draw keybinding window. - struct World * world = (struct World *) win->data; - struct KeysWinData * keyswindata = (struct KeysWinData *) world->keyswindata; - struct KeyBinding * keybindings = world->keybindings; - int offset = 0; - if (keyswindata->max >= win->height) { - if (keyswindata->select > win->height / 2) { - if (keyswindata->select < (keyswindata->max - (win->height / 2))) - offset = keyswindata->select - (win->height / 2); - else - offset = keyswindata->max - win->height + 1; } } - int keydescwidth = 9 + 1; // max length assured by get_keyname() + \0 - char * keydesc = malloc(keydescwidth); - attr_t attri; - int y, x; - char * keyname; - for (y = 0; y <= keyswindata->max && y < win->height; y++) { - attri = 0; - if (y == keyswindata->select - offset) { - attri = A_REVERSE; - if (1 == keyswindata->edit) - attri = attri | A_BLINK; } - keyname = get_keyname(keybindings[y + offset].key); - snprintf(keydesc, keydescwidth, "%-9s", keyname); - free(keyname); - for (x = 0; x < win->width; x++) - if (x < strlen(keydesc)) - mvwaddch(win->curses_win, y, x, keydesc[x] | attri); - else if (strlen(keydesc) < x && x < strlen(keybindings[y + offset].name) + strlen(keydesc) + 1) - mvwaddch(win->curses_win, y, x, keybindings[y + offset].name[x - strlen(keydesc) - 1] | attri); - else - mvwaddch(win->curses_win, y, x, ' ' | attri); } - free(keydesc); } +void record_action (char action) { +// Append action to game record file. + FILE * file = fopen("record", "a"); + fputc(action, file); + fclose(file); } -void init_keybindings(struct World * world) { -// Initialize keybindings from file "keybindings". - FILE * file = fopen("keybindings", "r"); - int lines = 0; - int c = 0; - int linemax = 0; - int c_count = 0; - while (EOF != c) { - c_count++; - c = getc(file); - if ('\n' == c) { - if (c_count > linemax) - linemax = c_count; - c_count = 0; - lines++; } } - struct KeyBinding * keybindings = malloc(lines * sizeof(struct KeyBinding)); - fseek(file, 0, SEEK_SET); - char * command = malloc(linemax); - int commcount = 0; - char * digits = malloc(3); - int digicount = 0; - int key, digimax; - int keycount = 0; - c = getc(file); - while (EOF != c) { - if ('\n' == c) { - keybindings[keycount].name = calloc(commcount + 1, sizeof(char)); - memcpy(keybindings[keycount].name, command, commcount); - keybindings[keycount].key = key; - keycount++; - digicount = 0; - commcount = 0; } - else if (-1 != digicount) - if (' ' == c) { - key = 0; - digimax = digicount - 1; - while (digicount > 0) { - digicount--; - key = key + ((digits[digicount] - 48) * pow(10, digimax - digicount)); } - digicount = -1; } - else { - digits[digicount] = c; - digicount++; } +void move_player (struct World * world, char d) { +// Move player in direction d, increment turn counter and update log. + static char prev = 0; + char success = 0; + char * dir; + uint16_t ty = world->player->y; + uint16_t tx = world->player->x; + if ('s' == d) { + dir = "south"; + ty++; } + if ('n' == d) { + dir = "north"; + ty--; } + if ('w' == d) { + dir = "west"; + tx--; } + if ('e' == d) { + dir = "east"; + tx++; } + if (ty == world->monster->y && tx == world->monster->x) + success = 2; + else if (is_passable(world, tx, ty)) { + success = 1; + world->player->y = ty; + world->player->x = tx; } + if (success * d == prev) + update_log (world, "."); + else { + if (2 == success) + update_log (world, "\nYou hit the monster."); else { - command[commcount] = c; - commcount++; } - c = getc(file); } - free(command); - free(digits); - fclose(file); - struct KeysWinData * keyswindata = malloc(sizeof(struct KeysWinData)); - keyswindata->max = lines - 1; - keyswindata->select = 0; - keyswindata->edit = 0; - world->keybindings = keybindings; - world->keyswindata = keyswindata; } + char * msg = calloc(25, sizeof(char)); + char * msg_content = "You fail to move"; + if (1 == success) + msg_content = "You move"; + sprintf(msg, "\n%s %s.", msg_content, dir); + update_log (world, msg); + free(msg); } } + prev = success * d; + if (1 == world->interactive) + record_action(d); + next_turn (world); } -void save_keybindings(struct World * world) { -// Write keybindings to keybindings file. - struct KeysWinData * keyswindata = (struct KeysWinData *) world->keyswindata; - struct KeyBinding * keybindings = world->keybindings; - FILE * file = fopen("keybindings", "w"); - int linemax = 0; - int i; - for (i = 0; i <= keyswindata->max; i++) - if (strlen(keybindings[i].name) > linemax) - linemax = strlen(keybindings[i].name); - linemax = linemax + 6; // + 6 = + 3 digits + whitespace + newline + null byte - char * line = malloc(linemax); - for (i = 0; i <= keyswindata->max; i++) { - snprintf(line, linemax, "%d %s\n", keybindings[i].key, keybindings[i].name); - fwrite(line, sizeof(char), strlen(line), file); } - free(line); - fclose(file); } +void player_wait (struct World * world) { +// Make player wait one turn. + if (1 == world->interactive) + record_action(0); + next_turn (world); + update_log (world, "\nYou wait."); } -int main () { +void startpos(struct World * world) { +// Initialize some default starting values. + world->turn = 1; + world->player->y = 8; + world->player->x = 8; + world->monster->y = 55; + world->monster->x = 55; } + +unsigned char meta_keys(int key, struct World * world, struct WinMeta * win_meta, struct Win * win_keys, + struct Win * win_map, struct Win * win_info, struct Win * win_log) { +// Call some meta program / window management actions dependent on key. Return 1 to signal quitting. + if (key == get_action_key(world->keybindings, "quit")) + return 1; + else if (key == get_action_key(world->keybindings, "scroll pad right")) + scroll_pad (win_meta, '+'); + else if (key == get_action_key(world->keybindings, "scroll pad left")) + scroll_pad (win_meta, '-'); + else if (key == get_action_key(world->keybindings, "toggle keys window")) + toggle_window(win_meta, win_keys); + else if (key == get_action_key(world->keybindings, "toggle map window")) + toggle_window(win_meta, win_map); + else if (key == get_action_key(world->keybindings, "toggle info window")) + toggle_window(win_meta, win_info); + else if (key == get_action_key(world->keybindings, "toggle log window")) + toggle_window(win_meta, win_log); + else if (key == get_action_key(world->keybindings, "cycle forwards")) + cycle_active_window(win_meta, 'n'); + else if (key == get_action_key(world->keybindings, "cycle backwards")) + cycle_active_window(win_meta, 'p'); + else if (key == get_action_key(world->keybindings, "shift forwards")) + shift_active_window(win_meta, 'f'); + else if (key == get_action_key(world->keybindings, "shift backwards")) + shift_active_window(win_meta, 'b'); + else if (key == get_action_key(world->keybindings, "grow horizontally")) + growshrink_active_window(win_meta, '*'); + else if (key == get_action_key(world->keybindings, "shrink horizontally")) + growshrink_active_window(win_meta, '_'); + else if (key == get_action_key(world->keybindings, "grow vertically")) + growshrink_active_window(win_meta, '+'); + else if (key == get_action_key(world->keybindings, "shrink vertically")) + growshrink_active_window(win_meta, '-'); + else if (key == get_action_key(world->keybindings, "save keys")) + save_keybindings(world); + else if (key == get_action_key(world->keybindings, "keys nav up")) + keyswin_move_selection (world, 'u'); + else if (key == get_action_key(world->keybindings, "keys nav down")) + keyswin_move_selection (world, 'd'); + else if (key == get_action_key(world->keybindings, "keys mod")) + keyswin_mod_key (world, win_meta); + else if (key == get_action_key(world->keybindings, "map up")) + map_scroll (world->map, 'n'); + else if (key == get_action_key(world->keybindings, "map down")) + map_scroll (world->map, 's'); + else if (key == get_action_key(world->keybindings, "map right")) + map_scroll (world->map, 'e'); + else if (key == get_action_key(world->keybindings, "map left")) + map_scroll (world->map, 'w'); + return 0; } + +int main (int argc, char *argv[]) { struct World world; + world.interactive = 1; + int opt; + uint32_t start_turn; + while ((opt = getopt(argc, argv, "s::")) != -1) { + switch (opt) { + case 's': + world.interactive = 0; + start_turn = 0; + if (optarg) + start_turn = atoi(optarg); + break; + default: + exit(EXIT_FAILURE); } } + init_keybindings(&world); + world.log = calloc(1, sizeof(char)); + update_log (&world, " "); + struct Player player; + world.player = &player; + struct Monster monster; + world.monster = &monster; + FILE * file; + + if (0 == world.interactive) { + startpos(&world); + file = fopen("record", "r"); + world.seed = read_uint32_bigendian(file); } + else { + if (0 == access("savefile", F_OK)) + load_game(&world); + else { + startpos(&world); + world.seed = time(NULL); + file = fopen("record", "w"); + write_uint32_bigendian(world.seed, file); + fclose(file); } } + rrand(1, world.seed); + struct Map map = init_map(); + world.map = ↦ WINDOW * screen = initscr(); noecho(); @@ -321,100 +335,79 @@ int main () { keypad(screen, TRUE); raw(); struct WinMeta win_meta = init_win_meta(screen); - - struct Win win_keys = init_window(&win_meta, "Keys"); - win_keys.draw = draw_keys_window; - win_keys.data = &world; - - struct Win win_map = init_window(&win_meta, "Map"); - win_map.draw = draw_map; - struct Map map = init_map(); - win_map.data = ↦ - - struct Win win_info = init_window(&win_meta, "Info"); - win_info.draw = draw_info; - win_info.data = malloc(sizeof(int)); - * (int *) win_info.data = 0; - - struct Win win_log = init_window(&win_meta, "Log"); - win_log.draw = draw_text_from_bottom; - win_log.data = calloc(1, sizeof(char)); - update_log (&win_log, "Start!"); + struct Win win_keys = init_window(&win_meta, "Keys", &world, draw_keys_win); + struct Win win_map = init_window(&win_meta, "Map", &world, draw_map_win); + struct Win win_info = init_window(&win_meta, "Info", &world, draw_info_win); + struct Win win_log = init_window(&win_meta, "Log", &world, draw_log_win); + win_keys.width = 29; + win_map.width = win_meta.width - win_keys.width - win_log.width - 2; + win_info.height = 1; + win_log.height = win_meta.height - 3; + toggle_window(&win_meta, &win_keys); + toggle_window(&win_meta, &win_map); + toggle_window(&win_meta, &win_info); + toggle_window(&win_meta, &win_log); int key; - while (1) { - draw_all_windows (&win_meta); - key = getch(); - if (key == get_action_key(world.keybindings, "quit")) - break; - else if (key == get_action_key(world.keybindings, "scroll pad right")) - win_meta.pad_offset++; - else if (key == get_action_key(world.keybindings, "scroll pad left") && win_meta.pad_offset > 0) - win_meta.pad_offset--; - else if (key == get_action_key(world.keybindings, "toggle keys window")) - toggle_window(&win_meta, &win_keys); - else if (key == get_action_key(world.keybindings, "toggle map window")) - toggle_window(&win_meta, &win_map); - else if (key == get_action_key(world.keybindings, "toggle info window")) - toggle_window(&win_meta, &win_info); - else if (key == get_action_key(world.keybindings, "toggle log window")) - toggle_window(&win_meta, &win_log); - else if (key == get_action_key(world.keybindings, "cycle forwards") && win_meta.active != 0) - cycle_active_window(&win_meta, 'n'); - else if (key == get_action_key(world.keybindings, "cycle backwards") && win_meta.active != 0) - cycle_active_window(&win_meta, 'p'); - else if (key == get_action_key(world.keybindings, "shift forwards") && win_meta.active != 0) - shift_window(&win_meta, 'f'); - else if (key == get_action_key(world.keybindings, "shift backwards") && win_meta.active != 0) - shift_window(&win_meta, 'b'); - else if (key == get_action_key(world.keybindings, "grow horizontally") && win_meta.active != 0) - resize_window(&win_meta, '*'); - else if (key == get_action_key(world.keybindings, "shrink horizontally") && win_meta.active != 0) - resize_window(&win_meta, '_'); - else if (key == get_action_key(world.keybindings, "grow vertically") && win_meta.active != 0) - resize_window(&win_meta, '+'); - else if (key == get_action_key(world.keybindings, "shrink vertically") && win_meta.active != 0) - resize_window(&win_meta, '-'); - else if (key == get_action_key(world.keybindings, "save keys")) - save_keybindings(&world); - else if (key == get_action_key(world.keybindings, "keys nav up") && world.keyswindata->select > 0) - world.keyswindata->select--; - else if (key == get_action_key(world.keybindings, "keys nav down") && world.keyswindata->select < world.keyswindata->max) - world.keyswindata->select++; - else if (key == get_action_key(world.keybindings, "keys mod")) { - world.keyswindata->edit = 1; + unsigned char quit_called; + if (0 == world.interactive) { + unsigned char still_reading_file = 1; + int action; + while (1) { + if (start_turn == world.turn) + start_turn = 0; + if (0 == start_turn) { + draw_all_windows (&win_meta); + key = getch(); } + if (1 == still_reading_file && + (world.turn < start_turn || key == get_action_key(world.keybindings, "wait / next turn")) ) { + action = getc(file); + if (EOF == action) { + start_turn = 0; + still_reading_file = 0; } + else if (0 == action) + player_wait (&world); + else if ('s' == action) + move_player(&world, 's'); + else if ('n' == action) + move_player(&world, 'n'); + else if ('e' == action) + move_player(&world, 'e'); + else if ('w' == action) + move_player(&world, 'w'); } + else + quit_called = meta_keys(key, &world, &win_meta, &win_keys, &win_map, &win_info, &win_log); + if (1 == quit_called) + break; } } + else { + uint32_t last_turn = 0; + while (1) { + if (last_turn != world.turn) { + save_game(&world); + last_turn = world.turn; } draw_all_windows (&win_meta); key = getch(); - if (key < 1000) // ensure maximum of three digits in key code field - world.keybindings[world.keyswindata->select].key = key; - world.keyswindata->edit = 0; } - else if (key == get_action_key(world.keybindings, "map up") && map.offset_y > 0) - map.offset_y--; - else if (key == get_action_key(world.keybindings, "map down")) - map.offset_y++; - else if (key == get_action_key(world.keybindings, "map right")) - map.offset_x++; - else if (key == get_action_key(world.keybindings, "map left") && map.offset_x > 0) - map.offset_x--; - else if (key == get_action_key(world.keybindings, "player down") && map.player_y < map.height - 1) { - update_info (&win_info); - update_log (&win_log, "\nYou move south."); - map.player_y++; } - else if (key == get_action_key(world.keybindings, "player up") && map.player_y > 0) { - update_info (&win_info); - update_log (&win_log, "\nYou move north."); - map.player_y--; } - else if (key == get_action_key(world.keybindings, "player right") && map.player_x < map.width - 1) { - update_info (&win_info); - update_log (&win_log, "\nYou move east."); - map.player_x++; } - else if (key == get_action_key(world.keybindings, "player left") && map.player_x > 0) { - update_info (&win_info); - update_log (&win_log, "\nYou move west."); - map.player_x--; } - else if (key == get_action_key(world.keybindings, "wait") ) { - update_info (&win_info); - update_log (&win_log, "\nYou wait."); } } + if (key == get_action_key(world.keybindings, "player down")) + move_player(&world, 's'); + else if (key == get_action_key(world.keybindings, "player up")) + move_player(&world, 'n'); + else if (key == get_action_key(world.keybindings, "player right")) + move_player(&world, 'e'); + else if (key == get_action_key(world.keybindings, "player left")) + move_player(&world, 'w'); + else if (key == get_action_key(world.keybindings, "wait / next turn")) + player_wait (&world); + else + quit_called = meta_keys(key, &world, &win_meta, &win_keys, &win_map, &win_info, &win_log); + if (1 == quit_called) + break; } } + + free(map.cells); + for (key = 0; key <= world.keyswindata->max; key++) + free(world.keybindings[key].name); + free(world.keybindings); + free(world.keyswindata); + free(world.log); endwin(); return 0; }