自学教程：C++ GetGameObject函数代码示例

WorldObject* ObjectAccessor::GetWorldObject(WorldObject const& p, uint64 guid){    switch (GUID_HIPART(guid))    {        case HIGHGUID_PLAYER:        return GetPlayer(p, guid);        case HIGHGUID_TRANSPORT:        case HIGHGUID_MO_TRANSPORT:        case HIGHGUID_GAMEOBJECT:    return GetGameObject(p, guid);        case HIGHGUID_VEHICLE:        case HIGHGUID_UNIT:          return GetCreature(p, guid);        case HIGHGUID_PET:           return GetPet(p, guid);        case HIGHGUID_DYNAMICOBJECT: return GetDynamicObject(p, guid);        case HIGHGUID_CORPSE:        return GetCorpse(p, guid);        default:                     return NULL;    }}

WorldObject* ObjectAccessor::GetWorldObject(WorldObject const& p, ObjectGuid const& guid){    switch (guid.GetHigh())    {        case HighGuid::Player:        return GetPlayer(p, guid);        case HighGuid::Transport:        case HighGuid::GameObject:    return GetGameObject(p, guid);        case HighGuid::Vehicle:        case HighGuid::Creature:          return GetCreature(p, guid);        case HighGuid::Pet:           return GetPet(p, guid);        case HighGuid::DynamicObject: return GetDynamicObject(p, guid);        case HighGuid::AreaTrigger:   return GetAreaTrigger(p, guid);        case HighGuid::Corpse:        return GetCorpse(p, guid);        default:                     return NULL;    }}

//------------------------------------------------------------------------void CItem::InitClient(int channelId){	const int numAccessories = m_accessories.size();		// send the differences between the current, and the initial setup	for (int i = 0; i < numAccessories; i++)	{		uint16 classId = 0;		bool result = g_pGame->GetIGameFramework()->GetNetworkSafeClassId(classId, m_accessories[i].pClass->GetName());#if !defined(_RELEASE)		if(!result)		{			char errorMsg[256];			sprintf(errorMsg, "CItem::InitClient failed to find network safe class id for %s", m_accessories[i].pClass->GetName());			CRY_ASSERT_MESSAGE(result, errorMsg);		}#endif		if(result)			GetGameObject()->InvokeRMI(ClAttachInitialAccessory(), AccessoryParams(classId), eRMI_ToClientChannel, channelId);	}	IActor *pOwner=GetOwnerActor();	if (!pOwner)		return;	// only send the pickup message if the player is connecting	// for items spawned during gameplay, CItem::PickUp is already sending the pickup message	INetChannel *pNetChannel=m_pGameFramework->GetNetChannel(channelId);	if (pNetChannel && pNetChannel->GetContextViewState()<eCVS_InGame)	{		if (!m_stats.mounted && !m_stats.used)		{			pOwner->GetGameObject()->InvokeRMIWithDependentObject(CActor::ClPickUp(), 				CActor::PickItemParams(GetEntityId(), m_stats.selected, false), eRMI_ToClientChannel, GetEntityId(), channelId);			//GetOwnerActor()->GetGameObject()->InvokeRMI(CActor::ClPickUp(), 			//	CActor::PickItemParams(GetEntityId(), m_stats.selected, false), eRMI_ToClientChannel, channelId);		}	}	if (m_stats.mounted && m_stats.used)	{		pOwner->GetGameObject()->InvokeRMIWithDependentObject(CActor::ClStartUse(), 			CActor::ItemIdParam(GetEntityId()), eRMI_ToClientChannel, GetEntityId(), channelId);	}}

void CHeavyMountedWeapon::TryRipOffGun(){	CActor *pActor = GetOwnerActor();	if(!pActor)		return;	PerformRipOff(pActor);		if(gEnv->bServer)	{		CHANGED_NETWORK_STATE(this, ASPECT_RIPOFF);	}	else	{		GetGameObject()->InvokeRMI(SvRequestRipOff(), EmptyParams(), eRMI_ToServer);	}}

