Metin2 Hungarian Forum

Már jó régen volt, hogy valamit is kiraktam, szóval gondoltam itt az újév, meg karácsony volt meg mindenféle, ezért csinálok pár reload bővítést. Korábban már a boltok reloadját megírtam, és úgy terveztem, hogy majd az mbc0r3-val kirakom, de mivel az még jó messze van, és már amúgy is keresték többen rajtam, gondoltam megosztom.


[spoiler]Nos a regenes résszel eléggé megszenvedtem, mivel elég sok hivatkozás volt egy-egy regenre, így nem volt egyszerű törölni őket, nem túlzok, ha legalább 50x előttem a core-t, mire előállt a végső megoldás.

Egyébként érdeklődnék, hogy miért van az, hogy ha visual studio-ban debugolom a coret, akkor a regen_free_map funkcióban "beakad", felpörög a proci ~ 40%-ra, és nem óhajt semmilyen hibát sem adni, de továbbhaladni sem.

De ne tessék megijedni! ugyanis ez csak abban az esetben áll fent, ha windowson debugolom a core-t, egyébként a proci meg sem mozdul, és nem okoz semmiféle kellemetlenséget.[/spoiler]

---

[spoiler=cmd.cpp]Add hozzá ezt valahova az elejére, ahol van a sok ACMD:ACMD(do_free_regen);

Majd ezt: { "free_regens", do_free_regen, 0, POS_DEAD, GM_IMPLEMENTOR }, e fölé: { "who", do_who, 0, POS_DEAD, GM_IMPLEMENTOR },[/spoiler]

[spoiler=cmd_gm.cpp]
Add hozzá ezt a legaljára:ACMD(do_free_regen)
{
ch->ChatPacket(CHAT_TYPE_INFO, "freeing regens on mapindex %ld", ch->GetMapIndex());
regen_free_map(ch->GetMapIndex());
ch->ChatPacket(CHAT_TYPE_INFO, "the regens now FREEEE! :)");
}

Cseréld le az ACMD(do_purge) funkciót erre:ACMD(do_purge)
{
char arg1[256];
one_argument(argument, arg1, sizeof(arg1));

FuncPurge func(ch);

if (*arg1 && !strcmp(arg1, "map"))
{
CHARACTER_MANAGER::instance().DestroyCharacterInMap(ch->GetMapIndex());
}
else
{
if (*arg1 && !strcmp(arg1, "all"))
func.m_bAll = true;
LPSECTREE sectree = ch->GetSectree();
if (sectree) // #431
sectree->ForEachAround(func);
else
sys_err("PURGE_ERROR.NULL_SECTREE(mapIndex=%d, pos=(%d, %d)", ch->GetMapIndex(), ch->GetX(), ch->GetY());
}
}

Az ACMD(do_reload) funkcióban ez alá: case 'c': // cube
// ·ÎÄĂ ÇÁ·ÎĽĽ˝ş¸¸ °»»ęÇŃ´Ů.
Cube_init ();
break;

