Ejemplo n.º 1
0
	void ParticleEmitterData::CreateInputLayout()
	{
		HRESULT hr;

		D3DX11_PASS_DESC passDesc;
		hr = myEffect->GetTechnique()->GetPassByIndex(0)->GetDesc(&passDesc);
		DL_ASSERT_EXP(!FAILED(hr), "[ParticleEmitterData](CreateInputLayout) : Failed to get Pass Description!");

		const D3D11_INPUT_ELEMENT_DESC VertexParticleLayout[] =
		{
			{ "POSITION",	0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0,	D3D11_INPUT_PER_VERTEX_DATA, 0 },
			{ "COLOR",		0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 12,	D3D11_INPUT_PER_VERTEX_DATA, 0 },
			{ "ALPHA",		0, DXGI_FORMAT_R32_FLOAT,		0, 24,	D3D11_INPUT_PER_VERTEX_DATA, 0 },
			{ "SIZE",		0, DXGI_FORMAT_R32_FLOAT,		0, 28,	D3D11_INPUT_PER_VERTEX_DATA, 0 },
			{ "TIME",		0, DXGI_FORMAT_R32_FLOAT,		0, 32,	D3D11_INPUT_PER_VERTEX_DATA, 0 },
			{ "ROTATION",	0, DXGI_FORMAT_R32_FLOAT,		0, 36,	D3D11_INPUT_PER_VERTEX_DATA, 0 }
		};

		UINT size = ARRAYSIZE(VertexParticleLayout);

		hr = Engine::GetInstance()->GetDevice()->CreateInputLayout(VertexParticleLayout
			, size
			, passDesc.pIAInputSignature
			, passDesc.IAInputSignatureSize
			, &myInputLayout);
		DL_ASSERT_EXP(!FAILED(hr), "[ParticleEmitterData](CreateInputLayout) : Failed to Create InputLayout!");

		Engine::GetInstance()->SetDebugName(myInputLayout, "ParticleEmitterData::myInputLayout");
	}
Ejemplo n.º 2
0
void StateStack::PushSubGameState(GameState* aSubGameState)
{
    DL_ASSERT_EXP(myGameStates.Size() > 0, "Can't push sub game state, no main game state present.");
    DL_ASSERT_EXP(myMainIndex < 20 && mySubIndex < 20, "Can't add more than 20 states, it's unreasonable!");

    myGameStates[myMainIndex].Add(aSubGameState);

    aSubGameState->InitState(myStateStackProxy);

    mySubIndex = myGameStates[myMainIndex].Size() - 1;
}
Ejemplo n.º 3
0
	void Cube3D::InitVertexBuffer()
	{
		myVertexBuffer = new VertexBufferWrapper();
		HRESULT hr;

		if (myInputLayout == nullptr)
		{
			D3DX11_PASS_DESC passDesc;
			hr = myEffect->GetTechnique()->GetPassByIndex(0)->GetDesc(&passDesc);
			DL_ASSERT_EXP(!FAILED(hr), "[Cube3D](CreateInputLayout) : Failed to get Pass Description!");

			const D3D11_INPUT_ELEMENT_DESC Cube3DRendererLayout[] =
			{
				{ "POSITION", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 },
				{ "NORMAL", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, 16, D3D11_INPUT_PER_VERTEX_DATA, 0 },
				{ "COLOR", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, 32, D3D11_INPUT_PER_VERTEX_DATA, 0 },
			};

			UINT size = ARRAYSIZE(Cube3DRendererLayout);

			hr = Engine::GetInstance()->GetDevice()->CreateInputLayout(Cube3DRendererLayout
				, size
				, passDesc.pIAInputSignature
				, passDesc.IAInputSignatureSize
				, &myInputLayout);
			DL_ASSERT_EXP(!FAILED(hr), "[Cube3D](CreateInputLayout) : Failed to Create InputLayout!");

			Engine::GetInstance()->SetDebugName(myInputLayout, "Cube3D::myInputLayout");
		}

		D3D11_BUFFER_DESC vertexBufferDescription;
		vertexBufferDescription.Usage = D3D11_USAGE_DYNAMIC;
		vertexBufferDescription.ByteWidth = myVertexBaseData->mySize;
		vertexBufferDescription.BindFlags = D3D11_BIND_VERTEX_BUFFER;
		vertexBufferDescription.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
		vertexBufferDescription.MiscFlags = 0;
		vertexBufferDescription.StructureByteStride = 0;

		D3D11_SUBRESOURCE_DATA vertexBufferInitData;
		vertexBufferInitData.pSysMem = myVertexBaseData->myVertexData;

		// Set vertex buffer
		hr = Engine::GetInstance()->GetDevice()->CreateBuffer(&vertexBufferDescription, &vertexBufferInitData
			, &myVertexBuffer->myVertexBuffer);
		if (FAILED(hr))
		{
			DL_ASSERT("Failed to create vertexbuffer in CUBE3D");
		}

		Engine::GetInstance()->SetDebugName(myVertexBuffer->myVertexBuffer, "Cube3D::myVertexBuffer");


	}
