#include <stdint.h>
#include <ncurses.h>
#include <string.h>
+#include <time.h>
+#include <unistd.h>
#include "windows.h"
#include "draw_wins.h"
#include "roguelike.h"
#include "keybindings.h"
-uint16_t rrand() {
+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 = 0;
+ 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_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 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)
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);
for (y = 0; y < map.height; y++)
for (x = 0; x < map.width; x++) {
terrain = '.';
- ran = rrand();
+ 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)
void next_turn (struct World * world) {
// Increment turn and move enemy.
world->turn++;
- char d = rrand() % 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)
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++; }
next_turn (world);
update_log (world, "\nYou wait."); }
-void save_map (struct Map * map) {
-// Save map to file "map".
- FILE * file = fopen("map", "w");
- fputc(map->width / CHAR_MAX, file);
- fputc(map->width % CHAR_MAX, file);
- uint16_t y, x;
- for (y = 0; y < map->height; y++)
- for (x = 0; x < map->width; x++)
- fputc(map->cells[y * map->width + x], file);
- fclose(file); }
-
-struct Map load_map () {
-// Load map from file.
- FILE * file = fopen("map", "r");
- struct Map map;
- map.width = (fgetc(file) * CHAR_MAX) + fgetc(file);
- long pos = ftell(file);
- int c = fgetc(file);
- uint32_t i = 0;
- while (EOF != c) {
- i++;
- c = fgetc(file); }
- map.cells = malloc(i * sizeof(char));
- map.height = i / map.width;
- fseek(file, pos, SEEK_SET);
- c = fgetc(file);
- i = 0;
- while (EOF != c) {
- map.cells[i] = (char) c;
- c = fgetc(file);
- i++; }
- fclose(file);
- return map; }
-
-int main () {
+int main (int argc, char *argv[]) {
struct World world;
init_keybindings(&world);
- world.turn = 0;
+
world.log = calloc(1, sizeof(char));
- update_log (&world, "Start!");
- struct Map map = init_map();
- world.map = ↦
+ update_log (&world, " ");
struct Player player;
- player.y = 16;
- player.x = 16;
world.player = &player;
struct Monster monster;
- monster.y = 16;
- monster.x = 80;
world.monster = &monster;
+ if (0 == access("savefile", F_OK))
+ load_game(&world);
+ else {
+ player.y = 8;
+ player.x = 8;
+ monster.y = 55;
+ monster.x = 55;
+ world.seed = time(NULL);
+ world.turn = 1; }
+ rrand(1, world.seed);
+ struct Map map = init_map();
+ world.map = ↦
WINDOW * screen = initscr();
noecho();
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;
+ 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 == get_action_key(world.keybindings, "quit"))
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, "load map"))
- map = load_map();
- else if (key == get_action_key(world.keybindings, "save map"))
- save_map(&map);
else if (key == get_action_key(world.keybindings, "map up"))
map_scroll (&map, 'n');
else if (key == get_action_key(world.keybindings, "map down"))