packet.h

Search for this: typedef struct command_item_drop2
then replace this in the struct:

BYTE        count;
to this:

WORD        count;
Then search for this: typedef struct command_item_move
then replace this in the struct:

BYTE num;
To this:

WORD num;
Search for this: typedef struct SShopItemTable
then replace this in the struct:

BYTE		count;
to this:

WORD		count;
Search for this: typedef struct packet_set_item2
then replace this in the struct:

BYTE		count;
to this:

WORD		count;
Then search for this: typedef struct packet_update_item
then replace this in the struct:

BYTE		count;
to this:

WORD		count;

Then search for this: typedef struct SEquipmentItemSet
replace this:

BYTE    count;
to this:

WORD    count;

PythonNetworkPhaseGame.cpp->RecvExchangePacket function

Replace this:

CPythonExchange::Instance().SetItemToSelf(iSlotIndex, exchange_packet.arg1, (BYTE) exchange_packet.arg3);
To this:

CPythonExchange::Instance().SetItemToSelf(iSlotIndex, exchange_packet.arg1, (WORD) exchange_packet.arg3);
and this:

CPythonExchange::Instance().SetItemToTarget(iSlotIndex, exchange_packet.arg1, (BYTE) exchange_packet.arg3);
to this:

CPythonExchange::Instance().SetItemToTarget(iSlotIndex, exchange_packet.arg1, (WORD) exchange_packet.arg3);

pythonexchange.cpp:

Replace this:

BYTE CPythonExchange::GetItemCountFromTarget(BYTE pos)
With this:

WORD CPythonExchange::GetItemCountFromTarget(BYTE pos)
Then this:

BYTE CPythonExchange::GetItemCountFromSelf(BYTE pos)
With this:

WORD CPythonExchange::GetItemCountFromSelf(BYTE pos)
And this:

void CPythonExchange::SetItemToTarget(DWORD pos, DWORD vnum, BYTE count)
With this:

void CPythonExchange::SetItemToTarget(DWORD pos, DWORD vnum, WORD count)
And then this:

void CPythonExchange::SetItemToSelf(DWORD pos, DWORD vnum, BYTE count)
With this:

void CPythonExchange::SetItemToSelf(DWORD pos, DWORD vnum, WORD count)

pythonexchange.h

Replace this ones:

		BYTE			GetItemCountFromTarget(BYTE pos);
		BYTE			GetItemCountFromSelf(BYTE pos);
		
		void			SetItemToTarget(DWORD pos, DWORD vnum, BYTE count);
		void			SetItemToSelf(DWORD pos, DWORD vnum, BYTE count);
		
		BYTE					item_count[EXCHANGE_ITEM_MAX_NUM];
To this:

		WORD			GetItemCountFromTarget(BYTE pos);
		WORD			GetItemCountFromSelf(BYTE pos);
		
		void			SetItemToTarget(DWORD pos, DWORD vnum, WORD count);
		void			SetItemToSelf(DWORD pos, DWORD vnum, WORD count);
		
		WORD					item_count[EXCHANGE_ITEM_MAX_NUM];

PythonNetworkStreamPhaseGameItem.cpp

Replace the whole function:

bool CPythonNetworkStream::SendShopSellPacketNew
With this:

typedef struct fckOFF
{
	BYTE		bySlot;
	WORD		byCount;
} TfckOFF;

bool CPythonNetworkStream::SendShopSellPacketNew(BYTE bySlot, WORD byCount)
{
	if (!__CanActMainInstance())
		return true;

	TPacketCGShop PacketShop;
	PacketShop.header = HEADER_CG_SHOP;
	PacketShop.subheader = SHOP_SUBHEADER_CG_SELL2;
	TfckOFF second;
	second.byCount = byCount;
	second.bySlot = bySlot;

	if (!Send(sizeof(TPacketCGShop), &PacketShop))
	{
		Tracef("SendShopSellPacket Error\n");
		return false;
	}
	if (!Send(sizeof(TfckOFF), &second))
	{
		Tracef("SendShopAddSellPacket Error\n");
		return false;
	}
	/*if (!Send(sizeof(WORD), &byCount))
	{
		Tracef("SendShopAddSellPacket Error\n");
		return false;
	}*/

	Tracef(" SendShopSellPacketNew(bySlot=%d, byCount=%u)\n", bySlot, byCount);

	return SendSequence();
}
Then replace this:

bool CPythonNetworkStream::SendItemMovePacket(TItemPos pos, TItemPos change_pos, BYTE num)
bool CPythonNetworkStream::SendSafeBoxItemMovePacket(BYTE bySourcePos, BYTE byTargetPos, BYTE byCount)
To this:

bool CPythonNetworkStream::SendItemMovePacket(TItemPos pos, TItemPos change_pos, WORD num)
bool CPythonNetworkStream::SendSafeBoxItemMovePacket(BYTE bySourcePos, BYTE byTargetPos, WORD byCount)

pythonplayermodule.cpp

Replace the whole function:

PyObject * playerSetItemCount(PyObject* poSelf, PyObject* poArgs)
With this:

