Cevaplandı Ticaret Problemi - İlk 4 Slot

[theay]

ROHAN2 WORLD 1-120 TR TİPİ OFFICIAL YOHARA, BALATHOR VE AMON! 80. GÜNÜNDE! +10.000 ONLİNE! HİLE VE BOT %100 ENGELLİ HEMEN TIKLA!

Merhabalar videoda olduğu gibi envanterin sadece ilk 4 slotundaki eşyaları ticarete koyabiliyorum diğerlerini koyamıyorum
herhangi bir syserr yok client tarafında.
game tarafındada yok fakat syslog şu şekilde ;

[CODE title="syslog ch1"]Jun 4 20:36:57 :: CInputMain()::Exchange() SubHeader 0
Jun 4 20:36:57 :: CInputMain()::Exchange() SubHeader 1
Jun 4 20:36:57 :: EXCHANGE AddItem success Ruh Taşı pos(1, 0) 0
Jun 4 20:36:59 :: CInputMain()::Exchange() SubHeader 5
Jun 4 20:37:00 :: Test: ITEM_MOVE Ruh Taşı (window: 1, cell : 0) -> (window:1, cell 28) count 1
Jun 4 20:37:01 :: CInputMain()::Exchange() SubHeader 0
Jun 4 20:37:01 :: CInputMain()::Exchange() SubHeader 1
Jun 4 20:37:03 :: CInputMain()::Exchange() SubHeader 5
Jun 4 20:37:04 :: CInputMain()::Exchange() SubHeader 0
Jun 4 20:37:04 :: CInputMain()::Exchange() SubHeader 1
Jun 4 20:37:05 :: CInputMain()::Exchange() SubHeader 5
Jun 4 20:37:06 :: Test: ITEM_MOVE Kutsama Kağıdı (window: 1, cell : 5) -> (window:1, cell 0) count 1
Jun 4 20:37:07 :: CInputMain()::Exchange() SubHeader 0
Jun 4 20:37:07 :: CInputMain()::Exchange() SubHeader 1
Jun 4 20:37:07 :: EXCHANGE AddItem success Kutsama Kağıdı pos(1, 0) 0
Jun 4 20:37:08 :: CInputMain()::Exchange() SubHeader 1
Jun 4 20:37:09 :: CInputMain()::Exchange() SubHeader 5
Jun 4 20:37:10 :: Test: ITEM_MOVE Kutsama Kağıdı (window: 1, cell : 6) -> (window:1, cell 1) count 1
Jun 4 20:37:11 :: CInputMain()::Exchange() SubHeader 0
Jun 4 20:37:11 :: CInputMain()::Exchange() SubHeader 1
Jun 4 20:37:11 :: EXCHANGE AddItem success Kutsama Kağıdı pos(1, 1) 0
Jun 4 20:37:12 :: CInputMain()::Exchange() SubHeader 1
Jun 4 20:37:12 :: EXCHANGE AddItem success Büyülü Metal pos(1, 4) 1[/CODE]

 

[llJ3Luell]

Ticaret ekranı açıkken ekleniyor mu yoksa sadece eşyayı diğer kişinin üstüne sürükleyince mi oluyor?

 

[theay]

Ticaret ekranı açıkken ekleniyor mu yoksa sadece eşyayı diğer kişinin üstüne sürükleyince mi oluyor?

Sorun orada değil window kısmında slot pos belirlemiyor ticaret ekranı açıkken eşya ekleniyor fakat ilk 4 slotda ise eşya eklenebiliyor 5.slottan sonra eklenmiyor

 

[salihq]

input_main.cpp gonder

 

[theay]

input_main.cpp gonder

Sorunun kaynağını tespit etim. Switchbot sistemi deaktif ettiğimde problem ortadan kalkıyor.

[CODE lang="cpp" title="input_main.cpp"]#include "stdafx.h"
#incl#includestants.h"
#incl#includefig.h"
#incl#includels.h"
#incl#includec_client.h"
#incl#includec_manager.h"
#incl#includefer_manager.h"
#incl#includeket.h"
#incl#includetocol.h"
#incl#includer.h"
#incl#includer_manager.h"
#incl#includem.h"
#incl#includem_manager.h"
#incl#include.h"
#incl#includep.h"
#incl#includep_manager.h"
#incl#includeebox.h"
#incl#includeen.h"
#incl#includetle.h"
#incl#includehange.h"
#incl#includestmanager.h"
#incl#includefiler.h"
#incl#includesenger_manager.h"
#incl#includety.h"
#incl#include.h"
#incl#includeect.h"
#incl#includeld.h"
#incl#includeld_manager.h"
#incl#include.h"
#incl#includeword.h"
#incl#includeire_text_convert.h"
#incl#includeque_item.h"
#incl#includelding.h"
#incl#includeale_service.h"
#incl#includeh"
#incl#includem.h"
#incl#include.h"
#incl#includeion.h"
#incl#includevent.h"
#incl#includeale_service.h"
#incl#includekShield.h"
#incl#includeapManager.h"
#incl#includegonSoul.h"
#incl#includet_inventory_helper.h" // @fixme119
#incl#include../common/CommonDefines.h"

#incl#includeut.h"

#defi#defineLE_CHAT_COLOR_SYSTEM
#defi#defineLE_CHAT_LOGGING
#defi#defineLE_CHAT_SPAMLIMIT
#defi#defineLE_WHISPER_CHAT_SPAMLIMIT
#defi#defineLE_CHECK_GHOSTMODE
#ifde#ifdefLE_SWITCHBOT
#incl#include_switchbot.h"
#endi#endife#ifdefLE_DROP_ITEM_WORLDARD
#incl#includep_item.h"
#endi#endife#ifdefLE_CHAT_LOGGING
static char __escape_string[1024];
static char __escape_string2[1024];
#endi#endiftic int __deposit_limit()
{
return (1000*10000);
}

#ifde#ifdefND_TARGET_INFO__
void CInputMain::TargetInfoLoad(LPCHARACTER ch, const char* c_pData)
{
TPacketCGTargetInfoLoad* p = (TPacketCGTargetInfoLoad*)c_pData;
TPacketGCTargetInfo pInfo;
pInfo.header = HEADER_GC_TARGET_INFO;
static std::vector<LPITEM> s_vec_item;
s_vec_item.clear();
LPITEM pkInfoItem;
LPCHARACTER m_pkChrTarget = CHARACTER_MANAGER::instance().Find(p->dwVID);

if (m_pkChrTarget){
if (ITEM_MANAGER::instance().CreateDropItemVector(m_pkChrTarget, ch, s_vec_item) && (m_pkChrTarget->IsMonster() || m_pkChrTarget->IsStone()))
{
if (s_vec_item.size() == 0);
else if (s_vec_item.size() == 1)
{
pkInfoItem = s_vec_item[0];
pInfo.dwVID = m_pkChrTarget->GetVID();
pInfo.race = m_pkChrTarget->GetRaceNum();
pInfo.dwVnum = pkInfoItem->GetVnum();
pInfo.count = pkInfoItem->GetCount();
ch->GetDesc()->Packet(&pInfo, sizeof(TPacketGCTargetInfo));
}
else
{
int iItemIdx = s_vec_item.size() - 1;
while (iItemIdx >= 0)
{
pkInfoItem = s_vec_item[iItemIdx--];

if (!pkInfoItem)
{
sys_err("pkInfoItem null in vector idx %d", iItemIdx + 1);
continue;
}

pInfo.dwVID = m_pkChrTarget->GetVID();
pInfo.race = m_pkChrTarget->GetRaceNum();
pInfo.dwVnum = pkInfoItem->GetVnum();
pInfo.count = pkInfoItem->GetCount();
ch->GetDesc()->Packet(&pInfo, sizeof(TPacketGCTargetInfo));
}
}
}
}
}
#endi#endifid SendBlockChatInfo(LPCHARACTER ch, int sec)
{
if (sec <= 0)
{
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("SOHBETBLOKGMENGEL"));
return;
}

long hour = sec / 3600;
sec -= hour * 3600;

long min = (sec / 60);
sec -= min * 60;

char buf[128+1];

if (hour > 0 && min > 0)
snprintf(buf, sizeof(buf), LC_TEXT("Your chat is blocked for %d hours %d min and %d sec."), hour, min, sec);
else if (hour > 0 && min == 0)
snprintf(buf, sizeof(buf), LC_TEXT("Your chat is blocked for %d hours and %d sec."), hour, sec);
else if (hour == 0 && min > 0)
snprintf(buf, sizeof(buf), LC_TEXT("Your chat is blocked for %d min and %d sec."), min, sec);
else
snprintf(buf, sizeof(buf), LC_TEXT("Your chat is blocked for %d sec."), sec);

ch->ChatPacket(CHAT_TYPE_INFO, buf);
}

EVENTINFO(spam_event_info)
{
char host[MAX_HOST_LENGTH+1];

spam_event_info()
{
::memset( host, 0, MAX_HOST_LENGTH+1 );
}
};

typedef boost::unordered_map<std::string, std:air<unsigned int, LPEVENT> > spam_score_of_ip_t;
spam_score_of_ip_t spam_score_of_ip;

EVENTFUNC(block_chat_by_ip_event)
{
spam_event_info* info = dynamic_cast<spam_event_info*>( event->info );

if ( info == NULL )
{
sys_err( "block_chat_by_ip_event> <Factor> Null pointer" );
return 0;
}

const char * host = info->host;

spam_score_of_ip_t::iterator it = spam_score_of_ip.find(host);

if (it != spam_score_of_ip.end())
{
it->second.first = 0;
it->second.second = NULL;
}

return 0;
}

bool SpamBlockCheck(LPCHARACTER ch, const char* const buf, const size_t buflen)
{
if (ch->GetLevel() < g_iSpamBlockMaxLevel)
{
spam_score_of_ip_t::iterator it = spam_score_of_ip.find(ch->GetDesc()->GetHostName());

if (it == spam_score_of_ip.end())
{
spam_score_of_ip.insert(std::make_pair(ch->GetDesc()->GetHostName(), std::make_pair(0, (LPEVENT) NULL)));
it = spam_score_of_ip.find(ch->GetDesc()->GetHostName());
}

if (it->second.second)
{
SendBlockChatInfo(ch, event_time(it->second.second) / passes_per_sec);
return true;
}

unsigned int score;
const char * word = SpamManager::instance().GetSpamScore(buf, buflen, score);

it->second.first += score;

if (word)
sys_log(0, "SPAM_SCORE: %s text: %s score: %u total: %u word: %s", ch->GetName(), buf, score, it->second.first, word);

if (it->second.first >= g_uiSpamBlockScore)
{
spam_event_info* info = AllocEventInfo<spam_event_info>();
strlcpy(info->host, ch->GetDesc()->GetHostName(), sizeof(info->host));

it->second.second = event_create(block_chat_by_ip_event, info, PASSES_PER_SEC(g_uiSpamBlockDuration));
sys_log(0, "SPAM_IP: %s for %u seconds", info->host, g_uiSpamBlockDuration);

LogManager::instance().CharLog(ch, 0, "SPAM", word);

SendBlockChatInfo(ch, event_time(it->second.second) / passes_per_sec);

return true;
}
}

return false;
}

enum
{
TEXT_TAG_PLAIN,
TEXT_TAG_TAG, // ||
TEXT_TAG_COLOR, // |cffffffff
TEXT_TAG_HYPERLINK_START, // |H
TEXT_TAG_HYPERLINK_END, // |h ex) |Hitem:1234:1:1:1|h
TEXT_TAG_RESTORE_COLOR,
};

int GetTextTag(const char * src, int maxLen, int & tagLen, std::string & extraInfo)
{
tagLen = 1;

if (maxLen < 2 || *src != '|')
return TEXT_TAG_PLAIN;

const char * cur = ++src;

if (*cur == '|')
{
tagLen = 2;
return TEXT_TAG_TAG;
}
else if (*cur == 'c') // color |cffffffffblahblah|r
{
tagLen = 2;
return TEXT_TAG_COLOR;
}
else if (*cur == 'H')
{
tagLen = 2;
return TEXT_TAG_HYPERLINK_START;
}
else if (*cur == 'h') // end of hyperlink
{
tagLen = 2;
return TEXT_TAG_HYPERLINK_END;
}

return TEXT_TAG_PLAIN;
}

