Restructure repository to include all source folders

Move git root from Client/ to src/ to track all source code:
- Client: Game client source (moved to Client/Client/)
- Server: Game server source
- GameTools: Development tools
- CryptoSource: Encryption utilities
- database: Database scripts
- Script: Game scripts
- rylCoder_16.02.2008_src: Legacy coder tools
- GMFont, Game: Additional resources

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

Server/RylServerProject/RylGameLibrary/Item/Container/ContainerConstant.h

@@ -0,0 +1,38 @@
+#ifndef _RYL_GAME_LIB_CONTAINER_CONSTANTS_H_
+#define _RYL_GAME_LIB_CONTAINER_CONSTANTS_H_
+
+namespace ContainerConstant
+{
+	enum Const
+	{
+		QUEST_INVENTORY_TAB		= 3		// 인벤토리의 퀘스트 아이템 탭 (4번째 탭)
+	};
+
+	enum Size
+    {   
+		// -------------------------------------
+		// 캐릭터
+
+        INVENTORY_WIDTH		= 6,    
+        INVENTORY_HEIGHT	= 6,    
+        MAX_INVENTORY_TAB	= 4,    // 인벤토리
+
+        EXCHANGE_WIDTH		= 8,    
+        EXCHANGE_HEIGHT		= 4,    // 교환창
+
+        DEPOSIT_WIDTH       = 8,    
+        DEPOSIT_HEIGHT      = 12,   
+        MAX_DEPOSIT_TAB     = 4,    // 창고
+
+        STALL_WIDTH			= 10,	
+        STALL_HEIGHT		= 8,	// 노점상
+
+		// -------------------------------------
+		// 길드 요새 상점
+
+		CAMPSHOP_WIDTH		= 10, 
+		CAMPSHOP_HEIGHT		= 8,	// 판매 목록
+	};
+};
+
+#endif

Server/RylServerProject/RylGameLibrary/Item/Container/DepositContainer.cpp

