thirdparty/scummvm
2
0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
scummvm/engines/supernova/state.cpp

1101 lines
32 KiB
C++
Raw Normal View History

SUPERNOVA: Adds missing copyright header
2017-07-11 07:34:04 +02: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.
*
*/
SUPERNOVA: Implements GUI routines and refactors code Of course the short description does not adequately describe the changes made with this commit and I assume this won't be the last big restructuring unfortunately. Focus of this commit was to implement/fix the code so the main user interface can be rendered. Bugs in the core routines for rendering Messages and Images were fixed as well.
2017-07-11 05:33:46 +02:00
SUPERNOVA: Adds tons of stuff Most notably changes are, Handling of object state when calling drawImage() for inverse section rendering Beginning to convert GUI to GuiElements (_guiCommandButton) Mouse Input handling This is still WIP but better than the glitchfest before.
2017-07-17 16:44:08 +02:00
#include "common/system.h"
SUPERNOVA: Implements GUI routines and refactors code Of course the short description does not adequately describe the changes made with this commit and I assume this won't be the last big restructuring unfortunately. Focus of this commit was to implement/fix the code so the main user interface can be rendered. Bugs in the core routines for rendering Messages and Images were fixed as well.
2017-07-11 05:33:46 +02:00
#include "supernova/supernova.h"
#include "supernova/state.h"
namespace Supernova {
Inventory::Inventory()
: _numObjects(0)
{}
// TODO: Update Inventory surface for scrolling
void Inventory::add(Object &obj) {
if (_numObjects < kMaxCarry)
_inventory[_numObjects++] = &obj;
// if (inventory_amount>8) inventory_scroll = ((inventory_amount+1)/2)*2-8;
// show_inventory();
}
// TODO: Update Inventory surface for scrolling
void Inventory::remove(Object &obj) {
SUPERNOVA: Removes warnings for Inventory code
2017-07-17 16:42:13 +02:00
for (int i = 0; i < _numObjects; ++i) {
SUPERNOVA: Implements GUI routines and refactors code Of course the short description does not adequately describe the changes made with this commit and I assume this won't be the last big restructuring unfortunately. Focus of this commit was to implement/fix the code so the main user interface can be rendered. Bugs in the core routines for rendering Messages and Images were fixed as well.
2017-07-11 05:33:46 +02:00
if (_inventory[i] == &obj) {
--_numObjects;
while (i < _numObjects) {
_inventory[i] = _inventory[i + 1];
++i;
}
obj.disableProperty(CARRIED);
}
}
}
SUPERNOVA: Removes warnings for Inventory code
2017-07-17 16:42:13 +02:00
Object *Inventory::get(int index) const {
SUPERNOVA: Implements GUI routines and refactors code Of course the short description does not adequately describe the changes made with this commit and I assume this won't be the last big restructuring unfortunately. Focus of this commit was to implement/fix the code so the main user interface can be rendered. Bugs in the core routines for rendering Messages and Images were fixed as well.
2017-07-11 05:33:46 +02:00
if (index < _numObjects)
return _inventory[index];
SUPERNOVA: Makes Inventory::get() return nullObject
2017-07-18 18:30:50 +02:00
return const_cast<Object *>(&Object::nullObject);
SUPERNOVA: Implements GUI routines and refactors code Of course the short description does not adequately describe the changes made with this commit and I assume this won't be the last big restructuring unfortunately. Focus of this commit was to implement/fix the code so the main user interface can be rendered. Bugs in the core routines for rendering Messages and Images were fixed as well.
2017-07-11 05:33:46 +02:00
}
Object *Inventory::get(ObjectID id) const {
SUPERNOVA: Removes warnings for Inventory code
2017-07-17 16:42:13 +02:00
for (int i = 0; i < _numObjects; ++i) {
SUPERNOVA: Implements GUI routines and refactors code Of course the short description does not adequately describe the changes made with this commit and I assume this won't be the last big restructuring unfortunately. Focus of this commit was to implement/fix the code so the main user interface can be rendered. Bugs in the core routines for rendering Messages and Images were fixed as well.
2017-07-11 05:33:46 +02:00
if (_inventory[i]->_id == id)
return _inventory[i];
}
SUPERNOVA: Makes Inventory::get() return nullObject
2017-07-18 18:30:50 +02:00
return const_cast<Object *>(&Object::nullObject);
SUPERNOVA: Implements GUI routines and refactors code Of course the short description does not adequately describe the changes made with this commit and I assume this won't be the last big restructuring unfortunately. Focus of this commit was to implement/fix the code so the main user interface can be rendered. Bugs in the core routines for rendering Messages and Images were fixed as well.
2017-07-11 05:33:46 +02:00
}
SUPERNOVA: Adds GuiElement Class
2017-07-17 10:33:57 +02:00
GuiElement::GuiElement()
: _text("")
, _isHighlighted(false)
, _bgColorNormal(kColorWhite25)
, _bgColorHighlighted(kColorWhite44)
, _bgColor(kColorWhite25)
, _textColorNormal(kColorGreen)
, _textColorHighlighted(kColorLightGreen)
, _textColor(kColorGreen)
{}
void GuiElement::setText(const char *text) {
strncpy(_text, text, sizeof(_text));
}
void GuiElement::setTextPosition(int x, int y) {
_textPosition.x = x;
_textPosition.y = y;
}
void GuiElement::setSize(int x1, int y1, int x2, int y2) {
this->left = x1;
this->top = y1;
this->right = x2;
this->bottom = y2;
_textPosition.x = x1 + 1;
_textPosition.y = y1 + 1;
}
void GuiElement::setColor(int bgColor, int textColor, int bgColorHighlighted, int textColorHightlighted) {
_bgColor = bgColor;
_textColor = textColor;
_bgColorNormal = bgColor;
_textColorNormal = textColor;
_bgColorHighlighted = bgColorHighlighted;
_textColorHighlighted = textColorHightlighted;
}
void GuiElement::setHighlight(bool isHighlighted) {
if (isHighlighted) {
_bgColor = _bgColorHighlighted;
_textColor = _textColorHighlighted;
} else {
_bgColor = _bgColorNormal;
_textColor = _textColorNormal;
}
}
SUPERNOVA: Implements GUI routines and refactors code Of course the short description does not adequately describe the changes made with this commit and I assume this won't be the last big restructuring unfortunately. Focus of this commit was to implement/fix the code so the main user interface can be rendered. Bugs in the core routines for rendering Messages and Images were fixed as well.
2017-07-11 05:33:46 +02:00
SUPERNOVA: Implements animation The original game's time was stored in 55ms ticks but we just run on milliseconds. setAnimationTimer() sets the ticks the currrent room's animation() function will not be called.
2017-07-25 02:11:00 +02:00
static Common::String timeToString(int t) {
char s[9] = " 0:00:00";
t /= 1000;
SUPERNOVA: Implements GUI routines and refactors code Of course the short description does not adequately describe the changes made with this commit and I assume this won't be the last big restructuring unfortunately. Focus of this commit was to implement/fix the code so the main user interface can be rendered. Bugs in the core routines for rendering Messages and Images were fixed as well.
2017-07-11 05:33:46 +02:00
s[7] = t % 10 + '0';
t /= 10;
s[6] = t % 6 + '0';
t /= 6;
s[4] = t % 10 + '0';
t /= 10;
s[3] = t % 6 + '0';
t /= 6;
s[1] = t % 10 + '0';
t /= 10;
if (t)
SUPERNOVA: Implements animation The original game's time was stored in 55ms ticks but we just run on milliseconds. setAnimationTimer() sets the ticks the currrent room's animation() function will not be called.
2017-07-25 02:11:00 +02:00
s[0] = t + '0';
SUPERNOVA: Implements GUI routines and refactors code Of course the short description does not adequately describe the changes made with this commit and I assume this won't be the last big restructuring unfortunately. Focus of this commit was to implement/fix the code so the main user interface can be rendered. Bugs in the core routines for rendering Messages and Images were fixed as well.
2017-07-11 05:33:46 +02:00
SUPERNOVA: Implements animation The original game's time was stored in 55ms ticks but we just run on milliseconds. setAnimationTimer() sets the ticks the currrent room's animation() function will not be called.
2017-07-25 02:11:00 +02:00
return Common::String(s);
SUPERNOVA: Implements GUI routines and refactors code Of course the short description does not adequately describe the changes made with this commit and I assume this won't be the last big restructuring unfortunately. Focus of this commit was to implement/fix the code so the main user interface can be rendered. Bugs in the core routines for rendering Messages and Images were fixed as well.
2017-07-11 05:33:46 +02:00
}
GameManager::GameManager(SupernovaEngine *vm) {
_rooms[INTRO] = new StartingItems(vm, this);
_rooms[CORRIDOR] = new ShipCorridor(vm, this);
_rooms[HALL] = new ShipHall(vm, this);
_rooms[SLEEP] = new ShipSleepCabin(vm, this);
_rooms[COCKPIT] = new ShipCockpit(vm, this);
_rooms[AIRLOCK] = new ShipAirlock(vm, this);
_rooms[HOLD] = new ShipHold(vm, this);
_rooms[LANDINGMODULE] = new ShipLandingModule(vm, this);
_rooms[GENERATOR] = new ShipGenerator(vm, this);
_rooms[OUTSIDE] = new ShipOuterSpace(vm, this);
_rooms[CABIN_R1] = new ShipCabinR1(vm, this);
_rooms[CABIN_R2] = new ShipCabinR2(vm, this);
_rooms[CABIN_R3] = new ShipCabinR3(vm, this);
_rooms[CABIN_L1] = new ShipCabinL1(vm, this);
_rooms[CABIN_L2] = new ShipCabinL2(vm, this);
_rooms[CABIN_L3] = new ShipCabinL3(vm, this);
_rooms[BATHROOM] = new ShipCabinBathroom(vm, this);
SUERNOVA: Initializes missing rooms on startup
2017-07-25 02:08:55 +02:00
_rooms[ROCKS] = new ArsanoRocks(vm, this);
_rooms[CAVE] = new ArsanoCave(vm, this);
_rooms[MEETUP] = new ArsanoMeetup(vm, this);
_rooms[ENTRANCE] = new ArsanoEntrance(vm, this);
_rooms[REST] = new ArsanoRemaining(vm, this);
_rooms[ROGER] = new ArsanoRoger(vm, this);
_rooms[GLIDER] = new ArsanoGlider(vm, this);
_rooms[MEETUP2] = new ArsanoMeetup2(vm, this);
_rooms[MEETUP3] = new ArsanoMeetup3(vm, this);
_rooms[CELL] = new AxacussCell(vm, this);
_rooms[CORRIDOR1] = new AxacussCorridor1(vm, this);
_rooms[CORRIDOR2] = new AxacussCorridor2(vm, this);
_rooms[CORRIDOR3] = new AxacussCorridor3(vm, this);
_rooms[CORRIDOR4] = new AxacussCorridor3(vm, this);
_rooms[CORRIDOR5] = new AxacussCorridor4(vm, this);
_rooms[CORRIDOR6] = new AxacussCorridor5(vm, this);
_rooms[CORRIDOR7] = new AxacussCorridor6(vm, this);
_rooms[CORRIDOR8] = new AxacussCorridor7(vm, this);
_rooms[CORRIDOR9] = new AxacussCorridor8(vm, this);
_rooms[BCORRIDOR] = new AxacussBcorridor(vm, this);
_rooms[GUARD] = new AxacussIntersection(vm, this);
_rooms[GUARD3] = new AxacussExit(vm, this);
_rooms[OFFICE_L1] = new AxacussOffice1(vm, this);
_rooms[OFFICE_L2] = new AxacussOffice2(vm, this);
_rooms[OFFICE_R1] = new AxacussOffice3(vm, this);
_rooms[OFFICE_R2] = new AxacussOffice4(vm, this);
_rooms[OFFICE_L] = new AxacussOffice5(vm, this);
_rooms[ELEVATOR] = new AxacussElevator(vm, this);
_rooms[STATION] = new AxacussStation(vm, this);
_rooms[SIGN] = new AxacussSign(vm, this);
SUPERNOVA: Implements GUI routines and refactors code Of course the short description does not adequately describe the changes made with this commit and I assume this won't be the last big restructuring unfortunately. Focus of this commit was to implement/fix the code so the main user interface can be rendered. Bugs in the core routines for rendering Messages and Images were fixed as well.
2017-07-11 05:33:46 +02:00
_currentRoom = _rooms[INTRO];
_vm = vm;
SUPERNOVA: Adds tons of stuff Most notably changes are, Handling of object state when calling drawImage() for inverse section rendering Beginning to convert GUI to GuiElements (_guiCommandButton) Mouse Input handling This is still WIP but better than the glitchfest before.
2017-07-17 16:44:08 +02:00
Object::setObjectNull(_currentInputObject);
Object::setObjectNull(_inputObject[0]);
Object::setObjectNull(_inputObject[1]);
SUPERNOVA: Implements GUI routines and refactors code Of course the short description does not adequately describe the changes made with this commit and I assume this won't be the last big restructuring unfortunately. Focus of this commit was to implement/fix the code so the main user interface can be rendered. Bugs in the core routines for rendering Messages and Images were fixed as well.
2017-07-11 05:33:46 +02:00
_inputVerb = ACTION_WALK;
SUPERNOVA: Adds tons of stuff Most notably changes are, Handling of object state when calling drawImage() for inverse section rendering Beginning to convert GUI to GuiElements (_guiCommandButton) Mouse Input handling This is still WIP but better than the glitchfest before.
2017-07-17 16:44:08 +02:00
_processInput = false;
SUPERNOVA: Implements animation The original game's time was stored in 55ms ticks but we just run on milliseconds. setAnimationTimer() sets the ticks the currrent room's animation() function will not be called.
2017-07-25 02:11:00 +02:00
_guiEnabled = true;
_animationEnabled = true;
SUPERNOVA: Adds tons of stuff Most notably changes are, Handling of object state when calling drawImage() for inverse section rendering Beginning to convert GUI to GuiElements (_guiCommandButton) Mouse Input handling This is still WIP but better than the glitchfest before.
2017-07-17 16:44:08 +02:00
_mouseField = -1;
SUPERNOVA: Implements GUI routines and refactors code Of course the short description does not adequately describe the changes made with this commit and I assume this won't be the last big restructuring unfortunately. Focus of this commit was to implement/fix the code so the main user interface can be rendered. Bugs in the core routines for rendering Messages and Images were fixed as well.
2017-07-11 05:33:46 +02:00
_inventoryScroll = 0;
SUPERNOVA: Implements animation The original game's time was stored in 55ms ticks but we just run on milliseconds. setAnimationTimer() sets the ticks the currrent room's animation() function will not be called.
2017-07-25 02:11:00 +02:00
_timer1 = 0;
_animationTimer = 0;
_state.time = 14200;
_state.timeSleep = 0;
_state.timeStarting = 50400000;
_state.timeAlarm = 25200000;
_state.timeAlarmSystem = _state.timeAlarm + _state.timeStarting;
_state.eventTime = 0xffffffff;
_state.shipEnergy = 2135;
_state.landingModuleEnergy = 923;
_state.greatF = 0;
_state.timeRobot = 0;
_state.money = 0;
_state.coins = 0;
_state.shoes = 0;
_state.nameSeen = 0;
_state.destination = 255;
_state.benOverlay = 0;
_state.language = 0;
_state.corridorSearch = false;
_state.alarmOn = false;
_state.terminalStripConnected = false;
_state.terminalStripWire = false;
_state.cableConnected = false;
_state.powerOff = false;
_state.cockpitSeen = false;
_state.airlockSeen = false;
_state.holdSeen = false;
_state.dream = false;
SUPERNOVA: Implements GUI routines and refactors code Of course the short description does not adequately describe the changes made with this commit and I assume this won't be the last big restructuring unfortunately. Focus of this commit was to implement/fix the code so the main user interface can be rendered. Bugs in the core routines for rendering Messages and Images were fixed as well.
2017-07-11 05:33:46 +02:00
initGui();
}
void GameManager::initGui() {
SUPERNOVA: Removes shadowing of variables
2017-07-25 23:40:23 +02:00
int commandButtonX = 0;
SUPERNOVA: Adds tons of stuff Most notably changes are, Handling of object state when calling drawImage() for inverse section rendering Beginning to convert GUI to GuiElements (_guiCommandButton) Mouse Input handling This is still WIP but better than the glitchfest before.
2017-07-17 16:44:08 +02:00
for (int i = 0; i < ARRAYSIZE(_guiCommandButton); ++i) {
SUPERNOVA: Implements GUI routines and refactors code Of course the short description does not adequately describe the changes made with this commit and I assume this won't be the last big restructuring unfortunately. Focus of this commit was to implement/fix the code so the main user interface can be rendered. Bugs in the core routines for rendering Messages and Images were fixed as well.
2017-07-11 05:33:46 +02:00
int width;
if (i < 9)
SUPERNOVA: Renames charcterWidth() to textWidth()
2017-07-18 23:29:12 +02:00
width = _vm->textWidth(guiCommand_DE[i]) + 2;
SUPERNOVA: Implements GUI routines and refactors code Of course the short description does not adequately describe the changes made with this commit and I assume this won't be the last big restructuring unfortunately. Focus of this commit was to implement/fix the code so the main user interface can be rendered. Bugs in the core routines for rendering Messages and Images were fixed as well.
2017-07-11 05:33:46 +02:00
else
SUPERNOVA: Removes shadowing of variables
2017-07-25 23:40:23 +02:00
width = 320 - commandButtonX;
SUPERNOVA: Implements GUI routines and refactors code Of course the short description does not adequately describe the changes made with this commit and I assume this won't be the last big restructuring unfortunately. Focus of this commit was to implement/fix the code so the main user interface can be rendered. Bugs in the core routines for rendering Messages and Images were fixed as well.
2017-07-11 05:33:46 +02:00
SUPERNOVA: Removes shadowing of variables
2017-07-25 23:40:23 +02:00
_guiCommandButton[i].setSize(commandButtonX, 150, commandButtonX + width, 159);
SUPERNOVA: Adds tons of stuff Most notably changes are, Handling of object state when calling drawImage() for inverse section rendering Beginning to convert GUI to GuiElements (_guiCommandButton) Mouse Input handling This is still WIP but better than the glitchfest before.
2017-07-17 16:44:08 +02:00
_guiCommandButton[i].setText(guiCommand_DE[i]);
_guiCommandButton[i].setColor(kColorWhite25, kColorDarkGreen, kColorWhite44, kColorGreen);
SUPERNOVA: Removes shadowing of variables
2017-07-25 23:40:23 +02:00
commandButtonX += width + 2;
SUPERNOVA: Implements GUI routines and refactors code Of course the short description does not adequately describe the changes made with this commit and I assume this won't be the last big restructuring unfortunately. Focus of this commit was to implement/fix the code so the main user interface can be rendered. Bugs in the core routines for rendering Messages and Images were fixed as well.
2017-07-11 05:33:46 +02:00
}
SUPERNOVA: Adds tons of stuff Most notably changes are, Handling of object state when calling drawImage() for inverse section rendering Beginning to convert GUI to GuiElements (_guiCommandButton) Mouse Input handling This is still WIP but better than the glitchfest before.
2017-07-17 16:44:08 +02:00
SUPERNOVA: Converts Inventory as GuiElements By encapsulating the inventory state in GuiElements we can through out inventory_object
2017-07-19 02:45:50 +02:00
for (int i = 0; i < ARRAYSIZE(_guiInventory); ++i) {
SUPERNOVA: Removes shadowing of variables
2017-07-25 23:40:23 +02:00
int inventoryX = 136 * (i % 2);
int inventoryY = 161 + 10 * (i / 2);
SUPERNOVA: Converts Inventory as GuiElements By encapsulating the inventory state in GuiElements we can through out inventory_object
2017-07-19 02:45:50 +02:00
SUPERNOVA: Removes shadowing of variables
2017-07-25 23:40:23 +02:00
_guiInventory[i].setSize(inventoryX, inventoryY, inventoryX + 135, inventoryY + 9);
SUPERNOVA: Converts Inventory as GuiElements By encapsulating the inventory state in GuiElements we can through out inventory_object
2017-07-19 02:45:50 +02:00
_guiInventory[i].setColor(kColorWhite25, kColorDarkRed, kColorWhite35, kColorRed);
}
SUPERNOVA: Implements GUI routines and refactors code Of course the short description does not adequately describe the changes made with this commit and I assume this won't be the last big restructuring unfortunately. Focus of this commit was to implement/fix the code so the main user interface can be rendered. Bugs in the core routines for rendering Messages and Images were fixed as well.
2017-07-11 05:33:46 +02:00
}
SUPERNOVA: Implements animation The original game's time was stored in 55ms ticks but we just run on milliseconds. setAnimationTimer() sets the ticks the currrent room's animation() function will not be called.
2017-07-25 02:11:00 +02:00
SUPERNOVA: Implements GUI routines and refactors code Of course the short description does not adequately describe the changes made with this commit and I assume this won't be the last big restructuring unfortunately. Focus of this commit was to implement/fix the code so the main user interface can be rendered. Bugs in the core routines for rendering Messages and Images were fixed as well.
2017-07-11 05:33:46 +02:00
void GameManager::processInput(Common::KeyState &state) {
switch (state.keycode) {
case Common::KEYCODE_F1:
// help
break;
case Common::KEYCODE_F2:
// show game doc
break;
case Common::KEYCODE_F3:
// show game info
break;
case Common::KEYCODE_F4:
// set text speed
break;
case Common::KEYCODE_F5:
// load/save
break;
case Common::KEYCODE_x:
if (state.flags & Common::KBD_ALT) {
// quit game
_vm->_gameRunning = false;
} else {
_key = state.ascii;
}
break;
default:
_key = state.ascii;
}
}
SUPERNOVA: Adds tons of stuff Most notably changes are, Handling of object state when calling drawImage() for inverse section rendering Beginning to convert GUI to GuiElements (_guiCommandButton) Mouse Input handling This is still WIP but better than the glitchfest before.
2017-07-17 16:44:08 +02:00
void GameManager::resetInputState() {
Object::setObjectNull(_inputObject[0]);
Object::setObjectNull(_inputObject[1]);
_inputVerb = ACTION_WALK;
_processInput = false;
SUPERNOVA: Implements animation The original game's time was stored in 55ms ticks but we just run on milliseconds. setAnimationTimer() sets the ticks the currrent room's animation() function will not be called.
2017-07-25 02:11:00 +02:00
_mouseClicked = false;
_key = 0;
_mouseClickType = Common::EVENT_MOUSEMOVE;
SUPERNOVA: Adds tons of stuff Most notably changes are, Handling of object state when calling drawImage() for inverse section rendering Beginning to convert GUI to GuiElements (_guiCommandButton) Mouse Input handling This is still WIP but better than the glitchfest before.
2017-07-17 16:44:08 +02:00
SUPERNOVA: Implements animation The original game's time was stored in 55ms ticks but we just run on milliseconds. setAnimationTimer() sets the ticks the currrent room's animation() function will not be called.
2017-07-25 02:11:00 +02:00
processInput();
SUPERNOVA: Adds tons of stuff Most notably changes are, Handling of object state when calling drawImage() for inverse section rendering Beginning to convert GUI to GuiElements (_guiCommandButton) Mouse Input handling This is still WIP but better than the glitchfest before.
2017-07-17 16:44:08 +02:00
}
SUPERNOVA: Implements animation The original game's time was stored in 55ms ticks but we just run on milliseconds. setAnimationTimer() sets the ticks the currrent room's animation() function will not be called.
2017-07-25 02:11:00 +02:00
void GameManager::processInput() {
SUPERNOVA: Implements GUI routines and refactors code Of course the short description does not adequately describe the changes made with this commit and I assume this won't be the last big restructuring unfortunately. Focus of this commit was to implement/fix the code so the main user interface can be rendered. Bugs in the core routines for rendering Messages and Images were fixed as well.
2017-07-11 05:33:46 +02:00
if (_mouseClickType == Common::EVENT_LBUTTONUP) {
SUPERNOVA: Adds tons of stuff Most notably changes are, Handling of object state when calling drawImage() for inverse section rendering Beginning to convert GUI to GuiElements (_guiCommandButton) Mouse Input handling This is still WIP but better than the glitchfest before.
2017-07-17 16:44:08 +02:00
_vm->removeMessage();
SUPERNOVA: Corrects left mouse click behavior This still needs work especially concerning actions that need two objects like ACTION_USE or ACTION_GIVE.
2017-07-19 02:50:17 +02:00
if (((_mouseField >= 0) && (_mouseField < 256)) ||
((_mouseField >= 512) && (_mouseField < 768))) {
if (_inputVerb == ACTION_GIVE || _inputVerb == ACTION_USE) {
SUPERNOVA: Implements animation The original game's time was stored in 55ms ticks but we just run on milliseconds. setAnimationTimer() sets the ticks the currrent room's animation() function will not be called.
2017-07-25 02:11:00 +02:00
if (Object::isNullObject(_inputObject[0])) {
SUPERNOVA: Corrects left mouse click behavior This still needs work especially concerning actions that need two objects like ACTION_USE or ACTION_GIVE.
2017-07-19 02:50:17 +02:00
_inputObject[0] = _currentInputObject;
SUPERNOVA: Implements animation The original game's time was stored in 55ms ticks but we just run on milliseconds. setAnimationTimer() sets the ticks the currrent room's animation() function will not be called.
2017-07-25 02:11:00 +02:00
if (!_inputObject[0]->hasProperty(COMBINABLE))
_processInput = true;
} else {
SUPERNOVA: Corrects left mouse click behavior This still needs work especially concerning actions that need two objects like ACTION_USE or ACTION_GIVE.
2017-07-19 02:50:17 +02:00
_inputObject[1] = _currentInputObject;
SUPERNOVA: Implements animation The original game's time was stored in 55ms ticks but we just run on milliseconds. setAnimationTimer() sets the ticks the currrent room's animation() function will not be called.
2017-07-25 02:11:00 +02:00
_processInput = true;
}
SUPERNOVA: Corrects left mouse click behavior This still needs work especially concerning actions that need two objects like ACTION_USE or ACTION_GIVE.
2017-07-19 02:50:17 +02:00
} else {
_inputObject[0] = _currentInputObject;
if (!Object::isNullObject(_currentInputObject))
_processInput = true;
}
} else if (_mouseField >= 256 && _mouseField < 512) {
SUPERNOVA: Adds tons of stuff Most notably changes are, Handling of object state when calling drawImage() for inverse section rendering Beginning to convert GUI to GuiElements (_guiCommandButton) Mouse Input handling This is still WIP but better than the glitchfest before.
2017-07-17 16:44:08 +02:00
resetInputState();
_inputVerb = static_cast<Action>(_mouseField - 256);
SUPERNOVA: Corrects left mouse click behavior This still needs work especially concerning actions that need two objects like ACTION_USE or ACTION_GIVE.
2017-07-19 02:50:17 +02:00
} else if (_mouseField == 768) {
SUPERNOVA: Implements animation The original game's time was stored in 55ms ticks but we just run on milliseconds. setAnimationTimer() sets the ticks the currrent room's animation() function will not be called.
2017-07-25 02:11:00 +02:00
if (_inventoryScroll >= 2)
_inventoryScroll -= 2;
SUPERNOVA: Corrects left mouse click behavior This still needs work especially concerning actions that need two objects like ACTION_USE or ACTION_GIVE.
2017-07-19 02:50:17 +02:00
} else if (_mouseField == 769) {
SUPERNOVA: Implements animation The original game's time was stored in 55ms ticks but we just run on milliseconds. setAnimationTimer() sets the ticks the currrent room's animation() function will not be called.
2017-07-25 02:11:00 +02:00
_inventoryScroll += 2;
SUPERNOVA: Adds tons of stuff Most notably changes are, Handling of object state when calling drawImage() for inverse section rendering Beginning to convert GUI to GuiElements (_guiCommandButton) Mouse Input handling This is still WIP but better than the glitchfest before.
2017-07-17 16:44:08 +02:00
}
SUPERNOVA: Implements GUI routines and refactors code Of course the short description does not adequately describe the changes made with this commit and I assume this won't be the last big restructuring unfortunately. Focus of this commit was to implement/fix the code so the main user interface can be rendered. Bugs in the core routines for rendering Messages and Images were fixed as well.
2017-07-11 05:33:46 +02:00
} else if (_mouseClickType == Common::EVENT_RBUTTONUP) {
SUPERNOVA: Adds tons of stuff Most notably changes are, Handling of object state when calling drawImage() for inverse section rendering Beginning to convert GUI to GuiElements (_guiCommandButton) Mouse Input handling This is still WIP but better than the glitchfest before.
2017-07-17 16:44:08 +02:00
_vm->removeMessage();
if (Object::isNullObject(_currentInputObject))
return;
SUPERNOVA: Implements GUI routines and refactors code Of course the short description does not adequately describe the changes made with this commit and I assume this won't be the last big restructuring unfortunately. Focus of this commit was to implement/fix the code so the main user interface can be rendered. Bugs in the core routines for rendering Messages and Images were fixed as well.
2017-07-11 05:33:46 +02:00
ObjectType type;
if (((_mouseField >= 0) && (_mouseField < 256)) ||
SUPERNOVA: Adds tons of stuff Most notably changes are, Handling of object state when calling drawImage() for inverse section rendering Beginning to convert GUI to GuiElements (_guiCommandButton) Mouse Input handling This is still WIP but better than the glitchfest before.
2017-07-17 16:44:08 +02:00
((_mouseField >= 512) && (_mouseField < 768))) {
_inputObject[0] = _currentInputObject;
SUPERNOVA: Implements GUI routines and refactors code Of course the short description does not adequately describe the changes made with this commit and I assume this won't be the last big restructuring unfortunately. Focus of this commit was to implement/fix the code so the main user interface can be rendered. Bugs in the core routines for rendering Messages and Images were fixed as well.
2017-07-11 05:33:46 +02:00
type = _inputObject[0]->_type;
SUPERNOVA: Corrects OPEN to more descriptive OPENABLE
2017-07-17 16:53:19 +02:00
if (type & OPENABLE) {
SUPERNOVA: Implements GUI routines and refactors code Of course the short description does not adequately describe the changes made with this commit and I assume this won't be the last big restructuring unfortunately. Focus of this commit was to implement/fix the code so the main user interface can be rendered. Bugs in the core routines for rendering Messages and Images were fixed as well.
2017-07-11 05:33:46 +02:00
if (type & OPENED)
_inputVerb = ACTION_CLOSE;
else
_inputVerb = ACTION_OPEN;
} else if (type & PRESS) {
_inputVerb = ACTION_PRESS;
} else if (type & TALK) {
_inputVerb = ACTION_TALK;
} else {
_inputVerb = ACTION_LOOK;
}
SUPERNOVA: Adds tons of stuff Most notably changes are, Handling of object state when calling drawImage() for inverse section rendering Beginning to convert GUI to GuiElements (_guiCommandButton) Mouse Input handling This is still WIP but better than the glitchfest before.
2017-07-17 16:44:08 +02:00
_processInput = true;
SUPERNOVA: Implements GUI routines and refactors code Of course the short description does not adequately describe the changes made with this commit and I assume this won't be the last big restructuring unfortunately. Focus of this commit was to implement/fix the code so the main user interface can be rendered. Bugs in the core routines for rendering Messages and Images were fixed as well.
2017-07-11 05:33:46 +02:00
}
SUPERNOVA: Adds tons of stuff Most notably changes are, Handling of object state when calling drawImage() for inverse section rendering Beginning to convert GUI to GuiElements (_guiCommandButton) Mouse Input handling This is still WIP but better than the glitchfest before.
2017-07-17 16:44:08 +02:00
SUPERNOVA: Implements GUI routines and refactors code Of course the short description does not adequately describe the changes made with this commit and I assume this won't be the last big restructuring unfortunately. Focus of this commit was to implement/fix the code so the main user interface can be rendered. Bugs in the core routines for rendering Messages and Images were fixed as well.
2017-07-11 05:33:46 +02:00
} else if (_mouseClickType == Common::EVENT_MOUSEMOVE) {
SUPERNOVA: Adds tons of stuff Most notably changes are, Handling of object state when calling drawImage() for inverse section rendering Beginning to convert GUI to GuiElements (_guiCommandButton) Mouse Input handling This is still WIP but better than the glitchfest before.
2017-07-17 16:44:08 +02:00
int field = -1;
int click = -1;
SUPERNOVA: Implements GUI routines and refactors code Of course the short description does not adequately describe the changes made with this commit and I assume this won't be the last big restructuring unfortunately. Focus of this commit was to implement/fix the code so the main user interface can be rendered. Bugs in the core routines for rendering Messages and Images were fixed as well.
2017-07-11 05:33:46 +02:00
/* command row? */
SUPERNOVA: Implements animation The original game's time was stored in 55ms ticks but we just run on milliseconds. setAnimationTimer() sets the ticks the currrent room's animation() function will not be called.
2017-07-25 02:11:00 +02:00
if ((_mouseY >= _guiCommandButton[0].top) && (_mouseY <= _guiCommandButton[0].bottom)) {
SUPERNOVA: Implements GUI routines and refactors code Of course the short description does not adequately describe the changes made with this commit and I assume this won't be the last big restructuring unfortunately. Focus of this commit was to implement/fix the code so the main user interface can be rendered. Bugs in the core routines for rendering Messages and Images were fixed as well.
2017-07-11 05:33:46 +02:00
field = 9;
SUPERNOVA: Implements animation The original game's time was stored in 55ms ticks but we just run on milliseconds. setAnimationTimer() sets the ticks the currrent room's animation() function will not be called.
2017-07-25 02:11:00 +02:00
while (_mouseX < _guiCommandButton[field].left - 1)
SUPERNOVA: Implements GUI routines and refactors code Of course the short description does not adequately describe the changes made with this commit and I assume this won't be the last big restructuring unfortunately. Focus of this commit was to implement/fix the code so the main user interface can be rendered. Bugs in the core routines for rendering Messages and Images were fixed as well.
2017-07-11 05:33:46 +02:00
field--;
field += 256;
}
/* exit box? */
SUPERNOVA: Implements animation The original game's time was stored in 55ms ticks but we just run on milliseconds. setAnimationTimer() sets the ticks the currrent room's animation() function will not be called.
2017-07-25 02:11:00 +02:00
else if ((_mouseX >= 283) && (_mouseX <= 317) && (_mouseY >= 163) && (_mouseY <= 197)) {
field = _exitList[(_mouseX - 283) / 7 + 5 * ((_mouseY - 163) / 7)];
SUPERNOVA: Adds tons of stuff Most notably changes are, Handling of object state when calling drawImage() for inverse section rendering Beginning to convert GUI to GuiElements (_guiCommandButton) Mouse Input handling This is still WIP but better than the glitchfest before.
2017-07-17 16:44:08 +02:00
}
SUPERNOVA: Implements GUI routines and refactors code Of course the short description does not adequately describe the changes made with this commit and I assume this won't be the last big restructuring unfortunately. Focus of this commit was to implement/fix the code so the main user interface can be rendered. Bugs in the core routines for rendering Messages and Images were fixed as well.
2017-07-11 05:33:46 +02:00
/* inventory box */
SUPERNOVA: Implements animation The original game's time was stored in 55ms ticks but we just run on milliseconds. setAnimationTimer() sets the ticks the currrent room's animation() function will not be called.
2017-07-25 02:11:00 +02:00
else if ((_mouseY >= 161) && (_mouseX <= 270)) {
field = (_mouseX + 1) / 136 + ((_mouseY - 161) / 10) * 2;
SUPERNOVA: Implements GUI routines and refactors code Of course the short description does not adequately describe the changes made with this commit and I assume this won't be the last big restructuring unfortunately. Focus of this commit was to implement/fix the code so the main user interface can be rendered. Bugs in the core routines for rendering Messages and Images were fixed as well.
2017-07-11 05:33:46 +02:00
if (field + _inventoryScroll < _inventory.getSize())
field += 512;
else
field = -1;
}
/* inventory arrows */
SUPERNOVA: Implements animation The original game's time was stored in 55ms ticks but we just run on milliseconds. setAnimationTimer() sets the ticks the currrent room's animation() function will not be called.
2017-07-25 02:11:00 +02:00
else if ((_mouseY >= 161) && (_mouseX >= 271) && (_mouseX < 279)) {
if (_mouseY > 180)
SUPERNOVA: Adds tons of stuff Most notably changes are, Handling of object state when calling drawImage() for inverse section rendering Beginning to convert GUI to GuiElements (_guiCommandButton) Mouse Input handling This is still WIP but better than the glitchfest before.
2017-07-17 16:44:08 +02:00
field = 769;
else
field = 768;
SUPERNOVA: Implements GUI routines and refactors code Of course the short description does not adequately describe the changes made with this commit and I assume this won't be the last big restructuring unfortunately. Focus of this commit was to implement/fix the code so the main user interface can be rendered. Bugs in the core routines for rendering Messages and Images were fixed as well.
2017-07-11 05:33:46 +02:00
}
/* normal item */
else {
SUPERNOVA: Implements animation The original game's time was stored in 55ms ticks but we just run on milliseconds. setAnimationTimer() sets the ticks the currrent room's animation() function will not be called.
2017-07-25 02:11:00 +02:00
for (int i = 0; (_currentRoom->getObject(i)->_name[0] != '\0') && (field == -1) && i < kMaxObject; i++) {
SUPERNOVA: Implements GUI routines and refactors code Of course the short description does not adequately describe the changes made with this commit and I assume this won't be the last big restructuring unfortunately. Focus of this commit was to implement/fix the code so the main user interface can be rendered. Bugs in the core routines for rendering Messages and Images were fixed as well.
2017-07-11 05:33:46 +02:00
click = _currentRoom->getObject(i)->_click;
if (click != 255) {
MSNImageDecoder::ClickField *clickField = _vm->_currentImage->_clickField;
do {
SUPERNOVA: Implements animation The original game's time was stored in 55ms ticks but we just run on milliseconds. setAnimationTimer() sets the ticks the currrent room's animation() function will not be called.
2017-07-25 02:11:00 +02:00
if ((_mouseX >= clickField[click].x1) && (_mouseX <= clickField[click].x2) &&
(_mouseY >= clickField[click].y1) && (_mouseY <= clickField[click].y2))
SUPERNOVA: Implements GUI routines and refactors code Of course the short description does not adequately describe the changes made with this commit and I assume this won't be the last big restructuring unfortunately. Focus of this commit was to implement/fix the code so the main user interface can be rendered. Bugs in the core routines for rendering Messages and Images were fixed as well.
2017-07-11 05:33:46 +02:00
field = i;
click = clickField[click].next;
} while ((click != 0) && (field == -1));
}
}
SUPERNOVA: Adds tons of stuff Most notably changes are, Handling of object state when calling drawImage() for inverse section rendering Beginning to convert GUI to GuiElements (_guiCommandButton) Mouse Input handling This is still WIP but better than the glitchfest before.
2017-07-17 16:44:08 +02:00
// if ((_objectNumber == 1) && (_currentRoom->getObject(field) == _currentInputObject))
// field = -1;
SUPERNOVA: Implements GUI routines and refactors code Of course the short description does not adequately describe the changes made with this commit and I assume this won't be the last big restructuring unfortunately. Focus of this commit was to implement/fix the code so the main user interface can be rendered. Bugs in the core routines for rendering Messages and Images were fixed as well.
2017-07-11 05:33:46 +02:00
}
SUPERNOVA: Adds tons of stuff Most notably changes are, Handling of object state when calling drawImage() for inverse section rendering Beginning to convert GUI to GuiElements (_guiCommandButton) Mouse Input handling This is still WIP but better than the glitchfest before.
2017-07-17 16:44:08 +02:00
SUPERNOVA: Implements GUI routines and refactors code Of course the short description does not adequately describe the changes made with this commit and I assume this won't be the last big restructuring unfortunately. Focus of this commit was to implement/fix the code so the main user interface can be rendered. Bugs in the core routines for rendering Messages and Images were fixed as well.
2017-07-11 05:33:46 +02:00
if (_mouseField != field) {
if (_mouseField >= 768) {
SUPERNOVA: Adds tons of stuff Most notably changes are, Handling of object state when calling drawImage() for inverse section rendering Beginning to convert GUI to GuiElements (_guiCommandButton) Mouse Input handling This is still WIP but better than the glitchfest before.
2017-07-17 16:44:08 +02:00
inventory_arrow(_mouseField - 768, false);
SUPERNOVA: Implements GUI routines and refactors code Of course the short description does not adequately describe the changes made with this commit and I assume this won't be the last big restructuring unfortunately. Focus of this commit was to implement/fix the code so the main user interface can be rendered. Bugs in the core routines for rendering Messages and Images were fixed as well.
2017-07-11 05:33:46 +02:00
} else if (_mouseField >= 512) {
SUPERNOVA: Converts Inventory as GuiElements By encapsulating the inventory state in GuiElements we can through out inventory_object
2017-07-19 02:45:50 +02:00
_guiInventory[_mouseField - 512].setHighlight(false);
SUPERNOVA: Implements GUI routines and refactors code Of course the short description does not adequately describe the changes made with this commit and I assume this won't be the last big restructuring unfortunately. Focus of this commit was to implement/fix the code so the main user interface can be rendered. Bugs in the core routines for rendering Messages and Images were fixed as well.
2017-07-11 05:33:46 +02:00
} else if (_mouseField >= 256) {
SUPERNOVA: Adds tons of stuff Most notably changes are, Handling of object state when calling drawImage() for inverse section rendering Beginning to convert GUI to GuiElements (_guiCommandButton) Mouse Input handling This is still WIP but better than the glitchfest before.
2017-07-17 16:44:08 +02:00
_guiCommandButton[_mouseField - 256].setHighlight(false);
SUPERNOVA: Implements GUI routines and refactors code Of course the short description does not adequately describe the changes made with this commit and I assume this won't be the last big restructuring unfortunately. Focus of this commit was to implement/fix the code so the main user interface can be rendered. Bugs in the core routines for rendering Messages and Images were fixed as well.
2017-07-11 05:33:46 +02:00
} else if (_mouseField != -1) {
}
SUPERNOVA: Converts Inventory as GuiElements By encapsulating the inventory state in GuiElements we can through out inventory_object
2017-07-19 02:45:50 +02:00
Object::setObjectNull(_currentInputObject);
SUPERNOVA: Adds tons of stuff Most notably changes are, Handling of object state when calling drawImage() for inverse section rendering Beginning to convert GUI to GuiElements (_guiCommandButton) Mouse Input handling This is still WIP but better than the glitchfest before.
2017-07-17 16:44:08 +02:00
SUPERNOVA: Implements GUI routines and refactors code Of course the short description does not adequately describe the changes made with this commit and I assume this won't be the last big restructuring unfortunately. Focus of this commit was to implement/fix the code so the main user interface can be rendered. Bugs in the core routines for rendering Messages and Images were fixed as well.
2017-07-11 05:33:46 +02:00
_mouseField = field;
if (_mouseField >= 768) {
SUPERNOVA: Adds tons of stuff Most notably changes are, Handling of object state when calling drawImage() for inverse section rendering Beginning to convert GUI to GuiElements (_guiCommandButton) Mouse Input handling This is still WIP but better than the glitchfest before.
2017-07-17 16:44:08 +02:00
inventory_arrow(_mouseField - 768, true);
SUPERNOVA: Implements GUI routines and refactors code Of course the short description does not adequately describe the changes made with this commit and I assume this won't be the last big restructuring unfortunately. Focus of this commit was to implement/fix the code so the main user interface can be rendered. Bugs in the core routines for rendering Messages and Images were fixed as well.
2017-07-11 05:33:46 +02:00
} else if (_mouseField >= 512) {
SUPERNOVA: Converts Inventory as GuiElements By encapsulating the inventory state in GuiElements we can through out inventory_object
2017-07-19 02:45:50 +02:00
_guiInventory[_mouseField - 512].setHighlight(true);
SUPERNOVA: Adds tons of stuff Most notably changes are, Handling of object state when calling drawImage() for inverse section rendering Beginning to convert GUI to GuiElements (_guiCommandButton) Mouse Input handling This is still WIP but better than the glitchfest before.
2017-07-17 16:44:08 +02:00
_currentInputObject = _inventory.get(_mouseField - 512 + _inventoryScroll);
SUPERNOVA: Implements GUI routines and refactors code Of course the short description does not adequately describe the changes made with this commit and I assume this won't be the last big restructuring unfortunately. Focus of this commit was to implement/fix the code so the main user interface can be rendered. Bugs in the core routines for rendering Messages and Images were fixed as well.
2017-07-11 05:33:46 +02:00
} else if (_mouseField >= 256) {
SUPERNOVA: Adds tons of stuff Most notably changes are, Handling of object state when calling drawImage() for inverse section rendering Beginning to convert GUI to GuiElements (_guiCommandButton) Mouse Input handling This is still WIP but better than the glitchfest before.
2017-07-17 16:44:08 +02:00
_guiCommandButton[_mouseField - 256].setHighlight(true);
SUPERNOVA: Implements GUI routines and refactors code Of course the short description does not adequately describe the changes made with this commit and I assume this won't be the last big restructuring unfortunately. Focus of this commit was to implement/fix the code so the main user interface can be rendered. Bugs in the core routines for rendering Messages and Images were fixed as well.
2017-07-11 05:33:46 +02:00
} else if (_mouseField != -1) {
SUPERNOVA: Adds tons of stuff Most notably changes are, Handling of object state when calling drawImage() for inverse section rendering Beginning to convert GUI to GuiElements (_guiCommandButton) Mouse Input handling This is still WIP but better than the glitchfest before.
2017-07-17 16:44:08 +02:00
_currentInputObject = _currentRoom->getObject(_mouseField);
SUPERNOVA: Implements GUI routines and refactors code Of course the short description does not adequately describe the changes made with this commit and I assume this won't be the last big restructuring unfortunately. Focus of this commit was to implement/fix the code so the main user interface can be rendered. Bugs in the core routines for rendering Messages and Images were fixed as well.
2017-07-11 05:33:46 +02:00
}
}
SUPERNOVA: Adds tons of stuff Most notably changes are, Handling of object state when calling drawImage() for inverse section rendering Beginning to convert GUI to GuiElements (_guiCommandButton) Mouse Input handling This is still WIP but better than the glitchfest before.
2017-07-17 16:44:08 +02:00
SUPERNOVA: Implements animation The original game's time was stored in 55ms ticks but we just run on milliseconds. setAnimationTimer() sets the ticks the currrent room's animation() function will not be called.
2017-07-25 02:11:00 +02:00
// drawStatus();
SUPERNOVA: Adds tons of stuff Most notably changes are, Handling of object state when calling drawImage() for inverse section rendering Beginning to convert GUI to GuiElements (_guiCommandButton) Mouse Input handling This is still WIP but better than the glitchfest before.
2017-07-17 16:44:08 +02:00
}
}
void GameManager::drawImage(int section) {
bool sectionVisible = true;
if (section > 128) {
sectionVisible = false;
section -= 128;
SUPERNOVA: Implements GUI routines and refactors code Of course the short description does not adequately describe the changes made with this commit and I assume this won't be the last big restructuring unfortunately. Focus of this commit was to implement/fix the code so the main user interface can be rendered. Bugs in the core routines for rendering Messages and Images were fixed as well.
2017-07-11 05:33:46 +02:00
}
SUPERNOVA: Adds tons of stuff Most notably changes are, Handling of object state when calling drawImage() for inverse section rendering Beginning to convert GUI to GuiElements (_guiCommandButton) Mouse Input handling This is still WIP but better than the glitchfest before.
2017-07-17 16:44:08 +02:00
do {
_currentRoom->setSectionVisible(section, sectionVisible);
if (sectionVisible)
_vm->renderImage(_currentRoom->getFileNumber(), section);
else
_vm->renderImage(_currentRoom->getFileNumber(), section + 128);
section = _vm->_currentImage->_section[section].next;
} while (section != 0);
SUPERNOVA: Implements GUI routines and refactors code Of course the short description does not adequately describe the changes made with this commit and I assume this won't be the last big restructuring unfortunately. Focus of this commit was to implement/fix the code so the main user interface can be rendered. Bugs in the core routines for rendering Messages and Images were fixed as well.
2017-07-11 05:33:46 +02:00
}
bool GameManager::isHelmetOff() {
Object *helmet = _inventory.get(HELMET);
if (helmet && helmet->hasProperty(WORN)) {
_vm->renderMessage("Irgendwie ist ein Raumhelm|beim Essen unpraktisch.");
return false;
}
return true;
}
void GameManager::great(uint number) {
if (number && (_state.greatF & (1 << number)))
return;
_vm->playSound(kAudioUndef7);
_state.greatF |= 1 << number;
}
bool GameManager::airless() {
return (
((_currentRoom > _rooms[AIRLOCK]) && (_currentRoom < _rooms[CABIN_R1])) ||
((_currentRoom > _rooms[BATHROOM])&& (_currentRoom < _rooms[ENTRANCE])) ||
((_currentRoom == _rooms[AIRLOCK]) && (_currentRoom->getObject(1)->hasProperty(OPENED))) ||
(_currentRoom >= _rooms[MEETUP2])
);
}
void GameManager::turnOff() {
if (_state.powerOff)
return;
_state.powerOff = true;
roomBrightness();
}
void GameManager::turnOn() {
// STUB
}
void GameManager::takeObject(Object &obj) {
if (obj.hasProperty(CARRIED))
return;
if (obj._section != 0)
SUPERNOVA: Fixes that objects are removed when taken
2017-07-19 02:47:52 +02:00
drawImage(obj._section);
SUPERNOVA: Implements GUI routines and refactors code Of course the short description does not adequately describe the changes made with this commit and I assume this won't be the last big restructuring unfortunately. Focus of this commit was to implement/fix the code so the main user interface can be rendered. Bugs in the core routines for rendering Messages and Images were fixed as well.
2017-07-11 05:33:46 +02:00
obj.setProperty(CARRIED);
obj._click = obj._click2 = 255;
_inventory.add(obj);
}
void GameManager::drawCommandBox() {
SUPERNOVA: Adds tons of stuff Most notably changes are, Handling of object state when calling drawImage() for inverse section rendering Beginning to convert GUI to GuiElements (_guiCommandButton) Mouse Input handling This is still WIP but better than the glitchfest before.
2017-07-17 16:44:08 +02:00
for (int i = 0; i < ARRAYSIZE(_guiCommandButton); ++i) {
_vm->renderBox(_guiCommandButton[i].left,
_guiCommandButton[i].top,
_guiCommandButton[i].width(),
_guiCommandButton[i].height(),
_guiCommandButton[i]._bgColor);
_vm->renderText(_guiCommandButton[i]._text,
_guiCommandButton[i]._textPosition.x,
_guiCommandButton[i]._textPosition.y,
_guiCommandButton[i]._textColor);
}
SUPERNOVA: Implements GUI routines and refactors code Of course the short description does not adequately describe the changes made with this commit and I assume this won't be the last big restructuring unfortunately. Focus of this commit was to implement/fix the code so the main user interface can be rendered. Bugs in the core routines for rendering Messages and Images were fixed as well.
2017-07-11 05:33:46 +02:00
}
void GameManager::inventory_arrow(int num, bool brightness) {
// STUB
}
void GameManager::drawInventory() {
SUPERNOVA: Converts Inventory as GuiElements By encapsulating the inventory state in GuiElements we can through out inventory_object
2017-07-19 02:45:50 +02:00
for (int i = 0; i < ARRAYSIZE(_guiInventory); ++i) {
_vm->renderBox(_guiInventory[i].left,
_guiInventory[i].top,
_guiInventory[i].width(),
_guiInventory[i].height(),
_guiInventory[i]._bgColor);
_vm->renderText(_inventory.get(i + _inventoryScroll)->_name,
_guiInventory[i]._textPosition.x,
_guiInventory[i]._textPosition.y,
_guiInventory[i]._textColor);
SUPERNOVA: Implements GUI routines and refactors code Of course the short description does not adequately describe the changes made with this commit and I assume this won't be the last big restructuring unfortunately. Focus of this commit was to implement/fix the code so the main user interface can be rendered. Bugs in the core routines for rendering Messages and Images were fixed as well.
2017-07-11 05:33:46 +02:00
}
SUPERNOVA: Converts Inventory as GuiElements By encapsulating the inventory state in GuiElements we can through out inventory_object
2017-07-19 02:45:50 +02:00
SUPERNOVA: Implements GUI routines and refactors code Of course the short description does not adequately describe the changes made with this commit and I assume this won't be the last big restructuring unfortunately. Focus of this commit was to implement/fix the code so the main user interface can be rendered. Bugs in the core routines for rendering Messages and Images were fixed as well.
2017-07-11 05:33:46 +02:00
_vm->renderBox(272, 161, 7, 19, HGR_INV);
_vm->renderBox(272, 181, 7, 19, HGR_INV);
}
void GameManager::mouseInput() {
// STUB
}
void GameManager::mouseInput2() {
SUPERNOVA: Implements 'wait for input' Currrently the only implemented scene that uses this function is looking at the monitor in the cockpit. Depending on use cases in other scenes the function needs to be extended.
2017-07-29 11:38:20 +02:00
while (true) {
_vm->updateEvents();
// TODO: handle key input (e.g. alt+x, F-keys?)
if (_mouseClicked || _key) {
break;
}
g_system->updateScreen();
g_system->delayMillis(_vm->_delay);
}
SUPERNOVA: Implements GUI routines and refactors code Of course the short description does not adequately describe the changes made with this commit and I assume this won't be the last big restructuring unfortunately. Focus of this commit was to implement/fix the code so the main user interface can be rendered. Bugs in the core routines for rendering Messages and Images were fixed as well.
2017-07-11 05:33:46 +02:00
}
void GameManager::mouseInput3() {
// STUB
}
void GameManager::mouseWait(int delay) {
// STUB
}
void GameManager::roomBrightness() {
// STUB
}
void GameManager::loadTime() {
// STUB
}
void GameManager::saveTime() {
// STUB
}
bool GameManager::saveGame(int number) {
// STUB
return false;
}
void GameManager::changeRoom(RoomID id) {
_currentRoom = _rooms[id];
}
void GameManager::errorTemp() {
// STUB
}
SUPERNOVA: Implements delay for animations
2017-07-23 12:32:11 +02:00
void GameManager::wait2(int ticks) {
// 1 tick = 1/18.2s
uint end = g_system->getMillis() + (55 * ticks);
while (g_system->getMillis() < end) {
_vm->updateEvents();
g_system->updateScreen();
g_system->delayMillis(_vm->_delay);
}
SUPERNOVA: Implements GUI routines and refactors code Of course the short description does not adequately describe the changes made with this commit and I assume this won't be the last big restructuring unfortunately. Focus of this commit was to implement/fix the code so the main user interface can be rendered. Bugs in the core routines for rendering Messages and Images were fixed as well.
2017-07-11 05:33:46 +02:00
}
SUPERNOVA: Rewrites animation for Cockpit and SleepCabin
2017-07-25 02:03:35 +02:00
void GameManager::setAnimationTimer(int ticks) {
_animationTimer = g_system->getMillis() + (55 * ticks);
}
SUPERNOVA: Implements animation The original game's time was stored in 55ms ticks but we just run on milliseconds. setAnimationTimer() sets the ticks the currrent room's animation() function will not be called.
2017-07-25 02:11:00 +02:00
void GameManager::handleTime() {
_state.time = g_system->getMillis();
if (_animationTimer <= _state.time)
_animationTimer = 0;
}
SUPERNOVA: Implements GUI routines and refactors code Of course the short description does not adequately describe the changes made with this commit and I assume this won't be the last big restructuring unfortunately. Focus of this commit was to implement/fix the code so the main user interface can be rendered. Bugs in the core routines for rendering Messages and Images were fixed as well.
2017-07-11 05:33:46 +02:00
void GameManager::screenShake() {
// STUB
}
void GameManager::palette() {
// STUB
// Adjust palette to brightness parameters and make it current
}
void GameManager::shock() {
// STUB
_vm->playSound(kAudioShock);
// die
}
void GameManager::showMenu() {
_vm->renderBox(0, 138, 320, 62, 0);
_vm->renderBox(0, 140, 320, 9, HGR_BEF_ANZ);
SUPERNOVA: Adds tons of stuff Most notably changes are, Handling of object state when calling drawImage() for inverse section rendering Beginning to convert GUI to GuiElements (_guiCommandButton) Mouse Input handling This is still WIP but better than the glitchfest before.
2017-07-17 16:44:08 +02:00
drawCommandBox();
SUPERNOVA: Implements GUI routines and refactors code Of course the short description does not adequately describe the changes made with this commit and I assume this won't be the last big restructuring unfortunately. Focus of this commit was to implement/fix the code so the main user interface can be rendered. Bugs in the core routines for rendering Messages and Images were fixed as well.
2017-07-11 05:33:46 +02:00
_vm->renderBox(281, 161, 39, 39, HGR_AUSG);
drawInventory();
}
void GameManager::drawMapExits() {
// TODO: Preload _exitList on room entry instead on every call
_vm->renderBox(281, 161, 39, 39, HGR_AUSG);
for (int i = 0; i < 25; i++)
_exitList[i] = -1;
for (int i = 0; i < kMaxObject; i++) {
if (_currentRoom->getObject(i)->hasProperty(EXIT)) {
byte r = _currentRoom->getObject(i)->_direction;
_exitList[r] = i;
int x = 284 + 7 * (r % 5);
int y = 164 + 7 * (r / 5);
_vm->renderBox(x, y, 5, 5, COL_AUSG);
}
}
}
void GameManager::animationOff() {
SUPERNOVA: Implements animation The original game's time was stored in 55ms ticks but we just run on milliseconds. setAnimationTimer() sets the ticks the currrent room's animation() function will not be called.
2017-07-25 02:11:00 +02:00
_animationEnabled = false;
SUPERNOVA: Implements GUI routines and refactors code Of course the short description does not adequately describe the changes made with this commit and I assume this won't be the last big restructuring unfortunately. Focus of this commit was to implement/fix the code so the main user interface can be rendered. Bugs in the core routines for rendering Messages and Images were fixed as well.
2017-07-11 05:33:46 +02:00
}
void GameManager::animationOn() {
SUPERNOVA: Implements animation The original game's time was stored in 55ms ticks but we just run on milliseconds. setAnimationTimer() sets the ticks the currrent room's animation() function will not be called.
2017-07-25 02:11:00 +02:00
_animationEnabled = true;
SUPERNOVA: Implements GUI routines and refactors code Of course the short description does not adequately describe the changes made with this commit and I assume this won't be the last big restructuring unfortunately. Focus of this commit was to implement/fix the code so the main user interface can be rendered. Bugs in the core routines for rendering Messages and Images were fixed as well.
2017-07-11 05:33:46 +02:00
}
void GameManager::edit(char *text, int x, int y, int length) {
// STUB
}
void GameManager::loadOverlayStart() {
// STUB
}
void GameManager::drawStatus() {
int index = static_cast<int>(_inputVerb);
SUPERNOVA: Implements animation The original game's time was stored in 55ms ticks but we just run on milliseconds. setAnimationTimer() sets the ticks the currrent room's animation() function will not be called.
2017-07-25 02:11:00 +02:00
_vm->renderBox(0, 140, 320, 9, kColorWhite25);
_vm->renderText(guiStatusCommand_DE[index], 1, 141, kColorDarkGreen);
SUPERNOVA: Implements GUI routines and refactors code Of course the short description does not adequately describe the changes made with this commit and I assume this won't be the last big restructuring unfortunately. Focus of this commit was to implement/fix the code so the main user interface can be rendered. Bugs in the core routines for rendering Messages and Images were fixed as well.
2017-07-11 05:33:46 +02:00
SUPERNOVA: Adds tons of stuff Most notably changes are, Handling of object state when calling drawImage() for inverse section rendering Beginning to convert GUI to GuiElements (_guiCommandButton) Mouse Input handling This is still WIP but better than the glitchfest before.
2017-07-17 16:44:08 +02:00
if (Object::isNullObject(_inputObject[0])) {
_vm->renderText(_currentInputObject->_name);
} else {
SUPERNOVA: Implements GUI routines and refactors code Of course the short description does not adequately describe the changes made with this commit and I assume this won't be the last big restructuring unfortunately. Focus of this commit was to implement/fix the code so the main user interface can be rendered. Bugs in the core routines for rendering Messages and Images were fixed as well.
2017-07-11 05:33:46 +02:00
_vm->renderText(_inputObject[0]->_name);
SUPERNOVA: Adds tons of stuff Most notably changes are, Handling of object state when calling drawImage() for inverse section rendering Beginning to convert GUI to GuiElements (_guiCommandButton) Mouse Input handling This is still WIP but better than the glitchfest before.
2017-07-17 16:44:08 +02:00
if (_inputVerb == ACTION_GIVE) {
// to
_vm->renderText(" an ");
} else if (_inputVerb == ACTION_USE) {
// with
_vm->renderText(" mit ");
SUPERNOVA: Implements GUI routines and refactors code Of course the short description does not adequately describe the changes made with this commit and I assume this won't be the last big restructuring unfortunately. Focus of this commit was to implement/fix the code so the main user interface can be rendered. Bugs in the core routines for rendering Messages and Images were fixed as well.
2017-07-11 05:33:46 +02:00
}
SUPERNOVA: Adds tons of stuff Most notably changes are, Handling of object state when calling drawImage() for inverse section rendering Beginning to convert GUI to GuiElements (_guiCommandButton) Mouse Input handling This is still WIP but better than the glitchfest before.
2017-07-17 16:44:08 +02:00
_vm->renderText(_currentInputObject->_name);
SUPERNOVA: Implements GUI routines and refactors code Of course the short description does not adequately describe the changes made with this commit and I assume this won't be the last big restructuring unfortunately. Focus of this commit was to implement/fix the code so the main user interface can be rendered. Bugs in the core routines for rendering Messages and Images were fixed as well.
2017-07-11 05:33:46 +02:00
}
}
void GameManager::openLocker(const Room *room, Object *obj, Object *lock, int section) {
SUPERNOVA: Implements animation The original game's time was stored in 55ms ticks but we just run on milliseconds. setAnimationTimer() sets the ticks the currrent room's animation() function will not be called.
2017-07-25 02:11:00 +02:00
drawImage(section);
SUPERNOVA: Implements GUI routines and refactors code Of course the short description does not adequately describe the changes made with this commit and I assume this won't be the last big restructuring unfortunately. Focus of this commit was to implement/fix the code so the main user interface can be rendered. Bugs in the core routines for rendering Messages and Images were fixed as well.
2017-07-11 05:33:46 +02:00
obj->setProperty(OPENED);
lock->_click = 255;
int i = obj->_click;
obj->_click = obj->_click2;
obj->_click2 = i;
}
void GameManager::closeLocker(const Room *room, Object *obj, Object *lock, int section) {
SUPERNOVA: Implements animation The original game's time was stored in 55ms ticks but we just run on milliseconds. setAnimationTimer() sets the ticks the currrent room's animation() function will not be called.
2017-07-25 02:11:00 +02:00
if (!obj->hasProperty(OPENED)) {
_vm->renderMessage("Das ist schon geschlossen.");
} else {
drawImage(invertSection(section));
obj->disableProperty(OPENED);
lock->_click = lock->_click2;
int i = obj->_click;
obj->_click = obj->_click2;
obj->_click2 = i;
}
SUPERNOVA: Implements GUI routines and refactors code Of course the short description does not adequately describe the changes made with this commit and I assume this won't be the last big restructuring unfortunately. Focus of this commit was to implement/fix the code so the main user interface can be rendered. Bugs in the core routines for rendering Messages and Images were fixed as well.
2017-07-11 05:33:46 +02:00
}
int GameManager::invertSection(int section) {
if (section < 128)
section += 128;
else
section -= 128;
return section;
}
bool GameManager::genericInteract(Action verb, Object &obj1, Object &obj2) {
Room *r;
char t[150];
if ((verb == ACTION_USE) && (obj1._id == SCHNUCK)) {
if (isHelmetOff()) {
takeObject(obj1);
_vm->renderMessage("Schmeckt ganz gut.");
_inventory.remove(obj1);
}
} else if ((verb == ACTION_USE) && (obj1._id == EGG)) {
if (isHelmetOff()) {
takeObject(obj1);
if (obj1.hasProperty(OPENED))
_vm->renderMessage("Schmeckt ganz gut.");
else
_vm->renderMessage("Da war irgendetwas drin,|aber jetzt hast du es|mit runtergeschluckt.");
_inventory.remove(obj1);
}
} else if ((verb == ACTION_OPEN) && (obj1._id == EGG)) {
takeObject(obj1);
if (obj1.hasProperty(OPENED)) {
_vm->renderMessage("Du hast es doch schon ge”ffnet.");
} else {
takeObject(*_rooms[ENTRANCE]->getObject(8));
_vm->renderMessage("In dem Ei ist eine Tablette|in einer Plastikhlle.");
obj1.setProperty(OPENED);
}
} else if ((verb == ACTION_USE) && (obj1._id == PILL)) {
if (isHelmetOff()) {
_vm->renderMessage("Du iát die Tablette und merkst,|daá sich irgendetwas ver„ndert hat.");
great(0);
_inventory.remove(obj1);
_state.language = 2;
takeObject(*_rooms[ENTRANCE]->getObject(17));
}
} else if ((verb == ACTION_LOOK) && (obj1._id == PILL_HULL) &&
(_state.language == 2)) {
_vm->renderMessage("Komisch! Auf einmal kannst du die Schrift lesen!|Darauf steht:\"Wenn Sie diese Schrift jetzt|lesen k”nnen, hat die Tablette gewirkt.\"");
_state.language = 1;
} else if ((verb == ACTION_OPEN) && (obj1._id == WALLET)) {
if (!_rooms[ROGER]->getObject(3)->hasProperty(CARRIED)) {
_vm->renderMessage("Das muát du erst nehmen.");
} else if (_rooms[ROGER]->getObject(7)->hasProperty(CARRIED)) {
_vm->renderMessage("Sie ist leer.");
} else {
_vm->renderMessage("Du findest 10 Buckazoids und eine Keycard.");
takeObject(*_rooms[ROGER]->getObject(7));
takeObject(*_rooms[ROGER]->getObject(8));
}
} else if ((verb == ACTION_LOOK) && (obj1._id == NEWSPAPER)) {
_vm->renderMessage("Es ist eine Art elektronische Zeitung.");
mouseWait(_timer1);
_vm->removeMessage();
_vm->renderMessage("Halt, hier ist ein interessanter Artikel.");
mouseWait(_timer1);
_vm->removeMessage();
SUPERNOVA: Adds tons of stuff Most notably changes are, Handling of object state when calling drawImage() for inverse section rendering Beginning to convert GUI to GuiElements (_guiCommandButton) Mouse Input handling This is still WIP but better than the glitchfest before.
2017-07-17 16:44:08 +02:00
// TODO: Implement a 'newspaper room' to eliminate handling
// those cases seperately
_vm->renderImage(2, 0);
SUPERNOVA: Implements GUI routines and refactors code Of course the short description does not adequately describe the changes made with this commit and I assume this won't be the last big restructuring unfortunately. Focus of this commit was to implement/fix the code so the main user interface can be rendered. Bugs in the core routines for rendering Messages and Images were fixed as well.
2017-07-11 05:33:46 +02:00
_vm->setColor63(40);
mouseInput2();
_vm->renderRoom(*_currentRoom);
roomBrightness();
palette();
showMenu();
drawMapExits();
_vm->renderMessage("Hmm, irgendwie komme|ich mir verarscht vor.");
} else if ((verb == ACTION_LOOK) && (obj1._id == KEYCARD2)) {
_vm->renderMessage(obj1._description);
obj1._description = "Es ist die Keycard des Commanders.";
} else if ((verb == ACTION_LOOK) && (obj1._id == WATCH)) {
_vm->renderMessage(Common::String::format(
"Es ist eine Uhr mit extra|lautem Wecker. "
"Sie hat einen|Knopf zum Verstellen der Alarmzeit.|"
"Uhrzeit: %s Alarmzeit: %s",
SUPERNOVA: Implements animation The original game's time was stored in 55ms ticks but we just run on milliseconds. setAnimationTimer() sets the ticks the currrent room's animation() function will not be called.
2017-07-25 02:11:00 +02:00
timeToString(_state.time + _state.timeStarting).c_str(),
timeToString(_state.timeAlarm).c_str()).c_str());
SUPERNOVA: Implements GUI routines and refactors code Of course the short description does not adequately describe the changes made with this commit and I assume this won't be the last big restructuring unfortunately. Focus of this commit was to implement/fix the code so the main user interface can be rendered. Bugs in the core routines for rendering Messages and Images were fixed as well.
2017-07-11 05:33:46 +02:00
} else if ((verb == ACTION_PRESS) && (obj1._id == WATCH)) {
char *min;
int hours, minutes;
bool f;
animationOff();
_vm->saveScreen(88, 87, 144, 24);
_vm->renderBox(88, 87, 144, 24, kColorWhite35);
_vm->renderText("Neue Alarmzeit (hh:mm) :", 91, 90, kColorWhite99);
do {
t[0] = 0;
_vm->renderBox(91, 99, 138, 9, kColorDarkBlue);
do {
edit(t, 91, 100, 5);
} while ((_key != Common::ASCII_RETURN) && (_key != Common::ASCII_ESCAPE));
f = false;
if (t[0] == ':') {
t[0] = 0;
min = &(t[1]);
} else if (t[1] == ':') {
t[1] = 0;
min = &(t[2]);
} else if (t[2] == ':') {
t[2] = 0;
min = &(t[3]);
} else {
f = true;
}
for (uint i = 0; i < strlen(t); i++)
if ((t[i] < '0') || (t[i] > '9')) f = true;
for (uint i = 0; i < strlen(min); i++)
if ((min[i] < '0') || (min[i] > '9')) f = true;
hours = atoi(t);
minutes = atoi(min);
if ((hours > 23) || (minutes > 59)) f = true;
animationOn();
} while (f && (_key != Common::ASCII_ESCAPE));
_vm->restoreScreen();
if (_key != Common::ASCII_ESCAPE) {
_state.timeAlarm = (hours * 60 + minutes) * 1092.3888 + 8;
_state.timeAlarmSystem = _state.timeAlarm + _state.timeStarting;
_state.alarmOn = (_state.timeAlarmSystem > _vm->getDOSTicks());
}
} else if ((verb == ACTION_USE) && Object::combine(obj1, obj2, TERMINALSTRIP, WIRE)) {
r = _rooms[CABIN_L3];
if (!r->getObject(8)->hasProperty(CARRIED)) {
if (r->isSectionVisible(26))
_vm->renderMessage(Object::takeMessage);
else
return false;
} else {
r->getObject(8)->_name = "Leitung mit Lsterklemme";
r = _rooms[HOLD];
_inventory.remove(*r->getObject(2));
_state.terminalStripConnected = true;
_state.terminalStripWire = true;
_vm->renderMessage("Ok.");
}
} else if ((verb == ACTION_USE) && Object::combine(obj1, obj2, TERMINALSTRIP, SPOOL)) {
r = _rooms[CABIN_L2];
takeObject(*r->getObject(9));
r->getObject(9)->_name = "Kabelrolle mit Lsterklemme";
r = _rooms[HOLD];
_inventory.remove(*r->getObject(2));
_state.terminalStripConnected = true;
_vm->renderMessage("Ok.");
} else if ((verb == ACTION_USE) && Object::combine(obj1, obj2, WIRE, SPOOL)) {
r = _rooms[CABIN_L3];
if (!_state.terminalStripConnected) {
if (r->isSectionVisible(26))
_vm->renderMessage("Womit denn?");
else
return false;
} else {
if (!r->getObject(8)->hasProperty(CARRIED)) {
_vm->renderMessage(Object::takeMessage);
} else {
r = _rooms[CABIN_L2];
takeObject(*r->getObject(9));
r = _rooms[CABIN_L3];
r->getObject(8)->_name = "langes Kabel mit Stecker";
r = _rooms[CABIN_L2];
_inventory.remove(*r->getObject(9));
_state.cableConnected = true;
_vm->renderMessage("Ok.");
}
}
} else if ((verb == ACTION_USE) && (obj1._id == SUIT)) {
takeObject(obj1);
if ((_currentRoom >= _rooms[ENTRANCE]) && (_currentRoom <= _rooms[ROGER])) {
if (obj1.hasProperty(WORN)) {
_vm->renderMessage("Die Luft hier ist atembar,|du ziehst den Anzug aus.");
_rooms[AIRLOCK]->getObject(4)->disableProperty(WORN);
_rooms[AIRLOCK]->getObject(5)->disableProperty(WORN);
_rooms[AIRLOCK]->getObject(6)->disableProperty(WORN);
} else
_vm->renderMessage("Hier drinnen brauchtst du deinen Anzug nicht.");
} else {
if (obj1.hasProperty(WORN)) {
r = _rooms[AIRLOCK];
if (r->getObject(4)->hasProperty(WORN)) {
_vm->renderMessage("Du muát erst den Helm abnehmen.");
} else if (r->getObject(6)->hasProperty(WORN)) {
_vm->renderMessage("Du muát erst den Versorgungsteil abnehmen.");
} else {
obj1.disableProperty(WORN);
_vm->renderMessage("Du ziehst den Raumanzug aus.");
}
} else {
obj1.setProperty(WORN);
_vm->renderMessage("Du ziehst den Raumanzug an.");
}
}
} else if ((verb == ACTION_USE) && (obj1._id == HELMET)) {
takeObject(obj1);
if ((_currentRoom >= _rooms[ENTRANCE]) && (_currentRoom <= _rooms[ROGER])) {
if (obj1.hasProperty(WORN)) {
_vm->renderMessage("Die Luft hier ist atembar,|du ziehst den Anzug aus.");
_rooms[AIRLOCK]->getObject(4)->disableProperty(WORN);
_rooms[AIRLOCK]->getObject(5)->disableProperty(WORN);
_rooms[AIRLOCK]->getObject(6)->disableProperty(WORN);
} else {
_vm->renderMessage("Hier drinnen brauchtst du deinen Anzug nicht.");
}
} else {
if (obj1.hasProperty(WORN)) {
if (airless()) {
//TODO: Death screen
// longjmp(dead, "Den Helm h„ttest du|besser angelassen!");
}
obj1.disableProperty(WORN);
_vm->renderMessage("Du ziehst den Helm ab.");
} else {
r = _rooms[AIRLOCK];
if (r->getObject(5)->hasProperty(WORN)) {
obj1.setProperty(WORN);
_vm->renderMessage("Du ziehst den Helm auf.");
} else {
_vm->renderMessage("Du muát erst den Anzug anziehen.");
}
}
}
} else if ((verb == ACTION_USE) && (obj1._id == LIFESUPPORT)) {
takeObject(obj1);
if ((_currentRoom >= _rooms[ENTRANCE]) && (_currentRoom <= _rooms[ROGER])) {
if (obj1.hasProperty(WORN)) {
_vm->renderMessage("Die Luft hier ist atembar,|du ziehst den Anzug aus.");
_rooms[AIRLOCK]->getObject(4)->disableProperty(WORN);
_rooms[AIRLOCK]->getObject(5)->disableProperty(WORN);
_rooms[AIRLOCK]->getObject(6)->disableProperty(WORN);
} else
_vm->renderMessage("Hier drinnen brauchtst du deinen Anzug nicht.");
} else {
if (obj1.hasProperty(WORN)) {
if (airless()) {
//TODO: Death screen
// longjmp(dead, "Den Versorungsteil h„ttest du|besser nicht abgenommen!");
}
obj1.disableProperty(WORN);
_vm->renderMessage("Du nimmst den Versorgungsteil ab.");
} else {
r = _rooms[AIRLOCK];
if (r->getObject(5)->hasProperty(WORN)) {
obj1.setProperty(WORN);
_vm->renderMessage("Du ziehst den Versorgungsteil an.");
} else {
_vm->renderMessage("Du muát erst den Anzug anziehen.");
}
}
}
} else if ((verb == ACTION_WALK) && (obj1._id == BATHROOM_DOOR)) {
// *bathroom = current_room;
return false;
} else if ((verb == ACTION_USE) && Object::combine(obj1, obj2, WIRE, SOCKET))
_vm->renderMessage("Die Leitung ist hier unntz.");
else if ((verb == ACTION_LOOK) && (obj1._id == BOOK2)) {
_vm->renderMessage("Stark, das ist ja die Fortsetzung zum \"Anhalter\":|\"Das Restaurant am Ende des Universums\".");
mouseWait(_timer1);
_vm->removeMessage();
_vm->renderMessage("Moment mal, es ist ein Lesezeichen drin,|auf dem \"Zweiundvierzig\" steht.");
} else {
return false;
}
return true;
}
SUPERNOVA: Implements animation The original game's time was stored in 55ms ticks but we just run on milliseconds. setAnimationTimer() sets the ticks the currrent room's animation() function will not be called.
2017-07-25 02:11:00 +02:00
void GameManager::handleInput() {
SUPERNOVA: Adds tons of stuff Most notably changes are, Handling of object state when calling drawImage() for inverse section rendering Beginning to convert GUI to GuiElements (_guiCommandButton) Mouse Input handling This is still WIP but better than the glitchfest before.
2017-07-17 16:44:08 +02:00
bool validCommand = genericInteract(_inputVerb, *_inputObject[0], *_inputObject[1]);
if (!validCommand)
SUPERNOVA: Implements GUI routines and refactors code Of course the short description does not adequately describe the changes made with this commit and I assume this won't be the last big restructuring unfortunately. Focus of this commit was to implement/fix the code so the main user interface can be rendered. Bugs in the core routines for rendering Messages and Images were fixed as well.
2017-07-11 05:33:46 +02:00
validCommand = _currentRoom->interact(_inputVerb, *_inputObject[0], *_inputObject[1]);
SUPERNOVA: Adds tons of stuff Most notably changes are, Handling of object state when calling drawImage() for inverse section rendering Beginning to convert GUI to GuiElements (_guiCommandButton) Mouse Input handling This is still WIP but better than the glitchfest before.
2017-07-17 16:44:08 +02:00
if (!validCommand) {
switch (_inputVerb) {
case ACTION_LOOK:
_vm->renderMessage(_inputObject[0]->_description);
break;
case ACTION_WALK:
if (_inputObject[0]->hasProperty(CARRIED)) {
// You already carry this.
_vm->renderMessage("Das tr„gst du doch bei dir.");
} else if (!_inputObject[0]->hasProperty(EXIT)) {
// You're already there.
_vm->renderMessage("Du bist doch schon da.");
SUPERNOVA: Corrects OPEN to more descriptive OPENABLE
2017-07-17 16:53:19 +02:00
} else if (_inputObject[0]->hasProperty(OPENABLE) && !_inputObject[0]->hasProperty(OPENED)) {
SUPERNOVA: Adds tons of stuff Most notably changes are, Handling of object state when calling drawImage() for inverse section rendering Beginning to convert GUI to GuiElements (_guiCommandButton) Mouse Input handling This is still WIP but better than the glitchfest before.
2017-07-17 16:44:08 +02:00
// This is closed
_vm->renderMessage("Das ist geschlossen.");
} else {
changeRoom(_inputObject[0]->_exitRoom);
SUPERNOVA: Implements GUI routines and refactors code Of course the short description does not adequately describe the changes made with this commit and I assume this won't be the last big restructuring unfortunately. Focus of this commit was to implement/fix the code so the main user interface can be rendered. Bugs in the core routines for rendering Messages and Images were fixed as well.
2017-07-11 05:33:46 +02:00
}
SUPERNOVA: Adds tons of stuff Most notably changes are, Handling of object state when calling drawImage() for inverse section rendering Beginning to convert GUI to GuiElements (_guiCommandButton) Mouse Input handling This is still WIP but better than the glitchfest before.
2017-07-17 16:44:08 +02:00
break;
case ACTION_TAKE:
if (_inputObject[0]->hasProperty(OPENED)) {
// You already have that
_vm->renderMessage("Das hast du doch schon.");
} else if (_inputObject[0]->hasProperty(UNNECESSARY)) {
// You do not need that.
_vm->renderMessage("Das brauchst du nicht.");
} else if (!_inputObject[0]->hasProperty(TAKE)) {
// You can't take that.
_vm->renderMessage("Das kannst du nicht nehmen.");
} else {
takeObject(*_inputObject[0]);
SUPERNOVA: Implements GUI routines and refactors code Of course the short description does not adequately describe the changes made with this commit and I assume this won't be the last big restructuring unfortunately. Focus of this commit was to implement/fix the code so the main user interface can be rendered. Bugs in the core routines for rendering Messages and Images were fixed as well.
2017-07-11 05:33:46 +02:00
}
SUPERNOVA: Adds tons of stuff Most notably changes are, Handling of object state when calling drawImage() for inverse section rendering Beginning to convert GUI to GuiElements (_guiCommandButton) Mouse Input handling This is still WIP but better than the glitchfest before.
2017-07-17 16:44:08 +02:00
break;
case ACTION_OPEN:
SUPERNOVA: Corrects OPEN to more descriptive OPENABLE
2017-07-17 16:53:19 +02:00
if (!_inputObject[0]->hasProperty(OPENABLE)) {
SUPERNOVA: Adds tons of stuff Most notably changes are, Handling of object state when calling drawImage() for inverse section rendering Beginning to convert GUI to GuiElements (_guiCommandButton) Mouse Input handling This is still WIP but better than the glitchfest before.
2017-07-17 16:44:08 +02:00
// This can't be opened
_vm->renderMessage("Das l„át sich nicht ”ffnen.");
} else if (_inputObject[0]->hasProperty(OPENED)) {
// This is already opened.
_vm->renderMessage("Das ist schon offen.");
} else if (_inputObject[0]->hasProperty(CLOSED)) {
// This is locked.
_vm->renderMessage("Das ist verschlossen.");
} else {
drawImage(_inputObject[0]->_section);
_inputObject[0]->setProperty(OPENED);
byte i = _inputObject[0]->_click;
_inputObject[0]->_click = _inputObject[0]->_click2;
_inputObject[0]->_click2 = i;
_vm->playSound(kAudioDoorOpen);
SUPERNOVA: Implements GUI routines and refactors code Of course the short description does not adequately describe the changes made with this commit and I assume this won't be the last big restructuring unfortunately. Focus of this commit was to implement/fix the code so the main user interface can be rendered. Bugs in the core routines for rendering Messages and Images were fixed as well.
2017-07-11 05:33:46 +02:00
}
SUPERNOVA: Adds tons of stuff Most notably changes are, Handling of object state when calling drawImage() for inverse section rendering Beginning to convert GUI to GuiElements (_guiCommandButton) Mouse Input handling This is still WIP but better than the glitchfest before.
2017-07-17 16:44:08 +02:00
break;
case ACTION_CLOSE:
SUPERNOVA: Corrects OPEN to more descriptive OPENABLE
2017-07-17 16:53:19 +02:00
if (!_inputObject[0]->hasProperty(OPENABLE) ||
SUPERNOVA: Adds tons of stuff Most notably changes are, Handling of object state when calling drawImage() for inverse section rendering Beginning to convert GUI to GuiElements (_guiCommandButton) Mouse Input handling This is still WIP but better than the glitchfest before.
2017-07-17 16:44:08 +02:00
(_inputObject[0]->hasProperty(CLOSED) &&
_inputObject[0]->hasProperty(OPENED))) {
// This can't be closed.
_vm->renderMessage("Das l„át sich nicht schlieáen.");
} else if (!_inputObject[0]->hasProperty(OPENED)) {
// This is already closed.
_vm->renderMessage("Das ist schon geschlossen.");
} else {
drawImage(invertSection(_inputObject[0]->_section));
_inputObject[0]->disableProperty(OPENED);
byte i = _inputObject[0]->_click;
_inputObject[0]->_click = _inputObject[0]->_click2;
_inputObject[0]->_click2 = i;
_vm->playSound(kAudioDoorClose);
}
break;
case ACTION_GIVE:
if (_inputObject[0]->hasProperty(CARRIED)) {
// Better keep it!
_vm->renderMessage("Behalt es lieber!");
}
break;
default:
// This is not possible.
_vm->renderMessage("Das geht nicht.");
}
SUPERNOVA: Implements animation The original game's time was stored in 55ms ticks but we just run on milliseconds. setAnimationTimer() sets the ticks the currrent room's animation() function will not be called.
2017-07-25 02:11:00 +02:00
}
}
SUPERNOVA: Adds tons of stuff Most notably changes are, Handling of object state when calling drawImage() for inverse section rendering Beginning to convert GUI to GuiElements (_guiCommandButton) Mouse Input handling This is still WIP but better than the glitchfest before.
2017-07-17 16:44:08 +02:00
SUPERNOVA: Implements animation The original game's time was stored in 55ms ticks but we just run on milliseconds. setAnimationTimer() sets the ticks the currrent room's animation() function will not be called.
2017-07-25 02:11:00 +02:00
void GameManager::executeRoom() {
SUPERNOVA: Gets input before drawing calls; Before the status line would show invalid input for a frame what was especially annoying during animations, as they currently tend to block the game loop for their duration.
2017-07-25 13:50:42 +02:00
if (_processInput && !_vm->_messageDisplayed && _guiEnabled) {
handleInput();
resetInputState();
}
SUPERNOVA: Implements animation The original game's time was stored in 55ms ticks but we just run on milliseconds. setAnimationTimer() sets the ticks the currrent room's animation() function will not be called.
2017-07-25 02:11:00 +02:00
if (_guiEnabled) {
if (!_vm->_messageDisplayed) {
g_system->fillScreen(kColorBlack);
_vm->renderRoom(*_currentRoom);
SUPERNOVA: Implements GUI routines and refactors code Of course the short description does not adequately describe the changes made with this commit and I assume this won't be the last big restructuring unfortunately. Focus of this commit was to implement/fix the code so the main user interface can be rendered. Bugs in the core routines for rendering Messages and Images were fixed as well.
2017-07-11 05:33:46 +02:00
}
SUPERNOVA: Implements animation The original game's time was stored in 55ms ticks but we just run on milliseconds. setAnimationTimer() sets the ticks the currrent room's animation() function will not be called.
2017-07-25 02:11:00 +02:00
drawMapExits();
drawInventory();
drawStatus();
drawCommandBox();
}
roomBrightness();
if (_vm->_brightness == 0)
_vm->paletteFadeIn();
else
_vm->paletteBrightness();
if (!_currentRoom->hasSeen())
_currentRoom->onEntrance();
SUPERNOVA: Implements GUI routines and refactors code Of course the short description does not adequately describe the changes made with this commit and I assume this won't be the last big restructuring unfortunately. Focus of this commit was to implement/fix the code so the main user interface can be rendered. Bugs in the core routines for rendering Messages and Images were fixed as well.
2017-07-11 05:33:46 +02:00
}
}
Reference in a new issue Copy permalink