end sequence stuff

Assets/Shaders/frag.glsl

@@ -67,6 +67,6 @@ void main()
     FragColor = mix(FragColor, vec4(1.0, 0.0, 0.0, FragColor.a), redness);
 
     if (FogFar < 1000)
-	    FragColor = mix(FragColor, vec4(FogColor, 1.0), fogFactor);
+	    FragColor = mix(FragColor, vec4(FogColor, FragColor.a), fogFactor);
 
 }

src/Engine/Audio/AudioManager.h

@@ -117,6 +117,14 @@ class Channel {
 		CheckError();
 	}
 
+	float GetPosition()
+	{
+		if (!IsLoaded())
+			return 0;
+
+		return BASS_ChannelBytes2Seconds(id, BASS_ChannelGetPosition(id, BASS_POS_BYTE));
+	}
+
 	void Set3DDistanceFactor(float dist)
 	{
 		if (!IsLoaded())

src/Engine/Objects/3DSprite.cpp

@@ -59,6 +59,26 @@ void Sprite3D::Draw()
 	Game::instance->shader->Unbind();
 }
 
+void Sprite3D::LookAt(glm::vec3 target)
+{
+	glm::vec3 direction = glm::normalize(target - position);
+	glm::vec3 up = glm::vec3(0, 1, 0);
+	glm::vec3 right = glm::cross(direction, up);
+	up = glm::cross(right, direction);
+
+	glm::mat4 rotation = glm::mat4(1.0f);
+	rotation[0] = glm::vec4(right, 0);
+	rotation[1] = glm::vec4(up, 0);
+	rotation[2] = glm::vec4(-direction, 0);
+
+	glm::quat q = glm::quat_cast(rotation);
+	glm::vec3 euler = glm::eulerAngles(q);
+
+	angle = glm::degrees(euler.x);
+	angleY = glm::degrees(euler.y);
+	angleZ = glm::degrees(euler.z);
+}
+
 void Sprite3D::UpdateSprite()
 {
 	vertices.clear();

src/Engine/Objects/3DSprite.h

@@ -27,6 +27,8 @@ class Sprite3D : public GameObject
 
 	void Draw() override;
 
+	void LookAt(glm::vec3 target);
+
 	void UpdateSprite();
 
 	void Destroy() override;

src/Engine/Objects/Camera.cpp

@@ -92,13 +92,25 @@ void Camera::DrawDebugCube(glm::vec3 pos, glm::vec3 scale)
 
 }
 
+void Camera::SetDirectionSmooth(float amount)
+{
+	glm::vec3 direction;
+	direction.x = cos(glm::radians(yaw)) * cos(glm::radians(pitch));
+	direction.y = sin(glm::radians(pitch));
+	direction.z = sin(glm::radians(yaw)) * cos(glm::radians(pitch));
+	cameraFront = glm::mix(smoothFront, glm::normalize(direction), amount);
+
+	SetViewMatrix();
+}
+
 void Camera::SetDirection()
 {
 	glm::vec3 direction;
 	direction.x = cos(glm::radians(yaw)) * cos(glm::radians(pitch));
 	direction.y = sin(glm::radians(pitch));
 	direction.z = sin(glm::radians(yaw)) * cos(glm::radians(pitch));
 	cameraFront = glm::normalize(direction);
+	smoothFront = cameraFront;
 
 	SetViewMatrix();
 }

src/Engine/Objects/Camera.h

@@ -25,6 +25,8 @@ class Camera
 
 	float cameraFar = 100.0f;
 
+	glm::vec3 smoothFront = glm::vec3(0.0f, 0.0f, -1.0f);
+
 	glm::vec3 scale = glm::vec3(1, 1, 1);
 
 	Camera();
@@ -49,10 +51,9 @@ class Camera
 
 	void LookAt(glm::vec3 target)
 	{
-		glm::vec3 direction = glm::normalize(position - target);
+		glm::vec3 direction = -glm::normalize(position - target);
 		pitch = glm::degrees(asin(direction.y));
 		yaw = glm::degrees(atan2(direction.z, direction.x));
-		SetDirection();
 	}
 
 	float YawAngleTo(glm::vec3 pos)
@@ -69,6 +70,8 @@ class Camera
 		return angle;
 	}
 
+	void SetDirectionSmooth(float amount);
+
 	void SetDirection();
 	void SetViewMatrix();
 

src/Game/LightingManager.cpp

@@ -45,6 +45,8 @@ void LightingManager::SunColor()
 
 	Gameplay* gp = (Gameplay*)Game::instance->currentScene;
 
+	Camera* cam = Game::instance->GetCamera();
+
 	int playerY = gp->player->position.y;
 	Chunk* c = WorldManager::instance->GetChunk(gp->player->position.x, gp->player->position.z);
 	int highestBlock = 0;
@@ -113,6 +115,11 @@ void LightingManager::SunColor()
 
     float distance = (float)highestBlock - (float)playerY;
 
+	if (cam->position.y > 170.0f)
+	{
+		distance = 5.0f;
+	}
+
     float mixProgress = distance / 5.0f;
 
     if (mixProgress > 1.0f)

