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 ChainMapObject * get_next_cmo (void *, char *, size_t, struct ChainMapObject *);
  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 tto map objects of type monster.
  18   struct Monster * monster = (struct Monster *) start;
  19   fputc(monster->hitpoints, file); }
  20
  21 extern void write_map_objects (void * start, FILE * file, void (* f) (void *, FILE *) ) {
  22 // Write into file the map object chain starting at start, use f() for object-type specific data.
  23   struct ChainMapObject * cmo;
  24   for (cmo = start; cmo != 0; cmo = cmo->next) {
  25     write_uint16_bigendian(cmo->pos.y + 1, file);
  26     write_uint16_bigendian(cmo->pos.x + 1, file);
  27     fputc(cmo->name, file);
  28     f (cmo, 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 * monster = (struct Monster *) start;
  34   monster->hitpoints = fgetc(file); }
  35
  36 static struct ChainMapObject * get_next_cmo (void * start, char * still_at_start, size_t size, struct ChainMapObject * cmo) {
  37 // Return pointer to map object of size "size". If first in chain ("still_at_start"), make "start" point to it.
  38   if (*still_at_start) {
  39     struct ChainMapObject * * z = start;
  40     cmo = malloc(size);
  41     * z = cmo;
  42     *still_at_start = 0; }
  43   else {
  44     cmo->next = malloc(size);
  45     cmo = cmo->next; }
  46   return cmo; }
  47
  48 extern void read_map_objects (void * start, FILE * file, size_t size, void (* f) (void *, FILE *) ) {
  49 // Read from file chain of map objects starting at start, use f() for object-type specific data.
  50   struct ChainMapObject * cmo;
  51   uint16_t test;
  52   char still_at_start = 1;
  53   while (1) {
  54     test = read_uint16_bigendian(file);
  55     if (0 == test)
  56       break;
  57     cmo = get_next_cmo(start, &still_at_start, size, cmo);
  58     cmo->pos.y = test - 1;
  59     cmo->pos.x = read_uint16_bigendian(file) - 1;
  60     cmo->name = fgetc(file);
  61     f (cmo, file); }
  62   if (!still_at_start)
  63     cmo->next = 0; }
  64
  65 extern void build_map_objects_monsterdata (void * start) {
  66 // Build data specific to map objects of type monster.
  67   struct Monster * monster = (struct Monster *) start;
  68   monster->cmo.name = 'A' + (rrand(0, 0) % 8);
  69   monster->hitpoints = 5; }
  70
  71 extern void build_map_objects_itemdata (void * start) {
  72 // Build data speciifc to map objects of type data.
  73   struct Item * item = (struct Item *) start;
  74   item->cmo.name = '#' + (rrand(0, 0) % 4); }
  75
  76 extern void build_map_objects (void * start, unsigned char n, size_t size, void (* f) (void *), struct Map * map) {
  77 // Build chain of n map objects starting at start, use f() for object-specific data.
  78   unsigned char i;
  79   struct ChainMapObject * cmo;
  80   char still_at_start = 1;
  81   for (i = 0; i < n; i++) {
  82     cmo = get_next_cmo(start, &still_at_start, size, cmo);
  83     cmo->pos = find_passable_pos(map);
  84     f (cmo); }
  85   if (!still_at_start)
  86     cmo->next = 0; }
  87
  88 extern struct yx_uint16 find_passable_pos (struct Map * map) {
  89 // Return a random passable position on map.
  90   struct yx_uint16 pos;
  91   for (pos.y = pos.x = 0; 0 == is_passable(map, pos);) {
  92       pos.y = rrand(0, 0) % map->size.y;
  93       pos.x = rrand(0, 0) % map->size.x; }
  94   return pos; }
  95
  96 extern char is_passable (struct Map * map, struct yx_uint16 pos) {
  97 // Check if coordinate on (or beyond) map is accessible to actor movement.
  98   char passable = 0;
  99   if (0 <= pos.x && pos.x < map->size.x && 0 <= pos.y && pos.y < map->size.y)
 100     if ('.' == map->cells[pos.y * map->size.x + pos.x])
 101       passable = 1;
 102   return passable; }
 103
 104 extern void move_monster (struct World * world, struct Monster * monster) {
 105 // Move monster in random direction, trigger fighting when hindered by player/monster.
 106   char d = rrand(0, 0) % 5;
 107   struct yx_uint16 t = mv_yx_in_dir (d, monster->cmo.pos);
 108   if (yx_uint16_cmp (t, world->player->pos)) {
 109     update_log (world, "\nThe monster hits you.");
 110     world->player->hitpoints--;
 111     if (0 == world->player->hitpoints)
 112       update_log (world, "\nYou are dead.");
 113     return; }
 114   struct Monster * other_monster;
 115   for (other_monster = world->monster; other_monster != 0; other_monster = other_monster->cmo.next) {
 116     if (other_monster == monster)
 117       continue;
 118     if (yx_uint16_cmp (t, other_monster->cmo.pos)) {
 119       update_log (world, "\nMonster bumps into monster.");
 120       return; } }
 121   if (is_passable(world->map, t))
 122     monster->cmo.pos = t; }
 123
 124 extern void move_player (struct World * world, char d) {
 125 // Move player in direction d, update log and turn over to the enemy.
 126   struct yx_uint16 t = mv_yx_in_dir (d, world->player->pos);
 127   struct Monster * monster;
 128   for (monster = world->monster; monster != 0; monster = monster->cmo.next)
 129     if (yx_uint16_cmp (t, monster->cmo.pos)) {
 130       update_log (world, "\nYou hit the monster.");
 131       monster->hitpoints--;
 132       if (0 == monster->hitpoints) {
 133         update_log (world, "\nYou kill the monster.");
 134         if (world->monster == monster)
 135           world->monster = world->monster->cmo.next;
 136         else {
 137           struct Monster * m_prev;
 138           for (m_prev = world->monster; m_prev->cmo.next != monster; m_prev = m_prev->cmo.next);
 139           m_prev->cmo.next = monster->cmo.next; }
 140         free(monster); }
 141       turn_over (world, d);
 142       return; }
 143   char * msg = calloc(25, sizeof(char));
 144   char * msg_content = "You fail to move";
 145   char * dir;
 146   if      (NORTH == d) dir = "north";
 147   else if (EAST  == d) dir = "east" ;
 148   else if (SOUTH == d) dir = "south";
 149   else if (WEST  == d) dir = "west" ;
 150   if (is_passable(world->map, t)) {
 151     msg_content = "You move";
 152     world->player->pos = t; }
 153   sprintf(msg, "\n%s %s.", msg_content, dir);
 154   update_log (world, msg);
 155   free(msg);
 156   turn_over (world, d); }
 157
 158 extern void player_wait (struct World * world) {
 159 // Make player wait one turn.
 160   update_log (world, "\nYou wait.");
 161   turn_over (world, 0); }