void GetTextTagInfo(const char * src, int src_len, int & hyperlinks, bool & colored)
{
colored = false;
hyperlinks = 0;

int len;
std::string extraInfo;

for (int i = 0; i < src_len
{
int tag = GetTextTag(&src, src_len - i, len, extraInfo);

if (tag == TEXT_TAG_HYPERLINK_START)
++hyperlinks;

if (tag == TEXT_TAG_COLOR)
colored = true;

i += len;
}
}

int ProcessTextTag(LPCHARACTER ch, const char * c_pszText, size_t len)
{






int hyperlinks;
bool colored;

GetTextTagInfo(c_pszText, len, hyperlinks, colored);

if (colored == true && hyperlinks == 0)
return 4;

#ifde#ifdefLE_NEWSTUFF
if (g_bDisablePrismNeed)
return 0;
#endi#endifint nPrismCount = ch->CountSpecifyItem(ITEM_PRISM);

if (nPrismCount < hyperlinks)
return 1;


if (!ch->GetMyShop())
{
ch->RemoveSpecifyItem(ITEM_PRISM, hyperlinks);
return 0;
} else
{
int sellingNumber = ch->GetMyShop()->GetNumberByVnum(ITEM_PRISM);
if(nPrismCount - sellingNumber < hyperlinks)
{
return 2;
} else
{
ch->RemoveSpecifyItem(ITEM_PRISM, hyperlinks);
return 0;
}
}

return 4;
}

int CInputMain::Whisper(LPCHARACTER ch, const char * data, size_t uiBytes)
{
const TPacketCGWhisper* pinfo = reinterpret_cast<const TPacketCGWhisper*>(data);

if (uiBytes < pinfo->wSize)
return -1;

int iExtraLen = pinfo->wSize - sizeof(TPacketCGWhisper);

if (iExtraLen < 0)
{
sys_err("invalid packet length (len %d size %u buffer %u)", iExtraLen, pinfo->wSize, uiBytes);
ch->GetDesc()->SetPhase(PHASE_CLOSE);
return -1;
}

#ifde#ifdefLE_WHISPER_CHAT_SPAMLIMIT
if (ch->IncreaseChatCounter() >= 10)
{
ch->GetDesc()->DelayedDisconnect(0);
return (iExtraLen);
}
#endi#endif if (ch->FindAffect(AFFECT_BLOCK_CHAT))
{
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("SOHBETBLOKGMENGEL"));
return (iExtraLen);
}

LPCHARACTER pkChr = CHARACTER_MANAGER::instance().FindPC(pinfo->szNameTo);

if (pkChr == ch)
return (iExtraLen);

LPDESC pkDesc = NULL;

BYTE bOpponentEmpire = 0;

if (test_server)
{
if (!pkChr)
sys_log(0, "Whisper to %s(%s) from %s", "Null", pinfo->szNameTo, ch->GetName());
else
sys_log(0, "Whisper to %s(%s) from %s", pkChr->GetName(), pinfo->szNameTo, ch->GetName());
}

if (ch->IsBlockMode(BLOCK_WHISPER))
{
if (ch->GetDesc())
{
TPacketGCWhisper pack;
pack.bHeader = HEADER_GC_WHISPER;
pack.bType = WHISPER_TYPE_SENDER_BLOCKED;
pack.wSize = sizeof(TPacketGCWhisper);
strlcpy(pack.szNameFrom, pinfo->szNameTo, sizeof(pack.szNameFrom));
ch->GetDesc()->Packet(&pack, sizeof(pack));
}
return iExtraLen;
}

if (!pkChr)
{
CCI * pkCCI = P2P_MANAGER::instance().Find(pinfo->szNameTo);

if (pkCCI)
{
pkDesc = pkCCI->pkDesc;
pkDesc->SetRelay(pinfo->szNameTo);
bOpponentEmpire = pkCCI->bEmpire;

if (test_server)
sys_log(0, "Whisper to %s from %s (Channel %d Mapindex %d)", "Null", ch->GetName(), pkCCI->bChannel, pkCCI->lMapIndex);
}
}
else
{
pkDesc = pkChr->GetDesc();
bOpponentEmpire = pkChr->GetEmpire();
}

if (!pkDesc)
{
if (ch->GetDesc())
{
TPacketGCWhisper pack;

pack.bHeader = HEADER_GC_WHISPER;
pack.bType = WHISPER_TYPE_NOT_EXIST;
pack.wSize = sizeof(TPacketGCWhisper);
strlcpy(pack.szNameFrom, pinfo->szNameTo, sizeof(pack.szNameFrom));
ch->GetDesc()->Packet(&pack, sizeof(TPacketGCWhisper));
sys_log(0, "WHISPER: no player");
}
}
else
{
if (ch->IsBlockMode(BLOCK_WHISPER))
{
if (ch->GetDesc())
{
TPacketGCWhisper pack;
pack.bHeader = HEADER_GC_WHISPER;
pack.bType = WHISPER_TYPE_SENDER_BLOCKED;
pack.wSize = sizeof(TPacketGCWhisper);
strlcpy(pack.szNameFrom, pinfo->szNameTo, sizeof(pack.szNameFrom));
ch->GetDesc()->Packet(&pack, sizeof(pack));
}
}
else if (pkChr && pkChr->IsBlockMode(BLOCK_WHISPER))
{
if (ch->GetDesc())
{
TPacketGCWhisper pack;
pack.bHeader = HEADER_GC_WHISPER;
pack.bType = WHISPER_TYPE_TARGET_BLOCKED;
pack.wSize = sizeof(TPacketGCWhisper);
strlcpy(pack.szNameFrom, pinfo->szNameTo, sizeof(pack.szNameFrom));
ch->GetDesc()->Packet(&pack, sizeof(pack));
}
}
else
{
BYTE bType = WHISPER_TYPE_NORMAL;

char buf[CHAT_MAX_LEN + 1];
strlcpy(buf, data + sizeof(TPacketCGWhisper), MIN(iExtraLen + 1, sizeof(buf)));
const size_t buflen = strlen(buf);

if (true == SpamBlockCheck(ch, buf, buflen))
{
if (!pkChr)
{
CCI * pkCCI = P2P_MANAGER::instance().Find(pinfo->szNameTo);

if (pkCCI)
{
pkDesc->SetRelay("");
}
}
return iExtraLen;
}

CBanwordManager::instance().ConvertString(buf, buflen);

if (g_bEmpireWhisper)
if (!ch->IsEquipUniqueGroup(UNIQUE_GROUP_RING_OF_LANGUAGE))
if (!(pkChr && pkChr->IsEquipUniqueGroup(UNIQUE_GROUP_RING_OF_LANGUAGE)))
if (bOpponentEmpire != ch->GetEmpire() && ch->GetEmpire() && bOpponentEmpire
&& ch->GetGMLevel() == GM_PLAYER && gm_get_level(pinfo->szNameTo) == GM_PLAYER)

{
if (!pkChr)
{

bType = ch->GetEmpire() << 4;
}
else
{
ConvertEmpireText(ch->GetEmpire(), buf, buflen, 10 + 2 * pkChr->GetSkillPower(SKILL_LANGUAGE1 + ch->GetEmpire() - 1));
}
}

int processReturn = ProcessTextTag(ch, buf, buflen);
if (0!=processReturn)
{
if (ch->GetDesc())
{
TItemTable * pTable = ITEM_MANAGER::instance().GetTable(ITEM_PRISM);

if (pTable)
{
char buf[128];
int len;
if (3==processReturn)
len = snprintf(buf, sizeof(buf), LC_TEXT("You can't use a private shop now."), pTable->szLocaleName);
else
len = snprintf(buf, sizeof(buf), LC_TEXT("%s is required."), pTable->szLocaleName);

if (len < 0 || len >= (int) sizeof(buf))
len = sizeof(buf) - 1;

++len;

TPacketGCWhisper pack;

pack.bHeader = HEADER_GC_WHISPER;
pack.bType = WHISPER_TYPE_ERROR;
pack.wSize = sizeof(TPacketGCWhisper) + len;
strlcpy(pack.szNameFrom, pinfo->szNameTo, sizeof(pack.szNameFrom));

ch->GetDesc()->BufferedPacket(&pack, sizeof(pack));
ch->GetDesc()->Packet(buf, len);

sys_log(0, "WHISPER: not enough %s: char: %s", pTable->szLocaleName, ch->GetName());
}
}


pkDesc->SetRelay("");
return (iExtraLen);
}

if (ch->IsGM())
bType = (bType & 0xF0) | WHISPER_TYPE_GM;

if (buflen > 0)
{
TPacketGCWhisper pack;

pack.bHeader = HEADER_GC_WHISPER;
pack.wSize = sizeof(TPacketGCWhisper) + buflen;
pack.bType = bType;
strlcpy(pack.szNameFrom, ch->GetName(), sizeof(pack.szNameFrom));



TEMP_BUFFER tmpbuf;

tmpbuf.write(&pack, sizeof(pack));
tmpbuf.write(buf, buflen);

pkDesc->Packet(tmpbuf.read_peek(), tmpbuf.size());

// @warme006
// sys_log(0, "WHISPER: %s -> %s : %s", ch->GetName(), pinfo->szNameTo, buf);
#ifde#ifdefLE_CHAT_LOGGING
if (ch->IsGM())
{
LogManager::instance().EscapeString(__escape_string, sizeof(__escape_string), buf, buflen);
LogManager::instance().EscapeString(__escape_string2, sizeof(__escape_string2), pinfo->szNameTo, sizeof(pack.szNameFrom));
LogManager::instance().ChatLog(ch->GetMapIndex(), ch->GetPlayerID(), ch->GetName(), 0, __escape_string2, "WHISPER", __escape_string, ch->GetDesc() ? ch->GetDesc()->GetHostName() : "");
}
#endi#endif }
}
}
if(pkDesc)
pkDesc->SetRelay("");

return (iExtraLen);
}

struct RawPacketToCharacterFunc
{
const void * m_buf;
int m_buf_len;

RawPacketToCharacterFunc(const void * buf, int buf_len) : m_buf(buf), m_buf_len(buf_len)
{
}

void operator () (LPCHARACTER c)
{
if (!c->GetDesc())
return;

c->GetDesc()->Packet(m_buf, m_buf_len);
}
};

struct FEmpireChatPacket
{
packet_chat& p;
const char* orig_msg;
int orig_len;
char converted_msg[CHAT_MAX_LEN+1];

BYTE bEmpire;
int iMapIndex;
int namelen;

FEmpireChatPacket(packet_chat& p, const char* chat_msg, int len, BYTE bEmpire, int iMapIndex, int iNameLen)
: p(p), orig_msg(chat_msg), orig_len(len), bEmpire(bEmpire), iMapIndex(iMapIndex), namelen(iNameLen)
{
memset( converted_msg, 0, sizeof(converted_msg) );
}

void operator () (LPDESC d)
{
if (!d->GetCharacter())
return;

if (d->GetCharacter()->GetMapIndex() != iMapIndex)
return;

d->BufferedPacket(&p, sizeof(packet_chat));

if (d->GetEmpire() == bEmpire ||
bEmpire == 0 ||
d->GetCharacter()->GetGMLevel() > GM_PLAYER ||
d->GetCharacter()->IsEquipUniqueGroup(UNIQUE_GROUP_RING_OF_LANGUAGE))
{
d->Packet(orig_msg, orig_len);
}
else
{

size_t len = strlcpy(converted_msg, orig_msg, sizeof(converted_msg));

if (len >= sizeof(converted_msg))
len = sizeof(converted_msg) - 1;

ConvertEmpireText(bEmpire, converted_msg + namelen, len - namelen, 10 + 2 * d->GetCharacter()->GetSkillPower(SKILL_LANGUAGE1 + bEmpire - 1));
d->Packet(converted_msg, orig_len);
}
}
};

struct FYmirChatPacket
{
packet_chat& packet;
const char* m_szChat;
size_t m_lenChat;
const char* m_szName;

int m_iMapIndex;
BYTE m_bEmpire;
bool m_ring;

char m_orig_msg[CHAT_MAX_LEN+1];
int m_len_orig_msg;
char m_conv_msg[CHAT_MAX_LEN+1];
int m_len_conv_msg;

FYmirChatPacket(packet_chat& p, const char* chat, size_t len_chat, const char* name, size_t len_name, int iMapIndex, BYTE empire, bool ring)
: packet(p),
m_szChat(chat), m_lenChat(len_chat),
m_szName(name),
m_iMapIndex(iMapIndex), m_bEmpire(empire),
m_ring(ring)
{
m_len_orig_msg = snprintf(m_orig_msg, sizeof(m_orig_msg), "%s : %s", m_szName, m_szChat) + 1;

if (m_len_orig_msg < 0 || m_len_orig_msg >= (int) sizeof(m_orig_msg))
m_len_orig_msg = sizeof(m_orig_msg) - 1;

m_len_conv_msg = snprintf(m_conv_msg, sizeof(m_conv_msg), "??? : %s", m_szChat) + 1;

if (m_len_conv_msg < 0 || m_len_conv_msg >= (int) sizeof(m_conv_msg))
m_len_conv_msg = sizeof(m_conv_msg) - 1;

ConvertEmpireText(m_bEmpire, m_conv_msg + 6, m_len_conv_msg - 6, 10);
}

void operator() (LPDESC d)
{
if (!d->GetCharacter())
return;

if (d->GetCharacter()->GetMapIndex() != m_iMapIndex)
return;

if (m_ring ||
d->GetEmpire() == m_bEmpire ||
d->GetCharacter()->GetGMLevel() > GM_PLAYER ||
d->GetCharacter()->IsEquipUniqueGroup(UNIQUE_GROUP_RING_OF_LANGUAGE))
{
packet.size = m_len_orig_msg + sizeof(TPacketGCChat);

d->BufferedPacket(&packet, sizeof(packet_chat));
d->Packet(m_orig_msg, m_len_orig_msg);
}
else
{
packet.size = m_len_conv_msg + sizeof(TPacketGCChat);

d->BufferedPacket(&packet, sizeof(packet_chat));
d->Packet(m_conv_msg, m_len_conv_msg);
}
}
};

int CInputMain::Chat(LPCHARACTER ch, const char * data, size_t uiBytes)
{
const TPacketCGChat* pinfo = reinterpret_cast<const TPacketCGChat*>(data);

if (uiBytes < pinfo->size)
return -1;

const int iExtraLen = pinfo->size - sizeof(TPacketCGChat);

if (iExtraLen < 0)
{
sys_err("invalid packet length (len %d size %u buffer %u)", iExtraLen, pinfo->size, uiBytes);
ch->GetDesc()->SetPhase(PHASE_CLOSE);
return -1;
}

char buf[CHAT_MAX_LEN - (CHARACTER_NAME_MAX_LEN + 3) + 1];
strlcpy(buf, data + sizeof(TPacketCGChat), MIN(iExtraLen + 1, sizeof(buf)));
const size_t buflen = strlen(buf);

if (buflen > 1 && *buf == '/')
{
interpret_command(ch, buf + 1, buflen - 1);
return iExtraLen;
}
#ifde#ifdefLE_CHAT_SPAMLIMIT
if (ch->IncreaseChatCounter() >= 4)
{
if (ch->GetChatCounter() == 10)
ch->GetDesc()->DelayedDisconnect(0);
return iExtraLen;
}
#else#elseif (ch->IncreaseChatCounter() >= 10)
{
if (ch->GetChatCounter() == 10)
{
sys_log(0, "CHAT_HACK: %s", ch->GetName());
ch->GetDesc()->DelayedDisconnect(5);
}

return iExtraLen;
}
#endi#endif const CAffect* pAffect = ch->FindAffect(AFFECT_BLOCK_CHAT);

if (pAffect != NULL)
{
SendBlockChatInfo(ch, pAffect->lDuration);
return iExtraLen;
}

if (true == SpamBlockCheck(ch, buf, buflen))
{
return iExtraLen;
}

// @fixme133 begin
CBanwordManager::instance().ConvertString(buf, buflen);

int processReturn = ProcessTextTag(ch, buf, buflen);
if (0!=processReturn)
{
const TItemTable* pTable = ITEM_MANAGER::instance().GetTable(ITEM_PRISM);

if (NULL != pTable)
{
if (3==processReturn)
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("You can't use a private shop now."), pTable->szLocaleName);
else
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("%s is required."), pTable->szLocaleName);

}

return iExtraLen;
}
// @fixme133 end

char chatbuf[CHAT_MAX_LEN + 1];
#ifde#ifdefLE_CHAT_COLOR_SYSTEM
static const char* colorbuf[] = {"|cFFffa200|H|h[Oyun Yetkilisi]|h|r", "|cFFff0000|H|h[Shinsoo]|h|r", "|cFFffc700|H|h[Chunjo]|h|r", "|cFF000bff|H|h[Jinno]|h|r"};
int len = snprintf(chatbuf, sizeof(chatbuf), "%s %s : %s", (ch->IsGM()?colorbuf[0]:colorbuf[MINMAX(0, ch->GetEmpire(), 3)]), ch->GetName(), buf);
#else#elseint len = snprintf(chatbuf, sizeof(chatbuf), "%s : %s", ch->GetName(), buf);
#endi#endifif (CHAT_TYPE_SHOUT == pinfo->type)
{
LogManager::instance().ShoutLog(g_bChannel, ch->GetEmpire(), chatbuf);
}

