WeenieFactory.cpp

#include "StdAfx.h"
#include "WeenieFactory.h"
#include "Door.h"
#include "Lifestone.h"
#include "Portal.h"
#include "Monster.h"
#include "TownCrier.h"
#include "Vendor.h"
#include "World.h"
#include "ClothingCache.h"
#include "Player.h"
#include "HotSpot.h"
#include "PressurePlate.h"
#include "Switch.h"
#include "Book.h"
#include "Food.h"
#include "Caster.h"
#include "Clothing.h"
#include "Corpse.h"
#include "Healer.h"
#include "House.h"
#include "Scroll.h"
#include "MeleeWeapon.h"
#include "Missile.h"
#include "MissileLauncher.h"
#include "Config.h"
#include "Key.h"
#include "Lockpick.h"
#include "Gem.h"
#include "PKModifier.h"
#include "Ammunition.h"
#include "AttributeTransferDevice.h"
#include "SkillAlterationDevice.h"
#include "GameEventManager.h"

CWeenieFactory::CWeenieFactory()
{
}

CWeenieFactory::~CWeenieFactory()
{
	Reset();
}

void CWeenieFactory::Reset()
{
	for (auto entry : _weenieDefaults)
		delete entry.second;

	_weenieDefaults.clear();
	_weenieDefaultsByName.clear();
	_scrollWeenies.clear();
}

void CWeenieFactory::Initialize()
{
	LOG_PRIVATE(Data, Normal, "Loading weenies...\n");
	LoadLocalStorage();
	LoadLocalStorageIndexed();
	LoadAvatarData();

	MapScrollWCIDs();
	LOG_PRIVATE(Data, Normal, "Loaded %d weenie defaults...\n", _weenieDefaults.size());
}

DWORD CWeenieFactory::GetScrollSpellForWCID(DWORD wcid)
{
	if (CWeenieDefaults *defaults = GetWeenieDefaults(wcid))
	{
		if (defaults->m_Qualities.m_WeenieType == Scroll_WeenieType)
		{
			DWORD spell_id = 0;
			if (defaults->m_Qualities.InqDataID(SPELL_DID, spell_id))
			{
				return spell_id;
			}
		}
	}

	return 0;
}

DWORD CWeenieFactory::GetWCIDForScrollSpell(DWORD spell_id)
{
	auto i = _scrollWeenies.find(spell_id);
	if (i != _scrollWeenies.end())
		return i->second;

	return 0;
}

void CWeenieFactory::MapScrollWCIDs()
{
	_scrollWeenies.clear();
	for (auto &entry : _weenieDefaults)
	{
		if (entry.second->m_Qualities.m_WeenieType != Scroll_WeenieType)
		{
			continue;
		}

		DWORD spell_id;
		if (entry.second->m_Qualities.InqDataID(SPELL_DID, spell_id))
		{
			_scrollWeenies[spell_id] = entry.first;
		}
	}
}

std::list<DWORD> CWeenieFactory::GetWCIDsWithMotionTable(DWORD mtable)
{
	std::list<DWORD> results;

	for (auto &entry : _weenieDefaults)
	{
		DWORD mid = 0;
		if (entry.second->m_Qualities.InqDataID(MOTION_TABLE_DID, mid))
		{
			if (mtable == mid)
			{
				results.push_back(entry.first);
			}
		}
	}

	return results;
}

CWeenieDefaults *CWeenieFactory::GetWeenieDefaults(DWORD wcid)
{
	auto i = _weenieDefaults.find(wcid);
	if (i != _weenieDefaults.end())
		return i->second;

	return NULL;
}

DWORD CWeenieFactory::GetWCIDByName(const char *name, int index)
{
	CWeenieDefaults *defaults = GetWeenieDefaults(name, index);

	if (!defaults)
		return 0;

	return defaults->m_Qualities.GetID();
}

CWeenieDefaults *CWeenieFactory::GetWeenieDefaults(const char *name, int index)
{
	std::string search = name;
	
	// convert name for easier matching, lowercase and remove any spaces
	std::transform(search.begin(), search.end(), search.begin(), ::tolower);
	search.erase(remove_if(search.begin(), search.end(), isspace), search.end());
	
	std::pair<
		std::multimap<std::string, CWeenieDefaults *>::iterator,
		std::multimap<std::string, CWeenieDefaults *>::iterator> range = _weenieDefaultsByName.equal_range(search);

	for (std::multimap<std::string, CWeenieDefaults *>::iterator i = range.first; i != range.second; i++)
	{
		if (!index)
			return i->second;

		index--;
	}

	return NULL;
}

