mirror of
https://github.com/OpenFusionProject/OpenFusion.git
synced 2024-11-04 22:40:05 +00:00
[refactor] Remove the word 'Manager' from most source files/namespaces
ChatManager -> Chat MissionManager -> Missions NanoManager -> Nanos TransportManager -> Transport ChunkManager -> Chunking BuddyManager -> Buddies GroupManager -> Groups RacingManager -> Racing ItemManager -> Items NPCManager and PlayerManager remain. Note: You can use git log --follow src/file.cpp to trace the history of a file from before it was renamed.
This commit is contained in:
parent
cee09f6344
commit
e9bc2fe561
36
Makefile
36
Makefile
@ -42,7 +42,7 @@ CXXSRC=\
|
||||
src/db/shard.cpp\
|
||||
src/db/player.cpp\
|
||||
src/db/email.cpp\
|
||||
src/ChatManager.cpp\
|
||||
src/Chat.cpp\
|
||||
src/CustomCommands.cpp\
|
||||
src/CNLoginServer.cpp\
|
||||
src/CNProtocol.cpp\
|
||||
@ -51,24 +51,24 @@ CXXSRC=\
|
||||
src/Defines.cpp\
|
||||
src/Email.cpp\
|
||||
src/main.cpp\
|
||||
src/MissionManager.cpp\
|
||||
src/Missions.cpp\
|
||||
src/MobAI.cpp\
|
||||
src/Combat.cpp\
|
||||
src/NanoManager.cpp\
|
||||
src/Nanos.cpp\
|
||||
src/Abilities.cpp\
|
||||
src/ItemManager.cpp\
|
||||
src/Items.cpp\
|
||||
src/NPCManager.cpp\
|
||||
src/PlayerManager.cpp\
|
||||
src/PlayerMovement.cpp\
|
||||
src/BuiltinCommands.cpp\
|
||||
src/settings.cpp\
|
||||
src/TransportManager.cpp\
|
||||
src/Transport.cpp\
|
||||
src/TableData.cpp\
|
||||
src/ChunkManager.cpp\
|
||||
src/BuddyManager.cpp\
|
||||
src/GroupManager.cpp\
|
||||
src/Chunking.cpp\
|
||||
src/Buddies.cpp\
|
||||
src/Groups.cpp\
|
||||
src/Monitor.cpp\
|
||||
src/RacingManager.cpp\
|
||||
src/Racing.cpp\
|
||||
src/Vendor.cpp\
|
||||
src/Trading.cpp\
|
||||
|
||||
@ -81,7 +81,7 @@ CXXHDR=\
|
||||
vendor/JSON.hpp\
|
||||
src/db/Database.hpp\
|
||||
src/db/internal.hpp\
|
||||
src/ChatManager.hpp\
|
||||
src/Chat.hpp\
|
||||
src/CustomCommands.hpp\
|
||||
src/CNLoginServer.hpp\
|
||||
src/CNProtocol.hpp\
|
||||
@ -90,25 +90,25 @@ CXXHDR=\
|
||||
src/CNStructs.hpp\
|
||||
src/Defines.hpp\
|
||||
src/Email.hpp\
|
||||
src/MissionManager.hpp\
|
||||
src/Missions.hpp\
|
||||
src/MobAI.hpp\
|
||||
src/Combat.hpp\
|
||||
src/NanoManager.hpp\
|
||||
src/Nanos.hpp\
|
||||
src/Abilities.hpp\
|
||||
src/ItemManager.hpp\
|
||||
src/Items.hpp\
|
||||
src/NPCManager.hpp\
|
||||
src/Player.hpp\
|
||||
src/PlayerManager.hpp\
|
||||
src/PlayerMovement.hpp\
|
||||
src/BuiltinCommands.hpp\
|
||||
src/settings.hpp\
|
||||
src/TransportManager.hpp\
|
||||
src/Transport.hpp\
|
||||
src/TableData.hpp\
|
||||
src/ChunkManager.hpp\
|
||||
src/BuddyManager.hpp\
|
||||
src/GroupManager.hpp\
|
||||
src/Chunking.hpp\
|
||||
src/Buddies.hpp\
|
||||
src/Groups.hpp\
|
||||
src/Monitor.hpp\
|
||||
src/RacingManager.hpp\
|
||||
src/Racing.hpp\
|
||||
src/Vendor.hpp\
|
||||
src/Trading.hpp\
|
||||
|
||||
|
@ -2,21 +2,21 @@
|
||||
#include "PlayerManager.hpp"
|
||||
#include "Player.hpp"
|
||||
#include "NPCManager.hpp"
|
||||
#include "NanoManager.hpp"
|
||||
#include "GroupManager.hpp"
|
||||
#include "Nanos.hpp"
|
||||
#include "Groups.hpp"
|
||||
|
||||
/*
|
||||
* TODO: This file is in desperate need of deduplication and rewriting.
|
||||
*/
|
||||
|
||||
std::map<int32_t, SkillData> NanoManager::SkillTable;
|
||||
std::map<int32_t, SkillData> Nanos::SkillTable;
|
||||
|
||||
/*
|
||||
* targetData approach
|
||||
* first integer is the count
|
||||
* second to fifth integers are IDs, these can be either player iID or mob's iID
|
||||
*/
|
||||
std::vector<int> NanoManager::findTargets(Player* plr, int skillID, CNPacketData* data) {
|
||||
std::vector<int> Nanos::findTargets(Player* plr, int skillID, CNPacketData* data) {
|
||||
std::vector<int> tD(5);
|
||||
|
||||
if (SkillTable[skillID].targetType <= 2 && data != nullptr) { // client gives us the targets
|
||||
@ -65,7 +65,7 @@ std::vector<int> NanoManager::findTargets(Player* plr, int skillID, CNPacketData
|
||||
return tD;
|
||||
}
|
||||
|
||||
void NanoManager::nanoUnbuff(CNSocket* sock, std::vector<int> targetData, int32_t bitFlag, int16_t timeBuffID, int16_t amount, bool groupPower) {
|
||||
void Nanos::nanoUnbuff(CNSocket* sock, std::vector<int> targetData, int32_t bitFlag, int16_t timeBuffID, int16_t amount, bool groupPower) {
|
||||
Player *plr = PlayerManager::getPlayer(sock);
|
||||
|
||||
plr->iSelfConditionBitFlag &= ~bitFlag;
|
||||
@ -75,7 +75,7 @@ void NanoManager::nanoUnbuff(CNSocket* sock, std::vector<int> targetData, int32_
|
||||
plr->iGroupConditionBitFlag &= ~bitFlag;
|
||||
Player *leader = PlayerManager::getPlayerFromID(plr->iIDGroup);
|
||||
if (leader != nullptr)
|
||||
groupFlags = GroupManager::getGroupFlags(leader);
|
||||
groupFlags = Groups::getGroupFlags(leader);
|
||||
}
|
||||
|
||||
for (int i = 0; i < targetData[0]; i++) {
|
||||
@ -100,7 +100,7 @@ void NanoManager::nanoUnbuff(CNSocket* sock, std::vector<int> targetData, int32_
|
||||
}
|
||||
}
|
||||
|
||||
int NanoManager::applyBuff(CNSocket* sock, int skillID, int eTBU, int eTBT, int32_t groupFlags) {
|
||||
int Nanos::applyBuff(CNSocket* sock, int skillID, int eTBU, int eTBT, int32_t groupFlags) {
|
||||
if (SkillTable[skillID].drainType == 1)
|
||||
return 0;
|
||||
|
||||
@ -133,7 +133,7 @@ int NanoManager::applyBuff(CNSocket* sock, int skillID, int eTBU, int eTBT, int3
|
||||
}
|
||||
|
||||
#pragma region Nano Powers
|
||||
namespace NanoManager {
|
||||
namespace Nanos {
|
||||
|
||||
bool doDebuff(CNSocket *sock, sSkillResult_Buff *respdata, int i, int32_t targetID, int32_t bitFlag, int16_t timeBuffID, int16_t duration, int16_t amount) {
|
||||
if (MobAI::Mobs.find(targetID) == MobAI::Mobs.end()) {
|
||||
|
@ -49,7 +49,7 @@ struct SkillData {
|
||||
int powerIntensity[4];
|
||||
};
|
||||
|
||||
namespace NanoManager {
|
||||
namespace Nanos {
|
||||
extern std::vector<NanoPower> NanoPowers;
|
||||
extern std::map<int32_t, SkillData> SkillTable;
|
||||
|
||||
|
@ -1,10 +1,10 @@
|
||||
#include "CNShardServer.hpp"
|
||||
#include "CNStructs.hpp"
|
||||
#include "ChatManager.hpp"
|
||||
#include "Buddies.hpp"
|
||||
#include "PlayerManager.hpp"
|
||||
#include "BuddyManager.hpp"
|
||||
#include "Buddies.hpp"
|
||||
#include "db/Database.hpp"
|
||||
#include "ItemManager.hpp"
|
||||
#include "Items.hpp"
|
||||
#include "db/Database.hpp"
|
||||
|
||||
#include <iostream>
|
||||
@ -12,7 +12,7 @@
|
||||
#include <algorithm>
|
||||
#include <thread>
|
||||
|
||||
using namespace BuddyManager;
|
||||
using namespace Buddies;
|
||||
|
||||
#pragma region Helper methods
|
||||
|
||||
@ -36,7 +36,7 @@ static bool playerHasBuddyWithID(Player* plr, int buddyID) {
|
||||
#pragma endregion
|
||||
|
||||
// Refresh buddy list
|
||||
void BuddyManager::refreshBuddyList(CNSocket* sock) {
|
||||
void Buddies::refreshBuddyList(CNSocket* sock) {
|
||||
Player* plr = PlayerManager::getPlayer(sock);
|
||||
int buddyCnt = Database::getNumBuddies(plr);
|
||||
|
||||
@ -483,7 +483,7 @@ fail:
|
||||
sock->sendPacket((void*)&resp, P_FE2CL_REP_PC_BUDDY_WARP_FAIL, sizeof(sP_FE2CL_REP_PC_BUDDY_WARP_FAIL));
|
||||
}
|
||||
|
||||
void BuddyManager::init() {
|
||||
void Buddies::init() {
|
||||
REGISTER_SHARD_PACKET(P_CL2FE_REQ_REQUEST_MAKE_BUDDY, requestBuddy);
|
||||
REGISTER_SHARD_PACKET(P_CL2FE_REQ_PC_FIND_NAME_MAKE_BUDDY, reqBuddyByName);
|
||||
REGISTER_SHARD_PACKET(P_CL2FE_REQ_ACCEPT_MAKE_BUDDY, reqAcceptBuddy);
|
@ -5,7 +5,7 @@
|
||||
#include "CNStructs.hpp"
|
||||
#include "CNProtocol.hpp"
|
||||
|
||||
namespace BuddyManager {
|
||||
namespace Buddies {
|
||||
void init();
|
||||
|
||||
// Buddy list
|
@ -1,8 +1,8 @@
|
||||
#include "BuiltinCommands.hpp"
|
||||
#include "PlayerManager.hpp"
|
||||
#include "ChatManager.hpp"
|
||||
#include "ItemManager.hpp"
|
||||
#include "MissionManager.hpp"
|
||||
#include "Chat.hpp"
|
||||
#include "Items.hpp"
|
||||
#include "Missions.hpp"
|
||||
|
||||
// helper function, not a packet handler
|
||||
void BuiltinCommands::setSpecialState(CNSocket* sock, CNPacketData* data) {
|
||||
@ -14,7 +14,7 @@ void BuiltinCommands::setSpecialState(CNSocket* sock, CNPacketData* data) {
|
||||
|
||||
// HACK: work around the invisible weapon bug
|
||||
if (setData->iSpecialStateFlag == CN_SPECIAL_STATE_FLAG__FULL_UI)
|
||||
ItemManager::updateEquips(sock, plr);
|
||||
Items::updateEquips(sock, plr);
|
||||
|
||||
INITSTRUCT(sP_FE2CL_PC_SPECIAL_STATE_CHANGE, response);
|
||||
|
||||
@ -93,7 +93,7 @@ static void setValuePlayer(CNSocket* sock, CNPacketData* data) {
|
||||
plr->batteryN = 9999;
|
||||
break;
|
||||
case 4:
|
||||
MissionManager::updateFusionMatter(sock, setData->iSetValue - plr->fusionmatter);
|
||||
Missions::updateFusionMatter(sock, setData->iSetValue - plr->fusionmatter);
|
||||
break;
|
||||
case 5:
|
||||
plr->money = setData->iSetValue;
|
||||
@ -133,7 +133,7 @@ static void setGMSpecialOnOff(CNSocket *sock, CNPacketData *data) {
|
||||
CNSocket *otherSock = PlayerManager::getSockFromAny(req->eTargetSearchBy, req->iTargetPC_ID, req->iTargetPC_UID,
|
||||
U16toU8(req->szTargetPC_FirstName), U16toU8(req->szTargetPC_LastName));
|
||||
if (otherSock == nullptr) {
|
||||
ChatManager::sendServerMessage(sock, "player to teleport not found");
|
||||
Chat::sendServerMessage(sock, "player to teleport not found");
|
||||
return;
|
||||
}
|
||||
|
||||
@ -161,7 +161,7 @@ static void locatePlayer(CNSocket *sock, CNPacketData *data) {
|
||||
CNSocket *otherSock = PlayerManager::getSockFromAny(req->eTargetSearchBy, req->iTargetPC_ID, req->iTargetPC_UID,
|
||||
U16toU8(req->szTargetPC_FirstName), U16toU8(req->szTargetPC_LastName));
|
||||
if (otherSock == nullptr) {
|
||||
ChatManager::sendServerMessage(sock, "player not found");
|
||||
Chat::sendServerMessage(sock, "player not found");
|
||||
return;
|
||||
}
|
||||
|
||||
@ -199,14 +199,14 @@ static void kickPlayer(CNSocket *sock, CNPacketData *data) {
|
||||
CNSocket *otherSock = PlayerManager::getSockFromAny(req->eTargetSearchBy, req->iTargetPC_ID, req->iTargetPC_UID,
|
||||
U16toU8(req->szTargetPC_FirstName), U16toU8(req->szTargetPC_LastName));
|
||||
if (otherSock == nullptr) {
|
||||
ChatManager::sendServerMessage(sock, "player not found");
|
||||
Chat::sendServerMessage(sock, "player not found");
|
||||
return;
|
||||
}
|
||||
|
||||
Player *otherPlr = PlayerManager::getPlayer(otherSock);
|
||||
|
||||
if (plr->accountLevel > otherPlr->accountLevel) {
|
||||
ChatManager::sendServerMessage(sock, "player has higher access level");
|
||||
Chat::sendServerMessage(sock, "player has higher access level");
|
||||
return;
|
||||
}
|
||||
|
||||
@ -236,7 +236,7 @@ static void warpToPlayer(CNSocket *sock, CNPacketData *data) {
|
||||
|
||||
Player *otherPlr = PlayerManager::getPlayerFromID(req->iPC_ID);
|
||||
if (otherPlr == nullptr) {
|
||||
ChatManager::sendServerMessage(sock, "player not found");
|
||||
Chat::sendServerMessage(sock, "player not found");
|
||||
return;
|
||||
}
|
||||
|
||||
@ -260,7 +260,7 @@ static void teleportPlayer(CNSocket *sock, CNPacketData *data) {
|
||||
CNSocket *targetSock = PlayerManager::getSockFromAny(req->eTargetPCSearchBy, req->iTargetPC_ID, req->iTargetPC_UID,
|
||||
U16toU8(req->szTargetPC_FirstName), U16toU8(req->szTargetPC_LastName));
|
||||
if (targetSock == nullptr) {
|
||||
ChatManager::sendServerMessage(sock, "player to teleport not found");
|
||||
Chat::sendServerMessage(sock, "player to teleport not found");
|
||||
return;
|
||||
}
|
||||
|
||||
@ -285,7 +285,7 @@ static void teleportPlayer(CNSocket *sock, CNPacketData *data) {
|
||||
goalSock = PlayerManager::getSockFromAny(req->eGoalPCSearchBy, req->iGoalPC_ID, req->iGoalPC_UID,
|
||||
U16toU8(req->szGoalPC_FirstName), U16toU8(req->szGoalPC_LastName));
|
||||
if (goalSock == nullptr) {
|
||||
ChatManager::sendServerMessage(sock, "teleportation target player not found");
|
||||
Chat::sendServerMessage(sock, "teleportation target player not found");
|
||||
return;
|
||||
}
|
||||
goalPlr = PlayerManager::getPlayer(goalSock);
|
||||
@ -318,7 +318,7 @@ static void itemGMGiveHandler(CNSocket* sock, CNPacketData* data) {
|
||||
// sock->sendPacket(new CNPacketData((void*)resp, P_FE2CL_REP_PC_GIVE_ITEM_FAIL, sizeof(sP_FE2CL_REP_PC_GIVE_ITEM_FAIL), sock->getFEKey()));
|
||||
} else if (itemreq->eIL == 1 && itemreq->Item.iType >= 0 && itemreq->Item.iType <= 10) {
|
||||
|
||||
if (ItemManager::ItemData.find(std::pair<int32_t, int32_t>(itemreq->Item.iID, itemreq->Item.iType)) == ItemManager::ItemData.end()) {
|
||||
if (Items::ItemData.find(std::pair<int32_t, int32_t>(itemreq->Item.iID, itemreq->Item.iType)) == Items::ItemData.end()) {
|
||||
// invalid item
|
||||
std::cout << "[WARN] Item id " << itemreq->Item.iID << " with type " << itemreq->Item.iType << " is invalid (give item)" << std::endl;
|
||||
return;
|
||||
|
@ -3,7 +3,7 @@
|
||||
#include "CNStructs.hpp"
|
||||
#include "db/Database.hpp"
|
||||
#include "PlayerManager.hpp"
|
||||
#include "ItemManager.hpp"
|
||||
#include "Items.hpp"
|
||||
#include <regex>
|
||||
#include "bcrypt/BCrypt.hpp"
|
||||
|
||||
@ -364,7 +364,7 @@ bool validateCharacterCreation(sP_CL2LS_REQ_CHAR_CREATE* character) {
|
||||
// once we have a static database perhaps we can check for the exact char creation items,
|
||||
// for now only checking if it's a valid lvl1 item
|
||||
for (int i = 0; i < 3; i++) {
|
||||
if (ItemManager::ItemData.find(items[i]) == ItemManager::ItemData.end() || ItemManager::ItemData[items[i]].level != 1)
|
||||
if (Items::ItemData.find(items[i]) == Items::ItemData.end() || Items::ItemData[items[i]].level != 1)
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
|
@ -1,13 +1,13 @@
|
||||
#include "ChatManager.hpp"
|
||||
#include "Chat.hpp"
|
||||
#include "PlayerManager.hpp"
|
||||
#include "GroupManager.hpp"
|
||||
#include "Groups.hpp"
|
||||
#include "CustomCommands.hpp"
|
||||
|
||||
#include <assert.h>
|
||||
|
||||
std::vector<std::string> ChatManager::dump;
|
||||
std::vector<std::string> Chat::dump;
|
||||
|
||||
using namespace ChatManager;
|
||||
using namespace Chat;
|
||||
|
||||
static void chatHandler(CNSocket* sock, CNPacketData* data) {
|
||||
if (data->size != sizeof(sP_CL2FE_REQ_SEND_FREECHAT_MESSAGE))
|
||||
@ -88,7 +88,7 @@ static void emoteHandler(CNSocket* sock, CNPacketData* data) {
|
||||
PlayerManager::sendToViewable(sock, (void*)&resp, P_FE2CL_REP_PC_AVATAR_EMOTES_CHAT, sizeof(sP_FE2CL_REP_PC_AVATAR_EMOTES_CHAT));
|
||||
}
|
||||
|
||||
void ChatManager::sendServerMessage(CNSocket* sock, std::string msg) {
|
||||
void Chat::sendServerMessage(CNSocket* sock, std::string msg) {
|
||||
INITSTRUCT(sP_FE2CL_PC_MOTD_LOGIN, motd);
|
||||
|
||||
motd.iType = 1;
|
||||
@ -276,7 +276,7 @@ static void groupChatHandler(CNSocket* sock, CNPacketData* data) {
|
||||
resp.iSendPCID = plr->iID;
|
||||
resp.iEmoteCode = chat->iEmoteCode;
|
||||
|
||||
GroupManager::sendToGroup(otherPlr, (void*)&resp, P_FE2CL_REP_SEND_ALL_GROUP_FREECHAT_MESSAGE_SUCC, sizeof(sP_FE2CL_REP_SEND_ALL_GROUP_FREECHAT_MESSAGE_SUCC));
|
||||
Groups::sendToGroup(otherPlr, (void*)&resp, P_FE2CL_REP_SEND_ALL_GROUP_FREECHAT_MESSAGE_SUCC, sizeof(sP_FE2CL_REP_SEND_ALL_GROUP_FREECHAT_MESSAGE_SUCC));
|
||||
}
|
||||
|
||||
static void groupMenuChatHandler(CNSocket* sock, CNPacketData* data) {
|
||||
@ -303,11 +303,11 @@ static void groupMenuChatHandler(CNSocket* sock, CNPacketData* data) {
|
||||
resp.iSendPCID = plr->iID;
|
||||
resp.iEmoteCode = chat->iEmoteCode;
|
||||
|
||||
GroupManager::sendToGroup(otherPlr, (void*)&resp, P_FE2CL_REP_SEND_ALL_GROUP_MENUCHAT_MESSAGE_SUCC, sizeof(sP_FE2CL_REP_SEND_ALL_GROUP_MENUCHAT_MESSAGE_SUCC));
|
||||
Groups::sendToGroup(otherPlr, (void*)&resp, P_FE2CL_REP_SEND_ALL_GROUP_MENUCHAT_MESSAGE_SUCC, sizeof(sP_FE2CL_REP_SEND_ALL_GROUP_MENUCHAT_MESSAGE_SUCC));
|
||||
}
|
||||
|
||||
// we only allow plain ascii, at least for now
|
||||
std::string ChatManager::sanitizeText(std::string text, bool allowNewlines) {
|
||||
std::string Chat::sanitizeText(std::string text, bool allowNewlines) {
|
||||
int i;
|
||||
const int BUFSIZE = 512;
|
||||
char buf[BUFSIZE];
|
||||
@ -330,7 +330,7 @@ std::string ChatManager::sanitizeText(std::string text, bool allowNewlines) {
|
||||
return std::string(buf);
|
||||
}
|
||||
|
||||
void ChatManager::init() {
|
||||
void Chat::init() {
|
||||
REGISTER_SHARD_PACKET(P_CL2FE_REQ_SEND_FREECHAT_MESSAGE, chatHandler);
|
||||
REGISTER_SHARD_PACKET(P_CL2FE_REQ_PC_AVATAR_EMOTES_CHAT, emoteHandler);
|
||||
REGISTER_SHARD_PACKET(P_CL2FE_REQ_SEND_MENUCHAT_MESSAGE, menuChatHandler);
|
@ -4,7 +4,7 @@
|
||||
|
||||
#include "CNShardServer.hpp"
|
||||
|
||||
namespace ChatManager {
|
||||
namespace Chat {
|
||||
extern std::vector<std::string> dump;
|
||||
void init();
|
||||
|
@ -1,12 +1,12 @@
|
||||
#include "ChunkManager.hpp"
|
||||
#include "Chunking.hpp"
|
||||
#include "PlayerManager.hpp"
|
||||
#include "NPCManager.hpp"
|
||||
#include "settings.hpp"
|
||||
#include "Combat.hpp"
|
||||
|
||||
using namespace ChunkManager;
|
||||
using namespace Chunking;
|
||||
|
||||
std::map<ChunkPos, Chunk*> ChunkManager::chunks;
|
||||
std::map<ChunkPos, Chunk*> Chunking::chunks;
|
||||
|
||||
static void newChunk(ChunkPos pos) {
|
||||
if (chunkExists(pos)) {
|
||||
@ -53,21 +53,21 @@ static void deleteChunk(ChunkPos pos) {
|
||||
delete chunk; // free from memory
|
||||
}
|
||||
|
||||
void ChunkManager::trackPlayer(ChunkPos chunkPos, CNSocket* sock) {
|
||||
void Chunking::trackPlayer(ChunkPos chunkPos, CNSocket* sock) {
|
||||
if (!chunkExists(chunkPos))
|
||||
return; // shouldn't happen
|
||||
|
||||
chunks[chunkPos]->players.insert(sock);
|
||||
}
|
||||
|
||||
void ChunkManager::trackNPC(ChunkPos chunkPos, int32_t id) {
|
||||
void Chunking::trackNPC(ChunkPos chunkPos, int32_t id) {
|
||||
if (!chunkExists(chunkPos))
|
||||
return; // shouldn't happen
|
||||
|
||||
chunks[chunkPos]->NPCs.insert(id);
|
||||
}
|
||||
|
||||
void ChunkManager::untrackPlayer(ChunkPos chunkPos, CNSocket* sock) {
|
||||
void Chunking::untrackPlayer(ChunkPos chunkPos, CNSocket* sock) {
|
||||
if (!chunkExists(chunkPos))
|
||||
return; // do nothing if chunk doesn't even exist
|
||||
|
||||
@ -80,7 +80,7 @@ void ChunkManager::untrackPlayer(ChunkPos chunkPos, CNSocket* sock) {
|
||||
deleteChunk(chunkPos);
|
||||
}
|
||||
|
||||
void ChunkManager::untrackNPC(ChunkPos chunkPos, int32_t id) {
|
||||
void Chunking::untrackNPC(ChunkPos chunkPos, int32_t id) {
|
||||
if (!chunkExists(chunkPos))
|
||||
return; // do nothing if chunk doesn't even exist
|
||||
|
||||
@ -93,7 +93,7 @@ void ChunkManager::untrackNPC(ChunkPos chunkPos, int32_t id) {
|
||||
deleteChunk(chunkPos);
|
||||
}
|
||||
|
||||
void ChunkManager::addPlayerToChunks(std::set<Chunk*> chnks, CNSocket* sock) {
|
||||
void Chunking::addPlayerToChunks(std::set<Chunk*> chnks, CNSocket* sock) {
|
||||
INITSTRUCT(sP_FE2CL_PC_NEW, newPlayer);
|
||||
|
||||
for (Chunk* chunk : chnks) {
|
||||
@ -165,7 +165,7 @@ void ChunkManager::addPlayerToChunks(std::set<Chunk*> chnks, CNSocket* sock) {
|
||||
}
|
||||
}
|
||||
|
||||
void ChunkManager::addNPCToChunks(std::set<Chunk*> chnks, int32_t id) {
|
||||
void Chunking::addNPCToChunks(std::set<Chunk*> chnks, int32_t id) {
|
||||
BaseNPC* npc = NPCManager::NPCs[id];
|
||||
|
||||
switch (npc->npcClass) {
|
||||
@ -209,7 +209,7 @@ void ChunkManager::addNPCToChunks(std::set<Chunk*> chnks, int32_t id) {
|
||||
}
|
||||
}
|
||||
|
||||
void ChunkManager::removePlayerFromChunks(std::set<Chunk*> chnks, CNSocket* sock) {
|
||||
void Chunking::removePlayerFromChunks(std::set<Chunk*> chnks, CNSocket* sock) {
|
||||
INITSTRUCT(sP_FE2CL_PC_EXIT, exitPlayer);
|
||||
|
||||
// for chunks that need the player to be removed from
|
||||
@ -253,7 +253,7 @@ void ChunkManager::removePlayerFromChunks(std::set<Chunk*> chnks, CNSocket* sock
|
||||
|
||||
}
|
||||
|
||||
void ChunkManager::removeNPCFromChunks(std::set<Chunk*> chnks, int32_t id) {
|
||||
void Chunking::removeNPCFromChunks(std::set<Chunk*> chnks, int32_t id) {
|
||||
BaseNPC* npc = NPCManager::NPCs[id];
|
||||
|
||||
switch (npc->npcClass) {
|
||||
@ -320,7 +320,7 @@ static void emptyChunk(ChunkPos chunkPos) {
|
||||
}
|
||||
}
|
||||
|
||||
void ChunkManager::updatePlayerChunk(CNSocket* sock, ChunkPos from, ChunkPos to) {
|
||||
void Chunking::updatePlayerChunk(CNSocket* sock, ChunkPos from, ChunkPos to) {
|
||||
Player* plr = PlayerManager::getPlayer(sock);
|
||||
|
||||
// if the new chunk doesn't exist, make it first
|
||||
@ -356,7 +356,7 @@ void ChunkManager::updatePlayerChunk(CNSocket* sock, ChunkPos from, ChunkPos to)
|
||||
plr->viewableChunks->insert(newViewables.begin(), newViewables.end());
|
||||
}
|
||||
|
||||
void ChunkManager::updateNPCChunk(int32_t id, ChunkPos from, ChunkPos to) {
|
||||
void Chunking::updateNPCChunk(int32_t id, ChunkPos from, ChunkPos to) {
|
||||
BaseNPC* npc = NPCManager::NPCs[id];
|
||||
|
||||
// if the new chunk doesn't exist, make it first
|
||||
@ -392,15 +392,15 @@ void ChunkManager::updateNPCChunk(int32_t id, ChunkPos from, ChunkPos to) {
|
||||
npc->viewableChunks->insert(newViewables.begin(), newViewables.end());
|
||||
}
|
||||
|
||||
bool ChunkManager::chunkExists(ChunkPos chunk) {
|
||||
bool Chunking::chunkExists(ChunkPos chunk) {
|
||||
return chunks.find(chunk) != chunks.end();
|
||||
}
|
||||
|
||||
ChunkPos ChunkManager::chunkPosAt(int posX, int posY, uint64_t instanceID) {
|
||||
ChunkPos Chunking::chunkPosAt(int posX, int posY, uint64_t instanceID) {
|
||||
return std::make_tuple(posX / (settings::VIEWDISTANCE / 3), posY / (settings::VIEWDISTANCE / 3), instanceID);
|
||||
}
|
||||
|
||||
std::set<Chunk*> ChunkManager::getViewableChunks(ChunkPos chunk) {
|
||||
std::set<Chunk*> Chunking::getViewableChunks(ChunkPos chunk) {
|
||||
std::set<Chunk*> chnks;
|
||||
|
||||
int x, y;
|
||||
@ -439,7 +439,7 @@ static std::vector<ChunkPos> getChunksInMap(uint64_t mapNum) {
|
||||
/*
|
||||
* Used only for eggs; use npc->playersInView for everything visible
|
||||
*/
|
||||
bool ChunkManager::inPopulatedChunks(std::set<Chunk*>* chnks) {
|
||||
bool Chunking::inPopulatedChunks(std::set<Chunk*>* chnks) {
|
||||
|
||||
for (auto it = chnks->begin(); it != chnks->end(); it++) {
|
||||
if (!(*it)->players.empty())
|
||||
@ -449,7 +449,7 @@ bool ChunkManager::inPopulatedChunks(std::set<Chunk*>* chnks) {
|
||||
return false;
|
||||
}
|
||||
|
||||
void ChunkManager::createInstance(uint64_t instanceID) {
|
||||
void Chunking::createInstance(uint64_t instanceID) {
|
||||
|
||||
std::vector<ChunkPos> templateChunks = getChunksInMap(MAPNUM(instanceID)); // base instance chunks
|
||||
if (getChunksInMap(instanceID).size() == 0) { // only instantiate if the instance doesn't exist already
|
||||
@ -517,7 +517,7 @@ static void destroyInstance(uint64_t instanceID) {
|
||||
}
|
||||
}
|
||||
|
||||
void ChunkManager::destroyInstanceIfEmpty(uint64_t instanceID) {
|
||||
void Chunking::destroyInstanceIfEmpty(uint64_t instanceID) {
|
||||
if (PLAYERID(instanceID) == 0)
|
||||
return; // don't clean up overworld/IZ chunks
|
||||
|
@ -21,7 +21,7 @@ enum {
|
||||
INSTANCE_UNIQUE // these aren't actually used
|
||||
};
|
||||
|
||||
namespace ChunkManager {
|
||||
namespace Chunking {
|
||||
extern std::map<ChunkPos, Chunk*> chunks;
|
||||
|
||||
void updatePlayerChunk(CNSocket* sock, ChunkPos from, ChunkPos to);
|
@ -1,12 +1,12 @@
|
||||
#include "Combat.hpp"
|
||||
#include "PlayerManager.hpp"
|
||||
#include "NanoManager.hpp"
|
||||
#include "Nanos.hpp"
|
||||
#include "NPCManager.hpp"
|
||||
#include "ItemManager.hpp"
|
||||
#include "MissionManager.hpp"
|
||||
#include "GroupManager.hpp"
|
||||
#include "TransportManager.hpp"
|
||||
#include "RacingManager.hpp"
|
||||
#include "Items.hpp"
|
||||
#include "Missions.hpp"
|
||||
#include "Groups.hpp"
|
||||
#include "Transport.hpp"
|
||||
#include "Racing.hpp"
|
||||
#include "Abilities.hpp"
|
||||
|
||||
#include <assert.h>
|
||||
@ -119,7 +119,7 @@ static void pcAttackNpcs(CNSocket *sock, CNPacketData *data) {
|
||||
damage.first = plr->pointDamage;
|
||||
|
||||
int difficulty = (int)mob->data["m_iNpcLevel"];
|
||||
damage = getDamage(damage.first, (int)mob->data["m_iProtection"], true, (plr->batteryW > 6 + difficulty), NanoManager::nanoStyle(plr->activeNano), (int)mob->data["m_iNpcStyle"], difficulty);
|
||||
damage = getDamage(damage.first, (int)mob->data["m_iProtection"], true, (plr->batteryW > 6 + difficulty), Nanos::nanoStyle(plr->activeNano), (int)mob->data["m_iNpcStyle"], difficulty);
|
||||
|
||||
if (plr->batteryW >= 6 + difficulty)
|
||||
plr->batteryW -= 6 + difficulty;
|
||||
@ -241,8 +241,8 @@ void Combat::killMob(CNSocket *sock, Mob *mob) {
|
||||
int rolledQItem = rand();
|
||||
|
||||
if (plr->groupCnt == 1 && plr->iIDGroup == plr->iID) {
|
||||
ItemManager::giveMobDrop(sock, mob, rolledBoosts, rolledPotions, rolledCrate, rolledCrateType, rolledEvent);
|
||||
MissionManager::mobKilled(sock, mob->appearanceData.iNPCType, rolledQItem);
|
||||
Items::giveMobDrop(sock, mob, rolledBoosts, rolledPotions, rolledCrate, rolledCrateType, rolledEvent);
|
||||
Missions::mobKilled(sock, mob->appearanceData.iNPCType, rolledQItem);
|
||||
} else {
|
||||
Player* otherPlayer = PlayerManager::getPlayerFromID(plr->iIDGroup);
|
||||
|
||||
@ -261,8 +261,8 @@ void Combat::killMob(CNSocket *sock, Mob *mob) {
|
||||
if (dist > 5000)
|
||||
continue;
|
||||
|
||||
ItemManager::giveMobDrop(sockTo, mob, rolledBoosts, rolledPotions, rolledCrate, rolledCrateType, rolledEvent);
|
||||
MissionManager::mobKilled(sockTo, mob->appearanceData.iNPCType, rolledQItem);
|
||||
Items::giveMobDrop(sockTo, mob, rolledBoosts, rolledPotions, rolledCrate, rolledCrateType, rolledEvent);
|
||||
Missions::mobKilled(sockTo, mob->appearanceData.iNPCType, rolledQItem);
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -275,8 +275,8 @@ void Combat::killMob(CNSocket *sock, Mob *mob) {
|
||||
if (event.trigger == ON_KILLED && event.npcType == mob->appearanceData.iNPCType)
|
||||
event.handler(sock, mob);
|
||||
|
||||
auto it = TransportManager::NPCQueues.find(mob->appearanceData.iNPC_ID);
|
||||
if (it == TransportManager::NPCQueues.end() || it->second.empty())
|
||||
auto it = Transport::NPCQueues.find(mob->appearanceData.iNPC_ID);
|
||||
if (it == Transport::NPCQueues.end() || it->second.empty())
|
||||
return;
|
||||
|
||||
// rewind or empty the movement queue
|
||||
@ -293,7 +293,7 @@ void Combat::killMob(CNSocket *sock, Mob *mob) {
|
||||
queue.push(point);
|
||||
}
|
||||
} else {
|
||||
TransportManager::NPCQueues.erase(mob->appearanceData.iNPC_ID);
|
||||
Transport::NPCQueues.erase(mob->appearanceData.iNPC_ID);
|
||||
}
|
||||
}
|
||||
|
||||
@ -366,7 +366,7 @@ static void dealGooDamage(CNSocket *sock, int amount) {
|
||||
if (plr->Nanos[plr->activeNano].iStamina <= 0) {
|
||||
dmg->bNanoDeactive = 1;
|
||||
plr->Nanos[plr->activeNano].iStamina = 0;
|
||||
NanoManager::summonNano(PlayerManager::getSockFromID(plr->iID), -1, true);
|
||||
Nanos::summonNano(PlayerManager::getSockFromID(plr->iID), -1, true);
|
||||
}
|
||||
}
|
||||
|
||||
@ -472,7 +472,7 @@ static void pcAttackChars(CNSocket *sock, CNPacketData *data) {
|
||||
int difficulty = (int)mob->data["m_iNpcLevel"];
|
||||
|
||||
damage = getDamage(damage.first, (int)mob->data["m_iProtection"], true, (plr->batteryW > 6 + difficulty),
|
||||
NanoManager::nanoStyle(plr->activeNano), (int)mob->data["m_iNpcStyle"], difficulty);
|
||||
Nanos::nanoStyle(plr->activeNano), (int)mob->data["m_iNpcStyle"], difficulty);
|
||||
|
||||
if (plr->batteryW >= 6 + difficulty)
|
||||
plr->batteryW -= 6 + difficulty;
|
||||
@ -667,7 +667,7 @@ static void projectileHit(CNSocket* sock, CNPacketData* data) {
|
||||
damage.first = pkt->iTargetCnt > 1 ? bullet->groupDamage : bullet->pointDamage;
|
||||
|
||||
int difficulty = (int)mob->data["m_iNpcLevel"];
|
||||
damage = getDamage(damage.first, (int)mob->data["m_iProtection"], true, bullet->weaponBoost, NanoManager::nanoStyle(plr->activeNano), (int)mob->data["m_iNpcStyle"], difficulty);
|
||||
damage = getDamage(damage.first, (int)mob->data["m_iProtection"], true, bullet->weaponBoost, Nanos::nanoStyle(plr->activeNano), (int)mob->data["m_iNpcStyle"], difficulty);
|
||||
|
||||
damage.first = hitMob(sock, mob, damage.first);
|
||||
|
||||
@ -696,7 +696,7 @@ static void playerTick(CNServer *serv, time_t currTime) {
|
||||
|
||||
// group ticks
|
||||
if (plr->groupCnt > 1)
|
||||
GroupManager::groupTickInfo(plr);
|
||||
Groups::groupTickInfo(plr);
|
||||
|
||||
// do not tick dead players
|
||||
if (plr->HP <= 0)
|
||||
@ -723,7 +723,7 @@ static void playerTick(CNServer *serv, time_t currTime) {
|
||||
plr->Nanos[plr->activeNano].iStamina -= 1 + plr->nanoDrainRate / 5;
|
||||
|
||||
if (plr->Nanos[plr->activeNano].iStamina <= 0)
|
||||
NanoManager::summonNano(sock, -1, true); // unsummon nano silently
|
||||
Nanos::summonNano(sock, -1, true); // unsummon nano silently
|
||||
|
||||
transmit = true;
|
||||
} else if (plr->Nanos[plr->equippedNanos[i]].iStamina < 150) { // regain stamina
|
||||
|
@ -1,13 +1,13 @@
|
||||
#include "CustomCommands.hpp"
|
||||
#include "ChatManager.hpp"
|
||||
#include "Chat.hpp"
|
||||
#include "PlayerManager.hpp"
|
||||
#include "TableData.hpp"
|
||||
#include "NPCManager.hpp"
|
||||
#include "MobAI.hpp"
|
||||
#include "ItemManager.hpp"
|
||||
#include "Items.hpp"
|
||||
#include "db/Database.hpp"
|
||||
#include "TransportManager.hpp"
|
||||
#include "MissionManager.hpp"
|
||||
#include "Transport.hpp"
|
||||
#include "Missions.hpp"
|
||||
|
||||
#include <sstream>
|
||||
#include <iterator>
|
||||
@ -48,36 +48,36 @@ bool CustomCommands::runCmd(std::string full, CNSocket* sock) {
|
||||
command.handlr(full, args, sock);
|
||||
return true;
|
||||
} else {
|
||||
ChatManager::sendServerMessage(sock, "You don't have access to that command!");
|
||||
Chat::sendServerMessage(sock, "You don't have access to that command!");
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
ChatManager::sendServerMessage(sock, "Unknown command!");
|
||||
Chat::sendServerMessage(sock, "Unknown command!");
|
||||
return false;
|
||||
}
|
||||
|
||||
static void helpCommand(std::string full, std::vector<std::string>& args, CNSocket* sock) {
|
||||
ChatManager::sendServerMessage(sock, "Commands available to you:");
|
||||
Chat::sendServerMessage(sock, "Commands available to you:");
|
||||
Player *plr = PlayerManager::getPlayer(sock);
|
||||
|
||||
for (auto& cmd : commands) {
|
||||
if (cmd.second.requiredAccLevel >= plr->accountLevel)
|
||||
ChatManager::sendServerMessage(sock, "/" + cmd.first + (cmd.second.help.length() > 0 ? " - " + cmd.second.help : ""));
|
||||
Chat::sendServerMessage(sock, "/" + cmd.first + (cmd.second.help.length() > 0 ? " - " + cmd.second.help : ""));
|
||||
}
|
||||
}
|
||||
|
||||
static void accessCommand(std::string full, std::vector<std::string>& args, CNSocket* sock) {
|
||||
ChatManager::sendServerMessage(sock, "Your access level is " + std::to_string(PlayerManager::getPlayer(sock)->accountLevel));
|
||||
Chat::sendServerMessage(sock, "Your access level is " + std::to_string(PlayerManager::getPlayer(sock)->accountLevel));
|
||||
}
|
||||
|
||||
static void populationCommand(std::string full, std::vector<std::string>& args, CNSocket* sock) {
|
||||
ChatManager::sendServerMessage(sock, std::to_string(PlayerManager::players.size()) + " players online");
|
||||
Chat::sendServerMessage(sock, std::to_string(PlayerManager::players.size()) + " players online");
|
||||
}
|
||||
|
||||
static void levelCommand(std::string full, std::vector<std::string>& args, CNSocket* sock) {
|
||||
if (args.size() < 2) {
|
||||
ChatManager::sendServerMessage(sock, "/level: no level specified");
|
||||
Chat::sendServerMessage(sock, "/level: no level specified");
|
||||
return;
|
||||
}
|
||||
|
||||
@ -105,8 +105,8 @@ static void levelCommand(std::string full, std::vector<std::string>& args, CNSoc
|
||||
|
||||
static void mssCommand(std::string full, std::vector<std::string>& args, CNSocket* sock) {
|
||||
if (args.size() < 2) {
|
||||
ChatManager::sendServerMessage(sock, "[MSS] Too few arguments");
|
||||
ChatManager::sendServerMessage(sock, "[MSS] Usage: /mss <route> <add/remove/goto/clear/test/export> <<height>>");
|
||||
Chat::sendServerMessage(sock, "[MSS] Too few arguments");
|
||||
Chat::sendServerMessage(sock, "[MSS] Usage: /mss <route> <add/remove/goto/clear/test/export> <<height>>");
|
||||
return;
|
||||
}
|
||||
|
||||
@ -115,13 +115,13 @@ static void mssCommand(std::string full, std::vector<std::string>& args, CNSocke
|
||||
int routeNum = std::strtol(args[1].c_str(), &routeNumC, 10);
|
||||
if (*routeNumC) {
|
||||
// not an integer
|
||||
ChatManager::sendServerMessage(sock, "[MSS] Invalid route number '" + args[1] + "'");
|
||||
Chat::sendServerMessage(sock, "[MSS] Invalid route number '" + args[1] + "'");
|
||||
return;
|
||||
}
|
||||
|
||||
if (args.size() < 3) {
|
||||
ChatManager::sendServerMessage(sock, "[MSS] Too few arguments");
|
||||
ChatManager::sendServerMessage(sock, "[MSS] Usage: /mss <route> <add/remove/goto/clear/test> <<height>>");
|
||||
Chat::sendServerMessage(sock, "[MSS] Too few arguments");
|
||||
Chat::sendServerMessage(sock, "[MSS] Usage: /mss <route> <add/remove/goto/clear/test> <<height>>");
|
||||
return;
|
||||
}
|
||||
|
||||
@ -132,41 +132,41 @@ static void mssCommand(std::string full, std::vector<std::string>& args, CNSocke
|
||||
if (args[2] == "add") {
|
||||
// make sure height token exists
|
||||
if (args.size() < 4) {
|
||||
ChatManager::sendServerMessage(sock, "[MSS] Point height must be specified");
|
||||
ChatManager::sendServerMessage(sock, "[MSS] Usage: /mss <route> add <height>");
|
||||
Chat::sendServerMessage(sock, "[MSS] Point height must be specified");
|
||||
Chat::sendServerMessage(sock, "[MSS] Usage: /mss <route> add <height>");
|
||||
return;
|
||||
}
|
||||
// validate height token
|
||||
char* heightC;
|
||||
int height = std::strtol(args[3].c_str(), &heightC, 10);
|
||||
if (*heightC) {
|
||||
ChatManager::sendServerMessage(sock, "[MSS] Invalid height " + args[3]);
|
||||
Chat::sendServerMessage(sock, "[MSS] Invalid height " + args[3]);
|
||||
return;
|
||||
}
|
||||
|
||||
Player* plr = PlayerManager::getPlayer(sock);
|
||||
route->push_back({ plr->x, plr->y, height }); // add point
|
||||
ChatManager::sendServerMessage(sock, "[MSS] Added point (" + std::to_string(plr->x) + ", " + std::to_string(plr->y) + ", " + std::to_string(height) + ") to route " + std::to_string(routeNum));
|
||||
Chat::sendServerMessage(sock, "[MSS] Added point (" + std::to_string(plr->x) + ", " + std::to_string(plr->y) + ", " + std::to_string(height) + ") to route " + std::to_string(routeNum));
|
||||
return;
|
||||
}
|
||||
|
||||
// mss <route> remove
|
||||
if (args[2] == "remove") {
|
||||
if (route->empty()) {
|
||||
ChatManager::sendServerMessage(sock, "[MSS] Route " + std::to_string(routeNum) + " is empty");
|
||||
Chat::sendServerMessage(sock, "[MSS] Route " + std::to_string(routeNum) + " is empty");
|
||||
return;
|
||||
}
|
||||
|
||||
WarpLocation pulled = route->back();
|
||||
route->pop_back(); // remove point at top of stack
|
||||
ChatManager::sendServerMessage(sock, "[MSS] Removed point (" + std::to_string(pulled.x) + ", " + std::to_string(pulled.y) + ", " + std::to_string(pulled.z) + ") from route " + std::to_string(routeNum));
|
||||
Chat::sendServerMessage(sock, "[MSS] Removed point (" + std::to_string(pulled.x) + ", " + std::to_string(pulled.y) + ", " + std::to_string(pulled.z) + ") from route " + std::to_string(routeNum));
|
||||
return;
|
||||
}
|
||||
|
||||
// mss <route> goto
|
||||
if (args[2] == "goto") {
|
||||
if (route->empty()) {
|
||||
ChatManager::sendServerMessage(sock, "[MSS] Route " + std::to_string(routeNum) + " is empty");
|
||||
Chat::sendServerMessage(sock, "[MSS] Route " + std::to_string(routeNum) + " is empty");
|
||||
return;
|
||||
}
|
||||
|
||||
@ -178,37 +178,37 @@ static void mssCommand(std::string full, std::vector<std::string>& args, CNSocke
|
||||
// mss <route> clear
|
||||
if (args[2] == "clear") {
|
||||
route->clear();
|
||||
ChatManager::sendServerMessage(sock, "[MSS] Cleared route " + std::to_string(routeNum));
|
||||
Chat::sendServerMessage(sock, "[MSS] Cleared route " + std::to_string(routeNum));
|
||||
return;
|
||||
}
|
||||
|
||||
// mss <route> test
|
||||
if (args[2] == "test") {
|
||||
if (route->empty()) {
|
||||
ChatManager::sendServerMessage(sock, "[MSS] Route " + std::to_string(routeNum) + " is empty");
|
||||
Chat::sendServerMessage(sock, "[MSS] Route " + std::to_string(routeNum) + " is empty");
|
||||
return;
|
||||
}
|
||||
|
||||
WarpLocation pulled = route->front();
|
||||
PlayerManager::sendPlayerTo(sock, pulled.x, pulled.y, pulled.z);
|
||||
TransportManager::testMssRoute(sock, route);
|
||||
Transport::testMssRoute(sock, route);
|
||||
return;
|
||||
}
|
||||
|
||||
// for compatibility: mss <route> export
|
||||
if (args[2] == "export") {
|
||||
ChatManager::sendServerMessage(sock, "Wrote gruntwork to " + settings::GRUNTWORKJSON);
|
||||
Chat::sendServerMessage(sock, "Wrote gruntwork to " + settings::GRUNTWORKJSON);
|
||||
TableData::flush();
|
||||
return;
|
||||
}
|
||||
|
||||
// mss ????
|
||||
ChatManager::sendServerMessage(sock, "[MSS] Unknown command '" + args[2] + "'");
|
||||
Chat::sendServerMessage(sock, "[MSS] Unknown command '" + args[2] + "'");
|
||||
}
|
||||
|
||||
static void summonWCommand(std::string full, std::vector<std::string>& args, CNSocket* sock) {
|
||||
if (args.size() < 2) {
|
||||
ChatManager::sendServerMessage(sock, "/summonW: no mob type specified");
|
||||
Chat::sendServerMessage(sock, "/summonW: no mob type specified");
|
||||
return;
|
||||
}
|
||||
Player* plr = PlayerManager::getPlayer(sock);
|
||||
@ -216,7 +216,7 @@ static void summonWCommand(std::string full, std::vector<std::string>& args, CNS
|
||||
char *rest;
|
||||
int type = std::strtol(args[1].c_str(), &rest, 10);
|
||||
if (*rest) {
|
||||
ChatManager::sendServerMessage(sock, "Invalid NPC number: " + args[1]);
|
||||
Chat::sendServerMessage(sock, "Invalid NPC number: " + args[1]);
|
||||
return;
|
||||
}
|
||||
|
||||
@ -240,7 +240,7 @@ static void summonWCommand(std::string full, std::vector<std::string>& args, CNS
|
||||
NPCManager::updateNPCPosition(npc->appearanceData.iNPC_ID, plr->x, plr->y, plr->z, npc->instanceID, npc->appearanceData.iAngle);
|
||||
}
|
||||
|
||||
ChatManager::sendServerMessage(sock, "/summonW: placed mob with type: " + std::to_string(type) +
|
||||
Chat::sendServerMessage(sock, "/summonW: placed mob with type: " + std::to_string(type) +
|
||||
", id: " + std::to_string(npc->appearanceData.iNPC_ID));
|
||||
TableData::RunningMobs[npc->appearanceData.iNPC_ID] = npc; // only record the one in the template
|
||||
}
|
||||
@ -251,12 +251,12 @@ static void unsummonWCommand(std::string full, std::vector<std::string>& args, C
|
||||
BaseNPC* npc = NPCManager::getNearestNPC(plr->viewableChunks, plr->x, plr->y, plr->z);
|
||||
|
||||
if (npc == nullptr) {
|
||||
ChatManager::sendServerMessage(sock, "/unsummonW: No NPCs found nearby");
|
||||
Chat::sendServerMessage(sock, "/unsummonW: No NPCs found nearby");
|
||||
return;
|
||||
}
|
||||
|
||||
if (TableData::RunningEggs.find(npc->appearanceData.iNPC_ID) != TableData::RunningEggs.end()) {
|
||||
ChatManager::sendServerMessage(sock, "/unsummonW: removed egg with type: " + std::to_string(npc->appearanceData.iNPCType) +
|
||||
Chat::sendServerMessage(sock, "/unsummonW: removed egg with type: " + std::to_string(npc->appearanceData.iNPCType) +
|
||||
", id: " + std::to_string(npc->appearanceData.iNPC_ID));
|
||||
TableData::RunningEggs.erase(npc->appearanceData.iNPC_ID);
|
||||
NPCManager::destroyNPC(npc->appearanceData.iNPC_ID);
|
||||
@ -265,7 +265,7 @@ static void unsummonWCommand(std::string full, std::vector<std::string>& args, C
|
||||
|
||||
if (TableData::RunningMobs.find(npc->appearanceData.iNPC_ID) == TableData::RunningMobs.end()
|
||||
&& TableData::RunningGroups.find(npc->appearanceData.iNPC_ID) == TableData::RunningGroups.end()) {
|
||||
ChatManager::sendServerMessage(sock, "/unsummonW: Closest NPC is not a gruntwork mob.");
|
||||
Chat::sendServerMessage(sock, "/unsummonW: Closest NPC is not a gruntwork mob.");
|
||||
return;
|
||||
}
|
||||
|
||||
@ -289,12 +289,12 @@ static void unsummonWCommand(std::string full, std::vector<std::string>& args, C
|
||||
}
|
||||
TableData::RunningGroups.erase(leadId);
|
||||
NPCManager::destroyNPC(leadId);
|
||||
ChatManager::sendServerMessage(sock, "/unsummonW: Mob group destroyed.");
|
||||
Chat::sendServerMessage(sock, "/unsummonW: Mob group destroyed.");
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
ChatManager::sendServerMessage(sock, "/unsummonW: removed mob with type: " + std::to_string(npc->appearanceData.iNPCType) +
|
||||
Chat::sendServerMessage(sock, "/unsummonW: removed mob with type: " + std::to_string(npc->appearanceData.iNPCType) +
|
||||
", id: " + std::to_string(npc->appearanceData.iNPC_ID));
|
||||
|
||||
TableData::RunningMobs.erase(npc->appearanceData.iNPC_ID);
|
||||
@ -333,7 +333,7 @@ static void npcRotateCommand(std::string full, std::vector<std::string>& args, C
|
||||
BaseNPC* npc = NPCManager::getNearestNPC(plr->viewableChunks, plr->x, plr->y, plr->z);
|
||||
|
||||
if (npc == nullptr) {
|
||||
ChatManager::sendServerMessage(sock, "[NPCR] No NPCs found nearby");
|
||||
Chat::sendServerMessage(sock, "[NPCR] No NPCs found nearby");
|
||||
return;
|
||||
}
|
||||
|
||||
@ -344,12 +344,12 @@ static void npcRotateCommand(std::string full, std::vector<std::string>& args, C
|
||||
if (TableData::RunningMobs.find(npc->appearanceData.iNPC_ID) != TableData::RunningMobs.end()) {
|
||||
NPCManager::updateNPCPosition(npc->appearanceData.iNPC_ID, npc->appearanceData.iX, npc->appearanceData.iY, npc->appearanceData.iZ, npc->instanceID, angle);
|
||||
|
||||
ChatManager::sendServerMessage(sock, "[NPCR] Successfully set angle to " + std::to_string(angle) + " for gruntwork NPC "
|
||||
Chat::sendServerMessage(sock, "[NPCR] Successfully set angle to " + std::to_string(angle) + " for gruntwork NPC "
|
||||
+ std::to_string(npc->appearanceData.iNPC_ID));
|
||||
} else {
|
||||
TableData::RunningNPCRotations[npc->appearanceData.iNPC_ID] = angle;
|
||||
|
||||
ChatManager::sendServerMessage(sock, "[NPCR] Successfully set angle to " + std::to_string(angle) + " for NPC "
|
||||
Chat::sendServerMessage(sock, "[NPCR] Successfully set angle to " + std::to_string(angle) + " for NPC "
|
||||
+ std::to_string(npc->appearanceData.iNPC_ID));
|
||||
}
|
||||
|
||||
@ -363,8 +363,8 @@ static void refreshCommand(std::string full, std::vector<std::string>& args, CNS
|
||||
Player* plr = PlayerManager::getPlayer(sock);
|
||||
ChunkPos currentChunk = plr->chunkPos;
|
||||
ChunkPos nullChunk = std::make_tuple(0, 0, 0);
|
||||
ChunkManager::updatePlayerChunk(sock, currentChunk, nullChunk);
|
||||
ChunkManager::updatePlayerChunk(sock, nullChunk, currentChunk);
|
||||
Chunking::updatePlayerChunk(sock, currentChunk, nullChunk);
|
||||
Chunking::updatePlayerChunk(sock, nullChunk, currentChunk);
|
||||
}
|
||||
|
||||
static void instanceCommand(std::string full, std::vector<std::string>& args, CNSocket* sock) {
|
||||
@ -372,8 +372,8 @@ static void instanceCommand(std::string full, std::vector<std::string>& args, CN
|
||||
|
||||
// no additional arguments: report current instance ID
|
||||
if (args.size() < 2) {
|
||||
ChatManager::sendServerMessage(sock, "[INST] Current instance ID: " + std::to_string(plr->instanceID));
|
||||
ChatManager::sendServerMessage(sock, "[INST] (Map " + std::to_string(MAPNUM(plr->instanceID)) + ", instance " + std::to_string(PLAYERID(plr->instanceID)) + ")");
|
||||
Chat::sendServerMessage(sock, "[INST] Current instance ID: " + std::to_string(plr->instanceID));
|
||||
Chat::sendServerMessage(sock, "[INST] (Map " + std::to_string(MAPNUM(plr->instanceID)) + ", instance " + std::to_string(PLAYERID(plr->instanceID)) + ")");
|
||||
return;
|
||||
}
|
||||
|
||||
@ -382,7 +382,7 @@ static void instanceCommand(std::string full, std::vector<std::string>& args, CN
|
||||
char* instanceS;
|
||||
uint64_t instance = std::strtoll(args[1].c_str(), &instanceS, 10);
|
||||
if (*instanceS) {
|
||||
ChatManager::sendServerMessage(sock, "[INST] Invalid instance ID: " + args[1]);
|
||||
Chat::sendServerMessage(sock, "[INST] Invalid instance ID: " + args[1]);
|
||||
return;
|
||||
}
|
||||
|
||||
@ -392,7 +392,7 @@ static void instanceCommand(std::string full, std::vector<std::string>& args, CN
|
||||
|
||||
if (playerid != 0) {
|
||||
instance |= playerid << 32ULL;
|
||||
ChunkManager::createInstance(instance);
|
||||
Chunking::createInstance(instance);
|
||||
|
||||
// a precaution
|
||||
plr->recallInstance = 0;
|
||||
@ -400,22 +400,22 @@ static void instanceCommand(std::string full, std::vector<std::string>& args, CN
|
||||
}
|
||||
|
||||
PlayerManager::sendPlayerTo(sock, plr->x, plr->y, plr->z, instance);
|
||||
ChatManager::sendServerMessage(sock, "[INST] Switched to instance with ID " + std::to_string(instance));
|
||||
Chat::sendServerMessage(sock, "[INST] Switched to instance with ID " + std::to_string(instance));
|
||||
}
|
||||
|
||||
static void npcInstanceCommand(std::string full, std::vector<std::string>& args, CNSocket* sock) {
|
||||
Player* plr = PlayerManager::getPlayer(sock);
|
||||
|
||||
if (args.size() < 2) {
|
||||
ChatManager::sendServerMessage(sock, "[NPCI] Instance ID must be specified");
|
||||
ChatManager::sendServerMessage(sock, "[NPCI] Usage: /npci <instance ID>");
|
||||
Chat::sendServerMessage(sock, "[NPCI] Instance ID must be specified");
|
||||
Chat::sendServerMessage(sock, "[NPCI] Usage: /npci <instance ID>");
|
||||
return;
|
||||
}
|
||||
|
||||
BaseNPC* npc = NPCManager::getNearestNPC(plr->viewableChunks, plr->x, plr->y, plr->z);
|
||||
|
||||
if (npc == nullptr) {
|
||||
ChatManager::sendServerMessage(sock, "[NPCI] No NPCs found nearby");
|
||||
Chat::sendServerMessage(sock, "[NPCI] No NPCs found nearby");
|
||||
return;
|
||||
}
|
||||
|
||||
@ -423,34 +423,34 @@ static void npcInstanceCommand(std::string full, std::vector<std::string>& args,
|
||||
char* instanceS;
|
||||
int instance = std::strtol(args[1].c_str(), &instanceS, 10);
|
||||
if (*instanceS) {
|
||||
ChatManager::sendServerMessage(sock, "[NPCI] Invalid instance ID: " + args[1]);
|
||||
Chat::sendServerMessage(sock, "[NPCI] Invalid instance ID: " + args[1]);
|
||||
return;
|
||||
}
|
||||
|
||||
ChatManager::sendServerMessage(sock, "[NPCI] Moving NPC with ID " + std::to_string(npc->appearanceData.iNPC_ID) + " to instance " + std::to_string(instance));
|
||||
Chat::sendServerMessage(sock, "[NPCI] Moving NPC with ID " + std::to_string(npc->appearanceData.iNPC_ID) + " to instance " + std::to_string(instance));
|
||||
TableData::RunningNPCMapNumbers[npc->appearanceData.iNPC_ID] = instance;
|
||||
NPCManager::updateNPCPosition(npc->appearanceData.iNPC_ID, npc->appearanceData.iX, npc->appearanceData.iY, npc->appearanceData.iZ, instance, npc->appearanceData.iAngle);
|
||||
}
|
||||
|
||||
static void minfoCommand(std::string full, std::vector<std::string>& args, CNSocket* sock) {
|
||||
Player* plr = PlayerManager::getPlayer(sock);
|
||||
ChatManager::sendServerMessage(sock, "[MINFO] Current mission ID: " + std::to_string(plr->CurrentMissionID));
|
||||
Chat::sendServerMessage(sock, "[MINFO] Current mission ID: " + std::to_string(plr->CurrentMissionID));
|
||||
|
||||
for (int i = 0; i < ACTIVE_MISSION_COUNT; i++) {
|
||||
if (plr->tasks[i] != 0) {
|
||||
TaskData& task = *MissionManager::Tasks[plr->tasks[i]];
|
||||
TaskData& task = *Missions::Tasks[plr->tasks[i]];
|
||||
if ((int)(task["m_iHMissionID"]) == plr->CurrentMissionID) {
|
||||
ChatManager::sendServerMessage(sock, "[MINFO] Current task ID: " + std::to_string(plr->tasks[i]));
|
||||
ChatManager::sendServerMessage(sock, "[MINFO] Current task type: " + std::to_string((int)(task["m_iHTaskType"])));
|
||||
ChatManager::sendServerMessage(sock, "[MINFO] Current waypoint NPC ID: " + std::to_string((int)(task["m_iSTGrantWayPoint"])));
|
||||
ChatManager::sendServerMessage(sock, "[MINFO] Current terminator NPC ID: " + std::to_string((int)(task["m_iHTerminatorNPCID"])));
|
||||
Chat::sendServerMessage(sock, "[MINFO] Current task ID: " + std::to_string(plr->tasks[i]));
|
||||
Chat::sendServerMessage(sock, "[MINFO] Current task type: " + std::to_string((int)(task["m_iHTaskType"])));
|
||||
Chat::sendServerMessage(sock, "[MINFO] Current waypoint NPC ID: " + std::to_string((int)(task["m_iSTGrantWayPoint"])));
|
||||
Chat::sendServerMessage(sock, "[MINFO] Current terminator NPC ID: " + std::to_string((int)(task["m_iHTerminatorNPCID"])));
|
||||
|
||||
if ((int)(task["m_iSTGrantTimer"]) != 0)
|
||||
ChatManager::sendServerMessage(sock, "[MINFO] Current task timer: " + std::to_string((int)(task["m_iSTGrantTimer"])));
|
||||
Chat::sendServerMessage(sock, "[MINFO] Current task timer: " + std::to_string((int)(task["m_iSTGrantTimer"])));
|
||||
|
||||
for (int j = 0; j < 3; j++)
|
||||
if ((int)(task["m_iCSUEnemyID"][j]) != 0)
|
||||
ChatManager::sendServerMessage(sock, "[MINFO] Current task mob #" + std::to_string(j+1) +": " + std::to_string((int)(task["m_iCSUEnemyID"][j])));
|
||||
Chat::sendServerMessage(sock, "[MINFO] Current task mob #" + std::to_string(j+1) +": " + std::to_string((int)(task["m_iCSUEnemyID"][j])));
|
||||
|
||||
return;
|
||||
}
|
||||
@ -464,16 +464,16 @@ static void tasksCommand(std::string full, std::vector<std::string>& args, CNSoc
|
||||
|
||||
for (int i = 0; i < ACTIVE_MISSION_COUNT; i++) {
|
||||
if (plr->tasks[i] != 0) {
|
||||
TaskData& task = *MissionManager::Tasks[plr->tasks[i]];
|
||||
ChatManager::sendServerMessage(sock, "[TASK-" + std::to_string(i) + "] mission ID: " + std::to_string((int)(task["m_iHMissionID"])));
|
||||
ChatManager::sendServerMessage(sock, "[TASK-" + std::to_string(i) + "] task ID: " + std::to_string(plr->tasks[i]));
|
||||
TaskData& task = *Missions::Tasks[plr->tasks[i]];
|
||||
Chat::sendServerMessage(sock, "[TASK-" + std::to_string(i) + "] mission ID: " + std::to_string((int)(task["m_iHMissionID"])));
|
||||
Chat::sendServerMessage(sock, "[TASK-" + std::to_string(i) + "] task ID: " + std::to_string(plr->tasks[i]));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void buffCommand(std::string full, std::vector<std::string>& args, CNSocket* sock) {
|
||||
if (args.size() < 3) {
|
||||
ChatManager::sendServerMessage(sock, "/buff: no skill Id and duration time specified");
|
||||
Chat::sendServerMessage(sock, "/buff: no skill Id and duration time specified");
|
||||
return;
|
||||
}
|
||||
|
||||
@ -486,13 +486,13 @@ static void buffCommand(std::string full, std::vector<std::string>& args, CNSock
|
||||
return;
|
||||
|
||||
if (NPCManager::eggBuffPlayer(sock, skillId, 0, duration)<0)
|
||||
ChatManager::sendServerMessage(sock, "/buff: unknown skill Id");
|
||||
Chat::sendServerMessage(sock, "/buff: unknown skill Id");
|
||||
|
||||
}
|
||||
|
||||
static void eggCommand(std::string full, std::vector<std::string>& args, CNSocket* sock) {
|
||||
if (args.size() < 2) {
|
||||
ChatManager::sendServerMessage(sock, "/egg: no egg type specified");
|
||||
Chat::sendServerMessage(sock, "/egg: no egg type specified");
|
||||
return;
|
||||
}
|
||||
|
||||
@ -502,7 +502,7 @@ static void eggCommand(std::string full, std::vector<std::string>& args, CNSocke
|
||||
return;
|
||||
|
||||
if (NPCManager::EggTypes.find(eggType) == NPCManager::EggTypes.end()) {
|
||||
ChatManager::sendServerMessage(sock, "/egg: Unknown egg type");
|
||||
Chat::sendServerMessage(sock, "/egg: Unknown egg type");
|
||||
return;
|
||||
}
|
||||
|
||||
@ -530,22 +530,22 @@ static void notifyCommand(std::string full, std::vector<std::string>& args, CNSo
|
||||
|
||||
if (plr->notify) {
|
||||
plr->notify = false;
|
||||
ChatManager::sendServerMessage(sock, "[ADMIN] No longer receiving join notifications");
|
||||
Chat::sendServerMessage(sock, "[ADMIN] No longer receiving join notifications");
|
||||
} else {
|
||||
plr->notify = true;
|
||||
ChatManager::sendServerMessage(sock, "[ADMIN] Receiving join notifications");
|
||||
Chat::sendServerMessage(sock, "[ADMIN] Receiving join notifications");
|
||||
}
|
||||
}
|
||||
|
||||
static void playersCommand(std::string full, std::vector<std::string>& args, CNSocket* sock) {
|
||||
ChatManager::sendServerMessage(sock, "[ADMIN] Players on the server:");
|
||||
Chat::sendServerMessage(sock, "[ADMIN] Players on the server:");
|
||||
for (auto pair : PlayerManager::players)
|
||||
ChatManager::sendServerMessage(sock, PlayerManager::getPlayerName(pair.second));
|
||||
Chat::sendServerMessage(sock, PlayerManager::getPlayerName(pair.second));
|
||||
}
|
||||
|
||||
static void summonGroupCommand(std::string full, std::vector<std::string>& args, CNSocket* sock) {
|
||||
if (args.size() < 4) {
|
||||
ChatManager::sendServerMessage(sock, "/summonGroup(W) <leadermob> <mob> <number> [distance]");
|
||||
Chat::sendServerMessage(sock, "/summonGroup(W) <leadermob> <mob> <number> [distance]");
|
||||
return;
|
||||
}
|
||||
Player* plr = PlayerManager::getPlayer(sock);
|
||||
@ -561,7 +561,7 @@ static void summonGroupCommand(std::string full, std::vector<std::string>& args,
|
||||
distance = std::strtol(args[4].c_str(), &rest, 10);
|
||||
|
||||
if (*rest) {
|
||||
ChatManager::sendServerMessage(sock, "Invalid NPC number: " + args[1]);
|
||||
Chat::sendServerMessage(sock, "Invalid NPC number: " + args[1]);
|
||||
return;
|
||||
}
|
||||
|
||||
@ -569,7 +569,7 @@ static void summonGroupCommand(std::string full, std::vector<std::string>& args,
|
||||
|
||||
// permission & sanity check
|
||||
if (type > limit || type2 > limit || count > 5) {
|
||||
ChatManager::sendServerMessage(sock, "Invalid parameters; double check types and count");
|
||||
Chat::sendServerMessage(sock, "Invalid parameters; double check types and count");
|
||||
return;
|
||||
}
|
||||
|
||||
@ -621,7 +621,7 @@ static void summonGroupCommand(std::string full, std::vector<std::string>& args,
|
||||
NPCManager::updateNPCPosition(npc->appearanceData.iNPC_ID, x, y, z, plr->instanceID, npc->appearanceData.iAngle);
|
||||
}
|
||||
|
||||
ChatManager::sendServerMessage(sock, "/summonGroup(W): placed mob with type: " + std::to_string(type) +
|
||||
Chat::sendServerMessage(sock, "/summonGroup(W): placed mob with type: " + std::to_string(type) +
|
||||
", id: " + std::to_string(npc->appearanceData.iNPC_ID));
|
||||
|
||||
if (i == 0 && team == 2) {
|
||||
@ -644,7 +644,7 @@ static void summonGroupCommand(std::string full, std::vector<std::string>& args,
|
||||
|
||||
static void flushCommand(std::string full, std::vector<std::string>& args, CNSocket* sock) {
|
||||
TableData::flush();
|
||||
ChatManager::sendServerMessage(sock, "Wrote gruntwork to " + settings::GRUNTWORKJSON);
|
||||
Chat::sendServerMessage(sock, "Wrote gruntwork to " + settings::GRUNTWORKJSON);
|
||||
}
|
||||
|
||||
static void whoisCommand(std::string full, std::vector<std::string>& args, CNSocket* sock) {
|
||||
@ -652,31 +652,31 @@ static void whoisCommand(std::string full, std::vector<std::string>& args, CNSoc
|
||||
BaseNPC* npc = NPCManager::getNearestNPC(plr->viewableChunks, plr->x, plr->y, plr->z);
|
||||
|
||||
if (npc == nullptr) {
|
||||
ChatManager::sendServerMessage(sock, "[WHOIS] No NPCs found nearby");
|
||||
Chat::sendServerMessage(sock, "[WHOIS] No NPCs found nearby");
|
||||
return;
|
||||
}
|
||||
|
||||
ChatManager::sendServerMessage(sock, "[WHOIS] ID: " + std::to_string(npc->appearanceData.iNPC_ID));
|
||||
ChatManager::sendServerMessage(sock, "[WHOIS] Type: " + std::to_string(npc->appearanceData.iNPCType));
|
||||
ChatManager::sendServerMessage(sock, "[WHOIS] HP: " + std::to_string(npc->appearanceData.iHP));
|
||||
ChatManager::sendServerMessage(sock, "[WHOIS] CBF: " + std::to_string(npc->appearanceData.iConditionBitFlag));
|
||||
ChatManager::sendServerMessage(sock, "[WHOIS] Class: " + std::to_string(npc->npcClass));
|
||||
ChatManager::sendServerMessage(sock, "[WHOIS] X: " + std::to_string(npc->appearanceData.iX));
|
||||
ChatManager::sendServerMessage(sock, "[WHOIS] Y: " + std::to_string(npc->appearanceData.iY));
|
||||
ChatManager::sendServerMessage(sock, "[WHOIS] Z: " + std::to_string(npc->appearanceData.iZ));
|
||||
ChatManager::sendServerMessage(sock, "[WHOIS] Angle: " + std::to_string(npc->appearanceData.iAngle));
|
||||
Chat::sendServerMessage(sock, "[WHOIS] ID: " + std::to_string(npc->appearanceData.iNPC_ID));
|
||||
Chat::sendServerMessage(sock, "[WHOIS] Type: " + std::to_string(npc->appearanceData.iNPCType));
|
||||
Chat::sendServerMessage(sock, "[WHOIS] HP: " + std::to_string(npc->appearanceData.iHP));
|
||||
Chat::sendServerMessage(sock, "[WHOIS] CBF: " + std::to_string(npc->appearanceData.iConditionBitFlag));
|
||||
Chat::sendServerMessage(sock, "[WHOIS] Class: " + std::to_string(npc->npcClass));
|
||||
Chat::sendServerMessage(sock, "[WHOIS] X: " + std::to_string(npc->appearanceData.iX));
|
||||
Chat::sendServerMessage(sock, "[WHOIS] Y: " + std::to_string(npc->appearanceData.iY));
|
||||
Chat::sendServerMessage(sock, "[WHOIS] Z: " + std::to_string(npc->appearanceData.iZ));
|
||||
Chat::sendServerMessage(sock, "[WHOIS] Angle: " + std::to_string(npc->appearanceData.iAngle));
|
||||
std::string chunkPosition = std::to_string(std::get<0>(npc->chunkPos)) + ", " + std::to_string(std::get<1>(npc->chunkPos)) + ", " + std::to_string(std::get<2>(npc->chunkPos));
|
||||
ChatManager::sendServerMessage(sock, "[WHOIS] Chunk: {" + chunkPosition + "}");
|
||||
ChatManager::sendServerMessage(sock, "[WHOIS] MapNum: " + std::to_string(MAPNUM(npc->instanceID)));
|
||||
ChatManager::sendServerMessage(sock, "[WHOIS] Instance: " + std::to_string(PLAYERID(npc->instanceID)));
|
||||
Chat::sendServerMessage(sock, "[WHOIS] Chunk: {" + chunkPosition + "}");
|
||||
Chat::sendServerMessage(sock, "[WHOIS] MapNum: " + std::to_string(MAPNUM(npc->instanceID)));
|
||||
Chat::sendServerMessage(sock, "[WHOIS] Instance: " + std::to_string(PLAYERID(npc->instanceID)));
|
||||
}
|
||||
|
||||
static void lairUnlockCommand(std::string full, std::vector<std::string>& args, CNSocket* sock) {
|
||||
Player* plr = PlayerManager::getPlayer(sock);
|
||||
if (!ChunkManager::chunkExists(plr->chunkPos))
|
||||
if (!Chunking::chunkExists(plr->chunkPos))
|
||||
return;
|
||||
|
||||
Chunk* chnk = ChunkManager::chunks[plr->chunkPos];
|
||||
Chunk* chnk = Chunking::chunks[plr->chunkPos];
|
||||
int taskID = -1;
|
||||
int missionID = -1;
|
||||
int found = 0;
|
||||
@ -688,7 +688,7 @@ static void lairUnlockCommand(std::string full, std::vector<std::string>& args,
|
||||
for (auto it = NPCManager::Warps.begin(); it != NPCManager::Warps.end(); it++) {
|
||||
if ((*it).second.npcID == npc->appearanceData.iNPCType) {
|
||||
taskID = (*it).second.limitTaskID;
|
||||
missionID = MissionManager::Tasks[taskID]->task["m_iHMissionID"];
|
||||
missionID = Missions::Tasks[taskID]->task["m_iHMissionID"];
|
||||
found++;
|
||||
break;
|
||||
}
|
||||
@ -696,17 +696,17 @@ static void lairUnlockCommand(std::string full, std::vector<std::string>& args,
|
||||
}
|
||||
|
||||
if (missionID == -1 || taskID == -1) {
|
||||
ChatManager::sendServerMessage(sock, "You are NOT standing near a lair portal; move around and try again!");
|
||||
Chat::sendServerMessage(sock, "You are NOT standing near a lair portal; move around and try again!");
|
||||
return;
|
||||
}
|
||||
|
||||
if (found > 1) {
|
||||
ChatManager::sendServerMessage(sock, "More than one lair found; decrease chunk size and try again!");
|
||||
Chat::sendServerMessage(sock, "More than one lair found; decrease chunk size and try again!");
|
||||
return;
|
||||
}
|
||||
|
||||
INITSTRUCT(sP_FE2CL_REP_PC_TASK_START_SUCC, taskResp);
|
||||
MissionManager::startTask(plr, taskID);
|
||||
Missions::startTask(plr, taskID);
|
||||
taskResp.iTaskNum = taskID;
|
||||
taskResp.iRemainTime = 0;
|
||||
sock->sendPacket((void*)&taskResp, P_FE2CL_REP_PC_TASK_START_SUCC, sizeof(sP_FE2CL_REP_PC_TASK_START_SUCC));
|
||||
@ -720,35 +720,35 @@ static void lairUnlockCommand(std::string full, std::vector<std::string>& args,
|
||||
static void hideCommand(std::string full, std::vector<std::string>& args, CNSocket* sock) {
|
||||
Player* plr = PlayerManager::getPlayer(sock);
|
||||
if (plr->hidden) {
|
||||
ChatManager::sendServerMessage(sock, "[HIDE] You're already hidden from the map.");
|
||||
Chat::sendServerMessage(sock, "[HIDE] You're already hidden from the map.");
|
||||
return;
|
||||
}
|
||||
|
||||
plr->hidden = true;
|
||||
ChatManager::sendServerMessage(sock, "[HIDE] Successfully hidden from the map.");
|
||||
Chat::sendServerMessage(sock, "[HIDE] Successfully hidden from the map.");
|
||||
}
|
||||
|
||||
static void unhideCommand(std::string full, std::vector<std::string>& args, CNSocket* sock) {
|
||||
Player* plr = PlayerManager::getPlayer(sock);
|
||||
if (!plr->hidden) {
|
||||
ChatManager::sendServerMessage(sock, "[HIDE] You're already visible from the map.");
|
||||
Chat::sendServerMessage(sock, "[HIDE] You're already visible from the map.");
|
||||
return;
|
||||
}
|
||||
|
||||
plr->hidden = false;
|
||||
ChatManager::sendServerMessage(sock, "[HIDE] Successfully un-hidden from the map.");
|
||||
Chat::sendServerMessage(sock, "[HIDE] Successfully un-hidden from the map.");
|
||||
}
|
||||
|
||||
static void redeemCommand(std::string full, std::vector<std::string>& args, CNSocket* sock) {
|
||||
if (args.size() < 2) {
|
||||
ChatManager::sendServerMessage(sock, "/redeem: No code specified");
|
||||
Chat::sendServerMessage(sock, "/redeem: No code specified");
|
||||
return;
|
||||
}
|
||||
|
||||
// convert string to all lowercase
|
||||
const char* codeRaw = args[1].c_str();
|
||||
if (args[1].size() > 256) { // prevent overflow
|
||||
ChatManager::sendServerMessage(sock, "/redeem: Code too long");
|
||||
Chat::sendServerMessage(sock, "/redeem: Code too long");
|
||||
return;
|
||||
}
|
||||
|
||||
@ -757,25 +757,25 @@ static void redeemCommand(std::string full, std::vector<std::string>& args, CNSo
|
||||
buf[i] = std::tolower(codeRaw[i]);
|
||||
std::string code(buf, args[1].size());
|
||||
|
||||
if (ItemManager::CodeItems.find(code) == ItemManager::CodeItems.end()) {
|
||||
ChatManager::sendServerMessage(sock, "/redeem: Unknown code");
|
||||
if (Items::CodeItems.find(code) == Items::CodeItems.end()) {
|
||||
Chat::sendServerMessage(sock, "/redeem: Unknown code");
|
||||
return;
|
||||
}
|
||||
|
||||
Player* plr = PlayerManager::getPlayer(sock);
|
||||
|
||||
if (Database::isCodeRedeemed(plr->iID, code)) {
|
||||
ChatManager::sendServerMessage(sock, "/redeem: You have already redeemed this code item");
|
||||
Chat::sendServerMessage(sock, "/redeem: You have already redeemed this code item");
|
||||
return;
|
||||
}
|
||||
|
||||
int itemCount = ItemManager::CodeItems[code].size();
|
||||
int itemCount = Items::CodeItems[code].size();
|
||||
std::vector<int> slots;
|
||||
|
||||
for (int i = 0; i < itemCount; i++) {
|
||||
slots.push_back(ItemManager::findFreeSlot(plr));
|
||||
slots.push_back(Items::findFreeSlot(plr));
|
||||
if (slots[i] == -1) {
|
||||
ChatManager::sendServerMessage(sock, "/redeem: Not enough space in inventory");
|
||||
Chat::sendServerMessage(sock, "/redeem: Not enough space in inventory");
|
||||
|
||||
// delete any temp items we might have set
|
||||
for (int j = 0; j < i; j++) {
|
||||
@ -790,7 +790,7 @@ static void redeemCommand(std::string full, std::vector<std::string>& args, CNSo
|
||||
Database::recordCodeRedemption(plr->iID, code);
|
||||
|
||||
for (int i = 0; i < itemCount; i++) {
|
||||
std::pair<int32_t, int32_t> item = ItemManager::CodeItems[code][i];
|
||||
std::pair<int32_t, int32_t> item = Items::CodeItems[code][i];
|
||||
INITSTRUCT(sP_FE2CL_REP_PC_GIVE_ITEM_SUCC, resp);
|
||||
|
||||
resp.eIL = 1;
|
||||
@ -806,7 +806,7 @@ static void redeemCommand(std::string full, std::vector<std::string>& args, CNSo
|
||||
sock->sendPacket((void*)&resp, P_FE2CL_REP_PC_GIVE_ITEM_SUCC, sizeof(sP_FE2CL_REP_PC_GIVE_ITEM_SUCC));
|
||||
}
|
||||
std::string msg = itemCount == 1 ? "You have redeemed a code item" : "You have redeemed code items";
|
||||
ChatManager::sendServerMessage(sock, msg);
|
||||
Chat::sendServerMessage(sock, msg);
|
||||
}
|
||||
|
||||
static void unwarpableCommand(std::string full, std::vector<std::string>& args, CNSocket* sock) {
|
||||
@ -857,14 +857,14 @@ static void banCommand(std::string full, std::vector<std::string>& args, CNSocke
|
||||
Player* plr = PlayerManager::getPlayer(sock);
|
||||
|
||||
if (args.size() < 2) {
|
||||
ChatManager::sendServerMessage(sock, "Usage: /ban PlayerID [reason...]");
|
||||
Chat::sendServerMessage(sock, "Usage: /ban PlayerID [reason...]");
|
||||
return;
|
||||
}
|
||||
|
||||
char *rest;
|
||||
int playerId = std::strtol(args[1].c_str(), &rest, 10);
|
||||
if (*rest) {
|
||||
ChatManager::sendServerMessage(sock, "Invalid PlayerID: " + args[1]);
|
||||
Chat::sendServerMessage(sock, "Invalid PlayerID: " + args[1]);
|
||||
return;
|
||||
}
|
||||
|
||||
@ -880,17 +880,17 @@ static void banCommand(std::string full, std::vector<std::string>& args, CNSocke
|
||||
// ban the account that player belongs to
|
||||
if (!Database::banPlayer(playerId, reason)) {
|
||||
// propagating a more descriptive error message from banPlayer() would be too much work
|
||||
ChatManager::sendServerMessage(sock, "Failed to ban target player. Check server logs.");
|
||||
Chat::sendServerMessage(sock, "Failed to ban target player. Check server logs.");
|
||||
return;
|
||||
}
|
||||
|
||||
ChatManager::sendServerMessage(sock, "Banned target player.");
|
||||
Chat::sendServerMessage(sock, "Banned target player.");
|
||||
std::cout << "[INFO] " << PlayerManager::getPlayerName(plr) << " banned player " << playerId << std::endl;
|
||||
|
||||
// if the player is online, kick them
|
||||
CNSocket *otherSock = PlayerManager::getSockFromID(playerId);
|
||||
if (otherSock == nullptr) {
|
||||
ChatManager::sendServerMessage(sock, "Player wasn't online. Didn't need to kick.");
|
||||
Chat::sendServerMessage(sock, "Player wasn't online. Didn't need to kick.");
|
||||
return;
|
||||
}
|
||||
|
||||
@ -907,29 +907,29 @@ static void banCommand(std::string full, std::vector<std::string>& args, CNSocke
|
||||
// ensure that the connection has terminated
|
||||
otherSock->kill();
|
||||
|
||||
ChatManager::sendServerMessage(sock, PlayerManager::getPlayerName(otherPlr) + " was online. Kicked.");
|
||||
Chat::sendServerMessage(sock, PlayerManager::getPlayerName(otherPlr) + " was online. Kicked.");
|
||||
}
|
||||
|
||||
static void unbanCommand(std::string full, std::vector<std::string>& args, CNSocket *sock) {
|
||||
Player* plr = PlayerManager::getPlayer(sock);
|
||||
|
||||
if (args.size() < 2) {
|
||||
ChatManager::sendServerMessage(sock, "Usage: /unban PlayerID");
|
||||
Chat::sendServerMessage(sock, "Usage: /unban PlayerID");
|
||||
return;
|
||||
}
|
||||
|
||||
char *rest;
|
||||
int playerId = std::strtol(args[1].c_str(), &rest, 10);
|
||||
if (*rest) {
|
||||
ChatManager::sendServerMessage(sock, "Invalid PlayerID: " + args[1]);
|
||||
Chat::sendServerMessage(sock, "Invalid PlayerID: " + args[1]);
|
||||
return;
|
||||
}
|
||||
|
||||
if (Database::unbanPlayer(playerId)) {
|
||||
ChatManager::sendServerMessage(sock, "Unbanned player.");
|
||||
Chat::sendServerMessage(sock, "Unbanned player.");
|
||||
std::cout << "[INFO] " << PlayerManager::getPlayerName(plr) << " unbanned player " << playerId << std::endl;
|
||||
} else {
|
||||
ChatManager::sendServerMessage(sock, "Failed to unban player. Check server logs.");
|
||||
Chat::sendServerMessage(sock, "Failed to unban player. Check server logs.");
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -6,8 +6,8 @@
|
||||
|
||||
#include "db/Database.hpp"
|
||||
#include "PlayerManager.hpp"
|
||||
#include "ItemManager.hpp"
|
||||
#include "ChatManager.hpp"
|
||||
#include "Items.hpp"
|
||||
#include "Chat.hpp"
|
||||
|
||||
using namespace Email;
|
||||
|
||||
@ -149,7 +149,7 @@ static void emailReceiveItemAll(CNSocket* sock, CNPacketData* data) {
|
||||
Player* plr = PlayerManager::getPlayer(sock);
|
||||
sItemBase* itemsFrom = Database::getEmailAttachments(plr->iID, pkt->iEmailIndex);
|
||||
for (int i = 0; i < 4; i++) {
|
||||
int slot = ItemManager::findFreeSlot(plr);
|
||||
int slot = Items::findFreeSlot(plr);
|
||||
if (slot < 0 || slot >= AINVEN_COUNT) {
|
||||
INITSTRUCT(sP_FE2CL_REP_PC_RECV_EMAIL_ITEM_ALL_FAIL, failResp);
|
||||
failResp.iEmailIndex = pkt->iEmailIndex;
|
||||
@ -292,8 +292,8 @@ static void emailSend(CNSocket* sock, CNPacketData* data) {
|
||||
plr->iID, // SenderID
|
||||
U16toU8(plr->PCStyle.szFirstName), // SenderFirstName
|
||||
U16toU8(plr->PCStyle.szLastName), // SenderLastName
|
||||
ChatManager::sanitizeText(U16toU8(pkt->szSubject)), // SubjectLine
|
||||
ChatManager::sanitizeText(U16toU8(pkt->szContent), true), // MsgBody
|
||||
Chat::sanitizeText(U16toU8(pkt->szSubject)), // SubjectLine
|
||||
Chat::sanitizeText(U16toU8(pkt->szContent), true), // MsgBody
|
||||
pkt->iCash, // Taros
|
||||
(uint64_t)getTimestamp(), // SendTime
|
||||
0 // DeleteTime (unimplemented)
|
||||
|
@ -1,8 +1,8 @@
|
||||
#include "CNShardServer.hpp"
|
||||
#include "CNStructs.hpp"
|
||||
#include "PlayerManager.hpp"
|
||||
#include "GroupManager.hpp"
|
||||
#include "NanoManager.hpp"
|
||||
#include "Groups.hpp"
|
||||
#include "Nanos.hpp"
|
||||
#include "Abilities.hpp"
|
||||
|
||||
#include <iostream>
|
||||
@ -10,7 +10,7 @@
|
||||
#include <algorithm>
|
||||
#include <thread>
|
||||
|
||||
using namespace GroupManager;
|
||||
using namespace Groups;
|
||||
|
||||
static void requestGroup(CNSocket* sock, CNPacketData* data) {
|
||||
if (data->size != sizeof(sP_CL2FE_REQ_PC_GROUP_INVITE))
|
||||
@ -137,10 +137,10 @@ static void joinGroup(CNSocket* sock, CNPacketData* data) {
|
||||
// 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 (NanoManager::SkillTable[varPlr->Nanos[varPlr->activeNano].iSkillID].targetType == 3)
|
||||
NanoManager::applyBuff(sock, varPlr->Nanos[varPlr->activeNano].iSkillID, 1, 1, bitFlag);
|
||||
if (NanoManager::SkillTable[plr->Nanos[plr->activeNano].iSkillID].targetType == 3)
|
||||
NanoManager::applyBuff(sockTo, plr->Nanos[plr->activeNano].iSkillID, 1, 1, bitFlag);
|
||||
if (Nanos::SkillTable[varPlr->Nanos[varPlr->activeNano].iSkillID].targetType == 3)
|
||||
Nanos::applyBuff(sock, varPlr->Nanos[varPlr->activeNano].iSkillID, 1, 1, bitFlag);
|
||||
if (Nanos::SkillTable[plr->Nanos[plr->activeNano].iSkillID].targetType == 3)
|
||||
Nanos::applyBuff(sockTo, plr->Nanos[plr->activeNano].iSkillID, 1, 1, bitFlag);
|
||||
}
|
||||
}
|
||||
|
||||
@ -152,7 +152,7 @@ static void leaveGroup(CNSocket* sock, CNPacketData* data) {
|
||||
groupKickPlayer(plr);
|
||||
}
|
||||
|
||||
void GroupManager::sendToGroup(Player* plr, void* buf, uint32_t type, size_t size) {
|
||||
void Groups::sendToGroup(Player* plr, void* buf, uint32_t type, size_t size) {
|
||||
for (int i = 0; i < plr->groupCnt; i++) {
|
||||
CNSocket* sock = PlayerManager::getSockFromID(plr->groupIDs[i]);
|
||||
|
||||
@ -168,7 +168,7 @@ void GroupManager::sendToGroup(Player* plr, void* buf, uint32_t type, size_t siz
|
||||
}
|
||||
}
|
||||
|
||||
void GroupManager::groupTickInfo(Player* plr) {
|
||||
void Groups::groupTickInfo(Player* plr) {
|
||||
if (!validOutVarPacket(sizeof(sP_FE2CL_PC_GROUP_MEMBER_INFO), plr->groupCnt, sizeof(sPCGroupMemberInfo))) {
|
||||
std::cout << "[WARN] bad sP_FE2CL_PC_GROUP_JOIN packet size\n";
|
||||
return;
|
||||
@ -223,12 +223,12 @@ static void groupUnbuff(Player* plr) {
|
||||
Player* otherPlr = PlayerManager::getPlayerFromID(plr->groupIDs[i]);
|
||||
CNSocket* sock = PlayerManager::getSockFromID(plr->groupIDs[n]);
|
||||
|
||||
NanoManager::applyBuff(sock, otherPlr->Nanos[otherPlr->activeNano].iSkillID, 2, 1, 0);
|
||||
Nanos::applyBuff(sock, otherPlr->Nanos[otherPlr->activeNano].iSkillID, 2, 1, 0);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void GroupManager::groupKickPlayer(Player* plr) {
|
||||
void Groups::groupKickPlayer(Player* plr) {
|
||||
// if you are the group leader, destroy your own group and kick everybody
|
||||
if (plr->iID == plr->iIDGroup) {
|
||||
groupUnbuff(plr);
|
||||
@ -297,10 +297,10 @@ void GroupManager::groupKickPlayer(Player* plr) {
|
||||
moveDown = 1;
|
||||
otherPlr->groupIDs[i] = 0;
|
||||
} else { // remove the leaving member's buffs from the group and remove the group buffs from the leaving member.
|
||||
if (NanoManager::SkillTable[varPlr->Nanos[varPlr->activeNano].iSkillID].targetType == 3)
|
||||
NanoManager::applyBuff(sock, varPlr->Nanos[varPlr->activeNano].iSkillID, 2, 1, 0);
|
||||
if (NanoManager::SkillTable[plr->Nanos[varPlr->activeNano].iSkillID].targetType == 3)
|
||||
NanoManager::applyBuff(sockTo, plr->Nanos[plr->activeNano].iSkillID, 2, 1, bitFlag);
|
||||
if (Nanos::SkillTable[varPlr->Nanos[varPlr->activeNano].iSkillID].targetType == 3)
|
||||
Nanos::applyBuff(sock, varPlr->Nanos[varPlr->activeNano].iSkillID, 2, 1, 0);
|
||||
if (Nanos::SkillTable[plr->Nanos[varPlr->activeNano].iSkillID].targetType == 3)
|
||||
Nanos::applyBuff(sockTo, plr->Nanos[plr->activeNano].iSkillID, 2, 1, bitFlag);
|
||||
}
|
||||
}
|
||||
|
||||
@ -313,7 +313,7 @@ void GroupManager::groupKickPlayer(Player* plr) {
|
||||
sock->sendPacket((void*)&resp1, P_FE2CL_PC_GROUP_LEAVE_SUCC, sizeof(sP_FE2CL_PC_GROUP_LEAVE_SUCC));
|
||||
}
|
||||
|
||||
int GroupManager::getGroupFlags(Player* plr) {
|
||||
int Groups::getGroupFlags(Player* plr) {
|
||||
int bitFlag = 0;
|
||||
|
||||
for (int i = 0; i < plr->groupCnt; i++) {
|
||||
@ -328,7 +328,7 @@ int GroupManager::getGroupFlags(Player* plr) {
|
||||
return bitFlag;
|
||||
}
|
||||
|
||||
void GroupManager::init() {
|
||||
void Groups::init() {
|
||||
REGISTER_SHARD_PACKET(P_CL2FE_REQ_PC_GROUP_INVITE, requestGroup);
|
||||
REGISTER_SHARD_PACKET(P_CL2FE_REQ_PC_GROUP_INVITE_REFUSE, refuseGroup);
|
||||
REGISTER_SHARD_PACKET(P_CL2FE_REQ_PC_GROUP_JOIN, joinGroup);
|
@ -8,7 +8,7 @@
|
||||
#include <map>
|
||||
#include <list>
|
||||
|
||||
namespace GroupManager {
|
||||
namespace Groups {
|
||||
void init();
|
||||
|
||||
void sendToGroup(Player* plr, void* buf, uint32_t type, size_t size);
|
@ -1,31 +1,31 @@
|
||||
#include "CNShardServer.hpp"
|
||||
#include "CNStructs.hpp"
|
||||
#include "ItemManager.hpp"
|
||||
#include "Items.hpp"
|
||||
#include "PlayerManager.hpp"
|
||||
#include "NanoManager.hpp"
|
||||
#include "Nanos.hpp"
|
||||
#include "NPCManager.hpp"
|
||||
#include "Player.hpp"
|
||||
#include "Abilities.hpp"
|
||||
#include "MissionManager.hpp"
|
||||
#include "Missions.hpp"
|
||||
|
||||
#include <string.h> // for memset()
|
||||
#include <assert.h>
|
||||
|
||||
using namespace ItemManager;
|
||||
using namespace Items;
|
||||
|
||||
std::map<std::pair<int32_t, int32_t>, ItemManager::Item> ItemManager::ItemData;
|
||||
std::map<int32_t, CrocPotEntry> ItemManager::CrocPotTable;
|
||||
std::map<int32_t, std::vector<int>> ItemManager::RarityRatios;
|
||||
std::map<int32_t, Crate> ItemManager::Crates;
|
||||
std::map<std::pair<int32_t, int32_t>, Items::Item> Items::ItemData;
|
||||
std::map<int32_t, CrocPotEntry> Items::CrocPotTable;
|
||||
std::map<int32_t, std::vector<int>> Items::RarityRatios;
|
||||
std::map<int32_t, Crate> Items::Crates;
|
||||
// pair Itemset, Rarity -> vector of pointers (map iterators) to records in ItemData
|
||||
std::map<std::pair<int32_t, int32_t>, std::vector<std::map<std::pair<int32_t, int32_t>, ItemManager::Item>::iterator>> ItemManager::CrateItems;
|
||||
std::map<std::string, std::vector<std::pair<int32_t, int32_t>>> ItemManager::CodeItems;
|
||||
std::map<std::pair<int32_t, int32_t>, std::vector<std::map<std::pair<int32_t, int32_t>, Items::Item>::iterator>> Items::CrateItems;
|
||||
std::map<std::string, std::vector<std::pair<int32_t, int32_t>>> Items::CodeItems;
|
||||
|
||||
std::map<int32_t, MobDropChance> ItemManager::MobDropChances;
|
||||
std::map<int32_t, MobDrop> ItemManager::MobDrops;
|
||||
std::map<int32_t, MobDropChance> Items::MobDropChances;
|
||||
std::map<int32_t, MobDrop> Items::MobDrops;
|
||||
|
||||
#ifdef ACADEMY
|
||||
std::map<int32_t, int32_t> ItemManager::NanoCapsules; // crate id -> nano id
|
||||
std::map<int32_t, int32_t> Items::NanoCapsules; // crate id -> nano id
|
||||
|
||||
static void nanoCapsuleHandler(CNSocket* sock, int slot, sItemBase *chest) {
|
||||
Player* plr = PlayerManager::getPlayer(sock);
|
||||
@ -77,7 +77,7 @@ static void nanoCapsuleHandler(CNSocket* sock, int slot, sItemBase *chest) {
|
||||
sock->sendPacket((void*)&msg, P_FE2CL_GM_REP_PC_ANNOUNCE, sizeof(sP_FE2CL_GM_REP_PC_ANNOUNCE));
|
||||
return;
|
||||
}
|
||||
NanoManager::addNano(sock, nanoId, -1, false);
|
||||
Nanos::addNano(sock, nanoId, -1, false);
|
||||
}
|
||||
#endif
|
||||
|
||||
@ -360,7 +360,7 @@ static void itemUseHandler(CNSocket* sock, CNPacketData* data) {
|
||||
}
|
||||
|
||||
// sanity check, check if gumball type matches nano style
|
||||
int nanoStyle = NanoManager::nanoStyle(nano.iID);
|
||||
int nanoStyle = Nanos::nanoStyle(nano.iID);
|
||||
if (!((gumball.iID == 119 && nanoStyle == 0) ||
|
||||
( gumball.iID == 120 && nanoStyle == 1) ||
|
||||
( gumball.iID == 121 && nanoStyle == 2))) {
|
||||
@ -417,7 +417,7 @@ static void itemUseHandler(CNSocket* sock, CNPacketData* data) {
|
||||
player->Inven[resp->iSlotNum] = resp->RemainItem;
|
||||
|
||||
std::pair<CNSocket*, int32_t> key = std::make_pair(sock, value1);
|
||||
time_t until = getTime() + (time_t)NanoManager::SkillTable[144].durationTime[0] * 100;
|
||||
time_t until = getTime() + (time_t)Nanos::SkillTable[144].durationTime[0] * 100;
|
||||
NPCManager::EggBuffs[key] = until;
|
||||
}
|
||||
|
||||
@ -532,8 +532,8 @@ static void chestOpenHandler(CNSocket *sock, CNPacketData *data) {
|
||||
sock->sendPacket((void*)&resp, P_FE2CL_REP_ITEM_CHEST_OPEN_SUCC, sizeof(sP_FE2CL_REP_ITEM_CHEST_OPEN_SUCC));
|
||||
}
|
||||
|
||||
// TODO: use this in cleaned up ItemManager
|
||||
int ItemManager::findFreeSlot(Player *plr) {
|
||||
// TODO: use this in cleaned up Items
|
||||
int Items::findFreeSlot(Player *plr) {
|
||||
int i;
|
||||
|
||||
for (i = 0; i < AINVEN_COUNT; i++)
|
||||
@ -544,13 +544,13 @@ int ItemManager::findFreeSlot(Player *plr) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
Item* ItemManager::getItemData(int32_t id, int32_t type) {
|
||||
Item* Items::getItemData(int32_t id, int32_t type) {
|
||||
if(ItemData.find(std::make_pair(id, type)) != ItemData.end())
|
||||
return &ItemData[std::make_pair(id, type)];
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
void ItemManager::checkItemExpire(CNSocket* sock, Player* player) {
|
||||
void Items::checkItemExpire(CNSocket* sock, Player* player) {
|
||||
if (player->toRemoveVehicle.eIL == 0 && player->toRemoveVehicle.iSlotNum == 0)
|
||||
return;
|
||||
|
||||
@ -585,7 +585,7 @@ void ItemManager::checkItemExpire(CNSocket* sock, Player* player) {
|
||||
player->toRemoveVehicle.iSlotNum = 0;
|
||||
}
|
||||
|
||||
void ItemManager::setItemStats(Player* plr) {
|
||||
void Items::setItemStats(Player* plr) {
|
||||
|
||||
plr->pointDamage = 8 + plr->level * 2;
|
||||
plr->groupDamage = 8 + plr->level * 2;
|
||||
@ -609,7 +609,7 @@ void ItemManager::setItemStats(Player* plr) {
|
||||
|
||||
// HACK: work around the invisible weapon bug
|
||||
// TODO: I don't think this makes a difference at all? Check and remove, if necessary.
|
||||
void ItemManager::updateEquips(CNSocket* sock, Player* plr) {
|
||||
void Items::updateEquips(CNSocket* sock, Player* plr) {
|
||||
for (int i = 0; i < 4; i++) {
|
||||
INITSTRUCT(sP_FE2CL_PC_EQUIP_CHANGE, resp);
|
||||
|
||||
@ -696,7 +696,7 @@ static void giveEventDrop(CNSocket* sock, Player* player, int rolled) {
|
||||
sock->sendPacket((void*)respbuf, P_FE2CL_REP_REWARD_ITEM, resplen);
|
||||
}
|
||||
|
||||
void ItemManager::giveMobDrop(CNSocket *sock, Mob* mob, int rolledBoosts, int rolledPotions,
|
||||
void Items::giveMobDrop(CNSocket *sock, Mob* mob, int rolledBoosts, int rolledPotions,
|
||||
int rolledCrate, int rolledCrateType, int rolledEvent) {
|
||||
Player *plr = PlayerManager::getPlayer(sock);
|
||||
|
||||
@ -723,7 +723,7 @@ void ItemManager::giveMobDrop(CNSocket *sock, Mob* mob, int rolledBoosts, int ro
|
||||
// money nano boost
|
||||
if (plr->iConditionBitFlag & CSB_BIT_REWARD_CASH) {
|
||||
int boost = 0;
|
||||
if (NanoManager::getNanoBoost(plr)) // for gumballs
|
||||
if (Nanos::getNanoBoost(plr)) // for gumballs
|
||||
boost = 1;
|
||||
plr->money += drop.taros * (5 + boost) / 25;
|
||||
}
|
||||
@ -736,12 +736,12 @@ void ItemManager::giveMobDrop(CNSocket *sock, Mob* mob, int rolledBoosts, int ro
|
||||
// scavenger nano boost
|
||||
if (plr->iConditionBitFlag & CSB_BIT_REWARD_BLOB) {
|
||||
int boost = 0;
|
||||
if (NanoManager::getNanoBoost(plr)) // for gumballs
|
||||
if (Nanos::getNanoBoost(plr)) // for gumballs
|
||||
boost = 1;
|
||||
fm += fm * (5 + boost) / 25;
|
||||
}
|
||||
|
||||
MissionManager::updateFusionMatter(sock, fm);
|
||||
Missions::updateFusionMatter(sock, fm);
|
||||
|
||||
// give boosts 1 in 3 times
|
||||
if (drop.boosts > 0) {
|
||||
@ -800,7 +800,7 @@ void ItemManager::giveMobDrop(CNSocket *sock, Mob* mob, int rolledBoosts, int ro
|
||||
giveEventDrop(sock, plr, rolledEvent);
|
||||
}
|
||||
|
||||
void ItemManager::init() {
|
||||
void Items::init() {
|
||||
REGISTER_SHARD_PACKET(P_CL2FE_REQ_ITEM_MOVE, itemMoveHandler);
|
||||
REGISTER_SHARD_PACKET(P_CL2FE_REQ_PC_ITEM_DELETE, itemDeleteHandler);
|
||||
// this one is for gumballs
|
@ -27,7 +27,7 @@ struct MobDrop {
|
||||
int boosts;
|
||||
};
|
||||
|
||||
namespace ItemManager {
|
||||
namespace Items {
|
||||
enum class SlotType {
|
||||
EQUIP = 0,
|
||||
INVENTORY = 1,
|
@ -1,17 +1,17 @@
|
||||
#include "CNShardServer.hpp"
|
||||
#include "CNStructs.hpp"
|
||||
#include "MissionManager.hpp"
|
||||
#include "Missions.hpp"
|
||||
#include "PlayerManager.hpp"
|
||||
#include "NanoManager.hpp"
|
||||
#include "ItemManager.hpp"
|
||||
#include "Nanos.hpp"
|
||||
#include "Items.hpp"
|
||||
|
||||
#include "string.h"
|
||||
|
||||
using namespace MissionManager;
|
||||
using namespace Missions;
|
||||
|
||||
std::map<int32_t, Reward*> MissionManager::Rewards;
|
||||
std::map<int32_t, TaskData*> MissionManager::Tasks;
|
||||
nlohmann::json MissionManager::AvatarGrowth[37];
|
||||
std::map<int32_t, Reward*> Missions::Rewards;
|
||||
std::map<int32_t, TaskData*> Missions::Tasks;
|
||||
nlohmann::json Missions::AvatarGrowth[37];
|
||||
|
||||
static void saveMission(Player* player, int missionId) {
|
||||
// sanity check missionID so we don't get exceptions
|
||||
@ -127,7 +127,7 @@ static int giveMissionReward(CNSocket *sock, int task, int choice=0) {
|
||||
|
||||
int slots[4];
|
||||
for (int i = 0; i < nrewards; i++) {
|
||||
slots[i] = ItemManager::findFreeSlot(plr);
|
||||
slots[i] = Items::findFreeSlot(plr);
|
||||
if (slots[i] == -1) {
|
||||
std::cout << "Not enough room to complete task" << std::endl;
|
||||
INITSTRUCT(sP_FE2CL_REP_PC_TASK_END_FAIL, fail);
|
||||
@ -160,14 +160,14 @@ static int giveMissionReward(CNSocket *sock, int task, int choice=0) {
|
||||
plr->money += reward->money;
|
||||
if (plr->iConditionBitFlag & CSB_BIT_REWARD_CASH) { // nano boost for taros
|
||||
int boost = 0;
|
||||
if (NanoManager::getNanoBoost(plr)) // for gumballs
|
||||
if (Nanos::getNanoBoost(plr)) // for gumballs
|
||||
boost = 1;
|
||||
plr->money += reward->money * (5 + boost) / 25;
|
||||
}
|
||||
|
||||
if (plr->iConditionBitFlag & CSB_BIT_REWARD_BLOB) { // nano boost for fm
|
||||
int boost = 0;
|
||||
if (NanoManager::getNanoBoost(plr)) // for gumballs
|
||||
if (Nanos::getNanoBoost(plr)) // for gumballs
|
||||
boost = 1;
|
||||
updateFusionMatter(sock, reward->fusionmatter * (30 + boost) / 25);
|
||||
} else
|
||||
@ -259,7 +259,7 @@ static bool endTask(CNSocket *sock, int32_t taskNum, int choice=0) {
|
||||
|
||||
// if it's a nano mission, reward the nano.
|
||||
if (task["m_iSTNanoID"] != 0)
|
||||
NanoManager::addNano(sock, task["m_iSTNanoID"], 0, true);
|
||||
Nanos::addNano(sock, task["m_iSTNanoID"], 0, true);
|
||||
|
||||
// remove current mission
|
||||
plr->CurrentMissionID = 0;
|
||||
@ -268,13 +268,13 @@ static bool endTask(CNSocket *sock, int32_t taskNum, int choice=0) {
|
||||
return true;
|
||||
}
|
||||
|
||||
bool MissionManager::startTask(Player* plr, int TaskID) {
|
||||
if (MissionManager::Tasks.find(TaskID) == MissionManager::Tasks.end()) {
|
||||
bool Missions::startTask(Player* plr, int TaskID) {
|
||||
if (Missions::Tasks.find(TaskID) == Missions::Tasks.end()) {
|
||||
std::cout << "[WARN] Player submitted unknown task!?" << std::endl;
|
||||
return false;
|
||||
}
|
||||
|
||||
TaskData& task = *MissionManager::Tasks[TaskID];
|
||||
TaskData& task = *Missions::Tasks[TaskID];
|
||||
|
||||
// client freaks out if nano mission isn't sent first after relogging, so it's easiest to set it here
|
||||
if (task["m_iSTNanoID"] != 0 && plr->tasks[0] != 0) {
|
||||
@ -357,7 +357,7 @@ static void taskEnd(CNSocket* sock, CNPacketData* data) {
|
||||
|
||||
// failed timed missions give an iNPC_ID of 0
|
||||
if (missionData->iNPC_ID == 0) {
|
||||
TaskData* task = MissionManager::Tasks[missionData->iTaskNum];
|
||||
TaskData* task = Missions::Tasks[missionData->iTaskNum];
|
||||
if (task->task["m_iSTGrantTimer"] > 0) { // its a timed mission
|
||||
Player* plr = PlayerManager::getPlayer(sock);
|
||||
/*
|
||||
@ -384,7 +384,7 @@ static void taskEnd(CNSocket* sock, CNPacketData* data) {
|
||||
|
||||
int failTaskID = task->task["m_iFOutgoingTask"];
|
||||
if (failTaskID != 0) {
|
||||
MissionManager::quitTask(sock, missionData->iTaskNum, false);
|
||||
Missions::quitTask(sock, missionData->iTaskNum, false);
|
||||
|
||||
for (int i = 0; i < 6; i++)
|
||||
if (plr->tasks[i] == missionData->iTaskNum)
|
||||
@ -428,7 +428,7 @@ static void quitMission(CNSocket* sock, CNPacketData* data) {
|
||||
quitTask(sock, missionData->iTaskNum, true);
|
||||
}
|
||||
|
||||
void MissionManager::quitTask(CNSocket* sock, int32_t taskNum, bool manual) {
|
||||
void Missions::quitTask(CNSocket* sock, int32_t taskNum, bool manual) {
|
||||
Player* plr = PlayerManager::getPlayer(sock);
|
||||
|
||||
if (Tasks.find(taskNum) == Tasks.end())
|
||||
@ -478,7 +478,7 @@ void MissionManager::quitTask(CNSocket* sock, int32_t taskNum, bool manual) {
|
||||
sock->sendPacket((void*)&response, P_FE2CL_REP_PC_TASK_STOP_SUCC, sizeof(sP_FE2CL_REP_PC_TASK_STOP_SUCC));
|
||||
}
|
||||
|
||||
void MissionManager::updateFusionMatter(CNSocket* sock, int fusion) {
|
||||
void Missions::updateFusionMatter(CNSocket* sock, int fusion) {
|
||||
Player *plr = PlayerManager::getPlayer(sock);
|
||||
|
||||
plr->fusionmatter += fusion;
|
||||
@ -521,7 +521,7 @@ void MissionManager::updateFusionMatter(CNSocket* sock, int fusion) {
|
||||
if (plr->level >= 36)
|
||||
return;
|
||||
|
||||
plr->fusionmatter -= (int)MissionManager::AvatarGrowth[plr->level]["m_iReqBlob_NanoCreate"];
|
||||
plr->fusionmatter -= (int)Missions::AvatarGrowth[plr->level]["m_iReqBlob_NanoCreate"];
|
||||
plr->level++;
|
||||
|
||||
INITSTRUCT(sP_FE2CL_REP_PC_CHANGE_LEVEL_SUCC, response);
|
||||
@ -539,7 +539,7 @@ void MissionManager::updateFusionMatter(CNSocket* sock, int fusion) {
|
||||
PlayerManager::sendToViewable(sock, (void*)&bcast, P_FE2CL_PC_EVENT, sizeof(sP_FE2CL_PC_EVENT));
|
||||
}
|
||||
|
||||
void MissionManager::mobKilled(CNSocket *sock, int mobid, int rolledQItem) {
|
||||
void Missions::mobKilled(CNSocket *sock, int mobid, int rolledQItem) {
|
||||
Player *plr = PlayerManager::getPlayer(sock);
|
||||
|
||||
bool missionmob = false;
|
||||
@ -587,26 +587,26 @@ void MissionManager::mobKilled(CNSocket *sock, int mobid, int rolledQItem) {
|
||||
}
|
||||
}
|
||||
|
||||
void MissionManager::failInstancedMissions(CNSocket* sock) {
|
||||
void Missions::failInstancedMissions(CNSocket* sock) {
|
||||
// loop through all tasks; if the required instance is being left, "fail" the task
|
||||
Player* plr = PlayerManager::getPlayer(sock);
|
||||
for (int i = 0; i < 6; i++) {
|
||||
int taskNum = plr->tasks[i];
|
||||
if (MissionManager::Tasks.find(taskNum) == MissionManager::Tasks.end())
|
||||
if (Missions::Tasks.find(taskNum) == Missions::Tasks.end())
|
||||
continue; // sanity check
|
||||
|
||||
TaskData* task = MissionManager::Tasks[taskNum];
|
||||
TaskData* task = Missions::Tasks[taskNum];
|
||||
if (task->task["m_iRequireInstanceID"] != 0) { // mission is instanced
|
||||
int failTaskID = task->task["m_iFOutgoingTask"];
|
||||
if (failTaskID != 0) {
|
||||
MissionManager::quitTask(sock, taskNum, false);
|
||||
Missions::quitTask(sock, taskNum, false);
|
||||
//plr->tasks[i] = failTaskID; // this causes the client to freak out and send a dupe task
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void MissionManager::init() {
|
||||
void Missions::init() {
|
||||
REGISTER_SHARD_PACKET(P_CL2FE_REQ_PC_TASK_START, taskStart);
|
||||
REGISTER_SHARD_PACKET(P_CL2FE_REQ_PC_TASK_END, taskEnd);
|
||||
REGISTER_SHARD_PACKET(P_CL2FE_REQ_PC_SET_CURRENT_MISSION_ID, setMission);
|
@ -35,7 +35,7 @@ struct TaskData {
|
||||
auto operator[](std::string s) { return task[s]; }
|
||||
};
|
||||
|
||||
namespace MissionManager {
|
||||
namespace Missions {
|
||||
extern std::map<int32_t, Reward*> Rewards;
|
||||
extern std::map<int32_t, TaskData*> Tasks;
|
||||
extern nlohmann::json AvatarGrowth[37];
|
@ -1,8 +1,8 @@
|
||||
#include "MobAI.hpp"
|
||||
#include "Player.hpp"
|
||||
#include "RacingManager.hpp"
|
||||
#include "TransportManager.hpp"
|
||||
#include "NanoManager.hpp"
|
||||
#include "Racing.hpp"
|
||||
#include "Transport.hpp"
|
||||
#include "Nanos.hpp"
|
||||
#include "Combat.hpp"
|
||||
#include "Abilities.hpp"
|
||||
|
||||
@ -19,7 +19,7 @@ bool MobAI::simulateMobs;
|
||||
static void roamingStep(Mob *mob, time_t currTime);
|
||||
|
||||
/*
|
||||
* Dynamic lerp; distinct from TransportManager::lerp(). This one doesn't care about height and
|
||||
* Dynamic lerp; distinct from Transport::lerp(). This one doesn't care about height and
|
||||
* only returns the first step, since the rest will need to be recalculated anyway if chasing player.
|
||||
*/
|
||||
static std::pair<int,int> lerp(int x1, int y1, int x2, int y2, int speed) {
|
||||
@ -130,7 +130,7 @@ bool MobAI::aggroCheck(Mob *mob, time_t currTime) {
|
||||
int mobRange = mob->sightRange;
|
||||
|
||||
if (plr->iConditionBitFlag & CSB_BIT_UP_STEALTH
|
||||
|| RacingManager::EPRaces.find(s) != RacingManager::EPRaces.end())
|
||||
|| Racing::EPRaces.find(s) != Racing::EPRaces.end())
|
||||
mobRange /= 3;
|
||||
|
||||
// 0.33x - 1.66x the range
|
||||
@ -223,10 +223,10 @@ static void dealCorruption(Mob *mob, std::vector<int> targetData, int skillID, i
|
||||
respdata[i].iActiveNanoSlotNum = n;
|
||||
respdata[i].iNanoID = plr->activeNano;
|
||||
|
||||
int style2 = NanoManager::nanoStyle(plr->activeNano);
|
||||
int style2 = Nanos::nanoStyle(plr->activeNano);
|
||||
if (style2 == -1) { // no nano
|
||||
respdata[i].iHitFlag = 8;
|
||||
respdata[i].iDamage = NanoManager::SkillTable[skillID].powerIntensity[0] * PC_MAXHEALTH((int)mob->data["m_iNpcLevel"]) / 1500;
|
||||
respdata[i].iDamage = Nanos::SkillTable[skillID].powerIntensity[0] * PC_MAXHEALTH((int)mob->data["m_iNpcLevel"]) / 1500;
|
||||
} else if (style == style2) {
|
||||
respdata[i].iHitFlag = 8; // tie
|
||||
respdata[i].iDamage = 0;
|
||||
@ -239,12 +239,12 @@ static void dealCorruption(Mob *mob, std::vector<int> targetData, int skillID, i
|
||||
respdata[i].iNanoStamina = plr->Nanos[plr->activeNano].iStamina = 150;
|
||||
// fire damage power disguised as a corruption attack back at the enemy
|
||||
std::vector<int> targetData2 = {1, mob->appearanceData.iNPC_ID, 0, 0, 0};
|
||||
for (auto& pwr : NanoManager::NanoPowers)
|
||||
for (auto& pwr : Nanos::NanoPowers)
|
||||
if (pwr.skillType == EST_DAMAGE)
|
||||
pwr.handle(sock, targetData2, plr->activeNano, skillID, 0, 200);
|
||||
} else {
|
||||
respdata[i].iHitFlag = 16; // lose
|
||||
respdata[i].iDamage = NanoManager::SkillTable[skillID].powerIntensity[0] * PC_MAXHEALTH((int)mob->data["m_iNpcLevel"]) / 1500;
|
||||
respdata[i].iDamage = Nanos::SkillTable[skillID].powerIntensity[0] * PC_MAXHEALTH((int)mob->data["m_iNpcLevel"]) / 1500;
|
||||
respdata[i].iNanoStamina = plr->Nanos[plr->activeNano].iStamina -= 90;
|
||||
if (plr->Nanos[plr->activeNano].iStamina < 0) {
|
||||
respdata[i].bNanoDeactive = 1;
|
||||
@ -305,7 +305,7 @@ static void useAbilities(Mob *mob, time_t currTime) {
|
||||
continue;
|
||||
|
||||
int distance = hypot(mob->hitX - plr->x, mob->hitY - plr->y);
|
||||
if (distance < NanoManager::SkillTable[skillID].effectArea) {
|
||||
if (distance < Nanos::SkillTable[skillID].effectArea) {
|
||||
targetData[0] += 1;
|
||||
targetData[targetData[0]] = plr->iID;
|
||||
if (targetData[0] > 3) // make sure not to have more than 4
|
||||
@ -315,8 +315,8 @@ static void useAbilities(Mob *mob, time_t currTime) {
|
||||
}
|
||||
|
||||
for (auto& pwr : Combat::MobPowers)
|
||||
if (pwr.skillType == NanoManager::SkillTable[skillID].skillType)
|
||||
pwr.handle(mob, targetData, skillID, NanoManager::SkillTable[skillID].durationTime[0], NanoManager::SkillTable[skillID].powerIntensity[0]);
|
||||
if (pwr.skillType == Nanos::SkillTable[skillID].skillType)
|
||||
pwr.handle(mob, targetData, skillID, Nanos::SkillTable[skillID].durationTime[0], Nanos::SkillTable[skillID].powerIntensity[0]);
|
||||
mob->skillStyle = -3; // eruption cooldown
|
||||
mob->nextAttack = currTime + 1000;
|
||||
return;
|
||||
@ -336,10 +336,10 @@ static void useAbilities(Mob *mob, time_t currTime) {
|
||||
int skillID = (int)mob->data["m_iActiveSkill1"];
|
||||
std::vector<int> targetData = {1, plr->iID, 0, 0, 0};
|
||||
for (auto& pwr : Combat::MobPowers)
|
||||
if (pwr.skillType == NanoManager::SkillTable[skillID].skillType) {
|
||||
if (pwr.skillType == Nanos::SkillTable[skillID].skillType) {
|
||||
if (pwr.bitFlag != 0 && (plr->iConditionBitFlag & pwr.bitFlag))
|
||||
return; // prevent debuffing a player twice
|
||||
pwr.handle(mob, targetData, skillID, NanoManager::SkillTable[skillID].durationTime[0], NanoManager::SkillTable[skillID].powerIntensity[0]);
|
||||
pwr.handle(mob, targetData, skillID, Nanos::SkillTable[skillID].durationTime[0], Nanos::SkillTable[skillID].powerIntensity[0]);
|
||||
}
|
||||
mob->nextAttack = currTime + (int)mob->data["m_iDelayTime"] * 100;
|
||||
return;
|
||||
@ -353,7 +353,7 @@ static void useAbilities(Mob *mob, time_t currTime) {
|
||||
pkt.iValue1 = plr->x;
|
||||
pkt.iValue2 = plr->y;
|
||||
pkt.iValue3 = plr->z;
|
||||
mob->skillStyle = NanoManager::nanoStyle(plr->activeNano) - 1;
|
||||
mob->skillStyle = Nanos::nanoStyle(plr->activeNano) - 1;
|
||||
if (mob->skillStyle == -1)
|
||||
mob->skillStyle = 2;
|
||||
if (mob->skillStyle == -2)
|
||||
@ -394,8 +394,8 @@ void MobAI::enterCombat(CNSocket *sock, Mob *mob) {
|
||||
int skillID = (int)mob->data["m_iPassiveBuff"]; // cast passive
|
||||
std::vector<int> targetData = {1, mob->appearanceData.iNPC_ID, 0, 0, 0};
|
||||
for (auto& pwr : Combat::MobPowers)
|
||||
if (pwr.skillType == NanoManager::SkillTable[skillID].skillType)
|
||||
pwr.handle(mob, targetData, skillID, NanoManager::SkillTable[skillID].durationTime[0], NanoManager::SkillTable[skillID].powerIntensity[0]);
|
||||
if (pwr.skillType == Nanos::SkillTable[skillID].skillType)
|
||||
pwr.handle(mob, targetData, skillID, Nanos::SkillTable[skillID].durationTime[0], Nanos::SkillTable[skillID].powerIntensity[0]);
|
||||
|
||||
for (NPCEvent& event : NPCManager::NPCEvents) // trigger an ON_COMBAT
|
||||
if (event.trigger == ON_COMBAT && event.npcType == mob->appearanceData.iNPCType)
|
||||
@ -652,7 +652,7 @@ static void roamingStep(Mob *mob, time_t currTime) {
|
||||
|
||||
/*
|
||||
* mob->nextMovement is also updated whenever the path queue is traversed in
|
||||
* TransportManager::stepNPCPathing() (which ticks at a higher frequency than nextMovement),
|
||||
* Transport::stepNPCPathing() (which ticks at a higher frequency than nextMovement),
|
||||
* so we don't have to check if there's already entries in the queue since we know there won't be.
|
||||
*/
|
||||
if (mob->nextMovement != 0 && currTime < mob->nextMovement)
|
||||
@ -694,9 +694,9 @@ static void roamingStep(Mob *mob, time_t currTime) {
|
||||
WarpLocation from = { mob->appearanceData.iX, mob->appearanceData.iY, mob->appearanceData.iZ };
|
||||
WarpLocation to = { farX, farY, mob->appearanceData.iZ };
|
||||
|
||||
// add a route to the queue; to be processed in TransportManager::stepNPCPathing()
|
||||
TransportManager::lerp(&queue, from, to, speed);
|
||||
TransportManager::NPCQueues[mob->appearanceData.iNPC_ID] = queue;
|
||||
// add a route to the queue; to be processed in Transport::stepNPCPathing()
|
||||
Transport::lerp(&queue, from, to, speed);
|
||||
Transport::NPCQueues[mob->appearanceData.iNPC_ID] = queue;
|
||||
|
||||
if (mob->groupLeader != 0 && mob->groupLeader == mob->appearanceData.iNPC_ID) {
|
||||
// make followers follow this npc.
|
||||
@ -713,8 +713,8 @@ static void roamingStep(Mob *mob, time_t currTime) {
|
||||
Mob* followerMob = Mobs[mob->groupMember[i]];
|
||||
from = { followerMob->appearanceData.iX, followerMob->appearanceData.iY, followerMob->appearanceData.iZ };
|
||||
to = { farX + followerMob->offsetX, farY + followerMob->offsetY, followerMob->appearanceData.iZ };
|
||||
TransportManager::lerp(&queue2, from, to, speed);
|
||||
TransportManager::NPCQueues[followerMob->appearanceData.iNPC_ID] = queue2;
|
||||
Transport::lerp(&queue2, from, to, speed);
|
||||
Transport::NPCQueues[followerMob->appearanceData.iNPC_ID] = queue2;
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -757,8 +757,8 @@ static void retreatStep(Mob *mob, time_t currTime) {
|
||||
// cast a return home heal spell, this is the right way(tm)
|
||||
std::vector<int> targetData = {1, 0, 0, 0, 0};
|
||||
for (auto& pwr : Combat::MobPowers)
|
||||
if (pwr.skillType == NanoManager::SkillTable[110].skillType)
|
||||
pwr.handle(mob, targetData, 110, NanoManager::SkillTable[110].durationTime[0], NanoManager::SkillTable[110].powerIntensity[0]);
|
||||
if (pwr.skillType == Nanos::SkillTable[110].skillType)
|
||||
pwr.handle(mob, targetData, 110, Nanos::SkillTable[110].durationTime[0], Nanos::SkillTable[110].powerIntensity[0]);
|
||||
// clear outlying debuffs
|
||||
clearDebuff(mob);
|
||||
}
|
||||
|
@ -1,6 +1,6 @@
|
||||
#include "CNShardServer.hpp"
|
||||
#include "PlayerManager.hpp"
|
||||
#include "ChatManager.hpp"
|
||||
#include "Chat.hpp"
|
||||
#include "CNStructs.hpp"
|
||||
#include "Monitor.hpp"
|
||||
#include "settings.hpp"
|
||||
@ -64,7 +64,7 @@ outer:
|
||||
}
|
||||
|
||||
// chat
|
||||
for (auto& str : ChatManager::dump) {
|
||||
for (auto& str : Chat::dump) {
|
||||
n = std::snprintf(buff, sizeof(buff), "chat %s\n", str.c_str());
|
||||
|
||||
if (!transmit(it, buff, n))
|
||||
@ -77,7 +77,7 @@ outer:
|
||||
it++;
|
||||
}
|
||||
|
||||
ChatManager::dump.clear();
|
||||
Chat::dump.clear();
|
||||
}
|
||||
|
||||
bool Monitor::acceptConnection(SOCKET fd, uint16_t revents) {
|
||||
|
@ -1,7 +1,7 @@
|
||||
#pragma once
|
||||
|
||||
#include "CNStructs.hpp"
|
||||
#include "ChunkManager.hpp"
|
||||
#include "Chunking.hpp"
|
||||
|
||||
class BaseNPC {
|
||||
public:
|
||||
|
@ -1,13 +1,13 @@
|
||||
#include "NPCManager.hpp"
|
||||
#include "ItemManager.hpp"
|
||||
#include "Items.hpp"
|
||||
#include "settings.hpp"
|
||||
#include "Combat.hpp"
|
||||
#include "MissionManager.hpp"
|
||||
#include "ChunkManager.hpp"
|
||||
#include "NanoManager.hpp"
|
||||
#include "Missions.hpp"
|
||||
#include "Chunking.hpp"
|
||||
#include "Nanos.hpp"
|
||||
#include "TableData.hpp"
|
||||
#include "GroupManager.hpp"
|
||||
#include "RacingManager.hpp"
|
||||
#include "Groups.hpp"
|
||||
#include "Racing.hpp"
|
||||
#include "Vendor.hpp"
|
||||
#include "Abilities.hpp"
|
||||
|
||||
@ -49,16 +49,16 @@ void NPCManager::destroyNPC(int32_t id) {
|
||||
BaseNPC* entity = NPCs[id];
|
||||
|
||||
// sanity check
|
||||
if (!ChunkManager::chunkExists(entity->chunkPos)) {
|
||||
if (!Chunking::chunkExists(entity->chunkPos)) {
|
||||
std::cout << "chunk not found!" << std::endl;
|
||||
return;
|
||||
}
|
||||
|
||||
// remove NPC from the chunk
|
||||
ChunkManager::untrackNPC(entity->chunkPos, id);
|
||||
Chunking::untrackNPC(entity->chunkPos, id);
|
||||
|
||||
// remove from viewable chunks
|
||||
ChunkManager::removeNPCFromChunks(ChunkManager::getViewableChunks(entity->chunkPos), id);
|
||||
Chunking::removeNPCFromChunks(Chunking::getViewableChunks(entity->chunkPos), id);
|
||||
|
||||
// remove from mob manager
|
||||
if (MobAI::Mobs.find(id) != MobAI::Mobs.end())
|
||||
@ -78,14 +78,14 @@ void NPCManager::updateNPCPosition(int32_t id, int X, int Y, int Z, uint64_t I,
|
||||
BaseNPC* npc = NPCs[id];
|
||||
npc->appearanceData.iAngle = angle;
|
||||
ChunkPos oldChunk = npc->chunkPos;
|
||||
ChunkPos newChunk = ChunkManager::chunkPosAt(X, Y, I);
|
||||
ChunkPos newChunk = Chunking::chunkPosAt(X, Y, I);
|
||||
npc->appearanceData.iX = X;
|
||||
npc->appearanceData.iY = Y;
|
||||
npc->appearanceData.iZ = Z;
|
||||
npc->instanceID = I;
|
||||
if (oldChunk == newChunk)
|
||||
return; // didn't change chunks
|
||||
ChunkManager::updateNPCChunk(id, oldChunk, newChunk);
|
||||
Chunking::updateNPCChunk(id, oldChunk, newChunk);
|
||||
}
|
||||
|
||||
void NPCManager::sendToViewable(BaseNPC *npc, void *buf, uint32_t type, size_t size) {
|
||||
@ -104,7 +104,7 @@ static void npcBarkHandler(CNSocket* sock, CNPacketData* data) {
|
||||
sP_CL2FE_REQ_BARKER* req = (sP_CL2FE_REQ_BARKER*)data->buf;
|
||||
|
||||
// get bark IDs from task data
|
||||
TaskData* td = MissionManager::Tasks[req->iMissionTaskID];
|
||||
TaskData* td = Missions::Tasks[req->iMissionTaskID];
|
||||
std::vector<int> barks;
|
||||
for (int i = 0; i < 4; i++) {
|
||||
if (td->task["m_iHBarkerTextID"][i] != 0) // non-zeroes only
|
||||
@ -204,7 +204,7 @@ static void handleWarp(CNSocket* sock, int32_t warpId) {
|
||||
// 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
|
||||
instanceID += ((uint64_t)plr->iIDGroup << 32); // upper 32 bits are leader ID
|
||||
ChunkManager::createInstance(instanceID);
|
||||
Chunking::createInstance(instanceID);
|
||||
|
||||
// save Lair entrance coords as a pseudo-Resurrect 'Em
|
||||
plr->recallX = Warps[warpId].x;
|
||||
@ -261,18 +261,18 @@ static void handleWarp(CNSocket* sock, int32_t warpId) {
|
||||
resp.eIL = 4; // do not take away any items
|
||||
uint64_t fromInstance = plr->instanceID; // pre-warp instance, saved for post-warp
|
||||
plr->instanceID = INSTANCE_OVERWORLD;
|
||||
MissionManager::failInstancedMissions(sock); // fail any instanced missions
|
||||
Missions::failInstancedMissions(sock); // fail any instanced missions
|
||||
sock->sendPacket((void*)&resp, P_FE2CL_REP_PC_WARP_USE_NPC_SUCC, sizeof(sP_FE2CL_REP_PC_WARP_USE_NPC_SUCC));
|
||||
|
||||
ChunkManager::updatePlayerChunk(sock, plr->chunkPos, std::make_tuple(0, 0, 0)); // force player to reload chunks
|
||||
Chunking::updatePlayerChunk(sock, plr->chunkPos, std::make_tuple(0, 0, 0)); // force player to reload chunks
|
||||
PlayerManager::updatePlayerPosition(sock, resp.iX, resp.iY, resp.iZ, INSTANCE_OVERWORLD, plr->angle);
|
||||
|
||||
// remove the player's ongoing race, if any
|
||||
if (RacingManager::EPRaces.find(sock) != RacingManager::EPRaces.end())
|
||||
RacingManager::EPRaces.erase(sock);
|
||||
if (Racing::EPRaces.find(sock) != Racing::EPRaces.end())
|
||||
Racing::EPRaces.erase(sock);
|
||||
|
||||
// post-warp: check if the source instance has no more players in it and delete it if so
|
||||
ChunkManager::destroyInstanceIfEmpty(fromInstance);
|
||||
Chunking::destroyInstanceIfEmpty(fromInstance);
|
||||
}
|
||||
}
|
||||
|
||||
@ -316,8 +316,8 @@ int NPCManager::eggBuffPlayer(CNSocket* sock, int skillId, int eggId, int durati
|
||||
Player* plr = PlayerManager::getPlayer(sock);
|
||||
Player* otherPlr = PlayerManager::getPlayerFromID(plr->iIDGroup);
|
||||
|
||||
int bitFlag = GroupManager::getGroupFlags(otherPlr);
|
||||
int CBFlag = NanoManager::applyBuff(sock, skillId, 1, 3, bitFlag);
|
||||
int bitFlag = Groups::getGroupFlags(otherPlr);
|
||||
int CBFlag = Nanos::applyBuff(sock, skillId, 1, 3, bitFlag);
|
||||
|
||||
size_t resplen;
|
||||
|
||||
@ -339,7 +339,7 @@ int NPCManager::eggBuffPlayer(CNSocket* sock, int skillId, int eggId, int durati
|
||||
memset(respbuf, 0, resplen);
|
||||
skill->eCT = 1;
|
||||
skill->iID = plr->iID;
|
||||
skill->iDamage = PC_MAXHEALTH(plr->level) * NanoManager::SkillTable[skillId].powerIntensity[0] / 1000;
|
||||
skill->iDamage = PC_MAXHEALTH(plr->level) * Nanos::SkillTable[skillId].powerIntensity[0] / 1000;
|
||||
plr->HP -= skill->iDamage;
|
||||
if (plr->HP < 0)
|
||||
plr->HP = 0;
|
||||
@ -349,7 +349,7 @@ int NPCManager::eggBuffPlayer(CNSocket* sock, int skillId, int eggId, int durati
|
||||
memset(respbuf, 0, resplen);
|
||||
skill->eCT = 1;
|
||||
skill->iID = plr->iID;
|
||||
skill->iHealHP = PC_MAXHEALTH(plr->level) * NanoManager::SkillTable[skillId].powerIntensity[0] / 1000;
|
||||
skill->iHealHP = PC_MAXHEALTH(plr->level) * Nanos::SkillTable[skillId].powerIntensity[0] / 1000;
|
||||
plr->HP += skill->iHealHP;
|
||||
if (plr->HP > PC_MAXHEALTH(plr->level))
|
||||
plr->HP = PC_MAXHEALTH(plr->level);
|
||||
@ -364,7 +364,7 @@ int NPCManager::eggBuffPlayer(CNSocket* sock, int skillId, int eggId, int durati
|
||||
|
||||
skillUse->iNPC_ID = eggId;
|
||||
skillUse->iSkillID = skillId;
|
||||
skillUse->eST = NanoManager::SkillTable[skillId].skillType;
|
||||
skillUse->eST = Nanos::SkillTable[skillId].skillType;
|
||||
skillUse->iTargetCnt = 1;
|
||||
|
||||
sock->sendPacket((void*)&respbuf, P_FE2CL_NPC_SKILL_HIT, resplen);
|
||||
@ -397,8 +397,8 @@ static void eggStep(CNServer* serv, time_t currTime) {
|
||||
Player* plr = PlayerManager::getPlayer(sock);
|
||||
Player* otherPlr = PlayerManager::getPlayerFromID(plr->iIDGroup);
|
||||
|
||||
int groupFlags = GroupManager::getGroupFlags(otherPlr);
|
||||
for (auto& pwr : NanoManager::NanoPowers) {
|
||||
int groupFlags = Groups::getGroupFlags(otherPlr);
|
||||
for (auto& pwr : Nanos::NanoPowers) {
|
||||
if (pwr.bitFlag == CBFlag) { // pick the power with the right flag and unbuff
|
||||
INITSTRUCT(sP_FE2CL_PC_BUFF_UPDATE, resp);
|
||||
resp.eCSTB = pwr.timeBuffID;
|
||||
@ -422,7 +422,7 @@ static void eggStep(CNServer* serv, time_t currTime) {
|
||||
|
||||
// check dead eggs and eggs in inactive chunks
|
||||
for (auto egg : Eggs) {
|
||||
if (!egg.second->dead || !ChunkManager::inPopulatedChunks(egg.second->viewableChunks))
|
||||
if (!egg.second->dead || !Chunking::inPopulatedChunks(egg.second->viewableChunks))
|
||||
continue;
|
||||
if (egg.second->deadUntil <= timeStamp) {
|
||||
// respawn it
|
||||
@ -430,7 +430,7 @@ static void eggStep(CNServer* serv, time_t currTime) {
|
||||
egg.second->deadUntil = 0;
|
||||
egg.second->appearanceData.iHP = 400;
|
||||
|
||||
ChunkManager::addNPCToChunks(ChunkManager::getViewableChunks(egg.second->chunkPos), egg.first);
|
||||
Chunking::addNPCToChunks(Chunking::getViewableChunks(egg.second->chunkPos), egg.first);
|
||||
}
|
||||
}
|
||||
|
||||
@ -525,7 +525,7 @@ static void eggPickup(CNSocket* sock, CNPacketData* data) {
|
||||
reward->iFatigue_Level = 1;
|
||||
reward->iItemCnt = 1; // remember to update resplen if you change this
|
||||
|
||||
int slot = ItemManager::findFreeSlot(plr);
|
||||
int slot = Items::findFreeSlot(plr);
|
||||
|
||||
// no space for drop
|
||||
if (slot != -1) {
|
||||
@ -546,7 +546,7 @@ static void eggPickup(CNSocket* sock, CNPacketData* data) {
|
||||
if (egg->summoned)
|
||||
destroyNPC(eggId);
|
||||
else {
|
||||
ChunkManager::removeNPCFromChunks(ChunkManager::getViewableChunks(egg->chunkPos), eggId);
|
||||
Chunking::removeNPCFromChunks(Chunking::getViewableChunks(egg->chunkPos), eggId);
|
||||
egg->dead = true;
|
||||
egg->deadUntil = getTime() + (time_t)type->regen * 1000;
|
||||
egg->appearanceData.iHP = 0;
|
||||
|
@ -1,22 +1,22 @@
|
||||
#include "CNShardServer.hpp"
|
||||
#include "CNStructs.hpp"
|
||||
#include "NanoManager.hpp"
|
||||
#include "Nanos.hpp"
|
||||
#include "PlayerManager.hpp"
|
||||
#include "NPCManager.hpp"
|
||||
#include "Combat.hpp"
|
||||
#include "MissionManager.hpp"
|
||||
#include "GroupManager.hpp"
|
||||
#include "Missions.hpp"
|
||||
#include "Groups.hpp"
|
||||
#include "Abilities.hpp"
|
||||
|
||||
#include <cmath>
|
||||
|
||||
using namespace NanoManager;
|
||||
using namespace Nanos;
|
||||
|
||||
std::map<int32_t, NanoData> NanoManager::NanoTable;
|
||||
std::map<int32_t, NanoTuning> NanoManager::NanoTunings;
|
||||
std::map<int32_t, NanoData> Nanos::NanoTable;
|
||||
std::map<int32_t, NanoTuning> Nanos::NanoTunings;
|
||||
|
||||
#pragma region Helper methods
|
||||
void NanoManager::addNano(CNSocket* sock, int16_t nanoID, int16_t slot, bool spendfm) {
|
||||
void Nanos::addNano(CNSocket* sock, int16_t nanoID, int16_t slot, bool spendfm) {
|
||||
if (nanoID <= 0 || nanoID >= NANO_COUNT)
|
||||
return;
|
||||
|
||||
@ -35,7 +35,7 @@ void NanoManager::addNano(CNSocket* sock, int16_t nanoID, int16_t slot, bool spe
|
||||
plr->level = level;
|
||||
|
||||
if (spendfm)
|
||||
MissionManager::updateFusionMatter(sock, -(int)MissionManager::AvatarGrowth[plr->level-1]["m_iReqBlob_NanoCreate"]);
|
||||
Missions::updateFusionMatter(sock, -(int)Missions::AvatarGrowth[plr->level-1]["m_iReqBlob_NanoCreate"]);
|
||||
#endif
|
||||
|
||||
// Send to client
|
||||
@ -70,7 +70,7 @@ void NanoManager::addNano(CNSocket* sock, int16_t nanoID, int16_t slot, bool spe
|
||||
PlayerManager::sendToViewable(sock, (void*)&resp2, P_FE2CL_REP_PC_CHANGE_LEVEL, sizeof(sP_FE2CL_REP_PC_CHANGE_LEVEL));
|
||||
}
|
||||
|
||||
void NanoManager::summonNano(CNSocket *sock, int slot, bool silent) {
|
||||
void Nanos::summonNano(CNSocket *sock, int slot, bool silent) {
|
||||
INITSTRUCT(sP_FE2CL_REP_NANO_ACTIVE_SUCC, resp);
|
||||
resp.iActiveNanoSlotNum = slot;
|
||||
Player *plr = PlayerManager::getPlayer(sock);
|
||||
@ -159,11 +159,11 @@ static void setNanoSkill(CNSocket* sock, sP_CL2FE_REQ_NANO_TUNE* skill) {
|
||||
}
|
||||
|
||||
#ifndef ACADEMY
|
||||
if (plr->fusionmatter < (int)MissionManager::AvatarGrowth[plr->level]["m_iReqBlob_NanoTune"]) // sanity check
|
||||
if (plr->fusionmatter < (int)Missions::AvatarGrowth[plr->level]["m_iReqBlob_NanoTune"]) // sanity check
|
||||
return;
|
||||
#endif
|
||||
|
||||
plr->fusionmatter -= (int)MissionManager::AvatarGrowth[plr->level]["m_iReqBlob_NanoTune"];
|
||||
plr->fusionmatter -= (int)Missions::AvatarGrowth[plr->level]["m_iReqBlob_NanoTune"];
|
||||
|
||||
int reqItemCount = NanoTunings[skill->iTuneID].reqItemCount;
|
||||
int reqItemID = NanoTunings[skill->iTuneID].reqItems;
|
||||
@ -203,13 +203,13 @@ static void setNanoSkill(CNSocket* sock, sP_CL2FE_REQ_NANO_TUNE* skill) {
|
||||
}
|
||||
|
||||
// 0=A 1=B 2=C -1=Not found
|
||||
int NanoManager::nanoStyle(int nanoID) {
|
||||
int Nanos::nanoStyle(int nanoID) {
|
||||
if (nanoID < 1 || nanoID >= (int)NanoTable.size())
|
||||
return -1;
|
||||
return NanoTable[nanoID].style;
|
||||
}
|
||||
|
||||
bool NanoManager::getNanoBoost(Player* plr) {
|
||||
bool Nanos::getNanoBoost(Player* plr) {
|
||||
for (int i = 0; i < 3; i++)
|
||||
if (plr->equippedNanos[i] == plr->activeNano)
|
||||
if (plr->iConditionBitFlag & (CSB_BIT_STIMPAKSLOT1 << i))
|
||||
@ -431,7 +431,7 @@ static void nanoPotionHandler(CNSocket* sock, CNPacketData* data) {
|
||||
|
||||
}
|
||||
|
||||
void NanoManager::init() {
|
||||
void Nanos::init() {
|
||||
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);
|
@ -15,7 +15,7 @@ struct NanoTuning {
|
||||
int reqItems;
|
||||
};
|
||||
|
||||
namespace NanoManager {
|
||||
namespace Nanos {
|
||||
extern std::map<int32_t, NanoData> NanoTable;
|
||||
extern std::map<int32_t, NanoTuning> NanoTunings;
|
||||
void init();
|
@ -5,7 +5,7 @@
|
||||
|
||||
#include "CNProtocol.hpp"
|
||||
#include "CNStructs.hpp"
|
||||
#include "ChunkManager.hpp"
|
||||
#include "Chunking.hpp"
|
||||
|
||||
#define ACTIVE_MISSION_COUNT 6
|
||||
|
||||
|
@ -1,15 +1,15 @@
|
||||
#include "PlayerManager.hpp"
|
||||
#include "NPCManager.hpp"
|
||||
#include "CNShardServer.hpp"
|
||||
#include "MissionManager.hpp"
|
||||
#include "ItemManager.hpp"
|
||||
#include "NanoManager.hpp"
|
||||
#include "GroupManager.hpp"
|
||||
#include "ChatManager.hpp"
|
||||
#include "Missions.hpp"
|
||||
#include "Items.hpp"
|
||||
#include "Nanos.hpp"
|
||||
#include "Groups.hpp"
|
||||
#include "Chat.hpp"
|
||||
#include "db/Database.hpp"
|
||||
#include "BuddyManager.hpp"
|
||||
#include "Buddies.hpp"
|
||||
#include "Combat.hpp"
|
||||
#include "RacingManager.hpp"
|
||||
#include "Racing.hpp"
|
||||
#include "BuiltinCommands.hpp"
|
||||
#include "Abilities.hpp"
|
||||
|
||||
@ -44,20 +44,20 @@ void PlayerManager::removePlayer(CNSocket* key) {
|
||||
Player* plr = getPlayer(key);
|
||||
uint64_t fromInstance = plr->instanceID;
|
||||
|
||||
GroupManager::groupKickPlayer(plr);
|
||||
Groups::groupKickPlayer(plr);
|
||||
|
||||
// remove player's bullets
|
||||
Combat::Bullets.erase(plr->iID);
|
||||
|
||||
// remove player's ongoing race, if it exists
|
||||
RacingManager::EPRaces.erase(key);
|
||||
Racing::EPRaces.erase(key);
|
||||
|
||||
// save player to DB
|
||||
Database::updatePlayer(plr);
|
||||
|
||||
// remove player visually and untrack
|
||||
ChunkManager::removePlayerFromChunks(ChunkManager::getViewableChunks(plr->chunkPos), key);
|
||||
ChunkManager::untrackPlayer(plr->chunkPos, key);
|
||||
Chunking::removePlayerFromChunks(Chunking::getViewableChunks(plr->chunkPos), key);
|
||||
Chunking::untrackPlayer(plr->chunkPos, key);
|
||||
|
||||
std::cout << getPlayerName(plr) << " has left!" << std::endl;
|
||||
|
||||
@ -67,7 +67,7 @@ void PlayerManager::removePlayer(CNSocket* key) {
|
||||
players.erase(key);
|
||||
|
||||
// if the player was in a lair, clean it up
|
||||
ChunkManager::destroyInstanceIfEmpty(fromInstance);
|
||||
Chunking::destroyInstanceIfEmpty(fromInstance);
|
||||
|
||||
// remove player's buffs from the server
|
||||
auto it = NPCManager::EggBuffs.begin();
|
||||
@ -86,14 +86,14 @@ void PlayerManager::updatePlayerPosition(CNSocket* sock, int X, int Y, int Z, ui
|
||||
Player* plr = getPlayer(sock);
|
||||
plr->angle = angle;
|
||||
ChunkPos oldChunk = plr->chunkPos;
|
||||
ChunkPos newChunk = ChunkManager::chunkPosAt(X, Y, I);
|
||||
ChunkPos newChunk = Chunking::chunkPosAt(X, Y, I);
|
||||
plr->x = X;
|
||||
plr->y = Y;
|
||||
plr->z = Z;
|
||||
plr->instanceID = I;
|
||||
if (oldChunk == newChunk)
|
||||
return; // didn't change chunks
|
||||
ChunkManager::updatePlayerChunk(sock, oldChunk, newChunk);
|
||||
Chunking::updatePlayerChunk(sock, oldChunk, newChunk);
|
||||
}
|
||||
|
||||
void PlayerManager::sendPlayerTo(CNSocket* sock, int X, int Y, int Z, uint64_t I) {
|
||||
@ -108,7 +108,7 @@ void PlayerManager::sendPlayerTo(CNSocket* sock, int X, int Y, int Z, uint64_t I
|
||||
plr->lastAngle = plr->angle;
|
||||
}
|
||||
|
||||
MissionManager::failInstancedMissions(sock); // fail any instanced missions
|
||||
Missions::failInstancedMissions(sock); // fail any instanced missions
|
||||
|
||||
uint64_t fromInstance = plr->instanceID; // pre-warp instance, saved for post-warp
|
||||
|
||||
@ -127,8 +127,8 @@ void PlayerManager::sendPlayerTo(CNSocket* sock, int X, int Y, int Z, uint64_t I
|
||||
INITSTRUCT(sP_FE2CL_INSTANCE_MAP_INFO, pkt);
|
||||
pkt.iInstanceMapNum = (int32_t)MAPNUM(I); // lower 32 bits are mapnum
|
||||
if (I != fromInstance // do not retransmit MAP_INFO on recall
|
||||
&& RacingManager::EPData.find(pkt.iInstanceMapNum) != RacingManager::EPData.end()) {
|
||||
EPInfo* ep = &RacingManager::EPData[pkt.iInstanceMapNum];
|
||||
&& Racing::EPData.find(pkt.iInstanceMapNum) != Racing::EPData.end()) {
|
||||
EPInfo* ep = &Racing::EPData[pkt.iInstanceMapNum];
|
||||
pkt.iEP_ID = ep->EPID;
|
||||
pkt.iMapCoordX_Min = ep->zoneX * 51200;
|
||||
pkt.iMapCoordX_Max = (ep->zoneX + 1) * 51200;
|
||||
@ -146,16 +146,16 @@ void PlayerManager::sendPlayerTo(CNSocket* sock, int X, int Y, int Z, uint64_t I
|
||||
pkt2.iY = Y;
|
||||
pkt2.iZ = Z;
|
||||
sock->sendPacket((void*)&pkt2, P_FE2CL_REP_PC_GOTO_SUCC, sizeof(sP_FE2CL_REP_PC_GOTO_SUCC));
|
||||
ChunkManager::updatePlayerChunk(sock, plr->chunkPos, std::make_tuple(0, 0, 0)); // force player to reload chunks
|
||||
Chunking::updatePlayerChunk(sock, plr->chunkPos, std::make_tuple(0, 0, 0)); // force player to reload chunks
|
||||
updatePlayerPosition(sock, X, Y, Z, I, plr->angle);
|
||||
|
||||
// post-warp: check if the source instance has no more players in it and delete it if so
|
||||
ChunkManager::destroyInstanceIfEmpty(fromInstance);
|
||||
Chunking::destroyInstanceIfEmpty(fromInstance);
|
||||
|
||||
// clean up EPRaces if we were likely in an IZ and left
|
||||
if (fromInstance != INSTANCE_OVERWORLD && fromInstance != I
|
||||
&& RacingManager::EPRaces.find(sock) != RacingManager::EPRaces.end())
|
||||
RacingManager::EPRaces.erase(sock);
|
||||
&& Racing::EPRaces.find(sock) != Racing::EPRaces.end())
|
||||
Racing::EPRaces.erase(sock);
|
||||
}
|
||||
|
||||
void PlayerManager::sendPlayerTo(CNSocket* sock, int X, int Y, int Z) {
|
||||
@ -266,7 +266,7 @@ static void enterPlayer(CNSocket* sock, CNPacketData* data) {
|
||||
if (plr.tasks[i] == 0)
|
||||
break;
|
||||
response.PCLoadData2CL.aRunningQuest[i].m_aCurrTaskID = plr.tasks[i];
|
||||
TaskData &task = *MissionManager::Tasks[plr.tasks[i]];
|
||||
TaskData &task = *Missions::Tasks[plr.tasks[i]];
|
||||
for (int j = 0; j < 3; j++) {
|
||||
response.PCLoadData2CL.aRunningQuest[i].m_aKillNPCID[j] = (int)task["m_iCSUEnemyID"][j];
|
||||
response.PCLoadData2CL.aRunningQuest[i].m_aKillNPCCount[j] = plr.RemainingNPCCount[i][j];
|
||||
@ -307,25 +307,25 @@ static void enterPlayer(CNSocket* sock, CNPacketData* data) {
|
||||
sock->sendPacket((void*)&response, P_FE2CL_REP_PC_ENTER_SUCC, sizeof(sP_FE2CL_REP_PC_ENTER_SUCC));
|
||||
|
||||
// transmit MOTD after entering the game, so the client hopefully changes modes on time
|
||||
ChatManager::sendServerMessage(sock, settings::MOTDSTRING);
|
||||
Chat::sendServerMessage(sock, settings::MOTDSTRING);
|
||||
|
||||
addPlayer(sock, plr);
|
||||
// check if there is an expiring vehicle
|
||||
ItemManager::checkItemExpire(sock, getPlayer(sock));
|
||||
Items::checkItemExpire(sock, getPlayer(sock));
|
||||
|
||||
// set player equip stats
|
||||
ItemManager::setItemStats(getPlayer(sock));
|
||||
Items::setItemStats(getPlayer(sock));
|
||||
|
||||
MissionManager::failInstancedMissions(sock);
|
||||
Missions::failInstancedMissions(sock);
|
||||
|
||||
sendNanoBookSubset(sock);
|
||||
|
||||
// initial buddy sync
|
||||
BuddyManager::refreshBuddyList(sock);
|
||||
Buddies::refreshBuddyList(sock);
|
||||
|
||||
for (auto& pair : players)
|
||||
if (pair.second->notify)
|
||||
ChatManager::sendServerMessage(pair.first, "[ADMIN]" + getPlayerName(&plr) + " has joined.");
|
||||
Chat::sendServerMessage(pair.first, "[ADMIN]" + getPlayerName(&plr) + " has joined.");
|
||||
}
|
||||
|
||||
void PlayerManager::sendToViewable(CNSocket* sock, void* buf, uint32_t type, size_t size) {
|
||||
@ -411,7 +411,7 @@ static void revivePlayer(CNSocket* sock, CNPacketData* data) {
|
||||
// nano revive
|
||||
plr->Nanos[plr->activeNano].iStamina = 0;
|
||||
plr->HP = PC_MAXHEALTH(plr->level);
|
||||
NanoManager::applyBuff(sock, plr->Nanos[plr->activeNano].iSkillID, 2, 1, 0);
|
||||
Nanos::applyBuff(sock, plr->Nanos[plr->activeNano].iSkillID, 2, 1, 0);
|
||||
} else if (reviveData->iRegenType == 4) {
|
||||
plr->HP = PC_MAXHEALTH(plr->level);
|
||||
} else {
|
||||
@ -471,7 +471,7 @@ static void revivePlayer(CNSocket* sock, CNPacketData* data) {
|
||||
|
||||
Player *otherPlr = getPlayerFromID(plr->iIDGroup);
|
||||
if (otherPlr != nullptr) {
|
||||
int bitFlag = GroupManager::getGroupFlags(otherPlr);
|
||||
int bitFlag = Groups::getGroupFlags(otherPlr);
|
||||
resp2.PCRegenDataForOtherPC.iConditionBitFlag = plr->iConditionBitFlag = plr->iSelfConditionBitFlag | bitFlag;
|
||||
|
||||
resp2.PCRegenDataForOtherPC.iPCState = plr->iPCState;
|
||||
@ -484,7 +484,7 @@ static void revivePlayer(CNSocket* sock, CNPacketData* data) {
|
||||
if (!move)
|
||||
return;
|
||||
|
||||
ChunkManager::updatePlayerChunk(sock, plr->chunkPos, std::make_tuple(0, 0, 0)); // force player to reload chunks
|
||||
Chunking::updatePlayerChunk(sock, plr->chunkPos, std::make_tuple(0, 0, 0)); // force player to reload chunks
|
||||
updatePlayerPosition(sock, x, y, z, plr->instanceID, plr->angle);
|
||||
}
|
||||
|
||||
@ -512,7 +512,7 @@ static void enterPlayerVehicle(CNSocket* sock, CNPacketData* data) {
|
||||
if (expired) {
|
||||
plr->toRemoveVehicle.eIL = 0;
|
||||
plr->toRemoveVehicle.iSlotNum = 8;
|
||||
ItemManager::checkItemExpire(sock, plr);
|
||||
Items::checkItemExpire(sock, plr);
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -558,11 +558,11 @@ static void changePlayerGuide(CNSocket *sock, CNPacketData *data) {
|
||||
// remove all active missions
|
||||
for (int i = 0; i < ACTIVE_MISSION_COUNT; i++) {
|
||||
if (plr->tasks[i] != 0)
|
||||
MissionManager::quitTask(sock, plr->tasks[i], true);
|
||||
Missions::quitTask(sock, plr->tasks[i], true);
|
||||
}
|
||||
|
||||
// start Blossom nano mission if applicable
|
||||
MissionManager::updateFusionMatter(sock, 0);
|
||||
Missions::updateFusionMatter(sock, 0);
|
||||
}
|
||||
// save it on player
|
||||
plr->mentor = pkt->iMentor;
|
||||
|
@ -4,7 +4,7 @@
|
||||
#include "CNProtocol.hpp"
|
||||
#include "CNStructs.hpp"
|
||||
#include "CNShardServer.hpp"
|
||||
#include "ChunkManager.hpp"
|
||||
#include "Chunking.hpp"
|
||||
|
||||
#include <utility>
|
||||
#include <map>
|
||||
|
@ -1,17 +1,17 @@
|
||||
#include "CNShardServer.hpp"
|
||||
#include "CNStructs.hpp"
|
||||
#include "RacingManager.hpp"
|
||||
#include "Racing.hpp"
|
||||
#include "PlayerManager.hpp"
|
||||
#include "MissionManager.hpp"
|
||||
#include "ItemManager.hpp"
|
||||
#include "Missions.hpp"
|
||||
#include "Items.hpp"
|
||||
#include "db/Database.hpp"
|
||||
#include "NPCManager.hpp"
|
||||
|
||||
using namespace RacingManager;
|
||||
using namespace Racing;
|
||||
|
||||
std::map<int32_t, EPInfo> RacingManager::EPData;
|
||||
std::map<CNSocket*, EPRace> RacingManager::EPRaces;
|
||||
std::map<int32_t, std::pair<std::vector<int>, std::vector<int>>> RacingManager::EPRewards;
|
||||
std::map<int32_t, EPInfo> Racing::EPData;
|
||||
std::map<CNSocket*, EPRace> Racing::EPRaces;
|
||||
std::map<int32_t, std::pair<std::vector<int>, std::vector<int>>> Racing::EPRewards;
|
||||
|
||||
static void racingStart(CNSocket* sock, CNPacketData* data) {
|
||||
if (data->size != sizeof(sP_CL2FE_REQ_EP_RACE_START))
|
||||
@ -135,14 +135,14 @@ static void racingEnd(CNSocket* sock, CNPacketData* data) {
|
||||
resp.iEPRaceMode = EPRaces[sock].mode;
|
||||
resp.iEPRewardFM = fm;
|
||||
|
||||
MissionManager::updateFusionMatter(sock, resp.iEPRewardFM);
|
||||
Missions::updateFusionMatter(sock, resp.iEPRewardFM);
|
||||
|
||||
resp.iFusionMatter = plr->fusionmatter;
|
||||
resp.iFatigue = 50;
|
||||
resp.iFatigue_Level = 1;
|
||||
|
||||
sItemReward reward;
|
||||
reward.iSlotNum = ItemManager::findFreeSlot(plr);
|
||||
reward.iSlotNum = Items::findFreeSlot(plr);
|
||||
reward.eIL = 1;
|
||||
sItemBase item;
|
||||
item.iID = rankRewards->at(rank); // rank scores and rewards line up
|
||||
@ -160,7 +160,7 @@ static void racingEnd(CNSocket* sock, CNPacketData* data) {
|
||||
sock->sendPacket((void*)&resp, P_FE2CL_REP_EP_RACE_END_SUCC, sizeof(sP_FE2CL_REP_EP_RACE_END_SUCC));
|
||||
}
|
||||
|
||||
void RacingManager::init() {
|
||||
void Racing::init() {
|
||||
REGISTER_SHARD_PACKET(P_CL2FE_REQ_EP_RACE_START, racingStart);
|
||||
REGISTER_SHARD_PACKET(P_CL2FE_REQ_EP_GET_RING, racingGetPod);
|
||||
REGISTER_SHARD_PACKET(P_CL2FE_REQ_EP_RACE_CANCEL, racingCancel);
|
@ -11,7 +11,7 @@ struct EPRace {
|
||||
time_t startTime;
|
||||
};
|
||||
|
||||
namespace RacingManager {
|
||||
namespace Racing {
|
||||
extern std::map<int32_t, EPInfo> EPData;
|
||||
extern std::map<CNSocket*, EPRace> EPRaces;
|
||||
extern std::map<int32_t, std::pair<std::vector<int>, std::vector<int>>> EPRewards;
|
@ -1,12 +1,12 @@
|
||||
#include "TableData.hpp"
|
||||
#include "NPCManager.hpp"
|
||||
#include "TransportManager.hpp"
|
||||
#include "ItemManager.hpp"
|
||||
#include "Transport.hpp"
|
||||
#include "Items.hpp"
|
||||
#include "settings.hpp"
|
||||
#include "MissionManager.hpp"
|
||||
#include "ChunkManager.hpp"
|
||||
#include "NanoManager.hpp"
|
||||
#include "RacingManager.hpp"
|
||||
#include "Missions.hpp"
|
||||
#include "Chunking.hpp"
|
||||
#include "Nanos.hpp"
|
||||
#include "Racing.hpp"
|
||||
#include "Vendor.hpp"
|
||||
#include "Abilities.hpp"
|
||||
|
||||
@ -48,11 +48,11 @@ static void constructPathSkyway(nlohmann::json::iterator _pathData) {
|
||||
for (_point++; _point != pathPoints.end(); _point++) {
|
||||
point = _point.value();
|
||||
WarpLocation coords = { point["iX"] , point["iY"] , point["iZ"] };
|
||||
TransportManager::lerp(&points, last, coords, pathData["iMonkeySpeed"]);
|
||||
Transport::lerp(&points, last, coords, pathData["iMonkeySpeed"]);
|
||||
points.push(coords); // add keyframe to the queue
|
||||
last = coords; // update start pos
|
||||
}
|
||||
TransportManager::SkywayPaths[pathData["iRouteID"]] = points;
|
||||
Transport::SkywayPaths[pathData["iRouteID"]] = points;
|
||||
}
|
||||
|
||||
static void constructPathNPC(nlohmann::json::iterator _pathData, int32_t id=0) {
|
||||
@ -69,7 +69,7 @@ static void constructPathNPC(nlohmann::json::iterator _pathData, int32_t id=0) {
|
||||
for(int i = 0; i < stopTime + 1; i++) // repeat point if it's a stop
|
||||
points.push(from); // add point A to the queue
|
||||
WarpLocation to = { point["iX"] , point["iY"] , point["iZ"] }; // point B coords
|
||||
TransportManager::lerp(&points, from, to, pathData["iBaseSpeed"]); // lerp from A to B
|
||||
Transport::lerp(&points, from, to, pathData["iBaseSpeed"]); // lerp from A to B
|
||||
from = to; // update point A
|
||||
stopTime = point["stop"];
|
||||
}
|
||||
@ -77,7 +77,7 @@ static void constructPathNPC(nlohmann::json::iterator _pathData, int32_t id=0) {
|
||||
if (id == 0)
|
||||
id = pathData["iNPCID"];
|
||||
|
||||
TransportManager::NPCQueues[id] = points;
|
||||
Transport::NPCQueues[id] = points;
|
||||
}
|
||||
|
||||
/*
|
||||
@ -96,7 +96,7 @@ static void loadPaths(int* nextId) {
|
||||
for (nlohmann::json::iterator skywayPath = pathDataSkyway.begin(); skywayPath != pathDataSkyway.end(); skywayPath++) {
|
||||
constructPathSkyway(skywayPath);
|
||||
}
|
||||
std::cout << "[INFO] Loaded " << TransportManager::SkywayPaths.size() << " skyway paths" << std::endl;
|
||||
std::cout << "[INFO] Loaded " << Transport::SkywayPaths.size() << " skyway paths" << std::endl;
|
||||
|
||||
// slider circuit
|
||||
nlohmann::json pathDataSlider = pathData["slider"];
|
||||
@ -121,7 +121,7 @@ static void loadPaths(int* nextId) {
|
||||
} else if (point["stop"]) { // point B is a stop
|
||||
curve = 0.375f;//0.35f;
|
||||
}
|
||||
TransportManager::lerp(&route, from, to, SLIDER_SPEED * curve, 1); // lerp from A to B (arbitrary speed)
|
||||
Transport::lerp(&route, from, to, SLIDER_SPEED * curve, 1); // lerp from A to B (arbitrary speed)
|
||||
from = to; // update point A
|
||||
stopTime = point["stop"] ? SLIDER_STOP_TICKS : 0; // set stop ticks for next point A
|
||||
}
|
||||
@ -141,7 +141,7 @@ static void loadPaths(int* nextId) {
|
||||
BaseNPC* slider = new BaseNPC(point.x, point.y, point.z, 0, INSTANCE_OVERWORLD, 1, (*nextId)++, NPC_BUS);
|
||||
NPCManager::NPCs[slider->appearanceData.iNPC_ID] = slider;
|
||||
NPCManager::updateNPCPosition(slider->appearanceData.iNPC_ID, slider->appearanceData.iX, slider->appearanceData.iY, slider->appearanceData.iZ, INSTANCE_OVERWORLD, 0);
|
||||
TransportManager::NPCQueues[slider->appearanceData.iNPC_ID] = route;
|
||||
Transport::NPCQueues[slider->appearanceData.iNPC_ID] = route;
|
||||
}
|
||||
// rotate
|
||||
route.pop();
|
||||
@ -177,7 +177,7 @@ static void loadPaths(int* nextId) {
|
||||
}
|
||||
}
|
||||
}
|
||||
std::cout << "[INFO] Loaded " << TransportManager::NPCQueues.size() << " NPC paths" << std::endl;
|
||||
std::cout << "[INFO] Loaded " << Transport::NPCQueues.size() << " NPC paths" << std::endl;
|
||||
}
|
||||
catch (const std::exception& err) {
|
||||
std::cerr << "[FATAL] Malformed paths.json file! Reason:" << err.what() << std::endl;
|
||||
@ -206,7 +206,7 @@ static void loadDrops() {
|
||||
for (nlohmann::json::iterator _cratesRatio = dropChance["CratesRatio"].begin(); _cratesRatio != dropChance["CratesRatio"].end(); _cratesRatio++) {
|
||||
toAdd.cratesRatio.push_back((int)_cratesRatio.value());
|
||||
}
|
||||
ItemManager::MobDropChances[(int)dropChance["Type"]] = toAdd;
|
||||
Items::MobDropChances[(int)dropChance["Type"]] = toAdd;
|
||||
}
|
||||
|
||||
// MobDrops
|
||||
@ -220,21 +220,21 @@ static void loadDrops() {
|
||||
|
||||
toAdd.dropChanceType = (int)drop["DropChance"];
|
||||
// Check if DropChance exists
|
||||
if (ItemManager::MobDropChances.find(toAdd.dropChanceType) == ItemManager::MobDropChances.end()) {
|
||||
if (Items::MobDropChances.find(toAdd.dropChanceType) == Items::MobDropChances.end()) {
|
||||
throw TableException(" MobDropChance not found: " + std::to_string((toAdd.dropChanceType)));
|
||||
}
|
||||
// Check if number of crates is correct
|
||||
if (!(ItemManager::MobDropChances[(int)drop["DropChance"]].cratesRatio.size() == toAdd.crateIDs.size())) {
|
||||
if (!(Items::MobDropChances[(int)drop["DropChance"]].cratesRatio.size() == toAdd.crateIDs.size())) {
|
||||
throw TableException(" DropType " + std::to_string((int)drop["DropType"]) + " contains invalid number of crates");
|
||||
}
|
||||
|
||||
toAdd.taros = (int)drop["Taros"];
|
||||
toAdd.fm = (int)drop["FM"];
|
||||
toAdd.boosts = (int)drop["Boosts"];
|
||||
ItemManager::MobDrops[(int)drop["DropType"]] = toAdd;
|
||||
Items::MobDrops[(int)drop["DropType"]] = toAdd;
|
||||
}
|
||||
|
||||
std::cout << "[INFO] Loaded " << ItemManager::MobDrops.size() << " Mob Drop Types"<< std::endl;
|
||||
std::cout << "[INFO] Loaded " << Items::MobDrops.size() << " Mob Drop Types"<< std::endl;
|
||||
|
||||
// Rarity Ratios
|
||||
nlohmann::json rarities = dropData["RarityRatios"];
|
||||
@ -244,7 +244,7 @@ static void loadDrops() {
|
||||
for (nlohmann::json::iterator _ratio = rarity["Ratio"].begin(); _ratio != rarity["Ratio"].end(); _ratio++){
|
||||
toAdd.push_back((int)_ratio.value());
|
||||
}
|
||||
ItemManager::RarityRatios[(int)rarity["Type"]] = toAdd;
|
||||
Items::RarityRatios[(int)rarity["Type"]] = toAdd;
|
||||
}
|
||||
|
||||
// Crates
|
||||
@ -256,7 +256,7 @@ static void loadDrops() {
|
||||
for (nlohmann::json::iterator _itemSet = crate["ItemSets"].begin(); _itemSet != crate["ItemSets"].end(); _itemSet++) {
|
||||
toAdd.itemSets.push_back((int)_itemSet.value());
|
||||
}
|
||||
ItemManager::Crates[(int)crate["Id"]] = toAdd;
|
||||
Items::Crates[(int)crate["Id"]] = toAdd;
|
||||
}
|
||||
|
||||
// Crate Items
|
||||
@ -267,21 +267,21 @@ static void loadDrops() {
|
||||
std::pair<int32_t, int32_t> itemSetkey = std::make_pair((int)item["ItemSet"], (int)item["Rarity"]);
|
||||
std::pair<int32_t, int32_t> itemDataKey = std::make_pair((int)item["Id"], (int)item["Type"]);
|
||||
|
||||
if (ItemManager::ItemData.find(itemDataKey) == ItemManager::ItemData.end()) {
|
||||
if (Items::ItemData.find(itemDataKey) == Items::ItemData.end()) {
|
||||
char buff[255];
|
||||
sprintf(buff, "Unknown item with Id %d and Type %d", (int)item["Id"], (int)item["Type"]);
|
||||
throw TableException(std::string(buff));
|
||||
}
|
||||
|
||||
std::map<std::pair<int32_t, int32_t>, ItemManager::Item>::iterator toAdd = ItemManager::ItemData.find(itemDataKey);
|
||||
std::map<std::pair<int32_t, int32_t>, Items::Item>::iterator toAdd = Items::ItemData.find(itemDataKey);
|
||||
|
||||
// if item collection doesn't exist, start a new one
|
||||
if (ItemManager::CrateItems.find(itemSetkey) == ItemManager::CrateItems.end()) {
|
||||
std::vector<std::map<std::pair<int32_t, int32_t>, ItemManager::Item>::iterator> vector;
|
||||
if (Items::CrateItems.find(itemSetkey) == Items::CrateItems.end()) {
|
||||
std::vector<std::map<std::pair<int32_t, int32_t>, Items::Item>::iterator> vector;
|
||||
vector.push_back(toAdd);
|
||||
ItemManager::CrateItems[itemSetkey] = vector;
|
||||
Items::CrateItems[itemSetkey] = vector;
|
||||
} else // else add a new element to existing collection
|
||||
ItemManager::CrateItems[itemSetkey].push_back(toAdd);
|
||||
Items::CrateItems[itemSetkey].push_back(toAdd);
|
||||
|
||||
itemCount++;
|
||||
}
|
||||
@ -291,7 +291,7 @@ static void loadDrops() {
|
||||
|
||||
for (nlohmann::json::iterator _capsule = capsules.begin(); _capsule != capsules.end(); _capsule++) {
|
||||
auto capsule = _capsule.value();
|
||||
ItemManager::NanoCapsules[(int)capsule["Crate"]] = (int)capsule["Nano"];
|
||||
Items::NanoCapsules[(int)capsule["Crate"]] = (int)capsule["Nano"];
|
||||
}
|
||||
#endif
|
||||
nlohmann::json codes = dropData["CodeItems"];
|
||||
@ -300,13 +300,13 @@ static void loadDrops() {
|
||||
std::string codeStr = code["Code"];
|
||||
std::pair<int32_t, int32_t> item = std::make_pair((int)code["Id"], (int)code["Type"]);
|
||||
|
||||
if (ItemManager::CodeItems.find(codeStr) == ItemManager::CodeItems.end())
|
||||
ItemManager::CodeItems[codeStr] = std::vector<std::pair<int32_t, int32_t>>();
|
||||
if (Items::CodeItems.find(codeStr) == Items::CodeItems.end())
|
||||
Items::CodeItems[codeStr] = std::vector<std::pair<int32_t, int32_t>>();
|
||||
|
||||
ItemManager::CodeItems[codeStr].push_back(item);
|
||||
Items::CodeItems[codeStr].push_back(item);
|
||||
}
|
||||
|
||||
std::cout << "[INFO] Loaded " << ItemManager::Crates.size() << " Crates containing "
|
||||
std::cout << "[INFO] Loaded " << Items::Crates.size() << " Crates containing "
|
||||
<< itemCount << " items" << std::endl;
|
||||
|
||||
// Racing rewards
|
||||
@ -317,7 +317,7 @@ static void loadDrops() {
|
||||
|
||||
// find the instance data corresponding to the EPID
|
||||
int EPMap = -1;
|
||||
for (auto it = RacingManager::EPData.begin(); it != RacingManager::EPData.end(); it++) {
|
||||
for (auto it = Racing::EPData.begin(); it != Racing::EPData.end(); it++) {
|
||||
if (it->second.EPID == raceEPID) {
|
||||
EPMap = it->first;
|
||||
}
|
||||
@ -329,7 +329,7 @@ static void loadDrops() {
|
||||
}
|
||||
|
||||
// time limit isn't stored in the XDT, so we include it in the reward table instead
|
||||
RacingManager::EPData[EPMap].maxTime = race["TimeLimit"];
|
||||
Racing::EPData[EPMap].maxTime = race["TimeLimit"];
|
||||
|
||||
// score cutoffs
|
||||
std::vector<int> rankScores;
|
||||
@ -349,10 +349,10 @@ static void loadDrops() {
|
||||
throw TableException(std::string(buff));
|
||||
}
|
||||
|
||||
RacingManager::EPRewards[raceEPID] = std::make_pair(rankScores, rankRewards);
|
||||
Racing::EPRewards[raceEPID] = std::make_pair(rankScores, rankRewards);
|
||||
}
|
||||
|
||||
std::cout << "[INFO] Loaded rewards for " << RacingManager::EPRewards.size() << " IZ races" << std::endl;
|
||||
std::cout << "[INFO] Loaded rewards for " << Racing::EPRewards.size() << " IZ races" << std::endl;
|
||||
|
||||
}
|
||||
catch (const std::exception& err) {
|
||||
@ -620,17 +620,17 @@ void TableData::init() {
|
||||
for (nlohmann::json::iterator _tLoc = transLocData.begin(); _tLoc != transLocData.end(); _tLoc++) {
|
||||
auto tLoc = _tLoc.value();
|
||||
TransportLocation transLoc = { tLoc["m_iNPCID"], tLoc["m_iXpos"], tLoc["m_iYpos"], tLoc["m_iZpos"] };
|
||||
TransportManager::Locations[tLoc["m_iLocationID"]] = transLoc;
|
||||
Transport::Locations[tLoc["m_iLocationID"]] = transLoc;
|
||||
}
|
||||
std::cout << "[INFO] Loaded " << TransportManager::Locations.size() << " S.C.A.M.P.E.R. locations" << std::endl;
|
||||
std::cout << "[INFO] Loaded " << Transport::Locations.size() << " S.C.A.M.P.E.R. locations" << std::endl;
|
||||
|
||||
for (nlohmann::json::iterator _tRoute = transRouteData.begin(); _tRoute != transRouteData.end(); _tRoute++) {
|
||||
auto tRoute = _tRoute.value();
|
||||
TransportRoute transRoute = { tRoute["m_iMoveType"], tRoute["m_iStartLocation"], tRoute["m_iEndLocation"],
|
||||
tRoute["m_iCost"] , tRoute["m_iSpeed"], tRoute["m_iRouteNum"] };
|
||||
TransportManager::Routes[tRoute["m_iVehicleID"]] = transRoute;
|
||||
Transport::Routes[tRoute["m_iVehicleID"]] = transRoute;
|
||||
}
|
||||
std::cout << "[INFO] Loaded " << TransportManager::Routes.size() << " transportation routes" << std::endl;
|
||||
std::cout << "[INFO] Loaded " << Transport::Routes.size() << " transportation routes" << std::endl;
|
||||
|
||||
// load mission-related data
|
||||
nlohmann::json tasks = xdtData["m_pMissionTable"]["m_pMissionData"];
|
||||
@ -644,11 +644,11 @@ void TableData::init() {
|
||||
Reward *rew = new Reward(_rew["m_iMissionRewardID"], _rew["m_iMissionRewarItemType"],
|
||||
_rew["m_iMissionRewardItemID"], _rew["m_iCash"], _rew["m_iFusionMatter"]);
|
||||
|
||||
MissionManager::Rewards[task["m_iHTaskID"]] = rew;
|
||||
Missions::Rewards[task["m_iHTaskID"]] = rew;
|
||||
}
|
||||
|
||||
// everything else lol. see TaskData comment.
|
||||
MissionManager::Tasks[task["m_iHTaskID"]] = new TaskData(task);
|
||||
Missions::Tasks[task["m_iHTaskID"]] = new TaskData(task);
|
||||
}
|
||||
|
||||
std::cout << "[INFO] Loaded mission-related data" << std::endl;
|
||||
@ -669,7 +669,7 @@ void TableData::init() {
|
||||
for (nlohmann::json::iterator _item = itemSet.begin(); _item != itemSet.end(); _item++) {
|
||||
auto item = _item.value();
|
||||
int itemID = item["m_iItemNumber"];
|
||||
INITSTRUCT(ItemManager::Item, itemData);
|
||||
INITSTRUCT(Items::Item, itemData);
|
||||
itemData.tradeable = item["m_iTradeAble"] == 1;
|
||||
itemData.sellable = item["m_iSellAble"] == 1;
|
||||
itemData.buyPrice = item["m_iItemPrice"];
|
||||
@ -687,18 +687,18 @@ void TableData::init() {
|
||||
} else {
|
||||
itemData.rarity = 1;
|
||||
}
|
||||
ItemManager::ItemData[std::make_pair(itemID, i)] = itemData;
|
||||
Items::ItemData[std::make_pair(itemID, i)] = itemData;
|
||||
}
|
||||
}
|
||||
|
||||
std::cout << "[INFO] Loaded " << ItemManager::ItemData.size() << " items" << std::endl;
|
||||
std::cout << "[INFO] Loaded " << Items::ItemData.size() << " items" << std::endl;
|
||||
|
||||
// load player limits from m_pAvatarTable.m_pAvatarGrowData
|
||||
|
||||
nlohmann::json growth = xdtData["m_pAvatarTable"]["m_pAvatarGrowData"];
|
||||
|
||||
for (int i = 0; i < 37; i++) {
|
||||
MissionManager::AvatarGrowth[i] = growth[i];
|
||||
Missions::AvatarGrowth[i] = growth[i];
|
||||
}
|
||||
|
||||
// load vendor listings
|
||||
@ -718,10 +718,10 @@ void TableData::init() {
|
||||
for (nlohmann::json::iterator croc = crocs.begin(); croc != crocs.end(); croc++) {
|
||||
CrocPotEntry crocEntry = { croc.value()["m_iStatConstant"], croc.value()["m_iLookConstant"], croc.value()["m_fLevelGapStandard"],
|
||||
croc.value()["m_fSameGrade"], croc.value()["m_fOneGrade"], croc.value()["m_fTwoGrade"], croc.value()["m_fThreeGrade"] };
|
||||
ItemManager::CrocPotTable[croc.value()["m_iLevelGap"]] = crocEntry;
|
||||
Items::CrocPotTable[croc.value()["m_iLevelGap"]] = crocEntry;
|
||||
}
|
||||
|
||||
std::cout << "[INFO] Loaded " << ItemManager::CrocPotTable.size() << " croc pot value sets" << std::endl;
|
||||
std::cout << "[INFO] Loaded " << Items::CrocPotTable.size() << " croc pot value sets" << std::endl;
|
||||
|
||||
// load nano info
|
||||
nlohmann::json nanoInfo = xdtData["m_pNanoTable"]["m_pNanoData"];
|
||||
@ -729,10 +729,10 @@ void TableData::init() {
|
||||
auto nano = _nano.value();
|
||||
NanoData nanoData;
|
||||
nanoData.style = nano["m_iStyle"];
|
||||
NanoManager::NanoTable[NanoManager::NanoTable.size()] = nanoData;
|
||||
Nanos::NanoTable[Nanos::NanoTable.size()] = nanoData;
|
||||
}
|
||||
|
||||
std::cout << "[INFO] Loaded " << NanoManager::NanoTable.size() << " nanos" << std::endl;
|
||||
std::cout << "[INFO] Loaded " << Nanos::NanoTable.size() << " nanos" << std::endl;
|
||||
|
||||
nlohmann::json nanoTuneInfo = xdtData["m_pNanoTable"]["m_pNanoTuneData"];
|
||||
for (nlohmann::json::iterator _nano = nanoTuneInfo.begin(); _nano != nanoTuneInfo.end(); _nano++) {
|
||||
@ -740,10 +740,10 @@ void TableData::init() {
|
||||
NanoTuning nanoData;
|
||||
nanoData.reqItems = nano["m_iReqItemID"];
|
||||
nanoData.reqItemCount = nano["m_iReqItemCount"];
|
||||
NanoManager::NanoTunings[nano["m_iSkillID"]] = nanoData;
|
||||
Nanos::NanoTunings[nano["m_iSkillID"]] = nanoData;
|
||||
}
|
||||
|
||||
std::cout << "[INFO] Loaded " << NanoManager::NanoTable.size() << " nano tunings" << std::endl;
|
||||
std::cout << "[INFO] Loaded " << Nanos::NanoTable.size() << " nano tunings" << std::endl;
|
||||
|
||||
// load nano powers
|
||||
nlohmann::json skills = xdtData["m_pSkillTable"]["m_pSkillData"];
|
||||
@ -756,10 +756,10 @@ void TableData::init() {
|
||||
skillData.durationTime[i] = skills["m_iDurationTime"][i];
|
||||
skillData.powerIntensity[i] = skills["m_iValueA"][i];
|
||||
}
|
||||
NanoManager::SkillTable[skills["m_iSkillNumber"]] = skillData;
|
||||
Nanos::SkillTable[skills["m_iSkillNumber"]] = skillData;
|
||||
}
|
||||
|
||||
std::cout << "[INFO] Loaded " << NanoManager::SkillTable.size() << " nano skills" << std::endl;
|
||||
std::cout << "[INFO] Loaded " << Nanos::SkillTable.size() << " nano skills" << std::endl;
|
||||
|
||||
// load EP data
|
||||
nlohmann::json instances = xdtData["m_pInstanceTable"]["m_pInstanceData"];
|
||||
@ -767,10 +767,10 @@ void TableData::init() {
|
||||
for (nlohmann::json::iterator _instance = instances.begin(); _instance != instances.end(); _instance++) {
|
||||
auto instance = _instance.value();
|
||||
EPInfo epInfo = {instance["m_iZoneX"], instance["m_iZoneY"], instance["m_iIsEP"], (int)instance["m_ScoreMax"]};
|
||||
RacingManager::EPData[instance["m_iInstanceNameID"]] = epInfo;
|
||||
Racing::EPData[instance["m_iInstanceNameID"]] = epInfo;
|
||||
}
|
||||
|
||||
std::cout << "[INFO] Loaded " << RacingManager::EPData.size() << " instances" << std::endl;
|
||||
std::cout << "[INFO] Loaded " << Racing::EPData.size() << " instances" << std::endl;
|
||||
|
||||
}
|
||||
catch (const std::exception& err) {
|
||||
|
@ -1,6 +1,6 @@
|
||||
#pragma once
|
||||
|
||||
#include "ItemManager.hpp"
|
||||
#include "Items.hpp"
|
||||
|
||||
namespace Trading {
|
||||
void init();
|
||||
|
@ -1,8 +1,8 @@
|
||||
#include "CNShardServer.hpp"
|
||||
#include "CNStructs.hpp"
|
||||
#include "PlayerManager.hpp"
|
||||
#include "NanoManager.hpp"
|
||||
#include "TransportManager.hpp"
|
||||
#include "Nanos.hpp"
|
||||
#include "Transport.hpp"
|
||||
#include "TableData.hpp"
|
||||
#include "Combat.hpp"
|
||||
#include "MobAI.hpp"
|
||||
@ -10,13 +10,13 @@
|
||||
#include <unordered_map>
|
||||
#include <cmath>
|
||||
|
||||
using namespace TransportManager;
|
||||
using namespace Transport;
|
||||
|
||||
std::map<int32_t, TransportRoute> TransportManager::Routes;
|
||||
std::map<int32_t, TransportLocation> TransportManager::Locations;
|
||||
std::map<int32_t, std::queue<WarpLocation>> TransportManager::SkywayPaths;
|
||||
std::unordered_map<CNSocket*, std::queue<WarpLocation>> TransportManager::SkywayQueues;
|
||||
std::unordered_map<int32_t, std::queue<WarpLocation>> TransportManager::NPCQueues;
|
||||
std::map<int32_t, TransportRoute> Transport::Routes;
|
||||
std::map<int32_t, TransportLocation> Transport::Locations;
|
||||
std::map<int32_t, std::queue<WarpLocation>> Transport::SkywayPaths;
|
||||
std::unordered_map<CNSocket*, std::queue<WarpLocation>> Transport::SkywayQueues;
|
||||
std::unordered_map<int32_t, std::queue<WarpLocation>> Transport::NPCQueues;
|
||||
|
||||
static void transportRegisterLocationHandler(CNSocket* sock, CNPacketData* data) {
|
||||
if (data->size != sizeof(sP_CL2FE_REQ_REGIST_TRANSPORTATION_LOCATION))
|
||||
@ -133,13 +133,13 @@ static void transportWarpHandler(CNSocket* sock, CNPacketData* data) {
|
||||
plr->lastY = plr->y;
|
||||
plr->lastZ = plr->z;
|
||||
if (SkywayPaths.find(route.mssRouteNum) != SkywayPaths.end()) { // check if route exists
|
||||
NanoManager::summonNano(sock, -1); // make sure that no nano is active during the ride
|
||||
Nanos::summonNano(sock, -1); // make sure that no nano is active during the ride
|
||||
SkywayQueues[sock] = SkywayPaths[route.mssRouteNum]; // set socket point queue to route
|
||||
plr->onMonkey = true;
|
||||
break;
|
||||
} else if (TableData::RunningSkywayRoutes.find(route.mssRouteNum) != TableData::RunningSkywayRoutes.end()) {
|
||||
std::vector<WarpLocation>* _route = &TableData::RunningSkywayRoutes[route.mssRouteNum];
|
||||
NanoManager::summonNano(sock, -1);
|
||||
Nanos::summonNano(sock, -1);
|
||||
testMssRoute(sock, _route);
|
||||
plr->onMonkey = true;
|
||||
break;
|
||||
@ -172,18 +172,18 @@ static void transportWarpHandler(CNSocket* sock, CNPacketData* data) {
|
||||
if (target == nullptr)
|
||||
return;
|
||||
// we warped; update position and chunks
|
||||
ChunkManager::updatePlayerChunk(sock, plr->chunkPos, std::make_tuple(0, 0, 0)); // force player to reload chunks
|
||||
Chunking::updatePlayerChunk(sock, plr->chunkPos, std::make_tuple(0, 0, 0)); // force player to reload chunks
|
||||
PlayerManager::updatePlayerPosition(sock, target->x, target->y, target->z, INSTANCE_OVERWORLD, plr->angle);
|
||||
}
|
||||
|
||||
void TransportManager::testMssRoute(CNSocket *sock, std::vector<WarpLocation>* route) {
|
||||
void Transport::testMssRoute(CNSocket *sock, std::vector<WarpLocation>* route) {
|
||||
int speed = 1500; // TODO: make this adjustable
|
||||
std::queue<WarpLocation> path;
|
||||
WarpLocation last = route->front(); // start pos
|
||||
|
||||
for (int i = 1; i < route->size(); i++) {
|
||||
WarpLocation coords = route->at(i);
|
||||
TransportManager::lerp(&path, last, coords, speed);
|
||||
Transport::lerp(&path, last, coords, speed);
|
||||
path.push(coords); // add keyframe to the queue
|
||||
last = coords; // update start pos
|
||||
}
|
||||
@ -332,7 +332,7 @@ static void tickTransportationSystem(CNServer* serv, time_t currTime) {
|
||||
/*
|
||||
* Linearly interpolate between two points and insert the results into a queue.
|
||||
*/
|
||||
void TransportManager::lerp(std::queue<WarpLocation>* queue, WarpLocation start, WarpLocation end, int gapSize, float curve) {
|
||||
void Transport::lerp(std::queue<WarpLocation>* queue, WarpLocation start, WarpLocation end, int gapSize, float curve) {
|
||||
int dXY = hypot(end.x - start.x, end.y - start.y); // XY plane distance
|
||||
int distanceBetween = hypot(dXY, end.z - start.z); // total distance
|
||||
int lerps = distanceBetween / gapSize; // number of intermediate points to add
|
||||
@ -347,11 +347,11 @@ void TransportManager::lerp(std::queue<WarpLocation>* queue, WarpLocation start,
|
||||
queue->push(lerp); // add lerp'd point
|
||||
}
|
||||
}
|
||||
void TransportManager::lerp(std::queue<WarpLocation>* queue, WarpLocation start, WarpLocation end, int gapSize) {
|
||||
void Transport::lerp(std::queue<WarpLocation>* queue, WarpLocation start, WarpLocation end, int gapSize) {
|
||||
lerp(queue, start, end, gapSize, 1);
|
||||
}
|
||||
|
||||
void TransportManager::init() {
|
||||
void Transport::init() {
|
||||
REGISTER_SHARD_TIMER(tickTransportationSystem, 1000);
|
||||
|
||||
REGISTER_SHARD_PACKET(P_CL2FE_REQ_REGIST_TRANSPORTATION_LOCATION, transportRegisterLocationHandler);
|
@ -19,7 +19,7 @@ struct TransportLocation {
|
||||
int npcID, x, y, z;
|
||||
};
|
||||
|
||||
namespace TransportManager {
|
||||
namespace Transport {
|
||||
extern std::map<int32_t, TransportRoute> Routes;
|
||||
extern std::map<int32_t, TransportLocation> Locations;
|
||||
extern std::map<int32_t, std::queue<WarpLocation>> SkywayPaths; // predefined skyway paths with points
|
@ -15,7 +15,7 @@ static void vendorBuy(CNSocket* sock, CNPacketData* data) {
|
||||
INITSTRUCT(sP_FE2CL_REP_PC_VENDOR_ITEM_BUY_FAIL, failResp);
|
||||
failResp.iErrorCode = 0;
|
||||
|
||||
ItemManager::Item* itemDat = ItemManager::getItemData(req->Item.iID, req->Item.iType);
|
||||
Items::Item* itemDat = Items::getItemData(req->Item.iID, req->Item.iType);
|
||||
|
||||
if (itemDat == nullptr) {
|
||||
std::cout << "[WARN] Item id " << req->Item.iID << " with type " << req->Item.iType << " not found (buy)" << std::endl;
|
||||
@ -24,7 +24,7 @@ static void vendorBuy(CNSocket* sock, CNPacketData* data) {
|
||||
}
|
||||
|
||||
int itemCost = itemDat->buyPrice * (itemDat->stackSize > 1 ? req->Item.iOpt : 1);
|
||||
int slot = ItemManager::findFreeSlot(plr);
|
||||
int slot = Items::findFreeSlot(plr);
|
||||
if (itemCost > plr->money || slot == -1) {
|
||||
sock->sendPacket((void*)&failResp, P_FE2CL_REP_PC_VENDOR_ITEM_BUY_FAIL, sizeof(sP_FE2CL_REP_PC_VENDOR_ITEM_BUY_FAIL));
|
||||
return;
|
||||
@ -77,7 +77,7 @@ static void vendorSell(CNSocket* sock, CNPacketData* data) {
|
||||
}
|
||||
|
||||
sItemBase* item = &plr->Inven[req->iInvenSlotNum];
|
||||
ItemManager::Item* itemData = ItemManager::getItemData(item->iID, item->iType);
|
||||
Items::Item* itemData = Items::getItemData(item->iID, item->iType);
|
||||
|
||||
if (itemData == nullptr || !itemData->sellable || item->iOpt < req->iItemCnt) { // sanity + sellable check
|
||||
std::cout << "[WARN] Item id " << item->iID << " with type " << item->iType << " not found (sell)" << std::endl;
|
||||
@ -171,7 +171,7 @@ static void vendorBuyback(CNSocket* sock, CNPacketData* data) {
|
||||
}
|
||||
//std::cout << (int)plr->buyback->size() << " items in buyback\n";
|
||||
|
||||
ItemManager::Item* itemDat = ItemManager::getItemData(item.iID, item.iType);
|
||||
Items::Item* itemDat = Items::getItemData(item.iID, item.iType);
|
||||
|
||||
if (itemDat == nullptr) {
|
||||
std::cout << "[WARN] Item id " << item.iID << " with type " << item.iType << " not found (rebuy)" << std::endl;
|
||||
@ -181,7 +181,7 @@ static void vendorBuyback(CNSocket* sock, CNPacketData* data) {
|
||||
|
||||
// sell price is used on rebuy. ternary identifies stacked items
|
||||
int itemCost = itemDat->sellPrice * (itemDat->stackSize > 1 ? item.iOpt : 1);
|
||||
int slot = ItemManager::findFreeSlot(plr);
|
||||
int slot = Items::findFreeSlot(plr);
|
||||
if (itemCost > plr->money || slot == -1) {
|
||||
sock->sendPacket((void*)&failResp, P_FE2CL_REP_PC_VENDOR_ITEM_RESTORE_BUY_FAIL, sizeof(sP_FE2CL_REP_PC_VENDOR_ITEM_RESTORE_BUY_FAIL));
|
||||
return;
|
||||
@ -308,12 +308,12 @@ static void vendorCombineItems(CNSocket* sock, CNPacketData* data) {
|
||||
|
||||
sItemBase* itemStats = &plr->Inven[req->iStatItemSlot];
|
||||
sItemBase* itemLooks = &plr->Inven[req->iCostumeItemSlot];
|
||||
ItemManager::Item* itemStatsDat = ItemManager::getItemData(itemStats->iID, itemStats->iType);
|
||||
ItemManager::Item* itemLooksDat = ItemManager::getItemData(itemLooks->iID, itemLooks->iType);
|
||||
Items::Item* itemStatsDat = Items::getItemData(itemStats->iID, itemStats->iType);
|
||||
Items::Item* itemLooksDat = Items::getItemData(itemLooks->iID, itemLooks->iType);
|
||||
|
||||
// sanity check item and combination entry existence
|
||||
if (itemStatsDat == nullptr || itemLooksDat == nullptr
|
||||
|| ItemManager::CrocPotTable.find(abs(itemStatsDat->level - itemLooksDat->level)) == ItemManager::CrocPotTable.end()) {
|
||||
|| Items::CrocPotTable.find(abs(itemStatsDat->level - itemLooksDat->level)) == Items::CrocPotTable.end()) {
|
||||
std::cout << "[WARN] Either item ids or croc pot value set not found" << std::endl;
|
||||
sock->sendPacket((void*)&failResp, P_FE2CL_REP_PC_ITEM_COMBINATION_FAIL, sizeof(sP_FE2CL_REP_PC_ITEM_COMBINATION_FAIL));
|
||||
return;
|
||||
@ -327,7 +327,7 @@ static void vendorCombineItems(CNSocket* sock, CNPacketData* data) {
|
||||
return;
|
||||
}
|
||||
|
||||
CrocPotEntry* recipe = &ItemManager::CrocPotTable[abs(itemStatsDat->level - itemLooksDat->level)];
|
||||
CrocPotEntry* recipe = &Items::CrocPotTable[abs(itemStatsDat->level - itemLooksDat->level)];
|
||||
int cost = itemStatsDat->buyPrice * recipe->multStats + itemLooksDat->buyPrice * recipe->multLooks;
|
||||
float successChance = recipe->base / 100.0f; // base success chance
|
||||
|
||||
|
@ -4,7 +4,7 @@
|
||||
#include "CNStructs.hpp"
|
||||
#include "CNShardServer.hpp"
|
||||
|
||||
#include "ItemManager.hpp"
|
||||
#include "Items.hpp"
|
||||
#include "PlayerManager.hpp"
|
||||
|
||||
struct VendorListing {
|
||||
|
32
src/main.cpp
32
src/main.cpp
@ -3,21 +3,21 @@
|
||||
#include "PlayerManager.hpp"
|
||||
#include "PlayerMovement.hpp"
|
||||
#include "BuiltinCommands.hpp"
|
||||
#include "ChatManager.hpp"
|
||||
#include "Buddies.hpp"
|
||||
#include "CustomCommands.hpp"
|
||||
#include "Combat.hpp"
|
||||
#include "MobAI.hpp"
|
||||
#include "ItemManager.hpp"
|
||||
#include "MissionManager.hpp"
|
||||
#include "NanoManager.hpp"
|
||||
#include "Items.hpp"
|
||||
#include "Missions.hpp"
|
||||
#include "Nanos.hpp"
|
||||
#include "NPCManager.hpp"
|
||||
#include "TransportManager.hpp"
|
||||
#include "BuddyManager.hpp"
|
||||
#include "Transport.hpp"
|
||||
#include "Buddies.hpp"
|
||||
#include "db/Database.hpp"
|
||||
#include "TableData.hpp"
|
||||
#include "GroupManager.hpp"
|
||||
#include "Groups.hpp"
|
||||
#include "Monitor.hpp"
|
||||
#include "RacingManager.hpp"
|
||||
#include "Racing.hpp"
|
||||
#include "Trading.hpp"
|
||||
#include "Email.hpp"
|
||||
#include "Vendor.hpp"
|
||||
@ -101,20 +101,20 @@ int main() {
|
||||
PlayerManager::init();
|
||||
PlayerMovement::init();
|
||||
BuiltinCommands::init();
|
||||
ChatManager::init();
|
||||
Buddies::init();
|
||||
CustomCommands::init();
|
||||
Combat::init();
|
||||
MobAI::init();
|
||||
ItemManager::init();
|
||||
MissionManager::init();
|
||||
NanoManager::init();
|
||||
Items::init();
|
||||
Missions::init();
|
||||
Nanos::init();
|
||||
NPCManager::init();
|
||||
Vendor::init();
|
||||
TransportManager::init();
|
||||
BuddyManager::init();
|
||||
Transport::init();
|
||||
Buddies::init();
|
||||
Email::init();
|
||||
GroupManager::init();
|
||||
RacingManager::init();
|
||||
Groups::init();
|
||||
Racing::init();
|
||||
Database::open();
|
||||
Trading::init();
|
||||
|
||||
|
Loading…
Reference in New Issue
Block a user