blame: source/code/main.cpp

/*

===========================================================================

blockattack - Block Attack - Rise of the Blocks

Copyright (C) 2005-2016 Poul Sander

This program is free software: you can redistribute it and/or modify

it under the terms of the GNU General Public License as published by

the Free Software Foundation, either version 2 of the License, or

(at your option) any later version.

This program is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

GNU General Public License for more details.

You should have received a copy of the GNU General Public License

along with this program.  If not, see http://www.gnu.org/licenses/

Source information and contacts persons can be found at

https://blockattack.net

===========================================================================

*/

#include "MenuSystem.h"

#include "replayhandler.hpp"

#include "common.h"

#include "global.hpp"

#include "scopeHelpers.hpp"

#include "icon.hpp"

#include "os.hpp"

#include <string.h>

#include <fmt/core.h>

#include "version.h"

#define WITH_SDL 1

#include "sago/SagoSpriteHolder.hpp"

#include "sago/SagoTextBox.hpp"

#include "sago/SagoMisc.hpp"

#include <iostream>

#include <stdlib.h>

#include <time.h>           //Used for srand()

#include <sstream>          //Still used by std::to_string2

#include <string>

#include "SDL.h"            //The SDL libary, used for most things

#include <SDL_mixer.h>      //Used for sound & music

#include <SDL_image.h>      //To load PNG images!

#include <physfs.h>         //Abstract file system. To use containers

#include <vector>

#include "puzzlehandler.hpp"

#include "stageclearhandler.hpp"

#include <memory>

#include "ScoresDisplay.hpp"

#include "highscore.h"      //Stores highscores

#include "ReadKeyboard.h"   //Reads text from keyboard

#include "stats.h"          //Saves general stats

#include "common.h"

#include "gamecontroller.h"

#include <boost/algorithm/string.hpp>

#include <boost/program_options.hpp>

#include <fstream>

#include "levelselect.hpp"

#include "ExplosionManager.hpp"

#include "puzzle_editor/PuzzleEditorState.hpp"

#include "SagoImGui.hpp"

/*******************************************************************************

* All variables and constant has been moved to mainVars.inc for the overview.  *

*******************************************************************************/

#include "mainVars.inc"

GlobalData globalData;

static int InitImages(sago::SagoSpriteHolder& holder);

static void FsSearchParthMainAppend(std::vector<std::string>& paths) {

	paths.push_back((std::string)SHAREDIR+"/blockattack.data");

	paths.push_back((std::string)PHYSFS_getBaseDir()+"/blockattack.data");

	paths.push_back((std::string)PHYSFS_getBaseDir()+"/data");

}

static void FsSearchPathModAppend(std::vector<std::string>& paths, const std::vector<std::string>& modlist) {

	for (const std::string& mod : modlist) {

		std::string filename = std::string(SHAREDIR)+"/mods/"+mod+".data";

		paths.push_back(filename);

		filename = std::string(PHYSFS_getBaseDir())+"/mods/"+mod+".data";

		paths.push_back(filename);

	}

}

static void PhysFsSetSearchPath(const std::vector<std::string>& paths, const std::string& savepath) {

	for (const std::string& path : paths) {

		PHYSFS_mount(path.c_str(), "/", 0);

	}

	PHYSFS_mount(savepath.c_str(), "/", 0);

	PHYSFS_setWriteDir(savepath.c_str());

}

static void PhysFsCreateFolders() {

	//PHYSFS_mkdir("screenshots");

	PHYSFS_mkdir("replays");

	PHYSFS_mkdir("puzzles");

}

static void setGameOverFont(const sago::SagoDataHolder* holder, sago::SagoTextBox& field, const char* text) {

	field.SetHolder(holder);

	field.SetFont("freeserif");

	field.SetColor({0,0,255,255});

	field.SetFontSize(60);

	field.SetOutline(3, {192,192,255,255});

	field.SetMaxWidth(280);

	field.SetText(text);

}

//Load all image files to memory