ObjectData* Event::GetGameObject(const std::string& aName, ObjectData* aParent) const{    for (unsigned int i = 0; i < aParent->myChilds.Size(); ++i)    {        if (aParent->myChilds[i]->myName == aName)        {            return aParent->myChilds[i];        }        ObjectData* data = GetGameObject(aName, aParent->myChilds[i]);        if (data != nullptr)        {            return data;        }    }    return nullptr;}

void CGunTurret::FullSerialize(TSerialize ser){	CWeapon::FullSerialize(ser);	ser.BeginGroup("GunTurret");	ser.Value("target", m_targetId);	ser.EndGroup();	if(ser.IsReading())	{		if(!IsDestroyed())		{			if(IGameObject *pGameObject = GetGameObject())				PostInit(pGameObject);		}	}}

//-----------------------------------------------------------------------void CWeapon::RequestCancelReload(){    CActor *pActor=GetOwnerActor();    if (!gEnv->bServer && pActor && pActor->IsClient())    {        if(m_fm)        {            m_fm->CancelReload();        }        GetGameObject()->InvokeRMI(SvRequestCancelReload(), DefaultParams(), eRMI_ToServer);    }    else if (IsServer())    {        SvCancelReload();    }}

	GameObject* Transform::Find(RegistrationId nameHash)	{		GameObject* gameObject = GetGameObject();		if( gameObject->GetNameHash() == nameHash )			return gameObject;		for(Transform* child = firstChild; child != 0; child = child->nextSibling)		{			GameObject* childObject = child->GetGameObject();			RegistrationId childNameHash = childObject->GetNameHash();			if( childNameHash == nameHash )				return childObject;		}		return 0;			}

void CAccessory::Physicalize( bool enable, bool rigid ){    const bool isMounted = (GetParentId() != 0);    int profile = eIPhys_NotPhysicalized;    if (enable && !isMounted)        {            profile = rigid ? eIPhys_PhysicalizedRigid : eIPhys_PhysicalizedStatic;        }    if (IsServer())        {            GetGameObject()->SetAspectProfile(eEA_Physics, profile);        }    m_deferPhysicalization = eIPhys_Max;}

const EDMath::Aabb& ShapeRenderer::GetAabb(void){	const EDMath::Float4x4& worldMat = GetGameObject()->GetTransform()->GetWorldMatrix();	if(renderShapePtr != 0)	{		EDMath::Aabb aabb = renderShapePtr->GetRenderMesh()->GetAabb();		EDMath::TransformAabb(worldAabb, aabb, worldMat);	}	else	{		worldAabb.center = worldMat.WAxis;		worldAabb.extents.x = worldAabb.extents.y = worldAabb.extents.z = 0.001f;	}	return worldAabb;}

void Target::Update(void){	if( spinTimer > 0.0f )	{		float deltaTime = EDGameCore::Game::GetDeltaTime();		spinTimer -= deltaTime;		GetTransform()->RotateLocalY( 3.14159f * deltaTime );	}	else	{		LookAt* lookAtBehavior = GetGameObject()->GetBehavior<LookAt>();		if( lookAtBehavior != 0 )			lookAtBehavior->enable();	}}

