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

http://www.blockattack.net

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

*/

#include "common.h"

#include "global.hpp"

#include "scopeHelpers.hpp"

#include "icon.hpp"

#include "os.hpp"

#include <string.h>

#include "version.h"

#define WITH_SDL 1

#include "sago/SagoSpriteHolder.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 "Libs/NFont.h"

#include <vector>

#include "MenuSystem.h"

#include "puzzlehandler.hpp"

#include "stageclearhandler.hpp"

#include <memory>

#include "ScoresDisplay.hpp"

//if SHAREDIR is not used we look in current directory

#ifndef SHAREDIR

#define SHAREDIR "."

#endif

#ifndef LOCALEDIR

#define LOCALEDIR SHAREDIR"/locale"

#endif

#ifndef PACKAGE

#define PACKAGE "blockattack_roftb"

#endif

#include "highscore.h"      //Stores highscores

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

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

#include "replayhandler.hpp"

#include "common.h"

#include "gamecontroller.h"

#include <boost/program_options.hpp>

#include <fstream>

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

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

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

#include "mainVars.inc"

using std::string;

using std::cerr;

using std::cout;

using std::exception;

using std::vector;

GlobalData globalData;

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

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

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

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

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

}

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

	for (const string& path : paths) {

		PHYSFS_addToSearchPath(path.c_str(),1);

	}

	PHYSFS_addToSearchPath(savepath.c_str(), 1);

	PHYSFS_setWriteDir(savepath.c_str());

}

static void PhysFsCreateFolders() {

	PHYSFS_mkdir("screenshots");

	PHYSFS_mkdir("replays");

	PHYSFS_mkdir("puzzles");

}

//Load all image files to memory

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

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

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

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

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

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

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

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

	bomb = holder.GetSprite("block_bomb");

	backgroundImage = holder.GetSprite("background");

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

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

	bForward = holder.GetSprite("b_forward");

	blackLine = holder.GetSprite("black_line");

	stageBobble = holder.GetSprite("i_stage_clear_limit");

	crossover = holder.GetSprite("crossover");

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

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

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

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

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

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

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

	cursor = holder.GetSprite("cursor");

	ready = holder.GetSprite("block_ready");

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

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

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

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

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

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

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

	iGameOver = holder.GetSprite("i_game_over");

	iWinner = holder.GetSprite("i_winner");

	iDraw = holder.GetSprite("i_draw");

	iLoser = holder.GetSprite("i_loser");

	iChainFrame = holder.GetSprite("chain_frame");

	iLevelCheck = holder.GetSprite("i_level_check");

	iLevelCheckBox = holder.GetSprite("i_level_check_box");

	iLevelCheckBoxMarked = holder.GetSprite("i_level_check_box_marked");

	iCheckBoxArea = holder.GetSprite("i_check_box_area");

	boardBackBack = holder.GetSprite("board_back_back");

	garbageTL = holder.GetSprite("garbage_tl");

	garbageT = holder.GetSprite("garbage_t");

	garbageTR = holder.GetSprite("garbage_tr");

	garbageR = holder.GetSprite("garbage_r");

	garbageBR = holder.GetSprite("garbage_br");

	garbageB = holder.GetSprite("garbage_b");

	garbageBL = holder.GetSprite("garbage_bl");

	garbageL = holder.GetSprite("garbage_l");

	garbageFill = holder.GetSprite("garbage_fill");

	garbageML = holder.GetSprite("garbage_ml");

	garbageM = holder.GetSprite("garbage_m");

	garbageMR = holder.GetSprite("garbage_mr");

	garbageGM = holder.GetSprite("garbage_gm");

	garbageGML = holder.GetSprite("garbage_gml");

	garbageGMR = holder.GetSprite("garbage_gmr");

	smiley[0] = holder.GetSprite("smileys0");

	smiley[1] = holder.GetSprite("smileys1");

	smiley[2] = holder.GetSprite("smileys2");

	smiley[3] = holder.GetSprite("smileys3");

	transCover = holder.GetSprite("trans_cover");

	bExit = holder.GetSprite("b_exit");

	bSkip = holder.GetSprite("b_blank");

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

	bRetry = holder.GetSprite("b_blank");

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

	globalData.menuMarked = holder.GetSprite("menu_marked");

	globalData.menuUnmarked = holder.GetSprite("menu_unmarked");

	backBoard = holder.GetSprite("back_board");

	SDL_Color nf_button_color, nf_standard_blue_color, nf_standard_small_color;

	memset(&nf_button_color,0,sizeof(SDL_Color));

	nf_button_color.b = 255;

	nf_button_color.g = 255;

	nf_button_color.r = 255;

	nf_button_color.a = 255;

	nf_standard_blue_color.b = 255;

	nf_standard_blue_color.g = 0;

	nf_standard_blue_color.r = 0;

	nf_standard_blue_color.a = 255;

	nf_standard_small_color.b = 0;

	nf_standard_small_color.g = 0;

	nf_standard_small_color.r = 200;

	nf_standard_small_color.a = 255;

	globalData.nf_button_font.load(globalData.screen, holder.GetDataHolder().getFontPtr("freeserif", 24), nf_button_color);

	globalData.nf_standard_blue_font.load(globalData.screen, holder.GetDataHolder().getFontPtr("freeserif", 30), nf_standard_blue_color);

	nf_standard_small_font.load(globalData.screen, holder.GetDataHolder().getFontPtr("freeserif", 16), nf_standard_small_color);

	globalData.nf_scoreboard_font.load(globalData.screen, holder.GetDataHolder().getFontPtr("penguinattack", 20), nf_button_color);