static int InitImages(sago::SagoSpriteHolder& holder) {

	globalData.bricks[0] = holder.GetSprite("block_blue");

	globalData.bricks[1] = holder.GetSprite("block_green");

	globalData.bricks[2] = holder.GetSprite("block_purple");

	globalData.bricks[3] = holder.GetSprite("block_red");

	globalData.bricks[4] = holder.GetSprite("block_yellow");

	globalData.bricks[5] = holder.GetSprite("block_turkish");

	globalData.bricks[6] = holder.GetSprite("block_grey");

	globalData.bomb = holder.GetSprite("block_bomb");

	globalData.bHighScore = holder.GetSprite("b_highscore");

	globalData.bBack = holder.GetSprite("b_blank");

	bForward = holder.GetSprite("b_forward");

	globalData.blackLine = holder.GetSprite("black_line");

	globalData.stageBobble = holder.GetSprite("i_stage_clear_limit");

	globalData.crossover = holder.GetSprite("crossover");

	globalData.balls[0] = holder.GetSprite("ball_blue");

	globalData.balls[1] = holder.GetSprite("ball_green");

	globalData.balls[2] = holder.GetSprite("ball_purple");

	globalData.balls[3] = holder.GetSprite("ball_red");

	globalData.balls[4] = holder.GetSprite("ball_yellow");

	globalData.balls[5] = holder.GetSprite("ball_turkish");

	globalData.balls[6] = holder.GetSprite("ball_gray");

	globalData.cursor = holder.GetSprite("cursor");

	globalData.ready = holder.GetSprite("block_ready");

	globalData.explosion[0] = holder.GetSprite("explosion0");

	globalData.explosion[1] = holder.GetSprite("explosion1");

	globalData.explosion[2] = holder.GetSprite("explosion2");

	globalData.explosion[3] = holder.GetSprite("explosion3");

	globalData.counter[0] = holder.GetSprite("counter_1");

	globalData.counter[1] = holder.GetSprite("counter_2");

	globalData.counter[2] = holder.GetSprite("counter_3");

	setGameOverFont(&holder.GetDataHolder(),globalData.tbGameOver, _("GAME OVER"));

	setGameOverFont(&holder.GetDataHolder(),globalData.tbWinner, _("WINNER"));

	setGameOverFont(&holder.GetDataHolder(),globalData.tbDraw, _("DRAW"));

	globalData.iChainFrame = holder.GetSprite("chain_frame");

	globalData.iLevelCheck = holder.GetSprite("i_level_check");

	globalData.iLevelCheckBox = holder.GetSprite("i_level_check_box");

	globalData.iLevelCheckBoxMarked = holder.GetSprite("i_level_check_box_marked");

	globalData.iCheckBoxArea = holder.GetSprite("i_check_box_area");

	globalData.boardBackBack = holder.GetSprite("board_back_back");

	globalData.garbageTL = holder.GetSprite("garbage_tl");

	globalData.garbageT = holder.GetSprite("garbage_t");

	globalData.garbageTR = holder.GetSprite("garbage_tr");

	globalData.garbageR = holder.GetSprite("garbage_r");

	globalData.garbageBR = holder.GetSprite("garbage_br");

	globalData.garbageB = holder.GetSprite("garbage_b");

	globalData.garbageBL = holder.GetSprite("garbage_bl");

	globalData.garbageL = holder.GetSprite("garbage_l");

	globalData.garbageFill = holder.GetSprite("garbage_fill");

	globalData.garbageML = holder.GetSprite("garbage_ml");

	globalData.garbageM = holder.GetSprite("garbage_m");

	globalData.garbageMR = holder.GetSprite("garbage_mr");

	globalData.garbageGM = holder.GetSprite("garbage_gm");

	globalData.garbageGML = holder.GetSprite("garbage_gml");

	globalData.garbageGMR = holder.GetSprite("garbage_gmr");

	globalData.transCover = holder.GetSprite("trans_cover");

	bExit = holder.GetSprite("b_exit");

	globalData.bSkip = holder.GetSprite("b_blank");

	globalData.bNext = holder.GetSprite("b_blank");

	globalData.bRetry = holder.GetSprite("b_blank");

	globalData.mouse = holder.GetSprite("mouse");

	globalData.cordNextButton.x = 3*bsize+(3*bsize-buttonXsize)/2;

	globalData.cordNextButton.y = 10*bsize;

	globalData.cordNextButton.xsize = buttonXsize;

	globalData.cordNextButton.ysize = buttonYsize;

	globalData.cordRetryButton.x = (3*bsize-buttonXsize)/2;

	globalData.cordRetryButton.y = 10*bsize;

	globalData.cordRetryButton.xsize = buttonXsize;

	globalData.cordRetryButton.ysize = buttonYsize;

//Loads the sound if sound present

	if (!globalData.NoSound) {

		//And here the music:

		bgMusic = holder.GetDataHolder().getMusicHandler("bgmusic");

		highbeatMusic = holder.GetDataHolder().getMusicHandler("highbeat");

		//the music... we just hope it exists, else the user won't hear anything

		//Same goes for the sounds

		globalData.boing = holder.GetDataHolder().getSoundHandler("pop");

		globalData.applause = holder.GetDataHolder().getSoundHandler("applause");

		globalData.photoClick = holder.GetDataHolder().getSoundHandler("cameraclick");

		globalData.typingChunk = holder.GetDataHolder().getSoundHandler("typing");

		globalData.counterChunk = holder.GetDataHolder().getSoundHandler("counter");

		globalData.counterFinalChunk = holder.GetDataHolder().getSoundHandler("counter_final");

		Config::getInstance()->setDefault("volume_sound", "24"); //0-128

		int soundVolume = Config::getInstance()->getInt("volume_sound");

		Mix_VolumeChunk(globalData.boing.get(), soundVolume);

		Mix_VolumeChunk(globalData.applause.get(), soundVolume);

		Mix_VolumeChunk(globalData.photoClick.get(), soundVolume);

		Mix_VolumeChunk(globalData.typingChunk.get(), soundVolume);

		Mix_VolumeChunk(globalData.counterChunk.get(), soundVolume);

		Mix_VolumeChunk(globalData.counterFinalChunk.get(), soundVolume);

	} //All sound has been loaded or not

	return 0;

} //InitImages()

