ilk commit

server/shared/database/AchieveComSet.h

@@ -0,0 +1,28 @@
+#pragma once
+
+class CAchieveComSet : public OdbcRecordset
+{
+public:
+	CAchieveComSet(OdbcConnection * dbConnection, AchieveComArray * pMap) : OdbcRecordset(dbConnection), m_pMap(pMap) {}
+
+	virtual tstring GetTableName() { return _T("ACHIEVE_COM"); }
+	virtual tstring GetColumns() { return _T("cAchieveID, cType, cQuest1, cQuest2"); }
+
+	virtual bool Fetch()
+	{
+		auto pData = new _ACHIEVE_COM;
+
+		auto i = 1;
+		_dbCommand->FetchUInt32(i++, pData->ID);
+		_dbCommand->FetchByte(i++, pData->UnKnow1);
+		_dbCommand->FetchUInt32(i++, pData->UnKnow2);
+		_dbCommand->FetchUInt32(i++, pData->UnKnow3);
+
+		if (!m_pMap->PutData(pData->ID, pData))
+			delete pData;
+
+		return true;
+	}
+
+	AchieveComArray * m_pMap;
+};

server/shared/database/AchieveMainSet.h

@@ -0,0 +1,39 @@
+#pragma once
+
+class CAchieveMainSet : public OdbcRecordset
+{
+public:
+	CAchieveMainSet(OdbcConnection * dbConnection, AchieveMainArray * pMap) : OdbcRecordset(dbConnection), m_pMap(pMap) {}
+
+	virtual tstring GetTableName() { return _T("ACHIEVE_MAIN"); }
+	virtual tstring GetColumns() { return _T("mMainID, strName, strDescription, mKind, mAchieveID, mPoints, mItemID, mItemCount, mZoneNum, mKilled, mKilled, mType, mTime, mSize, Category"); }
+
+	virtual bool Fetch()
+	{
+		auto pData = new _ACHIEVE_MAIN;
+
+		auto i = 1;
+		_dbCommand->FetchUInt32(i++, pData->ID);
+		_dbCommand->FetchByte(i++, pData->Type);
+		_dbCommand->FetchUInt16(i++, pData->TitleID);
+		_dbCommand->FetchUInt16(i++, pData->Point);
+		_dbCommand->FetchUInt32(i++, pData->ItemID);
+		_dbCommand->FetchUInt32(i++, pData->Count);
+		_dbCommand->FetchByte(i++, pData->ZoneID);
+		_dbCommand->FetchByte(i++, pData->UnKnow7);
+		_dbCommand->FetchByte(i++, pData->TabIndex);
+		_dbCommand->FetchUInt16(i++, pData->Time);
+		_dbCommand->FetchString(i++, pData->Name);
+		_dbCommand->FetchString(i++, pData->Description);
+		_dbCommand->FetchByte(i++, pData->PropertiesType);
+		_dbCommand->FetchByte(i++, pData->SubTabIndex);
+				
+		if (!m_pMap->PutData(pData->ID, pData))
+			delete pData;
+
+
+		return true;
+	}
+
+	AchieveMainArray * m_pMap;
+};

server/shared/database/AchieveMonsterSet.h

@@ -0,0 +1,35 @@
+#pragma once
+
+class CAchieveMonsterSet : public OdbcRecordset
+{
+public:
+	CAchieveMonsterSet(OdbcConnection * dbConnection, AchieveMonsterArray * pMap) : OdbcRecordset(dbConnection), m_pMap(pMap) {}
+
+	virtual tstring GetTableName() { return _T("ACHIEVE_MON"); }
+	virtual tstring GetColumns() { return _T("oMainID, oType, oType2, oSsid1, oSsid2, oSsid3, oSsid4, oCount, oSsid5, oSsid6, oSsid7, oSsid8, oCount2"); }
+
+	virtual bool Fetch()
+	{
+		auto pData = new _ACHIEVE_MONSTER;
+
+		auto i = 1;
+		_dbCommand->FetchUInt32(i++, pData->ID);
+		_dbCommand->FetchByte(i++, pData->Unknow2);
+		_dbCommand->FetchByte(i++, pData->Unknow3);
+
+		for (size_t ii = 0; ii < 2; ii++)
+		{
+			for (size_t iii = 0; iii < 4; iii++)
+				_dbCommand->FetchUInt32(i++, pData->MonsterID[ii][iii]);
+
+			_dbCommand->FetchUInt32(i++, pData->MonsterCount[ii]);
+		}
+
+		if (!m_pMap->PutData(pData->ID, pData))
+			delete pData;
+
+		return true;
+	}
+
+	AchieveMonsterArray * m_pMap;
+};

server/shared/database/AchieveNormalSet.h

@@ -0,0 +1,27 @@
+#pragma once
+
+class CAchieveNormalSet : public OdbcRecordset
+{
+public:
+	CAchieveNormalSet(OdbcConnection * dbConnection, AchieveNormalArray * pMap) : OdbcRecordset(dbConnection), m_pMap(pMap) {}
+
+	virtual tstring GetTableName() { return _T("ACHIEVE_NORMAL"); }
+	virtual tstring GetColumns() { return _T("nAchieveID, nType, nTypeCount"); }
+
+	virtual bool Fetch()
+	{
+		auto pData = new _ACHIEVE_NORMAL;
+
+		auto i = 1;
+		_dbCommand->FetchUInt32(i++, pData->ID);
+		_dbCommand->FetchUInt16(i++, pData->UnKnow1);
+		_dbCommand->FetchUInt32(i++, pData->UnKnow2);
+
+		if (!m_pMap->PutData(pData->ID, pData))
+			delete pData;
+
+		return true;
+	}
+
+	AchieveNormalArray * m_pMap;
+};

server/shared/database/AchieveTitleSet.h

@@ -0,0 +1,51 @@
+#pragma once
+
+class CAchieveTitleSet : public OdbcRecordset
+{
+public:
+	CAchieveTitleSet(OdbcConnection * dbConnection, AchieveTitleArray * pMap) : OdbcRecordset(dbConnection), m_pMap(pMap) {}
+
+	virtual tstring GetTableName() { return _T("ACHIEVE_TITLE"); }
+	virtual tstring GetColumns() { return _T("cAchieveID, strTitle, cMainID, cStrB, cStaB, cDexB, cIntB, cChaB, cAttack, cAC, cNPContribu, cExpPct, cSSwordAC, cJamadarAC, cSwordAC, cBlowAC, cAxeAC, cSpearAC, cArrowAC, cFlameB, cIceB, cLightB, cFireR, cIceR, cLightR, cMagicR, cCurseR, cPoisonR"); }
+
+	virtual bool Fetch()
+	{
+		auto pData = new _ACHIEVE_TITLE;
+
+		auto i = 1;
+		_dbCommand->FetchUInt32(i++, pData->ID);
+		_dbCommand->FetchUInt16(i++, pData->UnKnow1);
+		_dbCommand->FetchInt16(i++, pData->Strength);
+		_dbCommand->FetchInt16(i++, pData->Health);
+		_dbCommand->FetchInt16(i++, pData->Dexterity);
+		_dbCommand->FetchInt16(i++, pData->Intelligence);
+		_dbCommand->FetchInt16(i++, pData->MagicPower);
+		_dbCommand->FetchInt16(i++, pData->Attack);
+		_dbCommand->FetchInt16(i++, pData->Defense);
+		_dbCommand->FetchInt16(i++, pData->Contribution);
+		_dbCommand->FetchInt16(i++, pData->ExpBonusPercent);
+		_dbCommand->FetchInt16(i++, pData->ShortSwordDefense);
+		_dbCommand->FetchInt16(i++, pData->JamadarDefense);
+		_dbCommand->FetchInt16(i++, pData->SwordDefense);
+		_dbCommand->FetchInt16(i++, pData->BlowDefense);
+		_dbCommand->FetchInt16(i++, pData->AxeDefense);
+		_dbCommand->FetchInt16(i++, pData->SpearDefense);
+		_dbCommand->FetchInt16(i++, pData->ArrowDefense);
+		_dbCommand->FetchInt16(i++, pData->FlameBonus);
+		_dbCommand->FetchInt16(i++, pData->IceBonus);
+		_dbCommand->FetchInt16(i++, pData->ElectricShockBonus);
+		_dbCommand->FetchInt16(i++, pData->FlameResistence);
+		_dbCommand->FetchInt16(i++, pData->IceResistence);
+		_dbCommand->FetchInt16(i++, pData->ElectrickShockResistence);
+		_dbCommand->FetchInt16(i++, pData->MagicResistence);
+		_dbCommand->FetchInt16(i++, pData->SpellResistence);
+		_dbCommand->FetchInt16(i++, pData->PoisonResistence);
+
+		if (!m_pMap->PutData(pData->ID, pData))
+			delete pData;
+
+		return true;
+	}
+
+	AchieveTitleArray * m_pMap;
+};

server/shared/database/AchieveWarSet.h

@@ -0,0 +1,29 @@
+#pragma once
+
+class CAchieveWarSet : public OdbcRecordset
+{
+public:
+	CAchieveWarSet(OdbcConnection * dbConnection, AchieveWarArray * pMap) : OdbcRecordset(dbConnection), m_pMap(pMap) {}
+
+	virtual tstring GetTableName() { return _T("ACHIEVE_WAR"); }
+	virtual tstring GetColumns() { return _T("wMainID, wType, UnKnow, wKillCount, UnKnow2"); }
+
+	virtual bool Fetch()
+	{
+		auto pData = new _ACHIEVE_WAR;
+
+		auto i = 1;
+		_dbCommand->FetchUInt32(i++, pData->ID);
+		_dbCommand->FetchByte(i++, pData->Type);
+		_dbCommand->FetchByte(i++, pData->UnKnow2);
+		_dbCommand->FetchUInt32(i++, pData->Data);
+		_dbCommand->FetchUInt32(i++, pData->UnKnow4);
+
+		if (!m_pMap->PutData(pData->ID, pData))
+			delete pData;
+
+		return true;
+	}
+
+	AchieveWarArray * m_pMap;
+};

server/shared/database/BattleSet.h

@@ -0,0 +1,19 @@
+#pragma once
+
+class CBattleSet : public OdbcRecordset
+{
+public:
+	CBattleSet(OdbcConnection * dbConnection, uint8 * byOldVictory) 
+		: OdbcRecordset(dbConnection), m_byOldVictory(byOldVictory) {}
+
+	virtual tstring GetTableName() { return _T("BATTLE"); }
+	virtual tstring GetColumns() { return _T("byNation"); }
+
+	virtual bool Fetch() 
+	{
+		_dbCommand->FetchByte(1, *m_byOldVictory); 
+		return true;
+	}
+
+	uint8 *m_byOldVictory;
+};

server/shared/database/BotTableSet.h

@@ -0,0 +1,88 @@
+#pragma once
+
+class CBotTableSet : public OdbcRecordset
+{
+public:
+	CBotTableSet(OdbcConnection * dbConnection, BotArray *pMap) 
+		: OdbcRecordset(dbConnection), m_pMap(pMap) {}
+
+	virtual tstring GetTableName() { return _T("BOTDATA"); }
+	virtual tstring GetColumns() 
+	{
+		return _T("strUserID, Nation, Race, Class, HairRGB, [Level], Face, Knights, Fame, Zone, PX, PZ, PY, strItem, id, CoverTitle, RebLevel, strSkill, Gold, Points, Strong, Sta, Dex, Intel, Cha");
+	}
+
+	virtual bool Fetch()
+	{
+		CBot * pUser = new CBot();
+		int field = 1;
+		
+	char strItem[INVENTORY_TOTAL * 8];
+	memset(strItem, 0x00, sizeof(strItem));
+		
+	_dbCommand->FetchString(field++, pUser->m_strUserID);
+	_dbCommand->FetchByte(field++, pUser->m_bNation);
+	_dbCommand->FetchByte(field++, pUser->m_bRace);
+	_dbCommand->FetchUInt16(field++, pUser->m_sClass);
+	_dbCommand->FetchUInt32(field++, pUser->m_nHair);
+	_dbCommand->FetchByte(field++, pUser->m_bLevel);
+	_dbCommand->FetchByte(field++, pUser->m_bFace);
+	_dbCommand->FetchInt16(field++, pUser->m_bKnights);
+	_dbCommand->FetchByte(field++, pUser->m_bFame);
+	_dbCommand->FetchByte(field++, pUser->m_bZone);
+	pUser->m_curx = (float)(_dbCommand->FetchInt32(field++) / 100.0f);
+	pUser->m_curz = (float)(_dbCommand->FetchInt32(field++) / 100.0f);
+	pUser->m_cury = (float)(_dbCommand->FetchInt32(field++) / 100.0f);
+	pUser->m_oldx = pUser->m_curx;
+	pUser->m_oldy = pUser->m_cury;
+	pUser->m_oldz = pUser->m_curz;
+
+	
+	memset(pUser->m_sItemArray, 0x00, sizeof(pUser->m_sItemArray));
+
+	_dbCommand->FetchBinary(field++, strItem, sizeof(strItem));
+	ByteBuffer itemData;
+	itemData.append(strItem, sizeof(strItem));
+	for (int i = 0; i < INVENTORY_TOTAL; i++) 
+	{
+		uint32 nItemID;
+		uint16 sDurability, sCount;
+		itemData >> nItemID >> sDurability >> sCount;
+		_ITEM_DATA *pItem = &pUser->m_sItemArray[i];
+		pItem->nNum = nItemID;
+		pItem->sDuration = sDurability;
+		pItem->sCount = sCount;
+	
+	}
+
+
+	_dbCommand->FetchUInt16(field++, pUser->m_sSid);
+	_dbCommand->FetchUInt16(field++, pUser->m_sAchieveCoverTitle);
+
+	_dbCommand->FetchByte(field++, pUser->m_reblvl);
+
+
+	_dbCommand->FetchBinary(field++, (char *)pUser->m_bstrSkill, sizeof(pUser->m_bstrSkill));
+
+	_dbCommand->FetchUInt32(field++, pUser->m_iGold);
+	_dbCommand->FetchInt16(field++, pUser->m_sPoints);
+	_dbCommand->FetchByte(field++, pUser->m_bStats[STAT_STR]);
+	_dbCommand->FetchByte(field++, pUser->m_bStats[STAT_STA]);
+	_dbCommand->FetchByte(field++, pUser->m_bStats[STAT_DEX]);
+	_dbCommand->FetchByte(field++, pUser->m_bStats[STAT_INT]);
+	_dbCommand->FetchByte(field++, pUser->m_bStats[STAT_CHA]);
+
+	
+	pUser->m_sSid += MAX_USER;
+
+		if (pUser == nullptr)
+			delete pUser;
+		else
+			m_pMap->PutData(pUser->m_sSid,pUser);
+
+
+		return true;
+	}
+
+	BotArray * m_pMap;
+};

server/shared/database/CoefficientSet.h

@@ -0,0 +1,39 @@
+#pragma once
+
+class CCoefficientSet : public OdbcRecordset
+{
+public:
+	CCoefficientSet(OdbcConnection * dbConnection, CoefficientArray * pMap) 
+		: OdbcRecordset(dbConnection), m_pMap(pMap) {}
+
+	virtual tstring GetTableName() { return _T("COEFFICIENT"); }
+	virtual tstring GetColumns() { return _T("sClass, ShortSword, Sword, Axe, Club, Spear, Pole, Staff, Bow, Hp, Mp, Sp, Ac, Hitrate, Evasionrate"); }
+
+	virtual bool Fetch()
+	{
+		_CLASS_COEFFICIENT *pData = new _CLASS_COEFFICIENT;
+
+		_dbCommand->FetchUInt16(1, pData->sClassNum);
+		_dbCommand->FetchSingle(2, pData->ShortSword);
+		_dbCommand->FetchSingle(3, pData->Sword);
+		_dbCommand->FetchSingle(4, pData->Axe);
+		_dbCommand->FetchSingle(5, pData->Club);
+		_dbCommand->FetchSingle(6, pData->Spear);
+		_dbCommand->FetchSingle(7, pData->Pole);
+		_dbCommand->FetchSingle(8, pData->Staff);
+		_dbCommand->FetchSingle(9, pData->Bow);
+		_dbCommand->FetchSingle(10, pData->HP);
+		_dbCommand->FetchSingle(11, pData->MP);
+		_dbCommand->FetchSingle(12, pData->SP);
+		_dbCommand->FetchSingle(13, pData->AC);
+		_dbCommand->FetchSingle(14, pData->Hitrate);
+		_dbCommand->FetchSingle(15, pData->Evasionrate);
+
+		if (!m_pMap->PutData(pData->sClassNum, pData))
+			delete pData;
+
+		return true;
+	}
+
+	CoefficientArray *m_pMap;
+};

server/shared/database/CypherTableSet.h

@@ -0,0 +1,40 @@
+#pragma once
+
+class CCypherTableSet : public OdbcRecordset
+{
+public:
+	CCypherTableSet(OdbcConnection * dbConnection, CypherRingArray *pMap) 
+		: OdbcRecordset(dbConnection), m_pMap(pMap) {}
+
+	virtual tstring GetTableName() { return _T("USERDATA_CYPHER"); }
+	virtual tstring GetColumns() 
+	{
+		return _T("id, strUserId, strSerial, sClass, bLevel, iExp, bRace");
+	}
+
+	virtual bool Fetch()
+	{
+		int i = 1;
+		_CYPHERRING_DATA * pData = new _CYPHERRING_DATA;
+		_dbCommand->FetchUInt32(i++, pData->ID);
+		_dbCommand->FetchString(i++, pData->UserName);
+		_dbCommand->FetchUInt64(i++, pData->m_Serial);
+		_dbCommand->FetchByte(i++, pData->sClass);
+		_dbCommand->FetchByte(i++, pData->bLevel);
+		_dbCommand->FetchUInt64(i++, pData->iExp);
+		_dbCommand->FetchUInt16(i++, pData->bRace);
+
+		if (pData->ID > g_pMain->LastPetID)
+			g_pMain->LastPetID = pData->ID;
+		
+		if (pData == nullptr)
+			delete pData;
+		else
+			m_pMap->insert(std::make_pair(pData->m_Serial, pData));
+
+
+		return true;
+	}
+
+	CypherRingArray * m_pMap;
+};

server/shared/database/EventSet.h

@@ -0,0 +1,46 @@
+#pragma once
+
+class CEventSet : public OdbcRecordset
+{
+public:
+	CEventSet(OdbcConnection * dbConnection, ZoneArray *pZoneArray) 
+		: OdbcRecordset(dbConnection), m_pZoneArray(pZoneArray) {}
+
+	virtual tstring GetTableName() { return _T("EVENT"); }
+	virtual tstring GetColumns() { return _T("ZoneNum, EventNum, Type, Cond1, Cond2, Cond3, Cond4, Cond5, Exec1, Exec2, Exec3, Exec4, Exec5"); }
+
+	virtual bool Fetch()
+	{
+		CGameEvent *pData = new CGameEvent();
+		uint8 bZone;
+		int i = 1;
+
+		_dbCommand->FetchByte(i++, bZone);
+		_dbCommand->FetchUInt16(i++, pData->m_sIndex);
+		_dbCommand->FetchByte(i++, pData->m_bType);
+
+		// TODO: Get rid of this (need to tweak the database to just use int fields)
+		for (int j = 0; j < 5; j++)
+		{
+			char tmp[16];
+			_dbCommand->FetchString(i++, tmp, sizeof(tmp));
+			pData->m_iCond[j] = atoi(tmp);
+		}
+
+		for (int j = 0; j < 5; j++)
+		{
+			char tmp[16];
+			_dbCommand->FetchString(i++, tmp, sizeof(tmp));
+			pData->m_iExec[j] = atoi(tmp);
+		}
+
+		C3DMap *pZone = m_pZoneArray->GetData(bZone);
+		if (pZone == nullptr
+			|| !pZone->m_EventArray.PutData(pData->m_sIndex, pData))
+			delete pData;
+
+		return true;
+	}
+
+	ZoneArray * m_pZoneArray;
+};

server/shared/database/EventTimes.h

@@ -0,0 +1,31 @@
+#pragma once
+ 
+class CEventTimes : public OdbcRecordset
+{
+public:
+	CEventTimes(OdbcConnection * dbConnection, EventTimesArray * pMap) 
+    : OdbcRecordset(dbConnection), m_pMap(pMap) {}
+	
+	virtual tstring GetTableName() { return _T("EVENT_TIMES"); }
+	virtual tstring GetColumns() { return _T("sIndex, bTime1, bTime2, bTime3, bLvMin, bLvMax, AllDays"); }
+ 
+	virtual bool Fetch()
+	{
+		_EVENT_TIMES * pData = new _EVENT_TIMES;
+		
+		_dbCommand->FetchUInt16(1, pData->sIndex);
+		_dbCommand->FetchByte(2, pData->bTime1);
+		_dbCommand->FetchByte(3, pData->bTime2);
+		_dbCommand->FetchByte(4, pData->bTime3);
+		_dbCommand->FetchByte(5, pData->bLvMin);
+		_dbCommand->FetchByte(6, pData->bLvMax);
+		_dbCommand->FetchByte(7, pData->AllDays);
+ 
+     if (!m_pMap->PutData(pData->sIndex, pData))
+       delete pData;
+ 
+     return true;
+   }
+ 
+   EventTimesArray *m_pMap;
+ };

server/shared/database/EventTriggerSet.h

@@ -0,0 +1,28 @@
+ #pragma once
+
+class CEventTriggerSet : public OdbcRecordset
+{
+public:
+	CEventTriggerSet(OdbcConnection * dbConnection, EventTriggerArray * pMap) 
+		: OdbcRecordset(dbConnection), m_pMap(pMap) {}
+
+	virtual tstring GetTableName() { return _T("EVENT_TRIGGER"); }
+	virtual tstring GetColumns() { return _T("nIndex, bNpcType, sNpcID, nTriggerNum"); }
+
+	virtual bool Fetch()
+	{
+		_EVENT_TRIGGER * pData = new _EVENT_TRIGGER;
+
+		_dbCommand->FetchUInt32(1, pData->nIndex);
+		_dbCommand->FetchUInt16(2, pData->bNpcType);
+		_dbCommand->FetchUInt32(3, pData->sNpcID);
+		_dbCommand->FetchUInt32(4, pData->nTriggerNum);
+
+		if (!m_pMap->PutData(pData->nIndex, pData))
+			delete pData;
+
+		return true;
+	}
+
+	EventTriggerArray *m_pMap;
+};

server/shared/database/IlegalItems.h

@@ -0,0 +1,26 @@
+#pragma once
+
+class CIlegalItems : public OdbcRecordset
+{
+public:
+	CIlegalItems(OdbcConnection * dbConnection, IlegalItemsArray * pMap) 
+		: OdbcRecordset(dbConnection), m_pMap(pMap) {}
+
+	virtual tstring GetTableName() { return _T("ILEGAL_ITEMS"); }
+	virtual tstring GetColumns() { return _T("nIndex, nItemID"); }
+
+	virtual bool Fetch()
+	{
+		_ILEGAL_ITEMS * pData = new _ILEGAL_ITEMS;
+
+		_dbCommand->FetchUInt32(1, pData->i_Index);
+		_dbCommand->FetchUInt32(2, pData->i_ItemID);
+
+		if (!m_pMap->PutData(pData->i_Index, pData))
+			delete pData;
+
+		return true;
+	}
+
+	IlegalItemsArray *m_pMap;
+};

server/shared/database/ItemCrashSet.h

