src/Abilities.cpp

@@ -1,7 +1,5 @@
 #include "Abilities.hpp"
 
-#include "servers/CNShardServer.hpp"
-
 #include "NPCManager.hpp"
 #include "PlayerManager.hpp"
 #include "Buffs.hpp"
@@ -47,39 +45,11 @@ static SkillResult handleSkillHealHP(SkillData* skill, int power, ICombatant* so
 }
 
 static SkillResult handleSkillDamageNDebuff(SkillData* skill, int power, ICombatant* source, ICombatant* target) {
-    // take aggro
+    // TODO abilities
-    target->takeDamage(source->getRef(), 0);
-
-    int duration = 0;
-    int strength = 0;
-    bool blocked = target->hasBuff(ECSB_FREEDOM);
-    if(!blocked) {
-        duration = skill->durationTime[power];
-        strength = skill->values[0][power];
-        BuffStack debuff = {
-            (duration * 100) / MS_PER_COMBAT_TICK, // ticks
-            strength, // value
-            source->getRef(), // source
-            BuffClass::NANO, // buff class
-        };
-        int timeBuffId = Abilities::getCSTBFromST(skill->skillType);
-        target->addBuff(timeBuffId,
-            [](EntityRef self, Buff* buff, int status, BuffStack* stack) {
-                Buffs::timeBuffUpdate(self, buff, status, stack);
-                if(status == ETBU_DEL) Buffs::timeBuffTimeout(self);
-            },
-            [](EntityRef self, Buff* buff, time_t currTime) {
-                Buffs::timeBuffTick(self, buff);
-            },
-            &debuff);
-    }
-
     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.bProtected = false;
     result.iConditionBitFlag = target->getCompositeCondition();
     return SkillResult(sizeof(sSkillResult_Damage_N_Debuff), &result);
 }