/*Draws a image from on a given Surface. Takes source image, destination surface and coordinates*/

void DrawIMG(const sago::SagoSprite& sprite, SDL_Renderer* target, int x, int y) {

	sprite.Draw(target, SDL_GetTicks(),x,y);

}

void DrawIMG_Bounded(const sago::SagoSprite& sprite, SDL_Renderer* target, int x, int y, int minx, int miny, int maxx, int maxy) {

	SDL_Rect bounds;

	bounds.x = minx;

	bounds.y = miny;

	bounds.w = maxx-minx;

	bounds.h = maxy-miny;

	sprite.DrawBounded(target, SDL_GetTicks(),x,y,bounds);

}

SDL_Window* sdlWindow;

sago::SagoDataHolder dataHolder;

void ResetFullscreen() {

	Mix_HaltMusic();  //We need to reload all data in case the screen type changes. Music must be stopped before unload.

	if (globalData.bFullscreen) {

		SDL_DisplayMode dm;

		globalData.xsize = SIXTEEN_NINE_WIDTH;

		globalData.ysize = SCREEN_HIGHT;

		if (SDL_GetDesktopDisplayMode(0, &dm) == 0) {

			globalData.xsize = globalData.ysize*dm.w/(double)dm.h;

		}

		SDL_SetWindowFullscreen(sdlWindow, SDL_WINDOW_FULLSCREEN_DESKTOP);

	}

	else {

		globalData.xsize = FOUR_THREE_WIDTH;

		globalData.ysize = SCREEN_HIGHT;

		SDL_SetWindowFullscreen(sdlWindow, 0);

	}

	if (globalData.alwaysSixteenNine || globalData.xsize > SIXTEEN_NINE_WIDTH) {

		globalData.xsize = SIXTEEN_NINE_WIDTH;

	}

	if (globalData.xsize < FOUR_THREE_WIDTH) {

		globalData.xsize = FOUR_THREE_WIDTH;

	}

	if (!puzzleEditor) {

		SDL_RenderSetLogicalSize(globalData.screen, globalData.xsize, globalData.ysize);

	}

	dataHolder.invalidateAll(globalData.screen);

	globalData.spriteHolder.reset(new sago::SagoSpriteHolder( dataHolder ) );

	globalData.spriteHolder->ReadSprites(globalData.modinfo.getModSpriteFiles());

	if (sago::FileExists("sprites/custom_backgrounds.sprite")) {

		std::vector<std::string> custom_backgrounds = { "custom_backgrounds" };

		globalData.spriteHolder->ReadSprites(custom_backgrounds);

	}

	InitImages(*(globalData.spriteHolder.get()) );

	SDL_ShowCursor(SDL_DISABLE);

}

static bool logicalRenderer = false;

void DrawBackground(SDL_Renderer* target) {

	SDL_RenderClear(target);

	sago::SagoSprite background = globalData.spriteHolder->GetSprite(globalData.theme.background.background_sprite);

	if ( (double)globalData.xsize/globalData.ysize > 1.5 && globalData.theme.background.background_sprite_16x9.length()) {

		background = globalData.spriteHolder->GetSprite(globalData.theme.background.background_sprite_16x9);

	}

	size_t ticks = SDL_GetTicks();

	if (globalData.theme.background.background_scale == ImgScale::Tile) {

		int nextX = 0;

		if (globalData.theme.background.tileMoveSpeedX) {

			nextX -= (ticks/globalData.theme.background.tileMoveSpeedX)%background.GetWidth();

		}

		while (nextX < globalData.xsize) {

			int nextY = 0;

			if (globalData.theme.background.tileMoveSpeedY) {

				nextY -= (ticks/globalData.theme.background.tileMoveSpeedY)%background.GetWidth();

			}

			while (nextY < globalData.ysize) {

				background.Draw(target, ticks, nextX, nextY);

				nextY += background.GetHeight();

			}

			nextX += background.GetWidth();

		}

		return;

	}

	background.DrawScaled(target, ticks, 0, 0, globalData.xsize, globalData.ysize);

}

/**

 * This function reads the mouse coordinates from a relevant event.

 * Unlike SDL_GetMouseState this works even if SDL_RenderSetLogicalSize is used

 * @param event

 * @param mousex

 * @param mousey

 */