Ezt illeszd be:
default:
const int FILE_NAME_LEN = 256;
if (strstr(arg1, "drop"))
{
char szETCDropItemFileName[FILE_NAME_LEN];
char szMOBDropItemFileName[FILE_NAME_LEN];
char szSpecialItemGroupFileName[FILE_NAME_LEN];

snprintf(szETCDropItemFileName, sizeof(szETCDropItemFileName),
"%s/etc_drop_item.txt", LocaleService_GetBasePath().c_str());
snprintf(szMOBDropItemFileName, sizeof(szMOBDropItemFileName),
"%s/mob_drop_item.txt", LocaleService_GetBasePath().c_str());
snprintf(szSpecialItemGroupFileName, sizeof(szSpecialItemGroupFileName),
"%s/special_item_group.txt", LocaleService_GetBasePath().c_str());

ch->ChatPacket(CHAT_TYPE_INFO, "Reloading: ETCDropItem: %s", szETCDropItemFileName);
if (!ITEM_MANAGER::instance().ReadEtcDropItemFile(szETCDropItemFileName, true))
ch->ChatPacket(CHAT_TYPE_INFO, "failed to reload ETCDropItem: %s", szETCDropItemFileName);
else
ch->ChatPacket(CHAT_TYPE_INFO, "reload success: ETCDropItem: %s", szETCDropItemFileName);

ch->ChatPacket(CHAT_TYPE_INFO, "Reloading: SpecialItemGroup: %s", szSpecialItemGroupFileName);
if (!ITEM_MANAGER::instance().ReadSpecialDropItemFile(szSpecialItemGroupFileName, true))
ch->ChatPacket(CHAT_TYPE_INFO, "failed to reload SpecialItemGroup: %s", szSpecialItemGroupFileName);
else
ch->ChatPacket(CHAT_TYPE_INFO, "reload success: SpecialItemGroup: %s", szSpecialItemGroupFileName);

ch->ChatPacket(CHAT_TYPE_INFO, "Reloading: MOBDropItemFile: %s", szMOBDropItemFileName);
if (!ITEM_MANAGER::instance().ReadMonsterDropItemGroup(szMOBDropItemFileName, true))
ch->ChatPacket(CHAT_TYPE_INFO, "failed to reload MOBDropItemFile: %s", szMOBDropItemFileName);
else
ch->ChatPacket(CHAT_TYPE_INFO, "reload success: MOBDropItemFile: %s", szMOBDropItemFileName);
}
else if (strstr(arg1, "group"))
{
char szGroupFileName[FILE_NAME_LEN];
char szGroupGroupFileName[FILE_NAME_LEN];

snprintf(szGroupFileName, sizeof(szGroupGroupFileName),
"%s/group.txt", LocaleService_GetBasePath().c_str());
snprintf(szGroupGroupFileName, sizeof(szGroupGroupFileName),
"%s/group_group.txt", LocaleService_GetBasePath().c_str());

ch->ChatPacket(CHAT_TYPE_INFO, "Reloading: mob groups: %s", szGroupFileName);
if (!CMobManager::instance().LoadGroup(szGroupFileName, true))
ch->ChatPacket(CHAT_TYPE_INFO, "failed to reload mob groups: %s", szGroupFileName);

ch->ChatPacket(CHAT_TYPE_INFO, "Reloading: mob group group: %s", szGroupGroupFileName);
if (!CMobManager::instance().LoadGroupGroup(szGroupGroupFileName, true))
ch->ChatPacket(CHAT_TYPE_INFO, "failed to reload mob group group: %s", szGroupGroupFileName);
}
else if (strstr(arg1, "regen"))
{
SendNoticeMap("Reloading regens!", ch->GetMapIndex(), false);
regen_free_map(ch->GetMapIndex());
CHARACTER_MANAGER::instance().DestroyCharacterInMap(ch->GetMapIndex());
regen_reload(ch->GetMapIndex());
SendNoticeMap("Regens reloaded!", ch->GetMapIndex(), false);
}
break;
[/spoiler]

[spoiler=input_db.cpp]
void CInputDB::ReloadProto(const char * c_pData)

E fölé: CMotionManager::instance().Build();

Ezt:
/*
* SHOP
*/

wSize = decode_2bytes(c_pData);
c_pData += sizeof(WORD);
sys_log(0, "RELOAD: SHOP: %d", wSize);


if (wSize)
{
CShopManager::instance().Initialize((TShopTable *)c_pData, wSize);
c_pData += wSize * sizeof(TShopTable);
}

/*
* REFINE
*/
wSize = decode_2bytes(c_pData);
c_pData += 2;
sys_log(0, "RELOAD: REFINE: %d", wSize);

if (wSize)
{
CRefineManager::instance().Initialize((TRefineTable *)c_pData, wSize);
c_pData += wSize * sizeof(TRefineTable);
}

/*
* ATTR
*/
wSize = decode_2bytes(c_pData);
c_pData += 2;
sys_log(0, "RELOAD: ItemAtt: %d", wSize);

if (wSize)
{
TItemAttrTable * p = (TItemAttrTable *)c_pData;
g_map_itemAttr.clear();
for (int i = 0; i < wSize; ++i, ++p)
{
if (p->dwApplyIndex >= MAX_APPLY_NUM)
continue;

g_map_itemAttr[p->dwApplyIndex] = *p;
sys_log(0, "ITEM_ATTR[%d]: %s %u", p->dwApplyIndex, p->szApply, p->dwProb);
}
c_pData += wSize*sizeof(TItemAttrTable);
}

