#include "stdafx.h"

#include <Item/ItemFactory.h>
#include <Item/ItemStructure.h>
#include <Item/ItemMgr.h>

#include <Utility/Math/Math.h>
#include <Log/LogCommands.h>
#include <Community/Guild/GuildConstants.h>

#include "GlobalFunctions.h"
#include "PrintLog.h"

using namespace GAMELOG;

CTypeName g_HumanEquipmentPosTypeName[Item::EquipmentPos::MAX_EQUPMENT_POS];
CTypeName g_AkhanEquipmentPosTypeName[Item::EquipmentPos::MAX_EQUPMENT_POS];

CTypeName g_PositionName[TakeType::TS_MAXTYPE];

bool g_bInitializePositionData = GAMELOG::SimpleInfo::InitPositionData();


inline const char* GetItemName(unsigned short usProtoTypeID)
{
    const Item::ItemInfo* lpItemInfo = Item::CItemMgr::GetInstance().GetItemInfo(usProtoTypeID);
    return (0 != lpItemInfo) 
		? lpItemInfo->m_SpriteData.m_szName : GetMyINIString("STRING_FOR_LOCALIZE", "UNKNOWN_ITEM");
}

bool IsEquip(unsigned short usProtoTypeID)
{
    const Item::ItemInfo* lpItemInfo = Item::CItemMgr::GetInstance().GetItemInfo(usProtoTypeID);
    return (0 != lpItemInfo) ? 0 != (lpItemInfo->m_DetailData.m_dwFlags & Item::DetailData::EQUIP) : false;
}

const char* GAMELOG::GuildLogType(const char cType)
{
    const char* szResult = GetMyINIString("STRING_FOR_LOCALIZE", "UNKNOWN_TYPE");

    switch(cType)
    {
    case GAMELOG::sGuildLog::REQUEST:
        szResult = GetMyINIString("STRING_FOR_LOCALIZE", "REQUEST");
        break;

    case GAMELOG::sGuildLog::RESULT:
        szResult = GetMyINIString("STRING_FOR_LOCALIZE", "RESULT");
        break;
    }

    return szResult;
}

const char* GAMELOG::GuildTitle(unsigned long dwTitle)
{
    const char* szResult = GetMyINIString("STRING_FOR_LOCALIZE", "UNKNOWN_MEMBER_LV");

    switch(dwTitle)
    {
    case Guild::MASTER:
        szResult = GetMyINIString("STRING_FOR_LOCALIZE", "GUILDRIGHTS_GUILD_MASTER");
        break;

    case Guild::MIDDLE_ADMIN:
        szResult = GetMyINIString("STRING_FOR_LOCALIZE", "GUILDRIGHTS_MIDDLE_ADMIN");
        break;

    case Guild::COMMON:
        szResult = GetMyINIString("STRING_FOR_LOCALIZE", "GUILDRIGHTS_COMMON");
        break;

    case Guild::LEAVE_WAIT:    
        szResult = GetMyINIString("STRING_FOR_LOCALIZE", "GUILDRIGHTS_LEAVE_WAIT");
        break;

    case Guild::JOIN_WAIT:
        szResult = GetMyINIString("STRING_FOR_LOCALIZE", "GUILDRIGHTS_JOIN_WAIT");
        break;
    }

    return szResult;
}

bool SimpleInfo::InitPositionData()
{
    using namespace Item;

    // ÈÞ¸Õ
    g_HumanEquipmentPosTypeName[EquipmentPos::HELM]           = CTypeName(EquipmentPos::HELM, (char*)GetMyINIString("STRING_FOR_LOCALIZE", "HELM"));
	g_HumanEquipmentPosTypeName[EquipmentPos::SHIRT]          = CTypeName(EquipmentPos::SHIRT, (char*)GetMyINIString("STRING_FOR_LOCALIZE", "SHIRT"));
	g_HumanEquipmentPosTypeName[EquipmentPos::TUNIC]          = CTypeName(EquipmentPos::TUNIC, (char*)GetMyINIString("STRING_FOR_LOCALIZE", "TUNIC"));
	g_HumanEquipmentPosTypeName[EquipmentPos::ARMOUR]         = CTypeName(EquipmentPos::ARMOUR, (char*)GetMyINIString("STRING_FOR_LOCALIZE", "ARMOUR"));
	g_HumanEquipmentPosTypeName[EquipmentPos::GLOVE]          = CTypeName(EquipmentPos::GLOVE, (char*)GetMyINIString("STRING_FOR_LOCALIZE", "GLOVE"));
	g_HumanEquipmentPosTypeName[EquipmentPos::BOOTS]          = CTypeName(EquipmentPos::BOOTS, (char*)GetMyINIString("STRING_FOR_LOCALIZE", "BOOTS"));
	g_HumanEquipmentPosTypeName[EquipmentPos::NECKLACE]       = CTypeName(EquipmentPos::NECKLACE, (char*)GetMyINIString("STRING_FOR_LOCALIZE", "NECKLACE"));	
	g_HumanEquipmentPosTypeName[EquipmentPos::RINGR]          = CTypeName(EquipmentPos::RINGR, (char*)GetMyINIString("STRING_FOR_LOCALIZE", "RINGR"));
	g_HumanEquipmentPosTypeName[EquipmentPos::RINGL]          = CTypeName(EquipmentPos::RINGL, (char*)GetMyINIString("STRING_FOR_LOCALIZE", "RINGL"));
	g_HumanEquipmentPosTypeName[EquipmentPos::SHIELD_HAND1]   = CTypeName(EquipmentPos::SHIELD_HAND1, (char*)GetMyINIString("STRING_FOR_LOCALIZE", "SHIELD_HAND1"));
	g_HumanEquipmentPosTypeName[EquipmentPos::SHIELD_HAND2]   = CTypeName(EquipmentPos::SHIELD_HAND2, (char*)GetMyINIString("STRING_FOR_LOCALIZE", "SHIELD_HAND2"));
	g_HumanEquipmentPosTypeName[EquipmentPos::WEAPON_HAND1]   = CTypeName(EquipmentPos::WEAPON_HAND1, (char*)GetMyINIString("STRING_FOR_LOCALIZE", "WEAPON_HAND1"));
	g_HumanEquipmentPosTypeName[EquipmentPos::WEAPON_HAND2]   = CTypeName(EquipmentPos::WEAPON_HAND2, (char*)GetMyINIString("STRING_FOR_LOCALIZE", "WEAPON_HAND2"));
	g_HumanEquipmentPosTypeName[EquipmentPos::AVATA]          = CTypeName(EquipmentPos::AVATA, (char*)GetMyINIString("STRING_FOR_LOCALIZE", "AVATA"));
//    g_HumanEquipmentPosTypeName[EquipmentPos::RIDE]           = CTypeName(EquipmentPos::RIDE, (char*)GetMyINIString("STRING_FOR_LOCALIZE", "RIDE"));

    // ¾ÆÄ­
	g_AkhanEquipmentPosTypeName[EquipmentPos::HEAD]           = CTypeName(EquipmentPos::HEAD, (char*)GetMyINIString("STRING_FOR_LOCALIZE", "HEAD"));
	g_AkhanEquipmentPosTypeName[EquipmentPos::BODY]           = CTypeName(EquipmentPos::BODY, (char*)GetMyINIString("STRING_FOR_LOCALIZE", "BODY"));
	g_AkhanEquipmentPosTypeName[EquipmentPos::PROTECT_ARM]    = CTypeName(EquipmentPos::PROTECT_ARM, (char*)GetMyINIString("STRING_FOR_LOCALIZE", "PROTECT_ARM"));
	g_AkhanEquipmentPosTypeName[EquipmentPos::PELVIS]         = CTypeName(EquipmentPos::PELVIS, (char*)GetMyINIString("STRING_FOR_LOCALIZE", "PELVIS"));
	//g_AkhanEquipmentPosTypeName[EquipmentPos::ACCESSORY1]     = CTypeName(EquipmentPos::ACCESSORY1, (char*)GetMyINIString("STRING_FOR_LOCALIZE", "ACCESSORY1"));
	//g_AkhanEquipmentPosTypeName[EquipmentPos::ACCESSORY2]     = CTypeName(EquipmentPos::ACCESSORY2, (char*)GetMyINIString("STRING_FOR_LOCALIZE", "ACCESSORY2"));
	//g_AkhanEquipmentPosTypeName[EquipmentPos::ACCESSORY3]     = CTypeName(EquipmentPos::ACCESSORY3, (char*)GetMyINIString("STRING_FOR_LOCALIZE", "ACCESSORY3"));
    g_AkhanEquipmentPosTypeName[EquipmentPos::SKILL_ARM]      = CTypeName(EquipmentPos::SKILL_ARM, (char*)GetMyINIString("STRING_FOR_LOCALIZE", "SKILL_ARM"));

    g_PositionName[TakeType::TS_NONE]       = CTypeName(TakeType::TS_NONE, (char*)GetMyINIString("STRING_FOR_LOCALIZE", "TS_NONE"));
    g_PositionName[TakeType::TS_EQUIP]      = CTypeName(TakeType::TS_EQUIP, (char*)GetMyINIString("STRING_FOR_LOCALIZE", "TS_EQUIP"));
    g_PositionName[TakeType::TS_INVEN]      = CTypeName(TakeType::TS_INVEN, (char*)GetMyINIString("STRING_FOR_LOCALIZE", "TS_INVEN"));
    g_PositionName[TakeType::TS_QSLOT]      = CTypeName(TakeType::TS_QSLOT, (char*)GetMyINIString("STRING_FOR_LOCALIZE", "TS_QSLOT"));
    g_PositionName[TakeType::TS_SSLOT]      = CTypeName(TakeType::TS_SSLOT, (char*)GetMyINIString("STRING_FOR_LOCALIZE", "TS_SSLOT"));
    g_PositionName[TakeType::TS_TEMP]       = CTypeName(TakeType::TS_TEMP, (char*)GetMyINIString("STRING_FOR_LOCALIZE", "TS_TEMP"));
	g_PositionName[TakeType::TS_TEMPINVEN]	= CTypeName(TakeType::TS_TEMPINVEN, (char*)GetMyINIString("STRING_FOR_LOCALIZE", "TS_TEMPINVEN"));
	g_PositionName[TakeType::TS_EXTRA]		= CTypeName(TakeType::TS_EXTRA, (char*)GetMyINIString("STRING_FOR_LOCALIZE", "TS_EXTRA"));
    g_PositionName[TakeType::TS_EXCHANGE]   = CTypeName(TakeType::TS_EXCHANGE, (char*)GetMyINIString("STRING_FOR_LOCALIZE", "TS_EXCHANGE"));
    g_PositionName[TakeType::TS_DEPOSIT]    = CTypeName(TakeType::TS_DEPOSIT, (char*)GetMyINIString("STRING_FOR_LOCALIZE", "TS_DEPOSIT"));
    
    return true;
}


void SimpleInfo::BaseLog(CString& Result, const sLogBase* lpLogBase, const DWORD dwLogType)
{
	if(dwLogType & GAMELOG::UID) 
    { 
        Result.AppendFormat("[UID:%10u]", lpLogBase->m_dwUID);
    }

	if(dwLogType & GAMELOG::CID) 
    { 
        Result.AppendFormat("[CID:%10u]", lpLogBase->m_dwCID); 
    }

	if(dwLogType & GAMELOG::TIME) 
	{
        struct tm* pTm = localtime(&lpLogBase->m_time);

		Result.AppendFormat("[%4d/%02d/%02d %02d:%02d:%02d]", 
            pTm->tm_year + 1900, pTm->tm_mon + 1, pTm->tm_mday,
            pTm->tm_hour, pTm->tm_min, pTm->tm_sec);
	}

	if(dwLogType & GAMELOG::POS)
	{
		Result.AppendFormat("[PosX:%5d PosY:%5d PosZ:%5d]", 
			lpLogBase->m_usXPos, lpLogBase->m_usYPos, lpLogBase->m_usZPos);
	}

	Result.AppendFormat("[Err:%u]", lpLogBase->m_cErr);	
}


int SimpleInfo::PositionToString(char* lpBuffer_Out, 
                                 const int nBufferSize, 
                                 const Item::ItemPos itemPos)
{
	int nLength = 0;

    const char* szString = 0;
    bool bArrayContainer = false;
	bool bExtraPosition  = false;

	switch(itemPos.m_cPos)
	{
	case TakeType::TS_NONE:
		szString = GetMyINIString("STRING_FOR_LOCALIZE", "FORMAT_052");
		break;

	case TakeType::TS_QSLOT:
		szString = GetMyINIString("STRING_FOR_LOCALIZE", "FORMAT_053");
		break;

	case TakeType::TS_SSLOT:
		szString = GetMyINIString("STRING_FOR_LOCALIZE", "FORMAT_054");
		break;

	case TakeType::TS_TEMP:
		szString = GetMyINIString("STRING_FOR_LOCALIZE", "FORMAT_055");
		break;

	case TakeType::TS_TEMPINVEN:
		szString = GetMyINIString("STRING_FOR_LOCALIZE", "FORMAT_066");
		break;

	case TakeType::TS_EXTRA:
		szString = GetMyINIString("STRING_FOR_LOCALIZE", "FORMAT_056");
		bExtraPosition = true;
		break;

	case TakeType::TS_INVEN:
		szString = GetMyINIString("STRING_FOR_LOCALIZE", "FORMAT_057");
        bArrayContainer = true;
		break;

	case TakeType::TS_EXCHANGE:
        szString = GetMyINIString("STRING_FOR_LOCALIZE", "FORMAT_058");
        bArrayContainer = true;
		break;

    case TakeType::TS_DEPOSIT:
        szString = GetMyINIString("STRING_FOR_LOCALIZE", "FORMAT_059");
        bArrayContainer = true;
		break;

    case TakeType::TS_STALL:
        szString = GetMyINIString("STRING_FOR_LOCALIZE", "FORMAT_060");
        bArrayContainer = true;
        break;

	case TakeType::TS_EQUIP:
		
		if(itemPos.m_cIndex < Item::EquipmentPos::MAX_EQUPMENT_POS)
		{
			nLength = _snprintf(lpBuffer_Out, nBufferSize - 1, GetMyINIString("STRING_FOR_LOCALIZE", "FORMAT_061"), 
				g_HumanEquipmentPosTypeName[itemPos.m_cIndex].GetTypeName());
		}
		else
		{
			nLength = _snprintf(lpBuffer_Out, nBufferSize - 1, GetMyINIString("STRING_FOR_LOCALIZE", "FORMAT_062"), itemPos.m_cIndex);
		}		
		break;

    default:
		szString = GetMyINIString("STRING_FOR_LOCALIZE", "FORMAT_051");
		break;
	};


    if(szString)
    {
        if(bArrayContainer)
        {
		    nLength = _snprintf(lpBuffer_Out, nBufferSize - 1, szString, 
                itemPos.GetXIndex(), itemPos.GetYIndex(), itemPos.GetZIndex());
        }
		else if(bExtraPosition)
		{
			nLength = _snprintf(lpBuffer_Out, nBufferSize - 1, szString,
				GetExtraPosString(itemPos.m_cIndex));
		}
        else
        {
    		nLength = _snprintf(lpBuffer_Out, nBufferSize - 1, szString, itemPos.m_cIndex);
        }
    };

    lpBuffer_Out[nBufferSize - 1] = 0;
	return nLength;
}


const char* SimpleInfo::GetPositionName(unsigned char cPos)
{
    const char* szPositionString = GetMyINIString("STRING_FOR_LOCALIZE", "UNKNOWN_POS");

    if(cPos < TakeType::TS_MAXTYPE)
    {
        const char* szResult = g_PositionName[cPos].GetTypeName();

        if(0 != szResult)
        {
            szPositionString = szResult;
        }
    }

    return szPositionString;
}

const char* SimpleInfo::GetExtraPosString(unsigned char cIndex)
{
	const char* szKey = 0;

	switch(cIndex)
	{
	case Item::ExtraSpacePos::UPGRADE_EQUIPMENT_POS:	szKey = "UPGRADE_EQUIPMENT_POS";	break;
	case Item::ExtraSpacePos::UPGRADE_MATERIAL_POS:		szKey = "UPGRADE_MATERIAL_POS";		break;
	case Item::ExtraSpacePos::HOLDITEM_POS:				szKey = "HOLDITEM_POS";				break;
	case Item::ExtraSpacePos::KIT_MATERIAL_POS:			szKey = "KIT_MATERIAL_POS";			break;
	case Item::ExtraSpacePos::CAMP_MATERIAL_POS:		szKey = "CAMP_MATERIAL_POS";		break;
	case Item::ExtraSpacePos::EMBLEM_JEWEL_POS1:		szKey = "EMBLEM_JEWEL_POS1";		break;
	case Item::ExtraSpacePos::EMBLEM_JEWEL_POS2:		szKey = "EMBLEM_JEWEL_POS2";		break;
	case Item::ExtraSpacePos::EMBLEM_JEWEL_POS3:		szKey = "EMBLEM_JEWEL_POS3";		break;
	case Item::ExtraSpacePos::EMBLEM_JEWEL_POS4:		szKey = "EMBLEM_JEWEL_POS4";		break;
	case Item::ExtraSpacePos::EMBLEM_JEWEL_POS5:		szKey = "EMBLEM_JEWEL_POS5";		break;
	case Item::ExtraSpacePos::EMBLEM_JEWEL_POS6:		szKey = "EMBLEM_JEWEL_POS6";		break;
	case Item::ExtraSpacePos::EMBLEM_JEWEL_POS7:		szKey = "EMBLEM_JEWEL_POS7";		break;
	case Item::ExtraSpacePos::EMBLEM_JEWEL_POS8:		szKey = "EMBLEM_JEWEL_POS8";		break;
	case Item::ExtraSpacePos::EMBLEM_JEWEL_POS9:		szKey = "EMBLEM_JEWEL_POS9";		break;
	case Item::ExtraSpacePos::GRAFT_ORIGINAL_POS:		szKey = "GRAFT_ORIGINAL_POS";		break;
	case Item::ExtraSpacePos::GRAFT_SACRIFICE_POS:		szKey = "GRAFT_SACRIFICE_POS";		break;
	case Item::ExtraSpacePos::GRAFT_RESULT_POS:			szKey = "GRAFT_RESULT_POS";			break;
	case Item::ExtraSpacePos::COMPENSATION_POS:			szKey = "COMPENSATION_POS";			break;
	default:											szKey = "UNKNOWN_POS";				break;
	}
	
	return GetMyINIString("STRING_FOR_LOCALIZE", szKey);
}


// ---------------------------------------------------------------------------------------------
// ij¸¯ÅÍ °ü·Ã ·Î±× Ãâ·Â

void SimpleInfo::CharLogin(CString& Result, const sLogBase* lpLogBase)
{
	const GAMELOG::sCharLoginOut* pCharLoginOut = 
		static_cast<const GAMELOG::sCharLoginOut*>(lpLogBase);


	unsigned short	usUpdateInfo[DBUpdateData::MAX_UPDATE_DB];
	std::copy(&pCharLoginOut->m_usDataSize[0],
		&pCharLoginOut->m_usDataSize[DBUpdateData::MAX_UPDATE_DB],
		usUpdateInfo);

    size_t nSize = std::accumulate(&usUpdateInfo[0], &usUpdateInfo[DBUpdateData::MAX_UPDATE_DB], 0);
	char szCharacterInfo[DBUpdateData::MAX_DBUPDATE_SIZE];
    memcpy(szCharacterInfo, reinterpret_cast<const char*>(&pCharLoginOut[1]), nSize);

    CHAR_INFOST* pCharInfoSt = reinterpret_cast<CHAR_INFOST*>(szCharacterInfo 
		+ std::accumulate(&usUpdateInfo[0], &usUpdateInfo[DBUpdateData::STATUS_UPDATE], 0));

//	pCharInfoSt->Race

	SOCKADDR_IN sockAddr;
	sockAddr.sin_addr.S_un.S_addr = pCharLoginOut->m_nIP;

	Result.Append(" ");
	Result.AppendFormat(GetMyINIString("STRING_FOR_LOCALIZE", "FORMAT_004"),
		pCharInfoSt->Race, inet_ntoa(sockAddr.sin_addr), ntohs(pCharLoginOut->m_usPort));
}

void SimpleInfo::CharLogout(CString& Result, const sLogBase* lpLogBase)
{
	const GAMELOG::sCharLoginOut* pCharLoginOut = 
		static_cast<const GAMELOG::sCharLoginOut*>(lpLogBase);

	SOCKADDR_IN sockAddr;	
	sockAddr.sin_addr.S_un.S_addr = pCharLoginOut->m_nIP;

	Result.Append(" ");
    Result.AppendFormat(GetMyINIString("STRING_FOR_LOCALIZE", "FORMAT_005"),
		inet_ntoa(sockAddr.sin_addr), ntohs(pCharLoginOut->m_usPort));
}

void SimpleInfo::CharCreate(CString& Result, const sLogBase* lpLogBase)
{
    const GAMELOG::sCharCreateDelete* lpCharCreateDelete = 
        static_cast<const GAMELOG::sCharCreateDelete*>(lpLogBase);

    SOCKADDR_IN sockAddr;	
    sockAddr.sin_addr.S_un.S_addr = lpCharCreateDelete->m_nIP;

	Result.Append(" ");
    Result.AppendFormat(GetMyINIString("STRING_FOR_LOCALIZE", "FORMAT_006"),
        inet_ntoa(sockAddr.sin_addr), ntohs(lpCharCreateDelete->m_usPort));
}

