File content as of revision 6:5f76dd718dc3:

/*
ELEC2645 Embedded Systems Project
School of Electronic & Electrical Engineering
University of Leeds
2019/20

Name: Henry Triff
Username: el18ht
Student ID Number: 201224295
Date: 10/02/2020
*/

//LIBRARIES
#include "mbed.h"
#include "Gamepad.h"
#include "N5110.h"
#include "FXOS8700CQ.h"
#include "Graphics.h"
#include "Controls.h"
#include "Mechanics.h"
#include "Menu.h"
#include "LEDs.h"
#include "Ghost.h"
#include <string>

//OBJECTS
Gamepad Device;
N5110 LCD;
FXOS8700CQ Gyro(I2C_SDA,I2C_SCL);
Graphics Graphics;
Controls Controls;
Mechanics Mechanics;
Menu Menu;
LEDs LEDs;
Ghost Ghost;

#ifndef STRUCTS
#define STRUCTS

//STRUCTS
struct Point_2D {
    float x;
    float y;
};
struct Line_2D {
    Point_2D from;
    Point_2D to;
};

struct Square_2D {
    Point_2D TL;
    Point_2D BR;
};
struct Triangle_2D {
    Point_2D TL;
    Point_2D BR;
    int Type;
};

struct Map_Data {
    int number_of_track_lines;
    int number_of_dotted_lines;
    int number_of_flags;
    int number_of_walls;
    int number_of_off_track_squares;
    int number_of_off_track_triangles;
    int number_of_out_of_bounds_squares;
    int number_of_out_of_bounds_triangles;
    int number_of_gates;
    int number_of_boost_plates;
};

struct Time {
    int mins;
    int secs;
    int milis;
};

struct Gyro_Data {
    float ax;
    float ay;
    float az;
    float mx;
    float my;
    float mz;
};

#endif

//MAP - 1
Map_Data Map_1 = {36,1,2,20,14,19,9,5,12,0};

//Lines
const Line_2D Map_1_Track_Lines[36] = {
    //Inside Line
    {{-20,0},{-20,80}},
    {{-20,80},{-40,100}},
    {{-40,100},{-80,100}},
    {{-80,100},{-100,80}},
    {{-100,80},{-100,40}},
    {{-100,40},{-140,0}},
    {{-140,0},{-220,0}},
    {{-220,0},{-260,40}},
    {{-260,40},{-260,80}},
    {{-260,80},{-280,100}},
    {{-280,100},{-320,100}},
    {{-320,100},{-360,60}},
    {{-360,60},{-360,-100}},
    {{-360,-100},{-300,-160}},
    {{-300,-160},{-220,-80}},
    {{-220,-80},{-100,-80}},
    {{-100,-80},{-20,0}},
    //Outside Line
    {{20,-20},{20,100}},
    {{20,100},{-20,140}},
    {{-20,140},{-100,140}},
    {{-100,140},{-140,100}},
    {{-140,100},{-140,60}},
    {{-140,60},{-160,40}},
    {{-160,40},{-200,40}},
    {{-200,40},{-220,60}},
    {{-220,60},{-220,100}},
    {{-220,100},{-260,140}},
    {{-260,140},{-340,140}},
    {{-340,140},{-400,80}},
    {{-400,80},{-400,-120}},
    {{-400,-120},{-320,-200}},
    {{-320,-200},{-280,-200}},
    {{-280,-200},{-200,-120}},
    {{-200,-120},{-80,-120}},
    {{-80,-120},{20,-20}},
};

//Dotted Lines
const Line_2D Map_1_Track_Dotted_Lines[1] = {
    {{-20,0},{20,0}},
};

//Flags
Point_2D Map_1_Flags[2] = {
    {-20,0},
    {24,0}
};

//Walls
Line_2D Map_1_Walls[20] = {
    //Inside
    {{-40,80},{-40,0}},
    {{-40,0},{-100,-60}},
    {{-100,-60},{-240,-60}},
    {{-240,-60},{-300,-120}},
    {{-300,-120},{-340,-60}},
    {{-340,-60},{-340,60}},
    {{-340,60},{-280,60}},
    {{-280,60},{-280,-20}},
    {{-280,-20},{-100,-20}},
    {{-100,-20},{-80,0}},
    {{-80,0},{-80,80}},
    {{-80,80},{-40,80}},
    //Outside
    {{40,160},{40,-220}},
    {{40,-220},{-420,-220}},
    {{-420,-220},{-420,160}},
    {{-420,160},{-200,160}},
    {{-200,160},{-200,60}},
    {{-200,60},{-160,60}},
    {{-160,60},{-160,160}},
    {{-160,160},{40,160}},
};

