X-Git-Url: https://plomlompom.com/repos/?a=blobdiff_plain;f=src%2Froguelike.c;h=a4db13ca22db478f5c9dccda4a28012492e8164f;hb=714bf970109b33005e0ab3e588d818460ccdc304;hp=37e90c96ac8b766849de77895d1d4e91b3807cba;hpb=bbea8aaa3fa48f00ea46a7d8d79138e02929881e;p=plomrogue

diff --git a/src/roguelike.c b/src/roguelike.c
index 37e90c9..a4db13c 100644
--- a/src/roguelike.c
+++ b/src/roguelike.c
@@ -9,7 +9,7 @@
 #include "draw_wins.h"
 #include "keybindings.h"
 #include "readwrite.h"
-#include "actors.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.
@@ -56,9 +56,8 @@ struct Map init_map () {
     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++) {
+  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;
@@ -66,16 +65,31 @@ struct Map init_map () {
         (   (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] = '.'; }
+         || (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) {
+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 (SOUTH == dir)                      map->offset.y++;
-  else if (WEST  == dir && map->offset.x > 0) map->offset.x--;
-  else if (EAST  == dir)                      map->offset.x++; }
+  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.
@@ -86,7 +100,7 @@ void turn_over (struct World * world, char action) {
   world->turn++;
   rrand(1, world->seed * world->turn);
   struct Monster * monster;
-  for (monster = world->monster; monster != 0; monster = monster->next)
+  for (monster = world->monster; monster != 0; monster = monster->cmo.next)
     move_monster(world, monster); }
 
 void save_game(struct World * world) {
@@ -94,20 +108,10 @@ void save_game(struct World * world) {
   FILE * file = fopen("savefile", "w");
   write_uint32_bigendian(world->seed, file);
   write_uint32_bigendian(world->turn, file);
-  write_uint16_bigendian(world->player->pos.y, file);
-  write_uint16_bigendian(world->player->pos.x, file);
-  write_uint16_bigendian(world->monster->pos.y, file);
-  write_uint16_bigendian(world->monster->pos.x, file);
-  write_uint16_bigendian(world->monster->next->pos.y, file);
-  write_uint16_bigendian(world->monster->next->pos.x, file);
-  write_uint16_bigendian(world->monster->next->next->pos.y, file);
-  write_uint16_bigendian(world->monster->next->next->pos.x, file);
-  write_uint16_bigendian(world->item->pos.y, file);
-  write_uint16_bigendian(world->item->pos.x, file);
-  write_uint16_bigendian(world->item->next->pos.y, file);
-  write_uint16_bigendian(world->item->next->pos.x, file);
-  write_uint16_bigendian(world->item->next->next->pos.y, file);
-  write_uint16_bigendian(world->item->next->next->pos.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) {
@@ -176,13 +180,15 @@ 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, NORTH);
+    map_scroll (world->map, NORTH, win_map->frame.size);
   else if (key == get_action_key(world->keybindings, "map down"))
-    map_scroll (world->map, SOUTH);
+    map_scroll (world->map, SOUTH, win_map->frame.size);
   else if (key == get_action_key(world->keybindings, "map right"))
-    map_scroll (world->map, EAST);
+    map_scroll (world->map, EAST, win_map->frame.size);
   else if (key == get_action_key(world->keybindings, "map left"))
-    map_scroll (world->map, WEST);
+    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[]) {
@@ -207,27 +213,10 @@ int main (int argc, char *argv[]) {
   world.log = calloc(1, sizeof(char));
   update_log (&world, " ");
   struct Player player;
+  player.hitpoints = 5;
   world.player = &player;
-  struct Monster monster1;
-  struct Monster monster2;
-  struct Monster monster3;
-  world.monster = &monster1;
-  monster1.next = &monster2;
-  monster2.next = &monster3;
-  monster3.next = 0;
-  monster1.name = 'A';
-  monster2.name = 'B';
-  monster3.name = 'C';
-  struct Item item1;
-  struct Item item2;
-  struct Item item3;
-  world.item = &item1;
-  item1.next = &item2;
-  item2.next = &item3;
-  item3.next = 0;
-  item1.name = '&';
-  item2.name = '%';
-  item3.name = '#';
+  world.monster = 0;
+  world.item = 0;
 
   // For interactive mode, try to load world state from savefile.
   FILE * file;
@@ -235,23 +224,13 @@ int main (int argc, char *argv[]) {
     file = fopen("savefile", "r");
     world.seed = read_uint32_bigendian(file);
     world.turn = read_uint32_bigendian(file);
-    player.pos.y = read_uint16_bigendian(file);
-    player.pos.x = read_uint16_bigendian(file);
-    monster1.pos.y = read_uint16_bigendian(file);
-    monster1.pos.x = read_uint16_bigendian(file);
-    monster2.pos.y = read_uint16_bigendian(file);
-    monster2.pos.x = read_uint16_bigendian(file);
-    monster3.pos.y = read_uint16_bigendian(file);
-    monster3.pos.x = read_uint16_bigendian(file);
-    item1.pos.y = read_uint16_bigendian(file);
-    item1.pos.x = read_uint16_bigendian(file);
-    item2.pos.y = read_uint16_bigendian(file);
-    item2.pos.x = read_uint16_bigendian(file);
-    item3.pos.y = read_uint16_bigendian(file);
-    item3.pos.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 frecord file.
+  // For non-interactive mode, try to load world state from record file.
   else {
     world.turn = 1;
     if (0 == world.interactive) {
@@ -270,19 +249,11 @@ int main (int argc, char *argv[]) {
   struct Map map = init_map();
   world.map = &map;
   if (1 == world.turn) {
-    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; }
-    struct Item * item;
-    for (item = world.item; item != 0; 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; }
-    struct Monster * monster;
-    for (monster = world.monster; monster != 0; 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; } }
+    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();
@@ -298,8 +269,8 @@ 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);
@@ -308,8 +279,8 @@ int main (int argc, char *argv[]) {
   // 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)
@@ -317,12 +288,12 @@ 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 (NORTH == action)
@@ -345,17 +316,19 @@ int main (int argc, char *argv[]) {
       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 up"))
+      if      (1 == await_actions && key == get_action_key(world.keybindings, "player up"))
         move_player(&world, NORTH);
-      else if (key == get_action_key(world.keybindings, "player right"))
+      else if (1 == await_actions && key == get_action_key(world.keybindings, "player right"))
         move_player(&world, EAST);
-      else if (key == get_action_key(world.keybindings, "player down"))
+      else if (1 == await_actions && key == get_action_key(world.keybindings, "player down"))
         move_player(&world, SOUTH);
-      else if (key == get_action_key(world.keybindings, "player left"))
+      else if (1 == await_actions && key == get_action_key(world.keybindings, "player left"))
         move_player(&world, WEST);
-      else if (key == get_action_key(world.keybindings, "wait / next turn"))
+      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);