void SimpleInfo::CharDelete(CString& Result, const sLogBase* lpLogBase)
{
    const GAMELOG::sCharCreateDelete* lpCharCreateDelete = 
        static_cast<const GAMELOG::sCharCreateDelete*>(lpLogBase);

    SOCKADDR_IN sockAddr;	
    sockAddr.sin_addr.S_un.S_addr = lpCharCreateDelete->m_nIP;

	Result.Append(" ");
    Result.AppendFormat(GetMyINIString("STRING_FOR_LOCALIZE", "FORMAT_007"),
        inet_ntoa(sockAddr.sin_addr), ntohs(lpCharCreateDelete->m_usPort));	
}

void SimpleInfo::CharDBUpdate(CString& Result, const sLogBase* lpLogBase)
{
	Result.Append(" ");
	Result.AppendFormat(GetMyINIString("STRING_FOR_LOCALIZE", "FORMAT_008"));
}


void SimpleInfo::CharLevelUp(CString& Result, const sLogBase* lpLogBase)
{
	const sCharLevelUpLog* pCharLevelUpLog = static_cast<const sCharLevelUpLog*>(lpLogBase);

	Result.Append(" ");
	Result.AppendFormat(GetMyINIString("STRING_FOR_LOCALIZE", "FORMAT_009"), 
		pCharLevelUpLog->m_cLevel, pCharLevelUpLog->m_usIP);
}

void SimpleInfo::CharBindPos(CString& Result, const sLogBase* lpLogBase)
{
	Result.Append(" ");
	Result.AppendFormat(GetMyINIString("STRING_FOR_LOCALIZE", "FORMAT_010"),
		lpLogBase->m_usXPos, lpLogBase->m_usYPos, lpLogBase->m_usZPos);
}

void SimpleInfo::CharDead(CString& Result, const sLogBase* lpLogBase)
{
	const sCharDeadLog* pCharDeadLog = 
        static_cast<const sCharDeadLog*>(lpLogBase);

	Result.Append(" ");
    Result.AppendFormat(GetMyINIString("STRING_FOR_LOCALIZE", "FORMAT_011"),
		pCharDeadLog->m_cLevel, pCharDeadLog->m_dwAttackerCID,
        pCharDeadLog->m_nPrevExp,
        pCharDeadLog->m_nNextExp, 
        pCharDeadLog->m_nPrevExp - pCharDeadLog->m_nNextExp);
}
		
void SimpleInfo::CharRespawn(CString& Result, const sLogBase* lpLogBase)
{
	const sCharRespawnLog* pCharRespawnLog = 
        static_cast<const sCharRespawnLog*>(lpLogBase);

	Result.Append(" ");
	Result.AppendFormat(GetMyINIString("STRING_FOR_LOCALIZE", "FORMAT_012"),
		lpLogBase->m_usXPos, lpLogBase->m_usYPos, lpLogBase->m_usZPos,
        pCharRespawnLog->m_nPrevExp, pCharRespawnLog->m_nNextExp,
        pCharRespawnLog->m_nPrevExp -  pCharRespawnLog->m_nNextExp);
}





// ---------------------------------------------------------------------------------------------
// ¾ÆÀÌÅÛ °ü·Ã ·Î±× Ãâ·Â

void SimpleInfo::MoveItem(CString& Result, const sLogBase* lpLogBase)
{
	const sMoveItemLog* lpMoveItemLog = static_cast<const sMoveItemLog*>(lpLogBase);
	const TakeType&		takeType = lpMoveItemLog->m_takeType;

	char szSrc[MIN_BUFFER];
    char szDst[MIN_BUFFER];

	PositionToString(szSrc, MIN_BUFFER, takeType.m_srcPos);
	PositionToString(szDst, MIN_BUFFER, takeType.m_dstPos);

	Result.Append(" ");
    Result.AppendFormat(GetMyINIString("STRING_FOR_LOCALIZE", "FORMAT_013"),
        lpMoveItemLog->m_itemInfo.m_dwItemUID,
        lpMoveItemLog->m_itemInfo.m_usProtoTypeID,
        GetItemName(lpMoveItemLog->m_itemInfo.m_usProtoTypeID), 
        szSrc, szDst, lpMoveItemLog->m_itemInfo.m_cNowDurability);
}

void SimpleInfo::SwapItem(CString& Result, const sLogBase* lpLogBase)
{
	const sSwapItemLog* lpSwapItemLog = static_cast<const sSwapItemLog*>(lpLogBase);
	const TakeType&		takeSrc = lpSwapItemLog->m_srcTake;
	const TakeType&		takeDst = lpSwapItemLog->m_dstTake;

    char szSrcSrc[MIN_BUFFER], szSrcDst[MIN_BUFFER];
	char szDstSrc[MIN_BUFFER], szDstDst[MIN_BUFFER];

	PositionToString(szSrcSrc, MIN_BUFFER, takeSrc.m_srcPos);
	PositionToString(szSrcDst, MIN_BUFFER, takeSrc.m_dstPos);
	PositionToString(szDstSrc, MIN_BUFFER, takeDst.m_srcPos);
	PositionToString(szDstDst, MIN_BUFFER, takeDst.m_dstPos);

	Result.Append(" ");
    Result.AppendFormat(GetMyINIString("STRING_FOR_LOCALIZE", "FORMAT_014"), 
        lpSwapItemLog->m_srcItemInfo.m_dwItemUID,
        lpSwapItemLog->m_srcItemInfo.m_usProtoTypeID, 
        GetItemName(lpSwapItemLog->m_srcItemInfo.m_usProtoTypeID),        
        szSrcSrc, szSrcDst, lpSwapItemLog->m_srcItemInfo.m_cNowDurability, 
        
        lpSwapItemLog->m_dstItemInfo.m_dwItemUID,
        lpSwapItemLog->m_dstItemInfo.m_usProtoTypeID, 
        GetItemName(lpSwapItemLog->m_dstItemInfo.m_usProtoTypeID),        
        szDstSrc, szDstDst, lpSwapItemLog->m_dstItemInfo.m_cNowDurability);	
}


void SimpleInfo::UseItem(CString& Result, const sLogBase* lpLogBase)
{
	const sUseItemLog* lpUseItemLog = static_cast<const sUseItemLog*>(lpLogBase);

	char szUseIndex[MIN_BUFFER];
    PositionToString(szUseIndex, MIN_BUFFER, lpUseItemLog->m_usePos);

	char szUID[MIN_BUFFER];
	Math::Convert::Hex64ToStr(szUID, lpUseItemLog->m_itemInfo.m_dwItemUID);

	Result.Append(" ");
    Result.AppendFormat(GetMyINIString("STRING_FOR_LOCALIZE", "FORMAT_015"), 
		lpUseItemLog->m_itemInfo.m_dwItemUID,
        lpUseItemLog->m_itemInfo.m_usProtoTypeID,
        GetItemName(lpUseItemLog->m_itemInfo.m_usProtoTypeID),
        szUseIndex, lpUseItemLog->m_itemInfo.m_cNowDurability);
}

void SimpleInfo::SplitItem(CString& Result, const sLogBase* lpLogBase)
{
	const sSplitItemLog* lpSplitItemLog = static_cast<const sSplitItemLog*>(lpLogBase);
	const TakeType&		 takeType = lpSplitItemLog->m_splitTake;

	char szSplitSrc[MIN_BUFFER], szSplitDst[MIN_BUFFER];
	PositionToString(szSplitSrc, MIN_BUFFER, takeType.m_srcPos);
	PositionToString(szSplitDst, MIN_BUFFER, takeType.m_dstPos);

	Result.Append(" ");
    Result.AppendFormat(GetMyINIString("STRING_FOR_LOCALIZE", "FORMAT_016"),	
        lpSplitItemLog->m_prevItem.m_dwItemUID,
        lpSplitItemLog->m_prevItem.m_usProtoTypeID,
        GetItemName(lpSplitItemLog->m_prevItem.m_usProtoTypeID),
        szSplitSrc, szSplitDst, takeType.m_cNum);
}


void SimpleInfo::PickupItem(CString& Result, const sLogBase* lpLogBase)
{
	const sPickupItemLog* lpPickupItemLog = static_cast<const sPickupItemLog*>(lpLogBase);
	
	char szPickupIndex[MIN_BUFFER];
	PositionToString(szPickupIndex, MIN_BUFFER, lpPickupItemLog->m_itemPos);

	if(0 != lpPickupItemLog->m_dwGold)
	{                             
		Result.Append(" ");
		
		std::string szMoney = GetMoneyString(lpPickupItemLog->m_dwGold);

		Result.AppendFormat(GetMyINIString("STRING_FOR_LOCALIZE", "FORMAT_017"), szMoney.c_str());
	}
	else if(0 == lpLogBase->m_cErr)
	{
        size_t nItemSize = Item::MAX_ITEM_SIZE;
        
        Item::CItem* lpItem = Item::CItemFactory::GetInstance().CreateItem(
            (const char*)lpPickupItemLog + sizeof(sPickupItemLog), nItemSize);

        if(0 != lpItem)
        {
			Result.Append(" ");
            Result.AppendFormat(GetMyINIString("STRING_FOR_LOCALIZE", "FORMAT_018"),
                lpItem->GetUID(), lpItem->GetPrototypeID(), GetItemName(lpItem->GetPrototypeID()),
                szPickupIndex, lpItem->GetNumOrDurability());

            DELETE_ITEM(lpItem)
        }
	}
	else
	{
		Result.Append(" ");
        Result.AppendFormat(GetMyINIString("STRING_FOR_LOCALIZE", "FORMAT_019"), szPickupIndex);
	}
}

void SimpleInfo::UseLottery(CString& Result, const sLogBase* lpLogBase)
{
	const sUseLotteryLog* lpUseLotteryLog = static_cast<const sUseLotteryLog*>(lpLogBase);

	char szUID[MIN_BUFFER];
	Math::Convert::Hex64ToStr(szUID, lpUseLotteryLog->m_itemInfo.m_dwItemUID);

	Result.Append(" ");
    Result.AppendFormat(GetMyINIString("STRING_FOR_LOCALIZE", "FORMAT_095"), 
		lpUseLotteryLog->m_itemInfo.m_dwItemUID,
        lpUseLotteryLog->m_itemInfo.m_usProtoTypeID,
        GetItemName(lpUseLotteryLog->m_itemInfo.m_usProtoTypeID),
        lpUseLotteryLog->m_itemInfo.m_cNowDurability);
}