/*
* ATTR_RARE
*/
wSize = decode_2bytes(c_pData);
c_pData += 2;
sys_log(0, "RELOAD: ItemRareAtt: %d", wSize);

if (wSize)
{
TItemAttrTable * p = (TItemAttrTable *)c_pData;
g_map_itemRare.clear();
for (int i = 0; i < wSize; ++i, ++p)
{
if (p->dwApplyIndex >= MAX_APPLY_NUM)
continue;

g_map_itemRare[p->dwApplyIndex] = *p;
sys_log(0, "ITEM_RARE[%d]: %s %u", p->dwApplyIndex, p->szApply, p->dwProb);
}
c_pData += wSize*sizeof(TItemAttrTable);
}
[/spoiler]

[spoiler=shop_manager.cpp]
bool CShopManager::Initialize(TShopTable * table, int size)

Ezt cseréljük le:
if (!m_map_pkShop.empty())
return false;

erre:
if (!m_map_pkShop.empty())
{
for (TShopMap::iterator it = m_map_pkShop.begin(); it != m_map_pkShop.end(); it++)
{
it->second->RemoveAllGuests();
}
}

m_map_pkShop.clear();
m_map_pkShopByNPCVnum.clear();
[/spoiler]

[spoiler=refine.cpp]
bool CRefineManager::Initialize(TRefineTable * table, int size)

Rögtön a funkció elejére (a for fölé) illesszük be ezt: m_map_RefineRecipe.clear();
[/spoiler]

[spoiler=char_manager.cpp]A fájl aljára illeszd be ezt:void CHARACTER_MANAGER::DestroyCharacterInMap(long lMapIndex)
{
std::vector<LPCHARACTER> tempVec;
for (itertype(m_map_pkChrByVID) it = m_map_pkChrByVID.begin(); it != m_map_pkChrByVID.end(); it++)
{
LPCHARACTER pkChr = it->second;
if (pkChr && pkChr->GetMapIndex() == lMapIndex && pkChr->IsNPC() && !pkChr->IsPet() && pkChr->GetRider() == NULL)
{
tempVec.push_back(pkChr);
}
}
for (std::vector<LPCHARACTER>::iterator it = tempVec.begin(); it != tempVec.end(); it++)
{
DestroyCharacter(*it);
}
}[/spoiler]

[spoiler=char_manager.h]E fölé:void Update(int iPulse);

Ezt:void DestroyCharacterInMap(long lMapIndex);[/spoiler]

[spoiler=item_manager.h]Ezeket cseréld le: bool ReadEtcDropItemFile(const char * c_pszFileName);
bool ReadMonsterDropItemGroup(const char * c_pszFileName);
bool ReadSpecialDropItemFile(const char * c_pszFileName);

Ezekre: bool ReadEtcDropItemFile(const char * c_pszFileName, bool isReloading = false);
bool ReadMonsterDropItemGroup(const char * c_pszFileName, bool isReloading = false);
bool ReadSpecialDropItemFile(const char * c_pszFileName, bool isReloading = false);[/spoiler]

[spoiler=item_manager_read_tables.cpp]Elsőnek ezt cseréljük le:bool ITEM_MANAGER::ReadEtcDropItemFile(const char * c_pszFileName)

Erre:bool ITEM_MANAGER::ReadEtcDropItemFile(const char * c_pszFileName, bool isReloading)

Majd ebben a funkcióban e fölé: char buf[512]

Adjuk ezt: std::map<DWORD, DWORD> tempLoader;
if (isReloading)
{
sys_log(0, "RELOADING EtcDrop");
}

Majd ezt cseréljük le:m_map_dwEtcItemDropProb[dwItemVnum] = (DWORD) (fProb * 10000.0f);

Erre: if (isReloading)
tempLoader[dwItemVnum] = (DWORD)(fProb * 10000.0f);
else
m_map_dwEtcItemDropProb[dwItemVnum] = (DWORD) (fProb * 10000.0f);