void UpdateMouseCoordinates(const SDL_Event& event, int& mousex, int& mousey) {

	switch (event.type) {

	case SDL_MOUSEBUTTONDOWN:

	case SDL_MOUSEBUTTONUP:

		mousex = event.button.x;

		mousey = event.button.y;

		break;

	case SDL_MOUSEMOTION:

		mousex = event.motion.x;

		mousey = event.motion.y;

		break;

	default:

		break;

	}

}

BallManager theBallManager;

ExplosionManager theExplosionManager;

//Here comes the Block Game object

#include "BlockGame.hpp"

#include "os.hpp"

#include "sago/SagoMiscSdl2.hpp"

#include "ScoresDisplay.hpp"

#include "BlockGameSdl.hpp"

#include "sago/SagoMisc.hpp"

#include "ReplayPlayer.hpp"

#include "platform_folders.h"

std::string pathToScreenShots() {

	Config::getInstance()->setDefault("screenshot_dir", _("Block Attack - Rise of the Blocks"));

	std::string screenshot_dir = Config::getInstance()->getString("screenshot_dir");

	if (OsPathIsRelative(screenshot_dir)) {

		return sago::getPicturesFolder() + "/" + screenshot_dir;

	}

	return screenshot_dir;

}

//writeScreenShot saves the screen as a bmp file, it uses the time to get a unique filename

void writeScreenShot() {

	if (globalData.verboseLevel) {

		std::cout << "Saving screenshot" << "\n";

	}

	int rightNow = (int)time(nullptr);

	int w, h;

	SDL_GetRendererOutputSize(globalData.screen, &w, &h);

	SDL_Surface* sreenshotSurface = SDL_CreateRGBSurface(0, w, h, 32, 0x00ff0000, 0x0000ff00, 0x000000ff, 0xff000000);

	SDL_RenderReadPixels(globalData.screen, NULL, SDL_PIXELFORMAT_ARGB8888, sreenshotSurface->pixels, sreenshotSurface->pitch);

	OsCreateFolder(pathToScreenShots());

	std::string buf = pathToScreenShots() + "/screenshot"+std::to_string(rightNow)+".bmp";

	SDL_SaveBMP(sreenshotSurface, buf.c_str());

	SDL_FreeSurface(sreenshotSurface);

	if (!globalData.NoSound) {

		if (globalData.SoundEnabled) {

			Mix_PlayChannel(1, globalData.photoClick.get(), 0);

		}

	}

}

//Function to return the name of a key, to be displayed...

std::string getKeyName(SDL_Keycode key);

void RunGameState(sago::GameStateInterface& state ) {

	bool done = false;     //We are done!

	while (!done && !Config::getInstance()->isShuttingDown()) {

		state.Draw(globalData.screen);

		SDL_Delay(1);

		SDL_Event event;

		bool mustWriteScreenshot = false;

		while ( SDL_PollEvent(&event) ) {

			UpdateMouseCoordinates(event, globalData.mousex, globalData.mousey);

			if ( event.type == SDL_QUIT ) {

				Config::getInstance()->setShuttingDown(5);

				done = true;

			}

			if ( event.key.keysym.sym == SDLK_F9 ) {

				mustWriteScreenshot = true;

			}

			bool processed = false;

			state.ProcessInput(event, processed);

		}

		state.Update();

		globalData.mouse.Draw(globalData.screen, SDL_GetTicks(), globalData.mousex, globalData.mousey);

		SDL_RenderPresent(globalData.screen);

		if (mustWriteScreenshot) {

			writeScreenShot();

		}

		if (!state.IsActive()) {

			done = true;

		}

	}

}

void RunImGuiGameState(sago::GameStateInterface& state ) {

	bool done = false;     //We are done!

	while (!done && !Config::getInstance()->isShuttingDown()) {

		SDL_SetRenderDrawColor(globalData.screen, 0, 0, 0, 0);

		SDL_RenderClear(globalData.screen);

		ImGui_ImplSDLRenderer2_NewFrame();

		ImGui_ImplSDL2_NewFrame();

		ImGui::NewFrame();

		state.Draw(globalData.screen);

		ImGui::Render();

		ImGui_ImplSDLRenderer2_RenderDrawData( ImGui::GetDrawData(), globalData.screen );

		//While using Dear ImGui we do not draw the mouse ourself. This is gone: globalData.mouse.Draw(globalData.screen, SDL_GetTicks(), globalData.mousex, globalData.mousey);

		SDL_RenderPresent(globalData.screen);

		SDL_Delay(1);

		SDL_Event event;

		bool mustWriteScreenshot = false;

		while ( SDL_PollEvent(&event) ) {

			if ( event.type == SDL_QUIT ) {

				Config::getInstance()->setShuttingDown(5);

				done = true;

			}

			if (event.type == SDL_WINDOWEVENT) {

				if (event.window.event == SDL_WINDOWEVENT_SIZE_CHANGED) {

					std::cout << event.window.data1 << ", " << event.window.data2 << "\n";

					SDL_GetRendererOutputSize(globalData.screen, &globalData.xsize, &globalData.ysize);

				}

			}

			if (event.type == SDL_KEYDOWN) {

				if ( event.key.keysym.sym == SDLK_F9 ) {

					mustWriteScreenshot = true;

				}

			}

			if (mustWriteScreenshot) {

				writeScreenShot();

			}

			bool processed = false;

			ImGui_ImplSDL2_ProcessEvent(&event);

			state.ProcessInput(event, processed);

		}

		state.Update();

		//SDL_RenderPresent(globalData.screen);

		if (!state.IsActive()) {

			done = true;

		}

	}

}

