2014-03-15 21:38:44 +00:00
|
|
|
/* ScummVM - Graphic Adventure Engine
|
|
|
|
*
|
|
|
|
* ScummVM is the legal property of its developers, whose names
|
|
|
|
* are too numerous to list here. Please refer to the COPYRIGHT
|
|
|
|
* file distributed with this source distribution.
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU General Public License
|
|
|
|
* as published by the Free Software Foundation; either version 2
|
|
|
|
* of the License, or (at your option) any later version.
|
|
|
|
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program; if not, write to the Free Software
|
|
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include "common/scummsys.h"
|
|
|
|
#include "mads/mads.h"
|
|
|
|
#include "mads/inventory.h"
|
|
|
|
|
|
|
|
namespace MADS {
|
|
|
|
|
2014-04-23 03:00:41 +00:00
|
|
|
void InventoryObject::synchronize(Common::Serializer &s) {
|
|
|
|
s.syncAsUint16LE(_descId);
|
|
|
|
s.syncAsUint16LE(_roomNumber);
|
|
|
|
s.syncAsByte(_article);
|
|
|
|
s.syncAsByte(_vocabCount);
|
2014-03-15 21:38:44 +00:00
|
|
|
|
|
|
|
for (int i = 0; i < 3; ++i) {
|
2014-04-23 03:00:41 +00:00
|
|
|
s.syncAsByte(_vocabList[i]._verbType);
|
|
|
|
s.syncAsByte(_vocabList[i]._prepType);
|
|
|
|
s.syncAsUint16LE( _vocabList[i]._vocabId);
|
2014-03-15 21:38:44 +00:00
|
|
|
}
|
|
|
|
|
2014-04-23 03:00:41 +00:00
|
|
|
s.skip(4); // field12
|
|
|
|
s.syncBytes((byte *)&_mutilateString[0], 10);
|
|
|
|
s.skip(16);
|
2014-03-15 21:38:44 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*------------------------------------------------------------------------*/
|
|
|
|
|
|
|
|
void InventoryObjects::load() {
|
|
|
|
File f("*OBJECTS.DAT");
|
2014-04-23 03:00:41 +00:00
|
|
|
Common::Serializer s(&f, nullptr);
|
2014-03-15 21:38:44 +00:00
|
|
|
|
2014-04-23 03:00:41 +00:00
|
|
|
// Load the objects data
|
|
|
|
synchronize(s);
|
|
|
|
}
|
|
|
|
|
|
|
|
void InventoryObjects::synchronize(Common::Serializer &s) {
|
|
|
|
int count = size();
|
|
|
|
s.syncAsUint16LE(count);
|
|
|
|
|
|
|
|
if (s.isSaving()) {
|
|
|
|
// Store the data for each object in the inventory lsit
|
|
|
|
for (int idx = 0; idx < count; ++idx)
|
|
|
|
(*this)[idx].synchronize(s);
|
|
|
|
} else {
|
|
|
|
clear();
|
|
|
|
_inventoryList.clear();
|
|
|
|
reserve(count);
|
2014-03-15 21:38:44 +00:00
|
|
|
|
2014-04-23 03:00:41 +00:00
|
|
|
// Read in each object
|
|
|
|
for (int i = 0; i < count; ++i) {
|
|
|
|
InventoryObject obj;
|
|
|
|
obj.synchronize(s);
|
|
|
|
push_back(obj);
|
2014-03-15 21:38:44 +00:00
|
|
|
|
2014-04-23 03:00:41 +00:00
|
|
|
// If it's for the player's inventory, add the index to the inventory list
|
|
|
|
if (obj._roomNumber == PLAYER_INVENTORY) {
|
|
|
|
_inventoryList.push_back(i);
|
|
|
|
assert(_inventoryList.size() <= 32);
|
|
|
|
}
|
2014-03-15 21:38:44 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-03-26 13:32:33 +00:00
|
|
|
void InventoryObjects::setQuality(int objIndex, int id, const byte *p) {
|
2014-03-15 21:38:44 +00:00
|
|
|
// TODO: This whole method seems weird. Check it out more thoroughly once
|
|
|
|
// more of the engine is implemented
|
|
|
|
for (int i = 0; i < (int)size(); ++i) {
|
|
|
|
InventoryObject &obj = (*this)[i];
|
2014-04-09 03:01:46 +00:00
|
|
|
if (obj._vocabList[0]._verbType <= i)
|
2014-03-15 21:38:44 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
if (obj._mutilateString[6 + i] == id) {
|
|
|
|
(*this)[objIndex]._objFolder = p;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-03-19 04:15:25 +00:00
|
|
|
void InventoryObjects::setRoom(int objectId, int sceneNumber) {
|
|
|
|
InventoryObject &obj = (*this)[objectId];
|
|
|
|
|
|
|
|
if (obj._roomNumber == PLAYER_INVENTORY)
|
|
|
|
removeFromInventory(objectId, 1);
|
|
|
|
|
|
|
|
if (sceneNumber == PLAYER_INVENTORY)
|
|
|
|
addToInventory(objectId);
|
|
|
|
else
|
|
|
|
obj._roomNumber = sceneNumber;
|
2014-03-15 21:38:44 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
bool InventoryObjects::isInRoom(int objectId) const {
|
|
|
|
return (*this)[objectId]._roomNumber == _vm->_game->_scene._currentSceneId;
|
|
|
|
}
|
|
|
|
|
2014-03-18 17:49:36 +00:00
|
|
|
bool InventoryObjects::isInInventory(int objectId) const {
|
|
|
|
return (*this)[objectId]._roomNumber == PLAYER_INVENTORY;
|
|
|
|
}
|
2014-03-15 21:38:44 +00:00
|
|
|
|
2014-03-19 04:15:25 +00:00
|
|
|
void InventoryObjects::addToInventory(int objectId) {
|
|
|
|
assert(_inventoryList.size() < 32);
|
|
|
|
UserInterface &userInterface = _vm->_game->_scene._userInterface;
|
|
|
|
|
|
|
|
if (!isInInventory(objectId)) {
|
|
|
|
_inventoryList.push_back(objectId);
|
|
|
|
userInterface._selectedInvIndex = _inventoryList.size() - 1;
|
|
|
|
userInterface._inventoryTopIndex = CLIP(userInterface._inventoryTopIndex,
|
|
|
|
0, (int)_inventoryList.size() - 1);
|
|
|
|
|
2014-04-11 00:06:02 +00:00
|
|
|
if ((userInterface._inventoryTopIndex + 5) <= (int)_inventoryList.size())
|
|
|
|
userInterface._inventoryTopIndex = size() - 4;
|
2014-03-19 04:15:25 +00:00
|
|
|
userInterface._inventoryChanged = true;
|
|
|
|
|
|
|
|
(*this)[objectId]._roomNumber = PLAYER_INVENTORY;
|
|
|
|
|
2014-04-04 02:02:12 +00:00
|
|
|
if (_vm->_game->_kernelMode == KERNEL_ACTIVE_CODE &&
|
|
|
|
_vm->_game->_screenObjects._inputMode == kInputBuildingSentences) {
|
2014-03-19 04:15:25 +00:00
|
|
|
userInterface.categoryChanged();
|
|
|
|
userInterface.selectObject(userInterface._selectedInvIndex);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void InventoryObjects::removeFromInventory(int objectId, int newScene) {
|
|
|
|
Scene &scene = _vm->_game->_scene;
|
|
|
|
UserInterface &userInterface = scene._userInterface;
|
|
|
|
|
|
|
|
// Scan the inventory list for the object
|
|
|
|
int invIndex = -1;
|
|
|
|
for (int idx = 0; idx < (int)_inventoryList.size() && invIndex == -1; ++idx) {
|
|
|
|
if (_inventoryList[idx] == objectId)
|
|
|
|
invIndex = idx;
|
|
|
|
}
|
|
|
|
|
|
|
|
int selectedIndex = userInterface._selectedInvIndex;
|
|
|
|
bool noSelection = selectedIndex < 0;
|
|
|
|
|
2014-04-04 02:02:12 +00:00
|
|
|
if (_vm->_game->_kernelMode == KERNEL_ACTIVE_CODE &&
|
|
|
|
_vm->_game->_screenObjects._inputMode == kInputBuildingSentences)
|
2014-03-19 04:15:25 +00:00
|
|
|
userInterface.selectObject(-1);
|
|
|
|
|
|
|
|
// Remove the item from the inventory list
|
|
|
|
_inventoryList.remove_at(invIndex);
|
|
|
|
|
|
|
|
if (invIndex > userInterface._inventoryTopIndex) {
|
|
|
|
userInterface._inventoryTopIndex = MAX(userInterface._inventoryTopIndex, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
userInterface._inventoryChanged = true;
|
|
|
|
(*this)[objectId]._roomNumber = newScene;
|
|
|
|
|
|
|
|
int newIndex = selectedIndex;
|
|
|
|
if (!noSelection) {
|
|
|
|
if (newIndex >= invIndex)
|
|
|
|
--newIndex;
|
|
|
|
if (newIndex < 0 && size() > 0)
|
|
|
|
newIndex = 0;
|
|
|
|
}
|
|
|
|
|
2014-04-04 02:02:12 +00:00
|
|
|
if (_vm->_game->_kernelMode == KERNEL_ACTIVE_CODE &&
|
|
|
|
_vm->_game->_screenObjects._inputMode == kInputBuildingSentences) {
|
2014-03-19 04:15:25 +00:00
|
|
|
userInterface.categoryChanged();
|
|
|
|
userInterface.selectObject(newIndex);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-04-06 20:32:18 +00:00
|
|
|
int InventoryObjects::getIdFromDesc(int descId) {
|
|
|
|
for (int i = 0; i < (int)size(); ++i) {
|
|
|
|
InventoryObject &obj = (*this)[i];
|
|
|
|
if (obj._descId == descId)
|
|
|
|
return i;
|
|
|
|
}
|
|
|
|
|
|
|
|
return -1;
|
2014-04-05 21:37:10 +00:00
|
|
|
}
|
|
|
|
|
2014-03-15 21:38:44 +00:00
|
|
|
} // End of namespace MADS
|