diff options
Diffstat (limited to 'engines/agi')
44 files changed, 15176 insertions, 0 deletions
diff --git a/engines/agi/agi.cpp b/engines/agi/agi.cpp new file mode 100644 index 0000000000..7487cbecf9 --- /dev/null +++ b/engines/agi/agi.cpp @@ -0,0 +1,627 @@ +/* ScummVM - Scumm Interpreter + * Copyright (C) 2006 The ScummVM project + * + * Copyright (C) 1999-2003 Sarien Team + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + * $URL$ + * $Id$ + * + */ + +#include "common/stdafx.h" +#include "common/file.h" +#include "common/savefile.h" +#include "common/config-manager.h" + +#include "base/plugins.h" + +#include "backends/fs/fs.h" + +#include "sound/mididrv.h" +#include "sound/mixer.h" + +#include "agi/agi.h" +#include "agi/text.h" +#include "agi/graphics.h" +#include "agi/sprite.h" +#include "agi/opcodes.h" +#include "agi/keyboard.h" +#include "agi/menu.h" +#include "agi/savegame.h" + +namespace Agi { + +void gfx_set_palette(); + +extern int optind; + +struct agi_options opt; +struct game_id_list game_info; +struct agi_game game; + +static struct agi_loader *loader; /* loader */ + +extern struct agi_loader agi_v2; +extern struct agi_loader agi_v3; + +static volatile uint32 tick_timer = 0; + +#define TICK_SECONDS 20 + +static int key_control = 0; +static int key_alt = 0; + +#define KEY_QUEUE_SIZE 16 + +static int key_queue[KEY_QUEUE_SIZE]; +static int key_queue_start = 0; +static int key_queue_end = 0; + +#define key_enqueue(k) do { key_queue[key_queue_end++] = (k); \ + key_queue_end %= KEY_QUEUE_SIZE; } while (0) +#define key_dequeue(k) do { (k) = key_queue[key_queue_start++]; \ + key_queue_start %= KEY_QUEUE_SIZE; } while (0) + +static void process_events() { + OSystem::Event event; + int key = 0; + + while (g_system->pollEvent(event)) { + switch (event.type) { + case OSystem::EVENT_QUIT: + deinit_video(); + deinit_machine(); + g_system->quit(); + break; + case OSystem::EVENT_LBUTTONDOWN: + key = BUTTON_LEFT; + mouse.button = 1; + key_enqueue(key); + mouse.x = event.mouse.x; + mouse.y = event.mouse.y; + break; + case OSystem::EVENT_RBUTTONDOWN: + key = BUTTON_RIGHT; + mouse.button = 2; + key_enqueue(key); + mouse.x = event.mouse.x; + mouse.y = event.mouse.y; + break; + case OSystem::EVENT_MOUSEMOVE: + mouse.x = event.mouse.x; + mouse.y = event.mouse.y; + break; + case OSystem::EVENT_LBUTTONUP: + case OSystem::EVENT_RBUTTONUP: + mouse.button = 0; + break; + case OSystem::EVENT_KEYDOWN: + if (event.kbd.flags == OSystem::KBD_CTRL) { + key_control |= 1; + key = 0; + break; + } else if (event.kbd.flags == OSystem::KBD_ALT) { + key_alt |= 1; + key = 0; + break; + } else if (event.kbd.flags == OSystem::KBD_SHIFT) { + key = 0; + break; + } + + switch (key = event.kbd.keycode) { + case 256 + 20: // left arrow + key = KEY_LEFT; + break; + case 256 + 19: // right arrow + key = KEY_RIGHT; + break; + case 256 + 17: // up arrow + key = KEY_UP; + break; + case 256 + 18: // down arrow + key = KEY_DOWN; + break; + case 256 + 24: // page up + key = KEY_UP_RIGHT; + break; + case 256 + 25: // page down + key = KEY_DOWN_RIGHT; + break; + case 256 + 22: // home + key = KEY_UP_LEFT; + break; + case 256 + 23: // end + key = KEY_DOWN_LEFT; + break; + case '+': + key = '+'; + break; + case '-': + key = '-'; + break; + case 9: + key = 0x0009; + break; + case 282: + key = 0x3b00; + break; + case 283: + key = 0x3c00; + break; + case 284: + key = 0x3d00; + break; + case 285: + key = 0x3e00; + break; + case 286: + key = 0x3f00; + break; + case 287: + key = 0x4000; + break; + case 288: + key = 0x4100; + break; + case 289: + key = 0x4200; + break; + case 290: + key = 0x4300; + break; + case 291: + key = 0x4400; + break; + case 292: + key = KEY_STATUSLN; + break; + case 293: + key = KEY_PRIORITY; + break; + case 27: + key = 0x1b; + break; + case '\n': + case '\r': + key = KEY_ENTER; + break; + default: + if (!isalpha(key)) + break; + if (key_control) + key = (key & ~0x20) - 0x40; + else if (key_alt) + key = scancode_table[(key & ~0x20) - 0x41] << 8; + break; + } + if (key) + key_enqueue(key); + break; + case OSystem::EVENT_KEYUP: + if (event.kbd.flags == OSystem::KBD_CTRL) { + key_control &= ~1; + key = 0; + break; + } else if (event.kbd.flags == OSystem::KBD_ALT) { + key_alt &= ~1; + key = 0; + break; + } else if (event.kbd.flags == OSystem::KBD_SHIFT) { + key = 0; + break; + } + break; + default: + break; + } + } +} + +int agi_is_keypress_low() { + process_events(); + return key_queue_start != key_queue_end; +} + +void agi_timer_low() { + static uint32 m = 0; + uint32 dm; + + if (tick_timer < m) + m = 0; + + while ((dm = tick_timer - m) < 5) { + process_events(); + g_system->delayMillis(10); + g_system->updateScreen(); + } + m = tick_timer; +} + +int agi_get_keypress_low() { + int k; + + while (key_queue_start == key_queue_end) /* block */ + agi_timer_low(); + key_dequeue(k); + + return k; +} + +static uint32 agi_timer_function_low(uint32 i) { + tick_timer++; + return i; +} + +static void init_pri_table() { + int i, p, y = 0; + + for (p = 1; p < 15; p++) { + for (i = 0; i < 12; i++) { + game.pri_table[y++] = p < 4 ? 4 : p; + } + } +} + +int agi_init() { + int ec, i; + + debug(2, "initializing"); + debug(2, "game.ver = 0x%x", game.ver); + + /* reset all flags to false and all variables to 0 */ + for (i = 0; i < MAX_FLAGS; i++) + game.flags[i] = 0; + for (i = 0; i < MAX_VARS; i++) + game.vars[i] = 0; + + /* clear all resources and events */ + for (i = 0; i < MAX_DIRS; i++) { + memset(&game.views[i], 0, sizeof(struct agi_view)); + memset(&game.pictures[i], 0, sizeof(struct agi_picture)); + memset(&game.logics[i], 0, sizeof(struct agi_logic)); + memset(&game.sounds[i], 0, sizeof(struct agi_sound)); + } + + /* clear view table */ + for (i = 0; i < MAX_VIEWTABLE; i++) + memset(&game.view_table[i], 0, sizeof(struct vt_entry)); + + init_words(); + + menu_init(); + init_pri_table(); + + /* clear string buffer */ + for (i = 0; i < MAX_STRINGS; i++) + game.strings[i][0] = 0; + + /* setup emulation */ + + switch (loader->int_version >> 12) { + case 2: + report("Emulating Sierra AGI v%x.%03x\n", + (int)(loader->int_version >> 12) & 0xF, + (int)(loader->int_version) & 0xFFF); + break; + case 3: + report("Emulating Sierra AGI v%x.002.%03x\n", + (int)(loader->int_version >> 12) & 0xF, + (int)(loader->int_version) & 0xFFF); + break; + } + + game.game_flags |= opt.amiga ? ID_AMIGA : 0; + game.game_flags |= opt.agds ? ID_AGDS : 0; + + if (game.game_flags & ID_AMIGA) + report("Amiga padded game detected.\n"); + + if (game.game_flags & ID_AGDS) + report("AGDS mode enabled.\n"); + + ec = loader->init(); /* load vol files, etc */ + + if (ec == err_OK) + ec = loader->load_objects(OBJECTS); + + /* note: demogs has no words.tok */ + if (ec == err_OK) + ec = loader->load_words(WORDS); + + /* FIXME: load IIgs instruments and samples */ + /* load_instruments("kq.sys16"); */ + + /* Load logic 0 into memory */ + if (ec == err_OK) + ec = loader->load_resource(rLOGIC, 0); + + return ec; +} + +/* + * Public functions + */ + +void agi_unload_resources() { + int i; + + /* Make sure logic 0 is always loaded */ + for (i = 1; i < MAX_DIRS; i++) { + loader->unload_resource(rLOGIC, i); + } + for (i = 0; i < MAX_DIRS; i++) { + loader->unload_resource(rVIEW, i); + loader->unload_resource(rPICTURE, i); + loader->unload_resource(rSOUND, i); + } +} + +int agi_deinit() { + int ec; + + clean_input(); /* remove all words from memory */ + agi_unload_resources(); /* unload resources in memory */ + loader->unload_resource(rLOGIC, 0); + ec = loader->deinit(); + unload_objects(); + unload_words(); + + clear_image_stack(); + + return ec; +} + +int agi_detect_game() { + int ec = err_OK; + + loader = &agi_v2; + ec = loader->detect_game(); + + if (ec != err_OK) { + loader = &agi_v3; + ec = loader->detect_game(); + } + + return ec; +} + +int agi_version() { + return loader->version; +} + +int agi_get_release() { + return loader->int_version; +} + +void agi_set_release(int n) { + loader->int_version = n; +} + +int agi_load_resource(int r, int n) { + int i; + + i = loader->load_resource(r, n); +#ifdef PATCH_LOGIC + if (r == rLOGIC) + patch_logic(n); +#endif + + return i; +} + +int agi_unload_resource(int r, int n) { + return loader->unload_resource(r, n); +} + +const char *_savePath; +extern AGIMusic *g_agi_music; + +struct GameSettings { + const char *gameid; + const char *description; + byte id; + uint32 features; + const char *detectname; +}; + +static const GameSettings agi_settings[] = { + {"agi", "AGI game", GID_AGI, MDT_ADLIB, "VIEWDIR"}, + {NULL, NULL, 0, 0, NULL} +}; + +Common::RandomSource * rnd; + +AgiEngine::AgiEngine(OSystem * syst) : Engine(syst) { + + // Setup mixer + if (!_mixer->isReady()) { + warning("Sound initialization failed."); + } + + _mixer->setVolumeForSoundType(Audio::Mixer::kSFXSoundType, ConfMan.getInt("sfx_volume")); + _mixer->setVolumeForSoundType(Audio::Mixer::kMusicSoundType, ConfMan.getInt("music_volume")); + + _savePath = _saveFileMan->getSavePath(); + + const GameSettings *g; + + const char *gameid = ConfMan.get("gameid").c_str(); + for (g = agi_settings; g->gameid; ++g) + if (!scumm_stricmp(g->gameid, gameid)) + _gameId = g->id; + + rnd = new Common::RandomSource(); + + game.clock_enabled = false; + game.state = STATE_INIT; +} + +void AgiEngine::initialize() { + memset(&opt, 0, sizeof(struct agi_options)); + opt.gamerun = GAMERUN_RUNGAME; +#ifdef USE_HIRES + opt.hires = true; +#endif + opt.soundemu = SOUND_EMU_NONE; + + init_machine(); + + game.color_fg = 15; + game.color_bg = 0; + + *game.name = 0; + + game.sbuf = (uint8 *) calloc(_WIDTH, _HEIGHT); +#ifdef USE_HIRES + game.hires = (uint8 *) calloc(_WIDTH * 2, _HEIGHT); +#endif + + init_sprites(); + init_video(); + + tick_timer = 0; + Common::g_timer->installTimerProc((Common::Timer::TimerProc) agi_timer_function_low, 10 * 1000, NULL); + + console_init(); + + game.ver = -1; /* Don't display the conf file warning */ + + debugC(2, kDebugLevelMain, "Detect game"); + if (agi_detect_game() == err_OK) { + game.state = STATE_LOADED; + debugC(2, kDebugLevelMain, "game loaded"); + } else { + report("Could not open AGI game"); + } + + debugC(2, kDebugLevelMain, "Init sound"); + init_sound(); + g_agi_music = new AGIMusic(_mixer); +} + +AgiEngine::~AgiEngine() { + agi_deinit(); + delete g_agi_music; + deinit_sound(); + deinit_video(); + deinit_sprites(); +#ifdef USE_HIRES + free(game.hires); +#endif + free(game.sbuf); + deinit_machine(); + delete rnd; +} + +void AgiEngine::errorString(const char *buf1, char *buf2) { + strcpy(buf2, buf1); +} + +int AgiEngine::init() { + // Initialize backend + _system->beginGFXTransaction(); + initCommonGFX(false); + _system->initSize(320, 200); + _system->endGFXTransaction(); + + Common::addSpecialDebugLevel(kDebugLevelMain, "Main", "Generic debug level"); + Common::addSpecialDebugLevel(kDebugLevelResources, "Resources", "Resources debugging"); + Common::addSpecialDebugLevel(kDebugLevelSprites, "Sprites", "Sprites debugging"); + Common::addSpecialDebugLevel(kDebugLevelInventory, "Inventory", "Inventory debugging"); + Common::addSpecialDebugLevel(kDebugLevelInput, "Input", "Input events debugging"); + Common::addSpecialDebugLevel(kDebugLevelMenu, "Menu", "Menu debugging"); + Common::addSpecialDebugLevel(kDebugLevelScripts, "Scrpits", "Scripts debugging"); + Common::addSpecialDebugLevel(kDebugLevelSound, "Sound", "Sound debugging"); + Common::addSpecialDebugLevel(kDebugLevelText, "Text", "Text output debugging"); + + initialize(); + + gfx_set_palette(); + + return 0; +} + +int AgiEngine::go() { + _system->showMouse(true); + + report(" \nAGI engine " VERSION " is ready.\n"); + if (game.state < STATE_LOADED) { + console_prompt(); + do { + main_cycle(); + } while (game.state < STATE_RUNNING); + if (game.ver < 0) + game.ver = 0; /* Enable conf file warning */ + } + + run_game(); + + return 0; +} + +} // End of namespace Agi + +GameList Engine_AGI_gameIDList() { + GameList games; + const Agi::GameSettings *g = Agi::agi_settings; + + while (g->gameid) { + games.push_back(*g); + g++; + } + + return games; +} + +GameDescriptor Engine_AGI_findGameID(const char *gameid) { + const Agi::GameSettings *g = Agi::agi_settings; + while (g->gameid) { + if (0 == scumm_stricmp(gameid, g->gameid)) + break; + g++; + } + return *g; +} + +DetectedGameList Engine_AGI_detectGames(const FSList &fslist) { + DetectedGameList detectedGames; + const Agi::GameSettings * g; + + for (g = Agi::agi_settings; g->gameid; ++g) { + // Iterate over all files in the given directory + for (FSList::const_iterator file = fslist.begin(); + file != fslist.end(); ++file) { + const char *gameName = file->displayName().c_str(); + + if (0 == scumm_stricmp(g->detectname, gameName)) { + // Match found, add to list of candidates, then abort inner loop. + detectedGames.push_back(*g); + break; + } + } + } + return detectedGames; +} + +PluginError Engine_AGI_create(OSystem *syst, Engine **engine) { + assert(engine); + *engine = new Agi::AgiEngine(syst); + return kNoError; +} + +REGISTER_PLUGIN(AGI, "AGI Engine"); diff --git a/engines/agi/agi.h b/engines/agi/agi.h new file mode 100644 index 0000000000..f6d890c80c --- /dev/null +++ b/engines/agi/agi.h @@ -0,0 +1,545 @@ +/* ScummVM - Scumm Interpreter + * Copyright (C) 2006 The ScummVM project + * + * Copyright (C) 1999-2001 Sarien Team + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + * $URL$ + * $Id$ + * + */ + +#ifndef __AGI_H +#define __AGI_H + +#include "common/stdafx.h" +#include "common/scummsys.h" +#include "common/endian.h" +#include "common/util.h" +#include "common/file.h" +#include "common/savefile.h" +#include "common/system.h" + +#include "base/engine.h" + +namespace Agi { + +typedef signed int Err; + +/* + * Version and other definitions + */ +#define INLINE __inline +#define VERSION __DATE__ " " __TIME__ + +/* Default features -- can be overriden in portdefs.h */ +#define USE_CONSOLE +#define USE_PCM_SOUND +#define USE_IIGS_SOUND +#define USE_HIRES +#define USE_MOUSE +#define AGDS_SUPPORT + +#define TITLE "AGI engine" + +#define DIR_ "dir" +#define LOGDIR "logdir" +#define PICDIR "picdir" +#define VIEWDIR "viewdir" +#define SNDDIR "snddir" +#define OBJECTS "object" +#define WORDS "words.tok" + +#define MAX_DIRS 256 +#define MAX_VARS 256 +#define MAX_FLAGS (256 >> 3) +#define MAX_VIEWTABLE 255 /* KQ3 uses o255! */ +#define MAX_WORDS 20 +#define MAX_STRINGS 24 /* MAX_STRINGS + 1 used for get.num */ +#define MAX_STRINGLEN 40 +#ifndef MAX_PATH +#define MAX_PATH 260 +#endif + +#define _EMPTY 0xfffff +#define EGO_OWNED 0xff + +#define CRYPT_KEY_SIERRA "Avis Durgan" +#define CRYPT_KEY_AGDS "Alex Simkin" + +#ifndef INLINE +#define INLINE +#endif + +#ifndef USE_PCM_SOUND +#undef USE_IIGS_SOUND +#endif + +#define MSG_BOX_COLOUR 0x0f /* White */ +#define MSG_BOX_TEXT 0x00 /* Black */ +#define MSG_BOX_LINE 0x04 /* Red */ +#define STATUS_FG 0x00 /* Black */ +#define STATUS_BG 0x0f /* White */ +#define PATCH_LOGIC /* disable copy protection on some games */ + +} // End of namespace Agi + +/* AGI resources */ +#include "agi/console.h" +#include "agi/view.h" +#include "agi/picture.h" +#include "agi/logic.h" +#include "agi/sound.h" + +namespace Agi { + +int getflag(int); +void setflag(int, int); +void flipflag(int); +int getvar(int); +void setvar(int, int); +void decrypt(uint8 * mem, int len); +void release_sprites(void); +int main_cycle(void); +int view_pictures(void); +int parse_cli(int, char **); +int run_game(void); +int init_machine(void); +int deinit_machine(void); +int get_direction(int x, int y, int x0, int y0, int s); +void inventory(void); +void list_games(void); +uint32 match_crc(uint32, char *, int); +int v2id_game(void); +int v3id_game(void); +int v4id_game(uint32 ver); +void update_timer(void); +int get_app_dir(char *app_dir, unsigned int size); + +enum { + NO_GAMEDIR = 0, + GAMEDIR +}; + +enum AGIErrors { + err_OK = 0, + err_DoNothing, + err_BadCLISwitch, + err_InvalidAGIFile, + err_BadFileOpen, + err_NotEnoughMemory, + err_BadResource, + err_UnknownAGIVersion, + err_RestartGame, + err_NoLoopsInView, + err_ViewDataError, + err_NoGameList, + + err_Unk = 127 +}; + +enum kDebugLevels { + kDebugLevelMain = 1 << 0, + kDebugLevelResources = 1 << 1, + kDebugLevelSprites = 1 << 2, + kDebugLevelInventory = 1 << 3, + kDebugLevelInput = 1 << 4, + kDebugLevelMenu = 1 << 5, + kDebugLevelScripts = 1 << 6, + kDebugLevelSound = 1 << 7, + kDebugLevelText = 1 << 8 +}; + +/** + * AGI resources. + */ +enum { + rLOGIC = 1, + rSOUND, + rVIEW, + rPICTURE +}; + +enum { + RES_LOADED = 1, + RES_COMPRESSED = 0x40 +}; + +enum { + lCOMMAND_MODE = 1, + lTEST_MODE +}; + +struct game_id_list { + struct game_id_list *next; + uint32 version; + uint32 crc; + char *gName; + char *switches; +}; + +#ifdef USE_MOUSE +struct mouse { + int button; + unsigned int x; + unsigned int y; +}; +#endif + +/** + * Command-line options. + */ +struct agi_options { +#define GAMERUN_RUNGAME 0 +#define GAMERUN_PICVIEW 1 +#define GAMERUN_WORDS 2 +#define GAMERUN_OBJECTS 3 +#define GAMERUN_GAMES 4 +#define GAMERUN_CRC 5 + int gamerun; /**< game run mode*/ + int emuversion; /**< AGI version to emulate */ + int agds; /**< enable AGDS mode */ + int amiga; /**< enable Amiga mode */ + int fullscreen; /**< use full screen mode if available */ + int nosound; /**< disable sound */ + int egapal; /**< use PC EGA palette */ + int cgaemu; /**< use PC CGA emulation */ +#ifdef USE_HIRES + int hires; /**< use hi-res pictures */ +#endif + int soundemu; /**< sound emulation mode */ +#ifdef USE_MOUSE + int agimouse; /**< AGI Mouse 1.0 emulation */ +#endif +}; + +extern struct agi_options opt; +extern uint8 *exec_name; + +extern volatile uint32 clock_ticks; +extern volatile uint32 clock_count; +extern volatile uint32 msg_box_secs2; + +#ifdef USE_CONSOLE +extern struct agi_debug debug_; +#endif + +#ifdef USE_MOUSE +extern struct mouse mouse; +#endif + +int console_keyhandler(int); +int console_init(void); +void console_cycle(void); +void console_lock(void); +void console_prompt(void); +#define report printf + +enum GameId { + GID_AGI = 1 +}; + +extern Common::RandomSource * rnd; +extern const char *_savePath; + +class AgiEngine:public::Engine { + int _gameId; + + void errorString(const char *buf_input, char *buf_output); + +protected: + int init(); + int go(); + void shutdown(); + void initialize(); + + +public: + AgiEngine(OSystem * syst); + virtual ~ AgiEngine(); + int getGameId() { + return _gameId; +}}; + +#define WIN_TO_PIC_X(x) ((x) / 2) +#define WIN_TO_PIC_Y(y) ((y) < 8 ? 999 : (y) >= (8 + _HEIGHT) ? 999 : (y) - 8) + +/** + * AGI variables. + */ +enum { + V_cur_room = 0, /* 0 */ + V_prev_room, + V_border_touch_ego, + V_score, + V_border_code, + V_border_touch_obj, /* 5 */ + V_ego_dir, + V_max_score, + V_free_pages, + V_word_not_found, + V_time_delay, /* 10 */ + V_seconds, + V_minutes, + V_hours, + V_days, + V_joystick_sensitivity, /* 15 */ + V_ego_view_resource, + V_agi_err_code, + V_agi_err_code_info, + V_key, + V_computer, /* 20 */ + V_window_reset, + V_soundgen, + V_volume, + V_max_input_chars, + V_sel_item, /* 25 */ + V_monitor +}; + +/** + * AGI flags + */ +enum { + F_ego_water = 0, /* 0 */ + F_ego_invisible, + F_entered_cli, + F_ego_touched_p2, + F_said_accepted_input, + F_new_room_exec, /* 5 */ + F_restart_game, + F_script_blocked, + F_joy_sensitivity, + F_sound_on, + F_debugger_on, /* 10 */ + F_logic_zero_firsttime, + F_restore_just_ran, + F_status_selects_items, + F_menus_work, + F_output_mode, /* 15 */ + F_auto_restart +}; + +struct agi_event { + uint16 data; + uint8 occured; +}; + +struct agi_object { + int location; + char *name; +}; + +struct agi_word { + int id; + char *word; +}; + +struct agi_dir { + uint8 volume; + uint32 offset; + uint32 len; + uint32 clen; + uint8 flags; + /* 0 = not in mem, can be freed + * 1 = in mem, can be released + * 2 = not in mem, cant be released + * 3 = in mem, cant be released + * 0x40 = was compressed + */ +}; + +struct agi_block { + int active; + int x1, y1; + int x2, y2; + uint8 *buffer; /* used for window background */ +}; + +#define EGO_VIEW_TABLE 0 +#define HORIZON 36 +#define _WIDTH 160 +#define _HEIGHT 168 + +/** + * AGI game structure. + * This structure contains all global data of an AGI game executed + * by the interpreter. + */ +struct agi_game { +#define STATE_INIT 0x00 +#define STATE_LOADED 0x01 +#define STATE_RUNNING 0x02 + int state; /**< state of the interpreter */ + + char name[8]; /**< lead in id (e.g. `GR' for goldrush) */ + char id[8]; /**< game id */ + uint32 crc; /**< game CRC */ + + /* game flags and variables */ + uint8 flags[MAX_FLAGS]; + /**< 256 1-bit flags */ + uint8 vars[MAX_VARS]; + /**< 256 variables */ + + /* internal variables */ + int horizon; /**< horizon y coordinate */ + int line_status; /**< line number to put status on */ + int line_user_input; + /**< line to put user input on */ + int line_min_print; + /**< num lines to print on */ + int cursor_pos; /**< column where the input cursor is */ + uint8 input_buffer[40]; + /**< buffer for user input */ + uint8 echo_buffer[40]; + /**< buffer for echo.line */ + int keypress; +#define INPUT_NORMAL 0x01 +#define INPUT_GETSTRING 0x02 +#define INPUT_MENU 0x03 +#define INPUT_NONE 0x04 + int input_mode; /**< keyboard input mode */ + int input_enabled; + /**< keyboard input enabled */ + int lognum; /**< current logic number */ + + /* internal flags */ + int player_control; + /**< player is in control */ + int quit_prog_now; + /**< quit now */ + int status_line; /**< status line on/off */ + int clock_enabled; + /**< clock is on/off */ + int exit_all_logics; + /**< break cycle after new.room */ + int picture_shown; + /**< show.pic has been issued */ + int has_prompt; /**< input prompt has been printed */ +#define ID_AGDS 0x00000001 +#define ID_AMIGA 0x00000002 + int game_flags; /**< agi options flags */ + + uint8 pri_table[_HEIGHT]; + /**< priority table */ + + /* windows */ + uint32 msg_box_ticks; + /**< timed message box tick counter */ + struct agi_block block; + struct agi_block window; + int has_window; + + /* graphics & text */ + int gfx_mode; + char cursor_char; + unsigned int color_fg; + unsigned int color_bg; + uint8 *sbuf; /**< 160x168 AGI screen buffer */ +#ifdef USE_HIRES + uint8 *hires; /**< 320x168 hi-res buffer */ +#endif + + /* player command line */ + struct agi_word ego_words[MAX_WORDS]; + int num_ego_words; + + unsigned int num_objects; + + struct agi_event ev_keyp[MAX_DIRS]; + /**< keyboard keypress events */ + char strings[MAX_STRINGS + 1][MAX_STRINGLEN]; + /**< strings */ + + /* directory entries for resources */ + struct agi_dir dir_logic[MAX_DIRS]; + struct agi_dir dir_pic[MAX_DIRS]; + struct agi_dir dir_view[MAX_DIRS]; + struct agi_dir dir_sound[MAX_DIRS]; + + /* resources */ + struct agi_picture pictures[MAX_DIRS]; + /**< AGI picture resources */ + struct agi_logic logics[MAX_DIRS]; + /**< AGI logic resources */ + struct agi_view views[MAX_DIRS]; /**< AGI view resources */ + struct agi_sound sounds[MAX_DIRS]; + /**< AGI sound resources */ + + /* view table */ + struct vt_entry view_table[MAX_VIEWTABLE]; + + int32 ver; /**< detected game version */ + + int simple_save; /**< select simple savegames */ +}; + +/** + * + */ +struct agi_loader { + int version; + int int_version; + int (*init) (void); + int (*deinit) (void); + int (*detect_game) (); + int (*load_resource) (int, int); + int (*unload_resource) (int, int); + int (*load_objects) (char *); + int (*load_words) (char *); +}; + +extern struct agi_game game; + +int agi_init(void); +int agi_deinit(void); +int agi_version(void); +int agi_get_release(void); +void agi_set_release(int); +int agi_detect_game(); +int agi_load_resource(int, int); +int agi_unload_resource(int, int); +void agi_unload_resources(void); + +/* words */ +int show_words(void); +int load_words(char *); +void unload_words(void); +int find_word(char *word, int *flen); +void dictionary_words(char *); + +/* objects */ +int show_objects(void); +int load_objects(char *fname); +int alloc_objects(int); +void unload_objects(void); +char *object_name(unsigned int); +int object_get_location(unsigned int); +void object_set_location(unsigned int, int); + +void new_input_mode(int); +void old_input_mode(void); + +int run_logic(int); + +void agi_timer_low(); +int agi_get_keypress_low(); +int agi_is_keypress_low(); + +} // End of namespace Agi + +#endif /* __AGI_H */ diff --git a/engines/agi/agi_v2.cpp b/engines/agi/agi_v2.cpp new file mode 100644 index 0000000000..deb849c200 --- /dev/null +++ b/engines/agi/agi_v2.cpp @@ -0,0 +1,309 @@ +/* ScummVM - Scumm Interpreter + * Copyright (C) 2006 The ScummVM project + * + * Copyright (C) 1999-2001 Sarien Team + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + * $URL$ + * $Id$ + * + */ + +#include "common/stdafx.h" +#include "common/file.h" + +#include "agi/agi.h" + +namespace Agi { + +static int agi_v2_init(void); +static int agi_v2_deinit(void); +static int agi_v2_detect_game(); +static int agi_v2_load_resource(int, int); +static int agi_v2_unload_resource(int, int); +static int agi_v2_load_objects(char *); +static int agi_v2_load_words(char *); + +struct agi_loader agi_v2 = { + 2, + 0, + agi_v2_init, + agi_v2_deinit, + agi_v2_detect_game, + agi_v2_load_resource, + agi_v2_unload_resource, + agi_v2_load_objects, + agi_v2_load_words +}; + +static int agi_v2_detect_game() { + if (!Common::File::exists(LOGDIR) || + !Common::File::exists(PICDIR) || + !Common::File::exists(SNDDIR) || + !Common::File::exists(VIEWDIR)) + return err_InvalidAGIFile; + + agi_v2.int_version = 0x2917; /* setup for 2.917 */ + return v2id_game(); +} + +static int agi_v2_load_dir(struct agi_dir *agid, char *fname) { + Common::File fp; + uint8 *mem; + uint32 flen; + unsigned int i; + char *path; + + path = fname; + report("Loading directory: %s\n", path); + + if ((!fp.open(path))) { + return err_BadFileOpen; + } + + fp.seek(0, SEEK_END); + flen = fp.pos(); + fp.seek(0, SEEK_SET); + + if ((mem = (uint8 *) malloc(flen + 32)) == NULL) { + fp.close(); + return err_NotEnoughMemory; + } + + fp.read(mem, flen); + + /* set all directory resources to gone */ + for (i = 0; i < MAX_DIRS; i++) { + agid[i].volume = 0xff; + agid[i].offset = _EMPTY; + } + + /* build directory entries */ + for (i = 0; i < flen; i += 3) { + agid[i / 3].volume = *(mem + i) >> 4; + agid[i / 3].offset = READ_BE_UINT24(mem + i) & (uint32) _EMPTY; + debugC(3, kDebugLevelResources, "%d: volume %d, offset 0x%05x", i / 3, agid[i / 3].volume, agid[i / 3].offset); + } + + free(mem); + fp.close(); + + return err_OK; +} + +static int agi_v2_init() { + int ec = err_OK; + + /* load directory files */ + ec = agi_v2_load_dir(game.dir_logic, LOGDIR); + if (ec == err_OK) + ec = agi_v2_load_dir(game.dir_pic, PICDIR); + if (ec == err_OK) + ec = agi_v2_load_dir(game.dir_view, VIEWDIR); + if (ec == err_OK) + ec = agi_v2_load_dir(game.dir_sound, SNDDIR); + + return ec; +} + +static int agi_v2_deinit() { + int ec = err_OK; + +#if 0 + /* unload words */ + agi_v2_unload_words(); + + /* unload objects */ + agi_v2_unload_objects(); +#endif + + return ec; +} + +static int agi_v2_unload_resource(int t, int n) { + debugC(3, kDebugLevelResources, "unload resource"); + + switch (t) { + case rLOGIC: + unload_logic(n); + break; + case rPICTURE: + unload_picture(n); + break; + case rVIEW: + unload_view(n); + break; + case rSOUND: + unload_sound(n); + break; + } + + return err_OK; +} + +/* + * This function does noting but load a raw resource into memory, + * if further decoding is required, it must be done by another + * routine. NULL is returned if unsucsessfull. + */ +static uint8 *agi_v2_load_vol_res(struct agi_dir *agid) { + uint8 *data = NULL; + char x[MAX_PATH], *path; + Common::File fp; + unsigned int sig; + + sprintf(x, "vol.%i", agid->volume); + path = x; + debugC(3, kDebugLevelResources, "Vol res: path = %s", path); + + if (agid->offset != _EMPTY && fp.open(path)) { + debugC(3, kDebugLevelResources, "loading resource at offset %d", agid->offset); + fp.seek(agid->offset, SEEK_SET); + fp.read(&x, 5); + if ((sig = READ_BE_UINT16((uint8 *) x)) == 0x1234) { + agid->len = READ_LE_UINT16((uint8 *) x + 3); + data = (uint8 *) calloc(1, agid->len + 32); + if (data != NULL) { + fp.read(data, agid->len); + } else { + abort(); + } + } else { +#if 0 + /* FIXME: call some panic handler instead of + * deiniting directly + */ + deinit_video_mode(); +#endif + report("Error: bad signature %04x\n", sig); + // fprintf (stderr, "ACK! BAD RESOURCE!!!\n"); + return 0; + } + fp.close(); + } else { + /* we have a bad volume resource */ + /* set that resource to NA */ + agid->offset = _EMPTY; + } + + return data; +} + +/* + * Loads a resource into memory, a raw resource is loaded in + * with above routine, then further decoded here. + */ +int agi_v2_load_resource(int t, int n) { + int ec = err_OK; + uint8 *data = NULL; + + debugC(3, kDebugLevelResources, "(t = %d, n = %d)", t, n); + if (n > MAX_DIRS) + return err_BadResource; + + switch (t) { + case rLOGIC: + if (~game.dir_logic[n].flags & RES_LOADED) { + debugC(3, kDebugLevelResources, "loading logic resource %d", n); + agi_v2.unload_resource(rLOGIC, n); + + /* load raw resource into data */ + data = agi_v2_load_vol_res(&game.dir_logic[n]); + + game.logics[n].data = data; + ec = data ? decode_logic(n) : err_BadResource; + + game.logics[n].sIP = 2; + } + + /* if logic was cached, we get here */ + /* reset code pointers incase it was cached */ + + game.logics[n].cIP = game.logics[n].sIP; + break; + case rPICTURE: + /* if picture is currently NOT loaded *OR* cacheing is off, + * unload the resource (caching == off) and reload it + */ + + debugC(3, kDebugLevelResources, "loading picture resource %d", n); + if (game.dir_pic[n].flags & RES_LOADED) + break; + + /* if loaded but not cached, unload it */ + /* if cached but not loaded, etc */ + agi_v2.unload_resource(rPICTURE, n); + data = agi_v2_load_vol_res(&game.dir_pic[n]); + + if (data != NULL) { + game.pictures[n].rdata = data; + game.dir_pic[n].flags |= RES_LOADED; + } else { + ec = err_BadResource; + } + break; + case rSOUND: + debugC(3, kDebugLevelResources, "loading sound resource %d", n); + if (game.dir_sound[n].flags & RES_LOADED) + break; + + data = agi_v2_load_vol_res(&game.dir_sound[n]); + + if (data != NULL) { + game.sounds[n].rdata = data; + game.dir_sound[n].flags |= RES_LOADED; + decode_sound(n); + } else { + ec = err_BadResource; + } + break; + case rVIEW: + /* Load a VIEW resource into memory... + * Since VIEWS alter the view table ALL the time + * can we cache the view? or must we reload it all + * the time? + */ + if (game.dir_view[n].flags & RES_LOADED) + break; + + debugC(3, kDebugLevelResources, "loading view resource %d", n); + agi_v2.unload_resource(rVIEW, n); + data = agi_v2_load_vol_res(&game.dir_view[n]); + if (data) { + game.views[n].rdata = data; + game.dir_view[n].flags |= RES_LOADED; + ec = decode_view(n); + } else { + ec = err_BadResource; + } + break; + default: + ec = err_BadResource; + break; + } + + return ec; +} + +static int agi_v2_load_objects(char *fname) { + return load_objects(fname); +} + +static int agi_v2_load_words(char *fname) { + return load_words(fname); +} + +} // End of namespace Agi diff --git a/engines/agi/agi_v3.cpp b/engines/agi/agi_v3.cpp new file mode 100644 index 0000000000..5c99472b78 --- /dev/null +++ b/engines/agi/agi_v3.cpp @@ -0,0 +1,389 @@ +/* ScummVM - Scumm Interpreter + * Copyright (C) 2006 The ScummVM project + * + * Copyright (C) 1999-2003 Sarien Team + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + * $URL$ + * $Id$ + * + */ + +#include "common/stdafx.h" + +#include "agi/agi.h" +#include "agi/lzw.h" + +#include "backends/fs/fs.h" + +#include "common/config-manager.h" + +namespace Agi { + +static int agi_v3_init(void); +static int agi_v3_deinit(void); +static int agi_v3_detect_game(); +static int agi_v3_load_resource(int, int); +static int agi_v3_unload_resource(int, int); +static int agi_v3_load_objects(char *); +static int agi_v3_load_words(char *); + +struct agi_loader agi_v3 = { + 3, + 0, + agi_v3_init, + agi_v3_deinit, + agi_v3_detect_game, + agi_v3_load_resource, + agi_v3_unload_resource, + agi_v3_load_objects, + agi_v3_load_words +}; + +int agi_v3_detect_game() { + int ec = err_Unk; + bool found = false; + + FSList fslist; + FilesystemNode dir(ConfMan.get("path")); + + if (!dir.listDir(fslist, FilesystemNode::kListFilesOnly)) { + warning("AgiEngine: invalid game path '%s'", + dir.path().c_str()); + return err_InvalidAGIFile; + } + + for (FSList::const_iterator file = fslist.begin(); + file != fslist.end() && !found; ++file) { + Common::String f = file->displayName(); + f.toLowercase(); + + if (f.hasSuffix("vol.0")) { + strncpy(game.name, f.c_str(), f.size() > 5 ? f.size() - 5 : f.size()); + debugC(3, kDebugLevelMain, "game.name = %s", game.name); + agi_v3.int_version = 0x3149; // setup for 3.002.149 + ec = v3id_game(); + + found = true; + } + } + + if (!found) { + debugC(3, kDebugLevelMain, "not found"); + ec = err_InvalidAGIFile; + } + + return ec; +} + +static int agi_v3_load_dir(struct agi_dir *agid, Common::File *fp, + uint32 offs, uint32 len) { + int ec = err_OK; + uint8 *mem; + unsigned int i; + + fp->seek(offs, SEEK_SET); + if ((mem = (uint8 *) malloc(len + 32)) != NULL) { + fp->read(mem, len); + + /* set all directory resources to gone */ + for (i = 0; i < MAX_DIRS; i++) { + agid[i].volume = 0xff; + agid[i].offset = _EMPTY; + } + + /* build directory entries */ + for (i = 0; i < len; i += 3) { + agid[i / 3].volume = *(mem + i) >> 4; + agid[i / 3].offset = READ_BE_UINT24(mem + i) & (uint32) _EMPTY; + } + + free(mem); + } else { + ec = err_NotEnoughMemory; + } + + return ec; +} + +struct agi3vol { + uint32 sddr; + uint32 len; +}; + +int agi_v3_init(void) { + int ec = err_OK; + struct agi3vol agi_vol3[4]; + int i; + uint16 xd[4]; + Common::File fp; + Common::String path; + + path = Common::String(game.name) + DIR_; + + if (!fp.open(path)) { + printf("Failed to open \"%s\"\n", path.c_str()); + return err_BadFileOpen; + } + /* build offset table for v3 directory format */ + fp.read(&xd, 8); + fp.seek(0, SEEK_END); + + for (i = 0; i < 4; i++) + agi_vol3[i].sddr = READ_LE_UINT16((uint8 *) & xd[i]); + + agi_vol3[0].len = agi_vol3[1].sddr - agi_vol3[0].sddr; + agi_vol3[1].len = agi_vol3[2].sddr - agi_vol3[1].sddr; + agi_vol3[2].len = agi_vol3[3].sddr - agi_vol3[2].sddr; + agi_vol3[3].len = fp.pos() - agi_vol3[3].sddr; + + if (agi_vol3[3].len > 256 * 3) + agi_vol3[3].len = 256 * 3; + + fp.seek(0, SEEK_SET); + + /* read in directory files */ + ec = agi_v3_load_dir(game.dir_logic, &fp, agi_vol3[0].sddr, + agi_vol3[0].len); + + if (ec == err_OK) { + ec = agi_v3_load_dir(game.dir_pic, &fp, agi_vol3[1].sddr, agi_vol3[1].len); + } + + if (ec == err_OK) { + ec = agi_v3_load_dir(game.dir_view, &fp, agi_vol3[2].sddr, agi_vol3[2].len); + } + + if (ec == err_OK) { + ec = agi_v3_load_dir(game.dir_sound, &fp, agi_vol3[3].sddr, agi_vol3[3].len); + } + + return ec; +} + +int agi_v3_deinit() { + int ec = err_OK; + +#if 0 + /* unload words */ + agi_v3_unload_words(); + + /* unload objects */ + agi_v3_unload_objects(); +#endif + + return ec; +} + +int agi_v3_unload_resource(int t, int n) { + switch (t) { + case rLOGIC: + unload_logic(n); + break; + case rPICTURE: + unload_picture(n); + break; + case rVIEW: + unload_view(n); + break; + case rSOUND: + unload_sound(n); + break; + } + + return err_OK; +} + +/* + * This function does noting but load a raw resource into memory. + * If further decoding is required, it must be done by another + * routine. + * + * NULL is returned if unsucsessful. + */ +uint8 *agi_v3_load_vol_res(struct agi_dir *agid) { + char x[MAX_PATH]; + uint8 *data = NULL, *comp_buffer; + Common::File fp; + Common::String path; + + debugC(3, kDebugLevelResources, "(%p)", agid); + sprintf(x, "vol.%i", agid->volume); + path = Common::String(game.name) + x; + + if (agid->offset != _EMPTY && fp.open(path)) { + fp.seek(agid->offset, SEEK_SET); + fp.read(&x, 7); + + if (READ_BE_UINT16((uint8 *) x) != 0x1234) { +#if 0 + /* FIXME */ + deinit_video_mode(); +#endif + debugC(3, kDebugLevelResources, "path = %s", path.c_str()); + debugC(3, kDebugLevelResources, "offset = %d", agid->offset); + debugC(3, kDebugLevelResources, "x = %x %x", x[0], x[1]); + error("ACK! BAD RESOURCE"); + + g_system->quit(); + } + + agid->len = READ_LE_UINT16((uint8 *) x + 3); /* uncompressed size */ + agid->clen = READ_LE_UINT16((uint8 *) x + 5); /* compressed len */ + + comp_buffer = (uint8 *)calloc(1, agid->clen + 32); + fp.read(comp_buffer, agid->clen); + + if (x[2] & 0x80 || agid->len == agid->clen) { + /* do not decompress */ + data = comp_buffer; + +#if 0 + /* CM: added to avoid problems in + * convert_v2_v3_pic() when clen > len + * e.g. Sierra demo 4, first picture + * (Tue Mar 16 13:13:43 EST 1999) + */ + agid->len = agid->clen; + + /* Now removed to fix Gold Rush! in demo4 */ +#endif + } else { + /* it is compressed */ + data = (uint8 *)calloc(1, agid->len + 32); + LZW_expand(comp_buffer, data, agid->len); + free(comp_buffer); + agid->flags |= RES_COMPRESSED; + } + + fp.close(); + } else { + /* we have a bad volume resource */ + /* set that resource to NA */ + agid->offset = _EMPTY; + } + + return data; +} + +/* + * Loads a resource into memory, a raw resource is loaded in + * with above routine, then further decoded here. + */ +int agi_v3_load_resource(int t, int n) { + int ec = err_OK; + uint8 *data = NULL; + + if (n > MAX_DIRS) + return err_BadResource; + + switch (t) { + case rLOGIC: + /* load resource into memory, decrypt messages at the end + * and build the message list (if logic is in memory) + */ + if (~game.dir_logic[n].flags & RES_LOADED) { + /* if logic is already in memory, unload it */ + agi_v3.unload_resource(rLOGIC, n); + + /* load raw resource into data */ + data = agi_v3_load_vol_res(&game.dir_logic[n]); + game.logics[n].data = data; + + /* uncompressed logic files need to be decrypted */ + if (data != NULL) { + /* resloaded flag gets set by decode logic */ + /* needed to build string table */ + ec = decode_logic(n); + game.logics[n].sIP = 2; + } else { + ec = err_BadResource; + } + + /*logics[n].sIP=2; *//* saved IP = 2 */ + /*logics[n].cIP=2; *//* current IP = 2 */ + + game.logics[n].cIP = game.logics[n].sIP; + } + + /* if logic was cached, we get here */ + /* reset code pointers incase it was cached */ + + game.logics[n].cIP = game.logics[n].sIP; + break; + case rPICTURE: + /* if picture is currently NOT loaded *OR* cacheing is off, + * unload the resource (caching==off) and reload it + */ + if (~game.dir_pic[n].flags & RES_LOADED) { + agi_v3.unload_resource(rPICTURE, n); + data = agi_v3_load_vol_res(&game.dir_pic[n]); + if (data != NULL) { + data = convert_v3_pic(data, game.dir_pic[n].len); + game.pictures[n].rdata = data; + game.dir_pic[n].flags |= RES_LOADED; + } else { + ec = err_BadResource; + } + } + break; + case rSOUND: + if (game.dir_sound[n].flags & RES_LOADED) + break; + + if ((data = agi_v3_load_vol_res(&game.dir_sound[n])) != NULL) { + game.sounds[n].rdata = data; + game.dir_sound[n].flags |= RES_LOADED; + decode_sound(n); + } else { + ec = err_BadResource; + } + break; + case rVIEW: + /* Load a VIEW resource into memory... + * Since VIEWS alter the view table ALL the time can we + * cache the view? or must we reload it all the time? + */ + /* load a raw view from a VOL file into data */ + if (game.dir_view[n].flags & RES_LOADED) + break; + + agi_v3.unload_resource(rVIEW, n); + if ((data = agi_v3_load_vol_res(&game.dir_view[n])) != NULL) { + game.views[n].rdata = data; + game.dir_view[n].flags |= RES_LOADED; + ec = decode_view(n); + } else { + ec = err_BadResource; + } + break; + default: + ec = err_BadResource; + break; + } + + return ec; +} + +static int agi_v3_load_objects(char *fname) { + return load_objects(fname); +} + +static int agi_v3_load_words(char *fname) { + return load_words(fname); +} + +} // End of namespace Agi diff --git a/engines/agi/checks.cpp b/engines/agi/checks.cpp new file mode 100644 index 0000000000..1042ef1579 --- /dev/null +++ b/engines/agi/checks.cpp @@ -0,0 +1,320 @@ +/* ScummVM - Scumm Interpreter + * Copyright (C) 2006 The ScummVM project + * + * Copyright (C) 1999-2001 Sarien Team + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + * $URL$ + * $Id$ + * + */ + +#include "common/stdafx.h" +#include "agi/agi.h" + +namespace Agi { + +static int check_position(struct vt_entry *v) { + debugC(4, kDebugLevelSprites, "check position @ %d, %d", v->x_pos, v->y_pos); + + if (v->x_pos < 0 || + v->x_pos + v->x_size > _WIDTH || + v->y_pos - v->y_size + 1 < 0 || + v->y_pos >= _HEIGHT || + ((~v->flags & IGNORE_HORIZON) && v->y_pos <= game.horizon)) { + debugC(4, kDebugLevelSprites, "check position failed: x=%d, y=%d, h=%d, w=%d", + v->x_pos, v->y_pos, v->x_size, v->y_size); + return 0; + } + + /* MH1 needs this, but it breaks LSL1 */ + if (agi_get_release() >= 0x3000) { + if (v->y_pos < v->y_size) + return 0; + } + + return 1; +} + +/** + * Check if there's another object on the way + */ +static int check_collision(struct vt_entry *v) { + struct vt_entry *u; + + if (v->flags & IGNORE_OBJECTS) + return 0; + + for (u = game.view_table; u < &game.view_table[MAX_VIEWTABLE]; u++) { + if ((u->flags & (ANIMATED | DRAWN)) != (ANIMATED | DRAWN)) + continue; + + if (u->flags & IGNORE_OBJECTS) + continue; + + /* Same object, check next */ + if (v->entry == u->entry) + continue; + + /* No horizontal overlap, check next */ + if (v->x_pos + v->x_size < u->x_pos || + v->x_pos > u->x_pos + u->x_size) + continue; + + /* Same y, return error! */ + if (v->y_pos == u->y_pos) + goto return_1; + + /* Crossed the baseline, return error! */ + if ((v->y_pos > u->y_pos && v->y_pos2 < u->y_pos2) || + (v->y_pos < u->y_pos && v->y_pos2 > u->y_pos2)) { + goto return_1; + } + } + + return 0; + + return_1: + debugC(4, kDebugLevelSprites, "check returns 1 (object %d)", v->entry); + return 1; +} + +static int check_priority(struct vt_entry *v) { + int i, trigger, water, pass, pri; + uint8 *p0; + + if (~v->flags & FIXED_PRIORITY) { + /* Priority bands */ + v->priority = game.pri_table[v->y_pos]; + } + + trigger = 0; + water = 0; + pass = 1; + + if (v->priority == 0x0f) + goto _check_ego; + + water = 1; + + p0 = &game.sbuf[v->x_pos + v->y_pos * _WIDTH]; + + for (i = 0; i < v->x_size; i++, p0++) { + pri = *p0 >> 4; + + if (pri == 0) { /* unconditional black. no go at all! */ + pass = 0; + break; + } + + if (pri == 3) /* water surface */ + continue; + + water = 0; + + if (pri == 1) { /* conditional blue */ + if (v->flags & IGNORE_BLOCKS) + continue; + + debugC(4, kDebugLevelSprites, "Blocks observed!"); + pass = 0; + break; + } + + if (pri == 2) { /* trigger */ + debugC(4, kDebugLevelSprites, "stepped on trigger"); +#ifdef USE_CONSOLE + if (!debug_.ignoretriggers) +#endif + trigger = 1; + } + } + + if (pass) { + if (!water && v->flags & ON_WATER) + pass = 0; + if (water && v->flags & ON_LAND) + pass = 0; + } + + _check_ego: + if (v->entry == 0) { + setflag(F_ego_touched_p2, trigger ? true : false); + setflag(F_ego_water, water ? true : false); + } + + return pass; +} + +/* + * Public functions + */ + +/** + * Update position of objects + * This function updates the position of all animated, updating view + * table entries according to its motion type, step size, etc. The + * new position must be valid according to the sprite positioning + * rules, otherwise the previous position will be kept. + */ +void update_position() { + struct vt_entry *v; + int x, y, old_x, old_y, border; + + game.vars[V_border_code] = 0; + game.vars[V_border_touch_ego] = 0; + game.vars[V_border_touch_obj] = 0; + + for (v = game.view_table; v < &game.view_table[MAX_VIEWTABLE]; v++) { + if ((v->flags & (ANIMATED | UPDATE | DRAWN)) != (ANIMATED | UPDATE | DRAWN)) { + continue; + } + + if (v->step_time_count != 0) { + if (--v->step_time_count != 0) + continue; + } + + v->step_time_count = v->step_time; + + x = old_x = v->x_pos; + y = old_y = v->y_pos; + + /* If object has moved, update its position */ + if (~v->flags & UPDATE_POS) { + int dx[9] = { 0, 0, 1, 1, 1, 0, -1, -1, -1 }; + int dy[9] = { 0, -1, -1, 0, 1, 1, 1, 0, -1 }; + x += v->step_size * dx[v->direction]; + y += v->step_size * dy[v->direction]; + } + + /* Now check if it touched the borders */ + border = 0; + + /* Check left/right borders */ + if (x < 0) { + x = 0; + border = 4; + } else if (x <= 0 && agi_get_release() == 0x3086) { /* KQ4 */ + x = 0; /* See bug #590462 */ + border = 4; + } else if (v->entry == 0 && x == 0 && v->flags & ADJ_EGO_XY) { + /* Extra test to walk west clicking the mouse */ + x = 0; + border = 4; + } else if (x + v->x_size > _WIDTH) { + x = _WIDTH - v->x_size; + border = 2; + } + + /* Check top/bottom borders. */ + if (y - v->y_size + 1 < 0) { + y = v->y_size - 1; + border = 1; + } else if (y > _HEIGHT - 1) { + y = _HEIGHT - 1; + border = 3; + } else if ((~v->flags & IGNORE_HORIZON) && y <= game.horizon) { + debugC(4, kDebugLevelSprites, "y = %d, horizon = %d", y, game.horizon); + y = game.horizon + 1; + border = 1; + } + + /* Test new position. rollback if test fails */ + v->x_pos = x; + v->y_pos = y; + if (check_collision(v) || !check_priority(v)) { + v->x_pos = old_x; + v->y_pos = old_y; + border = 0; + fix_position(v->entry); + } + + if (border != 0) { + if (v == game.view_table) { + game.vars[V_border_touch_ego] = border; + } else { + game.vars[V_border_code] = v->entry; + game.vars[V_border_touch_obj] = border; + } + if (v->motion == MOTION_MOVE_OBJ) { + in_destination(v); + } + } + + v->flags &= ~UPDATE_POS; + } +} + +/** + * Adjust position of a sprite + * This function adjusts the position of a sprite moving it until + * certain criteria is matched. According to priority and control line + * data, a sprite may not always appear at the location we specified. + * This behaviour is also known as the "Budin-Sonneveld effect". + * + * @param n view table entry number + */ +void fix_position(int n) { + struct vt_entry *v = &game.view_table[n]; + int count, dir, size; + + debugC(4, kDebugLevelSprites, "adjusting view table entry #%d (%d,%d)", n, v->x_pos, v->y_pos); + + /* test horizon */ + if ((~v->flags & IGNORE_HORIZON) && v->y_pos <= game.horizon) + v->y_pos = game.horizon + 1; + + dir = 0; + count = size = 1; + + while (!check_position(v) || check_collision(v) || !check_priority(v)) { + switch (dir) { + case 0: /* west */ + v->x_pos--; + if (--count) + continue; + dir = 1; + break; + case 1: /* south */ + v->y_pos++; + if (--count) + continue; + dir = 2; + size++; + break; + case 2: /* east */ + v->x_pos++; + if (--count) + continue; + dir = 3; + break; + case 3: /* north */ + v->y_pos--; + if (--count) + continue; + dir = 0; + size++; + break; + } + + count = size; + } + + debugC(4, kDebugLevelSprites, "view table entry #%d position adjusted to (%d,%d)", n, v->x_pos, v->y_pos); +} + +} // End of namespace Agi diff --git a/engines/agi/console.cpp b/engines/agi/console.cpp new file mode 100644 index 0000000000..cbfa8b2b08 --- /dev/null +++ b/engines/agi/console.cpp @@ -0,0 +1,873 @@ +/* ScummVM - Scumm Interpreter + * Copyright (C) 2006 The ScummVM project + * + * Copyright (C) 1999-2002 Sarien Team + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + * $URL$ + * $Id$ + * + */ + +#include "common/stdafx.h" + +#include "agi/agi.h" +#include "agi/graphics.h" +#include "agi/sprite.h" +#include "agi/text.h" +#include "agi/keyboard.h" +#include "agi/opcodes.h" +#include "agi/console.h" + +namespace Agi { + +#ifdef USE_CONSOLE + +/* + * The main interpreter engine has not been designed to have a console, and a few + * kludges were needed to make the console work. First of all, the main + * interpreter loop works at cycle level, not instruction level. To keep + * the illusion that the console is threaded, a console updating function + * is called from loops inside instructions such as get.string(). + */ + +#define CONSOLE_LINES_ONSCREEN 20 +#define CONSOLE_PROMPT "$" +#define CONSOLE_CURSOR_HOLLOW 1 +#define CONSOLE_CURSOR_SOLID 2 +#define CONSOLE_CURSOR_EMPTY 3 +#define CONSOLE_COLOR 14 +#define CONSOLE_SCROLLUP_KEY KEY_PGUP +#define CONSOLE_SCROLLDN_KEY KEY_PGDN +#define CONSOLE_START_KEY KEY_HOME +#define CONSOLE_END_KEY KEY_END +#define CONSOLE_INPUT_SIZE 39 + +struct console_command { + char cmd[8]; + char dsc[40]; + void (*handler) (void); +}; + +struct agi_console console; +struct agi_debug debug_; + +/* This used to be a linked list, but we reduce total memory footprint + * by implementing it as a statically allocated array. + */ +#define MAX_CCMD 16 +static struct console_command ccmd_list[MAX_CCMD]; +static int num_ccmd = 0; + +static uint8 has_console = 0; +static uint8 console_input = 0; + +static char *_p0, *_p1, *_p2, *_p3, *_p4, *_p5; /* FIXME: array */ +static char _p[80]; +static int _pn; + +/* + * Console line management + */ + +static int first_line = 0; + +static void add_console_line(char *s) { + int last_line; + + last_line = (CONSOLE_LINES_BUFFER - 1 + first_line) % CONSOLE_LINES_BUFFER; + + strncpy(console.line[last_line], s, CONSOLE_LINE_SIZE); + first_line %= CONSOLE_LINES_BUFFER; +} + +static char *get_console_line(int n) { + return console.line[(n + first_line) % CONSOLE_LINES_BUFFER]; +} + +static char *get_last_console_line() { + int last_line = (CONSOLE_LINES_BUFFER - 1 + first_line) % CONSOLE_LINES_BUFFER; + + return console.line[last_line]; +} + +/* + * Console command parsing + * 'o' commands added by Shaun Jackman <sjackman@shaw.ca>, 11 Apr 2002 + */ + +static int console_parse(char *b) { + struct console_command *d; + int i; + + for (; *b && *b == ' '; b++) { + } /* eat spaces */ + for (; *b && b[strlen(b) - 1] == ' '; b[strlen(b) - 1] = 0) { + } + if (!*b) + return 0; + + /* get or set flag/var/obj values */ + if ((b[0] == 'f' || b[0] == 'v' || b[0] == 'o') && isdigit(b[1])) { + char *e; + int f = (int)strtoul(&b[1], &e, 10); + if (*e == 0) { + if (f >= 0 && f <= 255) { + switch (b[0]) { + case 'f': + report(getflag(f) ? "true\n" : "false\n"); + break; + case 'v': + report("%3d\n", getvar(f)); + break; + case 'o': + report("%3d]%-24s(%3d)\n", f, object_name(f), object_get_location(f)); + break; + } + return 0; + } + return -1; + } else if (*e == '=') { + int n = (int)strtoul(e + 1, NULL, 0); + switch (b[0]) { + case 'f': + setflag(f, !!n); + break; + case 'v': + setvar(f, n); + break; + case 'o': + object_set_location(f, n); + break; + } + return 0; + } + } + + /* tokenize the input line */ + if (strchr(b, ' ')) + strcpy(_p, strchr(b, ' ') + 1); + _p0 = strtok(b, " "); + _p1 = strtok(NULL, " "); + _p2 = strtok(NULL, " "); + _p3 = strtok(NULL, " "); + _p4 = strtok(NULL, " "); + _p5 = strtok(NULL, " "); + + /* set number of parameters. ugh, must rewrite this later */ + _pn = 5; + if (!_p5) + _pn = 4; + if (!_p4) + _pn = 3; + if (!_p3) + _pn = 2; + if (!_p2) + _pn = 1; + if (!_p1) + _pn = 0; + + debugC(5, kDebugLevelMain, "number of parameters: %d", _pn); + + for (i = 0; i < num_ccmd; i++) { + d = &ccmd_list[i]; + if (!strcmp(_p0, d->cmd) && d->handler) { + d->handler(); + return 0; + } + } + + for (i = 0; logic_names_cmd[i].name; i++) { + if (!strcmp(_p0, logic_names_cmd[i].name)) { + uint8 p[16]; + if (_pn != logic_names_cmd[i].num_args) { + report("AGI command wants %d arguments\n", logic_names_cmd[i].num_args); + return 0; + } + p[0] = _p1 ? (char)strtoul(_p1, NULL, 0) : 0; + p[1] = _p2 ? (char)strtoul(_p2, NULL, 0) : 0; + p[2] = _p3 ? (char)strtoul(_p3, NULL, 0) : 0; + p[3] = _p4 ? (char)strtoul(_p4, NULL, 0) : 0; + p[4] = _p5 ? (char)strtoul(_p5, NULL, 0) : 0; + + debugC(5, kDebugLevelMain, "ccmd: %s %d %d %d", logic_names_cmd[i].name, p[0], p[1], p[2]); + + execute_agi_command(i, p); + + return 0; + } + } + + return -1; +} + +/* + * Console commands + */ + +static void ccmd_help() { + int i; + + if (!_p1) { + report("Command Description\n"); + report("------- --------------------------------\n"); + for (i = 0; i < num_ccmd; i++) + report("%-8s%s\n", ccmd_list[i].cmd, ccmd_list[i].dsc); + return; + } + + for (i = 0; i < num_ccmd; i++) { + if (!strcmp(ccmd_list[i].cmd, _p1) && ccmd_list[i].handler) { + report("%s\n", ccmd_list[i].dsc); + return; + } + } + + report("Unknown command or no help available\n"); + + return; +} + +static void ccmd_ver() { + report(VERSION "\n"); + return; +} + +static void ccmd_crc() { + char name[80]; + report("0x%05x\n", game.crc); + if (match_crc(game.crc, name, 80)) + report("%s\n", name); + else + report("Unknown game\n"); + return; +} + +static void ccmd_quit() { + deinit_video(); + /* deinit_machine (); */ + exit(0); +} + +#if 0 +static void ccmd_exec() { + if (game.state < STATE_LOADED) { + report("No game loaded.\n"); + return; + } + + if (game.state >= STATE_RUNNING) { + report("Game already running.\n"); + return; + } + + report("Executing AGI game.\n"); + game.state = STATE_RUNNING; +} +#endif + +#ifdef USE_HIRES + +static void ccmd_hires() { + if (_pn != 1 || (strcmp(_p1, "on") && strcmp(_p1, "off"))) { + report("Usage: hires on|off\n"); + return; + } + + opt.hires = !strcmp(_p1, "on"); + erase_both(); + show_pic(); + blit_both(); + return; +} + +#endif + +static void ccmd_agiver() { + int ver, maj, min; + + ver = agi_get_release(); + maj = (ver >> 12) & 0xf; + min = ver & 0xfff; + + report(maj <= 2 ? "%x.%03x\n" : "%x.002.%03x\n", maj, min); + return; +} + +static void ccmd_flags() { + int i, j; + + report(" "); + for (j = 0; j < 10; j++) + report("%d ", j); + report("\n"); + + for (i = 0; i < 255;) { + report("%3d ", i); + for (j = 0; j < 10; j++, i++) { + report("%c ", getflag(i) ? 'T' : 'F'); + } + report("\n"); + } + return; +} + +static void ccmd_vars() { + int i, j; + + for (i = 0; i < 255;) { + for (j = 0; j < 5; j++, i++) { + report("%03d:%3d ", i, getvar(i)); + } + report("\n"); + } + return; +} + +#if 0 + +static void ccmd_say() { + setflag(F_entered_cli, true); + dictionary_words(_p); +} + +static void ccmd_inv() { + unsigned int i, j; + + for (j = i = 0; i < game.num_objects; i++) { + if (object_get_location(i) == EGO_OWNED) { + report("%3d]%-16.16s", i, object_name(i)); + if (j % 2) + report("\n"); + j++; + } + } + if (j == 0) { + report("none\n"); + return; + } + if (j % 2) + report("\n"); +} + +#endif + +static void ccmd_objs() { + unsigned int i; + + for (i = 0; i < game.num_objects; i++) { + report("%3d]%-24s(%3d)\n", i, object_name(i), object_get_location(i)); + } + return; +} + +static void ccmd_opcode() { + if (_pn != 1 || (strcmp(_p1, "on") && strcmp(_p1, "off"))) { + report("Usage: opcode on|off\n"); + return; + } + + debug_.opcodes = !strcmp(_p1, "on"); + return; +} + +static void ccmd_logic0() { + if (_pn != 1 || (strcmp(_p1, "on") && strcmp(_p1, "off"))) { + report("Usage: logic0 on|off\n"); + return; + } + + debug_.logic0 = !strcmp(_p1, "on"); + return; +} + +static void ccmd_trigger() { + if (_pn != 1 || (strcmp(_p1, "on") && strcmp(_p1, "off"))) { + report("Usage: trigger on|off\n"); + return; + } + + debug_.ignoretriggers = strcmp(_p1, "on"); + return; +} + +static void ccmd_step() { + debug_.enabled = 1; + + if (_pn == 0) { + debug_.steps = 1; + return; + } + + debug_.steps = strtoul(_p1, NULL, 0); + return; +} + +static void ccmd_debug() { + debug_.enabled = 1; + debug_.steps = 0; + return; +} + +static void ccmd_cont() { + debug_.enabled = 0; + debug_.steps = 0; + return; +} + +/* + * Register console commands + */ +static void console_cmd(char *cmd, char *dsc, void (*handler) (void)) { + assert(num_ccmd < MAX_CCMD); + + strcpy(ccmd_list[num_ccmd].cmd, cmd); + strcpy(ccmd_list[num_ccmd].dsc, dsc); + ccmd_list[num_ccmd].handler = handler; + + num_ccmd++; +} + +/* Console reporting */ + +/* A slightly modified strtok() for report() */ +static char *get_token(char *s, char d) { + static char *x; + char *n, *m; + + if (s) + x = s; + + m = x; + n = strchr(x, d); + + if (n) { + *n = 0; + x = n + 1; + } else { + x = strchr(x, 0); + } + + return m; +} + +static void build_console_lines(int n) { + int j, y1; + char *line; + + clear_console_screen(GFX_HEIGHT - n * 10); + + for (j = CONSOLE_LINES_ONSCREEN - n; j < CONSOLE_LINES_ONSCREEN; j++) { + line = get_console_line(console.first_line + j); + print_text_console(line, 0, j, strlen(line) + 1, CONSOLE_COLOR, 0); + } + + y1 = console.y - n * 10; + if (y1 < 0) + y1 = 0; + + /* CM: + * This will cause blinking when using menus+console, but this + * function is called by report() which can be called from any + * point with or without sprites placed. If we protect the + * flush_block() call with redraw/release sprites cloning will + * happen when activating the console. This could be fixed by + * keeping a control flag in redraw/release to not do the + * actions twice, but I don't want to do that -- not yet. + */ + flush_block(0, y1, GFX_WIDTH - 1, console.y); +} + +/* + * Public functions + */ + +int console_init() { + console_cmd("agiver", "Show emulated Sierra AGI version", ccmd_agiver); + console_cmd("cont", "Resume interpreter execution", ccmd_cont); + console_cmd("debug", "Stop interpreter execution", ccmd_debug); + console_cmd("crc", "Show AGI game CRC", ccmd_crc); +#if 0 + console_cmd("exec", "Execute loaded AGI game", ccmd_exec); +#endif + console_cmd("flags", "Dump all AGI flags", ccmd_flags); + console_cmd("help", "List available commands", ccmd_help); +#ifdef USE_HIRES + console_cmd("hires", "Turn hi-res mode on/off", ccmd_hires); +#endif + console_cmd("logic0", "Turn logic 0 debugging on/off", ccmd_logic0); + console_cmd("objs", "List all objects and locations", ccmd_objs); + console_cmd("opcode", "Turn opcodes on/off in debug", ccmd_opcode); + console_cmd("quit", "Quit the interpreter", ccmd_quit); +#if 0 + console_cmd("inv", "List current inventory", ccmd_inv); + console_cmd("say", "Pass argument to the AGI parser", ccmd_say); +#endif + console_cmd("step", "Execute the next AGI instruction", ccmd_step); + console_cmd("trigger", "Turn trigger lines on/off", ccmd_trigger); + console_cmd("vars", "Dump all AGI variables", ccmd_vars); + console_cmd("ver", "Show interpreter version", ccmd_ver); + + console.active = 1; + console.input_active = 1; + console.index = 0; + console.max_y = 150; + console.y = console.max_y; + console.first_line = CONSOLE_LINES_BUFFER - CONSOLE_LINES_ONSCREEN; + + debug_.enabled = 0; + debug_.opcodes = 0; + debug_.logic0 = 1; + debug_.priority = 0; + + has_console = 1; + clear_screen(0); + + return err_OK; +} + +static void build_console_layer() { + build_console_lines(console.max_y / 10); +} + +void report(char *message, ...) { + char x[512], y[512], z[64], *msg, *n; + va_list args; + int i, s, len; + + if (!has_console) + return; + + va_start(args, message); +#ifdef HAVE_VSNPRINTF + vsnprintf(y, 510, (char *)message, args); +#else + vsprintf(y, (char *)message, args); +#endif + va_end(args); + + if (console_input) { + strcpy(z, get_last_console_line()); + strcpy(x, ">"); + } else { + strcpy(x, get_last_console_line()); + } + + strcat(x, y); + + len = 40; + msg = n = word_wrap_string(x, &len); + + for (s = 1; *n; n++) + if (*n == '\n') + s++; + + add_console_line(get_token(msg, '\n')); + for (i = 1; i < s; i++) { + first_line++; + n = get_token(NULL, '\n'); + add_console_line(n); + } + + console.first_line = CONSOLE_LINES_BUFFER - CONSOLE_LINES_ONSCREEN; + + if (console_input) { + add_console_line(z); + } + + /* Build layer */ + if (console.y) { + if (s > 1) + build_console_layer(); + else + build_console_lines(1); + } + + free(msg); + + do_update(); +} + +void console_cycle() { + static int old_y = 0; + static int blink = 0; + static char cursor[] = " "; + + /* If no game has been loaded, keep the console visible! */ + if (game.state < STATE_RUNNING) { + console.active = 1; + console.count = 10; + } + + /* Initial console auto-hide timer */ + if (console.count > 0) + console.count--; + if (console.count == 0) { + console.active = 0; + console.count = -1; + } + + if (console.active) { + if (console.y < console.max_y) + console.y += 15; + else + console.y = console.max_y; + } else { + console.count = -1; + + if (console.y > 0) + console.y -= 15; + else + console.y = 0; + } + + /* console shading animation */ + if (old_y != console.y) { + int y = console.y; + if (old_y > console.y) { + /* going up */ + y = old_y; + } + flush_block(0, 0, GFX_WIDTH - 1, y); + old_y = console.y; + } + + blink++; + blink %= 16; + if (console.input_active) { + *cursor = blink < 8 ? + CONSOLE_CURSOR_SOLID : CONSOLE_CURSOR_EMPTY; + } else { + *cursor = CONSOLE_CURSOR_HOLLOW; + } + if (console.y > 0 + && console.first_line == + CONSOLE_LINES_BUFFER - CONSOLE_LINES_ONSCREEN) { + int16 y1 = console.y - 10, y2 = console.y - 1; + if (y1 < 0) + y1 = 0; + if (y2 < 0) + y2 = 0; + print_text_console(cursor, (1 + console.index), 19, 2, CONSOLE_COLOR, 0); + flush_block((1 + console.index) * 8, y1, (1 + console.index) * 8 + 7, y2 - 1); + } + + do_update(); +} + +/* Return true if key was handled */ +int console_keyhandler(int k) { + static char buffer[CONSOLE_INPUT_SIZE]; + int16 y1, y2; + char m[2]; + +#ifdef USE_MOUSE + /* Right button switches console on/off */ + if (!opt.agimouse) /* AGI Mouse uses right button */ + if (k == BUTTON_RIGHT) + k = CONSOLE_ACTIVATE_KEY; +#endif + + if (!console.active) { + if (k == CONSOLE_ACTIVATE_KEY) { + console.active = 1; + return true; + } + return false; + } + + if (!console.input_active) { + if (k == CONSOLE_SWITCH_KEY) { + console.input_active = 1; + return true; + } + if (k == CONSOLE_ACTIVATE_KEY) { + console.active = 0; + return true; + } + return false; + } + + y1 = console.y - 10; + y2 = console.y - 1; + + if (y1 < 0) + y1 = 0; + if (y2 < 0) + y2 = 0; + +#ifdef USE_MOUSE + /* Ignore left button in console */ + if (k == BUTTON_LEFT) + return true; +#endif + + /* this code breaks scrolling up, maybe it shoud only be executed + * in the default case? + */ + if (k) { + /* make sure it's not enter or a scroll key */ + if ((k != KEY_ENTER) && (k != CONSOLE_SCROLLUP_KEY) && (k != CONSOLE_SCROLLDN_KEY) + && (k != CONSOLE_START_KEY)) { + /* on any other input reset the console to the bottom */ + if (console.first_line != CONSOLE_LINES_BUFFER - CONSOLE_LINES_ONSCREEN) { + console.first_line = CONSOLE_LINES_BUFFER - CONSOLE_LINES_ONSCREEN; + build_console_layer(); + } + console.count = -1; + } + } + + switch (k) { + case KEY_ENTER: + console_lock(); + console.index = 0; + report("\n"); + + if (console_parse(buffer) != 0) + report("What? Where?\n"); + + buffer[0] = 0; + console_prompt(); + break; + case KEY_BACKSPACE:{ + char *x; + if (!console.index) + break; + x = get_last_console_line(); + x[console.index] = 0; + *m = CONSOLE_CURSOR_EMPTY; + print_text_console(m, (console.index + 1), 19, 2, CONSOLE_COLOR, 0); + flush_block((console.index + 1) * CHAR_COLS, y1, (console.index + 1 + 1) * CHAR_COLS - 1, y2); + console.index--; + buffer[console.index] = 0; + } + break; + case CONSOLE_ACTIVATE_KEY: + console.active = !console.active; + if (console.active) + build_console_layer(); + break; + case CONSOLE_SWITCH_KEY: + console.count = -1; + if (console.y) + console.input_active = !console.input_active; + break; + case CONSOLE_SCROLLUP_KEY: + console.count = -1; + if (!console.y) + break; + if (console.first_line > (CONSOLE_LINES_ONSCREEN / 2)) + console.first_line -= CONSOLE_LINES_ONSCREEN / 2; + else + console.first_line = 0; + build_console_layer(); + break; + case CONSOLE_SCROLLDN_KEY: + console.count = -1; + if (!console.y) + break; + if (console.first_line < (CONSOLE_LINES_BUFFER - CONSOLE_LINES_ONSCREEN - CONSOLE_LINES_ONSCREEN / 2)) + console.first_line += CONSOLE_LINES_ONSCREEN / 2; + else + console.first_line = CONSOLE_LINES_BUFFER - CONSOLE_LINES_ONSCREEN; + build_console_layer(); + break; + case CONSOLE_START_KEY: + console.count = -1; + if (console.y) + console.first_line = 0; + break; + case CONSOLE_END_KEY: + console.count = -1; + if (console.y) + console.first_line = CONSOLE_LINES_BUFFER - CONSOLE_LINES_ONSCREEN; + break; + default: + if (k >= 0x20 && k <= 0x7f && (console.index < CONSOLE_INPUT_SIZE - 2)) { + char l[42]; + buffer[console.index] = k; + *m = k; + m[1] = 0; + console.index++; + + sprintf(l, "%s%c", get_last_console_line(), k); + strncpy(get_last_console_line(), l, CONSOLE_LINE_SIZE); + + buffer[console.index] = 0; + print_text_console(m, console.index, 19, 2, CONSOLE_COLOR, 0); + flush_block(console.index * 8, y1, console.index * 8 + 7, y2); + } + break; + } + + do_update(); + + return true; +} + +void console_prompt() { + report(CONSOLE_PROMPT); + console_input = 1; +} + +void console_lock() { + console_input = 0; +} + +#else + +void *debug; + +void report(char *message, ...) { + /* dummy */ +} + +int console_init() { + return 0; +} + +/* Date: Sun, 14 Oct 2001 23:02:02 -0700 + * From: Vasyl Tsvirkunov <vasyl@pacbell.net> + * + * This one was rather harmless and affected only builds without console. + * In SQ1&2 (and likely some others) name entry screen did not update + * properly. The bug caused by implicit assumption in cycle.c that + * console_cycle() updates the screen. Well, it does, if console is enabled. + * The fix is simple. In the second version of console_cycle() in console.c + * (the "dummy" one) add call to do_update(). The thing raises some + * questions about overall architecture of main cycle, but otherwise the fix + * works just fine. + */ +void console_cycle() { + do_update(); +} + +void console_lock() { + /* dummy */ +} + +void console_prompt() { + /* dummy */ +} + +int console_keyhandler(int i) { + return false; +} + +#endif /* USE_CONSOLE */ + +} // End of namespace Agi diff --git a/engines/agi/console.h b/engines/agi/console.h new file mode 100644 index 0000000000..1a211f9826 --- /dev/null +++ b/engines/agi/console.h @@ -0,0 +1,71 @@ +/* ScummVM - Scumm Interpreter + * Copyright (C) 2006 The ScummVM project + * + * Copyright (C) 1999-2001 Sarien Team + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + * $URL$ + * $Id$ + * + */ + +#ifndef __AGI_CONSOLE_H +#define __AGI_CONSOLE_H + +namespace Agi { + +#ifdef USE_CONSOLE + +#define CONSOLE_LINES_BUFFER 80 +#define CONSOLE_LINE_SIZE (GFX_WIDTH / 8) +#define CONSOLE_ACTIVATE_KEY '`' +#define CONSOLE_SWITCH_KEY '~' + +struct agi_console { + int active; + int input_active; + int index; + int y; + int max_y; + int first_line; + int count; + char *line[CONSOLE_LINES_BUFFER]; +}; + +struct agi_debug { + int enabled; + int opcodes; + int logic0; + int steps; + int priority; + int statusline; + int ignoretriggers; +}; + +extern struct agi_console console; + +#endif /* USE_CONSOLE */ + +int console_keyhandler(int); +int console_init(void); +void console_cycle(void); +void console_lock(void); +void console_prompt(void); +void report(char *, ...); + +} // End of namespace Agi + +#endif /* __AGI_CONSOLE_H */ diff --git a/engines/agi/cycle.cpp b/engines/agi/cycle.cpp new file mode 100644 index 0000000000..1c5365e4d1 --- /dev/null +++ b/engines/agi/cycle.cpp @@ -0,0 +1,423 @@ +/* ScummVM - Scumm Interpreter + * Copyright (C) 2006 The ScummVM project + * + * Copyright (C) 1999-2003 Sarien Team + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + * $URL$ + * $Id$ + * + */ + +#include "common/stdafx.h" + +#include "agi/agi.h" +#include "agi/text.h" +#include "agi/sprite.h" +#include "agi/graphics.h" +#include "agi/keyboard.h" +#include "agi/menu.h" +#include "agi/savegame.h" + +namespace Agi { + +#define TICK_SECONDS 20 + +#ifdef USE_MOUSE +struct mouse mouse; +#endif + +volatile uint32 clock_ticks; +volatile uint32 clock_count; + +/** + * Set up new room. + * This function is called when ego enters a new room. + * @param n room number + */ +void new_room(int n) { + struct vt_entry *v; + int i; + + debugC(4, kDebugLevelMain, "*** room %d ***", n); + stop_sound(); + + i = 0; + for (v = game.view_table; v < &game.view_table[MAX_VIEWTABLE]; v++) { + v->entry = i++; + v->flags &= ~(ANIMATED | DRAWN); + v->flags |= UPDATE; + v->step_time = 1; + v->step_time_count = 1; + v->cycle_time = 1; + v->cycle_time_count = 1; + v->step_size = 1; + } + agi_unload_resources(); + + game.player_control = true; + game.block.active = false; + game.horizon = 36; + game.vars[V_prev_room] = game.vars[V_cur_room]; + game.vars[V_cur_room] = n; + game.vars[V_border_touch_obj] = 0; + game.vars[V_border_code] = 0; + game.vars[V_ego_view_resource] = game.view_table[0].current_view; + + agi_load_resource(rLOGIC, n); + + /* Reposition ego in the new room */ + switch (game.vars[V_border_touch_ego]) { + case 1: + game.view_table[0].y_pos = _HEIGHT - 1; + break; + case 2: + game.view_table[0].x_pos = 0; + break; + case 3: + game.view_table[0].y_pos = HORIZON + 1; + break; + case 4: + game.view_table[0].x_pos = _WIDTH - game.view_table[0].x_size; + break; + } + + game.vars[V_border_touch_ego] = 0; + setflag(F_new_room_exec, true); + + game.exit_all_logics = true; + + write_status(); + write_prompt(); +} + +static void reset_controllers() { + int i; + + for (i = 0; i < MAX_DIRS; i++) { + game.ev_keyp[i].occured = false; + } +} + +static void interpret_cycle() { + int old_sound, old_score; + + if (game.player_control) + game.vars[V_ego_dir] = game.view_table[0].direction; + else + game.view_table[0].direction = game.vars[V_ego_dir]; + + check_all_motions(); + + old_score = game.vars[V_score]; + old_sound = getflag(F_sound_on); + + game.exit_all_logics = false; + while (run_logic(0) == 0 && !game.quit_prog_now) { + game.vars[V_word_not_found] = 0; + game.vars[V_border_touch_obj] = 0; + game.vars[V_border_code] = 0; + old_score = game.vars[V_score]; + setflag(F_entered_cli, false); + game.exit_all_logics = false; + reset_controllers(); + } + reset_controllers(); + + game.view_table[0].direction = game.vars[V_ego_dir]; + + if (game.vars[V_score] != old_score || getflag(F_sound_on) != old_sound) + write_status(); + + game.vars[V_border_touch_obj] = 0; + game.vars[V_border_code] = 0; + setflag(F_new_room_exec, false); + setflag(F_restart_game, false); + setflag(F_restore_just_ran, false); + + if (game.gfx_mode) { + update_viewtable(); + do_update(); + } +} + +/** + * Update AGI interpreter timer. + */ +void update_timer() { + clock_count++; + if (clock_count <= TICK_SECONDS) + return; + + clock_count -= TICK_SECONDS; + + if (!game.clock_enabled) + return; + + setvar(V_seconds, getvar(V_seconds) + 1); + if (getvar(V_seconds) < 60) + return; + + setvar(V_seconds, 0); + setvar(V_minutes, getvar(V_minutes) + 1); + if (getvar(V_minutes) < 60) + return; + + setvar(V_minutes, 0); + setvar(V_hours, getvar(V_hours) + 1); + if (getvar(V_hours) < 24) + return; + + setvar(V_hours, 0); + setvar(V_days, getvar(V_days) + 1); +} + +static int old_mode = -1; + +void new_input_mode(int i) { + old_mode = game.input_mode; + game.input_mode = i; +} + +void old_input_mode() { + game.input_mode = old_mode; +} + +/* If main_cycle returns false, don't process more events! */ +int main_cycle() { + unsigned int key, kascii; + struct vt_entry *v = &game.view_table[0]; + + poll_timer(); /* msdos driver -> does nothing */ + update_timer(); + + if (game.ver == 0) { + message_box("Warning: game CRC not listed, assuming AGI version 2.917."); + game.ver = -1; + } + + key = do_poll_keyboard(); + +#ifdef USE_MOUSE + /* In AGI Mouse emulation mode we must update the mouse-related + * vars in every interpreter cycle. + */ + if (opt.agimouse) { + game.vars[28] = mouse.x / 2; + game.vars[29] = mouse.y; + } +#endif + +#ifdef USE_CONSOLE + if (key == KEY_PRIORITY) { + erase_both(); + debug_.priority = !debug_.priority; + show_pic(); + blit_both(); + commit_both(); + key = 0; + } + + if (key == KEY_STATUSLN) { + debug_.statusline = !debug_.statusline; + write_status(); + key = 0; + } +#endif + + /* Click-to-walk mouse interface */ + if (game.player_control && v->flags & ADJ_EGO_XY) { + v->direction = get_direction(v->x_pos, v->y_pos, v->parm1, v->parm2, v->step_size); + + if (v->direction == 0) + in_destination(v); + } + + kascii = KEY_ASCII(key); + + if (!console_keyhandler(key)) { + if (kascii) + setvar(V_key, kascii); + process_key: + switch (game.input_mode) { + case INPUT_NORMAL: + if (!handle_controller(key)) { + if (key == 0 || !game.input_enabled) + break; + handle_keys(key); + + /* if ESC pressed, activate menu before + * accept.input from the interpreter cycle + * sets the input mode to normal again + * (closes: #540856) + */ + if (key == KEY_ESCAPE) { + key = 0; + goto process_key; + } + + /* commented out to close bug #438872 + * if (key) game.keypress = key; + */ + } + break; + case INPUT_GETSTRING: + handle_controller(key); + handle_getstring(key); + setvar(V_key, 0); /* clear ENTER key */ + break; + case INPUT_MENU: + menu_keyhandler(key); + console_cycle(); + return false; + case INPUT_NONE: + handle_controller(key); + if (key) + game.keypress = key; + break; + } + } else { + if (game.input_mode == INPUT_MENU) { + console_cycle(); + return false; + } + } + + console_cycle(); + + if (game.msg_box_ticks > 0) + game.msg_box_ticks--; + + return true; +} + +static int play_game() { + int ec = err_OK; + + debugC(2, kDebugLevelMain, "initializing..."); + debugC(2, kDebugLevelMain, "game.ver = 0x%x", game.ver); + + stop_sound(); + clear_screen(0); + + game.horizon = HORIZON; + game.player_control = false; + + setflag(F_logic_zero_firsttime, true); /* not in 2.917 */ + setflag(F_new_room_exec, true); /* needed for MUMG and SQ2! */ + setflag(F_sound_on, true); /* enable sound */ + setvar(V_time_delay, 2); /* "normal" speed */ + + game.gfx_mode = true; + game.quit_prog_now = false; + game.clock_enabled = true; + game.line_user_input = 22; + +#ifdef USE_MOUSE + if (opt.agimouse) + report("Using AGI Mouse 1.0 protocol\n"); +#endif + + report("Running AGI script.\n"); + +#ifdef USE_CONSOLE + console.count = 5; + console_prompt(); +#endif + + setflag(F_entered_cli, false); + setflag(F_said_accepted_input, false); + game.vars[V_word_not_found] = 0; + game.vars[V_key] = 0; + + debugC(2, kDebugLevelMain, "Entering main loop"); + do { + + if (!main_cycle()) + continue; + + if (getvar(V_time_delay) == 0 || + (1 + clock_count) % getvar(V_time_delay) == 0) { + if (!game.has_prompt && game.input_mode == INPUT_NORMAL) { + write_prompt(); + game.has_prompt = 1; + } else + if (game.has_prompt && game.input_mode == INPUT_NONE) { + write_prompt(); + game.has_prompt = 0; + } + + interpret_cycle(); + + setflag(F_entered_cli, false); + setflag(F_said_accepted_input, false); + game.vars[V_word_not_found] = 0; + game.vars[V_key] = 0; + } + + if (game.quit_prog_now == 0xff) + ec = err_RestartGame; + + } while (game.quit_prog_now == 0); + + stop_sound(); + + return ec; +} + +int run_game() { + int i, ec = err_OK; + +#ifdef USE_HIRES + if (opt.cgaemu) + opt.hires = 0; +#endif + + for (i = 0; i < MAX_DIRS; i++) + memset(&game.ev_keyp[i], 0, sizeof(struct agi_event)); + + /* Execute the game */ + do { + debugC(2, kDebugLevelMain, "game loop"); + debugC(2, kDebugLevelMain, "game.ver = 0x%x", game.ver); + + if (agi_init() != err_OK) + break; + if (ec == err_RestartGame) + setflag(F_restart_game, true); + + setvar(V_computer, 0); /* IBM PC (4 = Atari ST) */ + setvar(V_soundgen, 1); /* IBM PC SOUND */ + setvar(V_monitor, 0x3); /* EGA monitor */ + setvar(V_max_input_chars, 38); + game.input_mode = INPUT_NONE; + game.input_enabled = 0; + game.has_prompt = 0; + + game.state = STATE_RUNNING; + ec = play_game(); + game.state = STATE_LOADED; + agi_deinit(); + } while (ec == err_RestartGame); + + menu_deinit(); + + release_image_stack(); + + return ec; +} + +} // End of namespace Agi diff --git a/engines/agi/font.cpp b/engines/agi/font.cpp new file mode 100644 index 0000000000..487107dfe8 --- /dev/null +++ b/engines/agi/font.cpp @@ -0,0 +1,295 @@ +/* ScummVM - Scumm Interpreter + * Copyright (C) 2006 The ScummVM project + * + * Copyright (C) 1999-2001 Sarien Team + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + * $URL$ + * $Id$ + * + */ + +#include "common/stdafx.h" + +#include "agi/agi.h" + +namespace Agi { + +/* 8x8 font patterns */ +uint8 cur_font[] = { + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x7E, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x7E, /* cursor hollow */ + 0x7E, 0x7E, 0x7E, 0x7E, 0x7E, 0x7E, 0x7E, 0x7E, /* cursor solid */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* cursor empty */ + 0x10, 0x38, 0x7C, 0xFE, 0x7C, 0x38, 0x10, 0x00, + 0x3C, 0x3C, 0x18, 0xFF, 0xE7, 0x18, 0x3C, 0x00, + 0x10, 0x38, 0x7C, 0xFE, 0xEE, 0x10, 0x38, 0x00, + 0x00, 0x00, 0x18, 0x3C, 0x3C, 0x18, 0x00, 0x00, + 0xFF, 0xFF, 0xE7, 0xC3, 0xC3, 0xE7, 0xFF, 0xFF, + 0x00, 0x3C, 0x66, 0x42, 0x42, 0x66, 0x3C, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* \n */ + 0x0F, 0x07, 0x0F, 0x7D, 0xCC, 0xCC, 0xCC, 0x78, + 0x3C, 0x66, 0x66, 0x66, 0x3C, 0x18, 0x7E, 0x18, + 0x08, 0x0C, 0x0A, 0x0A, 0x08, 0x78, 0xF0, 0x00, + 0x18, 0x14, 0x1A, 0x16, 0x72, 0xE2, 0x0E, 0x1C, + 0x10, 0x54, 0x38, 0xEE, 0x38, 0x54, 0x10, 0x00, + 0x80, 0xE0, 0xF8, 0xFE, 0xF8, 0xE0, 0x80, 0x00, + 0x02, 0x0E, 0x3E, 0xFE, 0x3E, 0x0E, 0x02, 0x00, + 0x18, 0x3C, 0x5A, 0x18, 0x5A, 0x3C, 0x18, 0x00, + 0x66, 0x66, 0x66, 0x66, 0x66, 0x00, 0x66, 0x00, + 0x7F, 0xDB, 0xDB, 0xDB, 0x7B, 0x1B, 0x1B, 0x00, + 0x1C, 0x22, 0x38, 0x44, 0x44, 0x38, 0x88, 0x70, + 0x00, 0x00, 0x00, 0x00, 0x7E, 0x7E, 0x7E, 0x00, + 0x18, 0x3C, 0x5A, 0x18, 0x5A, 0x3C, 0x18, 0x7E, + 0x18, 0x3C, 0x5A, 0x18, 0x18, 0x18, 0x18, 0x00, + 0x18, 0x18, 0x18, 0x18, 0x5A, 0x3C, 0x18, 0x00, + 0x00, 0x18, 0x0C, 0xFE, 0x0C, 0x18, 0x00, 0x00, + 0x00, 0x30, 0x60, 0xFE, 0x60, 0x30, 0x00, 0x00, + 0x00, 0x00, 0xC0, 0xC0, 0xC0, 0xFE, 0x00, 0x00, + 0x00, 0x24, 0x42, 0xFF, 0x42, 0x24, 0x00, 0x00, + 0x00, 0x10, 0x38, 0x7C, 0xFE, 0xFE, 0x00, 0x00, + 0x00, 0xFE, 0xFE, 0x7C, 0x38, 0x10, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x18, 0x3C, 0x3C, 0x18, 0x18, 0x00, 0x18, 0x00, + 0x6C, 0x24, 0x24, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x6C, 0x6C, 0xFE, 0x6C, 0xFE, 0x6C, 0x6C, 0x00, + 0x10, 0x7C, 0xD0, 0x7C, 0x16, 0xFC, 0x10, 0x00, + 0x00, 0x66, 0xAC, 0xD8, 0x36, 0x6A, 0xCC, 0x00, + 0x38, 0x4C, 0x38, 0x78, 0xCE, 0xCC, 0x7A, 0x00, + 0x30, 0x10, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x18, 0x30, 0x60, 0x60, 0x60, 0x30, 0x18, 0x00, + 0x60, 0x30, 0x18, 0x18, 0x18, 0x30, 0x60, 0x00, + 0x00, 0x66, 0x3C, 0xFF, 0x3C, 0x66, 0x00, 0x00, + 0x00, 0x30, 0x30, 0xFC, 0x30, 0x30, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x10, 0x20, + 0x00, 0x00, 0x00, 0xFC, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, + 0x02, 0x06, 0x0C, 0x18, 0x30, 0x60, 0xC0, 0x00, + 0x7C, 0xCE, 0xDE, 0xF6, 0xE6, 0xE6, 0x7C, 0x00, + 0x18, 0x38, 0x78, 0x18, 0x18, 0x18, 0x7E, 0x00, + 0x7C, 0xC6, 0x06, 0x1C, 0x70, 0xC6, 0xFE, 0x00, + 0x7C, 0xC6, 0x06, 0x3C, 0x06, 0xC6, 0x7C, 0x00, + 0x1C, 0x3C, 0x6C, 0xCC, 0xFE, 0x0C, 0x1E, 0x00, + 0xFE, 0xC0, 0xFC, 0x06, 0x06, 0xC6, 0x7C, 0x00, + 0x7C, 0xC6, 0xC0, 0xFC, 0xC6, 0xC6, 0x7C, 0x00, + 0xFE, 0xC6, 0x0C, 0x18, 0x30, 0x30, 0x30, 0x00, + 0x7C, 0xC6, 0xC6, 0x7C, 0xC6, 0xC6, 0x7C, 0x00, + 0x7C, 0xC6, 0xC6, 0x7E, 0x06, 0xC6, 0x7C, 0x00, + 0x00, 0x30, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, + 0x00, 0x30, 0x00, 0x00, 0x00, 0x30, 0x10, 0x20, + 0x0C, 0x18, 0x30, 0x60, 0x30, 0x18, 0x0C, 0x00, + 0x00, 0x00, 0x7E, 0x00, 0x00, 0x7E, 0x00, 0x00, + 0x60, 0x30, 0x18, 0x0C, 0x18, 0x30, 0x60, 0x00, + 0x78, 0xCC, 0x0C, 0x18, 0x30, 0x00, 0x30, 0x00, + 0x7C, 0x82, 0x9E, 0xA6, 0x9E, 0x80, 0x7C, 0x00, + 0x7C, 0xC6, 0xC6, 0xFE, 0xC6, 0xC6, 0xC6, 0x00, + 0xFC, 0x66, 0x66, 0x7C, 0x66, 0x66, 0xFC, 0x00, + 0x7C, 0xC6, 0xC0, 0xC0, 0xC0, 0xC6, 0x7C, 0x00, + 0xFC, 0x66, 0x66, 0x66, 0x66, 0x66, 0xFC, 0x00, + 0xFE, 0x62, 0x68, 0x78, 0x68, 0x62, 0xFE, 0x00, + 0xFE, 0x62, 0x68, 0x78, 0x68, 0x60, 0xF0, 0x00, + 0x7C, 0xC6, 0xC6, 0xC0, 0xCE, 0xC6, 0x7E, 0x00, + 0xC6, 0xC6, 0xC6, 0xFE, 0xC6, 0xC6, 0xC6, 0x00, + 0x3C, 0x18, 0x18, 0x18, 0x18, 0x18, 0x3C, 0x00, + 0x1E, 0x0C, 0x0C, 0x0C, 0xCC, 0xCC, 0x78, 0x00, + 0xE6, 0x66, 0x6C, 0x78, 0x6C, 0x66, 0xE6, 0x00, + 0xF0, 0x60, 0x60, 0x60, 0x62, 0x66, 0xFE, 0x00, + 0x82, 0xC6, 0xEE, 0xFE, 0xD6, 0xC6, 0xC6, 0x00, + 0xC6, 0xE6, 0xF6, 0xDE, 0xCE, 0xC6, 0xC6, 0x00, + 0x7C, 0xC6, 0xC6, 0xC6, 0xC6, 0xC6, 0x7C, 0x00, + 0xFC, 0x66, 0x66, 0x7C, 0x60, 0x60, 0xF0, 0x00, + 0x7C, 0xC6, 0xC6, 0xC6, 0xD6, 0xDE, 0x7C, 0x06, + 0xFC, 0x66, 0x66, 0x7C, 0x66, 0x66, 0xE6, 0x00, + 0x7C, 0xC6, 0xC0, 0x7C, 0x06, 0xC6, 0x7C, 0x00, + 0x7E, 0x5A, 0x5A, 0x18, 0x18, 0x18, 0x3C, 0x00, + 0xC6, 0xC6, 0xC6, 0xC6, 0xC6, 0xC6, 0x7C, 0x00, + 0xC6, 0xC6, 0xC6, 0xC6, 0x6C, 0x38, 0x10, 0x00, + 0xC6, 0xC6, 0xD6, 0xFE, 0xEE, 0xC6, 0x82, 0x00, + 0xC6, 0x6C, 0x38, 0x38, 0x38, 0x6C, 0xC6, 0x00, + 0x66, 0x66, 0x66, 0x3C, 0x18, 0x18, 0x3C, 0x00, + 0xFE, 0xC6, 0x8C, 0x18, 0x32, 0x66, 0xFE, 0x00, + 0x78, 0x60, 0x60, 0x60, 0x60, 0x60, 0x78, 0x00, + 0xC0, 0x60, 0x30, 0x18, 0x0C, 0x06, 0x02, 0x00, + 0x78, 0x18, 0x18, 0x18, 0x18, 0x18, 0x78, 0x00, + 0x10, 0x38, 0x6C, 0xC6, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, + 0x30, 0x20, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x78, 0x0C, 0x7C, 0xCC, 0x76, 0x00, + 0xE0, 0x60, 0x60, 0x7C, 0x66, 0x66, 0x7C, 0x00, + 0x00, 0x00, 0x7C, 0xC6, 0xC0, 0xC6, 0x7C, 0x00, + 0x1C, 0x0C, 0x0C, 0x7C, 0xCC, 0xCC, 0x76, 0x00, + 0x00, 0x00, 0x7C, 0xC6, 0xFE, 0xC0, 0x7C, 0x00, + 0x1C, 0x36, 0x30, 0x78, 0x30, 0x30, 0x78, 0x00, + 0x00, 0x00, 0x76, 0xCC, 0xCC, 0x7C, 0x0C, 0x78, + 0xE0, 0x60, 0x6C, 0x76, 0x66, 0x66, 0xE6, 0x00, + 0x18, 0x00, 0x38, 0x18, 0x18, 0x18, 0x3C, 0x00, + 0x00, 0x0C, 0x00, 0x1C, 0x0C, 0x0C, 0xCC, 0x78, + 0xE0, 0x60, 0x66, 0x6C, 0x78, 0x6C, 0xE6, 0x00, + 0x38, 0x18, 0x18, 0x18, 0x18, 0x18, 0x3C, 0x00, + 0x00, 0x00, 0xCC, 0xFE, 0xD6, 0xD6, 0xD6, 0x00, + 0x00, 0x00, 0xDC, 0x66, 0x66, 0x66, 0x66, 0x00, + 0x00, 0x00, 0x7C, 0xC6, 0xC6, 0xC6, 0x7C, 0x00, + 0x00, 0x00, 0xDC, 0x66, 0x66, 0x7C, 0x60, 0xF0, + 0x00, 0x00, 0x7C, 0xCC, 0xCC, 0x7C, 0x0C, 0x1E, + 0x00, 0x00, 0xDE, 0x76, 0x60, 0x60, 0xF0, 0x00, + 0x00, 0x00, 0x7C, 0xC0, 0x7C, 0x06, 0x7C, 0x00, + 0x10, 0x30, 0xFC, 0x30, 0x30, 0x34, 0x18, 0x00, + 0x00, 0x00, 0xCC, 0xCC, 0xCC, 0xCC, 0x76, 0x00, + 0x00, 0x00, 0xC6, 0xC6, 0x6C, 0x38, 0x10, 0x00, + 0x00, 0x00, 0xC6, 0xD6, 0xD6, 0xFE, 0x6C, 0x00, + 0x00, 0x00, 0xC6, 0x6C, 0x38, 0x6C, 0xC6, 0x00, + 0x00, 0x00, 0xCC, 0xCC, 0xCC, 0x7C, 0x0C, 0xF8, + 0x00, 0x00, 0xFC, 0x98, 0x30, 0x64, 0xFC, 0x00, + 0x0E, 0x18, 0x18, 0x30, 0x18, 0x18, 0x0E, 0x00, + 0x18, 0x18, 0x18, 0x00, 0x18, 0x18, 0x18, 0x00, + 0xE0, 0x30, 0x30, 0x18, 0x30, 0x30, 0xE0, 0x00, + 0x76, 0xDC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*0x00, 0x10, 0x38, 0x6C, 0xC6, 0xC6, 0xFE, 0x00, */ + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, /*replacement 0x7F */ + +#ifdef AGDS_SUPPORT + 0x1E, 0x36, 0x66, 0x66, 0x7E, 0x66, 0x66, 0x00, + 0x7C, 0x60, 0x60, 0x7C, 0x66, 0x66, 0x7C, 0x00, + 0x7C, 0x66, 0x66, 0x7C, 0x66, 0x66, 0x7C, 0x00, + 0x7E, 0x60, 0x60, 0x60, 0x60, 0x60, 0x60, 0x00, + 0x38, 0x6C, 0x6C, 0x6C, 0x6C, 0x6C, 0xFE, 0xC6, + 0x7E, 0x60, 0x60, 0x7C, 0x60, 0x60, 0x7E, 0x00, + 0xDB, 0xDB, 0x7E, 0x3C, 0x7E, 0xDB, 0xDB, 0x00, + 0x3C, 0x66, 0x06, 0x1C, 0x06, 0x66, 0x3C, 0x00, + 0x66, 0x66, 0x6E, 0x7E, 0x76, 0x66, 0x66, 0x00, + 0x3C, 0x66, 0x6E, 0x7E, 0x76, 0x66, 0x66, 0x00, + 0x66, 0x6C, 0x78, 0x70, 0x78, 0x6C, 0x66, 0x00, + 0x1E, 0x36, 0x66, 0x66, 0x66, 0x66, 0x66, 0x00, + 0xC6, 0xEE, 0xFE, 0xFE, 0xD6, 0xC6, 0xC6, 0x00, + 0x66, 0x66, 0x66, 0x7E, 0x66, 0x66, 0x66, 0x00, + 0x3C, 0x66, 0x66, 0x66, 0x66, 0x66, 0x3C, 0x00, + 0x7E, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x00, + 0x7C, 0x66, 0x66, 0x66, 0x7C, 0x60, 0x60, 0x00, + 0x3C, 0x66, 0x60, 0x60, 0x60, 0x66, 0x3C, 0x00, + 0x7E, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x00, + 0x66, 0x66, 0x66, 0x3E, 0x06, 0x66, 0x3C, 0x00, + 0x7E, 0xDB, 0xDB, 0xDB, 0x7E, 0x18, 0x18, 0x00, + 0x66, 0x66, 0x3C, 0x18, 0x3C, 0x66, 0x66, 0x00, + 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x7F, 0x03, + 0x66, 0x66, 0x66, 0x3E, 0x06, 0x06, 0x06, 0x00, + 0xDB, 0xDB, 0xDB, 0xDB, 0xDB, 0xDB, 0xFF, 0x00, + 0xDB, 0xDB, 0xDB, 0xDB, 0xDB, 0xDB, 0xFF, 0x03, + 0xE0, 0x60, 0x60, 0x7C, 0x66, 0x66, 0x7C, 0x00, + 0xC6, 0xC6, 0xC6, 0xF6, 0xDE, 0xDE, 0xF6, 0x00, + 0x60, 0x60, 0x60, 0x7C, 0x66, 0x66, 0x7C, 0x00, + 0x78, 0x8C, 0x06, 0x3E, 0x06, 0x8C, 0x78, 0x00, + 0xCE, 0xDB, 0xDB, 0xFB, 0xDB, 0xDB, 0xCE, 0x00, + 0x3E, 0x66, 0x66, 0x66, 0x3E, 0x36, 0x66, 0x00, + 0x00, 0x00, 0x3C, 0x06, 0x3E, 0x66, 0x3A, 0x00, + 0x00, 0x3C, 0x60, 0x3C, 0x66, 0x66, 0x3C, 0x00, + 0x00, 0x00, 0x7C, 0x66, 0x7C, 0x66, 0x7C, 0x00, + 0x00, 0x00, 0x7E, 0x60, 0x60, 0x60, 0x60, 0x00, + 0x00, 0x00, 0x3C, 0x6C, 0x6C, 0x6C, 0xFE, 0xC6, + 0x00, 0x00, 0x3C, 0x66, 0x7E, 0x60, 0x3C, 0x00, + 0x00, 0x00, 0xDB, 0x7E, 0x3C, 0x7E, 0xDB, 0x00, + 0x00, 0x00, 0x3C, 0x66, 0x0C, 0x66, 0x3C, 0x00, + 0x00, 0x00, 0x66, 0x6E, 0x7E, 0x76, 0x66, 0x00, + 0x00, 0x18, 0x66, 0x6E, 0x7E, 0x76, 0x66, 0x00, + 0x00, 0x00, 0x66, 0x6C, 0x78, 0x6C, 0x66, 0x00, + 0x00, 0x00, 0x1E, 0x36, 0x66, 0x66, 0x66, 0x00, + 0x00, 0x00, 0xC6, 0xFE, 0xFE, 0xD6, 0xC6, 0x00, + 0x00, 0x00, 0x66, 0x66, 0x7E, 0x66, 0x66, 0x00, + 0x00, 0x00, 0x3C, 0x66, 0x66, 0x66, 0x3C, 0x00, + 0x00, 0x00, 0x7E, 0x66, 0x66, 0x66, 0x66, 0x00, + 0x11, 0x44, 0x11, 0x44, 0x11, 0x44, 0x11, 0x44, + 0x55, 0xAA, 0x55, 0xAA, 0x55, 0xAA, 0x55, 0xAA, + 0xDD, 0x77, 0xDD, 0x77, 0xDD, 0x77, 0xDD, 0x77, + 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, + 0x18, 0x18, 0x18, 0xF8, 0x18, 0x18, 0x18, 0x18, + 0x18, 0xF8, 0x18, 0xF8, 0x18, 0x18, 0x18, 0x18, + 0x36, 0x36, 0x36, 0xF6, 0x36, 0x36, 0x36, 0x36, + 0x00, 0x00, 0x00, 0xFE, 0x36, 0x36, 0x36, 0x36, + 0x00, 0xF8, 0x18, 0xF8, 0x18, 0x18, 0x18, 0x18, + 0x36, 0xF6, 0x06, 0xF6, 0x36, 0x36, 0x36, 0x36, + 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, + 0x00, 0xFE, 0x06, 0xF6, 0x36, 0x36, 0x36, 0x36, + 0x36, 0xF6, 0x06, 0xFE, 0x00, 0x00, 0x00, 0x00, + 0x36, 0x36, 0x36, 0xFE, 0x00, 0x00, 0x00, 0x00, + 0x18, 0xF8, 0x18, 0xF8, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0xF8, 0x18, 0x18, 0x18, 0x18, + 0x18, 0x18, 0x18, 0x1F, 0x00, 0x00, 0x00, 0x00, + 0x18, 0x18, 0x18, 0xFF, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0xFF, 0x18, 0x18, 0x18, 0x18, + 0x18, 0x18, 0x18, 0x1F, 0x18, 0x18, 0x18, 0x18, + 0x00, 0x00, 0x00, 0xFF, 0x00, 0x00, 0x00, 0x00, + 0x18, 0x18, 0x18, 0xFF, 0x18, 0x18, 0x18, 0x18, + 0x18, 0x1F, 0x18, 0x1F, 0x18, 0x18, 0x18, 0x18, + 0x36, 0x36, 0x36, 0x37, 0x36, 0x36, 0x36, 0x36, + 0x36, 0x37, 0x30, 0x3F, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x3F, 0x30, 0x37, 0x36, 0x36, 0x36, 0x36, + 0x36, 0xF7, 0x00, 0xFF, 0x00, 0x00, 0x00, 0x00, + 0x00, 0xFF, 0x00, 0xF7, 0x36, 0x36, 0x36, 0x36, + 0x36, 0x37, 0x30, 0x37, 0x36, 0x36, 0x36, 0x36, + 0x00, 0xFF, 0x00, 0xFF, 0x00, 0x00, 0x00, 0x00, + 0x36, 0xF7, 0x00, 0xF7, 0x36, 0x36, 0x36, 0x36, + 0x18, 0xFF, 0x00, 0xFF, 0x00, 0x00, 0x00, 0x00, + 0x36, 0x36, 0x36, 0xFF, 0x00, 0x00, 0x00, 0x00, + 0x00, 0xFF, 0x00, 0xFF, 0x18, 0x18, 0x18, 0x18, + 0x00, 0x00, 0x00, 0xFF, 0x36, 0x36, 0x36, 0x36, + 0x36, 0x36, 0x36, 0x3F, 0x00, 0x00, 0x00, 0x00, + 0x18, 0x1F, 0x18, 0x1F, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x1F, 0x18, 0x1F, 0x18, 0x18, 0x18, 0x18, + 0x00, 0x00, 0x00, 0x3F, 0x36, 0x36, 0x36, 0x36, + 0x36, 0x36, 0x36, 0xFF, 0x36, 0x36, 0x36, 0x36, + 0x18, 0xFF, 0x18, 0xFF, 0x18, 0x18, 0x18, 0x18, + 0x18, 0x18, 0x18, 0xF8, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x1F, 0x18, 0x18, 0x18, 0x18, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, + 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, + 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x7C, 0x66, 0x66, 0x7C, 0x60, 0x00, + 0x00, 0x00, 0x3C, 0x66, 0x60, 0x66, 0x3C, 0x00, + 0x00, 0x00, 0x7E, 0x18, 0x18, 0x18, 0x18, 0x00, + 0x00, 0x00, 0x66, 0x66, 0x3E, 0x06, 0x7C, 0x00, + 0x00, 0x00, 0x7E, 0xDB, 0xDB, 0x7E, 0x18, 0x00, + 0x00, 0x00, 0x66, 0x3C, 0x18, 0x3C, 0x66, 0x00, + 0x00, 0x00, 0x66, 0x66, 0x66, 0x66, 0x7F, 0x03, + 0x00, 0x00, 0x66, 0x66, 0x3E, 0x06, 0x06, 0x00, + 0x00, 0x00, 0xDB, 0xDB, 0xDB, 0xDB, 0xFF, 0x00, + 0x00, 0x00, 0xDB, 0xDB, 0xDB, 0xDB, 0xFF, 0x03, + 0x00, 0x00, 0xE0, 0x60, 0x7C, 0x66, 0x7C, 0x00, + 0x00, 0x00, 0xC6, 0xC6, 0xF6, 0xDE, 0xF6, 0x00, + 0x00, 0x00, 0x60, 0x60, 0x7C, 0x66, 0x7C, 0x00, + 0x00, 0x00, 0x7C, 0x06, 0x3E, 0x06, 0x7C, 0x00, + 0x00, 0x00, 0xCE, 0xDB, 0xFB, 0xDB, 0xCE, 0x00, + 0x00, 0x00, 0x3E, 0x66, 0x3E, 0x36, 0x66, 0x00, + 0x00, 0x00, 0xFE, 0x00, 0xFE, 0x00, 0xFE, 0x00, + 0x10, 0x10, 0x7C, 0x10, 0x10, 0x00, 0x7C, 0x00, + 0x00, 0x30, 0x18, 0x0C, 0x06, 0x0C, 0x18, 0x30, + 0x00, 0x0C, 0x18, 0x30, 0x60, 0x30, 0x18, 0x0C, + 0x0E, 0x1B, 0x1B, 0x18, 0x18, 0x18, 0x18, 0x18, + 0x18, 0x18, 0x18, 0x18, 0x18, 0xD8, 0xD8, 0x70, + 0x00, 0x18, 0x18, 0x00, 0x7E, 0x00, 0x18, 0x18, + 0x00, 0x76, 0xDC, 0x00, 0x76, 0xDC, 0x00, 0x00, + 0x00, 0x38, 0x6C, 0x6C, 0x38, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x38, 0x38, 0x00, 0x00, 0x00, + 0x03, 0x02, 0x06, 0x04, 0xCC, 0x68, 0x38, 0x10, + 0x3C, 0x42, 0x99, 0xA1, 0xA1, 0x99, 0x42, 0x3C, + 0x30, 0x48, 0x10, 0x20, 0x78, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x7C, 0x7C, 0x7C, 0x7C, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x42, 0x7E, 0x00 +#endif /* AGDS_SUPPORT */ +}; + +} // End of namespace Agi diff --git a/engines/agi/global.cpp b/engines/agi/global.cpp new file mode 100644 index 0000000000..404726f2b7 --- /dev/null +++ b/engines/agi/global.cpp @@ -0,0 +1,73 @@ +/* ScummVM - Scumm Interpreter + * Copyright (C) 2006 The ScummVM project + * + * Copyright (C) 1999-2003 Sarien Team + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + * $URL$ + * $Id$ + * + */ + +#include "common/stdafx.h" + +#include "agi/agi.h" + +namespace Agi { + +int getflag(int n) { + uint8 *set = (uint8 *) & game.flags; + + set += n >> 3; + return (*set & (1 << (n & 0x07))) != 0; +} + +void setflag(int n, int v) { + uint8 *set = (uint8 *) & game.flags; + + set += n >> 3; + if (v) + *set |= 1 << (n & 0x07); /* set bit */ + else + *set &= ~(1 << (n & 0x07)); /* clear bit */ +} + +void flipflag(int n) { + uint8 *set = (uint8 *) & game.flags; + + set += n >> 3; + *set ^= 1 << (n & 0x07); /* flip bit */ +} + +void setvar(int var, int val) { + game.vars[var] = val; +} + +int getvar(int var) { + return game.vars[var]; +} + +void decrypt(uint8 *mem, int len) { + uint8 *key; + int i; + + key = opt.agds ? (uint8 *)CRYPT_KEY_AGDS : (uint8 *)CRYPT_KEY_SIERRA; + + for (i = 0; i < len; i++) + *(mem + i) ^= *(key + (i % 11)); +} + +} // End of namespace Agi diff --git a/engines/agi/graphics.cpp b/engines/agi/graphics.cpp new file mode 100644 index 0000000000..fbe0228efa --- /dev/null +++ b/engines/agi/graphics.cpp @@ -0,0 +1,742 @@ +/* ScummVM - Scumm Interpreter + * Copyright (C) 2006 The ScummVM project + * + * Copyright (C) 1999-2003 Sarien Team + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + * $URL$ + * $Id$ + * + */ + +#include "common/stdafx.h" + +#include "agi/agi.h" +#include "agi/graphics.h" + +namespace Agi { + +#define DEV_X0(x) ((x) << 1) +#define DEV_X1(x) (((x) << 1) + 1) +#define DEV_Y(x) (x) + +#ifndef MAX_INT +# define MAX_INT (int)((unsigned)~0 >> 1) +#endif + +static uint8 *agi_screen; +#ifdef USE_CONSOLE +static uint8 *console_screen; +#endif + +static unsigned char *screen; + +extern uint8 cur_font[]; + +/** + * 16 color RGB palette (plus 16 transparent colors). + * This array contains the 6-bit RGB values of the EGA palette exported + * to the console drivers. + */ +uint8 ega_palette[16 * 3] = { + 0x00, 0x00, 0x00, + 0x00, 0x00, 0x2a, + 0x00, 0x2a, 0x00, + 0x00, 0x2a, 0x2a, + 0x2a, 0x00, 0x00, + 0x2a, 0x00, 0x2a, + 0x2a, 0x15, 0x00, + 0x2a, 0x2a, 0x2a, + 0x15, 0x15, 0x15, + 0x15, 0x15, 0x3f, + 0x15, 0x3f, 0x15, + 0x15, 0x3f, 0x3f, + 0x3f, 0x15, 0x15, + 0x3f, 0x15, 0x3f, + 0x3f, 0x3f, 0x15, + 0x3f, 0x3f, 0x3f +}; + +/** + * 16 color amiga-ish palette. + */ +uint8 new_palette[16 * 3] = { + 0x00, 0x00, 0x00, + 0x00, 0x00, 0x3f, + 0x00, 0x2A, 0x00, + 0x00, 0x2A, 0x2A, + 0x33, 0x00, 0x00, + 0x2f, 0x1c, 0x37, + 0x23, 0x14, 0x00, + 0x2f, 0x2f, 0x2f, + 0x15, 0x15, 0x15, + 0x00, 0x2f, 0x3f, + 0x00, 0x33, 0x15, + 0x15, 0x3F, 0x3F, + 0x3f, 0x27, 0x23, + 0x3f, 0x15, 0x3f, + 0x3b, 0x3b, 0x00, + 0x3F, 0x3F, 0x3F +}; + +uint8 palette[32 * 3]; + +static uint16 cga_map[16] = { + 0x0000, /* 0 - black */ + 0x0d00, /* 1 - blue */ + 0x0b00, /* 2 - green */ + 0x0f00, /* 3 - cyan */ + 0x000b, /* 4 - red */ + 0x0b0d, /* 5 - magenta */ + 0x000d, /* 6 - brown */ + 0x0b0b, /* 7 - gray */ + 0x0d0d, /* 8 - dark gray */ + 0x0b0f, /* 9 - light blue */ + 0x0b0d, /* 10 - light green */ + 0x0f0d, /* 11 - light cyan */ + 0x0f0d, /* 12 - light red */ + 0x0f00, /* 13 - light magenta */ + 0x0f0b, /* 14 - yellow */ + 0x0f0f /* 15 - white */ +}; + +struct update_block { + int x1, y1; + int x2, y2; +}; + +static struct update_block update = { + MAX_INT, MAX_INT, 0, 0 +}; + +struct gfx_driver *gfx; /* graphics driver */ + +/* + * Layer 4: 640x480? ================== User display + * ^ + * | do_update(), put_block() + * | + * Layer 3: 640x480? ================== Framebuffer + * ^ + * | flush_block(), put_pixels() + * | + * Layer 2: 320x200 ================== AGI engine screen (console), put_pixel() + * | + * Layer 1: 160x168 ================== AGI screen + */ + +#ifdef USE_CONSOLE + +/** + * Draws a row of pixels in the output device framebuffer. + * This function adds the console layer using transparent colors if + * appropriate. + */ +static void put_pixels(const int x, const int y, const int w, uint8 *p) { + int i; + uint8 _b[GFX_WIDTH] = { 0 }; + uint8 *b, *c = NULL; + + if (console.y <= y) { + gfx_putpixels(x, y, w, p); + return; + } + + b = &_b[0]; + c = &console_screen[x + (y + GFX_HEIGHT - 1 - console.y) * GFX_WIDTH]; + + for (i = 0; i < w; i++, c++, p++) { + *b++ = *c ? *c : *p + 16; + } + + gfx_putpixels(x, y, w, _b); +} + +static void init_console() { + int i; + + /* Console */ + console.line[0] = (char *)calloc(CONSOLE_LINES_BUFFER, CONSOLE_LINE_SIZE + 1); + for (i = 1; i < CONSOLE_LINES_BUFFER; i++) + console.line[i] = console.line[i - 1] + CONSOLE_LINE_SIZE + 1; +} + +#else + +static void put_pixels(const int x, const int y, const int w, uint8 *p) { + gfx->put_pixels(x, y, w, p); +} + +static void init_console() +{ +} + +#endif /* USE_CONSOLE */ + +#define SHAKE_MAG 3 +static uint8 *shake_h, *shake_v; + +void shake_start() { + int i; + + if ((shake_h = (uint8 *)malloc(GFX_WIDTH * SHAKE_MAG)) == NULL) + return; + + if ((shake_v = (uint8 *)malloc(SHAKE_MAG * (GFX_HEIGHT - SHAKE_MAG))) == NULL) { + free(shake_h); + return; + } + + for (i = 0; i < GFX_HEIGHT - SHAKE_MAG; i++) { + memcpy(shake_v + i * SHAKE_MAG, agi_screen + i * GFX_WIDTH, SHAKE_MAG); + } + + for (i = 0; i < SHAKE_MAG; i++) { + memcpy(shake_h + i * GFX_WIDTH, agi_screen + i * GFX_WIDTH, GFX_WIDTH); + } +} + +void shake_screen(int n) { + int i; + + if (n == 0) { + for (i = 0; i < (GFX_HEIGHT - SHAKE_MAG); i++) { + memmove(&agi_screen[GFX_WIDTH * i], + &agi_screen[GFX_WIDTH * (i + SHAKE_MAG) + SHAKE_MAG], + GFX_WIDTH - SHAKE_MAG); + } + } else { + for (i = GFX_HEIGHT - SHAKE_MAG - 1; i >= 0; i--) { + memmove(&agi_screen[GFX_WIDTH * (i + SHAKE_MAG) + SHAKE_MAG], + &agi_screen[GFX_WIDTH * i], GFX_WIDTH - SHAKE_MAG); + } + } +} + +void shake_end() { + int i; + + for (i = 0; i < GFX_HEIGHT - SHAKE_MAG; i++) { + memcpy(agi_screen + i * GFX_WIDTH, shake_v + i * SHAKE_MAG, SHAKE_MAG); + } + + for (i = 0; i < SHAKE_MAG; i++) { + memcpy(agi_screen + i * GFX_WIDTH, shake_h + i * GFX_WIDTH, GFX_WIDTH); + } + + flush_block(0, 0, GFX_WIDTH - 1, GFX_HEIGHT - 1); + + free(shake_v); + free(shake_h); +} + +void put_text_character(int l, int x, int y, unsigned int c, int fg, int bg) { + int x1, y1, xx, yy, cc; + uint8 *p; + + p = cur_font + ((unsigned int)c * CHAR_LINES); + for (y1 = 0; y1 < CHAR_LINES; y1++) { + for (x1 = 0; x1 < CHAR_COLS; x1++) { + xx = x + x1; + yy = y + y1; + cc = (*p & (1 << (7 - x1))) ? fg : bg; +#ifdef USE_CONSOLE + if (l) { + console_screen[xx + yy * GFX_WIDTH] = cc; + } else +#endif + { + agi_screen[xx + yy * GFX_WIDTH] = cc; + } + } + + p++; + } + /* FIXME: we don't want this when we're writing on the + * console! + */ + flush_block(x, y, x + CHAR_COLS - 1, y + CHAR_LINES - 1); +} + +void draw_rectangle(int x1, int y1, int x2, int y2, int c) { + int y, w, h; + uint8 *p0; + + if (x1 >= GFX_WIDTH) + x1 = GFX_WIDTH - 1; + if (y1 >= GFX_HEIGHT) + y1 = GFX_HEIGHT - 1; + if (x2 >= GFX_WIDTH) + x2 = GFX_WIDTH - 1; + if (y2 >= GFX_HEIGHT) + y2 = GFX_HEIGHT - 1; + + w = x2 - x1 + 1; + h = y2 - y1 + 1; + p0 = &agi_screen[x1 + y1 * GFX_WIDTH]; + for (y = 0; y < h; y++) { + memset(p0, c, w); + p0 += GFX_WIDTH; + } +} + +static void draw_frame(int x1, int y1, int x2, int y2, int c1, int c2) { + int y, w; + uint8 *p0; + + /* top line */ + w = x2 - x1 + 1; + p0 = &agi_screen[x1 + y1 * GFX_WIDTH]; + memset(p0, c1, w); + + /* bottom line */ + p0 = &agi_screen[x1 + y2 * GFX_WIDTH]; + memset(p0, c2, w); + + /* side lines */ + for (y = y1; y <= y2; y++) { + agi_screen[x1 + y * GFX_WIDTH] = c1; + agi_screen[x2 + y * GFX_WIDTH] = c2; + } +} + +void draw_box(int x1, int y1, int x2, int y2, int colour1, int colour2, int m) { + x1 += m; + y1 += m; + x2 -= m; + y2 -= m; + + draw_rectangle(x1, y1, x2, y2, colour1); + draw_frame(x1 + 2, y1 + 2, x2 - 2, y2 - 2, colour2, colour2); + flush_block(x1, y1, x2, y2); +} + +void print_character(int x, int y, char c, int fg, int bg) { + x *= CHAR_COLS; + y *= CHAR_LINES; + + put_text_character(0, x, y, c, fg, bg); + // redundant! already inside put_text_character! + // flush_block (x, y, x + CHAR_COLS - 1, y + CHAR_LINES - 1); +} + +/** + * Draw button + * @param x x coordinate of the button + * @param y y coordinate of the button + * @param a set if the button has focus + * @param p set if the button is pressed + */ +void draw_button(int x, int y, char *s, int a, int p) { + int len = strlen(s); + int x1, y1, x2, y2; + + x1 = x - 3; + y1 = y - 3; + x2 = x + CHAR_COLS * len + 2; + y2 = y + CHAR_LINES + 2; + + while (*s) { + put_text_character(0, x + (!!p), y + (!!p), *s++, + a ? 15 : 0, a ? 0 : 15); + x += CHAR_COLS; + } + + x1 -= 2; + y1 -= 2; + x2 += 2; + y2 += 2; + + flush_block(x1, y1, x2, y2); +} + +#ifdef USE_MOUSE +int test_button(int x, int y, char *s) { + int len = strlen(s); + int x1, y1, x2, y2; + + x1 = x - 3; + y1 = y - 3; + x2 = x + CHAR_COLS * len + 2; + y2 = y + CHAR_LINES + 2; + + if ((int)mouse.x >= x1 && (int)mouse.y >= y1 + && (int)mouse.x <= x2 && (int)mouse.y <= y2) + return true; + + return false; +} +#endif + +void put_block(int x1, int y1, int x2, int y2) { + gfx_putblock(x1, y1, x2, y2); +} + +void put_screen() { + put_block(0, 0, GFX_WIDTH - 1, GFX_HEIGHT - 1); +} + +void poll_timer() { + agi_timer_low(); +} + +int get_key() { + return agi_get_keypress_low(); +} + +int keypress() { + return agi_is_keypress_low(); +} + +/* + * Public functions + */ + +/** + * Initialize the color palette + * This function initializes the color palette using the specified 16-color + * RGB palette and creates 16 extra palette entries with translucent colors + * for the interpreter console. + * @param p A pointer to the 16-color RGB palette. + */ +void init_palette(uint8 *p) { + int i; + + for (i = 0; i < 48; i++) { + palette[i] = p[i]; + palette[i + 48] = (p[i] + 0x30) >> 2; + } +} + +void gfx_set_palette() { + int i; + byte pal[32 * 4]; + + for (i = 0; i < 32; i++) { + pal[i * 4 + 0] = palette[i * 3 + 0] << 2; + pal[i * 4 + 1] = palette[i * 3 + 1] << 2; + pal[i * 4 + 2] = palette[i * 3 + 2] << 2; + pal[i * 4 + 3] = 0; + } + g_system->setPalette(pal, 0, 32); +} + +void gfx_putpixels(int x, int y, int w, uint8 *p) { + uint8 *p0 = screen + x + y * 320; + memcpy(p0, p, w); +} + +/* put a block onto the screen */ +void gfx_putblock(int x1, int y1, int x2, int y2) { + if (x1 >= GFX_WIDTH) + x1 = GFX_WIDTH - 1; + if (y1 >= GFX_HEIGHT) + y1 = GFX_HEIGHT - 1; + if (x2 >= GFX_WIDTH) + x2 = GFX_WIDTH - 1; + if (y2 >= GFX_HEIGHT) + y2 = GFX_HEIGHT - 1; + + // force full update until fix wrong partial updates + g_system->copyRectToScreen(screen, 320, 0, 0, 320, 200); + //g_system->copyRectToScreen(screen, 320, x1, y1, x2 - x1 + 1, y2 - y1 + 1); + //g_system->updateScreen(); +} + +static const byte mouseCursorArrow[] = { + 0x00, 0x00, 0x40, 0x00, 0x60, 0x00, 0x70, 0x00, + 0x78, 0x00, 0x7C, 0x00, 0x7E, 0x00, 0x7F, 0x00, + 0x7F, 0x80, 0x7C, 0x00, 0x6C, 0x00, 0x46, 0x00, + 0x06, 0x00, 0x03, 0x00, 0x03, 0x00, 0x00, 0x00, + 0xC0, 0x00, 0xE0, 0x00, 0xF0, 0x00, 0xF8, 0x00, + 0xFC, 0x00, 0xFE, 0x00, 0xFF, 0x00, 0xFF, 0x80, + 0xFF, 0xC0, 0xFF, 0xC0, 0xFE, 0x00, 0xFF, 0x00, + 0xCF, 0x00, 0x07, 0x80, 0x07, 0x80, 0x03, 0x80 +}; + +/** + * Initialize graphics device. + * + * @see deinit_video() + */ +int init_video() { + if (opt.egapal) + init_palette(ega_palette); + else + init_palette(new_palette); + + init_console(); + + if ((agi_screen = (uint8 *)calloc(GFX_WIDTH, GFX_HEIGHT)) == NULL) + return err_NotEnoughMemory; + +#ifdef USE_CONSOLE + if ((console_screen = (uint8 *)calloc(GFX_WIDTH, GFX_HEIGHT)) == NULL) { + free(agi_screen); + return err_NotEnoughMemory; + } +#endif + + gfx_set_palette(); + + byte mouseCursor[16 * 16]; + const byte *src = mouseCursorArrow; + for (int i = 0; i < 32; ++i) { + int offs = i * 8; + for (byte mask = 0x80; mask != 0; mask >>= 1) { + if (src[0] & mask) { + mouseCursor[offs] = 2; + } else if (src[32] & mask) { + mouseCursor[offs] = 0; + } else { + mouseCursor[offs] = 0xFF; + } + ++offs; + } + ++src; + } + g_system->setMouseCursor(mouseCursor, 16, 16, 1, 1); + + return err_OK; +} + +/** + * Deinitialize graphics device. + * + * @see init_video() + */ +int deinit_video() { + free(agi_screen); +#ifdef USE_CONSOLE + free(console_screen); +#endif + + return err_OK; +} + +int init_machine() { + screen = (unsigned char *)malloc(320 * 200); + clock_count = 0; + clock_ticks = 0; + + return err_OK; +} + +int deinit_machine() { + free(screen); + + return err_OK; +} + +/** + * Write pixels on the output device. + * This function writes a row of pixels on the output device. Only the + * lower 4 bits of each pixel in the row will be used, making this + * function suitable for use with rows from the AGI screen. + * @param x x coordinate of the row start (AGI coord.) + * @param y y coordinate of the row start (AGI coord.) + * @param n number of pixels in the row + * @param p pointer to the row start in the AGI screen + */ +void put_pixels_a(int x, int y, int n, uint8 *p) { + if (opt.cgaemu) { + for (x *= 2; n--; p++, x += 2) { + register uint16 q = (cga_map[(*p & 0xf0) >> 4] << 4) | cga_map[*p & 0x0f]; +#ifdef USE_CONSOLE + if (debug_.priority) + q >>= 4; +#endif + *(uint16 *)&agi_screen[x + y * GFX_WIDTH] = q & 0x0f0f; + } + } else { + for (x *= 2; n--; p++, x += 2) { + register uint16 q = ((uint16) * p << 8) | *p; +#ifdef USE_CONSOLE + if (debug_.priority) + q >>= 4; +#endif + *(uint16 *)&agi_screen[x + y * GFX_WIDTH] = q & 0x0f0f; + } + } +} + +#ifdef USE_HIRES + +void put_pixels_hires(int x, int y, int n, uint8 *p) { + //y += CHAR_LINES; + for (; n--; p++, x++) { + uint8 q = *p; +#ifdef USE_CONSOLE + if (debug_.priority) + q >>= 4; +#endif + agi_screen[x + y * GFX_WIDTH] = q & 0x0f; + } +} + +#endif + +/** + * Schedule blocks for blitting on the output device. + * This function gets the coordinates of a block in the AGI screen and + * schedule it to be updated in the output device. + * @param x1 x coordinate of the upper left corner of the block (AGI coord.) + * @param y1 y coordinate of the upper left corner of the block (AGI coord.) + * @param x2 x coordinate of the lower right corner of the block (AGI coord.) + * @param y2 y coordinate of the lower right corner of the block (AGI coord.) + * + * @see do_update() + */ +void schedule_update(int x1, int y1, int x2, int y2) { + if (x1 < update.x1) + update.x1 = x1; + if (y1 < update.y1) + update.y1 = y1; + if (x2 > update.x2) + update.x2 = x2; + if (y2 > update.y2) + update.y2 = y2; +} + +/** + * Update scheduled blocks on the output device. + * This function exposes the blocks scheduled for updating to the output + * device. Blocks can be scheduled at any point of the AGI cycle. + * + * @see schedule_update() + */ +void do_update() { + if (update.x1 <= update.x2 && update.y1 <= update.y2) { + gfx_putblock(update.x1, update.y1, update.x2, update.y2); + } + + /* reset update block variables */ + update.x1 = MAX_INT; + update.y1 = MAX_INT; + update.x2 = 0; + update.y2 = 0; +} + +/** + * Updates a block of the framebuffer with contents of the AGI engine screen. + * This function updates a block in the output device with the contents of + * the AGI engine screen, handling console transparency. + * @param x1 x coordinate of the upper left corner of the block + * @param y1 y coordinate of the upper left corner of the block + * @param x2 x coordinate of the lower right corner of the block + * @param y2 y coordinate of the lower right corner of the block + * + * @see flush_block_a() + */ +void flush_block(int x1, int y1, int x2, int y2) { + int y, w; + uint8 *p0; + + schedule_update(x1, y1, x2, y2); + + p0 = &agi_screen[x1 + y1 * GFX_WIDTH]; + w = x2 - x1 + 1; + + for (y = y1; y <= y2; y++) { + put_pixels(x1, y, w, p0); + p0 += GFX_WIDTH; + } +} + +/** + * Updates a block of the framebuffer receiving AGI picture coordinates. + * @param x1 x AGI picture coordinate of the upper left corner of the block + * @param y1 y AGI picture coordinate of the upper left corner of the block + * @param x2 x AGI picture coordinate of the lower right corner of the block + * @param y2 y AGI picture coordinate of the lower right corner of the block + * + * @see flush_block() + */ +void flush_block_a(int x1, int y1, int x2, int y2) { + //y1 += 8; + //y2 += 8; + flush_block(DEV_X0(x1), DEV_Y(y1), DEV_X1(x2), DEV_Y(y2)); +} + +/** + * Updates the framebuffer with contents of the AGI engine screen (console-aware). + * This function updates the output device with the contents of the AGI + * screen, handling console transparency. + */ +void flush_screen() { + flush_block(0, 0, GFX_WIDTH - 1, GFX_HEIGHT - 1); +} + +/** + * Clear the output device screen (console-aware). + * This function clears the output device screen and updates the + * output device. Contents of the AGI screen are left untouched. This + * function can be used to simulate a switch to a text mode screen in + * a graphic-only device. + * @param c color to clear the screen + */ +void clear_screen(int c) { + memset(agi_screen, c, GFX_WIDTH * GFX_HEIGHT); + flush_screen(); +} + +#ifdef USE_CONSOLE +/** + * Clear the console screen. + * This function clears the top n lines of the console screen. + * @param n number of lines to clear (in pixels) + */ +void clear_console_screen(int n) { + memset(console_screen + n * GFX_WIDTH, 0, (GFX_HEIGHT - n) * GFX_WIDTH); +} +#endif + +/** + * Save a block of the AGI engine screen + */ +void save_block(int x1, int y1, int x2, int y2, uint8 *b) { + uint8 *p0; + int w, h; + + p0 = &agi_screen[x1 + GFX_WIDTH * y1]; + w = x2 - x1 + 1; + h = y2 - y1 + 1; + while (h--) { + memcpy(b, p0, w); + b += w; + p0 += GFX_WIDTH; + } +} + +/** + * Restore a block of the AGI engine screen + */ +void restore_block(int x1, int y1, int x2, int y2, uint8 *b) { + uint8 *p0; + int w, h; + + p0 = &agi_screen[x1 + GFX_WIDTH * y1]; + w = x2 - x1 + 1; + h = y2 - y1 + 1; + while (h--) { + memcpy(p0, b, w); + b += w; + p0 += GFX_WIDTH; + } + flush_block(x1, y1, x2, y2); +} + +} // End of namespace Agi diff --git a/engines/agi/graphics.h b/engines/agi/graphics.h new file mode 100644 index 0000000000..3931677441 --- /dev/null +++ b/engines/agi/graphics.h @@ -0,0 +1,86 @@ +/* ScummVM - Scumm Interpreter + * Copyright (C) 2006 The ScummVM project + * + * Copyright (C) 1999-2001 Sarien Team + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + * $URL$ + * $Id$ + * + */ + +#ifndef __AGI_GRAPHICS_H +#define __AGI_GRAPHICS_H + +#include "common/stdafx.h" + +#include "agi/agi.h" + +namespace Agi { + +#define GFX_WIDTH 320 +#define GFX_HEIGHT 200 +#define CHAR_COLS 8 +#define CHAR_LINES 8 + +extern uint8 palette[]; + +/* Transparent layer */ +extern uint8 layer1_data[]; +extern uint8 layer2_data[]; + +void gfx_putpixels(int x, int y, int w, uint8 * p); +void gfx_putblock(int x1, int y1, int x2, int y2); + +void put_text_character(int, int, int, unsigned int, int, int); +void shake_screen(int); +void shake_start(void); +void shake_end(void); +void save_screen(void); +void restore_screen(void); + +int init_video(void); +int deinit_video(void); +void schedule_update(int, int, int, int); +void do_update(void); +void put_screen(void); +void flush_block(int, int, int, int); +void flush_block_a(int, int, int, int); +void put_pixels_a(int, int, int, uint8 *); +void flush_screen(void); +void clear_screen(int); +void clear_console_screen(int); +void draw_box(int, int, int, int, int, int, int); +void draw_button(int, int, char *, int, int); +int test_button(int, int, char *); +void draw_rectangle(int, int, int, int, int); +void save_block(int, int, int, int, uint8 *); +void restore_block(int, int, int, int, uint8 *); +void init_palette(uint8 *); + +void put_pixel(int, int, int); + +#ifdef USE_HIRES +void put_pixels_hires(int x, int y, int n, uint8 * p); +#endif +int keypress(void); +int get_key(void); +void print_character(int, int, char, int, int); +void poll_timer(void); + +} // End of namespace Agi + +#endif /* __AGI_GRAPHICS_H */ diff --git a/engines/agi/id.cpp b/engines/agi/id.cpp new file mode 100644 index 0000000000..28c1c00200 --- /dev/null +++ b/engines/agi/id.cpp @@ -0,0 +1,475 @@ +/* ScummVM - Scumm Interpreter + * Copyright (C) 2006 The ScummVM project + * + * Copyright (C) 1999-2003 Sarien Team + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + * $URL$ + * $Id$ + * + */ + +#include "common/stdafx.h" + +#include "agi/agi.h" +#include "agi/opcodes.h" + +namespace Agi { + +/* + * Determine what AGI v2 system to emulate, these are the major version + * to emulate, thus 2.915 comes under 2.917, 2.4xxx is 2.440, etc. + * + * 0x2089 + * 0x2272 + * 0x2440 + * 0x2917 + * 0x2936 + */ + +const char *ids_database = "\ +# CRC Int Ver [options] Game name # Comment \n\ + \n\ +#---------------------------------------------------------------------------- \n\ +# PC-DOS versions \n\ +#---------------------------------------------------------------------------- \n\ + \n\ +0x484AA 0x2440 AGI Demo 1 (PC) 05/87 [AGI 2.425] # A.K.A. Demo 5 \n\ +0x8CC43 0x2917 AGI Demo 2 (PC 5.25) 11/87 [v1] [AGI 2.915] # Demo 1 \n\ +0x8856C 0x2917 AGI Demo 2 (PC 3.5) 11/87 [AGI 2.915] \n\ +0x843AC 0x2917 AGI Demo 2 (PC 5.25) 01/88 [v2] [AGI 2.917] # Demo 3 \n\ +0x89592 0x3149 AGI Demo 3 (PC) 09/88 [AGI 3.002.102] # Demo 4 \n\ +0x24A18 0x2440 Black Cauldron (PC) 2.00 6/14/87 [AGI 2.439] \n\ +0x22B50 0x3149 Black Cauldron (PC 5.25) 2.10 11/10/88 [AGI 3.002.098] \n\ +0x23E0E 0x3149 Black Cauldron (PC 3.5) 2.10 11/10/88 [AGI 3.002.098] \n\ +0xB5A25 0x3149 Gold Rush! (PC 5.25) 2.01 12/22/88 [AGI 3.002.149] \n\ +0xB1C9E 0x3149 Gold Rush! (PC 3.5) 2.01 12/22/88 [AGI 3.002.149] \n\ +0x49EDA 0x2917 King's Quest 1 (PC 5.25/3.5) 2.0F [AGI 2.917] # also 2.425 \n\ +0x633CB 0x2440 King's Quest 2 (PC 5.25/3.5) 2.1 [AGI 2.411] \n\ +0x63338 0x2917 King's Quest 2 (PC 5.25/3.5) 2.2 [AGI 2.426] # also 2.917 \n\ +0x88673 0x2272 King's Quest 3 (PC) 1.01 11/08/86 [AGI 2.272] \n\ +0x840D3 0x2440 King's Quest 3 (PC 5.25) 2.00 5/25/87 [AGI 2.435] \n\ +0x83191 0x2440 King's Quest 3 (PC 3.5) 2.00 5/25/87 [AGI 2.435] \n\ +0x83695 0x2936 King's Quest 3 (PC 3.5) 2.14 3/15/88 [AGI 2.936] \n\ +0x8410B 0x2936 King's Quest 3 (PC 5.25) 2.14 3/15/88 [AGI 2.936] \n\ +0xB124B 0x3086 King's Quest 4 (PC 3.5) 2.0 7/27/88 [AGI 3.002.086] \n\ +0xB291F 0x3086 King's Quest 4 (PC 3.5) 2.2 9/27/88 [AGI 3.002.086] \n\ +0xB3722 0x3086 King's Quest 4 (PC 5.25) 2.3 9/27/88 [AGI 3.002.086] \n\ +0x9CB15 0x3149 King's Quest 4 demo (PC) [AGI 3.002.102] \n\ +0x6F5E1 0x2440 Leisure Suit Larry 1 (PC 5.25/3.5) 1.00 6/1/87 [AGI 2.440] \n\ +0x4C16D 0x3149 Manhunter NY (PC 5.25) 1.22 8/31/88 [AGI 3.002.107] # also 3.003.102 \n\ +0x49687 0x3149 Manhunter NY (PC 3.5) 1.22 8/31/88 [AGI 3.002.102] \n\ +0x53971 0x3149 Manhunter SF (PC 3.5) 3.02 7/26/89 [AGI 3.002.149] \n\ +0x584F9 0x3149 Manhunter SF (PC 5.25) 3.03 8/17/89 [AGI 3.002.149] \n\ +0x5D77C 0x2917 Mixed-Up Mother Goose (PC) [AGI 2.915] \n\ +0x5D7C6 0x2917 Mixed Up Mother Goose (PC) [AGI 2.915] (Broken) \n\ +0x7F18B 0x2917 Police Quest 1 (PC) 2.0A 10/23/87 [AGI 2.903/2.911] \n\ +0x7EF35 0x2917 Police Quest 1 (PC) 2.0E 11/17/87 [AGI 2.915] \n\ +0x7EF06 0x2917 Police Quest 1 (PC 5.25/ST) 2.0G 12/03/87 [AGI 2.917] \n\ +0x7E0BC 0x2917 Police Quest 1 (PC 3.5) 2.0G 12/03/87 [AGI 2.917] \n\ +0x67FCC 0x2089 Space Quest 1 (PC) 1.0 [AGI 2.089] \n\ +0x68036 0x2089 Space Quest 1 (PC) 1.0X [AGI 2.089] \n\ +0x67F6E 0x2272 Space Quest 1 (PC) 1.1A [AGI 2.272] \n\ +0x68244 0x2440 Space Quest 1 (PC 5.25/3.5) 2.2 [AGI 2.426/2.917] \n\ +0x8DB32 0x2917 Space Quest 2 (PC 5.25) 2.0A [AGI 2.912] \n\ +0x8D825 0x2917 Space Quest 2 (PC 3.5) 2.0A [AGI 2.912] \n\ +0x8DA3E 0x2917 Space Quest 2 (PC 5.25/ST) 2.0C/A [AGI 2.915] \n\ +0x8E6A7 0x2917 Space Quest 2 (PC 3.5) 2.0C/B [AGI 2.917] \n\ +0x8E29B 0x2936 Space Quest 2 (PC 3.5) 2.0F [AGI 2.936] \n\ +0x8DF84 0x2936 Space Quest 2 (PC 5.25) 2.0D [AGI 2.936] \n\ +0x8DE46 0x2936 Space Quest 2 (PC 3.5) 2.0D [AGI 2.936] \n\ +0x8E310 0x2936 Space Quest 2 (PC 5.25) 2.0F [AGI 2.936] \n\ +0x31677 0x2272 Xmas Card 1986 (PC) [AGI 2.272] \n\ + \n\ +#---------------------------------------------------------------------------- \n\ +# Apple //gs versions \n\ +# all guessed interpreter versions \n\ +# \n\ +# Notes: \n\ +# - (CE) in Apple IIgs versions stands for Carlos Escobar --PDD \n\ +#---------------------------------------------------------------------------- \n\ + \n\ +0x93260 0x2917 AGI Demo 2 (IIgs) 1.0C (Censored) \n\ +0x285FB 0x3149 Black Cauldron (Apple IIgs) 1.0O 2/24/89 (CE) # 2.24.89 (CE) \n\ +0xB6F67 0x3149 Gold Rush! (Apple IIgs) 1.0M 2/28/89 (CE) aka 2.01 12/22/88 \n\ +0x4A9E8 0x2272 King's Quest 1 (IIgs) 1.0S-88223 \n\ +0x79D1B 0x2917 King's Quest 2 (IIgs) 2.0A 6/16/88 (CE) \n\ +0x85CD4 0x2917 King's Quest 3 (IIgs) 2.0A 8/28/88 (CE) \n\ +0xAF778 0x3086 King's Quest 4 (IIgs) 1.0K 11/22/88 (CE) \n\ +0x6E41E 0x2440 Leisure Suit Larry 1 (IIgs) 1.0E \n\ +0x4C705 0x3149 Manhunter NY (IIgs) 2.0E 10/05/88 (CE) \n\ +0x5F4E8 0x2917 Mixed Up Mother Goose (IIgs) \n\ +0x7DB3F 0x2917 Police Quest 1 (IIgs) 2.0A-88318 \n\ +0x7DBE5 0x2917 Police Quest 1 (IIgs) 2.0B-88421 \n\ +0x69EC0 0x2917 Space Quest 1 (IIgs) 2.2 \n\ +0x8E983 0x2936 Space Quest 2 (IIgs) 2.0A 7/25/88 (CE) \n\ + \n\ +#---------------------------------------------------------------------------- \n\ +# Macintosh versions \n\ +# all guessed interpreter versions \n\ +#---------------------------------------------------------------------------- \n\ + \n\ +0x4C02C 0x2440 King's Quest 1 (Mac) 2.0C \n\ +0x6382E 0x2440 King's Quest 2 (Mac) 2.0R \n\ +0x8410B 0x2440 King's Quest 3 (Mac) 2.14 3/15/88 \n\ +0x78202 0x2440 Leisure Suit Larry 1 (Mac) 1.05 6/26/87 \n\ +0x7EF06 0x2440 Police Quest 1 (Mac) 2.0G 12/3/87 \n\ +0x6A277 0x2440 Space Quest 1 (Mac) 1.5D \n\ +0x8DF84 0x2936 Space Quest 2 (Mac) 2.0D \n\ + \n\ +#---------------------------------------------------------------------------- \n\ +# Atari ST versions \n\ +# all guessed interpreter versions \n\ +# \n\ +# Notes: \n\ +# - Chris Iden wrote the Atari ST port of AGI --PDD \n\ +#---------------------------------------------------------------------------- \n\ + \n\ +0x1A7AF 0x2272 Donald Duck's Playground (ST) 1.0A 8/8/86 \n\ +0x4A079 0x2272 King's Quest 1 (ST) 1.0V \n\ +0x882B7 0x2272 King's Quest 3 (ST) 1.02 11/18/86 \n\ +0xB68AB 0x3149 Gold Rush! (ST) 1.01 1/13/89 aka 2.01 12/22/88 \n\ +0x6F7E1 0x2440 Leisure Suit Larry 1 (ST) 1.04 6/18/87 \n\ +0x4CE19 0x3149 Manhunter NY (ST) 1.03 10/20/88 \n\ +0x5360B 0x3149 Manhunter SF (ST) 1.0 7/29/89 \n\ +0x69597 0x2440 Space Quest 1 (ST) 1.1A \n\ + \n\ +#---------------------------------------------------------------------------- \n\ +# Amiga versions \n\ +# Use option -A- to enable padding \n\ +# \n\ +# Notes: \n\ +# - Amiga KQ3 (2.333) seems to need interpreter version 3.002.086 \n\ +#---------------------------------------------------------------------------- \n\ + \n\ +0x25640 0x2440 [A] Black Cauldron (Amiga) 2.00 6/14/87 # guessed int \n\ +0x1AFBA 0x2272 [A] Donald Duck's Playground (Amiga) 1.0C # guessed int \n\ +0xB3E1A 0x3149 [A] Gold Rush! (Amiga) 1.01 1/13/89 aka 2.05 3/9/89 # 2.316 \n\ +0x49C6B 0x2440 [A] King's Quest 1 (Amiga) 1.0U # 2.082 \n\ +0x5D395 0x2440 [A] King's Quest 2 (Amiga) 2.0J # guessed int \n\ +0x5BCE6 0x2440 [A] King's Quest 2 (Amiga) 2.0J (Broken) \n\ +0x5F4B9 0x2440 [A] King's Quest 2 (Amiga) 2.0J (Broken) # 2.176 \n\ +0x888C1 0x2440 [A] King's Quest 3 (Amiga) 1.01 11/8/86 \n\ +0x84793 0x3086 [A] King's Quest 3 (Amiga) 2.15 11/15/89 # 2.333 \n\ +0x6FDDB 0x2440 [A] Leisure Suit Larry 1 (Amiga) 1.05 6/26/87 # x.yyy \n\ +0x4BA94 0x3149 [A] Manhunter NY (Amiga) 1.06 3/18/89 # x.yyy \n\ +0x53D51 0x3086 [A] Manhunter SF (Amiga) 3.06 8/17/89 # 2.333 \n\ +0x5CFB1 0x3086 [A] Mixed-Up Mother Goose (Amiga) 1.1 # guessed int \n\ +0x7F752 0x3149 [A] Police Quest 1 (Amiga) 2.0B 2/22/89 # 2.310 \n\ +0x696DD 0x2440 [A] Space Quest 1 (Amiga) 1.2 # 2.082 \n\ +0x8FEA6 0x2936 [A] Space Quest 2 (Amiga) 2.0F # 2.202 \n\ + \n\ +#---------------------------------------------------------------------------- \n\ +# CoCo versions \n\ +# what version of DOS AGI does CoCo 2.023 correspond with? \n\ +# guessing 2.272 because the PC version 1.0 is 2.272; doesn't fit date though \n\ +# \n\ +# Notes: \n\ +# - Chris Iden wrote the CoCo port of AGI --PDD \n\ +#---------------------------------------------------------------------------- \n\ + \n\ +0x7CBE8 0x2272 King's Quest 3 (CoCo3) 1.0C 6/27/88 # 2.023 \n\ +0x70D35 0x2440 Leisure Suit Larry 1 (CoCo3) \n\ + \n\ +#---------------------------------------------------------------------------- \n\ +# AGDS games \n\ +# Use option -a- for AGDS games \n\ +#---------------------------------------------------------------------------- \n\ + \n\ +0x5501A 0x2440 [a] Groza # AGDS sample game \n\ + \n\ +#---------------------------------------------------------------------------- \n\ +# Fan-made AGI games \n\ +#---------------------------------------------------------------------------- \n\ + \n\ +0x3F2F7 0x2917 [m] AGI Mouse 0.7 Demo \n\ +0x3F744 0x2917 [m] AGI Mouse 1.0 Demo # 2.917 6/24/00 \n\ +0x3F74F 0x2917 [m] AGI Mouse 1.1 Demo # 2.917 1/01/01 \n\ +0x17599 0x2917 [m] Sliding Tile Game v1.00 # 2.917 6/02/01 \n\ +0x785c4 0x2936 [m] Jolimie v0.6 # 2.936 2000 \n\ +#Jolimie uses AGIPal only and not AGIMouse; no way to separate these currently \n\ +0x40D80 0x2440 AGI Trek # 2.440 9/21/98 \n\ +0x64CB7 0x2440 Space Trek 1.0 # 2.440 12/13/98 \n\ +0x6596A 0x2917 Space Trek (remake) # 2.917 6/09/99 \n\ +0x96909 0x2917 Operation: RECON teaser 1.1 # \n\ +0x185A6 0x2917 AGI Piano v1.0 # ? 1998 \n\ +0x91ACF 0x2917 Dave's Quest .07 # ? \n\ +0x620F6 0x2917 Time Quest demo D0.2 # ? 1998 \n\ +0x7466F 0x2917 Tex McPhilip I # ? 2000 \n\ +0x9E400 0x2917 Tex McPhilip II # ? 2000 \n\ +0xAB9A8 0x2917 Justin Quest 1.0 # 2.917 \n\ +0x7D473 0x2917 The Ruby Cast demo 0.2 # 2.917 1998 \n\ +0xB4D7A 0x2917 Residence 44 Quest 1.0a # 2.917 1999 \n\ +0x5D077 0x2917 Escape Quest demo # ? 1998 \n\ +0x5A434 0x2917 Acidopolis (1.0) demo # ? \n\ +0x45CDF 0x2917 Go West, Young Hippie demo # 2.917 \n\ +0x4C9DC 0x2917 Speeder Bike Challenge v1.0 # ? \n\ +0x112BF9 0x2917 Space Quest 0: Replicated 1.04 # 6/27/2003 \n\ +0x6E70F 0x2917 Space Quest: The Lost Chapter v10.0 \n\ +0x5859E 0x2917 Phantasmagoria \n\ +0x7B5DF 0x2917 Dashiki demo \n\ +0x9405B 0x2917 Dashiki 256-color demo (Unsupported) \n\ +0x6ADCD 0x2917 Jen's Quest 0.1 demo \n\ +0x4EE64 0x2917 Monkey Man \n\ +"; + +int setup_v2_game(int ver, uint32 crc); +int setup_v3_game(int ver, uint32 crc); +int v4id_game(uint32 crc); + +uint32 match_crc(uint32 crc, char *name, int len) { + char *c, *t, buf[256]; + uint32 id, ver; + + Common::MemoryReadStream f((const byte *)ids_database, strlen(ids_database)); + + while (!f.eos()) { + f.readLine(buf, 256); + c = strchr(buf, '#'); + if (c) + *c = 0; + + /* Remove spaces at end of line */ + if (strlen(buf)) { + for (c = buf + strlen(buf) - 1; + *c == ' ' || *c == '\t'; *c-- = 0) { + } + } + + t = strtok(buf, " \t\r\n"); + if (t == NULL) + continue; + id = strtoul(t, NULL, 0); + + t = strtok(NULL, " \t\r\n"); + if (t == NULL) + continue; + ver = strtoul(t, NULL, 0); + + t = strtok(NULL, "\n\r"); + for (; *t == ' ' || *t == '\t'; t++); + + if (id == crc) { + /* Now we must check options enclosed in brackets + * like [A] for Amiga + */ + + if (*t == '[') { + while (*t != ']') { + switch (*t++) { + case 'A': + opt.amiga = true; + break; + case 'a': + opt.agds = true; + break; +#ifdef USE_MOUSE + case 'm': + opt.agimouse = true; + break; +#endif + } + } + t++; + + for (; (*t == ' ' || *t == '\t') && *t; t++) { + } + } + + strncpy(name, t, len); + return ver; + } + } + + return 0; +} + +static uint32 match_version(uint32 crc) { + int ver; + char name[80]; + + if ((ver = match_crc(crc, name, 80)) > 0) + report("AGI game detected: %s\n\n", name); + + return ver; +} + +int v2id_game() { + int y, ver; + uint32 len, c, crc; + uint8 *buff; + Common::File fp; + char *fn[] = { "viewdir", "logdir", "picdir", "snddir", "words.tok", "object", "" }; + + buff = (uint8 *)malloc(8192); + + for (crc = y = 0; fn[y][0]; y++) { + char *path = fn[y]; + if (fp.open(path)) { + for (len = 1; len > 0;) { + memset(buff, 0, 8192); + len = fp.read(buff, 8000); + for (c = 0; c < len; c++) + crc += *(buff + c); + } + fp.close(); + } + } + free(buff); + + report("Computed CRC: 0x%05x\n", crc); + ver = match_version(crc); + game.crc = crc; + game.ver = ver; + debugC(2, kDebugLevelMain, "game.ver = 0x%x", game.ver); + agi_set_release(ver); + return setup_v2_game(ver, crc); +} + +/* + * Currently, there is no known difference between v3.002.098 -> v3.002.149 + * So version emulated; + * + * 0x0086, + * 0x0149 + */ + +int v3id_game() { + int ec = err_OK, y, ver; + uint32 len, c, crc; + uint8 *buff; + Common::File fp; + char *fn[] = { "words.tok", "object", "" }; + Common::String path; + + buff = (uint8 *)malloc(8192); + + for (crc = 0, y = 0; fn[y][0] != 0x0; y++) { + path = fn[y]; + if (fp.open(path)) { + len = 1; + while (len > 0) { + memset(buff, 0, 8192); + len = fp.read(buff, 8000); + for (c = 0; c < len; c++) + crc += *(buff + c); + } + fp.close(); + } + } + + /* now do the directory file */ + + path = Common::String(game.name) + DIR_; + + if (fp.open(path)) { + for (len = 1; len > 0;) { + memset(buff, 0, 8192); + len = fp.read(buff, 8000); + for (c = 0; c < len; c++) + crc += *(buff + c); + } + fp.close(); + } + + free(buff); + + report("Computed CRC: 0x%05x\n", crc); + ver = match_version(crc); + game.crc = crc; + game.ver = ver; + agi_set_release(ver); + + ec = setup_v3_game(ver, crc); + + return ec; +} + +/** + * + */ +int setup_v2_game(int ver, uint32 crc) { + int ec = err_OK; + + if (ver == 0) { + report("Unknown v2 Sierra game: %08x\n\n", crc); + agi_set_release(0x2917); + } + + /* setup the differences in the opcodes and other bits in the + * AGI v2 specs + */ + if (opt.emuversion) + agi_set_release(opt.emuversion); + + if (opt.agds) + agi_set_release(0x2440); /* ALL AGDS games built for 2.440 */ + + switch (agi_get_release()) { + case 0x2089: + logic_names_cmd[0x86].num_args = 0; /* quit: 0 args */ + logic_names_cmd[0x97].num_args = 3; /* print.at: 3 args */ + logic_names_cmd[0x98].num_args = 3; /* print.at.v: 3 args */ + break; + case 0x2272: + /* KQ3 0x88673 (2.272) requires print.at with 4 arguments */ + break; + case 0x2440: + break; + case 0x2917: + break; + case 0x2936: + break; + default: + report("** Cannot setup for unknown version\n"); + ec = err_UnknownAGIVersion; + break; + } + + return ec; +} + +/** + * + */ +int setup_v3_game(int ver, uint32 crc) { + int ec = err_OK; + + if (ver == 0) { + report("Unknown v3 Sierra game: %08x\n\n", crc); + agi_set_release(ver = 0x3149); + } + + if (opt.emuversion) + agi_set_release(ver = opt.emuversion); + + switch (ver) { + case 0x3086: + logic_names_cmd[0xad].num_args = 1; /* 173 : 1 args */ + break; + case 0x3149: + logic_names_cmd[0xad].num_args = 0; /* 173 : 0 args */ + break; + default: + report("Error: cannot setup for unknown version\n"); + ec = err_UnknownAGIVersion; + break; + } + + return ec; +} + +} // End of namespace Agi diff --git a/engines/agi/inv.cpp b/engines/agi/inv.cpp new file mode 100644 index 0000000000..4d4014027e --- /dev/null +++ b/engines/agi/inv.cpp @@ -0,0 +1,212 @@ +/* ScummVM - Scumm Interpreter + * Copyright (C) 2006 The ScummVM project + * + * Copyright (C) 1999-2001 Sarien Team + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + * $URL$ + * $Id$ + * + */ + +#include "common/stdafx.h" + +#include "agi/agi.h" +#include "agi/sprite.h" +#include "agi/graphics.h" +#include "agi/keyboard.h" +#include "agi/text.h" +#include "agi/keyboard.h" + +namespace Agi { + +/* + * Messages and coordinates + */ + +#define NOTHING_X 16 +#define NOTHING_Y 3 +#define NOTHING_MSG "nothing" + +#define ANY_KEY_X 4 +#define ANY_KEY_Y 24 +#define ANY_KEY_MSG "Press a key to return to the game" + +#define YOUHAVE_X 11 +#define YOUHAVE_Y 0 +#define YOUHAVE_MSG "You are carrying:" + +#define SELECT_X 2 +#define SELECT_Y 24 +#define SELECT_MSG "Press ENTER to select, ESC to cancel" + +static uint8 *intobj = NULL; + +static void print_item(int n, int fg, int bg) +{ + print_text(object_name(intobj[n]), 0, n % 2 ? 39 - strlen(object_name(intobj[n])) : 1, + (n / 2) + 2, 40, fg, bg); +} + +#ifdef USE_MOUSE +static int find_item() { + int r, c; + + r = mouse.y / CHAR_LINES; + c = mouse.x / CHAR_COLS; + + debugC(6, kDebugLevelInventory, "r = %d, c = %d", r, c); + + if (r < 2) + return -1; + + return (r - 2) * 2 + (c > 20); +} +#endif + +static int show_items() { + unsigned int x, i; + + for (x = i = 0; x < game.num_objects; x++) { + if (object_get_location(x) == EGO_OWNED) { + /* add object to our list! */ + intobj[i] = x; + print_item(i, STATUS_FG, STATUS_BG); + i++; + } + } + + if (i == 0) { + print_text(NOTHING_MSG, 0, NOTHING_X, NOTHING_Y, 40, STATUS_FG, STATUS_BG); + } + + return i; +} + +static void select_items(int n) { + int fsel = 0; + + while (42) { + if (n > 0) + print_item(fsel, STATUS_BG, STATUS_FG); + + switch (wait_any_key()) { + case KEY_ENTER: + setvar(V_sel_item, intobj[fsel]); + goto exit_select; + case KEY_ESCAPE: + setvar(V_sel_item, 0xff); + goto exit_select; + case KEY_UP: + if (fsel >= 2) + fsel -= 2; + break; + case KEY_DOWN: + if (fsel + 2 < n) + fsel += 2; + break; + case KEY_LEFT: + if (fsel % 2 == 1) + fsel--; + break; + case KEY_RIGHT: + if (fsel % 2 == 0 && fsel + 1 < n) + fsel++; + break; +#ifdef USE_MOUSE + case BUTTON_LEFT:{ + int i = find_item(); + if (i >= 0 && i < n) { + setvar(V_sel_item, intobj[fsel = i]); + debugC(6, kDebugLevelInventory, "item found: %d", fsel); + show_items(); + print_item(fsel, STATUS_BG, STATUS_FG); + do_update(); + goto exit_select; + } + break; + } +#endif + default: + break; + } + + show_items(); + do_update(); + } + + exit_select: + debugC(6, kDebugLevelInventory, "selected: %d", fsel); +} + +/* + * Public functions + */ + +/** + * Display inventory items. + */ +void inventory() { + int old_fg, old_bg; + int n; + + /* screen is white with black text */ + old_fg = game.color_fg; + old_bg = game.color_bg; + game.color_fg = 0; + game.color_bg = 15; + clear_screen(game.color_bg); + + print_text(YOUHAVE_MSG, 0, YOUHAVE_X, YOUHAVE_Y, 40, STATUS_FG, STATUS_BG); + + /* FIXME: doesn't check if objects overflow off screen... */ + + intobj = (uint8 *) malloc(4 + game.num_objects); + memset(intobj, 0, (4 + game.num_objects)); + + n = show_items(); + + if (getflag(F_status_selects_items)) { + print_text(SELECT_MSG, 0, SELECT_X, SELECT_Y, 40, STATUS_FG, STATUS_BG); + } else { + print_text(ANY_KEY_MSG, 0, ANY_KEY_X, ANY_KEY_Y, 40, STATUS_FG, STATUS_BG); + } + + flush_screen(); + + /* If flag 13 is set, we want to highlight & select an item. + * opon selection, put objnum in var 25. Then on esc put in + * var 25 = 0xff. + */ + + if (getflag(F_status_selects_items)) + select_items(n); + + free(intobj); + + if (!getflag(F_status_selects_items)) + wait_any_key(); + + clear_screen(0); + write_status(); + show_pic(); + game.color_fg = old_fg; + game.color_bg = old_bg; + game.has_prompt = 0; + flush_lines(game.line_user_input, 24); +} + +} // End of namespace Agi diff --git a/engines/agi/keyboard.cpp b/engines/agi/keyboard.cpp new file mode 100644 index 0000000000..998b95f1cd --- /dev/null +++ b/engines/agi/keyboard.cpp @@ -0,0 +1,388 @@ +/* ScummVM - Scumm Interpreter + * Copyright (C) 2006 The ScummVM project + * + * Copyright (C) 1999-2003 Sarien Team + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + * $URL$ + * $Id$ + * + */ + +#include "common/stdafx.h" + +#include "agi/agi.h" +#include "agi/graphics.h" +#include "agi/keyboard.h" +#include "agi/menu.h" +#include "agi/text.h" /* remove later */ + +namespace Agi { + +char last_sentence[40]; + +#ifdef USE_CONSOLE +extern struct agi_console console; +#endif + +/* FIXME */ +extern int open_dialogue; + +struct string_data { + int x; + int y; + int len; + int str; +}; + +struct string_data stringdata; + +/* + * IBM-PC keyboard scancodes + */ +uint8 scancode_table[26] = { + 30, /* A */ + 48, /* B */ + 46, /* C */ + 32, /* D */ + 18, /* E */ + 33, /* F */ + 34, /* G */ + 35, /* H */ + 23, /* I */ + 36, /* J */ + 37, /* K */ + 38, /* L */ + 50, /* M */ + 49, /* N */ + 24, /* O */ + 25, /* P */ + 16, /* Q */ + 19, /* R */ + 31, /* S */ + 20, /* T */ + 22, /* U */ + 47, /* V */ + 17, /* W */ + 45, /* X */ + 21, /* Y */ + 44 /* Z */ +}; + +void init_words() { + game.num_ego_words = 0; +} + +void clean_input() { + while (game.num_ego_words) + free(game.ego_words[--game.num_ego_words].word); +} + +void get_string(int x, int y, int len, int str) { + new_input_mode(INPUT_GETSTRING); + stringdata.x = x; + stringdata.y = y; + stringdata.len = len; + stringdata.str = str; +} + +/** + * Raw key grabber. + * poll_keyboard() is the raw key grabber (above the gfx driver, that is). + * It handles console keys and insulates AGI from the console. In the main + * loop, handle_keys() handles keyboard input and ego movement. + */ +int do_poll_keyboard() { + int key = 0; + + /* If a key is ready, rip it */ + if (keypress()) { + key = get_key(); + debugC(3, kDebugLevelInput, "key %02x pressed", key); + } + + return key; +} + +int handle_controller(int key) { + struct vt_entry *v = &game.view_table[0]; + int i; + + /* The Black Cauldron needs KEY_ESCAPE to use menus */ + if (key == 0 /*|| key == KEY_ESCAPE */ ) + return false; + + debugC(3, kDebugLevelInput, "key = %04x", key); + + for (i = 0; i < MAX_DIRS; i++) { + if (game.ev_keyp[i].data == key) { + debugC(3, kDebugLevelInput, "event %d: key press", i); + game.ev_keyp[i].occured = true; + report("event AC:%i occured\n", i); + return true; + } + } + +#ifdef USE_MOUSE + if (key == BUTTON_LEFT) { + if (getflag(F_menus_work) && mouse.y <= CHAR_LINES) { + new_input_mode(INPUT_MENU); + return true; + } + } +#endif + + if (game.player_control) { + int d = 0; + + if (!KEY_ASCII(key)) { + switch (key) { + case KEY_UP: + d = 1; + break; + case KEY_DOWN: + d = 5; + break; + case KEY_LEFT: + d = 7; + break; + case KEY_RIGHT: + d = 3; + break; + case KEY_UP_RIGHT: + d = 2; + break; + case KEY_DOWN_RIGHT: + d = 4; + break; + case KEY_UP_LEFT: + d = 8; + break; + case KEY_DOWN_LEFT: + d = 6; + break; + } + } +#ifdef USE_MOUSE + if (!opt.agimouse) { + /* Handle mouse button events */ + if (key == BUTTON_LEFT) { + v->flags |= ADJ_EGO_XY; + v->parm1 = WIN_TO_PIC_X(mouse.x); + v->parm2 = WIN_TO_PIC_Y(mouse.y); + return true; + } + } +#endif + + v->flags &= ~ADJ_EGO_XY; + + if (d || key == KEY_STATIONARY) { + v->direction = v->direction == d ? 0 : d; + return true; + } + } + + return false; +} + +void handle_getstring(int key) { + static int pos = 0; /* Cursor position */ + static char buf[40]; + + if (KEY_ASCII(key) == 0) + return; + + debugC(3, kDebugLevelInput, "handling key: %02x", key); + + switch (key) { + case KEY_ENTER: + debugC(3, kDebugLevelInput, "KEY_ENTER"); + game.has_prompt = 0; + buf[pos] = 0; + strcpy(game.strings[stringdata.str], buf); + debugC(3, kDebugLevelInput, "buffer=[%s]", buf); + buf[pos = 0] = 0; + new_input_mode(INPUT_NORMAL); + print_character(stringdata.x + strlen(game.strings[stringdata.str]) + 1, + stringdata.y, ' ', game.color_fg, game.color_bg); + return; + case KEY_ESCAPE: + debugC(3, kDebugLevelInput, "KEY_ESCAPE"); + game.has_prompt = 0; + buf[pos = 0] = 0; + strcpy(game.strings[stringdata.str], buf); + new_input_mode(INPUT_NORMAL); + /* new_input_mode (INPUT_MENU); */ + break; + case KEY_BACKSPACE: /*0x08: */ + if (!pos) + break; + + print_character(stringdata.x + (pos + 1), stringdata.y, + ' ', game.color_fg, game.color_bg); + + pos--; + buf[pos] = 0; + break; + default: + if (key < 0x20 || key > 0x7f) + break; + + if (pos >= stringdata.len) + break; + + buf[pos++] = key; + buf[pos] = 0; + + /* Echo */ + print_character(stringdata.x + pos, stringdata.y, buf[pos - 1], + game.color_fg, game.color_bg); + + break; + } + + /* print cursor */ + print_character(stringdata.x + pos + 1, stringdata.y, + (char)game.cursor_char, game.color_fg, game.color_bg); +} + +void handle_keys(int key) { + uint8 *p = NULL; + int c = 0; + static uint8 formated_entry[256]; + int l = game.line_user_input; + int fg = game.color_fg, bg = game.color_bg; + + setvar(V_word_not_found, 0); + + debugC(3, kDebugLevelInput, "handling key: %02x", key); + + switch (key) { + case KEY_ENTER: + debugC(3, kDebugLevelInput, "KEY_ENTER"); + game.keypress = 0; + + /* Remove all leading spaces */ + for (p = game.input_buffer; *p && *p == 0x20; p++); + + /* Copy to internal buffer */ + for (; *p; p++) { + /* Squash spaces */ + if (*p == 0x20 && *(p + 1) == 0x20) { + p++; + continue; + } + formated_entry[c++] = tolower(*p); + } + formated_entry[c++] = 0; + + /* Handle string only if it's not empty */ + if (formated_entry[0]) { + strcpy((char *)game.echo_buffer, (const char *)game.input_buffer); + strcpy(last_sentence, (const char *)formated_entry); + dictionary_words(last_sentence); + } + + /* Clear to start a new line */ + game.has_prompt = 0; + game.input_buffer[game.cursor_pos = 0] = 0; + debugC(3, kDebugLevelInput, "clear lines"); + clear_lines(l, l + 1, bg); + flush_lines(l, l + 1); + + break; + case KEY_ESCAPE: + debugC(3, kDebugLevelInput, "KEY_ESCAPE"); + new_input_mode(INPUT_MENU); + break; + case KEY_BACKSPACE: + /* Ignore backspace at start of line */ + if (game.cursor_pos == 0) + break; + + /* erase cursor */ + print_character(game.cursor_pos + 1, l, ' ', fg, bg); + game.input_buffer[--game.cursor_pos] = 0; + /* Print cursor */ + print_character(game.cursor_pos + 1, l, game.cursor_char, fg, bg); + break; + default: + /* Ignore invalid keystrokes */ + if (key < 0x20 || key > 0x7f) + break; + + /* Maximum input size reached */ + if (game.cursor_pos >= getvar(V_max_input_chars)) + break; + + game.input_buffer[game.cursor_pos++] = key; + game.input_buffer[game.cursor_pos] = 0; + + /* echo */ + print_character(game.cursor_pos, l, game.input_buffer[game.cursor_pos - 1], fg, bg); + + /* Print cursor */ + print_character(game.cursor_pos + 1, l, game.cursor_char, fg, bg); + break; + } +} + +int wait_key() { + int key; + + /* clear key queue */ + while (keypress()) { + get_key(); + } + + debugC(3, kDebugLevelInput, "waiting..."); + while (42) { + poll_timer(); /* msdos driver -> does nothing */ + key = do_poll_keyboard(); + if (!console_keyhandler(key)) { + if (key == KEY_ENTER || key == KEY_ESCAPE +#ifdef USE_MOUSE + || key == BUTTON_LEFT +#endif + ) + break; + } + console_cycle(); + } + return key; +} + +int wait_any_key() { + int key; + + /* clear key queue */ + while (keypress()) { + get_key(); + } + + debugC(3, kDebugLevelInput, "waiting..."); + while (42) { + poll_timer(); /* msdos driver -> does nothing */ + key = do_poll_keyboard(); + if (!console_keyhandler(key) && key) + break; + console_cycle(); + } + return key; +} + +} // End of namespace Agi diff --git a/engines/agi/keyboard.h b/engines/agi/keyboard.h new file mode 100644 index 0000000000..7e507e5f97 --- /dev/null +++ b/engines/agi/keyboard.h @@ -0,0 +1,94 @@ +/* ScummVM - Scumm Interpreter + * Copyright (C) 2006 The ScummVM project + * + * Copyright (C) 1999-2001 Sarien Team + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + * $URL$ + * $Id$ + * + */ + +#ifndef __AGI_KEYBOARD_H +#define __AGI_KEYBOARD_H + +#include "common/stdafx.h" + +#include "agi/agi.h" + +namespace Agi { + +/* QNX4 has a KEY_DOWN defined which we don't need to care about */ +#undef KEY_DOWN + +/* Allegro defines these */ +#undef KEY_BACKSPACE +#undef KEY_ENTER +#undef KEY_LEFT +#undef KEY_RIGHT +#undef KEY_UP +#undef KEY_PGUP +#undef KEY_PGDN +#undef KEY_HOME +#undef KEY_END + +#define KEY_BACKSPACE 0x08 +#define KEY_ESCAPE 0x1B +#define KEY_ENTER 0x0D +#define KEY_UP 0x4800 +#define KEY_DOWN 0x5000 +#define KEY_LEFT 0x4B00 +#define KEY_STATIONARY 0x4C00 +#define KEY_RIGHT 0x4D00 + +#define KEY_DOWN_LEFT 0x4F00 +#define KEY_DOWN_RIGHT 0x5100 +#define KEY_UP_LEFT 0x4700 +#define KEY_UP_RIGHT 0x4900 + +#define KEY_STATUSLN 0xd900 /* F11 */ +#define KEY_PRIORITY 0xda00 /* F12 */ + +#define KEY_PGUP 0x4900 /* Page Up (fixed by Ziv Barber) */ +#define KEY_PGDN 0x5100 /* Page Down */ +#define KEY_HOME 0x4700 /* Home */ +#define KEY_END 0x4f00 /* End * */ + +#ifdef USE_MOUSE +#define BUTTON_LEFT 0xF101 /* Left mouse button */ +#define BUTTON_RIGHT 0xF202 /* Right mouse button */ +#endif + +#define KEY_SCAN(k) (k >> 8) +#define KEY_ASCII(k) (k & 0xff) + +extern uint8 scancode_table[]; + +void init_words(void); +void clean_input(void); +int do_poll_keyboard(void); +void clean_keyboard(void); +void handle_keys(int); +void handle_getstring(int); +int handle_controller(int); +void get_string(int, int, int, int); +uint16 agi_get_keypress(void); +int wait_key(void); +int wait_any_key(void); + +} // End of namespace Agi + +#endif /* __AGI_KEYBOARD_H */ diff --git a/engines/agi/list.h b/engines/agi/list.h new file mode 100644 index 0000000000..999c591ce0 --- /dev/null +++ b/engines/agi/list.h @@ -0,0 +1,140 @@ +/* + * $Id$ + * + * List management macros from the Linux kernel + */ + +#ifndef _LINUX_LIST_H +#define _LINUX_LIST_H + +#include "agi/agi.h" + +namespace Agi { + +/** + * Simple doubly linked list implementation. + * + * Some of the internal functions ("__xxx") are useful when + * manipulating whole lists rather than single entries, as + * sometimes we already know the next/prev entries and we can + * generate better code by using them directly rather than + * using the generic single-entry routines. + */ + +struct list_head { + struct list_head *next, *prev; +}; + +#define LIST_HEAD_INIT(name) { &(name), &(name) } + +#define LIST_HEAD(name) \ + struct list_head name = LIST_HEAD_INIT(name) + +#define INIT_LIST_HEAD(ptr) do { \ + (ptr)->next = (ptr); (ptr)->prev = (ptr); \ +} while (0) + +/* + * Insert a new entry between two known consecutive entries. + * + * This is only for internal list manipulation where we know + * the prev/next entries already! + */ +static INLINE void __list_add(struct list_head *tnew, struct list_head *prev, struct list_head *next) { + next->prev = tnew; + tnew->next = next; + tnew->prev = prev; + prev->next = tnew; +} + +/** + * add a new entry + * Insert a new entry after the specified head. + * This is good for implementing stacks. + * + * @param new new entry to be added + * @param head list head to add it after + */ +static INLINE void list_add(struct list_head *tnew, struct list_head *head) { + __list_add(tnew, head, head->next); +} + +/** + * add a new entry + * Insert a new entry before the specified head. + * This is useful for implementing queues. + * + * @new: new entry to be added + * @head: list head to add it before + */ +static INLINE void list_add_tail(struct list_head *tnew, struct list_head *head) { + __list_add(tnew, head->prev, head); +} + +/** + * Delete a list entry (makes prev/next entries point to each other) + * + * This is only for internal list manipulation where we know + * the prev/next entries already! + */ +static INLINE void __list_del(struct list_head *prev, struct list_head *next) { + next->prev = prev; + prev->next = next; +} + +/** + * deletes entry from list. + * @param entry the element to delete from the list. + */ +static INLINE void list_del(struct list_head *entry) { + __list_del(entry->prev, entry->next); +} + +/** + * tests whether a list is empty + * @param head the list to test. + */ +static INLINE int list_empty(struct list_head *head) { + return head->next == head; +} + +/** + * join two lists + * @param list the new list to add. + * @param head the place to add it in the first list. + */ +static INLINE void list_splice(struct list_head *list, struct list_head *head) { + struct list_head *first = list->next; + + if (first != list) { + struct list_head *last = list->prev; + struct list_head *at = head->next; + + first->prev = head; + head->next = first; + + last->next = at; + at->prev = last; + } +} + +/** + * get the struct for this entry + * @param ptr the &struct list_head pointer. + * @param type the type of the struct this is embedded in. + * @param member the name of the list_struct within the struct. + */ +#define list_entry(ptr, type, member) \ + ((type *)((char *)(ptr)-(unsigned long)(&((type *)0)->member))) + +/** + * iterate over a list + * @param pos the &struct list_head to use as a loop counter. + * @param head the head for your list. + */ +#define list_for_each(pos, head, next) \ + for (pos = (head)->next; pos != (head); pos = pos->next) + +} // End of namespace Agi + +#endif diff --git a/engines/agi/logic.cpp b/engines/agi/logic.cpp new file mode 100644 index 0000000000..1929b3fb3c --- /dev/null +++ b/engines/agi/logic.cpp @@ -0,0 +1,116 @@ +/* ScummVM - Scumm Interpreter + * Copyright (C) 2006 The ScummVM project + * + * Copyright (C) 1999-2001 Sarien Team + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + * $URL$ + * $Id$ + * + */ + +#include "common/stdafx.h" + +#include "agi/agi.h" + +namespace Agi { + +/** + * Decode logic resource + * This function decodes messages from the specified raw logic resource + * into a message list. + * @param n The number of the logic resource to decode. + */ +int decode_logic(int n) { + int ec = err_OK; + int mstart, mend, mc; + uint8 *m0; + + /* decrypt messages at end of logic + build message list */ + + /* report ("decoding logic #%d\n", n); */ + m0 = game.logics[n].data; + + mstart = READ_LE_UINT16(m0) + 2; + mc = *(m0 + mstart); + mend = READ_LE_UINT16(m0 + mstart + 1); + m0 += mstart + 3; /* cover header info */ + mstart = mc << 1; + + /* if the logic was not compressed, decrypt the text messages + * only if there are more than 0 messages + */ + if ((~game.dir_logic[n].flags & RES_COMPRESSED) && mc > 0) + decrypt(m0 + mstart, mend - mstart); /* decrypt messages */ + + /* build message list */ + m0 = game.logics[n].data; + mstart = READ_LE_UINT16(m0) + 2; /* +2 covers pointer */ + game.logics[n].num_texts = *(m0 + mstart); + + /* resetp logic pointers */ + game.logics[n].sIP = 2; + game.logics[n].cIP = 2; + game.logics[n].size = READ_LE_UINT16(m0) + 2; /* logic end pointer */ + + /* allocate list of pointers to point into our data */ + + game.logics[n].texts = (char **)calloc(1 + game.logics[n].num_texts, sizeof(char *)); + + /* cover header info */ + m0 += mstart + 3; + + if (game.logics[n].texts != NULL) { + /* move list of strings into list to make real pointers */ + for (mc = 0; mc < game.logics[n].num_texts; mc++) { + mend = READ_LE_UINT16(m0 + mc * 2); + game.logics[n].texts[mc] = mend ? (char *)m0 + mend - 2 : (char *)""; + } + /* set loaded flag now its all completly loaded */ + game.dir_logic[n].flags |= RES_LOADED; + } else { + /* unload data + * blah DF YA WANKER!!@!@# frag. i'm so dumb. not every logic + * has text + */ + free(game.logics[n].data); + ec = err_NotEnoughMemory; + } + + return ec; +} + +/** + * Unload logic resource + * This function unloads the specified logic resource, freeing any + * memory chunks allocated for this resource. + * @param n The number of the logic resource to unload + */ +void unload_logic(int n) { + if (game.dir_logic[n].flags & RES_LOADED) { + free(game.logics[n].data); + if (game.logics[n].num_texts) + free(game.logics[n].texts); + game.logics[n].num_texts = 0; + game.dir_logic[n].flags &= ~RES_LOADED; + } + + /* if cached, we end up here */ + game.logics[n].sIP = 2; + game.logics[n].cIP = 2; +} + +} // End of namespace Agi diff --git a/engines/agi/logic.h b/engines/agi/logic.h new file mode 100644 index 0000000000..cd6fbf752c --- /dev/null +++ b/engines/agi/logic.h @@ -0,0 +1,49 @@ +/* ScummVM - Scumm Interpreter + * Copyright (C) 2006 The ScummVM project + * + * Copyright (C) 1999-2001 Sarien Team + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + * $URL$ + * $Id$ + * + */ + +#ifndef __AGI_LOGIC_H +#define __AGI_LOGIC_H + +#include "agi/agi.h" + +namespace Agi { + +/** + * AGI logic resource structure. + */ +struct agi_logic { + uint8 *data; /**< raw resource data */ + int size; /**< size of data */ + int sIP; /**< saved IP */ + int cIP; /**< current IP */ + int num_texts; /**< number of messages */ + char **texts; /**< message list */ +}; + +int decode_logic(int); +void unload_logic(int); + +} // End of namespace Agi + +#endif /* __AGI_LOGIC_H */ diff --git a/engines/agi/lzw.cpp b/engines/agi/lzw.cpp new file mode 100644 index 0000000000..29259a5bc9 --- /dev/null +++ b/engines/agi/lzw.cpp @@ -0,0 +1,191 @@ +/* ScummVM - Scumm Interpreter + * Copyright (C) 2006 The ScummVM project + * + * Copyright (C) 1999-2001 Sarien Team + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + * $URL$ + * $Id$ + * + */ + +/*************************************************************************** +** decomp.c +** +** Routines that deal with AGI version 3 specific features. +** The original LZW code is from DJJ, October 1989, p.86. +** It has been modified to handle AGI compression. +** +** (c) 1997 Lance Ewing +***************************************************************************/ + +#include "common/stdafx.h" + +#include "agi/agi.h" +#include "agi/lzw.h" + +namespace Agi { + +#define MAXBITS 12 +#define TABLE_SIZE 18041 /* strange number */ +#define START_BITS 9 + +static int32 BITS, MAX_VALUE, MAX_CODE; +static uint32 *prefix_code; +static uint8 *append_character; +static uint8 *decode_stack; +static int32 input_bit_count = 0; /* Number of bits in input bit buffer */ +static uint32 input_bit_buffer = 0L; + +static void initLZW() { + decode_stack = (uint8 *)calloc(1, 8192); + prefix_code = (uint32 *)malloc(TABLE_SIZE * sizeof(uint32)); + append_character = (uint8 *)malloc(TABLE_SIZE * sizeof(uint8)); + input_bit_count = 0; /* Number of bits in input bit buffer */ + input_bit_buffer = 0L; +} + +static void closeLZW() { + free(decode_stack); + free(prefix_code); + free(append_character); +} + +/*************************************************************************** +** setBITS +** +** Purpose: To adjust the number of bits used to store codes to the value +** passed in. +***************************************************************************/ +int setBITS(int32 value) { + if (value == MAXBITS) + return true; + + BITS = value; + MAX_VALUE = (1 << BITS) - 1; + MAX_CODE = MAX_VALUE - 1; + + return false; +} + +/*************************************************************************** +** decode_string +** +** Purpose: To return the string that the code taken from the input buffer +** represents. The string is returned as a stack, i.e. the characters are +** in reverse order. +***************************************************************************/ +static uint8 *decode_string(uint8 *buffer, uint32 code) { + uint32 i; + + for (i = 0; code > 255;) { + *buffer++ = append_character[code]; + code = prefix_code[code]; + if (i++ >= 4000) { + fprintf(stderr, "lzw: error in code expansion.\n"); + abort(); + } + } + *buffer = code; + + return buffer; +} + +/*************************************************************************** +** input_code +** +** Purpose: To return the next code from the input buffer. +***************************************************************************/ +static uint32 input_code(uint8 **input) { + uint32 r; + + while (input_bit_count <= 24) { + input_bit_buffer |= (uint32) * (*input)++ << input_bit_count; + input_bit_count += 8; + } + r = (input_bit_buffer & 0x7FFF) % (1 << BITS); + input_bit_buffer >>= BITS; + input_bit_count -= BITS; + + return r; +} + +/*************************************************************************** +** expand +** +** Purpose: To uncompress the data contained in the input buffer and store +** the result in the output buffer. The fileLength parameter says how +** many bytes to uncompress. The compression itself is a form of LZW that +** adjusts the number of bits that it represents its codes in as it fills +** up the available codes. Two codes have special meaning: +** +** code 256 = start over +** code 257 = end of data +***************************************************************************/ +void LZW_expand(uint8 *in, uint8 *out, int32 len) { + int32 c, lzwnext, lzwnew, lzwold; + uint8 *s, *end; + + initLZW(); + + setBITS(START_BITS); /* Starts at 9-bits */ + lzwnext = 257; /* Next available code to define */ + + end = (unsigned char *)((long)out + (long)len); + + lzwold = input_code(&in); /* Read in the first code */ + c = lzwold; + lzwnew = input_code(&in); + + while ((out < end) && (lzwnew != 0x101)) { + if (lzwnew == 0x100) { + /* Code to "start over" */ + lzwnext = 258; + setBITS(START_BITS); + lzwold = input_code(&in); + c = lzwold; + *out++ = (char)c; + lzwnew = input_code(&in); + } else { + if (lzwnew >= lzwnext) { + /* Handles special LZW scenario */ + *decode_stack = c; + s = decode_string(decode_stack + 1, lzwold); + } else + s = decode_string(decode_stack, lzwnew); + + /* Reverse order of decoded string and + * store in out buffer + */ + c = *s; + while (s >= decode_stack) + *out++ = *s--; + + if (lzwnext > MAX_CODE) + setBITS(BITS + 1); + + prefix_code[lzwnext] = lzwold; + append_character[lzwnext] = c; + lzwnext++; + lzwold = lzwnew; + + lzwnew = input_code(&in); + } + } + closeLZW(); +} + +} // End of namespace Agi diff --git a/engines/agi/lzw.h b/engines/agi/lzw.h new file mode 100644 index 0000000000..5923f98055 --- /dev/null +++ b/engines/agi/lzw.h @@ -0,0 +1,33 @@ +/* ScummVM - Scumm Interpreter + * Copyright (C) 2006 The ScummVM project + * + * Copyright (C) 1999-2001 Sarien Team + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + * $URL$ + * $Id$ + * + */ + +#ifndef __AGI_LZW_H +#define __AGI_LZW_H + +namespace Agi { + +void LZW_expand(uint8 *, uint8 *, int32); + +} // End of namespace Agi +#endif diff --git a/engines/agi/menu.cpp b/engines/agi/menu.cpp new file mode 100644 index 0000000000..950b054cb3 --- /dev/null +++ b/engines/agi/menu.cpp @@ -0,0 +1,503 @@ +/* ScummVM - Scumm Interpreter + * Copyright (C) 2006 The ScummVM project + * + * Copyright (C) 1999-2002 Sarien Team + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + * $URL$ + * $Id$ + * + */ + +#include "common/stdafx.h" + +#include "agi/agi.h" +#include "agi/sprite.h" +#include "agi/graphics.h" +#include "agi/keyboard.h" +#include "agi/menu.h" +#include "agi/text.h" +#include "agi/list.h" + +namespace Agi { + +struct agi_menu { + struct list_head list; /**< list head for menubar list */ + struct list_head down; /**< list head for menu options */ + int index; /**< number of menu in menubar */ + int width; /**< width of menu in characters */ + int height; /**< height of menu in characters */ + int col; /**< column of menubar entry */ + int wincol; /**< column of menu window */ + char *text; /**< menu name */ +}; + +struct agi_menu_option { + struct list_head list; /**< list head for menu options */ + int enabled; /**< option is enabled or disabled */ + int event; /**< menu event */ + int index; /**< number of option in this menu */ + char *text; /**< text of menu option */ +}; + +static LIST_HEAD(menubar); + +static int h_cur_menu; +static int v_cur_menu; + +static struct agi_menu *get_menu(int i) { + struct list_head *h; + struct agi_menu *m; + + list_for_each(h, &menubar, next) { + m = list_entry(h, struct agi_menu, list); + if (m->index == i) + return m; + } + return NULL; +} + +static struct agi_menu_option *get_menu_option(int i, int j) { + struct list_head *h; + struct agi_menu *m; + struct agi_menu_option *d; + + m = get_menu(i); + + list_for_each(h, &m->down, next) { + d = list_entry(h, struct agi_menu_option, list); + if (d->index == j) + return d; + } + + return NULL; +} + +static void draw_menu_bar() { + struct list_head *h; + struct agi_menu *m; + + clear_lines(0, 0, MENU_BG); + flush_lines(0, 0); + + list_for_each(h, &menubar, next) { + m = list_entry(h, struct agi_menu, list); + print_text(m->text, 0, m->col, 0, 40, MENU_FG, MENU_BG); + } + +} + +static void draw_menu_hilite(int cur_menu) { + struct agi_menu *m; + + m = get_menu(cur_menu); + debugC(6, kDebugLevelMenu, "[%s]", m->text); + print_text(m->text, 0, m->col, 0, 40, MENU_BG, MENU_FG); + flush_lines(0, 0); +} + +/* draw box and pulldowns. */ +static void draw_menu_option(int h_menu) { + struct list_head *h; + struct agi_menu *m = NULL; + struct agi_menu_option *d = NULL; + + /* find which vertical menu it is */ + m = get_menu(h_menu); + + draw_box(m->wincol * CHAR_COLS, 1 * CHAR_LINES, (m->wincol + m->width + 2) * CHAR_COLS, + (1 + m->height + 2) * CHAR_LINES, MENU_BG, MENU_LINE, 0); + + list_for_each(h, &m->down, next) { + d = list_entry(h, struct agi_menu_option, list); + print_text(d->text, 0, m->wincol + 1, d->index + 2, m->width + 2, + d->enabled ? MENU_FG : MENU_DISABLED, MENU_BG); + } +} + +static void draw_menu_option_hilite(int h_menu, int v_menu) { + struct agi_menu *m; + struct agi_menu_option *d; + + m = get_menu(h_menu); + d = get_menu_option(h_menu, v_menu); + + print_text(d->text, 0, m->wincol + 1, v_menu + 2, m->width + 2, + MENU_BG, d->enabled ? MENU_FG : MENU_DISABLED); +} + +static void new_menu_selected(int i) { + show_pic(); + draw_menu_bar(); + draw_menu_hilite(i); + draw_menu_option(i); +} + +#ifdef USE_MOUSE +static int mouse_over_text(unsigned int line, unsigned int col, char *s) { + if (mouse.x < col * CHAR_COLS) + return false; + + if (mouse.x > (col + strlen(s)) * CHAR_COLS) + return false; + + if (mouse.y < line * CHAR_LINES) + return false; + + if (mouse.y >= (line + 1) * CHAR_LINES) + return false; + + return true; +} +#endif + +static int h_index; +static int v_index; +static int h_col; +static int h_max_menu; +static int v_max_menu[10]; + +#if 0 +static void add_about_option() { + struct agi_menu *m; + struct agi_menu_option *d; + char text[] = "About AGI engine"; + + d = malloc(sizeof(struct agi_menu_option)); + d->text = strdup(text); + d->enabled = true; + d->event = 255; + d->index = (v_max_menu[0] += 1); + + m = list_entry(menubar.next, struct agi_menu, list); + list_add_tail(&d->list, &m->down); + m->height++; + if (m->width < strlen(text)) + m->width = strlen(text); +} +#endif + +/* + * Public functions + */ + +void menu_init() { + h_index = 0; + h_col = 1; + h_cur_menu = 0; + v_cur_menu = 0; +} + +void menu_deinit() { + struct list_head *h, *h2, *v, *v2; + struct agi_menu *m = NULL; + struct agi_menu_option *d = NULL; + + for (h = (&menubar)->prev; h != (&menubar); h = h2) { + m = list_entry(h, struct agi_menu, list); + h2 = h->prev; + debugC(3, kDebugLevelMenu, "deiniting hmenu %s", m->text); + for (v = (&m->down)->prev; v != (&m->down); v = v2) { + d = list_entry(v, struct agi_menu_option, list); + v2 = v->prev; + debugC(3, kDebugLevelMenu, " deiniting vmenu %s", d->text); + list_del(v); + free(d->text); + free(d); + } + list_del(h); + free(m->text); + free(m); + } +} + +void menu_add(char *s) { + struct agi_menu *m; + + m = (agi_menu *) malloc(sizeof(struct agi_menu)); + m->text = strdup(s); + while (m->text[strlen(m->text) - 1] == ' ') + m->text[strlen(m->text) - 1] = 0; + m->down.next = &m->down; + m->down.prev = &m->down; + m->width = 0; + m->height = 0; + m->index = h_index++; + m->col = h_col; + m->wincol = h_col - 1; + v_index = 0; + v_max_menu[m->index] = 0; + h_col += strlen(m->text) + 1; + h_max_menu = m->index; + + debugC(3, kDebugLevelMenu, "add menu: '%s' %02x", s, m->text[strlen(m->text)]); + list_add_tail(&m->list, &menubar); +} + +void menu_add_item(char *s, int code) { + struct agi_menu *m; + struct agi_menu_option *d; + int l; + + d = (agi_menu_option *) malloc(sizeof(struct agi_menu_option)); + d->text = strdup(s); + d->enabled = true; + d->event = code; + d->index = v_index++; + + m = list_entry(menubar.prev, struct agi_menu, list); + m->height++; + + v_max_menu[m->index] = d->index; + + l = strlen(d->text); + if (l > 40) + l = 38; + if (m->wincol + l > 38) + m->wincol = 38 - l; + if (l > m->width) + m->width = l; + + debugC(3, kDebugLevelMenu, "Adding menu item: %s (size = %d)", s, m->height); + list_add_tail(&d->list, &m->down); +} + +void menu_submit() { + struct list_head *h, *h2; + struct agi_menu *m = NULL; + + debugC(3, kDebugLevelMenu, "Submitting menu"); + + /* add_about_option (); */ + + /* If a menu has no options, delete it */ + for (h = (&menubar)->prev; h != (&menubar); h = h2) { + m = list_entry(h, struct agi_menu, list); + h2 = h->prev; + if ((&m->down)->prev == (&m->down)) { + list_del(h); + free(m->text); + free(m); + h_max_menu--; + } + } +} + +int menu_keyhandler(int key) { + static int clock_val; + static int menu_active = false; + struct agi_menu_option *d; + struct list_head *h; + struct agi_menu *m; + static int button_used = 0; + + if (!getflag(F_menus_work)) + return false; + + if (!menu_active) { + clock_val = game.clock_enabled; + game.clock_enabled = false; + draw_menu_bar(); + } +#ifdef USE_MOUSE + /* + * Mouse handling + */ + if (mouse.button) { + int hmenu, vmenu; + + button_used = 1; /* Button has been used at least once */ + if (mouse.y <= CHAR_LINES) { + /* on the menubar */ + hmenu = 0; + + list_for_each(h, &menubar, next) { + m = list_entry(h, struct agi_menu, list); + if (mouse_over_text(0, m->col, m->text)) { + break; + } else { + hmenu++; + } + } + + if (hmenu <= h_max_menu) { + if (h_cur_menu != hmenu) { + v_cur_menu = -1; + new_menu_selected(hmenu); + } + h_cur_menu = hmenu; + } + } else { + /* not in menubar */ + struct agi_menu_option *do1; + + vmenu = 0; + + m = get_menu(h_cur_menu); + list_for_each(h, &m->down, next) { + do1 = list_entry(h, struct agi_menu_option, list); + if (mouse_over_text(2 + do1->index, m->wincol + 1, do1->text)) { + break; + } else { + vmenu++; + } + } + + if (vmenu <= v_max_menu[h_cur_menu]) { + if (v_cur_menu != vmenu) { + draw_menu_option(h_cur_menu); + draw_menu_option_hilite(h_cur_menu, vmenu); + } + v_cur_menu = vmenu; + } + } + } else if (button_used) { + /* Button released */ + button_used = 0; + + debugC(6, kDebugLevelMenu | kDebugLevelInput, "button released!"); + + if (v_cur_menu < 0) + v_cur_menu = 0; + + draw_menu_option_hilite(h_cur_menu, v_cur_menu); + + if (mouse.y <= CHAR_LINES) { + /* on the menubar */ + } else { + /* see which option we selected */ + m = get_menu(h_cur_menu); + list_for_each(h, &m->down, next) { + d = list_entry(h, struct agi_menu_option, list); + if (mouse_over_text(2 + d->index, + m->wincol + 1, d->text)) { + /* activate that option */ + if (d->enabled) { + debugC(6, kDebugLevelMenu | kDebugLevelInput, "event %d registered", d->event); + game.ev_keyp[d->event].occured = true; + game.ev_keyp[d->event].data = d->event; + goto exit_menu; + } + } + } + goto exit_menu; + } + } +#endif /* USE_MOUSE */ + + if (!menu_active) { + if (h_cur_menu >= 0) { + draw_menu_hilite(h_cur_menu); + draw_menu_option(h_cur_menu); + if (!button_used && v_cur_menu >= 0) + draw_menu_option_hilite(h_cur_menu, v_cur_menu); + } + menu_active = true; + } + + switch (key) { + case KEY_ESCAPE: + debugC(6, kDebugLevelMenu | kDebugLevelInput, "KEY_ESCAPE"); + goto exit_menu; + case KEY_ENTER: + debugC(6, kDebugLevelMenu | kDebugLevelInput, "KEY_ENTER"); + d = get_menu_option(h_cur_menu, v_cur_menu); + if (d->enabled) { + debugC(6, kDebugLevelMenu | kDebugLevelInput, "event %d registered", d->event); + game.ev_keyp[d->event].occured = true; + goto exit_menu; + } + break; + case KEY_DOWN: + case KEY_UP: + v_cur_menu += key == KEY_DOWN ? 1 : -1; + + if (v_cur_menu < 0) + v_cur_menu = 0; + if (v_cur_menu > v_max_menu[h_cur_menu]) + v_cur_menu = v_max_menu[h_cur_menu]; + + draw_menu_option(h_cur_menu); + draw_menu_option_hilite(h_cur_menu, v_cur_menu); + break; + case KEY_RIGHT: + case KEY_LEFT: + h_cur_menu += key == KEY_RIGHT ? 1 : -1; + + if (h_cur_menu < 0) + h_cur_menu = h_max_menu; + if (h_cur_menu > h_max_menu) + h_cur_menu = 0; + + v_cur_menu = 0; + new_menu_selected(h_cur_menu); + draw_menu_option_hilite(h_cur_menu, v_cur_menu); + break; + } + + return true; + +exit_menu: + button_used = 0; + show_pic(); + write_status(); + + setvar(V_key, 0); + game.keypress = 0; + game.clock_enabled = clock_val; + old_input_mode(); + debugC(3, kDebugLevelMenu, "exit_menu: input mode reset to %d", game.input_mode); + menu_active = false; + + return true; +} + +void menu_set_item(int event, int state) { + struct list_head *h, *v; + struct agi_menu *m = NULL; + struct agi_menu_option *d = NULL; + + /* scan all menus for event number # */ + + debugC(6, kDebugLevelMenu, "event = %d, state = %d", event, state); + list_for_each(h, &menubar, next) { + m = list_entry(h, struct agi_menu, list); + list_for_each(v, &m->down, next) { + d = list_entry(v, struct agi_menu_option, list); + if (d->event == event) { + d->enabled = state; + return; + } + } + } +} + +void menu_enable_all() { + struct list_head *h, *v; + struct agi_menu *m = NULL; + struct agi_menu_option *d = NULL; + + list_for_each(h, &menubar, next) { + m = list_entry(h, struct agi_menu, list); + list_for_each(v, &m->down, next) { + d = list_entry(v, struct agi_menu_option, list); + d->enabled = true; + } + } + +} + +} // End of namespace Agi diff --git a/engines/agi/menu.h b/engines/agi/menu.h new file mode 100644 index 0000000000..095f802bd4 --- /dev/null +++ b/engines/agi/menu.h @@ -0,0 +1,46 @@ +/* ScummVM - Scumm Interpreter + * Copyright (C) 2006 The ScummVM project + * + * Copyright (C) 1999-2003 Sarien Team + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + * $URL$ + * $Id$ + * + */ + +#ifndef __AGI_MENU_H +#define __AGI_MENU_H + +namespace Agi { + +#define MENU_BG 0x0f /* White */ +#define MENU_DISABLED 0x07 /* Grey */ + +#define MENU_FG 0x00 /* Black */ +#define MENU_LINE 0x00 /* Black */ + +void menu_init(void); +void menu_deinit(void); +void menu_add(char *); +void menu_add_item(char *, int); +void menu_submit(void); +void menu_set_item(int, int); +int menu_keyhandler(int); +void menu_enable_all(void); + +} // End of namespace Agi +#endif diff --git a/engines/agi/module.mk b/engines/agi/module.mk new file mode 100644 index 0000000000..a5a81f2b15 --- /dev/null +++ b/engines/agi/module.mk @@ -0,0 +1,42 @@ +MODULE := engines/agi + +MODULE_OBJS = \ + agi.o \ + agi_v2.o \ + agi_v3.o \ + checks.o \ + console.o \ + cycle.o \ + font.o \ + global.o \ + graphics.o \ + id.o \ + inv.o \ + keyboard.o \ + logic.o \ + lzw.o \ + menu.o \ + motion.o \ + objects.o \ + op_cmd.o \ + op_dbg.o \ + op_test.o \ + patches.o \ + picture.o \ + savegame.o \ + sound.o \ + sprite.o \ + text.o \ + view.o \ + words.o + +MODULE_DIRS += \ + engines/agi + +# This module can be built as a plugin +ifdef BUILD_PLUGINS +PLUGIN := 1 +endif + +# Include common rules +include $(srcdir)/common.rules diff --git a/engines/agi/motion.cpp b/engines/agi/motion.cpp new file mode 100644 index 0000000000..61d14dc1a3 --- /dev/null +++ b/engines/agi/motion.cpp @@ -0,0 +1,232 @@ +/* ScummVM - Scumm Interpreter + * Copyright (C) 2006 The ScummVM project + * + * Copyright (C) 1999-2001 Sarien Team + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + * $URL$ + * $Id$ + * + */ + +#include "common/stdafx.h" + +#include "agi/agi.h" + +namespace Agi { + +static int check_step(int delta, int step) { + return (-step >= delta) ? 0 : (step <= delta) ? 2 : 1; +} + +static int check_block(int x, int y) { + if (x <= game.block.x1 || x >= game.block.x2) + return false; + + if (y <= game.block.y1 || y >= game.block.y2) + return false; + + return true; +} + +static void changepos(struct vt_entry *v) { + int b, x, y; + int dx[9] = { 0, 0, 1, 1, 1, 0, -1, -1, -1 }; + int dy[9] = { 0, -1, -1, 0, 1, 1, 1, 0, -1 }; + + x = v->x_pos; + y = v->y_pos; + b = check_block(x, y); + + x += v->step_size * dx[v->direction]; + y += v->step_size * dy[v->direction]; + + if (check_block(x, y) == b) { + v->flags &= ~MOTION; + } else { + v->flags |= MOTION; + v->direction = 0; + if /*_is_ego_view*/ (v) + game.vars[V_ego_dir] = 0; + } +} + +static void motion_wander(struct vt_entry *v) { + if (v->parm1--) { + if (~v->flags & DIDNT_MOVE) + return; + } + + v->direction = rnd->getRandomNumber(8); + + if /*_is_ego_view */ (v) { + game.vars[V_ego_dir] = v->direction; + while (v->parm1 < 6) { + v->parm1 = rnd->getRandomNumber(50); /* huh? */ + } + } +} + +static void motion_followego(struct vt_entry *v) { + int ego_x, ego_y; + int obj_x, obj_y; + int dir; + + ego_x = game.view_table[0].x_pos + game.view_table[0].x_size / 2; + ego_y = game.view_table[0].y_pos; + + obj_x = v->x_pos + v->x_size / 2; + obj_y = v->y_pos; + + /* Get direction to reach ego */ + dir = get_direction(obj_x, obj_y, ego_x, ego_y, v->parm1); + + /* Already at ego coordinates */ + if (dir == 0) { + v->direction = 0; + v->motion = MOTION_NORMAL; + setflag(v->parm2, true); + return; + } + + if (v->parm3 == 0xff) { + v->parm3 = 0; + } else if (v->flags & DIDNT_MOVE) { + int d; + + while ((v->direction = rnd->getRandomNumber(8)) == 0) { + } + + d = (abs(ego_y - obj_y) + abs(ego_x - obj_x)) / 2; + + if (d < v->step_size) { + v->parm3 = v->step_size; + return; + } + + while ((v->parm3 = rnd->getRandomNumber(d)) < v->step_size) { + } + return; + } + + if (v->parm3 != 0) { + int k; + + /* DF: this is ugly and I dont know why this works, but + * other line does not! (watcom complained about lvalue) + * + * if (((int8)v->parm3 -= v->step_size) < 0) + * v->parm3 = 0; + */ + k = v->parm3; + k -= v->step_size; + v->parm3 = k; + + if ((int8) v->parm3 < 0) + v->parm3 = 0; + } else { + v->direction = dir; + } +} + +static void motion_moveobj(struct vt_entry *v) { + v->direction = get_direction(v->x_pos, v->y_pos, v->parm1, v->parm2, v->step_size); + + /* Update V6 if ego */ + if (v == game.view_table) + game.vars[V_ego_dir] = v->direction; + + if (v->direction == 0) + in_destination(v); +} + +static void check_motion(struct vt_entry *v) { + switch (v->motion) { + case MOTION_WANDER: + motion_wander(v); + break; + case MOTION_FOLLOW_EGO: + motion_followego(v); + break; + case MOTION_MOVE_OBJ: + motion_moveobj(v); + break; + } + + if ((game.block.active && (~v->flags & IGNORE_BLOCKS)) && v->direction) + changepos(v); +} + +/* + * Public functions + */ + +/** + * + */ +void check_all_motions() { + struct vt_entry *v; + + for (v = game.view_table; v < &game.view_table[MAX_VIEWTABLE]; v++) { + if ((v->flags & (ANIMATED | UPDATE | DRAWN)) == (ANIMATED | UPDATE | DRAWN) + && v->step_time_count == 1) { + check_motion(v); + } + } +} + +/** + * Check if given entry is at destination point. + * This function is used to updated the flags of an object with move.obj + * type motion that * has reached its final destination coordinates. + * @param v Pointer to view table entry + */ +void in_destination(struct vt_entry *v) { + if (v->motion == MOTION_MOVE_OBJ) { + v->step_size = v->parm3; + setflag(v->parm4, true); + } + v->motion = MOTION_NORMAL; + if (v == game.view_table) + game.player_control = true; +} + +/** + * Wrapper for static function motion_moveobj(). + * This function is used by cmd_move_object() in the first motion cycle + * after setting the motion mode to MOTION_MOVE_OBJ. + * @param v Pointer to view table entry + */ +void move_obj(struct vt_entry *v) { + motion_moveobj(v); +} + +/** + * Get direction from motion coordinates + * This function gets the motion direction from the current and previous + * object coordinates and the step size. + * @param x0 Original x coordinate of the object + * @param y0 Original y coordinate of the object + * @param x x coordinate of the object + * @param y y coordinate of the object + * @param s step size + */ +int get_direction(int x0, int y0, int x, int y, int s) { + int dir_table[9] = { 8, 1, 2, 7, 0, 3, 6, 5, 4 }; + return dir_table[check_step(x - x0, s) + 3 * check_step(y - y0, s)]; +} + +} // End of namespace Agi diff --git a/engines/agi/objects.cpp b/engines/agi/objects.cpp new file mode 100644 index 0000000000..352dabcf95 --- /dev/null +++ b/engines/agi/objects.cpp @@ -0,0 +1,167 @@ +/* ScummVM - Scumm Interpreter + * Copyright (C) 2006 The ScummVM project + * + * Copyright (C) 1999-2003 Sarien Team + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + * $URL$ + * $Id$ + * + */ + +#include "common/stdafx.h" + +#include "agi/agi.h" + +namespace Agi { + +extern int decode_objects(uint8 *mem, uint32 flen); + +static struct agi_object *objects; /* objects in the game */ + +int alloc_objects(int n) { + if ((objects = (agi_object *) calloc(n, sizeof(struct agi_object))) == NULL) + return err_NotEnoughMemory; + + return err_OK; +} + +int decode_objects(uint8 *mem, uint32 flen) { + unsigned int i, so, padsize; + + padsize = game.game_flags & ID_AMIGA ? 4 : 3; + + game.num_objects = 0; + objects = NULL; + + /* check if first pointer exceeds file size + * if so, its encrypted, else it is not + */ + + if (READ_LE_UINT16(mem) > flen) { + report("Decrypting objects... "); + decrypt(mem, flen); + report("done.\n"); + } + + /* alloc memory for object list + * byte 3 = number of animated objects. this is ignored.. ?? + */ + if (READ_LE_UINT16(mem) / padsize >= 256) { +#ifdef AGDS_SUPPORT + /* die with no error! AGDS game needs not to die to work!! :( */ + return err_OK; +#else + /* no AGDS support, die with error */ + return err_BadResource; +#endif + } + + game.num_objects = READ_LE_UINT16(mem) / padsize; + debugC(5, kDebugLevelResources, "num_objects = %d (padsize = %d)", game.num_objects, padsize); + + if (alloc_objects(game.num_objects) != err_OK) + return err_NotEnoughMemory; + + /* build the object list */ + for (i = 0, so = padsize; i < game.num_objects; i++, so += padsize) { + int offset; + + (objects + i)->location = *(mem + so + 2); + offset = READ_LE_UINT16(mem + so) + padsize; + + if ((uint) offset < flen) { + (objects + i)->name = (char *)strdup((const char *)mem + offset); + } else { + printf("ERROR: object %i name beyond object filesize! " + "(%04x > %04x)\n", i, offset, flen); + (objects + i)->name = strdup(""); + } + } + report("Reading objects: %d objects read.\n", game.num_objects); + + return err_OK; + +} + +int load_objects(char *fname) { + Common::File fp; + uint32 flen; + uint8 *mem; + char *path; + + objects = NULL; + game.num_objects = 0; + + debugC(5, kDebugLevelResources, "(fname = %s)", fname); + path = fname; + report("Loading objects: %s\n", path); + + if (!fp.open(path)) + return err_BadFileOpen; + + fp.seek(0, SEEK_END); + flen = fp.pos(); + fp.seek(0, SEEK_SET); + + if ((mem = (uint8 *) calloc(1, flen + 32)) == NULL) { + fp.close(); + return err_NotEnoughMemory; + } + + fp.read(mem, flen); + fp.close(); + + decode_objects(mem, flen); + free(mem); + return err_OK; +} + +void unload_objects() { + unsigned int i; + + if (objects != NULL) { + for (i = 0; i < game.num_objects; i++) + free(objects[i].name); + free(objects); + } +} + +void object_set_location(unsigned int n, int i) { + if (n >= game.num_objects) { + report("Error: Can't access object %d.\n", n); + return; + } + objects[n].location = i; +} + +int object_get_location(unsigned int n) { + if (n >= game.num_objects) { + report("Error: Can't access object %d.\n", n); + return 0; + } + return objects[n].location; +} + +char *object_name(unsigned int n) { + if (n >= game.num_objects) { + report("Error: Can't access object %d.\n", n); + return ""; + } + return objects[n].name; +} + +} // End of namespace Agi diff --git a/engines/agi/op_cmd.cpp b/engines/agi/op_cmd.cpp new file mode 100644 index 0000000000..042556b09e --- /dev/null +++ b/engines/agi/op_cmd.cpp @@ -0,0 +1,1513 @@ +/* ScummVM - Scumm Interpreter + * Copyright (C) 2006 The ScummVM project + * + * Copyright (C) 1999-2003 Sarien Team + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + * $URL$ + * $Id$ + * + */ + +#include "common/stdafx.h" + +#include "agi/agi.h" +#include "agi/sprite.h" +#include "agi/graphics.h" +#include "agi/keyboard.h" +#include "agi/opcodes.h" +#include "agi/menu.h" +#include "agi/savegame.h" +#include "agi/text.h" + +namespace Agi { + +#define p0 (p[0]) +#define p1 (p[1]) +#define p2 (p[2]) +#define p3 (p[3]) +#define p4 (p[4]) +#define p5 (p[5]) +#define p6 (p[6]) + +#define ip cur_logic->cIP +#define vt game.view_table[p0] + +static struct agi_logic *cur_logic; + +int timer_hack; /* Workaround for timer loop in MH1 */ + +#define _v game.vars +#define cmd(x) static void cmd_##x (uint8 *p) + +cmd(increment) { + if (_v[p0] != 0xff) + ++_v[p0]; +} + +cmd(decrement) { + if (_v[p0] != 0) + --_v[p0]; +} + +cmd(assignn) { + _v[p0] = p1; +} + +cmd(addn) { + _v[p0] += p1; +} + +cmd(subn) { + _v[p0] -= p1; +} + +cmd(assignv) { + _v[p0] = _v[p1]; +} + +cmd(addv) { + _v[p0] += _v[p1]; +} + +cmd(subv) { + _v[p0] -= _v[p1]; +} + +cmd(mul_n) { + _v[p0] *= p1; +} + +cmd(mul_v) { + _v[p0] *= _v[p1]; +} + +cmd(div_n) { + _v[p0] /= p1; +} + +cmd(div_v) { + _v[p0] /= _v[p1]; +} + +cmd(random) { + _v[p2] = rnd->getRandomNumber(p1 - p0) + p0; +} + +cmd(lindirectn) { + _v[_v[p0]] = p1; +} + +cmd(lindirectv) { + _v[_v[p0]] = _v[p1]; +} + +cmd(rindirect) { + _v[p0] = _v[_v[p1]]; +} + +cmd(set) { + setflag(*p, true); +} + +cmd(reset) { + setflag(*p, false); +} + +cmd(toggle) { + setflag(*p, !getflag(*p)); +} + +cmd(set_v) { + setflag(_v[p0], true); +} + +cmd(reset_v) { + setflag(_v[p0], false); +} + +cmd(toggle_v) { + setflag(_v[p0], !getflag(_v[p0])); +} + +cmd(new_room) { + new_room(p0); +} + +cmd(new_room_f) { + new_room(_v[p0]); +} + +cmd(load_view) { + agi_load_resource(rVIEW, p0); +} + +cmd(load_logic) { + agi_load_resource(rLOGIC, p0); +} + +cmd(load_sound) { + agi_load_resource(rSOUND, p0); +} + +cmd(load_view_f) { + agi_load_resource(rVIEW, _v[p0]); +} + +cmd(load_logic_f) { + agi_load_resource(rLOGIC, _v[p0]); +} + +cmd(discard_view) { + agi_unload_resource(rVIEW, p0); +} + +cmd(object_on_anything) { + vt.flags &= ~(ON_WATER | ON_LAND); +} + +cmd(object_on_land) { + debugC(4, kDebugLevelScripts, "p0 = %d", p0); + vt.flags |= ON_LAND; +} + +cmd(object_on_water) { + debugC(4, kDebugLevelScripts, "p0 = %d", p0); + vt.flags |= ON_WATER; +} + +cmd(observe_horizon) { + debugC(4, kDebugLevelScripts, "p0 = %d", p0); + vt.flags &= ~IGNORE_HORIZON; +} + +cmd(ignore_horizon) { + debugC(4, kDebugLevelScripts, "p0 = %d", p0); + vt.flags |= IGNORE_HORIZON; +} + +cmd(observe_objs) { + debugC(4, kDebugLevelScripts, "p0 = %d", p0); + vt.flags &= ~IGNORE_OBJECTS; +} + +cmd(ignore_objs) { + debugC(4, kDebugLevelScripts, "p0 = %d", p0); + vt.flags |= IGNORE_OBJECTS; +} + +cmd(observe_blocks) { + debugC(4, kDebugLevelScripts, "p0 = %d", p0); + vt.flags &= ~IGNORE_BLOCKS; +} + +cmd(ignore_blocks) { + debugC(4, kDebugLevelScripts, "p0 = %d", p0); + vt.flags |= IGNORE_BLOCKS; +} + +cmd(set_horizon) { + debugC(4, kDebugLevelScripts, "p0 = %d", p0); + game.horizon = p0; +} + +cmd(get_priority) { + _v[p1] = vt.priority; +} + +cmd(set_priority) { + vt.flags |= FIXED_PRIORITY; + vt.priority = p1; +} + +cmd(set_priority_f) { + vt.flags |= FIXED_PRIORITY; + vt.priority = _v[p1]; +} + +cmd(release_priority) { + vt.flags &= ~FIXED_PRIORITY; +} + +cmd(set_upper_left) { /* do nothing (AGI 2.917) */ +} + +cmd(start_update) { + start_update(&vt); +} + +cmd(stop_update) { + stop_update(&vt); +} + +cmd(current_view) { + _v[p1] = vt.current_view; +} + +cmd(current_cel) { + _v[p1] = vt.current_cel; + debugC(4, kDebugLevelScripts, "v%d=%d", p1, _v[p1]); +} + +cmd(current_loop) { + _v[p1] = vt.current_loop; +} + +cmd(last_cel) { + _v[p1] = vt.loop_data->num_cels - 1; +} + +cmd(set_cel) { + set_cel(&vt, p1); + vt.flags &= ~DONTUPDATE; +} + +cmd(set_cel_f) { + set_cel(&vt, _v[p1]); + vt.flags &= ~DONTUPDATE; +} + +cmd(set_view) { + debugC(4, kDebugLevelScripts, "o%d, %d", p0, p1); + set_view(&vt, p1); +} + +cmd(set_view_f) { + set_view(&vt, _v[p1]); +} + +cmd(set_loop) { + set_loop(&vt, p1); +} + +cmd(set_loop_f) { + set_loop(&vt, _v[p1]); +} + +cmd(number_of_loops) { + _v[p1] = vt.num_loops; +} + +cmd(fix_loop) { + vt.flags |= FIX_LOOP; +} + +cmd(release_loop) { + vt.flags &= ~FIX_LOOP; +} + +cmd(step_size) { + vt.step_size = _v[p1]; +} + +cmd(step_time) { + vt.step_time = vt.step_time_count = _v[p1]; +} + +cmd(cycle_time) { + vt.cycle_time = vt.cycle_time_count = _v[p1]; +} + +cmd(stop_cycling) { + vt.flags &= ~CYCLING; +} + +cmd(start_cycling) { + vt.flags |= CYCLING; +} + +cmd(normal_cycle) { + vt.cycle = CYCLE_NORMAL; + vt.flags |= CYCLING; +} + +cmd(reverse_cycle) { + vt.cycle = CYCLE_REVERSE; + vt.flags |= CYCLING; +} + +cmd(set_dir) { + vt.direction = _v[p1]; +} + +cmd(get_dir) { + _v[p1] = vt.direction; +} + +cmd(get_room_f) { + _v[p1] = object_get_location(_v[p0]); +} + +cmd(put) { + object_set_location(p0, _v[p1]); +} + +cmd(put_f) { + object_set_location(_v[p0], _v[p1]); +} + +cmd(drop) { + object_set_location(p0, 0); +} + +cmd(get) { + object_set_location(p0, EGO_OWNED); +} + +cmd(get_f) { + object_set_location(_v[p0], EGO_OWNED); +} + +cmd(word_to_string) { + strcpy(game.strings[p0], game.ego_words[p1].word); +} + +cmd(open_dialogue) { + debugC(4, kDebugLevelScripts, "p0 = %d", p0); + game.has_window = true; +} + +cmd(close_dialogue) { + debugC(4, kDebugLevelScripts, "p0 = %d", p0); + game.has_window = false; +} + +cmd(close_window) { + close_window(); +} + +cmd(status_line_on) { + game.status_line = true; + write_status(); +} + +cmd(status_line_off) { + game.status_line = false; + write_status(); +} + +cmd(show_obj) { + show_obj(p0); +} + +cmd(show_obj_v) { + show_obj(_v[p0]); +} + +cmd(sound) { + start_sound(p0, p1); +} + +cmd(stop_sound) { + stop_sound(); +} + +cmd(menu_input) { + new_input_mode(INPUT_MENU); +} + +cmd(enable_item) { + menu_set_item(p0, true); +} + +cmd(disable_item) { + menu_set_item(p0, false); +} + +cmd(submit_menu) { + menu_submit(); +} + +cmd(set_scan_start) { + cur_logic->sIP = cur_logic->cIP; +} + +cmd(reset_scan_start) { + cur_logic->sIP = 2; +} + +cmd(save_game) { + game.simple_save ? savegame_simple() : savegame_dialog(); +} + +cmd(load_game) { + game.simple_save ? loadgame_simple() : loadgame_dialog(); +} + +cmd(init_disk) { /* do nothing */ +} + +cmd(log) { /* do nothing */ +} + +cmd(trace_on) { /* do nothing */ +} + +cmd(trace_info) { /* do nothing */ +} + +cmd(show_mem) { + message_box("Enough memory"); +} + +cmd(init_joy) { /* do nothing */ ; +} + +cmd(script_size) { + report("script.size(%d)\n", p0); +} + +cmd(cancel_line) { + report("cancel.line\n"); +} + +cmd(obj_status_f) { + report("obj.status.f\n"); +} + +/* unknown commands: + * unk_170: Force savegame name -- j5 + * unk_171: script save -- j5 + * unk_172: script restore -- j5 + * unk_173: Activate keypressed control (ego only moves while key is pressed) + * unk_174: Change priority table (used in KQ4) -- j5 + * unk_177: Disable menus completely -- j5 + * unk_181: Deactivate keypressed control (default control of ego) + */ +cmd(set_simple) { + game.simple_save = true; +} + +cmd(pop_script) { + report("pop.script\n"); +} + +cmd(hold_key) { + report("hold.key\n"); +} + +cmd(discard_sound) { + report("discard.sound\n"); +} + +cmd(hide_mouse) { + report("hide.mouse\n"); +} + +cmd(allow_menu) { + report("allow.menu\n"); +} + +cmd(show_mouse) { + report("show.mouse\n"); +} + +cmd(fence_mouse) { + report("fence.mouse\n"); +} + +cmd(release_key) { + report("release.key\n"); +} + +cmd(adj_ego_move_to_x_y) { + game.view_table[0].flags |= ADJ_EGO_XY; +} + +cmd(parse) { + _v[V_word_not_found] = 0; + setflag(F_entered_cli, false); + setflag(F_said_accepted_input, false); + + dictionary_words(agi_sprintf(game.strings[p0])); +} + +cmd(call) { + int old_cIP; + int old_lognum; + + /* CM: we don't save sIP because set.scan.start can be + * used in a called script (fixes xmas demo) + */ + old_cIP = cur_logic->cIP; + old_lognum = game.lognum; + + run_logic(p0); + + game.lognum = old_lognum; + cur_logic = &game.logics[game.lognum]; + cur_logic->cIP = old_cIP; +} + +cmd(call_f) { + cmd_call(&_v[p0]); +} + +cmd(draw_pic) { + debugC(6, kDebugLevelScripts, "=== draw pic %d ===", _v[p0]); + erase_both(); + decode_picture(_v[p0], true); + blit_both(); + game.picture_shown = 0; + debugC(6, kDebugLevelScripts, "--- end of draw pic %d ---", _v[p0]); +} + +cmd(show_pic) { + debugC(6, kDebugLevelScripts, "=== show pic ==="); + setflag(F_output_mode, false); + cmd_close_window(NULL); + show_pic(); + game.picture_shown = 1; + debugC(6, kDebugLevelScripts, "--- end of show pic ---"); +} + +cmd(load_pic) { + erase_both(); + agi_load_resource(rPICTURE, _v[p0]); + blit_both(); +} + +cmd(discard_pic) { + debugC(6, kDebugLevelScripts, "--- discard pic ---"); + /* do nothing */ +} + +cmd(overlay_pic) { + debugC(6, kDebugLevelScripts, "--- overlay pic ---"); + erase_both(); + decode_picture(_v[p0], false); + blit_both(); + game.picture_shown = 0; + commit_both(); +} + +cmd(show_pri_screen) { +#ifdef USE_CONSOLE + debug_.priority = 1; + erase_both(); + show_pic(); + blit_both(); + wait_key(); + debug_.priority = 0; + erase_both(); + show_pic(); + blit_both(); +#endif +} + +cmd(animate_obj) { + if (vt.flags & ANIMATED) + return; + + debugC(4, kDebugLevelScripts, "animate vt entry #%d", p0); + vt.flags = ANIMATED | UPDATE | CYCLING; + vt.motion = MOTION_NORMAL; + vt.cycle = CYCLE_NORMAL; + vt.direction = 0; +} + +cmd(unanimate_all) { + int i; + for (i = 0; i < MAX_VIEWTABLE; i++) + game.view_table[i].flags &= ~(ANIMATED | DRAWN); +} + +cmd(draw) { + if (vt.flags & DRAWN) + return; + + if (vt.y_size <= 0 || vt.x_size <= 0) + return; + + debugC(4, kDebugLevelScripts, "draw entry %d", vt.entry); + + vt.flags |= UPDATE; + if (agi_get_release() >= 0x3000) { + set_loop(&vt, vt.current_loop); + set_cel(&vt, vt.current_cel); + } + fix_position(p0); + vt.x_pos2 = vt.x_pos; + vt.y_pos2 = vt.y_pos; + vt.cel_data_2 = vt.cel_data; + erase_upd_sprites(); + vt.flags |= DRAWN; + + if (agi_get_release() <= 0x2440) /* See bug #546562 */ + vt.flags |= ANIMATED; + + blit_upd_sprites(); + vt.flags &= ~DONTUPDATE; + + commit_block(vt.x_pos, vt.y_pos - vt.y_size + 1, vt.x_pos + vt.x_size - 1, vt.y_pos); + + debugC(4, kDebugLevelScripts, "vt entry #%d flags = %02x", p0, vt.flags); +} + +cmd(erase) { + if (~vt.flags & DRAWN) + return; + + erase_upd_sprites(); + if (vt.flags & UPDATE) { + vt.flags &= ~DRAWN; + } else { + erase_nonupd_sprites(); + vt.flags &= ~DRAWN; + blit_nonupd_sprites(); + } + blit_upd_sprites(); + + commit_block(vt.x_pos, vt.y_pos - vt.y_size + 1, vt.x_pos + vt.x_size - 1, vt.y_pos); +} + +cmd(position) { + vt.x_pos = vt.x_pos2 = p1; + vt.y_pos = vt.y_pos2 = p2; +} + +cmd(position_f) { + vt.x_pos = vt.x_pos2 = _v[p1]; + vt.y_pos = vt.y_pos2 = _v[p2]; +} + +cmd(get_posn) { + game.vars[p1] = (unsigned char)vt.x_pos; + game.vars[p2] = (unsigned char)vt.y_pos; +} + +cmd(reposition) { + int dx = (int8) _v[p1], dy = (int8) _v[p2]; + + debugC(4, kDebugLevelScripts, "dx=%d, dy=%d", dx, dy); + vt.flags |= UPDATE_POS; + + if (dx < 0 && vt.x_pos < -dx) + vt.x_pos = 0; + else + vt.x_pos += dx; + + if (dy < 0 && vt.y_pos < -dy) + vt.y_pos = 0; + else + vt.y_pos += dy; + + fix_position(p0); +} + +cmd(reposition_to) { + vt.x_pos = p1; + vt.y_pos = p2; + vt.flags |= UPDATE_POS; + fix_position(p0); +} + +cmd(reposition_to_f) { + vt.x_pos = _v[p1]; + vt.y_pos = _v[p2]; + vt.flags |= UPDATE_POS; + fix_position(p0); +} + +cmd(add_to_pic) { + add_to_pic(p0, p1, p2, p3, p4, p5, p6); +} + +cmd(add_to_pic_f) { + add_to_pic(_v[p0], _v[p1], _v[p2], _v[p3], _v[p4], _v[p5], _v[p6]); +} + +cmd(force_update) { + erase_both(); + blit_both(); + commit_both(); +} + +cmd(reverse_loop) { + debugC(4, kDebugLevelScripts, "o%d, f%d", p0, p1); + vt.cycle = CYCLE_REV_LOOP; + vt.flags |= (DONTUPDATE | UPDATE | CYCLING); + vt.parm1 = p1; + setflag(p1, false); +} + +cmd(end_of_loop) { + debugC(4, kDebugLevelScripts, "o%d, f%d", p0, p1); + vt.cycle = CYCLE_END_OF_LOOP; + vt.flags |= (DONTUPDATE | UPDATE | CYCLING); + vt.parm1 = p1; + setflag(p1, false); +} + +cmd(block) { + debugC(4, kDebugLevelScripts, "x1=%d, y1=%d, x2=%d, y2=%d", p0, p1, p2, p3); + game.block.active = true; + game.block.x1 = p0; + game.block.y1 = p1; + game.block.x2 = p2; + game.block.y2 = p3; +} + +cmd(unblock) { + game.block.active = false; +} + +cmd(normal_motion) { + vt.motion = MOTION_NORMAL; +} + +cmd(stop_motion) { + vt.direction = 0; + vt.motion = MOTION_NORMAL; + if (p0 == 0) { /* ego only */ + _v[V_ego_dir] = 0; + game.player_control = false; + } +} + +cmd(start_motion) { + vt.motion = MOTION_NORMAL; + if (p0 == 0) { /* ego only */ + _v[V_ego_dir] = 0; + game.player_control = true; + } +} + +cmd(player_control) { + game.player_control = true; + game.view_table[0].motion = MOTION_NORMAL; +} + +cmd(program_control) { + game.player_control = false; +} + +cmd(follow_ego) { + vt.motion = MOTION_FOLLOW_EGO; + vt.parm1 = p1 > vt.step_size ? p1 : vt.step_size; + vt.parm2 = p2; + vt.parm3 = 0xff; + setflag(p2, false); + vt.flags |= UPDATE; +} + +cmd(move_obj) { + /* _D (_D_WARN "o=%d, x=%d, y=%d, s=%d, f=%d", p0, p1, p2, p3, p4); */ + + vt.motion = MOTION_MOVE_OBJ; + vt.parm1 = p1; + vt.parm2 = p2; + vt.parm3 = vt.step_size; + vt.parm4 = p4; + + if (p3 != 0) + vt.step_size = p3; + + setflag(p4, false); + vt.flags |= UPDATE; + + if (p0 == 0) + game.player_control = false; + + /* AGI 2.272 (ddp, xmas) doesn't call move_obj! */ + if (agi_get_release() > 0x2272) + move_obj(&vt); +} + +cmd(move_obj_f) { + vt.motion = MOTION_MOVE_OBJ; + vt.parm1 = _v[p1]; + vt.parm2 = _v[p2]; + vt.parm3 = vt.step_size; + vt.parm4 = p4; + + if (_v[p3] != 0) + vt.step_size = _v[p3]; + + setflag(p4, false); + vt.flags |= UPDATE; + + if (p0 == 0) + game.player_control = false; + + /* AGI 2.272 (ddp, xmas) doesn't call move_obj! */ + if (agi_get_release() > 0x2272) + move_obj(&vt); +} + +cmd(wander) { + if (p0 == 0) + game.player_control = false; + vt.motion = MOTION_WANDER; + vt.flags |= UPDATE; +} + +cmd(set_game_id) { + if (cur_logic->texts && (p0 - 1) <= cur_logic->num_texts) + strncpy(game.id, cur_logic->texts[p0 - 1], 8); + else + game.id[0] = 0; + + report("Game ID: \"%s\"\n", game.id); +} + +cmd(pause) { + int tmp = game.clock_enabled; + char *b[] = { "Continue", NULL }; + + game.clock_enabled = false; + selection_box(" Game is paused. \n\n\n", b); + game.clock_enabled = tmp; +} + +cmd(set_menu) { + debugC(4, kDebugLevelScripts, "text %02x of %02x", p0, cur_logic->num_texts); + if (cur_logic->texts != NULL && p0 < cur_logic->num_texts) + menu_add(cur_logic->texts[p0 - 1]); +} + +cmd(set_menu_item) { + debugC(4, kDebugLevelScripts, "text %02x of %02x", p0, cur_logic->num_texts); + if (cur_logic->texts != NULL && p0 <= cur_logic->num_texts) + menu_add_item(cur_logic->texts[p0 - 1], p1); +} + +cmd(version) { + char ver_msg[] = TITLE " v" VERSION; + char ver2_msg[] = + "\n" + " \n\n" + "Emulating Sierra AGI v%x.%03x\n"; + char ver3_msg[] = + "\n" + " \n\n" + " Emulating AGI v%x.002.%03x\n"; + /* no Sierra as it wraps textbox */ + char *r, *q; + int ver, maj, min; + char msg[256]; + + ver = agi_get_release(); + maj = (ver >> 12) & 0xf; + min = ver & 0xfff; + + q = maj == 2 ? ver2_msg : ver3_msg; + r = strchr(q + 1, '\n'); + + strncpy(q + 1 + ((r - q > 0 ? r - q : 1) / 4), ver_msg, strlen(ver_msg)); + sprintf(msg, q, maj, min); + message_box(msg); +} + +cmd(configure_screen) { + game.line_min_print = p0; + game.line_user_input = p1; + game.line_status = p2; +} + +cmd(text_screen) { + debugC(4, kDebugLevelScripts, "switching to text mode"); + game.gfx_mode = false; + /* + * Simulates the "bright background bit" of the PC video + * controller. + */ + if (game.color_bg) + game.color_bg |= 0x08; + clear_screen(game.color_bg); +} + +cmd(graphics) { + debugC(4, kDebugLevelScripts, "switching to graphics mode"); + if (!game.gfx_mode) { + game.gfx_mode = true; + clear_screen(0); + show_pic(); + write_status(); + write_prompt(); + } +} + +cmd(set_text_attribute) { + game.color_fg = p0; + game.color_bg = p1; + + if (game.gfx_mode) { + if (game.color_bg != 0) { + game.color_fg = 0; + game.color_bg = 15; + } + } +} + +cmd(status) { + inventory(); +} + +cmd(quit) { + char *buttons[] = { "Quit", "Continue", NULL }; + + stop_sound(); + if (p0) { + game.quit_prog_now = true; + } else { + if (selection_box + (" Quit the game, or continue? \n\n\n", buttons) == 0) { + game.quit_prog_now = true; + } + } +} + +cmd(restart_game) { + char *buttons[] = { "Restart", "Continue", NULL }; + int sel; + + stop_sound(); + sel = getflag(F_auto_restart) ? 1 : + selection_box(" Restart game, or continue? \n\n\n", buttons); + + if (sel == 0) { + game.quit_prog_now = 0xff; + setflag(F_restart_game, true); + menu_enable_all(); + } +} + +cmd(distance) { + int16 x1, y1, x2, y2, d; + struct vt_entry *v0 = &game.view_table[p0]; + struct vt_entry *v1 = &game.view_table[p1]; + + if (v0->flags & DRAWN && v1->flags & DRAWN) { + x1 = v0->x_pos + v0->x_size / 2; + y1 = v0->y_pos; + x2 = v1->x_pos + v1->x_size / 2; + y2 = v1->y_pos; + d = abs(x1 - x2) + abs(y1 - y2); + if (d > 0xfe) + d = 0xfe; + } else { + d = 0xff; + } + _v[p2] = (unsigned char)d; +} + +cmd(accept_input) { + debugC(4, kDebugLevelScripts | kDebugLevelInput, "input normal"); + new_input_mode(INPUT_NORMAL); + game.input_enabled = true; +} + +cmd(prevent_input) { + debugC(4, kDebugLevelScripts | kDebugLevelInput, "no input"); + new_input_mode(INPUT_NONE); + game.input_enabled = false; +} + +cmd(get_string) { + int tex, row, col; + + debugC(4, kDebugLevelScripts, "%d %d %d %d %d", p0, p1, p2, p3, p4); + + tex = p1 - 1; + row = p2; + col = p3; + + /* Workaround for SQLC bug. + * See bug #792125 for details + */ + if (row > 24) + row = 24; + if (col > 39) + col = 39; + + new_input_mode(INPUT_GETSTRING); + + if (cur_logic->texts != NULL && cur_logic->num_texts >= tex) { + int len = strlen(cur_logic->texts[tex]); + print_text(cur_logic->texts[tex], 0, col, row, len, game.color_fg, game.color_bg); + get_string(col + len - 1, row, p4, p0); + + /* SGEO: display input char */ + print_character((col + len), row, game.cursor_char, game.color_fg, game.color_bg); + } + + do { + main_cycle(); + } while (game.input_mode == INPUT_GETSTRING); +} + +cmd(get_num) { + debugC(4, kDebugLevelScripts, "%d %d", p0, p1); + new_input_mode(INPUT_GETSTRING); + + if (cur_logic->texts != NULL && cur_logic->num_texts >= (p0 - 1)) { + int len = strlen(cur_logic->texts[p0 - 1]); + print_text(cur_logic->texts[p0 - 1], 0, 0, 22, len, game.color_fg, game.color_bg); + get_string(len - 1, 22, 3, MAX_STRINGS); + + /* CM: display input char */ + print_character((p3 + len), 22, game.cursor_char, game.color_fg, game.color_bg); + } + + do { + main_cycle(); + } while (game.input_mode == INPUT_GETSTRING); + + _v[p1] = atoi(game.strings[MAX_STRINGS]); + debugC(4, kDebugLevelScripts, "[%s] -> %d", game.strings[MAX_STRINGS], _v[p1]); + clear_lines(22, 22, game.color_bg); + flush_lines(22, 22); +} + +cmd(set_cursor_char) { + if (cur_logic->texts != NULL && (p0 - 1) <= cur_logic->num_texts) { + game.cursor_char = *cur_logic->texts[p0 - 1]; + } else { + /* default */ + game.cursor_char = '_'; + } +} + +cmd(set_key) { + int key; + + debugC(4, kDebugLevelScripts, "%d %d %d", p0, p1, p2); + + if (game.ev_keyp[p2].data != 0) /* TBC sets c23 (ESC) twice! */ + return; + + key = 256 * p1 + p0; + game.ev_keyp[p2].data = key; + game.ev_keyp[p2].occured = false; +} + +cmd(set_string) { + /* CM: to avoid crash in Groza (str = 150) */ + if (p0 > MAX_STRINGS) + return; + strcpy(game.strings[p0], cur_logic->texts[p1 - 1]); +} + +cmd(display) { + print_text(cur_logic->texts[p2 - 1], p1, 0, p0, 40, game.color_fg, game.color_bg); +} + +cmd(display_f) { + debugC(4, kDebugLevelScripts, "p0 = %d", p0); + print_text(cur_logic->texts[_v[p2] - 1], _v[p1], 0, _v[p0], 40, game.color_fg, game.color_bg); +} + +cmd(clear_text_rect) { + int c, x1, y1, x2, y2; + + if ((c = p4) != 0) + c = 15; + x1 = p1 * CHAR_COLS; + y1 = p0 * CHAR_LINES; + x2 = (p3 + 1) * CHAR_COLS - 1; + y2 = (p2 + 1) * CHAR_LINES - 1; + + /* Added to prevent crash with x2 = 40 in the iigs demo */ + if (x1 > GFX_WIDTH) + x1 = GFX_WIDTH - 1; + if (x2 > GFX_WIDTH) + x2 = GFX_WIDTH - 1; + if (y1 > GFX_HEIGHT) + y1 = GFX_HEIGHT - 1; + if (y2 > GFX_HEIGHT) + y2 = GFX_HEIGHT - 1; + + draw_rectangle(x1, y1, x2, y2, c); + flush_block(x1, y1, x2, y2); +} + +cmd(toggle_monitor) { + report("toggle.monitor\n"); +#ifdef USE_HIRES + opt.hires = !opt.hires; + erase_both(); + show_pic(); + blit_both(); +#endif +} + +cmd(echo_line) { + strcpy((char *)game.input_buffer, (const char *)game.echo_buffer); + game.cursor_pos = strlen((char *)game.input_buffer); + game.has_prompt = 0; +} + +cmd(clear_lines) { + uint8 l; + + /* Residence 44 calls clear.lines(24,0,0), see bug #558423 */ + l = p1 ? p1 : p0; + + clear_lines(p0, l, p2); + flush_lines(p0, l); +} + +cmd(print) { + int n = p0 < 1 ? 1 : p0; + print(cur_logic->texts[n - 1], 0, 0, 0); +} + +cmd(print_f) { + int n = _v[p0] < 1 ? 1 : _v[p0]; + print(cur_logic->texts[n - 1], 0, 0, 0); +} + +cmd(print_at) { + int n = p0 < 1 ? 1 : p0; + debugC(4, kDebugLevelScripts, "%d %d %d %d", p0, p1, p2, p3); + print(cur_logic->texts[n - 1], p1, p2, p3); +} + +cmd(print_at_v) { + int n = _v[p0] < 1 ? 1 : _v[p0]; + print(cur_logic->texts[n - 1], p1, p2, p3); +} + +cmd(push_script) { +#ifdef USE_MOUSE + if (opt.agimouse) { + game.vars[27] = mouse.button; + game.vars[28] = mouse.x / 2; + game.vars[29] = mouse.y; + } else +#endif + report("push.script\n"); +} + +cmd(set_pri_base) { + int i, x, pri; + + report("Priority base set to %d\n", p0); + + /* game.alt_pri = true; */ + x = (_HEIGHT - p0) * _HEIGHT / 10; + + for (i = 0; i < _HEIGHT; i++) { + pri = (i - p0) < 0 ? 4 : (i - p0) * _HEIGHT / x + 5; + if (pri > 15) + pri = 15; + game.pri_table[i] = pri; + } +} + +cmd(mouse_posn) { +#ifdef USE_MOUSE + _v[p0] = WIN_TO_PIC_X(mouse.x); + _v[p1] = WIN_TO_PIC_Y(mouse.y); +#endif +} + +cmd(shake_screen) { + int i; + +#ifdef USE_MOUSE + /* AGI Mouse 1.1 uses shake.screen values between 100 and 109 to + * set the palette. + */ + if (opt.agimouse && p0 >= 100 && p0 < 110) { + report("not implemented: AGI Mouse palettes\n"); + return; + } else +#endif + shake_start(); + + commit_both(); /* Fixes SQ1 demo */ + for (i = 4 * p0; i; i--) { + shake_screen(i & 1); + flush_block(0, 0, GFX_WIDTH - 1, GFX_HEIGHT - 1); + main_cycle(); + } + shake_end(); +} + +static void (*agi_command[183]) (uint8 *) = { + NULL, /* 0x00 */ + cmd_increment, + cmd_decrement, + cmd_assignn, + cmd_assignv, + cmd_addn, + cmd_addv, + cmd_subn, + cmd_subv, /* 0x08 */ + cmd_lindirectv, + cmd_rindirect, + cmd_lindirectn, + cmd_set, + cmd_reset, + cmd_toggle, + cmd_set_v, + cmd_reset_v, /* 0x10 */ + cmd_toggle_v, + cmd_new_room, + cmd_new_room_f, + cmd_load_logic, + cmd_load_logic_f, + cmd_call, + cmd_call_f, + cmd_load_pic, /* 0x18 */ + cmd_draw_pic, + cmd_show_pic, + cmd_discard_pic, + cmd_overlay_pic, + cmd_show_pri_screen, + cmd_load_view, + cmd_load_view_f, + cmd_discard_view, /* 0x20 */ + cmd_animate_obj, + cmd_unanimate_all, + cmd_draw, + cmd_erase, + cmd_position, + cmd_position_f, + cmd_get_posn, + cmd_reposition, /* 0x28 */ + cmd_set_view, + cmd_set_view_f, + cmd_set_loop, + cmd_set_loop_f, + cmd_fix_loop, + cmd_release_loop, + cmd_set_cel, + cmd_set_cel_f, /* 0x30 */ + cmd_last_cel, + cmd_current_cel, + cmd_current_loop, + cmd_current_view, + cmd_number_of_loops, + cmd_set_priority, + cmd_set_priority_f, + cmd_release_priority, /* 0x38 */ + cmd_get_priority, + cmd_stop_update, + cmd_start_update, + cmd_force_update, + cmd_ignore_horizon, + cmd_observe_horizon, + cmd_set_horizon, + cmd_object_on_water, /* 0x40 */ + cmd_object_on_land, + cmd_object_on_anything, + cmd_ignore_objs, + cmd_observe_objs, + cmd_distance, + cmd_stop_cycling, + cmd_start_cycling, + cmd_normal_cycle, /* 0x48 */ + cmd_end_of_loop, + cmd_reverse_cycle, + cmd_reverse_loop, + cmd_cycle_time, + cmd_stop_motion, + cmd_start_motion, + cmd_step_size, + cmd_step_time, /* 0x50 */ + cmd_move_obj, + cmd_move_obj_f, + cmd_follow_ego, + cmd_wander, + cmd_normal_motion, + cmd_set_dir, + cmd_get_dir, + cmd_ignore_blocks, /* 0x58 */ + cmd_observe_blocks, + cmd_block, + cmd_unblock, + cmd_get, + cmd_get_f, + cmd_drop, + cmd_put, + cmd_put_f, /* 0x60 */ + cmd_get_room_f, + cmd_load_sound, + cmd_sound, + cmd_stop_sound, + cmd_print, + cmd_print_f, + cmd_display, + cmd_display_f, /* 0x68 */ + cmd_clear_lines, + cmd_text_screen, + cmd_graphics, + cmd_set_cursor_char, + cmd_set_text_attribute, + cmd_shake_screen, + cmd_configure_screen, + cmd_status_line_on, /* 0x70 */ + cmd_status_line_off, + cmd_set_string, + cmd_get_string, + cmd_word_to_string, + cmd_parse, + cmd_get_num, + cmd_prevent_input, + cmd_accept_input, /* 0x78 */ + cmd_set_key, + cmd_add_to_pic, + cmd_add_to_pic_f, + cmd_status, + cmd_save_game, + cmd_load_game, + cmd_init_disk, + cmd_restart_game, /* 0x80 */ + cmd_show_obj, + cmd_random, + cmd_program_control, + cmd_player_control, + cmd_obj_status_f, + cmd_quit, + cmd_show_mem, + cmd_pause, /* 0x88 */ + cmd_echo_line, + cmd_cancel_line, + cmd_init_joy, + cmd_toggle_monitor, + cmd_version, + cmd_script_size, + cmd_set_game_id, + cmd_log, /* 0x90 */ + cmd_set_scan_start, + cmd_reset_scan_start, + cmd_reposition_to, + cmd_reposition_to_f, + cmd_trace_on, + cmd_trace_info, + cmd_print_at, + cmd_print_at_v, /* 0x98 */ + cmd_discard_view, + cmd_clear_text_rect, + cmd_set_upper_left, + cmd_set_menu, + cmd_set_menu_item, + cmd_submit_menu, + cmd_enable_item, + cmd_disable_item, /* 0xa0 */ + cmd_menu_input, + cmd_show_obj_v, + cmd_open_dialogue, + cmd_close_dialogue, + cmd_mul_n, + cmd_mul_v, + cmd_div_n, + cmd_div_v, /* 0xa8 */ + cmd_close_window, + cmd_set_simple, + cmd_push_script, + cmd_pop_script, + cmd_hold_key, + cmd_set_pri_base, + cmd_discard_sound, + cmd_hide_mouse, /* 0xb0 */ + cmd_allow_menu, + cmd_show_mouse, + cmd_fence_mouse, + cmd_mouse_posn, + cmd_release_key, + cmd_adj_ego_move_to_x_y +}; + +#define CMD_BSIZE 12 + +/** + * Execute a logic script + * @param n Number of the logic resource to execute + */ +int run_logic(int n) { + uint8 op = 0; + uint8 p[CMD_BSIZE] = { 0 }; + uint8 *code = NULL; + int num = 0; + + /* If logic not loaded, load it */ + if (~game.dir_logic[n].flags & RES_LOADED) { + debugC(4, kDebugLevelScripts, "logic %d not loaded!", n); + agi_load_resource(rLOGIC, n); + } + + game.lognum = n; + cur_logic = &game.logics[game.lognum]; + + code = cur_logic->data; + cur_logic->cIP = cur_logic->sIP; + + timer_hack = 0; + while (ip < game.logics[n].size && !game.quit_prog_now) { +#ifdef USE_CONSOLE + if (debug_.enabled) { + if (debug_.steps > 0) { + if (debug_.logic0 || n) { + debug_console(n, lCOMMAND_MODE, NULL); + debug_.steps--; + } + } else { + blit_both(); + console_prompt(); + do { + main_cycle(); + } while (!debug_.steps && debug_.enabled); + console_lock(); + erase_both(); + } + } +#endif + + switch (op = *(code + ip++)) { + case 0xff: /* if (open/close) */ + test_if_code(n); + break; + case 0xfe: /* goto */ + /* +2 covers goto size */ + ip += 2 + ((int16)READ_LE_UINT16(code + ip)); + /* timer must keep running even in goto loops, + * but AGI engine can't do that :( + */ + if (timer_hack > 20) { + poll_timer(); + update_timer(); + timer_hack = 0; + } + break; + case 0x00: /* return */ + return 1; + default: + num = logic_names_cmd[op].num_args; + memmove(p, code + ip, num); + memset(p + num, 0, CMD_BSIZE - num); + agi_command[op] (p); + ip += num; + } + + if (game.exit_all_logics) + break; + } + + return 0; /* after executing new.room() */ +} + +void execute_agi_command(uint8 op, uint8 *p) { +#ifdef USE_CONSOLE + debugC(2, kDebugLevelScripts, "%s %d %d %d", logic_names_cmd[op].name, p[0], p[1], p[2]); +#endif + agi_command[op] (p); +} + +} // End of namespace Agi diff --git a/engines/agi/op_dbg.cpp b/engines/agi/op_dbg.cpp new file mode 100644 index 0000000000..2a8af3bc68 --- /dev/null +++ b/engines/agi/op_dbg.cpp @@ -0,0 +1,353 @@ +/* ScummVM - Scumm Interpreter + * Copyright (C) 2006 The ScummVM project + * + * Copyright (C) 1999-2001 Sarien Team + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + * $URL$ + * $Id$ + * + */ + +#include "common/stdafx.h" + +#include "agi/agi.h" +#include "agi/opcodes.h" + +namespace Agi { + +#define ip (game.logics[lognum].cIP) +#define code (game.logics[lognum].data) + +#ifdef _L +#undef _L +#endif + +#ifdef USE_CONSOLE +#define _L(a,b,c) { a, b, c } +#else +#define _L(a,b,c) { b, c } +#endif + +struct agi_logicnames logic_names_test[] = { + _L("", 0, 0x00), + _L("equaln", 2, 0x80), + _L("equalv", 2, 0xC0), + _L("lessn", 2, 0x80), + _L("lessv", 2, 0xC0), + _L("greatern", 2, 0x80), + _L("greaterv", 2, 0xC0), + _L("isset", 1, 0x00), + _L("issetv", 1, 0x80), + _L("has", 1, 0x00), + _L("obj.in.room", 2, 0x40), + _L("posn", 5, 0x00), + _L("controller", 1, 0x00), + _L("have.key", 0, 0x00), + + /* Not 0 args. Has variable number. */ + _L("said", 0, 0x00), + + _L("compare.strings", 2, 0x00), + _L("obj.in.box", 5, 0x00), + _L("center.posn", 5, 0x00), + _L("right.posn", 5, 0x00) +}; + +struct agi_logicnames logic_names_if[] = { + _L("OR", 0, 0x00), + _L("NOT", 0, 0x00), + _L("ELSE", 0, 0x00), + _L("IF", 0, 0x00) +}; + +struct agi_logicnames logic_names_cmd[] = { + _L("return", 0, 0x00), /* 00 */ + _L("increment", 1, 0x80), /* 01 */ + _L("decrement", 1, 0x80), /* 02 */ + _L("assignn", 2, 0x80), /* 03 */ + _L("assignv", 2, 0xC0), /* 04 */ + _L("addn", 2, 0x80), /* 05 */ + _L("addv", 2, 0xC0), /* 06 */ + _L("subn", 2, 0x80), /* 07 */ + _L("subv", 2, 0xC0), /* 08 */ + _L("lindirectv", 2, 0xC0), /* 09 */ + _L("rindirect", 2, 0xC0), /* 0A */ + _L("lindirectn", 2, 0x80), /* 0B */ + _L("set", 1, 0x00), /* 0C */ + _L("reset", 1, 0x00), /* 0D */ + _L("toggle", 1, 0x00), /* 0E */ + _L("set.v", 1, 0x80), /* 0F */ + _L("reset.v", 1, 0x80), /* 10 */ + _L("toggle.v", 1, 0x80), /* 11 */ + _L("new.room", 1, 0x00), /* 12 */ + _L("new.room.v", 1, 0x80), /* 13 */ + _L("load.logics", 1, 0x00), /* 14 */ + _L("load.logics.v", 1, 0x80), /* 15 */ + _L("call", 1, 0x00), /* 16 */ + _L("call.v", 1, 0x80), /* 17 */ + _L("load.pic", 1, 0x80), /* 18 */ + _L("draw.pic", 1, 0x80), /* 19 */ + _L("show.pic", 0, 0x00), /* 1A */ + _L("discard.pic", 1, 0x80), /* 1B */ + _L("overlay.pic", 1, 0x80), /* 1C */ + _L("show.pri.screen", 0, 0x00), /* 1D */ + _L("load.view", 1, 0x00), /* 1E */ + _L("load.view.v", 1, 0x80), /* 1F */ + _L("discard.view", 1, 0x00), /* 20 */ + _L("animate.obj", 1, 0x00), /* 21 */ + _L("unanimate.all", 0, 0x00), /* 22 */ + _L("draw", 1, 0x00), /* 23 */ + _L("erase", 1, 0x00), /* 24 */ + _L("position", 3, 0x00), /* 25 */ + _L("position.v", 3, 0x60), /* 26 */ + _L("get.posn", 3, 0x60), /* 27 */ + _L("reposition", 3, 0x60), /* 28 */ + _L("set.view", 2, 0x00), /* 29 */ + _L("set.view.v", 2, 0x40), /* 2A */ + _L("set.loop", 2, 0x00), /* 2B */ + _L("set.loop.v", 2, 0x40), /* 2C */ + _L("fix.loop", 1, 0x00), /* 2D */ + _L("release.loop", 1, 0x00), /* 2E */ + _L("set.cel", 2, 0x00), /* 2F */ + _L("set.cel.v", 2, 0x40), /* 30 */ + _L("last.cel", 2, 0x40), /* 31 */ + _L("current.cel", 2, 0x40), /* 32 */ + _L("current.loop", 2, 0x40), /* 33 */ + _L("current.view", 2, 0x40), /* 34 */ + _L("number.of.loops", 2, 0x40), /* 35 */ + _L("set.priority", 2, 0x00), /* 36 */ + _L("set.priority.v", 2, 0x40), /* 37 */ + _L("release.priority", 1, 0x00), /* 38 */ + _L("get.priority", 2, 0x40), /* 39 */ + _L("stop.update", 1, 0x00), /* 3A */ + _L("start.update", 1, 0x00), /* 3B */ + _L("force.update", 1, 0x00), /* 3C */ + _L("ignore.horizon", 1, 0x00), /* 3D */ + _L("observe.horizon", 1, 0x00), /* 3E */ + _L("set.horizon", 1, 0x00), /* 3F */ + _L("object.on.water", 1, 0x00), /* 40 */ + _L("object.on.land", 1, 0x00), /* 41 */ + _L("object.on.anything", 1, 0x00), /* 42 */ + _L("ignore.objs", 1, 0x00), /* 43 */ + _L("observe.objs", 1, 0x00), /* 44 */ + _L("distance", 3, 0x20), /* 45 */ + _L("stop.cycling", 1, 0x00), /* 46 */ + _L("start.cycling", 1, 0x00), /* 47 */ + _L("normal.cycle", 1, 0x00), /* 48 */ + _L("end.of.loop", 2, 0x00), /* 49 */ + _L("reverse.cycle", 1, 0x00), /* 4A */ + _L("reverse.loop", 2, 0x00), /* 4B */ + _L("cycle.time", 2, 0x40), /* 4C */ + _L("stop.motion", 1, 0x00), /* 4D */ + _L("start.motion", 1, 0x00), /* 4E */ + _L("step.size", 2, 0x40), /* 4F */ + _L("step.time", 2, 0x40), /* 50 */ + _L("move.obj", 5, 0x00), /* 51 */ + _L("move.obj.v", 5, 0x70), /* 52 */ + _L("follow.ego", 3, 0x00), /* 53 */ + _L("wander", 1, 0x00), /* 54 */ + _L("normal.motion", 1, 0x00), /* 55 */ + _L("set.dir", 2, 0x40), /* 56 */ + _L("get.dir", 2, 0x40), /* 57 */ + _L("ignore.blocks", 1, 0x00), /* 58 */ + _L("observe.blocks", 1, 0x00), /* 59 */ + _L("block", 4, 0x00), /* 5A */ + _L("unblock", 0, 0x00), /* 5B */ + _L("get", 1, 0x00), /* 5C */ + _L("get.v", 1, 0x80), /* 5D */ + _L("drop", 1, 0x00), /* 5E */ + _L("put", 2, 0x00), /* 5F */ + _L("put.v", 2, 0x40), /* 60 */ + _L("get.room.v", 2, 0xC0), /* 61 */ + _L("load.sound", 1, 0x00), /* 62 */ + _L("sound", 2, 0x00), /* 63 */ + _L("stop.sound", 0, 0x00), /* 64 */ + _L("print", 1, 0x00), /* 65 */ + _L("print.v", 1, 0x80), /* 66 */ + _L("display", 3, 0x00), /* 67 */ + _L("display.v", 3, 0xE0), /* 68 */ + _L("clear.lines", 3, 0x00), /* 69 */ + _L("text.screen", 0, 0x00), /* 6A */ + _L("graphics", 0, 0x00), /* 6B */ + _L("set.cursor.char", 1, 0x00), /* 6C */ + _L("set.text.attribute", 2, 0x00), /* 6D */ + _L("shake.screen", 1, 0x00), /* 6E */ + _L("configure.screen", 3, 0x00), /* 6F */ + _L("status.line.on", 0, 0x00), /* 70 */ + _L("status.line.off", 0, 0x00), /* 71 */ + _L("set.string", 2, 0x00), /* 72 */ + _L("get.string", 5, 0x00), /* 73 */ + _L("word.to.string", 2, 0x00), /* 74 */ + _L("parse", 1, 0x00), /* 75 */ + _L("get.num", 2, 0x40), /* 76 */ + _L("prevent.input", 0, 0x00), /* 77 */ + _L("accept.input", 0, 0x00), /* 78 */ + _L("set.key", 3, 0x00), /* 79 */ + _L("add.to.pic", 7, 0x00), /* 7A */ + _L("add.to.pic.v", 7, 0xFE), /* 7B */ + _L("status", 0, 0x00), /* 7C */ + _L("save.game", 0, 0x00), /* 7D */ + _L("restore.game", 0, 0x00), /* 7E */ + _L("init.disk", 0, 0x00), /* 7F */ + _L("restart.game", 0, 0x00), /* 80 */ + _L("show.obj", 1, 0x00), /* 81 */ + _L("random", 3, 0x20), /* 82 */ + _L("program.control", 0, 0x00), /* 83 */ + _L("player.control", 0, 0x00), /* 84 */ + _L("obj.status.v", 1, 0x80), /* 85 */ + /* 0 args for AGI version 2.089 */ + _L("quit", 1, 0x00), /* 86 */ + + _L("show.mem", 0, 0x00), /* 87 */ + _L("pause", 0, 0x00), /* 88 */ + _L("echo.line", 0, 0x00), /* 89 */ + _L("cancel.line", 0, 0x00), /* 8A */ + _L("init.joy", 0, 0x00), /* 8B */ + _L("toggle.monitor", 0, 0x00), /* 8C */ + _L("version", 0, 0x00), /* 8D */ + _L("script.size", 1, 0x00), /* 8E */ + _L("set.game.id", 1, 0x00), /* 8F */ + _L("log", 1, 0x00), /* 90 */ + _L("set.scan.start", 0, 0x00), /* 91 */ + _L("reset.scan.start", 0, 0x00), /* 92 */ + _L("reposition.to", 3, 0x00), /* 93 */ + _L("reposition.to.v", 3, 0x60), /* 94 */ + _L("trace.on", 0, 0x00), /* 95 */ + _L("trace.info", 3, 0x00), /* 96 */ + + /* 3 args for AGI versions before 2.440 */ + _L("print.at", 4, 0x00), /* 97 */ + _L("print.at.v", 4, 0x80), /* 98 */ + + _L("discard.view.v", 1, 0x80), /* 99 */ + _L("clear.text.rect", 5, 0x00), /* 9A */ + _L("set.upper.left", 2, 0x00), /* 9B */ + _L("set.menu", 1, 0x00), /* 9C */ + _L("set.menu.item", 2, 0x00), /* 9D */ + _L("submit.menu", 0, 0x00), /* 9E */ + _L("enable.item", 1, 0x00), /* 9F */ + _L("disable.item", 1, 0x00), /* A0 */ + _L("menu.input", 0, 0x00), /* A1 */ + _L("show.obj.v", 1, 0x01), /* A2 */ + _L("open.dialogue", 0, 0x00), /* A3 */ + _L("close.dialogue", 0, 0x00), /* A4 */ + _L("mul.n", 2, 0x80), /* A5 */ + _L("mul.v", 2, 0xC0), /* A6 */ + _L("div.n", 2, 0x80), /* A7 */ + _L("div.v", 2, 0xC0), /* A8 */ + _L("close.window", 0, 0x00), /* A9 */ + + _L("set.simple", 1, 0x00), /* AA */ + _L("push.script", 0, 0x00), /* AB */ + _L("pop.script", 0, 0x00), /* AC */ + _L("hold.key", 0, 0x00), /* AD */ + _L("set.pri.base", 1, 0x00), /* AE */ + _L("discard.sound", 1, 0x00), /* AF */ + + /* 1 arg for AGI version 3.002.086 */ + _L("hide.mouse", 0, 0x00), /* B0 */ + + _L("allow.menu", 1, 0x00), /* B1 */ + _L("show.mouse", 0, 0x00), /* B2 */ + _L("fence.mouse", 4, 0x00), /* B3 */ + _L("mouse.posn", 2, 0x00), /* B4 */ + _L("release.key", 0, 0x00), /* B5 */ + _L("adj.ego.move.to.xy", 0, 0x00), /* B6 */ + _L(NULL, 0, 0x00) +}; + +#ifdef USE_CONSOLE + +void debug_console(int lognum, int mode, char *str) { + struct agi_logicnames *x; + uint8 a, c, z; + + if (str) { + report(" %s\n", str); + return; + } + + report("%03d:%04x ", lognum, ip); + + switch (*(code + ip)) { + case 0xFC: + case 0xFD: + case 0xFE: + case 0xFF: + x = logic_names_if; + + if (debug_.opcodes) { + report("%02X %02X %02X %02X %02X %02X %02X %02X %02X\n" + " ", + (uint8) * (code + (0 + ip)) & 0xFF, + (uint8) * (code + (1 + ip)) & 0xFF, + (uint8) * (code + (2 + ip)) & 0xFF, + (uint8) * (code + (3 + ip)) & 0xFF, + (uint8) * (code + (4 + ip)) & 0xFF, + (uint8) * (code + (5 + ip)) & 0xFF, + (uint8) * (code + (6 + ip)) & 0xFF, + (uint8) * (code + (7 + ip)) & 0xFF, + (uint8) * (code + (8 + ip)) & 0xFF); + } + report("%s ", (x + *(code + ip) - 0xFC)->name); + break; + default: + x = mode == lCOMMAND_MODE ? logic_names_cmd : logic_names_test; + a = (unsigned char)(x + *(code + ip))->num_args; + c = (unsigned char)(x + *(code + ip))->arg_mask; + + if (debug_.opcodes) { + report("%02X %02X %02X %02X %02X %02X %02X %02X %02X\n" + " ", + (uint8) * (code + (0 + ip)) & 0xFF, + (uint8) * (code + (1 + ip)) & 0xFF, + (uint8) * (code + (2 + ip)) & 0xFF, + (uint8) * (code + (3 + ip)) & 0xFF, + (uint8) * (code + (4 + ip)) & 0xFF, + (uint8) * (code + (5 + ip)) & 0xFF, + (uint8) * (code + (6 + ip)) & 0xFF, + (uint8) * (code + (7 + ip)) & 0xFF, + (uint8) * (code + (8 + ip)) & 0xFF); + } + report("%s ", (x + *(code + ip))->name); + + for (z = 1; a > 0;) { + if (~c & 0x80) { + report("%d", *(code + (ip + z))); + } else { + report("v%d[%d]", *(code + (ip + z)), getvar(*(code + (ip + z)))); + } + c <<= 1; + z++; + if (--a > 0) + report(","); + } + break; + } + + report("\n"); +} + +#else + +void debug_console(int lognum, int mode, char *str) { + /* dummy */ +} + +#endif /* USE_CONSOLE */ + +} // End of namespace Agi diff --git a/engines/agi/op_test.cpp b/engines/agi/op_test.cpp new file mode 100644 index 0000000000..d4a98bb0ac --- /dev/null +++ b/engines/agi/op_test.cpp @@ -0,0 +1,419 @@ +/* ScummVM - Scumm Interpreter + * Copyright (C) 2006 The ScummVM project + * + * Copyright (C) 1999-2003 Sarien Team + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + * $URL$ + * $Id$ + * + */ + +#include "common/stdafx.h" + +#include "agi/agi.h" +#include "agi/keyboard.h" +#include "agi/opcodes.h" + +namespace Agi { + +static uint8 test_obj_right(uint8, uint8, uint8, uint8, uint8); +static uint8 test_obj_centre(uint8, uint8, uint8, uint8, uint8); +static uint8 test_obj_in_box(uint8, uint8, uint8, uint8, uint8); +static uint8 test_posn(uint8, uint8, uint8, uint8, uint8); +static uint8 test_said(uint8, uint8 *); +static uint8 test_controller(uint8); +static uint8 test_keypressed(void); +static uint8 test_compare_strings(uint8, uint8); + +#define ip (game.logics[lognum].cIP) +#define code (game.logics[lognum].data) + +#define test_equal(v1,v2) (getvar(v1) == (v2)) +#define test_less(v1,v2) (getvar(v1) < (v2)) +#define test_greater(v1,v2) (getvar(v1) > (v2)) +#define test_isset(flag) (getflag (flag)) +#define test_has(obj) (object_get_location (obj) == EGO_OWNED) +#define test_obj_in_room(obj,v) (object_get_location (obj) == getvar (v)) + +extern int timer_hack; /* For the timer loop in MH1 logic 153 */ + +static uint8 test_compare_strings(uint8 s1, uint8 s2) { + char ms1[MAX_STRINGLEN]; + char ms2[MAX_STRINGLEN]; + int j, k, l; + + strcpy(ms1, game.strings[s1]); + strcpy(ms2, game.strings[s2]); + + l = strlen(ms1); + for (k = 0, j = 0; k < l; k++) { + switch (ms1[k]) { + case 0x20: + case 0x09: + case '-': + case '.': + case ',': + case ':': + case ';': + case '!': + case '\'': + break; + + default: + ms1[j++] = toupper(ms1[k]); + break; + } + } + ms1[j] = 0x0; + + l = strlen(ms2); + for (k = 0, j = 0; k < l; k++) { + switch (ms2[k]) { + case 0x20: + case 0x09: + case '-': + case '.': + case ',': + case ':': + case ';': + case '!': + case '\'': + break; + + default: + ms2[j++] = toupper(ms2[k]); + break; + } + } + ms2[j] = 0x0; + + return !strcmp(ms1, ms2); +} + +static uint8 test_keypressed() { + int x = game.keypress; + + game.keypress = 0; + if (!x) { + int mode = game.input_mode; + game.input_mode = INPUT_NONE; + main_cycle(); + game.input_mode = mode; + } + + if (x) + debugC(5, kDebugLevelScripts | kDebugLevelInput, "keypress = %02x", x); + + return x; +} + +static uint8 test_controller(uint8 cont) { + return game.ev_keyp[cont].occured; +} + +static uint8 test_posn(uint8 n, uint8 x1, uint8 y1, uint8 x2, uint8 y2) { + struct vt_entry *v = &game.view_table[n]; + uint8 r; + + r = v->x_pos >= x1 && v->y_pos >= y1 && v->x_pos <= x2 && v->y_pos <= y2; + + debugC(7, kDebugLevelScripts, "(%d,%d) in (%d,%d,%d,%d): %s", v->x_pos, v->y_pos, x1, y1, x2, y2, r ? "true" : "false"); + + return r; +} + +static uint8 test_obj_in_box(uint8 n, uint8 x1, uint8 y1, uint8 x2, uint8 y2) { + struct vt_entry *v = &game.view_table[n]; + + return v->x_pos >= x1 && + v->y_pos >= y1 && v->x_pos + v->x_size - 1 <= x2 && v->y_pos <= y2; +} + +/* if n is in centre of box */ +static uint8 test_obj_centre(uint8 n, uint8 x1, uint8 y1, uint8 x2, uint8 y2) { + struct vt_entry *v = &game.view_table[n]; + + return v->x_pos + v->x_size / 2 >= x1 && + v->x_pos + v->x_size / 2 <= x2 && v->y_pos >= y1 && v->y_pos <= y2; +} + +/* if nect N is in right corner */ +static uint8 test_obj_right(uint8 n, uint8 x1, uint8 y1, uint8 x2, uint8 y2) { + struct vt_entry *v = &game.view_table[n]; + + return v->x_pos + v->x_size - 1 >= x1 && + v->x_pos + v->x_size - 1 <= x2 && v->y_pos >= y1 && v->y_pos <= y2; +} + +/* When player has entered something, it is parsed elsewhere */ +static uint8 test_said(uint8 nwords, uint8 *cc) { + int c, n = game.num_ego_words; + int z = 0; + + if (getflag(F_said_accepted_input) || !getflag(F_entered_cli)) + return false; + + /* FR: + * I think the reason for the code below is to add some speed.... + * + * if (nwords != num_ego_words) + * return false; + * + * In the disco scene in Larry 1 when you type "examine blonde", + * inside the logic is expected ( said("examine", "blonde", "rol") ) + * where word("rol") = 9999 + * + * According to the interpreter code 9999 means that whatever the + * user typed should be correct, but it looks like code 9999 means that + * if the string is empty at this point, the entry is also correct... + * + * With the removal of this code, the behaviour of the scene was + * corrected + */ + + for (c = 0; nwords && n; c++, nwords--, n--) { + z = READ_LE_UINT16(cc); + cc += 2; + + switch (z) { + case 9999: /* rest of line (empty string counts to...) */ + nwords = 1; + break; + case 1: /* any word */ + break; + default: + if (game.ego_words[c].id != z) + return false; + break; + } + } + + /* The entry string should be entirely parsed, or last word = 9999 */ + if (n && z != 9999) + return false; + + /* The interpreter string shouldn't be entirely parsed, but next + * word must be 9999. + */ + if (nwords != 0 && READ_LE_UINT16(cc) != 9999) + return false; + + setflag(F_said_accepted_input, true); + + return true; +} + +int test_if_code(int lognum) { + int ec = true; + int retval = true; + uint8 op = 0; + uint8 not_test = false; + uint8 or_test = false; + uint16 last_ip = ip; + uint8 p[16] = { 0 }; + + while (retval && !game.quit_prog_now) { +#ifdef USE_CONSOLE + if (debug_.enabled && (debug_.logic0 || lognum)) + debug_console(lognum, lTEST_MODE, NULL); +#endif + + last_ip = ip; + op = *(code + ip++); + memmove(p, (code + ip), 16); + + switch (op) { + case 0xFF: /* END IF, TEST true */ + goto end_test; + case 0xFD: + not_test = !not_test; + continue; + case 0xFC: /* OR */ + /* if or_test is ON and we hit 0xFC, end of OR, then + * or is STILL false so break. + */ + if (or_test) { + ec = false; + retval = false; + goto end_test; + } + + or_test = true; + continue; + + case 0x00: + /* return true? */ + goto end_test; + case 0x01: + ec = test_equal(p[0], p[1]); + if (p[0] == 11) + timer_hack++; + break; + case 0x02: + ec = test_equal(p[0], getvar(p[1])); + if (p[0] == 11 || p[1] == 11) + timer_hack++; + break; + case 0x03: + ec = test_less(p[0], p[1]); + if (p[0] == 11) + timer_hack++; + break; + case 0x04: + ec = test_less(p[0], getvar(p[1])); + if (p[0] == 11 || p[1] == 11) + timer_hack++; + break; + case 0x05: + ec = test_greater(p[0], p[1]); + if (p[0] == 11) + timer_hack++; + break; + case 0x06: + ec = test_greater(p[0], getvar(p[1])); + if (p[0] == 11 || p[1] == 11) + timer_hack++; + break; + case 0x07: + ec = test_isset(p[0]); + break; + case 0x08: + ec = test_isset(getvar(p[0])); + break; + case 0x09: + ec = test_has(p[0]); + break; + case 0x0A: + ec = test_obj_in_room(p[0], p[1]); + break; + case 0x0B: + ec = test_posn(p[0], p[1], p[2], p[3], p[4]); + break; + case 0x0C: + ec = test_controller(p[0]); + break; + case 0x0D: + ec = test_keypressed(); + break; + case 0x0E: + ec = test_said(p[0], (uint8 *) code + (ip + 1)); + ip = last_ip; + ip++; /* skip opcode */ + ip += p[0] * 2; /* skip num_words * 2 */ + ip++; /* skip num_words opcode */ + break; + case 0x0F: + debugC(7, kDebugLevelScripts, "comparing [%s], [%s]", game.strings[p[0]], game.strings[p[1]]); + ec = test_compare_strings(p[0], p[1]); + break; + case 0x10: + ec = test_obj_in_box(p[0], p[1], p[2], p[3], p[4]); + break; + case 0x11: + ec = test_obj_centre(p[0], p[1], p[2], p[3], p[4]); + break; + case 0x12: + ec = test_obj_right(p[0], p[1], p[2], p[3], p[4]); + break; + default: + ec = false; + goto end_test; + } + + if (op <= 0x12) + ip += logic_names_test[op].num_args; + + /* exchange ec value */ + if (not_test) + ec = !ec; + + /* not is only enabled for 1 test command */ + not_test = false; + + if (or_test && ec) { + /* a true inside an OR statement passes + * ENTIRE statement scan for end of OR + */ + + /* CM: test for opcode < 0xfc changed from 'op' to + * '*(code+ip)', to avoid problem with the 0xfd (NOT) + * opcode byte. Changed a bad ip += ... ip++ construct. + * This should fix the crash with Larry's logic.0 code: + * + * if ((isset(4) || + * !isset(2) || + * v30 == 2 || + * v30 == 1)) { + * goto Label1; + * } + * + * The bytecode is: + * ff fc 07 04 fd 07 02 01 1e 02 01 1e 01 fc ff + */ + + /* find end of OR */ + while (*(code + ip) != 0xFC) { + if (*(code + ip) == 0x0E) { /* said */ + ip++; + /* cover count + ^words */ + ip += 1 + ((*(code + ip)) * 2); + continue; + } + + if (*(code + ip) < 0xFC) + ip += logic_names_test[*(code + ip)].num_args; + ip++; + } + ip++; + + or_test = false; + retval = true; + } else { + retval = or_test ? retval || ec : retval && ec; + } + } + end_test: + + /* if false, scan for end of IP? */ + if (retval) + ip += 2; + else { + ip = last_ip; + while (*(code + ip) != 0xff) { + if (*(code + ip) == 0x0e) { + ip++; + ip += (*(code + ip)) * 2 + 1; + } else if (*(code + ip) < 0xfc) { + ip += logic_names_test[*(code + ip)].num_args; + ip++; + } else { + ip++; + } + } + ip++; /* skip over 0xFF */ + ip += READ_LE_UINT16(code + ip) + 2; + } + +#ifdef USE_CONSOLE + if (debug_.enabled && (debug_.logic0 || lognum)) + debug_console(lognum, 0xFF, retval ? (char *)"=true" : (char *)"=false"); +#endif + + return retval; +} + +} // End of namespace Agi diff --git a/engines/agi/opcodes.h b/engines/agi/opcodes.h new file mode 100644 index 0000000000..236ba19e68 --- /dev/null +++ b/engines/agi/opcodes.h @@ -0,0 +1,55 @@ +/* ScummVM - Scumm Interpreter + * Copyright (C) 2006 The ScummVM project + * + * Copyright (C) 1999-2001 Sarien Team + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + * $URL$ + * $Id$ + * + */ + +#ifndef __AGI_OPCODES_H +#define __AGI_OPCODES_H + +#include "agi/agi.h" + +namespace Agi { + +struct agi_logicnames { +#ifdef USE_CONSOLE /* ifndef NO_DEBUG */ + char *name; +#endif + uint16 num_args; + uint16 arg_mask; +}; + +extern struct agi_logicnames logic_names_test[]; +extern struct agi_logicnames logic_names_cmd[]; +extern struct agi_logicnames logic_names_if[]; + +void debug_console(int, int, char *); +int test_if_code(int); +void new_room(int); +void execute_agi_command(uint8, uint8 *); + +#ifdef PATCH_LOGIC +void patch_logic(int); +#endif + +} // End of namespace Agi + +#endif /* __AGI_OPCODES_H */ diff --git a/engines/agi/patches.cpp b/engines/agi/patches.cpp new file mode 100644 index 0000000000..a666c84686 --- /dev/null +++ b/engines/agi/patches.cpp @@ -0,0 +1,144 @@ +/* ScummVM - Scumm Interpreter + * Copyright (C) 2006 The ScummVM project + * + * Copyright (C) 1999-2001 Sarien Team + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + * $URL$ + * $Id$ + * + */ + +#include "common/stdafx.h" + +#include "agi/agi.h" +#include "agi/opcodes.h" + +namespace Agi { + +#ifdef PATCH_LOGIC + +#define ip (game.logics[n].cIP) +#define code (game.logics[n].data) +#define size (game.logics[n].size) + +/* + * Patches + */ + +static uint8 kq4data_find[] = { + 0x0C, 0x04, 0xFF, 0x07, 0x05, 0xFF, 0x15, 0x00, + 0x03, 0x0A, 0x00, 0x77, 0x83, 0x71, 0x0D, 0x97, + 0x03, 0x98, 0xCE, 0x18, 0x98, 0x19, 0x98, 0x1B, + 0x98, 0x0C, 0x5A, 0x1A, 0x00 +}; + +static uint8 kq4data_fix[] = { + /* v19 = 0 + * new.room(96) + * return + */ + 0x03, 0x13, 0x0, 0x12, 0x60, 0x00 +}; + +static uint8 grdata_find[] = { + 0x0C, 0x04, 0xFF, 0x07, 0x05, 0xFF, 0x16, 0x00, + 0x0C, 0x96, 0x03, 0x0A, 0x00, 0x77, 0x83, 0x71, + 0x0D, 0xD9, 0x03, 0xDC, 0xBF, 0x18, 0xDC, 0x19, + 0xDC, 0x1B, 0xDC, 0x0C, 0x95, 0x1A +}; + +static uint8 grdata_fix[] = { + /* reset(227) + * v19 = 0 + * v246 = 1 + * set(15) + * new.room(73) + */ + 0x0D, 0xE3, 0x03, 0x13, 0x00, 0x03, 0xF6, 0x01, + 0x0C, 0x0F, 0x12, 0x49 +}; + +#if 0 +static uint8 lsl1data_find[] = { + 0xFF, 0xFD, 0x07, 0x1E, 0xFC, 0x07, 0x6D, 0x01, + 0x5F, 0x03, 0xFC, 0xFF, 0x12, 0x00, 0x0C, 0x6D, + 0x78, 0x8A, 0x77, 0x69, 0x16, 0x18, 0x00, 0x0D, + 0x30, 0x0D, 0x55, 0x78, 0x65, 0x0A +}; + +static uint8 lsl1data_fix[] = { + /* set(109) + * reset(48) + * reset(85) + * accept.input() + * new.room(11) + */ + 0x0C, 0x6D, 0x0D, 0x30, 0x0D, 0x55, 0x78, 0x12, + 0x0B +}; +#endif + +static uint8 mh1data_find[] = { + 0xFF, 0x07, 0x05, 0xFF, 0xE6, 0x00, + 0x03, 0x0A, 0x02, 0x77, 0x83, 0x71, + 0x6F, 0x01, 0x17, 0x00, 0x03, 0x00, + 0x9F, 0x03, 0x37, 0x00, 0x03, 0x32, + 0x03, 0x03, 0x3B, 0x00, 0x6C, 0x03 +}; + +static uint8 mh1data_fix[] = { + 0x0C, 0x05, 0x16, 0x5A, 0x12, 0x99 +}; + +void patch_logic(int n) { + switch (n) { +#if 0 + /* ALT-X in the questions takes care of that */ + case 6: + /* lsl1 bypass questions */ + if (!strcmp(game.id, "LLLLL")) { + if (!memcmp(lsl1data_find, (code + ip), 30)) + memmove((code + ip), lsl1data_fix, 9); + } + break; +#endif + case 125: + /* gold rush code break */ + if (!strcmp(game.id, "GR")) { + if (!memcmp(grdata_find, (code + ip), 30)) + memmove((code + ip), grdata_fix, 12); + } + break; + case 140: + /* kings quest 4 code break */ + if (!strcmp(game.id, "KQ4")) { + if (memcmp(kq4data_find, (code + ip), 29) == 0) + memmove((code + ip), kq4data_fix, 6); + } + break; + case 159: + /* manhunter 1 amiga */ + if (ip + 30 < size && !memcmp(mh1data_find, (code + ip), 30)) { + memmove((code + ip), mh1data_fix, 6); + } + break; + } +} + +#endif + +} // End of namespace Agi diff --git a/engines/agi/picture.cpp b/engines/agi/picture.cpp new file mode 100644 index 0000000000..1b9ab22cdf --- /dev/null +++ b/engines/agi/picture.cpp @@ -0,0 +1,1034 @@ +/* ScummVM - Scumm Interpreter + * Copyright (C) 2006 The ScummVM project + * + * Copyright (C) 1999-2001 Sarien Team + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + * $URL$ + * $Id$ + * + */ + +#include "common/stdafx.h" + +#include "agi/agi.h" +#include "agi/graphics.h" +#include "agi/savegame.h" + +namespace Agi { + +#define next_byte data[foffs++] + +static uint8 *data; +static uint32 flen; +static uint32 foffs; + +static uint8 pat_code; +static uint8 pat_num; +static uint8 pri_on; +static uint8 scr_on; +static uint8 scr_colour; +static uint8 pri_colour; + +static uint8 circles[][15] = { /* agi circle bitmaps */ + {0x80}, + {0xfc}, + {0x5f, 0xf4}, + {0x66, 0xff, 0xf6, 0x60}, + {0x23, 0xbf, 0xff, 0xff, 0xee, 0x20}, + {0x31, 0xe7, 0x9e, 0xff, 0xff, 0xde, 0x79, 0xe3, 0x00}, + {0x38, 0xf9, 0xf3, 0xef, 0xff, 0xff, 0xff, 0xfe, 0xf9, 0xf3, 0xe3, 0x80}, + {0x18, 0x3c, 0x7e, 0x7e, 0x7e, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7e, 0x7e, 0x7e, 0x3c, 0x18} +}; + +static uint8 splatter_map[32] = { /* splatter brush bitmaps */ + 0x20, 0x94, 0x02, 0x24, 0x90, 0x82, 0xa4, 0xa2, + 0x82, 0x09, 0x0a, 0x22, 0x12, 0x10, 0x42, 0x14, + 0x91, 0x4a, 0x91, 0x11, 0x08, 0x12, 0x25, 0x10, + 0x22, 0xa8, 0x14, 0x24, 0x00, 0x50, 0x24, 0x04 +}; + +static uint8 splatter_start[128] = { /* starting bit position */ + 0x00, 0x18, 0x30, 0xc4, 0xdc, 0x65, 0xeb, 0x48, + 0x60, 0xbd, 0x89, 0x05, 0x0a, 0xf4, 0x7d, 0x7d, + 0x85, 0xb0, 0x8e, 0x95, 0x1f, 0x22, 0x0d, 0xdf, + 0x2a, 0x78, 0xd5, 0x73, 0x1c, 0xb4, 0x40, 0xa1, + 0xb9, 0x3c, 0xca, 0x58, 0x92, 0x34, 0xcc, 0xce, + 0xd7, 0x42, 0x90, 0x0f, 0x8b, 0x7f, 0x32, 0xed, + 0x5c, 0x9d, 0xc8, 0x99, 0xad, 0x4e, 0x56, 0xa6, + 0xf7, 0x68, 0xb7, 0x25, 0x82, 0x37, 0x3a, 0x51, + 0x69, 0x26, 0x38, 0x52, 0x9e, 0x9a, 0x4f, 0xa7, + 0x43, 0x10, 0x80, 0xee, 0x3d, 0x59, 0x35, 0xcf, + 0x79, 0x74, 0xb5, 0xa2, 0xb1, 0x96, 0x23, 0xe0, + 0xbe, 0x05, 0xf5, 0x6e, 0x19, 0xc5, 0x66, 0x49, + 0xf0, 0xd1, 0x54, 0xa9, 0x70, 0x4b, 0xa4, 0xe2, + 0xe6, 0xe5, 0xab, 0xe4, 0xd2, 0xaa, 0x4c, 0xe3, + 0x06, 0x6f, 0xc6, 0x4a, 0xa4, 0x75, 0x97, 0xe1 +}; + +static void fix_pixel_bothsides(int x, int y); + +static void put_virt_pixel(int x, int y, int res) { + uint8 *p; + int width = _WIDTH * res; + + if (x < 0 || y < 0 || x >= width || y >= _HEIGHT) + return; + + p = +#ifdef USE_HIRES + res > 1 ? &game.hires[y * width + x] : +#endif + &game.sbuf[y * width + x]; + + if (pri_on) + *p = (pri_colour << 4) | (*p & 0x0f); + if (scr_on) + *p = scr_colour | (*p & 0xf0); +} + +/* For the flood fill routines */ + +/* MH2 needs stack size > 300 */ +#define STACK_SIZE 512 +static unsigned int stack_ptr; +static uint16 stack[STACK_SIZE]; + +static INLINE void _PUSH(uint16 c) { + assert(stack_ptr < STACK_SIZE); + + stack[stack_ptr] = c; + stack_ptr++; +} + +static INLINE uint16 _POP() { + if (stack_ptr == 0) + return 0xffff; + + stack_ptr--; + return stack[stack_ptr]; +} + +/** + * Draw an AGI line. + * A line drawing routine sent by Joshua Neal, modified by Stuart George + * (fixed >>2 to >>1 and some other bugs like x1 instead of y1, etc.) + * @param x1 x coordinate of start point + * @param y1 y coordinate of start point + * @param x2 x coordinate of end point + * @param y2 y coordinate of end point + * @param res horizontal resolution multiplier + */ +static void draw_line(int x1, int y1, int x2, int y2, int res) { + int i, x, y, deltaX, deltaY, stepX, stepY, errorX, errorY, detdelta; + int width = _WIDTH * res; + + /* CM: Do clipping */ +#define clip(x, y) if((x)>=(y)) (x)=(y) + clip(x1, width - 1); + clip(x2, width - 1); + clip(y1, _HEIGHT - 1); + clip(y2, _HEIGHT - 1); + + /* Vertical line */ + + if (x1 == x2) { + if (y1 > y2) { + y = y1; + y1 = y2; + y2 = y; + } + + for (; y1 <= y2; y1++) { + put_virt_pixel(x1, y1, res); +#ifdef USE_HIRES + if (res > 1) + fix_pixel_bothsides(x1, y1); +#endif + } + + return; + } + + /* Horizontal line */ + + if (y1 == y2) { + if (x1 > x2) { + x = x1; + x1 = x2; + x2 = x; + } +#ifdef USE_HIRES + if (res > 1) + fix_pixel_bothsides(x1, y1); +#endif + + for (; x1 <= x2; x1++) + put_virt_pixel(x1, y1, res); + +#ifdef USE_HIRES + if (res > 1) { + put_virt_pixel(x1, y1, res); + fix_pixel_bothsides(x1, y1); + } +#endif + + return; + } + + y = y1; + x = x1; + + stepY = 1; + deltaY = y2 - y1; + if (deltaY < 0) { + stepY = -1; + deltaY = -deltaY; + } + + stepX = 1; + deltaX = x2 - x1; + if (deltaX < 0) { + stepX = -1; + deltaX = -deltaX; + } + + if (deltaY > deltaX) { + i = deltaY; + detdelta = deltaY; + errorX = deltaY / 2; + errorY = 0; + } else { + i = deltaX; + detdelta = deltaX; + errorX = 0; + errorY = deltaX / 2; + } + + put_virt_pixel(x, y, res); +#ifdef USE_HIRES + if (res > 1) + fix_pixel_bothsides(x, y); +#endif + + do { + errorY += deltaY; + if (errorY >= detdelta) { + errorY -= detdelta; + y += stepY; + } + + errorX += deltaX; + if (errorX >= detdelta) { + errorX -= detdelta; + x += stepX; + } + + put_virt_pixel(x, y, res); +#ifdef USE_HIRES + if (res > 1) + fix_pixel_bothsides(x, y); +#endif + i--; + } while (i > 0); + +#ifdef USE_HIRES + if (res > 1) { + put_virt_pixel(x, y, res); + fix_pixel_bothsides(x, y); + } +#endif +} + +/** + * Draw a relative AGI line. + * Draws short lines relative to last position. (drawing action 0xF7) + * @param res horizontal resolution multiplier + */ +static void dynamic_draw_line(int res) { + int x1, y1, disp, dx, dy; + + x1 = next_byte * res; + y1 = next_byte; + + put_virt_pixel(x1, y1, res); + + while (42) { + if ((disp = next_byte) >= 0xf0) + break; + + dx = ((disp & 0xf0) >> 4) & 0x0f; + dy = (disp & 0x0f); + + if (dx & 0x08) + dx = -(dx & 0x07); + if (dy & 0x08) + dy = -(dy & 0x07); + + dx *= res; + + draw_line(x1, y1, x1 + dx, y1 + dy, res); + x1 += dx; + y1 += dy; + } + foffs--; +} + +/************************************************************************** +** absoluteLine +** +** Draws long lines to actual locations (cf. relative) (drawing action 0xF6) +**************************************************************************/ +static void absolute_draw_line(int res) { + int x1, y1, x2, y2; + + x1 = next_byte * res; + y1 = next_byte; + put_virt_pixel(x1, y1, res); + + while (42) { + if ((x2 = next_byte) >= 0xf0) + break; + + if ((y2 = next_byte) >= 0xf0) + break; + + x2 *= res; + + draw_line(x1, y1, x2, y2, res); + x1 = x2; + y1 = y2; + } + foffs--; +} + +/************************************************************************** +** okToFill +**************************************************************************/ +static INLINE int is_ok_fill_here(int x, int y) { + uint8 p; + + if (x < 0 || x >= _WIDTH || y < 0 || y >= _HEIGHT) + return false; + + if (!scr_on && !pri_on) + return false; + + p = game.sbuf[y * _WIDTH + x]; + + if (!pri_on && scr_on && scr_colour != 15) + return (p & 0x0f) == 15; + + if (pri_on && !scr_on && pri_colour != 4) + return (p >> 4) == 4; + + return (scr_on && (p & 0x0f) == 15 && scr_colour != 15); +} + +/************************************************************************** +** agi_fill +**************************************************************************/ +static void fill_scanline(int x, int y) { + unsigned int c; + int newspan_up, newspan_down; + + if (!is_ok_fill_here(x, y)) + return; + + /* Scan for left border */ + for (c = x - 1; is_ok_fill_here(c, y); c--); + + newspan_up = newspan_down = 1; + for (c++; is_ok_fill_here(c, y); c++) { + put_virt_pixel(c, y, 1); + if (is_ok_fill_here(c, y - 1)) { + if (newspan_up) { + _PUSH(c + 320 * (y - 1)); + newspan_up = 0; + } + } else { + newspan_up = 1; + } + + if (is_ok_fill_here(c, y + 1)) { + if (newspan_down) { + _PUSH(c + 320 * (y + 1)); + newspan_down = 0; + } + } else { + newspan_down = 1; + } + } +} + +static void agi_fill(unsigned int x, unsigned int y) { + _PUSH(x + 320 * y); + + while (42) { + uint16 c = _POP(); + + /* Exit if stack is empty */ + if (c == 0xffff) + break; + + x = c % 320; + y = c / 320; + + fill_scanline(x, y); + } + + stack_ptr = 0; +} + +/************************************************************************** +** xCorner +** +** Draws an xCorner (drawing action 0xF5) +**************************************************************************/ +static void x_corner(int res) { + int x1, x2, y1, y2; + + x1 = next_byte * res; + y1 = next_byte; + put_virt_pixel(x1, y1, res); + + while (42) { + x2 = next_byte; + + if (x2 >= 0xf0) + break; + + x2 *= res; + + draw_line(x1, y1, x2, y1, res); + x1 = x2; + y2 = next_byte; + + if (y2 >= 0xf0) + break; + + draw_line(x1, y1, x1, y2, res); + y1 = y2; + } + foffs--; +} + +/************************************************************************** +** yCorner +** +** Draws an yCorner (drawing action 0xF4) +**************************************************************************/ +static void y_corner(int res) { + int x1, x2, y1, y2; + + x1 = next_byte * res; + y1 = next_byte; + put_virt_pixel(x1, y1, res); + + while (42) { + y2 = next_byte; + + if (y2 >= 0xF0) + break; + + draw_line(x1, y1, x1, y2, res); + y1 = y2; + x2 = next_byte; + + if (x2 >= 0xf0) + break; + + x2 *= res; + + draw_line(x1, y1, x2, y1, res); + x1 = x2; + } + + foffs--; +} + +/************************************************************************** +** fill +** +** AGI flood fill. (drawing action 0xF8) +**************************************************************************/ +static void fill() { + int x1, y1; + + while ((x1 = next_byte) < 0xF0 && (y1 = next_byte) < 0xf0) + agi_fill(x1, y1); + + foffs--; +} + +/************************************************************************** +** plotPattern +** +** Draws pixels, circles, squares, or splatter brush patterns depending +** on the pattern code. +**************************************************************************/ + +static int plot_pattern_point(int x, int y, int bitpos, int res) { + if (pat_code & 0x20) { + if ((splatter_map[bitpos >> 3] >> (7 - (bitpos & 7))) & 1) { +#ifdef USE_HIRES + if (res > 1) { + /* extra randomness in hi-res brush fill + */ + if (rnd->getRandomNumber(3)) + put_virt_pixel(x * 2, y, 2); + if (!rnd->getRandomNumber(3)) + put_virt_pixel(x * 2 + 1, y, 2); + } else +#endif + { + put_virt_pixel(x, y, 1); + } + } + bitpos++; + if (bitpos == 0xff) + bitpos = 0; + } else { +#ifdef USE_HIRES + if (res > 1) { + /* double width pixels make MUMG and others + * look nicer + */ + put_virt_pixel(x * 2, y, 2); + put_virt_pixel(x * 2 + 1, y, 2); + } else +#endif + { + put_virt_pixel(x, y, 1); + } + } + + return bitpos; +} + +static void plot_pattern(int x, int y, int res) { + int32 circlePos = 0; + uint32 x1, y1, pensize, bitpos = splatter_start[pat_num]; + + pensize = (pat_code & 7); + + if (x < (int)pensize) + x = pensize - 1; + if (y < (int)pensize) + y = pensize; + + for (y1 = y - pensize; y1 <= y + pensize; y1++) { + for (x1 = x - (pensize + 1) / 2; x1 <= x + pensize / 2; x1++) { + if (pat_code & 0x10) { /* Square */ + bitpos = plot_pattern_point (x1, y1, bitpos, res); + } else { /* Circle */ + if ((circles[pat_code & 7][circlePos >> 3] >> (7 - (circlePos & 7))) & 1) { + bitpos = plot_pattern_point(x1, y1, bitpos, res); + } + circlePos++; + } + } + } +} + +/************************************************************************** +** plotBrush +** +** Plots points and various brush patterns. +**************************************************************************/ +static void plot_brush(int res) { + int x1, y1; + + while (42) { + if (pat_code & 0x20) { + if ((pat_num = next_byte) >= 0xF0) + break; + pat_num = (pat_num >> 1) & 0x7f; + } + + if ((x1 = next_byte) >= 0xf0) + break; + + if ((y1 = next_byte) >= 0xf0) + break; + + plot_pattern(x1, y1, res); + } + + foffs--; +} + +#ifdef USE_HIRES + +static void fix_pixel_bothsides(int x, int y) { + uint8 *p, *s; + + if (x >= (_WIDTH * 2) - 2) + return; + + /* Sometimes a solid color area in the lo-res pic is made + * with lines, and we want to keep this effect in the + * hi-res pic. + */ + p = &game.hires[y * (_WIDTH * 2) + x]; + if ((*(p - 2) & 0x0f) == scr_colour) + put_virt_pixel(x - 1, y, 2); + if ((*(p + 2) & 0x0f) == scr_colour) + put_virt_pixel(x + 1, y, 2); + + /* If two lines are contiguous in the lo-res pic, make them + * contiguous in the hi-res pic. This condition is needed + * in some scenes like in front of Lefty's in LSL1, to draw + * the pole. Note: it adds artifacts in some cases. + */ + s = &game.sbuf[y * _WIDTH + x / 2]; + if ((*(p - 1) & 0x0f) != (*(s - 1) & 0x0f)) + put_virt_pixel(x - 1, y, 2); +} + +/************************************************************************** +** okToFill +**************************************************************************/ +static INLINE int hires_fill_here(int x, int y) { + uint8 *p, *s; + + if (x < 0 || x >= _WIDTH || y < 0 || y >= _HEIGHT) + return false; + + if (!scr_on && !pri_on) + return false; + + p = &game.hires[(int32) y * (_WIDTH * 2) + x * 2]; + s = &game.sbuf[y * _WIDTH + x]; + + if (scr_on) { + if (scr_colour == 0x0f) + return false; + if ((*p & 0x0f) != 0x0f || (*(p + 1) & 0x0f) != 0x0f) + return false; + if ((*s & 0x0f) != scr_colour) + return false; + } + + if (pri_on) { + if (pri_colour == 0x04) + return false; + if ((*p >> 4) != 0x04 || (*(p + 1) >> 4) != 0x04) + return false; + if ((*s >> 4) != pri_colour) + return false; + } + + return true; +} + +static void fix_pixel_left(int x, int y) { + uint8 *p; + + if (!scr_on) + return; + + p = &game.hires[y * (_WIDTH * 2) + x * 2 + 1]; + if ((*p & 0x0f) == 0x0f) + put_virt_pixel(2 * x + 1, y, 2); + else if ((*p & 0x0f) == (*(p - 1) & 0x0f)) + put_virt_pixel(2 * x + 1, y, 2); +} + +static void fix_pixel_right(int x, int y) { + int idx = y * (_WIDTH * 2) + x * 2; + + if (idx >= 160 * 168) + return; + + if (scr_on && (game.hires[idx] & 0x0f) == 0x0f) + put_virt_pixel(2 * x, y, 2); +} + +static void fix_pixel_here(int x, int y) { + uint8 p; + + p = game.hires[y * (_WIDTH * 2) + x * 2 + 1]; + if (scr_on && (p & 0x0f) == 0x0f) + put_virt_pixel(2 * x + 1, y, 2); +} + +/************************************************************************** +** agiFill +**************************************************************************/ +static void hires_fill_scanline(int x, int y) { + unsigned int c; + int newspan_up, newspan_down; + + if (!hires_fill_here(x, y)) + return; + + /* Scan for left border */ + for (c = x - 1; c > 0 && hires_fill_here(c, y); c--); + fix_pixel_left(c, y); + + newspan_up = newspan_down = 1; + for (c++; hires_fill_here(c, y); c++) { + put_virt_pixel(c * 2, y, 2); + fix_pixel_here(c, y); + + if (hires_fill_here(c, y - 1)) { + if (newspan_up) { + _PUSH(c + 320 * (y - 1)); + newspan_up = 0; + } + } else { + newspan_up = 1; + } + + if (hires_fill_here(c, y + 1)) { + if (newspan_down) { + _PUSH(c + 320 * (y + 1)); + newspan_down = 0; + } + } else { + newspan_down = 1; + } + } + + fix_pixel_right(c, y); +} + +static void _hires_fill(unsigned int x, unsigned int y) { + _PUSH(x + 320 * y); + + while (42) { + uint16 c = _POP(); + + /* Exit if stack is empty */ + if (c == 0xffff) + break; + + x = c % 320; + y = c / 320; + + hires_fill_scanline(x, y); + } + + stack_ptr = 0; +} + +/************************************************************************** +** fill +** +** AGI flood fill. (drawing action 0xF8) +**************************************************************************/ +static void hires_fill() { + int x1, y1; + + while ((x1 = next_byte) < 0xf0 && (y1 = next_byte) < 0xf0) { + _hires_fill(x1, y1); + } + + foffs--; +} + +/** + * Show AGI picture. + * This function copies a ``hidden'' AGI picture to the output device. + */ +void show_hires_pic() { + int y, offset; + int32 i; + + i = 0; + offset = game.line_min_print * CHAR_LINES; + for (y = 0; y < _HEIGHT; y++) { + put_pixels_hires(0, y + offset, _WIDTH * 2, &game.hires[i]); + i += _WIDTH * 2; + } + + flush_screen(); +} + +void fix_hires_picture() { + uint8 *p, *b; + int i; + + p = game.hires; + b = game.sbuf; + + for (i = 0; p < &game.hires[_WIDTH * _HEIGHT * 2] - 1; p++, i++) { + if ((*p & 0x0f) == 0x0f && (*b & 0x0f) != 0x0f) { + if ((*(p + 1) & 0x0f) != 0x0f) + *p = *(p + 1); + else + *p = *b; + } + if ((*p >> 4) == 4 && (*b >> 4) != 4 && (*(b + 1) >> 4) != 4) { + *p = (*p & 0x0f) | (*b & 0xf0); + } + b += (i & 1); + } +} + +#endif /* USE_HIRES */ + +static void draw_picture() { + uint8 act; + int drawing; +#ifdef USE_HIRES + int save_foffs; +#endif + + pat_code = 0; + pat_num = 0; + pri_on = scr_on = false; + scr_colour = 0xf; + pri_colour = 0x4; + + drawing = 1; + + debugC(8, kDebugLevelMain, "Drawing picture"); + for (drawing = 1; drawing && foffs < flen;) { + +#ifdef USE_HIRES + save_foffs = foffs; +#endif + + act = next_byte; + switch (act) { + case 0xf0: /* set colour on screen */ + scr_colour = next_byte; + scr_colour &= 0xF; /* for v3 drawing diff */ + scr_on = true; + break; + case 0xf1: /* disable screen drawing */ + scr_on = false; + break; + case 0xf2: /* set colour on priority */ + pri_colour = next_byte; + pri_colour &= 0xf; /* for v3 drawing diff */ + pri_on = true; + break; + case 0xf3: /* disable priority screen */ + pri_on = false; + break; + case 0xf4: /* y-corner */ + y_corner(1); + break; + case 0xf5: /* x-corner */ + x_corner(1); + break; + case 0xf6: /* absolute draw lines */ + absolute_draw_line(1); + break; + case 0xf7: /* dynamic draw lines */ + dynamic_draw_line(1); + break; + case 0xf8: /* fill */ + fill(); + break; + case 0xf9: /* set pattern */ + pat_code = next_byte; + break; + case 0xfA: /* plot brush */ + plot_brush(1); + break; + case 0xFF: /* end of pic data */ + default: + drawing = 0; + break; + } + +#ifdef USE_HIRES + foffs = save_foffs; + + act = next_byte; + switch (act) { + case 0xf0: /* set colour on screen */ + scr_colour = next_byte; + scr_colour &= 0xF; /* for v3 drawing diff */ + scr_on = true; + break; + case 0xf1: /* disable screen drawing */ + scr_on = false; + break; + case 0xf2: /* set colour on priority */ + pri_colour = next_byte; + pri_colour &= 0xf; /* for v3 drawing diff */ + pri_on = true; + break; + case 0xf3: /* disable priority screen */ + pri_on = false; + break; + case 0xf4: /* y-corner */ + y_corner(2); + break; + case 0xf5: /* x-corner */ + x_corner(2); + break; + case 0xf6: /* absolute draw lines */ + absolute_draw_line(2); + break; + case 0xf7: /* dynamic draw lines */ + dynamic_draw_line(2); + break; + case 0xf8: /* fill */ + hires_fill(); + break; + case 0xf9: /* set pattern */ + pat_code = next_byte; + break; + case 0xfA: /* plot brush */ + plot_brush(2); + break; + case 0xFF: /* end of pic data */ + default: + drawing = 0; + break; + } +#endif + } +} + +/* + * Public functions + */ + +/** + * + */ +uint8 *convert_v3_pic(uint8 *data, uint32 len) { + uint8 d, old = 0, x, *in, *xdata, *out, mode = 0; + uint32 i, ulen; + + xdata = (uint8 *) malloc(len + len / 2); + + out = xdata; + in = data; + + for (i = ulen = 0; i < len; i++, ulen++) { + d = *in++; + + *out++ = x = mode ? ((d & 0xF0) >> 4) + ((old & 0x0F) << 4) : d; + + if (x == 0xFF) { + ulen++; + break; + } + + if (x == 0xf0 || x == 0xf2) { + if (mode) { + *out++ = d & 0x0F; + ulen++; + } else { + d = *in++; + *out++ = (d & 0xF0) >> 4; + i++, ulen++; + } + + mode = !mode; + } + + old = d; + } + + free(data); + xdata = (uint8 *)realloc(xdata, ulen); + + return xdata; +} + +/** + * Decode an AGI picture resource. + * This function decodes an AGI picture resource into the correct slot + * and draws it on the AGI screen, optionally cleaning the screen before + * drawing. + * @param n AGI picture resource number + * @param clear clear AGI screen before drawing + */ +int decode_picture(int n, int clear) { + debugC(8, kDebugLevelResources, "(%d)", n); + + pat_code = 0; + pat_num = 0; + pri_on = scr_on = false; + scr_colour = 0xF; + pri_colour = 0x4; + + data = game.pictures[n].rdata; + flen = game.dir_pic[n].len; + foffs = 0; + + if (clear) { + memset(game.sbuf, 0x4f, _WIDTH * _HEIGHT); +#ifdef USE_HIRES + memset(game.hires, 0x4f, _WIDTH * 2 * _HEIGHT); +#endif + } + + draw_picture(); + +#ifdef USE_HIRES + fix_hires_picture(); +#endif + + if (clear) + clear_image_stack(); + record_image_stack_call(ADD_PIC, n, clear, 0, 0, 0, 0, 0); + + return err_OK; +} + +/** + * Unload an AGI picture resource. + * This function unloads an AGI picture resource and deallocates + * resource data. + * @param n AGI picture resource number + */ +int unload_picture(int n) { + /* remove visual buffer & priority buffer if they exist */ + if (game.dir_pic[n].flags & RES_LOADED) { + free(game.pictures[n].rdata); + game.dir_pic[n].flags &= ~RES_LOADED; + } + + return err_OK; +} + +/** + * Show AGI picture. + * This function copies a ``hidden'' AGI picture to the output device. + */ +void show_pic() { + int i, y; + int offset; + + debugC(8, kDebugLevelMain, "Show picture!"); +#ifdef USE_HIRES + if (opt.hires) { + show_hires_pic(); + return; + } +#endif + + i = 0; + offset = game.line_min_print * CHAR_LINES; + for (y = 0; y < _HEIGHT; y++) { + put_pixels_a(0, y + offset, _WIDTH, &game.sbuf[i]); + i += _WIDTH; + } + + flush_screen(); +} + +} // End of namespace Agi diff --git a/engines/agi/picture.h b/engines/agi/picture.h new file mode 100644 index 0000000000..0828cdecc1 --- /dev/null +++ b/engines/agi/picture.h @@ -0,0 +1,47 @@ +/* ScummVM - Scumm Interpreter + * Copyright (C) 2006 The ScummVM project + * + * Copyright (C) 1999-2001 Sarien Team + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + * $URL$ + * $Id$ + * + */ + +#ifndef __AGI_PICTURE_H +#define __AGI_PICTURE_H + +#include "agi/agi.h" + +namespace Agi { + +/** + * AGI picture resource. + */ +struct agi_picture { + uint32 flen; /**< size of raw data */ + uint8 *rdata; /**< raw vector image data */ +}; + +int decode_picture(int, int); +int unload_picture(int); +void show_pic(void); +uint8 *convert_v3_pic(uint8 *data, uint32 len); + +} // End of namespace Agi + +#endif /* __AGI_PICTURE_H */ diff --git a/engines/agi/savegame.cpp b/engines/agi/savegame.cpp new file mode 100644 index 0000000000..e4efc4402f --- /dev/null +++ b/engines/agi/savegame.cpp @@ -0,0 +1,790 @@ +/* ScummVM - Scumm Interpreter + * Copyright (C) 2006 The ScummVM project + * + * Copyright (C) 1999-2003 Sarien Team + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + * $URL$ + * $Id$ + * + */ + +/* + * Savegame support by Vasyl Tsvirkunov <vasyl@pacbell.net> + * Multi-slots by Claudio Matsuoka <claudio@helllabs.org> + */ + +#include "common/stdafx.h" + +#include "agi/agi.h" +#include "agi/graphics.h" +#include "agi/sprite.h" +#include "agi/text.h" +#include "agi/savegame.h" +#include "agi/keyboard.h" +#include "agi/menu.h" + +namespace Agi { + +#if defined(WIN32) +#define MKDIR(a,b) mkdir(a) +#else +#define MKDIR(a,b) mkdir(a,b) +#endif + +/* Image stack support */ +struct image_stack_element { + uint8 type; + uint8 pad; + int16 parm1; + int16 parm2; + int16 parm3; + int16 parm4; + int16 parm5; + int16 parm6; + int16 parm7; +}; + +#define INITIAL_IMAGE_STACK_SIZE 32 +static int stack_size = 0; +static struct image_stack_element *image_stack = NULL; +static int image_stack_pointer = 0; + +void clear_image_stack(void) { + image_stack_pointer = 0; +} + +void release_image_stack(void) { + if (image_stack) + free(image_stack); + image_stack = NULL; + stack_size = image_stack_pointer = 0; +} + +void record_image_stack_call(uint8 type, int16 p1, int16 p2, int16 p3, + int16 p4, int16 p5, int16 p6, int16 p7) { + struct image_stack_element *pnew; + + if (image_stack_pointer == stack_size) { + if (stack_size == 0) { /* first call */ + image_stack = (struct image_stack_element *) + malloc(INITIAL_IMAGE_STACK_SIZE * sizeof(struct image_stack_element)); + stack_size = INITIAL_IMAGE_STACK_SIZE; + } else { /* has to grow */ + struct image_stack_element *new_stack; + new_stack = (struct image_stack_element *) + malloc(2 * stack_size * sizeof(struct image_stack_element)); + memcpy(new_stack, image_stack, stack_size * sizeof(struct image_stack_element)); + free(image_stack); + image_stack = new_stack; + stack_size *= 2; + } + } + + pnew = &image_stack[image_stack_pointer]; + image_stack_pointer++; + + pnew->type = type; + pnew->parm1 = p1; + pnew->parm2 = p2; + pnew->parm3 = p3; + pnew->parm4 = p4; + pnew->parm5 = p5; + pnew->parm6 = p6; + pnew->parm7 = p7; +} + +void replay_image_stack_call(uint8 type, int16 p1, int16 p2, int16 p3, + int16 p4, int16 p5, int16 p6, int16 p7) { + switch (type) { + case ADD_PIC: + debugC(8, kDebugLevelMain, "--- decoding picture %d ---", p1); + agi_load_resource(rPICTURE, p1); + decode_picture(p1, p2); + break; + case ADD_VIEW: + agi_load_resource(rVIEW, p1); + add_to_pic(p1, p2, p3, p4, p5, p6, p7); + break; + } +} + +/* */ + +static char *strSig = "AGI:"; + +static void write_uint8(Common::File *f, int8 val) { + f->write(&val, 1); +} + +static void write_sint16(Common::File *f, int16 val) { + static uint8 buf[2]; + buf[0] = (uint8) ((val >> 8) & 255); + buf[1] = (uint8) (val & 255); + f->write(buf, 2); +} + +static void write_uint16(Common::File *f, uint16 val) { + static uint8 buf[2]; + buf[0] = (uint8) ((val >> 8) & 255); + buf[1] = (uint8) (val & 255); + f->write(buf, 2); +} + +static uint8 read_uint8(Common::File *f) { + static uint8 buf[1]; + f->read(buf, 1); + return buf[0]; +} + +static uint16 read_uint16(Common::File *f) { + static uint8 buf[2]; + f->read(buf, 2); + return (buf[0] << 8) | buf[1]; +} + +static int16 read_sint16(Common::File *f) { + static uint8 buf[2]; + f->read(buf, 2); + return (int16) ((buf[0] << 8) | buf[1]); +} + +static void write_string(Common::File *f, char *s) { + write_sint16(f, (int16) strlen(s)); + f->write(s, strlen(s)); +} + +static void read_string(Common::File *f, char *s) { + int16 size = read_sint16(f); + f->read(s, size); + s[size] = (char)0; +} + +static void write_bytes(Common::File *f, char *s, int16 size) { + f->write(s, size); +} + +static void read_bytes(Common::File *f, char *s, int16 size) { + f->read(s, size); +} + +/* + * Version 0: view table has 64 entries + * Version 1: view table has 256 entries (needed in KQ3) + */ +#define SAVEGAME_VERSION 1 + +int save_game(char *s, char *d) { + int16 i; + struct image_stack_element *ptr = image_stack; + Common::File f; + + f.open(s, Common::File::kFileWriteMode); + + if (!f.isOpen()) + return err_BadFileOpen; + + write_bytes(&f, strSig, 8); + write_string(&f, d); + + write_uint8(&f, (uint8) SAVEGAME_VERSION); + write_uint8(&f, (uint8) game.state); + /* game.name */ + write_string(&f, game.id); + /* game.crc */ + + for (i = 0; i < MAX_FLAGS; i++) + write_uint8(&f, game.flags[i]); + for (i = 0; i < MAX_VARS; i++) + write_uint8(&f, game.vars[i]); + + write_sint16(&f, (int8) game.horizon); + write_sint16(&f, (int16) game.line_status); + write_sint16(&f, (int16) game.line_user_input); + write_sint16(&f, (int16) game.line_min_print); + /* game.cursor_pos */ + /* game.input_buffer */ + /* game.echo_buffer */ + /* game.keypress */ + write_sint16(&f, (int16) game.input_mode); + write_sint16(&f, (int16) game.lognum); + + write_sint16(&f, (int16) game.player_control); + write_sint16(&f, (int16) game.quit_prog_now); + write_sint16(&f, (int16) game.status_line); + write_sint16(&f, (int16) game.clock_enabled); + write_sint16(&f, (int16) game.exit_all_logics); + write_sint16(&f, (int16) game.picture_shown); + write_sint16(&f, (int16) game.has_prompt); + write_sint16(&f, (int16) game.game_flags); + + /* Reversed to keep compatibility with old savegames */ + write_sint16(&f, (int16)!game.input_enabled); + + for (i = 0; i < _HEIGHT; i++) + write_uint8(&f, game.pri_table[i]); + + /* game.msg_box_ticks */ + /* game.block */ + /* game.window */ + /* game.has_window */ + + write_sint16(&f, (int16)game.gfx_mode); + write_uint8(&f, game.cursor_char); + write_sint16(&f, (int16)game.color_fg); + write_sint16(&f, (int16)game.color_bg); + + /* game.hires (#ifdef USE_HIRES) */ + /* game.sbuf */ + /* game.ego_words */ + /* game.num_ego_words */ + + write_sint16(&f, (int16)game.num_objects); + for (i = 0; i < (int16)game.num_objects; i++) + write_sint16(&f, (int16)object_get_location(i)); + + /* game.ev_keyp */ + for (i = 0; i < MAX_STRINGS; i++) + write_string(&f, game.strings[i]); + + /* record info about loaded resources */ + for (i = 0; i < MAX_DIRS; i++) { + write_uint8(&f, game.dir_logic[i].flags); + write_sint16(&f, (int16)game.logics[i].sIP); + write_sint16(&f, (int16)game.logics[i].cIP); + } + for (i = 0; i < MAX_DIRS; i++) + write_uint8(&f, game.dir_pic[i].flags); + for (i = 0; i < MAX_DIRS; i++) + write_uint8(&f, game.dir_view[i].flags); + for (i = 0; i < MAX_DIRS; i++) + write_uint8(&f, game.dir_sound[i].flags); + + /* game.pictures */ + /* game.logics */ + /* game.views */ + /* game.sounds */ + + for (i = 0; i < MAX_VIEWTABLE; i++) { + struct vt_entry *v = &game.view_table[i]; + + write_uint8(&f, v->step_time); + write_uint8(&f, v->step_time_count); + write_uint8(&f, v->entry); + write_sint16(&f, v->x_pos); + write_sint16(&f, v->y_pos); + write_uint8(&f, v->current_view); + + /* v->view_data */ + + write_uint8(&f, v->current_loop); + write_uint8(&f, v->num_loops); + + /* v->loop_data */ + + write_uint8(&f, v->current_cel); + write_uint8(&f, v->num_cels); + + /* v->cel_data */ + /* v->cel_data_2 */ + + write_sint16(&f, v->x_pos2); + write_sint16(&f, v->y_pos2); + + /* v->s */ + + write_sint16(&f, v->x_size); + write_sint16(&f, v->y_size); + write_uint8(&f, v->step_size); + write_uint8(&f, v->cycle_time); + write_uint8(&f, v->cycle_time_count); + write_uint8(&f, v->direction); + + write_uint8(&f, v->motion); + write_uint8(&f, v->cycle); + write_uint8(&f, v->priority); + + write_uint16(&f, v->flags); + + write_uint8(&f, v->parm1); + write_uint8(&f, v->parm2); + write_uint8(&f, v->parm3); + write_uint8(&f, v->parm4); + } + + /* Save image stack */ + + for (i = 0; i < image_stack_pointer; i++) { + ptr = &image_stack[i]; + write_uint8(&f, ptr->type); + write_sint16(&f, ptr->parm1); + write_sint16(&f, ptr->parm2); + write_sint16(&f, ptr->parm3); + write_sint16(&f, ptr->parm4); + write_sint16(&f, ptr->parm5); + write_sint16(&f, ptr->parm6); + write_sint16(&f, ptr->parm7); + } + write_uint8(&f, 0); + + f.close(); + + return err_OK; +} + +int load_game(char *s) { + int i, ver, vt_entries = MAX_VIEWTABLE; + uint8 t; + int16 parm[7]; + char sig[8]; + char id[8]; + char description[256]; + Common::File f; + + f.open(s); + + if (!f.isOpen()) + return err_BadFileOpen; + + read_bytes(&f, sig, 8); + if (strncmp(sig, strSig, 8)) { + f.close(); + return err_BadFileOpen; + } + + read_string(&f, description); + + ver = read_uint8(&f); + if (ver == 0) + vt_entries = 64; + game.state = read_uint8(&f); + /* game.name - not saved */ + read_string(&f, id); + if (strcmp(id, game.id)) { + f.close(); + return err_BadFileOpen; + } + /* game.crc - not saved */ + + for (i = 0; i < MAX_FLAGS; i++) + game.flags[i] = read_uint8(&f); + for (i = 0; i < MAX_VARS; i++) + game.vars[i] = read_uint8(&f); + + game.horizon = read_sint16(&f); + game.line_status = read_sint16(&f); + game.line_user_input = read_sint16(&f); + game.line_min_print = read_sint16(&f); + + /* These are never saved */ + game.cursor_pos = 0; + game.input_buffer[0] = 0; + game.echo_buffer[0] = 0; + game.keypress = 0; + + game.input_mode = read_sint16(&f); + game.lognum = read_sint16(&f); + + game.player_control = read_sint16(&f); + game.quit_prog_now = read_sint16(&f); + game.status_line = read_sint16(&f); + game.clock_enabled = read_sint16(&f); + game.exit_all_logics = read_sint16(&f); + game.picture_shown = read_sint16(&f); + game.has_prompt = read_sint16(&f); + game.game_flags = read_sint16(&f); + game.input_enabled = !read_sint16(&f); + + for (i = 0; i < _HEIGHT; i++) + game.pri_table[i] = read_uint8(&f); + + if (game.has_window) + close_window(); + game.msg_box_ticks = 0; + game.block.active = false; + /* game.window - fixed by close_window() */ + /* game.has_window - fixed by close_window() */ + + game.gfx_mode = read_sint16(&f); + game.cursor_char = read_uint8(&f); + game.color_fg = read_sint16(&f); + game.color_bg = read_sint16(&f); + + /* game.hires (#ifdef USE_HIRES) - rebuilt from image stack */ + /* game.sbuf - rebuilt from image stack */ + + /* game.ego_words - fixed by clean_input */ + /* game.num_ego_words - fixed by clean_input */ + + game.num_objects = read_sint16(&f); + for (i = 0; i < (int16) game.num_objects; i++) + object_set_location(i, read_sint16(&f)); + + /* Those are not serialized */ + for (i = 0; i < MAX_DIRS; i++) { + game.ev_keyp[i].occured = false; + } + + for (i = 0; i < MAX_STRINGS; i++) + read_string(&f, game.strings[i]); + + for (i = 0; i < MAX_DIRS; i++) { + if (read_uint8(&f) & RES_LOADED) + agi_load_resource(rLOGIC, i); + else + agi_unload_resource(rLOGIC, i); + game.logics[i].sIP = read_sint16(&f); + game.logics[i].cIP = read_sint16(&f); + } + + for (i = 0; i < MAX_DIRS; i++) { + if (read_uint8(&f) & RES_LOADED) + agi_load_resource(rPICTURE, i); + else + agi_unload_resource(rPICTURE, i); + } + + for (i = 0; i < MAX_DIRS; i++) { + if (read_uint8(&f) & RES_LOADED) + agi_load_resource(rVIEW, i); + else + agi_unload_resource(rVIEW, i); + } + + for (i = 0; i < MAX_DIRS; i++) { + if (read_uint8(&f) & RES_LOADED) + agi_load_resource(rSOUND, i); + else + agi_unload_resource(rSOUND, i); + } + + /* game.pictures - loaded above */ + /* game.logics - loaded above */ + /* game.views - loaded above */ + /* game.sounds - loaded above */ + + for (i = 0; i < vt_entries; i++) { + struct vt_entry *v = &game.view_table[i]; + + v->step_time = read_uint8(&f); + v->step_time_count = read_uint8(&f); + v->entry = read_uint8(&f); + v->x_pos = read_sint16(&f); + v->y_pos = read_sint16(&f); + v->current_view = read_uint8(&f); + + /* v->view_data - fixed below */ + + v->current_loop = read_uint8(&f); + v->num_loops = read_uint8(&f); + + /* v->loop_data - fixed below */ + + v->current_cel = read_uint8(&f); + v->num_cels = read_uint8(&f); + + /* v->cel_data - fixed below */ + /* v->cel_data_2 - fixed below */ + + v->x_pos2 = read_sint16(&f); + v->y_pos2 = read_sint16(&f); + + /* v->s - fixed below */ + + v->x_size = read_sint16(&f); + v->y_size = read_sint16(&f); + v->step_size = read_uint8(&f); + v->cycle_time = read_uint8(&f); + v->cycle_time_count = read_uint8(&f); + v->direction = read_uint8(&f); + + v->motion = read_uint8(&f); + v->cycle = read_uint8(&f); + v->priority = read_uint8(&f); + + v->flags = read_uint16(&f); + + v->parm1 = read_uint8(&f); + v->parm2 = read_uint8(&f); + v->parm3 = read_uint8(&f); + v->parm4 = read_uint8(&f); + } + for (i = vt_entries; i < MAX_VIEWTABLE; i++) { + memset(&game.view_table[i], 0, sizeof(struct vt_entry)); + } + + /* Fix some pointers in viewtable */ + + for (i = 0; i < MAX_VIEWTABLE; i++) { + struct vt_entry *v = &game.view_table[i]; + + if (game.dir_view[v->current_view].offset == _EMPTY) + continue; + + if (!(game.dir_view[v->current_view].flags & RES_LOADED)) + agi_load_resource(rVIEW, v->current_view); + + set_view(v, v->current_view); /* Fix v->view_data */ + set_loop(v, v->current_loop); /* Fix v->loop_data */ + set_cel(v, v->current_cel); /* Fix v->cel_data */ + v->cel_data_2 = v->cel_data; + v->s = NULL; /* not sure if it is used... */ + } + + erase_both(); + + /* Clear input line */ + clear_screen(0); + write_status(); + + /* Recreate background from saved image stack */ + clear_image_stack(); + while ((t = read_uint8(&f)) != 0) { + for (i = 0; i < 7; i++) + parm[i] = read_sint16(&f); + replay_image_stack_call(t, parm[0], parm[1], parm[2], + parm[3], parm[4], parm[5], parm[6]); + } + + f.close(); + + setflag(F_restore_just_ran, true); + + game.has_prompt = 0; /* force input line repaint if necessary */ + clean_input(); + + erase_both(); + blit_both(); + commit_both(); + show_pic(); + do_update(); + + return err_OK; +} + +#define NUM_SLOTS 12 + +static int select_slot() { + int i, key, active = 0; + int rc = -1; + int hm = 2, vm = 3; /* box margins */ + char desc[NUM_SLOTS][40]; + + for (i = 0; i < NUM_SLOTS; i++) { + char name[MAX_PATH]; + Common::File f; + char sig[8]; + sprintf(name, "%s/%05X_%s_%02d.sav", _savePath, game.crc, game.id, i); + f.open(name); + if (!f.isOpen()) { + strcpy(desc[i], " (empty slot)"); + } else { + read_bytes(&f, sig, 8); + if (strncmp(sig, strSig, 8)) { + strcpy(desc[i], "(corrupt file)"); + } else { + read_string(&f, desc[i]); + } + f.close(); + } + } + + while (42) { + char dstr[64]; + for (i = 0; i < NUM_SLOTS; i++) { + sprintf(dstr, "[%-32.32s]", desc[i]); + print_text(dstr, 0, hm + 1, vm + 4 + i, + (40 - 2 * hm) - 1, i == active ? MSG_BOX_COLOUR : MSG_BOX_TEXT, + i == active ? MSG_BOX_TEXT : MSG_BOX_COLOUR); + + } + + poll_timer(); /* msdos driver -> does nothing */ + key = do_poll_keyboard(); + if (!console_keyhandler(key)) { + switch (key) { + case KEY_ENTER: + rc = active; + strncpy(game.strings[MAX_STRINGS], desc[i], MAX_STRINGLEN); + goto press; + case KEY_ESCAPE: + rc = -1; + goto getout; +#ifdef USE_MOUSE + case BUTTON_LEFT: + break; +#endif + case KEY_DOWN: + active++; + active %= NUM_SLOTS; + break; + case KEY_UP: + active--; + if (active < 0) + active = NUM_SLOTS - 1; + break; + } + } + console_cycle(); + } + +press: + debugC(8, kDebugLevelMain | kDebugLevelInput, "Button pressed: %d", rc); + +getout: + close_window(); + return rc; +} + +int savegame_simple() { + char path[MAX_PATH]; + + sprintf(path, "%s/%05X_%s_%02d.sav", _savePath, game.crc, game.id, 0); + save_game(path, "Default savegame"); + + return err_OK; +} + +int savegame_dialog() { + char path[MAX_PATH]; + char *desc; + char *buttons[] = { "Do as I say!", "I regret", NULL }; + char dstr[200]; + int rc, slot = 0; + int hm, vm, hp, vp; /* box margins */ + int w; + + hm = 2; + vm = 3; + hp = hm * CHAR_COLS; + vp = vm * CHAR_LINES; + w = (40 - 2 * hm) - 1; + + sprintf(path, "%s/%05X_%s_%02d.sav", _savePath, game.crc, game.id, slot); + + draw_window(hp, vp, GFX_WIDTH - hp, GFX_HEIGHT - vp); + print_text("Select a slot in which you wish to save the game:", + 0, hm + 1, vm + 1, w, MSG_BOX_TEXT, MSG_BOX_COLOUR); + print_text("Press ENTER to select, ESC cancels", + 0, hm + 1, vm + 17, w, MSG_BOX_TEXT, MSG_BOX_COLOUR); + + slot = select_slot(); + if (slot < 0) /* ESC pressed */ + return err_OK; + + /* Get savegame description */ + draw_window(hp, vp + 5 * CHAR_LINES, GFX_WIDTH - hp, + GFX_HEIGHT - vp - 9 * CHAR_LINES); + print_text("Enter a description for this game:", + 0, hm + 1, vm + 6, w, MSG_BOX_TEXT, MSG_BOX_COLOUR); + draw_rectangle(3 * CHAR_COLS, 11 * CHAR_LINES - 1, + 37 * CHAR_COLS, 12 * CHAR_LINES, MSG_BOX_TEXT); + flush_block(3 * CHAR_COLS, 11 * CHAR_LINES - 1, + 37 * CHAR_COLS, 12 * CHAR_LINES); + + get_string(2, 11, 33, MAX_STRINGS); + print_character(3, 11, game.cursor_char, MSG_BOX_COLOUR, MSG_BOX_TEXT); + do { + main_cycle(); + } while (game.input_mode == INPUT_GETSTRING); + close_window(); + + desc = game.strings[MAX_STRINGS]; + sprintf(dstr, "Are you sure you want to save the game " + "described as:\n\n%s\n\nin slot %d?\n\n\n", desc, slot); + + rc = selection_box(dstr, buttons); + + if (rc != 0) { + message_box("Game NOT saved."); + return err_OK; + } + + sprintf(path, "%s/%05X_%s_%02d.sav", _savePath, game.crc, game.id, slot); + debugC(8, kDebugLevelMain | kDebugLevelResources, "file is [%s]", path); + + save_game(path, desc); + + message_box("Game saved."); + + return err_OK; +} + +int loadgame_simple() { + char path[MAX_PATH]; + int rc = 0; + + sprintf(path, "%s/%05X_%s_%02d.sav", _savePath, game.crc, game.id, 0); + + erase_both(); + stop_sound(); + close_window(); + + if ((rc = load_game(path)) == err_OK) { + message_box("Game restored."); + game.exit_all_logics = 1; + menu_enable_all(); + } else { + message_box("Error restoring game."); + } + + return rc; +} + +int loadgame_dialog() { + char path[MAX_PATH]; + int rc, slot = 0; + int hm, vm, hp, vp; /* box margins */ + int w; + + hm = 2; + vm = 3; + hp = hm * CHAR_COLS; + vp = vm * CHAR_LINES; + w = (40 - 2 * hm) - 1; + + sprintf(path, "%s/%05X_%s_%02d.sav", _savePath, game.crc, game.id, slot); + + erase_both(); + stop_sound(); + + draw_window(hp, vp, GFX_WIDTH - hp, GFX_HEIGHT - vp); + print_text("Select a game which you wish to\nrestore:", + 0, hm + 1, vm + 1, w, MSG_BOX_TEXT, MSG_BOX_COLOUR); + print_text("Press ENTER to select, ESC cancels", + 0, hm + 1, vm + 17, w, MSG_BOX_TEXT, MSG_BOX_COLOUR); + + slot = select_slot(); + + if (slot < 0) { + message_box("Game NOT restored."); + return err_OK; + } + + sprintf(path, "%s/%05X_%s_%02d.sav", _savePath, game.crc, game.id, slot); + + if ((rc = load_game(path)) == err_OK) { + message_box("Game restored."); + game.exit_all_logics = 1; + menu_enable_all(); + } else { + message_box("Error restoring game."); + } + + return rc; +} + +} // End of namespace Agi diff --git a/engines/agi/savegame.h b/engines/agi/savegame.h new file mode 100644 index 0000000000..ac62bb66e7 --- /dev/null +++ b/engines/agi/savegame.h @@ -0,0 +1,50 @@ +/* ScummVM - Scumm Interpreter + * Copyright (C) 2006 The ScummVM project + * + * Copyright (C) 1999-2001 Sarien Team + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + * $URL$ + * $Id$ + * + */ + +#ifndef __AGI_SAVEGAME_H +#define __AGI_SAVEGAME_H + +#include "agi/agi.h" + +namespace Agi { + +int savegame_dialog(void); +int loadgame_dialog(void); +int savegame_simple(void); +int loadgame_simple(void); + +/* Image stack support */ +#define ADD_PIC 1 +#define ADD_VIEW 2 + +void clear_image_stack(void); +void record_image_stack_call(uint8 type, int16 p1, int16 p2, int16 p3, + int16 p4, int16 p5, int16 p6, int16 p7); +void replay_image_stack_call(uint8 type, int16 p1, int16 p2, int16 p3, + int16 p4, int16 p5, int16 p6, int16 p7); +void release_image_stack(void); + +} // End of namespace Agi + +#endif diff --git a/engines/agi/sound.cpp b/engines/agi/sound.cpp new file mode 100644 index 0000000000..963e55c0b3 --- /dev/null +++ b/engines/agi/sound.cpp @@ -0,0 +1,772 @@ +/* ScummVM - Scumm Interpreter + * Copyright (C) 2006 The ScummVM project + * + * Copyright (C) 1999-2001 Sarien Team + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + * $URL$ + * $Id$ + * + */ + +#include "common/stdafx.h" + +#include "sound/mixer.h" + +#include "agi/agi.h" + +namespace Agi { + +#define USE_INTERPOLATION +#define USE_CHORUS + +/* TODO: add support for variable sampling rate in the output device + */ + +#ifdef USE_IIGS_SOUND + +/** + * AGI engine sound envelope structure. + */ +struct sound_envelope { + uint8 bp; + uint8 inc_hi; + uint8 inc_lo; +}; + +struct sound_wavelist { + uint8 top; + uint8 addr; + uint8 size; + uint8 mode; + uint8 rel_hi; + uint8 rel_lo; +}; + +struct sound_instrument { + struct sound_envelope env[8]; + uint8 relseg; + uint8 priority; + uint8 bendrange; + uint8 vibdepth; + uint8 vibspeed; + uint8 spare; + uint8 wac; + uint8 wbc; + struct sound_wavelist wal[8]; + struct sound_wavelist wbl[8]; +}; + +struct sound_iigs_sample { + uint8 type_lo; + uint8 type_hi; + uint8 srate_lo; + uint8 srate_hi; + uint16 unknown[2]; + uint8 size_lo; + uint8 size_hi; + uint16 unknown2[13]; +}; + +#if 0 +static struct sound_instrument *instruments; +static int num_instruments; +static uint8 *wave; +#endif + +#endif + +static int playing; +static struct channel_info chn[NUM_CHANNELS]; +static int endflag = -1; +static int playing_sound = -1; +static uint8 *song; +static uint8 env; + +struct sound_driver *snd; + +extern struct sound_driver sound_dummy; + +static void stop_note(int i); +static void play_note(int i, int freq, int vol); + +#ifdef USE_PCM_SOUND + +int16 *snd_buffer; +static int16 *waveform; + +static int16 waveform_ramp[WAVEFORM_SIZE] = { + 0, 8, 16, 24, 32, 40, 48, 56, + 64, 72, 80, 88, 96, 104, 112, 120, + 128, 136, 144, 152, 160, 168, 176, 184, + 192, 200, 208, 216, 224, 232, 240, 255, + 0, -248, -240, -232, -224, -216, -208, -200, + -192, -184, -176, -168, -160, -152, -144, -136, + -128, -120, -112, -104, -96, -88, -80, -72, + -64, -56, -48, -40, -32, -24, -16, -8 /* Ramp up */ +}; + +static int16 waveform_square[WAVEFORM_SIZE] = { + 255, 230, 220, 220, 220, 220, 220, 220, + 220, 220, 220, 220, 220, 220, 220, 220, + 220, 220, 220, 220, 220, 220, 220, 220, + 220, 220, 220, 220, 220, 220, 220, 110, + -255, -230, -220, -220, -220, -220, -220, -220, + -220, -220, -220, -220, -220, -220, -220, -220, + -220, -220, -220, -220, -220, -220, -220, -220, + -220, -220, -220, -110, 0, 0, 0, 0 /* Square */ +}; + +static int16 waveform_mac[WAVEFORM_SIZE] = { + 45, 110, 135, 161, 167, 173, 175, 176, + 156, 137, 123, 110, 91, 72, 35, -2, + -60, -118, -142, -165, -170, -176, -177, -179, + -177, -176, -164, -152, -117, -82, -17, 47, + 92, 137, 151, 166, 170, 173, 171, 169, + 151, 133, 116, 100, 72, 43, -7, -57, + -99, -141, -156, -170, -174, -177, -178, -179, + -175, -172, -165, -159, -137, -114, -67, -19 +}; + +#endif /* USE_PCM_SOUND */ + +#ifdef USE_IIGS_SOUND + +static uint16 period[] = { + 1024, 1085, 1149, 1218, 1290, 1367, + 1448, 1534, 1625, 1722, 1825, 1933 +}; + +static struct agi_note play_sample[] = { + {0xff, 0x7f, 0x18, 0x00, 0x7f}, + {0xff, 0xff, 0x00, 0x00, 0x00}, + {0xff, 0xff, 0x00, 0x00, 0x00}, + {0xff, 0xff, 0x00, 0x00, 0x00} +}; + +static int note_to_period(int note) { + return 10 * (period[note % 12] >> (note / 12 - 3)); +} + +#endif /* USE_IIGS_SOUND */ + +void unload_sound(int resnum) { + if (game.dir_sound[resnum].flags & RES_LOADED) { + if (game.sounds[resnum].flags & SOUND_PLAYING) + /* FIXME: Stop playing */ + ; + + /* Release RAW data for sound */ + free(game.sounds[resnum].rdata); + game.sounds[resnum].rdata = NULL; + game.dir_sound[resnum].flags &= ~RES_LOADED; + } +} + +void decode_sound(int resnum) { +#ifdef USE_IIGS_SOUND + int type, size; + int16 *buf; + uint8 *src; + struct sound_iigs_sample *smp; + + debugC(3, kDebugLevelSound, "(%d)", resnum); + type = READ_LE_UINT16(game.sounds[resnum].rdata); + + if (type == AGI_SOUND_SAMPLE) { + /* Convert sample data to 16 bit signed format + */ + smp = (struct sound_iigs_sample *)game.sounds[resnum].rdata; + size = ((int)smp->size_hi << 8) + smp->size_lo; + src = (uint8 *) game.sounds[resnum].rdata; + buf = (int16 *) calloc(1, 54 + (size << 1) + 100); /* FIXME */ + memcpy(buf, src, 54); + for (; size--; buf[size + 54] = ((int16) src[size + 54] - 0x80) << 4); /* FIXME */ + game.sounds[resnum].rdata = (uint8 *) buf; + free(src); + } +#endif /* USE_IIGS_SOUND */ +} + +void start_sound(int resnum, int flag) { + int i, type; +#ifdef USE_IIGS_SOUND + struct sound_iigs_sample *smp; +#endif + + if (game.sounds[resnum].flags & SOUND_PLAYING) + return; + + stop_sound(); + + if (game.sounds[resnum].rdata == NULL) + return; + + type = READ_LE_UINT16(game.sounds[resnum].rdata); + + if (type != AGI_SOUND_SAMPLE && type != AGI_SOUND_MIDI && type != AGI_SOUND_4CHN) + return; + + game.sounds[resnum].flags |= SOUND_PLAYING; + game.sounds[resnum].type = type; + playing_sound = resnum; + song = (uint8 *) game.sounds[resnum].rdata; + + switch (type) { +#ifdef USE_IIGS_SOUND + case AGI_SOUND_SAMPLE: + debugC(3, kDebugLevelSound, "IIGS sample"); + smp = (struct sound_iigs_sample *)game.sounds[resnum].rdata; + for (i = 0; i < NUM_CHANNELS; i++) { + chn[i].type = type; + chn[i].flags = 0; + chn[i].ins = (int16 *) & game.sounds[resnum].rdata[54]; + chn[i].size = ((int)smp->size_hi << 8) + smp->size_lo; + chn[i].ptr = &play_sample[i]; + chn[i].timer = 0; + chn[i].vol = 0; + chn[i].end = 0; + } + break; + case AGI_SOUND_MIDI: + debugC(3, kDebugLevelSound, "IIGS MIDI sequence"); + + for (i = 0; i < NUM_CHANNELS; i++) { + chn[i].type = type; + chn[i].flags = AGI_SOUND_LOOP | AGI_SOUND_ENVELOPE; + chn[i].ins = waveform; + chn[i].size = WAVEFORM_SIZE; + chn[i].vol = 0; + chn[i].end = 0; + } + + chn[0].timer = *(song + 2); + chn[0].ptr = (struct agi_note *)(song + 3); + break; +#endif + case AGI_SOUND_4CHN: + /* Initialize channel info */ + for (i = 0; i < NUM_CHANNELS; i++) { + chn[i].type = type; + chn[i].flags = AGI_SOUND_LOOP; + if (env) { + chn[i].flags |= AGI_SOUND_ENVELOPE; + chn[i].adsr = AGI_SOUND_ENV_ATTACK; + } +#ifdef USE_PCM_SOUND + chn[i].ins = waveform; + chn[i].size = WAVEFORM_SIZE; +#endif + chn[i].ptr = (struct agi_note *)(song + (song[i << 1] | (song[(i << 1) + 1] << 8))); + chn[i].timer = 0; + chn[i].vol = 0; + chn[i].end = 0; + } + break; + } + +#ifdef USE_PCM_SOUND + memset(snd_buffer, 0, BUFFER_SIZE << 1); +#endif + endflag = flag; + + /* Nat Budin reports that the flag should be reset when sound starts + */ + setflag(endflag, false); + + /* FIXME: should wait for sound time instead of setting the flag + * immediately + */ + if (opt.nosound) { + setflag(endflag, true); + stop_sound(); + } +} + +void stop_sound() { + int i; + + endflag = -1; + for (i = 0; i < NUM_CHANNELS; i++) + stop_note(i); + + if (playing_sound != -1) { + game.sounds[playing_sound].flags &= ~SOUND_PLAYING; + playing_sound = -1; + } +} + +static int16 *buffer; + +int init_sound() { + int r = -1; + +#ifdef USE_PCM_SOUND + buffer = snd_buffer = (int16 *) calloc(2, BUFFER_SIZE); +#endif + + env = false; + +#ifdef USE_PCM_SOUND + switch (opt.soundemu) { + case SOUND_EMU_NONE: + waveform = waveform_ramp; + env = true; + break; + case SOUND_EMU_AMIGA: + case SOUND_EMU_PC: + waveform = waveform_square; + break; + case SOUND_EMU_MAC: + waveform = waveform_mac; + break; + } +#endif + + report("Initializing sound:\n"); + + report("sound: envelopes "); + if (env) { + report("enabled (decay=%d, sustain=%d)\n", ENV_DECAY, ENV_SUSTAIN); + } else { + report("disabled\n"); + } + +#ifdef USE_IIGS_SOUND + /*load_instruments ("demo.sys"); */ +#endif + + return r; +} + +void deinit_sound(void) { + debugC(3, kDebugLevelSound, "()"); + if (snd) + snd->deinit(); +#ifdef USE_PCM_SOUND + free(snd_buffer); +#endif +} + +static void stop_note(int i) { + chn[i].adsr = AGI_SOUND_ENV_RELEASE; + +#ifdef USE_CHORUS + /* Stop chorus ;) */ + if (chn[i].type == AGI_SOUND_4CHN && + opt.soundemu == SOUND_EMU_NONE && i < 3) { + stop_note(i + 4); + } +#endif + +#ifdef __TURBOC__ + if (i == 0) + nosound(); +#endif +} + +static void play_note(int i, int freq, int vol) { + if (!getflag(F_sound_on)) + vol = 0; + else if (vol && opt.soundemu == SOUND_EMU_PC) + vol = 160; + +#ifdef USE_PCM_SOUND + chn[i].phase = 0; +#endif + + chn[i].freq = freq; + chn[i].vol = vol; + chn[i].env = 0x10000; + chn[i].adsr = AGI_SOUND_ENV_ATTACK; + +#ifdef USE_CHORUS + /* Add chorus ;) */ + if (chn[i].type == AGI_SOUND_4CHN && + opt.soundemu == SOUND_EMU_NONE && i < 3) { + int newfreq = freq * 1007 / 1000; + if (freq == newfreq) + newfreq++; + play_note(i + 4, newfreq, vol * 2 / 3); + } +#endif + +#ifdef __TURBOC__ + if (i == 0) + sound(freq); +#endif +} + +#ifdef USE_IIGS_SOUND + +void play_midi_sound() { + uint8 *p; + uint8 parm1, parm2; + static uint8 cmd, ch; + + playing = 1; + + if (chn[0].timer > 0) { + chn[0].timer -= 2; + return; + } + + p = (uint8 *) chn[0].ptr; + + if (*p & 0x80) { + cmd = *p++; + ch = cmd & 0x0f; + cmd >>= 4; + } + + switch (cmd) { + case 0x08: + parm1 = *p++; + parm2 = *p++; + if (ch < NUM_CHANNELS) + stop_note(ch); + break; + case 0x09: + parm1 = *p++; + parm2 = *p++; + if (ch < NUM_CHANNELS) + play_note(ch, note_to_period(parm1), 127); + break; + case 0x0b: + parm1 = *p++; + parm2 = *p++; + debugC(3, kDebugLevelSound, "controller %02x, ch %02x, val %02x", parm1, ch, parm2); + break; + case 0x0c: + parm1 = *p++; +#if 0 + if (ch < NUM_CHANNELS) { + chn[ch].ins = (uint16 *) & wave[waveaddr[parm1]]; + chn[ch].size = wavesize[parm1]; + } + debugC(3, kDebugLevelSound, "set patch %02x (%d,%d), ch %02x", + parm1, waveaddr[parm1], wavesize[parm1], ch); +#endif + break; + } + + chn[0].timer = *p++; + chn[0].ptr = (struct agi_note *)p; + + if (*p >= 0xfc) { + debugC(3, kDebugLevelSound, "end of sequence"); + playing = 0; + return; + } +} + +void play_sample_sound() { + play_note(0, 11025 * 10, 200); + playing = 1; +} + +#endif /* USE_IIGS_SOUND */ + +void play_agi_sound() { + int i, freq; + + for (playing = i = 0; i < (opt.soundemu == SOUND_EMU_PC ? 1 : 4); i++) { + playing |= !chn[i].end; + + if (chn[i].end) + continue; + + if ((--chn[i].timer) <= 0) { + stop_note(i); + freq = ((chn[i].ptr->frq_0 & 0x3f) << 4) | (int)(chn[i].ptr->frq_1 & 0x0f); + + if (freq) { + uint8 v = chn[i].ptr->vol & 0x0f; + play_note(i, freq * 10, v == 0xf ? 0 : 0xff - (v << 1)); + } + + chn[i].timer = ((int)chn[i].ptr->dur_hi << 8) | chn[i].ptr->dur_lo; + + if (chn[i].timer == 0xffff) { + chn[i].end = 1; + chn[i].vol = 0; + chn[i].env = 0; +#ifdef USE_CHORUS + /* chorus */ + if (chn[i].type == AGI_SOUND_4CHN && opt.soundemu == SOUND_EMU_NONE && i < 3) { + chn[i + 4].vol = 0; + chn[i + 4].env = 0; + } +#endif + } + chn[i].ptr++; + } + } +} + +void play_sound() { + int i; + + if (endflag == -1) + return; + +#ifdef USE_IIGS_SOUND + if (chn[0].type == AGI_SOUND_MIDI) { + /* play_midi_sound (); */ + playing = 0; + } else if (chn[0].type == AGI_SOUND_SAMPLE) { + play_sample_sound(); + } else +#endif + play_agi_sound(); + + if (!playing) { + for (i = 0; i < NUM_CHANNELS; chn[i++].vol = 0); + + if (endflag != -1) + setflag(endflag, true); + + if (playing_sound != -1) + game.sounds[playing_sound].flags &= ~SOUND_PLAYING; + playing_sound = -1; + endflag = -1; + } +} + +#ifdef USE_PCM_SOUND + +uint32 mix_sound(void) { + register int i, p; + int16 *src; + int c, b, m; + + memset(snd_buffer, 0, BUFFER_SIZE << 1); + + for (c = 0; c < NUM_CHANNELS; c++) { + if (!chn[c].vol) + continue; + + m = chn[c].flags & AGI_SOUND_ENVELOPE ? + chn[c].vol * chn[c].env >> 16 : chn[c].vol; + + if (chn[c].type != AGI_SOUND_4CHN || c != 3) { + src = chn[c].ins; + + p = chn[c].phase; + for (i = 0; i < BUFFER_SIZE; i++) { + b = src[p >> 8]; +#ifdef USE_INTERPOLATION + b += ((src[((p >> 8) + 1) % chn[c].size] - src[p >> 8]) * (p & 0xff)) >> 8; +#endif + snd_buffer[i] += (b * m) >> 4; + + p += (uint32) 118600 *4 / chn[c].freq; + + /* FIXME */ + if (chn[c].flags & AGI_SOUND_LOOP) { + p %= chn[c].size << 8; + } else { + if (p >= chn[c].size << 8) { + p = chn[c].vol = 0; + chn[c].end = 1; + break; + } + } + + } + chn[c].phase = p; + } else { + /* Add white noise */ + for (i = 0; i < BUFFER_SIZE; i++) { + b = rnd->getRandomNumber(255) - 128; + snd_buffer[i] += (b * m) >> 4; + } + } + + switch (chn[c].adsr) { + case AGI_SOUND_ENV_ATTACK: + /* not implemented */ + chn[c].adsr = AGI_SOUND_ENV_DECAY; + break; + case AGI_SOUND_ENV_DECAY: + if (chn[c].env > chn[c].vol * ENV_SUSTAIN + ENV_DECAY) { + chn[c].env -= ENV_DECAY; + } else { + chn[c].env = chn[c].vol * ENV_SUSTAIN; + chn[c].adsr = AGI_SOUND_ENV_SUSTAIN; + } + break; + case AGI_SOUND_ENV_SUSTAIN: + break; + case AGI_SOUND_ENV_RELEASE: + if (chn[c].env >= ENV_RELEASE) { + chn[c].env -= ENV_RELEASE; + } else { + chn[c].env = 0; + } + } + } + + return BUFFER_SIZE; +} + +#ifdef USE_IIGS_SOUND + +#if 0 +int load_instruments(char *fname) { + Common::File fp; + int i, j, k; + struct sound_instrument ai; + int num_wav; + char *path; + + path = "sierrast"; + + if (!fp.open(path)) + return err_BadFileOpen; + report("Loading samples: %s\n", path); + + if ((wave = malloc(0x10000 * 2)) == NULL) + return err_NotEnoughMemory; + + fp.read(wave, 0x10000); + fp.close(); + for (i = 0x10000; i--;) { + ((int16 *) wave)[i] = 2 * ((int16) wave[i] - 128); + } + + fp = fopen("bla", "w"); + fwrite(wave, 2, 0x10000, fp); + fclose(fp); + + report("Loading instruments: %s\n", path); + + if ((fp = fopen(path, "rb")) == NULL) + return err_BadFileOpen; + + fseek(fp, 0x8469, SEEK_SET); + + for (num_wav = j = 0; j < 40; j++) { + fread(&ai, 1, 32, fp); + + if (ai.env[0].bp > 0x7f) + break; + +#if 0 + printf("Instrument %d loaded ----------------\n", j); + printf("Envelope:\n"); + for (i = 0; i < 8; i++) + printf("[seg %d]: BP %02x Inc %04x\n", i, ai.env[i].bp, + ((int)ai.env[i].inc_hi << 8) | ai.env[i].inc_lo); + printf("rel seg: %d, pri inc: %d, bend range: %d, vib dep: %d, " + "vib spd: %d\n", ai.relseg, ai.priority, + ai.bendrange, ai.vibdepth, ai.vibspeed); + printf("A wave count: %d, B wave count: %d\n", ai.wac, ai.wbc); +#endif + + for (k = 0; k < ai.wac; k++, num_wav++) { + fread(&ai.wal[k], 1, 6, fp); +#if 0 + printf("[A %d of %d] top: %02x, wave address: %02x, " + "size: %02x, mode: %02x, relPitch: %04x\n", k + 1, + ai.wac, ai.wal[k].top, ai.wal[k].addr, ai.wal[k].size, + ai.wal[k].mode, ((int)ai.wal[k].rel_hi << 8) | ai.wal[k].rel_lo); +#endif + } + + for (k = 0; k < ai.wbc; k++, num_wav++) { + fread(&ai.wbl[k], 1, 6, fp); +#if 0 + printf("[B %d of %d] top: %02x, wave address: %02x, " + "size: %02x, mode: %02x, relPitch: %04x\n", k + 1, ai.wbc, + ai.wbl[k].top, ai.wbl[k].addr, ai.wbl[k].size, + ai.wbl[k].mode, ((int)ai.wbl[k].rel_hi << 8) | ai.wbl[k].rel_lo); +#endif + } + waveaddr[j] = 256 * ai.wal[0].addr; + wavesize[j] = 256 * (1 << ((ai.wal[0].size) & 0x07)); +#if 1 + printf("%d addr = %d\n", j, waveaddr[j]); + printf(" size = %d\n", wavesize[j]); +#endif + } + + num_instruments = j; + printf("%d Ensoniq 5503 instruments loaded. (%d waveforms)\n", num_instruments, num_wav); + + fclose(fp); + + return err_OK; +} + +void unload_instruments() { + free(instruments); +} +#endif + +#endif /* USE_IIGS_SOUND */ + +static void fill_audio(void *udata, int16 * stream, uint len) { + int16 *origData = stream; + len <<= 2; + uint origLen = len; + + uint32 p = 0; + static uint32 n = 0, s = 0; + + debugC(5, kDebugLevelSound, "(%p, %p, %d)", udata, stream, len); + memcpy(stream, (uint8 *) buffer + s, p = n); + for (n = 0, len -= p; n < len; p += n, len -= n) { + play_sound(); + n = mix_sound() << 1; + if (len < n) { + memcpy((uint8 *) stream + p, buffer, len); + s = len; + n -= s; + return; + } else { + memcpy((uint8 *) stream + p, buffer, n); + } + } + play_sound(); + n = mix_sound() << 1; + memcpy((uint8 *) stream + p, buffer, s = len); + n -= s; +} + +AGIMusic::AGIMusic(Audio::Mixer *pMixer) { + _mixer = pMixer; + _sampleRate = pMixer->getOutputRate(); + _mixer->setupPremix(this); +} + +void AGIMusic::premixerCall(int16 *data, uint len) { + Agi::fill_audio(NULL, data, len); +} + +void AGIMusic::setVolume(uint8 volume) { + // TODO +} + +AGIMusic::~AGIMusic(void) { + _mixer->setupPremix(NULL); +} + +AGIMusic *g_agi_music; + +#endif /* USE_PCM_SOUND */ + +} // End of namespace Agi diff --git a/engines/agi/sound.h b/engines/agi/sound.h new file mode 100644 index 0000000000..5af9fe1a5f --- /dev/null +++ b/engines/agi/sound.h @@ -0,0 +1,167 @@ +/* ScummVM - Scumm Interpreter + * Copyright (C) 2006 The ScummVM project + * + * Copyright (C) 1999-2001 Sarien Team + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + * $URL$ + * $Id$ + * + */ + +#ifndef __AGI_SOUND_H +#define __AGI_SOUND_H + +#include "agi/agi.h" + +namespace Agi { + +#define BUFFER_SIZE 410 + +#define SOUND_EMU_NONE 0 +#define SOUND_EMU_PC 1 +#define SOUND_EMU_TANDY 2 +#define SOUND_EMU_MAC 3 +#define SOUND_EMU_AMIGA 4 + +#define SOUND_PLAYING 0x01 +#define WAVEFORM_SIZE 64 +#define ENV_ATTACK 10000 /**< envelope attack rate */ +#define ENV_DECAY 1000 /**< envelope decay rate */ +#define ENV_SUSTAIN 100 /**< envelope sustain level */ +#define ENV_RELEASE 7500 /**< envelope release rate */ +#define NUM_CHANNELS 7 /**< number of sound channels */ + +/** + * AGI engine sound driver structure. + */ +struct sound_driver { + char *description; + int (*init) (int16 * buffer); + void (*deinit) (void); +}; + +/** + * AGI sound resource structure. + */ +struct agi_sound { + uint32 flen; /**< size of raw data */ + uint8 *rdata; /**< raw sound data */ + uint8 flags; /**< sound flags */ + uint16 type; /**< sound resource type */ +}; + +/** + * AGI sound note structure. + */ +struct agi_note { + uint8 dur_lo; /**< LSB of note duration */ + uint8 dur_hi; /**< MSB of note duration */ + uint8 frq_0; /**< LSB of note frequency */ + uint8 frq_1; /**< MSB of note frequency */ + uint8 vol; /**< note volume */ +}; + +/** + * AGI engine sound channel structure. + */ +struct channel_info { +#define AGI_SOUND_SAMPLE 0x0001 +#define AGI_SOUND_MIDI 0x0002 +#define AGI_SOUND_4CHN 0x0008 + uint32 type; + struct agi_note *ptr; +#ifdef USE_PCM_SOUND + int16 *ins; + int32 size; + uint32 phase; +#endif +#define AGI_SOUND_LOOP 0x0001 +#define AGI_SOUND_ENVELOPE 0x0002 + uint32 flags; +#define AGI_SOUND_ENV_ATTACK 3 +#define AGI_SOUND_ENV_DECAY 2 +#define AGI_SOUND_ENV_SUSTAIN 1 +#define AGI_SOUND_ENV_RELEASE 0 + uint32 adsr; + int32 timer; + uint32 end; + uint32 freq; + uint32 vol; + uint32 env; +}; + +void decode_sound(int); +void unload_sound(int); +void play_sound(void); +int init_sound(void); +void deinit_sound(void); +void start_sound(int, int); +void stop_sound(void); +uint32 mix_sound(void); +void __init_sound(void); +int load_instruments(char *fname); + +extern struct sound_driver *snd; + +#endif /* __AGI_SOUND_H */ + +#ifdef USE_PCM_SOUND + +} // End of namespace Agi + +#include "sound/audiostream.h" + +namespace Audio { +class Mixer; +} // End of namespace Audio + +namespace Agi { + +class AGIMusic : public Audio::AudioStream { +public: + AGIMusic(Audio::Mixer * pMixer); + ~AGIMusic(void); + virtual void setVolume(uint8 volume); + + // AudioStream API + int readBuffer(int16 * buffer, const int numSamples) { + premixerCall(buffer, numSamples / 2); + return numSamples; + } + + bool isStereo() const { + return false; + } + + bool endOfData() const { + return false; + } + + int getRate() const { + return _sampleRate; + } + +private: + Audio::Mixer * _mixer; + uint32 _sampleRate; + + void premixerCall(int16 * buf, uint len); +}; + +} // End of namespace Agi + +#endif diff --git a/engines/agi/sprite.cpp b/engines/agi/sprite.cpp new file mode 100644 index 0000000000..3a3ba7354e --- /dev/null +++ b/engines/agi/sprite.cpp @@ -0,0 +1,868 @@ +/* ScummVM - Scumm Interpreter + * Copyright (C) 2006 The ScummVM project + * + * Copyright (C) 1999-2003 Sarien Team + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + * $URL$ + * $Id$ + * + */ + +#include "agi/agi.h" +#include "agi/list.h" +#include "agi/sprite.h" +#include "agi/graphics.h" +#include "agi/text.h" +#include "agi/savegame.h" + +namespace Agi { + +/** + * Sprite structure. + * This structure holds information on visible and priority data of + * a rectangular area of the AGI screen. Sprites are chained in two + * circular lists, one for updating and other for non-updating sprites. + */ +struct sprite { + struct list_head list; + struct vt_entry *v; /**< pointer to view table entry */ + int16 x_pos; /**< x coordinate of the sprite */ + int16 y_pos; /**< y coordinate of the sprite */ + int16 x_size; /**< width of the sprite */ + int16 y_size; /**< height of the sprite */ + uint8 *buffer; /**< buffer to store background data */ +#ifdef USE_HIRES + uint8 *hires; /**< buffer for hi-res background */ +#endif +}; + +/* + * Sprite pool replaces dynamic allocation + */ +#undef ALLOC_DEBUG + +#ifdef USE_HIRES +#define POOL_SIZE 68000 /* Gold Rush mine room needs > 50000 */ + /* Speeder bike challenge needs > 67000 */ +#else +#define POOL_SIZE 25000 +#endif +static uint8 *sprite_pool; +static uint8 *pool_top; + +static void *pool_alloc(int size) { + uint8 *x; + + /* Adjust size to 32-bit boundary to prevent data misalignment + * errors. + */ + size = (size + 3) & ~3; + + x = pool_top; + pool_top += size; + + if (pool_top >= (uint8 *)sprite_pool + POOL_SIZE) { + debugC(1, kDebugLevelMain | kDebugLevelResources, "not enough memory"); + pool_top = x; + return NULL; + } + + return x; +} + +static void pool_release(void *s) { + pool_top = (uint8 *)s; +} + +/* + * Blitter functions + */ + +/* Blit one pixel considering the priorities */ + +static void blit_pixel(uint8 *p, uint8 *end, uint8 col, int spr, int width, int *hidden) { + int epr = 0, pr = 0; /* effective and real priorities */ + + /* CM: priority 15 overrides control lines and is ignored when + * tracking effective priority. This tweak is needed to fix + * bug #451768, and should not affect Sierra games because + * sprites shouldn't have priority 15 (like the AGI Mouse + * demo "mouse pointer") + * + * Update: this solution breaks other games, and can't be used. + */ + + if (p >= end) + return; + + /* Check if we're on a control line */ + if ((pr = *p & 0xf0) < 0x30) { + uint8 *p1; + /* Yes, get effective priority going down */ + for (p1 = p; p1 < end && (epr = *p1 & 0xf0) < 0x30; + p1 += width); + if (p1 >= end) + epr = 0x40; + } else { + epr = pr; + } + + if (spr >= epr) { + /* Keep control line information visible, but put our + * priority over water (0x30) surface + */ + *p = (pr < 0x30 ? pr : spr) | col; + *hidden = false; + + /* Except if our priority is 15, which should never happen + * (fixes bug #451768) + * + * Update: breaks other games, can't be used + * + * if (spr == 0xf0) + * *p = spr | col; + */ + } +} + +#ifdef USE_HIRES + +#define X_FACT 2 /* Horizontal hires factor */ + +static int blit_hires_cel(int x, int y, int spr, struct view_cel *c) { + uint8 *q = NULL; + uint8 *h0, *h, *end; + int i, j, t, m, col; + int hidden = true; + + q = c->data; + t = c->transparency; + m = c->mirror; + spr <<= 4; + h0 = &game.hires[(x + y * _WIDTH + m * (c->width - 1)) * X_FACT]; + + end = game.hires + _WIDTH * X_FACT * _HEIGHT; + + for (i = 0; i < c->height; i++) { + h = h0; + while (*q) { + col = (*q & 0xf0) >> 4; + for (j = *q & 0x0f; j; j--, h += X_FACT * (1 - 2 * m)) { + if (col != t) { + blit_pixel(h, end, col, spr, _WIDTH * X_FACT, &hidden); + blit_pixel(h + 1, end, col, spr, _WIDTH * X_FACT, &hidden); + } + } + q++; + } + h0 += _WIDTH * X_FACT; + q++; + } + return hidden; +} + +#endif + +static int blit_cel(int x, int y, int spr, struct view_cel *c) { + uint8 *p0, *p, *q = NULL, *end; + int i, j, t, m, col; + int hidden = true; + + /* Fixes bug #477841 (crash in PQ1 map C4 when y == -2) */ + if (y < 0) + y = 0; + if (x < 0) + x = 0; + if (y >= _HEIGHT) + y = _HEIGHT - 1; + if (x >= _WIDTH) + x = _WIDTH - 1; + +#ifdef USE_HIRES + if (opt.hires) + blit_hires_cel(x, y, spr, c); +#endif + + q = c->data; + t = c->transparency; + m = c->mirror; + spr <<= 4; + p0 = &game.sbuf[x + y * _WIDTH + m * (c->width - 1)]; + + end = game.sbuf + _WIDTH * _HEIGHT; + + for (i = 0; i < c->height; i++) { + p = p0; + while (*q) { + col = (*q & 0xf0) >> 4; + for (j = *q & 0x0f; j; j--, p += 1 - 2 * m) { + if (col != t) { + blit_pixel(p, end, col, spr, _WIDTH, &hidden); + } + } + q++; + } + p0 += _WIDTH; + q++; + } + + return hidden; +} + +static void objs_savearea(struct sprite *s) { + int y; + int16 x_pos = s->x_pos, y_pos = s->y_pos; + int16 x_size = s->x_size, y_size = s->y_size; + uint8 *p0, *q; +#ifdef USE_HIRES + uint8 *h0, *k; +#endif + + if (x_pos + x_size > _WIDTH) + x_size = _WIDTH - x_pos; + + if (x_pos < 0) { + x_size += x_pos; + x_pos = 0; + } + + if (y_pos + y_size > _HEIGHT) + y_size = _HEIGHT - y_pos; + + if (y_pos < 0) { + y_size += y_pos; + y_pos = 0; + } + + if (x_size <= 0 || y_size <= 0) + return; + + p0 = &game.sbuf[x_pos + y_pos * _WIDTH]; + q = s->buffer; +#ifdef USE_HIRES + h0 = &game.hires[(x_pos + y_pos * _WIDTH) * 2]; + k = s->hires; +#endif + for (y = 0; y < y_size; y++) { + memcpy(q, p0, x_size); + q += x_size; + p0 += _WIDTH; +#ifdef USE_HIRES + memcpy(k, h0, x_size * 2); + k += x_size * 2; + h0 += _WIDTH * 2; +#endif + } +} + +static void objs_restorearea(struct sprite *s) { + int y, offset; + int16 x_pos = s->x_pos, y_pos = s->y_pos; + int16 x_size = s->x_size, y_size = s->y_size; + uint8 *p0, *q; +#ifdef USE_HIRES + uint8 *h0, *k; +#endif + + if (x_pos + x_size > _WIDTH) + x_size = _WIDTH - x_pos; + + if (x_pos < 0) { + x_size += x_pos; + x_pos = 0; + } + + if (y_pos + y_size > _HEIGHT) + y_size = _HEIGHT - y_pos; + + if (y_pos < 0) { + y_size += y_pos; + y_pos = 0; + } + + if (x_size <= 0 || y_size <= 0) + return; + + p0 = &game.sbuf[x_pos + y_pos * _WIDTH]; + q = s->buffer; +#ifdef USE_HIRES + h0 = &game.hires[(x_pos + y_pos * _WIDTH) * 2]; + k = s->hires; +#endif + offset = game.line_min_print * CHAR_LINES; + for (y = 0; y < y_size; y++) { + memcpy(p0, q, x_size); + put_pixels_a(x_pos, y_pos + y + offset, x_size, p0); + q += x_size; + p0 += _WIDTH; +#ifdef USE_HIRES + memcpy(h0, k, x_size * 2); + if (opt.hires) { + put_pixels_hires(x_pos * 2, y_pos + y + offset, x_size * 2, h0); + } + k += x_size * 2; + h0 += _WIDTH * 2; +#endif + } +} + +/* + * Sprite management functions + */ + +static LIST_HEAD(spr_upd_head); +static LIST_HEAD(spr_nonupd_head); + +/** + * Condition to determine whether a sprite will be in the 'updating' list. + */ +static int test_updating(struct vt_entry *v) { + /* Sanity check (see bug #779302) */ + if (~game.dir_view[v->current_view].flags & RES_LOADED) + return 0; + + return (v->flags & (ANIMATED | UPDATE | DRAWN)) == (ANIMATED | UPDATE | DRAWN); +} + +/** + * Condition to determine whether a sprite will be in the 'non-updating' list. + */ +static int test_not_updating(struct vt_entry *v) { + /* Sanity check (see bug #779302) */ + if (~game.dir_view[v->current_view].flags & RES_LOADED) + return 0; + + return (v->flags & (ANIMATED | UPDATE | DRAWN)) == (ANIMATED | DRAWN); +} + +/** + * Convert sprite priority to y value. + */ +static INLINE int prio_to_y(int p) { + int i; + + if (p == 0) + return -1; + + for (i = 167; i >= 0; i--) { + if (game.pri_table[i] < p) + return i; + } + + return -1; /* (p - 5) * 12 + 48; */ +} + +/** + * Create and initialize a new sprite structure. + */ +static struct sprite *new_sprite(struct vt_entry *v) { + struct sprite *s; + + s = (struct sprite *)pool_alloc(sizeof(struct sprite)); + if (s == NULL) + return NULL; + + s->v = v; /* link sprite to associated view table entry */ + s->x_pos = v->x_pos; + s->y_pos = v->y_pos - v->y_size + 1; + s->x_size = v->x_size; + s->y_size = v->y_size; + s->buffer = (uint8 *) pool_alloc(s->x_size * s->y_size); +#ifdef USE_HIRES + s->hires = (uint8 *) pool_alloc(s->x_size * s->y_size * 2); +#endif + v->s = s; /* link view table entry to this sprite */ + + return s; +} + +/** + * Insert sprite in the specified sprite list. + */ +static void spr_addlist(struct list_head *head, struct vt_entry *v) { + struct sprite *s; + + s = new_sprite(v); + list_add_tail(&s->list, head); +} + +/** + * Sort sprites from lower y values to build a sprite list. + */ +static struct list_head *build_list(struct list_head *head, + int (*test) (struct vt_entry *)) { + int i, j, k; + struct vt_entry *v; + struct vt_entry *entry[0x100]; + int y_val[0x100]; + int min_y = 0xff, min_index = 0; + + /* fill the arrays with all sprites that satisfy the 'test' + * condition and their y values + */ + i = 0; + for (v = game.view_table; v < &game.view_table[MAX_VIEWTABLE]; v++) { + if (test(v)) { + entry[i] = v; + y_val[i] = v->flags & FIXED_PRIORITY ? prio_to_y(v->priority) : v->y_pos; + i++; + } + } + + /* now look for the smallest y value in the array and put that + * sprite in the list + */ + for (j = 0; j < i; j++) { + min_y = 0xff; + for (k = 0; k < i; k++) { + if (y_val[k] < min_y) { + min_index = k; + min_y = y_val[k]; + } + } + + y_val[min_index] = 0xff; + spr_addlist(head, entry[min_index]); + } + + return head; +} + +/** + * Build list of updating sprites. + */ +static struct list_head *build_upd_blitlist() { + return build_list(&spr_upd_head, test_updating); +} + +/** + * Build list of non-updating sprites. + */ +static struct list_head *build_nonupd_blitlist() { + return build_list(&spr_nonupd_head, test_not_updating); +} + +/** + * Clear the given sprite list. + */ +static void free_list(struct list_head *head) { + struct list_head *h; + struct sprite *s; + + list_for_each(h, head, prev) { + s = list_entry(h, struct sprite, list); + list_del(h); +#ifdef USE_HIRES + pool_release(s->hires); +#endif + pool_release(s->buffer); + pool_release(s); + } +} + +/** + * Copy sprites from the pic buffer to the screen buffer, and check if + * sprites of the given list have moved. + */ +static void commit_sprites(struct list_head *head) { + struct list_head *h; + + list_for_each(h, head, next) { + struct sprite *s = list_entry(h, struct sprite, list); + int x1, y1, x2, y2, w, h; + + w = (s->v->cel_data->width > s->v->cel_data_2->width) ? + s->v->cel_data->width : s->v->cel_data_2->width; + + h = (s->v->cel_data->height > + s->v->cel_data_2->height) ? s->v->cel_data-> + height : s->v->cel_data_2->height; + + s->v->cel_data_2 = s->v->cel_data; + + if (s->v->x_pos < s->v->x_pos2) { + x1 = s->v->x_pos; + x2 = s->v->x_pos2 + w - 1; + } else { + x1 = s->v->x_pos2; + x2 = s->v->x_pos + w - 1; + } + + if (s->v->y_pos < s->v->y_pos2) { + y1 = s->v->y_pos - h + 1; + y2 = s->v->y_pos2; + } else { + y1 = s->v->y_pos2 - h + 1; + y2 = s->v->y_pos; + } + + commit_block(x1, y1, x2, y2); + + if (s->v->step_time_count != s->v->step_time) + continue; + + if (s->v->x_pos == s->v->x_pos2 && s->v->y_pos == s->v->y_pos2) { + s->v->flags |= DIDNT_MOVE; + continue; + } + + s->v->x_pos2 = s->v->x_pos; + s->v->y_pos2 = s->v->y_pos; + s->v->flags &= ~DIDNT_MOVE; + } + +#ifdef USE_CONSOLE + if (debug_.statusline) + write_status(); +#endif +} + +/** + * Erase all sprites in the given list. + */ +static void erase_sprites(struct list_head *head) { + struct list_head *h; + + list_for_each(h, head, prev) { + struct sprite *s = list_entry(h, struct sprite, list); + objs_restorearea(s); + } + + free_list(head); +} + +/** + * Blit all sprites in the given list. + */ +static void blit_sprites(struct list_head *head) { + struct list_head *h = NULL; + int hidden; + + list_for_each(h, head, next) { + struct sprite *s = list_entry(h, struct sprite, list); + objs_savearea(s); + debugC(8, kDebugLevelSprites, "s->v->entry = %d (prio %d)", s->v->entry, s->v->priority); + hidden = blit_cel(s->x_pos, s->y_pos, s->v->priority, s->v->cel_data); + if (s->v->entry == 0) { /* if ego, update f1 */ + setflag(F_ego_invisible, hidden); + } + } +} + +/* + * Public functions + */ + +void commit_upd_sprites() { + commit_sprites(&spr_upd_head); +} + +void commit_nonupd_sprites() { + commit_sprites(&spr_nonupd_head); +} + +/* check moves in both lists */ +void commit_both() { + commit_upd_sprites(); + commit_nonupd_sprites(); +} + +/** + * Erase updating sprites. + * This function follows the list of all updating sprites and restores + * the visible and priority data of their background buffers back to + * the AGI screen. + * + * @see erase_nonupd_sprites() + * @see erase_both() + */ +void erase_upd_sprites() { + erase_sprites(&spr_upd_head); +} + +/** + * Erase non-updating sprites. + * This function follows the list of all non-updating sprites and restores + * the visible and priority data of their background buffers back to + * the AGI screen. + * + * @see erase_upd_sprites() + * @see erase_both() + */ +void erase_nonupd_sprites() { + erase_sprites(&spr_nonupd_head); +} + +/** + * Erase all sprites. + * This function follows the lists of all updating and non-updating + * sprites and restores the visible and priority data of their background + * buffers back to the AGI screen. + * + * @see erase_upd_sprites() + * @see erase_nonupd_sprites() + */ +void erase_both() { + erase_upd_sprites(); + erase_nonupd_sprites(); +} + +/** + * Blit updating sprites. + * This function follows the list of all updating sprites and blits + * them on the AGI screen. + * + * @see blit_nonupd_sprites() + * @see blit_both() + */ +void blit_upd_sprites() { + debugC(7, kDebugLevelSprites, "blit updating"); + blit_sprites(build_upd_blitlist()); +} + +/** + * Blit non-updating sprites. + * This function follows the list of all non-updating sprites and blits + * them on the AGI screen. + * + * @see blit_upd_sprites() + * @see blit_both() + */ +void blit_nonupd_sprites() { + debugC(7, kDebugLevelSprites, "blit non-updating"); + blit_sprites(build_nonupd_blitlist()); +} + +/** + * Blit all sprites. + * This function follows the lists of all updating and non-updating + * sprites and blits them on the AGI screen. + * + * @see blit_upd_sprites() + * @see blit_nonupd_sprites() + */ +void blit_both() { + blit_nonupd_sprites(); + blit_upd_sprites(); +} + +/** + * Add view to picture. + * This function is used to implement the add.to.pic AGI command. It + * copies the specified cel from a view resource on the current picture. + * This cel is not a sprite, it can't be moved or removed. + * @param view number of view resource + * @param loop number of loop in the specified view resource + * @param cel number of cel in the specified loop + * @param x x coordinate to place the view + * @param y y coordinate to place the view + * @param pri priority to use + * @param mar if < 4, create a margin around the the base of the cel + */ +void add_to_pic(int view, int loop, int cel, int x, int y, int pri, int mar) { + struct view_cel *c = NULL; + int x1, y1, x2, y2, y3; + uint8 *p1, *p2; + + debugC(3, kDebugLevelSprites, "v=%d, l=%d, c=%d, x=%d, y=%d, p=%d, m=%d", view, loop, cel, x, y, pri, mar); + + record_image_stack_call(ADD_VIEW, view, loop, cel, x, y, pri, mar); + + /* + * Was hardcoded to 8, changed to pri_table[y] to fix Gold + * Rush (see bug #587558) + */ + if (pri == 0) + pri = game.pri_table[y]; + + c = &game.views[view].loop[loop].cel[cel]; + + x1 = x; + y1 = y - c->height + 1; + x2 = x + c->width - 1; + y2 = y; + + if (x1 < 0) { + x2 -= x1; + x1 = 0; + } + if (y1 < 0) { + y2 -= y1; + y1 = 0; + } + if (x2 >= _WIDTH) + x2 = _WIDTH - 1; + if (y2 >= _HEIGHT) + y2 = _HEIGHT - 1; + + erase_both(); + + debugC(4, kDebugLevelSprites, "blit_cel (%d, %d, %d, c)", x, y, pri); + blit_cel(x1, y1, pri, c); + + /* If margin is 0, 1, 2, or 3, the base of the cel is + * surrounded with a rectangle of the corresponding priority. + * If margin >= 4, this extra margin is not shown. + */ + if (mar < 4) { + /* add rectangle around object, don't clobber control + * info in priority data. The box extends to the end of + * its priority band! + * + * SQ1 needs +1 (see bug #810331) + */ + y3 = (y2 / 12) * 12 + 1; + + p1 = &game.sbuf[x1 + y3 * _WIDTH]; + p2 = &game.sbuf[x2 + y3 * _WIDTH]; + + for (y = y3; y <= y2; y++) { + if ((*p1 >> 4) >= 4) + *p1 = (mar << 4) | (*p1 & 0x0f); + if ((*p2 >> 4) >= 4) + *p2 = (mar << 4) | (*p2 & 0x0f); + p1 += _WIDTH; + p2 += _WIDTH; + } + + debugC(4, kDebugLevelSprites, "pri box: %d %d %d %d (%d)", x1, y3, x2, y2, mar); + p1 = &game.sbuf[x1 + y3 * _WIDTH]; + p2 = &game.sbuf[x1 + y2 * _WIDTH]; + for (x = x1; x <= x2; x++) { + if ((*p1 >> 4) >= 4) + *p1 = (mar << 4) | (*p1 & 0x0f); + if ((*p2 >> 4) >= 4) + *p2 = (mar << 4) | (*p2 & 0x0f); + p1++; + p2++; + } + } + + blit_both(); + + debugC(4, kDebugLevelSprites, "commit_block (%d, %d, %d, %d)", x1, y1, x2, y2); + commit_block(x1, y1, x2, y2); +} + +/** + * Show object and description + * This function shows an object from the player's inventory, displaying + * a message box with the object description. + * @param n Number of the object to show + */ +void show_obj(int n) { + struct view_cel *c; + struct sprite s; + int x1, y1, x2, y2; + + agi_load_resource(rVIEW, n); + if (!(c = &game.views[n].loop[0].cel[0])) + return; + + x1 = (_WIDTH - c->width) / 2; + y1 = 112; + x2 = x1 + c->width - 1; + y2 = y1 + c->height - 1; + + s.x_pos = x1; + s.y_pos = y1; + s.x_size = c->width; + s.y_size = c->height; + s.buffer = (uint8 *)malloc(s.x_size * s.y_size); +#ifdef USE_HIRES + s.hires = (uint8 *)malloc(s.x_size * s.y_size * 2); +#endif + + objs_savearea(&s); + blit_cel(x1, y1, s.x_size, c); + commit_block(x1, y1, x2, y2); + message_box(game.views[n].descr); + objs_restorearea(&s); + commit_block(x1, y1, x2, y2); + + free(s.buffer); + + /* Added to fix a memory leak --Vasyl */ +#ifdef USE_HIRES + free(s.hires); +#endif +} + +void commit_block(int x1, int y1, int x2, int y2) { + int i, w, offset; + uint8 *q; +#ifdef USE_HIRES + uint8 *h; +#endif + + if (!game.picture_shown) + return; + + /* Clipping */ + if (x1 < 0) + x1 = 0; + if (x2 < 0) + x2 = 0; + if (y1 < 0) + y1 = 0; + if (y2 < 0) + y2 = 0; + if (x1 >= _WIDTH) + x1 = _WIDTH - 1; + if (x2 >= _WIDTH) + x2 = _WIDTH - 1; + if (y1 >= _HEIGHT) + y1 = _HEIGHT - 1; + if (y2 >= _HEIGHT) + y2 = _HEIGHT - 1; + + debugC(7, kDebugLevelSprites, "%d, %d, %d, %d", x1, y1, x2, y2); + + w = x2 - x1 + 1; + q = &game.sbuf[x1 + _WIDTH * y1]; +#ifdef USE_HIRES + h = &game.hires[(x1 + _WIDTH * y1) * 2]; +#endif + offset = game.line_min_print * CHAR_LINES; + for (i = y1; i <= y2; i++) { + put_pixels_a(x1, i + offset, w, q); + q += _WIDTH; +#ifdef USE_HIRES + if (opt.hires) { + put_pixels_hires(x1 * 2, i + offset, w * 2, h); + } + h += _WIDTH * 2; +#endif + } + + flush_block_a(x1, y1 + offset, x2, y2 + offset); +} + +int init_sprites() { + if ((sprite_pool = (uint8 *)malloc(POOL_SIZE)) == NULL) + return err_NotEnoughMemory; + + pool_top = sprite_pool; + + return err_OK; +} + +void deinit_sprites() { + free(sprite_pool); +} + +} // End of namespace Agi diff --git a/engines/agi/sprite.h b/engines/agi/sprite.h new file mode 100644 index 0000000000..a3d0d8b871 --- /dev/null +++ b/engines/agi/sprite.h @@ -0,0 +1,47 @@ +/* ScummVM - Scumm Interpreter + * Copyright (C) 2006 The ScummVM project + * + * Copyright (C) 1999-2001 Sarien Team + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + * $URL$ + * $Id$ + * + */ + +#ifndef __AGI_SPRITE_H +#define __AGI_SPRITE_H + +namespace Agi { + +int init_sprites(void); +void deinit_sprites(void); +void erase_upd_sprites(void); +void erase_nonupd_sprites(void); +void erase_both(void); +void blit_upd_sprites(void); +void blit_nonupd_sprites(void); +void blit_both(void); +void commit_upd_sprites(void); +void commit_nonupd_sprites(void); +void commit_both(void); +void add_to_pic(int, int, int, int, int, int, int); +void show_obj(int); +void commit_block(int, int, int, int); + +} // End of namespace Agi + +#endif /* __AGI_SPRITE_H */ diff --git a/engines/agi/text.cpp b/engines/agi/text.cpp new file mode 100644 index 0000000000..5619e1cf02 --- /dev/null +++ b/engines/agi/text.cpp @@ -0,0 +1,677 @@ +/* ScummVM - Scumm Interpreter + * Copyright (C) 2006 The ScummVM project + * + * Copyright (C) 1999-2003 Sarien Team + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + * $URL$ + * $Id$ + * + */ + +#include "agi/agi.h" +#include "agi/sprite.h" /* for commit_both() */ +#include "agi/graphics.h" +#include "agi/keyboard.h" +#include "agi/text.h" + +namespace Agi { + +static void print_text2(int l, char *msg, int foff, int xoff, int yoff, + int len, int fg, int bg) { + int x1, y1; + int maxx, minx, ofoff; + int update; + /* Note: Must be unsigned to use AGDS cyrillic characters! */ + unsigned char *m; + + /* kludge! */ + update = 1; + if (l == 2) { + update = l = 0; + } + + /* FR: strings with len == 1 were not printed + */ + if (len == 1) { + put_text_character(l, xoff + foff, yoff, *msg, fg, bg); + maxx = 1; + minx = 0; + ofoff = foff; + y1 = 0; /* Check this */ + } else { + maxx = 0; + minx = GFX_WIDTH; + ofoff = foff; + + for (m = (unsigned char *)msg, x1 = y1 = 0; *m; m++) { + + if (*m >= 0x20 || *m == 1 || *m == 2 || *m == 3) { + /* FIXME */ + int ypos; + + ypos = (y1 * CHAR_LINES) + yoff; + + if ((x1 != (len - 1) || x1 == 39) && (ypos <= (GFX_HEIGHT - CHAR_LINES))) { + int xpos; + + xpos = (x1 * CHAR_COLS) + xoff + foff; + + if (xpos >= GFX_WIDTH) + continue; + + put_text_character(l, xpos, ypos, *m, fg, bg); + + if (x1 > maxx) + maxx = x1; + if (x1 < minx) + minx = x1; + } + + x1++; + /* DF: changed the len-1 to len... */ + if (x1 == len && m[1] != '\n') + y1++, x1 = foff = 0; + } else { + y1++; + x1 = foff = 0; + } + } + } + + if (l) + return; + + if (maxx < minx) + return; + + maxx *= CHAR_COLS; + minx *= CHAR_COLS; + + if (update) { + schedule_update(foff + xoff + minx, yoff, ofoff + xoff + maxx + CHAR_COLS - 1, + yoff + y1 * CHAR_LINES + CHAR_LINES + 1); + /* Making synchronous text updates reduces CPU load + * when updating status line and input area + */ + do_update(); + } +} + +/* len is in characters, not pixels!! + */ +static void blit_textbox(char *p, int y, int x, int len) { + /* if x | y = -1, then centre the box */ + int xoff, yoff, lin, h, w; + char *msg, *m; + + debugC(3, kDebugLevelText, "x=%d, y=%d, len=%d", x, y, len); + if (game.window.active) + close_window(); + + if (x == 0 && y == 0 && len == 0) + x = y = -1; + + if (len <= 0 || len >= 40) + len = 32; + + xoff = x * CHAR_COLS; + yoff = y * CHAR_LINES; + len--; + + m = msg = word_wrap_string(agi_sprintf(p), &len); + + for (lin = 1; *m; m++) { + /* Test \r for MacOS 8 */ + if (*m == '\n' || *m == '\r') + lin++; + } + + if (lin * CHAR_LINES > GFX_HEIGHT) + lin = (GFX_HEIGHT / CHAR_LINES); + + w = (len + 2) * CHAR_COLS; + h = (lin + 2) * CHAR_LINES; + + if (xoff < 0) + xoff = (GFX_WIDTH - w - CHAR_COLS) / 2; + else + xoff -= CHAR_COLS; + + if (yoff < 0) + yoff = (GFX_HEIGHT - 3 * CHAR_LINES - h) / 2; + + draw_window(xoff, yoff, xoff + w - 1, yoff + h - 1); + + print_text2(2, msg, 0, CHAR_COLS + xoff, CHAR_LINES + yoff, + len + 1, MSG_BOX_TEXT, MSG_BOX_COLOUR); + + free(msg); + + do_update(); +} + +static void erase_textbox() { + if (!game.window.active) { + debugC(3, kDebugLevelText, "no window active"); + return; + } + + debugC(4, kDebugLevelText, "x1=%d, y1=%d, x2=%d, y2=%d", game.window.x1, + game.window.y1, game.window.x2, game.window.y2); + + restore_block(game.window.x1, game.window.y1, + game.window.x2, game.window.y2, game.window.buffer); + + free(game.window.buffer); + game.window.active = false; + + do_update(); +} + +/* + * Public functions + */ + +/** + * Print text in the AGI engine screen. + */ +void print_text(char *msg, int f, int x, int y, int len, int fg, int bg) { + f *= CHAR_COLS; + x *= CHAR_COLS; + y *= CHAR_LINES; + + debugC(4, kDebugLevelText, "%s, %d, %d, %d, %d, %d, %d", msg, f, x, y, len, fg, bg); + print_text2(0, agi_sprintf(msg), f, x, y, len, fg, bg); +} + +/** + * Print text in the AGI engine console. + */ +void print_text_console(char *msg, int x, int y, int len, int fg, int bg) { + x *= CHAR_COLS; + y *= 10; + + print_text2(1, msg, 0, x, y, len, fg, bg); +} + +/** + * Wrap text line to the specified width. + * @param str String to wrap. + * @param len Length of line. + */ +char *word_wrap_string(char *str, int *len) { + /* If the message has a long word (longer than 31 character) then + * loop in line 239 (for (; *v != ' '; v--, c--);) can wrap + * around 0 and write large number in c. This causes returned + * length to be negative (!) and eventually crashes in calling + * code. The fix is simple -- remove unsigned in maxc, c, l + * declaration. --Vasyl + */ + char *msg, *v, *e; + int maxc, c, l = *len; + + v = msg = strdup(str); + e = msg + strlen(msg); + maxc = 0; + + while (42) { + debugC(3, kDebugLevelText, "[%s], %d", msg, maxc); + if (strchr(v, ' ') == NULL && (int)strlen(v) > l) { + debugC(1, kDebugLevelText | kDebugLevelMain, "Word too long in message"); + l = strlen(v); + } + /* Must include \r for MacOS 8 */ + while ((c = strcspn(v, "\n\r")) <= l) { + debugC(3, kDebugLevelText, "c = %d, maxc = %d", c, maxc); + if (c > maxc) + maxc = c; + if ((v += c + 1) >= e) + goto end; + } + c = l; + if ((v += l) >= e) + break; + + /* The same line that caused that bug I mentioned + * should also do another check: + * for (; *v != ' ' && *v != '\n'; v--, c--); + * While this does not matter in most cases, in the case of + * long words it caused extra \n inserted in the line + * preceding long word. This one is definitely non-critical; + * one might argue that the function is not supposed to deal + * with long words. BTW, that condition at the beginning of + * the while loop that checks word length does not make much + * sense -- it verifies the length of the first word but for + * the rest it does something odd. Overall, even with these + * changes the function is still not completely robust. + * --Vasyl + */ + if (*v != ' ') + for (; *v != ' ' && *v != '\n' && *v != '\r'; + v--, c--); + if (c > maxc) + maxc = c; + *v++ = '\n'; + } + end: + *len = maxc; + return msg; +} + +/** + * Remove existing window, if any. + */ +void close_window() { + debugC(4, kDebugLevelText, "close window"); + erase_both(); + erase_textbox(); /* remove window, if any */ + blit_both(); + commit_both(); /* redraw sprites */ + game.has_window = false; +} + +/** + * Display a message box. + * This function displays the specified message in a text box + * centered in the screen and waits until a key is pressed. + * @param p The text to be displayed + */ +int message_box(char *s) { + int k; + + erase_both(); + blit_textbox(s, -1, -1, -1); + blit_both(); + k = wait_key(); + debugC(4, kDebugLevelText, "wait_key returned %02x", k); + close_window(); + + return k; +} + +/** + * Display a message box with buttons. + * This function displays the specified message in a text box + * centered in the screen and waits until a button is pressed. + * @param p The text to be displayed + * @param b NULL-terminated list of button labels + */ +int selection_box(char *m, char **b) { + int x, y, i, s; + int key, active = 0; + int rc = -1; + int bx[5], by[5]; + + erase_both(); + blit_textbox(m, -1, -1, -1); + + x = game.window.x1 + 5 * CHAR_COLS / 2; + y = game.window.y2 - 5 * CHAR_LINES / 2; + s = game.window.x2 - game.window.x1 + 1 - 5 * CHAR_COLS; + debugC(3, kDebugLevelText, "s = %d", s); + + /* Automatically position buttons */ + for (i = 0; b[i]; i++) { + s -= CHAR_COLS * strlen(b[i]); + } + + if (i > 1) { + debugC(3, kDebugLevelText, "s / %d = %d", i - 1, s / (i - 1)); + s /= (i - 1); + } else { + x += s / 2; + } + + for (i = 0; b[i]; i++) { + bx[i] = x; + by[i] = y; + x += CHAR_COLS * strlen(b[i]) + s; + } + + blit_both(); + + /* clear key queue */ + while (keypress()) { + get_key(); + } + + debugC(4, kDebugLevelText, "waiting..."); + while (42) { + for (i = 0; b[i]; i++) + draw_button(bx[i], by[i], b[i], i == active, 0); + + poll_timer(); /* msdos driver -> does nothing */ + key = do_poll_keyboard(); + if (!console_keyhandler(key)) { + switch (key) { + case KEY_ENTER: + rc = active; + goto press; + case KEY_ESCAPE: + rc = -1; + goto getout; +#ifdef USE_MOUSE + case BUTTON_LEFT: + for (i = 0; b[i]; i++) { + if (test_button(bx[i], by[i], b[i])) { + rc = active = i; + goto press; + } + } + break; +#endif + case 0x09: /* Tab */ + debugC(3, kDebugLevelText, "Focus change"); + active++; + active %= i; + break; + } + } + console_cycle(); + } + + press: + debugC(4, kDebugLevelText, "Button pressed: %d", rc); + + getout: + close_window(); + debugC(2, kDebugLevelText, "Result = %d", rc); + + return rc; +} + +/** + * + */ +int print(char *p, int lin, int col, int len) { + if (p == NULL) + return 0; + + debugC(4, kDebugLevelText, "lin = %d, col = %d, len = %d", lin, col, len); + + if (col == 0 && lin == 0 && len == 0) + lin = col = -1; + + if (len == 0) + len = 30; + + blit_textbox(p, lin, col, len); + + if (getflag(F_output_mode)) { + /* non-blocking window */ + setflag(F_output_mode, false); + return 1; + } + + /* blocking */ + + if (game.vars[V_window_reset] == 0) { + int k; + setvar(V_key, 0); + k = wait_key(); + close_window(); + return k; + } + + /* timed window */ + + debugC(3, kDebugLevelText, "f15==0, v21==%d => timed", getvar(21)); + game.msg_box_ticks = getvar(V_window_reset) * 10; + setvar(V_key, 0); + + do { + main_cycle(); + if (game.keypress == KEY_ENTER) { + debugC(4, kDebugLevelText, "KEY_ENTER"); + setvar(V_window_reset, 0); + game.keypress = 0; + break; + } + } while (game.msg_box_ticks > 0); + + setvar(V_window_reset, 0); + + close_window(); + + return 0; +} + +/** + * + */ +static void print_status(char *message, ...) { + char x[42]; + va_list args; + + va_start(args, message); + +#ifdef HAVE_VSNPRINTF + vsnprintf(x, 41, message, args); +#else + vsprintf(x, message, args); +#endif + + va_end(args); + + debugC(4, kDebugLevelText, "fg=%d, bg=%d", STATUS_FG, STATUS_BG); + print_text(x, 0, 0, game.line_status, 40, STATUS_FG, STATUS_BG); +} + +static char *safe_strcat(char *s, const char *t) { + if (t != NULL) + strcat(s, t); + + return s; +} + +/** + * Formats AGI string. + * This function turns a AGI string into a real string expanding values + * according to the AGI format specifiers. + * @param s string containing the format specifier + * @param n logic number + */ +#define MAX_LEN 768 +char *agi_sprintf(char *s) { + static char y[MAX_LEN]; + char x[MAX_LEN]; + char z[16], *p; + + debugC(3, kDebugLevelText, "logic %d, '%s'", game.lognum, s); + p = x; + + for (*p = 0; *s;) { + switch (*s) { + case '\\': + s++; + goto literal; + case '%': + s++; + switch (*s++) { + int i; + case 'v': + i = strtoul(s, NULL, 10); + while (*s >= '0' && *s <= '9') + s++; + sprintf(z, "%015i", getvar(i)); + + i = 99; + if (*s == '|') { + s++; + i = strtoul(s, NULL, 10); + while (*s >= '0' && *s <= '9') + s++; + } + + if (i == 99) { + /* remove all leading 0 */ + /* don't remove the 3rd zero if 000 */ + for (i = 0; + z[i] == '0' && i < 14; i++); + } else { + i = 15 - i; + } + safe_strcat(p, z + i); + break; + case '0': + i = strtoul(s, NULL, 10) - 1; + safe_strcat(p, object_name(i)); + break; + case 'g': + i = strtoul(s, NULL, 10) - 1; + safe_strcat(p, game.logics[0].texts[i]); + break; + case 'w': + i = strtoul(s, NULL, 10) - 1; + safe_strcat(p, game.ego_words[i].word); + break; + case 's': + i = strtoul(s, NULL, 10); + safe_strcat(p, game.strings[i]); + break; + case 'm': + i = strtoul(s, NULL, 10) - 1; + if (game.logics[game.lognum].num_texts > i) + safe_strcat(p, agi_sprintf(game. logics[game.lognum].texts[i])); + break; + } + + while (*s >= '0' && *s <= '9') + s++; + while (*p) + p++; + break; + + default: + literal: + assert(p < x + MAX_LEN); + *p++ = *s++; + *p = 0; + break; + } + } + + strcpy(y, x); + return y; +} + +/** + * Write the status line. + */ +void write_status() { + char x[64]; + +#ifdef USE_CONSOLE + if (debug_.statusline) { +#ifdef USE_MOUSE + print_status("%3d(%03d) %3d,%3d(%3d,%3d) ", + getvar(0), getvar(1), game.view_table[0].x_pos, + game.view_table[0].y_pos, WIN_TO_PIC_X(mouse.x), + WIN_TO_PIC_Y(mouse.y)); +#else + print_status("%3d(%03d) %3d,%3d ", + getvar(0), getvar(1), game.view_table[0].x_pos, + game.view_table[0].y_pos); +#endif + return; + } +#endif /* USE_CONSOLE */ + + if (!game.status_line) { + int l = game.line_status; + clear_lines(l, l, 0); + flush_lines(l, l); + return; + } + + sprintf(x, " Score:%i of %-3i", game.vars[V_score], game.vars[V_max_score]); + print_status("%-17s Sound:%s ", x, getflag(F_sound_on) ? "on " : "off"); +} + +/** + * Print user input prompt. + */ +void write_prompt() { + int l, fg, bg, pos; + + if (!game.input_enabled || game.input_mode != INPUT_NORMAL) + return; + + l = game.line_user_input; + fg = game.color_fg; + bg = game.color_bg; + pos = game.cursor_pos; + + debugC(4, kDebugLevelText, "erase line %d", l); + clear_lines(l, l, game.color_bg); + + debugC(4, kDebugLevelText, "prompt = '%s'", agi_sprintf(game.strings[0])); + print_text(game.strings[0], 0, 0, l, 1, fg, bg); + print_text((char *)game.input_buffer, 0, 1, l, pos + 1, fg, bg); + print_character(pos + 1, l, game.cursor_char, fg, bg); + + flush_lines(l, l); + do_update(); +} + +/** + * Clear text lines in the screen. + * @param l1 start line + * @param l2 end line + * @param c color + */ +void clear_lines(int l1, int l2, int c) { + /* do we need to adjust for +8 on topline? + * inc for endline so it matches the correct num + * ie, from 22 to 24 is 3 lines, not 2 lines. + */ + + l1 *= CHAR_LINES; + l2 *= CHAR_LINES; + l2 += CHAR_LINES - 1; + + draw_rectangle(0, l1, GFX_WIDTH - 1, l2, c); +} + +/** + * + */ +void flush_lines(int l1, int l2) { + l1 *= CHAR_LINES; + l2 *= CHAR_LINES; + l2 += CHAR_LINES - 1; + + flush_block(0, l1, GFX_WIDTH - 1, l2); +} + +/** + * + */ +void draw_window(int x1, int y1, int x2, int y2) { + game.window.active = true; + game.window.x1 = x1; + game.window.y1 = y1; + game.window.x2 = x2; + game.window.y2 = y2; + game.window.buffer = (uint8 *) malloc((x2 - x1 + 1) * (y2 - y1 + 1)); + + debugC(4, kDebugLevelText, "x1=%d, y1=%d, x2=%d, y2=%d", x1, y1, x2, y2); + save_block(x1, y1, x2, y2, game.window.buffer); + draw_box(x1, y1, x2, y2, MSG_BOX_COLOUR, MSG_BOX_LINE, 2); +} + +} // End of namespace Agi diff --git a/engines/agi/text.h b/engines/agi/text.h new file mode 100644 index 0000000000..4ce37bc7fb --- /dev/null +++ b/engines/agi/text.h @@ -0,0 +1,48 @@ +/* ScummVM - Scumm Interpreter + * Copyright (C) 2006 The ScummVM project + * + * Copyright (C) 1999-2001 Sarien Team + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + * $URL$ + * $Id$ + * + */ + +#ifndef __AGI_TEXT_H +#define __AGI_TEXT_H + +#include "agi/agi.h" + +namespace Agi { + +int message_box(char *); +int selection_box(char *, char **); +void close_window(void); +void draw_window(int, int, int, int); +void print_text(char *, int, int, int, int, int, int); +void print_text_console(char *, int, int, int, int, int); +int print(char *, int, int, int); +char *word_wrap_string(char *, int *); +char *agi_sprintf(char *); +void write_status(void); +void write_prompt(void); +void clear_lines(int, int, int); +void flush_lines(int, int); + +} // End of namespace Agi + +#endif /* __AGI_TEXT_H */ diff --git a/engines/agi/view.cpp b/engines/agi/view.cpp new file mode 100644 index 0000000000..b8fc559b84 --- /dev/null +++ b/engines/agi/view.cpp @@ -0,0 +1,396 @@ +/* ScummVM - Scumm Interpreter + * Copyright (C) 2006 The ScummVM project + * + * Copyright (C) 1999-2003 Sarien Team + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + * $URL$ + * $Id$ + * + */ + +#include "agi/agi.h" +#include "agi/sprite.h" + +namespace Agi { + +static void _set_cel(struct vt_entry *v, int n) { + struct view_loop *current_vl; + struct view_cel *current_vc; + + v->current_cel = n; + + current_vl = &game.views[v->current_view].loop[v->current_loop]; + + /* Added by Amit Vainsencher <amitv@subdimension.com> to prevent + * crash in KQ1 -- not in the Sierra interpreter + */ + if (current_vl->num_cels == 0) + return; + + if (!(v->flags & UPDATE) + && (agi_get_release() >= 0x3000)) + return; + + current_vc = ¤t_vl->cel[n]; + v->cel_data = current_vc; + v->x_size = current_vc->width; + v->y_size = current_vc->height; +} + +static void _set_loop(struct vt_entry *v, int n) { + struct view_loop *current_vl; + debugC(7, kDebugLevelResources, "vt entry #%d, loop = %d", v->entry, n); + + /* Added to avoid crash when leaving the arcade machine in MH1 + * -- not in AGI 2.917 + */ + if (n >= v->num_loops) + n = 0; + + v->current_loop = n; + current_vl = &game.views[v->current_view].loop[v->current_loop]; + + v->num_cels = current_vl->num_cels; + if (v->current_cel >= v->num_cels) + v->current_cel = 0; + + if (!(v->flags & UPDATE) && (agi_get_release() >= 0x3000)) + return; + + v->loop_data = &game.views[v->current_view].loop[n]; +} + +static void update_view(struct vt_entry *v) { + int cel, last_cel; + + if (v->flags & DONTUPDATE) { + v->flags &= ~DONTUPDATE; + return; + } + + cel = v->current_cel; + last_cel = v->num_cels - 1; + + switch (v->cycle) { + case CYCLE_NORMAL: + if (++cel > last_cel) + cel = 0; + break; + case CYCLE_END_OF_LOOP: + if (cel < last_cel) { + debugC(5, kDebugLevelResources, "cel %d (last = %d)", cel + 1, last_cel); + if (++cel != last_cel) + break; + } + setflag(v->parm1, true); + v->flags &= ~CYCLING; + v->direction = 0; + v->cycle = CYCLE_NORMAL; + break; + case CYCLE_REV_LOOP: + if (cel) { + if (--cel) + break; + } + setflag(v->parm1, true); + v->flags &= ~CYCLING; + v->direction = 0; + v->cycle = CYCLE_NORMAL; + break; + case CYCLE_REVERSE: + if (cel == 0) { + cel = last_cel; + } else { + cel--; + } + break; + } + + set_cel(v, cel); +} + +/* + * Public functions + */ + +/** + * Decode an AGI view resource. + * This function decodes the raw data of the specified AGI view resource + * and fills the corresponding views array element. + * @param n number of view resource to decode + */ +int decode_view(int n) { + int loop, cel; + uint8 *v, *lptr; + uint16 lofs, cofs; + struct view_loop *vl; + struct view_cel *vc; + + debugC(5, kDebugLevelResources, "decode_view(%d)", n); + v = game.views[n].rdata; + + assert(v != NULL); + + game.views[n].descr = READ_LE_UINT16(v + 3) ? (char *)(v + READ_LE_UINT16(v + 3)) : (char *)(v + 3); + + /* if no loops exist, return! */ + if ((game.views[n].num_loops = *(v + 2)) == 0) + return err_NoLoopsInView; + + /* allocate memory for all views */ + game.views[n].loop = (view_loop *) + calloc(game.views[n].num_loops, sizeof(struct view_loop)); + + if (game.views[n].loop == NULL) + return err_NotEnoughMemory; + + /* decode all of the loops in this view */ + lptr = v + 5; /* first loop address */ + + for (loop = 0; loop < game.views[n].num_loops; loop++, lptr += 2) { + lofs = READ_LE_UINT16(lptr); /* loop header offset */ + vl = &game.views[n].loop[loop]; /* the loop struct */ + + vl->num_cels = *(v + lofs); + debugC(6, kDebugLevelResources, "view %d, num_cels = %d", n, vl->num_cels); + vl->cel = (view_cel *) calloc(vl->num_cels, sizeof(struct view_cel)); + if (vl->cel == NULL) { + free(game.views[n].loop); + game.views[n].num_loops = 0; + return err_NotEnoughMemory; + } + + /* decode the cells */ + for (cel = 0; cel < vl->num_cels; cel++) { + cofs = lofs + READ_LE_UINT16(v + lofs + 1 + (cel * 2)); + vc = &vl->cel[cel]; + + vc->width = *(v + cofs); + vc->height = *(v + cofs + 1); + vc->transparency = *(v + cofs + 2) & 0xf; + vc->mirror_loop = (*(v + cofs + 2) >> 4) & 0x7; + vc->mirror = (*(v + cofs + 2) >> 7) & 0x1; + + /* skip over width/height/trans|mirror data */ + cofs += 3; + + vc->data = v + cofs; + /* If mirror_loop is pointing to the current loop, + * then this is the original. + */ + if (vc->mirror_loop == loop) + vc->mirror = 0; + } /* cel */ + } /* loop */ + + return err_OK; +} + +/** + * Unloads all data in a view resource + * @param n number of view resource + */ +void unload_view(int n) { + int x; + + debugC(5, kDebugLevelResources, "discard view %d", n); + if (~game.dir_view[n].flags & RES_LOADED) + return; + + /* Rebuild sprite list, see bug #779302 */ + erase_both(); + blit_both(); + commit_both(); + + /* free all the loops */ + for (x = 0; x < game.views[n].num_loops; x++) + free(game.views[n].loop[x].cel); + + free(game.views[n].loop); + free(game.views[n].rdata); + + game.dir_view[n].flags &= ~RES_LOADED; +} + +/** + * Set a view table entry to use the specified cel of the current loop. + * @param v pointer to view table entry + * @param n number of cel + */ +void set_cel(struct vt_entry *v, int n) { + assert(v->view_data != NULL); + assert(v->num_cels >= n); + + _set_cel(v, n); + + /* If position isn't appropriate, update it accordingly */ + if (v->x_pos + v->x_size > _WIDTH) { + v->flags |= UPDATE_POS; + v->x_pos = _WIDTH - v->x_size; + } + if (v->y_pos - v->y_size + 1 < 0) { + v->flags |= UPDATE_POS; + v->y_pos = v->y_size - 1; + } + if (v->y_pos <= game.horizon && (~v->flags & IGNORE_HORIZON)) { + v->flags |= UPDATE_POS; + v->y_pos = game.horizon + 1; + } +} + +/** + * Set a view table entry to use the specified loop of the current view. + * @param v pointer to view table entry + * @param n number of loop + */ +void set_loop(struct vt_entry *v, int n) { + assert(v->view_data != NULL); + assert(v->num_loops >= n); + _set_loop(v, n); + set_cel(v, v->current_cel); +} + +/** + * Set a view table entry to use the specified view resource. + * @param v pointer to view table entry + * @param n number of AGI view resource + */ +void set_view(struct vt_entry *v, int n) { + v->view_data = &game.views[n]; + v->current_view = n; + v->num_loops = v->view_data->num_loops; + set_loop(v, v->current_loop >= v->num_loops ? 0 : v->current_loop); +} + +/** + * Set the view table entry as updating. + * @param v pointer to view table entry + */ +void start_update(struct vt_entry *v) { + if (~v->flags & UPDATE) { + erase_both(); + v->flags |= UPDATE; + blit_both(); + } +} + +/** + * Set the view table entry as non-updating. + * @param v pointer to view table entry + */ +void stop_update(struct vt_entry *v) { + if (v->flags & UPDATE) { + erase_both(); + v->flags &= ~UPDATE; + blit_both(); + } +} + +/* loops to use according to direction and number of loops in + * the view resource + */ +static int loop_table_2[] = { + 0x04, 0x04, 0x00, 0x00, 0x00, 0x04, 0x01, 0x01, 0x01 +}; + +static int loop_table_4[] = { + 0x04, 0x03, 0x00, 0x00, 0x00, 0x02, 0x01, 0x01, 0x01 +}; + +/** + * Update view table entries. + * This function is called at the end of each interpreter cycle + * to update the view table entries and blit the sprites. + */ +void update_viewtable() { + struct vt_entry *v; + int i, loop; + + i = 0; + for (v = game.view_table; v < &game.view_table[MAX_VIEWTABLE]; v++) { + if ((v->flags & (ANIMATED | UPDATE | DRAWN)) != (ANIMATED | UPDATE | DRAWN)) { + continue; + } + + i++; + + loop = 4; + if (~v->flags & FIX_LOOP) { + switch (v->num_loops) { + case 2: + case 3: + loop = loop_table_2[v->direction]; + break; + case 4: + loop = loop_table_4[v->direction]; + break; + default: + /* for KQ4 */ + if (agi_get_release() == 0x3086) + loop = loop_table_4[v->direction]; + break; + } + } + + /* AGI 2.272 (ddp, xmas) doesn't test step_time_count! */ + if (loop != 4 && loop != v->current_loop) { + if (agi_get_release() <= 0x2272 || + v->step_time_count == 1) { + set_loop(v, loop); + } + } + + if (~v->flags & CYCLING) + continue; + + if (v->cycle_time_count == 0) + continue; + + if (--v->cycle_time_count == 0) { + update_view(v); + v->cycle_time_count = v->cycle_time; + } + } + + if (i) { +#ifdef USE_CONSOLE + /* To correctly update sprites when we use the console + * we must work with all sprites. + */ + if (console.y > 0) { + erase_both(); + update_position(); + blit_both(); + commit_both(); + } else +#endif + /* If we're not using the console, updating only + * the active sprites lets us save some CPU cycles. + * This is how the original Sierra AGI works. + */ + { + erase_upd_sprites(); + update_position(); + blit_upd_sprites(); + commit_upd_sprites(); + } + + game.view_table[0].flags &= ~(ON_WATER | ON_LAND); + } +} + +} // End of namespace Agi diff --git a/engines/agi/view.h b/engines/agi/view.h new file mode 100644 index 0000000000..3394c8609a --- /dev/null +++ b/engines/agi/view.h @@ -0,0 +1,142 @@ +/* ScummVM - Scumm Interpreter + * Copyright (C) 2006 The ScummVM project + * + * Copyright (C) 1999-2001 Sarien Team + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + * $URL$ + * $Id$ + * + */ + +#ifndef __AGI_VIEW_H +#define __AGI_VIEW_H + +namespace Agi { + +struct view_cel { + uint8 height; + uint8 width; + uint8 transparency; + uint8 mirror_loop; + uint8 mirror; + uint8 *data; +}; + +struct view_loop { + int num_cels; + struct view_cel *cel; +}; + +/** + * AGI view resource structure. + */ +struct agi_view { + int num_loops; + struct view_loop *loop; + char *descr; + uint8 *rdata; +}; + +/** + * AGI view table entry + */ +struct vt_entry { + uint8 step_time; + uint8 step_time_count; + uint8 entry; + int16 x_pos; + int16 y_pos; + uint8 current_view; + struct agi_view *view_data; + uint8 current_loop; + uint8 num_loops; + struct view_loop *loop_data; + uint8 current_cel; + uint8 num_cels; + struct view_cel *cel_data; + struct view_cel *cel_data_2; + int16 x_pos2; + int16 y_pos2; + void *s; + int16 x_size; + int16 y_size; + uint8 step_size; + uint8 cycle_time; + uint8 cycle_time_count; + uint8 direction; + +#define MOTION_NORMAL 0 +#define MOTION_WANDER 1 +#define MOTION_FOLLOW_EGO 2 +#define MOTION_MOVE_OBJ 3 + uint8 motion; + +#define CYCLE_NORMAL 0 +#define CYCLE_END_OF_LOOP 1 +#define CYCLE_REV_LOOP 2 +#define CYCLE_REVERSE 3 + uint8 cycle; + + uint8 priority; + +#define DRAWN 0x0001 +#define IGNORE_BLOCKS 0x0002 +#define FIXED_PRIORITY 0x0004 +#define IGNORE_HORIZON 0x0008 +#define UPDATE 0x0010 +#define CYCLING 0x0020 +#define ANIMATED 0x0040 +#define MOTION 0x0080 +#define ON_WATER 0x0100 +#define IGNORE_OBJECTS 0x0200 +#define UPDATE_POS 0x0400 +#define ON_LAND 0x0800 +#define DONTUPDATE 0x1000 +#define FIX_LOOP 0x2000 +#define DIDNT_MOVE 0x4000 +#define ADJ_EGO_XY 0x8000 + uint16 flags; + + uint8 parm1; + uint8 parm2; + uint8 parm3; + uint8 parm4; +}; /* struct vt_entry */ + +/* Motion */ +void check_all_motions(void); +void move_obj(struct vt_entry *); +void in_destination(struct vt_entry *); +void fix_position(int); +void update_position(void); + +/* View table management */ +void set_cel(struct vt_entry *, int); +void set_loop(struct vt_entry *, int); +void set_view(struct vt_entry *, int); +void start_update(struct vt_entry *); +void stop_update(struct vt_entry *); +void update_viewtable(void); + +void unload_view(int); +int decode_view(int); +void add_to_pic(int, int, int, int, int, int, int); +void draw_obj(int); + +} // End of namespace Agi + +#endif /* __AGI_VIEW_H */ diff --git a/engines/agi/words.cpp b/engines/agi/words.cpp new file mode 100644 index 0000000000..77cdd97667 --- /dev/null +++ b/engines/agi/words.cpp @@ -0,0 +1,213 @@ +/* ScummVM - Scumm Interpreter + * Copyright (C) 2006 The ScummVM project + * + * Copyright (C) 1999-2002 Sarien Team + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + * $URL$ + * $Id$ + * + */ + +/* + * New find_word algorithm by Thomas Akesson <tapilot@home.se> + */ + +#include "agi/agi.h" +#include "agi/keyboard.h" /* for clean_input() */ + +namespace Agi { + +static uint8 *words; /* words in the game */ +static uint32 words_flen; /* length of word memory */ + +/* + * Local implementation to avoid problems with strndup() used by + * gcc 3.2 Cygwin (see #635984) + */ +static char *my_strndup(char *src, int n) { + char *tmp = strncpy((char *)malloc(n + 1), src, n); + tmp[n] = 0; + return tmp; +} + +int load_words(char *fname) { + Common::File fp; + uint32 flen; + uint8 *mem = NULL; + char *path = NULL; + + words = NULL; + + path = fname; + + if (!fp.open(path)) { + report("Warning: can't open %s\n", path); + return err_OK /*err_BadFileOpen */ ; + } + report("Loading dictionary: %s\n", path); + + fp.seek(0, SEEK_END); + flen = fp.pos(); + words_flen = flen; + fp.seek(0, SEEK_SET); + + if ((mem = (uint8 *)calloc(1, flen + 32)) == NULL) { + fp.close(); + return err_NotEnoughMemory; + } + + fp.read(mem, flen); + fp.close(); + + words = mem; + + return err_OK; +} + +void unload_words() { + if (words != NULL) { + free(words); + words = NULL; + } +} + +/** + * Find a word in the dictionary + * Uses an algorithm hopefully like the one Sierra used. Returns the ID + * of the word and the length in flen. Returns -1 if not found. + * + * Thomas Åkesson, November 2001 + */ +int find_word(char *word, int *flen) { + int mchr = 0; /* matched chars */ + int len, fchr, id = -1; + uint8 *p = words; + uint8 *q = words + words_flen; + *flen = 0; + + debugC(2, kDebugLevelScripts, "find_word(%s)", word); + if (word[0] >= 'a' && word[0] <= 'z') + fchr = word[0] - 'a'; + else + return -1; + + len = strlen(word); + + /* Get the offset to the first word beginning with the + * right character + */ + p += READ_BE_UINT16(p + 2 * fchr); + + while (p[0] >= mchr) { + if (p[0] == mchr) { + p++; + /* Loop through all matching characters */ + while ((p[0] ^ word[mchr]) == 0x7F && mchr < len) { + mchr++; + p++; + } + /* Check if this is the last character of the word + * and if it matches + */ + if ((p[0] ^ word[mchr]) == 0xFF && mchr < len) { + mchr++; + if (word[mchr] == 0 || word[mchr] == 0x20) { + id = READ_BE_UINT16(p + 1); + *flen = mchr; + } + } + } + if (p >= q) + return -1; + + /* Step to the next word */ + while (p[0] < 0x80) + p++; + p += 3; + } + + return id; +} + +void dictionary_words(char *msg) { + char *p = NULL; + char *q = NULL; + int wid, wlen; + + debugC(2, kDebugLevelScripts, "msg = \"%s\"", msg); + + clean_input(); + + for (p = msg; p && *p && getvar(V_word_not_found) == 0;) { + if (*p == 0x20) + p++; + + if (*p == 0) + break; + + wid = find_word(p, &wlen); + debugC(2, kDebugLevelScripts, "find_word(p) == %d", wid); + + switch (wid) { + case -1: + debugC(2, kDebugLevelScripts, "unknown word"); + game.ego_words[game.num_ego_words].word = strdup(p); + q = game.ego_words[game.num_ego_words].word; + game.ego_words[game.num_ego_words].id = 19999; + setvar(V_word_not_found, 1 + game.num_ego_words); + game.num_ego_words++; + p += strlen(p); + break; + case 0: + /* ignore this word */ + debugC(2, kDebugLevelScripts, "ignore word"); + p += wlen; + q = NULL; + break; + default: + /* an OK word */ + debugC(3, kDebugLevelScripts, "ok word (%d)", wid); + game.ego_words[game.num_ego_words].id = wid; + game.ego_words[game.num_ego_words].word = my_strndup(p, wlen); + game.num_ego_words++; + p += wlen; + break; + } + + if (p != NULL && *p) { + debugC(2, kDebugLevelScripts, "p = %s", p); + *p = 0; + p++; + } + + if (q != NULL) { + for (; (*q != 0 && *q != 0x20); q++); + if (*q) { + *q = 0; + q++; + } + } + } + + debugC(4, kDebugLevelScripts, "num_ego_words = %d", game.num_ego_words); + if (game.num_ego_words > 0) { + setflag(F_entered_cli, true); + setflag(F_said_accepted_input, false); + } +} + +} // End of namespace Agi |