Initial public OpenBMH 0.1 source (by Codex)
This commit is contained in:
commit
558fbf166b
613 files changed
+168029
No files matched your search
@@ -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
|
||||
@@ -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
@@ -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
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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
File diff suppressed because it is too large.
Load diff
@@ -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
|
||||
@@ -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
|
||||
Reference in new issue
Block a user