PyObject * playerSetItemCount(PyObject* poSelf, PyObject* poArgs)
{
	switch (PyTuple_Size(poArgs))
	{
	case 2:
		{
			int iSlotIndex;
			if (!PyTuple_GetInteger(poArgs, 0, &iSlotIndex))
				return Py_BuildException();

			WORD wCount;
			if (!PyTuple_GetInteger(poArgs, 1, &wCount))
				return Py_BuildException();

			if (0 == wCount)
				return Py_BuildException();

			CPythonPlayer::Instance().SetItemCount(TItemPos (INVENTORY, iSlotIndex), wCount);
			return Py_BuildNone();
		}
	case 3:
		{
			TItemPos Cell;
			if (!PyTuple_GetByte(poArgs, 0, &Cell.window_type))
				return Py_BuildException();

			if (!PyTuple_GetInteger(poArgs, 1, &Cell.cell))
				return Py_BuildException();

			WORD wCount;
			if (!PyTuple_GetInteger(poArgs, 2, &wCount))
				return Py_BuildException();

			CPythonPlayer::Instance().SetItemCount(Cell, wCount);

			return Py_BuildNone();
		}
	default:
		return Py_BuildException();

	}
}
PythonNetworkStreamModule.cpp

Replace the following function:

PyObject* netSendItemMovePacket(PyObject* poSelf, PyObject* poArgs)
With this:

PyObject* netSendItemMovePacket(PyObject* poSelf, PyObject* poArgs)
{
	TItemPos Cell;
	TItemPos ChangeCell;
	int num;

	switch (PyTuple_Size(poArgs))
	{
	case 3:
		if (!PyTuple_GetInteger(poArgs, 0, &Cell.cell))
			return Py_BuildException();
		if (!PyTuple_GetInteger(poArgs, 1, &ChangeCell.cell))
			return Py_BuildException();
		if (!PyTuple_GetInteger(poArgs, 2, &num))
			return Py_BuildException();
		break;
	case 5:
		{
			if (!PyTuple_GetByte(poArgs, 0, &Cell.window_type))
				return Py_BuildException();
			if (!PyTuple_GetInteger(poArgs, 1, &Cell.cell))
				return Py_BuildException();
			if (!PyTuple_GetByte(poArgs, 2, &ChangeCell.window_type))
				return Py_BuildException();
			if (!PyTuple_GetInteger(poArgs, 3, &ChangeCell.cell))
				return Py_BuildException();
			if (!PyTuple_GetInteger(poArgs, 4, &num))
				return Py_BuildException();
		}
		break;
	default:
		return Py_BuildException();
	}

	CPythonNetworkStream& rkNetStream=CPythonNetworkStream::Instance();
	rkNetStream.SendItemMovePacket(Cell, ChangeCell, (WORD) num);//ez a sor az
	return Py_BuildNone();
}
GameType.h

Search for this: typedef struct packet_item
Then replace this:

BYTE        count;
With this:

WORD        count;
Search for this: typedef struct packet_shop_item
And edit this:

BYTE        count;
to this:

WORD        count;
AbstractPlayer.h

Replace this:

virtual void	SetItemCount(TItemPos itemPos, BYTE byCount) = 0;
With this:

virtual void	SetItemCount(TItemPos itemPos, WORD byCount) = 0;
PythonPlayer.cpp

Replace this:

void CPythonPlayer::SetItemCount(TItemPos Cell, BYTE byCount)
With this:

void CPythonPlayer::SetItemCount(TItemPos Cell, WORD byCount)
PythonPlayer.h

Replace this:

void	SetItemCount(TItemPos Cell, BYTE byCount);
With this:

void	SetItemCount(TItemPos Cell, WORD byCount);
PythonNetworkStream.h

And this:

bool SendSafeBoxItemMovePacket(BYTE bySourcePos, BYTE byTargetPos, BYTE byCount);
bool SendShopSellPacketNew(BYTE bySlot, BYTE byCount);
bool SendItemMovePacket(TItemPos pos, TItemPos change_pos, BYTE num);
With this:

bool SendSafeBoxItemMovePacket(BYTE bySourcePos, BYTE byTargetPos, WORD byCount);
bool SendShopSellPacketNew(BYTE bySlot, WORD byCount);
bool SendItemMovePacket(TItemPos pos, TItemPos change_pos, WORD num);
Now we are done with the client, you can build it now.


server

common/tables.h

Search this: typedef struct SShopItemTable
Then replace this:

BYTE		count;
To this:

WORD		count;
packet.h

Search for this: typedef struct command_item_drop2
Then edit this:

BYTE	count;
To this:

WORD	count;
Then search this:: typedef struct command_item_move
Replace this:

BYTE	count;
With this:

WORD	count;
Then search this: typedef struct packet_item_set
Replace this:

BYTE	count;
To this:

WORD	count;
Search this: typedef struct packet_item_update
Replace this:

BYTE	count;
To this:

WORD	count;
Search this: struct packet_shop_item
Replace this:

BYTE        count;
To this:

WORD        count;
Search this: typedef struct pakcet_view_equip
Then replace this:

BYTE	count;
To this:

WORD	count;

input_main.cpp

Replace this whole function:

int CInputMain::Shop(LPCHARACTER ch, const char * data, size_t uiBytes)
With this:

typedef struct fckOFF
{
	BYTE		bySlot;
	WORD		byCount;
} TfckOFF;

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

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

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

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

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

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

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

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

				BYTE pos = *c_pData;

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

		case SHOP_SUBHEADER_CG_SELL2:
			{
				if (uiBytes < sizeof(TfckOFF))
					return -1;
				TfckOFF*p2 = (TfckOFF*)c_pData;
				/*BYTE pos = *(c_pData++);
				WORD count = *(c_pData);*/

				sys_log(0, "INPUT: %s SHOP: SELL2", ch->GetName());
				CShopManager::instance().Sell(ch, p2->bySlot, p2->byCount);
				return sizeof(TfckOFF);
			}

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

	return 0;
}

shop_manager.cpp

Replace this:

void CShopManager::Sell(LPCHARACTER ch, BYTE bCell, BYTE bCount)
To this:

void CShopManager::Sell(LPCHARACTER ch, BYTE bCell, WORD bCount)
 
shop.h
Search this: typedef struct shop_item

Replace this:

BYTE	count;
To this:

WORD	count;
shop_manager.h

Replace this:

void	Sell(LPCHARACTER ch, BYTE bCell, BYTE bCount=0);
To this:

void	Sell(LPCHARACTER ch, BYTE bCell, WORD bCount=0);
char_item.cpp

Replace this:

bool CHARACTER::DropItem(TItemPos Cell, BYTE bCount)
To this:

bool CHARACTER::DropItem(TItemPos Cell, WORD bCount)
Then replace this:

bool CHARACTER::MoveItem(TItemPos Cell, TItemPos DestCell, BYTE count)
To this:

bool CHARACTER::MoveItem(TItemPos Cell, TItemPos DestCell, WORD count)
And replace this in this function:

count = MIN(200 - item2->GetCount(), count);
To this:

count = MIN(ITEM_MAX_COUNT - item2->GetCount(), count);
Then replace this:

LPITEM CHARACTER::AutoGiveItem(DWORD dwItemVnum, BYTE bCount, int iRarePct, bool bMsg)
To this:

LPITEM CHARACTER::AutoGiveItem(DWORD dwItemVnum, WORD bCount, int iRarePct, bool bMsg)
And replace this in this function:

BYTE bCount2 = MIN(200 - item->GetCount(), bCount);
To this:

WORD bCount2 = MIN(ITEM_MAX_COUNT - item->GetCount(), bCount);
And replace this inside the PickupItem function:

BYTE bCount = item->GetCount();
To this:

WORD bCount = item->GetCount();
And this (still inside this function):

BYTE bCount2 = MIN(200 - item2->GetCount(), bCount);
To this:

WORD bCount2 = MIN(ITEM_MAX_COUNT - item2->GetCount(), bCount);

item.cpp->DWORD CItem::GetCount()

Replace this:

return MIN(m_dwCount, 200);
To this:

return MIN(m_dwCount, ITEM_MAX_COUNT);

safebox.cpp

Replace this:

bool CSafebox::MoveItem(BYTE bCell, BYTE bDestCell, BYTE count)
To this:

bool CSafebox::MoveItem(BYTE bCell, BYTE bDestCell, WORD count)
Then replace this inside this function:

count = MIN(200 - item2->GetCount(), count);
To this:

count = MIN(ITEM_MAX_COUNT - item2->GetCount(), count);
common/item_lenght.h

Here you can set the maximum number in a stack. Change this as big as you want (between 0 and ~60k)

ITEM_MAX_COUNT				= 200,
(I changed this to 300, just for the test)

char.h

Replace this:

bool			DropItem(TItemPos Cell,  BYTE bCount=0);
bool			MoveItem(TItemPos pos, TItemPos change_pos, BYTE num);
LPITEM			AutoGiveItem(DWORD dwItemVnum, BYTE bCount=1, int iRarePct = -1, bool bMsg = true);
To this:

bool			DropItem(TItemPos Cell,  WORD bCount=0);
bool			MoveItem(TItemPos pos, TItemPos change_pos, WORD num);
LPITEM			AutoGiveItem(DWORD dwItemVnum, WORD bCount=1, int iRarePct = -1, bool bMsg = true);

safebox.h

Replace this:

bool		MoveItem(BYTE bCell, BYTE bDestCell, BYTE count);
To this:

bool		MoveItem(BYTE bCell, BYTE bDestCell, WORD count);
oxevent.cpp

Replace this:

bool COXEventManager::GiveItemToAttender(DWORD dwItemVnum, BYTE count)
To this:

bool COXEventManager::GiveItemToAttender(DWORD dwItemVnum, WORD count)
oxevent.h

Replace this:

bool GiveItemToAttender(DWORD dwItemVnum, BYTE count);
With this:

bool GiveItemToAttender(DWORD dwItemVnum, WORD count);