if (len < 0 || len >= (int) sizeof(chatbuf))
len = sizeof(chatbuf) - 1;

if (pinfo->type == CHAT_TYPE_SHOUT)
{
if (ch->GetLevel() < g_iShoutLimitLevel)
{
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("BAGIRMAENGEL"), g_iShoutLimitLevel);
return (iExtraLen);
}

if (thecore_heart->pulse - (int) ch->GetLastShoutPulse() < passes_per_sec * 15)
return (iExtraLen);

ch->SetLastShoutPulse(thecore_heart->pulse);

TPacketGGShout p;

p.bHeader = HEADER_GG_SHOUT;
p.bEmpire = ch->GetEmpire();
strlcpy(p.szText, chatbuf, sizeof(p.szText));

P2P_MANAGER::instance().Send(&p, sizeof(TPacketGGShout));

SendShout(chatbuf, ch->GetEmpire());

return (iExtraLen);
}

TPacketGCChat pack_chat;

pack_chat.header = HEADER_GC_CHAT;
pack_chat.size = sizeof(TPacketGCChat) + len;
pack_chat.type = pinfo->type;
pack_chat.id = ch->GetVID();

switch (pinfo->type)
{
case CHAT_TYPE_TALKING:
{
const DESC_MANAGER:ESC_SET & c_ref_set = DESC_MANAGER::instance().GetClientSet();

if (false)
{
std::for_each(c_ref_set.begin(), c_ref_set.end(),
FYmirChatPacket(pack_chat,
buf,
strlen(buf),
ch->GetName(),
strlen(ch->GetName()),
ch->GetMapIndex(),
ch->GetEmpire(),
ch->IsEquipUniqueGroup(UNIQUE_GROUP_RING_OF_LANGUAGE)));
}
else
{
std::for_each(c_ref_set.begin(), c_ref_set.end(),
FEmpireChatPacket(pack_chat,
chatbuf,
len,
(ch->GetGMLevel() > GM_PLAYER ||
ch->IsEquipUniqueGroup(UNIQUE_GROUP_RING_OF_LANGUAGE)) ? 0 : ch->GetEmpire(),
ch->GetMapIndex(), strlen(ch->GetName())));
#ifde#ifdefLE_CHAT_LOGGING
if (ch->IsGM())
{
LogManager::instance().EscapeString(__escape_string, sizeof(__escape_string), chatbuf, len);
LogManager::instance().ChatLog(ch->GetMapIndex(), ch->GetPlayerID(), ch->GetName(), 0, "", "NORMAL", __escape_string, ch->GetDesc() ? ch->GetDesc()->GetHostName() : "");
}
#endi#endif }
}
break;

case CHAT_TYPE_PARTY:
{
if (!ch->GetParty())
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("BUGRUPTADEGILSIN"));
else
{
TEMP_BUFFER tbuf;

tbuf.write(&pack_chat, sizeof(pack_chat));
tbuf.write(chatbuf, len);

RawPacketToCharacterFunc f(tbuf.read_peek(), tbuf.size());
ch->GetParty()->ForEachOnlineMember(f);
#ifde#ifdefLE_CHAT_LOGGING
if (ch->IsGM())
{
LogManager::instance().EscapeString(__escape_string, sizeof(__escape_string), chatbuf, len);
LogManager::instance().ChatLog(ch->GetMapIndex(), ch->GetPlayerID(), ch->GetName(), ch->GetParty()->GetLeaderPID(), "", "PARTY", __escape_string, ch->GetDesc() ? ch->GetDesc()->GetHostName() : "");
}
#endi#endif }
}
break;

case CHAT_TYPE_GUILD:
{
if (!ch->GetGuild())
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("LONCAYAKATILAMADIN"));
else
{
ch->GetGuild()->Chat(chatbuf);
#ifde#ifdefLE_CHAT_LOGGING
if (ch->IsGM())
{
LogManager::instance().EscapeString(__escape_string, sizeof(__escape_string), chatbuf, len);
LogManager::instance().ChatLog(ch->GetMapIndex(), ch->GetPlayerID(), ch->GetName(), ch->GetGuild()->GetID(), ch->GetGuild()->GetName(), "GUILD", __escape_string, ch->GetDesc() ? ch->GetDesc()->GetHostName() : "");
}
#endi#endif }
}
break;

default:
sys_err("Unknown chat type %d", pinfo->type);
break;
}

return (iExtraLen);
}

void CInputMain::ItemUse(LPCHARACTER ch, const char * data)
{
ch->UseItem(((struct command_item_use *) data)->Cell);
}

void CInputMain::ItemToItem(LPCHARACTER ch, const char * pcData)
{
TPacketCGItemUseToItem * p = (TPacketCGItemUseToItem *) pcData;
if (ch)
ch->UseItem(p->Cell, p->TargetCell);
}

void CInputMain::ItemDrop(LPCHARACTER ch, const char * data)
{
struct command_item_drop * pinfo = (struct command_item_drop *) data;

//MONARCH_LIMIT
//if (ch->IsMonarch())
// return;
//END_MONARCH_LIMIT
if (!ch)
return;


if (pinfo->gold > 0)
ch->DropGold(pinfo->gold);
else
ch->DropItem(pinfo->Cell);
}

void CInputMain::ItemDrop2(LPCHARACTER ch, const char * data)
{
//MONARCH_LIMIT
//if (ch->IsMonarch())
// return;
//END_MONARCH_LIMIT

TPacketCGItemDrop2 * pinfo = (TPacketCGItemDrop2 *) data;



if (!ch)
return;
if (pinfo->gold > 0)
ch->DropGold(pinfo->gold);
else
ch->DropItem(pinfo->Cell, pinfo->count);
}

void CInputMain::ItemMove(LPCHARACTER ch, const char * data)
{
struct command_item_move * pinfo = (struct command_item_move *) data;

if (ch)
ch->MoveItem(pinfo->Cell, pinfo->CellTo, pinfo->count);
}

void CInputMain::ItemPickup(LPCHARACTER ch, const char * data)
{
struct command_item_pickup * pinfo = (struct command_item_pickup*) data;
if (ch)
ch->PickupItem(pinfo->vid);
}

void CInputMain::QuickslotAdd(LPCHARACTER ch, const char * data)
{
struct command_quickslot_add * pinfo = (struct command_quickslot_add *) data;
ch->SetQuickslot(pinfo->pos, pinfo->slot);
}

void CInputMain::QuickslotDelete(LPCHARACTER ch, const char * data)
{
struct command_quickslot_del * pinfo = (struct command_quickslot_del *) data;
ch->DelQuickslot(pinfo->pos);
}

void CInputMain::QuickslotSwap(LPCHARACTER ch, const char * data)
{
struct command_quickslot_swap * pinfo = (struct command_quickslot_swap *) data;
ch->SwapQuickslot(pinfo->pos, pinfo->change_pos);
}

int CInputMain::Messenger(LPCHARACTER ch, const char* c_pData, size_t uiBytes)
{
TPacketCGMessenger* p = (TPacketCGMessenger*) c_pData;

if (uiBytes < sizeof(TPacketCGMessenger))
return -1;

c_pData += sizeof(TPacketCGMessenger);
uiBytes -= sizeof(TPacketCGMessenger);

switch (p->subheader)
{
case MESSENGER_SUBHEADER_CG_ADD_BY_VID:
{
if (uiBytes < sizeof(TPacketCGMessengerAddByVID))
return -1;

TPacketCGMessengerAddByVID * p2 = (TPacketCGMessengerAddByVID *) c_pData;
LPCHARACTER ch_companion = CHARACTER_MANAGER::instance().Find(p2->vid);

if (!ch_companion)
return sizeof(TPacketCGMessengerAddByVID);

if (ch->IsObserverMode())
return sizeof(TPacketCGMessengerAddByVID);

if (ch_companion->IsBlockMode(BLOCK_MESSENGER_INVITE))
{
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("OYUNCUDAVETIREDDETTI"));
return sizeof(TPacketCGMessengerAddByVID);
}

LPDESC d = ch_companion->GetDesc();

if (!d)
return sizeof(TPacketCGMessengerAddByVID);

if (ch->GetGMLevel() == GM_PLAYER && ch_companion->GetGMLevel() != GM_PLAYER)
{
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("GMEKLEYEMEZSINIZ"));
return sizeof(TPacketCGMessengerAddByVID);
}

if (ch->GetDesc() == d)
return sizeof(TPacketCGMessengerAddByVID);

MessengerManager::instance().RequestToAdd(ch, ch_companion);
//MessengerManager::instance().AddToList(ch->GetName(), ch_companion->GetName());
}
return sizeof(TPacketCGMessengerAddByVID);

case MESSENGER_SUBHEADER_CG_ADD_BY_NAME:
{
if (uiBytes < CHARACTER_NAME_MAX_LEN)
return -1;

char name[CHARACTER_NAME_MAX_LEN + 1];
strlcpy(name, c_pData, sizeof(name));

if (ch->GetGMLevel() == GM_PLAYER && gm_get_level(name) != GM_PLAYER)
{
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("GMEKLEYEMEZSINIZ"));
return CHARACTER_NAME_MAX_LEN;
}

LPCHARACTER tch = CHARACTER_MANAGER::instance().FindPC(name);

if (!tch)
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("%s OYUNDADEGIL"), name);
else
{
if (tch == ch)
return CHARACTER_NAME_MAX_LEN;

if (tch->IsBlockMode(BLOCK_MESSENGER_INVITE) == true)
{
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("OYUNCUDAVETIREDDETTI"));
}
else
{

MessengerManager::instance().RequestToAdd(ch, tch);
//MessengerManager::instance().AddToList(ch->GetName(), tch->GetName());
}
}
}
return CHARACTER_NAME_MAX_LEN;

case MESSENGER_SUBHEADER_CG_REMOVE:
{
if (uiBytes < CHARACTER_NAME_MAX_LEN)
return -1;

char char_name[CHARACTER_NAME_MAX_LEN + 1];
strlcpy(char_name, c_pData, sizeof(char_name));
MessengerManager::instance().RemoveFromList(ch->GetName(), char_name);
MessengerManager::instance().RemoveFromList(char_name, ch->GetName()); // @fixme183
}
return CHARACTER_NAME_MAX_LEN;

default:
sys_err("CInputMain::Messenger : Unknown subheader %d : %s", p->subheader, ch->GetName());
break;
}

return 0;
}

int CInputMain::Shop(LPCHARACTER ch, const char * data, size_t uiBytes)
{
TPacketCGShop * p = (TPacketCGShop *) data;

if (uiBytes < sizeof(TPacketCGShop))
return -1;

if (test_server)
sys_log(0, "CInputMain::Shop() ==> SubHeader %d", p->subheader);

const char * c_pData = data + sizeof(TPacketCGShop);
uiBytes -= sizeof(TPacketCGShop);

switch (p->subheader)
{
case SHOP_SUBHEADER_CG_END:
sys_log(1, "INPUT: %s SHOP: END", ch->GetName());
CShopManager::instance().StopShopping(ch);
return 0;

case SHOP_SUBHEADER_CG_BUY:
{
if (uiBytes < sizeof(BYTE) + sizeof(BYTE))
return -1;

BYTE bPos = *(c_pData + 1);
sys_log(1, "INPUT: %s SHOP: BUY %d", ch->GetName(), bPos);
CShopManager::instance().Buy(ch, bPos);
return (sizeof(BYTE) + sizeof(BYTE));
}

case SHOP_SUBHEADER_CG_SELL:
{
if (uiBytes < sizeof(BYTE))
return -1;

BYTE pos = *c_pData;

sys_log(0, "INPUT: %s SHOP: SELL", ch->GetName());
CShopManager::instance().Sell(ch, pos);
return sizeof(BYTE);
}

case SHOP_SUBHEADER_CG_SELL2:
{
const TPacketCGShopSell* p = reinterpret_cast<const TPacketCGShopSell*>(c_pData);

sys_log(0, "INPUT: %s SHOP: SELL2", ch->GetName());

CShopManager::instance().Sell(ch, p->wPos, p->wCount);
return sizeof(TPacketCGShopSell);
}

default:
sys_err("CInputMain::Shop : Unknown subheader %d : %s", p->subheader, ch->GetName());
break;
}

return 0;
}

void CInputMain::OnClick(LPCHARACTER ch, const char * data)
{
struct command_on_click * pinfo = (struct command_on_click *) data;
LPCHARACTER victim;

if ((victim = CHARACTER_MANAGER::instance().Find(pinfo->vid)))
victim->OnClick(ch);
else if (test_server)
{
sys_err("CInputMain::OnClick %s.Click.NOT_EXIST_VID[%d]", ch->GetName(), pinfo->vid);
}
}

void CInputMain::Exchange(LPCHARACTER ch, const char * data)
{
struct command_exchange * pinfo = (struct command_exchange *) data;
LPCHARACTER to_ch = NULL;

if (!ch->CanHandleItem())
return;

int iPulse = thecore_pulse();

if ((to_ch = CHARACTER_MANAGER::instance().Find(pinfo->arg1)))
{
if (iPulse - to_ch->GetSafeboxLoadTime() < PASSES_PER_SEC(g_nPortalLimitTime))
{
to_ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("TICARETTENSONRA %d DEPOACAMAZSIN"), g_nPortalLimitTime);
return;
}

if( true == to_ch->IsDead() )
{
return;
}
}

sys_log(0, "CInputMain()::Exchange() SubHeader %d ", pinfo->sub_header);

if (iPulse - ch->GetSafeboxLoadTime() < PASSES_PER_SEC(g_nPortalLimitTime))
{
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("TICARETTENSONRA %d DEPOACAMAZSIN"), g_nPortalLimitTime);
return;
}


switch (pinfo->sub_header)
{
case EXCHANGE_SUBHEADER_CG_START: // arg1 == vid of target character
if (!ch->GetExchange())
{
if ((to_ch = CHARACTER_MANAGER::instance().Find(pinfo->arg1)))
{
//MONARCH_LIMIT

if (iPulse - ch->GetSafeboxLoadTime() < PASSES_PER_SEC(g_nPortalLimitTime))
{
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("TICARETTENSONRA %d DEPOACAMAZSIN"), g_nPortalLimitTime);

if (test_server)
ch->ChatPacket(CHAT_TYPE_INFO, "[TestOnly][Safebox]Pulse %d LoadTime %d PASS %d", iPulse, ch->GetSafeboxLoadTime(), PASSES_PER_SEC(g_nPortalLimitTime));
return;
}

if (iPulse - to_ch->GetSafeboxLoadTime() < PASSES_PER_SEC(g_nPortalLimitTime))
{
to_ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("TICARETTENSONRA %d DEPOACAMAZSIN"), g_nPortalLimitTime);


if (test_server)
to_ch->ChatPacket(CHAT_TYPE_INFO, "[TestOnly][Safebox]Pulse %d LoadTime %d PASS %d", iPulse, to_ch->GetSafeboxLoadTime(), PASSES_PER_SEC(g_nPortalLimitTime));
return;
}

if (ch->GetGold() >= GOLD_MAX)
{
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("2MILYONDANFAZLAYANGTASIRKENTICARETYAPAMAZSIN"));

sys_err("[OVERFLOG_GOLD] START (%u) id %u name %s ", ch->GetGold(), ch->GetPlayerID(), ch->GetName());
return;
}