@@ -0,0 +1,30 @@
+#pragma once
+
+class CItemCrashSet : public OdbcRecordset
+{
+public:
+	CItemCrashSet(OdbcConnection * dbConnection, ItemCrashArray * pMap) 
+		: OdbcRecordset(dbConnection), m_pMap(pMap) {}
+
+	virtual tstring GetTableName() { return _T("ITEM_CRASH"); }
+	virtual tstring GetColumns() { return _T("nIndex,Flag,ItemID,ItemCount,SuccessRate"); }
+	virtual tstring GetOrderBy() { return _T("DropRate"); }
+
+	virtual bool Fetch()
+	{
+		_ITEM_CRASH * pData = new _ITEM_CRASH;
+
+		int index = 1;
+		_dbCommand->FetchUInt32(index++,pData->Index);
+		_dbCommand->FetchByte(index++, pData->Flag);
+		_dbCommand->FetchUInt32(index++, pData->ItemID);
+		_dbCommand->FetchUInt16(index++, pData->ItemCount);
+		_dbCommand->FetchUInt16(index++, pData->SuccessRate);
+
+		if(!m_pMap->PutData(pData->Index,pData))
+			delete pData;
+		return true;
+	}
+
+	ItemCrashArray *m_pMap;
+};

server/shared/database/ItemDuper.h

@@ -0,0 +1,28 @@
+#pragma once
+
+class CItemDuper : public OdbcRecordset
+{
+public:
+	CItemDuper(OdbcConnection * dbConnection, ItemDupersArray * pMap) 
+		: OdbcRecordset(dbConnection), m_pMap(pMap) {}
+
+	virtual tstring GetTableName() { return _T("ITEM_DUPERS"); }
+	virtual tstring GetColumns() { return _T("nIndex, nItemID, nSerial"); }
+
+	virtual bool Fetch()
+	{
+		_ITEM_DUPER * pData = new _ITEM_DUPER;
+
+		_dbCommand->FetchUInt32(1, pData->n_Index);
+		_dbCommand->FetchUInt32(2, pData->d_ItemID);
+		_dbCommand->FetchUInt64(3, pData->d_Serial);
+
+
+		if (!m_pMap->PutData(pData->n_Index, pData))
+			delete pData;
+
+		return true;
+	}
+
+	ItemDupersArray *m_pMap;
+};

server/shared/database/ItemExchangeExpSet.h

@@ -0,0 +1,39 @@
+#pragma once
+
+class CItemExchangeExpSet : public OdbcRecordset
+{
+public:
+	CItemExchangeExpSet(OdbcConnection * dbConnection, ItemExchangeExpArray *pMap) 
+		: OdbcRecordset(dbConnection), m_pMap(pMap) {}
+
+	virtual tstring GetTableName() { return _T("ITEM_EXCHANGE_EXP"); }
+	virtual tstring GetColumns() 
+	{
+		return _T("nIndex, bRandomFlag, "
+			"nExchangeItemNum1, nExchangeItemCount1, nExchangeItemNum2, nExchangeItemCount2,"
+			"nExchangeItemNum3, nExchangeItemCount3, "
+			"nExchangeItemNum4, nExchangeItemCount4, nExchangeItemNum5, nExchangeItemCount5");
+	}
+
+	virtual bool Fetch()
+	{
+		_ITEM_EXCHANGE_EXP *pData = new _ITEM_EXCHANGE_EXP;
+
+		int i = 1;
+		_dbCommand->FetchUInt32(i++, pData->nIndex);
+		_dbCommand->FetchByte(i++, pData->bRandomFlag);
+
+		for (int j = 0; j < ITEMS_IN_EXCHANGE_GROUP; j++)
+		{
+			_dbCommand->FetchUInt32(i++, pData->nExchangeItemNum[j]);
+			_dbCommand->FetchUInt32(i++, pData->sExchangeItemCount[j]);
+		}
+
+		if (!m_pMap->PutData(pData->nIndex, pData))
+			delete pData;
+
+		return true;
+	}
+
+	ItemExchangeExpArray * m_pMap;
+};

server/shared/database/ItemExchangeSet.h

@@ -0,0 +1,53 @@
+#pragma once
+
+class CItemExchangeSet : public OdbcRecordset
+{
+public:
+	CItemExchangeSet(OdbcConnection * dbConnection, ItemExchangeArray *pMap) 
+		: OdbcRecordset(dbConnection), m_pMap(pMap) {}
+
+	virtual tstring GetTableName() { return _T("ITEM_EXCHANGE"); }
+	virtual tstring GetColumns() 
+	{
+		return _T("nIndex, bRandomFlag,nUnk1, "
+			"nOriginItemNum1, nOriginItemCount1, nOriginItemNum2, nOriginItemCount2, "
+			"nOriginItemNum3, nOriginItemCount3, nOriginItemNum4, nOriginItemCount4, "
+			"nOriginItemNum5, nOriginItemCount5,"
+			"nExchangeItemNum1, nExchangeItemCount1, nExchangeItemNum2, nExchangeItemCount2, nExchangeItemNum3, nExchangeItemCount3, "
+			"nExchangeItemNum4, nExchangeItemCount4, nExchangeItemNum5, nExchangeItemCount5,nUnk2 , nUnk3, nUnk4, nUnk5");
+	}
+
+	virtual bool Fetch()
+	{
+		_ITEM_EXCHANGE *pData = new _ITEM_EXCHANGE;
+
+		int i = 1;
+		_dbCommand->FetchUInt32(i++, pData->nIndex);
+		_dbCommand->FetchByte(i++, pData->bRandomFlag);
+		_dbCommand->FetchUInt32(i++, pData->Unk1);
+
+		for (int x = 0; x < ITEMS_IN_ORIGIN_GROUP; x++)
+		{
+			_dbCommand->FetchUInt32(i++, pData->nOriginItemNum[x]);
+			_dbCommand->FetchUInt32(i++, pData->sOriginItemCount[x]);
+		}
+
+		for (int j = 0; j < ITEMS_IN_EXCHANGE_GROUP; j++)
+		{
+			_dbCommand->FetchUInt32(i++, pData->nExchangeItemNum[j]);
+			_dbCommand->FetchUInt32(i++, pData->sExchangeItemCount[j]);
+			
+		}
+		_dbCommand->FetchUInt32(i++, pData->Unk2);
+		_dbCommand->FetchUInt32(i++, pData->Unk3);
+		_dbCommand->FetchUInt32(i++, pData->Unk4);
+		_dbCommand->FetchUInt32(i++, pData->Unk5);
+
+		if (!m_pMap->PutData(pData->nIndex, pData))
+			delete pData;
+
+		return true;
+	}
+
+	ItemExchangeArray * m_pMap;
+};

server/shared/database/ItemMiningSet.h

@@ -0,0 +1,51 @@
+#pragma once
+
+class CItemMiningSet : public OdbcRecordset
+{
+public:
+	CItemMiningSet(OdbcConnection * dbConnection, ItemMiningArray *pMap) 
+		: OdbcRecordset(dbConnection), m_pMap(pMap) {}
+
+	virtual tstring GetTableName() { return _T("ITEM_MINING"); }
+	virtual tstring GetColumns() 
+	{
+		return _T("nIndex, ExchangeItemNum, ExchangeRate, isGoldenMattock");
+	}
+
+	virtual bool Fetch()
+	{
+		_MINING_ITEM *pData = new _MINING_ITEM;
+
+		int i = 1;
+
+		_dbCommand->FetchUInt32(i++, pData->nMiningID);
+		_dbCommand->FetchUInt32(i++, pData->nExchangeItemNum);
+		_dbCommand->FetchUInt16(i++, pData->sExchangeItemRate);
+		_dbCommand->FetchUInt16(i++, pData->isGoldenMattock);
+
+		if (pData->isGoldenMattock == 0)
+		{
+	for(int ad=0; ad < pData->sExchangeItemRate; ad++)
+		{
+				g_pMain->bRandArrayNormalMattock[g_pMain->TotalMiningExchangeRate + ad] = pData->nExchangeItemNum;
+		}
+			g_pMain->TotalMiningExchangeRate += pData->sExchangeItemRate;
+		}
+		else
+		{
+	for(int ad=0; ad < pData->sExchangeItemRate; ad++)
+		{
+				g_pMain->bRandArrayGoldenMattock[g_pMain->TotalGoldenMiningExchangeRate + ad] = pData->nExchangeItemNum;
+		}
+			g_pMain->TotalGoldenMiningExchangeRate += pData->sExchangeItemRate;
+		}
+	
+		
+		if (!m_pMap->PutData(pData->nMiningID, pData))
+			delete pData;
+
+		return true;
+	}
+
+	ItemMiningArray * m_pMap;
+};

server/shared/database/ItemMixSet.h

@@ -0,0 +1,60 @@
+#pragma once
+
+class CItemMixSet : public OdbcRecordset
+{
+public:
+	CItemMixSet(OdbcConnection * dbConnection, ItemMixArray *pMap) 
+		: OdbcRecordset(dbConnection), m_pMap(pMap) {}
+
+	virtual tstring GetTableName() { return _T("ITEM_MIX"); }
+	virtual tstring GetColumns() 
+	{
+		
+		return _T("nIndex, nNpcID,bType,strName,bStatus,"
+			"nOriginItemNum1, nOriginItemCount1, nOriginItemNum2, nOriginItemCount2, "
+			"nOriginItemNum3, nOriginItemCount3, nOriginItemNum4, nOriginItemCount4, "
+			"nOriginItemNum5, nOriginItemCount5,nOriginItemNum6, nOriginItemCount6,nOriginItemNum7, nOriginItemCount7,"
+			"nOriginItemNum8, nOriginItemCount8,nOriginItemNum9, nOriginItemCount9,nOriginItemNum10, nOriginItemCount10,"
+			"sSuccessEffect,bSuccessRate,sFailEffect,bBonusRate,"
+			"nExchangeItemNum1, nExchangeItemCount1, nExchangeItemNum2, nExchangeItemCount2, nExchangeItemNum3, nExchangeItemCount3, "
+			"nExchangeItemNum4, nExchangeItemCount4, nExchangeItemNum5, nExchangeItemCount5, nExchangeItemNum6, nExchangeItemCount6,"
+			"nExchangeItemNum7, nExchangeItemCount7, nExchangeItemNum8, nExchangeItemCount8, nExchangeItemNum9, nExchangeItemCount9, nExchangeItemNum10, nExchangeItemCount10");
+	}
+
+	virtual bool Fetch()
+	{
+		_ITEM_MIX *pData = new _ITEM_MIX;
+
+		int i = 1;
+		_dbCommand->FetchUInt32(i++, pData->nIndex);
+		_dbCommand->FetchUInt16(i++, pData->sNpcNum);
+		_dbCommand->FetchByte(i++, pData->bType);
+		_dbCommand->FetchString(i++, pData->strName);
+		_dbCommand->FetchByte(i++, pData->bStatus);
+
+		for (int x = 0; x < ITEMS_IN_SPECIAL_ORIGIN_GROUP; x++)
+		{
+			_dbCommand->FetchUInt32(i++, pData->nOriginItemNum[x]);
+			_dbCommand->FetchUInt16(i++, pData->sOriginItemCount[x]);
+		}
+
+		_dbCommand->FetchUInt16(i++, pData->sSuccessEffect);
+		_dbCommand->FetchUInt16(i++, pData->bSuccessRate);
+		_dbCommand->FetchUInt16(i++, pData->sFailEffect);
+		_dbCommand->FetchUInt16(i++, pData->bBonusRate);
+
+		for (int j = 0; j < ITEMS_IN_SPECIAL_EXCHANGE_GROUP; j++)
+		{
+			_dbCommand->FetchUInt32(i++, pData->nExchangeItemNum[j]);
+			_dbCommand->FetchUInt16(i++, pData->sExchangeItemCount[j]);
+			
+		}
+
+		if (!m_pMap->PutData(pData->nIndex, pData))
+			delete pData;
+
+		return true;
+	}
+
+	ItemMixArray *m_pMap;
+};

server/shared/database/ItemOpSet.h

@@ -0,0 +1,28 @@
+#pragma once
+
+class CItemOpSet : public OdbcRecordset
+{
+public:
+	CItemOpSet(OdbcConnection * dbConnection, ItemOpArray * pMap) 
+		: OdbcRecordset(dbConnection), m_pMap(pMap) {}
+
+	virtual tstring GetTableName() { return _T("ITEM_OP"); }
+	virtual tstring GetColumns() { return _T("nItemID, bTriggerType, nSkillID, bTriggerRate"); }
+
+	virtual bool Fetch()
+	{
+		_ITEM_OP * pData = new _ITEM_OP;
+
+		_dbCommand->FetchUInt32(1, pData->nItemID);
+		_dbCommand->FetchByte(2, pData->bTriggerType);
+		_dbCommand->FetchUInt32(3, pData->nSkillID);
+		_dbCommand->FetchByte(4, pData->bTriggerRate);
+
+		if (!m_pMap->PutData(pData->nItemID, pData))
+			delete pData;
+
+		return true;
+	}
+
+	ItemOpArray *m_pMap;
+};

server/shared/database/ItemTableSet.h

@@ -0,0 +1,85 @@
+#pragma once
+
+class CItemTableSet : public OdbcRecordset
+{
+public:
+	CItemTableSet(OdbcConnection * dbConnection, ItemtableArray * pMap) 
+		: OdbcRecordset(dbConnection), m_pMap(pMap) {}
+
+	virtual tstring GetTableName() { return _T("ITEM"); }
+	virtual tstring GetColumns() { return _T("Num, ItemExt, ItemClass, strName, Kind, Slot, Race, Class, Damage, Delay, Range, Weight, Duration, BuyPrice, SellPrice, Ac, Countable, Effect1, Effect2, ReqLevel, ReqLevelMax, ReqRank, ReqTitle, ReqStr, ReqSta, ReqDex, ReqIntel, ReqCha, SellingGroup, ItemType, Hitrate, Evasionrate, DaggerAc, SwordAc, MaceAc, AxeAc, SpearAc, BowAc, FireDamage, IceDamage, LightningDamage, PoisonDamage, HPDrain, MPDamage, MPDrain, MirrorDamage, StrB, StaB, DexB, IntelB, ChaB, MaxHpB, MaxMpB, FireR, ColdR, LightningR, MagicR, PoisonR, CurseR, NPbuyPrice"); }
+
+	virtual bool Fetch()
+	{
+		_ITEM_TABLE *pData = new _ITEM_TABLE;
+
+		int i = 1;
+		_dbCommand->FetchUInt32(i++, pData->m_iNum);
+		_dbCommand->FetchInt16(i++, pData->ItemExt);
+		_dbCommand->FetchInt16(i++, pData->ItemClass);
+		_dbCommand->FetchString(i++, pData->m_sName);
+		_dbCommand->FetchByte(i++, pData->m_bKind);
+		_dbCommand->FetchByte(i++, pData->m_bSlot);
+		_dbCommand->FetchByte(i++, pData->m_bRace);
+		_dbCommand->FetchByte(i++, pData->m_bClass);
+		_dbCommand->FetchUInt16(i++, pData->m_sDamage);
+		_dbCommand->FetchUInt16(i++, pData->m_sDelay);
+		_dbCommand->FetchUInt16(i++, pData->m_sRange);
+		_dbCommand->FetchUInt16(i++, pData->m_sWeight);
+		_dbCommand->FetchUInt16(i++, pData->m_sDuration);
+		_dbCommand->FetchUInt32(i++, pData->m_iBuyPrice);
+		_dbCommand->FetchUInt32(i++, pData->m_iSellPrice);
+		_dbCommand->FetchInt16(i++, pData->m_sAc);
+		_dbCommand->FetchByte(i++, pData->m_bCountable);
+		_dbCommand->FetchUInt32(i++, pData->m_iEffect1);
+		_dbCommand->FetchUInt32(i++, pData->m_iEffect2);
+		_dbCommand->FetchByte(i++, pData->m_bReqLevel);
+		_dbCommand->FetchByte(i++, pData->m_bReqLevelMax);
+		_dbCommand->FetchByte(i++, pData->m_bReqRank);
+		_dbCommand->FetchByte(i++, pData->m_bReqTitle);
+		_dbCommand->FetchByte(i++, pData->m_bReqStr);
+		_dbCommand->FetchByte(i++, pData->m_bReqSta);
+		_dbCommand->FetchByte(i++, pData->m_bReqDex);
+		_dbCommand->FetchByte(i++, pData->m_bReqIntel);
+		_dbCommand->FetchByte(i++, pData->m_bReqCha);
+		_dbCommand->FetchUInt32(i++, pData->m_bSellingGroup);
+		_dbCommand->FetchByte(i++, pData->m_ItemType);
+		_dbCommand->FetchUInt16(i++, pData->m_sHitrate);
+		_dbCommand->FetchUInt16(i++, pData->m_sEvarate);
+		_dbCommand->FetchUInt16(i++, pData->m_sDaggerAc);
+		_dbCommand->FetchUInt16(i++, pData->m_sSwordAc);
+		_dbCommand->FetchUInt16(i++, pData->m_sMaceAc);
+		_dbCommand->FetchUInt16(i++, pData->m_sAxeAc);
+		_dbCommand->FetchUInt16(i++, pData->m_sSpearAc);
+		_dbCommand->FetchUInt16(i++, pData->m_sBowAc);
+		_dbCommand->FetchByte(i++, pData->m_bFireDamage);
+		_dbCommand->FetchByte(i++, pData->m_bIceDamage);
+		_dbCommand->FetchByte(i++, pData->m_bLightningDamage);
+		_dbCommand->FetchByte(i++, pData->m_bPoisonDamage);
+		_dbCommand->FetchByte(i++, pData->m_bHPDrain);
+		_dbCommand->FetchByte(i++, pData->m_bMPDamage);
+		_dbCommand->FetchByte(i++, pData->m_bMPDrain);
+		_dbCommand->FetchByte(i++, pData->m_bMirrorDamage);
+		_dbCommand->FetchInt16(i++, pData->m_sStrB);
+		_dbCommand->FetchInt16(i++, pData->m_sStaB);
+		_dbCommand->FetchInt16(i++, pData->m_sDexB);
+		_dbCommand->FetchInt16(i++, pData->m_sIntelB);
+		_dbCommand->FetchInt16(i++, pData->m_sChaB);
+		_dbCommand->FetchInt16(i++, pData->m_MaxHpB);
+		_dbCommand->FetchInt16(i++, pData->m_MaxMpB);
+		_dbCommand->FetchInt16(i++, pData->m_bFireR);
+		_dbCommand->FetchInt16(i++, pData->m_bColdR);
+		_dbCommand->FetchInt16(i++, pData->m_bLightningR);
+		_dbCommand->FetchInt16(i++, pData->m_bMagicR);
+		_dbCommand->FetchInt16(i++, pData->m_bPoisonR);
+		_dbCommand->FetchInt16(i++, pData->m_bCurseR);
+		_dbCommand->FetchUInt32(i++, pData->m_iNPBuyPrice);
+
+		if (!m_pMap->PutData(pData->m_iNum, pData))
+			delete pData;
+
+		return true;
+	}
+
+	ItemtableArray *m_pMap;
+};

server/shared/database/ItemUpgradeSet.h

@@ -0,0 +1,37 @@
+#pragma once
+
+class CItemUpgradeSet : public OdbcRecordset
+{
+public:
+	CItemUpgradeSet(OdbcConnection * dbConnection, ItemUpgradeArray * pMap) 
+		: OdbcRecordset(dbConnection), m_pMap(pMap) {}
+
+	virtual tstring GetTableName() { return _T("ITEM_UPGRADE"); }
+	virtual tstring GetColumns() { return _T("nIndex, nNPCNum, nOriginType, nOriginItem, "
+		"nReqItem1, nReqItem2, nReqItem3, nReqItem4, nReqItem5, nReqItem6, nReqItem7, nReqItem8, "
+		"nReqNoah, bRateType, nGenRate, nGiveItem"); }
+
+	virtual bool Fetch()
+	{
+		_ITEM_UPGRADE *pData = new _ITEM_UPGRADE;
+
+		int i = 1;
+		_dbCommand->FetchUInt32(i++, pData->nIndex);
+		_dbCommand->FetchUInt16(i++, pData->sNpcNum);
+		_dbCommand->FetchSByte(i++, pData->bOriginType);
+		_dbCommand->FetchUInt16(i++, pData->sOriginItem);
+		for (int x = 0; x < MAX_ITEMS_REQ_FOR_UPGRADE; x++)
+			_dbCommand->FetchUInt32(i++, pData->nReqItem[x]);
+		_dbCommand->FetchUInt32(i++, pData->nReqNoah);
+		_dbCommand->FetchByte(i++, pData->bRateType);
+		_dbCommand->FetchUInt16(i++, pData->sGenRate);
+		_dbCommand->FetchInt32(i++, pData->nGiveItem);
+
+		if (!m_pMap->PutData(pData->nIndex, pData))
+			delete pData;
+
+		return true;
+	}
+
+	ItemUpgradeArray *m_pMap;
+};

server/shared/database/KingCandidacyNoticeBoardSet.h

@@ -0,0 +1,52 @@
+#pragma once
+
+class CKingCandidacyNoticeBoardSet : public OdbcRecordset
+{
+public:
+	CKingCandidacyNoticeBoardSet(OdbcConnection * dbConnection, KingSystemArray * pMap) 
+		: OdbcRecordset(dbConnection), m_pMap(pMap) {}
+
+	virtual tstring GetTableName() { return _T("KING_CANDIDACY_NOTICE_BOARD"); }
+	virtual tstring GetColumns() { return _T("byNation, strUserID, strNotice"); }
+
+	virtual bool Fetch()
+	{
+		CKingSystem * pData;
+		uint8 byNation;
+
+		// Pull the nation first so we can use it as an ID.
+		_dbCommand->FetchByte(1, byNation);
+
+		// Hi, I'll take a map for 2 please.
+		if (byNation != KARUS && byNation != ELMORAD)
+			return false;
+
+		// Do we have an entry for this nation already?
+		pData = m_pMap->GetData(byNation);
+
+		// We don't? Nothing to do here.
+		if (pData == nullptr)
+			return true;
+
+		std::string strUserID;
+		char strNotice[1024];	// strNotice is always a 1024 byte binary field 
+		// which we implicitly create a variable sized std::string from to save memory.
+
+		_dbCommand->FetchString(2, strUserID);
+		_dbCommand->FetchBinary(3, strNotice, sizeof(strNotice));
+
+		// Is this user added to the map already?
+		KingCandidacyNoticeBoardMap::iterator itr = pData->m_noticeBoardMap.find(strUserID);
+
+		// Nope, let's add them.
+		if (itr == pData->m_noticeBoardMap.end())
+			pData->m_noticeBoardMap.insert(make_pair(strUserID, strNotice));
+		// They do, replace the notice board entry (no need to clear for reloads).
+		else
+			itr->second = strNotice;
+
+		return true;
+	}
+
+	KingSystemArray * m_pMap;
+};

server/shared/database/KingElectionListSet.h