//Off track? objects
Square_2D Map_1_Off_Track_Square[14] = {
    //Inside
    {{-100,80},{-20,0}},
    {{-80,100},{-40,80}},
    {{-260,0},{-100,-80}},
    {{-360,60},{-260,-100}},
    {{-320,100},{-280,60}},
    {{-280,80},{-260,60}},
    {{-300,-100},{-260,-120}},
    {{-200,60},{-60,40}},
    {{-220,140},{-140,60}},
    {{-200,-120},{20,-200}},
    {{-400,200},{20,140}},
    {{-500,200},{-400,-300}},
    {{20,200},{100,-300}},
    {{-400,-200},{20,-300}}
};

//Off track? objects
Triangle_2D Map_1_Off_Track_Triangle[19] = {
    {{-40,100},{-20,80},1},
    {{-100,100},{-80,80},4},
    {{-140,40},{-100,0},4},
    {{-100,0},{-20,-80},2}, //
    {{-260,40},{-220,0},1},
    {{-260,-80},{-220,-120},2},
    {{-200,-120},{-260,-160},2},
    {{-280,100},{-260,80},1},
    {{-360,100},{-320,60},4},
    {{-360,-100},{-300,-160},3},
    //Outside
    {{-20,140},{20,100},3},
    {{-80,-20},{20,-120},4},
    {{-140,140},{-100,100},2},
    {{-160,60},{-140,40},2}, //
    {{-220,60},{-200,40},3},
    {{-280,-120},{-200,-200},4},
    {{-260,140},{-240,100},3},
    {{-400,140},{-340,80},2}, //
    {{-400,-120},{-320,-200},1}
};

Square_2D Map_1_Out_Of_Bounds_Square[9] = {
    //Inside
    {{-80,80},{-40,0}},
    {{-340,60},{-280,-60}},
    {{-280,-20},{-100,-60}},
    {{-80,0},{-60,-20}},
    //Outside
    {{40,160},{60,-220}},
    {{-420,-220},{40,-240}},
    {{-440,160},{-420,-220}},
    {{-420,180},{40,160}},
    {{-200,160},{-160,60}}
};

Triangle_2D Map_1_Out_Of_Bounds_Triangle[5] = {
    //Inside
    {{-60,0},{-40,-20},2},
    {{-100,0},{-80,-20},4},
    {{-100,-20},{-60,-60},2},
    {{-300,-60},{-240,-120},2},
    {{-340,-60},{-300,-120},3}
};

Square_2D Map_1_Gates[12] = {
    {{-40,0},{40,-10}},
    {{-40,80},{40,70}},
    {{-80,160},{-70,80}},
    {{-160,70},{-80,60}},
    {{-200,60},{-190,-20}},
    {{-310,160},{-300,60}},
    {{-420,10},{-340,0}},
    {{-420,-90},{-300, -100}},
    {{-300,-100},{-290,-220}},
    {{-200,-60},{-190,-220}},
    {{-110,-60},{-100,-220}},
    {{-100,-40},{40,-60}}
};

Triangle_2D Map_1_Boost_Plates[0] = {
};

//GLOBAL VARIABLES

//Transform
int angle = 0;
Point_2D translation = {0,0};
float squish = 0.15;

//Vehicle parameters
float speed = 0;
float max_speed = 4;
int handling = 2;

//Mechanics
bool off_track = false;
bool out_of_bounds = false;
int lap_gate = 0;
int laps = 1;
int number_of_laps = 3;
bool direction = true;
int race_time = 0;
bool ghost_available = false;

//Game parameters
int game_fps = 50;
bool back_light = true;
bool leds = true;
bool rumble = true;
bool gyro_enabled = false;

