Пример #1
0
void cPlayer::FinishEating(void)
{
	// Reset the timer:
	m_EatingFinishTick = -1;
	
	// Send the packets:
	m_ClientHandle->SendEntityStatus(*this, esPlayerEatingAccepted);
	m_World->BroadcastEntityAnimation(*this, 0);
	m_World->BroadcastEntityMetadata(*this);

	// consume the item:
	cItem Item(GetEquippedItem());
	Item.m_ItemCount = 1;
	cItemHandler * ItemHandler = cItemHandler::GetItemHandler(Item.m_ItemType);
	if (!ItemHandler->EatItem(this, &Item))
	{
		return;
	}
	ItemHandler->OnFoodEaten(m_World, this, &Item);

	GetInventory().RemoveOneEquippedItem();

	//if the food is mushroom soup, return a bowl to the inventory
	if( Item.m_ItemType == E_ITEM_MUSHROOM_SOUP ) {
		cItem emptyBowl(E_ITEM_BOWL, 1, 0, "");
		GetInventory().AddItem(emptyBowl, true, true);
	}
}
Пример #2
0
void AMech_RPGCharacter::Reset()
{
	if (GetCurrentWeapon() != nullptr) {
		GetCurrentWeapon()->Destroy();
		SetCurrentWeapon(nullptr);
	}

	abilities.Empty();
	armour.Empty();

	if (GetInventory() != nullptr) {
		GetInventory()->GetItems().Empty();
	}

	inventory = NewObject<UInventory>(UInventory::StaticClass());

	SetHealth(GetMaxHealth());

	channeling = false;
	inCombat = false;

	canAttack = 0;
	canMove = 0;
	canBeDamaged = 0;
}
Пример #3
0
void cPlayer::TossItem(
    bool a_bDraggingItem,
    char a_Amount /* = 1 */,
    short a_CreateType /* = 0 */,
    short a_CreateHealth /* = 0 */
)
{
    cItems Drops;
    if (a_CreateType != 0)
    {
        // Just create item without touching the inventory (used in creative mode)
        Drops.push_back(cItem(a_CreateType, a_Amount, a_CreateHealth));
    }
    else
    {
        // Drop an item from the inventory:
        if (a_bDraggingItem)
        {
            cItem & Item = GetDraggingItem();
            if (!Item.IsEmpty())
            {
                char OriginalItemAmount = Item.m_ItemCount;
                Item.m_ItemCount = std::min(OriginalItemAmount, a_Amount);
                Drops.push_back(Item);
                if (OriginalItemAmount > a_Amount)
                {
                    Item.m_ItemCount = OriginalItemAmount - (char)a_Amount;
                }
                else
                {
                    Item.Empty();
                }
            }
        }
        else
        {
            // Else drop equipped item
            cItem DroppedItem(GetInventory().GetEquippedItem());
            if (!DroppedItem.IsEmpty())
            {
                if (GetInventory().RemoveOneEquippedItem())
                {
                    DroppedItem.m_ItemCount = 1; // RemoveItem decreases the count, so set it to 1 again
                    Drops.push_back(DroppedItem);
                }
            }
        }
    }
    double vX = 0, vY = 0, vZ = 0;
    EulerToVector(-GetRotation(), GetPitch(), vZ, vX, vY);
    vY = -vY * 2 + 1.f;
    m_World->SpawnItemPickups(Drops, GetPosX(), GetPosY() + 1.6f, GetPosZ(), vX * 3, vY * 3, vZ * 3, true); // 'true' because created by player
}
Пример #4
0
void cPlayer::UseEquippedItem(int a_Amount)
{
	if (IsGameModeCreative() || IsGameModeSpectator())  // No damage in creative or spectator
	{
		return;
	}

	// If the item has an unbreaking enchantment, give it a random chance of not breaking:
	cItem Item = GetEquippedItem();
	int UnbreakingLevel = Item.m_Enchantments.GetLevel(cEnchantments::enchUnbreaking);
	if (UnbreakingLevel > 0)
	{
		int chance;
		if (ItemCategory::IsArmor(Item.m_ItemType))
		{
			chance = 60 + (40 / (UnbreakingLevel + 1));
		}
		else
		{
			chance = 100 / (UnbreakingLevel + 1);
		}

		cFastRandom Random;
		if (Random.NextInt(101) <= chance)
		{
			return;
		}
	}

	if (GetInventory().DamageEquippedItem(a_Amount))
	{
		m_World->BroadcastSoundEffect("random.break", GetPosX(), GetPosY(), GetPosZ(), 0.5f, (float)(0.75 + ((float)((GetUniqueID() * 23) % 32)) / 64));
	}
}
Пример #5
0
PacketData CGameServerPlayer::GetInventoryInfo()
{
	auto playerActor = m_instance.GetActor<CPlayerActor>(PLAYER_ID);
	const auto& inventory = playerActor->GetInventory();

	PacketData outgoingPacket;

	unsigned int itemCount = inventory.size();		//Item count can be less than 200, but we have to make sure no equipped items are using item indices over the itemCount
	assert(itemCount <= 200);
	while(itemCount != 0)
	{
		CCompositePacket compositePacket;
		{
			unsigned int itemsToCopy = std::min<unsigned int>(itemCount, 32);
			unsigned int itemBase = itemCount - itemsToCopy;
			CSetInventoryPacket setInventoryPacket;
			setInventoryPacket.SetSourceId(PLAYER_ID);
			setInventoryPacket.SetTargetId(PLAYER_ID);
			setInventoryPacket.SetItemCount(itemsToCopy);
			for(unsigned int i = 0; i < itemsToCopy; i++)
			{
				const auto& inventoryItem = inventory[i + itemBase];
				setInventoryPacket.SetItemIndex(i, i + itemBase + 1);
				setInventoryPacket.SetItemId(i, inventoryItem.itemId);
				setInventoryPacket.SetItemDefinitionId(i, inventoryItem.itemDefId);
			}
			compositePacket.AddPacket(setInventoryPacket.ToPacketData());
			itemCount -= itemsToCopy;
		}
		auto compositePacketData = compositePacket.ToPacketData();
		outgoingPacket.insert(std::end(outgoingPacket), std::begin(compositePacketData), std::end(compositePacketData));
	}

	return outgoingPacket;
}
Пример #6
0
void PlayerBehaviour::Drop()
{
	GetInventory();
	size_t count = pcinventory->GetEntityCount();
	if(count <= 0)
	{
		printf("Inventory is empty!\n");
		return;
	}
	iCelEntity* child = pcinventory->GetEntity(0);
	pcinventory->RemoveEntity(child);
	csRef<iPcLinearMovement> pclinmove = CEL_QUERY_PROPCLASS_ENT(
		child, iPcLinearMovement);
	if(pclinmove)
	{
		GetMesh ();
		csVector3 pos = pcmesh->GetMesh()->GetMovable()->GetTransform()
			.This2Other(csVector3 (0, 2, -2));
		iSector* sector = pcmesh->GetMesh()->GetMovable()->GetSectors()->Get(0);
		pclinmove->SetPosition(pos, 0, sector);
		pclinmove->SetVelocity(csVector3 (0, .1f, 0));
		csRef<iPcMesh> pcmesh_child = CEL_QUERY_PROPCLASS_ENT(child, iPcMesh);
		if(pcmesh_child) pcmesh_child->Show();
	}
}
Пример #7
0
//------------------------------------------------------------------------
int CScriptBind_Inventory::Destroy(IFunctionHandler *pH)
{
	CInventory *pInventory = GetInventory(pH);
	CRY_ASSERT(pInventory);

	pInventory->Destroy();
	return pH->EndFunction();
}
Пример #8
0
void cPlayer::UseEquippedItem(void)
{
    if (IsGameModeCreative()) // No damage in creative
    {
        return;
    }

    GetInventory().DamageEquippedItem();
}
Пример #9
0
//------------------------------------------------------------------------
int CScriptBind_Inventory::GetAmmoCount(IFunctionHandler *pH, const char *ammoName)
{
	CInventory *pInventory = GetInventory(pH);
	CRY_ASSERT(pInventory);

	IEntityClass* pClass = gEnv->pEntitySystem->GetClassRegistry()->FindClass(ammoName);
	CRY_ASSERT(pClass);
	return pH->EndFunction(pInventory->GetAmmoCount(pClass));
}
Пример #10
0
void CCar::OnEvent(NET_Packet& P, u16 type)
{
	inherited::OnEvent		(P,type);
	CExplosive::OnEvent		(P,type);

	//обработка сообщений, нужных для работы с багажником машины
	u16 id;
	switch (type)
	{
	case GE_OWNERSHIP_TAKE:
		{
			P.r_u16		(id);
			CObject* O	= Level().Objects.net_Find	(id);
			if( GetInventory()->CanTakeItem(smart_cast<CInventoryItem*>(O)) ) 
			{
				O->H_SetParent(this);
				GetInventory()->Take(smart_cast<CGameObject*>(O), false, false);
			}
			else 
			{
				if (!O || !O->H_Parent() || (this != O->H_Parent())) return;
				NET_Packet P;
				u_EventGen(P,GE_OWNERSHIP_REJECT,ID());
				P.w_u16(u16(O->ID()));
				u_EventSend(P);
			}
		}break;
	case GE_OWNERSHIP_REJECT:
		{
			P.r_u16		(id);
			CObject* O	= Level().Objects.net_Find	(id);

			bool just_before_destroy		= !P.r_eof() && P.r_u8();
			O->SetTmpPreDestroy				(just_before_destroy);
			GetInventory()->DropItem(smart_cast<CGameObject*>(O), just_before_destroy, just_before_destroy);
			//if(GetInventory()->DropItem(smart_cast<CGameObject*>(O), just_before_destroy)) 
			//{
			//	O->H_SetParent(0, just_before_destroy);
			//}
			//moved to DropItem
		}break;
	}

}
Пример #11
0
//------------------------------------------------------------------------
int CScriptBind_Inventory::GetCurrentItemId(IFunctionHandler *pH)
{
	CInventory *pInventory = GetInventory(pH);
	CRY_ASSERT(pInventory);

	EntityId currentItemId = pInventory->GetCurrentItem();
	if (currentItemId)
		return pH->EndFunction(ScriptHandle(currentItemId));
	return pH->EndFunction();
}
Пример #12
0
bool PlayerBehaviour::SendMessage (csStringID msg_id, iCelPropertyClass* pc,
	celData& ret, iCelParameterBlock* params, va_list arg)
{
	GetActorMove ();

	if(msg_id == id_pccommandinput_forward1)
		pcactormove->Forward(true);
	else if(msg_id == id_pccommandinput_forward0)
		pcactormove->Forward(false);
	else if(msg_id == id_pccommandinput_backward1)
		pcactormove->Backward(true);
	else if(msg_id == id_pccommandinput_backward0)
		pcactormove->Backward(false);
	else if(msg_id == id_pccommandinput_rotateleft1)
		pcactormove->RotateLeft(true);
	else if(msg_id == id_pccommandinput_rotateleft0)
    pcactormove->RotateLeft(false);
	else if(msg_id == id_pccommandinput_rotateright1)
		pcactormove->RotateRight(true);
	else if(msg_id == id_pccommandinput_rotateright0)
		pcactormove->RotateRight(false);
	else if(msg_id == id_pccommandinput_cammode1)
		pcactormove->ToggleCameraMode ();
	else if(msg_id == id_pccommandinput_drop1)
		Drop();
	else if(msg_id == id_pcinventory_addchild)
	{
		GetInventory();
		printf("Got a new object! Objects in inventory:\n");
		ShowInventory();
	}
	else if(msg_id == id_pcinventory_removechild)
	{
		GetInventory();
		printf("Object removed from inventory! Objects in inventory:\n");
		ShowInventory();
	}
	else
		return CommonBehaviour::SendMessage(msg_id, pc, ret, params, arg);

	return true;
}
Пример #13
0
void cPlayer::TossEquippedItem(char a_Amount)
{
	cItems Drops;
	cItem DroppedItem(GetInventory().GetEquippedItem());
	if (!DroppedItem.IsEmpty())
	{
		char NewAmount = a_Amount;
		if (NewAmount > GetInventory().GetEquippedItem().m_ItemCount)
		{
			NewAmount = GetInventory().GetEquippedItem().m_ItemCount; // Drop only what's there
		}

		GetInventory().GetHotbarGrid().ChangeSlotCount(GetInventory().GetEquippedSlotNum() /* Returns hotbar subslot, which HotbarGrid takes */, -a_Amount);

		DroppedItem.m_ItemCount = NewAmount;
		Drops.push_back(DroppedItem);
	}

	TossItems(Drops);
}
Пример #14
0
//-------------------------------------------------------------------
int CScriptBind_Inventory::HasAccessory(IFunctionHandler *pH, const char *accessoryName)
{
	CInventory *pInventory = GetInventory(pH);
	CRY_ASSERT(pInventory);

	IEntityClass* pClass = gEnv->pEntitySystem->GetClassRegistry()->FindClass(accessoryName);
	if(pClass)
		return pH->EndFunction(pInventory->HasAccessory(pClass));

	return pH->EndFunction();
}
Пример #15
0
bool cInstruments::CreateInstrument( const std::string& name )
{
    std::string cname;
    SaHpiUint32T num;
    bool rc = DisassembleNumberedObjectName( name, cname, num );
    if ( !rc ) {
        return false;
    }

    if ( cname == cControl::classname ) {
        if ( !GetControl( num ) ) {
            m_controls[num] = new cControl( m_handler, m_resource, num );
            return true;
        }
    }
    if ( cname == cSensor::classname ) {
        if ( !GetSensor( num ) ) {
            m_sensors[num] = new cSensor( m_handler, m_resource, num );
            return true;
        }
    }
    if ( cname == cInventory::classname ) {
        if ( !GetInventory( num ) ) {
            m_invs[num] = new cInventory( m_handler, m_resource, num );
            return true;
        }
    }
    if ( cname == cWatchdog::classname ) {
        if ( !GetWatchdog( num ) ) {
            m_wdts[num] = new cWatchdog( m_handler, m_resource, num );
            return true;
        }
    }
    if ( cname == cAnnunciator::classname ) {
        if ( !GetAnnunciator( num ) ) {
            m_anns[num] = new cAnnunciator( m_handler, m_resource, num );
            return true;
        }
    }
    if ( cname == cDimi::classname ) {
        if ( !GetDimi( num ) ) {
            m_dimis[num] = new cDimi( m_handler, m_resource, num );
            return true;
        }
    }
    if ( cname == cFumi::classname ) {
        if ( !GetFumi( num ) ) {
            m_fumis[num] = new cFumi( m_handler, m_resource, num );
            return true;
        }
    }

    return false;
}
Пример #16
0
//----------------------------------------------------------------------
int CScriptBind_Inventory::GetGrenadeWeaponByClass(IFunctionHandler *pH, const char *className)
{
	CInventory *pInventory = GetInventory(pH);
	CRY_ASSERT(pInventory);

	IEntityClass* pClass = gEnv->pEntitySystem->GetClassRegistry()->FindClass(className);
	EntityId itemId = pInventory->GetItemByClass(pClass,NULL);
	if (itemId)
		return pH->EndFunction(ScriptHandle(itemId));

	return pH->EndFunction();
}
Пример #17
0
//------------------------------------------------------------------------
int CScriptBind_Inventory::Dump(IFunctionHandler *pH)
{

#if DEBUG_INVENTORY_ENABLED
	CInventory *pInventory = GetInventory(pH);
	CRY_ASSERT(pInventory);

	pInventory->Dump();
#endif

	return pH->EndFunction();
}
Пример #18
0
void cPlayer::UseEquippedItem(void)
{
	if (IsGameModeCreative()) // No damage in creative
	{
		return;
	}

	if (GetInventory().DamageEquippedItem())
	{
		m_World->BroadcastSoundEffect("random.break", (int)GetPosX() * 8, (int)GetPosY() * 8, (int)GetPosZ() * 8, 0.5f, (float)(0.75 + ((float)((GetUniqueID() * 23) % 32)) / 64));
	}
}
Пример #19
0
//------------------------------------------------------------------------
int CScriptBind_Inventory::GetCurrentItem(IFunctionHandler *pH)
{
	CInventory *pInventory = GetInventory(pH);
	CRY_ASSERT(pInventory);

	EntityId currentItemId = pInventory->GetCurrentItem();
	if (currentItemId)
	{
		IEntity *pEntity = m_pEntitySystem->GetEntity(currentItemId);
		if (pEntity)
			return pH->EndFunction(pEntity->GetScriptTable());
	}
	return pH->EndFunction();
}
Пример #20
0
void cPlayer::TossEquippedItem(char a_Amount)
{
	cItems Drops;
	cItem DroppedItem(GetInventory().GetEquippedItem());
	if (!DroppedItem.IsEmpty())
	{
		char NewAmount = a_Amount;
		if (NewAmount > GetInventory().GetEquippedItem().m_ItemCount)
		{
			NewAmount = GetInventory().GetEquippedItem().m_ItemCount; // Drop only what's there
		}

		GetInventory().GetHotbarGrid().ChangeSlotCount(GetInventory().GetEquippedSlotNum() /* Returns hotbar subslot, which HotbarGrid takes */, -a_Amount);

		DroppedItem.m_ItemCount = NewAmount;
		Drops.push_back(DroppedItem);
	}

	double vX = 0, vY = 0, vZ = 0;
	EulerToVector(-GetYaw(), GetPitch(), vZ, vX, vY);
	vY = -vY * 2 + 1.f;
	m_World->SpawnItemPickups(Drops, GetPosX(), GetEyeHeight(), GetPosZ(), vX * 3, vY * 3, vZ * 3, true); // 'true' because created by player
}
Пример #21
0
AItem* AMech_RPGCharacter::AddItem(AItem* itemToAdd)
{
	AItem* item = GetInventory()->AddItem(itemToAdd);
	itemToAdd->SetItemOwner(this);

	if (GetGroup() != nullptr) {
		GetGroup()->ItemPickup(itemToAdd);
	}

	if (OnItemPickUpEvent.IsBound()) {
		OnItemPickUpEvent.Broadcast(itemToAdd);
	}
	return item;
}
Пример #22
0
BOOL CDbManager::GetUserInventoryBank( CMover* pMover, CQuery* pQueryChar )
{
	pMover->m_idPlayer	= pQueryChar->GetInt( "m_idPlayer" );
	pMover->m_nSlot		= pQueryChar->GetInt( "playerslot" );
	
	// GetItem
	LPDB_OVERLAPPED_PLUS lpDbOverlappedPlus	= NULL;
	//GetInventory( pMover, pQueryChar, lpDbOverlappedPlus );
	//GetBankMover( pMover, pQueryChar, 0 );
	// mirchang_100416 VERIFYSTRING use return value
	if( GetInventory( pMover, pQueryChar, lpDbOverlappedPlus ) == FALSE || GetBankMover( pMover, pQueryChar, 0 ) == FALSE )
	{
		return FALSE;
	}
	return TRUE;
	// mirchang_100416
}
Пример #23
0
void AMech_RPGCharacter::SetCurrentWeapon(AWeapon* newVal) {
	if (newVal != nullptr && currentWeapon != newVal) {
		if (!GetInventory()->GetItems().Contains(newVal)) {
			AddItem(newVal);
		}

		if (GetCurrentWeapon() != nullptr) {
			GetCurrentWeapon()->Unequip();
		}

		if (OnSwappedWeapons.IsBound()) {
			OnSwappedWeapons.Broadcast(currentWeapon, newVal);
		}

		newVal->Equip();
	}

	currentWeapon = newVal;
}
Пример #24
0
//------------------------------------------------------------------------
int CScriptBind_Inventory::SetAmmoCount(IFunctionHandler *pH, const char *ammoName, int count)
{
	CInventory *pInventory = GetInventory(pH);
	CRY_ASSERT(pInventory);

	IEntityClass* pClass = gEnv->pEntitySystem->GetClassRegistry()->FindClass(ammoName);
	CRY_ASSERT(pClass);
	if (pClass)
	{
		pInventory->SetAmmoCount(pClass, count);
		if (gEnv->bServer)
		{
			pInventory->GetActor()->GetGameObject()->InvokeRMI(CInventory::Cl_SetAmmoCount(), 
				TRMIInventory_Ammo(ammoName, count), 
				eRMI_ToRemoteClients);
		}
	}
	else
	{
		CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_ERROR, "Ammo class %s not found!", ammoName);
	}

	return pH->EndFunction();
}
Пример #25
0
// the current stuff is at the bottom of this function
void WorldDatabase::GetCharSelectInfo(uint32 accountID, EQApplicationPacket **outApp, uint32 clientVersionBit)
{
	/* Set Character Creation Limit */
	ClientVersion client_version = ClientVersionFromBit(clientVersionBit);
	size_t character_limit = EQLimits::CharacterCreationLimit(client_version);
	
	// Validate against absolute server max
	if (character_limit > EmuConstants::CHARACTER_CREATION_LIMIT)
		character_limit = EmuConstants::CHARACTER_CREATION_LIMIT;

	// Force Titanium clients to use '8'
	if (client_version == ClientVersion::Titanium)
		character_limit = 8;
	
	/* Get Character Info */
	std::string cquery = StringFormat(
		"SELECT                     "
		"`id`,                      "  // 0
		"name,                      "  // 1
		"gender,                    "  // 2
		"race,                      "  // 3
		"class,                     "  // 4
		"`level`,                   "  // 5
		"deity,                     "  // 6
		"last_login,                "  // 7
		"time_played,               "  // 8
		"hair_color,                "  // 9
		"beard_color,               "  // 10
		"eye_color_1,               "  // 11
		"eye_color_2,               "  // 12
		"hair_style,                "  // 13
		"beard,                     "  // 14
		"face,                      "  // 15
		"drakkin_heritage,          "  // 16
		"drakkin_tattoo,            "  // 17
		"drakkin_details,           "  // 18
		"zone_id		            "  // 19
		"FROM                       "
		"character_data             "
		"WHERE `account_id` = %i ORDER BY `name` LIMIT %u", accountID, character_limit);
	auto results = database.QueryDatabase(cquery);

	size_t character_count = results.RowCount();
	if (character_count == 0) {
		*outApp = new EQApplicationPacket(OP_SendCharInfo, sizeof(CharacterSelect_Struct));
		CharacterSelect_Struct *cs = (CharacterSelect_Struct *)(*outApp)->pBuffer;
		cs->CharCount = 0;
		cs->TotalChars = character_limit;
		return;
	}

	size_t packet_size = sizeof(CharacterSelect_Struct) + (sizeof(CharacterSelectEntry_Struct) * character_count);
	*outApp = new EQApplicationPacket(OP_SendCharInfo, packet_size);

	unsigned char *buff_ptr = (*outApp)->pBuffer;
	CharacterSelect_Struct *cs = (CharacterSelect_Struct *)buff_ptr;

	cs->CharCount = character_count;
	cs->TotalChars = character_limit;

	buff_ptr += sizeof(CharacterSelect_Struct);
	for (auto row = results.begin(); row != results.end(); ++row) {
		CharacterSelectEntry_Struct *cse = (CharacterSelectEntry_Struct *)buff_ptr;
		PlayerProfile_Struct pp;
		Inventory inv;
		uint32 character_id = (uint32)atoi(row[0]);
		uint8 has_home = 0;
		uint8 has_bind = 0;

		memset(&pp, 0, sizeof(PlayerProfile_Struct));
		
		/* Fill CharacterSelectEntry_Struct */
		memset(cse->Name, 0, sizeof(cse->Name));
		strcpy(cse->Name, row[1]);
		cse->Class = (uint8)atoi(row[4]);
		cse->Race = (uint32)atoi(row[3]);
		cse->Level = (uint8)atoi(row[5]);
		cse->ShroudClass = cse->Class;
		cse->ShroudRace = cse->Race;
		cse->Zone = (uint16)atoi(row[19]);
		cse->Instance = 0;
		cse->Gender = (uint8)atoi(row[2]);
		cse->Face = (uint8)atoi(row[15]);

		for (uint32 matslot = 0; matslot < _MaterialCount; matslot++) {	// Processed below
			cse->Equip[matslot].Material = 0;
			cse->Equip[matslot].Unknown1 = 0;
			cse->Equip[matslot].EliteMaterial = 0;
			cse->Equip[matslot].HeroForgeModel = 0;
			cse->Equip[matslot].Material2 = 0;
			cse->Equip[matslot].Color.Color = 0;
		}						

		cse->Unknown15 = 0xFF;
		cse->Unknown19 = 0xFF;
		cse->DrakkinTattoo = (uint32)atoi(row[17]);
		cse->DrakkinDetails = (uint32)atoi(row[18]);
		cse->Deity = (uint32)atoi(row[6]);
		cse->PrimaryIDFile = 0;							// Processed Below
		cse->SecondaryIDFile = 0;						// Processed Below
		cse->HairColor = (uint8)atoi(row[9]);
		cse->BeardColor = (uint8)atoi(row[10]);
		cse->EyeColor1 = (uint8)atoi(row[11]);
		cse->EyeColor2 = (uint8)atoi(row[12]);
		cse->HairStyle = (uint8)atoi(row[13]);
		cse->Beard = (uint8)atoi(row[14]);
		cse->GoHome = 0;								// Processed Below
		cse->Tutorial = 0;								// Processed Below
		cse->DrakkinHeritage = (uint32)atoi(row[16]);
		cse->Unknown1 = 0;
		cse->Enabled = 1;
		cse->LastLogin = (uint32)atoi(row[7]);			// RoF2 value: 1212696584
		cse->Unknown2 = 0;
		/* Fill End */

		if (RuleB(World, EnableReturnHomeButton)) {
			int now = time(nullptr);
			if ((now - atoi(row[7])) >= RuleI(World, MinOfflineTimeToReturnHome))
				cse->GoHome = 1;
		}

		if (RuleB(World, EnableTutorialButton) && (cse->Level <= RuleI(World, MaxLevelForTutorial))) {
			cse->Tutorial = 1;
		}

		/* Set Bind Point Data for any character that may possibly be missing it for any reason */
		cquery = StringFormat("SELECT `zone_id`, `instance_id`, `x`, `y`, `z`, `heading`, `slot` FROM `character_bind`  WHERE `id` = %i LIMIT 5", character_id);
		auto results_bind = database.QueryDatabase(cquery);
		for (auto row_b = results_bind.begin(); row_b != results_bind.end(); ++row_b) {
			if (row_b[6] && atoi(row_b[6]) == 4){ has_home = 1; }
			if (row_b[6] && atoi(row_b[6]) == 0){ has_bind = 1; }
		}

		if (has_home == 0 || has_bind == 0) {
			cquery = StringFormat("SELECT `zone_id`, `bind_id`, `x`, `y`, `z` FROM `start_zones` WHERE `player_class` = %i AND `player_deity` = %i AND `player_race` = %i",
				cse->Class, cse->Deity, cse->Race);
			auto results_bind = database.QueryDatabase(cquery);
			for (auto row_d = results_bind.begin(); row_d != results_bind.end(); ++row_d) {
				/* If a bind_id is specified, make them start there */
				if (atoi(row_d[1]) != 0) {
					pp.binds[4].zoneId = (uint32)atoi(row_d[1]);
					GetSafePoints(pp.binds[4].zoneId, 0, &pp.binds[4].x, &pp.binds[4].y, &pp.binds[4].z);
				}
				/* Otherwise, use the zone and coordinates given */
				else {
					pp.binds[4].zoneId = (uint32)atoi(row_d[0]);
					float x = atof(row_d[2]);
					float y = atof(row_d[3]);
					float z = atof(row_d[4]);
					if (x == 0 && y == 0 && z == 0){ GetSafePoints(pp.binds[4].zoneId, 0, &x, &y, &z); }
					pp.binds[4].x = x; pp.binds[4].y = y; pp.binds[4].z = z;
				}
			}
			pp.binds[0] = pp.binds[4];
			/* If no home bind set, set it */
			if (has_home == 0) {
				std::string query = StringFormat("REPLACE INTO `character_bind` (id, zone_id, instance_id, x, y, z, heading, slot)"
					" VALUES (%u, %u, %u, %f, %f, %f, %f, %i)",
					character_id, pp.binds[4].zoneId, 0, pp.binds[4].x, pp.binds[4].y, pp.binds[4].z, pp.binds[4].heading, 4);
				auto results_bset = QueryDatabase(query);
			}
			/* If no regular bind set, set it */
			if (has_bind == 0) {
				std::string query = StringFormat("REPLACE INTO `character_bind` (id, zone_id, instance_id, x, y, z, heading, slot)"
					" VALUES (%u, %u, %u, %f, %f, %f, %f, %i)",
					character_id, pp.binds[0].zoneId, 0, pp.binds[0].x, pp.binds[0].y, pp.binds[0].z, pp.binds[0].heading, 0);
				auto results_bset = QueryDatabase(query);
			}
		}
		/* Bind End */

		/* Load Character Material Data for Char Select */
		cquery = StringFormat("SELECT slot, red, green, blue, use_tint, color FROM `character_material` WHERE `id` = %u", character_id);
		auto results_b = database.QueryDatabase(cquery); uint8 slot = 0;
		for (auto row_b = results_b.begin(); row_b != results_b.end(); ++row_b) {
			slot = atoi(row_b[0]);
			pp.item_tint[slot].RGB.Red = atoi(row_b[1]);
			pp.item_tint[slot].RGB.Green = atoi(row_b[2]);
			pp.item_tint[slot].RGB.Blue = atoi(row_b[3]);
			pp.item_tint[slot].RGB.UseTint = atoi(row_b[4]);
		}
		/* Character Material Data End */

		/* Load Inventory */
		// If we ensure that the material data is updated appropriately, we can do away with inventory loads
		if (GetInventory(accountID, cse->Name, &inv)) {
			const Item_Struct* item = nullptr;
			const ItemInst* inst = nullptr;
			int16 invslot = 0;

			for (uint32 matslot = 0; matslot < _MaterialCount; matslot++) {
				invslot = Inventory::CalcSlotFromMaterial(matslot);
				if (invslot == INVALID_INDEX) { continue; }
				inst = inv.GetItem(invslot);
				if (inst == nullptr) { continue; }
				item = inst->GetItem();
				if (item == nullptr) { continue; }

				if (matslot > 6) {
					uint32 idfile = 0;
					// Weapon Models 
					if (inst->GetOrnamentationIDFile() != 0) {
						idfile = inst->GetOrnamentationIDFile();
						cse->Equip[matslot].Material = idfile;
					}
					else {
						if (strlen(item->IDFile) > 2) {
							idfile = atoi(&item->IDFile[2]);
							cse->Equip[matslot].Material = idfile;
						}
					}
					if (matslot == MaterialPrimary) {
						cse->PrimaryIDFile = idfile;
					}
					else {
						cse->SecondaryIDFile = idfile;
					}
				}
				else {
					uint32 color = 0;
					if (pp.item_tint[matslot].RGB.UseTint) {
						color = pp.item_tint[matslot].Color;
					}
					else {
						color = inst->GetColor();
					}

					// Armor Materials/Models
					cse->Equip[matslot].Material = item->Material;
					cse->Equip[matslot].EliteMaterial = item->EliteMaterial;
					cse->Equip[matslot].HeroForgeModel = inst->GetOrnamentHeroModel(matslot);
					cse->Equip[matslot].Color.Color = color;
				}
			}
		}
		else {
			printf("Error loading inventory for %s\n", cse->Name);
		}
		/* Load Inventory End */

		buff_ptr += sizeof(CharacterSelectEntry_Struct);
	}
}
Пример #26
0
int CTFInventory::GetWeaponPreset(IBaseFileSystem *pFileSystem, int iClass, int iSlot)
{
	return GetLocalPreset(GetInventory(pFileSystem), iClass, iSlot);
};
Пример #27
0
WBEntity* WBCompEldHands::GetFists() const
{
	STATIC_HASHED_STRING( Fists );
	return GetInventory()->GetItem( sFists );
}
Пример #28
0
// solar: the current stuff is at the bottom of this function
void WorldDatabase::GetCharSelectInfo(uint32 account_id, CharacterSelect_Struct* cs) {
	char errbuf[MYSQL_ERRMSG_SIZE];
	char* query = 0;
	MYSQL_RES *result;
	MYSQL_ROW row;
	Inventory *inv;

	for (int i=0; i<10; i++) {
		strcpy(cs->name[i], "<none>");
		cs->zone[i] = 0;
		cs->level[i] = 0;
			cs->tutorial[i] = 0;
		cs->gohome[i] = 0;
	}

	int char_num = 0;
	unsigned long* lengths;

	// Populate character info
	if (RunQuery(query, MakeAnyLenString(&query, "SELECT name,profile,zonename,class,level FROM character_ WHERE account_id=%i order by name limit 10", account_id), errbuf, &result)) {
		safe_delete_array(query);
		while ((row = mysql_fetch_row(result))) {
			lengths = mysql_fetch_lengths(result);
			////////////
			////////////	This is the current one, the other are for converting
			////////////
			if ((lengths[1] == sizeof(PlayerProfile_Struct))) {
				strcpy(cs->name[char_num], row[0]);
				PlayerProfile_Struct* pp = (PlayerProfile_Struct*)row[1];
				uint8 clas = atoi(row[3]);
				uint8 lvl = atoi(row[4]);

				// Character information
				if(lvl == 0)
					cs->level[char_num]		= pp->level;	//no level in DB, trust PP
				else
					cs->level[char_num]		= lvl;
				if(clas == 0)
					cs->class_[char_num]	= pp->class_;	//no class in DB, trust PP
				else
					cs->class_[char_num]	= clas;
				cs->race[char_num]			= pp->race;
				cs->gender[char_num]		= pp->gender;
				cs->deity[char_num]			= pp->deity;
				cs->zone[char_num]			= GetZoneID(row[2]);
				cs->face[char_num]			= pp->face;
				cs->haircolor[char_num]		= pp->haircolor;
				cs->beardcolor[char_num]	= pp->beardcolor;
				cs->eyecolor2[char_num]		= pp->eyecolor2;
				cs->eyecolor1[char_num]		= pp->eyecolor1;
				cs->hairstyle[char_num]		= pp->hairstyle;
				cs->beard[char_num]			= pp->beard;
				cs->drakkin_heritage[char_num]	= pp->drakkin_heritage;
				cs->drakkin_tattoo[char_num]	= pp->drakkin_tattoo;
				cs->drakkin_details[char_num]	= pp->drakkin_details;

				if(RuleB(World, EnableTutorialButton) && (lvl <= RuleI(World, MaxLevelForTutorial)))
					cs->tutorial[char_num] = 1;

				if(RuleB(World, EnableReturnHomeButton)) {
					int now = time(nullptr);
					if((now - pp->lastlogin) >= RuleI(World, MinOfflineTimeToReturnHome))
						cs->gohome[char_num] = 1;
				}


				// This part creates home city entries for characters created before the home bind point was tracked.
				// Do it here because the player profile is already loaded and it's as good a spot as any. This whole block should
				// probably be removed at some point, when most accounts are safely converted.
				if(pp->binds[4].zoneId == 0) {
					bool altered = false;
					MYSQL_RES *result2;
					MYSQL_ROW row2;
					char startzone[50] = {0};

					// check for start zone variable (I didn't even know any variables were still being used...)
					if(database.GetVariable("startzone", startzone, 50)) {
						uint32 zoneid = database.GetZoneID(startzone);
						if(zoneid) {
							pp->binds[4].zoneId = zoneid;
							GetSafePoints(zoneid, 0, &pp->binds[4].x, &pp->binds[4].y, &pp->binds[4].z);
							altered = true;
						}
					}
					else {
						RunQuery(query,
							MakeAnyLenString(&query,
							"SELECT zone_id,bind_id,x,y,z FROM start_zones "
							"WHERE player_class=%i AND player_deity=%i AND player_race=%i",
							pp->class_,
							pp->deity,
							pp->race
							),
							errbuf,
							&result2
						);
						safe_delete_array(query);

						// if there is only one possible start city, set it
						if(mysql_num_rows(result2) == 1) {
							row2 = mysql_fetch_row(result2);
							if(atoi(row2[1]) != 0) {		// if a bind_id is specified, make them start there
								pp->binds[4].zoneId = (uint32)atoi(row2[1]);
								GetSafePoints(pp->binds[4].zoneId, 0, &pp->binds[4].x, &pp->binds[4].y, &pp->binds[4].z);
							}
							else {	// otherwise, use the zone and coordinates given
								pp->binds[4].zoneId = (uint32)atoi(row2[0]);
								float x = atof(row2[2]);
								float y = atof(row2[3]);
								float z = atof(row2[4]);
								if(x == 0 && y == 0 && z == 0)
									GetSafePoints(pp->binds[4].zoneId, 0, &x, &y, &z);

								pp->binds[4].x = x;
								pp->binds[4].y = y;
								pp->binds[4].z = z;
							}
							altered = true;
						}

						mysql_free_result(result2);
					}

					// update the player profile
					if(altered) {
						uint32 char_id = GetCharacterID(cs->name[char_num]);
						RunQuery(query,MakeAnyLenString(&query,"SELECT extprofile FROM character_ WHERE id=%i",char_id), errbuf, &result2);
						safe_delete_array(query);
						if(result2) {
							row2 = mysql_fetch_row(result2);
							ExtendedProfile_Struct* ext = (ExtendedProfile_Struct*)row2[0];
							SetPlayerProfile(account_id,char_id,pp,inv,ext, 0, 0, 5);
						}
						mysql_free_result(result2);
					}
				}	// end of "set start zone" block


				// Character's equipped items
				// @merth: Haven't done bracer01/bracer02 yet.
				// Also: this needs a second look after items are a little more solid
				// NOTE: items don't have a color, players MAY have a tint, if the
				// use_tint part is set. otherwise use the regular color
				inv = new Inventory;
				if(GetInventory(account_id, cs->name[char_num], inv))
				{
					for (uint8 material = 0; material <= 8; material++)
					{
						uint32 color;
						ItemInst *item = inv->GetItem(Inventory::CalcSlotFromMaterial(material));
						if(item == 0)
							continue;

						cs->equip[char_num][material] = item->GetItem()->Material;

						if(pp->item_tint[material].rgb.use_tint)	// they have a tint (LoY dye)
							color = pp->item_tint[material].color;
						else	// no tint, use regular item color
							color = item->GetItem()->Color;

						cs->cs_colors[char_num][material].color = color;

						// the weapons are kept elsewhere
						if ((material==MaterialPrimary) || (material==MaterialSecondary))
						{
							if(strlen(item->GetItem()->IDFile) > 2) {
								uint32 idfile=atoi(&item->GetItem()->IDFile[2]);
								if (material==MaterialPrimary)
									cs->primary[char_num]=idfile;
								else
									cs->secondary[char_num]=idfile;
							}
						}
					}
				}
				else
				{
					printf("Error loading inventory for %s\n", cs->name[char_num]);
				}
				safe_delete(inv);
				if (++char_num > 10)
					break;
			}
			else
			{
				std::cout << "Got a bogus character (" << row[0] << ") Ignoring!!!" << std::endl;
				std::cout << "PP length ="<<lengths[1]<<" but PP should be "<<sizeof(PlayerProfile_Struct) << std::endl;
				//DeleteCharacter(row[0]);
			}
		}
		mysql_free_result(result);
	}
	else
	{
		std::cerr << "Error in GetCharSelectInfo query '" << query << "' " << errbuf << std::endl;
		safe_delete_array(query);
		return;
	}

	return;
}
Пример #29
0
bool cInstruments::RemoveInstrument( const std::string& name )
{
    std::string classname;
    SaHpiUint32T num;
    bool rc = DisassembleNumberedObjectName( name, classname, num );
    if ( !rc ) {
        return false;
    }

    if ( classname == cControl::classname ) {
        cControl * ctrl = GetControl( num );
        if ( ctrl ) {
            m_controls.erase( num );
            delete ctrl;
            return true;
        }
    }
    if ( classname == cSensor::classname ) {
        cSensor * sen = GetSensor( num );
        if ( sen ) {
            m_sensors.erase( num );
            delete sen;
            return true;
        }
    }
    if ( classname == cInventory::classname ) {
        cInventory * inv = GetInventory( num );
        if ( inv ) {
            m_invs.erase( num );
            delete inv;
            return true;
        }
    }
    if ( classname == cWatchdog::classname ) {
        cWatchdog * wdt = GetWatchdog( num );
        if ( wdt ) {
            m_wdts.erase( num );
            delete wdt;
            return true;
        }
    }
    if ( classname == cAnnunciator::classname ) {
        cAnnunciator * ann = GetAnnunciator( num );
        if ( ann ) {
            m_anns.erase( num );
            delete ann;
            return true;
        }
    }
    if ( classname == cDimi::classname ) {
        cDimi * dimi = GetDimi( num );
        if ( dimi ) {
            m_dimis.erase( num );
            delete dimi;
            return true;
        }
    }
    if ( classname == cFumi::classname ) {
        cFumi * fumi = GetFumi( num );
        if ( fumi ) {
            m_fumis.erase( num );
            delete fumi;
            return true;
        }
    }

    return false;
}
Пример #30
0
WBEntity* WBCompEldHands::GetPower() const
{
	STATIC_HASHED_STRING( Power );
	return GetInventory()->GetItem( sPower );
}