path: root/engines/parallaction/exec_br.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 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.
 *
 * $URL$
 * $Id$
 *
 */

#include "parallaction/exec.h"
#include "parallaction/input.h"
#include "parallaction/parallaction.h"

namespace Parallaction {

#define INST_ON			1
#define INST_OFF		2
#define INST_X			3
#define INST_Y			4
#define INST_Z			5
#define INST_F			6
#define INST_LOOP		7
#define INST_ENDLOOP	8
#define INST_SHOW		9
#define INST_INC		10
#define INST_DEC		11
#define INST_SET		12
#define INST_PUT		13
#define INST_CALL		14
#define INST_WAIT		15
#define INST_START		16
#define INST_PROCESS	17
#define INST_MOVE		18
#define INST_COLOR		19
#define INST_SOUND		20
#define INST_MASK		21
#define INST_PRINT		22
#define INST_TEXT		23
#define INST_MUL		24
#define INST_DIV		25
#define INST_IFEQ		26
#define INST_IFLT		27
#define INST_IFGT		28
#define INST_ENDIF		29
#define INST_STOP		30
#define INST_ENDSCRIPT	31

#define SetOpcodeTable(x) table = &x;

typedef Common::Functor1Mem<CommandContext&, void, CommandExec_br> OpcodeV1;
#define COMMAND_OPCODE(op) table->push_back(new OpcodeV1(this, &CommandExec_br::cmdOp_##op))
#define DECLARE_COMMAND_OPCODE(op) void CommandExec_br::cmdOp_##op(CommandContext &ctxt)

typedef Common::Functor1Mem<ProgramContext&, void, ProgramExec_br> OpcodeV2;
#define INSTRUCTION_OPCODE(op) table->push_back(new OpcodeV2(this, &ProgramExec_br::instOp_##op))
#define DECLARE_INSTRUCTION_OPCODE(op) void ProgramExec_br::instOp_##op(ProgramContext &ctxt)

extern const char *_instructionNamesRes_br[];

void Parallaction_br::setupSubtitles(char *s, char *s2, int y) {
	debugC(5, kDebugExec, "setupSubtitles(%s, %s, %i)", s, s2, y);

	clearSubtitles();

	if (!scumm_stricmp("clear", s)) {
		return;
	}

	if (y != -1) {
		_subtitleY = y;
	}

	// FIXME: render subtitles using the right color (10 instead of 0).
	// The original game features a nasty hack, having the font rendering routine
	// replacing color 12 of font RUSSIA with 10 when preparing subtitles.
	_subtitle[0] = _gfx->createLabel(_labelFont, s, 0);
	_gfx->showLabel(_subtitle[0], CENTER_LABEL_HORIZONTAL, _subtitleY);
	if (s2) {
		_subtitle[1] = _gfx->createLabel(_labelFont, s2, 0);
		_gfx->showLabel(_subtitle[1], CENTER_LABEL_HORIZONTAL, _subtitleY + 5 + _labelFont->height());
	} else {
		_subtitle[1] = -1;
	}
#if 0	// disabled because no references to lip sync has been found in the scripts
	_subtitleLipSync = 0;
#endif
}

void Parallaction_br::clearSubtitles() {
	if (_subtitle[0] != -1) {
		_gfx->hideLabel(_subtitle[0]);
	}

	if (_subtitle[1] != -1) {
		_gfx->hideLabel(_subtitle[1]);
	}
}


DECLARE_COMMAND_OPCODE(location) {
	warning("Parallaction_br::cmdOp_location command not yet implemented");

	_vm->_location._startPosition = ctxt._cmd->u._startPos;
	_vm->_location._startFrame = 0; // TODO: verify this against the disassembly!f
	_vm->_location._followerStartPosition = ctxt._cmd->u._startPos2;
	_vm->_location._followerStartFrame = 0;

	// TODO: handle startPos and startPos2
	_vm->scheduleLocationSwitch(ctxt._cmd->u._string);
}


DECLARE_COMMAND_OPCODE(open) {
	_vm->updateDoor(ctxt._cmd->u._zone, false);
}


DECLARE_COMMAND_OPCODE(close) {
	_vm->updateDoor(ctxt._cmd->u._zone, true);
}


DECLARE_COMMAND_OPCODE(on) {
	_vm->showZone(ctxt._cmd->u._zone, true);
}


DECLARE_COMMAND_OPCODE(off) {
	_vm->showZone(ctxt._cmd->u._zone, false);
}


DECLARE_COMMAND_OPCODE(call) {
	_vm->callFunction(ctxt._cmd->u._callable, &ctxt._z);
}


DECLARE_COMMAND_OPCODE(drop) {
	_vm->dropItem(ctxt._cmd->u._object);
}


DECLARE_COMMAND_OPCODE(move) {
	_vm->scheduleWalk(ctxt._cmd->u._move.x, ctxt._cmd->u._move.y, false);
	suspend();
}

DECLARE_COMMAND_OPCODE(start) {
	ctxt._cmd->u._zone->_flags |= kFlagsActing;
}

DECLARE_COMMAND_OPCODE(stop) {
	ctxt._cmd->u._zone->_flags &= ~kFlagsActing;
}


DECLARE_COMMAND_OPCODE(character) {
	debugC(9, kDebugExec, "Parallaction_br::cmdOp_character(%s)", ctxt._cmd->u._string);
	_vm->changeCharacter(ctxt._cmd->u._string);
}


DECLARE_COMMAND_OPCODE(followme) {
	Common::String s(ctxt._cmd->u._string);
	if (!s.compareToIgnoreCase("NULL")) {
		s.clear();
	}
	_vm->setFollower(s);
}


DECLARE_COMMAND_OPCODE(onmouse) {
	_vm->_input->setMouseState(MOUSE_ENABLED_SHOW);
}


DECLARE_COMMAND_OPCODE(offmouse) {
	_vm->_input->setMouseState(MOUSE_DISABLED);
}


DECLARE_COMMAND_OPCODE(add) {
	_vm->addInventoryItem(ctxt._cmd->u._object);
}


DECLARE_COMMAND_OPCODE(leave) {
	ZonePtr z = ctxt._cmd->u._zone;
	_vm->dropItem(z->u.get->_icon);
	_vm->showZone(z, true);
}


DECLARE_COMMAND_OPCODE(inc) {
	int v = _vm->getCounterValue(ctxt._cmd->u._counterName);
	_vm->setCounterValue(ctxt._cmd->u._counterName, v + ctxt._cmd->u._counterValue);
}


DECLARE_COMMAND_OPCODE(dec) {
	int v = _vm->getCounterValue(ctxt._cmd->u._counterName);
	_vm->setCounterValue(ctxt._cmd->u._counterName, v - ctxt._cmd->u._counterValue);
}

// these definitions must match those in parser_br.cpp
#define CMD_TEST		25
#define CMD_TEST_GT		26
#define CMD_TEST_LT		27

DECLARE_COMMAND_OPCODE(ifeq) {
	_vm->testCounterCondition(ctxt._cmd->u._counterName, CMD_TEST, ctxt._cmd->u._counterValue);
}

DECLARE_COMMAND_OPCODE(iflt) {
	_vm->testCounterCondition(ctxt._cmd->u._counterName, CMD_TEST_LT, ctxt._cmd->u._counterValue);
}

DECLARE_COMMAND_OPCODE(ifgt) {
	_vm->testCounterCondition(ctxt._cmd->u._counterName, CMD_TEST_GT, ctxt._cmd->u._counterValue);
}


DECLARE_COMMAND_OPCODE(let) {
	_vm->setCounterValue(ctxt._cmd->u._counterName, ctxt._cmd->u._counterValue);
}


DECLARE_COMMAND_OPCODE(music) {
	warning("Parallaction_br::cmdOp_music not yet implemented");
}


DECLARE_COMMAND_OPCODE(fix) {
	ctxt._cmd->u._zone->_flags |= kFlagsFixed;
}


DECLARE_COMMAND_OPCODE(unfix) {
	ctxt._cmd->u._zone->_flags &= ~kFlagsFixed;
}


DECLARE_COMMAND_OPCODE(zeta) {
	_vm->_location._zeta0 = ctxt._cmd->u._zeta0;
	_vm->_location._zeta1 = ctxt._cmd->u._zeta1;
	_vm->_location._zeta2 = ctxt._cmd->u._zeta2;
}


DECLARE_COMMAND_OPCODE(scroll) {
	warning("Parallaction_br::cmdOp_scroll not yet implemented");
}


DECLARE_COMMAND_OPCODE(swap) {
	warning("Parallaction_br::cmdOp_swap not yet implemented");
}


DECLARE_COMMAND_OPCODE(give) {
	warning("Parallaction_br::cmdOp_give not yet implemented");
}


DECLARE_COMMAND_OPCODE(text) {
	CommandData *data = &ctxt._cmd->u;
	_vm->setupSubtitles(data->_string, data->_string2, data->_zeta0);
}


DECLARE_COMMAND_OPCODE(part) {
	warning("Parallaction_br::cmdOp_part not yet implemented");
}


DECLARE_COMMAND_OPCODE(testsfx) {
	warning("Parallaction_br::cmdOp_testsfx not completely implemented");
	_vm->clearLocationFlags(kFlagsTestTrue);	// should test if sfx are enabled
}


DECLARE_COMMAND_OPCODE(ret) {
	_engineFlags |= kEngineReturn;
}


DECLARE_COMMAND_OPCODE(onsave) {
	warning("Parallaction_br::cmdOp_onsave not yet implemented");
}


DECLARE_COMMAND_OPCODE(offsave) {
	warning("Parallaction_br::cmdOp_offsave not yet implemented");
}

DECLARE_INSTRUCTION_OPCODE(invalid) {
	error("Can't execute invalid opcode %i", (*ctxt._inst)->_index);
}

DECLARE_COMMAND_OPCODE(clear) {
	if (ctxt._cmd->u._flags & kFlagsGlobal) {
		ctxt._cmd->u._flags &= ~kFlagsGlobal;
		_globalFlags &= ~ctxt._cmd->u._flags;
	} else {
		_vm->clearLocationFlags(ctxt._cmd->u._flags);
	}
}

DECLARE_COMMAND_OPCODE(speak) {
	if (ACTIONTYPE(ctxt._cmd->u._zone) == kZoneSpeak) {
		_vm->enterDialogueMode(ctxt._cmd->u._zone);
	} else {
		_vm->_activeZone = ctxt._cmd->u._zone;
	}
}


DECLARE_COMMAND_OPCODE(get) {
	ctxt._cmd->u._zone->_flags &= ~kFlagsFixed;
	_vm->runZone(ctxt._cmd->u._zone);
}

DECLARE_COMMAND_OPCODE(toggle) {
	if (ctxt._cmd->u._flags & kFlagsGlobal) {
		ctxt._cmd->u._flags &= ~kFlagsGlobal;
		_globalFlags ^= ctxt._cmd->u._flags;
	} else {
		_vm->toggleLocationFlags(ctxt._cmd->u._flags);
	}
}

DECLARE_COMMAND_OPCODE(quit) {
	_vm->quitGame();
}

DECLARE_COMMAND_OPCODE(invalid) {
	error("Can't execute invalid command '%i'", ctxt._cmd->_id);
}

DECLARE_COMMAND_OPCODE(set) {
	if (ctxt._cmd->u._flags & kFlagsGlobal) {
		ctxt._cmd->u._flags &= ~kFlagsGlobal;
		_globalFlags |= ctxt._cmd->u._flags;
	} else {
		_vm->setLocationFlags(ctxt._cmd->u._flags);
	}
}



DECLARE_INSTRUCTION_OPCODE(on) {
	_vm->showZone((*ctxt._inst)->_z, true);
}


DECLARE_INSTRUCTION_OPCODE(off) {
	_vm->showZone((*ctxt._inst)->_z, false);
}


DECLARE_INSTRUCTION_OPCODE(set) {
	InstructionPtr inst = *ctxt._inst;
	inst->_opA.setValue(inst->_opB.getValue());
}



DECLARE_INSTRUCTION_OPCODE(inc) {
	InstructionPtr inst = *ctxt._inst;

	int16 rvalue = inst->_opB.getValue();

	if (inst->_flags & kInstMod) {	// mod
		int16 _bx = (rvalue > 0 ? rvalue : -rvalue);
		if (ctxt._modCounter % _bx != 0) return;

		rvalue = (rvalue > 0 ?  1 : -1);
	}

	int16 lvalue = inst->_opA.getValue();

	switch (inst->_index) {
	case INST_INC:
		lvalue += rvalue;
		break;

	case INST_DEC:
		lvalue -= rvalue;
		break;

	case INST_MUL:
		lvalue *= rvalue;
		break;

	case INST_DIV:
		lvalue /= rvalue;
		break;

	default:
		error("This should never happen. Report immediately");
	}

	inst->_opA.setValue(lvalue);

}


DECLARE_INSTRUCTION_OPCODE(put) {
	// NOTE: there is not a single occurrence of PUT in the scripts
	warning("PUT instruction is not implemented!");
}



DECLARE_INSTRUCTION_OPCODE(wait) {
	// NOTE: there is not a single occurrence of WAIT in the scripts
	warning("WAIT instruction is not implemented!");
}


DECLARE_INSTRUCTION_OPCODE(start) {
	(*ctxt._inst)->_z->_flags |= kFlagsActing;
}


DECLARE_INSTRUCTION_OPCODE(process) {
	_vm->_activeZone2 = (*ctxt._inst)->_z;
}


DECLARE_INSTRUCTION_OPCODE(move) {
	warning("Parallaction_br::instOp_move not yet implemented");
}


DECLARE_INSTRUCTION_OPCODE(color) {
	InstructionPtr inst = *ctxt._inst;
	_vm->_gfx->_palette.setEntry(inst->_opB.getValue(), inst->_colors[0], inst->_colors[1], inst->_colors[2]);
}


DECLARE_INSTRUCTION_OPCODE(mask) {
#if 0
	Instruction *inst = *ctxt._inst;
	_gfx->_bgLayers[0] = inst->_opA.getRValue();
	_gfx->_bgLayers[1] = inst->_opB.getRValue();
	_gfx->_bgLayers[2] = inst->_opC.getRValue();
#endif
}


DECLARE_INSTRUCTION_OPCODE(print) {
	// NOTE: there is not a single occurrence of PRINT in the scripts
	// I suppose it was used for debugging
	warning("PRINT instruction is not implemented!");
}

DECLARE_INSTRUCTION_OPCODE(text) {
	InstructionPtr inst = (*ctxt._inst);
	_vm->setupSubtitles(inst->_text, inst->_text2, inst->_y);
}


DECLARE_INSTRUCTION_OPCODE(ifeq) {
	warning("Parallaction_br::instOp_ifeq not yet implemented");
}


DECLARE_INSTRUCTION_OPCODE(iflt) {
	warning("Parallaction_br::instOp_iflt not yet implemented");
}


DECLARE_INSTRUCTION_OPCODE(ifgt) {
	warning("Parallaction_br::instOp_ifgt not yet implemented");
}


DECLARE_INSTRUCTION_OPCODE(endif) {
	warning("Parallaction_br::instOp_endif not yet implemented");
}


DECLARE_INSTRUCTION_OPCODE(stop) {
	warning("Parallaction_br::instOp_stop not yet implemented");
}

DECLARE_INSTRUCTION_OPCODE(loop) {
	InstructionPtr inst = *ctxt._inst;

	ctxt._program->_loopCounter = inst->_opB.getValue();
	ctxt._program->_loopStart = ctxt._ip;
}


DECLARE_INSTRUCTION_OPCODE(endloop) {
	if (--ctxt._program->_loopCounter > 0) {
		ctxt._ip = ctxt._program->_loopStart;
	}
}

DECLARE_INSTRUCTION_OPCODE(show) {
	ctxt._suspend = true;
}

DECLARE_INSTRUCTION_OPCODE(call) {
	_vm->callFunction((*ctxt._inst)->_immediate, 0);
}


DECLARE_INSTRUCTION_OPCODE(endscript) {
	if ((ctxt._anim->_flags & kFlagsLooping) == 0) {
		ctxt._anim->_flags &= ~kFlagsActing;
		_vm->_cmdExec->run(ctxt._anim->_commands, ctxt._anim);
		ctxt._program->_status = kProgramDone;
	}

	ctxt._ip = ctxt._program->_instructions.begin();
	ctxt._suspend = true;
}


CommandExec_br::CommandExec_br(Parallaction_br* vm) : CommandExec(vm), _vm(vm) {
	CommandOpcodeSet *table = 0;

	SetOpcodeTable(_opcodes);
	COMMAND_OPCODE(invalid);
	COMMAND_OPCODE(set);
	COMMAND_OPCODE(clear);
	COMMAND_OPCODE(start);
	COMMAND_OPCODE(speak);
	COMMAND_OPCODE(get);
	COMMAND_OPCODE(location);
	COMMAND_OPCODE(open);
	COMMAND_OPCODE(close);
	COMMAND_OPCODE(on);
	COMMAND_OPCODE(off);
	COMMAND_OPCODE(call);
	COMMAND_OPCODE(toggle);
	COMMAND_OPCODE(drop);
	COMMAND_OPCODE(quit);
	COMMAND_OPCODE(move);
	COMMAND_OPCODE(stop);
	COMMAND_OPCODE(character);
	COMMAND_OPCODE(followme);
	COMMAND_OPCODE(onmouse);
	COMMAND_OPCODE(offmouse);
	COMMAND_OPCODE(add);
	COMMAND_OPCODE(leave);
	COMMAND_OPCODE(inc);
	COMMAND_OPCODE(dec);
	COMMAND_OPCODE(ifeq);
	COMMAND_OPCODE(iflt);
	COMMAND_OPCODE(ifgt);
	COMMAND_OPCODE(let);
	COMMAND_OPCODE(music);
	COMMAND_OPCODE(fix);
	COMMAND_OPCODE(unfix);
	COMMAND_OPCODE(zeta);
	COMMAND_OPCODE(scroll);
	COMMAND_OPCODE(swap);
	COMMAND_OPCODE(give);
	COMMAND_OPCODE(text);
	COMMAND_OPCODE(part);
	COMMAND_OPCODE(testsfx);
	COMMAND_OPCODE(ret);
	COMMAND_OPCODE(onsave);
	COMMAND_OPCODE(offsave);
}


ProgramExec_br::ProgramExec_br(Parallaction_br *vm) : _vm(vm) {
	_instructionNames = _instructionNamesRes_br;

	ProgramOpcodeSet *table = 0;

	SetOpcodeTable(_opcodes);
	INSTRUCTION_OPCODE(invalid);
	INSTRUCTION_OPCODE(on);
	INSTRUCTION_OPCODE(off);
	INSTRUCTION_OPCODE(set);		// x
	INSTRUCTION_OPCODE(set);		// y
	INSTRUCTION_OPCODE(set);		// z
	INSTRUCTION_OPCODE(set);		// f
	INSTRUCTION_OPCODE(loop);
	INSTRUCTION_OPCODE(endloop);
	INSTRUCTION_OPCODE(show);		// show
	INSTRUCTION_OPCODE(inc);
	INSTRUCTION_OPCODE(inc);		// dec
	INSTRUCTION_OPCODE(set);
	INSTRUCTION_OPCODE(put);
	INSTRUCTION_OPCODE(call);
	INSTRUCTION_OPCODE(wait);
	INSTRUCTION_OPCODE(start);
	INSTRUCTION_OPCODE(process);
	INSTRUCTION_OPCODE(move);
	INSTRUCTION_OPCODE(color);
	INSTRUCTION_OPCODE(process);	// sound
	INSTRUCTION_OPCODE(mask);
	INSTRUCTION_OPCODE(print);
	INSTRUCTION_OPCODE(text);
	INSTRUCTION_OPCODE(inc);		// mul
	INSTRUCTION_OPCODE(inc);		// div
	INSTRUCTION_OPCODE(ifeq);
	INSTRUCTION_OPCODE(iflt);
	INSTRUCTION_OPCODE(ifgt);
	INSTRUCTION_OPCODE(endif);
	INSTRUCTION_OPCODE(stop);
	INSTRUCTION_OPCODE(endscript);
}



} // namespace Parallaction