int main()
{
    LCD.init();
    Device.init();
    Gyro.init();
    Graphics.Change_Contrast(LCD,Device);

    //MENU

    /*int main_option_selected;
    int settings_option_selected;

    while(main_option_selected != 1) {
        main_option_selected = Menu.Main_Menu(LCD, Device);

        if(main_option_selected == 2) {
            while(settings_option_selected != 0) {
                //settings_option_selected = Menu.Settings_Menu(LCD, Device);
                if(settings_option_selected == 1) {

                }
                if(settings_option_selected == 2) {

                }
                if(settings_option_selected == 3) {

                }

            }
        }
        if(main_option_selected == 3) {
            Menu.Credits_Menu(LCD, Device);
        }

    }*/

    while(1) {

        //COUNTDOWN

        LCD.clear();
        Graphics.Draw_Map(
            translation,
            angle,
            squish,
            (Line_2D *) Map_1_Track_Lines,
            (Line_2D *)Map_1_Track_Dotted_Lines,
            (Line_2D *)Map_1_Walls,
            (Point_2D *)Map_1_Flags,
            (Triangle_2D *)Map_1_Boost_Plates,
            Map_1,
            Ghost.Play(ghost_available, race_time),
            LCD
        );
        Graphics.Start_Sequence(3, LCD);
        LCD.refresh();
        wait(1);

        LCD.clear();
        Graphics.Draw_Map(
            translation,
            angle,
            squish,
            (Line_2D *) Map_1_Track_Lines,
            (Line_2D *)Map_1_Track_Dotted_Lines,
            (Line_2D *)Map_1_Walls,
            (Point_2D *)Map_1_Flags,
            (Triangle_2D *)Map_1_Boost_Plates,
            Map_1,
            Ghost.Play(ghost_available, race_time),
            LCD
        );
        Graphics.Start_Sequence(2, LCD);
        LEDs.Start_Sequence(back_light, 2, Device);
        LCD.refresh();
        wait(1);

        LCD.clear();
        Graphics.Draw_Map(
            translation,
            angle,
            squish,
            (Line_2D *) Map_1_Track_Lines,
            (Line_2D *)Map_1_Track_Dotted_Lines,
            (Line_2D *)Map_1_Walls,
            (Point_2D *)Map_1_Flags,
            (Triangle_2D *)Map_1_Boost_Plates,
            Map_1,
            Ghost.Play(ghost_available, race_time),
            LCD
        );
        Graphics.Start_Sequence(1, LCD);
        LEDs.Start_Sequence(back_light, 1, Device);
        LCD.refresh();
        wait(1);
        LCD.clear();
        Graphics.Draw_Map(
            translation,
            angle,
            squish,
            (Line_2D *) Map_1_Track_Lines,
            (Line_2D *)Map_1_Track_Dotted_Lines,
            (Line_2D *)Map_1_Walls,
            (Point_2D *)Map_1_Flags,
            (Triangle_2D *)Map_1_Boost_Plates,
            Map_1,
            Ghost.Play(ghost_available, race_time),
            LCD
        );
        Graphics.Start_Sequence(0, LCD);
        LEDs.Start_Sequence(back_light, 0, Device);
        LCD.refresh();
        wait(1);
        LEDs.Clear(Device);

        while(laps <= number_of_laps) {
            //MECHANICS
            off_track = Mechanics.Is_Offtrack(translation, Map_1_Off_Track_Square, Map_1_Off_Track_Triangle, Map_1);
            out_of_bounds = Mechanics.Is_Out_Of_Bounds(translation, Map_1_Out_Of_Bounds_Square, Map_1_Out_Of_Bounds_Triangle, Map_1);
            laps = Mechanics.Get_Laps(laps, Map_1_Gates, Map_1.number_of_gates, translation, lap_gate);
            lap_gate = Mechanics.Get_Gate(Map_1_Gates, Map_1.number_of_gates, translation, lap_gate);

            //CONTROLS
            angle = Controls.Get_Angle(angle, handling, gyro_enabled, Gyro, Device);
            translation = Controls.Get_Translation(translation, angle, speed, out_of_bounds, Device);
            speed = Controls.Get_Speed(speed, max_speed, off_track, out_of_bounds, Device);
            speed = Mechanics.Get_Boost_Speed(Map_1_Boost_Plates, Map_1.number_of_boost_plates, translation, speed);

            //LEDS
            LEDs.Speed(leds, speed, max_speed, Device);

            //GHOST
            Ghost.Record(translation, race_time);

            //GRAPHICS
            LCD.clear();
            Graphics.Change_Contrast(LCD,Device);
            Graphics.Draw_Map(
                translation,
                angle,
                squish,
                (Line_2D *) Map_1_Track_Lines,
                (Line_2D *)Map_1_Track_Dotted_Lines,
                (Line_2D *)Map_1_Walls,
                (Point_2D *)Map_1_Flags,
                (Triangle_2D *)Map_1_Boost_Plates,
                Map_1,
                Ghost.Play(ghost_available, race_time),
                LCD
            );
            Graphics.Draw_Laps(laps, LCD);
            Graphics.Draw_Time(false, Mechanics.Convert_To_Time(game_fps, race_time), LCD);
            LCD.refresh();
            wait((1 / float(game_fps)));
            race_time++;

        }
        LEDs.Clear(Device);
        LCD.clear();
        Graphics.Draw_Map(
            translation,
            angle,
            squish,
            (Line_2D *) Map_1_Track_Lines,
            (Line_2D *)Map_1_Track_Dotted_Lines,
            (Line_2D *)Map_1_Walls,
            (Point_2D *)Map_1_Flags,
            (Triangle_2D *)Map_1_Boost_Plates,
            Map_1,
            Ghost.Play(ghost_available, race_time),
            LCD
        );
        Graphics.Finish(LCD);
        Graphics.Draw_Time(true, Mechanics.Convert_To_Time(game_fps, race_time), LCD);
        LCD.refresh();
        ghost_available = true;
        Ghost.Copy(race_time);

        //RESET
        angle = 0;
        Point_2D test = {0,0};
        translation = test;
        squish = 0.15;
        speed = 0;
        max_speed = 4;
        handling = 2;
        off_track = false;
        out_of_bounds = false;
        lap_gate = 0;
        laps = 1;
        direction = true;
        race_time = 0;

        wait(3);
    }
}