scummvm-cursorfix/engines/nancy/action/conversation.cpp

/* 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/random.h"
#include "common/config-manager.h"
#include "common/serializer.h"
#include "common/memstream.h"

#include "engines/nancy/nancy.h"
#include "engines/nancy/sound.h"
#include "engines/nancy/input.h"
#include "engines/nancy/util.h"
#include "engines/nancy/graphics.h"
#include "engines/nancy/resource.h"

#include "engines/nancy/action/conversation.h"

#include "engines/nancy/state/scene.h"

namespace Nancy {
namespace Action {

ConversationSound::ConversationSound() :
		RenderActionRecord(8),
		_noResponse(g_nancy->getGameType() <= kGameTypeNancy2 ? 10 : 20),
		_hasDrawnTextbox(false),
		_pickedResponse(-1) {
	_conditionalResponseCharacterID = _noResponse;
	_goodbyeResponseCharacterID = _noResponse;
}

ConversationSound::~ConversationSound() {
	if (NancySceneState.getActiveConversation() == this) {
		NancySceneState.setActiveConversation(nullptr);
	}
}

void ConversationSound::init() {
	RenderObject::init();
}

void ConversationSound::readData(Common::SeekableReadStream &stream) {
	Common::Serializer ser(&stream, nullptr);
	ser.setVersion(g_nancy->getGameType());

	if (ser.getVersion() >= kGameTypeNancy2) {
		_sound.readNormal(stream);
	}

	readCaptionText(stream);

	if (ser.getVersion() <= kGameTypeNancy1) {
		_sound.readNormal(stream);
	}

	_responseGenericSound.readNormal(stream);
	ser.skip(1); // RESPONSE_STARTUP_CLEAR_ALL, RESPONSE_STARTUP_KEEP_OLD; never used (tested up to nancy5)
	ser.syncAsByte(_conditionalResponseCharacterID);
	ser.syncAsByte(_goodbyeResponseCharacterID);
	ser.syncAsByte(_defaultNextScene);
	ser.syncAsByte(_popNextScene);
	_sceneChange.readData(stream, ser.getVersion() == kGameTypeVampire);
	ser.skip(0x32, kGameTypeVampire, kGameTypeNancy1);
	ser.skip(2, kGameTypeNancy2);

	uint16 numResponses = 0;
	ser.syncAsUint16LE(numResponses);

	_responses.resize(numResponses);
	for (uint i = 0; i < numResponses; ++i) {
		ResponseStruct &response = _responses[i];
		response.conditionFlags.read(stream);
		readResponseText(stream, response);
		readFilename(stream, response.soundName);
		ser.syncAsByte(response.addRule);
		response.sceneChange.readData(stream, ser.getVersion() == kGameTypeVampire);
		ser.syncAsSint16LE(response.flagDesc.label);
		ser.syncAsByte(response.flagDesc.flag);
		ser.skip(0x32, kGameTypeVampire, kGameTypeNancy1);
		ser.skip(2, kGameTypeNancy2);
	}

	uint16 numSceneBranchStructs = stream.readUint16LE();
	_sceneBranchStructs.resize(numSceneBranchStructs);
	for (uint i = 0; i < numSceneBranchStructs; ++i) {
		_sceneBranchStructs[i].conditions.read(stream);
		_sceneBranchStructs[i].sceneChange.readData(stream, g_nancy->getGameType() == kGameTypeVampire);
		ser.skip(0x32, kGameTypeVampire, kGameTypeNancy1);
		ser.skip(2, kGameTypeNancy2);
	}

	uint16 numFlagsStructs = stream.readUint16LE();
	_flagsStructs.resize(numFlagsStructs);
	for (uint i = 0; i < numFlagsStructs; ++i) {
		FlagsStruct &flagsStruct = _flagsStructs[i];
		flagsStruct.conditions.read(stream);
		flagsStruct.flagToSet.type = stream.readByte();
		flagsStruct.flagToSet.flag.label = stream.readSint16LE();
		flagsStruct.flagToSet.flag.flag = stream.readByte();
	}
}

void ConversationSound::readTerseData(Common::SeekableReadStream &stream) {
	readFilename(stream, _sound.name);
	_sound.volume = stream.readUint16LE();
	_sound.channelID = 12; // hardcoded
	_sound.numLoops = 1;

	_responseGenericSound.volume = _sound.volume;
	_responseGenericSound.numLoops = 1;
	_responseGenericSound.channelID = 13; // hardcoded

	readTerseCaptionText(stream);

	_conditionalResponseCharacterID = stream.readByte();
	_goodbyeResponseCharacterID = stream.readByte();

	_defaultNextScene = stream.readByte();

	_sceneChange.sceneID = stream.readUint16LE();
	_sceneChange.continueSceneSound = kContinueSceneSound;

	uint16 numResponses = stream.readUint16LE();
	_responses.resize(numResponses);
	for (uint i = 0; i < numResponses; ++i) {
		ResponseStruct &response = _responses[i];
		response.conditionFlags.read(stream);
		readTerseResponseText(stream, response);
		readFilename(stream, response.soundName);
		response.sceneChange.sceneID = stream.readUint16LE();
		response.sceneChange.continueSceneSound = kContinueSceneSound;
	}

	// No scene branches
	uint16 numFlagsStructs = stream.readUint16LE();
	_flagsStructs.resize(numFlagsStructs);
	for (uint i = 0; i < numFlagsStructs; ++i) {
		FlagsStruct &flagsStruct = _flagsStructs[i];
		flagsStruct.conditions.read(stream);
		flagsStruct.flagToSet.type = stream.readByte();
		flagsStruct.flagToSet.flag.label = stream.readSint16LE();
		flagsStruct.flagToSet.flag.flag = stream.readByte();
	}
}

void ConversationSound::readCaptionText(Common::SeekableReadStream &stream) {
	char *rawText = new char[1500];
	stream.read(rawText, 1500);
	assembleTextLine(rawText, _text, 1500);
	delete[] rawText;
}

void ConversationSound::readResponseText(Common::SeekableReadStream &stream, ResponseStruct &response) {
	char *rawText = new char[400];
	stream.read(rawText, 400);
	assembleTextLine(rawText, response.text, 400);
	delete[] rawText;
}

void ConversationSound::readTerseCaptionText(Common::SeekableReadStream &stream) {
	Common::String key;
	readFilename(stream, key);

	const CVTX *convo = (const CVTX *)g_nancy->getEngineData("CONVO");
	assert(convo);

	_text = convo->texts[key];
}

void ConversationSound::readTerseResponseText(Common::SeekableReadStream &stream, ResponseStruct &response) {
	Common::String key;
	readFilename(stream, key);

	const CVTX *convo = (const CVTX *)g_nancy->getEngineData("CONVO");
	assert(convo);

	response.text = convo->texts[key];
}

void ConversationSound::execute() {
	ConversationSound *activeConversation = NancySceneState.getActiveConversation();
	if (activeConversation != this && activeConversation != nullptr) {
		if (	!activeConversation->_isDone ||
				activeConversation->_defaultNextScene == kDefaultNextSceneEnabled ||
				activeConversation->_pickedResponse != -1	) {

			return;
		} else {
			// Chained videos, hide the previous one and start this
			activeConversation->setVisible(false);
			NancySceneState.setActiveConversation(this);
		}
	}

	switch (_state) {
	case kBegin: {
		init();
		g_nancy->_sound->loadSound(_sound);

		if (!ConfMan.getBool("speech_mute") && ConfMan.getBool("character_speech")) {
			g_nancy->_sound->playSound(_sound);
		}

		// Remove held item and re-add it to inventory
		NancySceneState.setNoHeldItem();

		// Move the mouse to the default position defined in CURS
		const Common::Point initialMousePos = g_nancy->_cursor->getPrimaryVideoInitialPos();
		const Common::Point cursorHotspot = g_nancy->_cursor->getCurrentCursorHotspot();
		Common::Point adjustedMousePos = g_nancy->_input->getInput().mousePos;
		adjustedMousePos.x -= cursorHotspot.x;
		adjustedMousePos.y -= cursorHotspot.y - 1;
		if (g_nancy->_cursor->getPrimaryVideoInactiveZone().bottom > adjustedMousePos.y) {
			g_nancy->_cursor->warpCursor(Common::Point(initialMousePos.x + cursorHotspot.x, initialMousePos.y + cursorHotspot.y));
			g_nancy->_cursor->setCursorType(CursorManager::kNormalArrow);
		}

		_state = kRun;
		NancySceneState.setActiveConversation(this);

		// Do not draw first frame since video won't be loaded yet
		g_nancy->_graphics->suppressNextDraw();

		if (g_nancy->getGameType() < kGameTypeNancy6) {
			// Do not fall through to give the execution one loop for event flag changes
			// This fixes TVD scene 750
			break;
		}

		// However, nancy6 scene 1299 requires us to fall through in order to get the correct caption.
		// By that point Conversation scenes weren't the tangled mess they were in earlier games,
		// so hopefully this won't break anything
	}
		// fall through
	case kRun:
		if (!_hasDrawnTextbox) {
			_hasDrawnTextbox = true;
			auto *textboxData = GetEngineData(TBOX);
			assert(textboxData);
			NancySceneState.getTextbox().clear();
			NancySceneState.getTextbox().setOverrideFont(textboxData->conversationFontID);

			if (ConfMan.getBool("subtitles")) {
				NancySceneState.getTextbox().addTextLine(_text);
			}

			Common::Array<uint> responsesToAdd;
			for (uint i = 0; i < _responses.size(); ++i) {
				auto &res = _responses[i];

				if (res.conditionFlags.isSatisfied()) {
					int foundIndex = -1;
					for (uint j = 0; j < responsesToAdd.size(); ++j) {
						if (_responses[responsesToAdd[j]].text.compareToIgnoreCase(res.text) == 0) {
							foundIndex = j;
							break;
						}
					}
					switch(res.addRule) {
					case ResponseStruct::kAddIfNotFound:
						if (foundIndex == -1) {
							responsesToAdd.push_back(i);
						}

						break;
					case ResponseStruct::kRemoveAndAddToEnd:
						if (foundIndex != -1) {
							responsesToAdd.remove_at(foundIndex);
						}

						responsesToAdd.push_back(i);
						break;
					case ResponseStruct::kRemove:
						if (foundIndex != -1) {
							responsesToAdd.remove_at(foundIndex);
						}

						break;
					}
				}
			}

			uint numRegularResponses = _responses.size();

			// Add responses when conditions have been satisfied
			if (_conditionalResponseCharacterID != _noResponse) {
				addConditionalDialogue();
			}

			if (_goodbyeResponseCharacterID != _noResponse) {
				addGoodbye();
			}

			// If conditionals/goodbyes added, make sure to send them to Textbox
			for (uint i = numRegularResponses; i < _responses.size(); ++i) {
				responsesToAdd.push_back(i);
			}

			for (uint i : responsesToAdd) {
				NancySceneState.getTextbox().addTextLine(_responses[i].text);
				_responses[i].isOnScreen = true;
			}
		}

		if (!g_nancy->_sound->isSoundPlaying(_sound) && isVideoDonePlaying()) {
			g_nancy->_sound->stopSound(_sound);

			bool hasResponses = false;
			for (auto &res : _responses) {
				if (res.isOnScreen) {
					hasResponses = true;
					break;
				}
			}

			if (!hasResponses) {
				// NPC has finished talking with no responses available, auto-advance to next scene
				_state = kActionTrigger;
			} else {
				// NPC has finished talking, we have responses
				for (uint i = 0; i < 30; ++i) {
					if (NancySceneState.getLogicCondition(i, g_nancy->_true)) {
						_pickedResponse = i;

						// Adjust to account for hidden responses
						for (uint j = 0; j < _responses.size(); ++j) {
							if (!_responses[j].isOnScreen) {
								++_pickedResponse;
							}

							if ((int)j == _pickedResponse) {
								break;
							}
						}

						break;
					}
				}

				if (_pickedResponse != -1) {
					// Player has picked response, play sound file and change state
					_responseGenericSound.name = _responses[_pickedResponse].soundName;
					g_nancy->_sound->loadSound(_responseGenericSound);

					if (!ConfMan.getBool("speech_mute") && ConfMan.getBool("player_speech")) {
						g_nancy->_sound->playSound(_responseGenericSound);
					}

					_state = kActionTrigger;
				}
			}
		}
		break;
	case kActionTrigger:
		if (!g_nancy->_sound->isSoundPlaying(_responseGenericSound)) {
			// process flags structs
			for (auto &flags : _flagsStructs) {
				if (flags.conditions.isSatisfied()) {
					flags.flagToSet.set();
				}
			}

			if (_pickedResponse != -1) {
				// Set response's event flag, if any
				NancySceneState.setEventFlag(_responses[_pickedResponse].flagDesc);
			}

			g_nancy->_sound->stopSound(_responseGenericSound);

			if (_pickedResponse != -1) {
				NancySceneState.changeScene(_responses[_pickedResponse].sceneChange);
			} else {
				for (uint i = 0; i < _sceneBranchStructs.size(); ++i) {
					if (_sceneBranchStructs[i].conditions.isSatisfied()) {
						NancySceneState.changeScene(_sceneBranchStructs[i].sceneChange);
						break;
					}
				}

				if (_defaultNextScene == kDefaultNextSceneEnabled) {
					NancySceneState.changeScene(_sceneChange);
				} else if (_popNextScene == kPopNextScene) {
					// Exit dialogue
					NancySceneState.popScene();
				}
			}

			finishExecution();
		}

		break;
	}
}

void ConversationSound::addConditionalDialogue() {
	for (const auto &res : g_nancy->getStaticData().conditionalDialogue[_conditionalResponseCharacterID]) {
		bool isSatisfied = true;

		for (const auto &cond : res.conditions) {
			switch (cond.type) {
			case (byte)StaticDataConditionType::kEvent :
				if (!NancySceneState.getEventFlag(cond.label, cond.flag)) {
					isSatisfied = false;
				}

				break;
			case (byte)StaticDataConditionType::kInventory :
				if (NancySceneState.hasItem(cond.label) != cond.flag) {
					isSatisfied = false;
				}

				break;
			case (byte)StaticDataConditionType::kDifficulty :
				if (	(NancySceneState.getDifficulty() != cond.label && cond.flag != 0) ||
						(NancySceneState.getDifficulty() == cond.label && cond.flag == 0) ) {
					isSatisfied = false;
				}

				break;
			}

			if (!isSatisfied) {
				break;
			}
		}

		if (isSatisfied) {
			_responses.push_back(ResponseStruct());
			ResponseStruct &newResponse = _responses.back();
			newResponse.soundName = res.soundID;

			if (g_nancy->getGameType() <= kGameTypeNancy5) {
				// String is also inside nancy.dat
				newResponse.text = g_nancy->getStaticData().conditionalDialogueTexts[res.textID];
			} else {
				// String is inside the CVTX chunk in the CONVO file. Sound ID doubles as string key
				const CVTX *convo = (const CVTX *)g_nancy->getEngineData("CONVO");
				assert(convo);

				newResponse.text = convo->texts[res.soundID];
			}

			newResponse.sceneChange.sceneID = res.sceneID;
			newResponse.sceneChange.continueSceneSound = kContinueSceneSound;
			newResponse.sceneChange.listenerFrontVector.set(0, 0, 1);

			// Check if the response is a repeat. This can happen when multiple condition combinations
			// trigger the same response.
			for (uint i = 0; i < _responses.size() - 1; ++i) {
				if (	_responses[i].soundName == newResponse.soundName &&
						_responses[i].text == newResponse.text &&
						_responses[i].sceneChange.sceneID == newResponse.sceneChange.sceneID) {
					_responses.pop_back();
					break;
				}
			}
		}
	}
}

void ConversationSound::addGoodbye() {
	auto &res = g_nancy->getStaticData().goodbyes[_goodbyeResponseCharacterID];
	_responses.push_back(ResponseStruct());
	ResponseStruct &newResponse = _responses.back();
	newResponse.soundName = res.soundID;

	if (g_nancy->getGameType() <= kGameTypeNancy5) {
		// String is also inside nancy.dat
		newResponse.text = g_nancy->getStaticData().goodbyeTexts[_goodbyeResponseCharacterID];
	} else {
		// String is inside the CVTX chunk in the CONVO file. Sound ID doubles as string key
		const CVTX *convo = (const CVTX *)g_nancy->getEngineData("CONVO");
		assert(convo);

		newResponse.text = convo->texts[res.soundID];
	}

	// Evaluate conditions to pick from the collection of replies
	uint sceneChangeID = 0;
	for (uint i = 0; i < res.sceneChanges.size(); ++i) {
		const GoodbyeSceneChange &sc = res.sceneChanges[i];
		if (sc.conditions.size() == 0) {
			// No conditions, default choice
			sceneChangeID = i;
			break;
		} else {
			bool isSatisfied = true;

			for (const auto &cond : sc.conditions) {
				switch (cond.type) {
				case (byte)StaticDataConditionType::kEvent :
					if (!NancySceneState.getEventFlag(cond.label, cond.flag)) {
						isSatisfied = false;
					}

					break;
				case (byte)StaticDataConditionType::kInventory :
					if (NancySceneState.hasItem(cond.label) != cond.flag) {
						isSatisfied = false;
					}

					break;
				case (byte)StaticDataConditionType::kDifficulty :
					if (	(NancySceneState.getDifficulty() != cond.label && cond.flag != 0) ||
							(NancySceneState.getDifficulty() == cond.label && cond.flag == 0) ) {
						isSatisfied = false;
					}

					break;
				}

				if (!isSatisfied) {
					break;
				}
			}

			if (isSatisfied) {
				sceneChangeID = i;
				break;
			}
		}
	}

	const GoodbyeSceneChange &sceneChange = res.sceneChanges[sceneChangeID];

	// The reply from the character is picked randomly
	newResponse.sceneChange.sceneID = sceneChange.sceneIDs[g_nancy->_randomSource->getRandomNumber(sceneChange.sceneIDs.size() - 1)];
	newResponse.sceneChange.continueSceneSound = kContinueSceneSound;
	newResponse.sceneChange.listenerFrontVector.set(0, 0, 1);

	// Set an event flag if applicable
	// Assumes flagToSet is an event flag
	NancySceneState.setEventFlag(sceneChange.flagToSet.label, sceneChange.flagToSet.flag);
}

void ConversationSound::ConversationFlag::read(Common::SeekableReadStream &stream) {
	type = stream.readByte();
	flag.label = stream.readSint16LE();
	flag.flag = stream.readByte();
	orFlag = stream.readByte();
}

bool ConversationSound::ConversationFlag::isSatisfied() const {
	switch (type) {
	case kFlagEvent:
		return NancySceneState.getEventFlag(flag);
	case kFlagInventory:
		return NancySceneState.hasItem(flag.label) == flag.flag;
	default:
		return false;
	}
}

void ConversationSound::ConversationFlag::set() const {
	switch (type) {
	case kFlagEvent:
		NancySceneState.setEventFlag(flag);
		break;
	case kFlagInventory:
		if (flag.flag == g_nancy->_true) {
			NancySceneState.addItemToInventory(flag.label);
		} else {
			NancySceneState.removeItemFromInventory(flag.label);
		}

		break;
	default:
		break;
	}
}

void ConversationSound::ConversationFlags::read(Common::SeekableReadStream &stream) {
	uint16 numFlags = stream.readUint16LE();

	conditionFlags.resize(numFlags);
	for (uint i = 0; i < numFlags; ++i) {
		conditionFlags[i].read(stream);
	}
}

bool ConversationSound::ConversationFlags::isSatisfied() const {
	Common::Array<bool> conditionsMet(conditionFlags.size(), false);

	for (uint i = 0; i < conditionFlags.size(); ++i) {
		if (conditionFlags[i].isSatisfied()) {
			conditionsMet[i] = true;
		}
	}

	for (uint i = 0; i < conditionsMet.size(); ++i) {
		if (conditionFlags[i].orFlag) {
			bool foundSatisfied = false;
			for (uint j = 0; j < conditionFlags.size(); ++j) {
				if (conditionsMet[j]) {
					foundSatisfied = true;
					break;
				}

				// Found end of orFlag chain
				if (!conditionFlags[j].orFlag) {
					break;
				}
			}

			if (foundSatisfied) {
				for (; i < conditionsMet.size(); ++i) {
					conditionsMet[i] = true;
					if (!conditionFlags[i].orFlag) {
						// End of orFlag chain
						break;
					}
				}
			}
		}
	}

	for (uint i = 0; i < conditionsMet.size(); ++i) {
		if (conditionsMet[i] == false) {
			return false;
		}
	}

	return true;
}

void ConversationVideo::init() {
	if (!_decoder.loadFile(Common::Path(_videoName + ".avf"))) {
		error("Couldn't load video file %s", _videoName.c_str());
	}

	_decoder.seekToFrame(_firstFrame);

	if (!_paletteName.empty()) {
		GraphicsManager::loadSurfacePalette(_drawSurface, _paletteName);
		setTransparent(true);
	}

	ConversationSound::init();
	registerGraphics();
}

void ConversationVideo::readData(Common::SeekableReadStream &stream) {
	Common::Serializer ser(&stream, nullptr);
	ser.setVersion(g_nancy->getGameType());

	readFilename(stream, _videoName);
	readFilename(ser, _paletteName, kGameTypeVampire, kGameTypeVampire);

	ser.skip(2, kGameTypeVampire, kGameTypeNancy1);
	ser.syncAsUint16LE(_videoFormat);
	ser.skip(3); // Quality
	ser.skip(4, kGameTypeVampire, kGameTypeVampire); // paletteStart, paletteSize
	ser.syncAsUint16LE(_firstFrame);
	ser.syncAsUint16LE(_lastFrame);
	ser.skip(8, kGameTypeVampire, kGameTypeNancy1);
	ser.skip(6, kGameTypeNancy2);

	ser.skip(0x10); // Bounds
	readRect(stream, _screenPosition);

	ConversationSound::readData(stream);
}

void ConversationVideo::updateGraphics() {
	if (!_decoder.isVideoLoaded()) {
		return;
	}

	if (!_decoder.isPlaying()) {
		_decoder.start();
	}

	if (_decoder.getCurFrame() == _lastFrame) {
		_decoder.pauseVideo(true);
	}

	if (_decoder.needsUpdate()) {
		GraphicsManager::copyToManaged(*_decoder.decodeNextFrame(), _drawSurface, _videoFormat == kSmallVideoFormat);

		_needsRedraw = true;
	}

	RenderObject::updateGraphics();
}

void ConversationVideo::onPause(bool pause) {
	_decoder.pauseVideo(pause);
	RenderActionRecord::onPause(pause);
}

bool ConversationVideo::isVideoDonePlaying() {
	return _decoder.endOfVideo() || _decoder.getCurFrame() == _lastFrame;
}

Common::String ConversationVideo::getRecordTypeName() const {
	if (g_nancy->getGameType() <= kGameTypeNancy1) {
		return "PlayPrimaryVideo";
	} else {
		return "ConversationVideo";
	}
}

class ConversationCelLoader : public DeferredLoader {
public:
	ConversationCelLoader(ConversationCel &owner) : _owner(owner) {}

private:
	bool loadInner() override;

	ConversationCel &_owner;
};

bool ConversationCelLoader::loadInner() {
	for (uint i = _owner._curFrame; i < _owner._celNames[0].size(); ++i) {
		for (uint j = 0; j < _owner._celRObjects.size(); ++j) {
			if (!_owner._celCache.contains(_owner._celNames[j][i])) {
				_owner.loadCel(_owner._celNames[j][i], _owner._treeNames[j]);
				return false;
			}
		}
	}

	return true;
}

ConversationCel::~ConversationCel() {
	// Make sure there isn't a single-frame gap between conversation scenes where
	// the character is invisible
	g_nancy->_graphics->suppressNextDraw();
}

void ConversationCel::init() {
	_curFrame = _firstFrame;
	_nextFrameTime = g_nancy->getTotalPlayTime();
	ConversationSound::init();

	_loaderPtr.reset(new ConversationCelLoader(*this));
	auto castedPtr = _loaderPtr.dynamicCast<DeferredLoader>();
	g_nancy->addDeferredLoader(castedPtr);

	for (uint i = 0; i < _treeNames.size(); ++i) {
		if (_treeNames[i].size()) {
			_celRObjects.push_back(RenderedCel());
		} else break;
	}

	registerGraphics();
}

void ConversationCel::registerGraphics() {
	for (uint i = 0; i < _celRObjects.size(); ++i) {
		_celRObjects[i]._z = 9 + _drawingOrder[i];
		_celRObjects[i].setVisible(true);
		_celRObjects[i].setTransparent(true);
		_celRObjects[i].registerGraphics();
	}

	RenderActionRecord::registerGraphics();
}

void ConversationCel::updateGraphics() {
	uint32 currentTime = g_nancy->getTotalPlayTime();

	if (_state == kRun && currentTime > _nextFrameTime && _curFrame < MIN<uint>(_lastFrame + 1, _celNames[0].size())) {
		for (uint i = 0; i < _celRObjects.size(); ++i) {
			Cel &cel = loadCel(_celNames[i][_curFrame], _treeNames[i]);
			if (_overrideTreeRects[i] == kCelOverrideTreeRectsOn) {
				_celRObjects[i]._drawSurface.create(cel.surf, _overrideRectSrcs[i]);
				_celRObjects[i].moveTo(_overrideRectDests[i]);
			} else {
				_celRObjects[i]._drawSurface.create(cel.surf, cel.src);
				_celRObjects[i].moveTo(cel.dest);
			}
		}

		_nextFrameTime += _frameTime;
		++_curFrame;
	}
}

void ConversationCel::readData(Common::SeekableReadStream &stream) {
	Common::String xsheetName;
	readFilename(stream, xsheetName);

	readFilenameArray(stream, _treeNames, 4);
	readXSheet(stream, xsheetName);

	// Continue reading the AR stream

	// Something related to quality
	stream.skip(3);

	_firstFrame = stream.readUint16LE();
	_lastFrame = stream.readUint16LE();

	stream.skip(6);

	_drawingOrder.resize(4);
	for (uint i = 0; i < 4; ++i) {
		_drawingOrder[i] = stream.readByte();
	}

	_overrideTreeRects.resize(4);
	for (uint i = 0; i < 4; ++i) {
		_overrideTreeRects[i] = stream.readByte();
	}

	readRectArray(stream, _overrideRectSrcs, 4);
	readRectArray(stream, _overrideRectDests, 4);

	ConversationSound::readData(stream);
}

void ConversationCel::readXSheet(Common::SeekableReadStream &stream, const Common::String &xsheetName) {
	Common::SeekableReadStream *xsheet = SearchMan.createReadStreamForMember(Common::Path(xsheetName));

	// Read the xsheet and load all images into the arrays
	// Completely unoptimized, the original engine uses a buffer
	xsheet->seek(0);
	Common::String signature = xsheet->readString('\0', 18);
	if (signature != "XSHEET WayneSikes") {
		warning("XSHEET signature doesn't match!");
		return;
	}

	xsheet->seek(0x22);
	uint numFrames = xsheet->readUint16LE();
	xsheet->skip(2);
	_frameTime = xsheet->readUint16LE();
	xsheet->skip(2);

	_celNames.resize(4, Common::Array<Common::Path>(numFrames));
	for (uint i = 0; i < numFrames; ++i) {
		for (uint j = 0; j < _celNames.size(); ++j) {
			readFilename(*xsheet, _celNames[j][i]);
		}

		// 4 unknown values
		xsheet->skip(8);
	}

	delete xsheet;
}

bool ConversationCel::isVideoDonePlaying() {
	return _curFrame >= MIN<uint>(_lastFrame, _celNames[0].size()) && _nextFrameTime <= g_nancy->getTotalPlayTime();
}

ConversationCel::Cel &ConversationCel::loadCel(const Common::Path &name, const Common::String &treeName) {
	// Assumes head and body cels will be named differently
	if (_celCache.contains(name)) {
		return _celCache[name];
	}

	Cel &newCel = _celCache.getOrCreateVal(name);
	g_nancy->_resource->loadImage(name, newCel.surf, treeName, &newCel.src, &newCel.dest);
	return _celCache[name];
}

void ConversationSoundTerse::readData(Common::SeekableReadStream &stream) {
	readTerseData(stream);
}

void ConversationCelTerse::readData(Common::SeekableReadStream &stream) {
	Common::String xsheetName;
	readFilename(stream, xsheetName);

	readFilenameArray(stream, _treeNames, 2); // Only 2
	readXSheet(stream, xsheetName);

	_lastFrame = stream.readUint16LE();
	_drawingOrder = { 1, 0, 2, 3 };
	_overrideTreeRects.resize(4, kCelOverrideTreeRectsOff);

	readTerseData(stream);
}

} // End of namespace Action
} // End of namespace Nancy