Ejemplo n.º 4
0
void LevelFactory::LoadDifficults()
{
	XMLReader reader;
	reader.OpenDocument("Data/Setting/SET_difficulty.xml");
	tinyxml2::XMLElement* rootElement = reader.ForceFindFirstChild("root");
	int index = 0;
	for (tinyxml2::XMLElement* e = reader.ForceFindFirstChild(rootElement); e != nullptr; e = reader.FindNextElement(e))
	{
		DL_ASSERT_EXP(index < static_cast<int>(eDifficult::_COUNT), "You are trying to add more difficults than there should be.");
		if (std::strcmp(e->Name(), "Difficult") == 0)
		{
			Difficult newDifficult;
			std::string diffType;
			reader.ForceReadAttribute(e, "type", diffType);
			reader.ForceReadAttribute(e, "multiplier", newDifficult.myMultiplier);
			reader.ForceReadAttribute(e, "defendHealthMulitplier", newDifficult.myHealthMultiplier);

			if (diffType == "Easy")
			{
				newDifficult.myType = eDifficult::EASY;
			}
			else if (diffType == "Normal")
			{
				newDifficult.myType = eDifficult::NORMAL;
			}
			else if (diffType == "Hard")
			{
				newDifficult.myType = eDifficult::HARD;
			}

			myDifficults.Insert(index++,newDifficult);
		}
	}
	reader.CloseDocument();
}
	void ParticleEmitterInstance::Initiate(ParticleEmitterData* someData, bool anAllowManyParticles)
	{
		myParticleEmitterData = someData;
		myEmitterPath = myParticleEmitterData->myFileName;

		int particleCount = static_cast<int>(myParticleEmitterData->myParticlesPerEmitt * myParticleEmitterData->myParticlesLifeTime / myParticleEmitterData->myEmissionRate) + 1;

		
		DL_DEBUG(("Loading :" + myEmitterPath).c_str());
		DL_ASSERT_EXP(anAllowManyParticles == true || particleCount <= 201, "Can't have more than 201 particles in an emitter!");

		myGraphicalParticles.Init(particleCount);
		myLogicalParticles.Init(particleCount);

		myEmissionTime = myParticleEmitterData->myEmissionRate;

		myDiffColor = (myParticleEmitterData->myData.myEndColor - myParticleEmitterData->myData.myStartColor) / myParticleEmitterData->myParticlesLifeTime;

		for (int i = 0; i < particleCount; ++i)
		{
			GraphicalParticle tempGraphics;
			myGraphicalParticles.Add(tempGraphics);
			LogicalParticle tempLogic;
			myLogicalParticles.Add(tempLogic);
		}

		myIsActive = myParticleEmitterData->myIsActiveAtStart;
		myShouldLive = myParticleEmitterData->myIsActiveAtStart;

		myEmitterLife = myParticleEmitterData->myEmitterLifeTime;
		CreateVertexBuffer();
	}
	void ParticleEmitterInstance::CreateVertexBuffer()
	{

		myVertexWrapper = new VertexBufferWrapper();
		myVertexWrapper->myStride = sizeof(GraphicalParticle);
		myVertexWrapper->myByteOffset = 0;
		myVertexWrapper->myStartSlot = 0;
		myVertexWrapper->myNumberOfBuffers = 1;

		HRESULT hr;
		D3D11_BUFFER_DESC vertexBufferDesc;
		ZeroMemory(&vertexBufferDesc, sizeof(vertexBufferDesc));

		vertexBufferDesc.Usage = D3D11_USAGE_DYNAMIC;
		vertexBufferDesc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
		vertexBufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
		vertexBufferDesc.MiscFlags = 0;
		vertexBufferDesc.StructureByteStride = 0;

		if (myVertexWrapper->myVertexBuffer != nullptr)
		{
			myVertexWrapper->myVertexBuffer->Release();
		}

		vertexBufferDesc.ByteWidth = sizeof(GraphicalParticle) * myGraphicalParticles.Size();

		hr = Engine::GetInstance()->GetDevice()->CreateBuffer(&vertexBufferDesc, nullptr, &myVertexWrapper->myVertexBuffer);
		DL_ASSERT_EXP(hr == S_OK, "[ParticleEmitterInstance](CreateVertexBuffer) : Failed to create VertexBuffer");

		Engine::GetInstance()->SetDebugName(myVertexWrapper->myVertexBuffer
			, "ParticleEmitterInstance::myVertexWrapper->myVertexBuffer");

	}
