X-Git-Url: https://plomlompom.com/repos/feed.xml?a=blobdiff_plain;f=roguelike.c;h=6217fec2713128b4b4987c52f5f34e841da66078;hb=98588def4ac3ab05cb815814de67a44f506ae569;hp=20181befccf6b2de2c62d2a74091c4463cd50e2e;hpb=122747fbbdc061942de2fc2bca901a44a6b4ab61;p=plomrogue diff --git a/roguelike.c b/roguelike.c index 20181be..6217fec 100644 --- a/roguelike.c +++ b/roguelike.c @@ -1,11 +1,81 @@ +#include +#include +#include #include #include -#include +#include +#include #include "windows.h" #include "draw_wins.h" #include "roguelike.h" #include "keybindings.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. + 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). + +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; } + +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); } + +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 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 load_seed(struct World * world) { +// Load seed integer from seed 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 save_seed(struct World * world) { +// Save seed integer to seed 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) @@ -16,8 +86,8 @@ void toggle_window (struct WinMeta * win_meta, struct Win * 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) { - int height = win_meta->active->height; - int width = win_meta->active->width; + uint16_t height = win_meta->active->height; + uint16_t width = win_meta->active->width; if (change == '-') height--; else if (change == '+') @@ -31,17 +101,17 @@ void growshrink_active_window (struct WinMeta * win_meta, char change) { struct Map init_map () { // Initialize map with some experimental start values. struct Map map; - map.width = 96; - map.height = 32; + map.width = 64; + map.height = 64; map.offset_x = 0; map.offset_y = 0; map.cells = malloc(map.width * map.height); - int x, y, ran; + uint16_t x, y, ran; char terrain; for (y = 0; y < map.height; y++) for (x = 0; x < map.width; x++) { terrain = '.'; - ran = rand(); + 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) @@ -64,9 +134,10 @@ void map_scroll (struct Map * map, char dir) { void next_turn (struct World * world) { // Increment turn and move enemy. world->turn++; - char d = rand() % 5; - char ty = world->monster->y; - char tx = world->monster->x; + 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) @@ -84,16 +155,16 @@ void next_turn (struct World * world) { void update_log (struct World * world, char * text) { // Update log with new text to be appended. char * new_text; - int len_old = strlen(world->log); - 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, world->log, len_old); memcpy(new_text + len_old, text, len_new); free(world->log); world->log = new_text; } -char is_passable (struct World * world, int x, int y) { +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) @@ -106,8 +177,8 @@ void move_player (struct World * world, char d) { static char prev = 0; char success = 0; char * dir; - char ty = world->player->y; - char tx = world->player->x; + uint16_t ty = world->player->y; + uint16_t tx = world->player->x; if ('s' == d) { dir = "south"; ty++; } @@ -142,27 +213,33 @@ void move_player (struct World * world, char d) { prev = success * d; next_turn (world); } -void player_wait(struct World * world) { +void player_wait (struct World * world) { // Make player wait one turn. next_turn (world); update_log (world, "\nYou wait."); } -int main () { +int main (int argc, char *argv[]) { struct World world; + struct Player player; + world.player = &player; + struct Monster monster; + world.monster = &monster; + if (0 == access("savefile", F_OK)) + load_seed(&world); + else { + player.y = 8; + player.x = 8; + monster.y = 55; + monster.x = 55; + world.seed = time(NULL); + world.turn = 0; } + rrand(1, world.seed); + init_keybindings(&world); - world.turn = 0; world.log = calloc(1, sizeof(char)); update_log (&world, "Start!"); struct Map map = init_map(); world.map = ↦ - struct Player player; - player.y = 16; - player.x = 16; - world.player = &player; - struct Monster monster; - monster.y = 16; - monster.x = 80; - world.monster = &monster; WINDOW * screen = initscr(); noecho(); @@ -217,6 +294,8 @@ int main () { 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, "save game")) + save_seed(&world); else if (key == get_action_key(world.keybindings, "map up")) map_scroll (&map, 'n'); else if (key == get_action_key(world.keybindings, "map down"))