void OpenScoresDisplay() {

	ScoresDisplay d;

	d.scoreX = buttonXsize*2;

	d.scoreY = 0;

	d.buttonXsize = buttonXsize;

	d.buttonYsize = buttonYsize;

	RunGameState(d);

}

static sago::SagoTextField* getSmallInt(size_t number) {

	static std::vector<std::shared_ptr<sago::SagoTextField> > smallFontCache;

	if (smallFontCache.size() < number+1) {

		smallFontCache.resize(number+1);

	}

	if (!smallFontCache[number]) {

		std::shared_ptr<sago::SagoTextField> newNumber = std::make_shared<sago::SagoTextField>();

		newNumber->SetHolder(&globalData.spriteHolder->GetDataHolder());

		newNumber->SetFont("freeserif");

		newNumber->SetFontSize(16);

		newNumber->SetColor({255,0,0,255});

		newNumber->SetText(std::to_string(number));

		smallFontCache[number] = newNumber;

	}

	return smallFontCache[number].get();

}

//Draws the balls and explosions

static void DrawBalls() {

	for (size_t i = 0; i< theBallManager.ballArray.size(); i++) {

		if (theBallManager.ballArray[i].inUse) {

			DrawIMG(globalData.balls[theBallManager.ballArray[i].getColor()], globalData.screen, theBallManager.ballArray[i].getX(), theBallManager.ballArray[i].getY());

		} //if used

	}

	for (size_t i = 0; i< theExplosionManager.explosionArray.size(); i++) {

		if (theExplosionManager.explosionArray[i].inUse) {

			DrawIMG(globalData.explosion[theExplosionManager.explosionArray[i].getFrame()], globalData.screen, theExplosionManager.explosionArray[i].getX(), theExplosionManager.explosionArray[i].getY());

		}

	} //for

	for (size_t i = 0; i < globalData.theTextManager.textArray.size(); ++i) {

		if (globalData.theTextManager.textArray[i].inUse) {

			int x = globalData.theTextManager.textArray[i].getX()-12;

			int y = globalData.theTextManager.textArray[i].getY()-12;

			DrawIMG(globalData.iChainFrame, globalData.screen, x, y);

			getSmallInt(globalData.theTextManager.textArray[i].getText())->Draw(globalData.screen, x+12, y+7,

			        sago::SagoTextField::Alignment::center);

		}

	}

}    //DrawBalls

void sagoTextSetBlueFont(sago::SagoTextField& field) {

	field.SetHolder(&globalData.spriteHolder->GetDataHolder());

	field.SetFont("freeserif");

	field.SetFontSize(30);

	field.SetColor({0,0,255,255});

	field.SetOutline(1, {128,128,255,255});

}

//draws everything

