sem/SDBA
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

merge Feature/game logic/game over into develop #6

Merged
SemvdH merged 8 commits from feature/game_logic/game_over into develop 2021-06-18 13:18:18 +00:00
Conversation 5 Commits 8 Files Changed 16 +393 -90
16 changed files with 393 additions and 90 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
src/collision/collision_handler.cpp
View File

@@ -3,7 +3,7 @@
namespace collision
{
void CheckCollisions(std::vector<std::shared_ptr<entities::CollisionEntity>> entities)
void CheckCollisions(std::deque<std::shared_ptr<entities::CollisionEntity>>& entities)
{
if (entities.size() < 2) { return; }
if (entities.size() == 2)
@@ -15,7 +15,7 @@ namespace collision
entities[1]->OnCollide(c);
}
}
for (int i = 0; i < entities.size() - 2; i++)
{
std::shared_ptr<entities::CollisionEntity> entity = entities[i];

3
src/collision/collision_handler.h
View File

@@ -4,6 +4,7 @@
#include <vector>
#include "../entities/collision_entity.h"
#include "collision.h"
#include <deque>
namespace collision
{
@@ -13,5 +14,5 @@ namespace collision
*
* @param entities: A list with all the collision entities.
*/
void CheckCollisions(std::vector<std::shared_ptr<entities::CollisionEntity>> entities);
void CheckCollisions(std::deque<std::shared_ptr<entities::CollisionEntity>>& entities);
}

7
src/entities/collision_entity.cpp
View File

@@ -40,7 +40,10 @@ namespace entities
const glm::vec3 size = bounding_box.size;
min_xyz = bounding_box.center_pos;
max_xyz = glm::vec3(min_xyz.x + size.x, min_xyz.y + size.y, min_xyz.z + size.z);
min_xyz = { bounding_box.center_pos.x - (0.5 * size.x), bounding_box.center_pos.y, bounding_box.center_pos.z + (0.5 * size.z) };
max_xyz = { bounding_box.center_pos.x + (0.5 * size.x), bounding_box.center_pos.y + size.y, bounding_box.center_pos.z - (0.5 * size.z) };
// min_xyz = bounding_box.center_pos;
// max_xyz = { bounding_box.center_pos.x + size.x, bounding_box.center_pos.y + size.y, bounding_box.center_pos.z + size.z };
}
}

2
src/entities/collision_entity.h
View File

