OpenPunk/OpenFusion
1
0
Fork 0
mirror of https://github.com/OpenFusionProject/OpenFusion.git synced 2024-11-14 02:10:06 +00:00
Code Issues Packages Projects Releases Wiki Activity

[WIP] Fix Nanos -> Abilities namespace calls

Browse Source
This commit is contained in:
gsemaj 2021-06-20 13:05:10 -04:00
parent c965024d1c
commit 32db574700
8 changed files with 53 additions and 53 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
src/Abilities.cpp
View File

@ -107,7 +107,7 @@ int Abilities::applyBuff(CNSocket* sock, int skillID, int eTBU, int eTBT, int32_
int32_t bitFlag = 0; int32_t bitFlag = 0;
for (auto& pwr : NanoPowers) { for (auto& pwr : Powers) {
if (pwr.skillType == SkillTable[skillID].skillType) { if (pwr.skillType == SkillTable[skillID].skillType) {
bitFlag = pwr.bitFlag; bitFlag = pwr.bitFlag;
Player *plr = PlayerManager::getPlayer(sock); Player *plr = PlayerManager::getPlayer(sock);
@ -686,7 +686,7 @@ template<class sPAYLOAD,
} }
// nano power dispatch table // nano power dispatch table
std::vector<Power> Powers = { std::vector<Power> Powers = {};/*
Power(EST_STUN, CSB_BIT_STUN, ECSB_STUN, power<sSkillResult_Damage_N_Debuff, doDamageNDebuff>), Power(EST_STUN, CSB_BIT_STUN, ECSB_STUN, power<sSkillResult_Damage_N_Debuff, doDamageNDebuff>),
Power(EST_HEAL_HP, CSB_BIT_NONE, ECSB_NONE, power<sSkillResult_Heal_HP, doHeal>), Power(EST_HEAL_HP, CSB_BIT_NONE, ECSB_NONE, power<sSkillResult_Heal_HP, doHeal>),
Power(EST_BOUNDINGBALL, CSB_BIT_BOUNDINGBALL, ECSB_BOUNDINGBALL, power<sSkillResult_Buff, doDebuff>), Power(EST_BOUNDINGBALL, CSB_BIT_BOUNDINGBALL, ECSB_BOUNDINGBALL, power<sSkillResult_Buff, doDebuff>),
@ -722,6 +722,6 @@ std::vector<Power> Powers = {
Power(EST_SLEEP, CSB_BIT_MEZ, ECSB_MEZ, power<sSkillResult_Damage_N_Debuff, doDamageNDebuff>), Power(EST_SLEEP, CSB_BIT_MEZ, ECSB_MEZ, power<sSkillResult_Damage_N_Debuff, doDamageNDebuff>),
Power(EST_BLOODSUCKING, CSB_BIT_NONE, ECSB_NONE, power<sSkillResult_Heal_HP, doLeech>), Power(EST_BLOODSUCKING, CSB_BIT_NONE, ECSB_NONE, power<sSkillResult_Heal_HP, doLeech>),
Power(EST_FREEDOM, CSB_BIT_FREEDOM, ECSB_FREEDOM, power<sSkillResult_Buff, doBuff>) Power(EST_FREEDOM, CSB_BIT_FREEDOM, ECSB_FREEDOM, power<sSkillResult_Buff, doBuff>)
}; };*/
}; // namespace }; // namespace

10
src/Eggs.cpp
View File

@ -19,7 +19,7 @@ int Eggs::eggBuffPlayer(CNSocket* sock, int skillId, int eggId, int duration) {
Player* otherPlr = PlayerManager::getPlayerFromID(plr->iIDGroup); Player* otherPlr = PlayerManager::getPlayerFromID(plr->iIDGroup);
int bitFlag = Groups::getGroupFlags(otherPlr); int bitFlag = Groups::getGroupFlags(otherPlr);
int CBFlag = Nanos::applyBuff(sock, skillId, 1, 3, bitFlag); int CBFlag = Abilities::applyBuff(sock, skillId, 1, 3, bitFlag);
size_t resplen; size_t resplen;
@ -41,7 +41,7 @@ int Eggs::eggBuffPlayer(CNSocket* sock, int skillId, int eggId, int duration) {
memset(respbuf, 0, resplen); memset(respbuf, 0, resplen);
skill->eCT = 1; skill->eCT = 1;
skill->iID = plr->iID; skill->iID = plr->iID;
skill->iDamage = PC_MAXHEALTH(plr->level) * Nanos::SkillTable[skillId].powerIntensity[0] / 1000; skill->iDamage = PC_MAXHEALTH(plr->level) * Abilities::SkillTable[skillId].powerIntensity[0] / 1000;
plr->HP -= skill->iDamage; plr->HP -= skill->iDamage;
if (plr->HP < 0) if (plr->HP < 0)
plr->HP = 0; plr->HP = 0;
@ -51,7 +51,7 @@ int Eggs::eggBuffPlayer(CNSocket* sock, int skillId, int eggId, int duration) {
memset(respbuf, 0, resplen); memset(respbuf, 0, resplen);
skill->eCT = 1; skill->eCT = 1;
skill->iID = plr->iID; skill->iID = plr->iID;
skill->iHealHP = PC_MAXHEALTH(plr->level) * Nanos::SkillTable[skillId].powerIntensity[0] / 1000; skill->iHealHP = PC_MAXHEALTH(plr->level) * Abilities::SkillTable[skillId].powerIntensity[0] / 1000;
plr->HP += skill->iHealHP; plr->HP += skill->iHealHP;
if (plr->HP > PC_MAXHEALTH(plr->level)) if (plr->HP > PC_MAXHEALTH(plr->level))
plr->HP = PC_MAXHEALTH(plr->level); plr->HP = PC_MAXHEALTH(plr->level);
@ -66,7 +66,7 @@ int Eggs::eggBuffPlayer(CNSocket* sock, int skillId, int eggId, int duration) {
skillUse->iNPC_ID = eggId; skillUse->iNPC_ID = eggId;
skillUse->iSkillID = skillId; skillUse->iSkillID = skillId;
skillUse->eST = Nanos::SkillTable[skillId].skillType; skillUse->eST = Abilities::SkillTable[skillId].skillType;
skillUse->iTargetCnt = 1; skillUse->iTargetCnt = 1;
sock->sendPacket((void*)&respbuf, P_FE2CL_NPC_SKILL_HIT, resplen); sock->sendPacket((void*)&respbuf, P_FE2CL_NPC_SKILL_HIT, resplen);
@ -100,7 +100,7 @@ static void eggStep(CNServer* serv, time_t currTime) {
Player* otherPlr = PlayerManager::getPlayerFromID(plr->iIDGroup); Player* otherPlr = PlayerManager::getPlayerFromID(plr->iIDGroup);
int groupFlags = Groups::getGroupFlags(otherPlr); int groupFlags = Groups::getGroupFlags(otherPlr);
for (auto& pwr : Nanos::NanoPowers) { for (auto& pwr : Abilities::Powers) {
if (pwr.bitFlag == CBFlag) { // pick the power with the right flag and unbuff if (pwr.bitFlag == CBFlag) { // pick the power with the right flag and unbuff
INITSTRUCT(sP_FE2CL_PC_BUFF_UPDATE, resp); INITSTRUCT(sP_FE2CL_PC_BUFF_UPDATE, resp);
resp.eCSTB = pwr.timeBuffID; resp.eCSTB = pwr.timeBuffID;

18
src/Groups.cpp
View File

@ -135,10 +135,10 @@ static void joinGroup(CNSocket* sock, CNPacketData* data) {
// client doesnt read nano data here // client doesnt read nano data here
if (varPlr != plr) { // apply the new member's buffs to the group and the group's buffs to the new member if (varPlr != plr) { // apply the new member's buffs to the group and the group's buffs to the new member
if (Nanos::SkillTable[varPlr->Nanos[varPlr->activeNano].iSkillID].targetType == 3) if (Abilities::SkillTable[varPlr->Nanos[varPlr->activeNano].iSkillID].targetType == 3)
Nanos::applyBuff(sock, varPlr->Nanos[varPlr->activeNano].iSkillID, 1, 1, bitFlag); Abilities::applyBuff(sock, varPlr->Nanos[varPlr->activeNano].iSkillID, 1, 1, bitFlag);
if (Nanos::SkillTable[plr->Nanos[plr->activeNano].iSkillID].targetType == 3) if (Abilities::SkillTable[plr->Nanos[plr->activeNano].iSkillID].targetType == 3)
Nanos::applyBuff(sockTo, plr->Nanos[plr->activeNano].iSkillID, 1, 1, bitFlag); Abilities::applyBuff(sockTo, plr->Nanos[plr->activeNano].iSkillID, 1, 1, bitFlag);
} }
} }
@ -221,7 +221,7 @@ static void groupUnbuff(Player* plr) {
Player* otherPlr = PlayerManager::getPlayerFromID(plr->groupIDs[i]); Player* otherPlr = PlayerManager::getPlayerFromID(plr->groupIDs[i]);
CNSocket* sock = PlayerManager::getSockFromID(plr->groupIDs[n]); CNSocket* sock = PlayerManager::getSockFromID(plr->groupIDs[n]);
Nanos::applyBuff(sock, otherPlr->Nanos[otherPlr->activeNano].iSkillID, 2, 1, 0); Abilities::applyBuff(sock, otherPlr->Nanos[otherPlr->activeNano].iSkillID, 2, 1, 0);
} }
} }
} }
@ -295,10 +295,10 @@ void Groups::groupKickPlayer(Player* plr) {
moveDown = 1; moveDown = 1;
otherPlr->groupIDs[i] = 0; otherPlr->groupIDs[i] = 0;
} else { // remove the leaving member's buffs from the group and remove the group buffs from the leaving member. } else { // remove the leaving member's buffs from the group and remove the group buffs from the leaving member.
if (Nanos::SkillTable[varPlr->Nanos[varPlr->activeNano].iSkillID].targetType == 3) if (Abilities::SkillTable[varPlr->Nanos[varPlr->activeNano].iSkillID].targetType == 3)
Nanos::applyBuff(sock, varPlr->Nanos[varPlr->activeNano].iSkillID, 2, 1, 0); Abilities::applyBuff(sock, varPlr->Nanos[varPlr->activeNano].iSkillID, 2, 1, 0);
if (Nanos::SkillTable[plr->Nanos[varPlr->activeNano].iSkillID].targetType == 3) if (Abilities::SkillTable[plr->Nanos[varPlr->activeNano].iSkillID].targetType == 3)
Nanos::applyBuff(sockTo, plr->Nanos[plr->activeNano].iSkillID, 2, 1, bitFlag); Abilities::applyBuff(sockTo, plr->Nanos[plr->activeNano].iSkillID, 2, 1, bitFlag);
} }
} }

2
src/Items.cpp
View File

@ -501,7 +501,7 @@ static void itemUseHandler(CNSocket* sock, CNPacketData* data) {
player->Inven[resp->iSlotNum] = resp->RemainItem; player->Inven[resp->iSlotNum] = resp->RemainItem;
std::pair<CNSocket*, int32_t> key = std::make_pair(sock, value1); std::pair<CNSocket*, int32_t> key = std::make_pair(sock, value1);
time_t until = getTime() + (time_t)Nanos::SkillTable[144].durationTime[0] * 100; time_t until = getTime() + (time_t)Abilities::SkillTable[144].durationTime[0] * 100;
Eggs::EggBuffs[key] = until; Eggs::EggBuffs[key] = until;
} }

32
src/MobAI.cpp
View File

@ -235,7 +235,7 @@ static void dealCorruption(Mob *mob, std::vector<int> targetData, int skillID, i
int style2 = Nanos::nanoStyle(plr->activeNano); int style2 = Nanos::nanoStyle(plr->activeNano);
if (style2 == -1) { // no nano if (style2 == -1) { // no nano
respdata[i].iHitFlag = 8; respdata[i].iHitFlag = 8;
respdata[i].iDamage = Nanos::SkillTable[skillID].powerIntensity[0] * PC_MAXHEALTH((int)mob->data["m_iNpcLevel"]) / 1500; respdata[i].iDamage = Abilities::SkillTable[skillID].powerIntensity[0] * PC_MAXHEALTH((int)mob->data["m_iNpcLevel"]) / 1500;
} else if (style == style2) { } else if (style == style2) {
respdata[i].iHitFlag = 8; // tie respdata[i].iHitFlag = 8; // tie
respdata[i].iDamage = 0; respdata[i].iDamage = 0;
@ -248,12 +248,12 @@ static void dealCorruption(Mob *mob, std::vector<int> targetData, int skillID, i
respdata[i].iNanoStamina = plr->Nanos[plr->activeNano].iStamina = 150; respdata[i].iNanoStamina = plr->Nanos[plr->activeNano].iStamina = 150;
// fire damage power disguised as a corruption attack back at the enemy // fire damage power disguised as a corruption attack back at the enemy
std::vector<int> targetData2 = {1, mob->appearanceData.iNPC_ID, 0, 0, 0}; std::vector<int> targetData2 = {1, mob->appearanceData.iNPC_ID, 0, 0, 0};
for (auto& pwr : Nanos::NanoPowers) for (auto& pwr : Abilities::Powers)
if (pwr.skillType == EST_DAMAGE) if (pwr.skillType == EST_DAMAGE)
pwr.handle(sock, targetData2, plr->activeNano, skillID, 0, 200); pwr.handle(sock, targetData2, plr->activeNano, skillID, 0, 200);
} else { } else {
respdata[i].iHitFlag = 16; // lose respdata[i].iHitFlag = 16; // lose
respdata[i].iDamage = Nanos::SkillTable[skillID].powerIntensity[0] * PC_MAXHEALTH((int)mob->data["m_iNpcLevel"]) / 1500; respdata[i].iDamage = Abilities::SkillTable[skillID].powerIntensity[0] * PC_MAXHEALTH((int)mob->data["m_iNpcLevel"]) / 1500;
respdata[i].iNanoStamina = plr->Nanos[plr->activeNano].iStamina -= 90; respdata[i].iNanoStamina = plr->Nanos[plr->activeNano].iStamina -= 90;
if (plr->Nanos[plr->activeNano].iStamina < 0) { if (plr->Nanos[plr->activeNano].iStamina < 0) {
respdata[i].bNanoDeactive = 1; respdata[i].bNanoDeactive = 1;
@ -319,7 +319,7 @@ static void useAbilities(Mob *mob, time_t currTime) {
continue; continue;
int distance = hypot(mob->hitX - plr->x, mob->hitY - plr->y); int distance = hypot(mob->hitX - plr->x, mob->hitY - plr->y);
if (distance < Nanos::SkillTable[skillID].effectArea) { if (distance < Abilities::SkillTable[skillID].effectArea) {
targetData[0] += 1; targetData[0] += 1;
targetData[targetData[0]] = plr->iID; targetData[targetData[0]] = plr->iID;
if (targetData[0] > 3) // make sure not to have more than 4 if (targetData[0] > 3) // make sure not to have more than 4
@ -328,9 +328,9 @@ static void useAbilities(Mob *mob, time_t currTime) {
} }
} }
for (auto& pwr : Combat::MobPowers) for (auto& pwr : Abilities::Powers)
if (pwr.skillType == Nanos::SkillTable[skillID].skillType) if (pwr.skillType == Abilities::SkillTable[skillID].skillType)
pwr.handle(mob, targetData, skillID, Nanos::SkillTable[skillID].durationTime[0], Nanos::SkillTable[skillID].powerIntensity[0]); pwr.handle(mob, targetData, skillID, Abilities::SkillTable[skillID].durationTime[0], Abilities::SkillTable[skillID].powerIntensity[0]);
mob->skillStyle = -3; // eruption cooldown mob->skillStyle = -3; // eruption cooldown
mob->nextAttack = currTime + 1000; mob->nextAttack = currTime + 1000;
return; return;
@ -349,11 +349,11 @@ static void useAbilities(Mob *mob, time_t currTime) {
if (random < prob1) { // active skill hit if (random < prob1) { // active skill hit
int skillID = (int)mob->data["m_iActiveSkill1"]; int skillID = (int)mob->data["m_iActiveSkill1"];
std::vector<int> targetData = {1, plr->iID, 0, 0, 0}; std::vector<int> targetData = {1, plr->iID, 0, 0, 0};
for (auto& pwr : Combat::MobPowers) for (auto& pwr : Abilities::Powers)
if (pwr.skillType == Nanos::SkillTable[skillID].skillType) { if (pwr.skillType == Abilities::SkillTable[skillID].skillType) {
if (pwr.bitFlag != 0 && (plr->iConditionBitFlag & pwr.bitFlag)) if (pwr.bitFlag != 0 && (plr->iConditionBitFlag & pwr.bitFlag))
return; // prevent debuffing a player twice return; // prevent debuffing a player twice
pwr.handle(mob, targetData, skillID, Nanos::SkillTable[skillID].durationTime[0], Nanos::SkillTable[skillID].powerIntensity[0]); pwr.handle(mob, targetData, skillID, Abilities::SkillTable[skillID].durationTime[0], Abilities::SkillTable[skillID].powerIntensity[0]);
} }
mob->nextAttack = currTime + (int)mob->data["m_iDelayTime"] * 100; mob->nextAttack = currTime + (int)mob->data["m_iDelayTime"] * 100;
return; return;
@ -407,9 +407,9 @@ void MobAI::enterCombat(CNSocket *sock, Mob *mob) {
int skillID = (int)mob->data["m_iPassiveBuff"]; // cast passive int skillID = (int)mob->data["m_iPassiveBuff"]; // cast passive
std::vector<int> targetData = {1, mob->appearanceData.iNPC_ID, 0, 0, 0}; std::vector<int> targetData = {1, mob->appearanceData.iNPC_ID, 0, 0, 0};
for (auto& pwr : Combat::MobPowers) for (auto& pwr : Abilities::Powers)
if (pwr.skillType == Nanos::SkillTable[skillID].skillType) if (pwr.skillType == Abilities::SkillTable[skillID].skillType)
pwr.handle(mob, targetData, skillID, Nanos::SkillTable[skillID].durationTime[0], Nanos::SkillTable[skillID].powerIntensity[0]); pwr.handle(mob, targetData, skillID, Abilities::SkillTable[skillID].durationTime[0], Abilities::SkillTable[skillID].powerIntensity[0]);
for (NPCEvent& event : NPCManager::NPCEvents) // trigger an ON_COMBAT for (NPCEvent& event : NPCManager::NPCEvents) // trigger an ON_COMBAT
if (event.trigger == ON_COMBAT && event.npcType == mob->appearanceData.iNPCType) if (event.trigger == ON_COMBAT && event.npcType == mob->appearanceData.iNPCType)
@ -773,9 +773,9 @@ static void retreatStep(Mob *mob, time_t currTime) {
// cast a return home heal spell, this is the right way(tm) // cast a return home heal spell, this is the right way(tm)
std::vector<int> targetData = {1, 0, 0, 0, 0}; std::vector<int> targetData = {1, 0, 0, 0, 0};
for (auto& pwr : Combat::MobPowers) for (auto& pwr : Abilities::Powers)
if (pwr.skillType == Nanos::SkillTable[110].skillType) if (pwr.skillType == Abilities::SkillTable[110].skillType)
pwr.handle(mob, targetData, 110, Nanos::SkillTable[110].durationTime[0], Nanos::SkillTable[110].powerIntensity[0]); pwr.handle(mob, targetData, 110, Abilities::SkillTable[110].durationTime[0], Abilities::SkillTable[110].powerIntensity[0]);
// clear outlying debuffs // clear outlying debuffs
clearDebuff(mob); clearDebuff(mob);
} }

32
src/Nanos.cpp
View File

@ -86,12 +86,12 @@ void Nanos::summonNano(CNSocket *sock, int slot, bool silent) {
int16_t skillID = plr->Nanos[plr->activeNano].iSkillID; int16_t skillID = plr->Nanos[plr->activeNano].iSkillID;
// passive nano unbuffing // passive nano unbuffing
if (SkillTable[skillID].drainType == 2) { if (Abilities::SkillTable[skillID].drainType == 2) {
std::vector<int> targetData = findTargets(plr, skillID); std::vector<int> targetData = Abilities::findTargets(plr, skillID);
for (auto& pwr : NanoPowers) for (auto& pwr : Abilities::Powers)
if (pwr.skillType == SkillTable[skillID].skillType) if (pwr.skillType == Abilities::SkillTable[skillID].skillType)
nanoUnbuff(sock, targetData, pwr.bitFlag, pwr.timeBuffID, 0,(SkillTable[skillID].targetType == 3)); Abilities::removeBuff(sock, targetData, pwr.bitFlag, pwr.timeBuffID, 0,(Abilities::SkillTable[skillID].targetType == 3));
} }
if (nanoID >= NANO_COUNT || nanoID < 0) if (nanoID >= NANO_COUNT || nanoID < 0)
@ -101,19 +101,19 @@ void Nanos::summonNano(CNSocket *sock, int slot, bool silent) {
skillID = plr->Nanos[nanoID].iSkillID; skillID = plr->Nanos[nanoID].iSkillID;
// passive nano buffing // passive nano buffing
if (SkillTable[skillID].drainType == 2) { if (Abilities::SkillTable[skillID].drainType == 2) {
std::vector<int> targetData = findTargets(plr, skillID); std::vector<int> targetData = Abilities::findTargets(plr, skillID);
int boost = 0; int boost = 0;
if (getNanoBoost(plr)) if (getNanoBoost(plr))
boost = 1; boost = 1;
for (auto& pwr : NanoPowers) { for (auto& pwr : Abilities::Powers) {
if (pwr.skillType == SkillTable[skillID].skillType) { if (pwr.skillType == Abilities::SkillTable[skillID].skillType) {
resp.eCSTB___Add = 1; // the part that makes nano go ZOOMAZOOM resp.eCSTB___Add = 1; // the part that makes nano go ZOOMAZOOM
plr->nanoDrainRate = SkillTable[skillID].batteryUse[boost*3]; plr->nanoDrainRate = Abilities::SkillTable[skillID].batteryUse[boost*3];
pwr.handle(sock, targetData, nanoID, skillID, 0, SkillTable[skillID].powerIntensity[boost]); pwr.handle(sock, targetData, nanoID, skillID, 0, Abilities::SkillTable[skillID].powerIntensity[boost]);
} }
} }
} }
@ -296,19 +296,19 @@ static void nanoSkillUseHandler(CNSocket* sock, CNPacketData* data) {
std::cout << PlayerManager::getPlayerName(plr) << " requested to summon nano skill " << std::endl; std::cout << PlayerManager::getPlayerName(plr) << " requested to summon nano skill " << std::endl;
) )
std::vector<int> targetData = findTargets(plr, skillID, data); std::vector<int> targetData = Abilities::findTargets(plr, skillID, data);
int boost = 0; int boost = 0;
if (getNanoBoost(plr)) if (getNanoBoost(plr))
boost = 1; boost = 1;
plr->Nanos[plr->activeNano].iStamina -= SkillTable[skillID].batteryUse[boost*3]; plr->Nanos[plr->activeNano].iStamina -= Abilities::SkillTable[skillID].batteryUse[boost*3];
if (plr->Nanos[plr->activeNano].iStamina < 0) if (plr->Nanos[plr->activeNano].iStamina < 0)
plr->Nanos[plr->activeNano].iStamina = 0; plr->Nanos[plr->activeNano].iStamina = 0;
for (auto& pwr : NanoPowers) for (auto& pwr : Abilities::Powers)
if (pwr.skillType == SkillTable[skillID].skillType) if (pwr.skillType == Abilities::SkillTable[skillID].skillType)
pwr.handle(sock, targetData, nanoID, skillID, SkillTable[skillID].durationTime[boost], SkillTable[skillID].powerIntensity[boost]); pwr.handle(sock, targetData, nanoID, skillID, Abilities::SkillTable[skillID].durationTime[boost], Abilities::SkillTable[skillID].powerIntensity[boost]);
if (plr->Nanos[plr->activeNano].iStamina < 0) if (plr->Nanos[plr->activeNano].iStamina < 0)
summonNano(sock, -1); summonNano(sock, -1);

2
src/PlayerManager.cpp
View File

@ -410,7 +410,7 @@ static void revivePlayer(CNSocket* sock, CNPacketData* data) {
// nano revive // nano revive
plr->Nanos[plr->activeNano].iStamina = 0; plr->Nanos[plr->activeNano].iStamina = 0;
plr->HP = PC_MAXHEALTH(plr->level) / 2; plr->HP = PC_MAXHEALTH(plr->level) / 2;
Nanos::applyBuff(sock, plr->Nanos[plr->activeNano].iSkillID, 2, 1, 0); Abilities::applyBuff(sock, plr->Nanos[plr->activeNano].iSkillID, 2, 1, 0);
} else if (reviveData->iRegenType == 4) { } else if (reviveData->iRegenType == 4) {
// revived by group member's nano // revived by group member's nano
plr->HP = PC_MAXHEALTH(plr->level) / 2; plr->HP = PC_MAXHEALTH(plr->level) / 2;

4
src/TableData.cpp
View File

@ -239,10 +239,10 @@ static void loadXDT(json& xdtData) {
skillData.durationTime[i] = skills["m_iDurationTime"][i]; skillData.durationTime[i] = skills["m_iDurationTime"][i];
skillData.powerIntensity[i] = skills["m_iValueA"][i]; skillData.powerIntensity[i] = skills["m_iValueA"][i];
} }
Nanos::SkillTable[skills["m_iSkillNumber"]] = skillData; Abilities::SkillTable[skills["m_iSkillNumber"]] = skillData;
} }
std::cout << "[INFO] Loaded " << Nanos::SkillTable.size() << " nano skills" << std::endl; std::cout << "[INFO] Loaded " << Abilities::SkillTable.size() << " nano skills" << std::endl;
// load EP data // load EP data
json instances = xdtData["m_pInstanceTable"]["m_pInstanceData"]; json instances = xdtData["m_pInstanceTable"]["m_pInstanceData"];