Files
Dreierpack-Manager/src/modern/ui/live_state.inc
T
MichaelandClaude Fable 5.2 72e06aabdb Players wear shirt numbers the manager can change
Every player keeps a number from 1 to 99, unique within his squad. The
line-up shows it and changes it by a click; the tactics sketch and the
match sheet wear it too.

Engine: shirt_numbers.hpp, squad read player.shirtNumber, command
lineup.setNumber; saved in state/modern.json.

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
2026-11-17 16:58:34 +01:00

94 lines
5.0 KiB
C++

// SPDX-License-Identifier: GPL-3.0-only
LivePlayback live_;
Json live_drafts_ = Json::object(), live_dialog_draft_;
std::string live_tab_ = "team", live_coverage_ = "all", live_filter_ = "all",
live_selected_match_, live_dialog_, live_feedback_, live_out_, live_in_;
uint64_t live_last_tick_ = 0;
const DataSource *live_source_ = nullptr;
std::shared_ptr<const Catalog> live_world_;
int live_resume_speed_ = 0;
bool live_speed_dragging_ = false, live_review_ = false,
live_reset_detail_ = false, live_reset_ticker_ = false,
live_restore_scroll_ = false;
bool live_detail_pending_ = false, live_ticker_pending_ = false;
uint64_t live_detail_updates_ = 0, live_ticker_updates_ = 0;
std::string live_ticker_events(const Json &frame, size_t &shown);
void live_update_parts();
float live_ticker_scroll_ = 0, live_detail_scroll_ = 0;
std::string render_live();
std::string live_sheet(const std::string &over);
std::string live_roster(const Json &owner);
std::string live_detail(const Json &owner, const Json &frame);
std::string live_dialog_markup(const Json &owner);
std::string live_badge(const Json &, double);
std::string live_icon(const std::string &kind, double size);
std::string live_weather_icon(int code, double size);
// the stadium picture behind the match sheet, by the crowd and the weather ("" = none)
std::string live_backdrop() const;
bool live_indoor() const;
// the manager whose team the right page shows follows the chosen match, and the other way round
void live_follow_match();
// the two club colours of a match (home, away), far enough apart to tell the sides
std::array<std::string, 2> live_colours(const Json &match);
std::string live_card(const Json &match, const Json &frame, const std::string &layout, size_t index);
std::string live_moment_; // the event whose banner was shown last
bool live_halt_interval_ = false, live_halt_behind_ = false;
std::string live_halted_; // the reason of the last automatic halt, cleared when play resumes
Json live_owner() const;
Json live_owner_rows(const Json &) const;
Json live_owner_state(const Json &) const;
bool live_open();
// Engine career: shows the recording of the kickoff that was just played.
bool engine_live_open(const Json &recording);
std::string live_return_scene_;
Json engine_advance_payload_ = Json::object();
Json engine_postmatch_read_; // the engine's post-match read of the last kickoff
std::string engine_expiry_player_;
std::string engine_offer_player_; // the listed player whose bids are being decided
void engine_offers_ask(const Json &args);
// The annual general meeting: what the engine reported (vote, interested clubs) and whether
// the list of clubs is shown to a manager who was voted out.
Json engine_assembly_;
bool engine_assembly_forced_ = false;
void engine_assembly_ask(const Json &args);
void engine_assembly_clubs(bool forced);
void engine_assembly_choose(const std::string &team);
// The shirt number of a player of the squad at the desk, or of its n-th player; the fallback
// (the place on the board) where the engine gives none.
std::string engine_shirt(const std::string &player, size_t fallback) const;
std::string engine_shirt_at(size_t place) const;
// The big sheet of the interested clubs: open or not, the club whose details are shown, and
// where its list was scrolled to before the sheet was drawn again.
bool engine_assembly_open_ = false;
std::string engine_assembly_pick_;
std::optional<float> engine_assembly_scroll_;
std::string engine_assembly_sheet();
bool engine_assembly_action(const std::string &action, const std::string &id);
// The needle of the meeting: when it started to swing (0 = at rest) and where it comes to rest.
uint64_t engine_assembly_started_ = 0;
int engine_assembly_target_ = 50;
void engine_assembly_tick();
void engine_kickoff();
// A kickoff of the engine that is played minute by minute while the ticker is open.
bool engine_live_running_ = false, engine_live_busy_ = false, engine_live_at_end_ = false;
std::future<Json> engine_live_job_;
std::string engine_live_revision_;
uint64_t engine_live_elapsed_ = 0;
Json engine_live_roster_ = Json::array(), engine_live_swap_, engine_live_queue_;
// The tactics board during a live kickoff: the engine's controls with the values in force.
Json engine_live_tactics_ = Json::array(), engine_live_tactics_sent_;
bool engine_live_assistant_ = false; // the assistant adapts the attitude until it is set by hand
void engine_live_begin(const Json &state, const std::string &revision);
void engine_live_send(const std::string &kind, const Json &payload);
void engine_live_poll();
void engine_live_enter();
void engine_expiry_ask(const Json &args);
void live_close();
bool live_action(const std::string &, Rml::Element *);
bool live_event(Rml::Event &);
void live_tick();
void live_after_render();
void live_set_speed(int);
void live_dialog_close(bool);
Json live_snapshot() const;