OpenFusion/src/NanoManager.cpp

205 lines
6.5 KiB
C++
Raw Normal View History

2020-08-20 15:43:37 +00:00
#include "CNShardServer.hpp"
#include "CNStructs.hpp"
#include "NanoManager.hpp"
#include "PlayerManager.hpp"
void NanoManager::init() {
2020-08-21 00:37:34 +00:00
REGISTER_SHARD_PACKET(P_CL2FE_REQ_NANO_ACTIVE, nanoSummonHandler);
REGISTER_SHARD_PACKET(P_CL2FE_REQ_NANO_EQUIP, nanoEquipHandler);
REGISTER_SHARD_PACKET(P_CL2FE_REQ_NANO_UNEQUIP, nanoUnEquipHandler);
REGISTER_SHARD_PACKET(P_CL2FE_REQ_PC_GIVE_NANO, nanoGMGiveHandler);
REGISTER_SHARD_PACKET(P_CL2FE_REQ_NANO_TUNE, nanoSkillSetHandler);
REGISTER_SHARD_PACKET(P_CL2FE_REQ_NANO_SKILL_USE, nanoSkillUseHandler);
}
void NanoManager::nanoEquipHandler(CNSocket* sock, CNPacketData* data) {
if (data->size != sizeof(sP_CL2FE_REQ_NANO_EQUIP))
return; // malformed packet
sP_CL2FE_REQ_NANO_EQUIP* nano = (sP_CL2FE_REQ_NANO_EQUIP*)data->buf;
2020-08-23 00:26:18 +00:00
INITSTRUCT(sP_FE2CL_REP_NANO_EQUIP_SUCC, resp);
Player plr = PlayerManager::getPlayer(sock);
2020-08-23 03:15:27 +00:00
if (nano->iNanoSlotNum > 2)
return;
2020-08-22 23:31:09 +00:00
resp.iNanoID = nano->iNanoID;
resp.iNanoSlotNum = nano->iNanoSlotNum;
2020-08-23 03:15:27 +00:00
// Update player
plr.equippedNanos[nano->iNanoSlotNum] = nano->iNanoID;
PlayerManager::updatePlayer(sock, plr);
2020-08-22 23:31:09 +00:00
sock->sendPacket((void*)&resp, P_FE2CL_REP_NANO_EQUIP_SUCC, sizeof(sP_FE2CL_REP_NANO_EQUIP_SUCC));
}
void NanoManager::nanoUnEquipHandler(CNSocket* sock, CNPacketData* data) {
if (data->size != sizeof(sP_CL2FE_REQ_NANO_UNEQUIP))
return; // malformed packet
sP_CL2FE_REQ_NANO_UNEQUIP* nano = (sP_CL2FE_REQ_NANO_UNEQUIP*)data->buf;
2020-08-23 00:26:18 +00:00
INITSTRUCT(sP_FE2CL_REP_NANO_UNEQUIP_SUCC, resp);
Player plr = PlayerManager::getPlayer(sock);
2020-08-22 23:31:09 +00:00
2020-08-23 03:15:27 +00:00
if (nano->iNanoSlotNum > 2)
return;
2020-08-22 23:31:09 +00:00
resp.iNanoSlotNum = nano->iNanoSlotNum;
// update player
plr.equippedNanos[nano->iNanoSlotNum] = 0;
PlayerManager::updatePlayer(sock, plr);
2020-08-22 23:31:09 +00:00
sock->sendPacket((void*)&resp, P_FE2CL_REP_NANO_UNEQUIP_SUCC, sizeof(sP_FE2CL_REP_NANO_UNEQUIP_SUCC));
}
void NanoManager::nanoGMGiveHandler(CNSocket* sock, CNPacketData* data) {
if (data->size != sizeof(sP_CL2FE_REQ_PC_GIVE_NANO))
return; // ignore the malformed packet
// Cmd: /nano <nanoId>
sP_CL2FE_REQ_PC_GIVE_NANO* nano = (sP_CL2FE_REQ_PC_GIVE_NANO*)data->buf;
Player plr = PlayerManager::getPlayer(sock);
// Add nano to player
addNano(sock, nano->iNanoID, 0);
DEBUGLOG(
std::cout << U16toU8(plr.PCStyle.szFirstName) << U16toU8(plr.PCStyle.szLastName) << " requested to add nano id: " << nano->iNanoID << std::endl;
)
2020-08-20 15:43:37 +00:00
}
void NanoManager::nanoSummonHandler(CNSocket* sock, CNPacketData* data) {
2020-08-21 00:37:34 +00:00
if (data->size != sizeof(sP_CL2FE_REQ_NANO_ACTIVE))
2020-08-20 23:50:30 +00:00
return; // malformed packet
sP_CL2FE_REQ_NANO_ACTIVE* pkt = (sP_CL2FE_REQ_NANO_ACTIVE*)data->buf;
2020-08-21 00:37:34 +00:00
PlayerView plr = PlayerManager::players[sock];
2020-08-20 15:43:37 +00:00
2020-08-21 00:37:34 +00:00
// Send to client
2020-08-23 00:26:18 +00:00
INITSTRUCT(sP_FE2CL_REP_NANO_ACTIVE_SUCC, resp);
resp.iActiveNanoSlotNum = pkt->iNanoSlotNum;
2020-08-22 23:31:09 +00:00
sock->sendPacket((void*)&resp, P_FE2CL_REP_NANO_ACTIVE_SUCC, sizeof(sP_FE2CL_REP_NANO_ACTIVE_SUCC));
2020-08-20 15:43:37 +00:00
2020-08-23 03:15:27 +00:00
if (pkt->iNanoSlotNum > 2)
return;
int nanoId = plr.plr.equippedNanos[pkt->iNanoSlotNum];
2020-08-23 03:15:27 +00:00
if (nanoId > 36)
return; // sanity check
sNano nano = plr.plr.Nanos[nanoId];
// Send to other players
for (CNSocket *s : PlayerManager::players[sock].viewable) {
INITSTRUCT(sP_FE2CL_NANO_ACTIVE, pkt);
pkt.iPC_ID = plr.plr.iID;
pkt.Nano = nano;
s->sendPacket((void*)&pkt, P_FE2CL_NANO_ACTIVE, sizeof(sP_FE2CL_NANO_ACTIVE));
}
// update player
plr.plr.nano = nanoId;
PlayerManager::updatePlayer(sock, plr.plr);
DEBUGLOG(
std::cout << U16toU8(plr.plr.PCStyle.szFirstName) << U16toU8(plr.plr.PCStyle.szLastName) << " requested to summon nano slot: " << pkt->iNanoSlotNum << std::endl;
)
}
void NanoManager::nanoSkillUseHandler(CNSocket* sock, CNPacketData* data) {
if (data->size != sizeof(sP_CL2FE_REQ_NANO_SKILL_USE))
return; // malformed packet
sP_CL2FE_REQ_NANO_SKILL_USE* skill = (sP_CL2FE_REQ_NANO_SKILL_USE*)data->buf;
PlayerView plr = PlayerManager::players[sock];
// Send to client
2020-08-23 00:26:18 +00:00
INITSTRUCT(sP_FE2CL_NANO_SKILL_USE_SUCC, resp);
2020-08-22 23:31:09 +00:00
resp.iArg1 = skill->iArg1;
resp.iArg2 = skill->iArg2;
resp.iArg3 = skill->iArg3;
resp.iBulletID = skill->iBulletID;
resp.iTargetCnt = skill->iTargetCnt;
resp.iPC_ID = plr.plr.iID;
resp.iNanoStamina = 150; // Hardcoded for now
2020-08-22 23:31:09 +00:00
sock->sendPacket((void*)&resp, P_FE2CL_NANO_SKILL_USE_SUCC, sizeof(sP_FE2CL_NANO_SKILL_USE_SUCC));
2020-08-22 18:08:37 +00:00
DEBUGLOG(
std::cout << U16toU8(plr.plr.PCStyle.szFirstName) << U16toU8(plr.plr.PCStyle.szLastName) << " requested to summon nano skill " << std::endl;
)
}
void NanoManager::nanoSkillSetHandler(CNSocket* sock, CNPacketData* data) {
if (data->size != sizeof(sP_CL2FE_REQ_NANO_TUNE))
return; // malformed packet
sP_CL2FE_REQ_NANO_TUNE* skill = (sP_CL2FE_REQ_NANO_TUNE*)data->buf;
setNanoSkill(sock, skill->iNanoID, skill->iTuneID);
}
#pragma region Helper methods
void NanoManager::addNano(CNSocket* sock, int16_t nanoId, int16_t slot) {
2020-08-23 03:15:27 +00:00
if (nanoId > 36)
return;
Player plr = PlayerManager::getPlayer(sock);
// Send to client
2020-08-23 00:26:18 +00:00
INITSTRUCT(sP_FE2CL_REP_PC_NANO_CREATE_SUCC, resp);
2020-08-22 23:31:09 +00:00
resp.Nano.iID = nanoId;
resp.Nano.iStamina = 150;
resp.iQuestItemSlotNum = slot;
2020-08-22 23:31:09 +00:00
sock->sendPacket((void*)&resp, P_FE2CL_REP_PC_NANO_CREATE_SUCC, sizeof(sP_FE2CL_REP_PC_NANO_CREATE_SUCC));
// Update player
2020-08-22 23:31:09 +00:00
plr.Nanos[nanoId] = resp.Nano;
PlayerManager::updatePlayer(sock, plr);
}
void NanoManager::setNanoSkill(CNSocket* sock, int16_t nanoId, int16_t skillId) {
2020-08-23 03:15:27 +00:00
if (nanoId > 36)
return;
Player plr = PlayerManager::getPlayer(sock);
sNano nano = plr.Nanos[nanoId];
nano.iSkillID = skillId;
plr.Nanos[nanoId] = nano;
// Send to client
2020-08-23 00:26:18 +00:00
INITSTRUCT(sP_FE2CL_REP_NANO_TUNE_SUCC, resp);
2020-08-22 23:31:09 +00:00
resp.iNanoID = nanoId;
resp.iSkillID = skillId;
2020-08-22 23:31:09 +00:00
sock->sendPacket((void*)&resp, P_FE2CL_REP_NANO_TUNE_SUCC, sizeof(sP_FE2CL_REP_NANO_TUNE_SUCC));
DEBUGLOG(
std::cout << U16toU8(plr.PCStyle.szFirstName) << U16toU8(plr.PCStyle.szLastName) << " set skill id " << skillId << " for nano: " << nanoId << std::endl;
)
// Update the player
PlayerManager::updatePlayer(sock, plr);
}
void NanoManager::resetNanoSkill(CNSocket* sock, int16_t nanoId) {
2020-08-23 03:15:27 +00:00
if (nanoId > 36)
return;
Player plr = PlayerManager::getPlayer(sock);
sNano nano = plr.Nanos[nanoId];
nano.iSkillID = 0;
plr.Nanos[nanoId] = nano;
// Update the player
PlayerManager::updatePlayer(sock, plr);
2020-08-21 00:37:34 +00:00
}
#pragma endregion