void SimpleInfo::DropItem(CString& Result, const sLogBase* lpLogBase)
{
	const sDropItemLog* pDropItemLog = static_cast<const sDropItemLog*>(lpLogBase);
	
	char szDropIndex[MIN_BUFFER];
	PositionToString(szDropIndex, MIN_BUFFER, pDropItemLog->m_itemPos);

	if(0 != pDropItemLog->m_dwGold)
	{
		Result.Append(" ");

		std::string szMoney = GetMoneyString(pDropItemLog->m_dwGold);

		Result.AppendFormat(GetMyINIString("STRING_FOR_LOCALIZE", "FORMAT_020"), szMoney.c_str());
	}
	else if(0 == pDropItemLog->m_cErr)
	{
        size_t nItemSize = Item::MAX_ITEM_SIZE;

        Item::CItem* lpItem = Item::CItemFactory::GetInstance().CreateItem(
            (const char*)pDropItemLog + sizeof(sDropItemLog), nItemSize);

        if(0 != lpItem)
        {
			Result.Append(" ");
            Result.AppendFormat(GetMyINIString("STRING_FOR_LOCALIZE", "FORMAT_021"),
                lpItem->GetUID(), lpItem->GetPrototypeID(), GetItemName(lpItem->GetPrototypeID()), 
                szDropIndex, lpItem->GetNumOrDurability());

            DELETE_ITEM(lpItem)
        }
	}
	else
	{
		Result.Append(" ");
        Result.AppendFormat(GetMyINIString("STRING_FOR_LOCALIZE", "FORMAT_022"), szDropIndex);
	}
}


void SimpleInfo::SellItem(CString& Result, const sLogBase* lpLogBase)
{
	const sTradeItemLog* pTradeItemLog = static_cast<const sTradeItemLog*>(lpLogBase);

	char szTradeIndex[MIN_BUFFER];
	PositionToString(szTradeIndex, MIN_BUFFER, pTradeItemLog->m_itemPos);

	if(0 == lpLogBase->m_cErr)
	{
        size_t nItemSize = Item::MAX_ITEM_SIZE;

        Item::CItem* lpItem = Item::CItemFactory::GetInstance().CreateItem(
            (const char*)pTradeItemLog + sizeof(sTradeItemLog), nItemSize);

        if(0 != lpItem)
        {
			std::string szMoney = GetMoneyString(pTradeItemLog->m_dwGold);
			std::string szSellMoney = GetMoneyString(lpItem->GetSellPrice());


			Result.Append(" ");
            Result.AppendFormat(GetMyINIString("STRING_FOR_LOCALIZE", "FORMAT_023"),
                lpItem->GetUID(), lpItem->GetPrototypeID(), GetItemName(lpItem->GetPrototypeID()), 
                szTradeIndex, pTradeItemLog->m_dwTraderCID, 
				szMoney.c_str(), szSellMoney.c_str());

            DELETE_ITEM(lpItem)
        }
	}
	else
	{
		std::string szMoney = GetMoneyString(pTradeItemLog->m_dwGold);

		Result.Append(" ");
        Result.AppendFormat(GetMyINIString("STRING_FOR_LOCALIZE", "FORMAT_024"),
			szTradeIndex, szMoney.c_str());
	}
}


void SimpleInfo::BuyItem(CString& Result, const sLogBase* lpLogBase)
{
	const sTradeItemLog* pTradeItemLog = static_cast<const sTradeItemLog*>(lpLogBase);

	char szTradeIndex[MIN_BUFFER];
	PositionToString(szTradeIndex, MIN_BUFFER, pTradeItemLog->m_itemPos);

	if(0 == lpLogBase->m_cErr)
	{
        size_t nItemSize = Item::MAX_ITEM_SIZE;

        Item::CItem* lpItem = Item::CItemFactory::GetInstance().CreateItem(
            (const char*)pTradeItemLog + sizeof(sTradeItemLog), nItemSize);

        if(0 != lpItem)
        {            
			std::string szMoney = GetMoneyString(pTradeItemLog->m_dwGold);
			std::string szBuyMoney = GetMoneyString(lpItem->GetBuyPrice());

			Result.Append(" ");
            Result.AppendFormat(GetMyINIString("STRING_FOR_LOCALIZE", "FORMAT_025"),
                lpItem->GetUID(), lpItem->GetPrototypeID(), GetItemName(lpItem->GetPrototypeID()),
                szTradeIndex, pTradeItemLog->m_dwTraderCID,
				szMoney.c_str(), szBuyMoney.c_str());

            DELETE_ITEM(lpItem)
        }
	}
	else
	{
		std::string szMoney = GetMoneyString(pTradeItemLog->m_dwGold);

		Result.Append(" ");
        Result.AppendFormat(GetMyINIString("STRING_FOR_LOCALIZE", "FORMAT_026"),
			szTradeIndex, szMoney.c_str());
	}
}

void SimpleInfo::MedalItemBuy(CString& Result, const sLogBase* lpLogBase)
{
    const sTradeItemLog* pTradeItemLog = static_cast<const sTradeItemLog*>(lpLogBase);

    char szTradeIndex[MIN_BUFFER];
    PositionToString(szTradeIndex, MIN_BUFFER, pTradeItemLog->m_itemPos);

    if(0 == lpLogBase->m_cErr)
    {
        size_t nItemSize = Item::MAX_ITEM_SIZE;

        Item::CItem* lpItem = Item::CItemFactory::GetInstance().CreateItem(
            (const char*)pTradeItemLog + sizeof(sTradeItemLog), nItemSize);

        if(0 != lpItem)
        {
			std::string szMoney = GetMoneyString(pTradeItemLog->m_dwGold);
			std::string szBuyMoney = GetMoneyString(lpItem->GetBuyPrice());

			Result.Append(" ");
            Result.AppendFormat(GetMyINIString("STRING_FOR_LOCALIZE", "FORMAT_027"),
                lpItem->GetUID(), lpItem->GetPrototypeID(), GetItemName(lpItem->GetPrototypeID()), 
                pTradeItemLog->m_dwTraderCID, szTradeIndex,
				szMoney.c_str(), szBuyMoney.c_str());

            DELETE_ITEM(lpItem)
        }
    }
    else
    {
		std::string szMoney = GetMoneyString(pTradeItemLog->m_dwGold);

		Result.Append(" ");
        Result.AppendFormat(GetMyINIString("STRING_FOR_LOCALIZE", "FORMAT_026"),
			szTradeIndex, szMoney.c_str());
    }
}


void SimpleInfo::BeforeExchange(CString& Result, const sLogBase* lpLogBase)
{
	const sExchangeItemLog* pExchangeItemLog = static_cast<const sExchangeItemLog*>(lpLogBase);

	std::string szMoney = GetMoneyString(pExchangeItemLog->m_dwGold);

	Result.Append(" ");
    Result.AppendFormat(GetMyINIString("STRING_FOR_LOCALIZE", "FORMAT_028"), 
		pExchangeItemLog->m_dwDstCID, szMoney.c_str());
}

void SimpleInfo::AfterExchange(CString& Result, const sLogBase* lpLogBase)
{	
	const sExchangeItemLog* pExchangeItemLog = static_cast<const sExchangeItemLog*>(lpLogBase);

	std::string szMoney = GetMoneyString(pExchangeItemLog->m_dwGold);

	Result.Append(" ");
    Result.AppendFormat(GetMyINIString("STRING_FOR_LOCALIZE", "FORMAT_029"), 
		pExchangeItemLog->m_dwDstCID, szMoney.c_str());
}


void SimpleInfo::InstallSocketItem(CString& Result, const sLogBase* lpLogBase)
{
	const sInstallSocketLog* pInstallSocketLog = 
		static_cast<const sInstallSocketLog*>(lpLogBase);

	char szGemIndex[MIN_BUFFER];
	char szEquipIndex[MIN_BUFFER];

	PositionToString(szGemIndex, MIN_BUFFER, pInstallSocketLog->m_GemAndEquip.m_srcPos);
	PositionToString(szEquipIndex, MIN_BUFFER, pInstallSocketLog->m_GemAndEquip.m_dstPos);
    

    size_t nItemSize = Item::MAX_ITEM_SIZE;
    Item::CItem* lpGem = Item::CItemFactory::GetInstance().CreateItem(
        (const char*)pInstallSocketLog + sizeof(sInstallSocketLog), nItemSize);

    if(0 != lpGem)
    {
        size_t nGemSize = reinterpret_cast<const Item::ItemData*>(
            (const char*)pInstallSocketLog + sizeof(sInstallSocketLog))->m_cItemSize;

        nItemSize = Item::MAX_ITEM_SIZE;

        Item::CItem* lpEquip = Item::CItemFactory::GetInstance().CreateItem(
            (const char*)pInstallSocketLog + sizeof(sInstallSocketLog) + nGemSize, nItemSize);

        if(0 != lpEquip)
        {
			Result.Append(" ");
            Result.AppendFormat(GetMyINIString("STRING_FOR_LOCALIZE", "FORMAT_030"),
                lpGem->GetUID(), lpGem->GetPrototypeID(), GetItemName(lpGem->GetPrototypeID()), szGemIndex,
                lpEquip->GetUID(), lpEquip->GetPrototypeID(), GetItemName(lpEquip->GetPrototypeID()), szEquipIndex);
		        
            DELETE_ITEM(lpEquip);
        }

        DELETE_ITEM(lpGem);
    }
}


void SimpleInfo::RepairItem(CString& Result, const sLogBase* lpLogBase)
{
    const sRepairItemLog* lpRepairItemLog = static_cast<const sRepairItemLog*>(lpLogBase);

	std::string szMoney = GetMoneyString(lpRepairItemLog->m_dwUsed);

	Result.Append(" ");
    Result.AppendFormat(GetMyINIString("STRING_FOR_LOCALIZE", "FORMAT_031"),
        lpRepairItemLog->m_RepairedItem.m_dwItemUID, 
        lpRepairItemLog->m_RepairedItem.m_usProtoTypeID, 
        GetItemName(lpRepairItemLog->m_RepairedItem.m_usProtoTypeID),        
        lpRepairItemLog->m_cPreRepairDurability,
        lpRepairItemLog->m_RepairedItem.m_cNowDurability,
		szMoney.c_str());
}


void SimpleInfo::ChangeWeapon(CString& Result, const sLogBase* lpLogBase)
{
    const sChangeWeaponLog* lpChangeWeaponLog = static_cast<const sChangeWeaponLog*>(lpLogBase);

	Result.Append(" ");
    Result.AppendFormat(GetMyINIString("STRING_FOR_LOCALIZE", "FORMAT_032"), lpChangeWeaponLog->m_cCurrentHand);
}