void DrawEverything(int xsize, int ysize,BlockGameSdl* theGame, BlockGameSdl* theGame2) {

	SDL_ShowCursor(SDL_DISABLE);

	DrawBackground(globalData.screen);

	theGame->DoPaintJob();

	theGame2->DoPaintJob();

	std::string strHolder;

	strHolder = std::to_string(theGame->GetScore()+theGame->GetHandicap());

	/*player1score.SetText(strHolder);

	player1score.Draw(globalData.screen, theGame->GetTopX()+310,theGame->GetTopY()+100);

	if (theGame->GetAIenabled()) {

	    player1name.SetText(_("AI"));

	}

	else if (singlePuzzle) {

	    player1name.SetText(_("Playing field"));

	}

	else {

	    player1name.SetText(globalData.player1name);

	}

	player1name.Draw(globalData.screen, theGame->GetTopX()+10,theGame->GetTopY()-34);

	if (theGame->isTimeTrial()) {

	    int tid = (int)SDL_GetTicks()-theGame->GetGameStartedAt();

	    int minutes;

	    int seconds;

	    if (tid>=0) {

	        minutes = (2*60*1000-(abs((int)SDL_GetTicks()-(int)theGame->GetGameStartedAt())))/60/1000;

	        seconds = ((2*60*1000-(abs((int)SDL_GetTicks()-(int)theGame->GetGameStartedAt())))%(60*1000))/1000;

	    }

	    else {

	        minutes = ((abs((int)SDL_GetTicks()-(int)theGame->GetGameStartedAt())))/60/1000;

	        seconds = (((abs((int)SDL_GetTicks()-(int)theGame->GetGameStartedAt())))%(60*1000))/1000;

	    }

	    if (theGame->isGameOver()) {

	        minutes=0;

	    }

	    if (theGame->isGameOver()) {

	        seconds=0;

	    }

	    if (seconds>9) {

	        strHolder = std::to_string(minutes)+":"+std::to_string(seconds);

	    }

	    else {

	        strHolder = std::to_string(minutes)+":0"+std::to_string(seconds);

	    }

	    player1time.SetText(strHolder);

	}

	else {

	    int minutes = ((abs((int)SDL_GetTicks()-(int)theGame->GetGameStartedAt())))/60/1000;

	    int seconds = (((abs((int)SDL_GetTicks()-(int)theGame->GetGameStartedAt())))%(60*1000))/1000;

	    if (theGame->isGameOver()) {

	        minutes=(theGame->GetGameEndedAt()/1000/60)%100;

	    }

	    if (theGame->isGameOver()) {

	        seconds=(theGame->GetGameEndedAt()/1000)%60;

	    }

	    if (seconds>9) {

	        strHolder = std::to_string(minutes)+":"+std::to_string(seconds);

	    }

	    else {

	        strHolder = std::to_string(minutes)+":0"+std::to_string(seconds);

	    }

	    player1time.SetText(strHolder);

	}

	player1time.Draw(globalData.screen, theGame->GetTopX()+310,theGame->GetTopY()+150);

	strHolder = std::to_string(theGame->GetChains());

	player1chain.SetText(strHolder);

	player1chain.Draw(globalData.screen, theGame->GetTopX()+310,theGame->GetTopY()+200);

	//drawspeedLevel:

	strHolder = std::to_string(theGame->GetSpeedLevel());

	player1speed.SetText(strHolder);

	player1speed.Draw(globalData.screen, theGame->GetTopX()+310,theGame->GetTopY()+250);

	if ((theGame->isStageClear()) &&(theGame->GetTopY()+700+50*(theGame->GetStageClearLimit()-theGame->GetLinesCleared())-theGame->GetPixels()-1<600+theGame->GetTopY())) {

	    oldBubleX = theGame->GetTopX()+280;

	    oldBubleY = theGame->GetTopY()+650+50*(theGame->GetStageClearLimit()-theGame->GetLinesCleared())-theGame->GetPixels()-1;

	    DrawIMG(globalData.stageBobble,globalData.screen,theGame->GetTopX()+280,theGame->GetTopY()+650+50*(theGame->GetStageClearLimit()-theGame->GetLinesCleared())-theGame->GetPixels()-1);

	}*/

	//player1 finnish, player2 start

#if 0

	if (true ) {

		/*

		 *If single player mode (and not VS)

		 */

		if (!twoPlayers && !theGame->isGameOver()) {

			//Blank player2's board:

			globalData.spriteHolder->GetSprite(globalData.theme.back_board).DrawScaled(globalData.screen, SDL_GetTicks(), theGame2->GetTopX(),theGame2->GetTopY(), BOARD_WIDTH, BOARD_HEIGHT);

			//Write a description:

			std::string gametypeName;

			std::string infostring;

			if (theGame->isTimeTrial()) {

				gametypeName = _("Time Trial");

				infostring = _("Score as much as possible in 2 minutes");

			}

			else if (theGame->isStageClear()) {

				gametypeName = _("Stage Clear");

				infostring = _("You must clear a number of lines. Speed is rapidly increased.");

			}

			else if (theGame->isPuzzleMode()) {

				gametypeName = _("Puzzle");

				infostring = _("Clear the entire board with a limited number of moves.");

			}

			else {

				gametypeName = _("Endless");

				infostring = _("Score as much as possible. No time limit.");

			}

			if (infostring.length() > 0) {

				static sago::SagoTextBox infoBox;

				static sago::SagoTextField objectiveField;

				static sago::SagoTextField gametypeNameField;

				sagoTextSetHelpFont(infoBox);

				infoBox.SetMaxWidth(290);

				infoBox.SetText(infostring);

				sagoTextSetHelpFont(objectiveField);

				objectiveField.SetText(_("Objective:"));

				sagoTextSetHelpFont(gametypeNameField);

				gametypeNameField.SetText(gametypeName);

				gametypeNameField.Draw(globalData.screen, theGame2->GetTopX()+7,theGame2->GetTopY()+10);

				objectiveField.Draw(globalData.screen, theGame2->GetTopX()+7, theGame2->GetTopY()+160);

				infoBox.Draw(globalData.screen, theGame2->GetTopX()+7, theGame2->GetTopY()+160+32);

			}

			//Write the keys that are in use

			int y = theGame2->GetTopY()+400;

			std::string controldBoxText = std::string(_("Movement keys:"))+"\n"+getKeyName(keySettings[0].left)+", "+getKeyName(keySettings[0].right)+",\n"

			                              + getKeyName(keySettings[0].up)+", "+getKeyName(keySettings[0].down)+"\n"

			                              + _("Switch: ") + getKeyName(keySettings[0].change);

			if (theGame->isPuzzleMode()) {

				controldBoxText += std::string("\n") + _("Restart: ")+getKeyName(keySettings[0].push);

			}

			else {

				controldBoxText += std::string("\n") + _("Push line: ")+getKeyName(keySettings[0].push);

			}

			static sago::SagoTextBox controldBox;

			controldBox.SetHolder(&globalData.spriteHolder->GetDataHolder());

			sagoTextSetHelpFont(controldBox);

			controldBox.SetMaxWidth(290);

			controldBox.SetText(controldBoxText);

			controldBox.Draw(globalData.screen, theGame2->GetTopX()+7,y);

		}

		strHolder = std::to_string(theGame2->GetScore()+theGame2->GetHandicap());

		player2score.SetText(strHolder);

		player2score.Draw(globalData.screen, theGame2->GetTopX()+310, theGame2->GetTopY()+100);

		if (theGame2->GetAIenabled()) {

			player2name.SetText(_("AI"));

		}

		else {

			player2name.SetText(theGame2->name);

		}

		player2name.Draw(globalData.screen, theGame2->GetTopX()+10,theGame2->GetTopY()-34);

		if (theGame2->isTimeTrial()) {

			int tid = (int)SDL_GetTicks()-theGame2->GetGameStartedAt();

			int minutes;

			int seconds;

			if (tid>=0) {

				minutes = (2*60*1000-(abs((int)SDL_GetTicks()-(int)theGame2->GetGameStartedAt())))/60/1000;

				seconds = ((2*60*1000-(abs((int)SDL_GetTicks()-(int)theGame2->GetGameStartedAt())))%(60*1000))/1000;

			}

			else {

				minutes = ((abs((int)SDL_GetTicks()-(int)theGame2->GetGameStartedAt())))/60/1000;

				seconds = (((abs((int)SDL_GetTicks()-(int)theGame2->GetGameStartedAt())))%(60*1000))/1000;

			}

			if (theGame2->isGameOver()) {

				minutes=0;

			}

			if (theGame2->isGameOver()) {

				seconds=0;

			}

			if (seconds>9) {

				strHolder = std::to_string(minutes)+":"+std::to_string(seconds);

			}

			else {

				strHolder = std::to_string(minutes)+":0"+std::to_string(seconds);

			}

		}

		else {

			int minutes = (abs((int)SDL_GetTicks()-(int)theGame2->GetGameStartedAt()))/60/1000;

			int seconds = (abs((int)SDL_GetTicks()-(int)theGame2->GetGameStartedAt())%(60*1000))/1000;

			if (theGame2->isGameOver()) {

				minutes=(theGame2->GetGameEndedAt()/1000/60)%100;

			}

			if (theGame2->isGameOver()) {

				seconds=(theGame2->GetGameEndedAt()/1000)%60;

			}

			if (seconds>9) {

				strHolder = std::to_string(minutes)+":"+std::to_string(seconds);

			}

			else {

				strHolder = std::to_string(minutes)+":0"+std::to_string(seconds);

			}

		}

		player2time.SetText(strHolder);

		player2time.Draw(globalData.screen, theGame2->GetTopX()+310,theGame2->GetTopY()+150);

		strHolder = std::to_string(theGame2->GetChains());

		player2chain.SetText(strHolder);

		player2chain.Draw(globalData.screen, theGame2->GetTopX()+310,theGame2->GetTopY()+200);

		strHolder = std::to_string(theGame2->GetSpeedLevel());

		player2speed.SetText(strHolder);

		player2speed.Draw(globalData.screen, theGame2->GetTopX()+310,theGame2->GetTopY()+250);

	}

	//player2 finnish

#endif

	//draw exit

	bExit.Draw(globalData.screen,SDL_GetTicks(), xsize-bExitOffset, ysize-bExitOffset);

	DrawBalls();

#if DEBUG

	static sago::SagoTextField fpsField;

	sagoTextSetBlueFont(fpsField);

	Frames++;

	if (SDL_GetTicks() >= Ticks + 1000) {

		if (Frames > 999) {

			Frames=999;

		}

		snprintf(FPS, sizeof(FPS), "%lu fps", Frames);

		Frames = 0;

		Ticks = SDL_GetTicks();

	}

	fpsField.SetText(FPS);

	fpsField.Draw(globalData.screen, globalData.xsize - 4, 4, sago::SagoTextField::Alignment::right, sago::SagoTextField::VerticalAlignment::top);

#endif

}

