FactoryCraft-Server/FactoryCraft/Inventory.cpp

#include <InMemoryBuffer.h>

#include "Inventory.h"
#include "ItemFilter.h"
#include "Constants.h"
#include "Area.h"
#include "NetworkMessage.h"
#include "Entity.h"
#include "Game.h"


using namespace Framework;

InventoryInteraction::InventoryInteraction(Inventory* current, Inventory* other, Direction dir)
	: current(current),
	other(other),
	dir(dir)
{
	lock();
}

InventoryInteraction::InventoryInteraction(const InventoryInteraction& interaction)
	: InventoryInteraction(interaction.current, interaction.other, interaction.dir)
{}

InventoryInteraction::~InventoryInteraction()
{
	unlock();
}

void InventoryInteraction::lock()
{
	if (!current || !other) return;
	if (current->location.x < other->location.x)
	{
		current->cs.lock();
		other->cs.lock();
		return;
	}
	else if (current->location.x == other->location.x)
	{
		if (current->location.y < other->location.y)
		{
			current->cs.lock();
			other->cs.lock();
			return;
		}
		else if (current->location.y == other->location.y)
		{
			if (current->location.z < other->location.z)
			{
				current->cs.lock();
				other->cs.lock();
				return;
			}
		}
	}
	other->cs.lock();
	current->cs.lock();
}

void InventoryInteraction::unlock()
{
	if (!current || !other) return;
	if (current->location.x < other->location.x)
	{
		current->cs.unlock();
		other->cs.unlock();
		return;
	}
	else if (current->location.x == other->location.x)
	{
		if (current->location.y < other->location.y)
		{
			current->cs.unlock();
			other->cs.unlock();
			return;
		}
		else if (current->location.y == other->location.y)
		{
			if (current->location.z < other->location.z)
			{
				current->cs.unlock();
				other->cs.unlock();
				return;
			}
		}
	}
	other->cs.unlock();
	current->cs.unlock();
}

void InventoryInteraction::transaction(Inventory* zSource, Inventory* zTarget, ItemFilter* zFilter, Direction sourceView, Direction targetView, int count)
{
	for (auto sourceSlot = zSource->pullSlotsOrder->begin(); sourceSlot; )
	{
		while (sourceSlot && (sourceSlot->getNumberOfItems() == 0 || (zFilter && !zFilter->matchSourceSlot(sourceSlot))))
			sourceSlot++;
		if (!sourceSlot) break;
		// TODO: use target cache ot get list of slots that already contains the source ite
		bool needNext = 1;
		for (auto targetSlot = zTarget->pushSlotsOrder->begin(); targetSlot; )
		{
			while (targetSlot && (targetSlot->isFull() || (zFilter && !zFilter->matchTargetSlot(targetSlot))))
				targetSlot++;
			if (!targetSlot) break;
			if (targetSlot->zStack())
			{
				if (sourceSlot->zStack()->zItem()->canBeStackedWith(targetSlot->zStack()->zItem()))
				{
					int number = MIN(targetSlot->numberOfAddableItems(sourceSlot->zStack(), sourceView), count);
					int tmp = number;
					if (number > 0 && zSource->allowPullStack(sourceSlot, sourceView) && zTarget->allowPushStack(targetSlot, targetView, sourceSlot->zStack()->zItem(), tmp))
					{
						number = MIN(number, tmp);
						ItemStack* stack = sourceSlot->takeItemsOut(number, dir);
						if (stack)
						{
							targetSlot->addItems(stack, dir);
							zSource->updateCache(sourceSlot, targetSlot->zStack()->zItem()->zItemType()->getId());
							zSource->afterPullStack(sourceSlot, sourceView, targetSlot->zStack()->zItem(), number);
							zTarget->afterPushStack(targetSlot, targetView, targetSlot->zStack()->zItem(), number);
							if (stack->getSize())
								throw stack;
							stack->release();
							count -= number;
							if (count == 0)
								return;
							needNext = 0;
						}
						else
							targetSlot++;
					}
					else
						targetSlot++;
				}
				else
					targetSlot++;
			}
			else
			{
				int number = MIN(targetSlot->numberOfAddableItems(sourceSlot->zStack(), sourceView), count);
				int tmp = number;
				if (number > 0 && zSource->allowPullStack(sourceSlot, sourceView) && zTarget->allowPushStack(targetSlot, targetView, sourceSlot->zStack()->zItem(), tmp))
				{
					number = MIN(number, tmp);
					if (number > 0)
					{
						ItemStack* stack = sourceSlot->takeItemsOut(number, dir);
						if (stack)
						{
							targetSlot->addItems(stack, dir);
							zSource->updateCache(sourceSlot, targetSlot->zStack()->zItem()->zItemType()->getId());
							zTarget->updateCache(targetSlot, -1);
							zSource->afterPullStack(sourceSlot, sourceView, targetSlot->zStack()->zItem(), number);
							zTarget->afterPushStack(targetSlot, targetView, targetSlot->zStack()->zItem(), number);
							if (stack->getSize())
								throw stack;
							stack->release();
							count -= number;
							if (count == 0)
								return;
							needNext = 0;
						}
						else
							targetSlot++;
					}
					else
						targetSlot++;
				}
				else
					targetSlot++;
			}
			if (sourceSlot->getNumberOfItems() == 0)
				break;
		}
		if (needNext)
			sourceSlot++;
	}
}


