|
|
|
|
|
/*
|
|
|
Saving Sedit: An OLC Code Jam 2018 Submission
|
|
|
"At least this is checked off my list now..." - javidx9
|
|
|
|
|
|
Download the playable version here: https://onelonecoder.itch.io/saving-sedit
|
|
|
|
|
|
Note: This was a JAM entry, it is incomplete, has bugs, has features that
|
|
|
dont go anywhere. I've not tidied up the code - it is a record of how
|
|
|
the JAM went.
|
|
|
|
|
|
License (OLC-3)
|
|
|
~~~~~~~~~~~~~~~
|
|
|
|
|
|
Copyright 2018-2019 OneLoneCoder.com
|
|
|
|
|
|
Redistribution and use in source and binary forms, with or without
|
|
|
modification, are permitted provided that the following conditions
|
|
|
are met:
|
|
|
|
|
|
1. Redistributions or derivations of source code must retain the above
|
|
|
copyright notice, this list of conditions and the following disclaimer.
|
|
|
|
|
|
2. Redistributions or derivative works in binary form must reproduce
|
|
|
the above copyright notice. This list of conditions and the following
|
|
|
disclaimer must be reproduced in the documentation and/or other
|
|
|
materials provided with the distribution.
|
|
|
|
|
|
3. Neither the name of the copyright holder nor the names of its
|
|
|
contributors may be used to endorse or promote products derived
|
|
|
from this software without specific prior written permission.
|
|
|
|
|
|
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
|
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
|
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
|
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
|
HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
|
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
|
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
|
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
|
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
|
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
|
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
|
|
Relevant Video: https://youtu.be/Qco5BstCxRM
|
|
|
|
|
|
Links
|
|
|
~~~~~
|
|
|
YouTube: https://www.youtube.com/javidx9
|
|
|
https://www.youtube.com/javidx9extra
|
|
|
Discord: https://discord.gg/WhwHUMV
|
|
|
Twitter: https://www.twitter.com/javidx9
|
|
|
Twitch: https://www.twitch.tv/javidx9
|
|
|
GitHub: https://www.github.com/onelonecoder
|
|
|
Patreon: https://www.patreon.com/javidx9
|
|
|
Homepage: https://www.onelonecoder.com
|
|
|
|
|
|
Author
|
|
|
~~~~~~
|
|
|
David Barr, aka javidx9, <EFBFBD>OneLoneCoder 2019
|
|
|
*/
|
|
|
|
|
|
#define OLC_PGE_APPLICATION
|
|
|
#include "olcPixelGameEngine.h"
|
|
|
#define OLC_PGE_GRAPHICS2D
|
|
|
#include "olcPGEX_Graphics2D.h"
|
|
|
|
|
|
#include "olcPGEX_TileMaps_new.h"
|
|
|
#define OLC_PGEX_SOUND
|
|
|
#include "olcPGEX_Sound.h"
|
|
|
|
|
|
#include "Zix_PGE_Controller.h"
|
|
|
|
|
|
#include <list>
|
|
|
#include <algorithm>
|
|
|
#include <string>
|
|
|
#include <stack>
|
|
|
#include <map>
|
|
|
using namespace std;
|
|
|
|
|
|
|
|
|
class cAnimator
|
|
|
{
|
|
|
public:
|
|
|
std::map<std::string, std::vector<olc::Sprite*>> mapStates;
|
|
|
|
|
|
public:
|
|
|
std::string sCurrentState;
|
|
|
int nCurrentFrame = 0;
|
|
|
float fTimeBetweenFrames = 0.1f;
|
|
|
float fTimeCounter = 0.0f;
|
|
|
|
|
|
|
|
|
void ChangeState(std::string s)
|
|
|
{
|
|
|
if (s != sCurrentState)
|
|
|
{
|
|
|
sCurrentState = s;
|
|
|
fTimeCounter = 0;
|
|
|
nCurrentFrame = 0;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void Update(float fElapsedTime)
|
|
|
{
|
|
|
fTimeCounter += fElapsedTime;
|
|
|
if (fTimeCounter >= fTimeBetweenFrames)
|
|
|
{
|
|
|
fTimeCounter -= fTimeBetweenFrames;
|
|
|
nCurrentFrame++;
|
|
|
if (nCurrentFrame >= mapStates[sCurrentState].size())
|
|
|
nCurrentFrame = 0;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void DrawSelf(olc::PixelGameEngine *pge, olc::GFX2D::Transform2D &t)
|
|
|
{
|
|
|
olc::GFX2D::DrawSprite(mapStates[sCurrentState][nCurrentFrame], t);
|
|
|
}
|
|
|
|
|
|
};
|
|
|
|
|
|
// Override base class with your custom functionality
|
|
|
class Discovery : public olc::PixelGameEngine
|
|
|
{
|
|
|
public:
|
|
|
Discovery()
|
|
|
{
|
|
|
sAppName = "Discovery - OLC CodeJam 2018";
|
|
|
}
|
|
|
|
|
|
private:
|
|
|
|
|
|
int nTileSizeX = 64;
|
|
|
int nTileSizeY = 64;
|
|
|
olc::TILE::Layer<olc::TILE::BasicTile> layerWorld;
|
|
|
olc::TILE::Layer<olc::TILE::BasicTile> layerCollectibles;
|
|
|
olc::TILE::Layer<olc::TILE::BasicTile> layerJavid;
|
|
|
olc::TILE::Atlas atlasWorldMagetzub;
|
|
|
olc::TILE::Atlas atlasWorldJavid;
|
|
|
olc::TILE::Atlas atlasWorldHopson;
|
|
|
olc::TILE::Atlas atlasCollectibles;
|
|
|
|
|
|
olc::ResourcePack rpPlayer;
|
|
|
|
|
|
olc::Sprite *sprBackdropMagetzub;
|
|
|
olc::Sprite *sprBackdropHopson;
|
|
|
|
|
|
olc::Sprite *sprTitleScreen;
|
|
|
olc::Sprite *sprStoryScreen;
|
|
|
olc::Sprite *sprControlScreen;
|
|
|
olc::Sprite *sprCreditScreen;
|
|
|
olc::Sprite *sprCompleteScreen;
|
|
|
|
|
|
float fBackdropScaleX = 1.0f;
|
|
|
float fBackdropScaleY = 1.0f;
|
|
|
|
|
|
olc::Sprite *sprMiniMap = nullptr;
|
|
|
|
|
|
olc::Sprite *backBuff;
|
|
|
|
|
|
|
|
|
|
|
|
cAnimator animPlayer;
|
|
|
ControllerManager controller;
|
|
|
|
|
|
float fPlayerPosX = 2.0f;
|
|
|
float fPlayerPosY = 2.0f;
|
|
|
float fPlayerVelX = 0.0f;
|
|
|
float fPlayerVelY = 0.0f;
|
|
|
float fCameraPosX = 0.0f;
|
|
|
float fCameraPosY = 0.0f;
|
|
|
bool bPlayerOnGround = false;
|
|
|
bool bPlayerTouchingWall = false;
|
|
|
bool bPlayerTouchingWallOld = false;
|
|
|
bool bCollisionLeft = false;
|
|
|
float fTimeToJump = 0.0f;
|
|
|
float fTimeToJumpMax = 0.25f;
|
|
|
float fFaceDir = 1.0f;
|
|
|
int nFloppyDisks = 0;
|
|
|
float fGameTime = 0.0f;
|
|
|
float fGameTimeMultiplier = 1.0f;
|
|
|
int nHopsonTokens = 0;
|
|
|
int nJavidTokens = 0;
|
|
|
|
|
|
int nKeys = 0;
|
|
|
float fEffectTime = 0.0f;
|
|
|
float fModeTime = 0.0f;
|
|
|
|
|
|
bool bFire = false;
|
|
|
|
|
|
list<pair<int, int>> listKeys;
|
|
|
|
|
|
struct sBullet
|
|
|
{
|
|
|
float bx;
|
|
|
float by;
|
|
|
float vx;
|
|
|
bool bRemove = false;
|
|
|
};
|
|
|
|
|
|
enum
|
|
|
{
|
|
|
MODE_MAGETZUB,
|
|
|
MODE_JAVID,
|
|
|
MODE_HOPSON,
|
|
|
MODE_HUHLIG
|
|
|
|
|
|
} nRenderMode;
|
|
|
|
|
|
enum
|
|
|
{
|
|
|
EFFECT_NONE,
|
|
|
EFFECT_UGLYSWEDISHFISH,
|
|
|
EFFECT_SEDIT,
|
|
|
EFFECT_BRANK,
|
|
|
EFFECT_GORBIT,
|
|
|
|
|
|
} nRenderEffect;
|
|
|
|
|
|
|
|
|
enum
|
|
|
{
|
|
|
GS_LOADING,
|
|
|
GS_TITLE,
|
|
|
GS_STORY,
|
|
|
GS_CREDITS,
|
|
|
GS_GENERATE,
|
|
|
GS_MAIN,
|
|
|
GS_COMPLETE,
|
|
|
} nGameState = GS_LOADING;
|
|
|
|
|
|
int nChallengeMapSizeX = 8;
|
|
|
int nChallengeMapSizeY = 8;
|
|
|
int nChallengePathSizeX = 4;
|
|
|
int nChallengePathSizeY = 4;
|
|
|
|
|
|
void CreateMaze(bool* &pMap, int nCellWidth, int nCellHeight, int nCellsX, int nCellsY, int &nMapWidth, int &nMapHeight)
|
|
|
{
|
|
|
int *pLevel = new int[nCellsX * nCellsY]{ 0 };
|
|
|
|
|
|
enum
|
|
|
{
|
|
|
CELL_PATH_N = 0x01,
|
|
|
CELL_PATH_E = 0x02,
|
|
|
CELL_PATH_S = 0x04,
|
|
|
CELL_PATH_W = 0x08,
|
|
|
CELL_VISITED = 0x10,
|
|
|
};
|
|
|
|
|
|
std::stack<std::pair<int, int>> m_stack;
|
|
|
|
|
|
|
|
|
auto offset = [&](int x, int y)
|
|
|
{
|
|
|
return (m_stack.top().second + y) * nCellsX + (m_stack.top().first + x);
|
|
|
};
|
|
|
|
|
|
m_stack.push(std::make_pair(0, 0));
|
|
|
pLevel[0] = CELL_VISITED;
|
|
|
int nVisitedCells = 1;
|
|
|
|
|
|
// Do Maze Algorithm
|
|
|
while (nVisitedCells < nCellsX * nCellsY)
|
|
|
{
|
|
|
// Step 1: Create a set of the unvisted neighbours
|
|
|
|
|
|
std::vector<int> neighbours;
|
|
|
|
|
|
// North Neighbour
|
|
|
if (m_stack.top().second > 0 && (pLevel[offset(0, -1)] & CELL_VISITED) == 0)
|
|
|
neighbours.push_back(0);
|
|
|
// East neighbour
|
|
|
if (m_stack.top().first < nCellsX - 1 && (pLevel[offset(1, 0)] & CELL_VISITED) == 0)
|
|
|
neighbours.push_back(1);
|
|
|
// South neighbour
|
|
|
if (m_stack.top().second < nCellsY - 1 && (pLevel[offset(0, 1)] & CELL_VISITED) == 0)
|
|
|
neighbours.push_back(2);
|
|
|
// West neighbour
|
|
|
if (m_stack.top().first > 0 && (pLevel[offset(-1, 0)] & CELL_VISITED) == 0)
|
|
|
neighbours.push_back(3);
|
|
|
|
|
|
|
|
|
// Are there any neighbours available?
|
|
|
if (!neighbours.empty())
|
|
|
{
|
|
|
// Choose one available neighbour at random
|
|
|
int next_cell_dir = neighbours[rand() % neighbours.size()];
|
|
|
|
|
|
// Create a path between the neighbour and the current cell
|
|
|
switch (next_cell_dir)
|
|
|
{
|
|
|
case 0: // North
|
|
|
pLevel[offset(0, -1)] |= CELL_VISITED | CELL_PATH_S;
|
|
|
pLevel[offset(0, 0)] |= CELL_PATH_N;
|
|
|
m_stack.push(std::make_pair((m_stack.top().first + 0), (m_stack.top().second - 1)));
|
|
|
break;
|
|
|
|
|
|
case 1: // East
|
|
|
pLevel[offset(+1, 0)] |= CELL_VISITED | CELL_PATH_W;
|
|
|
pLevel[offset(0, 0)] |= CELL_PATH_E;
|
|
|
m_stack.push(std::make_pair((m_stack.top().first + 1), (m_stack.top().second + 0)));
|
|
|
break;
|
|
|
|
|
|
case 2: // South
|
|
|
pLevel[offset(0, +1)] |= CELL_VISITED | CELL_PATH_N;
|
|
|
pLevel[offset(0, 0)] |= CELL_PATH_S;
|
|
|
m_stack.push(std::make_pair((m_stack.top().first + 0), (m_stack.top().second + 1)));
|
|
|
break;
|
|
|
|
|
|
case 3: // West
|
|
|
pLevel[offset(-1, 0)] |= CELL_VISITED | CELL_PATH_E;
|
|
|
pLevel[offset(0, 0)] |= CELL_PATH_W;
|
|
|
m_stack.push(std::make_pair((m_stack.top().first - 1), (m_stack.top().second + 0)));
|
|
|
break;
|
|
|
|
|
|
}
|
|
|
|
|
|
nVisitedCells++;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
m_stack.pop(); // Backtrack
|
|
|
}
|
|
|
}
|
|
|
|
|
|
printf("M1 %d\n", m_stack.size());
|
|
|
|
|
|
// Convert Maze into tile map
|
|
|
nMapWidth = (nCellWidth + 1) * nCellsX + 1;
|
|
|
nMapHeight = (nCellHeight + 1) * nCellsY + 1;
|
|
|
pMap = new bool[nMapWidth * nMapHeight]{ 0 };
|
|
|
printf("M1\n");
|
|
|
|
|
|
// Draw Maze
|
|
|
for (int x = 0; x < nCellsX; x++)
|
|
|
{
|
|
|
for (int y = 0; y < nCellsY; y++)
|
|
|
{
|
|
|
for (int py = 0; py < nCellHeight; py++)
|
|
|
for (int px = 0; px < nCellWidth; px++)
|
|
|
{
|
|
|
if (pLevel[y * nCellsX + x] & CELL_VISITED)
|
|
|
pMap[(y* (nCellHeight + 1) + py + 1) * nMapWidth + (x * (nCellWidth + 1) + px) + 1] = true;
|
|
|
else
|
|
|
pMap[(y* (nCellHeight + 1) + py + 1) * nMapWidth + (x * (nCellWidth + 1) + px + 1)] = false;
|
|
|
}
|
|
|
|
|
|
for (int p = 0; p < nCellWidth; p++)
|
|
|
if (pLevel[y * nCellsX + x] & CELL_PATH_S)
|
|
|
pMap[(y * (nCellHeight + 1) + nCellHeight + 1) * nMapWidth + (x * (nCellWidth + 1) + p + 1)] = true;
|
|
|
|
|
|
for (int p = 0; p < nCellHeight; p++)
|
|
|
if (pLevel[y * nCellsX + x] & CELL_PATH_E)
|
|
|
pMap[(y * (nCellHeight + 1) + p + 1) * nMapWidth + (x * (nCellWidth + 1) + nCellWidth + 1)] = true;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
printf("M1\n");
|
|
|
delete[] pLevel;
|
|
|
printf("M1\n");
|
|
|
}
|
|
|
|
|
|
void CalculateFlowMap()
|
|
|
{
|
|
|
// Update Flow map
|
|
|
|
|
|
int nFlowWidth = layerJavid.nLayerWidth;
|
|
|
int nFlowHeight = layerJavid.nLayerHeight;
|
|
|
|
|
|
// 1) Prepare it centered on player
|
|
|
for (int x = 0; x < nFlowWidth; x++)
|
|
|
for (int y = 0; y < nFlowHeight; y++)
|
|
|
{
|
|
|
layerJavid.GetTile(x, y)->id = 2;
|
|
|
layerJavid.GetTile(x, y)->edge_id[0] = 0;
|
|
|
|
|
|
if (x == 0 || x == (nFlowWidth - 1) || y == 0 || y == (nFlowHeight - 1))
|
|
|
layerJavid.GetTile(x, y)->edge_id[0] = -1;
|
|
|
else
|
|
|
//layerJavid.GetTile(x, y)->exist = layerWorld.GetTile(x, y)->exist;
|
|
|
layerJavid.GetTile(x, y)->edge_id[0] = layerWorld.GetTile(x, y)->exist ? -1 : 0;
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
list<tuple<int, int, int>> nodes;
|
|
|
|
|
|
nodes.push_back({ listKeys.back().first,listKeys.back().second, 1 });
|
|
|
|
|
|
while (!nodes.empty())
|
|
|
{
|
|
|
list<tuple<int, int, int>> new_nodes;
|
|
|
|
|
|
// For each node in processing queue, set its count value, and add unmarked
|
|
|
// neighbour nodes
|
|
|
for (auto &n : nodes)
|
|
|
{
|
|
|
int x = get<0>(n);
|
|
|
int y = get<1>(n);
|
|
|
int d = get<2>(n);
|
|
|
|
|
|
// Set distance for this node
|
|
|
layerJavid.GetTile(x, y)->edge_id[0] = d;
|
|
|
|
|
|
// Add neigbour nodes if unmarked
|
|
|
if ((x + 1) < nFlowWidth && layerJavid.GetTile(x+1, y)->edge_id[0] == 0)
|
|
|
new_nodes.push_back({ x + 1, y, d + 1 });
|
|
|
if ((x - 1) >= 0 && layerJavid.GetTile(x - 1, y)->edge_id[0] == 0)
|
|
|
new_nodes.push_back({ x - 1, y, d + 1});
|
|
|
if ((y + 1) < nFlowHeight && layerJavid.GetTile(x, y+1)->edge_id[0] == 0)
|
|
|
new_nodes.push_back({ x, y + 1, d + 1 });
|
|
|
if ((y - 1) >= 0 && layerJavid.GetTile(x, y-1)->edge_id[0] == 0)
|
|
|
new_nodes.push_back({ x, y - 1, d + 1 });
|
|
|
}
|
|
|
|
|
|
new_nodes.sort([&](const tuple<int, int, int> &n1, const tuple<int, int, int> &n2)
|
|
|
{
|
|
|
return (get<1>(n1) * layerJavid.nLayerWidth + get<0>(n1)) < (get<1>(n2) * layerJavid.nLayerWidth + get<0>(n2));
|
|
|
});
|
|
|
|
|
|
new_nodes.unique([&](const tuple<int, int, int> &n1, const tuple<int, int, int> &n2)
|
|
|
{
|
|
|
return (get<1>(n1) * layerJavid.nLayerWidth + get<0>(n1)) == (get<1>(n2) * layerJavid.nLayerWidth + get<0>(n2));
|
|
|
});
|
|
|
|
|
|
|
|
|
nodes.clear();
|
|
|
nodes.insert(nodes.begin(), new_nodes.begin(), new_nodes.end());
|
|
|
}
|
|
|
|
|
|
for (int x = 0; x < nFlowWidth; x++)
|
|
|
{
|
|
|
for (int y = 0; y < nFlowHeight; y++)
|
|
|
{
|
|
|
if (layerJavid.GetTile(x, y)->edge_id[0] > 0)
|
|
|
{
|
|
|
int flow_xa, flow_xb, flow_ya, flow_yb;
|
|
|
flow_xa = flow_xb = flow_ya = flow_yb = layerJavid.GetTile(x, y)->edge_id[0];
|
|
|
|
|
|
if ((x + 1) < nFlowWidth && layerJavid.GetTile(x+1, y)->edge_id[0] > 0)
|
|
|
flow_xb = layerJavid.GetTile(x + 1, y)->edge_id[0];
|
|
|
|
|
|
if ((x - 1) >= 0 && layerJavid.GetTile(x-1, y)->edge_id[0] > 0)
|
|
|
flow_xa = layerJavid.GetTile(x - 1, y)->edge_id[0];
|
|
|
|
|
|
if ((y + 1) < nFlowHeight && layerJavid.GetTile(x, y+1)->edge_id[0] > 0)
|
|
|
flow_yb = layerJavid.GetTile(x, y + 1)->edge_id[0];
|
|
|
|
|
|
if ((y - 1) >= 0 && layerJavid.GetTile(x, y-1)->edge_id[0] > 0)
|
|
|
flow_ya = layerJavid.GetTile(x, y - 1)->edge_id[0];
|
|
|
|
|
|
float fdx = (float)(flow_xa - flow_xb);
|
|
|
float fdy = (float)(flow_ya - flow_yb);
|
|
|
float r = 1.0f / sqrtf(fdx * fdx + fdy * fdy);
|
|
|
|
|
|
if (fabs(fdx) > fabs(fdy))
|
|
|
{
|
|
|
if (fdx > 0)
|
|
|
{
|
|
|
layerJavid.GetTile(x, y)->exist = true;
|
|
|
layerJavid.GetTile(x, y)->id = 8;
|
|
|
}
|
|
|
|
|
|
if (fdx < 0)
|
|
|
{
|
|
|
layerJavid.GetTile(x, y)->exist = true;
|
|
|
layerJavid.GetTile(x, y)->id = 10;
|
|
|
}
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
if (fdy > 0)
|
|
|
{
|
|
|
layerJavid.GetTile(x, y)->exist = true;
|
|
|
layerJavid.GetTile(x, y)->id = 9;
|
|
|
}
|
|
|
|
|
|
if (fdy < 0)
|
|
|
{
|
|
|
layerJavid.GetTile(x, y)->exist = true;
|
|
|
layerJavid.GetTile(x, y)->id = 7;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void CreateBorderMap()
|
|
|
{
|
|
|
// Use OLC Standard Bordered tile atlas
|
|
|
for (int x = 0; x < layerWorld.nLayerWidth; x++)
|
|
|
{
|
|
|
for (int y = 0; y < layerWorld.nLayerHeight; y++)
|
|
|
{
|
|
|
int s = 0;
|
|
|
auto a = [&](int i, int j)
|
|
|
{
|
|
|
return (layerWorld.GetTile(i, j) && layerWorld.GetTile(i, j)->exist);
|
|
|
};
|
|
|
|
|
|
if (a(x, y))
|
|
|
{
|
|
|
s |= a(x - 1, y + 0) ? 1 : 0; s <<= 1;
|
|
|
s |= a(x - 1, y + 1) ? 1 : 0; s <<= 1;
|
|
|
s |= a(x + 0, y + 1) ? 1 : 0; s <<= 1;
|
|
|
s |= a(x + 1, y + 1) ? 1 : 0; s <<= 1;
|
|
|
s |= a(x + 1, y + 0) ? 1 : 0; s <<= 1;
|
|
|
s |= a(x + 1, y - 1) ? 1 : 0; s <<= 1;
|
|
|
s |= a(x - 0, y - 1) ? 1 : 0; s <<= 1;
|
|
|
s |= a(x - 1, y - 1) ? 1 : 0;
|
|
|
|
|
|
int ix = s % 16;
|
|
|
int iy = s / 16;
|
|
|
layerWorld.GetTile(x, y)->id = (iy * 256 + 64) + (ix * 4) + 1;
|
|
|
}
|
|
|
else
|
|
|
layerWorld.GetTile(x, y)->id = 0;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
public:
|
|
|
|
|
|
int sndHelperChange;
|
|
|
int sndJump;
|
|
|
int sndWall;
|
|
|
int sndGithubPatch;
|
|
|
int sndKeyCollect;
|
|
|
int sndDiskCollect;
|
|
|
int sndThump;
|
|
|
int sndTheme;
|
|
|
|
|
|
|
|
|
|
|
|
bool OnUserCreate() override
|
|
|
{
|
|
|
controller.Initialize();
|
|
|
backBuff = new olc::Sprite(ScreenWidth(), ScreenHeight());
|
|
|
|
|
|
olc::SOUND::InitialiseAudio();
|
|
|
|
|
|
animPlayer.ChangeState("idle");
|
|
|
return true;
|
|
|
}
|
|
|
|
|
|
bool OnUserDestroy()
|
|
|
{
|
|
|
olc::SOUND::DestroyAudio();
|
|
|
return true;
|
|
|
}
|
|
|
|
|
|
bool bFirstFrameLoading = true;
|
|
|
|
|
|
bool GameState_Loading(float fElapsedTime)
|
|
|
{
|
|
|
|
|
|
|
|
|
|
|
|
if (bFirstFrameLoading)
|
|
|
{
|
|
|
Clear(olc::BLACK);
|
|
|
DrawString(60, 240, "- Loading, Please Wait - ", olc::WHITE, 2);
|
|
|
bFirstFrameLoading = false;
|
|
|
|
|
|
return true;
|
|
|
}
|
|
|
|
|
|
rpPlayer.LoadPack("./discres/savingsedit.olcdat");
|
|
|
|
|
|
sndHelperChange = olc::SOUND::LoadAudioSample("E:\\linshare\\olcSimpleGameEngine\\discres\\PP_Negative_Trigger_1_2.wav", &rpPlayer);
|
|
|
sndJump = olc::SOUND::LoadAudioSample("E:\\linshare\\olcSimpleGameEngine\\discres\\PP_Jump_1_5.wav", &rpPlayer);
|
|
|
sndWall = olc::SOUND::LoadAudioSample("E:\\linshare\\olcSimpleGameEngine\\discres\\LQ_Back_Button.wav", &rpPlayer);
|
|
|
sndThump = olc::SOUND::LoadAudioSample("E:\\linshare\\olcSimpleGameEngine\\discres\\PP_Small_Impact_1_1.wav", &rpPlayer);
|
|
|
sndGithubPatch = olc::SOUND::LoadAudioSample("E:\\linshare\\olcSimpleGameEngine\\discres\\PP_Skill_Unlock.wav", &rpPlayer);
|
|
|
sndKeyCollect = olc::SOUND::LoadAudioSample("E:\\linshare\\olcSimpleGameEngine\\discres\\FA_Special_Item_2_1.wav", &rpPlayer);
|
|
|
sndDiskCollect = olc::SOUND::LoadAudioSample("E:\\linshare\\olcSimpleGameEngine\\discres\\FA_Funny_Impact_1_3.wav", &rpPlayer);
|
|
|
sndTheme = olc::SOUND::LoadAudioSample("E:\\linshare\\olcSimpleGameEngine\\discres\\Funky Chill 2 loop.wav", &rpPlayer);
|
|
|
|
|
|
olc::SOUND::PlaySample(sndHelperChange);
|
|
|
|
|
|
// Load Game Resources
|
|
|
// Define OLC Standard atlas
|
|
|
//atlasWorldMagetzub.Create(new olc::Sprite());// new olc::Sprite("thruster_landscape_all3_neo.png"));
|
|
|
//atlasWorldMagetzub.sprTileSheet->SaveToPGESprFile("discres\\discovery_magetzub_64x64.olcspr");
|
|
|
//atlasWorldMagetzub.sprTileSheet->LoadFromPGESprFile("E:\\linshare\\olcSimpleGameEngine\\discres\\discovery_magetzub_64x64.olcspr");
|
|
|
atlasWorldMagetzub.Create(new olc::Sprite("E:\\linshare\\olcSimpleGameEngine\\discres\\discovery_magetzub_64x64.olcspr", &rpPlayer));
|
|
|
|
|
|
//atlasWorldJavid.Create(new olc::Sprite());//new olc::Sprite("discovery_javid_64x64.png"));
|
|
|
//atlasWorldJavid.sprTileSheet->SaveToPGESprFile("discres\\discovery_javid_64x64.olcspr");
|
|
|
//atlasWorldJavid.sprTileSheet->LoadFromPGESprFile("E:\\linshare\\olcSimpleGameEngine\\discres\\discovery_javid_64x64.olcspr");
|
|
|
atlasWorldJavid.Create(new olc::Sprite("E:\\linshare\\olcSimpleGameEngine\\discres\\discovery_javid_64x64.olcspr", &rpPlayer));
|
|
|
|
|
|
//atlasWorldHopson.Create(new olc::Sprite());//new olc::Sprite("discovery_hopson_64x64.png"));
|
|
|
//atlasWorldHopson.sprTileSheet->SaveToPGESprFile("discres\\discovery_hopson_64x64.olcspr");
|
|
|
atlasWorldHopson.Create(new olc::Sprite("E:\\linshare\\olcSimpleGameEngine\\discres\\discovery_hopson_64x64.olcspr", &rpPlayer));
|
|
|
//atlasWorldHopson.sprTileSheet->LoadFromPGESprFile("E:\\linshare\\olcSimpleGameEngine\\discres\\discovery_hopson_64x64.olcspr");
|
|
|
for (int i = 0; i < 64; i++)
|
|
|
for (int j = 0; j < 64; j++)
|
|
|
{
|
|
|
//atlasWorld.location.emplace_back(j * 16, i * 16, 16, 16);
|
|
|
atlasWorldMagetzub.location.emplace_back(j * 64, i * 64, 64, 64);
|
|
|
atlasWorldJavid.location.emplace_back(j * 64, i * 64, 64, 64);
|
|
|
atlasWorldHopson.location.emplace_back(j * 64, i * 64, 64, 64);
|
|
|
}
|
|
|
|
|
|
//atlasCollectibles.Create(new olc::Sprite());// "discovery_collect1.png"));
|
|
|
//atlasCollectibles.sprTileSheet->SaveToPGESprFile("discres\\discovery_collectibles.olcspr");
|
|
|
//atlasCollectibles.sprTileSheet->LoadFromPGESprFile("E:\\linshare\\olcSimpleGameEngine\\discres\\discovery_collectibles.olcspr");
|
|
|
atlasCollectibles.Create(new olc::Sprite("E:\\linshare\\olcSimpleGameEngine\\discres\\discovery_collectibles.olcspr", &rpPlayer));
|
|
|
atlasCollectibles.location.emplace_back(0, 0, 16, 16); // Blank
|
|
|
atlasCollectibles.location.emplace_back(16, 0, 16, 16); // Disk
|
|
|
atlasCollectibles.location.emplace_back(32, 0, 16, 16); // Exit
|
|
|
atlasCollectibles.location.emplace_back(48, 0, 16, 16); // Key
|
|
|
atlasCollectibles.location.emplace_back(64, 0, 16, 16); // Javid
|
|
|
atlasCollectibles.location.emplace_back(80, 0, 16, 16); // Github
|
|
|
atlasCollectibles.location.emplace_back(96, 0, 16, 16); // Hopson
|
|
|
atlasCollectibles.location.emplace_back(112, 0, 16, 16); // Up
|
|
|
atlasCollectibles.location.emplace_back(128, 0, 16, 16); // Right
|
|
|
atlasCollectibles.location.emplace_back(144, 0, 16, 16); // Down
|
|
|
atlasCollectibles.location.emplace_back(160, 0, 16, 16); // Left
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
animPlayer.mapStates["idle"].push_back(new olc::Sprite("E:\\linshare\\olcSimpleGameEngine\\discres\\Player_Idle_000.olcspr", &rpPlayer));
|
|
|
animPlayer.mapStates["idle"].push_back(new olc::Sprite("E:\\linshare\\olcSimpleGameEngine\\discres\\Player_Idle_001.olcspr", &rpPlayer));
|
|
|
animPlayer.mapStates["idle"].push_back(new olc::Sprite("E:\\linshare\\olcSimpleGameEngine\\discres\\Player_Idle_002.olcspr", &rpPlayer));
|
|
|
animPlayer.mapStates["idle"].push_back(new olc::Sprite("E:\\linshare\\olcSimpleGameEngine\\discres\\Player_Idle_003.olcspr", &rpPlayer));
|
|
|
animPlayer.mapStates["idle"].push_back(new olc::Sprite("E:\\linshare\\olcSimpleGameEngine\\discres\\Player_Idle_004.olcspr", &rpPlayer));
|
|
|
animPlayer.mapStates["idle"].push_back(new olc::Sprite("E:\\linshare\\olcSimpleGameEngine\\discres\\Player_Idle_005.olcspr", &rpPlayer));
|
|
|
animPlayer.mapStates["idle"].push_back(new olc::Sprite("E:\\linshare\\olcSimpleGameEngine\\discres\\Player_Idle_006.olcspr", &rpPlayer));
|
|
|
animPlayer.mapStates["idle"].push_back(new olc::Sprite("E:\\linshare\\olcSimpleGameEngine\\discres\\Player_Idle_007.olcspr", &rpPlayer));
|
|
|
animPlayer.mapStates["idle"].push_back(new olc::Sprite("E:\\linshare\\olcSimpleGameEngine\\discres\\Player_Idle_008.olcspr", &rpPlayer));
|
|
|
animPlayer.mapStates["idle"].push_back(new olc::Sprite("E:\\linshare\\olcSimpleGameEngine\\discres\\Player_Idle_009.olcspr", &rpPlayer));
|
|
|
animPlayer.mapStates["idle"].push_back(new olc::Sprite("E:\\linshare\\olcSimpleGameEngine\\discres\\Player_Idle_010.olcspr", &rpPlayer));
|
|
|
animPlayer.mapStates["idle"].push_back(new olc::Sprite("E:\\linshare\\olcSimpleGameEngine\\discres\\Player_Idle_011.olcspr", &rpPlayer));
|
|
|
|
|
|
animPlayer.mapStates["idle_fire"].push_back(new olc::Sprite("E:\\linshare\\olcSimpleGameEngine\\discres\\Player_IdleFire_000.olcspr", &rpPlayer));
|
|
|
animPlayer.mapStates["idle_fire"].push_back(new olc::Sprite("E:\\linshare\\olcSimpleGameEngine\\discres\\Player_IdleFire_001.olcspr", &rpPlayer));
|
|
|
animPlayer.mapStates["idle_fire"].push_back(new olc::Sprite("E:\\linshare\\olcSimpleGameEngine\\discres\\Player_IdleFire_002.olcspr", &rpPlayer));
|
|
|
animPlayer.mapStates["idle_fire"].push_back(new olc::Sprite("E:\\linshare\\olcSimpleGameEngine\\discres\\Player_IdleFire_003.olcspr", &rpPlayer));
|
|
|
animPlayer.mapStates["idle_fire"].push_back(new olc::Sprite("E:\\linshare\\olcSimpleGameEngine\\discres\\Player_IdleFire_004.olcspr", &rpPlayer));
|
|
|
animPlayer.mapStates["idle_fire"].push_back(new olc::Sprite("E:\\linshare\\olcSimpleGameEngine\\discres\\Player_IdleFire_005.olcspr", &rpPlayer));
|
|
|
animPlayer.mapStates["idle_fire"].push_back(new olc::Sprite("E:\\linshare\\olcSimpleGameEngine\\discres\\Player_IdleFire_006.olcspr", &rpPlayer));
|
|
|
animPlayer.mapStates["idle_fire"].push_back(new olc::Sprite("E:\\linshare\\olcSimpleGameEngine\\discres\\Player_IdleFire_007.olcspr", &rpPlayer));
|
|
|
animPlayer.mapStates["idle_fire"].push_back(new olc::Sprite("E:\\linshare\\olcSimpleGameEngine\\discres\\Player_IdleFire_008.olcspr", &rpPlayer));
|
|
|
animPlayer.mapStates["idle_fire"].push_back(new olc::Sprite("E:\\linshare\\olcSimpleGameEngine\\discres\\Player_IdleFire_009.olcspr", &rpPlayer));
|
|
|
animPlayer.mapStates["idle_fire"].push_back(new olc::Sprite("E:\\linshare\\olcSimpleGameEngine\\discres\\Player_IdleFire_010.olcspr", &rpPlayer));
|
|
|
animPlayer.mapStates["idle_fire"].push_back(new olc::Sprite("E:\\linshare\\olcSimpleGameEngine\\discres\\Player_IdleFire_011.olcspr", &rpPlayer));
|
|
|
|
|
|
animPlayer.mapStates["run"].push_back(new olc::Sprite("E:\\linshare\\olcSimpleGameEngine\\discres\\Player_Run_000.olcspr", &rpPlayer));
|
|
|
animPlayer.mapStates["run"].push_back(new olc::Sprite("E:\\linshare\\olcSimpleGameEngine\\discres\\Player_Run_001.olcspr", &rpPlayer));
|
|
|
animPlayer.mapStates["run"].push_back(new olc::Sprite("E:\\linshare\\olcSimpleGameEngine\\discres\\Player_Run_002.olcspr", &rpPlayer));
|
|
|
animPlayer.mapStates["run"].push_back(new olc::Sprite("E:\\linshare\\olcSimpleGameEngine\\discres\\Player_Run_003.olcspr", &rpPlayer));
|
|
|
animPlayer.mapStates["run"].push_back(new olc::Sprite("E:\\linshare\\olcSimpleGameEngine\\discres\\Player_Run_004.olcspr", &rpPlayer));
|
|
|
animPlayer.mapStates["run"].push_back(new olc::Sprite("E:\\linshare\\olcSimpleGameEngine\\discres\\Player_Run_005.olcspr", &rpPlayer));
|
|
|
animPlayer.mapStates["run"].push_back(new olc::Sprite("E:\\linshare\\olcSimpleGameEngine\\discres\\Player_Run_006.olcspr", &rpPlayer));
|
|
|
animPlayer.mapStates["run"].push_back(new olc::Sprite("E:\\linshare\\olcSimpleGameEngine\\discres\\Player_Run_007.olcspr", &rpPlayer));
|
|
|
animPlayer.mapStates["run"].push_back(new olc::Sprite("E:\\linshare\\olcSimpleGameEngine\\discres\\Player_Run_008.olcspr", &rpPlayer));
|
|
|
animPlayer.mapStates["run"].push_back(new olc::Sprite("E:\\linshare\\olcSimpleGameEngine\\discres\\Player_Run_009.olcspr", &rpPlayer));
|
|
|
animPlayer.mapStates["run"].push_back(new olc::Sprite("E:\\linshare\\olcSimpleGameEngine\\discres\\Player_Run_010.olcspr", &rpPlayer));
|
|
|
animPlayer.mapStates["run"].push_back(new olc::Sprite("E:\\linshare\\olcSimpleGameEngine\\discres\\Player_Run_011.olcspr", &rpPlayer));
|
|
|
|
|
|
animPlayer.mapStates["run_fire"].push_back(new olc::Sprite("E:\\linshare\\olcSimpleGameEngine\\discres\\Player_RunFire_000.olcspr", &rpPlayer));
|
|
|
animPlayer.mapStates["run_fire"].push_back(new olc::Sprite("E:\\linshare\\olcSimpleGameEngine\\discres\\Player_RunFire_001.olcspr", &rpPlayer));
|
|
|
animPlayer.mapStates["run_fire"].push_back(new olc::Sprite("E:\\linshare\\olcSimpleGameEngine\\discres\\Player_RunFire_002.olcspr", &rpPlayer));
|
|
|
animPlayer.mapStates["run_fire"].push_back(new olc::Sprite("E:\\linshare\\olcSimpleGameEngine\\discres\\Player_RunFire_003.olcspr", &rpPlayer));
|
|
|
animPlayer.mapStates["run_fire"].push_back(new olc::Sprite("E:\\linshare\\olcSimpleGameEngine\\discres\\Player_RunFire_004.olcspr", &rpPlayer));
|
|
|
animPlayer.mapStates["run_fire"].push_back(new olc::Sprite("E:\\linshare\\olcSimpleGameEngine\\discres\\Player_RunFire_005.olcspr", &rpPlayer));
|
|
|
animPlayer.mapStates["run_fire"].push_back(new olc::Sprite("E:\\linshare\\olcSimpleGameEngine\\discres\\Player_RunFire_006.olcspr", &rpPlayer));
|
|
|
animPlayer.mapStates["run_fire"].push_back(new olc::Sprite("E:\\linshare\\olcSimpleGameEngine\\discres\\Player_RunFire_007.olcspr", &rpPlayer));
|
|
|
animPlayer.mapStates["run_fire"].push_back(new olc::Sprite("E:\\linshare\\olcSimpleGameEngine\\discres\\Player_RunFire_008.olcspr", &rpPlayer));
|
|
|
animPlayer.mapStates["run_fire"].push_back(new olc::Sprite("E:\\linshare\\olcSimpleGameEngine\\discres\\Player_RunFire_009.olcspr", &rpPlayer));
|
|
|
animPlayer.mapStates["run_fire"].push_back(new olc::Sprite("E:\\linshare\\olcSimpleGameEngine\\discres\\Player_RunFire_010.olcspr", &rpPlayer));
|
|
|
animPlayer.mapStates["run_fire"].push_back(new olc::Sprite("E:\\linshare\\olcSimpleGameEngine\\discres\\Player_RunFire_011.olcspr", &rpPlayer));
|
|
|
|
|
|
animPlayer.mapStates["jump"].push_back(new olc::Sprite("E:\\linshare\\olcSimpleGameEngine\\discres\\Player_Jump_000.olcspr", &rpPlayer));
|
|
|
animPlayer.mapStates["jump"].push_back(new olc::Sprite("E:\\linshare\\olcSimpleGameEngine\\discres\\Player_Jump_001.olcspr", &rpPlayer));
|
|
|
animPlayer.mapStates["jump"].push_back(new olc::Sprite("E:\\linshare\\olcSimpleGameEngine\\discres\\Player_Jump_002.olcspr", &rpPlayer));
|
|
|
animPlayer.mapStates["jump"].push_back(new olc::Sprite("E:\\linshare\\olcSimpleGameEngine\\discres\\Player_Jump_003.olcspr", &rpPlayer));
|
|
|
animPlayer.mapStates["jump"].push_back(new olc::Sprite("E:\\linshare\\olcSimpleGameEngine\\discres\\Player_Jump_004.olcspr", &rpPlayer));
|
|
|
animPlayer.mapStates["jump"].push_back(new olc::Sprite("E:\\linshare\\olcSimpleGameEngine\\discres\\Player_Jump_005.olcspr", &rpPlayer));
|
|
|
|
|
|
animPlayer.mapStates["fall"].push_back(new olc::Sprite("E:\\linshare\\olcSimpleGameEngine\\discres\\Player_Fall_000.olcspr", &rpPlayer));
|
|
|
animPlayer.mapStates["fall"].push_back(new olc::Sprite("E:\\linshare\\olcSimpleGameEngine\\discres\\Player_Fall_001.olcspr", &rpPlayer));
|
|
|
animPlayer.mapStates["fall"].push_back(new olc::Sprite("E:\\linshare\\olcSimpleGameEngine\\discres\\Player_Fall_002.olcspr", &rpPlayer));
|
|
|
animPlayer.mapStates["fall"].push_back(new olc::Sprite("E:\\linshare\\olcSimpleGameEngine\\discres\\Player_Fall_003.olcspr", &rpPlayer));
|
|
|
animPlayer.mapStates["fall"].push_back(new olc::Sprite("E:\\linshare\\olcSimpleGameEngine\\discres\\Player_Fall_004.olcspr", &rpPlayer));
|
|
|
animPlayer.mapStates["fall"].push_back(new olc::Sprite("E:\\linshare\\olcSimpleGameEngine\\discres\\Player_Fall_005.olcspr", &rpPlayer));
|
|
|
|
|
|
animPlayer.mapStates["air_fire"].push_back(new olc::Sprite("E:\\linshare\\olcSimpleGameEngine\\discres\\Player_AirFire_000.olcspr", &rpPlayer));
|
|
|
animPlayer.mapStates["air_fire"].push_back(new olc::Sprite("E:\\linshare\\olcSimpleGameEngine\\discres\\Player_AirFire_001.olcspr", &rpPlayer));
|
|
|
animPlayer.mapStates["air_fire"].push_back(new olc::Sprite("E:\\linshare\\olcSimpleGameEngine\\discres\\Player_AirFire_002.olcspr", &rpPlayer));
|
|
|
animPlayer.mapStates["air_fire"].push_back(new olc::Sprite("E:\\linshare\\olcSimpleGameEngine\\discres\\Player_AirFire_003.olcspr", &rpPlayer));
|
|
|
animPlayer.mapStates["air_fire"].push_back(new olc::Sprite("E:\\linshare\\olcSimpleGameEngine\\discres\\Player_AirFire_004.olcspr", &rpPlayer));
|
|
|
animPlayer.mapStates["air_fire"].push_back(new olc::Sprite("E:\\linshare\\olcSimpleGameEngine\\discres\\Player_AirFire_005.olcspr", &rpPlayer));
|
|
|
|
|
|
//sprBackdropMagetzub = new olc::Sprite("discovery_magetzub_bg.png");
|
|
|
//sprBackdropHopson = new olc::Sprite("discovery_hopson_bg.png");
|
|
|
//sprTitleScreen = new olc::Sprite("discovery_titlescreen.png");
|
|
|
//sprStoryScreen = new olc::Sprite("discovery_story.png");
|
|
|
//sprCreditScreen = new olc::Sprite("discovery_credits.png");
|
|
|
//sprControlScreen = new olc::Sprite("discovery_story2.png");
|
|
|
//sprCompleteScreen = new olc::Sprite("discovery_title_bg.png");
|
|
|
|
|
|
//sprBackdropMagetzub->SaveToPGESprFile("discres\\discovery_magetzub_bg.olcspr");
|
|
|
//sprBackdropHopson->SaveToPGESprFile("discres\\discovery_hopson_bg.olcspr");
|
|
|
//sprTitleScreen->SaveToPGESprFile("discres\\discovery_titlescreen.olcspr");
|
|
|
//sprStoryScreen->SaveToPGESprFile("discres\\discovery_story.olcspr");
|
|
|
//sprCreditScreen->SaveToPGESprFile("discres\\discovery_credits.olcspr");
|
|
|
//sprControlScreen->SaveToPGESprFile("discres\\discovery_story2.olcspr");
|
|
|
//sprCompleteScreen->SaveToPGESprFile("discres\\discovery_title_bg.olcspr");
|
|
|
|
|
|
sprBackdropMagetzub = new olc::Sprite("E:\\linshare\\olcSimpleGameEngine\\discres\\discovery_magetzub_bg.olcspr", &rpPlayer);
|
|
|
sprBackdropHopson = new olc::Sprite("E:\\linshare\\olcSimpleGameEngine\\discres\\discovery_hopson_bg.olcspr", &rpPlayer);
|
|
|
sprTitleScreen = new olc::Sprite("E:\\linshare\\olcSimpleGameEngine\\discres\\discovery_titlescreen.olcspr", &rpPlayer);
|
|
|
sprStoryScreen = new olc::Sprite("E:\\linshare\\olcSimpleGameEngine\\discres\\discovery_story.olcspr", &rpPlayer);
|
|
|
sprCreditScreen = new olc::Sprite("E:\\linshare\\olcSimpleGameEngine\\discres\\discovery_credits.olcspr", &rpPlayer);
|
|
|
sprControlScreen = new olc::Sprite("E:\\linshare\\olcSimpleGameEngine\\discres\\discovery_story2.olcspr", &rpPlayer);
|
|
|
sprCompleteScreen = new olc::Sprite("E:\\linshare\\olcSimpleGameEngine\\discres\\discovery_title_bg.olcspr", &rpPlayer);
|
|
|
|
|
|
rpPlayer.ClearPack();
|
|
|
|
|
|
nGameState = GS_TITLE;
|
|
|
|
|
|
return true;
|
|
|
}
|
|
|
|
|
|
int nTitleSelection = 0;
|
|
|
int nLevelSeed = 1;
|
|
|
int nLevelSize = 2;
|
|
|
|
|
|
bool GameState_Title(float fElapsedTime)
|
|
|
{
|
|
|
controller.Update(fElapsedTime);
|
|
|
|
|
|
DrawSprite(0, 0, sprTitleScreen);
|
|
|
|
|
|
DrawString(300, 280, "Story & Help", nTitleSelection == 0 ? olc::WHITE : olc::YELLOW, 2);
|
|
|
DrawString(300, 310, "Credits", nTitleSelection == 1 ? olc::WHITE : olc::YELLOW, 2);
|
|
|
DrawString(300, 340, "Level: " + to_string(nLevelSeed), nTitleSelection == 2 ? olc::WHITE : olc::YELLOW, 2);
|
|
|
DrawString(300, 370, "Size: " + to_string((int)pow(2, (nLevelSize+2))), nTitleSelection == 3 ? olc::WHITE : olc::YELLOW, 2);
|
|
|
DrawString(300, 400, "Start", nTitleSelection == 4 ? olc::WHITE : olc::YELLOW, 2);
|
|
|
|
|
|
if (GetKey(olc::Key::UP).bPressed || controller.GetButton(UP).bPressed)
|
|
|
{
|
|
|
nTitleSelection--;
|
|
|
if (nTitleSelection < 0) nTitleSelection = 4;
|
|
|
olc::SOUND::PlaySample(sndThump);
|
|
|
}
|
|
|
|
|
|
if (GetKey(olc::Key::DOWN).bPressed || controller.GetButton(DOWN).bPressed)
|
|
|
{
|
|
|
nTitleSelection++;
|
|
|
if (nTitleSelection > 4 ) nTitleSelection = 0;
|
|
|
olc::SOUND::PlaySample(sndThump);
|
|
|
}
|
|
|
|
|
|
if (GetKey(olc::Key::LEFT).bPressed || controller.GetButton(LEFT).bPressed)
|
|
|
{
|
|
|
if (nTitleSelection == 2)
|
|
|
{
|
|
|
nLevelSeed--;
|
|
|
if (nLevelSeed < 0) nLevelSeed = 999;
|
|
|
}
|
|
|
|
|
|
if (nTitleSelection == 3)
|
|
|
{
|
|
|
nLevelSize--;
|
|
|
if (nLevelSize < 1) nLevelSize = 3;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
if (GetKey(olc::Key::RIGHT).bPressed || controller.GetButton(RIGHT).bPressed)
|
|
|
{
|
|
|
if (nTitleSelection == 2)
|
|
|
{
|
|
|
nLevelSeed++;
|
|
|
if (nLevelSeed > 999) nLevelSeed = 0;
|
|
|
}
|
|
|
|
|
|
if (nTitleSelection == 3)
|
|
|
{
|
|
|
nLevelSize++;
|
|
|
if (nLevelSize > 3) nLevelSize = 1;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
if (GetKey(olc::Key::SPACE).bPressed || controller.GetButton(A).bPressed)
|
|
|
{
|
|
|
if (nTitleSelection == 0) nGameState = GS_STORY;
|
|
|
if (nTitleSelection == 1) nGameState = GS_CREDITS;
|
|
|
|
|
|
if (nTitleSelection == 4) nGameState = GS_GENERATE;
|
|
|
}
|
|
|
|
|
|
return true;
|
|
|
}
|
|
|
|
|
|
bool GameState_Generating(float fElapsedTime)
|
|
|
{
|
|
|
fPlayerPosX = 2.0f;
|
|
|
fPlayerPosY = 2.0f;
|
|
|
fPlayerVelX = 0.0f;
|
|
|
fPlayerVelY = 0.0f;
|
|
|
fCameraPosX = 0.0f;
|
|
|
fCameraPosY = 0.0f;
|
|
|
bPlayerOnGround = false;
|
|
|
bPlayerTouchingWall = false;
|
|
|
bPlayerTouchingWallOld = false;
|
|
|
bCollisionLeft = false;
|
|
|
fTimeToJump = 0.0f;
|
|
|
fTimeToJumpMax = 0.25f;
|
|
|
fFaceDir = 1.0f;
|
|
|
nFloppyDisks = 0;
|
|
|
fGameTime = 0.0f;
|
|
|
fGameTimeMultiplier = 1.0f;
|
|
|
nHopsonTokens = 0;
|
|
|
nJavidTokens = 0;
|
|
|
nKeys = 0;
|
|
|
fEffectTime = 0.0f;
|
|
|
fModeTime = 0.0f;
|
|
|
|
|
|
nChallengeMapSizeX = (int)pow(2, nLevelSize + 2);
|
|
|
nChallengeMapSizeY = (int)pow(2, nLevelSize + 2);
|
|
|
srand(nLevelSeed);
|
|
|
|
|
|
|
|
|
// Generate a boolean maze
|
|
|
bool *bTileMaze = nullptr;
|
|
|
int nMapWidth, nMapHeight;
|
|
|
printf("D\n");
|
|
|
CreateMaze(bTileMaze, nChallengePathSizeX - 1, nChallengePathSizeY - 1, nChallengeMapSizeX, nChallengeMapSizeY, nMapWidth, nMapHeight);
|
|
|
|
|
|
if (sprMiniMap != nullptr) delete sprMiniMap;
|
|
|
sprMiniMap = new olc::Sprite(nChallengeMapSizeX, nChallengeMapSizeY);
|
|
|
printf("D\n");
|
|
|
// Create tilemap to match dimensions of generated maze
|
|
|
layerWorld.Create(nMapWidth, nMapHeight, nTileSizeX, nTileSizeY);
|
|
|
layerCollectibles.Create(nMapWidth, nMapHeight, nTileSizeX, nTileSizeY);
|
|
|
layerJavid.Create(nMapWidth, nMapHeight, nTileSizeX, nTileSizeY);
|
|
|
|
|
|
printf("D\n");
|
|
|
// Transfer over boolean maze to tilemap
|
|
|
for (int x = 0; x < layerWorld.nLayerWidth; x++)
|
|
|
for (int y = 0; y < layerWorld.nLayerHeight; y++)
|
|
|
{
|
|
|
layerWorld.GetTile(x, y)->exist = !bTileMaze[y*layerWorld.nLayerWidth + x];
|
|
|
}
|
|
|
|
|
|
printf("D\n");
|
|
|
CreateBorderMap();
|
|
|
|
|
|
printf("D\n");
|
|
|
delete[] bTileMaze;
|
|
|
printf("D\n");
|
|
|
listKeys.clear();
|
|
|
printf("D\n");
|
|
|
// Add 100 Drops
|
|
|
for (int i = 0; i < 136; i++)
|
|
|
{
|
|
|
bool bDone = false;
|
|
|
do
|
|
|
{
|
|
|
int x = rand() % layerWorld.nLayerWidth;
|
|
|
int y = rand() % layerWorld.nLayerHeight;
|
|
|
if (!layerWorld.GetTile(x, y)->exist && !layerCollectibles.GetTile(x, y)->exist)
|
|
|
{
|
|
|
|
|
|
layerCollectibles.GetTile(x, y)->exist = true;
|
|
|
if (i < 100) layerCollectibles.GetTile(x, y)->id = 1; // Place disks
|
|
|
if (i == 100) // Place Exit
|
|
|
{
|
|
|
layerCollectibles.GetTile(x, y)->id = 2; listKeys.push_back(make_pair(x, y));
|
|
|
}
|
|
|
if (i > 100 && i <= 104)// Place Keys
|
|
|
{
|
|
|
layerCollectibles.GetTile(x, y)->id = 3; listKeys.push_back(make_pair(x, y));
|
|
|
}
|
|
|
if (i > 105 && i <= 125) layerCollectibles.GetTile(x, y)->id = 5; // Place Githubs
|
|
|
if (i > 125 && i <= 130) layerCollectibles.GetTile(x, y)->id = 4; // Place Javids
|
|
|
if (i > 130 && i <= 135) layerCollectibles.GetTile(x, y)->id = 6; // Place Hopsons
|
|
|
bDone = true;
|
|
|
}
|
|
|
|
|
|
} while (!bDone);
|
|
|
}
|
|
|
|
|
|
olc::SOUND::PlaySample(sndTheme, true);
|
|
|
nGameState = GS_MAIN;
|
|
|
printf("Entering Main\n");
|
|
|
|
|
|
return true;
|
|
|
}
|
|
|
|
|
|
bool GameState_Main(float fElapsedTime)
|
|
|
{
|
|
|
fGameTime += fElapsedTime * fGameTimeMultiplier;
|
|
|
|
|
|
controller.Update(fElapsedTime);
|
|
|
animPlayer.Update(fElapsedTime);
|
|
|
|
|
|
bool bStartWallJump = bPlayerTouchingWall & !bPlayerTouchingWallOld;
|
|
|
bPlayerTouchingWallOld = bPlayerTouchingWall;
|
|
|
|
|
|
if (bStartWallJump)
|
|
|
{
|
|
|
fTimeToJump = fTimeToJumpMax;
|
|
|
olc::SOUND::PlaySample(sndWall);
|
|
|
}
|
|
|
|
|
|
if (fTimeToJump >= 0.0f)
|
|
|
fTimeToJump -= fElapsedTime;
|
|
|
|
|
|
bPlayerTouchingWall = false;
|
|
|
|
|
|
// Handle Input
|
|
|
if (IsFocused())
|
|
|
{
|
|
|
/*if (GetKey(olc::Key::F1).bReleased) nRenderMode = MODE_MAGETZUB;
|
|
|
if (GetKey(olc::Key::F2).bReleased) {
|
|
|
nRenderMode = MODE_JAVID; fModeTime = 500.0f; CalculateFlowMap();
|
|
|
}
|
|
|
if (GetKey(olc::Key::F3).bReleased) nRenderMode = MODE_HOPSON;
|
|
|
|
|
|
|
|
|
if (GetKey(olc::Key::F5).bReleased) nRenderEffect = EFFECT_NONE;
|
|
|
if (GetKey(olc::Key::F6).bReleased) nRenderEffect = EFFECT_UGLYSWEDISHFISH;
|
|
|
if (GetKey(olc::Key::F7).bReleased) nRenderEffect = EFFECT_GORBIT;
|
|
|
if (GetKey(olc::Key::F8).bReleased) nRenderEffect = EFFECT_SEDIT;*/
|
|
|
|
|
|
/*if (GetKey(olc::Key::UP).bHeld || controller.GetButton(UP).bHeld)
|
|
|
{
|
|
|
fPlayerVelY = -2.0f;
|
|
|
}
|
|
|
|
|
|
if (GetKey(olc::Key::DOWN).bHeld || controller.GetButton(DOWN).bHeld)
|
|
|
{
|
|
|
fPlayerVelY = 2.0f;
|
|
|
}*/
|
|
|
|
|
|
if (GetKey(olc::Key::LEFT).bHeld || controller.GetButton(LEFT).bHeld)
|
|
|
{
|
|
|
fPlayerVelX += (bPlayerOnGround ? -25.0f : -15.0f) *fElapsedTime;
|
|
|
fFaceDir = -1.0f;
|
|
|
}
|
|
|
|
|
|
if (GetKey(olc::Key::RIGHT).bHeld || controller.GetButton(RIGHT).bHeld)
|
|
|
{
|
|
|
fPlayerVelX += (bPlayerOnGround ? 25.0f : 15.0f) *fElapsedTime;
|
|
|
fFaceDir = +1.0f;
|
|
|
}
|
|
|
|
|
|
if (GetKey(olc::Key::SPACE).bPressed || controller.GetButton(A).bPressed)
|
|
|
{
|
|
|
if (bPlayerOnGround)
|
|
|
{
|
|
|
fPlayerVelY = -12.0f;
|
|
|
olc::SOUND::PlaySample(sndJump);
|
|
|
}
|
|
|
|
|
|
if (fTimeToJump >= 0.0f)
|
|
|
{
|
|
|
if (fPlayerVelX < 0 && !bCollisionLeft)
|
|
|
{
|
|
|
fPlayerVelY = -12.0f;
|
|
|
olc::SOUND::PlaySample(sndJump);
|
|
|
}
|
|
|
|
|
|
if (fPlayerVelX > 0 && bCollisionLeft)
|
|
|
{
|
|
|
fPlayerVelY = -12.0f;
|
|
|
olc::SOUND::PlaySample(sndJump);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
|
|
|
bFire = false;
|
|
|
if (GetKey(olc::Key::A).bPressed || controller.GetButton(X).bPressed)
|
|
|
{
|
|
|
//bFire = true;
|
|
|
|
|
|
if (nRenderMode == MODE_HOPSON)
|
|
|
{
|
|
|
if (fFaceDir < 0)
|
|
|
{
|
|
|
int bx = fPlayerPosX;
|
|
|
int by = fPlayerPosY + 0.5f;
|
|
|
if (bx > 0 && bx < (layerWorld.nLayerWidth - 1) && by > 0 && by < (layerWorld.nLayerHeight - 1) && layerWorld.GetTile(bx, by)->exist)
|
|
|
{
|
|
|
layerWorld.GetTile(bx, by)->exist = false;
|
|
|
CreateBorderMap();
|
|
|
}
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
int bx = fPlayerPosX + 1.0f;
|
|
|
int by = fPlayerPosY + 0.5f;
|
|
|
if (bx > 0 && bx < (layerWorld.nLayerWidth - 1) && by > 0 && by < (layerWorld.nLayerHeight - 1) && layerWorld.GetTile(bx, by)->exist)
|
|
|
{
|
|
|
layerWorld.GetTile(bx, by)->exist = false;
|
|
|
CreateBorderMap();
|
|
|
}
|
|
|
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
if (GetKey(olc::Key::J).bPressed || controller.GetButton(Y).bPressed)
|
|
|
{
|
|
|
if (nRenderMode != MODE_JAVID && nJavidTokens > 0)
|
|
|
{
|
|
|
nJavidTokens--;
|
|
|
nRenderMode = MODE_JAVID;
|
|
|
fModeTime = 60.0f;
|
|
|
CalculateFlowMap();
|
|
|
olc::SOUND::PlaySample(sndHelperChange);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
if (GetKey(olc::Key::H).bPressed || controller.GetButton(B).bPressed)
|
|
|
{
|
|
|
if (nRenderMode != MODE_HOPSON && nHopsonTokens > 0)
|
|
|
{
|
|
|
nHopsonTokens--;
|
|
|
nRenderMode = MODE_HOPSON;
|
|
|
fModeTime = 30.0f;
|
|
|
olc::SOUND::PlaySample(sndHelperChange);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
|
|
|
fPlayerVelY += 20.0f * fElapsedTime;
|
|
|
|
|
|
if (bPlayerOnGround)
|
|
|
{
|
|
|
|
|
|
fPlayerVelX += -3.0f * fPlayerVelX * fElapsedTime;
|
|
|
if (fabs(fPlayerVelX) < 0.01f)
|
|
|
{
|
|
|
fPlayerVelX = 0.0f;
|
|
|
animPlayer.ChangeState(bFire ? "idle_fire" : "idle");
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
animPlayer.ChangeState(bFire ? "run_fire" : "run");
|
|
|
}
|
|
|
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
if (!bFire)
|
|
|
{
|
|
|
if (fPlayerVelY < 0)
|
|
|
animPlayer.ChangeState("jump");
|
|
|
else
|
|
|
animPlayer.ChangeState("fall");
|
|
|
}
|
|
|
else
|
|
|
animPlayer.ChangeState("air_fire");
|
|
|
}
|
|
|
|
|
|
|
|
|
if (layerCollectibles.GetTile(fPlayerPosX + 0.5f, fPlayerPosY + 0.5f)->id == 1) // Disk
|
|
|
{
|
|
|
layerCollectibles.GetTile(fPlayerPosX + 0.5f, fPlayerPosY + 0.5f)->id = 0;
|
|
|
layerCollectibles.GetTile(fPlayerPosX + 0.5f, fPlayerPosY + 0.5f)->exist = false;
|
|
|
nFloppyDisks++;
|
|
|
olc::SOUND::PlaySample(sndDiskCollect);
|
|
|
}
|
|
|
|
|
|
if (layerCollectibles.GetTile(fPlayerPosX + 0.5f, fPlayerPosY + 0.5f)->id == 2) // Exit
|
|
|
{
|
|
|
if (nKeys == 4)
|
|
|
{
|
|
|
// Game Completed
|
|
|
nGameState = GS_COMPLETE;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
if (layerCollectibles.GetTile(fPlayerPosX + 0.5f, fPlayerPosY + 0.5f)->id == 3) // Keys
|
|
|
{
|
|
|
layerCollectibles.GetTile(fPlayerPosX + 0.5f, fPlayerPosY + 0.5f)->id = 0;
|
|
|
layerCollectibles.GetTile(fPlayerPosX + 0.5f, fPlayerPosY + 0.5f)->exist = false;
|
|
|
nKeys++;
|
|
|
|
|
|
|
|
|
// Remove key from list
|
|
|
listKeys.remove_if([&](pair<int, int> &p) {return p.first == ((int)(fPlayerPosX + 0.5f)) && p.second == ((int)(fPlayerPosY + 0.5f)); });
|
|
|
CalculateFlowMap();
|
|
|
olc::SOUND::PlaySample(sndKeyCollect);
|
|
|
}
|
|
|
|
|
|
if (layerCollectibles.GetTile(fPlayerPosX + 0.5f, fPlayerPosY + 0.5f)->id == 4) // Javid
|
|
|
{
|
|
|
layerCollectibles.GetTile(fPlayerPosX + 0.5f, fPlayerPosY + 0.5f)->id = 0;
|
|
|
layerCollectibles.GetTile(fPlayerPosX + 0.5f, fPlayerPosY + 0.5f)->exist = false;
|
|
|
nJavidTokens++;
|
|
|
|
|
|
//fModeTime = 30.0f;
|
|
|
//nRenderMode = MODE_JAVID;
|
|
|
|
|
|
//if (nRenderMode == MODE_JAVID)
|
|
|
//{
|
|
|
// // Javid is helpful and likes to simplify so help out the user
|
|
|
// CalculateFlowMap();
|
|
|
//}
|
|
|
olc::SOUND::PlaySample(sndKeyCollect);
|
|
|
}
|
|
|
|
|
|
if (layerCollectibles.GetTile(fPlayerPosX + 0.5f, fPlayerPosY + 0.5f)->id == 6) // Hopson
|
|
|
{
|
|
|
layerCollectibles.GetTile(fPlayerPosX + 0.5f, fPlayerPosY + 0.5f)->id = 0;
|
|
|
layerCollectibles.GetTile(fPlayerPosX + 0.5f, fPlayerPosY + 0.5f)->exist = false;
|
|
|
nHopsonTokens++;
|
|
|
|
|
|
/*fModeTime = 30.0f;
|
|
|
nRenderMode = MODE_HOPSON;*/
|
|
|
olc::SOUND::PlaySample(sndKeyCollect);
|
|
|
}
|
|
|
|
|
|
if (layerCollectibles.GetTile(fPlayerPosX + 0.5f, fPlayerPosY + 0.5f)->id == 5) // Github
|
|
|
{
|
|
|
layerCollectibles.GetTile(fPlayerPosX + 0.5f, fPlayerPosY + 0.5f)->id = 0;
|
|
|
layerCollectibles.GetTile(fPlayerPosX + 0.5f, fPlayerPosY + 0.5f)->exist = false;
|
|
|
fEffectTime = 10.0f;
|
|
|
switch (rand() % 4)
|
|
|
{
|
|
|
case 0: nRenderEffect = EFFECT_UGLYSWEDISHFISH; break;
|
|
|
case 1: nRenderEffect = EFFECT_SEDIT; break;
|
|
|
case 2: nRenderEffect = EFFECT_GORBIT; break;
|
|
|
case 3: nRenderEffect = EFFECT_BRANK; break;
|
|
|
}
|
|
|
fGameTimeMultiplier = 0.75f;
|
|
|
olc::SOUND::PlaySample(sndGithubPatch);
|
|
|
}
|
|
|
|
|
|
if (fEffectTime > 0.0f)
|
|
|
{
|
|
|
fEffectTime -= fElapsedTime;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
nRenderEffect = EFFECT_NONE;
|
|
|
fGameTimeMultiplier = 1.0f;
|
|
|
}
|
|
|
|
|
|
|
|
|
if (fModeTime > 0.0f)
|
|
|
{
|
|
|
fModeTime -= fElapsedTime;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
nRenderMode = MODE_MAGETZUB;
|
|
|
//olc::SOUND::PlaySample(sndHelperChange);
|
|
|
}
|
|
|
|
|
|
|
|
|
if (fPlayerVelX > 10.0f)
|
|
|
fPlayerVelX = 10.0f;
|
|
|
|
|
|
if (fPlayerVelX < -10.0f)
|
|
|
fPlayerVelX = -10.0f;
|
|
|
|
|
|
if (fPlayerVelY > 100.0f)
|
|
|
fPlayerVelY = 100.0f;
|
|
|
|
|
|
if (fPlayerVelY < -100.0f)
|
|
|
fPlayerVelY = -100.0f;
|
|
|
|
|
|
sprMiniMap->SetPixel(fPlayerPosX / nChallengePathSizeX, fPlayerPosY / nChallengePathSizeY, olc::GREEN);
|
|
|
|
|
|
float fNewPlayerPosX = fPlayerPosX + fPlayerVelX * fElapsedTime;
|
|
|
float fNewPlayerPosY = fPlayerPosY + fPlayerVelY * fElapsedTime;
|
|
|
|
|
|
sprMiniMap->SetPixel(fNewPlayerPosX / nChallengePathSizeX, fNewPlayerPosY / nChallengePathSizeY, olc::WHITE);
|
|
|
|
|
|
// Collision
|
|
|
float fOffset = 0.2f;
|
|
|
if (fPlayerVelX <= 0)
|
|
|
{
|
|
|
if (layerWorld.GetTile(fNewPlayerPosX + 0.0f + fOffset, fPlayerPosY + 0.0f)->exist || layerWorld.GetTile(fNewPlayerPosX + 0.0f + fOffset, fPlayerPosY + 0.9f)->exist)
|
|
|
{
|
|
|
fNewPlayerPosX = (int)fNewPlayerPosX + 1 - fOffset;
|
|
|
fPlayerVelX = 0;
|
|
|
bPlayerTouchingWall = true;
|
|
|
bCollisionLeft = true;
|
|
|
}
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
if (layerWorld.GetTile(fNewPlayerPosX + 1.0f - fOffset, fPlayerPosY + 0.0f)->exist || layerWorld.GetTile(fNewPlayerPosX + 1.0f - fOffset, fPlayerPosY + 0.9f)->exist)
|
|
|
{
|
|
|
fNewPlayerPosX = (int)fNewPlayerPosX + fOffset;
|
|
|
fPlayerVelX = 0;
|
|
|
bPlayerTouchingWall = true;
|
|
|
bCollisionLeft = false;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
bPlayerOnGround = false;
|
|
|
if (fPlayerVelY <= 0)
|
|
|
{
|
|
|
if (layerWorld.GetTile(fNewPlayerPosX + 0.0f + fOffset, fNewPlayerPosY)->exist || layerWorld.GetTile(fNewPlayerPosX + 0.9f - fOffset, fNewPlayerPosY)->exist)
|
|
|
{
|
|
|
fNewPlayerPosY = (int)fNewPlayerPosY + 1;
|
|
|
fPlayerVelY = 0;
|
|
|
}
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
if (layerWorld.GetTile(fNewPlayerPosX + 0.0f + fOffset, fNewPlayerPosY + 1.0f)->exist || layerWorld.GetTile(fNewPlayerPosX + 0.9f - fOffset, fNewPlayerPosY + 1.0f)->exist)
|
|
|
{
|
|
|
fNewPlayerPosY = (int)fNewPlayerPosY;
|
|
|
fPlayerVelY = 0;
|
|
|
bPlayerOnGround = true;
|
|
|
|
|
|
}
|
|
|
}
|
|
|
|
|
|
fPlayerPosX = fNewPlayerPosX;
|
|
|
fPlayerPosY = fNewPlayerPosY;
|
|
|
|
|
|
fCameraPosX = fPlayerPosX;
|
|
|
fCameraPosY = fPlayerPosY;
|
|
|
|
|
|
int nVisibleTilesX = ScreenWidth() / nTileSizeX;
|
|
|
int nVisibleTilesY = ScreenHeight() / nTileSizeY;
|
|
|
|
|
|
// Calculate Top-Leftmost visible tile
|
|
|
float fOffsetX = fCameraPosX - (float)nVisibleTilesX / 2.0f;
|
|
|
float fOffsetY = fCameraPosY - (float)nVisibleTilesY / 2.0f;
|
|
|
|
|
|
|
|
|
// Clamp camera to game boundaries
|
|
|
if (fOffsetX < 0) fOffsetX = 0;
|
|
|
if (fOffsetY < 0) fOffsetY = 0;
|
|
|
if (fOffsetX > layerWorld.nLayerWidth - nVisibleTilesX) fOffsetX = layerWorld.nLayerWidth - nVisibleTilesX;
|
|
|
if (fOffsetY > layerWorld.nLayerHeight - nVisibleTilesY) fOffsetY = layerWorld.nLayerHeight - nVisibleTilesY;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
SetDrawTarget(backBuff);
|
|
|
//Clear(olc::VERY_DARK_BLUE);
|
|
|
|
|
|
|
|
|
if (nRenderMode == MODE_MAGETZUB)
|
|
|
{
|
|
|
fBackdropScaleX = (float)(sprBackdropMagetzub->width - ScreenWidth()) / (float)((layerWorld.nLayerWidth) + (float)nVisibleTilesX);
|
|
|
fBackdropScaleY = (float)(sprBackdropMagetzub->height - ScreenHeight()) / (float)((layerWorld.nLayerHeight) + (float)nVisibleTilesY);
|
|
|
DrawPartialSprite(0, 0, sprBackdropMagetzub, fOffsetX * fBackdropScaleX, fOffsetY * fBackdropScaleY, ScreenWidth(), ScreenHeight());
|
|
|
|
|
|
|
|
|
SetPixelMode(olc::Pixel::ALPHA);
|
|
|
olc::TILE::DrawLayer(layerWorld, atlasWorldMagetzub, fOffsetX, fOffsetY, nVisibleTilesX + 1, nVisibleTilesY + 1, 1);
|
|
|
olc::TILE::DrawLayer(layerCollectibles, atlasCollectibles, fOffsetX, fOffsetY, nVisibleTilesX + 1, nVisibleTilesY + 1, 3);
|
|
|
SetPixelMode(olc::Pixel::NORMAL);
|
|
|
}
|
|
|
|
|
|
if (nRenderMode == MODE_HOPSON)
|
|
|
{
|
|
|
fBackdropScaleX = (float)(sprBackdropHopson->width - ScreenWidth()) / (float)((layerWorld.nLayerWidth) + (float)nVisibleTilesX);
|
|
|
fBackdropScaleY = (float)(sprBackdropHopson->height - ScreenHeight()) / (float)((layerWorld.nLayerHeight) + (float)nVisibleTilesY);
|
|
|
DrawPartialSprite(0, 0, sprBackdropHopson, fOffsetX * fBackdropScaleX, fOffsetY * fBackdropScaleY, ScreenWidth(), ScreenHeight());
|
|
|
|
|
|
|
|
|
SetPixelMode(olc::Pixel::ALPHA);
|
|
|
olc::TILE::DrawLayer(layerWorld, atlasWorldHopson, fOffsetX, fOffsetY, nVisibleTilesX + 1, nVisibleTilesY + 1, 1);
|
|
|
olc::TILE::DrawLayer(layerCollectibles, atlasCollectibles, fOffsetX, fOffsetY, nVisibleTilesX + 1, nVisibleTilesY + 1, 3);
|
|
|
SetPixelMode(olc::Pixel::NORMAL);
|
|
|
}
|
|
|
|
|
|
if (nRenderMode == MODE_JAVID)
|
|
|
{
|
|
|
Clear(olc::BLACK);
|
|
|
SetPixelMode(olc::Pixel::ALPHA);
|
|
|
olc::TILE::DrawLayer(layerWorld, atlasWorldJavid, fOffsetX, fOffsetY, nVisibleTilesX + 1, nVisibleTilesY + 1, 1);
|
|
|
|
|
|
olc::TILE::DrawLayer(layerJavid, atlasCollectibles, fOffsetX, fOffsetY, nVisibleTilesX + 1, nVisibleTilesY + 1, 3);
|
|
|
|
|
|
olc::TILE::DrawLayer(layerCollectibles, atlasCollectibles, fOffsetX, fOffsetY, nVisibleTilesX + 1, nVisibleTilesY + 1, 3);
|
|
|
SetPixelMode(olc::Pixel::NORMAL);
|
|
|
}
|
|
|
|
|
|
// Draw Player
|
|
|
|
|
|
olc::GFX2D::Transform2D t;
|
|
|
t.Translate(-220.0f, 174.0f);
|
|
|
t.Scale(fFaceDir * 0.25f, 0.25f);
|
|
|
|
|
|
t.Translate((fPlayerPosX - fOffsetX) * nTileSizeX + 32, (fPlayerPosY - fOffsetY) * nTileSizeY - 48);
|
|
|
|
|
|
SetPixelMode(olc::Pixel::ALPHA);
|
|
|
animPlayer.DrawSelf(this, t);
|
|
|
SetPixelMode(olc::Pixel::NORMAL);
|
|
|
|
|
|
|
|
|
//this_thread::sleep_for(20ms);
|
|
|
|
|
|
string s = "Disks: " + to_string(nFloppyDisks) + "/100\nJx9: " + to_string(nJavidTokens) + " Hop: " + to_string(nHopsonTokens) + "\nKeys: " + to_string(nKeys) + " /4";
|
|
|
|
|
|
|
|
|
|
|
|
DrawString(11, 11, s, olc::BLACK, 2);
|
|
|
DrawString(9, 9, s, olc::YELLOW, 2);
|
|
|
|
|
|
SetPixelBlend(0.5f);
|
|
|
SetPixelMode(olc::Pixel::ALPHA);
|
|
|
DrawSprite(10, ScreenHeight() - (sprMiniMap->height + 4) * 3, sprMiniMap, 3);
|
|
|
SetPixelMode(olc::Pixel::NORMAL);
|
|
|
SetPixelBlend(1.0f);
|
|
|
|
|
|
//Draw(10 + (fNewPlayerPosX / nChallengePathSizeX), ScreenHeight() - sprMiniMap->height - 8 + (fNewPlayerPosY / nChallengePathSizeY), olc::YELLOW);
|
|
|
|
|
|
//DrawString(10, ScreenHeight() - (sprMiniMap->height - 16) * 2, "Map", olc::BLACK, 2);
|
|
|
//DrawString(9, ScreenHeight() - (sprMiniMap->height - 17) * 2, "Map", olc::YELLOW, 2);
|
|
|
|
|
|
// Draw Time Information
|
|
|
int minutes = (int)fGameTime / 60;
|
|
|
int seconds = (int)fGameTime - (minutes * 60);
|
|
|
string sMinutes = (minutes <= 9 ? "0" : "") + to_string(minutes);
|
|
|
string sSeconds = (seconds <= 9 ? "0" : "") + to_string(seconds);
|
|
|
DrawString(ScreenWidth() - 158, 12, sMinutes + ":" + sSeconds, olc::BLACK, 3);
|
|
|
DrawString(ScreenWidth() - 160, 10, sMinutes + ":" + sSeconds, olc::YELLOW, 3);
|
|
|
|
|
|
if (fGameTimeMultiplier != 1.0f)
|
|
|
{
|
|
|
DrawString(ScreenWidth() - 158, 50, "x0.75", olc::BLACK, 4);
|
|
|
DrawString(ScreenWidth() - 160, 53, "x0.75", olc::YELLOW, 4);
|
|
|
}
|
|
|
|
|
|
SetDrawTarget(nullptr);
|
|
|
|
|
|
|
|
|
// UglySwedishFisk Mode
|
|
|
if (nRenderEffect == EFFECT_UGLYSWEDISHFISH)
|
|
|
{
|
|
|
int sparkles = 100 / fElapsedTime;
|
|
|
for (int i = 0; i < sparkles; i++)
|
|
|
{
|
|
|
int x = rand() % ScreenWidth();
|
|
|
int y = rand() % ScreenHeight();
|
|
|
Draw(x, y, backBuff->GetPixel(x, y));
|
|
|
}
|
|
|
}
|
|
|
|
|
|
if (nRenderEffect == EFFECT_GORBIT)
|
|
|
{
|
|
|
int sparkles = 10 / fElapsedTime;
|
|
|
for (int i = 0; i < sparkles; i++)
|
|
|
{
|
|
|
int x = rand() % 32;
|
|
|
int y = rand() % 32;
|
|
|
DrawPartialSprite(x * 32, y * 32, backBuff, x * 32, y * 32, 32, 32);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
|
|
|
if (nRenderEffect == EFFECT_SEDIT)
|
|
|
{
|
|
|
SetPixelMode([](int x, int y, const olc::Pixel &s, const olc::Pixel &d)
|
|
|
{
|
|
|
olc::Pixel p = s;
|
|
|
if (y % 2)
|
|
|
{
|
|
|
float c = ((float)s.r * 1.5f + (float)s.g * 1.5f + (float)s.b * 1.5f) / 3.0f;
|
|
|
p.r = c;
|
|
|
p.g = c;
|
|
|
p.b = c;
|
|
|
}
|
|
|
return p;
|
|
|
});
|
|
|
|
|
|
DrawSprite(0, 0, backBuff);
|
|
|
|
|
|
SetPixelMode(olc::Pixel::NORMAL);
|
|
|
}
|
|
|
|
|
|
if (nRenderEffect == EFFECT_BRANK)
|
|
|
{
|
|
|
for (int i = 0; i < 4; i++)
|
|
|
{
|
|
|
int sx = rand() % 2;
|
|
|
int sy = rand() % 2;
|
|
|
int tx = rand() % 2;
|
|
|
int ty = rand() % 2;
|
|
|
DrawPartialSprite(0, 0, backBuff, ScreenWidth()/2,ScreenHeight()/2, ScreenWidth()/2, ScreenHeight()/2);
|
|
|
DrawPartialSprite(ScreenWidth()/2, 0, backBuff, 0, ScreenHeight() / 2, ScreenWidth() / 2, ScreenHeight() / 2);
|
|
|
DrawPartialSprite( 0,ScreenHeight()/2, backBuff, ScreenWidth()/2, 0, ScreenWidth() / 2, ScreenHeight() / 2);
|
|
|
DrawPartialSprite(ScreenWidth() / 2, ScreenHeight()/2, backBuff, 0, 0, ScreenWidth() / 2, ScreenHeight() / 2);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// No effect mode
|
|
|
if (nRenderEffect == EFFECT_NONE)
|
|
|
DrawSprite(0, 0, backBuff);
|
|
|
|
|
|
string sHelper = "";
|
|
|
if (nRenderEffect == EFFECT_UGLYSWEDISHFISH)
|
|
|
sHelper = "UGLYSWEDISHFISH Is Patching Your Code!\nHonestly, It's better like this...";
|
|
|
if (nRenderEffect == EFFECT_GORBIT)
|
|
|
sHelper = "GORBIT Is Patching Your Code!\nLook how beautiful my gifs are...";
|
|
|
if (nRenderEffect == EFFECT_SEDIT)
|
|
|
sHelper = "SEDIT Is Patching Your Code!\nI'm only going to change one little thing... oh.";
|
|
|
if (nRenderEffect == EFFECT_BRANK)
|
|
|
sHelper = "BRANKEC Is Patching Your Code!\nNow it'll be at least 7623 FPS...";
|
|
|
|
|
|
DrawString(ScreenWidth() - 338, ScreenHeight() - 22, sHelper, olc::BLACK);
|
|
|
DrawString(ScreenWidth() - 339, ScreenHeight() - 23, sHelper, olc::YELLOW);
|
|
|
return true;
|
|
|
}
|
|
|
|
|
|
bool GameState_Complete(float fElapsedTime)
|
|
|
{
|
|
|
|
|
|
controller.Update(fElapsedTime);
|
|
|
DrawSprite(0, 0, sprCompleteScreen);
|
|
|
|
|
|
DrawString(4, 10, "YOU SAVED SEDIT!", olc::YELLOW, 4);
|
|
|
|
|
|
int minutes = (int)fGameTime / 60;
|
|
|
int seconds = (int)fGameTime - (minutes * 60);
|
|
|
string sMinutes = (minutes <= 9 ? "0" : "") + to_string(minutes);
|
|
|
string sSeconds = (seconds <= 9 ? "0" : "") + to_string(seconds);
|
|
|
string sTime = "Your Time: " + sMinutes + ":" + sSeconds;
|
|
|
DrawString(10, 200, sTime, olc::YELLOW, 2);
|
|
|
DrawString(10, 240, "OS Disks Found: " + to_string(nFloppyDisks) + "/100", olc::YELLOW, 2);
|
|
|
DrawString(10, 260, "Level: " + to_string(nLevelSeed) + " Size: " + to_string((int)pow(2,2+nLevelSize)), olc::YELLOW, 2);
|
|
|
DrawString(10, 300, "Jump to Title Screen?", olc::YELLOW, 2);
|
|
|
|
|
|
if (GetKey(olc::Key::SPACE).bPressed || controller.GetButton(A).bPressed)
|
|
|
{
|
|
|
nGameState = GS_TITLE;
|
|
|
}
|
|
|
|
|
|
return true;
|
|
|
}
|
|
|
|
|
|
int nStoryStage = 0;
|
|
|
|
|
|
bool GameState_Story(float fElapsedTime)
|
|
|
{
|
|
|
controller.Update(fElapsedTime);
|
|
|
|
|
|
if(nStoryStage == 0)
|
|
|
DrawSprite(0, 0, sprStoryScreen);
|
|
|
else
|
|
|
DrawSprite(0, 0, sprControlScreen);
|
|
|
|
|
|
if (GetKey(olc::Key::SPACE).bPressed || controller.GetButton(A).bPressed)
|
|
|
{
|
|
|
nStoryStage++;
|
|
|
if (nStoryStage == 2)
|
|
|
{
|
|
|
nGameState = GS_TITLE;
|
|
|
nStoryStage = 0;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
return true;
|
|
|
}
|
|
|
|
|
|
bool GameState_Credits(float fElapsedTime)
|
|
|
{
|
|
|
controller.Update(fElapsedTime);
|
|
|
DrawSprite(0, 0, sprCreditScreen);
|
|
|
if (GetKey(olc::Key::SPACE).bPressed || controller.GetButton(A).bPressed)
|
|
|
{
|
|
|
nGameState = GS_TITLE;
|
|
|
}
|
|
|
return true;
|
|
|
}
|
|
|
|
|
|
bool OnUserUpdate(float fElapsedTime) override
|
|
|
{
|
|
|
|
|
|
switch (nGameState)
|
|
|
{
|
|
|
case GS_LOADING: GameState_Loading(fElapsedTime); break;
|
|
|
case GS_TITLE: GameState_Title(fElapsedTime); break;
|
|
|
case GS_GENERATE: GameState_Generating(fElapsedTime); break;
|
|
|
case GS_MAIN: GameState_Main(fElapsedTime); break;
|
|
|
case GS_STORY: GameState_Story(fElapsedTime); break;
|
|
|
case GS_CREDITS: GameState_Credits(fElapsedTime); break;
|
|
|
case GS_COMPLETE: GameState_Complete(fElapsedTime); break;
|
|
|
}
|
|
|
|
|
|
return true;
|
|
|
}
|
|
|
};
|
|
|
|
|
|
int main()
|
|
|
{
|
|
|
Discovery demo;
|
|
|
if (demo.Construct(512, 448, 2, 2))
|
|
|
demo.Start();
|
|
|
return 0;
|
|
|
}
|
|
|
|