Ejemplo n.º 7
0
bool Prism::Surface::SetTexture(const std::string& aResourceName, Texture* aTexture)
{
	DL_ASSERT_EXP(aTexture != nullptr
		, CU::Concatenate("Shader resource ( %s ) tried to use invalid texture", aResourceName.c_str()));

	ID3DX11EffectShaderResourceVariable* shaderVar = myEffect->GetEffect()->GetVariableByName(aResourceName.c_str())->AsShaderResource();
	if (shaderVar->IsValid() == false)
	{
		//DL_MESSAGE_BOX("Failed to get ShaderResource", "Surface Error", MB_ICONWARNING);
		RESOURCE_LOG("Failed to get ShaderResource");
		return false;
	}

	if (aResourceName == "EmissiveTexture")
	{
		myEmissive = true;
	}

	myTextures.Add(aTexture);
	myShaderResources.Add(aTexture->GetShaderView());
	myShaderResourceViews.Add(shaderVar);
	myShaderResourceNames.Add(aResourceName);

	return true;
}
Ejemplo n.º 8
0
bool Prism::Surface::SetTexture(const std::string& aResourceName, const std::string& aFileName, bool aUseSRGB)
{
	aUseSRGB;

	DL_ASSERT_EXP(aFileName != ""
		, CU::Concatenate("Shader resource ( %s ) tried to use invalid filePath", aResourceName.c_str()));

	Texture* tex = Engine::GetInstance()->GetTextureContainer()->GetTexture(aFileName);
	ID3DX11EffectShaderResourceVariable* shaderVar = myEffect->GetEffect()->GetVariableByName(aResourceName.c_str())->AsShaderResource();

	if (shaderVar->IsValid() == false)
	{
		std::string errorMsg = "Failed to get ShaderResource: " + aResourceName;
		//DL_MESSAGE_BOX(errorMsg.c_str(), "Surface Error", MB_ICONWARNING);
		RESOURCE_LOG(errorMsg.c_str());
		return false;
	}

	if (aResourceName == "EmissiveTexture")
	{
		myEmissive = true;
	}

	myTextures.Add(tex);
	myShaderResources.Add(tex->GetShaderView());
	myShaderResourceViews.Add(shaderVar);
	myFilePaths.Add(aFileName);
	myShaderResourceNames.Add(aResourceName);

	return true;
}
Ejemplo n.º 9
0
void MissionManager::Update(float aDeltaTime, bool aForceNextMission)
{
	DL_ASSERT_EXP(myCurrentMission < myMissions.Size(), "CurrentMission out of bounds!");
	std::stringstream ss;
	ss << myCurrentMission;
	Prism::Engine::GetInstance()->PrintText(ss.str(), { 400, -370 }, Prism::eTextType::DEBUG_TEXT);
	if (aForceNextMission == true || myEndEventsActive == false && myMissions[myCurrentMission]->Update(aDeltaTime, -1, eMissionCategory::DUMMY) == true)
	{
		myAllowedToStartNextMission = !myMissions[myCurrentMission]->EventsEnd();
		myEndEventsActive = true;
	}

	if (myEndEventsActive == true && myAllowedToStartNextMission == true)
	{
		myMissions[myCurrentMission]->End();
		Prism::Audio::AudioInterface::GetInstance()->PostEvent("Play_MissionCompleted", 0);
		++myCurrentMission;
		if (myCurrentMission == myMissions.Size())
		{
			myLevel.CompleteLevel();
		}
		else
		{
			myMissions[myCurrentMission]->EventsStart();
			myMissions[myCurrentMission]->Start();
			myAllowedToStartNextMission = false;
			myEndEventsActive = false;
		}
	}
}
Ejemplo n.º 10
0
bool DeliverWaterAction::Update(float /*aDelta*/)
{
	StockpileComponent* stockpile = myStockpileToDeliverTo->GetComponent<StockpileComponent>();
	DL_ASSERT_EXP(stockpile != nullptr, "Tried to Deliver Water to a non-stockpile entity");

	stockpile->PlaceResource(WATER);

	return true;
}
Ejemplo n.º 11
0
	void Renderer::BeginScene()
	{
		DL_ASSERT_EXP(mySceneIndex < MAX_NUMBER_OF_SCENES, "Tried to Begin to many Scenes");

		SceneData& data = mySceneData[mySceneIndex];

		ID3D11RenderTargetView* renderTarget = data.myScene->GetRenderTargetView();
		ID3D11DepthStencilView* depth = data.myScene->GetDepthStencilView();
		myEngine->GetContex()->ClearRenderTargetView(renderTarget, myClearColor);
		myEngine->GetContex()->ClearDepthStencilView(depth, D3D11_CLEAR_DEPTH | D3D11_CLEAR_STENCIL, 1.0f, 0);
		myEngine->GetContex()->OMSetRenderTargets(1, &renderTarget, depth);
	}
