BTH/squidout
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Files
965cebf708ffb7e058dc46f4300d5fb2492c5ae6
squidout/src/game/Game/KrakenSystem.cpp
T

518 lines
15 KiB
C++
Raw Blame History

//
// Created by Adniklastrator on 2015-10-15.
//
#include "PrecompiledHeader.h"
#include "Game/KrakenSystem.h"
void dd::Systems::KrakenSystem::Initialize()
{
std::random_device rd;
m_RandomGenerator = std::mt19937(rd());
EVENT_SUBSCRIBE_MEMBER(m_EPause, &KrakenSystem::OnPause);
EVENT_SUBSCRIBE_MEMBER(m_EResume, &KrakenSystem::OnResume);
EVENT_SUBSCRIBE_MEMBER(m_EContact, &KrakenSystem::OnContact);
EVENT_SUBSCRIBE_MEMBER(m_EKrakenAppear, &KrakenSystem::OnKrakenAppear);
EVENT_SUBSCRIBE_MEMBER(m_EKrakenAttack, &KrakenSystem::OnKrakenAttack);
EVENT_SUBSCRIBE_MEMBER(m_EKrakenHit, &KrakenSystem::OnKrakenHit);
EVENT_SUBSCRIBE_MEMBER(m_EKrakenDefeated, &KrakenSystem::OnKrakenDefeated);
EVENT_SUBSCRIBE_MEMBER(m_EBrickGenerating, &KrakenSystem::OnBrickGenerating);
EVENT_SUBSCRIBE_MEMBER(m_EArrivedAtNewStage, &KrakenSystem::OnArrivedAtNewStage);
EntityID ent = m_World->CreateEntity();
auto transform = m_World->AddComponent<Components::Transform>(ent);
transform->Position = glm::vec3(50, 50, -10);
auto model = m_World->AddComponent<Components::Model>(ent);
model->ModelFile = "Models/Kraken/Body.dae";
auto animationComponent = m_World->AddComponent<Components::Animation>(ent);
animationComponent->Speed = 0.6f;
auto kraken = m_World->AddComponent<Components::Kraken>(ent);
std::shared_ptr<Components::RectangleShape> cRect = m_World->AddComponent<Components::RectangleShape>(ent);
cRect->Dimensions = glm::vec2(10.f, 4.f);
//cCircle->Radius = 2;
std::shared_ptr<Components::Physics> cPhys = m_World->AddComponent<Components::Physics>(ent);
cPhys->CollisionType = CollisionType::Type::Static;
cPhys->GravityScale = 0.f;
cPhys->Category = CollisionLayer::Type::Brick;
cPhys->Mask = static_cast<CollisionLayer::Type>(CollisionLayer::Type::Ball | CollisionLayer::Type::Projectile | CollisionLayer::Type::Wall | CollisionLayer::LifeBuoy);
std::shared_ptr<Components::Template> cTemplate = m_World->AddComponent<Components::Template>(ent);
auto travels = m_World->AddComponent<Components::Travels>(ent);
travels->CurrentlyTraveling = false;
//sound
auto collisionSound = m_World->AddComponent<Components::CollisionSound>(ent);
collisionSound->FilePath = "Sounds/Boss/boss-hit.wav";
m_World->CommitEntity(ent);
m_KrakenTemplate = ent;
InitializeObjects();
}
void dd::Systems::KrakenSystem::InitializeObjects()
{
}
void dd::Systems::KrakenSystem::Update(double dt)
{
if (m_Pause) {
return;
}
}
void dd::Systems::KrakenSystem::UpdateEntity(double dt, EntityID entity, EntityID parent)
{
auto kraken = m_World->GetComponent<Components::Kraken>(entity);
if (kraken != nullptr) {
if (kraken->Health < 0) {
auto transform = m_World->GetComponent<Components::Transform>(entity);
transform->Position.y += kraken->RetreatSpeed * dt;
kraken->RetreatSpeed += 0.05;
return;
}
}
if (IsPaused() || !m_KrakenBattle) {
return;
}
auto templateCheck = m_World->GetComponent<Components::Template>(entity);
if (templateCheck != nullptr){ return; }
if (kraken != nullptr) {
auto transform = m_World->GetComponent<Components::Transform>(entity);
if (transform->Position.y < -10) {
m_World->RemoveEntity(entity);
return;
}
Events::KrakenAttack krakenAttack;
switch (kraken->CurrentAction) {
case 1: // Idle
if (m_RandomKraken) {
m_KrakenTimer += dt;
}
if (m_KrakenTimer > m_KrakenCurrentSecondsToAction) {
m_KrakenTimer = 0;
kraken->CurrentAction = 3;
if (m_NumberOfActions == 0) {
kraken->CurrentAction = 3;
} else {
std::uniform_real_distribution<float> dist(1, 4.999f);
float random = dist(m_RandomGenerator);
//std::cout << random << std::endl;
kraken->CurrentAction = random;
//std::cout << kraken->CurrentAction << std::endl;
}
}
break;
case 2: // Grabbing
m_NumberOfActions++;
kraken->CurrentAction = 3;
/*krakenAttack.ChargeUpdate = 0;
krakenAttack.KrakenStrength = 0.1;
krakenAttack.PlayerStrength = 0.05;
EventBroker->Publish(krakenAttack);*/
break;
case 3: // Brick Generating
{
m_NumberOfActions++;
kraken->CurrentAction = 1;
Events::BrickGenerating e;
e.Origin1 = glm::vec3(-5, 7, -10);
e.Origin2 = glm::vec3(5, 7, -10);
e.Speed = 10;
if (m_RandomKraken) {
if (kraken->Health > 20) {
e.SetCluster = 0;
} else if (kraken->Health > 10) {
e.SetCluster = 1;
} else {
e.SetCluster = 2;
}
std::uniform_real_distribution<float> dist(1, 6.999f);
float random = dist(m_RandomGenerator);
e.Set = random;
} else {
e.Set = m_Set;
e.SetCluster = m_SetCluster;
m_Set++;
if (m_Set > 6) {
m_SetCluster++;
m_Set = 1;
}
}
EventBroker->Publish(e);
break;
}
case 4: // Brick Generating second case
{
m_NumberOfActions++;
kraken->CurrentAction = 1;
Events::BrickGenerating e;
e.Origin1 = glm::vec3(-5, 7, -10);
e.Origin2 = glm::vec3(5, 7, -10);
e.Speed = 10;
if (m_RandomKraken) {
if (kraken->Health > 20) {
e.SetCluster = 0;
} else if (kraken->Health > 10) {
e.SetCluster = 1;
} else {
e.SetCluster = 2;
}
std::uniform_real_distribution<float> dist(1, 6.999f);
float random = dist(m_RandomGenerator);
e.Set = random;
} else {
e.Set = m_Set;
e.SetCluster = m_SetCluster;
m_Set++;
if (m_Set > 6) {
m_SetCluster++;
m_Set = 1;
}
}
EventBroker->Publish(e);
break;
}
case 5: // Taunting
if (m_ReturnToIdle) {
m_ReturnToIdle = false;
kraken->CurrentAction = Idle;
}
break;
default:
//LOG_INFO("Something's probably off about the random number generator.");
break;
}
}
}
bool dd::Systems::KrakenSystem::OnPause(const dd::Events::Pause &event)
{
/*if (event.Type != "KrakenSystem" && event.Type != "All") {
return false;
}*/
m_Pause = true;
return true;
}
bool dd::Systems::KrakenSystem::OnResume(const dd::Events::Resume &event)
{
/*if (event.Type != "KrakenSystem" && event.Type != "All") {
return false;
}*/
m_Pause = false;
return true;
}
bool dd::Systems::KrakenSystem::OnContact(const dd::Events::Contact &event)
{
Components::Kraken* kraken1 = m_World->GetComponent<Components::Kraken>(event.Entity1);
Components::Kraken* kraken2 = m_World->GetComponent<Components::Kraken>(event.Entity2);
Components::Kraken* kraken;
if (kraken1 != nullptr && kraken2 != nullptr) {
return false;
}
EntityID krakenEntity, otherEntitiy;
//Which is the ball?
if (kraken1 != nullptr) {
krakenEntity = event.Entity1;
otherEntitiy = event.Entity2;
kraken = kraken1;
}
else if (kraken2 != nullptr) {
krakenEntity = event.Entity2;
otherEntitiy = event.Entity1;
kraken = kraken2;
}
else {
return false;
}
auto projectile = m_World->GetComponent<Components::Projectile>(otherEntitiy);
if (projectile != nullptr) {
Events::ScoreEvent es;
es.Score = 23;
EventBroker->Publish(es);
Events::KrakenHit e;
e.Kraken = krakenEntity;
e.Hitter = otherEntitiy;
e.MaxHealth = kraken->MaxHealth;
e.CurrentHealth = kraken->Health;
e.NewHealth = kraken->Health - 1;
EventBroker->Publish(e);
m_World->RemoveEntity(otherEntitiy);
return true;
}
auto ball = m_World->GetComponent<Components::Ball>(otherEntitiy);
if (ball != nullptr) {
ball->Combo += 1;
Events::ComboEvent ec;
ec.Combo = ball->Combo;
ec.Ball = otherEntitiy;
EventBroker->Publish(ec);
Events::ScoreEvent es;
es.Score = ball->Combo * 23;
EventBroker->Publish(es);
Events::KrakenHit e;
e.Kraken = krakenEntity;
e.Hitter = otherEntitiy;
e.MaxHealth = kraken->MaxHealth;
e.CurrentHealth = kraken->Health;
e.NewHealth = kraken->Health - 1;
EventBroker->Publish(e);
}
return true;
}
bool dd::Systems::KrakenSystem::OnKrakenAppear(const dd::Events::KrakenAppear &event)
{
auto ent = m_World->CloneEntity(m_KrakenTemplate);
m_World->RemoveComponent<Components::Template>(ent);
auto transform = m_World->GetComponent<Components::Transform>(ent);
transform->Position = event.Position;
transform->Position.y += 3.f;
m_KrakenBattle = true;
Events::ScreenShake e;
e.Intensity = 10;
e.Time = 2;
e.TimeTakenToCoolDown = 6;
EventBroker->Publish(e);
return true;
}
bool dd::Systems::KrakenSystem::OnKrakenAttack(const dd::Events::KrakenAttack &event)
{
if (event.ChargeUpdate >= 1) {
m_ReturnToIdle = true;
}
Events::ScreenShake e;
e.Intensity = 2;
e.Time = 0.5f;
e.TimeTakenToCoolDown = 3.f;
EventBroker->Publish(e);
return true;
}
bool dd::Systems::KrakenSystem::OnKrakenHit(const dd::Events::KrakenHit &event)
{
auto kraken = m_World->GetComponent<Components::Kraken>(event.Kraken);
auto transform = m_World->GetComponent<Components::Transform>(event.Hitter);
kraken->Health--;
kraken->CurrentAction = 3;
//kraken->Health -= 15;
//kraken->Health = -1; //To defeat the kraken instantly.
auto model = m_World->GetComponent<Components::Model>(event.Kraken);
float modifier = ((float)kraken->MaxHealth - (float)kraken->Health) / (float)kraken->MaxHealth; // 1 is almost no life left, 0 is max life left.
//std::cout << modifier << std::endl;
model->Color = glm::vec4(1, 1 - modifier, 1 - modifier, 1);
int timeDifferenceBetweenMaxAndMin = m_KrakenMaxSecondsToAction - m_KrakenMinSecondsToAction;
m_KrakenCurrentSecondsToAction = m_KrakenMaxSecondsToAction - (modifier * timeDifferenceBetweenMaxAndMin);
// If modifier is 1, MaxSeconds is 15, MinSeconds is 5, then... 15 - (1 * 10), meaning 5.
CreateBloodEffect(transform->Position);
//std::cout << kraken->Health << std::endl;
//kraken->Health = -1;
if (kraken->Health < 0) {
Events::KrakenDefeated e;
e.Kraken = event.Kraken;
e.Hitter = event.Hitter;
EventBroker->Publish(e);
}
Events::ScreenShake e;
e.Intensity = 2;
e.Time = 0.2f;
e.TimeTakenToCoolDown = 1.5f;
EventBroker->Publish(e);
return false;
}
bool dd::Systems::KrakenSystem::OnKrakenDefeated(const dd::Events::KrakenDefeated &event)
{
m_KrakenBattle = false;
m_Set = 0;
m_SetCluster = 0;
auto kraken = m_World->GetComponent<Components::Kraken>(event.Kraken);
auto physicsComponent = m_World->GetComponent<Components::Physics>(event.Kraken);
m_World->RemoveComponent<Components::Travels>(event.Kraken);
/*physicsComponent->CollisionType = CollisionType::Type::Dynamic;
physicsComponent->GravityScale = 1.f;*/
physicsComponent->Mask = static_cast<CollisionLayer::Type>(CollisionLayer::Water | CollisionLayer::Wall);
/*physicsComponent->Calculate = false;*/
auto transformComponentBrick = m_World->GetComponent<Components::Transform>(event.Kraken);
auto transformComponentHitter = m_World->GetComponent<Components::Transform>(event.Hitter);
auto brickModel = m_World->GetComponent<Components::Model>(event.Kraken);
auto cTransform = m_World->GetComponent<Components::Transform>(event.Kraken);
/*cTransform->Position = cTransform->Position + transformComponentBrick->Position;
glm::vec2 ballToBrick = 4.f * glm::normalize(glm::vec2(cTransform->Position.x - transformComponentHitter->Position.x, cTransform->Position.y - transformComponentHitter->Position.y));
cTransform->Velocity = glm::vec3(ballToBrick.x, ballToBrick.y, 0.f);
std::uniform_real_distribution<float> dist(-1.5f, 1.5f);
int impulseStrength = dist(m_RandomGenerator);
Events::SetImpulse i;
i.Entity = event.Kraken;
i.Impulse = glm::vec2(impulseStrength, 0.f);
i.Point = glm::vec2(cTransform->Position.x, cTransform->Position.y + 0.5f);
EventBroker->Publish(i);*/
auto cModel = m_World->GetComponent<Components::Model>(event.Kraken);
cModel->Color = glm::vec4(1, 1, 1, 1);
cModel->Color *= 0.3f;
/*m_World->RemoveComponent<Components::Template>(event.Kraken);
m_World->SetEntityParent(event.Kraken, 0);
m_World->CommitEntity(event.Kraken);*/
//Particle trail
Events::CreateParticleSequence trail;
trail.parent = event.Kraken;
trail.AlphaValues.push_back(1.f);
trail.AlphaValues.push_back(0.f);
trail.ScaleValues.push_back(glm::vec3(0.08f));
trail.ScaleValues.push_back(glm::vec3(0.f));
trail.RadiusDistribution = 1;
trail.EmitterLifeTime = 2.f;
trail.ParticleLifeTime = 1.f;
trail.ParticlesPerTick = 1;
trail.SpawnRate = 0.1f;
trail.Speed = 10.f;
trail.EmittingAngle = glm::half_pi<float>();
trail.SpriteFile = "Textures/Particles/FadeBall.png";
trail.Color = brickModel->Color;
//p.Spread = ...
EventBroker->Publish(trail);
//ParticlePoof
Events::CreateParticleSequence poof;
poof.EmitterLifeTime = 4;
poof.EmittingAngle = glm::half_pi<float>();
poof.Spread = 0.5f;
poof.NumberOfTicks = 1;
poof.ParticleLifeTime = 1.5f;
poof.ParticlesPerTick = 1;
poof.Position = cTransform->Position;
poof.ScaleValues.clear();
poof.ScaleValues.push_back(glm::vec3(0.5f));
poof.ScaleValues.push_back(glm::vec3(2.f, 2.f, 0.2f));
poof.SpriteFile = "Textures/Particles/Cloud_Particle.png";
poof.Color = brickModel->Color;
poof.AlphaValues.clear();
poof.AlphaValues.push_back(1.f);
poof.AlphaValues.push_back(0.f);
poof.Speed = 10;
EventBroker->Publish(poof);
return true;
}
bool dd::Systems::KrakenSystem::OnBrickGenerating(const dd::Events::BrickGenerating &event)
{
return true;
}
bool dd::Systems::KrakenSystem::OnArrivedAtNewStage(const dd::Events::ArrivedAtNewStage &event)
{
if (m_KrakenBattle) {
m_KrakenHasArrived = true;
}
return true;
}
void dd::Systems::KrakenSystem::CreateBloodEffect(glm::vec3 pos)
{
//ParticlePoof
Events::CreateParticleSequence dust;
dust.EmitterLifeTime = 4;
dust.EmittingAngle = glm::half_pi<float>();
dust.Spread = 0.5f;
dust.NumberOfTicks = 1;
dust.ParticleLifeTime = 1.f;
dust.ParticlesPerTick = 1;
dust.Position = pos;
dust.ScaleValues.clear();
dust.ScaleValues.push_back(glm::vec3(0.5f));
dust.ScaleValues.push_back(glm::vec3(2.f, 2.f, 0.2f));
dust.SpriteFile = "Textures/Particles/Cloud_Particle.png";
dust.Color = glm::vec4(1, 0, 0, 1);
dust.AlphaValues.clear();
dust.AlphaValues.push_back(1.f);
dust.AlphaValues.push_back(0.f);
dust.Speed = 20;
EventBroker->Publish(dust);
std::uniform_real_distribution<float> dist(glm::pi<float>(), glm::two_pi<float>());
for (int i = 0; i < 3; i++) {
float angle = dist(m_RandomGenerator);
Events::CreateParticleSequence squirt;
squirt.EmitterLifeTime = 0.3f;
squirt.EmittingAngle = angle;
squirt.Spread = 0;
squirt.SpawnRate = 0.01f;
squirt.ParticleLifeTime = 0.5f;
squirt.ParticlesPerTick = 1;
squirt.Position = pos;
squirt.ScaleValues.clear();
squirt.ScaleValues.push_back(glm::vec3(0.09f));
squirt.SpriteFile = "Textures/Particles/FadeBall.png";
squirt.Color = glm::vec4(1, 0, 0, 1);
squirt.AlphaValues.clear();
squirt.AlphaValues.push_back(1.f);
squirt.AlphaValues.push_back(0.f);
squirt.Speed = 1000;
EventBroker->Publish(squirt);
}
Events::CreateParticleSequence drop;
drop.EmitterLifeTime = 7.f;
drop.SpawnRate = 0.1f;
//drop.EmittingAngle = glm::two_pi<float>() + glm::pi<float>();
drop.EmittingAngle = -glm::half_pi<float>();
drop.Spread = 0;
//drop.Spread = glm::two_pi<float>();
drop.ParticleLifeTime = 1.f;
drop.ParticlesPerTick = 2;
drop.Position = pos;
drop.ScaleValues.clear();
drop.ScaleValues.push_back(glm::vec3(.15f));
drop.ScaleValues.push_back(glm::vec3(0.1f));
drop.SpriteFile = "Textures/Particles/FadeBall.png";
drop.Color = glm::vec4(1, 0, 0, 1);
drop.AlphaValues.clear();
drop.AlphaValues.push_back(1.f);
drop.AlphaValues.push_back(0.f);
drop.GravityScale = 0;
drop.Speed = 300;
EventBroker->Publish(drop);
}
Reference in New Issue View Git Blame Copy Permalink