Clear player buffs on death if not revived

improperly erasing during iteration oops

src/Abilities.cpp

@@ -76,20 +76,12 @@ static SkillResult handleSkillDamageNDebuff(SkillData* skill, int power, ICombat
     }
 
     sSkillResult_Damage_N_Debuff result{};
-
     result.iDamage = duration / 10; // we use the duration as the damage number (why?)
     result.iHP = target->getCurrentHP();
     result.eCT = target->getCharType();
     result.iID = target->getID();
     result.bProtected = blocked;
     result.iConditionBitFlag = target->getCompositeCondition();
-
-    // for player targets, make sure to update Nano stamina
-    if (target->getCharType() == 1) {
-        Player *plr = dynamic_cast<Player*>(target);
-        result.iStamina = plr->getActiveNano()->iStamina;
-    }
-
     return SkillResult(sizeof(sSkillResult_Damage_N_Debuff), &result);
 }
 
@@ -120,8 +112,7 @@ static SkillResult handleSkillBuff(SkillData* skill, int power, ICombatant* sour
     int duration = skill->durationTime[power];
     int strength = skill->values[0][power];
     BuffStack passiveBuff = {
-        // if the duration is 0, it needs to be recast every tick
-        duration == 0 ? 1 : (duration * 100) / MS_PER_COMBAT_TICK, // ticks
+        skill->drainType == SkillDrainType::PASSIVE ? 1 : (duration * 100) / MS_PER_COMBAT_TICK, // ticks
         strength, // value
         source->getRef(), // source
         source == target ? BuffClass::NANO : BuffClass::GROUP_NANO, // buff class
@@ -129,10 +120,9 @@ static SkillResult handleSkillBuff(SkillData* skill, int power, ICombatant* sour
 
     int timeBuffId = Abilities::getCSTBFromST(skill->skillType);
     SkillDrainType drainType = skill->drainType;
-    int combatLifetime = 0;
     if(!target->addBuff(timeBuffId,
         [drainType](EntityRef self, Buff* buff, int status, BuffStack* stack) {
-            if(buff->id == ECSB_BOUNDINGBALL && status == ETBU_ADD) {
+            if(buff->id == ECSB_BOUNDINGBALL) {
                 // drain
                 ICombatant* combatant = dynamic_cast<ICombatant*>(self.getEntity());
                 combatant->takeDamage(buff->getLastSource(), 0); // aggro
@@ -141,13 +131,11 @@ static SkillResult handleSkillBuff(SkillData* skill, int power, ICombatant* sour
             if(drainType == SkillDrainType::ACTIVE && status == ETBU_DEL)
                 Buffs::timeBuffTimeout(self);
         },
-        [combatLifetime](EntityRef self, Buff* buff, time_t currTime) mutable {
-            if(buff->id == ECSB_BOUNDINGBALL &&
-                combatLifetime % COMBAT_TICKS_PER_DRAIN_PROC == 0)
-                Buffs::tickDrain(self, buff, COMBAT_TICKS_PER_DRAIN_PROC); // drain
-            combatLifetime++;
+        [](EntityRef self, Buff* buff, time_t currTime) {
+            if(buff->id == ECSB_BOUNDINGBALL)
+                Buffs::tickDrain(self, buff); // drain
         },
-        &passiveBuff)) return SkillResult();
+        &passiveBuff)) return SkillResult(); // no result if already buffed
 
     sSkillResult_Buff result{};
     result.eCT = target->getCharType();

src/Abilities.hpp

@@ -9,18 +9,17 @@
 #include <vector>
 #include <assert.h>
 
-const int COMBAT_TICKS_PER_DRAIN_PROC = 2;
 constexpr size_t MAX_SKILLRESULT_SIZE = sizeof(sSkillResult_BatteryDrain);
 
 enum class SkillType {
     DAMAGE = 1,
     HEAL_HP = 2,
-    KNOCKDOWN = 3, // uses DamageNDebuff
-    SLEEP = 4, // uses DamageNDebuff
-    SNARE = 5, // uses DamageNDebuff
+    KNOCKDOWN = 3, // dnd
+    SLEEP = 4, // dnd
+    SNARE = 5, // dnd
     HEAL_STAMINA = 6,
     STAMINA_SELF = 7,
-    STUN = 8, // uses DamageNDebuff
+    STUN = 8, // dnd
     WEAPONSLOW = 9,
     JUMP = 10,
     RUN = 11,

src/Buffs.cpp

@@ -169,13 +169,12 @@ void Buffs::timeBuffTimeout(EntityRef self) {
     NPCManager::sendToViewable(entity, &pkt, P_FE2CL_CHAR_TIME_BUFF_TIME_OUT, sizeof(sP_FE2CL_CHAR_TIME_BUFF_TIME_OUT));
 }
 
-void Buffs::tickDrain(EntityRef self, Buff* buff, int mult) {
+void Buffs::tickDrain(EntityRef self, Buff* buff) {
     if(self.kind != EntityKind::COMBAT_NPC && self.kind != EntityKind::MOB)
         return; // not implemented
     Entity* entity = self.getEntity();
     ICombatant* combatant = dynamic_cast<ICombatant*>(entity);
-    int damage = combatant->getMaxHP() / 100 * mult;
-    int dealt = combatant->takeDamage(buff->getLastSource(), damage);
+    int damage = combatant->takeDamage(buff->getLastSource(), combatant->getMaxHP() / 100);
 
     size_t resplen = sizeof(sP_FE2CL_CHAR_TIME_BUFF_TIME_TICK) + sizeof(sSkillResult_Damage);
     assert(resplen < CN_PACKET_BUFFER_SIZE - 8);
@@ -188,7 +187,7 @@ void Buffs::tickDrain(EntityRef self, Buff* buff, int mult) {
     pkt->iTB_ID = ECSB_BOUNDINGBALL;
 
     sSkillResult_Damage *drain = (sSkillResult_Damage*)(respbuf + sizeof(sP_FE2CL_CHAR_TIME_BUFF_TIME_TICK));
-    drain->iDamage = dealt;
+    drain->iDamage = damage;
     drain->iHP = combatant->getCurrentHP();
     drain->eCT = pkt->eCT;
     drain->iID = pkt->iID;

src/Buffs.hpp

@@ -89,5 +89,5 @@ namespace Buffs {
     void timeBuffUpdate(EntityRef self, Buff* buff, int status, BuffStack* stack);
     void timeBuffTick(EntityRef self, Buff* buff);
     void timeBuffTimeout(EntityRef self);
-    void tickDrain(EntityRef self, Buff* buff, int mult);
+    void tickDrain(EntityRef self, Buff* buff);
 }

src/Combat.cpp

@@ -175,13 +175,10 @@ void Player::step(time_t currTime) {
 #pragma endregion
 
 #pragma region CombatNPC
-bool CombatNPC::addBuff(int buffId, BuffCallback<int, BuffStack*> onUpdate, BuffCallback<time_t> onTick, BuffStack* stack) {
+bool CombatNPC::addBuff(int buffId, BuffCallback<int, BuffStack*> onUpdate, BuffCallback<time_t> onTick, BuffStack* stack) { /* stubbed */
     if(!isAlive())
         return false;
 
-    if (this->state != AIState::COMBAT && this->state != AIState::ROAMING)
-        return false;
-
     if(!hasBuff(buffId)) {
         buffs[buffId] = new Buff(buffId, getRef(), onUpdate, onTick, stack);
         return true;
@@ -192,7 +189,7 @@ bool CombatNPC::addBuff(int buffId, BuffCallback<int, BuffStack*> onUpdate, Buff
     return false;
 }
 
-Buff* CombatNPC::getBuff(int buffId) {
+Buff* CombatNPC::getBuff(int buffId) { /* stubbed */
     if(hasBuff(buffId)) {
         return buffs[buffId];
     }
@@ -310,19 +307,19 @@ void CombatNPC::step(time_t currTime) {
 }
 
 void CombatNPC::transition(AIState newState, EntityRef src) {
-    state = newState;
 
+    state = newState;
     if (transitionHandlers.find(newState) != transitionHandlers.end())
         transitionHandlers[newState](this, src);
     else {
         std::cout << "[WARN] Transition to " << (int)state << " has no handler; going inactive" << std::endl;
         transition(AIState::INACTIVE, id);
     }
-
-    // trigger special NPCEvents, if applicable
+    /* TODO: fire any triggered events
     for (NPCEvent& event : NPCManager::NPCEvents)
-        if (event.triggerState == newState && event.npcType == type)
-            event.handler(this);
+        if (event.trigger == ON_KILLED && event.npcType == type)
+            event.handler(src, this);
+    */
 }
 #pragma endregion
 

src/Entities.hpp

@@ -106,11 +106,11 @@ struct CombatNPC : public BaseNPC, public ICombatant {
 
     std::unordered_map<int, Buff*> buffs = {};
 
-    CombatNPC(int spawnX, int spawnY, int spawnZ, int angle, uint64_t iID, int t, int id, int maxHP)
+    CombatNPC(int x, int y, int z, int angle, uint64_t iID, int t, int id, int maxHP)
         : BaseNPC(angle, iID, t, id), maxHealth(maxHP) {
-        this->spawnX = spawnX;
-        this->spawnY = spawnY;
-        this->spawnZ = spawnZ;
+        spawnX = x;
+        spawnY = y;
+        spawnZ = z;
 
         kind = EntityKind::COMBAT_NPC;
 

src/MobAI.hpp

@@ -50,8 +50,8 @@ struct Mob : public CombatNPC {
     // temporary; until we're sure what's what
     nlohmann::json data = {};
 
-    Mob(int spawnX, int spawnY, int spawnZ, int angle, uint64_t iID, int t, nlohmann::json d, int32_t id)
-        : CombatNPC(spawnX, spawnY, spawnZ, angle, iID, t, id, d["m_iHP"]),
+    Mob(int x, int y, int z, int angle, uint64_t iID, int t, nlohmann::json d, int32_t id)
+        : CombatNPC(x, y, z, angle, iID, t, id, d["m_iHP"]),
           sightRange(d["m_iSightRange"]) {
         state = AIState::ROAMING;
 
@@ -62,9 +62,9 @@ struct Mob : public CombatNPC {
         idleRange = (int)data["m_iIdleRange"];
         level = data["m_iNpcLevel"];
 
-        roamX = spawnX;
-        roamY = spawnY;
-        roamZ = spawnZ;
+        roamX = x;
+        roamY = y;
+        roamZ = z;
 
         offsetX = 0;
         offsetY = 0;

src/NPCManager.cpp

@@ -122,15 +122,16 @@ static void npcUnsummonHandler(CNSocket* sock, CNPacketData* data) {
 }
 
 // type must already be checked and updateNPCPosition() must be called on the result
-BaseNPC *NPCManager::summonNPC(int spawnX, int spawnY, int spawnZ, uint64_t instance, int type, bool respawn, bool baseInstance) {
+BaseNPC *NPCManager::summonNPC(int x, int y, int z, uint64_t instance, int type, bool respawn, bool baseInstance) {
     uint64_t inst = baseInstance ? MAPNUM(instance) : instance;
 
+    //assert(nextId < INT32_MAX);
     int id = nextId--;
     int team = NPCData[type]["m_iTeam"];
     BaseNPC *npc = nullptr;
 
     if (team == 2) {
-        npc = new Mob(spawnX, spawnY, spawnZ, inst, type, NPCData[type], id);
+        npc = new Mob(x, y, z, inst, type, NPCData[type], id);
 
         // re-enable respawning, if desired
         ((Mob*)npc)->summoned = !respawn;
@@ -293,55 +294,57 @@ BaseNPC* NPCManager::getNearestNPC(std::set<Chunk*>* chunks, int X, int Y, int Z
     return npc;
 }
 
-// TODO: Move this to separate file in ai/ subdir when implementing more events
+// TODO: Move this to MobAI, possibly
 #pragma region NPCEvents
 
 // summon right arm and stage 2 body
-static void lordFuseStageTwo(CombatNPC *npc) {
+static void lordFuseStageTwo(CNSocket *sock, BaseNPC *npc) {
     Mob *oldbody = (Mob*)npc; // adaptium, stun
+    Player *plr = PlayerManager::getPlayer(sock);
 
     std::cout << "Lord Fuse stage two" << std::endl;
 
     // Fuse doesn't move
     // Blastons, Heal
-    Mob *newbody = (Mob*)NPCManager::summonNPC(oldbody->x, oldbody->y, oldbody->z, oldbody->instanceID, 2467);
+    Mob *newbody = (Mob*)NPCManager::summonNPC(oldbody->x, oldbody->y, oldbody->z, plr->instanceID, 2467);
 
     newbody->angle = oldbody->angle;
-    NPCManager::updateNPCPosition(newbody->id, newbody->spawnX, newbody->spawnY, newbody->spawnZ,
-        oldbody->instanceID, oldbody->angle);
+    NPCManager::updateNPCPosition(newbody->id, newbody->x, newbody->y, newbody->z,
+        plr->instanceID, oldbody->angle);
 
     // right arm, Adaptium, Stun
-    Mob *arm = (Mob*)NPCManager::summonNPC(oldbody->x - 600, oldbody->y, oldbody->z, oldbody->instanceID, 2469);
+    Mob *arm = (Mob*)NPCManager::summonNPC(oldbody->x - 600, oldbody->y, oldbody->z, plr->instanceID, 2469);
 
     arm->angle = oldbody->angle;
-    NPCManager::updateNPCPosition(arm->id, arm->spawnX, arm->spawnY, arm->spawnZ,
-        oldbody->instanceID, oldbody->angle);
+    NPCManager::updateNPCPosition(arm->id, arm->x, arm->y, arm->z,
+        plr->instanceID, oldbody->angle);
 }
 
 // summon left arm and stage 3 body
-static void lordFuseStageThree(CombatNPC *npc) {
+static void lordFuseStageThree(CNSocket *sock, BaseNPC *npc) {
     Mob *oldbody = (Mob*)npc;
+    Player *plr = PlayerManager::getPlayer(sock);
 
     std::cout << "Lord Fuse stage three" << std::endl;
 
     // Cosmix, Damage Point
-    Mob *newbody = (Mob*)NPCManager::summonNPC(oldbody->x, oldbody->y, oldbody->z, oldbody->instanceID, 2468);
+    Mob *newbody = (Mob*)NPCManager::summonNPC(oldbody->x, oldbody->y, oldbody->z, plr->instanceID, 2468);
 
     newbody->angle = oldbody->angle;
-    NPCManager::updateNPCPosition(newbody->id, newbody->spawnX, newbody->spawnY, newbody->spawnZ,
-        newbody->instanceID, oldbody->angle);
+    NPCManager::updateNPCPosition(newbody->id, newbody->x, newbody->y, newbody->z,
+        plr->instanceID, oldbody->angle);
 
     // Blastons, Heal
-    Mob *arm = (Mob*)NPCManager::summonNPC(oldbody->x + 600, oldbody->y, oldbody->z, oldbody->instanceID, 2470);
+    Mob *arm = (Mob*)NPCManager::summonNPC(oldbody->x + 600, oldbody->y, oldbody->z, plr->instanceID, 2470);
 
     arm->angle = oldbody->angle;
-    NPCManager::updateNPCPosition(arm->id, arm->spawnX, arm->spawnY, arm->spawnZ,
-        arm->instanceID, oldbody->angle);
+    NPCManager::updateNPCPosition(arm->id, arm->x, arm->y, arm->z,
+        plr->instanceID, oldbody->angle);
 }
 
 std::vector<NPCEvent> NPCManager::NPCEvents = {
-    NPCEvent(2466, AIState::DEAD, lordFuseStageTwo),
-    NPCEvent(2467, AIState::DEAD, lordFuseStageThree),
+    NPCEvent(2466, ON_KILLED, lordFuseStageTwo),
+    NPCEvent(2467, ON_KILLED, lordFuseStageThree),
 };
 
 #pragma endregion NPCEvents

src/NPCManager.hpp

@@ -14,15 +14,20 @@
 
 #define RESURRECT_HEIGHT 400
 
-typedef void (*NPCEventHandler)(CombatNPC*);
+enum Trigger {
+    ON_KILLED,
+    ON_COMBAT
+};
+
+typedef void (*NPCEventHandler)(CNSocket*, BaseNPC*);
 
 struct NPCEvent {
     int32_t npcType;
-    AIState triggerState;
+    int trigger;
     NPCEventHandler handler;
 
-    NPCEvent(int32_t t, AIState tr, NPCEventHandler hndlr)
-        : npcType(t), triggerState(tr), handler(hndlr) {}
+    NPCEvent(int32_t t, int tr, NPCEventHandler hndlr)
+        : npcType(t), trigger(tr), handler(hndlr) {}
 };
 
 namespace NPCManager {