plomlompom.com Git - plomrogue/blob - src/map_objects.c

   1 #include "map_objects.h"
   2 #include <stdlib.h>
   3 #include <stdio.h>
   4 #include "yx_uint16.h"
   5 #include "readwrite.h"
   6 #include "misc.h"
   7 #include "map.h"
   8 #include "main.h"
   9
  10 static struct MapObj * get_next_map_obj (void *, char *, size_t, struct MapObj *);
  11
  12 extern void readwrite_map_objects_dummy (void * dummy, FILE * file) {
  13 // Dummy function for calls of (write|read)_map_objects on map objects without specific attributes.
  14   ; }
  15
  16 extern void write_map_objects_monsterdata (void * start, FILE * file) {
  17 // Write to file data specific to map objects of type monster.
  18   struct Monster * m = (struct Monster *) start;
  19   fputc(m->hitpoints, file); }
  20
  21 extern void write_map_objects (void * start, FILE * file, void (* w_typedata) (void *, FILE *) ) {
  22 // Write into file the map object chain starting at start, use write_type() for object-type specific data.
  23   struct MapObj * map_obj;
  24   for (map_obj = start; map_obj != 0; map_obj = map_obj->next) {
  25     write_uint16_bigendian(map_obj->pos.y + 1, file);
  26     write_uint16_bigendian(map_obj->pos.x + 1, file);
  27     fputc(map_obj->type, file);
  28     w_typedata (map_obj, file); }
  29   write_uint16_bigendian(0, file); }
  30
  31 extern void read_map_objects_monsterdata (void * start, FILE * file) {
  32 // Read from file data speciifc to map objects of type monster.
  33   struct Monster * m = (struct Monster *) start;
  34   m->hitpoints = fgetc(file); }
  35
  36 static struct MapObj * get_next_map_obj (void * start, char * first, size_t size, struct MapObj * map_obj) {
  37 // Return pointer to map object of "size". If first in chain ("first" pointing to !0), point "start" to it.
  38   if (* first) {
  39     struct MapObj * * z = start;
  40     map_obj = malloc(size);
  41     * z = map_obj;
  42     * first = 0; }
  43   else {
  44     map_obj->next = malloc(size);
  45     map_obj = map_obj->next; }
  46   return map_obj; }
  47
  48 extern void read_map_objects (void * start, FILE * file, size_t size, void (* r_typedata) (void *, FILE *) ) {
  49 // Read from file chain of map objects starting at start, use r_typedata() for object-type specific data.
  50   struct MapObj * map_obj;
  51   uint16_t test;
  52   char first = 1;
  53   while (1) {
  54     test = read_uint16_bigendian(file);
  55     if (0 == test)
  56       break;
  57     map_obj = get_next_map_obj(start, &first, size, map_obj);
  58     map_obj->pos.y = test - 1;
  59     map_obj->pos.x = read_uint16_bigendian(file) - 1;
  60     map_obj->type = fgetc(file);
  61     r_typedata (map_obj, file); }
  62   if (!first)
  63     map_obj->next = 0; }
  64
  65 extern void build_map_objects_monsterdata (struct MapObjDef * map_obj_def, void * start) {
  66 // Build data specific to map objects of type monster.
  67   struct Monster * m = (struct Monster *) start;
  68   m->map_obj.type = map_obj_def->id;
  69   struct MonsterDef * md = (struct MonsterDef *) map_obj_def;
  70   m->hitpoints = md->hitpoints_start; }
  71
  72 extern void build_map_objects_itemdata (struct MapObjDef * map_obj_def, void * start) {
  73 // Build data speciifc to map objects of type data.
  74   struct Item * i = (struct Item *) start;
  75   i->map_obj.type = map_obj_def->id; }
  76
  77 extern void * build_map_objects (struct World * world, void * start, char def_id, unsigned char n,
  78                                  size_t size, void (* b_typedata) (struct MapObjDef *, void *)) {
  79 // Build chain of n map objects starting at start, use f() for object-specific data.
  80   unsigned char i;
  81   struct MapObj * mo;
  82   char first = 1;
  83   struct MapObjDef * mod = get_map_obj_def (world, def_id);
  84   for (i = 0; i < n; i++) {
  85     mo = get_next_map_obj(start, &first, size, mo);
  86     mo->pos = find_passable_pos(world->map);
  87     b_typedata (mod, mo); }
  88   if (!first)
  89     mo->next = 0;
  90   return &mo->next; }
  91
  92 extern struct MapObjDef * get_map_obj_def (struct World * world, char def_id) {
  93 // Get pointer to the map object definition with id "def_id".
  94   struct MapObjDef * d = NULL;
  95   for (d = (struct MapObjDef *) world->monster_def; d->id != def_id && 0 != d->next; d = d->next);
  96   if (d->id != def_id)
  97     for (d = (struct MapObjDef *) world->item_def; d->id != def_id && 0 != d->next; d = d->next);
  98   return d; }
  99
 100 extern struct yx_uint16 find_passable_pos (struct Map * map) {
 101 // Return a random passable position on map.
 102   struct yx_uint16 pos;
 103   for (pos.y = pos.x = 0; 0 == is_passable(map, pos);) {
 104       pos.y = rrand(0, 0) % map->size.y;
 105       pos.x = rrand(0, 0) % map->size.x; }
 106   return pos; }
 107
 108 extern char is_passable (struct Map * map, struct yx_uint16 pos) {
 109 // Check if coordinate on (or beyond) map is accessible to actor movement.
 110   char passable = 0;
 111   if (0 <= pos.x && pos.x < map->size.x && 0 <= pos.y && pos.y < map->size.y)
 112     if ('.' == map->cells[pos.y * map->size.x + pos.x])
 113       passable = 1;
 114   return passable; }
 115
 116 extern void move_monster (struct World * world, struct Monster * monster) {
 117 // Move monster in random direction, trigger fighting when hindered by player/monster.
 118   char d = rrand(0, 0) % 5;
 119   struct yx_uint16 t = mv_yx_in_dir (d, monster->map_obj.pos);
 120   char * msg = malloc(100);
 121   struct MapObjDef * mod = get_map_obj_def (world, monster->map_obj.type);
 122   char * desc = mod->desc;
 123   char * desc_other;
 124   if (yx_uint16_cmp (t, world->player->pos)) {
 125     sprintf(msg, "\nThe %s hits you.", desc);
 126     update_log (world, msg);
 127     world->player->hitpoints--;
 128     if (0 == world->player->hitpoints)
 129       update_log (world, "\nYou are dead.");
 130     return; }
 131   struct Monster * other_monster;
 132   for (other_monster = world->monster; other_monster != 0; other_monster = other_monster->map_obj.next) {
 133     if (other_monster == monster)
 134       continue;
 135     if (yx_uint16_cmp (t, other_monster->map_obj.pos)) {
 136       mod = get_map_obj_def (world, monster->map_obj.type);
 137       desc_other = mod->desc;
 138       sprintf(msg, "\n%s bumps into %s.", desc, desc_other);
 139       update_log (world, msg);
 140       return; } }
 141   free (msg);
 142   if (is_passable(world->map, t))
 143     monster->map_obj.pos = t; }
 144
 145 extern void move_player (struct World * world, char d) {
 146 // Move player in direction d, update log and turn over to the enemy.
 147   struct yx_uint16 t = mv_yx_in_dir (d, world->player->pos);
 148   struct Monster * monster;
 149   struct MapObjDef * mod;
 150   char * msg = calloc(100, sizeof(char));
 151   char * desc;
 152   for (monster = world->monster; monster != 0; monster = monster->map_obj.next)
 153     if (yx_uint16_cmp (t, monster->map_obj.pos)) {
 154       mod = get_map_obj_def (world, monster->map_obj.type);
 155       desc = mod->desc;
 156       sprintf (msg, "\nYou hit the %s.", desc);
 157       update_log (world, msg);
 158       monster->hitpoints--;
 159       if (0 == monster->hitpoints) {
 160         sprintf (msg, "\nYou kill the %s.", desc);
 161         update_log (world, msg);
 162         if (world->monster == monster)
 163           world->monster = world->monster->map_obj.next;
 164         else {
 165           struct Monster * m_prev;
 166           for (m_prev = world->monster; m_prev->map_obj.next != monster; m_prev = m_prev->map_obj.next);
 167           m_prev->map_obj.next = monster->map_obj.next; }
 168         free(monster); }
 169       turn_over (world, d);
 170       return; }
 171   char * msg_content = "You fail to move";
 172   char * dir;
 173   if      (NORTH == d) dir = "north";
 174   else if (EAST  == d) dir = "east" ;
 175   else if (SOUTH == d) dir = "south";
 176   else if (WEST  == d) dir = "west" ;
 177   if (is_passable(world->map, t)) {
 178     msg_content = "You move";
 179     world->player->pos = t; }
 180   sprintf(msg, "\n%s %s.", msg_content, dir);
 181   update_log (world, msg);
 182   free(msg);
 183   turn_over (world, d); }
 184
 185 extern void player_wait (struct World * world) {
 186 // Make player wait one turn.
 187   update_log (world, "\nYou wait.");
 188   turn_over (world, 0); }