X-Git-Url: https://plomlompom.com/repos/?a=blobdiff_plain;f=src%2Fmap_objects.c;h=d114c5b74cfe4dcfce87c96cb4de1aca96d8a01b;hb=350ef2e2d17e8122e2991466f76a9a083a6303e7;hp=7c13ed21c592717a5f1cccd4b30fb423a0dd1898;hpb=d165f8ae619c78fd1ef98a9ba2abdaeeceff853e;p=plomrogue

diff --git a/src/map_objects.c b/src/map_objects.c
index 7c13ed2..d114c5b 100644
--- a/src/map_objects.c
+++ b/src/map_objects.c
@@ -1,188 +1,303 @@
+/* map_objects.c */
+
 #include "map_objects.h"
-#include <stdlib.h>
-#include <stdio.h>
-#include "yx_uint16.h"
-#include "readwrite.h"
-#include "misc.h"
-#include "map.h"
-#include "main.h"
-
-static struct MapObj * get_next_map_obj (void *, char *, size_t, struct MapObj *);
-
-extern void readwrite_map_objects_dummy (void * dummy, FILE * file) {
-// Dummy function for calls of (write|read)_map_objects on map objects without specific attributes.
-  ; }
-
-extern void write_map_objects_monsterdata (void * start, FILE * file) {
-// Write to file data specific to map objects of type monster.
-  struct Monster * m = (struct Monster *) start;
-  fputc(m->hitpoints, file); }
-
-extern void write_map_objects (void * start, FILE * file, void (* w_typedata) (void *, FILE *) ) {
-// Write into file the map object chain starting at start, use write_type() for object-type specific data.
-  struct MapObj * map_obj;
-  for (map_obj = start; map_obj != 0; map_obj = map_obj->next) {
-    write_uint16_bigendian(map_obj->pos.y + 1, file);
-    write_uint16_bigendian(map_obj->pos.x + 1, file);
-    fputc(map_obj->type, file);
-    w_typedata (map_obj, file); }
-  write_uint16_bigendian(0, file); }
-
-extern void read_map_objects_monsterdata (void * start, FILE * file) {
-// Read from file data speciifc to map objects of type monster.
-  struct Monster * m = (struct Monster *) start;
-  m->hitpoints = fgetc(file); }
-
-static struct MapObj * get_next_map_obj (void * start, char * first, size_t size, struct MapObj * map_obj) {
-// Return pointer to map object of "size". If first in chain ("first" pointing to !0), point "start" to it.
-  if (* first) {
-    struct MapObj * * z = start;
-    map_obj = malloc(size);
-    * z = map_obj;
-    * first = 0; }
-  else {
-    map_obj->next = malloc(size);
-    map_obj = map_obj->next; }
-  return map_obj; }
-
-extern void read_map_objects (void * start, FILE * file, size_t size, void (* r_typedata) (void *, FILE *) ) {
-// Read from file chain of map objects starting at start, use r_typedata() for object-type specific data.
-  struct MapObj * map_obj;
-  uint16_t test;
-  char first = 1;
-  while (1) {
-    test = read_uint16_bigendian(file);
-    if (0 == test)
-      break;
-    map_obj = get_next_map_obj(start, &first, size, map_obj);
-    map_obj->pos.y = test - 1;
-    map_obj->pos.x = read_uint16_bigendian(file) - 1;
-    map_obj->type = fgetc(file);
-    r_typedata (map_obj, file); }
-  if (!first)
-    map_obj->next = 0; }
-
-extern void build_map_objects_monsterdata (struct MapObjDef * map_obj_def, void * start) {
-// Build data specific to map objects of type monster.
-  struct Monster * m = (struct Monster *) start;
-  m->map_obj.type = map_obj_def->id;
-  struct MonsterDef * md = (struct MonsterDef *) map_obj_def;
-  m->hitpoints = md->hitpoints_start; }
-
-extern void build_map_objects_itemdata (struct MapObjDef * map_obj_def, void * start) {
-// Build data speciifc to map objects of type data.
-  struct Item * i = (struct Item *) start;
-  i->map_obj.type = map_obj_def->id; }
-
-extern void * build_map_objects (struct World * world, void * start, char def_id, unsigned char n,
-                                 size_t size, void (* b_typedata) (struct MapObjDef *, void *)) {
-// Build chain of n map objects starting at start, use f() for object-specific data.
-  unsigned char i;
-  struct MapObj * mo;
-  char first = 1;
-  struct MapObjDef * mod = get_map_obj_def (world, def_id);
-  for (i = 0; i < n; i++) {
-    mo = get_next_map_obj(start, &first, size, mo);
-    mo->pos = find_passable_pos(world->map);
-    b_typedata (mod, mo); }
-  if (!first)
-    mo->next = 0;
-  return &mo->next; }
-
-extern struct MapObjDef * get_map_obj_def (struct World * world, char def_id) {
-// Get pointer to the map object definition with id "def_id".
-  struct MapObjDef * d = NULL;
-  for (d = (struct MapObjDef *) world->monster_def; d->id != def_id && 0 != d->next; d = d->next);
-  if (d->id != def_id)
-    for (d = (struct MapObjDef *) world->item_def; d->id != def_id && 0 != d->next; d = d->next);
-  return d; }
-
-extern struct yx_uint16 find_passable_pos (struct Map * map) {
-// Return a random passable position on map.
-  struct yx_uint16 pos;
-  for (pos.y = pos.x = 0; 0 == is_passable(map, pos);) {
-      pos.y = rrand(0, 0) % map->size.y;
-      pos.x = rrand(0, 0) % map->size.x; }
-  return pos; }
-
-extern char is_passable (struct Map * map, struct yx_uint16 pos) {
-// Check if coordinate on (or beyond) map is accessible to actor movement.
-  char passable = 0;
-  if (0 <= pos.x && pos.x < map->size.x && 0 <= pos.y && pos.y < map->size.y)
-    if ('.' == map->cells[pos.y * map->size.x + pos.x])
-      passable = 1;
-  return passable; }
-
-extern void move_monster (struct World * world, struct Monster * monster) {
-// Move monster in random direction, trigger fighting when hindered by player/monster.
-  char d = rrand(0, 0) % 5;
-  struct yx_uint16 t = mv_yx_in_dir (d, monster->map_obj.pos);
-  char * msg = malloc(100);
-  struct MapObjDef * mod = get_map_obj_def (world, monster->map_obj.type);
-  char * desc = mod->desc;
-  char * desc_other;
-  if (yx_uint16_cmp (t, world->player->pos)) {
-    sprintf(msg, "\nThe %s hits you.", desc);
-    update_log (world, msg);
-    world->player->hitpoints--;
-    if (0 == world->player->hitpoints)
-      update_log (world, "\nYou are dead.");
-    return; }
-  struct Monster * other_monster;
-  for (other_monster = world->monster; other_monster != 0; other_monster = other_monster->map_obj.next) {
-    if (other_monster == monster)
-      continue;
-    if (yx_uint16_cmp (t, other_monster->map_obj.pos)) {
-      mod = get_map_obj_def (world, monster->map_obj.type);
-      desc_other = mod->desc;
-      sprintf(msg, "\n%s bumps into %s.", desc, desc_other);
-      update_log (world, msg);
-      return; } }
-  free (msg);
-  if (is_passable(world->map, t))
-    monster->map_obj.pos = t; }
-
-extern void move_player (struct World * world, char d) {
-// Move player in direction d, update log and turn over to the enemy.
-  struct yx_uint16 t = mv_yx_in_dir (d, world->player->pos);
-  struct Monster * monster;
-  struct MapObjDef * mod;
-  char * msg = calloc(100, sizeof(char));
-  char * desc;
-  for (monster = world->monster; monster != 0; monster = monster->map_obj.next)
-    if (yx_uint16_cmp (t, monster->map_obj.pos)) {
-      mod = get_map_obj_def (world, monster->map_obj.type);
-      desc = mod->desc;
-      sprintf (msg, "\nYou hit the %s.", desc);
-      update_log (world, msg);
-      monster->hitpoints--;
-      if (0 == monster->hitpoints) {
-        sprintf (msg, "\nYou kill the %s.", desc);
-        update_log (world, msg);
-        if (world->monster == monster)
-          world->monster = world->monster->map_obj.next;
-        else {
-          struct Monster * m_prev;
-          for (m_prev = world->monster; m_prev->map_obj.next != monster; m_prev = m_prev->map_obj.next);
-          m_prev->map_obj.next = monster->map_obj.next; }
-        free(monster); }
-      turn_over (world, d);
-      return; }
-  char * msg_content = "You fail to move";
-  char * dir;
-  if      (NORTH == d) dir = "north";
-  else if (EAST  == d) dir = "east" ;
-  else if (SOUTH == d) dir = "south";
-  else if (WEST  == d) dir = "west" ;
-  if (is_passable(world->map, t)) {
-    msg_content = "You move";
-    world->player->pos = t; }
-  sprintf(msg, "\n%s %s.", msg_content, dir);
-  update_log (world, msg);
-  free(msg);
-  turn_over (world, d); }
-
-extern void player_wait (struct World * world) {
-// Make player wait one turn.
-  update_log (world, "\nYou wait.");
-  turn_over (world, 0); }
+#include <stdlib.h> /* for free(), atoi() */
+#include <stdint.h> /* for uint8_t */
+#include <stdio.h> /* for FILE typedef */
+#include <string.h> /* for strchr(), strlen(), memcpy(), strtok() */
+#include "readwrite.h" /* for get_linemax(), try_fopen(), try_fclose()
+                        * [read/write]_uint[8/16/23][_bigendian]()
+                        */
+#include "misc.h" /* for try_malloc(), find_passable_pos() */
+#include "main.h" /* for world global */
+#include "rexit.h" /* for err_exit() */
+#include "yx_uint16.h" /* for yx_uint16 struct, yx_uint16_cmp() */
+
+
+
+/* Write representation of "mo" and all of the map objects it owns to "file". */
+static void write_map_object(FILE * file, struct MapObj * mo);
+
+/* Return pointer to map object of "id" in chain starting at "ptr". */
+static struct MapObj * get_map_object(struct MapObj * ptr, uint8_t id);
+
+
+
+static void write_map_object(FILE * file, struct MapObj * mo)
+{
+    char * f_name = "write_map_object()";
+    struct MapObj * mo_ptr = mo->owns;
+    uint8_t i = 0;
+    for (; NULL != mo_ptr; mo_ptr = mo_ptr->next, i++);
+    uint8_t size = 3+1 + 3+1 + 3+1 + 5+1 + 5 + ((1+3)*i) + 1 + 1;
+    char line[size];
+    sprintf(line, "%d %d %d %d %d",
+                  mo->id, mo->type, mo->lifepoints, mo->pos.y, mo->pos.x);
+    for (mo_ptr = mo->owns; NULL != mo_ptr; mo_ptr = mo_ptr->next)
+    {
+        sprintf(line + strlen(line), " %d", mo_ptr->id);
+    }
+    line[strlen(line) + 1] = '\0';
+    line[strlen(line)] = '\n';
+    try_fwrite(line, strlen(line), 1, file, f_name);
+    for (mo_ptr = mo->owns; NULL != mo_ptr; mo_ptr = mo_ptr->next)
+    {
+        write_map_object(file, mo_ptr);
+    }
+}
+
+
+
+static struct MapObj * get_map_object(struct MapObj * ptr, uint8_t id)
+{
+    while (1)
+    {
+        if (NULL == ptr || id == ptr->id)
+        {
+            return ptr;
+        }
+        struct MapObj * owned_object = get_map_object(ptr->owns, id);
+        if (NULL != owned_object)
+        {
+            return ptr;
+        }
+        ptr = ptr->next;
+    }
+}
+
+
+
+extern void init_map_object_defs(char * filename)
+{
+    char * f_name = "init_map_object_defs()";
+    FILE * file = try_fopen(filename, "r", f_name);
+    uint16_t linemax = get_linemax(file, f_name);
+    struct MapObjDef ** last_mod_ptr_ptr = &world.map_obj_defs;
+    char * delim = " ";
+    char line[linemax + 1];
+    while (try_fgets(line, linemax + 1, file, f_name))
+    {
+        struct MapObjDef * mod;
+        mod = try_malloc(sizeof(struct MapObjDef), f_name);
+        mod->next = NULL;
+        mod->id = atoi(strtok(line, delim));
+        mod->corpse_id = atoi(strtok(NULL, delim));
+        mod->char_on_map = * strtok(NULL, delim);
+        mod->lifepoints = atoi(strtok(NULL, delim));
+        char * name = strtok(NULL, "\n");
+        mod->name = try_malloc(strlen(name) + 1, f_name);
+        memcpy(mod->name, name, strlen(name) + 1);
+        * last_mod_ptr_ptr = mod;
+        last_mod_ptr_ptr = &mod->next;
+    }
+    try_fclose(file, f_name);
+}
+
+
+
+extern void free_map_object_defs(struct MapObjDef * mod_start)
+{
+    if (NULL == mod_start)
+    {
+        return;
+    }
+    free_map_object_defs(mod_start->next);
+    free(mod_start->name);
+    free(mod_start);
+}
+
+
+
+extern void write_map_objects(FILE * file)
+{
+    struct MapObj * mo = world.map_objs;
+    while (NULL != mo)
+    {
+        write_map_object(file, mo);
+        mo = mo->next;
+    }
+}
+
+
+
+extern void read_map_objects(FILE * file, char * line, int linemax)
+{
+    char * f_name = "read_map_objects()";
+    struct MapObj ** mo_ptr_ptr = &world.map_objs;
+    char * delim = " ";
+    struct MapObj * mo;
+    fpos_t pos;
+    exit_err(-1 == fgetpos(file, &pos), f_name);
+    while (try_fgets(line, linemax + 1, file, f_name))
+    {
+        mo = malloc(sizeof(struct MapObj));
+        mo->next       = NULL;
+        mo->id         = atoi(strtok(line, delim));
+        mo->type       = atoi(strtok(NULL, delim));
+        mo->lifepoints = atoi(strtok(NULL, delim));
+        mo->pos.y      = atoi(strtok(NULL, delim));
+        mo->pos.x      = atoi(strtok(NULL, delim));
+        mo->owns       = NULL;
+        if (mo->id > world.map_obj_count)
+        {
+            world.map_obj_count = mo->id;
+        }
+        * mo_ptr_ptr = mo;
+        mo_ptr_ptr = &mo->next;
+    }
+    exit_err(-1 == fsetpos(file, &pos), f_name);
+    while (try_fgets(line, linemax + 1, file, f_name))
+    {
+        uint8_t id = atoi(strtok(line, delim));
+        strtok(NULL, delim);
+        strtok(NULL, delim);
+        strtok(NULL, delim);
+        strtok(NULL, delim);
+        char * owned = strtok(NULL, "\n");
+        if (NULL != owned)
+        {
+            mo = get_map_object(world.map_objs, id);
+            char * owned_id = "";
+            owned_id = strtok(owned, delim);
+            while (NULL != owned_id)
+            {
+                own_map_object(&mo->owns, &world.map_objs,
+                               (uint8_t) atoi(owned_id));
+                owned_id = strtok(NULL, delim);
+            }
+        }
+    }
+}
+
+
+
+extern void add_map_object(uint8_t type)
+{
+    char * f_name = "add_map_object()";
+    struct MapObjDef * mod = get_map_object_def(type);
+    struct MapObj * mo = try_malloc(sizeof(struct MapObj), f_name);
+    mo->id = world.map_obj_count;
+    world.map_obj_count++;
+    mo->type = mod->id;
+    mo->lifepoints = mod->lifepoints;
+    while (1)
+    {
+        struct yx_uint16 pos = find_passable_pos(world.map);
+        struct MapObj * mo_ptr;
+        uint8_t clear = 1;
+        for (mo_ptr = world.map_objs; mo_ptr != NULL; mo_ptr = mo_ptr->next)
+        {
+            if (yx_uint16_cmp(&pos, &mo_ptr->pos) && 0 != mo_ptr->lifepoints)
+            {
+                clear = 0;
+                break;
+            }
+        }
+        if (1 == clear)
+        {
+            mo->pos = pos;
+            break;
+        }
+    }
+    mo->owns = NULL;
+    mo->next = NULL;
+    struct MapObj ** last_ptr_ptr = &world.map_objs;
+    struct MapObj * mo_ptr;
+    while (NULL != * last_ptr_ptr)
+    {
+        mo_ptr = * last_ptr_ptr;
+        last_ptr_ptr = & mo_ptr->next;
+    }
+    * last_ptr_ptr = mo;
+}
+
+
+
+extern void add_map_objects(uint8_t type, uint8_t n)
+{
+    uint8_t i;
+    for (i = 0; i < n; i++)
+    {
+        add_map_object(type);
+    }
+}
+
+
+
+extern void free_map_objects(struct MapObj * mo_start)
+{
+    if (NULL == mo_start)
+    {
+        return;
+    }
+    free_map_objects(mo_start->owns);
+    free_map_objects(mo_start->next);
+    free(mo_start);
+}
+
+
+
+extern void own_map_object(struct MapObj ** target, struct MapObj ** source,
+                           uint8_t id)
+{
+    struct MapObj * mo;
+    if (id == (*source)->id)
+    {
+        mo = * source;
+        * source = mo->next;
+    }
+    else
+    {
+        struct MapObj * penult = * source;
+        while (1)
+        {
+            if (id == penult->next->id)
+            {
+                break;
+            }
+            penult = penult->next;
+        }
+        mo = penult->next;
+        penult->next = mo->next;
+    }
+    struct MapObj ** last_ptr_ptr = target;
+    struct MapObj * mo_ptr;
+    while (NULL != * last_ptr_ptr)
+    {
+        mo_ptr = * last_ptr_ptr;
+        last_ptr_ptr = & mo_ptr->next;
+    }
+    * last_ptr_ptr = mo;
+    mo->next = NULL;
+}
+
+
+
+extern struct MapObj * get_player()
+{
+    return get_map_object(world.map_objs, 0);
+}
+
+
+
+extern struct MapObjDef * get_map_object_def(uint8_t id)
+{
+    struct MapObjDef * mod = world.map_obj_defs;
+    while (id != mod->id)
+    {
+        mod = mod->next;
+    }
+    return mod;
+}
+
+
+
+extern void set_object_position(struct MapObj * mo, struct yx_uint16 pos)
+{
+    mo->pos = pos;
+    struct MapObj * owned = mo->owns;
+    for (; owned != NULL; owned = owned->next)
+    {
+        set_object_position(owned, pos);
+    }
+}