Végül a funkció legalján lévő return true; fölé ezt: if (isReloading)
{
m_map_dwEtcItemDropProb.clear();
for (std::map<DWORD, DWORD>::iterator it = tempLoader.begin(); it != tempLoader.end(); it++)
{
m_map_dwEtcItemDropProb[it->first] = it->second;
}
}


Ezután ezt cseréljük le:bool ITEM_MANAGER::ReadSpecialDropItemFile(const char * c_pszFileName)

Erre:bool ITEM_MANAGER::ReadSpecialDropItemFile(const char * c_pszFileName, bool isReloading)

Majd ebben a funkcióba a legelső for ciklus elé tegyük be ezeket: std::map<DWORD, CSpecialAttrGroup*> tempSpecAttr;
std::map<DWORD, CSpecialItemGroup*> tempSpecItem;
std::map<DWORD, CSpecialItemGroup*> tempSpecItemQuest;
if (isReloading)
sys_log(0, "RELOADING SpecialDrop");

Utána ezt cseréljük le:m_map_pkSpecialAttrGroup.insert(std::make_pair(iVnum, pkGroup));

Erre: if (isReloading)
tempSpecAttr.insert(std::make_pair(iVnum, pkGroup));
else
m_map_pkSpecialAttrGroup.insert(std::make_pair(iVnum, pkGroup));

Utána ezt: if (CSpecialItemGroup::QUEST == type)
{
m_map_pkQuestItemGroup.insert(std::make_pair(iVnum, pkGroup));
}
else
{
m_map_pkSpecialItemGroup.insert(std::make_pair(iVnum, pkGroup));
}

Erre: if (CSpecialItemGroup::QUEST == type)
{
if (isReloading)
tempSpecItemQuest.insert(std::make_pair(iVnum, pkGroup));
else
m_map_pkQuestItemGroup.insert(std::make_pair(iVnum, pkGroup));
}
else
{
if (isReloading)
tempSpecItem.insert(std::make_pair(iVnum, pkGroup));
else
m_map_pkSpecialItemGroup.insert(std::make_pair(iVnum, pkGroup));
}

Utána a funkció legalján a return true; elé írjuk be ezt: if (isReloading)
{
m_map_pkQuestItemGroup.clear();
m_map_pkSpecialItemGroup.clear();
m_map_pkSpecialAttrGroup.clear();

for (std::map<DWORD, CSpecialAttrGroup*>::iterator it = tempSpecAttr.begin(); it != tempSpecAttr.end(); it++)
{
m_map_pkSpecialAttrGroup[it->first] = it->second;
}

for (std::map<DWORD, CSpecialItemGroup*>::iterator it = tempSpecItem.begin(); it != tempSpecItem.end(); it++)
{
m_map_pkSpecialItemGroup[it->first] = it->second;
}

for (std::map<DWORD, CSpecialItemGroup*>::iterator it = tempSpecItemQuest.begin(); it != tempSpecItemQuest.end(); it++)
{
m_map_pkQuestItemGroup[it->first] = it->second;
}
}


Ezután ezt cseréljük le:bool ITEM_MANAGER::ReadMonsterDropItemGroup(const char * c_pszFileName)

Erre:bool ITEM_MANAGER::ReadMonsterDropItemGroup(const char * c_pszFileName, bool isReloading)

Majd mint az előzőknél, itt is a funkción belül az első for elé illesszük be ezt: std::map<DWORD, CMobItemGroup*> temMobItemGr;
std::map<DWORD, CDropItemGroup*> tempDropItemGr;
std::map<DWORD, CLevelItemGroup*> tempLevelItemGr;
std::map<DWORD, CBuyerThiefGlovesItemGroup*> tempThiefGlovesGr;
if (isReloading)
{
sys_log(0, "RELOADING MonsterDrop");
}

Ezt cseréljük le:m_map_pkMobItemGroup.insert(std::map<DWORD, CMobItemGroup*>::value_type(iMobVnum, pkGroup));

Erre: if (isReloading)
temMobItemGr.insert(std::map<DWORD, CMobItemGroup*>::value_type(iMobVnum, pkGroup));
else
m_map_pkMobItemGroup.insert(std::map<DWORD, CMobItemGroup*>::value_type(iMobVnum, pkGroup));