InventoryInteraction& InventoryInteraction::operator=(const InventoryInteraction& data)
{
	if (&data == this) return *this;
	unlock();
	current = data.current;
	other = data.other;
	dir = data.dir;
	lock();
	return *this;
}

void InventoryInteraction::endInteraction()
{
	unlock();
	current = 0;
	other = 0;
}

void InventoryInteraction::pullItems(int count, ItemFilter* zFilter)
{
	if (!current || !other) return;
	transaction(other, current, zFilter, getOppositeDirection(dir), dir, count);
}

void InventoryInteraction::pushItems(int count, ItemFilter* zFilter)
{
	if (!current || !other) return;
	transaction(current, other, zFilter, dir, getOppositeDirection(dir), count);
}


Inventory::Inventory(const Framework::Vec3<float> location, bool hasInventory)
	: ReferenceCounter(),
	nextSlotId(1),
	location(location)
{
	if (hasInventory)
	{
		pullSlotsOrder = new Framework::RCArray<ItemSlot>();
		pushSlotsOrder = new Framework::RCArray<ItemSlot>();
		itemCache = new Framework::HashMap<int, Framework::Array<ItemSlot*>*>(ITEM_CACHE_SIZE, std::_Identity<int>());
	}
	else
	{
		pullSlotsOrder = 0;
		pushSlotsOrder = 0;
		itemCache = 0;
	}
}

Inventory::~Inventory()
{
	if (pullSlotsOrder)
		pullSlotsOrder->release();
	if (pushSlotsOrder)
		pushSlotsOrder->release();
	if (itemCache)
		itemCache->release();
}

void Inventory::updateCache(ItemSlot* zSlot, int beforeKey)
{
	if (!itemCache)
		return;
	int key = zSlot->zStack() ? zSlot->zStack()->zItem()->zItemType()->getId() : -1;
	if (key == beforeKey)
		return;
	if (beforeKey >= 0)
	{
		auto tmp = itemCache->safeGet(key, 0);
		if (tmp)
			tmp->removeValue(zSlot);
	}
	if (zSlot->zStack())
	{
		auto tmp = itemCache->safeGet(key, 0);
		if (!tmp)
		{
			tmp = new Array<ItemSlot*>();
			itemCache->put(key, tmp);
		}
		tmp->add(zSlot, 0);
	}
}

