AGI: Refactor interpreter core (somewhat akin to SCI)
* Instruction tables are now defined in opcodes.{cpp,h}.
* Move opcode handlers from Agi::AgiEngine to Agi
* Opcode handlers take as parameter a pointer to AGI state (AgiGame)
This commit is contained in:
Jussi Pitkanen
Eugene Sandulenko
parent
e1153cf11f
commit
a4e0cd53f0
10 changed files with 1066 additions and 1237 deletions
|
|
@ -536,6 +536,8 @@ AgiEngine::AgiEngine(OSystem *syst, const AGIGameDescription *gameDesc) : AgiBas
|
|||
memset(&_debug, 0, sizeof(struct AgiDebug));
|
||||
memset(&_mouse, 0, sizeof(struct Mouse));
|
||||
|
||||
_game._vm = this;
|
||||
|
||||
_game.clockEnabled = false;
|
||||
_game.state = STATE_INIT;
|
||||
|
||||
|
|
@ -571,7 +573,7 @@ AgiEngine::AgiEngine(OSystem *syst, const AGIGameDescription *gameDesc) : AgiBas
|
|||
_game.controllerOccured[i] = false;
|
||||
|
||||
setupOpcodes();
|
||||
_curLogic = NULL;
|
||||
_game._curLogic = NULL;
|
||||
_timerHack = 0;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -537,6 +537,8 @@ enum {
|
|||
* by the interpreter.
|
||||
*/
|
||||
struct AgiGame {
|
||||
AgiEngine *_vm;
|
||||
|
||||
State state; /**< state of the interpreter */
|
||||
|
||||
// TODO: Check whether adjMouseX and adjMouseY must be saved and loaded when using savegames.
|
||||
|
|
@ -621,6 +623,8 @@ struct AgiGame {
|
|||
AgiView views[MAX_DIRS]; /**< AGI view resources */
|
||||
AgiSound *sounds[MAX_DIRS]; /**< Pointers to AGI sound resources */
|
||||
|
||||
AgiLogic *_curLogic;
|
||||
|
||||
// view table
|
||||
VtEntry viewTable[MAX_VIEWTABLE];
|
||||
|
||||
|
|
@ -629,6 +633,14 @@ struct AgiGame {
|
|||
int simpleSave; /**< select simple savegames */
|
||||
|
||||
Common::Rect mouseFence; /**< rectangle set by fence.mouse command */
|
||||
|
||||
// IF conditions
|
||||
int endTest;
|
||||
int orTest;
|
||||
int orVal;
|
||||
int notTest;
|
||||
int testVal;
|
||||
int ec;
|
||||
};
|
||||
|
||||
/**
|
||||
|
|
@ -833,6 +845,8 @@ public:
|
|||
bool canSaveGameStateCurrently();
|
||||
};
|
||||
|
||||
typedef void (*AgiCommand)(AgiGame *state, uint8 *p);
|
||||
|
||||
class AgiEngine : public AgiBase {
|
||||
protected:
|
||||
// Engine APIs
|
||||
|
|
@ -972,7 +986,7 @@ public:
|
|||
int testIfCode(int);
|
||||
void executeAgiCommand(uint8, uint8 *);
|
||||
|
||||
private:
|
||||
public:
|
||||
// Some submethods of testIfCode
|
||||
uint8 testObjRight(uint8, uint8, uint8, uint8, uint8);
|
||||
uint8 testObjCenter(uint8, uint8, uint8, uint8, uint8);
|
||||
|
|
@ -1085,227 +1099,13 @@ public:
|
|||
char _predictiveResult[40];
|
||||
|
||||
private:
|
||||
typedef void (AgiEngine::*AgiCommand)(uint8 *);
|
||||
typedef int (AgiEngine::*AgiCondCommand)(uint8 *);
|
||||
|
||||
AgiCommand _agiCommands[183];
|
||||
AgiCondCommand _agiCondCommands[256];
|
||||
AgiLogic *_curLogic;
|
||||
int _endTest;
|
||||
int _orTest;
|
||||
int _orVal;
|
||||
int _notTest;
|
||||
int _testVal;
|
||||
int _timerHack; // Workaround for timer loop in MH1 logic 153
|
||||
AgiCommand _agiCondCommands[256];
|
||||
|
||||
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);
|
||||
|
||||
int cond_end(uint8 *p);
|
||||
int cond_equal(uint8 *p);
|
||||
int cond_equalv(uint8 *p);
|
||||
int cond_less(uint8 *p);
|
||||
int cond_lessv(uint8 *p);
|
||||
int cond_greater(uint8 *p);
|
||||
int cond_greaterv(uint8 *p);
|
||||
int cond_isset(uint8 *p);
|
||||
int cond_issetv(uint8 *p);
|
||||
int cond_has(uint8 *p);
|
||||
int cond_obj_in_room(uint8 *p);
|
||||
int cond_posn(uint8 *p);
|
||||
int cond_controller(uint8 *p);
|
||||
int cond_have_key(uint8 *p);
|
||||
int cond_said(uint8 *p);
|
||||
int cond_compare_strings(uint8 *p);
|
||||
int cond_obj_in_box(uint8 *p);
|
||||
int cond_center_posn(uint8 *p);
|
||||
int cond_right_posn(uint8 *p);
|
||||
int cond_unknown_13(uint8 *p);
|
||||
int cond_unknown(uint8 *p);
|
||||
int cond_not(uint8 *p);
|
||||
int cond_or(uint8 *p);
|
||||
public:
|
||||
int _timerHack; // Workaround for timer loop in MH1 logic 153
|
||||
};
|
||||
|
||||
} // End of namespace Agi
|
||||
|
|
|
|||
|
|
@ -96,8 +96,8 @@ bool Console::Cmd_RunOpcode(int argc, const char **argv) {
|
|||
for (int i = 0; logicNamesCmd[i].name; i++) {
|
||||
if (!strcmp(argv[1], logicNamesCmd[i].name)) {
|
||||
uint8 p[16];
|
||||
if ((argc - 2) != logicNamesCmd[i].numArgs) {
|
||||
DebugPrintf("AGI command wants %d arguments\n", logicNamesCmd[i].numArgs);
|
||||
if ((argc - 2) != logicNamesCmd[i].argumentsLength()) {
|
||||
DebugPrintf("AGI command wants %d arguments\n", logicNamesCmd[i].argumentsLength());
|
||||
return 0;
|
||||
}
|
||||
p[0] = argv[2] ? (char)strtoul(argv[2], NULL, 0) : 0;
|
||||
|
|
@ -260,7 +260,7 @@ bool Console::Cmd_BT(int argc, const char **argv) {
|
|||
for (it = _vm->_game.execStack.begin(); it != _vm->_game.execStack.end(); ++it) {
|
||||
code = _vm->_game.logics[it->script].data;
|
||||
op = code[it->curIP];
|
||||
num = logicNamesCmd[op].numArgs;
|
||||
num = logicNamesCmd[op].argumentsLength();
|
||||
memmove(p, &code[it->curIP], num);
|
||||
memset(p + num, 0, CMD_BSIZE - num);
|
||||
|
||||
|
|
|
|||
|
|
@ -48,14 +48,17 @@ int AgiEngine::setupV2Game(int ver) {
|
|||
|
||||
// 'quit' takes 0 args for 2.089
|
||||
if (ver == 0x2089)
|
||||
logicNamesCmd[0x86].numArgs = 0;
|
||||
// logicNamesCmd[0x86].numArgs = 0;
|
||||
logicNamesCmd[0x86].args = "";
|
||||
|
||||
// 'print.at' and 'print.at.v' take 3 args before 2.272
|
||||
// This is documented in the specs as only < 2.440, but it seems
|
||||
// that KQ3 (2.272) needs a 'print.at' taking 4 args.
|
||||
if (ver < 0x2272) {
|
||||
logicNamesCmd[0x97].numArgs = 3;
|
||||
logicNamesCmd[0x98].numArgs = 3;
|
||||
// logicNamesCmd[0x97].numArgs = 3;
|
||||
// logicNamesCmd[0x98].numArgs = 3;
|
||||
logicNamesCmd[0x97].args = "vvv";
|
||||
logicNamesCmd[0x98].args = "vvv";
|
||||
}
|
||||
|
||||
return ec;
|
||||
|
|
@ -73,8 +76,10 @@ int AgiEngine::setupV3Game(int ver) {
|
|||
// 'unknown173' also takes 1 arg for 3.002.068, not 0 args.
|
||||
// Is this actually used anywhere? -- dsymonds
|
||||
if (ver == 0x3086) {
|
||||
logicNamesCmd[0xb0].numArgs = 1;
|
||||
logicNamesCmd[0xad].numArgs = 1;
|
||||
// logicNamesCmd[0xb0].numArgs = 1;
|
||||
// logicNamesCmd[0xad].numArgs = 1;
|
||||
logicNamesCmd[0xb0].args = "n";
|
||||
logicNamesCmd[0xad].args = "n";
|
||||
}
|
||||
|
||||
// FIXME: Apply this fix to other games also that use 2 arguments for command 182.
|
||||
|
|
@ -83,7 +88,8 @@ int AgiEngine::setupV3Game(int ver) {
|
|||
// has been set to use AGI 3.149 in ScummVM so that's why this initialization is
|
||||
// here and not in setupV2Game.
|
||||
if (getGameID() == GID_GOLDRUSH && getPlatform() == Common::kPlatformAmiga)
|
||||
logicNamesCmd[182].numArgs = 2;
|
||||
// logicNamesCmd[182].numArgs = 2;
|
||||
logicNamesCmd[182].args = "vv";
|
||||
|
||||
return ec;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -19,6 +19,7 @@ MODULE_OBJS := \
|
|||
menu.o \
|
||||
motion.o \
|
||||
objects.o \
|
||||
opcodes.o \
|
||||
op_cmd.o \
|
||||
op_dbg.o \
|
||||
op_test.o \
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load diff
|
|
@ -28,248 +28,17 @@ namespace Agi {
|
|||
#define ip (_game.logics[lognum].cIP)
|
||||
#define code (_game.logics[lognum].data)
|
||||
|
||||
#ifdef _L
|
||||
#undef _L
|
||||
#endif
|
||||
|
||||
#define _L(a,b,c) { a, b, c }
|
||||
|
||||
struct AgiLogicnames logicNamesTest[] = {
|
||||
_L("", 0, 0x00),
|
||||
_L("equaln", 2, 0x80),
|
||||
_L("equalv", 2, 0xC0),
|
||||
_L("lessn", 2, 0x80),
|
||||
_L("lessv", 2, 0xC0),
|
||||
_L("greatern", 2, 0x80),
|
||||
_L("greaterv", 2, 0xC0),
|
||||
_L("isset", 1, 0x00),
|
||||
_L("issetv", 1, 0x80),
|
||||
_L("has", 1, 0x00),
|
||||
_L("obj.in.room", 2, 0x40),
|
||||
_L("posn", 5, 0x00),
|
||||
_L("controller", 1, 0x00),
|
||||
_L("have.key", 0, 0x00),
|
||||
|
||||
// Not 0 args. Has variable number.
|
||||
_L("said", 0, 0x00),
|
||||
|
||||
_L("compare.strings", 2, 0x00),
|
||||
_L("obj.in.box", 5, 0x00),
|
||||
_L("center.posn", 5, 0x00),
|
||||
_L("right.posn", 5, 0x00),
|
||||
|
||||
// Haven't seen an official name for this command so tried to name it descriptively.
|
||||
_L("in.motion.using.mouse", 0, 0x00)
|
||||
};
|
||||
|
||||
struct AgiLogicnames logicNamesIf[] = {
|
||||
_L("OR", 0, 0x00),
|
||||
_L("NOT", 0, 0x00),
|
||||
_L("ELSE", 0, 0x00),
|
||||
_L("IF", 0, 0x00)
|
||||
};
|
||||
|
||||
struct AgiLogicnames logicNamesCmd[] = {
|
||||
_L("return", 0, 0x00), // 00
|
||||
_L("increment", 1, 0x80), // 01
|
||||
_L("decrement", 1, 0x80), // 02
|
||||
_L("assignn", 2, 0x80), // 03
|
||||
_L("assignv", 2, 0xC0), // 04
|
||||
_L("addn", 2, 0x80), // 05
|
||||
_L("addv", 2, 0xC0), // 06
|
||||
_L("subn", 2, 0x80), // 07
|
||||
_L("subv", 2, 0xC0), // 08
|
||||
_L("lindirectv", 2, 0xC0), // 09
|
||||
_L("rindirect", 2, 0xC0), // 0A
|
||||
_L("lindirectn", 2, 0x80), // 0B
|
||||
_L("set", 1, 0x00), // 0C
|
||||
_L("reset", 1, 0x00), // 0D
|
||||
_L("toggle", 1, 0x00), // 0E
|
||||
_L("set.v", 1, 0x80), // 0F
|
||||
_L("reset.v", 1, 0x80), // 10
|
||||
_L("toggle.v", 1, 0x80), // 11
|
||||
_L("new.room", 1, 0x00), // 12
|
||||
_L("new.room.v", 1, 0x80), // 13
|
||||
_L("load.logics", 1, 0x00), // 14
|
||||
_L("load.logics.v", 1, 0x80), // 15
|
||||
_L("call", 1, 0x00), // 16
|
||||
_L("call.v", 1, 0x80), // 17
|
||||
_L("load.pic", 1, 0x80), // 18
|
||||
_L("draw.pic", 1, 0x80), // 19
|
||||
_L("show.pic", 0, 0x00), // 1A
|
||||
_L("discard.pic", 1, 0x80), // 1B
|
||||
_L("overlay.pic", 1, 0x80), // 1C
|
||||
_L("show.pri.screen", 0, 0x00), // 1D
|
||||
_L("load.view", 1, 0x00), // 1E
|
||||
_L("load.view.v", 1, 0x80), // 1F
|
||||
_L("discard.view", 1, 0x00), // 20
|
||||
_L("animate.obj", 1, 0x00), // 21
|
||||
_L("unanimate.all", 0, 0x00), // 22
|
||||
_L("draw", 1, 0x00), // 23
|
||||
_L("erase", 1, 0x00), // 24
|
||||
_L("position", 3, 0x00), // 25
|
||||
_L("position.v", 3, 0x60), // 26
|
||||
_L("get.posn", 3, 0x60), // 27
|
||||
_L("reposition", 3, 0x60), // 28
|
||||
_L("set.view", 2, 0x00), // 29
|
||||
_L("set.view.v", 2, 0x40), // 2A
|
||||
_L("set.loop", 2, 0x00), // 2B
|
||||
_L("set.loop.v", 2, 0x40), // 2C
|
||||
_L("fix.loop", 1, 0x00), // 2D
|
||||
_L("release.loop", 1, 0x00), // 2E
|
||||
_L("set.cel", 2, 0x00), // 2F
|
||||
_L("set.cel.v", 2, 0x40), // 30
|
||||
_L("last.cel", 2, 0x40), // 31
|
||||
_L("current.cel", 2, 0x40), // 32
|
||||
_L("current.loop", 2, 0x40), // 33
|
||||
_L("current.view", 2, 0x40), // 34
|
||||
_L("number.of.loops", 2, 0x40), // 35
|
||||
_L("set.priority", 2, 0x00), // 36
|
||||
_L("set.priority.v", 2, 0x40), // 37
|
||||
_L("release.priority", 1, 0x00), // 38
|
||||
_L("get.priority", 2, 0x40), // 39
|
||||
_L("stop.update", 1, 0x00), // 3A
|
||||
_L("start.update", 1, 0x00), // 3B
|
||||
_L("force.update", 1, 0x00), // 3C
|
||||
_L("ignore.horizon", 1, 0x00), // 3D
|
||||
_L("observe.horizon", 1, 0x00), // 3E
|
||||
_L("set.horizon", 1, 0x00), // 3F
|
||||
_L("object.on.water", 1, 0x00), // 40
|
||||
_L("object.on.land", 1, 0x00), // 41
|
||||
_L("object.on.anything", 1, 0x00), // 42
|
||||
_L("ignore.objs", 1, 0x00), // 43
|
||||
_L("observe.objs", 1, 0x00), // 44
|
||||
_L("distance", 3, 0x20), // 45
|
||||
_L("stop.cycling", 1, 0x00), // 46
|
||||
_L("start.cycling", 1, 0x00), // 47
|
||||
_L("normal.cycle", 1, 0x00), // 48
|
||||
_L("end.of.loop", 2, 0x00), // 49
|
||||
_L("reverse.cycle", 1, 0x00), // 4A
|
||||
_L("reverse.loop", 2, 0x00), // 4B
|
||||
_L("cycle.time", 2, 0x40), // 4C
|
||||
_L("stop.motion", 1, 0x00), // 4D
|
||||
_L("start.motion", 1, 0x00), // 4E
|
||||
_L("step.size", 2, 0x40), // 4F
|
||||
_L("step.time", 2, 0x40), // 50
|
||||
_L("move.obj", 5, 0x00), // 51
|
||||
_L("move.obj.v", 5, 0x70), // 52
|
||||
_L("follow.ego", 3, 0x00), // 53
|
||||
_L("wander", 1, 0x00), // 54
|
||||
_L("normal.motion", 1, 0x00), // 55
|
||||
_L("set.dir", 2, 0x40), // 56
|
||||
_L("get.dir", 2, 0x40), // 57
|
||||
_L("ignore.blocks", 1, 0x00), // 58
|
||||
_L("observe.blocks", 1, 0x00), // 59
|
||||
_L("block", 4, 0x00), // 5A
|
||||
_L("unblock", 0, 0x00), // 5B
|
||||
_L("get", 1, 0x00), // 5C
|
||||
_L("get.v", 1, 0x80), // 5D
|
||||
_L("drop", 1, 0x00), // 5E
|
||||
_L("put", 2, 0x00), // 5F
|
||||
_L("put.v", 2, 0x40), // 60
|
||||
_L("get.room.v", 2, 0xC0), // 61
|
||||
_L("load.sound", 1, 0x00), // 62
|
||||
_L("sound", 2, 0x00), // 63
|
||||
_L("stop.sound", 0, 0x00), // 64
|
||||
_L("print", 1, 0x00), // 65
|
||||
_L("print.v", 1, 0x80), // 66
|
||||
_L("display", 3, 0x00), // 67
|
||||
_L("display.v", 3, 0xE0), // 68
|
||||
_L("clear.lines", 3, 0x00), // 69
|
||||
_L("text.screen", 0, 0x00), // 6A
|
||||
_L("graphics", 0, 0x00), // 6B
|
||||
_L("set.cursor.char", 1, 0x00), // 6C
|
||||
_L("set.text.attribute", 2, 0x00), // 6D
|
||||
_L("shake.screen", 1, 0x00), // 6E
|
||||
_L("configure.screen", 3, 0x00), // 6F
|
||||
_L("status.line.on", 0, 0x00), // 70
|
||||
_L("status.line.off", 0, 0x00), // 71
|
||||
_L("set.string", 2, 0x00), // 72
|
||||
_L("get.string", 5, 0x00), // 73
|
||||
_L("word.to.string", 2, 0x00), // 74
|
||||
_L("parse", 1, 0x00), // 75
|
||||
_L("get.num", 2, 0x40), // 76
|
||||
_L("prevent.input", 0, 0x00), // 77
|
||||
_L("accept.input", 0, 0x00), // 78
|
||||
_L("set.key", 3, 0x00), // 79
|
||||
_L("add.to.pic", 7, 0x00), // 7A
|
||||
_L("add.to.pic.v", 7, 0xFE), // 7B
|
||||
_L("status", 0, 0x00), // 7C
|
||||
_L("save.game", 0, 0x00), // 7D
|
||||
_L("restore.game", 0, 0x00), // 7E
|
||||
_L("init.disk", 0, 0x00), // 7F
|
||||
_L("restart.game", 0, 0x00), // 80
|
||||
_L("show.obj", 1, 0x00), // 81
|
||||
_L("random", 3, 0x20), // 82
|
||||
_L("program.control", 0, 0x00), // 83
|
||||
_L("player.control", 0, 0x00), // 84
|
||||
_L("obj.status.v", 1, 0x80), // 85
|
||||
// 0 args for AGI version 2.089
|
||||
_L("quit", 1, 0x00), // 86
|
||||
|
||||
_L("show.mem", 0, 0x00), // 87
|
||||
_L("pause", 0, 0x00), // 88
|
||||
_L("echo.line", 0, 0x00), // 89
|
||||
_L("cancel.line", 0, 0x00), // 8A
|
||||
_L("init.joy", 0, 0x00), // 8B
|
||||
_L("toggle.monitor", 0, 0x00), // 8C
|
||||
_L("version", 0, 0x00), // 8D
|
||||
_L("script.size", 1, 0x00), // 8E
|
||||
_L("set.game.id", 1, 0x00), // 8F
|
||||
_L("log", 1, 0x00), // 90
|
||||
_L("set.scan.start", 0, 0x00), // 91
|
||||
_L("reset.scan.start", 0, 0x00), // 92
|
||||
_L("reposition.to", 3, 0x00), // 93
|
||||
_L("reposition.to.v", 3, 0x60), // 94
|
||||
_L("trace.on", 0, 0x00), // 95
|
||||
_L("trace.info", 3, 0x00), // 96
|
||||
|
||||
// 3 args for AGI versions before 2.440
|
||||
_L("print.at", 4, 0x00), // 97
|
||||
_L("print.at.v", 4, 0x80), // 98
|
||||
|
||||
_L("discard.view.v", 1, 0x80), // 99
|
||||
_L("clear.text.rect", 5, 0x00), // 9A
|
||||
_L("set.upper.left", 2, 0x00), // 9B
|
||||
_L("set.menu", 1, 0x00), // 9C
|
||||
_L("set.menu.item", 2, 0x00), // 9D
|
||||
_L("submit.menu", 0, 0x00), // 9E
|
||||
_L("enable.item", 1, 0x00), // 9F
|
||||
_L("disable.item", 1, 0x00), // A0
|
||||
_L("menu.input", 0, 0x00), // A1
|
||||
_L("show.obj.v", 1, 0x01), // A2
|
||||
_L("open.dialogue", 0, 0x00), // A3
|
||||
_L("close.dialogue", 0, 0x00), // A4
|
||||
_L("mul.n", 2, 0x80), // A5
|
||||
_L("mul.v", 2, 0xC0), // A6
|
||||
_L("div.n", 2, 0x80), // A7
|
||||
_L("div.v", 2, 0xC0), // A8
|
||||
_L("close.window", 0, 0x00), // A9
|
||||
|
||||
_L("set.simple", 1, 0x00), // AA
|
||||
_L("push.script", 0, 0x00), // AB
|
||||
_L("pop.script", 0, 0x00), // AC
|
||||
_L("hold.key", 0, 0x00), // AD
|
||||
_L("set.pri.base", 1, 0x00), // AE
|
||||
_L("discard.sound", 1, 0x00), // AF
|
||||
|
||||
// 1 arg for AGI version 3.002.086
|
||||
_L("hide.mouse", 0, 0x00), // B0
|
||||
|
||||
_L("allow.menu", 1, 0x00), // B1
|
||||
_L("show.mouse", 0, 0x00), // B2
|
||||
_L("fence.mouse", 4, 0x00), // B3
|
||||
_L("mouse.posn", 2, 0x00), // B4
|
||||
_L("release.key", 0, 0x00), // B5
|
||||
|
||||
// 2 args for at least the Amiga Gold Rush! (v2.05 1989-03-09) using Amiga AGI 2.316.
|
||||
_L("adj.ego.move.to.xy", 0, 0x00), // B6
|
||||
_L(NULL, 0, 0x00)
|
||||
AgiInstruction logicNamesIf[] = {
|
||||
{ "OR", "", NULL },
|
||||
{ "NOT", "", NULL },
|
||||
{ "ELSE", "", NULL },
|
||||
{ "IF", "", NULL }
|
||||
};
|
||||
|
||||
void AgiEngine::debugConsole(int lognum, int mode, const char *str) {
|
||||
AgiLogicnames *x;
|
||||
uint8 a, c, z;
|
||||
AgiInstruction *x;
|
||||
uint8 a, z;
|
||||
const char *c;
|
||||
|
||||
if (str) {
|
||||
debug(0, " %s", str);
|
||||
|
|
@ -302,8 +71,8 @@ void AgiEngine::debugConsole(int lognum, int mode, const char *str) {
|
|||
break;
|
||||
default:
|
||||
x = mode == lCOMMAND_MODE ? logicNamesCmd : logicNamesTest;
|
||||
a = (unsigned char)(x + *(code + ip))->numArgs;
|
||||
c = (unsigned char)(x + *(code + ip))->argMask;
|
||||
a = x[*(code + ip)].argumentsLength();
|
||||
c = x[*(code + ip)].args;
|
||||
|
||||
if (_debug.opcodes) {
|
||||
debugN(0, "%02X %02X %02X %02X %02X %02X %02X %02X %02X\n"
|
||||
|
|
@ -321,12 +90,12 @@ void AgiEngine::debugConsole(int lognum, int mode, const char *str) {
|
|||
debugN(0, "%s ", (x + *(code + ip))->name);
|
||||
|
||||
for (z = 1; a > 0;) {
|
||||
if (~c & 0x80) {
|
||||
if (*c == 'n') {
|
||||
debugN(0, "%d", *(code + (ip + z)));
|
||||
} else {
|
||||
debugN(0, "v%d[%d]", *(code + (ip + z)), getvar(*(code + (ip + z))));
|
||||
}
|
||||
c <<= 1;
|
||||
c++;
|
||||
z++;
|
||||
if (--a > 0)
|
||||
debugN(0, ",");
|
||||
|
|
|
|||
|
|
@ -26,158 +26,158 @@
|
|||
|
||||
namespace Agi {
|
||||
|
||||
#define ip (_curLogic->cIP)
|
||||
#define code (_curLogic->data)
|
||||
#define ip (state->_curLogic->cIP)
|
||||
#define code (state->_curLogic->data)
|
||||
|
||||
#define getvar(a) state->_vm->getvar(a)
|
||||
#define getflag(a) state->_vm->getflag(a)
|
||||
|
||||
#define testEqual(v1, v2) (getvar(v1) == (v2))
|
||||
#define testLess(v1, v2) (getvar(v1) < (v2))
|
||||
#define testGreater(v1, v2) (getvar(v1) > (v2))
|
||||
#define testIsSet(flag) (getflag(flag))
|
||||
#define testHas(obj) (objectGetLocation(obj) == EGO_OWNED)
|
||||
#define testObjInRoom(obj, v) (objectGetLocation(obj) == getvar(v))
|
||||
#define testHas(obj) (state->_vm->objectGetLocation(obj) == EGO_OWNED)
|
||||
#define testObjInRoom(obj, v) (state->_vm->objectGetLocation(obj) == getvar(v))
|
||||
|
||||
int AgiEngine::cond_end(uint8 *p) {
|
||||
_endTest = true;
|
||||
return true;
|
||||
void cond_end(AgiGame *state, uint8 *p) {
|
||||
state->endTest = true;
|
||||
state->ec = true;
|
||||
}
|
||||
|
||||
int AgiEngine::cond_equal(uint8 *p) {
|
||||
void cond_equal(AgiGame *state, uint8 *p) {
|
||||
if (p[0] == 11)
|
||||
_timerHack++;
|
||||
state->_vm->_timerHack++;
|
||||
ip += 2;
|
||||
return testEqual(p[0], p[1]);
|
||||
state->ec = testEqual(p[0], p[1]);
|
||||
}
|
||||
|
||||
int AgiEngine::cond_equalv(uint8 *p) {
|
||||
void cond_equalv(AgiGame *state, uint8 *p) {
|
||||
if (p[0] == 11 || p[1] == 11)
|
||||
_timerHack++;
|
||||
state->_vm->_timerHack++;
|
||||
ip += 2;
|
||||
return testEqual(p[0], getvar(p[1]));
|
||||
state->ec = testEqual(p[0], getvar(p[1]));
|
||||
}
|
||||
|
||||
int AgiEngine::cond_less(uint8 *p) {
|
||||
void cond_less(AgiGame *state, uint8 *p) {
|
||||
if (p[0] == 11)
|
||||
_timerHack++;
|
||||
state->_vm->_timerHack++;
|
||||
ip += 2;
|
||||
return testLess(p[0], p[1]);
|
||||
state->ec = testLess(p[0], p[1]);
|
||||
}
|
||||
|
||||
int AgiEngine::cond_lessv(uint8 *p) {
|
||||
void cond_lessv(AgiGame *state, uint8 *p) {
|
||||
if (p[0] == 11 || p[1] == 11)
|
||||
_timerHack++;
|
||||
state->_vm->_timerHack++;
|
||||
ip += 2;
|
||||
return testLess(p[0], getvar(p[1]));
|
||||
state->ec = testLess(p[0], getvar(p[1]));
|
||||
}
|
||||
|
||||
int AgiEngine::cond_greater(uint8 *p) {
|
||||
void cond_greater(AgiGame *state, uint8 *p) {
|
||||
if (p[0] == 11)
|
||||
_timerHack++;
|
||||
state->_vm->_timerHack++;
|
||||
ip += 2;
|
||||
return testGreater(p[0], p[1]);
|
||||
state->ec = testGreater(p[0], p[1]);
|
||||
}
|
||||
|
||||
int AgiEngine::cond_greaterv(uint8 *p) {
|
||||
void cond_greaterv(AgiGame *state, uint8 *p) {
|
||||
if (p[0] == 11 || p[1] == 11)
|
||||
_timerHack++;
|
||||
state->_vm->_timerHack++;
|
||||
ip += 2;
|
||||
return testGreater(p[0], getvar(p[1]));
|
||||
state->ec = testGreater(p[0], getvar(p[1]));
|
||||
}
|
||||
|
||||
int AgiEngine::cond_isset(uint8 *p) {
|
||||
void cond_isset(AgiGame *state, uint8 *p) {
|
||||
ip += 1;
|
||||
return testIsSet(p[0]);
|
||||
state->ec = testIsSet(p[0]);
|
||||
}
|
||||
|
||||
int AgiEngine::cond_issetv(uint8 *p) {
|
||||
void cond_issetv(AgiGame *state, uint8 *p) {
|
||||
ip += 1;
|
||||
return testIsSet(getvar(p[1]));
|
||||
state->ec = testIsSet(getvar(p[1]));
|
||||
}
|
||||
|
||||
int AgiEngine::cond_has(uint8 *p) {
|
||||
void cond_has(AgiGame *state, uint8 *p) {
|
||||
ip += 1;
|
||||
return testHas(p[0]);
|
||||
state->ec = testHas(p[0]);
|
||||
}
|
||||
|
||||
int AgiEngine::cond_obj_in_room(uint8 *p) {
|
||||
void cond_obj_in_room(AgiGame *state, uint8 *p) {
|
||||
ip += 2;
|
||||
return testObjInRoom(p[0], p[1]);
|
||||
state->ec = testObjInRoom(p[0], p[1]);
|
||||
}
|
||||
|
||||
int AgiEngine::cond_posn(uint8 *p) {
|
||||
void cond_posn(AgiGame *state, uint8 *p) {
|
||||
ip += 5;
|
||||
return testPosn(p[0], p[1], p[2], p[3], p[4]);
|
||||
state->ec = state->_vm->testPosn(p[0], p[1], p[2], p[3], p[4]);
|
||||
}
|
||||
|
||||
int AgiEngine::cond_controller(uint8 *p) {
|
||||
void cond_controller(AgiGame *state, uint8 *p) {
|
||||
ip += 1;
|
||||
return testController(p[0]);
|
||||
state->ec = state->_vm->testController(p[0]);
|
||||
}
|
||||
|
||||
int AgiEngine::cond_have_key(uint8 *p) {
|
||||
return testKeypressed();
|
||||
void cond_have_key(AgiGame *state, uint8 *p) {
|
||||
state->ec = state->_vm->testKeypressed();
|
||||
}
|
||||
|
||||
int AgiEngine::cond_said(uint8 *p) {
|
||||
int ec = testSaid(p[0], p + 1);
|
||||
void cond_said(AgiGame *state, uint8 *p) {
|
||||
int ec = state->_vm->testSaid(p[0], p + 1);
|
||||
ip += p[0] * 2; // skip num_words * 2
|
||||
ip++; // skip num_words opcode
|
||||
return ec;
|
||||
state->ec = ec;
|
||||
}
|
||||
|
||||
int AgiEngine::cond_compare_strings(uint8 *p) {
|
||||
debugC(7, kDebugLevelScripts, "comparing [%s], [%s]", _game.strings[p[0]], _game.strings[p[1]]);
|
||||
void cond_compare_strings(AgiGame *state, uint8 *p) {
|
||||
debugC(7, kDebugLevelScripts, "comparing [%s], [%s]", state->strings[p[0]], state->strings[p[1]]);
|
||||
ip += 2;
|
||||
return testCompareStrings(p[0], p[1]);
|
||||
state->ec = state->_vm->testCompareStrings(p[0], p[1]);
|
||||
}
|
||||
|
||||
int AgiEngine::cond_obj_in_box(uint8 *p) {
|
||||
void cond_obj_in_box(AgiGame *state, uint8 *p) {
|
||||
ip += 5;
|
||||
return testObjInBox(p[0], p[1], p[2], p[3], p[4]);
|
||||
state->ec = state->_vm->testObjInBox(p[0], p[1], p[2], p[3], p[4]);
|
||||
}
|
||||
|
||||
int AgiEngine::cond_center_posn(uint8 *p) {
|
||||
void cond_center_posn(AgiGame *state, uint8 *p) {
|
||||
ip += 5;
|
||||
return testObjCenter(p[0], p[1], p[2], p[3], p[4]);
|
||||
state->ec = state->_vm->testObjCenter(p[0], p[1], p[2], p[3], p[4]);
|
||||
}
|
||||
|
||||
int AgiEngine::cond_right_posn(uint8 *p) {
|
||||
void cond_right_posn(AgiGame *state, uint8 *p) {
|
||||
ip += 5;
|
||||
return testObjRight(p[0], p[1], p[2], p[3], p[4]);
|
||||
state->ec = state->_vm->testObjRight(p[0], p[1], p[2], p[3], p[4]);
|
||||
}
|
||||
|
||||
int AgiEngine::cond_unknown_13(uint8 *p) {
|
||||
void cond_unknown_13(AgiGame *state, uint8 *p) {
|
||||
// My current theory is that this command checks whether the ego is currently moving
|
||||
// and that that movement has been caused using the mouse and not using the keyboard.
|
||||
// I base this theory on the game's behavior on an Amiga emulator, not on disassembly.
|
||||
// This command is used at least in the Amiga version of Gold Rush! v2.05 1989-03-09
|
||||
// (AGI 2.316) in logics 1, 3, 5, 6, 137 and 192 (Logic.192 revealed this command's nature).
|
||||
// TODO: Check this command's implementation using disassembly just to be sure.
|
||||
int ec = _game.viewTable[0].flags & ADJ_EGO_XY;
|
||||
int ec = state->viewTable[0].flags & ADJ_EGO_XY;
|
||||
debugC(7, kDebugLevelScripts, "op_test: in.motion.using.mouse = %s (Amiga-specific testcase 19)", ec ? "true" : "false");
|
||||
return ec;
|
||||
state->ec = ec;
|
||||
}
|
||||
|
||||
int AgiEngine::cond_unknown(uint8 *p) {
|
||||
_endTest = true;
|
||||
return false;
|
||||
void cond_unknown(AgiGame *state, uint8 *p) {
|
||||
state->endTest = true;
|
||||
}
|
||||
|
||||
int AgiEngine::cond_not(uint8 *p) {
|
||||
_notTest = !_notTest;
|
||||
return false;
|
||||
void cond_not(AgiGame *state, uint8 *p) {
|
||||
state->notTest = !state->notTest;
|
||||
}
|
||||
|
||||
int AgiEngine::cond_or(uint8 *p) {
|
||||
void cond_or(AgiGame *state, uint8 *p) {
|
||||
// if or_test is ON and we hit 0xFC, end of OR, then
|
||||
// or is STILL false so break.
|
||||
if (_orTest) {
|
||||
_orTest = false;
|
||||
_testVal &= _orVal;
|
||||
if (state->orTest) {
|
||||
state->orTest = false;
|
||||
state->testVal &= state->orVal;
|
||||
} else {
|
||||
_orTest = true;
|
||||
_orVal = false;
|
||||
state->orTest = true;
|
||||
state->orVal = false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
uint8 AgiEngine::testCompareStrings(uint8 s1, uint8 s2) {
|
||||
|
|
@ -291,6 +291,7 @@ uint8 AgiEngine::testObjRight(uint8 n, uint8 x1, uint8 y1, uint8 x2, uint8 y2) {
|
|||
|
||||
// When player has entered something, it is parsed elsewhere
|
||||
uint8 AgiEngine::testSaid(uint8 nwords, uint8 *cc) {
|
||||
AgiGame *state = &_game;
|
||||
int c, n = _game.numEgoWords;
|
||||
int z = 0;
|
||||
|
||||
|
|
@ -346,17 +347,18 @@ uint8 AgiEngine::testSaid(uint8 nwords, uint8 *cc) {
|
|||
}
|
||||
|
||||
int AgiEngine::testIfCode(int lognum) {
|
||||
int ec = true;
|
||||
AgiGame *state = &_game;
|
||||
uint8 op = 0;
|
||||
uint16 lastIp = ip;
|
||||
uint8 p[16] = { 0 };
|
||||
|
||||
_notTest = false;
|
||||
_orTest = false;
|
||||
_endTest = false;
|
||||
_testVal = true;
|
||||
state->ec = true;
|
||||
state->notTest = false;
|
||||
state->orTest = false;
|
||||
state->endTest = false;
|
||||
state->testVal = true;
|
||||
|
||||
while (!(shouldQuit() || _restartGame) && !_endTest) {
|
||||
while (!(shouldQuit() || _restartGame) && !state->endTest) {
|
||||
if (_debug.enabled && (_debug.logic0 || lognum))
|
||||
debugConsole(lognum, lTEST_MODE, NULL);
|
||||
|
||||
|
|
@ -364,32 +366,32 @@ int AgiEngine::testIfCode(int lognum) {
|
|||
op = *(code + ip++);
|
||||
memmove(p, (code + ip), 16);
|
||||
|
||||
ec = (this->*_agiCondCommands[op])(p);
|
||||
_agiCondCommands[op](state, p);
|
||||
if (op == 0xFF || op == 0xFD || op == 0xFC)
|
||||
continue;
|
||||
|
||||
// not is only enabled for 1 test command
|
||||
if (_notTest)
|
||||
ec = !ec;
|
||||
_notTest = false;
|
||||
if (state->notTest)
|
||||
state->ec = !state->ec;
|
||||
state->notTest = false;
|
||||
|
||||
if (_orTest)
|
||||
_orVal |= ec;
|
||||
if (state->orTest)
|
||||
state->orVal |= state->ec;
|
||||
else
|
||||
_testVal &= ec;
|
||||
state->testVal &= state->ec;
|
||||
}
|
||||
|
||||
// Execute the following IF block if the condition is true, otherwise
|
||||
// skip the block.
|
||||
if (_testVal)
|
||||
if (state->testVal)
|
||||
ip += 2;
|
||||
else
|
||||
ip += READ_LE_UINT16(code + ip) + 2;
|
||||
|
||||
if (_debug.enabled && (_debug.logic0 || lognum))
|
||||
debugConsole(lognum, 0xFF, _testVal ? "=true" : "=false");
|
||||
debugConsole(lognum, 0xFF, state->testVal ? "=true" : "=false");
|
||||
|
||||
return _testVal;
|
||||
return state->testVal;
|
||||
}
|
||||
|
||||
} // End of namespace Agi
|
||||
|
|
|
|||
250
engines/agi/opcodes.cpp
Normal file
250
engines/agi/opcodes.cpp
Normal file
|
|
@ -0,0 +1,250 @@
|
|||
/* 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.
|
||||
*
|
||||
*/
|
||||
|
||||
#include "agi/agi.h"
|
||||
#include "agi/opcodes.h"
|
||||
|
||||
namespace Agi {
|
||||
|
||||
AgiInstruction logicNamesTest[] = {
|
||||
{ "", "", &cond_end }, // 00
|
||||
{ "equaln", "vn", &cond_equal }, // 01
|
||||
{ "equalv", "vv", &cond_equalv }, // 02
|
||||
{ "lessn", "vn", &cond_less }, // 03
|
||||
{ "lessv", "vv", &cond_lessv }, // 04
|
||||
{ "greatern", "vn", &cond_greater }, // 05
|
||||
{ "greaterv", "vv", &cond_greaterv }, // 06
|
||||
{ "isset", "n", &cond_isset }, // 07
|
||||
{ "issetv", "v", &cond_issetv }, // 08
|
||||
{ "has", "n", &cond_has }, // 09
|
||||
{ "obj.in.room", "nv", &cond_obj_in_room}, // 0A
|
||||
{ "posn", "nnnnn", &cond_posn }, // 0B
|
||||
{ "controller", "n", &cond_controller }, // 0C
|
||||
{ "have.key", "", &cond_have_key}, // 0D
|
||||
{ "said", "", &cond_said }, // 0E
|
||||
{ "compare.strings", "ss", &cond_compare_strings }, // 0F
|
||||
{ "obj.in.box", "nnnnn", &cond_obj_in_box }, // 10
|
||||
{ "center.posn", "nnnnn", &cond_center_posn }, // 11
|
||||
{ "right.posn", "nnnnn", &cond_right_posn }, // 12
|
||||
{ "in.motion.using.mouse", "", &cond_unknown_13 } // 13
|
||||
};
|
||||
|
||||
AgiInstruction logicNamesCmd[] = {
|
||||
{ "return", "", NULL },
|
||||
{ "increment", "v", &cmd_increment },
|
||||
{ "decrement", "v", &cmd_decrement },
|
||||
{ "assignn", "vn", &cmd_assignn },
|
||||
{ "assignv", "vv", &cmd_assignv },
|
||||
{ "addn", "vn", &cmd_addn },
|
||||
{ "addv", "vv", &cmd_addv },
|
||||
{ "subn", "vn", &cmd_subn },
|
||||
{ "subv", "vv", &cmd_subv },
|
||||
{ "lindirectv", "vv", &cmd_lindirectv },
|
||||
{ "lindirect", "vv", &cmd_rindirect },
|
||||
{ "lindirectn", "vn", &cmd_lindirectn },
|
||||
{ "set", "n", &cmd_set },
|
||||
{ "reset", "n", &cmd_reset },
|
||||
{ "toggle", "n", &cmd_toggle },
|
||||
{ "set.v", "v", &cmd_set_v },
|
||||
{ "reset.v", "v", &cmd_reset_v },
|
||||
{ "toggle.v", "v", &cmd_toggle_v },
|
||||
{ "new.room", "n", &cmd_new_room },
|
||||
{ "new.room.v", "v", &cmd_new_room_f },
|
||||
{ "load.logics", "n", &cmd_load_logic },
|
||||
{ "load.logics.v", "v", &cmd_load_logic_f },
|
||||
{ "call", "n", &cmd_call },
|
||||
{ "call.v", "v", &cmd_call_f },
|
||||
{ "load.pic", "v", &cmd_load_pic },
|
||||
{ "draw.pic", "v", &cmd_draw_pic },
|
||||
{ "show.pic", "", &cmd_show_pic },
|
||||
{ "discard.pic", "v", &cmd_discard_pic },
|
||||
{ "overlay.pic", "v", &cmd_overlay_pic },
|
||||
{ "show.pri.screen", "", &cmd_show_pri_screen },
|
||||
{ "load.view", "n", &cmd_load_view },
|
||||
{ "load.view.v", "v", &cmd_load_view_f },
|
||||
{ "discard.view", "n", &cmd_discard_view },
|
||||
{ "animate.obj", "n", &cmd_animate_obj },
|
||||
{ "unanimate.all", "", &cmd_unanimate_all },
|
||||
{ "draw", "n", &cmd_draw },
|
||||
{ "erase", "n", &cmd_erase },
|
||||
{ "position", "nnn", &cmd_position },
|
||||
{ "position.v", "nvv", &cmd_position_f },
|
||||
{ "get.posn", "nvv", &cmd_get_posn },
|
||||
{ "reposition", "nvv", &cmd_reposition },
|
||||
{ "set.view", "nn", &cmd_set_view },
|
||||
{ "set.view.v", "nv", &cmd_set_view_f },
|
||||
{ "set.loop", "nn", &cmd_set_loop },
|
||||
{ "set.loop.v", "nv", &cmd_set_loop_f },
|
||||
{ "fix.loop", "n", &cmd_fix_loop },
|
||||
{ "release.loop", "n", &cmd_release_loop },
|
||||
{ "set.cel", "nn", &cmd_set_cel },
|
||||
{ "set.cel.v", "nv", &cmd_set_cel_f },
|
||||
{ "last.cel", "nv", &cmd_last_cel },
|
||||
{ "current.cel", "nv", &cmd_current_cel },
|
||||
{ "current.loop", "nv", &cmd_current_loop },
|
||||
{ "current.view", "nv", &cmd_current_view },
|
||||
{ "number.of.loops", "nv", &cmd_number_of_loops },
|
||||
{ "set.priority", "nn", &cmd_set_priority },
|
||||
{ "set.priority.v", "nv", &cmd_set_priority_f },
|
||||
{ "release.priority", "n", &cmd_release_priority },
|
||||
{ "get.priority", "nn", &cmd_get_priority },
|
||||
{ "stop.update", "n", &cmd_stop_update },
|
||||
{ "start.update", "n", &cmd_start_update },
|
||||
{ "force.update", "n", &cmd_force_update },
|
||||
{ "ignore.horizon", "n", &cmd_ignore_horizon },
|
||||
{ "observe.horizon", "n", &cmd_observe_horizon },
|
||||
{ "set.horizon", "n", &cmd_set_horizon },
|
||||
{ "object.on.water", "n", &cmd_object_on_water },
|
||||
{ "object.on.land", "n", &cmd_object_on_land },
|
||||
{ "object.on.anything", "n", &cmd_object_on_anything },
|
||||
{ "ignore.objs", "n", &cmd_ignore_objs },
|
||||
{ "observe.objs", "n", &cmd_observe_objs },
|
||||
{ "distance", "nnv", &cmd_distance },
|
||||
{ "stop.cycling", "n", &cmd_stop_cycling },
|
||||
{ "start.cycling", "n", &cmd_start_cycling },
|
||||
{ "normal.cycle", "n", &cmd_normal_cycle },
|
||||
{ "end.of.loop", "nn", &cmd_end_of_loop },
|
||||
{ "reverse.cycle", "n", &cmd_reverse_cycle },
|
||||
{ "reverse.loop", "nn", &cmd_reverse_loop },
|
||||
{ "cycle.time", "nv", &cmd_cycle_time },
|
||||
{ "stop.motion", "n", &cmd_stop_motion },
|
||||
{ "start.motion", "n", &cmd_start_motion },
|
||||
{ "step.size", "nv", &cmd_step_size },
|
||||
{ "step.time", "nv", &cmd_step_time },
|
||||
{ "move.obj", "nnnnn", &cmd_move_obj },
|
||||
{ "move.obj.v", "nvvvv", &cmd_move_obj_f },
|
||||
{ "follow.ego", "nnn", &cmd_follow_ego },
|
||||
{ "wander", "n", &cmd_wander },
|
||||
{ "normal.motion", "n", &cmd_normal_motion },
|
||||
{ "set.dir", "nv", &cmd_set_dir },
|
||||
{ "get.dir", "nv", &cmd_get_dir },
|
||||
{ "ignore.blocks", "n", &cmd_ignore_blocks },
|
||||
{ "observe.blocks", "n", &cmd_observe_blocks },
|
||||
{ "block", "nnnn", &cmd_block },
|
||||
{ "unblock", "", &cmd_unblock },
|
||||
{ "get", "n", &cmd_get },
|
||||
{ "get.v", "v", &cmd_get_f },
|
||||
{ "drop", "n", &cmd_drop },
|
||||
{ "put", "nn", &cmd_put },
|
||||
{ "put.v", "vv", &cmd_put_f },
|
||||
{ "get.room.v", "vv", &cmd_get_room_f },
|
||||
{ "load.sound", "n", &cmd_load_sound },
|
||||
{ "sound", "nn", &cmd_sound },
|
||||
{ "stop.sound", "", &cmd_stop_sound },
|
||||
{ "print", "s", &cmd_print },
|
||||
{ "print.v", "v", &cmd_print_f },
|
||||
{ "display", "nns", &cmd_display },
|
||||
{ "display.v", "vvv", &cmd_display_f },
|
||||
{ "clear.lines", "nns", &cmd_clear_lines },
|
||||
{ "text.screen", "", &cmd_text_screen },
|
||||
{ "graphics", "", &cmd_graphics },
|
||||
{ "set.cursor.char", "s", &cmd_set_cursor_char },
|
||||
{ "set.text.attribute", "nn", &cmd_set_text_attribute },
|
||||
{ "shake.screen", "n", &cmd_shake_screen },
|
||||
{ "configure.screen", "nnn", &cmd_configure_screen },
|
||||
{ "status.line.on", "", &cmd_status_line_on },
|
||||
{ "status.line.off", "", &cmd_status_line_off },
|
||||
{ "set.string", "ns", &cmd_set_string },
|
||||
{ "get.string", "ns", &cmd_get_string },
|
||||
{ "word.to.string", "nn", &cmd_word_to_string },
|
||||
{ "parse", "n", &cmd_parse },
|
||||
{ "get.num", "nv", &cmd_get_num },
|
||||
{ "prevent.input", "", &cmd_prevent_input },
|
||||
{ "accept.input", "", &cmd_accept_input },
|
||||
{ "set.key", "nnn", &cmd_set_key },
|
||||
{ "add.to.pic", "nnnnnnn", &cmd_add_to_pic },
|
||||
{ "add.to.pic.v", "vvvvvvv", &cmd_add_to_pic_f },
|
||||
{ "status", "", &cmd_status },
|
||||
{ "save.game", "", &cmd_save_game },
|
||||
{ "restore.game", "", &cmd_load_game },
|
||||
{ "init.disk", "", &cmd_init_disk },
|
||||
{ "restart.game", "", &cmd_restart_game },
|
||||
{ "show.obj", "n", &cmd_show_obj },
|
||||
{ "random", "nnv", &cmd_random },
|
||||
{ "program.control", "", &cmd_program_control },
|
||||
{ "player.control", "", &cmd_player_control },
|
||||
{ "obj.status.v", "v", &cmd_obj_status_f },
|
||||
{ "quit", "n", &cmd_quit },
|
||||
{ "show.mem", "", &cmd_show_mem },
|
||||
{ "pause", "", &cmd_pause },
|
||||
{ "echo.line", "", &cmd_echo_line },
|
||||
{ "cancel.line", "", &cmd_cancel_line },
|
||||
{ "init.joy", "", &cmd_init_joy },
|
||||
{ "toggle.monitor", "", &cmd_toggle_monitor },
|
||||
{ "version", "", &cmd_version },
|
||||
{ "script.size", "n", &cmd_script_size },
|
||||
{ "set.game.id", "s", &cmd_set_game_id },
|
||||
{ "log", "s", &cmd_log },
|
||||
{ "set.scan.start", "", &cmd_set_scan_start },
|
||||
{ "reset.scan.start", "", &cmd_reset_scan_start },
|
||||
{ "reposition.to", "nnn", &cmd_reposition_to },
|
||||
{ "reposition.to.v", "nvv", &cmd_reposition_to_f },
|
||||
{ "trace.on", "", &cmd_trace_on },
|
||||
{ "trace.info", "nnn", &cmd_trace_info },
|
||||
{ "print.at", "snnn", &cmd_print_at },
|
||||
{ "print.at.v", "vnnn", &cmd_print_at_v },
|
||||
{ "discard.view.v", "v", &cmd_discard_view},
|
||||
{ "clear.text.rect", "nnnnn", &cmd_clear_text_rect },
|
||||
{ "set.upper.left", "nn", &cmd_set_upper_left },
|
||||
{ "set.menu", "s", &cmd_set_menu },
|
||||
{ "set.menu.member", "sn", &cmd_set_menu_item },
|
||||
{ "submit.menu", "", &cmd_submit_menu },
|
||||
{ "enable.member", "n", &cmd_enable_item },
|
||||
{ "disable.member", "n", &cmd_disable_item },
|
||||
{ "menu.input", "", &cmd_menu_input },
|
||||
{ "show.obj.v", "v", &cmd_show_obj_v },
|
||||
{ "open.dialogue", "", &cmd_open_dialogue },
|
||||
{ "close.dialogue", "", &cmd_close_dialogue },
|
||||
{ "mul.n", "vn", &cmd_mul_n },
|
||||
{ "mul.v", "vv", &cmd_mul_v },
|
||||
{ "div.n", "vn", &cmd_div_n },
|
||||
{ "div.v", "vv", &cmd_div_v },
|
||||
{ "close.window", "", &cmd_close_window },
|
||||
{ "set.simple", "n", &cmd_set_simple },
|
||||
{ "push.script", "", &cmd_push_script },
|
||||
{ "pop.script", "", &cmd_pop_script },
|
||||
{ "hold.key", "", &cmd_hold_key },
|
||||
{ "set.pri.base", "n", &cmd_set_pri_base },
|
||||
{ "discard.sound", "n", &cmd_discard_sound },
|
||||
{ "hide.mouse", "", &cmd_hide_mouse },
|
||||
{ "allow.menu", "n", &cmd_allow_menu },
|
||||
{ "show.mouse", "", &cmd_show_mouse },
|
||||
{ "fence.mouse", "nnnn", &cmd_fence_mouse },
|
||||
{ "mouse.posn", "vv", &cmd_mouse_posn },
|
||||
{ "release.key", "", &cmd_release_key },
|
||||
{ "adj.ego.move.to.xy", "", &cmd_adj_ego_move_to_x_y }
|
||||
};
|
||||
|
||||
void AgiEngine::setupOpcodes() {
|
||||
for (int i = 0; i < 256; ++i)
|
||||
_agiCondCommands[i] = &cond_unknown;
|
||||
for (int i = 0; i <= ARRAYSIZE(logicNamesTest); ++i)
|
||||
_agiCondCommands[i] = logicNamesTest[i].func;
|
||||
_agiCondCommands[0xFF] = &cond_end;
|
||||
_agiCondCommands[0xFD] = &cond_not;
|
||||
_agiCondCommands[0xFC] = &cond_or;
|
||||
|
||||
for (int i = 0; i < ARRAYSIZE(logicNamesCmd); ++i)
|
||||
_agiCommands[i] = logicNamesCmd[i].func;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -23,17 +23,227 @@
|
|||
#ifndef AGI_OPCODES_H
|
||||
#define AGI_OPCODES_H
|
||||
|
||||
#include <string.h>
|
||||
|
||||
namespace Agi {
|
||||
|
||||
struct AgiLogicnames {
|
||||
struct AgiInstruction {
|
||||
const char *name;
|
||||
uint16 numArgs;
|
||||
uint16 argMask;
|
||||
const char *args;
|
||||
AgiCommand func;
|
||||
|
||||
int argumentsLength() { return strlen(args); }
|
||||
};
|
||||
|
||||
extern AgiLogicnames logicNamesTest[];
|
||||
extern AgiLogicnames logicNamesCmd[];
|
||||
extern AgiLogicnames logicNamesIf[];
|
||||
extern AgiInstruction logicNamesTest[];
|
||||
extern AgiInstruction logicNamesCmd[];
|
||||
|
||||
void cmd_increment(AgiGame *state, uint8 *p);
|
||||
void cmd_decrement(AgiGame *state, uint8 *p);
|
||||
void cmd_assignn(AgiGame *state, uint8 *p);
|
||||
void cmd_assignv(AgiGame *state, uint8 *p);
|
||||
void cmd_addn(AgiGame *state, uint8 *p);
|
||||
void cmd_addv(AgiGame *state, uint8 *p);
|
||||
void cmd_subn(AgiGame *state, uint8 *p);
|
||||
void cmd_subv(AgiGame *state, uint8 *p); // 0x08
|
||||
void cmd_lindirectv(AgiGame *state, uint8 *p);
|
||||
void cmd_rindirect(AgiGame *state, uint8 *p);
|
||||
void cmd_lindirectn(AgiGame *state, uint8 *p);
|
||||
void cmd_set(AgiGame *state, uint8 *p);
|
||||
void cmd_reset(AgiGame *state, uint8 *p);
|
||||
void cmd_toggle(AgiGame *state, uint8 *p);
|
||||
void cmd_set_v(AgiGame *state, uint8 *p);
|
||||
void cmd_reset_v(AgiGame *state, uint8 *p); // 0x10
|
||||
void cmd_toggle_v(AgiGame *state, uint8 *p);
|
||||
void cmd_new_room(AgiGame *state, uint8 *p);
|
||||
void cmd_new_room_f(AgiGame *state, uint8 *p);
|
||||
void cmd_load_logic(AgiGame *state, uint8 *p);
|
||||
void cmd_load_logic_f(AgiGame *state, uint8 *p);
|
||||
void cmd_call(AgiGame *state, uint8 *p);
|
||||
void cmd_call_f(AgiGame *state, uint8 *p);
|
||||
void cmd_load_pic(AgiGame *state, uint8 *p); // 0x18
|
||||
void cmd_draw_pic(AgiGame *state, uint8 *p);
|
||||
void cmd_show_pic(AgiGame *state, uint8 *p);
|
||||
void cmd_discard_pic(AgiGame *state, uint8 *p);
|
||||
void cmd_overlay_pic(AgiGame *state, uint8 *p);
|
||||
void cmd_show_pri_screen(AgiGame *state, uint8 *p);
|
||||
void cmd_load_view(AgiGame *state, uint8 *p);
|
||||
void cmd_load_view_f(AgiGame *state, uint8 *p);
|
||||
void cmd_discard_view(AgiGame *state, uint8 *p); // 0x20
|
||||
void cmd_animate_obj(AgiGame *state, uint8 *p);
|
||||
void cmd_unanimate_all(AgiGame *state, uint8 *p);
|
||||
void cmd_draw(AgiGame *state, uint8 *p);
|
||||
void cmd_erase(AgiGame *state, uint8 *p);
|
||||
void cmd_position(AgiGame *state, uint8 *p);
|
||||
void cmd_position_f(AgiGame *state, uint8 *p);
|
||||
void cmd_get_posn(AgiGame *state, uint8 *p);
|
||||
void cmd_reposition(AgiGame *state, uint8 *p); // 0x28
|
||||
void cmd_set_view(AgiGame *state, uint8 *p);
|
||||
void cmd_set_view_f(AgiGame *state, uint8 *p);
|
||||
void cmd_set_loop(AgiGame *state, uint8 *p);
|
||||
void cmd_set_loop_f(AgiGame *state, uint8 *p);
|
||||
void cmd_fix_loop(AgiGame *state, uint8 *p);
|
||||
void cmd_release_loop(AgiGame *state, uint8 *p);
|
||||
void cmd_set_cel(AgiGame *state, uint8 *p);
|
||||
void cmd_set_cel_f(AgiGame *state, uint8 *p); // 0x30
|
||||
void cmd_last_cel(AgiGame *state, uint8 *p);
|
||||
void cmd_current_cel(AgiGame *state, uint8 *p);
|
||||
void cmd_current_loop(AgiGame *state, uint8 *p);
|
||||
void cmd_current_view(AgiGame *state, uint8 *p);
|
||||
void cmd_number_of_loops(AgiGame *state, uint8 *p);
|
||||
void cmd_set_priority(AgiGame *state, uint8 *p);
|
||||
void cmd_set_priority_f(AgiGame *state, uint8 *p);
|
||||
void cmd_release_priority(AgiGame *state, uint8 *p); // 0x38
|
||||
void cmd_get_priority(AgiGame *state, uint8 *p);
|
||||
void cmd_stop_update(AgiGame *state, uint8 *p);
|
||||
void cmd_start_update(AgiGame *state, uint8 *p);
|
||||
void cmd_force_update(AgiGame *state, uint8 *p);
|
||||
void cmd_ignore_horizon(AgiGame *state, uint8 *p);
|
||||
void cmd_observe_horizon(AgiGame *state, uint8 *p);
|
||||
void cmd_set_horizon(AgiGame *state, uint8 *p);
|
||||
void cmd_object_on_water(AgiGame *state, uint8 *p); // 0x40
|
||||
void cmd_object_on_land(AgiGame *state, uint8 *p);
|
||||
void cmd_object_on_anything(AgiGame *state, uint8 *p);
|
||||
void cmd_ignore_objs(AgiGame *state, uint8 *p);
|
||||
void cmd_observe_objs(AgiGame *state, uint8 *p);
|
||||
void cmd_distance(AgiGame *state, uint8 *p);
|
||||
void cmd_stop_cycling(AgiGame *state, uint8 *p);
|
||||
void cmd_start_cycling(AgiGame *state, uint8 *p);
|
||||
void cmd_normal_cycle(AgiGame *state, uint8 *p); // 0x48
|
||||
void cmd_end_of_loop(AgiGame *state, uint8 *p);
|
||||
void cmd_reverse_cycle(AgiGame *state, uint8 *p);
|
||||
void cmd_reverse_loop(AgiGame *state, uint8 *p);
|
||||
void cmd_cycle_time(AgiGame *state, uint8 *p);
|
||||
void cmd_stop_motion(AgiGame *state, uint8 *p);
|
||||
void cmd_start_motion(AgiGame *state, uint8 *p);
|
||||
void cmd_step_size(AgiGame *state, uint8 *p);
|
||||
void cmd_step_time(AgiGame *state, uint8 *p); // 0x50
|
||||
void cmd_move_obj(AgiGame *state, uint8 *p);
|
||||
void cmd_move_obj_f(AgiGame *state, uint8 *p);
|
||||
void cmd_follow_ego(AgiGame *state, uint8 *p);
|
||||
void cmd_wander(AgiGame *state, uint8 *p);
|
||||
void cmd_normal_motion(AgiGame *state, uint8 *p);
|
||||
void cmd_set_dir(AgiGame *state, uint8 *p);
|
||||
void cmd_get_dir(AgiGame *state, uint8 *p);
|
||||
void cmd_ignore_blocks(AgiGame *state, uint8 *p); // 0x58
|
||||
void cmd_observe_blocks(AgiGame *state, uint8 *p);
|
||||
void cmd_block(AgiGame *state, uint8 *p);
|
||||
void cmd_unblock(AgiGame *state, uint8 *p);
|
||||
void cmd_get(AgiGame *state, uint8 *p);
|
||||
void cmd_get_f(AgiGame *state, uint8 *p);
|
||||
void cmd_drop(AgiGame *state, uint8 *p);
|
||||
void cmd_put(AgiGame *state, uint8 *p);
|
||||
void cmd_put_f(AgiGame *state, uint8 *p); // 0x60
|
||||
void cmd_get_room_f(AgiGame *state, uint8 *p);
|
||||
void cmd_load_sound(AgiGame *state, uint8 *p);
|
||||
void cmd_sound(AgiGame *state, uint8 *p);
|
||||
void cmd_stop_sound(AgiGame *state, uint8 *p);
|
||||
void cmd_print(AgiGame *state, uint8 *p);
|
||||
void cmd_print_f(AgiGame *state, uint8 *p);
|
||||
void cmd_display(AgiGame *state, uint8 *p);
|
||||
void cmd_display_f(AgiGame *state, uint8 *p); // 0x68
|
||||
void cmd_clear_lines(AgiGame *state, uint8 *p);
|
||||
void cmd_text_screen(AgiGame *state, uint8 *p);
|
||||
void cmd_graphics(AgiGame *state, uint8 *p);
|
||||
void cmd_set_cursor_char(AgiGame *state, uint8 *p);
|
||||
void cmd_set_text_attribute(AgiGame *state, uint8 *p);
|
||||
void cmd_shake_screen(AgiGame *state, uint8 *p);
|
||||
void cmd_configure_screen(AgiGame *state, uint8 *p);
|
||||
void cmd_status_line_on(AgiGame *state, uint8 *p); // 0x70
|
||||
void cmd_status_line_off(AgiGame *state, uint8 *p);
|
||||
void cmd_set_string(AgiGame *state, uint8 *p);
|
||||
void cmd_get_string(AgiGame *state, uint8 *p);
|
||||
void cmd_word_to_string(AgiGame *state, uint8 *p);
|
||||
void cmd_parse(AgiGame *state, uint8 *p);
|
||||
void cmd_get_num(AgiGame *state, uint8 *p);
|
||||
void cmd_prevent_input(AgiGame *state, uint8 *p);
|
||||
void cmd_accept_input(AgiGame *state, uint8 *p); // 0x78
|
||||
void cmd_set_key(AgiGame *state, uint8 *p);
|
||||
void cmd_add_to_pic(AgiGame *state, uint8 *p);
|
||||
void cmd_add_to_pic_f(AgiGame *state, uint8 *p);
|
||||
void cmd_status(AgiGame *state, uint8 *p);
|
||||
void cmd_save_game(AgiGame *state, uint8 *p);
|
||||
void cmd_load_game(AgiGame *state, uint8 *p);
|
||||
void cmd_init_disk(AgiGame *state, uint8 *p);
|
||||
void cmd_restart_game(AgiGame *state, uint8 *p); // 0x80
|
||||
void cmd_show_obj(AgiGame *state, uint8 *p);
|
||||
void cmd_random(AgiGame *state, uint8 *p);
|
||||
void cmd_program_control(AgiGame *state, uint8 *p);
|
||||
void cmd_player_control(AgiGame *state, uint8 *p);
|
||||
void cmd_obj_status_f(AgiGame *state, uint8 *p);
|
||||
void cmd_quit(AgiGame *state, uint8 *p);
|
||||
void cmd_show_mem(AgiGame *state, uint8 *p);
|
||||
void cmd_pause(AgiGame *state, uint8 *p); // 0x88
|
||||
void cmd_echo_line(AgiGame *state, uint8 *p);
|
||||
void cmd_cancel_line(AgiGame *state, uint8 *p);
|
||||
void cmd_init_joy(AgiGame *state, uint8 *p);
|
||||
void cmd_toggle_monitor(AgiGame *state, uint8 *p);
|
||||
void cmd_version(AgiGame *state, uint8 *p);
|
||||
void cmd_script_size(AgiGame *state, uint8 *p);
|
||||
void cmd_set_game_id(AgiGame *state, uint8 *p);
|
||||
void cmd_log(AgiGame *state, uint8 *p); // 0x90
|
||||
void cmd_set_scan_start(AgiGame *state, uint8 *p);
|
||||
void cmd_reset_scan_start(AgiGame *state, uint8 *p);
|
||||
void cmd_reposition_to(AgiGame *state, uint8 *p);
|
||||
void cmd_reposition_to_f(AgiGame *state, uint8 *p);
|
||||
void cmd_trace_on(AgiGame *state, uint8 *p);
|
||||
void cmd_trace_info(AgiGame *state, uint8 *p);
|
||||
void cmd_print_at(AgiGame *state, uint8 *p);
|
||||
void cmd_print_at_v(AgiGame *state, uint8 *p); // 0x98
|
||||
//void cmd_discard_view(AgiGame *state, uint8 *p); // Opcode repeated from 0x20 ?
|
||||
void cmd_clear_text_rect(AgiGame *state, uint8 *p);
|
||||
void cmd_set_upper_left(AgiGame *state, uint8 *p);
|
||||
void cmd_set_menu(AgiGame *state, uint8 *p);
|
||||
void cmd_set_menu_item(AgiGame *state, uint8 *p);
|
||||
void cmd_submit_menu(AgiGame *state, uint8 *p);
|
||||
void cmd_enable_item(AgiGame *state, uint8 *p);
|
||||
void cmd_disable_item(AgiGame *state, uint8 *p); // 0xa0
|
||||
void cmd_menu_input(AgiGame *state, uint8 *p);
|
||||
void cmd_show_obj_v(AgiGame *state, uint8 *p);
|
||||
void cmd_open_dialogue(AgiGame *state, uint8 *p);
|
||||
void cmd_close_dialogue(AgiGame *state, uint8 *p);
|
||||
void cmd_mul_n(AgiGame *state, uint8 *p);
|
||||
void cmd_mul_v(AgiGame *state, uint8 *p);
|
||||
void cmd_div_n(AgiGame *state, uint8 *p);
|
||||
void cmd_div_v(AgiGame *state, uint8 *p); // 0xa8
|
||||
void cmd_close_window(AgiGame *state, uint8 *p);
|
||||
void cmd_set_simple(AgiGame *state, uint8 *p);
|
||||
void cmd_push_script(AgiGame *state, uint8 *p);
|
||||
void cmd_pop_script(AgiGame *state, uint8 *p);
|
||||
void cmd_hold_key(AgiGame *state, uint8 *p);
|
||||
void cmd_set_pri_base(AgiGame *state, uint8 *p);
|
||||
void cmd_discard_sound(AgiGame *state, uint8 *p);
|
||||
void cmd_hide_mouse(AgiGame *state, uint8 *p); // 0xb0
|
||||
void cmd_allow_menu(AgiGame *state, uint8 *p);
|
||||
void cmd_show_mouse(AgiGame *state, uint8 *p);
|
||||
void cmd_fence_mouse(AgiGame *state, uint8 *p);
|
||||
void cmd_mouse_posn(AgiGame *state, uint8 *p);
|
||||
void cmd_release_key(AgiGame *state, uint8 *p);
|
||||
void cmd_adj_ego_move_to_x_y(AgiGame *state, uint8 *p);
|
||||
|
||||
void cond_end(AgiGame *state, uint8 *p);
|
||||
void cond_equal(AgiGame *state, uint8 *p);
|
||||
void cond_equalv(AgiGame *state, uint8 *p);
|
||||
void cond_less(AgiGame *state, uint8 *p);
|
||||
void cond_lessv(AgiGame *state, uint8 *p);
|
||||
void cond_greater(AgiGame *state, uint8 *p);
|
||||
void cond_greaterv(AgiGame *state, uint8 *p);
|
||||
void cond_isset(AgiGame *state, uint8 *p);
|
||||
void cond_issetv(AgiGame *state, uint8 *p);
|
||||
void cond_has(AgiGame *state, uint8 *p);
|
||||
void cond_obj_in_room(AgiGame *state, uint8 *p);
|
||||
void cond_posn(AgiGame *state, uint8 *p);
|
||||
void cond_controller(AgiGame *state, uint8 *p);
|
||||
void cond_have_key(AgiGame *state, uint8 *p);
|
||||
void cond_said(AgiGame *state, uint8 *p);
|
||||
void cond_compare_strings(AgiGame *state, uint8 *p);
|
||||
void cond_obj_in_box(AgiGame *state, uint8 *p);
|
||||
void cond_center_posn(AgiGame *state, uint8 *p);
|
||||
void cond_right_posn(AgiGame *state, uint8 *p);
|
||||
void cond_unknown_13(AgiGame *state, uint8 *p);
|
||||
void cond_unknown(AgiGame *state, uint8 *p);
|
||||
void cond_not(AgiGame *state, uint8 *p);
|
||||
void cond_or(AgiGame *state, uint8 *p);
|
||||
|
||||
} // End of namespace Agi
|
||||
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue