X-Git-Url: https://plomlompom.com/repos/?a=blobdiff_plain;ds=sidebyside;f=src%2Froguelike.c;h=162740d696836317214df2a1d4b1f3b1001064b3;hb=d46d650d78b1e9830934d912998f17fae7ac592c;hp=0d1e96b60966338f4b5e7bba283cd4e64d49334d;hpb=d7c46fb1de25edd8782fbc7642be71e5e54deab2;p=plomrogue

diff --git a/src/roguelike.c b/src/roguelike.c
index 0d1e96b..162740d 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.
@@ -20,14 +20,25 @@ uint16_t rrand(char use_seed, uint32_t new_seed) {
   return (seed / 65536); }                         // Ignore least significant 16 bits (they are less random).
 
 void update_log (struct World * world, char * text) {
-// Update log with new text to be appended.
+// 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);
-  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);
+  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; }
 
@@ -45,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;
@@ -55,8 +65,10 @@ 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) {
@@ -75,7 +87,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) {
@@ -83,14 +95,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->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) {
@@ -186,21 +194,13 @@ int main (int argc, char *argv[]) {
       default:
         exit(EXIT_FAILURE); } }
 
-  // Initialize log, player and monsters.
+  // Initialize log, player, monsters and items.
   world.log = calloc(1, sizeof(char));
   update_log (&world, " ");
   struct Player player;
   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';
+  world.monster = 0;
+  world.item = 0;
 
   // For interactive mode, try to load world state from savefile.
   FILE * file;
@@ -208,17 +208,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);
+    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) {
@@ -237,14 +233,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.y, player.pos.x);) {
-      player.pos.y = rrand(0, 0) % map.size.y;
-      player.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.y, monster->pos.x);) {
-        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();