Ezt: itertype(m_map_pkDropItemGroup) it = m_map_pkDropItemGroup.find(iMobVnum);
if (it == m_map_pkDropItemGroup.end())
{
pkGroup = M2_NEW CDropItemGroup(0, iMobVnum, stName);
}
else
{
bNew = false;
CDropItemGroup* pkGroup = it->second;
}

Erre: if (isReloading)
{
itertype(tempDropItemGr) it = tempDropItemGr.find(iMobVnum);
if (it == tempDropItemGr.end())
{
pkGroup = M2_NEW CDropItemGroup(0, iMobVnum, stName);
}
else
{
bNew = false;
CDropItemGroup* pkGroup = it->second;
}
}
else
{
itertype(m_map_pkDropItemGroup) it = m_map_pkDropItemGroup.find(iMobVnum);
if (it == m_map_pkDropItemGroup.end())
{
pkGroup = M2_NEW CDropItemGroup(0, iMobVnum, stName);
}
else
{
bNew = false;
CDropItemGroup* pkGroup = it->second;
}
}

Ezt: if (bNew)
m_map_pkDropItemGroup.insert(std::map<DWORD, CDropItemGroup*>::value_type(iMobVnum, pkGroup));

Erre: if (bNew)
{
if (isReloading)
tempDropItemGr.insert(std::map<DWORD, CDropItemGroup*>::value_type(iMobVnum, pkGroup));
else
m_map_pkDropItemGroup.insert(std::map<DWORD, CDropItemGroup*>::value_type(iMobVnum, pkGroup));
}

Ezt:m_map_pkLevelItemGroup.insert(std::map<DWORD, CLevelItemGroup*>::value_type(iMobVnum, pkLevelItemGroup));

Erre: if (isReloading)
tempLevelItemGr.insert(std::map<DWORD, CLevelItemGroup*>::value_type(iMobVnum, pkLevelItemGroup));
else
m_map_pkLevelItemGroup.insert(std::map<DWORD, CLevelItemGroup*>::value_type(iMobVnum, pkLevelItemGroup));

Ezt:m_map_pkGloveItemGroup.insert(std::map<DWORD, CBuyerThiefGlovesItemGroup*>::value_type(iMobVnum, pkGroup));

Erre: if (isReloading)
tempThiefGlovesGr.insert(std::map<DWORD, CBuyerThiefGlovesItemGroup*>::value_type(iMobVnum, pkGroup));
else
m_map_pkGloveItemGroup.insert(std::map<DWORD, CBuyerThiefGlovesItemGroup*>::value_type(iMobVnum, pkGroup));

Majd a funkció aljára a return true; fölé ezt: if (isReloading)
{
for (std::map<DWORD, CBuyerThiefGlovesItemGroup*>::iterator it = m_map_pkGloveItemGroup.begin(); it != m_map_pkGloveItemGroup.end(); it++)
M2_DELETE(it->second);
m_map_pkGloveItemGroup.clear();
for (std::map<DWORD, CLevelItemGroup*>::iterator it = m_map_pkLevelItemGroup.begin(); it != m_map_pkLevelItemGroup.end(); it++)
M2_DELETE(it->second);
m_map_pkLevelItemGroup.clear();
for (std::map<DWORD, CDropItemGroup*>::iterator it = m_map_pkDropItemGroup.begin(); it != m_map_pkDropItemGroup.end(); it++)
M2_DELETE(it->second);
m_map_pkDropItemGroup.clear();
for (std::map<DWORD, CMobItemGroup*>::iterator it = m_map_pkMobItemGroup.begin(); it != m_map_pkMobItemGroup.end(); it++)
M2_DELETE(it->second);
m_map_pkMobItemGroup.clear();

for (std::map<DWORD, CBuyerThiefGlovesItemGroup*>::iterator it = tempThiefGlovesGr.begin(); it != tempThiefGlovesGr.end(); it++)
{
m_map_pkGloveItemGroup[it->first] = it->second;
}

for (std::map<DWORD, CLevelItemGroup*>::iterator it = tempLevelItemGr.begin(); it != tempLevelItemGr.end(); it++)
{
m_map_pkLevelItemGroup[it->first] = it->second;
}

for (std::map<DWORD, CDropItemGroup*>::iterator it = tempDropItemGr.begin(); it != tempDropItemGr.end(); it++)
{
m_map_pkDropItemGroup[it->first] = it->second;
}

for (std::map<DWORD, CMobItemGroup*>::iterator it = temMobItemGr.begin(); it != temMobItemGr.end(); it++)
{
m_map_pkMobItemGroup[it->first] = it->second;
}
}[/spoiler]