void BattlefieldWG::ProcessEvent(WorldObject* obj, uint32 eventId){    if (!obj || !IsWarTime())        return;    // We handle only gameobjects here    GameObject* go = obj->ToGameObject();    if (!go)        return;    // On click on titan relic    if (go->GetEntry() == GO_WINTERGRASP_TITAN_S_RELIC)    {        if (CanInteractWithRelic())            EndBattle(false);        else if (GameObject* relic = GetRelic())            relic->SetRespawnTime(RESPAWN_IMMEDIATELY);    }    // if destroy or damage event, search the wall/tower and update worldstate/send warning message    for (GameObjectBuilding::const_iterator itr = BuildingsInZone.begin(); itr != BuildingsInZone.end(); ++itr)    {        if (GameObject* build = GetGameObject((*itr)->m_BuildGUID))        {            if (go->GetEntry() == build->GetEntry())            {                if (build->GetGOInfo()->building.damagedEvent == eventId)                    (*itr)->Damaged();                if (build->GetGOInfo()->building.destroyedEvent == eventId)                    (*itr)->Destroyed();                // Add Support of Quests Toppling the Towers & Southern Sabotage                if (go->GetEntry()==190356 || go->GetEntry()==190357 || go->GetEntry()==190358)                {                    for (GuidSet::const_iterator itr = m_PlayersInWar[GetDefenderTeam()].begin(); itr != m_PlayersInWar[GetDefenderTeam()].end(); ++itr)                        if (Player* player = sObjectAccessor->FindPlayer(*itr))                            player->RewardPlayerAndGroupAtEvent(35074, go);                }                break;            }        }    }}

void CLivingEntitySample::Reset( const bool enteringGameMode ){	ResetCharacterModel();	ResetAnimationState();	Physicalize();	IGameObject* pGameObject = GetGameObject();	if ( enteringGameMode )	{		pGameObject->EnablePostUpdates( this );		pGameObject->EnablePrePhysicsUpdate( ePPU_Always );	}	else	{		pGameObject->DisablePostUpdates( this );		pGameObject->EnablePrePhysicsUpdate( ePPU_Never );	}}

//------------------------------------------------------------------------void CGameRules::ClientHit(const HitInfo &hitInfo){	FUNCTION_PROFILER(GetISystem(), PROFILE_GAME);	IActor *pClientActor = g_pGame->GetIGameFramework()->GetClientActor();	IEntity *pTarget = m_pEntitySystem->GetEntity(hitInfo.targetId);	IEntity *pShooter =	m_pEntitySystem->GetEntity(hitInfo.shooterId);	IVehicle *pVehicle = g_pGame->GetIGameFramework()->GetIVehicleSystem()->GetVehicle(hitInfo.targetId);	IActor *pActor = g_pGame->GetIGameFramework()->GetIActorSystem()->GetActor(hitInfo.targetId);	bool dead = pActor?(pActor->GetHealth()<=0):false;	if((pClientActor && pClientActor->GetEntity()==pShooter) && pTarget && (pVehicle || pActor) && !dead)	{		SAFE_HUD_FUNC(GetCrosshair()->CrosshairHit());		SAFE_HUD_FUNC(GetTagNames()->AddEnemyTagName(pActor?pActor->GetEntityId():pVehicle->GetEntityId()));	}	if(pActor == pClientActor)		if (gEnv->pInput) gEnv->pInput->ForceFeedbackEvent( SFFOutputEvent(eDI_XI, eFF_Rumble_Basic, 0.5f * hitInfo.damage * 0.01f, hitInfo.damage * 0.02f, 0.0f));/*	if (gEnv->pAISystem && !gEnv->bMultiplayer)	{		static int htMelee = GetHitTypeId("melee");		if (pShooter && hitInfo.type != htMelee)		{			ISurfaceType *pSurfaceType = GetHitMaterial(hitInfo.material);			const ISurfaceType::SSurfaceTypeAIParams* pParams = pSurfaceType ? pSurfaceType->GetAIParams() : 0;			const float radius = pParams ? pParams->fImpactRadius : 5.0f;			gEnv->pAISystem->BulletHitEvent(hitInfo.pos, radius, pShooter->GetAI());		}	}*/	CreateScriptHitInfo(m_scriptHitInfo, hitInfo);	CallScript(m_clientStateScript, "OnHit", m_scriptHitInfo);	bool backface = hitInfo.dir.Dot(hitInfo.normal)>0;	if (!hitInfo.remote && hitInfo.targetId && !backface)	{		if (!gEnv->bServer)			GetGameObject()->InvokeRMI(SvRequestHit(), hitInfo, eRMI_ToServer);		else			ServerHit(hitInfo);	}}

void MeshRenderer::Update(GameTime* gameTime,GraphicsDevice* graphicsDevice){	int drawCalls = 0;	int triangles = 0;	if(_mesh != NULL)	{		VertexBuffer* vertexBuffer = _mesh->GetVertexBuffer();		IndexBuffer* indexBuffer = _mesh->GetIndexBuffer();				//Set the per object uniforms of the game object(for example - the world matrix)		_material->SetObjectUniforms(graphicsDevice, GetGameObject());		vertexBuffer->BindBuffer();		//Draw the mesh		unsigned int numberOfAttributeInformations = vertexBuffer->GetNumberOfAttributeInfos();		for(unsigned int i = 0; i < numberOfAttributeInformations; i++)		{			const VertexAttributeInformation& thisInfo = vertexBuffer->GetVertexAttributeInformation(i);			graphicsDevice->EnableVertexAttribute(thisInfo.GetIndex());			graphicsDevice->SetVertexAttribute(thisInfo.GetIndex(), 							  thisInfo.GetSize(), 							  thisInfo.GetType(),							  thisInfo.GetIsNormalized(), 							  thisInfo.GetStride(), 							  thisInfo.GetOffset());		}		//Bind the index buffer		indexBuffer->BindBuffer();		//DRAW		graphicsDevice->DrawElements(GraphicsPrimitiveType::Triangles(), indexBuffer->GetNumberOfElements(), indexBuffer->GetIndexDataType(), (void*)0);		drawCalls++;		triangles += indexBuffer->GetNumberOfElements() / 3;		for(unsigned int i = 0; i < numberOfAttributeInformations; i++)		{			graphicsDevice->DisableVertexAttribute(vertexBuffer->GetVertexAttributeInformation(i).GetIndex());		}		indexBuffer->UnbindBuffer();		vertexBuffer->UnbindBuffer();	}	SetNumberOfDrawCalls(drawCalls);	SetNumberOfTriangles(triangles);}

bool CBattleEvent::Init(IGameObject *pGameObject){	SetGameObject(pGameObject);	if(!GetGameObject()->BindToNetwork())		return false;	if(GetEntity())		m_entityId = GetEntity()->GetId();	if(gEnv->bServer && g_pGame->GetGameRules())	{		CBattleDust* pBD = g_pGame->GetGameRules()->GetBattleDust();		if(pBD)			pBD->NewBattleArea(this);	}	return true;}

	void Camera::Render() const	{		auto context = GraphicsDevice::GetInstance()->GetDeviceContext();		auto render_buffer= GraphicsDevice::GetInstance()->GetRenderTargetView();		auto depth_buffer = GraphicsDevice::GetInstance()->GetDepthStencilView();		SetViewport();		//set target		context->OMSetRenderTargets(1, &render_buffer, depth_buffer);		//clear		context->ClearRenderTargetView(render_buffer, (const float *) &m_clear_color);		context->ClearDepthStencilView(depth_buffer, D3D11_CLEAR_DEPTH | D3D11_CLEAR_STENCIL, 1.0f, 0);				//render		m_current = GetGameObject()->GetComponent<Camera>();		Renderer::RenderAll();	}

void Blast::Update(void){	const float LIFE_SPAN = 0.375f;	static float GREEN = 1.0f;		if( GREEN > 0.5f )		GREEN = 0.5f;	else		GREEN = 1.0f;	EDGameCore::ICollider* iCollider = GetCollider();	if( iCollider == 0 )		return;	if( iCollider->GetColliderType() != EDGameCore::SPHERE )		return;	EDGameCore::SphereCollider* sphereCollider = (EDGameCore::SphereCollider*)iCollider;	EDMath::Sphere sphere = sphereCollider->GetSphere();	float deltaTime = EDGameCore::Game::GetDeltaTime();	age += deltaTime;	if( age >= LIFE_SPAN )	{		EDGameCore::Game::destroy( GetGameObject() );		return;	}	float ratio = age / LIFE_SPAN;	float ALPHA = 1.0f - ratio*ratio;		sphere.radius *= 1.0f + 10.0f * deltaTime;	sphereCollider->SetSphere( sphere );	XMFLOAT4 color( 1.0f, GREEN, 0.0f, ALPHA );	EDRendererD3D::DebugRenderer::GetInstance()->DrawSphere( sphereCollider->GetWorldSphere(), color );}

void ComponentRootMotion::OnUpdate(float dt){    float metric_proportion = App->hints->GetFloatValue(ModuleHints::METRIC_PROPORTION);    GameObject* go   = GetGameObject();    float angle_diff = atan2(dir.x, dir.z)- atan2(local_dir[dir_axis].x, local_dir[dir_axis].z);    while(angle_diff < -PI) angle_diff += PI*2.0f;    while(angle_diff > PI) angle_diff -= PI*2.0f;    float max_angle  = MAX_ANGULAR_SPEED*dt;    float angle      = angle_diff > 0.0f ? min(max_angle, angle_diff) : max(-max_angle, angle_diff);    go->SetLocalRotation((Quat(float3::unitY, angle)*go->GetLocalRotationQ()).Normalized());    float4x4 transform = go->GetGlobalTransformation();    float3 global_dir  = transform.TransformDir(local_dir[dir_axis]);    go->SetLocalPosition(go->GetLocalPosition()+global_dir*(min(MAX_LINEAR_SPEED*metric_proportion, speed)*dt));}

bool AnimStateComponent::Update(float fDelta){	if( !m_pkAnimStateAttrib )	{		m_pkAnimStateAttrib     = GetGameObjectAttribute(GetGameObject(),AnimStateAttributeBase);	}	assert(m_pkAnimStateAttrib);	IAnimState  *pkAnimState = m_pkAnimStateAttrib->GetAnimState();	if( pkAnimState!=m_pkCurrState )		SetAnimState(pkAnimState);	if (m_pkCurrState)	{		m_pkCurrState->Update(m_pkAnimComponent);	}	return true;}

//------------------------------------------------------------------------void CGunTurret::UpdateEntityProperties(){	bool enabled = m_turretparams.enabled;	GetEntityProperty("GunTurret","bEnabled",m_turretparams.enabled);	if(enabled!=m_turretparams.enabled)	{		Activate(m_turretparams.enabled);		GetGameObject()->ChangedNetworkState(ASPECT_STATEBITS);	}	GetEntityProperty("GunTurret", "bSearching", m_turretparams.searching);	GetEntityProperty("GunTurret", "bSurveillance", m_turretparams.surveillance);	const char *teamName=0;	GetEntityProperty("teamName", teamName);	if(teamName && teamName[0])		m_turretparams.team = g_pGame->GetGameRules()->GetTeamId(teamName);}

//------------------------------------------------------------------------void CProjectile::InitWithAI(){	// register with ai if needed	//FIXME	//make AI ignore grenades thrown by AI; needs proper/readable grenade reaction	if (m_pAmmoParams->aiType!=AIOBJECT_NONE)	{		bool	isFriendlyGrenade(true);		IEntity *pOwnerEntity = gEnv->pEntitySystem->GetEntity(m_ownerId);		if (pOwnerEntity && pOwnerEntity->GetAI())			isFriendlyGrenade = (pOwnerEntity->GetAI()->GetAIType() == AIOBJECT_ACTOR);		if (!isFriendlyGrenade)		{			GetEntity()->RegisterInAISystem(AIObjectParams(m_pAmmoParams->aiType));		}	}	GetGameObject()->SetAIActivation(eGOAIAM_Always);}

Object* ObjectAccessor::GetObjectByTypeMask(WorldObject const& p, uint64 guid, uint32 typemask){    switch (GUID_HIPART(guid))    {    case HIGHGUID_ITEM:        if (typemask & TYPEMASK_ITEM && p.GetTypeId() == TYPEID_PLAYER)            return ((Player const&)p).GetItemByGuid(guid);        break;    case HIGHGUID_PLAYER:        if (typemask & TYPEMASK_PLAYER)            return GetPlayer(p, guid);        break;    case HIGHGUID_TRANSPORT:    case HIGHGUID_MO_TRANSPORT:    case HIGHGUID_GAMEOBJECT:        if (typemask & TYPEMASK_GAMEOBJECT)            return GetGameObject(p, guid);        break;    case HIGHGUID_UNIT:    case HIGHGUID_VEHICLE:        if (typemask & TYPEMASK_UNIT)            return GetCreature(p, guid);        break;    case HIGHGUID_PET:        if (typemask & TYPEMASK_UNIT)            return GetPet(p, guid);        break;    case HIGHGUID_DYNAMICOBJECT:        if (typemask & TYPEMASK_DYNAMICOBJECT)            return GetDynamicObject(p, guid);        break;    case HIGHGUID_AREATRIGGER:        if (typemask & TYPEMASK_AREATRIGGER)            return GetAreaTrigger(p, guid);        break;    case HIGHGUID_CORPSE:        break;    }    return NULL;}

Object* ObjectAccessor::GetObjectByTypeMask(WorldObject const& p, ObjectGuid const& guid, uint32 typemask){    switch (guid.GetHigh())    {        case HighGuid::Item:            if (typemask & TYPEMASK_ITEM && p.GetTypeId() == TYPEID_PLAYER)                return ((Player const&)p).GetItemByGuid(guid);            break;        case HighGuid::Player:            if (typemask & TYPEMASK_PLAYER)                return GetPlayer(p, guid);            break;        case HighGuid::Transport:        case HighGuid::GameObject:            if (typemask & TYPEMASK_GAMEOBJECT)                return GetGameObject(p, guid);            break;        case HighGuid::Creature:        case HighGuid::Vehicle:            if (typemask & TYPEMASK_UNIT)                return GetCreature(p, guid);            break;        case HighGuid::Pet:            if (typemask & TYPEMASK_UNIT)                return GetPet(p, guid);            break;        case HighGuid::DynamicObject:            if (typemask & TYPEMASK_DYNAMICOBJECT)                return GetDynamicObject(p, guid);            break;        case HighGuid::AreaTrigger:            if (typemask & TYPEMASK_AREATRIGGER)                return GetAreaTrigger(p, guid);        case HighGuid::Corpse:            break;        default:            break;    }    return nullptr;}

bool CMonoEntityExtension::Init(IGameObject *pGameObject){	SetGameObject(pGameObject);	pGameObject->EnablePhysicsEvent( true, eEPE_OnPostStepImmediate );	if (!GetGameObject()->BindToNetwork())		return false;	IEntity *pEntity = GetEntity();	IEntityClass *pEntityClass = pEntity->GetClass();	m_pScript = g_pScriptSystem->InstantiateScript(pEntityClass->GetName(), eScriptFlag_Entity);	IMonoClass *pEntityInfoClass = g_pScriptSystem->GetCryBraryAssembly()->GetClass("EntityInitializationParams", "CryEngine.Native");	SMonoEntityInfo entityInfo(pEntity);	IMonoArray *pArgs = CreateMonoArray(1);	pArgs->InsertMonoObject(pEntityInfoClass->BoxObject(&entityInfo));	g_pScriptSystem->InitializeScriptInstance(m_pScript, pArgs);	pArgs->Release();	int numProperties;	auto pProperties = static_cast<CEntityPropertyHandler *>(pEntityClass->GetPropertyHandler())->GetQueuedProperties(pEntity->GetId(), numProperties);	if(pProperties)	{		for(int i = 0; i < numProperties; i++)		{			auto queuedProperty = pProperties[i];			SetPropertyValue(queuedProperty.propertyInfo, queuedProperty.value.c_str());		}	}	m_bInitialized = true;	return true;}

YmxExplodeParticleSystem::YmxExplodeParticleSystem(LPYMXCOMPONENT pComponent, LPYMXTEXTURE pTexture, int maxCount)	:YmxParticleSystem(pComponent, pTexture, maxCount){	m_Type = PAR_TYPE_EXPLODE;	// init all null pointers	m_ParVertexs = NULL;	m_ParAttributes = NULL;	m_ParGroups = NULL;	m_Center.x = (m_BoundingBox.right - m_BoundingBox.left) * 0.5f;	m_Center.y = (m_BoundingBox.bottom - m_BoundingBox.top) * 0.5f;	m_Velocity = 10.0f;	m_VelocityVariant = 1.0f;	m_ParLife = 10.0f;	m_ParLifeVariant = 0.0f;	m_StartSize = 3.0f;	m_EndSize = 4.0f;	m_Delta = GetGameObject()->GetUpdateDelta();	m_SizeVariant = 0.0f;	m_Acceleration = 0.0f;	m_StartAngle = 0.0f;	m_EndAngle = 360.0f;	m_StartColorA = m_EndColorA = 255;	m_StartColorR = m_EndColorR = 255;	m_StartColorG = m_EndColorG = 255;	m_StartColorB = m_EndColorB = 255;	m_StartColor = YMX_RGB(255, 255, 255);	m_EndColor = YMX_RGB(255, 255, 255);	m_RGBVariant = 0;	m_elapseTimeSinceUpdatePSize = 0.0f;	m_Style |= _PS_COLOR_GRADIENT;	m_Style |= _PS_HIGHLIGHT;	m_Style |= _PS_SIZE_GRADIENT;	//m_Style |= _PS_EXPLODE_CONTINUOUS;}

Object* MapMgr::_GetObject(const uint64 & guid){	switch(GET_TYPE_FROM_GUID(guid))	{	case	HIGHGUID_TYPE_GAMEOBJECT:		return GetGameObject(GET_LOWGUID_PART(guid));		break;	case	HIGHGUID_TYPE_UNIT:		return GetCreature(GET_LOWGUID_PART(guid));		break;	case	HIGHGUID_TYPE_DYNAMICOBJECT:		return GetDynamicObject((uint32)guid);		break;	case	HIGHGUID_TYPE_TRANSPORTER:		return objmgr.GetTransporter(GUID_LOPART(guid));		break;	default:		return GetUnit(guid);		break;	}}

YmxCometParticleSystem::YmxCometParticleSystem(LPYMXCOMPONENT pComponent, LPYMXTEXTURE pTexture, int maxCount)	:YmxParticleSystem(pComponent, pTexture, maxCount){	m_Type = PAR_TYPE_COMET;	m_Particles = NULL;	m_FreeParticles = NULL;	m_ParGroups = NULL;	m_ParLife = 0.5f;	m_ParLifeVariant = 0.1f;	m_StartSize = 30.0f;	m_EndSize = 1.0f;	m_SizeVariant = 0.0f;	m_Velocity = 30.0f;	m_VelocityVariant = 10.0f;	m_Density = 10;	m_StartColorA = m_EndColorA = 255;	m_StartColorR = m_EndColorR = 255;	m_StartColorG = m_EndColorG = 255;	m_StartColorB = m_EndColorB = 255;	m_StartColor = YMX_RGB(255, 255, 255);	m_EndColor = YMX_RGB(255, 255, 255);	m_RGBVariant = 0;	m_Delta = GetGameObject()->GetUpdateDelta();	m_Acceleration = 0.0f;	m_AccelerationVariant = 0.0f;	m_elapseTimeSinceUpdatePSize = 0.0f;	m_Style |= _PS_COLOR_GRADIENT;	m_Style |= _PS_HIGHLIGHT;	m_Style |= _PS_SIZE_GRADIENT;	m_Style |= _PS_COMIT_BURN_ONLY_ONMOVING;}

            bool SetBossState(uint32 type, EncounterState state) override            {                if (!InstanceScript::SetBossState(type, state))                    return false;                switch (type)                {                    case DATA_TALON_KING_IKISS:                        if (state == DONE)                        {                            /// @workaround: GO_FLAG_INTERACT_COND remains on the gob, but it is not handled correctly in this case                            ///              gameobject should have GO_DYNFLAG_LO_ACTIVATE too, which makes gobs interactable with GO_FLAG_INTERACT_COND                            ///              so just removed GO_FLAG_INTERACT_COND                            if (GameObject* coffer = GetGameObject(DATA_TALON_KING_COFFER))                                coffer->RemoveFlag(GAMEOBJECT_FLAGS, GO_FLAG_INTERACT_COND | GO_FLAG_NOT_SELECTABLE);                        }                        break;                    default:                        break;                }                return true;            }