static BlockGameSdl* player1;

static BlockGameSdl* player2;

static bool registerEndlessHighscore = false;

static bool registerTTHighscorePlayer1 = false;

static bool registerTTHighscorePlayer2 = false;

static bool saveReplay = false;

/**

 * startSpeed is a value from 0 to 4

 * */

static void StartSinglePlayerEndless(int startSpeed) {

	//1 player - endless

	BlockGameStartInfo startInfo;

	startInfo.ticks = SDL_GetTicks();

	startInfo.startBlocks = startInfo.ticks;

	startInfo.gameSpeed = startSpeed;

	startInfo.basicBlockVariants = Config::getInstance()->getInt("basic_block_variants", 6);

	player1->NewGame(startInfo);

	twoPlayers =false;

	BlockGameAction a;

	a.action = BlockGameAction::Action::SET_GAME_OVER;

	a.tick = startInfo.ticks;

	player2->DoAction(a);

	player1->name = globalData.player1name;

	player2->name = globalData.player2name;

	registerEndlessHighscore = true;

}

static void StartSinglePlayerTimeTrial() {

	BlockGameStartInfo startInfo;

	startInfo.ticks = SDL_GetTicks();

	startInfo.timeTrial = true;

	startInfo.basicBlockVariants = Config::getInstance()->getInt("basic_block_variants", 6);

	player1->NewGame(startInfo);

	twoPlayers =false;

	BlockGameAction a;

	a.action = BlockGameAction::Action::SET_GAME_OVER;

	a.tick = startInfo.ticks;

	player2->DoAction(a);

	//vsMode = false;

	player1->name = globalData.player1name;

	player2->name = globalData.player2name;

	registerTTHighscorePlayer1 = true;

	saveReplay = true;

}