@@ -0,0 +1,67 @@
+#pragma once
+
+class CKingElectionListSet : public OdbcRecordset
+{
+public:
+	CKingElectionListSet(OdbcConnection * dbConnection, KingSystemArray * pMap) 
+		: OdbcRecordset(dbConnection), m_pMap(pMap) {}
+
+	virtual tstring GetTableName() { return _T("KING_ELECTION_LIST"); }
+	virtual tstring GetColumns() { return _T("byNation, byType, strName, nKnights, nMoney"); }
+
+	virtual bool Fetch()
+	{
+		CKingSystem * pData;
+		uint8 byNation, byType;
+
+		// Pull the nation first so we can use it as an ID.
+		_dbCommand->FetchByte(1, byNation);
+
+		// Hi, I'll take a map for 2 please.
+		if (byNation != KARUS && byNation != ELMORAD)
+			return false;
+
+		// Do we have an entry for this nation already?
+		pData = m_pMap->GetData(byNation);
+
+		// We don't? Nothing to do here.
+		if (pData == nullptr)
+			return true;
+		/**
+		* byType list:
+		* 1 = ???
+		* 2 = elected senator to replace King?
+		* 3 = ???
+		* 4 = candidate for King
+		**/
+
+		_dbCommand->FetchByte(2, byType);
+
+		// Only support senators / nominated/elected Kings for now.
+		if (byType != 3 && byType != 4)
+			return true;
+
+		std::string strUserID;
+		_dbCommand->FetchString(3, strUserID);
+
+		KingElectionList * pList = (byType == 3 ? &pData->m_senatorList : &pData->m_candidateList);
+
+		// Is this user added to the list already?
+		KingElectionList::iterator itr = pList->find(strUserID);
+
+		// Nope, let's add them.
+		if (itr == pList->end())
+		{
+			_KING_ELECTION_LIST * pEntry = new _KING_ELECTION_LIST;
+
+			_dbCommand->FetchUInt16(4, pEntry->sKnights);
+			_dbCommand->FetchUInt32(5, pEntry->nVotes); // probably not needed as this is all handled in the procs as far as I know
+
+			pList->insert(make_pair(strUserID, pEntry));
+		}
+
+		return true;
+	}
+
+	KingSystemArray * m_pMap;
+};

server/shared/database/KingSystemSet.h

@@ -0,0 +1,94 @@
+#pragma once
+
+class CKingSystemSet : public OdbcRecordset
+{
+public:
+	CKingSystemSet(OdbcConnection * dbConnection, KingSystemArray * pMap) 
+		: OdbcRecordset(dbConnection), m_pMap(pMap) {}
+
+	virtual tstring GetTableName() { return _T("KING_SYSTEM"); }
+	virtual tstring GetColumns() { return _T("byNation, byType, sYear, byMonth, byDay, byHour, byMinute, byImType, sImYear, byImMonth, byImDay, byImHour, byImMinute, byNoahEvent, byNoahEvent_Day, byNoahEvent_Hour, byNoahEvent_Minute, sNoahEvent_Duration, byExpEvent, byExpEvent_Day, byExpEvent_Hour, byExpEvent_Minute, sExpEvent_Duration, nTribute, byTerritoryTariff, nTerritoryTax, nNationalTreasury, strKingName, strImRequestID"); }
+
+	virtual bool Fetch()
+	{
+		CKingSystem * pData;
+		uint8 byNation;
+		uint32 i = 1;
+
+		// Pull the nation first so we can use it as an ID.
+		_dbCommand->FetchByte(i++, byNation);
+
+		// Hi, I'll take a map for 2 please.
+		if (byNation != KARUS && byNation != ELMORAD)
+			return true;
+
+		// Do we have an entry for this nation already?
+		pData = m_pMap->GetData(byNation);
+
+		// We don't? Create one.
+		if (pData == nullptr)
+		{
+			pData = new CKingSystem();
+
+			// We don't need to check if it exists, because if it did
+			// we wouldn't be here...
+			m_pMap->PutData(byNation, pData);
+		}
+
+		// Let's set the nation then read the rest of the data from the table.
+		pData->m_byNation = byNation;
+
+		/* Election */
+		_dbCommand->FetchByte(i++, pData->m_byType);
+		_dbCommand->FetchUInt16(i++, pData->m_sYear);
+		_dbCommand->FetchByte(i++, pData->m_byMonth);
+		_dbCommand->FetchByte(i++, pData->m_byDay);
+		_dbCommand->FetchByte(i++, pData->m_byHour);
+		_dbCommand->FetchByte(i++, pData->m_byMinute);
+
+		/* Impeachment */
+		_dbCommand->FetchByte(i++, pData->m_byImType);
+		_dbCommand->FetchUInt16(i++, pData->m_sImYear);
+		_dbCommand->FetchByte(i++, pData->m_byImMonth);
+		_dbCommand->FetchByte(i++, pData->m_byImDay);
+		_dbCommand->FetchByte(i++, pData->m_byImHour);
+		_dbCommand->FetchByte(i++, pData->m_byImMinute);
+
+		/* King events */
+
+		// Noah
+		_dbCommand->FetchByte(i++, pData->m_byNoahEvent);
+		_dbCommand->FetchByte(i++, pData->m_byNoahEvent_Day);
+		_dbCommand->FetchByte(i++, pData->m_byNoahEvent_Hour);
+		_dbCommand->FetchByte(i++, pData->m_byNoahEvent_Minute);
+		_dbCommand->FetchUInt16(i++, pData->m_sNoahEvent_Duration);
+
+		// Experience
+		_dbCommand->FetchByte(i++, pData->m_byExpEvent);
+		_dbCommand->FetchByte(i++, pData->m_byExpEvent_Day);
+		_dbCommand->FetchByte(i++, pData->m_byExpEvent_Hour);
+		_dbCommand->FetchByte(i++, pData->m_byExpEvent_Minute);
+		_dbCommand->FetchUInt16(i++, pData->m_sExpEvent_Duration);
+
+		/* Money, money, money. */
+		_dbCommand->FetchUInt32(i++, pData->m_nTribute);
+		_dbCommand->FetchByte(i++, pData->m_nTerritoryTariff);
+		_dbCommand->FetchUInt32(i++, pData->m_nTerritoryTax);
+		_dbCommand->FetchUInt32(i++, pData->m_nNationalTreasury);
+
+		C3DMap * pMap = g_pMain->GetZoneByID(pData->m_byNation);
+		if (pMap != nullptr)
+			pMap->SetTariff(pData->m_nTerritoryTariff);
+
+		
+		/* Names are so hard to remember. */
+		_dbCommand->FetchString(i++, pData->m_strKingName);
+		_dbCommand->FetchString(i++, pData->m_strImRequestID);
+
+		pData->ResetElectionLists();
+
+		return true;
+	}
+
+	KingSystemArray * m_pMap;
+};

server/shared/database/KnightsAllianceSet.h

@@ -0,0 +1,30 @@
+#pragma once
+
+class CKnightsAllianceSet : public OdbcRecordset
+{
+public:
+	CKnightsAllianceSet(OdbcConnection * dbConnection, KnightsAllianceArray * pMap) 
+		: OdbcRecordset(dbConnection), m_pMap(pMap) {}
+
+	virtual tstring GetTableName() { return _T("KNIGHTS_ALLIANCE"); }
+	virtual tstring GetColumns() { return _T("sMainAllianceKnights, sSubAllianceKnights, sMercenaryClan_1, sMercenaryClan_2"); }
+
+	virtual bool Fetch()
+	{
+		_KNIGHTS_ALLIANCE *pData = new _KNIGHTS_ALLIANCE;
+
+		_dbCommand->FetchUInt16(1, pData->sMainAllianceKnights);
+		_dbCommand->FetchUInt16(2, pData->sSubAllianceKnights);
+		_dbCommand->FetchUInt16(3, pData->sMercenaryClan_1);
+		_dbCommand->FetchUInt16(4, pData->sMercenaryClan_2);
+
+		CKnights * pKnights = g_pMain->GetClanPtr(pData->sMainAllianceKnights);
+		if (pKnights == nullptr
+			|| !m_pMap->PutData(pData->sMainAllianceKnights, pData))
+			delete pData;
+
+		return true;
+	}
+
+	KnightsAllianceArray *m_pMap;
+};

server/shared/database/KnightsCapeSet.h

@@ -0,0 +1,29 @@
+#pragma once
+
+class CKnightsCapeSet : public OdbcRecordset
+{
+public:
+	CKnightsCapeSet(OdbcConnection * dbConnection, KnightsCapeArray * pMap) 
+		: OdbcRecordset(dbConnection), m_pMap(pMap) {}
+
+	virtual tstring GetTableName() { return _T("KNIGHTS_CAPE"); }
+	virtual tstring GetColumns() { return _T("sCapeIndex, nBuyPrice, byGrade, nBuyLoyalty, byRanking"); }
+
+	virtual bool Fetch()
+	{
+		_KNIGHTS_CAPE *pData = new _KNIGHTS_CAPE;
+
+		_dbCommand->FetchUInt16(1, pData->sCapeIndex);
+		_dbCommand->FetchUInt32(2, pData->nReqCoins);
+		_dbCommand->FetchByte(3, pData->byGrade);
+		_dbCommand->FetchUInt32(4, pData->nReqClanPoints);
+		_dbCommand->FetchByte(5, pData->byRanking);
+
+		if (!m_pMap->PutData(pData->sCapeIndex, pData))
+			delete pData;
+
+		return true;
+	}
+
+	KnightsCapeArray *m_pMap;
+};

server/shared/database/KnightsRankSet.h

@@ -0,0 +1,69 @@
+#pragma once
+
+class CKnightsRankSet : public OdbcRecordset
+{
+public:
+	CKnightsRankSet(OdbcConnection * dbConnection, void * dummy) 
+		: OdbcRecordset(dbConnection), nKarusCount(0), nElmoCount(0) 
+	{
+		memset(&strKarusCaptain, 0, sizeof(strKarusCaptain));
+		memset(&strElmoCaptain, 0, sizeof(strElmoCaptain));
+	}
+
+	virtual tstring GetTableName() { return _T("KNIGHTS_RATING"); }
+	virtual tstring GetColumns() { return _T("nRank, shIndex, nPoints"); }
+
+	virtual bool Fetch()
+	{
+		_KNIGHTS_RATING * pData = new _KNIGHTS_RATING;
+
+		_dbCommand->FetchUInt32(1, pData->nRank);
+		_dbCommand->FetchUInt16(2, pData->sClanID);
+		_dbCommand->FetchUInt32(3, pData->nPoints);
+
+		CKnights *pKnights = g_pMain->GetClanPtr(pData->sClanID);
+		if (pKnights == nullptr 
+			|| (pKnights->m_byNation != KARUS && pKnights->m_byNation != ELMORAD)
+			|| !g_pMain->m_KnightsRatingArray[pKnights->m_byNation - 1].PutData(pData->nRank, pData))
+		{
+			delete pData;
+			return true;
+		}
+
+		if (pKnights->m_byNation == KARUS)
+		{
+			if (nKarusCount == 5)
+				return true;
+
+			CUser *pUser = g_pMain->GetUserPtr(pKnights->m_strChief, TYPE_CHARACTER);
+			if (pUser == nullptr || !pUser->GetMap()->isWarZone())
+				return true;
+
+			if (pUser->GetClanID() == pData->sClanID)
+			{
+				_snprintf(strKarusCaptain[nKarusCount++], 50, "[%s][%s]", pKnights->m_strName.c_str(), pUser->GetName().c_str());
+				pUser->ChangeFame(COMMAND_CAPTAIN);
+			}
+		}
+		else if (pKnights->m_byNation == ELMORAD)
+		{
+			if (nElmoCount == 5)
+				return true;
+
+			CUser *pUser = g_pMain->GetUserPtr(pKnights->m_strChief, TYPE_CHARACTER);
+			if (pUser == nullptr || !pUser->GetMap()->isWarZone())
+				return true;
+
+			if (pUser->GetClanID() == pData->sClanID)
+			{
+				_snprintf(strElmoCaptain[nElmoCount++], 50, "[%s][%s]", pKnights->m_strName.c_str(), pUser->GetName().c_str());
+				pUser->ChangeFame(COMMAND_CAPTAIN);
+			}
+		}
+
+		return true;
+	}
+
+	char strKarusCaptain[5][50], strElmoCaptain[5][50];	
+	uint32 nKarusCount, nElmoCount;
+};

server/shared/database/KnightsSet.h

@@ -0,0 +1,53 @@
+#pragma once
+
+class CKnightsSet : public OdbcRecordset
+{
+public:
+	CKnightsSet(OdbcConnection * dbConnection, KnightsArray * pMap) 
+		: OdbcRecordset(dbConnection), m_pMap(pMap) {}
+
+	virtual tstring GetTableName() { return _T("KNIGHTS"); }
+	virtual tstring GetColumns() { return _T("IDNum, Flag, Nation, Ranking, IDName, Members, Chief, ViceChief_1, ViceChief_2, ViceChief_3, Gold, Domination, Points, Mark, sMarkVersion, sMarkLen, sCape, bCapeR, bCapeG, bCapeB, sAllianceKnights, ClanPointFund, strClanNotice, bySiegeFlag, nLose, nVictory, ClanPointMethod"); }
+
+	virtual bool Fetch()
+	{
+		CKnights *pData = new CKnights();
+
+		_dbCommand->FetchUInt16(1, pData->m_sIndex);
+		_dbCommand->FetchByte(2, pData->m_byFlag);
+		_dbCommand->FetchByte(3, pData->m_byNation);
+		_dbCommand->FetchByte(4, pData->m_byRanking);
+		_dbCommand->FetchString(5, pData->m_strName);
+		_dbCommand->FetchUInt16(6, pData->m_sMembers);
+		_dbCommand->FetchString(7, pData->m_strChief);
+		_dbCommand->FetchString(8, pData->m_strViceChief_1);
+		_dbCommand->FetchString(9, pData->m_strViceChief_2);
+		_dbCommand->FetchString(10, pData->m_strViceChief_3);
+		_dbCommand->FetchUInt64(11, pData->m_nMoney);
+		_dbCommand->FetchUInt16(12, pData->m_sDomination);
+		_dbCommand->FetchUInt32(13, (uint32 &) pData->m_nPoints);
+		_dbCommand->FetchBinary(14, pData->m_Image, sizeof(pData->m_Image));
+		_dbCommand->FetchUInt16(15, pData->m_sMarkVersion);
+		_dbCommand->FetchUInt16(16, pData->m_sMarkLen);
+		_dbCommand->FetchUInt16(17, pData->m_sCape);
+		_dbCommand->FetchByte(18, pData->m_bCapeR);
+		_dbCommand->FetchByte(19, pData->m_bCapeG);
+		_dbCommand->FetchByte(20, pData->m_bCapeB);
+		_dbCommand->FetchUInt16(21, pData->m_sAlliance);
+		_dbCommand->FetchUInt32(22, (uint32 &) pData->m_nClanPointFund);
+		_dbCommand->FetchString(23, pData->m_strClanNotice);
+		_dbCommand->FetchByte(24, pData->bySiegeFlag);
+		_dbCommand->FetchUInt16(25, pData->nLose);
+		_dbCommand->FetchUInt16(26, pData->nVictory);
+		_dbCommand->FetchByte(24, pData->m_sClanPointMethod);
+
+		pData->m_byGrade = g_pMain->GetKnightsGrade(pData->m_nPoints);
+
+		if (!m_pMap->PutData(pData->m_sIndex, pData))
+			delete pData;
+
+		return true;
+	}
+
+	KnightsArray *m_pMap;
+};

server/shared/database/KnightsSiegeWar.h

@@ -0,0 +1,64 @@
+ #pragma once
+
+class CKnightsSiegeWarfare : public OdbcRecordset
+{
+public:
+	CKnightsSiegeWarfare(OdbcConnection * dbConnection, KnightsSiegeWarfareArray * pMap) 
+		: OdbcRecordset(dbConnection), m_pMap(pMap) {}
+
+	virtual tstring GetTableName() { return _T("KNIGHTS_SIEGE_WARFARE"); }
+	virtual tstring GetColumns() { return _T("sCastleIndex, sMasterKnights, bySiegeType, byWarDay, byWarTime, byWarMinute, sChallengeList_1, sChallengeList_2, sChallengeList_3, sChallengeList_4, sChallengeList_5, sChallengeList_6, sChallengeList_7, sChallengeList_8, sChallengeList_9, sChallengeList_10, byWarRequestDay, byWarRequestTime, byWarRequestMinute, byGuerrillaWarDay, byGuerrillaWarTime, byGuerrillaWarMinute, strChallengeList, sMoradonTariff, sDellosTariff, nDungeonCharge, nMoradonTax, nDellosTax, sRequestList_1, sRequestList_2, sRequestList_3, sRequestList_4, sRequestList_5, sRequestList_6, sRequestList_7, sRequestList_8, sRequestList_9, sRequestList_10"); }
+
+	virtual bool Fetch()
+	{
+		_KNIGHTS_SIEGE_WARFARE * pData = new _KNIGHTS_SIEGE_WARFARE;
+		int i = 1;
+
+		_dbCommand->FetchUInt16(i++, pData->sCastleIndex);
+		_dbCommand->FetchUInt16(i++, pData->sMasterKnights);
+		_dbCommand->FetchByte(i++, pData->bySiegeType);
+		_dbCommand->FetchByte(i++, pData->byWarDay);
+		_dbCommand->FetchByte(i++, pData->byWarTime);
+		_dbCommand->FetchByte(i++, pData->byWarMinute);
+		_dbCommand->FetchUInt16(i++, pData->sChallengeList_1);
+		_dbCommand->FetchUInt16(i++, pData->sChallengeList_2);
+		_dbCommand->FetchUInt16(i++, pData->sChallengeList_3);
+		_dbCommand->FetchUInt16(i++, pData->sChallengeList_4);
+		_dbCommand->FetchUInt16(i++, pData->sChallengeList_5);
+		_dbCommand->FetchUInt16(i++, pData->sChallengeList_6);
+		_dbCommand->FetchUInt16(i++, pData->sChallengeList_7);
+		_dbCommand->FetchUInt16(i++, pData->sChallengeList_8);
+		_dbCommand->FetchUInt16(i++, pData->sChallengeList_9);
+		_dbCommand->FetchUInt16(i++, pData->sChallengeList_10);
+		_dbCommand->FetchByte(i++, pData->byWarRequestDay);
+		_dbCommand->FetchByte(i++, pData->byWarRequestTime);
+		_dbCommand->FetchByte(i++, pData->byWarRequestMinute);
+		_dbCommand->FetchByte(i++, pData->byGuerrillaWarDay);
+		_dbCommand->FetchByte(i++, pData->byGuerrillaWarTime);
+		_dbCommand->FetchByte(i++, pData->byGuerrillaWarMinute);
+		_dbCommand->FetchString(i++, pData->strChallengeList);
+		_dbCommand->FetchUInt16(i++, pData->sMoradonTariff);
+		_dbCommand->FetchUInt16(i++, pData->sDellosTariff);
+		_dbCommand->FetchInt32(i++, pData->nDungeonCharge);
+		_dbCommand->FetchInt32(i++, pData->nMoradonTax);
+		_dbCommand->FetchInt32(i++, pData->nDellosTax);
+		_dbCommand->FetchUInt16(i++, pData->sRequestList_1);
+		_dbCommand->FetchUInt16(i++, pData->sRequestList_2);
+		_dbCommand->FetchUInt16(i++, pData->sRequestList_3);
+		_dbCommand->FetchUInt16(i++, pData->sRequestList_4);
+		_dbCommand->FetchUInt16(i++, pData->sRequestList_5);
+		_dbCommand->FetchUInt16(i++, pData->sRequestList_6);
+		_dbCommand->FetchUInt16(i++, pData->sRequestList_7);
+		_dbCommand->FetchUInt16(i++, pData->sRequestList_8);
+		_dbCommand->FetchUInt16(i++, pData->sRequestList_9);
+		_dbCommand->FetchUInt16(i++, pData->sRequestList_10);
+
+
+		if (!m_pMap->PutData(pData->sCastleIndex, pData))
+			delete pData;
+
+		return true;
+	}
+
+	KnightsSiegeWarfareArray *m_pMap;
+};

server/shared/database/KnightsUserSet.h

@@ -0,0 +1,26 @@
+#pragma once
+
+class CKnightsUserSet : public OdbcRecordset
+{
+public:
+	CKnightsUserSet(OdbcConnection * dbConnection, void * dummy) 
+		: OdbcRecordset(dbConnection) {}
+
+	virtual tstring GetTableName() { return _T("KNIGHTS_USER"); }
+	virtual tstring GetColumns() { return _T("sIDNum, strUserID, nDonatedNP"); }
+
+	virtual bool Fetch()
+	{
+		uint16 sIDNum;
+		std::string strUserID;
+		uint32 nDonatedNP;
+
+		_dbCommand->FetchUInt16(1, sIDNum);
+		_dbCommand->FetchString(2, strUserID);
+		_dbCommand->FetchUInt32(3, nDonatedNP);
+
+		CKnightsManager::AddKnightsUser(sIDNum, strUserID);
+		CKnightsManager::LoadUserDonatedNP(sIDNum, strUserID, nDonatedNP, false);
+		return true;
+	}
+};

server/shared/database/LevelUpTableSet.h

@@ -0,0 +1,25 @@
+#pragma once
+
+class CLevelUpTableSet : public OdbcRecordset
+{
+public:
+	CLevelUpTableSet(OdbcConnection * dbConnection, LevelUpArray * pMap) 
+		: OdbcRecordset(dbConnection), m_pMap(pMap) {}
+
+	virtual tstring GetTableName() { return _T("LEVEL_UP"); }
+	virtual tstring GetColumns() { return _T("[Level], [Exp]"); }
+
+	virtual bool Fetch()
+	{
+		std::pair<uint8, int64> pData;
+
+		_dbCommand->FetchByte(1, pData.first);
+		_dbCommand->FetchInt64(2, pData.second);
+
+		m_pMap->insert(pData);
+
+		return true;
+	}
+
+	LevelUpArray *m_pMap;
+};

server/shared/database/MagicTableSet.h

@@ -0,0 +1,46 @@
+#pragma once
+
+class CMagicTableSet : public OdbcRecordset
+{
+public:
+	CMagicTableSet(OdbcConnection * dbConnection, MagictableArray * pMap) 
+		: OdbcRecordset(dbConnection), m_pMap(pMap) {}
+
+	virtual tstring GetTableName() { return _T("MAGIC"); }
+	virtual tstring GetColumns() { return _T("MagicNum, BeforeAction, TargetAction, SelfEffect, FlyingEffect, TargetEffect, Moral, SkillLevel, Skill, Msp, HP, ItemGroup, UseItem, CastTime, ReCastTime, SuccessRate, Type1, Type2, Range, UseStanding, Etc"); }
+
+	virtual bool Fetch()
+	{
+		_MAGIC_TABLE *pData = new _MAGIC_TABLE;
+
+		int i = 1;
+		_dbCommand->FetchUInt32(i++, pData->iNum);
+		_dbCommand->FetchUInt32(i++, pData->nBeforeAction);
+		_dbCommand->FetchByte(i++, pData->bTargetAction);
+		_dbCommand->FetchByte(i++, pData->bSelfEffect);
+		_dbCommand->FetchUInt16(i++, pData->bFlyingEffect);
+		_dbCommand->FetchUInt16(i++, pData->iTargetEffect);
+		_dbCommand->FetchByte(i++, pData->bMoral);
+		_dbCommand->FetchUInt16(i++, pData->sSkillLevel);
+		_dbCommand->FetchUInt16(i++, pData->sSkill);
+		_dbCommand->FetchUInt16(i++, pData->sMsp);
+		_dbCommand->FetchUInt16(i++, pData->sHP);
+		_dbCommand->FetchByte(i++, pData->bItemGroup);
+		_dbCommand->FetchUInt32(i++, pData->iUseItem);
+		_dbCommand->FetchByte(i++, pData->bCastTime);
+		_dbCommand->FetchUInt16(i++, pData->sReCastTime);
+		_dbCommand->FetchByte(i++, pData->bSuccessRate);
+		_dbCommand->FetchByte(i++, pData->bType[0]);
+		_dbCommand->FetchByte(i++, pData->bType[1]);
+		_dbCommand->FetchUInt16(i++, pData->sRange);
+		_dbCommand->FetchByte(i++, pData->sUseStanding);
+		_dbCommand->FetchUInt16(i++, pData->sEtc);
+
+		if (!m_pMap->PutData(pData->iNum, pData))
+			delete pData;
+
+		return true;
+	}
+
+	MagictableArray *m_pMap;
+};