bool CWeenieFactory::ApplyWeenieDefaults(CWeenieObject *weenie, DWORD wcid)
{
	auto defaults = GetWeenieDefaults(wcid);

	if (defaults)
	{
		ApplyWeenieDefaults(weenie, defaults);
		return true;
	}
	else
	{
		LOG_PRIVATE(Data, Warning, "Failed to find defaults for WCID %u! This is bad!\n", wcid);
		return false;
	}
}

void CWeenieFactory::ApplyWeenieDefaults(CWeenieObject *weenie, CWeenieDefaults *defaults)
{
	weenie->m_Qualities.CopyFrom(&defaults->m_Qualities);

	int weaponSkill;
	if (weenie->m_Qualities.InqInt(WEAPON_SKILL_INT, weaponSkill, TRUE, FALSE))
		weenie->m_Qualities.SetInt(WEAPON_SKILL_INT, SkillTable::OldToNewSkill((STypeSkill) weaponSkill));

	int wieldReq;
	wieldReq = weenie->m_Qualities.GetInt(WIELD_REQUIREMENTS_INT, 0);
	if (wieldReq == 1 || wieldReq == 2 || wieldReq == 8)
	{
		if (weenie->m_Qualities.InqInt(WIELD_SKILLTYPE_INT, weaponSkill, TRUE, FALSE))
			weenie->m_Qualities.SetInt(WIELD_SKILLTYPE_INT, SkillTable::OldToNewSkill((STypeSkill)weaponSkill));
	}

	wieldReq = weenie->m_Qualities.GetInt(WIELD_REQUIREMENTS_2_INT, 0);
	if (wieldReq == 1 || wieldReq == 2 || wieldReq == 8)
	{
		if (weenie->m_Qualities.InqInt(WIELD_SKILLTYPE_2_INT, weaponSkill, TRUE, FALSE))
			weenie->m_Qualities.SetInt(WIELD_SKILLTYPE_2_INT, SkillTable::OldToNewSkill((STypeSkill)weaponSkill));
	}

	wieldReq = weenie->m_Qualities.GetInt(WIELD_REQUIREMENTS_3_INT, 0);
	if (wieldReq == 1 || wieldReq == 2 || wieldReq == 8)
	{
		if (weenie->m_Qualities.InqInt(WIELD_SKILLTYPE_3_INT, weaponSkill, TRUE, FALSE))
			weenie->m_Qualities.SetInt(WIELD_SKILLTYPE_3_INT, SkillTable::OldToNewSkill((STypeSkill)weaponSkill));
	}

	wieldReq = weenie->m_Qualities.GetInt(WIELD_REQUIREMENTS_4_INT, 0);
	if (wieldReq == 1 || wieldReq == 2 || wieldReq == 8)
	{
		if (weenie->m_Qualities.InqInt(WIELD_SKILLTYPE_4_INT, weaponSkill, TRUE, FALSE))
			weenie->m_Qualities.SetInt(WIELD_SKILLTYPE_4_INT, SkillTable::OldToNewSkill((STypeSkill)weaponSkill));
	}

	Skill uaSkill;
	if (weenie->m_Qualities.InqSkill(UNARMED_COMBAT_SKILL, uaSkill))
	{
		Skill finSkill;
		if (!weenie->m_Qualities.InqSkill(LIGHT_WEAPONS_SKILL, finSkill))
		{
			weenie->m_Qualities.SetSkill(LIGHT_WEAPONS_SKILL, uaSkill);
		}
	}

	weenie->m_Qualities.RemoveInt(PARENT_LOCATION_INT);

	if (weenie->m_Qualities._skillStatsTable)
	{
		for (auto &entry : *weenie->m_Qualities._skillStatsTable)
		{
			STypeSkill newSkill = SkillTable::OldToNewSkill((STypeSkill)entry.first);

			if (newSkill != entry.first)
			{
				weenie->m_Qualities.SetSkill(newSkill, entry.second);
			}
		}
	}

	std::string eventString;
	if (weenie->m_Qualities.InqString(GENERATOR_EVENT_STRING, eventString))
	{
		eventString = g_pGameEventManager->NormalizeEventName(eventString.c_str());
		weenie->m_Qualities.SetString(GENERATOR_EVENT_STRING, eventString);
	}

	weenie->m_ObjDescOverride = defaults->m_WorldObjDesc;
	weenie->m_WornObjDesc = defaults->m_WornObjDesc;
}