És most következik a tutorial második része:

[spoiler=mob_manager.h]
Ezeket: bool LoadGroup(const char * c_pszFileName);
bool LoadGroupGroup(const char * c_pszFileName);

Erre: bool LoadGroup(const char * c_pszFileName, bool isReloading = false);
bool LoadGroupGroup(const char * c_pszFileName, bool isReloading = false);
[/spoiler]

[spoiler=mob_manager.cpp]
Ezt cseréljük le:bool CMobManager::LoadGroupGroup(const char * c_pszFileName)

Erre:bool CMobManager::LoadGroupGroup(const char * c_pszFileName, bool isReloading)

Majd a funkción belül az első for ciklus elé adjuk hozzá ezt: std::map<DWORD, CMobGroupGroup *> tempLoader;
if (isReloading)
sys_log(0, "RELOADING group group: %s", c_pszFileName);

Ezt: m_map_pkMobGroupGroup.insert(std::make_pair((DWORD)iVnum, pkGroup));

Erre: if (isReloading)
tempLoader.insert(std::make_pair((DWORD)iVnum, pkGroup));
else
m_map_pkMobGroupGroup.insert(std::make_pair((DWORD)iVnum, pkGroup));

Majd írjuk be ezt a funkció alján a return true; elé: if (isReloading)
{
for (std::map<DWORD, CMobGroupGroup *>::iterator it = m_map_pkMobGroupGroup.begin(); it != m_map_pkMobGroupGroup.end(); it++)
M2_DELETE(it->second);
m_map_pkMobGroupGroup.clear();
for (std::map<DWORD, CMobGroupGroup *>::iterator it = tempLoader.begin(); it != tempLoader.end(); it++)
{
m_map_pkMobGroupGroup[it->first] = it->second;
}
}


Ezután ezt cseréljük le:bool CMobManager::LoadGroup(const char * c_pszFileName)

Erre:bool CMobManager::LoadGroup(const char * c_pszFileName, bool isReloading)

Majd a funkción belül adjuk hozzá az első for elé ezt:
std::map<DWORD, CMobGroup *> tempLoader;
if (isReloading)
sys_log(0, "RELOADING groups: %s", c_pszFileName);

Majd ezt cseréljük le:m_map_pkMobGroup.insert(std::map<DWORD, CMobGroup *>::value_type(iVnum, pkGroup));

Erre: if (isReloading)
tempLoader.insert(std::map<DWORD, CMobGroup *>::value_type(iVnum, pkGroup));
else
m_map_pkMobGroup.insert(std::map<DWORD, CMobGroup *>::value_type(iVnum, pkGroup));

Legaljára a funkcióban a return true; elé ezt: if (isReloading)
{
for (std::map<DWORD, CMobGroup *>::iterator it = m_map_pkMobGroup.begin(); it != m_map_pkMobGroup.end(); it++)
M2_DELETE(it->second);
m_map_pkMobGroup.clear();
for (std::map<DWORD, CMobGroup *>::iterator it = tempLoader.begin(); it != tempLoader.end(); it++)
{
m_map_pkMobGroup[it->first] = it->second;
}
}
[/spoiler]

[spoiler=char.cpp]
void CHARACTER::Destroy()

Ezt cseréld le: if (m_pkRegen)
{
if (m_pkDungeon) {
// Dungeon regen may not be valid at this point
if (m_pkDungeon->IsValidRegen(m_pkRegen, regen_id_)) {
--m_pkRegen->count;
}
} else {
// Is this really safe?
--m_pkRegen->count;
}
m_pkRegen = NULL;
}