server/shared/database/MagicType1Set.h

@@ -0,0 +1,34 @@
+#pragma once
+
+class CMagicType1Set : public OdbcRecordset
+{
+public:
+	CMagicType1Set(OdbcConnection * dbConnection, Magictype1Array * pMap) 
+		: OdbcRecordset(dbConnection), m_pMap(pMap) {}
+
+	virtual tstring GetTableName() { return _T("MAGIC_TYPE1"); }
+	virtual tstring GetColumns() { return _T("iNum, Type, HitRate, Hit, AddDamage, Delay, ComboType, ComboCount, ComboDamage, Range"); }
+
+	virtual bool Fetch()
+	{
+		_MAGIC_TYPE1 *pData = new _MAGIC_TYPE1;
+
+		_dbCommand->FetchUInt32(1, pData->iNum);
+		_dbCommand->FetchByte(2, pData->bHitType);
+		_dbCommand->FetchUInt16(3, pData->sHitRate);
+		_dbCommand->FetchUInt16(4, pData->sHit);
+		_dbCommand->FetchUInt16(5, pData->sAddDamage);
+		_dbCommand->FetchByte(6, pData->bDelay);
+		_dbCommand->FetchByte(7, pData->bComboType);
+		_dbCommand->FetchByte(8, pData->bComboCount);
+		_dbCommand->FetchUInt16(9, pData->sComboDamage);
+		_dbCommand->FetchUInt16(10, pData->sRange);
+
+		if (!m_pMap->PutData(pData->iNum, pData))
+			delete pData;
+
+		return true;
+	}
+
+	Magictype1Array *m_pMap;
+};

server/shared/database/MagicType2Set.h

@@ -0,0 +1,30 @@
+#pragma once
+
+class CMagicType2Set : public OdbcRecordset
+{
+public:
+	CMagicType2Set(OdbcConnection * dbConnection, Magictype2Array * pMap) 
+		: OdbcRecordset(dbConnection), m_pMap(pMap) {}
+
+	virtual tstring GetTableName() { return _T("MAGIC_TYPE2"); }
+	virtual tstring GetColumns() { return _T("iNum, HitType, HitRate, AddDamage, AddRange, NeedArrow"); }
+
+	virtual bool Fetch()
+	{
+		_MAGIC_TYPE2 *pData = new _MAGIC_TYPE2;
+
+		_dbCommand->FetchUInt32(1, pData->iNum);
+		_dbCommand->FetchByte(2, pData->bHitType);
+		_dbCommand->FetchUInt16(3, pData->sHitRate);
+		_dbCommand->FetchUInt16(4, pData->sAddDamage);
+		_dbCommand->FetchUInt16(5, pData->sAddRange);
+		_dbCommand->FetchByte(6, pData->bNeedArrow);
+
+		if (!m_pMap->PutData(pData->iNum, pData))
+			delete pData;
+
+		return true;
+	}
+
+	Magictype2Array *m_pMap;
+};

server/shared/database/MagicType3Set.h

@@ -0,0 +1,32 @@
+#pragma once
+
+class CMagicType3Set : public OdbcRecordset
+{
+public:
+	CMagicType3Set(OdbcConnection * dbConnection, Magictype3Array * pMap) 
+		: OdbcRecordset(dbConnection), m_pMap(pMap) {}
+
+	virtual tstring GetTableName() { return _T("MAGIC_TYPE3"); }
+	virtual tstring GetColumns() { return _T("iNum,Radius, DirectType, FirstDamage, TimeDamage, Duration, Attribute"); }
+
+	virtual bool Fetch()
+	{
+		_MAGIC_TYPE3 *pData = new _MAGIC_TYPE3;
+
+		_dbCommand->FetchUInt32(1, pData->iNum);
+		_dbCommand->FetchByte(2, pData->bRadius);
+		_dbCommand->FetchByte(3, pData->bDirectType);
+		_dbCommand->FetchInt16(4, pData->sFirstDamage);
+		_dbCommand->FetchInt16(5, pData->sTimeDamage);
+		_dbCommand->FetchByte(6, pData->bDuration);
+		_dbCommand->FetchByte(7, pData->bAttribute);
+
+
+		if (!m_pMap->PutData(pData->iNum, pData))
+			delete pData;
+
+		return true;
+	}
+
+	Magictype3Array *m_pMap;
+};

server/shared/database/MagicType4Set.h

@@ -0,0 +1,56 @@
+#pragma once
+
+class CMagicType4Set : public OdbcRecordset
+{
+public:
+	CMagicType4Set(OdbcConnection * dbConnection, Magictype4Array * pMap) 
+		: OdbcRecordset(dbConnection), m_pMap(pMap) {}
+
+	virtual tstring GetTableName() { return _T("MAGIC_TYPE4"); }
+	virtual tstring GetColumns() { return _T("iNum, BuffType, Radius, Duration, AttackSpeed, Speed, AC, ACPct, Attack, MagicAttack, MaxHP, MaxHPPct, MaxMP, MaxMPPct, HitRate, AvoidRate, Str, Sta, Dex, Intel, Cha, FireR, ColdR, LightningR, MagicR, DiseaseR, PoisonR, ExpPct, SpecialAmount"); }
+
+	virtual bool Fetch()
+	{
+		_MAGIC_TYPE4 *pData = new _MAGIC_TYPE4;
+
+		_dbCommand->FetchUInt32(1, pData->iNum);
+		_dbCommand->FetchByte(2, pData->bBuffType);
+		_dbCommand->FetchByte(3, pData->bRadius);
+		_dbCommand->FetchUInt16(4, pData->sDuration);
+		_dbCommand->FetchByte(5, pData->bAttackSpeed);
+		_dbCommand->FetchByte(6, pData->bSpeed);
+		_dbCommand->FetchInt16(7, pData->sAC);
+		_dbCommand->FetchUInt16(8, pData->sACPct);
+		_dbCommand->FetchByte(9, pData->bAttack);
+		_dbCommand->FetchByte(10, pData->bMagicAttack);
+		_dbCommand->FetchUInt16(11, pData->sMaxHP);
+		_dbCommand->FetchUInt16(12, pData->sMaxHPPct);
+		_dbCommand->FetchUInt16(13, pData->sMaxMP);
+		_dbCommand->FetchUInt16(14, pData->sMaxMPPct);
+		_dbCommand->FetchByte(15, pData->bHitRate);
+		_dbCommand->FetchUInt16(16, pData->sAvoidRate);
+		_dbCommand->FetchSByte(17, pData->bStr);
+		_dbCommand->FetchSByte(18, pData->bSta);
+		_dbCommand->FetchSByte(19, pData->bDex);
+		_dbCommand->FetchSByte(20, pData->bIntel);
+		_dbCommand->FetchSByte(21, pData->bCha);
+		_dbCommand->FetchByte(22, pData->bFireR);
+		_dbCommand->FetchByte(23, pData->bColdR);
+		_dbCommand->FetchByte(24, pData->bLightningR);
+		_dbCommand->FetchByte(25, pData->bMagicR);
+		_dbCommand->FetchByte(26, pData->bDiseaseR);
+		_dbCommand->FetchByte(27, pData->bPoisonR);
+		_dbCommand->FetchUInt16(28, pData->sExpPct);
+		_dbCommand->FetchUInt16(29, pData->sSpecialAmount);
+
+		// Determine if the skill is a buff or a debuff.
+		pData->bIsBuff = CMagicProcess::IsBuff(pData);
+
+		if (!m_pMap->PutData(pData->iNum, pData))
+			delete pData;
+
+		return true;
+	}
+
+	Magictype4Array *m_pMap;
+};

server/shared/database/MagicType5Set.h

@@ -0,0 +1,28 @@
+#pragma once
+
+class CMagicType5Set : public OdbcRecordset
+{
+public:
+	CMagicType5Set(OdbcConnection * dbConnection, Magictype5Array * pMap) 
+		: OdbcRecordset(dbConnection), m_pMap(pMap) {}
+
+	virtual tstring GetTableName() { return _T("MAGIC_TYPE5"); }
+	virtual tstring GetColumns() { return _T("iNum, Type, ExpRecover, NeedStone"); }
+
+	virtual bool Fetch()
+	{
+		_MAGIC_TYPE5 *pData = new _MAGIC_TYPE5;
+
+		_dbCommand->FetchUInt32(1, pData->iNum);
+		_dbCommand->FetchByte(2, pData->bType);
+		_dbCommand->FetchByte(3, pData->bExpRecover);
+		_dbCommand->FetchUInt16(4, pData->sNeedStone);
+
+		if (!m_pMap->PutData(pData->iNum, pData))
+			delete pData;
+
+		return true;
+	}
+
+	Magictype5Array *m_pMap;
+};

server/shared/database/MagicType6Set.h

@@ -0,0 +1,48 @@
+#pragma once
+	
+class CMagicType6Set : public OdbcRecordset
+{
+public:
+	CMagicType6Set(OdbcConnection * dbConnection, Magictype6Array * pMap) 
+		: OdbcRecordset(dbConnection), m_pMap(pMap) {}
+
+	virtual tstring GetTableName() { return _T("MAGIC_TYPE6"); }
+	virtual tstring GetColumns() { return _T("iNum, Size, TransformID, Duration, MaxHp, MaxMp, Speed, AttackSpeed, TotalHit, TotalAc, TotalHitRate, TotalEvasionRate, TotalFireR, TotalColdR, TotalLightningR, TotalMagicR, TotalDiseaseR, TotalPoisonR, Class, UserSkillUse, NeedItem, SkillSuccessRate, MonsterFriendly, Nation"); }
+
+	virtual bool Fetch()
+	{
+		_MAGIC_TYPE6 *pData = new _MAGIC_TYPE6;
+
+		_dbCommand->FetchUInt32(1, pData->iNum);
+		_dbCommand->FetchUInt16(2, pData->sSize);
+		_dbCommand->FetchUInt16(3, pData->sTransformID);
+		_dbCommand->FetchUInt16(4, pData->sDuration);
+		_dbCommand->FetchUInt16(5, pData->sMaxHp);
+		_dbCommand->FetchUInt16(6, pData->sMaxMp);
+		_dbCommand->FetchByte(7, pData->bSpeed);
+		_dbCommand->FetchUInt16(8, pData->sAttackSpeed);
+		_dbCommand->FetchUInt16(9, pData->sTotalHit);
+		_dbCommand->FetchUInt16(10, pData->sTotalAc);
+		_dbCommand->FetchUInt16(11, pData->sTotalHitRate);
+		_dbCommand->FetchUInt16(12, pData->sTotalEvasionRate);
+		_dbCommand->FetchUInt16(13, pData->sTotalFireR);
+		_dbCommand->FetchUInt16(14, pData->sTotalColdR);
+		_dbCommand->FetchUInt16(15, pData->sTotalLightningR);
+		_dbCommand->FetchUInt16(16, pData->sTotalMagicR);
+		_dbCommand->FetchUInt16(17, pData->sTotalDiseaseR);
+		_dbCommand->FetchUInt16(18, pData->sTotalPoisonR);
+		_dbCommand->FetchUInt16(19, pData->sClass);
+		_dbCommand->FetchByte(20, pData->bUserSkillUse);
+		_dbCommand->FetchByte(21, pData->bNeedItem);
+		_dbCommand->FetchByte(22, pData->bSkillSuccessRate);
+		_dbCommand->FetchByte(23, pData->bMonsterFriendly);
+		_dbCommand->FetchByte(24, pData->bNation);
+
+		if (!m_pMap->PutData(pData->iNum, pData))
+			delete pData;
+
+		return true;
+	}
+
+	Magictype6Array *m_pMap;
+};

server/shared/database/MagicType7Set.h

@@ -0,0 +1,36 @@
+#pragma once
+
+class CMagicType7Set : public OdbcRecordset
+{
+public:
+	CMagicType7Set(OdbcConnection * dbConnection, Magictype7Array * pMap) 
+		: OdbcRecordset(dbConnection), m_pMap(pMap) {}
+
+	virtual tstring GetTableName() { return _T("MAGIC_TYPE7"); }
+	virtual tstring GetColumns() { return _T("nIndex, byValidGroup, byNatoinChange, shMonsterNum, byTargetChange, byStateChange, byRadius, shHitrate, shDuration, shDamage, nNeedItem"); }
+
+	virtual bool Fetch()
+	{
+		_MAGIC_TYPE7 *pData = new _MAGIC_TYPE7;
+
+		int index = 1;
+		_dbCommand->FetchUInt32(index++, pData->iNum);
+		_dbCommand->FetchByte(index++, pData->bValidGroup);
+		_dbCommand->FetchByte(index++, pData->bNationChange);
+		_dbCommand->FetchUInt16(index++, pData->sMonsterNum);
+		_dbCommand->FetchByte(index++, pData->bTargetChange);
+		_dbCommand->FetchByte(index++, pData->bStateChange);
+		_dbCommand->FetchByte(index++, pData->bRadius);
+		_dbCommand->FetchUInt16(index++, pData->sHitRate);
+		_dbCommand->FetchUInt16(index++, pData->sDuration);
+		_dbCommand->FetchUInt16(index++, pData->sDamage);
+		_dbCommand->FetchUInt32(index++, pData->nNeedItem);
+
+		if (!m_pMap->PutData(pData->iNum, pData))
+			delete pData;
+
+		return true;
+	}
+
+	Magictype7Array *m_pMap;
+};

server/shared/database/MagicType8Set.h

@@ -0,0 +1,30 @@
+#pragma once
+
+class CMagicType8Set : public OdbcRecordset
+{
+public:
+	CMagicType8Set(OdbcConnection * dbConnection, Magictype8Array * pMap) 
+		: OdbcRecordset(dbConnection), m_pMap(pMap) {}
+
+	virtual tstring GetTableName() { return _T("MAGIC_TYPE8"); }
+	virtual tstring GetColumns() { return _T("iNum, Target, Radius, WarpType, ExpRecover, KickDistance"); }
+
+	virtual bool Fetch()
+	{
+		_MAGIC_TYPE8 *pData = new _MAGIC_TYPE8;
+
+		_dbCommand->FetchUInt32(1, pData->iNum);
+		_dbCommand->FetchByte(2, pData->bTarget);
+		_dbCommand->FetchUInt16(3, pData->sRadius);
+		_dbCommand->FetchByte(4, pData->bWarpType);
+		_dbCommand->FetchUInt16(5, pData->sExpRecover);
+		_dbCommand->FetchUInt16(6, pData->sKickDistance);
+
+		if (!m_pMap->PutData(pData->iNum, pData))
+			delete pData;
+
+		return true;
+	}
+
+	Magictype8Array *m_pMap;
+};

server/shared/database/MagicType9Set.h

@@ -0,0 +1,36 @@
+#pragma once
+
+class CMagicType9Set : public OdbcRecordset
+{
+public:
+	CMagicType9Set(OdbcConnection * dbConnection, Magictype9Array * pMap) 
+		: OdbcRecordset(dbConnection), m_pMap(pMap) {}
+
+	virtual tstring GetTableName() { return _T("MAGIC_TYPE9"); }
+	virtual tstring GetColumns() { return _T("iNum, ValidGroup, NationChange, MonsterNum, TargetChange, StateChange, Radius, Hitrate, Duration, AddDamage, Vision, NeedItem"); }
+
+	virtual bool Fetch()
+	{
+		_MAGIC_TYPE9 *pData = new _MAGIC_TYPE9;
+
+		_dbCommand->FetchUInt32(1, pData->iNum);
+		_dbCommand->FetchByte(2, pData->bValidGroup);
+		_dbCommand->FetchByte(3, pData->bNationChange);
+		_dbCommand->FetchUInt16(4, pData->sMonsterNum);
+		_dbCommand->FetchByte(5, pData->bTargetChange);
+		_dbCommand->FetchByte(6, pData->bStateChange);
+		_dbCommand->FetchUInt16(7, pData->sRadius);
+		_dbCommand->FetchUInt16(8, pData->sHitRate);
+		_dbCommand->FetchUInt16(9, pData->sDuration);
+		_dbCommand->FetchUInt16(10, pData->sDamage);
+		_dbCommand->FetchUInt16(11, pData->sVision);
+		_dbCommand->FetchUInt32(12, pData->nNeedItem);
+
+		if (!m_pMap->PutData(pData->iNum, pData))
+			delete pData;
+
+		return true;
+	}
+
+	Magictype9Array *m_pMap;
+};

server/shared/database/MakeDefensiveTableSet.h

@@ -0,0 +1,28 @@
+#pragma once
+
+class CMakeDefensiveTableSet : public OdbcRecordset
+{
+public:
+	CMakeDefensiveTableSet(OdbcConnection * dbConnection, MakeWeaponItemTableArray * pMap) 
+		: OdbcRecordset(dbConnection), m_pMap(pMap) {}
+
+	virtual tstring GetTableName() { return _T("MAKE_DEFENSIVE"); }
+	virtual tstring GetColumns() { return _T("byLevel, sClass_1, sClass_2, sClass_3, sClass_4, sClass_5, sClass_6, sClass_7"); }
+
+	virtual bool Fetch()
+	{
+		_MAKE_WEAPON *pData = new _MAKE_WEAPON;
+
+		_dbCommand->FetchByte(1, pData->byIndex);
+
+		for (int i = 1; i <= 7; i++)
+			_dbCommand->FetchUInt16(i+1, pData->sClass[i-1]);
+
+		if (!m_pMap->PutData(pData->byIndex, pData))
+			delete pData;
+
+		return true;
+	}
+
+	MakeWeaponItemTableArray *m_pMap;
+};

server/shared/database/MakeGradeItemTableSet.h

@@ -0,0 +1,28 @@
+#pragma once
+
+class CMakeGradeItemTableSet : public OdbcRecordset
+{
+public:
+	CMakeGradeItemTableSet(OdbcConnection * dbConnection, MakeGradeItemTableArray * pMap) 
+		: OdbcRecordset(dbConnection), m_pMap(pMap) {}
+
+	virtual tstring GetTableName() { return _T("MAKE_ITEM_GRADECODE"); }
+	virtual tstring GetColumns() { return _T("byItemIndex, byGrade_1, byGrade_2, byGrade_3, byGrade_4, byGrade_5, byGrade_6, byGrade_7, byGrade_8, byGrade_9"); }
+
+	virtual bool Fetch()
+	{
+		_MAKE_ITEM_GRADE_CODE *pData = new _MAKE_ITEM_GRADE_CODE;
+
+		_dbCommand->FetchByte(1, pData->byItemIndex);
+
+		for (int i = 1; i <= 9; i++)
+			_dbCommand->FetchUInt16(i+1, pData->sGrade[i-1]);
+
+		if (!m_pMap->PutData(pData->byItemIndex, pData))
+			delete pData;
+
+		return true;
+	}
+
+	MakeGradeItemTableArray *m_pMap;
+};

server/shared/database/MakeItemGroupSet.h

@@ -0,0 +1,33 @@
+#pragma once
+
+class CMakeItemGroupSet : public OdbcRecordset
+{
+public:
+	CMakeItemGroupSet(OdbcConnection * dbConnection, MakeItemGroupArray * pMap) 
+		: OdbcRecordset(dbConnection), m_pMap(pMap) {}
+
+	virtual tstring GetTableName() { return _T("MAKE_ITEM_GROUP"); }
+	virtual tstring GetColumns() { return _T("iItemGroupNum, iItem_1, iItem_2, iItem_3, iItem_4, iItem_5, iItem_6, iItem_7, iItem_8, iItem_9, iItem_10, iItem_11, iItem_12, iItem_13, iItem_14, iItem_15, iItem_16, iItem_17, iItem_18, iItem_19, iItem_20, iItem_21, iItem_22, iItem_23, iItem_24, iItem_25, iItem_26, iItem_27, iItem_28, iItem_29, iItem_30"); }
+
+	virtual bool Fetch()
+	{
+		_MAKE_ITEM_GROUP *pData = new _MAKE_ITEM_GROUP;
+
+		_dbCommand->FetchUInt32(1, pData->iItemGroupNum);
+		for (int i = 1; i <= 30; i++)
+		{
+			uint32 iItem;
+			_dbCommand->FetchUInt32(i + 1, iItem);
+
+			// Insert regardless of whether it's set or not. This is official behaviour.
+			pData->iItems.push_back(iItem);
+		}
+
+		if (!m_pMap->PutData(pData->iItemGroupNum, pData))
+			delete pData;
+
+		return true;
+	}
+
+	MakeItemGroupArray *m_pMap;
+};

server/shared/database/MakeLareItemTableSet.h

@@ -0,0 +1,28 @@
+#pragma once
+
+class CMakeLareItemTableSet : public OdbcRecordset
+{
+public:
+	CMakeLareItemTableSet(OdbcConnection * dbConnection, MakeLareItemTableArray * pMap) 
+		: OdbcRecordset(dbConnection), m_pMap(pMap) {}
+
+	virtual tstring GetTableName() { return _T("MAKE_ITEM_LARECODE"); }
+	virtual tstring GetColumns() { return _T("byLevelGrade, sLareItem, sMagicItem, sGereralItem"); }
+
+	virtual bool Fetch()
+	{
+		_MAKE_ITEM_LARE_CODE *pData = new _MAKE_ITEM_LARE_CODE;
+
+		_dbCommand->FetchByte(1, pData->byItemLevel);
+		_dbCommand->FetchUInt16(2, pData->sLareItem);
+		_dbCommand->FetchUInt16(3, pData->sMagicItem);
+		_dbCommand->FetchUInt16(4, pData->sGeneralItem);
+
+		if (!m_pMap->PutData(pData->byItemLevel, pData))
+			delete pData;
+
+		return true;
+	}
+
+	MakeLareItemTableArray *m_pMap;
+};

server/shared/database/MakeWeaponTableSet.h

@@ -0,0 +1,28 @@
+#pragma once
+
+class CMakeWeaponTableSet : public OdbcRecordset
+{
+public:
+	CMakeWeaponTableSet(OdbcConnection * dbConnection, MakeWeaponItemTableArray * pMap) 
+		: OdbcRecordset(dbConnection), m_pMap(pMap) {}
+
+	virtual tstring GetTableName() { return _T("MAKE_WEAPON"); }
+	virtual tstring GetColumns() { return _T("byLevel, sClass_1, sClass_2, sClass_3, sClass_4, sClass_5, sClass_6, sClass_7, sClass_8, sClass_9, sClass_10, sClass_11, sClass_12"); }
+
+	virtual bool Fetch()
+	{
+		_MAKE_WEAPON *pData = new _MAKE_WEAPON;
+
+		_dbCommand->FetchByte(1, pData->byIndex);
+
+		for (int i = 1; i <= 12; i++)
+			_dbCommand->FetchUInt16(i+1, pData->sClass[i-1]);
+
+		if (!m_pMap->PutData(pData->byIndex, pData))
+			delete pData;
+
+		return true;
+	}
+
+	MakeWeaponItemTableArray *m_pMap;
+};

server/shared/database/MineListSet.h

