mirror of
https://github.com/MaSzyna-EU07/maszyna.git
synced 2026-10-17 15:39:20 +02:00
Hirek193
54d8b112b8
Joining meant replaying backbuffer.bin from the very first frame of the session, so the longer a session ran, the longer it took to get in - and the whole history had to be kept for it. - network/snapshot: a chunked container with a version of its own. Every section carries its length, so a peer built before a section existed reads a newer snapshot and simply walks past what it does not know. Version 1 carries the session (tick, clock, weather, the state of the random engine), the vehicles (position on the track, speed, direction, controls, brake pressures, whether the AI is driving) and the crew roster. Switches, memcells, signals and the event queue are the next sections - joining is now: handshake -> load the scenario -> CLIENT_READY -> the server takes a snapshot on the spot and sends it -> the peer goes live. Because the snapshot is taken at the moment the peer becomes active there is no backlog to replay at all; the frame by frame catch-up is gone - the server refuses a peer that loaded a different scenario, with a readable reason instead of a silent desync - reconnecting into a session that is already loaded asks for a fresh snapshot straight away rather than waiting for a loader that will not run again - a vehicle is only put back on the rails when it really is somewhere else; the arithmetic that turns the recorded bogie offset back into the nose distance place_on_track() expects mirrors what that function itself does - the session log is still written out - it is useful when picking a desync apart - but nothing depends on replaying it any more
110 lines
3.5 KiB
C++
110 lines
3.5 KiB
C++
/*
|
|
This Source Code Form is subject to the
|
|
terms of the Mozilla Public License, v.
|
|
2.0. If a copy of the MPL was not
|
|
distributed with this file, You can
|
|
obtain one at
|
|
http://mozilla.org/MPL/2.0/.
|
|
*/
|
|
|
|
#include "stdafx.h"
|
|
#include "application/scenarioloadermode.h"
|
|
|
|
#include "utilities/Globals.h"
|
|
#include "simulation/simulation.h"
|
|
#include "simulation/simulationtime.h"
|
|
#include "simulation/simulationenvironment.h"
|
|
#include "application/application.h"
|
|
#include "application/scenarioloaderuilayer.h"
|
|
#include "rendering/renderer.h"
|
|
#include "utilities/Logs.h"
|
|
#include "utilities/translation.h"
|
|
#include "network/entities.h"
|
|
|
|
scenarioloader_mode::scenarioloader_mode() {
|
|
m_userinterface = std::make_shared<scenarioloader_ui>();
|
|
}
|
|
|
|
// initializes internal data structures of the mode. returns: true on success, false otherwise
|
|
bool scenarioloader_mode::init() {
|
|
// nothing to do here
|
|
return true;
|
|
}
|
|
|
|
// mode-specific update of simulation data. returns: false on error, true otherwise
|
|
bool scenarioloader_mode::update() {
|
|
if (!Global.ready_to_load) {
|
|
// waiting for the network handshake to tell us which scenario to load
|
|
m_userinterface->set_progress(
|
|
Global.network_status.empty()
|
|
? STR("Connecting to server")
|
|
: Global.network_status);
|
|
return true;
|
|
}
|
|
|
|
if (!state) {
|
|
WriteLog("using simulation seed: " + std::to_string(Global.random_seed), logtype::generic);
|
|
WriteLog("using simulation starting timestamp: " + std::to_string(Global.starting_timestamp), logtype::generic);
|
|
|
|
Application.set_title( Global.AppName + " (" + Global.SceneryFile + ")" );
|
|
WriteLog( "\nLoading scenario \"" + Global.SceneryFile + "\"..." );
|
|
|
|
timestart = std::chrono::system_clock::now();
|
|
state = simulation::State.deserialize_begin(Global.SceneryFile);
|
|
}
|
|
|
|
try {
|
|
if (simulation::State.deserialize_continue(state))
|
|
return true;
|
|
}
|
|
catch (invalid_scenery_exception &e) {
|
|
ErrorLog( "Bad init: scenario loading failed" );
|
|
Application.pop_mode();
|
|
}
|
|
|
|
if( Application.is_server() ) {
|
|
// the server owns the vehicle numbering for the whole session and publishes it
|
|
network::Entities.build();
|
|
}
|
|
|
|
// a client can take the state of the world over now; the server answers with a
|
|
// snapshot instead of making us replay the session from its first frame
|
|
Application.network_scenario_loaded();
|
|
|
|
WriteLog( "Scenario loading time: " + std::to_string( std::chrono::duration_cast<std::chrono::seconds>( std::chrono::system_clock::now() - timestart ).count() ) + " seconds" );
|
|
// TODO: implement and use next mode cue
|
|
|
|
Application.pop_mode();
|
|
Application.push_mode( eu07_application::mode::driver );
|
|
|
|
return true;
|
|
}
|
|
|
|
bool scenarioloader_mode::is_command_processor() const {
|
|
return false;
|
|
}
|
|
|
|
// maintenance method, called when the mode is activated
|
|
void scenarioloader_mode::enter() {
|
|
// TBD: hide cursor in fullscreen mode?
|
|
Application.set_cursor( GLFW_CURSOR_NORMAL );
|
|
|
|
simulation::is_ready = false;
|
|
|
|
if( Global.SceneryFile.empty() ) {
|
|
// multiplayer client: the scenario is not known until the server answers
|
|
Application.set_title( Global.AppName );
|
|
m_userinterface->set_progress( STR( "Connecting to server" ) );
|
|
}
|
|
else {
|
|
Application.set_title( Global.AppName + " (" + Global.SceneryFile + ")" );
|
|
m_userinterface->set_progress(STR("Loading scenery"));
|
|
}
|
|
}
|
|
|
|
// maintenance method, called when the mode is deactivated
|
|
void scenarioloader_mode::exit() {
|
|
simulation::Time.init( Global.starting_timestamp );
|
|
simulation::Environment.init();
|
|
}
|