void CWeenieFactory::RefreshLocalStorage()
{
	LoadLocalStorage(true);
	MapScrollWCIDs();
}

void CWeenieFactory::LoadLocalStorage(bool refresh)
{
#if 0 // old
	std::list<std::string> filePaths;
	// EnumerateFolderFilePaths(filePaths, "data\\weenie\\defaults", "*.wqd", true);
	EnumerateFolderFilePaths(filePaths, "data\\weenie\\defaults\\custom", "*.wqd", true);

	if (atoi(g_pConfig->GetValue("weapons_testing", "0")) != 0)
	{
		EnumerateFolderFilePaths(filePaths, "data\\weenie\\defaults\\manual_content", "*.wqd", true);
	}

	for (auto filePath : filePaths)
	{
		BYTE *data = NULL;
		DWORD length = 0;
		if (LoadDataFromFile(filePath.c_str(), &data, &length))
		{
			BinaryReader reader(data, length);
			
			CWeenieDefaults *pDefaults = new CWeenieDefaults();
			if (pDefaults->UnPack(&reader))
			{
				bool bShouldInsert = true;
				bool bDuplicate = false;

				auto existing = m_WeenieDefaults.find(pDefaults->m_WCID);
				if (existing != m_WeenieDefaults.end())
				{
					if (refresh)
					{
					}
					else
					{
						if (existing->second->m_bIsAutoGenerated)
						{
							if (pDefaults->m_bIsAutoGenerated)
							{
								bDuplicate = true;
								bShouldInsert = false;
							}
						}
						else
						{
							// existing was not auto-generated
							bShouldInsert = false;

							if (!pDefaults->m_bIsAutoGenerated)
							{
								bDuplicate = true;
							}
						}
					}
				}

				if (bShouldInsert)
				{
					CWeenieDefaults *toDelete = NULL;

					auto existing = m_WeenieDefaults.find(pDefaults->m_WCID);
					if (existing != m_WeenieDefaults.end())
					{
						toDelete = existing->second;
					}

					pDefaults->m_sourceFile = filePath;
					m_WeenieDefaults[pDefaults->m_WCID] = pDefaults;

					std::string name;
					if (pDefaults->m_Qualities.InqString(NAME_STRING, name))
					{
						// convert name for easier matching, lowercase and remove any spaces
						std::transform(name.begin(), name.end(), name.begin(), ::tolower);
						name.erase(remove_if(name.begin(), name.end(), isspace), name.end());

						// remove if this WCID is already in here
						for (std::multimap<std::string, CWeenieDefaults *>::iterator i = m_WeenieDefaultsByName.begin(); i != m_WeenieDefaultsByName.end(); i++)
						{
							if (i->second->m_Qualities.GetID() == pDefaults->m_Qualities.GetID())
							{
								m_WeenieDefaultsByName.erase(i);
								break;
							}
						}

						m_WeenieDefaultsByName.insert(std::pair<std::string, CWeenieDefaults *>(name, pDefaults));
					}

					if (toDelete)
					{
						delete toDelete;
					}
				}
				else
				{
					if (bDuplicate)
					{
						LOG_PRIVATE(Data, Warning, "Duplicate WCID %d, ignoring WQD file: \"%s\" due to \"%s\"\n", pDefaults->m_WCID, filePath.c_str(), m_WeenieDefaults[pDefaults->m_WCID]->m_sourceFile.c_str());
					}

					delete pDefaults;
				}
			}
			else
			{
				LOG_PRIVATE(Data, Warning, "Error parsing WQD file: %s\n", filePath.c_str());
				delete pDefaults;
			}

			delete [] data;
		}
	}
#endif

	std::list<std::string> filePaths;
	EnumerateFolderFilePaths(filePaths, "data\\json\\weenies\\", "*.json", true);

	for (const auto &filePath : filePaths)
	{
		std::ifstream fileStream(filePath.c_str());

		if (fileStream.is_open())
		{
			json jsonData;
			fileStream >> jsonData;
			fileStream.close();

			CWeenieDefaults *pDefaults = new CWeenieDefaults();
			if (pDefaults->m_Qualities.UnPackJson(jsonData))
			{
				pDefaults->m_WCID = pDefaults->m_Qualities.id;
				pDefaults->m_sourceFile = filePath;

				bool bShouldInsert = true;
				bool bDuplicate = false;

				auto existing = _weenieDefaults.find(pDefaults->m_WCID);
				if (existing != _weenieDefaults.end())
				{
					if (refresh)
					{
					}
					else
					{
						if (existing->second->m_bIsAutoGenerated)
						{
							if (pDefaults->m_bIsAutoGenerated)
							{
								bDuplicate = true;
								bShouldInsert = false;
							}
						}
						else
						{
							// existing was not auto-generated
							bShouldInsert = false;

							if (!pDefaults->m_bIsAutoGenerated)
							{
								bDuplicate = true;
							}
						}
					}
				}

				if (bShouldInsert)
				{
					CWeenieDefaults *toDelete = NULL;

					auto existing = _weenieDefaults.find(pDefaults->m_WCID);
					if (existing != _weenieDefaults.end())
					{
						toDelete = existing->second;
					}

					pDefaults->m_sourceFile = filePath;
					_weenieDefaults[pDefaults->m_WCID] = pDefaults;

					std::string name;
					if (pDefaults->m_Qualities.InqString(NAME_STRING, name))
					{
						// convert name for easier matching, lowercase and remove any spaces
						std::transform(name.begin(), name.end(), name.begin(), ::tolower);
						name.erase(remove_if(name.begin(), name.end(), isspace), name.end());

						// remove if this WCID is already in here
						for (std::multimap<std::string, CWeenieDefaults *>::iterator i = _weenieDefaultsByName.begin(); i != _weenieDefaultsByName.end(); i++)
						{
							if (i->second->m_Qualities.GetID() == pDefaults->m_Qualities.GetID())
							{
								_weenieDefaultsByName.erase(i);
								break;
							}
						}

						_weenieDefaultsByName.insert(std::pair<std::string, CWeenieDefaults *>(name, pDefaults));
					}

					if (toDelete)
					{
						delete toDelete;
					}
				}
				else
				{
					if (bDuplicate)
					{
						LOG_PRIVATE(Data, Warning, "Duplicate WCID %d, ignoring WQF file: \"%s\" due to \"%s\"\n", pDefaults->m_WCID, filePath.c_str(), _weenieDefaults[pDefaults->m_WCID]->m_sourceFile.c_str());
					}

					delete pDefaults;
				}
			}
			else
			{
				delete pDefaults;
			}
		}
	}
}