@@ -0,0 +1,32 @@
+#pragma once
+
+class CMineListSet : public OdbcRecordset
+{
+public:
+	CMineListSet(OdbcConnection * dbConnection, MineListArray * pMap) 
+		: OdbcRecordset(dbConnection), m_pMap(pMap) {}
+
+	virtual tstring GetTableName() { return _T("MINE_LIST"); }
+	virtual tstring GetColumns() { return _T("nIndex, Item, Count"); }
+
+	virtual bool Fetch()
+	{
+		_MINE_LIST pData;
+
+		_dbCommand->FetchUInt32(1, pData.nIndex);
+		_dbCommand->FetchUInt32(2, pData.Item);
+		_dbCommand->FetchUInt16(3, pData.Count);
+
+		auto itr = m_pMap->GetData(pData.Count);
+		if (itr == nullptr)
+		{
+			itr = new MineList();
+			m_pMap->PutData(pData.Count, itr);
+		}
+
+		itr->push_back(pData);
+		return true;
+	}
+
+	MineListArray *m_pMap;
+};

server/shared/database/MonsterChallenge.h

@@ -0,0 +1,30 @@
+#pragma once
+ 
+class CMonsterChallenge : public OdbcRecordset
+{
+public:
+	CMonsterChallenge(OdbcConnection * dbConnection, MonsterChallengeArray * pMap) 
+    : OdbcRecordset(dbConnection), m_pMap(pMap) {}
+	
+	virtual tstring GetTableName() { return _T("MONSTER_CHALLENGE"); }
+	virtual tstring GetColumns() { return _T("sIndex, bStartTime1, bStartTime2, bStartTime3, bLevelMin, bLevelMax"); }
+ 
+	virtual bool Fetch()
+	{
+		_MONSTER_CHALLENGE * pData = new _MONSTER_CHALLENGE;
+		
+		_dbCommand->FetchUInt16(1, pData->sIndex);
+		_dbCommand->FetchByte(2, pData->bStartTime1);
+		_dbCommand->FetchByte(3, pData->bStartTime2);
+		_dbCommand->FetchByte(4, pData->bStartTime3);
+		_dbCommand->FetchByte(5, pData->bLevelMin);
+		_dbCommand->FetchByte(6, pData->bLevelMax);
+ 
+     if (!m_pMap->PutData(pData->sIndex, pData))
+       delete pData;
+ 
+     return true;
+   }
+ 
+   MonsterChallengeArray *m_pMap;
+ };

server/shared/database/MonsterChallengeSummonList.h

@@ -0,0 +1,35 @@
+#pragma once
+ 
+class CMonsterChallengeSummonList : public OdbcRecordset
+{
+public:
+	CMonsterChallengeSummonList(OdbcConnection * dbConnection, MonsterChallengeSummonListArray * pMap) 
+    : OdbcRecordset(dbConnection), m_pMap(pMap) {}
+	
+	virtual tstring GetTableName() { return _T("MONSTER_CHALLENGE_SUMMON_LIST"); }
+	virtual tstring GetColumns() { return _T("sIndex, bLevel, bStage, bStageLevel, sTime, sSid, sCount, sPosX, sPosZ, bRange"); }
+ 
+	virtual bool Fetch()
+	{
+		_MONSTER_CHALLENGE_SUMMON_LIST * pData = new _MONSTER_CHALLENGE_SUMMON_LIST;
+		
+		int i = 1;
+		_dbCommand->FetchUInt16(i++, pData->sIndex);
+		_dbCommand->FetchByte(i++, pData->bLevel);
+		_dbCommand->FetchByte(i++, pData->bStage);
+		_dbCommand->FetchByte(i++, pData->bStageLevel);
+		_dbCommand->FetchUInt16(i++, pData->sTime);
+		_dbCommand->FetchUInt16(i++, pData->sSid);
+		_dbCommand->FetchUInt16(i++, pData->sCount);
+		_dbCommand->FetchUInt16(i++, pData->sPosX);
+		_dbCommand->FetchUInt16(i++, pData->sPosZ);
+		_dbCommand->FetchByte(i++, pData->bRange);
+ 
+     if (!m_pMap->PutData(pData->sIndex, pData))
+       delete pData;
+ 
+     return true;
+   }
+ 
+   MonsterChallengeSummonListArray *m_pMap;
+ };

server/shared/database/MonsterRespawnListInformationSet.h

@@ -0,0 +1,33 @@
+#pragma once
+
+class CMonsterRespawnListInformationSet : public OdbcRecordset
+{
+public:
+	CMonsterRespawnListInformationSet(OdbcConnection * dbConnection, MonsterRespawnListInformationArray * pMap) 
+		: OdbcRecordset(dbConnection), m_pMap(pMap) {}
+
+	virtual tstring GetTableName() { return _T("MONSTER_RESPAWN_LIST_INFORMATION"); }
+	virtual tstring GetColumns() { return _T("sIndex, sSid, ZoneID, X, Y, Z, sCount, bRadius"); }
+
+	virtual bool Fetch()
+	{
+		_MONSTER_RESPAWN_LIST_INFORMATION * pData = new _MONSTER_RESPAWN_LIST_INFORMATION;
+
+		int i = 1;
+		_dbCommand->FetchUInt16(i++, pData->sIndex);
+		_dbCommand->FetchUInt16(i++, pData->sSid);
+		_dbCommand->FetchByte(i++, pData->ZoneID);
+		_dbCommand->FetchUInt16(i++, pData->X);
+		_dbCommand->FetchUInt16(i++, pData->Y);
+		_dbCommand->FetchUInt16(i++, pData->Z);
+		_dbCommand->FetchUInt16(i++, pData->sCount);
+		_dbCommand->FetchByte(i++, pData->bRadius);
+
+		if (!m_pMap->PutData(pData->sIndex, pData))
+			delete pData;
+
+		return true;
+	}
+
+	MonsterRespawnListInformationArray *m_pMap;
+};

server/shared/database/MonsterRespawnListRandomSet.h

@@ -0,0 +1,32 @@
+#pragma once
+
+class CMonsterRespawnListRandomSet : public OdbcRecordset
+{
+public:
+	CMonsterRespawnListRandomSet(OdbcConnection * dbConnection, MonsterRespawnListRandomArray * pMap) 
+		: OdbcRecordset(dbConnection), m_pMap(pMap) {}
+
+	virtual tstring GetTableName() { return _T("MONSTER_RESPAWN_LIST_RANDOM"); }
+	virtual tstring GetColumns() { return _T("sIndex, sSid, strName, sPid, ZoneID, isBoss, Family"); }
+
+	virtual bool Fetch()
+	{
+		_MONSTER_RESPAWN_LIST_RANDOM * pData = new _MONSTER_RESPAWN_LIST_RANDOM;
+
+		int i = 1;
+		_dbCommand->FetchUInt16(i++, pData->sIndex);
+		_dbCommand->FetchUInt16(i++, pData->sSid);
+		_dbCommand->FetchString(i++, pData->strName);
+		_dbCommand->FetchUInt16(i++, pData->sPid);
+		_dbCommand->FetchByte(i++, pData->ZoneID);
+		_dbCommand->FetchByte(i++, pData->isBoss);
+		_dbCommand->FetchByte(i++, pData->Family);
+		
+		if (!m_pMap->PutData(pData->sIndex, pData))
+			delete pData;
+
+		return true;
+	}
+
+	MonsterRespawnListRandomArray *m_pMap;
+};

server/shared/database/MonsterRespawnListSet.h

@@ -0,0 +1,27 @@
+ #pragma once
+
+class CMonsterRespawnListSet : public OdbcRecordset
+{
+public:
+	CMonsterRespawnListSet(OdbcConnection * dbConnection, MonsterRespawnListArray * pMap) 
+		: OdbcRecordset(dbConnection), m_pMap(pMap) {}
+
+	virtual tstring GetTableName() { return _T("MONSTER_RESPAWN_LIST"); }
+	virtual tstring GetColumns() { return _T("sIndex, sSid, sCount"); }
+
+	virtual bool Fetch()
+	{
+		_MONSTER_RESPAWN_LIST * pData = new _MONSTER_RESPAWN_LIST;
+
+		_dbCommand->FetchUInt16(1, pData->sIndex);
+		_dbCommand->FetchUInt16(2, pData->sSid);
+		_dbCommand->FetchUInt16(3, pData->sCount);
+
+		if (!m_pMap->PutData(pData->sIndex, pData))
+			delete pData;
+
+		return true;
+	}
+
+	MonsterRespawnListArray *m_pMap;
+};

server/shared/database/MonsterSummonListSet.h

@@ -0,0 +1,33 @@
+#pragma once
+
+class CMonsterSummonListSet : public OdbcRecordset
+{
+public:
+	CMonsterSummonListSet(OdbcConnection * dbConnection, MonsterSummonListArray * pMap) 
+		: OdbcRecordset(dbConnection), m_pMap(pMap) {}
+
+	virtual tstring GetTableName() { return _T("MONSTER_SUMMON_LIST"); }
+	virtual tstring GetColumns() { return _T("sSid, sLevel, sProbability, bType"); }
+
+	virtual bool Fetch()
+	{
+		_MONSTER_SUMMON_LIST pData;
+
+		_dbCommand->FetchUInt16(1, pData.sSid);
+		_dbCommand->FetchUInt16(2, pData.sLevel);
+		_dbCommand->FetchUInt16(3, pData.sProbability);
+		_dbCommand->FetchByte(4, pData.bType);
+
+		auto itr = m_pMap->GetData(pData.bType);
+		if (itr == nullptr)
+		{
+			itr = new MonsterSummonList();
+			m_pMap->PutData(pData.bType, itr);
+		}
+		// pType, MonsterSummonList vector
+		itr->push_back(pData);
+		return true;
+	}
+
+	MonsterSummonListArray *m_pMap;
+};

server/shared/database/MonsterSummonListZoneSet.h

@@ -0,0 +1,30 @@
+ #pragma once
+
+class CMonsterSummonListZoneSet : public OdbcRecordset
+{
+public:
+	CMonsterSummonListZoneSet(OdbcConnection * dbConnection, MonsterSummonListZoneArray * pMap) 
+		: OdbcRecordset(dbConnection), m_pMap(pMap) {}
+
+	virtual tstring GetTableName() { return _T("MONSTER_SUMMON_LIST_ZONE"); }
+	virtual tstring GetColumns() { return _T("nIndex, ZoneID, sSid, byFamily"); }
+
+	virtual bool Fetch()
+	{
+		_MONSTER_SUMMON_LIST_ZONE * pData = new _MONSTER_SUMMON_LIST_ZONE;
+
+		_dbCommand->FetchUInt32(1, pData->nIndex);
+		_dbCommand->FetchUInt16(2, pData->ZoneID);
+		_dbCommand->FetchUInt16(3, pData->sSid);
+		_dbCommand->FetchByte(4, pData->byFamily);
+
+		pData->nIndex = m_pMap->GetSize();
+
+		if (!m_pMap->PutData(pData->nIndex, pData))
+			delete pData;
+
+		return true;
+	}
+
+	MonsterSummonListZoneArray *m_pMap;
+};

server/shared/database/NpcItemSet.h

@@ -0,0 +1,30 @@
+#pragma once
+
+class CNpcItemSet : public OdbcRecordset
+{
+public:
+	CNpcItemSet(OdbcConnection * dbConnection, NpcItemArray * pMap) 
+		: OdbcRecordset(dbConnection), m_pMap(pMap) {}
+
+	virtual tstring GetTableName() { return _T("K_MONSTER_ITEM"); }
+	virtual tstring GetColumns() { return _T("sIndex, iItem01, sPersent01, iItem02, sPersent02, iItem03, sPersent03, iItem04, sPersent04, iItem05, sPersent05"); }
+
+	virtual bool Fetch()
+	{
+		_K_MONSTER_ITEM *pData = new _K_MONSTER_ITEM;
+
+		_dbCommand->FetchUInt16(1, pData->sIndex);
+		for (int i = 0, j = 2; i < 5; i++)
+		{
+			_dbCommand->FetchUInt32(j++, pData->iItem[i]);
+			_dbCommand->FetchUInt16(j++, pData->sPercent[i]);
+		}
+
+		if (!m_pMap->PutData(pData->sIndex, pData))
+			delete pData;
+
+		return true;
+	}
+
+	NpcItemArray *m_pMap;
+};

server/shared/database/NpcPosSet.h

@@ -0,0 +1,13 @@
+#pragma once
+
+class CNpcPosSet : public OdbcRecordset
+{
+public:
+	CNpcPosSet(OdbcConnection * dbConnection, void * dummy) 
+		: OdbcRecordset(dbConnection) {}
+
+	virtual tstring GetTableName() { return _T("K_NPCPOS"); }
+	virtual tstring GetColumns() { return _T("ZoneID, NpcID, strName, isNPC, ActType, DungeonFamily, SpecialType, TrapNumber, LeftX, TopZ, NumNPC, iRange, XiDontKnow, RegTime, byDirection, path, EventRoom"); }
+
+	virtual bool Fetch() { return g_pMain->LoadSpawnCallback(_dbCommand); }
+};

server/shared/database/NpcTableSet.h

@@ -0,0 +1,92 @@
+#pragma once
+
+class CNpcTableSet : public OdbcRecordset
+{
+public:
+	CNpcTableSet(OdbcConnection * dbConnection, NpcTableArray * pMap) 
+		: OdbcRecordset(dbConnection), m_pMap(pMap), m_bMonster(false)
+	{
+	}
+
+	virtual tstring GetTableName() { return _T("K_NPC"); }
+	virtual tstring GetColumns() { return _T("sSid, strName, sPid, sSize, isBoss, iWeapon1, iWeapon2, byGroup, byActType, byType, byFamily, iSellingGroup, sLevel, iExp, iLoyalty, iHpPoint, sAtk, sAc, sHitRate, sEvadeRate, sDamage, sAttackDelay, bySpeed1, bySpeed2, sStandtime, iMagic1, iMagic2, iMagic3, sFireR, sColdR, sLightningR, sMagicR, sDiseaseR, sPoisonR, sBulk, byAttackRange, bySearchRange, byTracingRange, iMoney, byDirectAttack, byMagicAttack, sItem, byMoneyType, xType, yType, zType, tType"); }
+
+	virtual bool Fetch()
+	{
+		CNpcTable *pData = new CNpcTable();
+		uint16 sBulk, isBoss;
+
+		int i = 1;
+		_dbCommand->FetchUInt16(i++, pData->m_sSid);
+		_dbCommand->FetchString(i++, pData->m_strName);
+		_dbCommand->FetchUInt16(i++, pData->m_sPid);
+		_dbCommand->FetchUInt16(i++, pData->m_sSize);
+		_dbCommand->FetchUInt16(i++, isBoss);
+		_dbCommand->FetchUInt32(i++, pData->m_iWeapon_1);
+		_dbCommand->FetchUInt32(i++, pData->m_iWeapon_2);
+		_dbCommand->FetchByte(i++, pData->m_byGroup);
+		_dbCommand->FetchByte(i++, pData->m_byActType);
+		_dbCommand->FetchByte(i++, pData->m_tNpcType);
+		_dbCommand->FetchByte(i++, pData->m_byFamilyType);
+		_dbCommand->FetchUInt32(i++, pData->m_iSellingGroup);
+		_dbCommand->FetchUInt16(i++, pData->m_sLevel);
+		_dbCommand->FetchUInt32(i++, pData->m_iExp);
+		_dbCommand->FetchUInt32(i++, pData->m_iLoyalty);
+		_dbCommand->FetchUInt32(i++, pData->m_iMaxHP);
+		_dbCommand->FetchUInt16(i++, pData->m_sAttack);
+		_dbCommand->FetchUInt16(i++, pData->m_sDefense);
+		_dbCommand->FetchUInt16(i++, pData->m_sHitRate);
+		_dbCommand->FetchUInt16(i++, pData->m_sEvadeRate);
+		_dbCommand->FetchUInt16(i++, pData->m_sDamage);
+		_dbCommand->FetchUInt16(i++, pData->m_sAttackDelay);
+		_dbCommand->FetchByte(i++, pData->m_bySpeed_1);
+		_dbCommand->FetchByte(i++, pData->m_bySpeed_2);
+		_dbCommand->FetchUInt16(i++, pData->m_sStandTime);
+		_dbCommand->FetchUInt32(i++, pData->m_iMagic1);
+		_dbCommand->FetchUInt32(i++, pData->m_iMagic2);
+		_dbCommand->FetchUInt32(i++, pData->m_iMagic3);
+		_dbCommand->FetchUInt16(i++, pData->m_byFireR);
+		_dbCommand->FetchUInt16(i++, pData->m_byColdR);
+		_dbCommand->FetchUInt16(i++, pData->m_byLightningR);
+		_dbCommand->FetchUInt16(i++, pData->m_byMagicR);
+		_dbCommand->FetchUInt16(i++, pData->m_byDiseaseR);
+		_dbCommand->FetchUInt16(i++, pData->m_byPoisonR);
+		_dbCommand->FetchUInt16(i++, sBulk);
+		_dbCommand->FetchByte(i++, pData->m_byAttackRange);
+		_dbCommand->FetchByte(i++, pData->m_bySearchRange);
+		_dbCommand->FetchByte(i++, pData->m_byTracingRange);
+		_dbCommand->FetchUInt32(i++, pData->m_iMoney);
+		_dbCommand->FetchByte(i++, pData->m_byDirectAttack);
+		_dbCommand->FetchByte(i++, pData->m_byMagicAttack);
+		_dbCommand->FetchUInt16(i++, pData->m_iItem);
+		
+		pData->m_byGroupSpecial = 0; // Default value
+		pData->m_sSpeed = 1500;
+		// Certain NPCs are defined in the database with a type of 0, which is the monster type.
+		// This can potentially cause problems in the future, so fix it now.
+		if (!m_bMonster && pData->m_tNpcType == NPC_MONSTER)
+			pData->m_tNpcType = NPC_GENERAL;
+
+		pData->m_fBulk =  (float)(((double)sBulk / 100) * ((double)pData->m_sSize / 100));
+
+		if (!m_pMap->PutData(pData->m_sSid, pData))
+			delete pData;
+
+		return true;
+	}
+
+	NpcTableArray *m_pMap;
+	bool m_bMonster;
+};
+
+class CMonTableSet : public CNpcTableSet
+{
+public:
+	CMonTableSet(OdbcConnection * dbConnection, NpcTableArray * pMap) 
+		: CNpcTableSet(dbConnection, pMap)
+	{
+		m_bMonster = true;
+	}
+
+	virtual tstring GetTableName() { return _T("K_MONSTER"); }
+};

server/shared/database/ObjectPosSet.h

@@ -0,0 +1,38 @@
+#pragma once
+
+class CObjectPosSet : public OdbcRecordset
+{
+public:
+	CObjectPosSet(OdbcConnection * dbConnection, ObjectEventArray * pMap) 
+		: OdbcRecordset(dbConnection), m_pMap(pMap) {}
+
+	virtual tstring GetTableName() { return _T("K_OBJECTPOS"); }
+	virtual tstring GetColumns() { return _T("ZoneID, Belong, sIndex, Type, ControlNPCID, Status, PosX, PosY, PosZ, byLife"); }
+
+	virtual bool Fetch()
+	{
+		_OBJECT_EVENT *pData = new _OBJECT_EVENT;
+
+		int i = 1;
+		_dbCommand->FetchUInt16(i++, pData->sZoneID);
+		_dbCommand->FetchInt32(i++, pData->sBelong);
+		_dbCommand->FetchInt16(i++, pData->sIndex);
+		_dbCommand->FetchInt16(i++, pData->sType);
+		_dbCommand->FetchInt16(i++, pData->sControlNpcID);
+		_dbCommand->FetchInt16(i++, pData->sStatus);
+		_dbCommand->FetchSingle(i++, pData->fPosX);
+		_dbCommand->FetchSingle(i++, pData->fPosY);
+		_dbCommand->FetchSingle(i++, pData->fPosZ);
+		_dbCommand->FetchByte(i++, pData->byLife);
+
+		pData->RoomEvent = 0;
+		pData->nIndex = m_pMap->GetSize();
+
+		if (!m_pMap->PutData(pData->nIndex, pData))
+			delete pData;
+
+		return true;
+	}
+
+	ObjectEventArray *m_pMap;
+};

server/shared/database/OdbcCommand.cpp

