/* ScummVM - Graphic Adventure Engine
 *
 * ScummVM is the legal property of its developers, whose names
 * are too numerous to list here. Please refer to the COPYRIGHT
 * file distributed with this source distribution.
 *
 * 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 3 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/>.
 *
 */

#include "common/debug.h"
#include "common/rect.h"
#include "common/savefile.h"
#include "common/system.h"

#include "graphics/cursorman.h"

#include "alg/graphics.h"
#include "alg/logic/game_johnnyrock.h"
#include "alg/scene.h"

namespace Alg {

GameJohnnyRock::GameJohnnyRock(AlgEngine *vm, const AlgGameDescription *gd) : Game(vm) {
}

GameJohnnyRock::~GameJohnnyRock() {
	for (auto item : *_difficultyIcon) {
		item->free();
		delete item;
	}
	if (_levelIcon) {
		_levelIcon->free();
		delete _levelIcon;
	}
	if (_bulletholeIcon) {
		_bulletholeIcon->free();
		delete _bulletholeIcon;
	}
}

void GameJohnnyRock::init() {
	Game::init();

	_videoPosX = 11;
	_videoPosY = 2;

	setupCursorTimer();

	if(_vm->useSingleSpeedVideos()) {
		loadLibArchive("johnroc.lib");
	} else {
		loadLibArchive("johnrocd.lib");
	}

	_sceneInfo->loadScnFile("johnroc.scn");
	_startScene = _sceneInfo->getStartScene();

	registerScriptFunctions();
	verifyScriptFunctions();

	_menuzone = new Zone("MainMenu", "GLOBALHIT");
	_menuzone->addRect(0x0C, 0xBB, 0x3C, 0xC7, nullptr, 0, "SHOTMENU", "0");

	_submenzone = new Zone("SubMenu", "GLOBALHIT");
	_submenzone->addRect(0x10, 0x0F, 0x78, 0x34, nullptr, 0, "STARTMENU", "0");
	_submenzone->addRect(0x10, 0x8E, 0x8A, 0xAF, nullptr, 0, "CONTMENU", "0");
	_submenzone->addRect(0x10, 0x3A, 0x6A, 0x5C, nullptr, 0, "RECTSAVE", "0");
	_submenzone->addRect(0x10, 0x64, 0x84, 0x99, nullptr, 0, "RECTLOAD", "0");
	_submenzone->addRect(0xD2, 0x8D, 0x12F, 0xB0, nullptr, 0, "EXITMENU", "0");
	_submenzone->addRect(0xD0, 0x35, 0x123, 0x51, nullptr, 0, "RECTEASY", "0");
	_submenzone->addRect(0xD2, 0x50, 0x125, 0x6B, nullptr, 0, "RECTAVG", "0");
	_submenzone->addRect(0xD2, 0x6D, 0x122, 0x86, nullptr, 0, "RECTHARD", "0");

	_shotSound = loadSoundFile("blow.8b");
	_emptySound = loadSoundFile("empty.8b");
	_saveSound = loadSoundFile("saved.8b");
	_loadSound = loadSoundFile("loaded.8b");
	_skullSound = loadSoundFile("money.8b");

	_gun = AlgGraphics::loadScreenCoordAniImage("gun.ani", _palette);
	_numbers = AlgGraphics::loadAniImage("numbers.ani", _palette);
	_difficultyIcon = AlgGraphics::loadAniImage("diff.ani", _palette);
	auto level = AlgGraphics::loadScreenCoordAniImage("level.ani", _palette);
	_levelIcon = (*level)[0];
	auto hole = AlgGraphics::loadScreenCoordAniImage("hole.ani", _palette);
	_bulletholeIcon = (*hole)[0];

	_background = AlgGraphics::loadVgaBackground("backgrnd.vga", _palette);
	_screen->copyRectToSurface(_background->getPixels(), _background->pitch, 0, 0, _background->w, _background->h);

	moveMouse();
}

// FIXME: Need to unregisterScriptFunctions() in destructor to delete all allocated JRScriptFunctionRect and prevent reallocation to fix memory leakage here...
void GameJohnnyRock::registerScriptFunctions() {
#define RECT_HIT_FUNCTION(name, func) _rectHitFuncs[name] = new JRScriptFunctionRect(this, &GameJohnnyRock::func);
	RECT_HIT_FUNCTION("DEFAULT", rectNewScene);
	RECT_HIT_FUNCTION("NEWSCENE", rectNewScene);
	RECT_HIT_FUNCTION("EXITMENU", rectExit);
	RECT_HIT_FUNCTION("CONTMENU", rectContinue);
	RECT_HIT_FUNCTION("STARTMENU", rectStart);
	RECT_HIT_FUNCTION("SHOTMENU", rectShotMenu);
	RECT_HIT_FUNCTION("RECTSAVE", rectSave);
	RECT_HIT_FUNCTION("RECTLOAD", rectLoad);
	RECT_HIT_FUNCTION("RECTEASY", rectEasy);
	RECT_HIT_FUNCTION("RECTAVG", rectAverage);
	RECT_HIT_FUNCTION("RECTHARD", rectHard);
	RECT_HIT_FUNCTION("KILLINNOCENT", rectKillInnocent);
	RECT_HIT_FUNCTION("SELCASINO", rectSelectCasino);
	RECT_HIT_FUNCTION("SELPOOLH", rectSelectPoolhall);
	RECT_HIT_FUNCTION("SELWAREHSE", rectSelectWarehouse);
	RECT_HIT_FUNCTION("SELGARAGE", rectSelectGarage);
	RECT_HIT_FUNCTION("SELMANSION", rectSelectMansion);
	RECT_HIT_FUNCTION("SELAMMO", rectSelectAmmo);
	RECT_HIT_FUNCTION("SELOFFICE", rectSelectOffice);
	RECT_HIT_FUNCTION("MANBUST", rectShotManBust);
	RECT_HIT_FUNCTION("WOMANBUST", rectShotWomanBust);
	RECT_HIT_FUNCTION("BLUEVASE", rectShotBlueVase);
	RECT_HIT_FUNCTION("CAT", rectShotCat);
	RECT_HIT_FUNCTION("INDIAN", rectShotIndian);
	RECT_HIT_FUNCTION("PLATE", rectShotPlate);
	RECT_HIT_FUNCTION("BLUEDRESSPIC", rectShotBlueDressPic);
	RECT_HIT_FUNCTION("MODERNPIC", rectShotModernPic);
	RECT_HIT_FUNCTION("MONALISA", rectShotMonaLisa);
	RECT_HIT_FUNCTION("GWASHINGTON", rectShotGWashington);
	RECT_HIT_FUNCTION("BOYINREDPIC", rectShotBoyInRedPic);
	RECT_HIT_FUNCTION("COATOFARMS", rectShotCoatOfArms);
	RECT_HIT_FUNCTION("COMBNOA0", rectShotCombinationA0);
	RECT_HIT_FUNCTION("COMBNOA1", rectShotCombinationA1);
	RECT_HIT_FUNCTION("COMBNOA2", rectShotCombinationA2);
	RECT_HIT_FUNCTION("COMBNOA3", rectShotCombinationA3);
	RECT_HIT_FUNCTION("COMBNOA4", rectShotCombinationA4);
	RECT_HIT_FUNCTION("COMBNOA5", rectShotCombinationA5);
	RECT_HIT_FUNCTION("COMBNOB0", rectShotCombinationB0);
	RECT_HIT_FUNCTION("COMBNOB1", rectShotCombinationB1);
	RECT_HIT_FUNCTION("COMBNOB2", rectShotCombinationB2);
	RECT_HIT_FUNCTION("COMBNOB3", rectShotCombinationB3);
	RECT_HIT_FUNCTION("COMBNOB4", rectShotCombinationB4);
	RECT_HIT_FUNCTION("COMBNOB5", rectShotCombinationB5);
	RECT_HIT_FUNCTION("LUCKNO0", rectShotLuckyNumber0);
	RECT_HIT_FUNCTION("LUCKNO1", rectShotLuckyNumber1);
	RECT_HIT_FUNCTION("LUCKNO2", rectShotLuckyNumber2);
	RECT_HIT_FUNCTION("LUCKNO3", rectShotLuckyNumber3);
	RECT_HIT_FUNCTION("LUCKNO4", rectShotLuckyNumber4);
	RECT_HIT_FUNCTION("LUCKNO5", rectShotLuckyNumber5);
#undef RECT_HIT_FUNCTION

#define PRE_OPS_FUNCTION(name, func) _scenePreOps[name] = new JRScriptFunctionScene(this, &GameJohnnyRock::func);
	PRE_OPS_FUNCTION("DRAWRCT", scenePsoDrawRct);
	PRE_OPS_FUNCTION("PAUSE", scenePsoPause);
	PRE_OPS_FUNCTION("FADEIN", scenePsoFadeIn);
	PRE_OPS_FUNCTION("PAUSFI", scenePsoPauseFadeIn);
	PRE_OPS_FUNCTION("PREREAD", scenePsoPreRead);
	PRE_OPS_FUNCTION("PAUSPR", scenePsoPausePreRead);
	PRE_OPS_FUNCTION("DEFAULT", scenePsoDrawRct);
	PRE_OPS_FUNCTION("DRAWRCTFDI", scenePsoDrawRctFadeIn);
#undef PRE_OPS_FUNCTION

#define INS_OPS_FUNCTION(name, func) _sceneInsOps[name] = new JRScriptFunctionScene(this, &GameJohnnyRock::func);
	INS_OPS_FUNCTION("DEFAULT", sceneIsoDoNothing);
	INS_OPS_FUNCTION("PAUSE", sceneIsoPause);
	INS_OPS_FUNCTION("SPAUSE", sceneIsoShootpastPause);
	INS_OPS_FUNCTION("STARTGAME", sceneIsoStartGame);
	INS_OPS_FUNCTION("SHOOTPAST", sceneIsoShootpast);
	INS_OPS_FUNCTION("GOTTOCASINO", sceneIsoGotoCasino);
	INS_OPS_FUNCTION("GOTTOPOOLH", sceneIsoGotoPoolhall);
	INS_OPS_FUNCTION("GOTTOWAREHSE", sceneIsoGotoWarehouse);
	INS_OPS_FUNCTION("INWAREHSE2", sceneIsoInWarehouse2);
	INS_OPS_FUNCTION("INWAREHSE3", sceneIsoInwarehouse3);
	INS_OPS_FUNCTION("GOTOGARAGE", sceneIsoGotoGarage);
	INS_OPS_FUNCTION("GOTOMANSION", sceneIsoGotoMansion);
	INS_OPS_FUNCTION("INMANSION1", sceneIsoInMansion1);
#undef INS_OPS_FUNCTION

#define NXT_SCN_FUNCTION(name, func) _sceneNxtScn[name] = new JRScriptFunctionScene(this, &GameJohnnyRock::func);
	NXT_SCN_FUNCTION("DEFAULT", sceneDefaultNxtscn);
	NXT_SCN_FUNCTION("DRAWGUN", sceneDefaultNxtscn);
	NXT_SCN_FUNCTION("DIED", sceneNxtscnDied);
	NXT_SCN_FUNCTION("BOMBDEAD", sceneNxtscnBombDead);
	NXT_SCN_FUNCTION("PIKUNDRTAKR", sceneNxtscnPickUndertaker);
	NXT_SCN_FUNCTION("CALLATTRACT", sceneNxtscnCallAttract);
	NXT_SCN_FUNCTION("PICKLUCKNO", sceneNxtscnPickLuckyNumber);
	NXT_SCN_FUNCTION("PICKMAP", sceneNxtscnPickMap);
	NXT_SCN_FUNCTION("PICKCLUE", sceneNxtscnPickClue);
	NXT_SCN_FUNCTION("MAPTIMEOUT", sceneNxtscnMapTimeout);
	NXT_SCN_FUNCTION("ENTCASINO", sceneNxtscnEnterCasino);
	NXT_SCN_FUNCTION("CASINOWHAT?", sceneNxtscnCasinoWhat);
	NXT_SCN_FUNCTION("ENTPOOLH", sceneNxtscnEnterPoolhall);
	NXT_SCN_FUNCTION("POOLHCLUE", sceneNxtscnPoolhallClue);
	NXT_SCN_FUNCTION("ENTWAREHSE", sceneNxtscnEnterWarehouse);
	NXT_SCN_FUNCTION("WAREHSECLUE", sceneNxtscnWarehouseClue);
	NXT_SCN_FUNCTION("ENTGARAGE", sceneNxtscnEnterGarage);
	NXT_SCN_FUNCTION("GARAGECLUE", sceneNxtscnGarageClue);
	NXT_SCN_FUNCTION("ENTMANSION", sceneNxtscnEnterMansion);
	NXT_SCN_FUNCTION("GIVECLUE", sceneNxtscnGiveClue);
	NXT_SCN_FUNCTION("PICKFLOWERMAN", sceneNxtscnPickFlowerMan);
	NXT_SCN_FUNCTION("RANDOMSCENE", sceneNxtscnRandomScene);
	NXT_SCN_FUNCTION("ENDRANDSCENE", sceneNxtscnEndRandScene);
	NXT_SCN_FUNCTION("SCN_KILLINNOCENT", sceneNxtscnKillInnocent);
#undef NXT_SCN_FUNCTION

	_zonePtrFb["DEFAULT"] = new JRScriptFunctionPoint(this, &GameJohnnyRock::zoneBullethole);
	_sceneShowMsg["DEFAULT"] = new JRScriptFunctionScene(this, &GameJohnnyRock::sceneSmDonothing);
	_sceneWepDwn["DEFAULT"] = new JRScriptFunctionScene(this, &GameJohnnyRock::sceneDefaultWepdwn);
	_sceneScnScr["DEFAULT"] = new JRScriptFunctionScene(this, &GameJohnnyRock::sceneDefaultScore);
	_sceneNxtFrm["DEFAULT"] = new JRScriptFunctionScene(this, &GameJohnnyRock::sceneNxtfrm);
}

void GameJohnnyRock::verifyScriptFunctions() {
	auto scenes = _sceneInfo->getScenes();
	for (auto scene : *scenes) {
		getScriptFunctionScene(PREOP, scene->_preop);
		getScriptFunctionScene(SHOWMSG, scene->_scnmsg);
		getScriptFunctionScene(INSOP, scene->_insop);
		getScriptFunctionScene(WEPDWN, scene->_wepdwn);
		getScriptFunctionScene(SCNSCR, scene->_scnscr);
		getScriptFunctionScene(NXTFRM, scene->_nxtfrm);
		getScriptFunctionScene(NXTSCN, scene->_nxtscn);
		for (auto zone : scene->_zones) {
			for (auto rect : zone->_rects) {
				getScriptFunctionRectHit(rect->_rectHit);
			}
		}
	}
}

JRScriptFunctionPoint GameJohnnyRock::getScriptFunctionZonePtrFb(Common::String name) {
	auto it = _zonePtrFb.find(name);
	if (it != _zonePtrFb.end()) {
		return *it->_value;
	} else {
		error("GameJohnnyRock::getScriptFunctionZonePtrFb(): Could not find zonePtrFb function: %s", name.c_str());
	}
}

JRScriptFunctionRect GameJohnnyRock::getScriptFunctionRectHit(Common::String name) {
	auto it = _rectHitFuncs.find(name);
	if (it != _rectHitFuncs.end()) {
		return *it->_value;
	} else {
		error("GameJohnnyRock::getScriptFunctionRectHit(): Could not find rectHit function: %s", name.c_str());
	}
}

JRScriptFunctionScene GameJohnnyRock::getScriptFunctionScene(SceneFuncType type, Common::String name) {
	JRScriptFunctionSceneMap *functionMap;
	switch (type) {
	case PREOP:
		functionMap = &_scenePreOps;
		break;
	case SHOWMSG:
		functionMap = &_sceneShowMsg;
		break;
	case INSOP:
		functionMap = &_sceneInsOps;
		break;
	case WEPDWN:
		functionMap = &_sceneWepDwn;
		break;
	case SCNSCR:
		functionMap = &_sceneScnScr;
		break;
	case NXTFRM:
		functionMap = &_sceneNxtFrm;
		break;
	case NXTSCN:
		functionMap = &_sceneNxtScn;
		break;
	default:
		error("GameJohnnyRock::getScriptFunctionScene(): Unkown scene script type: %u", type);
		break;
	}
	JRScriptFunctionSceneMap::iterator it;
	it = functionMap->find(name);
	if (it != functionMap->end()) {
		return *it->_value;
	} else {
		error("GameJohnnyRock::getScriptFunctionScene(): Could not find scene type %u function: %s", type, name.c_str());
	}
}

void GameJohnnyRock::callScriptFunctionZonePtrFb(Common::String name, Common::Point *point) {
	JRScriptFunctionPoint function = getScriptFunctionZonePtrFb(name);
	function(point);
}

void GameJohnnyRock::callScriptFunctionRectHit(Common::String name, Rect *rect) {
	JRScriptFunctionRect function = getScriptFunctionRectHit(name);
	function(rect);
}

void GameJohnnyRock::callScriptFunctionScene(SceneFuncType type, Common::String name, Scene *scene) {
	JRScriptFunctionScene function = getScriptFunctionScene(type, name);
	function(scene);
}

Common::Error GameJohnnyRock::run() {
	init();
	newGame();
	_curScene = _startScene;
	Common::String oldscene;
	while (!_vm->shouldQuit()) {
		_leftDown = false;
		oldscene = _curScene;
		_fired = false;
		Scene *scene = _sceneInfo->findScene(_curScene);
		if (!loadScene(scene)) {
			error("GameJohnnyRock::run(): Cannot find scene %s in libfile", scene->_name.c_str());
		}
		_paletteDirty = true;
		_nextFrameTime = getMsTime() + 100;
		callScriptFunctionScene(PREOP, scene->_preop, scene);
		_currentFrame = getFrame(scene);
		while (_currentFrame <= scene->_endFrame && _curScene == oldscene && !_vm->shouldQuit()) {
			updateMouse();
			// TODO: call scene->messageFunc
			callScriptFunctionScene(INSOP, scene->_insop, scene);
			_holster = weaponDown();
			if (_holster) {
				callScriptFunctionScene(WEPDWN, scene->_wepdwn, scene);
			}
			Common::Point firedCoords;
			if (fired(&firedCoords)) {
				if (!_holster) {
					Rect *hitGlobalRect = checkZone(_menuzone, &firedCoords);
					if (hitGlobalRect != nullptr) {
						callScriptFunctionRectHit(hitGlobalRect->_rectHit, hitGlobalRect);
					} else if (_shots > 0) {
						if (!_debug_unlimitedAmmo) {
							_shots--;
						}
						updateStat();
						Rect *hitRect = nullptr;
						Zone *hitSceneZone = checkZonesV1(scene, hitRect, &firedCoords);
						if (hitSceneZone != nullptr) {
							callScriptFunctionZonePtrFb(hitSceneZone->_ptrfb, &firedCoords);
							callScriptFunctionRectHit(hitRect->_rectHit, hitRect);
						} else {
							defaultBullethole(&firedCoords);
						}
					} else {
						playSound(_emptySound);
						_whichGun = 9;
					}
				}
			}
			if (_curScene == oldscene) {
				callScriptFunctionScene(NXTFRM, scene->_nxtfrm, scene);
			}
			displayScore();
			moveMouse();
			if (_pauseTime > 0) {
				_videoDecoder->pauseAudio(true);
			} else {
				_videoDecoder->pauseAudio(false);
			}
			if (_videoDecoder->getCurrentFrame() == 0) {
				_videoDecoder->getNextFrame();
			}
			updateScreen();
			int32 remainingMillis = _nextFrameTime - getMsTime();
			if (remainingMillis < 10) {
				if (_videoDecoder->getCurrentFrame() > 0) {
					_videoDecoder->getNextFrame();
				}
				remainingMillis = _nextFrameTime - getMsTime();
				_nextFrameTime = getMsTime() + (remainingMillis > 0 ? remainingMillis : 0) + 100;
			}
			if (remainingMillis > 0) {
				if (remainingMillis > 15) {
					remainingMillis = 15;
				}
				g_system->delayMillis(remainingMillis);
			}
			_currentFrame = getFrame(scene);
		}
		// frame limit reached or scene changed, prepare for next scene
		_hadPause = false;
		_pauseTime = 0;
		if (_retScene != "") {
			_curScene = _retScene;
			_retScene = "";
		}
		if (_subScene != "") {
			_retScene = _subScene;
			_subScene = "";
		}
		if (_curScene == oldscene) {
			callScriptFunctionScene(NXTSCN, scene->_nxtscn, scene);
		}
		if (_curScene == "") {
			shutdown();
		}
	}
	removeCursorTimer();
	return Common::kNoError;
}

bool GameJohnnyRock::fired(Common::Point *point) {
	pollEvents();
	_fired = false;
	if (!_leftDown) {
		_buttonDown = false;
		return false;
	}
	if (_leftDown && !_inMenu) {
		_leftDown = true;
	}
	if (_buttonDown) {
		if (_thisGameTimer - _machGunTimer > 3) {
			_buttonDown = false;
			_mgunCnt++;
			if (_mgunCnt > 5) {
				_mgunCnt = 0;
				_leftDown = false;
			}
		}
		return false;
	}
	_fired = true;
	point->x = _mousePos.x;
	point->y = _mousePos.y;
	_machGunTimer = _thisGameTimer;
	_buttonDown = true;
	return true;
}

void GameJohnnyRock::newGame() {
	_gameMoney = 2000;
	_shots = 400;
	_score = 0;
	_holster = false;
	updateStat();
	_retScene = "";
	_subScene = "";
}

void GameJohnnyRock::resetParams() {
	_subScene = "";
	_moneyScene = "";
	_thisMap = _rnd->getRandomNumber(2);
	_clues = 0;
	_gotThisNumber = 0;
	_gotThisClue = 0;
	_thisClue = 0;
	_office = 0;
	_casino = 0;
	_poolHall = 0;
	_warehouse = 0;
	_garage = 0;
	_mansion = 0;
	_didContinue = 0;
	_thisDifficulty = _difficulty - 1;
	_casinoType = _rnd->getRandomNumber(1);
	_poolHallType = _rnd->getRandomNumber(2);
	_warehouseType = _rnd->getRandomNumber(2);
	_garageType = _rnd->getRandomNumber(1);
	_mapTimeout = 0;
	_ammoAgain = 0;
	_combinations[0] = _rnd->getRandomNumber(5);
	_combinations[1] = _rnd->getRandomNumber(5);
	_combinations[2] = _rnd->getRandomNumber(5);
	_combinations[3] = _rnd->getRandomNumber(5);
	_whoDidIt = _rnd->getRandomNumber(3);
	_inWarehouse = 0;
	_officeCount = 0;
	_hadGoToMansion = 0;
	_randomPlaceBits = 0;
	for (int i = 0; i < 5; i++) {
		// this assigns places from _randomPlaces
		uint16 picked = pickBits(&_randomPlaceBits, 6);
		_entranceIndex[i] = picked;
	}
	_randomPlaceBits = 0;
	for (uint8 i = 5; i < 19; i++) {
		// this assigns places from _randomPlacesMR
		uint16 picked = pickBits(&_randomPlaceBits, 8);
		_entranceIndex[i] = picked;
	}
	_maxRepeat = _thisDifficulty + 4;
	_repeatRandomPlace = 0;
	_gotTo = 0;
	updateStat();
}

void GameJohnnyRock::outShots() {
	_shots = 400;
	_score = 0;
	_holster = false;
	updateStat();
}

void GameJohnnyRock::doMenu() {
	uint32 startTime = getMsTime();
	updateCursor();
	_inMenu = true;
	moveMouse();
	_videoDecoder->pauseAudio(true);
	_screen->copyRectToSurface(_background->getBasePtr(_videoPosX, _videoPosY), _background->pitch, _videoPosX, _videoPosY, _videoDecoder->getWidth(), _videoDecoder->getHeight());
	showDifficulty(_difficulty, false);
	while (_inMenu && !_vm->shouldQuit()) {
		Common::Point firedCoords;
		if (fired(&firedCoords)) {
			Rect *hitMenuRect = checkZone(_submenzone, &firedCoords);
			if (hitMenuRect != nullptr) {
				callScriptFunctionRectHit(hitMenuRect->_rectHit, hitMenuRect);
			}
		}
		_leftDown = false;
		if (_difficulty != _oldDifficulty) {
			changeDifficulty(_difficulty);
		}
		updateScreen();
		g_system->delayMillis(15);
	}
	updateCursor();
	_videoDecoder->pauseAudio(false);
	if (_hadPause) {
		uint32 endTime = getMsTime();
		uint32 timeDiff = endTime - startTime;
		_pauseTime += timeDiff;
		_nextFrameTime += timeDiff;
	}
}

void GameJohnnyRock::updateStat() {
	if (_score != _oldScore) {
		_oldScore = _score;
		Common::String buffer = Common::String::format("%05d", _score);
		for (int i = 0; i < 5; i++) {
			uint8 digit = buffer[i] - '0';
			AlgGraphics::drawImage(_screen, (*_numbers)[digit], (i * 7) + 0x7D, 0xBE);
		}
	}
	if (_gameMoney != _oldGameMoney) {
		_oldGameMoney = _gameMoney;
		Common::String buffer = Common::String::format("%04d", _gameMoney < 0 ? 0 : _gameMoney);
		for (int i = 0; i < 4; i++) {
			uint8 digit = buffer[i] - '0';
			AlgGraphics::drawImage(_screen, (*_numbers)[digit], (i * 7) + 0x43, 0xBE);
		}
	}
	if (_shots != _oldShots) {
		_oldShots = _shots;
		Common::String buffer = Common::String::format("%04d", _shots);
		for (int i = 0; i < 4; i++) {
			uint8 digit = buffer[i] - '0';
			AlgGraphics::drawImage(_screen, (*_numbers)[digit], (i * 7) + 0x10A, 0xBE);
		}
	}
	AlgGraphics::drawImage(_screen, (*_difficultyIcon)[_difficulty - 1], 0xBA, 0xBE);
}

void GameJohnnyRock::displayScore() {
	updateStat();
}

void GameJohnnyRock::showDifficulty(uint8 newDifficulty, bool cursor) {
	// reset menu screen
	_screen->copyRectToSurface(_background->getBasePtr(_videoPosX, _videoPosY), _background->pitch, _videoPosX, _videoPosY, _videoDecoder->getWidth(), _videoDecoder->getHeight());
	AlgGraphics::drawImageCentered(_screen, _levelIcon, _diffPos[newDifficulty][0], _diffPos[newDifficulty][1]);
	if (cursor) {
		updateCursor();
	}
}

void GameJohnnyRock::changeDifficulty(uint8 newDifficulty) {
	if (newDifficulty == _oldDifficulty) {
		return;
	}
	showDifficulty(newDifficulty, true);
	Game::adjustDifficulty(newDifficulty, _oldDifficulty);
	_oldDifficulty = newDifficulty;
	_difficulty = newDifficulty;
}

void GameJohnnyRock::updateCursor() {
	_oldWhichGun = _whichGun;
}

void GameJohnnyRock::updateMouse() {
	if (_oldWhichGun != _whichGun) {
		Graphics::Surface *cursor = (*_gun)[_whichGun];
		uint16 hotspotX = (cursor->w / 2);
		uint16 hotspotY = (cursor->h / 2);
		if (debugChannelSet(1, Alg::kAlgDebugGraphics)) {
			cursor->drawLine(0, hotspotY, cursor->w, hotspotY, 1);
			cursor->drawLine(hotspotX, 0, hotspotX, cursor->h, 1);
		}
		CursorMan.replaceCursor(cursor->getPixels(), cursor->w, cursor->h, hotspotX, hotspotY, 0);
		CursorMan.showMouse(true);
		_oldWhichGun = _whichGun;
	}
}

void GameJohnnyRock::moveMouse() {
	if (_inMenu) {
		if (_mousePos.y > 0xB7) {
			_mousePos.y = 0xB7;
		}
		_whichGun = 8;
	} else {
		if (_mousePos.y > 0xBC) {
			_whichGun = 6;
		} else if (_whichGun > 5) {
			_whichGun = 0;
		}
	}
	updateMouse();
}

bool GameJohnnyRock::weaponDown() {
	if (_rightDown && _mousePos.y >= 0xBC && _mousePos.x >= 0x37) {
		return true;
	}
	return false;
}

bool GameJohnnyRock::saveState() {
	Common::OutSaveFile *outSaveFile;
	Common::String saveFileName = _vm->getSaveStateName(0);
	if (!(outSaveFile = g_system->getSavefileManager()->openForSaving(saveFileName))) {
		warning("GameJohnnyRock::saveState(): Can't create file '%s', game not saved", saveFileName.c_str());
		return false;
	}
	outSaveFile->writeUint32BE(MKTAG('A', 'L', 'G', 'S')); // header
	outSaveFile->writeByte(0);                             // version, unused for now
	outSaveFile->writeUint16LE(_totalDies);
	outSaveFile->writeSint16LE(_gameMoney);
	outSaveFile->writeUint16LE(_ammoAgain);
	outSaveFile->writeUint16LE(_mapTimeout);
	outSaveFile->writeByte(_luckyNumber);
	outSaveFile->writeByte(_thisMap);
	outSaveFile->writeUint16LE(_clues);
	outSaveFile->writeUint16LE(_placeBits);
	outSaveFile->writeByte(_randomCount);
	outSaveFile->writeUint16LE(_doctorBits);
	outSaveFile->writeUint16LE(_undertakerBits);
	for (int i = 0; i < 4; i++) {
		outSaveFile->writeByte(_clueTable[i]);
	}
	outSaveFile->writeUint16LE(_thisClue);
	outSaveFile->writeByte(_gotThisNumber);
	outSaveFile->writeByte(_casino);
	outSaveFile->writeByte(_poolHall);
	outSaveFile->writeByte(_warehouse);
	outSaveFile->writeByte(_garage);
	outSaveFile->writeByte(_office);
	outSaveFile->writeByte(_casinoType);
	outSaveFile->writeByte(_poolHallType);
	outSaveFile->writeByte(_warehouseType);
	outSaveFile->writeByte(_garageType);
	outSaveFile->writeByte(_mansion);
	outSaveFile->writeByte(_inWarehouse);
	outSaveFile->writeByte(_inOffice);
	outSaveFile->writeUint16LE(_gotTo);
	for (int i = 0; i < 20; i++) {
		outSaveFile->writeUint16LE(_entranceIndex[i]);
	}
	for (int i = 0; i < 10; i++) {
		outSaveFile->writeUint16LE(_randomScenesIndex[i]);
	}
	for (int i = 0; i < 4; i++) {
		outSaveFile->writeByte(_combinations[i]);
	}
	outSaveFile->writeByte(_whoDidIt);
	outSaveFile->writeByte(_hadGoToMansion);
	outSaveFile->writeUint16LE(_officeCount);
	outSaveFile->writeUint16LE(_randomPlaceBits);
	outSaveFile->writeByte(_maxRandomCount);
	outSaveFile->writeUint16LE(_gotoAfterRandom);
	outSaveFile->writeUint16LE(_repeatRandomPlace);
	outSaveFile->writeUint16LE(_maxRepeat);
	outSaveFile->writeUint16LE(_gotThisClue);
	outSaveFile->writeUint16LE(_didContinue);
	outSaveFile->writeUint16LE(_thisGameTime);
	outSaveFile->writeUint16LE(_shots);
	outSaveFile->writeSint32LE(_score);
	outSaveFile->writeByte(_holster);
	outSaveFile->writeByte(_difficulty);
	outSaveFile->writeByte(_thisDifficulty);
	outSaveFile->writeString(_moneyScene);
	outSaveFile->writeByte(0);
	outSaveFile->writeString(_curScene);
	outSaveFile->writeByte(0);
	outSaveFile->writeString(_subScene);
	outSaveFile->writeByte(0);
	outSaveFile->writeString(_retScene);
	outSaveFile->writeByte(0);
	outSaveFile->writeByte(_randomScenesSavestateIndex);
	outSaveFile->finalize();
	delete outSaveFile;
	return true;
}

bool GameJohnnyRock::loadState() {
	Common::InSaveFile *inSaveFile;
	Common::String saveFileName = _vm->getSaveStateName(0);
	if (!(inSaveFile = g_system->getSavefileManager()->openForLoading(saveFileName))) {
		debug("GameJohnnyRock::loadState(): Can't load file '%s', game not loaded", saveFileName.c_str());
		return false;
	}
	uint32 header = inSaveFile->readUint32BE();
	if (header != MKTAG('A', 'L', 'G', 'S')) {
		warning("GameJohnnyRock::loadState(): Unkown save file, header: %s", tag2str(header));
		return false;
	}
	inSaveFile->skip(1); // version, unused for now
	_totalDies = inSaveFile->readUint16LE();
	_gameMoney = inSaveFile->readSint16LE();
	_ammoAgain = inSaveFile->readUint16LE();
	_mapTimeout = inSaveFile->readUint16LE();
	_luckyNumber = inSaveFile->readByte();
	_thisMap = inSaveFile->readByte();
	_clues = inSaveFile->readUint16LE();
	_placeBits = inSaveFile->readUint16LE();
	_randomCount = inSaveFile->readByte();
	_doctorBits = inSaveFile->readUint16LE();
	_undertakerBits = inSaveFile->readUint16LE();
	for (int i = 0; i < 4; i++) {
		_clueTable[i] = inSaveFile->readByte();
	}
	_thisClue = inSaveFile->readUint16LE();
	_gotThisNumber = inSaveFile->readByte();
	_casino = inSaveFile->readByte();
	_poolHall = inSaveFile->readByte();
	_warehouse = inSaveFile->readByte();
	_garage = inSaveFile->readByte();
	_office = inSaveFile->readByte();
	_casinoType = inSaveFile->readByte();
	_poolHallType = inSaveFile->readByte();
	_warehouseType = inSaveFile->readByte();
	_garageType = inSaveFile->readByte();
	_mansion = inSaveFile->readByte();
	_inWarehouse = inSaveFile->readByte();
	_inOffice = inSaveFile->readByte();
	_gotTo = inSaveFile->readUint16LE();
	for (int i = 0; i < 20; i++) {
		_entranceIndex[i] = inSaveFile->readUint16LE();
	}
	for (int i = 0; i < 10; i++) {
		_randomScenesIndex[i] = inSaveFile->readUint16LE();
	}
	for (int i = 0; i < 4; i++) {
		_combinations[i] = inSaveFile->readByte();
	}
	_whoDidIt = inSaveFile->readByte();
	_hadGoToMansion = inSaveFile->readByte();
	_officeCount = inSaveFile->readUint16LE();
	_randomPlaceBits = inSaveFile->readUint16LE();
	_maxRandomCount = inSaveFile->readByte();
	_gotoAfterRandom = inSaveFile->readUint16LE();
	_repeatRandomPlace = inSaveFile->readUint16LE();
	_maxRepeat = inSaveFile->readUint16LE();
	_gotThisClue = inSaveFile->readUint16LE();
	_didContinue = inSaveFile->readUint16LE();
	_thisGameTime = inSaveFile->readUint16LE();
	_shots = inSaveFile->readUint16LE();
	_score = inSaveFile->readSint32LE();
	_holster = inSaveFile->readByte();
	_difficulty = inSaveFile->readByte();
	_thisDifficulty = inSaveFile->readByte();
	_moneyScene = inSaveFile->readString();
	_curScene = inSaveFile->readString();
	_subScene = inSaveFile->readString();
	_retScene = inSaveFile->readString();
	_randomScenesSavestateIndex = inSaveFile->readByte();
	delete inSaveFile;
	// find out where _random_scenes should point
	uint16 placeIndex = _entranceIndex[_randomScenesSavestateIndex];
	if (_randomScenesSavestateIndex < 5) {
		_randomScenes = _randomPlaces[placeIndex];
	} else {
		_randomScenes = _randomPlacesMR[placeIndex];
	}
	changeDifficulty(_difficulty);
	debug("lucky number: %d", (_luckyNumber + 1));
	return true;
}

void GameJohnnyRock::doMoneySound() {
	playSound(_skullSound);
}

// Misc game functions
Common::String GameJohnnyRock::numToScene(int n) {
	switch (n) {
	case 1:
		return "scene1a";
	case 10:
		return "scene10a";
	case 12:
		return "scene12a";
	case 14:
		return "scene14a";
	case 18:
		return "scene18a";
	case 63:
		return "scene63a";
	case 71:
		return "scene71a";
	case 120:
		return "scn120a";
	case 137:
		return "scn137a";
	default:
		return Common::String::format("scene%d", n);
	}
}

uint16 GameJohnnyRock::sceneToNum(Common::String sceneName) {
	Common::String temp;
	uint16 index = 4;
	if (sceneName[index] == 'e') {
		index++;
	}
	while (sceneName[index] != 'a' && sceneName[index] != 'b' && sceneName[index] != 'c' && sceneName[index] != '\0') {
		temp += sceneName[index];
		index++;
		if (index >= sceneName.size()) {
			break;
		}
	}
	return atoi(temp.c_str());
}

void GameJohnnyRock::defaultBullethole(Common::Point *point) {
	if (point->x >= 14 && point->x <= 306 && point->y >= 5 && point->y <= 169) {
		uint16 targetX = point->x - _videoPosX;
		uint16 targetY = point->y - _videoPosY;
		AlgGraphics::drawImageCentered(_videoDecoder->getVideoFrame(), _bulletholeIcon, targetX, targetY);
		updateCursor();
		_shotFired = true;
		doShot();
	}
}

uint16 GameJohnnyRock::pickBits(uint16 *bits, uint8 max) {
	// reset bits if full
	if (*bits == (0xFFFF >> (16 - max))) {
		*bits = 0;
	}
	uint8 randomNum = _rnd->getRandomNumber(max - 1);
	// find first unused bit position
	while (*bits & (1 << randomNum)) {
		randomNum++;
		if (randomNum >= max) {
			randomNum = 0;
		}
	}
	*bits |= (1 << randomNum);
	return randomNum;
}

uint16 GameJohnnyRock::pickRandomPlace(uint8 place) {
	_randomScenesSavestateIndex = place;
	uint16 placeIndex = _entranceIndex[place];
	if (place < 5) {
		_randomScenes = _randomPlaces[placeIndex];
	} else {
		_randomScenes = _randomPlacesMR[placeIndex];
	}
	_placeBits = 0;
	_randomCount = 0;
	memset(&_randomScenesIndex, 0, (10 * sizeof(uint16)));
	for (int i = 0; i < (_randomScenes[0] + 4); i++) {
		_randomScenesIndex[i] = _randomScenes[i];
	}
	if (_randomScenes[1] < 0) {
		_maxRandomCount = (_thisDifficulty * 2) - _randomScenes[1];
	} else {
		_maxRandomCount = _randomScenes[1];
	}
	uint16 index = pickBits(&_placeBits, _randomScenes[0]);
	return _randomScenes[index + 4];
}

void GameJohnnyRock::showCombination() {
	uint16 offset = (_gotThisClue * 6) + _combinations[_gotThisClue];
	_gotThisClue++;
	if (_gotThisClue == 4) {
		_mansion = 3;
	}
	_curScene = numToScene(offset + 0xDB);
}

// Script functions: Zone
void GameJohnnyRock::zoneBullethole(Common::Point *point) {
	defaultBullethole(point);
}

void GameJohnnyRock::rectShotMenu(Rect *rect) {
	doMenu();
}

void GameJohnnyRock::rectSave(Rect *rect) {
	if (saveState()) {
		doSaveSound();
	}
}

void GameJohnnyRock::rectLoad(Rect *rect) {
	if (loadState()) {
		doLoadSound();
	}
}

void GameJohnnyRock::rectContinue(Rect *rect) {
	_inMenu = false;
	_fired = false;
	if (_gameMoney < 0) {
		newGame();
		_retScene = "";
		_subScene = "";
		if (_inOffice) {
			_curScene = numToScene(_inOffice);
		} else {
			_curScene = numToScene(_thisMap + 174);
		}
		_didContinue++;
	}
	if (_shots <= 0) {
		outShots();
		_didContinue++;
	}
}

void GameJohnnyRock::rectStart(Rect *rect) {
	_inMenu = false;
	_fired = false;
	_thisDifficulty = 0;
	Scene *scene = _sceneInfo->findScene(_startScene);
	if (scene->_nxtscn == "DRAWGUN") {
		callScriptFunctionScene(NXTSCN, "DRAWGUN", scene);
	}
	_curScene = _startScene;
	resetParams();
	newGame();
	updateStat();
}

void GameJohnnyRock::rectKillInnocent(Rect *rect) {
	_inOffice = sceneToNum(_curScene);
	if (_inOffice >= 0x13) {
		_inOffice = 0;
	}
	if (!_debug_godMode) {
		_gameMoney -= 400;
	}
	if (_gameMoney < 0) {
		_subScene = "scene358";
		_retScene = "";
		_curScene = "scene151";
	} else {
		switch (_rnd->getRandomNumber(2)) {
		case 0:
			_curScene = "scene151";
			break;
		case 1:
			_curScene = "scene152";
			break;
		case 2:
			_curScene = "scene153";
			break;
		}
	}
}

void GameJohnnyRock::rectSelectCasino(Rect *rect) {
	_retScene = "";
	if (_mansion == 5 && _whoDidIt == 1) {
		_repeatRandomPlace = _maxRepeat;
		_gotoAfterRandom = 0xF5;
		_curScene = numToScene(pickRandomPlace(_maxRepeat + 5));
	} else if (_casino == 0) {
		if (_gotTo & 1) {
			_curScene = "scene19";
		} else {
			_gotoAfterRandom = 0x13;
			_curScene = numToScene(pickRandomPlace(0));
		}
	} else if (_casino == 1 || _casino == 3) {
		_curScene = "scene44";
	} else {
		_casino = 3;
		if (_rnd->getRandomBit()) { // original: (_this_game_time & 1) == 0
			_curScene = "scene64";
		} else {
			_curScene = "scene65";
		}
	}
}

void GameJohnnyRock::rectSelectPoolhall(Rect *rect) {
	_retScene = "";
	if (_mansion == 5 && _whoDidIt == 0) {
		_repeatRandomPlace = _maxRepeat;
		_gotoAfterRandom = 0xF7;
		_curScene = numToScene(pickRandomPlace(_maxRepeat + 5));
	} else if (_poolHall == 0) {
		if (_gotTo & 2) {
			_curScene = "scene66";
		} else {
			_gotoAfterRandom = 0x42;
			_curScene = numToScene(pickRandomPlace(1));
		}
	} else if (_poolHall == 1 || _poolHall == 3) {
		_curScene = "scene82";
	} else {
		_poolHall = 3;
		_curScene = "scene89";
	}
}

void GameJohnnyRock::rectSelectWarehouse(Rect *rect) {
	_retScene = "";
	if (_mansion == 5 && _whoDidIt == 2) {
		_repeatRandomPlace = _maxRepeat;
		_gotoAfterRandom = 0xF9;
		_curScene = numToScene(pickRandomPlace(_maxRepeat + 5));
	} else if (_warehouse == 0) {
		if (_inWarehouse < 2) {
			if (_gotTo & 4) {
				_curScene = "scene90";
			} else {
				_inWarehouse = 1;
				_gotoAfterRandom = 0x5A;
				_curScene = numToScene(pickRandomPlace(2));
			}
		} else if (_inWarehouse == 2) {
			_curScene = "scene93";
		} else if (_inWarehouse == 3) {
			_curScene = "scene119";
		}
	} else if (_warehouse == 1 || _warehouse == 3) {
		_curScene = "scene122";
	} else {
		_warehouse = 3;
		_curScene = "scene121";
	}
}

void GameJohnnyRock::rectSelectGarage(Rect *rect) {
	_retScene = "";
	if (_mansion == 5 && _whoDidIt == 3) {
		_repeatRandomPlace = _maxRepeat;
		_gotoAfterRandom = 0xFB;
		_curScene = numToScene(pickRandomPlace(_maxRepeat + 5));
	} else if (_garage == 0) {
		if (_gotTo & 8) {
			_curScene = "scene123";
		} else {
			_gotoAfterRandom = 0x7B;
			_curScene = numToScene(pickRandomPlace(3));
		}
	} else if (_garage == 1 || _garage == 3) {
		_curScene = "scene138";
	} else {
		_garage = 3;
		_curScene = "scene139";
	}
}

void GameJohnnyRock::rectSelectMansion(Rect *rect) {
	_placeBits = 0;
	_randomCount = 1;
	_retScene = "";
	if (_mansion == 1) {
		uint16 picked = pickBits(&_placeBits, 5);
		_curScene = numToScene(0xB8 + (picked * 2));
	} else if (_mansion == 2) {
		_curScene = "scene194";
	} else if (_mansion == 3) {
		_curScene = "scene207";
	} else if (_mansion == 4) {
		_gotThisNumber = 0;
		_curScene = "scene212";
	} else if (_mansion == 5) {
		_curScene = "scene243";
	} else {
		if (_garage == 0 || _casino == 0 || _poolHall == 0 || _warehouse == 0) {
			_curScene = "scene243";
		} else if (_gotTo & 0x10) {
			_curScene = "scene180";
		} else {
			_gotoAfterRandom = 0xB4;
			_curScene = numToScene(pickRandomPlace(4));
		}
	}
}

void GameJohnnyRock::rectSelectAmmo(Rect *rect) {
	_retScene = "";
	if (_gameMoney >= 100) {
		if (!_debug_godMode) {
			_gameMoney -= 100;
		}
		_shots += 200;
		_ammoAgain = 0;
		doMoneySound();
		_curScene = "scene178";
	} else {
		_ammoAgain++;
		if (_ammoAgain >= 2) {
			_curScene = "scene243";
		} else {
			_curScene = "scene179";
		}
	}
}

void GameJohnnyRock::rectSelectOffice(Rect *rect) {
	_retScene = "";
	if (!_office) {
		_office = 1;
		_curScene = "scene168";
	} else {
		if (_rnd->getRandomBit()) { // original: _this_game_time & 1
			_curScene = "scene243";
		} else {
			_curScene = "scene262";
		}
	}
}

void GameJohnnyRock::shotClue(uint8 clue) {
	if (_clueTable[_gotThisClue] == clue) {
		showCombination();
	} else {
		_gotThisClue = 0;
		_curScene = "scene374";
	}
}

void GameJohnnyRock::rectShotManBust(Rect *rect) {
	shotClue(0);
}

void GameJohnnyRock::rectShotWomanBust(Rect *rect) {
	shotClue(1);
}

void GameJohnnyRock::rectShotBlueVase(Rect *rect) {
	shotClue(2);
}

void GameJohnnyRock::rectShotCat(Rect *rect) {
	shotClue(3);
}

void GameJohnnyRock::rectShotIndian(Rect *rect) {
	shotClue(4);
}

void GameJohnnyRock::rectShotPlate(Rect *rect) {
	shotClue(5);
}

void GameJohnnyRock::rectShotBlueDressPic(Rect *rect) {
	shotClue(6);
}

void GameJohnnyRock::rectShotModernPic(Rect *rect) {
	shotClue(7);
}

void GameJohnnyRock::rectShotMonaLisa(Rect *rect) {
	shotClue(8);
}

void GameJohnnyRock::rectShotGWashington(Rect *rect) {
	shotClue(9);
}

void GameJohnnyRock::rectShotBoyInRedPic(Rect *rect) {
	shotClue(10);
}

void GameJohnnyRock::rectShotCoatOfArms(Rect *rect) {
	shotClue(11);
}

void GameJohnnyRock::shotCombination(uint8 combination, bool combinationB) {
	if (_combinations[_gotThisNumber] == combination) {
		_gotThisNumber++;
		if (_gotThisNumber >= 4) {
			_mansion = 5;
			_curScene = numToScene(_whoDidIt + 0xD7);
		} else {
			if (combinationB) {
				_curScene = "scene213";
			} else {
				_curScene = "scene214";
			}
		}
	} else {
		_gotThisNumber = 0;
		_curScene = "scene376";
	}
}

void GameJohnnyRock::rectShotCombinationA0(Rect *rect) {
	shotCombination(0, false);
}

void GameJohnnyRock::rectShotCombinationA1(Rect *rect) {
	shotCombination(1, false);
}

void GameJohnnyRock::rectShotCombinationA2(Rect *rect) {
	shotCombination(2, false);
}

void GameJohnnyRock::rectShotCombinationA3(Rect *rect) {
	shotCombination(3, false);
}

void GameJohnnyRock::rectShotCombinationA4(Rect *rect) {
	shotCombination(4, false);
}

void GameJohnnyRock::rectShotCombinationA5(Rect *rect) {
	shotCombination(5, false);
}

void GameJohnnyRock::rectShotCombinationB0(Rect *rect) {
	shotCombination(0, true);
}

void GameJohnnyRock::rectShotCombinationB1(Rect *rect) {
	shotCombination(1, true);
}

void GameJohnnyRock::rectShotCombinationB2(Rect *rect) {
	shotCombination(2, true);
}

void GameJohnnyRock::rectShotCombinationB3(Rect *rect) {
	shotCombination(3, true);
}

void GameJohnnyRock::rectShotCombinationB4(Rect *rect) {
	shotCombination(4, true);
}

void GameJohnnyRock::rectShotCombinationB5(Rect *rect) {
	shotCombination(5, true);
}

void GameJohnnyRock::shotLuckyNumber(uint8 number) {
	if (_luckyNumber != number || _curScene == _moneyScene) {
		return;
	}
	doMoneySound();
	_gameMoney += 100;
	_score += 500;
	_moneyScene = _curScene;
}

void GameJohnnyRock::rectShotLuckyNumber0(Rect *rect) {
	shotLuckyNumber(0);
}

void GameJohnnyRock::rectShotLuckyNumber1(Rect *rect) {
	shotLuckyNumber(1);
}

void GameJohnnyRock::rectShotLuckyNumber2(Rect *rect) {
	shotLuckyNumber(2);
}

void GameJohnnyRock::rectShotLuckyNumber3(Rect *rect) {
	shotLuckyNumber(3);
}

void GameJohnnyRock::rectShotLuckyNumber4(Rect *rect) {
	shotLuckyNumber(4);
}

void GameJohnnyRock::rectShotLuckyNumber5(Rect *rect) {
	shotLuckyNumber(5);
}

// Script functions: Scene PreOps

// Script functions: Scene Scene InsOps
void GameJohnnyRock::sceneIsoShootpast(Scene *scene) {
	if (_fired) {
		if (_retScene != "") {
			_curScene = _retScene;
			_retScene = "";
		} else if (_subScene != "") {
			_curScene = _subScene;
			_subScene = "";
		} else {
			callScriptFunctionScene(NXTSCN, scene->_nxtscn, scene);
		}
	}
}

void GameJohnnyRock::sceneIsoShootpastPause(Scene *scene) {
	sceneIsoShootpast(scene);
	sceneIsoPause(scene);
}

void GameJohnnyRock::sceneIsoGotoCasino(Scene *scene) {
	_gotTo |= 1;
	sceneIsoShootpast(scene);
}

void GameJohnnyRock::sceneIsoGotoPoolhall(Scene *scene) {
	_gotTo |= 2;
	sceneIsoShootpast(scene);
}

void GameJohnnyRock::sceneIsoGotoWarehouse(Scene *scene) {
	_gotTo |= 4;
}

void GameJohnnyRock::sceneIsoInWarehouse2(Scene *scene) {
	_inWarehouse = 2;
	sceneIsoShootpast(scene);
}

void GameJohnnyRock::sceneIsoInwarehouse3(Scene *scene) {
	_inWarehouse = 3;
	sceneIsoShootpast(scene);
}

void GameJohnnyRock::sceneIsoGotoGarage(Scene *scene) {
	_gotTo |= 8;
	sceneIsoShootpast(scene);
}

void GameJohnnyRock::sceneIsoGotoMansion(Scene *scene) {
	_gotTo |= 0x10;
}

void GameJohnnyRock::sceneIsoInMansion1(Scene *scene) {
	_mansion = 1;
}

// Script functions: Scene NxtScn
void GameJohnnyRock::sceneNxtscnDied(Scene *scene) {
	uint16 sceneNum = sceneToNum(_curScene);
	_inOffice = sceneNum;
	if (sceneNum >= 0x13) {
		_inOffice = 0;
	}
	_totalDies++;
	if (!_debug_godMode) {
		_gameMoney -= 400;
	}
	if (_gameMoney < 0) {
		switch (_rnd->getRandomNumber(2)) {
		case 0:
			_curScene = "scene148";
			break;
		case 1:
			_curScene = "scene149";
			break;
		case 2:
			_curScene = "scene150";
			break;
		}
	} else {
		switch (pickBits(&_doctorBits, 8)) {
		case 0:
			_curScene = "scene140";
			break;
		case 1:
			_curScene = "scene141";
			break;
		case 2:
			_curScene = "scene142";
			break;
		case 3:
			_curScene = "scene143";
			break;
		case 4:
			_curScene = "scene144";
			break;
		case 5:
			_curScene = "scene145";
			break;
		case 6:
			_curScene = "scene146";
			break;
		case 7:
			_curScene = "scene147";
			break;
		}
	}
}

void GameJohnnyRock::sceneNxtscnBombDead(Scene *scene) {
	uint16 sceneNum = sceneToNum(_curScene);
	_inOffice = sceneNum;
	if (sceneNum >= 0x13) {
		_inOffice = 0;
	}
	_totalDies++;
	if (!_debug_godMode) {
		_gameMoney -= 400;
	}
	if (_gameMoney < 0) {
		switch (_rnd->getRandomNumber(2)) {
		case 0:
			_curScene = "scene148";
			break;
		case 1:
			_curScene = "scene149";
			break;
		case 2:
			_curScene = "scene150";
			break;
		}
	} else {
		_curScene = "scene142";
	}
}

void GameJohnnyRock::sceneNxtscnPickUndertaker(Scene *scene) {
	switch (pickBits(&_undertakerBits, 3)) {
	case 0:
		_curScene = "scene154";
		break;
	case 1:
		_curScene = "scene155";
		break;
	case 2:
		_curScene = "scene156";
		break;
	}
}

void GameJohnnyRock::sceneNxtscnCallAttract(Scene *scene) {
	resetParams();
	newGame();
	_curScene = "scn354aa";
}

void GameJohnnyRock::sceneNxtscnPickLuckyNumber(Scene *scene) {
	_luckyNumber = _rnd->getRandomNumber(5);
	debug("lucky number: %d", (_luckyNumber + 1));
	_curScene = Common::String::format("scene%d", _luckyNumber + 3);
}

void GameJohnnyRock::sceneNxtscnPickMap(Scene *scene) {
	Common::String nextScene;
	if (_gameMoney < 0) {
		switch (_rnd->getRandomNumber(2)) {
		case 0:
			_curScene = "scene148";
			break;
		case 1:
			_curScene = "scene149";
			break;
		case 2:
			_curScene = "scene150";
			break;
		}
		return;
	}
	uint16 sceneNum = sceneToNum(_curScene);
	if (sceneNum == 18) {
		_inOffice = 0;
	}
	if (_inOffice) {
		nextScene = numToScene(_inOffice);
	} else if (_officeCount < 10) {
		if ((_officeCount % 3) == 0) {
			uint16 sceneNume = _officeTable[_officeCount / 3];
			nextScene = numToScene(sceneNume);
		}
		_officeCount++;
	} else if (_thisClue == 2 && !_hadGoToMansion) {
		if (!_didContinue) {
			_thisDifficulty++;
			if (_thisDifficulty > 7)
				_thisDifficulty = 7;
		}
		_hadGoToMansion = 1;
		if (_poolHall) {
			_poolHall = 2;
			nextScene = "scene162";
		} else if (_casino) {
			_casino = 2;
			nextScene = "scene163";
		} else if (_warehouse) {
			_warehouse = 2;
			nextScene = "scene165";
		}
	} else if (_thisClue == 3 && _hadGoToMansion == 1) {
		if (_totalDies < 4) {
			_thisDifficulty++;
			if (_thisDifficulty > 7)
				_thisDifficulty = 7;
		}
		_hadGoToMansion = 2;
		if (_poolHall == 1) {
			_poolHall = 2;
			nextScene = "scene162";
		} else if (_casino == 1) {
			_casino = 2;
			nextScene = "scene163";
		} else if (_warehouse == 1) {
			_warehouse = 2;
			nextScene = "scene165";
		}
	} else if (_hadGoToMansion == 2 && _garage && _casino && _poolHall && _warehouse) {
		if (_totalDies < 5 || _didContinue <= 1) {
			_thisDifficulty++;
			if (_thisDifficulty > 7)
				_thisDifficulty = 7;
		}
		_hadGoToMansion = 3;
		nextScene = "scene166";
	}
	if (!nextScene.empty()) {
		_curScene = nextScene;
	} else {
		_curScene = numToScene(_thisMap + 174);
	}
}

void GameJohnnyRock::sceneNxtscnPickClue(Scene *scene) {
	uint16 picked = pickBits(&_clues, 12);
	_clueTable[_thisClue] = picked;
	_thisClue++;
	_curScene = numToScene(picked + 0xC3);
}

void GameJohnnyRock::sceneNxtscnMapTimeout(Scene *scene) {
	_mapTimeout++;
	if (_mapTimeout < 3) {
		_curScene = "scene360";
	} else {
		_curScene = "scene262";
	}
}

void GameJohnnyRock::sceneNxtscnEnterCasino(Scene *scene) {
	_placeBits = 0;
	_randomCount = 0;
	uint16 sceneNum;
	if (_casinoType != 0) {
		sceneNum = (pickBits(&_placeBits, 12) * 2) + 0x14;
	} else {
		sceneNum = (pickBits(&_placeBits, 8) * 2) + 0x2D;
	}
	_curScene = numToScene(sceneNum);
}

void GameJohnnyRock::sceneNxtscnCasinoWhat(Scene *scene) {
	_randomCount++;
	uint16 maxRandom = ((_thisDifficulty * 3) + 6);
	if (_randomCount > maxRandom) {
		_casino = 1;
		_curScene = "scene63a";
	} else {
		uint16 sceneNum;
		if (_casinoType != 0) {
			sceneNum = (pickBits(&_placeBits, 12) * 2) + 0x14;
		} else {
			sceneNum = (pickBits(&_placeBits, 8) * 2) + 0x2D;
		}
		_curScene = numToScene(sceneNum);
	}
}

void GameJohnnyRock::sceneNxtscnEnterPoolhall(Scene *scene) {
	if (_poolHallType == 0) {
		_curScene = "scene67";
	} else if (_poolHallType == 1) {
		_curScene = "scene73";
	} else {
		_curScene = "scene78";
	}
}

void GameJohnnyRock::sceneNxtscnPoolhallClue(Scene *scene) {
	_poolHall = 1;
	uint16 clue = pickBits(&_clues, 12);
	_clueTable[_thisClue] = clue;
	_thisClue++;
	_curScene = numToScene(clue + 0xC3);
}

void GameJohnnyRock::sceneNxtscnEnterWarehouse(Scene *scene) {
	if (_warehouseType == 0) {
		_curScene = "scene94";
	} else if (_warehouseType == 1) {
		_curScene = "scene102";
	} else {
		_curScene = "scene110";
	}
}

void GameJohnnyRock::sceneNxtscnWarehouseClue(Scene *scene) {
	_warehouse = 1;
	uint16 clue = pickBits(&_clues, 12);
	_clueTable[_thisClue] = clue;
	_thisClue++;
	_curScene = numToScene(clue + 0xC3);
}

void GameJohnnyRock::sceneNxtscnEnterGarage(Scene *scene) {
	if (_garageType != 0) {
		_curScene = "scene124";
	} else {
		_curScene = "scene131";
	}
}

void GameJohnnyRock::sceneNxtscnGarageClue(Scene *scene) {
	_garage = 1;
	uint16 clue = pickBits(&_clues, 12);
	_clueTable[_thisClue] = clue;
	_thisClue++;
	_curScene = numToScene(clue + 0xC3);
}

void GameJohnnyRock::sceneNxtscnEnterMansion(Scene *scene) {
	_mansion = 1;
	_randomCount++;
	uint16 maxRandom = ((_thisDifficulty * 2) + 7);
	if (_randomCount <= maxRandom) {
		uint16 picked = pickBits(&_placeBits, 5);
		_curScene = numToScene((picked * 2) + 0xB8);
	} else {
		_mansion = 2;
		_curScene = "scene194";
	}
}

void GameJohnnyRock::sceneNxtscnGiveClue(Scene *scene) {
	_score += 1000;
	_gameMoney += 50;
	sceneNxtscnPickMap(scene);
}

void GameJohnnyRock::sceneNxtscnPickFlowerMan(Scene *scene) {
	if (_rnd->getRandomBit()) {
		_curScene = "scene10a";
	} else {
		_curScene = "scene12a";
	}
}

void GameJohnnyRock::sceneNxtscnRandomScene(Scene *scene) {
	_randomCount++;
	if (_randomCount <= _maxRandomCount) {
		_placeBits = pickBits(&_placeBits, _randomScenes[0]);
		_curScene = numToScene(_randomScenes[_placeBits + 4]);
	} else {
		if (_randomScenes[2] != 0) {
			_curScene = numToScene(_randomScenes[2]);
		} else if (_repeatRandomPlace > 0) {
			_repeatRandomPlace--;
			_maxRepeat--;
			uint16 picked = pickRandomPlace(_repeatRandomPlace + 5);
			_curScene = numToScene(picked);
		} else {
			_curScene = numToScene(_gotoAfterRandom);
			_gotoAfterRandom = 0;
			_placeBits = 0;
			_randomCount = 1;
		}
	}
}

void GameJohnnyRock::sceneNxtscnEndRandScene(Scene *scene) {
	if (_repeatRandomPlace > 0) {
		_repeatRandomPlace--;
		_maxRepeat--;
		uint16 picked = pickRandomPlace(_repeatRandomPlace + 5);
		_curScene = numToScene(picked);
	} else {
		_curScene = numToScene(_gotoAfterRandom);
		_gotoAfterRandom = 0;
		_placeBits = 0;
		_randomCount = 1;
	}
}

void GameJohnnyRock::sceneNxtscnKillInnocent(Scene *scene) {
	if (!_debug_godMode) {
		_gameMoney -= 400;
	}
	if (_gameMoney < 0) {
		_retScene = "scene358";
		_curScene = "scene151";
	} else {
		switch (_rnd->getRandomNumber(2)) {
		case 0:
			_curScene = "scene151";
			break;
		case 1:
			_curScene = "scene152";
			break;
		case 2:
			_curScene = "scene153";
			break;
		}
	}
}

// Script functions: WepDwn
void GameJohnnyRock::sceneDefaultWepdwn(Scene *scene) {
	_inHolster = 9;
	_whichGun = 7;
	updateMouse();
}

// Debug methods
void GameJohnnyRock::debugWarpTo(int val) {
	// TODO implement
}

// Debugger methods
DebuggerJohnnyRock::DebuggerJohnnyRock(GameJohnnyRock *game) {
	_game = game;
	registerVar("drawRects", &game->_debug_drawRects);
	registerVar("godMode", &game->_debug_godMode);
	registerVar("unlimitedAmmo", &game->_debug_unlimitedAmmo);
	registerCmd("warpTo", WRAP_METHOD(DebuggerJohnnyRock, cmdWarpTo));
	registerCmd("dumpLib", WRAP_METHOD(DebuggerJohnnyRock, cmdDumpLib));
}

bool DebuggerJohnnyRock::cmdWarpTo(int argc, const char **argv) {
	if (argc != 2) {
		debugPrintf("Usage: warp <int>");
		return true;
	} else {
		int val = atoi(argv[1]);
		_game->debugWarpTo(val);
		return false;
	}
}

bool DebuggerJohnnyRock::cmdDumpLib(int argc, const char **argv) {
	return _game->debug_dumpLibFile();
}

} // End of namespace Alg