X-Git-Url: https://plomlompom.com/repos/?a=blobdiff_plain;f=src%2Froguelike.c;h=a4db13ca22db478f5c9dccda4a28012492e8164f;hb=714bf970109b33005e0ab3e588d818460ccdc304;hp=f0057e295884edbae3ad10dc1819dcd9d07d3c8d;hpb=e9d8b1aca776341c9cdaa2ea6406336661d82a76;p=plomrogue diff --git a/src/roguelike.c b/src/roguelike.c index f0057e2..a4db13c 100644 --- a/src/roguelike.c +++ b/src/roguelike.c @@ -1,3 +1,4 @@ +#include "roguelike.h" #include #include #include @@ -6,9 +7,9 @@ #include #include "windows.h" #include "draw_wins.h" -#include "roguelike.h" #include "keybindings.h" #include "readwrite.h" +#include "objects_on_map.h" uint16_t rrand(char use_seed, uint32_t new_seed) { // Pseudo-random number generator (LGC algorithm). Use instead of rand() to ensure portable predictability. @@ -18,15 +19,99 @@ uint16_t rrand(char use_seed, uint32_t 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). +void update_log (struct World * world, char * text) { +// Update log by appending text, or by appending a "." if text is the same as the last one. + static char * last_msg; + if (0 == last_msg) + last_msg = calloc(1, sizeof(char)); + char * new_text; + uint16_t len_old = strlen(world->log); + if (0 == strcmp(last_msg, text)) { + uint16_t len_whole = len_old + 1; + new_text = calloc(len_whole + 1, sizeof(char)); + memcpy(new_text, world->log, len_old); + memcpy(new_text + len_old, ".", 1); } + else { + uint16_t len_new = strlen(text); + uint16_t len_whole = len_old + len_new + 1; + new_text = calloc(len_whole, sizeof(char)); + memcpy(new_text, world->log, len_old); + memcpy(new_text + len_old, text, len_new); + last_msg = calloc(len_new + 1, sizeof(char)); + memcpy(last_msg, text, len_new); } + free(world->log); + world->log = new_text; } + +struct Map init_map () { +// Initialize map with some experimental start values. + struct Map map; + map.size.x = 64; + map.size.y = 64; + map.offset.x = 0; + map.offset.y = 0; + uint32_t size = map.size.x * map.size.y; + map.cells = malloc(size); + uint16_t y, x; + for (y = 0; y < map.size.y; y++) + for (x = 0; x < map.size.x; x++) + map.cells[(y * map.size.x) + x] = '~'; + map.cells[size / 2 + (map.size.x / 2)] = '.'; + uint32_t curpos; + while (1) { + y = rrand(0, 0) % map.size.y; + x = rrand(0, 0) % map.size.x; + curpos = y * map.size.x + x; + if ('~' == map.cells[curpos] && + ( (curpos >= map.size.x && '.' == map.cells[curpos - map.size.x]) + || (curpos < map.size.x * (map.size.y-1) && '.' == map.cells[curpos + map.size.x]) + || (curpos > 0 && curpos % map.size.x != 0 && '.' == map.cells[curpos-1]) + || (curpos < (map.size.x * map.size.y) && (curpos+1) % map.size.x != 0 && '.' == map.cells[curpos+1]))) { + if (y == 0 || y == map.size.y - 1 || x == 0 || x == map.size.x - 1) + break; + map.cells[y * map.size.x + x] = '.'; } } + return map; } + +void map_scroll (struct Map * map, char dir, struct yx_uint16 win_size) { +// Scroll map into direction dir if possible by changing the offset. + if (NORTH == dir && map->offset.y > 0) + map->offset.y--; + else if (WEST == dir && map->offset.x > 0) + map->offset.x--; + else if (SOUTH == dir && map->offset.y + win_size.y < map->size.y) + map->offset.y++; + else if (EAST == dir && map->offset.x + win_size.x < map->size.x) + map->offset.x++; } + +void map_center_player (struct Map * map, struct Player * player, struct yx_uint16 win_size) { +// Center map on player. + if (player->pos.y < win_size.y / 2) map->offset.y = 0; + else if (player->pos.y < map->size.y - (win_size.y / 2)) map->offset.y = player->pos.y - (win_size.y / 2); + else map->offset.y = map->size.y - win_size.y; + if (player->pos.x < win_size.x / 2) map->offset.x = 0; + else if (player->pos.x < map->size.x - (win_size.x / 2)) map->offset.x = player->pos.x - (win_size.x / 2); + else map->offset.x = map->size.x - win_size.x; } + +void turn_over (struct World * world, char action) { +// Record action in game record file, increment turn and move enemy. + if (1 == world->interactive) { + FILE * file = fopen("record", "a"); + fputc(action, file); + fclose(file); } + world->turn++; + rrand(1, world->seed * world->turn); + struct Monster * monster; + for (monster = world->monster; monster != 0; monster = monster->cmo.next) + move_monster(world, monster); } + 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); + write_uint16_bigendian(world->player->pos.y + 1, file); + write_uint16_bigendian(world->player->pos.x + 1, file); + write_map_objects (world->monster, file, write_map_objects_monsterdata); + write_map_objects (world->item, file, readwrite_map_objects_dummy); fclose(file); } void toggle_window (struct WinMeta * win_meta, struct Win * win) { @@ -46,153 +131,12 @@ void scroll_pad (struct WinMeta * win_meta, char dir) { 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->frame.size.y; - uint16_t width = win_meta->active->frame.size.x; - if (change == '-') - height--; - else if (change == '+') - height++; - else if (change == '_') - width--; - else if (change == '*') - width++; - resize_active_win (win_meta, height, width); } } - -struct Map init_map () { -// Initialize map with some experimental start values. - struct Map map; - map.width = 64; - map.height = 64; - map.offset_x = 0; - map.offset_y = 0; - uint32_t size = map.width * map.height; - map.cells = malloc(size); - uint16_t y, x; - for (y = 0; y < map.height; y++) - for (x = 0; x < map.width; x++) - map.cells[(y * map.width) + x] = '~'; - map.cells[size / 2 + (map.width / 2)] = '.'; - uint32_t repeats, root, curpos; - for (root = 0; root * root * root < size; root++); - for (repeats = 0; repeats < size * root; repeats++) { - y = rrand(0, 0) % map.height; - x = rrand(0, 0) % map.width; - curpos = y * map.width + x; - if ('~' == map.cells[curpos] && - ( (curpos >= map.width && '.' == map.cells[curpos - map.width]) - || (curpos < map.width * (map.height-1) && '.' == map.cells[curpos + map.width]) - || (curpos > 0 && curpos % map.width != 0 && '.' == map.cells[curpos-1]) - || (curpos < (map.width * map.height) && (curpos+1) % map.width != 0 && '.' == map.cells[curpos+1]))) - map.cells[y * map.width + x] = '.'; } - return map; } - -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->map, ty, tx)) { - world->monster->y = ty; - world->monster->x = tx; } } - -void update_log (struct World * world, char * text) { -// Update log with new text to be appended. - char * new_text; - 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, world->log, len_old); - memcpy(new_text + len_old, text, len_new); - free(world->log); - world->log = new_text; } - -char is_passable (struct Map * map, uint16_t y, uint16_t x) { -// Check if coordinate on (or beyond) map is accessible to movement. - char passable = 0; - if (0 <= x && x < map->width && 0 <= y && y < map->height) - if ('.' == map->cells[y * map->width + x]) - passable = 1; - return passable; } - -void record_action (char action) { -// Append action to game record file. - FILE * file = fopen("record", "a"); - fputc(action, file); - fclose(file); } - -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->map, ty, tx)) { - 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 { - 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 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."); } + struct yx_uint16 size = win_meta->active->frame.size; + if (change == '-') size.y--; + else if (change == '+') size.y++; + else if (change == '_') size.x--; + else if (change == '*') size.x++; + resize_active_win (win_meta, size); } } 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) { @@ -236,20 +180,24 @@ unsigned char meta_keys(int key, struct World * world, struct WinMeta * win_meta 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'); + map_scroll (world->map, NORTH, win_map->frame.size); else if (key == get_action_key(world->keybindings, "map down")) - map_scroll (world->map, 's'); + map_scroll (world->map, SOUTH, win_map->frame.size); else if (key == get_action_key(world->keybindings, "map right")) - map_scroll (world->map, 'e'); + map_scroll (world->map, EAST, win_map->frame.size); else if (key == get_action_key(world->keybindings, "map left")) - map_scroll (world->map, 'w'); + map_scroll (world->map, WEST, win_map->frame.size); + else if (key == get_action_key(world->keybindings, "map center player")) + map_center_player (world->map, world->player, win_map->frame.size); return 0; } int main (int argc, char *argv[]) { struct World world; - world.interactive = 1; + + // Read in startup options (i.e. replay option and replay start turn). int opt; uint32_t start_turn; + world.interactive = 1; while ((opt = getopt(argc, argv, "s::")) != -1) { switch (opt) { case 's': @@ -261,43 +209,53 @@ int main (int argc, char *argv[]) { default: exit(EXIT_FAILURE); } } + // Initialize log, player, monsters and items. world.log = calloc(1, sizeof(char)); update_log (&world, " "); struct Player player; + player.hitpoints = 5; world.player = &player; - struct Monster monster; - world.monster = &monster; + world.monster = 0; + world.item = 0; + + // For interactive mode, try to load world state from savefile. FILE * file; if (1 == world.interactive && 0 == access("savefile", F_OK)) { file = fopen("savefile", "r"); world.seed = read_uint32_bigendian(file); world.turn = read_uint32_bigendian(file); - player.y = read_uint16_bigendian(file); - player.x = read_uint16_bigendian(file); - monster.y = read_uint16_bigendian(file); - monster.x = read_uint16_bigendian(file); + player.pos.y = read_uint16_bigendian(file) - 1; + player.pos.x = read_uint16_bigendian(file) - 1; + read_map_objects (&world.monster, file, sizeof(struct Monster), read_map_objects_monsterdata); + read_map_objects (&world.item, file, sizeof(struct Item), readwrite_map_objects_dummy); fclose(file); } + + // For non-interactive mode, try to load world state from record file. else { world.turn = 1; if (0 == world.interactive) { file = fopen("record", "r"); world.seed = read_uint32_bigendian(file); } + + // For interactive-mode in newly started world, generate a start seed from the current time. else { file = fopen("record", "w"); world.seed = time(NULL); write_uint32_bigendian(world.seed, file); fclose(file); } } + + // Generate map from seed and, if newly generated world, start positions of actors. rrand(1, world.seed); struct Map map = init_map(); world.map = ↦ if (1 == world.turn) { - for (player.y = player.x = 0; 0 == is_passable(&map, player.y, player.x);) { - player.y = rrand(0, 0) % map.height; - player.x = rrand(0, 0) % map.width; } - for (monster.y = monster.x = 0; 0 == is_passable(&map, monster.y, monster.x);) { - monster.y = rrand(0, 0) % map.height; - monster.x = rrand(0, 0) % map.width; } } + player.pos = find_passable_pos(&map); + unsigned char n_monsters = rrand(0, 0) % 16; + unsigned char n_items = rrand(0, 0) % 48; + build_map_objects (&world.monster, n_monsters, sizeof(struct Monster), build_map_objects_monsterdata, &map); + build_map_objects (&world.item, n_items, sizeof(struct Item), build_map_objects_itemdata, &map); } + // Initialize window system and windows. WINDOW * screen = initscr(); noecho(); curs_set(0); @@ -311,17 +269,18 @@ int main (int argc, char *argv[]) { struct Win win_log = init_win(&win_meta, "Log", &world, draw_log_win); win_keys.frame.size.x = 29; win_map.frame.size.x = win_meta.pad.size.x - win_keys.frame.size.x - win_log.frame.size.x - 2; - win_info.frame.size.y = 1; - win_log.frame.size.y = win_meta.pad.size.y - 3; + win_info.frame.size.y = 2; + win_log.frame.size.y = win_meta.pad.size.y - (2 + win_info.frame.size.y); toggle_window(&win_meta, &win_keys); toggle_window(&win_meta, &win_map); toggle_window(&win_meta, &win_info); toggle_window(&win_meta, &win_log); + // Replay mode. int key; unsigned char quit_called = 0; + unsigned char await_actions = 1; if (0 == world.interactive) { - unsigned char still_reading_file = 1; int action; while (1) { if (start_turn == world.turn) @@ -329,55 +288,59 @@ int main (int argc, char *argv[]) { if (0 == start_turn) { draw_all_wins (&win_meta); key = getch(); } - if (1 == still_reading_file && + if (1 == await_actions && (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; } + await_actions = 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 if (NORTH == action) + move_player(&world, NORTH); + else if (EAST == action) + move_player(&world, EAST); + else if (SOUTH == action) + move_player(&world, SOUTH); + else if (WEST == action) + move_player(&world, WEST); } else quit_called = meta_keys(key, &world, &win_meta, &win_keys, &win_map, &win_info, &win_log); if (1 == quit_called) break; } } + + // Interactive mode. else { uint32_t last_turn = 0; while (1) { if (last_turn != world.turn) { save_game(&world); last_turn = world.turn; } + if (1 == await_actions && 0 == player.hitpoints) + await_actions = 0; draw_all_wins (&win_meta); key = getch(); - 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")) + if (1 == await_actions && key == get_action_key(world.keybindings, "player up")) + move_player(&world, NORTH); + else if (1 == await_actions && key == get_action_key(world.keybindings, "player right")) + move_player(&world, EAST); + else if (1 == await_actions && key == get_action_key(world.keybindings, "player down")) + move_player(&world, SOUTH); + else if (1 == await_actions && key == get_action_key(world.keybindings, "player left")) + move_player(&world, WEST); + else if (1 == await_actions && 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; } } + // Clean up and exit. 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; }