scummvm/engines/sword2/mouse.cpp
Torbjörn Andersson 54b2a8c98d JANITORIAL: Cleanup (mostly whitespace)
svn-id: r53161
2010-10-12 04:19:58 +00:00

1738 lines
41 KiB
C++

/* ScummVM - Graphic Adventure Engine
*
* ScummVM is the legal property of its developers, whose names
* are too numerous to list here. Please refer to the COPYRIGHT
* file distributed with this source distribution.
*
* Additional copyright for this file:
* Copyright (C) 1994-1998 Revolution Software Ltd.
*
* 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/system.h"
#include "common/events.h"
#include "graphics/cursorman.h"
#include "sword2/sword2.h"
#include "sword2/console.h"
#include "sword2/controls.h"
#include "sword2/defs.h"
#include "sword2/header.h"
#include "sword2/logic.h"
#include "sword2/maketext.h"
#include "sword2/mouse.h"
#include "sword2/object.h"
#include "sword2/resman.h"
#include "sword2/screen.h"
#include "sword2/sound.h"
namespace Sword2 {
// Pointer resource id's
enum {
CROSHAIR = 18,
EXIT0 = 788,
EXIT1 = 789,
EXIT2 = 790,
EXIT3 = 791,
EXIT4 = 792,
EXIT5 = 793,
EXIT6 = 794,
EXIT7 = 795,
EXITDOWN = 796,
EXITUP = 797,
MOUTH = 787,
NORMAL = 17,
PICKUP = 3099,
SCROLL_L = 1440,
SCROLL_R = 1441,
USE = 3100
};
Mouse::Mouse(Sword2Engine *vm) {
_vm = vm;
resetMouseList();
_mouseTouching = 0;
_oldMouseTouching = 0;
_menuSelectedPos = 0;
_examiningMenuIcon = false;
_mousePointerRes = 0;
_mouseMode = 0;
_mouseStatus = false;
_mouseModeLocked = false;
_currentLuggageResource = 0;
_oldButton = 0;
_buttonClick = 0;
_pointerTextBlocNo = 0;
_playerActivityDelay = 0;
_realLuggageItem = 0;
_mouseAnim.data = NULL;
_luggageAnim.data = NULL;
// For the menus
_totalTemp = 0;
memset(_tempList, 0, sizeof(_tempList));
_totalMasters = 0;
memset(_masterMenuList, 0, sizeof(_masterMenuList));
memset(_mouseList, 0, sizeof(_mouseList));
memset(_subjectList, 0, sizeof(_subjectList));
_defaultResponseId = 0;
_choosing = false;
_iconCount = 0;
for (int i = 0; i < 2; i++) {
for (int j = 0; j < RDMENU_MAXPOCKETS; j++) {
_icons[i][j] = NULL;
_pocketStatus[i][j] = 0;
}
_menuStatus[i] = RDMENU_HIDDEN;
}
}
Mouse::~Mouse() {
free(_mouseAnim.data);
free(_luggageAnim.data);
for (int i = 0; i < 2; i++)
for (int j = 0; j < RDMENU_MAXPOCKETS; j++)
free(_icons[i][j]);
}
void Mouse::getPos(int &x, int &y) {
Common::EventManager *eventMan = _vm->_system->getEventManager();
Common::Point pos = eventMan->getMousePos();
x = pos.x;
y = pos.y - MENUDEEP;
}
int Mouse::getX() {
int x, y;
getPos(x, y);
return x;
}
int Mouse::getY() {
int x, y;
getPos(x, y);
return y;
}
/**
* Call at beginning of game loop
*/
void Mouse::resetMouseList() {
_curMouse = 0;
}
void Mouse::registerMouse(byte *ob_mouse, BuildUnit *build_unit) {
assert(_curMouse < TOTAL_mouse_list);
ObjectMouse mouse;
mouse.read(ob_mouse);
if (!mouse.pointer)
return;
if (build_unit) {
_mouseList[_curMouse].rect.left = build_unit->x;
_mouseList[_curMouse].rect.top = build_unit->y;
_mouseList[_curMouse].rect.right = 1 + build_unit->x + build_unit->scaled_width;
_mouseList[_curMouse].rect.bottom = 1 + build_unit->y + build_unit->scaled_height;
} else {
_mouseList[_curMouse].rect.left = mouse.x1;
_mouseList[_curMouse].rect.top = mouse.y1;
_mouseList[_curMouse].rect.right = 1 + mouse.x2;
_mouseList[_curMouse].rect.bottom = 1 + mouse.y2;
}
_mouseList[_curMouse].priority = mouse.priority;
_mouseList[_curMouse].pointer = mouse.pointer;
// Change all COGS pointers to CROSHAIR. I'm guessing that this was a
// design decision made in mid-development and they didn't want to go
// back and re-generate the resource files.
if (_mouseList[_curMouse].pointer == USE)
_mouseList[_curMouse].pointer = CROSHAIR;
// Check if pointer text field is set due to previous object using this
// slot (ie. not correct for this one)
// If 'pointer_text' field is set, but the 'id' field isn't same is
// current id then we don't want this "left over" pointer text
if (_mouseList[_curMouse].pointer_text && _mouseList[_curMouse].id != (int32)_vm->_logic->readVar(ID))
_mouseList[_curMouse].pointer_text = 0;
// Get id from system variable 'id' which is correct for current object
_mouseList[_curMouse].id = _vm->_logic->readVar(ID);
_curMouse++;
}
void Mouse::registerPointerText(int32 text_id) {
assert(_curMouse < TOTAL_mouse_list);
// current object id - used for checking pointer_text when mouse area
// registered (in fnRegisterMouse and fnRegisterFrame)
_mouseList[_curMouse].id = _vm->_logic->readVar(ID);
_mouseList[_curMouse].pointer_text = text_id;
}
/**
* This function is called every game cycle.
*/
void Mouse::mouseEngine() {
monitorPlayerActivity();
clearPointerText();
// If George is dead, the system menu is visible all the time, and is
// the only thing that can be used.
if (_vm->_logic->readVar(DEAD)) {
if (_mouseMode != MOUSE_system_menu) {
_mouseMode = MOUSE_system_menu;
if (_mouseTouching) {
_oldMouseTouching = 0;
_mouseTouching = 0;
}
setMouse(NORMAL_MOUSE_ID);
buildSystemMenu();
}
systemMenuMouse();
return;
}
// If the mouse is not visible, do nothing
if (_mouseStatus)
return;
switch (_mouseMode) {
case MOUSE_normal:
normalMouse();
break;
case MOUSE_menu:
menuMouse();
break;
case MOUSE_drag:
dragMouse();
break;
case MOUSE_system_menu:
systemMenuMouse();
break;
case MOUSE_holding:
if (getY() < 400) {
_mouseMode = MOUSE_normal;
debug(5, " releasing");
}
break;
default:
break;
}
}
#if RIGHT_CLICK_CLEARS_LUGGAGE
bool Mouse::heldIsInInventory() {
int32 object_held = (int32)_vm->_logic->readVar(OBJECT_HELD);
for (uint i = 0; i < _totalMasters; i++) {
if (_masterMenuList[i].icon_resource == object_held)
return true;
}
return false;
}
#endif
int Mouse::menuClick(int menu_items) {
int x = getX();
byte menuIconWidth;
if (Sword2Engine::isPsx())
menuIconWidth = RDMENU_PSXICONWIDE;
else
menuIconWidth = RDMENU_ICONWIDE;
if (x < RDMENU_ICONSTART)
return -1;
if (x > RDMENU_ICONSTART + menu_items * (menuIconWidth + RDMENU_ICONSPACING) - RDMENU_ICONSPACING)
return -1;
return (x - RDMENU_ICONSTART) / (menuIconWidth + RDMENU_ICONSPACING);
}
void Mouse::systemMenuMouse() {
uint32 safe_looping_music_id;
MouseEvent *me;
int hit;
byte *icon;
int32 pars[2];
uint32 icon_list[5] = {
OPTIONS_ICON,
QUIT_ICON,
SAVE_ICON,
RESTORE_ICON,
RESTART_ICON
};
// If the mouse is moved off the menu, close it. Unless the player is
// dead, in which case the menu should always be visible.
int y = getY();
if (y > 0 && !_vm->_logic->readVar(DEAD)) {
_mouseMode = MOUSE_normal;
hideMenu(RDMENU_TOP);
return;
}
// Check if the user left-clicks anywhere in the menu area.
me = _vm->mouseEvent();
if (!me || !(me->buttons & RD_LEFTBUTTONDOWN))
return;
if (y > 0)
return;
hit = menuClick(ARRAYSIZE(icon_list));
if (hit < 0)
return;
// Do nothing if using PSX version and are on TOP menu.
if ((icon_list[hit] == OPTIONS_ICON || icon_list[hit] == QUIT_ICON
|| icon_list[hit] == SAVE_ICON || icon_list[hit] == RESTORE_ICON
|| icon_list[hit] == RESTART_ICON) && Sword2Engine::isPsx())
return;
// No save when dead
if (icon_list[hit] == SAVE_ICON && _vm->_logic->readVar(DEAD))
return;
// Gray out all he icons, except the one that was clicked
for (int i = 0; i < ARRAYSIZE(icon_list); i++) {
if (i != hit) {
icon = _vm->_resman->openResource(icon_list[i]) + ResHeader::size();
setMenuIcon(RDMENU_TOP, i, icon);
_vm->_resman->closeResource(icon_list[i]);
}
}
_vm->_sound->pauseFx();
// NB. Need to keep a safe copy of '_loopingMusicId' for savegame & for
// playing when returning from control panels because control panel
// music will overwrite it!
safe_looping_music_id = _vm->_sound->getLoopingMusicId();
pars[0] = 221;
pars[1] = FX_LOOP;
_vm->_logic->fnPlayMusic(pars);
// HACK: Restore proper looping_music_id
_vm->_sound->setLoopingMusicId(safe_looping_music_id);
processMenu();
// call the relevant screen
switch (hit) {
case 0:
{
OptionsDialog dialog(_vm);
dialog.runModal();
}
break;
case 1:
{
QuitDialog dialog(_vm);
dialog.runModal();
}
break;
case 2:
{
SaveDialog dialog(_vm);
dialog.runModal();
}
break;
case 3:
{
RestoreDialog dialog(_vm);
dialog.runModal();
}
break;
case 4:
{
RestartDialog dialog(_vm);
dialog.runModal();
}
break;
}
// Menu stays open on death screen. Otherwise it's closed.
if (!_vm->_logic->readVar(DEAD)) {
_mouseMode = MOUSE_normal;
hideMenu(RDMENU_TOP);
} else {
setMouse(NORMAL_MOUSE_ID);
buildSystemMenu();
}
// Back to the game again
processMenu();
// Reset game palette, but not after a successful restore or restart!
// See RestoreFromBuffer() in saveload.cpp
ScreenInfo *screenInfo = _vm->_screen->getScreenInfo();
if (screenInfo->new_palette != 99) {
// 0 means put back game screen palette; see build_display.cpp
_vm->_screen->setFullPalette(0);
// Stop the engine fading in the restored screens palette
screenInfo->new_palette = 0;
} else
screenInfo->new_palette = 1;
_vm->_sound->unpauseFx();
// If there was looping music before coming into the control panels
// then restart it! NB. If a game has been restored the music will be
// restarted twice, but this shouldn't cause any harm.
if (_vm->_sound->getLoopingMusicId()) {
pars[0] = _vm->_sound->getLoopingMusicId();
pars[1] = FX_LOOP;
_vm->_logic->fnPlayMusic(pars);
} else
_vm->_logic->fnStopMusic(NULL);
}
void Mouse::dragMouse() {
byte buf1[NAME_LEN], buf2[NAME_LEN];
MouseEvent *me;
int hit;
// We can use dragged object both on other inventory objects, or on
// objects in the scene, so if the mouse moves off the inventory menu,
// then close it.
int x, y;
getPos(x, y);
if (y < 400) {
_mouseMode = MOUSE_normal;
hideMenu(RDMENU_BOTTOM);
return;
}
// Handles cursors and the luggage on/off according to type
mouseOnOff();
// Now do the normal click stuff
me = _vm->mouseEvent();
if (!me)
return;
#if RIGHT_CLICK_CLEARS_LUGGAGE
if ((me->buttons & RD_RIGHTBUTTONDOWN) && heldIsInInventory()) {
_vm->_logic->writeVar(OBJECT_HELD, 0);
_menuSelectedPos = 0;
_mouseMode = MOUSE_menu;
setLuggage(0);
buildMenu();
return;
}
#endif
if (!(me->buttons & RD_LEFTBUTTONDOWN))
return;
// there's a mouse event to be processed
// could be clicking on an on screen object or on the menu
// which is currently displayed
if (_mouseTouching) {
// mouse is over an on screen object - and we have luggage
// Depending on type we'll maybe kill the object_held - like
// for exits
// Set global script variable 'button'. We know that it was the
// left button, not the right one.
_vm->_logic->writeVar(LEFT_BUTTON, 1);
_vm->_logic->writeVar(RIGHT_BUTTON, 0);
// These might be required by the action script about to be run
ScreenInfo *screenInfo = _vm->_screen->getScreenInfo();
_vm->_logic->writeVar(MOUSE_X, x + screenInfo->scroll_offset_x);
_vm->_logic->writeVar(MOUSE_Y, y + screenInfo->scroll_offset_y);
// For scripts to know what's been clicked. First used for
// 'room_13_turning_script' in object 'biscuits_13'
_vm->_logic->writeVar(CLICKED_ID, _mouseTouching);
_vm->_logic->setPlayerActionEvent(CUR_PLAYER_ID, _mouseTouching);
debug(2, "Used \"%s\" on \"%s\"",
_vm->_resman->fetchName(_vm->_logic->readVar(OBJECT_HELD), buf1),
_vm->_resman->fetchName(_vm->_logic->readVar(CLICKED_ID), buf2));
// Hide menu - back to normal menu mode
hideMenu(RDMENU_BOTTOM);
_mouseMode = MOUSE_normal;
return;
}
// Better check for combine/cancel. Cancel puts us back in MOUSE_menu
// mode
hit = menuClick(TOTAL_engine_pockets);
if (hit < 0 || !_masterMenuList[hit].icon_resource)
return;
// Always back into menu mode. Remove the luggage as well.
_mouseMode = MOUSE_menu;
setLuggage(0);
if ((uint)hit == _menuSelectedPos) {
// If we clicked on the same icon again, reset the first icon
_vm->_logic->writeVar(OBJECT_HELD, 0);
_menuSelectedPos = 0;
} else {
// Otherwise, combine the two icons
_vm->_logic->writeVar(COMBINE_BASE, _masterMenuList[hit].icon_resource);
_vm->_logic->setPlayerActionEvent(CUR_PLAYER_ID, MENU_MASTER_OBJECT);
// Turn off mouse now, to prevent player trying to click
// elsewhere BUT leave the bottom menu open
hideMouse();
debug(2, "Used \"%s\" on \"%s\"",
_vm->_resman->fetchName(_vm->_logic->readVar(OBJECT_HELD), buf1),
_vm->_resman->fetchName(_vm->_logic->readVar(COMBINE_BASE), buf2));
}
// Refresh the menu
buildMenu();
}
void Mouse::menuMouse() {
MouseEvent *me;
int hit;
// If the mouse is moved off the menu, close it.
if (getY() < 400) {
_mouseMode = MOUSE_normal;
hideMenu(RDMENU_BOTTOM);
return;
}
me = _vm->mouseEvent();
if (!me)
return;
hit = menuClick(TOTAL_engine_pockets);
// Check if we clicked on an actual icon.
if (hit < 0 || !_masterMenuList[hit].icon_resource)
return;
if (me->buttons & RD_RIGHTBUTTONDOWN) {
// Right button - examine an object, identified by its icon
// resource id.
_examiningMenuIcon = true;
_vm->_logic->writeVar(OBJECT_HELD, _masterMenuList[hit].icon_resource);
// Must clear this so next click on exit becomes 1st click
// again
_vm->_logic->writeVar(EXIT_CLICK_ID, 0);
_vm->_logic->setPlayerActionEvent(CUR_PLAYER_ID, MENU_MASTER_OBJECT);
// Refresh the menu
buildMenu();
// Turn off mouse now, to prevent player trying to click
// elsewhere BUT leave the bottom menu open
hideMouse();
debug(2, "Right-click on \"%s\" icon",
_vm->_resman->fetchName(_vm->_logic->readVar(OBJECT_HELD)));
return;
}
if (me->buttons & RD_LEFTBUTTONDOWN) {
// Left button - bung us into drag luggage mode. The object is
// identified by its icon resource id. We need the luggage
// resource id for mouseOnOff
_mouseMode = MOUSE_drag;
_menuSelectedPos = hit;
_vm->_logic->writeVar(OBJECT_HELD, _masterMenuList[hit].icon_resource);
_currentLuggageResource = _masterMenuList[hit].luggage_resource;
// Must clear this so next click on exit becomes 1st click
// again
_vm->_logic->writeVar(EXIT_CLICK_ID, 0);
// Refresh the menu
buildMenu();
setLuggage(_masterMenuList[hit].luggage_resource);
debug(2, "Left-clicked on \"%s\" icon - switch to drag mode",
_vm->_resman->fetchName(_vm->_logic->readVar(OBJECT_HELD)));
}
}
void Mouse::normalMouse() {
// The game is playing and none of the menus are activated - but, we
// need to check if a menu is to start. Note, won't have luggage
MouseEvent *me;
// Check if the cursor has moved onto the system menu area. No save in
// big-object menu lock situation, of if the player is dragging an
// object.
int x, y;
getPos(x, y);
if (y < 0 && !_mouseModeLocked && !_vm->_logic->readVar(OBJECT_HELD)) {
_mouseMode = MOUSE_system_menu;
if (_mouseTouching) {
// We were on something, but not anymore
_oldMouseTouching = 0;
_mouseTouching = 0;
}
// Reset mouse cursor - in case we're between mice
setMouse(NORMAL_MOUSE_ID);
buildSystemMenu();
return;
}
// Check if the cursor has moved onto the inventory menu area. No
// inventory in big-object menu lock situation,
if (y > 399 && !_mouseModeLocked) {
// If an object is being held, i.e. if the mouse cursor has a
// luggage, go to drag mode instead of menu mode, but the menu
// is still opened.
//
// That way, we can still use an object on another inventory
// object, even if the inventory menu was closed after the
// first object was selected.
if (!_vm->_logic->readVar(OBJECT_HELD))
_mouseMode = MOUSE_menu;
else
_mouseMode = MOUSE_drag;
// If mouse is moving off an object and onto the menu then do a
// standard get-off
if (_mouseTouching) {
_oldMouseTouching = 0;
_mouseTouching = 0;
}
// Reset mouse cursor
setMouse(NORMAL_MOUSE_ID);
buildMenu();
return;
}
// Check for moving the mouse on or off things
mouseOnOff();
me = _vm->mouseEvent();
if (!me)
return;
bool button_down = (me->buttons & (RD_LEFTBUTTONDOWN | RD_RIGHTBUTTONDOWN)) != 0;
// For debugging. We can draw a rectangle on the screen and see its
// coordinates. This was probably used to help defining hit areas.
if (_vm->_debugger->_definingRectangles) {
ScreenInfo *screenInfo = _vm->_screen->getScreenInfo();
if (_vm->_debugger->_draggingRectangle == 0) {
// Not yet dragging a rectangle, so need click to start
if (button_down) {
// set both (x1,y1) and (x2,y2) to this point
_vm->_debugger->_rectX1 = _vm->_debugger->_rectX2 = (uint32)x + screenInfo->scroll_offset_x;
_vm->_debugger->_rectY1 = _vm->_debugger->_rectY2 = (uint32)y + screenInfo->scroll_offset_y;
_vm->_debugger->_draggingRectangle = 1;
}
} else if (_vm->_debugger->_draggingRectangle == 1) {
// currently dragging a rectangle - click means reset
if (button_down) {
// lock rectangle, so you can let go of mouse
// to type in the coords
_vm->_debugger->_draggingRectangle = 2;
} else {
// drag rectangle
_vm->_debugger->_rectX2 = (uint32)x + screenInfo->scroll_offset_x;
_vm->_debugger->_rectY2 = (uint32)y + screenInfo->scroll_offset_y;
}
} else {
// currently locked to avoid knocking out of place
// while reading off the coords
if (button_down) {
// click means reset - back to start again
_vm->_debugger->_draggingRectangle = 0;
}
}
return;
}
#if RIGHT_CLICK_CLEARS_LUGGAGE
if (_vm->_logic->readVar(OBJECT_HELD) && (me->buttons & RD_RIGHTBUTTONDOWN) && heldIsInInventory()) {
_vm->_logic->writeVar(OBJECT_HELD, 0);
_menuSelectedPos = 0;
setLuggage(0);
return;
}
#endif
// Now do the normal click stuff
// We only care about down clicks when the mouse is over an object.
if (!_mouseTouching || !button_down)
return;
// There's a mouse event to be processed and the mouse is on something.
// Notice that the floor itself is considered an object.
// There are no menus about so its nice and simple. This is as close to
// the old advisor_188 script as we get, I'm sorry to say.
// If player is walking or relaxing then those need to terminate
// correctly. Otherwise set player run the targets action script or, do
// a special walk if clicking on the scroll-more icon
// PLAYER_ACTION script variable - whatever catches this must reset to
// 0 again
// _vm->_logic->writeVar(PLAYER_ACTION, _mouseTouching);
// Idle or router-anim will catch it
// Set global script variable 'button'
if (me->buttons & RD_LEFTBUTTONDOWN) {
_vm->_logic->writeVar(LEFT_BUTTON, 1);
_vm->_logic->writeVar(RIGHT_BUTTON, 0);
_buttonClick = 0; // for re-click
} else {
_vm->_logic->writeVar(LEFT_BUTTON, 0);
_vm->_logic->writeVar(RIGHT_BUTTON, 1);
_buttonClick = 1; // for re-click
}
// These might be required by the action script about to be run
ScreenInfo *screenInfo = _vm->_screen->getScreenInfo();
_vm->_logic->writeVar(MOUSE_X, x + screenInfo->scroll_offset_x);
_vm->_logic->writeVar(MOUSE_Y, y + screenInfo->scroll_offset_y);
if (_mouseTouching == _vm->_logic->readVar(EXIT_CLICK_ID) && (me->buttons & RD_LEFTBUTTONDOWN)) {
// It's the exit double click situation. Let the existing
// interaction continue and start fading down. Switch the human
// off too
noHuman();
_vm->_logic->fnFadeDown(NULL);
// Tell the walker
_vm->_logic->writeVar(EXIT_FADING, 1);
} else if (_oldButton == _buttonClick && _mouseTouching == _vm->_logic->readVar(CLICKED_ID) && _mousePointerRes != NORMAL_MOUSE_ID) {
// Re-click. Do nothing, except on floors
} else {
// For re-click
_oldButton = _buttonClick;
// For scripts to know what's been clicked. First used for
// 'room_13_turning_script' in object 'biscuits_13'
_vm->_logic->writeVar(CLICKED_ID, _mouseTouching);
// Must clear these two double-click control flags - do it here
// so reclicks after exit clicks are cleared up
_vm->_logic->writeVar(EXIT_CLICK_ID, 0);
_vm->_logic->writeVar(EXIT_FADING, 0);
_vm->_logic->setPlayerActionEvent(CUR_PLAYER_ID, _mouseTouching);
byte buf1[NAME_LEN], buf2[NAME_LEN];
if (_vm->_logic->readVar(OBJECT_HELD))
debug(2, "Used \"%s\" on \"%s\"",
_vm->_resman->fetchName(_vm->_logic->readVar(OBJECT_HELD), buf1),
_vm->_resman->fetchName(_vm->_logic->readVar(CLICKED_ID), buf2));
else if (_vm->_logic->readVar(LEFT_BUTTON))
debug(2, "Left-clicked on \"%s\"",
_vm->_resman->fetchName(_vm->_logic->readVar(CLICKED_ID)));
else // RIGHT BUTTON
debug(2, "Right-clicked on \"%s\"",
_vm->_resman->fetchName(_vm->_logic->readVar(CLICKED_ID)));
}
}
uint32 Mouse::chooseMouse() {
// Unlike the other mouse "engines", this one is called directly by the
// fnChoose() opcode.
byte menuIconWidth;
if (Sword2Engine::isPsx())
menuIconWidth = RDMENU_PSXICONWIDE;
else
menuIconWidth = RDMENU_ICONWIDE;
uint i;
_vm->_logic->writeVar(AUTO_SELECTED, 0);
uint32 in_subject = _vm->_logic->readVar(IN_SUBJECT);
uint32 object_held = _vm->_logic->readVar(OBJECT_HELD);
if (object_held) {
// The player used an object on a person. In this case it
// triggered a conversation menu. Act as if the user tried to
// talk to the person about that object. If the person doesn't
// know anything about it, use the default response.
uint32 response = _defaultResponseId;
for (i = 0; i < in_subject; i++) {
if (_subjectList[i].res == object_held) {
response = _subjectList[i].ref;
break;
}
}
// The user won't be holding the object any more, and the
// conversation menu will be closed.
_vm->_logic->writeVar(OBJECT_HELD, 0);
_vm->_logic->writeVar(IN_SUBJECT, 0);
return response;
}
if (_vm->_logic->readVar(CHOOSER_COUNT_FLAG) == 0 && in_subject == 1 && _subjectList[0].res == EXIT_ICON) {
// This is the first time the chooser is coming up in this
// conversation, there is only one subject and that's the
// EXIT icon.
//
// In other words, the player doesn't have anything to talk
// about. Skip it.
// The conversation menu will be closed. We set AUTO_SELECTED
// because the speech script depends on it.
_vm->_logic->writeVar(AUTO_SELECTED, 1);
_vm->_logic->writeVar(IN_SUBJECT, 0);
return _subjectList[0].ref;
}
byte *icon;
if (!_choosing) {
// This is a new conversation menu.
if (!in_subject)
error("fnChoose with no subjects");
for (i = 0; i < in_subject; i++) {
icon = _vm->_resman->openResource(_subjectList[i].res) + ResHeader::size() + menuIconWidth * RDMENU_ICONDEEP;
setMenuIcon(RDMENU_BOTTOM, i, icon);
_vm->_resman->closeResource(_subjectList[i].res);
}
for (; i < 15; i++)
setMenuIcon(RDMENU_BOTTOM, (uint8) i, NULL);
showMenu(RDMENU_BOTTOM);
setMouse(NORMAL_MOUSE_ID);
_choosing = true;
return (uint32)-1;
}
// The menu is there - we're just waiting for a click. We only care
// about left clicks.
MouseEvent *me = _vm->mouseEvent();
int mouseX, mouseY;
getPos(mouseX, mouseY);
if (!me || !(me->buttons & RD_LEFTBUTTONDOWN) || mouseY < 400)
return (uint32)-1;
// Check for click on a menu.
int hit = _vm->_mouse->menuClick(in_subject);
if (hit < 0)
return (uint32)-1;
// Hilight the clicked icon by greying the others. This can look a bit
// odd when you click on the exit icon, but there are also cases when
// it looks strange if you don't do it.
for (i = 0; i < in_subject; i++) {
if ((int)i != hit) {
icon = _vm->_resman->openResource(_subjectList[i].res) + ResHeader::size();
_vm->_mouse->setMenuIcon(RDMENU_BOTTOM, i, icon);
_vm->_resman->closeResource(_subjectList[i].res);
}
}
// For non-speech scripts that manually call the chooser
_vm->_logic->writeVar(RESULT, _subjectList[hit].res);
// The conversation menu will be closed
_choosing = false;
_vm->_logic->writeVar(IN_SUBJECT, 0);
setMouse(0);
return _subjectList[hit].ref;
}
void Mouse::mouseOnOff() {
// this handles the cursor graphic when moving on and off mouse areas
// it also handles the luggage thingy
uint32 pointer_type;
static uint8 mouse_flicked_off = 0;
_oldMouseTouching = _mouseTouching;
// don't detect objects that are hidden behind the menu bars (ie. in
// the scrolled-off areas of the screen)
int y = getY();
if (y < 0 || y > 399) {
pointer_type = 0;
_mouseTouching = 0;
} else {
// set '_mouseTouching' & return pointer_type
pointer_type = checkMouseList();
}
// same as previous cycle?
if (!mouse_flicked_off && _oldMouseTouching == _mouseTouching) {
// yes, so nothing to do
// BUT CARRY ON IF MOUSE WAS FLICKED OFF!
return;
}
// can reset this now
mouse_flicked_off = 0;
//the cursor has moved onto something
if (!_oldMouseTouching && _mouseTouching) {
// make a copy of the object we've moved onto because one day
// we'll move back off again! (but the list positioning could
// theoretically have changed)
// we can only move onto something from being on nothing - we
// stop the system going from one to another when objects
// overlap
_oldMouseTouching = _mouseTouching;
// run get on
if (pointer_type) {
// 'pointer_type' holds the resource id of the
// pointer anim
setMouse(pointer_type);
// setup luggage icon
if (_vm->_logic->readVar(OBJECT_HELD)) {
setLuggage(_currentLuggageResource);
}
} else {
error("ERROR: mouse.pointer==0 for object %d (%s) - update logic script", _mouseTouching, _vm->_resman->fetchName(_mouseTouching));
}
} else if (_oldMouseTouching && !_mouseTouching) {
// the cursor has moved off something - reset cursor to
// normal pointer
_oldMouseTouching = 0;
setMouse(NORMAL_MOUSE_ID);
// reset luggage only when necessary
} else if (_oldMouseTouching && _mouseTouching) {
// The cursor has moved off something and onto something
// else. Flip to a blank cursor for a cycle.
// ignore the new id this cycle - should hit next cycle
_mouseTouching = 0;
_oldMouseTouching = 0;
setMouse(0);
// so we know to set the mouse pointer back to normal if 2nd
// hot-spot doesn't register because mouse pulled away
// quickly (onto nothing)
mouse_flicked_off = 1;
// reset luggage only when necessary
} else {
// Mouse was flicked off for one cycle, but then moved onto
// nothing before 2nd hot-spot registered
// both '_oldMouseTouching' & '_mouseTouching' will be zero
// reset cursor to normal pointer
setMouse(NORMAL_MOUSE_ID);
}
// possible check for edge of screen more-to-scroll here on large
// screens
}
void Mouse::setMouse(uint32 res) {
// high level - whats the mouse - for the engine
_mousePointerRes = res;
if (res) {
byte *icon = _vm->_resman->openResource(res) + ResHeader::size();
uint32 len = _vm->_resman->fetchLen(res) - ResHeader::size();
// don't pulse the normal pointer - just do the regular anim
// loop
if (res == NORMAL_MOUSE_ID)
setMouseAnim(icon, len, RDMOUSE_NOFLASH);
else
setMouseAnim(icon, len, RDMOUSE_FLASH);
_vm->_resman->closeResource(res);
} else {
// blank cursor
setMouseAnim(NULL, 0, 0);
}
}
void Mouse::setLuggage(uint32 res) {
_realLuggageItem = res;
if (res) {
byte *icon = _vm->_resman->openResource(res) + ResHeader::size();
uint32 len = _vm->_resman->fetchLen(res) - ResHeader::size();
setLuggageAnim(icon, len);
_vm->_resman->closeResource(res);
} else
setLuggageAnim(NULL, 0);
}
void Mouse::setObjectHeld(uint32 res) {
setLuggage(res);
_vm->_logic->writeVar(OBJECT_HELD, res);
_currentLuggageResource = res;
// mode locked - no menu available
_mouseModeLocked = true;
}
uint32 Mouse::checkMouseList() {
ScreenInfo *screenInfo = _vm->_screen->getScreenInfo();
int x, y;
getPos(x, y);
Common::Point mousePos(x + screenInfo->scroll_offset_x, y + screenInfo->scroll_offset_y);
// Number of priorities subject to implementation needs
for (int priority = 0; priority < 10; priority++) {
for (uint i = 0; i < _curMouse; i++) {
// If the mouse pointer is over this
// mouse-detection-box
if (_mouseList[i].priority == priority && _mouseList[i].rect.contains(mousePos)) {
// Record id
_mouseTouching = _mouseList[i].id;
createPointerText(_mouseList[i].pointer_text, _mouseList[i].pointer);
// Return pointer type
return _mouseList[i].pointer;
}
}
}
// Touching nothing; no pointer to return
_mouseTouching = 0;
return 0;
}
#define POINTER_TEXT_WIDTH 640 // just in case!
#define POINTER_TEXT_PEN 184 // white
void Mouse::createPointerText(uint32 text_id, uint32 pointer_res) {
uint32 local_text;
uint32 text_res;
byte *text;
// offsets for pointer text sprite from pointer position
int16 xOffset, yOffset;
uint8 justification;
if (!_objectLabels || !text_id)
return;
// Check what the pointer is, to set offsets correctly for text
// position
switch (pointer_res) {
case CROSHAIR:
yOffset = -7;
xOffset = +10;
break;
case EXIT0:
yOffset = +15;
xOffset = +20;
break;
case EXIT1:
yOffset = +16;
xOffset = -10;
break;
case EXIT2:
yOffset = +10;
xOffset = -22;
break;
case EXIT3:
yOffset = -16;
xOffset = -10;
break;
case EXIT4:
yOffset = -15;
xOffset = +15;
break;
case EXIT5:
yOffset = -12;
xOffset = +10;
break;
case EXIT6:
yOffset = +10;
xOffset = +25;
break;
case EXIT7:
yOffset = +16;
xOffset = +20;
break;
case EXITDOWN:
yOffset = -20;
xOffset = -10;
break;
case EXITUP:
yOffset = +20;
xOffset = +20;
break;
case MOUTH:
yOffset = -10;
xOffset = +15;
break;
case NORMAL:
yOffset = -10;
xOffset = +15;
break;
case PICKUP:
yOffset = -40;
xOffset = +10;
break;
case SCROLL_L:
yOffset = -20;
xOffset = +20;
break;
case SCROLL_R:
yOffset = -20;
xOffset = -20;
break;
case USE:
yOffset = -8;
xOffset = +20;
break;
default:
// Shouldn't happen if we cover all the different mouse
// pointers above
yOffset = -10;
xOffset = +10;
break;
}
// Set up justification for text sprite, based on its offsets from the
// pointer position
if (yOffset < 0) {
// Above pointer
if (xOffset < 0) {
// Above left
justification = POSITION_AT_RIGHT_OF_BASE;
} else if (xOffset > 0) {
// Above right
justification = POSITION_AT_LEFT_OF_BASE;
} else {
// Above centre
justification = POSITION_AT_CENTRE_OF_BASE;
}
} else if (yOffset > 0) {
// Below pointer
if (xOffset < 0) {
// Below left
justification = POSITION_AT_RIGHT_OF_TOP;
} else if (xOffset > 0) {
// Below right
justification = POSITION_AT_LEFT_OF_TOP;
} else {
// Below centre
justification = POSITION_AT_CENTRE_OF_TOP;
}
} else {
// Same y-coord as pointer
if (xOffset < 0) {
// Centre left
justification = POSITION_AT_RIGHT_OF_CENTRE;
} else if (xOffset > 0) {
// Centre right
justification = POSITION_AT_LEFT_OF_CENTRE;
} else {
// Centre centre - shouldn't happen anyway!
justification = POSITION_AT_LEFT_OF_CENTRE;
}
}
// Text resource number, and line number within the resource
text_res = text_id / SIZE;
local_text = text_id & 0xffff;
// open text file & get the line
text = _vm->fetchTextLine(_vm->_resman->openResource(text_res), local_text);
// 'text+2' to skip the first 2 bytes which form the
// line reference number
int x, y;
getPos(x, y);
_pointerTextBlocNo = _vm->_fontRenderer->buildNewBloc(
text + 2, x + xOffset,
y + yOffset,
POINTER_TEXT_WIDTH, POINTER_TEXT_PEN,
RDSPR_TRANS | RDSPR_DISPLAYALIGN,
_vm->_speechFontId, justification);
// now ok to close the text file
_vm->_resman->closeResource(text_res);
}
void Mouse::clearPointerText() {
if (_pointerTextBlocNo) {
_vm->_fontRenderer->killTextBloc(_pointerTextBlocNo);
_pointerTextBlocNo = 0;
}
}
void Mouse::hideMouse() {
// leaves the menus open
// used by the system when clicking right on a menu item to examine
// it and when combining objects
// for logic scripts
_vm->_logic->writeVar(MOUSE_AVAILABLE, 0);
// human/mouse off
_mouseStatus = true;
setMouse(0);
setLuggage(0);
}
void Mouse::noHuman() {
hideMouse();
clearPointerText();
// Must be normal mouse situation or a largely neutral situation -
// special menus use hideMouse()
// Don't hide menu in conversations
if (_vm->_logic->readVar(TALK_FLAG) == 0)
hideMenu(RDMENU_BOTTOM);
if (_mouseMode == MOUSE_system_menu) {
// Close menu
_mouseMode = MOUSE_normal;
hideMenu(RDMENU_TOP);
}
}
void Mouse::addHuman() {
// For logic scripts
_vm->_logic->writeVar(MOUSE_AVAILABLE, 1);
if (_mouseStatus) {
// Force engine to choose a cursor
_mouseStatus = false;
_mouseTouching = 1;
}
// Clear this to reset no-second-click system
_vm->_logic->writeVar(CLICKED_ID, 0);
// This is now done outside the OBJECT_HELD check in case it's set to
// zero before now!
// Unlock the mouse from possible large object lock situtations - see
// syphon in rm 3
_mouseModeLocked = false;
if (_vm->_logic->readVar(OBJECT_HELD)) {
// Was dragging something around - need to clear this again
_vm->_logic->writeVar(OBJECT_HELD, 0);
// And these may also need clearing, just in case
_examiningMenuIcon = false;
_vm->_logic->writeVar(COMBINE_BASE, 0);
setLuggage(0);
}
// If mouse is over menu area
if (getY() > 399) {
if (_mouseMode != MOUSE_holding) {
// VITAL - reset things & rebuild the menu
_mouseMode = MOUSE_normal;
}
setMouse(NORMAL_MOUSE_ID);
}
// Enabled/disabled from console; status printed with on-screen debug
// info
if (_vm->_debugger->_testingSnR) {
uint8 black[4] = { 0, 0, 0, 0 };
uint8 white[4] = { 255, 255, 255, 0 };
// Testing logic scripts by simulating instant Save & Restore
_vm->_screen->setPalette(0, 1, white, RDPAL_INSTANT);
// Stops all fx & clears the queue - eg. when leaving a room
_vm->_sound->clearFxQueue(false);
// Trash all object resources so they load in fresh & restart
// their logic scripts
_vm->_resman->killAllObjects(false);
_vm->_screen->setPalette(0, 1, black, RDPAL_INSTANT);
}
}
void Mouse::refreshInventory() {
// Can reset this now
_vm->_logic->writeVar(COMBINE_BASE, 0);
// Cause 'object_held' icon to be greyed. The rest are coloured.
_examiningMenuIcon = true;
buildMenu();
_examiningMenuIcon = false;
}
void Mouse::startConversation() {
if (_vm->_logic->readVar(TALK_FLAG) == 0) {
// See fnChooser & speech scripts
_vm->_logic->writeVar(CHOOSER_COUNT_FLAG, 0);
}
noHuman();
}
void Mouse::endConversation() {
hideMenu(RDMENU_BOTTOM);
if (getY() > 399) {
// Will wait for cursor to move off the bottom menu
_mouseMode = MOUSE_holding;
}
// In case DC forgets
_vm->_logic->writeVar(TALK_FLAG, 0);
}
void Mouse::monitorPlayerActivity() {
// if there is at least one mouse event outstanding
if (_vm->checkForMouseEvents()) {
// reset activity delay counter
_playerActivityDelay = 0;
} else {
// no. of game cycles since mouse event queue last empty
_playerActivityDelay++;
}
}
void Mouse::checkPlayerActivity(uint32 seconds) {
// Convert seconds to game cycles
uint32 threshold = seconds * 12;
// If the actual delay is at or above the given threshold, reset the
// activity delay counter now that we've got a positive check.
if (_playerActivityDelay >= threshold) {
_playerActivityDelay = 0;
_vm->_logic->writeVar(RESULT, 1);
} else
_vm->_logic->writeVar(RESULT, 0);
}
void Mouse::pauseEngine(bool pause) {
if (pause) {
// Make the mouse cursor normal. This is the only place where
// we are allowed to clear the luggage this way.
clearPointerText();
setLuggageAnim(NULL, 0);
setMouse(0);
setMouseTouching(1);
} else {
if (_vm->_logic->readVar(OBJECT_HELD) && _realLuggageItem)
setLuggage(_realLuggageItem);
}
}
#define MOUSEFLASHFRAME 6
void Mouse::decompressMouse(byte *decomp, byte *comp, uint8 frame, int width, int height, int pitch, int xOff, int yOff) {
int32 size = width * height;
int32 i = 0;
int x = 0;
int y = 0;
if (Sword2Engine::isPsx()) {
comp = comp + READ_LE_UINT32(comp + 2 + frame * 4) - MOUSE_ANIM_HEADER_SIZE;
yOff /= 2; // Without this, distance of object from cursor is too big.
byte *buffer;
buffer = (byte *)malloc(size);
Screen::decompressHIF(comp, buffer);
for (int line = 0; line < height; line++) {
memcpy(decomp + (line + yOff) * pitch + xOff, buffer + line * width, width);
}
free(buffer);
} else {
comp = comp + READ_LE_UINT32(comp + frame * 4) - MOUSE_ANIM_HEADER_SIZE;
while (i < size) {
if (*comp > 183) {
decomp[(y + yOff) * pitch + x + xOff] = *comp++;
if (++x >= width) {
x = 0;
y++;
}
i++;
} else {
x += *comp;
while (x >= width) {
y++;
x -= width;
}
i += *comp++;
}
}
}
}
void Mouse::drawMouse() {
if (!_mouseAnim.data && !_luggageAnim.data)
return;
// When an object is used in the game, the mouse cursor should be a
// combination of a standard mouse cursor and a luggage cursor.
//
// However, judging by the original code luggage cursors can also
// appear on their own. I have no idea which cases though.
uint16 mouse_width = 0;
uint16 mouse_height = 0;
uint16 hotspot_x = 0;
uint16 hotspot_y = 0;
int deltaX = 0;
int deltaY = 0;
if (_mouseAnim.data) {
hotspot_x = _mouseAnim.xHotSpot;
hotspot_y = _mouseAnim.yHotSpot;
mouse_width = _mouseAnim.mousew;
mouse_height = _mouseAnim.mouseh;
}
if (_luggageAnim.data) {
if (!_mouseAnim.data) {
hotspot_x = _luggageAnim.xHotSpot;
hotspot_y = _luggageAnim.yHotSpot;
}
if (_luggageAnim.mousew > mouse_width)
mouse_width = _luggageAnim.mousew;
if (_luggageAnim.mouseh > mouse_height)
mouse_height = _luggageAnim.mouseh;
}
if (_mouseAnim.data && _luggageAnim.data) {
deltaX = _mouseAnim.xHotSpot - _luggageAnim.xHotSpot;
deltaY = _mouseAnim.yHotSpot - _luggageAnim.yHotSpot;
}
assert(deltaX >= 0);
assert(deltaY >= 0);
mouse_width += deltaX;
mouse_height += deltaY;
byte *mouseData = (byte *)calloc(mouse_height, mouse_width);
if (_luggageAnim.data)
decompressMouse(mouseData, _luggageAnim.data, 0,
_luggageAnim.mousew, _luggageAnim.mouseh,
mouse_width, deltaX, deltaY);
if (_mouseAnim.data)
decompressMouse(mouseData, _mouseAnim.data, _mouseFrame,
_mouseAnim.mousew, _mouseAnim.mouseh, mouse_width);
// Fix height for mouse sprite in PSX version
if (Sword2Engine::isPsx()) {
mouse_height *= 2;
byte *buffer = (byte *)malloc(mouse_width * mouse_height);
Screen::resizePsxSprite(buffer, mouseData, mouse_width, mouse_height);
free(mouseData);
mouseData = buffer;
}
CursorMan.replaceCursor(mouseData, mouse_width, mouse_height, hotspot_x, hotspot_y, 0);
free(mouseData);
}
/**
* Animates the current mouse pointer
*/
int32 Mouse::animateMouse() {
uint8 prevMouseFrame = _mouseFrame;
if (!_mouseAnim.data)
return RDERR_UNKNOWN;
if (++_mouseFrame == _mouseAnim.noAnimFrames)
_mouseFrame = MOUSEFLASHFRAME;
if (_mouseFrame != prevMouseFrame)
drawMouse();
return RD_OK;
}
/**
* Sets the mouse cursor animation.
* @param ma a pointer to the animation data, or NULL to clear the current one
* @param size the size of the mouse animation data
* @param mouseFlash RDMOUSE_FLASH or RDMOUSE_NOFLASH, depending on whether
* or not there is a lead-in animation
*/
int32 Mouse::setMouseAnim(byte *ma, int32 size, int32 mouseFlash) {
free(_mouseAnim.data);
_mouseAnim.data = NULL;
if (ma) {
if (mouseFlash == RDMOUSE_FLASH)
_mouseFrame = 0;
else
_mouseFrame = MOUSEFLASHFRAME;
Common::MemoryReadStream readS(ma, size);
_mouseAnim.runTimeComp = readS.readByte();
_mouseAnim.noAnimFrames = readS.readByte();
_mouseAnim.xHotSpot = readS.readSByte();
_mouseAnim.yHotSpot = readS.readSByte();
_mouseAnim.mousew = readS.readByte();
_mouseAnim.mouseh = readS.readByte();
_mouseAnim.data = (byte *)malloc(size - MOUSE_ANIM_HEADER_SIZE);
if (!_mouseAnim.data)
return RDERR_OUTOFMEMORY;
readS.read(_mouseAnim.data, size - MOUSE_ANIM_HEADER_SIZE);
animateMouse();
drawMouse();
CursorMan.showMouse(true);
} else {
if (_luggageAnim.data)
drawMouse();
else
CursorMan.showMouse(false);
}
return RD_OK;
}
/**
* Sets the "luggage" animation to accompany the mouse animation. Luggage
* sprites are of the same format as mouse sprites.
* @param ma a pointer to the animation data, or NULL to clear the current one
* @param size the size of the animation data
*/
int32 Mouse::setLuggageAnim(byte *ma, int32 size) {
free(_luggageAnim.data);
_luggageAnim.data = NULL;
if (ma) {
Common::MemoryReadStream readS(ma, size);
_luggageAnim.runTimeComp = readS.readByte();
_luggageAnim.noAnimFrames = readS.readByte();
_luggageAnim.xHotSpot = readS.readSByte();
_luggageAnim.yHotSpot = readS.readSByte();
_luggageAnim.mousew = readS.readByte();
_luggageAnim.mouseh = readS.readByte();
_luggageAnim.data = (byte *)malloc(size - MOUSE_ANIM_HEADER_SIZE);
if (!_luggageAnim.data)
return RDERR_OUTOFMEMORY;
readS.read(_luggageAnim.data, size - MOUSE_ANIM_HEADER_SIZE);
animateMouse();
drawMouse();
CursorMan.showMouse(true);
} else {
if (_mouseAnim.data)
drawMouse();
else
CursorMan.showMouse(false);
}
return RD_OK;
}
int Mouse::getMouseMode() {
return _mouseMode;
}
void Mouse::setMouseMode(int mouseMode) {
_mouseMode = mouseMode;
}
} // End of namespace Sword2