Erre: if (m_pkRegen)
{
if (m_pkDungeon) {
// Dungeon regen may not be valid at this point
if (m_pkDungeon->IsValidRegen(m_pkRegen, regen_id_)) {
--m_pkRegen->count;
}
} else {
// Is this really safe? NO IT ISNT! F*CK THAT SH!T!
if (is_valid_regen(m_pkRegen))
--m_pkRegen->count;
}
m_pkRegen = NULL;
}
[/spoiler]

[spoiler=sectree_manager.cpp]
int SECTREE_MANAGER::Build(const char * c_pszListFileName, const char* c_pszMapBasePath)

Másoljuk be ezt: snprintf(szFilename, sizeof(szFilename), "%s/%s/", c_pszMapBasePath, szMapName);
regen_register_map(szFilename, setting.iIndex, setting.iBaseX, setting.iBaseY);

Ez alá: snprintf(szFilename, sizeof(szFilename), "%s/%s/server_attr", c_pszMapBasePath, szMapName);
LoadAttribute(pkMapSectree, szFilename, setting);
[/spoiler]

[spoiler=regen.h]Másoljuk be ezeket:extern void regen_free_map(long lMapIndex);
extern void regen_reload(long lMapIndex);
extern void regen_register_map(const char * szBaseName, long lMapIndex, int base_x, int base_y);
extern bool is_valid_regen(LPREGEN currRegen);

Ez alá:extern bool regen_load(const char *filename, long lMapIndex, int base_x, int base_y);[/spoiler]

[spoiler=regen.cpp]Ez alá: LPREGEN_EXCEPTION regen_exception_list = NULL;

Másoljuk be ezt:typedef struct SMapDataContainer
{
char szBaseName[256];
int base_x;
int base_y;
}TMapDataContainer;

#define mbMapDataCType std::map<DWORD, TMapDataContainer*>
mbMapDataCType mbMapDataContainer;

A fájl aljára másoljuk be ezeket:bool is_valid_regen(LPREGEN currRegen)
{
LPREGEN regen;

for (regen = regen_list; regen; regen = regen->next)
{
if (regen == currRegen)
return true;
}
return false;
}

void regen_free_map(long lMapIndex)
{
LPREGEN regen, prev, next;

for (regen = regen_list; regen; regen = regen->next)
{
if (regen->lMapIndex != lMapIndex)
continue;
event_cancel(&regen->event);
REMOVE_FROM_TW_LIST(regen, regen_list, prev, next);
M2_DELETE(regen);
}
}

void regen_reload(long lMapIndex)
{
if (mbMapDataContainer.find(lMapIndex) == mbMapDataContainer.end())
return;

char szFilename[256];

snprintf(szFilename, sizeof(szFilename), "%sregen.txt", mbMapDataContainer[lMapIndex]->szBaseName);
regen_load(szFilename, lMapIndex, mbMapDataContainer[lMapIndex]->base_x, mbMapDataContainer[lMapIndex]->base_y);

snprintf(szFilename, sizeof(szFilename), "%snpc.txt", mbMapDataContainer[lMapIndex]->szBaseName);
regen_load(szFilename, lMapIndex, mbMapDataContainer[lMapIndex]->base_x, mbMapDataContainer[lMapIndex]->base_y);

snprintf(szFilename, sizeof(szFilename), "%sboss.txt", mbMapDataContainer[lMapIndex]->szBaseName);
regen_load(szFilename, lMapIndex, mbMapDataContainer[lMapIndex]->base_x, mbMapDataContainer[lMapIndex]->base_y);

snprintf(szFilename, sizeof(szFilename), "%sstone.txt", mbMapDataContainer[lMapIndex]->szBaseName);
regen_load(szFilename, lMapIndex, mbMapDataContainer[lMapIndex]->base_x, mbMapDataContainer[lMapIndex]->base_y);
}

void regen_register_map(const char * szBaseName, long lMapIndex, int base_x, int base_y)
{
TMapDataContainer* container = new TMapDataContainer;
memset(container->szBaseName, 0, sizeof(container->szBaseName));
#ifdef __FreeBSD__
strlcpy(container->szBaseName, szBaseName, sizeof(container->szBaseName) - 1);
#else
strncpy(container->szBaseName, szBaseName, sizeof(container->szBaseName) - 1);
#endif
container->base_x = base_x;
container->base_y = base_y;
mbMapDataContainer[lMapIndex] = container;
}