if (to_ch->IsPC())
{
if (quest::CQuestManager::instance().GiveItemToPC(ch->GetPlayerID(), to_ch))
{
sys_log(0, "Exchange canceled by quest %s %s", ch->GetName(), to_ch->GetName());
return;
}
}


if (ch->GetMyShop() || ch->IsOpenSafebox() || ch->GetShopOwner() || ch->IsCubeOpen())
{
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("BASKASIYLATICYAPARKENOZELDEPOACAMAZSIN"));
return;
}

ch->ExchangeStart(to_ch);
}
}
break;

case EXCHANGE_SUBHEADER_CG_ITEM_ADD: // arg1 == position of item, arg2 == position in exchange window
if (ch->GetExchange())
{
if (ch->GetExchange()->GetCompany()->GetAcceptStatus() != true)
ch->GetExchange()->AddItem(pinfo->Pos, pinfo->arg2);
}
break;

case EXCHANGE_SUBHEADER_CG_ITEM_DEL: // arg1 == position of item
if (ch->GetExchange())
{
if (ch->GetExchange()->GetCompany()->GetAcceptStatus() != true)
ch->GetExchange()->RemoveItem(pinfo->arg1);
}
break;

#ifde#ifdefLE_YANG_LIMIT
case EXCHANGE_SUBHEADER_CG_ELK_ADD: // arg1 == amount of gold
if (ch->GetExchange())
{
const long long nTotalGold = static_cast<long long>(ch->GetExchange()->GetCompany()->GetOwner()->GetGold()) + static_cast<long long>(pinfo->arg1);

if (nTotalGold > GOLD_MAX)
{
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("TICKARSITARAF2MILYON"));
return;
}

if (ch->GetExchange()->GetCompany()->GetAcceptStatus() != true)
ch->GetExchange()->AddGold(pinfo->arg1);
}
break;
#else#else case EXCHANGE_SUBHEADER_CG_ELK_ADD: // arg1 == amount of gold
if (ch->GetExchange())
{
const int64_t nTotalGold = static_cast<int64_t>(ch->GetExchange()->GetCompany()->GetOwner()->GetGold()) + static_cast<int64_t>(pinfo->arg1);

if (GOLD_MAX <= nTotalGold)
{
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("TICKARSITARAF2MILYON"));
return;
}

if (ch->GetExchange()->GetCompany()->GetAcceptStatus() != true)
ch->GetExchange()->AddGold(pinfo->arg1);
}
break;
#endi#endif case EXCHANGE_SUBHEADER_CG_ACCEPT: // arg1 == not used
if (ch->GetExchange())
{
sys_log(0, "CInputMain()::Exchange() ==> ACCEPT ");
ch->GetExchange()->Accept(true);
}

break;

case EXCHANGE_SUBHEADER_CG_CANCEL: // arg1 == not used
if (ch->GetExchange())
ch->GetExchange()->Cancel();
break;
}
}

void CInputMain:osition(LPCHARACTER ch, const char * data)
{
struct command_position * pinfo = (struct command_position *) data;

switch (pinfo->position)
{
case POSITION_GENERAL:
ch->Standup();
break;

case POSITION_SITTING_CHAIR:
ch->Sitdown(0);
break;

case POSITION_SITTING_GROUND:
ch->Sitdown(1);
break;
}
}

static const int ComboSequenceBySkillLevel[3][8] =
{
// 0 1 2 3 4 5 6 7
{ 14, 15, 16, 17, 0, 0, 0, 0 },
{ 14, 15, 16, 18, 20, 0, 0, 0 },
{ 14, 15, 16, 18, 19, 17, 0, 0 },
};

#defi#defineO_HACK_ALLOWABLE_MS 100

bool CheckComboHack(LPCHARACTER ch, BYTE bArg, DWORD dwTime, bool CheckSpeedHack)
{
if(!gHackCheckEnable) return false;



// if (IsStun() || IsDead()) return false;




if (ch->IsStun() || ch->IsDead())
return false;
int ComboInterval = dwTime - ch->GetLastComboTime();
int HackScalar = 0;
#if 0#if sys_log(0, "COMBO: %s arg:%u seq:%u delta:%d checkspeedhack:%d",
ch->GetName(), bArg, ch->GetComboSequence(), ComboInterval - ch->GetValidComboInterval(), CheckSpeedHack);
#endi#endif if (bArg == 14)
{
if (CheckSpeedHack && ComboInterval > 0 && ComboInterval < ch->GetValidComboInterval() - COMBO_HACK_ALLOWABLE_MS)
{





//HackScalar = 1 + (ch->GetValidComboInterval() - ComboInterval) / 300;

//sys_log(0, "COMBO_HACK: 2 %s arg:%u interval:%d valid:%u atkspd:%u riding:%s",
// ch->GetName(),
// bArg,
// ComboInterval,
// ch->GetValidComboInterval(),
// ch->GetPoint(POINT_ATT_SPEED),
// ch->IsRiding() ? "yes" : "no");
}

ch->SetComboSequence(1);
ch->SetValidComboInterval((int) (ani_combo_speed(ch, 1) / (ch->GetPoint(POINT_ATT_SPEED) / 100.f)));
ch->SetLastComboTime(dwTime);
}
else if (bArg > 14 && bArg < 22)
{
int idx = MIN(2, ch->GetComboIndex());

if (ch->GetComboSequence() > 5)
{
HackScalar = 1;
ch->SetValidComboInterval(300);
sys_log(0, "COMBO_HACK: 5 %s combo_seq:%d", ch->GetName(), ch->GetComboSequence());
}

else if (bArg == 21 &&
idx == 2 &&
ch->GetComboSequence() == 5 &&
ch->GetJob() == JOB_ASSASSIN &&
ch->GetWear(WEAR_WEAPON) &&
ch->GetWear(WEAR_WEAPON)->GetSubType() == WEAPON_DAGGER)
ch->SetValidComboInterval(300);
#ifde#ifdefLE_WOLFMAN_CHARACTER
else if (bArg == 21 && idx == 2 && ch->GetComboSequence() == 5 && ch->GetJob() == JOB_WOLFMAN && ch->GetWear(WEAR_WEAPON) && ch->GetWear(WEAR_WEAPON)->GetSubType() == WEAPON_CLAW)
ch->SetValidComboInterval(300);
#endi#endif else if (ComboSequenceBySkillLevel[idx][ch->GetComboSequence()] != bArg)
{
HackScalar = 1;
ch->SetValidComboInterval(300);

sys_log(0, "COMBO_HACK: 3 %s arg:%u valid:%u combo_idx:%d combo_seq:%d",
ch->GetName(),
bArg,
ComboSequenceBySkillLevel[idx][ch->GetComboSequence()],
idx,
ch->GetComboSequence());
}
else
{
if (CheckSpeedHack && ComboInterval < ch->GetValidComboInterval() - COMBO_HACK_ALLOWABLE_MS)
{
HackScalar = 1 + (ch->GetValidComboInterval() - ComboInterval) / 100;

sys_log(0, "COMBO_HACK: 2 %s arg:%u interval:%d valid:%u atkspd:%u riding:%s",
ch->GetName(),
bArg,
ComboInterval,
ch->GetValidComboInterval(),
ch->GetPoint(POINT_ATT_SPEED),
ch->IsRiding() ? "yes" : "no");
}


//if (ch->IsHorseRiding())
if (ch->IsRiding())
ch->SetComboSequence(ch->GetComboSequence() == 1 ? 2 : 1);
else
ch->SetComboSequence(ch->GetComboSequence() + 1);

ch->SetValidComboInterval((int) (ani_combo_speed(ch, bArg - 13) / (ch->GetPoint(POINT_ATT_SPEED) / 100.f)));
ch->SetLastComboTime(dwTime);
}
}
else if (bArg == 13)
{
if (CheckSpeedHack && ComboInterval > 0 && ComboInterval < ch->GetValidComboInterval() - COMBO_HACK_ALLOWABLE_MS)
{



//HackScalar = 1 + (ch->GetValidComboInterval() - ComboInterval) / 100;

//sys_log(0, "COMBO_HACK: 6 %s arg:%u interval:%d valid:%u atkspd:%u",
// ch->GetName(),
// bArg,
// ComboInterval,
// ch->GetValidComboInterval(),
// ch->GetPoint(POINT_ATT_SPEED));
}

if (ch->GetRaceNum() >= MAIN_RACE_MAX_NUM)
{
// POLYMORPH_BUG_FIX

// DELETEME

float normalAttackDuration = CMotionManager::instance().GetNormalAttackDuration(ch->GetRaceNum());
int k = (int) (normalAttackDuration / ((float) ch->GetPoint(POINT_ATT_SPEED) / 100.f) * 900.f);
ch->SetValidComboInterval(k);
ch->SetLastComboTime(dwTime);
// END_OF_POLYMORPH_BUG_FIX
}
else
{

//if (ch->GetDesc()->DelayedDisconnect(number(2, 9)))
//{
// LogManager::instance().HackLog("Hacker", ch);
// sys_log(0, "HACKER: %s arg %u", ch->GetName(), bArg);
//}







//

//




// by rtsummit
}
}
else
{

if (ch->GetDesc()->DelayedDisconnect(number(2, 9)))
{
LogManager::instance().HackLog("Hacker", ch);
sys_log(0, "HACKER: %s arg %u", ch->GetName(), bArg);
}

HackScalar = 10;
ch->SetValidComboInterval(300);
}

if (HackScalar)
{

if (get_dword_time() - ch->GetLastMountTime() > 1500)
ch->IncreaseComboHackCount(1 + HackScalar);

ch->SkipComboAttackByTime(ch->GetValidComboInterval());
}

return HackScalar;


}

void CInputMain::Move(LPCHARACTER ch, const char * data)
{
if (!ch->CanMove())
return;

struct command_move * pinfo = (struct command_move *) data;

if (pinfo->bFunc >= FUNC_MAX_NUM && !(pinfo->bFunc & 0x80))
{
sys_err("invalid move type: %s", ch->GetName());
return;
}

//enum EMoveFuncType
//{
// FUNC_WAIT,
// FUNC_MOVE,
// FUNC_ATTACK,
// FUNC_COMBO,
// FUNC_MOB_SKILL,
// _FUNC_SKILL,
// FUNC_MAX_NUM,
// FUNC_SKILL = 0x80,
//};


{
// #defi#defineLE_TP_SPEED_CHECK
#ifde#ifdefLE_TP_SPEED_CHECK
const float fDist = DISTANCE_SQRT((ch->GetX() - pinfo->lX) / 100, (ch->GetY() - pinfo->lY) / 100);
if (((false == ch->IsRiding() && fDist > 25) || fDist > 60) && OXEVENT_MAP_INDEX != ch->GetMapIndex()) // @fixme106 (changed 40 to 60)
{
#ifde#ifdefLE_HACK_TELEPORT_LOG // @warme006
{
const PIXEL_POSITION & warpPos = ch->GetWarpPosition();

if (warpPos.x == 0 && warpPos.y == 0)
LogManager::instance().HackLog("Teleport", ch);
}
#endi#endif sys_log(0, "MOVE: %s trying to move too far (dist: %.1fm) Riding(%d)", ch->GetName(), fDist, ch->IsRiding());

ch->Show(ch->GetMapIndex(), ch->GetX(), ch->GetY(), ch->GetZ());
ch->Stop();
return;
}
#endi#endif #ifde#ifdefLE_CHECK_GHOSTMODE
if (ch->IsPC() && ch->IsDead())
{
sys_log(0, "MOVE: %s trying to move as dead", ch->GetName());

ch->Show(ch->GetMapIndex(), ch->GetX(), ch->GetY(), ch->GetZ());
ch->Stop();
return;
}
#endi#endif //
//
DWORD dwCurTime = get_dword_time();

bool CheckSpeedHack = (false == ch->GetDesc()->IsHandshaking() && dwCurTime - ch->GetDesc()->GetClientTime() > 7000);

if (CheckSpeedHack)
{
int iDelta = (int) (pinfo->dwTime - ch->GetDesc()->GetClientTime());
int iServerDelta = (int) (dwCurTime - ch->GetDesc()->GetClientTime());

iDelta = (int) (dwCurTime - pinfo->dwTime);


if (iDelta >= 30000)
{
sys_log(0, "SPEEDHACK: slow timer name %s delta %d", ch->GetName(), iDelta);
ch->GetDesc()->DelayedDisconnect(3);
}

else if (iDelta < -(iServerDelta / 50))
{
sys_log(0, "SPEEDHACK: DETECTED! %s (delta %d %d)", ch->GetName(), iDelta, iServerDelta);
ch->GetDesc()->DelayedDisconnect(3);
}
}

//

//
if (pinfo->bFunc == FUNC_COMBO && g_bCheckMultiHack)
{
CheckComboHack(ch, pinfo->bArg, pinfo->dwTime, CheckSpeedHack);
}
}

if (pinfo->bFunc == FUNC_MOVE)
{
if (ch->GetLimitPoint(POINT_MOV_SPEED) == 0)
return;

ch->SetRotation(pinfo->bRot * 5);
ch->ResetStopTime(); // ""

ch->Goto(pinfo->lX, pinfo->lY);
}
else
{
if (pinfo->bFunc == FUNC_ATTACK || pinfo->bFunc == FUNC_COMBO)
ch->OnMove(true);
else if (pinfo->bFunc & FUNC_SKILL)
{
const int MASK_SKILL_MOTION = 0x7F;
unsigned int motion = pinfo->bFunc & MASK_SKILL_MOTION;

if (!ch->IsUsableSkillMotion(motion))
{
const char* name = ch->GetName();
unsigned int job = ch->GetJob();
unsigned int group = ch->GetSkillGroup();

char szBuf[256];
snprintf(szBuf, sizeof(szBuf), "SKILL_HACK: name=%s, job=%d, group=%d, motion=%d", name, job, group, motion);
LogManager::instance().HackLog(szBuf, ch->GetDesc()->GetAccountTable().login, ch->GetName(), ch->GetDesc()->GetHostName());
sys_log(0, "%s", szBuf);

if (test_server)
{
ch->GetDesc()->DelayedDisconnect(number(2, 8));
ch->ChatPacket(CHAT_TYPE_INFO, szBuf);
}
else
{
ch->GetDesc()->DelayedDisconnect(number(150, 500));
}
}

ch->OnMove();
}

ch->SetRotation(pinfo->bRot * 5);
ch->ResetStopTime(); // ""

ch->Move(pinfo->lX, pinfo->lY);
ch->Stop();
ch->StopStaminaConsume();
}

TPacketGCMove pack;

pack.bHeader = HEADER_GC_MOVE;
pack.bFunc = pinfo->bFunc;
pack.bArg = pinfo->bArg;
pack.bRot = pinfo->bRot;
pack.dwVID = ch->GetVID();
pack.lX = pinfo->lX;
pack.lY = pinfo->lY;
pack.dwTime = pinfo->dwTime;
pack.dwDuration = (pinfo->bFunc == FUNC_MOVE) ? ch->GetCurrentMoveDuration() : 0;

ch->PacketAround(&pack, sizeof(TPacketGCMove), ch);

/*
sys_log(0,
"MOVE: %s Func:%u Arg:%u Pos:%dx%d Time:%u Dist:%.1f",
ch->GetName(),
pinfo->bFunc,
pinfo->bArg,
pinfo->lX / 100,
pinfo->lY / 100,
pinfo->dwTime,
fDist);
*/
}