void SimpleInfo::ChangeRide(CString& Result, const sLogBase* lpLogBase)
{
    const sChangeRideLog* lpChangeRideLog = static_cast<const sChangeRideLog*>(lpLogBase);

	Result.Append(" ");
    Result.AppendFormat(GetMyINIString("STRING_FOR_LOCALIZE", "FORMAT_081"), lpChangeRideLog->m_cCurrentRide);
}

void SimpleInfo::IllegalItem(CString& Result, const sLogBase* lpLogBase)
{
	const sIllegalItemLog* lpIllegalItemLog = static_cast<const sIllegalItemLog*>(lpLogBase);

	char szUseIndex[MIN_BUFFER];
	PositionToString(szUseIndex, MIN_BUFFER, lpIllegalItemLog->m_usePos);

	Result.Append(" ");
	Result.AppendFormat(GetMyINIString("STRING_FOR_LOCALIZE", "FORMAT_082"), 
		lpIllegalItemLog->m_itemInfo.m_dwItemUID,
		lpIllegalItemLog->m_itemInfo.m_usProtoTypeID,
		GetItemName(lpIllegalItemLog->m_itemInfo.m_usProtoTypeID), 
		szUseIndex);
}

void SimpleInfo::IllegalWarpPos(CString& Result, const sLogBase* lpLogBase)
{
	const sIllegalWarpPosLog* lpIllegalWarpPosLog = static_cast<const sIllegalWarpPosLog*>(lpLogBase);

	Result.Append(" ");
	Result.AppendFormat(GetMyINIString("STRING_FOR_LOCALIZE", "FORMAT_083"), 
		lpLogBase->m_usXPos, lpLogBase->m_usYPos, lpLogBase->m_usZPos,
		lpIllegalWarpPosLog->m_usWarpXPos, lpIllegalWarpPosLog->m_usWarpYPos, lpIllegalWarpPosLog->m_usWarpZPos,
		lpIllegalWarpPosLog->m_lDis);
}

void SimpleInfo::HackDoubt(CString& Result, const sLogBase* lpLogBase)
{
	const sHockDoubtLog* lpHackDoubtLog = static_cast<const sHockDoubtLog*>(lpLogBase);

	Result.Append(" ");

	enum {
		HACK_BLACK_RANDOM = 0,		// ¾Ï½ÃÀå ¿À·ù : ·£´ý¿É¼Ç Àåºñ¸¦ ±¸ÀÔÇÏ°Ô Çß½À´Ï´Ù
		HACK_BLACK_NOTEXITSITEM,	// ¾Ï½ÃÀå ¿À·ù : Á¸ÀçÇÏÁö ¾Ê´Â ¾ÆÀÌÅÛÀÔ´Ï´Ù
		HACK_MILEAGE_RANDOM,		// ¸Þ´Þ»óÁ¡ ¿À·ù : ·£´ý¿É¼Ç Àåºñ¸¦ ±¸ÀÔÇÏ°Ô Çß½À´Ï´Ù
		HACK_MILEAGE_NOTEXITSITEM,	// ¸Þ´Þ»óÁ¡ ¿À·ù : Á¸ÀçÇÏÁö ¾Ê´Â ¾ÆÀÌÅÛÀÔ´Ï´Ù
		HACK_SHOP_NOTEXITSITEM,		// Àåºñ»ó ¿À·ù : Ãë±ÞÇÏÁö ¾Ê´Â ¾ÆÀÌÅÛÀ» ±¸¸ÅÇÕ´Ï´Ù.
		HACK_SHOP_NOEQUIP,			// Àåºñ»ó ¿À·ù : Àåºñ°¡ ¾Æ´Ñ ¾ÆÀÌÅÛÀ» ±¸¸ÅÇÏ·Á ÇÕ´Ï´Ù
		HACK_SHOP_NOTGRADEITEM,		// Àåºñ»ó ¿À·ù : ÆǸÅÇÏÁö ¾Ê´Â ±×·¹À̵åÀÇ ¾ÆÀÌÅÛÀ» ¿äûÇÏ¿´½À´Ï´Ù
		HACK_SHOP_NOFGRADEITEM,		// Àåºñ»ó ¿À·ù : F±×·¹À̵尡 ¾Æ´Ñ ¾ÆÀÌÅÛÀ» ¿äûÇÏ¿´½À´Ï´Ù
		HACK_SHOP_SOCKETITEM,		// Àåºñ»ó ¿À·ù : ±¸¸ÅÇÒ ¼ö ¾ø´Â ¼ÒÄÏÀÌ ÀÖ´Â ¾ÆÀÌÅÛÀ» ¿äûÇÏ¿´½À´Ï´Ù
		HACK_SHOP_OVERDURABILITY,	// Àåºñ»ó ¿À·ù : ³»±¸µµ°¡ 180 ÀÌ»óÀÎ ¾ÆÀÌÅÛÀÌ »ý¼ºµÇ¾ú½À´Ï´Ù.
	};

	switch(lpHackDoubtLog->m_wHackID)
	{
	case HACK_BLACK_RANDOM:		// ¾Ï½ÃÀå ¿À·ù : ·£´ý¿É¼Ç Àåºñ¸¦ ±¸ÀÔÇÏ°Ô Çß½À´Ï´Ù
		Result.AppendFormat(GetMyINIString("STRING_FOR_LOCALIZE", "FORMAT_084"), lpHackDoubtLog->m_wKindItem);
		break;
	case HACK_BLACK_NOTEXITSITEM:	// ¾Ï½ÃÀå ¿À·ù : Á¸ÀçÇÏÁö ¾Ê´Â ¾ÆÀÌÅÛÀÔ´Ï´Ù
		Result.AppendFormat(GetMyINIString("STRING_FOR_LOCALIZE", "FORMAT_085"), lpHackDoubtLog->m_wKindItem);
		break;
	case HACK_MILEAGE_RANDOM:		// ¸Þ´Þ»óÁ¡ ¿À·ù : ·£´ý¿É¼Ç Àåºñ¸¦ ±¸ÀÔÇÏ°Ô Çß½À´Ï´Ù
		Result.AppendFormat(GetMyINIString("STRING_FOR_LOCALIZE", "FORMAT_086"), lpHackDoubtLog->m_wKindItem);
		break;
	case HACK_MILEAGE_NOTEXITSITEM:	// ¸Þ´Þ»óÁ¡ ¿À·ù : Á¸ÀçÇÏÁö ¾Ê´Â ¾ÆÀÌÅÛÀÔ´Ï´Ù
		Result.AppendFormat(GetMyINIString("STRING_FOR_LOCALIZE", "FORMAT_087"), lpHackDoubtLog->m_wKindItem);
		break;
	case HACK_SHOP_NOTEXITSITEM:		// Àåºñ»ó ¿À·ù : Ãë±ÞÇÏÁö ¾Ê´Â ¾ÆÀÌÅÛÀ» ±¸¸ÅÇÕ´Ï´Ù.
		Result.AppendFormat(GetMyINIString("STRING_FOR_LOCALIZE", "FORMAT_088"), lpHackDoubtLog->m_wKindItem);
		break;
	case HACK_SHOP_NOEQUIP:			// Àåºñ»ó ¿À·ù : Àåºñ°¡ ¾Æ´Ñ ¾ÆÀÌÅÛÀ» ±¸¸ÅÇÏ·Á ÇÕ´Ï´Ù
		Result.AppendFormat(GetMyINIString("STRING_FOR_LOCALIZE", "FORMAT_089"), lpHackDoubtLog->m_wKindItem);
		break;
	case HACK_SHOP_NOTGRADEITEM:		// Àåºñ»ó ¿À·ù : ÆǸÅÇÏÁö ¾Ê´Â ±×·¹À̵åÀÇ ¾ÆÀÌÅÛÀ» ¿äûÇÏ¿´½À´Ï´Ù
		Result.AppendFormat(GetMyINIString("STRING_FOR_LOCALIZE", "FORMAT_090"), lpHackDoubtLog->m_wKindItem);
		break;
	case HACK_SHOP_NOFGRADEITEM:		// Àåºñ»ó ¿À·ù : F±×·¹À̵尡 ¾Æ´Ñ ¾ÆÀÌÅÛÀ» ¿äûÇÏ¿´½À´Ï´Ù
		Result.AppendFormat(GetMyINIString("STRING_FOR_LOCALIZE", "FORMAT_091"), lpHackDoubtLog->m_wKindItem);
		break;
	case HACK_SHOP_SOCKETITEM:		// Àåºñ»ó ¿À·ù : ±¸¸ÅÇÒ ¼ö ¾ø´Â ¼ÒÄÏÀÌ ÀÖ´Â ¾ÆÀÌÅÛÀ» ¿äûÇÏ¿´½À´Ï´Ù
		Result.AppendFormat(GetMyINIString("STRING_FOR_LOCALIZE", "FORMAT_092"), lpHackDoubtLog->m_wKindItem);
		break;
	case HACK_SHOP_OVERDURABILITY:	// Àåºñ»ó ¿À·ù : ³»±¸µµ°¡ 180 ÀÌ»óÀÎ ¾ÆÀÌÅÛÀÌ »ý¼ºµÇ¾ú½À´Ï´Ù.
		Result.AppendFormat(GetMyINIString("STRING_FOR_LOCALIZE", "FORMAT_093"), lpHackDoubtLog->m_wKindItem);
		break;
	}
}

void SimpleInfo::TakeGold(CString& Result, const sLogBase* lpLogBase)
{
    const sTakeGoldLog* lpTakeGoldLog = static_cast<const sTakeGoldLog*>(lpLogBase);

	std::string szMoney = GetMoneyString(lpTakeGoldLog->m_SrcGold);
	std::string szMoney2 = GetMoneyString(lpTakeGoldLog->m_DstGold);

	Result.Append(" ");
    Result.AppendFormat(GetMyINIString("STRING_FOR_LOCALIZE", "FORMAT_033"),
		GetPositionName(lpTakeGoldLog->m_cSrcPos), szMoney.c_str(), 
		GetPositionName(lpTakeGoldLog->m_cDstPos), szMoney2.c_str());
}

void SimpleInfo::TakeGoldV2(CString& Result, const sLogBase* lpLogBase)
{
    const sTakeGoldLogV2* lpTakeGoldLogV2 = static_cast<const sTakeGoldLogV2*>(lpLogBase);

	CString strMoveGoldPurpose;
	strMoveGoldPurpose.Format("MOVE_GOLD_PURPOSE_%02d", (int)lpTakeGoldLogV2->m_cPurpose);

	std::string szMoney1 = GetMoneyString(lpTakeGoldLogV2->m_SrcGold);
	std::string szMoney2 = GetMoneyString(lpTakeGoldLogV2->m_DstGold);
	std::string szMoney3 = GetMoneyString(lpTakeGoldLogV2->m_MoveGold);

	Result.Append(" ");
    Result.AppendFormat(GetMyINIString("STRING_FOR_LOCALIZE", "FORMAT_050"),
		GetPositionName(lpTakeGoldLogV2->m_cSrcPos), szMoney1.c_str(), 
        GetPositionName(lpTakeGoldLogV2->m_cDstPos), szMoney2.c_str(),
		szMoney3.c_str(), 
		GetMyINIString("STRING_FOR_LOCALIZE", strMoveGoldPurpose));
}

