/* 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 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, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 *
 */

/*
 * This code is based on the original source code of Lord Avalot d'Argent version 1.3.
 * Copyright (c) 1994-1995 Mike, Mark and Thomas Thurman.
 */

/* LUCERNA		The screen, [keyboard] and mouse handler.*/

#include "avalanche/avalanche.h"

#include "avalanche/lucerna.h"
#include "avalanche/gyro.h"
#include "avalanche/scrolls.h"
#include "avalanche/timer.h"
#include "avalanche/animation.h"
#include "avalanche/background.h"
#include "avalanche/pingo.h"
#include "avalanche/sequence.h"
#include "avalanche/acci.h"
#include "avalanche/roomnums.h"

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

#include "graphics/palette.h"

namespace Avalanche {

Clock::Clock(AvalancheEngine *vm) {
	_vm = vm;
	_oldHour = _oldHourAngle = _oldMinute = 17717;
}

void Clock::update() { // TODO: Move variables from Gyro to here (or at least somewhere nearby), rename them.
	TimeDate t;
	_vm->_system->getTimeAndDate(t);
	_hour = t.tm_hour;
	_minute = t.tm_min;
	_second = t.tm_sec;

	_hourAngle = (_hour % 12) * 30 + _minute / 2;

	if (_oldHour != _hour)  {
		plotHands();
		chime();
	}

	if (_oldMinute != _minute)
		plotHands();

	if ((_hour == 0) && (_oldHour != 0) && (_oldHour != 17717)) {
		Common::String tmpStr = Common::String::format("Good morning!%c%cYes, it's just past " \
			"midnight. Are you having an all-night Avvy session? Glad you like the game that much!", 
			Scrolls::kControlNewLine, Scrolls::kControlNewLine);
		_vm->_scrolls->displayText(tmpStr);
	}
	_oldHour = _hour;
	_oldHourAngle = _hourAngle;
	_oldMinute = _minute;
}

void Clock::calcHand(uint16 angle, uint16 length, Common::Point &endPoint, byte color) {
	if (angle > 900) {
		endPoint.x = 177;
		return;
	}

	endPoint = _vm->_graphics->drawArc(_vm->_graphics->_surface, kCenterX, kCenterY, 449 - angle, 450 - angle, length, color);
}

void Clock::drawHand(const Common::Point &endPoint, byte color) {
	if (endPoint.x == 177)
		return;

	_vm->_graphics->_surface.drawLine(kCenterX, kCenterY, endPoint.x, endPoint.y, color);
}

void Clock::plotHands() {
	calcHand(_oldHourAngle, 14, _clockHandHour, kColorYellow);
	calcHand(_oldMinute * 6, 17, _clockHandMinute, kColorYellow);
	drawHand(_clockHandHour, kColorBrown);
	drawHand(_clockHandMinute, kColorBrown);

	calcHand(_hourAngle, 14, _clockHandHour, kColorBrown);
	calcHand(_minute * 6, 17, _clockHandMinute, kColorBrown);
	drawHand(_clockHandHour, kColorYellow);
	drawHand(_clockHandMinute, kColorYellow);
}

void Clock::chime() {
	warning("STUB: Clock::chime()");
}

Lucerna::Lucerna(AvalancheEngine *vm) : _fxHidden(false), _clock(vm) {
	_vm = vm;
}

Lucerna::~Lucerna() {
	for (int i = 0; i < 31; i++) {
		for (int j = 0; j < 2; j++) {
			if (_vm->_gyro->_also[i][j] != 0)  {
				delete _vm->_gyro->_also[i][j];
				_vm->_gyro->_also[i][j] = 0;
			}
		}
	}
}

void Lucerna::init() {
	for (int i = 0; i < 31; i++) {
		for (int j = 0; j < 2; j++)
			_vm->_gyro->_also[i][j] = 0;
	}

#if 0
	if (_vm->_enhanced->atbios)
		_vm->_gyro->atkey = "f1";
	else
		_vm->_gyro->atkey = "alt-";
#endif
}

/**
 * Call a given Verb
 * @remarks	Originally called 'callverb'
 */
void Lucerna::callVerb(byte id) {
	if (id == _vm->_acci->kPardon) {
		Common::String tmpStr = Common::String::format("The f5 key lets you do a particular action in certain " \
			"situations. However, at the moment there is nothing assigned to it. You may press alt-A to see " \
			"what the current setting of this key is.");
		_vm->_scrolls->displayText(tmpStr);
	} else {
		_vm->_gyro->_weirdWord = false;
		_vm->_acci->_polite = true;
		_vm->_acci->_verb = id;
		_vm->_acci->doThat();
	}
}

void Lucerna::drawAlsoLines() {
	CursorMan.showMouse(false);

	_vm->_graphics->_magics.fillRect(Common::Rect(0, 0, 640, 200), 0);
	_vm->_graphics->_magics.frameRect(Common::Rect(0, 45, 640, 161), 15);

	for (int i = 0; i < _vm->_gyro->_lineNum; i++) {
		// We had to check if the lines are within the borders of the screen.
		if ((_vm->_gyro->_lines[i]._x1 >= 0) && (_vm->_gyro->_lines[i]._x1 < _vm->_graphics->kScreenWidth) && (_vm->_gyro->_lines[i]._y1 >= 0) && (_vm->_gyro->_lines[i]._y1 < _vm->_graphics->kScreenHeight)
		 && (_vm->_gyro->_lines[i]._x2 >= 0) && (_vm->_gyro->_lines[i]._x2 < _vm->_graphics->kScreenWidth) && (_vm->_gyro->_lines[i]._y2 >= 0) && (_vm->_gyro->_lines[i]._y2 < _vm->_graphics->kScreenHeight))
			_vm->_graphics->_magics.drawLine(_vm->_gyro->_lines[i]._x1, _vm->_gyro->_lines[i]._y1, _vm->_gyro->_lines[i]._x2, _vm->_gyro->_lines[i]._y2, _vm->_gyro->_lines[i]._color);
	}

	CursorMan.showMouse(true);
}

// readAlsoStringFromFile, scram and unScramble are only used in loadAlso

/**
 * Check is it's possible to give something to Spludwick
 * @remarks	Originally called 'nextstring'
 */
Common::String Lucerna::readAlsoStringFromFile() {
	Common::String str;
	byte length = file.readByte();
	for (int i = 0; i < length; i++)
		str += file.readByte();
	return str;
}

void Lucerna::scram(Common::String &str) {
	for (uint i = 0; i < str.size(); i++)
		str.setChar(str[i] ^ 177, i);
}

void Lucerna::unScramble() {
	for (int i = 0; i < 31; i++) {
		for (int j = 0; j < 2; j++) {
			if (_vm->_gyro->_also[i][j] != 0)
				scram(*_vm->_gyro->_also[i][j]);
		}
	}
	scram(_vm->_gyro->_listen);
	scram(_vm->_gyro->_flags);
}

void Lucerna::loadAlso(byte num) {
	for (int i = 0; i < 31; i++) {
		for (int j = 0; j < 2; j++) {
			if (_vm->_gyro->_also[i][j] != 0)  {
				delete _vm->_gyro->_also[i][j];
				_vm->_gyro->_also[i][j] = 0;
			}
		}
	}
	Common::String filename;
	filename = Common::String::format("also%d.avd", num);
	if (!file.open(filename))
		error("AVALANCHE: Lucerna: File not found: %s", filename.c_str());

	file.seek(128);

	byte alsoNum = file.readByte();
	Common::String tmpStr;
	for (int i = 0; i <= alsoNum; i++) {
		for (int j = 0; j < 2; j++) {
			_vm->_gyro->_also[i][j] = new Common::String;
			*_vm->_gyro->_also[i][j] = readAlsoStringFromFile();
		}
		tmpStr = Common::String::format("\x9D%s\x9D", _vm->_gyro->_also[i][0]->c_str());
		*_vm->_gyro->_also[i][0] = tmpStr;
	}

	memset(_vm->_gyro->_lines, 0xFF, sizeof(_vm->_gyro->_lines));

	_vm->_gyro->_lineNum = file.readByte();
	for (int i = 0; i < _vm->_gyro->_lineNum; i++) {
		LineType *curLine = &_vm->_gyro->_lines[i];
		curLine->_x1 = file.readSint16LE();
		curLine->_y1 = file.readSint16LE();
		curLine->_x2 = file.readSint16LE();
		curLine->_y2 = file.readSint16LE();
		curLine->_color = file.readByte();
	}

	memset(_vm->_gyro->_peds, 177, sizeof(_vm->_gyro->_peds));
	byte pedNum = file.readByte();
	for (int i = 0; i < pedNum; i++) {
		PedType *curPed = &_vm->_gyro->_peds[i];
		curPed->_x = file.readSint16LE();
		curPed->_y = file.readSint16LE();
		curPed->_direction = file.readByte();
	}

	_vm->_gyro->_fieldNum = file.readByte();
	for (int i = 0; i < _vm->_gyro->_fieldNum; i++) {
		FieldType *curField = &_vm->_gyro->_fields[i];
		curField->_x1 = file.readSint16LE();
		curField->_y1 = file.readSint16LE();
		curField->_x2 = file.readSint16LE();
		curField->_y2 = file.readSint16LE();
	}

	for (int i = 0; i < 15; i++) {
		MagicType *magic = &_vm->_gyro->_magics[i];
		magic->_operation = file.readByte();
		magic->_data = file.readUint16LE();
	}

	for (int i = 0; i < 7; i++) {
		MagicType *portal = &_vm->_gyro->_portals[i];
		portal->_operation = file.readByte();
		portal->_data = file.readUint16LE();
	}

	_vm->_gyro->_flags.clear();
	for (int i = 0;  i < 26; i++)
		_vm->_gyro->_flags += file.readByte();

	int16 listen_length = file.readByte();
	_vm->_gyro->_listen.clear();
	for (int i = 0; i < listen_length; i++)
		_vm->_gyro->_listen += file.readByte();

	drawAlsoLines();

	file.close();
	unScramble();
	for (int i = 0; i <= alsoNum; i++) {
		tmpStr = Common::String::format(",%s,", _vm->_gyro->_also[i][0]->c_str());
		*_vm->_gyro->_also[i][0] = tmpStr;
	}
}

void Lucerna::loadRoom(byte num) {
	CursorMan.showMouse(false);

	_vm->_graphics->fleshColors();

	Common::String filename = Common::String::format("place%d.avd", num);
	if (!file.open(filename))
		error("AVALANCHE: Lucerna: File not found: %s", filename.c_str());

	file.seek(146);
	if (!_vm->_gyro->_roomnName.empty())
		_vm->_gyro->_roomnName.clear();
	for (int i = 0; i < 30; i++) {
		char actChar = file.readByte();
		if ((32 <= actChar) && (actChar <= 126))
			_vm->_gyro->_roomnName += actChar;
	}
	// Compression method byte follows this...

	file.seek(177);

	_vm->_graphics->_background = _vm->_graphics->loadPictureRow(file, _vm->_graphics->kBackgroundWidth, _vm->_graphics->kBackgroundHeight);
	_vm->_graphics->refreshBackground();

	file.close();

	loadAlso(num);
	_vm->_background->loadBackgroundSprites(num);
	CursorMan.showMouse(true);
}

void Lucerna::zoomOut(int16 x, int16 y) {
	warning("STUB: Lucerna::zoomout()");
}

void Lucerna::findPeople(byte room) {
	for (int i = 1; i < 29; i++) {
		if (_vm->_gyro->_whereIs[i] == room) {
			if (i < 25)
				_vm->_gyro->_him = i + 150;
			else
				_vm->_gyro->_her = i + 150;
		}
	}
}

void Lucerna::exitRoom(byte x) {
	_vm->_sound->stopSound();
	_vm->_background->forgetBackgroundSprites();
	_vm->_gyro->_seeScroll = true;  // This stops the trippancy system working over the length of this procedure.

	switch (x) {
	case kRoomSpludwicks:
		_vm->_timer->loseTimer(Timer::kReasonAvariciusTalks);
		 _vm->_gyro->_avariciusTalk = 0;
		// He doesn't HAVE to be talking for this to work. It just deletes it IF it exists.
		break;
	case kRoomBridge:
		if (_vm->_gyro->_drawbridgeOpen > 0) {
			_vm->_gyro->_drawbridgeOpen = 4; // Fully open.
			_vm->_timer->loseTimer(Timer::kReasonDrawbridgeFalls);
		}
		break;
	case kRoomOutsideCardiffCastle:
		_vm->_timer->loseTimer(Timer::kReasonCardiffsurvey);
		break;
	case kRoomRobins:
		_vm->_timer->loseTimer(Timer::kReasonGettingTiedUp);
		break;
	}

	_vm->_gyro->_interrogation = 0; // Leaving the room cancels all the questions automatically.
	_vm->_gyro->_seeScroll = false; // Now it can work again!

	_vm->_gyro->_lastRoom = _vm->_gyro->_room;
	if (_vm->_gyro->_room != kRoomMap)
		_vm->_gyro->_lastRoomNotMap = _vm->_gyro->_room;
}


/**
 * Only when entering a NEW town! Not returning to the last one,
 * but choosing another from the map.
 * @remarks	Originally called 'new_town'
 */
void Lucerna::enterNewTown() {
	_vm->_menu->setup();

	switch (_vm->_gyro->_room) {
	case kRoomOutsideNottsPub: // Entry into Nottingham.
		if ((_vm->_gyro->_roomCount[kRoomRobins] > 0) && (_vm->_gyro->_beenTiedUp) && (!_vm->_gyro->_takenMushroom))
			_vm->_gyro->_mushroomGrowing = true;
		break;
	case kRoomWiseWomans: // Entry into Argent.
		if (_vm->_gyro->_talkedToCrapulus && (!_vm->_gyro->_lustieIsAsleep)) {
			_vm->_gyro->_spludwickAtHome = !((_vm->_gyro->_roomCount[kRoomWiseWomans] % 3) == 1);
			_vm->_gyro->_crapulusWillTell = !_vm->_gyro->_spludwickAtHome;
		} else {
			_vm->_gyro->_spludwickAtHome = true;
			_vm->_gyro->_crapulusWillTell = false;
		}
		if (_vm->_gyro->_boxContent == Gyro::kObjectWine)
			_vm->_gyro->_wineState = 3; // Vinegar
		break;
	}

	if (_vm->_gyro->_room != kRoomOutsideDucks) {
		if ((_vm->_gyro->_objects[Gyro::kObjectOnion - 1]) && !(_vm->_gyro->_onionInVinegar))
			_vm->_gyro->_rottenOnion = true; // You're holding the onion
	}
}

void Lucerna::putGeidaAt(byte whichPed, byte ped) {
	if (ped == 0)
		return;
	AnimationType *spr1 = &_vm->_animation->_sprites[1];

	spr1->init(5, false, _vm->_animation); // load Geida
	_vm->_animation->appearPed(1, whichPed);
	spr1->_callEachStepFl = true;
	spr1->_eachStepProc = Animation::kProcGeida;
}

void Lucerna::enterRoom(byte room, byte ped) {
	_vm->_gyro->_seeScroll = true;  // This stops the trippancy system working over the length of this procedure.

	findPeople(room);
	_vm->_gyro->_room = room;
	if (ped != 0)
		_vm->_gyro->_roomCount[room]++;

	loadRoom(room);

	if ((_vm->_gyro->_roomCount[room] == 0) && (!_vm->_gyro->setFlag('S')))
		incScore(1);

	_vm->_gyro->_whereIs[Gyro::kPeopleAvalot - 150] = _vm->_gyro->_room;

	if (_vm->_gyro->_geidaFollows)
		_vm->_gyro->_whereIs[Gyro::kPeopleGeida - 150] = room;

	_vm->_gyro->_roomTime = 0;


	if ((_vm->_gyro->_lastRoom == kRoomMap) && (_vm->_gyro->_lastRoomNotMap != _vm->_gyro->_room))
		enterNewTown();


	switch (room) {
	case kRoomYours:
		if (_vm->_gyro->_avvyInBed) {
			_vm->_background->drawBackgroundSprite(-1, -1, 2);
			_vm->_graphics->refreshBackground();
			_vm->_timer->addTimer(100, Timer::kProcArkataShouts, Timer::kReasonArkataShouts);
		}
		break;

	case kRoomOutsideYours:
		if (ped > 0) {
			AnimationType *spr1 = &_vm->_animation->_sprites[1];
			if (!_vm->_gyro->_talkedToCrapulus) {
				_vm->_gyro->_whereIs[Gyro::kPeopleCrapulus - 150] = kRoomOutsideYours;
				spr1->init(8, false, _vm->_animation); // load Crapulus

				if (_vm->_gyro->_roomCount[kRoomOutsideYours] == 1) {
					_vm->_animation->appearPed(1, 3); // Start on the right-hand side of the screen.
					spr1->walkTo(4); // Walks up to greet you.
				} else {
					_vm->_animation->appearPed(1, 4); // Starts where he was before.
					spr1->_facingDir = Animation::kDirLeft;
				}

				spr1->_callEachStepFl = true;
				spr1->_eachStepProc = Animation::kProcFaceAvvy; // He always faces Avvy.

			} else
				_vm->_gyro->_whereIs[Gyro::kPeopleCrapulus - 150] = kRoomNowhere;

			if (_vm->_gyro->_crapulusWillTell) {
				spr1->init(8, false, _vm->_animation);
				_vm->_animation->appearPed(1, 1);
				spr1->walkTo(3);
				_vm->_timer->addTimer(20, Timer::kProcCrapulusSpludOut, Timer::kReasonCrapulusSaysSpludwickOut);
				_vm->_gyro->_crapulusWillTell = false;
			}
		}
		break;

	case kRoomOutsideSpludwicks:
		if ((_vm->_gyro->_roomCount[kRoomOutsideSpludwicks] == 1) && (ped == 1)) {
			_vm->_timer->addTimer(20, Timer::kProcBang, Timer::kReasonExplosion);
			_vm->_gyro->_spludwickAtHome = true;
		}
		break;

	case kRoomSpludwicks:
		if (_vm->_gyro->_spludwickAtHome) {
			AnimationType *spr1 = &_vm->_animation->_sprites[1];
			if (ped > 0) {
				spr1->init(2, false, _vm->_animation); // load Spludwick
				_vm->_animation->appearPed(1, 1);
				_vm->_gyro->_whereIs[Gyro::kPeopleSpludwick - 150] = kRoomSpludwicks;
			}

			spr1->_callEachStepFl = true;
			spr1->_eachStepProc = Animation::kProcGeida;
		} else
			_vm->_gyro->_whereIs[Gyro::kPeopleSpludwick - 150] = kRoomNowhere;
		break;

	case kRoomBrummieRoad:
		if (_vm->_gyro->_geidaFollows)
			putGeidaAt(4, ped);
		if (_vm->_gyro->_cwytalotGone) {
			_vm->_gyro->_magics[kColorLightred - 1]._operation = Gyro::kMagicNothing;
			_vm->_gyro->_whereIs[Gyro::kPeopleCwytalot - 150] = kRoomNowhere;
		} else {
			if (ped > 0) {
				AnimationType *spr1 = &_vm->_animation->_sprites[1];
				spr1->init(4, false, _vm->_animation); // 4 = Cwytalot
				spr1->_callEachStepFl = true;
				spr1->_eachStepProc = Animation::kProcFollowAvvyY;
				_vm->_gyro->_whereIs[Gyro::kPeopleCwytalot - 150] = kRoomBrummieRoad;

				if (_vm->_gyro->_roomCount[kRoomBrummieRoad] == 1) { // First time here...
					_vm->_animation->appearPed(1, 1); // He appears on the right of the screen...
					spr1->walkTo(3); // ...and he walks up...
				} else {
					// You've been here before.
					_vm->_animation->appearPed(1, 3); // He's standing in your way straight away...
					spr1->_facingDir = Animation::kDirLeft;
				}
			}
		}
		break;

	case kRoomArgentRoad:
		if ((_vm->_gyro->_cwytalotGone) && (!_vm->_gyro->_passedCwytalotInHerts) && (ped == 2) && (_vm->_gyro->_roomCount[kRoomArgentRoad] > 3)) {
			AnimationType *spr1 = &_vm->_animation->_sprites[1];
			spr1->init(4, false, _vm->_animation); // 4 = Cwytalot again
			_vm->_animation->appearPed(1, 0);
			spr1->walkTo(1);
			spr1->_vanishIfStill = true;
			_vm->_gyro->_passedCwytalotInHerts = true;
			// _vm->_gyro->whereis[#157] = r__Nowhere; // can we fit this in?
			_vm->_timer->addTimer(20, Timer::kProcCwytalotInHerts, Timer::kReasonCwytalotInHerts);
		}
		break;

	case kRoomBridge:
		if (_vm->_gyro->_drawbridgeOpen == 4) { // open
			_vm->_background->drawBackgroundSprite(-1, -1, 2); // Position of drawbridge
			_vm->_graphics->refreshBackground();
			_vm->_gyro->_magics[kColorGreen - 1]._operation = Gyro::kMagicNothing; // You may enter the drawbridge.
		}
		if (_vm->_gyro->_geidaFollows)
			putGeidaAt(ped + 2, ped); // load Geida
		break;

	case kRoomRobins:
		if (ped > 0) {
			if (!_vm->_gyro->_beenTiedUp) {
				// A welcome party... or maybe not...
				AnimationType *spr1 = &_vm->_animation->_sprites[1];
				spr1->init(6, false, _vm->_animation);
				_vm->_animation->appearPed(1, 1);
				spr1->walkTo(2);
				_vm->_timer->addTimer(36, Timer::kProcGetTiedUp, Timer::kReasonGettingTiedUp);
			}
		}

		if (_vm->_gyro->_beenTiedUp) {
			_vm->_gyro->_whereIs[Gyro::kPeopleRobinHood - 150] = 0;
			_vm->_gyro->_whereIs[Gyro::kPeopleFriarTuck - 150] = 0;
		}

		if (_vm->_gyro->_tiedUp)
			_vm->_background->drawBackgroundSprite(-1, -1, 1);

		if (!_vm->_gyro->_mushroomGrowing)
			_vm->_background->drawBackgroundSprite(-1, -1, 2);
		_vm->_graphics->refreshBackground();
		break;

	case kRoomOutsideCardiffCastle:
		if (ped > 0) {
			AnimationType *spr1 = &_vm->_animation->_sprites[1];
			switch (_vm->_gyro->_cardiffQuestionNum) {
			case 0 : // You've answered NONE of his questions.
				spr1->init(9, false, _vm->_animation);
				_vm->_animation->appearPed(1, 1);
				spr1->walkTo(2);
				_vm->_timer->addTimer(47, Timer::kProcCardiffSurvey, Timer::kReasonCardiffsurvey);
				break;
			case 5 :
				_vm->_gyro->_magics[1]._operation = Gyro::kMagicNothing;
				break; // You've answered ALL his questions. => nothing happens.
			default: // You've answered SOME of his questions.
				spr1->init(9, false, _vm->_animation);
				_vm->_animation->appearPed(1, 2);
				spr1->_facingDir = Animation::kDirRight;
				_vm->_timer->addTimer(3, Timer::kProcCardiffReturn, Timer::kReasonCardiffsurvey);
			}
		}

		if (_vm->_gyro->_cardiffQuestionNum < 5)
			_vm->_gyro->_interrogation = _vm->_gyro->_cardiffQuestionNum;
		else
			_vm->_gyro->_interrogation = 0;
		break;

	case kRoomMap:
		// You're entering the map.
		dawn();
		//setactivepage(cp);
		if (ped > 0)
			zoomOut(_vm->_gyro->_peds[ped]._x, _vm->_gyro->_peds[ped]._y);
		//setactivepage(1 - cp);

		if ((_vm->_gyro->_objects[Gyro::kObjectWine - 1]) && (_vm->_gyro->_wineState != 3)) {
			_vm->_scrolls->displayScrollChain('q', 9); // Don't want to waste the wine!
			_vm->_gyro->_objects[Gyro::kObjectWine - 1] = false;
			refreshObjectList();
		}

		_vm->_scrolls->displayScrollChain('q', 69);
		break;

	case kRoomCatacombs:
		if ((ped == 0) || (ped == 3) || (ped == 5) || (ped == 6)) {

			switch (ped) {
			case 3: // Enter from oubliette
				_vm->_gyro->_catacombX = 8;
				_vm->_gyro->_catacombY = 4;
				break;
			case 5: // Enter from du Lustie's
				_vm->_gyro->_catacombX = 8;
				_vm->_gyro->_catacombY = 7;
				break;
			case 6: // Enter from Geida's
				_vm->_gyro->_catacombX = 4;
				_vm->_gyro->_catacombY = 1;
				break;
			}

			_vm->_gyro->_enterCatacombsFromLustiesRoom = true;
			_vm->_animation->catacombMove(ped);
			_vm->_gyro->_enterCatacombsFromLustiesRoom = false;
		}
		break;

	case kRoomArgentPub:
		if (_vm->_gyro->_wonNim)
			_vm->_background->drawBackgroundSprite(-1, -1, 0);   // No lute by the settle.
		_vm->_gyro->_malagauche = 0; // Ready to boot Malagauche
		if (_vm->_gyro->_givenBadgeToIby) {
			_vm->_background->drawBackgroundSprite(-1, -1, 7);
			_vm->_background->drawBackgroundSprite(-1, -1, 8);
		}
		_vm->_graphics->refreshBackground();
		break;

	case kRoomLustiesRoom:
		_vm->_gyro->_npcFacing = 1; // du Lustie.
		if (_vm->_animation->_sprites[0]._id == 0) // Avvy in his normal clothes
			_vm->_timer->addTimer(3, Timer::kProcCallsGuards, Timer::kReasonDuLustieTalks);
		else if (!_vm->_gyro->_enteredLustiesRoomAsMonk) // already
			// Presumably, Avvy dressed as a monk.
			_vm->_timer->addTimer(3, Timer::kProcGreetsMonk, Timer::kReasonDuLustieTalks);

		if (_vm->_gyro->_geidaFollows) {
			putGeidaAt(4, ped);
			if (_vm->_gyro->_lustieIsAsleep) {
				_vm->_background->drawBackgroundSprite(-1, -1, 4);
				_vm->_graphics->refreshBackground();
			}
		}
		break;

	case kRoomMusicRoom:
		if (_vm->_gyro->_jacquesState > 0) {
			_vm->_gyro->_jacquesState = 5;
			_vm->_background->drawBackgroundSprite(-1, -1, 1);
			_vm->_graphics->refreshBackground();
			_vm->_background->drawBackgroundSprite(-1, -1, 3);
			_vm->_gyro->_magics[kColorBrown - 1]._operation = Gyro::kMagicNothing;
			_vm->_gyro->_whereIs[Gyro::kPeopleJacques - 150] = 0;
		}
		if (ped != 0) {
			_vm->_background->drawBackgroundSprite(-1, -1, 5);
			_vm->_graphics->refreshBackground();
			_vm->_sequence->firstShow(6);
			_vm->_sequence->thenShow(5);
			_vm->_sequence->thenShow(7);
			_vm->_sequence->startToClose();
		}
		break;

	case kRoomOutsideNottsPub:
		if (ped == 2) {
			_vm->_background->drawBackgroundSprite(-1, -1, 2);
			_vm->_graphics->refreshBackground();
			_vm->_sequence->firstShow(3);
			_vm->_sequence->thenShow(2);
			_vm->_sequence->thenShow(1);
			_vm->_sequence->thenShow(4);
			_vm->_sequence->startToClose();
		}
		break;

	case kRoomOutsideArgentPub:
		if (ped == 2)  {
			_vm->_background->drawBackgroundSprite(-1, -1, 5);
			_vm->_graphics->refreshBackground();
			_vm->_sequence->firstShow(6);
			_vm->_sequence->thenShow(5);
			_vm->_sequence->thenShow(7);
			_vm->_sequence->startToClose();
		}
		break;

	case kRoomWiseWomans: {
		AnimationType *spr1 = &_vm->_animation->_sprites[1];
		spr1->init(11, false, _vm->_animation);
		if ((_vm->_gyro->_roomCount[kRoomWiseWomans] == 1) && (ped > 0)) {
			_vm->_animation->appearPed(1, 1); // Start on the right-hand side of the screen.
			spr1->walkTo(3); // Walks up to greet you.
		} else {
			_vm->_animation->appearPed(1, 3); // Starts where she was before.
			spr1->_facingDir = Animation::kDirLeft;
		}

		spr1->_callEachStepFl = true;
		spr1->_eachStepProc = Animation::kProcFaceAvvy; // She always faces Avvy.
		}
		break;

	case kRoomInsideCardiffCastle:
		if (ped > 0) {
			_vm->_animation->_sprites[1].init(10, false, _vm->_animation); // Define the dart.
			_vm->_background->drawBackgroundSprite(-1, -1, 0);
			_vm->_graphics->refreshBackground();
			_vm->_sequence->firstShow(1);
			if (_vm->_gyro->_arrowInTheDoor)
				_vm->_sequence->thenShow(3);
			else
				_vm->_sequence->thenShow(2);

			if (_vm->_gyro->_takenPen)
				_vm->_background->drawBackgroundSprite(-1, -1, 3);

			_vm->_sequence->startToClose();
		} else {
			_vm->_background->drawBackgroundSprite(-1, -1, 0);
			if (_vm->_gyro->_arrowInTheDoor)
				_vm->_background->drawBackgroundSprite(-1, -1, 2);
			else
				_vm->_background->drawBackgroundSprite(-1, -1, 1);
			_vm->_graphics->refreshBackground();
		}
		break;

	case kRoomAvvysGarden:
		if (ped == 1)  {
			_vm->_background->drawBackgroundSprite(-1, -1, 1);
			_vm->_graphics->refreshBackground();
			_vm->_sequence->firstShow(2);
			_vm->_sequence->thenShow(1);
			_vm->_sequence->thenShow(3);
			_vm->_sequence->startToClose();
		}
		break;

	case kRoomEntranceHall:
	case kRoomInsideAbbey:
	case kRoomYourHall:
		if (ped == 2)  {
#if 0
			// It was the original:
			_vm->_celer->show_one(-1, -1, 2);
			_vm->_sequence->first_show(1);
			_vm->_sequence->then_show(3);
			_vm->_sequence->start_to_close();
#endif

			_vm->_background->drawBackgroundSprite(-1, -1, 1);
			_vm->_graphics->refreshBackground();
			_vm->_sequence->firstShow(2);
			_vm->_sequence->thenShow(1);
			_vm->_sequence->thenShow(3);
			_vm->_sequence->startToClose();
		}
		break;

	case kRoomAylesOffice:
		if (_vm->_gyro->_aylesIsAwake)
			_vm->_background->drawBackgroundSprite(-1, -1, 1);
		_vm->_graphics->refreshBackground();
		break; // Ayles awake.

	case kRoomGeidas:
		putGeidaAt(1, ped);
		break; // load Geida

	case kRoomEastHall:
	case kRoomWestHall:
		if (_vm->_gyro->_geidaFollows)
			putGeidaAt(ped + 1, ped);
		break;

	case kRoomLusties:
		if (_vm->_gyro->_geidaFollows)
			putGeidaAt(ped + 5, ped);
		break;

	case kRoomNottsPub:
		if (_vm->_gyro->_sittingInPub)
			_vm->_background->drawBackgroundSprite(-1, -1, 2);
		_vm->_gyro->_npcFacing = 1; // Port.
		break;

	case kRoomOutsideDucks:
		if (ped == 2) {
			// Shut the door
			_vm->_background->drawBackgroundSprite(-1, -1, 2);
			_vm->_graphics->refreshBackground();
			_vm->_sequence->firstShow(3);
			_vm->_sequence->firstShow(2);
			_vm->_sequence->thenShow(1);
			_vm->_sequence->thenShow(4);
			_vm->_sequence->startToClose();
		}
		break;

	case kRoomDucks:
		_vm->_gyro->_npcFacing = 1; // Duck.
		break; 
	}

	_vm->_gyro->_seeScroll = false; // Now it can work again!
	_vm->_gyro->_isLoaded = false;
}

void Lucerna::thinkAbout(byte object, bool type) {
	const int16 picSize = 966;

	_vm->_gyro->_thinks = object;
	object--;

	_vm->_gyro->setMousePointerWait();

	if (type == Gyro::kThing) {
		if (!file.open("thinks.avd"))
			error("AVALANCHE: Lucerna: File not found: thinks.avd");
	} else { // Gyro::kPerson
		if (!file.open("folk.avd"))
			error("AVALANCHE: Lucerna: File not found: folk.avd");

		object -= 149;
		if (object >= 25)
			object -= 8;
		if (object == 20)
			object--; // Last time...
	}

	file.seek(object * picSize + 65);
	::Graphics::Surface picture = _vm->_graphics->loadPictureGraphic(file);
	_vm->_graphics->drawPicture(_vm->_graphics->_surface, picture, 205, 170);

	picture.free();
	file.close();

	CursorMan.showMouse(false);

#if 0
	setactivepage(3);
	putimage(x, y, p, 0);
	setactivepage(1 - cp);
#endif

	CursorMan.showMouse(true);
	_vm->_gyro->_thinkThing = type;
}

void Lucerna::loadDigits() {   // Load the scoring digits & rwlites
	const byte digitsize = 134;
	const byte rwlitesize = 126;

	if (!file.open("digit.avd"))
		error("AVALANCHE: Lucerna: File not found: digit.avd");

	for (int i = 0; i < 10; i++) {
		file.seek(i * digitsize);
		_vm->_gyro->_digits[i] = _vm->_graphics->loadPictureGraphic(file);
	}

	for (int i = 0; i < 9; i++) {
		file.seek(10 * digitsize + i * rwlitesize);
		_vm->_gyro->_directions[i] = _vm->_graphics->loadPictureGraphic(file);
	}

	file.close();
}

void Lucerna::drawToolbar() {
	if (!file.open("useful.avd"))
		error("AVALANCHE: Lucerna: File not found: useful.avd");

	file.seek(40);

	CursorMan.showMouse(false);
	::Graphics::Surface picture = _vm->_graphics->loadPictureGraphic(file);
	_vm->_graphics->drawPicture(_vm->_graphics->_surface, picture, 5, 169);

	picture.free();
	file.close();

	CursorMan.showMouse(true);
	_vm->_animation->_oldDirection = 177;
	drawDirection();
}

void Lucerna::drawScore() {
	uint16 score = _vm->_gyro->_dnascore;
	int8 numbers[3] = {0, 0, 0};
	for (int i = 0; i < 2; i++) {
		byte divisor = 1;
		for (int j = 0; j < (2 - i); j++)
			divisor *= 10;
		numbers[i] = score / divisor;
		score -= numbers[i] * divisor;
	}
	numbers[2] = score;

	CursorMan.showMouse(false);

	for (int i = 0; i < 3; i++) {
		if (_vm->_gyro->_scoreToDisplay[i] != numbers[i])
			_vm->_graphics->drawPicture(_vm->_graphics->_surface, _vm->_gyro->_digits[numbers[i]], 250 + (i + 1) * 15, 177);
	}

	CursorMan.showMouse(true);

	for (int i = 0; i < 3; i++)
		_vm->_gyro->_scoreToDisplay[i] = numbers[i];
}

void Lucerna::incScore(byte num) {     // Add on no. of points
	for (int i = 1; i <= num; i++) {
		_vm->_gyro->_dnascore++;

//		if (soundfx) {
			for (int j = 1; j <= 97; j++)
				// Length os 2 is a guess, the original doesn't have a delay specified
				_vm->_sound->playNote(177 + _vm->_gyro->_dnascore * 3, 2);
//		}
	}
	warning("STUB: Lucerna::points()");

	drawScore();
}

void Lucerna::useCompass(const Common::Point &cursorPos) {
	byte color = *(byte *)_vm->_graphics->_surface.getBasePtr(cursorPos.x, cursorPos.y / 2);

	switch (color) {
	case kColorGreen:
		_vm->_animation->_direction = Animation::kDirUp;
		_vm->_animation->changeDirection(0, Animation::kDirUp);
		drawDirection();
		break;
	case kColorBrown:
		_vm->_animation->_direction = Animation::kDirDown;
		_vm->_animation->changeDirection(0, Animation::kDirDown);
		drawDirection();
		break;
	case kColorCyan:
		_vm->_animation->_direction = Animation::kDirLeft;
		_vm->_animation->changeDirection(0, Animation::kDirLeft);
		drawDirection();
		break;
	case kColorLightmagenta:
		_vm->_animation->_direction = Animation::kDirRight;
		_vm->_animation->changeDirection(0, Animation::kDirRight);
		drawDirection();
		break;
	case kColorRed:
	case kColorWhite:
	case kColorLightcyan:
	case kColorYellow: // Fall-throughs are intended.
		_vm->_animation->stopWalking();
		drawDirection();
		break;
	}
}

void Lucerna::fxToggle() {
	warning("STUB: Lucerna::fxtoggle()");
}

void Lucerna::refreshObjectList() {
	_vm->_gyro->_carryNum = 0;
	if (_vm->_gyro->_thinkThing && !_vm->_gyro->_objects[_vm->_gyro->_thinks - 1])
		thinkAbout(Gyro::kObjectMoney, Gyro::kThing); // you always have money

	for (int i = 0; i < kObjectNum; i++) {
		if (_vm->_gyro->_objects[i]) {
			_vm->_gyro->_objectList[_vm->_gyro->_carryNum] = i + 1;
			_vm->_gyro->_carryNum++;
		}
	}
}

/**
 * @remarks	Originally called 'verte'
 */
void Lucerna::guideAvvy(Common::Point cursorPos) {
	if (!_vm->_gyro->_userMovesAvvy)
		return;

	cursorPos.y /= 2;
	byte what;

	// _vm->_animation->tr[0] is Avalot.)
	AnimationType *avvy = &_vm->_animation->_sprites[0];
	if (cursorPos.x < avvy->_x)
		what = 1;
	else if (cursorPos.x > (avvy->_x + avvy->_info._xLength))
		what = 2;
	else
		what = 0; // On top

	if (cursorPos.y < avvy->_y)
		what += 3;
	else if (cursorPos.y > (avvy->_y + avvy->_info._yLength))
		what += 6;

	switch (what) {
	case 0:
		_vm->_animation->stopWalking();
		break; // Clicked on Avvy: no movement.
	case 1:
		_vm->_animation->changeDirection(0, Animation::kDirLeft);
		break;
	case 2:
		_vm->_animation->changeDirection(0, Animation::kDirRight);
		break;
	case 3:
		_vm->_animation->changeDirection(0, Animation::kDirUp);
		break;
	case 4:
		_vm->_animation->changeDirection(0, Animation::kDirUpLeft);
		break;
	case 5:
		_vm->_animation->changeDirection(0, Animation::kDirUpRight);
		break;
	case 6:
		_vm->_animation->changeDirection(0, Animation::kDirDown);
		break;
	case 7:
		_vm->_animation->changeDirection(0, Animation::kDirDownLeft);
		break;
	case 8:
		_vm->_animation->changeDirection(0, Animation::kDirDownRight);
		break;
	}    // No other values are possible.

	drawDirection();
}

void Lucerna::checkClick() {
	Common::Point cursorPos = _vm->getMousePos();
	_vm->_gyro->_onToolbar = _vm->_gyro->kSlowComputer && ((cursorPos.y >= 169) || (cursorPos.y <= 10));

	/*if (_vm->_gyro->mrelease > 0)
	_vm->_gyro->after_the_scroll = false;*/

	if ((0 <= cursorPos.y) && (cursorPos.y <= 21))
		_vm->_gyro->newMouse(0); // up arrow
	else if ((317 <= cursorPos.y) && (cursorPos.y <= 339))
		_vm->_gyro->newMouse(7); //I-beam
	else if ((340 <= cursorPos.y) && (cursorPos.y <= 399))
		_vm->_gyro->newMouse(1); // screwdriver
	else if (!_vm->_menu->isActive()) { // Dropdown can handle its own pointers.
		if (_holdLeftMouse) {
			_vm->_gyro->newMouse(6); // Mark's crosshairs
			guideAvvy(cursorPos); // Normally, if you click on the picture, you're guiding Avvy around.
		} else
			_vm->_gyro->newMouse(3); // fletch
	}

	if (_holdLeftMouse) {
		if ((0 <= cursorPos.y) && (cursorPos.y <= 21)) { // Click on the dropdown menu.
			if (_vm->_gyro->_dropsOk)
				_vm->_menu->update();
		} else if ((317 <= cursorPos.y) && (cursorPos.y <= 339)) { // Click on the command line.
			_vm->_parser->_inputTextPos = (cursorPos.x - 23) / 8;
			if (_vm->_parser->_inputTextPos > _vm->_parser->_inputText.size() + 1)
				_vm->_parser->_inputTextPos = _vm->_parser->_inputText.size() + 1;
			if (_vm->_parser->_inputTextPos < 1)
				_vm->_parser->_inputTextPos = 1;
			_vm->_parser->_inputTextPos--;
			_vm->_parser->plotText();
		} else if ((340 <= cursorPos.y) && (cursorPos.y <= 399)) { // Check the toolbar.
			if ((137 <= cursorPos.x) && (cursorPos.x <= 207)) { // Control Avvy with the compass.
				if (_vm->_gyro->_alive && _vm->_gyro->_avvyIsAwake)
					useCompass(cursorPos);
			} else if ((208 <= cursorPos.x) && (cursorPos.x <= 260)) { // Examine the _thing.
				do {
					_vm->updateEvents();
				} while (_holdLeftMouse);

				if (_vm->_gyro->_thinkThing) {
					_vm->_acci->_thing = _vm->_gyro->_thinks;
					_vm->_acci->_thing += 49;
					_vm->_acci->_person = _vm->_acci->kPardon;
				} else {
					_vm->_acci->_person = _vm->_gyro->_thinks;
					_vm->_acci->_thing = _vm->_acci->kPardon;
				}
				callVerb(Acci::kVerbCodeExam);
			} else if ((261 <= cursorPos.x) && (cursorPos.x <= 319)) { // Display the score.
				do {
					_vm->updateEvents();
				} while (_holdLeftMouse);

				callVerb(Acci::kVerbCodeScore);
			} else if ((320 <= cursorPos.x) && (cursorPos.x <= 357)) { // Change speed.
				_vm->_animation->_sprites[0]._speedX = _vm->_gyro->kWalk;
				_vm->_animation->updateSpeed();
			} else if ((358 <= cursorPos.x) && (cursorPos.x <= 395)) { // Change speed.
				_vm->_animation->_sprites[0]._speedX = _vm->_gyro->kRun;
				_vm->_animation->updateSpeed();
			} else if ((396 <= cursorPos.x) && (cursorPos.x <= 483))
				fxToggle();
			else if ((535 <= cursorPos.x) && (cursorPos.x <= 640))
				_vm->_gyro->_mouseText.insertChar(Scrolls::kControlNewLine, 0);
		} else if (!_vm->_gyro->_dropsOk)
			_vm->_gyro->_mouseText = Common::String(13) + _vm->_gyro->_mouseText;
	}
}

void Lucerna::errorLed() {
	warning("STUB: Lucerna::errorled()");
}

int8 Lucerna::fades(int8 x) {
	warning("STUB: Lucerna::fades()");
	return 0;
}

void Lucerna::fadeOut(byte n) {
	warning("STUB: Lucerna::fadeOut()");
}

void Lucerna::dusk() {
	warning("STUB: Lucerna::dusk()");
}

void Lucerna::fadeIn(byte n) {
	warning("STUB: Lucerna::fadeIn()");
}

void Lucerna::dawn() {
	warning("STUB: Lucerna::dawn()");
}

void Lucerna::drawDirection() { // It's data is loaded in load_digits().
	if (_vm->_animation->_oldDirection == _vm->_animation->_direction)
		return;

	_vm->_animation->_oldDirection = _vm->_animation->_direction;

	CursorMan.showMouse(false);
	_vm->_graphics->drawPicture(_vm->_graphics->_surface, _vm->_gyro->_directions[_vm->_animation->_direction], 0, 161);
	CursorMan.showMouse(true);
}


void Lucerna::gameOver() {
	_vm->_gyro->_userMovesAvvy = false;

	AnimationType *avvy = &_vm->_animation->_sprites[0];
	int16 sx = avvy->_x;
	int16 sy = avvy->_y;

	avvy->remove();
	avvy->init(12, true, _vm->_animation); // 12 = Avalot falls
	avvy->_stepNum = 0;
	avvy->appear(sx, sy, 0);

	_vm->_timer->addTimer(3, Timer::kProcAvalotFalls, Timer::kReasonFallingOver);
	_vm->_gyro->_alive = false;
}

void Lucerna::minorRedraw() {
	dusk();

	enterRoom(_vm->_gyro->_room, 0); // Ped unknown or non-existant.

	for (int i = 0; i < 3; i++)
		_vm->_gyro->_scoreToDisplay[i] = -1; // impossible digits
	drawScore();

	dawn();
}

void Lucerna::majorRedraw() {
	warning("STUB: Lucerna::major_redraw()");
}

uint16 Lucerna::bearing(byte whichPed) {
	static const double rad2deg = 180 / 3.14; // Pi
	AnimationType *avvy = &_vm->_animation->_sprites[0];
	PedType *curPed = &_vm->_gyro->_peds[whichPed];

	if (avvy->_x == curPed->_x)
		return 0;
	else if (avvy->_x < curPed->_x) {
		return (uint16)((atan(double((avvy->_y - curPed->_y)) / (avvy->_x - curPed->_x)) * rad2deg) + 90);
	} else {
		return (uint16)((atan(double((avvy->_y - curPed->_y)) / (avvy->_x - curPed->_x)) * rad2deg) + 270);
	}
}

/** 
 * A sprite run is performed before displaying a scroll, if not all the
 * sprites are still. It performs two fast cycles, only using a few of
 * the links usually used, and without any extra animation. This should
 * make the sprites the same on both pages.
 * @remarks	Originally called 'sprite_run'
 */
void Lucerna::spriteRun() {
	_vm->_gyro->_doingSpriteRun = true;
	_vm->_animation->animLink();
	_vm->_gyro->_doingSpriteRun = false;
}

void Lucerna::fixFlashers() {
	_vm->_gyro->_ledStatus = 177;
	_vm->_animation->_oldDirection = 177;
	_vm->_scrolls->setReadyLight(2);
	drawDirection();
}

} // End of namespace Avalanche