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

   1 /* map_object_actions.c */
   2
   3 #include "map_object_actions.h"
   4 #include <stdlib.h> /* for malloc(), calloc(), free() */
   5 #include <string.h> /* for strlen() */
   6 #include "yx_uint16.h" /* for yx_uint16 struct, mv_yx_in_dir(), yx_uint16_cmp */
   7 #include "misc.h" /* for update_log(), turn_over()*/
   8 #include "map.h" /* for Map struct */
   9 #include "main.h" /* for World struct */
  10 #include "map_objects.h" /* for map object (definition) structs */
  11 #include "rrand.h" /* for rrand() */
  12
  13
  14
  15 /* Log monster bumping into monster. */
  16 static void monster_bumps_monster(struct World * world, char * desc_monster1,
  17                                   struct Monster * monster2);
  18
  19 /* Decrement player HPs due to attack of monster, kill him if necessary and log
  20  * the whole action.
  21  */
  22 static void monster_hits_player(struct World * world, char * desc_monster);
  23
  24
  25
  26 static void monster_bumps_monster(struct World * world, char * desc_monster1,
  27                                   struct Monster * monster2)
  28 {
  29     char * bumpdesc = " bumps into ";
  30     struct MapObjDef * mod = get_map_obj_def(world, monster2->map_obj.type);
  31     char * msg = malloc(strlen(desc_monster1) + strlen(bumpdesc)
  32                         + strlen(mod->desc) + 3);
  33     sprintf(msg, "\n%s%s%s.", desc_monster1, bumpdesc, mod->desc);
  34     update_log(world, msg);
  35     free(msg);
  36 }
  37
  38
  39
  40 static void monster_hits_player(struct World * world, char * desc_monster)
  41 {
  42     char * hitdesc = " hits you.";
  43     char * msg = malloc(strlen(desc_monster) + strlen(hitdesc) + 2);
  44     sprintf(msg, "\n%s%s", desc_monster, hitdesc);
  45     update_log(world, msg);
  46     free(msg);
  47     world->player->hitpoints--;
  48     if (0 == world->player->hitpoints)
  49     {
  50         update_log(world, "\nYou are dead.");
  51     }
  52 }
  53
  54
  55
  56 extern void move_monster(struct World * world, struct Monster * monster)
  57 {
  58     char d = rrand() % 5;
  59     struct yx_uint16 t = mv_yx_in_dir(d, monster->map_obj.pos);
  60     struct MapObjDef * mod = get_map_obj_def(world, monster->map_obj.type);
  61     char * desc = mod->desc;
  62     if (yx_uint16_cmp(&t, &world->player->pos))
  63     {
  64         monster_hits_player(world, desc);
  65         return;
  66     }
  67     struct Monster * other_monster;
  68     for (other_monster = world->monster;
  69          other_monster != 0;
  70          other_monster = other_monster->map_obj.next)
  71     {
  72         if (other_monster == monster)
  73         {
  74             continue;
  75         }
  76         if (yx_uint16_cmp(&t, &other_monster->map_obj.pos))
  77         {
  78             monster_bumps_monster(world, desc, other_monster);
  79             return;
  80         }
  81     }
  82     if (is_passable(world->map, t))
  83     {
  84         monster->map_obj.pos = t;
  85     }
  86 }
  87
  88
  89
  90 extern void move_player (struct World * world, enum dir d)
  91 {
  92     struct yx_uint16 t = mv_yx_in_dir(d, world->player->pos);
  93     struct Monster * monster;
  94     struct MapObjDef * mod;
  95     char * msg = calloc(100, sizeof(char));
  96     char * desc;
  97     for (monster = world->monster;
  98          monster != 0;
  99          monster = monster->map_obj.next)
 100     {
 101         if (yx_uint16_cmp(&t, &monster->map_obj.pos))
 102         {
 103             mod = get_map_obj_def(world, monster->map_obj.type);
 104             desc = mod->desc;
 105             sprintf(msg, "\nYou hit the %s.", desc);
 106             update_log(world, msg);
 107             monster->hitpoints--;
 108             if (0 == monster->hitpoints)
 109             {
 110                 sprintf(msg, "\nYou kill the %s.", desc);
 111                 update_log(world, msg);
 112                 if (world->monster == monster)
 113                 {
 114                     world->monster = world->monster->map_obj.next;
 115                 }
 116                 else
 117                 {
 118                     struct Monster * m_prev;
 119                     for (m_prev = world->monster;
 120                          m_prev->map_obj.next != monster;
 121                          m_prev = m_prev->map_obj.next);
 122                     m_prev->map_obj.next = monster->map_obj.next;
 123                 }
 124                 free(monster);
 125             }
 126             turn_over(world, d);
 127             return;
 128           }
 129       }
 130       char * msg_content = "You fail to move";
 131       char * dir;
 132       if      (NORTH == d)
 133       {
 134           dir = "north";
 135       }
 136       else if (EAST  == d)
 137       {
 138           dir = "east" ;
 139       }
 140       else if (SOUTH == d)
 141       {
 142           dir = "south";
 143       }
 144       else if (WEST  == d)
 145       {
 146           dir = "west" ;
 147       }
 148       if (is_passable(world->map, t))
 149       {
 150           msg_content = "You move";
 151           world->player->pos = t;
 152       }
 153       sprintf(msg, "\n%s %s.", msg_content, dir);
 154       update_log(world, msg);
 155       free(msg);
 156       turn_over(world, d);
 157 }
 158
 159
 160
 161 extern void player_wait (struct World * world)
 162 {
 163     update_log(world, "\nYou wait.");
 164     turn_over(world, 0);
 165 }
 166
 167
 168
 169 extern char is_passable (struct Map * map, struct yx_uint16 pos)
 170 {
 171     char passable = 0;
 172     if (0 <= pos.x && pos.x < map->size.x && 0 <= pos.y && pos.y < map->size.y)
 173     {
 174         if ('.' == map->cells[pos.y * map->size.x + pos.x])
 175         {
 176             passable = 1;
 177         }
 178     }
 179     return passable;
 180 }
 181