void CInputMain::Attack(LPCHARACTER ch, const BYTE header, const char* data)
{
if (NULL == ch)
return;

struct type_identifier
{
BYTE header;
BYTE type;
};

const struct type_identifier* const type = reinterpret_cast<const struct type_identifier*>(data);

if (type->type > 0)
{
if (false == ch->CanUseSkill(type->type))
{
return;
}

switch (type->type)
{
case SKILL_GEOMPUNG:
case SKILL_SANGONG:
case SKILL_YEONSA:
case SKILL_KWANKYEOK:
case SKILL_HWAJO:
case SKILL_GIGUNG:
case SKILL_PABEOB:
case SKILL_MARYUNG:
case SKILL_TUSOK:
case SKILL_MAHWAN:
case SKILL_BIPABU:
case SKILL_NOEJEON:
case SKILL_CHAIN:
case SKILL_HORSE_WILDATTACK_RANGE:
if (HEADER_CG_SHOOT != type->header)
{
if (test_server)
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("Attack :name[%s] Vnum[%d] can't use skill by attack(warning)"), type->type);
return;
}
break;
}
}

switch (header)
{
case HEADER_CG_ATTACK:
{
if (NULL == ch->GetDesc())
return;

const TPacketCGAttack* const packMelee = reinterpret_cast<const TPacketCGAttack*>(data);

ch->GetDesc()->AssembleCRCMagicCube(packMelee->bCRCMagicCubeProcPiece, packMelee->bCRCMagicCubeFilePiece);

LPCHARACTER victim = CHARACTER_MANAGER::instance().Find(packMelee->dwVID);

if (NULL == victim || ch == victim)
return;

switch (victim->GetCharType())
{
case CHAR_TYPE_NPC:
case CHAR_TYPE_WARP:
case CHAR_TYPE_GOTO:
return;
}

if (packMelee->bType > 0)
{
if (false == ch->CheckSkillHitCount(packMelee->bType, victim->GetVID()))
{
return;
}
}

ch->Attack(victim, packMelee->bType);
}
break;

case HEADER_CG_SHOOT:
{
const TPacketCGShoot* const packShoot = reinterpret_cast<const TPacketCGShoot*>(data);

ch->Shoot(packShoot->bType);
}
break;
}
}

int CInputMain::SyncPosition(LPCHARACTER ch, const char * c_pcData, size_t uiBytes)
{
const TPacketCGSyncPosition* pinfo = reinterpret_cast<const TPacketCGSyncPosition*>( c_pcData );

if (uiBytes < pinfo->wSize)
return -1;

int iExtraLen = pinfo->wSize - sizeof(TPacketCGSyncPosition);

if (iExtraLen < 0)
{
sys_err("invalid packet length (len %d size %u buffer %u)", iExtraLen, pinfo->wSize, uiBytes);
ch->GetDesc()->SetPhase(PHASE_CLOSE);
return -1;
}

if (0 != (iExtraLen % sizeof(TPacketCGSyncPositionElement)))
{
sys_err("invalid packet length %d (name: %s)", pinfo->wSize, ch->GetName());
return iExtraLen;
}

int iCount = iExtraLen / sizeof(TPacketCGSyncPositionElement);

if (iCount <= 0)
return iExtraLen;

static const int nCountLimit = 16;

if( iCount > nCountLimit )
{
//LogManager::instance().HackLog( "SYNC_POSITION_HACK", ch );
sys_err( "Too many SyncPosition Count(%d) from Name(%s)", iCount, ch->GetName() );
//ch->GetDesc()->SetPhase(PHASE_CLOSE);
//return -1;
iCount = nCountLimit;
}

TEMP_BUFFER tbuf;
LPBUFFER lpBuf = tbuf.getptr();

TPacketGCSyncPosition * pHeader = (TPacketGCSyncPosition *) buffer_write_peek(lpBuf);
buffer_write_proceed(lpBuf, sizeof(TPacketGCSyncPosition));

const TPacketCGSyncPositionElement* e =
reinterpret_cast<const TPacketCGSyncPositionElement*>(c_pcData + sizeof(TPacketCGSyncPosition));

timeval tvCurTime;
gettimeofday(&tvCurTime, NULL);

for (int i = 0; i < iCount; ++i, ++e)
{
LPCHARACTER victim = CHARACTER_MANAGER::instance().Find(e->dwVID);

if (!victim)
continue;

switch (victim->GetCharType())
{
case CHAR_TYPE_NPC:
case CHAR_TYPE_WARP:
case CHAR_TYPE_GOTO:
continue;
}


if (!victim->SetSyncOwner(ch))
continue;

const float fDistWithSyncOwner = DISTANCE_SQRT( (victim->GetX() - ch->GetX()) / 100, (victim->GetY() - ch->GetY()) / 100 );
static const float fLimitDistWithSyncOwner = 2500.f + 1000.f;





if (fDistWithSyncOwner > fLimitDistWithSyncOwner)
{
if (ch->GetSyncHackCount() < g_iSyncHackLimitCount)
{
ch->SetSyncHackCount(ch->GetSyncHackCount() + 1);
continue;
}
else
{
LogManager::instance().HackLog( "SYNC_POSITION_HACK", ch );

sys_err( "Too far SyncPosition DistanceWithSyncOwner(%f)(%s) from Name(%s) CH(%d,%d) VICTIM(%d,%d) SYNC(%d,%d)",
fDistWithSyncOwner, victim->GetName(), ch->GetName(), ch->GetX(), ch->GetY(), victim->GetX(), victim->GetY(),
e->lX, e->lY );

ch->GetDesc()->SetPhase(PHASE_CLOSE);

return -1;
}
}

const float fDist = DISTANCE_SQRT( (victim->GetX() - e->lX) / 100, (victim->GetY() - e->lY) / 100 );
static const long g_lValidSyncInterval = 100 * 1000; // 100ms
const timeval &tvLastSyncTime = victim->GetLastSyncTime();
timeval *tvDiff = timediff(&tvCurTime, &tvLastSyncTime);



if (tvDiff->tv_sec == 0 && tvDiff->tv_usec < g_lValidSyncInterval)
{
if (ch->GetSyncHackCount() < g_iSyncHackLimitCount)
{
ch->SetSyncHackCount(ch->GetSyncHackCount() + 1);
continue;
}
else
{
LogManager::instance().HackLog( "SYNC_POSITION_HACK", ch );

sys_err( "Too often SyncPosition Interval(%ldms)(%s) from Name(%s) VICTIM(%d,%d) SYNC(%d,%d)",
tvDiff->tv_sec * 1000 + tvDiff->tv_usec / 1000, victim->GetName(), ch->GetName(), victim->GetX(), victim->GetY(),
e->lX, e->lY );

ch->GetDesc()->SetPhase(PHASE_CLOSE);

return -1;
}
}
else if( fDist > 25.0f )
{
LogManager::instance().HackLog( "SYNC_POSITION_HACK", ch );

sys_err( "Too far SyncPosition Distance(%f)(%s) from Name(%s) CH(%d,%d) VICTIM(%d,%d) SYNC(%d,%d)",
fDist, victim->GetName(), ch->GetName(), ch->GetX(), ch->GetY(), victim->GetX(), victim->GetY(),
e->lX, e->lY );

ch->GetDesc()->SetPhase(PHASE_CLOSE);

return -1;
}
else
{
victim->SetLastSyncTime(tvCurTime);
victim->Sync(e->lX, e->lY);
buffer_write(lpBuf, e, sizeof(TPacketCGSyncPositionElement));
}
}

if (buffer_size(lpBuf) != sizeof(TPacketGCSyncPosition))
{
pHeader->bHeader = HEADER_GC_SYNC_POSITION;
pHeader->wSize = buffer_size(lpBuf);

ch->PacketAround(buffer_read_peek(lpBuf), buffer_size(lpBuf), ch);
}

return iExtraLen;
}

void CInputMain::FlyTarget(LPCHARACTER ch, const char * pcData, BYTE bHeader)
{
TPacketCGFlyTargeting * p = (TPacketCGFlyTargeting *) pcData;
ch->FlyTarget(p->dwTargetVID, p->x, p->y, bHeader);
}

void CInputMain::UseSkill(LPCHARACTER ch, const char * pcData)
{
TPacketCGUseSkill * p = (TPacketCGUseSkill *) pcData;
ch->UseSkill(p->dwVnum, CHARACTER_MANAGER::instance().Find(p->dwVID));
}

void CInputMain::ScriptButton(LPCHARACTER ch, const void* c_pData)
{
TPacketCGScriptButton * p = (TPacketCGScriptButton *) c_pData;
sys_log(0, "QUEST ScriptButton pid %d idx %u", ch->GetPlayerID(), p->idx);

quest:C* pc = quest::CQuestManager::instance().GetPCForce(ch->GetPlayerID());
if (pc && pc->IsConfirmWait())
{
quest::CQuestManager::instance().Confirm(ch->GetPlayerID(), quest::CONFIRM_TIMEOUT);
}
else if (p->idx & 0x80000000)
{

quest::CQuestManager::Instance().QuestInfo(ch->GetPlayerID(), p->idx & 0x7fffffff);
}
else
{
quest::CQuestManager::Instance().QuestButton(ch->GetPlayerID(), p->idx);
}
}

void CInputMain::ScriptAnswer(LPCHARACTER ch, const void* c_pData)
{
TPacketCGScriptAnswer * p = (TPacketCGScriptAnswer *) c_pData;
sys_log(0, "QUEST ScriptAnswer pid %d answer %d", ch->GetPlayerID(), p->answer);

if (p->answer > 250)
{
quest::CQuestManager::Instance().Resume(ch->GetPlayerID());
}
else
{
quest::CQuestManager::Instance().Select(ch->GetPlayerID(), p->answer);
}
}


// SCRIPT_SELECT_ITEM
void CInputMain::ScriptSelectItem(LPCHARACTER ch, const void* c_pData)
{
TPacketCGScriptSelectItem* p = (TPacketCGScriptSelectItem*) c_pData;
sys_log(0, "QUEST ScriptSelectItem pid %d answer %d", ch->GetPlayerID(), p->selection);
quest::CQuestManager::Instance().SelectItem(ch->GetPlayerID(), p->selection);
}
// END_OF_SCRIPT_SELECT_ITEM

void CInputMain::QuestInputString(LPCHARACTER ch, const void* c_pData)
{
TPacketCGQuestInputString * p = (TPacketCGQuestInputString*) c_pData;

char msg[65];
strlcpy(msg, p->msg, sizeof(msg));
sys_log(0, "QUEST InputString pid %u msg %s", ch->GetPlayerID(), msg);

quest::CQuestManager::Instance().Input(ch->GetPlayerID(), msg);
}

void CInputMain::QuestConfirm(LPCHARACTER ch, const void* c_pData)
{
TPacketCGQuestConfirm* p = (TPacketCGQuestConfirm*) c_pData;
LPCHARACTER ch_wait = CHARACTER_MANAGER::instance().FindByPID(p->requestPID);
if (p->answer)
p->answer = quest::CONFIRM_YES;
sys_log(0, "QuestConfirm from %s pid %u name %s answer %d", ch->GetName(), p->requestPID, (ch_wait)?ch_wait->GetName():"", p->answer);
if (ch_wait)
{
quest::CQuestManager::Instance().Confirm(ch_wait->GetPlayerID(), (quest::EQuestConfirmType) p->answer, ch->GetPlayerID());
}
}

void CInputMain::Target(LPCHARACTER ch, const char * pcData)
{
TPacketCGTarget * p = (TPacketCGTarget *) pcData;

building::LPOBJECT pkObj = building::CManager::instance().FindObjectByVID(p->dwVID);

if (pkObj)
{
TPacketGCTarget pckTarget;
pckTarget.header = HEADER_GC_TARGET;
pckTarget.dwVID = p->dwVID;
ch->GetDesc()->Packet(&pckTarget, sizeof(TPacketGCTarget));
}
else
ch->SetTarget(CHARACTER_MANAGER::instance().Find(p->dwVID));
}

void CInputMain::Warp(LPCHARACTER ch, const char * pcData)
{
ch->WarpEnd();
}

void CInputMain::SafeboxCheckin(LPCHARACTER ch, const char * c_pData)
{
if (quest::CQuestManager::instance().GetPCForce(ch->GetPlayerID())->IsRunning() == true)
return;

TPacketCGSafeboxCheckin * p = (TPacketCGSafeboxCheckin *) c_pData;

if (!ch->CanHandleItem())
return;

CSafebox * pkSafebox = ch->GetSafebox();
LPITEM pkItem = ch->GetItem(p->ItemPos);

if (!pkSafebox || !pkItem)
return;

if (pkItem->GetCell() >= INVENTORY_MAX_NUM && IS_SET(pkItem->GetFlag(), ITEM_FLAG_IRREMOVABLE))
{
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("HATAZORLAMA"));
return;
}

if (!pkSafebox->IsEmpty(p->bSafePos, pkItem->GetSize()))
{
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("HAREKETYAPAMAMAZSIN"));
return;
}

if (pkItem->GetVnum() == UNIQUE_ITEM_SAFEBOX_EXPAND)
{
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ESYADEPOLANAMAZ"));
return;
}

if( IS_SET(pkItem->GetAntiFlag(), ITEM_ANTIFLAG_SAFEBOX) )
{
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ESYADEPOLANAMAZ"));
return;
}

