931 lines
38 KiB
C++
931 lines
38 KiB
C++
/*
|
|
* monster.cpp
|
|
* BoE
|
|
*
|
|
* Created by Celtic Minstrel on 20/04/09.
|
|
*
|
|
*/
|
|
|
|
#include "monster.hpp"
|
|
|
|
#include <string>
|
|
#include <vector>
|
|
#include <map>
|
|
#include <sstream>
|
|
#include <iostream>
|
|
#include <iomanip>
|
|
#include <boost/lexical_cast.hpp>
|
|
|
|
#include "oldstructs.hpp"
|
|
#include "fileio/fileio.hpp"
|
|
#include "fileio/tagfile.hpp"
|
|
#include "spell.hpp"
|
|
#include "gfx/gfxsheets.hpp" // for NO_PIC
|
|
|
|
void cMonster::import_legacy(legacy::monster_record_type& old){
|
|
level = old.level;
|
|
m_name = std::string((char*) old.m_name, 26);
|
|
m_name.erase(m_name.begin() + m_name.find_first_of('\0'), m_name.end());
|
|
m_health = old.m_health;
|
|
armor = old.armor;
|
|
skill = old.skill;
|
|
for(int i = 0; i < 3; i++) {
|
|
a[i].dice = old.a[i] / 100;
|
|
a[i].sides = old.a[i] % 100;
|
|
}
|
|
a[0].type = eMonstMelee(old.a1_type);
|
|
a[1].type = a[2].type = eMonstMelee(old.a23_type);
|
|
// Unless human, add 3 to the monster's type to get its race
|
|
// This is because nephil, slith, and vahnatai were inserted
|
|
if(old.m_type) m_type = eRace(old.m_type + 3);
|
|
else m_type = eRace::HUMAN;
|
|
speed = old.speed;
|
|
mu = old.mu;
|
|
cl = old.cl;
|
|
treasure = old.treasure;
|
|
invisible = mindless = invuln = guard = false;
|
|
abil.clear();
|
|
switch(old.spec_skill) {
|
|
case 1: addAbil(eMonstAbilTemplate::THROWS_DARTS); break;
|
|
case 2: addAbil(eMonstAbilTemplate::SHOOTS_ARROWS); break;
|
|
case 3: addAbil(eMonstAbilTemplate::THROWS_SPEARS); break;
|
|
case 4: addAbil(eMonstAbilTemplate::THROWS_ROCKS1); break;
|
|
case 5: addAbil(eMonstAbilTemplate::THROWS_ROCKS2); break;
|
|
case 6: addAbil(eMonstAbilTemplate::THROWS_ROCKS3); break;
|
|
case 7: addAbil(eMonstAbilTemplate::THROWS_RAZORDISKS); break;
|
|
case 8: addAbil(eMonstAbilTemplate::RAY_PETRIFY); break;
|
|
case 9: addAbil(eMonstAbilTemplate::RAY_SP_DRAIN); break;
|
|
case 10: addAbil(eMonstAbilTemplate::RAY_HEAT); break;
|
|
case 11: invisible = true; break;
|
|
case 12: addAbil(eMonstAbilTemplate::SPLITS); break;
|
|
case 13: mindless = true; break;
|
|
case 14: addAbil(eMonstAbilTemplate::BREATH_FOUL); break;
|
|
case 15: addAbil(eMonstAbilTemplate::TOUCH_ICY); break;
|
|
case 17: addAbil(eMonstAbilTemplate::TOUCH_ICY_DRAINING); break;
|
|
case 16: addAbil(eMonstAbilTemplate::TOUCH_XP_DRAIN); break;
|
|
case 18: addAbil(eMonstAbilTemplate::TOUCH_STUN); break;
|
|
case 19: addAbil(eMonstAbilTemplate::SHOOTS_WEB); break;
|
|
case 20: addAbil(eMonstAbilTemplate::GOOD_ARCHER); break;
|
|
case 21: addAbil(eMonstAbilTemplate::TOUCH_STEAL_FOOD); break;
|
|
case 22: addAbil(eMonstAbilTemplate::MARTYRS_SHIELD); break;
|
|
case 23: addAbil(eMonstAbilTemplate::RAY_PARALYSIS); break;
|
|
case 24: addAbil(eMonstAbilTemplate::TOUCH_DUMB); break;
|
|
case 25: addAbil(eMonstAbilTemplate::TOUCH_DISEASE); break;
|
|
case 26: addAbil(eMonstAbilTemplate::ABSORB_SPELLS); break;
|
|
case 27: addAbil(eMonstAbilTemplate::TOUCH_WEB); break;
|
|
case 28: addAbil(eMonstAbilTemplate::TOUCH_SLEEP); break;
|
|
case 29: addAbil(eMonstAbilTemplate::TOUCH_PARALYSIS); break;
|
|
case 30: addAbil(eMonstAbilTemplate::TOUCH_PETRIFY); break;
|
|
case 31: addAbil(eMonstAbilTemplate::TOUCH_ACID); break;
|
|
case 32: addAbil(eMonstAbilTemplate::BREATH_SLEEP); break;
|
|
case 33: addAbil(eMonstAbilTemplate::SPIT_ACID); break;
|
|
case 34: addAbil(eMonstAbilTemplate::SHOOTS_SPINES); break;
|
|
case 35: addAbil(eMonstAbilTemplate::TOUCH_DEATH); break;
|
|
case 36: invuln = true; break;
|
|
case 37: guard = true; break;
|
|
}
|
|
switch(old.radiate_1) {
|
|
case 1: addAbil(eMonstAbilTemplate::RADIATE_FIRE, old.radiate_2); break;
|
|
case 2: addAbil(eMonstAbilTemplate::RADIATE_ICE, old.radiate_2); break;
|
|
case 3: addAbil(eMonstAbilTemplate::RADIATE_SHOCK, old.radiate_2); break;
|
|
case 4: addAbil(eMonstAbilTemplate::RADIATE_ANTIMAGIC, old.radiate_2); break;
|
|
case 5: addAbil(eMonstAbilTemplate::RADIATE_SLEEP, old.radiate_2); break;
|
|
case 6: addAbil(eMonstAbilTemplate::RADIATE_STINK, old.radiate_2); break;
|
|
case 10: addAbil(eMonstAbilTemplate::SUMMON_5, old.radiate_2); break;
|
|
case 11: addAbil(eMonstAbilTemplate::SUMMON_20, old.radiate_2); break;
|
|
case 12: addAbil(eMonstAbilTemplate::SUMMON_50, old.radiate_2); break;
|
|
case 15: addAbil(eMonstAbilTemplate::DEATH_TRIGGERS, old.radiate_2); break;
|
|
}
|
|
if(old.poison > 0) addAbil(eMonstAbilTemplate::TOUCH_POISON, old.poison);
|
|
if(old.breath > 0) {
|
|
switch(old.breath_type) {
|
|
case 0: addAbil(eMonstAbilTemplate::BREATH_FIRE, old.breath); break;
|
|
case 1: addAbil(eMonstAbilTemplate::BREATH_FROST, old.breath); break;
|
|
case 2: addAbil(eMonstAbilTemplate::BREATH_ELECTRICITY, old.breath); break;
|
|
case 3: addAbil(eMonstAbilTemplate::BREATH_DARKNESS, old.breath); break;
|
|
}
|
|
}
|
|
corpse_item = old.corpse_item;
|
|
corpse_item_chance = old.corpse_item_chance;
|
|
if(old.immunities & 2)
|
|
resist[eDamageType::MAGIC] = 0;
|
|
else if(old.immunities & 1)
|
|
resist[eDamageType::MAGIC] = 50;
|
|
else resist[eDamageType::MAGIC] = 100;
|
|
if(old.immunities & 8)
|
|
resist[eDamageType::FIRE] = 0;
|
|
else if(old.immunities & 4)
|
|
resist[eDamageType::FIRE] = 50;
|
|
else resist[eDamageType::FIRE] = 100;
|
|
if(old.immunities & 32)
|
|
resist[eDamageType::COLD] = 0;
|
|
else if(old.immunities & 16)
|
|
resist[eDamageType::COLD] = 50;
|
|
else resist[eDamageType::COLD] = 100;
|
|
if(old.immunities & 128)
|
|
resist[eDamageType::POISON] = 0;
|
|
else if(old.immunities & 64)
|
|
resist[eDamageType::POISON] = 50;
|
|
else resist[eDamageType::POISON] = 100;
|
|
x_width = old.x_width;
|
|
y_width = old.y_width;
|
|
default_attitude = eAttitude(old.default_attitude);
|
|
summon_type = old.summon_type;
|
|
default_facial_pic = old.default_facial_pic;
|
|
if(default_facial_pic == 0)
|
|
default_facial_pic = NO_PIC;
|
|
else default_facial_pic--;
|
|
picture_num = old.picture_num;
|
|
if(picture_num == 122) picture_num = 119;
|
|
see_spec = -1;
|
|
}
|
|
|
|
int cMonster::addAttack(unsigned short dice, unsigned short sides, eMonstMelee type) {
|
|
int which = 0;
|
|
while(which < a.size() && a[which].dice > 0 && a[which].sides > 0)
|
|
which++;
|
|
if(which >= a.size()) return -1;
|
|
a[which].dice = dice;
|
|
a[which].sides = sides;
|
|
a[which].type = type;
|
|
return which;
|
|
}
|
|
|
|
std::map<eMonstAbil,uAbility>::iterator cMonster::addAbil(eMonstAbilTemplate what, int param) {
|
|
switch(what) {
|
|
// Missiles: {true, type, missile pic, dice, sides, skill, range, odds}
|
|
case eMonstAbilTemplate::THROWS_DARTS:
|
|
abil[eMonstAbil::MISSILE].missile = {true, eMonstMissile::DART, 1, 1, 7, 2, 6, 500};
|
|
return abil.find(eMonstAbil::MISSILE);
|
|
case eMonstAbilTemplate::SHOOTS_ARROWS:
|
|
abil[eMonstAbil::MISSILE].missile = {true, eMonstMissile::ARROW, 3, 2, 7, 4, 8, 750};
|
|
return abil.find(eMonstAbil::MISSILE);
|
|
case eMonstAbilTemplate::THROWS_SPEARS:
|
|
abil[eMonstAbil::MISSILE].missile = {true, eMonstMissile::SPEAR, 5, 3, 7, 6, 8, 625};
|
|
return abil.find(eMonstAbil::MISSILE);
|
|
case eMonstAbilTemplate::THROWS_ROCKS1:
|
|
abil[eMonstAbil::MISSILE].missile = {true, eMonstMissile::BOULDER, 12, 4, 7, 8, 10, 625};
|
|
return abil.find(eMonstAbil::MISSILE);
|
|
case eMonstAbilTemplate::THROWS_ROCKS2:
|
|
abil[eMonstAbil::MISSILE].missile = {true, eMonstMissile::BOULDER, 12, 6, 7, 12, 10, 500};
|
|
return abil.find(eMonstAbil::MISSILE);
|
|
case eMonstAbilTemplate::THROWS_ROCKS3:
|
|
abil[eMonstAbil::MISSILE].missile = {true, eMonstMissile::BOULDER, 12, 8, 7, 16, 10, 500};
|
|
return abil.find(eMonstAbil::MISSILE);
|
|
case eMonstAbilTemplate::THROWS_RAZORDISKS:
|
|
abil[eMonstAbil::MISSILE].missile = {true, eMonstMissile::RAZORDISK, 7, 7, 7, 14, 8, 625};
|
|
return abil.find(eMonstAbil::MISSILE);
|
|
case eMonstAbilTemplate::THROWS_KNIVES:
|
|
abil[eMonstAbil::MISSILE].missile = {true, eMonstMissile::KNIFE, 10, 2, 7, 2, 6, 500};
|
|
return abil.find(eMonstAbil::MISSILE);
|
|
case eMonstAbilTemplate::GOOD_ARCHER:
|
|
abil[eMonstAbil::MISSILE].missile = {true, eMonstMissile::RAPID_ARROW, 3, 8, 7, 16, 10, 875};
|
|
return abil.find(eMonstAbil::MISSILE);
|
|
case eMonstAbilTemplate::SHOOTS_SPINES:
|
|
abil[eMonstAbil::MISSILE].missile = {true, eMonstMissile::SPINE, 5, 6, 7, 12, 9, 625};
|
|
return abil.find(eMonstAbil::MISSILE);
|
|
case eMonstAbilTemplate::CROSSBOWMAN:
|
|
abil[eMonstAbil::MISSILE].missile = {true, eMonstMissile::BOLT, 3, 10, 7, 16, 10, 875};
|
|
return abil.find(eMonstAbil::MISSILE);
|
|
case eMonstAbilTemplate::SLINGER:
|
|
abil[eMonstAbil::MISSILE].missile = {true, eMonstMissile::ROCK, 12, 2, 7, 3, 8, 750};
|
|
return abil.find(eMonstAbil::MISSILE);
|
|
// Magical missiles: {true, type, missile pic, strength, range, odds}
|
|
case eMonstAbilTemplate::RAY_PETRIFY:
|
|
abil[eMonstAbil::PETRIFY].gen = {true, eMonstGen::GAZE, -1, 25, 6, 625};
|
|
return abil.find(eMonstAbil::PETRIFY);
|
|
case eMonstAbilTemplate::RAY_SP_DRAIN:
|
|
abil[eMonstAbil::DRAIN_SP].gen = {true, eMonstGen::GAZE, 8, 50, 8, 625};
|
|
return abil.find(eMonstAbil::DRAIN_SP);
|
|
case eMonstAbilTemplate::RAY_HEAT:
|
|
abil[eMonstAbil::RAY_HEAT].special = {true, 6, 625, 7};
|
|
return abil.find(eMonstAbil::RAY_HEAT);
|
|
case eMonstAbilTemplate::RAY_PARALYSIS:
|
|
abil[eMonstAbil::STATUS].gen = {true, eMonstGen::RAY, -1, 100, 6, 750};
|
|
abil[eMonstAbil::STATUS].gen.stat = eStatus::PARALYZED;
|
|
return abil.find(eMonstAbil::STATUS);
|
|
case eMonstAbilTemplate::BREATH_FIRE:
|
|
abil[eMonstAbil::DAMAGE2].gen = {true, eMonstGen::BREATH, 13, param, 8, 375};
|
|
abil[eMonstAbil::DAMAGE2].gen.dmg = eDamageType::FIRE;
|
|
return abil.find(eMonstAbil::DAMAGE2);
|
|
case eMonstAbilTemplate::BREATH_FROST:
|
|
abil[eMonstAbil::DAMAGE2].gen = {true, eMonstGen::BREATH, 6, param, 8, 375};
|
|
abil[eMonstAbil::DAMAGE2].gen.dmg = eDamageType::COLD;
|
|
return abil.find(eMonstAbil::DAMAGE2);
|
|
case eMonstAbilTemplate::BREATH_ELECTRICITY:
|
|
abil[eMonstAbil::DAMAGE2].gen = {true, eMonstGen::BREATH, 8, param, 8, 375};
|
|
abil[eMonstAbil::DAMAGE2].gen.dmg = eDamageType::MAGIC;
|
|
return abil.find(eMonstAbil::DAMAGE2);
|
|
case eMonstAbilTemplate::BREATH_DARKNESS:
|
|
abil[eMonstAbil::DAMAGE2].gen = {true, eMonstGen::BREATH, 8, param, 8, 375};
|
|
abil[eMonstAbil::DAMAGE2].gen.dmg = eDamageType::UNBLOCKABLE;
|
|
return abil.find(eMonstAbil::DAMAGE2);
|
|
case eMonstAbilTemplate::BREATH_FOUL:
|
|
abil[eMonstAbil::FIELD].gen = {true, eMonstGen::BREATH, 12, PAT_SINGLE, 6, 375};
|
|
abil[eMonstAbil::FIELD].gen.fld = eFieldType::CLOUD_STINK;
|
|
return abil.find(eMonstAbil::FIELD);
|
|
case eMonstAbilTemplate::BREATH_SLEEP:
|
|
abil[eMonstAbil::FIELD].gen = {true, eMonstGen::BREATH, 0, PAT_RAD2, 8, 750};
|
|
abil[eMonstAbil::FIELD].gen.fld = eFieldType::CLOUD_SLEEP;
|
|
return abil.find(eMonstAbil::FIELD);
|
|
case eMonstAbilTemplate::SPIT_ACID:
|
|
abil[eMonstAbil::STATUS].gen = {true, eMonstGen::SPIT, 0, 6, 6, 500};
|
|
abil[eMonstAbil::STATUS].gen.stat = eStatus::ACID;
|
|
return abil.find(eMonstAbil::STATUS);
|
|
case eMonstAbilTemplate::SHOOTS_WEB:
|
|
abil[eMonstAbil::MISSILE_WEB].special = {true, 4, 375};
|
|
return abil.find(eMonstAbil::MISSILE_WEB);
|
|
// Touch abilities
|
|
case eMonstAbilTemplate::TOUCH_POISON:
|
|
abil[eMonstAbil::STATUS2].gen = {true, eMonstGen::TOUCH, -1, param, 0, 1000};
|
|
abil[eMonstAbil::STATUS2].gen.stat = eStatus::POISON;
|
|
return abil.find(eMonstAbil::STATUS2);
|
|
case eMonstAbilTemplate::TOUCH_ACID:
|
|
abil[eMonstAbil::STATUS].gen = {true, eMonstGen::TOUCH, -1, level > 20 ? 4 : 2, 0, 1000};
|
|
abil[eMonstAbil::STATUS].gen.stat = eStatus::ACID;
|
|
return abil.find(eMonstAbil::STATUS);
|
|
case eMonstAbilTemplate::TOUCH_DISEASE:
|
|
abil[eMonstAbil::STATUS].gen = {true, eMonstGen::TOUCH, -1, 6, 0, 667};
|
|
abil[eMonstAbil::STATUS].gen.stat = eStatus::DISEASE;
|
|
return abil.find(eMonstAbil::STATUS);
|
|
case eMonstAbilTemplate::TOUCH_WEB:
|
|
abil[eMonstAbil::STATUS].gen = {true, eMonstGen::TOUCH, -1, 5, 0, 1000};
|
|
abil[eMonstAbil::STATUS].gen.stat = eStatus::WEBS;
|
|
return abil.find(eMonstAbil::STATUS);
|
|
case eMonstAbilTemplate::TOUCH_SLEEP:
|
|
abil[eMonstAbil::STATUS].gen = {true, eMonstGen::TOUCH, -1, 6, 0, 1000};
|
|
abil[eMonstAbil::STATUS].gen.stat = eStatus::ASLEEP;
|
|
return abil.find(eMonstAbil::STATUS);
|
|
case eMonstAbilTemplate::TOUCH_DUMB:
|
|
abil[eMonstAbil::STATUS].gen = {true, eMonstGen::TOUCH, -1, 2, 0, 1000};
|
|
abil[eMonstAbil::STATUS].gen.stat = eStatus::DUMB;
|
|
return abil.find(eMonstAbil::STATUS);
|
|
case eMonstAbilTemplate::TOUCH_PARALYSIS:
|
|
abil[eMonstAbil::STATUS].gen = {true, eMonstGen::TOUCH, -1, 500};
|
|
abil[eMonstAbil::STATUS].gen.stat = eStatus::PARALYZED;
|
|
return abil.find(eMonstAbil::STATUS);
|
|
case eMonstAbilTemplate::TOUCH_PETRIFY:
|
|
abil[eMonstAbil::PETRIFY].gen = {true, eMonstGen::TOUCH, -1, 25};
|
|
return abil.find(eMonstAbil::PETRIFY);
|
|
case eMonstAbilTemplate::TOUCH_DEATH:
|
|
abil[eMonstAbil::KILL].gen = {true, eMonstGen::TOUCH, -1, 2, 0, 667};
|
|
return abil.find(eMonstAbil::KILL);
|
|
case eMonstAbilTemplate::TOUCH_ICY:
|
|
case eMonstAbilTemplate::TOUCH_ICY_DRAINING:
|
|
abil[eMonstAbil::DAMAGE].gen = {true, eMonstGen::TOUCH, -1, 3, 0, 667};
|
|
abil[eMonstAbil::DAMAGE].gen.dmg = eDamageType::COLD;
|
|
if(what == eMonstAbilTemplate::TOUCH_ICY)
|
|
return abil.find(eMonstAbil::DAMAGE);
|
|
BOOST_FALLTHROUGH;
|
|
case eMonstAbilTemplate::TOUCH_XP_DRAIN:
|
|
abil[eMonstAbil::DRAIN_XP].gen = {true, eMonstGen::TOUCH, -1, 150};
|
|
return abil.find(eMonstAbil::DRAIN_XP);
|
|
case eMonstAbilTemplate::TOUCH_STUN:
|
|
abil[eMonstAbil::STUN].gen = {true, eMonstGen::TOUCH, -1, 2, 0, 667};
|
|
abil[eMonstAbil::STUN].gen.stat = eStatus::HASTE_SLOW;
|
|
return abil.find(eMonstAbil::STUN);
|
|
case eMonstAbilTemplate::TOUCH_STEAL_FOOD:
|
|
abil[eMonstAbil::STEAL_FOOD].gen = {true, eMonstGen::TOUCH, -1, 10, 0, 667};
|
|
return abil.find(eMonstAbil::STEAL_FOOD);
|
|
case eMonstAbilTemplate::TOUCH_STEAL_GOLD:
|
|
abil[eMonstAbil::STEAL_GOLD].gen = {true, eMonstGen::TOUCH, -1, 10, 0, 667};
|
|
return abil.find(eMonstAbil::STEAL_GOLD);
|
|
// Misc abilities
|
|
case eMonstAbilTemplate::SPLITS:
|
|
abil[eMonstAbil::SPLITS].special = {true, 1000, 0, 0};
|
|
amorphous = true;
|
|
return abil.find(eMonstAbil::SPLITS);
|
|
case eMonstAbilTemplate::MARTYRS_SHIELD:
|
|
abil[eMonstAbil::MARTYRS_SHIELD].special = {true, 1000, 100, 0};
|
|
return abil.find(eMonstAbil::MARTYRS_SHIELD);
|
|
case eMonstAbilTemplate::ABSORB_SPELLS:
|
|
abil[eMonstAbil::ABSORB_SPELLS].special = {true, 1000, 3, 0};
|
|
return abil.find(eMonstAbil::ABSORB_SPELLS);
|
|
case eMonstAbilTemplate::SUMMON_5:
|
|
abil[eMonstAbil::SUMMON].summon = {true, eMonstSummon::TYPE, static_cast<mon_num_t>(param), 1, 1, 130, 50};
|
|
return abil.find(eMonstAbil::SUMMON);
|
|
case eMonstAbilTemplate::SUMMON_20:
|
|
abil[eMonstAbil::SUMMON].summon = {true, eMonstSummon::TYPE, static_cast<mon_num_t>(param), 1, 1, 130, 200};
|
|
return abil.find(eMonstAbil::SUMMON);
|
|
case eMonstAbilTemplate::SUMMON_50:
|
|
abil[eMonstAbil::SUMMON].summon = {true, eMonstSummon::TYPE, static_cast<mon_num_t>(param), 1, 1, 130, 500};
|
|
return abil.find(eMonstAbil::SUMMON);
|
|
case eMonstAbilTemplate::SPECIAL:
|
|
abil[eMonstAbil::SPECIAL].special = {true, param, 1};
|
|
return abil.find(eMonstAbil::SPECIAL);
|
|
case eMonstAbilTemplate::HIT_TRIGGERS:
|
|
abil[eMonstAbil::HIT_TRIGGER].special = {true, param, 0};
|
|
return abil.find(eMonstAbil::HIT_TRIGGER);
|
|
case eMonstAbilTemplate::DEATH_TRIGGERS:
|
|
abil[eMonstAbil::DEATH_TRIGGER].special = {true, param, 0};
|
|
return abil.find(eMonstAbil::DEATH_TRIGGER);
|
|
// Radiate abilities
|
|
case eMonstAbilTemplate::RADIATE_FIRE:
|
|
abil[eMonstAbil::RADIATE].radiate = {true, eFieldType::WALL_FIRE, param, PAT_SQ};
|
|
return abil.find(eMonstAbil::RADIATE);
|
|
case eMonstAbilTemplate::RADIATE_ICE:
|
|
abil[eMonstAbil::RADIATE].radiate = {true, eFieldType::WALL_ICE, param, PAT_SQ};
|
|
return abil.find(eMonstAbil::RADIATE);
|
|
case eMonstAbilTemplate::RADIATE_SHOCK:
|
|
abil[eMonstAbil::RADIATE].radiate = {true, eFieldType::WALL_FORCE, param, PAT_SQ};
|
|
return abil.find(eMonstAbil::RADIATE);
|
|
case eMonstAbilTemplate::RADIATE_ANTIMAGIC:
|
|
abil[eMonstAbil::RADIATE].radiate = {true, eFieldType::FIELD_ANTIMAGIC, param, PAT_SQ};
|
|
return abil.find(eMonstAbil::RADIATE);
|
|
case eMonstAbilTemplate::RADIATE_SLEEP:
|
|
abil[eMonstAbil::RADIATE].radiate = {true, eFieldType::CLOUD_SLEEP, param, PAT_SQ};
|
|
return abil.find(eMonstAbil::RADIATE);
|
|
case eMonstAbilTemplate::RADIATE_STINK:
|
|
abil[eMonstAbil::RADIATE].radiate = {true, eFieldType::CLOUD_STINK, param, PAT_SQ};
|
|
return abil.find(eMonstAbil::RADIATE);
|
|
case eMonstAbilTemplate::RADIATE_BLADE:
|
|
abil[eMonstAbil::RADIATE].radiate = {true, eFieldType::WALL_BLADES, param, PAT_SQ};
|
|
return abil.find(eMonstAbil::RADIATE);
|
|
case eMonstAbilTemplate::RADIATE_WEB:
|
|
abil[eMonstAbil::RADIATE].radiate = {true, eFieldType::FIELD_WEB, param, PAT_SQ};
|
|
return abil.find(eMonstAbil::RADIATE);
|
|
// Advanced abilities
|
|
case eMonstAbilTemplate::CUSTOM_MISSILE:
|
|
abil[eMonstAbil::MISSILE].active = true;
|
|
return abil.find(eMonstAbil::MISSILE);
|
|
case eMonstAbilTemplate::CUSTOM_DAMAGE:
|
|
abil[eMonstAbil::DAMAGE].active = true;
|
|
return abil.find(eMonstAbil::DAMAGE);
|
|
case eMonstAbilTemplate::CUSTOM_DAMAGE2:
|
|
abil[eMonstAbil::DAMAGE2].active = true;
|
|
return abil.find(eMonstAbil::DAMAGE2);
|
|
case eMonstAbilTemplate::CUSTOM_STATUS:
|
|
abil[eMonstAbil::STATUS].active = true;
|
|
return abil.find(eMonstAbil::STATUS);
|
|
case eMonstAbilTemplate::CUSTOM_FIELD:
|
|
abil[eMonstAbil::FIELD].active = true;
|
|
return abil.find(eMonstAbil::FIELD);
|
|
case eMonstAbilTemplate::CUSTOM_PETRIFY:
|
|
abil[eMonstAbil::PETRIFY].active = true;
|
|
return abil.find(eMonstAbil::PETRIFY);
|
|
case eMonstAbilTemplate::CUSTOM_SP_DRAIN:
|
|
abil[eMonstAbil::DRAIN_SP].active = true;
|
|
return abil.find(eMonstAbil::DRAIN_SP);
|
|
case eMonstAbilTemplate::CUSTOM_XP_DRAIN:
|
|
abil[eMonstAbil::DRAIN_XP].active = true;
|
|
return abil.find(eMonstAbil::DRAIN_XP);
|
|
case eMonstAbilTemplate::CUSTOM_KILL:
|
|
abil[eMonstAbil::KILL].active = true;
|
|
return abil.find(eMonstAbil::KILL);
|
|
case eMonstAbilTemplate::CUSTOM_STEAL_FOOD:
|
|
abil[eMonstAbil::STEAL_FOOD].active = true;
|
|
return abil.find(eMonstAbil::STEAL_FOOD);
|
|
case eMonstAbilTemplate::CUSTOM_STEAL_GOLD:
|
|
abil[eMonstAbil::STEAL_GOLD].active = true;
|
|
return abil.find(eMonstAbil::STEAL_GOLD);
|
|
case eMonstAbilTemplate::CUSTOM_STUN:
|
|
abil[eMonstAbil::STUN].active = true;
|
|
return abil.find(eMonstAbil::STUN);
|
|
case eMonstAbilTemplate::CUSTOM_STATUS2:
|
|
abil[eMonstAbil::STATUS2].active = true;
|
|
return abil.find(eMonstAbil::STATUS2);
|
|
case eMonstAbilTemplate::CUSTOM_RADIATE:
|
|
abil[eMonstAbil::RADIATE].active = true;
|
|
return abil.find(eMonstAbil::RADIATE);
|
|
case eMonstAbilTemplate::CUSTOM_SUMMON:
|
|
abil[eMonstAbil::SUMMON].active = true;
|
|
return abil.find(eMonstAbil::SUMMON);
|
|
}
|
|
return abil.end();
|
|
}
|
|
|
|
cMonster::cMonster(){
|
|
for(int i = 0; i <= int(eDamageType::SPECIAL); i++) {
|
|
eDamageType dmg = eDamageType(i);
|
|
resist[dmg] = 100;
|
|
}
|
|
// And just in case something weird happens:
|
|
resist[eDamageType::MARKED] = 100;
|
|
amorphous = mindless = invuln = guard = invisible = false;
|
|
level = m_health = armor = skill = 0;
|
|
speed = 4;
|
|
default_facial_pic = 0;
|
|
default_attitude = eAttitude::DOCILE;
|
|
ambient_sound = -1;
|
|
corpse_item = corpse_item_chance = treasure = 0;
|
|
mu = cl = 0;
|
|
summon_type = 0;
|
|
picture_num = 149;
|
|
x_width = y_width = 1;
|
|
see_spec = -1;
|
|
m_type = eRace::HUMAN;
|
|
}
|
|
|
|
cTownperson::cTownperson() {
|
|
start_loc = {80,80};
|
|
number = 0;
|
|
mobility = 1;
|
|
time_flag = eMonstTime::ALWAYS;
|
|
spec1 = -1;
|
|
spec2 = -1;
|
|
spec_enc_code = 0;
|
|
time_code = 0;
|
|
monster_time = 0;
|
|
personality = -1;
|
|
special_on_kill = -1;
|
|
special_on_talk = -1;
|
|
facial_pic = -1;
|
|
start_attitude = eAttitude::DOCILE;
|
|
}
|
|
|
|
cTownperson::cTownperson(location loc, mon_num_t num, const cMonster& monst) : cTownperson() {
|
|
start_loc = loc;
|
|
number = num;
|
|
start_attitude = monst.default_attitude;
|
|
facial_pic = monst.default_facial_pic;
|
|
}
|
|
|
|
void cTownperson::import_legacy(legacy::creature_start_type old){
|
|
number = old.number;
|
|
start_attitude = eAttitude(old.start_attitude);
|
|
start_loc.x = old.start_loc.x;
|
|
start_loc.y = old.start_loc.y;
|
|
mobility = old.mobile;
|
|
switch(old.time_flag) {
|
|
case 0: time_flag = eMonstTime::ALWAYS; break;
|
|
case 1: time_flag = eMonstTime::APPEAR_ON_DAY; break;
|
|
case 2: time_flag = eMonstTime::DISAPPEAR_ON_DAY; break;
|
|
case 4: time_flag = eMonstTime::SOMETIMES_A; break;
|
|
case 5: time_flag = eMonstTime::SOMETIMES_B; break;
|
|
case 6: time_flag = eMonstTime::SOMETIMES_C; break;
|
|
case 7: time_flag = eMonstTime::APPEAR_WHEN_EVENT; break;
|
|
case 8: time_flag = eMonstTime::DISAPPEAR_WHEN_EVENT; break;
|
|
}
|
|
spec1 = old.spec1;
|
|
spec2 = old.spec2;
|
|
spec_enc_code = old.spec_enc_code;
|
|
time_code = old.time_code;
|
|
monster_time = old.monster_time;
|
|
personality = old.personality;
|
|
special_on_kill = old.special_on_kill;
|
|
facial_pic = old.facial_pic;
|
|
if(facial_pic == 0)
|
|
facial_pic = NO_PIC;
|
|
else facial_pic--;
|
|
}
|
|
|
|
std::ostream& operator<<(std::ostream& out, const cMonster::cAttack& att) {
|
|
out << int(att.dice) << 'd' << int(att.sides);
|
|
return out;
|
|
}
|
|
|
|
std::string uAbility::to_string(eMonstAbil key) const {
|
|
std::ostringstream sout;
|
|
switch(getMonstAbilCategory(key)){
|
|
case eMonstAbilCat::INVALID: break;
|
|
case eMonstAbilCat::MISSILE:
|
|
switch(missile.type) {
|
|
case eMonstMissile::DART:
|
|
sout << "Throws darts (" << missile.dice << 'd' << missile.sides << ')';
|
|
break;
|
|
case eMonstMissile::ARROW:
|
|
sout << "Shoots arrows (" << missile.dice << 'd' << missile.sides << ')';
|
|
break;
|
|
case eMonstMissile::RAPID_ARROW:
|
|
sout << "Good archer (" << missile.dice << 'd' << missile.sides << ')';
|
|
break;
|
|
case eMonstMissile::BOLT:
|
|
sout << "Shoots bolts (" << missile.dice << 'd' << missile.sides << ')';
|
|
break;
|
|
case eMonstMissile::SPEAR:
|
|
sout << "Throws spears (" << missile.dice << 'd' << missile.sides << ')';
|
|
break;
|
|
case eMonstMissile::ROCK:
|
|
sout << "Throws stones (" << missile.dice << 'd' << missile.sides << ')';
|
|
break;
|
|
case eMonstMissile::BOULDER:
|
|
sout << "Throws rocks (" << missile.dice << 'd' << missile.sides << ')';
|
|
break;
|
|
case eMonstMissile::RAZORDISK:
|
|
sout << "Throws razordisks (" << missile.dice << 'd' << missile.sides << ')';
|
|
break;
|
|
case eMonstMissile::SPINE:
|
|
sout << "Shoots spines (" << missile.dice << 'd' << missile.sides << ')';
|
|
break;
|
|
case eMonstMissile::KNIFE:
|
|
sout << "Throws knives (" << missile.dice << 'd' << missile.sides << ')';
|
|
break;
|
|
}
|
|
break;
|
|
case eMonstAbilCat::GENERAL:
|
|
switch(key) {
|
|
// These first few aren't general-category abilities; they're included here just to silence compiler warnings
|
|
case eMonstAbil::NO_ABIL: case eMonstAbil::MISSILE: case eMonstAbil::SPLITS: case eMonstAbil::MARTYRS_SHIELD:
|
|
case eMonstAbil::ABSORB_SPELLS: case eMonstAbil::MISSILE_WEB: case eMonstAbil::RAY_HEAT: case eMonstAbil::SPECIAL:
|
|
case eMonstAbil::HIT_TRIGGER: case eMonstAbil::DEATH_TRIGGER: case eMonstAbil::RADIATE: case eMonstAbil::SUMMON:
|
|
break;
|
|
case eMonstAbil::STUN: sout << "Stunning"; break;
|
|
case eMonstAbil::PETRIFY: sout << "Petrifying"; break;
|
|
case eMonstAbil::DRAIN_SP: sout << "Spell point drain"; break;
|
|
case eMonstAbil::DRAIN_XP: sout << "Draining"; break;
|
|
case eMonstAbil::KILL: sout << "Death"; break;
|
|
case eMonstAbil::STEAL_FOOD: sout << "Steals food"; break;
|
|
case eMonstAbil::STEAL_GOLD: sout << "Steals gold"; break;
|
|
case eMonstAbil::FIELD:
|
|
switch(gen.fld) {
|
|
case eFieldType::SPECIAL_EXPLORED:
|
|
case eFieldType::SPECIAL_SPOT:
|
|
case eFieldType::SPECIAL_ROAD:
|
|
break; // These are invalid field types
|
|
case eFieldType::CLOUD_SLEEP: sout << "Sleep"; break;
|
|
case eFieldType::CLOUD_STINK: sout << "Foul"; break;
|
|
case eFieldType::WALL_FIRE: sout << "Fiery"; break;
|
|
case eFieldType::WALL_FORCE: sout << "Charged"; break;
|
|
case eFieldType::WALL_ICE: sout << "Frosted"; break;
|
|
case eFieldType::WALL_BLADES: sout << "Thorny"; break;
|
|
case eFieldType::FIELD_ANTIMAGIC: sout << "Null"; break;
|
|
case eFieldType::FIELD_WEB: sout << "Web"; break;
|
|
case eFieldType::FIELD_QUICKFIRE: sout << "Incendiary"; break;
|
|
case eFieldType::BARRIER_CAGE: sout << "Entrapping"; break;
|
|
case eFieldType::BARRIER_FIRE: case eFieldType::BARRIER_FORCE: sout << "Barrier"; break;
|
|
case eFieldType::FIELD_DISPEL: sout << "Dispelling"; break;
|
|
case eFieldType::FIELD_SMASH: sout << "Smashing"; break;
|
|
case eFieldType::OBJECT_BARREL: sout << "Barrel"; break;
|
|
case eFieldType::OBJECT_BLOCK: sout << "Stone Block"; break;
|
|
case eFieldType::OBJECT_CRATE: sout << "Crate"; break;
|
|
case eFieldType::SFX_ASH: case eFieldType::SFX_BONES: case eFieldType::SFX_RUBBLE:
|
|
case eFieldType::SFX_SMALL_BLOOD: case eFieldType::SFX_MEDIUM_BLOOD: case eFieldType::SFX_LARGE_BLOOD:
|
|
case eFieldType::SFX_SMALL_SLIME: case eFieldType::SFX_LARGE_SLIME:
|
|
sout << "Littering";
|
|
break;
|
|
}
|
|
break;
|
|
case eMonstAbil::DAMAGE: case eMonstAbil::DAMAGE2:
|
|
switch(gen.dmg) {
|
|
case eDamageType::FIRE: sout << "Fiery"; break;
|
|
case eDamageType::COLD: sout << "Icy"; break;
|
|
case eDamageType::MAGIC: sout << "Shock"; break;
|
|
case eDamageType::ACID: sout << "Acid"; break;
|
|
case eDamageType::SPECIAL:
|
|
case eDamageType::UNBLOCKABLE: sout << "Wounding"; break;
|
|
case eDamageType::POISON: sout << "Pain"; break;
|
|
case eDamageType::WEAPON: sout << "Stamina drain"; break;
|
|
case eDamageType::DEMON: sout << "Unholy"; break;
|
|
case eDamageType::UNDEAD: sout << "Necrotic"; break;
|
|
case eDamageType::MARKED: break; // Invalid
|
|
}
|
|
break;
|
|
case eMonstAbil::STATUS: case eMonstAbil::STATUS2:
|
|
switch(gen.stat) {
|
|
case eStatus::MAIN: break; // Invalid
|
|
case eStatus::POISON: sout << "Poison"; break;
|
|
case eStatus::DISEASE: sout << "Infectious"; break;
|
|
case eStatus::DUMB: sout << "Dumbfounding"; break;
|
|
case eStatus::WEBS: sout << "Glue"; break;
|
|
case eStatus::ASLEEP: sout << "Sleep"; break;
|
|
case eStatus::PARALYZED: sout << "Paralysis"; break;
|
|
case eStatus::ACID: sout << "Acid"; break;
|
|
case eStatus::HASTE_SLOW: sout << "Slowing"; break;
|
|
case eStatus::BLESS_CURSE: sout << "Curse"; break;
|
|
case eStatus::CHARM: sout << "Charming"; break;
|
|
case eStatus::FORCECAGE: sout << "Entrapping"; break;
|
|
case eStatus::INVISIBLE: sout << "Revealing"; break;
|
|
case eStatus::INVULNERABLE: sout << "Piercing"; break;
|
|
case eStatus::MAGIC_RESISTANCE: sout << "Overwhelming"; break;
|
|
case eStatus::MARTYRS_SHIELD: sout << "Anti-martyr's"; break;
|
|
case eStatus::POISONED_WEAPON: sout << "Poison-draining"; break;
|
|
}
|
|
break;
|
|
}
|
|
switch(gen.type) {
|
|
case eMonstGen::RAY: sout << " ray"; break;
|
|
case eMonstGen::TOUCH: sout << " touch"; break;
|
|
case eMonstGen::GAZE: sout << " gaze"; break;
|
|
case eMonstGen::BREATH: sout << " breath"; break;
|
|
case eMonstGen::SPIT: sout << " spit"; break;
|
|
}
|
|
if(key == eMonstAbil::DAMAGE || key == eMonstAbil::DAMAGE2) {
|
|
sout << " (" << gen.strength << ")";
|
|
} else if(key == eMonstAbil::STATUS || key == eMonstAbil::STATUS2 || key == eMonstAbil::STUN) {
|
|
sout << " (" << gen.strength;
|
|
switch(gen.type) {
|
|
case eMonstGen::RAY: sout << "d6"; break;
|
|
case eMonstGen::TOUCH: sout << "d10"; break;
|
|
case eMonstGen::GAZE: sout << "d6"; break;
|
|
case eMonstGen::BREATH: sout << "d8"; break;
|
|
case eMonstGen::SPIT: sout << "d10"; break;
|
|
}
|
|
sout << ")";
|
|
} else if(key == eMonstAbil::FIELD && gen.strength != PAT_SINGLE) {
|
|
sout << " (";
|
|
switch(eSpellPat(gen.strength)) {
|
|
case PAT_CURRENT: case PAT_SINGLE: break;
|
|
case PAT_SMSQ: sout << "small "; BOOST_FALLTHROUGH;
|
|
case PAT_SQ: sout << "square"; break;
|
|
case PAT_OPENSQ: sout << "open square"; break;
|
|
case PAT_PLUS: sout << "plus"; break;
|
|
case PAT_RAD2: sout << "small circle"; break;
|
|
case PAT_RAD3: sout << "big circle"; break;
|
|
case PAT_WALL: sout << "line"; break;
|
|
case PAT_PROT: sout << "protective circle"; break;
|
|
case PAT_CUSTOM: sout << "unusual shap"; break;
|
|
}
|
|
sout << ")";
|
|
} else if(key == eMonstAbil::KILL) {
|
|
sout << " (" << gen.strength * 20 << "d10)";
|
|
} else if(key == eMonstAbil::STEAL_FOOD || key == eMonstAbil::STEAL_GOLD) {
|
|
sout << " (" << gen.strength << '-' << gen.strength * 2 << ")";
|
|
}
|
|
break;
|
|
case eMonstAbilCat::SPECIAL:
|
|
switch(key) {
|
|
case eMonstAbil::SPLITS:
|
|
sout << "Splits when hit (" << std::fixed << std::setprecision(1) << double(special.extra1) / 10 << "% chance)";
|
|
break;
|
|
case eMonstAbil::MARTYRS_SHIELD:
|
|
sout << "Permanent martyr's shield";
|
|
break;
|
|
case eMonstAbil::ABSORB_SPELLS:
|
|
sout << "Absorbs spells";
|
|
break;
|
|
case eMonstAbil::MISSILE_WEB:
|
|
sout << "Throws webs";
|
|
break;
|
|
case eMonstAbil::RAY_HEAT:
|
|
sout << "Heat ray (" << special.extra3 << "d6)";
|
|
break;
|
|
case eMonstAbil::SPECIAL:
|
|
sout << "Unusual ability (active)";
|
|
break;
|
|
case eMonstAbil::DEATH_TRIGGER:
|
|
sout << "Unusual ability (death)";
|
|
break;
|
|
case eMonstAbil::HIT_TRIGGER:
|
|
sout << "Unusual ability (passive)";
|
|
break;
|
|
// Non-special abilities
|
|
case eMonstAbil::STUN: case eMonstAbil::NO_ABIL: case eMonstAbil::RADIATE: case eMonstAbil::SUMMON:
|
|
case eMonstAbil::DAMAGE: case eMonstAbil::DAMAGE2: case eMonstAbil::DRAIN_SP: case eMonstAbil::DRAIN_XP:
|
|
case eMonstAbil::FIELD: case eMonstAbil::KILL: case eMonstAbil::MISSILE: case eMonstAbil::PETRIFY:
|
|
case eMonstAbil::STATUS: case eMonstAbil::STATUS2: case eMonstAbil::STEAL_FOOD: case eMonstAbil::STEAL_GOLD:
|
|
break;
|
|
}
|
|
break;
|
|
case eMonstAbilCat::SUMMON:
|
|
sout << "Summons " << summon.min << '-' << summon.max << ' ';
|
|
switch(summon.type) {
|
|
case eMonstSummon::TYPE:
|
|
sout << "%s";
|
|
break;
|
|
case eMonstSummon::SPECIES:
|
|
switch(eRace(summon.what)) {
|
|
case eRace::BEAST: sout << "beasts"; break;
|
|
case eRace::BIRD: sout << "birds"; break;
|
|
case eRace::BUG: sout << "bugs"; break;
|
|
case eRace::DEMON: sout << "demons"; break;
|
|
case eRace::DRAGON: sout << "dragons"; break;
|
|
case eRace::GIANT: sout << "giants"; break;
|
|
case eRace::GOBLIN: sout << "goblins"; break;
|
|
case eRace::HUMAN: sout << "humans"; break;
|
|
case eRace::HUMANOID: sout << "humanoids"; break;
|
|
case eRace::IMPORTANT: sout << "VIPs"; break;
|
|
case eRace::MAGE: sout << "mages"; break;
|
|
case eRace::MAGICAL: sout << "magical beings"; break;
|
|
case eRace::NEPHIL: sout << "nephilim"; break;
|
|
case eRace::PLANT: sout << "plants"; break;
|
|
case eRace::PRIEST: sout << "priests"; break;
|
|
case eRace::REPTILE: sout << "reptiles"; break;
|
|
case eRace::SKELETAL: sout << "skeletal undead"; break;
|
|
case eRace::SLIME: sout << "slimes"; break;
|
|
case eRace::SLITH: sout << "sliths"; break;
|
|
case eRace::STONE: sout << "mineral beings"; break;
|
|
case eRace::UNDEAD: sout << "undead"; break;
|
|
case eRace::UNKNOWN: sout << "monsters"; break;
|
|
case eRace::VAHNATAI: sout << "vahnatai"; break;
|
|
}
|
|
break;
|
|
case eMonstSummon::LEVEL:
|
|
switch(summon.what) {
|
|
case 0: sout << "cannon fodder"; break;
|
|
case 1: sout << "minor allies"; break;
|
|
case 2: sout << "allies"; break;
|
|
case 3: sout << "major allies"; break;
|
|
case 4: sout << "protectors"; break;
|
|
}
|
|
break;
|
|
}
|
|
sout << " (" << summon.chance << "% chance)";
|
|
break;
|
|
case eMonstAbilCat::RADIATE:
|
|
sout << "Radiates ";
|
|
switch(radiate.type) {
|
|
case eFieldType::SPECIAL_EXPLORED:
|
|
case eFieldType::SPECIAL_SPOT:
|
|
case eFieldType::SPECIAL_ROAD:
|
|
break; // These are invalid field types
|
|
case eFieldType::WALL_BLADES: sout << "blade fields"; break;
|
|
case eFieldType::WALL_FIRE: sout << "fire fields"; break;
|
|
case eFieldType::WALL_FORCE: sout << "shock fields"; break;
|
|
case eFieldType::WALL_ICE: sout << "ice fields"; break;
|
|
case eFieldType::CLOUD_STINK: sout << "stinking clouds"; break;
|
|
case eFieldType::CLOUD_SLEEP: sout << "sleep fields"; break;
|
|
case eFieldType::FIELD_ANTIMAGIC: sout << "antimagic fields"; break;
|
|
case eFieldType::FIELD_WEB: sout << "webs"; break;
|
|
case eFieldType::FIELD_QUICKFIRE: sout << "quickfire"; break;
|
|
case eFieldType::BARRIER_CAGE: sout << "forcecages"; break;
|
|
case eFieldType::BARRIER_FIRE: case eFieldType::BARRIER_FORCE: sout << "barriers"; break;
|
|
case eFieldType::FIELD_DISPEL: sout.str("Dispels surrounding fields"); break;
|
|
case eFieldType::FIELD_SMASH: sout.str("Wall-smashing aura");; break;
|
|
case eFieldType::OBJECT_BARREL: sout << "barrels"; break;
|
|
case eFieldType::OBJECT_BLOCK: sout << "stone blocks"; break;
|
|
case eFieldType::OBJECT_CRATE: sout << "crates"; break;
|
|
case eFieldType::SFX_ASH: case eFieldType::SFX_BONES: case eFieldType::SFX_RUBBLE:
|
|
case eFieldType::SFX_SMALL_BLOOD: case eFieldType::SFX_MEDIUM_BLOOD: case eFieldType::SFX_LARGE_BLOOD:
|
|
case eFieldType::SFX_SMALL_SLIME: case eFieldType::SFX_LARGE_SLIME:
|
|
sout << "litter";
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
return sout.str();
|
|
}
|
|
|
|
// Returns the action point cost, or one of the following magic values:
|
|
// 0 - passive ability
|
|
// -1 - part of normal attack
|
|
// -256 - unknown (error)
|
|
int uAbility::get_ap_cost(eMonstAbil key) const {
|
|
switch(key) {
|
|
case eMonstAbil::MISSILE:
|
|
switch(missile.type) {
|
|
case eMonstMissile::ARROW: case eMonstMissile::BOLT: case eMonstMissile::SPINE: case eMonstMissile::BOULDER:
|
|
return 3;
|
|
default:
|
|
return 2;
|
|
}
|
|
case eMonstAbil::RAY_HEAT:
|
|
return 1;
|
|
case eMonstAbil::DAMAGE2:
|
|
return 4;
|
|
case eMonstAbil::DAMAGE: case eMonstAbil::STATUS: case eMonstAbil::STATUS2: case eMonstAbil::STUN:
|
|
case eMonstAbil::FIELD: case eMonstAbil::PETRIFY: case eMonstAbil::DRAIN_SP: case eMonstAbil::DRAIN_XP:
|
|
case eMonstAbil::KILL: case eMonstAbil::STEAL_FOOD: case eMonstAbil::STEAL_GOLD:
|
|
return gen.type == eMonstGen::TOUCH ? -1 : 3;
|
|
case eMonstAbil::MISSILE_WEB:
|
|
return 3;
|
|
case eMonstAbil::SPECIAL:
|
|
return special.extra2;
|
|
case eMonstAbil::ABSORB_SPELLS: case eMonstAbil::DEATH_TRIGGER: case eMonstAbil::HIT_TRIGGER:
|
|
case eMonstAbil::MARTYRS_SHIELD: case eMonstAbil::RADIATE: case eMonstAbil::SPLITS:
|
|
case eMonstAbil::SUMMON:
|
|
return 0;
|
|
case eMonstAbil::NO_ABIL:
|
|
return -256;
|
|
}
|
|
return -256;
|
|
}
|
|
|
|
void cMonster::writeTo(cTagFile_Page& page) const {
|
|
page["MONSTER"] << m_name;
|
|
page["LEVEL"] << level;
|
|
page["ARMOR"] << armor;
|
|
page["SKILL"] << skill;
|
|
for(int i = 0; i < a.size(); i++) {
|
|
page["ATTACK"] << i + 1 << a[i].dice << a[i].sides << a[i].type;
|
|
}
|
|
page["HEALTH"] << m_health;
|
|
page["SPEED"] << speed;
|
|
page["MAGE"] << mu;
|
|
page["PRIEST"] << cl;
|
|
page["RACE"] << m_type;
|
|
page["TREASURE"] << treasure;
|
|
page["CORPSEITEM"] << corpse_item << corpse_item_chance;
|
|
page["IMMUNE"].encodeSparse(resist);
|
|
page["SIZE"] << x_width << y_width;
|
|
page["ATTITUDE"] << default_attitude;
|
|
page["SUMMON"] << summon_type;
|
|
page["PORTRAIT"] << default_facial_pic;
|
|
page["PICTURE"] << picture_num;
|
|
page["SOUND"] << ambient_sound;
|
|
if(mindless) page.add("MINDLESS");
|
|
if(invuln) page.add("INVULNERABLE");
|
|
if(invisible) page.add("INVISIBLE");
|
|
if(guard) page.add("GUARD");
|
|
if(amorphous) page.add("AMORPHOUS");
|
|
}
|
|
|
|
bool uAbility::writeTo(eMonstAbil key, cTagFile_Page &page) const {
|
|
if(key == eMonstAbil::NO_ABIL || !active) return false;
|
|
page["ABIL"] << key;
|
|
switch(getMonstAbilCategory(key)) {
|
|
case eMonstAbilCat::INVALID: return false;
|
|
case eMonstAbilCat::MISSILE:
|
|
page["TYPE"] << missile.type << missile.pic;
|
|
page["DAMAGE"] << missile.dice << missile.sides;
|
|
page["SKILL"] << missile.skill;
|
|
page["RANGE"] << missile.range;
|
|
page["CHANCE"] << missile.odds;
|
|
break;
|
|
case eMonstAbilCat::GENERAL:
|
|
page["TYPE"] << gen.type << gen.pic;
|
|
page["DAMAGE"] << gen.strength;
|
|
page["RANGE"] << gen.range;
|
|
page["CHANCE"] << gen.odds;
|
|
if(key == eMonstAbil::DAMAGE || key == eMonstAbil::DAMAGE2)
|
|
page["EXTRA"] << gen.dmg;
|
|
else if(key == eMonstAbil::FIELD)
|
|
page["EXTRA"] << gen.fld;
|
|
else if(key == eMonstAbil::STATUS || key == eMonstAbil::STATUS2 || key == eMonstAbil::STUN)
|
|
page["EXTRA"] << gen.stat;
|
|
break;
|
|
case eMonstAbilCat::RADIATE:
|
|
page["TYPE"] << radiate.type << radiate.pat;
|
|
page["CHANCE"] << radiate.chance;
|
|
break;
|
|
case eMonstAbilCat::SUMMON:
|
|
page["TYPE"] << summon.type << summon.what;
|
|
page["HOWMANY"] << summon.min << summon.max;
|
|
page["DURATION"] << summon.len;
|
|
page["CHANCE"] << summon.chance;
|
|
break;
|
|
case eMonstAbilCat::SPECIAL:
|
|
page["EXTRA"] << special.extra1 << special.extra2 << special.extra3;
|
|
break;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void cMonster::readFrom(const cTagFile_Page& page) {
|
|
// On-see event is not exported, so make sure the field ise not filled with garbage data
|
|
see_spec = -1;
|
|
page["MONSTER"] >> m_name;
|
|
page["SIZE"] >> x_width >> y_width;
|
|
page["IMMUNE"].extractSparse(resist);
|
|
page["RACE"] >> m_type;
|
|
page["CORPSEITEM"] >> corpse_item >> corpse_item_chance;
|
|
page["PORTRAIT"] >> default_facial_pic;
|
|
page["PICTURE"] >> picture_num;
|
|
page["SOUND"] >> ambient_sound;
|
|
page["ATTITUDE"] >> default_attitude;
|
|
page["LEVEL"] >> level;
|
|
page["ARMOR"] >> armor;
|
|
page["SKILL"] >> skill;
|
|
page["HEALTH"] >> m_health;
|
|
page["SPEED"] >> speed;
|
|
page["MAGE"] >> mu;
|
|
page["PRIEST"] >> cl;
|
|
page["TREASURE"] >> treasure;
|
|
page["SUMMON"] >> summon_type;
|
|
mindless = page.contains("MINDLESS");
|
|
invuln = page.contains("INVULNERABLE");
|
|
invisible = page.contains("INVISIBLE");
|
|
guard = page.contains("GUARD");
|
|
amorphous = page.contains("AMORPHOUS");
|
|
for(int i = 0; i < page["ATTACK"].size(); i++) {
|
|
size_t which_atk = 0;
|
|
auto tmp = page["ATTACK"] >> which_atk;
|
|
if(which_atk > 0 && which_atk <= a.size()) {
|
|
which_atk--;
|
|
tmp >> a[which_atk].dice >> a[which_atk].sides >> a[which_atk].type;
|
|
}
|
|
}
|
|
}
|
|
|
|
eMonstAbil uAbility::readFrom(const cTagFile_Page& page) {
|
|
eMonstAbil key = eMonstAbil::NO_ABIL;
|
|
page["ABIL"] >> key;
|
|
eMonstAbilCat cat = getMonstAbilCategory(key);
|
|
switch(cat) {
|
|
case eMonstAbilCat::INVALID: return eMonstAbil::NO_ABIL;
|
|
case eMonstAbilCat::MISSILE:
|
|
page["TYPE"] >> missile.type >> missile.pic;
|
|
page["DAMAGE"] >> missile.dice >> missile.sides;
|
|
page["SKILL"] >> missile.skill;
|
|
page["RANGE"] >> missile.range;
|
|
page["CHANCE"] >> missile.odds;
|
|
break;
|
|
case eMonstAbilCat::GENERAL:
|
|
page["TYPE"] >> gen.type >> gen.pic;
|
|
page["DAMAGE"] >> gen.strength;
|
|
page["RANGE"] >> gen.range;
|
|
page["CHANCE"] >> gen.odds;
|
|
if(key == eMonstAbil::DAMAGE || key == eMonstAbil::DAMAGE2)
|
|
page["EXTRA"] >> gen.dmg;
|
|
else if(key == eMonstAbil::FIELD)
|
|
page["EXTRA"] >> gen.fld;
|
|
else if(key == eMonstAbil::STATUS || key == eMonstAbil::STATUS2 || key == eMonstAbil::STUN)
|
|
page["EXTRA"] >> gen.stat;
|
|
break;
|
|
case eMonstAbilCat::RADIATE:
|
|
page["TYPE"] >> radiate.type >> radiate.pat;
|
|
page["CHANCE"] >> radiate.chance;
|
|
break;
|
|
case eMonstAbilCat::SUMMON:
|
|
page["TYPE"] >> summon.type >> summon.what;
|
|
page["HOWMANY"] >> summon.min >> summon.max;
|
|
page["DURATION"] >> summon.len;
|
|
page["CHANCE"] >> summon.chance;
|
|
break;
|
|
case eMonstAbilCat::SPECIAL:
|
|
page["EXTRA"] >> special.extra1 >> special.extra2 >> special.extra3;
|
|
break;
|
|
}
|
|
return key;
|
|
}
|
|
|