src/Game/MobManager.cpp

@@ -63,7 +63,7 @@ void MobManager::Update()
 	Camera* cam = Game::instance->GetCamera();
 
 	// spawn mobs around player
-	if (glfwGetTime() - lastWave > 30 && mobs.size() < 45)
+	if (glfwGetTime() - lastWave > 30 && mobs.size() < 45 && !Hud::endSequence)
 	{
 		lastWave = glfwGetTime();
 
@@ -148,12 +148,12 @@ void MobManager::Update()
 	{
 		float angle = cam->YawAngleTo(mob->position);
 
-		if (angle > 100 && glfwGetTime() - mob->lastSeen > 140) // not visible
+		if (angle > 260 && glfwGetTime() - mob->lastSeen > 140) // not visible
 		{
 			RemoveMob(mob);
 			break;
 		}
-		else if (angle > 100)
+		else if (angle > 260)
 			mob->lastSeen = glfwGetTime();
 
 		if (mob->dead)
@@ -192,7 +192,7 @@ void MobManager::Update()
 
 		float r = rand() % 35 + 20;
 
-		if (mob->lastNoise + r < glfwGetTime())
+		if (mob->lastNoise + r < glfwGetTime() && !Hud::endSequence)
 			mob->Noise();
 	}
 }

src/Game/MusicManager.cpp

@@ -133,6 +133,7 @@ void MusicManager::PlayMusic(std::string path)
 	c->CreateFX();
 
 	c->Play();
+	_isPlaying = true;
 
 	_fadeTime = 0;
 	_fadeDuration = 0;
@@ -169,6 +170,7 @@ void MusicManager::PlayMusic(std::string path, float fadeDuration)
 
 	c->SetVolume(0);
 	c->Play();
+	_isPlaying = true;
 
 	_fadeTime = glfwGetTime();
 	_fadeDuration = fadeDuration;
@@ -275,6 +277,16 @@ void MusicManager::PlaySFX(std::string path, glm::vec3 from, float pitch, std::s
 	c->Play();
 }
 
+float MusicManager::GetTime()
+{
+	Channel* c = Game::instance->audioManager->GetChannel(currentSong);
+
+	if (c == nullptr)
+		return 0;
+
+	return c->GetPosition();
+}
+
 void MusicManager::FadeOut(float duration)
 {
 	if (currentSong == "")
@@ -333,7 +345,7 @@ void MusicManager::PlayNext()
 
 bool MusicManager::IsPlaying()
 {
-	return _isPlaying;
+	return ChannelIsPlaying(currentSong);
 }
 
 void MusicManager::Update()
@@ -356,6 +368,7 @@ void MusicManager::Update()
 	if (Game::instance->audioManager->channels.size() == 0)
 		return;
 
+
 	if (glfwGetTime() > lastCheck)
 	{
 		lastCheck = glfwGetTime() + 0.15f;

src/Game/MusicManager.h

@@ -56,6 +56,8 @@ class MusicManager
 	void PlaySFX(std::string path, std::string customName = "sfx");
 	void PlaySFX(std::string path, glm::vec3 from, float pitch, std::string customName = "sfx");
 
+	float GetTime();
+
 	void FadeOut(float duration);
 
 	void FadeTo(float volume, float duration);

src/Game/Objects/Base/Blocks/Rocket.cpp

@@ -2,6 +2,7 @@
 #include "../../../LightingManager.h"
 #include "../../../Scenes/Gameplay.h"
 #include <Game.h>
+#include "../RocketEnd.h"
 
 Rocket::Rocket(glm::vec3 _position) : Block(_position, BlockType::ROCKET)
 {
@@ -43,15 +44,34 @@ bool Rocket::Update(int tick)
 		return true;
 
 	int highest = currentChunk->GetHighestBlock(position.x, position.z);
+	Gameplay* gp = (Gameplay*)Game::instance->currentScene;
 
 	if (position.y < highest)
 	{
-		Gameplay* gp = (Gameplay*)Game::instance->currentScene;
 
 		gp->hud->ShowHint("Route blocked, unable to launch.");
 		Hud::endSequence = false;
+		gp->hud->playEnd = false;
+		return true;
+	}
+
+	if (LightingManager::GetInstance()->sun.angle < 200 || LightingManager::GetInstance()->sun.angle > 290)
+	{
+		gp->hud->ShowHint("Route unclear, the sky must be shrouded in darkness.");
+		Hud::endSequence = false;
+		gp->hud->playEnd = false;
 		return true;
 	}
 
+	if (!destroyed)
+	{
+		RocketEnd* end = new RocketEnd(position);
+
+		gp->AddObject(end);
+
+		destroyed = true;
+		currentChunk->ModifyBlock(position.x, position.y, position.z, 0);
+	}
+
 	return true;
 }

src/Game/Objects/Base/Blocks/Rocket.h

@@ -9,6 +9,8 @@ class Rocket : public Block
 public:
 	Chunk* currentChunk;
 
+	bool destroyed = false;
+
 	Rocket(glm::vec3 _position);
 
 	void LoadModel() override;