@@ -58,7 +58,7 @@ namespace entities
void SetCollisionBehaviour(std::function<void(const collision::Collision&)> function)
{ if (function != nullptr) { on_collide = function; } }
protected:
public:
/*
* @brief: This method moves the collision to the center of the entity

121
src/entities/house_generator.cpp
View File

@@ -20,71 +20,75 @@ namespace entities
GenerateFurnitureModels();
}
std::deque<std::shared_ptr<Entity>> HouseGenerator::GenerateHouse(const glm::vec3& position, float y_rotation)
std::deque<std::shared_ptr<CollisionEntity>> HouseGenerator::GenerateHouse(const glm::vec3& position, float y_rotation)
{
std::deque<std::shared_ptr<Entity>> furniture;
std::deque<std::shared_ptr<CollisionEntity>> furniture;
// Add house
furniture.push_front(std::make_shared<Entity>(house_model, position, glm::vec3(0, y_rotation, 0), HOUSE_SIZE));
collision::Box house_box = { position, glm::vec3(0,0,0) };
furniture.push_front(std::make_shared<CollisionEntity>(house_model, position, glm::vec3(0, y_rotation, 0), HOUSE_SIZE, house_box));
for(int i = 0; i<toolbox::Random(1,4);i++)
{
FurnitureType type = FurnitureType(toolbox::Random(0, furniture_models.size() - 1));
models::TexturedModel model = GetFurnitureModel(type);
glm::vec3 model_pos = glm::vec3(position.x, position.y, position.z);
collision::Box model_box = { model_pos, model.raw_model.model_size };
model_box.SetRotation(-90);
furniture.push_back(std::make_shared<CollisionEntity>(model, model_pos, glm::vec3(0, -90, 0), HOUSE_SIZE * 2, model_box));
}
for(int i = 0; i<toolbox::Random(1,4);i++)
{
FurnitureType type = FurnitureType(toolbox::Random(0, furniture_models.size() - 1));
models::TexturedModel model = GetFurnitureModel(type);
glm::vec3 model_pos = glm::vec3(position.x, position.y, position.z);
collision::Box model_box = { model_pos, model.raw_model.model_size };
model_box.SetRotation(-90);
furniture.push_back(std::make_shared<CollisionEntity>(model, model_pos, glm::vec3(0, -90, 0), HOUSE_SIZE * 2, model_box));
}
//furniture_collision.pop_front();
/*
// Add furniture
models::TexturedModel couch = GetFurnitureModel(FurnitureType::COUCH);
glm::vec3 couch_pos = glm::vec3(position.x + 200, position.y, position.z + 10);
collision::Box couch_box = { couch_pos, couch.raw_model.model_size };
couch_box.SetRotation(-90);
furniture.push_back(std::make_shared<CollisionEntity>(couch, couch_pos, glm::vec3(0, -90, 0), HOUSE_SIZE * 2, couch_box));
models::TexturedModel table = GetFurnitureModel(FurnitureType::TABLE);
glm::vec3 table_pos = glm::vec3(position.x - 30, position.y, position.z);
collision::Box table_box = { table_pos, table.raw_model.model_size };
furniture.push_back(std::make_shared<CollisionEntity>(table, table_pos, glm::vec3(0, 0, 0), HOUSE_SIZE * 1.3, table_box));
models::TexturedModel chair = GetFurnitureModel(FurnitureType::CHAIR);
glm::vec3 chair_pos = glm::vec3(position.x - 50, position.y, position.z + 220);
collision::Box chair_box = { chair_pos, chair.raw_model.model_size };
furniture.push_back(std::make_shared<CollisionEntity>(chair, chair_pos, glm::vec3(0, 0, 0), HOUSE_SIZE, chair_box));
models::TexturedModel plant = GetFurnitureModel(FurnitureType::PLANT);
glm::vec3 plant_pos = glm::vec3(position.x - 50, position.y, position.z + 220);
collision::Box plant_box = { plant_pos, plant.raw_model.model_size };
furniture.push_back(std::make_shared<CollisionEntity>(plant, plant_pos, glm::vec3(0, 0, 0), HOUSE_SIZE, plant_box));
models::TexturedModel guitar = GetFurnitureModel(FurnitureType::GUITAR);
glm::vec3 guitar_pos = glm::vec3(position.x - 50, position.y, position.z + 220);
collision::Box guitar_box = { guitar_pos, guitar.raw_model.model_size };
furniture.push_back(std::make_shared<CollisionEntity>(guitar, guitar_pos, glm::vec3(0, 0, 0), HOUSE_SIZE, guitar_box));
models::TexturedModel bookshelf = GetFurnitureModel(FurnitureType::BOOKSHELF);
glm::vec3 bookshelf_pos = glm::vec3(position.x - 50, position.y, position.z + 220);
collision::Box bookshelf_box = { bookshelf_pos, bookshelf.raw_model.model_size };
furniture.push_back(std::make_shared<CollisionEntity>(bookshelf, bookshelf_pos, glm::vec3(0, 0, 0), HOUSE_SIZE, bookshelf_box));
models::TexturedModel lamp = GetFurnitureModel(FurnitureType::LAMP);
glm::vec3 lamp_pos = glm::vec3(position.x - 50, position.y, position.z + 220);
collision::Box lamp_box = { lamp_pos, lamp.raw_model.model_size };
furniture.push_back(std::make_shared<CollisionEntity>(lamp, lamp_pos, glm::vec3(0, 0, 0), HOUSE_SIZE, lamp_box));
models::TexturedModel ceiling_object = GetFurnitureModel(FurnitureType::CEILING_OBJECTS);
glm::vec3 ceiling_object_pos = glm::vec3(position.x - 50, position.y, position.z + 220);
collision::Box ceiling_object_box = { ceiling_object_pos, ceiling_object.raw_model.model_size };
furniture.push_back(std::make_shared<CollisionEntity>(ceiling_object, ceiling_object_pos, glm::vec3(0, 0, 0), HOUSE_SIZE, ceiling_object_box));
models::TexturedModel couch = GetFurnitureModel(FurnitureType::COUCH);
glm::vec3 couch_pos = glm::vec3(position.x + 200, position.y, position.z + 10);
collision::Box couch_box = { couch_pos, couch.raw_model.model_size * (HOUSE_SIZE) };
couch_box.SetRotation(-90);
furniture.push_back(std::make_shared<CollisionEntity>(couch, couch_pos, glm::vec3(0, -90, 0), HOUSE_SIZE * 2, couch_box));
models::TexturedModel table = GetFurnitureModel(FurnitureType::TABLE);
glm::vec3 table_pos = glm::vec3(position.x - 30, position.y, position.z);
collision::Box table_box = { table_pos, table.raw_model.model_size * ((HOUSE_SIZE) * 1.3f) };
furniture.push_back(std::make_shared<CollisionEntity>(table, table_pos, glm::vec3(0, 0, 0), HOUSE_SIZE * 1.3, table_box));
models::TexturedModel chair = GetFurnitureModel(FurnitureType::CHAIR);
glm::vec3 chair_pos = glm::vec3(position.x - 50, position.y, position.z + 220);
collision::Box chair_box = { chair_pos, chair.raw_model.model_size * (HOUSE_SIZE) };
furniture.push_back(std::make_shared<CollisionEntity>(chair, chair_pos, glm::vec3(0, 0, 0), HOUSE_SIZE, chair_box));
models::TexturedModel plant = GetFurnitureModel(FurnitureType::PLANT);
glm::vec3 plant_pos = glm::vec3(position.x - 50, position.y, position.z + 220);
collision::Box plant_box = { plant_pos, plant.raw_model.model_size * (HOUSE_SIZE) };
furniture.push_back(std::make_shared<CollisionEntity>(plant, plant_pos, glm::vec3(0, 0, 0), HOUSE_SIZE, plant_box));
models::TexturedModel guitar = GetFurnitureModel(FurnitureType::GUITAR);
glm::vec3 guitar_pos = glm::vec3(position.x - 50, position.y, position.z + 220);
collision::Box guitar_box = { guitar_pos, guitar.raw_model.model_size * (HOUSE_SIZE) };
furniture.push_back(std::make_shared<CollisionEntity>(guitar, guitar_pos, glm::vec3(0, 0, 0), HOUSE_SIZE, guitar_box));
models::TexturedModel bookshelf = GetFurnitureModel(FurnitureType::BOOKSHELF);
glm::vec3 bookshelf_pos = glm::vec3(position.x - 50, position.y, position.z + 220);
collision::Box bookshelf_box = { bookshelf_pos, bookshelf.raw_model.model_size * (HOUSE_SIZE) };
furniture.push_back(std::make_shared<CollisionEntity>(bookshelf, bookshelf_pos, glm::vec3(0, 0, 0), HOUSE_SIZE, bookshelf_box));
models::TexturedModel lamp = GetFurnitureModel(FurnitureType::LAMP);
glm::vec3 lamp_pos = glm::vec3(position.x - 50, position.y, position.z + 220);
collision::Box lamp_box = { lamp_pos, lamp.raw_model.model_size * (HOUSE_SIZE) };
furniture.push_back(std::make_shared<CollisionEntity>(lamp, lamp_pos, glm::vec3(0, 0, 0), HOUSE_SIZE, lamp_box));
models::TexturedModel ceiling_object = GetFurnitureModel(FurnitureType::CEILING_OBJECTS);
glm::vec3 ceiling_object_pos = glm::vec3(position.x - 50, position.y, position.z + 220);
collision::Box ceiling_object_box = { ceiling_object_pos, ceiling_object.raw_model.model_size * (HOUSE_SIZE) };
furniture.push_back(std::make_shared<CollisionEntity>(ceiling_object, ceiling_object_pos, glm::vec3(0, 0, 0), HOUSE_SIZE, ceiling_object_box));
models::TexturedModel misc = GetFurnitureModel(FurnitureType::MISC);
glm::vec3 misc_pos = glm::vec3(position.x - 50, position.y, position.z + 220);
collision::Box misc_box = { misc_pos, misc.raw_model.model_size };
glm::vec3 misc_pos = glm::vec3(position.x - 50, position.y - 10, position.z + 220);
collision::Box misc_box = { misc_pos, misc.raw_model.model_size * (HOUSE_SIZE) };
furniture.push_back(std::make_shared<CollisionEntity>(misc, misc_pos, glm::vec3(0, 0, 0), HOUSE_SIZE, misc_box));
*/
return furniture;
}
@@ -255,4 +259,9 @@ namespace entities
furniture_models.insert(std::pair<FurnitureType, std::deque<models::TexturedModel>>(FurnitureType::MISC, miscs));
}
/*std::deque<std::shared_ptr<CollisionEntity>> HouseGenerator::GetFurnitureCollisions()
{
return furniture_collision;
}*/
}

