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