mirror of
https://github.com/MaSzyna-EU07/maszyna.git
synced 2026-11-20 08:04:57 +01:00
The tapes of the user's vehicles were written by update() after the check for the writer of the recording, which close() drops on entering the editor (F11). With "physicslog no", the speed recorder's tape ended at F11 while the drivers' own logs of "physicslog yes" went on. The tapes are files of their own: they are kept from the moment the recording was to be made, the file made or not, closed or not, until the simulator closes, after the gap of the time in the editor. Only the recording itself stops at F11, as before. Reported in the review of #385. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
150 lines
5.8 KiB
C++
150 lines
5.8 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/.
|
|
*/
|
|
|
|
#pragma once
|
|
|
|
#include "vehicle/blackbox.h"
|
|
|
|
#include <array>
|
|
#include <chrono>
|
|
#include <cstdint>
|
|
#include <fstream>
|
|
#include <memory>
|
|
#include <mutex>
|
|
#include <set>
|
|
#include <string>
|
|
#include <unordered_map>
|
|
#include <utility>
|
|
#include <vector>
|
|
|
|
class TDynamicObject;
|
|
class TTrack;
|
|
class TMemCell;
|
|
class basic_event;
|
|
enum class user_command;
|
|
|
|
namespace simulation {
|
|
|
|
// the black box of the session (see blackbox_doc.md): written along with the physics logs, in driver mode,
|
|
// from the moment the scenario is loaded until the simulator closes or the editor is entered. the tapes of the user's
|
|
// vehicles, with the physics logs off, go on after the editor until the simulator closes
|
|
class blackbox_recorder {
|
|
public:
|
|
// starts the recording once the scenario is ready, if it is to be made, then records what is due.
|
|
// Deltatime: simulation time passed since the last call
|
|
void update(double Deltatime);
|
|
// writes the end of the recording and closes the file. a recording closed isn't started again; its tapes go on
|
|
void close();
|
|
|
|
// what happens between the looks, from wherever it happens; the cabs may run on threads of their own.
|
|
// nothing is written unless the recording runs
|
|
void command(TDynamicObject const *Vehicle, user_command Command, int Action, double Param1, double Param2);
|
|
void driver_changed(TDynamicObject const *Vehicle, bool Ai);
|
|
// Event: the one telling the aspect of the signal
|
|
void signal_passed(TDynamicObject const *Vehicle, basic_event const &Event, double Speed1, double Speed2, double Trainspeed, double Overrun, std::uint8_t Flags);
|
|
void vehicle_removed(TDynamicObject const *Vehicle);
|
|
// a train at a station of its timetable; the time and the vehicle are filled in here
|
|
void station(TDynamicObject const *Vehicle, blackbox::station_event Station);
|
|
// a train told to sound the horn (W6), at Position
|
|
void horn_requested(TDynamicObject const *Vehicle, double Duration, double Tone, glm::dvec3 const &Position);
|
|
// where the user looks from, every frame; written when it changes, at most twice a second. Owner: the vehicle the
|
|
// camera goes with; the time and its number are filled in here
|
|
void camera(blackbox::camera_state Camera, TDynamicObject const *Owner);
|
|
|
|
private:
|
|
struct coupler_entry {
|
|
TDynamicObject const *other{nullptr};
|
|
int other_side{0};
|
|
int flags{0};
|
|
};
|
|
struct vehicle_entry {
|
|
std::uint32_t id{blackbox::no_vehicle};
|
|
blackbox::vehicle_state last; // as listed last
|
|
bool listed{false};
|
|
std::array<coupler_entry, 2> couplers; // as seen last
|
|
bool couplers_known{false};
|
|
};
|
|
struct switch_entry {
|
|
TTrack *track{nullptr};
|
|
std::uint32_t index{0};
|
|
int state{-1};
|
|
};
|
|
struct signal_entry {
|
|
TMemCell const *cell{nullptr};
|
|
glm::dvec3 location{0.0};
|
|
float speed1{0.0f};
|
|
float speed2{0.0f};
|
|
std::string command;
|
|
bool known{false};
|
|
};
|
|
|
|
void open();
|
|
void write_map();
|
|
static std::vector<std::pair<glm::dvec3, float>> stop_point_headings();
|
|
void write_cab();
|
|
// with the physics logs off, the line of the log of the driver the user is with, to its log, physicslog/<vehicle>.dat,
|
|
// as the physics logs would have it. a driver's log is begun at the first line given for that driver, and goes on
|
|
// while the user looks around outside or is in another vehicle of that driver; back with it, after the gap
|
|
void keep_tape_line();
|
|
// the clock, the user's vehicle, the vehicles, the switches and the signals
|
|
void look_around(bool Keyframe);
|
|
void look_at_vehicles(bool Keyframe);
|
|
void look_at_switches();
|
|
void look_at_signals();
|
|
// the couplers of every vehicle against the last look: those coupled at the first look, then the changes
|
|
void look_at_couplers();
|
|
void write_camera();
|
|
// the timetable of the train the user is in, written again when it is another one; none isn't written
|
|
void look_at_timetable(TDynamicObject const &Vehicle, std::uint32_t Id);
|
|
// number of the vehicle, given (and the vehicle written) on first sight
|
|
std::uint32_t vehicle_id(TDynamicObject const *Vehicle);
|
|
// the number of a vehicle still on the scenery, no_vehicle for none or one taken off it
|
|
std::uint32_t known_id(TDynamicObject const *Vehicle);
|
|
std::uint32_t signal_at(glm::dvec3 const &Location) const;
|
|
|
|
std::mutex m_mutex;
|
|
std::array<char, 256 * 1024> m_filebuffer{};
|
|
std::ofstream m_file;
|
|
std::unique_ptr<blackbox::writer> m_writer;
|
|
bool m_started{false}; // tried to start, made or not
|
|
bool m_taping{false}; // the recording was to be made: its tapes are kept from then on, the file made or not, closed or not
|
|
double m_time{0.0};
|
|
double m_cabdue{0.0};
|
|
double m_tapedue{0.0};
|
|
// the names of the logs begun by the recording
|
|
std::set<std::string> m_tapes;
|
|
double m_lookdue{0.0};
|
|
double m_keyframedue{0.0};
|
|
std::unordered_map<TDynamicObject const *, vehicle_entry> m_vehicles;
|
|
std::uint32_t m_nextvehicle{1};
|
|
std::vector<switch_entry> m_switches;
|
|
std::vector<signal_entry> m_signals;
|
|
std::uint32_t m_uservehicle{blackbox::no_vehicle};
|
|
bool m_userincab{false};
|
|
std::int8_t m_usercab{0};
|
|
bool m_userknown{false};
|
|
std::string m_timetabletrain;
|
|
TDynamicObject const *m_timetablevehicle{nullptr}; // the user's vehicle at the last look at the timetable
|
|
int m_timetablestations{0};
|
|
blackbox::camera_state m_camera; // as given last
|
|
TDynamicObject const *m_cameraowner{nullptr};
|
|
blackbox::camera_state m_camerawritten; // as written last
|
|
bool m_cameraknown{false};
|
|
bool m_camerawrote{false};
|
|
double m_cameradue{0.0};
|
|
// how long the looks around take, told in the log when the recording ends
|
|
std::chrono::steady_clock::duration m_looktime{};
|
|
std::chrono::steady_clock::duration m_looklongest{};
|
|
int m_looks{0};
|
|
};
|
|
|
|
extern blackbox_recorder Blackbox;
|
|
|
|
} // namespace simulation
|