611 lines
17 KiB
C++
611 lines
17 KiB
C++
#include "stdafx.h"
|
|
|
|
#include "Map.h"
|
|
#include "GameEvent.h"
|
|
|
|
#include "KnightsManager.h"
|
|
#include "DBAgent.h"
|
|
#include "KingSystem.h"
|
|
|
|
#include "../shared/database/OdbcRecordset.h"
|
|
#include "../shared/database/ItemTableSet.h"
|
|
#include "../shared/database/BotTableSet.h"
|
|
#include "../shared/database/SetItemTableSet.h"
|
|
#include "../shared/database/ItemMiningSet.h"
|
|
#include "../shared/database/ItemExchangeSet.h"
|
|
#include "../shared/database/ItemUpgradeSet.h"
|
|
#include "../shared/database/ItemOpSet.h"
|
|
#include "../shared/database/MagicTableSet.h"
|
|
#include "../shared/database/MagicType1Set.h"
|
|
#include "../shared/database/MagicType2Set.h"
|
|
#include "../shared/database/MagicType3Set.h"
|
|
#include "../shared/database/MagicType4Set.h"
|
|
#include "../shared/database/MagicType5Set.h"
|
|
#include "../shared/database/MagicType6Set.h"
|
|
#include "../shared/database/MagicType7Set.h"
|
|
#include "../shared/database/MagicType8Set.h"
|
|
#include "../shared/database/MagicType9Set.h"
|
|
#include "../shared/database/ObjectPosSet.h"
|
|
#include "../shared/database/ZoneInfoSet.h"
|
|
#include "../shared/database/EventSet.h"
|
|
#include "../shared/database/CoefficientSet.h"
|
|
#include "../shared/database/LevelUpTableSet.h"
|
|
#include "../shared/database/PetLevelUpTableSet.h"
|
|
#include "../shared/database/ServerResourceSet.h"
|
|
#include "../shared/database/QuestHelperSet.h"
|
|
#include "../shared/database/QuestMonsterSet.h"
|
|
#include "../shared/database/KnightsSet.h"
|
|
#include "../shared/database/ReKnightsSet.h"
|
|
#include "../shared/database/KnightsUserSet.h"
|
|
#include "../shared/database/KnightsAllianceSet.h"
|
|
#include "../shared/database/KnightsRankSet.h"
|
|
#include "../shared/database/KnightsCapeSet.h"
|
|
#include "../shared/database/UserPersonalRankSet.h"
|
|
#include "../shared/database/UserKnightsRankSet.h"
|
|
#include "../shared/database/StartPositionSet.h"
|
|
#include "../shared/database/StartPositionRandomSet.h"
|
|
#include "../shared/database/BattleSet.h"
|
|
#include "../shared/database/RentalItemSet.h"
|
|
#include "../shared/database/KingSystemSet.h"
|
|
#include "../shared/database/KingCandidacyNoticeBoardSet.h"
|
|
#include "../shared/database/KingElectionListSet.h"
|
|
#include "../shared/database/EventTriggerSet.h"
|
|
#include "../shared/database/MonsterChallenge.h"
|
|
#include "../shared/database/EventTimes.h"
|
|
#include "../shared/database/MonsterChallengeSummonList.h"
|
|
#include "../shared/database/MonsterSummonListSet.h"
|
|
#include "../shared/database/MonsterSummonListZoneSet.h"
|
|
#include "../shared/database/MonsterRespawnListSet.h"
|
|
#include "../shared/database/MonsterRespawnListInformationSet.h"
|
|
#include "../shared/database/MonsterRespawnListRandomSet.h"
|
|
#include "../shared/database/PremiumItemSet.h"
|
|
#include "../shared/database/PremiumItemExpSet.h"
|
|
#include "../shared/database/PetTableSet.h"
|
|
#include "../shared/database/CypherTableSet.h"
|
|
#include "../shared/database/UserDailyOpSet.h"
|
|
#include "../shared/database/UserItemSet.h"
|
|
#include "../shared/database/KnightsSiegeWar.h"
|
|
#include "../shared/database/AchieveComSet.h"
|
|
#include "../shared/database/AchieveWarSet.h"
|
|
#include "../shared/database/AchieveTitleSet.h"
|
|
#include "../shared/database/AchieveMainSet.h"
|
|
#include "../shared/database/AchieveNormalSet.h"
|
|
#include "../shared/database/AchieveMonsterSet.h"
|
|
#include "../shared/database/ItemCrashSet.h"
|
|
#include "../shared/database/ItemMixSet.h"
|
|
#include "../shared/database/ItemDuper.h"
|
|
#include "../shared/database/IlegalItems.h"
|
|
#include "../shared/database/ItemExchangeExpSet.h"
|
|
|
|
bool CGameServerDlg::LoadItemCrashTable()
|
|
{
|
|
LOAD_TABLE(CItemCrashSet,g_DBAgent.m_GameDB,&m_ItemCrashArray,true,false);
|
|
}
|
|
|
|
bool CGameServerDlg::LoadItemTable()
|
|
{
|
|
LOAD_TABLE(CItemTableSet, g_DBAgent.m_GameDB, &m_ItemtableArray, false, false);
|
|
}
|
|
|
|
bool CGameServerDlg::LoadItemDuper()
|
|
{
|
|
LOAD_TABLE(CItemDuper, g_DBAgent.m_GameDB, &m_ItemDupersArray,true, false);
|
|
}
|
|
|
|
bool CGameServerDlg::LoadIlegalItems()
|
|
{
|
|
LOAD_TABLE(CIlegalItems, g_DBAgent.m_GameDB, &m_IlegalItemsArray,true, false);
|
|
}
|
|
|
|
bool CGameServerDlg::LoadSetItemTable()
|
|
{
|
|
LOAD_TABLE(CSetItemTableSet, g_DBAgent.m_GameDB, &m_SetItemArray,true, false);
|
|
}
|
|
|
|
bool CGameServerDlg::LoadAchieveMonsterTable()
|
|
{
|
|
LOAD_TABLE(CAchieveMonsterSet, g_DBAgent.m_GameDB, &ACHIEVE_MONSTER,true, false);
|
|
}
|
|
|
|
bool CGameServerDlg::LoadAchieveNormalTable()
|
|
{
|
|
LOAD_TABLE(CAchieveNormalSet, g_DBAgent.m_GameDB, &ACHIEVE_NORMAL,true, false);
|
|
}
|
|
|
|
bool CGameServerDlg::LoadAchieveTitleTable()
|
|
{
|
|
LOAD_TABLE(CAchieveTitleSet, g_DBAgent.m_GameDB, &ACHIEVE_TITLE,true, false);
|
|
}
|
|
|
|
bool CGameServerDlg::LoadAchieveWarTable()
|
|
{
|
|
LOAD_TABLE(CAchieveWarSet, g_DBAgent.m_GameDB, &ACHIEVE_WAR,true, false);
|
|
}
|
|
|
|
bool CGameServerDlg::LoadAchieveMainTable()
|
|
{
|
|
LOAD_TABLE(CAchieveMainSet, g_DBAgent.m_GameDB, &ACHIEVE_MAIN,true, false);
|
|
}
|
|
|
|
bool CGameServerDlg::LoadAchieveComTable()
|
|
{
|
|
LOAD_TABLE(CAchieveComSet, g_DBAgent.m_GameDB, &ACHIEVE_COM,true, false);
|
|
}
|
|
|
|
bool CGameServerDlg::LoadKnightsSiegeWarsTable()
|
|
{
|
|
LOAD_TABLE(CKnightsSiegeWarfare, g_DBAgent.m_GameDB, &m_KnightsSiegeWarfareArray,true, false);
|
|
}
|
|
bool CGameServerDlg::LoadItemExchangeTable()
|
|
{
|
|
LOAD_TABLE(CItemExchangeSet, g_DBAgent.m_GameDB, &m_ItemExchangeArray,true, false);
|
|
}
|
|
|
|
bool CGameServerDlg::LoadItemMixTable()
|
|
{
|
|
LOAD_TABLE(CItemMixSet, g_DBAgent.m_GameDB, &m_ItemMixArray,true, false);
|
|
}
|
|
|
|
bool CGameServerDlg::LoadItemExchangeExpTable()
|
|
{
|
|
LOAD_TABLE(CItemExchangeExpSet, g_DBAgent.m_GameDB, &m_ItemExchangeExpArray,true, false);
|
|
}
|
|
|
|
uint8 CGameServerDlg::GetTariffByZone(int zoneid)
|
|
{
|
|
|
|
_KNIGHTS_SIEGE_WARFARE *pSiegeWar = g_pMain->GetSiegeMasterKnightsPtr(1);
|
|
CKingSystem *pKingSystemK = g_pMain->m_KingSystemArray.GetData(1);
|
|
CKingSystem *pKingSystemH = g_pMain->m_KingSystemArray.GetData(2);
|
|
|
|
switch (zoneid)
|
|
{
|
|
case ZONE_KARUS:
|
|
if (pKingSystemK != nullptr)
|
|
return (10 + pKingSystemK->m_nTerritoryTariff);
|
|
else
|
|
return 10;
|
|
break;
|
|
case ZONE_KARUS_ESLANT:
|
|
if (pKingSystemK != nullptr)
|
|
return (10 + pKingSystemK->m_nTerritoryTariff);
|
|
else
|
|
return 10;
|
|
break;
|
|
case ZONE_ELMORAD:
|
|
if (pKingSystemH != nullptr)
|
|
return (10 + pKingSystemH->m_nTerritoryTariff);
|
|
else
|
|
return 10;
|
|
break;
|
|
case ZONE_ELMORAD_ESLANT:
|
|
if (pKingSystemH != nullptr){
|
|
return (10 + pKingSystemH->m_nTerritoryTariff);
|
|
}else
|
|
return 10;
|
|
break;
|
|
case ZONE_MORADON:
|
|
if (pSiegeWar != nullptr){
|
|
return (uint8)pSiegeWar->sMoradonTariff;
|
|
}else
|
|
return 0;
|
|
break;
|
|
case ZONE_DELOS:
|
|
if (pSiegeWar != nullptr){
|
|
return (uint8)pSiegeWar->sDellosTariff;
|
|
}else
|
|
return 0;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
bool CGameServerDlg::LoadItemMiningTable()
|
|
{
|
|
|
|
memset(&bRandArrayNormalMattock, 0, sizeof(bRandArrayNormalMattock));
|
|
memset(&bRandArrayGoldenMattock, 0, sizeof(bRandArrayGoldenMattock));
|
|
|
|
g_pMain->TotalMiningExchangeRate = 0;
|
|
g_pMain->TotalGoldenMiningExchangeRate = 0;
|
|
|
|
LOAD_TABLE(CItemMiningSet, g_DBAgent.m_GameDB, &m_ItemMiningArray,true, false);
|
|
|
|
|
|
if (g_pMain->TotalMiningExchangeRate != 10000)
|
|
printf("WARNING : Total Mining Exchange Rate(ITEM_MINING) have to be [10000]!\n");
|
|
|
|
if (g_pMain->TotalGoldenMiningExchangeRate != 10000)
|
|
printf("WARNING : Total Golden Mining Exchange Rate(ITEM_MINING) have to be [10000]!\n");
|
|
|
|
}
|
|
|
|
bool CGameServerDlg::LoadItemUpgradeTable()
|
|
{
|
|
LOAD_TABLE(CItemUpgradeSet, g_DBAgent.m_GameDB, &m_ItemUpgradeArray, false, false);
|
|
}
|
|
|
|
bool CGameServerDlg::LoadItemOpTable()
|
|
{
|
|
LOAD_TABLE(CItemOpSet, g_DBAgent.m_GameDB, &m_ItemOpArray,true, false);
|
|
}
|
|
|
|
bool CGameServerDlg::LoadServerResourceTable()
|
|
{
|
|
LOAD_TABLE(CServerResourceSet, g_DBAgent.m_GameDB, &m_ServerResourceArray, false, false);
|
|
}
|
|
|
|
bool CGameServerDlg::LoadQuestHelperTable()
|
|
{
|
|
Guard lock(m_questNpcLock);
|
|
m_QuestNpcList.clear();
|
|
LOAD_TABLE(CQuestHelperSet, g_DBAgent.m_GameDB, &m_QuestHelperArray,true, false);
|
|
}
|
|
|
|
bool CGameServerDlg::LoadQuestMonsterTable()
|
|
{
|
|
LOAD_TABLE(CQuestMonsterSet, g_DBAgent.m_GameDB, &m_QuestMonsterArray,true, false);
|
|
}
|
|
|
|
bool CGameServerDlg::LoadMagicTable()
|
|
{
|
|
LOAD_TABLE(CMagicTableSet, g_DBAgent.m_GameDB, &m_MagictableArray, false, false);
|
|
}
|
|
|
|
bool CGameServerDlg::LoadMagicType1()
|
|
{
|
|
LOAD_TABLE(CMagicType1Set, g_DBAgent.m_GameDB, &m_Magictype1Array, false, false);
|
|
}
|
|
|
|
bool CGameServerDlg::LoadMagicType2()
|
|
{
|
|
LOAD_TABLE(CMagicType2Set, g_DBAgent.m_GameDB, &m_Magictype2Array, false, false);
|
|
}
|
|
|
|
bool CGameServerDlg::LoadMagicType3()
|
|
{
|
|
LOAD_TABLE(CMagicType3Set, g_DBAgent.m_GameDB, &m_Magictype3Array, false, false);
|
|
}
|
|
|
|
bool CGameServerDlg::LoadMagicType4()
|
|
{
|
|
LOAD_TABLE(CMagicType4Set, g_DBAgent.m_GameDB, &m_Magictype4Array, false, false);
|
|
}
|
|
|
|
bool CGameServerDlg::LoadMagicType5()
|
|
{
|
|
LOAD_TABLE(CMagicType5Set, g_DBAgent.m_GameDB, &m_Magictype5Array, false, false);
|
|
}
|
|
|
|
bool CGameServerDlg::LoadMagicType6()
|
|
{
|
|
LOAD_TABLE(CMagicType6Set, g_DBAgent.m_GameDB, &m_Magictype6Array, false, false);
|
|
}
|
|
|
|
bool CGameServerDlg::LoadMagicType7()
|
|
{
|
|
LOAD_TABLE(CMagicType7Set, g_DBAgent.m_GameDB, &m_Magictype7Array, false, false);
|
|
}
|
|
|
|
bool CGameServerDlg::LoadMagicType8()
|
|
{
|
|
LOAD_TABLE(CMagicType8Set, g_DBAgent.m_GameDB, &m_Magictype8Array, false, false);
|
|
}
|
|
|
|
bool CGameServerDlg::LoadMagicType9()
|
|
{
|
|
LOAD_TABLE(CMagicType9Set, g_DBAgent.m_GameDB, &m_Magictype9Array, false, false);
|
|
}
|
|
|
|
bool CGameServerDlg::LoadRentalList()
|
|
{
|
|
LOAD_TABLE(CRentalItemSet, g_DBAgent.m_GameDB, &m_RentalItemArray,true, false);
|
|
}
|
|
|
|
bool CGameServerDlg::LoadCoefficientTable()
|
|
{
|
|
LOAD_TABLE(CCoefficientSet, g_DBAgent.m_GameDB, &m_CoefficientArray, false, false);
|
|
}
|
|
|
|
bool CGameServerDlg::LoadLevelUpTable()
|
|
{
|
|
LOAD_TABLE(CLevelUpTableSet, g_DBAgent.m_GameDB, &m_LevelUpArray, false, false);
|
|
}
|
|
|
|
bool CGameServerDlg::LoadPetLevelUpTable()
|
|
{
|
|
LOAD_TABLE(CPetLevelUpTableSet, g_DBAgent.m_GameDB, &m_PetLevelUpArray, false, false);
|
|
}
|
|
|
|
bool CGameServerDlg::LoadAllKnights(bool bIsSlient)
|
|
{
|
|
Guard lock(m_KnightsArray.m_lock);
|
|
LOAD_TABLE(CKnightsSet, g_DBAgent.m_GameDB, &m_KnightsArray,true, bIsSlient);
|
|
}
|
|
|
|
bool CGameServerDlg::ReloadAllKnights(bool bIsSlient)
|
|
{
|
|
Guard lock(m_KnightsArray.m_lock);
|
|
LOAD_TABLE(CReKnightsSet, g_DBAgent.m_GameDB, &m_KnightsArray,true, bIsSlient);
|
|
}
|
|
|
|
bool CGameServerDlg::LoadAllKnightsUserData(bool bIsSlient)
|
|
{
|
|
LOAD_TABLE(CKnightsUserSet, g_DBAgent.m_GameDB, nullptr,true, bIsSlient);
|
|
}
|
|
|
|
bool CGameServerDlg::LoadKnightsAllianceTable(bool bIsSlient)
|
|
{
|
|
LOAD_TABLE(CKnightsAllianceSet, g_DBAgent.m_GameDB, &m_KnightsAllianceArray,true, bIsSlient);
|
|
}
|
|
|
|
bool CGameServerDlg::LoadUserRankings()
|
|
{
|
|
CUserPersonalRankSet UserPersonalRankSet(g_DBAgent.m_GameDB, &m_UserPersonalRankMap);
|
|
CUserKnightsRankSet UserKnightsRankSet(g_DBAgent.m_GameDB, &m_UserKnightsRankMap);
|
|
TCHAR * szError = nullptr;
|
|
|
|
// Cleanup first, in the event it's already loaded (we'll have this automatically reload in-game)
|
|
CleanupUserRankings();
|
|
|
|
// Acquire the lock for thread safety, and load both tables.
|
|
//Guard lock(m_userRankingsLock);
|
|
|
|
szError = UserPersonalRankSet.Read(true);
|
|
if (szError != nullptr)
|
|
{
|
|
printf("ERROR: Failed to load personal rankings, error:\n%s\n", szError);
|
|
return false;
|
|
}
|
|
|
|
szError = UserKnightsRankSet.Read(true);
|
|
if (szError != nullptr)
|
|
{
|
|
printf("ERROR: Failed to load user knights rankings, error:\n%s\n", szError);
|
|
return false;
|
|
}
|
|
|
|
foreach (itr, m_UserKnightsRankMap)
|
|
{
|
|
CUser *pUser = GetUserPtr(itr->first, TYPE_CHARACTER);
|
|
if (pUser == nullptr)
|
|
continue;
|
|
|
|
GetUserRank(pUser);
|
|
|
|
}
|
|
|
|
foreach (itr, m_UserPersonalRankMap)
|
|
{
|
|
CUser *pUser = GetUserPtr(itr->first, TYPE_CHARACTER);
|
|
if (pUser == nullptr)
|
|
continue;
|
|
|
|
GetUserRank(pUser);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void CGameServerDlg::CleanupUserRankings()
|
|
{
|
|
std::set<_USER_RANK *> deleteSet, DELETESET2;
|
|
Guard lock(m_userRankingsLock);
|
|
|
|
// Go through the personal rank map, reset the character's rank and insert
|
|
// the _USER_RANK struct instance into the deletion set for later.
|
|
foreach (itr, m_UserPersonalRankMap)
|
|
{
|
|
CUser *pUser = GetUserPtr(itr->first, TYPE_CHARACTER);
|
|
if (pUser != nullptr)
|
|
pUser->m_bPersonalRank = -1;
|
|
|
|
deleteSet.insert(itr->second);
|
|
}
|
|
|
|
// Go through the knights rank map, reset the character's rank and insert
|
|
// the _USER_RANK struct instance into the deletion set for later.
|
|
foreach (itr, m_UserKnightsRankMap)
|
|
{
|
|
CUser *pUser = GetUserPtr(itr->first, TYPE_CHARACTER);
|
|
if (pUser != nullptr)
|
|
pUser->m_bKnightsRank = -1;
|
|
|
|
DELETESET2.insert(itr->second);
|
|
}
|
|
|
|
// Clear out the maps
|
|
m_UserPersonalRankMap.clear();
|
|
m_UserKnightsRankMap.clear();
|
|
|
|
// Free the memory used by the _USER_RANK structs
|
|
foreach (itr, deleteSet)
|
|
delete *itr;
|
|
|
|
foreach (itr, DELETESET2)
|
|
delete *itr;
|
|
|
|
// These only store pointers to memory that was already freed by the primary rankings maps.
|
|
m_playerRankings[KARUS_ARRAY].clear();
|
|
m_playerRankings[ELMORAD_ARRAY].clear();
|
|
m_playerPersonalRankings[KARUS_ARRAY].clear();
|
|
m_playerPersonalRankings[ELMORAD_ARRAY].clear();
|
|
}
|
|
|
|
bool CGameServerDlg::LoadKnightsCapeTable()
|
|
{
|
|
LOAD_TABLE(CKnightsCapeSet, g_DBAgent.m_GameDB, &m_KnightsCapeArray, false, false);
|
|
}
|
|
|
|
bool CGameServerDlg::LoadKnightsRankTable(bool bWarTime /*= false*/, bool bIsSlient /*= false*/)
|
|
{
|
|
std::string strKarusCaptainNames, strElmoCaptainNames;
|
|
LOAD_TABLE_ERROR_ONLY(CKnightsRankSet, g_DBAgent.m_GameDB, nullptr, true, bIsSlient);
|
|
|
|
BoardCache[0].clear();
|
|
BoardCache[1].clear();
|
|
|
|
|
|
if (!bWarTime)
|
|
return true;
|
|
|
|
CKnightsRankSet & pSet = _CKnightsRankSet; // kind ugly generic naming
|
|
|
|
if (pSet.nKarusCount > 0)
|
|
{
|
|
Packet result;
|
|
GetServerResource(IDS_KARUS_CAPTAIN, &strKarusCaptainNames,
|
|
pSet.strKarusCaptain[0], pSet.strKarusCaptain[1], pSet.strKarusCaptain[2],
|
|
pSet.strKarusCaptain[3], pSet.strKarusCaptain[4]);
|
|
ChatPacket::Construct(&result, WAR_SYSTEM_CHAT, &strKarusCaptainNames);
|
|
Send_All(&result, nullptr, KARUS);
|
|
}
|
|
|
|
if (pSet.nElmoCount > 0)
|
|
{
|
|
Packet result;
|
|
GetServerResource(IDS_ELMO_CAPTAIN, &strElmoCaptainNames,
|
|
pSet.strElmoCaptain[0], pSet.strElmoCaptain[1], pSet.strElmoCaptain[2],
|
|
pSet.strElmoCaptain[3], pSet.strElmoCaptain[4]);
|
|
ChatPacket::Construct(&result, WAR_SYSTEM_CHAT, &strElmoCaptainNames);
|
|
Send_All(&result, nullptr, ELMORAD);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool CGameServerDlg::LoadStartPositionTable()
|
|
{
|
|
LOAD_TABLE(CStartPositionSet, g_DBAgent.m_GameDB, &m_StartPositionArray, false, false);
|
|
}
|
|
|
|
bool CGameServerDlg::LoadBattleTable()
|
|
{
|
|
LOAD_TABLE(CBattleSet, g_DBAgent.m_GameDB, &m_byOldVictory,true, false);
|
|
}
|
|
|
|
bool CGameServerDlg::LoadKingSystem()
|
|
{
|
|
LOAD_TABLE_ERROR_ONLY(CKingSystemSet, g_DBAgent.m_GameDB, &m_KingSystemArray,true, false);
|
|
LOAD_TABLE_ERROR_ONLY(CKingCandidacyNoticeBoardSet, g_DBAgent.m_GameDB, &m_KingSystemArray,true, false);
|
|
LOAD_TABLE(CKingElectionListSet, g_DBAgent.m_GameDB, &m_KingSystemArray,true, false);
|
|
}
|
|
|
|
bool CGameServerDlg::LoadMonsterChallengeTable()
|
|
{
|
|
LOAD_TABLE(CMonsterChallenge, g_DBAgent.m_GameDB, &m_MonsterChallengeArray,true, false);
|
|
}
|
|
|
|
bool CGameServerDlg::LoadEventTimesTable()
|
|
{
|
|
LOAD_TABLE(CEventTimes, g_DBAgent.m_GameDB, &m_EventTimesArray,true, false);
|
|
}
|
|
|
|
bool CGameServerDlg::LoadMonsterChallengeSummonListTable()
|
|
{
|
|
LOAD_TABLE(CMonsterChallengeSummonList, g_DBAgent.m_GameDB, &m_MonsterChallengeSummonListArray,true, false);
|
|
}
|
|
|
|
bool CGameServerDlg::LoadMonsterSummonListTable()
|
|
{
|
|
LOAD_TABLE(CMonsterSummonListSet, g_DBAgent.m_GameDB, &m_MonsterSummonList,true, false);
|
|
}
|
|
|
|
bool CGameServerDlg::LoadMonsterSummonListZoneTable()
|
|
{
|
|
LOAD_TABLE(CMonsterSummonListZoneSet, g_DBAgent.m_GameDB, &m_MonsterSummonListZoneArray,true, false);
|
|
}
|
|
|
|
bool CGameServerDlg::LoadMonsterRespawnListTable()
|
|
{
|
|
LOAD_TABLE(CMonsterRespawnListSet, g_DBAgent.m_GameDB, &m_MonsterRespawnListArray,true, false);
|
|
}
|
|
|
|
bool CGameServerDlg::LoadMonsterRespawnListInformationTable()
|
|
{
|
|
LOAD_TABLE(CMonsterRespawnListInformationSet, g_DBAgent.m_GameDB, &m_MonsterRespawnListInformationArray,true, false);
|
|
}
|
|
|
|
bool CGameServerDlg::LoadMonsterRespawnListRandomTable()
|
|
{
|
|
LOAD_TABLE(CMonsterRespawnListRandomSet, g_DBAgent.m_GameDB, &m_MonsterRespawnListRandomArray,true, false);
|
|
}
|
|
|
|
bool CGameServerDlg::LoadPremiumItemTable()
|
|
{
|
|
LOAD_TABLE(CPremiumItemSet, g_DBAgent.m_GameDB, &m_PremiumItemArray,true, false);
|
|
}
|
|
|
|
bool CGameServerDlg::LoadPremiumItemExpTable()
|
|
{
|
|
LOAD_TABLE(CPremiumItemExpSet, g_DBAgent.m_GameDB, &m_PremiumItemExpArray,true, false);
|
|
}
|
|
|
|
bool CGameServerDlg::LoadPetTable()
|
|
{
|
|
LastPetID = 2;
|
|
LOAD_TABLE(CPetTableSet, g_DBAgent.m_GameDB, &m_PetArray,true, false);
|
|
}
|
|
|
|
bool CGameServerDlg::LoadBotTable()
|
|
{
|
|
LOAD_TABLE(CBotTableSet, g_DBAgent.m_GameDB, &m_arBotArray,true, false);
|
|
}
|
|
|
|
bool CGameServerDlg::LoadCypherRingTable()
|
|
{
|
|
LOAD_TABLE(CCypherTableSet, g_DBAgent.m_GameDB, &m_CypherRingArray,true, false);
|
|
}
|
|
|
|
bool CGameServerDlg::LoadUserDailyOpTable()
|
|
{
|
|
LOAD_TABLE(CUserDailyOpSet, g_DBAgent.m_GameDB, &m_UserDailyOpMap,true, false);
|
|
}
|
|
|
|
bool CGameServerDlg::LoadEventTriggerTable()
|
|
{
|
|
LOAD_TABLE(CEventTriggerSet, g_DBAgent.m_GameDB, &m_EventTriggerArray,true, false);
|
|
}
|
|
|
|
bool CGameServerDlg::LoadStartPositionRandomTable()
|
|
{
|
|
LOAD_TABLE(CStartPositionRandomSet, g_DBAgent.m_GameDB, &m_StartPositionRandomArray,true, false);
|
|
}
|
|
|
|
bool CGameServerDlg::LoadUserItemTable()
|
|
{
|
|
LOAD_TABLE(CUserItemSet, g_DBAgent.m_GameDB, &m_UserItemArray,true, false);
|
|
}
|
|
|
|
bool CGameServerDlg::LoadObjectPosTable()
|
|
{
|
|
LOAD_TABLE(CObjectPosSet, g_DBAgent.m_GameDB, &m_ObjectEventArray,true, false);
|
|
}
|
|
|
|
bool CGameServerDlg::MapFileLoad()
|
|
{
|
|
ZoneInfoMap zoneMap;
|
|
LOAD_TABLE_ERROR_ONLY(CZoneInfoSet, g_DBAgent.m_GameDB, &zoneMap, false, false);
|
|
|
|
foreach (itr, zoneMap)
|
|
{
|
|
C3DMap *pMap = new C3DMap();
|
|
_ZONE_INFO *pZone = itr->second;
|
|
if (!pMap->Initialize(pZone))
|
|
{
|
|
printf("ERROR: Unable to load SMD - %s\n", pZone->m_MapName.c_str());
|
|
delete pZone;
|
|
delete pMap;
|
|
m_ZoneArray.DeleteAllData();
|
|
return false;
|
|
}
|
|
|
|
delete pZone;
|
|
m_ZoneArray.PutData(pMap->m_nZoneNumber, pMap);
|
|
}
|
|
|
|
LOAD_TABLE_ERROR_ONLY(CEventSet, g_DBAgent.m_GameDB, &m_ZoneArray, true, false);
|
|
return true;
|
|
} |