void Inventory::addSlot(ItemSlot* slot)
{
	cs.lock();
	((ItemSlotIDSetter*)slot)->setId(nextSlotId++);
	int pullPrio = slot->getPullPriority();
	int pushPrio = slot->getPushPriority();
	int index = 0;
	for (auto stack : *pullSlotsOrder)
	{
		if (stack->getPullPriority() > pullPrio)
			break;
		index++;
	}
	pullSlotsOrder->add(dynamic_cast<ItemSlot*>(slot->getThis()), index);
	index = 0;
	for (auto stack : *pushSlotsOrder)
	{
		if (stack->getPushPriority() > pushPrio)
			break;
		index++;
	}
	pushSlotsOrder->add(slot, index);
	updateCache(slot, -1);
	cs.unlock();
}

bool Inventory::allowPullStack(ItemSlot* zSlot, Direction dir) const
{
	return pullSlotsOrder;
}

bool Inventory::allowPushStack(ItemSlot* zSlot, Direction dir, const Item* zItem, int& count) const
{
	return pushSlotsOrder;
}

void Inventory::afterPullStack(ItemSlot* zSlot, Direction dir, const Item* zItem, int count)
{
	NetworkMessage* msg = new NetworkMessage();
	char* message = new char[9];
	message[0] = 1; // set count of items
	*(int*)(message + 1) = zSlot->getId();
	*(int*)(message + 5) = zSlot->getNumberOfItems();
	msg->setMessage(message, 9);
	notyObservers(msg);
	for (auto call : afterPullStackCalls)
		call(zSlot, dir, zItem, count);
}

void Inventory::afterPushStack(ItemSlot* zSlot, Direction dir, const Item* zItem, int count)
{
	if (zSlot->getNumberOfItems() > count)
	{
		NetworkMessage* msg = new NetworkMessage();
		char* message = new char[9];
		message[0] = 1; // set count of items
		*(int*)(message + 1) = zSlot->getId();
		*(int*)(message + 5) = zSlot->getNumberOfItems();
		msg->setMessage(message, 9);
		notyObservers(msg);
	}
	else
	{
		NetworkMessage* msg = new NetworkMessage();
		char* message = new char[29];
		message[0] = 2; // add new stack
		*(int*)(message + 1) = zSlot->getId();
		*(int*)(message + 5) = zSlot->getNumberOfItems();
		const Item* zItem = zSlot->zStack()->zItem();
		*(float*)(message + 9) = zItem->getHp();
		*(float*)(message + 13) = zItem->getMaxHp();
		*(float*)(message + 17) = zItem->getDurability();
		*(float*)(message + 21) = zItem->getMaxDurability();
		*(int*)(message + 25) = zItem->zItemType()->getId();
		msg->setMessage(message, 29);
		notyObservers(msg);
	}
	for (auto call : afterPushStackCalls)
		call(zSlot, dir, zItem, count);
}

void Inventory::loadInventory(Framework::StreamReader* zReader)
{
	if (itemCache)
	{
		for (auto stack : *pushSlotsOrder)
		{
			int size = 0;
			zReader->lese((char*)&size, 4);
			if (size != 0)
			{
				int id = 0;
				zReader->lese((char*)&id, 4);
				Item* item = StaticRegistry<ItemType>::INSTANCE.zElement(id)->loadItem(zReader);
				stack->addItems(new ItemStack(item, size), NO_DIRECTION);
			}
		}
	}
}

void Inventory::saveInventory(Framework::StreamWriter* zWriter)
{
	if (itemCache)
	{
		for (auto slot : *pushSlotsOrder)
		{
			const ItemStack* stack = slot->zStack();
			int value = 0;
			if (!stack || !stack->zItem())
			{
				zWriter->schreibe((char*)&value, 4);
			}
			else
			{
				value = stack->getSize();
				zWriter->schreibe((char*)&value, 4);
				value = stack->zItem()->zItemType()->getId();
				zWriter->schreibe((char*)&value, 4);
				stack->zItem()->zItemType()->saveItem(stack->zItem(), zWriter);
			}
		}
	}
}