Ejemplo n.º 12
0
	void Renderer::EndScene(int aEffect)
	{
		DL_ASSERT_EXP(mySceneIndex < MAX_NUMBER_OF_SCENES, "Tried to Begin to many Scenes");

		SceneData& data = mySceneData[mySceneIndex];

		ID3D11RenderTargetView* renderTarget = data.myFinished->GetRenderTargetView();
		myEngine->GetContex()->ClearRenderTargetView(renderTarget, myClearColor);

		myFullScreenHelper->Process(data.myScene, data.myFinished, aEffect);

		++mySceneIndex;
	}
Ejemplo n.º 13
0
	void GPUData::SetupIndexBuffer(int aIndexCount, char* aIndexData)
	{
		if (myIndexBuffer->myIndexBuffer != nullptr)
		{
			SAFE_RELEASE(myIndexBuffer->myIndexBuffer);
		}

		myIndexBuffer->myBufferDesc->ByteWidth = sizeof(UINT) * aIndexCount;
		D3D11_SUBRESOURCE_DATA initData;
		initData.pSysMem = aIndexData;

		DL_ASSERT_EXP(SUCCEEDED(Engine::GetInstance()->GetDevice()->CreateBuffer(myIndexBuffer->myBufferDesc, &initData,
			&myIndexBuffer->myIndexBuffer)) == TRUE, "GPUData::SetupIndexBuffer: Failed to SetupIndexBuffer");
	}
Ejemplo n.º 14
0
	void GPUData::SetupVertexBuffer(int aVertexCount, char* aVertexData, GPUContext& aGPUContext)
	{
		if (myVertexBuffer->myVertexBuffer != nullptr)
		{
			SAFE_RELEASE(myVertexBuffer->myVertexBuffer);
		}

		myVertexBuffer->myBufferDesc->ByteWidth = myVertexBuffer->myStride * aVertexCount;
		D3D11_SUBRESOURCE_DATA initData;
		initData.pSysMem = aVertexData;

		DL_ASSERT_EXP(SUCCEEDED(aGPUContext.GetDevice()->CreateBuffer(myVertexBuffer->myBufferDesc, &initData
			, &myVertexBuffer->myVertexBuffer)) == TRUE, "GPUData::SetupVertexBuffer: Failed to SetupVertexBuffer");
	}