@@ -0,0 +1,252 @@
+#include "stdafx.h"
+#include "OdbcConnection.h"
+
+OdbcCommand::OdbcCommand(HDBC conn) : m_connHandle(conn), m_odbcConnection(nullptr), m_hStmt(nullptr), m_resultCode(-1)
+{
+}
+
+OdbcCommand::OdbcCommand(OdbcConnection * conn) : m_odbcConnection(conn), m_hStmt(nullptr)
+{
+	m_connHandle = conn->GetConnectionHandle();
+	m_odbcConnection->AddCommand(this);
+}
+
+bool OdbcCommand::BindParameters()
+{
+	for (auto itr = m_params.begin(); itr != m_params.end(); itr++)
+	{
+		auto param = itr->second;
+
+		if (!SQL_SUCCEEDED(SQLBindParameter(m_hStmt, itr->first + 1, param->GetParameterType(), 
+			param->GetCDataType(), param->GetDataType(), param->GetDataTypeSize(), 0, 
+			param->GetAddress(), param->GetDataTypeSize(), param->GetCBValue())))
+		{
+			if (m_odbcConnection != nullptr)
+				m_szError = m_odbcConnection->ReportSQLError(SQL_HANDLE_STMT, m_hStmt, _T("SQLBindParameter"), _T("Failed to bind parameter."));
+			else
+				m_szError = OdbcConnection::GetSQLError(SQL_HANDLE_STMT, m_hStmt);
+
+			Close();
+			return false;
+		}
+	}
+	return true;
+}
+
+bool OdbcCommand::Open(bool bRetry /*= false*/)
+{
+	if (isOpen())
+		Close();
+
+	if (!SQL_SUCCEEDED(SQLAllocHandle(SQL_HANDLE_STMT, m_connHandle, &m_hStmt)))
+	{
+		if (m_odbcConnection != nullptr)
+			m_szError = m_odbcConnection->ReportSQLError(SQL_HANDLE_DBC, m_connHandle, _T("SQLAllocHandle"), _T("Failed to allocate statement handle."));
+		else
+			m_szError = OdbcConnection::GetSQLError(SQL_HANDLE_DBC, m_connHandle);
+
+		// Attempt full SQL reconnection once.
+		if (m_odbcConnection == nullptr || bRetry)
+			return false;
+
+		// Perform soft disconnect, preserving existing commands
+		m_odbcConnection->Close();
+
+		// Reconnect
+		m_odbcConnection->Connect();
+
+		// Now try running the statement once more time.
+		return Open(true); 
+	}
+
+	SQLExecDirect(m_hStmt, (SQLTCHAR *)_T("SET NOCOUNT ON"), SQL_NTS);
+	return true;
+}
+
+bool OdbcCommand::Execute(const tstring & szSQL)
+{
+	if (!Open())
+		return false;
+
+#ifdef USE_SQL_TRACE
+	TRACE((szSQL + _T("\n")).c_str());
+#endif
+
+	if (!BindParameters())
+		return false;
+
+	SQLRETURN result = SQLExecDirect(m_hStmt, (SQLTCHAR *)szSQL.c_str(), szSQL.length());
+	if (!(result == SQL_SUCCESS || result == SQL_SUCCESS_WITH_INFO || result == SQL_NO_DATA))
+	{
+		if (m_odbcConnection != nullptr)
+			m_szError = m_odbcConnection->ReportSQLError(SQL_HANDLE_STMT, m_hStmt, (TCHAR *)szSQL.c_str(), _T("Failed to execute statement."));
+		else
+			m_szError = OdbcConnection::GetSQLError(SQL_HANDLE_STMT, m_hStmt);
+
+		Close();
+		return false;
+	}
+
+	if (!MoveNext())
+		MoveNextSet();
+
+	return true;
+}
+
+bool OdbcCommand::Prepare(const tstring & szSQL)
+{
+	if (!Open())
+		return false;
+
+#ifdef USE_SQL_TRACE
+	TRACE((szSQL + _T("\n")).c_str());
+#endif
+
+	if (!SQL_SUCCEEDED(SQLPrepare(m_hStmt, (SQLTCHAR *)szSQL.c_str(), szSQL.length())))
+	{
+		if (m_odbcConnection != nullptr)
+			m_szError = m_odbcConnection->ReportSQLError(SQL_HANDLE_STMT, m_hStmt, _T("SQLPrepare"), _T("Failed to prepare statement."));
+		else
+			m_szError = OdbcConnection::GetSQLError(SQL_HANDLE_STMT, m_hStmt);
+
+		Close();
+		return false;
+	}
+
+	if (!BindParameters())
+		return false;
+
+	SQLRETURN result = SQLExecute(m_hStmt);
+	if (!(result == SQL_SUCCESS || result == SQL_SUCCESS_WITH_INFO || result == SQL_NO_DATA))
+	{
+		if (m_odbcConnection != nullptr)
+			m_szError = m_odbcConnection->ReportSQLError(SQL_HANDLE_STMT, m_hStmt, (TCHAR *)szSQL.c_str(), _T("Failed to execute prepared statement."));
+		else
+			m_szError = OdbcConnection::GetSQLError(SQL_HANDLE_STMT, m_hStmt);
+
+		Close();
+		return false;
+	}
+
+	// If there's no rows to move through, skip to the next result set.
+	if (!MoveNext())
+		MoveNextSet();
+
+	ClearParameters();
+	return true;
+}
+
+bool OdbcCommand::MoveNext()
+{
+	if (!isOpen())
+		return false;
+
+	return SQL_SUCCEEDED(m_resultCode = SQLFetch(m_hStmt));
+}
+
+bool OdbcCommand::MoveNextSet()
+{
+	if (!isOpen())
+		return false;
+
+	return SQL_SUCCEEDED(m_resultCode = SQLMoreResults(m_hStmt));
+}
+
+#define ADD_ODBC_PARAMETER(name, type, sqlType) void OdbcCommand::AddParameter(SQLSMALLINT paramType, type *value, SQLLEN maxLength) { m_params.insert(std::make_pair(m_params.size(), new OdbcParameter(paramType, sqlType, (SQLPOINTER)value, maxLength))); } \
+	type OdbcCommand::Fetch ## name(int pos) { type value; SQLLEN cb = SQL_NTS; SQLGetData(m_hStmt, pos, sqlType, &value, 0, &cb); return value; } \
+	void OdbcCommand::Fetch ## name(int pos, type & value) { SQLLEN cb = SQL_NTS; SQLGetData(m_hStmt, pos, sqlType, &value, 0, &cb); }
+ADD_ODBC_PARAMETER(Byte, uint8, SQL_C_UTINYINT)
+	ADD_ODBC_PARAMETER(SByte, int8, SQL_C_STINYINT)
+	ADD_ODBC_PARAMETER(UInt16, uint16, SQL_C_USHORT)
+	ADD_ODBC_PARAMETER(Int16, int16, SQL_C_SSHORT)
+	ADD_ODBC_PARAMETER(UInt32, uint32, SQL_C_ULONG)
+	ADD_ODBC_PARAMETER(Int32, int32, SQL_C_SLONG)
+	ADD_ODBC_PARAMETER(Single, float, SQL_C_FLOAT)
+	ADD_ODBC_PARAMETER(Double, double, SQL_C_DOUBLE)
+	ADD_ODBC_PARAMETER(UInt64, uint64, SQL_C_UBIGINT)
+	ADD_ODBC_PARAMETER(Int64, int64, SQL_C_SBIGINT)
+#undef ADD_ODBC_PARAMETER
+
+void OdbcCommand::AddParameter(SQLSMALLINT paramType, const char *value, SQLLEN maxLength = 1, SQLSMALLINT sqlDataType /*= SQL_CHAR*/)
+{
+	m_params.insert(std::make_pair(m_params.size(), new OdbcParameter(paramType, sqlDataType, (SQLPOINTER)value, maxLength))); 
+}
+
+bool OdbcCommand::FetchString(int pos, char *charArray, SQLLEN maxLength, SQLLEN *bufferSize)
+{
+	memset(charArray, 0x00, maxLength);
+	return SQL_SUCCEEDED(SQLGetData(m_hStmt, pos, SQL_CHAR, charArray, maxLength, bufferSize));
+}
+
+bool OdbcCommand::FetchBinary(int pos, char *charArray, SQLLEN maxLength, SQLLEN *bufferSize)
+{
+	return SQL_SUCCEEDED(SQLGetData(m_hStmt, pos, SQL_BINARY, charArray, maxLength, bufferSize));
+}
+
+bool OdbcCommand::FetchString(int pos, std::string & value)
+{
+	SQLLEN bufferSize = 0;
+	char buffer[256] = "";
+
+	// Attempt to fetch "small" string of 256 bytes at most (should fit everything we'll need)
+	if (!FetchString(pos, buffer, sizeof(buffer), &bufferSize))
+	{
+		// Error fetching string, nothing we can do.
+		if (bufferSize <= 0)
+			return false;
+
+		// Allocate a buffer large enough for the string's actual length
+		std::unique_ptr<char> varBuffer(new char[bufferSize + 1]);
+
+		// If the string still couldn't be fetched, nothing we can do.
+		if (!FetchString(pos, varBuffer.get(), bufferSize + 1, &bufferSize))
+			return false;
+
+		value = varBuffer.get();
+	}
+	// String could be fetched, copy it over to the output var.
+	else
+	{
+		value = buffer;
+	}
+
+	// This line's necessary for SQL_CHAR type columns to trim the padding.
+	// NOTE: If we need the padding, we should be using the OTHER FetchString() method for it (to fetch it straight into a char array)
+	rtrim(value);
+	return true;
+}
+
+void OdbcCommand::ClearParameters()
+{
+	if (m_params.empty())
+		return;
+
+	for (auto itr = m_params.begin(); itr != m_params.end(); itr++)
+		delete itr->second;
+
+	m_params.clear();
+}
+
+void OdbcCommand::Close()
+{
+	if (m_hStmt != nullptr)
+	{
+		SQLCloseCursor(m_hStmt); // free results, if any
+		SQLFreeHandle(SQL_HANDLE_STMT, m_hStmt);
+		m_hStmt = nullptr;
+	}
+}
+
+void OdbcCommand::Detach()
+{
+	m_odbcConnection = nullptr;
+}
+
+OdbcCommand::~OdbcCommand()
+{
+	Close();
+	ClearParameters();
+
+	if (m_odbcConnection != nullptr)
+		m_odbcConnection->RemoveCommand(this);
+}

server/shared/database/OdbcCommand.h

@@ -0,0 +1,84 @@
+#pragma once
+
+#include "OdbcParameter.h"
+#include <map>
+
+class OdbcConnection;
+class OdbcCommand
+{
+public:
+	typedef std::map<size_t, OdbcParameter *> OdbcParameterCollection;
+
+	OdbcCommand(HDBC conn);
+	OdbcCommand(OdbcConnection * conn);
+
+	INLINE bool isOpen() { return m_hStmt != nullptr; };
+	INLINE TCHAR * GetError() { return (TCHAR *)m_szError.c_str();  };
+	INLINE bool hasData() { return m_resultCode != SQL_NO_DATA && SQL_SUCCEEDED(m_resultCode); };
+	INLINE void SetConnectionHandle(HDBC handle) { m_connHandle = handle; };
+
+private:
+	bool BindParameters();
+
+public:
+	bool Execute(const tstring & szSQL);
+	bool Prepare(const tstring & szSQL);
+
+	bool MoveNext();
+	bool MoveNextSet();
+
+
+#define ADD_ODBC_PARAMETER(name, type, sqlType) \
+	void AddParameter(SQLSMALLINT paramType, type *value, SQLLEN maxLength = sizeof(type)); \
+	type Fetch ## name(int pos); \
+	void Fetch ## name(int pos, type & value);
+
+	ADD_ODBC_PARAMETER(Byte, uint8, SQL_C_TINYINT)
+		ADD_ODBC_PARAMETER(SByte, int8, SQL_C_STINYINT)
+		ADD_ODBC_PARAMETER(UInt16, uint16, SQL_C_USHORT)
+		ADD_ODBC_PARAMETER(Int16, int16, SQL_C_SSHORT)
+		ADD_ODBC_PARAMETER(UInt32, uint32, SQL_C_ULONG)
+		ADD_ODBC_PARAMETER(Int32, int32, SQL_C_LONG)
+		ADD_ODBC_PARAMETER(Single, float, SQL_C_FLOAT)
+		ADD_ODBC_PARAMETER(Double, double, SQL_C_DOUBLE)
+		ADD_ODBC_PARAMETER(UInt64, uint64, SQL_C_UBIGINT)
+		ADD_ODBC_PARAMETER(Int64, int64, SQL_C_SBIGINT)
+
+		void AddParameter(SQLSMALLINT paramType, const char *value, SQLLEN maxLength, SQLSMALLINT sqlDatatype = SQL_CHAR);
+
+	INLINE bool FetchString(int pos, char *outBuffer, SQLLEN maxLength)
+	{
+		SQLLEN bufferSize = 0;
+		return FetchString(pos, outBuffer, maxLength, &bufferSize);
+	};
+
+	bool FetchString(int pos, char *charArray, SQLLEN maxLength, SQLLEN *bufferSize);
+	bool FetchString(int pos, std::string & value);
+
+	INLINE bool FetchBinary(int pos, char *outBuffer, SQLLEN maxLength)
+	{
+		SQLLEN bufferSize = 0;
+		return FetchBinary(pos, outBuffer, maxLength, &bufferSize);
+	};
+	bool FetchBinary(int pos, char *charArray, SQLLEN maxLength, SQLLEN *bufferSize);
+
+
+#undef ADD_ODBC_PARAMETER
+
+	void Detach();
+	~OdbcCommand();
+
+private:
+	bool Open(bool bRetry = false);
+	void ClearParameters();
+public:	void Close();
+private:
+	HDBC m_connHandle;
+	OdbcConnection *m_odbcConnection;
+	HSTMT m_hStmt;
+
+	OdbcParameterCollection m_params;
+
+	tstring m_szError;
+	SQLRETURN m_resultCode;
+};

server/shared/database/OdbcConnection.cpp

@@ -0,0 +1,245 @@
+#include "stdafx.h"
+#include <cstdarg>
+#include "OdbcConnection.h"
+
+OdbcConnection::OdbcConnection() : m_envHandle(nullptr), m_connHandle(nullptr), m_lock(new std::recursive_mutex()), m_bMarsEnabled(false)
+{
+
+}
+
+bool OdbcConnection::isConnected() 
+{
+	Guard lock(m_lock);
+	return (m_connHandle != nullptr);
+}
+
+bool OdbcConnection::isError() 
+{
+	Guard lock(m_lock);
+	return (!m_odbcErrors.empty());
+}
+
+bool OdbcConnection::Connect(tstring & szDSN, tstring & szUser, tstring & szPass, bool bMarsEnabled)
+{
+	m_szDSN = szDSN;
+	m_szUser = szUser;
+	m_szPass = szPass;
+
+	m_bMarsEnabled = bMarsEnabled;
+
+	return Connect();
+}
+
+bool OdbcConnection::Connect()
+{
+	if (m_szDSN.empty())
+		return false;
+
+	Guard lock(m_lock);
+
+	tstring szConn = _T("DSN=") + m_szDSN + _T(";");
+	// Reconnect if we need to.
+	if (isConnected())
+		Disconnect();
+
+	// Allocate enviroment handle
+	if (!SQL_SUCCEEDED(SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &m_envHandle)))
+	{
+		ReportSQLError(SQL_HANDLE_ENV, m_envHandle, _T("SQLAllocHandle"), _T("Unable to allocate environment handle."));
+		goto error_handler;
+	}
+
+	// Request ODBC3 support
+	if (!SQL_SUCCEEDED(SQLSetEnvAttr(m_envHandle, SQL_ATTR_ODBC_VERSION, (void *)SQL_OV_ODBC3, 0)))
+	{
+		ReportSQLError(SQL_HANDLE_ENV, m_envHandle, _T("SQLSetEnvAttr"), _T("Unable to set environment attribute (SQL_ATTR_ODBC_VERSION)."));
+		goto error_handler;
+	}
+
+	// Allocate the connection handle
+	if (!SQL_SUCCEEDED(SQLAllocHandle(SQL_HANDLE_DBC, m_envHandle, &m_connHandle)))
+	{
+		ReportSQLError(SQL_HANDLE_ENV, m_envHandle, _T("SQLAllocHandle"), _T("Unable to allocate connection handle."));
+		goto error_handler;
+	}
+
+	if (m_szUser.length())
+	{
+		szConn += _T("UID=") + m_szUser + _T(";");
+		if (m_szPass.length())
+			szConn += _T("PWD=") + m_szPass + _T(";");
+	}
+
+	if (m_bMarsEnabled)
+	{
+		if (!SQL_SUCCEEDED(SQLSetConnectAttr(m_connHandle, SQL_COPT_SS_MARS_ENABLED, SQL_MARS_ENABLED_YES, SQL_IS_UINTEGER)))
+		{
+			printf("** WARNING **\n\n");
+			printf("Attempted to used MARS (Multiple Active Result Sets), but this\n");
+			printf("feature is not supported by your ODBC driver or SQL Server version.\n\n");
+			printf("To benefit from MARS, you need to be using at least SQL Server 2005, and at\n");
+			printf("least the 'SQL Native Client' ODBC driver (as opposed to the vastly outdated\n'SQL Server' driver).\n\n");
+			printf("Continuing to connect without MARS.\n\n");
+			m_bMarsEnabled = false;
+		}
+	}
+
+	if (!SQL_SUCCEEDED(SQLDriverConnect(m_connHandle, SQL_NULL_HANDLE, (SQLTCHAR *)szConn.c_str(), SQL_NTS, 0, 0, 0, 0)))
+	{
+		ReportSQLError(SQL_HANDLE_DBC, m_connHandle, _T("SQLDriverConnect"), _T("Unable to establish connection."));
+		goto error_handler;
+	}
+
+	for (auto itr = m_commandSet.begin(); itr != m_commandSet.end(); itr++)
+		(*itr)->SetConnectionHandle(m_connHandle);
+
+	return true;
+
+error_handler:
+	ResetHandles();
+	return false;
+}
+
+OdbcCommand *OdbcConnection::CreateCommand()
+{
+	if (!isConnected()
+		&& !Connect())
+		return nullptr;
+
+	return new OdbcCommand(this);
+}
+
+void OdbcConnection::AddCommand(OdbcCommand *dbCommand)
+{
+	Guard lock(m_lock);
+	m_commandSet.insert(dbCommand);
+}
+
+void OdbcConnection::RemoveCommand(OdbcCommand *dbCommand)
+{
+	Guard lock(m_lock);
+	m_commandSet.erase(dbCommand);
+}
+
+// Used to internally reset handles. Should ONLY be used in special cases, otherwise we'll break the state of the connection.
+void OdbcConnection::ResetHandles()
+{
+	// Free the connection handle if it's allocated
+	if (m_connHandle != nullptr)
+	{
+		SQLFreeHandle(SQL_HANDLE_DBC, m_connHandle);
+		m_connHandle = nullptr;
+	}
+
+	// Free the environment handle if it's allocated
+	if (m_envHandle != nullptr)
+	{
+		SQLFreeHandle(SQL_HANDLE_ENV, m_envHandle);
+		m_envHandle = nullptr;
+	}
+}
+
+tstring OdbcConnection::ReportSQLError(SQLSMALLINT handleType, SQLHANDLE handle,
+									   const TCHAR *szSource, const TCHAR *szError, ...)
+{
+	Guard lock(m_lock);
+	TCHAR szErrorBuffer[256];
+	OdbcError *error = new OdbcError();
+
+	va_list args;
+	va_start(args, szError);
+	_vsntprintf(szErrorBuffer, sizeof(szErrorBuffer), szError, args);
+	va_end(args);
+
+	error->Source = szSource;
+	error->ErrorMessage = szErrorBuffer;
+
+	m_odbcErrors.push_back(error);
+
+	if (handle != nullptr)
+	{
+		error->ExtendedErrorMessage = GetSQLError(handleType, handle);
+		if (!error->ExtendedErrorMessage.empty())
+			return error->ExtendedErrorMessage;
+	}
+
+	return szErrorBuffer;
+}
+
+tstring OdbcConnection::GetSQLError(SQLSMALLINT handleType, SQLHANDLE handle)
+{
+	tstring result;
+	SQLTCHAR SqlState[256], SqlMessage[256];
+	SQLINTEGER NativeError;
+	SQLSMALLINT TextLength;
+
+	if (!SQL_SUCCEEDED(SQLGetDiagRec(handleType, handle, 1, (SQLTCHAR *)&SqlState, &NativeError, (SQLTCHAR *)&SqlMessage, sizeof(SqlMessage), &TextLength)))
+		return result;
+
+	result = (TCHAR *)SqlMessage;
+	return result;
+}
+
+OdbcError *OdbcConnection::GetError()
+{
+	Guard lock(m_lock);
+	if (m_odbcErrors.empty())
+		return nullptr;
+
+	OdbcError *pError = m_odbcErrors.back();
+	m_odbcErrors.pop_back();
+	return pError;
+}
+
+void OdbcConnection::ResetErrors()
+{
+	if (!isError())
+		return;
+
+	Guard lock(m_lock);
+	OdbcError *pError;
+	while ((pError = GetError()) != nullptr)
+		delete pError;
+}
+
+void OdbcConnection::Disconnect()
+{
+	// Make sure our handles are open. If not, there's nothing to do.
+	if (!isConnected())
+		return;
+
+	Guard lock(m_lock);
+	// Kill off open statements
+	if (m_commandSet.size())
+	{
+		for (auto itr = m_commandSet.begin(); itr != m_commandSet.end(); itr++)
+		{
+			// Detach from the connection first so we don't try to remove it from the set (while we're using it!)
+			(*itr)->Detach();
+
+			// Now free it.
+			delete (*itr);
+		}
+
+		m_commandSet.clear();
+	}
+
+	// Close the connection to the server & reset our handles
+	Close();
+}
+
+void OdbcConnection::Close()
+{
+	// Disconnect from server.
+	SQLDisconnect(m_connHandle);
+
+	// Reset handles
+	ResetHandles();
+}
+
+OdbcConnection::~OdbcConnection()
+{
+	Disconnect();
+	ResetErrors();
+	delete m_lock;
+}

server/shared/database/OdbcConnection.h

@@ -0,0 +1,74 @@
+#pragma once
+
+#pragma comment(lib, "odbc32.lib")
+
+#include <sqlext.h>
+#include <set>
+
+// MARS settings from sqlncli.h
+#ifndef SQL_COPT_SS_MARS_ENABLED
+#        define SQL_COPT_SS_MARS_ENABLED 1224
+#endif
+
+#ifndef SQL_MARS_ENABLED_YES
+#        define SQL_MARS_ENABLED_YES (SQLPOINTER)1
+#endif
+
+#include "../tstring.h"
+
+struct OdbcError
+{
+	tstring	Source;
+	tstring	ErrorMessage;
+	tstring	ExtendedErrorMessage;
+};
+
+#include "OdbcCommand.h"
+
+class std::recursive_mutex;
+class OdbcConnection
+{
+	friend class OdbcCommand;
+
+public:
+	OdbcConnection();
+
+	bool isConnected();
+	bool isError();
+
+	INLINE HDBC GetConnectionHandle() { return m_connHandle; }
+	INLINE bool isMarsEnabled() { return m_bMarsEnabled; }
+
+	bool Connect(tstring & szDSN, tstring & szUser, tstring & szPass, bool bMarsEnabled = false);
+	bool Connect();
+
+	OdbcCommand *CreateCommand();
+	static tstring GetSQLError(SQLSMALLINT handleType, SQLHANDLE handle);
+
+	OdbcError *GetError();
+	void ResetErrors();
+
+	void Disconnect();
+	~OdbcConnection();
+
+private:
+	void AddCommand(OdbcCommand *dbCommand);
+	void RemoveCommand(OdbcCommand *dbCommand);
+	tstring ReportSQLError(SQLSMALLINT handleType, SQLHANDLE handle, const TCHAR *szSource, const TCHAR *szError, ...);
+
+	void Close();
+	void ResetHandles();
+
+private:
+	tstring m_szDSN, m_szUser, m_szPass;
+
+	HENV m_envHandle;
+	HDBC m_connHandle;
+
+	std::recursive_mutex * m_lock;
+
+	std::vector<OdbcError   *> m_odbcErrors;
+	std::set   <OdbcCommand *> m_commandSet;
+
+	 bool m_bMarsEnabled;
+};

server/shared/database/OdbcParameter.cpp

@@ -0,0 +1,46 @@
+#include "stdafx.h"
+#include "OdbcConnection.h"
+
+OdbcParameter::OdbcParameter(SQLSMALLINT parameterType, SQLSMALLINT dataType, SQLPOINTER parameterAddress, SQLLEN maxLength /*= 1*/)
+	: m_parameterType(parameterType), m_cDataType(dataType), m_parameterAddress(parameterAddress), 
+	m_dataTypeLength(0), m_pCBValue(SQL_NTS)
+{
+	switch (m_cDataType)
+	{
+	case SQL_CHAR:
+	case SQL_VARCHAR:
+	case SQL_BINARY:
+		m_dataTypeLength = maxLength;
+		m_dataType = m_cDataType;
+		if (m_cDataType == SQL_BINARY || m_cDataType == SQL_CHAR)
+			m_pCBValue = m_dataTypeLength;
+		break;
+
+	case SQL_C_STINYINT:
+	case SQL_C_UTINYINT:
+		m_dataType = SQL_TINYINT;
+		break;
+
+	case SQL_C_SSHORT:
+	case SQL_C_USHORT:
+		m_dataType = SQL_SMALLINT;
+		break;
+
+	case SQL_C_SLONG:
+	case SQL_C_ULONG:
+		m_dataType = SQL_INTEGER;
+		break;
+
+	case SQL_FLOAT:
+		m_cDataType = m_dataType;
+		break;
+
+	case SQL_DOUBLE:
+		m_cDataType = m_dataType;
+		break;
+
+	default: // unknown, default to integer
+		m_dataType = SQL_INTEGER;
+		m_cDataType = m_dataType + SQL_SIGNED_OFFSET;
+	}
+}

server/shared/database/OdbcParameter.h

@@ -0,0 +1,19 @@
+#pragma once
+
+class OdbcParameter
+{
+public:
+	OdbcParameter(SQLSMALLINT parameterType, SQLSMALLINT dataType, SQLPOINTER parameterAddress, SQLLEN maxLength = 1);
+
+	INLINE SQLSMALLINT GetParameterType() { return m_parameterType; };
+	INLINE SQLSMALLINT GetDataType() { return m_dataType; };
+	INLINE SQLSMALLINT GetCDataType() { return m_cDataType; };
+	INLINE SQLPOINTER GetAddress() { return m_parameterAddress; };
+	INLINE SQLLEN GetDataTypeSize() { return m_dataTypeLength; };
+	INLINE SQLLEN *GetCBValue() { return &m_pCBValue; };
+
+private:
+	SQLSMALLINT m_parameterType, m_dataType, m_cDataType;
+	SQLPOINTER m_parameterAddress;
+	SQLLEN m_dataTypeLength, m_pCBValue;
+};