@@ -90,31 +60,20 @@ static SkillResult handleSkillLeech(SkillData* skill, int power, ICombatant* sou
 }
 
 static SkillResult handleSkillBuff(SkillData* skill, int power, ICombatant* source, ICombatant* target) {
-    int duration = skill->durationTime[power];
-    int strength = skill->values[0][power];
     BuffStack passiveBuff = {
-        skill->drainType == SkillDrainType::PASSIVE ? 1 : (duration * 100) / MS_PER_COMBAT_TICK, // ticks
+        skill->drainType == SkillDrainType::PASSIVE ? 1 : skill->durationTime[power], // ticks
-        strength, // value
+        skill->values[0][power], // value
         source->getRef(), // source
         source == target ? BuffClass::NANO : BuffClass::GROUP_NANO, // buff class
     };
 
     int timeBuffId = Abilities::getCSTBFromST(skill->skillType);
-    SkillDrainType drainType = skill->drainType;
     if(!target->addBuff(timeBuffId,
-        [drainType](EntityRef self, Buff* buff, int status, BuffStack* stack) {
+            [](EntityRef self, Buff* buff, int status, BuffStack* stack) {
-            if(buff->id == ECSB_BOUNDINGBALL) {
-                // drain
-                ICombatant* combatant = dynamic_cast<ICombatant*>(self.getEntity());
-                combatant->takeDamage(buff->getLastSource(), 0); // aggro
-            }
                 Buffs::timeBuffUpdate(self, buff, status, stack);
-            if(drainType == SkillDrainType::ACTIVE && status == ETBU_DEL)
-                Buffs::timeBuffTimeout(self);
             },
             [](EntityRef self, Buff* buff, time_t currTime) {
-            if(buff->id == ECSB_BOUNDINGBALL)
+                // no-op
-                Buffs::tickDrain(self, buff); // drain
             },
             &passiveBuff)) return SkillResult(); // no result if already buffed
 
@@ -257,18 +216,16 @@ static std::vector<SkillResult> handleSkill(SkillData* skill, int power, ICombat
     return results;
 }
 
-static void attachSkillResults(std::vector<SkillResult> results, uint8_t* pivot) {
+static void attachSkillResults(std::vector<SkillResult> results, size_t resultSize, uint8_t* pivot) {
     for(SkillResult& result : results) {
-        size_t sz = result.size;
+        memcpy(pivot, result.payload, resultSize);
-        memcpy(pivot, result.payload, sz);
+        pivot += resultSize;
-        pivot += sz;
     }
 }
 
 void Abilities::useNanoSkill(CNSocket* sock, SkillData* skill, sNano& nano, std::vector<ICombatant*> affected) {
 
     Player* plr = PlayerManager::getPlayer(sock);
-    ICombatant* combatant = dynamic_cast<ICombatant*>(plr);
 
     int boost = 0;
     if (Nanos::getNanoBoost(plr))
@@ -280,19 +237,17 @@ void Abilities::useNanoSkill(CNSocket* sock, SkillData* skill, sNano& nano, std:
             nano.iStamina = 0;
     }
 
-    std::vector<SkillResult> results = handleSkill(skill, boost, combatant, affected);
+    std::vector<SkillResult> results = handleSkill(skill, boost, plr, affected);
     if(results.empty()) return; // no effect; no need for confirmation packets
 
-    // lazy validation since skill results might be different sizes
+    size_t resultSize = MAX_SKILLRESULT_SIZE; // lazy
-    if (!validOutVarPacket(sizeof(sP_FE2CL_NANO_SKILL_USE_SUCC), results.size(), MAX_SKILLRESULT_SIZE)) {
+    if (!validOutVarPacket(sizeof(sP_FE2CL_NANO_SKILL_USE_SUCC), results.size(), resultSize)) {
         std::cout << "[WARN] bad sP_FE2CL_NANO_SKILL_USE_SUCC packet size\n";
         return;
     }
 
     // initialize response struct
-    size_t resplen = sizeof(sP_FE2CL_NANO_SKILL_USE_SUCC);
+    size_t resplen = sizeof(sP_FE2CL_NANO_SKILL_USE_SUCC) + results.size() * resultSize;
-    for(SkillResult& sr : results)
-        resplen += sr.size;
     uint8_t respbuf[CN_PACKET_BUFFER_SIZE];
     memset(respbuf, 0, resplen);
 
@@ -305,7 +260,7 @@ void Abilities::useNanoSkill(CNSocket* sock, SkillData* skill, sNano& nano, std:
     pkt->eST = (int32_t)skill->skillType;
     pkt->iTargetCnt = (int32_t)results.size();
 
-    attachSkillResults(results, (uint8_t*)(pkt + 1));
+    attachSkillResults(results, resultSize, (uint8_t*)(pkt + 1));
     sock->sendPacket(pkt, P_FE2CL_NANO_SKILL_USE_SUCC, resplen);
 
     if(skill->skillType == SkillType::RECALL_GROUP)
@@ -329,16 +284,15 @@ void Abilities::useNPCSkill(EntityRef npc, int skillID, std::vector<ICombatant*>
     std::vector<SkillResult> results = handleSkill(skill, 0, src, affected);
     if(results.empty()) return; // no effect; no need for confirmation packets
 
-    // lazy validation since skill results might be different sizes
+    size_t resultSize = results.back().size; // guaranteed to be the same for every item
-    if (!validOutVarPacket(sizeof(sP_FE2CL_NPC_SKILL_HIT), results.size(), MAX_SKILLRESULT_SIZE)) {
+
+    if (!validOutVarPacket(sizeof(sP_FE2CL_NPC_SKILL_HIT), results.size(), resultSize)) {
         std::cout << "[WARN] bad sP_FE2CL_NPC_SKILL_HIT packet size\n";
         return;
     }
 
     // initialize response struct
-    size_t resplen = sizeof(sP_FE2CL_NPC_SKILL_HIT);
+    size_t resplen = sizeof(sP_FE2CL_NPC_SKILL_HIT) + results.size() * resultSize;
-    for(SkillResult& sr : results)
-        resplen += sr.size;
     uint8_t respbuf[CN_PACKET_BUFFER_SIZE];
     memset(respbuf, 0, resplen);
 
@@ -348,7 +302,7 @@ void Abilities::useNPCSkill(EntityRef npc, int skillID, std::vector<ICombatant*>
     pkt->eST = (int32_t)skill->skillType;
     pkt->iTargetCnt = (int32_t)results.size();
 
-    attachSkillResults(results, (uint8_t*)(pkt + 1));
+    attachSkillResults(results, resultSize, (uint8_t*)(pkt + 1));
     NPCManager::sendToViewable(entity, pkt, P_FE2CL_NPC_SKILL_HIT, resplen);
 }
 
@@ -423,6 +377,12 @@ int Abilities::getCSTBFromST(SkillType skillType) {
     case SkillType::PROTECTINFECTION:
         result = ECSB_PROTECT_INFECTION;
         break;
+    case SkillType::SNARE:
+        result = ECSB_DN_MOVE_SPEED;
+        break;
+    case SkillType::SLEEP:
+        result = ECSB_MEZ;
+        break;
     case SkillType::MINIMAPENEMY:
         result = ECSB_MINIMAP_ENEMY;
         break;
@@ -435,9 +395,15 @@ int Abilities::getCSTBFromST(SkillType skillType) {
     case SkillType::REWARDCASH:
         result = ECSB_REWARD_CASH;
         break;
+    case SkillType::INFECTIONDAMAGE:
+        result = ECSB_INFECTION;
+        break;
     case SkillType::FREEDOM:
         result = ECSB_FREEDOM;
         break;
+    case SkillType::BOUNDINGBALL:
+        result = ECSB_BOUNDINGBALL;
+        break;
     case SkillType::INVULNERABLE:
         result = ECSB_INVULNERABLE;
         break;
@@ -446,22 +412,6 @@ int Abilities::getCSTBFromST(SkillType skillType) {
         break;
     case SkillType::NANOSTIMPAK:
         result = ECSB_STIMPAKSLOT1;
-        // shift as necessary
-        break;
-    case SkillType::SNARE:
-        result = ECSB_DN_MOVE_SPEED;
-        break;
-    case SkillType::STUN:
-        result = ECSB_STUN;
-        break;
-    case SkillType::SLEEP:
-        result = ECSB_MEZ;
-        break;
-    case SkillType::INFECTIONDAMAGE:
-        result = ECSB_INFECTION;
-        break;
-    case SkillType::BOUNDINGBALL:
-        result = ECSB_BOUNDINGBALL;
         break;
     default:
         break;

src/Buffs.cpp

@@ -95,12 +95,6 @@ int Buff::getValue(BuffValueSelector selector) {
     return value;
 }
 
-EntityRef Buff::getLastSource() {
-    if(stacks.empty())
-        return self;
-    return stacks.back().source;
-}
-
 bool Buff::isStale() {
     return stacks.empty();
 }
@@ -143,55 +137,15 @@ void Buffs::timeBuffUpdate(EntityRef self, Buff* buff, int status, BuffStack* st
     self.sock->sendPacket((void*)&pkt, P_FE2CL_PC_BUFF_UPDATE, sizeof(sP_FE2CL_PC_BUFF_UPDATE));
 }
 
-void Buffs::timeBuffTick(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);
-
-    INITSTRUCT(sP_FE2CL_CHAR_TIME_BUFF_TIME_TICK, pkt);
-    pkt.eCT = combatant->getCharType();
-    pkt.iID = combatant->getID();
-    pkt.iTB_ID = buff->id;
-    NPCManager::sendToViewable(entity, &pkt, P_FE2CL_CHAR_TIME_BUFF_TIME_TICK, sizeof(sP_FE2CL_CHAR_TIME_BUFF_TIME_TICK));
-}
-
 void Buffs::timeBuffTimeout(EntityRef self) {
     if(self.kind != EntityKind::PLAYER && self.kind != EntityKind::COMBAT_NPC && self.kind != EntityKind::MOB)
         return; // not a combatant
     Entity* entity = self.getEntity();
     ICombatant* combatant = dynamic_cast<ICombatant*>(entity);
     INITSTRUCT(sP_FE2CL_CHAR_TIME_BUFF_TIME_OUT, pkt); // send a buff timeout to other players
-    int32_t eCharType = combatant->getCharType();
+    pkt.eCT = combatant->getCharType();
-    pkt.eCT = eCharType == 4 ? 2 : eCharType; // convention not followed by client here
     pkt.iID = combatant->getID();
     pkt.iConditionBitFlag = combatant->getCompositeCondition();
     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) {
-    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->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);
-    uint8_t respbuf[CN_PACKET_BUFFER_SIZE];
-    memset(respbuf, 0, resplen);
-
-    sP_FE2CL_CHAR_TIME_BUFF_TIME_TICK *pkt = (sP_FE2CL_CHAR_TIME_BUFF_TIME_TICK*)respbuf;
-    pkt->iID = self.id;
-    pkt->eCT = combatant->getCharType();
-    pkt->iTB_ID = ECSB_BOUNDINGBALL;
-
-    sSkillResult_Damage *drain = (sSkillResult_Damage*)(respbuf + sizeof(sP_FE2CL_CHAR_TIME_BUFF_TIME_TICK));
-    drain->iDamage = damage;
-    drain->iHP = combatant->getCurrentHP();
-    drain->eCT = pkt->eCT;
-    drain->iID = pkt->iID;
-
-    NPCManager::sendToViewable(self.getEntity(), (void*)&respbuf, P_FE2CL_CHAR_TIME_BUFF_TIME_TICK, resplen);
-}
 #pragma endregion

src/Buffs.hpp

@@ -66,7 +66,6 @@ public:
     BuffClass maxClass();
 
     int getValue(BuffValueSelector selector);
-    EntityRef getLastSource();
 
     /* 
      * In general, a Buff object won't exist
@@ -87,7 +86,5 @@ public:
 
 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);
 }

src/Combat.cpp

@@ -24,8 +24,10 @@ bool Player::addBuff(int buffId, BuffCallback<int, BuffStack*> onUpdate, BuffCal
     if(!isAlive())
         return false;
 
+    EntityRef self = PlayerManager::getSockFromID(iID);
+
     if(!hasBuff(buffId)) {
-        buffs[buffId] = new Buff(buffId, getRef(), onUpdate, onTick, stack);
+        buffs[buffId] = new Buff(buffId, self, onUpdate, onTick, stack);
         return true;
     }
     
@@ -52,7 +54,6 @@ void Player::removeBuff(int buffId) {
 void Player::removeBuff(int buffId, int buffClass) {
     if(hasBuff(buffId)) {
         buffs[buffId]->clear((BuffClass)buffClass);
-        // buff might not be stale since another buff class might remain
         if(buffs[buffId]->isStale()) {
             delete buffs[buffId];
             buffs.erase(buffId);
@@ -60,17 +61,6 @@ void Player::removeBuff(int buffId, int buffClass) {
     }
 }
 
-void Player::clearBuffs(bool force) {
-    for(auto buff : buffs) {
-        if(!force) {
-            removeBuff(buff.first);
-        } else {
-            delete buff.second;
-        }
-    }
-    buffs.clear();
-}
-
 bool Player::hasBuff(int buffId) {
     auto buff = buffs.find(buffId);
     return buff != buffs.end() && !buff->second->isStale();
@@ -175,68 +165,23 @@ void Player::step(time_t currTime) {
 
 #pragma region CombatNPC
 bool CombatNPC::addBuff(int buffId, BuffCallback<int, BuffStack*> onUpdate, BuffCallback<time_t> onTick, BuffStack* stack) { /* stubbed */
-    if(!isAlive())
-        return false;
-
-    if(!hasBuff(buffId)) {
-        buffs[buffId] = new Buff(buffId, getRef(), onUpdate, onTick, stack);
-        return true;
-    }
-
-    buffs[buffId]->updateCallbacks(onUpdate, onTick);
-    buffs[buffId]->addStack(stack);
     return false;
 }
 
 Buff* CombatNPC::getBuff(int buffId) { /* stubbed */
-    if(hasBuff(buffId)) {
-        return buffs[buffId];
-    }
     return nullptr;
 }
 
-void CombatNPC::removeBuff(int buffId) {
+void CombatNPC::removeBuff(int buffId) { /* stubbed */ }
-    if(hasBuff(buffId)) {
+
-        buffs[buffId]->clear();
+void CombatNPC::removeBuff(int buffId, int buffClass) { /* stubbed */ }
-        delete buffs[buffId];
+
-        buffs.erase(buffId);
+bool CombatNPC::hasBuff(int buffId) { /* stubbed */
-    }
+    return false;
 }
 
-void CombatNPC::removeBuff(int buffId, int buffClass) {
+int CombatNPC::getCompositeCondition() { /* stubbed */
-    if(hasBuff(buffId)) {
+    return 0;
-        buffs[buffId]->clear((BuffClass)buffClass);
-        // buff might not be stale since another buff class might remain
-        if(buffs[buffId]->isStale()) {
-            delete buffs[buffId];
-            buffs.erase(buffId);
-        }
-    }
-}
-
-void CombatNPC::clearBuffs(bool force) {
-    for(auto buff : buffs) {
-        if(!force) {
-            removeBuff(buff.first);
-        } else {
-            delete buff.second;
-        }
-    }
-    buffs.clear();
-}
-
-bool CombatNPC::hasBuff(int buffId) {
-    auto buff = buffs.find(buffId);
-    return buff != buffs.end() && !buff->second->isStale();
-}
-
-int CombatNPC::getCompositeCondition() {
-    int conditionBitFlag = 0;
-    for(auto buff : buffs) {
-        if(!buff.second->isStale() && buff.second->id > 0)
-            conditionBitFlag |= CSB_FROM_ECSB(buff.first);
-    }
-    return conditionBitFlag;
 }
 
 int CombatNPC::takeDamage(EntityRef src, int amt) {

src/CustomCommands.cpp

@@ -678,6 +678,7 @@ static void whoisCommand(std::string full, std::vector<std::string>& args, CNSoc
     Chat::sendServerMessage(sock, "[WHOIS] ID: " + std::to_string(npc->id));
     Chat::sendServerMessage(sock, "[WHOIS] Type: " + std::to_string(npc->type));
     Chat::sendServerMessage(sock, "[WHOIS] HP: " + std::to_string(npc->hp));
+    Chat::sendServerMessage(sock, "[WHOIS] CBF: " + std::to_string(npc->cbf));
     Chat::sendServerMessage(sock, "[WHOIS] EntityType: " + std::to_string((int)npc->kind));
     Chat::sendServerMessage(sock, "[WHOIS] X: " + std::to_string(npc->x));
     Chat::sendServerMessage(sock, "[WHOIS] Y: " + std::to_string(npc->y));

src/Entities.cpp

@@ -40,7 +40,7 @@ sNPCAppearanceData BaseNPC::getAppearanceData() {
     sNPCAppearanceData data = {};
     data.iAngle = angle;
     data.iBarkerType = 0; // unused?
-    data.iConditionBitFlag = 0;
+    data.iConditionBitFlag = cbf;
     data.iHP = hp;
     data.iNPCType = type;
     data.iNPC_ID = id;
@@ -50,12 +50,6 @@ sNPCAppearanceData BaseNPC::getAppearanceData() {
     return data;
 }
 
-sNPCAppearanceData CombatNPC::getAppearanceData() {
-    sNPCAppearanceData data = BaseNPC::getAppearanceData();
-    data.iConditionBitFlag = getCompositeCondition();
-    return data;
-}
-
 /*
  * Entity coming into view.
  */

src/Entities.hpp

@@ -48,7 +48,6 @@ public:
     virtual Buff* getBuff(int) = 0;
     virtual void removeBuff(int) = 0;
     virtual void removeBuff(int, int) = 0;
-    virtual void clearBuffs(bool) = 0;
     virtual bool hasBuff(int) = 0;
     virtual int getCompositeCondition() = 0;
     virtual int takeDamage(EntityRef, int) = 0;
@@ -73,6 +72,7 @@ public:
     int type;
     int hp;
     int angle;
+    int cbf;
     bool loopingPath = false;
 
     BaseNPC(int _A, uint64_t iID, int t, int _id) {
@@ -80,6 +80,7 @@ public:
         type = t;
         hp = 400;
         angle = _A;
+        cbf = 0;
         id = _id;
         instanceID = iID;
     };
@@ -87,7 +88,7 @@ public:
     virtual void enterIntoViewOf(CNSocket *sock) override;
     virtual void disappearFromViewOf(CNSocket *sock) override;
 
-    virtual sNPCAppearanceData getAppearanceData();
+    sNPCAppearanceData getAppearanceData();
 };
 
 struct CombatNPC : public BaseNPC, public ICombatant {
@@ -104,8 +105,6 @@ struct CombatNPC : public BaseNPC, public ICombatant {
     std::map<AIState, void (*)(CombatNPC*, time_t)> stateHandlers;
     std::map<AIState, void (*)(CombatNPC*, EntityRef)> transitionHandlers;
 
-    std::unordered_map<int, Buff*> buffs = {};
-
     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) {
         spawnX = x;
@@ -118,15 +117,12 @@ struct CombatNPC : public BaseNPC, public ICombatant {
         transitionHandlers[AIState::INACTIVE] = {};
     }
 
-    virtual sNPCAppearanceData getAppearanceData() override;
-
     virtual bool isExtant() override { return hp > 0; }
 
     virtual bool addBuff(int buffId, BuffCallback<int, BuffStack*> onUpdate, BuffCallback<time_t> onTick, BuffStack* stack) override;
     virtual Buff* getBuff(int buffId) override;
     virtual void removeBuff(int buffId) override;
     virtual void removeBuff(int buffId, int buffClass) override;
-    virtual void clearBuffs(bool force) override;
     virtual bool hasBuff(int buffId) override;
     virtual int getCompositeCondition() override;
     virtual int takeDamage(EntityRef src, int amt) override;

src/Groups.hpp

@@ -3,7 +3,6 @@
 #include "EntityRef.hpp"
 
 #include <vector>
-#include <assert.h>
 
 struct Group {
     std::vector<EntityRef> members;
@@ -15,10 +14,6 @@ struct Group {
             });
         return filtered;
     }
-    EntityRef getLeader() {
-        assert(members.size() > 0);
-        return members[0];
-    }
 
     Group(EntityRef leader);
 };

src/MobAI.cpp

@@ -51,13 +51,13 @@ int Mob::takeDamage(EntityRef src, int amt) {
     }
 
     // wake up sleeping monster
-    if (hasBuff(ECSB_MEZ)) {
+    if (cbf & CSB_BIT_MEZ) {
-        removeBuff(ECSB_MEZ);
+        cbf &= ~CSB_BIT_MEZ;
 
         INITSTRUCT(sP_FE2CL_CHAR_TIME_BUFF_TIME_OUT, pkt1);
         pkt1.eCT = 2;
         pkt1.iID = id;
-        pkt1.iConditionBitFlag = getCompositeCondition();
+        pkt1.iConditionBitFlag = cbf;
         NPCManager::sendToViewable(this, &pkt1, P_FE2CL_CHAR_TIME_BUFF_TIME_OUT, sizeof(sP_FE2CL_CHAR_TIME_BUFF_TIME_OUT));
     }
 
@@ -96,12 +96,13 @@ static std::pair<int,int> lerp(int x1, int y1, int x2, int y2, int speed) {
 
 void MobAI::clearDebuff(Mob *mob) {
     mob->skillStyle = -1;
-    mob->clearBuffs(false);
+    mob->cbf = 0;
+    mob->unbuffTimes.clear();
 
     INITSTRUCT(sP_FE2CL_CHAR_TIME_BUFF_TIME_OUT, pkt1);
     pkt1.eCT = 2;
     pkt1.iID = mob->id;
-    pkt1.iConditionBitFlag = mob->getCompositeCondition();
+    pkt1.iConditionBitFlag = mob->cbf;
     NPCManager::sendToViewable(mob, &pkt1, P_FE2CL_CHAR_TIME_BUFF_TIME_OUT, sizeof(sP_FE2CL_CHAR_TIME_BUFF_TIME_OUT));
 }
 
@@ -441,7 +442,6 @@ static void useAbilities(Mob *mob, time_t currTime) {
     return;
 }
 
-// TODO abiilities
 static void drainMobHP(Mob *mob, int amount) {
     size_t resplen = sizeof(sP_FE2CL_CHAR_TIME_BUFF_TIME_TICK) + sizeof(sSkillResult_Damage);
     assert(resplen < CN_PACKET_BUFFER_SIZE - 8);
@@ -553,26 +553,38 @@ void MobAI::combatStep(CombatNPC* npc, time_t currTime) {
         return;
     }
 
-    // tick buffs
+    // drain
-    auto it = npc->buffs.begin();
+    if (self->skillStyle < 0 && (self->lastDrainTime == 0 || currTime - self->lastDrainTime >= 1000)
-    while(it != npc->buffs.end()) {
+        && self->cbf & CSB_BIT_BOUNDINGBALL) {
-        Buff* buff = (*it).second;
+        drainMobHP(self, self->maxHealth / 20); // lose 5% every second
-        buff->combatTick(currTime);
+        self->lastDrainTime = currTime;
-        buff->tick(currTime);
-        if(buff->isStale()) {
-            // garbage collect
-            it = npc->buffs.erase(it);
-            delete buff;
-        }
-        else it++;
     }
 
-    // if debuffs killed the mob, return early
+    // if drain killed the mob, return early
     if (self->hp <= 0)
         return;
 
+    // unbuffing
+    std::unordered_map<int32_t, time_t>::iterator it = self->unbuffTimes.begin();
+    while (it != self->unbuffTimes.end()) {
+
+        if (currTime >= it->second) {
+            self->cbf &= ~it->first;
+
+            INITSTRUCT(sP_FE2CL_CHAR_TIME_BUFF_TIME_OUT, pkt1);
+            pkt1.eCT = 2;
+            pkt1.iID = self->id;
+            pkt1.iConditionBitFlag = self->cbf;
+            NPCManager::sendToViewable(self, &pkt1, P_FE2CL_CHAR_TIME_BUFF_TIME_OUT, sizeof(sP_FE2CL_CHAR_TIME_BUFF_TIME_OUT));
+
+            it = self->unbuffTimes.erase(it);
+        } else {
+            it++;
+        }
+    }
+
     // skip attack if stunned or asleep
-    if (self->hasBuff(ECSB_STUN) || self->hasBuff(ECSB_MEZ)) {
+    if (self->cbf & (CSB_BIT_STUN|CSB_BIT_MEZ)) {
         self->skillStyle = -1; // in this case we also reset the any outlying abilities the mob might be winding up.
         return;
     }
@@ -588,7 +600,6 @@ void MobAI::combatStep(CombatNPC* npc, time_t currTime) {
     }
 
     int distanceToTravel = INT_MAX;
-    int speed = self->speed;
     // movement logic: move when out of range but don't move while casting a skill
     if (distance > mobRange && self->skillStyle == -1) {
         if (self->nextMovement != 0 && currTime < self->nextMovement)
@@ -598,8 +609,8 @@ void MobAI::combatStep(CombatNPC* npc, time_t currTime) {
             self->nextAttack = 0;
 
         // halve movement speed if snared
-        if (self->hasBuff(ECSB_DN_MOVE_SPEED))
+        if (self->cbf & CSB_BIT_DN_MOVE_SPEED)
-            speed /= 2;
+            self->speed /= 2;
 
         int targetX = plr->x;
         int targetY = plr->y;
@@ -608,9 +619,9 @@ void MobAI::combatStep(CombatNPC* npc, time_t currTime) {
             targetY += self->offsetY*distance/(self->idleRange + 1);
         }
 
-        distanceToTravel = std::min(distance-mobRange+1, speed*2/5);
+        distanceToTravel = std::min(distance-mobRange+1, self->speed*2/5);
         auto targ = lerp(self->x, self->y, targetX, targetY, distanceToTravel);
-        if (distanceToTravel < speed*2/5 && currTime >= self->nextAttack)
+        if (distanceToTravel < self->speed*2/5 && currTime >= self->nextAttack)
             self->nextAttack = 0;
 
         NPCManager::updateNPCPosition(self->id, targ.first, targ.second, self->z, self->instanceID, self->angle);
@@ -618,7 +629,7 @@ void MobAI::combatStep(CombatNPC* npc, time_t currTime) {
         INITSTRUCT(sP_FE2CL_NPC_MOVE, pkt);
 
         pkt.iNPC_ID = self->id;
-        pkt.iSpeed = speed;
+        pkt.iSpeed = self->speed;
         pkt.iToX = self->x = targ.first;
         pkt.iToY = self->y = targ.second;
         pkt.iToZ = plr->z;
@@ -704,7 +715,7 @@ void MobAI::roamingStep(CombatNPC* npc, time_t currTime) {
     farY = std::clamp(farY, yStart, yStart + self->idleRange);
 
     // halve movement speed if snared
-    if (self->hasBuff(ECSB_DN_MOVE_SPEED))
+    if (self->cbf & CSB_BIT_DN_MOVE_SPEED)
         self->speed /= 2;
 
     std::queue<Vec3> queue;
@@ -777,6 +788,7 @@ void MobAI::onRoamStart(CombatNPC* npc, EntityRef src) {
     self->hp = self->maxHealth;
     self->killedTime = 0;
     self->nextAttack = 0;
+    self->cbf = 0;
 
     // cast a return home heal spell, this is the right way(tm)
     // TODO ABILITIES
@@ -821,8 +833,9 @@ void MobAI::onDeath(CombatNPC* npc, EntityRef src) {
     Mob* self = (Mob*)npc;
 
     self->target = nullptr;
+    self->cbf = 0;
     self->skillStyle = -1;
-    self->clearBuffs(true);
+    self->unbuffTimes.clear();
     self->killedTime = getTime(); // XXX: maybe introduce a shard-global time for each step?
 
     // check for the edge case where hitting the mob did not aggro it

src/MobAI.hpp

@@ -21,6 +21,8 @@ namespace MobAI {
 }
 
 struct Mob : public CombatNPC {
+    // general
+    std::unordered_map<int32_t,time_t> unbuffTimes = {};
 
     // dead
     time_t killedTime = 0;
@@ -69,6 +71,8 @@ struct Mob : public CombatNPC {
         offsetX = 0;
         offsetY = 0;
 
+        cbf = 0;
+
         // NOTE: there appear to be discrepancies in the dump
         hp = maxHealth;
 

src/NPCManager.cpp

@@ -376,5 +376,5 @@ void NPCManager::init() {
     REGISTER_SHARD_PACKET(P_CL2FE_REQ_NPC_UNSUMMON, npcUnsummonHandler);
     REGISTER_SHARD_PACKET(P_CL2FE_REQ_BARKER, npcBarkHandler);
 
-    REGISTER_SHARD_TIMER(step, MS_PER_COMBAT_TICK);
+    REGISTER_SHARD_TIMER(step, 200);
 }

src/Player.hpp

@@ -93,7 +93,6 @@ struct Player : public Entity, public ICombatant {
     virtual Buff* getBuff(int buffId) override;
     virtual void removeBuff(int buffId) override;
     virtual void removeBuff(int buffId, int buffClass) override;
-    virtual void clearBuffs(bool force) override;
     virtual bool hasBuff(int buffId) override;
     virtual int getCompositeCondition() override;
     virtual int takeDamage(EntityRef src, int amt) override;

src/servers/CNShardServer.hpp

@@ -8,7 +8,6 @@
 #define REGISTER_SHARD_PACKET(pactype, handlr) CNShardServer::ShardPackets[pactype] = handlr;
 #define REGISTER_SHARD_TIMER(handlr, delta) CNShardServer::Timers.push_back(TimerEvent(handlr, delta));
 #define MS_PER_PLAYER_TICK 500
-#define MS_PER_COMBAT_TICK 200
 
 class CNShardServer : public CNServer {
 private: