18
0
mirror of https://github.com/MaSzyna-EU07/maszyna.git synced 2026-11-20 08:04:57 +01:00
Files
maszyna/simulation/blackboxrecorder.h
maj00r 5d0bf6ed00 fix(blackbox): the wheels of the powered vehicle, as the speedometer has them, and the logs described as the drivers' they are
In a unit driven from an unpowered car, the speed of the wheels was of the car
the user is in, whose wheels never slip; now of the motor car, signed as the
occupied vehicle's speed. The doc tells of a log per driver, and of the two
seconds of real time a crash loses.
2026-11-15 23:32:39 +01:00

148 lines
5.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/.
*/
#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
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
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
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