diff options
22 files changed, 6070 insertions, 126 deletions
diff --git a/engines/gargoyle/frotz/buffer.cpp b/engines/gargoyle/frotz/buffer.cpp index 15ec771bfc..7d9e64465b 100644 --- a/engines/gargoyle/frotz/buffer.cpp +++ b/engines/gargoyle/frotz/buffer.cpp @@ -61,7 +61,7 @@ void Buffer::flush() { void Buffer::printChar(zchar c) { static bool flag = false; - if (g_vm->_message || g_vm->_ostream_memory || g_vm->_enableBuffering) { + if (g_vm->message || g_vm->ostream_memory || g_vm->enable_buffering) { if (!flag) { // Characters 0 and ZC_RETURN are special cases if (c == ZC_RETURN) { diff --git a/engines/gargoyle/frotz/err.cpp b/engines/gargoyle/frotz/err.cpp index f9a3ce9580..f75b764ad0 100644 --- a/engines/gargoyle/frotz/err.cpp +++ b/engines/gargoyle/frotz/err.cpp @@ -67,14 +67,15 @@ Errors::Errors() { Common::fill(&_count[0], &_count[ERR_NUM_ERRORS], 0); } -void Errors::runtimeError(int errNum) { - int wasfirst; +void Errors::runtimeError(ErrorCode errNum) { +#ifdef TODO + int wasfirst; if (errNum <= 0 || errNum > ERR_NUM_ERRORS) return; - if (g_vm->_options._err_report_mode == ERR_REPORT_FATAL - || (!g_vm->_options._ignore_errors && errNum <= ERR_MAX_FATAL)) { + if (g_vm->_err_report_mode == ERR_REPORT_FATAL + || (!g_vm->_ignore_errors && errNum <= ERR_MAX_FATAL)) { g_vm->_buffer.flush(); error(ERR_MESSAGES[errNum - 1]); return; @@ -83,9 +84,9 @@ void Errors::runtimeError(int errNum) { wasfirst = (_count[errNum - 1] == 0); _count[errNum - 1]++; - if ((g_vm->_options._err_report_mode == ERR_REPORT_ALWAYS) - || (g_vm->_options._err_report_mode == ERR_REPORT_ONCE && wasfirst)) { - long pc; + if ((g_vm->_err_report_mode == ERR_REPORT_ALWAYS) + || (_err_report_mode == ERR_REPORT_ONCE && wasfirst)) { + long pc = g_vm->_processor GET_PC(pc); printString("Warning: "); printString(ERR_MESSAGES[errNum - 1]); @@ -93,7 +94,7 @@ void Errors::runtimeError(int errNum) { printLong(pc, 16); printChar(')'); - if (g_vm->_options._err_report_mode == ERR_REPORT_ONCE) { + if (_err_report_mode == ERR_REPORT_ONCE) { printString(" (will ignore further occurrences)"); } else { printString(" (occurence "); @@ -103,6 +104,7 @@ void Errors::runtimeError(int errNum) { newLine(); } +#endif } void Errors::printLong(uint value, int base) { diff --git a/engines/gargoyle/frotz/err.h b/engines/gargoyle/frotz/err.h index f61d7269af..e71c9881e8 100644 --- a/engines/gargoyle/frotz/err.h +++ b/engines/gargoyle/frotz/err.h @@ -28,26 +28,51 @@ namespace Gargoyle { namespace Frotz { -#define ERR_NUM_ERRORS 33 -#define ERR_MAX_FATAL 19 +enum ErrorCode { + ERR_TEXT_BUF_OVF = 1, ///< Text buffer overflow + ERR_STORE_RANGE = 2, ///< Store out of dynamic memory + ERR_DIV_ZERO = 3, ///< Division by zero + ERR_ILL_OBJ = 4, ///< Illegal object + ERR_ILL_ATTR = 5, ///< Illegal attribute + ERR_NO_PROP = 6, ///< No such property + ERR_STK_OVF = 7, ///< Stack overflow + ERR_ILL_CALL_ADDR = 8, ///< Call to illegal address + ERR_CALL_NON_RTN = 9, ///< Call to non-routine + ERR_STK_UNDF = 10, ///< Stack underflow + ERR_ILL_OPCODE = 11, ///< Illegal opcode + ERR_BAD_FRAME = 12, ///< Bad stack frame + ERR_ILL_JUMP_ADDR = 13, ///< Jump to illegal address + ERR_SAVE_IN_INTER = 14, ///< Can't save while in interrupt + ERR_STR3_NESTING = 15, ///< Nesting stream #3 too deep + ERR_ILL_WIN = 16, ///< Illegal window + ERR_ILL_WIN_PROP = 17, ///< Illegal window property + ERR_ILL_PRINT_ADDR = 18, ///< Print at illegal address + ERR_DICT_LEN = 19, ///< Illegal dictionary word length + ERR_MAX_FATAL = 19, + + // Less serious errors + ERR_JIN_0 = 20, ///< @jin called with object 0 + ERR_GET_CHILD_0 = 21, ///< @get_child called with object 0 + ERR_GET_PARENT_0 = 22, ///< @get_parent called with object 0 + ERR_GET_SIBLING_0 = 23, ///< @get_sibling called with object 0 + ERR_GET_PROP_ADDR_0 = 24, ///< @get_prop_addr called with object 0 + ERR_GET_PROP_0 = 25, ///< @get_prop called with object 0 + ERR_PUT_PROP_0 = 26, ///< @put_prop called with object 0 + ERR_CLEAR_ATTR_0 = 27, ///< @clear_attr called with object 0 + ERR_SET_ATTR_0 = 28, ///< @set_attr called with object 0 + ERR_TEST_ATTR_0 = 29, ///< @test_attr called with object 0 + ERR_MOVE_OBJECT_0 = 30, ///< @move_object called moving object 0 + ERR_MOVE_OBJECT_TO_0 = 31, ///< @move_object called moving into object 0 + ERR_REMOVE_OBJECT_0 = 32, ///< @remove_object called with object 0 + ERR_GET_NEXT_PROP_0 = 33, ///< @get_next_prop called with object 0 + ERR_NUM_ERRORS = 33 +}; class Errors { private: static const char *const ERR_MESSAGES[ERR_NUM_ERRORS]; int _count[ERR_NUM_ERRORS]; -public: - /** - * Constructor - */ - Errors(); - - /** - * An error has occurred. Ignore it, pass it to os_fatal or report - * it according to err_report_mode. - * @param errNum Numeric code for error (1 to ERR_NUM_ERRORS) - */ - void runtimeError(int errNum); - +private: /** * Print an unsigned 32bit number in decimal or hex. */ @@ -67,6 +92,23 @@ public: * Add a newline */ void newLine(); +protected: + /** + * Get the PC. Is implemented by the Processor class, which derives from Errors + */ + virtual zword getPC() const = 0; +public: + /** + * Constructor + */ + Errors(); + + /** + * An error has occurred. Ignore it, pass it to os_fatal or report + * it according to err_report_mode. + * @param errNum Numeric code for error (1 to ERR_NUM_ERRORS) + */ + void runtimeError(ErrorCode errNum); }; } // End of namespace Frotz diff --git a/engines/gargoyle/frotz/frotz.cpp b/engines/gargoyle/frotz/frotz.cpp index 64b9f54449..c0a9442ad4 100644 --- a/engines/gargoyle/frotz/frotz.cpp +++ b/engines/gargoyle/frotz/frotz.cpp @@ -28,27 +28,18 @@ namespace Frotz { Frotz *g_vm; -Frotz::Frotz(OSystem *syst, const GargoyleGameDescription *gameDesc) : Glk(syst, gameDesc), - _storyId(UNKNOWN), _storySize(0), _sp(nullptr), _fp(nullptr), _frameCount(0), - _ostream_screen(true), _ostream_script(false), _ostream_memory(false), - _ostream_record(false), _istream_replay(false), _message(false), - _cwin(0), _mwin(0), _mouse_x(0), _mouse_y(0), _menu_selected(0), - _enableWrapping(false), _enableScripting(true), _enableScrolling(false), - _enableBuffering(false), _reserveMem(0) { +Frotz::Frotz(OSystem *syst, const GargoyleGameDescription *gameDesc) : + Processor(syst, gameDesc) { g_vm = this; - Common::fill(&_stack[0], &_stack[STACK_SIZE], 0); } void Frotz::runGame(Common::SeekableReadStream *gameFile) { + story_fp = gameFile; initialize(); // TODO } -void Frotz::initialize() { - _mem.initialize(); -} - Common::Error Frotz::loadGameState(int slot) { return Common::kNoError; } diff --git a/engines/gargoyle/frotz/frotz.h b/engines/gargoyle/frotz/frotz.h index 4dd583449b..c032265453 100644 --- a/engines/gargoyle/frotz/frotz.h +++ b/engines/gargoyle/frotz/frotz.h @@ -23,11 +23,7 @@ #ifndef GARGOYLE_FROTZ_FROTZ #define GARGOYLE_FROTZ_FROTZ -#include "gargoyle/glk.h" -#include "gargoyle/frotz/frotz_types.h" -#include "gargoyle/frotz/buffer.h" -#include "gargoyle/frotz/err.h" -#include "gargoyle/frotz/mem.h" +#include "gargoyle/frotz/processor.h" namespace Gargoyle { namespace Frotz { @@ -35,52 +31,7 @@ namespace Frotz { /** * Frotz interpreter for Z-code games */ -class Frotz : public Glk { -private: - /** - * Perform any initialization - */ - void initialize(); -public: - UserOptions _options; - Header _header; - Buffer _buffer; - Mem _mem; - - // Story file name, id number and size - Common::SeekableReadStream *_gameFile; - Story _storyId; - size_t _storySize; - - // Stack data - zword _stack[STACK_SIZE]; - zword *_sp; - zword *_fp; - zword _frameCount; - - // IO streams - bool _ostream_screen; - bool _ostream_script; - bool _ostream_memory; - bool _ostream_record; - bool _istream_replay; - bool _message; - - // Current window and mouse data - int _cwin; - int _mwin; - int _mouse_y; - int _mouse_x; - int _menu_selected; - - // Window attributes - bool _enableWrapping; - bool _enableScripting; - bool _enableScrolling; - bool _enableBuffering; - - // Size of memory to reserve (in bytes) - size_t _reserveMem; +class Frotz : public Processor { public: /** * Constructor diff --git a/engines/gargoyle/frotz/frotz_types.h b/engines/gargoyle/frotz/frotz_types.h index 3c7312c1bc..c4f4298a4e 100644 --- a/engines/gargoyle/frotz/frotz_types.h +++ b/engines/gargoyle/frotz/frotz_types.h @@ -35,15 +35,6 @@ namespace Frotz { #define lo(v) (v & 0xff) #define hi(v) (v >> 8) -#define SET_WORD(addr,v) WRITE_BE_UINT16(addr,v) -#define LOW_WORD(addr,v) READ_BE_UINT16(addr,v) -#define HIGH_WORD(addr,v) READ_BE_UINT16(addr,v) -#define HIGH_LONG(addr,v) READ_BE_UINT32(addr,v) -#define CODE_WORD(v) v = g_vm->_mem.readWord() -#define CODE_IDX_WORD(v,i) v = g_vm->_mem.readWord(i) -#define GET_PC(v) v = g_vm->_mem.getPC() -#define SET_PC(v) g_vm->_mem.setPC(v); - /* There are four error reporting modes: never report errors; * report only the first time a given error type occurs; * report every time an error occurs; @@ -113,6 +104,113 @@ enum Story { UNKNOWN }; +enum Version { + V1 = 1, + V2 = 2, + V3 = 3, + V4 = 4, + V5 = 5, + V6 = 6, + V7 = 7, + V8 = 8, + V9 = 9 +}; + +enum ConfigFlag { + CONFIG_BYTE_SWAPPED = 0x01, ///< Story file is byte swapped - V3 + CONFIG_TIME = 0x02, ///< Status line displays time - V3 + CONFIG_TWODISKS = 0x04, ///< Story file occupied two disks - V3 + CONFIG_TANDY = 0x08, ///< Tandy licensed game - V3 + CONFIG_NOSTATUSLINE = 0x10, ///< Interpr can't support status lines - V3 + CONFIG_SPLITSCREEN = 0x20, ///< Interpr supports split screen mode - V3 + CONFIG_PROPORTIONAL = 0x40, ///< Interpr uses proportional font - V3 + + CONFIG_COLOUR = 0x01, ///< Interpr supports colour - V5+ + CONFIG_PICTURES = 0x02, ///< Interpr supports pictures - V6 + CONFIG_BOLDFACE = 0x04, ///< Interpr supports boldface style - V4+ + CONFIG_EMPHASIS = 0x08, ///< Interpr supports emphasis style - V4+ + CONFIG_FIXED = 0x10, ///< Interpr supports fixed width style - V4+ + CONFIG_SOUND = 0x20, ///< Interpr supports sound - V6 + CONFIG_TIMEDINPUT = 0x80, ///< Interpr supports timed input - V4+ + + SCRIPTING_FLAG = 0x0001, ///< Outputting to transscription file - V1+ + FIXED_FONT_FLAG = 0x0002, ///< Use fixed width font - V3+ + REFRESH_FLAG = 0x0004, ///< Refresh the screen - V6 + GRAPHICS_FLAG = 0x0008, ///< Game wants to use graphics - V5+ + OLD_SOUND_FLAG = 0x0010, ///< Game wants to use sound effects - V3 + UNDO_FLAG = 0x0010, ///< Game wants to use UNDO feature - V5+ + MOUSE_FLAG = 0x0020, ///< Game wants to use a mouse - V5+ + COLOUR_FLAG = 0x0040, ///< Game wants to use colours - V5+ + SOUND_FLAG = 0x0080, ///< Game wants to use sound effects - V5+ + MENU_FLAG = 0x0100 ///< Game wants to use menus - V6 +}; + +enum { + TRANSPARENT_FLAG = 0x0001 ///< Game wants to use transparency - V6 +}; + +enum FrotzInterp { +#define INTERP_DEFAULT 0 +#define INTERP_DEC_20 1 +#define INTERP_APPLE_IIE 2 +#define INTERP_MACINTOSH 3 +#define INTERP_AMIGA 4 +#define INTERP_ATARI_ST 5 +#define INTERP_MSDOS 6 +#define INTERP_CBM_128 7 +#define INTERP_CBM_64 8 +#define INTERP_APPLE_IIC 9 +#define INTERP_APPLE_IIGS 10 +#define INTERP_TANDY 11 +}; + +enum Colour { + BLACK_COLOUR = 2, + RED_COLOUR = 3, + GREEN_COLOUR = 4, + YELLOW_COLOUR = 5, + BLUE_COLOUR = 6, + MAGENTA_COLOUR = 7, + CYAN_COLOUR = 8, + WHITE_COLOUR = 9, + GREY_COLOUR = 10, ///< INTERP_MSDOS only + LIGHTGREY_COLOUR = 10, ///< INTERP_AMIGA only + MEDIUMGREY_COLOUR = 11, ///< INTERP_AMIGA only + DARKGREY_COLOUR = 12, ///< INTERP_AMIGA only + TRANSPARENT_COLOUR = 15 ///< ZSpec 1.1 +}; + +enum Style { + REVERSE_STYLE = 1, + BOLDFACE_STYLE = 2, + EMPHASIS_STYLE = 4, + FIXED_WIDTH_STYLE = 8 +}; + +enum FontStyle { + TEXT_FONT = 1, + PICTURE_FONT = 2, + GRAPHICS_FONT = 3, + FIXED_WIDTH_FONT = 4 +}; + +/*** Constants for os_beep */ + +#define BEEP_HIGH 1 +#define BEEP_LOW 2 + +/*** Constants for os_restart_game */ + +#define RESTART_BEGIN 0 +#define RESTART_WPROP_SET 1 +#define RESTART_END 2 + +/*** Constants for os_menu */ + +#define MENU_NEW 0 +#define MENU_ADD 1 +#define MENU_REMOVE 2 + typedef byte zbyte; typedef uint zchar; typedef uint16 zword; diff --git a/engines/gargoyle/frotz/glk_interface.cpp b/engines/gargoyle/frotz/glk_interface.cpp new file mode 100644 index 0000000000..e1311fbc62 --- /dev/null +++ b/engines/gargoyle/frotz/glk_interface.cpp @@ -0,0 +1,272 @@ +/* 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 "gargoyle/frotz/glk_interface.h" + +namespace Gargoyle { +namespace Frotz { + +GlkInterface::GlkInterface(OSystem *syst, const GargoyleGameDescription *gameDesc) : + Glk(syst, gameDesc), + oldstyle(0), curstyle(0), cury(1), curx(1), fixforced(0), + curr_fg(-2), curr_bg(-2), curr_font(1), prev_font(1), temp_font(0), + curr_status_ht(0), mach_status_ht(0), gos_status(nullptr), gos_upper(nullptr), + gos_lower(nullptr), gos_curwin(nullptr), gos_linepending(0), gos_linebuf(nullptr), + gos_linewin(nullptr), gos_channel(nullptr), cwin(0), mwin(0), mouse_x(0), mouse_y(0), + menu_selected(0), ostream_screen(false), ostream_script(false), ostream_memory(false), + ostream_record(false), istream_replay(false), message(false), + enable_wrapping(false), enable_scripting(false), enable_scrolling(false), + enable_buffering(false), next_sample(0), next_volume(0), + _soundLocked(false), _soundPlaying(false) { + Common::fill(&statusline[0], &statusline[256], '\0'); +} + +int GlkInterface::os_char_width(zchar z) { + return 1; +} + +int GlkInterface::os_string_width(const zchar *s) { + int width = 0; + zchar c; + while ((c = *s++) != 0) + if (c == ZC_NEW_STYLE || c == ZC_NEW_FONT) + s++; + else + width += os_char_width(c); + return width; +} + +int GlkInterface::os_string_length(zchar *s) { + int length = 0; + while (*s++) length++; + return length; +} + +void GlkInterface::os_prepare_sample(int a) { + glk_sound_load_hint(a, 1); +} + +void GlkInterface::os_finish_with_sample(int a) { + glk_sound_load_hint(a, 0); +} + +void GlkInterface::os_start_sample(int number, int volume, int repeats, zword eos) { + int vol; + + if (!gos_channel) { + gos_channel = glk_schannel_create(0); + if (!gos_channel) + return; + } + + switch (volume) { + case 1: vol = 0x02000; break; + case 2: vol = 0x04000; break; + case 3: vol = 0x06000; break; + case 4: vol = 0x08000; break; + case 5: vol = 0x0a000; break; + case 6: vol = 0x0c000; break; + case 7: vol = 0x0e000; break; + case 8: vol = 0x10000; break; + default: vol = 0x20000; break; + } + + // we dont do repeating or eos-callback for now... + glk_schannel_play_ext(gos_channel, number, 1, 0); + glk_schannel_set_volume(gos_channel, vol); +} + +void GlkInterface::os_stop_sample(int a) { + if (!gos_channel) + return; + glk_schannel_stop(gos_channel); +} + +void GlkInterface::os_beep(int volume) { +} + +void GlkInterface::start_sample(int number, int volume, int repeats, zword eos) { + // TODO +} + +void GlkInterface::start_next_sample() { + // TODO +} + +void GlkInterface::gos_update_width() { + glui32 width; + if (gos_upper) { + glk_window_get_size(gos_upper, &width, nullptr); + h_screen_cols = width; + SET_BYTE(H_SCREEN_COLS, width); + if (curx > width) { + glk_window_move_cursor(gos_upper, 0, cury - 1); + curx = 1; + } + } +} + +void GlkInterface::gos_update_height() { + glui32 height_upper; + glui32 height_lower; + if (gos_curwin) { + glk_window_get_size(gos_upper, nullptr, &height_upper); + glk_window_get_size(gos_lower, nullptr, &height_lower); + h_screen_rows = height_upper + height_lower + 1; + SET_BYTE(H_SCREEN_ROWS, h_screen_rows); + } +} + +void GlkInterface::reset_status_ht() { + glui32 height; + if (gos_upper) { + glk_window_get_size(gos_upper, nullptr, &height); + if (mach_status_ht != height) { + glk_window_set_arrangement( + glk_window_get_parent(gos_upper), + winmethod_Above | winmethod_Fixed, + mach_status_ht, nullptr); + } + } +} + +void GlkInterface::erase_window(zword w) { + if (w == 0) + glk_window_clear(gos_lower); + else if (gos_upper) { +#ifdef GARGLK + garglk_set_reversevideo_stream( + glk_window_get_stream(gos_upper), + true); +#endif /* GARGLK */ + + memset(statusline, ' ', sizeof statusline); + glk_window_clear(gos_upper); + reset_status_ht(); + curr_status_ht = 0; + } +} + +void GlkInterface::split_window(zword lines) { + if (!gos_upper) + return; + + // The top line is always set for V1 to V3 games + if (h_version < V4) + lines++; + + if (!lines || lines > curr_status_ht) { + glui32 height; + + glk_window_get_size(gos_upper, nullptr, &height); + if (lines != height) + glk_window_set_arrangement( + glk_window_get_parent(gos_upper), + winmethod_Above | winmethod_Fixed, + lines, nullptr); + curr_status_ht = lines; + } + mach_status_ht = lines; + if (cury > lines) + { + glk_window_move_cursor(gos_upper, 0, 0); + curx = cury = 1; + } + gos_update_width(); + + if (h_version == V3) + glk_window_clear(gos_upper); +} + +void GlkInterface::restart_screen() { + erase_window(0); + erase_window(1); + split_window(0); +} + +void GlkInterface::packspaces(zchar *src, zchar *dst) { + int killing = 0; + while (*src) { + if (*src == 0x20202020) + *src = ' '; + if (*src == ' ') + killing++; + else + killing = 0; + if (killing > 2) + src++; + else + *dst++ = *src++; + } + + *dst = 0; +} + +void GlkInterface::smartstatusline() { + zchar packed[256]; + zchar buf[256]; + zchar *a, *b, *c, *d; + int roomlen, scorelen, scoreofs; + int len, tmp; + + packspaces(statusline, packed); + len = os_string_length(packed); + + a = packed; + while (a[0] == ' ') + a++; + + b = a; + while (b[0] != 0 && !(b[0] == ' ' && b[1] == ' ')) + b++; + + c = b; + while (c[0] == ' ') + c++; + + d = packed + len - 1; + while (d[0] == ' ' && d > c) + d--; + if (d[0] != ' ' && d[0] != 0) + d++; + if (d < c) + d = c; + + roomlen = b - a; + scorelen = d - c; + scoreofs = h_screen_cols - scorelen - 2; + if (scoreofs <= roomlen) + scoreofs = roomlen + 2; + + for (tmp = 0; tmp < h_screen_cols; tmp++) + buf[tmp] = ' '; + + memcpy(buf + 1 + scoreofs, c, scorelen * sizeof(zchar)); + memcpy(buf + 1, a, roomlen * sizeof(zchar)); + + glk_window_move_cursor(gos_upper, 0, 0); + glk_put_buffer_uni(buf, h_screen_cols); + glk_window_move_cursor(gos_upper, cury - 1, curx - 1); +} + +} // End of namespace Scott +} // End of namespace Gargoyle diff --git a/engines/gargoyle/frotz/glk_interface.h b/engines/gargoyle/frotz/glk_interface.h new file mode 100644 index 0000000000..ea3f60cfe8 --- /dev/null +++ b/engines/gargoyle/frotz/glk_interface.h @@ -0,0 +1,147 @@ +/* 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. + * + */ + +#ifndef GARGOYLE_FROTZ_GLK_INTERFACE +#define GARGOYLE_FROTZ_GLK_INTERFACE + +#include "gargoyle/glk.h" +#include "gargoyle/frotz/mem.h" + +namespace Gargoyle { +namespace Frotz { + +enum SoundEffect { + EFFECT_PREPARE = 1, + EFFECT_PLAY = 2, + EFFECT_STOP = 3, + EFFECT_FINISH_WITH = 4 +}; + +/** + * Implements an intermediate interface on top of the GLK layer, providing screen + * and sound effect handling + */ +class GlkInterface : public Glk, public virtual Mem { +public: + zchar statusline[256]; + int oldstyle; + int curstyle; + int cury; + int curx; + int fixforced; + + int curr_fg; + int curr_bg; + int curr_font; + int prev_font; + int temp_font; + + int curr_status_ht; + int mach_status_ht; + + winid_t gos_status; + winid_t gos_upper; + winid_t gos_lower; + winid_t gos_curwin; + int gos_linepending; + zchar *gos_linebuf; + winid_t gos_linewin; + schanid_t gos_channel; + + // Current window and mouse data + int cwin; + int mwin; + int mouse_y; + int mouse_x; + int menu_selected; + + // IO streams + bool ostream_screen; + bool ostream_script; + bool ostream_memory; + bool ostream_record; + bool istream_replay; + bool message; + + // Window attributes + bool enable_wrapping; + bool enable_scripting; + bool enable_scrolling; + bool enable_buffering; + + // Sound fields + int next_sample; + int next_volume; + + bool _soundLocked; + bool _soundPlaying; +protected: + int os_char_width(zchar z); + int os_string_width(const zchar *s); + int os_string_length(zchar *s); + void os_prepare_sample(int a); + void os_finish_with_sample(int a); + + /** + * Play the given sample at the given volume (ranging from 1 to 8 and + * 255 meaning a default volume). The sound is played once or several + * times in the background (255 meaning forever). In Z-code 3 the + * repeats value is always 0 and the number of repeats is taken from + * the sound file itself. The end_of_sound function is called as soon + * as the sound finishes. + */ + void os_start_sample(int number, int volume, int repeats, zword eos); + + void os_stop_sample(int a); + void os_beep(int volume); + + /** + * Call the IO interface to play a sample. + */ + void start_sample(int number, int volume, int repeats, zword eos); + + void start_next_sample(); + void gos_update_width(); + void gos_update_height(); + void reset_status_ht(); + void erase_window(zword w); + void split_window(zword lines); + void restart_screen(); + + /** + * statusline overflowed the window size ... bad game! + * so ... split status text into regions, reformat and print anew. + */ + void packspaces(zchar *src, zchar *dst); + + void smartstatusline(); +public: + /** + * Constructor + */ + GlkInterface(OSystem *syst, const GargoyleGameDescription *gameDesc); +}; + +} // End of namespace Frotz +} // End of namespace Gargoyle + +#endif diff --git a/engines/gargoyle/frotz/mem.cpp b/engines/gargoyle/frotz/mem.cpp index 1b43e93d20..cb5a73b8d1 100644 --- a/engines/gargoyle/frotz/mem.cpp +++ b/engines/gargoyle/frotz/mem.cpp @@ -22,12 +22,13 @@ #include "gargoyle/frotz/mem.h" #include "gargoyle/frotz/frotz.h" +#include "common/memstream.h" #include "common/textconsole.h" namespace Gargoyle { namespace Frotz { -const Mem::StoryEntry Mem::RECORDS[25] = { +const Header::StoryEntry Header::RECORDS[25] = { { SHERLOCK, 21, "871214" }, { SHERLOCK, 26, "880127" }, { BEYOND_ZORK, 47, "870915" }, @@ -55,28 +56,99 @@ const Mem::StoryEntry Mem::RECORDS[25] = { { UNKNOWN, 0, "------" } }; -Mem::Mem() : story_fp(nullptr), blorb_ofs(0), blorb_len(0) { +void Header::loadHeader(Common::SeekableReadStream &f) { + h_version = f.readByte(); + h_config = f.readByte(); + + if (h_version < V1 || h_version > V8) + error("Unknown Z-code version"); + + if (h_version == V6) + error("Cannot play Z-code version 6"); + + if (h_version == V3 && (h_config & CONFIG_BYTE_SWAPPED)) + error("Byte swapped story file"); + + h_release = f.readUint16BE(); + h_resident_size = f.readUint16BE(); + h_start_pc = f.readUint16BE(); + h_dictionary = f.readUint16BE(); + h_objects = f.readUint16BE(); + h_globals = f.readUint16BE(); + h_dynamic_size = f.readUint16BE(); + h_flags = f.readUint16BE(); + f.read(h_serial, 6); + + /* Auto-detect buggy story files that need special fixes */ + _storyId = UNKNOWN; + + for (int i = 0; RECORDS[i]._storyId != UNKNOWN; ++i) { + if (h_release == RECORDS[i]._release) { + if (!strncmp((const char *)h_serial, RECORDS[i]._serial, 6)) { + _storyId = RECORDS[i]._storyId; + break; + } + } + } + + h_abbreviations = f.readUint16BE(); + h_file_size = f.readUint16BE(); + h_checksum = f.readUint16BE(); + + f.seek(H_FUNCTIONS_OFFSET); + h_functions_offset = f.readUint16BE(); + h_strings_offset = f.readUint16BE(); + f.seek(H_TERMINATING_KEYS); + h_terminating_keys = f.readUint16BE(); + f.seek(H_ALPHABET); + h_alphabet = f.readUint16BE(); + h_extension_table = f.readUint16BE(); + + + // Zork Zero Macintosh doesn't have the graphics flag set + if (_storyId == ZORK_ZERO && h_release == 296) + h_flags |= GRAPHICS_FLAG; +} + +/*--------------------------------------------------------------------------*/ + +Mem::Mem() : story_fp(nullptr), blorb_ofs(0), blorb_len(0), story_size(0) { } void Mem::initialize() { -/* - long size; - zword addr; - unsigned n; - int i, j; - */ initializeStoryFile(); + loadGameHeader(); + + // Allocate memory for story data + if ((zmp = (zbyte *)realloc(zmp, story_size)) == nullptr) + error("Out of memory"); + + // Load story file in chunks of 32KB + uint n = 0x8000; + + for (uint size = 64; size < story_size; size += n) { + if (story_size - size < 0x8000) + n = story_size - size; + + setPC(size); - // TODO: More stuff + if (story_fp->read(pcp, n) != n) + error("Story file read error"); + + } + + // Read header extension table + hx_table_size = get_header_extension(HX_TABLE_SIZE); + hx_unicode_table = get_header_extension(HX_UNICODE_TABLE); + hx_flags = get_header_extension(HX_FLAGS); } void Mem::initializeStoryFile() { - Common::SeekableReadStream *f = g_vm->_gameFile; + Common::SeekableReadStream *f = story_fp; giblorb_map_t *map; giblorb_result_t res; uint32 magic; - story_fp = f; magic = f->readUint32BE(); if (magic == MKTAG('F', 'O', 'R', 'M')) { @@ -101,5 +173,41 @@ void Mem::initializeStoryFile() { error("This file is too small to be a Z-code file."); } +void Mem::loadGameHeader() { + // Load header + zmp = new byte[64]; + story_fp->seek(blorb_ofs); + story_fp->read(zmp, 64); + + Common::MemoryReadStream h(zmp, 64); + loadHeader(h); + + // Calculate story file size in bytes + if (h_file_size != 0) { + story_size = (long)2 * h_file_size; + + if (h_version >= V4) + story_size *= 2; + if (h_version >= V6) + story_size *= 2; + } else { + // Some old games lack the file size entry + story_size = blorb_len; + } +} + +zword Mem::get_header_extension(int entry) { + zword addr; + zword val; + + if (h_extension_table == 0 || entry > hx_table_size) + return 0; + + addr = h_extension_table + 2 * entry; + LOW_WORD(addr, val); + + return val; +} + } // End of namespace Scott } // End of namespace Gargoyle diff --git a/engines/gargoyle/frotz/mem.h b/engines/gargoyle/frotz/mem.h index 68c7b85ece..d37cdd3d99 100644 --- a/engines/gargoyle/frotz/mem.h +++ b/engines/gargoyle/frotz/mem.h @@ -28,11 +28,71 @@ namespace Gargoyle { namespace Frotz { +#define SET_WORD(addr,v) zmp[addr] = hi(v); zmp[addr+1] = lo(v) +#define LOW_WORD(addr,v) v = READ_BE_UINT16(&zmp[addr]) +#define HIGH_WORD(addr,v) v = READ_BE_UINT16(&zmp[addr]) +#define HIGH_LONG(addr,v) v = READ_BE_UINT32(&zmp[addr]) +#define SET_BYTE(addr,v) zmp[addr] = v +#define LOW_BYTE(addr,v) v = zmp[addr] + +enum HeaderByte { + H_VERSION = 0, + H_CONFIG = 1, + H_RELEASE = 2, + H_RESIDENT_SIZE = 4, + H_START_PC = 6, + H_DICTIONARY = 8, + H_OBJECTS = 10, + H_GLOBALS = 12, + H_DYNAMIC_SIZE = 14, + H_FLAGS = 16, + H_SERIAL = 18, + H_ABBREVIATIONS = 24, + H_FILE_SIZE = 26, + H_CHECKSUM = 28, + H_INTERPRETER_NUMBER = 30, + H_INTERPRETER_VERSION = 31, + H_SCREEN_ROWS = 32, + H_SCREEN_COLS = 33, + H_SCREEN_WIDTH = 34, + H_SCREEN_HEIGHT = 36, + H_FONT_HEIGHT = 38, ///< this is the font width in V5 + H_FONT_WIDTH = 39, ///< this is the font height in V5 + H_FUNCTIONS_OFFSET = 40, + H_STRINGS_OFFSET = 42, + H_DEFAULT_BACKGROUND = 44, + H_DEFAULT_FOREGROUND = 45, + H_TERMINATING_KEYS = 46, + H_LINE_WIDTH = 48, + H_STANDARD_HIGH = 50, + H_STANDARD_LOW = 51, + H_ALPHABET = 52, + H_EXTENSION_TABLE = 54, + H_USER_NAME = 56 +}; + +enum { + HX_TABLE_SIZE = 0, + HX_MOUSE_X = 1, + HX_MOUSE_Y = 2, + HX_UNICODE_TABLE = 3, + HX_FLAGS = 4, + HX_FORE_COLOUR = 5, + HX_BACK_COLOUR = 6 +}; /** * Story file header data */ struct Header { +private: + struct StoryEntry { + Story _storyId; + zword _release; + char _serial[7]; + }; + static const StoryEntry RECORDS[25]; +public: zbyte h_version; zbyte h_config; zword h_release; @@ -75,6 +135,11 @@ struct Header { zword hx_fore_colour; zword hx_back_colour; + Story _storyId; + + /** + * Constructor + */ Header() : h_version(0), h_config(0), h_release(0), h_resident_size(0), h_start_pc(0), h_dictionary(0), h_objects(0), h_globals(0), h_dynamic_size(0), h_flags(0), h_abbreviations(0), h_file_size(0), h_checksum(0), h_interpreter_number(0), @@ -84,22 +149,22 @@ struct Header { h_terminating_keys(0), h_line_width(0), h_standard_high(1), h_standard_low(1), h_alphabet(0), h_extension_table(0), hx_table_size(0), hx_mouse_x(0), hx_mouse_y(0), hx_unicode_table(0), - hx_flags(0), hx_fore_colour(0), hx_back_colour(0) { + hx_flags(0), hx_fore_colour(0), hx_back_colour(0), _storyId(UNKNOWN) { Common::fill(&h_serial[0], &h_serial[6], '\0'); Common::fill(&h_user_name[0], &h_user_name[8], '\0'); } + + /** + * Load the header + */ + void loadHeader(Common::SeekableReadStream &f); }; class Mem : public Header { - struct StoryEntry { - Story _storyId; - zword _release; - char _serial[7]; - }; - static const StoryEntry RECORDS[25]; -private: +protected: Common::SeekableReadStream *story_fp; uint blorb_ofs, blorb_len; + uint story_size; byte *pcp; byte *zmp; private: @@ -107,6 +172,11 @@ private: * Handles setting the story file, parsing it if it's a Blorb file */ void initializeStoryFile(); + + /** + * Handles loading the game header + */ + void loadGameHeader(); public: /** * Constructor @@ -116,7 +186,7 @@ public: /** * Initialize */ - void initialize(); + virtual void initialize(); /** * Read a word @@ -142,6 +212,11 @@ public: * Set the PC */ void setPC(uint ofs) { pcp = zmp + ofs; } + + /** + * Read a value from the header extension (former mouse table). + */ + zword get_header_extension(int entry); }; } // End of namespace Frotz diff --git a/engines/gargoyle/frotz/processor.cpp b/engines/gargoyle/frotz/processor.cpp new file mode 100644 index 0000000000..1a31898a2a --- /dev/null +++ b/engines/gargoyle/frotz/processor.cpp @@ -0,0 +1,659 @@ +/* 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 "gargoyle/frotz/processor.h" +#include "gargoyle/frotz/frotz.h" + +namespace Gargoyle { +namespace Frotz { + +// TODO: Stubs to replace with actual code +zword save_undo() { return 0; } +zword restore_undo() { return 0; } + + +Opcode Processor::var_opcodes[64] = { + &Processor::__illegal__, + &Processor::z_je, + &Processor::z_jl, + &Processor::z_jg, + &Processor::z_dec_chk, + &Processor::z_inc_chk, + &Processor::z_jin, + &Processor::z_test, + &Processor::z_or, + &Processor::z_and, + &Processor::z_test_attr, + &Processor::z_set_attr, + &Processor::z_clear_attr, + &Processor::z_store, + &Processor::z_insert_obj, + &Processor::z_loadw, + &Processor::z_loadb, + &Processor::z_get_prop, + &Processor::z_get_prop_addr, + &Processor::z_get_next_prop, + &Processor::z_add, + &Processor::z_sub, + &Processor::z_mul, + &Processor::z_div, + &Processor::z_mod, + &Processor::z_call_s, + &Processor::z_call_n, + &Processor::z_set_colour, + &Processor::z_throw, + &Processor::__illegal__, + &Processor::__illegal__, + &Processor::__illegal__, + &Processor::z_call_s, + &Processor::z_storew, + &Processor::z_storeb, + &Processor::z_put_prop, + &Processor::z_read, + &Processor::z_print_char, + &Processor::z_print_num, + &Processor::z_random, + &Processor::z_push, + &Processor::z_pull, + &Processor::z_split_window, + &Processor::z_set_window, + &Processor::z_call_s, + &Processor::z_erase_window, + &Processor::z_erase_line, + &Processor::z_set_cursor, + &Processor::z_get_cursor, + &Processor::z_set_text_style, + &Processor::z_buffer_mode, + &Processor::z_output_stream, + &Processor::z_input_stream, + &Processor::z_sound_effect, + &Processor::z_read_char, + &Processor::z_scan_table, + &Processor::z_not, + &Processor::z_call_n, + &Processor::z_call_n, + &Processor::z_tokenise, + &Processor::z_encode_text, + &Processor::z_copy_table, + &Processor::z_print_table, + &Processor::z_check_arg_count +}; + +Opcode Processor::ext_opcodes[64] = { + &Processor::z_save, + &Processor::z_restore, + &Processor::z_log_shift, + &Processor::z_art_shift, + &Processor::z_set_font, + &Processor::__illegal__, // glkify - Processor::z_draw_picture, + &Processor::__illegal__, // glkify - Processor::z_picture_data, + &Processor::__illegal__, // glkify - Processor::z_erase_picture, + &Processor::__illegal__, // glkify - Processor::z_set_margins, + &Processor::z_save_undo, + &Processor::z_restore_undo, + &Processor::z_print_unicode, + &Processor::z_check_unicode, + &Processor::z_set_true_colour, // spec 1.1 + &Processor::__illegal__, + &Processor::__illegal__, + &Processor::__illegal__, // glkify - Processor::z_move_window, + &Processor::__illegal__, // glkify - Processor::z_window_size, + &Processor::__illegal__, // glkify - Processor::z_window_style, + &Processor::__illegal__, // glkify - Processor::z_get_wind_prop, + &Processor::__illegal__, // glkify - Processor::z_scroll_window, + &Processor::z_pop_stack, + &Processor::__illegal__, // glkify - Processor::z_read_mouse, + &Processor::__illegal__, // glkify - Processor::z_mouse_window, + &Processor::z_push_stack, + &Processor::__illegal__, // glkify - Processor::z_put_wind_prop, + &Processor::z_print_form, + &Processor::z_make_menu, + &Processor::__illegal__, // glkify - Processor::z_picture_table + &Processor::z_buffer_screen, // spec 1.1 +}; + +Processor::Processor(OSystem *syst, const GargoyleGameDescription *gameDesc) : + GlkInterface(syst, gameDesc), Mem(), Errors(), UserOptions(), + _finished(0), _sp(nullptr), _fp(nullptr), _frameCount(0), + zargc(0), _decoded(nullptr), _encoded(nullptr), _resolution(0), + _randomInterval(0), _randomCtr(0), first_restart(true) { + static const Opcode OP0_OPCODES[16] = { + &Processor::z_rtrue, + &Processor::z_rfalse, + &Processor::z_print, + &Processor::z_print_ret, + &Processor::z_nop, + &Processor::z_save, + &Processor::z_restore, + &Processor::z_restart, + &Processor::z_ret_popped, + &Processor::z_catch, + &Processor::z_quit, + &Processor::z_new_line, + &Processor::z_show_status, + &Processor::z_verify, + &Processor::__extended__, + &Processor::z_piracy + }; + static const Opcode OP1_OPCODES[16] = { + &Processor::z_jz, + &Processor::z_get_sibling, + &Processor::z_get_child, + &Processor::z_get_parent, + &Processor::z_get_prop_len, + &Processor::z_inc, + &Processor::z_dec, + &Processor::z_print_addr, + &Processor::z_call_s, + &Processor::z_remove_obj, + &Processor::z_print_obj, + &Processor::z_ret, + &Processor::z_jump, + &Processor::z_print_paddr, + &Processor::z_load, + &Processor::z_call_n + }; + + Common::copy(&OP0_OPCODES[0], &OP0_OPCODES[16], op0_opcodes); + Common::copy(&OP1_OPCODES[0], &OP1_OPCODES[16], op1_opcodes); + Common::fill(&_stack[0], &_stack[STACK_SIZE], 0); + Common::fill(&zargs[0], &zargs[8], 0); +} + +void Processor::initialize() { + Mem::initialize(); + + if (h_version <= V4) { + op0_opcodes[9] = &Processor::z_pop; + op1_opcodes[15] = &Processor::z_not; + } else { + op0_opcodes[9] = &Processor::z_catch; + op1_opcodes[15] = &Processor::z_call_n; + } +} + +void Processor::load_operand(zbyte type) { + zword value; + + if (type & 2) { + // variable + zbyte variable; + + CODE_BYTE(variable); + + if (variable == 0) + value = *_sp++; + else if (variable < 16) + value = *(_fp - variable); + else { + zword addr = h_globals + 2 * (variable - 16); + LOW_WORD(addr, value); + } + } else if (type & 1) { + // small constant + zbyte bvalue; + + CODE_BYTE(bvalue); + value = bvalue; + + } else { + // large constant + CODE_WORD(value); + } + + zargs[zargc++] = value; +} + +void Processor::load_all_operands(zbyte specifier) { + for (int i = 6; i >= 0; i -= 2) { + zbyte type = (specifier >> i) & 0x03; + + if (type == 3) + break; + + load_operand(type); + } +} + +void Processor::interpret() { + do { + zbyte opcode; + CODE_BYTE(opcode); + zargc = 0; + + if (opcode < 0x80) { + // 2OP opcodes + load_operand((zbyte)(opcode & 0x40) ? 2 : 1); + load_operand((zbyte)(opcode & 0x20) ? 2 : 1); + + (*this.*var_opcodes[opcode & 0x1f])(); + + } else if (opcode < 0xb0) { + // 1OP opcodes + load_operand((zbyte)(opcode >> 4)); + + (*this.*op1_opcodes[opcode & 0x0f])(); + + } else if (opcode < 0xc0) { + // 0OP opcodes + (*this.*op0_opcodes[opcode - 0xb0])(); + + } else { + // VAR opcodes + zbyte specifier1; + zbyte specifier2; + + if (opcode == 0xec || opcode == 0xfa) { // opcodes 0xec + CODE_BYTE(specifier1); // and 0xfa are + CODE_BYTE(specifier2); // call opcodes + load_all_operands(specifier1); // with up to 8 + load_all_operands(specifier2); // arguments + } else { + CODE_BYTE(specifier1); + load_all_operands(specifier1); + } + + (*this.*var_opcodes[opcode - 0xc0])(); + } + +#if defined(DJGPP) && defined(SOUND_SUPPORT) + if (end_of_sound_flag) + end_of_sound(); +#endif + } while (!_finished); + + _finished--; +} + +void Processor::call(zword routine, int argc, zword *args, int ct) { + long pc; + zword value; + zbyte count; + int i; + + if (_sp - _stack < 4) + runtimeError(ERR_STK_OVF); + + GET_PC(pc); + + *--_sp = (zword)(pc >> 9); + *--_sp = (zword)(pc & 0x1ff); + *--_sp = (zword)(_fp - _stack - 1); + *--_sp = (zword)(argc | (ct << (_save_quetzal ? 12 : 8))); + + _fp = _sp; + _frameCount++; + + // Calculate byte address of routine + if (h_version <= V3) + pc = (long)routine << 1; + else if (h_version <= V5) + pc = (long)routine << 2; + else if (h_version <= V7) + pc = ((long)routine << 2) + ((long)h_functions_offset << 3); + else if (h_version <= V8) + pc = (long)routine << 3; + else { + // h_version == V9 + long indirect = (long)routine << 2; + HIGH_LONG(indirect, pc); + } + + if ((uint)pc >= story_size) + runtimeError(ERR_ILL_CALL_ADDR); + + SET_PC(pc); + + // Initialise local variables + CODE_BYTE(count); + + if (count > 15) + runtimeError(ERR_CALL_NON_RTN); + if (_sp - _stack < count) + runtimeError(ERR_STK_OVF); + + if (_save_quetzal) + _fp[0] |= (zword)count << 8; // Save local var count for Quetzal. + + value = 0; + + for (i = 0; i < count; i++) { + if (h_version <= V4) // V1 to V4 games provide default + CODE_WORD(value); // values for all local variables + + *--_sp = (zword)((argc-- > 0) ? args[i] : value); + } + + // Start main loop for direct calls + if (ct == 2) + interpret(); +} + +void Processor::ret(zword value) { + long pc; + int ct; + + if (_sp > _fp) + runtimeError(ERR_STK_UNDF); + + _sp = _fp; + + ct = *_sp++ >> (_save_quetzal ? 12 : 8); + _frameCount--; + _fp = _stack + 1 + *_sp++; + pc = *_sp++; + pc = ((long)*_sp++ << 9) | pc; + + SET_PC(pc); + + // Handle resulting value + if (ct == 0) + store(value); + if (ct == 2) + *--_sp = value; + + // Stop main loop for direct calls + if (ct == 2) + _finished++; +} + +void Processor::branch(bool flag) { + long pc; + zword offset; + zbyte specifier; + zbyte off1; + zbyte off2; + + CODE_BYTE(specifier); + off1 = specifier & 0x3f; + + if (!flag) + specifier ^= 0x80; + + if (!(specifier & 0x40)) { + // it's a long branch + if (off1 & 0x20) // propagate sign bit + off1 |= 0xc0; + + CODE_BYTE(off2); + offset = (off1 << 8) | off2; + } else { + // It's a short branch + offset = off1; + } + + if (specifier & 0x80) { + if (offset > 1) { + // normal branch + GET_PC(pc); + pc += (short)offset - 2; + SET_PC(pc); + } else { + // special case, return 0 or 1 + ret(offset); + } + } +} + +void Processor::store(zword value) { + zbyte variable; + + CODE_BYTE(variable); + + if (variable == 0) + *--_sp = value; + else if (variable < 16) + *(_fp - variable) = value; + else { + zword addr = h_globals + 2 * (variable - 16); + SET_WORD(addr, value); + } +} + +int Processor::direct_call(zword addr) { + zword saved_zargs[8]; + int saved_zargc; + int i; + + // Calls to address 0 return false + if (addr == 0) + return 0; + + // Save operands and operand count + for (i = 0; i < 8; i++) + saved_zargs[i] = zargs[i]; + + saved_zargc = zargc; + + // Call routine directly + call(addr, 0, 0, 2); + + // Restore operands and operand count + for (i = 0; i < 8; i++) + zargs[i] = saved_zargs[i]; + + zargc = saved_zargc; + + // Resulting value lies on top of the stack + return (short)*_sp++; +} + +void Processor::seed_random(int value) { + if (value == 0) { + // Now using random values + _randomInterval = 0; + } else if (value < 1000) { + // special seed value + _randomCtr = 0; + _randomInterval = value; + } else { + // standard seed value + _random.setSeed(value); + _randomInterval = 0; + } +} + +void Processor::__extended__() { + zbyte opcode; + zbyte specifier; + + CODE_BYTE(opcode); + CODE_BYTE(specifier); + + load_all_operands(specifier); + + if (opcode < 0x1e) // extended opcodes from 0x1e on + (*this.*ext_opcodes[opcode])(); // are reserved for future spec' +} + +void Processor::__illegal__() { + runtimeError(ERR_ILL_OPCODE); +} + +void Processor::z_catch() { + store(_save_quetzal ? _frameCount : (zword)(_fp - _stack)); +} + +void Processor::z_throw() { + if (_save_quetzal) { + if (zargs[1] > _frameCount) + runtimeError(ERR_BAD_FRAME); + + // Unwind the stack a frame at a time. + for (; _frameCount > zargs[1]; --_frameCount) + _fp = _stack + 1 + _fp[1]; + } else { + if (zargs[1] > STACK_SIZE) + runtimeError(ERR_BAD_FRAME); + + _fp = _stack + zargs[1]; + } + + ret(zargs[0]); +} + +void Processor::z_call_n() { + if (zargs[0] != 0) + call(zargs[0], zargc - 1, zargs + 1, 1); +} + +void Processor::z_call_s() { + if (zargs[0] != 0) + call(zargs[0], zargc - 1, zargs + 1, 0); + else + store(0); +} + +void Processor::z_check_arg_count() { + if (_fp == _stack + STACK_SIZE) + branch(zargs[0] == 0); + else + branch(zargs[0] <= (*_fp & 0xff)); +} + +void Processor::z_jump() { + long pc; + GET_PC(pc); + + pc += (short)zargs[0] - 2; + + if ((uint)pc >= story_size) + runtimeError(ERR_ILL_JUMP_ADDR); + + SET_PC(pc); +} + +void Processor::z_nop() { + // Do nothing +} + +void Processor::z_quit() { + _finished = 9999; +} + +void Processor::z_ret() { + ret(zargs[0]); +} + +void Processor::z_ret_popped() { + ret(*_sp++); +} + +void Processor::z_rfalse() { + ret(0); +} + +void Processor::z_rtrue() { + ret(1); +} + +void Processor::z_random() { + if ((short) zargs[0] <= 0) { + // set random seed + seed_random(- (short) zargs[0]); + store(0); + + } else { + // generate random number + zword result; + if (_randomInterval != 0) { + // ...in special mode + result = _randomCtr++; + if (_randomCtr == _randomInterval) + _randomCtr = 0; + } else { + // ...in standard mode + result = _random.getRandomNumber(0xffff); + } + + store((zword)(result % zargs[0] + 1)); + } +} + +void Processor::z_sound_effect() { + zword number = zargs[0]; + zword effect = zargs[1]; + zword volume = zargs[2]; + + if (zargc < 1) + number = 0; + if (zargc < 2) + effect = EFFECT_PLAY; + if (zargc < 3) + volume = 8; + + if (number >= 3 || number == 0) { + _soundLocked = true; + + if (_storyId == LURKING_HORROR && (number == 9 || number == 16)) { + if (effect == EFFECT_PLAY) { + next_sample = number; + next_volume = volume; + + _soundLocked = false; + + if (!_soundPlaying) + start_next_sample(); + } else { + _soundLocked = false; + } + return; + } + + _soundPlaying = false; + + switch (effect) { + + case EFFECT_PREPARE: + os_prepare_sample (number); + break; + case EFFECT_PLAY: + start_sample(number, lo (volume), hi (volume), (zargc == 4) ? zargs[3] : 0); + break; + case EFFECT_STOP: + os_stop_sample (number); + break; + case EFFECT_FINISH_WITH: + os_finish_with_sample (number); + break; + } + + _soundLocked = false; + } else { + os_beep(number); + } +} + +void Processor::z_piracy() { + branch(!_piracy); +} + +void Processor::z_save_undo(void) { + store((zword)save_undo()); +} + +void Processor::z_restore_undo(void) { + store((zword)restore_undo()); +} + +} // End of namespace Scott +} // End of namespace Gargoyle diff --git a/engines/gargoyle/frotz/processor.h b/engines/gargoyle/frotz/processor.h new file mode 100644 index 0000000000..074100abab --- /dev/null +++ b/engines/gargoyle/frotz/processor.h @@ -0,0 +1,1322 @@ +/* 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. + * + */ + +#ifndef GARGOYLE_FROTZ_PROCESSOR +#define GARGOYLE_FROTZ_PROCESSOR + +#include "gargoyle/frotz/buffer.h" +#include "gargoyle/frotz/err.h" +#include "gargoyle/frotz/mem.h" +#include "gargoyle/frotz/glk_interface.h" + +namespace Gargoyle { +namespace Frotz { + +#define CODE_BYTE(v) v = *pcp++ +#define CODE_WORD(v) v = READ_BE_UINT16(pcp += 2) +#define CODE_IDX_WORD(v,i) v = READ_BE_UINT16(pcp + i) +#define GET_PC(v) v = pcp - zmp +#define SET_PC(v) pcp = zmp + v + + +enum string_type { + LOW_STRING, ABBREVIATION, HIGH_STRING, EMBEDDED_STRING, VOCABULARY +}; + +class Processor; +typedef void (Processor::*Opcode)(); + +/** + * Zcode processor + */ +class Processor : public virtual Mem, public Errors, public GlkInterface, public UserOptions { +private: + Opcode op0_opcodes[16]; + Opcode op1_opcodes[16]; + static Opcode var_opcodes[64]; + static Opcode ext_opcodes[64]; + int _finished; + zword zargs[8]; + int zargc; + uint _randomInterval; + uint _randomCtr; + bool first_restart; + + // Stack data + zword _stack[STACK_SIZE]; + zword *_sp; + zword *_fp; + zword _frameCount; + + // Text related fields + static zchar ZSCII_TO_LATIN1[]; + zchar *_decoded, *_encoded; + int _resolution; +private: + /** + * \defgroup General support methods + * @{ + */ + + /** + * Load an operand, either a variable or a constant. + */ + void load_operand(zbyte type); + + /** + * Given the operand specifier byte, load all (up to four) operands + * for a VAR or EXT opcode. + */ + void load_all_operands(zbyte specifier); + + /** + * Call a subroutine. Save PC and FP then load new PC and initialise + * new stack frame. Note that the caller may legally provide less or + * more arguments than the function actually has. The call type "ct" + * can be 0 (z_call_s), 1 (z_call_n) or 2 (direct call). + */ + void call(zword routine, int argc, zword *args, int ct); + + /** + * Return from the current subroutine and restore the previous _stack + * frame. The result may be stored (0), thrown away (1) or pushed on + * the stack (2). In the latter case a direct call has been finished + * and we must exit the interpreter loop. + */ + void ret(zword value); + + /** + * Take a jump after an instruction based on the flag, either true or + * false. The branch can be short or long; it is encoded in one or two + * bytes respectively. When bit 7 of the first byte is set, the jump + * takes place if the flag is true; otherwise it is taken if the flag + * is false. When bit 6 of the first byte is set, the branch is short; + * otherwise it is long. The offset occupies the bottom 6 bits of the + * first byte plus all the bits in the second byte for long branches. + * Uniquely, an offset of 0 means return false, and an offset of 1 is + * return true. + */ + void branch(bool flag); + + /** + * Store an operand, either as a variable or pushed on the stack. + */ + void store(zword value); + + /* + * Call the interpreter loop directly. This is necessary when + * + * - a sound effect has been finished + * - a read instruction has timed out + * - a newline countdown has hit zero + * + * The interpreter returns the result value on the stack. + */ + int direct_call(zword addr); + + /** + * Set the seed value for the random number generator. + */ + void seed_random(int value); + + /**@}*/ + + /** + * \defgroup Input support methods + * @{ + */ + + /** + * Check if the given key is an input terminator. + */ + bool is_terminator(zchar key); + + /** + * Ask the user a question; return true if the answer is yes. + */ + bool read_yes_or_no(const char *s); + + /** + * Read a string from the current input stream. + */ + void read_string(int max, zchar *buffer); + + /** + * Ask the user to type in a number and return it. + */ + int read_number(); + + /**@}*/ + + /** + * \defgroup Object support methods + * @{ + */ + + /** + * Calculate the address of an object. + */ + zword object_address(zword obj); + + /** + * Return the address of the given object's name. + */ + zword object_name(zword object); + + /** + * Calculate the start address of the property list associated with an object. + */ + zword first_property(zword obj); + + /** + * Calculate the address of the next property in a property list. + */ + zword next_property(zword prop_addr); + + /** + * Unlink an object from its parent and siblings. + */ + void unlink_object(zword object); + + /**@}*/ + + /** + * \defgroup Screen support methods + * @{ + */ + + void screen_char(zchar c); + void screen_new_line(); + void screen_word(const zchar *s); + void screen_mssg_on(); + void screen_mssg_off(); + + /**@}*/ + + /** + * \defgroup Stream support methods + * @{ + */ + + /** + * Write a single character to the scrollback buffer. + * + */ + void scrollback_char(zchar c); + + /** + * Write a string to the scrollback buffer. + */ + void scrollback_word(const zchar *s); + + /** + * Send an input line to the scrollback buffer. + */ + void scrollback_write_input(const zchar *buf, zchar key); + + /** + * Remove an input line from the scrollback buffer. + */ + void scrollback_erase_input(const zchar *buf); + + /** + * Start printing a "debugging" message. + */ + void stream_mssg_on(); + + /** + * Stop printing a "debugging" message. + */ + void stream_mssg_off(); + + /** + * Send a single character to the output stream. + */ + void stream_char(zchar c); + + /** + * Send a string of characters to the output streams. + */ + void stream_word(const zchar *s); + + /** + * Send a newline to the output streams. + */ + void stream_new_line(); + + /** + * Read a single keystroke from the current input stream. + */ + zchar stream_read_key(zword timeout, zword routine, bool hot_keys); + + /** + * Read a line of input from the current input stream. + */ + zchar stream_read_input(int max, zchar *buf, zword timeout, zword routine, + bool hot_keys, bool no_scripting); + + /**@}*/ + + /** + * \defgroup Text support methods + * @{ + */ + + /** + * Map a ZSCII character into Unicode. + */ + zchar translate_from_zscii(zbyte c); + + /** + * Convert a Unicode character to ZSCII, returning 0 on failure. + */ + zbyte unicode_to_zscii(zchar c); + + /** + * Map a Unicode character onto the ZSCII alphabet. + * + */ + zbyte translate_to_zscii(zchar c); + + /** + * Return a character from one of the three character sets. + */ + zchar alphabet(int set, int index); + + /** + * Find the number of bytes used for dictionary resolution. + */ + void find_resolution(); + + /** + * Copy a ZSCII string from the memory to the global "decoded" string. + */ + void load_string(zword addr, zword length); + + /** + * Encode the Unicode text in the global "decoded" string then write + * the result to the global "encoded" array. (This is used to look up + * words in the dictionary.) Up to V3 the vocabulary resolution is + * two, from V4 it is three, and from V9 it is any number of words. + * Because each word contains three Z-characters, that makes six or + * nine Z-characters respectively. Longer words are chopped to the + * proper size, shorter words are are padded out with 5's. For word + * completion we pad with 0s and 31s, the minimum and maximum + * Z-characters. + */ + void encode_text(int padding); + + /** + * Convert _encoded text to Unicode. The _encoded text consists of 16bit + * words. Every word holds 3 Z-characters (5 bits each) plus a spare + * bit to mark the last word. The Z-characters translate to ZSCII by + * looking at the current current character set. Some select another + * character set, others refer to abbreviations. + * + * There are several different string types: + * + * LOW_STRING - from the lower 64KB (byte address) + * ABBREVIATION - from the abbreviations table (word address) + * HIGH_STRING - from the end of the memory map (packed address) + * EMBEDDED_STRING - from the instruction stream (at PC) + * VOCABULARY - from the dictionary (byte address) + * + * The last type is only used for word completion. + */ + void decode_text(string_type st, zword addr); + + /** + * Print a signed 16bit number. + */ + void print_num(zword value); + + /** + * print_object + * + * Print an object description. + * + */ + void print_object(zword object); + + /** + * Scan a dictionary searching for the given word. The first argument + * can be + * + * 0x00 - find the first word which is >= the given one + * 0x05 - find the word which exactly matches the given one + * 0x1f - find the last word which is <= the given one + * + * The return value is 0 if the search fails. + */ + zword lookup_text(int padding, zword dct); + + /** + * tokenise_text + * + * Translate a single word to a token and append it to the token + * buffer. Every token consists of the address of the dictionary + * entry, the length of the word and the offset of the word from + * the start of the text buffer. Unknown words cause empty slots + * if the flag is set (such that the text can be scanned several + * times with different dictionaries); otherwise they are zero. + * + */ + void tokenise_text(zword text, zword length, zword from, zword parse, zword dct, bool flag); + + /** + * Split an input line into words and translate the words to tokens. + */ + void tokenise_line(zword text, zword token, zword dct, bool flag); + + /** + * Scan the vocabulary to complete the last word on the input line + * (similar to "tcsh" under Unix). The return value is + * + * 2 ==> completion is impossible + * 1 ==> completion is ambiguous + * 0 ==> completion is successful + * + * The function also returns a string in its second argument. In case + * of 2, the string is empty; in case of 1, the string is the longest + * extension of the last word on the input line that is common to all + * possible completions (for instance, if the last word on the input + * is "fo" and its only possible completions are "follow" and "folly" + * then the string is "ll"); in case of 0, the string is an extension + * to the last word that results in the only possible completion. + */ + int completion(const zchar *buffer, zchar *result); + + /** + * Convert a Unicode character to lowercase. + * Taken from Zip2000 by Kevin Bracey. + */ + zchar unicode_tolower(zchar c); + + /**@}*/ +private: + /** + * \defgroup General Opcode methods + * @{ + */ + + /* + * Load and execute an extended opcode. + */ + void __extended__(); + + /* + * Exit game because an unknown opcode has been hit. + */ + void __illegal__(); + + /* + * Store the current _stack frame for later use with z_throw. + * + * no zargs used + */ + void z_catch(); + + /** + * Go back to the given _stack frame and return the given value. + * + * zargs[0] = value to return + * zargs[1] = _stack frame + */ + void z_throw(); + + /* + * Call a subroutine and discard its result. + * + * zargs[0] = packed address of subroutine + * zargs[1] = first argument (optional) + * ... + * zargs[7] = seventh argument (optional) + */ + void z_call_n(); + + /** + * Call a subroutine and store its result. + * + * zargs[0] = packed address of subroutine + * zargs[1] = first argument (optional) + * ... + * zargs[7] = seventh argument (optional) + */ + void z_call_s(); + + /** + * Branch if subroutine was called with >= n arg's. + * + * zargs[0] = number of arguments + */ + void z_check_arg_count(); + + /** + * Jump unconditionally to the given address. + * + * zargs[0] = PC relative address + */ + void z_jump(); + + /* + * No operation. + * + * no zargs used + */ + void z_nop(); + + /* + * Stop game and exit interpreter. + * + * no zargs used + */ + void z_quit(); + + /* + * Return from a subroutine with the given value. + * + * zargs[0] = value to return + */ + void z_ret(); + + /* + * Return from a subroutine with a value popped off the stack. + * + * no zargs used + */ + void z_ret_popped(); + + /* + * Return from a subroutine with false (0). + * + * no zargs used + */ + void z_rfalse(); + + /* + * Return from a subroutine with true (1). + * + * no zargs used + */ + void z_rtrue(); + + /** + * Store a random number or set the random number seed. + * + * zargs[0] = range (positive) or seed value (negative) + */ + void z_random(); + + /** + * Load / play / stop / discard a sound effect. + * + * zargs[0] = number of bleep (1 or 2) or sample + * zargs[1] = operation to perform (samples only) + * zargs[2] = repeats and volume (play sample only) + * zargs[3] = end-of-sound routine (play sample only, optional) + * + * Note: Volumes range from 1 to 8, volume 255 is the default volume. + * Repeats are stored in the high byte, 255 is infinite loop. + * + */ + void z_sound_effect(); + + /** + * Branch if the story file is a legal copy + */ + void z_piracy(); + + /** + * Save the current Z-machine state for a future undo. + * + * no zargs used + */ + void z_save_undo(); + + /** + * Restore a Z-machine state from memory. + * + * no zargs used + */ + void z_restore_undo(); + + /**@}*/ + + /** + * \defgroup Input Opcode methods + * @{ + */ + + /** + * Add or remove a menu and branch if successful. + * + * zargs[0] = number of menu + * zargs[1] = table of menu entries or 0 to remove menu + */ + void z_make_menu(); + + /** + * Read a line of input and (in V5+) store the terminating key. + * + * zargs[0] = address of text buffer + * zargs[1] = address of token buffer + * zargs[2] = timeout in tenths of a second (optional) + * zargs[3] = packed address of routine to be called on timeout + */ + void z_read(); + + /** + * Read and store a key. + * + * zargs[0] = input device (must be 1) + * zargs[1] = timeout in tenths of a second (optional) + * zargs[2] = packed address of routine to be called on timeout + */ + void z_read_char(); + + /** + * z_read_mouse, write the current mouse status into a table. + * + * zargs[0] = address of table + */ + void z_read_mouse(); + + /**@}*/ + + /** + * \defgroup Math Opcode methods + * @{ + */ + + /** + * 16 bit addition. + * + * zargs[0] = first value + * zargs[1] = second value + */ + void z_add(); + + /** + * Bitwise AND operation. + * + * zargs[0] = first value + * zargs[1] = second value + */ + void z_and(); + + /** + * Arithmetic SHIFT operation. + * + * zargs[0] = value + * zargs[1] = #positions to shift left (positive) or right + */ + void z_art_shift(); + + /** + * Signed 16bit division. + * + * zargs[0] = first value + * zargs[1] = second value + */ + void z_div(); + + /** + * B ranch if the first value equals any of the following. + * + * zargs[0] = first value + * zargs[1] = second value (optional) + * ... + * zargs[3] = fourth value (optional) + */ + void z_je(); + + /** + * Branch if the first value is greater than the second. + * + * zargs[0] = first value + * zargs[1] = second value + */ + void z_jg(); + + /** + * Branch if the first value is less than the second. + * + * zargs[0] = first value + * zargs[1] = second value + */ + void z_jl(); + + /** + * Branch if value is zero. + * + * zargs[0] = value + */ + void z_jz(); + + /** + * Logical SHIFT operation. + * + * zargs[0] = value + * zargs[1] = #positions to shift left (positive) or right (negative) + */ + void z_log_shift(); + + /* + * Remainder after signed 16bit division. + * + * zargs[0] = first value + * zargs[1] = second value + */ + void z_mod(); + + /** + * 16 bit multiplication. + * + * zargs[0] = first value + * zargs[1] = second value + */ + void z_mul(); + + /** + * Bitwise NOT operation. + * + * zargs[0] = value + */ + void z_not(); + + /** + * Bitwise OR operation. + * + * zargs[0] = first value + * zargs[1] = second value + */ + void z_or(); + + /** + * 16 bit substraction. + * + * zargs[0] = first value + * zargs[1] = second value + */ + void z_sub(); + + /** + * Branch if all the flags of a bit mask are set in a value. + * + * zargs[0] = value to be examined + * zargs[1] = bit mask + */ + void z_test(); + + /**@}*/ + + /** + * \defgroup Object Opcode methods + * @{ + */ + + /** + * Branch if the first object is inside the second. + * + * zargs[0] = first object + * zargs[1] = second object + */ + void z_jin(); + + /** + * Store the child of an object. + * + * zargs[0] = object + */ + void z_get_child(); + + /** + * Store the number of the first or next property. + * + * zargs[0] = object + * zargs[1] = address of current property (0 gets the first property) + */ + void z_get_next_prop(); + + /** + * Store the parent of an object. + * + * zargs[0] = object + */ + void z_get_parent(); + + /** + * Store the value of an object property. + * + * zargs[0] = object + * zargs[1] = number of property to be examined + */ + void z_get_prop(); + + /** + * Store the address of an object property. + * + * zargs[0] = object + * zargs[1] = number of property to be examined + */ + void z_get_prop_addr(); + + /** + * Store the length of an object property. + * + * zargs[0] = address of property to be examined + */ + void z_get_prop_len(); + + /** + * Store the sibling of an object. + * + * zargs[0] = object + */ + void z_get_sibling(); + + /** + * Make an object the first child of another object. + * + * zargs[0] = object to be moved + * zargs[1] = destination object + */ + void z_insert_obj(); + + /** + * Set the value of an object property. + * + * zargs[0] = object + * zargs[1] = number of property to set + * zargs[2] = value to set property to + */ + void z_put_prop(); + + /** + * Unlink an object from its parent and siblings. + * + * zargs[0] = object + */ + void z_remove_obj(); + + /** + * Set an object attribute. + * + * zargs[0] = object + * zargs[1] = number of attribute to set + */ + void z_set_attr(); + + /** + * Branch if an object attribute is set. + * + * zargs[0] = object + * zargs[1] = number of attribute to test + */ + void z_test_attr(); + + /** + * Clear an object attribute. + * + * zargs[0] = object + * zargs[1] = number of attribute to be cleared + */ + void z_clear_attr(); + + /**@}*/ + + /** + * \defgroup Screen Opcode methods + * @{ + */ + + /** + * Turn text buffering on/off. + * + * zargs[0] = new text buffering flag (0 or 1) + */ + void z_buffer_mode(); + + /** + * Set the screen buffering mode. + * + * zargs[0] = mode + */ + void z_buffer_screen(); + + /** + * Erase the line starting at the cursor position. + * + * zargs[0] = 1 + #units to erase (1 clears to the end of the line) + */ + void z_erase_line(); + + /** + * Erase a window or the screen to background colour. + * + * zargs[0] = window (-3 current, -2 screen, -1 screen & unsplit) + */ + void z_erase_window(); + + /** + * Write the cursor coordinates into a table. + * + * zargs[0] = address to write information to + */ + void z_get_cursor(); + + /** + * Print ASCII text in a rectangular area. + * + * zargs[0] = address of text to be printed + * zargs[1] = width of rectangular area + * zargs[2] = height of rectangular area (optional) + * zargs[3] = number of char's to skip between lines (optional) + */ + void z_print_table(); + + /** + * Set the foreground and background colours + * to specific RGB colour values. + * + * zargs[0] = foreground colour + * zargs[1] = background colour + * zargs[2] = window (-3 is the current one, optional) + */ + void z_set_true_colour(); + + /** + * Set the foreground and background colours. + * + * zargs[0] = foreground colour + * zargs[1] = background colour + * zargs[2] = window (-3 is the current one, optional) + */ + void z_set_colour(); + + /** + * Set the font for text output and store the previous font. + * + * zargs[0] = number of font or 0 to keep current font + */ + void z_set_font(); + + /** + * Set the cursor position or turn the cursor on/off. + * + * zargs[0] = y-coordinate or -2/-1 for cursor on/off + * zargs[1] = x-coordinate + * zargs[2] = window (-3 is the current one, optional) + */ + void z_set_cursor(); + + /** + * z_set_text_style, set the style for text output. + * + * zargs[0] = style flags to set or 0 to reset text style + */ + void z_set_text_style(); + + /** + * Select the current window. + * + * zargs[0] = window to be selected (-3 is the current one) + */ + void z_set_window(); + + /** + * Display the status line for V1 to V3 games. + * + * no zargs used + */ + void pad_status_line(int column); + + /** + * Display the status line for V1 to V3 games. + * + * no zargs used + */ + void z_show_status(); + + /** + * Split the screen into an upper (1) and lower (0) window. + * + * zargs[0] = height of upper window in screen units (V6) or #lines + */ + void z_split_window(); + + /**@}*/ + + /** + * \defgroup Stream Opcode methods + * @{ + */ + + /** + * Select an input stream. + * + * zargs[0] = input stream to be selected + */ + void z_input_stream(); + + /** + * Open or close an output stream. + * + * zargs[0] = stream to open (positive) or close (negative) + * zargs[1] = address to redirect output to (stream 3 only) + * zargs[2] = width of redirected output (stream 3 only, optional) + */ + void z_output_stream(); + + /** + * Re-load dynamic area, clear the stack and set the PC. + * + * no zargs used + */ + void z_restart(); + + /** + * Save [a part of] the Z-machine state to disk. + * + * zargs[0] = address of memory area to save (optional) + * zargs[1] = number of bytes to save + * zargs[2] = address of suggested file name + */ + void z_save(); + + /** + * Restore [a part of] a Z-machine state from disk + * + * zargs[0] = address of area to restore (optional) + * zargs[1] = number of bytes to restore + * zargs[2] = address of suggested file name + */ + void z_restore(); + + /** + * Check the story file integrity. + * + * no zargs used + */ + void z_verify(); + + /**@}*/ + + /** + * \defgroup Table Opcode methods + * @{ + */ + + /** + * Copy a table or fill it with zeroes. + * + * zargs[0] = address of table + * zargs[1] = destination address or 0 for fill + * zargs[2] = size of table + * + * Note: Copying is safe even when source and destination overlap; but + * if zargs[1] is negative the table _must_ be copied forwards. + */ + void z_copy_table(); + + /** + * Store a value from a table of bytes. + * + * zargs[0] = address of table + * zargs[1] = index of table entry to store + */ + void z_loadb(); + + /** + * Store a value from a table of words. + * + * zargs[0] = address of table + * zargs[1] = index of table entry to store + */ + void z_loadw(); + + /** + * Find and store the address of a target within a table. + * + * zargs[0] = target value to be searched for + * zargs[1] = address of table + * zargs[2] = number of table entries to check value against + * zargs[3] = type of table (optional, defaults to 0x82) + * + * Note: The table is a word array if bit 7 of zargs[3] is set; otherwise + * it's a byte array. The lower bits hold the address step. + */ + void z_scan_table(); + + /** + * Write a byte into a table of bytes. + * + * zargs[0] = address of table + * zargs[1] = index of table entry + * zargs[2] = value to be written + */ + void z_storeb(); + + /** + * Write a word into a table of words. + * + * zargs[0] = address of table + * zargs[1] = index of table entry + * zargs[2] = value to be written + */ + void z_storew(); + + /**@}*/ + + /** + * \defgroup Text Opcode methods + * @{ + */ + + /** + * Test if a unicode character can be printed (bit 0) and read (bit 1). + * + * zargs[0] = Unicode + */ + void z_check_unicode(); + + /** + * Encode a ZSCII string for use in a dictionary. + * + * zargs[0] = address of text buffer + * zargs[1] = length of ASCII string + * zargs[2] = offset of ASCII string within the text buffer + * zargs[3] = address to store encoded text in + * + * This is a V5+ opcode and therefore the dictionary resolution must be + * three 16bit words. + */ + void z_encode_text(); + + /** + * Print a new line. + * + * no zargs used + * + */ + void z_new_line(); + + /** + * Print a string embedded in the instruction stream. + * + * no zargs used + */ + void z_print(); + + /** + * Print a string from the lower 64KB. + * + * zargs[0] = address of string to print + */ + void z_print_addr(); + + /** + * Print a single ZSCII character. + * + * zargs[0] = ZSCII character to be printed + */ + void z_print_char(); + + /** + * Print a formatted table. + * + * zargs[0] = address of formatted table to be printed + */ + void z_print_form(); + + /** + * Print a signed number. + * + * zargs[0] = number to print + */ + void z_print_num(); + + /** + * Print an object description. + * + * zargs[0] = number of object to be printed + */ + void z_print_obj(); + + /** + * Print the string at the given packed address. + * + * zargs[0] = packed address of string to be printed + */ + void z_print_paddr(); + + /* + * Print the string at PC, print newline then return true. + * + * no zargs used + */ + void z_print_ret(); + + /** + * Print a string of ASCII characters. + */ + void print_string(const char *s); + + /** + * Print unicode character + * + * zargs[0] = Unicode + */ + void z_print_unicode(); + + /** + * Make a lexical analysis of a ZSCII string. + * + * zargs[0] = address of string to analyze + * zargs[1] = address of token buffer + * zargs[2] = address of dictionary (optional) + * zargs[3] = set when unknown words cause empty slots (optional) + */ + void z_tokenise(); + + /**@}*/ + + /** + * \defgroup Variable Opcode methods + * @{ + */ + + /** + * Decrement a variable. + * + * zargs[0] = variable to decrement + */ + void z_dec(); + + /** + * Decrement a variable and branch if now less than value. + * + * zargs[0] = variable to decrement + * zargs[1] = value to check variable against + */ + void z_dec_chk(); + + /** + * Increment a variable. + * + * zargs[0] = variable to increment + */ + void z_inc(); + + /** + * Increment a variable and branch if now greater than value. + * + * zargs[0] = variable to increment + * zargs[1] = value to check variable against + */ + void z_inc_chk(); + + /** + * Store the value of a variable. + * + * zargs[0] = variable to store + */ + void z_load(); + + /** + * Pop a value off the game stack and discard it. + * + * no zargs used + */ + void z_pop(); + + /** + * Pop n values off the game or user stack and discard them. + * + * zargs[0] = number of values to discard + * zargs[1] = address of user stack (optional) + */ + void z_pop_stack(); + + /** + * Pop a value off... + * + * a) ...the game or a user stack and store it (V6) + * + * zargs[0] = address of user stack (optional) + * + * b) ...the game stack and write it to a variable (other than V6) + * + * zargs[0] = variable to write value to + */ + void z_pull(); + + /** + * Push a value onto the game stack. + * + * zargs[0] = value to push onto the stack + */ + void z_push(); + + /** + * Push a value onto a user stack then branch if successful. + * + * zargs[0] = value to push onto the stack + * zargs[1] = address of user stack + */ + void z_push_stack(); + + /** + * Write a value to a variable. + * + * zargs[0] = variable to be written to + * zargs[1] = value to write + */ + void z_store(); + + /**@}*/ +protected: + /** + * Get the PC. Is implemented by the Processor class, which derives from Errors + */ + virtual zword getPC() const { return pcp - zmp; } +public: + /** + * Constructor + */ + Processor(OSystem *syst, const GargoyleGameDescription *gameDesc); + + /** + * Initialization + */ + virtual void initialize() override; + + /** + * Z-code interpreter main loop + */ + void interpret(); +}; + +} // End of namespace Frotz +} // End of namespace Gargoyle + +#endif diff --git a/engines/gargoyle/frotz/processor_input.cpp b/engines/gargoyle/frotz/processor_input.cpp new file mode 100644 index 0000000000..e7f92ab607 --- /dev/null +++ b/engines/gargoyle/frotz/processor_input.cpp @@ -0,0 +1,207 @@ +/* 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 "gargoyle/frotz/processor.h" + +namespace Gargoyle { +namespace Frotz { + +// TODO: Implement method stubs +static zchar stream_read_key(zword, zword, bool) { return 0; } +static zchar stream_read_input(int, zchar *, zword, zword, bool, bool) { return 0;} +static void storeb(zword, zchar) {} +static void storew(zword, zword) {} +static void save_undo() {} +static zword os_read_mouse() { return 0; } + + +#define INPUT_BUFFER_SIZE 200 + +void Processor::z_make_menu() { + // This opcode was only used for the Macintosh version of Journey. + // It controls menus with numbers greater than 2 (menus 0, 1 and 2 + // are system menus). + branch (false); +} + +bool Processor::read_yes_or_no(const char *s) { + zchar key; + + print_string(s); + print_string("? (y/n) >"); + + key = stream_read_key(0, 0, false); + + if (key == 'y' || key == 'Y') { + print_string("y\n"); + return true; + } else { + print_string("n\n"); + return false; + } +} + +void Processor::read_string(int max, zchar *buffer) { + zchar key; + + buffer[0] = 0; + + do { + key = stream_read_input(max, buffer, 0, 0, false, false); + } while (key != ZC_RETURN); +} + +int Processor::read_number() { + zchar buffer[6]; + int value = 0; + int i; + + read_string(5, buffer); + + for (i = 0; buffer[i] != 0; i++) + if (buffer[i] >= '0' && buffer[i] <= '9') + value = 10 * value + buffer[i] - '0'; + + return value; + +} + +void Processor::z_read() { + zchar buffer[INPUT_BUFFER_SIZE]; + zword addr; + zchar key; + zbyte max, size; + zbyte c; + int i; + + // Supply default arguments + if (zargc < 3) + zargs[2] = 0; + + // Get maximum input size + addr = zargs[0]; + + LOW_BYTE(addr, max); + + if (h_version <= V4) + max--; + + if (max >= INPUT_BUFFER_SIZE) + max = INPUT_BUFFER_SIZE - 1; + + // Get initial input size + if (h_version >= V5) { + addr++; + LOW_BYTE(addr, size); + } else { + size = 0; + } + + // Copy initial input to local buffer + for (i = 0; i < size; i++) { + addr++; + LOW_BYTE(addr, c); + buffer[i] = translate_from_zscii(c); + } + buffer[i] = 0; + + // Draw status line for V1 to V3 games + if (h_version <= V3) + z_show_status(); + + // Read input from current input stream + key = stream_read_input( + max, buffer, // buffer and size + zargs[2], // timeout value + zargs[3], // timeout routine + false, // enable hot keys + h_version == V6 // no script in V6 + ); + + if (key == ZC_BAD) + return; + + // Perform save_undo for V1 to V4 games + if (h_version <= V4) + save_undo(); + + // Copy local buffer back to dynamic memory + for (i = 0; buffer[i] != 0; i++) { + if (key == ZC_RETURN) { + buffer[i] = unicode_tolower (buffer[i]); + } + + storeb((zword) (zargs[0] + ((h_version <= V4) ? 1 : 2) + i), translate_to_zscii (buffer[i])); + } + + // Add null character (V1-V4) or write input length into 2nd byte + if (h_version <= V4) + storeb((zword) (zargs[0] + 1 + i), 0); + else + storeb((zword) (zargs[0] + 1), i); + + // Tokenise line if a token buffer is present + if (key == ZC_RETURN && zargs[1] != 0) + tokenise_line (zargs[0], zargs[1], 0, false); + + // Store key + if (h_version >= V5) + store(translate_to_zscii(key)); +} + +void Processor::z_read_char() { + zchar key; + + // Supply default arguments + if (zargc < 2) + zargs[1] = 0; + + // Read input from the current input stream + key = stream_read_key( + zargs[1], // timeout value + zargs[2], // timeout routine + false // enable hot keys + ); + + if (key == ZC_BAD) + return; + + // Store key + store (translate_to_zscii (key)); +} + +void Processor::z_read_mouse(){ + zword btn; + + // Read the mouse position, the last menu click and which buttons are down + btn = os_read_mouse(); + hx_mouse_y = mouse_y; + hx_mouse_x = mouse_x; + + storew((zword) (zargs[0] + 0), hx_mouse_y); + storew((zword) (zargs[0] + 2), hx_mouse_x); + storew((zword) (zargs[0] + 4), btn); // mouse button bits + storew((zword) (zargs[0] + 6), menu_selected); // menu selection +} + +} // End of namespace Scott +} // End of namespace Gargoyle diff --git a/engines/gargoyle/frotz/processor_maths.cpp b/engines/gargoyle/frotz/processor_maths.cpp new file mode 100644 index 0000000000..e64dd55a1a --- /dev/null +++ b/engines/gargoyle/frotz/processor_maths.cpp @@ -0,0 +1,105 @@ +/* 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 "gargoyle/frotz/processor.h" + +namespace Gargoyle { +namespace Frotz { + +void Processor::z_add() { + store((zword)((short)zargs[0] + (short)zargs[1])); +} + +void Processor::z_and() { + store((zword)(zargs[0] & zargs[1])); +} + +void Processor::z_art_shift() { + if ((short)zargs[1] > 0) + store((zword)((short)zargs[0] << (short)zargs[1])); + else + store((zword)((short)zargs[0] >> - (short)zargs[1])); +} + +void Processor::z_div() { + if (zargs[1] == 0) + runtimeError(ERR_DIV_ZERO); + + store((zword)((short)zargs[0] / (short)zargs[1])); +} + +void Processor::z_je() { + branch( + zargc > 1 && (zargs[0] == zargs[1] || ( + zargc > 2 && (zargs[0] == zargs[2] || ( + zargc > 3 && (zargs[0] == zargs[3]))))) + ); +} + +void Processor::z_jg() { + branch((short)zargs[0] > (short)zargs[1]); +} + +void Processor::z_jl() { + branch((short)zargs[0] < (short)zargs[1]); +} + +void Processor::z_jz() { + branch((short)zargs[0] == 0); +} + +void Processor::z_log_shift() { + if ((short)zargs[1] > 0) + store((zword)(zargs[0] << (short)zargs[1])); + else + store((zword)(zargs[0] >> - (short)zargs[1])); +} + +void Processor::z_mod() { + if (zargs[1] == 0) + runtimeError(ERR_DIV_ZERO); + + store((zword)((short)zargs[0] % (short)zargs[1])); +} + +void Processor::z_mul() { + store((zword)((short)zargs[0] * (short)zargs[1])); +} + +void Processor::z_not() { + store((zword)~zargs[0]); +} + +void Processor::z_or() { + store((zword)(zargs[0] | zargs[1])); +} + +void Processor::z_sub() { + store((zword)((short)zargs[0] - (short)zargs[1])); +} + +void Processor::z_test() { + branch((zargs[0] & zargs[1]) == zargs[1]); +} + +} // End of namespace Scott +} // End of namespace Gargoyle diff --git a/engines/gargoyle/frotz/processor_objects.cpp b/engines/gargoyle/frotz/processor_objects.cpp new file mode 100644 index 0000000000..3d2b17162d --- /dev/null +++ b/engines/gargoyle/frotz/processor_objects.cpp @@ -0,0 +1,735 @@ +/* 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 "gargoyle/frotz/processor.h" + +namespace Gargoyle { +namespace Frotz { + +// TODO: Method stubs to implement +static void new_line() {} + +#define MAX_OBJECT 2000 + +enum O1 { + O1_PARENT = 4, + O1_SIBLING = 5, + O1_CHILD = 6, + O1_PROPERTY_OFFSET = 7, + O1_SIZE = 9 +}; + +enum O4 { + O4_PARENT = 6, + O4_SIBLING = 8, + O4_CHILD = 10, + O4_PROPERTY_OFFSET = 12, + O4_SIZE = 14 +}; + +zword Processor::object_address(zword obj) { + // Check object number + if (obj > ((h_version <= V3) ? 255 : MAX_OBJECT)) { + print_string("@Attempt to address illegal object "); + print_num(obj); + print_string(". This is normally fatal."); + new_line(); + runtimeError(ERR_ILL_OBJ); + } + + // Return object address + if (h_version <= V3) + return h_objects + ((obj - 1) * O1_SIZE + 62); + else + return h_objects + ((obj - 1) * O4_SIZE + 126); +} + +zword Processor::object_name(zword object) { + zword obj_addr; + zword name_addr; + + obj_addr = object_address(object); + + // The object name address is found at the start of the properties + if (h_version <= V3) + obj_addr += O1_PROPERTY_OFFSET; + else + obj_addr += O4_PROPERTY_OFFSET; + + LOW_WORD(obj_addr, name_addr); + + return name_addr; +} + +zword Processor::first_property(zword obj) { + zword prop_addr; + zbyte size; + + // Fetch address of object name + prop_addr = object_name (obj); + + // Get length of object name + LOW_BYTE(prop_addr, size); + + // Add name length to pointer + return prop_addr + 1 + 2 * size; +} + +zword Processor::next_property(zword prop_addr) { + zbyte value; + + // Load the current property id + LOW_BYTE(prop_addr, value); + prop_addr++; + + // Calculate the length of this property + if (h_version <= V3) + value >>= 5; + else if (!(value & 0x80)) + value >>= 6; + else { + LOW_BYTE(prop_addr, value); + value &= 0x3f; + + if (value == 0) + // demanded by Spec 1.0 + value = 64; + } + + // Add property length to current property pointer + return prop_addr + value + 1; +} + +void Processor::unlink_object(zword object) { + zword obj_addr; + zword parent_addr; + zword sibling_addr; + + if (object == 0) { + runtimeError(ERR_REMOVE_OBJECT_0); + return; + } + + obj_addr = object_address(object); + + if (h_version <= V3) { + + zbyte parent; + zbyte younger_sibling; + zbyte older_sibling; + zbyte zero = 0; + + // Get parent of object, and return if no parent + obj_addr += O1_PARENT; + LOW_BYTE(obj_addr, parent); + if (!parent) + return; + + // Get (older) sibling of object and set both parent and sibling pointers to 0 + SET_BYTE(obj_addr, zero); + obj_addr += O1_SIBLING - O1_PARENT; + LOW_BYTE(obj_addr, older_sibling); + SET_BYTE(obj_addr, zero); + + // Get first child of parent (the youngest sibling of the object) + parent_addr = object_address(parent) + O1_CHILD; + LOW_BYTE(parent_addr, younger_sibling); + + // Remove object from the list of siblings + if (younger_sibling == object) + SET_BYTE(parent_addr, older_sibling); + else { + do { + sibling_addr = object_address(younger_sibling) + O1_SIBLING; + LOW_BYTE(sibling_addr, younger_sibling); + } while (younger_sibling != object); + SET_BYTE(sibling_addr, older_sibling); + } + } else { + zword parent; + zword younger_sibling; + zword older_sibling; + zword zero = 0; + + // Get parent of object, and return if no parent + obj_addr += O4_PARENT; + LOW_WORD(obj_addr, parent); + if (!parent) + return; + + // Get (older) sibling of object and set both parent and sibling pointers to 0 + SET_WORD(obj_addr, zero); + obj_addr += O4_SIBLING - O4_PARENT; + LOW_WORD(obj_addr, older_sibling); + SET_WORD(obj_addr, zero); + + // Get first child of parent (the youngest sibling of the object) + parent_addr = object_address(parent) + O4_CHILD; + LOW_WORD(parent_addr, younger_sibling); + + // Remove object from the list of siblings + if (younger_sibling == object) { + SET_WORD(parent_addr, older_sibling); + } else { + do { + sibling_addr = object_address(younger_sibling) + O4_SIBLING; + LOW_WORD(sibling_addr, younger_sibling); + } while (younger_sibling != object); + SET_WORD(sibling_addr, older_sibling); + } + } +} + +void Processor::z_clear_attr() { + zword obj_addr; + zbyte value; + + if (_storyId == SHERLOCK) + if (zargs[1] == 48) + return; + + if (zargs[1] > ((h_version <= V3) ? 31 : 47)) + runtimeError(ERR_ILL_ATTR); + + // If we are monitoring attribute assignment display a short note + if (_attribute_assignment) { + stream_mssg_on(); + print_string("@clear_attr "); + print_object(zargs[0]); + print_string(" "); + print_num(zargs[1]); + stream_mssg_off(); + } + + if (zargs[0] == 0) { + runtimeError(ERR_CLEAR_ATTR_0); + return; + } + + // Get attribute address + obj_addr = object_address(zargs[0]) + zargs[1] / 8; + + // Clear attribute bit + LOW_BYTE(obj_addr, value); + value &= ~(0x80 >> (zargs[1] & 7)); + SET_BYTE(obj_addr, value); +} + +void Processor::z_jin() { + zword obj_addr; + + // If we are monitoring object locating display a short note + if (_object_locating) { + stream_mssg_on(); + print_string("@jin "); + print_object(zargs[0]); + print_string(" "); + print_object(zargs[1]); + stream_mssg_off(); + } + + if (zargs[0] == 0) { + runtimeError(ERR_JIN_0); + branch(0 == zargs[1]); + return; + } + + obj_addr = object_address(zargs[0]); + + if (h_version <= V3) { + zbyte parent; + + // Get parent id from object + obj_addr += O1_PARENT; + LOW_BYTE(obj_addr, parent); + + // Branch if the parent is obj2 + branch(parent == zargs[1]); + + } else { + zword parent; + + // Get parent id from object + obj_addr += O4_PARENT; + LOW_WORD(obj_addr, parent); + + // Branch if the parent is obj2 + branch(parent == zargs[1]); + } +} + +void Processor::z_get_child() { + zword obj_addr; + + // If we are monitoring object locating display a short note + if (_object_locating) { + stream_mssg_on(); + print_string("@get_child "); + print_object(zargs[0]); + stream_mssg_off(); + } + + if (zargs[0] == 0) { + runtimeError(ERR_GET_CHILD_0); + store(0); + branch(false); + return; + } + + obj_addr = object_address(zargs[0]); + + if (h_version <= V3) { + zbyte child; + + // Get child id from object + obj_addr += O1_CHILD; + LOW_BYTE(obj_addr, child); + + // Store child id and branch + store(child); + branch(child); + } else { + zword child; + + // Get child id from object + obj_addr += O4_CHILD; + LOW_WORD(obj_addr, child); + + // Store child id and branch + store(child); + branch(child); + } +} + +void Processor::z_get_next_prop() { + zword prop_addr; + zbyte value; + zbyte mask; + + if (zargs[0] == 0) { + runtimeError(ERR_GET_NEXT_PROP_0); + store(0); + return; + } + + // Property id is in bottom five (six) bits + mask = (h_version <= V3) ? 0x1f : 0x3f; + + // Load address of first property + prop_addr = first_property(zargs[0]); + + if (zargs[1] != 0) { + // Scan down the property list + do { + LOW_BYTE(prop_addr, value); + prop_addr = next_property(prop_addr); + } while ((value & mask) > zargs[1]); + + // Exit if the property does not exist + if ((value & mask) != zargs[1]) + runtimeError(ERR_NO_PROP); + } + + // Return the property id + LOW_BYTE(prop_addr, value); + store((zword) (value & mask)); +} + +void Processor::z_get_parent() { + zword obj_addr; + + // If we are monitoring object locating display a short note + if (_object_locating) { + stream_mssg_on(); + print_string("@get_parent "); + print_object(zargs[0]); + stream_mssg_off(); + } + + if (zargs[0] == 0) { + runtimeError(ERR_GET_PARENT_0); + store(0); + return; + } + + obj_addr = object_address(zargs[0]); + + if (h_version <= V3) { + zbyte parent; + + // Get parent id from object + obj_addr += O1_PARENT; + LOW_BYTE(obj_addr, parent); + + // Store parent + store(parent); + + } else { + zword parent; + + // Get parent id from object + obj_addr += O4_PARENT; + LOW_WORD(obj_addr, parent); + + // Store parent + store(parent); + } +} + +void Processor::z_get_prop() { + zword prop_addr; + zword wprop_val; + zbyte bprop_val; + zbyte value; + zbyte mask; + + if (zargs[0] == 0) { + runtimeError(ERR_GET_PROP_0); + store(0); + return; + } + + // Property id is in bottom five (six) bits + mask = (h_version <= V3) ? 0x1f : 0x3f; + + // Load address of first property + prop_addr = first_property(zargs[0]); + + // Scan down the property list + for (;;) { + LOW_BYTE(prop_addr, value); + if ((value & mask) <= zargs[1]) + break; + prop_addr = next_property(prop_addr); + } + + if ((value & mask) == zargs[1]) { + // property found + + // Load property(byte or word sized) + prop_addr++; + + if ((h_version <= V3 && !(value & 0xe0)) || (h_version >= V4 && !(value & 0xc0))) { + LOW_BYTE(prop_addr, bprop_val); + wprop_val = bprop_val; + } else { + LOW_WORD(prop_addr, wprop_val); + } + } else { + // property not found + + // Load default value + prop_addr = h_objects + 2 * (zargs[1] - 1); + LOW_WORD(prop_addr, wprop_val); + } + + // Store the property value + store(wprop_val); +} + +void Processor::z_get_prop_addr() { + zword prop_addr; + zbyte value; + zbyte mask; + + if (zargs[0] == 0) { + runtimeError(ERR_GET_PROP_ADDR_0); + store(0); + return; + } + + if (_storyId == BEYOND_ZORK) + if (zargs[0] > MAX_OBJECT) + { store(0); return; } + + // Property id is in bottom five (six) bits + mask = (h_version <= V3) ? 0x1f : 0x3f; + + // Load address of first property + prop_addr = first_property(zargs[0]); + + // Scan down the property list + for (;;) { + LOW_BYTE(prop_addr, value); + if ((value & mask) <= zargs[1]) + break; + prop_addr = next_property(prop_addr); + } + + // Calculate the property address or return zero + if ((value & mask) == zargs[1]) { + + if (h_version >= V4 && (value & 0x80)) + prop_addr++; + store((zword) (prop_addr + 1)); + + } else { + store(0); + } +} + +void Processor::z_get_prop_len() { + zword addr; + zbyte value; + + // Back up the property pointer to the property id + addr = zargs[0] - 1; + LOW_BYTE(addr, value); + + // Calculate length of property + if (h_version <= V3) + value = (value >> 5) + 1; + else if (!(value & 0x80)) + value = (value >> 6) + 1; + else { + value &= 0x3f; + + if (value == 0) + value = 64; // demanded by Spec 1.0 + } + + // Store length of property + store(value); +} + +void Processor::z_get_sibling() { + zword obj_addr; + + if (zargs[0] == 0) { + runtimeError(ERR_GET_SIBLING_0); + store(0); + branch(false); + return; + } + + obj_addr = object_address(zargs[0]); + + if (h_version <= V3) { + zbyte sibling; + + // Get sibling id from object + obj_addr += O1_SIBLING; + LOW_BYTE(obj_addr, sibling); + + // Store sibling and branch + store(sibling); + branch(sibling); + + } else { + zword sibling; + + // Get sibling id from object + obj_addr += O4_SIBLING; + LOW_WORD(obj_addr, sibling); + + // Store sibling and branch + store(sibling); + branch(sibling); + } +} + +void Processor::z_insert_obj() { + zword obj1 = zargs[0]; + zword obj2 = zargs[1]; + zword obj1_addr; + zword obj2_addr; + + // If we are monitoring object movements display a short note + if (_object_movement) { + stream_mssg_on(); + print_string("@move_obj "); + print_object(obj1); + print_string(" "); + print_object(obj2); + stream_mssg_off(); + } + + if (obj1 == 0) { + runtimeError(ERR_MOVE_OBJECT_0); + return; + } + + if (obj2 == 0) { + runtimeError(ERR_MOVE_OBJECT_TO_0); + return; + } + + // Get addresses of both objects + obj1_addr = object_address(obj1); + obj2_addr = object_address(obj2); + + // Remove object 1 from current parent + unlink_object(obj1); + + // Make object 1 first child of object 2 + if (h_version <= V3) { + zbyte child; + + obj1_addr += O1_PARENT; + SET_BYTE(obj1_addr, obj2); + obj2_addr += O1_CHILD; + LOW_BYTE(obj2_addr, child); + SET_BYTE(obj2_addr, obj1); + obj1_addr += O1_SIBLING - O1_PARENT; + SET_BYTE(obj1_addr, child); + + } else { + zword child; + + obj1_addr += O4_PARENT; + SET_WORD(obj1_addr, obj2); + obj2_addr += O4_CHILD; + LOW_WORD(obj2_addr, child); + SET_WORD(obj2_addr, obj1); + obj1_addr += O4_SIBLING - O4_PARENT; + SET_WORD(obj1_addr, child); + } +} + +void Processor::z_put_prop() { + zword prop_addr; + zword value; + zbyte mask; + + if (zargs[0] == 0) { + runtimeError(ERR_PUT_PROP_0); + return; + } + + // Property id is in bottom five or six bits + mask = (h_version <= V3) ? 0x1f : 0x3f; + + // Load address of first property + prop_addr = first_property(zargs[0]); + + // Scan down the property list + for (;;) { + LOW_BYTE(prop_addr, value); + if ((value & mask) <= zargs[1]) + break; + + prop_addr = next_property(prop_addr); + } + + // Exit if the property does not exist + if ((value & mask) != zargs[1]) + runtimeError(ERR_NO_PROP); + + // Store the new property value (byte or word sized) + prop_addr++; + + if ((h_version <= V3 && !(value & 0xe0)) || (h_version >= V4 && !(value & 0xc0))) { + zbyte v = zargs[2]; + SET_BYTE(prop_addr, v); + } else { + zword v = zargs[2]; + SET_WORD(prop_addr, v); + } +} + +void Processor::z_remove_obj() { + // If we are monitoring object movements display a short note + if (_object_movement) { + stream_mssg_on(); + print_string("@remove_obj "); + print_object(zargs[0]); + stream_mssg_off(); + } + + // Call unlink_object to do the job + unlink_object(zargs[0]); +} + +void Processor::z_set_attr() { + zword obj_addr; + zbyte value; + + if (_storyId == SHERLOCK) + if (zargs[1] == 48) + return; + + if (zargs[1] > ((h_version <= V3) ? 31 : 47)) + runtimeError(ERR_ILL_ATTR); + + // If we are monitoring attribute assignment display a short note + if (_attribute_assignment) { + stream_mssg_on(); + print_string("@set_attr "); + print_object(zargs[0]); + print_string(" "); + print_num(zargs[1]); + stream_mssg_off(); + } + + if (zargs[0] == 0) { + runtimeError(ERR_SET_ATTR_0); + return; + } + + // Get attribute address + obj_addr = object_address(zargs[0]) + zargs[1] / 8; + + // Load attribute byte + LOW_BYTE(obj_addr, value); + + // Set attribute bit + value |= 0x80 >> (zargs[1] & 7); + + // Store attribute byte + SET_BYTE(obj_addr, value); +} + +void Processor::z_test_attr() { + zword obj_addr; + zbyte value; + + if (zargs[1] > ((h_version <= V3) ? 31 : 47)) + runtimeError(ERR_ILL_ATTR); + + // If we are monitoring attribute testing display a short note + if (_attribute_testing) { + stream_mssg_on(); + print_string("@test_attr "); + print_object(zargs[0]); + print_string(" "); + print_num(zargs[1]); + stream_mssg_off(); + } + + if (zargs[0] == 0) { + runtimeError(ERR_TEST_ATTR_0); + branch(false); + return; + } + + // Get attribute address + obj_addr = object_address(zargs[0]) + zargs[1] / 8; + + // Load attribute byte + LOW_BYTE(obj_addr, value); + + // Test attribute + branch(value & (0x80 >> (zargs[1] & 7))); +} + +} // End of namespace Scott +} // End of namespace Gargoyle diff --git a/engines/gargoyle/frotz/processor_screen.cpp b/engines/gargoyle/frotz/processor_screen.cpp new file mode 100644 index 0000000000..5b3b8cb379 --- /dev/null +++ b/engines/gargoyle/frotz/processor_screen.cpp @@ -0,0 +1,455 @@ +/* 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 "gargoyle/frotz/processor.h" + +namespace Gargoyle { +namespace Frotz { + +// TODO: Method stubs to implement +static void storew(zword, zword) {} +static void print_char(zchar) {} + + +void Processor::screen_char(zchar c) { + // TODO +} + +void Processor::screen_new_line() { + // TODO +} + +void Processor::screen_word(const zchar *s) { + // TODO +} + +void Processor::screen_mssg_on() { + // TODO +} + +void Processor::screen_mssg_off() { + // TODO +} + + +void Processor::z_buffer_mode() { +} + +void Processor::z_buffer_screen() { + store(0); +} + +void Processor::z_erase_line() { + int i; + + if (gos_upper && gos_curwin == gos_upper) { + for (i = 0; i < h_screen_cols + 1 - curx; i++) + glk_put_char(' '); + glk_window_move_cursor(gos_curwin, curx - 1, cury - 1); + } +} + +void Processor::z_erase_window() { + short w = zargs[0]; + if (w == -2) + { + if (gos_upper) { + glk_set_window(gos_upper); +#ifdef GARGLK + garglk_set_zcolors(curr_fg, curr_bg); +#endif /* GARGLK */ + glk_window_clear(gos_upper); + glk_set_window(gos_curwin); + } + glk_window_clear(gos_lower); + } + if (w == -1) + { + if (gos_upper) { + glk_set_window(gos_upper); +#ifdef GARGLK + garglk_set_zcolors(curr_fg, curr_bg); +#endif /* GARGLK */ + glk_window_clear(gos_upper); + } + glk_window_clear(gos_lower); + split_window(0); + glk_set_window(gos_lower); + gos_curwin = gos_lower; + } + if (w == 0) + glk_window_clear(gos_lower); + if (w == 1 && gos_upper) + glk_window_clear(gos_upper); +} + +void Processor::z_get_cursor() { + storew((zword) (zargs[0] + 0), cury); + storew((zword) (zargs[0] + 2), curx); +} + +void Processor::z_print_table() { + zword addr = zargs[0]; + zword x; + int i, j; + + // Supply default arguments + if (zargc < 3) + zargs[2] = 1; + if (zargc < 4) + zargs[3] = 0; + + // Write text in width x height rectangle + x = curx; + + for (i = 0; i < zargs[2]; i++) { + if (i != 0) { + cury += 1; + curx = x; + } + + for (j = 0; j < zargs[1]; j++) { + + zbyte c; + + LOW_BYTE(addr, c); + addr++; + + print_char(c); + } + + addr += zargs[3]; + } +} + +#define zB(i) ((((i >> 10) & 0x1F) << 3) | (((i >> 10) & 0x1F) >> 2)) +#define zG(i) ((((i >> 5) & 0x1F) << 3) | (((i >> 5) & 0x1F) >> 2)) +#define zR(i) ((((i ) & 0x1F) << 3) | (((i ) & 0x1F) >> 2)) + +#define zRGB(i) (zR(i) << 16 | zG(i) << 8 | zB(i)) + +void Processor::z_set_true_colour() { + int zfore = zargs[0]; + int zback = zargs[1]; + + if (!(zfore < 0)) + zfore = zRGB(zargs[0]); + + if (!(zback < 0)) + zback = zRGB(zargs[1]); + +#ifdef GARGLK + garglk_set_zcolors(zfore, zback); +#endif /* GARGLK */ + + curr_fg = zfore; + curr_bg = zback; +} + +static const int zcolor_map[] = { + -2, ///< 0 = current + -1, ///< 1 = default + 0x0000, ///< 2 = black + 0x001D, ///< 3 = red + 0x0340, ///< 4 = green + 0x03BD, ///< 5 = yellow + 0x59A0, ///< 6 = blue + 0x7C1F, ///< 7 = magenta + 0x77A0, ///< 8 = cyan + 0x7FFF, ///< 9 = white + 0x5AD6, ///< 10 = light grey + 0x4631, ///< 11 = medium grey + 0x2D6B, ///< 12 = dark grey +}; + +#define zcolor_NUMCOLORS (13) + +void Processor::z_set_colour() { + int zfore = zargs[0]; + int zback = zargs[1]; + + switch (zfore) { + case -1: + zfore = -3; + break; + + case 0: + case 1: + zfore = zcolor_map[zfore]; + break; + + default: + if (zfore < zcolor_NUMCOLORS) + zfore = zRGB(zcolor_map[zfore]); + break; + } + + switch (zback) { + case -1: + zback = -3; + + case 0: + case 1: + zback = zcolor_map[zback]; + break; + + default: + if (zback < zcolor_NUMCOLORS) + zback = zRGB(zcolor_map[zback]); + break; + } + +#ifdef GARGLK + garglk_set_zcolors(zfore, zback); +#endif /* GARGLK */ + + curr_fg = zfore; + curr_bg = zback; +} + +void Processor::z_set_font() { + zword font = zargs[0]; + + switch (font) { + case 0: + // previous font + temp_font = curr_font; + curr_font = prev_font; + prev_font = temp_font; + zargs[0] = 0xf000; // tickle tickle! + z_set_text_style(); + store (curr_font); + break; + + case 1: /* normal font */ + prev_font = curr_font; + curr_font = 1; + zargs[0] = 0xf000; // tickle tickle! + z_set_text_style(); + store (prev_font); + break; + + case 4: /* fixed-pitch font*/ + prev_font = curr_font; + curr_font = 4; + zargs[0] = 0xf000; // tickle tickle! + z_set_text_style(); + store (prev_font); + break; + + case 2: // picture font, undefined per 1.1 + case 3: // character graphics font + default: // unavailable + store (0); + break; + } +} + +void Processor::z_set_cursor() { + cury = zargs[0]; + curx = zargs[1]; + + if (gos_upper) { + if (cury > mach_status_ht) { + mach_status_ht = cury; + reset_status_ht(); + } + + glk_window_move_cursor(gos_upper, curx - 1, cury - 1); + } +} + +void Processor::z_set_text_style() { + int style; + + if (zargs[0] == 0) + curstyle = 0; + else if (zargs[0] != 0xf000) /* not tickle time */ + curstyle |= zargs[0]; + + if (h_flags & FIXED_FONT_FLAG || curr_font == 4) + style = curstyle | FIXED_WIDTH_STYLE; + else + style = curstyle; + + if (gos_linepending && gos_curwin == gos_linewin) + return; + + if (style & REVERSE_STYLE) { +#ifdef GARGLK + garglk_set_reversevideo(true); +#endif /* GARGLK */ + } + + if (style & FIXED_WIDTH_STYLE) { + if (style & BOLDFACE_STYLE && style & EMPHASIS_STYLE) + glk_set_style(style_BlockQuote); // monoz + else if (style & EMPHASIS_STYLE) + glk_set_style(style_Alert); // monoi + else if (style & BOLDFACE_STYLE) + glk_set_style(style_Subheader); // monob + else + glk_set_style(style_Preformatted); // monor + } else { + if (style & BOLDFACE_STYLE && style & EMPHASIS_STYLE) + glk_set_style(style_Note); // propz + else if (style & EMPHASIS_STYLE) + glk_set_style(style_Emphasized); // propi + else if (style & BOLDFACE_STYLE) + glk_set_style(style_Header); // propb + else + glk_set_style(style_Normal); // propr + } + + if (curstyle == 0) { +#ifdef GARGLK + garglk_set_reversevideo(false); +#endif /* GARGLK */ + } +} + +void Processor::z_set_window() { + int win = zargs[0]; + + if (win == 0) { + glk_set_window(gos_lower); + gos_curwin = gos_lower; + } else { + if (gos_upper) + glk_set_window(gos_upper); + gos_curwin = gos_upper; + } + + if (win == 0) + enable_scripting = true; + else + enable_scripting = false; + + zargs[0] = 0xf000; // tickle tickle! + z_set_text_style(); +} + +void Processor::pad_status_line(int column) { + int spaces; + spaces = (h_screen_cols + 1 - curx) - column; + while (spaces-- > 0) + print_char(' '); +} + +void Processor::z_show_status() { + zword global0; + zword global1; + zword global2; + zword addr; + + bool brief = false; + + if (!gos_upper) + return; + + // One V5 game (Wishbringer Solid Gold) contains this opcode by accident, + // so just return if the version number does not fit + if (h_version >= V4) + return; + + // Read all relevant global variables from the memory of the Z-machine + // into local variables + + addr = h_globals; + LOW_WORD(addr, global0); + addr += 2; + LOW_WORD(addr, global1); + addr += 2; + LOW_WORD(addr, global2); + + // Move to top of the status window, and print in reverse style. + glk_set_window(gos_upper); + gos_curwin = gos_upper; + +#ifdef GARGLK + garglk_set_reversevideo(true); +#endif /* GARGLK */ + + curx = cury = 1; + glk_window_move_cursor(gos_upper, 0, 0); + + // If the screen width is below 55 characters then we have to use + // the brief status line format + if (h_screen_cols < 55) + brief = true; + + // Print the object description for the global variable 0 + print_char (' '); + print_object (global0); + + // A header flag tells us whether we have to display the current + // time or the score/moves information + if (h_config & CONFIG_TIME) { + // print hours and minutes + zword hours = (global1 + 11) % 12 + 1; + + pad_status_line (brief ? 15 : 20); + + print_string ("Time: "); + + if (hours < 10) + print_char (' '); + print_num (hours); + + print_char (':'); + + if (global2 < 10) + print_char ('0'); + print_num (global2); + + print_char (' '); + + print_char ((global1 >= 12) ? 'p' : 'a'); + print_char ('m'); + + } else { + // print score and moves + pad_status_line (brief ? 15 : 30); + + print_string (brief ? "S: " : "Score: "); + print_num (global1); + + pad_status_line (brief ? 8 : 14); + + print_string (brief ? "M: " : "Moves: "); + print_num (global2); + } + + // Pad the end of the status line with spaces + pad_status_line (0); + + // Return to the lower window + glk_set_window(gos_lower); + gos_curwin = gos_lower; +} + +void Processor::z_split_window() { + split_window(zargs[0]); +} + +} // End of namespace Scott +} // End of namespace Gargoyle diff --git a/engines/gargoyle/frotz/processor_streams.cpp b/engines/gargoyle/frotz/processor_streams.cpp new file mode 100644 index 0000000000..5fe526fbe4 --- /dev/null +++ b/engines/gargoyle/frotz/processor_streams.cpp @@ -0,0 +1,533 @@ +/* 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 "gargoyle/frotz/processor.h" + +namespace Gargoyle { +namespace Frotz { + +// TODO: Implement method stubs +static void os_scrollback_char(zchar) {} +static void os_scrollback_erase(zword) {} +static void flush_buffer() {} +static void script_open() {} +static void script_close() {} +static void script_mssg_on() {} +static void script_mssg_off() {} +static void script_char(zchar) {} +static void script_word(const zchar *) {} +static void script_new_line() {} +static void script_erase_input(const zchar *) {} +static void script_write_input(zchar *, char) {} +static void memory_open(zword, zword, bool) {} +static void memory_close() {} +static void memory_word(const zchar *) {} +static void memory_new_line() {} +static void replay_open() {} +static void replay_close() {} +static zchar replay_read_key() { return 0; } +static zchar replay_read_input(zchar *) { return 0; } +static zchar console_read_key(zword) { return 0; } +static zchar console_read_input(uint, zchar *, uint, bool) { return 0; } +static void record_open() {} +static void record_close() {} +static void record_write_key(zchar) {} +static void record_write_input(zchar *, zchar) {} +static void os_restart_game(zword) {} +static void restart_header() {} + + +void Processor::scrollback_char (zchar c) { + if (c == ZC_INDENT) + { scrollback_char (' '); scrollback_char (' '); scrollback_char (' '); return; } + if (c == ZC_GAP) + { scrollback_char (' '); scrollback_char (' '); return; } + + os_scrollback_char(c); +} + +void Processor::scrollback_word(const zchar *s) { + int i; + + for (i = 0; s[i] != 0; i++) { + if (s[i] == ZC_NEW_FONT || s[i] == ZC_NEW_STYLE) + i++; + else + scrollback_char(s[i]); + } +} + +void Processor::scrollback_write_input(const zchar *buf, zchar key) { + int i; + + for (i = 0; buf[i] != 0; i++) + scrollback_char (buf[i]); + + if (key == ZC_RETURN) + scrollback_char ('\n'); +} + +void Processor::scrollback_erase_input(const zchar *buf) { + int width; + int i; + + for (i = 0, width = 0; buf[i] != 0; i++) + width++; + + os_scrollback_erase(width); + +} + +void Processor::stream_mssg_on() { + flush_buffer(); + + if (ostream_screen) + screen_mssg_on(); + if (ostream_script && enable_scripting) + script_mssg_on(); + + message = true; +} + +void Processor::stream_mssg_off() { + flush_buffer(); + + if (ostream_screen) + screen_mssg_off(); + if (ostream_script && enable_scripting) + script_mssg_off(); + + message = false; +} + +void Processor::stream_char(zchar c) { + if (ostream_screen) + screen_char(c); + if (ostream_script && enable_scripting) + script_char(c); + if (enable_scripting) + scrollback_char(c); +} + +void Processor::stream_word(const zchar *s) { + if (ostream_memory && !message) + memory_word(s); + else { + if (ostream_screen) + screen_word(s); + if (ostream_script && enable_scripting) + script_word(s); + if (enable_scripting) + scrollback_word(s); + } +} + +void Processor::stream_new_line() { + if (ostream_memory && !message) + memory_new_line(); + else { + if (ostream_screen) + screen_new_line(); + if (ostream_script && enable_scripting) + script_new_line(); + if (enable_scripting) + os_scrollback_char ('\n'); + } +} + +zchar Processor::stream_read_key(zword timeout, zword routine, bool hot_keys) { + zchar key = ZC_BAD; + + flush_buffer(); + + // Read key from current input stream +continue_input: + + do { + if (istream_replay) + key = replay_read_key(); + else + key = console_read_key(timeout); + } while (key == ZC_BAD); + + // Copy key to the command file + if (ostream_record && !istream_replay) + record_write_key(key); + + // Handle timeouts + if (key == ZC_TIME_OUT) + if (direct_call (routine) == 0) + goto continue_input; + + // Return key + return key; +} + +zchar Processor::stream_read_input(int max, zchar *buf, zword timeout, zword routine, + bool hot_keys, bool no_scripting) { + zchar key = ZC_BAD; + bool no_scrollback = no_scripting; + + if (h_version == V6 && _storyId == UNKNOWN && !ostream_script) + no_scrollback = false; + + flush_buffer(); + + // Remove initial input from the transscript file or from the screen + if (ostream_script && enable_scripting && !no_scripting) + script_erase_input(buf); + + // Read input line from current input stream +continue_input: + + do { + if (istream_replay) + key = replay_read_input(buf); + else + key = console_read_input(max, buf, timeout, key != ZC_BAD); + } while (key == ZC_BAD); + + // Copy input line to the command file + if (ostream_record && !istream_replay) + record_write_input(buf, key); + + // Handle timeouts + if (key == ZC_TIME_OUT) + if (direct_call(routine) == 0) + goto continue_input; + + // Copy input line to transscript file or to the screen + if (ostream_script && enable_scripting && !no_scripting) + script_write_input(buf, key); + + // Return terminating key + return key; +} + +void Processor::z_input_stream() { + flush_buffer(); + + if (zargs[0] == 0 && istream_replay) + replay_close(); + if (zargs[0] == 1 && !istream_replay) + replay_open(); +} + +void Processor::z_output_stream() { + flush_buffer(); + + switch ((short) zargs[0]) { + case 1: ostream_screen = true; + break; + case -1: ostream_screen = false; + break; + case 2: if (!ostream_script) script_open(); + break; + case -2: if (ostream_script) script_close(); + break; + case 3: memory_open(zargs[1], zargs[2], zargc >= 3); + break; + case -3: memory_close(); + break; + case 4: if (!ostream_record) record_open(); + break; + case -4: if (ostream_record) record_close(); + break; + default: + break; + } +} + +void Processor::z_restart(void) { + flush_buffer(); + + os_restart_game(RESTART_BEGIN); + + seed_random(0); + + if (!first_restart) { + story_fp->seek(blorb_ofs); + + if (story_fp->read(zmp, h_dynamic_size) != h_dynamic_size) + error("Story file read error"); + + } else { + first_restart = false; + } + + restart_header(); + restart_screen(); + + _sp = _fp = _stack + STACK_SIZE; + _frameCount = 0; + + if (h_version != V6 && h_version != V9) { + long pc = (long)h_start_pc; + SET_PC(pc); + } else { + call(h_start_pc, 0, nullptr, 0); + } + + os_restart_game(RESTART_END); +} + + +void Processor::z_save(void) { +#ifdef TODO + bool success = false; + + if (zargc != 0) { + // Open auxilary file + frefid_t ref = glk_fileref_create_by_prompt(fileusage_Data | fileusage_BinaryMode, + filemode_Write, 0); + if (ref == nullptr) + goto finished; + + // Write data + strid_t f = glk_stream_open_file(ref, filemode_Write); + + glk_put_buffer_stream(f, (const char *)zmp + zargs[0], zargs[1]); + + stream_result_t result; + glk_stream_close(f, &result); + + } else { + long pc; + zword addr; + zword nsp, nfp; + int skip; + int i; + + /* Open game file */ + + if ((gfp = frotzopenprompt (FILE_SAVE)) == nullptr) + goto finished; + + if (option_save_quetzal) { + success = save_quetzal (gfp, story_fp, blorb_ofs); + } else { + /* Write game file */ + + fputc ((int) hi (h_release), gfp); + fputc ((int) lo (h_release), gfp); + fputc ((int) hi (h_checksum), gfp); + fputc ((int) lo (h_checksum), gfp); + + GET_PC (pc) + + fputc ((int) (pc >> 16) & 0xff, gfp); + fputc ((int) (pc >> 8) & 0xff, gfp); + fputc ((int) (pc) & 0xff, gfp); + + nsp = (int) (_sp - _stack); + nfp = (int) (_fp - _stack); + + fputc ((int) hi (nsp), gfp); + fputc ((int) lo (nsp), gfp); + fputc ((int) hi (nfp), gfp); + fputc ((int) lo (nfp), gfp); + + for (i = nsp; i < STACK_SIZE; i++) { + fputc ((int) hi (_stack[i]), gfp); + fputc ((int) lo (_stack[i]), gfp); + } + + fseek (story_fp, blorb_ofs, SEEK_SET); + + for (addr = 0, skip = 0; addr < h_dynamic_size; addr++) + if (zmp[addr] != fgetc (story_fp) || skip == 255 || addr + 1 == h_dynamic_size) { + fputc (skip, gfp); + fputc (zmp[addr], gfp); + skip = 0; + } else skip++; + } + + /* Close game file and check for errors */ + + if (fclose (gfp) == EOF || ferror (story_fp)) { + print_string ("Error writing save file\n"); + goto finished; + } + + /* Success */ + + success = 1; + + } + +finished: + + if (h_version <= V3) + branch (success); + else + store (success); +#endif +} + +void Processor::z_restore() { +#ifdef TODO + FILE *gfp; + + zword success = 0; + + if (zargc != 0) { + + /* Get the file name */ + + /* Open auxilary file */ + + if ((gfp = frotzopenprompt(FILE_LOAD_AUX)) == nullptr) + goto finished; + + /* Load auxilary file */ + + success = fread (zmp + zargs[0], 1, zargs[1], gfp); + + /* Close auxilary file */ + + fclose (gfp); + + } else { + + long pc; + zword release; + zword addr; + int i; + + /* Open game file */ + + if ((gfp = frotzopenprompt(FILE_RESTORE)) == nullptr) + goto finished; + + if (option_save_quetzal) { + success = restore_quetzal (gfp, story_fp, blorb_ofs); + + } else { + /* Load game file */ + + release = (unsigned) fgetc (gfp) << 8; + release |= fgetc (gfp); + + (void) fgetc (gfp); + (void) fgetc (gfp); + + /* Check the release number */ + + if (release == h_release) { + + pc = (long) fgetc (gfp) << 16; + pc |= (unsigned) fgetc (gfp) << 8; + pc |= fgetc (gfp); + + SET_PC (pc); + + _sp = _stack + (fgetc (gfp) << 8); + _sp += fgetc (gfp); + _fp = _stack + (fgetc (gfp) << 8); + _fp += fgetc (gfp); + + for (i = (int) (_sp - _stack); i < STACK_SIZE; i++) { + _stack[i] = (unsigned) fgetc (gfp) << 8; + _stack[i] |= fgetc (gfp); + } + + fseek (story_fp, blorb_ofs, SEEK_SET); + + for (addr = 0; addr < h_dynamic_size; addr++) { + int skip = fgetc (gfp); + for (i = 0; i < skip; i++) + zmp[addr++] = fgetc (story_fp); + zmp[addr] = fgetc (gfp); + (void) fgetc (story_fp); + } + + /* Check for errors */ + + if (ferror (gfp) || ferror (story_fp) || addr != h_dynamic_size) + success = -1; + else + + /* Success */ + + success = 2; + + } else print_string ("Invalid save file\n"); + } + + if ((short) success >= 0) { + + /* Close game file */ + + fclose (gfp); + + if ((short) success > 0) { + zbyte old_screen_rows; + zbyte old_screen_cols; + + /* In V3, reset the upper window. */ + if (h_version == V3) + split_window (0); + + LOW_BYTE (H_SCREEN_ROWS, old_screen_rows); + LOW_BYTE (H_SCREEN_COLS, old_screen_cols); + + /* Reload cached header fields. */ + restart_header (); + + /* + * Since QUETZAL files may be saved on many different machines, + * the screen sizes may vary a lot. Erasing the status window + * seems to cover up most of the resulting badness. + */ + if (h_version > V3 && h_version != V6 + && (h_screen_rows != old_screen_rows + || h_screen_cols != old_screen_cols)) + erase_window (1); + } + } else + os_fatal ("Error reading save file"); + } + +finished: + + if (h_version <= V3) + branch (success); + else + store (success); +#endif +} + +void Processor::z_verify(void) { + zword checksum = 0; + + // Sum all bytes in story file except header bytes + story_fp->seek(blorb_ofs + 64); + + for (uint i = 64; i < story_size; i++) + checksum += story_fp->readByte(); + + // Branch if the checksums are equal + branch(checksum == h_checksum); +} + +} // End of namespace Scott +} // End of namespace Gargoyle diff --git a/engines/gargoyle/frotz/processor_table.cpp b/engines/gargoyle/frotz/processor_table.cpp new file mode 100644 index 0000000000..4e660ca693 --- /dev/null +++ b/engines/gargoyle/frotz/processor_table.cpp @@ -0,0 +1,125 @@ +/* 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 "gargoyle/frotz/processor.h" + +namespace Gargoyle { +namespace Frotz { + +// TODO: Method stubs to implement +static void storeb(zword, zbyte) {} +static void storew(zword, zword) {} + + +void Processor::z_copy_table() { + zword addr; + zword size = zargs[2]; + zbyte value; + int i; + + if (zargs[1] == 0) /* zero table */ + + for (i = 0; i < size; i++) + storeb((zword) (zargs[0] + i), 0); + + else if ((short) size < 0 || zargs[0] > zargs[1]) /* copy forwards */ + + for (i = 0; i < (((short) size < 0) ? - (short) size : size); i++) { + addr = zargs[0] + i; + LOW_BYTE(addr, value); + storeb((zword) (zargs[1] + i), value); + } else { + // copy backwards + for (i = size - 1; i >= 0; i--) { + addr = zargs[0] + i; + LOW_BYTE(addr, value); + storeb((zword) (zargs[1] + i), value); + } + } +} + +void Processor::z_loadb() { + zword addr = zargs[0] + zargs[1]; + zbyte value; + + LOW_BYTE(addr, value); + + store(value); +} + +void Processor::z_loadw() { + zword addr = zargs[0] + 2 * zargs[1]; + zword value; + + LOW_WORD(addr, value); + + store(value); +} + +void Processor::z_scan_table() { + zword addr = zargs[1]; + int i; + + // Supply default arguments + if (zargc < 4) + zargs[3] = 0x82; + + // Scan byte or word array + for (i = 0; i < zargs[2]; i++) { + if (zargs[3] & 0x80) { + // scan word array + zword wvalue; + + LOW_WORD(addr, wvalue); + + if (wvalue == zargs[0]) + goto finished; + } else { + // scan byte array + zbyte bvalue; + + LOW_BYTE(addr, bvalue); + + if (bvalue == zargs[0]) + goto finished; + } + + addr += zargs[3] & 0x7f; + } + + addr = 0; + +finished: + store(addr); + branch(addr); +} + +void Processor::z_storeb() { + storeb((zword) (zargs[0] + zargs[1]), zargs[2]); +} + +void Processor::z_storew() { + storew((zword)(zargs[0] + 2 * zargs[1]), zargs[2]); +} + +} // End of namespace Scott +} // End of namespace Gargoyle diff --git a/engines/gargoyle/frotz/processor_text.cpp b/engines/gargoyle/frotz/processor_text.cpp new file mode 100644 index 0000000000..e660ac1fd9 --- /dev/null +++ b/engines/gargoyle/frotz/processor_text.cpp @@ -0,0 +1,904 @@ +/* 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 "gargoyle/frotz/processor.h" + +namespace Gargoyle { +namespace Frotz { + +// TODO: Replace method stubs +static void new_line() {} +static void print_char(zchar) {} +static void storeb(zword, zchar) {} +static void storew(zword, zword) {} + + +zchar Processor::ZSCII_TO_LATIN1[] = { + 0x0e4, 0x0f6, 0x0fc, 0x0c4, 0x0d6, 0x0dc, 0x0df, 0x0bb, + 0x0ab, 0x0eb, 0x0ef, 0x0ff, 0x0cb, 0x0cf, 0x0e1, 0x0e9, + 0x0ed, 0x0f3, 0x0fa, 0x0fd, 0x0c1, 0x0c9, 0x0cd, 0x0d3, + 0x0da, 0x0dd, 0x0e0, 0x0e8, 0x0ec, 0x0f2, 0x0f9, 0x0c0, + 0x0c8, 0x0cc, 0x0d2, 0x0d9, 0x0e2, 0x0ea, 0x0ee, 0x0f4, + 0x0fb, 0x0c2, 0x0ca, 0x0ce, 0x0d4, 0x0db, 0x0e5, 0x0c5, + 0x0f8, 0x0d8, 0x0e3, 0x0f1, 0x0f5, 0x0c3, 0x0d1, 0x0d5, + 0x0e6, 0x0c6, 0x0e7, 0x0c7, 0x0fe, 0x0f0, 0x0de, 0x0d0, + 0x0a3, 0x153, 0x152, 0x0a1, 0x0bf +}; + +zchar Processor::translate_from_zscii(zbyte c) { + if (c == 0xfc) + return ZC_MENU_CLICK; + if (c == 0xfd) + return ZC_DOUBLE_CLICK; + if (c == 0xfe) + return ZC_SINGLE_CLICK; + + if (c >= 0x9b && _storyId != BEYOND_ZORK) { + if (hx_unicode_table != 0) { + // game has its own Unicode table + zbyte N; + LOW_BYTE(hx_unicode_table, N); + + if (c - 0x9b < N) { + zword addr = hx_unicode_table + 1 + 2 * (c - 0x9b); + zword unicode; + + LOW_WORD(addr, unicode); + + if (unicode < 0x20) + return '?'; + + return unicode; + } else { + return '?'; + } + } else { + // game uses standard set + if (c <= 0xdf) { + return ZSCII_TO_LATIN1[c - 0x9b]; + } else { + return '?'; + } + } + } + + return (zchar)c; +} + +zbyte Processor::unicode_to_zscii(zchar c) { + int i; + + if (c >= ZC_LATIN1_MIN) { + if (hx_unicode_table != 0) { + // game has its own Unicode table + zbyte N; + LOW_BYTE(hx_unicode_table, N); + + for (i = 0x9b; i < 0x9b + N; i++) { + zword addr = hx_unicode_table + 1 + 2 * (i - 0x9b); + zword unicode; + + LOW_WORD(addr, unicode); + + if (c == unicode) + return (zbyte) i; + } + + return 0; + } else { + // game uses standard set + for (i = 0x9b; i <= 0xdf; i++) + if (c == ZSCII_TO_LATIN1[i - 0x9b]) + return (zbyte) i; + + return 0; + } + } + + return (zbyte)c; +} + +zbyte Processor::translate_to_zscii(zchar c) { + if (c == ZC_SINGLE_CLICK) + return 0xfe; + if (c == ZC_DOUBLE_CLICK) + return 0xfd; + if (c == ZC_MENU_CLICK) + return 0xfc; + if (c == 0) + return 0; + + c = unicode_to_zscii (c); + if (c == 0) + c = '?'; + + return (zbyte)c; +} + +zchar Processor::alphabet(int set, int index) { + if (h_version > V1 && set == 2 && index == 1) + // always newline + return '\r'; + + if (h_alphabet != 0) { + // game uses its own alphabet + zbyte c; + + zword addr = h_alphabet + 26 * set + index; + LOW_BYTE(addr, c); + + return translate_from_zscii(c); + } else { + // game uses default alphabet + if (set == 0) + return 'a' + index; + else if (set == 1) + return 'A' + index; + else if (h_version == V1) + return " 0123456789.,!?_#'\"/\\<-:()"[index]; + else + return " ^0123456789.,!?_#'\"/\\-:()"[index]; + } +} + +void Processor::find_resolution() { + zword dct = h_dictionary; + zword entry_count; + zbyte sep_count; + zbyte entry_len; + + LOW_BYTE(dct, sep_count); + dct += 1 + sep_count; // skip word separators + LOW_BYTE(dct, entry_len); + dct += 1; // skip entry length + LOW_WORD(dct, entry_count); + dct += 2; // get number of entries + + if (h_version < V9) { + _resolution = (h_version <= V3) ? 2 : 3; + } else { + zword addr = dct; + zword code; + + if (entry_count == 0) + runtimeError(ERR_DICT_LEN); + + // check the first word in the dictionary + do { + LOW_WORD(addr, code); + addr += 2; + } while (!(code & 0x8000) && (addr - dct < entry_len + 1)); + + _resolution = (addr - dct) / 2; + } + + if (2 * _resolution > entry_len) { + runtimeError(ERR_DICT_LEN); + } + + _decoded = (zchar *)malloc (sizeof (zchar) * (3 * _resolution) + 1); + _encoded = (zchar *)malloc (sizeof (zchar) * _resolution); +} + +void Processor::load_string (zword addr, zword length) { + int i = 0; + + if (_resolution == 0) + find_resolution(); + + while (i < 3 * _resolution) { + if (i < length) { + zbyte c; + LOW_BYTE(addr, c); + addr++; + + _decoded[i++] = translate_from_zscii(c); + } else { + _decoded[i++] = 0; + } + } +} + +void Processor::encode_text(int padding) { + static const zchar again[] = { 'a', 'g', 'a', 'i', 'n', 0, 0, 0, 0 }; + static const zchar examine[] = { 'e', 'x', 'a', 'm', 'i', 'n', 'e', 0, 0 }; + static const zchar wait[] = { 'w', 'a', 'i', 't', 0, 0, 0, 0, 0 }; + + zbyte *zchars; + const zchar *ptr; + zchar c; + int i = 0; + + if (_resolution == 0) find_resolution(); + + zchars = new byte[3 * (_resolution + 1)]; + ptr = _decoded; + + // Expand abbreviations that some old Infocom games lack + if (_expand_abbreviations && (h_version <= V8)) { + if (padding == 0x05 && _decoded[1] == 0) { + switch (_decoded[0]) { + case 'g': ptr = again; break; + case 'x': ptr = examine; break; + case 'z': ptr = wait; break; + default: break; + } + } + } + + // Translate string to a sequence of Z-characters + while (i < 3 * _resolution) { + if ((c = *ptr++) != 0) { + int index, set; + zbyte c2; + + if (c == ' ') { + zchars[i++] = 0; + continue; + } + + // Search character in the alphabet + for (set = 0; set < 3; set++) + for (index = 0; index < 26; index++) + if (c == alphabet (set, index)) + goto letter_found; + + // Character not found, store its ZSCII value + c2 = translate_to_zscii (c); + + zchars[i++] = 5; + zchars[i++] = 6; + zchars[i++] = c2 >> 5; + zchars[i++] = c2 & 0x1f; + continue; + + letter_found: + // Character found, store its index + if (set != 0) + zchars[i++] = ((h_version <= V2) ? 1 : 3) + set; + + zchars[i++] = index + 6; + } else { + zchars[i++] = padding; + } + } + + // Three Z-characters make a 16bit word + for (i = 0; i < _resolution; i++) + _encoded[i] = + (zchars[3 * i + 0] << 10) | + (zchars[3 * i + 1] << 5) | + (zchars[3 * i + 2]); + + _encoded[_resolution - 1] |= 0x8000; + delete[] zchars; +} + +#define outchar(c) if (st == VOCABULARY) *ptr++=c; else print_char(c) + +void Processor::decode_text(enum string_type st, zword addr) { + zchar *ptr = nullptr; + long byte_addr = 0; + zchar c2; + zword code; + zbyte c, prev_c = 0; + int shift_state = 0; + int shift_lock = 0; + int status = 0; + + if (_resolution == 0) + find_resolution(); + + // Calculate the byte address if necessary + if (st == ABBREVIATION) + byte_addr = (long)addr << 1; + + else if (st == HIGH_STRING) { + if (h_version <= V3) + byte_addr = (long)addr << 1; + else if (h_version <= V5) + byte_addr = (long)addr << 2; + else if (h_version <= V7) + byte_addr = ((long)addr << 2) + ((long)h_strings_offset << 3); + else if (h_version <= V8) + byte_addr = (long)addr << 3; + else { + // h_version == V9 + long indirect = (long)addr << 2; + HIGH_LONG(indirect, byte_addr); + } + + if ((uint)byte_addr >= story_size) + runtimeError(ERR_ILL_PRINT_ADDR); + } + + // Loop until a 16bit word has the highest bit set + if (st == VOCABULARY) + ptr = _decoded; + + do { + int i; + + // Fetch the next 16bit word + if (st == LOW_STRING || st == VOCABULARY) { + LOW_WORD(addr, code); + addr += 2; + } else if (st == HIGH_STRING || st == ABBREVIATION) { + HIGH_WORD(byte_addr, code); + byte_addr += 2; + } else { + CODE_WORD(code); + } + + // Read its three Z-characters + for (i = 10; i >= 0; i -= 5) { + zword abbr_addr; + zword ptr_addr; + zchar zc; + + c = (code >> i) & 0x1f; + + switch (status) { + case 0: + // normal operation + if (shift_state == 2 && c == 6) + status = 2; + + else if (h_version == V1 && c == 1) + new_line(); + + else if (h_version >= V2 && shift_state == 2 && c == 7) + new_line(); + + else if (c >= 6) + outchar(alphabet(shift_state, c - 6)); + + else if (c == 0) + outchar(' '); + + else if (h_version >= V2 && c == 1) + status = 1; + + else if (h_version >= V3 && c <= 3) + status = 1; + + else { + shift_state = (shift_lock + (c & 1) + 1) % 3; + + if (h_version <= V2 && c >= 4) + shift_lock = shift_state; + + break; + } + + shift_state = shift_lock; + break; + + case 1: + // abbreviation + ptr_addr = h_abbreviations + 64 * (prev_c - 1) + 2 * c; + + LOW_WORD(ptr_addr, abbr_addr); + decode_text(ABBREVIATION, abbr_addr); + + status = 0; + break; + + case 2: + // ZSCII character - first part + status = 3; + break; + + case 3: + // ZSCII character - second part + zc = (prev_c << 5) | c; + + if (zc > 767) { + // Unicode escape + while (zc-- > 767) { + if (st == LOW_STRING || st == VOCABULARY) { + LOW_WORD(addr, c2); + addr += 2; + } else if (st == HIGH_STRING || st == ABBREVIATION) { + HIGH_WORD(byte_addr, c2); + byte_addr += 2; + } else + CODE_WORD(c2); + + outchar(c2 ^ 0xFFFF); + } + } else { + c2 = translate_from_zscii(zc); + outchar(c2); + } + + status = 0; + break; + + default: + break; + } + + prev_c = c; + } + } while (!(code & 0x8000)); + + if (st == VOCABULARY) + *ptr = 0; +} + +#undef outchar + +void Processor::print_num(zword value) { + int i; + + /* Print sign */ + + if ((short)value < 0) { + print_char('-'); + value = -(short)value; + } + + /* Print absolute value */ + + for (i = 10000; i != 0; i /= 10) + if (value >= i || i == 1) + print_char('0' + (value / i) % 10); + +} + +void Processor::print_object(zword object) { + zword addr = object_name(object); + zword code = 0x94a5; + zbyte length; + + LOW_BYTE(addr, length); + addr++; + + if (length != 0) + LOW_WORD(addr, code); + + if (code == 0x94a5) { + // _encoded text 0x94a5 == empty string + print_string("object#"); // supply a generic name + print_num(object); // for anonymous objects + } else { + decode_text(LOW_STRING, addr); + } +} + +void Processor::print_string(const char *s) { + char c; + + while ((c = *s++) != 0) { + if (c == '\n') + new_line(); + else + print_char(c); + } +} + +zword Processor::lookup_text(int padding, zword dct) { + zword entry_addr; + zword entry_count; + zword entry; + zword addr; + zbyte entry_len; + zbyte sep_count; + int entry_number; + int lower, upper; + int i; + bool sorted; + + if (_resolution == 0) + find_resolution(); + + encode_text(padding); + + LOW_BYTE(dct, sep_count); // skip word separators + dct += 1 + sep_count; + LOW_BYTE(dct, entry_len); // get length of entries + dct += 1; + LOW_WORD(dct, entry_count); // get number of entries + dct += 2; + + if ((short)entry_count < 0) { + // bad luck, entries aren't sorted + entry_count = -(short)entry_count; + sorted = false; + + } else { + sorted = true; // entries are sorted + } + + lower = 0; + upper = entry_count - 1; + + while (lower <= upper) { + if (sorted) + // binary search + entry_number = (lower + upper) / 2; + else + // linear search + entry_number = lower; + + entry_addr = dct + entry_number * entry_len; + + // Compare word to dictionary entry + addr = entry_addr; + + for (i = 0; i < _resolution; i++) { + LOW_WORD(addr, entry); + if (_encoded[i] != entry) + goto continuing; + addr += 2; + } + + return entry_addr; // exact match found, return now + + continuing: + if (sorted) { + // binary search + if (_encoded[i] > entry) + lower = entry_number + 1; + else + upper = entry_number - 1; + } else { + // linear search + lower++; + } + } + + // No exact match has been found + if (padding == 0x05) + return 0; + + entry_number = (padding == 0x00) ? lower : upper; + + if (entry_number == -1 || entry_number == entry_count) + return 0; + + return dct + entry_number * entry_len; +} + +void Processor::tokenise_text(zword text, zword length, zword from, zword parse, zword dct, bool flag) { + zword addr; + zbyte token_max, token_count; + + LOW_BYTE(parse, token_max); + parse++; + LOW_BYTE(parse, token_count); + + if (token_count < token_max) { + // sufficient space left for token? + storeb(parse++, token_count + 1); + + load_string((zword)(text + from), length); + + addr = lookup_text(0x05, dct); + + if (addr != 0 || !flag) { + + parse += 4 * token_count; + + storew((zword)(parse + 0), addr); + storeb((zword)(parse + 2), length); + storeb((zword)(parse + 3), from); + } + } +} + +void Processor::tokenise_line(zword text, zword token, zword dct, bool flag) { + zword addr1; + zword addr2; + zbyte length = 0; + zbyte c; + + // Use standard dictionary if the given dictionary is zero + if (dct == 0) + dct = h_dictionary; + + // Remove all tokens before inserting new ones + storeb((zword)(token + 1), 0); + + // Move the first pointer across the text buffer searching for the beginning + // of a word. If this succeeds, store the position in a second pointer. + // Move the first pointer searching for the end of the word. When it is found, + // "tokenise" the word. Continue until the end of the buffer is reached. + addr1 = text; + addr2 = 0; + + if (h_version >= V5) { + addr1++; + LOW_BYTE(addr1, length); + } + + do { + zword sep_addr; + zbyte sep_count; + zbyte separator; + + // Fetch next ZSCII character + addr1++; + + if (h_version >= V5 && addr1 == text + 2 + length) + c = 0; + else + LOW_BYTE(addr1, c); + + // Check for separator + sep_addr = dct; + + LOW_BYTE(sep_addr, sep_count); + sep_addr++; + + do { + LOW_BYTE(sep_addr, separator); + sep_addr++; + } while (c != separator && --sep_count != 0); + + // This could be the start or the end of a word + if (sep_count == 0 && c != ' ' && c != 0) { + if (addr2 == 0) + addr2 = addr1; + } else if (addr2 != 0) { + tokenise_text(text, (zword)(addr1 - addr2), (zword)(addr2 - text), + token, dct, flag); + + addr2 = 0; + } + + // Translate separator (which is a word in its own right) + if (sep_count != 0) + tokenise_text(text, (zword)(1), (zword)(addr1 - text), token, dct, flag); + + } while (c != 0); +} + +int Processor::completion(const zchar *buffer, zchar *result) { + zword minaddr; + zword maxaddr; + zchar *ptr; + zchar c; + int len; + int i; + + *result = 0; + + if (_resolution == 0) + find_resolution(); + + // Copy last word to "_decoded" string + len = 0; + + while ((c = *buffer++) != 0) + if (c != ' ') { + if (len < 3 * _resolution) + _decoded[len++] = c; + } else { + len = 0; + } + + _decoded[len] = 0; + + // Search the dictionary for first and last possible extensions + minaddr = lookup_text(0x00, h_dictionary); + maxaddr = lookup_text(0x1f, h_dictionary); + + if (minaddr == 0 || maxaddr == 0 || minaddr > maxaddr) + return 2; + + // Copy first extension to "result" string + decode_text(VOCABULARY, minaddr); + + ptr = result; + + for (i = len; (c = _decoded[i]) != 0; i++) + *ptr++ = c; + *ptr = 0; + + // Merge second extension with "result" string + decode_text(VOCABULARY, maxaddr); + + for (i = len, ptr = result; (c = _decoded[i]) != 0; i++, ptr++) { + if (*ptr != c) + break; + } + *ptr = 0; + + // Search was ambiguous or successful + return (minaddr == maxaddr) ? 0 : 1; +} + +zchar Processor::unicode_tolower(zchar c) { + static const byte tolower_basic_latin[0x100] = { + 0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0x0B,0x0C,0x0D,0x0E,0x0F, + 0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,0x1A,0x1B,0x1C,0x1D,0x1E,0x1F, + 0x20,0x21,0x22,0x23,0x24,0x25,0x26,0x27,0x28,0x29,0x2A,0x2B,0x2C,0x2D,0x2E,0x2F, + 0x30,0x31,0x32,0x33,0x34,0x35,0x36,0x37,0x38,0x39,0x3A,0x3B,0x3C,0x3D,0x3E,0x3F, + 0x40,0x61,0x62,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x6A,0x6B,0x6C,0x6D,0x6E,0x6F, + 0x70,0x71,0x72,0x73,0x74,0x75,0x76,0x77,0x78,0x79,0x7A,0x5B,0x5C,0x5D,0x5E,0x5F, + 0x60,0x61,0x62,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x6A,0x6B,0x6C,0x6D,0x6E,0x6F, + 0x70,0x71,0x72,0x73,0x74,0x75,0x76,0x77,0x78,0x79,0x7A,0x7B,0x7C,0x7D,0x7E,0x7F, + 0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F, + 0x90,0x91,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9A,0x9B,0x9C,0x9D,0x9E,0x9F, + 0xA0,0xA1,0xA2,0xA3,0xA4,0xA5,0xA6,0xA7,0xA8,0xA9,0xAA,0xAB,0xAC,0xAD,0xAE,0xAF, + 0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF, + 0xE0,0xE1,0xE2,0xE3,0xE4,0xE5,0xE6,0xE7,0xE8,0xE9,0xEA,0xEB,0xEC,0xED,0xEE,0xEF, + 0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xD7,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xDF, + 0xE0,0xE1,0xE2,0xE3,0xE4,0xE5,0xE6,0xE7,0xE8,0xE9,0xEA,0xEB,0xEC,0xED,0xEE,0xEF, + 0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF + }; + static const byte tolower_latin_extended_a[0x80] = { + 0x01,0x01,0x03,0x03,0x05,0x05,0x07,0x07,0x09,0x09,0x0B,0x0B,0x0D,0x0D,0x0F,0x0F, + 0x11,0x11,0x13,0x13,0x15,0x15,0x17,0x17,0x19,0x19,0x1B,0x1B,0x1D,0x1D,0x1F,0x1F, + 0x21,0x21,0x23,0x23,0x25,0x25,0x27,0x27,0x29,0x29,0x2B,0x2B,0x2D,0x2D,0x2F,0x2F, + 0x00,0x31,0x33,0x33,0x35,0x35,0x37,0x37,0x38,0x3A,0x3A,0x3C,0x3C,0x3E,0x3E,0x40, + 0x40,0x42,0x42,0x44,0x44,0x46,0x46,0x48,0x48,0x49,0x4B,0x4B,0x4D,0x4D,0x4F,0x4F, + 0x51,0x51,0x53,0x53,0x55,0x55,0x57,0x57,0x59,0x59,0x5B,0x5B,0x5D,0x5D,0x5F,0x5F, + 0x61,0x61,0x63,0x63,0x65,0x65,0x67,0x67,0x69,0x69,0x6B,0x6B,0x6D,0x6D,0x6F,0x6F, + 0x71,0x71,0x73,0x73,0x75,0x75,0x77,0x77,0x00,0x7A,0x7A,0x7C,0x7C,0x7E,0x7E,0x7F + }; + static const byte tolower_greek[0x50] = { + 0x80,0x81,0x82,0x83,0x84,0x85,0xAC,0x87,0xAD,0xAE,0xAF,0x8B,0xCC,0x8D,0xCD,0xCE, + 0x90,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF, + 0xC0,0xC1,0xA2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xAC,0xAD,0xAE,0xAF, + 0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF, + 0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF + }; + static const byte tolower_cyrillic[0x60] = { + 0x00,0x51,0x52,0x53,0x54,0x55,0x56,0x57,0x58,0x59,0x5A,0x5B,0x5C,0x5D,0x5E,0x5F, + 0x30,0x31,0x32,0x33,0x34,0x35,0x36,0x37,0x38,0x39,0x3A,0x3B,0x3C,0x3D,0x3E,0x3F, + 0x40,0x41,0x42,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0x4A,0x4B,0x4C,0x4D,0x4E,0x4F, + 0x30,0x31,0x32,0x33,0x34,0x35,0x36,0x37,0x38,0x39,0x3A,0x3B,0x3C,0x3D,0x3E,0x3F, + 0x40,0x41,0x42,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0x4A,0x4B,0x4C,0x4D,0x4E,0x4F, + 0x50,0x51,0x52,0x53,0x54,0x55,0x56,0x57,0x58,0x59,0x5A,0x5B,0x5C,0x5D,0x5E,0x5F + }; + + if (c < 0x0100) + c = tolower_basic_latin[c]; + else if (c == 0x0130) + c = 0x0069; // Capital I with dot -> lower case i + else if (c == 0x0178) + c = 0x00FF; // Capital Y diaeresis -> lower case y diaeresis + else if (c < 0x0180) + c = tolower_latin_extended_a[c - 0x100] + 0x100; + else if (c >= 0x380 && c < 0x3D0) + c = tolower_greek[c - 0x380] + 0x300; + else if (c >= 0x400 && c < 0x460) + c = tolower_cyrillic[c - 0x400] + 0x400; + + return c; +} + + +void Processor::z_check_unicode() { + zword c = zargs[0]; + zword result = 0; + + if (c <= 0x1f) { + if ((c == 0x08) || (c == 0x0d) || (c == 0x1b)) + result = 2; + } else if (c <= 0x7e) { + result = 3; + } else { + // we support unicode + result = 1; + } + + store (result); +} + +void Processor::z_encode_text() { + int i; + + load_string((zword) (zargs[0] + zargs[2]), zargs[1]); + + encode_text(0x05); + + for (i = 0; i < _resolution; i++) + storew((zword) (zargs[3] + 2 * i), _encoded[i]); + +} + +void Processor::z_new_line() { + new_line (); +} + +void Processor::z_print () { + decode_text(EMBEDDED_STRING, 0); +} + +void Processor::z_print_addr() { + decode_text(LOW_STRING, zargs[0]); +} + +void Processor::z_print_char() { + print_char (translate_from_zscii(zargs[0])); +} + +void Processor::z_print_form() { + zword count; + zword addr = zargs[0]; + bool first = true; + + for (;;) { + LOW_WORD(addr, count); + addr += 2; + + if (count == 0) + break; + + if (!first) + new_line (); + + while (count--) { + zbyte c; + + LOW_BYTE(addr, c); + addr++; + + print_char(translate_from_zscii (c)); + } + + first = false; + } +} + +void Processor::z_print_num() { + print_num (zargs[0]); +} + +void Processor::z_print_obj() { + print_object(zargs[0]); +} + +void Processor::z_print_paddr() { + decode_text (HIGH_STRING, zargs[0]); +} + +void Processor::z_print_ret() { + decode_text(EMBEDDED_STRING, 0); + new_line(); + ret(1); +} + +void Processor::z_print_unicode() { + if (zargs[0] < 0x20) + print_char('?'); + else + print_char(zargs[0]); +} + +void Processor::z_tokenise() { + // Supply default arguments + if (zargc < 3) + zargs[2] = 0; + if (zargc < 4) + zargs[3] = 0; + + // Call tokenise_line to do the real work + tokenise_line(zargs[0], zargs[1], zargs[2], zargs[3] != 0); +} + +} // End of namespace Scott +} // End of namespace Gargoyle diff --git a/engines/gargoyle/frotz/processor_variables.cpp b/engines/gargoyle/frotz/processor_variables.cpp new file mode 100644 index 0000000000..24bbd28fe3 --- /dev/null +++ b/engines/gargoyle/frotz/processor_variables.cpp @@ -0,0 +1,203 @@ +/* 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 "gargoyle/frotz/processor.h" + +namespace Gargoyle { +namespace Frotz { + +// TODO: Replace method stubs +static void storew(zword, zword) {} + + +void Processor::z_dec() { + zword value; + + if (zargs[0] == 0) + (*_sp)--; + else if (zargs[0] < 16) + (*(_fp - zargs[0]))--; + else { + zword addr = h_globals + 2 * (zargs[0] - 16); + LOW_WORD(addr, value); + value--; + SET_WORD(addr, value); + } +} + +void Processor::z_dec_chk() { + zword value; + + if (zargs[0] == 0) + value = --(*_sp); + else if (zargs[0] < 16) + value = --(*(_fp - zargs[0])); + else { + zword addr = h_globals + 2 * (zargs[0] - 16); + LOW_WORD(addr, value); + value--; + SET_WORD(addr, value); + } + + branch((short)value < (short)zargs[1]); +} + +void Processor::z_inc() { + zword value; + + if (zargs[0] == 0) + (*_sp)++; + else if (zargs[0] < 16) + (*(_fp - zargs[0]))++; + else { + zword addr = h_globals + 2 * (zargs[0] - 16); + LOW_WORD(addr, value); + value++; + SET_WORD(addr, value); + } +} + +void Processor::z_inc_chk() { + zword value; + + if (zargs[0] == 0) + value = ++(*_sp); + else if (zargs[0] < 16) + value = ++(*(_fp - zargs[0])); + else { + zword addr = h_globals + 2 * (zargs[0] - 16); + LOW_WORD(addr, value); + value++; + SET_WORD(addr, value); + } + + branch((short)value > (short)zargs[1]); +} + +void Processor::z_load() { + zword value; + + if (zargs[0] == 0) + value = *_sp; + else if (zargs[0] < 16) + value = *(_fp - zargs[0]); + else { + zword addr = h_globals + 2 * (zargs[0] - 16); + LOW_WORD(addr, value); + } + + store(value); +} + +void Processor::z_pop() { + _sp++; +} + +void Processor::z_pop_stack() { + if (zargc == 2) { + // it's a user stack + zword size; + zword addr = zargs[1]; + + LOW_WORD(addr, size); + + size += zargs[0]; + storew(addr, size); + } else { + // it's the game stack + _sp += zargs[0]; + } +} + +void Processor::z_pull() { + zword value; + + if (h_version != V6) { + // not a V6 game, pop stack and write + value = *_sp++; + + if (zargs[0] == 0) + *_sp = value; + else if (zargs[0] < 16) + *(_fp - zargs[0]) = value; + else { + zword addr = h_globals + 2 * (zargs[0] - 16); + SET_WORD(addr, value); + } + } else { + // it's V6, but is there a user stack? + if (zargc == 1) { + // it's a user stack + zword size; + zword addr = zargs[0]; + + LOW_WORD(addr, size); + + size++; + storew(addr, size); + + addr += 2 * size; + LOW_WORD(addr, value); + } else { + // it's the game stack + value = *_sp++; + } + + store(value); + } +} + +void Processor::z_push() { + *--_sp = zargs[0]; +} + +void Processor::z_push_stack() { + zword size; + zword addr = zargs[1]; + + LOW_WORD(addr, size); + + if (size != 0) { + storew((zword)(addr + 2 * size), zargs[0]); + + size--; + storew(addr, size); + } + + branch(size); +} + +void Processor::z_store() { + zword value = zargs[1]; + + if (zargs[0] == 0) + *_sp = value; + else if (zargs[0] < 16) + *(_fp - zargs[0]) = value; + else { + zword addr = h_globals + 2 * (zargs[0] - 16); + SET_WORD(addr, value); + } +} + +} // End of namespace Scott +} // End of namespace Gargoyle diff --git a/engines/gargoyle/glk.h b/engines/gargoyle/glk.h index 9dc7f97b2c..a7a119866f 100644 --- a/engines/gargoyle/glk.h +++ b/engines/gargoyle/glk.h @@ -72,7 +72,7 @@ public: glui32 size, winid_t keyWin); void glk_window_get_arrangement(winid_t win, glui32 *method, glui32 *size, winid_t *keyWin); - winid_t glk_window_iterate(winid_t win, glui32 *rock); + winid_t glk_window_iterate(winid_t win, glui32 *rock = 0); glui32 glk_window_get_rock(winid_t win); glui32 glk_window_get_type(winid_t win); winid_t glk_window_get_parent(winid_t win); @@ -85,8 +85,8 @@ public: strid_t glk_window_get_echo_stream(winid_t win); void glk_set_window(winid_t win); - strid_t glk_stream_open_file(frefid_t fileref, FileMode fmode, glui32 rock); - strid_t glk_stream_open_memory(char *buf, glui32 buflen, FileMode fmode, glui32 rock); + strid_t glk_stream_open_file(frefid_t fileref, FileMode fmode, glui32 rock = 0); + strid_t glk_stream_open_memory(char *buf, glui32 buflen, FileMode fmode, glui32 rock = 0); void glk_stream_close(strid_t str, stream_result_t *result); strid_t glk_stream_iterate(strid_t str, glui32 *rockptr) const; glui32 glk_stream_get_rock(strid_t str) const; @@ -114,10 +114,10 @@ public: glui32 glk_style_distinguish(winid_t win, glui32 style1, glui32 style2); bool glk_style_measure(winid_t win, glui32 style, glui32 hint, glui32 *result); - frefid_t glk_fileref_create_temp(glui32 usage, glui32 rock); - frefid_t glk_fileref_create_by_name(glui32 usage, const char *name, glui32 rock); - frefid_t glk_fileref_create_by_prompt(glui32 usage, FileMode fmode, glui32 rock); - frefid_t glk_fileref_create_from_fileref(glui32 usage, frefid_t fref, glui32 rock); + frefid_t glk_fileref_create_temp(glui32 usage, glui32 rock = 0); + frefid_t glk_fileref_create_by_name(glui32 usage, const char *name, glui32 rock = 0); + frefid_t glk_fileref_create_by_prompt(glui32 usage, FileMode fmode, glui32 rock = 0); + frefid_t glk_fileref_create_from_fileref(glui32 usage, frefid_t fref, glui32 rock = 0); void glk_fileref_destroy(frefid_t fref); frefid_t glk_fileref_iterate(frefid_t fref, glui32 *rockptr); glui32 glk_fileref_get_rock(frefid_t fref); @@ -169,8 +169,8 @@ public: glui32 glk_get_buffer_stream_uni(strid_t str, glui32 *buf, glui32 len); glui32 glk_get_line_stream_uni(strid_t str, glui32 *buf, glui32 len); - strid_t glk_stream_open_file_uni(frefid_t fileref, FileMode fmode, glui32 rock); - strid_t glk_stream_open_memory_uni(glui32 *buf, glui32 buflen, FileMode fmode, glui32 rock); + strid_t glk_stream_open_file_uni(frefid_t fileref, FileMode fmode, glui32 rock = 0); + strid_t glk_stream_open_memory_uni(glui32 *buf, glui32 buflen, FileMode fmode, glui32 rock = 0); void glk_request_char_event_uni(winid_t win); void glk_request_line_event_uni(winid_t win, glui32 *buf, @@ -206,7 +206,7 @@ public: #ifdef GLK_MODULE_SOUND - schanid_t glk_schannel_create(glui32 rock); + schanid_t glk_schannel_create(glui32 rock = 0); void glk_schannel_destroy(schanid_t chan); schanid_t glk_schannel_iterate(schanid_t chan, glui32 *rockptr); glui32 glk_schannel_get_rock(schanid_t chan); diff --git a/engines/gargoyle/module.mk b/engines/gargoyle/module.mk index d359429487..9a1b4c40c1 100644 --- a/engines/gargoyle/module.mk +++ b/engines/gargoyle/module.mk @@ -26,7 +26,17 @@ MODULE_OBJS := \ frotz/detection_tables.o \ frotz/err.o \ frotz/frotz.o \ + frotz/glk_interface.o \ frotz/mem.o \ + frotz/processor.o \ + frotz/processor_input.o \ + frotz/processor_maths.o \ + frotz/processor_objects.o \ + frotz/processor_screen.o \ + frotz/processor_streams.o \ + frotz/processor_table.o \ + frotz/processor_text.o \ + frotz/processor_variables.o \ scott/detection.o \ scott/scott.o |