12
src/entities/house_generator.h
View File

@@ -5,6 +5,7 @@
#include <map>
#include "../models/Model.h"
#include "../collision/collision.h"
#include "collision_entity.h"
namespace entities
{
@@ -30,6 +31,8 @@ namespace entities
models::ModelTexture default_texture;
std::map<FurnitureType, std::deque<models::TexturedModel>> furniture_models;
//std::deque<std::shared_ptr<CollisionEntity>> furniture_collision;
public:
HouseGenerator();
@@ -42,12 +45,17 @@ namespace entities
*
* @return: A list with all the entities of the generated house (the furniture)
*/
std::deque<std::shared_ptr<Entity>> GenerateHouse(const glm::vec3& position, float y_rotation);
std::deque<std::shared_ptr<CollisionEntity>> GenerateHouse(const glm::vec3& position, float y_rotation);
/*
* @brief: Returns the depth of the house (chunk)
*/
float GetHouseDepth() const { return house_model.raw_model.model_size.x * HOUSE_SIZE; }
float GetHouseDepth() const { return house_model.raw_model.model_size.x * HOUSE_SIZE;
}
//std::deque<std::shared_ptr<CollisionEntity>> GetFurnitureCollisions();
private:
/*

6
src/entities/main_character.cpp
View File

@@ -22,7 +22,7 @@ namespace entities
void MainCharacter::Move(GLFWwindow* window)
{
if (is_playing) {
movement_speed = -0.5f; //Forward speed adjustment, bee is moving at a standard speedrate
movement_speed = -2.0f; //Forward speed adjustment, bee is moving at a standard speedrate
down_speed = -1.0f; //Down speed adjustment, downspeed is difference between down_speed and UP_SPEED
side_speed = 0; //Side speed adjustment
@@ -97,4 +97,8 @@ namespace entities
is_playing = false;
std::cout << "collision" << std::endl;
}
bool MainCharacter::GetOnCollide() {
return is_playing;
}
}

2
src/entities/main_character.h
View File

@@ -34,5 +34,7 @@ namespace entities
void Move(GLFWwindow* window);
void OnCollide(const collision::Collision& collision) override;
bool GetOnCollide();
};
}

16
src/main.cpp
View File

@@ -27,6 +27,8 @@
#include "scenes/scene.h"
#include "scenes/in_Game_Scene.h"
#include "scenes/startup_Scene.h"
#include "scenes/game_Over_Scene.h"
#include "entities/collision_entity.h"
#include "computervision/object_detection.h"
//#include "computervision/OpenPoseImage.h"
@@ -38,6 +40,7 @@
#pragma comment(lib, "glew32s.lib")
#pragma comment(lib, "opengl32.lib")
int score;
static double UpdateDelta();
static GLFWwindow* window;
@@ -72,7 +75,8 @@ int main(void)
glGetError();
#pragma endregion
//TODO change back to 0, only to show how score is visible on end screen
score = 0;
current_scene = new scene::Startup_Scene();
glfwSetKeyCallback(window, [](GLFWwindow* window, int key, int scancode, int action, int mods)
@@ -87,8 +91,6 @@ int main(void)
bool window_open = true;
// Main game loop
while (!glfwWindowShouldClose(window) && window_open)
{
@@ -109,9 +111,13 @@ int main(void)
case scene::Scenes::INGAME:
current_scene = new scene::In_Game_Scene();
current_scene = new scene::In_Game_Scene(&score);
break;
case scene::Scenes::GAMEOVER:
current_scene = new scene::Game_Over_Scene(score);
break;
default:
std::cout << "Wrong return value!!! ->" << std::endl;
break;
@@ -137,4 +143,4 @@ static double UpdateDelta()
double delt_time = current_time - last_frame_time;
last_frame_time = current_time;
return delt_time;
}
}

217
src/scenes/game_Over_Scene.cpp Normal file
View File

@@ -0,0 +1,217 @@
#include <iostream>
#include <GL/glew.h>
#include <GLFW/glfw3.h>
#include <map>
#include "game_Over_Scene.h"
#include <iostream>
#include <opencv2/core/mat.hpp>
#include "../models/model.h"
#include "../renderEngine/loader.h"
#include "../renderEngine/obj_loader.h"
#include "../renderEngine/renderer.h"
#include "../shaders/entity_shader.h"
#include "../gui/gui_interactable.h"
#include "../toolbox/toolbox.h"
#include "../computervision/MenuTest.h"
#include "../computervision/ObjectDetection.h"
#include "../computervision/HandDetectRegion.h"
namespace scene
{
shaders::GuiShader* gui_shader_gameOver;
std::vector<gui::GuiTexture*> guis_gameOver;
computervision::ObjectDetection objDetect_gameOver;
std::vector<std::shared_ptr<gui::GuiTexture>> score_textures_gameOver;
float item_number_gameOver = 0;
bool hand_mode_gameOver = false;
Game_Over_Scene::Game_Over_Scene(int score)
{
shaders::EntityShader shader;
shader.Init();
render_engine::renderer::Init(shader);
shader.CleanUp();
gui_shader_gameOver = new shaders::GuiShader();
gui_shader_gameOver->Init();
for (int i = 0; i <= 9; i++)
{
std::shared_ptr<gui::GuiTexture> score_pointer;
std::string texture_path = "res/";
texture_path += std::to_string(i);
texture_path += ".png";
score_pointer = std::make_unique<gui::GuiTexture>(render_engine::loader::LoadTexture(texture_path), glm::vec2(0.0f, 0.2f), glm::vec2(0.07, 0.15));
score_textures_gameOver.push_back(score_pointer);
}
game_over_texture = std::make_unique<gui::GuiTexture>(render_engine::loader::LoadTexture("res/game_over.png"), glm::vec2(0.0f, 0.6f), glm::vec2(0.50f, 0.50f));
end_score = score;
}
gui::Button* ConvertGuiTextureToButtonGameOver(gui::GuiTexture* texture) {
gui::Button* button;
if (texture != NULL)
{
if (texture->GetType() == gui::GuiType::BUTTON) {
button = (gui::Button*)texture;
return button;
}
else {
button = nullptr;
return button;
}
}
else {
button = nullptr;
return button;
}
}
gui::GuiTexture* GetMenuItemGameOver(bool hand_state) {
if (hand_state)
item_number_gameOver += 0.20f;
int temp_item_number = item_number_gameOver;
//If temp_item_number is equal to the size of the array, set item_number bac to zero to loop through the array again
if (temp_item_number == guis_gameOver.size()) {
item_number_gameOver = 0;
temp_item_number = 0;
}
std::cout << guis_gameOver[temp_item_number]->texture << std::endl;
return guis_gameOver[temp_item_number];
}
scene::Scenes scene::Game_Over_Scene::start(GLFWwindow* window) {
gui::Button button_start_scene(render_engine::loader::LoadTexture("res/Birb1.jpg"), glm::vec2(0.0f, -0.5f), glm::vec2(0.25f, 0.25f));
button_start_scene.SetHoverTexture(render_engine::loader::LoadTexture("res/Birb2.jpg"));
button_start_scene.SetClickedTexture(render_engine::loader::LoadTexture("res/Birb3.jpg"));
button_start_scene.SetOnClickAction([]()
{
std::cout << "Back to start screen!!" << std::endl;
});
guis_gameOver.push_back(&button_start_scene);
computervision::ObjectDetection objDetect;
cv::Mat cameraFrame;
gui::GuiTexture* chosen_item_gameOver = NULL; //This is the selected menu_item
bool hand_closed = false; //Flag to prevent multiple button presses
while (return_value == scene::Scenes:: GAMEOVER)
{
render();
update(window);
if (hand_mode_gameOver)
{
cameraFrame = objDetect_gameOver.ReadCamera();
bool detect = false;
bool hand_detection = objDetect_gameOver.DetectHand(cameraFrame, detect);
if (hand_detection)
{
hand_closed = false;
std::cout << "hand is opened" << std::endl;
//Loop through menu items
chosen_item_gameOver = GetMenuItemGameOver(true);
gui::Button* new_button = ConvertGuiTextureToButtonGameOver(chosen_item_gameOver);
if (new_button != NULL) {
const float x_pos = (chosen_item_gameOver->position.x + 1.0) * WINDOW_WIDTH / 2;
const float y_pos = (1.0 - chosen_item_gameOver->position.y) * WINDOW_HEIGHT / 2;
//Set cursor to location of selected menu_item
glfwSetCursorPos(window, x_pos, y_pos);
}
}
else if (!hand_detection)
{
std::cout << "hand is closed" << std::endl;
//Gets selected menu_item
chosen_item_gameOver = GetMenuItemGameOver(false);
gui::Button* new_button = ConvertGuiTextureToButtonGameOver(chosen_item_gameOver);
if (new_button != NULL && !hand_closed) {
//Run function click
new_button->ForceClick(GLFW_MOUSE_BUTTON_LEFT);
hand_closed = true;
}
}
}
glfwSwapBuffers(window);
glfwPollEvents();
}
gui_shader_gameOver->CleanUp();
render_engine::loader::CleanUp();
return return_value;
}
/**
* renders the models in the start-up scene
*/
void scene::Game_Over_Scene::render()
{
render_engine::renderer::Prepare();
// Render GUI items
render_engine::renderer::Render(guis_gameOver, *gui_shader_gameOver);
}
/**
* updates the variables for the start-up scene
*/
void scene::Game_Over_Scene::update(GLFWwindow* window)
{
for (gui::GuiTexture* button : guis_gameOver) {
gui::Button* new_button = ConvertGuiTextureToButtonGameOver(button);
if (new_button != NULL)
new_button->Update(window);
}
bool hand_present;
objDetect_gameOver.DetectHand(objDetect_gameOver.ReadCamera(), hand_present);
render_engine::renderer::Render(game_over_texture, *gui_shader_gameOver);
DrawScore(end_score);
}
/**
* manages the key input in the start-up scene
*/
void scene::Game_Over_Scene::onKey(GLFWwindow* window, int key, int scancode, int action, int mods)
{
if (glfwGetKey(window, GLFW_KEY_SPACE) == GLFW_PRESS)
{
//return_value = scene::Scenes::STARTUP;
cv::destroyWindow("camera");
}
else if (glfwGetKey(window, GLFW_KEY_BACKSPACE) == GLFW_PRESS) {
hand_mode_gameOver = !hand_mode_gameOver;
}
}
void Game_Over_Scene::DrawScore(int score)
{
std::vector<int> digits;
score_guis_gameOver.clear();
toolbox::GetDigitsFromNumber(score, digits);
for (int i = digits.size() - 1; i >= 0; i--)
{
score_textures_gameOver[digits[i]].get()->position.x = (0.15 * i - 0.05);
render_engine::renderer::Render(score_textures_gameOver[digits[i]], *gui_shader_gameOver);
}
}
}

