AGI: Change AGI commands/opcodes to member methods

svn-id: r50124

3 files changed, 582 insertions, 383 deletions

diff --git a/engines/agi/agi.cpp b/engines/agi/agi.cpp
index 0875646148..0f5d3ee2f0 100644
--- a/engines/agi/agi.cpp
+++ b/engines/agi/agi.cpp
@@ -569,6 +569,8 @@ AgiEngine::AgiEngine(OSystem *syst, const AGIGameDescription *gameDesc) : AgiBas
 	_game.lastController = 0;
 	for (int i = 0; i < MAX_DIRS; i++)
 		_game.controllerOccured[i] = false;
+
+	setupOpcodes();
 }
 
 void AgiEngine::initialize() {
diff --git a/engines/agi/agi.h b/engines/agi/agi.h
index 18f291d62c..02d3526f16 100644
--- a/engines/agi/agi.h
+++ b/engines/agi/agi.h
@@ -119,6 +119,7 @@ enum AgiGameID {
 	GID_XMASCARD,
 	GID_FANMADE,
 	GID_GETOUTTASQ,	// Fanmade
+	GID_SQ0,				// Fanmade
 	GID_MICKEY,			// PreAGI
 	GID_WINNIE,			// PreAGI
 	GID_TROLL				// PreAGI
@@ -1041,6 +1042,196 @@ private:
 	bool _predictiveDialogRunning;
 public:
 	char _predictiveResult[40];
+
+private:
+	typedef void (AgiEngine::*AgiCommand)(uint8 *);
+
+	AgiCommand _agiCommands[183];
+
+	void setupOpcodes();
+
+	void cmd_increment(uint8 *p);
+	void cmd_decrement(uint8 *p);
+	void cmd_assignn(uint8 *p);
+	void cmd_assignv(uint8 *p);
+	void cmd_addn(uint8 *p);
+	void cmd_addv(uint8 *p);
+	void cmd_subn(uint8 *p);
+	void cmd_subv(uint8 *p);	// 0x08
+	void cmd_lindirectv(uint8 *p);
+	void cmd_rindirect(uint8 *p);
+	void cmd_lindirectn(uint8 *p);
+	void cmd_set(uint8 *p);
+	void cmd_reset(uint8 *p);
+	void cmd_toggle(uint8 *p);
+	void cmd_set_v(uint8 *p);
+	void cmd_reset_v(uint8 *p);	// 0x10
+	void cmd_toggle_v(uint8 *p);
+	void cmd_new_room(uint8 *p);
+	void cmd_new_room_f(uint8 *p);
+	void cmd_load_logic(uint8 *p);
+	void cmd_load_logic_f(uint8 *p);
+	void cmd_call(uint8 *p);
+	void cmd_call_f(uint8 *p);
+	void cmd_load_pic(uint8 *p);	// 0x18
+	void cmd_draw_pic(uint8 *p);
+	void cmd_show_pic(uint8 *p);
+	void cmd_discard_pic(uint8 *p);
+	void cmd_overlay_pic(uint8 *p);
+	void cmd_show_pri_screen(uint8 *p);
+	void cmd_load_view(uint8 *p);
+	void cmd_load_view_f(uint8 *p);
+	void cmd_discard_view(uint8 *p);	// 0x20
+	void cmd_animate_obj(uint8 *p);
+	void cmd_unanimate_all(uint8 *p);
+	void cmd_draw(uint8 *p);
+	void cmd_erase(uint8 *p);
+	void cmd_position(uint8 *p);
+	void cmd_position_f(uint8 *p);
+	void cmd_get_posn(uint8 *p);
+	void cmd_reposition(uint8 *p);	// 0x28
+	void cmd_set_view(uint8 *p);
+	void cmd_set_view_f(uint8 *p);
+	void cmd_set_loop(uint8 *p);
+	void cmd_set_loop_f(uint8 *p);
+	void cmd_fix_loop(uint8 *p);
+	void cmd_release_loop(uint8 *p);
+	void cmd_set_cel(uint8 *p);
+	void cmd_set_cel_f(uint8 *p);	// 0x30
+	void cmd_last_cel(uint8 *p);
+	void cmd_current_cel(uint8 *p);
+	void cmd_current_loop(uint8 *p);
+	void cmd_current_view(uint8 *p);
+	void cmd_number_of_loops(uint8 *p);
+	void cmd_set_priority(uint8 *p);
+	void cmd_set_priority_f(uint8 *p);
+	void cmd_release_priority(uint8 *p);	// 0x38
+	void cmd_get_priority(uint8 *p);
+	void cmd_stop_update(uint8 *p);
+	void cmd_start_update(uint8 *p);
+	void cmd_force_update(uint8 *p);
+	void cmd_ignore_horizon(uint8 *p);
+	void cmd_observe_horizon(uint8 *p);
+	void cmd_set_horizon(uint8 *p);
+	void cmd_object_on_water(uint8 *p);	// 0x40
+	void cmd_object_on_land(uint8 *p);
+	void cmd_object_on_anything(uint8 *p);
+	void cmd_ignore_objs(uint8 *p);
+	void cmd_observe_objs(uint8 *p);
+	void cmd_distance(uint8 *p);
+	void cmd_stop_cycling(uint8 *p);
+	void cmd_start_cycling(uint8 *p);
+	void cmd_normal_cycle(uint8 *p);	// 0x48
+	void cmd_end_of_loop(uint8 *p);
+	void cmd_reverse_cycle(uint8 *p);
+	void cmd_reverse_loop(uint8 *p);
+	void cmd_cycle_time(uint8 *p);
+	void cmd_stop_motion(uint8 *p);
+	void cmd_start_motion(uint8 *p);
+	void cmd_step_size(uint8 *p);
+	void cmd_step_time(uint8 *p);	// 0x50
+	void cmd_move_obj(uint8 *p);
+	void cmd_move_obj_f(uint8 *p);
+	void cmd_follow_ego(uint8 *p);
+	void cmd_wander(uint8 *p);
+	void cmd_normal_motion(uint8 *p);
+	void cmd_set_dir(uint8 *p);
+	void cmd_get_dir(uint8 *p);
+	void cmd_ignore_blocks(uint8 *p);	// 0x58
+	void cmd_observe_blocks(uint8 *p);
+	void cmd_block(uint8 *p);
+	void cmd_unblock(uint8 *p);
+	void cmd_get(uint8 *p);
+	void cmd_get_f(uint8 *p);
+	void cmd_drop(uint8 *p);
+	void cmd_put(uint8 *p);
+	void cmd_put_f(uint8 *p);	// 0x60
+	void cmd_get_room_f(uint8 *p);
+	void cmd_load_sound(uint8 *p);
+	void cmd_sound(uint8 *p);
+	void cmd_stop_sound(uint8 *p);
+	void cmd_print(uint8 *p);
+	void cmd_print_f(uint8 *p);
+	void cmd_display(uint8 *p);
+	void cmd_display_f(uint8 *p);	// 0x68
+	void cmd_clear_lines(uint8 *p);
+	void cmd_text_screen(uint8 *p);
+	void cmd_graphics(uint8 *p);
+	void cmd_set_cursor_char(uint8 *p);
+	void cmd_set_text_attribute(uint8 *p);
+	void cmd_shake_screen(uint8 *p);
+	void cmd_configure_screen(uint8 *p);
+	void cmd_status_line_on(uint8 *p);	// 0x70
+	void cmd_status_line_off(uint8 *p);
+	void cmd_set_string(uint8 *p);
+	void cmd_get_string(uint8 *p);
+	void cmd_word_to_string(uint8 *p);
+	void cmd_parse(uint8 *p);
+	void cmd_get_num(uint8 *p);
+	void cmd_prevent_input(uint8 *p);
+	void cmd_accept_input(uint8 *p);	// 0x78
+	void cmd_set_key(uint8 *p);
+	void cmd_add_to_pic(uint8 *p);
+	void cmd_add_to_pic_f(uint8 *p);
+	void cmd_status(uint8 *p);
+	void cmd_save_game(uint8 *p);
+	void cmd_load_game(uint8 *p);
+	void cmd_init_disk(uint8 *p);
+	void cmd_restart_game(uint8 *p);	// 0x80
+	void cmd_show_obj(uint8 *p);
+	void cmd_random(uint8 *p);
+	void cmd_program_control(uint8 *p);
+	void cmd_player_control(uint8 *p);
+	void cmd_obj_status_f(uint8 *p);
+	void cmd_quit(uint8 *p);
+	void cmd_show_mem(uint8 *p);
+	void cmd_pause(uint8 *p);	// 0x88
+	void cmd_echo_line(uint8 *p);
+	void cmd_cancel_line(uint8 *p);
+	void cmd_init_joy(uint8 *p);
+	void cmd_toggle_monitor(uint8 *p);
+	void cmd_version(uint8 *p);
+	void cmd_script_size(uint8 *p);
+	void cmd_set_game_id(uint8 *p);
+	void cmd_log(uint8 *p);	// 0x90
+	void cmd_set_scan_start(uint8 *p);
+	void cmd_reset_scan_start(uint8 *p);
+	void cmd_reposition_to(uint8 *p);
+	void cmd_reposition_to_f(uint8 *p);
+	void cmd_trace_on(uint8 *p);
+	void cmd_trace_info(uint8 *p);
+	void cmd_print_at(uint8 *p);
+	void cmd_print_at_v(uint8 *p);	// 0x98
+	//void cmd_discard_view(uint8 *p);	// Opcode repeated from 0x20 ?
+	void cmd_clear_text_rect(uint8 *p);
+	void cmd_set_upper_left(uint8 *p);
+	void cmd_set_menu(uint8 *p);
+	void cmd_set_menu_item(uint8 *p);
+	void cmd_submit_menu(uint8 *p);
+	void cmd_enable_item(uint8 *p);
+	void cmd_disable_item(uint8 *p);	// 0xa0
+	void cmd_menu_input(uint8 *p);
+	void cmd_show_obj_v(uint8 *p);
+	void cmd_open_dialogue(uint8 *p);
+	void cmd_close_dialogue(uint8 *p);
+	void cmd_mul_n(uint8 *p);
+	void cmd_mul_v(uint8 *p);
+	void cmd_div_n(uint8 *p);
+	void cmd_div_v(uint8 *p);	// 0xa8
+	void cmd_close_window(uint8 *p);
+	void cmd_set_simple(uint8 *p);
+	void cmd_push_script(uint8 *p);
+	void cmd_pop_script(uint8 *p);
+	void cmd_hold_key(uint8 *p);
+	void cmd_set_pri_base(uint8 *p);
+	void cmd_discard_sound(uint8 *p);
+	void cmd_hide_mouse(uint8 *p);	// 0xb0
+	void cmd_allow_menu(uint8 *p);
+	void cmd_show_mouse(uint8 *p);
+	void cmd_fence_mouse(uint8 *p);
+	void cmd_mouse_posn(uint8 *p);
+	void cmd_release_key(uint8 *p);
+	void cmd_adj_ego_move_to_x_y(uint8 *p);
 };
 
 } // End of namespace Agi
