src/Abilities.cpp

@@ -97,13 +97,8 @@ static SkillResult handleSkillBatteryDrain(SkillData* skill, int power, ICombata
 static SkillResult handleSkillMove(SkillData* skill, int power, ICombatant* source, ICombatant* target) {
     if(source->getCharType() != 1)
         return SkillResult(); // only Players are valid sources for recall
-
     Player* plr = dynamic_cast<Player*>(source);
-    if(source == target) {
+    PlayerManager::sendPlayerTo(source->getRef().sock, plr->recallX, plr->recallY, plr->recallZ, plr->recallInstance);
-        // no trailing struct for self
-        PlayerManager::sendPlayerTo(target->getRef().sock, plr->recallX, plr->recallY, plr->recallZ, plr->recallInstance);
-        return SkillResult();
-    }
 
     sSkillResult_Move result{};
     result.eCT = target->getCharType();
@@ -131,50 +126,50 @@ static std::vector<SkillResult> handleSkill(SkillData* skill, int power, ICombat
 
     switch(skill->skillType)
     {
-        case SkillType::DAMAGE:
+        case EST_DAMAGE:
             resultSize = sizeof(sSkillResult_Damage);
             skillHandler = handleSkillDamage;
             break;
-        case SkillType::HEAL_HP:
+        case EST_HEAL_HP:
-        case SkillType::RETURNHOMEHEAL:
+        case EST_RETURNHOMEHEAL:
             resultSize = sizeof(sSkillResult_Heal_HP);
             skillHandler = handleSkillHealHP;
             break;
-        case SkillType::JUMP:
+        case EST_JUMP:
-        case SkillType::RUN:
+        case EST_RUN:
-        case SkillType::FREEDOM:
+        case EST_FREEDOM:
-        case SkillType::PHOENIX:
+        case EST_PHOENIX:
-        case SkillType::INVULNERABLE:
+        case EST_INVULNERABLE:
-        case SkillType::MINIMAPENEMY:
+        case EST_MINIMAPENEMY:
-        case SkillType::MINIMAPTRESURE:
+        case EST_MINIMAPTRESURE:
-        case SkillType::NANOSTIMPAK:
+        case EST_NANOSTIMPAK:
-        case SkillType::PROTECTBATTERY:
+        case EST_PROTECTBATTERY:
-        case SkillType::PROTECTINFECTION:
+        case EST_PROTECTINFECTION:
-        case SkillType::REWARDBLOB:
+        case EST_REWARDBLOB:
-        case SkillType::REWARDCASH:
+        case EST_REWARDCASH:
-        case SkillType::STAMINA_SELF:
+        case EST_STAMINA_SELF:
-        case SkillType::STEALTH:
+        case EST_STEALTH:
             resultSize = sizeof(sSkillResult_Buff);
             skillHandler = handleSkillBuff;
             break;
-        case SkillType::BATTERYDRAIN:
+        case EST_BATTERYDRAIN:
             resultSize = sizeof(sSkillResult_BatteryDrain);
             skillHandler = handleSkillBatteryDrain;
             break;
-        case SkillType::RECALL: // still soft lock
+        case EST_RECALL: // still soft lock
-        case SkillType::RECALL_GROUP: // works for player who uses it
+        case EST_RECALL_GROUP: // works for player who uses it
             resultSize = sizeof(sSkillResult_Move);
             skillHandler = handleSkillMove;
             break;
-        case SkillType::PHOENIX_GROUP: // broken
+        case EST_PHOENIX_GROUP: // broken
             resultSize = sizeof(sSkillResult_Resurrect);
             skillHandler = handleSkillResurrect;
             break;
-        case SkillType::RETROROCKET_SELF:
+        case EST_RETROROCKET_SELF:
             // no-op
             return results;
         default:
-            std::cout << "[WARN] Unhandled skill type " << (int)skill->skillType << std::endl;
+            std::cout << "[WARN] Unhandled skill type " << skill->skillType << std::endl;
             return results;
     }
 
@@ -183,7 +178,7 @@ static std::vector<SkillResult> handleSkill(SkillData* skill, int power, ICombat
         SkillResult result = skillHandler(skill, power, src != nullptr ? src : target, target);
         if(result.size == 0) continue; // skill not applicable
         if(result.size != resultSize) {
-            std::cout << "[WARN] bad skill result size for " << (int)skill->skillType << " from " << (void*)handleSkillBuff << std::endl;
+            std::cout << "[WARN] bad skill result size for " << skill->skillType << " from " << (void*)handleSkillBuff << std::endl;
             continue;
         }
         results.push_back(result);
@@ -230,17 +225,12 @@ void Abilities::useNanoSkill(CNSocket* sock, SkillData* skill, sNano& nano, std:
     pkt->iSkillID = nano.iSkillID;
     pkt->iNanoStamina = nano.iStamina;
     pkt->bNanoDeactive = nano.iStamina <= 0;
-    pkt->eST = (int32_t)skill->skillType;
+    pkt->eST = skill->skillType;
     pkt->iTargetCnt = (int32_t)results.size();
 
     attachSkillResults(results, resultSize, (uint8_t*)(pkt + 1));
     sock->sendPacket(pkt, P_FE2CL_NANO_SKILL_USE_SUCC, resplen);
-
+    PlayerManager::sendToViewable(sock, pkt, P_FE2CL_NANO_SKILL_USE_SUCC, resplen);
-    if(skill->skillType == SkillType::RECALL_GROUP)
-        // group recall packet is sent only to group members
-        PlayerManager::sendToGroup(sock, pkt, P_FE2CL_NANO_SKILL_USE, resplen);
-    else
-        PlayerManager::sendToViewable(sock, pkt, P_FE2CL_NANO_SKILL_USE, resplen);
 
     if (nano.iStamina <= 0)
         Nanos::summonNano(sock, -1);
@@ -273,7 +263,7 @@ void Abilities::useNPCSkill(EntityRef npc, int skillID, std::vector<ICombatant*>
     sP_FE2CL_NPC_SKILL_HIT* pkt = (sP_FE2CL_NPC_SKILL_HIT*)respbuf;
     pkt->iNPC_ID = npc.id;
     pkt->iSkillID = skillID;
-    pkt->eST = (int32_t)skill->skillType;
+    pkt->eST = skill->skillType;
     pkt->iTargetCnt = (int32_t)results.size();
 
     attachSkillResults(results, resultSize, (uint8_t*)(pkt + 1));
@@ -293,6 +283,9 @@ static std::vector<ICombatant*> entityRefsToCombatants(std::vector<EntityRef> re
 
 std::vector<ICombatant*> Abilities::matchTargets(ICombatant* src, SkillData* skill, int count, int32_t *ids) {
 
+    if(skill->effectTarget == SkillEffectTarget::SELF)
+        return {src}; // client sends 0 targets for certain self-targeting skills (recall)
+
     if(skill->targetType == SkillTargetType::GROUP) {
         // group
         if(count != 1 || ids[0] != src->getID()) {
@@ -302,10 +295,6 @@ std::vector<ICombatant*> Abilities::matchTargets(ICombatant* src, SkillData* ski
         return entityRefsToCombatants(src->getGroupMembers());
     }
 
-    // this check *has* to happen after the group check above due to cases like group recall that use both
-    if(skill->effectTarget == SkillEffectTarget::SELF)
-        return {src}; // client sends 0 targets for certain self-targeting skills (recall)
-
     // individuals
     std::vector<ICombatant*> targets;
     for (int i = 0; i < count; i++) {
@@ -335,62 +324,62 @@ std::vector<ICombatant*> Abilities::matchTargets(ICombatant* src, SkillData* ski
 }
 
 /* ripped from client (enums emplaced) */
-int Abilities::getCSTBFromST(SkillType skillType) {
+int Abilities::getCSTBFromST(int eSkillType) {
     int result = 0;
-    switch (skillType)
+    switch (eSkillType)
     {
-    case SkillType::RUN:
+    case EST_RUN:
         result = ECSB_UP_MOVE_SPEED;
         break;
-    case SkillType::JUMP:
+    case EST_JUMP:
         result = ECSB_UP_JUMP_HEIGHT;
         break;
-    case SkillType::STEALTH:
+    case EST_STEALTH:
         result = ECSB_UP_STEALTH;
         break;
-    case SkillType::PHOENIX:
+    case EST_PHOENIX:
         result = ECSB_PHOENIX;
         break;
-    case SkillType::PROTECTBATTERY:
+    case EST_PROTECTBATTERY:
         result = ECSB_PROTECT_BATTERY;
         break;
-    case SkillType::PROTECTINFECTION:
+    case EST_PROTECTINFECTION:
         result = ECSB_PROTECT_INFECTION;
         break;
-    case SkillType::SNARE:
+    case EST_SNARE:
         result = ECSB_DN_MOVE_SPEED;
         break;
-    case SkillType::SLEEP:
+    case EST_SLEEP:
         result = ECSB_MEZ;
         break;
-    case SkillType::MINIMAPENEMY:
+    case EST_MINIMAPENEMY:
         result = ECSB_MINIMAP_ENEMY;
         break;
-    case SkillType::MINIMAPTRESURE:
+    case EST_MINIMAPTRESURE:
         result = ECSB_MINIMAP_TRESURE;
         break;
-    case SkillType::REWARDBLOB:
+    case EST_REWARDBLOB:
         result = ECSB_REWARD_BLOB;
         break;
-    case SkillType::REWARDCASH:
+    case EST_REWARDCASH:
         result = ECSB_REWARD_CASH;
         break;
-    case SkillType::INFECTIONDAMAGE:
+    case EST_INFECTIONDAMAGE:
         result = ECSB_INFECTION;
         break;
-    case SkillType::FREEDOM:
+    case EST_FREEDOM:
         result = ECSB_FREEDOM;
         break;
-    case SkillType::BOUNDINGBALL:
+    case EST_BOUNDINGBALL:
         result = ECSB_BOUNDINGBALL;
         break;
-    case SkillType::INVULNERABLE:
+    case EST_INVULNERABLE:
         result = ECSB_INVULNERABLE;
         break;
-    case SkillType::BUFFHEAL:
+    case EST_BUFFHEAL:
         result = ECSB_HEAL;
         break;
-    case SkillType::NANOSTIMPAK:
+    case EST_NANOSTIMPAK:
         result = ECSB_STIMPAKSLOT1;
         break;
     }

src/Abilities.hpp

@@ -10,47 +10,6 @@
 
 constexpr size_t MAX_SKILLRESULT_SIZE = sizeof(sSkillResult_BatteryDrain);
 
-enum class SkillType {
-    DAMAGE = 1,
-    HEAL_HP = 2,
-    KNOCKDOWN = 3,
-    SLEEP = 4,
-    SNARE = 5,
-    HEAL_STAMINA = 6,
-    STAMINA_SELF = 7,
-    STUN = 8,
-    WEAPONSLOW = 9,
-    JUMP = 10,
-    RUN = 11,
-    STEALTH = 12,
-    SWIM = 13,
-    MINIMAPENEMY = 14,
-    MINIMAPTRESURE = 15,
-    PHOENIX = 16,
-    PROTECTBATTERY = 17,
-    PROTECTINFECTION = 18,
-    REWARDBLOB = 19,
-    REWARDCASH = 20,
-    BATTERYDRAIN = 21,
-    CORRUPTIONATTACK = 22,
-    INFECTIONDAMAGE = 23,
-    KNOCKBACK = 24,
-    FREEDOM = 25,
-    PHOENIX_GROUP = 26,
-    RECALL = 27,
-    RECALL_GROUP = 28,
-    RETROROCKET_SELF = 29,
-    BLOODSUCKING = 30,
-    BOUNDINGBALL = 31,
-    INVULNERABLE = 32,
-    NANOSTIMPAK = 33,
-    RETURNHOMEHEAL = 34,
-    BUFFHEAL = 35,
-    EXTRABANK = 36,
-    CORRUPTIONATTACKWIN = 38,
-    CORRUPTIONATTACKLOSE = 39,
-};
-
 enum class SkillEffectTarget {
     POINT = 1,
     SELF = 2,
@@ -84,7 +43,7 @@ struct SkillResult {
 };
 
 struct SkillData {
-    SkillType skillType; // eST
+    int skillType; // eST
     SkillEffectTarget effectTarget;
     int effectType; // always 1?
     SkillTargetType targetType;
@@ -105,5 +64,5 @@ namespace Abilities {
     void useNPCSkill(EntityRef, int skillID, std::vector<ICombatant*>);
 
     std::vector<ICombatant*> matchTargets(ICombatant*, SkillData*, int, int32_t*);
-    int getCSTBFromST(SkillType skillType);
+    int getCSTBFromST(int eSkillType);
 }

src/Items.cpp

@@ -482,7 +482,7 @@ static void itemUseHandler(CNSocket* sock, CNPacketData* data) {
     resp->iSlotNum = request->iSlotNum;
     resp->RemainItem = gumball;
     resp->iTargetCnt = 1;
-    resp->eST = (int32_t)SkillType::NANOSTIMPAK;
+    resp->eST = EST_NANOSTIMPAK;
     resp->iSkillID = 144;
 
     int eCSB = ECSB_STIMPAKSLOT1 + request->iNanoSlot;

src/PlayerManager.cpp

@@ -338,14 +338,6 @@ static void enterPlayer(CNSocket* sock, CNPacketData* data) {
     delete lm;
 }
 
-void PlayerManager::sendToGroup(CNSocket* sock, void* buf, uint32_t type, size_t size) {
-    Player* plr = getPlayer(sock);
-    if (plr->group == nullptr)
-        return;
-    for(const EntityRef& ref : plr->group->filter(EntityKind::PLAYER))
-        ref.sock->sendPacket(buf, type, size);
-}
-
 void PlayerManager::sendToViewable(CNSocket* sock, void* buf, uint32_t type, size_t size) {
     Player* plr = getPlayer(sock);
     for (auto it = plr->viewableChunks.begin(); it != plr->viewableChunks.end(); it++) {

src/PlayerManager.hpp

@@ -33,7 +33,6 @@ namespace PlayerManager {
     CNSocket *getSockFromAny(int by, int id, int uid, std::string firstname, std::string lastname);
     WarpLocation *getRespawnPoint(Player *plr);
 
-    void sendToGroup(CNSocket *sock, void* buf, uint32_t type, size_t size);
     void sendToViewable(CNSocket *sock, void* buf, uint32_t type, size_t size);
 
     // TODO: unify this under the new Entity system

src/core/Defines.hpp

@@ -46,8 +46,49 @@ enum class ePCRegenType {
     End
 };
 
-// nano power flags
+// nano powers
 enum {
+    EST_NONE = 0,
+    EST_DAMAGE = 1,
+    EST_HEAL_HP = 2,
+    EST_KNOCKDOWN = 3,
+    EST_SLEEP = 4,
+    EST_SNARE = 5,
+    EST_HEAL_STAMINA = 6,
+    EST_STAMINA_SELF = 7,
+    EST_STUN = 8,
+    EST_WEAPONSLOW = 9,
+    EST_JUMP = 10,
+    EST_RUN = 11,
+    EST_STEALTH = 12,
+    EST_SWIM = 13,
+    EST_MINIMAPENEMY = 14,
+    EST_MINIMAPTRESURE = 15,
+    EST_PHOENIX = 16,
+    EST_PROTECTBATTERY = 17,
+    EST_PROTECTINFECTION = 18,
+    EST_REWARDBLOB = 19,
+    EST_REWARDCASH = 20,
+    EST_BATTERYDRAIN = 21,
+    EST_CORRUPTIONATTACK = 22,
+    EST_INFECTIONDAMAGE = 23,
+    EST_KNOCKBACK = 24,
+    EST_FREEDOM = 25,
+    EST_PHOENIX_GROUP = 26,
+    EST_RECALL = 27,
+    EST_RECALL_GROUP = 28,
+    EST_RETROROCKET_SELF = 29,
+    EST_BLOODSUCKING = 30,
+    EST_BOUNDINGBALL = 31,
+    EST_INVULNERABLE = 32,
+    EST_NANOSTIMPAK = 33,
+    EST_RETURNHOMEHEAL = 34,
+    EST_BUFFHEAL = 35,
+    EST_EXTRABANK = 36,
+    EST__END = 37,
+    EST_CORRUPTIONATTACKWIN = 38,
+    EST_CORRUPTIONATTACKLOSE = 39,
+
     ECSB_NONE = 0,
     ECSB_UP_MOVE_SPEED = 1,
     ECSB_UP_SWIM_SPEED = 2,