BTH/squidout
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Merge remote-tracking branch 'origin/LevelSystemAndSuch' into water

Browse Source
This commit is contained in:
Stiffly
2015-10-22 16:27:42 +02:00
parent 7c2782fe2c f54af2a240
commit 33e5ab9a22
46 changed files with 25342 additions and 2084 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/game/Core/ResourceManager.cpp
+84
View File
@@ -19,10 +19,12 @@
#include "PrecompiledHeader.h"
#include "Core/ResourceManager.h"
std::unordered_map<std::string, std::string> dd::ResourceManager::m_CompilerTypenameToResourceType;
std::unordered_map<std::string, std::function<dd::Resource*(std::string)>> dd::ResourceManager::m_FactoryFunctions;
std::unordered_map<std::pair<std::string, std::string>, dd::Resource*> dd::ResourceManager::m_ResourceCache;
std::unordered_map<std::string, dd::Resource*> dd::ResourceManager::m_ResourceFromName;
std::unordered_map<dd::Resource*, dd::Resource*> dd::ResourceManager::m_ResourceParents;
std::set<std::pair<std::string, std::string>> dd::ResourceManager::m_Preloads; // (type, name)
unsigned int dd::ResourceManager::m_CurrentResourceTypeID = 0;
std::unordered_map<std::string, unsigned int> dd::ResourceManager::m_ResourceTypeIDs;
std::unordered_map<unsigned int, unsigned int> dd::ResourceManager::m_ResourceCount;
@@ -82,4 +84,86 @@ void dd::ResourceManager::fileWatcherCallback(std::string path, FileWatcher::Fil
void dd::ResourceManager::Update()
{
m_FileWatcher.Check();
}
void dd::ResourceManager::LoadPreloadsFromFile()
{
std::ifstream f("PreloadResources");
while (f.good()) {
std::string resourceType;
std::string resourceName;
f >> resourceType >> resourceName;
if (!resourceType.empty() && !resourceType.empty()) {
m_Preloads.insert(std::make_pair(resourceType, resourceName));
}
}
f.close();
}
void dd::ResourceManager::Preload(std::string resourceType, std::string resourceName)
{
if (IsResourceLoaded(resourceType, resourceName))
{
//LOG_WARNING("Attempted to preload resource \"%s\" multiple times!", resourceName.c_str());
return;
}
m_Preloading = true;
LOG_INFO("Preloading resource \"%s\"", resourceName.c_str());
CreateResource(resourceType, resourceName, nullptr);
m_Preloading = false;
}
dd::Resource* dd::ResourceManager::Load(std::string resourceType, std::string resourceName, dd::Resource* parent /*= nullptr*/)
{
auto it = m_ResourceCache.find(std::make_pair(resourceType, resourceName));
if (it != m_ResourceCache.end())
return it->second;
if (m_Preloading) {
LOG_INFO("Preloading resource \"%s\"", resourceName.c_str());
} else {
LOG_WARNING("Hot-loading resource \"%s\"", resourceName.c_str());
if (!resourceType.empty() && !resourceName.empty()) {
std::replace(resourceName.begin(), resourceName.end(), '\\', '/');
if (m_Preloads.find(std::make_pair(resourceType, resourceName)) == m_Preloads.end()) {
std::ofstream f("PreloadResources", std::ofstream::app);
f << resourceType << " " << resourceName << std::endl;
f.close();
m_Preloads.insert(std::make_pair(resourceType, resourceName));
}
}
}
return CreateResource(resourceType, resourceName, parent);
}
dd::Resource* dd::ResourceManager::CreateResource(std::string resourceType, std::string resourceName, dd::Resource* parent)
{
auto facIt = m_FactoryFunctions.find(resourceType);
if (facIt == m_FactoryFunctions.end())
{
LOG_ERROR("Failed to load resource \"%s\" of type \"%s\": type not registered", resourceName.c_str(), resourceType.c_str());
return nullptr;
}
// Call the factory function
Resource* resource = facIt->second(resourceName);
// Store IDs
resource->TypeID = GetTypeID(resourceType);
resource->ResourceID = GetNewResourceID(resource->TypeID);
// Cache
m_ResourceCache[std::make_pair(resourceType, resourceName)] = resource;
m_ResourceFromName[resourceName] = resource;
if (parent != nullptr)
{
m_ResourceParents[resource] = parent;
}
if (!boost::filesystem::is_directory(resourceName))
{
LOG_DEBUG("Adding watch for %s", resourceName.c_str());
m_FileWatcher.AddWatch(resourceName, fileWatcherCallback);
}
return resource;
}
src/game/Game/BallSystem.cpp
+516 -574
View File
File diff suppressed because it is too large Load Diff
src/game/Game/KrakenSystem.cpp
+23 -17
View File
@@ -20,31 +20,36 @@ void dd::Systems::KrakenSystem::Initialize()
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> cCircle = m_World->AddComponent<Components::RectangleShape>(ent);
cCircle->Dimensions = glm::vec2(2, 4);
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);
std::shared_ptr<Components::Template> cTemplate = m_World->AddComponent<Components::Template>(ent);
auto travels = m_World->AddComponent<Components::Travels>(ent);
travels->CurrentlyTraveling = false;
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);
model->ModelFile = "Models/Test/Ball/Sid.obj";
transform->Position = glm::vec3(50, 50, -10);
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/Brick/LTTP_Boss_Hit.wav";
m_World->CommitEntity(ent);
m_KrakenTemplate = ent;
InitializeObjects();
}
@@ -82,16 +87,16 @@ void dd::Systems::KrakenSystem::UpdateEntity(double dt, EntityID entity, EntityI
case 1: // Idle
m_KrakenTimer += dt;
if (m_KrakenTimer > m_KrakenSecondsToAction) {
m_KrakenTimer = 0;
if (m_NumberOfActions == 0) {
kraken->CurrentAction = 3;
break;
} 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;
}
m_KrakenTimer = 0;
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
@@ -227,6 +232,7 @@ bool dd::Systems::KrakenSystem::OnKrakenAppear(const dd::Events::KrakenAppear &e
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;
return true;
}
src/game/Game/LevelSystem.cpp
+50 -31
View File
@@ -25,7 +25,7 @@ void dd::Systems::LevelSystem::Initialize()
EVENT_SUBSCRIBE_MEMBER(m_EBrickGenerating, &LevelSystem::OnBrickGenerating);
EVENT_SUBSCRIBE_MEMBER(m_EKrakenDefeated, &LevelSystem::OnKrakenDefeated);
m_GodMode = ResourceManager::Load<ConfigFile>("Config.ini")->GetValue("Cheat.GodMode", false);
m_GodMode = ResourceManager::Load<ConfigFile>("Config.ini")->GetValue<bool>("Cheat.GodMode", false);
//PointLightTest
{
@@ -61,8 +61,8 @@ void dd::Systems::LevelSystem::Initialize()
auto travels = m_World->AddComponent<Components::Travels>(t_halfPipe);
travels->CurrentlyTraveling = false;
auto model = m_World->AddComponent<Components::Model>(t_halfPipe);
model->ModelFile = "Models/Test/halfpipe/Halfpipe.obj";
model->Color = glm::vec4(0.8f, 0.8f, 0.8f, 1.f);
model->ModelFile = "Models/Halfpipe.obj";
//model->Color = glm::vec4(0.8f, 0.8f, 0.8f, 1.f);
m_World->CommitEntity(t_halfPipe);
auto t_halfPipe2 = m_World->CloneEntity(t_halfPipe);
@@ -240,6 +240,7 @@ void dd::Systems::LevelSystem::Initialize()
auto collisionSound = m_World->AddComponent<Components::CollisionSound>(m_BrickTemplate);
collisionSound->FilePath = "Sounds/Brick/shortbrickbreak.wav";
m_World->CommitEntity(m_BrickTemplate);
return;
}
@@ -278,18 +279,21 @@ void dd::Systems::LevelSystem::UpdateEntity(double dt, EntityID entity, EntityID
}
}
auto brickPart = m_World->GetComponent<Components::BrickPart>(entity);
if (brickPart != nullptr) {
auto transform = m_World->GetComponent<Components::Transform>(entity);
if (transform->Position.y < -10) {
m_World->RemoveEntity(entity);
return;
}
}
auto brick = m_World->GetComponent<Components::Brick>(entity);
if (brick != nullptr) {
auto transform = m_World->GetComponent<Components::Transform>(entity);
auto transform = m_World->GetComponent<Components::Transform>(entity);
if (brick->BeingGenerated) {
if (transform->Position == brick->GenerationGoal) {
brick->BeingGenerated = false;
auto cPhys = m_World->AddComponent<Components::Physics>(entity);
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);
}
}
//Removes bricks that falls out of the stage.
if (transform->Position.y < -10) {
if (brick->Type == StandardBrick) {
@@ -447,13 +451,15 @@ EntityID dd::Systems::LevelSystem::CreateBrick(int row, int line, glm::vec2 spac
auto type = m_World->AddComponent<Components::StickyBrick>(brick);
model->ModelFile = "Models/Brick/StickyBrick.obj";
} else if (typeInt == InkBlasterBrick) {
cBrick->Type = InkBlasterBrick;
cBrick->Type = InkBlasterBrick;
auto type = m_World->AddComponent<Components::InkBlasterBrick>(brick);
model->Color = glm::vec4(0.1f, 0.1f, 0.1f, 1.0f);
model->ModelFile = "Models/Brick/InkBrick.obj";
model->Color = glm::vec4(0.7f, 0.7f, 0.7f, 1.f);
} else if (typeInt == KrakenAttackBrick) {
cBrick->Type = KrakenAttackBrick;
auto type = m_World->AddComponent<Components::KrakenAttackBrick>(brick);
model->Color = glm::vec4(0.f, 0.5f, 1.0f, 1.0f);
model->ModelFile = "Models/Brick/KrakenBrick.obj";
} else if (typeInt == Kraken) {
Events::KrakenAppear e;
e.Position = transform->Position;
@@ -487,6 +493,8 @@ bool dd::Systems::LevelSystem::BrickGenerating(const dd::Events::BrickGenerating
auto ent = CreateBrick(i, j, SpaceBetweenBricks(), SpaceToEdge(), -3.2, 1, m_BrickSet[getter], m_ColorSet[getter]);
if (ent != NULL) {
auto brick = m_World->GetComponent<Components::Brick>(ent);
brick->BeingGenerated = true;
m_World->RemoveComponent<Components::Physics>(ent);
brick->Number = getter;
m_KrakenBricks[getter] = true;
auto transform = m_World->GetComponent<Components::Transform>(ent);
@@ -497,6 +505,7 @@ bool dd::Systems::LevelSystem::BrickGenerating(const dd::Events::BrickGenerating
} else {
transform->Position = event.Origin2;
}
brick->GenerationGoal = e.GoalPosition;
e.Entity = ent;
e.Speed = 6;
e.Queue = false;
@@ -696,7 +705,11 @@ bool dd::Systems::LevelSystem::OnContact(const dd::Events::Contact &event)
brick = m_World->GetComponent<Components::Brick>(entityBrick);
if (brick == nullptr) {
return false;
}
}
if (brick->BeingGenerated) {
return false;
}
if (entityShot != 0) {
// For when a brick gets shot.
@@ -1180,11 +1193,11 @@ void dd::Systems::LevelSystem::GetNextLevel()
else if (m_CurrentLevel == 6) {
level =
{0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 100, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0};
0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 100, 0, 0, 0 };
color =
{w, w, w, w, w, w, w,
w, w, w, w, w, w, w,
@@ -1216,40 +1229,45 @@ void dd::Systems::LevelSystem::SetBrokenModel(EntityID entity)
std::uniform_int_distribution<int> dist(0, 2);
int index = dist(m_RandomGenerator);
int parts = 0;
switch (index)
{
case 0:
CreateBrokenModelPart(entity, "Models/Brick/BrickBreak/1/WhiteBrickBreak1.obj", glm::vec3(-0.29912f, 0.0082f, 0.f), glm::vec2(0.281f, 0.351f));
CreateBrokenModelPart(entity, "Models/Brick/BrickBreak/1/WhiteBrickBreak2.obj", glm::vec3(0.07597f, -0.02899f, 0.f), glm::vec2(0.559f, 0.351f));
CreateBrokenModelPart(entity, "Models/Brick/BrickBreak/1/WhiteBrickBreak3.obj", glm::vec3(0.3227f, 0.05632, 0.f), glm::vec2(0.25f, 0.25f));
CreateBrokenModelPart(entity, "Models/Brick/BrickBreak/1/WhiteBrickBreak1.obj", glm::vec3(-0.29912f, 0.0082f, 0.f), glm::vec2(0.281f, 0.351f), 3);
CreateBrokenModelPart(entity, "Models/Brick/BrickBreak/1/WhiteBrickBreak2.obj", glm::vec3(0.07597f, -0.02899f, 0.f), glm::vec2(0.559f, 0.351f), 3);
CreateBrokenModelPart(entity, "Models/Brick/BrickBreak/1/WhiteBrickBreak3.obj", glm::vec3(0.3227f, 0.05632, 0.f), glm::vec2(0.25f, 0.25f), 3);
break;
case 1:
CreateBrokenModelPart(entity, "Models/Brick/BrickBreak/2/WhiteBrickBreak1.obj", glm::vec3(-0.3236f, 0.0159f, 0.f), glm::vec2(0.237f, 0.327f));
CreateBrokenModelPart(entity, "Models/Brick/BrickBreak/2/WhiteBrickBreak2.obj", glm::vec3(0.07645f, 0.03131f, 0.f), glm::vec2(0.594f, 0.211f));
CreateBrokenModelPart(entity, "Models/Brick/BrickBreak/2/WhiteBrickBreak3.obj", glm::vec3(0.09468f, -0.11792f, 0.f), glm::vec2(0.692f, 0.112f));
CreateBrokenModelPart(entity, "Models/Brick/BrickBreak/2/WhiteBrickBreak4.obj", glm::vec3(0.33957f, 0.13079f, 0.f), glm::vec2(0.208f, 0.085f));
CreateBrokenModelPart(entity, "Models/Brick/BrickBreak/2/WhiteBrickBreak1.obj", glm::vec3(-0.3236f, 0.0159f, 0.f), glm::vec2(0.237f, 0.327f), 4);
CreateBrokenModelPart(entity, "Models/Brick/BrickBreak/2/WhiteBrickBreak2.obj", glm::vec3(0.07645f, 0.03131f, 0.f), glm::vec2(0.594f, 0.211f), 4);
CreateBrokenModelPart(entity, "Models/Brick/BrickBreak/2/WhiteBrickBreak3.obj", glm::vec3(0.09468f, -0.11792f, 0.f), glm::vec2(0.692f, 0.112f), 4);
CreateBrokenModelPart(entity, "Models/Brick/BrickBreak/2/WhiteBrickBreak4.obj", glm::vec3(0.33957f, 0.13079f, 0.f), glm::vec2(0.208f, 0.085f), 4);
break;
case 2:
CreateBrokenModelPart(entity, "Models/Brick/BrickBreak/3/WhiteBrickBreak1.obj", glm::vec3(-0.34882f, 0.0564f, 0.f), glm::vec2(0.175f, 0.228f));
CreateBrokenModelPart(entity, "Models/Brick/BrickBreak/3/WhiteBrickBreak2.obj", glm::vec3(0.0678f, 0.07679f, 0.f), glm::vec2(0.699f, 0.183f));
CreateBrokenModelPart(entity, "Models/Brick/BrickBreak/3/WhiteBrickBreak3.obj", glm::vec3(-0.11862f, -0.10342, 0.f), glm::vec2(0.563f, 0.164f));
CreateBrokenModelPart(entity, "Models/Brick/BrickBreak/3/WhiteBrickBreak4.obj", glm::vec3(0.31479f, -0.06351f, 0.f), glm::vec2(0.261f, 0.21f));
CreateBrokenModelPart(entity, "Models/Brick/BrickBreak/3/WhiteBrickBreak1.obj", glm::vec3(-0.34882f, 0.0564f, 0.f), glm::vec2(0.175f, 0.228f), 4);
CreateBrokenModelPart(entity, "Models/Brick/BrickBreak/3/WhiteBrickBreak2.obj", glm::vec3(0.0678f, 0.07679f, 0.f), glm::vec2(0.699f, 0.183f), 4);
CreateBrokenModelPart(entity, "Models/Brick/BrickBreak/3/WhiteBrickBreak3.obj", glm::vec3(-0.11862f, -0.10342, 0.f), glm::vec2(0.563f, 0.164f), 4);
CreateBrokenModelPart(entity, "Models/Brick/BrickBreak/3/WhiteBrickBreak4.obj", glm::vec3(0.31479f, -0.06351f, 0.f), glm::vec2(0.261f, 0.21f), 4);
break;
default:
LOG_INFO("Something went wrong with the random generator in SetBrokenModel");
break;
}
return;
}
void dd::Systems::LevelSystem::CreateBrokenModelPart(EntityID Parent, std::string ModelPath, glm::vec3 RelativePosition, glm::vec2 Hitbox)
void dd::Systems::LevelSystem::CreateBrokenModelPart(EntityID Parent, std::string ModelPath, glm::vec3 RelativePosition, glm::vec2 Hitbox, int NumberOfParts)
{
auto ent = m_World->CreateEntity(Parent);
auto cTemplate = m_World->AddComponent<Components::Template>(ent);
auto cTransform = m_World->AddComponent<Components::Transform>(ent);
auto cBrickPart = m_World->AddComponent<Components::BrickPart>(ent);
cBrickPart->NumberOfPartsInBrick = NumberOfParts;
cTransform->Position = RelativePosition;
@@ -1262,6 +1280,7 @@ void dd::Systems::LevelSystem::CreateBrokenModelPart(EntityID Parent, std::strin
auto cPhys = m_World->AddComponent<Components::Physics>(ent);
cPhys->CollisionType = CollisionType::Type::Dynamic;
cPhys->GravityScale = 1.f;
cPhys->Density = 30;
cPhys->Category = CollisionLayer::Type::Brick;
cPhys->Mask = static_cast<CollisionLayer::Type>(CollisionLayer::Type::Wall);
}
src/game/Game/LevelSystem.cpp.orig
-1179
View File
File diff suppressed because it is too large Load Diff
src/game/Game/LifeSystem.cpp
+125
View File
@@ -0,0 +1,125 @@
//
// Created by Adniklastrator on 2015-10-13.
//
#include "PrecompiledHeader.h"
#include "Game/LifeSystem.h"
void dd::Systems::LifeSystem::Initialize()
{
EVENT_SUBSCRIBE_MEMBER(m_EPause, &LifeSystem::OnPause);
EVENT_SUBSCRIBE_MEMBER(m_EResume, &LifeSystem::OnResume);
EVENT_SUBSCRIBE_MEMBER(m_ELifeLost, &LifeSystem::OnLifeLost);
for (int i = 0; i < Lives(); i++) {
CreateLife(i);
}
m_GodMode = ResourceManager::Load<ConfigFile>("Config.ini")->GetValue<bool>("Cheat.GodMode", false);
}
void dd::Systems::LifeSystem::Update(double dt)
{
if (m_Pause) {
return;
}
if (Lives() < 0) {
Events::KrakenAttackEnd ek;
EventBroker->Publish(ek);
Events::GameOver e;
EventBroker->Publish(e);
Events::Pause p;
p.Type = "All";
EventBroker->Publish(p);
//TODO: Make this not so ugly
SetLives(3);
}
}
void dd::Systems::LifeSystem::UpdateEntity(double dt, EntityID entity, EntityID parent)
{
if (m_Pause) {
return;
}
auto templateCheck = m_World->GetComponent<Components::Template>(entity);
if (templateCheck != nullptr){ return; }
auto life = m_World->GetComponent<Components::Life>(entity);
if (life != nullptr) {
auto transform = m_World->GetComponent<Components::Transform>(entity);
if (life->Left) {
if (transform->Position.x > 3) {
life->Left = false;
transform->Velocity.x = m_LifeSpeed;
}
} else {
if (transform->Position.x < -3) {
life->Left = true;
transform->Velocity.x = -m_LifeSpeed;
}
}
transform->Position.x += transform->Velocity.x * dt;
/*glm::vec2 dir = glm::normalize(glm::vec2(transform->Velocity.x, transform->Velocity.y));
glm::vec2 up = glm::vec2(0.f, 1.f);
float angle = glm::acos(glm::dot<float>(dir, up)) * glm::sign(dir.x);
transform->Orientation = glm::rotate(glm::quat(), angle, glm::vec3(0.f, 0.f, -1.f));*/
if (Lives() != PastLives()) {
if (life->Number + 1 == PastLives()) {
m_World->RemoveEntity(entity);
SetPastLives(Lives());
}
}
}
}
void dd::Systems::LifeSystem::CreateLife(int number)
{
auto life = m_World->CreateEntity();
std::shared_ptr<Components::Transform> transform = m_World->AddComponent<Components::Transform>(life);
transform->Position = glm::vec3(-1.5f + number * 0.15f, -2.f, -5.f);
//transform->Position = glm::vec3(-1.5f + number * 1.5f, -3.f, -10.f);
transform->Scale = glm::vec3(0.1f, 0.1f, 0.1f);
//transform->Scale = glm::vec3(0.2f, 0.2f, 0.2f);
std::shared_ptr<Components::Life> lifeNr = m_World->AddComponent<Components::Life>(life);
lifeNr->Number = number;
auto model = m_World->AddComponent<Components::Model>(life);
model->ModelFile = "Models/Sid/Sid.dae";
auto anim = m_World->AddComponent<Components::Animation>(life);
anim->Speed = 0.f;
m_World->CommitEntity(life);
}
bool dd::Systems::LifeSystem::OnLifeLost(const dd::Events::LifeLost &event)
{
if (!m_GodMode){
SetLives(Lives() - 1);
return true;
}
return true;
}
bool dd::Systems::LifeSystem::OnPause(const dd::Events::Pause &event)
{
/*if (event.Type != "LifeSystem" && event.Type != "All") {
return false;
}*/
m_Pause = true;
return true;
}
bool dd::Systems::LifeSystem::OnResume(const dd::Events::Resume &event)
{
/*if (event.Type != "LifeSystem" && event.Type != "All") {
return false;
}*/
m_Pause = false;
return true;
}
src/game/Game/PadSystem.cpp
+37 -13
View File
@@ -44,7 +44,7 @@ void dd::Systems::PadSystem::Initialize()
auto ent = m_World->CreateEntity();
m_World->SetProperty(ent, "Name", "Pad");
auto ctransform = m_World->AddComponent<Components::Transform>(ent);
ctransform->Position = glm::vec3(0.f, -4.8f, -10.f);
ctransform->Position = glm::vec3(0.f, m_PadHeight, -10.f);
auto rectangleShape = m_World->AddComponent<Components::RectangleShape>(ent);
rectangleShape->Dimensions = glm::vec2(1.f, 0.1f);
auto physics = m_World->AddComponent<Components::Physics>(ent);
@@ -159,6 +159,13 @@ void dd::Systems::PadSystem::Update(double dt)
auto pad = Pad();
auto acceleration = Acceleration();
if (glm::abs(transform->Position.y - m_PadHeight) > m_PadRiseSpeed) {
if (transform->Position.y < m_PadHeight) {
transform->Position.y += m_PadRiseSpeed * (float)dt;
} else if (transform->Position.y > m_PadHeight) {
transform->Position.y -= m_PadRiseSpeed * 5 * (float)dt;
}
}
if (transform->Velocity.x < -pad->MaxSpeed) {
transform->Velocity.x = -pad->MaxSpeed;
}
@@ -420,6 +427,7 @@ bool dd::Systems::PadSystem::OnStageCleared(const dd::Events::StageCleared &even
{
//auto entity = CreateBall();
m_StickyAim->Aiming = false;
m_PadHeight = m_PadOriginalHeight;
return true;
}
@@ -451,14 +459,8 @@ bool dd::Systems::PadSystem::OnRaiseWaterWall(const dd::Events::RaiseWaterWall &
bool dd::Systems::PadSystem::RaisePad(float amount, float speed)
{
auto transform = Transform();
glm::vec3 raise = glm::vec3(0, amount, 0);
Events::Move e;
e.Entity = m_Entity;
e.GoalPosition = transform->Position + raise;
e.Speed = speed;
e.Queue = true;
EventBroker->Publish(e);
m_PadHeight += amount;
m_PadRiseSpeed = speed;
return true;
}
@@ -474,16 +476,36 @@ bool dd::Systems::PadSystem::OnKrakenAttack(const dd::Events::KrakenAttack &even
transform->Velocity = glm::vec3(0, 0, 0);
acceleration = glm::vec3(0, 0, 0);
LOG_INFO("Kraken arm duuude");
if (!m_KrakenArm){
LOG_INFO("InKrakenArmDuuude");
m_KrakenArm = m_World->CreateEntity(Entity());
auto transform = m_World->AddComponent<Components::Transform>(m_KrakenArm);
transform->Position = glm::vec3(1.f, -3.0f, 0.f);
auto model = m_World->AddComponent<Components::Model>(m_KrakenArm);
model->ModelFile = "Models/kraken/Arm.dae";
auto animation = m_World->AddComponent<Components::Animation>(m_KrakenArm);
animation->Speed = 1.0f;
model->ModelFile = "Models/Kraken/Arm.dae";
auto animation = m_World->AddComponent<Components::Animation>(m_KrakenArm);
animation->Speed = 1.0f;
animation->Loop = false;
m_World->CommitEntity(m_KrakenArm);
m_KrakenArmHitbox = m_World->CreateEntity();
auto hb_transform = m_World->AddComponent<Components::Transform>(m_KrakenArmHitbox);
hb_transform->Position = transform->Position + glm::vec3(-1.f, -5.0f, -10.f);
//hb_transform->Position = glm::vec3(-2.f, -8.0f, -10.f);
hb_transform->Scale = glm::vec3(2.5f, 2.5f, 1.f);
hb_transform->Velocity = glm::vec3(0.f, 10.f, 0.f);
//auto hb_sprite = m_World->AddComponent<Components::Sprite>(m_KrakenArmHitbox);
//hb_sprite->SpriteFile = "Textures/Core/ErrorTexture.png";
auto hb_physics = m_World->AddComponent<Components::Physics>(m_KrakenArmHitbox);
hb_physics->Calculate = true;
hb_physics->CollisionType = CollisionType::Type::Static;
hb_physics->Category = CollisionLayer::Type::Other;
hb_physics->Mask = CollisionLayer::Type::Water;
hb_physics->GravityScale = 0.f;
auto hb_HitBox = m_World->AddComponent<Components::CircleShape>(m_KrakenArmHitbox);
hb_HitBox->Radius = 1.25f;
m_World->CommitEntity(m_KrakenArmHitbox);
}
SetTransform(transform);
@@ -504,7 +526,9 @@ bool dd::Systems::PadSystem::OnKrakenAttackEnd(const dd::Events::KrakenAttackEnd
m_PlayerStrength = 0;
m_World->RemoveEntity(m_KrakenArm);
m_World->RemoveEntity(m_KrakenArmHitbox);
m_KrakenArm = NULL;
m_KrakenArmHitbox = NULL;
return true;
}
src/game/Game/WaterSystem.cpp
+54 -4
View File
@@ -14,6 +14,8 @@ void dd::Systems::WaterSystem::Initialize()
EVENT_SUBSCRIBE_MEMBER(m_ERaiseWater, &WaterSystem::OnRaiseWater);
EVENT_SUBSCRIBE_MEMBER(m_ERaiseWaterWall, &WaterSystem::OnRaiseWaterWall);
m_RaiseWater = ResourceManager::Load<ConfigFile>("Config.ini")->GetValue<bool>("Debug.RaiseWater", false);
//Water test
{
auto t_waterBody = m_World->CreateEntity();
@@ -24,6 +26,10 @@ void dd::Systems::WaterSystem::Initialize()
auto body = m_World->AddComponent<Components::RectangleShape>(t_waterBody);
m_World->CommitEntity(t_waterBody);
}
m_BrickPartCounters =
{0, 0, 0, 0, 0,
0, 0, 0, 0, 0 };
}
void dd::Systems::WaterSystem::Update(double dt)
@@ -43,6 +49,31 @@ void dd::Systems::WaterSystem::UpdateEntity(double dt, EntityID entity, EntityID
auto templateCheck = m_World->GetComponent<Components::Template>(entity);
if (templateCheck != nullptr){ return; }
auto brickPart = m_World->GetComponent<Components::BrickPart>(entity);
if (brickPart != nullptr) {
auto transform = m_World->GetComponent<Components::Transform>(entity);
if (m_RaiseWater) {
if (!brickPart->Submerged) {
if (transform->Position.y < m_SubmergedHeight) {
brickPart->Submerged = true;
m_BrickPartCounters[brickPart->NumberOfPartsInBrick]++;
std::cout << "Parts: " << m_BrickPartCounters[brickPart->NumberOfPartsInBrick] << " of " << brickPart->NumberOfPartsInBrick << std::endl;
if (m_BrickPartCounters[brickPart->NumberOfPartsInBrick] >= brickPart->NumberOfPartsInBrick) {
m_BrickPartCounters[brickPart->NumberOfPartsInBrick] = 0;
Events::RaiseWater e;
e.Amount = 0.2;
e.Speed = 0.2;
EventBroker->Publish(e);
}
}
}
}
if (transform->Position.y < -10) {
m_World->RemoveEntity(entity);
return;
}
}
if (m_BottomWall == 0) {
for (auto it = m_World->GetEntities()->begin(); it != m_World->GetEntities()->end(); it++) {
if (m_World->GetProperty<std::string>(it->first, "Name") == "BottomWall") {
@@ -51,6 +82,21 @@ void dd::Systems::WaterSystem::UpdateEntity(double dt, EntityID entity, EntityID
}
}
}
auto newWater = m_World->GetComponent<Components::NewWaterVolume>(entity);
if (newWater != nullptr) {
if (m_RemoveWater) {
//m_World->RemoveComponent<Components::WaterVolume>(entity);
//m_World->RemoveComponent<Components::RectangleShape>(entity);
//m_World->RemoveComponent<Components::WaterVolume>(entity);
//m_World->RemoveEntity(entity);
//m_World->RemoveComponent<Components::>();
}
/*auto transform = m_World->AddComponent<Components::Transform>(entity);
if (transform->Position.y < -10) {
m_World->RemoveEntity(entity);
}*/
}
}
bool dd::Systems::WaterSystem::OnPause(const dd::Events::Pause &event)
@@ -80,13 +126,14 @@ bool dd::Systems::WaterSystem::OnRelevantObjectCreated(const dd::Events::Relevan
bool dd::Systems::WaterSystem::OnStageCleared(const dd::Events::StageCleared &event)
{
m_SubmergedHeight = m_SubmergedOriginalHeight;
m_RemoveWater = true;
return true;
}
bool dd::Systems::WaterSystem::OnArrivedAtNewStage(const dd::Events::ArrivedAtNewStage &event)
{
m_RemoveWater = false;
return true;
}
@@ -95,13 +142,16 @@ bool dd::Systems::WaterSystem::OnRaiseWater(const dd::Events::RaiseWater &event)
{
auto t_waterBody = m_World->CreateEntity();
auto transform = m_World->AddComponent<Components::Transform>(t_waterBody);
transform->Position = glm::vec3(0.f, -3.5f, -10.f);
transform->Scale = glm::vec3(7.0f, event.Amount * 1.6f, 1.f);
transform->Position = glm::vec3(0.f, m_SubmergedHeight, -10.f);
transform->Scale = glm::vec3(7.0f, event.Amount * 1.4f, 1.f);
auto water = m_World->AddComponent<Components::WaterVolume>(t_waterBody);
auto newWater = m_World->AddComponent<Components::NewWaterVolume>(t_waterBody); //Meaning it isn't the original water we had.
auto body = m_World->AddComponent<Components::RectangleShape>(t_waterBody);
m_World->CommitEntity(t_waterBody);
}
m_SubmergedHeight += event.Amount;
return true;
}
src/game/Physics/PhysicsSystem.cpp
+1
View File
@@ -37,6 +37,7 @@ void dd::Systems::PhysicsSystem::InitializeWater()
m_ParticleSystemDef.radius = radius;
m_ParticleSystemDef.gravityScale = gravityScale;
m_ParticleSystemDef.density = 4.f;
m_ParticleSystemDef.surfaceTensionNormalStrength = 0.07;
m_WaterParticleSystem = m_PhysicsWorld->CreateParticleSystem(&m_ParticleSystemDef);
}
src/game/Rendering/OpenGL/Renderer.cpp
+4
View File
@@ -21,6 +21,10 @@
void dd::Renderer::Initialize()
{
ResourceManager::RegisterType<ShaderProgram>("ShaderProgram");
ResourceManager::RegisterType<VertexShader>("VertexShader");
ResourceManager::RegisterType<FragmentShader>("FragmentShader");
// Initialize GLFW
if (!glfwInit()) {
LOG_ERROR("GLFW: Initialization failed");