X-Git-Url: https://plomlompom.com/repos/?a=blobdiff_plain;f=src%2Froguelike.c;h=f20bfe18e1b123ce7cb5d4ef592b59e30923a96c;hb=5dfbb430e0aed478ced7cdc32c1777745a435532;hp=54c62c2fd919e277b492150db8fe6803ffc3873a;hpb=b1f018b25a1cd4a48b197208ae48675f0065eb64;p=plomrogue

diff --git a/src/roguelike.c b/src/roguelike.c
index 54c62c2..f20bfe1 100644
--- a/src/roguelike.c
+++ b/src/roguelike.c
@@ -1,3 +1,4 @@
+#include "roguelike.h"
 #include <stdlib.h>
 #include <stdint.h>
 #include <ncurses.h>
@@ -6,9 +7,9 @@
 #include <unistd.h>
 #include "windows.h"
 #include "draw_wins.h"
-#include "roguelike.h"
 #include "keybindings.h"
 #include "readwrite.h"
+#include "actors.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,142 +19,95 @@ 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.width = 64;
-  map.height = 64;
-  map.offset_x = 0;
-  map.offset_y = 0;
-  uint32_t size = map.width * map.height;
+  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.height; y++)
-    for (x = 0; x < map.width; x++)
-      map.cells[(y * map.width) + x] = '~';
-  map.cells[size / 2 + (map.width / 2)] = '.';
+  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 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;
+    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.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] = '.'; }
+        (   (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])))
+      map.cells[y * map.size.x + x] = '.'; }
   return map; }
 
+void map_scroll (struct Map * map, char dir) {
+// Scroll map into direction dir if possible by changing the offset.
+  if      (NORTH == dir && map->offset.y > 0) map->offset.y--;
+  else if (SOUTH == dir)                      map->offset.y++;
+  else if (WEST  == dir && map->offset.x > 0) map->offset.x--;
+  else if (EAST  == dir)                      map->offset.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->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);
-  fclose(file); }
-
-void record_action (char action) {
-// Append action to game record file.
-  FILE * file = fopen("record", "a");
-  fputc(action, file);
+  write_uint16_bigendian(world->player->pos.y + 1, file);
+  write_uint16_bigendian(world->player->pos.x + 1, file);
+  struct Monster * monster;
+  for (monster = world->monster; monster != 0; monster = monster->next) {
+    write_uint16_bigendian(monster->pos.y + 1, file);
+    write_uint16_bigendian(monster->pos.x + 1, file); }
+  write_uint16_bigendian(0, file);
+  struct Item * item;
+  for (item = world->item; item != 0; item = item->next) {
+    write_uint16_bigendian(item->pos.y + 1, file);
+    write_uint16_bigendian(item->pos.x + 1, file); }
+  write_uint16_bigendian(0, file);
   fclose(file); }
 
-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; }
-
-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); }
-
-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 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."); }
-
 void toggle_window (struct WinMeta * win_meta, struct Win * win) {
 // Toggle display of window win.
   if (0 != win->frame.curses_win)
@@ -171,28 +125,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); } }
-
-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++; }
+    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 +174,22 @@ 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);
   else if (key == get_action_key(world->keybindings, "map down"))
-    map_scroll (world->map, 's');
+    map_scroll (world->map, SOUTH);
   else if (key == get_action_key(world->keybindings, "map right"))
-    map_scroll (world->map, 'e');
+    map_scroll (world->map, EAST);
   else if (key == get_action_key(world->keybindings, "map left"))
-    map_scroll (world->map, 'w');
+    map_scroll (world->map, WEST);
   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 +201,121 @@ 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;
   world.player = &player;
