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

   1 /* src/server/map_object_actions.c */
   2
   3 #include "map_object_actions.h"
   4 #include <stddef.h> /* NULL */
   5 #include <stdint.h> /* uint8_t, uint16_t */
   6 #include <stdio.h> /* sprintf() */
   7 #include <stdlib.h> /* free() */
   8 #include <string.h> /* strlen(), strcmp(), memcpy(), strncmp() */
   9 #include "../common/rexit.h" /* exit_err() */
  10 #include "../common/try_malloc.h" /* try_malloc() */
  11 #include "../common/yx_uint8.h" /* struct yx_uint8 */
  12 #include "map_objects.h" /* structs MapObj, MapObjDef, get_player(),
  13                           * set_object_position(), own_map_object(),
  14                           * get_map_object_def()
  15                           */
  16 #include "map.h" /* is_passable() */
  17 #include "yx_uint8.h" /* mv_yx_in_dir(), yx_uint8_cmp() */
  18 #include "world.h" /* global world */
  19
  20
  21
  22 /* Append "text" to game log, or a "." if "text" is the same as the last one. */
  23 static void update_log(char * text);
  24
  25 /* If "name" fits "moa"->name, set "moa"->func to "func". */
  26 //static uint8_t try_func_name(struct MapObjAct * moa,
  27 //                             char * name, void (* func) (struct MapObj *));
  28
  29 /* One actor "wounds" another actor, decrementing his lifepoints and, if they
  30  * reach zero in the process, killing it. Generates appropriate log message.
  31  */
  32 static void actor_hits_actor(struct MapObj * hitter, struct MapObj * hitted);
  33
  34 /* Bonus stuff to actor_*() to happen if actor==player. Mostly writing of log
  35  * messages; _pick and _drop also decrement world.inventory_sel by 1 if >0.
  36  * (match_dir() is just a little helper to playerbonus_move().)
  37  */
  38 static void playerbonus_wait();
  39 static uint8_t match_dir(char d, char ** dsc_d, char match, char * dsc_match);
  40 static void playerbonus_move(char d, uint8_t passable);
  41 static void playerbonus_drop(uint8_t owns_none);
  42 static void playerbonus_pick(uint8_t picked);
  43 static void playerbonus_use(uint8_t no_object, uint8_t wrong_object);
  44
  45
  46
  47 static void update_log(char * text)
  48 {
  49     char * f_name = "update_log()";
  50     uint16_t len_new = strlen(text);
  51     uint16_t len_old = 0;
  52     if (world.log)
  53     {
  54         len_old = strlen(world.log);
  55         uint16_t last_nl = len_old - 1;
  56         while (last_nl != 0)
  57         {
  58             if ('\n' == world.log[last_nl])
  59             {
  60                 break;
  61             }
  62             last_nl--;
  63         }
  64         uint16_t last_stop = len_old - 1;
  65         while (last_stop != 0)
  66         {
  67             if ('.' == world.log[last_stop] && '.' != world.log[last_stop - 1])
  68             {
  69                 break;
  70             }
  71             last_stop--;
  72         }
  73         if (   (last_stop + 1) - last_nl == (uint16_t) strlen(text)
  74             && 0 == strncmp(world.log + last_nl, text, strlen(text)))
  75         {
  76             text = ".";
  77         }
  78     }
  79     uint16_t len_whole = len_old + len_new + 1;
  80     char * new_text = try_malloc(len_whole, f_name);
  81     memcpy(new_text, world.log, len_old);
  82     sprintf(new_text + len_old, "%s", text);
  83     free(world.log);
  84     world.log = new_text;
  85 }
  86
  87
  88
  89 static void actor_hits_actor(struct MapObj * hitter, struct MapObj * hitted)
  90 {
  91     struct MapObjDef * mod_hitter = get_map_object_def(hitter->type);
  92     struct MapObjDef * mod_hitted = get_map_object_def(hitted->type);
  93     struct MapObj * player = get_player();
  94     char * msg1 = "You";
  95     char * msg2 = "wound";
  96     char * msg3 = "you";
  97     if      (player != hitter)
  98     {
  99         msg1 = mod_hitter->name;
 100         msg2 = "wounds";
 101     }
 102     if (player != hitted)
 103     {
 104         msg3 = mod_hitted->name;
 105     }
 106     uint8_t len = 1 + strlen(msg1) + 1 + strlen(msg2) + 1 + strlen(msg3) + 2;
 107     char msg[len];
 108     sprintf(msg, "\n%s %s %s.", msg1, msg2, msg3);
 109     update_log(msg);
 110     hitted->lifepoints--;
 111     if (0 == hitted->lifepoints)
 112     {
 113         hitted->type = mod_hitted->corpse_id;
 114         if (player == hitted)
 115         {
 116             update_log(" You die.");
 117             return;
 118         }
 119         update_log(" It dies.");
 120     }
 121 }
 122
 123
 124
 125 static void playerbonus_wait()
 126 {
 127         update_log("\nYou wait.");
 128 }
 129
 130
 131
 132 static uint8_t match_dir(char d, char ** dsc_d, char match, char * dsc_match)
 133 {
 134     if (d == match)
 135     {
 136         * dsc_d = dsc_match;
 137         return 1;
 138     }
 139     return 0;
 140 }
 141
 142
 143
 144 static void playerbonus_move(char d, uint8_t passable)
 145 {
 146     char * dsc_dir = "north";
 147     if (   match_dir(d, &dsc_dir, '6', "east")
 148         || match_dir(d, &dsc_dir, '2', "south")
 149         || match_dir(d, &dsc_dir, '4', "west")
 150         || match_dir(d, &dsc_dir, '7', "north-west")
 151         || match_dir(d, &dsc_dir, '9', "north-east")
 152         || match_dir(d, &dsc_dir, '1', "south-west")
 153         || match_dir(d, &dsc_dir, '3', "south-east"))
 154     {
 155         ;
 156     }
 157     char * dsc_move = "You move ";
 158     if (0 == passable)
 159     {
 160         dsc_move = "You fail to move ";
 161     }
 162     char msg[strlen(dsc_move) + strlen (dsc_dir) + 3];
 163     sprintf(msg, "\n%s%s.", dsc_move, dsc_dir);
 164     update_log(msg);
 165 }
 166
 167
 168
 169 static void playerbonus_drop(uint8_t owns_none)
 170 {
 171     if (0 != owns_none)
 172     {
 173         update_log("\nYou try to drop an object, but you own none.");
 174         return;
 175     }
 176     update_log("\nYou drop an object.");
 177 }
 178
 179
 180
 181 static void playerbonus_pick(uint8_t picked)
 182 {
 183     if (picked)
 184     {
 185         update_log("\nYou pick up an object.");
 186         return;
 187     }
 188     update_log("\nYou try to pick up an object, but there is none.");
 189 }
 190
 191
 192
 193 static void playerbonus_use(uint8_t no_object, uint8_t wrong_object)
 194 {
 195     if      (no_object)
 196     {
 197         update_log("\nYou try to use an object, but you own none.");
 198         return;
 199     }
 200     else if (wrong_object)
 201     {
 202         update_log("\nYou try to use this object, but fail.");
 203         return;
 204     }
 205     update_log("\nYou consume MAGIC MEAT.");
 206 }
 207
 208
 209
 210 extern void free_map_object_actions(struct MapObjAct * moa)
 211 {
 212     if (NULL == moa)
 213     {
 214         return;
 215     }
 216     free(moa->name);
 217     free_map_object_actions(moa->next);
 218     free(moa);
 219 }
 220
 221
 222
 223 extern uint8_t get_moa_id_by_name(char * name)
 224 {
 225     struct MapObjAct * moa = world.map_obj_acts;
 226     while (NULL != moa)
 227     {
 228         if (0 == strcmp(moa->name, name))
 229         {
 230             break;
 231         }
 232         moa = moa->next;
 233     }
 234     exit_err(NULL==moa, "get_moa_id_by_name() did not find map object action.");
 235     return moa->id;
 236 }
 237
 238
 239
 240 extern void actor_wait(struct MapObj * mo)
 241 {
 242     if (mo == get_player())
 243     {
 244         playerbonus_wait();
 245     }
 246 }
 247
 248
 249
 250 extern void actor_move(struct MapObj * mo)
 251 {
 252     char d = mo->arg;
 253     struct yx_uint8 target = mv_yx_in_dir(d, mo->pos);
 254     struct MapObj * other_mo;
 255     for (other_mo = world.map_objs; other_mo != 0; other_mo = other_mo->next)
 256     {
 257         if (0 == other_mo->lifepoints || other_mo == mo)
 258         {
 259             continue;
 260         }
 261         if (yx_uint8_cmp(&target, &other_mo->pos))
 262         {
 263             actor_hits_actor(mo, other_mo);
 264             return;
 265         }
 266     }
 267     uint8_t passable = is_passable(target);
 268     if (passable)
 269     {
 270         set_object_position(mo, target);
 271     }
 272     if (mo == get_player())
 273     {
 274         playerbonus_move(d, passable);
 275     }
 276 }
 277
 278
 279
 280 extern void actor_drop(struct MapObj * mo)
 281 {
 282     uint8_t owns_none = (NULL == mo->owns);
 283     if (!owns_none)
 284     {
 285         uint8_t select = mo->arg;
 286         struct MapObj * owned = mo->owns;
 287         uint8_t i = 0;
 288         for (; i != select; i++, owned = owned->next);
 289         own_map_object(&world.map_objs, &mo->owns, owned->id);
 290     }
 291     if (mo == get_player())
 292     {
 293         playerbonus_drop(owns_none);
 294     }
 295 }
 296
 297
 298
 299 extern void actor_pick(struct MapObj * mo)
 300 {
 301     struct MapObj * picked = NULL;
 302     struct MapObj * mo_i;
 303     for (mo_i = world.map_objs; NULL != mo_i; mo_i = mo_i->next)
 304     {
 305         if (mo_i != mo && yx_uint8_cmp(&mo_i->pos, &mo->pos))
 306         {
 307             picked = mo_i;
 308         }
 309     }
 310     if (NULL != picked)
 311     {
 312         own_map_object(&mo->owns, &world.map_objs, picked->id);
 313         set_object_position(picked, mo->pos);
 314     }
 315     if (mo == get_player())
 316     {
 317         playerbonus_pick(NULL != picked);
 318     }
 319 }
 320
 321
 322
 323 extern void actor_use(struct MapObj * mo)
 324 {
 325     uint8_t wrong_object = 1;
 326     uint8_t no_object = (NULL == mo->owns);
 327     if (!no_object)
 328     {
 329         uint8_t select = mo->arg;
 330         uint8_t i = 0;
 331         struct MapObj * selected = mo->owns;
 332         for (; i != select; i++, selected = selected->next);
 333         struct MapObjDef * mod = get_map_object_def(selected->type);
 334         if (mod->consumable)
 335         {
 336             wrong_object = 0;
 337             struct MapObj * next = selected->next;
 338             free(selected);
 339             if (0 < select)
 340             {
 341                 select--;
 342                 selected = mo->owns;
 343                 for (i = 0; i != select; i++, selected = selected->next);
 344                 selected->next = next;
 345             }
 346             else
 347             {
 348                 mo->owns = next;
 349             }
 350             mo->lifepoints = mo->lifepoints + mod->consumable;
 351         }
 352     }
 353     if (mo == get_player())
 354     {
 355         playerbonus_use(no_object, wrong_object);
 356     }
 357 }