crawl-ref/source/l_mons.cc

   1 #include "AppHdr.h"
   2
   3 #include "cluautil.h"
   4 #include "l_libs.h"
   5
   6 #include "delay.h"
   7 #include "dlua.h"
   8 #include "initfile.h"
   9 #include "libutil.h"
  10 #include "mon-act.h"
  11 #include "mon-behv.h"
  12 #include "mon-util.h"
  13 #include "mon-stuff.h"
  14
  15 #define WRAPPED_MONSTER(ls, name)                                       \
  16     MonsterWrap *___mw = clua_get_userdata< MonsterWrap >(ls, MONS_METATABLE); \
  17     if (!___mw                                                          \
  18         || !___mw->mons                                              \
  19         || CLua::get_vm(ls).managed_vm && ___mw->turn != you.num_turns) \
  20     {                                                                \
  21         luaL_argerror(ls, 1, "Invalid monster wrapper");             \
  22     } \
  23     monster *name(___mw->mons)
  24
  25 /////////////////////////////////////////////////////////////////////
  26 // Monster handling
  27
  28 void push_monster(lua_State *ls, monster* mons)
  29 {
  30     MonsterWrap *mw = clua_new_userdata< MonsterWrap >(ls, MONS_METATABLE);
  31     mw->turn = you.num_turns;
  32     mw->mons = mons;
  33 }
  34
  35 #define MDEF(name)                                                      \
  36     static int l_mons_##name(lua_State *ls, monster* mons,             \
  37                              const char *attr)                         \
  38
  39 #define MDEFN(name, closure)                    \
  40     static int l_mons_##name(lua_State *ls, monster* mons, const char *attrs) \
  41     {                                                                   \
  42     lua_pushlightuserdata(ls, mons);                                    \
  43     lua_pushcclosure(ls, l_mons_##closure, 1);                          \
  44     return (1);                                                         \
  45     }
  46
  47 MDEF(name)
  48 {
  49     PLUARET(string, mons->name(DESC_PLAIN, true).c_str());
  50 }
  51
  52 MDEF(unique)
  53 {
  54     PLUARET(boolean, mons_is_unique(mons->type));
  55 }
  56
  57 MDEF(base_name)
  58 {
  59     PLUARET(string, mons->base_name(DESC_PLAIN, true).c_str());
  60 }
  61
  62 MDEF(full_name)
  63 {
  64     PLUARET(string, mons->full_name(DESC_PLAIN, true).c_str());
  65 }
  66
  67 MDEF(db_name)
  68 {
  69     PLUARET(string, mons->name(DESC_DBNAME, true).c_str());
  70 }
  71
  72 MDEF(type_name)
  73 {
  74     PLUARET(string, mons_type_name(mons->type, DESC_PLAIN).c_str());
  75 }
  76
  77 MDEF(entry_name)
  78 {
  79     ASSERT_DLUA;
  80
  81     const monsterentry *me = get_monster_data(mons->type);
  82     if (me)
  83         lua_pushstring(ls, me->name);
  84     else
  85         lua_pushnil(ls);
  86
  87     return (1);
  88 }
  89
  90 MDEF(x)
  91 {
  92     PLUARET(number, int(mons->pos().x) - int(you.pos().x));
  93 }
  94
  95 MDEF(y)
  96 {
  97     PLUARET(number, int(mons->pos().y) - int(you.pos().y));
  98 }
  99
 100 static const char* _behaviour_name(beh_type beh);
 101 MDEF(beh)
 102 {
 103     PLUARET(string, _behaviour_name(mons->behaviour));
 104 }
 105
 106 MDEF(energy)
 107 {
 108     // XXX: fix this after speed_increment clean up
 109     PLUARET(number, (mons->speed_increment - 79))
 110 }
 111
 112 LUAFN(l_mons_add_energy)
 113 {
 114     ASSERT_DLUA;
 115     monster* mons = clua_get_lightuserdata<monster>(ls, lua_upvalueindex(1));
 116     mons->speed_increment += luaL_checkint(ls, 1);
 117     return (0);
 118 }
 119 MDEFN(add_energy, add_energy)
 120
 121 #define LUANAMEFN(name, expr)                     \
 122     static int l_mons_##name##_fn(lua_State *ls) {      \
 123        ASSERT_DLUA;                              \
 124        const monster* mons =                                    \
 125            clua_get_lightuserdata<monster>(ls, lua_upvalueindex(1)); \
 126        const description_level_type dtype =                          \
 127            lua_isstring(ls, 1)?                                      \
 128            description_type_by_name(luaL_checkstring(ls, 1))         \
 129            : DESC_PLAIN;                                             \
 130        PLUARET(string, expr.c_str());             \
 131     }                                             \
 132     MDEFN(name, name##_fn)                        \
 133
 134 LUANAMEFN(mname, mons->name(dtype, true))
 135 LUANAMEFN(mfull_name, mons->full_name(dtype, true))
 136 LUANAMEFN(mbase_name, mons->base_name(dtype, true))
 137
 138 MDEF(hd)
 139 {
 140     PLUARET(number, mons->hit_dice);
 141 }
 142
 143 MDEF(targetx)
 144 {
 145     PLUARET(number, mons->target.x);
 146 }
 147
 148 MDEF(targety)
 149 {
 150     PLUARET(number, mons->target.y);
 151 }
 152
 153 MDEF(shapeshifter)
 154 {
 155     ASSERT_DLUA;
 156     if (mons->has_ench(ENCH_GLOWING_SHAPESHIFTER))
 157         lua_pushstring(ls, "glowing shapeshifter");
 158     else if (mons->has_ench(ENCH_SHAPESHIFTER))
 159         lua_pushstring(ls, "shapeshifter");
 160     else
 161         lua_pushnil(ls);
 162     return (1);
 163 }
 164
 165 MDEF(mimic)
 166 {
 167     ASSERT_DLUA;
 168     if (mons_genus(mons->type) == MONS_GOLD_MIMIC)
 169     {
 170         switch (mons->type)
 171         {
 172         case MONS_GOLD_MIMIC:
 173             lua_pushstring(ls, "gold mimic"); break;
 174         case MONS_WEAPON_MIMIC:
 175             lua_pushstring(ls, "weapon mimic"); break;
 176         case MONS_ARMOUR_MIMIC:
 177             lua_pushstring(ls, "armour mimic"); break;
 178         case MONS_POTION_MIMIC:
 179             lua_pushstring(ls, "potion mimic"); break;
 180         case MONS_SCROLL_MIMIC:
 181             lua_pushstring(ls, "scroll mimic"); break;
 182         default:
 183             lua_pushstring(ls, "unknown mimic"); break;
 184         }
 185     }
 186     else
 187         lua_pushnil(ls);
 188
 189     return (1);
 190 }
 191
 192 MDEF(dancing_weapon)
 193 {
 194     ASSERT_DLUA;
 195
 196     if (mons_genus(mons->type) == MONS_DANCING_WEAPON)
 197         lua_pushstring(ls, "dancing weapon");
 198     else
 199         lua_pushnil(ls);
 200
 201     return (1);
 202 }
 203
 204 static const char *_monuse_names[] =
 205 {
 206     "nothing", "open_doors", "starting_equipment", "weapons_armour"
 207 };
 208
 209 static const char *_monuse_to_str(mon_itemuse_type utyp)
 210 {
 211     COMPILE_CHECK(ARRAYSZ(_monuse_names) == NUM_MONUSE, c1);
 212     return _monuse_names[utyp];
 213 }
 214
 215 MDEF(muse)
 216 {
 217     if (const monsterentry *me = mons->find_monsterentry())
 218     {
 219         PLUARET(string, _monuse_to_str(me->gmon_use));
 220     }
 221     return (0);
 222 }
 223
 224 static const char *_moneat_names[] =
 225 {
 226     "nothing", "items", "corpses", "food"
 227 };
 228
 229 static const char *_moneat_to_str(mon_itemeat_type etyp)
 230 {
 231     COMPILE_CHECK(ARRAYSZ(_moneat_names) == NUM_MONEAT, c1);
 232     return _moneat_names[etyp];
 233 }
 234
 235 MDEF(meat)
 236 {
 237     if (const monsterentry *me = mons->find_monsterentry())
 238     {
 239         PLUARET(string, _moneat_to_str(me->gmon_eat));
 240     }
 241     return (0);
 242 }
 243
 244 static int l_mons_do_dismiss(lua_State *ls)
 245 {
 246     // dismiss is only callable from dlua, not from managed VMs (i.e.
 247     // end-user scripts cannot dismiss monsters).
 248     ASSERT_DLUA;
 249     monster* mons = clua_get_lightuserdata<monster>(ls, lua_upvalueindex(1));
 250
 251     if (mons->alive())
 252     {
 253         mons->flags |= MF_HARD_RESET;
 254         monster_die(mons, KILL_DISMISSED, NON_MONSTER);
 255     }
 256     return (0);
 257 }
 258 MDEFN(dismiss, do_dismiss)
 259
 260 // Run the monster AI code.
 261 static int l_mons_do_run_ai(lua_State *ls)
 262 {
 263     ASSERT_DLUA;
 264     monster* mons = clua_get_lightuserdata<monster>(ls, lua_upvalueindex(1));
 265     if (mons->alive())
 266         handle_monster_move(mons);
 267     return (0);
 268 }
 269 MDEFN(run_ai, do_run_ai)
 270
 271 static int l_mons_do_handle_behaviour(lua_State *ls)
 272 {
 273     ASSERT_DLUA;
 274     monster* mons = clua_get_lightuserdata<monster>(ls, lua_upvalueindex(1));
 275     if (mons->alive())
 276         handle_behaviour(mons);
 277     return (0);
 278 }
 279 MDEFN(handle_behaviour, do_handle_behaviour)
 280
 281 static int l_mons_do_random_teleport(lua_State *ls)
 282 {
 283     // We should only be able to teleport monsters from dlua.
 284     ASSERT_DLUA;
 285
 286     monster* mons = clua_get_lightuserdata<monster>(ls, lua_upvalueindex(1));
 287
 288     if (mons->alive())
 289         mons->teleport(true);
 290
 291     return (0);
 292 }
 293
 294 MDEFN(random_teleport, do_random_teleport)
 295
 296 MDEF(experience)
 297 {
 298     ASSERT_DLUA;
 299     PLUARET(number, exper_value(mons));
 300 }
 301
 302 static int l_mons_do_set_prop(lua_State *ls)
 303 {
 304     // We should only be able to set properties from dlua.
 305     ASSERT_DLUA;
 306
 307     monster* mons =
 308         clua_get_lightuserdata<monster>(ls, lua_upvalueindex(1));
 309
 310     const char *prop_name = luaL_checkstring(ls, 1);
 311
 312     if (lua_isnoneornil(ls, 2))
 313         mons->props.erase(prop_name);
 314     else if (lua_isboolean(ls, 2))
 315         mons->props[prop_name] = (bool) lua_toboolean(ls, 2);
 316     // NOTE: number has to be before string, or numbers will get converted
 317     // into strings.
 318     else if (lua_isnumber(ls, 2))
 319         mons->props[prop_name].get_int() = luaL_checklong(ls, 2);
 320     else if (lua_isstring(ls, 2))
 321         mons->props[prop_name] = lua_tostring(ls, 2);
 322     else if (lua_isfunction(ls, 2))
 323     {
 324         dlua_chunk chunk(ls);
 325         mons->props[prop_name] = chunk;
 326     }
 327     else
 328     {
 329         std::string err
 330             = make_stringf("Don't know how to set monster property of the "
 331                            "given value type for property '%s'", prop_name);
 332         luaL_argerror(ls, 2, err.c_str());
 333     }
 334
 335     return (0);
 336 }
 337
 338 MDEFN(set_prop, do_set_prop)
 339
 340 static int l_mons_do_get_prop(lua_State *ls)
 341 {
 342     // We should only be able to set properties from dlua.
 343     ASSERT_DLUA;
 344
 345     monster* mons =
 346         clua_get_lightuserdata<monster>(ls, lua_upvalueindex(1));
 347
 348     const char *prop_name = luaL_checkstring(ls, 1);
 349
 350     if (!mons->props.exists(prop_name))
 351     {
 352         if (lua_isboolean(ls, 2))
 353         {
 354             std::string err = make_stringf("Don't have a property called '%s'.", prop_name);
 355             luaL_argerror(ls, 2, err.c_str());
 356         }
 357
 358         return (0);
 359     }
 360
 361     CrawlStoreValue prop = mons->props[prop_name];
 362     int num_pushed = 1;
 363
 364     switch (prop.get_type())
 365     {
 366     case SV_NONE: lua_pushnil(ls); break;
 367     case SV_BOOL: lua_pushboolean(ls, prop.get_bool()); break;
 368     case SV_BYTE: lua_pushboolean(ls, prop.get_byte()); break;
 369     case SV_SHORT: lua_pushnumber(ls, prop.get_short()); break;
 370     case SV_INT: lua_pushnumber(ls, prop.get_int()); break;
 371     case SV_FLOAT: lua_pushnumber(ls, prop.get_float()); break;
 372     case SV_STR: lua_pushstring(ls, prop.get_string().c_str()); break;
 373     case SV_COORD:
 374         num_pushed++;
 375         lua_pushnumber(ls, prop.get_coord().x);
 376         lua_pushnumber(ls, prop.get_coord().y);
 377         break;
 378     default:
 379         // Do nothing for some things.
 380         lua_pushnil(ls);
 381         break;
 382     }
 383
 384     return (num_pushed);
 385 }
 386
 387 MDEFN(get_prop, do_get_prop)
 388
 389 static int l_mons_do_has_prop(lua_State *ls)
 390 {
 391     // We should only be able to get properties from dlua.
 392     ASSERT_DLUA;
 393
 394     monster* mons =
 395         clua_get_lightuserdata<monster>(ls, lua_upvalueindex(1));
 396
 397     const char *prop_name = luaL_checkstring(ls, 1);
 398
 399     lua_pushboolean(ls, mons->props.exists(prop_name));
 400     return (1);
 401 }
 402
 403 MDEFN(has_prop, do_has_prop)
 404
 405 static int l_mons_do_add_ench(lua_State *ls)
 406 {
 407     ASSERT_DLUA;
 408
 409     monster* mons =
 410         clua_get_lightuserdata<monster>(ls, lua_upvalueindex(1));
 411
 412     const char *ench_name = luaL_checkstring(ls, 1);
 413     enchant_type met = name_to_ench(ench_name);
 414     if (!met)
 415     {
 416         std::string err
 417             = make_stringf("No such enchantment: %s", ench_name);
 418         luaL_argerror(ls, 1, err.c_str());
 419         return 0;
 420     }
 421
 422     mons->add_ench(mon_enchant(met, luaL_checkint(ls, 2), KC_OTHER,
 423                                luaL_checkint(ls, 3)));
 424     return 0;
 425 }
 426
 427 MDEFN(add_ench, do_add_ench)
 428
 429 static int l_mons_do_del_ench(lua_State *ls)
 430 {
 431     ASSERT_DLUA;
 432
 433     monster* mons =
 434         clua_get_lightuserdata<monster>(ls, lua_upvalueindex(1));
 435
 436     const char *ench_name = luaL_checkstring(ls, 1);
 437     enchant_type met = name_to_ench(ench_name);
 438     if (!met)
 439     {
 440         std::string err
 441             = make_stringf("No such enchantment: %s", ench_name);
 442         luaL_argerror(ls, 1, err.c_str());
 443         return 0;
 444     }
 445
 446     mons->del_ench(met);
 447     return 0;
 448 }
 449
 450 MDEFN(del_ench, do_del_ench)
 451
 452 MDEF(you_can_see)
 453 {
 454     ASSERT_DLUA;
 455     PLUARET(boolean, you.can_see(mons));
 456 }
 457
 458 struct MonsAccessor
 459 {
 460     const char *attribute;
 461     int (*accessor)(lua_State *ls, monster* mons, const char *attr);
 462 };
 463
 464 static MonsAccessor mons_attrs[] =
 465 {
 466     { "name",           l_mons_name      },
 467     { "base_name",      l_mons_base_name },
 468     { "full_name",      l_mons_full_name },
 469     { "db_name",        l_mons_db_name   },
 470     { "type_name",      l_mons_type_name },
 471     { "entry_name",     l_mons_entry_name },
 472     { "unique"   ,      l_mons_unique },
 473     { "shapeshifter",   l_mons_shapeshifter },
 474     { "mimic",          l_mons_mimic },
 475     { "dancing_weapon", l_mons_dancing_weapon },
 476
 477     { "x"   , l_mons_x    },
 478     { "y"   , l_mons_y    },
 479     { "hd"  , l_mons_hd   },
 480     { "beh" , l_mons_beh  },
 481     { "muse", l_mons_muse },
 482     { "meat", l_mons_meat },
 483
 484     { "targetx", l_mons_targetx },
 485     { "targety", l_mons_targety },
 486
 487     { "mname",           l_mons_mname           },
 488     { "mfull_name",      l_mons_mfull_name      },
 489     { "mbase_name",      l_mons_mbase_name      },
 490     { "energy",          l_mons_energy          },
 491     { "add_energy",      l_mons_add_energy      },
 492     { "dismiss",         l_mons_dismiss         },
 493     { "run_ai",          l_mons_run_ai          },
 494     { "handle_behaviour",l_mons_handle_behaviour },
 495     { "experience",      l_mons_experience      },
 496     { "random_teleport", l_mons_random_teleport },
 497     { "set_prop",        l_mons_set_prop        },
 498     { "get_prop",        l_mons_get_prop        },
 499     { "has_prop",        l_mons_has_prop        },
 500     { "add_ench",        l_mons_add_ench        },
 501     { "del_ench",        l_mons_del_ench        },
 502     { "you_can_see",     l_mons_you_can_see     }
 503 };
 504
 505 static int monster_get(lua_State *ls)
 506 {
 507     WRAPPED_MONSTER(ls, mons);
 508
 509     const char *attr = luaL_checkstring(ls, 2);
 510     if (!attr)
 511         return (0);
 512
 513     for (unsigned i = 0; i < sizeof(mons_attrs) / sizeof(mons_attrs[0]); ++i)
 514         if (!strcmp(attr, mons_attrs[i].attribute))
 515             return (mons_attrs[i].accessor(ls, mons, attr));
 516
 517     return (0);
 518 }
 519
 520 static const char *_monster_behaviour_names[] = {
 521     "sleep",
 522     "wander",
 523     "seek",
 524     "flee",
 525     "cornered",
 526     "panic",
 527     "lurk"
 528 };
 529
 530 static const char* _behaviour_name(beh_type beh)
 531 {
 532     if (0 <= beh && beh < static_cast<int>(ARRAYSZ(_monster_behaviour_names)))
 533         return (_monster_behaviour_names[beh]);
 534     else
 535         return ("invalid");
 536 }
 537
 538 static beh_type behaviour_by_name(const std::string &name)
 539 {
 540     ASSERT(ARRAYSZ(_monster_behaviour_names) == NUM_BEHAVIOURS);
 541
 542     for (unsigned i = 0; i < ARRAYSZ(_monster_behaviour_names); ++i)
 543         if (name == _monster_behaviour_names[i])
 544             return static_cast<beh_type>(i);
 545
 546     return NUM_BEHAVIOURS;
 547 }
 548
 549 static int monster_set(lua_State *ls)
 550 {
 551     // Changing monster behaviour is for the dungeon builder only,
 552     // never for user scripts.
 553     ASSERT_DLUA;
 554
 555     MonsterWrap *mw = clua_get_userdata< MonsterWrap >(ls, MONS_METATABLE);
 556     if (!mw || !mw->mons)
 557         return (0);
 558
 559     const char *attr = luaL_checkstring(ls, 2);
 560     if (!attr)
 561         return (0);
 562
 563     if (!strcmp(attr, "beh"))
 564     {
 565         const beh_type beh =
 566             lua_isnumber(ls, 3) ? static_cast<beh_type>(luaL_checkint(ls, 3)) :
 567             lua_isstring(ls, 3) ? behaviour_by_name(lua_tostring(ls, 3))
 568                                 : NUM_BEHAVIOURS;
 569
 570         if (beh != NUM_BEHAVIOURS)
 571             mw->mons->behaviour = beh;
 572     }
 573     else if (!strcmp(attr, "targetx"))
 574         mw->mons->target.x = luaL_checkint(ls, 3);
 575     else if (!strcmp(attr, "targety"))
 576         mw->mons->target.y = luaL_checkint(ls, 3);
 577
 578     return (0);
 579 }
 580
 581 static int mons_behaviour(lua_State *ls)
 582 {
 583     if (lua_gettop(ls) < 1)
 584         return (0);
 585
 586     if (lua_isnumber(ls, 1))
 587     {
 588         lua_pushvalue(ls, 1);
 589         return (1);
 590     }
 591     else if (lua_isstring(ls, 1))
 592     {
 593         const beh_type beh = behaviour_by_name(lua_tostring(ls, 1));
 594         if (beh != NUM_BEHAVIOURS)
 595         {
 596             lua_pushnumber(ls, beh);
 597             return (1);
 598         }
 599     }
 600     return (0);
 601 }
 602
 603 static const struct luaL_reg mons_lib[] =
 604 {
 605     { "behaviour", mons_behaviour },
 606     { NULL, NULL }
 607 };
 608
 609 void dluaopen_monsters(lua_State *ls)
 610 {
 611     lua_stack_cleaner stack_clean(ls);
 612     luaL_newmetatable(ls, MONS_METATABLE);
 613     lua_pushstring(ls, "__index");
 614     lua_pushcfunction(ls, monster_get);
 615     lua_settable(ls, -3);
 616
 617     lua_pushstring(ls, "__newindex");
 618     lua_pushcfunction(ls, monster_set);
 619     lua_settable(ls, -3);
 620     luaL_register(ls, "mons", mons_lib);
 621 }