server/shared/database/OdbcRecordset.cpp

@@ -0,0 +1,61 @@
+#include "stdafx.h"
+#include "OdbcConnection.h"
+#include "OdbcRecordset.h"
+
+OdbcRecordset::OdbcRecordset(OdbcConnection * dbConnection) : _dbConnection(dbConnection)
+{
+	_dbCommand = _dbConnection->CreateCommand();
+}
+
+TCHAR * OdbcRecordset::Read(bool bAllowEmptyTable /*= false*/)
+{
+	static TCHAR szError[128] = {0};
+
+	// Build statement
+	tstring szSQL = _T("SELECT ");
+	
+	szSQL += GetColumns();
+	szSQL += _T(" FROM ");
+	szSQL += GetTableName();
+
+	tstring szWhereClause = GetWhereClause();
+	// Do we have a where clause? Include it.
+	if (!szWhereClause.empty())
+	{
+		szSQL += _T(" WHERE ");
+		szSQL += szWhereClause;
+	}
+
+	// Attempt to execute the statement.
+	if (!_dbCommand->Execute(szSQL))
+		return _dbCommand->GetError();
+
+	// Does the table have any rows?
+	// Make sure we allow for tables that can be empty.
+	if (!_dbCommand->hasData())
+	{
+		if (bAllowEmptyTable)
+			return nullptr;
+
+		_stprintf(szError, _T("%s table is empty."), GetTableName().c_str());
+		return szError;
+	}
+
+	do
+	{
+		// This extra result/check potentially slows things down. 
+		// It's also not very informative, so this could really use a bit of a rewrite
+		// to better allow for this scenario.
+		if (!Fetch())
+		{
+			_stprintf(szError, _T("Could not fetch row in table %s."), GetTableName().c_str());
+			return szError;
+		}
+	} while (_dbCommand->MoveNext());
+	return nullptr;
+}
+
+OdbcRecordset::~OdbcRecordset()
+{
+	_dbCommand->Close();
+}

server/shared/database/OdbcRecordset.h