diff --git a/engines/agi/op_cmd.cpp b/engines/agi/op_cmd.cpp
index 9728ed9b42..e18b35d35d 100644
--- a/engines/agi/op_cmd.cpp
+++ b/engines/agi/op_cmd.cpp
@@ -35,6 +35,8 @@
 
 namespace Agi {
 
+#define g_agi this
+
 #define p0	(p[0])
 #define p1	(p[1])
 #define p2	(p[2])
@@ -43,34 +45,33 @@ namespace Agi {
 #define p5	(p[5])
 #define p6	(p[6])
 
-#define game g_agi->_game
-#define g_sprites g_agi->_sprites
-#define g_sound g_agi->_sound
-#define g_gfx g_agi->_gfx
-#define g_picture g_agi->_picture
+#define game _game
+#define g_sprites _sprites
+#define g_sound _sound
+#define g_gfx _gfx
+#define g_picture _picture
 
 #define ip	curLogic->cIP
-#define vt	game.viewTable[p0]
-#define vt_v game.viewTable[game.vars[p0]]
+#define vt	_game.viewTable[p0]
+#define vt_v _game.viewTable[_game.vars[p0]]
 
 static struct AgiLogic *curLogic;
 
 int timerHack;			// Workaround for timer loop in MH1
 
-#define _v game.vars
-#define cmd(x) static void cmd_##x (AgiEngine *g_agi, uint8 *p)
+#define _v _game.vars
 
-cmd(increment) {
+void AgiEngine::cmd_increment(uint8 *p) {
 	if (_v[p0] != 0xff)
 		++_v[p0];
 }
 
-cmd(decrement) {
+void AgiEngine::cmd_decrement(uint8 *p) {
 	if (_v[p0] != 0)
 		--_v[p0];
 }
 
-cmd(assignn) {
+void AgiEngine::cmd_assignn(uint8 *p) {
 	_v[p0] = p1;
 
 	// WORKAROUND for a bug in fan game "Get outta SQ"
@@ -84,83 +85,83 @@ cmd(assignn) {
 		_v[p0] = 8;
 }
 
-cmd(addn) {
+void AgiEngine::cmd_addn(uint8 *p) {
 	_v[p0] += p1;
 }
 
-cmd(subn) {
+void AgiEngine::cmd_subn(uint8 *p) {
 	_v[p0] -= p1;
 }
 
-cmd(assignv) {
+void AgiEngine::cmd_assignv(uint8 *p) {
 	_v[p0] = _v[p1];
 }
 
-cmd(addv) {
+void AgiEngine::cmd_addv(uint8 *p) {
 	_v[p0] += _v[p1];
 }
 
-cmd(subv) {
+void AgiEngine::cmd_subv(uint8 *p) {
 	_v[p0] -= _v[p1];
 }
 
-cmd(mul_n) {
+void AgiEngine::cmd_mul_n(uint8 *p) {
 	_v[p0] *= p1;
 }
 
-cmd(mul_v) {
+void AgiEngine::cmd_mul_v(uint8 *p) {
 	_v[p0] *= _v[p1];
 }
 
-cmd(div_n) {
+void AgiEngine::cmd_div_n(uint8 *p) {
 	_v[p0] /= p1;
 }
 
-cmd(div_v) {
+void AgiEngine::cmd_div_v(uint8 *p) {
 	_v[p0] /= _v[p1];
 }
 
-cmd(random) {
+void AgiEngine::cmd_random(uint8 *p) {
 	_v[p2] = g_agi->_rnd->getRandomNumber(p1 - p0) + p0;
 }
 
-cmd(lindirectn) {
+void AgiEngine::cmd_lindirectn(uint8 *p) {
 	_v[_v[p0]] = p1;
 }
 
-cmd(lindirectv) {
+void AgiEngine::cmd_lindirectv(uint8 *p) {
 	_v[_v[p0]] = _v[p1];
 }
 
-cmd(rindirect) {
+void AgiEngine::cmd_rindirect(uint8 *p) {
 	_v[p0] = _v[_v[p1]];
 }
 
-cmd(set) {
+void AgiEngine::cmd_set(uint8 *p) {
 	g_agi->setflag(*p, true);
 }
 
-cmd(reset) {
+void AgiEngine::cmd_reset(uint8 *p) {
 	g_agi->setflag(*p, false);
 }
 
-cmd(toggle) {
+void AgiEngine::cmd_toggle(uint8 *p) {
 	g_agi->setflag(*p, !g_agi->getflag(*p));
 }
 
-cmd(set_v) {
+void AgiEngine::cmd_set_v(uint8 *p) {
 	g_agi->setflag(_v[p0], true);
 }
 
-cmd(reset_v) {
+void AgiEngine::cmd_reset_v(uint8 *p) {
 	g_agi->setflag(_v[p0], false);
 }
 
-cmd(toggle_v) {
+void AgiEngine::cmd_toggle_v(uint8 *p) {
 	g_agi->setflag(_v[p0], !g_agi->getflag(_v[p0]));
 }
 
-cmd(new_room) {
+void AgiEngine::cmd_new_room(uint8 *p) {
 	g_agi->newRoom(p0);
 
 	// WORKAROUND: Works around intro skipping bug (#1737343) in Gold Rush.
@@ -176,79 +177,79 @@ cmd(new_room) {
 		game.keypress = 0;
 }
 
-cmd(new_room_f) {
+void AgiEngine::cmd_new_room_f(uint8 *p) {
 	g_agi->newRoom(_v[p0]);
 }
 
-cmd(load_view) {
+void AgiEngine::cmd_load_view(uint8 *p) {
 	g_agi->agiLoadResource(rVIEW, p0);
 }
 
-cmd(load_logic) {
+void AgiEngine::cmd_load_logic(uint8 *p) {
 	g_agi->agiLoadResource(rLOGIC, p0);
 }
 
-cmd(load_sound) {
+void AgiEngine::cmd_load_sound(uint8 *p) {
 	g_agi->agiLoadResource(rSOUND, p0);
 }
 
-cmd(load_view_f) {
+void AgiEngine::cmd_load_view_f(uint8 *p) {
 	g_agi->agiLoadResource(rVIEW, _v[p0]);
 }
 
-cmd(load_logic_f) {
+void AgiEngine::cmd_load_logic_f(uint8 *p) {
 	g_agi->agiLoadResource(rLOGIC, _v[p0]);
 }
 
-cmd(discard_view) {
+void AgiEngine::cmd_discard_view(uint8 *p) {
 	g_agi->agiUnloadResource(rVIEW, p0);
 }
 
-cmd(object_on_anything) {
+void AgiEngine::cmd_object_on_anything(uint8 *p) {
 	vt.flags &= ~(ON_WATER | ON_LAND);
 }
 
-cmd(object_on_land) {
+void AgiEngine::cmd_object_on_land(uint8 *p) {
 	vt.flags |= ON_LAND;
 }
 
-cmd(object_on_water) {
+void AgiEngine::cmd_object_on_water(uint8 *p) {
 	vt.flags |= ON_WATER;
 }
 
-cmd(observe_horizon) {
+void AgiEngine::cmd_observe_horizon(uint8 *p) {
 	vt.flags &= ~IGNORE_HORIZON;
 }
 
-cmd(ignore_horizon) {
+void AgiEngine::cmd_ignore_horizon(uint8 *p) {
 	vt.flags |= IGNORE_HORIZON;
 }
 
-cmd(observe_objs) {
+void AgiEngine::cmd_observe_objs(uint8 *p) {
 	vt.flags &= ~IGNORE_OBJECTS;
 }
 
-cmd(ignore_objs) {
+void AgiEngine::cmd_ignore_objs(uint8 *p) {
 	vt.flags |= IGNORE_OBJECTS;
 }
 
-cmd(observe_blocks) {
+void AgiEngine::cmd_observe_blocks(uint8 *p) {
 	vt.flags &= ~IGNORE_BLOCKS;
 }
 
-cmd(ignore_blocks) {
+void AgiEngine::cmd_ignore_blocks(uint8 *p) {
 	vt.flags |= IGNORE_BLOCKS;
 }
 
-cmd(set_horizon) {
+void AgiEngine::cmd_set_horizon(uint8 *p) {
 	game.horizon = p0;
 }
 
-cmd(get_priority) {
+void AgiEngine::cmd_get_priority(uint8 *p) {
 	_v[p1] = vt.priority;
 }
 
-cmd(set_priority) {
+void AgiEngine::cmd_set_priority(uint8 *p) {
 	vt.flags |= FIXED_PRIORITY;
 	vt.priority = p1;
 
@@ -271,242 +272,242 @@ cmd(set_priority) {
 	}
 }
 
-cmd(set_priority_f) {
+void AgiEngine::cmd_set_priority_f(uint8 *p) {
 	vt.flags |= FIXED_PRIORITY;
 	vt.priority = _v[p1];
 }
 
-cmd(release_priority) {
+void AgiEngine::cmd_release_priority(uint8 *p) {
 	vt.flags &= ~FIXED_PRIORITY;
 }
 
-cmd(set_upper_left) {				// do nothing (AGI 2.917)
+void AgiEngine::cmd_set_upper_left(uint8 *p) {				// do nothing (AGI 2.917)
 }
 
-cmd(start_update) {
+void AgiEngine::cmd_start_update(uint8 *p) {
 	g_agi->startUpdate(&vt);
 }
 
-cmd(stop_update) {
+void AgiEngine::cmd_stop_update(uint8 *p) {
 	g_agi->stopUpdate(&vt);
 }
 
-cmd(current_view) {
+void AgiEngine::cmd_current_view(uint8 *p) {
 	_v[p1] = vt.currentView;
 }
 
-cmd(current_cel) {
+void AgiEngine::cmd_current_cel(uint8 *p) {
 	_v[p1] = vt.currentCel;
 	debugC(4, kDebugLevelScripts, "v%d=%d", p1, _v[p1]);
 }
 
-cmd(current_loop) {
+void AgiEngine::cmd_current_loop(uint8 *p) {
 	_v[p1] = vt.currentLoop;
 }
 
-cmd(last_cel) {
+void AgiEngine::cmd_last_cel(uint8 *p) {
 	_v[p1] = vt.loopData->numCels - 1;
 }
 
-cmd(set_cel) {
+void AgiEngine::cmd_set_cel(uint8 *p) {
 	g_agi->setCel(&vt, p1);
 	vt.flags &= ~DONTUPDATE;
 }
 
-cmd(set_cel_f) {
+void AgiEngine::cmd_set_cel_f(uint8 *p) {
 	g_agi->setCel(&vt, _v[p1]);
 	vt.flags &= ~DONTUPDATE;
 }
 
-cmd(set_view) {
+void AgiEngine::cmd_set_view(uint8 *p) {
 	g_agi->setView(&vt, p1);
 }
 
-cmd(set_view_f) {
+void AgiEngine::cmd_set_view_f(uint8 *p) {
 	g_agi->setView(&vt, _v[p1]);
 }
 
-cmd(set_loop) {
+void AgiEngine::cmd_set_loop(uint8 *p) {
 	g_agi->setLoop(&vt, p1);
 }
 
-cmd(set_loop_f) {
+void AgiEngine::cmd_set_loop_f(uint8 *p) {
 	g_agi->setLoop(&vt, _v[p1]);
 }
 
-cmd(number_of_loops) {
+void AgiEngine::cmd_number_of_loops(uint8 *p) {
 	_v[p1] = vt.numLoops;
 }
 
-cmd(fix_loop) {
+void AgiEngine::cmd_fix_loop(uint8 *p) {
 	vt.flags |= FIX_LOOP;
 }
 
-cmd(release_loop) {
+void AgiEngine::cmd_release_loop(uint8 *p) {
 	vt.flags &= ~FIX_LOOP;
 }
 
-cmd(step_size) {
+void AgiEngine::cmd_step_size(uint8 *p) {
 	vt.stepSize = _v[p1];
 }
 
-cmd(step_time) {
+void AgiEngine::cmd_step_time(uint8 *p) {
 	vt.stepTime = vt.stepTimeCount = _v[p1];
 }
 
-cmd(cycle_time) {
+void AgiEngine::cmd_cycle_time(uint8 *p) {
 	vt.cycleTime = vt.cycleTimeCount = _v[p1];
 }
 
-cmd(stop_cycling) {
+void AgiEngine::cmd_stop_cycling(uint8 *p) {
 	vt.flags &= ~CYCLING;
 }
 
-cmd(start_cycling) {
+void AgiEngine::cmd_start_cycling(uint8 *p) {
 	vt.flags |= CYCLING;
 }
 
-cmd(normal_cycle) {
+void AgiEngine::cmd_normal_cycle(uint8 *p) {
 	vt.cycle = CYCLE_NORMAL;
 	vt.flags |= CYCLING;
 }
 
-cmd(reverse_cycle) {
+void AgiEngine::cmd_reverse_cycle(uint8 *p) {
 	vt.cycle = CYCLE_REVERSE;
 	vt.flags |= CYCLING;
 }
 
-cmd(set_dir) {
+void AgiEngine::cmd_set_dir(uint8 *p) {
 	vt.direction = _v[p1];
 }
 
-cmd(get_dir) {
+void AgiEngine::cmd_get_dir(uint8 *p) {
 	_v[p1] = vt.direction;
 }
 
-cmd(get_room_f) {
+void AgiEngine::cmd_get_room_f(uint8 *p) {
 	_v[p1] = g_agi->objectGetLocation(_v[p0]);
 }
 
-cmd(put) {
+void AgiEngine::cmd_put(uint8 *p) {
 	g_agi->objectSetLocation(p0, _v[p1]);
 }
 
-cmd(put_f) {
+void AgiEngine::cmd_put_f(uint8 *p) {
 	g_agi->objectSetLocation(_v[p0], _v[p1]);
 }
 
-cmd(drop) {
+void AgiEngine::cmd_drop(uint8 *p) {
 	g_agi->objectSetLocation(p0, 0);
 }
 
-cmd(get) {
+void AgiEngine::cmd_get(uint8 *p) {
 	g_agi->objectSetLocation(p0, EGO_OWNED);
 }
 
-cmd(get_f) {
+void AgiEngine::cmd_get_f(uint8 *p) {
 	g_agi->objectSetLocation(_v[p0], EGO_OWNED);
 }
 
-cmd(word_to_string) {
+void AgiEngine::cmd_word_to_string(uint8 *p) {
 	strcpy(game.strings[p0], game.egoWords[p1].word);
 }
 
-cmd(open_dialogue) {
+void AgiEngine::cmd_open_dialogue(uint8 *p) {
 	game.hasWindow = true;
 }
 
-cmd(close_dialogue) {
+void AgiEngine::cmd_close_dialogue(uint8 *p) {
 	game.hasWindow = false;
 }
 
-cmd(close_window) {
+void AgiEngine::cmd_close_window(uint8 *p) {
 	g_agi->closeWindow();
 }
 
-cmd(status_line_on) {
+void AgiEngine::cmd_status_line_on(uint8 *p) {
 	game.statusLine = true;
 	g_agi->writeStatus();
 }
 
-cmd(status_line_off) {
+void AgiEngine::cmd_status_line_off(uint8 *p) {
 	game.statusLine = false;
 	g_agi->writeStatus();
 }
 
-cmd(show_obj) {
+void AgiEngine::cmd_show_obj(uint8 *p) {
 	g_sprites->showObj(p0);
 }
 
-cmd(show_obj_v) {
+void AgiEngine::cmd_show_obj_v(uint8 *p) {
 	g_sprites->showObj(_v[p0]);
 }
 
-cmd(sound) {
+void AgiEngine::cmd_sound(uint8 *p) {
 	g_sound->startSound(p0, p1);
 }
 
-cmd(stop_sound) {
+void AgiEngine::cmd_stop_sound(uint8 *p) {
 	g_sound->stopSound();
 }
 
-cmd(menu_input) {
+void AgiEngine::cmd_menu_input(uint8 *p) {
 	g_agi->newInputMode(INPUT_MENU);
 }
 
-cmd(enable_item) {
+void AgiEngine::cmd_enable_item(uint8 *p) {
 	g_agi->_menu->setItem(p0, true);
 }
 
-cmd(disable_item) {
+void AgiEngine::cmd_disable_item(uint8 *p) {
 	g_agi->_menu->setItem(p0, false);
 }
 
-cmd(submit_menu) {
+void AgiEngine::cmd_submit_menu(uint8 *p) {
 	g_agi->_menu->submit();
 }
 
-cmd(set_scan_start) {
+void AgiEngine::cmd_set_scan_start(uint8 *p) {
 	curLogic->sIP = curLogic->cIP;
 }
 
-cmd(reset_scan_start) {
+void AgiEngine::cmd_reset_scan_start(uint8 *p) {
 	curLogic->sIP = 2;
 }
 
-cmd(save_game) {
+void AgiEngine::cmd_save_game(uint8 *p) {
 	game.simpleSave ? g_agi->saveGameSimple() : g_agi->saveGameDialog();
 }
 
-cmd(load_game) {
+void AgiEngine::cmd_load_game(uint8 *p) {
 	assert(1);
 	game.simpleSave ? g_agi->loadGameSimple() : g_agi->loadGameDialog();
 }
 
-cmd(init_disk) {				// do nothing
+void AgiEngine::cmd_init_disk(uint8 *p) {				// do nothing
 }
 
-cmd(log) {				// do nothing
+void AgiEngine::cmd_log(uint8 *p) {				// do nothing
 }
 
-cmd(trace_on) {				// do nothing
+void AgiEngine::cmd_trace_on(uint8 *p) {				// do nothing
 }
 
-cmd(trace_info) {				// do nothing
+void AgiEngine::cmd_trace_info(uint8 *p) {				// do nothing
 }
 
-cmd(show_mem) {
+void AgiEngine::cmd_show_mem(uint8 *p) {
 	g_agi->messageBox("Enough memory");
 }
 
-cmd(init_joy) { // do nothing
+void AgiEngine::cmd_init_joy(uint8 *p) { // do nothing
 }
 
-cmd(script_size) {
+void AgiEngine::cmd_script_size(uint8 *p) {
 	report("script.size(%d)\n", p0);
 }
 
-cmd(cancel_line) {
+void AgiEngine::cmd_cancel_line(uint8 *p) {
 	g_agi->_game.inputBuffer[0] = 0;
 	g_agi->writePrompt();
 }
@@ -521,7 +522,7 @@ cmd(cancel_line) {
 // 4051 (When ego is stationary),
 // 471 (When walking on the first screen's bridge),
 // 71 (When walking around, using the mouse or the keyboard).
-cmd(obj_status_f) {
+void AgiEngine::cmd_obj_status_f(uint8 *p) {
 	const char *cycleDesc;  // Object's cycle description line
 	const char *motionDesc; // Object's motion description line
 	char msg[256];          // The whole object status message
@@ -593,22 +594,22 @@ cmd(obj_status_f) {
 // unk_174: Change priority table (used in KQ4) -- j5
 // unk_177: Disable menus completely -- j5
 // unk_181: Deactivate keypressed control (default control of ego)
-cmd(set_simple) {
+void AgiEngine::cmd_set_simple(uint8 *p) {
 	if (!(g_agi->getFeatures() & (GF_AGI256 | GF_AGI256_2))) {
 		game.simpleSave = true;
 	} else { // AGI256 and AGI256-2 use this unknown170 command to load 256 color pictures.
-		// Load the picture. Similar to cmd(load_pic).
+		// Load the picture. Similar to void AgiEngine::cmd_load_pic(uint8 *p).
 		g_sprites->eraseBoth();
 		g_agi->agiLoadResource(rPICTURE, _v[p0]);
 
-		// Draw the picture. Similar to cmd(draw_pic).
+		// Draw the picture. Similar to void AgiEngine::cmd_draw_pic(uint8 *p).
 		g_picture->decodePicture(_v[p0], false, true);
 		g_sprites->blitBoth();
 		game.pictureShown = 0;
 
-		// Show the picture. Similar to cmd(show_pic).
+		// Show the picture. Similar to void AgiEngine::cmd_show_pic(uint8 *p).
 		g_agi->setflag(fOutputMode, false);
-		cmd_close_window(g_agi, NULL);
+		g_agi->closeWindow();
 		g_picture->showPic();
 		game.pictureShown = 1;
 
@@ -617,25 +618,25 @@ cmd(set_simple) {
 	}
 }
 
-cmd(pop_script) {
+void AgiEngine::cmd_pop_script(uint8 *p) {
 	if (g_agi->getVersion() >= 0x2915) {
 		report("pop.script\n");
 	}
 }
 
-cmd(hold_key) {
+void AgiEngine::cmd_hold_key(uint8 *p) {
 	if (g_agi->getVersion() >= 0x3098) {
 		g_agi->_egoHoldKey = true;
 	}
 }
 
-cmd(discard_sound) {
+void AgiEngine::cmd_discard_sound(uint8 *p) {
 	if (g_agi->getVersion() >= 0x2936) {
 		report("discard.sound\n");
 	}
 }
 
-cmd(hide_mouse) {
+void AgiEngine::cmd_hide_mouse(uint8 *p) {
 	// WORKAROUND: Turns off current movement that's being caused with the mouse.
 	// This fixes problems with too many popup boxes appearing in the Amiga
 	// Gold Rush's copy protection failure scene (i.e. the hanging scene, logic.192).
@@ -648,29 +649,29 @@ cmd(hide_mouse) {
 	g_system->showMouse(false);
 }
 
-cmd(allow_menu) {
+void AgiEngine::cmd_allow_menu(uint8 *p) {
 	if (g_agi->getVersion() >= 0x3098) {
 		g_agi->setflag(fMenusWork, ((p0 != 0) ? true : false));
 	}
 }
 
-cmd(show_mouse) {
+void AgiEngine::cmd_show_mouse(uint8 *p) {
 	g_system->showMouse(true);
 }
 
-cmd(fence_mouse) {
+void AgiEngine::cmd_fence_mouse(uint8 *p) {
 	g_agi->_game.mouseFence.moveTo(p0, p1);
 	g_agi->_game.mouseFence.setWidth(p2 - p0);
 	g_agi->_game.mouseFence.setHeight(p3 - p1);
 }
 
-cmd(release_key) {
+void AgiEngine::cmd_release_key(uint8 *p) {
 	if (g_agi->getVersion() >= 0x3098) {
 		g_agi->_egoHoldKey = false;
 	}
 }
 
-cmd(adj_ego_move_to_x_y) {
+void AgiEngine::cmd_adj_ego_move_to_x_y(uint8 *p) {
 	int8 x, y;
 
 	switch (logicNamesCmd[182].numArgs) {
@@ -708,7 +709,7 @@ cmd(adj_ego_move_to_x_y) {
 	}
 }
 
-cmd(parse) {
+void AgiEngine::cmd_parse(uint8 *p) {
 	_v[vWordNotFound] = 0;
 	g_agi->setflag(fEnteredCli, false);
 	g_agi->setflag(fSaidAcceptedInput, false);
@@ -716,7 +717,7 @@ cmd(parse) {
 	g_agi->dictionaryWords(g_agi->agiSprintf(game.strings[p0]));
 }
 
-cmd(call) {
+void AgiEngine::cmd_call(uint8 *p) {
 	int oldCIP;
 	int oldLognum;
 
@@ -732,11 +733,11 @@ cmd(call) {
 	curLogic->cIP = oldCIP;
 }
 
-cmd(call_f) {
-	cmd_call(g_agi, &_v[p0]);
+void AgiEngine::cmd_call_f(uint8 *p) {
+	cmd_call(&_v[p0]);
 }
 
-cmd(draw_pic) {
+void AgiEngine::cmd_draw_pic(uint8 *p) {
 	debugC(6, kDebugLevelScripts, "=== draw pic %d ===", _v[p0]);
 	g_sprites->eraseBoth();
 	g_picture->decodePicture(_v[p0], true);
@@ -764,30 +765,30 @@ cmd(draw_pic) {
 	g_agi->pause(kPausePicture);
 }
 
-cmd(show_pic) {
+void AgiEngine::cmd_show_pic(uint8 *p) {
 	debugC(6, kDebugLevelScripts, "=== show pic ===");
 
 	g_agi->setflag(fOutputMode, false);
-	cmd_close_window(g_agi, NULL);
+	g_agi->closeWindow();
 	g_picture->showPic();
 	game.pictureShown = 1;
 
 	debugC(6, kDebugLevelScripts, "--- end of show pic ---");
 }
 
-cmd(load_pic) {
+void AgiEngine::cmd_load_pic(uint8 *p) {
 	g_sprites->eraseBoth();
 	g_agi->agiLoadResource(rPICTURE, _v[p0]);
 	g_sprites->blitBoth();
 	g_sprites->commitBoth();
 }
 
-cmd(discard_pic) {
+void AgiEngine::cmd_discard_pic(uint8 *p) {
 	debugC(6, kDebugLevelScripts, "--- discard pic ---");
 	// do nothing
 }
 
-cmd(overlay_pic) {
+void AgiEngine::cmd_overlay_pic(uint8 *p) {
 	debugC(6, kDebugLevelScripts, "--- overlay pic ---");
 
 	g_sprites->eraseBoth();
@@ -800,7 +801,7 @@ cmd(overlay_pic) {
 	g_agi->pause(kPausePicture);
 }
 
-cmd(show_pri_screen) {
+void AgiEngine::cmd_show_pri_screen(uint8 *p) {
 	g_agi->_debug.priority = 1;
 	g_sprites->eraseBoth();
 	g_picture->showPic();
@@ -814,7 +815,7 @@ cmd(show_pri_screen) {
 	g_sprites->blitBoth();
 }
 
-cmd(animate_obj) {
+void AgiEngine::cmd_animate_obj(uint8 *p) {
 	if (vt.flags & ANIMATED)
 		return;
 
@@ -825,14 +826,14 @@ cmd(animate_obj) {
 	vt.direction = 0;
 }
 
-cmd(unanimate_all) {
+void AgiEngine::cmd_unanimate_all(uint8 *p) {
 	int i;
 
 	for (i = 0; i < MAX_VIEWTABLE; i++)
 		game.viewTable[i].flags &= ~(ANIMATED | DRAWN);
 }
 
-cmd(draw) {
+void AgiEngine::cmd_draw(uint8 *p) {
 	if (vt.flags & DRAWN)
 		return;
 
@@ -876,7 +877,7 @@ cmd(draw) {
 	debugC(4, kDebugLevelScripts, "vt entry #%d flags = %02x", p0, vt.flags);
 }
 
-cmd(erase) {
+void AgiEngine::cmd_erase(uint8 *p) {
 	if (~vt.flags & DRAWN)
 		return;
 
@@ -901,7 +902,7 @@ cmd(erase) {
 	g_sprites->commitBlock(x1, y1, x2, y2, true);
 }
 
-cmd(position) {
+void AgiEngine::cmd_position(uint8 *p) {
 	vt.xPos = vt.xPos2 = p1;
 	vt.yPos = vt.yPos2 = p2;
 
@@ -922,7 +923,7 @@ cmd(position) {
 		g_agi->clipViewCoordinates(&vt);
 }
 
-cmd(position_f) {
+void AgiEngine::cmd_position_f(uint8 *p) {
 	vt.xPos = vt.xPos2 = _v[p1];
 	vt.yPos = vt.yPos2 = _v[p2];
 
@@ -933,12 +934,12 @@ cmd(position_f) {
 		g_agi->clipViewCoordinates(&vt);
 }
 
-cmd(get_posn) {
+void AgiEngine::cmd_get_posn(uint8 *p) {
 	game.vars[p1] = (unsigned char)vt.xPos;
 	game.vars[p2] = (unsigned char)vt.yPos;
 }
 
-cmd(reposition) {
+void AgiEngine::cmd_reposition(uint8 *p) {
 	int dx = (int8) _v[p1], dy = (int8) _v[p2];
 
 	debugC(4, kDebugLevelScripts, "dx=%d, dy=%d", dx, dy);
@@ -957,35 +958,35 @@ cmd(reposition) {
 	g_agi->fixPosition(p0);
 }
 
-cmd(reposition_to) {
+void AgiEngine::cmd_reposition_to(uint8 *p) {
 	vt.xPos = p1;
 	vt.yPos = p2;
 	vt.flags |= UPDATE_POS;
 	g_agi->fixPosition(p0);
 }
 
-cmd(reposition_to_f) {
+void AgiEngine::cmd_reposition_to_f(uint8 *p) {
 	vt.xPos = _v[p1];
 	vt.yPos = _v[p2];
 	vt.flags |= UPDATE_POS;
 	g_agi->fixPosition(p0);
 }
 
-cmd(add_to_pic) {
+void AgiEngine::cmd_add_to_pic(uint8 *p) {
 	g_sprites->addToPic(p0, p1, p2, p3, p4, p5, p6);
 }
 
-cmd(add_to_pic_f) {
+void AgiEngine::cmd_add_to_pic_f(uint8 *p) {
 	g_sprites->addToPic(_v[p0], _v[p1], _v[p2], _v[p3], _v[p4], _v[p5], _v[p6]);
 }
 
-cmd(force_update) {
+void AgiEngine::cmd_force_update(uint8 *p) {
 	g_sprites->eraseBoth();
 	g_sprites->blitBoth();
 	g_sprites->commitBoth();
 }
 
-cmd(reverse_loop) {
+void AgiEngine::cmd_reverse_loop(uint8 *p) {
 	debugC(4, kDebugLevelScripts, "o%d, f%d", p0, p1);
 	vt.cycle = CYCLE_REV_LOOP;
 	vt.flags |= (DONTUPDATE | UPDATE | CYCLING);
@@ -993,7 +994,7 @@ cmd(reverse_loop) {
 	g_agi->setflag(p1, false);
 }
 
-cmd(end_of_loop) {
+void AgiEngine::cmd_end_of_loop(uint8 *p) {
 	debugC(4, kDebugLevelScripts, "o%d, f%d", p0, p1);
 	vt.cycle = CYCLE_END_OF_LOOP;
 	vt.flags |= (DONTUPDATE | UPDATE | CYCLING);
@@ -1001,7 +1002,7 @@ cmd(end_of_loop) {
 	g_agi->setflag(p1, false);
 }
 
-cmd(block) {
+void AgiEngine::cmd_block(uint8 *p) {
 	debugC(4, kDebugLevelScripts, "x1=%d, y1=%d, x2=%d, y2=%d", p0, p1, p2, p3);
 	game.block.active = true;
 	game.block.x1 = p0;
@@ -1010,15 +1011,15 @@ cmd(block) {
 	game.block.y2 = p3;
 }
 
-cmd(unblock) {
+void AgiEngine::cmd_unblock(uint8 *p) {
 	game.block.active = false;
 }
 
-cmd(normal_motion) {
+void AgiEngine::cmd_normal_motion(uint8 *p) {
 	vt.motion = MOTION_NORMAL;
 }
 
-cmd(stop_motion) {
+void AgiEngine::cmd_stop_motion(uint8 *p) {
 	vt.direction = 0;
 	vt.motion = MOTION_NORMAL;
 	if (p0 == 0) {		// ego only
@@ -1027,7 +1028,7 @@ cmd(stop_motion) {
 	}
 }
 
-cmd(start_motion) {
+void AgiEngine::cmd_start_motion(uint8 *p) {
 	vt.motion = MOTION_NORMAL;
 	if (p0 == 0) {		// ego only
 		_v[vEgoDir] = 0;
@@ -1035,16 +1036,16 @@ cmd(start_motion) {
 	}
 }
 
-cmd(player_control) {
+void AgiEngine::cmd_player_control(uint8 *p) {
 	game.playerControl = true;
 	game.viewTable[0].motion = MOTION_NORMAL;
 }
 
-cmd(program_control) {
+void AgiEngine::cmd_program_control(uint8 *p) {
 	game.playerControl = false;
 }
 
-cmd(follow_ego) {
+void AgiEngine::cmd_follow_ego(uint8 *p) {
 	vt.motion = MOTION_FOLLOW_EGO;
 	vt.parm1 = p1 > vt.stepSize ? p1 : vt.stepSize;
 	vt.parm2 = p2;
@@ -1053,7 +1054,7 @@ cmd(follow_ego) {
 	vt.flags |= UPDATE;
 }
 
-cmd(move_obj) {
+void AgiEngine::cmd_move_obj(uint8 *p) {
 	// _D (_D_WARN "o=%d, x=%d, y=%d, s=%d, f=%d", p0, p1, p2, p3, p4);
 
 	vt.motion = MOTION_MOVE_OBJ;
@@ -1076,7 +1077,7 @@ cmd(move_obj) {
 		g_agi->moveObj(&vt);
 }
 
-cmd(move_obj_f) {
+void AgiEngine::cmd_move_obj_f(uint8 *p) {
 	vt.motion = MOTION_MOVE_OBJ;
 	vt.parm1 = _v[p1];
 	vt.parm2 = _v[p2];
@@ -1097,7 +1098,7 @@ cmd(move_obj_f) {
 		g_agi->moveObj(&vt);
 }
 
-cmd(wander) {
+void AgiEngine::cmd_wander(uint8 *p) {
 	if (p0 == 0)
 		game.playerControl = false;
 
@@ -1105,7 +1106,7 @@ cmd(wander) {
 	vt.flags |= UPDATE;
 }
 
-cmd(set_game_id) {
+void AgiEngine::cmd_set_game_id(uint8 *p) {
 	if (curLogic->texts && (p0 - 1) <= curLogic->numTexts)
 		strncpy(game.id, curLogic->texts[p0 - 1], 8);
 	else
@@ -1114,7 +1115,7 @@ cmd(set_game_id) {
 	report("Game ID: \"%s\"\n", game.id);
 }
 
-cmd(pause) {
+void AgiEngine::cmd_pause(uint8 *p) {
 	int tmp = game.clockEnabled;
 	const char *b[] = { "Continue", NULL };
 	const char *b_ru[] = { "\x8f\xe0\xae\xa4\xae\xab\xa6\xa8\xe2\xec", NULL };
@@ -1132,21 +1133,21 @@ cmd(pause) {
 	game.clockEnabled = tmp;
 }
 
-cmd(set_menu) {
+void AgiEngine::cmd_set_menu(uint8 *p) {
 	debugC(4, kDebugLevelScripts, "text %02x of %02x", p0, curLogic->numTexts);
 
 	if (curLogic->texts != NULL && p0 <= curLogic->numTexts)
 		g_agi->_menu->add(curLogic->texts[p0 - 1]);
 }
 
-cmd(set_menu_item) {
+void AgiEngine::cmd_set_menu_item(uint8 *p) {
 	debugC(4, kDebugLevelScripts, "text %02x of %02x", p0, curLogic->numTexts);
 
 	if (curLogic->texts != NULL && p0 <= curLogic->numTexts)
 		g_agi->_menu->addItem(curLogic->texts[p0 - 1], p1);
 }
 
-cmd(version) {
+void AgiEngine::cmd_version(uint8 *p) {
 	char verMsg[64];
 	char ver2Msg[] =
 	    "\n"
@@ -1186,13 +1187,13 @@ cmd(version) {
 	g_agi->messageBox(msg);
 }
 
-cmd(configure_screen) {
+void AgiEngine::cmd_configure_screen(uint8 *p) {
 	game.lineMinPrint = p0;
 	game.lineUserInput = p1;
 	game.lineStatus = p2;
 }
 
-cmd(text_screen) {
+void AgiEngine::cmd_text_screen(uint8 *p) {
 	debugC(4, kDebugLevelScripts, "switching to text mode");
 	game.gfxMode = false;
 
@@ -1204,7 +1205,7 @@ cmd(text_screen) {
 	g_gfx->clearScreen(game.colorBg);
 }
 
-cmd(graphics) {
+void AgiEngine::cmd_graphics(uint8 *p) {
 	debugC(4, kDebugLevelScripts, "switching to graphics mode");
 
 	if (!game.gfxMode) {
@@ -1216,7 +1217,7 @@ cmd(graphics) {
 	}
 }
 
-cmd(set_text_attribute) {
+void AgiEngine::cmd_set_text_attribute(uint8 *p) {
 	game.colorFg = p0;
 	game.colorBg = p1;
 
@@ -1228,11 +1229,11 @@ cmd(set_text_attribute) {
 	}
 }
 
-cmd(status) {
+void AgiEngine::cmd_status(uint8 *p) {
 	g_agi->inventory();
 }
 
-cmd(quit) {
+void AgiEngine::cmd_quit(uint8 *p) {
 	const char *buttons[] = { "Quit", "Continue", NULL };
 
 	g_sound->stopSound();
@@ -1246,7 +1247,7 @@ cmd(quit) {
 	}
 }
 
-cmd(restart_game) {
+void AgiEngine::cmd_restart_game(uint8 *p) {
 	const char *buttons[] = { "Restart", "Continue", NULL };
 	int sel;
 
@@ -1261,7 +1262,7 @@ cmd(restart_game) {
 	}
 }
 
-cmd(distance) {
+void AgiEngine::cmd_distance(uint8 *p) {
 	int16 x1, y1, x2, y2, d;
 	VtEntry *v0 = &game.viewTable[p0];
 	VtEntry *v1 = &game.viewTable[p1];
@@ -1312,7 +1313,7 @@ cmd(distance) {
 	_v[p2] = (unsigned char)d;
 }
 
-cmd(accept_input) {
+void AgiEngine::cmd_accept_input(uint8 *p) {
 	debugC(4, kDebugLevelScripts | kDebugLevelInput, "input normal");
 
 	g_agi->newInputMode(INPUT_NORMAL);
@@ -1320,7 +1321,7 @@ cmd(accept_input) {
 	g_agi->writePrompt();
 }
 
-cmd(prevent_input) {
+void AgiEngine::cmd_prevent_input(uint8 *p) {
 	debugC(4, kDebugLevelScripts | kDebugLevelInput, "no input");
 
 	g_agi->newInputMode(INPUT_NONE);
@@ -1329,7 +1330,7 @@ cmd(prevent_input) {
 	g_agi->clearPrompt();
 }
 
-cmd(get_string) {
+void AgiEngine::cmd_get_string(uint8 *p) {
 	int tex, row, col;
 
 	debugC(4, kDebugLevelScripts, "%d %d %d %d %d", p0, p1, p2, p3, p4);
@@ -1362,7 +1363,7 @@ cmd(get_string) {
 	} while (game.inputMode == INPUT_GETSTRING && !(g_agi->shouldQuit() || g_agi->_restartGame));
 }
 
-cmd(get_num) {
+void AgiEngine::cmd_get_num(uint8 *p) {
 	debugC(4, kDebugLevelScripts, "%d %d", p0, p1);
 
 	g_agi->newInputMode(INPUT_GETSTRING);
@@ -1389,7 +1390,7 @@ cmd(get_num) {
 	g_agi->flushLines(22, 22);
 }
 
-cmd(set_cursor_char) {
+void AgiEngine::cmd_set_cursor_char(uint8 *p) {
 	if (curLogic->texts != NULL && (p0 - 1) <= curLogic->numTexts) {
 		game.cursorChar = *curLogic->texts[p0 - 1];
 	} else {
@@ -1398,7 +1399,7 @@ cmd(set_cursor_char) {
 	}
 }
 
-cmd(set_key) {
+void AgiEngine::cmd_set_key(uint8 *p) {
 	int key;
 
 	if (game.lastController >= MAX_CONTROLLERS) {
@@ -1417,14 +1418,14 @@ cmd(set_key) {
 	game.controllerOccured[p2] = false;
 }
 
-cmd(set_string) {
+void AgiEngine::cmd_set_string(uint8 *p) {
 	// CM: to avoid crash in Groza (str = 150)
 	if (p0 > MAX_STRINGS)
 		return;
 	strcpy(game.strings[p0], curLogic->texts[p1 - 1]);
 }
 
-cmd(display) {
+void AgiEngine::cmd_display(uint8 *p) {
 	int len = 40;
 
 	char *s = g_agi->wordWrapString(curLogic->texts[p2 - 1], &len);
@@ -1434,11 +1435,11 @@ cmd(display) {
 	free(s);
 }
 
-cmd(display_f) {
+void AgiEngine::cmd_display_f(uint8 *p) {
 	g_agi->printText(curLogic->texts[_v[p2] - 1], _v[p1], 0, _v[p0], 40, game.colorFg, game.colorBg);
 }
 
-cmd(clear_text_rect) {
+void AgiEngine::cmd_clear_text_rect(uint8 *p) {
 	int c, x1, y1, x2, y2;
 
 	if ((c = p4) != 0)
@@ -1463,17 +1464,17 @@ cmd(clear_text_rect) {
 	g_gfx->flushBlock(x1, y1, x2, y2);
 }
 
-cmd(toggle_monitor) {
+void AgiEngine::cmd_toggle_monitor(uint8 *p) {
 	report("toggle.monitor\n");
 }
 
-cmd(echo_line) {
+void AgiEngine::cmd_echo_line(uint8 *p) {
 	strcpy((char *)game.inputBuffer, (const char *)game.echoBuffer);
 	game.cursorPos = strlen((char *)game.inputBuffer);
 	game.hasPrompt = 0;
 }
 
-cmd(clear_lines) {
+void AgiEngine::cmd_clear_lines(uint8 *p) {
 	uint8 l;
 
 	// Residence 44 calls clear.lines(24,0,0), see Sarien bug #558423
@@ -1487,19 +1488,19 @@ cmd(clear_lines) {
 	g_agi->flushLines(p0, l);
 }
 
-cmd(print) {
+void AgiEngine::cmd_print(uint8 *p) {
 	int n = p0 < 1 ? 1 : p0;
 
 	g_agi->print(curLogic->texts[n - 1], 0, 0, 0);
 }
 
-cmd(print_f) {
+void AgiEngine::cmd_print_f(uint8 *p) {
 	int n = _v[p0] < 1 ? 1 : _v[p0];
 
 	g_agi->print(curLogic->texts[n - 1], 0, 0, 0);
 }
 
-cmd(print_at) {
+void AgiEngine::cmd_print_at(uint8 *p) {
 	int n = p0 < 1 ? 1 : p0;
 
 	debugC(4, kDebugLevelScripts, "%d %d %d %d", p0, p1, p2, p3);
@@ -1507,13 +1508,13 @@ cmd(print_at) {
 	g_agi->print(curLogic->texts[n - 1], p1, p2, p3);
 }
 
-cmd(print_at_v) {
+void AgiEngine::cmd_print_at_v(uint8 *p) {
 	int n = _v[p0] < 1 ? 1 : _v[p0];
 
 	g_agi->print(curLogic->texts[n - 1], p1, p2, p3);
 }
 
-cmd(push_script) {
+void AgiEngine::cmd_push_script(uint8 *p) {
 	// We run AGIMOUSE always as a side effect
 	if (g_agi->getFeatures() & GF_AGIMOUSE || 1) {
 		game.vars[27] = g_agi->_mouse.button;
@@ -1526,7 +1527,7 @@ cmd(push_script) {
 	}
 }
 
-cmd(set_pri_base) {
+void AgiEngine::cmd_set_pri_base(uint8 *p) {
 	int i, x, pri;
 
 	report("Priority base set to %d\n", p0);
@@ -1542,12 +1543,12 @@ cmd(set_pri_base) {
 	}
 }
 
-cmd(mouse_posn) {
+void AgiEngine::cmd_mouse_posn(uint8 *p) {
 	_v[p0] = WIN_TO_PIC_X(g_agi->_mouse.x);
 	_v[p1] = WIN_TO_PIC_Y(g_agi->_mouse.y);
 }
 
-cmd(shake_screen) {
+void AgiEngine::cmd_shake_screen(uint8 *p) {
 	int i;
 
 	// AGIPAL uses shake.screen values between 100 and 109 to set the palette
@@ -1580,191 +1581,196 @@ cmd(shake_screen) {
 	game.inputEnabled = originalValue;
 }
 
-static void (*agiCommand[183])(AgiEngine *, uint8 *) = {
-	NULL,			// 0x00
-	cmd_increment,
-	cmd_decrement,
-	cmd_assignn,
-	cmd_assignv,
-	cmd_addn,
-	cmd_addv,
-	cmd_subn,
-	cmd_subv,	// 0x08
-	cmd_lindirectv,
-	cmd_rindirect,
-	cmd_lindirectn,
-	cmd_set,
-	cmd_reset,
-	cmd_toggle,
-	cmd_set_v,
-	cmd_reset_v,	// 0x10
-	cmd_toggle_v,
-	cmd_new_room,
-	cmd_new_room_f,
-	cmd_load_logic,
-	cmd_load_logic_f,
-	cmd_call,
-	cmd_call_f,
-	cmd_load_pic,	// 0x18
-	cmd_draw_pic,
-	cmd_show_pic,
-	cmd_discard_pic,
-	cmd_overlay_pic,
-	cmd_show_pri_screen,
-	cmd_load_view,
-	cmd_load_view_f,
-	cmd_discard_view,	// 0x20
-	cmd_animate_obj,
-	cmd_unanimate_all,
-	cmd_draw,
-	cmd_erase,
-	cmd_position,
-	cmd_position_f,
-	cmd_get_posn,
-	cmd_reposition,	// 0x28
-	cmd_set_view,
-	cmd_set_view_f,
-	cmd_set_loop,
-	cmd_set_loop_f,
-	cmd_fix_loop,
-	cmd_release_loop,
-	cmd_set_cel,
-	cmd_set_cel_f,	// 0x30
-	cmd_last_cel,
-	cmd_current_cel,
-	cmd_current_loop,
-	cmd_current_view,
-	cmd_number_of_loops,
-	cmd_set_priority,
-	cmd_set_priority_f,
-	cmd_release_priority,	// 0x38
-	cmd_get_priority,
-	cmd_stop_update,
-	cmd_start_update,
-	cmd_force_update,
-	cmd_ignore_horizon,
-	cmd_observe_horizon,
-	cmd_set_horizon,
-	cmd_object_on_water,	// 0x40
-	cmd_object_on_land,
-	cmd_object_on_anything,
-	cmd_ignore_objs,
-	cmd_observe_objs,
-	cmd_distance,
-	cmd_stop_cycling,
-	cmd_start_cycling,
-	cmd_normal_cycle,	// 0x48
-	cmd_end_of_loop,
-	cmd_reverse_cycle,
-	cmd_reverse_loop,
-	cmd_cycle_time,
-	cmd_stop_motion,
-	cmd_start_motion,
-	cmd_step_size,
-	cmd_step_time,	// 0x50
-	cmd_move_obj,
-	cmd_move_obj_f,
-	cmd_follow_ego,
-	cmd_wander,
-	cmd_normal_motion,
-	cmd_set_dir,
-	cmd_get_dir,
-	cmd_ignore_blocks,	// 0x58
-	cmd_observe_blocks,
-	cmd_block,
-	cmd_unblock,
-	cmd_get,
-	cmd_get_f,
-	cmd_drop,
-	cmd_put,
-	cmd_put_f,	// 0x60
-	cmd_get_room_f,
-	cmd_load_sound,
-	cmd_sound,
-	cmd_stop_sound,
-	cmd_print,
-	cmd_print_f,
-	cmd_display,
-	cmd_display_f,	// 0x68
-	cmd_clear_lines,
-	cmd_text_screen,
-	cmd_graphics,
-	cmd_set_cursor_char,
-	cmd_set_text_attribute,
-	cmd_shake_screen,
-	cmd_configure_screen,
-	cmd_status_line_on,	// 0x70
-	cmd_status_line_off,
-	cmd_set_string,
-	cmd_get_string,
-	cmd_word_to_string,
-	cmd_parse,
-	cmd_get_num,
-	cmd_prevent_input,
-	cmd_accept_input,	// 0x78
-	cmd_set_key,
-	cmd_add_to_pic,
-	cmd_add_to_pic_f,
-	cmd_status,
-	cmd_save_game,
-	cmd_load_game,
-	cmd_init_disk,
-	cmd_restart_game,	// 0x80
-	cmd_show_obj,
-	cmd_random,
-	cmd_program_control,
-	cmd_player_control,
-	cmd_obj_status_f,
-	cmd_quit,
-	cmd_show_mem,
-	cmd_pause,	// 0x88
-	cmd_echo_line,
-	cmd_cancel_line,
-	cmd_init_joy,
-	cmd_toggle_monitor,
-	cmd_version,
-	cmd_script_size,
-	cmd_set_game_id,
-	cmd_log,	// 0x90
-	cmd_set_scan_start,
-	cmd_reset_scan_start,
-	cmd_reposition_to,
-	cmd_reposition_to_f,
-	cmd_trace_on,
-	cmd_trace_info,
-	cmd_print_at,
-	cmd_print_at_v,	// 0x98
-	cmd_discard_view,
-	cmd_clear_text_rect,
-	cmd_set_upper_left,
-	cmd_set_menu,
-	cmd_set_menu_item,
-	cmd_submit_menu,
-	cmd_enable_item,
-	cmd_disable_item,	// 0xa0
-	cmd_menu_input,
-	cmd_show_obj_v,
-	cmd_open_dialogue,
-	cmd_close_dialogue,
-	cmd_mul_n,
-	cmd_mul_v,
-	cmd_div_n,
-	cmd_div_v,	// 0xa8
-	cmd_close_window,
-	cmd_set_simple,
-	cmd_push_script,
-	cmd_pop_script,
-	cmd_hold_key,
-	cmd_set_pri_base,
-	cmd_discard_sound,
-	cmd_hide_mouse,	// 0xb0
-	cmd_allow_menu,
-	cmd_show_mouse,
-	cmd_fence_mouse,
-	cmd_mouse_posn,
-	cmd_release_key,
-	cmd_adj_ego_move_to_x_y
-};
+void AgiEngine::setupOpcodes() {
+	AgiCommand tmp[] = {
+		NULL,			// 0x00
+		&AgiEngine::cmd_increment,
+		&AgiEngine::cmd_decrement,
+		&AgiEngine::cmd_assignn,
+		&AgiEngine::cmd_assignv,
+		&AgiEngine::cmd_addn,
+		&AgiEngine::cmd_addv,
+		&AgiEngine::cmd_subn,
+		&AgiEngine::cmd_subv,	// 0x08
+		&AgiEngine::cmd_lindirectv,
+		&AgiEngine::cmd_rindirect,
+		&AgiEngine::cmd_lindirectn,
+		&AgiEngine::cmd_set,
+		&AgiEngine::cmd_reset,
+		&AgiEngine::cmd_toggle,
+		&AgiEngine::cmd_set_v,
+		&AgiEngine::cmd_reset_v,	// 0x10
+		&AgiEngine::cmd_toggle_v,
+		&AgiEngine::cmd_new_room,
+		&AgiEngine::cmd_new_room_f,
+		&AgiEngine::cmd_load_logic,
+		&AgiEngine::cmd_load_logic_f,
+		&AgiEngine::cmd_call,
+		&AgiEngine::cmd_call_f,
+		&AgiEngine::cmd_load_pic,	// 0x18
+		&AgiEngine::cmd_draw_pic,
+		&AgiEngine::cmd_show_pic,
+		&AgiEngine::cmd_discard_pic,
+		&AgiEngine::cmd_overlay_pic,
+		&AgiEngine::cmd_show_pri_screen,
+		&AgiEngine::cmd_load_view,
+		&AgiEngine::cmd_load_view_f,
+		&AgiEngine::cmd_discard_view,	// 0x20
+		&AgiEngine::cmd_animate_obj,
+		&AgiEngine::cmd_unanimate_all,
+		&AgiEngine::cmd_draw,
+		&AgiEngine::cmd_erase,
+		&AgiEngine::cmd_position,
+		&AgiEngine::cmd_position_f,
+		&AgiEngine::cmd_get_posn,
+		&AgiEngine::cmd_reposition,	// 0x28
+		&AgiEngine::cmd_set_view,
+		&AgiEngine::cmd_set_view_f,
+		&AgiEngine::cmd_set_loop,
+		&AgiEngine::cmd_set_loop_f,
+		&AgiEngine::cmd_fix_loop,
+		&AgiEngine::cmd_release_loop,
+		&AgiEngine::cmd_set_cel,
+		&AgiEngine::cmd_set_cel_f,	// 0x30
+		&AgiEngine::cmd_last_cel,
+		&AgiEngine::cmd_current_cel,
+		&AgiEngine::cmd_current_loop,
+		&AgiEngine::cmd_current_view,
+		&AgiEngine::cmd_number_of_loops,
+		&AgiEngine::cmd_set_priority,
+		&AgiEngine::cmd_set_priority_f,
+		&AgiEngine::cmd_release_priority,	// 0x38
+		&AgiEngine::cmd_get_priority,
+		&AgiEngine::cmd_stop_update,
+		&AgiEngine::cmd_start_update,
+		&AgiEngine::cmd_force_update,
+		&AgiEngine::cmd_ignore_horizon,
+		&AgiEngine::cmd_observe_horizon,
+		&AgiEngine::cmd_set_horizon,
+		&AgiEngine::cmd_object_on_water,	// 0x40
+		&AgiEngine::cmd_object_on_land,
+		&AgiEngine::cmd_object_on_anything,
+		&AgiEngine::cmd_ignore_objs,
+		&AgiEngine::cmd_observe_objs,
+		&AgiEngine::cmd_distance,
+		&AgiEngine::cmd_stop_cycling,
+		&AgiEngine::cmd_start_cycling,
+		&AgiEngine::cmd_normal_cycle,	// 0x48
+		&AgiEngine::cmd_end_of_loop,
+		&AgiEngine::cmd_reverse_cycle,
+		&AgiEngine::cmd_reverse_loop,
+		&AgiEngine::cmd_cycle_time,
+		&AgiEngine::cmd_stop_motion,
+		&AgiEngine::cmd_start_motion,
+		&AgiEngine::cmd_step_size,
+		&AgiEngine::cmd_step_time,	// 0x50
+		&AgiEngine::cmd_move_obj,
+		&AgiEngine::cmd_move_obj_f,
+		&AgiEngine::cmd_follow_ego,
+		&AgiEngine::cmd_wander,
+		&AgiEngine::cmd_normal_motion,
+		&AgiEngine::cmd_set_dir,
+		&AgiEngine::cmd_get_dir,
+		&AgiEngine::cmd_ignore_blocks,	// 0x58
+		&AgiEngine::cmd_observe_blocks,
+		&AgiEngine::cmd_block,
+		&AgiEngine::cmd_unblock,
+		&AgiEngine::cmd_get,
+		&AgiEngine::cmd_get_f,
+		&AgiEngine::cmd_drop,
+		&AgiEngine::cmd_put,
+		&AgiEngine::cmd_put_f,	// 0x60
+		&AgiEngine::cmd_get_room_f,
+		&AgiEngine::cmd_load_sound,
+		&AgiEngine::cmd_sound,
+		&AgiEngine::cmd_stop_sound,
+		&AgiEngine::cmd_print,
+		&AgiEngine::cmd_print_f,
+		&AgiEngine::cmd_display,
+		&AgiEngine::cmd_display_f,	// 0x68
+		&AgiEngine::cmd_clear_lines,
+		&AgiEngine::cmd_text_screen,
+		&AgiEngine::cmd_graphics,
+		&AgiEngine::cmd_set_cursor_char,
+		&AgiEngine::cmd_set_text_attribute,
+		&AgiEngine::cmd_shake_screen,
+		&AgiEngine::cmd_configure_screen,
+		&AgiEngine::cmd_status_line_on,	// 0x70
+		&AgiEngine::cmd_status_line_off,
+		&AgiEngine::cmd_set_string,
+		&AgiEngine::cmd_get_string,
+		&AgiEngine::cmd_word_to_string,
+		&AgiEngine::cmd_parse,
+		&AgiEngine::cmd_get_num,
+		&AgiEngine::cmd_prevent_input,
+		&AgiEngine::cmd_accept_input,	// 0x78
+		&AgiEngine::cmd_set_key,
+		&AgiEngine::cmd_add_to_pic,
+		&AgiEngine::cmd_add_to_pic_f,
+		&AgiEngine::cmd_status,
+		&AgiEngine::cmd_save_game,
+		&AgiEngine::cmd_load_game,
+		&AgiEngine::cmd_init_disk,
+		&AgiEngine::cmd_restart_game,	// 0x80
+		&AgiEngine::cmd_show_obj,
+		&AgiEngine::cmd_random,
+		&AgiEngine::cmd_program_control,
+		&AgiEngine::cmd_player_control,
+		&AgiEngine::cmd_obj_status_f,
+		&AgiEngine::cmd_quit,
+		&AgiEngine::cmd_show_mem,
+		&AgiEngine::cmd_pause,	// 0x88
+		&AgiEngine::cmd_echo_line,
+		&AgiEngine::cmd_cancel_line,
+		&AgiEngine::cmd_init_joy,
+		&AgiEngine::cmd_toggle_monitor,
+		&AgiEngine::cmd_version,
+		&AgiEngine::cmd_script_size,
+		&AgiEngine::cmd_set_game_id,
+		&AgiEngine::cmd_log,	// 0x90
+		&AgiEngine::cmd_set_scan_start,
+		&AgiEngine::cmd_reset_scan_start,
+		&AgiEngine::cmd_reposition_to,
+		&AgiEngine::cmd_reposition_to_f,
+		&AgiEngine::cmd_trace_on,
+		&AgiEngine::cmd_trace_info,
+		&AgiEngine::cmd_print_at,
+		&AgiEngine::cmd_print_at_v,	// 0x98
+		&AgiEngine::cmd_discard_view,	// Opcode repeated from 0x20 ?
+		&AgiEngine::cmd_clear_text_rect,
+		&AgiEngine::cmd_set_upper_left,
+		&AgiEngine::cmd_set_menu,
+		&AgiEngine::cmd_set_menu_item,
+		&AgiEngine::cmd_submit_menu,
+		&AgiEngine::cmd_enable_item,
+		&AgiEngine::cmd_disable_item,	// 0xa0
+		&AgiEngine::cmd_menu_input,
+		&AgiEngine::cmd_show_obj_v,
+		&AgiEngine::cmd_open_dialogue,
+		&AgiEngine::cmd_close_dialogue,
+		&AgiEngine::cmd_mul_n,
+		&AgiEngine::cmd_mul_v,
+		&AgiEngine::cmd_div_n,
+		&AgiEngine::cmd_div_v,	// 0xa8
+		&AgiEngine::cmd_close_window,
+		&AgiEngine::cmd_set_simple,
+		&AgiEngine::cmd_push_script,
+		&AgiEngine::cmd_pop_script,
+		&AgiEngine::cmd_hold_key,
+		&AgiEngine::cmd_set_pri_base,
+		&AgiEngine::cmd_discard_sound,
+		&AgiEngine::cmd_hide_mouse,	// 0xb0
+		&AgiEngine::cmd_allow_menu,
+		&AgiEngine::cmd_show_mouse,
+		&AgiEngine::cmd_fence_mouse,
+		&AgiEngine::cmd_mouse_posn,
+		&AgiEngine::cmd_release_key,
+		&AgiEngine::cmd_adj_ego_move_to_x_y
+	};
+	assert(ARRAYSIZE(_agiCommands) == ARRAYSIZE(tmp));
+	for (int i = 0; i < ARRAYSIZE(tmp); ++i)
+		_agiCommands[i] = tmp[i];
+}
 
 /**
  * Execute a logic script
@@ -1850,7 +1856,7 @@ int AgiEngine::runLogic(int n) {
 
 			debugC(2, kDebugLevelScripts, "%s%s(%d %d %d)", st, logicNamesCmd[op].name, p[0], p[1], p[2]);
 
-			agiCommand[op](this, p);
+			(this->*_agiCommands[op])(p);
 			ip += num;
 		}
 
@@ -1866,7 +1872,7 @@ int AgiEngine::runLogic(int n) {
 void AgiEngine::executeAgiCommand(uint8 op, uint8 *p) {
 	debugC(2, kDebugLevelScripts, "%s(%d %d %d)", logicNamesCmd[op].name, p[0], p[1], p[2]);
 
-	agiCommand[op] (this, p);
+	(this->*_agiCommands[op])(p);
 }
 
 } // End of namespace Agi