home · contact · privacy
Server: Add animate things in field of view to THINGS_HERE results.
[plomrogue] / src / server / thing_actions.c
1 /* src/server/thing_actions.c
2  *
3  * This file is part of PlomRogue. PlomRogue is licensed under the GPL version 3
4  * or any later version. For details on its copyright, license, and warranties,
5  * see the file NOTICE in the root directory of the PlomRogue source package.
6  */
7
8 #include "thing_actions.h"
9 #include <stddef.h> /* NULL */
10 #include <stdint.h> /* uint8_t */
11 #include <stdio.h> /* sprintf() */
12 #include <stdlib.h> /* free() */
13 #include <string.h> /* strlen() */
14 #include "../common/rexit.h" /* exit_trouble() */
15 #include "../common/try_malloc.h" /* try_malloc() */
16 #include "../common/yx_uint8.h" /* yx_uint8 */
17 #include "field_of_view.h" /* build_fov_map() */
18 #include "hardcoded_strings.h" /* s */
19 #include "things.h" /* Thing, ThingType, get_player(), free_things_in_memory(),
20                      * own_thing(), set_thing_position(), get_thing_type(),
21                      */
22 #include "map.h" /* mv_yx_in_dir_legal() */
23 #include "run.h" /* send_to_outfile() */
24 #include "world.h" /* global world */
25
26
27
28 /* Send "text" as log message to server out file. */
29 static void update_log(char * text);
30
31 /* One actor "wounds" another actor, decrementing his lifepoints and, if they
32  * reach zero in the process, killing it. Generates appropriate log message.
33  */
34 static void actor_hits_actor(struct Thing * hitter, struct Thing * hitted);
35
36 /* Bonus stuff to actor_*() to happen if actor==player. Mostly writing of log
37  * messages; _pick and _drop also decrement world.inventory_sel by 1 if >0.
38  * (match_dir() is just a little helper to playerbonus_move().)
39  */
40 static void playerbonus_wait();
41 static uint8_t match_dir(char d, char ** dsc_d, char match, char * dsc_match);
42 static void playerbonus_move(char d, uint8_t passable);
43 static void playerbonus_drop(uint8_t owns_none);
44 static void playerbonus_pick(uint8_t picked);
45 static void playerbonus_use(uint8_t no_thing, uint8_t wrong_thing);
46
47
48
49 static void update_log(char * text)
50 {
51     send_to_outfile("LOG ", 0);
52     send_to_outfile(text, 0);
53     send_to_outfile("\n", 1);
54 }
55
56
57
58 static void actor_hits_actor(struct Thing * hitter, struct Thing * hitted)
59 {
60     struct ThingType * tt_hitter = get_thing_type(hitter->type);
61     struct ThingType * tt_hitted = get_thing_type(hitted->type);
62     struct Thing * player = get_player();
63     char * msg1 = "You";
64     char * msg2 = "wound";
65     char * msg3 = "you";
66     if      (player != hitter)
67     {
68         msg1 = tt_hitter->name;
69         msg2 = "wounds";
70     }
71     if (player != hitted)
72     {
73         msg3 = tt_hitted->name;
74     }
75     uint8_t len = strlen(msg1) + 1 + strlen(msg2) + 1 + strlen(msg3) + 2;
76     char * msg = try_malloc(len, __func__);
77     int test = sprintf(msg, "%s %s %s.", msg1, msg2, msg3);
78     exit_trouble(test < 0, __func__, s[S_FCN_SPRINTF]);
79     update_log(msg);
80     free(msg);
81     hitted->lifepoints--;
82     if (0 == hitted->lifepoints)
83     {
84         hitted->type = tt_hitted->corpse_id;
85         if (player == hitted)
86         {
87             update_log("You die.");
88             memset(hitted->fov_map, ' ', world.map.length * world.map.length);
89             return;
90         }
91         else
92         {
93             free(hitted->fov_map);
94             hitted->fov_map = NULL;
95             free(hitted->mem_map);
96             hitted->mem_map = NULL;
97             free_things_in_memory(hitted->t_mem);
98             hitted->t_mem = NULL;
99         }
100         update_log("It dies.");
101     }
102 }
103
104
105
106 static void playerbonus_wait()
107 {
108         update_log("You wait.");
109 }
110
111
112
113 static uint8_t match_dir(char d, char ** dsc_d, char match, char * dsc_match)
114 {
115     if (d == match)
116     {
117         * dsc_d = dsc_match;
118         return 1;
119     }
120     return 0;
121 }
122
123
124
125 static void playerbonus_move(char d, uint8_t passable)
126 {
127     char * dsc_dir = "north-east";
128     if (   match_dir(d, &dsc_dir, 'd', "east")
129         || match_dir(d, &dsc_dir, 'c', "south-east")
130         || match_dir(d, &dsc_dir, 'x', "south-west")
131         || match_dir(d, &dsc_dir, 's', "west")
132         || match_dir(d, &dsc_dir, 'w', "north-west"))
133     {
134         ;
135     }
136     char * dsc_move = "You move ";
137     if (0 == passable)
138     {
139         dsc_move = "You fail to move ";
140     }
141     char * msg = try_malloc(strlen(dsc_move) + strlen (dsc_dir) + 2, __func__);
142     int test = sprintf(msg, "%s%s.", dsc_move, dsc_dir);
143     exit_trouble(test < 0, __func__, s[S_FCN_SPRINTF]);
144     update_log(msg);
145     free(msg);
146 }
147
148
149
150 static void playerbonus_drop(uint8_t owns_none)
151 {
152     if (0 != owns_none)
153     {
154         update_log("You try to drop an object, but you own none.");
155         return;
156     }
157     update_log("You drop an object.");
158 }
159
160
161
162 static void playerbonus_pick(uint8_t picked)
163 {
164     if (picked)
165     {
166         update_log("You pick up an object.");
167         return;
168     }
169     update_log("You try to pick up an object, but there is none.");
170 }
171
172
173
174 static void playerbonus_use(uint8_t no_thing, uint8_t wrong_thing)
175 {
176     if      (no_thing)
177     {
178         update_log("You try to use an object, but you own none.");
179         return;
180     }
181     else if (wrong_thing)
182     {
183         update_log("You try to use this object, but fail.");
184         return;
185     }
186     update_log("You consume MAGIC MEAT.");
187 }
188
189
190
191 extern void actor_wait(struct Thing * t)
192 {
193     if (t == get_player())
194     {
195         playerbonus_wait();
196     }
197 }
198
199
200
201 extern void actor_move(struct Thing * t)
202 {
203     char d = t->arg;
204     struct Thing * other_t;
205     struct yx_uint8 target = t->pos;
206     uint8_t legal_move = mv_yx_in_dir_legal(d, &target);
207     mv_yx_in_dir_legal(0, NULL);
208     uint8_t passable = 0;
209     if (legal_move)
210     {
211         passable = '.' == world.map.cells[target.y*world.map.length + target.x];
212         for (other_t = world.things; other_t != 0; other_t = other_t->next)
213         {
214             if (0 == other_t->lifepoints || other_t == t)
215             {
216                 continue;
217             }
218             if (target.y == other_t->pos.y && target.x == other_t->pos.x)
219             {
220                actor_hits_actor(t, other_t);
221                return;
222             }
223         }
224     }
225     if (passable)
226     {
227         set_thing_position(t, target);
228         build_fov_map(t);
229     }
230     if (t == get_player())
231     {
232         playerbonus_move(d, passable);
233     }
234 }
235
236
237
238 extern void actor_drop(struct Thing * t)
239 {
240     uint8_t owns_none = (!t->owns);
241     if (!owns_none)
242     {
243         uint8_t select = t->arg;
244         struct Thing * owned = t->owns;
245         uint8_t i = 0;
246         for (; i != select; i++, owned = owned->next);
247         own_thing(&world.things, &t->owns, owned->id);
248     }
249     if (t == get_player())
250     {
251         playerbonus_drop(owns_none);
252     }
253 }
254
255
256
257 extern void actor_pick(struct Thing * t)
258 {
259     struct Thing * picked = NULL;
260     struct Thing * t_i;
261     for (t_i = world.things; t_i; t_i = t_i->next)
262     {
263         if (t_i != t && t_i->pos.y == t->pos.y && t_i->pos.x == t->pos.x)
264         {
265             picked = t_i;
266         }
267     }
268     if (picked)
269     {
270         own_thing(&t->owns, &world.things, picked->id);
271         set_thing_position(picked, t->pos);
272     }
273     if (t == get_player())
274     {
275         playerbonus_pick(!(!picked));
276     }
277 }
278
279
280
281 extern void actor_use(struct Thing * t)
282 {
283     uint8_t wrong_thing = 1;
284     uint8_t no_thing = (!t->owns);
285     if (!no_thing)
286     {
287         uint8_t select = t->arg;
288         uint8_t i = 0;
289         struct Thing * selected = t->owns;
290         for (; i != select; i++, selected = selected->next);
291         struct ThingType * tt = get_thing_type(selected->type);
292         if (tt->consumable)
293         {
294             wrong_thing = 0;
295             struct Thing * next = selected->next;
296             free(selected);
297             if (0 < select)
298             {
299                 select--;
300                 selected = t->owns;
301                 for (i = 0; i != select; i++, selected = selected->next);
302                 selected->next = next;
303             }
304             else
305             {
306                 t->owns = next;
307             }
308             t->lifepoints = t->lifepoints + tt->consumable;
309         }
310     }
311     if (t == get_player())
312     {
313         playerbonus_use(no_thing, wrong_thing);
314     }
315 }