void SimpleInfo::UpgradeItem(CString& Result, const sLogBase* lpLogBase)
{
    const sUpgradeItemLog* lpUpgradeItemLog = static_cast<const sUpgradeItemLog*>(lpLogBase);

    if(0 == lpUpgradeItemLog->m_cErr)
    {
        size_t nMineralSize = Item::MAX_ITEM_SIZE;
        size_t nEquipSize = Item::MAX_ITEM_SIZE;

        if(0 != lpUpgradeItemLog->m_cMineralSize)
        {            
            Item::CItem* lpMineral = Item::CItemFactory::GetInstance().CreateItem(
                (const char*)lpUpgradeItemLog + sizeof(sUpgradeItemLog), nMineralSize);

            if(0 != lpMineral)
            {
                // MineralÀÌ ¾øÀ» ¼öµµ ÀÖ´Ù.

                DELETE_ITEM(lpMineral);
            }
        }

        if(0 != lpUpgradeItemLog->m_cEquipSize)
        {            
            Item::CItem* lpEquip = Item::CItemFactory::GetInstance().CreateItem(
                (const char*)lpUpgradeItemLog + sizeof(sUpgradeItemLog) + lpUpgradeItemLog->m_cMineralSize, nEquipSize);

            if(0 != lpEquip)
            {
                Item::CEquipment* lpEquipment = Item::CEquipment::DowncastToEquipment(lpEquip);
                if(0 != lpEquipment)
                {
					Result.Append(" ");
                    Result.AppendFormat(GetMyINIString("STRING_FOR_LOCALIZE", "FORMAT_034"),
                        GetItemName(lpEquipment->GetPrototypeID()), lpEquipment->GetPrototypeID(), lpEquipment->GetUpgradeLevel());                
                }
                else
                {
					Result.Append(" ");
                    Result.AppendFormat(GetMyINIString("STRING_FOR_LOCALIZE", "FORMAT_035"));
                }

                DELETE_ITEM(lpEquip);
            }
        }
    }
    else
    {
		Result.Append(" ");
        Result.AppendFormat(GetMyINIString("STRING_FOR_LOCALIZE", "FORMAT_036"));
    }    
}


void SimpleInfo::StallOpenClose(CString& Result, const sLogBase* lpLogBase)
{
    const sStallOpenCloseLog* lpStallOpenCloseLog = static_cast<const sStallOpenCloseLog*>(lpLogBase);

    char szStallName[sStallOpenCloseLog::MAX_STALL_NAME + 1];
    
    if(0 != lpStallOpenCloseLog->m_szStallName)
    {
        strncpy(szStallName, lpStallOpenCloseLog->m_szStallName, sStallOpenCloseLog::MAX_STALL_NAME);
    }
    else
    {
        strcpy(szStallName, GetMyINIString("STRING_FOR_LOCALIZE", "UNKNOWN_NAME"));
    }
    
    switch(lpStallOpenCloseLog->m_cMode)
    {
    case sStallOpenCloseLog::STALL_OPEN:
		Result.Append(" ");
        Result.AppendFormat(GetMyINIString("STRING_FOR_LOCALIZE", "FORMAT_037"), szStallName);
        break;

    case sStallOpenCloseLog::STALL_CLOSE:
		Result.Append(" ");
        Result.AppendFormat(GetMyINIString("STRING_FOR_LOCALIZE", "FORMAT_038"), szStallName);
        break;
    }
}

void SimpleInfo::StallEnterLeave(CString& Result, const sLogBase* lpLogBase)
{
    const sStallEnterLeaveLog* lpStallEnterLeaveLog = static_cast<const sStallEnterLeaveLog*>(lpLogBase);

    const char* szType = "????";
    
    switch(lpStallEnterLeaveLog->m_cMode)
    {
    case sStallEnterLeaveLog::STALL_ENTER:  
		szType = GetMyINIString("STRING_FOR_LOCALIZE", "ENTER");    
		break;
    case sStallEnterLeaveLog::STALL_LEAVE:  
		szType = GetMyINIString("STRING_FOR_LOCALIZE", "LEAVE");    
		break;
    }

	Result.Append(" ");
    Result.AppendFormat(GetMyINIString("STRING_FOR_LOCALIZE", "FORMAT_039"), szType, 
        lpStallEnterLeaveLog->m_dwCustomerCID, szType);

}

void SimpleInfo::StallRegisterRemoveItem(CString& Result, const sLogBase* lpLogBase)
{
    const sStallRegisterRemoveItemLog* lpStallRegisterRemoveItemLog = 
        static_cast<const sStallRegisterRemoveItemLog*>(lpLogBase);

    const char* szCmd = "????"; 

    switch(lpStallRegisterRemoveItemLog->m_cMode)
    {
    case sStallRegisterRemoveItemLog::STALL_REGISTERITEM:
        szCmd = GetMyINIString("STRING_FOR_LOCALIZE", "REGISTER");         break;

    case sStallRegisterRemoveItemLog::STALL_REMOVEITEM:
        szCmd = GetMyINIString("STRING_FOR_LOCALIZE", "REMOVE");         break;

    case sStallRegisterRemoveItemLog::STALL_CHANGEPRICE:
        szCmd = GetMyINIString("STRING_FOR_LOCALIZE", "CHANGE_PRICE");    break;
    }

    const TakeType takeType = lpStallRegisterRemoveItemLog->m_takeType;

    char szSrc[MIN_BUFFER], szDst[MIN_BUFFER];

    PositionToString(szSrc, MIN_BUFFER, takeType.m_srcPos);
    PositionToString(szDst, MIN_BUFFER, takeType.m_dstPos);

    char szUID[MIN_BUFFER];
    Math::Convert::Hex64ToStr(szUID, lpStallRegisterRemoveItemLog->m_itemInfo.m_dwItemUID);

    const char* szIsEquip = IsEquip(lpStallRegisterRemoveItemLog->m_itemInfo.m_usProtoTypeID) 
		? GetMyINIString("STRING_FOR_LOCALIZE", "DURABILITY") : GetMyINIString("STRING_FOR_LOCALIZE", "NUMS");

	std::string szMoney = GetMoneyString(lpStallRegisterRemoveItemLog->m_dwStallPrice);

	Result.Append(" ");
    Result.AppendFormat(GetMyINIString("STRING_FOR_LOCALIZE", "FORMAT_040"), 
        szCmd,
        GetItemName(lpStallRegisterRemoveItemLog->m_itemInfo.m_usProtoTypeID),
        lpStallRegisterRemoveItemLog->m_itemInfo.m_usProtoTypeID,        
        szUID, szSrc, szDst, 
		szMoney.c_str(), szCmd, szIsEquip,
        lpStallRegisterRemoveItemLog->m_itemInfo.m_cNowDurability);
}

// ±æµå »ý¼º        
void SimpleInfo::GuildCreate(CString& Result, const sLogBase* lpLogBase)
{
    const sGuildLog* lpGuildLog = static_cast<const sGuildLog*>(lpLogBase);

    unsigned long dwGuildGold = 0;

    if(sizeof(unsigned long) == lpGuildLog->m_usExtraDataSize)
    {
        dwGuildGold = *reinterpret_cast<const unsigned long*>(lpGuildLog + 1);
    }

	std::string szMoney = GetMoneyString(dwGuildGold);

	Result.Append(" ");
    Result.AppendFormat(GetMyINIString("STRING_FOR_LOCALIZE", "FORMAT_041"),
		GuildLogType(lpGuildLog->m_cType), lpGuildLog->m_dwGID, lpGuildLog->m_dwSrcCID, szMoney.c_str());
}


// ±æµå °¡ÀÔ
void SimpleInfo::GuildJoin(CString& Result, const sLogBase* lpLogBase)
{
    const sGuildLog* lpGuildLog = static_cast<const sGuildLog*>(lpLogBase);

    unsigned long dwFirstTitle = 0;

    if(sizeof(unsigned long) == lpGuildLog->m_usExtraDataSize)
    {
        dwFirstTitle = *reinterpret_cast<const unsigned long*>(lpGuildLog + 1);
    }

	Result.Append(" ");
    Result.AppendFormat(GetMyINIString("STRING_FOR_LOCALIZE", "FORMAT_042"),
        GuildLogType(lpGuildLog->m_cType), lpGuildLog->m_dwGID, lpGuildLog->m_dwSrcCID,  GuildTitle(dwFirstTitle));
}


// ±æµå Å»Åð
void SimpleInfo::GuildLeave(CString& Result, const sLogBase* lpLogBase)
{  
    const sGuildLog* lpGuildLog = static_cast<const sGuildLog*>(lpLogBase);

	Result.Append(" ");
    Result.AppendFormat(GetMyINIString("STRING_FOR_LOCALIZE", "FORMAT_043"),
        GuildLogType(lpGuildLog->m_cType), lpGuildLog->m_dwGID, lpGuildLog->m_dwSrcCID, lpGuildLog->m_dwDstCID);
}

// ±æµå¿ø µî±Þ º¯°æ
void SimpleInfo::GuildMemberLevelAdjust(CString& Result, const sLogBase* lpLogBase)
{
    const sGuildLog* lpGuildLog = static_cast<const sGuildLog*>(lpLogBase);

    unsigned long dwTitle = 0;

    if(sizeof(unsigned long) == lpGuildLog->m_usExtraDataSize)
    {
        dwTitle = *reinterpret_cast<const unsigned long*>(lpGuildLog + 1);
    }

	Result.Append(" ");
    Result.AppendFormat(GetMyINIString("STRING_FOR_LOCALIZE", "FORMAT_044"),
        GuildLogType(lpGuildLog->m_cType), lpGuildLog->m_dwGID, 
        lpGuildLog->m_dwSrcCID, lpGuildLog->m_dwDstCID, GuildTitle(dwTitle));
}

// ±æµå¿ø ±ÇÇÑ ¼³Á¤
void SimpleInfo::GuildRightsLevelChange(CString& Result, const sLogBase* lpLogBase)
{
    const sGuildLog* lpGuildLog = static_cast<const sGuildLog*>(lpLogBase);
    
	Result.Append(" ");
    Result.AppendFormat(GetMyINIString("STRING_FOR_LOCALIZE", "FORMAT_045"),
        GuildLogType(lpGuildLog->m_cType), lpGuildLog->m_dwGID, lpGuildLog->m_dwSrcCID);
}


