mirror of
https://github.com/libretro/scummvm.git
synced 2024-12-19 08:06:42 +00:00
239 lines
10 KiB
C++
239 lines
10 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.
|
|
*
|
|
* 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$
|
|
*
|
|
*/
|
|
|
|
/*
|
|
* This code is based on original Hugo Trilogy source code
|
|
*
|
|
* Copyright (c) 1989-1995 David P. Gray
|
|
*
|
|
*/
|
|
|
|
#include "common/system.h"
|
|
|
|
#include "hugo/hugo.h"
|
|
#include "hugo/game.h"
|
|
#include "hugo/file.h"
|
|
#include "hugo/schedule.h"
|
|
#include "hugo/display.h"
|
|
#include "hugo/mouse.h"
|
|
#include "hugo/inventory.h"
|
|
#include "hugo/parser.h"
|
|
#include "hugo/object.h"
|
|
|
|
namespace Hugo {
|
|
|
|
#define MAX_DISP (XPIX / INV_DX) // Max icons displayable
|
|
|
|
InventoryHandler::InventoryHandler(HugoEngine *vm) : _vm(vm) {
|
|
}
|
|
|
|
/**
|
|
* Construct the inventory scrollbar in dib_i
|
|
* imageTotNumb is total number of inventory icons
|
|
* displayNumb is number requested for display
|
|
* scrollFl is TRUE if scroll arrows required
|
|
* firstObjId is index of first (scrolled) inventory object to display
|
|
*/
|
|
void InventoryHandler::constructInventory(int16 imageTotNumb, int displayNumb, bool scrollFl, int16 firstObjId) {
|
|
debugC(1, kDebugInventory, "constructInventory(%d, %d, %d, %d)", imageTotNumb, displayNumb, (scrollFl) ? 0 : 1, firstObjId);
|
|
|
|
// Clear out icon buffer
|
|
memset(_vm->_screen->getIconBuffer(), 0, sizeof(_vm->_screen->getIconBuffer()));
|
|
|
|
// If needed, copy arrows - reduce number of icons displayable
|
|
if (scrollFl) { // Display at first and last icon positions
|
|
_vm->_screen->moveImage(_vm->_screen->getGUIBuffer(), 0, 0, INV_DX, INV_DY, XPIX, _vm->_screen->getIconBuffer(), 0, 0, XPIX);
|
|
_vm->_screen->moveImage(_vm->_screen->getGUIBuffer(), INV_DX, 0, INV_DX, INV_DY, XPIX, _vm->_screen->getIconBuffer(), INV_DX *(MAX_DISP - 1), 0, XPIX);
|
|
displayNumb = MIN(displayNumb, MAX_DISP - NUM_ARROWS);
|
|
} else // No, override first index - we can show 'em all!
|
|
firstObjId = 0;
|
|
|
|
// Copy inventory icons to remaining positions
|
|
int16 displayed = 0;
|
|
int16 carried = 0;
|
|
for (int16 i = 0; (i < imageTotNumb) && (displayed < displayNumb); i++) {
|
|
if (_vm->_object->isCarried(_vm->_invent[i])) {
|
|
// Check still room to display and past first scroll index
|
|
if (displayed < displayNumb && carried >= firstObjId) {
|
|
// Compute source coordinates in dib_u
|
|
int16 ux = (i + NUM_ARROWS) * INV_DX % XPIX;
|
|
int16 uy = (i + NUM_ARROWS) * INV_DX / XPIX * INV_DY;
|
|
|
|
// Compute dest coordinates in dib_i
|
|
int16 ix = ((scrollFl) ? displayed + 1 : displayed) * INV_DX;
|
|
displayed++; // Count number displayed
|
|
|
|
// Copy the icon
|
|
_vm->_screen->moveImage(_vm->_screen->getGUIBuffer(), ux, uy, INV_DX, INV_DY, XPIX, _vm->_screen->getIconBuffer(), ix, 0, XPIX);
|
|
}
|
|
carried++; // Count number carried
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Process required action for inventory
|
|
* Returns objId under cursor (or -1) for INV_GET
|
|
*/
|
|
int16 InventoryHandler::processInventory(invact_t action, ...) {
|
|
debugC(1, kDebugInventory, "processInventory(invact_t action, ...)");
|
|
|
|
static int16 firstIconId = 0; // Index of first icon to display
|
|
|
|
int16 imageNumb; // Total number of inventory items
|
|
int displayNumb; // Total number displayed/carried
|
|
// Compute total number and number displayed, i.e. number carried
|
|
for (imageNumb = 0, displayNumb = 0; imageNumb < _vm->_maxInvent && _vm->_invent[imageNumb] != -1; imageNumb++) {
|
|
if (_vm->_object->isCarried(_vm->_invent[imageNumb]))
|
|
displayNumb++;
|
|
}
|
|
|
|
// Will we need the scroll arrows?
|
|
bool scrollFl = displayNumb > MAX_DISP;
|
|
va_list marker; // Args used for D_ADD operation
|
|
int16 cursorx, cursory; // Current cursor position
|
|
int16 objId = -1; // Return objid under cursor
|
|
|
|
switch (action) {
|
|
case INV_INIT: // Initialize inventory display
|
|
constructInventory(imageNumb, displayNumb, scrollFl, firstIconId);
|
|
break;
|
|
case INV_LEFT: // Scroll left by one icon
|
|
firstIconId = MAX(0, firstIconId - 1);
|
|
constructInventory(imageNumb, displayNumb, scrollFl, firstIconId);
|
|
break;
|
|
case INV_RIGHT: // Scroll right by one icon
|
|
firstIconId = MIN(displayNumb, firstIconId + 1);
|
|
constructInventory(imageNumb, displayNumb, scrollFl, firstIconId);
|
|
break;
|
|
case INV_GET: // Return object id under cursor
|
|
// Get cursor position from variable argument list
|
|
va_start(marker, action); // Initialize variable arguments
|
|
cursorx = va_arg(marker, int); // Cursor x
|
|
cursory = va_arg(marker, int); // Cursor y
|
|
va_end(marker); // Reset variable arguments
|
|
|
|
cursory -= DIBOFF_Y; // Icon bar is at true zero
|
|
if (cursory > 0 && cursory < INV_DY) { // Within icon bar?
|
|
int16 i = cursorx / INV_DX; // Compute icon index
|
|
if (scrollFl) { // Scroll buttons displayed
|
|
if (i == 0) { // Left scroll button
|
|
objId = LEFT_ARROW;
|
|
} else {
|
|
if (i == MAX_DISP - 1) // Right scroll button
|
|
objId = RIGHT_ARROW;
|
|
else // Adjust for scroll
|
|
i += firstIconId - 1; // i is icon index
|
|
}
|
|
}
|
|
|
|
// If not an arrow, find object id - limit to valid range
|
|
if (objId == -1 && i < displayNumb) {
|
|
// Find objid by counting # carried objects == i+1
|
|
int16 j;
|
|
for (j = 0, i++; i > 0 && j < _vm->_object->_numObj; j++) {
|
|
if (_vm->_object->isCarried(j)) {
|
|
if (--i == 0)
|
|
objId = j;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
return objId; // For the INV_GET action
|
|
}
|
|
|
|
/**
|
|
* Process inventory state machine
|
|
*/
|
|
void InventoryHandler::runInventory() {
|
|
status_t &gameStatus = _vm->getGameStatus();
|
|
|
|
debugC(1, kDebugInventory, "runInventory");
|
|
|
|
switch (gameStatus.inventoryState) {
|
|
case I_OFF: // Icon bar off screen
|
|
break;
|
|
case I_UP: // Icon bar moving up
|
|
gameStatus.inventoryHeight -= STEP_DY; // Move the icon bar up
|
|
if (gameStatus.inventoryHeight <= 0) // Limit travel
|
|
gameStatus.inventoryHeight = 0;
|
|
|
|
// Move visible portion to _frontBuffer, restore uncovered portion, display results
|
|
_vm->_screen->moveImage(_vm->_screen->getIconBuffer(), 0, 0, XPIX, gameStatus.inventoryHeight, XPIX, _vm->_screen->getFrontBuffer(), 0, DIBOFF_Y, XPIX);
|
|
_vm->_screen->moveImage(_vm->_screen->getBackBufferBackup(), 0, gameStatus.inventoryHeight + DIBOFF_Y, XPIX, STEP_DY, XPIX, _vm->_screen->getFrontBuffer(), 0, gameStatus.inventoryHeight + DIBOFF_Y, XPIX);
|
|
_vm->_screen->displayRect(0, DIBOFF_Y, XPIX, gameStatus.inventoryHeight + STEP_DY);
|
|
|
|
if (gameStatus.inventoryHeight == 0) { // Finished moving up?
|
|
// Yes, restore dibs and exit back to game state machine
|
|
_vm->_screen->moveImage(_vm->_screen->getBackBufferBackup(), 0, 0, XPIX, YPIX, XPIX, _vm->_screen->getBackBuffer(), 0, 0, XPIX);
|
|
_vm->_screen->moveImage(_vm->_screen->getBackBuffer(), 0, 0, XPIX, YPIX, XPIX, _vm->_screen->getFrontBuffer(), 0, 0, XPIX);
|
|
_vm->_object->updateImages(); // Add objects back into display list for restore
|
|
gameStatus.inventoryState = I_OFF;
|
|
gameStatus.viewState = V_PLAY;
|
|
}
|
|
break;
|
|
case I_DOWN: // Icon bar moving down
|
|
// If this is the first step, initialize dib_i
|
|
// and get any icon/text out of _frontBuffer
|
|
if (gameStatus.inventoryHeight == 0) {
|
|
processInventory(INV_INIT); // Initialize dib_i
|
|
_vm->_screen->displayList(D_RESTORE); // Restore _frontBuffer
|
|
_vm->_object->updateImages(); // Rebuild _frontBuffer without icons/text
|
|
_vm->_screen->displayList(D_DISPLAY); // Blit display list to screen
|
|
}
|
|
|
|
gameStatus.inventoryHeight += STEP_DY; // Move the icon bar down
|
|
if (gameStatus.inventoryHeight >= INV_DY) // Limit travel
|
|
gameStatus.inventoryHeight = INV_DY;
|
|
|
|
// Move visible portion to _frontBuffer, display results
|
|
_vm->_screen->moveImage(_vm->_screen->getIconBuffer(), 0, 0, XPIX, gameStatus.inventoryHeight, XPIX, _vm->_screen->getFrontBuffer(), 0, DIBOFF_Y, XPIX);
|
|
_vm->_screen->displayRect(0, DIBOFF_Y, XPIX, gameStatus.inventoryHeight);
|
|
|
|
if (gameStatus.inventoryHeight == INV_DY) { // Finished moving down?
|
|
// Yes, prepare view dibs for special inventory display since
|
|
// we can't refresh objects while icon bar overlayed...
|
|
// 1. Save backing store _backBuffer in temporary dib_c
|
|
// 2. Make snapshot of _frontBuffer the new _backBuffer backing store
|
|
// 3. Reset the display list
|
|
_vm->_screen->moveImage(_vm->_screen->getBackBuffer(), 0, 0, XPIX, YPIX, XPIX, _vm->_screen->getBackBufferBackup(), 0, 0, XPIX);
|
|
_vm->_screen->moveImage(_vm->_screen->getFrontBuffer(), 0, 0, XPIX, YPIX, XPIX, _vm->_screen->getBackBuffer(), 0, 0, XPIX);
|
|
_vm->_screen->displayList(D_INIT);
|
|
gameStatus.inventoryState = I_ACTIVE;
|
|
}
|
|
break;
|
|
case I_ACTIVE: // Inventory active
|
|
_vm->_parser->charHandler(); // Still allow commands
|
|
_vm->_screen->displayList(D_RESTORE); // Restore previous background
|
|
_vm->_mouse->mouseHandler(); // Mouse activity - adds to display list
|
|
_vm->_screen->displayList(D_DISPLAY); // Blit the display list to screen
|
|
break;
|
|
}
|
|
}
|
|
|
|
} // End of namespace Hugo
|