Initial public OpenBMH 0.1 source (by Codex)

This commit is contained in:
Codex committed 2026-10-16 19:36:32 +02:00
commit 558fbf166b
613 files changed
+168029

No files matched your search

+36
View File
@@ -0,0 +1,36 @@
// SPDX-License-Identifier: GPL-3.0-only
#pragma once
#include "app/career_session.hpp"
namespace bmh::app::detail {
template<class Checkpoint, class Restore>
bool apply_window(CareerSession& session, uint64_t& revision, Checkpoint before,
Restore restore_checkpoint, const std::function<bool()>& action) {
const auto game = session.game();
const auto rand = session.rand();
const auto old_revision = revision;
const auto restore = [&] {
session.game() = game;
session.rand() = rand;
// Some owners reconstruct their saved RNG identity during restore.
restore_checkpoint(std::move(before));
revision = old_revision;
};
try {
if (action()) return true;
} catch (...) {
restore();
throw;
}
restore();
return false;
}
inline bool apply_native(CareerSession& session, uint64_t& revision, const std::function<bool()>& action) {
return apply_window(session, revision, session.state(),
[&](GameState before) { session.state() = std::move(before); }, action);
}
} // namespace bmh::app::detail
+75
View File
@@ -0,0 +1,75 @@
// SPDX-License-Identifier: GPL-3.0-only
#include "formats/executable_layout.hpp"
#pragma once
#include "audio/playback.hpp"
#include "formats/le.hpp"
#include "game/state.hpp"
#include "ui/setup.hpp"
namespace bmh::app {
inline openbmh::audio::OriginalAssets original_audio_assets(
const std::filesystem::path& directory, const LeImage& exe) {
openbmh::audio::OriginalAssets assets;
for (unsigned i = 0; i < 4; ++i)
assets.containers[i] = read_file(ui::asset_path(directory / "S", std::to_string(2000 + i)));
for (unsigned i = 0; i < assets.tables.frequencies.size(); ++i)
assets.tables.frequencies[i] = exe.u16(::bmh::layout::Audio_OriginalAudioAssets_RuntimeField2 + 2 * i);
for (unsigned i = 0; i < assets.tables.operators.size(); ++i)
assets.tables.operators[i] = exe.u8(::bmh::layout::Audio_OriginalAudioAssets_RuntimeField + 16 * i);
return assets;
}
inline openbmh::audio::OriginalAudioOptions original_audio_options(const GameState& state, bool music) {
const auto on = [&](std::uint32_t address) {
return !state.memory.has(address) || (state.memory.u8(address) & 0x7f) == 0;
};
// A5 governs match presentation and is checked by the match observer. It
// must not mute menu clicks. A6/A7 are independent saved music/click switches.
return {music && on(::bmh::layout::Audio_OriginalAudioOptions_ExecutableField), true, on(::bmh::layout::Audio_OriginalAudioOptions_ExecutableField2)};
}
inline bool match_sound_enabled(const GameState& state) {
return !state.memory.has(::bmh::layout::Audio_MatchSoundEnabled_RuntimeField) || (state.memory.u8(::bmh::layout::Audio_MatchSoundEnabled_RuntimeField) & 0x7f) == 0;
}
inline void original_audio_command(openbmh::audio::Playback& playback, std::uint8_t id) {
if (!playback.original_ready() || !playback.available()) return;
std::string error;
playback.play_original_id(id, error);
}
inline void original_match_audio_command(openbmh::audio::Playback& playback,
const GameState& state, std::uint8_t id) {
if (match_sound_enabled(state)) original_audio_command(playback, id);
else if (id == 3) original_audio_command(playback, 8); // Match entry still stops desk music.
}
// One callback per actual SDL mouse event, including nested modal loops. No
// rendering/hover polling, no scene inference, and no application/GameState access
// from a possible SDL event thread. Source OriginalMouseSound maps left2/right8 to10/11.
class OriginalMouseSound {
public:
explicit OriginalMouseSound(openbmh::audio::Playback& p) : playback_(p) {
SDL_AddEventWatch(watch, this);
}
~OriginalMouseSound() { detach(); }
void detach() noexcept {
if (!attached_) return;
SDL_DelEventWatch(watch, this);
attached_ = false;
}
OriginalMouseSound(const OriginalMouseSound&) = delete;
OriginalMouseSound& operator=(const OriginalMouseSound&) = delete;
private:
static int watch(void* data, SDL_Event* event) {
if (event->type == SDL_MOUSEBUTTONDOWN) {
auto& self = *static_cast<OriginalMouseSound*>(data);
if (event->button.button == SDL_BUTTON_LEFT) original_audio_command(self.playback_, 10);
if (event->button.button == SDL_BUTTON_RIGHT) original_audio_command(self.playback_, 11);
}
return 1;
}
openbmh::audio::Playback& playback_;
bool attached_ = true;
};
} // namespace bmh::app
File diff suppressed because it is too large. Load diff
File diff suppressed because it is too large. Load diff
File diff suppressed because it is too large. Load diff
+100
View File
@@ -0,0 +1,100 @@
// SPDX-License-Identifier: GPL-3.0-only
#pragma once
#include "app/career_session.hpp"
#include "audio/playback.hpp"
#include <functional>
namespace bmh::app {
using SeasonPresenter = std::function<void(const char*, const GameState&)>;
using TransferOfferPresenter = std::function<int(const GameState&, const TransferOfferListView&)>;
using TransferDecisionPresenter = std::function<void(const GameState&, const TransferDecisionEvent&)>;
using PoachNoticePresenter = std::function<void(const GameState&,const PoachStart&,const Image&)>;
using AdvertisingRenewalPresenter = std::function<CareerSession::AdvertisingRenewalPresentation(
const GameState&, const AdvertisingRenewal&, const Image&)>;
using NationalFriendlyQuestionPresenter = std::function<std::optional<bool>(
const GameState&, ui::TaxDialogProjection, const Image&)>;
using ContractExpiryPresenter = CareerSession::ContractExpiryPresenter;
using LoanReturnPresenter = CareerSession::LoanReturnPresenter;
using LoanReturnOfferPresenter = CareerSession::LoanReturnOfferPresenter;
using LiveLineupDispatcher = std::function<LiveSubstitutionResult(const ui::LineupRequest&)>;
using LiveTacticsDispatcher = std::function<bool(const ui::TacticsRequest&, std::string&)>;
using LivePitchDispatcher = std::function<LiveSubstitutionResult(const ui::PitchRequest&)>;
enum class LiveInterventionBoundary { begin, finish, abort };
using LiveInterventionScopeDispatcher = std::function<bool(LiveInterventionBoundary, int, int, int, std::string&)>;
using LiveInterventionPresenter = std::function<void(int, MatchEngine&, std::vector<MatchGroup>&,
GameState&, uint64_t&, const LiveLineupDispatcher&, const LiveTacticsDispatcher&,
const LivePitchDispatcher&, const LiveInterventionScopeDispatcher&)>;
using LiveMatchEventPresenter = std::function<void(const LiveMatchEvent&, MatchEngine&,
std::vector<MatchGroup>&, GameState&, uint64_t&, const LiveLineupDispatcher&,
const LiveTacticsDispatcher&, const LivePitchDispatcher&,
const LiveInterventionScopeDispatcher&)>;
using EnvironmentNoticePresenter = std::function<bool(const GameState&, ui::TaxDialogProjection, const Image&)>;
using LiveRealityPresenter = decltype(TurnDriver::live_reality);
using PhaseResultPresenter = decltype(TurnDriver::phase_results);
using LiveBallPresenter = std::function<void(const LiveBallEvent&,
const std::vector<MatchGroup>&, const GameState&)>;
using LiveChancePresenter = std::function<void(const LiveChanceEvent&,
const std::vector<MatchGroup>&, const GameState&)>;
using LiveShotPresenter = std::function<void(const LiveShotEvent&,
const std::vector<MatchGroup>&, const GameState&)>;
using LiveSetPiecePresenter = std::function<void(const LiveSetPieceEvent&,
const std::vector<MatchGroup>&, const GameState&)>;
using LiveBookingPresenter = std::function<void(const LiveBookingEvent&,
const std::vector<MatchGroup>&, const GameState&)>;
using LiveShootoutPresenter = std::function<void(const LiveShootoutEvent&,
const std::vector<MatchGroup>&, const GameState&)>;
// Shared, synchronous request boundary of the SDL app. Tests drive the same
// controller without a window; rendering and navigation never advance the engine.
std::string serve_flow_request(ui::StartupFlow&, const ui::FlowResult&,
std::unique_ptr<CareerSession>&, const std::filesystem::path& data,
const std::filesystem::path& save_directory, uint32_t seed, uint64_t& revision,
openbmh::audio::Playback&, std::optional<uint64_t>& audio_session, bool music_enabled,
std::function<void(int, const std::vector<MatchGroup>&, const GameState&)> live_presenter = {},
TransferOfferPresenter transfer_presenter = {},
TransferDecisionPresenter transfer_decision_presenter = {},
SeasonPresenter season_presenter = {},
SeasonTaxHooks tax_presenter = {},
SeasonHighscoreHook highscore_presenter = {},
SeasonPromotionHook promotion_presenter = {},
SeasonCupDrawHook cup_draw_presenter = {},
PendingOfferHooks pending_offer_presenter = {},
PendingOfferEntryPolicy pending_entry_policy = PendingOfferEntryPolicy::legacy_unpresented,
HumanBuyerSaleHooks market_sale_presenter = {},
HumanBuyerMarketEntryPolicy market_entry_policy = HumanBuyerMarketEntryPolicy::legacy_unpresented,
TransferOfferTeamInfoPresenter team_info_presenter = {},
TransferOfferPlayerInfoPresenter player_info_presenter = {},
ConstructionNoticeHook construction_notice_presenter = {},
SeasonTicketCompensationNoticeHook compensation_notice_presenter = {},
SportschauPresentationHooks sportschau_presenter = {},
AdvertisingRenewalPresenter advertising_renewal_presenter = {},
CareerSession::PoachPlayerSelector poach_player_selector = {},
PoachNoticePresenter poach_notice_presenter = {},
ContractExpiryPresenter contract_expiry_presenter = {},
NationalFriendlyQuestionPresenter national_friendly_question_presenter = {},
LoanReturnPresenter loan_return_presenter = {},
LoanReturnOfferPresenter loan_return_offer_presenter = {},
LiveInterventionPresenter live_intervention_presenter = {},
EnvironmentNoticePresenter environment_notice_presenter = {},
LiveMatchEventPresenter live_match_event_presenter = {},
LiveBallPresenter live_ball_presenter = {},
LiveChancePresenter live_chance_presenter = {},
LiveShotPresenter live_shot_presenter = {},
LiveSetPiecePresenter live_set_piece_presenter = {},
LiveBookingPresenter live_booking_presenter = {},
LiveShootoutPresenter live_shootout_presenter = {},
LiveRealityPresenter live_reality_presenter = {},
PhaseResultPresenter phase_result_presenter = {}, bool enable_autosave = false);
// Focused controller entry for callers that only need to inject the original
// yes/no question presenter; all unrelated synchronous hooks keep defaults.
std::string serve_flow_request(ui::StartupFlow&, const ui::FlowResult&,
std::unique_ptr<CareerSession>&, const std::filesystem::path& data,
const std::filesystem::path& save_directory, uint32_t seed, uint64_t& revision,
openbmh::audio::Playback&, std::optional<uint64_t>& audio_session, bool music_enabled,
NationalFriendlyQuestionPresenter national_friendly_question_presenter);
} // namespace bmh::app
+564
View File
@@ -0,0 +1,564 @@
// SPDX-License-Identifier: GPL-3.0-only
#include "formats/executable_layout.hpp"
#include "app/desktop_actions.hpp"
#include "app/action_transaction.hpp"
#include <algorithm>
namespace bmh::app {
ui::DeskRequest DesktopActions::menu(const ui::DeskState& observed, int kind) {
ui::DeskRequest request;
request.kind = ui::DeskRequestKind::open_menu;
request.menu_kind = kind;
request.manager_slot = observed.manager_slot;
request.revision = observed.revision;
for (const auto& item : observed.items)
if (item.kind == kind) request.item_id = item.id;
return request;
}
bool DeskSettingsActions::apply(uint64_t& revision, const std::function<bool()>& action) {
return detail::apply_window(session_, revision, session_.desk_settings_checkpoint(revision),
[&](CareerSession::DeskSettingsCheckpoint before) {
session_.restore_desk_settings_checkpoint(std::move(before), revision);
}, action);
}
std::optional<CareerSession::DeskSettingsProjection> DeskSettingsActions::open(
const ui::DeskRequest& request, uint64_t& revision, std::string& error, const OpenAccept& acknowledge) {
std::optional<CareerSession::DeskSettingsProjection> result;
apply(revision, [&] {
result = session_.open_desk_settings(request, revision, error);
if (!result) return false;
if (acknowledge) acknowledge(*result);
return true;
});
return result;
}
std::optional<CareerSession::DeskSettingsDispatch> DeskSettingsActions::dispatch(
const CareerSession::DeskSettingsAction& request, uint64_t& revision, std::string& error,
const Accept& acknowledge) {
std::optional<CareerSession::DeskSettingsDispatch> result;
apply(revision, [&] {
result = session_.dispatch_desk_settings(request, revision, error);
if (!result) return false;
if (acknowledge) acknowledge(*result);
return true;
});
return result;
}
std::optional<CareerSession::DeskSettingsDispatch> DeskSettingsActions::write(uint64_t sequence,
const ui::SettingsWriteRequest& request, uint64_t& revision, std::string& error, const Accept& acknowledge) {
return dispatch(CareerSession::DeskSettingsWrite{sequence, request}, revision, error, acknowledge);
}
std::optional<CareerSession::DeskSettingsDispatch> DeskSettingsActions::file(uint64_t sequence,
const ui::SaveLoadRequest& request, uint64_t& revision, std::string& error, const Accept& acknowledge) {
return dispatch(CareerSession::DeskSettingsFile{sequence, request}, revision, error, acknowledge);
}
std::optional<CareerSession::DeskSettingsDispatch> DeskSettingsActions::close(uint64_t sequence,
uint64_t owner_revision, const ui::DeskRequest& observed, uint64_t& revision, std::string& error,
const Accept& acknowledge) {
const CareerSession::DeskSettingsOwner owner{sequence, owner_revision, observed.manager_slot, observed.item_id};
return dispatch(CareerSession::DeskSettingsClose{owner}, revision, error, acknowledge);
}
bool DeskSettingsActions::edit(const ui::SettingsState& observed, int row, int column, ui::SettingsEdit operation,
uint64_t& revision, std::string& error) {
ui::SettingsWriteRequest request;
request.manager_slot = observed.manager_slot;
request.revision = observed.revision;
request.expected_raw = observed.cells;
request.row = uint8_t(row);
request.column = uint8_t(column);
request.operation = operation;
return apply(revision, [&] { return session_.dispatch_settings(request, revision, error); });
}
bool BalanceActions::apply(uint64_t& revision, const std::function<bool()>& action) {
return detail::apply_window(session_, revision, session_.balance_checkpoint(),
[&](CareerSession::BalanceCheckpoint before) { session_.restore_balance_checkpoint(std::move(before)); }, action);
}
std::optional<ui::BalanceState> BalanceActions::open(const ui::DeskRequest& request,
uint64_t& revision, const Image& underlay, std::string& error, const OpenAccept& acknowledge) {
std::optional<ui::BalanceState> result;
apply(revision, [&] {
result = session_.open_balance_plan(request, revision, underlay, error);
if (!result) return false;
if (acknowledge) acknowledge(*result);
return true;
});
return result;
}
std::optional<CareerSession::BalanceDispatch> BalanceActions::dispatch(const ui::BalanceRequest& request,
uint64_t& revision, std::string& error, const Accept& acknowledge) {
std::optional<CareerSession::BalanceDispatch> result;
apply(revision, [&] {
result = session_.dispatch_balance_plan(request, revision, error);
if (!result) return false;
if (acknowledge) acknowledge(*result);
return true;
});
return result;
}
BalancePlanDraft BalanceActions::open_draft(int manager) const { return bmh::open_balance_plan(session_.state(), manager); }
void BalanceActions::cycle_draft(BalancePlanDraft& draft) const { cycle_balance_view(session_.state(), draft); }
void BalanceActions::reset_draft(BalancePlanDraft& draft) const { reset_balance_plan(session_.state(), draft); }
BalanceEditStatus BalanceActions::edit_draft(BalancePlanDraft& draft, int row, int32_t value) const {
return edit_balance_plan(session_.state(), draft, row, value);
}
bool BalanceActions::close_draft(const BalancePlanDraft& draft, uint64_t& revision) {
bool warning = false;
apply(revision, [&] {
warning = bmh::close_balance_plan(session_.state(), draft);
++revision;
return true;
});
return warning;
}
bool OtherGamesActions::apply(uint64_t& revision, const std::function<bool()>& action) {
return detail::apply_window(session_, revision, session_.other_games_checkpoint(),
[&](CareerSession::OtherGamesCheckpoint before) { session_.restore_other_games_checkpoint(std::move(before)); }, action);
}
std::optional<ui::OtherGamesState> OtherGamesActions::open(const ui::DeskRequest& request,
uint64_t& revision, const Image& underlay, std::string& error, const OpenAccept& acknowledge) {
std::optional<ui::OtherGamesState> result;
apply(revision, [&] {
result = session_.open_other_games(request, revision, underlay, error);
if (!result) return false;
if (acknowledge) acknowledge(*result);
return true;
});
return result;
}
std::optional<CareerSession::OtherGamesDispatch> OtherGamesActions::dispatch(const ui::OtherGamesRequest& request,
uint64_t& revision, std::string& error, const TransferOfferTeamInfoPresenter& team_info, const Accept& acknowledge) {
std::optional<CareerSession::OtherGamesDispatch> result;
apply(revision, [&] {
result = session_.dispatch_other_games(request, revision, error, team_info);
if (!result) return false;
if (acknowledge) acknowledge(*result);
return true;
});
return result;
}
bool TopScorersActions::apply(uint64_t& revision, const std::function<bool()>& action) {
return detail::apply_window(session_, revision, session_.top_scorers_checkpoint(),
[&](CareerSession::TopScorersCheckpoint before) { session_.restore_top_scorers_checkpoint(std::move(before)); }, action);
}
std::optional<ui::TopScorersState> TopScorersActions::open(const ui::DeskRequest& request,
uint64_t& revision, const Image& underlay, std::string& error, const OpenAccept& acknowledge) {
std::optional<ui::TopScorersState> result;
apply(revision, [&] {
result = session_.open_top_scorers(request, revision, underlay, error);
if (!result) return false;
++revision; // Preserve the existing menu-20 opening revision.
if (acknowledge) acknowledge(*result);
return true;
});
return result;
}
std::optional<CareerSession::TopScorersDispatch> TopScorersActions::dispatch(const ui::TopScorersRequest& request,
uint64_t& revision, std::string& error, const Accept& acknowledge) {
std::optional<CareerSession::TopScorersDispatch> result;
apply(revision, [&] {
result = session_.dispatch_top_scorers(request, revision, error);
if (!result) return false;
if (acknowledge) acknowledge(*result);
return true;
});
return result;
}
bool OpportunitiesActions::apply(uint64_t& revision, const std::function<bool()>& action) {
return detail::apply_window(session_, revision, session_.opportunities_checkpoint(),
[&](CareerSession::OpportunitiesCheckpoint before) { session_.restore_opportunities_checkpoint(std::move(before)); }, action);
}
std::optional<ui::OpportunitiesState> OpportunitiesActions::open(const ui::DeskRequest& request,
uint64_t& revision, const Image& underlay, std::string& error, bool national_source_case,
int stable_identity, const OpenAccept& acknowledge) {
std::optional<ui::OpportunitiesState> result;
apply(revision, [&] {
result = session_.open_opportunities(request, revision, underlay, error, national_source_case, stable_identity);
if (!result) return false;
++revision;
if (acknowledge) acknowledge(*result);
return true;
});
return result;
}
std::optional<CareerSession::OpportunitiesDispatch> OpportunitiesActions::dispatch(const ui::OpportunitiesRequest& request,
uint64_t& revision, std::string& error, const Accept& acknowledge) {
std::optional<CareerSession::OpportunitiesDispatch> result;
apply(revision, [&] {
result = session_.dispatch_opportunities(request, revision, error);
if (!result) return false;
if (acknowledge) acknowledge(*result);
return true;
});
return result;
}
bool OpportunitiesActions::preference(const ui::AnalyticsRequest& request, uint64_t& revision,
std::string& error, const std::function<void()>& acknowledge) {
return apply(revision, [&] {
if (!session_.apply_statistics_preference(request.owner, request.manager_slot,
request.expected_flags, request.target_flags, revision, error)) return false;
if (revision == UINT64_MAX) throw FormatError("statistics: revision exhausted");
++revision;
if (acknowledge) acknowledge();
return true;
});
}
ui::OpportunitiesRequest OpportunitiesActions::close_request(const ui::OpportunitiesState& observed) {
return {observed.identity, ui::OpportunitiesAction::close, observed.mode};
}
bool ManagerJoinActions::apply(uint64_t& revision, const std::function<bool()>& action) {
return detail::apply_window(session_, revision, session_.manager_join_checkpoint(),
[&](CareerSession::ManagerJoinCheckpoint before) { session_.restore_manager_join_checkpoint(std::move(before)); }, action);
}
bool ManagerJoinActions::commit(uint64_t& revision, std::string& error,
const std::function<void(ui::CareerInitializationResult&)>& acknowledge) {
return apply(revision, [&] {
ui::CareerInitializationResult joined;
if (!session_.commit_manager_join(joined, revision, error)) return false;
if (acknowledge) acknowledge(joined);
return true;
});
}
bool MailboxActions::dispatch(const ui::MailboxActionRequest& request, uint64_t& revision,
std::string& error, const std::function<void()>& acknowledge) {
return detail::apply_native(session_, revision, [&] {
if (!session_.dispatch_mailbox(request, revision, error)) return false;
if (acknowledge) acknowledge();
return true;
});
}
bool MailboxActions::close(const ui::MailboxCloseRequest& request, uint64_t& revision,
std::string& error, const std::function<void()>& acknowledge) {
return detail::apply_native(session_, revision, [&] {
if (!session_.acknowledge_mailbox_close(request, revision, error)) return false;
if (acknowledge) acknowledge();
return true;
});
}
ui::MailboxActionRequest MailboxActions::request(int manager, uint64_t revision,
ui::MailboxActionKind kind, const ui::MailboxMessage& observed) {
ui::MailboxActionRequest request;
request.kind = kind;
request.manager_slot = manager;
request.revision = revision;
request.entry_index = observed.entry_index;
request.expected_entry = observed.raw_entry;
return request;
}
bool MenuLayoutActions::dispatch(const ui::SaveLoadRequest& request, uint64_t& revision,
std::string& error, const std::function<void()>& acknowledge) {
return detail::apply_native(session_, revision, [&] {
if (!session_.dispatch_menu_layout(request, revision, error)) return false;
if (acknowledge) acknowledge();
return true;
});
}
std::optional<EnvironmentResult> EnvironmentActions::set(const ui::EnvironmentRequest& request,
uint64_t& revision, std::string& error, const Notice& notice, const std::function<void(bool)>& acknowledge) {
return set_impl(request, revision, error, notice, acknowledge, false);
}
std::optional<EnvironmentResult> EnvironmentActions::set_console(const ui::EnvironmentView& observed,
int item, int level, uint64_t& revision, std::string& error, const Notice& notice) {
return set_impl(request(observed, item, level), revision, error, notice, {}, true);
}
std::optional<EnvironmentResult> EnvironmentActions::set_impl(const ui::EnvironmentRequest& request,
uint64_t& revision, std::string& error, const Notice& notice, const std::function<void(bool)>& acknowledge,
bool publish_console_result) {
error.clear();
std::optional<EnvironmentResult> result;
const bool accepted = detail::apply_native(session_, revision, [&] {
const auto& state = session_.state();
if (request.kind != ui::EnvironmentRequestKind::set_item || request.revision != revision ||
request.manager_slot < 0 || request.manager_slot > 3 || !state.memory.has(::bmh::layout::ActiveManager) ||
state.memory.u8(::bmh::layout::ActiveManager) != request.manager_slot ||
size_t(request.manager_slot) >= state.manager_teams.size() ||
state.manager_teams[size_t(request.manager_slot)] != request.runtime_club) {
error = "stale_environment_owner";
return false;
}
auto staged = state;
std::string message;
result = set_environment(staged, request.manager_slot, request.item, request.level, &message);
if (*result == EnvironmentResult::invalid) return true;
if (publish_console_result) session_.state() = staged;
if (!message.empty() && (!notice || !notice(staged, message))) {
if (error.empty()) error = "environment_source_notice_aborted";
return false;
}
const bool changed = *result == EnvironmentResult::changed;
if (changed) {
if (revision == UINT64_MAX) throw FormatError("environment revision exhausted");
++revision;
}
// The old Console called Core directly even for its handled refusals;
// SDL only published a changed result. Preserve both caller semantics.
if (changed || publish_console_result) session_.state() = std::move(staged);
if (acknowledge) acknowledge(changed);
return true;
});
if (!accepted) result.reset();
return result;
}
ui::EnvironmentRequest EnvironmentActions::request(const ui::EnvironmentView& observed, int item, int level) {
ui::EnvironmentRequest request;
request.kind = ui::EnvironmentRequestKind::set_item;
request.manager_slot = observed.manager_slot;
request.runtime_club = observed.runtime_club;
request.revision = observed.revision;
request.owner = observed.owner;
request.item = item;
request.level = level;
return request;
}
bool RescheduleActions::apply(uint64_t& revision, const std::function<bool()>& action) {
return detail::apply_native(session_, revision, action);
}
RescheduleStatus RescheduleActions::change(GameState& state, int manager, const LeagueMatchRef& match,
int day, ui::RescheduleActionKind kind) {
if (kind == ui::RescheduleActionKind::move) return reschedule_league_match(state, manager, match, day);
if (kind == ui::RescheduleActionKind::undo && undo_reschedule(state, manager, day)) return RescheduleStatus::moved;
return RescheduleStatus::invalid_match;
}
RescheduleStatus RescheduleActions::dispatch(const ui::RescheduleAction& request, uint64_t& revision,
const std::function<void()>& acknowledge) {
auto status = RescheduleStatus::invalid_match;
apply(revision, [&] {
const auto& before = session_.state();
const int manager = request.owner.manager_slot;
if (request.owner.kind != ui::DeskRequestKind::open_menu || request.owner.menu_kind != 7 ||
request.owner.revision != revision || revision == UINT64_MAX || !before.memory.has(::bmh::layout::ActiveManager) ||
manager != int(before.memory.u8(::bmh::layout::ActiveManager))) return false;
auto staged = before;
const auto eligible = request.kind == ui::RescheduleActionKind::move
? reschedulable_matches(before, manager) : moved_matches(before, manager);
if (std::find(eligible.begin(), eligible.end(), request.match) != eligible.end())
status = change(staged, manager, request.match, request.target_day, request.kind);
if (status != RescheduleStatus::moved) return false;
session_.state() = std::move(staged);
++revision;
if (acknowledge) acknowledge();
return true;
});
return status;
}
RescheduleStatus RescheduleActions::move(int manager, const LeagueMatchRef& match, int day, uint64_t& revision) {
auto status = RescheduleStatus::invalid_match;
apply(revision, [&] {
status = change(session_.state(), manager, match, day, ui::RescheduleActionKind::move);
if (status != RescheduleStatus::moved) return false;
++revision;
return true;
});
return status;
}
void RescheduleActions::undo_console(int manager, int day, uint64_t& revision) {
apply(revision, [&] {
// Keep the Console's existing accepted-command revision after its own
// observed moved-match selection, including Core's Boolean result.
(void)change(session_.state(), manager, {}, day, ui::RescheduleActionKind::undo);
++revision;
return true;
});
}
bool ContractActions::dispatch(const ui::ContractRequest& request, uint64_t& revision,
ui::ContractActionResult& result, std::string& error, const std::function<void()>& acknowledge) {
bool accepted = false;
try {
return detail::apply_native(session_, revision, [&] {
if (!session_.dispatch_contract(request, revision, result, error)) return false;
accepted = true;
if (acknowledge) acknowledge();
return true;
});
} catch (...) {
// Preserve the old SDL rejection's quote cleanup and consumed-ID policy.
if (accepted) session_.clear_contract_quote();
throw;
}
}
ui::ContractRequest ContractActions::bind(const ui::ContractsState& observed,
ui::ContractActionKind kind, uint64_t request_id) {
ui::ContractRequest request;
request.kind = kind;
request.request_id = request_id;
request.revision = observed.revision;
request.manager_slot = observed.manager_slot;
request.runtime_club = observed.runtime_club;
return request;
}
ui::ContractRequest ContractActions::demands(const ui::ContractsState& observed,
const ui::ContractPlayer& player, uint64_t request_id) {
auto request = bind(observed, ui::ContractActionKind::request_demands, request_id);
request.row = player.row;
request.player_id = player.player_id;
return request;
}
ui::ContractRequest ContractActions::team_bonus(const ui::ContractsState& observed,
int index, uint8_t percent, uint64_t request_id) {
auto request = bind(observed, ui::ContractActionKind::submit_bonuses, request_id);
request.proposed_bonuses = observed.team_premiums;
request.proposed_bonuses.at(size_t(index)) = percent;
return request;
}
ui::ContractRequest ContractActions::insurance(const ui::ContractsState& observed, int row,
int player, uint64_t quote, uint8_t form, uint8_t months, uint64_t request_id) {
auto request = bind(observed, ui::ContractActionKind::insure_player, request_id);
request.row = row; request.player_id = player; request.quote_id = quote;
request.term_column = form; request.insurance_months = months;
return request;
}
ui::ContractRequest ContractActions::offer(const ui::ContractsState& observed, int row,
int player, uint64_t quote, const std::array<uint8_t,7>& bonuses, int years, uint32_t salary,
const std::array<uint32_t,4>& demands, uint64_t request_id) {
auto request = bind(observed, years > 0 ? ui::ContractActionKind::submit_offer : ui::ContractActionKind::submit_bonuses, request_id);
request.row = row; request.player_id = player; request.quote_id = quote;
request.proposed_bonuses = bonuses;
if (years > 0) {
request.term_column = uint8_t(years - 1);
request.demand = demands.at(size_t(years - 1));
request.monthly_salary = salary;
}
return request;
}
bool FriendlyActions::apply(uint64_t& revision, const std::function<bool()>& action) {
return detail::apply_native(session_, revision, action);
}
FriendlyBookingRequest FriendlyActions::booking_request(const ui::FriendlyMatchRequest& observed) {
FriendlyBookingQuote quote;
quote.status = FriendlyQuoteStatus::quoted;
quote.manager = observed.manager_slot;
quote.opponent = observed.opponent;
quote.manager_team = observed.runtime_team;
quote.manager_home = observed.manager_home;
quote.home_team = observed.home_team;
quote.away_team = observed.away_team;
quote.payer_manager = observed.payer_manager;
quote.opponent_manager = observed.opponent_manager;
quote.cost = observed.cost;
quote.planner_count = uint8_t(observed.planner_count);
return {quote, uint16_t(observed.season_day), observed.accept_opponent, observed.consenting_manager,
observed.accept_cost, observed.approving_manager};
}
ui::FriendlyBookingAck FriendlyActions::acknowledgement(const ui::FriendlyMatchRequest& request,
const FriendlyBookingResult& outcome, uint64_t revision) const {
ui::FriendlyBookingAck ack;
ack.request_id = request.request_id; ack.quote_id = request.quote_id; ack.revision = revision;
ack.accepted = true; ack.manager_slot = request.manager_slot; ack.runtime_team = request.runtime_team;
ack.opponent = request.opponent; ack.opponent_manager = outcome.opponent_manager;
ack.season_day = request.season_day; ack.payer_manager = outcome.payer_manager;
ack.home_team = outcome.home_team; ack.away_team = outcome.away_team; ack.cost = outcome.cost;
ack.planner_count = session_.state().memory.u8(::bmh::layout::FriendlyPlanCount);
return ack;
}
FriendlyActions::Booking FriendlyActions::book(const ui::FriendlyMatchRequest& request,
uint64_t& revision, bool national, const Accept& acknowledge) {
Booking result;
result.applied = apply(revision, [&] {
if (request.kind != ui::FriendlyRequestKind::book || request.revision != revision || revision == UINT64_MAX) {
result.result.status = FriendlyBookingStatus::stale_quote;
return false;
}
if (national) {
if (!request.national_booking) return false;
result.result = book_national_friendly_match(session_.state(), *request.national_booking, session_.rand(), session_.game());
} else result.result = book_friendly_match(session_.state(), booking_request(request));
if (result.result.status != FriendlyBookingStatus::booked) return false;
const auto next_revision = revision + 1;
const auto ack = acknowledgement(request, result.result, next_revision);
if (ack.planner_count != request.planner_count + 2) {
result.planner_mismatch = true;
return false;
}
if (acknowledge) acknowledge(ack);
// Preserve the old UI caller's revision during its acknowledgement.
revision = next_revision;
return true;
});
return result;
}
FriendlyActions::Booking FriendlyActions::book_club(const ui::FriendlyMatchRequest& request,
uint64_t& revision, const Accept& acknowledge) { return book(request, revision, false, acknowledge); }
FriendlyActions::Booking FriendlyActions::book_national(const ui::FriendlyMatchRequest& request,
uint64_t& revision, const Accept& acknowledge) { return book(request, revision, true, acknowledge); }
FriendlyBookingResult FriendlyActions::book_console(const FriendlyBookingQuote& quote, uint16_t day,
bool accept_opponent, int consenting_manager, bool accept_cost, int approving_manager, uint64_t& revision) {
FriendlyBookingResult result;
apply(revision, [&] {
result = book_friendly_match(session_.state(),
{quote, day, accept_opponent, consenting_manager, accept_cost, approving_manager});
if (result.status != FriendlyBookingStatus::booked) return false;
++revision;
return true;
});
return result;
}
FriendlyBookingQuote FriendlyActions::quote(int manager, int opponent, bool home) const {
return quote_friendly_match(session_.state(), manager, opponent, home);
}
NationalFriendlyQuote FriendlyActions::national_quote(const NationalFriendlyOwner& owner, int opponent, bool home) {
return quote_national_friendly_match(session_.state(), owner, opponent, home, session_.rand());
}
FriendlyDateStatus FriendlyActions::date_status(const FriendlyBookingQuote& quote, uint16_t day) const {
return friendly_match_date_status(session_.state(), quote, day);
}
FriendlyDateStatus FriendlyActions::national_date_status(const NationalFriendlyQuote& quote,
const NationalFriendlyOwner& owner, uint16_t day) const {
return national_friendly_match_date_status(session_.state(), quote, owner, session_.rand(), day);
}
NationalFriendlyOwner FriendlyActions::national_owner(const ui::FriendlyMatchRequest& request) {
return {request.quote_id, request.revision, request.manager_slot, 0x165, 6};
}
} // namespace bmh::app
+200
View File
@@ -0,0 +1,200 @@
// SPDX-License-Identifier: GPL-3.0-only
#pragma once
#include "app/career_session.hpp"
namespace bmh::app {
class DesktopActions {
public:
static ui::DeskRequest menu(const ui::DeskState& observed, int kind);
};
class DeskSettingsActions {
public:
explicit DeskSettingsActions(CareerSession& session) : session_(session) {}
bool apply(uint64_t& revision, const std::function<bool()>& action);
using OpenAccept = std::function<void(CareerSession::DeskSettingsProjection&)>;
using Accept = std::function<void(CareerSession::DeskSettingsDispatch&)>;
std::optional<CareerSession::DeskSettingsProjection> open(const ui::DeskRequest&,
uint64_t& revision, std::string& error, const OpenAccept& = {});
std::optional<CareerSession::DeskSettingsDispatch> write(uint64_t owner_sequence,
const ui::SettingsWriteRequest&, uint64_t& revision, std::string& error, const Accept& = {});
std::optional<CareerSession::DeskSettingsDispatch> file(uint64_t owner_sequence,
const ui::SaveLoadRequest&, uint64_t& revision, std::string& error, const Accept& = {});
std::optional<CareerSession::DeskSettingsDispatch> close(uint64_t owner_sequence,
uint64_t owner_revision, const ui::DeskRequest& observed,
uint64_t& revision, std::string& error, const Accept& = {});
bool edit(const ui::SettingsState& observed, int row, int column, ui::SettingsEdit,
uint64_t& revision, std::string& error);
private:
std::optional<CareerSession::DeskSettingsDispatch> dispatch(const CareerSession::DeskSettingsAction&,
uint64_t& revision, std::string& error, const Accept&);
CareerSession& session_;
};
class BalanceActions {
public:
explicit BalanceActions(CareerSession& session) : session_(session) {}
bool apply(uint64_t& revision, const std::function<bool()>& action);
using OpenAccept = std::function<void(ui::BalanceState&)>;
using Accept = std::function<void(CareerSession::BalanceDispatch&)>;
std::optional<ui::BalanceState> open(const ui::DeskRequest&, uint64_t& revision,
const Image& underlay, std::string& error, const OpenAccept& = {});
std::optional<CareerSession::BalanceDispatch> dispatch(const ui::BalanceRequest&,
uint64_t& revision, std::string& error, const Accept& = {});
BalancePlanDraft open_draft(int manager) const;
void cycle_draft(BalancePlanDraft&) const;
void reset_draft(BalancePlanDraft&) const;
BalanceEditStatus edit_draft(BalancePlanDraft&, int row, int32_t value) const;
bool close_draft(const BalancePlanDraft&, uint64_t& revision);
private:
CareerSession& session_;
};
class OtherGamesActions {
public:
explicit OtherGamesActions(CareerSession& session) : session_(session) {}
bool apply(uint64_t& revision, const std::function<bool()>& action);
using OpenAccept = std::function<void(ui::OtherGamesState&)>;
using Accept = std::function<void(CareerSession::OtherGamesDispatch&)>;
std::optional<ui::OtherGamesState> open(const ui::DeskRequest&, uint64_t& revision,
const Image& underlay, std::string& error, const OpenAccept& = {});
std::optional<CareerSession::OtherGamesDispatch> dispatch(const ui::OtherGamesRequest&,
uint64_t& revision, std::string& error, const TransferOfferTeamInfoPresenter& = {}, const Accept& = {});
private:
CareerSession& session_;
};
class TopScorersActions {
public:
explicit TopScorersActions(CareerSession& session) : session_(session) {}
bool apply(uint64_t& revision, const std::function<bool()>& action);
using OpenAccept = std::function<void(ui::TopScorersState&)>;
using Accept = std::function<void(CareerSession::TopScorersDispatch&)>;
std::optional<ui::TopScorersState> open(const ui::DeskRequest&, uint64_t& revision,
const Image& underlay, std::string& error, const OpenAccept& = {});
std::optional<CareerSession::TopScorersDispatch> dispatch(const ui::TopScorersRequest&,
uint64_t& revision, std::string& error, const Accept& = {});
private:
CareerSession& session_;
};
class OpportunitiesActions {
public:
explicit OpportunitiesActions(CareerSession& session) : session_(session) {}
bool apply(uint64_t& revision, const std::function<bool()>& action);
using OpenAccept = std::function<void(ui::OpportunitiesState&)>;
using Accept = std::function<void(CareerSession::OpportunitiesDispatch&)>;
std::optional<ui::OpportunitiesState> open(const ui::DeskRequest&, uint64_t& revision,
const Image& underlay, std::string& error, bool national_source_case = false,
int stable_identity = -1, const OpenAccept& = {});
std::optional<CareerSession::OpportunitiesDispatch> dispatch(const ui::OpportunitiesRequest&,
uint64_t& revision, std::string& error, const Accept& = {});
bool preference(const ui::AnalyticsRequest&, uint64_t& revision, std::string& error,
const std::function<void()>& acknowledge = {});
static ui::OpportunitiesRequest close_request(const ui::OpportunitiesState& observed);
private:
CareerSession& session_;
};
class ManagerJoinActions {
public:
explicit ManagerJoinActions(CareerSession& session) : session_(session) {}
bool apply(uint64_t& revision, const std::function<bool()>& action);
bool commit(uint64_t& revision, std::string& error,
const std::function<void(ui::CareerInitializationResult&)>& acknowledge = {});
private:
CareerSession& session_;
};
class MailboxActions {
public:
explicit MailboxActions(CareerSession& session) : session_(session) {}
bool dispatch(const ui::MailboxActionRequest&, uint64_t& revision, std::string& error,
const std::function<void()>& acknowledge = {});
bool close(const ui::MailboxCloseRequest&, uint64_t& revision, std::string& error,
const std::function<void()>& acknowledge = {});
static ui::MailboxActionRequest request(int manager, uint64_t revision,
ui::MailboxActionKind, const ui::MailboxMessage& observed);
private:
CareerSession& session_;
};
class MenuLayoutActions {
public:
explicit MenuLayoutActions(CareerSession& session) : session_(session) {}
bool dispatch(const ui::SaveLoadRequest&, uint64_t& revision, std::string& error,
const std::function<void()>& acknowledge = {});
private:
CareerSession& session_;
};
class EnvironmentActions {
public:
explicit EnvironmentActions(CareerSession& session) : session_(session) {}
using Notice = std::function<bool(const GameState&, const std::string&)>;
std::optional<EnvironmentResult> set(const ui::EnvironmentRequest&, uint64_t& revision, std::string& error,
const Notice& = {}, const std::function<void(bool changed)>& acknowledge = {});
std::optional<EnvironmentResult> set_console(const ui::EnvironmentView&, int item, int level,
uint64_t& revision, std::string& error, const Notice& = {});
static ui::EnvironmentRequest request(const ui::EnvironmentView& observed, int item, int level);
private:
std::optional<EnvironmentResult> set_impl(const ui::EnvironmentRequest&, uint64_t&, std::string&,
const Notice&, const std::function<void(bool)>&, bool publish_console_result);
CareerSession& session_;
};
class RescheduleActions {
public:
explicit RescheduleActions(CareerSession& session) : session_(session) {}
bool apply(uint64_t& revision, const std::function<bool()>& action);
RescheduleStatus dispatch(const ui::RescheduleAction&, uint64_t& revision,
const std::function<void()>& acknowledge = {});
RescheduleStatus move(int manager, const LeagueMatchRef&, int day, uint64_t& revision);
void undo_console(int manager, int day, uint64_t& revision);
private:
static RescheduleStatus change(GameState&, int manager, const LeagueMatchRef&, int day, ui::RescheduleActionKind);
CareerSession& session_;
};
class ContractActions {
public:
explicit ContractActions(CareerSession& session) : session_(session) {}
bool dispatch(const ui::ContractRequest&, uint64_t& revision, ui::ContractActionResult&, std::string& error,
const std::function<void()>& acknowledge = {});
static ui::ContractRequest demands(const ui::ContractsState&, const ui::ContractPlayer&, uint64_t request_id);
static ui::ContractRequest team_bonus(const ui::ContractsState&, int index, uint8_t percent, uint64_t request_id);
static ui::ContractRequest insurance(const ui::ContractsState&, int row, int player, uint64_t quote,
uint8_t form, uint8_t months, uint64_t request_id);
static ui::ContractRequest offer(const ui::ContractsState&, int row, int player, uint64_t quote,
const std::array<uint8_t,7>& bonuses, int years, uint32_t salary,
const std::array<uint32_t,4>& demands, uint64_t request_id);
private:
static ui::ContractRequest bind(const ui::ContractsState&, ui::ContractActionKind, uint64_t request_id);
CareerSession& session_;
};
class FriendlyActions {
public:
explicit FriendlyActions(CareerSession& session) : session_(session) {}
struct Booking { FriendlyBookingResult result; bool applied = false, planner_mismatch = false; };
using Accept = std::function<void(const ui::FriendlyBookingAck&)>;
bool apply(uint64_t& revision, const std::function<bool()>& action);
Booking book_club(const ui::FriendlyMatchRequest&, uint64_t& revision, const Accept& = {});
Booking book_national(const ui::FriendlyMatchRequest&, uint64_t& revision, const Accept& = {});
FriendlyBookingResult book_console(const FriendlyBookingQuote&, uint16_t day, bool accept_opponent,
int consenting_manager, bool accept_cost, int approving_manager, uint64_t& revision);
FriendlyBookingQuote quote(int manager, int opponent, bool home) const;
NationalFriendlyQuote national_quote(const NationalFriendlyOwner&, int opponent, bool home);
FriendlyDateStatus date_status(const FriendlyBookingQuote&, uint16_t day) const;
FriendlyDateStatus national_date_status(const NationalFriendlyQuote&, const NationalFriendlyOwner&, uint16_t day) const;
static NationalFriendlyOwner national_owner(const ui::FriendlyMatchRequest&);
private:
Booking book(const ui::FriendlyMatchRequest&, uint64_t& revision, bool national, const Accept&);
static FriendlyBookingRequest booking_request(const ui::FriendlyMatchRequest&);
ui::FriendlyBookingAck acknowledgement(const ui::FriendlyMatchRequest&, const FriendlyBookingResult&, uint64_t revision) const;
CareerSession& session_;
};
} // namespace bmh::app
+47
View File
@@ -0,0 +1,47 @@
// SPDX-License-Identifier: GPL-3.0-only
#pragma once
#include <SDL.h>
#include <optional>
#include <vector>
namespace bmh::app {
// EndPhase accepts physical left/right DOWN after minute2, except at the
// first minute of a period. Its home interval ends at0x73, leaving0x74 out.
// Returning only a side keeps the current fixture/manager lookup in Main.
inline std::optional<int> live_matchday_board_side(const SDL_Event& event, int minute, bool indoor) {
if (event.type != SDL_MOUSEBUTTONDOWN ||
(event.button.button != SDL_BUTTON_LEFT && event.button.button != SDL_BUTTON_RIGHT) ||
minute <= 2 || (indoor ? minute == 21 : (minute == 46 || minute == 91 || minute == 106)))
return {};
if (event.button.x >= 0 && event.button.x <= 0x73) return 0;
if (event.button.x >= 0xa0 && event.button.x <= 0x113) return 1;
return {};
}
// Drain only while the engine is synchronously paused in its observer hook.
// ESC skips future presentation; QUIT is reported to the app. Only noninteractive
// system/window notifications are put back. User input is discarded so it cannot
// become an accidental desk/result action after the synchronous match finishes.
inline bool pump_live_matchday_events(bool& skip_presentation) {
std::vector<SDL_Event> deferred;
SDL_Event event;
bool quit = false;
while (SDL_PollEvent(&event)) {
if (event.type == SDL_QUIT) {
quit = true;
skip_presentation = true;
} else if (event.type == SDL_KEYDOWN && event.key.keysym.sym == SDLK_ESCAPE) {
skip_presentation = true;
} else if (event.type == SDL_USEREVENT || event.type == SDL_WINDOWEVENT ||
event.type == SDL_DISPLAYEVENT || event.type == SDL_SYSWMEVENT) {
deferred.push_back(event);
}
}
for (auto pending : deferred) SDL_PushEvent(&pending);
return quit;
}
} // namespace bmh::app
+3969
View File
File diff suppressed because it is too large. Load diff
+509
View File
@@ -0,0 +1,509 @@
// SPDX-License-Identifier: GPL-3.0-only
#include "formats/executable_layout.hpp"
#include "app/window_actions.hpp"
#include "app/action_transaction.hpp"
#include "game/save.hpp"
#include "game/lineup.hpp"
#include <algorithm>
#include <limits>
namespace bmh::app {
using detail::apply_window;
bool LeagueFamilyActions::apply(uint64_t& revision, const std::function<bool()>& action) {
auto before = session_.league_family_checkpoint();
const auto old_revision = revision;
try {
if (action()) return true;
} catch (...) {
session_.restore_league_family_checkpoint(std::move(before));
revision = old_revision;
throw;
}
session_.restore_league_family_checkpoint(std::move(before));
revision = old_revision;
return false;
}
std::optional<ui::LeaguePairingsState> LeagueFamilyActions::open_pairings(
const ui::DeskState& observed, uint64_t& revision, std::string& error) {
ui::DeskRequest request;
request.kind = ui::DeskRequestKind::open_menu;
request.menu_kind = 1;
request.manager_slot = observed.manager_slot;
request.revision = observed.revision;
for (const auto& item : observed.items)
if (item.kind == 1) request.item_id = item.id;
std::optional<ui::LeaguePairingsState> result;
apply(revision, [&] {
result = session_.open_league_pairings(request, revision, error);
return result.has_value();
});
return result;
}
std::optional<CareerSession::LeaguePairingsDispatch> LeagueFamilyActions::pairings(
const ui::LeaguePairingsIdentity& observed, LeaguePairingsAction kind, int value,
uint64_t& revision, std::string& error) {
ui::LeaguePairingsRequest request;
request.identity = observed;
request.event.kind = kind;
request.event.value = value;
std::optional<CareerSession::LeaguePairingsDispatch> result;
apply(revision, [&] {
result = session_.dispatch_league_pairings(request, revision, error);
return result.has_value();
});
return result;
}
ui::DeskRequest LeagueFamilyActions::pairings_entry(const ui::StrengthsIdentity& identity,
uint64_t revision) {
return {ui::DeskRequestKind::open_menu, identity.manager, 0, 1, -1, revision};
}
ui::LeaguePairingsRequest LeagueFamilyActions::pairings_selection(
const ui::LeaguePairingsIdentity& identity, int league) {
return {identity, {LeaguePairingsAction::select_league, league, -1}};
}
ui::StrengthsRequest LeagueFamilyActions::strengths_entry(const ui::StrengthsRequest& fresh,
const ui::StrengthsIdentity& identity) {
auto request = fresh;
request.identity = identity;
request.kind = ui::StrengthsAction::open;
return request;
}
bool TransferActions::apply(uint64_t& revision, const std::function<bool()>& action) {
auto state = session_.g_;
const auto game = session_.game_;
const auto rand = session_.rand_;
auto owner = session_.transfer_offer_editor_;
auto poach = session_.poach_;
const auto owner_revision = session_.transfer_offer_revision_;
auto runtime = session_.club_modal_runtime_;
const auto old_revision = revision;
const auto restore = [&] {
session_.g_ = std::move(state);
session_.game_ = game;
session_.rand_ = rand;
session_.transfer_offer_editor_ = std::move(owner);
session_.poach_ = std::move(poach);
session_.transfer_offer_revision_ = owner_revision;
session_.club_modal_runtime_ = std::move(runtime);
revision = old_revision;
};
try {
if (action()) return true;
} catch (...) {
restore();
throw;
}
restore();
return false;
}
std::optional<TransferActions::MarketDispatch> TransferActions::market(
const ui::TransferMarketRequest& request, const HumanBuyerSaleHooks& hooks,
uint64_t& revision, std::string& error, HumanBuyerMarketEntryPolicy policy,
const MarketAccept& acknowledge) {
std::optional<MarketDispatch> result;
apply(revision, [&] {
const auto old_revision = revision;
if (policy == HumanBuyerMarketEntryPolicy::normal_interactive) {
const auto action = session_.dispatch_transfer_market(request, hooks, revision, error);
if (!action) return false;
result = MarketDispatch{*action, revision != old_revision};
} else {
// Preserve the legacy caller's threshold draw even for a low offer.
// This path predates the interactive Source sale and has its own
// revision semantics; moving it must not merge the two policies.
error = rejection(request, revision, policy);
if (!error.empty()) return false;
if (request.kind != ui::TransferMarketRequestKind::list_player &&
request.kind != ui::TransferMarketRequestKind::submit_bid) {
error = "Diese Transferaktion ist nicht verfügbar.";
return false;
}
const auto before = save_stream(session_.state());
const auto game_calls = session_.game().calls();
const auto rand_calls = session_.rand().calls();
TransferActionResult action;
if (request.kind == ui::TransferMarketRequestKind::list_player) {
MinuteReport report;
action = list_manager_player(session_.state(), request.manager_slot,
request.squad_row, session_.rand(), report);
if (report.unsupported) throw FormatError("unsupported transfer listing");
} else {
action = submit_transfer_bid(session_.state(), request.bid, session_.rand());
}
const bool changed = session_.game().calls() != game_calls ||
session_.rand().calls() != rand_calls || save_stream(session_.state()) != before;
if (changed) ++revision;
result = MarketDispatch{action, changed};
}
if (acknowledge) acknowledge(*result);
return true;
});
return result;
}
std::string TransferActions::rejection(const ui::TransferMarketRequest& request,
uint64_t revision, HumanBuyerMarketEntryPolicy policy) const {
const auto& state = session_.state();
if (request.manager_slot < 0 || size_t(request.manager_slot) >= state.manager_teams.size() ||
request.manager_slot > 3 || !state.memory.has(::bmh::layout::ActiveManager) ||
state.memory.u8(::bmh::layout::ActiveManager) != request.manager_slot ||
request.runtime_club != state.manager_teams[size_t(request.manager_slot)] ||
request.revision != revision || revision == std::numeric_limits<uint64_t>::max())
return "Dieses Transferangebot gehört zu einem veralteten Spielstand.";
if (request.kind == ui::TransferMarketRequestKind::submit_bid) {
if (request.bid.manager != request.manager_slot || request.squad_row != -1 ||
request.expected_player != -1 ||
std::any_of(request.bid.bonuses.begin(), request.bid.bonuses.end(), [policy](uint32_t value) {
return value > (policy == HumanBuyerMarketEntryPolicy::normal_interactive ? 255u : 100u);
})) return "Die Angaben zum Transferangebot sind ungültig.";
} else if (request.kind == ui::TransferMarketRequestKind::list_player) {
const auto range = squad_range(request.runtime_club);
if (request.squad_row < 0 || size_t(request.squad_row) >= range.count ||
range.first + size_t(request.squad_row) >= state.squad_slots.size() ||
request.expected_player < 0 || request.expected_player >= 0xfff ||
(state.squad_slots[range.first + size_t(request.squad_row)] & 0xfff) != request.expected_player)
return "Dieser Spieler gehört nicht mehr zur gewählten Kaderposition.";
} else if (request.kind != ui::TransferMarketRequestKind::open_offer &&
request.kind != ui::TransferMarketRequestKind::preview_quote &&
request.kind != ui::TransferMarketRequestKind::open_poach)
return "Diese Transferaktion ist nicht verfügbar.";
return {};
}
std::optional<CareerSession::TransferOfferEditorDispatch> TransferActions::open_offer(
const ui::TransferMarketRequest& request, uint64_t& revision, std::string& error,
const OfferAccept& acknowledge) {
std::optional<CareerSession::TransferOfferEditorDispatch> result;
apply(revision, [&] {
result = session_.open_transfer_offer(request, revision, error);
if (!result) return false;
if (acknowledge) acknowledge(*result);
return true;
});
return result;
}
std::optional<CareerSession::TransferMarketPreviewDispatch> TransferActions::preview(
const ui::TransferMarketRequest& request, uint64_t& revision, std::string& error,
const PreviewAccept& acknowledge) {
std::optional<CareerSession::TransferMarketPreviewDispatch> result;
apply(revision, [&] {
result = session_.preview_transfer_market(request, revision, error);
if (!result) return false;
if (acknowledge) acknowledge(*result);
return true;
});
return result;
}
std::optional<CareerSession::TransferOfferEditorDispatch> TransferActions::offer(
const ui::OutgoingTransferRequest& request, const HumanBuyerSaleHooks& hooks,
uint64_t& revision, std::string& error, const TransferOfferTeamInfoPresenter& team_info,
const TransferOfferPlayerInfoPresenter& player_info, const OfferAccept& acknowledge) {
std::optional<CareerSession::TransferOfferEditorDispatch> result;
apply(revision, [&] {
result = session_.dispatch_transfer_offer(request, hooks, revision, error, team_info, player_info);
if (!result) return false;
if (acknowledge) acknowledge(*result);
return true;
});
return result;
}
std::optional<CareerSession::PoachDispatch> TransferActions::poach(int manager, int slot,
uint64_t& revision, std::string& error) {
std::optional<CareerSession::PoachDispatch> result;
apply(revision, [&] {
result = session_.open_poach(manager, slot, revision, error);
return result.has_value();
});
return result;
}
ui::TransferMarketRequest TransferActions::listing(const ui::TransferMarketState& observed,
const ui::TransferMarketSquadItem& item, bool loan) {
ui::TransferMarketRequest request;
request.kind = ui::TransferMarketRequestKind::list_player;
request.offer_is_loan = loan;
request.manager_slot = observed.manager_slot;
request.runtime_club = observed.runtime_club;
request.revision = observed.revision;
request.squad_row = item.row;
request.expected_player = item.player;
request.selected_players.push_back({-1, observed.roster.squad_start_offset + item.row,
item.player, observed.runtime_club, item.row});
return request;
}
ui::TransferMarketRequest TransferActions::opening(const ui::TransferMarketState& observed,
const ui::TransferMarketItem& item, bool loan) {
ui::TransferMarketRequest request;
request.kind = ui::TransferMarketRequestKind::open_offer;
request.offer_is_loan = loan;
request.manager_slot = observed.manager_slot;
request.runtime_club = observed.runtime_club;
request.revision = observed.revision;
if (item.own_bid) request.bid = *item.own_bid;
request.bid.manager = observed.manager_slot;
request.bid.list_entry = item.list_entry;
request.bid.player = item.player;
request.bid.source_slot = item.source_slot;
request.selected_players.push_back({item.list_entry, item.source_slot, item.player, item.seller, -1});
return request;
}
ui::OutgoingTransferRequest TransferActions::editor(const ui::OutgoingTransferEditorState& observed,
ui::OutgoingTransferRequestKind kind, ui::OutgoingTransferField field, uint32_t value) {
ui::OutgoingTransferRequest request;
request.kind = kind;
request.identity = {observed.manager_slot, observed.runtime_club, observed.revision,
observed.list_entry, observed.source_slot, observed.player, observed.seller, observed.bid_slot};
request.field = field;
request.value = value;
request.quote_loan = observed.quote_loan;
request.fee = observed.fee;
request.monthly_salary = observed.monthly_salary;
request.duration_years = observed.duration_years;
request.bonuses = observed.bonuses;
request.quoted_fee = observed.panel.quoted_fee;
request.quoted_monthly_salary = observed.panel.quoted_monthly_salary;
request.quoted_years = observed.panel.quoted_years;
return request;
}
bool BankActions::apply(uint64_t& revision, const std::function<bool()>& action) {
return apply_window(session_, revision, session_.bank_checkpoint(),
[&](CareerSession::BankCheckpoint before) { session_.restore_bank_checkpoint(std::move(before)); }, action);
}
bool BankActions::dispatch(const ui::BankRequest& request, uint64_t& revision, std::string& error,
const std::function<void()>& acknowledge) {
return apply(revision, [&] {
if (!session_.dispatch_bank(request, revision, error)) return false;
if (acknowledge) acknowledge();
return true;
});
}
ui::BankRequest BankActions::bind(const ui::BankState& observed, ui::BankRequestKind kind) {
ui::BankRequest request;
request.kind = kind;
request.manager_slot = observed.manager_slot;
request.runtime_club = observed.runtime_club;
request.revision = observed.revision;
return request;
}
ui::BankRequest BankActions::savings(const ui::BankState& observed, int32_t amount) {
auto request = bind(observed, ui::BankRequestKind::move_to_deposit);
request.amount = amount;
return request;
}
ui::BankRequest BankActions::investment(const ui::BankState& observed, ui::BankRequestKind kind,
int asset, int count) {
auto request = bind(observed, kind);
request.asset_index = asset;
request.count = count;
return request;
}
ui::BankRequest BankActions::credit(const ui::BankState& observed, const BankCreditContext& context,
const BankCreditDraft& draft, bool accept_fees, int counterparty) {
auto request = bind(observed, ui::BankRequestKind::bank_credit);
request.expected_credit = context.saved;
request.credit_edits = draft.edits;
request.accept_credit_fees = accept_fees;
request.credit_counterparty = counterparty;
return request;
}
bool StadiumActions::apply(uint64_t& revision, const std::function<bool()>& action) {
return apply_window(session_, revision, session_.stadium_checkpoint(),
[&](CareerSession::StadiumCheckpoint before) { session_.restore_stadium_checkpoint(std::move(before)); }, action);
}
bool StadiumActions::dispatch(const ui::StadiumRequest& request, uint64_t& revision, std::string& error,
const ConstructionNoticeHook& construction, const SeasonTicketCompensationNoticeHook& compensation,
const std::function<void()>& acknowledge) {
return apply(revision, [&] {
if (!session_.dispatch_stadium(request, revision, error, construction, compensation)) return false;
if (acknowledge) acknowledge();
return true;
});
}
ui::StadiumRequest StadiumActions::request(const ui::StadiumState& observed, ui::StadiumRequestKind kind,
int object, int option, int32_t price, bool accept_tip) {
ui::StadiumRequest request;
request.kind = kind;
request.manager_slot = observed.manager_slot;
request.runtime_club = observed.runtime_club;
request.stable_club_identity = observed.stable_club_identity;
request.revision = observed.revision;
request.scope = observed.scope;
request.sequence = observed.sequence;
request.object = object;
request.option = option;
request.price = price;
request.accept_tip = accept_tip;
return request;
}
bool DeskActions::ticket_price(const ui::DeskState& observed, int price,
uint64_t& revision, std::string& error) {
TicketPriceRequest request;
request.identity.manager_slot = observed.manager_slot;
request.identity.runtime_club = observed.runtime_club;
if (observed.runtime_club >= 0 && size_t(observed.runtime_club) < session_.state().club_ids.size())
request.identity.stable_club_identity = int(session_.state().club_ids[size_t(observed.runtime_club)]);
request.identity.revision = observed.revision;
request.price = price;
return session_.dispatch_ticket_price(request, revision, error);
}
bool LineupActions::apply(uint64_t& revision, const std::function<bool()>& action) {
return apply_window(session_, revision, session_.lineup_checkpoint(),
[&](CareerSession::LineupCheckpoint before) { session_.restore_lineup_checkpoint(std::move(before)); }, action);
}
bool LineupActions::lineup(const ui::LineupRequest& request, uint64_t& revision, std::string& error,
const std::function<void()>& acknowledge) {
return apply(revision, [&] {
if (!session_.dispatch_lineup(request, revision, error)) return false;
if (acknowledge) acknowledge();
return true;
});
}
bool LineupActions::pitch(const ui::PitchRequest& request, uint64_t& revision, std::string& error,
const std::function<void()>& acknowledge) {
return apply(revision, [&] {
if (!session_.dispatch_pitch(request, revision, error)) return false;
if (acknowledge) acknowledge();
return true;
});
}
bool LineupActions::pitch_swap(const ui::PitchRequest& request, uint64_t& revision, std::string& error) {
return apply(revision, [&] { return session_.dispatch_pitch_swap(request, revision, error); });
}
bool LineupActions::order(const ui::LineupState& observed, const ui::LineupPlayer& player,
int aspect, int value, uint64_t& revision) {
return apply(revision, [&] {
if (observed.revision != revision || !set_player_order_source(session_.state(), observed.manager_slot,
observed.runtime_club, player.row, player.player_id, aspect, value)) return false;
++revision;
return true;
});
}
LineupActions::PairTarget LineupActions::pair_target(const ui::PitchRequest& request, int second_row) const {
auto preview = session_.state();
if (!move_pitch_player_source(preview, request.manager_slot, request.runtime_club,
request.row, request.player_id, request.slot, request.old_depth, request.old_lane,
request.new_depth, request.new_lane)) return PairTarget::invalid;
const size_t board = size_t(request.manager_slot) * 0x840;
return preview.tactics.at(board + size_t(request.row) * 0x58 + 0x3f) == second_row &&
preview.tactics.at(board + size_t(second_row) * 0x58 + 0x3f) == request.row
? PairTarget::requested : PairTarget::other_pair;
}
ui::LineupRequest LineupActions::prepare(const ui::LineupState& observed) {
ui::LineupRequest request;
request.kind = ui::LineupRequestKind::prepare_lineup;
request.manager_slot = observed.manager_slot;
request.runtime_club = observed.runtime_club;
request.revision = observed.revision;
return request;
}
ui::LineupRequest LineupActions::swap(const ui::LineupState& observed,
const ui::LineupPlayer& first, const ui::LineupPlayer& second) {
auto request = prepare(observed);
request.kind = ui::LineupRequestKind::swap_players;
request.first_row = first.row; request.second_row = second.row;
request.first_player = first.player_id; request.second_player = second.player_id;
request.first_slot = first.slot; request.second_slot = second.slot;
return request;
}
ui::PitchRequest LineupActions::bind_pitch(const ui::PreparationState& observed, ui::PitchRequestKind kind) {
if (!observed.pitch || !observed.pitch->indoor.has_value())
throw FormatError("pitch: missing observed live mode");
ui::PitchRequest request;
request.kind = kind;
request.manager_slot = observed.lineup.manager_slot;
request.runtime_club = observed.lineup.runtime_club;
request.revision = observed.lineup.revision;
request.indoor = observed.pitch->indoor.value();
return request;
}
ui::PitchRequest LineupActions::swap_pitch(const ui::PreparationState& observed,
const ui::LineupPlayer& first, const ui::LineupPlayer& second) {
auto request = bind_pitch(observed, ui::PitchRequestKind::swap_players);
request.row = first.row; request.player_id = first.player_id; request.slot = first.slot;
request.old_depth = int8_t(first.board[0x41]); request.old_lane = int8_t(first.board[0x42]);
request.second_row = second.row; request.second_player = second.player_id; request.second_slot = second.slot;
return request;
}
ui::PitchRequest LineupActions::page(const ui::PreparationState& observed) {
auto request = bind_pitch(observed, ui::PitchRequestKind::select_pitch_page);
request.expected_mode = uint8_t(observed.pitch->mode);
request.expected_display_word = observed.pitch->native_display_word;
request.expected_set_piece_values = observed.pitch->set_piece_takers;
request.expected_set_piece_signature = observed.pitch->set_piece_signature;
request.page_control = 1;
request.new_display_word = uint16_t(request.expected_display_word ^ 0x000c);
return request;
}
ui::PitchRequest LineupActions::formation(const ui::PreparationState& observed,
ui::PitchRequestKind kind, int slot) {
auto request = bind_pitch(observed, kind);
request.old_weights = request.new_weights = observed.pitch->automatic_weights;
request.formation = slot;
if (kind == ui::PitchRequestKind::save_formation) {
for (size_t row = 0; row < 11; ++row) {
const auto& player = observed.lineup.players.at(row);
request.formation_positions[row] = player.board[0x41];
request.formation_positions[11 + row] = player.board[0x42];
}
}
return request;
}
ui::PitchRequest LineupActions::move(const ui::PreparationState& observed, const ui::LineupPlayer& player,
int depth, int lane) {
auto request = bind_pitch(observed, ui::PitchRequestKind::move_player);
request.old_weights = request.new_weights = observed.pitch->automatic_weights;
request.row = player.row; request.player_id = player.player_id; request.slot = player.slot;
request.old_depth = int8_t(player.board[0x41]); request.old_lane = int8_t(player.board[0x42]);
request.new_depth = depth; request.new_lane = lane;
return request;
}
ui::PitchRequest LineupActions::weight(const ui::PreparationState& observed, int index) {
if (index < 0 || index > 2) throw FormatError("pitch: invalid automatic weight index");
auto request = bind_pitch(observed, ui::PitchRequestKind::set_automatic_weight);
request.old_weights = request.new_weights = observed.pitch->automatic_weights;
request.weight_index = index;
const int shift = 2 * index;
const int next = (((request.old_weights >> shift) & 3) + 1) & 3;
request.new_weights = uint8_t((request.old_weights & ~(3 << shift)) | (next << shift));
return request;
}
} // namespace bmh::app
+122
View File
@@ -0,0 +1,122 @@
// SPDX-License-Identifier: GPL-3.0-only
#pragma once
#include "app/career_session.hpp"
namespace bmh::app {
// Shared application boundary for Table, Pairings and Strengths. The callback
// includes the frontend's acknowledgement; false or an exception rolls back.
class LeagueFamilyActions {
public:
explicit LeagueFamilyActions(CareerSession& session) : session_(session) {}
bool apply(uint64_t& revision, const std::function<bool()>& action);
std::optional<ui::LeaguePairingsState> open_pairings(const ui::DeskState& observed,
uint64_t& revision, std::string& error);
std::optional<CareerSession::LeaguePairingsDispatch> pairings(
const ui::LeaguePairingsIdentity& observed, LeaguePairingsAction, int value,
uint64_t& revision, std::string& error);
static ui::DeskRequest pairings_entry(const ui::StrengthsIdentity&, uint64_t revision);
static ui::LeaguePairingsRequest pairings_selection(const ui::LeaguePairingsIdentity&, int league);
static ui::StrengthsRequest strengths_entry(const ui::StrengthsRequest&, const ui::StrengthsIdentity&);
private:
CareerSession& session_;
};
// Market, quote and outgoing editor share this boundary, including frontend
// acknowledgement and the suspended poaching attempt behind an offer owner.
class TransferActions {
public:
explicit TransferActions(CareerSession& session) : session_(session) {}
bool apply(uint64_t& revision, const std::function<bool()>& action);
std::string rejection(const ui::TransferMarketRequest&, uint64_t revision,
HumanBuyerMarketEntryPolicy) const;
struct MarketDispatch { TransferActionResult action; bool changed = false; };
using MarketAccept = std::function<void(const MarketDispatch&)>;
using OfferAccept = std::function<void(CareerSession::TransferOfferEditorDispatch&)>;
using PreviewAccept = std::function<void(CareerSession::TransferMarketPreviewDispatch&)>;
std::optional<MarketDispatch> market(const ui::TransferMarketRequest&, const HumanBuyerSaleHooks&,
uint64_t& revision, std::string& error,
HumanBuyerMarketEntryPolicy = HumanBuyerMarketEntryPolicy::normal_interactive,
const MarketAccept& = {});
std::optional<CareerSession::TransferOfferEditorDispatch> open_offer(const ui::TransferMarketRequest&,
uint64_t& revision, std::string& error, const OfferAccept& = {});
std::optional<CareerSession::TransferMarketPreviewDispatch> preview(const ui::TransferMarketRequest&,
uint64_t& revision, std::string& error, const PreviewAccept& = {});
std::optional<CareerSession::TransferOfferEditorDispatch> offer(const ui::OutgoingTransferRequest&,
const HumanBuyerSaleHooks&, uint64_t& revision, std::string& error,
const TransferOfferTeamInfoPresenter& = {}, const TransferOfferPlayerInfoPresenter& = {},
const OfferAccept& = {});
std::optional<CareerSession::PoachDispatch> poach(int manager, int squad_slot,
uint64_t& revision, std::string& error);
static ui::TransferMarketRequest listing(const ui::TransferMarketState&,
const ui::TransferMarketSquadItem&, bool loan);
static ui::TransferMarketRequest opening(const ui::TransferMarketState&,
const ui::TransferMarketItem&, bool loan);
static ui::OutgoingTransferRequest editor(const ui::OutgoingTransferEditorState&,
ui::OutgoingTransferRequestKind, ui::OutgoingTransferField, uint32_t value);
private:
CareerSession& session_;
};
class BankActions {
public:
explicit BankActions(CareerSession& session) : session_(session) {}
bool apply(uint64_t& revision, const std::function<bool()>& action);
bool dispatch(const ui::BankRequest&, uint64_t& revision, std::string& error,
const std::function<void()>& acknowledge = {});
static ui::BankRequest savings(const ui::BankState&, int32_t amount);
static ui::BankRequest investment(const ui::BankState&, ui::BankRequestKind, int asset, int count = 0);
static ui::BankRequest credit(const ui::BankState&, const BankCreditContext&,
const BankCreditDraft&, bool accept_fees, int counterparty);
private:
static ui::BankRequest bind(const ui::BankState&, ui::BankRequestKind);
CareerSession& session_;
};
class StadiumActions {
public:
explicit StadiumActions(CareerSession& session) : session_(session) {}
bool apply(uint64_t& revision, const std::function<bool()>& action);
bool dispatch(const ui::StadiumRequest&, uint64_t& revision, std::string& error,
const ConstructionNoticeHook& = {}, const SeasonTicketCompensationNoticeHook& = {},
const std::function<void()>& acknowledge = {});
static ui::StadiumRequest request(const ui::StadiumState&, ui::StadiumRequestKind,
int object = -1, int option = -1, int32_t price = 0, bool accept_tip = false);
private:
CareerSession& session_;
};
class DeskActions {
public:
explicit DeskActions(CareerSession& session) : session_(session) {}
bool ticket_price(const ui::DeskState& observed, int price, uint64_t& revision, std::string& error);
private:
CareerSession& session_;
};
class LineupActions {
public:
explicit LineupActions(CareerSession& session) : session_(session) {}
bool apply(uint64_t& revision, const std::function<bool()>& action);
bool lineup(const ui::LineupRequest&, uint64_t& revision, std::string& error,
const std::function<void()>& acknowledge = {});
bool pitch(const ui::PitchRequest&, uint64_t& revision, std::string& error,
const std::function<void()>& acknowledge = {});
bool pitch_swap(const ui::PitchRequest&, uint64_t& revision, std::string& error);
bool order(const ui::LineupState&, const ui::LineupPlayer&, int aspect, int value, uint64_t& revision);
enum class PairTarget { invalid, other_pair, requested };
PairTarget pair_target(const ui::PitchRequest&, int second_row) const;
static ui::LineupRequest prepare(const ui::LineupState&);
static ui::LineupRequest swap(const ui::LineupState&, const ui::LineupPlayer&, const ui::LineupPlayer&);
static ui::PitchRequest swap_pitch(const ui::PreparationState&, const ui::LineupPlayer&, const ui::LineupPlayer&);
static ui::PitchRequest page(const ui::PreparationState&);
static ui::PitchRequest formation(const ui::PreparationState&, ui::PitchRequestKind, int slot);
static ui::PitchRequest move(const ui::PreparationState&, const ui::LineupPlayer&, int depth, int lane);
static ui::PitchRequest weight(const ui::PreparationState&, int index);
private:
static ui::PitchRequest bind_pitch(const ui::PreparationState&, ui::PitchRequestKind);
CareerSession& session_;
};
} // namespace bmh::app