static int StartSinglePlayerPuzzle() {

	BlockGameStartInfo startInfo;

	startInfo.ticks = SDL_GetTicks();

	startInfo.puzzleMode = true;

	startInfo.level = PuzzleLevelSelect(0);

	if (startInfo.level == -1) {

		return 1;

	}

	player1->NewGame(startInfo);

	DrawBackground(globalData.screen);

	twoPlayers = false;

	BlockGameAction a;

	a.action = BlockGameAction::Action::SET_GAME_OVER;

	a.tick = startInfo.ticks;

	player2->DoAction(a);

	player1->name = globalData.player1name;

	player2->name = globalData.player2name;

	return 0;

}

static void StarTwoPlayerTimeTrial() {

	BlockGameStartInfo startInfo;

	startInfo.ticks = SDL_GetTicks();

	startInfo.timeTrial = true;

	startInfo.basicBlockVariants = Config::getInstance()->getInt("basic_block_variants", 6);

	BlockGameStartInfo startInfo2 = startInfo;

	registerTTHighscorePlayer1 = true;

	registerTTHighscorePlayer2 = true;

	if (player1AI) {

		startInfo.AI = true;

		startInfo.level = player1AIlevel;

		registerTTHighscorePlayer1 = false;

	}

	if (player2AI) {

		startInfo2.AI = true;

		startInfo2.level = player2AIlevel;

		registerTTHighscorePlayer2 = false;

	}

	startInfo.gameSpeed = player1Speed;

	startInfo2.gameSpeed = player2Speed;

	startInfo.handicap = player1handicap;

	startInfo2.handicap = player2handicap;

	player1->NewGame(startInfo);

	player2->NewGame(startInfo2);

	twoPlayers = true;

	player1->name = globalData.player1name;

	player2->name = globalData.player2name;

}

static void StartTwoPlayerVs() {

	//2 player - VsMode

	BlockGameStartInfo startInfo;

	startInfo.ticks = SDL_GetTicks();

	startInfo.vsMode = true;

	startInfo.startBlocks = startInfo.ticks;

	startInfo.basicBlockVariants = Config::getInstance()->getInt("basic_block_variants", 6);

	BlockGameStartInfo startInfo2 = startInfo;

	if (player1AI) {

		startInfo.AI = true;

		startInfo.level = player1AIlevel;

	}

	if (player2AI) {

		startInfo2.AI = true;

		startInfo2.level = player2AIlevel;

	}

	startInfo.gameSpeed = player1Speed;

	startInfo2.gameSpeed = player2Speed;

	startInfo.handicap = player1handicap;

	startInfo2.handicap = player2handicap;

	player1->NewGame(startInfo);

	player2->NewGame(startInfo2);

	twoPlayers = true;

	player1->name = globalData.player1name;

	player2->name = globalData.player2name;

}

static void MoveBlockGameSdls( BlockGameSdl& game1, BlockGameSdl& game2 ) {

	game1.SetTopXY(globalData.xsize/2-440, globalData.ysize/2-284);

	game2.SetTopXY(globalData.xsize/2+40, globalData.ysize/2-284);