35
src/scenes/game_Over_Scene.h Normal file
View File

@@ -0,0 +1,35 @@
#pragma once
#include "scene.h"
#include "../gui/gui_element.h"
namespace scene
{
extern GLFWwindow* window;
class Game_Over_Scene : public scene::Scene
{
private:
int end_score;
scene::Scenes return_value = scene::Scenes::GAMEOVER;
std::vector<std::shared_ptr<gui::GuiTexture>> score_guis_gameOver;
std::shared_ptr<gui::GuiTexture> game_over_texture;
public:
Game_Over_Scene(int score);
Scenes start(GLFWwindow* window) override;
void render() override;
void update(GLFWwindow* window) override;
void onKey(GLFWwindow* window, int key, int scancode, int action, int mods) override;
/**
* @brief: This method renders the score points onto the game window
* @param score: Score to show
*/
void DrawScore(int score);
};
}

38
src/scenes/in_Game_Scene.cpp
View File

@@ -7,7 +7,10 @@
namespace scene
{
std::shared_ptr<entities::MainCharacter>main_character;
std::vector<std::shared_ptr<entities::CollisionEntity>> collision_entities;
std::deque<std::shared_ptr<entities::CollisionEntity>> collision_entities;
//std::deque<std::shared_ptr<entities::CollisionEntity>> furniture_collision;
entities::HouseGenerator* house_generator;
std::deque<std::shared_ptr<entities::Entity>> house_models;
@@ -20,6 +23,7 @@ namespace scene
int furniture_count_old;
int score;
int* ptr;
float delta_time = 0;
@@ -29,8 +33,9 @@ namespace scene
/**
* sets up the first things when the objects has been made
*/
In_Game_Scene::In_Game_Scene()
In_Game_Scene::In_Game_Scene(int *score_ptr)
{
ptr = score_ptr;
camera = std::make_unique<entities::Camera>(glm::vec3(0, 0, 0), glm::vec3(0, 0, 0));
shader = new shaders::EntityShader;
@@ -50,11 +55,8 @@ namespace scene
texture_path += ".png";
score_pointer = std::make_unique<gui::GuiTexture>(render_engine::loader::LoadTexture(texture_path), glm::vec2(-0.9f, 0.8f), glm::vec2(0.07, 0.15));
score_textures.push_back(score_pointer);
}
}
/**
@@ -110,16 +112,19 @@ namespace scene
for (int i = 0; i < furniture_count; i++)
{
house_models.pop_front();
collision_entities.erase(collision_entities.begin() + 1);
}
}
int z_offset = model_pos * (house_generator->GetHouseDepth()); // how much "in the distance" we should load the model
std::deque<std::shared_ptr<entities::Entity>> furniture = house_generator->GenerateHouse(glm::vec3(0, -75, -50 - z_offset), 90);
std::deque<std::shared_ptr<entities::CollisionEntity>> furniture = house_generator->GenerateHouse(glm::vec3(0, -75, -50 - z_offset), 90);
furniture_count = furniture.size();
house_models.insert(house_models.end(), furniture.begin(), furniture.end());
collision_entities.insert(collision_entities.end(), furniture.begin(), furniture.end());
std::cout << "funriture_count in load chunk (house included): " << furniture_count << std::endl;
furniture_count_old = furniture_count - 1;
}
/**
@@ -135,8 +140,9 @@ namespace scene
raw_model_char = render_engine::LoadObjModel("res/beeTwo.obj");
models::TexturedModel model_char = { raw_model_char, texture };
collision::Box char_box = create_bounding_box(raw_model_char.model_size, glm::vec3(0, 0, 0), 1);
main_character = std::make_shared<entities::MainCharacter>(model_char, glm::vec3(0, -50, -100), glm::vec3(0, 90, 0), 5, char_box);
collision_entities.push_back(main_character);
main_character = std::make_shared<entities::MainCharacter>(model_char, glm::vec3(0, 50, -100), glm::vec3(0, 90, 0), 5, char_box);
//collision_entities.push_back(main_character);
house_generator = new entities::HouseGenerator();
SetupHandDetection();
@@ -255,8 +261,13 @@ namespace scene
UpdateDeltaTime();
//camera.Move(window);
main_character->Move(window);
if (!main_character.get()->GetOnCollide())
{
*ptr = score;
std::cout << "Score: " << score << std::endl;
return_value = scene::Scenes::GAMEOVER;
}
//std::cout << "x get: " << movement.x << "\ny get: " << movement.y << "\nz get: " << movement.z << "\n";
camera->Follow(main_character->GetPosition());
// calculate where the next house model should be loaded
@@ -274,11 +285,12 @@ namespace scene
}
// remember the position at which the new model was added
last_model_pos = model_pos;
collision_entities.push_front(main_character);
collision::CheckCollisions(collision_entities);
collision_entities.pop_front();
update_hand_detection();
}
//manages the key input in the game scene
@@ -335,11 +347,11 @@ namespace scene
toolbox::GetDigitsFromNumber(score, digits);
for (int i = digits.size() - 1; i >= 0; i--)
{
score_textures[digits[i]].get()->position.x = 0.15 * i - 0.9; // place the number at the top left. the numbers are just fine tuned to get the position just right
render_engine::renderer::Render(score_textures[digits[i]], *gui_shader);
}
}

9
src/scenes/in_Game_Scene.h
View File

@@ -45,7 +45,6 @@ namespace scene
PAUSED
};
class In_Game_Scene : public scene::Scene
{
private:
@@ -117,7 +116,7 @@ namespace scene
void LoadChunk(int model_pos);
public:
In_Game_Scene();
In_Game_Scene(int *score_ptr);
~In_Game_Scene();
/**
@@ -152,7 +151,11 @@ namespace scene
*/
void onKey(GLFWwindow* window, int key, int scancode, int action, int mods) override;
/**
* @brief: This method renders the score points onto the game window
* @param score: Score to show
*/
void DrawScore(int score);
};
}

