Merge remote-tracking branch 'origin/master'

Conflicts:
	src/game/Game/PadSystem.cpp

assets/DefaultConfig.ini

@@ -9,4 +9,4 @@ BGMVolume=0.5
 [Video]
 Fullscreen=false
 Width=675
-Height=1080[Water]Radius=0.3[Cheat]GodMode=false[Water]Radius=0.3[Cheat]GodMode=false
+Height=1080[Water]Radius=0.3[Cheat]GodMode=false

include/Game/CBall.h

@@ -24,6 +24,8 @@ struct Ball : Component
 	bool Sticky = false;
 	glm::vec3 StickyPlacement = glm::vec3(0, 0, 0);
     glm::vec3 SavedSpeed = glm::vec3(0, 1, 0);
+
+	int PosterBoy = 0;
 };
 
 }

include/Game/CBrick.h

@@ -20,6 +20,8 @@ struct Brick : Component
     int Type = 0;
     bool Removed = false;
 	int Number = 100; // For the Kraken to keep track of which bricks needs replacing.
+	bool BeingGenerated = false;
+	glm::vec3 GenerationGoal;
 
 	//What number of types each is.
 	const int EmptyBrickSpace = 0;

include/Game/CLife.h

@@ -13,10 +13,11 @@ namespace dd
 namespace Components
 {
 
-struct Life : Component {
+struct Life : Component 
-
+{
     int Number = 0;
-
+	float SinusAltitude = 1;
+	bool Left = false;
 };
 
 }

include/Game/LifeSystem.h

@@ -24,6 +24,8 @@
 #include "Game/EGameOver.h"
 #include "Game/EKrakenAttackEnd.h"
 
+#include "Rendering/CAnimation.h"
+
 
 namespace dd
 {
@@ -54,6 +56,7 @@ private:
 	bool m_Pause = false;
 	int m_Lives = 3;
 	int m_PastLives = 3;
+	float m_LifeSpeed = 0.8;
 
 	bool m_GodMode = false;
 

include/Game/PadSystem.h

@@ -72,29 +72,12 @@ public:
     void Update(double dt) override;
     void UpdateEntity(double dt, EntityID entity, EntityID parent) override;
 
-    EntityID& Entity() { return m_Entity; }
-    void SetEntity(const EntityID& ent) { m_Entity = ent; }
-    glm::vec3 Acceleration() const { return m_Acceleration; }
-    void SetAcceleration(const glm::vec3& acceleration) { m_Acceleration = acceleration; }
-
-    bool Left() const { return m_Left; }
-    void SetLeft(const bool& left) { m_Left = left; }
-    bool Right() const { return m_Right; }
-    void SetRight(const bool& right) { m_Right = right; }
-    float Edge() const { return m_Edge; }
-    void SetEdge(const float& edge) { m_Edge = edge; }
-
-    Components::Transform* Transform() const { return m_Transform; }
-    void SetTransform(Components::Transform* transform) { m_Transform = transform; }
-    Components::Pad* Pad() const { return m_Pad; }
-    void SetPad(Components::Pad* pad) { m_Pad = pad; }
-
     bool IsPaused() const { return m_Pause; }
     void SetPause(const bool& pause) { m_Pause = pause; }
 
 private:
-    EntityID m_Entity = 0;
+    EntityID m_PadEntity = 0;
-    glm::vec3 m_Acceleration = glm::vec3(0.f, 0.f, 0.f);
+    glm::vec3 m_PadAcceleration = glm::vec3(0.f, 0.f, 0.f);
     bool m_Left = false;
     bool m_Right = false;
     bool m_ReplaceBall = false;
@@ -110,8 +93,8 @@ private:
 	EntityID m_KrakenArm = 0;
 	EntityID m_KrakenArmHitbox = 0;
 	float m_PadRiseSpeed = 0.2;
-    Components::Transform* m_Transform = nullptr;
+    Components::Transform* m_PadTransform = nullptr;
-    Components::Pad* m_Pad = nullptr;
+    Components::Pad* m_PadComponent = nullptr;
 	std::shared_ptr<Components::Transform> m_StickTransform;
 	std::shared_ptr<Components::StickyAim> m_StickyAim;
 

include/Game/ProjectileSystem.h

@@ -5,6 +5,10 @@
 #ifndef DAYDREAM_PROJECTILESYSTEM_H
 #define DAYDREAM_PROJECTILESYSTEM_H
 
+
+#include <fstream>
+#include <iostream>
+
 #include "Core/System.h"
 #include "Core/CTransform.h"
 #include "Core/CTemplate.h"
@@ -26,8 +30,6 @@
 #include "Game/CProjectile.h"
 #include "Game/CBall.h"
 #include "Rendering/CSprite.h"
-#include <fstream>
-#include <iostream>
 
 namespace dd
 {

include/Physics/CParticleEmitter.h

@@ -22,7 +22,7 @@ struct ParticleEmitter : public Component
     float Speed = 2.f;
     double LifeTime = 100;
 	float RadiusDistribution = 0;
-
+	bool DefaultScale = false;
 	//values to interpolate between.
 	std::vector<glm::vec3> ScaleValues;
 	std::vector<float> AlphaValues;

include/Physics/ECreateParticleSequence.h

@@ -26,6 +26,7 @@ struct CreateParticleSequence : public Event
 	glm::vec4 Color = glm::vec4(0);
 	EntityID parent = 0;
 	// values to interpolate between.
+	bool DefaultScale = false;
 	std::vector<glm::vec3> ScaleValues;
 	std::vector<float> AlphaValues;
 

include/Physics/PhysicsSystem.h

@@ -14,6 +14,7 @@
 #include "Core/CTemplate.h"
 #include "Core/CTransform.h"
 #include "Core/CTemplate.h"
+#include "Rendering/Texture.h"
 
 #include "Physics/EContact.h"
 #include "Physics/ESetImpulse.h"

src/game/Game/BallSystem.cpp

@@ -64,6 +64,13 @@ void dd::Systems::BallSystem::Initialize()
         auto transform2 = m_World->GetComponent<Components::Transform>(ent2);
         transform2->Position = glm::vec3(-0.f, 0.26f, -10.f);
         transform2->Velocity = glm::vec3(0.0f, -10.f, 0.f);
+
+		/*auto PosterBoy = CreateBall();
+		auto PosterBall = m_World->GetComponent<Components::Ball>(PosterBoy);
+		PosterBall->PosterBoy = 1;
+		auto Postertran = m_World->GetComponent<Components::Transform>(PosterBoy);
+		Postertran->Position = glm::vec3(-3.f, -3.f, -10.f);
+		Postertran->Velocity = glm::vec3(0.0f, 0.f, 0.f);*/
     }
 
 	SetReplaceBall(true);
@@ -88,6 +95,11 @@ void dd::Systems::BallSystem::UpdateEntity(double dt, EntityID entity, EntityID
     if (templateCheck != nullptr){ return; }
 
     if (ballComponent != nullptr) {
+		auto transformBall = m_World->GetComponent<Components::Transform>(entity);
+		if (ballComponent->PosterBoy == 1) {
+			transformBall->Position = glm::vec3(-3, 3, -10);
+		}
+
 		if (ReplaceBall()) {
 			m_First = true;
 			SetReplaceBall(false);
@@ -97,24 +109,21 @@ void dd::Systems::BallSystem::UpdateEntity(double dt, EntityID entity, EntityID
 			ballComponent->SavedSpeed = glm::vec3(random, 1, 0.f);
 			//ballComponent->SavedSpeed = glm::vec3(0.f, 1, 0.f);
 			ballComponent->Waiting = true;
-			auto transform = m_World->GetComponent<Components::Transform>(entity);
 		}
 
         if (ballComponent->Waiting) {
             if (!m_Waiting) {
 				m_Restarting = false;
                 ballComponent->Waiting = false;
-				auto transform = m_World->GetComponent<Components::Transform>(entity);
 				/*std::uniform_real_distribution<float> dist(-0.5f, 0.5f);
 				float random = dist(m_RandomGenerator);*/
-                transform->Velocity = glm::normalize(ballComponent->SavedSpeed) * ballComponent->Speed;
+                transformBall->Velocity = glm::normalize(ballComponent->SavedSpeed) * ballComponent->Speed;
 				//transform->Velocity = glm::normalize(glm::vec3(0, 1, 0)) * ballComponent->Speed;
             } else if (!ballComponent->Sticky) {
-                auto transform = m_World->GetComponent<Components::Transform>(entity);
+                transformBall->Velocity = glm::vec3(0.f, 0.f, 0.f);
-                transform->Velocity = glm::vec3(0.f, 0.f, 0.f);
                 //transform->Position = glm::vec3(0.0f, -3.f, -10.f);
 				if (m_First) {
-					transform->Orientation = glm::quat();
+					transformBall->Orientation = glm::quat();
 					m_First = false;
 				}
                 return;
@@ -124,8 +133,7 @@ void dd::Systems::BallSystem::UpdateEntity(double dt, EntityID entity, EntityID
 			//TODO - Ball can stick to same pad just after detaching.
 			if (!m_Waiting)
 			{
-				auto transform = m_World->GetComponent<Components::Transform>(entity);
+				transformBall->Velocity = ballComponent->SavedSpeed;
-				transform->Velocity = ballComponent->SavedSpeed;
 				m_StickyCounter--;
 				if (m_StickyCounter > 0) {
 					m_Sticky = true;
@@ -134,7 +142,6 @@ void dd::Systems::BallSystem::UpdateEntity(double dt, EntityID entity, EntityID
 			}
 		}
         
-        auto transformBall = m_World->GetComponent<Components::Transform>(entity);
         if (glm::abs(transformBall->Velocity.y) < 2) {
             if (transformBall->Velocity.y > 0) {
                 transformBall->Velocity.y = 2;

src/game/Game/LevelSystem.cpp

@@ -281,7 +281,19 @@ void dd::Systems::LevelSystem::UpdateEntity(double dt, EntityID entity, EntityID
 
     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) {
@@ -317,7 +329,7 @@ void dd::Systems::LevelSystem::UpdateEntity(double dt, EntityID entity, EntityID
 
     auto ball = m_World->GetComponent<Components::Ball>(entity);
 
-    if (NumberOfBricks() <= 0 && m_LooseBricks <= 0 && !Restarting()) {
+    if (NumberOfBricks() <= 0 && m_LooseBricks <= 0 && !Restarting() && !m_Cleared) {
         if (MultiBalls() <= 0 && PowerUps() <= 0) {
             Events::StageCleared ec;
             ec.ClearedStage = m_CurrentLevel;
@@ -481,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);
@@ -491,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;
@@ -690,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.
@@ -1002,7 +1021,6 @@ void dd::Systems::LevelSystem::GetNextLevel()
 	glm::vec4 p3 = glm::vec4(189.f / 255.f, 0.f / 255.f, 187.f / 255.f, 1.f);
 	glm::vec4 p4 = glm::vec4(125.f / 255.f, 0.f / 255.f, 147.f / 255.f, 1.f);
 
-
     if (m_CurrentCluster == 0) {
         if (m_CurrentLevel == 1) {
             level =
@@ -1102,7 +1120,7 @@ void dd::Systems::LevelSystem::GetNextLevel()
                      1, 1, 1, 1, 1, 1, 1,
                      1, 0, 1, 2, 1, 0, 1,
                      0, 1, 0, 1, 0, 1, 0,
-                     0, 0, 0, 0, 0, 0, 6,
+                     0, 0, 0, 0, 0, 0, 0,
                      0, 0, 0, 0, 0, 0, 0};
 			color = 
 					{w, w, w, w, w, w, w,

src/game/Game/LifeSystem.cpp

@@ -47,10 +47,29 @@ void dd::Systems::LifeSystem::UpdateEntity(double dt, EntityID entity, EntityID
 
 	auto templateCheck = m_World->GetComponent<Components::Template>(entity);
 	if (templateCheck != nullptr){ return; }
+	auto life = m_World->GetComponent<Components::Life>(entity);
 
-	if (Lives() != PastLives()) {
+	
-		auto life = m_World->GetComponent<Components::Life>(entity);
+	if (life != nullptr) {
-		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());
@@ -64,7 +83,10 @@ 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);
+	transform->Velocity.x = m_LifeSpeed;*/
 
 	std::shared_ptr<Components::Life> lifeNr = m_World->AddComponent<Components::Life>(life);
 	lifeNr->Number = number;
@@ -72,6 +94,8 @@ void dd::Systems::LifeSystem::CreateLife(int 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);
 }
 
@@ -81,7 +105,7 @@ bool dd::Systems::LifeSystem::OnLifeLost(const dd::Events::LifeLost &event)
 		SetLives(Lives() - 1);
 		return true;
 	}
-	return false;
+	return true;
 }
 
 bool dd::Systems::LifeSystem::OnPause(const dd::Events::Pause &event)

src/game/Game/PadSystem.cpp

@@ -58,10 +58,11 @@ void dd::Systems::PadSystem::Initialize()
         auto pad = m_World->AddComponent<Components::Pad>(ent);
         m_World->CommitEntity(ent);
 
-        SetEdge(3.2 - (ctransform->Scale.x / 2));
+        m_Edge = 3.2 - (ctransform->Scale.x / 2);
-		SetEntity(ent);
+		
-		SetTransform(m_World->GetComponent<Components::Transform>(Entity()));
+		m_PadEntity = ent;
-		SetPad(m_World->GetComponent<Components::Pad>(Entity()));
+		m_PadTransform = ctransform.get();
+		m_PadComponent = pad.get();
     }
 
 	//Stick
@@ -94,7 +95,7 @@ void dd::Systems::PadSystem::Initialize()
 
 	// Kraken arm
 	{
-		m_KrakenArm = m_World->CreateEntity(Entity());
+		m_KrakenArm = m_World->CreateEntity(m_PadEntity);
 		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);
@@ -126,7 +127,7 @@ void dd::Systems::PadSystem::UpdateEntity(double dt, EntityID entity, EntityID p
 				m_ResetBall = false;
 			}
 			auto ballTransform = m_World->GetComponent<Components::Transform>(entity);
-			ballTransform->Position = Transform()->Position;
+			ballTransform->Position = m_PadTransform->Position;
 			ballTransform->Position += ball->StickyPlacement;
 			glm::vec2 dir = glm::normalize(glm::vec2(ball->SavedSpeed.x, ball->SavedSpeed.y));
 			glm::vec2 up = glm::vec2(0.f, 1.f);
@@ -160,9 +161,9 @@ void dd::Systems::PadSystem::Update(double dt)
 		return;
 	}
 
-	auto transform = Transform();
+	auto transform = m_PadTransform;
-	auto pad = Pad();
+	auto pad = m_PadComponent;
-	auto acceleration = Acceleration();
+	auto acceleration = m_PadAcceleration;
 
 	if (glm::abs(transform->Position.y - m_PadHeight) > m_PadRiseSpeed) {
 		if (transform->Position.y < m_PadHeight) {
@@ -178,27 +179,27 @@ void dd::Systems::PadSystem::Update(double dt)
         transform->Velocity.x = pad->MaxSpeed;
     }
     transform->Position += transform->Velocity * (float)dt;
-    if (transform->Position.x > Edge()) {
+    if (transform->Position.x > m_Edge) {
-        transform->Position.x = Edge();
+        transform->Position.x = m_Edge;
-    } else if (transform->Position.x < -Edge()) {
+    } else if (transform->Position.x < -m_Edge) {
-        transform->Position.x = -Edge();
+        transform->Position.x = -m_Edge;
     }
-    transform->Velocity += acceleration  * (float)dt;
+    transform->Velocity += acceleration * (float)dt;
-    if (glm::abs(transform->Velocity.x) > 1 || (!Left() && !Right())) {
+    if (glm::abs(transform->Velocity.x) > 1 || (!m_Left && !m_Right)) {
         transform->Velocity -= transform->Velocity * pad->SlowdownModifier * (float) dt;
     }
 
-    if (Left()) {
+    if (m_Left) {
         acceleration.x = -pad->AccelerationSpeed;
-    } else if (Right()) {
+    } else if (m_Right) {
         acceleration.x = pad->AccelerationSpeed;
     } else {
         acceleration.x = 0.f;
     }
 
-    SetTransform(transform);
+    m_PadTransform = transform;
-    SetPad(pad);
+    m_PadComponent = pad;
-    SetAcceleration(acceleration);
+    m_PadAcceleration = acceleration;
 
     return;
 }
@@ -232,11 +233,11 @@ bool dd::Systems::PadSystem::OnKeyDown(const dd::Events::KeyDown &event) {
     } else if (val == GLFW_KEY_LEFT) {
         //std::cout << "Left!" << std::endl;
         //acceleration.x = -0.01f;
-        SetLeft(true);
+        m_Left = true;
     } else if (val == GLFW_KEY_RIGHT) {
         //std::cout << "Right!" << std::endl;
         //acceleration.x = 0.01f;
-        SetRight(true);
+        m_Right = true;
     } else if (val == GLFW_KEY_R) {
         Events::ResetBall e;
         EventBroker->Publish(e);
@@ -255,7 +256,7 @@ bool dd::Systems::PadSystem::OnKeyDown(const dd::Events::KeyDown &event) {
 		EventBroker->Publish(e);
 	} else if (val == GLFW_KEY_M) {
         Events::MultiBall e;
-        e.padTransform = Transform();
+        e.padTransform = m_PadTransform;
         EventBroker->Publish(e);
     } else if (val == GLFW_KEY_P) {
 		if (IsPaused()) {
@@ -289,7 +290,7 @@ bool dd::Systems::PadSystem::OnKeyDown(const dd::Events::KeyDown &event) {
 		EventBroker->Publish(e);
 	} else if (val == GLFW_KEY_L) {
 		Events::Lifebuoy e;
-		e.Transform = Transform();
+		e.Transform = m_PadTransform;
 		EventBroker->Publish(e);
 	} else if (val == GLFW_KEY_Y) {
 		Events::StickyPad e;
@@ -308,14 +309,14 @@ bool dd::Systems::PadSystem::OnKeyDown(const dd::Events::KeyDown &event) {
 		EventBroker->Publish(e);
 	} else if (val == GLFW_KEY_Q) {
 		Events::Move e;
-		e.Entity = Entity();
+		e.Entity = m_PadEntity;
 		e.GoalPosition = glm::vec3(0, 0, -10); 
 		e.Speed = 5;
 		e.Queue = false;
 		EventBroker->Publish(e);
 	} else if (val == GLFW_KEY_SPACE) {
         Events::ActionButton e;
-		e.Position = Transform()->Position;
+		e.Position = m_PadTransform->Position;
         EventBroker->Publish(e);
     } else if (val == GLFW_KEY_D) {
         return false;
@@ -331,9 +332,9 @@ bool dd::Systems::PadSystem::OnKeyUp(const dd::Events::KeyUp &event)
     } else if (val == GLFW_KEY_DOWN) {
 
     } else if (val == GLFW_KEY_LEFT) {
-        SetLeft(false);
+        m_Left = false;
     } else if (val == GLFW_KEY_RIGHT) {
-        SetRight(false);
+        m_Right = false;
     }
     return true;
 }
@@ -476,8 +477,8 @@ bool dd::Systems::PadSystem::OnKrakenAttack(const dd::Events::KrakenAttack &even
 		m_PlayerStrength = event.PlayerStrength;
 		m_KrakenCharge = event.ChargeUpdate;
 		m_KrakenAttack = true;
-		auto transform = Transform();
+		auto transform = m_PadTransform;
-		auto acceleration = Acceleration();
+		auto acceleration = m_PadAcceleration;
 
 		transform->Velocity = glm::vec3(0, 0, 0);
 		acceleration = glm::vec3(0, 0, 0);
@@ -505,8 +506,8 @@ bool dd::Systems::PadSystem::OnKrakenAttack(const dd::Events::KrakenAttack &even
 			m_World->CommitEntity(m_KrakenArmHitbox);
 		}
 
-		SetTransform(transform);
+		m_PadTransform = transform;
-		SetAcceleration(acceleration);
+		m_PadAcceleration = acceleration;
 	} else if (m_KrakenCharge >= 1) {
 		m_KrakenAttack = false;
 		Events::KrakenAttackEnd e;

src/game/Game/ProjectileSystem.cpp

@@ -139,6 +139,7 @@ bool dd::Systems::ProjectileSystem::OnActionButton(const dd::Events::ActionButto
 			transform->Position = event.Position;
 			transform->Velocity = glm::vec3(0, projectile->Speed, 0);
 			m_Shots--;
+		
 			if (m_Shots <= 0) {
 				auto ball = m_World->GetComponent<Components::Ball>(m_AttachedSquid);
 				m_InkBlaster = false;

src/game/Game/ProjectileSystem.cpp.orig

@@ -1,151 +0,0 @@
-//
-// Created by Adniklastrator on 2015-10-08.
-//
-
-
-#include "PrecompiledHeader.h"
-#include "Game/ProjectileSystem.h"
-
-
-void dd::Systems::ProjectileSystem::Initialize()
-{
-	EVENT_SUBSCRIBE_MEMBER(m_EContact, &ProjectileSystem::OnContact);
-	EVENT_SUBSCRIBE_MEMBER(m_EPause, &ProjectileSystem::OnPause);
-	EVENT_SUBSCRIBE_MEMBER(m_EResume, &ProjectileSystem::OnResume);
-	EVENT_SUBSCRIBE_MEMBER(m_EInkBlaster, &ProjectileSystem::OnInkBlaster);
-	EVENT_SUBSCRIBE_MEMBER(m_EHitPad, &ProjectileSystem::OnHitPad);
-	EVENT_SUBSCRIBE_MEMBER(m_EActionButton, &ProjectileSystem::OnActionButton);
-
-	//Ink Blast
-	{
-		auto ent = m_World->CreateEntity();
-		m_World->SetProperty(ent, "Name", "Projectile");
-		std::shared_ptr<Components::Transform> ctransform = m_World->AddComponent<Components::Transform>(ent);
-		
-		auto circleShape = m_World->AddComponent<Components::CircleShape>(ent);
-		auto inkBlastTemplate = m_World->AddComponent<Components::Template>(ent);
-		circleShape->Radius = 0.1f;
-		auto physics = m_World->AddComponent<Components::Physics>(ent);
-		physics->CollisionType = CollisionType::Type::Dynamic;
-		physics->Category = CollisionLayer::Type::Projectile;
-		physics->Mask = static_cast<CollisionLayer::Type>(CollisionLayer::Type::Pad | CollisionLayer::Type::Brick | CollisionLayer::Type::Wall);
-		physics->Calculate = true;
-		ctransform->Position = glm::vec3(0.f, 0.f, -10.f);
-		ctransform->Scale = glm::vec3(0.6f, 0.6f, 0.6f);
-// 		auto cModel = m_World->AddComponent<Components::Model>(ent);
-// 		cModel->ModelFile = "Models/Test/Ball/Sid.obj";
-		auto cSprite = m_World->AddComponent<Components::Sprite>(ent);
-		cSprite->SpriteFile = "Textures/Particles/OilShot.png";
-		auto projectile = m_World->AddComponent<Components::Projectile>(ent);
-
-		m_World->CommitEntity(ent);
-
-		m_InkBlastTemplate = ent;
-	}
-
-    return;
-}
-
-void dd::Systems::ProjectileSystem::Update(double dt)
-{
-	if (m_Pause) {
-		return;
-	}
-}
-
-void dd::Systems::ProjectileSystem::UpdateEntity(double dt, EntityID entity, EntityID parent)
-{
-    if (IsPaused()) {
-        return;
-    }
-    auto templateCheck = m_World->GetComponent<Components::Template>(entity);
-    if (templateCheck != nullptr){ return; }
-
-	auto shot = m_World->GetComponent<Components::Projectile>(entity);
-	if (shot != nullptr) {
-		auto transform = m_World->GetComponent<Components::Transform>(entity);
-		if (transform->Position.y > 8) {
-			m_World->RemoveEntity(entity);
-		}
-	}
-}
-
-bool dd::Systems::ProjectileSystem::OnPause(const dd::Events::Pause &event)
-{
-    /*if (event.Type != "ProjectileSystem" && event.Type != "All") {
-        return false;
-    }*/
-    
-    m_Pause = true;
-
-    return true;
-}
-
-bool dd::Systems::ProjectileSystem::OnResume(const dd::Events::Resume &event)
-{
-	/*if (event.Type != "ProjectileSystem" && event.Type != "All") {
-	return false;
-	}*/
-	m_Pause = false;
-	return true;
-}
-
-bool dd::Systems::ProjectileSystem::OnContact(const dd::Events::Contact &event)
-{
-    
-    return true;
-}
-
-bool dd::Systems::ProjectileSystem::OnInkBlaster(const dd::Events::InkBlaster &event)
-{
-	m_InkBlaster = true;
-	m_Shots = event.Shots;
-	m_InkBlasterSpeed = event.Speed;
-	return true;
-}
-
-bool dd::Systems::ProjectileSystem::OnHitPad(const dd::Events::HitPad &event)
-{
-	if (m_InkBlaster) {
-		m_SquidLoaded = true;
-		m_AttachedSquid = event.Ball;
-	}
-	return true;
-}
-
-bool dd::Systems::ProjectileSystem::OnActionButton(const dd::Events::ActionButton &event)
-{
-	if (m_InkBlaster && m_SquidLoaded) {
-		auto ent = m_World->CloneEntity(m_InkBlastTemplate);
-		m_World->RemoveComponent<Components::Template>(ent);
-		auto projectile = m_World->GetComponent<Components::Projectile>(ent);
-		projectile->Speed = m_InkBlasterSpeed;
-		auto transform = m_World->GetComponent<Components::Transform>(ent);
-		transform->Position = event.Position;
-<<<<<<< HEAD
-		transform->Velocity = glm::vec3(0, projectile->Speed, 0);
-=======
-		transform->Velocity = glm::vec3(0, 7, 0);
->>>>>>> origin/master
-		m_Shots--;
-		if (m_Shots <= 0) {
-			auto ball = m_World->GetComponent<Components::Ball>(m_AttachedSquid);
-			m_InkBlaster = false;
-			m_SquidLoaded = false;
-			ball->InkBlaster = false;
-			ball->Sticky = false;
-			ball->Waiting = true;
-			
-			{
-				Events::InkBlasterOver e;
-				e.Ball = m_AttachedSquid;
-				EventBroker->Publish(e);
-			}
-			{
-				Events::ActionButton e;
-				EventBroker->Publish(e);
-			}
-		}
-	}
-	return true;
-}

src/game/Physics/PhysicsSystem.cpp

@@ -236,7 +236,12 @@ void dd::Systems::PhysicsSystem::Update(double dt)
 				auto particle = m_World->GetComponent<Components::Particle>(entity);
 
                 transform->Position = glm::vec3(position.x, position.y, transform->Position.z);
-				transform->Scale = particle->Scale;//glm::vec3(particle->Radius * 2.f, particle->Radius * 2.f, 1);
+				EntityID emitter = m_ParticleEmitters.ParticleEmitter[e];
+				auto cEmitter = m_World->GetComponent<Components::ParticleEmitter>(emitter);
+				if (!cEmitter->DefaultScale)
+				{
+					transform->Scale = particle->Scale;
+				}
             }
         }
 
@@ -272,7 +277,7 @@ void dd::Systems::PhysicsSystem::UpdateEntity(double dt, EntityID entity, Entity
                 m_World->RemoveEntity(entity);
             }
         }
-		//Update alpha
+		//Update alpha & scale
 		auto sprite = m_World->GetComponent<Components::Sprite>(entity);
 		float timeProgress = particle->TimeLived / (particle->LifeTime - 0.1);
 		if (timeProgress > 1) {
@@ -281,7 +286,9 @@ void dd::Systems::PhysicsSystem::UpdateEntity(double dt, EntityID entity, Entity
 		auto emitter = m_World->GetComponent<Components::ParticleEmitter>(particle->ParticleSystem);
 		if (emitter) {
 			sprite->Color.w = ScalarInterpolation(timeProgress, emitter->AlphaValues);
-			particle->Scale = VectorInterpolation(timeProgress, emitter->ScaleValues);
+			if (!emitter->DefaultScale) {
+				particle->Scale = VectorInterpolation(timeProgress, emitter->ScaleValues);
+			}
 			
 		}
     }
@@ -720,8 +727,9 @@ bool dd::Systems::PhysicsSystem::CreateParticleSequence(const Events::CreatePart
     particleEmitter->EmittingAngle = event.EmittingAngle;
     particleEmitter->LifeTime = event.EmitterLifeTime;
 	particleEmitter->AlphaValues = event.AlphaValues;
-	particleEmitter->ScaleValues = event.ScaleValues;
 	particleEmitter->RadiusDistribution = event.RadiusDistribution;
+	particleEmitter->DefaultScale = event.DefaultScale;
+	particleEmitter->ScaleValues = event.ScaleValues;
 	{
 		//Creating Particle Template
 		auto particle = m_World->CreateEntity(emitter);
@@ -731,10 +739,17 @@ bool dd::Systems::PhysicsSystem::CreateParticleSequence(const Events::CreatePart
 		m_World->AddComponent<Components::Template>(particle);
 		particleTransform->Position = emitterTransform->Position;
 		sprite->SpriteFile = event.SpriteFile;
+		if (particleEmitter->DefaultScale == true)
+		{
+			Texture* texture = ResourceManager::Load<Texture>(event.SpriteFile);
+			particleEmitter->ScaleValues.clear();
+			particleEmitter->ScaleValues.push_back(glm::vec3(texture->Width / 100, texture->Height / 100, 1));
+			
+		} 
 		sprite->Color = event.Color;
 		particleComponent->LifeTime = event.ParticleLifeTime;
 		particleComponent->Flags = event.Flags;
-		particleComponent->Scale = event.ScaleValues[0];
+		particleComponent->Scale = particleEmitter->ScaleValues[0];
 		particleComponent->ParticleSystem = emitter;
     }
     m_World->CommitEntity(emitter);
@@ -835,8 +850,9 @@ bool dd::Systems::PhysicsSystem::OnContact(const dd::Events::Contact &event)
 	e.Color = glm::vec4(1.f);
 	e.AlphaValues.push_back(1.f);
 	e.AlphaValues.push_back(0.f);
-	e.ScaleValues.push_back(glm::vec3(1.f));
+	e.ScaleValues.push_back(glm::vec3(4));
 	e.Speed = 0;
+	e.DefaultScale = true;
 
 	auto PowerFriend = m_World->GetComponent<Components::MultiBallBrick>(entity);
 	auto PowerSaviour = m_World->GetComponent<Components::LifebuoyBrick>(entity);
@@ -861,6 +877,7 @@ bool dd::Systems::PhysicsSystem::OnContact(const dd::Events::Contact &event)
 		e.SpriteFile = "Textures/PowerUps/RealeaseTheKraken.png";
 	}
 	else {
+		e.DefaultScale = false;
 		e.EmitterLifeTime = 4;
 		e.EmittingAngle = glm::half_pi<float>();
 		e.Spread = 0.5f;