// ±æµå ·¹º§ º¯°æ
void SimpleInfo::GuildLevelChange(CString& Result, const sLogBase* lpLogBase)
{
    const sGuildLog* lpGuildLog = static_cast<const sGuildLog*>(lpLogBase);

    unsigned long dwLevel = 0;
    unsigned long dwPreGuildGold = 0;
    unsigned long dwPostGuildGold = 0;

    if(sizeof(unsigned long) * 3 == lpGuildLog->m_usExtraDataSize)
    {
        dwLevel         = *reinterpret_cast<const unsigned long*>(lpGuildLog + 1);
        dwPreGuildGold  = *(reinterpret_cast<const unsigned long*>(lpGuildLog + 1) + 1);
        dwPostGuildGold = *(reinterpret_cast<const unsigned long*>(lpGuildLog + 1) + 2);
    }

	std::string szMoney = GetMoneyString(dwPreGuildGold);
	std::string szMoney2 = GetMoneyString(dwPostGuildGold);

	Result.Append(" ");
    Result.AppendFormat(GetMyINIString("STRING_FOR_LOCALIZE", "FORMAT_046"),
        GuildLogType(lpGuildLog->m_cType), lpGuildLog->m_dwGID, 
		lpGuildLog->m_dwSrcCID, dwLevel, szMoney.c_str(), szMoney2.c_str());
}

// ±æµå¸¶Å© µî·Ï/º¯°æ
void SimpleInfo::GuildMarkChange(CString& Result, const sLogBase* lpLogBase)
{
    const sGuildLog* lpGuildLog = static_cast<const sGuildLog*>(lpLogBase);

    unsigned long dwPreGuildGold = 0;
    unsigned long dwPostGuildGold = 0;

    if(sizeof(unsigned long) * 2 <= lpGuildLog->m_usExtraDataSize)
    {        
        dwPreGuildGold  = *(reinterpret_cast<const unsigned long*>(lpGuildLog + 1));
        dwPostGuildGold = *(reinterpret_cast<const unsigned long*>(lpGuildLog + 1) + 1);
    }

	std::string szMoney = GetMoneyString(dwPreGuildGold);
	std::string szMoney2 = GetMoneyString(dwPostGuildGold);


	Result.Append(" ");
    Result.AppendFormat(GetMyINIString("STRING_FOR_LOCALIZE", "FORMAT_047"),
        GuildLogType(lpGuildLog->m_cType), lpGuildLog->m_dwGID, 
		lpGuildLog->m_dwSrcCID, szMoney.c_str(), szMoney2.c_str());
}

// ±æµå ±Ý°í º¯°æ
void SimpleInfo::GuildStoreGoldChange(CString& Result, const sLogBase* lpLogBase)
{
    const sGuildLog* lpGuildLog = static_cast<const sGuildLog*>(lpLogBase);

    unsigned long dwPreGuildGold = 0;
    unsigned long dwPostGuildGold = 0;

    if(sizeof(unsigned long) * 2 <= lpGuildLog->m_usExtraDataSize)
    {        
        dwPreGuildGold  = *(reinterpret_cast<const unsigned long*>(lpGuildLog + 1));
        dwPostGuildGold = *(reinterpret_cast<const unsigned long*>(lpGuildLog + 1) + 1);
    }

    __int64 nDifference = dwPostGuildGold - dwPreGuildGold;

	std::string szDifference = GetMoneyString(dwPostGuildGold - dwPreGuildGold);
	std::string szPreGuildGold = GetMoneyString(dwPreGuildGold);
	std::string szPostGuildGold = GetMoneyString(dwPostGuildGold);

	Result.Append(" ");
    Result.AppendFormat(GetMyINIString("STRING_FOR_LOCALIZE", "FORMAT_048"),
        GuildLogType(lpGuildLog->m_cType), lpGuildLog->m_dwGID, 
		lpGuildLog->m_dwSrcCID, lpGuildLog->m_cCmd, szDifference.c_str(), szPreGuildGold.c_str(), szPostGuildGold.c_str());
}

// ±æµå ¼Ò¸êµÊ
void SimpleInfo::GuildDispose(CString& Result, const sLogBase* lpLogBase)
{
    const sGuildLog* lpGuildLog = static_cast<const sGuildLog*>(lpLogBase);

    int nLine = *reinterpret_cast<const int*>(lpGuildLog + 1);
    
    const char* szFileName = reinterpret_cast<const char*>(lpGuildLog + 1) + sizeof(int);

    if(lpGuildLog->m_usExtraDataSize <= sizeof(int))
    {
        szFileName = "Unknown";
    }

	Result.Append(" ");
    Result.AppendFormat(GetMyINIString("STRING_FOR_LOCALIZE", "FORMAT_049"),
        GuildLogType(lpGuildLog->m_cType), lpGuildLog->m_dwGID, szFileName, nLine);
}


void SimpleInfo::ZoneMoveLog(CString& Result, const sLogBase* lpLogBase)
{
    const sMoveZoneLog* lpMoveZoneLog = static_cast<const sMoveZoneLog*>(lpLogBase);

    Result.Append(" ");
    Result.AppendFormat(GetMyINIString("STRING_FOR_LOCALIZE", "FORMAT_065"),
        lpMoveZoneLog->m_cDstZone, lpMoveZoneLog->m_cDstChannel);
}


void SimpleInfo::ItemAttachOption(CString& Result, const sLogBase* lpLogBase)
{
    const sItemAttachOption* lpItemAttach = static_cast<const sItemAttachOption*>(lpLogBase);

    Result.Append(" ");

    if (0 == lpItemAttach->m_cErr &&
        0 != lpItemAttach->m_cOldItemLen &&
        0 != lpItemAttach->m_cUseItemLen &&
        0 != lpItemAttach->m_cNewItemLen)
    {
        const char* szOldItem = reinterpret_cast<const char*>(lpItemAttach + 1);
        const char* szUseItem = szOldItem + lpItemAttach->m_cOldItemLen;
        const char* szNewItem = szUseItem + lpItemAttach->m_cUseItemLen;

        size_t nItemLen = lpItemAttach->m_cOldItemLen;
        Item::CItem* lpOldItem = Item::CItemFactory::GetInstance().CreateItem(szOldItem, nItemLen);

        nItemLen = lpItemAttach->m_cNewItemLen;
        Item::CItem* lpNewItem = Item::CItemFactory::GetInstance().CreateItem(szNewItem, nItemLen);

        Item::CEquipment* lpOldEquipment = Item::CEquipment::DowncastToEquipment(lpOldItem);
        Item::CEquipment* lpNewEquipment = Item::CEquipment::DowncastToEquipment(lpNewItem);

        if(0 != lpOldEquipment && 0 != lpNewEquipment)
        {
            const char* szAttributeName = 
                Item::Attribute::Attributes[lpItemAttach->m_cSelectedOptionIndex].GetTypeName();

            Item::Attribute::Type eAttrType =
                static_cast<Item::Attribute::Type>(lpItemAttach->m_cSelectedOptionIndex);

			std::string szMoney = GetMoneyString(lpItemAttach->m_dwOldInvenGold - lpItemAttach->m_dwNewInvenGold);

            // 67 : ¿É¼ÇÀ̽Ŀ¡ ¼º°øÇÏ¿´½À´Ï´Ù - º¯°æ Àü ¿É¼Ç (%s:%4u) -> º¯°æ ÈÄ ¿É¼Ç (%s:%4u) / ¼Ò¸ð ±Ý¾× (%10u)
            Result.AppendFormat(GetMyINIString("STRING_FOR_LOCALIZE", "FORMAT_067"),
                szAttributeName, lpOldEquipment->GetAttribute(eAttrType),
                szAttributeName, lpNewEquipment->GetAttribute(eAttrType),
				szMoney.c_str());
        }

        DELETE_ITEM(lpOldItem);
        DELETE_ITEM(lpNewItem);
    }
    else
    {
        // 68 : ¿É¼ÇÀ̽Ŀ¡ ½ÇÆÐÇß½À´Ï´Ù
        Result.AppendFormat(GetMyINIString("STRING_FOR_LOCALIZE", "FORMAT_068"));
    }
}

void SimpleInfo::ItemCompensation(CString& Result, const sLogBase* lpLogBase)
{
    const sItemCompensation* lpItemCompensation = static_cast<const sItemCompensation*>(lpLogBase);

    Result.Append(" ");

    if (0 == lpItemCompensation->m_cErr &&
        0 != lpItemCompensation->m_cOldItemLen &&        
        0 != lpItemCompensation->m_cNewItemLen)
    {
        const char* szOldItem = reinterpret_cast<const char*>(lpItemCompensation + 1);        
        const char* szNewItem = szOldItem + lpItemCompensation->m_cOldItemLen;

        size_t nItemLen = lpItemCompensation->m_cOldItemLen;
        Item::CItem* lpOldItem = Item::CItemFactory::GetInstance().CreateItem(szOldItem, nItemLen);

        nItemLen = lpItemCompensation->m_cNewItemLen;
        Item::CItem* lpNewItem = Item::CItemFactory::GetInstance().CreateItem(szNewItem, nItemLen);

        Item::CEquipment* lpOldEquipment = Item::CEquipment::DowncastToEquipment(lpOldItem);
        Item::CEquipment* lpNewEquipment = Item::CEquipment::DowncastToEquipment(lpNewItem);

        if(0 != lpOldEquipment && 0 != lpNewEquipment)
        {
            long nGold = lpItemCompensation->m_dwOldInvenGold - lpItemCompensation->m_dwNewInvenGold;

			std::string szMoney = GetMoneyString(nGold < 0 ? -nGold : 0);
			std::string szMoney2 = GetMoneyString(0 < nGold ? nGold : 0);

            // 69 : ¾ÆÀÌÅÛ º¸»ó - º¯°æ Àü (%s) -> º¯°æ ÈÄ(%s) / º¸»ó °ñµå:%10u / ¼Ò¸ð °ñµå:%10u
            Result.AppendFormat(GetMyINIString("STRING_FOR_LOCALIZE", "FORMAT_069"),
                GetItemName(lpOldEquipment->GetPrototypeID()), 
                GetItemName(lpNewEquipment->GetPrototypeID()), 
				szMoney.c_str(), szMoney2.c_str());
        }

        DELETE_ITEM(lpOldItem);
        DELETE_ITEM(lpNewItem);
    }
    else
    {
        // 70 : ¾ÆÀÌÅÛ º¸»ó ½ÇÆÐ
        Result.AppendFormat(GetMyINIString("STRING_FOR_LOCALIZE", "FORMAT_070"));
    }
}