if (true == pkItem->isLocked())
{
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ESYADEPOLANAMAZ"));
return;
}

#ifde#ifdefLE_WEAPON_COSTUME_SYSTEM
if (pkItem->IsEquipped())
{
int iWearCell = pkItem->FindEquipCell(ch);
if (iWearCell == WEAR_WEAPON)
{
LPITEM costumeWeapon = ch->GetWear(WEAR_COSTUME_WEAPON);
if (costumeWeapon && !ch->UnequipItem(costumeWeapon))
{
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("You cannot unequip the costume weapon. Not enough space."));
return;
}
}
}
#endi#endif // @fixme140 BEGIN
if (ITEM_BELT == pkItem->GetType() && CBeltInventoryHelper::IsExistItemInBeltInventory(ch))
{
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("kemerslot1"));
return;
}
// @fixme140 END

pkItem->RemoveFromCharacter();
if (!pkItem->IsDragonSoul())
ch->SyncQuickslot(QUICKSLOT_TYPE_ITEM, p->ItemPos.cell, 255);
pkSafebox->Add(p->bSafePos, pkItem);

char szHint[128];
snprintf(szHint, sizeof(szHint), "%s %u", pkItem->GetName(), pkItem->GetCount());
LogManager::instance().ItemLog(ch, pkItem, "SAFEBOX PUT", szHint);
}

void CInputMain::SafeboxCheckout(LPCHARACTER ch, const char * c_pData, bool bMall)
{
TPacketCGSafeboxCheckout * p = (TPacketCGSafeboxCheckout *) c_pData;

if (!ch->CanHandleItem())
return;

CSafebox * pkSafebox;

if (bMall)
pkSafebox = ch->GetMall();
else
pkSafebox = ch->GetSafebox();

if (!pkSafebox)
return;

LPITEM pkItem = pkSafebox->Get(p->bSafePos);

if (!pkItem)
return;

#if d#ifned(__SPECIAL_INVENTORY_SYSTEM__)
if (p->ItemPos.IsSkillBookInventoryPosition() && !pkItem->IsSkillBook())
{
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("You can only move skill books into this inventory."));
return;
}

if (p->ItemPos.IsUpgradeItemsInventoryPosition() && !pkItem->IsUpgradeItem())
{
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("You can only move upgrade items into this inventory."));
return;
}

if (p->ItemPos.IsStoneInventoryPosition() && !pkItem->IsStone())
{
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("You can only move stones into this inventory."));
return;
}

if (p->ItemPos.IsGiftBoxInventoryPosition() && !pkItem->IsGiftBox())
{
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("You can only move chests into this inventory."));
return;
}
#endi#endif if (!ch->IsEmptyItemGrid(p->ItemPos, pkItem->GetSize()))
return;


if (pkItem->IsDragonSoul())
{
if (bMall)
{
DSManager::instance().DragonSoulItemInitialize(pkItem);
}

if (DRAGON_SOUL_INVENTORY != p->ItemPos.window_type)
{
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("HAREKETYAPAMAMAZSIN"));
return;
}

TItemPos DestPos = p->ItemPos;
if (!DSManager::instance().IsValidCellForThisItem(pkItem, DestPos))
{
int iCell = ch->GetEmptyDragonSoulInventory(pkItem);
if (iCell < 0)
{
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("HAREKETYAPAMAMAZSIN"));
return ;
}
DestPos = TItemPos (DRAGON_SOUL_INVENTORY, iCell);
}

pkSafebox->Remove(p->bSafePos);
pkItem->AddToCharacter(ch, DestPos);
ITEM_MANAGER::instance().FlushDelayedSave(pkItem);
}
else
{
if (DRAGON_SOUL_INVENTORY == p->ItemPos.window_type)
{
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<Storages> No movement possible."));
return;
}
// @fixme119
if (p->ItemPos.IsBeltInventoryPosition() && false == CBeltInventoryHelper::CanMoveIntoBeltInventory(pkItem))
{
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("KEMERENVANTERINESADECEIKSIRKOYABILIRSIN"));
return;
}

pkSafebox->Remove(p->bSafePos);
pkItem->AddToCharacter(ch, p->ItemPos);
ITEM_MANAGER::instance().FlushDelayedSave(pkItem);
}

DWORD dwID = pkItem->GetID();
db_clientdesc->DBPacketHeader(HEADER_GD_ITEM_FLUSH, 0, sizeof(DWORD));
db_clientdesc->Packet(&dwID, sizeof(DWORD));

char szHint[128];
snprintf(szHint, sizeof(szHint), "%s %u", pkItem->GetName(), pkItem->GetCount());
if (bMall)
LogManager::instance().ItemLog(ch, pkItem, "MALL GET", szHint);
else
LogManager::instance().ItemLog(ch, pkItem, "SAFEBOX GET", szHint);
}

void CInputMain::SafeboxItemMove(LPCHARACTER ch, const char * data)
{
struct command_item_move * pinfo = (struct command_item_move *) data;

if (!ch->CanHandleItem())
return;

if (!ch->GetSafebox())
return;

ch->GetSafebox()->MoveItem(pinfo->Cell.cell, pinfo->CellTo.cell, pinfo->count);
}

// PARTY_JOIN_BUG_FIX
void CInputMain:artyInvite(LPCHARACTER ch, const char * c_pData)
{
#ifde#ifdef_FIXED
if (!ch)
return;
#endi#endifif (ch->GetArena())
{
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("BUNUARENADAKULLANAMAZSINHATA"));
return;
}

TPacketCGPartyInvite * p = (TPacketCGPartyInvite*) c_pData;

LPCHARACTER pInvitee = CHARACTER_MANAGER::instance().Find(p->vid);

#ifde#ifdef_FIXED
if (!pInvitee || !ch->GetDesc() || !pInvitee->GetDesc() || !pInvitee->IsPC() || !ch->IsPC())
#else#elseif (!pInvitee || !ch->GetDesc() || !pInvitee->GetDesc())
#endi#endif{
sys_err("PARTY Cannot find invited character");
return;
}

ch->PartyInvite(pInvitee);
}

void CInputMain:artyInviteAnswer(LPCHARACTER ch, const char * c_pData)
{
#ifde#ifdef_FIXED
if (!ch)
return;
#endi#endifif (ch->GetArena())
{
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("BUNUARENADAKULLANAMAZSINHATA"));
return;
}

TPacketCGPartyInviteAnswer * p = (TPacketCGPartyInviteAnswer*) c_pData;

LPCHARACTER pInviter = CHARACTER_MANAGER::instance().Find(p->leader_vid);

#ifde#ifdef_FIXED
if (!pInviter || !pInviter->IsPC())
#else#elseif (!pInviter)
#endi#endif ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("GRUPDAVETEDILENCEVRIMICIDEGIL"));
else if (!p->accept)
pInviter->PartyInviteDeny(ch->GetPlayerID());
else
pInviter->PartyInviteAccept(ch);
}
// END_OF_PARTY_JOIN_BUG_FIX

void CInputMain:artySetState(LPCHARACTER ch, const char* c_pData)
{
if (!CPartyManager::instance().IsEnablePCParty())
{
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("SUNUCUYABILGIGITMEDI"));
return;
}

TPacketCGPartySetState* p = (TPacketCGPartySetState*) c_pData;

if (!ch->GetParty())
return;

if (ch->GetParty()->GetLeaderPID() != ch->GetPlayerID())
{
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("BUNUSADECEGRUPLIDERIDEGISTIREBILIR"));
return;
}

if (!ch->GetParty()->IsMember(p->pid))
{
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("HEDEFGRUPUYESIDEGIL"));
return;
}

DWORD pid = p->pid;
sys_log(0, "PARTY SetRole pid %d to role %d state %s", pid, p->byRole, p->flag ? "on" : "off");

switch (p->byRole)
{
case PARTY_ROLE_NORMAL:
break;

case PARTY_ROLE_ATTACKER:
case PARTY_ROLE_TANKER:
case PARTY_ROLE_BUFFER:
case PARTY_ROLE_SKILL_MASTER:
case PARTY_ROLE_HASTE:
case PARTY_ROLE_DEFENDER:
if (ch->GetParty()->SetRole(pid, p->byRole, p->flag))
{
TPacketPartyStateChange pack;
pack.dwLeaderPID = ch->GetPlayerID();
pack.dwPID = p->pid;
pack.bRole = p->byRole;
pack.bFlag = p->flag;
db_clientdesc->DBPacket(HEADER_GD_PARTY_STATE_CHANGE, 0, &pack, sizeof(pack));
}

break;

default:
sys_err("wrong byRole in PartySetState Packet name %s state %d", ch->GetName(), p->byRole);
break;
}
}

void CInputMain:artyRemove(LPCHARACTER ch, const char* c_pData)
{
if (ch->GetArena())
{
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("BUNUARENADAKULLANAMAZSINHATA"));
return;
}

if (!CPartyManager::instance().IsEnablePCParty())
{
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("SUNUCUYABILGIGITMEDI"));
return;
}

if (ch->GetDungeon())
{
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("GRUPZINDANDAOYUNCUATAMAZSIN"));
return;
}

TPacketCGPartyRemove* p = (TPacketCGPartyRemove*) c_pData;

if (!ch->GetParty())
return;

LPPARTY pParty = ch->GetParty();
if (pParty->GetLeaderPID() == ch->GetPlayerID())
{
if (ch->GetDungeon())
{
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("GRUPZINDANDAOYUNCUATAMAZSIN"));
}
else
{

if(pParty->IsPartyInDungeon(351))
{
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("HEDEFGRUPUYESIDEGIL"));
return;
}

// leader can remove any member
if (p->pid == ch->GetPlayerID() || pParty->GetMemberCount() == 2)
{
// party disband
CPartyManager::instance().DeleteParty(pParty);
}
else
{
LPCHARACTER B = CHARACTER_MANAGER::instance().FindByPID(p->pid);
if (B)
{
//pParty->SendPartyRemoveOneToAll(B);
B->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("GRUPTANATILDIN"));
//pParty->Unlink(B);
//CPartyManager::instance().SetPartyMember(B->GetPlayerID(), NULL);
}
pParty->Quit(p->pid);
}
}
}
else
{
// otherwise, only remove itself
if (p->pid == ch->GetPlayerID())
{
if (ch->GetDungeon())
{
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("GRUPZINDANDAYKENGRUPTANAYRILMAZSIN"));
}
else
{
if (pParty->GetMemberCount() == 2)
{
// party disband
CPartyManager::instance().DeleteParty(pParty);
}
else
{
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("GRUPTANAYRILDIN"));
//pParty->SendPartyRemoveOneToAll(ch);
pParty->Quit(ch->GetPlayerID());
//pParty->SendPartyRemoveAllToOne(ch);
//CPartyManager::instance().SetPartyMember(ch->GetPlayerID(), NULL);
}
}
}
else
{
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("GRUPUYELIERINIATAMAZSIN"));
}
}
}

void CInputMain::AnswerMakeGuild(LPCHARACTER ch, const char* c_pData)
{
TPacketCGAnswerMakeGuild* p = (TPacketCGAnswerMakeGuild*) c_pData;

if (ch->GetGold() < 200000)
return;

if (get_global_time() - ch->GetQuestFlag("guild_manage.new_disband_time") <
CGuildManager::instance().GetDisbandDelay())
{
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("LONCAHATA %d SILINDI"),
quest::CQuestManager::instance().GetEventFlag("guild_disband_delay"));
return;
}

if (get_global_time() - ch->GetQuestFlag("guild_manage.new_withdraw_time") <
CGuildManager::instance().GetWithdrawDelay())
{
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("LONCAAYRILTIKDANSONRABEKLEMENGEREK %d "),
quest::CQuestManager::instance().GetEventFlag("guild_withdraw_delay"));
return;
}

if (ch->GetGuild())
return;

CGuildManager& gm = CGuildManager::instance();

TGuildCreateParameter cp;
memset(&cp, 0, sizeof(cp));

cp.master = ch;
strlcpy(cp.name, p->guild_name, sizeof(cp.name));

if (cp.name[0] == 0 || !check_name(cp.name))
{
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("HATALONCAISMI"));
return;
}

DWORD dwGuildID = gm.CreateGuild(cp);

if (dwGuildID)
{
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("LONCAKURULDU [%s] "), cp.name);

int GuildCreateFee = 200000; // Lonca kurma ucreti

ch->PointChange(POINT_GOLD, -GuildCreateFee);
DBManager::instance().SendMoneyLog(MONEY_LOG_GUILD, ch->GetPlayerID(), -GuildCreateFee);

char Log[128];
snprintf(Log, sizeof(Log), "GUILD_NAME %s MASTER %s", cp.name, ch->GetName());
LogManager::instance().CharLog(ch, 0, "MAKE_GUILD", Log);

ch->RemoveSpecifyItem(GUILD_CREATE_ITEM_VNUM, 1);
//ch->SendGuildName(dwGuildID);
}
else
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("LONCAKURULAMADI"));
}

void CInputMain:artyUseSkill(LPCHARACTER ch, const char* c_pData)
{
TPacketCGPartyUseSkill* p = (TPacketCGPartyUseSkill*) c_pData;
if (!ch->GetParty())
return;

if (ch->GetPlayerID() != ch->GetParty()->GetLeaderPID())
{
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("GRUPBECKULLANMA"));
return;
}

switch (p->bySkillIndex)
{
case PARTY_SKILL_HEAL:
ch->GetParty()->HealParty();
break;
#ifde#ifdef_FIXED
case PARTY_SKILL_WARP:
{
LPCHARACTER pch = CHARACTER_MANAGER::instance().Find(p->vid);
if (pch)
{
if (pch->IsPC())
ch->GetParty()->SummonToLeader(pch->GetPlayerID());
else
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("HEDEFYOKGRUP"));
}
}
break;
#else#else case PARTY_SKILL_WARP:
{
LPCHARACTER pch = CHARACTER_MANAGER::instance().Find(p->vid);
if (pch)
ch->GetParty()->SummonToLeader(pch->GetPlayerID());
else
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("HEDEFYOKGRUP"));
}
break;
#endi#endif}
}

void CInputMain:artyParameter(LPCHARACTER ch, const char * c_pData)
{
TPacketCGPartyParameter * p = (TPacketCGPartyParameter *) c_pData;

#ifde#ifdef_FIXED
if (ch->GetParty() && ch->GetParty()->GetLeaderPID() == ch->GetPlayerID())
#else#elseif (ch->GetParty())
#endi#endif ch->GetParty()->SetParameter(p->bDistributeMode);
}