7
src/scenes/scene.h
View File

@@ -19,10 +19,10 @@ namespace scene {
};
class Scene
{
{
public:
virtual ~Scene() = 0;
/**
* @brief the method start is the start of a scene where a while loop runs, this runs the scene.
* @param window the main window of the application
@@ -54,7 +54,6 @@ namespace scene {
* @return void
*/
virtual void onKey(GLFWwindow* window, int key, int scancode, int action, int mods) {};
};
}

2
wk2_fps.vcxproj
View File

@@ -23,6 +23,7 @@
<ClCompile Include="src\entities\main_character.cpp" />
<ClCompile Include="src\entities\house_generator.cpp" />
<ClCompile Include="src\computervision\calibration\HandCalibrator.cpp" />
<ClCompile Include="src\scenes\game_Over_Scene.cpp" />
<ClCompile Include="src\computervision\hand_detect_region.cpp" />
<ClCompile Include="src\scenes\in_Game_Scene.cpp" />
<ClCompile Include="src\computervision\MenuTest.cpp" />
@@ -54,6 +55,7 @@
<ClInclude Include="src\entities\house_generator.h" />
<ClInclude Include="src\computervision\calibration\HandCalibrator.h" />
<ClInclude Include="src\computervision\calibration\StaticSkinTreshold.h" />
<ClInclude Include="src\scenes\game_Over_Scene.h" />
<ClInclude Include="src\computervision\hand_detect_region.h" />
<ClInclude Include="src\scenes\in_Game_Scene.h" />
<ClInclude Include="src\scenes\scene.h" />

2
wk2_fps.vcxproj.filters
View File

@@ -28,6 +28,7 @@
<ClCompile Include="src\entities\house_generator.cpp" />
<ClCompile Include="src\computervision\MenuTest.cpp" />
<ClCompile Include="src\scenes\scene.cpp" />
<ClCompile Include="src\scenes\game_Over_Scene.cpp" />
</ItemGroup>
<ItemGroup>
<ClCompile Include="src\entities\Camera.cpp">
@@ -148,6 +149,7 @@
<ClInclude Include="src\toolbox\Timer.h" />
<ClInclude Include="src\toolbox\toolbox.h" />
<ClInclude Include="src\scenes\startup_Scene.h" />
<ClInclude Include="src\scenes\game_Over_Scene.h" />
</ItemGroup>
<ItemGroup>
<Xml Include="res\haarcascade_frontalface_alt.xml" />