//Loads the sound if sound present

	if (!globalData.NoSound) {

		//And here the music:

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

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

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

		//Same goes for the sounds

		boing = holder.GetDataHolder().getSoundPtr("pop");

		applause = holder.GetDataHolder().getSoundPtr("applause");

		photoClick = holder.GetDataHolder().getSoundPtr("cameraclick");

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

		counterChunk = holder.GetDataHolder().getSoundPtr("counter");

		counterFinalChunk = holder.GetDataHolder().getSoundPtr("counter_final");

		const int soundVolume = 84;  //0-128

		Mix_VolumeChunk(boing, soundVolume);

		Mix_VolumeChunk(applause, soundVolume);

		Mix_VolumeChunk(photoClick, soundVolume);

		Mix_VolumeChunk(globalData.typingChunk, soundVolume);

		Mix_VolumeChunk(counterChunk, soundVolume);

		Mix_VolumeChunk(counterFinalChunk, 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);

}

static void NFont_Write(SDL_Renderer* target, int x, int y, const string& text) {

	globalData.nf_standard_blue_font.draw(target, x, y, "%s", text.c_str());

}

static void NFont_Write(SDL_Renderer* target, int x, int y, const char* text) {

	globalData.nf_standard_blue_font.draw(target, x, y, "%s", text);

}

SDL_Window* sdlWindow;

std::unique_ptr<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_SetWindowFullscreen(sdlWindow, SDL_WINDOW_FULLSCREEN_DESKTOP);

	}

	else {

		SDL_SetWindowFullscreen(sdlWindow, 0);

	}

	dataHolder.reset(new sago::SagoDataHolder(globalData.screen));

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

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

	SDL_ShowCursor(SDL_DISABLE);

}

static bool logicalRenderer = false;

void DrawBackground(SDL_Renderer* target) {

	SDL_RenderClear(target);

	if (logicalRenderer) {

		globalData.xsize = 1024;

		globalData.ysize = 768;

	}

	else {

		SDL_GetWindowSize(sdlWindow, &globalData.xsize, &globalData.ysize);

	}

	backgroundImage.DrawScaled(target, SDL_GetTicks(), 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;

  }

}

//The small things that are faaling when you clear something

class ABall {

private:

	double x = 0.0;

	double y = 0.0;

	double velocityY = 0.0;

	double velocityX = 0.0;

	int color = 0;

	unsigned long int lastTime = 0;

public:

	ABall() {

	}

	//constructor:

	ABall(int X, int Y, bool right, int coulor) {

		double tal = 1.0+((double)rand()/((double)RAND_MAX));

		velocityY = -tal*startVelocityY;

		lastTime = currentTime;

		x = (double)X;

		y = (double)Y;

		color = coulor;

		if (right) {

			velocityX = tal*VelocityX;

		}

		else {

			velocityX = -tal*VelocityX;

		}

	}  //constructor

	void update() {

		double timePassed = (((double)(currentTime-lastTime))/1000.0);  //time passed in seconds

		x = x+timePassed*velocityX;

		y = y+timePassed*velocityY;

		velocityY = velocityY + gravity*timePassed;

		if (y<1.0) {

			velocityY=10.0;

		}

		if ((velocityY>minVelocity) && (y>(globalData.ysize-ballSize)) && (y<globalData.ysize)) {

			velocityY = -0.70*velocityY;

			y = globalData.ysize-ballSize;

		}

		lastTime = currentTime;

	}