size_t GetSubPacketSize(const GUILD_SUBHEADER_CG& header)
{
switch (header)
{
case GUILD_SUBHEADER_CG_DEPOSIT_MONEY: return sizeof(int);
case GUILD_SUBHEADER_CG_WITHDRAW_MONEY: return sizeof(int);
case GUILD_SUBHEADER_CG_ADD_MEMBER: return sizeof(DWORD);
case GUILD_SUBHEADER_CG_REMOVE_MEMBER: return sizeof(DWORD);
case GUILD_SUBHEADER_CG_CHANGE_GRADE_NAME: return 10;
case GUILD_SUBHEADER_CG_CHANGE_GRADE_AUTHORITY: return sizeof(BYTE) + sizeof(BYTE);
case GUILD_SUBHEADER_CG_OFFER: return sizeof(DWORD);
case GUILD_SUBHEADER_CG_CHARGE_GSP: return sizeof(int);
case GUILD_SUBHEADER_CG_POST_COMMENT: return 1;
case GUILD_SUBHEADER_CG_DELETE_COMMENT: return sizeof(DWORD);
case GUILD_SUBHEADER_CG_REFRESH_COMMENT: return 0;
case GUILD_SUBHEADER_CG_CHANGE_MEMBER_GRADE: return sizeof(DWORD) + sizeof(BYTE);
case GUILD_SUBHEADER_CG_USE_SKILL: return sizeof(TPacketCGGuildUseSkill);
case GUILD_SUBHEADER_CG_CHANGE_MEMBER_GENERAL: return sizeof(DWORD) + sizeof(BYTE);
case GUILD_SUBHEADER_CG_GUILD_INVITE_ANSWER: return sizeof(DWORD) + sizeof(BYTE);
}

return 0;
}

int CInputMain::Guild(LPCHARACTER ch, const char * data, size_t uiBytes)
{
if (uiBytes < sizeof(TPacketCGGuild))
return -1;

const TPacketCGGuild* p = reinterpret_cast<const TPacketCGGuild*>(data);
const char* c_pData = data + sizeof(TPacketCGGuild);

uiBytes -= sizeof(TPacketCGGuild);

const GUILD_SUBHEADER_CG SubHeader = static_cast<GUILD_SUBHEADER_CG>(p->subheader);
const size_t SubPacketLen = GetSubPacketSize(SubHeader);

if (uiBytes < SubPacketLen)
{
return -1;
}

CGuild* pGuild = ch->GetGuild();

if (NULL == pGuild)
{
if (SubHeader != GUILD_SUBHEADER_CG_GUILD_INVITE_ANSWER)
{
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT(" BULONCAYAAITDEGIL"));
return SubPacketLen;
}
}

switch (SubHeader)
{
case GUILD_SUBHEADER_CG_DEPOSIT_MONEY:
{

return SubPacketLen;

const int gold = MIN(*reinterpret_cast<const int*>(c_pData), __deposit_limit());

if (gold < 0)
{
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("LONCAYANLISYANG"));
return SubPacketLen;
}

if (ch->GetGold() < gold)
{
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("LONCAYANGYOK"));
return SubPacketLen;
}

pGuild->RequestDepositMoney(ch, gold);
}
return SubPacketLen;

case GUILD_SUBHEADER_CG_WITHDRAW_MONEY:
{

return SubPacketLen;

const int gold = MIN(*reinterpret_cast<const int*>(c_pData), 500000);

if (gold < 0)
{
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("LONCAYANLISYANG"));
return SubPacketLen;
}

pGuild->RequestWithdrawMoney(ch, gold);
}
return SubPacketLen;

case GUILD_SUBHEADER_CG_ADD_MEMBER:
{
const DWORD vid = *reinterpret_cast<const DWORD*>(c_pData);
LPCHARACTER newmember = CHARACTER_MANAGER::instance().Find(vid);

if (!newmember)
{
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("LONCAISTENENOYUNCUYOK"));
return SubPacketLen;
}

// @fixme145 BEGIN (+newmember ispc check)
if (!ch->IsPC() || !newmember->IsPC())
return SubPacketLen;
// @fixme145 END

pGuild->Invite(ch, newmember);
}
return SubPacketLen;

case GUILD_SUBHEADER_CG_REMOVE_MEMBER:
{
if (pGuild->UnderAnyWar() != 0)
{
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("LONCAYASALDIRAMAZSIN"));
return SubPacketLen;
}

const DWORD pid = *reinterpret_cast<const DWORD*>(c_pData);
const TGuildMember* m = pGuild->GetMember(ch->GetPlayerID());

if (NULL == m)
return -1;

LPCHARACTER member = CHARACTER_MANAGER::instance().FindByPID(pid);

if (member)
{
if (member->GetGuild() != pGuild)
{
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("LONCAYNILONCADADEGIL"));
return SubPacketLen;
}

if (!pGuild->HasGradeAuth(m->grade, GUILD_AUTH_REMOVE_MEMBER))
{
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("LONCAUYELERINIATAMAZSIN"));
return SubPacketLen;
}

member->SetQuestFlag("guild_manage.new_withdraw_time", get_global_time());
pGuild->RequestRemoveMember(member->GetPlayerID());

if (g_bGuildInviteLimit)
{
DBManager::instance().Query("REPLACE INTO guild_invite_limit VALUES(%d, %d)", pGuild->GetID(), get_global_time());
}
}
else
{
if (!pGuild->HasGradeAuth(m->grade, GUILD_AUTH_REMOVE_MEMBER))
{
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("LONCAUYELERINIATAMAZSIN"));
return SubPacketLen;
}

if (pGuild->RequestRemoveMember(pid))
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("LONCAUYESINIATTIN"));
else
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("LONCAISTENENOYUNCUYOK"));
}
}
return SubPacketLen;

case GUILD_SUBHEADER_CG_CHANGE_GRADE_NAME:
{
char gradename[GUILD_GRADE_NAME_MAX_LEN + 1];
strlcpy(gradename, c_pData + 1, sizeof(gradename));

const TGuildMember * m = pGuild->GetMember(ch->GetPlayerID());

if (NULL == m)
return -1;

if (m->grade != GUILD_LEADER_GRADE)
{
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("LONCASIRAISMIENGEL"));
}
else if (*c_pData == GUILD_LEADER_GRADE)
{
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("LONCAMASTERGUCUDEGISTIRILEMEZ"));
}
else if (!check_name(gradename))
{
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("LONCABUSIRAISMIGECERSIZ"));
}
else
{
pGuild->ChangeGradeName(*c_pData, gradename);
}
}
return SubPacketLen;

case GUILD_SUBHEADER_CG_CHANGE_GRADE_AUTHORITY:
{
const TGuildMember* m = pGuild->GetMember(ch->GetPlayerID());

if (NULL == m)
return -1;

if (m->grade != GUILD_LEADER_GRADE)
{
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("LONCAPOZISYONUDEGISTIREMEZSIN"));
}
else if (*c_pData == GUILD_LEADER_GRADE)
{
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("LONCAMASTERGUCUDEGISTIRILEMEZ"));
}
else
{
pGuild->ChangeGradeAuth(*c_pData, *(c_pData + 1));
}
}
return SubPacketLen;

case GUILD_SUBHEADER_CG_OFFER:
{
DWORD offer = *reinterpret_cast<const DWORD*>(c_pData);

if (pGuild->GetLevel() >= GUILD_MAX_LEVEL)
{
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("LONCAMAXSEVIYE"));
}
else
{
offer /= 100;
offer *= 100;

if (pGuild->OfferExp(ch, offer))
{
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("LONCATRC %u"), offer);
}
else
{
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("LONCATECBASARISIZ"));
}
}
}
return SubPacketLen;

case GUILD_SUBHEADER_CG_CHARGE_GSP:
{
const int offer = *reinterpret_cast<const int*>(c_pData);
const int gold = offer * 100;

if (offer < 0 || gold < offer || gold < 0 || ch->GetGold() < gold)
{
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("LONCAYETERLIYANGYOK"));
return SubPacketLen;
}

if (!pGuild->ChargeSP(ch, offer))
{
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("LONCAEJDERHAYALETYUKLENMEDI"));
}
}
return SubPacketLen;

case GUILD_SUBHEADER_CG_POST_COMMENT:
{
const size_t length = *c_pData;

if (length > GUILD_COMMENT_MAX_LEN)
{

sys_err("POST_COMMENT: %s comment too long (length: %u)", ch->GetName(), length);
ch->GetDesc()->SetPhase(PHASE_CLOSE);
return -1;
}

if (uiBytes < 1 + length)
return -1;

const TGuildMember* m = pGuild->GetMember(ch->GetPlayerID());

if (NULL == m)
return -1;

if (length && !pGuild->HasGradeAuth(m->grade, GUILD_AUTH_NOTICE) && *(c_pData + 1) == '!')
{
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("LONCADUYURUYOK"));
}
else
{
std::string str(c_pData + 1, length);
pGuild->AddComment(ch, str);
}

return (1 + length);
}

case GUILD_SUBHEADER_CG_DELETE_COMMENT:
{
const DWORD comment_id = *reinterpret_cast<const DWORD*>(c_pData);

pGuild->DeleteComment(ch, comment_id);
}
return SubPacketLen;

case GUILD_SUBHEADER_CG_REFRESH_COMMENT:
pGuild->RefreshComment(ch);
return SubPacketLen;

case GUILD_SUBHEADER_CG_CHANGE_MEMBER_GRADE:
{
const DWORD pid = *reinterpret_cast<const DWORD*>(c_pData);
const BYTE grade = *(c_pData + sizeof(DWORD));
const TGuildMember* m = pGuild->GetMember(ch->GetPlayerID());

if (NULL == m)
return -1;

if (m->grade != GUILD_LEADER_GRADE)
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("LONCAPOZDEGISTIRMEENGEL"));
else if (ch->GetPlayerID() == pid)
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("LONCAMASTERSIRALAMADEGISMEZ"));
else if (grade == 1)
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("KENDINILONCAMASTER"));
else
pGuild->ChangeMemberGrade(pid, grade);
}
return SubPacketLen;

case GUILD_SUBHEADER_CG_USE_SKILL:
{
const TPacketCGGuildUseSkill* p = reinterpret_cast<const TPacketCGGuildUseSkill*>(c_pData);

pGuild->UseSkill(p->dwVnum, ch, p->dwPID);
}
return SubPacketLen;

case GUILD_SUBHEADER_CG_CHANGE_MEMBER_GENERAL:
{
const DWORD pid = *reinterpret_cast<const DWORD*>(c_pData);
const BYTE is_general = *(c_pData + sizeof(DWORD));
const TGuildMember* m = pGuild->GetMember(ch->GetPlayerID());

if (NULL == m)
return -1;

if (m->grade != GUILD_LEADER_GRADE)
{
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("LONCALIDERSECEMEZSIN"));
}
else
{
if (!pGuild->ChangeMemberGeneral(pid, is_general))
{
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("LONCADAHAFAZLALIDERSECILMEZ"));
}
}
}
return SubPacketLen;

case GUILD_SUBHEADER_CG_GUILD_INVITE_ANSWER:
{
const DWORD guild_id = *reinterpret_cast<const DWORD*>(c_pData);
const BYTE accept = *(c_pData + sizeof(DWORD));

CGuild * g = CGuildManager::instance().FindGuild(guild_id);

if (g)
{
if (accept)
g->InviteAccept(ch);
else
g->InviteDeny(ch->GetPlayerID());
}
}
return SubPacketLen;

}

return 0;
}

void CInputMain::Fishing(LPCHARACTER ch, const char* c_pData)
{
TPacketCGFishing* p = (TPacketCGFishing*)c_pData;
ch->SetRotation(p->dir * 5);
ch->fishing();
return;
}

void CInputMain::ItemGive(LPCHARACTER ch, const char* c_pData)
{
TPacketCGGiveItem* p = (TPacketCGGiveItem*) c_pData;
LPCHARACTER to_ch = CHARACTER_MANAGER::instance().Find(p->dwTargetVID);

if (to_ch)
ch->GiveItem(to_ch, p->ItemPos);
else
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("BUNESNEYLETICOLMAZ"));
}

void CInputMain::Hack(LPCHARACTER ch, const char * c_pData)
{
TPacketCGHack * p = (TPacketCGHack *) c_pData;

char buf[sizeof(p->szBuf)];
strlcpy(buf, p->szBuf, sizeof(buf));

sys_err("HACK_DETECT: %s %s", ch->GetName(), buf);


ch->GetDesc()->SetPhase(PHASE_CLOSE);
}

int CInputMain::MyShop(LPCHARACTER ch, const char * c_pData, size_t uiBytes)
{
TPacketCGMyShop * p = (TPacketCGMyShop *) c_pData;
int iExtraLen = p->bCount * sizeof(TShopItemTable);

if (uiBytes < sizeof(TPacketCGMyShop) + iExtraLen)
return -1;

if (ch->GetGold() >= GOLD_MAX)
{
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("2TYANGSINIR"));
sys_log(0, "MyShop ==> OverFlow Gold id %u name %s ", ch->GetPlayerID(), ch->GetName());
return (iExtraLen);
}

if (ch->IsStun() || ch->IsDead())
return (iExtraLen);

if (ch->GetExchange() || ch->IsOpenSafebox() || ch->GetShopOwner() || ch->IsCubeOpen())
{
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("BASKASIYLATICYAPARKENOZELDEPOACAMAZSIN"));
return (iExtraLen);
}

sys_log(0, "MyShop count %d", p->bCount);
ch->OpenMyShop(p->szSign, (TShopItemTable *) (c_pData + sizeof(TPacketCGMyShop)), p->bCount);
return (iExtraLen);
}

void CInputMain::Refine(LPCHARACTER ch, const char* c_pData)
{
const TPacketCGRefine* p = reinterpret_cast<const TPacketCGRefine*>(c_pData);

if (ch->GetExchange() || ch->IsOpenSafebox() || ch->GetShopOwner() || ch->GetMyShop() || ch->IsCubeOpen())
{
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("MAGAZAVEYATICACKKENYUKSELTMEOLMAZ"));
ch->ClearRefineMode();
return;
}

if (p->type == 255)
{
// DoRefine Cancel
ch->ClearRefineMode();
return;
}

if (p->pos >= INVENTORY_MAX_NUM)
{
ch->ClearRefineMode();
return;
}

LPITEM item = ch->GetInventoryItem(p->pos);

if (!item)
{
ch->ClearRefineMode();
return;
}

ch->SetRefineTime();