void Inventory::notyObservers(NetworkMessage* msg)
{
	cs.lock();
	int index = 0;
	Array<int> toDelete;
	for (auto observer : observers)
	{
		Entity* e = Game::INSTANCE->zEntity(observer.getFirst());
		if (e)
		{
			msg->addressGui(observer.getSecond());
			Game::INSTANCE->sendMessage(msg->clone(), e);
		}
		else
			toDelete.add(index, 0);
		index++;
	}
	for (int i : toDelete)
		observers.remove(i);
	cs.unlock();
	msg->release();
}

void Inventory::removeObserver(Entity* zSource, Framework::Text id)
{
	cs.lock();
	int index = 0;
	for (auto observer : observers)
	{
		if (observer.getFirst() == zSource->getId() && observer.getSecond().istGleich(id))
		{
			observers.remove(index);
			break;
		}
		index++;
	}
	cs.unlock();
}

void Inventory::addObserver(Entity* zSource, Framework::Text id)
{
	cs.lock();
	for (auto observer : observers)
	{
		if (observer.getFirst() == zSource->getId() && observer.getSecond().istGleich(id))
		{
			cs.unlock();
			return;
		}
	}
	observers.add(ImmutablePair<int, Text>(zSource->getId(), id));
	cs.unlock();
	for (auto call : observerAddedCalls)
		call(zSource, id);
}

const ItemSlot* Inventory::zSlot(int id) const
{
	if (itemCache)
	{
		for (auto slot : *pushSlotsOrder)
		{
			if (slot->getId() == id)
				return slot;
		}
	}
	return 0;
}

void Inventory::localTransaction(Array< ItemSlot* >* zSourceSlots, Array< ItemSlot* >* zTargetSlots, ItemFilter* zFilter, int count, Direction outDir, Direction inDir)
{
	if (itemCache)
	{
		cs.lock();
		auto sourceSlot = zSourceSlots ? zSourceSlots->begin() : pullSlotsOrder->begin();
		for (auto targetSlot = zTargetSlots->begin(); targetSlot; )
		{
			int amount = count;
			if (!targetSlot->isFull())
			{
				if (targetSlot->zStack())
				{
					Array<ItemSlot*>* zSurceListe = itemCache->safeGet(targetSlot->zStack()->zItem()->zItemType()->getId(), 0);
					if (zSurceListe)
					{
						Array<int> toDelete;
						int index = 0;
						for (auto sourceSlot = zSurceListe->begin(); sourceSlot; sourceSlot++, index++)
						{
							if (zSourceSlots && zSourceSlots->getWertIndex(sourceSlot) < 0)
								continue;
							if (zFilter && !zFilter->matchItem(sourceSlot->zStack()->zItem()))
								continue;
							int number = MIN(targetSlot->numberOfAddableItems(sourceSlot->zStack(), inDir), count);
							if (number > 0)
							{
								ItemStack* stack = sourceSlot->takeItemsOut(number, outDir);
								if (stack)
								{
									if (!sourceSlot->zStack())
										toDelete.add(index, 0);
									targetSlot->addItems(stack, inDir);
									updateCache(sourceSlot, targetSlot->zStack()->zItem()->zItemType()->getId());
									afterPullStack(sourceSlot, outDir, targetSlot->zStack()->zItem(), number);
									afterPushStack(targetSlot, inDir, targetSlot->zStack()->zItem(), number);
									if (stack->getSize())
									{
										cs.unlock();
										throw stack;
									}
									stack->release();
									count -= number;
									if (count == 0)
										break;
								}
							}
						}
						for (auto indexToDelete = toDelete.begin(); indexToDelete; indexToDelete++)
							zSurceListe->remove(indexToDelete);
						if (count == 0)
						{
							cs.unlock();
							return;
						}
					}
				}
				else
				{
					while (sourceSlot && (!sourceSlot->zStack() || (zFilter && !zFilter->matchItem(sourceSlot->zStack()->zItem()))))
						sourceSlot++;
					if (!sourceSlot)
					{
						cs.unlock();
						return;
					}
					int number = MIN(targetSlot->numberOfAddableItems(sourceSlot->zStack(), inDir), count);
					if (number > 0)
					{
						ItemStack* stack = sourceSlot->takeItemsOut(number, outDir);
						if (stack)
						{
							targetSlot->addItems(stack, inDir);
							updateCache(sourceSlot, targetSlot->zStack()->zItem()->zItemType()->getId());
							updateCache(targetSlot, -1);
							afterPullStack(sourceSlot, outDir, targetSlot->zStack()->zItem(), number);
							afterPushStack(targetSlot, inDir, targetSlot->zStack()->zItem(), number);
							if (stack->getSize())
							{
								cs.unlock();
								throw stack;
							}
							stack->release();
							count -= number;
							if (count == 0)
							{
								cs.unlock();
								return;
							}
						}
					}
				}
			}
			if (amount == count || targetSlot->isFull())
				targetSlot++;
		}
		cs.unlock();
	}
}