void CWeenieFactory::LoadLocalStorageIndexed()
{
	BYTE *data = NULL;
	DWORD length = 0;
	if (LoadDataFromPhatDataBin(9, &data, &length, 0xd8fd6b02, 0xa0427974))
	{
		BinaryReader reader(data, length);

		WORD count = reader.Read<DWORD>();
		for (DWORD i = 0; i < count; i++)
		{
			DWORD the_wcid = reader.Read<DWORD>();

			CWeenieDefaults *pDefaults = new CWeenieDefaults();
			if (pDefaults->UnPack(&reader))
			{
				/*
				if (pDefaults->m_Qualities.m_IntStats)
				{
					for (auto &entry : *pDefaults->m_Qualities.m_IntStats)
					{
						if (entry.first == IMBUED_EFFECT_INT)
						{
							if (entry.second & ArmorRending_ImbuedEffectType)
							{
								DebugBreak();
							}
						}
					}
				}
				*/

				bool bShouldInsert = true;
				bool bDuplicate = false;

				auto existing = _weenieDefaults.find(pDefaults->m_WCID);
				if (existing != _weenieDefaults.end())
				{
					if (existing->second->m_bIsAutoGenerated)
					{
						if (pDefaults->m_bIsAutoGenerated)
						{
							bDuplicate = true;
							bShouldInsert = false;
						}
					}
					else
					{
						// existing was not auto-generated
						bShouldInsert = false;

						if (!pDefaults->m_bIsAutoGenerated)
						{
							bDuplicate = true;
						}
					}
				}

				if (bShouldInsert)
				{
					auto existing = _weenieDefaults.find(pDefaults->m_WCID);
					if (existing != _weenieDefaults.end())
						delete existing->second;

					//pDefaults->m_sourceFile = filePath;
					_weenieDefaults[pDefaults->m_WCID] = pDefaults;

					std::string name;
					if (pDefaults->m_Qualities.InqString(NAME_STRING, name))
					{
						// convert name for easier matching, lowercase and remove any spaces
						std::transform(name.begin(), name.end(), name.begin(), ::tolower);
						name.erase(remove_if(name.begin(), name.end(), isspace), name.end());

						// remove if this WCID is already in here
						/*
						for (std::multimap<std::string, CWeenieDefaults *>::iterator i = m_WeenieDefaultsByName.begin(); i != m_WeenieDefaultsByName.end(); i++)
						{
							if (i->second->m_Qualities.GetID() == pDefaults->m_Qualities.GetID())
							{
								m_WeenieDefaultsByName.erase(i);
								break;
							}
						}
						*/

						_weenieDefaultsByName.insert(std::pair<std::string, CWeenieDefaults *>(name, pDefaults));
					}
				}
				else
				{
					if (bDuplicate)
					{
						LOG(Data, Warning, "Duplicate WCID %d, ignoring due to \"%s\"\n", pDefaults->m_WCID, _weenieDefaults[pDefaults->m_WCID]->m_sourceFile.c_str());
					}

					delete pDefaults;
				}
			}
			else
			{
				LOG(Data, Warning, "Error parsing weenie defaults file\n");
				delete pDefaults;
			}
		}

		delete[] data;
	}	
}