	int getX() {

		return (int)x;

	}

	int getY() {

		return (int)y;

	}

	int getColor() {

		return color;

	}

};  //aBall

static const int maxNumberOfBalls = 6*12*2*2;

class BallManager {

public:

	ABall ballArray[maxNumberOfBalls];

	bool ballUsed[maxNumberOfBalls];

	BallManager() {

		for (int i=0; i<maxNumberOfBalls; i++) {

			ballUsed[i] = false;

		}

	}

	//Adds a ball to the screen at given coordiantes, traveling right or not with color

	int addBall(int x, int y,bool right,int color) {

		int ballNumber = 0;

		//Find a free ball

		while (ballNumber<maxNumberOfBalls && ballUsed[ballNumber]) {

			ballNumber++;

		}

		//Could not find a free ball, return -1

		if (ballNumber==maxNumberOfBalls) {

			return -1;

		}

		currentTime = SDL_GetTicks();

		ballArray[ballNumber] = ABall(x,y,right,color);

		ballUsed[ballNumber] = true;

		return 1;

	}  //addBall

	void update() {

		currentTime = SDL_GetTicks();

		for (int i = 0; i<maxNumberOfBalls; i++) {

			if (ballUsed[i]) {

				ballArray[i].update();

				if (ballArray[i].getY()>globalData.ysize+100 || ballArray[i].getX()>globalData.xsize || ballArray[i].getX()<-ballSize) {

					ballUsed[i] = false;

				}

			}

		}

	} //update

}; //theBallManager

static BallManager theBallManager;

//a explosions, non moving

class AnExplosion {

private:

	int x = 0;

	int y = 0;

	Uint8 frameNumber = 0;

#define frameLength 80

	//How long an image in an animation should be showed

#define maxFrame 4

	//How many images there are in the animation

	unsigned long int placeTime = 0; //Then the explosion occored

public:

	AnExplosion() {

	}

	//constructor:

	AnExplosion(int X, int Y) {

		placeTime = currentTime;

		x = X;

		y = Y;

		frameNumber=0;

	}  //constructor

	//true if animation has played and object should be removed from the screen

	bool removeMe() {

		frameNumber = (currentTime-placeTime)/frameLength;

		return (!(frameNumber<maxFrame));

	}

	int getX() {

		return (int)x;

	}

	int getY() {

		return (int)y;

	}

	int getFrame() {

		return frameNumber;

	}

};  //nExplosion

class ExplosionManager {

public:

	AnExplosion explosionArray[maxNumberOfBalls];

	bool explosionUsed[maxNumberOfBalls];

	ExplosionManager() {

		for (int i=0; i<maxNumberOfBalls; i++) {

			explosionUsed[i] = false;

		}

	}

	int addExplosion(int x, int y) {

		int explosionNumber = 0;

		while ( explosionNumber<maxNumberOfBalls && explosionUsed[explosionNumber]) {

			explosionNumber++;

		}

		if (explosionNumber==maxNumberOfBalls) {

			return -1;

		}

		currentTime = SDL_GetTicks();

		explosionArray[explosionNumber] = AnExplosion(x,y);

		explosionUsed[explosionNumber] = true;

		return 1;

	}  //addBall

	void update() {

		currentTime = SDL_GetTicks();

		for (int i = 0; i<maxNumberOfBalls; i++) {

			if (explosionUsed[i]) {

				if (explosionArray[i].removeMe()) {

					explosionUsed[i] = false;

				}

			}

		}

	} //update

}; //explosionManager

static ExplosionManager theExplosionManager;

//text pop-up

class TextMessage {

private:

	int x = 0;

	int y = 0;

	string textt;

	unsigned long int time = 0;

	unsigned long int placeTime = 0; //Then the text was placed

public:

	TextMessage() {

	}

	//constructor:

	TextMessage(int X, int Y,const char* Text,unsigned int Time) {

		placeTime = currentTime;

		x = X;

		y = Y;

		textt = Text;

		time = Time;

	}  //constructor

	//true if the text has expired

	bool removeMe() {

		return currentTime-placeTime>time;

	}

	int getX() {

		return x;

	}

	int getY() {

		return y;

	}

	const char* getText() {

		return textt.c_str();

	}

};  //text popup

class TextManager {

public:

	TextMessage textArray[maxNumberOfBalls];

	bool textUsed[maxNumberOfBalls];

	TextManager() {

		for (int i=0; i<maxNumberOfBalls; i++) {

			textUsed[i] = false;

		}

	}

	int addText(int x, int y,string Text,unsigned int Time) {

		int textNumber = 0;

		while (textNumber<maxNumberOfBalls && textUsed[textNumber]) {

			textNumber++;

		}

		if (textNumber==maxNumberOfBalls) {

			return -1;

		}

		currentTime = SDL_GetTicks();

		textArray[textNumber] = TextMessage(x,y,Text.c_str(),Time);

		textUsed[textNumber] = true;

		return 1;

	}  //addText

	void update() {

		currentTime = SDL_GetTicks();

		for (int i = 0; i<maxNumberOfBalls; i++) {

			if (textUsed[i]) {

				if (textArray[i].removeMe()) {

					textUsed[i] = false;

				}

			}

		}

	} //update

}; //textManager

static TextManager theTextManager;

//Here comes the Block Game object

#include "BlockGame.hpp"

#include "os.hpp"

#include "sago/SagoMiscSdl2.hpp"

#include "ScoresDisplay.hpp"

#include "BlockGameSdl.inc"

#include "sago/SagoMisc.hpp"

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

void writeScreenShot() {

	if (globalData.verboseLevel) {

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

	}

	int rightNow = (int)time(nullptr);

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

	SDL_Surface* sreenshotSurface = SDL_CreateRGBSurface(0, 1024, 768, 32, 0x00ff0000, 0x0000ff00, 0x000000ff, 0xff000000);

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

	SDL_SaveBMP(sreenshotSurface, buf.c_str());

	SDL_FreeSurface(sreenshotSurface);

	if (!globalData.NoSound) {

		if (globalData.SoundEnabled) {

			Mix_PlayChannel(1, photoClick, 0);

		}

	}

}

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

static string getKeyName(SDL_Keycode key) {

	string keyname(SDL_GetKeyName(key));

	return keyname;

}

void RunGameState(sago::GameStateInterface& state ) {

	int mousex,mousey;

	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, mousex, 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(), mousex, mousey);

		SDL_RenderPresent(globalData.screen);

		if (mustWriteScreenshot) {

			writeScreenShot();

		}

		if (!state.IsActive()) {

			done = true;

		}

	}

}

void OpenScoresDisplay() {

	ScoresDisplay d;

	d.scoreX = buttonXsize*2;

	d.scoreY = 0;

	d.buttonXsize = buttonXsize;

	d.buttonYsize = buttonYsize;

	RunGameState(d);

}

//Draws the balls and explosions

static void DrawBalls() {

	for (int i = 0; i< maxNumberOfBalls; i++) {

		if (theBallManager.ballUsed[i]) {

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

		} //if used

		if (theExplosionManager.explosionUsed[i]) {

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

		}

		if (theTextManager.textUsed[i]) {

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

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

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

			nf_standard_small_font.draw(globalData.screen, x+12,y+7, NFont::CENTER, "%s",theTextManager.textArray[i].getText());

		}

	} //for

}    //DrawBalls