if (p->type == REFINE_TYPE_NORMAL)
{
sys_log (0, "refine_type_noraml");
ch->DoRefine(item);
}
else if (p->type == REFINE_TYPE_SCROLL || p->type == REFINE_TYPE_HYUNIRON || p->type == REFINE_TYPE_MUSIN || p->type == REFINE_TYPE_BDRAGON)
{
sys_log (0, "refine_type_scroll, ...");
ch->DoRefineWithScroll(item);
}
else if (p->type == REFINE_TYPE_MONEY_ONLY)
{
const LPITEM item = ch->GetInventoryItem(p->pos);

if (NULL != item)
{
if (500 <= item->GetRefineSet())
{
LogManager::instance().HackLog("DEVIL_TOWER_REFINE_HACK", ch);
}
else
{
if (ch->GetQuestFlag("deviltower_zone.can_refine") > 0) // @fixme158 (allow multiple refine attempts)
{
if (ch->DoRefine(item, true))
ch->SetQuestFlag("deviltower_zone.can_refine", ch->GetQuestFlag("deviltower_zone.can_refine") - 1);
}
else
{
ch->ChatPacket(CHAT_TYPE_INFO, "사귀 타워 완료 보상은 한번까지 사용가능합니다.");
}
}
}
}

ch->ClearRefineMode();
}

#ifdef ENABLE_ACCE_COSTUME_SYSTEM
void CInput#ifdefAcce(LPCHARACTER pkChar, const char* c_pData)
{
quest:C * pPC = quest::CQuestManager::instance().GetPCForce(pkChar->GetPlayerID());
if (pPC->IsRunning())
return;

TPacketAcce * sPacket = (TPacketAcce*) c_pData;
switch (sPacket->subheader)
{
case ACCE_SUBHEADER_CG_CLOSE:
{
pkChar->CloseAcce();
}
break;
case ACCE_SUBHEADER_CG_ADD:
{
pkChar->AddAcceMaterial(sPacket->tPos, sPacket->bPos);
}
break;
case ACCE_SUBHEADER_CG_REMOVE:
{
pkChar->RemoveAcceMaterial(sPacket->bPos);
}
break;
case ACCE_SUBHEADER_CG_REFINE:
{
pkChar->RefineAcceMaterials();
}
break;
default:
break;
}
}
#endif

#ifdef ENABLE_DROP_ITEM_WORLDARD
void#endiftM#ifdefropItemInfoSend(LPCHARACTER ch, const char* data)
{
struct packet_send_drop_item_system * pinfo = (struct packet_send_drop_item_system *) data;

switch (pinfo->subheader)
{
case DROP_ITEM_SUB_HEADER_OPEN:
{
CDropItem::instance().Open(ch);
}
break;

case DROP_ITEM_SUB_HEADER_SEARCH:
{
int vnum_item = pinfo->vnum_item;
CDropItem::instance().Search(ch,vnum_item);
}
break;

}
}
#endif


#ifdef ENABLE_CUBE_RENEWAL_WORLDARD
#endifInp#ifdef::CubeRenewalSend(LPCHARACTER ch, const char* data)
{
struct packet_send_cube_renewal * pinfo = (struct packet_send_cube_renewal *) data;
switch (pinfo->subheader)
{
case CUBE_RENEWAL_SUB_HEADER_MAKE_ITEM:
{

int index_item = pinfo->index_item;
int count_item = pinfo->count_item;

Cube_Make(ch,index_item,count_item);
}
break;

case CUBE_RENEWAL_SUB_HEADER_CLOSE:
{
Cube_close(ch);
}
break;
}
}
#endif

int CInputMain::Analyze(LPDESC d, BYT#endifder, const char * c_pData)
{
LPCHARACTER ch;

if (!(ch = d->GetCharacter()))
{
sys_err("no character on desc");
d->SetPhase(PHASE_CLOSE);
return (0);
}

int iExtraLen = 0;

if (test_server && bHeader != HEADER_CG_MOVE)
sys_log(0, "CInputMain::Analyze() ==> Header [%d] ", bHeader);

if (ch->GetDesc()->GetPhase() != PHASE_GAME && ch->GetDesc()->GetPhase() != PHASE_DEAD)
{
sys_err("no character in game");
sys_log(0, "no character in game %u %u %u", ch->GetPlayerID(), ch->GetDesc()->GetPhase(), bHeader);
d->SetPhase(PHASE_CLOSE);
return (0);
}


switch (bHeader)
{
case HEADER_CG_PONG:
Pong(d);
break;

case HEADER_CG_TIME_SYNC:
Handshake(d, c_pData);
break;

case HEADER_CG_CHAT:
if (test_server)
{
char* pBuf = (char*)c_pData;
sys_log(0, "%s", pBuf + sizeof(TPacketCGChat));
}

if ((iExtraLen = Chat(ch, c_pData, m_iBufferLeft)) < 0)
return -1;
break;

case HEADER_CG_WHISPER:
if ((iExtraLen = Whisper(ch, c_pData, m_iBufferLeft)) < 0)
return -1;
break;

case HEADER_CG_MOVE:
Move(ch, c_pData);
// @fixme103 (removed CheckClientVersion since useless in here)
break;

case HEADER_CG_CHARACTER_POSITION:
Position(ch, c_pData);
break;

case HEADER_CG_ITEM_USE:
if (!ch->IsObserverMode())
ItemUse(ch, c_pData);
break;

case HEADER_CG_ITEM_DROP:
if (!ch->IsObserverMode())
{
ItemDrop(ch, c_pData);
}
break;

case HEADER_CG_ITEM_DROP2:
if (!ch->IsObserverMode())
ItemDrop2(ch, c_pData);
break;

case HEADER_CG_ITEM_MOVE:
if (!ch->IsObserverMode())
ItemMove(ch, c_pData);
break;

case HEADER_CG_ITEM_PICKUP:
if (!ch->IsObserverMode())
ItemPickup(ch, c_pData);
break;

case HEADER_CG_ITEM_USE_TO_ITEM:
if (!ch->IsObserverMode())
ItemToItem(ch, c_pData);
break;

case HEADER_CG_ITEM_GIVE:
if (!ch->IsObserverMode())
ItemGive(ch, c_pData);
break;

case HEADER_CG_EXCHANGE:
if (!ch->IsObserverMode())
Exchange(ch, c_pData);
break;

case HEADER_CG_ATTACK:
case HEADER_CG_SHOOT:
if (!ch->IsObserverMode())
{
Attack(ch, bHeader, c_pData);
}
break;

case HEADER_CG_USE_SKILL:
if (!ch->IsObserverMode())
UseSkill(ch, c_pData);
break;

case HEADER_CG_QUICKSLOT_ADD:
QuickslotAdd(ch, c_pData);
break;

case HEADER_CG_QUICKSLOT_DEL:
QuickslotDelete(ch, c_pData);
break;

case HEADER_CG_QUICKSLOT_SWAP:
QuickslotSwap(ch, c_pData);
break;
#ifdef __SEND_TARGET_INFO__
case HEAD#ifdefTARGET_INFO_LOAD:
{
TargetInfoLoad(ch, c_pData);
}
break;
#endif
case HEADER_CG_SHOP:
#endif((iExtraLen = Shop(ch, c_pData, m_iBufferLeft)) < 0)
return -1;
break;

case HEADER_CG_MESSENGER:
if ((iExtraLen = Messenger(ch, c_pData, m_iBufferLeft))<0)
return -1;
break;

case HEADER_CG_ON_CLICK:
OnClick(ch, c_pData);
break;

case HEADER_CG_SYNC_POSITION:
if ((iExtraLen = SyncPosition(ch, c_pData, m_iBufferLeft)) < 0)
return -1;
break;

case HEADER_CG_ADD_FLY_TARGETING:
case HEADER_CG_FLY_TARGETING:
FlyTarget(ch, c_pData, bHeader);
break;

case HEADER_CG_SCRIPT_BUTTON:
ScriptButton(ch, c_pData);
break;

// SCRIPT_SELECT_ITEM
case HEADER_CG_SCRIPT_SELECT_ITEM:
ScriptSelectItem(ch, c_pData);
break;
// END_OF_SCRIPT_SELECT_ITEM

case HEADER_CG_SCRIPT_ANSWER:
ScriptAnswer(ch, c_pData);
break;

case HEADER_CG_QUEST_INPUT_STRING:
QuestInputString(ch, c_pData);
break;

case HEADER_CG_QUEST_CONFIRM:
QuestConfirm(ch, c_pData);
break;

case HEADER_CG_TARGET:
Target(ch, c_pData);
break;

case HEADER_CG_WARP:
Warp(ch, c_pData);
break;

case HEADER_CG_SAFEBOX_CHECKIN:
SafeboxCheckin(ch, c_pData);
break;

case HEADER_CG_SAFEBOX_CHECKOUT:
SafeboxCheckout(ch, c_pData, false);
break;

case HEADER_CG_SAFEBOX_ITEM_MOVE:
SafeboxItemMove(ch, c_pData);
break;

case HEADER_CG_MALL_CHECKOUT:
SafeboxCheckout(ch, c_pData, true);
break;

case HEADER_CG_PARTY_INVITE:
PartyInvite(ch, c_pData);
break;

case HEADER_CG_PARTY_REMOVE:
PartyRemove(ch, c_pData);
break;

case HEADER_CG_PARTY_INVITE_ANSWER:
PartyInviteAnswer(ch, c_pData);
break;

case HEADER_CG_PARTY_SET_STATE:
PartySetState(ch, c_pData);
break;

case HEADER_CG_PARTY_USE_SKILL:
PartyUseSkill(ch, c_pData);
break;

case HEADER_CG_PARTY_PARAMETER:
PartyParameter(ch, c_pData);
break;

case HEADER_CG_ANSWER_MAKE_GUILD:
#ifdef ENABLE_NEWGUILDMAKE
ch->Ch#ifdefet(CHAT_TYPE_INFO, "<%s> AnswerMakeGuild disabled", __FUNCTION__);
#else
AnswerMakeGuild(ch, c_pData#elsendif
break;

case HEADE#endifUILD:
if ((iExtraLen = Guild(ch, c_pData, m_iBufferLeft)) < 0)
return -1;
break;

case HEADER_CG_FISHING:
Fishing(ch, c_pData);
break;

case HEADER_CG_HACK:
Hack(ch, c_pData);
break;

case HEADER_CG_MYSHOP:
if ((iExtraLen = MyShop(ch, c_pData, m_iBufferLeft)) < 0)
return -1;
break;

#ifdef ENABLE_ACCE_COSTUME_SYSTEM
cas#ifdefER_CG_ACCE:
Acce(ch, c_pData);
break;
#endif

case HEADER_CG_REFINE:
#endifRefine(ch, c_pData);
break;

case HEADER_CG_CLIENT_VERSION:
Version(ch, c_pData);
break;

case HEADER_CG_HS_ACK:
if (isHackShieldEnable)
{
CHackShieldManager::instance().VerifyAck(d->GetCharacter(), c_pData);
}
break;

case HEADER_CG_XTRAP_ACK:
{
TPacketXTrapCSVerify* p = reinterpret_cast<TPacketXTrapCSVerify*>((void*)c_pData);
CXTrapManager::instance().Verify_CSStep3(d->GetCharacter(), p->bPacketData);
}
break;
case HEADER_CG_DRAGON_SOUL_REFINE:
{
TPacketCGDragonSoulRefine* p = reinterpret_cast <TPacketCGDragonSoulRefine*>((void*)c_pData);
switch(p->bSubType)
{
case DS_SUB_HEADER_CLOSE:
ch->DragonSoul_RefineWindow_Close();
break;
case DS_SUB_HEADER_DO_REFINE_GRADE:
{
DSManager::instance().DoRefineGrade(ch, p->ItemGrid);
}
break;
case DS_SUB_HEADER_DO_REFINE_STEP:
{
DSManager::instance().DoRefineStep(ch, p->ItemGrid);
}
break;
case DS_SUB_HEADER_DO_REFINE_STRENGTH:
{
DSManager::instance().DoRefineStrength(ch, p->ItemGrid);
}
break;
}
}
#ifdef ENABLE_SWITCHBOT
case HEADER_C#ifdefCHBOT:
if ((iExtraLen = Switchbot(ch, c_pData, m_iBufferLeft)) < 0)
{
return -1;
}
break;
#endif
#ifdef ENABLE_DROP_ITEM_WORLDARD
#endife#ifdefR_CG_DROP_ITEM_SYSTEM:
DropItemInfoSend(ch, c_pData);
break;
#endif
#ifdef ENABLE_CUBE_RENEWAL_WORLDARD
#endifc#ifdefADER_CG_CUBE_RENEWAL:
CubeRenewalSend(ch, c_pData);
break;
#endif
break;
}
return (i#endifen);
}

int CInputDead::Analyze(LPDESC d, BYTE bHeader, const char * c_pData)
{
LPCHARACTER ch;

if (!(ch = d->GetCharacter()))
{
sys_err("no character on desc");
return 0;
}

int iExtraLen = 0;

switch (bHeader)
{
case HEADER_CG_PONG:
Pong(d);
break;

case HEADER_CG_TIME_SYNC:
Handshake(d, c_pData);
break;

case HEADER_CG_CHAT:
if ((iExtraLen = Chat(ch, c_pData, m_iBufferLeft)) < 0)
return -1;

break;

case HEADER_CG_WHISPER:
if ((iExtraLen = Whisper(ch, c_pData, m_iBufferLeft)) < 0)
return -1;

break;

case HEADER_CG_HACK:
Hack(ch, c_pData);
break;

default:
return (0);
}

return (iExtraLen);
}

#ifdef ENABLE_SWITCHBOT
int CInputMain::Switc#ifdefPCHARACTER ch, const char* data, size_t uiBytes)
{
const TPacketCGSwitchbot* p = reinterpret_cast<const TPacketCGSwitchbot*>(data);

if (uiBytes < sizeof(TPacketCGSwitchbot))
{
return -1;
}

const char* c_pData = data + sizeof(TPacketCGSwitchbot);
uiBytes -= sizeof(TPacketCGSwitchbot);

switch (p->subheader)
{
case SUBHEADER_CG_SWITCHBOT_START:
{
size_t extraLen = sizeof(TSwitchbotAttributeAlternativeTable) * SWITCHBOT_ALTERNATIVE_COUNT;
if (uiBytes < extraLen)
{
return -1;
}

std::vector<TSwitchbotAttributeAlternativeTable> vec_alternatives;

for (BYTE alternative = 0; alternative < SWITCHBOT_ALTERNATIVE_COUNT; ++alternative)
{
const TSwitchbotAttributeAlternativeTable* pAttr = reinterpret_cast<const TSwitchbotAttributeAlternativeTable*>(c_pData);
c_pData += sizeof(TSwitchbotAttributeAlternativeTable);

vec_alternatives.emplace_back(*pAttr);
}

CSwitchbotManager::Instance().Start(ch->GetPlayerID(), p->slot, vec_alternatives);
return extraLen;
}

case SUBHEADER_CG_SWITCHBOT_STOP:
{
CSwitchbotManager::Instance().Stop(ch->GetPlayerID(), p->slot);
return 0;
}
}

return 0;
}
#endif


//martysama0134's 2022
[/CODE]#endif