Ejemplo n.º 15
0
void Prism::Effect::SetPosAndScale(const CU::Vector2<float>& aPos
	, const CU::Vector2<float>& aScale)
{
	DL_ASSERT_EXP(mySpritePosAndScale != nullptr
		, "Effect2D: Tried to SetPosAndScale but mySpritePosAndScale is nullptr");

	mySpritePosAndScaleVector.x = aPos.x;
	mySpritePosAndScaleVector.y = aPos.y;

	mySpritePosAndScaleVector.z = aScale.x;
	mySpritePosAndScaleVector.w = aScale.y;

	mySpritePosAndScale->SetFloatVector(&mySpritePosAndScaleVector.x);
}
Ejemplo n.º 16
0
bool DeliverWaterAction::IsInRange()
{
	DL_ASSERT_EXP(myStockpileToDeliverTo != nullptr, "Invalid TargetEntity");

	CU::Vector2<float> ownPosition = myEntity.GetPosition();
	CU::Vector2<float> otherPosition = GetTargetPosition();
	CU::Vector2<float> direction = otherPosition - ownPosition;
	float distance = CU::Length(direction);

	if (distance < 10.f)
		return true;

	return false;
}
Ejemplo n.º 17
0
void StateStack::PopSubGameState()
{
    DL_ASSERT_EXP(myGameStates.Size() > 0, "Can't pop an empty stack.");

    myGameStates[myMainIndex][mySubIndex]->EndState();

    myGameStates[myMainIndex].DeleteCyclicAtIndex(mySubIndex);
    --mySubIndex;

    if (mySubIndex >= 0)
    {
        myGameStates[myMainIndex][mySubIndex]->ResumeState();
    }
}
	void ParticleEmitterInstance::UpdateVertexBuffer()
	{
		D3D11_MAPPED_SUBRESOURCE mappedResource;
		Engine::GetInstance()->GetContex()->Map(myVertexWrapper->myVertexBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);

		if (mappedResource.pData != nullptr)
		{
			GraphicalParticle *data = (GraphicalParticle*)mappedResource.pData;

			bool isSafe = sizeof(GraphicalParticle) == sizeof(myGraphicalParticles[0]);
			DL_ASSERT_EXP(isSafe, "[ParticleEmitter](UpdateVertexBuffer) : Not safe to copy.");
			memcpy(data, &myGraphicalParticles[0], sizeof(GraphicalParticle)* myGraphicalParticles.Size());
		}
		Engine::GetInstance()->GetContex()->Unmap(myVertexWrapper->myVertexBuffer, 0);
	}