//draws everything

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

	SDL_ShowCursor(SDL_DISABLE);

	DrawBackground(globalData.screen);

	theGame->DoPaintJob();

	theGame2->DoPaintJob();

	string strHolder;

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

	NFont_Write(globalData.screen, theGame->GetTopX()+310,theGame->GetTopY()+100,strHolder.c_str());

	if (theGame->GetAIenabled()) {

		NFont_Write(globalData.screen, theGame->GetTopX()+10,theGame->GetTopY()-34,_("AI") );

	}

	else if (editorMode || singlePuzzle) {

		NFont_Write(globalData.screen, theGame->GetTopX()+10,theGame->GetTopY()-34,_("Playing field") );

	}

	else {

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

	}

	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);

		}

		//if ((SoundEnabled)&&(!NoSound)&&(tid>0)&&(seconds<5)&&(minutes == 0)&&(seconds>1)&&(!(Mix_Playing(6)))) Mix_PlayChannel(6,heartBeat,0);

		NFont_Write(globalData.screen, theGame->GetTopX()+310,theGame->GetTopY()+150,strHolder.c_str());

	}

	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);

		}

		NFont_Write(globalData.screen, theGame->GetTopX()+310,theGame->GetTopY()+150,strHolder.c_str());

	}

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

	NFont_Write(globalData.screen, theGame->GetTopX()+310,theGame->GetTopY()+200,strHolder.c_str());

	//drawspeedLevel:

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

	NFont_Write(globalData.screen, theGame->GetTopX()+310,theGame->GetTopY()+250,strHolder.c_str());

	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(stageBobble,globalData.screen,theGame->GetTopX()+280,theGame->GetTopY()+650+50*(theGame->GetStageClearLimit()-theGame->GetLinesCleared())-theGame->GetPixels()-1);

	}

	//player1 finnish, player2 start

	//DrawIMG(boardBackBack,globalData.screen,theGame2->GetTopX()-60,theGame2->GetTopY()-68);

	if (!editorMode /*&& !singlePuzzle*/ ) {

		/*

		 *If single player mode (and not VS)

		 */

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

			//Blank player2's board:

			DrawIMG(backBoard,globalData.screen,theGame2->GetTopX(),theGame2->GetTopY());

			//Write a description:

			string gametypeName;

			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) {

				NFont_Write(globalData.screen, theGame2->GetTopX()+7,theGame2->GetTopY()+10, gametypeName);

				NFont_Write(globalData.screen, theGame2->GetTopX()+7,theGame2->GetTopY()+160, _("Objective:"));

				globalData.nf_standard_blue_font.drawBox(globalData.screen, { static_cast<float>(theGame2->GetTopX()+7),static_cast<float>(theGame2->GetTopY()+160+32), 280, 200}, "%s", infostring.c_str());

			}

			//Write the keys that are in use

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

			NFont_Write(globalData.screen, theGame2->GetTopX()+7,y,_("Movement keys:") );

			NFont_Write(globalData.screen, theGame2->GetTopX()+7,y+40,(getKeyName(keySettings[0].left)+", "+getKeyName(keySettings[0].right)+"," ).c_str() );

			NFont_Write(globalData.screen, theGame2->GetTopX()+7,y+76,(getKeyName(keySettings[0].up)+", "+getKeyName(keySettings[0].down)).c_str() );

			NFont_Write(globalData.screen, theGame2->GetTopX()+7,y+120,( _("Switch: ")+getKeyName(keySettings[0].change) ).c_str() );

			if (theGame->isPuzzleMode()) {

				NFont_Write(globalData.screen, theGame2->GetTopX()+7,y+160,( _("Restart: ")+getKeyName(keySettings[0].push) ).c_str() );

			}

			else {

				NFont_Write(globalData.screen, theGame2->GetTopX()+7,y+160,( _("Push line: ")+getKeyName(keySettings[0].push) ).c_str() );

			}

		}

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

		NFont_Write(globalData.screen, theGame2->GetTopX()+310,theGame2->GetTopY()+100,strHolder.c_str());

		if (theGame2->GetAIenabled()) {

			NFont_Write(globalData.screen, theGame2->GetTopX()+10,theGame2->GetTopY()-34,_("AI") );

		}

		else {

			NFont_Write(globalData.screen, theGame2->GetTopX()+10,theGame2->GetTopY()-34,theGame2->name);

		}

		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);

			}

			//if ((SoundEnabled)&&(!NoSound)&&(tid>0)&&(seconds<5)&&(minutes == 0)&&(seconds>1)&&(!(Mix_Playing(6)))) Mix_PlayChannel(6,heartBeat,0);

			NFont_Write(globalData.screen, theGame2->GetTopX()+310,theGame2->GetTopY()+150,strHolder.c_str());

		}

		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);

			}

			NFont_Write(globalData.screen, theGame2->GetTopX()+310,theGame2->GetTopY()+150,strHolder.c_str());

		}

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

		NFont_Write(globalData.screen, theGame2->GetTopX()+310,theGame2->GetTopY()+200,strHolder.c_str());

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

		NFont_Write(globalData.screen, theGame2->GetTopX()+310,theGame2->GetTopY()+250,strHolder.c_str());

	}

	//player2 finnish

	//draw exit

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

	DrawBalls();

#if DEBUG

	Frames++;

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

		if (Frames > 999) {

			Frames=999;

		}

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

		Frames = 0;

		Ticks = SDL_GetTicks();

	}

	globalData.nf_standard_blue_font.draw(globalData.screen, 800, 4, "%s", FPS);

#endif

}

//The function that allows the player to choose PuzzleLevel

int PuzzleLevelSelect(int Type) {

	const int xplace = 200;