salmon-engine-projects/double-hit-balls
14
0 Fork 0
Code Issues 1 Pull Requests Projects Releases Wiki Activity

preparing

Browse Source
This commit is contained in:
Vladislav Khorev Dev committed 2017-12-19 16:28:16 +05:00
1 parent 7f5aea5047
commit 9096f79f5a
83 files changed
+21 -3278
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

game/creditscode.cpp
-83
View File
@@ -1,83 +0,0 @@
#include "creditscode.h"
#include "include/Engine.h"
#include "main_code.h"
const int TGameCredits::CONST_STATE_APPEARING = 0;
const int TGameCredits::CONST_STATE_APPEARED = 1;
const int TGameCredits::CONST_STATE_DISAPPEARING = 2;
const int TGameCredits::CONST_STATE_DISAPPEARED = 3;
const float TGameCredits::CONST_APPEAR_TIME = 150.f;
TGameCredits::TGameCredits()
: TGameAreaAncestor()
, StateTimer(0)
, State(CONST_STATE_DISAPPEARED)
{
}
void TGameCredits::Draw()
{
//*SE::Console << "TGameCredits::Draw";
float transparency = StateTimer/CONST_APPEAR_TIME;
RenderUniform1f("Transparency", transparency);
glBindTexture(GL_TEXTURE_2D,ResourceManager->TexList["main_menu_bkg_left"]);
Renderer->DrawRect(Vector2f(0, 0.f), Vector2f(480.f, 320.f));
const Vector2f creditsPos(140.f, 130.f);
const Vector2f creditsHalfSize(128.f, 128.f);
glBindTexture(GL_TEXTURE_2D,ResourceManager->TexList[CONST_CREDITS_TEXTURE]);
Renderer->DrawRect(creditsPos-creditsHalfSize, creditsPos+creditsHalfSize);
glBindTexture(GL_TEXTURE_2D,ResourceManager->TexList[CONST_LOGO_SMALL_TEXTURE]);
Renderer->DrawRect(Vector2f(240.f-128.f+15.f, 320.f-64.f), Vector2f(240.f+128.f+15.f, 320.f));
CheckGlError("Draw TGameCredits");
}
void TGameCredits::Update(size_t dt)
{
if (State == CONST_STATE_APPEARING)
{
*SE::Console << "TGameCredits::Update - CONST_STATE_APPEARING";
StateTimer += dt;
if (StateTimer >= CONST_APPEAR_TIME)
{
StateTimer = CONST_APPEAR_TIME;
State = CONST_STATE_APPEARED;
}
}
else if (State == CONST_STATE_DISAPPEARING)
{
StateTimer -= dt;
if (StateTimer <= 0.f)
{
StateTimer = 0.f;
State = CONST_STATE_DISAPPEARED;
}
}
}
void TGameCredits::OnTapDown(Vector2f p)
{
*SE::Console << "TGameCredits::OnTapDown";
Application->GoFromCreditsToMenu();
}
void TGameCredits::StartAppear()
{
*SE::Console << "TGameCredits::StartAppear";
State = CONST_STATE_APPEARING;
}
void TGameCredits::StartDisappear()
{
*SE::Console << "TGameCredits::StartDisappear";
State = CONST_STATE_DISAPPEARING;
}
game/creditscode.h
-34
View File
@@ -1,34 +0,0 @@
#ifndef CREDITSCODE_H_INCLUDED
#define CREDITSCODE_H_INCLUDED
#include "game_area_interface.h"
using namespace SE;
class TGameCredits : public TGameAreaAncestor
{
static const int CONST_STATE_APPEARING;
static const int CONST_STATE_APPEARED;
static const int CONST_STATE_DISAPPEARING;
static const int CONST_STATE_DISAPPEARED;
static const float CONST_APPEAR_TIME;
int State;
float StateTimer;
public:
TGameCredits();
virtual void Draw();
virtual void Update(size_t dt);
virtual void OnTapDown(Vector2f p);
void StartAppear();
void StartDisappear();
};
#endif
game/game_area_interface.h
-25
View File
@@ -1,25 +0,0 @@
#ifndef GAME_AREA_INTERFACE_H_INCLUDED
#define GAME_AREA_INTERFACE_H_INCLUDED
#include "include/Engine.h"
using namespace SE;
class TGameAreaAncestor
{
public:
virtual void Draw() { }
virtual void Update(size_t) { }
virtual void OnTapUp(Vector2f) { }
virtual void OnTapUpAfterMove(Vector2f) { }
virtual void OnTapDown(Vector2f) { }
virtual void OnFling(Vector2f) { }
virtual void OnScroll(Vector2f) { }
virtual ~TGameAreaAncestor() { } //By default destructor is not virtual
};
#endif
game/gamecode.cpp
-1628
View File
File diff suppressed because it is too large. Load diff
game/gamecode.h
-205
View File
@@ -1,205 +0,0 @@
#ifndef GAMECODE_H_INCLUDED
#define GAMECODE_H_INCLUDED
#include "include/Engine.h"
#include "game_area_interface.h"
#include <list>
using namespace SE;
const int CONST_BRICKSTATE_VISIBLE = 3;
const int CONST_BRICKSTATE_DISAPPEAR = 2;
const int CONST_BRICKSTATE_INVISIBLE = 1;
const int CONST_BRICKSTATE_APPEAR = 0;
const float CONST_BRICK_DISAPPEAR_TIME = 200.f;
const float CONST_BRICK_APPEAR_TIME = 200.f;
const int CONST_BRICKMATRIX_WIDTH = 12;
const int CONST_BRICKMATRIX_HEIGHT = 13;
const float CONST_BRICK_WIDTH = 37.5f;
const float CONST_BRICK_HEIGHT = 0.5f*CONST_BRICK_WIDTH;
const float CONST_BRICK_SHIFT_X = 15.f;
const float CONST_BRICK_SHIFT_Y = -16.f;
const float CONST_BONUS_APPEAR_TIME = 400.f;
const float CONST_BONUS_FALL_SPEED = 100.f;
const float CONST_BONUS_GOTHROUGH_TIME = 8000.f;
const float CONST_BONUS_CATCH_DISTANCE_X = 65.f;
const float CONST_BONUS_CATCH_DISTANCE_Y = 20.f;
const float CONST_BONUS_FLOOR_TIME = 8000.f;
const float CONST_BONUS_FLOOR_APPEAR_SPEED = 50.f;
const int CONST_BONUS_TYPE_MULTIPLIER = 0;
const int CONST_BONUS_TYPE_GOTHROUGH = 1;
const int CONST_BONUS_TYPE_FLOOR = 2;
class TBrick
{
protected:
int InitialLocked;
int Locked; //0, 1 or 2
int State;
float StateTimer;
Vector4f Color;
public:
TBrick();
void SetVisible(Vector4f color, int locked);
void SetInvisible();
void TryDrawAppear(int ipos, int jpos);
void Update(size_t dt);
Vector2f GetPosFrom(int ipos, int jpos);
Vector4f GetColor();
void Appear(Vector4f color, int locked);
void Appear();
void Hit();
void Disappear();
int GetLocked();
bool CanReact();
};
class TBonusFalling
{
protected:
float Lifetime;
Vector2f Pos;
std::string TexName;
int BonusType; //0 - multiplier, 1 - Go-through, 2 - floor
public:
TBonusFalling(Vector2f pos);
Vector2f GetPos();
int GetType();
void Draw();
void Update(size_t dt);
};
struct TBall
{
Vector2f Pos;
Vector2f Velocity;
Vector4f Color;
std::list<Vector2f> TalePos;
Vector2f BallInBlock;
Vector2f PrevBallInBlock;
TBall(Vector2f pos, Vector2f velocity, Vector4f color);
Vector2f GetPos();
Vector2f GetVelocityVector();
void Go();
void ReflectToLeft();
void ReflectToRight();
void ReflectToUp();
void ReflectToDown();
void TryReflectOnReflector(Vector2f refPos);
void Update(size_t dt);
};
typedef std::pair<Vector4f, std::string> PairColorTexture;
struct TBlockInstansingList
{
//color-texture ---> and list of triangles for this color
std::list<std::pair<PairColorTexture, TTriangleList>> ColorBlockList;
};
struct TBallInstancingList
{
std::map<int, TTriangleList> BallAndGlowList;
};
class TGameLevel : public TGameAreaAncestor
{
protected:
std::string BkgTexture;
std::string LevelScreenTexture;
std::string LevelFileName;
Vector2f ReflectorPos;
int LevelState;
bool PrevLevelStateIsStandby;
float StateTimer;
TBrick BlockMatrix[CONST_BRICKMATRIX_WIDTH][CONST_BRICKMATRIX_HEIGHT];
TBlockInstansingList BlockInstansingList;
bool TapInBackBtnArea(const Vector2f& pos);
void ReloadBlockInstansingList();
void SetFinished();
void SetFinishFreeze();
void DrawBuffer();
void DrawPauseButtons();
void DrawBallInstancingList();
bool RenderBufferReady;
float OutScale;
float OutScaleVelocity;
void TryGoToMenu();
std::list<TBonusFalling> BonusFallingList;
std::list<TBall> BallList;
TBallInstancingList BallInstancingList;
Vector4f BallColor;
void ReloadBallInstancingList();
void RefreshBallInstancingList();
void UpdateBallList(size_t dt);
void MultiplyBalls(Vector2f pos, Vector2f velocity);
Vector2f GetBlock(const Vector2f& pos);
void InitLevel();
float BonusGothroughTimer;
float BonusFloorTimer;
float BonusFloorPosY;
Vector4f ParseColor(const std::string& s);
void ReloadLevel();
public:
TGameLevel();
~TGameLevel();
void FillWithFile(const std::string& filename);
void SetStandBy();
void SetLoading(const std::string& bkg, const std::string& levelscreen);
bool IsLoaded();
virtual void Draw();
void SetPause();
bool IsPaused();
void ReleasePause();
virtual void Update(size_t dt);
virtual void OnTapDown(Vector2f pos);
virtual void OnTapUp(Vector2f pos);
virtual void OnFling(Vector2f slideSpeed);
virtual void OnScroll(Vector2f shift);
};
#endif
game/loadingcode.cpp
-20
View File
@@ -1,20 +0,0 @@
#include "loadingcode.h"
#include "include/Engine.h"
#include "main_code.h"
void TGameLoading::Draw()
{
//*SE::Console << "TGameLoading::Draw";
glBindTexture(GL_TEXTURE_2D, ResourceManager->TexList[CONST_LOADING_BACKGROUND_BLACK]);
Renderer->DrawRect(Vector2f(0.f, 0.f), Vector2f(Renderer->GetMatrixWidth(), Renderer->GetMatrixHeight()));
glBindTexture(GL_TEXTURE_2D,ResourceManager->TexList[CONST_LOADING_TEXTURE]);
Renderer->DrawRect(Vector2f(240.f - 128.f, 10.f), Vector2f(240.f + 128.f, 10.f + 64.f));
glBindTexture(GL_TEXTURE_2D,ResourceManager->TexList[CONST_LOGO_SMALL_TEXTURE]);
Renderer->DrawRect(Vector2f(480.f - 256.f+50.f, 320.f - 64.f), Vector2f(480.f+50.f, 320.f));
CheckGlError();
}
game/loadingcode.h
-15
View File
@@ -1,15 +0,0 @@
#ifndef LOADINGCODE_H_INCLUDED
#define LOADINGCODE_H_INCLUDED
#include "game_area_interface.h"
using namespace SE;
class TGameLoading : public TGameAreaAncestor
{
public:
virtual void Draw();
};
#endif
game/main_code.cpp
+5 -420
View File
@@ -7,47 +7,6 @@
#include "include/Engine.h"
#include "menucode.h"
#include "main_code.h"
boost::signals2::signal<void (Vector2f)> OnTapUpSignal;
boost::signals2::signal<void (Vector2f)> OnTapUpAfterMoveSignal;
boost::signals2::signal<void (Vector2f)> OnTapDownSignal;
boost::signals2::signal<void (Vector2f)> OnFlingSignal;
boost::signals2::signal<void (Vector2f)> OnScrollSignal;
boost::signals2::signal<void ()> OnDrawSignal;
const std::string CONST_BLOCK_TEXTURE1 = "block1";
const std::string CONST_BLOCK_TEXTURE2 = "block2";
const std::string CONST_BLOCK_TEXTURE3 = "block3";
const std::string CONST_BONUS_GOTHROUGH_TEXTURE = "bonus_gothrough";
const std::string CONST_BONUS_MULTIPLIER_TEXTURE = "bonus_multiplier";
const std::string CONST_BONUS_FLOOR_TEXTURE = "bonus_floor";
const std::string CONST_BALL_TEXTURE = "ball";
const std::string CONST_BALLGLOW_TEXTURE = "ball_glow";
const std::string CONST_REFLECTOR_TEXTURE = "reflector";
const std::string CONST_WALL_LEFT_TEXTURE = "wall_left";
const std::string CONST_WALL_RIGHT_TEXTURE = "wall_right";
const std::string CONST_WALL_UP_TEXTURE = "wall_up";
const std::string CONST_WALL_BONUS_TEXTURE = "wall_bonus";
const std::string CONST_BACK_BTN_TEXTURE = "back_btn";
const std::string CONST_SLIDE_UP_BTN_TEXTURE = "slide_up_btn";
const std::string CONST_TAP_TO_CONTINUE_BTN_TEXTURE = "tap_to_continue_btn";
const std::string CONST_LOADING_TEXTURE = "loading";
const std::string CONST_LOGO_SMALL_TEXTURE = "logo_small";
const std::string CONST_LOADING_BACKGROUND_BLACK = "loading_background_black";
const std::string CONST_CREDITS_TEXTURE = "credits";
const float CONST_CREDITS_SHOW_TIME = 150.f;
TMyApplication* Application;
@@ -73,421 +32,47 @@ void TMyApplication::InnerInit()
*Console<<"APP INIT\n";
}
srand (static_cast<size_t>(time(NULL)));
GameState = CONST_GAMESTATE_PRELOADING;
StateTimer = 0.f;
ResourceManager->ShaderManager.AddShader("DefaultShader", "shader1vertex.txt", "shader1fragment.txt");
ResourceManager->ShaderManager.AddShader("FrameShader", "frameshader_vertex.txt", "frameshader_fragment.txt");
ResourceManager->ShaderManager.AddShader("BrickShader", "brickshader_vertex.txt", "brickshader_fragment.txt");
ResourceManager->ShaderManager.AddShader("DefaultShader", "texture-shader.vertex", "texture-shader.fragment");
Renderer->PushShader("DefaultShader");
ResourceManager->TexList.AddTexture(CONST_LOADING_BACKGROUND_BLACK + ".png", CONST_LOADING_BACKGROUND_BLACK);
ResourceManager->TexList.AddTexture(CONST_LOADING_TEXTURE + ".png", CONST_LOADING_TEXTURE);
ResourceManager->TexList.AddTexture(CONST_LOGO_SMALL_TEXTURE + ".png", CONST_LOGO_SMALL_TEXTURE);
ResourceManager->TexList.AddTexture("console_bkg.bmp");
ResourceManager->FrameManager.AddFrameRenderBuffer("LevelBuffer", 512, 512);
OnDrawSignal.connect(boost::bind(&TGameLoading::Draw, boost::ref(GameLoading)));
Inited = true;
ResourceManager->FrameManager.AddFrameRenderBuffer("FrameBuffer", Renderer->GetMatrixWidth(), Renderer->GetMatrixHeight());
Renderer->SetOrthoProjection();
Renderer->SetFullScreenViewport();
}
void TMyApplication::InnerDeinit()
{
Inited = false;
Loaded = false;
if (Console != NULL)
{
*Console<<"APP DEINIT\n";
}
OnTapUpSignal.disconnect(boost::bind(&TGameLevel::OnTapUp, boost::ref(GameLevel), _1));
OnTapUpSignal.disconnect(boost::bind(&TGameMenu::OnTapUp, boost::ref(Menu), _1));
OnTapUpAfterMoveSignal.disconnect(boost::bind(&TGameMenu::OnTapUpAfterMove, boost::ref(Menu), _1));
OnFlingSignal.disconnect(boost::bind(&TGameLevel::OnFling, boost::ref(GameLevel), _1));
OnFlingSignal.disconnect(boost::bind(&TGameMenu::OnFling, boost::ref(Menu), _1));
OnScrollSignal.disconnect(boost::bind(&TGameLevel::OnScroll, boost::ref(GameLevel), _1));
OnScrollSignal.disconnect(boost::bind(&TGameMenu::OnScroll, boost::ref(Menu), _1));
OnTapDownSignal.disconnect(boost::bind(&TGameLevel::OnTapDown, boost::ref(GameLevel), _1));
OnTapDownSignal.disconnect(boost::bind(&TGameMenu::OnTapDown, boost::ref(Menu), _1));
OnTapDownSignal.disconnect(boost::bind(&TGameCredits::OnTapDown, boost::ref(GameCredits), _1));
OnDrawSignal.disconnect(boost::bind(&TGameLoading::Draw, boost::ref(GameLoading)));
OnDrawSignal.disconnect(boost::bind(&TGameMenu::Draw, boost::ref(Menu)));
OnDrawSignal.disconnect(boost::bind(&TGameLevel::Draw, boost::ref(GameLevel)));
OnDrawSignal.disconnect(boost::bind(&TGameCredits::Draw, boost::ref(GameCredits)));
}
void TMyApplication::InnerOnTapDown(Vector2f p)
{
//-OnTapDownSignal(Vector2f(p.v[0], p.v[1]));
OnTapDownSignal(Vector2f(p(0), p(1)));
}
void TMyApplication::InnerOnTapUp(Vector2f p)
{
OnTapUpSignal(Vector2f(p(0), p(1)));
}
void TMyApplication::InnerOnTapUpAfterMove(Vector2f p)
{
OnTapUpAfterMoveSignal(Vector2f(p(0), p(1)));
}
void TMyApplication::InnerOnMove(Vector2f p, Vector2f shift)
{
OnScrollSignal(Vector2f(shift(0), shift(1)));
}
void TMyApplication::OnFling(Vector2f v)
{
}
void TMyApplication::ApplySignalsToMenu()
{
OnTapUpSignal.connect(boost::bind(&TGameMenu::OnTapUp, boost::ref(Menu), _1));
OnTapUpAfterMoveSignal.connect(boost::bind(&TGameMenu::OnTapUpAfterMove, boost::ref(Menu), _1));
OnFlingSignal.connect(boost::bind(&TGameMenu::OnFling, boost::ref(Menu), _1));
OnScrollSignal.connect(boost::bind(&TGameMenu::OnScroll, boost::ref(Menu), _1));
OnTapDownSignal.connect(boost::bind(&TGameMenu::OnTapDown, boost::ref(Menu), _1));
}
void TMyApplication::DisapplySignalsToMenu()
{
OnTapUpSignal.disconnect(boost::bind(&TGameMenu::OnTapUp, boost::ref(Menu), _1));
OnTapUpAfterMoveSignal.disconnect(boost::bind(&TGameMenu::OnTapUpAfterMove, boost::ref(Menu), _1));
OnFlingSignal.disconnect(boost::bind(&TGameMenu::OnFling, boost::ref(Menu), _1));
OnScrollSignal.disconnect(boost::bind(&TGameMenu::OnScroll, boost::ref(Menu), _1));
OnTapDownSignal.disconnect(boost::bind(&TGameMenu::OnTapDown, boost::ref(Menu), _1));
}
void TMyApplication::ApplySignalsToGame()
{
OnTapUpSignal.connect(boost::bind(&TGameLevel::OnTapUp, boost::ref(GameLevel), _1));
OnFlingSignal.connect(boost::bind(&TGameLevel::OnFling, boost::ref(GameLevel), _1));
OnScrollSignal.connect(boost::bind(&TGameLevel::OnScroll, boost::ref(GameLevel), _1));
OnTapDownSignal.connect(boost::bind(&TGameLevel::OnTapDown, boost::ref(GameLevel), _1));
}
void TMyApplication::DisapplySignalsToGame()
{
OnTapUpSignal.disconnect(boost::bind(&TGameLevel::OnTapUp, boost::ref(GameLevel), _1));
OnFlingSignal.disconnect(boost::bind(&TGameLevel::OnFling, boost::ref(GameLevel), _1));
OnScrollSignal.disconnect(boost::bind(&TGameLevel::OnScroll, boost::ref(GameLevel), _1));
OnTapDownSignal.disconnect(boost::bind(&TGameLevel::OnTapDown, boost::ref(GameLevel), _1));
}
void TMyApplication::ApplySignalsToCredits()
{
OnTapDownSignal.connect(boost::bind(&TGameCredits::OnTapDown, boost::ref(GameCredits), _1));
}
void TMyApplication::DisapplySignalsToCredits()
{
OnTapDownSignal.disconnect(boost::bind(&TGameCredits::OnTapDown, boost::ref(GameCredits), _1));
}
void TMyApplication::LoadResources()
{
TextureNamesToLoad.clear();
TextureNamesToLoad.push_back(std::pair<std::string, std::string>("main_menu_bkg_left.png", "main_menu_bkg_left"));
TextureNamesToLoad.push_back(std::pair<std::string, std::string>("main_menu_bkg_right.png", "main_menu_bkg_right"));
TextureNamesToLoad.push_back(std::pair<std::string, std::string>("select_level.png", "select_level"));
TextureNamesToLoad.push_back(std::pair<std::string, std::string>("shutterstock1.png", "shutterstock1"));
TextureNamesToLoad.push_back(std::pair<std::string, std::string>("shutterstock2.png", "shutterstock2"));
TextureNamesToLoad.push_back(std::pair<std::string, std::string>("shutterstock3.png", "shutterstock3"));
TextureNamesToLoad.push_back(std::pair<std::string, std::string>("shutterstock4.png", "shutterstock4"));
TextureNamesToLoad.push_back(std::pair<std::string, std::string>("shutterstock5.png", "shutterstock5"));
TextureNamesToLoad.push_back(std::pair<std::string, std::string>("shutterstock6.png", "shutterstock6"));
TextureNamesToLoad.push_back(std::pair<std::string, std::string>("shutterstock7.png", "shutterstock7"));
TextureNamesToLoad.push_back(std::pair<std::string, std::string>("shutterstock8.png", "shutterstock8"));
TextureNamesToLoad.push_back(std::pair<std::string, std::string>("shutterstock9.png", "shutterstock9"));
TextureNamesToLoad.push_back(std::pair<std::string, std::string>("shutterstock10.png", "shutterstock10"));
TextureNamesToLoad.push_back(std::pair<std::string, std::string>("shutterstock11.png", "shutterstock11"));
TextureNamesToLoad.push_back(std::pair<std::string, std::string>("shutterstock12.png", "shutterstock12"));
TextureNamesToLoad.push_back(std::pair<std::string, std::string>("levelshot1.png", "levelshot1"));
TextureNamesToLoad.push_back(std::pair<std::string, std::string>("levelshot2.png", "levelshot2"));
TextureNamesToLoad.push_back(std::pair<std::string, std::string>("levelshot3.png", "levelshot3"));
TextureNamesToLoad.push_back(std::pair<std::string, std::string>("levelshot4.png", "levelshot4"));
TextureNamesToLoad.push_back(std::pair<std::string, std::string>("levelshot5.png", "levelshot5"));
TextureNamesToLoad.push_back(std::pair<std::string, std::string>("levelshot6.png", "levelshot6"));
TextureNamesToLoad.push_back(std::pair<std::string, std::string>("levelshot7.png", "levelshot7"));
TextureNamesToLoad.push_back(std::pair<std::string, std::string>("levelshot8.png", "levelshot8"));
TextureNamesToLoad.push_back(std::pair<std::string, std::string>("levelshot9.png", "levelshot9"));
TextureNamesToLoad.push_back(std::pair<std::string, std::string>("levelshot10.png", "levelshot10"));
TextureNamesToLoad.push_back(std::pair<std::string, std::string>("levelshot11.png", "levelshot11"));
TextureNamesToLoad.push_back(std::pair<std::string, std::string>("levelshot12.png", "levelshot12"));
TextureNamesToLoad.push_back(std::pair<std::string, std::string>("game_end.png", "game_end"));
TextureNamesToLoad.push_back(std::pair<std::string, std::string>(CONST_BLOCK_TEXTURE1 + ".png", CONST_BLOCK_TEXTURE1));
TextureNamesToLoad.push_back(std::pair<std::string, std::string>(CONST_BLOCK_TEXTURE2 + ".png", CONST_BLOCK_TEXTURE2));
TextureNamesToLoad.push_back(std::pair<std::string, std::string>(CONST_BLOCK_TEXTURE3 + ".png", CONST_BLOCK_TEXTURE3));
TextureNamesToLoad.push_back(std::pair<std::string, std::string>(CONST_BONUS_GOTHROUGH_TEXTURE + ".png", CONST_BONUS_GOTHROUGH_TEXTURE));
TextureNamesToLoad.push_back(std::pair<std::string, std::string>(CONST_BONUS_MULTIPLIER_TEXTURE + ".png", CONST_BONUS_MULTIPLIER_TEXTURE));
TextureNamesToLoad.push_back(std::pair<std::string, std::string>(CONST_BONUS_FLOOR_TEXTURE + ".png", CONST_BONUS_FLOOR_TEXTURE));
TextureNamesToLoad.push_back(std::pair<std::string, std::string>(CONST_BALL_TEXTURE + ".png", CONST_BALL_TEXTURE));
TextureNamesToLoad.push_back(std::pair<std::string, std::string>(CONST_BALLGLOW_TEXTURE + ".png", CONST_BALLGLOW_TEXTURE));
TextureNamesToLoad.push_back(std::pair<std::string, std::string>(CONST_WALL_LEFT_TEXTURE + ".png", CONST_WALL_LEFT_TEXTURE));
TextureNamesToLoad.push_back(std::pair<std::string, std::string>(CONST_WALL_RIGHT_TEXTURE + ".png", CONST_WALL_RIGHT_TEXTURE));
TextureNamesToLoad.push_back(std::pair<std::string, std::string>(CONST_WALL_UP_TEXTURE + ".png", CONST_WALL_UP_TEXTURE));
TextureNamesToLoad.push_back(std::pair<std::string, std::string>(CONST_WALL_BONUS_TEXTURE + ".png", CONST_WALL_BONUS_TEXTURE));
TextureNamesToLoad.push_back(std::pair<std::string, std::string>(CONST_REFLECTOR_TEXTURE + ".png", CONST_REFLECTOR_TEXTURE));
TextureNamesToLoad.push_back(std::pair<std::string, std::string>(CONST_BACK_BTN_TEXTURE + ".png", CONST_BACK_BTN_TEXTURE));
TextureNamesToLoad.push_back(std::pair<std::string, std::string>(CONST_SLIDE_UP_BTN_TEXTURE + ".png", CONST_SLIDE_UP_BTN_TEXTURE));
TextureNamesToLoad.push_back(std::pair<std::string, std::string>(CONST_TAP_TO_CONTINUE_BTN_TEXTURE + ".png", CONST_TAP_TO_CONTINUE_BTN_TEXTURE));
TextureNamesToLoad.push_back(std::pair<std::string, std::string>(CONST_CREDITS_TEXTURE + ".png", CONST_CREDITS_TEXTURE));
#ifdef TARGET_IOS
ResourceManager->SoundManager.LoadMusicLooped("level1ogg.ogg");
#else
//ResourceManager->SoundManager.LoadMusic("level1ogg.ogg");
#endif
ResourceManager->FontManager.AddFont("droid_sans14", "droid_sans14_font_bitmap.png", "droid_sans14_font_charmap.txt");
ResourceManager->FontManager.PushFont("droid_sans14");
TryLoadSavedGame();
}
void TMyApplication::TryLoadSavedGame()
{
std::string fileName = GetFilePathUserData("progress.txt");
FILE* file = fopen(fileName.c_str(), "r");
if (file != NULL)
{
char line[100];
char* r;
r = fgets(line, 100, file);
if (r != NULL)
{
Menu.SetMenuItemCount(toint(r));
}
fclose(file);
}
}
void TMyApplication::TrySaveGame()
{
std::string fileName = GetFilePathUserData("progress.txt");
std::string s = tostr(Menu.GetMenuItemCount());
FILE* file = fopen(fileName.c_str(), "w");
if (file != NULL)
{
fputs(s.c_str(), file);
fflush(file);
fclose(file);
}
}
void TMyApplication::InnerDraw()
{
glDisable(GL_DEPTH_TEST);
glClearColor(0, 0, 0, 0);
glClear(GL_COLOR_BUFFER_BIT);
OnDrawSignal();
}
void TMyApplication::InnerUpdate(size_t dt)
{
if (GameState == CONST_GAMESTATE_PRELOADING)
{
*SE::Console << "1CONST_GAMESTATE_PRELOADING";
StateTimer += dt/1000.f;
if (StateTimer >= 1.f)
{
LoadResources();
GameState = CONST_GAMESTATE_LOADING;
StateTimer = 0.f;
}
}
else if (GameState == CONST_GAMESTATE_LOADING)
{
*SE::Console << "2CONST_GAMESTATE_LOADING";
StateTimer += dt/1000.f;
if (StateTimer >= 1.f)
{
StateTimer -= 1.f;
}
if (TextureNamesToLoad.size() != 0)
{
ResourceManager->TexList.AddTexture(TextureNamesToLoad.begin()->first, TextureNamesToLoad.begin()->second);
TextureNamesToLoad.erase(TextureNamesToLoad.begin());
}
else
{
GameState = CONST_GAMESTATE_MENU;
ApplySignalsToMenu();
OnDrawSignal.disconnect(boost::bind(&TGameLoading::Draw, boost::ref(GameLoading)));
OnDrawSignal.connect(0, boost::bind(&TGameMenu::Draw, boost::ref(Menu)));
StateTimer = 0.f;
Loaded = true;
}
}
else if (GameState == CONST_GAMESTATE_LEVEL)
{
*SE::Console << "3CONST_GAMESTATE_LEVEL";
GameLevel.Update(dt);
}
else if (GameState == CONST_GAMESTATE_MENU)
{
//*SE::Console << "4CONST_GAMESTATE_MENU";
Menu.Update(dt);
}
else if (GameState == CONST_GAMESTATE_FROM_MENU_TO_LEVEL)
{
*SE::Console << "5CONST_GAMESTATE_FROM_MENU_TO_LEVEL";
GameLevel.Update(dt);
if (GameLevel.IsLoaded())
{
//*SE::Console << "5CONST_GAMESTATE_FROM_MENU_TO_LEVEL";
GameState = CONST_GAMESTATE_LEVEL;
OnDrawSignal.disconnect(boost::bind(&TGameMenu::Draw, boost::ref(Menu)));
//CONNECT SLOT
DisapplySignalsToMenu();
ApplySignalsToGame();
}
}
else if (GameState == CONST_GAMESTATE_FROM_MENU_TO_CREDITS)
{
*SE::Console << "6CONST_GAMESTATE_FROM_MENU_TO_CREDITS";
Menu.Update(dt);
GameCredits.Update(dt);
StateTimer -= dt;
if (StateTimer <= 0.f)
{
GameState = CONST_GAMESTATE_CREDITS;
OnDrawSignal.disconnect(boost::bind(&TGameMenu::Draw, boost::ref(Menu)));
ApplySignalsToCredits();
StateTimer = 0.f;
}
}
else if (GameState == CONST_GAMESTATE_CREDITS)
{
//*SE::Console << "7CONST_GAMESTATE_CREDITS";
GameCredits.Update(dt);
}
else if (GameState == CONST_GAMESTATE_FROM_CREDITS_TO_MENU)
{
Menu.Update(dt);
GameCredits.Update(dt);
StateTimer -= dt;
if (StateTimer <= 0.f)
{
GameState = CONST_GAMESTATE_MENU;
StateTimer = 0.f;
ApplySignalsToMenu();
OnDrawSignal.disconnect(boost::bind(&TGameCredits::Draw, boost::ref(GameCredits)));
}
}
}
void TMyApplication::GoFromMenuToGame(int level)
{
//#ifndef TARGET_IOS
// ResourceManager->SoundManager.PlayMusicLooped("level1ogg.ogg");
//#endif
GameLevel.FillWithFile(ST::PathToResources + "level"+tostr(level+1)+".txt");
GameLevel.SetLoading("shutterstock" + tostr(level+1), "levelshot"+tostr(level+1));
GameState = CONST_GAMESTATE_FROM_MENU_TO_LEVEL;
OnDrawSignal.connect(1, boost::bind(&TGameLevel::Draw, boost::ref(GameLevel)));
DisapplySignalsToMenu();
}
void TMyApplication::GoFromGameToMenu()
{
//#ifndef TARGET_IOS
// ResourceManager->SoundManager.StopMusic("level1ogg.ogg");
//#endif
TrySaveGame();
DisapplySignalsToGame();
ApplySignalsToMenu();
GameState = CONST_GAMESTATE_MENU;
OnDrawSignal.disconnect(boost::bind(&TGameLevel::Draw, boost::ref(GameLevel)));
}
void TMyApplication::GoFromMenuToCredits()
{
GameState = CONST_GAMESTATE_FROM_MENU_TO_CREDITS;
StateTimer = CONST_CREDITS_SHOW_TIME;
GameCredits.StartAppear();
OnDrawSignal.connect(1, boost::bind(&TGameCredits::Draw, boost::ref(GameCredits)));
DisapplySignalsToMenu();
}
void TMyApplication::GoFromCreditsToMenu()
{
GameState = CONST_GAMESTATE_FROM_CREDITS_TO_MENU;
StateTimer = CONST_CREDITS_SHOW_TIME;
GameCredits.StartDisappear();
OnDrawSignal.connect(0, boost::bind(&TGameMenu::Draw, boost::ref(Menu)));
DisapplySignalsToCredits();
}
void TMyApplication::MarkSetGameLevelPause()
{
OnDrawSignal.connect(0, boost::bind(&TGameMenu::Draw, boost::ref(Menu)));
}
void TMyApplication::MarkReleaseGameLevelPause()
{
OnDrawSignal.disconnect(boost::bind(&TGameMenu::Draw, boost::ref(Menu)));
}
void TMyApplication::OpenNextLevel()
{
Menu.OpenNextLevel();
}
bool TMyApplication::IsLoaded()
{
return Loaded;
}
bool TMyApplication::IsInited()
{
return Inited;
}
}
game/main_code.h
+1 -92
View File
@@ -24,11 +24,6 @@
#include "boost/signals2.hpp"//Signal must be included after asio
#include "gamecode.h"
#include "menucode.h"
#include "creditscode.h"
#include "loadingcode.h"
using namespace SE;
@@ -41,79 +36,11 @@ extern boost::signals2::signal<void(Vector2f)> OnScrollSignal;
extern boost::signals2::signal<void()> OnDrawSignal;
extern const std::string CONST_BLOCK_TEXTURE1;
extern const std::string CONST_BLOCK_TEXTURE2;
extern const std::string CONST_BLOCK_TEXTURE3;
extern const std::string CONST_BONUS_GOTHROUGH_TEXTURE;
extern const std::string CONST_BONUS_MULTIPLIER_TEXTURE;
extern const std::string CONST_BONUS_FLOOR_TEXTURE;
extern const std::string CONST_BALL_TEXTURE;
extern const std::string CONST_BALLGLOW_TEXTURE;
extern const std::string CONST_WALL_LEFT_TEXTURE;
extern const std::string CONST_WALL_RIGHT_TEXTURE;
extern const std::string CONST_WALL_UP_TEXTURE;
extern const std::string CONST_WALL_BONUS_TEXTURE;
extern const std::string CONST_REFLECTOR_TEXTURE;
extern const std::string CONST_BACK_BTN_TEXTURE;
extern const std::string CONST_SLIDE_UP_BTN_TEXTURE;
extern const std::string CONST_TAP_TO_CONTINUE_BTN_TEXTURE;
extern const std::string CONST_BACK_BTN_TEXTURE;
extern const std::string CONST_SLIDE_UP_BTN_TEXTURE;
extern const std::string CONST_TAP_TO_CONTINUE_BTN_TEXTURE;
extern const std::string CONST_LOADING_TEXTURE;
extern const std::string CONST_LOGO_SMALL_TEXTURE;
extern const std::string CONST_LOADING_BACKGROUND_BLACK;
extern const std::string CONST_CREDITS_TEXTURE;
const int CONST_GAMESTATE_LEVEL = 1;
const int CONST_GAMESTATE_MENU = 0;
const int CONST_GAMESTATE_FROM_MENU_TO_LEVEL = 2;
const int CONST_GAMESTATE_FROM_MENU_TO_CREDITS = 3;
const int CONST_GAMESTATE_CREDITS = 4;
const int CONST_GAMESTATE_FROM_CREDITS_TO_MENU = 5;
const int CONST_GAMESTATE_LOADING = 6;
const int CONST_GAMESTATE_PRELOADING = 7;
class TMyApplication : public TApplication
{
protected:
TGameMenu Menu;
TGameLevel GameLevel;
TGameCredits GameCredits;
TGameLoading GameLoading;
int GameState;
float StateTimer;
void TryLoadSavedGame();
void TrySaveGame();
bool Inited;
std::vector<std::pair<std::string, std::string> > TextureNamesToLoad;
void ApplySignalsToMenu();
void DisapplySignalsToMenu();
void ApplySignalsToGame();
void DisapplySignalsToGame();
void ApplySignalsToCredits();
void DisapplySignalsToCredits();
public:
bool Loaded;
TMyApplication() : TApplication(), Loaded(false), Inited(false) { }
TMyApplication() : TApplication() { }
virtual void InnerInit();
@@ -123,21 +50,6 @@ public:
virtual void InnerUpdate(size_t dt);
void GoFromMenuToGame(int level);
void GoFromGameToMenu();
void GoFromMenuToCredits();
void GoFromCreditsToMenu();
void MarkSetGameLevelPause();
void MarkReleaseGameLevelPause();
void OpenNextLevel();
bool IsLoaded();
bool IsInited();
void LoadResources();
virtual void InnerOnTapDown(Vector2f p);
virtual void InnerOnTapUp(Vector2f p);
@@ -146,13 +58,10 @@ public:
virtual void InnerOnMove(Vector2f p, Vector2f shift);
virtual void OnFling(Vector2f v);
};
extern TMyApplication* Application;
#endif
game/menucode.cpp
-220
View File
@@ -1,220 +0,0 @@
#include "menucode.h"
#include "main_code.h"
const float CONST_SPEED_NEG_ACCELERATION_K = 0.03f;
const float CONST_MENU_POS_K = 0.25f;
const float CONST_MENU_WINDOW_DISTANCE = 240.f + 40.f;
const float CONST_SHIFT_ON_SIDE = 0.f;
TGameMenu::TGameMenu()
: MenuSpeed(0)
, MenuPos(0)
, HoldToTap(false)
, MenuItemCount(1)
, SelectedGame(-1)
{
}
void TGameMenu::Draw()
{
// *SE::Console << "TGameMenu::Draw";
CheckGlError("Draw TGameMenu");
RenderUniform1i("sel", 0);
RenderUniform1f("Transparency", 1.f);
float bkgShift = MenuPos*0.1f - 100.f;
glBindTexture(GL_TEXTURE_2D, ResourceManager->TexList["main_menu_bkg_left"]);
Renderer->DrawRect(Vector2f(bkgShift,0.f), Vector2f(480.f+bkgShift,320.f));
glBindTexture(GL_TEXTURE_2D, ResourceManager->TexList["main_menu_bkg_right"]);
Renderer->DrawRect(Vector2f(480.f+bkgShift,0.f), Vector2f(960.f+bkgShift,320.f));
if (SelectedGame == 0)
{
RenderUniform1i("sel", 1);
}
else
{
RenderUniform1i("sel", 0);
}
for (int i=0; i<MenuItemCount; i++)
{
glBindTexture(GL_TEXTURE_2D, ResourceManager->TexList["levelshot"+tostr(i+1)]);
Renderer->DrawRect(Vector2f(160.f+MenuPos+CONST_MENU_WINDOW_DISTANCE*i,80.f), Vector2f(160.f+240.f+MenuPos+CONST_MENU_WINDOW_DISTANCE*i, 240.f));
}
if (MenuItemCount == 12)
{
glBindTexture(GL_TEXTURE_2D, ResourceManager->TexList["game_end"]);
Renderer->DrawRect(Vector2f(160.f+MenuPos+CONST_MENU_WINDOW_DISTANCE*12,160.f - 64.f), Vector2f(160.f+256.f+MenuPos+CONST_MENU_WINDOW_DISTANCE*12, 160.f + 64.f));
}
glBindTexture(GL_TEXTURE_2D, ResourceManager->TexList["select_level"]);
Renderer->DrawRect(Vector2f(240.f-128.f, 241.f), Vector2f(240.f+128.f, 305.f));
glBindTexture(GL_TEXTURE_2D, ResourceManager->TexList["logo_small"]);
Renderer->DrawRect(Vector2f(240.f-128.f+15.f, 0.f), Vector2f(240.f+128.f+15.f, 64.f));
CheckGlError("Draw TGameMenu 2");
}
void TGameMenu::Update(size_t dt)
{
if (HoldToTap)
return;
// åñëè êíîïêà íå íàæàòà
float k;
MenuPos = MenuPos + MenuSpeed*dt/1000.f;
int menuItemToShowCount;
if (MenuItemCount == 12)
{
menuItemToShowCount = 13;
}
else
{
menuItemToShowCount = MenuItemCount;
}
float acc;
if (MenuItemCount == 1)
{
k = 3;
}
else
{
k = fabs( - MenuPos - ((menuItemToShowCount-1)*CONST_MENU_WINDOW_DISTANCE*0.5f)) / ((MenuItemCount-1)*CONST_MENU_WINDOW_DISTANCE*0.5f);
}
acc = -MenuSpeed * CONST_SPEED_NEG_ACCELERATION_K * k;
float xleft = (- MenuPos + CONST_SHIFT_ON_SIDE - (menuItemToShowCount-1)*CONST_MENU_WINDOW_DISTANCE);
if (xleft < 0)
{
xleft = 0;
}
acc += xleft*CONST_MENU_POS_K;
float xright = (MenuPos - CONST_SHIFT_ON_SIDE);
if (xright < 0)
{
xright = 0;
}
acc -= xright*CONST_MENU_POS_K;
if ((MenuSpeed + acc*dt) * MenuSpeed < 0) //Check if MenuSpeed changes direction
{
MenuSpeed = 0;
}
else
{
MenuSpeed += acc*dt;
}
}
void TGameMenu::OnTapDown(Vector2f pos)
{
*SE::Console << "TGameMenu::OnTapDown";
HoldToTap = true;
if (pos(1)<64.f && pos(0)>=265.f-128.f && pos(0)<=265.f+128.f)
{
Application->GoFromMenuToCredits();
return;
}
Vector2f realPos = pos - Vector2f(MenuPos, 0);
if (realPos(1) >= 80.f && realPos(1) <= 240.f)
{
float x = realPos(0) - 160.f;
int p = 0;
while (x >280.f)
{
x -= 280.f;
p++;
}
if (x <= 240.f && x >= 0.f && (p<MenuItemCount))
{
SelectedGame = p;
return;
}
}
SelectedGame = -1;
}
void TGameMenu::OnTapUp(Vector2f pos)
{
*SE::Console << "TGameMenu::OnTapUp";
HoldToTap = false;
if (SelectedGame != -1)
{
MenuPos = -CONST_MENU_WINDOW_DISTANCE*SelectedGame-40.f;
Application->GoFromMenuToGame(SelectedGame);
SelectedGame = -1;
}
}
void TGameMenu::OnTapUpAfterMove(Vector2f pos)
{
HoldToTap = false;
}
void TGameMenu::OnFling(Vector2f slideSpeed)
{
*SE::Console << "TGameMenu::OnFling";
HoldToTap = false;
MenuSpeed = slideSpeed(0);
}
void TGameMenu::OnScroll(Vector2f shift)
{
MenuPos = MenuPos - shift(0);
}
void TGameMenu::OpenNextLevel()
{
*SE::Console << "TGameMenu::OpenNextLevel";
if (MenuItemCount < 12)
{
MenuItemCount++;
}
}
int TGameMenu::GetMenuItemCount()
{
*SE::Console << "TGameMenu::GetMenuItemCount";
return MenuItemCount;
}
void TGameMenu::SetMenuItemCount(int menuItemCount)
{
*SE::Console << "TGameMenu::SetMenuItemCount";
MenuItemCount = menuItemCount;
}
game/menucode.h
-41
View File
@@ -1,41 +0,0 @@
#ifndef MENUCODE_H_INCLUDED
#define MENUCODE_H_INCLUDED
#include "include/Engine.h"
#include "game_area_interface.h"
using namespace SE;
class TGameMenu : public TGameAreaAncestor
{
protected:
float MenuSpeed;
float MenuPos;
bool HoldToTap;
int MenuItemCount;
int SelectedGame;
public:
TGameMenu();
virtual void Draw();
virtual void Update(size_t dt);
virtual void OnTapDown(Vector2f pos);
virtual void OnTapUp(Vector2f pos);
virtual void OnTapUpAfterMove(Vector2f pos);
virtual void OnFling(Vector2f slideSpeed);
virtual void OnScroll(Vector2f shift);
void OpenNextLevel();
int GetMenuItemCount();
void SetMenuItemCount(int menuItemCount);
};
#endif