-  struct Monster monster;
-  world.monster = &monster;
+  struct Monster * monster;
+  struct Item * item;
+  uint16_t test;
+  char start;
+
+  // 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;
+    start = 1;
+    world.monster = 0;
+    while (1) {
+      test = read_uint16_bigendian(file);
+      if (0 == test)
+        break;
+      if (start) {
+        monster = malloc(sizeof(struct Monster));
+        world.monster = monster;
+        start = 0; }
+      else {
+        monster->next = malloc(sizeof(struct Monster));
+        monster = monster->next; }
+      monster->name = 'M';
+      monster->pos.y = test - 1;
+      monster->pos.x = read_uint16_bigendian(file) - 1; }
+    if (!start)
+      monster->next = 0;
+    start = 1;
+    world.item = 0;
+    while (1) {
+      test = read_uint16_bigendian(file);
+      if (0 == test)
+        break;
+      if (start) {
+        item = malloc(sizeof(struct Item));
+        world.item = item;
+        start = 0; }
+      else {
+        item->next = malloc(sizeof(struct Item));
+        item = item->next; }
+      item->name = '#';
+      item->pos.y = test - 1;
+      item->pos.x = read_uint16_bigendian(file) - 1; }
+    if (!start)
+      item->next = 0;
     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 = &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; } }
+    for (player.pos.y = player.pos.x = 0; 0 == is_passable(&map, player.pos);) {
+      player.pos.y = rrand(0, 0) % map.size.y;
+      player.pos.x = rrand(0, 0) % map.size.x; }
+    unsigned char n_monsters = rrand(0, 0) % 16;
+    unsigned char n_items    = rrand(0, 0) % 48;
+    unsigned char i;
+    start = 1;
+    world.monster = 0;
+    for (i = 0; i < n_monsters; i++) {
+      if (start) {
+        monster = malloc(sizeof(struct Monster));
+        world.monster = monster;
+        start = 0; }
+      else {
+        monster->next = malloc(sizeof(struct Monster));
+        monster = monster->next; }
+      for (monster->pos.y = monster->pos.x = 0; 0 == is_passable(&map, monster->pos);) {
+        monster->pos.y = rrand(0, 0) % map.size.y;
+        monster->pos.x = rrand(0, 0) % map.size.x; }
+      monster->name = 'M'; }
+    if (!start)
+      monster->next = 0;
+    start = 1;
+    world.item = 0;
+    for (i = 0; i < n_items; i++) {
+      if (start) {
+        item = malloc(sizeof(struct Item));
+        world.item = item;
+        start = 0; }
+      else {
+        item->next = malloc(sizeof(struct Item));
+        item = item->next; }
+      for (item->pos.y = item->pos.x = 0; 0 == is_passable(&map, item->pos);) {
+        item->pos.y = rrand(0, 0) % map.size.y;
+        item->pos.x = rrand(0, 0) % map.size.x; }
+      item->name = '#'; }
+    if (!start)
+      item->next = 0; }
 
+  // Initialize window system and windows.
   WINDOW * screen = initscr();
   noecho();
   curs_set(0);
@@ -318,6 +336,7 @@ int main (int argc, char *argv[]) {
   toggle_window(&win_meta, &win_info);
   toggle_window(&win_meta, &win_log);
 
+  // Replay mode.
   int key;
   unsigned char quit_called = 0;
   if (0 == world.interactive) {
@@ -337,18 +356,20 @@ int main (int argc, char *argv[]) {
           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 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) {
@@ -357,14 +378,14 @@ int main (int argc, char *argv[]) {
         last_turn = world.turn; }
       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');
+      if      (key == get_action_key(world.keybindings, "player up"))
+        move_player(&world, NORTH);
       else if (key == get_action_key(world.keybindings, "player right"))
-        move_player(&world, 'e');
+        move_player(&world, EAST);
+      else if (key == get_action_key(world.keybindings, "player down"))
+        move_player(&world, SOUTH);
       else if (key == get_action_key(world.keybindings, "player left"))
-        move_player(&world, 'w');
+        move_player(&world, WEST);
       else if (key == get_action_key(world.keybindings, "wait / next turn"))
         player_wait (&world);
       else
@@ -372,12 +393,12 @@ int main (int argc, char *argv[]) {
         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; }