Ejemplo n.º 19
0
void MissionContainer::SortCopy(CU::GrowingArray<Mission*>& someOut, const CU::GrowingArray<Mission*>& someIn) const
{
	int currentIndex = 0;
	while (someOut.Size() != someIn.Size())
	{
		int prevIndex = currentIndex;
		for (int i = 0; i < someIn.Size(); ++i)
		{
			if (someIn[i]->GetIndex() == currentIndex)
			{
				++currentIndex;
				someOut.Add(someIn[i]);
				break;
			}
		}
		DL_ASSERT_EXP(prevIndex == currentIndex - 1, "Mission index " + std::to_string(currentIndex) + " not found.");
	}
}
Ejemplo n.º 20
0
MissionManager::MissionManager(Level& aLevel, Entity& aPlayer, const std::string& aFileToReadFrom)
	: myLevel(aLevel)
	, myPlayer(aPlayer)
	, myMissions(16)
	, myCurrentMission(0) 
	, myMissionsNotOrder(16)
	, myAllowedToStartNextMission(true)
	, myEndEventsActive(false)
{
	PostMaster::GetInstance()->Subscribe(eMessageType::EVENT_QUEUE_EMPTY, this);
	XMLReader reader;
	reader.OpenDocument(aFileToReadFrom);

	tinyxml2::XMLElement* element = reader.ForceFindFirstChild("root");

	for (element = reader.ForceFindFirstChild(element, "missionContainer"); element != nullptr;
		element = reader.FindNextElement(element, "missionContainer"))
	{
		int missionIndex = -1;
		reader.ForceReadAttribute(element, "index", missionIndex);

		MissionContainer* mission = new MissionContainer(myLevel, myPlayer, reader, element);
		mission->SetIndex(missionIndex);
		myMissionsNotOrder.Add(mission);
	}
	reader.CloseDocument();

	int currentIndex = 0;
	while (myMissions.Size() != myMissionsNotOrder.Size())
	{
		int prevIndex = currentIndex;
		for (int i = 0; i < myMissionsNotOrder.Size(); ++i)
		{
			if (myMissionsNotOrder[i]->GetIndex() == currentIndex)
			{
				++currentIndex;
				myMissions.Add(myMissionsNotOrder[i]);
				break;
			}
		}
		DL_ASSERT_EXP(prevIndex == currentIndex - 1, "Mission index " + std::to_string(currentIndex) + " not found.");
	}
}
Ejemplo n.º 21
0
void Prism::Scene::AddInstance(Instance* aInstance)
{
#ifdef SCENE_USE_OCTREE
	if (aInstance->GetOctreeType() == eOctreeType::PLAYER)
	{
		DL_ASSERT_EXP(myPlayerInstance == nullptr, "Tried to add Player twice to Scene");
		myPlayerInstance = aInstance;
	}
	else if (aInstance->GetOctreeType() == eOctreeType::DYNAMIC)
	{
		myDynamicInstances.Add(aInstance);
	}
	else
	{
		myOctree->Add(aInstance);
	}
#else
	myInstances.Add(aInstance);
#endif
}
Ejemplo n.º 22
0
void LevelFactory::FillDataPropOrDefendable(XMLReader& aReader, tinyxml2::XMLElement* aLevelElement, Entity* aEntityToCreate)
{
	tinyxml2::XMLElement* propElement = aReader.ForceFindFirstChild(aLevelElement, "position");
	CU::Vector3<float> propPosition;
	aReader.ForceReadAttribute(propElement, "X", propPosition.x);
	aReader.ForceReadAttribute(propElement, "Y", propPosition.y);
	aReader.ForceReadAttribute(propElement, "Z", propPosition.z);
	aEntityToCreate->myOriginalOrientation.SetPos(propPosition*10.f);

	propElement = aReader.ForceFindFirstChild(aLevelElement, "rotation");
	CU::Vector3<float> propRotation;
	aReader.ForceReadAttribute(propElement, "X", propRotation.x);
	aReader.ForceReadAttribute(propElement, "Y", propRotation.y);
	aReader.ForceReadAttribute(propElement, "Z", propRotation.z);

	aEntityToCreate->myOriginalOrientation = CU::GetOrientation(aEntityToCreate->myOriginalOrientation, propRotation);

	//if (aEntityToCreate->GetType() == eEntityType::PROP)
	//{
	//	int health = 30;
	//	aEntityToCreate->AddComponent<HealthComponent>()->Init(health);
	//}

#ifdef _DEBUG //REMOVE THIS STUFF WHEN HENRIK HAS UPDATED Entities
	if (aEntityToCreate->GetComponent<HealthComponent>() == nullptr)
	{
		int health = 30;
		aEntityToCreate->AddComponent<HealthComponent>()->Init(health);
	}
#endif

	DL_ASSERT_EXP(aEntityToCreate->GetComponent<HealthComponent>() != nullptr, aEntityToCreate->GetName() + ": Prop without healthcomponent has been loaded.");

	aEntityToCreate->myOrientation = aEntityToCreate->myOriginalOrientation;
	myCurrentLevel->myEntities.Add(aEntityToCreate);
	myCurrentLevel->myCollisionManager->Add(myCurrentLevel->myEntities.GetLast()->GetComponent<CollisionComponent>(), aEntityToCreate->GetType());
}
Ejemplo n.º 23
0
void Prism::Octree::Add(Instance* aInstance)
{
	DL_ASSERT_EXP(aInstance->GetOctreeType() != eOctreeType::NOT_IN_OCTREE, "Can't add NOT_IN_OCTREE object to octree.");
	myRoot->InsertObjectDown(aInstance);
}
Ejemplo n.º 24
0
void BulletManager::ActivateBullet(BulletData* aWeaponData, const CU::Matrix44<float>& anOrientation
	, eEntityType aEntityType, const CU::Vector3<float>& aEnitityVelocity, const CU::Vector3<float>& aDirection
	, Entity* aHomingTarget, float aHomingTurnRateModifier)
{

	Entity* bullet = nullptr;
	if (aEntityType == eEntityType::PLAYER || aEntityType == eEntityType::ALLY)
	{
		bullet = aWeaponData->myPlayerBullets[aWeaponData->myPlayerBulletCounter];
	}
	else if (aEntityType == eEntityType::ENEMY)
	{
		bullet = aWeaponData->myEnemyBullets[aWeaponData->myEnemyBulletCounter];
	}
	DL_ASSERT_EXP(bullet != nullptr, "Non Player/Enemy cant activate bullets!");

	bullet->GetComponent<BulletComponent>()->SetOwner(aEntityType);

	if (bullet->GetComponent<BulletComponent>()->GetActive() == false)
	{
		if (aEntityType == eEntityType::PLAYER || aEntityType == eEntityType::ALLY)
		{
			myCollisionManager.Add(bullet->GetComponent<CollisionComponent>(), eEntityType::PLAYER_BULLET);
		}
		else if (aEntityType == eEntityType::ENEMY)
		{
			myCollisionManager.Add(bullet->GetComponent<CollisionComponent>(), eEntityType::ENEMY_BULLET);
		}
	}

	if (bullet->GetComponent<BulletAIComponent>() != nullptr)
	{
		bullet->RemoveComponent<BulletAIComponent>();
	}

	if (aEntityType == eEntityType::PLAYER)
	{
		bullet->GetComponent<PhysicsComponent>()->Init(anOrientation,
			(anOrientation.GetForward() * (aWeaponData->mySpeed)) + aEnitityVelocity);
	}
	else if (aEntityType == eEntityType::ENEMY || aEntityType == eEntityType::ALLY)
	{
		bullet->GetComponent<PhysicsComponent>()->Init(anOrientation,
			(aDirection * (aWeaponData->mySpeed)) + aEnitityVelocity);
	}
	
	bullet->GetComponent<BulletComponent>()->SetActive(true);
	bullet->GetComponent<CollisionComponent>()->Update(0.5f);

	if (bullet->GetComponent<StreakEmitterComponent>() != nullptr)
	{
		bullet->GetComponent<StreakEmitterComponent>()->Reset();
	}

	if (aHomingTarget != nullptr)
	{
		bullet->AddComponent<BulletAIComponent>()->Init((CU::Length((anOrientation.GetForward() * (aWeaponData->mySpeed)) + aEnitityVelocity) / 2.f)
			, aHomingTurnRateModifier, &myCollisionManager);
		bullet->GetComponent<BulletAIComponent>()->SetEntityToFollow(aHomingTarget, aHomingTarget);
	}

	if (aEntityType == eEntityType::PLAYER || aEntityType == eEntityType::ALLY)
	{
		aWeaponData->myPlayerBulletCounter++;
		if (aWeaponData->myPlayerBulletCounter >= aWeaponData->myMaxBullet)
		{
			aWeaponData->myPlayerBulletCounter = 0;
		}
	}
	else if (aEntityType == eEntityType::ENEMY)
	{
		aWeaponData->myEnemyBulletCounter++;
		if (aWeaponData->myEnemyBulletCounter >= aWeaponData->myMaxBullet)
		{
			aWeaponData->myEnemyBulletCounter = 0;
		}
	}
}
Ejemplo n.º 25
0
MissionContainer::MissionContainer(Level& aLevel, Entity& aPlayer, XMLReader& aReader, tinyxml2::XMLElement* aElement)
	: Mission(aReader, aElement)
	, myRequiredMissions(8)
	, myOptionalMissions(8)
	, myRequiredActiveMissions(8)
	, myOptionalActiveMissions(8)
	, myEndingMissions(8)
{
	PostMaster::GetInstance()->Subscribe(eMessageType::EVENT_QUEUE_EMPTY, this);

	CU::GrowingArray<Mission*> unorderedRequiredMissions(8);
	CU::GrowingArray<Mission*> unorderedOptionalMissions(8);

	for (tinyxml2::XMLElement* element = aReader.ForceFindFirstChild(aElement, "mission"); element != nullptr;
		element = aReader.FindNextElement(element, "mission"))
	{
		std::string type;
		aReader.ForceReadAttribute(element, "type", type);
		type = CU::ToLower(type);
		int missionIndex = -1;
		aReader.ForceReadAttribute(element, "index", missionIndex);
		bool required;
		aReader.ForceReadAttribute(element, "required", required);

		Mission* mission = nullptr;
		if (type == "waypoint")
		{
			mission = new WaypointMission(aLevel, aPlayer, aReader, element);
		}
		else if (type == "killx")
		{
			mission = new KillXEnemiesMission(aLevel, aReader, element);
		}
		else if (type == "killxabort")
		{
			mission = new KillXEnemiesAbortMission(aLevel, aReader, element);
		}
		else if (type == "killall")
		{
			mission = new KillAllMission(aLevel, aReader, element);
		}
		else if (type == "killallabort")
		{
			mission = new KillAllAbortMission(aLevel, aReader, element);
		}
		else if (type == "survival")
		{
			mission = new SurvivalMission(aReader, element);
		}
		else if (type == "survivalabort")
		{
			mission = new SurvivalAbortMission(aReader, element);
		}
		else if (type == "defend")
		{
			mission = new DefendMission(aReader, element, false);
		}
		else if (type == "defendabort")
		{
			mission = new DefendMission(aReader, element, true);
		}
		else if (type == "killstructures")
		{
			mission = new KillStructureMission(aReader, element);
		}

		DL_ASSERT_EXP(mission != nullptr, "Missiontype not recognized: " + type);

		mission->SetIndex(missionIndex);

		if (required == true)
		{
			unorderedRequiredMissions.Add(mission);
		}
		else
		{
			unorderedOptionalMissions.Add(mission);
			PostMaster::GetInstance()->SendMessage<LevelScoreMessage>(LevelScoreMessage(eLevelScoreMessageType::OPTIONAL_MISSION_ADDED));
		}
	}

	DL_ASSERT_EXP(unorderedRequiredMissions.Size() > 0, "Need a required mission in missioncontainer");

	SortCopy(myRequiredMissions, unorderedRequiredMissions);
	SortCopy(myOptionalMissions, unorderedOptionalMissions);
	

	for (int i = 0; i < myRequiredMissions.Size(); ++i)
	{
		myRequiredActiveMissions.Add(myRequiredMissions[i]);
	}

	for (int i = 0; i < myOptionalMissions.Size(); ++i)
	{
		myOptionalActiveMissions.Add(myOptionalMissions[i]);
	}
}
Ejemplo n.º 26
0
Event::Event(const std::string& aName, const CU::GrowingArray<Action*>& someActions)
	: myName(aName)
	, myActions(someActions)
{
	DL_ASSERT_EXP(myActions.Size() > 0, "Can't create event with zero actions.");
}
Ejemplo n.º 27
0
bool Prism::Surface::VerifyTextures(const std::string& aModelPath)
{
	if (aModelPath.find("skySphere") != std::string::npos)
	{
		return true;
	}

	bool diffuse = false;
	bool albedo = false;
	bool normal = false;
	bool roughness = false;
	bool metal = false;
	bool ao = false;
	bool emissiveness = false;

	for (int i = 0; i < myShaderResourceNames.Size(); ++i)
	{
		if (myShaderResourceNames[i] == "DiffiuseTexture")
		{
			diffuse = true;
		}
		else if (myShaderResourceNames[i] == "AlbedoTexture")
		{
			albedo = true;
		}
		else if (myShaderResourceNames[i] == "NormalTexture")
		{
			normal = true;
		}
		else if (myShaderResourceNames[i] == "RoughnessTexture")
		{
			roughness = true;
		}
		else if (myShaderResourceNames[i] == "MetalnessTexture")
		{
			metal = true;
		}
		else if (myShaderResourceNames[i] == "AOTexture")
		{
			ao = true;
		}
		else if (myShaderResourceNames[i] == "EmissiveTexture")
		{
			emissiveness = true;
		}
	}


	if (diffuse == true) return true;

#ifndef _DEBUG
	DL_ASSERT_EXP(albedo == true, CU::Concatenate("Albedo missing from %s", aModelPath.c_str()));
	DL_ASSERT_EXP(normal == true, CU::Concatenate("NormalMap missing from %s", aModelPath.c_str()));
	DL_ASSERT_EXP(roughness == true, CU::Concatenate("Roughness missing from %s", aModelPath.c_str()));
	DL_ASSERT_EXP(metal == true, CU::Concatenate("Metalness missing from %s", aModelPath.c_str()));
	DL_ASSERT_EXP(ao == true, CU::Concatenate("AmbientOcclusion missing from %s", aModelPath.c_str()));
	DL_ASSERT_EXP(emissiveness == true, CU::Concatenate("Emissiveness missing from %s", aModelPath.c_str()));
#endif

	return true;
}
Ejemplo n.º 28
0
void StateStack::RenderCurrentState()
{
    DL_ASSERT_EXP(myGameStates.Size() > 0, "Can't render, no gamestate present.");
    RenderStateAtIndex(mySubIndex);
}
Ejemplo n.º 29
0
void Prism::Sprite::CopyFromD3DTexture(ID3D11Texture2D* aTexture)
{
	DL_ASSERT_EXP(myTexture != nullptr, "Tried to CopyFromD3DTexture on a sprite that was created from file");
	Engine::GetInstance()->GetContex()->CopyResource(myTexture, aTexture);
}