void CWeenieFactory::LoadAvatarData()
{
	_numAvatars = 0;

	BYTE *data = NULL;
	DWORD length = 0;
	if (LoadDataFromPhatDataBin(7, &data, &length, 0x591c34e9, 0x2250b020))
	{
		BinaryReader reader(data, length);
		PackableHashTable<std::string, ObjDesc, std::string> avatarTable;
		avatarTable.UnPack(&reader);
		CWeenieDefaults *pRobeWithHood = GetWeenieDefaults(5851);
		
		DWORD autoWcid = _firstAvatarWCID = 7000000;

		if (pRobeWithHood)
		{
			for (auto &avatar : avatarTable)
			{
				autoWcid++;
				_numAvatars++;

				CWeenieDefaults *pDefaults = new CWeenieDefaults();
				pDefaults->m_Qualities.CopyFrom(&pRobeWithHood->m_Qualities);
				pDefaults->m_Qualities.SetString(NAME_STRING, csprintf("%s Jumpsuit", avatar.first.c_str()));
				pDefaults->m_Qualities.SetInt(CLOTHING_PRIORITY_INT, pDefaults->m_Qualities.GetInt(CLOTHING_PRIORITY_INT, 0) | HAND_WEAR_CLOTHING_PRIORITY);
				pDefaults->m_Qualities.SetInt(LOCATIONS_INT, pDefaults->m_Qualities.GetInt(LOCATIONS_INT, 0) | HAND_WEAR_LOC);
				pDefaults->m_Qualities.SetDataID(ICON_DID, 0x6001036);
				pDefaults->m_Qualities.SetBool(IGNORE_CLO_ICONS_BOOL, TRUE);
				pDefaults->m_WornObjDesc = avatar.second;
				pDefaults->m_WCID = autoWcid;
				pDefaults->m_Qualities.id = autoWcid;

				CWeenieDefaults *toDelete = NULL;

				auto existing = _weenieDefaults.find(pDefaults->m_WCID);
				if (existing != _weenieDefaults.end())
				{
					toDelete = existing->second;
				}

				_weenieDefaults[pDefaults->m_WCID] = pDefaults;

				std::string name;
				if (pDefaults->m_Qualities.InqString(NAME_STRING, name))
				{
					// convert name for easier matching, lowercase and remove any spaces
					std::transform(name.begin(), name.end(), name.begin(), ::tolower);
					name.erase(remove_if(name.begin(), name.end(), isspace), name.end());

					// remove if this WCID is already in here
					/*
					for (std::multimap<std::string, CWeenieDefaults *>::iterator i = m_WeenieDefaultsByName.begin(); i != m_WeenieDefaultsByName.end(); i++)
					{
						if (i->second->m_Qualities.GetID() == pDefaults->m_Qualities.GetID())
						{
							m_WeenieDefaultsByName.erase(i);
							break;
						}
					}
					*/

					_weenieDefaultsByName.insert(std::pair<std::string, CWeenieDefaults *>(name, pDefaults));
				}

				if (toDelete)
				{
					delete toDelete;
				}
			}
		}

		delete[] data;
	}
}