EVENTFUNC(regen_event)

Illeszd be ezt: if (!is_valid_regen(regen))
return 0;

Ez alá: LPREGEN regen = info->regen;
[/spoiler]

[spoiler=shop.h]
Írjuk be ezt: void RemoveAllGuests();

Ez alá: void RemoveGuest(LPCHARACTER ch);
[/spoiler]

[spoiler=shop.cpp]
Írjuk be ezt valahova a fájl aljára:void CShop::RemoveAllGuests()
{
if (m_map_guest.empty())
return;
for (GuestMapType::iterator it = m_map_guest.begin(); it != m_map_guest.end(); it++)
{
LPCHARACTER ch = it->first;
if (ch)
{
if (ch->GetDesc() && ch->GetShop() == this)
{
ch->SetShop(NULL);

TPacketGCShop pack;

pack.header = HEADER_GC_SHOP;
pack.subheader = SHOP_SUBHEADER_GC_END;
pack.size = sizeof(TPacketGCShop);

ch->GetDesc()->Packet(&pack, sizeof(pack));
}
}
}
m_map_guest.clear();
}
[/spoiler]

[spoiler=db/ClientManager.cpp]
void CClientManager::QUERY_RELOAD_PROTO()

Ezt cseréljük le: tmp->EncodeHeader(HEADER_DG_RELOAD_PROTO, 0,
sizeof(WORD) + sizeof(TSkillTable) * m_vec_skillTable.size() +
sizeof(WORD) + sizeof(TBanwordTable) * m_vec_banwordTable.size() +
sizeof(WORD) + sizeof(TItemTable) * m_vec_itemTable.size() +
sizeof(WORD) + sizeof(TMobTable) * m_vec_mobTable.size());

Erre: tmp->EncodeHeader(HEADER_DG_RELOAD_PROTO, 0,
sizeof(WORD) + sizeof(TSkillTable) * m_vec_skillTable.size() +
sizeof(WORD) + sizeof(TBanwordTable) * m_vec_banwordTable.size() +
sizeof(WORD) + sizeof(TItemTable) * m_vec_itemTable.size() +
sizeof(WORD) + sizeof(TMobTable) * m_vec_mobTable.size() +
sizeof(WORD) + sizeof(TShopTable) * m_iShopTableSize +
sizeof(WORD) + sizeof(TRefineTable)* m_iRefineTableSize +
sizeof(WORD) + sizeof(TItemAttrTable)*m_vec_itemAttrTable.size() +
sizeof(WORD) + sizeof(TItemAttrTable)*m_vec_itemRareTable.size());

Majd ez alá: tmp->EncodeWORD(m_vec_mobTable.size());
tmp->Encode(&m_vec_mobTable[0], sizeof(TMobTable) * m_vec_mobTable.size());

Ezt: tmp->EncodeWORD(m_iShopTableSize);
tmp->Encode(m_pShopTable, sizeof(TShopTable) * m_iShopTableSize);

tmp->EncodeWORD(m_iRefineTableSize);
tmp->Encode(m_pRefineTable, sizeof(TRefineTable) * m_iRefineTableSize);

tmp->EncodeWORD(m_vec_itemAttrTable.size());
tmp->Encode(&m_vec_itemAttrTable[0], sizeof(TItemAttrTable) * m_vec_itemAttrTable.size());

tmp->EncodeWORD(m_vec_itemRareTable.size());
tmp->Encode(&m_vec_itemRareTable[0], sizeof(TItemAttrTable) * m_vec_itemRareTable.size());
[/spoiler]

Mivel windowson fordítottam és teszteltem, esetlegesen előfordulhatnak fordítási problémák BSD-n, ebben az esetben tessék szólni. Valamint mivel jól láthatóan elég hosszú a leírás (~30k karakter) ezért előfordulhat olyan is, hogy valamit véletlenül kihagytam, ebben az esetben is tessék szólni. További szép estét.