sigonasr2
/
Smoke
generated from sigonasr2/CPlusPlusProjectTemplate
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
It's smoke
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1 Commit
1 Branch
0 Tags
1.1 MiB
Tag: Branch: Tree: 07131c8693
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '07131c8693'
${ noResults }
Smoke/main.cpp

1135 lines
33 KiB
Raw Blame History

//--------------------------------------------------------------------------------------------------
// F4 Racing
//--------------------------------------------------------------------------------------------------
// This is an advancement in my game making skills, building off the back of my work on the "Collect the Balls" game.
//--------------------------------------------------------------------------------------------------
// created by Rune
// black box code by Sigonasr2 from the OLC (one lone coder) Discord server
//--------------------------------------------------------------------------------------------------
#define OLC_PGE_APPLICATION
#include "pixelGameEngine.h" // used for drawing the game
//--------------------------------------------------------------------------------------------------
// class
//--------------------------------------------------------------------------------------------------
class Racer : public olc::PixelGameEngine
{
public:
Racer()
{
sAppName = "F4 Racing";
}
private:
float car_pos = 0.0f;
float distance = 0.0f;
float speed = 0.0f;
float curvature = 0.0f;
float track_curve = 0.0f;
float car_curve = 0.0f;
float track_dist = 0.0f;
float cur_lap_time = 0.0f;
std::vector<std::pair<float, float>> vecTrack;
std::list<float> list_times;
bool bothKeysPressed = false; // checking for dual key press; could probably work with more than 2 keys
// custom control template
olc::Key Move_Up = olc::W;
olc::Key Move_Down = olc::S;
olc::Key Move_Left = olc::A;
olc::Key Move_Right = olc::D;
std::array<std::string, 4> keyslist = { "UP", "DOWN", "LEFT", "RIGHT" };
int configKeyIndex = -1;
char pressedKey;
int cup = -1; // for cup selection screen
int track = -1; // for track selection screen
int player = 0; // for car selection screen
bool start = false;
public:
// Menu Setup
//----------------------------------------
bool activeOption = true; // highlighting current option
int highlighted=0;
struct MenuItem
{
std::string label; // label
olc::vi2d pos; // label's position
std::string label2; // another label to right of label
};
struct Object
{
olc::vf2d pos{ 0, 0 }; // the x position represents how far to the left/right it is from the center. -1 ~ 1: road's range; the y position is how far along the track it is
olc::vf2d size{ 1, 1 };
olc::Decal* decal = nullptr;
olc::vf2d offset{ 0, 0 }; // how far off the image will be
bool rendered = false;
olc::vf2d drawPos;
olc::vf2d drawSize;
olc::vf2d drawOffsetPos;
};
std::vector<MenuItem> mainMenu;
std::vector<MenuItem> playGame;
std::vector<MenuItem> pickTrack;
std::vector<MenuItem> grandPrix;
std::vector<MenuItem> selectCar;
std::vector<MenuItem> controls;
std::vector<std::string> gameOver;
std::vector<Object> gameObjects;
enum class state
{
MAIN_MENU,
PLAY_GAME,
CAR_SELECT,
CONTROLS,
RUN_GAME,
// game
TRACK_SELECT,
CUP_SELECT,
// tracks
CIRCUIT,
FIG_EIGHT,
ARROW_HEAD,
track_4,
OVERPASS,
PEANUT,
track_6,
track_7,
track_8,
track_9,
JX9, // special track ;)
// cups
INDIE,
STREET,
PRO,
GRAND_PRIX
};
state gameState = state::MAIN_MENU;
// Variables
//----------------------------------------
// lap times
// player
int score; // score at end of track; based on final place
int lap; // current lap player is on
int place; // current place player is in
olc::Decal* car; // initialize car
olc::Decal* hill; // initialize hill
olc::Decal* grass; // initialize grass
olc::Decal* road; // initialize road, curbs, and finish line
olc::Decal* banner; // initialize banner
olc::Decal* title; // initialize title banner
std::string KeyToString(olc::Key key)
{
const std::array<std::string, 98> keyStrings =
{
"NONE","A","B","C","D","E","F","G","H","I","J","K","L","M","N","O","P","Q","R","S","T","U","V","W","X","Y","Z","0","1","2","3","4","5","6","7","8","9",
"F1","F2","F3","F4","F5","F6","F7","F8","F9","F10","F11","F12","UP","DOWN","LEFT","RIGHT","SPACE","TAB","SHIFT","CTRL","INS","DEL","HOME","END","PGUP","PGDN","BACK","ESCAPE","ENTER","ENTER",
"PAUSE","SCROLL LK","Kp-0","Kp-1","Kp-2","Kp-3","Kp-4","Kp-5","Kp-6","Kp-7","Kp-8","Kp-9","Kp-*","Kp-/","Kp-+","Kp--","Kp-.",".","=",",","-","OEM_1",
"OEM_2","OEM_3","OEM_4","OEM_5","OEM_6","OEM_7","OEM_8","CAPS LOCK","END"
};
return keyStrings[key];
}
//--------------------------------------------------------------------------------------------------
// Create Game Objects
//--------------------------------------------------------------------------------------------------
bool OnUserCreate() override
{
mainMenu = // show menu options
{
{ "START GAME", { ScreenWidth() / 2, ScreenHeight() / 5 * 3} },
{ "CONTROLS", { ScreenWidth() / 2, ScreenHeight() / 5 * 3 + 64} },
{ "QUIT", {ScreenWidth() / 2, ScreenHeight() / 5 * 3 + 128 } }
};
playGame =
{
{ "TRACK SELECTION", { ScreenWidth() / 2, ScreenHeight() / 4 } },
{ "GRAND PRIX", { ScreenWidth() / 2, ScreenHeight() / 2 } },
{ "BACK", { ScreenWidth() / 2, ScreenHeight() / 6 * 5} }
};
pickTrack = // show track options
{
{ "CIRCUIT", { ScreenWidth() / 4, ScreenHeight() / 4 } },
{ "INFINITY", { ScreenWidth() / 2, ScreenHeight() / 4 } },
{ "ARROWHEAD", { ScreenWidth() / 4 * 3, ScreenHeight() / 4 } },
{"Track 4", { ScreenWidth() / 4, ScreenHeight() / 2 }},
{ "OVERPASS", { ScreenWidth() / 2, ScreenHeight() / 2 } },
{"Track 6", { ScreenWidth() / 4 * 3, ScreenHeight() / 2 } } ,
{"Track 7", { ScreenWidth() / 4, ScreenHeight() / 4 * 3 } },
{"Track 8", { ScreenWidth() / 2, ScreenHeight() / 4 * 3 } },
{"Track 9", { ScreenWidth() / 4 * 3, ScreenHeight() / 4 * 3 } },
{ "BACK", { ScreenWidth() / 2, ScreenHeight() / 6 * 5} }
};
grandPrix = // show race cups
{
{ "INDIE CUP", { ScreenWidth() / 3, ScreenHeight() / 3 } },
{ "STREET CUP", { ScreenWidth() / 3 * 2, ScreenHeight() / 3 } },
{ "PRO CUP", { ScreenWidth() / 3, ScreenHeight() / 3 * 2 } },
{ "GRAND PRIX", { ScreenWidth() / 3 * 2, ScreenHeight() / 3 * 2 } },
{ "BACK", { ScreenWidth() / 2, ScreenHeight() / 6 * 5 } }
};
selectCar = // pick a color
{
{ "RED", { ScreenWidth() / 5, ScreenHeight() / 3 } },
{ "BLUE", { ScreenWidth() / 5 * 2, ScreenHeight() / 3 } },
{ "GREEN", { ScreenWidth() / 5 * 3, ScreenHeight() / 3 } },
{ "GOLD", { ScreenWidth() / 5 * 4, ScreenHeight() / 3 } },
{ "PURPLE", { ScreenWidth() / 5, ScreenHeight() / 3 * 2 } },
{ "WHITE", { ScreenWidth() / 5 * 2, ScreenHeight() / 3 * 2 } },
{ "ORANGE", { ScreenWidth() / 5 * 3, ScreenHeight() / 3 * 2 } },
{ "BLACK", { ScreenWidth() / 5 * 4, ScreenHeight() / 3 * 2 } },
{ "BACK", { ScreenWidth() / 2, ScreenHeight() / 6 * 5} }
};
controls = // customize controls
{
{ "FORWARD", { ScreenWidth() / 3, ScreenHeight() / 9 * 2 }, KeyToString(Move_Up) },
{ "BACK", { ScreenWidth() / 3, ScreenHeight() / 9 * 3 }, KeyToString(Move_Down) },
{ "LEFT", { ScreenWidth() / 3, ScreenHeight() / 9 * 4 }, KeyToString(Move_Left) },
{ "RIGHT", { ScreenWidth() / 3, ScreenHeight() / 9 * 5 }, KeyToString(Move_Right) },
{ "DEFAULT", { ScreenWidth() / 2, ScreenHeight() / 9 * 6} },
{ "BACK", { ScreenWidth() / 2, ScreenHeight() / 6 * 5} }
};
gameOver = { "Return to Main Menu" };
//----------------------------------------
car = new olc::Decal(new olc::Sprite("art/car.png")); // load car
hill = new olc::Decal(new olc::Sprite("art/hills.png"), false, false); // load hill
grass = new olc::Decal(new olc::Sprite("art/grass.png"), false, false); // load grass
road = new olc::Decal(new olc::Sprite("art/road.png"), false, false); // load road, curbs, and finish line
banner = new olc::Decal(new olc::Sprite("art/start.png"), false, false); // load banner
title = new olc::Decal(new olc::Sprite("art/title.png")); // load title banner
//----------------------------------------
//----------------------------------------
// may need to separate the track list into it's own function so as to declutter this one
// especially, given that there's a bunch of stuff going on with the tracks with much redundancy
// JX9 track layout
// javidx9()
{
// these happen to be measured in meters, as per Javid's original construction
// they'll likely be wonky for the game as it's not really modified to fit my units of measure
vecTrack.push_back(std::make_pair(0.0f, 10.0f)); // flag (straight)
vecTrack.push_back(std::make_pair(0.0f, 200.0f)); // straight
vecTrack.push_back(std::make_pair(1.0f, 200.0f)); // sharp right
vecTrack.push_back(std::make_pair(0.0f, 400.0f)); // long straight
vecTrack.push_back(std::make_pair(-1.0f, 100.0f)); // soft left
vecTrack.push_back(std::make_pair(0.0f, 200.0f)); // straight
vecTrack.push_back(std::make_pair(-1.0f, 200.0f)); // sharp left
vecTrack.push_back(std::make_pair(1.0f, 200.0f)); // sharp right
vecTrack.push_back(std::make_pair(0.0, 200.0f)); // straight
vecTrack.push_back(std::make_pair(0.2f, 500.0f)); // gradual right
vecTrack.push_back(std::make_pair(0.0f, 200.0f)); // straight
}
// all 9 tracks below are running on yards for their distance units
// this means the end results are in miles; rather than kilometers
// enjoy the US measures of Burgers per Freedom Eagle
/*{
// Classic Oval
// Circuit()
{
// 1 mile loop; 1,760 yards
vecTrack.push_back(std::make_pair(0.0f, 10.0f)); // flag (straight)
vecTrack.push_back(std::make_pair(0.0f, 270.0f)); // straight
vecTrack.push_back(std::make_pair(-1.0f, 330.0f)); // left
vecTrack.push_back(std::make_pair(0.0f, 550.0f)); // straight
vecTrack.push_back(std::make_pair(-1.0f, 330.0f)); // left
vecTrack.push_back(std::make_pair(0.0f, 270.0f)); // straight
}
// Infinity
// FigureEight()
{
vecTrack.push_back(std::make_pair(0.0f, 10.0f)); // flag (straight); this is positioned somewhere after the intersection
vecTrack.push_back(std::make_pair(0.0f, 0.0f)); // straight
vecTrack.push_back(std::make_pair(-1.0f, 0.0f)); // left
vecTrack.push_back(std::make_pair(0.0f, 0.0f)); // straight; this crosses the first straight, to provide for chances of crashing
vecTrack.push_back(std::make_pair(1.0f, 0.0f)); // right
vecTrack.push_back(std::make_pair(0.0f, 0.0f)); // straight
}
// Arrow Head
// ArrowHead()
{
// miles
vecTrack.push_back(std::make_pair(0.0f, 10.0f)); // flag (straight)
vecTrack.push_back(std::make_pair(0.0f, 0.0f)); // straight
vecTrack.push_back(std::make_pair(1.0f, 0.0f)); // right
vecTrack.push_back(std::make_pair(0.0f, 0.0f)); // straight
vecTrack.push_back(std::make_pair(1.0f, 0.0f)); // right
vecTrack.push_back(std::make_pair(-1.0f, 0.0f)); // left
vecTrack.push_back(std::make_pair(1.0f, 0.0f)); // right
vecTrack.push_back(std::make_pair(0.0f, 0.0f)); // straight
}
// track 4
// ???()
{
vecTrack.push_back(std::make_pair(0.0f, 10.0f)); // flag (straight)
}
// Over/Under
// OverPass()
{
vecTrack.push_back(std::make_pair(0.0f, 10.0f)); // flag (straight)
vecTrack.push_back(std::make_pair(0.0f, 0.0f)); // straight
vecTrack.push_back(std::make_pair(1.0f, 0.0f)); // right
vecTrack.push_back(std::make_pair(0.0f, 0.0f)); // straight
vecTrack.push_back(std::make_pair(1.0f, 0.0f)); // right
vecTrack.push_back(std::make_pair(1.0f, 0.0f)); // right
vecTrack.push_back(std::make_pair(0.0f, 0.0f)); // straight
vecTrack.push_back(std::make_pair(1.0f, 0.0f)); // right
vecTrack.push_back(std::make_pair(0.0f, 0.0f)); // straight
}
// track 6
// ???()
{
vecTrack.push_back(std::make_pair(0.0f, 10.0f)); // flag (straight)
}
// track 7
// ???()
{
vecTrack.push_back(std::make_pair(0.0f, 10.0f)); // flag (straight)
}
// track 8
// ???()
{
vecTrack.push_back(std::make_pair(0.0f, 10.0f)); // flag (straight)
}
// track 9
// ???()
{
vecTrack.push_back(std::make_pair(0.0f, 10.0f)); // flag (straight)
}
}//*/
for (auto t : vecTrack)
{
track_dist += t.second;
}
distance = track_dist - 100;
list_times = { 0,0,0,0,0 };
gameObjects.push_back({ /*{-1.5,track_dist - 50}, {10,6}, {0,240}*/ });
return true;
}
//--------------------------------------------------------------------------------------------------
// reset game
//--------------------------------------------------------------------------------------------------
void Reset()
{
car_pos = 0.0f;
distance = 0.0f;
speed = 0.0f;
curvature = 0.0f;
track_curve = 0.0f;
car_curve = 0.0f;
//track_dist = 0.0f; will need to be moved elsewhere; the game will calculate *ALL* track sizes at the start, and then simply use the appropriate numbers when loading each track on request
cur_lap_time = 0.0f;
// Note: the following all need to be reset during the process, when they've been implemented
// -player position (on screen)
// -player position (on track)
// -track section
// -all lap times
// -score
//
// if called from other parts of the program, other than the 'F1' key, it should be resetting to the menu
// the 'F1' key is meant to reset the player on the current track they're on
//
}
//--------------------------------------------------------------------------------------------------
// main menu
//--------------------------------------------------------------------------------------------------
void DisplayMenu(std::vector<MenuItem> list)
{
// drawing and coloring menu selections
for (int i = 0; i < list.size(); i++)
{
olc::vi2d textSize = GetTextSize(list[i].label) / 2 * 4;
olc::Pixel textCol = olc::GREY; // greys out unselected options
if (highlighted == i)
{
textCol = olc::Pixel(255, 201, 14); // gold
}
DrawStringDecal(list[i].pos - textSize, list[i].label, textCol, { 4.0f, 4.0f });
if (list[i].label2.size() > 0)
{
olc::vi2d offset = { ScreenWidth() / 3, -textSize.y / 2 };
DrawStringDecal(list[i].pos + offset, list[i].label2, textCol, { 4.0f, 4.0f });
}
}
// selecting options
highlighted = std::clamp(highlighted, 0, (int)list.size() - 1); // loop if out of range
int shortestDist=9999999;
int largestDist=-9999999;
int targetItem=highlighted;
if (GetKey(olc::Key::DOWN).bPressed) {
for (int i=0;i<list.size();i++) {
if (highlighted!=i) {
if (list[highlighted].pos.x==list[i].pos.x) {
if (list[highlighted].pos.y<list[i].pos.y) { //It's below us.
int dist = abs(list[highlighted].pos.y-list[i].pos.y);
if (dist<shortestDist) {
targetItem=i;
shortestDist=dist;
}
}
}
}
}
for (int i=0;i<list.size();i++) {
if (highlighted!=i) {
if (list[highlighted].pos.y<list[i].pos.y) { //It's below us.
int dist = abs(list[highlighted].pos.y-list[i].pos.y);
if (dist<shortestDist) {
targetItem=i;
shortestDist=dist;
}
}
}
}
if (highlighted==targetItem) { //It failed, try another method.
targetItem=0;
}
highlighted=targetItem;
}
if (GetKey(olc::Key::UP).bPressed) {
for (int i=0;i<list.size();i++) {
if (highlighted!=i) {
if (list[highlighted].pos.x==list[i].pos.x) {
if (list[highlighted].pos.y>list[i].pos.y) { //It's above us.
int dist = abs(list[highlighted].pos.y-list[i].pos.y);
if (dist<shortestDist) {
targetItem=i;
shortestDist=dist;
}
}
}
}
}
for (int i=0;i<list.size();i++) {
if (highlighted!=i) {
if (list[highlighted].pos.y>list[i].pos.y) { //It's above us.
int dist = abs(list[highlighted].pos.y-list[i].pos.y);
if (dist<shortestDist) {
targetItem=i;
shortestDist=dist;
}
}
}
}
if (highlighted==targetItem) { //It failed, try another method.
targetItem=list.size()-1;
}
highlighted=targetItem;
}
if (GetKey(olc::Key::RIGHT).bPressed) {
for (int i=0;i<list.size();i++) {
if (highlighted!=i) {
if (list[highlighted].pos.y==list[i].pos.y) {
if (list[highlighted].pos.x<list[i].pos.x) { //It's to the right of us.
int dist = abs(list[highlighted].pos.x-list[i].pos.x);
if (dist<shortestDist) {
targetItem=i;
shortestDist=dist;
}
}
}
}
}
if (highlighted==targetItem) { //It failed, try another method.
for (int i=0;i<list.size();i++) {
if (highlighted!=i) {
if (list[highlighted].pos.y==list[i].pos.y) {
if (list[highlighted].pos.x>list[i].pos.x) { //It's to the left of us.
int dist = abs(list[highlighted].pos.x-list[i].pos.x);
if (dist>largestDist) {
targetItem=i;
largestDist=dist;
}
}
}
}
}
}
highlighted=targetItem;
}
if (GetKey(olc::Key::LEFT).bPressed) {
for (int i=0;i<list.size();i++) {
if (highlighted!=i) {
if (list[highlighted].pos.y==list[i].pos.y) {
if (list[highlighted].pos.x>list[i].pos.x) { //It's to the left of us.
int dist = abs(list[highlighted].pos.x-list[i].pos.x);
if (dist<shortestDist) {
targetItem=i;
shortestDist=dist;
}
}
}
}
}
if (highlighted==targetItem) { //It failed, try another method.
for (int i=0;i<list.size();i++) {
if (highlighted!=i) {
if (list[highlighted].pos.y==list[i].pos.y) {
if (list[highlighted].pos.x<list[i].pos.x) { //It's to the right of us.
int dist = abs(list[highlighted].pos.x-list[i].pos.x);
if (dist>largestDist) {
targetItem=i;
largestDist=dist;
}
}
}
}
}
}
highlighted=targetItem;
}
if (highlighted >= (int)list.size())
{
highlighted = 0; // wrap around when above max
}
if (highlighted < 0)
{
highlighted = list.size() - 1; // wrap around when below zero
}
}
//--------------------------------------------------------------------------------------------------
// controls
//--------------------------------------------------------------------------------------------------
void GetAnyKeyPress(olc::Key keypress) override
{
if (configKeyIndex != -1)
{
switch (configKeyIndex)
{
case 0:
{
Move_Up = keypress;
}break;
case 1:
{
Move_Right = keypress;
}break;
case 2:
{
Move_Left = keypress;
}break;
case 3:
{
Move_Down = keypress;
}break;
}
controls[configKeyIndex].label2 = KeyToString(keypress);
configKeyIndex = -1;
}
}
//--------------------------------------------------------------------------------------------------
// Main Game Function
//--------------------------------------------------------------------------------------------------
bool OnUserUpdate(float fElapsedTime) override
{
if (GetKey(olc::Key::CTRL).bHeld && GetKey(olc::Key::F12).bHeld && !bothKeysPressed)
{
return false;
}
// dry skybox
GradientFillRectDecal({ 0.0f, 0.0f }, { ScreenWidth() + 0.0f, ScreenHeight() / 2 + 0.0f }, olc::DARK_BLUE, olc::BLUE, olc::BLUE, olc::DARK_BLUE);
// the hills have eyes; y'know, like in Super Mario Bros. What reference did you think was going to be here?
DrawPartialDecal({ 0.0f, ScreenHeight() / 2 - 100.0f }, hill, { 0.0f + track_curve * 200, 0.0f }, { ScreenWidth() + 0.0f, (float)hill->sprite->height }, { 1.5f, 1.0f });
//DrawPartialDecal({ 180.0f, ScreenHeight() / 2 - 100.0f }, hill, { 0.0f + track_curve * 200, 0.0f }, { ScreenWidth() + 0.0f, (float)hill->sprite->height });
// draw grass
DrawPartialWarpedDecal(grass, { { 0.0f, ScreenHeight() / 2 + 0.0f }, { -ScreenWidth() * 2 + 0.0f, ScreenHeight() + 0.0f}, { ScreenWidth() * 2 + ScreenWidth() + 0.0f, ScreenHeight() + 0.0f }, { ScreenWidth() + 0.0f, ScreenHeight() / 2 + 0.0f } }, { 0.0f, -distance }, { 1 * 32, 4 * 64 });
//--------------------------------------------------------------------------------------------------
if (gameState == state::MAIN_MENU)
{
// display title
DrawDecal({ 95.5f, 95.5f }, title/*, {0.4f, 0.4f}*/);
DisplayMenu(mainMenu);
//DrawStringDecal({ ScreenWidth() / 2 + 0.0f, ScreenHeight() / 2 + 0.0f }, "START GAME", olc::WHITE, { 4.0f, 4.0f });
if (GetKey(olc::Key::ENTER).bPressed || GetKey(olc::Key::SPACE).bPressed)
{
// vertical menu
if (highlighted == 0)
{
gameState = state::PLAY_GAME;
highlighted = 0;
}
else if (highlighted == 1)
{
gameState = state::CONTROLS;
highlighted = 0;
}
else
{
return false; // quit game
}
}
if (GetKey(olc::Key::ESCAPE).bPressed)
{
return false; // exit via Escape key
}
}
//--------------------------------------------------------------------------------------------------
else if (gameState == state::PLAY_GAME)
{
DisplayMenu(playGame);
if (GetKey(olc::Key::ENTER).bPressed || GetKey(olc::Key::SPACE).bPressed)
{
// vertical menu
if (highlighted == 0)
{
gameState = state::TRACK_SELECT;
highlighted = 0;
}
else if (highlighted == 1)
{
gameState = state::CUP_SELECT;
highlighted = 0;
}
else
{
gameState = state::MAIN_MENU; // return to menu
highlighted = 0;
}
}
if (GetKey(olc::Key::ESCAPE).bPressed || GetKey(olc::Key::BACK).bPressed)
{
gameState = state::MAIN_MENU;
highlighted = 0;
}
}
//--------------------------------------------------------------------------------------------------
else if (gameState == state::TRACK_SELECT)
{
DisplayMenu(pickTrack);
if (GetKey(olc::Key::ENTER).bPressed || GetKey(olc::Key::SPACE).bPressed)
{
if (highlighted == 0)
{
gameState = state::CIRCUIT;
track = 1;
gameState = state::CAR_SELECT;
}
else if (highlighted == 1)
{
gameState = state::FIG_EIGHT;
track = 2;
gameState = state::CAR_SELECT;
}
else if (highlighted == 2)
{
gameState = state::ARROW_HEAD;
track = 3;
gameState = state::CAR_SELECT;
}
else if (highlighted == 3)
{
gameState = state::track_4;
track = 4;
gameState = state::CAR_SELECT;
}
else if (highlighted == 4)
{
gameState = state::OVERPASS;
track = 5;
gameState = state::CAR_SELECT;
}
else if (highlighted == 5)
{
gameState = state::PEANUT;
track = 6;
gameState = state::CAR_SELECT;
}
else if (highlighted == 6)
{
gameState = state::track_6;
track = 7;
gameState = state::CAR_SELECT;
}
else if (highlighted == 7)
{
gameState = state::track_7;
track = 8;
gameState = state::CAR_SELECT;
}
else if (highlighted == 8)
{
gameState = state::track_8;
track = 9;
gameState = state::CAR_SELECT;
}
else
{
gameState = state::PLAY_GAME;
highlighted = 0;
}
}
if (GetKey(olc::Key::CTRL).bHeld && GetKey(olc::Key::F9).bHeld)
{
// okay, so, gotta work out how to do cheat codes it seems xD
gameState = state::JX9;
track = 0;
gameState = state::CAR_SELECT;
}
if (GetKey(olc::Key::ESCAPE).bPressed || GetKey(olc::Key::BACK).bPressed)
{
gameState = state::PLAY_GAME;
highlighted = 0;
}
}
//--------------------------------------------------------------------------------------------------
else if (gameState == state::CUP_SELECT)
{
DisplayMenu(grandPrix);
if (GetKey(olc::Key::ENTER).bPressed || GetKey(olc::Key::SPACE).bPressed)
{
// 2 x 2 menu
if (highlighted == 0)
{
gameState = state::INDIE;
cup = 0;
gameState = state::CAR_SELECT;
}
else if (highlighted == 1)
{
gameState = state::STREET;
cup = 1;
gameState = state::CAR_SELECT;
}
else if (highlighted == 2)
{
gameState = state::PRO;
cup = 2;
gameState = state::CAR_SELECT;
}
else if (highlighted == 3)
{
gameState = state::GRAND_PRIX;
cup = 3;
gameState = state::CAR_SELECT;
}
else
{
gameState = state::PLAY_GAME; // return to menu
cup = -1;
highlighted = 0;
}
}
if (GetKey(olc::Key::ESCAPE).bPressed || GetKey(olc::Key::BACK).bPressed)
{
gameState = state::PLAY_GAME;
highlighted = 0;
}
}
//--------------------------------------------------------------------------------------------------
else if (gameState == state::CAR_SELECT)
{
DisplayMenu(selectCar);
if (GetKey(olc::Key::ENTER).bPressed || GetKey(olc::Key::SPACE).bPressed)
{
if (highlighted == 0)
{
// red car
player = 0;
gameState=state::RUN_GAME;
}
else if (highlighted == 1)
{
// blue car
player = 1;
}
else if (highlighted == 2)
{
// green car
player = 2;
}
else if (highlighted == 3)
{
// gold car
player = 3;
}
else if (highlighted == 4)
{
// purple car
player = 4;
}
else if (highlighted == 5)
{
// white car
player = 5;
}
else if (highlighted == 6)
{
// orange car
player = 6;
}
else if (highlighted == 7)
{
// black car
player = 7;
}
else
{
if (cup != -1)
{
// return to cup select
gameState = state::CUP_SELECT;
}
if (track != -1)
{
// return to track select
gameState = state::TRACK_SELECT;
}
highlighted = 0;
}
}
if (GetKey(olc::Key::ESCAPE).bPressed || GetKey(olc::Key::BACK).bPressed)
{
if (cup != -1)
{
// return to cup select
gameState = state::CUP_SELECT;
}
if (track != -1)
{
// return to track select
gameState = state::TRACK_SELECT;
}
highlighted = 0;
}
}
//--------------------------------------------------------------------------------------------------
else if (gameState == state::CONTROLS)
{
DisplayMenu(controls);
if (GetKey(olc::Key::ENTER).bPressed)
{
if (highlighted == 0)
{
configKeyIndex = highlighted;
}
else if (highlighted == 1)
{
configKeyIndex = highlighted;
}
else if (highlighted == 2)
{
configKeyIndex = highlighted;
}
else if (highlighted == 3)
{
configKeyIndex = highlighted;
}
else if (highlighted == 4)
{
// reset default controls
DisplayMenu(controls);
Move_Up = olc::W;
Move_Down = olc::S;
Move_Left = olc::A;
Move_Right = olc::D;
}
else
{
gameState = state::MAIN_MENU;
highlighted = 0;
}
}
if (GetKey(olc::Key::ESCAPE).bPressed || GetKey(olc::Key::BACK).bPressed)
{
gameState = state::MAIN_MENU;
}
}
//--------------------------------------------------------------------------------------------------
if (gameState == state::RUN_GAME) // run main game loop
{
Clear(olc::BLACK); // this still needed? we've since replaced it with the gradient sky box
// get a point on the track
float offset = 0;
int TrackSection = 0;
cur_lap_time += fElapsedTime;
// record lap time
if (distance >= track_dist)
{
distance -= track_dist;
list_times.push_front(cur_lap_time); // push time to front
list_times.pop_back(); // pop time to back
cur_lap_time = 0.0f;
}
// find position on track (could optimize) << should probably optimize given the complexity of this game
while (TrackSection < vecTrack.size() && offset <= distance)
{
offset += vecTrack[TrackSection].second;
TrackSection++;
}
float TargetCurvature = vecTrack[TrackSection - 1].first; // drawing curves to screen
float TrackCurveDiff = (TargetCurvature - curvature) * fElapsedTime * speed; // correcting the drawing of curves to the screen
curvature += TrackCurveDiff; // update track curve difference
track_curve += (curvature)*fElapsedTime * speed;
// draw racetrack canvas
std::vector<olc::vf2d> pos;
std::vector<olc::vf2d> uvs;
for (int y = 0; y < ScreenHeight() / 2; y++)
{
// racetrack canvas variables
float perspective = (float)y / (ScreenHeight() / 2.0f);
float mid_point = 0.5f + curvature * powf((1.0f - perspective), 3);
float road_width = 0.1f + perspective * 0.8f;
float curb_width = road_width * 0.15f;
road_width *= 0.5f;
int lf_curb = (mid_point - road_width) * ScreenWidth();
int rt_curb = (mid_point + road_width) * ScreenWidth();
int row = ScreenHeight() / 2 + y;
float horizon = powf(1.0f - perspective, 2) * 80;
// check for finish line
if (distance + horizon > track_dist - 20 && distance + horizon < track_dist)
{
// draw checkerboard pattern
uvs.push_back({ 0, fmod(((distance + horizon) - (track_dist - 20)) / 20.0f, 0.5f) + 0.5f });
uvs.push_back({ 1, fmod(((distance + horizon) - (track_dist - 20)) / 20.0f, 0.5f) + 0.5f });
}
else
{
// draw standard track piece
uvs.push_back({ 0, sinf(80.0f * powf(1.0f - perspective, 2) + distance) / 4 + 0.25f });
uvs.push_back({ 1, sinf(80.0f * powf(1.0f - perspective, 2) + distance) / 4 + 0.25f });
}
// drawing grass and curb
pos.push_back({ lf_curb + 0.0f, row + 0.0f });
pos.push_back({ rt_curb + 0.0f, row + 0.0f });
// black box rendering shenanigans; if I ever understand programming enough at a later date, I can figure out wtf is going on here
int i = 0;
for (Object& obj : gameObjects)
{
float horizonRange = powf(1.0f - perspective, 2) * ((distance + horizon) - obj.pos.y) / horizon;
if (!obj.rendered && (distance + horizon) > obj.pos.y && (distance + horizon) < obj.pos.y + 80 && row >= ScreenHeight() / 2 + ScreenHeight() / 2 * horizonRange)
{
obj.drawPos = { (mid_point + road_width * obj.pos.x) * ScreenWidth(), horizonRange * (ScreenHeight() / 2) + ScreenHeight() / 2 };
obj.drawOffsetPos = { obj.offset.x, obj.size.y * road_width * -obj.offset.y };
obj.drawSize = { obj.size.x * road_width, obj.size.y * road_width };
obj.rendered = true;
// yeah.... so, even after copying it manually, i still have no clue what this thing is doing, lol
}
}
}
// on the road again; drawing the track
SetDecalStructure(olc::DecalStructure::STRIP);
DrawPolygonDecal(road, pos, uvs);
SetDecalStructure(olc::DecalStructure::FAN);
// draw trackside props
for (Object& obj : gameObjects)
{
if (obj.rendered)
{
if (obj.decal != nullptr)
{
DrawDecal(obj.drawPos + obj.drawOffsetPos, obj.decal, obj.drawSize);
}
else
{
FillRectDecal(obj.drawPos, obj.drawSize, olc::BLUE);
}
}
}
//----------------------------------------
// debug quick-reset
if (GetKey(olc::Key::F4).bPressed)
{
Reset();
}
// move forward
if (GetKey(olc::Key::W).bHeld || GetKey(olc::Key::UP).bHeld)
{
speed += 2.0f * fElapsedTime;
}
else // might remove this in a later stage of development
{
speed -= 1.0f * fElapsedTime;
}
// move back ?
if (GetKey(olc::Key::S).bHeld || GetKey(olc::Key::DOWN).bHeld)
{
distance -= 20.0f * fElapsedTime;
}
int car_dir = 0; // default car facing
// move left
if (GetKey(olc::Key::A).bHeld || GetKey(olc::Key::LEFT).bHeld)
{
car_curve -= 0.7f * fElapsedTime;
car_dir = -1;
}
// move right
if (GetKey(olc::Key::D).bHeld || GetKey(olc::Key::RIGHT).bHeld)
{
car_curve += 0.7f * fElapsedTime;
car_dir = +1;
}
// slow car if on grass
if (fabs(car_curve - track_curve) >= 0.8f)
{
speed -= 5.0f * fElapsedTime;
}
// clamp speed
if (speed < 0.0f) speed = 0.0f;
if (speed > 1.0f) speed = 1.0f;
// move car along track according to car speed
distance += (70.0f * speed) * fElapsedTime;
// draw car
car_pos = car_curve - track_curve;
DrawDecal({ ScreenWidth() / 2 - 128 + car_pos * ScreenWidth() / 2, ScreenHeight() / 4 * 3.0f - 128 }, car);
SetPixelMode(olc::Pixel::ALPHA);
// spedometer
std::string mph = std::to_string(speed);
DrawString(4, 4, mph);
// show time
auto disp_time = [](float t)
{
int min = t / 60.0f;
int sec = t - (min * 60.0f);
int milli = (t - (float)sec) * 1000.0f;
// need to change this out to a 'DrawString()' function instead
return std::to_string(min) + "." + std::to_string(sec) + ":" + std::to_string(milli);
};
// correct for the first '0' in the seconds timer
//if ()
//{
// // draw min + '0' + sec + milli
// DrawString(4, 16, disp_time(cur_lap_time));
//}
//else
//{
DrawString(4, 16, disp_time(cur_lap_time));
//}
// display last 5 lap times
int j = 30;
for (auto l : list_times)
{
DrawString(10, j, disp_time(l));
j += 10;
}
// debug code
//std::string numb1 = std::to_string(car_pos);
//DrawString(4, 26, numb1);
//std::string numb2 = std::to_string(track_dist);
//DrawString(4, 38, numb2);
}
return true;
}
};
//--------------------------------------------------------------------------------------------------
int main()
{
Racer game;
if (game.Construct(1280, 720, 1, 1))
game.Start();
return 0;
}
//--------------------------------------------------------------------------------------------------
// END OF FILE
//--------------------------------------------------------------------------------------------------