CWeenieObject *CWeenieFactory::CreateWeenieByClassID(DWORD wcid, const Position *pos, bool bSpawn)
{
	if (!wcid)
		return NULL;

	CWeenieDefaults *defaults = GetWeenieDefaults(wcid);
	if (!defaults)
		return NULL;

	return CreateWeenie(defaults, pos, bSpawn);
}

CWeenieObject *CWeenieFactory::CreateWeenieByName(const char *name, const Position *pos, bool bSpawn)
{
	CWeenieDefaults *defaults = GetWeenieDefaults(name);
	if (!defaults)
		return NULL;

	return CreateWeenie(defaults, pos, bSpawn);
}

CWeenieObject *CWeenieFactory::CreateBaseWeenieByType(int weenieType, unsigned int wcid, const char *weenieName)
{
	CWeenieObject *weenie;
	switch (weenieType)
	{
	case Generic_WeenieType:
	case Admin_WeenieType:
		{
			if (wcid == 1)
				weenie = new CPlayerWeenie(NULL, 0, 0);
			else
				weenie = new CWeenieObject();

			break;
		}

	case Cow_WeenieType:
	case Creature_WeenieType:
		{
			if (!strcmp(weenieName, "Town Crier"))
				weenie = new CTownCrier();
			else
				weenie = new CMonsterWeenie();
			break;
		}
	case AttributeTransferDevice_WeenieType:
		{
			weenie = new CAttributeTransferDeviceWeenie();
			break;
		}
	case SkillAlterationDevice_WeenieType:
		{
			weenie = new CSkillAlterationDeviceWeenie();
			break;
		}
	case Container_WeenieType:
		{
			weenie = new CContainerWeenie();
			break;
		}
	case Portal_WeenieType:
		{
			weenie = new CPortal();
			break;
		}
	case LifeStone_WeenieType:
		{
			weenie = new CBaseLifestone();
			break;
		}
	case Door_WeenieType:
		{
			weenie = new CBaseDoor();
			break;
		}
	case HotSpot_WeenieType:
		{
			weenie = new CHotSpotWeenie();
			break;
		}
	case Switch_WeenieType:
		{
			weenie = new CSwitchWeenie();
			break;
		}
	case PressurePlate_WeenieType:
		{
			weenie = new CPressurePlateWeenie();
			break;
		}
	case Vendor_WeenieType:
		{
			/*
			if (wcid == 719)
				weenie = new CAvatarVendor(); // holtburg avatar vendor
			else
			*/
			weenie = new CVendor();
			break;
		}

	case Clothing_WeenieType:
		{
			weenie = new CClothingWeenie();
			break;
		}
	case Caster_WeenieType:
		{
			weenie = new CCasterWeenie();
			break;
		}
	case Healer_WeenieType:
		{
			weenie = new CHealerWeenie();
			break;
		}
	case House_WeenieType:
		{
			weenie = new CHouseWeenie();
			break;
		}
	case SlumLord_WeenieType:
		{
			weenie = new CSlumLordWeenie();
			break;
		}
	case Scroll_WeenieType:
		{
			weenie = new CScrollWeenie();
			break;
		}

	case Ammunition_WeenieType:
		{
			weenie = new CAmmunitionWeenie();
			break;
		}

	case Missile_WeenieType:
		{
			weenie = new CMissileWeenie();
			break;
		}

	case ManaStone_WeenieType:
	case Coin_WeenieType:
		{
			weenie = new CWeenieObject();
			break;
		}
	case Book_WeenieType:
		{
			weenie = new CBookWeenie();
			break;
		}
	case Food_WeenieType:
		{
			weenie = new CFoodWeenie();
			break;
		}
	case PKModifier_WeenieType:
		{
			weenie = new CPKModifierWeenie();
			break;
		}
	case Gem_WeenieType:
		{
			weenie = new CGemWeenie();
			break;
		}
	case Key_WeenieType:
		{
			weenie = new CKeyWeenie();
			break;
		}
	case Lockpick_WeenieType:
		{
			weenie = new CLockpickWeenie();
			break;
		}
	case Corpse_WeenieType:
		{
			weenie = new CCorpseWeenie();
			break;
		}
	case MeleeWeapon_WeenieType:
		{
			weenie = new CMeleeWeaponWeenie();
			break;
		}
	case MissileLauncher_WeenieType:
		{
			weenie = new CMissileLauncherWeenie();
			break;
		}
	case Hook_WeenieType:
		{
			weenie = new CHookWeenie();
			break;
		}
	case Deed_WeenieType:
		{
			weenie = new CDeedWeenie();
			break;
		}
	case BootSpot_WeenieType:
		{
			weenie = new CBootSpotWeenie();
			break;
		}
	case HousePortal_WeenieType:
		{
			weenie = new CHousePortalWeenie();
			break;
		}
	case Chest_WeenieType:
		{
			weenie = new CChestWeenie();
			break;
		}
	case Storage_WeenieType:
		{
			weenie = new CStorageWeenie();
			break;
		}

	default:
		weenie = new CWeenieObject();
		break;
	}

	return weenie;
}