void Inventory::addItems(ItemStack* zItems, Direction dir)
{
	if (itemCache && zItems && zItems->getSize() > 0)
	{
		cs.lock();
		for (auto targetSlot = pushSlotsOrder->begin(); targetSlot; targetSlot++)
		{
			if (!targetSlot->isFull())
			{
				if (targetSlot->zStack())
				{
					if (targetSlot->zStack()->zItem()->canBeStackedWith(zItems->zItem()))
					{
						int number = MIN(targetSlot->numberOfAddableItems(zItems, dir), zItems->getSize());
						int tmp = number;
						if (number > 0 && allowPushStack(targetSlot, dir, zItems->zItem(), tmp))
						{
							number = MIN(number, tmp);
							ItemStack* stack = zItems->split(number);
							if (stack)
							{
								targetSlot->addItems(stack, dir);
								afterPushStack(targetSlot, dir, targetSlot->zStack()->zItem(), number);
								if (stack->getSize())
									throw stack;
								stack->release();
								if (!zItems->getSize())
									break;
							}
						}
					}
				}
				else
				{
					int number = MIN(targetSlot->numberOfAddableItems(zItems, dir), zItems->getSize());
					int tmp = number;
					if (number > 0 && allowPushStack(targetSlot, dir, zItems->zItem(), tmp))
					{
						number = MIN(number, tmp);
						ItemStack* stack = zItems->split(number);
						if (stack)
						{
							targetSlot->addItems(stack, dir);
							updateCache(targetSlot, -1);
							afterPushStack(targetSlot, dir, targetSlot->zStack()->zItem(), number);
							if (stack->getSize())
								throw stack;
							stack->release();
							if (!zItems->getSize())
								break;
						}
					}
				}
			}
		}
		cs.unlock();
	}
}

void Inventory::addItems(ItemSlot* zSlot, ItemStack* zItems, Direction dir)
{
	if (zSlot->zStack() && !zSlot->zStack()->zItem()->canBeStackedWith(zItems->zItem()))
		return;
	bool needUpdate = !zSlot->zStack();
	int number = MIN(zSlot->numberOfAddableItems(zItems, dir), zItems->getSize());
	int tmp = number;
	if (number > 0 && allowPushStack(zSlot, dir, zItems->zItem(), tmp))
	{
		number = MIN(number, tmp);
		ItemStack* stack = zItems->split(number);
		if (stack)
		{
			zSlot->addItems(stack, dir);
			if (needUpdate)
				updateCache(zSlot, -1);
			afterPushStack(zSlot, dir, zSlot->zStack()->zItem(), number);
			if (stack->getSize())
				throw stack;
			stack->release();
		}
	}
}

ItemStack* Inventory::takeItemsOut(ItemSlot* zSlot, int count, Direction dir)
{
	if (allowPullStack(zSlot, dir))
	{
		ItemStack* stack = zSlot->takeItemsOut(count, dir);
		if (stack)
		{
			updateCache(zSlot, stack->zItem()->zItemType()->getId());
			if (stack->getSize() > 0)
				afterPullStack(zSlot, dir, stack->zItem(), stack->getSize());
		}
		return stack;
	}
	return 0;
}

