OpenPunk/OpenFusion
1
0
Fork 0
mirror of https://github.com/OpenFusionProject/OpenFusion.git synced 2024-09-28 14:38:21 +00:00
Code Issues Packages Projects Releases Wiki Activity

Get rid of PlayerView. For good.

Browse Source
This commit is contained in:
Gent S 2020-11-17 18:16:16 -05:00
parent d2e776b672
commit 5cbb8538c0
12 changed files with 241 additions and 246 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/BuddyManager.cpp
View File

@ -136,7 +136,7 @@ void BuddyManager::reqBuddyByName(CNSocket* sock, CNPacketData* data) {
CNSocket* otherSock = nullptr; CNSocket* otherSock = nullptr;
for (auto& pair : PlayerManager::players) { for (auto& pair : PlayerManager::players) {
Player* plr = pair.second.plr; Player* plr = pair.second;
if (strcmp(U16toU8(plr->PCStyle.szFirstName).c_str(), U16toU8(pkt->szFirstName).c_str()) == 0 if (strcmp(U16toU8(plr->PCStyle.szFirstName).c_str(), U16toU8(pkt->szFirstName).c_str()) == 0
&& strcmp(U16toU8(plr->PCStyle.szLastName).c_str(), U16toU8(pkt->szLastName).c_str()) == 0 && strcmp(U16toU8(plr->PCStyle.szLastName).c_str(), U16toU8(pkt->szLastName).c_str()) == 0
&& !playerHasBuddyWithID(plrReq, plr->iID)) { && !playerHasBuddyWithID(plrReq, plr->iID)) {

8
src/CNShardServer.cpp
View File

@ -32,15 +32,15 @@ void CNShardServer::handlePacket(CNSocket* sock, CNPacketData* data) {
std::cerr << "OpenFusion: SHARD UNIMPLM ERR. PacketType: " << Defines::p2str(CL2FE, data->type) << " (" << data->type << ")" << std::endl; std::cerr << "OpenFusion: SHARD UNIMPLM ERR. PacketType: " << Defines::p2str(CL2FE, data->type) << " (" << data->type << ")" << std::endl;
if (PlayerManager::players.find(sock) != PlayerManager::players.end()) if (PlayerManager::players.find(sock) != PlayerManager::players.end())
PlayerManager::players[sock].lastHeartbeat = getTime(); PlayerManager::players[sock]->lastHeartbeat = getTime();
} }
void CNShardServer::keepAliveTimer(CNServer* serv, time_t currTime) { void CNShardServer::keepAliveTimer(CNServer* serv, time_t currTime) {
for (auto& pair : PlayerManager::players) { for (auto& pair : PlayerManager::players) {
if (pair.second.lastHeartbeat != 0 && currTime - pair.second.lastHeartbeat > settings::TIMEOUT) { if (pair.second->lastHeartbeat != 0 && currTime - pair.second->lastHeartbeat > settings::TIMEOUT) {
// if the client hasn't responded in 60 seconds, its a dead connection so throw it out // if the client hasn't responded in 60 seconds, its a dead connection so throw it out
pair.first->kill(); pair.first->kill();
} else if (pair.second.lastHeartbeat != 0 && currTime - pair.second.lastHeartbeat > settings::TIMEOUT/2) { } else if (pair.second->lastHeartbeat != 0 && currTime - pair.second->lastHeartbeat > settings::TIMEOUT/2) {
// if the player hasn't responded in 30 seconds, send a live check // if the player hasn't responded in 30 seconds, send a live check
INITSTRUCT(sP_FE2CL_REQ_LIVE_CHECK, data); INITSTRUCT(sP_FE2CL_REQ_LIVE_CHECK, data);
pair.first->sendPacket((void*)&data, P_FE2CL_REQ_LIVE_CHECK, sizeof(sP_FE2CL_REQ_LIVE_CHECK)); pair.first->sendPacket((void*)&data, P_FE2CL_REQ_LIVE_CHECK, sizeof(sP_FE2CL_REQ_LIVE_CHECK));
@ -55,7 +55,7 @@ void CNShardServer::periodicSaveTimer(CNServer* serv, time_t currTime) {
std::cout << "[INFO] Saving " << PlayerManager::players.size() << " players to DB..." << std::endl; std::cout << "[INFO] Saving " << PlayerManager::players.size() << " players to DB..." << std::endl;
for (auto& pair : PlayerManager::players) { for (auto& pair : PlayerManager::players) {
Database::updatePlayer(pair.second.plr); Database::updatePlayer(pair.second);
} }
TableData::flush(); TableData::flush();

34
src/ChatManager.cpp
View File

@ -260,10 +260,9 @@ void summonWCommand(std::string full, std::vector<std::string>& args, CNSocket*
} }
void unsummonWCommand(std::string full, std::vector<std::string>& args, CNSocket* sock) { void unsummonWCommand(std::string full, std::vector<std::string>& args, CNSocket* sock) {
PlayerView& plrv = PlayerManager::players[sock]; Player* plr = PlayerManager::getPlayer(sock);
Player* plr = plrv.plr;
BaseNPC* npc = NPCManager::getNearestNPC(plrv.currentChunks, plr->x, plr->y, plr->z); BaseNPC* npc = NPCManager::getNearestNPC(*plr->currentChunks, plr->x, plr->y, plr->z);
if (npc == nullptr) { if (npc == nullptr) {
ChatManager::sendServerMessage(sock, "/unsummonW: No NPCs found nearby"); ChatManager::sendServerMessage(sock, "/unsummonW: No NPCs found nearby");
@ -317,10 +316,9 @@ void toggleAiCommand(std::string full, std::vector<std::string>& args, CNSocket*
} }
void npcRotateCommand(std::string full, std::vector<std::string>& args, CNSocket* sock) { void npcRotateCommand(std::string full, std::vector<std::string>& args, CNSocket* sock) {
PlayerView& plrv = PlayerManager::players[sock]; Player* plr = PlayerManager::getPlayer(sock);
Player* plr = plrv.plr;
BaseNPC* npc = NPCManager::getNearestNPC(plrv.currentChunks, plr->x, plr->y, plr->z); BaseNPC* npc = NPCManager::getNearestNPC(*plr->currentChunks, plr->x, plr->y, plr->z);
if (npc == nullptr) { if (npc == nullptr) {
ChatManager::sendServerMessage(sock, "[NPCR] No NPCs found nearby"); ChatManager::sendServerMessage(sock, "[NPCR] No NPCs found nearby");
@ -379,8 +377,7 @@ void instanceCommand(std::string full, std::vector<std::string>& args, CNSocket*
} }
void npcInstanceCommand(std::string full, std::vector<std::string>& args, CNSocket* sock) { void npcInstanceCommand(std::string full, std::vector<std::string>& args, CNSocket* sock) {
PlayerView& plrv = PlayerManager::players[sock]; Player* plr = PlayerManager::getPlayer(sock);
Player* plr = plrv.plr;
if (args.size() < 2) { if (args.size() < 2) {
ChatManager::sendServerMessage(sock, "[NPCI] Instance ID must be specified"); ChatManager::sendServerMessage(sock, "[NPCI] Instance ID must be specified");
@ -388,7 +385,7 @@ void npcInstanceCommand(std::string full, std::vector<std::string>& args, CNSock
return; return;
} }
BaseNPC* npc = NPCManager::getNearestNPC(plrv.currentChunks, plr->x, plr->y, plr->z); BaseNPC* npc = NPCManager::getNearestNPC(*plr->currentChunks, plr->x, plr->y, plr->z);
if (npc == nullptr) { if (npc == nullptr) {
ChatManager::sendServerMessage(sock, "[NPCI] No NPCs found nearby"); ChatManager::sendServerMessage(sock, "[NPCI] No NPCs found nearby");
@ -516,7 +513,7 @@ void notifyCommand(std::string full, std::vector<std::string>& args, CNSocket* s
void playersCommand(std::string full, std::vector<std::string>& args, CNSocket* sock) { void playersCommand(std::string full, std::vector<std::string>& args, CNSocket* sock) {
ChatManager::sendServerMessage(sock, "[ADMIN] Players on the server:"); ChatManager::sendServerMessage(sock, "[ADMIN] Players on the server:");
for (auto pair : PlayerManager::players) for (auto pair : PlayerManager::players)
ChatManager::sendServerMessage(sock, PlayerManager::getPlayerName(pair.second.plr)); ChatManager::sendServerMessage(sock, PlayerManager::getPlayerName(pair.second));
} }
void flushCommand(std::string full, std::vector<std::string>& args, CNSocket* sock) { void flushCommand(std::string full, std::vector<std::string>& args, CNSocket* sock) {
@ -599,7 +596,7 @@ void ChatManager::menuChatHandler(CNSocket* sock, CNPacketData* data) {
INITSTRUCT(sP_FE2CL_REP_SEND_MENUCHAT_MESSAGE_SUCC, resp); INITSTRUCT(sP_FE2CL_REP_SEND_MENUCHAT_MESSAGE_SUCC, resp);
U8toU16(fullChat, (char16_t*)&resp.szFreeChat, sizeof(resp.szFreeChat)); U8toU16(fullChat, (char16_t*)&resp.szFreeChat, sizeof(resp.szFreeChat));
resp.iPC_ID = PlayerManager::players[sock].plr->iID; resp.iPC_ID = PlayerManager::getPlayer(sock)->iID;
resp.iEmoteCode = chat->iEmoteCode; resp.iEmoteCode = chat->iEmoteCode;
sock->sendPacket((void*)&resp, P_FE2CL_REP_SEND_MENUCHAT_MESSAGE_SUCC, sizeof(sP_FE2CL_REP_SEND_MENUCHAT_MESSAGE_SUCC)); sock->sendPacket((void*)&resp, P_FE2CL_REP_SEND_MENUCHAT_MESSAGE_SUCC, sizeof(sP_FE2CL_REP_SEND_MENUCHAT_MESSAGE_SUCC));
@ -641,7 +638,9 @@ void ChatManager::sendServerMessage(CNSocket* sock, std::string msg) {
void ChatManager::announcementHandler(CNSocket* sock, CNPacketData* data) { void ChatManager::announcementHandler(CNSocket* sock, CNPacketData* data) {
if (data->size != sizeof(sP_CL2FE_GM_REQ_PC_ANNOUNCE)) if (data->size != sizeof(sP_CL2FE_GM_REQ_PC_ANNOUNCE))
return; // ignore malformed packet return; // ignore malformed packet
if (PlayerManager::getPlayer(sock)->accountLevel > 30)
Player* plr = PlayerManager::getPlayer(sock);
if (plr->accountLevel > 30)
return; // only players with account level less than 30 (GM) are allowed to use this command return; // only players with account level less than 30 (GM) are allowed to use this command
sP_CL2FE_GM_REQ_PC_ANNOUNCE* announcement = (sP_CL2FE_GM_REQ_PC_ANNOUNCE*)data->buf; sP_CL2FE_GM_REQ_PC_ANNOUNCE* announcement = (sP_CL2FE_GM_REQ_PC_ANNOUNCE*)data->buf;
@ -649,18 +648,17 @@ void ChatManager::announcementHandler(CNSocket* sock, CNPacketData* data) {
msg.iAnnounceType = announcement->iAnnounceType; msg.iAnnounceType = announcement->iAnnounceType;
msg.iDuringTime = announcement->iDuringTime; msg.iDuringTime = announcement->iDuringTime;
memcpy(msg.szAnnounceMsg, announcement->szAnnounceMsg, sizeof(msg.szAnnounceMsg)); memcpy(msg.szAnnounceMsg, announcement->szAnnounceMsg, sizeof(msg.szAnnounceMsg));
std::map<CNSocket*, PlayerView>::iterator it; std::map<CNSocket*, Player*>::iterator it;
switch (announcement->iAreaType) { switch (announcement->iAreaType) {
case 0: // area case 0: // area (all players in viewable chunks)
break; // stubbed for now PlayerManager::sendToViewable(sock, (void*)&msg, P_FE2CL_GM_REP_PC_ANNOUNCE, sizeof(sP_FE2CL_GM_REP_PC_ANNOUNCE));
break;
case 1: // shard case 1: // shard
break; //stubbed for now break; //stubbed for now
case 2: // world case 2: // world
break; // stubbed for now break; // stubbed for now
case 3: // global case 3: // global (all players)
// send announced messqage to ALL players
for (it = PlayerManager::players.begin(); it != PlayerManager::players.end(); it++) { for (it = PlayerManager::players.begin(); it != PlayerManager::players.end(); it++) {
CNSocket* allSock = it->first; CNSocket* allSock = it->first;
allSock->sendPacket((void*)&msg, P_FE2CL_GM_REP_PC_ANNOUNCE, sizeof(sP_FE2CL_GM_REP_PC_ANNOUNCE)); allSock->sendPacket((void*)&msg, P_FE2CL_GM_REP_PC_ANNOUNCE, sizeof(sP_FE2CL_GM_REP_PC_ANNOUNCE));

10
src/ChunkManager.cpp
View File

@ -23,7 +23,7 @@ void ChunkManager::populateNewChunk(Chunk* chunk, ChunkPos pos) {// add the new
continue; continue;
for (CNSocket *s : c->players) for (CNSocket *s : c->players)
PlayerManager::players[s].currentChunks.push_back(chunk); PlayerManager::getPlayer(s)->currentChunks->push_back(chunk);
for (int32_t id : c->NPCs) for (int32_t id : c->NPCs)
NPCManager::NPCs[id]->currentChunks.push_back(chunk); NPCManager::NPCs[id]->currentChunks.push_back(chunk);
@ -67,7 +67,7 @@ void ChunkManager::addPlayer(int posX, int posY, uint64_t instanceID, CNSocket*
Chunk* chunk = chunks[pos]; Chunk* chunk = chunks[pos];
if (newChunkUsed) if (newChunkUsed)
PlayerManager::players[sock].currentChunks.push_back(chunk); PlayerManager::getPlayer(sock)->currentChunks->push_back(chunk);
chunk->players.insert(sock); chunk->players.insert(sock);
@ -142,9 +142,9 @@ void ChunkManager::destroyChunk(ChunkPos chunkPos) {
// remove from players // remove from players
for (CNSocket* sock : otherChunk->players) { for (CNSocket* sock : otherChunk->players) {
PlayerView* plyr = &PlayerManager::players[sock]; Player* plr = PlayerManager::getPlayer(sock);
if (std::find(plyr->currentChunks.begin(), plyr->currentChunks.end(), chunk) != plyr->currentChunks.end()) { if (std::find(plr->currentChunks->begin(), plr->currentChunks->end(), chunk) != plr->currentChunks->end()) {
plyr->currentChunks.erase(std::remove(plyr->currentChunks.begin(), plyr->currentChunks.end(), chunk), plyr->currentChunks.end()); plr->currentChunks->erase(std::remove(plr->currentChunks->begin(), plr->currentChunks->end(), chunk), plr->currentChunks->end());
} }
} }
} }

200
src/ItemManager.cpp
View File

@ -44,17 +44,17 @@ void ItemManager::itemMoveHandler(CNSocket* sock, CNPacketData* data) {
sP_CL2FE_REQ_ITEM_MOVE* itemmove = (sP_CL2FE_REQ_ITEM_MOVE*)data->buf; sP_CL2FE_REQ_ITEM_MOVE* itemmove = (sP_CL2FE_REQ_ITEM_MOVE*)data->buf;
INITSTRUCT(sP_FE2CL_PC_ITEM_MOVE_SUCC, resp); INITSTRUCT(sP_FE2CL_PC_ITEM_MOVE_SUCC, resp);
PlayerView& plr = PlayerManager::players[sock]; Player* plr = PlayerManager::getPlayer(sock);
// sanity check // sanity check
if (plr.plr->Equip[itemmove->iFromSlotNum].iType != 0 && itemmove->eFrom == 0 && itemmove->eTo == 0) { if (plr->Equip[itemmove->iFromSlotNum].iType != 0 && itemmove->eFrom == 0 && itemmove->eTo == 0) {
// this packet should never happen unless it is a weapon, tell the client to do nothing and do nothing ourself // this packet should never happen unless it is a weapon, tell the client to do nothing and do nothing ourself
resp.eTo = itemmove->eFrom; resp.eTo = itemmove->eFrom;
resp.iToSlotNum = itemmove->iFromSlotNum; resp.iToSlotNum = itemmove->iFromSlotNum;
resp.ToSlotItem = plr.plr->Equip[itemmove->iToSlotNum]; resp.ToSlotItem = plr->Equip[itemmove->iToSlotNum];
resp.eFrom = itemmove->eTo; resp.eFrom = itemmove->eTo;
resp.iFromSlotNum = itemmove->iToSlotNum; resp.iFromSlotNum = itemmove->iToSlotNum;
resp.FromSlotItem = plr.plr->Equip[itemmove->iFromSlotNum]; resp.FromSlotItem = plr->Equip[itemmove->iFromSlotNum];
sock->sendPacket((void*)&resp, P_FE2CL_PC_ITEM_MOVE_SUCC, sizeof(sP_FE2CL_PC_ITEM_MOVE_SUCC)); sock->sendPacket((void*)&resp, P_FE2CL_PC_ITEM_MOVE_SUCC, sizeof(sP_FE2CL_PC_ITEM_MOVE_SUCC));
return; return;
@ -68,13 +68,13 @@ void ItemManager::itemMoveHandler(CNSocket* sock, CNPacketData* data) {
sItemBase *fromItem; sItemBase *fromItem;
switch ((SlotType)itemmove->eFrom) { switch ((SlotType)itemmove->eFrom) {
case SlotType::EQUIP: case SlotType::EQUIP:
fromItem = &plr.plr->Equip[itemmove->iFromSlotNum]; fromItem = &plr->Equip[itemmove->iFromSlotNum];
break; break;
case SlotType::INVENTORY: case SlotType::INVENTORY:
fromItem = &plr.plr->Inven[itemmove->iFromSlotNum]; fromItem = &plr->Inven[itemmove->iFromSlotNum];
break; break;
case SlotType::BANK: case SlotType::BANK:
fromItem = &plr.plr->Bank[itemmove->iFromSlotNum]; fromItem = &plr->Bank[itemmove->iFromSlotNum];
break; break;
default: default:
std::cout << "[WARN] MoveItem submitted unknown Item Type?! " << itemmove->eFrom << std::endl; std::cout << "[WARN] MoveItem submitted unknown Item Type?! " << itemmove->eFrom << std::endl;
@ -85,13 +85,13 @@ void ItemManager::itemMoveHandler(CNSocket* sock, CNPacketData* data) {
sItemBase* toItem; sItemBase* toItem;
switch ((SlotType)itemmove->eTo) { switch ((SlotType)itemmove->eTo) {
case SlotType::EQUIP: case SlotType::EQUIP:
toItem = &plr.plr->Equip[itemmove->iToSlotNum]; toItem = &plr->Equip[itemmove->iToSlotNum];
break; break;
case SlotType::INVENTORY: case SlotType::INVENTORY:
toItem = &plr.plr->Inven[itemmove->iToSlotNum]; toItem = &plr->Inven[itemmove->iToSlotNum];
break; break;
case SlotType::BANK: case SlotType::BANK:
toItem = &plr.plr->Bank[itemmove->iToSlotNum]; toItem = &plr->Bank[itemmove->iToSlotNum];
break; break;
default: default:
std::cout << "[WARN] MoveItem submitted unknown Item Type?! " << itemmove->eTo << std::endl; std::cout << "[WARN] MoveItem submitted unknown Item Type?! " << itemmove->eTo << std::endl;
@ -139,7 +139,7 @@ void ItemManager::itemMoveHandler(CNSocket* sock, CNPacketData* data) {
if (itemmove->eFrom == (int)SlotType::EQUIP || itemmove->eTo == (int)SlotType::EQUIP) { if (itemmove->eFrom == (int)SlotType::EQUIP || itemmove->eTo == (int)SlotType::EQUIP) {
INITSTRUCT(sP_FE2CL_PC_EQUIP_CHANGE, equipChange); INITSTRUCT(sP_FE2CL_PC_EQUIP_CHANGE, equipChange);
equipChange.iPC_ID = plr.plr->iID; equipChange.iPC_ID = plr->iID;
if (itemmove->eTo == (int)SlotType::EQUIP) { if (itemmove->eTo == (int)SlotType::EQUIP) {
equipChange.iEquipSlotNum = itemmove->iToSlotNum; equipChange.iEquipSlotNum = itemmove->iToSlotNum;
equipChange.EquipSlotItem = resp.FromSlotItem; equipChange.EquipSlotItem = resp.FromSlotItem;
@ -149,14 +149,14 @@ void ItemManager::itemMoveHandler(CNSocket* sock, CNPacketData* data) {
} }
// unequip vehicle if equip slot 8 is 0 // unequip vehicle if equip slot 8 is 0
if (plr.plr->Equip[8].iID == 0) if (plr->Equip[8].iID == 0)
plr.plr->iPCState = 0; plr->iPCState = 0;
// send equip event to other players // send equip event to other players
PlayerManager::sendToViewable(sock, (void*)&equipChange, P_FE2CL_PC_EQUIP_CHANGE, sizeof(sP_FE2CL_PC_EQUIP_CHANGE)); PlayerManager::sendToViewable(sock, (void*)&equipChange, P_FE2CL_PC_EQUIP_CHANGE, sizeof(sP_FE2CL_PC_EQUIP_CHANGE));
// set equipment stats serverside // set equipment stats serverside
setItemStats(plr.plr); setItemStats(plr);
} }
// send response // send response
@ -174,15 +174,15 @@ void ItemManager::itemDeleteHandler(CNSocket* sock, CNPacketData* data) {
sP_CL2FE_REQ_PC_ITEM_DELETE* itemdel = (sP_CL2FE_REQ_PC_ITEM_DELETE*)data->buf; sP_CL2FE_REQ_PC_ITEM_DELETE* itemdel = (sP_CL2FE_REQ_PC_ITEM_DELETE*)data->buf;
INITSTRUCT(sP_FE2CL_REP_PC_ITEM_DELETE_SUCC, resp); INITSTRUCT(sP_FE2CL_REP_PC_ITEM_DELETE_SUCC, resp);
PlayerView& plr = PlayerManager::players[sock]; Player* plr = PlayerManager::getPlayer(sock);
resp.eIL = itemdel->eIL; resp.eIL = itemdel->eIL;
resp.iSlotNum = itemdel->iSlotNum; resp.iSlotNum = itemdel->iSlotNum;
// so, im not sure what this eIL thing does since you always delete items in inventory and not equips // so, im not sure what this eIL thing does since you always delete items in inventory and not equips
plr.plr->Inven[itemdel->iSlotNum].iID = 0; plr->Inven[itemdel->iSlotNum].iID = 0;
plr.plr->Inven[itemdel->iSlotNum].iType = 0; plr->Inven[itemdel->iSlotNum].iType = 0;
plr.plr->Inven[itemdel->iSlotNum].iOpt = 0; plr->Inven[itemdel->iSlotNum].iOpt = 0;
sock->sendPacket((void*)&resp, P_FE2CL_REP_PC_ITEM_DELETE_SUCC, sizeof(sP_FE2CL_REP_PC_ITEM_DELETE_SUCC)); sock->sendPacket((void*)&resp, P_FE2CL_REP_PC_ITEM_DELETE_SUCC, sizeof(sP_FE2CL_REP_PC_ITEM_DELETE_SUCC));
} }
@ -192,9 +192,9 @@ void ItemManager::itemGMGiveHandler(CNSocket* sock, CNPacketData* data) {
return; // ignore the malformed packet return; // ignore the malformed packet
sP_CL2FE_REQ_PC_GIVE_ITEM* itemreq = (sP_CL2FE_REQ_PC_GIVE_ITEM*)data->buf; sP_CL2FE_REQ_PC_GIVE_ITEM* itemreq = (sP_CL2FE_REQ_PC_GIVE_ITEM*)data->buf;
PlayerView& plr = PlayerManager::players[sock]; Player* plr = PlayerManager::getPlayer(sock);
if (plr.plr->accountLevel > 50) { if (plr->accountLevel > 50) {
// TODO: send fail packet // TODO: send fail packet
return; return;
} }
@ -221,7 +221,7 @@ void ItemManager::itemGMGiveHandler(CNSocket* sock, CNPacketData* data) {
} }
resp.Item = itemreq->Item; resp.Item = itemreq->Item;
plr.plr->Inven[itemreq->iSlotNum] = itemreq->Item; plr->Inven[itemreq->iSlotNum] = itemreq->Item;
sock->sendPacket((void*)&resp, P_FE2CL_REP_PC_GIVE_ITEM_SUCC, sizeof(sP_FE2CL_REP_PC_GIVE_ITEM_SUCC)); sock->sendPacket((void*)&resp, P_FE2CL_REP_PC_GIVE_ITEM_SUCC, sizeof(sP_FE2CL_REP_PC_GIVE_ITEM_SUCC));
} }
@ -288,10 +288,12 @@ void ItemManager::itemBankOpenHandler(CNSocket* sock, CNPacketData* data) {
if (data->size != sizeof(sP_CL2FE_REQ_PC_BANK_OPEN)) if (data->size != sizeof(sP_CL2FE_REQ_PC_BANK_OPEN))
return; // ignore the malformed packet return; // ignore the malformed packet
Player* plr = PlayerManager::getPlayer(sock);
// just send bank inventory // just send bank inventory
INITSTRUCT(sP_FE2CL_REP_PC_BANK_OPEN_SUCC, resp); INITSTRUCT(sP_FE2CL_REP_PC_BANK_OPEN_SUCC, resp);
for (int i = 0; i < ABANK_COUNT; i++) { for (int i = 0; i < ABANK_COUNT; i++) {
resp.aBank[i] = PlayerManager::players[sock].plr->Bank[i]; resp.aBank[i] = plr->Bank[i];
} }
resp.iExtraBank = 1; resp.iExtraBank = 1;
sock->sendPacket((void*)&resp, P_FE2CL_REP_PC_BANK_OPEN_SUCC, sizeof(sP_FE2CL_REP_PC_BANK_OPEN_SUCC)); sock->sendPacket((void*)&resp, P_FE2CL_REP_PC_BANK_OPEN_SUCC, sizeof(sP_FE2CL_REP_PC_BANK_OPEN_SUCC));
@ -314,15 +316,15 @@ void ItemManager::itemTradeOfferHandler(CNSocket* sock, CNPacketData* data) {
CNSocket* otherSock = sock; CNSocket* otherSock = sock;
for (auto& pair : PlayerManager::players) { for (auto& pair : PlayerManager::players) {
if (pair.second.plr->iID == iID_Check) { if (pair.second->iID == iID_Check) {
otherSock = pair.first; otherSock = pair.first;
break; break;
} }
} }
PlayerView& plr = PlayerManager::players[otherSock]; Player* plr = PlayerManager::getPlayer(sock);
if (plr.plr->isTrading) { if (plr->isTrading) {
INITSTRUCT(sP_FE2CL_REP_PC_TRADE_OFFER_REFUSAL, resp); INITSTRUCT(sP_FE2CL_REP_PC_TRADE_OFFER_REFUSAL, resp);
resp.iID_Request = pacdat->iID_To; resp.iID_Request = pacdat->iID_To;
@ -360,7 +362,7 @@ void ItemManager::itemTradeOfferAcceptHandler(CNSocket* sock, CNPacketData* data
CNSocket* otherSock = sock; CNSocket* otherSock = sock;
for (auto& pair : PlayerManager::players) { for (auto& pair : PlayerManager::players) {
if (pair.second.plr->iID == iID_Check) { if (pair.second->iID == iID_Check) {
otherSock = pair.first; otherSock = pair.first;
break; break;
} }
@ -374,10 +376,10 @@ void ItemManager::itemTradeOfferAcceptHandler(CNSocket* sock, CNPacketData* data
// Clearing up trade slots // Clearing up trade slots
PlayerView& plr = PlayerManager::players[sock]; Player* plr = PlayerManager::getPlayer(sock);
PlayerView& plr2 = PlayerManager::players[otherSock]; Player* plr2 = PlayerManager::getPlayer(otherSock);
if (plr2.plr->isTrading) { if (plr2->isTrading) {
INITSTRUCT(sP_FE2CL_REP_PC_TRADE_OFFER_REFUSAL, resp); INITSTRUCT(sP_FE2CL_REP_PC_TRADE_OFFER_REFUSAL, resp);
resp.iID_Request = pacdat->iID_To; resp.iID_Request = pacdat->iID_To;
@ -389,13 +391,13 @@ void ItemManager::itemTradeOfferAcceptHandler(CNSocket* sock, CNPacketData* data
return; // prevent trading with a player already trading return; // prevent trading with a player already trading
} }
plr.plr->isTrading = true; plr->isTrading = true;
plr2.plr->isTrading = true; plr2->isTrading = true;
plr.plr->isTradeConfirm = false; plr->isTradeConfirm = false;
plr2.plr->isTradeConfirm = false; plr2->isTradeConfirm = false;
memset(&plr.plr->Trade, 0, sizeof(plr.plr->Trade)); memset(&plr->Trade, 0, sizeof(plr->Trade));
memset(&plr2.plr->Trade, 0, sizeof(plr2.plr->Trade)); memset(&plr2->Trade, 0, sizeof(plr2->Trade));
otherSock->sendPacket((void*)&resp, P_FE2CL_REP_PC_TRADE_OFFER_SUCC, sizeof(sP_FE2CL_REP_PC_TRADE_OFFER_SUCC)); otherSock->sendPacket((void*)&resp, P_FE2CL_REP_PC_TRADE_OFFER_SUCC, sizeof(sP_FE2CL_REP_PC_TRADE_OFFER_SUCC));
} }
@ -422,7 +424,7 @@ void ItemManager::itemTradeOfferRefusalHandler(CNSocket* sock, CNPacketData* dat
CNSocket* otherSock = sock; CNSocket* otherSock = sock;
for (auto& pair : PlayerManager::players) { for (auto& pair : PlayerManager::players) {
if (pair.second.plr->iID == iID_Check) { if (pair.second->iID == iID_Check) {
otherSock = pair.first; otherSock = pair.first;
break; break;
} }
@ -448,21 +450,21 @@ void ItemManager::itemTradeConfirmHandler(CNSocket* sock, CNPacketData* data) {
CNSocket* otherSock = sock; CNSocket* otherSock = sock;
for (auto& pair : PlayerManager::players) { for (auto& pair : PlayerManager::players) {
if (pair.second.plr->iID == iID_Check) { if (pair.second->iID == iID_Check) {
otherSock = pair.first; otherSock = pair.first;
break; break;
} }
} }
PlayerView& plr = PlayerManager::players[sock]; Player* plr = PlayerManager::getPlayer(sock);
PlayerView& plr2 = PlayerManager::players[otherSock]; Player* plr2 = PlayerManager::getPlayer(otherSock);
if (plr2.plr->isTradeConfirm) { if (plr2->isTradeConfirm) {
plr.plr->isTrading = false; plr->isTrading = false;
plr2.plr->isTrading = false; plr2->isTrading = false;
plr.plr->isTradeConfirm = false; plr->isTradeConfirm = false;
plr2.plr->isTradeConfirm = false; plr2->isTradeConfirm = false;
// Check if we have enough free slots // Check if we have enough free slots
int freeSlots = 0; int freeSlots = 0;
@ -471,22 +473,22 @@ void ItemManager::itemTradeConfirmHandler(CNSocket* sock, CNPacketData* data) {
int freeSlotsNeeded2 = 0; int freeSlotsNeeded2 = 0;
for (int i = 0; i < AINVEN_COUNT; i++) { for (int i = 0; i < AINVEN_COUNT; i++) {
if (plr.plr->Inven[i].iID == 0) if (plr->Inven[i].iID == 0)
freeSlots++; freeSlots++;
} }
for (int i = 0; i < 5; i++) { for (int i = 0; i < 5; i++) {
if (plr.plr->Trade[i].iID != 0) if (plr->Trade[i].iID != 0)
freeSlotsNeeded++; freeSlotsNeeded++;
} }
for (int i = 0; i < AINVEN_COUNT; i++) { for (int i = 0; i < AINVEN_COUNT; i++) {
if (plr2.plr->Inven[i].iID == 0) if (plr2->Inven[i].iID == 0)
freeSlots2++; freeSlots2++;
} }
for (int i = 0; i < 5; i++) { for (int i = 0; i < 5; i++) {
if (plr2.plr->Trade[i].iID != 0) if (plr2->Trade[i].iID != 0)
freeSlotsNeeded2++; freeSlotsNeeded2++;
} }
@ -524,27 +526,27 @@ void ItemManager::itemTradeConfirmHandler(CNSocket* sock, CNPacketData* data) {
// ^^ this is a must have or else the player won't accept a succ packet for some reason // ^^ this is a must have or else the player won't accept a succ packet for some reason
for (int i = 0; i < freeSlotsNeeded; i++) { for (int i = 0; i < freeSlotsNeeded; i++) {
plr.plr->Inven[plr.plr->Trade[i].iInvenNum].iID = 0; plr->Inven[plr->Trade[i].iInvenNum].iID = 0;
plr.plr->Inven[plr.plr->Trade[i].iInvenNum].iType = 0; plr->Inven[plr->Trade[i].iInvenNum].iType = 0;
plr.plr->Inven[plr.plr->Trade[i].iInvenNum].iOpt = 0; plr->Inven[plr->Trade[i].iInvenNum].iOpt = 0;
} }
for (int i = 0; i < freeSlotsNeeded2; i++) { for (int i = 0; i < freeSlotsNeeded2; i++) {
plr2.plr->Inven[plr2.plr->Trade[i].iInvenNum].iID = 0; plr2->Inven[plr2->Trade[i].iInvenNum].iID = 0;
plr2.plr->Inven[plr2.plr->Trade[i].iInvenNum].iType = 0; plr2->Inven[plr2->Trade[i].iInvenNum].iType = 0;
plr2.plr->Inven[plr2.plr->Trade[i].iInvenNum].iOpt = 0; plr2->Inven[plr2->Trade[i].iInvenNum].iOpt = 0;
} }
for (int i = 0; i < AINVEN_COUNT; i++) { for (int i = 0; i < AINVEN_COUNT; i++) {
if (freeSlotsNeeded <= 0) if (freeSlotsNeeded <= 0)
break; break;
if (plr2.plr->Inven[i].iID == 0) { if (plr2->Inven[i].iID == 0) {
plr2.plr->Inven[i].iID = plr.plr->Trade[freeSlotsNeeded - 1].iID; plr2->Inven[i].iID = plr->Trade[freeSlotsNeeded - 1].iID;
plr2.plr->Inven[i].iType = plr.plr->Trade[freeSlotsNeeded - 1].iType; plr2->Inven[i].iType = plr->Trade[freeSlotsNeeded - 1].iType;
plr2.plr->Inven[i].iOpt = plr.plr->Trade[freeSlotsNeeded - 1].iOpt; plr2->Inven[i].iOpt = plr->Trade[freeSlotsNeeded - 1].iOpt;
plr.plr->Trade[freeSlotsNeeded - 1].iInvenNum = i; plr->Trade[freeSlotsNeeded - 1].iInvenNum = i;
freeSlotsNeeded--; freeSlotsNeeded--;
} }
} }
@ -553,12 +555,12 @@ void ItemManager::itemTradeConfirmHandler(CNSocket* sock, CNPacketData* data) {
if (freeSlotsNeeded2 <= 0) if (freeSlotsNeeded2 <= 0)
break; break;
if (plr.plr->Inven[i].iID == 0) { if (plr->Inven[i].iID == 0) {
plr.plr->Inven[i].iID = plr2.plr->Trade[freeSlotsNeeded2 - 1].iID; plr->Inven[i].iID = plr2->Trade[freeSlotsNeeded2 - 1].iID;
plr.plr->Inven[i].iType = plr2.plr->Trade[freeSlotsNeeded2 - 1].iType; plr->Inven[i].iType = plr2->Trade[freeSlotsNeeded2 - 1].iType;
plr.plr->Inven[i].iOpt = plr2.plr->Trade[freeSlotsNeeded2 - 1].iOpt; plr->Inven[i].iOpt = plr2->Trade[freeSlotsNeeded2 - 1].iOpt;
plr2.plr->Trade[freeSlotsNeeded2 - 1].iInvenNum = i; plr2->Trade[freeSlotsNeeded2 - 1].iInvenNum = i;
freeSlotsNeeded2--; freeSlotsNeeded2--;
} }
} }
@ -569,19 +571,19 @@ void ItemManager::itemTradeConfirmHandler(CNSocket* sock, CNPacketData* data) {
resp2.iID_From = pacdat->iID_From; resp2.iID_From = pacdat->iID_From;
resp2.iID_To = pacdat->iID_To; resp2.iID_To = pacdat->iID_To;
plr.plr->money = plr.plr->money + plr2.plr->moneyInTrade - plr.plr->moneyInTrade; plr->money = plr->money + plr2->moneyInTrade - plr->moneyInTrade;
resp2.iCandy = plr.plr->money; resp2.iCandy = plr->money;
memcpy(resp2.Item, plr2.plr->Trade, sizeof(plr2.plr->Trade)); memcpy(resp2.Item, plr2->Trade, sizeof(plr2->Trade));
memcpy(resp2.ItemStay, plr.plr->Trade, sizeof(plr.plr->Trade)); memcpy(resp2.ItemStay, plr->Trade, sizeof(plr->Trade));
sock->sendPacket((void*)&resp2, P_FE2CL_REP_PC_TRADE_CONFIRM_SUCC, sizeof(sP_FE2CL_REP_PC_TRADE_CONFIRM_SUCC)); sock->sendPacket((void*)&resp2, P_FE2CL_REP_PC_TRADE_CONFIRM_SUCC, sizeof(sP_FE2CL_REP_PC_TRADE_CONFIRM_SUCC));
plr2.plr->money = plr2.plr->money + plr.plr->moneyInTrade - plr2.plr->moneyInTrade; plr2->money = plr2->money + plr->moneyInTrade - plr2->moneyInTrade;
resp2.iCandy = plr2.plr->money; resp2.iCandy = plr2->money;
memcpy(resp2.Item, plr.plr->Trade, sizeof(plr.plr->Trade)); memcpy(resp2.Item, plr->Trade, sizeof(plr->Trade));
memcpy(resp2.ItemStay, plr2.plr->Trade, sizeof(plr2.plr->Trade)); memcpy(resp2.ItemStay, plr2->Trade, sizeof(plr2->Trade));
otherSock->sendPacket((void*)&resp2, P_FE2CL_REP_PC_TRADE_CONFIRM_SUCC, sizeof(sP_FE2CL_REP_PC_TRADE_CONFIRM_SUCC)); otherSock->sendPacket((void*)&resp2, P_FE2CL_REP_PC_TRADE_CONFIRM_SUCC, sizeof(sP_FE2CL_REP_PC_TRADE_CONFIRM_SUCC));
} else { } else {
@ -592,7 +594,7 @@ void ItemManager::itemTradeConfirmHandler(CNSocket* sock, CNPacketData* data) {
resp.iID_From = pacdat->iID_From; resp.iID_From = pacdat->iID_From;
resp.iID_To = pacdat->iID_To; resp.iID_To = pacdat->iID_To;
plr.plr->isTradeConfirm = true; plr->isTradeConfirm = true;
sock->sendPacket((void*)&resp, P_FE2CL_REP_PC_TRADE_CONFIRM, sizeof(sP_FE2CL_REP_PC_TRADE_CONFIRM)); sock->sendPacket((void*)&resp, P_FE2CL_REP_PC_TRADE_CONFIRM, sizeof(sP_FE2CL_REP_PC_TRADE_CONFIRM));
otherSock->sendPacket((void*)&resp, P_FE2CL_REP_PC_TRADE_CONFIRM, sizeof(sP_FE2CL_REP_PC_TRADE_CONFIRM)); otherSock->sendPacket((void*)&resp, P_FE2CL_REP_PC_TRADE_CONFIRM, sizeof(sP_FE2CL_REP_PC_TRADE_CONFIRM));
@ -621,18 +623,18 @@ void ItemManager::itemTradeConfirmCancelHandler(CNSocket* sock, CNPacketData* da
CNSocket* otherSock = sock; CNSocket* otherSock = sock;
for (auto pair : PlayerManager::players) { for (auto pair : PlayerManager::players) {
if (pair.second.plr->iID == iID_Check) { if (pair.second->iID == iID_Check) {
otherSock = pair.first; otherSock = pair.first;
} }
} }
PlayerView& plr = PlayerManager::players[sock]; Player* plr = PlayerManager::getPlayer(sock);
PlayerView& plr2 = PlayerManager::players[otherSock]; Player* plr2 = PlayerManager::getPlayer(otherSock);
plr.plr->isTrading = false; plr->isTrading = false;
plr.plr->isTradeConfirm = false; plr->isTradeConfirm = false;
plr2.plr->isTrading = false; plr2->isTrading = false;
plr2.plr->isTradeConfirm = false; plr2->isTradeConfirm = false;
otherSock->sendPacket((void*)&resp, P_FE2CL_REP_PC_TRADE_CONFIRM_CANCEL, sizeof(sP_FE2CL_REP_PC_TRADE_CONFIRM_CANCEL)); otherSock->sendPacket((void*)&resp, P_FE2CL_REP_PC_TRADE_CONFIRM_CANCEL, sizeof(sP_FE2CL_REP_PC_TRADE_CONFIRM_CANCEL));
} }
@ -665,14 +667,14 @@ void ItemManager::itemTradeRegisterItemHandler(CNSocket* sock, CNPacketData* dat
CNSocket* otherSock = sock; CNSocket* otherSock = sock;
for (auto pair : PlayerManager::players) { for (auto pair : PlayerManager::players) {
if (pair.second.plr->iID == iID_Check) { if (pair.second->iID == iID_Check) {
otherSock = pair.first; otherSock = pair.first;
} }
} }
PlayerView& plr = PlayerManager::players[sock]; Player* plr = PlayerManager::getPlayer(sock);
plr.plr->Trade[pacdat->Item.iSlotNum] = pacdat->Item; plr->Trade[pacdat->Item.iSlotNum] = pacdat->Item;
plr.plr->isTradeConfirm = false; plr->isTradeConfirm = false;
sock->sendPacket((void*)&resp, P_FE2CL_REP_PC_TRADE_ITEM_REGISTER_SUCC, sizeof(sP_FE2CL_REP_PC_TRADE_ITEM_REGISTER_SUCC)); sock->sendPacket((void*)&resp, P_FE2CL_REP_PC_TRADE_ITEM_REGISTER_SUCC, sizeof(sP_FE2CL_REP_PC_TRADE_ITEM_REGISTER_SUCC));
otherSock->sendPacket((void*)&resp, P_FE2CL_REP_PC_TRADE_ITEM_REGISTER_SUCC, sizeof(sP_FE2CL_REP_PC_TRADE_ITEM_REGISTER_SUCC)); otherSock->sendPacket((void*)&resp, P_FE2CL_REP_PC_TRADE_ITEM_REGISTER_SUCC, sizeof(sP_FE2CL_REP_PC_TRADE_ITEM_REGISTER_SUCC));
@ -690,9 +692,9 @@ void ItemManager::itemTradeUnregisterItemHandler(CNSocket* sock, CNPacketData* d
resp.iID_To = pacdat->iID_To; resp.iID_To = pacdat->iID_To;
resp.TradeItem = pacdat->Item; resp.TradeItem = pacdat->Item;
PlayerView& plr = PlayerManager::players[sock]; Player* plr = PlayerManager::getPlayer(sock);
resp.InvenItem = plr.plr->Trade[pacdat->Item.iSlotNum]; resp.InvenItem = plr->Trade[pacdat->Item.iSlotNum];
plr.plr->isTradeConfirm = false; plr->isTradeConfirm = false;
int iID_Check; int iID_Check;
@ -705,7 +707,7 @@ void ItemManager::itemTradeUnregisterItemHandler(CNSocket* sock, CNPacketData* d
CNSocket* otherSock = sock; CNSocket* otherSock = sock;
for (auto pair : PlayerManager::players) { for (auto pair : PlayerManager::players) {
if (pair.second.plr->iID == iID_Check) { if (pair.second->iID == iID_Check) {
otherSock = pair.first; otherSock = pair.first;
} }
} }
@ -713,11 +715,11 @@ void ItemManager::itemTradeUnregisterItemHandler(CNSocket* sock, CNPacketData* d
int temp_num = pacdat->Item.iSlotNum; int temp_num = pacdat->Item.iSlotNum;
if (temp_num >= 0 && temp_num <= 4) { if (temp_num >= 0 && temp_num <= 4) {
plr.plr->Trade[temp_num].iID = 0; plr->Trade[temp_num].iID = 0;
plr.plr->Trade[temp_num].iType = 0; plr->Trade[temp_num].iType = 0;
plr.plr->Trade[temp_num].iOpt = 0; plr->Trade[temp_num].iOpt = 0;
plr.plr->Trade[temp_num].iInvenNum = 0; plr->Trade[temp_num].iInvenNum = 0;
plr.plr->Trade[temp_num].iSlotNum = 0; plr->Trade[temp_num].iSlotNum = 0;
} }
sock->sendPacket((void*)&resp, P_FE2CL_REP_PC_TRADE_ITEM_UNREGISTER_SUCC, sizeof(sP_FE2CL_REP_PC_TRADE_ITEM_UNREGISTER_SUCC)); sock->sendPacket((void*)&resp, P_FE2CL_REP_PC_TRADE_ITEM_UNREGISTER_SUCC, sizeof(sP_FE2CL_REP_PC_TRADE_ITEM_UNREGISTER_SUCC));
@ -730,9 +732,9 @@ void ItemManager::itemTradeRegisterCashHandler(CNSocket* sock, CNPacketData* dat
sP_CL2FE_REQ_PC_TRADE_CASH_REGISTER* pacdat = (sP_CL2FE_REQ_PC_TRADE_CASH_REGISTER*)data->buf; sP_CL2FE_REQ_PC_TRADE_CASH_REGISTER* pacdat = (sP_CL2FE_REQ_PC_TRADE_CASH_REGISTER*)data->buf;
PlayerView& plr = PlayerManager::players[sock]; Player* plr = PlayerManager::getPlayer(sock);
if (pacdat->iCandy < 0 || pacdat->iCandy > plr.plr->money) if (pacdat->iCandy < 0 || pacdat->iCandy > plr->money)
return; // famous glitch, begone return; // famous glitch, begone
INITSTRUCT(sP_FE2CL_REP_PC_TRADE_CASH_REGISTER_SUCC, resp); INITSTRUCT(sP_FE2CL_REP_PC_TRADE_CASH_REGISTER_SUCC, resp);
@ -753,13 +755,13 @@ void ItemManager::itemTradeRegisterCashHandler(CNSocket* sock, CNPacketData* dat
CNSocket* otherSock = sock; CNSocket* otherSock = sock;
for (auto pair : PlayerManager::players) { for (auto pair : PlayerManager::players) {
if (pair.second.plr->iID == iID_Check) { if (pair.second->iID == iID_Check) {
otherSock = pair.first; otherSock = pair.first;
} }
} }
plr.plr->moneyInTrade = pacdat->iCandy; plr->moneyInTrade = pacdat->iCandy;
plr.plr->isTradeConfirm = false; plr->isTradeConfirm = false;
sock->sendPacket((void*)&resp, P_FE2CL_REP_PC_TRADE_CASH_REGISTER_SUCC, sizeof(sP_FE2CL_REP_PC_TRADE_CASH_REGISTER_SUCC)); sock->sendPacket((void*)&resp, P_FE2CL_REP_PC_TRADE_CASH_REGISTER_SUCC, sizeof(sP_FE2CL_REP_PC_TRADE_CASH_REGISTER_SUCC));
otherSock->sendPacket((void*)&resp, P_FE2CL_REP_PC_TRADE_CASH_REGISTER_SUCC, sizeof(sP_FE2CL_REP_PC_TRADE_CASH_REGISTER_SUCC)); otherSock->sendPacket((void*)&resp, P_FE2CL_REP_PC_TRADE_CASH_REGISTER_SUCC, sizeof(sP_FE2CL_REP_PC_TRADE_CASH_REGISTER_SUCC));
@ -791,7 +793,7 @@ void ItemManager::itemTradeChatHandler(CNSocket* sock, CNPacketData* data) {
CNSocket* otherSock = sock; CNSocket* otherSock = sock;
for (auto pair : PlayerManager::players) { for (auto pair : PlayerManager::players) {
if (pair.second.plr->iID == iID_Check) { if (pair.second->iID == iID_Check) {
otherSock = pair.first; otherSock = pair.first;
} }
} }

6
src/MobManager.cpp
View File

@ -861,7 +861,7 @@ void MobManager::playerTick(CNServer *serv, time_t currTime) {
for (auto& pair : PlayerManager::players) { for (auto& pair : PlayerManager::players) {
CNSocket *sock = pair.first; CNSocket *sock = pair.first;
Player *plr = pair.second.plr; Player *plr = pair.second;
bool transmit = false; bool transmit = false;
// group ticks // group ticks
@ -1001,8 +1001,8 @@ void MobManager::pcAttackChars(CNSocket *sock, CNPacketData *data) {
Player *target = nullptr; Player *target = nullptr;
for (auto& pair : PlayerManager::players) { for (auto& pair : PlayerManager::players) {
if (pair.second.plr->iID == pktdata[i*2]) { if (pair.second->iID == pktdata[i*2]) {
target = pair.second.plr; target = pair.second;
break; break;
} }
} }

16
src/NPCManager.cpp
View File

@ -622,7 +622,7 @@ void NPCManager::npcWarpTimeMachine(CNSocket* sock, CNPacketData* data) {
} }
void NPCManager::handleWarp(CNSocket* sock, int32_t warpId) { void NPCManager::handleWarp(CNSocket* sock, int32_t warpId) {
PlayerView& plrv = PlayerManager::players[sock]; Player* plr = PlayerManager::getPlayer(sock);
// sanity check // sanity check
if (Warps.find(warpId) == Warps.end()) if (Warps.find(warpId) == Warps.end())
return; return;
@ -633,14 +633,14 @@ void NPCManager::handleWarp(CNSocket* sock, int32_t warpId) {
// if warp requires you to be on a mission, it's gotta be a unique instance // if warp requires you to be on a mission, it's gotta be a unique instance
if (Warps[warpId].limitTaskID != 0 || instanceID == 14) { // 14 is a special case for the Time Lab if (Warps[warpId].limitTaskID != 0 || instanceID == 14) { // 14 is a special case for the Time Lab
instanceID += ((uint64_t)plrv.plr->iIDGroup << 32); // upper 32 bits are leader ID instanceID += ((uint64_t)plr->iIDGroup << 32); // upper 32 bits are leader ID
ChunkManager::createInstance(instanceID); ChunkManager::createInstance(instanceID);
} }
if (plrv.plr->iID == plrv.plr->iIDGroup && plrv.plr->groupCnt == 1) if (plr->iID == plr->iIDGroup && plr->groupCnt == 1)
PlayerManager::sendPlayerTo(sock, Warps[warpId].x, Warps[warpId].y, Warps[warpId].z, instanceID); PlayerManager::sendPlayerTo(sock, Warps[warpId].x, Warps[warpId].y, Warps[warpId].z, instanceID);
else { else {
Player* leaderPlr = PlayerManager::getPlayerFromID(plrv.plr->iIDGroup); Player* leaderPlr = PlayerManager::getPlayerFromID(plr->iIDGroup);
for (int i = 0; i < leaderPlr->groupCnt; i++) { for (int i = 0; i < leaderPlr->groupCnt; i++) {
Player* otherPlr = PlayerManager::getPlayerFromID(leaderPlr->groupIDs[i]); Player* otherPlr = PlayerManager::getPlayerFromID(leaderPlr->groupIDs[i]);
@ -659,11 +659,11 @@ void NPCManager::handleWarp(CNSocket* sock, int32_t warpId) {
resp.iX = Warps[warpId].x; resp.iX = Warps[warpId].x;
resp.iY = Warps[warpId].y; resp.iY = Warps[warpId].y;
resp.iZ = Warps[warpId].z; resp.iZ = Warps[warpId].z;
resp.iCandy = plrv.plr->money; resp.iCandy = plr->money;
resp.eIL = 4; // do not take away any items resp.eIL = 4; // do not take away any items
PlayerManager::removePlayerFromChunks(plrv.currentChunks, sock); PlayerManager::removePlayerFromChunks(*plr->currentChunks, sock);
plrv.currentChunks.clear(); plr->currentChunks->clear();
plrv.plr->instanceID = INSTANCE_OVERWORLD; plr->instanceID = INSTANCE_OVERWORLD;
sock->sendPacket((void*)&resp, P_FE2CL_REP_PC_WARP_USE_NPC_SUCC, sizeof(sP_FE2CL_REP_PC_WARP_USE_NPC_SUCC)); sock->sendPacket((void*)&resp, P_FE2CL_REP_PC_WARP_USE_NPC_SUCC, sizeof(sP_FE2CL_REP_PC_WARP_USE_NPC_SUCC));
} }
} }

8
src/NanoManager.cpp
View File

@ -488,8 +488,8 @@ bool doHeal(CNSocket *sock, int32_t *pktdata, sSkillResult_Heal_HP *respdata, in
Player *plr = nullptr; Player *plr = nullptr;
for (auto& pair : PlayerManager::players) { for (auto& pair : PlayerManager::players) {
if (pair.second.plr->iID == pktdata[i]) { if (pair.second->iID == pktdata[i]) {
plr = pair.second.plr; plr = pair.second;
break; break;
} }
} }
@ -519,8 +519,8 @@ bool doGroupHeal(CNSocket *sock, int32_t *pktdata, sSkillResult_Heal_HP *respdat
Player *plr = nullptr; Player *plr = nullptr;
for (auto& pair : PlayerManager::players) { for (auto& pair : PlayerManager::players) {
if (pair.second.plr->iID == pktdata[0]) { if (pair.second->iID == pktdata[0]) {
plr = pair.second.plr; plr = pair.second;
break; break;
} }
} }

5
src/Player.hpp
View File

@ -5,6 +5,7 @@
#include "CNProtocol.hpp" #include "CNProtocol.hpp"
#include "CNStructs.hpp" #include "CNStructs.hpp"
#include "ChunkManager.hpp"
#define ACTIVE_MISSION_COUNT 6 #define ACTIVE_MISSION_COUNT 6
@ -75,4 +76,8 @@ struct Player {
bool buddiesSynced; bool buddiesSynced;
int64_t buddyIDs[50]; int64_t buddyIDs[50];
ChunkPos chunkPos;
std::vector<Chunk*>* currentChunks;
time_t lastHeartbeat;
}; };

181
src/PlayerManager.cpp
View File

@ -20,7 +20,7 @@
#include <vector> #include <vector>
#include <cmath> #include <cmath>
std::map<CNSocket*, PlayerView> PlayerManager::players; std::map<CNSocket*, Player*> PlayerManager::players;
void PlayerManager::init() { void PlayerManager::init() {
// register packet types // register packet types
@ -52,11 +52,10 @@ void PlayerManager::addPlayer(CNSocket* key, Player plr) {
memcpy(p, &plr, sizeof(Player)); memcpy(p, &plr, sizeof(Player));
players[key] = PlayerView(); players[key] = p;
players[key].chunkPos = std::make_tuple(0, 0, 0); p->chunkPos = std::make_tuple(0, 0, 0);
players[key].currentChunks = std::vector<Chunk*>(); p->currentChunks = new std::vector<Chunk*>();
players[key].plr = p; p->lastHeartbeat = 0;
players[key].lastHeartbeat = 0;
key->plr = p; key->plr = p;
@ -65,28 +64,28 @@ void PlayerManager::addPlayer(CNSocket* key, Player plr) {
} }
void PlayerManager::removePlayer(CNSocket* key) { void PlayerManager::removePlayer(CNSocket* key) {
PlayerView& view = players[key]; Player* plr = getPlayer(key);
uint64_t fromInstance = view.plr->instanceID; uint64_t fromInstance = plr->instanceID;
GroupManager::groupKickPlayer(view.plr); GroupManager::groupKickPlayer(plr);
// remove player's bullets // remove player's bullets
MobManager::Bullets.erase(view.plr->iID); MobManager::Bullets.erase(plr->iID);
// save player to DB // save player to DB
Database::updatePlayer(view.plr); Database::updatePlayer(plr);
// remove players from all chunks // remove players from all chunks
removePlayerFromChunks(view.currentChunks, key); removePlayerFromChunks(*plr->currentChunks, key);
// remove from chunk // remove from chunk
if (ChunkManager::chunks.find(view.chunkPos) != ChunkManager::chunks.end()) if (ChunkManager::chunks.find(plr->chunkPos) != ChunkManager::chunks.end())
ChunkManager::chunks[view.chunkPos]->players.erase(key); ChunkManager::chunks[plr->chunkPos]->players.erase(key);
std::cout << getPlayerName(key->plr) << " has left!" << std::endl; std::cout << getPlayerName(key->plr) << " has left!" << std::endl;
key->plr = nullptr; key->plr = nullptr;
delete view.plr; delete plr;
players.erase(key); players.erase(key);
// if the player was in a lair, clean it up // if the player was in a lair, clean it up
@ -136,15 +135,15 @@ bool PlayerManager::removePlayerFromChunks(std::vector<Chunk*> chunks, CNSocket*
// remove players from eachother // remove players from eachother
for (CNSocket* otherSock : chunk->players) { for (CNSocket* otherSock : chunk->players) {
exitPlayer.iID = players[sock].plr->iID; exitPlayer.iID = getPlayer(sock)->iID;
otherSock->sendPacket((void*)&exitPlayer, P_FE2CL_PC_EXIT, sizeof(sP_FE2CL_PC_EXIT)); otherSock->sendPacket((void*)&exitPlayer, P_FE2CL_PC_EXIT, sizeof(sP_FE2CL_PC_EXIT));
exitPlayer.iID = players[otherSock].plr->iID; exitPlayer.iID = getPlayer(otherSock)->iID;
sock->sendPacket((void*)&exitPlayer, P_FE2CL_PC_EXIT, sizeof(sP_FE2CL_PC_EXIT)); sock->sendPacket((void*)&exitPlayer, P_FE2CL_PC_EXIT, sizeof(sP_FE2CL_PC_EXIT));
} }
} }
// remove us from that old stinky chunk // remove us from that old stinky chunk
return ChunkManager::removePlayer(players[sock].chunkPos, sock); return ChunkManager::removePlayer(getPlayer(sock)->chunkPos, sock);
} }
void PlayerManager::addPlayerToChunks(std::vector<Chunk*> chunks, CNSocket* sock) { void PlayerManager::addPlayerToChunks(std::vector<Chunk*> chunks, CNSocket* sock) {
@ -182,8 +181,8 @@ void PlayerManager::addPlayerToChunks(std::vector<Chunk*> chunks, CNSocket* sock
if (sock == otherSock) if (sock == otherSock)
continue; continue;
Player *otherPlr = players[otherSock].plr; Player *otherPlr = getPlayer(otherSock);
Player *plr = players[sock].plr; Player *plr = getPlayer(sock);
newPlayer.PCAppearanceData.iID = plr->iID; newPlayer.PCAppearanceData.iID = plr->iID;
newPlayer.PCAppearanceData.iHP = plr->HP; newPlayer.PCAppearanceData.iHP = plr->HP;
@ -219,61 +218,63 @@ void PlayerManager::addPlayerToChunks(std::vector<Chunk*> chunks, CNSocket* sock
} }
void PlayerManager::updatePlayerPosition(CNSocket* sock, int X, int Y, int Z, int angle) { void PlayerManager::updatePlayerPosition(CNSocket* sock, int X, int Y, int Z, int angle) {
players[sock].plr->angle = angle; getPlayer(sock)->angle = angle;
updatePlayerPosition(sock, X, Y, Z); updatePlayerPosition(sock, X, Y, Z);
} }
void PlayerManager::updatePlayerPosition(CNSocket* sock, int X, int Y, int Z) { void PlayerManager::updatePlayerPosition(CNSocket* sock, int X, int Y, int Z) {
PlayerView& view = players[sock]; Player* plr = getPlayer(sock);
view.plr->x = X; plr->x = X;
view.plr->y = Y; plr->y = Y;
view.plr->z = Z; plr->z = Z;
updatePlayerChunk(sock, X, Y, view.plr->instanceID); updatePlayerChunk(sock, X, Y, plr->instanceID);
} }
void PlayerManager::updatePlayerChunk(CNSocket* sock, int X, int Y, uint64_t instanceID) { void PlayerManager::updatePlayerChunk(CNSocket* sock, int X, int Y, uint64_t instanceID) {
PlayerView& view = players[sock]; Player* plr = getPlayer(sock);
ChunkPos newPos = ChunkManager::grabChunk(X, Y, view.plr->instanceID); ChunkPos newPos = ChunkManager::grabChunk(X, Y, plr->instanceID);
// nothing to be done // nothing to be done
if (newPos == view.chunkPos) if (newPos == plr->chunkPos)
return; return;
// add player to chunk // add player to chunk
ChunkManager::addPlayer(X, Y, view.plr->instanceID, sock); ChunkManager::addPlayer(X, Y, plr->instanceID, sock);
std::vector<Chunk*> allChunks = ChunkManager::grabChunks(newPos); std::vector<Chunk*> allChunks = ChunkManager::grabChunks(newPos);
Chunk *chunk = nullptr; Chunk *chunk = nullptr;
if (ChunkManager::checkChunk(view.chunkPos)) if (ChunkManager::checkChunk(plr->chunkPos))
chunk = ChunkManager::chunks[view.chunkPos]; chunk = ChunkManager::chunks[plr->chunkPos];
// first, remove all the old npcs & players from the old chunks // first, remove all the old npcs & players from the old chunks
if (removePlayerFromChunks(ChunkManager::getDeltaChunks(view.currentChunks, allChunks), sock)) { if (removePlayerFromChunks(ChunkManager::getDeltaChunks(*plr->currentChunks, allChunks), sock)) {
allChunks.erase(std::remove(allChunks.begin(), allChunks.end(), chunk), allChunks.end()); allChunks.erase(std::remove(allChunks.begin(), allChunks.end(), chunk), allChunks.end());
} }
// now, add all the new npcs & players! // now, add all the new npcs & players!
addPlayerToChunks(ChunkManager::getDeltaChunks(allChunks, view.currentChunks), sock); addPlayerToChunks(ChunkManager::getDeltaChunks(allChunks, *plr->currentChunks), sock);
view.chunkPos = newPos; plr->chunkPos = newPos;
view.currentChunks = allChunks; plr->currentChunks->clear();
for (Chunk* c : allChunks) {
plr->currentChunks->push_back(c);
}
} }
void PlayerManager::sendPlayerTo(CNSocket* sock, int X, int Y, int Z, uint64_t I) { void PlayerManager::sendPlayerTo(CNSocket* sock, int X, int Y, int Z, uint64_t I) {
PlayerView& plrv = PlayerManager::players[sock]; Player* plr = getPlayer(sock);
Player* plr = plrv.plr;
if (plrv.plr->instanceID == 0) { if (plr->instanceID == 0) {
// save last uninstanced coords // save last uninstanced coords
plrv.plr->lastX = plrv.plr->x; plr->lastX = plr->x;
plrv.plr->lastY = plrv.plr->y; plr->lastY = plr->y;
plrv.plr->lastZ = plrv.plr->z; plr->lastZ = plr->z;
plrv.plr->lastAngle = plrv.plr->angle; plr->lastAngle = plr->angle;
} }
MissionManager::failInstancedMissions(sock); // fail any instanced missions MissionManager::failInstancedMissions(sock); // fail any instanced missions
uint64_t fromInstance = plrv.plr->instanceID; // pre-warp instance, saved for post-warp uint64_t fromInstance = plr->instanceID; // pre-warp instance, saved for post-warp
plr->instanceID = I; plr->instanceID = I;
if (I != INSTANCE_OVERWORLD) { if (I != INSTANCE_OVERWORLD) {
@ -288,10 +289,10 @@ void PlayerManager::sendPlayerTo(CNSocket* sock, int X, int Y, int Z, uint64_t I
resp.iX = X; resp.iX = X;
resp.iY = Y; resp.iY = Y;
resp.iZ = Z; resp.iZ = Z;
resp.iCandy = plrv.plr->money; resp.iCandy = plr->money;
resp.eIL = 4; // do not take away any items resp.eIL = 4; // do not take away any items
PlayerManager::removePlayerFromChunks(plrv.currentChunks, sock); PlayerManager::removePlayerFromChunks(*plr->currentChunks, sock);
plrv.currentChunks.clear(); plr->currentChunks->clear();
sock->sendPacket((void*)&resp, P_FE2CL_REP_PC_WARP_USE_NPC_SUCC, sizeof(sP_FE2CL_REP_PC_WARP_USE_NPC_SUCC)); sock->sendPacket((void*)&resp, P_FE2CL_REP_PC_WARP_USE_NPC_SUCC, sizeof(sP_FE2CL_REP_PC_WARP_USE_NPC_SUCC));
updatePlayerPosition(sock, X, Y, Z); updatePlayerPosition(sock, X, Y, Z);
} }
@ -308,10 +309,10 @@ void PlayerManager::sendPlayerTo(CNSocket* sock, int X, int Y, int Z) {
pkt.iZ = Z; pkt.iZ = Z;
// force player & NPC reload // force player & NPC reload
PlayerView& plrv = players[sock]; Player* plr = getPlayer(sock);
PlayerManager::removePlayerFromChunks(plrv.currentChunks, sock); PlayerManager::removePlayerFromChunks(*plr->currentChunks, sock);
plrv.currentChunks.clear(); plr->currentChunks->clear();
plrv.chunkPos = std::make_tuple(0, 0, plrv.plr->instanceID); plr->chunkPos = std::make_tuple(0, 0, plr->instanceID);
sock->sendPacket((void*)&pkt, P_FE2CL_REP_PC_GOTO_SUCC, sizeof(sP_FE2CL_REP_PC_GOTO_SUCC)); sock->sendPacket((void*)&pkt, P_FE2CL_REP_PC_GOTO_SUCC, sizeof(sP_FE2CL_REP_PC_GOTO_SUCC));
} }
@ -439,12 +440,12 @@ void PlayerManager::enterPlayer(CNSocket* sock, CNPacketData* data) {
BuddyManager::refreshBuddyList(sock); BuddyManager::refreshBuddyList(sock);
for (auto& pair : PlayerManager::players) for (auto& pair : PlayerManager::players)
if (pair.second.plr->notify) if (pair.second->notify)
ChatManager::sendServerMessage(pair.first, "[ADMIN]" + getPlayerName(&plr) + " has joined."); ChatManager::sendServerMessage(pair.first, "[ADMIN]" + getPlayerName(&plr) + " has joined.");
} }
void PlayerManager::sendToViewable(CNSocket* sock, void* buf, uint32_t type, size_t size) { void PlayerManager::sendToViewable(CNSocket* sock, void* buf, uint32_t type, size_t size) {
for (Chunk* chunk : players[sock].currentChunks) { for (Chunk* chunk : *getPlayer(sock)->currentChunks) {
for (CNSocket* otherSock : chunk->players) { for (CNSocket* otherSock : chunk->players) {
if (otherSock == sock) if (otherSock == sock)
continue; continue;
@ -482,12 +483,14 @@ void PlayerManager::movePlayer(CNSocket* sock, CNPacketData* data) {
sP_CL2FE_REQ_PC_MOVE* moveData = (sP_CL2FE_REQ_PC_MOVE*)data->buf; sP_CL2FE_REQ_PC_MOVE* moveData = (sP_CL2FE_REQ_PC_MOVE*)data->buf;
updatePlayerPosition(sock, moveData->iX, moveData->iY, moveData->iZ, moveData->iAngle); updatePlayerPosition(sock, moveData->iX, moveData->iY, moveData->iZ, moveData->iAngle);
players[sock].plr->angle = moveData->iAngle; Player* plr = getPlayer(sock);
plr->angle = moveData->iAngle;
uint64_t tm = getTime(); uint64_t tm = getTime();
INITSTRUCT(sP_FE2CL_PC_MOVE, moveResponse); INITSTRUCT(sP_FE2CL_PC_MOVE, moveResponse);
moveResponse.iID = players[sock].plr->iID; moveResponse.iID = plr->iID;
moveResponse.cKeyValue = moveData->cKeyValue; moveResponse.cKeyValue = moveData->cKeyValue;
moveResponse.iX = moveData->iX; moveResponse.iX = moveData->iX;
@ -516,7 +519,7 @@ void PlayerManager::stopPlayer(CNSocket* sock, CNPacketData* data) {
INITSTRUCT(sP_FE2CL_PC_STOP, stopResponse); INITSTRUCT(sP_FE2CL_PC_STOP, stopResponse);
stopResponse.iID = players[sock].plr->iID; stopResponse.iID = getPlayer(sock)->iID;
stopResponse.iX = stopData->iX; stopResponse.iX = stopData->iX;
stopResponse.iY = stopData->iY; stopResponse.iY = stopData->iY;
@ -539,7 +542,7 @@ void PlayerManager::jumpPlayer(CNSocket* sock, CNPacketData* data) {
INITSTRUCT(sP_FE2CL_PC_JUMP, jumpResponse); INITSTRUCT(sP_FE2CL_PC_JUMP, jumpResponse);
jumpResponse.iID = players[sock].plr->iID; jumpResponse.iID = getPlayer(sock)->iID;
jumpResponse.cKeyValue = jumpData->cKeyValue; jumpResponse.cKeyValue = jumpData->cKeyValue;
jumpResponse.iX = jumpData->iX; jumpResponse.iX = jumpData->iX;
@ -568,7 +571,7 @@ void PlayerManager::jumppadPlayer(CNSocket* sock, CNPacketData* data) {
INITSTRUCT(sP_FE2CL_PC_JUMPPAD, jumppadResponse); INITSTRUCT(sP_FE2CL_PC_JUMPPAD, jumppadResponse);
jumppadResponse.iPC_ID = players[sock].plr->iID; jumppadResponse.iPC_ID = getPlayer(sock)->iID;
jumppadResponse.cKeyValue = jumppadData->cKeyValue; jumppadResponse.cKeyValue = jumppadData->cKeyValue;
jumppadResponse.iX = jumppadData->iX; jumppadResponse.iX = jumppadData->iX;
@ -595,7 +598,7 @@ void PlayerManager::launchPlayer(CNSocket* sock, CNPacketData* data) {
INITSTRUCT(sP_FE2CL_PC_LAUNCHER, launchResponse); INITSTRUCT(sP_FE2CL_PC_LAUNCHER, launchResponse);
launchResponse.iPC_ID = players[sock].plr->iID; launchResponse.iPC_ID = getPlayer(sock)->iID;
launchResponse.iX = launchData->iX; launchResponse.iX = launchData->iX;
launchResponse.iY = launchData->iY; launchResponse.iY = launchData->iY;
@ -623,7 +626,7 @@ void PlayerManager::ziplinePlayer(CNSocket* sock, CNPacketData* data) {
INITSTRUCT(sP_FE2CL_PC_ZIPLINE, ziplineResponse); INITSTRUCT(sP_FE2CL_PC_ZIPLINE, ziplineResponse);
ziplineResponse.iPC_ID = players[sock].plr->iID; ziplineResponse.iPC_ID = getPlayer(sock)->iID;
ziplineResponse.iCliTime = ziplineData->iCliTime; ziplineResponse.iCliTime = ziplineData->iCliTime;
ziplineResponse.iSvrTime = tm; ziplineResponse.iSvrTime = tm;
ziplineResponse.iX = ziplineData->iX; ziplineResponse.iX = ziplineData->iX;
@ -658,7 +661,7 @@ void PlayerManager::movePlatformPlayer(CNSocket* sock, CNPacketData* data) {
INITSTRUCT(sP_FE2CL_PC_MOVEPLATFORM, platResponse); INITSTRUCT(sP_FE2CL_PC_MOVEPLATFORM, platResponse);
platResponse.iPC_ID = players[sock].plr->iID; platResponse.iPC_ID = getPlayer(sock)->iID;
platResponse.iCliTime = platformData->iCliTime; platResponse.iCliTime = platformData->iCliTime;
platResponse.iSvrTime = tm; platResponse.iSvrTime = tm;
platResponse.iX = platformData->iX; platResponse.iX = platformData->iX;
@ -690,7 +693,7 @@ void PlayerManager::moveSliderPlayer(CNSocket* sock, CNPacketData* data) {
INITSTRUCT(sP_FE2CL_PC_MOVETRANSPORTATION, sliderResponse); INITSTRUCT(sP_FE2CL_PC_MOVETRANSPORTATION, sliderResponse);
sliderResponse.iPC_ID = players[sock].plr->iID; sliderResponse.iPC_ID = getPlayer(sock)->iID;
sliderResponse.iCliTime = sliderData->iCliTime; sliderResponse.iCliTime = sliderData->iCliTime;
sliderResponse.iSvrTime = tm; sliderResponse.iSvrTime = tm;
sliderResponse.iX = sliderData->iX; sliderResponse.iX = sliderData->iX;
@ -721,7 +724,7 @@ void PlayerManager::moveSlopePlayer(CNSocket* sock, CNPacketData* data) {
INITSTRUCT(sP_FE2CL_PC_SLOPE, slopeResponse); INITSTRUCT(sP_FE2CL_PC_SLOPE, slopeResponse);
slopeResponse.iPC_ID = players[sock].plr->iID; slopeResponse.iPC_ID = getPlayer(sock)->iID;
slopeResponse.iCliTime = slopeData->iCliTime; slopeResponse.iCliTime = slopeData->iCliTime;
slopeResponse.iSvrTime = tm; slopeResponse.iSvrTime = tm;
slopeResponse.iX = slopeData->iX; slopeResponse.iX = slopeData->iX;
@ -809,7 +812,7 @@ void PlayerManager::setSpecialPlayer(CNSocket* sock, CNPacketData* data) {
} }
void PlayerManager::heartbeatPlayer(CNSocket* sock, CNPacketData* data) { void PlayerManager::heartbeatPlayer(CNSocket* sock, CNPacketData* data) {
players[sock].lastHeartbeat = getTime(); getPlayer(sock)->lastHeartbeat = getTime();
} }
void PlayerManager::exitGame(CNSocket* sock, CNPacketData* data) { void PlayerManager::exitGame(CNSocket* sock, CNPacketData* data) {
@ -893,48 +896,44 @@ void PlayerManager::revivePlayer(CNSocket* sock, CNPacketData* data) {
} }
void PlayerManager::enterPlayerVehicle(CNSocket* sock, CNPacketData* data) { void PlayerManager::enterPlayerVehicle(CNSocket* sock, CNPacketData* data) {
PlayerView& plr = PlayerManager::players[sock]; Player* plr = getPlayer(sock);
if (plr.plr->Equip[8].iID > 0 && plr.plr->Equip[8].iTimeLimit>getTimestamp()) { if (plr->Equip[8].iID > 0 && plr->Equip[8].iTimeLimit>getTimestamp()) {
INITSTRUCT(sP_FE2CL_PC_VEHICLE_ON_SUCC, response); INITSTRUCT(sP_FE2CL_PC_VEHICLE_ON_SUCC, response);
sock->sendPacket((void*)&response, P_FE2CL_PC_VEHICLE_ON_SUCC, sizeof(sP_FE2CL_PC_VEHICLE_ON_SUCC)); sock->sendPacket((void*)&response, P_FE2CL_PC_VEHICLE_ON_SUCC, sizeof(sP_FE2CL_PC_VEHICLE_ON_SUCC));
// send to other players // send to other players
plr.plr->iPCState |= 8; plr->iPCState |= 8;
INITSTRUCT(sP_FE2CL_PC_STATE_CHANGE, response2); INITSTRUCT(sP_FE2CL_PC_STATE_CHANGE, response2);
response2.iPC_ID = plr.plr->iID; response2.iPC_ID = plr->iID;
response2.iState = plr.plr->iPCState; response2.iState = plr->iPCState;
sendToViewable(sock, (void*)&response2, P_FE2CL_PC_STATE_CHANGE, sizeof(sP_FE2CL_PC_STATE_CHANGE));
for (Chunk* chunk : players[sock].currentChunks) {
for (CNSocket* otherSock : chunk->players) {
otherSock->sendPacket((void*)&response2, P_FE2CL_PC_STATE_CHANGE, sizeof(sP_FE2CL_PC_STATE_CHANGE));
}
}
} else { } else {
INITSTRUCT(sP_FE2CL_PC_VEHICLE_ON_FAIL, response); INITSTRUCT(sP_FE2CL_PC_VEHICLE_ON_FAIL, response);
sock->sendPacket((void*)&response, P_FE2CL_PC_VEHICLE_ON_FAIL, sizeof(sP_FE2CL_PC_VEHICLE_ON_FAIL)); sock->sendPacket((void*)&response, P_FE2CL_PC_VEHICLE_ON_FAIL, sizeof(sP_FE2CL_PC_VEHICLE_ON_FAIL));
// check if vehicle didn't expire // check if vehicle didn't expire
if (plr.plr->Equip[8].iTimeLimit < getTimestamp()) { if (plr->Equip[8].iTimeLimit < getTimestamp()) {
plr.plr->toRemoveVehicle.eIL = 0; plr->toRemoveVehicle.eIL = 0;
plr.plr->toRemoveVehicle.iSlotNum = 8; plr->toRemoveVehicle.iSlotNum = 8;
ItemManager::checkItemExpire(sock, plr.plr); ItemManager::checkItemExpire(sock, plr);
} }
} }
} }
void PlayerManager::exitPlayerVehicle(CNSocket* sock, CNPacketData* data) { void PlayerManager::exitPlayerVehicle(CNSocket* sock, CNPacketData* data) {
PlayerView plr = PlayerManager::players[sock]; Player* plr = getPlayer(sock);
if (plr.plr->iPCState & 8) { if (plr->iPCState & 8) {
INITSTRUCT(sP_FE2CL_PC_VEHICLE_OFF_SUCC, response); INITSTRUCT(sP_FE2CL_PC_VEHICLE_OFF_SUCC, response);
sock->sendPacket((void*)&response, P_FE2CL_PC_VEHICLE_OFF_SUCC, sizeof(sP_FE2CL_PC_VEHICLE_OFF_SUCC)); sock->sendPacket((void*)&response, P_FE2CL_PC_VEHICLE_OFF_SUCC, sizeof(sP_FE2CL_PC_VEHICLE_OFF_SUCC));
// send to other players // send to other players
plr.plr->iPCState &= ~8; plr->iPCState &= ~8;
INITSTRUCT(sP_FE2CL_PC_STATE_CHANGE, response2); INITSTRUCT(sP_FE2CL_PC_STATE_CHANGE, response2);
response2.iPC_ID = plr.plr->iID; response2.iPC_ID = plr->iID;
response2.iState = plr.plr->iPCState; response2.iState = plr->iPCState;
sendToViewable(sock, (void*)&response2, P_FE2CL_PC_STATE_CHANGE, sizeof(sP_FE2CL_PC_STATE_CHANGE)); sendToViewable(sock, (void*)&response2, P_FE2CL_PC_STATE_CHANGE, sizeof(sP_FE2CL_PC_STATE_CHANGE));
} }
@ -985,7 +984,7 @@ void PlayerManager::changePlayerGuide(CNSocket *sock, CNPacketData *data) {
#pragma region Helper methods #pragma region Helper methods
Player *PlayerManager::getPlayer(CNSocket* key) { Player *PlayerManager::getPlayer(CNSocket* key) {
if (players.find(key) != players.end()) if (players.find(key) != players.end())
return players[key].plr; return players[key];
return nullptr; return nullptr;
} }
@ -1019,20 +1018,20 @@ WarpLocation PlayerManager::getRespawnPoint(Player *plr) {
} }
bool PlayerManager::isAccountInUse(int accountId) { bool PlayerManager::isAccountInUse(int accountId) {
std::map<CNSocket*, PlayerView>::iterator it; std::map<CNSocket*, Player*>::iterator it;
for (it = PlayerManager::players.begin(); it != PlayerManager::players.end(); it++) { for (it = PlayerManager::players.begin(); it != PlayerManager::players.end(); it++) {
if (it->second.plr->accountId == accountId) if (it->second->accountId == accountId)
return true; return true;
} }
return false; return false;
} }
void PlayerManager::exitDuplicate(int accountId) { void PlayerManager::exitDuplicate(int accountId) {
std::map<CNSocket*, PlayerView>::iterator it; std::map<CNSocket*, Player*>::iterator it;
// disconnect any duplicate players // disconnect any duplicate players
for (it = players.begin(); it != players.end(); it++) { for (it = players.begin(); it != players.end(); it++) {
if (it->second.plr->accountId == accountId) { if (it->second->accountId == accountId) {
CNSocket* sock = it->first; CNSocket* sock = it->first;
INITSTRUCT(sP_FE2CL_REP_PC_EXIT_DUPLICATE, resp); INITSTRUCT(sP_FE2CL_REP_PC_EXIT_DUPLICATE, resp);
@ -1074,15 +1073,15 @@ void PlayerManager::setSpecialState(CNSocket* sock, CNPacketData* data) {
Player *PlayerManager::getPlayerFromID(int32_t iID) { Player *PlayerManager::getPlayerFromID(int32_t iID) {
for (auto& pair : PlayerManager::players) for (auto& pair : PlayerManager::players)
if (pair.second.plr->iID == iID) if (pair.second->iID == iID)
return pair.second.plr; return pair.second;
return nullptr; return nullptr;
} }
CNSocket *PlayerManager::getSockFromID(int32_t iID) { CNSocket *PlayerManager::getSockFromID(int32_t iID) {
for (auto& pair : PlayerManager::players) for (auto& pair : PlayerManager::players)
if (pair.second.plr->iID == iID) if (pair.second->iID == iID)
return pair.first; return pair.first;
return nullptr; return nullptr;

10
src/PlayerManager.hpp
View File

@ -12,16 +12,8 @@
struct WarpLocation; struct WarpLocation;
struct PlayerView {
ChunkPos chunkPos;
std::vector<Chunk*> currentChunks;
Player *plr;
time_t lastHeartbeat;
};
namespace PlayerManager { namespace PlayerManager {
extern std::map<CNSocket*, PlayerView> players; extern std::map<CNSocket*, Player*> players;
void init(); void init();
void addPlayer(CNSocket* key, Player plr); void addPlayer(CNSocket* key, Player plr);

7
src/TransportManager.cpp
View File

@ -139,7 +139,6 @@ void TransportManager::transportWarpHandler(CNSocket* sock, CNPacketData* data)
plr->money -= route.cost; plr->money -= route.cost;
TransportLocation target; TransportLocation target;
PlayerView& plrv = PlayerManager::players[sock];
switch (route.type) { switch (route.type) {
case 1: // S.C.A.M.P.E.R. case 1: // S.C.A.M.P.E.R.
target = Locations[route.end]; target = Locations[route.end];
@ -150,9 +149,9 @@ void TransportManager::transportWarpHandler(CNSocket* sock, CNPacketData* data)
* Not strictly necessary since there isn't a valid SCAMPER that puts you in the * Not strictly necessary since there isn't a valid SCAMPER that puts you in the
* same map tile you were already in, but we might as well force an NPC reload. * same map tile you were already in, but we might as well force an NPC reload.
*/ */
PlayerManager::removePlayerFromChunks(plrv.currentChunks, sock); PlayerManager::removePlayerFromChunks(*plr->currentChunks, sock);
plrv.currentChunks.clear(); plr->currentChunks->clear();
plrv.chunkPos = std::make_tuple(0, 0, plrv.plr->instanceID); plr->chunkPos = std::make_tuple(0, 0, plr->instanceID);
break; break;
case 2: // Monkey Skyway case 2: // Monkey Skyway
if (SkywayPaths.find(route.mssRouteNum) != SkywayPaths.end()) { // check if route exists if (SkywayPaths.find(route.mssRouteNum) != SkywayPaths.end()) { // check if route exists