CWeenieObject *CWeenieFactory::CreateWeenie(CWeenieDefaults *defaults, const Position *pos, bool bSpawn)
{
	CWeenieObject *weenie = CreateBaseWeenieByType(
		(defaults->m_Qualities.GetInt(ITEM_TYPE_INT, 0) & TYPE_VESTEMENTS) ? Clothing_WeenieType : defaults->m_Qualities.m_WeenieType,
		defaults->m_Qualities.GetID(), defaults->m_Qualities.GetString(NAME_STRING, "").c_str());
	ApplyWeenieDefaults(weenie, defaults);
	weenie->ApplyQualityOverrides();

	if (!weenie->IsAvatarJumpsuit())
		TryToResolveAppearanceData(weenie);

	if (weenie->IsCreature())
		weenie->SetMaxVitals();

	if (pos)
		weenie->SetInitialPosition(*pos);

	if (bSpawn)
	{
		if (!g_pWorld->CreateEntity(weenie))
			return NULL;
	}

	return weenie;
}

CWeenieObject *CWeenieFactory::CloneWeenie(CWeenieObject *weenie)
{
	CWeenieObject *clone = CreateBaseWeenieByType(
		(weenie->m_Qualities.GetInt(ITEM_TYPE_INT, 0) & TYPE_VESTEMENTS) ? Clothing_WeenieType : weenie->m_Qualities.m_WeenieType,
		weenie->m_Qualities.GetID(), weenie->InqStringQuality(NAME_STRING, "").c_str());
	clone->m_Qualities.CopyFrom(&weenie->m_Qualities);
	clone->m_bObjDescOverride = weenie->m_bObjDescOverride;
	clone->m_ObjDescOverride = weenie->m_ObjDescOverride;
	clone->m_WornObjDesc = weenie->m_WornObjDesc;
	return clone;
}

bool CWeenieFactory::TryToResolveAppearanceData(CWeenieObject *weenie)
{
	// this function is temporary

	if (weenie->GetItemType() & (ITEM_TYPE::TYPE_ARMOR | ITEM_TYPE::TYPE_CLOTHING))
	{
		DWORD iconID = weenie->GetIcon();

		if (iconID)
		{
			DWORD paletteKey;
			ClothingTable *pCT = g_ClothingCache.GetTableByIndexOfIconID(iconID, 0, &paletteKey);

			if (pCT)
			{
				weenie->m_WornObjDesc.Clear();
				weenie->m_WornObjDesc.paletteID = 0x0400007E; // pObject->m_miBaseModel.dwBasePalette;

				double shade = 1.0;
				pCT->BuildObjDesc(0x02000001, paletteKey, &ShadePackage(shade)/* &ShadePackage(Random::GenFloat(0.0, 1.0))*/, &weenie->m_WornObjDesc);
				
				// use the original palettes specified?		
				weenie->m_WornObjDesc.ClearSubpalettes();
				Subpalette *pSPC = weenie->m_ObjDescOverride.firstSubpal;
				while (pSPC)
				{
					weenie->m_WornObjDesc.AddSubpalette(new Subpalette(*pSPC));
					pSPC = pSPC->next;
				}

				ClothingTable::Release(pCT);
				return true;
			}
		}
	}

	return false;
}