bool CCollider::CollideWith(CCollider& other, const double dt)
{
if (!this->m_active || !other.GetActive()) // If one of the collider does not collide, no collision will occur, hence false
{
return false;
}
if (this->m_type == CT_AABB)
{
if (other.GetType() == CT_AABB)
{
// AABB - AABB collision
return AABBCollision(other, dt);
}
else if (other.GetType() == CT_DIST)
{
// AABB - Dist collision
return AABBCollision(other, dt); // Use AABB - AABB collision
}
}
else if (this->m_type == CT_DIST)
{
if (other.GetType() == CT_AABB)
{
// Dist - AABB collision
return AABBCollision(other, dt); // Use AABB - AABB collision
}
else if (other.GetType() == CT_DIST)
{
// Dist - Dist collision
return distCollision(other, dt);
}
}
}
bool CCollider::AABBCollision(CCollider & other, const double dt)
{
Vector3 oMin = other.GetMinBound();
Vector3 oMax = other.GetMaxBound();
if ( ( !(m_ignore[IGNORE_X] || other.GetIgnore(IGNORE_X)) && (m_maxBound.x < oMin.x || m_minBound.x > oMax.x) ) ||
( !(m_ignore[IGNORE_Y] || other.GetIgnore(IGNORE_Y)) && (m_maxBound.y < oMin.y || m_minBound.y > oMax.y) ) ||
( !(m_ignore[IGNORE_Z] || other.GetIgnore(IGNORE_Z)) && (m_maxBound.z < oMin.z || m_minBound.z > oMax.z) )
)
{
return false;
}
return true;
}
bool CCollider::distCollision(CCollider & other, const double dt)
{
// TODO: Make exceptions for oval
// Temp dist collision (Only works with circles)
float distSquared = (other.GetPosition() - m_position).LengthSquared();
float thisRadius = m_diameter.x * 0.5f, oRadius = other.GetDiameter().x * 0.5f;
if (((thisRadius * thisRadius) + (oRadius * oRadius)) < distSquared)
{
return true;
}
return false;
}
void CRigidbody::processCollisionData(CollisionData& data)
{
if (data.collidersRaw[0] != nullptr)
{
CCollider* other = (CCollider*)data.collidersRaw[0]->_getOwner(PhysicsOwnerType::Component);
data.collider[0] = other->getHandle();
}
if (data.collidersRaw[1] != nullptr)
{
CCollider* other = (CCollider*)data.collidersRaw[1]->_getOwner(PhysicsOwnerType::Component);
data.collider[1] = other->getHandle();
}
}
void CCollider::triggerOnCollisionEnd(const CollisionData& data)
{
// Const-cast and modify is okay because we're the only object receiving this event
CollisionData& hit = const_cast<CollisionData&>(data);
hit.collider[0] = mThisHandle;
if (hit.collidersRaw[1] != nullptr)
{
CCollider* other = (CCollider*)hit.collidersRaw[1]->_getOwner(PhysicsOwnerType::Component);
hit.collider[1] = other->getHandle();
}
onCollisionEnd(hit);
}
/*****************************************************************
* SmoothPath() Removes uneeded nodes from given path to smooth it out
* it out.
*
* Ins: vector<CNode*>&
*
*
* Outs: None
*
* Returns: None
*
* Mod. Date: 09/01/2015
* Mod. Initials: CM
*****************************************************************/
vector<XMFLOAT3> CPathFinding::SmoothPath(vector<CNode*>& path)
{
vector<XMFLOAT3> smoothedPath;
if (path.size() > 2)
{
XMFLOAT3 checkPoint = path[0]->GetPosition();
XMFLOAT3 currPoint = path[1]->GetPosition();
smoothedPath.push_back(path[0]->GetPosition());
for (size_t currNode = 1; currNode + 2 < path.size(); currNode++)
{
CCapsule* tempCapsule = new CCapsule(path[currNode + 2]->GetPosition(), checkPoint, 100.0f);
CCollider* tempCollider = new CCollider(true, tempCapsule);
std::vector<IObject*> colliders = m_pObjectManager->GetQuadTree()->GetNearbyObjects(tempCollider->GetBounds());
std::vector<IObject*> hit;
CheckCollision(tempCollider, colliders, hit);
bool skip = false;
for (size_t currHit = 0; currHit < hit.size(); currHit++)
{
if (hit[currHit]->GetTag() == "Wall")
{
checkPoint = currPoint;
currPoint = path[currNode + 1]->GetPosition();
skip = true;
smoothedPath.push_back(path[currNode]->GetPosition());
break;
}
}
if (skip == false)
{
currPoint = path[currNode + 1]->GetPosition();
}
delete tempCollider;
}
//currIndex++;
}
smoothedPath.push_back(path[path.size() - 1]->GetPosition());
return smoothedPath;
}
/*****************************************************************
* CollisionResponse() Responds to collision
*
* Ins: IObject*
*
* Outs: None
*
* Returns: void
*
* Mod. Date: 08/20/2015
* Mod. Initials: NS
*****************************************************************/
void CSkeleton::CollisionResponse(IObject * _cCollidedObject)
{
if (_cCollidedObject->GetTag() == "PlayerAttack" && !m_bInvincible && m_fCurrentHealth > 0.0f)
{
m_bInvincible = true;
m_fInvincibilityTimer = 0.35f;
m_fCurrentHealth -= ((CAttack*)_cCollidedObject)->GetDamage();
m_eNewState = HURT;
m_eCurrState = HURT;
EnterSubState();
}
else if (_cCollidedObject->GetTag() == "TrapPrefab")
{
for (size_t i = 1; i < _cCollidedObject->GetColliders().size(); i++)
{
if (_cCollidedObject->GetColliders()[i]->GetCollided())
{
if (_cCollidedObject->GetColliders()[i]->GetType() == Bounds::AABB)
{
CapsuleToWall(this, m_pvColliders[1], _cCollidedObject->GetColliders()[i]);
_cCollidedObject->GetColliders()[i]->SetCollided(false);
}
else if (_cCollidedObject->GetColliders()[i]->GetType() == Bounds::Plane)
{
if (m_mWorld.m[3][1] > -20.0f && m_f3Velocity.y < 0.0f)
{
CapsuleToFloor(this, m_pvColliders[1], _cCollidedObject->GetColliders()[i]);
_cCollidedObject->GetColliders()[i]->SetCollided(false);
m_bIsGrounded = true;
}
}
}
}
}
else if (_cCollidedObject->GetTag() == "Wall" || _cCollidedObject->GetTag() == "Door" || _cCollidedObject->GetTag() == "CrackedWall" || _cCollidedObject->GetTag() == "SafeHaven" || _cCollidedObject->GetTag() == "MinotaurSpawn")
{
if (m_eCurrState == ESkeletonStates::BACKING_OUT || m_eCurrState == ESkeletonStates::MANUVERING)
{
m_eNewState = ESkeletonStates::MOVING_IN;
}
for (size_t i = 1; i < _cCollidedObject->GetColliders().size(); i++)
{
if (_cCollidedObject->GetColliders()[i]->GetCollided())
{
if (_cCollidedObject->GetColliders()[i]->GetType() == Bounds::AABB)
{
CapsuleToWall(this, m_pvColliders[1], _cCollidedObject->GetColliders()[i]);
_cCollidedObject->GetColliders()[i]->SetCollided(false);
}
else if (_cCollidedObject->GetColliders()[i]->GetType() == Bounds::Plane)
{
if (m_mWorld.m[3][1] > -20.0f && m_f3Velocity.y < 0.0f)
{
CapsuleToFloor(this, m_pvColliders[1], _cCollidedObject->GetColliders()[i]);
_cCollidedObject->GetColliders()[i]->SetCollided(false);
m_bIsGrounded = true;
}
}
}
}
if (_cCollidedObject->GetTag() == "SafeHaven")
{
m_eNewState = RETREAT;
}
}
else if (_cCollidedObject->GetTag() == "SmallPit")
{
if (m_mWorld.m[3][1] > -20.0f && m_f3Velocity.y < 0.0f)
{
for (size_t i = 1; i < _cCollidedObject->GetColliders().size(); i++)
{
CCollider* tested = _cCollidedObject->GetColliders()[i];
if (tested->GetCollided())
{
if (tested->GetType() == Bounds::Plane)
{
if (((CPlane*)(tested->GetBounds()))->GetCenter().y < 0.0f)
{
CapsuleToFloor(this, m_pvColliders[1], tested);
tested->SetCollided(false);
m_bIsGrounded = true;
}
}
else
{
CapsuleToFloor(this, m_pvColliders[1], _cCollidedObject->GetColliders()[i]);
_cCollidedObject->GetColliders()[i]->SetCollided(false);
m_bIsGrounded = true;
}
}
}
}
else if (m_f3Velocity.y < 0.0f)
{
for (size_t i = 1; i < _cCollidedObject->GetColliders().size() - 2; i++)
{
if (_cCollidedObject->GetColliders()[i]->GetCollided())
{
CapsuleToWall(this, m_pvColliders[1], _cCollidedObject->GetColliders()[i]);
_cCollidedObject->GetColliders()[i]->SetCollided(false);
}
}
}
}
else if (_cCollidedObject->GetTag() == "BigPit")
{
if (m_mWorld.m[3][1] > -20.0f && m_f3Velocity.y < 0.0f)
{
for (size_t i = 1; i < _cCollidedObject->GetColliders().size(); i++)
{
CCollider* tested = _cCollidedObject->GetColliders()[i];
if (tested->GetCollided())
{
CapsuleToFloor(this, m_pvColliders[1], tested);
tested->SetCollided(false);
m_bIsGrounded = true;
}
}
}
else if (m_f3Velocity.y < 0.0f)
{
for (size_t i = 1; i < _cCollidedObject->GetColliders().size() - 1; i++)
{
CCollider* collider = _cCollidedObject->GetColliders()[i];
if (collider->GetCollided())
{
CapsuleToWall(this, m_pvColliders[1], collider);
collider->SetCollided(false);
}
}
}
}
else if (_cCollidedObject->GetTag() == "Skeleton")
{
//Need capsule to capulse to make slide off eachother
CapsuleToCapsule(this, m_pvColliders[1], _cCollidedObject->GetColliders()[1]);
}
else if (_cCollidedObject->GetTag() == "Floor" || _cCollidedObject->GetTag() == "SafeHavenFloor")
{
if (m_mWorld.m[3][1] > -20.0f && m_f3Velocity.y < 0.0f)
{
CapsuleToFloor(this, m_pvColliders[1], _cCollidedObject->GetColliders()[0]);
m_bIsGrounded = true;
}
}
else if (_cCollidedObject->GetTag() == "SpikeTrap")
{
if (m_fCurrentHealth > 0.0f)
{
CSpikeTrap* curTrap = reinterpret_cast<CSpikeTrap*>(_cCollidedObject);
if (curTrap->GetActive() || curTrap->GetReset())
{
SetWorldVelocity({ 0.0f, 0.0f, 0.0f });
}
if (curTrap->GetActive() && !m_bInvincible)
{
TakeDamage(curTrap->GetTrapDamage());
SetWorldVelocity({ 0, 1000.0f, 0 });
//ChangeState(ESkeletonStates::eIdleState);
}
else
{
CapsuleToWall(this, m_pvColliders[1], _cCollidedObject->GetColliders()[0]);
}
}
}
else if (_cCollidedObject->GetTag() == "FireTrap")
{
if (m_fCurrentHealth > 0.0f)
{
CFireTrap* curTrap = reinterpret_cast<CFireTrap*>(_cCollidedObject);
if (curTrap->GetActive() && !m_bInvincible)
{
TakeDamage(curTrap->GetTrapDamage());
}
}
}
else if (_cCollidedObject->GetTag() == "SpinningBlade")
{
if (m_fCurrentHealth > 0.0f && !m_bInvincible)
{
CSpinningBlade* curTrap = reinterpret_cast<CSpinningBlade*>(_cCollidedObject);
XMVECTOR mathTarget = XMVector3Normalize(XMLoadFloat3(GetPosition()) - XMLoadFloat3(curTrap->GetPosition()));
mathTarget *= 1000.0f;
XMFLOAT3 toTarget; XMStoreFloat3(&toTarget, mathTarget);
SetWorldVelocity(toTarget);
TakeDamage(curTrap->GetTrapDamage());
}
}
else if (_cCollidedObject->GetTag() == "PressurePlate")
{
_cCollidedObject->CollisionResponse(this);
}
else if (_cCollidedObject->GetTag() == "Bridge")
{
CBridge* curBridge = reinterpret_cast<CBridge*>(_cCollidedObject);
curBridge->SetCollided(true);
if (curBridge->IsActive() && curBridge->IsIntact())
{
if (_cCollidedObject->GetColliders()[1]->GetCollided())
{
if (_cCollidedObject->GetColliders()[1]->GetCollided())
_cCollidedObject->GetColliders()[1]->SetCollided(false);
}
for (size_t i = 2; i < 10; i++)
{
if (_cCollidedObject->GetColliders()[i]->GetCollided())
{
if (GetPosition()->y < 20.0f)
{
CapsuleToFloor(this, m_pvColliders[1], _cCollidedObject->GetColliders()[i]);
_cCollidedObject->GetColliders()[i]->SetCollided(false);
m_bIsGrounded = true;
}
else
{
CapsuleToWall(this, m_pvColliders[1], _cCollidedObject->GetColliders()[i]);
_cCollidedObject->GetColliders()[i]->SetCollided(false);
}
}
}
for (size_t i = 10; i < _cCollidedObject->GetColliders().size(); i++)
{
if (_cCollidedObject->GetColliders()[i]->GetCollided())
{
CapsuleToWall(this, m_pvColliders[1], _cCollidedObject->GetColliders()[i]);
_cCollidedObject->GetColliders()[i]->SetCollided(false);
}
}
}
}
else if (_cCollidedObject->GetTag() == "Minotaur")
{
TakeDamage(200.0f);
}
else if (_cCollidedObject->GetTag() == "MinotaurZone")
{
if (m_pDayNight->IsNight())
{
if (m_eNewState != DEATH && m_eCurrState != DEATH)
{
m_eNewState = RETREAT;
}
}
}
}
CMinotaur::CMinotaur(const XMFLOAT3& spawnPosition, CObjectManager* _manager, CAnimationManager* _animManager) : CBoid(15.0f, 300.0f, "Minotaur")
{
// Drop Shadow Creation //
CMesh cDropShadow;
cDropShadow.GetIndices().push_back(0);
cDropShadow.GetIndices().push_back(1);
cDropShadow.GetIndices().push_back(2);
cDropShadow.GetIndices().push_back(0);
cDropShadow.GetIndices().push_back(2);
cDropShadow.GetIndices().push_back(3);
cDropShadow.GetVertices().push_back
({
{ -400.0f, 3.0f, 400.0f, 1.0f },
{ 0.0f, 1.0f, 0.0f, 1.0f },
{ 0, 0 }
});
cDropShadow.GetVertices().push_back
({
{ 400.0f, 3.0f, 400.0f, 1.0f },
{ 0.0f, 1.0f, 0.0f, 1.0f },
{ 1, 0 }
});
cDropShadow.GetVertices().push_back
({
{ 400.0f, 3.0f, -400.0f, 1.0f },
{ 0.0f, 1.0f, 0.0f, 1.0f },
{ 1, 1 }
});
cDropShadow.GetVertices().push_back
({
{ -400.0f, 3.0f, -400.0f, 1.0f },
{ 0.0f, 1.0f, 0.0f, 1.0f },
{ 0, 1 }
});
m_cDropShadow = new CRenderMesh(&cDropShadow, GRAPHICS->GetStandardVS(), GRAPHICS->GetStandardPS());
m_cDropShadow->SetTexture(L"../Game/Assets/Art/2D/Textures/Shadow.dds");
m_cDropShadow->GetTransparent() = true;
m_cDropShadow->GetRender() = false;
GRAPHICS->AddRenderMesh(m_cDropShadow);
XMStoreFloat4x4(&m_mWorld, XMMatrixTranslation(spawnPosition.x, spawnPosition.y, spawnPosition.z));
m_tSpawnPosition = spawnPosition;
m_pPathPlanner = new CPathFinding("MinotaurNavGraph", _manager, false);
CNavGraph* cNavGraph = CNavGraphManager::GetReference().GetNavGraph("MinotaurNavGraph");
int unNodes[2];
unNodes[0] = rand() % cNavGraph->GetNodes().size();
unNodes[1] = rand() % cNavGraph->GetNodes().size();
if (unNodes[1] == unNodes[0])
{
unNodes[1]++;
}
m_vWaypoints.push_back(unNodes[0]);
m_vWaypoints.push_back(unNodes[1]);
//m_pSteering = new CSteeringManager(this);
m_pAssetManager = CAssetManager::GetInstance();
m_cpAnimationManager = _animManager;
m_cpObjectManager = _manager;
m_pPlayer = m_cpObjectManager->GetPlayer();
CMesh* m_cMesh = m_pAssetManager->GetPrefabMesh("minotaur");
m_cpRenderMesh = new CAnimationMesh(m_cMesh, GRAPHICS->GetSkinningVS(), GRAPHICS->GetStandardPS(), nullptr, nullptr, nullptr, L"../Game/Assets/Art/2D/Textures/Minotaur.dds");
m_cpRenderMesh->GetRender() = false;
GRAPHICS->AddRenderMesh(m_cpRenderMesh);
enum EMinotaurAnimation{ eIdleAnim, eRunAnim, eTellAnim, eChargeAnim, eStompAnim, eDeathAnim, eEnrageAnim, eStunnedAnim, eAnimCount };
m_cpAnimations[eIdleAnim] = CAssetManager::GetInstance()->GetAnimation("MinotaurIdle");
m_cpAnimations[eRunAnim] = CAssetManager::GetInstance()->GetAnimation("MinotaurRun");
m_cpAnimations[eTellAnim] = CAssetManager::GetInstance()->GetAnimation("MinotaurTell");
m_cpAnimations[eChargeAnim] = CAssetManager::GetInstance()->GetAnimation("MinotaurCharge");
m_cpAnimations[eStompAnim] = CAssetManager::GetInstance()->GetAnimation("MinotaurStomp");
m_cpAnimations[eDeathAnim] = CAssetManager::GetInstance()->GetAnimation("MinotaurDeath");
m_cpAnimations[eEnrageAnim] = CAssetManager::GetInstance()->GetAnimation("MinotaurEnrage");
m_cpAnimations[eStunnedAnim] = CAssetManager::GetInstance()->GetAnimation("MinotaurHurt");
for (unsigned int animation = 0; animation < eAnimCount; animation++)
{
m_cpAnimations[animation].SetAnimMesh((CAnimationMesh*)m_cpRenderMesh);
}
//m_cpAnimationManager->AddAnimation(&m_cpAnimations[eRunAnim]);
/*m_cpAnimationManager->AddAnimation(&m_cpAnimations[eWalkAnim]);
m_cpAnimationManager->AddAnimation(&m_cpAnimations[eRunAnim]);
m_cpAnimationManager->AddAnimation(&m_cpAnimations[eStompAnim]);*/
CCapsule* pCapsule = new CCapsule(XMFLOAT3(spawnPosition.x, 90.0f, spawnPosition.z), XMFLOAT3(spawnPosition.x, 250.0f, spawnPosition.z), 90.0f);
CCollider* pCapCollider = new CCollider(true, pCapsule, true, false);
CCollider* pBoxCollider = new CCollider(true, new CAABB(float3(spawnPosition.x, 250.0f, spawnPosition.z), float3(250.0f, 250.0f, 250.0f)), false, false);
CCollider* pZoneCollider = new CCollider(true, new CAABB(float3(spawnPosition.x, 250.0f, spawnPosition.z), float3(2500.0f, 250.0f, 2500.0f)), true, false);
m_pMinotaurZone = new CMinotaurZone();
m_pMinotaurZone->AddCollider(pZoneCollider);
pBoxCollider->GetBounds()->UpdatePosition(spawnPosition);
AddCollider(pBoxCollider);
AddCollider(pCapCollider);
m_pParticleManager = new CParticleManager(_manager);
m_unParticleEmitters[eBloodParticle] = m_pParticleManager->LoadEmitter("BloodDrop.xml");
m_unParticleEmitters[eBloodString] = m_pParticleManager->LoadEmitter("BloodString.xml");
m_unParticleEmitters[eBloodMist] = m_pParticleManager->LoadEmitter("BloodMist.xml");
m_unParticleEmitters[eBloodMist2] = m_pParticleManager->LoadEmitter("BloodMist.xml");
m_unParticleEmitters[eStompDustOut] = m_pParticleManager->LoadEmitter("MinotaurStompDust1.xml");
m_unParticleEmitters[eStompDustUp] = m_pParticleManager->LoadEmitter("MinotaurStompDust2.xml");
m_unParticleEmitters[eStepDust] = m_pParticleManager->LoadEmitter("MinoStepDust.xml");
m_unParticleEmitters[eChargeParticle] = m_pParticleManager->LoadEmitter("MinoCharge.xml");
m_pParticleManager->GetEmitter(m_unParticleEmitters[eChargeParticle])->GetParent() = this;
m_pParticleManager->GetEmitter(m_unParticleEmitters[eChargeParticle])->Stop();
m_pStates[ePatrolState] = new CMinotaurPatrol;
m_pStates[eHostileState] = new CMinotaurHostile;
m_pStates[eDeadState] = new CMinotaurDead;
m_unCurrAnim = -1;
m_nCurrState = ePatrolState;
//Activate();
}
