game_state.cpp

#include "game_state.h"
#include "object.h"
#include "context.h"
#include "skydome.h"
#include "helper.h"
#include "plane.h"
#include "terrain_map.h"
#include "loops.h"

#include "MicroGlut.h"
#include "GL_utilities.h"
#include "VectorUtils4.h"
#include "LittleOBJLoader.h"
#include "LoadTGA.h"

#include <iostream>

Game_State::Game_State(Context *c) : State(c->settings["game_state"], c)
{
    map = new TerrainMap(context->settings["terrain"], cameraPosition, frustum_obj);
    skydome = new Skydome(context->settings["skydome"], cameraPosition);
    plane = new Plane(context->settings["planes"][0], vec3(0,150,0));
    loop = new Loops(context->settings["loops"], vec3(0, 150, -1000));
    glutHideCursor();
    return;
}

void Game_State::keyboard(unsigned char key, int x, int y)
{
    State::keyboard(key, x, y);

    switch (key)
    {
        case '1':
        {
            if (current_plane == 0)
                break;
            vec3 tmp_pos = plane->get_lookAtPoint();
            delete plane;
            plane = new Plane(context->settings["planes"][0], tmp_pos);
            current_plane = 0;
            break;
        }

        case '2':
        {
            if (current_plane == 1)
                break;
            vec3 tmp_pos = plane->get_lookAtPoint();
            delete plane;
            plane = new Plane(context->settings["planes"][1], tmp_pos);
            current_plane = 1;
            break;
        }

        case '3':
        {
            if (current_plane == 2)
                break;
            vec3 tmp_pos = plane->get_lookAtPoint();
            delete plane;
            plane = new Plane(context->settings["planes"][2], tmp_pos);
            current_plane = 2;
            break;
        }

        case 'k':
        {
            light_intensity -= 0.1;
            if (light_intensity < 0.1)
                light_intensity = 0.1;
            break;
        }
        case 'l':
        {
            light_intensity += 0.1;
            if (light_intensity > 1.0)
                light_intensity = 1.0;
            break;
        }
        case 'r':
        {
            loop_on = !loop_on;
            break;
        }
    }

}

void Game_State::mouse(int x, int y)
{
    if (!keys_toggle['m'])
    {
        return;
    }

    // Warp the cursor back to the center of the window
    glutWarpPointer(glutGet(GLUT_WINDOW_WIDTH) / 2, glutGet(GLUT_WINDOW_HEIGHT) / 2);
    if (deltaX == -1 && deltaY == -1)
    {
        deltaX = 0;
        deltaY = 0;
        return;
    }
    // Calculate the delta from the center of the window
    int deltaX = x - glutGet(GLUT_WINDOW_WIDTH) / 2;
    int deltaY = y - glutGet(GLUT_WINDOW_HEIGHT) / 2;

    // Update theta and phi based on the mouse movement
    theta += deltaX * 0.001f;
    phi -= deltaY * 0.001f;

    // Clamp phi to be between -pi/2 and pi/2 to prevent the camera from flipping upside down
    float epsilon = 0.01f; // Small value to prevent phi from reaching exactly 0 or pi/2
    phi = std::max(std::min(phi, M_PI / 2.0f - epsilon), epsilon - M_PI / 2.0f);

    // Calculate the direction vector
    mouse_direction = vec3(cos(phi) * cos(theta), sin(phi), cos(phi) * sin(theta));
}

void Game_State::move_camera(int time_elapsed)
{
    if (!keys_toggle['m'])
    {
        world2view = plane->get_lookAtMatrix();
    }
    else
    {
        cameraPosition = plane->get_pos();
        lookAtPoint = mouse_direction + cameraPosition;
        upVector = vec3(0, 1, 0);
        world2view = lookAtv(cameraPosition, lookAtPoint, upVector);
    }
}

void Game_State::update(int time_elapsed)
{
    // Update camera etc. here, then update objects.

    plane->update(time_elapsed, plane->get_pos(), lookAtPoint, keys_pressed);
    map->update(plane->get_pos(), world2view);
    skydome->update(time_elapsed, plane->get_pos(), lookAtPoint, keys_pressed);
    if (loop_on) {
        loop->update(time_elapsed, plane->get_pos(), plane -> get_lookAtPoint(), keys_pressed);
    }

    for (Object *object : objects)
    {
        object->update(time_elapsed, plane->get_pos(), plane -> get_lookAtPoint(), keys_pressed);
    }
    move_camera(time_elapsed);

    // Check for collisions
    std::map<std::pair<int, int>, int> points = plane->get_points_on_radius();

    if (map->collision(points))
    {
        std::cout << "Collision detected" << std::endl;
        delete plane;
        plane = new Plane(context->settings["planes"][current_plane], vec3(0,150,0));
        return;
    }
}

void Game_State::display()
{
    // Upload matrices to shader, then display objects, map etc.
    // We make sure to use the program before uploading matrices.
    glUseProgram(program);
    upload2shader();

    cameraPosition = plane->get_pos();

    skydome->display(program, world2view, projection, light_intensity);
    
    glUniform1i(glGetUniformLocation(program, "map"), 1);
    map->display(program, world2view, projection, plane->get_pos());

    glUniform1i(glGetUniformLocation(program, "map"), 0);
    plane->display(program, world2view, projection);

    if (loop_on) {
        glUniform1i(glGetUniformLocation(program, "map"), 2);
        loop->display(program, world2view, projection);
    }

}

Game_State::~Game_State()
{
    // Objects, ground and skydome are deleted in State
    // Program is deleted in State
    delete plane;
    delete loop;
    return;
}