void CompositeViewer::frameStart( const uint32_t frameNumber,
const FrameData& frameData )
{
//LBINFO << "-----> Viewer::frameStart(" << frameNumber << ")" << std::endl;
advance( frameNumber, frameData );
eventTraversal( );
updateTraversal( );
Scenes scenes;
getScenes( scenes );
for( Scenes::iterator sitr = scenes.begin( );
sitr != scenes.end( ); ++sitr)
{
osgViewer::Scene* scene = *sitr;
osg::ref_ptr< osgDB::DatabasePager > dp = scene ?
scene->getDatabasePager( ) : 0;
if( dp.valid( ))
dp->signalBeginFrame( getViewerFrameStamp( ));
osg::ref_ptr< osg::Node > sceneData = scene ?
scene->getSceneData( ) : 0;
if( sceneData.valid( ))
sceneData->getBound( );
}
//LBINFO << "<----- Viewer::frameStart(" << frameNumber << ")" << std::endl;
}
void Objects::update(ObjectIndex index, EntityIndex entity, ObjectLocation status, CursorStyle windowCursor, CursorStyle handleCursor) {
if (index >= kObjectMax)
return;
Object *object = &_objects[index];
// Store original location
ObjectLocation original_status = object->status;
// Update entity
object->entity = entity;
object->status = status;
if (windowCursor != kCursorKeepValue || handleCursor != kCursorKeepValue) {
if (windowCursor != kCursorKeepValue)
object->windowCursor = windowCursor;
if (handleCursor != kCursorKeepValue)
object->handleCursor = handleCursor;
getLogic()->updateCursor();
}
getFlags()->flag_3 = true;
// Compartments
if (original_status != status && (original_status == kObjectLocation2 || status == kObjectLocation2)) {
if ((index >= kObjectCompartment1 && index <= kObjectCompartment8)
|| (index >= kObjectCompartmentA && index <= kObjectCompartmentF)) {
getScenes()->updateDoorsAndClock();
}
}
}
void Objects::update(ObjectIndex index, EntityIndex entity, ObjectLocation location, CursorStyle cursor, CursorStyle cursor2) {
if (index >= kObjectMax)
return;
Object *object = &_objects[index];
// Store original location
ObjectLocation original_location = object->location;
// Update entity
object->entity = entity;
object->location = location;
if (cursor != kCursorKeepValue || cursor2 != kCursorKeepValue) {
if (cursor != kCursorKeepValue)
object->cursor = cursor;
if (cursor2 != kCursorKeepValue)
object->cursor2 = cursor2;
getLogic()->updateCursor();
}
getFlags()->flag_3 = true;
// Compartments
if (original_location != location && (original_location == kObjectLocation2 || location == kObjectLocation2))
if ((index >= kObjectCompartment1 && index <= kObjectCompartment8)
|| (index >= kObjectCompartmentA && index <= kObjectCompartmentF)) {
getScenes()->updateDoorsAndClock();
}
}
void Menu::adjustTime() {
uint32 originalTime = _time;
// Adjust time delta
Common::Rational timeDelta(_delta >= 90 ? 9 : (9 * _delta + 89), _delta >= 90 ? 1 : 90);
if (_currentTime < _time) {
timeDelta *= 900;
_time -= timeDelta.toInt();
if (_currentTime > _time)
_time = _currentTime;
} else {
timeDelta *= 900;
_time += timeDelta.toInt();
if (_currentTime < _time)
_time = _currentTime;
}
if (_currentTime == _time && getSound()->isBuffered(kEntityChapters))
getSound()->removeFromQueue(kEntityChapters);
_clock->draw(_time);
_trainLine->draw(_time);
getScenes()->drawFrames(true);
adjustIndex(_time, originalTime, true);
++_delta;
}
// Draw the train line at the time
// line1: 150 frames (=> Belgrade)
// line2: 61 frames (=> Constantinople)
void TrainLine::draw(uint32 time) {
assert(time >= kTimeCityParis && time <= kTimeCityConstantinople);
// Check that sequences have been loaded
if (!_frameLine1 || !_frameLine2)
error("TrainLine::process: Line sequences have not been loaded correctly!");
// Clear existing frames
clear();
// Get the index of the last city the train has visited
uint index = 0;
for (uint i = 0; i < ARRAYSIZE(_trainCities); i++)
if ((uint32)_trainCities[i].time <= time)
index = i;
uint16 frame;
if (time > (uint32)_trainCities[index].time) {
// Interpolate linearly to use a frame between the cities
uint8 diffFrames = _trainCities[index + 1].frame - _trainCities[index].frame;
uint diffTimeCities = (uint)(_trainCities[index + 1].time - _trainCities[index].time);
uint traveledTime = (time - (uint)_trainCities[index].time);
frame = (uint16)(_trainCities[index].frame + (traveledTime * diffFrames) / diffTimeCities);
} else {
// Exactly on the city
frame = _trainCities[index].frame;
}
// Set frame, z-order and queue
if (frame < 150) {
_frameLine1->setFrame(frame);
_frameLine1->getInfo()->location = 1;
getScenes()->addToQueue(_frameLine1);
} else {
// We passed Belgrade
_frameLine1->setFrame(149);
_frameLine2->setFrame(frame - 150);
_frameLine1->getInfo()->location = 1;
_frameLine2->getInfo()->location = 1;
getScenes()->addToQueue(_frameLine1);
getScenes()->addToQueue(_frameLine2);
}
}
void Menu::showFrame(StartMenuOverlay overlayType, int index, bool redraw) {
if (index == -1) {
getScenes()->removeFromQueue(_frames[overlayType]);
} else {
// Check that the overlay is valid
if (!_frames[overlayType])
return;
// Remove the frame and add a new one with the proper index
getScenes()->removeFromQueue(_frames[overlayType]);
_frames[overlayType]->setFrame((uint16)index);
getScenes()->addToQueue(_frames[overlayType]);
}
if (redraw)
getScenes()->drawFrames(true);
}
void Beetle::unload() {
// Remove sequences from display list
if (_data)
getScenes()->removeFromQueue(_data->frame);
// Delete all loaded sequences
SAFE_DELETE(_data);
}
void Clock::draw(uint32 time) {
assert(time >= kTimeCityParis && time <= kTimeCityConstantinople);
// Check that sequences have been loaded
if (!_frameMinutes || !_frameHour || !_frameSun || !_frameDate)
error("Clock::process: clock sequences have not been loaded correctly!");
// Clear existing frames
clear();
// Game starts at: 1037700 = 7:13 p.m. on July 24, 1914
// Game ends at: 4941000 = 7:30 p.m. on July 26, 1914
// Game lasts for: 3903300 = 2 days + 17 mins = 2897 mins
// 15 = 1 second
// 15 * 60 = 900 = 1 minute
// 900 * 60 = 54000 = 1 hour
// 54000 * 24 = 1296000 = 1 day
// Calculate each sequence index from the current time
uint8 hour = 0;
uint8 minute = 0;
State::getHourMinutes(time, &hour, &minute);
uint32 index_date = 18 * time / 1296000;
if (hour == 23)
index_date += 18 * minute / 60;
// Set sequences frames
_frameMinutes->setFrame(minute);
_frameHour->setFrame((5 * hour + minute / 12) % 60);
_frameSun->setFrame((5 * hour + minute / 12) % 120);
_frameDate->setFrame((uint16)index_date);
// Adjust z-order and queue
_frameMinutes->getInfo()->location = 1;
_frameHour->getInfo()->location = 1;
_frameSun->getInfo()->location = 1;
_frameDate->getInfo()->location = 1;
getScenes()->addToQueue(_frameMinutes);
getScenes()->addToQueue(_frameHour);
getScenes()->addToQueue(_frameSun);
getScenes()->addToQueue(_frameDate);
}
void Menu::hideOverlays() {
_lastHotspot = NULL;
// Hide all menu overlays
for (MenuFrames::iterator it = _frames.begin(); it != _frames.end(); it++)
showFrame(it->_key, -1, false);
getScenes()->drawFrames(true);
}
//////////////////////////////////////////////////////////////////////////
// Handle events
void Menu::eventMouse(const Common::Event &ev) {
if (!getFlags()->shouldRedraw)
return;
bool redraw = true;
getFlags()->shouldRedraw = false;
// Update coordinates
setCoords(ev.mouse);
//_mouseFlags = (Common::EventType)(ev.type & Common::EVENT_LBUTTONUP);
if (_isShowingCredits) {
if (ev.type == Common::EVENT_RBUTTONUP) {
showFrame(kOverlayCredits, -1, true);
_isShowingCredits = false;
}
if (ev.type == Common::EVENT_LBUTTONUP) {
// Last frame of the credits
if (_seqCredits && _creditsSequenceIndex == _seqCredits->count() - 1) {
showFrame(kOverlayCredits, -1, true);
_isShowingCredits = false;
} else {
++_creditsSequenceIndex;
showFrame(kOverlayCredits, _creditsSequenceIndex, true);
}
}
} else {
// Check for hotspots
SceneHotspot *hotspot = NULL;
getScenes()->get(getState()->scene)->checkHotSpot(ev.mouse, &hotspot);
if (_lastHotspot != hotspot || ev.type == Common::EVENT_LBUTTONUP) {
_lastHotspot = hotspot;
if (ev.type == Common::EVENT_MOUSEMOVE) { /* todo check event type */
if (!_handleTimeDelta && hasTimeDelta())
setTime();
}
if (hotspot) {
redraw = handleEvent((StartMenuAction)hotspot->action, ev.type);
getFlags()->mouseRightClick = false;
getFlags()->mouseLeftClick = false;
} else {
hideOverlays();
}
}
}
if (redraw) {
getFlags()->shouldRedraw = true;
askForRedraw();
}
}
//////////////////////////////////////////////////////////////////////////
// Setup
void Menu::setup() {
// Clear drawing queue
getScenes()->removeAndRedraw(&_frames[kOverlayAcorn], false);
SAFE_DELETE(_seqAcorn);
// Load Menu scene
// + 1 = normal menu with open egg / clock
// + 2 = shield menu, when no savegame exists (no game has been started)
_isGameStarted = _lowerTime >= kTimeStartGame;
getScenes()->loadScene((SceneIndex)(_isGameStarted ? _gameId * 5 + 1 : _gameId * 5 + 2));
getFlags()->shouldRedraw = true;
getLogic()->updateCursor();
//////////////////////////////////////////////////////////////////////////
// Load Acorn sequence
_seqAcorn = loadSequence(getAcornSequenceName(_isGameStarted ? getNextGameId() : kGameBlue));
//////////////////////////////////////////////////////////////////////////
// Check if we loaded sequences before
if (_seqTooltips && _seqTooltips->count() > 0)
return;
// Load all static data
_seqTooltips = loadSequence("helpnewr.seq");
_seqEggButtons = loadSequence("buttns.seq");
_seqButtons = loadSequence("quit.seq");
_seqCity1 = loadSequence("jlinetl.seq");
_seqCity2 = loadSequence("jlinecen.seq");
_seqCity3 = loadSequence("jlinebr.seq");
_seqCredits = loadSequence("credits.seq");
_frames[kOverlayTooltip] = new SequenceFrame(_seqTooltips);
_frames[kOverlayEggButtons] = new SequenceFrame(_seqEggButtons);
_frames[kOverlayButtons] = new SequenceFrame(_seqButtons);
_frames[kOverlayAcorn] = new SequenceFrame(_seqAcorn);
_frames[kOverlayCity1] = new SequenceFrame(_seqCity1);
_frames[kOverlayCity2] = new SequenceFrame(_seqCity2);
_frames[kOverlayCity3] = new SequenceFrame(_seqCity3);
_frames[kOverlayCredits] = new SequenceFrame(_seqCredits);
}
Fighter::~Fighter() {
// The original game resets the function pointers to default values, just before deleting the struct
getScenes()->removeAndRedraw(&_frame, false);
// Free sequences
for (uint i = 0; i < _sequences.size(); i++)
SAFE_DELETE(_sequences[i]);
// Zero-out passed pointers
_sequence = NULL;
_opponent = NULL;
_fight = NULL;
_engine = NULL;
}
//////////////////////////////////////////////////////////////////////////
// Overlays & elements
//////////////////////////////////////////////////////////////////////////
void Menu::checkHotspots() {
if (!_isShowingMenu)
return;
if (!getFlags()->shouldRedraw)
return;
if (_isShowingCredits)
return;
SceneHotspot *hotspot = NULL;
getScenes()->get(getState()->scene)->checkHotSpot(getCoords(), &hotspot);
if (hotspot)
handleEvent((StartMenuAction)hotspot->action, _mouseFlags);
else
hideOverlays();
}
void CompositeViewer::frameDrawFinish( )
{
//LBINFO << "-----> Viewer::frameDrawFinish( )" << std::endl;
Scenes scenes;
getScenes( scenes );
for( Scenes::iterator sitr = scenes.begin( );
sitr != scenes.end( ); ++sitr )
{
osgViewer::Scene* scene = *sitr;
osg::ref_ptr< osgDB::DatabasePager > dp = scene ?
scene->getDatabasePager( ) : 0;
if( dp.valid( ))
dp->signalEndFrame( );
}
_requestRedraw = false;
//LBINFO << "<----- Viewer::frameDrawFinish( )" << std::endl;
}
void Clock::clear() {
getScenes()->removeFromQueue(_frameMinutes);
getScenes()->removeFromQueue(_frameHour);
getScenes()->removeFromQueue(_frameSun);
getScenes()->removeFromQueue(_frameDate);
}
// Remove all frames from the queue
void Menu::clear() {
for (MenuFrames::iterator it = _frames.begin(); it != _frames.end(); it++)
getScenes()->removeAndRedraw(&it->_value, false);
clearBg(GraphicsManager::kBackgroundOverlay);
}
void Beetle::drawUpdate() {
if (!_data)
error("Beetle::drawUpdate: sequences have not been loaded!");
if (_data->frame != NULL) {
getScenes()->setCoordinates(_data->frame);
getScenes()->removeFromQueue(_data->frame);
}
// Update current frame
switch (_data->indexes[_data->offset]) {
default:
_data->currentFrame += 10;
break;
case 3:
case 6:
case 9:
case 12:
case 15:
case 18:
case 21:
case 24:
case 25:
case 26:
case 27:
case 28:
_data->currentFrame++;
break;
}
// Update current sequence
if (_data->currentSequence->count() <= _data->currentFrame) {
switch (_data->indexes[_data->offset]) {
default:
_data->offset++;
_data->currentSequence = _data->sequences[_data->indexes[_data->offset]];
break;
case 3:
case 6:
case 9:
case 12:
case 15:
case 18:
case 21:
break;
}
_data->currentFrame = 0;
if (_data->indexes[_data->offset] == 29) {
SAFE_DELETE(_data->frame);
_data->currentSequence = NULL; // pointer to existing sequence
return;
}
}
// Update coordinates
switch (_data->indexes[_data->offset]) {
default:
break;
case 0:
_data->coordY -= _data->coordOffset;
break;
case 3:
_data->coordX += _data->coordOffset;
_data->coordY -= _data->coordOffset;
break;
case 6:
_data->coordX += _data->coordOffset;
break;
case 9:
_data->coordX += _data->coordOffset;
_data->coordY += _data->coordOffset;
break;
case 12:
_data->coordY += _data->coordOffset;
break;
case 15:
_data->coordX -= _data->coordOffset;
_data->coordY += _data->coordOffset;
break;
case 18:
_data->coordX -= _data->coordOffset;
break;
case 21:
_data->coordX -= _data->coordOffset;
_data->coordY -= _data->coordOffset;
break;
}
// Update beetle data
int rnd = rnd(100);
if (_data->coordX < 165 || _data->coordX > 465) {
uint index = 0;
if (rnd >= 30) {
if (rnd >= 70)
index = (_data->coordX < 165) ? 9 : 15;
else
index = (_data->coordX < 165) ? 6 : 18;
} else {
index = (_data->coordX < 165) ? 3 : 21;
}
updateData(index);
}
if (_data->coordY < 178) {
switch (_data->indexes[_data->offset]) {
default:
updateData(26);
break;
case 3:
updateData(25);
break;
case 21:
updateData(27);
break;
}
}
if (_data->coordY > 354) {
switch (_data->indexes[_data->offset]) {
default:
break;
case 9:
case 12:
case 15:
updateData(28);
break;
}
}
#define INVERT_Y() \
switch (_data->indexes[_data->offset]) { \
default: \
break; \
case 24: \
case 25: \
case 26: \
case 27: \
case 28: \
_data->coordY = -_data->coordY; \
break; \
}
// Invert direction
INVERT_Y();
SequenceFrame *frame = new SequenceFrame(_data->currentSequence, (uint16)_data->currentFrame);
updateFrame(frame);
INVERT_Y();
getScenes()->addToQueue(frame);
SAFE_DELETE(_data->frame);
_data->frame = frame;
}
void Fighter::draw() {
getScenes()->removeAndRedraw(&_frame, false);
_frameIndex = 0;
_field_24 = 0;
}
//////////////////////////////////////////////////////////////////////////
// Processing
//////////////////////////////////////////////////////////////////////////
void Fighter::process() {
if (!_fight)
error("[Fighter::handleAction] Fighter not initialized properly");
if (!_sequence) {
if (_frame) {
getScenes()->removeFromQueue(_frame);
getScenes()->setCoordinates(_frame);
}
SAFE_DELETE(_frame);
return;
}
if (_sequence->count() <= _frameIndex) {
switch(_action) {
default:
break;
case kFightAction101:
setSequenceAndDraw(_sequenceIndex2, kFightSequenceType1);
_sequenceIndex2 = 0;
break;
case kFightActionResetFrame:
_frameIndex = 0;
break;
case kFightAction103:
setSequenceAndDraw(0, kFightSequenceType1);
handleAction(kFightAction101);
_opponent->setSequenceAndDraw(0, kFightSequenceType1);
_opponent->handleAction(kFightAction101);
_opponent->update();
break;
case kFightActionWin:
_fight->bailout(Fight::kFightEndWin);
break;
case kFightActionLost:
_fight->bailout(Fight::kFightEndLost);
break;
}
}
if (_fight->isRunning()) {
// Get the current sequence frame
SequenceFrame *frame = new SequenceFrame(_sequence, (uint16)_frameIndex);
frame->getInfo()->location = 1;
if (_frame == frame) {
delete frame;
return;
}
getSound()->playFightSound(frame->getInfo()->soundAction, frame->getInfo()->field_31);
// Add current frame to queue and advance
getScenes()->addToQueue(frame);
_frameIndex++;
if (_frame) {
getScenes()->removeFromQueue(_frame);
if (!frame->getInfo()->field_2E)
getScenes()->setCoordinates(_frame);
}
// Replace by new frame
delete _frame;
_frame = frame;
}
}
void QDomoticzController::pollServer()
{
getScenes();
getSwitches();
}
void TrainLine::clear() {
getScenes()->removeFromQueue(_frameLine1);
getScenes()->removeFromQueue(_frameLine2);
}
void Logic::eventMouse(const Common::Event &ev) {
bool hotspotHandled = false;
// Reset mouse flags
getFlags()->mouseLeftClick = false;
getFlags()->mouseRightClick = false;
// Process event flags
if (ev.type == Common::EVENT_LBUTTONDOWN) {
if (getFlags()->frameInterval)
_ignoreFrameInterval = false;
getFlags()->frameInterval = false;
}
if (getFlags()->flag_0) {
if (ev.type == Common::EVENT_LBUTTONDOWN || ev.type == Common::EVENT_RBUTTONDOWN) {
getFlags()->flag_0 = false;
getFlags()->shouldRedraw = true;
updateCursor(true);
getFlags()->frameInterval = true;
}
return;
}
if (_ignoreFrameInterval && getScenes()->checkCurrentPosition(true) && _engine->getCursor()->getStyle() == kCursorForward) {
getFlags()->shouldRedraw = false;
getFlags()->flag_0 = true;
return;
}
// Update coordinates
getGameState()->setCoordinates(ev.mouse);
// Handle inventory
getInventory()->handleMouseEvent(ev);
// Stop processing is inside the menu
if (getMenu()->isShown())
return;
// Handle whistle case
if (getInventory()->getSelectedItem() == kItemWhistle
&& !getProgress().isEggOpen
&& !getEntities()->isPlayerPosition(kCarGreenSleeping, 59)
&& !getEntities()->isPlayerPosition(kCarGreenSleeping, 76)
&& !getInventory()->isPortraitHighlighted()
&& !getInventory()->isOpened()
&& !getInventory()->isEggHighlighted()
&& !getInventory()->isMagnifierInUse()) {
// Update cursor
_engine->getCursor()->setStyle(getInventory()->get(kItemWhistle)->cursor);
// Check if clicked
if (ev.type == Common::EVENT_LBUTTONUP && !getSoundQueue()->isBuffered("LIB045")) {
getSound()->playSoundEvent(kEntityPlayer, 45);
if (getEntities()->isPlayerPosition(kCarGreenSleeping, 26) || getEntities()->isPlayerPosition(kCarGreenSleeping, 25) || getEntities()->isPlayerPosition(kCarGreenSleeping, 23)) {
getSavePoints()->push(kEntityPlayer, kEntityMertens, kAction226078300);
} else if (getEntities()->isPlayerPosition(kCarRedSleeping, 26) || getEntities()->isPlayerPosition(kCarRedSleeping, 25) || getEntities()->isPlayerPosition(kCarRedSleeping, 23)) {
getSavePoints()->push(kEntityPlayer, kEntityCoudert, kAction226078300);
}
if (!getState()->sceneUseBackup)
getInventory()->unselectItem();
}
REDRAW_CURSOR()
}
bool Menu::handleEvent(StartMenuAction action, Common::EventType type) {
bool clicked = (type == Common::EVENT_LBUTTONUP);
switch(action) {
default:
hideOverlays();
break;
//////////////////////////////////////////////////////////////////////////
case kMenuCredits:
if (hasTimeDelta()) {
hideOverlays();
break;
}
if (clicked) {
showFrame(kOverlayEggButtons, kButtonCreditsPushed, true);
showFrame(kOverlayTooltip, -1, true);
getSound()->playSound(kEntityPlayer, "LIB046");
hideOverlays();
_isShowingCredits = true;
_creditsSequenceIndex = 0;
showFrame(kOverlayCredits, 0, true);
} else {
// TODO check flags ?
showFrame(kOverlayEggButtons, kButtonCredits, true);
showFrame(kOverlayTooltip, kTooltipCredits, true);
}
break;
//////////////////////////////////////////////////////////////////////////
case kMenuQuitGame:
showFrame(kOverlayTooltip, kTooltipQuit, true);
if (clicked) {
showFrame(kOverlayButtons, kButtonQuitPushed, true);
getSound()->clearStatus();
getSound()->updateQueue();
getSound()->playSound(kEntityPlayer, "LIB046");
// FIXME uncomment when sound queue is properly implemented
/*while (getSound()->isBuffered("LIB046"))
getSound()->updateQueue();*/
getFlags()->shouldRedraw = false;
Engine::quitGame();
return false;
} else {
showFrame(kOverlayButtons, kButtonQuit, true);
}
break;
//////////////////////////////////////////////////////////////////////////
case kMenuCase4:
if (clicked)
_index = 0;
// fall down to kMenuContinue
//////////////////////////////////////////////////////////////////////////
case kMenuContinue: {
if (hasTimeDelta()) {
hideOverlays();
break;
}
// Determine the proper CD archive
ArchiveIndex cd = kArchiveCd1;
if (getProgress().chapter > kChapter1)
cd = (getProgress().chapter > kChapter3) ? kArchiveCd3 : kArchiveCd2;
// Show tooltips & buttons to start a game, continue a game or load the proper cd
if (ResourceManager::isArchivePresent(cd)) {
if (_isGameStarted) {
showFrame(kOverlayEggButtons, kButtonContinue, true);
if (_lastIndex == _index) {
showFrame(kOverlayTooltip, getSaveLoad()->isGameFinished(_index, _lastIndex) ? kTooltipViewGameEnding : kTooltipContinueGame, true);
} else {
showFrame(kOverlayTooltip, kTooltipContinueRewoundGame, true);
}
} else {
showFrame(kOverlayEggButtons, kButtonShield, true);
showFrame(kOverlayTooltip, kTooltipPlayNewGame, true);
}
} else {
showFrame(kOverlayEggButtons, -1, true);
showFrame(kOverlayTooltip, cd - 1, true);
}
if (!clicked)
break;
// Try loading the archive file
if (!_engine->getResourceManager()->loadArchive(cd))
break;
// Load the train data file and setup game
getScenes()->loadSceneDataFile(cd);
showFrame(kOverlayTooltip, -1, true);
getSound()->playSound(kEntityPlayer, "LIB046");
// Setup new game
getSavePoints()->reset();
setLogicEventHandlers();
if (_index) {
getSound()->processEntry(SoundManager::kSoundType11);
} else {
if (!getFlags()->mouseRightClick) {
getScenes()->loadScene((SceneIndex)(5 * _gameId + 3));
if (!getFlags()->mouseRightClick) {
getScenes()->loadScene((SceneIndex)(5 * _gameId + 4));
if (!getFlags()->mouseRightClick) {
getScenes()->loadScene((SceneIndex)(5 * _gameId + 5));
if (!getFlags()->mouseRightClick) {
getSound()->processEntry(SoundManager::kSoundType11);
// Show intro
Animation animation;
if (animation.load(getArchive("1601.nis")))
animation.play();
getEvent(kEventIntro) = 1;
}
}
}
}
if (!getEvent(kEventIntro)) {
getEvent(kEventIntro) = 1;
getSound()->processEntry(SoundManager::kSoundType11);
}
}
// Setup game
getFlags()->isGameRunning = true;
startGame();
if (!_isShowingMenu)
getInventory()->show();
return false;
}
//////////////////////////////////////////////////////////////////////////
case kMenuSwitchSaveGame:
if (hasTimeDelta()) {
hideOverlays();
break;
}
if (clicked) {
showFrame(kOverlayAcorn, 1, true);
showFrame(kOverlayTooltip, -1, true);
getSound()->playSound(kEntityPlayer, "LIB047");
// Setup new menu screen
switchGame();
setup();
// Set fight state to 0
getFight()->resetState();
return true;
}
// TODO Check for flag
showFrame(kOverlayAcorn, 0, true);
if (_isGameStarted) {
showFrame(kOverlayTooltip, kTooltipSwitchBlueGame, true);
break;
}
if (_gameId == kGameGold) {
showFrame(kOverlayTooltip, kTooltipSwitchBlueGame, true);
break;
}
if (!SaveLoad::isSavegameValid(getNextGameId())) {
showFrame(kOverlayTooltip, kTooltipStartAnotherGame, true);
break;
}
// Stupid tooltips ids are not in order, so we can't just increment them...
switch(_gameId) {
default:
break;
case kGameBlue:
showFrame(kOverlayTooltip, kTooltipSwitchRedGame, true);
break;
case kGameRed:
showFrame(kOverlayTooltip, kTooltipSwitchGreenGame, true);
break;
case kGameGreen:
showFrame(kOverlayTooltip, kTooltipSwitchPurpleGame, true);
break;
case kGamePurple:
showFrame(kOverlayTooltip, kTooltipSwitchTealGame, true);
break;
case kGameTeal:
showFrame(kOverlayTooltip, kTooltipSwitchGoldGame, true);
break;
}
break;
//////////////////////////////////////////////////////////////////////////
case kMenuRewindGame:
if (!_index || _currentTime < _time) {
hideOverlays();
break;
}
if (clicked) {
if (hasTimeDelta())
_handleTimeDelta = false;
showFrame(kOverlayEggButtons, kButtonRewindPushed, true);
showFrame(kOverlayTooltip, -1, true);
getSound()->playSound(kEntityPlayer, "LIB046");
rewindTime();
_handleTimeDelta = false;
} else {
showFrame(kOverlayEggButtons, kButtonRewind, true);
showFrame(kOverlayTooltip, kTooltipRewind, true);
}
break;
//////////////////////////////////////////////////////////////////////////
case kMenuForwardGame:
if (_lastIndex <= _index || _currentTime > _time) {
hideOverlays();
break;
}
if (clicked) {
if (hasTimeDelta())
_handleTimeDelta = false;
showFrame(kOverlayEggButtons, kButtonForwardPushed, true);
showFrame(kOverlayTooltip, -1, true);
getSound()->playSound(kEntityPlayer, "LIB046");
forwardTime();
_handleTimeDelta = false;
} else {
showFrame(kOverlayEggButtons, kButtonForward, true);
showFrame(kOverlayTooltip, kTooltipFastForward, true);
}
break;
//////////////////////////////////////////////////////////////////////////
case kMenuParis:
moveToCity(kParis, clicked);
break;
//////////////////////////////////////////////////////////////////////////
case kMenuStrasBourg:
moveToCity(kStrasbourg, clicked);
break;
//////////////////////////////////////////////////////////////////////////
case kMenuMunich:
moveToCity(kMunich, clicked);
break;
//////////////////////////////////////////////////////////////////////////
case kMenuVienna:
moveToCity(kVienna, clicked);
break;
//////////////////////////////////////////////////////////////////////////
case kMenuBudapest:
moveToCity(kBudapest, clicked);
break;
//////////////////////////////////////////////////////////////////////////
case kMenuBelgrade:
moveToCity(kBelgrade, clicked);
break;
//////////////////////////////////////////////////////////////////////////
case kMenuConstantinople:
moveToCity(kConstantinople, clicked);
break;
//////////////////////////////////////////////////////////////////////////
case kMenuDecreaseVolume:
if (hasTimeDelta()) {
hideOverlays();
break;
}
// Cannot decrease volume further
if (getVolume() == 0) {
showFrame(kOverlayButtons, kButtonVolume, true);
showFrame(kOverlayTooltip, -1, true);
break;
}
showFrame(kOverlayTooltip, kTooltipVolumeDown, true);
// Show highlight on button & adjust volume if needed
if (clicked) {
showFrame(kOverlayButtons, kButtonVolumeDownPushed, true);
getSound()->playSound(kEntityPlayer, "LIB046");
setVolume(getVolume() - 1);
getSaveLoad()->saveVolumeBrightness();
uint32 nextFrameCount = getFrameCount() + 15;
while (nextFrameCount > getFrameCount()) {
_engine->pollEvents();
getSound()->updateQueue();
}
} else {
showFrame(kOverlayButtons, kButtonVolumeDown, true);
}
break;
//////////////////////////////////////////////////////////////////////////
case kMenuIncreaseVolume:
if (hasTimeDelta()) {
hideOverlays();
break;
}
// Cannot increase volume further
if (getVolume() >= 7) {
showFrame(kOverlayButtons, kButtonVolume, true);
showFrame(kOverlayTooltip, -1, true);
break;
}
showFrame(kOverlayTooltip, kTooltipVolumeUp, true);
// Show highlight on button & adjust volume if needed
if (clicked) {
showFrame(kOverlayButtons, kButtonVolumeUpPushed, true);
getSound()->playSound(kEntityPlayer, "LIB046");
setVolume(getVolume() + 1);
getSaveLoad()->saveVolumeBrightness();
uint32 nextFrameCount = getFrameCount() + 15;
while (nextFrameCount > getFrameCount()) {
_engine->pollEvents();
getSound()->updateQueue();
}
} else {
showFrame(kOverlayButtons, kButtonVolumeUp, true);
}
break;
//////////////////////////////////////////////////////////////////////////
case kMenuDecreaseBrightness:
if (hasTimeDelta()) {
hideOverlays();
break;
}
// Cannot increase brightness further
if (getBrightness() == 0) {
showFrame(kOverlayButtons, kButtonBrightness, true);
showFrame(kOverlayTooltip, -1, true);
break;
}
showFrame(kOverlayTooltip, kTooltipBrightnessDown, true);
// Show highlight on button & adjust brightness if needed
if (clicked) {
showFrame(kOverlayButtons, kButtonBrightnessDownPushed, true);
getSound()->playSound(kEntityPlayer, "LIB046");
setBrightness(getBrightness() - 1);
getSaveLoad()->saveVolumeBrightness();
// Reshow the background and frames (they will pick up the new brightness through the GraphicsManager)
_engine->getGraphicsManager()->draw(getScenes()->get((SceneIndex)(_isGameStarted ? _gameId * 5 + 1 : _gameId * 5 + 2)), GraphicsManager::kBackgroundC, true);
showFrame(kOverlayTooltip, kTooltipBrightnessDown, false);
showFrame(kOverlayButtons, kButtonBrightnessDownPushed, false);
} else {
showFrame(kOverlayButtons, kButtonBrightnessDown, true);
}
break;
//////////////////////////////////////////////////////////////////////////
case kMenuIncreaseBrightness:
if (hasTimeDelta()) {
hideOverlays();
break;
}
// Cannot increase brightness further
if (getBrightness() >= 6) {
showFrame(kOverlayButtons, kButtonBrightness, true);
showFrame(kOverlayTooltip, -1, true);
break;
}
showFrame(kOverlayTooltip, kTooltipBrightnessUp, true);
// Show highlight on button & adjust brightness if needed
if (clicked) {
showFrame(kOverlayButtons, kButtonBrightnessUpPushed, true);
getSound()->playSound(kEntityPlayer, "LIB046");
setBrightness(getBrightness() + 1);
getSaveLoad()->saveVolumeBrightness();
// Reshow the background and frames (they will pick up the new brightness through the GraphicsManager)
_engine->getGraphicsManager()->draw(getScenes()->get((SceneIndex)(_isGameStarted ? _gameId * 5 + 1 : _gameId * 5 + 2)), GraphicsManager::kBackgroundC, true);
showFrame(kOverlayTooltip, kTooltipBrightnessUp, false);
showFrame(kOverlayButtons, kButtonBrightnessUpPushed, false);
} else {
showFrame(kOverlayButtons, kButtonBrightnessUp, true);
}
break;
}
return true;
}
//////////////////////////////////////////////////////////////////////////
// Show the intro and load the main menu scene
void Menu::show(bool doSavegame, SavegameType type, uint32 value) {
if (_isShowingMenu)
return;
_isShowingMenu = true;
getEntities()->reset();
// If no blue savegame exists, this might be the first time we start the game, so we show the full intro
if (!getFlags()->mouseRightClick) {
if (!SaveLoad::isSavegameValid(kGameBlue) && _engine->getResourceManager()->loadArchive(kArchiveCd1)) {
if (!_hasShownIntro) {
// Show Broderbrund logo
Animation animation;
if (animation.load(getArchive("1930.nis")))
animation.play();
getFlags()->mouseRightClick = false;
// Play intro music
getSound()->playSoundWithSubtitles("MUS001.SND", SoundManager::kFlagMusic, kEntityPlayer);
// Show The Smoking Car logo
if (animation.load(getArchive("1931.nis")))
animation.play();
_hasShownIntro = true;
}
} else {
// Only show the quick intro
if (!_hasShownStartScreen) {
getSound()->playSoundWithSubtitles("MUS018.SND", SoundManager::kFlagMusic, kEntityPlayer);
getScenes()->loadScene(kSceneStartScreen);
// Original game waits 60 frames and loops Sound::unknownFunction1 unless the right button is pressed
uint32 nextFrameCount = getFrameCount() + 60;
while (getFrameCount() < nextFrameCount) {
_engine->pollEvents();
if (getFlags()->mouseRightClick)
break;
getSound()->updateQueue();
}
}
}
}
_hasShownStartScreen = true;
// Init Menu
init(doSavegame, type, value);
// Setup sound
getSound()->unknownFunction4();
getSound()->resetQueue(SoundManager::kSoundType11, SoundManager::kSoundType13);
if (getSound()->isBuffered("TIMER"))
getSound()->removeFromQueue("TIMER");
// Init flags & misc
_isShowingCredits = false;
_handleTimeDelta = hasTimeDelta();
getInventory()->unselectItem();
// Set Cursor type
_engine->getCursor()->setStyle(kCursorNormal);
_engine->getCursor()->show(true);
setup();
checkHotspots();
// Set event handlers
SET_EVENT_HANDLERS(Menu, this);
}