@@ -0,0 +1,52 @@
+#pragma once
+
+#include "../tstring.h"
+class OdbcConnection;
+class OdbcCommand;
+
+class OdbcRecordset
+{
+public:
+	OdbcRecordset(OdbcConnection * dbConnection);
+
+	virtual tstring GetTableName() = 0;
+	virtual tstring GetColumns() { return _T("*"); }
+	virtual tstring GetWhereClause() { return _T(""); }
+
+	TCHAR * Read(bool bAllowEmptyTable = false);
+	virtual bool Fetch() = 0;
+
+	virtual ~OdbcRecordset();
+
+protected:
+	OdbcConnection * _dbConnection;
+	OdbcCommand * _dbCommand;
+};
+
+#define _LOAD_TABLE(Set, DB, Array, AllowEmptyTable, IsSlient) \
+	Set _ ## Set(DB, Array); \
+	if (!IsSlient) \
+	_tprintf(_T("Loaded table [%s]\n"), _ ## Set .GetTableName().c_str()); \
+	TCHAR * _szError ## Set = _ ## Set.Read(AllowEmptyTable);
+
+#define LOAD_TABLE(Set, DB, Array, AllowEmptyTable, IsSlient) \
+	_LOAD_TABLE(Set, DB, Array, AllowEmptyTable, IsSlient); \
+	_HANDLE_DB_ERROR(_szError ## Set)
+
+#define LOAD_TABLE_ERROR_ONLY(Set, DB, Array, AllowEmptyTable, IsSlient) \
+	_LOAD_TABLE(Set, DB, Array, AllowEmptyTable, IsSlient); \
+	_HANDLE_DB_ERROR_ONLY(_szError ## Set)
+
+#define _DISPLAY_DB_ERROR(err) \
+	_tprintf(_T("ERROR: Could not load table, the error received was:\n%s\n"), err); \
+
+#define _HANDLE_DB_ERROR(err) \
+	if (err != nullptr) \
+	_DISPLAY_DB_ERROR(err); \
+	return (err == nullptr)
+
+#define _HANDLE_DB_ERROR_ONLY(err) \
+	if (err != nullptr) { \
+	_DISPLAY_DB_ERROR(err); \
+	return false; \
+	}

server/shared/database/PetLevelUpTableSet.h

@@ -0,0 +1,25 @@
+#pragma once
+
+class CPetLevelUpTableSet : public OdbcRecordset
+{
+public:
+	CPetLevelUpTableSet(OdbcConnection * dbConnection, LevelUpArray * pMap) 
+		: OdbcRecordset(dbConnection), m_pMap(pMap) {}
+
+	virtual tstring GetTableName() { return _T("LEVEL_UP_PET"); }
+	virtual tstring GetColumns() { return _T("[Level], [Exp]"); }
+
+	virtual bool Fetch()
+	{
+		std::pair<uint8, int64> pData;
+
+		_dbCommand->FetchByte(1, pData.first);
+		_dbCommand->FetchInt64(2, pData.second);
+
+		m_pMap->insert(pData);
+
+		return true;
+	}
+
+	LevelUpArray *m_pMap;
+};

server/shared/database/PetTableSet.h

@@ -0,0 +1,48 @@
+#pragma once
+
+class CPetTableSet : public OdbcRecordset
+{
+public:
+	CPetTableSet(OdbcConnection * dbConnection, PetArray *pMap) 
+		: OdbcRecordset(dbConnection), m_pMap(pMap) {}
+
+	virtual tstring GetTableName() { return _T("PET_DATA"); }
+	virtual tstring GetColumns() 
+	{
+		return _T("PET_SERIAL, PET_SLOT, PET_NAME, PET_EXP, PET_LEVEL, PET_STOMACH, PET_ITEMID, PET_CLASS");
+	}
+
+	virtual bool Fetch()
+	{
+		CPet * pData = new CPet();
+		int i = 1;
+		uint32 ItemId;
+		uint8 Slot;
+		_dbCommand->FetchUInt64(i++, pData->m_Serial);
+		_dbCommand->FetchString(i++, pData->m_strPetID);
+		_dbCommand->FetchUInt64(i++, pData->m_iExp);
+		_dbCommand->FetchByte(i++, pData->m_bLevel);
+		_dbCommand->FetchUInt16(i++, pData->m_sSatisfaction);
+		_dbCommand->FetchByte(i++, Slot);
+		_dbCommand->FetchUInt32(i++, ItemId);
+		_ITEM_DATA * pItem = &pData->m_sItemArray[Slot];
+		pItem->nNum = ItemId;
+		pItem->sCount = 1;
+		pItem->sDuration = 1;
+		_dbCommand->FetchByte(i++, pData->m_sClass);
+		_dbCommand->FetchUInt32(i++, pData->SpecialPetID);
+		if (pData->SpecialPetID > g_pMain->LastPetID)
+		g_pMain->LastPetID = pData->SpecialPetID;
+		pData->m_pNpc = nullptr;
+		
+		if (pData == nullptr)
+			delete pData;
+		else
+			m_pMap->insert(std::make_pair(pData->m_Serial, pData));
+
+
+		return true;
+	}
+
+	PetArray * m_pMap;
+};

server/shared/database/PremiumItemExpSet.h

@@ -0,0 +1,29 @@
+#pragma once
+
+class CPremiumItemExpSet : public OdbcRecordset
+{
+public:
+	CPremiumItemExpSet(OdbcConnection * dbConnection, PremiumItemExpArray * pMap) 
+		: OdbcRecordset(dbConnection), m_pMap(pMap) {}
+
+	virtual tstring GetTableName() { return _T("PREMIUM_ITEM_EXP"); }
+	virtual tstring GetColumns() { return _T("nIndex, Type, MinLevel, MaxLevel, sPercent"); }
+
+	virtual bool Fetch()
+	{
+		_PREMIUM_ITEM_EXP * pData = new _PREMIUM_ITEM_EXP;
+
+		_dbCommand->FetchUInt16(1, pData->nIndex);
+		_dbCommand->FetchByte(2, pData->Type);
+		_dbCommand->FetchByte(3, pData->MinLevel);
+		_dbCommand->FetchByte(4, pData->MaxLevel);
+		_dbCommand->FetchUInt16(5, pData->sPercent);
+
+		if (!m_pMap->PutData(pData->nIndex, pData))
+			delete pData;
+
+		return true;
+	}
+
+	PremiumItemExpArray *m_pMap;
+};

server/shared/database/PremiumItemSet.h

@@ -0,0 +1,31 @@
+#pragma once
+
+class CPremiumItemSet : public OdbcRecordset
+{
+public:
+	CPremiumItemSet(OdbcConnection * dbConnection, PremiumItemArray * pMap) 
+		: OdbcRecordset(dbConnection), m_pMap(pMap) {}
+
+	virtual tstring GetTableName() { return _T("PREMIUM_ITEM"); }
+	virtual tstring GetColumns() { return _T("Type, ExpRestorePercent, NoahPercent, DropPercent, BonusLoyalty, RepairDiscountPercent, ItemSellPercent"); }
+
+	virtual bool Fetch()
+	{
+		_PREMIUM_ITEM * pData = new _PREMIUM_ITEM;
+
+		_dbCommand->FetchByte(1, pData->Type);
+		_dbCommand->FetchUInt16(2, pData->ExpRestorePercent);
+		_dbCommand->FetchUInt16(3, pData->NoahPercent);
+		_dbCommand->FetchUInt16(4, pData->DropPercent);
+		_dbCommand->FetchUInt32(5, pData->BonusLoyalty);
+		_dbCommand->FetchUInt16(6, pData->RepairDiscountPercent);
+		_dbCommand->FetchUInt16(7, pData->ItemSellPercent);
+
+		if (!m_pMap->PutData(pData->Type, pData))
+			delete pData;
+
+		return true;
+	}
+
+	PremiumItemArray *m_pMap;
+};

server/shared/database/QuestHelperSet.h

@@ -0,0 +1,60 @@
+#pragma once
+
+class CQuestHelperSet : public OdbcRecordset
+{
+public:
+	CQuestHelperSet(OdbcConnection * dbConnection, QuestHelperArray * pMap) 
+		: OdbcRecordset(dbConnection), m_pMap(pMap) {}
+
+	virtual tstring GetTableName() { return _T("QUEST_HELPER"); }
+	virtual tstring GetColumns() { return _T("nIndex, bMessageType, bLevel, nExp, bClass, bNation, bQuestType, bZone, sNpcId, sEventDataIndex, bEventStatus, nEventTriggerIndex, nEventCompleteIndex, nExchangeIndex, nEventTalkIndex, strLuaFilename"); }
+
+	virtual bool Fetch()
+	{
+		_QUEST_HELPER *pData = new _QUEST_HELPER;
+		uint8 bEventStatus = 0xff;
+
+		_dbCommand->FetchUInt32(1, pData->nIndex);
+		_dbCommand->FetchByte  (2, pData->bMessageType);
+		_dbCommand->FetchByte  (3, pData->bLevel);
+		_dbCommand->FetchUInt32(4, pData->nExp);
+		_dbCommand->FetchByte  (5, pData->bClass);
+		_dbCommand->FetchByte  (6, pData->bNation);
+		_dbCommand->FetchByte  (7, pData->bQuestType);
+		_dbCommand->FetchByte  (8, pData->bZone);
+		_dbCommand->FetchUInt16(9, pData->sNpcId);
+		_dbCommand->FetchUInt16(10, pData->sEventDataIndex);
+		_dbCommand->FetchByte  (11, bEventStatus);
+		_dbCommand->FetchUInt32(12, pData->nEventTriggerIndex);
+		_dbCommand->FetchUInt32(13, pData->nEventCompleteIndex);
+		_dbCommand->FetchUInt32(14, pData->nExchangeIndex);
+		_dbCommand->FetchUInt32(15, pData->nEventTalkIndex);
+		_dbCommand->FetchString(16, pData->strLuaFilename);
+
+		// Hack to workaround some silly ODBC/MSSQL behaviour.
+		pData->bEventStatus = bEventStatus;
+
+		if (!m_pMap->PutData(pData->nIndex, pData))
+		{
+			delete pData;
+		}
+		else
+		{
+			// Add the quest helper instance to the NPC's list
+			// so that we can perform faster searches.
+			QuestNpcList * pList = &g_pMain->m_QuestNpcList;
+			QuestNpcList::iterator itr = pList->find(pData->sNpcId);
+			if (itr == pList->end())
+			{
+				pList->insert(make_pair(pData->sNpcId, QuestHelperList()));
+				itr = pList->find(pData->sNpcId);
+			}
+
+			itr->second.push_back(pData);
+		}
+
+		return true;
+	}
+
+	QuestHelperArray *m_pMap;
+};

server/shared/database/QuestMonsterSet.h

@@ -0,0 +1,32 @@
+#pragma once
+
+class CQuestMonsterSet : public OdbcRecordset
+{
+public:
+	CQuestMonsterSet(OdbcConnection * dbConnection, QuestMonsterArray * pMap) 
+		: OdbcRecordset(dbConnection), m_pMap(pMap) {}
+
+	virtual tstring GetTableName() { return _T("QUEST_MONSTER"); }
+	virtual tstring GetColumns() { return _T("sQuestNum, sNum1a, sNum1b, sNum1c, sNum1d, sCount1, sNum2a, sNum2b, sNum2c, sNum2d, sCount2, sNum3a, sNum3b, sNum3c, sNum3d, sCount3, sNum4a, sNum4b, sNum4c, sNum4d, sCount4"); }
+
+	virtual bool Fetch()
+	{
+		_QUEST_MONSTER *pData = new _QUEST_MONSTER();
+		uint32 col = 1;
+
+		_dbCommand->FetchUInt16(col++, pData->sQuestNum);
+		for (uint32 group = 0; group < QUEST_MOB_GROUPS; group++)
+		{
+			for (uint32 i = 0; i < QUEST_MOBS_PER_GROUP; i++)
+				_dbCommand->FetchUInt16(col++, pData->sNum[group][i]);
+			_dbCommand->FetchUInt16(col++, pData->sCount[group]);
+		}
+
+		if (!m_pMap->PutData(pData->sQuestNum, pData))
+			delete pData;
+
+		return true;
+	}
+
+	QuestMonsterArray *m_pMap;
+};

server/shared/database/ReKnightsSet.h

@@ -0,0 +1,59 @@
+#pragma once
+
+class CReKnightsSet : public OdbcRecordset
+{
+public:
+	CReKnightsSet(OdbcConnection * dbConnection, KnightsArray * pMap) 
+		: OdbcRecordset(dbConnection), m_pMap(pMap) {}
+
+	virtual tstring GetTableName() { return _T("KNIGHTS"); }
+	virtual tstring GetColumns() { return _T("IDNum, Flag, Nation, Ranking, IDName, Members, Chief, ViceChief_1, ViceChief_2, ViceChief_3, Gold, Domination, Points, Mark, sMarkVersion, sMarkLen, sCape, bCapeR, bCapeG, bCapeB, sAllianceKnights, ClanPointFund, strClanNotice, bySiegeFlag, nLose, nVictory, ClanPointMethod"); }
+
+	virtual bool Fetch()
+	{
+		uint16 myIndex = -1;
+		_dbCommand->FetchUInt16(1, myIndex);
+
+		CKnights *pData = m_pMap->GetData(myIndex);
+
+		if(pData != nullptr)
+		{
+			
+
+
+		_dbCommand->FetchByte(2, pData->m_byFlag);
+		_dbCommand->FetchByte(3, pData->m_byNation);
+		_dbCommand->FetchByte(4, pData->m_byRanking);
+		_dbCommand->FetchString(5, pData->m_strName);
+		_dbCommand->FetchUInt16(6, pData->m_sMembers);
+		_dbCommand->FetchString(7, pData->m_strChief);
+		_dbCommand->FetchString(8, pData->m_strViceChief_1);
+		_dbCommand->FetchString(9, pData->m_strViceChief_2);
+		_dbCommand->FetchString(10, pData->m_strViceChief_3);
+		_dbCommand->FetchUInt64(11, pData->m_nMoney);
+		_dbCommand->FetchUInt16(12, pData->m_sDomination);
+		_dbCommand->FetchUInt32(13, (uint32 &) pData->m_nPoints);
+		_dbCommand->FetchBinary(14, pData->m_Image, sizeof(pData->m_Image));
+		_dbCommand->FetchUInt16(15, pData->m_sMarkVersion);
+		_dbCommand->FetchUInt16(16, pData->m_sMarkLen);
+		_dbCommand->FetchUInt16(17, pData->m_sCape);
+		_dbCommand->FetchByte(18, pData->m_bCapeR);
+		_dbCommand->FetchByte(19, pData->m_bCapeG);
+		_dbCommand->FetchByte(20, pData->m_bCapeB);
+		_dbCommand->FetchUInt16(21, pData->m_sAlliance);
+		_dbCommand->FetchUInt32(22, (uint32 &) pData->m_nClanPointFund);
+		_dbCommand->FetchString(23, pData->m_strClanNotice);
+		_dbCommand->FetchByte(24, pData->bySiegeFlag);
+		_dbCommand->FetchUInt16(25, pData->nLose);
+		_dbCommand->FetchUInt16(26, pData->nVictory);
+		_dbCommand->FetchByte(24, pData->m_sClanPointMethod);
+
+		pData->m_byGrade = g_pMain->GetKnightsGrade(pData->m_nPoints);
+		
+		}
+		
+		return true;
+	}
+
+	KnightsArray *m_pMap;
+};

server/shared/database/RentalItemSet.h

@@ -0,0 +1,35 @@
+#pragma once
+
+class CRentalItemSet : public OdbcRecordset
+{
+public:
+	CRentalItemSet(OdbcConnection * dbConnection, RentalItemArray * pMap) 
+		: OdbcRecordset(dbConnection), m_pMap(pMap) {}
+
+	virtual tstring GetTableName() { return _T("RENTAL_ITEM"); }
+	virtual tstring GetColumns() { return _T("nRentalIndex, nItemIndex, sDurability, nSerialNumber, byRegType, byItemType, byClass, sRentalTime, nRentalMoney, strLenderCharID, strBorrowerCharID"); }
+
+	virtual bool Fetch()
+	{
+		_RENTAL_ITEM *pData = new _RENTAL_ITEM;
+
+		_dbCommand->FetchUInt32(1, pData->nRentalIndex);
+		_dbCommand->FetchUInt32(2, pData->nItemID);
+		_dbCommand->FetchUInt16(3, pData->sDurability);
+		_dbCommand->FetchUInt64(4, pData->nSerialNum);
+		_dbCommand->FetchByte(5, pData->byRegType);
+		_dbCommand->FetchByte(6, pData->byItemType);
+		_dbCommand->FetchByte(7, pData->byClass);
+		_dbCommand->FetchUInt16(8, pData->sRentalTime);
+		_dbCommand->FetchUInt32(9, pData->nRentalMoney);
+		_dbCommand->FetchString(10, pData->strLenderCharID);
+		_dbCommand->FetchString(11, pData->strBorrowerCharID);
+
+		if (!m_pMap->PutData(pData->nRentalIndex, pData))
+			delete pData;
+
+		return true;
+	}
+
+	RentalItemArray *m_pMap;
+};

server/shared/database/ServerResourceSet.h

@@ -0,0 +1,26 @@
+#pragma once
+
+class CServerResourceSet : public OdbcRecordset
+{
+public:
+	CServerResourceSet(OdbcConnection * dbConnection, ServerResourceArray * pMap) 
+		: OdbcRecordset(dbConnection), m_pMap(pMap) {}
+
+	virtual tstring GetTableName() { return _T("SERVER_RESOURCE"); }
+	virtual tstring GetColumns() { return _T("nResourceID, strResource"); }
+
+	virtual bool Fetch()
+	{
+		_SERVER_RESOURCE *pData = new _SERVER_RESOURCE;
+
+		_dbCommand->FetchUInt32(1, pData->nResourceID);
+		_dbCommand->FetchString(2, pData->strResource);
+
+		if (!m_pMap->PutData(pData->nResourceID, pData))
+			delete pData;
+
+		return true;
+	}
+
+	ServerResourceArray *m_pMap;
+};

server/shared/database/SetItemTableSet.h

@@ -0,0 +1,55 @@
+#pragma once
+
+class CSetItemTableSet : public OdbcRecordset
+{
+public:
+	CSetItemTableSet(OdbcConnection * dbConnection, SetItemArray * pMap) 
+		: OdbcRecordset(dbConnection), m_pMap(pMap) {}
+
+	virtual tstring GetTableName() { return _T("SET_ITEM"); }
+	virtual tstring GetColumns() 
+	{
+		return _T("SetIndex, HPBonus, MPBonus, StrengthBonus, StaminaBonus, DexterityBonus, IntelBonus, CharismaBonus, "
+			"FlameResistance, GlacierResistance, LightningResistance, PoisonResistance, MagicResistance, CurseResistance, "
+			"XPBonusPercent, CoinBonusPercent, APBonusPercent, APBonusClassType, APBonusClassPercent, ACBonus, ACBonusClassType, ACBonusClassPercent, "
+			"MaxWeightBonus, NPBonus");
+	}
+
+	virtual bool Fetch()
+	{
+		_SET_ITEM *pData = new _SET_ITEM;
+		int i = 1;
+
+		_dbCommand->FetchUInt32(i++, pData->SetIndex);
+		_dbCommand->FetchUInt16(i++, pData->HPBonus);
+		_dbCommand->FetchUInt16(i++, pData->MPBonus);
+		_dbCommand->FetchUInt16(i++, pData->StrengthBonus);
+		_dbCommand->FetchUInt16(i++, pData->StaminaBonus);
+		_dbCommand->FetchUInt16(i++, pData->DexterityBonus);
+		_dbCommand->FetchUInt16(i++, pData->IntelBonus);
+		_dbCommand->FetchUInt16(i++, pData->CharismaBonus);
+		_dbCommand->FetchUInt16(i++, pData->FlameResistance);
+		_dbCommand->FetchUInt16(i++, pData->GlacierResistance);
+		_dbCommand->FetchUInt16(i++, pData->LightningResistance);
+		_dbCommand->FetchUInt16(i++, pData->PoisonResistance);
+		_dbCommand->FetchUInt16(i++, pData->MagicResistance);
+		_dbCommand->FetchUInt16(i++, pData->CurseResistance);
+		_dbCommand->FetchUInt16(i++, pData->XPBonusPercent);
+		_dbCommand->FetchUInt16(i++, pData->CoinBonusPercent);
+		_dbCommand->FetchUInt16(i++, pData->APBonusPercent);
+		_dbCommand->FetchUInt16(i++, pData->APBonusClassType);
+		_dbCommand->FetchUInt16(i++, pData->APBonusClassPercent);
+		_dbCommand->FetchUInt16(i++, pData->ACBonus);
+		_dbCommand->FetchUInt16(i++, pData->ACBonusClassType);
+		_dbCommand->FetchUInt16(i++, pData->ACBonusClassPercent);
+		_dbCommand->FetchUInt16(i++, pData->MaxWeightBonus);
+		_dbCommand->FetchByte(i++, pData->NPBonus);
+
+		if (!m_pMap->PutData(pData->SetIndex, pData))
+			delete pData;
+
+		return true;
+	}
+
+	SetItemArray *m_pMap;
+};

server/shared/database/StartPositionRandomSet.h

@@ -0,0 +1,31 @@
+ #pragma once
+
+class CStartPositionRandomSet : public OdbcRecordset
+{
+public:
+	CStartPositionRandomSet(OdbcConnection * dbConnection, StartPositionRandomArray * pMap) 
+		: OdbcRecordset(dbConnection), m_pMap(pMap) {}
+
+	virtual tstring GetTableName() { return _T("START_POSITION_RANDOM"); }
+	virtual tstring GetColumns() { return _T("ZoneID, PosX, PosZ, Radius"); }
+
+	virtual bool Fetch()
+	{
+		_START_POSITION_RANDOM * pData = new _START_POSITION_RANDOM;
+
+		int i = 1;
+		_dbCommand->FetchByte(i++, pData->ZoneID);
+		_dbCommand->FetchUInt16(i++, pData->PosX);
+		_dbCommand->FetchUInt16(i++, pData->PosZ);
+		_dbCommand->FetchByte(i++, pData->Radius);
+
+		pData->sIndex = m_pMap->GetSize();
+
+		if (!m_pMap->PutData(pData->sIndex, pData))
+			delete pData;
+
+		return true;
+	}
+
+	StartPositionRandomArray *m_pMap;
+};

server/shared/database/StartPositionSet.h

@@ -0,0 +1,36 @@
+#pragma once
+
+class CStartPositionSet : public OdbcRecordset
+{
+public:
+	CStartPositionSet(OdbcConnection * dbConnection, StartPositionArray * pMap) 
+		: OdbcRecordset(dbConnection), m_pMap(pMap) {}
+
+	virtual tstring GetTableName() { return _T("START_POSITION"); }
+	virtual tstring GetColumns() { return _T("ZoneID, sKarusX, sKarusZ, sElmoradX, sElmoradZ, bRangeX, bRangeZ, sKarusGateX, sKarusGateZ, sElmoGateX, sElmoGateZ"); }
+
+	virtual bool Fetch()
+	{
+		_START_POSITION *pData = new _START_POSITION;
+
+		_dbCommand->FetchUInt16(1, pData->ZoneID);
+		_dbCommand->FetchUInt16(2, pData->sKarusX);
+		_dbCommand->FetchUInt16(3, pData->sKarusZ);
+		_dbCommand->FetchUInt16(4, pData->sElmoradX);
+		_dbCommand->FetchUInt16(5, pData->sElmoradZ);
+		_dbCommand->FetchByte (6, pData->bRangeX);
+		_dbCommand->FetchByte (7, pData->bRangeZ);
+		_dbCommand->FetchUInt16(8, pData->sKarusGateX);
+		_dbCommand->FetchUInt16(9, pData->sKarusGateZ);
+		_dbCommand->FetchUInt16(10, pData->sElmoradGateX);
+		_dbCommand->FetchUInt16(11, pData->sElmoradGateZ);
+
+
+		if (!m_pMap->PutData(pData->ZoneID, pData))
+			delete pData;
+
+		return true;
+	}
+
+	StartPositionArray *m_pMap;
+};

server/shared/database/UserDailyOpSet.h

@@ -0,0 +1,44 @@
+#pragma once
+
+class CUserDailyOpSet : public OdbcRecordset
+{
+public:
+	CUserDailyOpSet(OdbcConnection * dbConnection, UserDailyOpMap * pMap) 
+		: OdbcRecordset(dbConnection), m_pMap(pMap) {}
+
+	virtual tstring GetTableName() { return _T("USER_DAILY_OP"); }
+	virtual tstring GetColumns() { return _T("strUserId, ChaosMapTime, UserRankRewardTime, PersonalRankRewardTime, KingWingTime, WarderKillerTime1, WarderKillerTime2, KeeperKillerTime, UserLoyaltyWingRewardTime"); }
+
+	virtual bool Fetch()
+	{
+		_USER_DAILY_OP * pData = new _USER_DAILY_OP;
+
+		int i = 1;
+		_dbCommand->FetchString(i++, pData->strUserId);
+		_dbCommand->FetchInt32(i++, pData->ChaosMapTime);
+		_dbCommand->FetchInt32(i++, pData->UserRankRewardTime);
+		_dbCommand->FetchInt32(i++, pData->PersonalRankRewardTime);
+		_dbCommand->FetchInt32(i++, pData->KingWingTime);
+		_dbCommand->FetchInt32(i++, pData->WarderKillerTime1);
+		_dbCommand->FetchInt32(i++, pData->WarderKillerTime2);
+		_dbCommand->FetchInt32(i++, pData->KeeperKillerTime);
+		_dbCommand->FetchInt32(i++, pData->UserLoyaltyWingRewardTime);
+
+		if (pData->strUserId.empty())
+		{
+			delete pData;
+			return true;
+		}
+
+		InsertToMap(pData);
+		return true;
+	}
+
+	virtual void InsertToMap(_USER_DAILY_OP * pData) 
+	{
+		if (!pData->strUserId.empty())
+			m_pMap->insert(make_pair(pData->strUserId, pData));
+	}
+
+	UserDailyOpMap *m_pMap;
+};

server/shared/database/UserItemSet.h

@@ -0,0 +1,35 @@
+#pragma once
+
+class CUserItemSet : public OdbcRecordset
+{
+public:
+	CUserItemSet(OdbcConnection * dbConnection, UserItemArray * pMap) 
+		: OdbcRecordset(dbConnection), m_pMap(pMap) {}
+
+	virtual tstring GetTableName() { return _T("USER_ITEMS"); }
+	virtual tstring GetColumns() { return _T("nItemID, nItemSerial"); }
+
+	virtual bool Fetch()
+	{
+		uint32 nItemID = _dbCommand->FetchUInt32(1);
+		uint64 nItemSerial = _dbCommand->FetchUInt64(2);
+
+		_USER_ITEM * pData = m_pMap->GetData(nItemID);
+
+		if (pData == nullptr)
+		{
+			pData = new _USER_ITEM;
+			pData->nItemID = nItemID;
+			pData->nItemSerial.push_back(nItemSerial);
+
+			if (!m_pMap->PutData(pData->nItemID,pData))
+				delete pData;
+		}
+		else
+			pData->nItemSerial.push_back(nItemSerial);
+
+		return true;
+	}
+
+	UserItemArray *m_pMap;
+};

server/shared/database/UserKnightsRankSet.h

@@ -0,0 +1,26 @@
+#pragma once
+
+class CUserKnightsRankSet : public CUserPersonalRankSet
+{
+public:
+	CUserKnightsRankSet(OdbcConnection * dbConnection, UserNameRankMap * pMap) 
+		: CUserPersonalRankSet(dbConnection, pMap) {}
+
+	virtual tstring GetTableName() { return _T("USER_KNIGHTS_RANK"); }
+	virtual tstring GetColumns() { return _T("shIndex, nMoney, strElmoUserID, strKarusUserID, nElmoLoyalty, nKarusLoyalty"); }
+
+	virtual void InsertToMap(std::string & strKarusUserID, std::string & strElmoUserID, _USER_RANK * pData) 
+	{
+		if (!strElmoUserID.empty())
+		{
+			m_pMap->insert(make_pair(strElmoUserID, pData));
+			g_pMain->m_playerRankings[ELMORAD_ARRAY].insert(std::make_pair((uint8)pData->nRank, pData));
+		}
+
+		if (!strKarusUserID.empty())
+		{
+			m_pMap->insert(make_pair(strKarusUserID, pData));
+			g_pMain->m_playerRankings[KARUS_ARRAY].insert(std::make_pair((uint8)pData->nRank, pData));
+		}
+	}
+};

server/shared/database/UserPersonalRankSet.h

@@ -0,0 +1,58 @@
+#pragma once
+
+class CUserPersonalRankSet : public OdbcRecordset
+{
+public:
+	CUserPersonalRankSet(OdbcConnection * dbConnection, UserNameRankMap * pMap) 
+		: OdbcRecordset(dbConnection), m_pMap(pMap) {}
+
+	virtual tstring GetTableName() { return _T("USER_PERSONAL_RANK"); }
+	virtual tstring GetColumns() { return _T("nRank, nSalary, strElmoUserID, strKarusUserID, nElmoLoyaltyMonthly, nKarusLoyaltyMonthly"); }
+
+	virtual bool Fetch()
+	{
+		_USER_RANK *pData = new _USER_RANK;
+		std::string strElmoUserID, strKarusUserID;
+
+		_dbCommand->FetchUInt16(1, pData->nRank);
+		_dbCommand->FetchUInt32(2, pData->nSalary);
+		_dbCommand->FetchString(3, strElmoUserID);
+		_dbCommand->FetchString(4, strKarusUserID);
+		_dbCommand->FetchUInt32(5, pData->nLoyalty[ELMORAD_ARRAY]); // monthly NP for USER_PERSONAL_RANK
+		_dbCommand->FetchUInt32(6, pData->nLoyalty[KARUS_ARRAY]);
+
+		// Copy strings into struct
+		pData->strUserID[ELMORAD_ARRAY] = strElmoUserID;
+		pData->strUserID[KARUS_ARRAY] = strKarusUserID;
+
+		// Convert keys to uppercase for case insensitive lookups
+		STRTOUPPER(strElmoUserID);
+		STRTOUPPER(strKarusUserID);
+
+		// We're not going to insert either of them, so ignore this row and avoid a mem leak.
+		if (strElmoUserID.empty() && strKarusUserID.empty())
+		{
+			delete pData;
+			return true; // this is normal.
+		}
+
+		InsertToMap(strKarusUserID, strElmoUserID, pData);
+		return true;
+	}
+
+	virtual void InsertToMap(std::string & strKarusUserID, std::string & strElmoUserID, _USER_RANK * pData) 
+	{
+		if (!strElmoUserID.empty())
+		{
+			m_pMap->insert(make_pair(strElmoUserID, pData));
+			g_pMain->m_playerPersonalRankings[ELMORAD_ARRAY].insert(std::make_pair((uint8)pData->nRank, pData));
+		}
+		if (!strKarusUserID.empty())
+		{
+			m_pMap->insert(make_pair(strKarusUserID, pData));
+			g_pMain->m_playerPersonalRankings[KARUS_ARRAY].insert(std::make_pair((uint8)pData->nRank, pData));
+		}
+	}
+
+	UserNameRankMap *m_pMap;
+};

server/shared/database/ZoneInfoSet.h

@@ -0,0 +1,57 @@
+#pragma once
+
+typedef std::map<uint16, _ZONE_INFO *> ZoneInfoMap;
+
+class CZoneInfoSet : public OdbcRecordset
+{
+public:
+	CZoneInfoSet(OdbcConnection * dbConnection, ZoneInfoMap * pMap) 
+		: OdbcRecordset(dbConnection), m_pMap(pMap) {}
+
+	virtual tstring GetTableName() { return _T("ZONE_INFO"); }
+
+#if defined(AI_SERVER)
+	virtual tstring GetColumns() { return _T("ServerNo, ZoneNo, strZoneName, RoomEvent"); }
+#else
+	virtual tstring GetColumns() { return _T("ServerNo, ZoneNo, strZoneName, InitX, InitZ, InitY"); }
+#endif
+
+	virtual bool Fetch()
+	{
+		_ZONE_INFO * pData = new _ZONE_INFO;
+
+		int i = 1;
+		_dbCommand->FetchUInt16(i++, pData->m_nServerNo);
+		_dbCommand->FetchUInt16(i++, pData->m_nZoneNumber);
+		_dbCommand->FetchString(i++, pData->m_MapName);
+
+#ifdef AI_SERVER
+		_dbCommand->FetchByte(i++, pData->m_byRoomEvent);
+#else
+		uint32 iX = 0, iY = 0, iZ = 0;
+		_dbCommand->FetchUInt32(i++, iX);
+		_dbCommand->FetchUInt32(i++, iZ);
+		_dbCommand->FetchUInt32(i++, iY);
+
+		pData->m_fInitX = (float)(iX / 100.0f);
+		pData->m_fInitY = (float)(iY / 100.0f);
+		pData->m_fInitZ = (float)(iZ / 100.0f);
+#endif
+
+		if (pData->m_nZoneNumber > MAX_ZONE_ID)
+		{
+			printf("ERROR: Zone ID %d is too large. Highest zone ID can be %d.\n", pData->m_nZoneNumber, MAX_ZONE_ID);
+			delete pData;
+			return false;
+		}
+
+		if (m_pMap->find(pData->m_nZoneNumber) != m_pMap->end())
+			delete pData;
+		else
+			m_pMap->insert(std::make_pair(pData->m_nZoneNumber, pData));
+
+		return true;
+	}
+
+	ZoneInfoMap * m_pMap;
+};

server/shared/database/stdafx.cpp

@@ -0,0 +1 @@
+#include "stdafx.h"

server/shared/database/stdafx.h

@@ -0,0 +1,3 @@
+#pragma once
+
+#include "../stdafx.h"

server/shared/database/structs.h

@@ -0,0 +1,388 @@
+#pragma once
+
+struct _MAGIC_TABLE
+{
+	uint32	iNum;
+	uint32	nBeforeAction;
+	uint8	bTargetAction;
+	uint8	bSelfEffect;
+	uint16	bFlyingEffect;
+	uint16	iTargetEffect;
+	uint8	bMoral;
+	uint16	sSkillLevel;	
+	uint16	sSkill;
+	uint16	sMsp;
+	uint16	sHP;
+	uint8	bItemGroup;
+	uint32	iUseItem;
+	uint8	bCastTime;
+	uint16	sReCastTime;
+	uint8	bSuccessRate;
+	uint8	bType[2];
+	uint16	sRange;
+	uint8	sUseStanding;
+	uint16  sEtc;
+};
+
+struct _MAGIC_TYPE1
+{
+	uint32	iNum;
+	uint8	bHitType;
+	uint16	sHitRate;
+	uint16	sHit;
+	uint16	sAddDamage;
+	uint8	bDelay;
+	uint8	bComboType;
+	uint8	bComboCount;
+	uint16	sComboDamage;
+	uint16	sRange;
+};
+
+struct _MAGIC_TYPE2
+{
+	uint32	iNum;
+	uint8	bHitType;
+	uint16	sHitRate;
+	uint16	sAddDamage;
+	uint16	sAddRange;
+	uint8	bNeedArrow;
+};
+
+struct _MAGIC_TYPE3
+{
+	uint32	iNum;
+	uint8	bDirectType;
+	uint16	sAngle;
+	int16	sFirstDamage;
+	int16	sEndDamage;
+	int16	sTimeDamage;
+	uint8	bRadius;
+	uint8	bDuration;  // duration, in seconds
+	uint8	bAttribute;
+};
+
+struct _MAGIC_TYPE4
+{
+	uint32	iNum;
+	uint8	bBuffType;
+	uint8	bRadius;
+	uint16	sDuration;  // duration, in seconds
+	uint8	bAttackSpeed;
+	uint8	bSpeed;
+	int16	sAC;
+	uint16	sACPct;
+	uint8	bAttack;
+	uint8	bMagicAttack;
+	uint16	sMaxHP;
+	uint16	sMaxHPPct;
+	uint16	sMaxMP;
+	uint16	sMaxMPPct;
+	uint8	bHitRate;
+	uint16	sAvoidRate;
+	int8	bStr;
+	int8	bSta;
+	int8	bDex;
+	int8	bIntel;
+	int8	bCha;
+	uint8	bFireR;
+	uint8	bColdR;
+	uint8	bLightningR;
+	uint8	bMagicR;
+	uint8	bDiseaseR;
+	uint8	bPoisonR;
+	uint16	sExpPct;
+	uint16	sSpecialAmount;
+
+	bool	bIsBuff; // true if buff, false if debuff
+
+	INLINE bool isBuff() { return bIsBuff; }
+	INLINE bool isDebuff() { return !bIsBuff; }
+};
+
+struct _MAGIC_TYPE5
+{
+	uint32	iNum;
+	uint8	bType;
+	uint8	bExpRecover;
+	uint16	sNeedStone;
+};
+
+struct _MAGIC_TYPE6
+{
+	uint32	iNum;
+	uint16	sSize;
+	uint16	sTransformID;
+	uint16	sDuration; // duration, in seconds
+	uint16	sMaxHp;
+	uint16	sMaxMp;
+	uint8	bSpeed;
+	uint16	sAttackSpeed;
+	uint16	sTotalHit;
+	uint16	sTotalAc;
+	uint16	sTotalHitRate;
+	uint16	sTotalEvasionRate;
+	uint16	sTotalFireR;
+	uint16	sTotalColdR;
+	uint16	sTotalLightningR;
+	uint16	sTotalMagicR;
+	uint16	sTotalDiseaseR;
+	uint16	sTotalPoisonR;
+	uint16	sClass;
+	uint8	bUserSkillUse;
+	uint8	bNeedItem;
+	uint8	bSkillSuccessRate;
+	uint8	bMonsterFriendly;
+	uint8	bNation;
+};
+
+
+enum TransformationSkillUse
+{
+	TransformationSkillUseSiege		= 0,
+	TransformationSkillUseMonster	= 1,
+	TransformationSkillUseNPC		= 3,
+	TransformationSkillUseSpecial	= 4, // e.g. Snowman transformations
+	TransformationSkillUseSiege2	= 7  // e.g. Moving Towers
+};
+
+struct _MAGIC_TYPE7
+{
+	uint32	iNum;
+	uint8	bValidGroup;
+	uint8	bNationChange;
+	uint16	sMonsterNum;
+	uint8	bTargetChange;
+	uint8	bStateChange;
+	uint8	bRadius;
+	uint16	sHitRate;
+	uint16	sDuration;
+	uint16	sDamage;
+	uint8	bVision;
+	uint32	nNeedItem;
+};
+
+struct _MAGIC_TYPE8
+{
+	uint32	iNum;
+	uint8	bTarget;
+	uint16	sRadius;
+	uint8	bWarpType;
+	uint16	sExpRecover;
+	uint16	sKickDistance; // used exclusively by soccer ball-control skills.
+};
+
+struct _MAGIC_TYPE9
+{
+	uint32	iNum;
+	uint8	bValidGroup;
+	uint8	bNationChange;
+	uint16	sMonsterNum;
+	uint8	bTargetChange;
+	uint8	bStateChange;
+	uint16	sRadius;
+	uint16	sHitRate;
+	uint16	sDuration;
+	uint16	sDamage;
+	uint16	sVision;
+	uint32	nNeedItem;
+};
+
+struct _SERVER_RESOURCE
+{
+	uint32 nResourceID;
+	std::string strResource;
+};
+
+struct _OBJECT_EVENT
+{
+	int nIndex;
+	uint16 sZoneID;
+	int sBelong;
+	short sIndex;
+	short sType;
+	short sControlNpcID;
+	short sStatus;
+	float fPosX;
+	float fPosY;
+	float fPosZ;
+	uint8 byLife;
+	uint16 RoomEvent;
+};
+
+#pragma pack(push, 1)
+struct _REGENE_EVENT
+{
+	float fRegenePosX;
+	float fRegenePosY;
+	float fRegenePosZ;
+	float fRegeneAreaZ;
+	float fRegeneAreaX;
+	int	  sRegenePoint;
+};
+
+struct _WARP_INFO
+{
+	short	sWarpID;
+	char	strWarpName[32];
+	char	strAnnounce[256];
+	uint16	sUnk0; // padding?
+	uint32	dwPay;
+	short	sZone;
+	uint16	sUnk1; // padding?
+	float	fX;
+	float	fY;
+	float	fZ;
+	float	fR;
+	short	sNation;
+	uint16	sUnk2; // padding?
+
+	_WARP_INFO() { memset(this, 0, sizeof(_WARP_INFO)); };
+};
+#pragma pack(pop)
+
+struct _ZONE_INFO
+{
+	uint16	m_nServerNo;
+	uint16	m_nZoneNumber;
+	std::string	m_MapName;
+
+#if defined(AI_SERVER)
+	uint8	m_byRoomEvent;
+#else
+	float m_fInitX, m_fInitY, m_fInitZ;
+	uint8 m_bType, isAttackZone;
+#endif
+};
+
+struct _MONSTER_SUMMON_LIST
+{
+	uint16	sSid;
+	uint16	sLevel;
+	uint16	sProbability;
+	uint8	bType;
+};
+
+struct _MONSTER_SUMMON_LIST_ZONE
+{
+	uint32	nIndex;
+	uint16	ZoneID;
+	uint16	sSid;
+	uint8	byFamily;
+};
+
+struct _MONSTER_RESPAWN_LIST
+{
+	uint16	sIndex;
+	uint16	sSid;
+	uint16	sCount;
+};
+
+typedef std::map<uint16,std::string> RoomUserList;
+
+struct _CHAT_ROOM
+{
+	int nIndex;
+
+	std::string  strRoomName;
+	std::string  strAdministrator;
+	std::string  strPassword;
+
+	bool isPassword(){return STRCASECMP(strPassword.c_str(), "") != 0; };
+	uint8 isAdministrator(std::string strUserID){ return STRCASECMP(strAdministrator.c_str(), strUserID.c_str()) != 0 ? 1 : 2; };
+	
+	RoomUserList m_UserList;
+
+	uint16 m_sMaxUser;
+	uint16 m_sCurrentUser;
+
+	uint8 m_bRoomNation;
+
+	bool AddUser(std::string strUserID)
+	{
+		m_UserList.insert(std::make_pair(++m_sCurrentUser,strUserID));
+	
+		return true;
+	}
+};
+
+struct _MONSTER_RESPAWN_LIST_INFORMATION
+{
+	uint16 sIndex;
+	uint16 sSid;
+	uint8 ZoneID;
+	uint16 X;
+	uint16 Y;
+	uint16 Z;
+	uint16  sCount;
+	uint8 bRadius;
+};
+
+struct _MONSTER_RESPAWN_LIST_RANDOM
+{
+	uint16 sIndex;
+	uint16 sSid;
+	std::string strName;
+	uint16 sPid;
+	uint8 ZoneID;
+	uint8 isBoss;
+	uint8 Family;
+};
+
+struct _MINE_LIST
+{
+	uint32	nIndex;
+	uint32	Item;
+	uint16	Count;
+};
+
+#define MAX_PARTY_USERS		8
+struct	_PARTY_GROUP
+{
+	WORD	wIndex;
+	short	uid		[MAX_PARTY_USERS];
+
+#ifdef GAMESERVER
+	uint8	bItemRouting;
+	std::string	WantedMessage;
+	uint16	sWantedClass;
+#endif
+
+	_PARTY_GROUP()
+	{
+		for (int i = 0; i < MAX_PARTY_USERS; i++)
+			uid[i] = -1; 
+
+#ifdef GAMESERVER
+		bItemRouting = 0;
+#endif
+	}
+};
+
+struct _BUFF_TYPE4_INFO
+{
+	uint32	m_nSkillID;
+	uint8  m_bBuffType;
+	bool	m_bIsBuff; // Is it a buff or a debuff?
+	bool	m_bDurationExtended;
+	time_t	m_tEndTime;
+
+	INLINE bool isBuff() { return m_bIsBuff; }
+	INLINE bool isDebuff() { return !m_bIsBuff; }
+
+	_BUFF_TYPE4_INFO() 
+		: m_nSkillID(0), m_bBuffType(0), m_bIsBuff(false), m_bDurationExtended(false), m_tEndTime(0)
+	{
+	}
+};
+
+struct _BUFF_TYPE9_INFO
+{
+	uint32	nSkillID;
+	time_t	tEndTime;
+
+	_BUFF_TYPE9_INFO(uint32 nSkillID, time_t tEndTime)
+	{
+		this->nSkillID = nSkillID;
+		this->tEndTime = tEndTime;
+	}
+};