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 (described by "dsc_monster1") bumping into "monster2". */
  16 static void monster_bumps_monster(struct World * world, char * dsc_monster1,
  17                                   struct Monster * monster2);
  18
  19 /* Decrement player HPs due to attack of monster described by "dsc_monster",
  20  * kill player if his HP hit zero; log the whole action.
  21  */
  22 static void monster_hits_player(struct World * world, char * dsc_monster);
  23
  24 /* Decrement HP of "monster" hit by player, kill it if its HP hit zero; log the
  25  * whole action.
  26  */
  27 static void player_hits_monster(struct World * world, struct Monster * monster);
  28
  29 /* Try moving the player in direction "d" towards coordinate "target"; log
  30  * success or failure of the whole action.
  31  */
  32 static void try_player_move(struct World * world,
  33                             enum dir d, struct yx_uint16 target);
  34
  35
  36
  37 static void monster_bumps_monster(struct World * world, char * dsc_monster1,
  38                                   struct Monster * monster2)
  39 {
  40     char * bump_dsc = " bumps into ";
  41     struct MapObjDef * mod = get_map_obj_def(world, monster2->map_obj.type);
  42     char * msg = malloc(strlen(dsc_monster1) + strlen(bump_dsc)
  43                         + strlen(mod->desc) + 3);
  44     sprintf(msg, "\n%s%s%s.", dsc_monster1, bump_dsc, mod->desc);
  45     update_log(world, msg);
  46     free(msg);
  47 }
  48
  49
  50
  51 static void monster_hits_player(struct World * world, char * dsc_monster)
  52 {
  53     char * hit_dsc = " hits you";
  54     char * msg = malloc(strlen(dsc_monster) + strlen(hit_dsc) + 3);
  55     sprintf(msg, "\n%s%s.", dsc_monster, hit_dsc);
  56     update_log(world, msg);
  57     free(msg);
  58     world->player->hitpoints--;
  59     if (0 == world->player->hitpoints)
  60     {
  61         update_log(world, "\nYou are dead.");
  62     }
  63 }
  64
  65
  66
  67 static void player_hits_monster(struct World * world, struct Monster * monster)
  68 {
  69     struct MapObjDef * mod = get_map_obj_def(world, monster->map_obj.type);
  70     char * hit_dsc = "You hit the ";
  71     char * monster_dsc = mod->desc;
  72     char * msg = malloc(strlen(hit_dsc) + strlen(monster_dsc) + 3);
  73     sprintf(msg, "\n%s%s.", hit_dsc, monster_dsc);
  74     update_log(world, msg);
  75     free(msg);
  76     monster->hitpoints--;
  77     if (0 == monster->hitpoints)
  78     {
  79         hit_dsc = "You kill the ";
  80         msg = malloc(strlen(hit_dsc) + strlen(monster_dsc) + 3);
  81         sprintf(msg, "\n%s%s.", hit_dsc, monster_dsc);
  82         update_log(world, msg);
  83         free(msg);
  84         struct MonsterDef * md = (struct MonsterDef * ) mod;
  85         struct Item * corpse = malloc(sizeof(struct Item));
  86         corpse->map_obj.type = md->corpse_id;
  87         corpse->map_obj.pos = monster->map_obj.pos;
  88         corpse->map_obj.next = world->item;
  89         world->item = corpse;
  90         if (world->monster == monster)
  91         {
  92             world->monster = world->monster->map_obj.next;
  93         }
  94         else
  95         {
  96             struct Monster * m_prev;
  97             for (m_prev = world->monster;
  98                  m_prev->map_obj.next != monster;
  99                  m_prev = m_prev->map_obj.next);
 100             {
 101                 m_prev->map_obj.next = monster->map_obj.next;
 102             }
 103         }
 104         free(monster);
 105     }
 106 }
 107
 108
 109
 110 static void try_player_move(struct World * world,
 111                             enum dir d, struct yx_uint16 target)
 112 {
 113     char * dsc_dir;
 114     if      (NORTH == d)
 115     {
 116         dsc_dir = "north";
 117     }
 118     else if (EAST  == d)
 119     {
 120         dsc_dir = "east" ;
 121     }
 122     else if (SOUTH == d)
 123     {
 124         dsc_dir = "south";
 125     }
 126     else if (WEST  == d)
 127     {
 128         dsc_dir = "west" ;
 129     }
 130     char * dsc_move = "You fail to move ";
 131     if (is_passable(world->map, target))
 132     {
 133         dsc_move = "You move ";
 134         world->player->pos = target;
 135     }
 136     char * msg = malloc(strlen(dsc_move) + strlen (dsc_dir) + 3);
 137     sprintf(msg, "\n%s%s.", dsc_move, dsc_dir);
 138     update_log(world, msg);
 139     free(msg);
 140 }
 141
 142
 143
 144 extern void move_monster(struct World * world, struct Monster * monster)
 145 {
 146     char d = rrand() % 5;
 147     struct yx_uint16 t = mv_yx_in_dir(d, monster->map_obj.pos);
 148     struct MapObjDef * mod = get_map_obj_def(world, monster->map_obj.type);
 149     char * dsc = mod->desc;
 150     if (yx_uint16_cmp(&t, &world->player->pos))
 151     {
 152         monster_hits_player(world, dsc);
 153         return;
 154     }
 155     struct Monster * other_monster;
 156     for (other_monster = world->monster;
 157          other_monster != 0;
 158          other_monster = other_monster->map_obj.next)
 159     {
 160         if (other_monster == monster)
 161         {
 162             continue;
 163         }
 164         if (yx_uint16_cmp(&t, &other_monster->map_obj.pos))
 165         {
 166             monster_bumps_monster(world, dsc, other_monster);
 167             return;
 168         }
 169     }
 170     if (is_passable(world->map, t))
 171     {
 172         monster->map_obj.pos = t;
 173     }
 174 }
 175
 176
 177
 178 extern void move_player(struct World * world, enum dir d)
 179 {
 180     struct yx_uint16 t = mv_yx_in_dir(d, world->player->pos);
 181     struct Monster * monster;
 182     for (monster = world->monster;
 183          monster != 0;
 184          monster = monster->map_obj.next)
 185     {
 186         if (yx_uint16_cmp(&t, &monster->map_obj.pos))
 187         {
 188             player_hits_monster(world, monster);
 189             turn_over(world, d);
 190             return;
 191           }
 192     }
 193     try_player_move(world, d, t);
 194     turn_over(world, d);
 195 }
 196
 197
 198
 199 extern void player_wait (struct World * world)
 200 {
 201     update_log(world, "\nYou wait.");
 202     turn_over(world, 0);
 203 }
 204
 205
 206
 207 extern char is_passable (struct Map * map, struct yx_uint16 pos)
 208 {
 209     char passable = 0;
 210     if (0 <= pos.x && pos.x < map->size.x && 0 <= pos.y && pos.y < map->size.y)
 211     {
 212         if ('.' == map->cells[pos.y * map->size.x + pos.x])
 213         {
 214             passable = 1;
 215         }
 216     }
 217     return passable;
 218 }