home · contact · privacy
Killed monsters evolve into corpse items.
[plomrogue] / 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 }