@@ -0,0 +1,330 @@
+
+#include "stdafx.h"
+
+#include <Network/Stream/SendStream.h>
+#include <Network/Packet/PacketCommand.h>
+#include <Network/Packet/PacketStruct/CharItemPacket.h>
+#include <Network/Dispatch/GameClient/SendCharItem.h>
+
+#include <Creature/Character/Character.h>
+
+#include <Item/Item.h>
+#include <Item/ItemFactory.h>
+#include "DepositContainer.h"
+
+
+Item::CDepositContainer::CDepositContainer()
+:   m_lpArrayContainer(NULL),
+    m_lpOwner(NULL),
+    m_dwTabFlag(0),
+    m_dwGold(0),
+    m_nXSize(0),
+    m_nYSize(0),
+    m_nTabNum(0),
+    m_bLoginSuccess(false)
+{
+    memset(m_szPassword, 0, Deposit::PASSWORD_LENGTH);
+}
+
+
+Item::CDepositContainer::~CDepositContainer()
+{
+    DestroyDepositContainer();
+}
+
+
+bool Item::CDepositContainer::Initialize(CCharacter* lpCharacter, unsigned char nXSize, 
+                                         unsigned char nYSize, unsigned char nTabNum)
+{
+    m_lpOwner           = lpCharacter;
+    m_dwCID             = lpCharacter->GetCID();
+
+    m_nXSize            = nXSize;
+    m_nYSize            = nYSize;
+    m_nTabNum           = nTabNum;
+
+    m_lpArrayContainer  = new Item::CArrayContainer[nTabNum];
+
+    if(NULL != m_lpArrayContainer)
+    {
+        for(int nCount = 0; nCount < m_nTabNum; ++nCount)
+        {
+            if(!m_lpArrayContainer[nCount].Initialize(m_dwCID, nXSize, nYSize, 1))
+            {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    return false;
+}
+
+
+void Item::CDepositContainer::DestroyDepositContainer()
+{
+    if(NULL != m_lpArrayContainer)
+    {
+        delete [] m_lpArrayContainer;
+        m_lpArrayContainer = NULL;
+    }
+}
+
+
+Item::CItem* Item::CDepositContainer::GetItem(ItemPos itemPos)
+{
+    unsigned char cTabNum = itemPos.GetZIndex();
+
+    if(cTabNum < m_nTabNum && NULL != m_lpArrayContainer)
+    {
+        itemPos.SetZIndex(0);
+        return m_lpArrayContainer[cTabNum].GetItem(itemPos);
+    }
+
+    return NULL;
+}
+
+
+bool Item::CDepositContainer::SetItem(ItemPos itemPos, CItem* lpItem)
+{
+    unsigned char cTabNum = itemPos.GetZIndex();
+
+    bool bResult = false;
+
+    if(NULL != m_lpArrayContainer && NULL != lpItem &&
+        cTabNum < m_nTabNum && (0 != (m_dwTabFlag & (1 << cTabNum))))
+    {
+        // 이미 구입한 탭에만 Setting할 수 있다.
+        itemPos.SetZIndex(0);
+        bResult = m_lpArrayContainer[cTabNum].SetItem(itemPos, lpItem);
+
+        itemPos.SetZIndex(cTabNum);
+        lpItem->MoveItem(itemPos);
+    }
+    else
+    {
+        ERRLOG4(g_Log, "CID:0x%10u 창고 탭에 아이템을 놓을 수 없습니다. 탭 플래그 : 0x%08x, 위치(%d, 0x%04x)",
+            m_dwCID, m_dwTabFlag, itemPos.m_cPos, itemPos.m_cIndex);
+    }
+
+    return bResult;
+}
+
+
+bool Item::CDepositContainer::RemoveItem(ItemPos itemPos)
+{
+    unsigned char cTabNum = itemPos.GetZIndex();
+
+    if(NULL != m_lpArrayContainer && 
+        cTabNum < m_nTabNum && (0 != (m_dwTabFlag & (1 << cTabNum))))
+    {
+        // 이미 구입한 탭에만 Remove할 수 있다.
+        itemPos.SetZIndex(0);
+        return m_lpArrayContainer[cTabNum].RemoveItem(itemPos);
+    }
+
+    return false;
+}
+
+
+bool Item::CDepositContainer::SerializeIn(const char* szItemBuffer_In, unsigned long dwBufferSize_In)
+{
+    size_t nBufferSize = static_cast<size_t>(dwBufferSize_In);
+    size_t nUsed = 0;
+
+    Item::CItemFactory& ItemFactory = CItemFactory::GetInstance();
+
+    while(nBufferSize > 0)
+    {
+        size_t nItemSize = nBufferSize;
+        Item::CItem* lpItem = ItemFactory.CreateItem(szItemBuffer_In + nUsed, nItemSize);
+
+        if(NULL == lpItem)
+        {
+            nItemSize = reinterpret_cast<const Item::ItemData*>(szItemBuffer_In + nUsed)->m_cItemSize;
+            ERRLOG1(g_Log, "CID:0x%10u 아이템 생성에 실패했습니다.", m_dwCID);
+        }
+        else if(!CDepositContainer::SetItem(lpItem->GetPos(), lpItem))
+        {
+            nItemSize = reinterpret_cast<const Item::ItemData*>(szItemBuffer_In + nUsed)->m_cItemSize;
+            ERRLOG4(g_Log, "CID:0x%10u 아이템 놓기를 실패했습니다. (%d, 0x%x) TabFlag : 0x%08x", 
+                m_dwCID, lpItem->GetPos().m_cPos, lpItem->GetPos().m_cIndex, m_dwTabFlag);
+            
+            DELETE_ITEM(lpItem);
+        }
+
+        nUsed += nItemSize;
+        nBufferSize -= nItemSize;
+    }
+    
+    return true;
+}
+
+
+
+bool Item::CDepositContainer::ClientUpdate(CSendStream& ClientSendStream)
+{
+    char szData[PktDeposit::MIN_DATA_SIZE];
+
+    memset(szData, 0, sizeof(PktDeposit::MIN_DATA_SIZE));
+    *reinterpret_cast<unsigned long*>(szData) = m_dwGold;
+    *reinterpret_cast<unsigned char*>(szData + sizeof(unsigned long)) = IsPasswordSaved() ? 1 : 0;
+
+    // 돈하고 패스워드 저장 여부 리턴
+    if(GameClientSendPacket::SendCharDepositCmd(ClientSendStream, PktDeposit::SAVED_PASS, 
+        szData, PktDeposit::MIN_DATA_SIZE, 0))
+    {
+        return Update(ClientSendStream);
+    }
+
+    return false;
+}
+
+
+bool Item::CDepositContainer::DBUpdate(CSendStream& AgentSendStream)
+{   
+    if(GameClientSendPacket::SendCharDepositGoldToDBAgent(AgentSendStream, m_lpOwner->GetUID(), m_dwGold))
+    {
+        return Update(AgentSendStream);
+    }
+
+    return false;
+}
+
+
+bool Item::CDepositContainer::Update(CSendStream& SendStream)
+{
+    const int MAX_ITEM_BUFFER = 8000;
+    const int MAX_BUFFER = MAX_ITEM_BUFFER + sizeof(PktDepositUpdateDB);
+    char szBuffer[MAX_BUFFER];
+
+    PktDepositUpdateDB* lpPktDepositUpdateDB = reinterpret_cast<PktDepositUpdateDB*>(szBuffer);
+    char* szItemBuffer = szBuffer + sizeof(PktDepositUpdateDB);
+
+    // 헤더 세팅
+    lpPktDepositUpdateDB->m_dwUID               = m_lpOwner->GetUID();
+    lpPktDepositUpdateDB->m_dwCID               = m_dwCID;
+    lpPktDepositUpdateDB->m_dwTabFlag           = m_dwTabFlag;        // 현재 탭의 구입 상태를 나타내는 bitset
+    
+    // 두 탭씩 Serialize한다.
+    for(unsigned int nSerializeIndex = 0; nSerializeIndex < m_nTabNum; ++nSerializeIndex)
+    {
+        unsigned long dwUsedSize    = 0;
+        unsigned long dwBufferSize  = MAX_ITEM_BUFFER;
+
+        // 한번에 두탭씩 Serialize한다. 짝수탭 Serialize.
+        if(m_lpArrayContainer[nSerializeIndex].SerializeOut(szItemBuffer, dwBufferSize))
+        {
+            dwUsedSize += dwBufferSize;
+        }
+        else
+        {
+            const Item::ItemData* lpItemData = reinterpret_cast<Item::ItemData*>(szItemBuffer);
+            lpItemData->DumpInfo(m_dwCID, __FUNCTION__ " 의 첫번째 탭 업데이트에서 에러 발생");
+        }
+
+        // 홀수탭 Serialize.
+        ++nSerializeIndex;
+
+        if(nSerializeIndex < m_nTabNum)
+        {
+            dwBufferSize  = MAX_ITEM_BUFFER - dwUsedSize;
+            if(m_lpArrayContainer[nSerializeIndex].SerializeOut(szItemBuffer + dwUsedSize, dwBufferSize))
+            {
+                dwUsedSize += dwBufferSize;
+            }
+            else
+            {
+                const Item::ItemData* lpItemData = reinterpret_cast<Item::ItemData*>(szItemBuffer);
+                lpItemData->DumpInfo(m_dwCID, __FUNCTION__ " 의 두번째 탭 업데이트에서 에러 발생");        
+            }
+        }
+
+        lpPktDepositUpdateDB->m_usDataSize      = static_cast<unsigned short>(dwUsedSize);
+        lpPktDepositUpdateDB->m_cTabNum         = nSerializeIndex / 2;
+        lpPktDepositUpdateDB->m_bUpdateComplete = (nSerializeIndex + 1 < m_nTabNum) ? false : true;
+
+        if(!SendStream.WrapCompress(szBuffer, 
+            static_cast<unsigned short>(sizeof(PktDepositUpdateDB) + dwUsedSize), CmdDepositUpdate, 0, 0))
+        {
+            return false;
+        }
+    }
+
+    return true;
+}
+
+bool Item::CDepositContainer::ChangePassword(const char* szCurrentPassword, size_t nCurrentPasswordLength,
+                                       const char* szChangePassword, size_t nChangePasswordLength)
+{
+    if(0 == memcmp(m_szPassword, szCurrentPassword, 
+        (Deposit::PASSWORD_LENGTH < nCurrentPasswordLength) ? Deposit::PASSWORD_LENGTH : nCurrentPasswordLength))
+    {
+        SetPassword(szChangePassword, nChangePasswordLength);
+        return true;
+    }
+
+    return false;
+}
+
+
+
+bool Item::CDepositContainer::AddGold(unsigned long dwGold)
+{
+    if(m_dwGold <= ULONG_MAX - dwGold)
+    {
+        m_dwGold += dwGold;
+        return true;
+    }
+
+    ERRLOG2(g_Log, "CID:0x%10u 창고 돈 오버플로우가 발생했습니다. : %dGold", m_dwCID, dwGold);
+    return false;
+}
+
+bool Item::CDepositContainer::DeductGold(unsigned long dwGold)
+{
+    if(dwGold <= m_dwGold) 
+    {
+        m_dwGold -= dwGold;
+        return true;    
+    }
+    
+    ERRLOG1(g_Log, "CID:0x%10u 창고 돈 언더플로우가 발생했습니다.", m_dwCID);
+    return false;
+}
+
+
+// 정보 출력
+void Item::CDepositContainer::DumpItemInfo()
+{
+    for(int nCount = 0; nCount < m_nTabNum; ++nCount)
+    {
+        m_lpArrayContainer[nCount].DumpItemInfo();
+    }
+}
+
+
+// 창고 아이템을 로그로 남김.
+bool Item::CDepositContainer::LogUpdate(char* szLogBuffer_Out, unsigned long& dwBufferSize_InOut)
+{
+    char* szBufferOut       = szLogBuffer_Out;
+    unsigned long dwUsed    = 0;
+    unsigned long dwRemain  = dwBufferSize_InOut;
+
+    for(int nIndex = 0; nIndex < m_nTabNum; ++nIndex)
+    {        
+        if(!m_lpArrayContainer[nIndex].SerializeOut(szBufferOut + dwUsed, dwRemain))
+        {
+            ERRLOG1(g_Log, "CID:0x%10u 창고 로그 업데이트에 실패했습니다", m_dwCID);
+            dwBufferSize_InOut = dwUsed;
+            return false;
+        }
+
+        dwUsed += dwRemain;
+        dwRemain = dwBufferSize_InOut - dwUsed;
+    }
+
+    dwBufferSize_InOut = dwUsed;
+    return true;
+}

Server/RylServerProject/RylGameLibrary/Item/Container/DepositContainer.h

@@ -0,0 +1,148 @@
+#ifndef _DEPOSIT_CONTAINER_H_
+#define _DEPOSIT_CONTAINER_H_
+
+#include <climits>
+#include "ItemContainer.h"
+#include <Network/Packet/PacketStruct/CharItemPacket.h>
+
+// 전방 참조
+class CSendStream;
+class CCharacter;
+
+namespace Item
+{
+    class CDepositContainer : public CItemContainer
+    {
+    public:
+        
+        CDepositContainer();
+        virtual ~CDepositContainer();
+        bool Initialize(CCharacter* lpCharacter,
+            unsigned char nXSize, unsigned char nYSize, unsigned char nTabNum);
+
+        // 아이템 얻어오기 함수
+        virtual CItem* GetItem(ItemPos itemPos);
+        virtual bool SetItem(ItemPos itemPos, CItem* lpItem);
+        virtual bool RemoveItem(ItemPos itemPos);
+
+        // 인증 관련 함수
+        inline bool Login(const char* szPassword, size_t nPasswordLength, char bSavePassword);
+        inline bool IsLogin() { return m_bLoginSuccess; }
+        inline void Logout() { if(m_bLoginSuccess) { m_bLoginSuccess = false; } }
+        
+        inline bool IsPasswordSaved() { return (0 != (m_dwTabFlag & PktDepositUpdateDB::SAVED_PASSWORD)); }
+        inline void SetPassword(const char* szPassword, size_t nPasswordLength);
+        bool ChangePassword(const char* szCurrentPassword, size_t nCurrentPasswordLength,
+            const char* szChangePassword, size_t nChangePasswordLength);
+
+        // NULL-Terminated가 아님!
+        inline const unsigned char* GetPassword() const { return m_szPassword; }
+        
+        // 돈 관련 함수
+        inline unsigned long GetGold() const { return m_dwGold; }
+        bool AddGold(unsigned long dwGold);
+        bool DeductGold(unsigned long dwGold);
+
+        // Flag관련 함수. Tab1은 항상 사용 가능.
+        inline void SetTabFlag(unsigned long dwTabFlag);
+        inline unsigned long GetTabFlag() const { return m_dwTabFlag; }
+
+        // 탭 구매.
+        inline bool BuyTab(unsigned char cTabNum);
+       
+        // 각 탭을 얻어오는 함수
+        inline CItemContainer* GetTab(unsigned char nTabNum);
+        inline unsigned char GetMaxTabNum() const { return m_nTabNum; }
+
+        // Serialize In.
+        virtual bool SerializeIn(const char* szItemBuffer_In, unsigned long dwBufferSize_In);
+
+        // 정보 출력
+        virtual void DumpItemInfo();
+
+        // 창고 아이템 업데이트
+        bool ClientUpdate(CSendStream& ClientSendStream);        
+        bool DBUpdate(CSendStream& AgentSendStream);
+        bool LogUpdate(char* szLogBuffer_Out, unsigned long& dwBufferSize_InOut);
+
+    private:
+
+        bool Update(CSendStream& SendStream);
+        
+        void DestroyDepositContainer();
+
+        // Serialize Out은 각 탭을 얻어서, 탭별로 SerializeOut한다.
+        virtual bool SerializeOut(char* szItemBuffer_Out, unsigned long& dwBufferSize_InOut) const { return false; }
+                        
+        CArrayContainer*    m_lpArrayContainer;
+        CCharacter*         m_lpOwner;
+
+        unsigned long       m_dwTabFlag;
+        unsigned long       m_dwGold;
+
+        unsigned char       m_szPassword[Deposit::PASSWORD_LENGTH];
+
+        unsigned char       m_nXSize;
+        unsigned char       m_nYSize;
+        unsigned char       m_nTabNum;
+        bool                m_bLoginSuccess;
+    };
+};
+
+Item::CItemContainer* Item::CDepositContainer::GetTab(unsigned char nTabNum)
+{
+    return (nTabNum < m_nTabNum && NULL != m_lpArrayContainer) ? 
+        &m_lpArrayContainer[nTabNum] : NULL;
+}
+
+
+inline void Item::CDepositContainer::SetTabFlag(unsigned long dwTabFlag)
+{
+    m_dwTabFlag = dwTabFlag | PktDepositUpdateDB::ITEM_TAB1;
+
+    if(0 == memcmp(m_szPassword, "0000", Deposit::PASSWORD_LENGTH) && 0 == (m_dwTabFlag & PktDepositUpdateDB::USED_DEPOSIT))
+    {
+        m_dwTabFlag &= ~PktDepositUpdateDB::USED_DEPOSIT;
+    }
+    else
+    {
+        m_dwTabFlag |= PktDepositUpdateDB::USED_DEPOSIT;        
+    }
+}
+
+inline void Item::CDepositContainer::SetPassword(const char* szPassword, size_t nPasswordLength)
+{
+    memcpy(m_szPassword, szPassword, 
+        (Deposit::PASSWORD_LENGTH < nPasswordLength) ? Deposit::PASSWORD_LENGTH : nPasswordLength);
+}
+
+inline bool Item::CDepositContainer::Login(const char* szPassword, size_t nPasswordLength, char bSavePassword)
+{
+    if(0 == memcmp(m_szPassword, szPassword, 
+        (Deposit::PASSWORD_LENGTH < nPasswordLength) ? Deposit::PASSWORD_LENGTH : nPasswordLength))
+    {
+        m_bLoginSuccess = true;
+        if(0 != bSavePassword)
+        {
+            m_dwTabFlag |= PktDepositUpdateDB::SAVED_PASSWORD;
+        }
+
+        m_dwTabFlag |= PktDepositUpdateDB::USED_DEPOSIT;
+    }
+
+    return m_bLoginSuccess;
+}
+
+inline bool Item::CDepositContainer::BuyTab(unsigned char cTabNum)
+{
+    if(cTabNum < m_nTabNum) 
+    {
+        m_dwTabFlag |= (1 << cTabNum);
+        return true;
+    }
+    
+    return false;
+}
+
+
+#endif

Server/RylServerProject/RylGameLibrary/Item/Container/EquipmentsContainer.h

@@ -0,0 +1,88 @@
+#ifndef _EQUIPMENTS_CONTAINER_H_
+#define _EQUIPMENTS_CONTAINER_H_
+
+#include <Item/Item.h>
+#include "ItemContainer.h"
+
+// Àü¹æ ÂüÁ¶
+class CCharacter;
+
+namespace Item
+{
+	class CEquipmentsContainer : public CListContainer
+    {
+	protected:
+
+        CCharacter*		m_lpOwner;
+
+		unsigned char	m_cRightHand;
+		unsigned char	m_cLeftHand;
+		unsigned char	m_cRideFlag;
+	
+	public:
+
+        CEquipmentsContainer();
+        virtual ~CEquipmentsContainer();
+
+        bool Initialize(CCharacter* lpCharacter, unsigned short nMaxSize);
+
+		virtual CItem* GetItem(ItemPos itemPos);
+        virtual bool SetItem(ItemPos itemPos, CItem* lpItem);
+        virtual bool RemoveItem(ItemPos itemPos);
+
+        void GetEquipmentView(unsigned short* usProtoTypeArray, unsigned int nStartPos = 0,
+            int nCopyNum = Item::EquipmentPos::MAX_EQUPMENT_POS);
+
+		void ChangeWeaponAndShield() { m_cRightHand = GetExtraRightHandIndex(); m_cLeftHand = GetExtraLeftHandIndex(); }
+		void ChangeRide(char cRide) 
+		{ 
+			 m_cRideFlag = cRide;
+		}
+		
+
+		unsigned char GetRightHandIndex(void) const		{ return m_cRightHand;	}
+		unsigned char GetLeftHandIndex(void) const		{ return m_cLeftHand;	}
+
+		unsigned char GetExtraRightHandIndex() const 
+		{ 
+			return (m_cRightHand == Item::EquipmentPos::WEAPON_HAND1) ? 
+				Item::EquipmentPos::WEAPON_HAND2 : Item::EquipmentPos::WEAPON_HAND1; 
+		}
+		unsigned char GetExtraLeftHandIndex() const 
+		{ 
+			return (m_cLeftHand == Item::EquipmentPos::SHIELD_HAND1) ? 
+				Item::EquipmentPos::SHIELD_HAND2 : Item::EquipmentPos::SHIELD_HAND1; 
+		}
+
+		Item::CEquipment* GetRightHand(void) const	{ return static_cast<CEquipment*>(m_lppItems[m_cRightHand]);	}
+		Item::CEquipment* GetLeftHand(void) const	{ return static_cast<CEquipment*>(m_lppItems[m_cLeftHand]);		}
+
+		void GetEquipList(Item::CEquipment** ppEquip);
+
+		bool CheckEquipPos(ItemPos itemPos, const CEquipment* lpEquip);
+		bool CheckEquipInitPos(ItemPos itemPos, const CEquipment* lpEquip);
+
+		virtual bool SerializeIn(const char* szItemBuffer_In, unsigned long dwBufferSize_In);
+	};
+};
+
+
+inline void Item::CEquipmentsContainer::GetEquipmentView(unsigned short* usProtoTypeArray, unsigned int nStartPos, int nCopyNum)
+{
+    int nPastEnd = nStartPos + nCopyNum;
+    nPastEnd = Item::EquipmentPos::MAX_EQUPMENT_POS < nPastEnd ? Item::EquipmentPos::MAX_EQUPMENT_POS : nPastEnd;
+
+	for (int nDstIndex = 0, nSrcIndex = nStartPos; nSrcIndex < nPastEnd; ++nSrcIndex, ++nDstIndex) 
+	{
+		if (NULL == m_lppItems[nSrcIndex])
+		{ 
+			usProtoTypeArray[nDstIndex] = 0; 
+			continue; 
+		}		
+
+		usProtoTypeArray[nDstIndex] = m_lppItems[nSrcIndex]->GetPrototypeID();
+	}
+}
+
+
+#endif

Server/RylServerProject/RylGameLibrary/Item/Container/ExchangeContainer.cpp

@@ -0,0 +1,279 @@
+#include "stdafx.h"
+#include <Item/Item.h>
+#include "ExchangeContainer.h"
+#include <Log/LogCommands.h>
+#include <Log/ItemLog.h>
+#include <Creature/Character/Character.h>
+#include <Network/Dispatch/GameClient/GameClientDispatch.h>
+#include <Network/Dispatch/GameClient/SendCharCommunity.h>
+#include <Network/Dispatch/GameClient/SendCharItem.h>
+#include <Network/Packet/PacketStruct/CharItemPacket.h>
+
+using namespace Item;
+
+Item::CExchangeContainer::CExchangeContainer()
+:   m_dwGold(0), m_bLock(false), m_bAccept(false), m_lpOwner(NULL), m_lpExchangeCharacter(NULL)
+{
+
+
+}
+
+
+Item::CExchangeContainer::~CExchangeContainer()
+{
+
+}
+
+
+Item::CItem* Item::CExchangeContainer::GetItem(Item::ItemPos itemPos) 
+{ 
+	return Item::CArrayContainer::GetItem(itemPos); 
+}
+
+bool Item::CExchangeContainer::SetItem(Item::ItemPos itemPos, Item::CItem* lpItem) 
+{ 
+	if (false == CheckLock())
+	{
+		ERRLOG1(g_Log, "CID:0x%10u 락한 상태에서 교환창에 아이템을 올리려 합니다.", m_dwCID);		
+	}
+	else
+	{
+		if (Item::CArrayContainer::SetItem(itemPos, lpItem)) 
+		{
+			if (NULL != m_lpExchangeCharacter)
+			{
+				CGameClientDispatch* lpGameClientDispatch = m_lpExchangeCharacter->GetDispatcher();
+				if (NULL != lpGameClientDispatch)
+				{
+					GameClientSendPacket::SendCharExchangeItem(lpGameClientDispatch->GetSendStream(), 
+						m_lpOwner->GetCID(), 0, GetItem(itemPos), itemPos, false, false);
+				}
+			}
+
+			return true;
+		}
+	}
+
+	return false;
+}
+
+bool Item::CExchangeContainer::RemoveItem(Item::ItemPos itemPos) 
+{ 
+	if (false == CheckLock())
+	{
+		ERRLOG1(g_Log, "CID:0x%10u 락한 상태에서 교환창에 아이템을 내리려 합니다.", m_dwCID);		
+		return false;
+	}
+
+    if (NULL != m_lpExchangeCharacter)
+    {
+        CGameClientDispatch* lpGameClientDispatch = m_lpExchangeCharacter->GetDispatcher();
+        if (NULL != lpGameClientDispatch)
+        {
+            GameClientSendPacket::SendCharExchangeItem(lpGameClientDispatch->GetSendStream(), 
+                m_dwCID, 0, GetItem(itemPos), itemPos, false, true);
+        }
+    }
+
+	return Item::CArrayContainer::RemoveItem(itemPos); 
+}
+
+
+bool Item::CExchangeContainer::AddGold(unsigned long dwGold)
+{
+	if (false == CheckLock()) 
+	{
+		ERRLOG1(g_Log, "CID:0x%10u 락한 상태에서 교환창에 돈을 올리려 합니다.", m_dwCID);		
+	}
+    else if(m_dwGold <= ULONG_MAX - dwGold)
+    {
+	    m_dwGold += dwGold;
+
+        if(NULL != m_lpExchangeCharacter)
+        {
+            CGameClientDispatch* lpExchangerDispatch = m_lpExchangeCharacter->GetDispatcher();
+            if(NULL != lpExchangerDispatch)
+            {
+                GameClientSendPacket::SendCharExchangeItem(lpExchangerDispatch->GetSendStream(),
+                    m_dwCID, m_dwGold, NULL, Item::ItemPos(), false, false);
+            }
+        }
+
+        return true;
+    }
+    else
+    {
+        ERRLOG2(g_Log, "CID:0x%10u 교환 돈 오버플로우가 발생했습니다. : %dGold", m_dwCID, dwGold);
+    }
+
+	return false;
+}
+
+
+bool Item::CExchangeContainer::DeductGold(unsigned long dwGold)
+{ 
+	if (false == CheckLock()) 
+	{
+		ERRLOG1(g_Log, "CID:0x%10u 락한 상태에서 교환창의 돈을 내리려 합니다.", m_dwCID);		
+	}
+    else if (m_dwGold < dwGold)
+    { 
+        ERRLOG1(g_Log, "CID:0x%10u 내리려는 돈의 양이, 현재 보유 금액보다 큽니다.", m_dwCID);		
+	}
+    else
+    {
+        m_dwGold -= dwGold; 
+
+        if(NULL != m_lpExchangeCharacter)
+        {
+            CGameClientDispatch* lpExchangerDispatch = m_lpExchangeCharacter->GetDispatcher();
+            if(NULL != lpExchangerDispatch)
+            {
+                GameClientSendPacket::SendCharExchangeItem(lpExchangerDispatch->GetSendStream(),
+                    m_dwCID, m_dwGold, NULL, Item::ItemPos(), false, false);
+            }
+        }
+
+        return true;
+    }
+
+    return false;
+}
+
+
+inline bool Item::CExchangeContainer::CheckLock(void)
+{
+	if (m_bLock)
+    {
+		return false;
+	}
+
+    if (NULL == m_lpOwner || NULL == m_lpExchangeCharacter) 
+    {
+		return true;
+	}
+
+	if (m_lpExchangeCharacter->GetExchange().GetLock())
+	{
+        CGameClientDispatch* lpOwnerDispatch        = m_lpOwner->GetDispatcher();
+        CGameClientDispatch* lpExchangerDispatch    = m_lpExchangeCharacter->GetDispatcher();
+
+		m_lpExchangeCharacter->GetExchange().SetLock(false);
+
+        if(NULL != lpOwnerDispatch)
+        {
+            GameClientSendPacket::SendCharExchangeCmd(lpOwnerDispatch->GetSendStream(), m_lpExchangeCharacter->GetCID(), 
+                m_dwCID, PktExC::EXC_UNLOCK, PktExC::NO_SERVER_ERR);
+        }
+
+        if(NULL != lpExchangerDispatch)
+        {
+		    GameClientSendPacket::SendCharExchangeCmd(lpExchangerDispatch->GetSendStream(), m_lpExchangeCharacter->GetCID(), 
+                m_dwCID, PktExC::EXC_UNLOCK, PktExC::NO_SERVER_ERR);
+        }
+	}
+
+	return true;
+}
+
+
+
+bool Item::CExchangeContainer::ExchangeOK(bool bOK)
+{
+    bool bResult = true;
+
+	if (NULL == m_lpExchangeCharacter) 
+	{
+        bResult = false;
+		ERRLOG1(g_Log, "CID:0x%10u 거래하는 캐릭터가 없는데 교환이 성립되었습니다.", m_dwCID);
+	}
+    else
+    {
+        Item::CExchangeContainer& ExchangerContainer = m_lpExchangeCharacter->GetExchange();
+
+        if (bOK)
+	    {
+            unsigned long dwExchangerCID = m_lpExchangeCharacter->GetCID();
+
+		    // 교환 전 로그.
+		    GAMELOG::LogExchangeItem(*m_lpOwner, dwExchangerCID, *this, GAMELOG::CMD::BEFORE_EXCHANGE_ITEM);
+		    GAMELOG::LogExchangeItem(*m_lpExchangeCharacter, m_dwCID, ExchangerContainer, GAMELOG::CMD::BEFORE_EXCHANGE_ITEM);
+
+            // 교환
+            std::swap(m_lppItems, ExchangerContainer.m_lppItems);		    
+		    std::swap(m_dwGold, ExchangerContainer.m_dwGold);
+
+		    // 교환 후 로그.
+		    GAMELOG::LogExchangeItem(*m_lpOwner, dwExchangerCID, *this, GAMELOG::CMD::AFTER_EXCHANGE_ITEM);
+		    GAMELOG::LogExchangeItem(*m_lpExchangeCharacter, m_dwCID, ExchangerContainer, GAMELOG::CMD::AFTER_EXCHANGE_ITEM);
+        }
+
+	    m_lpExchangeCharacter->AddGold(ExchangerContainer.GetGold(), false);
+	    ExchangerContainer.Clear();
+
+	    m_lpExchangeCharacter->DBUpdateForce(DBUpdateData::UPDATE);
+    }
+
+	m_lpOwner->AddGold(m_dwGold, false);
+	Clear();
+
+    m_lpOwner->DBUpdateForce(DBUpdateData::UPDATE);
+	return bResult;
+}
+
+
+void Item::CExchangeContainer::ExchangeCancel(void)
+{
+	if (NULL == m_lpExchangeCharacter) 
+    {
+		return;
+	}
+
+	CGameClientDispatch*        lpOwnerDispatch             = m_lpOwner->GetDispatcher();
+    CGameClientDispatch*        lpExchangerDispatch         = m_lpExchangeCharacter->GetDispatcher();
+
+    unsigned long                       m_dwExchangerCID            = m_lpExchangeCharacter->GetCID();    
+    Item::CExchangeContainer&   ExchangerExchageContainer   = m_lpExchangeCharacter->GetExchange();
+
+	if (m_bAccept)
+	{
+		m_bAccept = false;
+
+        if(NULL != lpOwnerDispatch)
+        {
+            GameClientSendPacket::SendCharExchangeCmd(lpOwnerDispatch->GetSendStream(), 
+                m_dwCID, m_dwExchangerCID, PktExC::EXC_CANCEL, PktExC::NO_SERVER_ERR);
+        }
+
+        if(NULL != lpExchangerDispatch)
+        {
+            GameClientSendPacket::SendCharExchangeCmd(lpExchangerDispatch->GetSendStream(), 
+                m_dwCID, m_dwExchangerCID, PktExC::EXC_CANCEL, PktExC::NO_SERVER_ERR);
+        }
+	}
+
+	if (ExchangerExchageContainer.GetAccept())
+	{
+		ExchangerExchageContainer.SetAccept(false);
+
+        if(NULL != lpOwnerDispatch)
+        {
+            GameClientSendPacket::SendCharExchangeCmd(lpOwnerDispatch->GetSendStream(),
+                m_dwExchangerCID, m_dwCID, PktExC::EXC_CANCEL, PktExC::NO_SERVER_ERR);
+        }
+
+        if(NULL != lpExchangerDispatch)
+        {
+            GameClientSendPacket::SendCharExchangeCmd(lpExchangerDispatch->GetSendStream(), 
+                m_dwExchangerCID, m_dwCID, PktExC::EXC_CANCEL, PktExC::NO_SERVER_ERR);
+        }
+	}
+}
+
+
+bool Item::CExchangeContainer::Initialize(CCharacter* lpCharacter, 
+                                          unsigned char cExchangeWidth, unsigned char cExchangeHeight)
+{
+    m_lpOwner = lpCharacter;
+    return CArrayContainer::Initialize(lpCharacter->GetCID(), cExchangeWidth, cExchangeHeight, 1);
+}

Server/RylServerProject/RylGameLibrary/Item/Container/ExchangeContainer.h

@@ -0,0 +1,64 @@
+#ifndef _EXCHANGE_CONTAINER_H_
+#define _EXCHANGE_CONTAINER_H_
+
+#include "ItemContainer.h"
+
+// Àü¹æ ÂüÁ¶
+class CCharacter;
+
+namespace Item
+{
+	class CExchangeContainer : public CArrayContainer
+    {
+    public:
+
+        CExchangeContainer();
+        virtual ~CExchangeContainer();
+
+        bool Initialize(CCharacter* lpCharacter, unsigned char cExchangeWidth, unsigned char cExchangeHeight);
+
+        virtual CItem* GetItem(ItemPos itemPos);
+        virtual bool SetItem(ItemPos itemPos, CItem* lpItem);
+        virtual bool RemoveItem(ItemPos itemPos);        
+        		
+		void SetExchangeCharacter(CCharacter *pCharacter) { m_lpExchangeCharacter = pCharacter; }
+		CCharacter* GetExchangeCharacter(void) { return m_lpExchangeCharacter; }
+
+		bool ExchangeOK(bool bOK);
+		void ExchangeCancel(void);
+
+		bool AddGold(unsigned long dwGold);        
+		bool DeductGold(unsigned long dwGold);
+        unsigned long GetGold() const { return m_dwGold; }
+
+		void SetLock(bool bLock) { m_bLock = bLock; }
+		bool GetLock(void) { return m_bLock; }
+		void SetAccept(bool bAccept) { m_bAccept = bAccept; }
+		bool GetAccept(void) { return m_bAccept; }
+
+	protected:
+
+		inline bool CheckLock();
+        inline void Clear();
+
+        CCharacter*     m_lpOwner;
+        CCharacter*		m_lpExchangeCharacter;
+		unsigned long	m_dwGold;
+
+		bool	        m_bLock;
+		bool	        m_bAccept;
+        unsigned char   m_cPadding[2];  // 4 byte alignment...
+    };
+};
+
+
+void Item::CExchangeContainer::Clear()
+{
+	m_dwGold = 0;
+	m_lpExchangeCharacter = NULL;
+	m_bLock = false;
+	m_bAccept = false;
+}
+
+
+#endif

Server/RylServerProject/RylGameLibrary/Item/Container/InventoryContainer.cpp

@@ -0,0 +1,336 @@
+
+#include "stdafx.h"
+
+#include <Creature/Character/Character.h>
+#include <Item/Container/ContainerConstant.h>
+
+#include "InventoryContainer.h"
+
+using namespace Item;
+
+CInventoryContainer::CInventoryContainer()
+:	m_bAdminToolFlag(false)
+{
+}
+
+CInventoryContainer::~CInventoryContainer()
+{
+}
+
+bool CInventoryContainer::SetItem(ItemPos itemPos, CItem* lpItem)
+{
+	if (false == m_bAdminToolFlag)
+	{
+		CCharacter* lpCharacter = CCreatureManager::GetInstance().GetCharacter(m_dwCID);
+		if (NULL == lpCharacter)
+		{
+			return false;
+		}
+
+		// 퀘스트 트리거 발동
+		short wCount = (true == lpItem->IsSet(Item::DetailData::STACKABLE)) ? lpItem->GetNumOrDurability() : 1;
+		lpCharacter->CheckTrigger(Quest::TRIGGER_PICK, lpItem->GetPrototypeID(), Position(), wCount);
+	}
+
+	if (NULL == lpItem)
+	{
+		ERRLOG1(g_Log, "CID:%10u 아이템이 NULL입니다.", m_dwCID);
+		return false;
+	}
+
+	unsigned char cX, cY, cTab;
+	itemPos.GetPos(cX, cY, cTab);
+
+	// 퀘스트 탭 체크
+	unsigned char cItemType = lpItem->GetItemInfo().m_DetailData.m_cItemType;
+/*
+	// edith 2008.06.04 인벤토리 퀘스트 아이템 탭 제거
+	if ((Item::ItemType::QUEST_ITEM == cItemType && ContainerConstant::QUEST_INVENTORY_TAB != cTab) ||
+		(Item::ItemType::QUEST_ITEM != cItemType && ContainerConstant::QUEST_INVENTORY_TAB == cTab))
+	{
+		ERRLOG4(g_Log, "CID:%10u 아이템에 맞는 올바른 탭이 아닙니다. ItemType:%d, Tab:%d/%d", 
+			m_dwCID, cItemType, cTab, m_nTabNum);
+		return false;
+	}
+*/
+	unsigned char cXSize = lpItem->GetItemInfo().m_DetailData.m_cXSize;
+	unsigned char cYSize = lpItem->GetItemInfo().m_DetailData.m_cYSize;
+
+	if (m_nXSize < static_cast<size_t>(cX + cXSize) || 
+		m_nYSize < static_cast<size_t>(cY + cYSize) || m_nTabNum <= cTab)
+	{
+		ERRLOG9(g_Log, "CID:%10u 아이템 위치 및 크기가 올바르지 않습니다. "
+			"X:%d/%d, Y:%d/%d, Tab:%d/%d, X크기:%d, Y크기:%d", 
+			m_dwCID, cX, m_nXSize, cY, m_nYSize, cTab, m_nTabNum, cXSize, cYSize);
+		return false;
+	}
+
+	CItem** lppItemYIndexPastEnd = m_lppItems + m_nSizePerTab * cTab + m_nXSize * (cY + cYSize);
+	CItem **lppItemYIndex, **lppItemXIndex, **lppItemXIndexPastEnd;
+
+	for (lppItemYIndex = m_lppItems + m_nSizePerTab * cTab + cY * m_nXSize;
+		lppItemYIndex != lppItemYIndexPastEnd; lppItemYIndex += m_nXSize)
+	{
+		lppItemXIndexPastEnd = lppItemYIndex + cX + cXSize;
+
+		for (lppItemXIndex = lppItemYIndex + cX;
+			lppItemXIndex != lppItemXIndexPastEnd; ++lppItemXIndex)
+		{
+			if (0 != *lppItemXIndex)
+			{
+				ERRLOG4(g_Log, "CID:%10u (%d,%d,%d) 이미 그 장소에 아이템이 있습니다.",
+					m_dwCID, cX, cY, cTab);
+				return false;
+			}            
+		}        
+	}
+
+	for (lppItemYIndex = m_lppItems + m_nSizePerTab * cTab + cY * m_nXSize;
+		lppItemYIndex != lppItemYIndexPastEnd; lppItemYIndex += m_nXSize)
+	{
+		lppItemXIndexPastEnd = lppItemYIndex + cX + cXSize;
+
+		for (lppItemXIndex = lppItemYIndex + cX;
+			lppItemXIndex != lppItemXIndexPastEnd; ++lppItemXIndex)
+		{
+			*lppItemXIndex = m_lpNullItem;
+		}
+	}
+
+	m_lppItems[m_nSizePerTab * cTab + m_nXSize * cY + cX] = lpItem;
+	lpItem->MoveItem(itemPos);
+	return true;
+}
+
+bool CInventoryContainer::TestItem(ItemPos itemPos, unsigned short usProtoTypeID, unsigned char cNum)
+{
+	const Item::ItemInfo* lpItemInfo = CItemMgr::GetInstance().GetItemInfo(usProtoTypeID);
+
+	if (NULL == lpItemInfo)
+	{
+		ERRLOG2(g_Log, "CID:%10u 아이템 종류 ID가 없습니다. usProtoTypeID:%d",
+			m_dwCID, usProtoTypeID);
+		return false;
+	}
+
+	unsigned char cX, cY, cTab;
+	itemPos.GetPos(cX, cY, cTab);
+
+	// 퀘스트 탭 체크
+	unsigned char cItemType = lpItemInfo->m_DetailData.m_cItemType;
+/*
+	// edith 2008.06.04 인벤토리 퀘스트 아이템 탭 제거
+	if ((Item::ItemType::QUEST_ITEM == cItemType && ContainerConstant::QUEST_INVENTORY_TAB != cTab) ||
+		(Item::ItemType::QUEST_ITEM != cItemType && ContainerConstant::QUEST_INVENTORY_TAB == cTab))
+	{
+		ERRLOG4(g_Log, "CID:%10u 아이템에 맞는 올바른 탭이 아닙니다. ItemType:%d, Tab:%d/%d", 
+			m_dwCID, cItemType, cTab, m_nTabNum);
+		return false;
+	}
+*/
+	unsigned char cXSize = lpItemInfo->m_DetailData.m_cXSize;
+	unsigned char cYSize = lpItemInfo->m_DetailData.m_cYSize;
+
+	if (m_nXSize < static_cast<size_t>(cX + cXSize) || 
+		m_nYSize < static_cast<size_t>(cY + cYSize) || m_nTabNum <= cTab)
+	{
+		ERRLOG9(g_Log, "CID:%10u 아이템 위치 및 크기가 올바르지 않습니다. "
+			"X:%d/%d, Y:%d/%d, Tab:%d/%d, X크기:%d, Y크기:%d", 
+			m_dwCID, cX, m_nXSize, cY, m_nYSize, cTab, m_nTabNum, cXSize, cYSize);
+		return false;
+	}
+
+	CItem** lppItemYIndexPastEnd = m_lppItems + m_nSizePerTab * cTab + m_nXSize * (cY + cYSize);
+	CItem **lppItemYIndex, **lppItemXIndex, **lppItemXIndexPastEnd;
+
+	for (lppItemYIndex = m_lppItems + m_nSizePerTab * cTab + cY * m_nXSize;
+		lppItemYIndex != lppItemYIndexPastEnd; lppItemYIndex += m_nXSize)
+	{
+		lppItemXIndexPastEnd = lppItemYIndex + cX + cXSize;
+
+		for (lppItemXIndex = lppItemYIndex + cX;
+			lppItemXIndex != lppItemXIndexPastEnd; ++lppItemXIndex)
+		{
+			CItem* lpPreItem = *lppItemXIndex;
+			if (NULL != lpPreItem)
+			{
+				// 스택인 경우
+				if (true == lpPreItem->IsSet(DetailData::STACKABLE))
+				{
+					if (lpPreItem->GetItemInfo().m_usProtoTypeID == usProtoTypeID)
+					{
+						if (lpPreItem->GetNumOrDurability() + cNum <= lpPreItem->GetMaxNumOrDurability())
+						{
+							return true;
+						}
+					}
+				}
+
+				ERRLOG4(g_Log, "CID:%10u (%d,%d,%d) 이미 그 장소에 아이템이 있고, 스택할 수도 없습니다.",
+					m_dwCID, cX, cY, cTab);
+				return false;
+			}
+		}
+	}
+
+	return true;
+}
+
+bool CInventoryContainer::RemoveItem(ItemPos itemPos)
+{
+	CItem* lpItem = GetItem(itemPos);
+	if (NULL == lpItem)
+	{
+		return false;
+	}
+
+	if (false == m_bAdminToolFlag)
+	{
+		CCharacter* lpCharacter = CCreatureManager::GetInstance().GetCharacter(m_dwCID);
+		if (NULL == lpCharacter)
+		{
+			return false;
+		}
+
+		// 퀘스트 트리거 발동
+		short wCount = (true == lpItem->IsSet(Item::DetailData::STACKABLE)) ? lpItem->GetNumOrDurability() * (-1) : -1;
+		lpCharacter->CheckTrigger(Quest::TRIGGER_PICK, lpItem->GetPrototypeID(), Position(), wCount);
+	}
+
+	return CArrayContainer::RemoveItem(itemPos);		
+}
+
+ItemPos CInventoryContainer::GetBlankPos(unsigned short wProtoTypeID, unsigned char cNum, bool bStack, CItem** ppPrevItem)
+{
+	Item::ItemPos DstPos;
+	DstPos.m_cPos = TakeType::TS_NONE;
+
+	const Item::ItemInfo* lpItemInfo = Item::CItemMgr::GetInstance().GetItemInfo(wProtoTypeID);
+	if (NULL != lpItemInfo)
+	{
+		unsigned char cHeight, cWidth, cTab;
+		unsigned char cXSize = lpItemInfo->m_DetailData.m_cXSize;
+		unsigned char cYSize = lpItemInfo->m_DetailData.m_cYSize;
+
+		// 퀘스트 탭 체크
+		unsigned char cItemType = lpItemInfo->m_DetailData.m_cItemType;
+
+		unsigned char cStartTab = 0;
+		unsigned char cEndTab = m_nTabNum;
+/*
+		// edith 2008.06.04 인벤토리 퀘스트 아이템 탭 제거
+		unsigned char cEndTab = m_nTabNum - 1;
+
+		if (Item::ItemType::QUEST_ITEM == cItemType)
+		{
+			cStartTab = m_nTabNum - 1;
+			cEndTab = m_nTabNum;
+		}
+*/
+		if (DetailData::STACKABLE == (lpItemInfo->m_DetailData.m_dwFlags & DetailData::STACKABLE) && true == bStack)
+		{
+			// 스택할수 있는 아이템이 있는가 찾는다.
+			for (cTab = cStartTab; cTab < cEndTab; ++cTab)
+			{
+				for (cHeight = 0; cHeight < m_nYSize; ++cHeight)
+				{
+					if (cHeight + cYSize> m_nYSize) 
+					{
+						// YSize가 경계를 벗어나면 다음 탭으로...
+						break;
+					}
+
+					for (cWidth = 0; cWidth < m_nXSize; ++cWidth)
+					{
+						if (cWidth + cXSize > m_nXSize) 
+						{
+							// XSize가 경계를 벗어나면 다음 행으로...
+							break;	
+						}
+
+						CItem* lpItem = m_lppItems[m_nSizePerTab * cTab + m_nXSize * cHeight + cWidth];
+						if (NULL != lpItem)
+						{
+							// 장비 아이템은 스택할 수 없다.
+							if (false == lpItem->IsSet(DetailData::EQUIP))
+							{
+								// 이미 아이템이 있을 때, 획득한 아이템이 스택가능한 아이템이고, Max 개가 아니라면,
+								// 해당 자리에 스택시킨다.
+								if (lpItem->GetItemInfo().m_usProtoTypeID == wProtoTypeID)
+								{
+									if (lpItem->GetNumOrDurability() + cNum <= lpItem->GetMaxNumOrDurability())
+									{
+										*ppPrevItem = lpItem;
+
+										DstPos.m_cPos = TakeType::TS_INVEN;
+										DstPos.SetPos(cWidth, cHeight, cTab);
+										return DstPos;
+									}
+								}
+							}
+						}
+					}
+
+					// 아이템이 없거나, 다르거나, 스택할수 없으면, 다음 공간을 찾는다.
+				}
+			}
+		}
+
+		// 스택할 수 있는 아이템이 없으므로, 빈 공간을 찾는다.
+		for (cTab = cStartTab; cTab < cEndTab; ++cTab)
+		{
+			for (cHeight = 0; cHeight < m_nYSize; ++cHeight)
+			{
+				if (cHeight + cYSize> m_nYSize) 
+				{
+					// YSize가 경계를 벗어나면 다음 탭으로...
+					break;
+				}
+
+				for (cWidth = 0; cWidth < m_nXSize; ++cWidth)
+				{
+					if (cWidth + cXSize > m_nXSize) 
+					{
+						// XSize가 경계를 벗어나면 다음 행으로...
+						break;	
+					}
+
+					CItem* lpItem = m_lppItems[m_nSizePerTab * cTab + m_nXSize * cHeight + cWidth];
+					if (NULL == lpItem)
+					{
+						unsigned char cX, cY;
+						lpItem = NULL;
+
+						// 아이템이 없는 칸이면 크기를 비교하여 공간이 충분한가 체크
+						for (cX = cWidth; cX < cWidth + cXSize; ++cX)
+						{
+							for (cY = cHeight; cY < cHeight + cYSize; ++cY)
+							{
+								lpItem = m_lppItems[m_nSizePerTab * cTab + m_nXSize * cY + cX];
+								if (NULL != lpItem) 
+								{
+									break;
+								}
+							}
+
+							if (NULL != lpItem) 
+							{
+								break;
+							}
+						}
+
+						if (NULL == lpItem)
+						{
+							DstPos.m_cPos = TakeType::TS_INVEN;
+							DstPos.SetPos(cWidth, cHeight, cTab);
+							return DstPos;
+						}
+					}
+				}
+			}
+		}
+	}
+
+	return DstPos;
+}
+

Server/RylServerProject/RylGameLibrary/Item/Container/InventoryContainer.h

@@ -0,0 +1,32 @@
+#ifndef _INVENTORY_CONTAINER_H_
+#define _INVENTORY_CONTAINER_H_
+
+#include "ItemContainer.h"
+
+namespace Item
+{    
+    class CItem;
+
+	class CInventoryContainer : public CArrayContainer
+    {
+    public:
+
+        CInventoryContainer();
+        virtual ~CInventoryContainer();
+
+		ItemPos GetBlankPos(unsigned short wProtoTypeID, unsigned char cNum, bool bStack, CItem** ppPrevItem);
+		bool TestItem(ItemPos itemPos, unsigned short usProtoTypeID, unsigned char cNum); 
+
+		virtual bool SetItem(ItemPos itemPos, CItem* lpItem);
+		virtual bool RemoveItem(ItemPos itemPos);
+
+		void SetAdminTool(void)		{ m_bAdminToolFlag = true;	}
+
+
+	private:
+
+		bool	m_bAdminToolFlag;
+	};
+};
+
+#endif

Server/RylServerProject/RylGameLibrary/Item/Container/ItemContainer.cpp

@@ -0,0 +1,769 @@
+#include "stdafx.h"
+
+#include <Pattern/Singleton.h>
+#include <Utility/Math/Math.h>
+
+#include <Network/Dispatch/GameClient/GameClientDispatch.h>
+#include <Network/Dispatch/GameClient/SendCharItem.h>
+
+#include <Creature/CreatureManager.h>
+#include <Creature/Character/Character.h>
+
+#include <Item/Item.h>
+#include <Item/ItemMgr.h>
+#include <Item/ItemFactory.h>
+#include "ItemContainer.h"
+
+namespace Item
+{
+    class CNullItem : public CItem, public CSingleton<CNullItem>
+    {
+    public:
+        virtual ~CNullItem() { }
+    private:
+
+        CNullItem(const ItemInfo& itemInfo) : CItem(itemInfo) { }
+        
+        static ItemInfo  ms_thisiteminfo;
+        static CNullItem ms_this;
+    };
+};
+
+Item::ItemInfo      Item::CNullItem::ms_thisiteminfo(0xFFFF);        
+Item::CNullItem     Item::CNullItem::ms_this(Item::CNullItem::ms_thisiteminfo);
+
+
+size_t LogErrorItem(unsigned long dwCID, const char* szDetail, const char* szBuffer)
+{
+    const int   MIN_BUFFER = 64;
+    char        szItemUID[MIN_BUFFER];
+
+    const Item::ItemData* lpItemData = reinterpret_cast<const Item::ItemData*>(szBuffer);    
+    Math::Convert::Hex64ToStr(szItemUID, lpItemData->m_dwUID);
+
+    ERRLOG4(g_Log, "CID:%10u %s. UID:%s, ProtoTypeID:%d", 
+        dwCID, szDetail, szItemUID, lpItemData->m_usProtoTypeID);
+
+    return lpItemData->m_cItemSize;
+}
+
+
+
+// ----------------------------------------------------------------------------------------
+// CItemContainer
+
+Item::CItemContainer::CItemContainer()
+:   m_dwCID(0), m_nMaxSize(0), m_lpNullItem(&CNullItem::GetInstance()), 
+    m_lppItems(NULL), m_usFlags(0)
+{
+
+}
+
+Item::CItemContainer::~CItemContainer()
+{
+    Destroy();
+}
+
+
+bool Item::CItemContainer::Initialize(unsigned long dwCID, unsigned short nMaxSize)
+{    
+    Destroy();
+
+    m_dwCID     = dwCID;
+    m_nMaxSize  = nMaxSize;
+
+    m_lppItems  = new CItem*[m_nMaxSize];
+    if(NULL != m_lppItems)
+    {
+        std::fill_n(m_lppItems, m_nMaxSize, reinterpret_cast<CItem*>(NULL));
+        return true;
+    }
+
+    return false;
+}
+
+void Item::CItemContainer::ClearItems()
+{
+    if(NULL != m_lppItems)
+    {
+        CItem** lppItem         = m_lppItems;
+        CItem** lppItemPastEnd  = m_lppItems + m_nMaxSize;
+
+		// edith 2010.01.23 아이템 컨테이너 관련 버그 수정. 
+//      for (; lppItem != lppItemPastEnd; ++lppItem)
+        for (int i = 0; i < m_nMaxSize; ++i, ++lppItem)
+        {
+            CItem* lpItem = *lppItem;
+            if(NULL != lpItem && m_lpNullItem != lpItem)
+            {
+                DELETE_ITEM(lpItem);                
+            }            
+        }
+
+        std::fill_n(m_lppItems, m_nMaxSize, reinterpret_cast<CItem*>(NULL));
+    }
+}
+
+
+void Item::CItemContainer::Destroy()
+{
+    if(NULL != m_lppItems)
+    {
+        ClearItems();
+ 
+        delete [] m_lppItems;
+        m_lppItems = NULL;
+    }
+}
+
+
+void Item::CItemContainer::DumpItemInfo()
+{
+    const int MIN_BUFFER = 32;
+    const int MAX_BUFFER = 256;
+    char szUID[MIN_BUFFER];
+    char szBuffer[MAX_BUFFER];
+
+    CItem** lppItem         = m_lppItems;
+    CItem** lppItemPastEnd  = m_lppItems + m_nMaxSize;
+    
+	// edith 2010.01.23 아이템 컨테이너 관련 버그 수정. 
+//  for (; lppItem != lppItemPastEnd; ++lppItem)
+    for (int i = 0; i < m_nMaxSize; ++i, ++lppItem)
+    {
+        const CItem* lpItem = *lppItem;
+
+        if(NULL != lpItem && m_lpNullItem != lpItem)
+        {
+            Math::Convert::Hex64ToStr(szUID, lpItem->GetUID());
+                        
+            const ItemPos itemPos = lpItem->GetPos();
+            const DetailData& detailData = lpItem->GetItemInfo().m_DetailData;
+
+            unsigned char cX, cY, cTab;
+            itemPos.GetPos(cX, cY, cTab);
+
+            _snprintf(szBuffer, MAX_BUFFER, "CID:%10u 의 아이템입니다. UID: %s 종류ID : %5d,"
+                " 좌표:(%d - %2d,%2d,%2d), 크기:(%2d, %2d), 현재 개수(내구도):%2d",
+		        m_dwCID, szUID, lpItem->GetPrototypeID(), itemPos.m_cIndex, cX, cY, cTab,
+                detailData.m_cXSize, detailData.m_cXSize, lpItem->GetNumOrDurability());
+
+            ERRLOG1(g_Log, "%s", szBuffer);
+        }
+    }
+}
+
+void Item::CItemContainer::DumpMoneyInfo(unsigned long dwDepositMoney)
+{
+}
+
+
+bool Item::CItemContainer::SerializeOut(char* szItemBuffer_Out, unsigned long& dwBufferSize_InOut) const
+{
+    CItem** lppItem         = m_lppItems;
+    CItem** lppItemPastEnd  = m_lppItems + m_nMaxSize;
+    
+    size_t nRemainBufferSize    = static_cast<size_t>(dwBufferSize_InOut);
+    size_t nWritten             = 0;
+
+	// edith 2010.01.23 아이템 컨테이너 관련 버그 수정. 
+//  for (; lppItem != lppItemPastEnd; ++lppItem)
+    for (int i = 0; i < m_nMaxSize; ++i, ++lppItem)
+    {
+        CItem* lpItem = *lppItem;
+        if(NULL != lpItem && m_lpNullItem != lpItem)
+        {
+            size_t nItemSize = nRemainBufferSize;
+
+			// 3차 밸런스 패치 (S그레이드 아이템 제한선 보정)
+			lpItem->RevisionLimit();
+
+            if(!lpItem->SerializeOut(szItemBuffer_Out + nWritten, nItemSize))
+            {
+                ERRLOG3(g_Log, "CID:%10u 아이템 SerializeOut에 실패했습니다. 버퍼가 부족합니다. 쓴 크기:%d, 남은 버퍼 크기:%d",
+                    m_dwCID, nWritten, nRemainBufferSize);
+                return false;
+            }
+
+            nWritten += nItemSize;
+            nRemainBufferSize -= nItemSize;
+        }
+    }
+    
+    dwBufferSize_InOut = static_cast<unsigned long>(nWritten);
+    return true;
+}
+
+
+// ----------------------------------------------------------------------------------------
+// CArrayContainer
+
+Item::CArrayContainer::CArrayContainer()
+{
+        
+}
+
+Item::CArrayContainer::~CArrayContainer()
+{
+
+}
+
+bool Item::CArrayContainer::Initialize(unsigned long dwCID, unsigned char nXSize, unsigned char nYSize, unsigned char nTabNum)
+{
+    m_dwCID     = dwCID;
+    m_nXSize    = nXSize;
+    m_nYSize    = nYSize;
+    m_nTabNum   = nTabNum;
+    
+    m_nSizePerTab   = nXSize * nYSize;
+    return CItemContainer::Initialize(dwCID, nXSize * nYSize * nTabNum);
+}
+
+Item::CItem* Item::CArrayContainer::GetItem(Item::ItemPos itemPos)
+{
+    unsigned char cX, cY, cTab;
+    itemPos.GetPos(cX, cY, cTab);
+
+    if(m_nXSize <= cX || m_nYSize <= cY || m_nTabNum <= cTab)
+    {
+        ERRLOG7(g_Log, "CID:%10u 아이템 위치가 올바르지 않습니다. X:%d/%d, Y:%d/%d, Tab:%d/%d", 
+            m_dwCID, cX, m_nXSize, cY, m_nYSize, cTab, m_nTabNum);
+        return NULL;
+    }
+
+    CItem* lpItem = m_lppItems[m_nSizePerTab * cTab + m_nXSize * cY + cX];
+    return  (lpItem != m_lpNullItem) ? lpItem : NULL;
+}
+
+bool Item::CArrayContainer::SetItem(Item::ItemPos itemPos, Item::CItem* lpItem)
+{
+    if(NULL == lpItem)
+    {
+        ERRLOG1(g_Log, "CID:%10u 아이템이 NULL입니다.", m_dwCID);
+        return false;
+    }
+
+    unsigned char cX, cY, cTab;
+    itemPos.GetPos(cX, cY, cTab);
+
+    unsigned char cXSize = lpItem->GetItemInfo().m_DetailData.m_cXSize;
+    unsigned char cYSize = lpItem->GetItemInfo().m_DetailData.m_cYSize;
+
+    if(m_nXSize < static_cast<size_t>(cX + cXSize) || 
+        m_nYSize < static_cast<size_t>(cY + cYSize) || m_nTabNum <= cTab)
+    {
+        ERRLOG9(g_Log, "CID:%10u 아이템 위치 및 크기가 올바르지 않습니다. "
+            "X:%d/%d, Y:%d/%d, Tab:%d/%d, X크기:%d, Y크기:%d", 
+            m_dwCID, cX, m_nXSize, cY, m_nYSize, cTab, m_nTabNum, cXSize, cYSize);
+        return false;
+    }
+
+    CItem** lppItemYIndexPastEnd = m_lppItems + m_nSizePerTab * cTab + m_nXSize * (cY + cYSize);
+    CItem **lppItemYIndex, **lppItemXIndex, **lppItemXIndexPastEnd;
+
+    for (lppItemYIndex = m_lppItems + m_nSizePerTab * cTab + cY * m_nXSize;
+        lppItemYIndex != lppItemYIndexPastEnd; lppItemYIndex += m_nXSize)
+    {
+        lppItemXIndexPastEnd = lppItemYIndex + cX + cXSize;
+
+        for (lppItemXIndex = lppItemYIndex + cX;
+            lppItemXIndex != lppItemXIndexPastEnd; ++lppItemXIndex)
+        {
+            if(0 != *lppItemXIndex)
+            {
+                ERRLOG4(g_Log, "CID:%10u (%d,%d,%d) 이미 그 장소에 아이템이 있습니다.",
+                    m_dwCID, cX, cY, cTab);
+                return false;
+            }            
+        }        
+    }
+    
+    for (lppItemYIndex = m_lppItems + m_nSizePerTab * cTab + cY * m_nXSize;
+        lppItemYIndex != lppItemYIndexPastEnd; lppItemYIndex += m_nXSize)
+    {
+        lppItemXIndexPastEnd = lppItemYIndex + cX + cXSize;
+
+        for (lppItemXIndex = lppItemYIndex + cX;
+            lppItemXIndex != lppItemXIndexPastEnd; ++lppItemXIndex)
+        {
+            *lppItemXIndex = m_lpNullItem;
+        }
+    }
+    
+    m_lppItems[m_nSizePerTab * cTab + m_nXSize * cY + cX] = lpItem;
+    lpItem->MoveItem(itemPos);
+    return true;
+}
+
+bool Item::CArrayContainer::RemoveItem(Item::ItemPos itemPos)
+{
+    unsigned char cX, cY, cTab;
+    itemPos.GetPos(cX, cY, cTab);
+
+    if(m_nXSize <= cX || m_nYSize <= cY || m_nTabNum <= cTab)
+    {
+        ERRLOG7(g_Log, "CID:%10u 아이템 위치 및 크기가 올바르지 않습니다. X:%d/%d, Y:%d/%d, Tab:%d/%d",
+            m_dwCID, cX, m_nXSize, cY, m_nYSize, cTab, m_nTabNum);
+        return false;
+    }
+
+    CItem* lpItem = m_lppItems[m_nSizePerTab * cTab + m_nXSize * cY + cX];
+    if(NULL == lpItem || m_lpNullItem == lpItem)
+    {
+        ERRLOG4(g_Log, "CID:%10u 그 위치에 아이템이 없습니다. X:%d, Y:%d, Tab:%d", m_dwCID, cX, cY, cTab);
+        return false;
+    }
+
+    unsigned char cXSize = lpItem->GetItemInfo().m_DetailData.m_cXSize;
+    unsigned char cYSize = lpItem->GetItemInfo().m_DetailData.m_cYSize;
+ 
+    if(m_nXSize < static_cast<size_t>(cX + cXSize) || 
+        m_nYSize < static_cast<size_t>(cY + cYSize))
+    {        
+        ERRLOG9(g_Log, "CID:%10u 아이템 위치 및 크기가 올바르지 않습니다. "
+            "X:%d/%d, Y:%d/%d, Tab:%d/%d, X크기:%d, Y크기:%d", 
+            m_dwCID, cX, m_nXSize, cY, m_nYSize, cTab, m_nTabNum, cXSize, cYSize);
+        return false;        
+    }
+
+    CItem** lppItemYIndexPastEnd  = m_lppItems + m_nSizePerTab * cTab + m_nXSize * (cY + cYSize);    
+    CItem **lppItemYIndex, **lppItemXIndex, **lppItemXIndexPastEnd;
+
+    for (lppItemYIndex = m_lppItems + m_nSizePerTab * cTab + cY * m_nXSize;
+        lppItemYIndex != lppItemYIndexPastEnd; lppItemYIndex += m_nXSize)
+    {
+        lppItemXIndexPastEnd = lppItemYIndex + cX + cXSize;
+
+        for (lppItemXIndex = lppItemYIndex + cX;
+            lppItemXIndex != lppItemXIndexPastEnd; ++lppItemXIndex)
+        {
+            *lppItemXIndex = NULL;
+        }
+    }
+
+    return true;
+}
+
+unsigned short Item::CArrayContainer::GetItemNum(unsigned short usProtoTypeID)
+{
+	unsigned short wCount = 0;
+
+	for (unsigned short nTab = 0; nTab < m_nTabNum; ++nTab)
+	{
+		for (unsigned short nHeight = 0; nHeight < m_nYSize; ++nHeight)
+		{
+			for (unsigned short nWidth = 0; nWidth < m_nXSize; ++nWidth)
+			{                
+				const CItem* lpItem = m_lppItems[m_nSizePerTab * nTab + m_nXSize * nHeight + nWidth];
+				if (NULL == lpItem) { continue; }
+
+				if (usProtoTypeID == lpItem->GetPrototypeID())
+				{
+					wCount += (lpItem->IsSet(Item::DetailData::STACKABLE)) ? lpItem->GetNumOrDurability() : 1;
+				}
+			}
+		}
+	}
+
+	return wCount;
+}
+
+bool Item::CArrayContainer::DisappearItem(unsigned short wItemID, unsigned short wItemNum, 
+										  vector<Item::ItemGarbage>& vecItemGarbage)
+{
+	unsigned short tempItemNum = GetItemNum(wItemID);
+	if (wItemNum > tempItemNum) 
+	{ 
+		DETLOG3(g_Log, "DisappearItem = 해당 아이템이 존재하지 않습니다. ItemID:%d, ItemNum:%d/%d", wItemID, tempItemNum, wItemNum);
+		return false; 
+	}
+
+	// 음수가 될수 있으므로 short 형으로 변환
+	short itemNum = static_cast<short>(wItemNum);
+	for (unsigned short nTab = 0; nTab < m_nTabNum; ++nTab)
+	{
+		for (unsigned short nHeight = 0; nHeight < m_nYSize; ++nHeight)
+		{
+			for (unsigned short nWidth = 0; nWidth < m_nXSize; ++nWidth)
+			{                
+				CItem* lpItem = m_lppItems[m_nSizePerTab * nTab + m_nXSize * nHeight + nWidth];
+				if (NULL == lpItem) { continue; }
+
+				if (wItemID == lpItem->GetPrototypeID())
+				{
+                    itemNum -= (lpItem->IsSet(Item::DetailData::STACKABLE)) ? lpItem->GetNumOrDurability() : 1;
+
+					if (0 < itemNum)
+					{
+						vecItemGarbage.push_back(ItemGarbage(lpItem, 0));
+					}
+					else if (0 == itemNum)
+					{
+						vecItemGarbage.push_back(ItemGarbage(lpItem, 0));
+						return true;
+					}
+					else if (0 > itemNum)
+					{
+						unsigned char cRemainNum = static_cast<unsigned char>( -itemNum );
+						vecItemGarbage.push_back(ItemGarbage(lpItem, cRemainNum));
+						return true;
+					}
+				}
+			}
+		}
+	}
+
+	return false;
+}
+
+bool Item::CArrayContainer::DisappearItem(unsigned short wItemID, unsigned short wItemNum)
+{
+	if (wItemNum > GetItemNum(wItemID)) 
+	{ 
+		return false; 
+	}
+
+	// 음수가 될수 있으므로 short 형으로 변환
+	short itemNum = static_cast<short>(wItemNum);
+	for (unsigned short nTab = 0; nTab < m_nTabNum; ++nTab)
+	{
+		for (unsigned short nHeight = 0; nHeight < m_nYSize; ++nHeight)
+		{
+			for (unsigned short nWidth = 0; nWidth < m_nXSize; ++nWidth)
+			{                
+				CItem* lpItem = m_lppItems[m_nSizePerTab * nTab + m_nXSize * nHeight + nWidth];
+				if (NULL == lpItem) { continue; }
+
+				if (wItemID == lpItem->GetPrototypeID())
+				{
+					itemNum -= (lpItem->IsSet(Item::DetailData::STACKABLE)) ? lpItem->GetNumOrDurability() : 1;
+
+					CCharacter* lpOwner = CCreatureManager::GetInstance().GetCharacter(m_dwCID);
+					if (NULL == lpOwner) { return false; }
+					CGameClientDispatch* lpDispatch = lpOwner->GetDispatcher();
+
+					if (0 < itemNum)
+					{
+						if (NULL != lpDispatch)
+						{
+							GameClientSendPacket::SendCharDisappearItem(lpDispatch->GetSendStream(), 
+								m_dwCID, lpItem->GetPos(), 0, PktDisappearItem::DIC_LINKED_QUEST, PktBase::NO_SERVER_ERR);
+						}
+
+						RemoveItem(lpItem->GetPos());
+						DELETE_ITEM(lpItem);
+					}
+					else if (0 == itemNum)
+					{
+						if (NULL != lpDispatch)
+						{
+							GameClientSendPacket::SendCharDisappearItem(lpDispatch->GetSendStream(), 
+								m_dwCID, lpItem->GetPos(), 0, PktDisappearItem::DIC_LINKED_QUEST, PktBase::NO_SERVER_ERR);
+						}
+
+						RemoveItem(lpItem->GetPos());
+						DELETE_ITEM(lpItem);
+
+						return true;
+					}
+					else if (0 > itemNum)
+					{
+						unsigned char cRemainNum = static_cast<unsigned char>( -itemNum );
+
+						if (NULL != lpDispatch)
+						{
+							GameClientSendPacket::SendCharDisappearItem(lpDispatch->GetSendStream(), 
+								m_dwCID, lpItem->GetPos(), cRemainNum, PktDisappearItem::DIC_LINKED_QUEST, PktBase::NO_SERVER_ERR);
+						}
+
+						lpItem->SetNumOrDurability(cRemainNum);
+
+						return true;
+					}
+				}
+			}
+		}
+	}
+
+	return false;
+}
+
+void Item::CArrayContainer::DumpItemInfo()
+{
+	const int MAX_LINE = 1024;
+	char szLine[MAX_LINE];
+
+	int	nBufferPos = 0;
+
+	ERRLOG1(g_Log, "CID:%10u 의 아이템 로그를 시작합니다.", m_dwCID);
+
+	for (unsigned short nTab = 0; nTab < m_nTabNum; ++nTab)
+	{
+		ERRLOG2(g_Log, "CID:%10u 의 탭 %d의 아이템입니다.", m_dwCID, nTab);
+
+		for (unsigned short nHeight = 0; nHeight < m_nYSize; ++nHeight)
+		{
+			nBufferPos = _snprintf(szLine, MAX_LINE, "CID:%10u 의 아이템입니다. ", m_dwCID);
+
+			for (unsigned short nWidth = 0; nWidth < m_nXSize; ++nWidth)
+			{                
+                const CItem* lpItem = m_lppItems[m_nSizePerTab * nTab + m_nXSize * nHeight + nWidth];
+
+                nBufferPos += _snprintf(szLine + nBufferPos, MAX_LINE, " %5d ", 
+                    ((0 != lpItem) ? lpItem->GetPrototypeID() : 0));
+			}
+			
+			ERRLOG0(g_Log, szLine);
+		}
+	}
+
+    CItemContainer::DumpItemInfo();
+}
+
+void Item::CArrayContainer::DumpMoneyInfo(unsigned long dwDepositMoney)
+{
+	CItemContainer::DumpMoneyInfo(dwDepositMoney);
+}
+
+
+bool Item::CArrayContainer::SerializeIn(const char* szItemBuffer_In, unsigned long dwBufferSize_In)
+{
+    size_t nBufferSize = static_cast<size_t>(dwBufferSize_In);
+    size_t nUsed = 0;
+
+    Item::CItemFactory& ItemFactory = CItemFactory::GetInstance();
+
+    while(nBufferSize > 0)
+    {
+        size_t nItemSize = nBufferSize;
+        Item::CItem* lpItem = ItemFactory.CreateItem(szItemBuffer_In + nUsed, nItemSize);
+
+		// edith 2008.08.26 아이템 스크립트에해당 아이템이 없으면 아이템을 삭제해 버린다.
+        if(NULL == lpItem)
+        {
+            nItemSize = LogErrorItem(m_dwCID, "아이템 생성에 실패했습니다", szItemBuffer_In + nUsed);
+			break;	// 주석..
+        }
+        else if(!CArrayContainer::SetItem(lpItem->GetPos(), lpItem))
+        {
+            nItemSize = LogErrorItem(m_dwCID, "아이템 놓기를 실패했습니다", szItemBuffer_In + nUsed);
+            DELETE_ITEM(lpItem);
+			break;
+        }
+
+        nUsed += nItemSize;
+        nBufferSize -= nItemSize;        
+    }
+    
+    return true;
+}
+
+
+// ----------------------------------------------------------------------------------------
+// CListContainer
+
+Item::CListContainer::CListContainer()
+{
+
+}
+
+
+Item::CListContainer::~CListContainer()
+{
+
+}
+
+
+Item::CItem* Item::CListContainer::GetItem(Item::ItemPos itemPos)
+{
+    if(itemPos.m_cIndex < m_nMaxSize)
+    {
+        CItem* lpItem = m_lppItems[itemPos.m_cIndex];
+        return (lpItem != m_lpNullItem) ? lpItem : NULL;
+    }
+
+    return NULL;
+}
+
+
+bool Item::CListContainer::SetItem(Item::ItemPos itemPos, Item::CItem* lpItem)
+{
+    if(itemPos.m_cIndex < m_nMaxSize)
+    {        
+        if(NULL == m_lppItems[itemPos.m_cIndex])
+        {
+            m_lppItems[itemPos.m_cIndex] = lpItem;
+            lpItem->MoveItem(itemPos);
+            return true;
+        }
+        else
+        {
+            ERRLOG1(g_Log, "CID:%10u 아이템이 이미 존재합니다.", m_dwCID);
+        }
+    }
+
+    return false;
+}
+
+
+bool Item::CListContainer::RemoveItem(Item::ItemPos itemPos)
+{
+    if(itemPos.m_cIndex < m_nMaxSize)
+    {        
+        if(NULL != m_lppItems[itemPos.m_cIndex])
+        {            
+            m_lppItems[itemPos.m_cIndex] = NULL;
+            return true;
+        }
+        else
+        {
+            ERRLOG1(g_Log, "CID:%10u 아이템이 존재하지 않습니다.", m_dwCID);
+        }
+    }
+
+    return false;
+}
+
+
+bool Item::CListContainer::SerializeIn(const char* szItemBuffer_In, unsigned long dwBufferSize_In)
+{
+    size_t nBufferSize = static_cast<size_t>(dwBufferSize_In);
+    size_t nUsed = 0;
+
+    Item::CItemFactory& ItemFactory = CItemFactory::GetInstance();
+
+    while(nBufferSize > 0)
+    {
+        size_t nItemSize = nBufferSize;
+        Item::CItem* lpItem = ItemFactory.CreateItem(szItemBuffer_In + nUsed, nItemSize);
+
+        if(NULL == lpItem)
+        {
+            nItemSize = LogErrorItem(m_dwCID, "아이템 생성에 실패했습니다", szItemBuffer_In + nUsed);
+        }
+        else if(!CListContainer::SetItem(lpItem->GetPos(), lpItem))
+        {
+            nItemSize = LogErrorItem(m_dwCID, "아이템 놓기를 실패했습니다", szItemBuffer_In + nUsed);
+            DELETE_ITEM(lpItem);
+        }
+
+        nUsed += nItemSize;
+        nBufferSize -= nItemSize;        
+    }
+    
+    return true;
+}
+
+
+// ----------------------------------------------------------------------------------------
+// CSEQListContainer
+
+Item::CSEQListContainer::CSEQListContainer() : m_ListCount(0)
+{
+
+}
+
+
+Item::CSEQListContainer::~CSEQListContainer()
+{
+
+}
+
+Item::CItem* Item::CSEQListContainer::GetItem(ItemPos itemPos)
+{
+    if(itemPos.m_cIndex < m_nMaxSize)
+    {
+        CItem* lpItem = m_lppItems[itemPos.m_cIndex];
+        return (lpItem != m_lpNullItem) ? lpItem : NULL;
+    }
+
+    return NULL;
+}
+
+
+bool Item::CSEQListContainer::SetItem(ItemPos itemPos, Item::CItem* lpItem)
+{
+    if(itemPos.m_cIndex < m_nMaxSize)
+    {        
+        if(NULL == m_lppItems[itemPos.m_cIndex])
+        {
+            m_lppItems[itemPos.m_cIndex] = lpItem;
+            return true;
+        }
+        else
+        {
+            ERRLOG1(g_Log, "CID:%10u 아이템이 이미 존재합니다.", m_dwCID);
+        }
+    }
+
+    return false;
+}
+
+
+bool Item::CSEQListContainer::RemoveItem(Item::ItemPos itemPos)
+{
+    if(itemPos.m_cIndex < m_nMaxSize)
+    {        
+        if(NULL != m_lppItems[itemPos.m_cIndex])
+        {            
+            m_lppItems[itemPos.m_cIndex] = NULL;
+            return true;
+        }
+        else
+        {
+            ERRLOG1(g_Log, "CID:%10u 아이템이 존재하지 않습니다.", m_dwCID);
+        }
+    }
+
+    return false;
+}
+
+bool Item::CSEQListContainer::SerializeIn(const char* szItemBuffer_In, unsigned long dwBufferSize_In)
+{
+    size_t nBufferSize = static_cast<size_t>(dwBufferSize_In);
+    size_t nUsed = 0;
+
+    Item::CItemFactory& ItemFactory = CItemFactory::GetInstance();
+
+	m_ListCount = 0;
+    while(nBufferSize > 0)
+    {
+        size_t nItemSize = nBufferSize;
+
+		// 화살/볼트
+		unsigned short ProtoTypeID = reinterpret_cast<const Item::ItemData*>(szItemBuffer_In + nUsed)->m_usProtoTypeID;
+		if(ProtoTypeID >= 4001 && ProtoTypeID <= 4033)
+		{
+			nItemSize = reinterpret_cast<const Item::ItemData*>(szItemBuffer_In + nUsed)->m_cItemSize;
+			if(20 != nItemSize)
+			{
+				ERRLOG1(g_Log, "CID:%10u 이상한 화살. 아이템 생성에 실패했습니다.", m_dwCID);
+	 			
+				nUsed += nItemSize;
+				nBufferSize -= nItemSize;        
+				continue;
+			}
+		}
+		
+		Item::CItem* lpItem = ItemFactory.CreateItem(szItemBuffer_In + nUsed, nItemSize);
+
+        if(NULL == lpItem)
+        {
+            nItemSize = reinterpret_cast<const Item::ItemData*>(szItemBuffer_In + nUsed)->m_cItemSize;
+            ERRLOG1(g_Log, "CID:%10u 아이템 생성에 실패했습니다.", m_dwCID);
+        }
+        else if(!CSEQListContainer::SetItem(ItemPos(0, m_ListCount), lpItem))
+        {
+            nItemSize = reinterpret_cast<const Item::ItemData*>(szItemBuffer_In + nUsed)->m_cItemSize;
+            ERRLOG1(g_Log, "CID:%10u 아이템 놓기를 실패했습니다.", m_dwCID);
+            DELETE_ITEM(lpItem);
+        }
+
+        nUsed += nItemSize;
+        nBufferSize -= nItemSize;        
+
+		++m_ListCount;
+	}
+    
+    return true;
+}

Server/RylServerProject/RylGameLibrary/Item/Container/ItemContainer.h

@@ -0,0 +1,145 @@
+#ifndef _ITEM_CONTAINER_H_
+#define _ITEM_CONTAINER_H_
+
+#include <vector>
+#include <Item/ItemStructure.h>
+
+// Àü¹æ ÂüÁ¶
+namespace Item
+{    
+    class CItem;
+
+    class CItemContainer
+    {
+    public:
+
+        CItemContainer();
+        virtual ~CItemContainer();
+
+		bool Initialize(unsigned long dwCID, unsigned short nMaxSize);
+        void SetCID(unsigned long dwCID) { m_dwCID = dwCID; }
+        void ClearItems();
+
+        virtual CItem* GetItem(ItemPos itemPos) = 0;
+        virtual bool SetItem(ItemPos itemPos, CItem* lpItem) = 0;
+
+        virtual bool RemoveItem(ItemPos itemPos) = 0;
+        
+        virtual bool SerializeOut(char* szItemBuffer_Out, unsigned long& dwBufferSize_InOut) const; 
+        virtual bool SerializeIn(const char* szItemBuffer_In, unsigned long dwBufferSize_InOut) = 0;
+
+        virtual void DumpItemInfo();
+		virtual void DumpMoneyInfo(unsigned long dwDepoistMoney);
+		
+        class iterator
+        {
+        public:
+
+            iterator(CItem** lppItem, CItem* lpNull_Item, unsigned short usOffset) : m_lppItems(lppItem), m_lpNullItem(lpNull_Item), m_nCurrentPos(usOffset) { }
+            iterator() : m_lppItems(NULL), m_lpNullItem(NULL), m_nCurrentPos(0) { }
+
+            CItem* operator*() { return (m_lpNullItem != *(m_lppItems + m_nCurrentPos)) ? *(m_lppItems + m_nCurrentPos) : NULL; }
+            iterator& operator++() { ++m_nCurrentPos; return (*this); }
+
+            bool operator==(const iterator& _Right) const
+            {	// test for iterator equality
+                return (m_nCurrentPos == _Right.m_nCurrentPos && m_lppItems == _Right.m_lppItems
+                    && m_lpNullItem == _Right.m_lpNullItem);
+            }
+
+            bool operator!=(const iterator& _Right) const
+            {	// test for iterator inequality
+                return (!(*this == _Right));
+            }
+
+        private:
+
+            CItem**         m_lppItems;
+            CItem*          m_lpNullItem;
+            unsigned short  m_nCurrentPos;
+        };
+
+        iterator begin() const { return iterator(m_lppItems, m_lpNullItem, 0); }
+        iterator end()   const { return iterator(m_lppItems, m_lpNullItem, m_nMaxSize); }
+        
+    protected:
+        
+        virtual void Destroy();
+
+        CItem**         m_lppItems;
+        CItem*          m_lpNullItem;
+
+        unsigned long   m_dwCID;
+        unsigned short  m_nMaxSize;
+        unsigned short  m_usFlags;
+
+        friend class iterator;
+    };
+    
+    class CArrayContainer : public CItemContainer
+    {
+    public:
+
+        CArrayContainer();
+        virtual ~CArrayContainer();
+
+        bool Initialize(unsigned long dwCID, unsigned char nXSize, unsigned char nYSize, unsigned char nTabNum);
+
+        virtual CItem* GetItem(ItemPos itemPos);
+        virtual bool SetItem(ItemPos itemPos, CItem* lpItem);
+        virtual bool RemoveItem(ItemPos itemPos);
+		virtual unsigned short GetItemNum(unsigned short usProtoTypeID);
+
+        virtual bool SerializeIn(const char* szItemBuffer_In, unsigned long dwBufferSize_In);
+
+        virtual void DumpItemInfo();
+		virtual void DumpMoneyInfo(unsigned long dwDepoistMoney);
+
+		bool DisappearItem(unsigned short wItemID, unsigned short wItemNum, std::vector<Item::ItemGarbage>& vecItemGarbage);
+		bool DisappearItem(unsigned short wItemID, unsigned short wItemNum);
+
+	protected:        
+        
+        unsigned char  m_nXSize;
+        unsigned char  m_nYSize;
+        unsigned char  m_nTabNum;
+        unsigned char  m_nSizePerTab;
+    };
+
+
+	class CListContainer : public CItemContainer
+    {
+    public:
+
+        CListContainer();
+        virtual ~CListContainer();
+
+        virtual CItem* GetItem(ItemPos itemPos);
+        virtual bool SetItem(ItemPos itemPos, CItem* lpItem);
+        virtual bool RemoveItem(ItemPos itemPos);        
+
+        virtual bool SerializeIn(const char* szItemBuffer_In, unsigned long dwBufferSize_In);
+    };
+
+	class CSEQListContainer : public CItemContainer
+    {
+    public:
+
+        CSEQListContainer();
+        virtual ~CSEQListContainer();
+
+        virtual CItem* GetItem(ItemPos itemPos);
+        virtual bool SetItem(ItemPos itemPos, CItem* lpItem);
+        virtual bool RemoveItem(ItemPos itemPos);        
+
+        virtual bool SerializeIn(const char* szItemBuffer_In, unsigned long dwBufferSize_In);
+
+	private:
+		unsigned short m_ListCount;
+
+	public:
+		unsigned short GetListCount(void)	{	return m_ListCount;		}
+	};
+};
+
+#endif

Server/RylServerProject/RylGameLibrary/Item/Container/StallContainer.cpp

@@ -0,0 +1,775 @@
+
+#include "stdafx.h"
+
+#include <Network/Packet/PacketStruct/CharCommunityPacket.h>
+#include <Network/Packet/WrapPacket.h>
+#include <Network/Packet/PacketCommand.h>
+#include <Network/Packet/ChatPacket.h>
+#include <Network/Stream/SendStream.h>
+#include <Network/Dispatch/GameClient/GameClientDispatch.h>
+#include <Network/Dispatch/GameClient/SendCharCommunity.h>
+
+#include <Creature/Character/Character.h>
+#include <Creature/Siege/CampShop.h>
+
+#include <Community/Guild/Guild.h>
+#include <Community/Guild/GuildMgr.h>
+
+#include <Item/Item.h>
+#include <Item/ItemFactory.h>
+
+#include <Map/FieldMap/Cell.h>
+#include <Log/ItemLog.h>
+#include <Utility/Math/Math.h>
+
+#include "StallContainer.h"
+#include "ContainerConstant.h"
+
+using namespace Item;
+
+
+// ------------------------------------------------------------------------------------------
+// CShopContainer
+
+CShopContainer::CShopContainer()
+{
+	Clear();
+}
+
+CShopContainer::~CShopContainer()
+{
+	Destroy();
+}
+
+bool CShopContainer::Initialize(unsigned long dwCID, unsigned char cWidth, unsigned char cHeight)
+{
+    return CArrayContainer::Initialize(dwCID, cWidth, cHeight, 1);
+}
+
+void CShopContainer::Clear(void)
+{
+	std::fill_n(m_aryCustomerID, int(MAX_CUSTOMER_NUM), 0);
+}
+
+void CShopContainer::Destroy(void)
+{
+    if (NULL != m_lppItems)
+    {
+        delete [] m_lppItems;
+        m_lppItems = NULL;
+    }
+}
+
+CItem* CShopContainer::GetItem(ItemPos itemPos)
+{
+	return CArrayContainer::GetItem(itemPos);
+}
+
+bool CShopContainer::RemoveItem(ItemPos itemPos)
+{
+	CItem* lpItem = GetItem(itemPos);
+	if (NULL != lpItem)
+	{
+		lpItem->SetStallPrice(0);
+		if (true == CArrayContainer::RemoveItem(itemPos))
+		{
+			lpItem->MoveItem(lpItem->GetPos());
+			return true;
+		}
+	}
+
+	return false;
+}
+
+bool CShopContainer::Enter(CCharacter* lpCustomer)
+{
+    if (NULL != lpCustomer && 0 != m_dwCID)
+    {
+	    for (int nIndex = 0; nIndex < MAX_CUSTOMER_NUM; nIndex++)
+	    {
+		    if (0 == m_aryCustomerID[nIndex])
+		    {
+			    m_aryCustomerID[nIndex] = lpCustomer->GetCID();
+			    lpCustomer->GetStall().SetOtherOwner(m_dwCID);
+			    SendCharStallItemInfo(lpCustomer);
+
+			    // 노점상로그 : 입장(손님CID)
+				CAggresiveCreature* lpCreature = CCreatureManager::GetInstance().GetAggresiveCreature(m_dwCID);
+				if (NULL != lpCreature)
+				{
+	                GAMELOG::LogStallEnterLeave(*lpCreature, lpCustomer->GetCID(), true);
+				}
+			    return true;
+		    }
+        }
+    }
+
+	return false;
+}
+
+bool CShopContainer::Leave(CCharacter* lpCustomer)
+{
+    if (NULL != lpCustomer && 0 != m_dwCID)
+    {
+	    for (int nIndex = 0; nIndex < MAX_CUSTOMER_NUM; nIndex++)
+	    {
+		    if (m_aryCustomerID[nIndex] == lpCustomer->GetCID())
+		    {
+			    // 노점상로그 : 퇴장(손님CID)
+				CAggresiveCreature* lpCreature = CCreatureManager::GetInstance().GetAggresiveCreature(m_dwCID);
+				if (NULL != lpCreature)
+				{
+	                GAMELOG::LogStallEnterLeave(*lpCreature, lpCustomer->GetCID(), false);
+				}
+
+			    lpCustomer->GetStall().SetOtherOwner(0);
+
+				std::copy(m_aryCustomerID + nIndex + 1, m_aryCustomerID + MAX_CUSTOMER_NUM, m_aryCustomerID + nIndex);
+			    m_aryCustomerID[MAX_CUSTOMER_NUM - 1] = 0;
+
+				return true;
+		    }
+	    }
+    }
+
+	return false;
+}
+
+unsigned char CShopContainer::GetCurrentCustomerNum(void)
+{
+	unsigned char cCurrentNum = 0;
+	
+	for (int nIndex = 0; nIndex < MAX_CUSTOMER_NUM; ++nIndex)
+	{
+		if (0 != m_aryCustomerID[nIndex])
+		{
+			++cCurrentNum;
+		}
+	}
+
+	return cCurrentNum;
+}
+
+void CShopContainer::SwapPosAllItem(void)
+{
+    CItem** lppItem         = m_lppItems;
+    CItem** lppItemPastEnd  = m_lppItems + m_nMaxSize;
+    
+    for (; lppItem != lppItemPastEnd; ++lppItem)
+    {
+        CItem* lpItem = *lppItem;
+        if (NULL != lpItem && m_lpNullItem != lpItem)
+        {
+			lpItem->SwapPos();
+        }
+    }
+}
+
+bool CShopContainer::StallPriceOut(unsigned long* szStallPriceBuffer_Out, unsigned char& cItemNum_Out) const
+{
+    CItem** lppItem         = m_lppItems;
+    CItem** lppItemPastEnd  = m_lppItems + m_nMaxSize;
+    
+    for (; lppItem != lppItemPastEnd; ++lppItem)
+    {
+        CItem* lpItem = *lppItem;
+        if (NULL != lpItem && m_lpNullItem != lpItem)
+        {
+			szStallPriceBuffer_Out[cItemNum_Out] = lpItem->GetBuyPrice();
+			cItemNum_Out++;
+        }
+    }
+    
+    return true;
+}
+
+bool CShopContainer::Close(void)
+{
+	for (int nIndex = 0; nIndex < MAX_CUSTOMER_NUM && 0 != m_aryCustomerID[0]; ++nIndex)
+	{
+		CCharacter* lpCustomer = CCreatureManager::GetInstance().GetCharacter(m_aryCustomerID[0]);
+		if (NULL != lpCustomer)
+		{
+			// Leave 함수 내부에서 인덱스의 변화가 있으므로 0번 인덱스에 손님이 없을 때까지 계속 처리하면 된다.
+			Leave(lpCustomer);
+
+			CGameClientDispatch* lpDispatch = lpCustomer->GetDispatcher();
+			if (NULL != lpDispatch) 
+			{
+				GameClientSendPacket::SendCharStallEnter(lpDispatch->GetSendStream(), lpCustomer->GetCID(), 0, 0);
+			}
+		}
+	}
+
+	Clear();
+
+	return true;
+}
+
+bool CShopContainer::SendAllCustomer(const char* szPacket, const unsigned long dwPacketSize, 
+									 bool bIncludeOwner, unsigned char cCMD_In)
+{
+	for (int nIndex = 0; nIndex < MAX_CUSTOMER_NUM; nIndex++)
+	{
+		if (0 == m_aryCustomerID[nIndex]) { break; }
+
+		CCharacter* lpCustomer = CCreatureManager::GetInstance().GetCharacter(m_aryCustomerID[nIndex]);
+		if (NULL != lpCustomer)
+		{
+			CGameClientDispatch* lpDispatch = lpCustomer->GetDispatcher();
+			if (NULL != lpDispatch)
+			{
+				lpDispatch->GetSendStream().PutBuffer(szPacket, dwPacketSize, cCMD_In);
+			}
+		}
+	}
+
+	return true;
+}
+
+bool CShopContainer::SendRemoveItem(TakeType takeType, unsigned char cCmd, const char* strBuyUser)
+{
+	PktStRI pktStRI;
+
+	pktStRI.m_dwCharID = m_dwCID;
+	pktStRI.m_dwShopID = m_dwCID;
+	pktStRI.m_TakeType = takeType;
+	pktStRI.m_dwPrice = 0;
+	pktStRI.m_cCmd = cCmd;
+	strcpy(pktStRI.m_BuyUser, strBuyUser);
+
+	char* szPacket = reinterpret_cast<char*>(&pktStRI);
+	if (PacketWrap::WrapCrypt(szPacket, sizeof(PktStRI), CmdCharStallRegisterItem, 0, PktBase::NO_SERVER_ERR))
+	{
+		return SendAllCustomer(szPacket, sizeof(PktStRI), true, CmdCharStallRegisterItem);
+	}
+
+	return false;
+}
+
+bool CShopContainer::SendCharStallEnter(unsigned long dwCustomerID, unsigned long dwOwnerID)
+{
+	PktStE pktStE;
+
+	pktStE.m_dwCustomerID = dwCustomerID;
+	pktStE.m_dwOwnerID = dwOwnerID;
+
+	char* szPacket = reinterpret_cast<char*>(&pktStE);
+	if (PacketWrap::WrapCrypt(szPacket, sizeof(PktStE), CmdCharStallEnter, 0, 0))
+	{
+		return SendAllCustomer(szPacket, sizeof(PktStE), true, CmdCharStallEnter);
+	}
+
+	return false;
+}
+
+// ------------------------------------------------------------------------------------------
+// CCharacterShopContainer
+
+CCharacterShopContainer::CCharacterShopContainer()
+:	m_dwOtherOwnerID(0)
+{
+	Clear();
+}
+
+CCharacterShopContainer::~CCharacterShopContainer()
+{
+	Destroy();
+}
+
+void CCharacterShopContainer::Clear(void)
+{
+	std::fill_n(m_strStallName, int(MAX_STALL_NAME_LEN), 0);
+
+	CShopContainer::Clear();
+}
+
+void CCharacterShopContainer::RollBackAllItem(void)
+{
+	for (unsigned short nHeight = 0; nHeight < m_nYSize; ++nHeight)
+	{
+        const unsigned short nHeightPos = m_nXSize * nHeight;
+
+		for (unsigned short nWidth = 0; nWidth < m_nXSize; ++nWidth)
+		{
+            CItem* lpItem = m_lppItems[nHeightPos + nWidth];
+			if (NULL == lpItem || m_lpNullItem == lpItem) { continue; }
+
+			lpItem->MoveItem(lpItem->GetPos());
+			lpItem->SetStallPrice(0);
+		}
+	}
+
+	std::fill_n(m_lppItems, int(m_nXSize*m_nYSize), reinterpret_cast<CItem*>(NULL));
+}
+
+bool CCharacterShopContainer::SetItem(ItemPos itemPos, CItem* lpItem)
+{
+	CCharacter* lpCharacter = CCreatureManager::GetInstance().GetCharacter(m_dwCID);
+	if (NULL != lpCharacter)
+	{
+		if (false == lpCharacter->GetInventory().SetItem(lpItem->GetPos(), lpItem)) 
+		{ 
+			SERLOG1(g_Log, "CID:%10u 노점상에 아이템 등록시 인벤토리에 링크를 남기는 데 실패하였습니다.", 
+				lpCharacter->GetCID());
+			return false; 
+		}
+
+		if (false == CArrayContainer::SetItem(itemPos, lpItem)) 
+		{ 
+			SERLOG1(g_Log, "CID:%10u 노점상에 아이템을 올리는데 실패하였습니다.", lpCharacter->GetCID());
+			if (false == lpCharacter->GetInventory().RemoveItem(lpItem->GetPos()))
+			{
+				SERLOG1(g_Log, "CID:%10u 노점상에 아이템 등록에 실패하여 인벤토리에서 그 링크를 지우는데 실패하였습니다.", 
+					lpCharacter->GetCID());
+			}
+			return false; 
+		}
+
+		const int MAX_BUFFER = sizeof(PktStIInfo) + MAX_ITEM_SIZE + sizeof(unsigned long);
+		char szBuffer[MAX_BUFFER];
+
+		lpItem->SwapPos();
+		size_t nItemSize = MAX_ITEM_SIZE;		
+		lpItem->SerializeOut(szBuffer + sizeof(PktStIInfo), nItemSize);
+		if (0 == nItemSize) { return false; }
+		lpItem->SwapPos();
+
+		unsigned long* dwStallPrice = reinterpret_cast<unsigned long*>(szBuffer + sizeof(PktStIInfo) + nItemSize);
+		*dwStallPrice = lpItem->GetBuyPrice();
+
+		PktStIInfo* lpPktStIInfo = reinterpret_cast<PktStIInfo*>(szBuffer);
+
+		lpPktStIInfo->m_dwOwnerID = m_dwCID;
+
+		std::copy(m_aryCustomerID, m_aryCustomerID + MAX_CUSTOMER_NUM, lpPktStIInfo->m_dwCustomerID);
+
+		lpPktStIInfo->m_dwItemSize = static_cast<unsigned long>(nItemSize);
+		lpPktStIInfo->m_cItemNum = 1;
+
+		if (PacketWrap::WrapCrypt(szBuffer, static_cast<unsigned short>(sizeof(PktStIInfo) + nItemSize + sizeof(unsigned long)), 
+			CmdCharStallItemInfo, 0, 0))
+		{
+			return SendAllCustomer(szBuffer, 
+				static_cast<unsigned long>(sizeof(PktStIInfo) + nItemSize + sizeof(unsigned long)), 
+				false, CmdCharStallItemInfo);
+		}
+	}
+	
+	return false;
+}
+
+bool CCharacterShopContainer::Open(char *strStallName)
+{
+	if (0 != strcmp(m_strStallName, "") || 0 == m_dwCID) { return false; }
+
+	strncpy(m_strStallName, strStallName, MAX_STALL_NAME_LEN);
+
+	// 노점상로그 : 열기(노점상 이름)
+	CAggresiveCreature* lpCreature = CCreatureManager::GetInstance().GetAggresiveCreature(m_dwCID);
+	if (NULL != lpCreature)
+	{
+	    GAMELOG::LogStallOpenClose(*lpCreature, m_strStallName, true);
+	}
+	return true;
+}
+
+bool CCharacterShopContainer::Close(void)
+{
+	CShopContainer::Close();
+
+	// 노점상로그 : 닫기(노점상 이름)
+	CAggresiveCreature* lpCreature = CCreatureManager::GetInstance().GetAggresiveCreature(m_dwCID);
+	if (NULL != lpCreature)
+	{
+	    GAMELOG::LogStallOpenClose(*lpCreature, m_strStallName, false);
+	}
+	
+    RollBackAllItem();
+
+	return true;
+}
+
+bool CCharacterShopContainer::SendCharStallItemInfo(CCharacter *lpCustomer)
+{
+	const int MAX_BUFFER = sizeof(PktStIInfo) + 
+		((MAX_ITEM_SIZE + sizeof(unsigned long)) * ContainerConstant::STALL_WIDTH * ContainerConstant::STALL_HEIGHT);
+
+    char szBuffer[MAX_BUFFER];
+
+	SwapPosAllItem();
+	unsigned long dwItemSize = MAX_ITEM_SIZE * m_nXSize * m_nYSize;		
+	SerializeOut(szBuffer + sizeof(PktStIInfo), dwItemSize);
+	SwapPosAllItem();
+
+	unsigned char cItemNum = 0;
+	StallPriceOut(reinterpret_cast<unsigned long*>(szBuffer + sizeof(PktStIInfo) + dwItemSize), cItemNum);
+
+	CGameClientDispatch* lpDispatch = lpCustomer->GetDispatcher();
+	if (NULL != lpDispatch)
+	{
+		return GameClientSendPacket::SendCharStallItemInfo(lpDispatch->GetSendStream(), 
+			m_dwCID, m_aryCustomerID, 0, 0, szBuffer, dwItemSize, cItemNum);
+	}
+
+	return false;
+}
+
+bool CCharacterShopContainer::SendCharStallOpen(char *strStallName)
+{
+	CCharacter* lpCharacter = CCreatureManager::GetInstance().GetCharacter(m_dwCID);
+	if (NULL != lpCharacter)
+	{
+		CCell* lpCell = lpCharacter->GetCellPos().m_lpCell;
+		if (NULL == lpCell)
+		{
+			ERRLOG1(g_Log, "CID:%10u 셀 얻기 실패.", m_dwCID);
+			return false;
+		}
+
+		PktStO pktStO;
+        memset(&pktStO, 0, sizeof(PktStO));
+
+		pktStO.m_dwCharID = m_dwCID;
+		strncpy(pktStO.m_StallName, strStallName, PktStO::MAX_STALL_NAME_LEN);
+        pktStO.m_StallName[PktStO::MAX_STALL_NAME_LEN - 1] = 0;
+
+		lpCell->SendAllNearCellCharacter(&pktStO, sizeof(PktStO), CmdCharStallOpen);
+		return true;
+	}
+	
+	return false;
+}
+
+bool CCharacterShopContainer::SendAllCustomer(const char* szPacket, const unsigned long dwPacketSize, 
+											  bool bIncludeOwner, unsigned char cCMD_In)
+{
+	if (true == bIncludeOwner)
+	{
+		CCharacter* lpCharacter = CCreatureManager::GetInstance().GetCharacter(m_dwCID);
+		if (NULL != lpCharacter)
+		{
+			CGameClientDispatch* lpDispatch = lpCharacter->GetDispatcher();       
+			if (NULL != lpDispatch)
+			{
+				lpDispatch->GetSendStream().PutBuffer(szPacket, dwPacketSize, cCMD_In);
+			}
+		}
+	}
+
+	return CShopContainer::SendAllCustomer(szPacket, dwPacketSize, bIncludeOwner, cCMD_In);
+}
+
+
+// ------------------------------------------------------------------------------------------
+// CCampShopContainer
+
+CCampShopContainer::CCampShopContainer(void)
+:	m_cUpdateCount(0)
+{
+}
+
+CCampShopContainer::~CCampShopContainer(void)
+{
+}
+
+bool CCampShopContainer::SetItem(ItemPos itemPos, CItem* lpItem)
+{
+	if (false == CArrayContainer::SetItem(itemPos, lpItem)) 
+	{ 
+		SERLOG1(g_Log, "CID:%10u 노점상에 아이템을 올리는데 실패하였습니다.", m_dwCID);
+		return false; 
+	}
+
+	const int MAX_BUFFER = sizeof(PktStIInfo) + MAX_ITEM_SIZE + sizeof(unsigned long);
+	char szBuffer[MAX_BUFFER];
+
+	size_t nItemSize = MAX_ITEM_SIZE;		
+	lpItem->SerializeOut(szBuffer + sizeof(PktStIInfo), nItemSize);
+	if (0 == nItemSize) { return false; }
+
+	unsigned long* dwStallPrice = reinterpret_cast<unsigned long*>(szBuffer + sizeof(PktStIInfo) + nItemSize);
+	*dwStallPrice = lpItem->GetBuyPrice();
+
+	PktStIInfo* lpPktStIInfo = reinterpret_cast<PktStIInfo*>(szBuffer);
+
+	lpPktStIInfo->m_dwOwnerID = m_dwCID;
+
+	CCampShop* lpShop = 
+		reinterpret_cast<CCampShop*>(CCreatureManager::GetInstance().GetSiegeObject(m_dwCID));
+	if (NULL != lpShop)
+	{
+		lpPktStIInfo->m_dwTempSafe = lpShop->GetTempSafe();
+		lpPktStIInfo->m_cTax = lpShop->GetTax();
+	}
+
+	std::copy(m_aryCustomerID, m_aryCustomerID + MAX_CUSTOMER_NUM, lpPktStIInfo->m_dwCustomerID);
+
+	lpPktStIInfo->m_dwItemSize = static_cast<unsigned long>(nItemSize);
+	lpPktStIInfo->m_cItemNum = 1;
+
+	if (PacketWrap::WrapCrypt(szBuffer, static_cast<unsigned short>(sizeof(PktStIInfo) + nItemSize + sizeof(unsigned long)), 
+		CmdCharStallItemInfo, 0, 0))
+	{
+		IncreaseUpdateCount();
+		return SendAllCustomer(szBuffer, 
+			static_cast<unsigned long>(sizeof(PktStIInfo) + nItemSize + sizeof(unsigned long)), 
+			false, CmdCharStallItemInfo);
+	}
+	
+	return false;
+}
+
+bool CCampShopContainer::RemoveItem(ItemPos itemPos)
+{
+	IncreaseUpdateCount();
+	return CShopContainer::RemoveItem(itemPos);
+}
+
+void CCampShopContainer::DropItem(CCell* lpCell, const Position& currentPos, unsigned long dwOffencerGID)
+{
+	for (unsigned short nTab = 0; nTab < m_nTabNum; ++nTab)
+	{
+		for (unsigned short nHeight = 0; nHeight < m_nYSize; ++nHeight)
+		{
+			for (unsigned short nWidth = 0; nWidth < m_nXSize; ++nWidth)
+			{                
+				CItem* lpItem = m_lppItems[m_nSizePerTab * nTab + m_nXSize * nHeight + nWidth];
+				if (NULL != lpItem)
+				{
+					RemoveItem(lpItem->GetPos());
+
+					// 등록된 아이템이 사라지는(떨어지는) 케이스이므로 팔린 것처럼 보인다.
+					unsigned char cNum = (lpItem->IsSet(DetailData::STACKABLE)) ? lpItem->GetNumOrDurability() : 1;
+					SendRemoveItem(TakeType::TakeType(lpItem->GetPos(), ItemPos(), cNum), PktStRI::SC_CAMP_SELL, "");
+
+					CCell::ItemInfo itemInfo;
+					const Position Pos(currentPos.m_fPointX + Math::Random::ComplexRandom(40) - 20,
+						currentPos.m_fPointY,
+						currentPos.m_fPointZ + Math::Random::ComplexRandom(40) - 20);
+
+					lpCell->SetItem(Pos, lpItem, 0, dwOffencerGID, 
+						(0 == dwOffencerGID) ? CCell::NONE : CCell::GUILD, itemInfo);
+				}
+			}
+		}
+	}
+}
+
+bool CCampShopContainer::StallPriceIn(const unsigned long* szStallPriceBuffer_In, unsigned char cItemNum_In)
+{
+	CItem** lppItem         = m_lppItems;
+	CItem** lppItemPastEnd  = m_lppItems + m_nMaxSize;
+
+	unsigned char cItemIndex = 0;
+
+	for (; lppItem != lppItemPastEnd; ++lppItem)
+	{
+		CItem* lpItem = *lppItem;
+		if (NULL != lpItem && m_lpNullItem != lpItem)
+		{
+			if (cItemIndex >= cItemNum_In)
+			{
+				ERRLOG1(g_Log, "CID:0x%08x 길드 요새 상점 DB에 기록된 아이템 갯수가 맞지 않습니다.", m_dwCID);
+				return false;
+			}
+
+			lpItem->SetStallPrice(szStallPriceBuffer_In[cItemIndex]);
+			++cItemIndex;
+		}
+	}
+
+	return true;
+}
+
+bool CCampShopContainer::SendCharStallItemInfo(CCharacter *lpCustomer)
+{
+	CGameClientDispatch* lpDispatch = lpCustomer->GetDispatcher();
+	if (NULL != lpDispatch)
+	{
+		return SendCharStallItemInfo(lpDispatch->GetSendStream());
+	}
+
+	return false;
+}
+
+CItem* CCampShopContainer::RegisterCancelItem(CCharacter* lpCharacter, TakeType takeType, unsigned long dwPrice, unsigned char cCmd)
+{
+	CCampShop* lpShop = 
+		reinterpret_cast<CCampShop*>(CCreatureManager::GetInstance().GetSiegeObject(m_dwCID));
+	if (NULL != lpShop)
+	{
+		if (lpCharacter->GetGID() != lpShop->GetGID())
+		{
+			ERRLOG4(g_Log, "아이템을 등록/취소하려는 캐릭터와 길드 요새 상점의 ID가 다릅니다. "
+				"SenderID:%10u, SenderGID:%10u, CampID:%10u, CampGID:%10u", 
+				lpCharacter->GetCID(), lpCharacter->GetGID(), m_dwCID, lpShop->GetGID());
+			return NULL;
+		}
+
+		Guild::CGuild* lpGuild = Guild::CGuildMgr::GetInstance().GetGuild(lpCharacter->GetGID());
+		if (NULL == lpGuild)
+		{
+			ERRLOG2(g_Log, "아이템을 등록/취소하려는 캐릭터의 길드가 존재하지 않습니다. SenderID:%10u, SenderGID:%10u", 
+				lpCharacter->GetCID(), lpCharacter->GetGID());
+			return NULL;
+		}
+
+		if (lpGuild->GetMaster().m_dwCID != lpCharacter->GetCID())
+		{
+			ERRLOG2(g_Log, "아이템을 등록/취소하려는 캐릭터가 길드마스터가 아닙니다. SenderID:%10u, SenderGID:%10u", 
+				lpCharacter->GetCID(), lpCharacter->GetGID());
+			return NULL;
+		}
+
+		switch (cCmd)
+		{
+			case PktStRI::SC_CAMP_REGISTER:
+			{
+				if (takeType.m_dstPos.m_cPos != TakeType::TS_CAMPSHOP)
+				{
+					ERRLOG1(g_Log, "CID:%10u 아이템을 길드 요새 상점에 잘못 올려 놓았습니다."
+						"RegisterPacket에 DstPos가 Stall이 아닙니다.", lpCharacter->GetCID());
+					return NULL;
+				}
+
+				if (NULL != GetItem(takeType.m_dstPos))
+				{
+					ERRLOG3(g_Log, "CID:%10u 놓으려는 위치에 이미 아이템이 존재합니다. 클라이언트가 준 위치:(%d, 0x%04x)", 
+						lpCharacter->GetCID(), takeType.m_dstPos.m_cPos, takeType.m_dstPos.m_cIndex);
+					return NULL;
+				}
+
+				CItem* lpItem = lpCharacter->GetItem(takeType.m_srcPos);
+				if (NULL != lpItem)
+				{
+					if (false == lpItem->GetItemInfo().m_DetailData.m_bExchangeAndDrop )
+					{
+						ERRLOG1(g_Log, "CID:%10u 아이템을 길드 요새 상점에 잘못 올려 놓았습니다."
+							"ExchangeAndDrop가 TRUE가 아닙니다.", lpCharacter->GetCID());
+
+						return NULL;
+					}
+
+					if (true == lpCharacter->RemoveItem(takeType.m_srcPos))
+					{
+						lpItem->SetStallPrice(dwPrice);
+						if (true == SetItem(takeType.m_dstPos, lpItem))
+						{
+							return lpItem;
+						}
+						else
+						{
+							lpItem->SetStallPrice(0);
+							if (false == lpCharacter->SetItem(takeType.m_srcPos, lpItem)) 
+							{
+								SERLOG3(g_Log, "CID:0x%08x 아이템 이동 실패 : (%d, 0x%04x) 제자리에 돌려 놓을 수 없음. 아이템을 제거함.",
+									lpCharacter->GetCID(), takeType.m_srcPos.m_cPos, takeType.m_srcPos.m_cIndex);
+								DELETE_ITEM(lpItem);
+							}
+						}
+					}
+				}
+				break;
+			}
+
+			case PktStRI::SC_CAMP_CANCEL:
+			{
+				if (takeType.m_srcPos.m_cPos != TakeType::TS_CAMPSHOP)
+				{
+					ERRLOG1(g_Log, "CID:%10u 길드 요새 상점에 올린 아이템을 가져오는데 실패하였습니다."
+						"CancelPacket에 SrcPos가 Stall이 아닙니다.", lpCharacter->GetCID());
+					return NULL;
+				}
+
+				if (NULL != lpCharacter->GetItem(takeType.m_dstPos))
+				{
+					ERRLOG3(g_Log, "CID:%10u 놓으려는 위치에 이미 아이템이 존재합니다. 클라이언트가 준 위치:(%d, 0x%04x)", 
+						lpCharacter->GetCID(), takeType.m_dstPos.m_cPos, takeType.m_dstPos.m_cIndex);
+					return NULL;
+				}
+
+				CItem* lpItem = GetItem(takeType.m_srcPos);
+				if (NULL != lpItem)
+				{
+					if (true == RemoveItem(takeType.m_srcPos))
+					{
+						SendRemoveItem(takeType, PktStRI::SC_CAMP_CANCEL, "");
+						if (true == lpCharacter->SetItem(takeType.m_dstPos, lpItem))
+						{
+							return lpItem;
+						}
+						else
+						{
+							if (false == SetItem(takeType.m_srcPos, lpItem)) 
+							{
+								SERLOG3(g_Log, "CID:0x%08x 아이템 이동 실패 : (%d, 0x%04x) 제자리에 돌려 놓을 수 없음. 아이템을 제거함.",
+									lpCharacter->GetCID(), takeType.m_srcPos.m_cPos, takeType.m_srcPos.m_cIndex);
+								DELETE_ITEM(lpItem);
+							}
+						}
+					}
+				}
+				break;
+			}
+		}
+	}
+
+	return NULL;
+}
+
+bool CCampShopContainer::CheckUpdateCount(void)
+{
+	if (UPDATE_COUNT <= m_cUpdateCount)
+	{
+		m_cUpdateCount = 0;
+		return true;
+	}
+
+	return false;
+}
+
+bool CCampShopContainer::SendCharStallItemInfo(CSendStream& SendStream)
+{
+	CCampShop* lpShop = 
+		reinterpret_cast<CCampShop*>(CCreatureManager::GetInstance().GetSiegeObject(m_dwCID));
+	if (NULL != lpShop)
+	{
+		const int MAX_BUFFER = sizeof(PktStIInfo) + 
+			((Item::MAX_ITEM_SIZE + sizeof(unsigned long)) * 
+			ContainerConstant::CAMPSHOP_WIDTH * ContainerConstant::CAMPSHOP_HEIGHT);
+
+		char szBuffer[MAX_BUFFER];
+
+		unsigned long dwItemSize = Item::MAX_ITEM_SIZE * m_nXSize * m_nYSize;		
+		SerializeOut(szBuffer + sizeof(PktStIInfo), dwItemSize);
+
+		unsigned char cItemNum = 0;
+		StallPriceOut(reinterpret_cast<unsigned long*>(szBuffer + sizeof(PktStIInfo) + dwItemSize), cItemNum);
+
+		return GameClientSendPacket::SendCharStallItemInfo(SendStream, m_dwCID, m_aryCustomerID, 
+			lpShop->GetTempSafe(), lpShop->GetTax(), szBuffer, dwItemSize, cItemNum);
+	}
+
+	return false;
+}
+
+bool CCampShopContainer::IsEmpty() const
+{
+	for (unsigned short nTab = 0; nTab < m_nTabNum; ++nTab)
+	{
+		for (unsigned short nHeight = 0; nHeight < m_nYSize; ++nHeight)
+		{
+			for (unsigned short nWidth = 0; nWidth < m_nXSize; ++nWidth)
+			{                
+				const CItem* lpItem = m_lppItems[m_nSizePerTab * nTab + m_nXSize * nHeight + nWidth];
+				if (NULL != lpItem)
+				{
+                    return false;
+				}
+			}
+		}
+	}
+
+	return true;
+}

Server/RylServerProject/RylGameLibrary/Item/Container/StallContainer.h

@@ -0,0 +1,137 @@
+#ifndef _STALL_CONTAINER_H_
+#define _STALL_CONTAINER_H_
+
+#include "ItemContainer.h"
+
+
+// 전방 참조
+class CChatPacket;
+class CSendStream;
+class CAggresiveCreature;
+class CCharacter;
+class CCell;
+
+namespace Item
+{
+	class CShopContainer : public CArrayContainer
+	{
+	public:
+
+        enum 
+        { 
+            MAX_CUSTOMER_NUM	= 10
+        };
+
+        CShopContainer();
+        virtual ~CShopContainer();
+
+		bool Initialize(unsigned long dwCID, unsigned char cWidth, unsigned char cHeight);
+
+		virtual void Clear(void);
+
+        virtual CItem* GetItem(ItemPos itemPos);
+        virtual bool SetItem(ItemPos itemPos, CItem* lpItem) = 0;
+        virtual bool RemoveItem(ItemPos itemPos);
+
+		void SwapPosAllItem(void);
+
+		bool StallPriceOut(unsigned long* szStallPriceBuffer_Out, unsigned char& cItemNum_Out) const;
+
+		bool Enter(CCharacter *lpCustomer);
+		bool Leave(CCharacter *lpCustomer);
+
+		unsigned char GetCurrentCustomerNum(void);
+
+		virtual bool Close(void);
+
+		virtual bool SendCharStallItemInfo(CCharacter *lpCustomer) = 0;
+		virtual bool SendAllCustomer(const char* szPacket, const unsigned long dwPacketSize,
+            bool bIncludeOwner, unsigned char cCMD_In);
+
+		bool SendRemoveItem(TakeType takeType, unsigned char cCmd, const char* strBuyUser);
+		bool SendCharStallEnter(unsigned long dwCustomerID, unsigned long dwOwnerID);
+
+	protected:
+
+		void Destroy();
+
+		unsigned long	m_aryCustomerID[MAX_CUSTOMER_NUM];	// 손님들의 아이디 배열
+	};
+
+
+	class CCharacterShopContainer : public CShopContainer
+    {
+    public:
+
+        enum 
+        { 
+            MAX_STALL_NAME_LEN	= 32 
+        };
+
+        CCharacterShopContainer();
+        virtual ~CCharacterShopContainer();
+
+		virtual void Clear(void);
+
+		void RollBackAllItem(void);
+
+        virtual bool SetItem(ItemPos itemPos, CItem* lpItem);
+
+		void SetOtherOwner(unsigned long dwCID) { m_dwOtherOwnerID = dwCID;	}
+		unsigned long GetOtherOwner(void)		{ return m_dwOtherOwnerID;	}
+
+		char* GetStallName(void)				{ return m_strStallName;	}
+
+		bool Open(char *strStallName);
+		virtual bool Close(void);
+
+		virtual bool SendCharStallItemInfo(CCharacter *lpCustomer);
+		virtual bool SendAllCustomer(const char* szPacket, const unsigned long dwPacketSize,
+            bool bIncludeOwner, unsigned char cCMD_In);
+
+		bool SendCharStallOpen(char *strStallName);
+
+	protected:
+
+		unsigned long	m_dwOtherOwnerID;						// 주인의 아이디 (남이 개설한 노점상에 입장한 경우)
+        char			m_strStallName[MAX_STALL_NAME_LEN];		// 노점상 이름
+    };
+
+
+	class CCampShopContainer : public CShopContainer
+	{
+	public:
+
+		CCampShopContainer(void);
+		virtual ~CCampShopContainer(void);
+
+        virtual bool SetItem(ItemPos itemPos, CItem* lpItem);
+		virtual bool RemoveItem(ItemPos itemPos);
+
+		void DropItem(CCell* lpCell, const Position& currentPos, unsigned long dwOffencerGID);
+
+		bool StallPriceIn(const unsigned long* szStallPriceBuffer_In, unsigned char cItemNum_In);
+
+		virtual bool SendCharStallItemInfo(CCharacter *lpCustomer);
+
+		CItem* RegisterCancelItem(CCharacter* lpCharacter, TakeType takeType, unsigned long dwPrice, unsigned char cCmd);
+		bool CheckUpdateCount(void);
+		void IncreaseUpdateCount(void)	{ ++m_cUpdateCount;	}
+
+		bool SendCharStallItemInfo(CSendStream& SendStream);
+
+		bool IsEmpty() const;
+		
+	protected:
+
+		enum Const
+		{
+			UPDATE_COUNT	= 1								
+		};
+
+		unsigned char	m_cUpdateCount;							// 업데이트 카운트 (UPDATE_COUNT를 넘어서면 DB에 업데이트한다.)
+	};
+};
+
+
+#endif

Server/RylServerProject/RylGameLibrary/Item/Container/TempInvenContainer.cpp

@@ -0,0 +1,138 @@
+
+#include "stdafx.h"
+
+#include <Item/Item.h>
+#include <Item/Container/ItemContainer.h>
+
+#include <Network/Dispatch/GameClient/GameClientDispatch.h>
+#include <Network/Dispatch/GameClient/SendCharItem.h>
+
+#include <Creature/Character/Character.h>
+#include <Log/ItemLog.h>
+
+#include "TempInvenContainer.h"
+
+Item::CTempInvenContainer::CTempInvenContainer()
+:	m_lpOwner(NULL), m_cItemNum(0)
+{
+}
+
+Item::CTempInvenContainer::~CTempInvenContainer()
+{
+}
+
+bool Item::CTempInvenContainer::Initialize(CCharacter* lpCharacter, unsigned short nMaxSize)
+{
+	m_lpOwner = lpCharacter;
+	return Item::CListContainer::Initialize(lpCharacter->GetCID(), nMaxSize);
+}
+
+Item::CItem* Item::CTempInvenContainer::GetItem(Item::ItemPos itemPos) 
+{ 
+	CItem* lpItem = m_lppItems[0];
+	return (lpItem != m_lpNullItem) ? lpItem : NULL;
+}
+
+bool Item::CTempInvenContainer::SetItem(Item::ItemPos itemPos, Item::CItem* lpItem) 
+{ 
+	CGameClientDispatch* lpDispatch = m_lpOwner->GetDispatcher();
+
+	if (true == IsFull())
+	{
+		CCell::ItemInfo itemInfo;
+
+		CCell* lpCell = m_lpOwner->GetCellPos().m_lpCell;
+		if (NULL == lpCell) 
+		{
+			ERRLOG1(g_Log, "CID:%10u / 셀 얻기 실패", m_lpOwner->GetCID());
+			return false;
+		}
+
+		// 맨 위의 아이템
+		Item::CItem* lpItem = m_lppItems[0];
+		ItemPos itemPos(TakeType::TS_TEMPINVEN, 0);
+
+		// 임시 인벤토리에서 제거
+		if (false == RemoveItem(itemPos))
+		{
+			ERRLOG1(g_Log, "CID:%10u / 임시 인벤토리가 꽉 차서 맨 위의 아이템을 떨구는데 실패하였습니다. (임시 인벤토리에서 제거)",
+				m_lpOwner->GetCID());		    
+			return false;
+		}
+
+		// 필드에 아이템 떨구기
+		lpCell->SetItem(m_lpOwner->GetCurrentPos(), lpItem, 0, m_lpOwner->GetCID(), CCell::NONE, itemInfo);
+
+		// 아이템 떨구기 보냄
+		GAMELOG::LogDropItem(*m_lpOwner, itemPos, itemInfo.m_lpItem, 0, 0);
+
+		if (0 != lpDispatch)
+		{
+			GameClientSendPacket::SendCharPullDown(lpDispatch->GetSendStream(),
+				m_lpOwner->GetCID(), itemPos, itemInfo, PktBase::NO_SERVER_ERR);        
+		}
+	}
+
+	itemPos.m_cIndex = m_cItemNum;
+
+	if (!Item::CListContainer::SetItem(itemPos, lpItem)) 
+	{ 
+		ERRLOG1(g_Log, "CID:%10u / 임시 인벤토리에 아이템 추가를 실패하였습니다.", m_lpOwner->GetCID()); 
+		return false; 
+	}
+
+    // 성공시 아이템 개수 증가
+	++m_cItemNum;
+
+	if (0 != lpDispatch)
+	{
+		unsigned char cNum = (lpItem->IsSet(Item::DetailData::STACKABLE)) ? lpItem->GetNumOrDurability() : 1;
+		GameClientSendPacket::SendCharPickUp(lpDispatch->GetSendStream(), m_lpOwner->GetCID(), 
+			0, 0, lpItem, itemPos, cNum, PktBase::NO_SERVER_ERR);
+	}
+
+	return true;
+}
+
+bool Item::CTempInvenContainer::RemoveItem(Item::ItemPos itemPos) 
+{
+	if (NULL == m_lppItems[0])
+	{
+        ERRLOG1(g_Log, "CID:%10u / 임시 인벤토리에서 아이템을 제거하는데 실패하였습니다.", m_dwCID);
+		return false;
+	}
+
+	for (unsigned char cIndex = 0; cIndex < m_nMaxSize - 1; ++cIndex)
+	{
+		m_lppItems[cIndex] = m_lppItems[cIndex + 1];
+		if (NULL != m_lppItems[cIndex])
+		{
+			m_lppItems[cIndex]->MoveItem(ItemPos(TakeType::TS_TEMPINVEN, cIndex));
+		}
+	}
+
+	m_lppItems[m_nMaxSize - 1] = NULL;
+	--m_cItemNum;
+
+	return true;
+}
+
+bool Item::CTempInvenContainer::SerializeIn(const char* szItemBuffer_In, unsigned long dwBufferSize_In)
+{
+	if (false == CListContainer::SerializeIn(szItemBuffer_In, dwBufferSize_In))
+	{
+		return false;
+	}
+
+	for (unsigned char cIndex = 0; cIndex < m_nMaxSize; ++cIndex)
+	{
+		if (NULL == m_lppItems[cIndex])
+		{
+			break;
+		}
+
+		++m_cItemNum;
+	}
+
+	return true;
+}

Server/RylServerProject/RylGameLibrary/Item/Container/TempInvenContainer.h

@@ -0,0 +1,34 @@
+#ifndef _TEMP_INVEN_CONTAINER_H_
+#define _TEMP_INVEN_CONTAINER_H_
+
+// 전방 참조
+class CCharacter;
+
+namespace Item
+{
+	class CTempInvenContainer : public CListContainer
+	{
+	protected:
+
+		CCharacter*		m_lpOwner;			// 임시 인벤토리의 주인
+		unsigned char	m_cItemNum;			// 현재 임시 인벤토리의 아이템 갯수
+
+
+	public:
+
+		CTempInvenContainer();
+		virtual ~CTempInvenContainer();
+
+		bool Initialize(CCharacter* lpCharacter, unsigned short nMaxSize);
+
+		virtual CItem* GetItem(ItemPos itemPos);
+		virtual bool SetItem(ItemPos itemPos, CItem* lpItem);
+		virtual bool RemoveItem(ItemPos itemPos);
+
+		virtual bool SerializeIn(const char* szItemBuffer_In, unsigned long dwBufferSize_In);
+
+		bool IsFull(void)	{ return (m_cItemNum == m_nMaxSize);	}
+	};
+};
+
+#endif