void SimpleInfo::TicketBuySkillBook(CString& Result, const sLogBase* lpLogBase)
{
    const sTradeItemLog* pTradeItemLog = static_cast<const sTradeItemLog*>(lpLogBase);

    char szTradeIndex[MIN_BUFFER];
    PositionToString(szTradeIndex, MIN_BUFFER, pTradeItemLog->m_itemPos);

    Result.Append(" ");

    if(0 == lpLogBase->m_cErr)
    {
        size_t nItemSize = Item::MAX_ITEM_SIZE;

        Item::CItem* lpItem = Item::CItemFactory::GetInstance().CreateItem(
            (const char*)pTradeItemLog + sizeof(sTradeItemLog), nItemSize);

        if(0 != lpItem)
        {            
            // 71 : ¾ÆÀÌÅÛ ±¸¸Å (½ºÅ³ºÏ ƼÄÏ) - UID:0x%016I64X, Á¾·ùID:%5u, À̸§: %s, À§Ä¡:%s, ÆǸÅÀÚCID:%10u
            Result.AppendFormat(GetMyINIString("STRING_FOR_LOCALIZE", "FORMAT_071"),
                lpItem->GetUID(), lpItem->GetPrototypeID(), GetItemName(lpItem->GetPrototypeID()),
                szTradeIndex, pTradeItemLog->m_dwTraderCID);

            DELETE_ITEM(lpItem)
        }
    }
    else
    {
        Result.AppendFormat(GetMyINIString("STRING_FOR_LOCALIZE", "FORMAT_072"));
    }
}

void SimpleInfo::UpgradeItemV2(CString& Result, const sLogBase* lpLogBase)
{
    const sUpgradeItemLogV2* lpUpgradeItemLogV2 = static_cast<const sUpgradeItemLogV2*>(lpLogBase);

    Result.Append(" ");

    if(0 == lpUpgradeItemLogV2->m_cErr)
    {
        size_t nMineralSize = Item::MAX_ITEM_SIZE;
        size_t nEquipSize = Item::MAX_ITEM_SIZE;

		int iMineralID = 0;

        if(0 != lpUpgradeItemLogV2->m_cMineralSize)
        {            
            Item::CItem* lpMineral = Item::CItemFactory::GetInstance().CreateItem(
                (const char*)lpUpgradeItemLogV2 + sizeof(sUpgradeItemLogV2), nMineralSize);

            if(0 != lpMineral)
            {
                // MineralÀÌ ¾øÀ» ¼öµµ ÀÖ´Ù.
				iMineralID = lpMineral->GetPrototypeID();
                DELETE_ITEM(lpMineral);
            }
        }

        if(0 != lpUpgradeItemLogV2->m_cEquipSize)
        {            
            Item::CItem* lpEquip = Item::CItemFactory::GetInstance().CreateItem(
                (const char*)lpUpgradeItemLogV2 + sizeof(sUpgradeItemLogV2) + lpUpgradeItemLogV2->m_cMineralSize, nEquipSize);

            if(0 != lpEquip)
            {
                Item::CEquipment* lpEquipment = Item::CEquipment::DowncastToEquipment(lpEquip);
                if(0 != lpEquipment)
                {
					if(iMineralID == Item::EtcItemID::AWAKENCORE)
					{
						Result.AppendFormat(GetMyINIString("STRING_FOR_LOCALIZE", "FORMAT_094"),
							GetItemName(lpEquipment->GetPrototypeID()), lpEquipment->GetPrototypeID(), 
							lpUpgradeItemLogV2->m_cLastUpgradeLevel, lpEquipment->GetCoreLevel());
					}
					else
					{
						Result.AppendFormat(GetMyINIString("STRING_FOR_LOCALIZE", "FORMAT_073"),
							GetItemName(lpEquipment->GetPrototypeID()), lpEquipment->GetPrototypeID(), 
							lpUpgradeItemLogV2->m_cLastUpgradeLevel, lpEquipment->GetUpgradeLevel());
					}
                }
                else
                {
                    Result.AppendFormat(GetMyINIString("STRING_FOR_LOCALIZE", "FORMAT_035"));
                }

                DELETE_ITEM(lpEquip);
            }
        }
    }
    else
    {
        Result.AppendFormat(GetMyINIString("STRING_FOR_LOCALIZE", "FORMAT_036"));
    }
}


// ¸ó½ºÅÍ »ç¸Á ·Î±×
void SimpleInfo::MonsterDead(CString& Result, const sLogBase* lpLogBase)
{
    const sMonsterDeadLog* lpMonsterDeadLog = 
        static_cast<const sMonsterDeadLog*>(lpLogBase);

    Result.Append(" ");

    // ¸ó½ºÅÍ »ç¸Á : CID:0x%08X(Lv:%3u) %2d°³ ¾ÆÀÌÅÛ ¶³±À
    Result.AppendFormat(GetMyINIString("STRING_FOR_LOCALIZE", "FORMAT_074"), 
        lpMonsterDeadLog->m_dwMonsterCID, lpMonsterDeadLog->m_cMonsterLevel, 
        lpMonsterDeadLog->m_cDropItemNum);
}

// ÀüÅõ·Î ¾òÀº ¸í¼º
void SimpleInfo::FameGetBattle(CString& Result, const sLogBase* lpLogBase)
{
	const sFameGetBattleLog* lpFameGetBattleLog = 
		static_cast<const sFameGetBattleLog*>(lpLogBase);

	Result.Append(" ");

	// ÀüÅõ·Î ¾òÀº ¸í¼º :	EnemyCID:%010u, PID:%010u, °ú°Å ¸í¼ºÄ¡:%8u, ÇöÀç ¸í¼ºÄ¡:%8u, ¾òÀº ¸í¼ºÄ¡:%8u,
	//						°ú°Å °øÇå¸Å´Þ:%8u, ÇöÀç °øÇå¸Å´Þ:%8u, ¾òÀº °øÇå¸Å´Þ:%8u						
	Result.AppendFormat(GetMyINIString("STRING_FOR_LOCALIZE", "FORMAT_075"), 
		lpFameGetBattleLog->m_dwEnemyCID, lpFameGetBattleLog->m_dwOurPartyUID, 
		lpFameGetBattleLog->m_dwPrevFame, lpFameGetBattleLog->m_dwNextFame, (lpFameGetBattleLog->m_dwNextFame - lpFameGetBattleLog->m_dwPrevFame),
		lpFameGetBattleLog->m_dwPrevMileage, lpFameGetBattleLog->m_dwNextMileage, (lpFameGetBattleLog->m_dwNextMileage - lpFameGetBattleLog->m_dwPrevMileage));
}

// ÀüÅõ·Î ÀÒÀº ¸í¼º
void SimpleInfo::FameLoseBattle(CString& Result, const sLogBase* lpLogBase)
{
	const sFameLoseBattleLog* lpFameLoseBattleLog = 
		static_cast<const sFameLoseBattleLog*>(lpLogBase);

	Result.Append(" ");

	// ÀüÅõ·Î ÀÒÀº ¸í¼º : EnemyCID:%010u, PID:%010u, °ú°Å ¸í¼ºÄ¡:%8u, ÇöÀç ¸í¼ºÄ¡:%8u, ÀÒÀº ¸í¼ºÄ¡:%8u
	Result.AppendFormat(GetMyINIString("STRING_FOR_LOCALIZE", "FORMAT_076"),
		lpFameLoseBattleLog->m_dwEnemyCID, lpFameLoseBattleLog->m_dwOurPartyUID, 
		lpFameLoseBattleLog->m_dwPrevFame, lpFameLoseBattleLog->m_dwNextFame, (lpFameLoseBattleLog->m_dwPrevFame - lpFameLoseBattleLog->m_dwNextFame));
}

// ¿ä»õ·Î ¾òÀº ¸í¼º
void SimpleInfo::FameGetCamp(CString& Result, const sLogBase* lpLogBase)
{
	const sFameGetCampLog* lpFameGetCampLog = 
		static_cast<const sFameGetCampLog*>(lpLogBase);

	Result.Append(" ");

	// ¿ä»õ·Î ¾òÀº ¸í¼º : EnemyGID:%010u, °ú°Å ¸í¼ºÄ¡:%8u, ÇöÀç ¸í¼ºÄ¡:%8u, ¾òÀº ¸í¼ºÄ¡:%8u
	Result.AppendFormat(GetMyINIString("STRING_FOR_LOCALIZE", "FORMAT_077"),
		lpFameGetCampLog->m_dwEnemyGID, lpFameGetCampLog->m_dwPrevFame, lpFameGetCampLog->m_dwNextFame, (lpFameGetCampLog->m_dwNextFame - lpFameGetCampLog->m_dwPrevFame));
}

// ¿ä»õ·Î ÀÒÀº ¸í¼º
void SimpleInfo::FameLoseCamp(CString& Result, const sLogBase* lpLogBase)
{
	const sFameLoseCampLog* lpFameLoseCampLog = 
		static_cast<const sFameLoseCampLog*>(lpLogBase);

	Result.Append(" ");

	// ¿ä»õ·Î ÀÒÀº ¸í¼º : EnemyGID:%010u, °ú°Å ¸í¼ºÄ¡:%8u, ÇöÀç ¸í¼ºÄ¡:%8u, ÀÒÀº ¸í¼ºÄ¡:%8u	
	Result.AppendFormat(GetMyINIString("STRING_FOR_LOCALIZE", "FORMAT_078"),
		lpFameLoseCampLog->m_dwEnemyGID, lpFameLoseCampLog->m_dwPrevFame, lpFameLoseCampLog->m_dwNextFame, (lpFameLoseCampLog->m_dwPrevFame - lpFameLoseCampLog->m_dwNextFame));
}

// Äù½ºÆ® ¼öÇàÀ¸·Î ¾òÀº º¸»ó
void SimpleInfo::QuestGetReward(CString& Result, const sLogBase* lpLogBase)
{
	const sQuestGetRewardLog* lpQuestGetRewardLog = 
		static_cast<const sQuestGetRewardLog*>(lpLogBase);

	Result.Append(" ");

	std::string szMoney = GetMoneyString(lpQuestGetRewardLog->m_dwGold);

	// Äù½ºÆ® ¼öÇàÀ¸·Î ¾òÀº º¸»ó : QuestID:%10u, ItemUID:%016I64X, °æÇèÄ¡:%8u, °ñµå:%8u, ¸í¼º:%8u, °øÇå¸Þ´Þ:%8u
	Result.AppendFormat(GetMyINIString("STRING_FOR_LOCALIZE", "FORMAT_079"),
		lpQuestGetRewardLog->m_wQuestID, lpQuestGetRewardLog->m_dwItemUID, 
		lpQuestGetRewardLog->m_dwExp, szMoney.c_str(), 
		lpQuestGetRewardLog->m_dwFame, lpQuestGetRewardLog->m_dwMileage);
}