InventoryInteraction Inventory::interactWith(Inventory* zInventory, Direction dir)
{
	return InventoryInteraction(this, zInventory, dir);
}

void Inventory::unsaveAddItem(ItemStack* zStack, Direction dir)
{
	addItems(zStack, dir);
}

int Inventory::numberOfAddableItems(const ItemStack* zStack, Direction dir) const
{
	int count = 0;
	for (auto targetSlot = pushSlotsOrder->begin(); targetSlot; targetSlot++)
	{
		int maxCount = targetSlot->numberOfAddableItems(zStack, dir);
		int allowed = maxCount;
		if (allowPushStack(targetSlot, dir, zStack->zItem(), allowed))
			count += MIN(maxCount, allowed);
	}
	return count;
}

Framework::Iterator<ItemSlot*> Inventory::begin()
{
	return pullSlotsOrder->begin();
}

Framework::Iterator<ItemSlot*> Inventory::end()
{
	return pullSlotsOrder->end();
}

void Inventory::inventoryApi(Framework::StreamReader* zRequest, NetworkMessage* zResponse, Entity* zSource)
{
	char type;
	zRequest->lese(&type, 1);
	switch (type)
	{
	case 0: // request inventory
	{
		char idLen;
		zRequest->lese(&idLen, 1);
		char* id = new char[idLen + 1];
		zRequest->lese(id, idLen);
		id[(int)idLen] = 0;
		zResponse->addressGui(id);
		addObserver(zSource, id);
		delete[] id;
		char filterLen;
		zRequest->lese(&filterLen, 1);
		char* filter = new char[filterLen + 1];
		zRequest->lese(filter, filterLen);
		filter[(int)filterLen] = 0;
		InMemoryBuffer buffer;
		int count = 0;
		for (ItemSlot* slot : *this)
		{
			if (slot->getName().istGleich(filter))
			{
				count++;
				int id = slot->getId();
				buffer.schreibe((char*)&id, 4);
				int itemCount = slot->getNumberOfItems();
				buffer.schreibe((char*)&itemCount, 4);
				if (itemCount > 0)
				{
					float f = slot->zStack()->zItem()->getHp();
					buffer.schreibe((char*)&f, 4);
					f = slot->zStack()->zItem()->getMaxHp();
					buffer.schreibe((char*)&f, 4);
					f = slot->zStack()->zItem()->getDurability();
					buffer.schreibe((char*)&f, 4);
					f = slot->zStack()->zItem()->getMaxDurability();
					buffer.schreibe((char*)&f, 4);
					int id = slot->zStack()->zItem()->zItemType()->getId();
					buffer.schreibe((char*)&id, 4);
				}
			}
		}
		delete[] filter;
		char* msg = new char[5 + buffer.getSize()];
		msg[0] = 0;
		*(int*)(msg + 1) = count;
		buffer.lese(msg + 5, (int)buffer.getSize());
		zResponse->setMessage(msg, 5 + (int)buffer.getSize());
		break;
	}
	case 1: // remove Observer
		char idLen;
		zRequest->lese(&idLen, 1);
		char* id = new char[idLen + 1];
		zRequest->lese(id, idLen);
		id[(int)idLen] = 0;
		removeObserver(zSource, id);
		delete[] id;
		break;
	}
}

void Inventory::registerAfterPullStackCall(std::function<void(ItemSlot* zSlot, Direction dir, const Item* zItem, int count)> call)
{
	afterPullStackCalls.add(call);
}

void Inventory::registerAfterPushStackCall(std::function<void(ItemSlot* zSlot, Direction dir, const Item* zItem, int count)> call)
{
	afterPushStackCalls.add(call);
}

void Inventory::registerObserverAddedCall(std::function<void(Entity* zSource, Framework::Text id)> call)
{
	observerAddedCalls.add(call);
}