Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
93ca832c71 | ||
|
|
09b92c9b2a | ||
|
|
78118a6333 | ||
|
|
73ffd23dcb | ||
|
|
96d52202fc | ||
|
|
f63c0217ef | ||
|
|
73af2a657d | ||
|
|
e088704dff | ||
|
|
287b5a9251 |
No files matched your search
@@ -62,4 +62,4 @@ jobs:
|
||||
GH_TOKEN: ${{ github.token }}
|
||||
RELEASE_TAG: ${{ github.ref_name }}
|
||||
run: |
|
||||
gh release create "$RELEASE_TAG" dist/*.zip dist/SHA256SUMS dist/QA-REPORT.json --draft --verify-tag --title "OpenBMH $RELEASE_TAG" --notes-file docs/release/1.0.8/RELEASE_NOTES.md
|
||||
gh release create "$RELEASE_TAG" dist/*.zip dist/SHA256SUMS dist/QA-REPORT.json --draft --verify-tag --title "OpenBMH $RELEASE_TAG" --notes-file docs/release/1.0.9/RELEASE_NOTES.md
|
||||
+1
-1
@@ -1,6 +1,6 @@
|
||||
# SPDX-License-Identifier: GPL-3.0-only
|
||||
cmake_minimum_required(VERSION 3.24)
|
||||
project(OpenBMH VERSION 1.0.8 LANGUAGES CXX C)
|
||||
project(OpenBMH VERSION 1.0.9 LANGUAGES CXX C)
|
||||
if(APPLE)
|
||||
# Enable native languages before dependencies/subdirectories inherit rules.
|
||||
enable_language(OBJC OBJCXX)
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
# OpenBMH
|
||||
|
||||
**Classic-Version: 1.0.8.** Die originalgetreue Linie bleibt in diesem Repository.
|
||||
**Classic-Version: 1.0.9.** Die originalgetreue Linie bleibt in diesem Repository.
|
||||
Erweiterte Ligen, die gemeinsame deutsche/englische Karriere und der Dateneditor
|
||||
werden separat als **[OpenBMH-Extended 1.0 Beta](https://github.com/Weyoune/OpenBMH-extended)** entwickelt.
|
||||
|
||||
@@ -30,7 +30,7 @@ In Windows PowerShell, use `.\OpenBMH.exe` and `.\openbmh_cli.exe` instead.
|
||||
|
||||
To report a problem, start the game with `-debug`. It then writes `openbmh-debug.log` (timestamped events, errors and refused actions) and `openbmh-stderr.log` into the `debug` sub folder of the save directory, and saves the game there after every match day (`DBG00001.FBM`, `DBG00002.FBM`, ...). Attach the log and the last save to the report.
|
||||
|
||||
Use a writable save directory and keep backups of existing games. German editions are the primary compatibility target. **Football Limited / English data support is experimental**; original V2.20 save import and some edition-specific behaviour remain limited. See the [release notes](docs/release/1.0.8/RELEASE_NOTES.md).
|
||||
Use a writable save directory and keep backups of existing games. German editions are the primary compatibility target. **Football Limited / English data support is experimental**; original V2.20 save import and some edition-specific behaviour remain limited. See the [release notes](docs/release/1.0.9/RELEASE_NOTES.md).
|
||||
|
||||
## Features and direction
|
||||
|
||||
|
||||
@@ -20,11 +20,8 @@ describe deliberate changes; they are not a list of every known compatibility li
|
||||
- [src/game/match_engine.cpp](../src/game/match_engine.cpp): supports designated set-piece takers, the enhanced injury tables, and the extended suspension fields.
|
||||
- [src/game/month.cpp](../src/game/month.cpp): keep the price product in 64 bits until division, retaining per-unit truncation and recipient policy.
|
||||
- [src/game/national.cpp](../src/game/national.cpp): a new arrival must not inherit the previous occupant's retirement/refusal/month-processing flags.
|
||||
- [src/game/season.cpp](../src/game/season.cpp): retains the enhanced academy player-generation strength bands with monthly youth budgets.
|
||||
- [src/game/season.cpp](../src/game/season.cpp): age/retire each player once, even when a temporary offer row references his club slot or regeneration moves him to a later free-agent slot.
|
||||
- [src/game/season.cpp](../src/game/season.cpp): includes transfer-market players in retirement so the five-bit age cannot wrap to 16.
|
||||
- [src/game/season.cpp](../src/game/season.cpp): initializes the empty EM qualifier seeds with national teams, preventing club zero from entering the EM.
|
||||
- [src/game/season.hpp](../src/game/season.hpp): retains the enhanced academy player-generation strength bands with monthly youth budgets.
|
||||
- [src/game/stadium_blocks.cpp](../src/game/stadium_blocks.cpp): allow 144,000 standard places and size-aware construction times while retaining edition-owned unit prices.
|
||||
- [src/game/state.hpp](../src/game/state.hpp): retains designated set-piece selections in the supported manager-record extension.
|
||||
- [src/game/week.cpp](../src/game/week.cpp): widen products before annual-rate division so valid native account amounts do not overflow intermediate sums.
|
||||
|
||||
@@ -0,0 +1,65 @@
|
||||
# OpenBMH Classic 1.0.9
|
||||
|
||||
This release aligns the engine's hard-coded rules with BMH 2026-27 DIAMOND
|
||||
Edition 3.7. It requires the player's own game installation. Extended
|
||||
development remains separate in
|
||||
[OpenBMH-Extended](https://github.com/Weyoune/OpenBMH-extended).
|
||||
|
||||
## Why
|
||||
|
||||
The engine had been checked against an older Diamond build whose executable
|
||||
differs from 3.7 in about 2,700 bytes (50 code ranges, the Diamond patch area
|
||||
and 64 data bytes). Rules from v2.24, an older Diamond and 3.7 were therefore
|
||||
mixed. The routines of the real 3.7 executable were run in an emulator and
|
||||
compared with the engine; every difference found was ported and documented.
|
||||
|
||||
## Changes since 1.0.8
|
||||
|
||||
- **Injuries and cards.** New injury tables (thresholds and durations), the
|
||||
injury history factor 1.25, doctor and insurance caps, and the foul, booking
|
||||
and red-card chances of 3.7.
|
||||
- **Economy.** Credit limit 8,000,000, transfer fee base, DFB fee, advertising
|
||||
base, start capital, bankruptcy limit, championship and cup premiums,
|
||||
periphery prices, contract talk limit and training injury range.
|
||||
- **Weekly processing.** Retirement chance, side rating rhythm for human and
|
||||
computer managers, facility values, per-visitor income and the season
|
||||
ticket price.
|
||||
- **Youth academy.** 3.7 generation with its monthly budget gate. An age check
|
||||
was inverted in the port (older players were recycled the wrong way round);
|
||||
this is fixed.
|
||||
- **Season end.** Retirement and leave rules for the player slots.
|
||||
- **Live match statistics.** The chance counters at the bottom of the live
|
||||
matchday screen counted a chance as soon as the engine logged it, before the
|
||||
presentation started. They are now held back like the score and appear with
|
||||
the result of the chance.
|
||||
|
||||
## What was measured, what was derived
|
||||
|
||||
Compared with the 3.7 executable without any difference (boundary values and a
|
||||
deliberately wrong result per rule that must fail): random generator, market
|
||||
value, bank annuity, club mood and flags, cup tie order, advertising offers,
|
||||
bid rating, poaching, facility ageing and damage, manager offers, weekly
|
||||
statistics, familiarity decay, squad training, daily interest, youth academy,
|
||||
month change, new transfer list entries, and injuries including doctor and
|
||||
insurance (932 runs).
|
||||
|
||||
Derived from the constants of the 3.7 code but **not** measured in the
|
||||
emulator: foul and card chances in a match, and several economy numbers.
|
||||
Not covered: the complete weekly processing routine, and the amounts of newly
|
||||
created transfer bids (the original reads a stale stack value there; documented
|
||||
in the source as a known gap).
|
||||
|
||||
## Open points
|
||||
|
||||
Reported by the Diamond author and not changed here: the bug in "fetch player
|
||||
from transfer market / check offers" (exact steps still to be reproduced).
|
||||
Earlier open points remain: the
|
||||
"player card: original atlas bounds" error (#77), sporadic double clicks (#58)
|
||||
and the macOS match scene speed (#70).
|
||||
|
||||
## Known limits
|
||||
|
||||
The compatibility and long-career limits documented for
|
||||
[1.0.3](../1.0.3/RELEASE_NOTES.md) remain. Football Limited is experimental;
|
||||
its original V2.20 save layout remains unsupported. Keep backups of saves.
|
||||
macOS packages are unsigned terminal executables, not notarised app bundles.
|
||||
@@ -1,4 +1,10 @@
|
||||
// SPDX-License-Identifier: GPL-3.0-only
|
||||
// All-or-nothing wrapper for one UI window action on a CareerSession (used by
|
||||
// desktop_actions.cpp and window_actions.cpp). It snapshots the game state, the RNG and the
|
||||
// revision counter, runs the action and, if the action returns false or throws, restores
|
||||
// all three, so a rejected action leaves no half-applied change behind.
|
||||
// apply_native() is the variant for owners that keep their state in CareerSession::state().
|
||||
// Header-only; owns no state of its own.
|
||||
#pragma once
|
||||
|
||||
#include "app/career_session.hpp"
|
||||
|
||||
@@ -1,4 +1,11 @@
|
||||
// SPDX-License-Identifier: GPL-3.0-only
|
||||
// Glue between the original-audio engine (src/audio/playback.hpp) and the app: builds the
|
||||
// asset set from the game's sound containers and the frequency/operator tables read from the
|
||||
// executable, derives the music/click/match-sound options from the saved settings bytes of
|
||||
// the GameState, and sends sound commands only when the original sound path is ready.
|
||||
// OriginalMouseSound is an SDL event watch that plays the click sound on each real mouse
|
||||
// button press; it touches only the Playback object, never the GameState, because the
|
||||
// watch can run on SDL's event thread. Header-only.
|
||||
#include "formats/executable_layout.hpp"
|
||||
#pragma once
|
||||
|
||||
|
||||
File diff suppressed because it is too large.
Load diff
File diff suppressed because it is too large.
Load diff
@@ -1,4 +1,11 @@
|
||||
// SPDX-License-Identifier: GPL-3.0-only
|
||||
// The controller: the one synchronous boundary between the UI flow (ui::StartupFlow) and
|
||||
// the engine session (CareerSession). The flow turns a click or key into a ui::FlowResult
|
||||
// that carries a request; serve_flow_request() validates it against the current revision,
|
||||
// calls the session, and acknowledges the outcome back to the flow. Everything the engine
|
||||
// needs from the front end (dialogs, live match presentation, notices) is passed in as
|
||||
// std::function "presenter" hooks, so tests can drive the same code without a window.
|
||||
// Pairs with controller.cpp; the real hooks are supplied by main.cpp.
|
||||
#pragma once
|
||||
|
||||
#include "app/career_session.hpp"
|
||||
|
||||
@@ -1,4 +1,8 @@
|
||||
// SPDX-License-Identifier: GPL-3.0-only
|
||||
// Debug mode (command line -debug): a process-wide, mutex-protected log file plus numbered
|
||||
// automatic savegames, both kept in one folder. State is a function-local static; every
|
||||
// function is a no-op until init() has succeeded, so callers may log unconditionally.
|
||||
// init() also redirects stderr into the same folder. Header-only.
|
||||
#pragma once
|
||||
|
||||
#include <chrono>
|
||||
|
||||
@@ -1,4 +1,10 @@
|
||||
// SPDX-License-Identifier: GPL-3.0-only
|
||||
// Implementation of the desk-level action facades declared in desktop_actions.hpp. Each
|
||||
// method checkpoints the relevant session owner, runs the request through CareerSession,
|
||||
// lets the accept callback acknowledge the result to the UI, and rolls everything back via
|
||||
// detail::apply_window if the callback returns false or throws. Errors are returned through
|
||||
// the std::string& error parameter. The request/acknowledge flow as a whole is described
|
||||
// at the top of controller.cpp.
|
||||
#include "formats/executable_layout.hpp"
|
||||
#include "app/desktop_actions.hpp"
|
||||
#include "app/action_transaction.hpp"
|
||||
@@ -7,6 +13,8 @@
|
||||
|
||||
namespace bmh::app {
|
||||
|
||||
// Builds the desk request that opens menu `kind` for the observed manager; the item id is
|
||||
// taken from the desk item of that kind.
|
||||
ui::DeskRequest DesktopActions::menu(const ui::DeskState& observed, int kind) {
|
||||
ui::DeskRequest request;
|
||||
request.kind = ui::DeskRequestKind::open_menu;
|
||||
@@ -18,6 +26,8 @@ ui::DeskRequest DesktopActions::menu(const ui::DeskState& observed, int kind) {
|
||||
return request;
|
||||
}
|
||||
|
||||
// Runs `action` as a transaction on the desk settings owner; the checkpoint is restored
|
||||
// if the action fails.
|
||||
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) {
|
||||
@@ -25,6 +35,7 @@ bool DeskSettingsActions::apply(uint64_t& revision, const std::function<bool()>&
|
||||
}, action);
|
||||
}
|
||||
|
||||
// Opens the desk settings screen; `acknowledge` receives the projection on success.
|
||||
std::optional<CareerSession::DeskSettingsProjection> DeskSettingsActions::open(
|
||||
const ui::DeskRequest& request, uint64_t& revision, std::string& error, const OpenAccept& acknowledge) {
|
||||
std::optional<CareerSession::DeskSettingsProjection> result;
|
||||
@@ -37,6 +48,7 @@ std::optional<CareerSession::DeskSettingsProjection> DeskSettingsActions::open(
|
||||
return result;
|
||||
}
|
||||
|
||||
// Sends any settings action (write, file, close) to the session in one transaction.
|
||||
std::optional<CareerSession::DeskSettingsDispatch> DeskSettingsActions::dispatch(
|
||||
const CareerSession::DeskSettingsAction& request, uint64_t& revision, std::string& error,
|
||||
const Accept& acknowledge) {
|
||||
@@ -50,16 +62,19 @@ std::optional<CareerSession::DeskSettingsDispatch> DeskSettingsActions::dispatch
|
||||
return result;
|
||||
}
|
||||
|
||||
// Dispatches a settings write for the owner identified by `sequence`.
|
||||
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);
|
||||
}
|
||||
|
||||
// Dispatches a settings file (save/load) request for the owner `sequence`.
|
||||
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);
|
||||
}
|
||||
|
||||
// Dispatches the close of the settings owner, built from the observed desk request.
|
||||
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) {
|
||||
@@ -67,6 +82,8 @@ std::optional<CareerSession::DeskSettingsDispatch> DeskSettingsActions::close(ui
|
||||
return dispatch(CareerSession::DeskSettingsClose{owner}, revision, error, acknowledge);
|
||||
}
|
||||
|
||||
// Applies one edit (row, column, operation) to the settings cells; the request carries
|
||||
// the observed cells so that a stale view is detected.
|
||||
bool DeskSettingsActions::edit(const ui::SettingsState& observed, int row, int column, ui::SettingsEdit operation,
|
||||
uint64_t& revision, std::string& error) {
|
||||
ui::SettingsWriteRequest request;
|
||||
@@ -79,11 +96,13 @@ bool DeskSettingsActions::edit(const ui::SettingsState& observed, int row, int c
|
||||
return apply(revision, [&] { return session_.dispatch_settings(request, revision, error); });
|
||||
}
|
||||
|
||||
// Runs `action` as a transaction restoring the balance checkpoint on failure.
|
||||
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);
|
||||
}
|
||||
|
||||
// Opens the balance (finance plan) screen over `underlay`.
|
||||
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;
|
||||
@@ -96,6 +115,7 @@ std::optional<ui::BalanceState> BalanceActions::open(const ui::DeskRequest& requ
|
||||
return result;
|
||||
}
|
||||
|
||||
// Sends a balance screen request to the session in one transaction.
|
||||
std::optional<CareerSession::BalanceDispatch> BalanceActions::dispatch(const ui::BalanceRequest& request,
|
||||
uint64_t& revision, std::string& error, const Accept& acknowledge) {
|
||||
std::optional<CareerSession::BalanceDispatch> result;
|
||||
@@ -108,13 +128,20 @@ std::optional<CareerSession::BalanceDispatch> BalanceActions::dispatch(const ui:
|
||||
return result;
|
||||
}
|
||||
|
||||
// Draft helpers for the console balance plan (thin wrappers around the game functions):
|
||||
// open a draft for a manager,
|
||||
BalancePlanDraft BalanceActions::open_draft(int manager) const { return bmh::open_balance_plan(session_.state(), manager); }
|
||||
// switch its view,
|
||||
void BalanceActions::cycle_draft(BalancePlanDraft& draft) const { cycle_balance_view(session_.state(), draft); }
|
||||
// reset it,
|
||||
void BalanceActions::reset_draft(BalancePlanDraft& draft) const { reset_balance_plan(session_.state(), draft); }
|
||||
// and edit one row.
|
||||
BalanceEditStatus BalanceActions::edit_draft(BalancePlanDraft& draft, int row, int32_t value) const {
|
||||
return edit_balance_plan(session_.state(), draft, row, value);
|
||||
}
|
||||
|
||||
// Closes the draft inside a transaction and always increases the revision. Returns the
|
||||
// warning flag reported by the close.
|
||||
bool BalanceActions::close_draft(const BalancePlanDraft& draft, uint64_t& revision) {
|
||||
bool warning = false;
|
||||
apply(revision, [&] {
|
||||
@@ -125,11 +152,13 @@ bool BalanceActions::close_draft(const BalancePlanDraft& draft, uint64_t& revisi
|
||||
return warning;
|
||||
}
|
||||
|
||||
// Runs `action` as a transaction restoring the other-games checkpoint on failure.
|
||||
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);
|
||||
}
|
||||
|
||||
// Opens the other-games screen over `underlay`.
|
||||
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;
|
||||
@@ -142,6 +171,8 @@ std::optional<ui::OtherGamesState> OtherGamesActions::open(const ui::DeskRequest
|
||||
return result;
|
||||
}
|
||||
|
||||
// Sends an other-games request to the session; `team_info` presents club information
|
||||
// when the screen asks for it.
|
||||
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;
|
||||
@@ -154,11 +185,13 @@ std::optional<CareerSession::OtherGamesDispatch> OtherGamesActions::dispatch(con
|
||||
return result;
|
||||
}
|
||||
|
||||
// Runs `action` as a transaction restoring the top scorers checkpoint on failure.
|
||||
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);
|
||||
}
|
||||
|
||||
// Opens the top scorers screen over `underlay`; the revision is increased on opening.
|
||||
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;
|
||||
@@ -172,6 +205,7 @@ std::optional<ui::TopScorersState> TopScorersActions::open(const ui::DeskRequest
|
||||
return result;
|
||||
}
|
||||
|
||||
// Sends a top scorers request to the session in one transaction.
|
||||
std::optional<CareerSession::TopScorersDispatch> TopScorersActions::dispatch(const ui::TopScorersRequest& request,
|
||||
uint64_t& revision, std::string& error, const Accept& acknowledge) {
|
||||
std::optional<CareerSession::TopScorersDispatch> result;
|
||||
@@ -184,11 +218,13 @@ std::optional<CareerSession::TopScorersDispatch> TopScorersActions::dispatch(con
|
||||
return result;
|
||||
}
|
||||
|
||||
// Runs `action` as a transaction restoring the opportunities checkpoint on failure.
|
||||
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);
|
||||
}
|
||||
|
||||
// Opens the opportunities screen over `underlay`; the revision is increased on opening.
|
||||
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) {
|
||||
@@ -203,6 +239,7 @@ std::optional<ui::OpportunitiesState> OpportunitiesActions::open(const ui::DeskR
|
||||
return result;
|
||||
}
|
||||
|
||||
// Sends an opportunities request to the session in one transaction.
|
||||
std::optional<CareerSession::OpportunitiesDispatch> OpportunitiesActions::dispatch(const ui::OpportunitiesRequest& request,
|
||||
uint64_t& revision, std::string& error, const Accept& acknowledge) {
|
||||
std::optional<CareerSession::OpportunitiesDispatch> result;
|
||||
@@ -215,6 +252,8 @@ std::optional<CareerSession::OpportunitiesDispatch> OpportunitiesActions::dispat
|
||||
return result;
|
||||
}
|
||||
|
||||
// Stores a changed statistics display preference (expected flags to target flags) and
|
||||
// increases the revision; throws if the revision counter is exhausted.
|
||||
bool OpportunitiesActions::preference(const ui::AnalyticsRequest& request, uint64_t& revision,
|
||||
std::string& error, const std::function<void()>& acknowledge) {
|
||||
return apply(revision, [&] {
|
||||
@@ -227,15 +266,18 @@ bool OpportunitiesActions::preference(const ui::AnalyticsRequest& request, uint6
|
||||
});
|
||||
}
|
||||
|
||||
// Builds the request that closes the observed opportunities screen.
|
||||
ui::OpportunitiesRequest OpportunitiesActions::close_request(const ui::OpportunitiesState& observed) {
|
||||
return {observed.identity, ui::OpportunitiesAction::close, observed.mode};
|
||||
}
|
||||
|
||||
// Runs `action` as a transaction restoring the manager join checkpoint on failure.
|
||||
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);
|
||||
}
|
||||
|
||||
// Commits a new manager joining the career; `acknowledge` receives the initialization result.
|
||||
bool ManagerJoinActions::commit(uint64_t& revision, std::string& error,
|
||||
const std::function<void(ui::CareerInitializationResult&)>& acknowledge) {
|
||||
return apply(revision, [&] {
|
||||
@@ -246,6 +288,7 @@ bool ManagerJoinActions::commit(uint64_t& revision, std::string& error,
|
||||
});
|
||||
}
|
||||
|
||||
// Sends a mailbox action (via the native transaction wrapper) and acknowledges it.
|
||||
bool MailboxActions::dispatch(const ui::MailboxActionRequest& request, uint64_t& revision,
|
||||
std::string& error, const std::function<void()>& acknowledge) {
|
||||
return detail::apply_native(session_, revision, [&] {
|
||||
@@ -255,6 +298,7 @@ bool MailboxActions::dispatch(const ui::MailboxActionRequest& request, uint64_t&
|
||||
});
|
||||
}
|
||||
|
||||
// Acknowledges the closing of the mailbox.
|
||||
bool MailboxActions::close(const ui::MailboxCloseRequest& request, uint64_t& revision,
|
||||
std::string& error, const std::function<void()>& acknowledge) {
|
||||
return detail::apply_native(session_, revision, [&] {
|
||||
@@ -264,6 +308,7 @@ bool MailboxActions::close(const ui::MailboxCloseRequest& request, uint64_t& rev
|
||||
});
|
||||
}
|
||||
|
||||
// Builds a mailbox action request for the observed message (entry index and raw entry).
|
||||
ui::MailboxActionRequest MailboxActions::request(int manager, uint64_t revision,
|
||||
ui::MailboxActionKind kind, const ui::MailboxMessage& observed) {
|
||||
ui::MailboxActionRequest request;
|
||||
@@ -275,6 +320,7 @@ ui::MailboxActionRequest MailboxActions::request(int manager, uint64_t revision,
|
||||
return request;
|
||||
}
|
||||
|
||||
// Sends a menu layout save/load request and acknowledges it.
|
||||
bool MenuLayoutActions::dispatch(const ui::SaveLoadRequest& request, uint64_t& revision,
|
||||
std::string& error, const std::function<void()>& acknowledge) {
|
||||
return detail::apply_native(session_, revision, [&] {
|
||||
@@ -284,16 +330,22 @@ bool MenuLayoutActions::dispatch(const ui::SaveLoadRequest& request, uint64_t& r
|
||||
});
|
||||
}
|
||||
|
||||
// Sets one environment item through set_impl (normal UI path).
|
||||
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);
|
||||
}
|
||||
|
||||
// Console variant of set(): the staged state is published even if nothing changed.
|
||||
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);
|
||||
}
|
||||
|
||||
// Shared implementation. The request must match the current revision, manager slot
|
||||
// (0..3), active manager and club, otherwise error is "stale_environment_owner". The change
|
||||
// is made on a staged copy; a notice callback may abort it. The revision increases only
|
||||
// when something changed. Returns nothing if the transaction was not accepted.
|
||||
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) {
|
||||
@@ -333,6 +385,7 @@ std::optional<EnvironmentResult> EnvironmentActions::set_impl(const ui::Environm
|
||||
return result;
|
||||
}
|
||||
|
||||
// Builds a set_item request for `item` and `level` bound to the observed view.
|
||||
ui::EnvironmentRequest EnvironmentActions::request(const ui::EnvironmentView& observed, int item, int level) {
|
||||
ui::EnvironmentRequest request;
|
||||
request.kind = ui::EnvironmentRequestKind::set_item;
|
||||
@@ -345,10 +398,12 @@ ui::EnvironmentRequest EnvironmentActions::request(const ui::EnvironmentView& ob
|
||||
return request;
|
||||
}
|
||||
|
||||
// Runs `action` through the native transaction wrapper.
|
||||
bool RescheduleActions::apply(uint64_t& revision, const std::function<bool()>& action) {
|
||||
return detail::apply_native(session_, revision, action);
|
||||
}
|
||||
|
||||
// Moves a league match to `day` or undoes a move; any other combination is invalid.
|
||||
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);
|
||||
@@ -356,6 +411,9 @@ RescheduleStatus RescheduleActions::change(GameState& state, int manager, const
|
||||
return RescheduleStatus::invalid_match;
|
||||
}
|
||||
|
||||
// Handles a UI reschedule action: the owner must be the open menu 7 for the current
|
||||
// revision and active manager, and the match must be among the eligible (or already moved)
|
||||
// matches. The state changes only when the move succeeds.
|
||||
RescheduleStatus RescheduleActions::dispatch(const ui::RescheduleAction& request, uint64_t& revision,
|
||||
const std::function<void()>& acknowledge) {
|
||||
auto status = RescheduleStatus::invalid_match;
|
||||
@@ -379,6 +437,7 @@ RescheduleStatus RescheduleActions::dispatch(const ui::RescheduleAction& request
|
||||
return status;
|
||||
}
|
||||
|
||||
// Moves a match directly (console path); the revision increases on success.
|
||||
RescheduleStatus RescheduleActions::move(int manager, const LeagueMatchRef& match, int day, uint64_t& revision) {
|
||||
auto status = RescheduleStatus::invalid_match;
|
||||
apply(revision, [&] {
|
||||
@@ -390,6 +449,7 @@ RescheduleStatus RescheduleActions::move(int manager, const LeagueMatchRef& matc
|
||||
return status;
|
||||
}
|
||||
|
||||
// Console undo; the revision always increases, whatever the result of the undo.
|
||||
void RescheduleActions::undo_console(int manager, int day, uint64_t& revision) {
|
||||
apply(revision, [&] {
|
||||
// Keep the Console's existing accepted-command revision after its own
|
||||
@@ -400,6 +460,8 @@ void RescheduleActions::undo_console(int manager, int day, uint64_t& revision) {
|
||||
});
|
||||
}
|
||||
|
||||
// Sends a contract request to the session. If an exception follows an accepted request,
|
||||
// the pending contract quote is cleared before rethrowing.
|
||||
bool ContractActions::dispatch(const ui::ContractRequest& request, uint64_t& revision,
|
||||
ui::ContractActionResult& result, std::string& error, const std::function<void()>& acknowledge) {
|
||||
bool accepted = false;
|
||||
@@ -417,6 +479,7 @@ bool ContractActions::dispatch(const ui::ContractRequest& request, uint64_t& rev
|
||||
}
|
||||
}
|
||||
|
||||
// Creates a contract request of `kind` bound to the observed manager, club and revision.
|
||||
ui::ContractRequest ContractActions::bind(const ui::ContractsState& observed,
|
||||
ui::ContractActionKind kind, uint64_t request_id) {
|
||||
ui::ContractRequest request;
|
||||
@@ -428,6 +491,7 @@ ui::ContractRequest ContractActions::bind(const ui::ContractsState& observed,
|
||||
return request;
|
||||
}
|
||||
|
||||
// Request for a player's contract demands (row and player id).
|
||||
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);
|
||||
@@ -436,6 +500,7 @@ ui::ContractRequest ContractActions::demands(const ui::ContractsState& observed,
|
||||
return request;
|
||||
}
|
||||
|
||||
// Request that sets team bonus `index` to `percent`, keeping the other proposed premiums.
|
||||
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);
|
||||
@@ -444,6 +509,7 @@ ui::ContractRequest ContractActions::team_bonus(const ui::ContractsState& observ
|
||||
return request;
|
||||
}
|
||||
|
||||
// Request to insure a player (quote, insurance form in the term column, months).
|
||||
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);
|
||||
@@ -452,6 +518,8 @@ ui::ContractRequest ContractActions::insurance(const ui::ContractsState& observe
|
||||
return request;
|
||||
}
|
||||
|
||||
// Request for a contract offer. With years > 0 it is an offer for that term (salary and
|
||||
// the matching demand); with 0 years only the bonuses are submitted.
|
||||
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) {
|
||||
@@ -466,10 +534,12 @@ ui::ContractRequest ContractActions::offer(const ui::ContractsState& observed, i
|
||||
return request;
|
||||
}
|
||||
|
||||
// Runs `action` through the native transaction wrapper.
|
||||
bool FriendlyActions::apply(uint64_t& revision, const std::function<bool()>& action) {
|
||||
return detail::apply_native(session_, revision, action);
|
||||
}
|
||||
|
||||
// Converts the UI's friendly match request into the engine's booking request.
|
||||
FriendlyBookingRequest FriendlyActions::booking_request(const ui::FriendlyMatchRequest& observed) {
|
||||
FriendlyBookingQuote quote;
|
||||
quote.status = FriendlyQuoteStatus::quoted;
|
||||
@@ -487,6 +557,7 @@ FriendlyBookingRequest FriendlyActions::booking_request(const ui::FriendlyMatchR
|
||||
observed.accept_cost, observed.approving_manager};
|
||||
}
|
||||
|
||||
// Builds the acknowledgement for the UI from the booking outcome and the new revision.
|
||||
ui::FriendlyBookingAck FriendlyActions::acknowledgement(const ui::FriendlyMatchRequest& request,
|
||||
const FriendlyBookingResult& outcome, uint64_t revision) const {
|
||||
ui::FriendlyBookingAck ack;
|
||||
@@ -499,6 +570,9 @@ ui::FriendlyBookingAck FriendlyActions::acknowledgement(const ui::FriendlyMatchR
|
||||
return ack;
|
||||
}
|
||||
|
||||
// Books a friendly match (club or national). The request must be a book request for the
|
||||
// current revision, otherwise the quote is stale. After booking, the planner count must
|
||||
// have grown by 2, else the booking is rolled back and planner_mismatch is set.
|
||||
FriendlyActions::Booking FriendlyActions::book(const ui::FriendlyMatchRequest& request,
|
||||
uint64_t& revision, bool national, const Accept& acknowledge) {
|
||||
Booking result;
|
||||
@@ -526,11 +600,14 @@ FriendlyActions::Booking FriendlyActions::book(const ui::FriendlyMatchRequest& r
|
||||
return result;
|
||||
}
|
||||
|
||||
// Books a club friendly.
|
||||
FriendlyActions::Booking FriendlyActions::book_club(const ui::FriendlyMatchRequest& request,
|
||||
uint64_t& revision, const Accept& acknowledge) { return book(request, revision, false, acknowledge); }
|
||||
// Books a national team friendly.
|
||||
FriendlyActions::Booking FriendlyActions::book_national(const ui::FriendlyMatchRequest& request,
|
||||
uint64_t& revision, const Accept& acknowledge) { return book(request, revision, true, acknowledge); }
|
||||
|
||||
// Console booking from an existing quote; the revision increases when it was booked.
|
||||
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;
|
||||
@@ -544,19 +621,25 @@ FriendlyBookingResult FriendlyActions::book_console(const FriendlyBookingQuote&
|
||||
return result;
|
||||
}
|
||||
|
||||
// Quote functions (thin wrappers over the game functions): club friendly quote,
|
||||
FriendlyBookingQuote FriendlyActions::quote(int manager, int opponent, bool home) const {
|
||||
return quote_friendly_match(session_.state(), manager, opponent, home);
|
||||
}
|
||||
// national friendly quote (uses the random generator),
|
||||
NationalFriendlyQuote FriendlyActions::national_quote(const NationalFriendlyOwner& owner, int opponent, bool home) {
|
||||
return quote_national_friendly_match(session_.state(), owner, opponent, home, session_.rand());
|
||||
}
|
||||
// whether a club friendly can be played on a day,
|
||||
FriendlyDateStatus FriendlyActions::date_status(const FriendlyBookingQuote& quote, uint16_t day) const {
|
||||
return friendly_match_date_status(session_.state(), quote, day);
|
||||
}
|
||||
// the same for a national friendly,
|
||||
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);
|
||||
}
|
||||
// and the owner identity of a national friendly built from the request (the last two
|
||||
// fields are fixed constants).
|
||||
NationalFriendlyOwner FriendlyActions::national_owner(const ui::FriendlyMatchRequest& request) {
|
||||
return {request.quote_id, request.revision, request.manager_slot, 0x165, 6};
|
||||
}
|
||||
|
||||
@@ -1,4 +1,11 @@
|
||||
// SPDX-License-Identifier: GPL-3.0-only
|
||||
// Application-boundary facades for desk-level windows: one small class per owner (desk
|
||||
// settings, balance plan, other games, top scorers, opportunities, manager join, mailbox,
|
||||
// menu layout, environment, reschedule, contracts, friendly matches). Each wraps a
|
||||
// CareerSession reference; its apply() runs an action under a rollback transaction (see
|
||||
// action_transaction.hpp), and open()/dispatch() take the UI request plus the shared
|
||||
// revision counter and an optional "accept" callback that carries the front end's
|
||||
// acknowledgement. Implemented in desktop_actions.cpp; window_actions.hpp holds the club windows.
|
||||
#pragma once
|
||||
|
||||
#include "app/career_session.hpp"
|
||||
|
||||
@@ -1,4 +1,10 @@
|
||||
// SPDX-License-Identifier: GPL-3.0-only
|
||||
// SDL event helpers for the live match-day presentation, which runs while the engine is
|
||||
// synchronously paused in its observer hook. live_matchday_board_side() turns a mouse press
|
||||
// into a side (0 or 1) of the board only at the allowed minutes and screen intervals;
|
||||
// pump_live_matchday_events() drains the SDL queue, reports a quit request and an ESC skip
|
||||
// through its return value / out-parameter, and re-queues only non-interactive system events.
|
||||
// Header-only; owns no state.
|
||||
#pragma once
|
||||
|
||||
#include <SDL.h>
|
||||
|
||||
+416
-1
File diff suppressed because it is too large.
Load diff
@@ -1,4 +1,9 @@
|
||||
// SPDX-License-Identifier: GPL-3.0-only
|
||||
// Mouse pointer for the pitch page. SDL owns the pointer position; the UI only hands over
|
||||
// the original 11x11 pixel bitmap (121 ARGB values). PitchPointer builds an SDL colour
|
||||
// cursor from it, enlarged by an integer scale derived from the window size in points, and
|
||||
// caches it until the pixels or the scale change. set_default() sets the bitmap used on all
|
||||
// other pages. Header-only; the cursor is freed in clear() / the destructor.
|
||||
#pragma once
|
||||
|
||||
#include <SDL.h>
|
||||
|
||||
@@ -1,4 +1,9 @@
|
||||
// SPDX-License-Identifier: GPL-3.0-only
|
||||
// Quit confirmation (a deliberate deviation from the original): a native message box in
|
||||
// German or English whose default button is "Cancel". poll() and peep() wrap
|
||||
// SDL_PollEvent / SDL_PeepEvents and drop SDL_QUIT events the user does not confirm. The
|
||||
// dialog is shown from the UI thread only, and a dialog that fails to open counts as "not
|
||||
// confirmed". The presenter is injectable (defaults to SDL_ShowMessageBox). Header-only.
|
||||
#pragma once
|
||||
|
||||
#include <SDL.h>
|
||||
|
||||
@@ -1,4 +1,9 @@
|
||||
// SPDX-License-Identifier: GPL-3.0-only
|
||||
// Implementation of StartScreen (start_screen.hpp): decodes the embedded JPEG
|
||||
// (start_screen_data.hpp) with stb_image into an RGB24 texture, switches the renderer's
|
||||
// logical size to the image size while presenting and restores the previous logical size in
|
||||
// the destructor. Errors are reported as std::runtime_error; the stb_image implementation
|
||||
// is compiled into this file only (JPEG decoding, no stdio).
|
||||
#include "app/start_screen.hpp"
|
||||
#include "app/start_screen_data.hpp"
|
||||
#include <SDL.h>
|
||||
|
||||
@@ -1,4 +1,8 @@
|
||||
// SPDX-License-Identifier: GPL-3.0-only
|
||||
// Start screen shown before the game data is loaded: one embedded picture drawn with its
|
||||
// own renderer logical size, independent of the indexed game canvas. Owns the SDL
|
||||
// texture; non-copyable. Implemented in start_screen.cpp, the image bytes come from
|
||||
// start_screen_data.hpp.
|
||||
#pragma once
|
||||
struct SDL_Renderer;
|
||||
struct SDL_Texture;
|
||||
|
||||
@@ -1,4 +1,6 @@
|
||||
// SPDX-License-Identifier: GPL-3.0-only
|
||||
// Declares the embedded start screen artwork (JPEG bytes and their size); the definitions
|
||||
// live in a separate data translation unit. Consumed only by start_screen.cpp.
|
||||
#pragma once
|
||||
#include <cstddef>
|
||||
namespace bmh::app {
|
||||
|
||||
@@ -1,4 +1,7 @@
|
||||
// SPDX-License-Identifier: GPL-3.0-only
|
||||
// RAII guard for SDL video: SDL_Init(SDL_INIT_VIDEO) in the constructor (throws
|
||||
// std::runtime_error on failure) and SDL_Quit in the destructor. It must exist before any
|
||||
// native file picker is opened (see the comment on the class). Non-copyable, header-only.
|
||||
#pragma once
|
||||
#include <SDL.h>
|
||||
#include <stdexcept>
|
||||
|
||||
@@ -1,4 +1,9 @@
|
||||
// SPDX-License-Identifier: GPL-3.0-only
|
||||
// Implementation of the club and league window facades declared in window_actions.hpp. Each
|
||||
// method validates the UI request against the session state, runs it on the CareerSession
|
||||
// inside an apply() transaction (state, RNG and revision are restored on rejection or an
|
||||
// exception) and hands the result to the front end's acknowledgement callback. Errors come
|
||||
// back through the std::string& error parameter; see controller.cpp for the overall model.
|
||||
#include "formats/executable_layout.hpp"
|
||||
#include "app/window_actions.hpp"
|
||||
#include "app/action_transaction.hpp"
|
||||
@@ -11,6 +16,9 @@
|
||||
namespace bmh::app {
|
||||
using detail::apply_window;
|
||||
|
||||
// Runs `action` as a transaction on the league family state. Returns true if the action
|
||||
// succeeded; if it returns false or throws, the checkpoint and the revision are restored
|
||||
// (an exception is rethrown).
|
||||
bool LeagueFamilyActions::apply(uint64_t& revision, const std::function<bool()>& action) {
|
||||
auto before = session_.league_family_checkpoint();
|
||||
const auto old_revision = revision;
|
||||
@@ -26,6 +34,8 @@ bool LeagueFamilyActions::apply(uint64_t& revision, const std::function<bool()>&
|
||||
return false;
|
||||
}
|
||||
|
||||
// Opens the league pairings screen from the desk (menu kind 1, using the desk item of
|
||||
// kind 1). Returns its state, or nothing with `error` set if the session refused.
|
||||
std::optional<ui::LeaguePairingsState> LeagueFamilyActions::open_pairings(
|
||||
const ui::DeskState& observed, uint64_t& revision, std::string& error) {
|
||||
ui::DeskRequest request;
|
||||
@@ -43,6 +53,7 @@ std::optional<ui::LeaguePairingsState> LeagueFamilyActions::open_pairings(
|
||||
return result;
|
||||
}
|
||||
|
||||
// Sends one pairings screen event (kind and value) to the session inside a transaction.
|
||||
std::optional<CareerSession::LeaguePairingsDispatch> LeagueFamilyActions::pairings(
|
||||
const ui::LeaguePairingsIdentity& observed, LeaguePairingsAction kind, int value,
|
||||
uint64_t& revision, std::string& error) {
|
||||
@@ -58,16 +69,19 @@ std::optional<CareerSession::LeaguePairingsDispatch> LeagueFamilyActions::pairin
|
||||
return result;
|
||||
}
|
||||
|
||||
// Builds the desk request that opens menu 1 (pairings) for the manager of `identity`.
|
||||
ui::DeskRequest LeagueFamilyActions::pairings_entry(const ui::StrengthsIdentity& identity,
|
||||
uint64_t revision) {
|
||||
return {ui::DeskRequestKind::open_menu, identity.manager, 0, 1, -1, revision};
|
||||
}
|
||||
|
||||
// Builds the pairings request that selects `league`.
|
||||
ui::LeaguePairingsRequest LeagueFamilyActions::pairings_selection(
|
||||
const ui::LeaguePairingsIdentity& identity, int league) {
|
||||
return {identity, {LeaguePairingsAction::select_league, league, -1}};
|
||||
}
|
||||
|
||||
// Turns a fresh strengths request into an `open` request bound to `identity`.
|
||||
ui::StrengthsRequest LeagueFamilyActions::strengths_entry(const ui::StrengthsRequest& fresh,
|
||||
const ui::StrengthsIdentity& identity) {
|
||||
auto request = fresh;
|
||||
@@ -76,6 +90,9 @@ ui::StrengthsRequest LeagueFamilyActions::strengths_entry(const ui::StrengthsReq
|
||||
return request;
|
||||
}
|
||||
|
||||
// Runs `action` as a transaction on the transfer state. Before it, the game state, random
|
||||
// generators, offer editor, poach state, club modal runtime and revision are copied; they
|
||||
// are all restored if the action returns false or throws (then rethrown).
|
||||
bool TransferActions::apply(uint64_t& revision, const std::function<bool()>& action) {
|
||||
auto state = session_.g_;
|
||||
const auto game = session_.game_;
|
||||
@@ -85,6 +102,7 @@ bool TransferActions::apply(uint64_t& revision, const std::function<bool()>& act
|
||||
const auto owner_revision = session_.transfer_offer_revision_;
|
||||
auto runtime = session_.club_modal_runtime_;
|
||||
const auto old_revision = revision;
|
||||
// Puts every saved piece back into the session.
|
||||
const auto restore = [&] {
|
||||
session_.g_ = std::move(state);
|
||||
session_.game_ = game;
|
||||
@@ -105,12 +123,17 @@ bool TransferActions::apply(uint64_t& revision, const std::function<bool()>& act
|
||||
return false;
|
||||
}
|
||||
|
||||
// Handles a transfer market request. In the normal interactive policy the session does
|
||||
// the work (with the sale hooks and the review callback). The other policy is an older
|
||||
// path that only allows listing a player and submitting a bid; it bumps the revision
|
||||
// only if the state or random stream really changed. `acknowledge` is called on success.
|
||||
std::optional<TransferActions::MarketDispatch> TransferActions::market(
|
||||
const ui::TransferMarketRequest& request, const HumanBuyerSaleHooks& hooks,
|
||||
uint64_t& revision, std::string& error, HumanBuyerMarketEntryPolicy policy,
|
||||
const MarketAccept& acknowledge,
|
||||
const std::function<int(const GameState&, const TransferOfferListView&)>& review) {
|
||||
std::optional<MarketDispatch> result;
|
||||
// Body of the transaction; returning false rolls everything back.
|
||||
apply(revision, [&] {
|
||||
const auto old_revision = revision;
|
||||
if (policy == HumanBuyerMarketEntryPolicy::normal_interactive) {
|
||||
@@ -151,6 +174,9 @@ std::optional<TransferActions::MarketDispatch> TransferActions::market(
|
||||
return result;
|
||||
}
|
||||
|
||||
// Checks a market request against the current state. Returns a German error text if the
|
||||
// request is stale or invalid, or an empty string if it may proceed. Bonus values may be
|
||||
// at most 255 (interactive policy) or 100 (legacy policy).
|
||||
std::string TransferActions::rejection(const ui::TransferMarketRequest& request,
|
||||
uint64_t revision, HumanBuyerMarketEntryPolicy policy) const {
|
||||
const auto& state = session_.state();
|
||||
@@ -181,6 +207,7 @@ std::string TransferActions::rejection(const ui::TransferMarketRequest& request,
|
||||
return {};
|
||||
}
|
||||
|
||||
// Opens the transfer offer editor for a market request (one transaction).
|
||||
std::optional<CareerSession::TransferOfferEditorDispatch> TransferActions::open_offer(
|
||||
const ui::TransferMarketRequest& request, uint64_t& revision, std::string& error,
|
||||
const OfferAccept& acknowledge) {
|
||||
@@ -194,6 +221,7 @@ std::optional<CareerSession::TransferOfferEditorDispatch> TransferActions::open_
|
||||
return result;
|
||||
}
|
||||
|
||||
// Asks the session for a preview (quote) of a market request without committing it.
|
||||
std::optional<CareerSession::TransferMarketPreviewDispatch> TransferActions::preview(
|
||||
const ui::TransferMarketRequest& request, uint64_t& revision, std::string& error,
|
||||
const PreviewAccept& acknowledge) {
|
||||
@@ -207,6 +235,8 @@ std::optional<CareerSession::TransferMarketPreviewDispatch> TransferActions::pre
|
||||
return result;
|
||||
}
|
||||
|
||||
// Sends an action of the outgoing offer editor to the session; the team and player
|
||||
// information presenters are used when it opens those screens.
|
||||
std::optional<CareerSession::TransferOfferEditorDispatch> TransferActions::offer(
|
||||
const ui::OutgoingTransferRequest& request, const HumanBuyerSaleHooks& hooks,
|
||||
uint64_t& revision, std::string& error, const TransferOfferTeamInfoPresenter& team_info,
|
||||
@@ -221,6 +251,7 @@ std::optional<CareerSession::TransferOfferEditorDispatch> TransferActions::offer
|
||||
return result;
|
||||
}
|
||||
|
||||
// Starts a poaching attempt for the given manager and squad slot.
|
||||
std::optional<CareerSession::PoachDispatch> TransferActions::poach(int manager, int slot,
|
||||
uint64_t& revision, std::string& error) {
|
||||
std::optional<CareerSession::PoachDispatch> result;
|
||||
@@ -231,6 +262,8 @@ std::optional<CareerSession::PoachDispatch> TransferActions::poach(int manager,
|
||||
return result;
|
||||
}
|
||||
|
||||
// Builds the request to list the squad player `item` on the market (as a loan if `loan`),
|
||||
// bound to the observed state's manager, club and revision.
|
||||
ui::TransferMarketRequest TransferActions::listing(const ui::TransferMarketState& observed,
|
||||
const ui::TransferMarketSquadItem& item, bool loan) {
|
||||
ui::TransferMarketRequest request;
|
||||
@@ -246,6 +279,8 @@ ui::TransferMarketRequest TransferActions::listing(const ui::TransferMarketState
|
||||
return request;
|
||||
}
|
||||
|
||||
// Builds the request to open an offer for the market entry `item`; an existing own bid
|
||||
// is used as the starting point.
|
||||
ui::TransferMarketRequest TransferActions::opening(const ui::TransferMarketState& observed,
|
||||
const ui::TransferMarketItem& item, bool loan) {
|
||||
ui::TransferMarketRequest request;
|
||||
@@ -263,6 +298,7 @@ ui::TransferMarketRequest TransferActions::opening(const ui::TransferMarketState
|
||||
return request;
|
||||
}
|
||||
|
||||
// Builds a request from the offer editor's current state plus the changed field and value.
|
||||
ui::OutgoingTransferRequest TransferActions::editor(const ui::OutgoingTransferEditorState& observed,
|
||||
ui::OutgoingTransferRequestKind kind, ui::OutgoingTransferField field, uint32_t value) {
|
||||
ui::OutgoingTransferRequest request;
|
||||
@@ -282,11 +318,13 @@ ui::OutgoingTransferRequest TransferActions::editor(const ui::OutgoingTransferEd
|
||||
return request;
|
||||
}
|
||||
|
||||
// Runs `action` as a transaction restoring the bank checkpoint on failure.
|
||||
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);
|
||||
}
|
||||
|
||||
// Sends a bank request to the session; `acknowledge` is called when it was accepted.
|
||||
bool BankActions::dispatch(const ui::BankRequest& request, uint64_t& revision, std::string& error,
|
||||
const std::function<void()>& acknowledge) {
|
||||
return apply(revision, [&] {
|
||||
@@ -296,6 +334,7 @@ bool BankActions::dispatch(const ui::BankRequest& request, uint64_t& revision, s
|
||||
});
|
||||
}
|
||||
|
||||
// Creates a bank request of `kind` bound to the observed manager, club and revision.
|
||||
ui::BankRequest BankActions::bind(const ui::BankState& observed, ui::BankRequestKind kind) {
|
||||
ui::BankRequest request;
|
||||
request.kind = kind;
|
||||
@@ -305,12 +344,14 @@ ui::BankRequest BankActions::bind(const ui::BankState& observed, ui::BankRequest
|
||||
return request;
|
||||
}
|
||||
|
||||
// Request to move `amount` to the deposit account.
|
||||
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;
|
||||
}
|
||||
|
||||
// Request for an investment action on asset index `asset` with `count` units.
|
||||
ui::BankRequest BankActions::investment(const ui::BankState& observed, ui::BankRequestKind kind,
|
||||
int asset, int count) {
|
||||
auto request = bind(observed, kind);
|
||||
@@ -319,6 +360,8 @@ ui::BankRequest BankActions::investment(const ui::BankState& observed, ui::BankR
|
||||
return request;
|
||||
}
|
||||
|
||||
// Request for a bank credit: carries the saved credit, the player's edits, whether the
|
||||
// fees are accepted and the counterparty.
|
||||
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);
|
||||
@@ -329,11 +372,14 @@ ui::BankRequest BankActions::credit(const ui::BankState& observed, const BankCre
|
||||
return request;
|
||||
}
|
||||
|
||||
// Runs `action` as a transaction restoring the stadium checkpoint on failure.
|
||||
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);
|
||||
}
|
||||
|
||||
// Sends a stadium request to the session with the notice hooks; `acknowledge` is called
|
||||
// when it was accepted.
|
||||
bool StadiumActions::dispatch(const ui::StadiumRequest& request, uint64_t& revision, std::string& error,
|
||||
const ConstructionNoticeHook& construction, const SeasonTicketCompensationNoticeHook& compensation,
|
||||
const std::function<void()>& acknowledge) {
|
||||
@@ -344,6 +390,7 @@ bool StadiumActions::dispatch(const ui::StadiumRequest& request, uint64_t& revis
|
||||
});
|
||||
}
|
||||
|
||||
// Creates a stadium request bound to the observed club, revision, scope and sequence.
|
||||
ui::StadiumRequest StadiumActions::request(const ui::StadiumState& observed, ui::StadiumRequestKind kind,
|
||||
int object, int option, int32_t price, bool accept_tip) {
|
||||
ui::StadiumRequest request;
|
||||
@@ -361,6 +408,8 @@ ui::StadiumRequest StadiumActions::request(const ui::StadiumState& observed, ui:
|
||||
return request;
|
||||
}
|
||||
|
||||
// Sets the ticket price for the observed desk's club; the stable club identity is filled
|
||||
// in when the club index is valid.
|
||||
bool DeskActions::ticket_price(const ui::DeskState& observed, int price,
|
||||
uint64_t& revision, std::string& error) {
|
||||
TicketPriceRequest request;
|
||||
@@ -373,11 +422,13 @@ bool DeskActions::ticket_price(const ui::DeskState& observed, int price,
|
||||
return session_.dispatch_ticket_price(request, revision, error);
|
||||
}
|
||||
|
||||
// Runs `action` as a transaction restoring the lineup checkpoint on failure.
|
||||
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);
|
||||
}
|
||||
|
||||
// Sends a lineup request to the session; `acknowledge` is called when accepted.
|
||||
bool LineupActions::lineup(const ui::LineupRequest& request, uint64_t& revision, std::string& error,
|
||||
const std::function<void()>& acknowledge) {
|
||||
return apply(revision, [&] {
|
||||
@@ -387,6 +438,7 @@ bool LineupActions::lineup(const ui::LineupRequest& request, uint64_t& revision,
|
||||
});
|
||||
}
|
||||
|
||||
// Sends a pitch request to the session; `acknowledge` is called when accepted.
|
||||
bool LineupActions::pitch(const ui::PitchRequest& request, uint64_t& revision, std::string& error,
|
||||
const std::function<void()>& acknowledge) {
|
||||
return apply(revision, [&] {
|
||||
@@ -396,10 +448,13 @@ bool LineupActions::pitch(const ui::PitchRequest& request, uint64_t& revision, s
|
||||
});
|
||||
}
|
||||
|
||||
// Sends a pitch swap request to the session as one transaction.
|
||||
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); });
|
||||
}
|
||||
|
||||
// Changes one order value (`aspect`) of a player. Only valid for the observed revision;
|
||||
// on success the revision is increased.
|
||||
bool LineupActions::order(const ui::LineupState& observed, const ui::LineupPlayer& player,
|
||||
int aspect, int value, uint64_t& revision) {
|
||||
return apply(revision, [&] {
|
||||
@@ -410,6 +465,9 @@ bool LineupActions::order(const ui::LineupState& observed, const ui::LineupPlaye
|
||||
});
|
||||
}
|
||||
|
||||
// Tries the requested pitch move on a copy of the state and tells whether the player ends
|
||||
// up paired with `second_row` (requested), with another player (other_pair) or whether the
|
||||
// move is invalid.
|
||||
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,
|
||||
@@ -421,6 +479,7 @@ LineupActions::PairTarget LineupActions::pair_target(const ui::PitchRequest& req
|
||||
? PairTarget::requested : PairTarget::other_pair;
|
||||
}
|
||||
|
||||
// Creates a lineup request that prepares the lineup of the observed state.
|
||||
ui::LineupRequest LineupActions::prepare(const ui::LineupState& observed) {
|
||||
ui::LineupRequest request;
|
||||
request.kind = ui::LineupRequestKind::prepare_lineup;
|
||||
@@ -430,6 +489,7 @@ ui::LineupRequest LineupActions::prepare(const ui::LineupState& observed) {
|
||||
return request;
|
||||
}
|
||||
|
||||
// Creates a request to swap two players of the lineup.
|
||||
ui::LineupRequest LineupActions::swap(const ui::LineupState& observed,
|
||||
const ui::LineupPlayer& first, const ui::LineupPlayer& second) {
|
||||
auto request = prepare(observed);
|
||||
@@ -440,6 +500,8 @@ ui::LineupRequest LineupActions::swap(const ui::LineupState& observed,
|
||||
return request;
|
||||
}
|
||||
|
||||
// Creates a pitch request of `kind` bound to the observed lineup. The observed live mode
|
||||
// must be known, otherwise a FormatError is thrown.
|
||||
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");
|
||||
@@ -452,6 +514,7 @@ ui::PitchRequest LineupActions::bind_pitch(const ui::PreparationState& observed,
|
||||
return request;
|
||||
}
|
||||
|
||||
// Creates a request to swap two players on the pitch (including their current positions).
|
||||
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);
|
||||
@@ -461,6 +524,7 @@ ui::PitchRequest LineupActions::swap_pitch(const ui::PreparationState& observed,
|
||||
return request;
|
||||
}
|
||||
|
||||
// Creates a request to switch the pitch page (toggles the 0x000c bits of the display word).
|
||||
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);
|
||||
@@ -472,6 +536,8 @@ ui::PitchRequest LineupActions::page(const ui::PreparationState& observed) {
|
||||
return request;
|
||||
}
|
||||
|
||||
// Creates a request to load or save a formation in `slot`; saving copies the position
|
||||
// bytes of the 11 players on the pitch.
|
||||
ui::PitchRequest LineupActions::formation(const ui::PreparationState& observed,
|
||||
ui::PitchRequestKind kind, int slot) {
|
||||
auto request = bind_pitch(observed, kind);
|
||||
@@ -487,6 +553,7 @@ ui::PitchRequest LineupActions::formation(const ui::PreparationState& observed,
|
||||
return request;
|
||||
}
|
||||
|
||||
// Creates a request to move a player to the given depth and lane.
|
||||
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);
|
||||
@@ -497,6 +564,8 @@ ui::PitchRequest LineupActions::move(const ui::PreparationState& observed, const
|
||||
return request;
|
||||
}
|
||||
|
||||
// Creates a request that advances one of the three automatic weights (index 0..2) by one
|
||||
// step; each weight is a 2-bit value that wraps around after 3.
|
||||
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);
|
||||
|
||||
@@ -1,4 +1,9 @@
|
||||
// SPDX-License-Identifier: GPL-3.0-only
|
||||
// Application-boundary facades for the club and league windows: league table/pairings/
|
||||
// strengths, transfer market and offers, bank, stadium, desk actions and lineup. Same pattern
|
||||
// as desktop_actions.hpp: a class per owner that wraps a CareerSession, offers apply() as a
|
||||
// rollback transaction and takes the shared revision counter plus an acknowledgement
|
||||
// callback from the front end. Implemented in window_actions.cpp, called from controller.cpp.
|
||||
#pragma once
|
||||
|
||||
#include "app/career_session.hpp"
|
||||
|
||||
@@ -1,4 +1,9 @@
|
||||
// SPDX-License-Identifier: GPL-3.0-only
|
||||
// Implementation of container.hpp: parse_container() checks the FORM/ALPTRAUM header and
|
||||
// walks the adjacent little-endian chunks (no alignment byte) with bounds checks, filling
|
||||
// a Container of offsets; decode_sample() and decode_original_cue() convert the bounded
|
||||
// sample data to PCM. Pure functions on byte spans, no state; failures are reported through
|
||||
// the std::string& error argument and a false result.
|
||||
#include "container.hpp"
|
||||
|
||||
#include <algorithm>
|
||||
|
||||
@@ -1,4 +1,10 @@
|
||||
// SPDX-License-Identifier: GPL-3.0-only
|
||||
// Reader for the original sound container (a FORM/ALPTRAUM chunk wrapper) and for the PCM
|
||||
// samples inside it. A Container only lists chunk ids and payload offsets; the payload bytes
|
||||
// stay in the caller's buffer, which must outlive any use of the offsets. decode_sample()
|
||||
// turns unsigned 8-bit samples into signed 16-bit mono PCM; decode_original_cue() resolves
|
||||
// only the PCM-backed effects (original ids 17..22). Pairs with container.cpp; the PCM types
|
||||
// are shared by mixer, playback, semantic cues and the music fallback.
|
||||
#pragma once
|
||||
|
||||
#include <cstddef>
|
||||
|
||||
@@ -1,4 +1,8 @@
|
||||
// SPDX-License-Identifier: GPL-3.0-only
|
||||
// Implementation of Mixer (mixer.hpp). Incoming PCM is resampled to the output rate with
|
||||
// range and overflow checks and a total/per-voice byte ceiling (2 MiB overall, an eighth of
|
||||
// that per voice); mix_block() sums music and active voices into the output block, applies
|
||||
// the volume and advances the cursors (the music loops).
|
||||
#include "mixer.hpp"
|
||||
|
||||
#include <algorithm>
|
||||
|
||||
@@ -1,4 +1,9 @@
|
||||
// SPDX-License-Identifier: GPL-3.0-only
|
||||
// Small PCM mixer used by the software (non-original) playback path: one looping music
|
||||
// buffer plus up to 8 one-shot voices, all converted to the output rate when added.
|
||||
// start_music_loop()/add_voice() may allocate; mix_block() only reads the prepared buffers
|
||||
// and writes into caller-owned storage, so it is safe to call from the audio path. Owned
|
||||
// by Playback (playback.hpp); the byte limits are in mixer.cpp.
|
||||
#pragma once
|
||||
|
||||
#include "container.hpp"
|
||||
|
||||
@@ -1,4 +1,8 @@
|
||||
// SPDX-License-Identifier: GPL-3.0-only
|
||||
// Implementation of the synthetic matchday loop (music_fallback.hpp): a fixed 22050 Hz,
|
||||
// 108 bpm, 8-bar sequence of bass, chord and lead notes defined by constant MIDI tables,
|
||||
// rendered to mono PCM16. No game state or randomness is involved, so the output is the
|
||||
// same on every run.
|
||||
#include "music_fallback.hpp"
|
||||
|
||||
#include <algorithm>
|
||||
|
||||
@@ -1,4 +1,8 @@
|
||||
// SPDX-License-Identifier: GPL-3.0-only
|
||||
// Synthetic fallback matchday music: a deterministic 8-bar loop generated in code. It is
|
||||
// presentation filler, not decoded original music and not tied to any original sound id.
|
||||
// The result is a PcmSample that Playback::start_music_loop() can play; implemented in
|
||||
// music_fallback.cpp.
|
||||
#pragma once
|
||||
|
||||
#include "container.hpp"
|
||||
|
||||
@@ -1,4 +1,10 @@
|
||||
// SPDX-License-Identifier: GPL-3.0-only
|
||||
// Implementation of OriginalSynth (original.hpp). The hidden State holds the parsed
|
||||
// songs, tracks, channels, sample banks and the Nuked-OPL3 chip core (src/audio/third_party);
|
||||
// tick() runs one sequencer step of the original timer interrupt, render() produces output
|
||||
// samples from the chip and the PCM channel. load() validates every input and fails
|
||||
// cleanly on malformed data; the register and sample observers exist only for offline
|
||||
// validation (original_validation.cpp, sound_driver.cpp).
|
||||
#include "original.hpp"
|
||||
#include "container.hpp"
|
||||
#include "third_party/nuked-opl3/opl3.h"
|
||||
|
||||
@@ -1,4 +1,11 @@
|
||||
// SPDX-License-Identifier: GPL-3.0-only
|
||||
// Emulation of the original game's sound system (MIDI-style sequencer, OPL FM instruments
|
||||
// and one Sound Blaster PCM channel) as OriginalSynth. The application reads the sound
|
||||
// containers (S/2000..2003) and the frequency/operator tables from the user's executable
|
||||
// and hands them in as OriginalAssets; this module knows nothing about game state, file
|
||||
// layout, the simulation clock or random generators. command() takes the original sound ids
|
||||
// (0 title, 1 desk, 2 intro, 3 crowd, 8 stop, 10..22 effects); render() fills PCM blocks
|
||||
// without allocating. Implemented in original.cpp, driven by Playback and the audio tools.
|
||||
#pragma once
|
||||
|
||||
#include <array>
|
||||
|
||||
@@ -1,4 +1,10 @@
|
||||
// SPDX-License-Identifier: GPL-3.0-only
|
||||
// Validation executable for the original-sound emulation (original.hpp, playback.hpp). It
|
||||
// needs the user's game data directory as its single argument, loads the executable tables
|
||||
// and sound containers from it, and runs oracle checks on song/effect output, transitions,
|
||||
// malformed input, option and mute handling, effect priorities and the audio callback
|
||||
// lifecycle. With an empty argument it prints SKIP and exits with 77 (test skipped).
|
||||
// Contains no game assets itself.
|
||||
#include "formats/executable_layout.hpp"
|
||||
#include "original.hpp"
|
||||
#include "playback.hpp"
|
||||
|
||||
@@ -1,4 +1,9 @@
|
||||
// SPDX-License-Identifier: GPL-3.0-only
|
||||
// Implementation of Playback (playback.hpp): opens the SDL audio device, feeds either the
|
||||
// OriginalSynth from the SDL callback (original mode) or bounded blocks from the Mixer via
|
||||
// pump() (software mode), and maps original ids and semantic cues to sound played on the
|
||||
// device. Duplicate or out-of-order event ids are rejected before anything is played;
|
||||
// shutdown() releases the device.
|
||||
#include "playback.hpp"
|
||||
|
||||
#include <algorithm>
|
||||
|
||||
@@ -1,4 +1,10 @@
|
||||
// SPDX-License-Identifier: GPL-3.0-only
|
||||
// Audio output device wrapper (SDL) and the single audio object the application uses.
|
||||
// Playback owns the SDL device, a software Mixer (PCM effects, optional music loop) and the
|
||||
// OriginalSynth (the full original driver, streamed from SDL's audio callback so modal
|
||||
// windows cannot starve it). Cue requests carry a session id and an increasing event id
|
||||
// chosen by the controller; submit() consumes each event once and returns a CueStatus.
|
||||
// Mute and volume apply to both paths. Pairs with playback.cpp and app/audio.hpp.
|
||||
#pragma once
|
||||
|
||||
#include "container.hpp"
|
||||
|
||||
@@ -1,4 +1,7 @@
|
||||
// SPDX-License-Identifier: GPL-3.0-only
|
||||
// Implementation of synthesize_semantic_cue() (semantic_cues.hpp): builds each cue in code
|
||||
// (the whistles from frequency sweeps with attack and release shaping) at 22050 Hz and
|
||||
// clamps the result to 16-bit PCM. Pure and deterministic.
|
||||
#include "semantic_cues.hpp"
|
||||
|
||||
#include <algorithm>
|
||||
|
||||
@@ -1,4 +1,8 @@
|
||||
// SPDX-License-Identifier: GPL-3.0-only
|
||||
// Semantic sound cues (kickoff whistle, goal, full-time whistle) synthesized in code for
|
||||
// use when no verified original effect is available. They are labels of intent, never
|
||||
// original sound ids. The generator is deterministic mono PCM16 at 22050 Hz and has no
|
||||
// dependency on game state, randomness or rendering; implemented in semantic_cues.cpp.
|
||||
#pragma once
|
||||
|
||||
#include "container.hpp"
|
||||
|
||||
@@ -1,4 +1,10 @@
|
||||
// SPDX-License-Identifier: GPL-3.0-only
|
||||
// Command line tool openbmh_sound for the audio module. It works either on one sound
|
||||
// container file (play or export a sample, a test tone, or an original effect id as WAV) or,
|
||||
// with --original DATA_DIR, on the user's game data through OriginalSynth (export a song or
|
||||
// effect to WAV, or play ids through the real device). It also plays or exports the
|
||||
// synthetic semantic cues and the fallback music loop. Own state only: parsed arguments.
|
||||
// Bounds on seconds, loops and ids are checked before anything runs.
|
||||
#include "formats/executable_layout.hpp"
|
||||
#include "container.hpp"
|
||||
#include "music_fallback.hpp"
|
||||
|
||||
@@ -1,4 +1,9 @@
|
||||
// SPDX-License-Identifier: GPL-3.0-only
|
||||
// Self-contained checks for the audio module that need no game data: container parsing
|
||||
// against authored fixtures, sample and cue decoding, the mixer, the playback request
|
||||
// rules and the synthetic music fallback. The fixtures are built in code and are not
|
||||
// copied from any game asset. Returns non-zero on the first failed CHECK; companion of
|
||||
// original_validation.cpp, which covers the original-driver emulation.
|
||||
#include "container.hpp"
|
||||
#include "music_fallback.hpp"
|
||||
#include "playback.hpp"
|
||||
|
||||
@@ -1,4 +1,9 @@
|
||||
// SPDX-License-Identifier: GPL-3.0-only
|
||||
// Implementation of the console line parser (parser.hpp): trimming, top-level splitting of
|
||||
// the argument list (commas inside quotes or brackets do not split), parsing of one
|
||||
// argument (positional or name=value), canonical name comparison that ignores case, '.' and
|
||||
// '_', line classification, and the integer/bool converters for arguments. Pure functions;
|
||||
// no console state. The console (console.cpp, windows_*.cpp) checks the argument types.
|
||||
#include "cli/console/parser.hpp"
|
||||
|
||||
#include <cctype>
|
||||
|
||||
@@ -1,4 +1,8 @@
|
||||
// SPDX-License-Identifier: GPL-3.0-only
|
||||
// Implementation of parse_json()/dump_json() (json.hpp): a small recursive-descent Parser
|
||||
// over a string_view that reports the byte position in JsonError messages, UTF-8 handling
|
||||
// for string escapes, and a serializer for the Json variant. No state beyond the parser's
|
||||
// position in the input.
|
||||
#include "cli/json.hpp"
|
||||
|
||||
#include <charconv>
|
||||
|
||||
@@ -1,4 +1,9 @@
|
||||
// SPDX-License-Identifier: GPL-3.0-only
|
||||
// Minimal JSON value type for the CLI protocol (no external library). A Json holds null,
|
||||
// bool, a 64-bit integer, string, array or object (std::map) in one std::variant; the
|
||||
// accessors return null pointers when the type does not match, so callers must check.
|
||||
// Numbers are integers only. parse_json() throws JsonError on bad input; dump_json() writes
|
||||
// compact text. Used by protocol.*, seat_hub.cpp and main.cpp; implemented in json.cpp.
|
||||
#pragma once
|
||||
|
||||
#include <cstdint>
|
||||
|
||||
@@ -1,4 +1,11 @@
|
||||
// SPDX-License-Identifier: GPL-3.0-only
|
||||
// Entry point of openbmh_cli, the headless front end without a window. Besides parsing the
|
||||
// command line (Arguments) it offers several modes on top of the same engine: the JSON
|
||||
// protocol on stdin/stdout (protocol.hpp) with --log/--replay, the console language
|
||||
// (docs/CLI_CONCEPT) as plain session, replay, mailbox server (--serve), multi-seat server
|
||||
// (--seats, SeatHub), TCP listener on 127.0.0.1 (--listen), and --send to hand one block to
|
||||
// a running mailbox session. --data may be a game directory, the game's EXE or an archive
|
||||
// (src/launch resolves it). All game logic stays in the engine; this file only moves lines.
|
||||
#include "cli/protocol.hpp"
|
||||
#include "cli/console/console.hpp"
|
||||
#include "cli/seat_hub.hpp"
|
||||
|
||||
@@ -1,4 +1,11 @@
|
||||
// SPDX-License-Identifier: GPL-3.0-only
|
||||
// Implementation of the JSON protocol (protocol.hpp). Protocol::handle() validates the
|
||||
// request keys per command (check_keys / check_command_keys), then calls the CareerSession
|
||||
// and the same projection functions the SDL front end uses (desk, table, mail, tactics,
|
||||
// training, camp, bank, stadium, kickoff, save/load, ...), and wraps the result with the
|
||||
// current revision. Errors are returned as {"ok": false, "error": ...}, never thrown to the
|
||||
// caller. The "replay" flag lets a logged session be played again (saves may overwrite).
|
||||
// text_request()/text_response() implement the one-line text form of the protocol.
|
||||
#include "formats/executable_layout.hpp"
|
||||
#include "cli/protocol.hpp"
|
||||
|
||||
|
||||
@@ -1,4 +1,10 @@
|
||||
// SPDX-License-Identifier: GPL-3.0-only
|
||||
// The JSON line protocol of openbmh_cli (the non-console mode): one request object with a
|
||||
// "cmd" field in, one response object ("ok", "revision", result or error) out. Protocol owns
|
||||
// one app::CareerSession (created by "new" or "load") and the revision counter that every
|
||||
// state-changing command must echo back, so stale requests are refused like in the UI
|
||||
// flow. text_request()/text_response() translate a simple one-line text form to and from the
|
||||
// same JSON. Implemented in protocol.cpp; Protocol::help() lists the commands.
|
||||
#pragma once
|
||||
|
||||
#include "cli/json.hpp"
|
||||
|
||||
@@ -1,4 +1,10 @@
|
||||
// SPDX-License-Identifier: GPL-3.0-only
|
||||
// Implementation of SeatHub (seat_hub.hpp): routes the blocks of several clients into one
|
||||
// console::Console. It runs a block as the seat's manager ("@k"), classifies each output
|
||||
// line with Console::LineInfo, queues lines that concern other seats as their "meanwhile"
|
||||
// feed, holds WaitTurn blocks until they can be answered, and holds the Run/Step of a live
|
||||
// match until every seat has sent one. State per seat is a small Seat record; the game
|
||||
// itself lives in the console.
|
||||
#include "cli/seat_hub.hpp"
|
||||
|
||||
#include <algorithm>
|
||||
|
||||
@@ -1,4 +1,10 @@
|
||||
// SPDX-License-Identifier: GPL-3.0-only
|
||||
// Decides which club badge tokens the original draws as a fallback instead of an individual
|
||||
// crest. The cut-off for foreign clubs differs between game editions, so it is read from one
|
||||
// instruction in the loaded executable (layout::ForeignBadgeGateInstruction) and stored in the
|
||||
// process-wide original_foreign_badge_end by install_original_badge_policy(). An executable
|
||||
// that does not match the verified pattern falls back to 138. Header-only; the club
|
||||
// selectors themselves stay in the database and savegame data.
|
||||
#pragma once
|
||||
|
||||
#include "formats/executable_layout.hpp"
|
||||
|
||||
@@ -1,4 +1,8 @@
|
||||
// SPDX-License-Identifier: GPL-3.0-only
|
||||
// Implementation of the basic file helpers declared in binary.hpp: read_file() loads a whole
|
||||
// file into a Bytes vector (FormatError if it cannot be opened) and iso646de_to_utf8()
|
||||
// converts the game's ISO 646-DE strings ([ \ ] { | } ~ stand for the umlauts and the sharp s)
|
||||
// to UTF-8. No state.
|
||||
#include "formats/binary.hpp"
|
||||
|
||||
#include <fstream>
|
||||
|
||||
@@ -1,4 +1,9 @@
|
||||
// SPDX-License-Identifier: GPL-3.0-only
|
||||
// Implementation of the .FBM savegame container (fbm.hpp): fbm_encrypt()/fbm_decrypt() are the
|
||||
// stream cipher whose key changes by 0x29 per byte, and load_savegame() finds the "KRON_FBM"
|
||||
// magic, splits the plain header from the encrypted stream, decrypts it and verifies the
|
||||
// one-byte checksum, which is reported in Savegame::checksum_ok (not thrown). The decrypted
|
||||
// stream is interpreted by savestate.cpp. Pure functions, no state.
|
||||
#include "formats/fbm.hpp"
|
||||
|
||||
#include <algorithm>
|
||||
|
||||
@@ -1,4 +1,9 @@
|
||||
// SPDX-License-Identifier: GPL-3.0-only
|
||||
// Implementation of the .FNT bitmap font loader and renderer (font.hpp): load_font() reads
|
||||
// the header, the 1-bit glyph bitmap and the per-character location (and spacing) tables and
|
||||
// checks that the file size matches exactly; Font::glyph(), text_width() and draw() look up
|
||||
// glyphs (out-of-range characters use the last glyph) and draw them into an indexed Image.
|
||||
// No state beyond the Font object.
|
||||
#include "formats/font.hpp"
|
||||
|
||||
namespace bmh {
|
||||
|
||||
@@ -1,4 +1,9 @@
|
||||
// SPDX-License-Identifier: GPL-3.0-only
|
||||
// Implementation of the executable image loader (le.hpp): load_le() reads the original
|
||||
// DOS/4GW LE executable, places its objects at their link addresses and applies the internal
|
||||
// fixups (FormatError for other files or external fixups). It also accepts the OpenBMH image
|
||||
// format written by save_image(), so a translated image can replace the executable.
|
||||
// LeImage::cstring() reads NUL-terminated strings from the image. No global state.
|
||||
#include "formats/le.hpp"
|
||||
|
||||
#include <algorithm>
|
||||
|
||||
@@ -1,4 +1,8 @@
|
||||
// SPDX-License-Identifier: GPL-3.0-only
|
||||
// Reads from the loaded executable how many league levels a player can see; the original
|
||||
// separates internal domestic league slots from these visible levels. Throws
|
||||
// std::invalid_argument when the stored constants fail the sanity check. Header-only,
|
||||
// stateless; the address comes from executable_layout.hpp and the image from le.hpp.
|
||||
#pragma once
|
||||
#include "formats/executable_layout.hpp"
|
||||
#include "formats/le.hpp"
|
||||
|
||||
@@ -1,4 +1,9 @@
|
||||
// SPDX-License-Identifier: GPL-3.0-only
|
||||
// Implementation of the M3D.MAN master database loader (m3d.hpp). load_database() reads the
|
||||
// file sequentially with a bounds-checked Reader: first the lengths of the four string pools
|
||||
// (clubs, players, referees, stadiums), then the pools, the name offset tables and the raw
|
||||
// record blocks, whose sizes depend on the DbCounts passed in. Several blocks are kept as raw
|
||||
// bytes in the Database (raw_* fields). Throws FormatError on a truncated file.
|
||||
#include "formats/m3d.hpp"
|
||||
|
||||
#include <cstring>
|
||||
|
||||
@@ -1,4 +1,9 @@
|
||||
// SPDX-License-Identifier: GPL-3.0-only
|
||||
// Accepted savegame version markers for the native (original-layout) save format. The FBM
|
||||
// container (fbm.hpp) carries a version string; V2.24 and V3.7 share the same block order,
|
||||
// while expanded careers use their own marker (O1.1) and layout. require_native_savegame()
|
||||
// throws FormatError on a bad checksum or an unsupported marker; callers still validate the
|
||||
// full state layout afterwards (savestate.hpp). Header-only.
|
||||
#pragma once
|
||||
#include "formats/fbm.hpp"
|
||||
#include <string_view>
|
||||
|
||||
@@ -1,4 +1,9 @@
|
||||
// SPDX-License-Identifier: GPL-3.0-only
|
||||
// Implementation of the palette loader (palette.hpp). load_palette() reads a 256-entry,
|
||||
// 6 bits per channel RGB file and converts it to 32-bit ARGB via vga_dac_rgb8();
|
||||
// load_optional_embedded_palette() reads the palette that may follow the RLE data of a VGA
|
||||
// image file (std::nullopt if there is none); Palette::nearest() returns the index of the
|
||||
// closest colour by squared RGB distance. FormatError on short or inconsistent files.
|
||||
#include "formats/palette.hpp"
|
||||
|
||||
#include "formats/binary.hpp"
|
||||
|
||||
@@ -1,4 +1,9 @@
|
||||
// SPDX-License-Identifier: GPL-3.0-only
|
||||
// Implementation of the savegame stream layout (savestate.hpp). save_layout() lists the
|
||||
// blocks in the exact order the original wrote them, with sizes that are constants or depend
|
||||
// on DbCounts; the SaveState constructor splits a decrypted stream along that list, reads
|
||||
// the four string-pool trailer blocks and the optional OpenBMH extension, and throws
|
||||
// FormatError if the sizes do not add up. append_save_extension() writes that extension.
|
||||
#include "formats/executable_layout.hpp"
|
||||
#include "formats/savestate.hpp"
|
||||
|
||||
|
||||
@@ -1,4 +1,7 @@
|
||||
// SPDX-License-Identifier: GPL-3.0-only
|
||||
// Implementation of the TEXTD.BLK loader (textd.hpp): skips the 7-byte header, keeps the whole
|
||||
// blob and splits it into NUL-terminated strings, recording each string's offset. Exactly
|
||||
// TEXT_COUNT strings must be found, otherwise FormatError. No state.
|
||||
#include "formats/textd.hpp"
|
||||
|
||||
#include "formats/binary.hpp"
|
||||
|
||||
@@ -1,4 +1,8 @@
|
||||
// SPDX-License-Identifier: GPL-3.0-only
|
||||
// Implementation of the .VGA image support (vga.hpp): Image::blit() copies one indexed image
|
||||
// into another with clipping, decode_vga() unpacks the run-length data (a byte of 0x80 or
|
||||
// more is a run, below that a literal block) and checks the length fields and the single
|
||||
// trailing byte, and load_vga() reads a file and decodes it. FormatError on malformed data.
|
||||
#include "formats/vga.hpp"
|
||||
|
||||
namespace bmh {
|
||||
|
||||
@@ -1,4 +1,10 @@
|
||||
// SPDX-License-Identifier: GPL-3.0-only
|
||||
// Business plan (balance plan) screen of a human manager: builds a draft of the plan rows
|
||||
// (income, running costs, shares and loans, catering, ticket price), checks per-row maxima when
|
||||
// the player edits a row and writes the accepted plan back on close.
|
||||
// Reads and writes the manager records in GameState (manager_records); reads schedule, table and
|
||||
// prediction data for the forecast. Draws no random numbers.
|
||||
// Interface in balance_plan.hpp; monthly bookings of similar figures live in month.cpp / week.cpp.
|
||||
#include "formats/executable_layout.hpp"
|
||||
#include "game/environment.hpp"
|
||||
#include "game/balance_plan.hpp"
|
||||
@@ -30,7 +36,7 @@ constexpr uint16_t kFacilityCost[22] = {2000, 3000, 3000, 8000, 4000, 3000, 2500
|
||||
// BalancePlanRuntimeField6: monthly income of the first six facilities (FacilityIncome)
|
||||
constexpr uint16_t kFacilityIncome[6] = {0, 5000, 5000, 4800, 2400, 8000};
|
||||
// BalancePlanRuntimeField7: catering income per visitor of the facilities 0-13 (BookMoney)
|
||||
constexpr uint8_t kPerVisitor[14] = {0, 10, 10, 3, 5, 15, 3, 3, 3, 3, 2, 2, 2, 2};
|
||||
constexpr uint8_t kPerVisitor[14] = {0, 10, 15, 3, 5, 10, 3, 3, 3, 3, 2, 2, 2, 2}; // Diamond 3.7 (entries 2 and 5 were 10 and 15)
|
||||
// Rec32: price units of the six funds (BMH.exe+MonthRuntimeField10)
|
||||
constexpr int32_t kShareUnits[6] = {15, 18, 21, 24, 27, 30};
|
||||
|
||||
|
||||
@@ -1,4 +1,10 @@
|
||||
// SPDX-License-Identifier: GPL-3.0-only
|
||||
// Bank credit dialog: loans from the bank or from another manager, held in the per-manager loan
|
||||
// matrix of the manager records. Implements the amount/fee/monthly-payment arithmetic (with the
|
||||
// original's extended-precision rounding emulated in integers), draft editing with bounds, and
|
||||
// the interest-rate change. Reads the manager records and executable tables via BankCreditContext;
|
||||
// only change_bank_credit_interest writes GameState here. Draws no random numbers.
|
||||
// Types are declared in bank_credit.hpp.
|
||||
#include "formats/executable_layout.hpp"
|
||||
#include "game/bank_credit.hpp"
|
||||
|
||||
@@ -228,7 +234,7 @@ BankCreditBounds bank_credit_bounds(const BankCreditContext& c, const BankCredit
|
||||
int32_t lo = 0, hi = 0;
|
||||
if (field == 0) {
|
||||
lo = 1000;
|
||||
hi = sub(12000000, accrued);
|
||||
hi = sub(8000000, accrued); // Diamond 3.7: credit limit 8 million (12 million before)
|
||||
// case 5: no more than the lender can pay out (balance + credit line)
|
||||
if (c.counterparty && c.lender_liquidity < hi) hi = sub(c.lender_liquidity, accrued);
|
||||
}
|
||||
@@ -250,7 +256,7 @@ BankCreditBounds bank_credit_bounds(const BankCreditContext& c, const BankCredit
|
||||
if (field == 6) { hi = liquidity < accrued ? liquidity : signed_word(v[0]); }
|
||||
// Source checks availability before overriding the principal bounds.
|
||||
if (lo >= hi) return {};
|
||||
if (field == 0 && lo < signed_word(c.saved[0])) { lo = signed_word(c.saved[0]); hi = 12000000; }
|
||||
if (field == 0 && lo < signed_word(c.saved[0])) { lo = signed_word(c.saved[0]); hi = 8000000; }
|
||||
if (lo < 0 || hi < 0 || lo >= hi) return {};
|
||||
return {word(lo), word(hi), word(lo - (lo == 1)), true};
|
||||
} catch (const std::invalid_argument&) { return {}; }
|
||||
|
||||
@@ -1,4 +1,8 @@
|
||||
// SPDX-License-Identifier: GPL-3.0-only
|
||||
// Interface of the bank credit dialog: context (rate table, liquidity, saved loan row), draft,
|
||||
// edit and bounds types plus the projection/edit functions implemented in bank_credit.cpp.
|
||||
// Case "bank" and case "another manager lends" share these types; projection and draft editing
|
||||
// are read-only with respect to GameState. No random numbers are drawn.
|
||||
#pragma once
|
||||
|
||||
#include <array>
|
||||
|
||||
@@ -1,4 +1,8 @@
|
||||
// SPDX-License-Identifier: GPL-3.0-only
|
||||
// Per-manager guard against repeated bank robbery events: one blocked month key per manager,
|
||||
// stored in an OpenBMH-owned extension block of the static memory in GameState (not in the
|
||||
// original save fields). The month key function is implemented in week.cpp.
|
||||
// Header-only accessors; no random numbers are drawn.
|
||||
#pragma once
|
||||
#include "game/state.hpp"
|
||||
#include <limits>
|
||||
|
||||
@@ -1,4 +1,8 @@
|
||||
// SPDX-License-Identifier: GPL-3.0-only
|
||||
// Calendar epoch (start year and weekday of the season calendar), read from the date setup code
|
||||
// of the loaded executable image. Unknown or unverified setups are rejected with FormatError.
|
||||
// Holds one process-wide installed epoch; reads no GameState and draws no random numbers.
|
||||
// Declared in calendar.hpp.
|
||||
#include "game/calendar.hpp"
|
||||
#include "formats/executable_layout.hpp"
|
||||
#include "formats/le.hpp"
|
||||
|
||||
@@ -1,4 +1,8 @@
|
||||
// SPDX-License-Identifier: GPL-3.0-only
|
||||
// Interface for the calendar epoch (start year and weekday) used for date calculations.
|
||||
// calendar_epoch_from_executable validates the loaded executable, install_calendar_rules makes it
|
||||
// active, calendar_epoch returns it (a synthetic default for isolated test states).
|
||||
// Implemented in calendar.cpp; no GameState access and no random numbers.
|
||||
#pragma once
|
||||
namespace bmh {
|
||||
class LeImage;
|
||||
|
||||
+9
-2
@@ -1,4 +1,11 @@
|
||||
// SPDX-License-Identifier: GPL-3.0-only
|
||||
// Start of a new career: league strength ranges read from the executable, generation of players
|
||||
// (startup squads, the extra and market players), initial club moods and markets, the starting
|
||||
// state built from the data files, plus new-manager setup (stadium, sponsors, competition blocks).
|
||||
// Writes most of GameState (players, squad_slots, memory, manager records).
|
||||
// Draws from both generators: WatcomRandom for attributes and levels, GameRandom for the
|
||||
// reseeding done by stir_random and the mood reset.
|
||||
// Interface in career.hpp; the season-wide steps follow in season.cpp.
|
||||
#include "formats/executable_layout.hpp"
|
||||
#include "game/career.hpp"
|
||||
#include "game/lineup.hpp"
|
||||
@@ -403,7 +410,7 @@ void starting_sponsors(GameState& g, int m) {
|
||||
const size_t rec = size_t(m) * kRecord;
|
||||
int league = g.manager_records.at(rec + 0x210);
|
||||
if (league > 2) league--;
|
||||
const int v = (((league * -20 + 80) * 60000 + 1000000) / 12 * (mem.u8(::bmh::layout::Difficulty) * -5 + 0xaa)) / 3000000 * 10000;
|
||||
const int v = (((league * -20 + 80) * 60000 + 1000000) / 12 * (mem.u8(::bmh::layout::Difficulty) * -5 + 0x7d)) / 3000000 * 10000;
|
||||
for (size_t o : {size_t(0xae8), size_t(0xadc), size_t(0xa34)}) put32(g.manager_records, rec + o, uint32_t(v));
|
||||
for (size_t o : {size_t(0xaed), size_t(0xae1), size_t(0xa39)}) g.manager_records.at(rec + o) = 1;
|
||||
}
|
||||
@@ -560,7 +567,7 @@ bool career_add_manager(GameState& g, const LeImage& exe, int m, const CareerMan
|
||||
}
|
||||
for (size_t i = 0; i < 0x690; i++) g.manager_results.at(size_t(m) * 0x690 + i) = 0xff;
|
||||
const uint8_t level = mem.u8(::bmh::layout::Difficulty);
|
||||
const uint32_t money = level == 0 ? 50000000u : 4000000u - level * 200000u;
|
||||
const uint32_t money = level == 0 ? 50000000u : 3000000u - level * 200000u; // Diamond 3.7: 3 million start capital step base (4 million before)
|
||||
put32(r, rec + 0x314, money);
|
||||
put32(r, rec + 0x324, money);
|
||||
r.at(rec + 0x219) = r.at(rec + 0x218) = 0xf;
|
||||
|
||||
@@ -1,4 +1,8 @@
|
||||
// SPDX-License-Identifier: GPL-3.0-only
|
||||
// Club information screen preparation: sets the line-up markers (first eleven / bench) in the
|
||||
// club's squad_slots, clears markers of injured players and applies the chosen player category.
|
||||
// Reads players and squad ranges, writes squad_slots in GameState. Draws no random numbers.
|
||||
// Interface in club_info.hpp; line-up rules themselves are in lineup.cpp.
|
||||
#include "formats/executable_layout.hpp"
|
||||
#include "game/club_info.hpp"
|
||||
#include <stdexcept>
|
||||
|
||||
@@ -1,4 +1,10 @@
|
||||
// SPDX-License-Identifier: GPL-3.0-only
|
||||
// Player detail screen opened from a club squad or the market pool: resolves the selection to a
|
||||
// squad slot, builds the context (loans, national nomination mode, pending offers) and runs the
|
||||
// actions the screen offers (market value, add to national squad, offers).
|
||||
// Reads and writes players, squad_slots and manager data in GameState.
|
||||
// Draws from WatcomRandom (market value, adding to a squad) and reseeds both generators via
|
||||
// stir_random. Interface in club_player_detail.hpp; related code in national.cpp and weekly.cpp.
|
||||
#include "formats/executable_layout.hpp"
|
||||
#include "game/club_player_detail.hpp"
|
||||
|
||||
|
||||
@@ -1,4 +1,8 @@
|
||||
// SPDX-License-Identifier: GPL-3.0-only
|
||||
// Interface of the player detail screen: selection and context types (squad vs market pool row,
|
||||
// loan data, national mode) and the functions implemented in club_player_detail.cpp.
|
||||
// Context building is read-only; actions take both generators (GameRandom, WatcomRandom) and
|
||||
// a MinuteReport, as documented at each declaration below.
|
||||
#pragma once
|
||||
|
||||
#include <array>
|
||||
|
||||
@@ -1,4 +1,9 @@
|
||||
// SPDX-License-Identifier: GPL-3.0-only
|
||||
// Cup competitions: Masters qualification, replay lists, group tables and qualifiers, friendly
|
||||
// preparation, national tournament end and the draw/advance step advance_cup for each round.
|
||||
// Works on the cup entries in the static memory of GameState and on MatchGroup results.
|
||||
// Draws from WatcomRandom (tie ordering) and GameRandom (shuffling the Masters field).
|
||||
// Interface in cup.hpp; matchday_setup.cpp creates the matches, driver.cpp and season.cpp are neighbours.
|
||||
#include "formats/executable_layout.hpp"
|
||||
#include "game/cup.hpp"
|
||||
|
||||
|
||||
@@ -1,4 +1,9 @@
|
||||
// SPDX-License-Identifier: GPL-3.0-only
|
||||
// Entering a human manager's desk: desk button table per game mode, the random stir, the table
|
||||
// prediction messages, the autosave hook and the manager's prestige (weighted sum of ratings and
|
||||
// money). Reads and writes manager records and the mailbox in GameState.
|
||||
// Draws from WatcomRandom (the four save draws) and reseeds both generators via stir_random.
|
||||
// Interface in desk.hpp; called from turn.cpp before each desk.
|
||||
#include "formats/executable_layout.hpp"
|
||||
#include "game/desk.hpp"
|
||||
|
||||
|
||||
@@ -1,4 +1,7 @@
|
||||
// SPDX-License-Identifier: GPL-3.0-only
|
||||
// Interface for entering a human manager's desk (the part before the desk screen appears):
|
||||
// enter_desk, the draws made when saving, and the prestige update.
|
||||
// Implemented in desk.cpp; uses both generators (GameRandom, WatcomRandom) as documented below.
|
||||
#pragma once
|
||||
// Entering a human manager's desk (DeskDate, the part before the desk screen).
|
||||
|
||||
|
||||
@@ -1,4 +1,10 @@
|
||||
// SPDX-License-Identifier: GPL-3.0-only
|
||||
// Actions a human manager can take at the desk: friendly match quotes and booking (including
|
||||
// the national team variant), training camp configuration, and the transfer offer editor
|
||||
// with bids and market previews.
|
||||
// Reads and writes manager records, memory (friendly plan, calendar), players and squad_slots.
|
||||
// Quotes draw from WatcomRandom on a staged copy that is committed only when accepted; booking
|
||||
// also handles GameRandom. Interface in desk_actions.hpp; bids are settled in weekly.cpp.
|
||||
#include "formats/executable_layout.hpp"
|
||||
#include "game/desk_actions.hpp"
|
||||
|
||||
@@ -613,7 +619,7 @@ TransferActionResult submit_transfer_bid_impl(GameState& g, const TransferBidReq
|
||||
out.status = TransferActionStatus::blocked_by_board;
|
||||
return out;
|
||||
}
|
||||
const uint32_t fee_base = (g.memory.u32(entry + 0x2c) / 10000) * 0x30d4;
|
||||
const uint32_t fee_base = (g.memory.u32(entry + 0x2c) / 10000) * 10000; // Diamond 3.7: base 10000 per 10000 of value (12500 before)
|
||||
const uint32_t salary_base = ((uint32_t((request.contract_years - 1) * 20 + 100) * g.memory.u32(entry + 0x30)) / 10000) * 100;
|
||||
if (fee_base == 0 || salary_base == 0) {
|
||||
out.status = TransferActionStatus::offer_too_low;
|
||||
@@ -935,11 +941,11 @@ TransferActionResult submit_transfer_bid_source_impl(GameState& g, const Transfe
|
||||
bool dfb_fee = false;
|
||||
if (uint32_t(rand.range(92, request.poach ? 98 : 150)) >= fee_pct) {
|
||||
if (request.poach) {
|
||||
// The club refuses; as the player agreed, the DFB sets the fee to 188 % of his
|
||||
// market value (AddToSquad with 0xbc) and the buyer may pay it (PresentManagerDialog).
|
||||
// The club refuses; as the player agreed, the DFB sets the fee to 150 % of his
|
||||
// market value (AddToSquad with 0x96, Diamond 3.7; 188 % = 0xbc before) and the buyer may pay it (PresentManagerDialog).
|
||||
uint32_t fee = 0, salary = 0;
|
||||
const bool loan = (g.memory.u8(list + 0x34 + uint32_t(bid_slot)) & 0x80) != 0;
|
||||
market_value(g, request.source_slot, loan ? 1 : 0, 0xbc, fee, salary, 1, 0, rand);
|
||||
market_value(g, request.source_slot, loan ? 1 : 0, 0x96, fee, salary, 1, 0, rand);
|
||||
g.memory.set32(list + 0x1c + uint32_t(bid_slot) * 4, fee);
|
||||
const std::string question = message_text(g, ::bmh::layout::DeskActions_Unsupported_TextPointer4) + format_amount(g, std::bit_cast<int32_t>(fee)) +
|
||||
message_text(g, ::bmh::layout::DeskActions_Unsupported_TextPointer5);
|
||||
@@ -1228,7 +1234,7 @@ void editor_project(const GameState& g,TransferOfferEditorState& state) {
|
||||
} else {state.years=1;state.term=0;state.fee=0;state.salary=0;state.bonuses.fill(0);}
|
||||
// RateTransferBidSource: explicit byte years and Source32 unsigned products.
|
||||
const uint8_t year_index=state.editable?uint8_t((int(state.term&127)-1)/12):uint8_t(1);
|
||||
state.asking_fee=(g.memory.u32(list+0x2c)/10000u)*12500u;
|
||||
state.asking_fee=(g.memory.u32(list+0x2c)/10000u)*10000u;
|
||||
if(state.editable&&(state.term&128))state.asking_fee>>=2;
|
||||
state.asking_salary=((uint32_t(year_index)*20u+100u)*g.memory.u32(list+0x30)/10000u)*100u;
|
||||
state.money_profiles[0]=editor_profile(0,state.asking_fee*2u|0x40000000u,0xffffffffu,10000,0,state.asking_fee,::bmh::layout::DeskActions_EditorProject_RuntimeField);
|
||||
@@ -1594,7 +1600,7 @@ namespace bmh {
|
||||
namespace {
|
||||
|
||||
// StadiumPriceTable: base price of the 14 periphery objects.
|
||||
constexpr int32_t kPeripheryPrice[14] = {2500000, 1700000, 2200000, 1000000, 1100000, 1500000, 280000,
|
||||
constexpr int32_t kPeripheryPrice[14] = {2200000, 1700000, 2000000, 1000000, 1100000, 1800000, 280000,
|
||||
280000, 280000, 280000, 350000, 350000, 350000, 350000};
|
||||
// CareerSession_DispatchStadium_RuntimeField2[object * 5]: construction time in days.
|
||||
constexpr uint8_t kPeripheryDays[14] = {45, 30, 28, 40, 30, 20, 6, 6, 6, 6, 5, 5, 5, 5};
|
||||
|
||||
@@ -1,4 +1,10 @@
|
||||
// SPDX-License-Identifier: GPL-3.0-only
|
||||
// Match day driver: plays the minutes of all match groups of a matchday in phases (first half,
|
||||
// second half, extra phases), shows or hides screens per button table and handles the phase end
|
||||
// (cup tie decisions, results, reseeding via stir_random).
|
||||
// Works on MatchGroup lists, GameState and the MatchEngine of match_engine.cpp.
|
||||
// Passes both generators on to the engine; itself only reseeds them at phase end.
|
||||
// Interface in driver.hpp; neighbours are matchday_setup.cpp and season.cpp.
|
||||
#include "game/driver.hpp"
|
||||
|
||||
#include <algorithm>
|
||||
|
||||
@@ -1,4 +1,9 @@
|
||||
// SPDX-License-Identifier: GPL-3.0-only
|
||||
// Club environment budgets of a human manager (youth teams, academy, co-trainer, doctor,
|
||||
// physiotherapist): monthly cost per level, setting a level, and the youth team results and
|
||||
// season handover. Reads and writes the budget and youth blocks in the static memory of GameState.
|
||||
// advance_youth_teams draws from WatcomRandom; setting levels draws nothing.
|
||||
// Interface in environment.hpp.
|
||||
#include "formats/executable_layout.hpp"
|
||||
#include "game/environment.hpp"
|
||||
#include <algorithm>
|
||||
|
||||
@@ -1,4 +1,7 @@
|
||||
// SPDX-License-Identifier: GPL-3.0-only
|
||||
// Interface for the club environment budgets (youth teams, academy, co-trainer, doctor,
|
||||
// physiotherapist): item enum, monthly cost steps, state view and the functions implemented in
|
||||
// environment.cpp. Setting a level draws no random number; youth match results use WatcomRandom.
|
||||
#pragma once
|
||||
#include <array>
|
||||
#include <cstdint>
|
||||
|
||||
@@ -1,4 +1,8 @@
|
||||
// SPDX-License-Identifier: GPL-3.0-only
|
||||
// High-score table of the game: computes a manager's score from his record (assets, history,
|
||||
// titles), builds projections of the ranked table and reads/writes the five-row score file bytes.
|
||||
// Reads manager records in GameState; the file images are passed in and out as bytes.
|
||||
// Draws no random numbers. Interface in highscore.hpp.
|
||||
#include "formats/executable_layout.hpp"
|
||||
#include "game/highscore.hpp"
|
||||
|
||||
|
||||
@@ -1,4 +1,7 @@
|
||||
// SPDX-License-Identifier: GPL-3.0-only
|
||||
// Interface of the high-score table: row/table/projection types and the scoring and file
|
||||
// functions implemented in highscore.cpp. Names keep the original text encoding.
|
||||
// Reads GameState only; no random numbers are drawn.
|
||||
#pragma once
|
||||
|
||||
#include <array>
|
||||
|
||||
@@ -1,4 +1,8 @@
|
||||
// SPDX-License-Identifier: GPL-3.0-only
|
||||
// Types for completing the sale of a player to a human buyer (allocator gate, direct mode,
|
||||
// result status). The unsaved observations named here are supplied by the caller; missing
|
||||
// evidence means "unsupported", never an implicit default.
|
||||
// The matching settle_human_buyer_sale function is implemented in weekly.cpp and takes WatcomRandom.
|
||||
#pragma once
|
||||
|
||||
#include <cstddef>
|
||||
|
||||
@@ -1,4 +1,9 @@
|
||||
// SPDX-License-Identifier: GPL-3.0-only
|
||||
// League pairings screen: the fixture view of a league round (filtered, postponed and per team),
|
||||
// paging preferences and the computer tip (predicted results) for the shown round.
|
||||
// Reads and writes GameState (memory preferences, squad data) through the screen owner struct.
|
||||
// Computer tips use the game generator; closing the screen reseeds both generators via
|
||||
// stir_random. Interface in league_pairings.hpp; the tip arithmetic is shared with source_tip.cpp.
|
||||
#include "formats/executable_layout.hpp"
|
||||
#include "game/league_pairings.hpp"
|
||||
|
||||
|
||||
@@ -1,4 +1,7 @@
|
||||
// SPDX-License-Identifier: GPL-3.0-only
|
||||
// Interface of the league pairings screen: constants, owner state, tip result and view types
|
||||
// and the open/move/close functions implemented in league_pairings.cpp. No mutator here calls a
|
||||
// presenter, advances a day or saves; generators are passed in by the caller where needed.
|
||||
#pragma once
|
||||
|
||||
#include <array>
|
||||
|
||||
@@ -1,4 +1,9 @@
|
||||
// SPDX-License-Identifier: GPL-3.0-only
|
||||
// Line-up rules: position types per formation depth, player suitability values, automatic
|
||||
// line-up for computer teams and the optimizer for human boards, plus preparing the line-up
|
||||
// entry of a team. Reads players, formations and tactics boards; writes squad_slots and boards.
|
||||
// Draws from WatcomRandom in two places of the automatic selection (see the rand calls below).
|
||||
// Interface in lineup.hpp.
|
||||
#include "formats/executable_layout.hpp"
|
||||
#include "game/lineup.hpp"
|
||||
#include "formats/le.hpp"
|
||||
|
||||
@@ -1,4 +1,9 @@
|
||||
// SPDX-License-Identifier: GPL-3.0-only
|
||||
// Long-career extension: per-club player statistics (appearances, goals, assists) and title
|
||||
// history archives kept in an OpenBMH extension block outside the original save fields, with
|
||||
// encoding to and decoding from bytes for saving.
|
||||
// Reads and writes GameState (memory extension, manager records). Draws no random numbers.
|
||||
// Interface in long_career.hpp.
|
||||
#include "game/long_career.hpp"
|
||||
#include "game/state.hpp"
|
||||
#include "formats/executable_layout.hpp"
|
||||
|
||||
@@ -1,4 +1,7 @@
|
||||
// SPDX-License-Identifier: GPL-3.0-only
|
||||
// Interface of the long-career extension block (extension id, statistics and title history
|
||||
// archive types, record/reset/swap functions and encode/decode) implemented in long_career.cpp.
|
||||
// No random numbers are drawn.
|
||||
#pragma once
|
||||
#include <array>
|
||||
#include <cstdint>
|
||||
|
||||
+10
-4
@@ -1,4 +1,9 @@
|
||||
// SPDX-License-Identifier: GPL-3.0-only
|
||||
// Per-match environment values of the match engine: weather and temperature by month and region,
|
||||
// crowd bonus for the home side, and the start-of-match tactics choice for computer teams.
|
||||
// Reads GameState (clubs, month, spectators); the match state is filled by the caller.
|
||||
// Draws from WatcomRandom (weather, crowd, substitution mode); the minute simulation itself is
|
||||
// match_engine.cpp. Interface in match.hpp.
|
||||
#include "game/match.hpp"
|
||||
|
||||
#include <cstdlib>
|
||||
@@ -131,12 +136,13 @@ void rate_side(GameState& g, const MatchSetup& m, int side, int previous6, Watco
|
||||
// (the original lets two cheat codes, CareerSession_FormatError_RuntimeField9, set a human side's six ratings to
|
||||
// fixed values; not ported)
|
||||
if (manager < 0) {
|
||||
int rhythm = r[6] >> 1; // computer teams: half the balance, at least 50
|
||||
r[7] = uint8_t(rhythm < 50 ? 50 : rhythm);
|
||||
int rhythm = r[6] >> 1; // computer teams: half the balance, at least 48
|
||||
r[7] = uint8_t(rhythm < 48 ? 48 : rhythm); // Diamond 3.7: at least 48 (50 before)
|
||||
} else {
|
||||
// human teams: record +0xd9 (signed) * 5 plus the balance, scaled to 0-100
|
||||
// human teams: record +0xd9 (signed) * 5 plus a constant 110, scaled to 0-100. Diamond 3.7: the
|
||||
// condition/technique balance r[6] no longer enters (before: d9 * 5 + r[6]).
|
||||
const int8_t d9 = int8_t(g.manager_records.at(size_t(manager) * 0xB0C + 0xd9));
|
||||
r[7] = uint8_t((d9 * 5 + r[6]) * 100 / 0xFF);
|
||||
r[7] = uint8_t((d9 * 5 + 110) * 100 / 0xFF);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
+35
-24
@@ -1,4 +1,10 @@
|
||||
// SPDX-License-Identifier: GPL-3.0-only
|
||||
// Minute-by-minute match simulation: chances and goals, shooter/assistant/taker picking,
|
||||
// fouls, cards, injuries, substitutions and tactics changes, producing a MinuteReport per minute.
|
||||
// Reads and writes the match state in GameState and the MatchGroup fixtures it was built with.
|
||||
// Draws from both generators (WatcomRandom and GameRandom); the draw counts are compared with
|
||||
// recordings in regression tests.
|
||||
// MatchEngine is declared in match_engine.hpp; driver.cpp calls it.
|
||||
#include "formats/executable_layout.hpp"
|
||||
#include "game/match_engine.hpp"
|
||||
|
||||
@@ -392,20 +398,24 @@ void MatchEngine::rerate(MatchGroup& g, int m, int s, MinuteReport& report) {
|
||||
|
||||
namespace {
|
||||
|
||||
// Rules of the Diamond 3.7 programme: the injury, booking and red-card chances, the type tables and durations below and the
|
||||
// doctor's cut are the values of version 3.7 (an older Diamond build used other numbers).
|
||||
// OpenBMH deviates from the original: supports designated set-piece takers, the enhanced injury tables, and the extended suspension fields.
|
||||
// Injury type tables of InjurePlayer3 (supported rule profile patch): WatcomRandom(0, 999) is mapped to an
|
||||
// injury type by the first threshold it does not exceed; beyond the last one the type is
|
||||
// 30. Match injuries use the second table (types 6-30, the light types 0-5 of the first
|
||||
// table only happen elsewhere, e.g. in training).
|
||||
constexpr uint16_t kInjuryThresholdsOther[30] = {
|
||||
0x01f, 0x03f, 0x05f, 0x07f, 0x09f, 0x0bf, 0x0f1, 0x122, 0x153, 0x184, 0x1b5, 0x1e6, 0x217, 0x248, 0x279,
|
||||
0x2aa, 0x2db, 0x30c, 0x33d, 0x36e, 0x37e, 0x38e, 0x39e, 0x3ae, 0x3be, 0x3c9, 0x3d4, 0x3da, 0x3e0, 0x3e6};
|
||||
constexpr uint16_t kInjuryThresholdsMatch[24] = {
|
||||
0x03c, 0x079, 0x0b6, 0x0f3, 0x130, 0x16d, 0x1aa, 0x1e7, 0x224, 0x260, 0x29c, 0x2d8,
|
||||
0x315, 0x351, 0x365, 0x379, 0x38d, 0x3a1, 0x3b5, 0x3c3, 0x3d1, 0x3d8, 0x3df, 0x3e6};
|
||||
35, 71, 107, 154, 201, 248, 295, 342, 390, 426, 473, 518, 563, 610, 657,
|
||||
704, 751, 787, 834, 881, 897, 908, 924, 937, 953, 969, 977, 984, 989, 994};
|
||||
// Match injuries are the types 3-30 (the first table's types 0-2 cause no absence and only happen
|
||||
// elsewhere, e.g. in training): 27 thresholds, beyond the last one the type is 30.
|
||||
constexpr uint16_t kInjuryThresholdsMatch[27] = {
|
||||
52, 105, 158, 211, 264, 317, 356, 409, 458, 507, 560, 613, 666, 719,
|
||||
758, 811, 864, 882, 895, 913, 928, 946, 964, 973, 981, 987, 993};
|
||||
// Injury duration (matchdays) by type, table at layout field. Types 0-2 cause no absence.
|
||||
constexpr uint8_t kInjuryDuration[31] = {1, 1, 1, 2, 2, 2, 2, 3, 2, 3, 2, 2, 2, 2, 3, 4,
|
||||
2, 3, 2, 3, 6, 8, 6, 8, 10, 12, 16, 20, 24, 28, 30};
|
||||
constexpr uint8_t kInjuryDuration[31] = {1, 1, 1, 1, 2, 2, 2, 3, 2, 3, 1, 1, 2, 2, 3, 4,
|
||||
2, 1, 2, 3, 6, 8, 6, 10, 8, 10, 14, 16, 20, 22, 24};
|
||||
// Event log codes by event kind (MatchEngineRuntimeField8): yellow, red, injury. A second yellow card
|
||||
// is logged as red - 1 = 4.
|
||||
constexpr uint8_t kEventLogCode[3] = {3, 5, 6};
|
||||
@@ -433,16 +443,16 @@ int injure_player(GameState& g, int slot, int type, bool match, int manager, Wat
|
||||
const int roll = rand.range(0, 999);
|
||||
type = 30;
|
||||
if (match) {
|
||||
for (int i = 0; i < 24; i++)
|
||||
if (roll <= kInjuryThresholdsMatch[i]) { type = i + 6; break; }
|
||||
for (int i = 0; i < 27; i++)
|
||||
if (roll <= kInjuryThresholdsMatch[i]) { type = i + 3; break; }
|
||||
} else {
|
||||
for (int i = 0; i < 30; i++)
|
||||
if (roll <= kInjuryThresholdsOther[i]) { type = i; break; }
|
||||
}
|
||||
int duration = type > 2 ? kInjuryDuration[type] : 0;
|
||||
// w35c bits 27-31 remember the last injury type + 1: a player injured before is out
|
||||
// 1/8 longer (match injuries only).
|
||||
if (match && (p.w35c >> 27) != 0) duration = uint8_t(duration + (duration >> 3));
|
||||
// 1/4 longer (match injuries only).
|
||||
if (match && (p.w35c >> 27) != 0) duration = uint8_t(duration + (duration >> 2));
|
||||
if (manager >= 0) {
|
||||
// layout field: a player insured on the tactics board (slot byte 0x43, bits 6-7 the
|
||||
// cover) earns base pay * (50 + 50 * cover) / 100 per week while out (SquadRange2);
|
||||
@@ -460,17 +470,18 @@ int injure_player(GameState& g, int slot, int type, bool match, int manager, Wat
|
||||
}
|
||||
if (manager >= 0 && duration != 0) {
|
||||
// A human manager's club doctor (record +0x8ae) shortens the absence by
|
||||
// duration * (doctor / 100 - 5) / 16, at most 1 matchday for types 3-19, up to 5 for
|
||||
// the heavy ones (Int16T4); a poor doctor makes it longer.
|
||||
// duration * (doctor / 100 - 5) / 8; a poor doctor makes it longer. The cut is limited
|
||||
// only for the heavy injuries: types 20-25 by 4 matchdays, types 26-27 by 6, types 28-30
|
||||
// by 8; lighter types have no limit (the duration is cut to 0 at the lowest).
|
||||
const int doctor = int16_t(g.manager_records.at(size_t(manager) * 0xB0C + 0x8ae) |
|
||||
g.manager_records.at(size_t(manager) * 0xB0C + 0x8af) << 8);
|
||||
// (the / 16 is Watcom's SAR/SHL/SBB idiom at 00054453: (x + 7) >> 4 for negative
|
||||
// x, so a poor doctor lengthens by one matchday from x = -8 on)
|
||||
// (the / 8 is Watcom's SAR/SHL/SBB idiom: (x + 7) >> 3 for negative x)
|
||||
const int x = duration * (doctor / 100 - 5);
|
||||
int cut = (x + (x < 0 ? 7 : 0)) >> 4;
|
||||
int cap = type >= 3 ? 1 : 0;
|
||||
if (type >= 0x14) cap = ((type - 0x10) >> 2) + 1 + (type >= 0x1a ? 1 : 0);
|
||||
if (cut > cap) cut = cap;
|
||||
int cut = (x + (x < 0 ? 7 : 0)) >> 3;
|
||||
if (type >= 0x14 && type <= 0x1e) {
|
||||
const int cap = type >= 0x1c ? 8 : type >= 0x1a ? 6 : 4;
|
||||
if (cut > cap) cut = cap;
|
||||
}
|
||||
duration = uint8_t(duration - cut);
|
||||
}
|
||||
duration = std::clamp(int(int8_t(duration)), 0, 30); // Int8T
|
||||
@@ -487,8 +498,8 @@ bool MatchEngine::injure(int slot, bool match, int manager, MinuteReport& report
|
||||
|
||||
// EventImpl(-1, 0, side): a foul by `side` in match m. After the referee and team rolls
|
||||
// the event is one of
|
||||
// kind 2 injury (1 in 39): a random line-up player is injured and substituted,
|
||||
// kind 1 straight red card (1 in 28 of the bookings), banned for 1-4 matches,
|
||||
// kind 2 injury (1 in 31): a random line-up player is injured and substituted,
|
||||
// kind 1 straight red card (1 in 34 of the bookings), banned for 1-4 matches,
|
||||
// kind 0 yellow card; a second yellow in the same match turns into a red card (ban 1).
|
||||
// The ordinary minute loop ignores the return byte. Its draw order, immediate
|
||||
// substitutions and synchronous presenters remain the Source mode0 path.
|
||||
@@ -532,14 +543,14 @@ ForcedMatchEvent MatchEngine::event_impl(MatchGroup& g, int m, int s, int minute
|
||||
int kind = 0; // local_70: 0 yellow, 1 red, 2 injury
|
||||
int card_delta = 0; // added to the team's card counters
|
||||
int ban = 0; // local_80: matches banned for a red card (0 = no red card)
|
||||
if (!forced && rand.range(0, 38) == 0) {
|
||||
if (!forced && rand.range(0, 30) == 0) {
|
||||
kind = 2;
|
||||
rand.range(10, 30); // local_7c: passed to InjurePlayer but overwritten there
|
||||
} else {
|
||||
if (rand.range(0, 2) == 0) return result; // no booking after all
|
||||
if (rand.range(0, 3) == 0) return result; // no booking after all
|
||||
// local_5c = the team's card counters DeskRecords_Teams_RuntimeField (low byte yellow, high byte red;
|
||||
// red cards only counted in competitions 0 and 10)
|
||||
if (rand.range(0, 27) == 0) {
|
||||
if (rand.range(0, 33) == 0) {
|
||||
kind = 1;
|
||||
ban = rand.range(1, 4);
|
||||
if (g.desc.at(0) == 0 || g.desc.at(0) == 10) card_delta = 0x100;
|
||||
|
||||
@@ -1,4 +1,10 @@
|
||||
// SPDX-License-Identifier: GPL-3.0-only
|
||||
// Matchday processing shared by all competitions: match results into club tables, cards and
|
||||
// statistics, bonus payments, morale and player development after a match, league screens
|
||||
// and rating of the manager, plus stir_random (reseeding both generators).
|
||||
// Reads and writes GameState (players, tables, manager records, memory).
|
||||
// Draws from GameRandom and WatcomRandom as named at each use below.
|
||||
// Interface in matchday.hpp; the matches are set up in matchday_setup.cpp and played in driver.cpp.
|
||||
#include "formats/executable_layout.hpp"
|
||||
#include "game/environment.hpp"
|
||||
#include "game/matchday.hpp"
|
||||
|
||||
@@ -1,4 +1,10 @@
|
||||
// SPDX-License-Identifier: GPL-3.0-only
|
||||
// Matchday setup: builds the match groups of a calendar day (descriptors, teams, weather,
|
||||
// attendance and catering income, winter postponements, indoor tournament, live match choice,
|
||||
// kick-off) and the football pools coupon.
|
||||
// Reads and writes GameState (memory descriptors, squad_slots, manager records).
|
||||
// Draws heavily from WatcomRandom and also from GameRandom (see the calls below).
|
||||
// Interface in matchday_setup.hpp; results are handled in matchday.cpp and driver.cpp.
|
||||
#include "formats/executable_layout.hpp"
|
||||
#include "game/matchday_setup.hpp"
|
||||
#include "game/trace.hpp"
|
||||
@@ -102,7 +108,7 @@ void restore_forfeit_squad(GameState& g, int team) {
|
||||
// per facility 0-13 that exists, BalancePlanRuntimeField7[k] * attendance * level / 100 (level of
|
||||
// facility 0 = its size step), then scaled by W(85, 115) %.
|
||||
int32_t catering_income(const GameState& g, int manager, int32_t spectators, WatcomRandom& rand) {
|
||||
static const uint8_t kPerVisitor[14] = {0, 10, 10, 3, 5, 15, 3, 3, 3, 3, 2, 2, 2, 2}; // BalancePlanRuntimeField7
|
||||
static const uint8_t kPerVisitor[14] = {0, 10, 15, 3, 5, 10, 3, 3, 3, 3, 2, 2, 2, 2}; // BalancePlanRuntimeField7
|
||||
const size_t rec = size_t(manager) * kManagerRecord;
|
||||
uint32_t sum = 0;
|
||||
for (int k = 0; k < 14; k++) {
|
||||
|
||||
@@ -1,4 +1,8 @@
|
||||
// SPDX-License-Identifier: GPL-3.0-only
|
||||
// Mailbox and text helpers: posting messages to managers, looking up message texts and
|
||||
// formatting numbers with the original's flag conventions.
|
||||
// Reads and writes the mailbox of GameState and reads the text tables installed from the
|
||||
// executable. Draws no random numbers. Interface in messages.hpp.
|
||||
#include "formats/executable_layout.hpp"
|
||||
#include "game/messages.hpp"
|
||||
#include "game/schedule.hpp"
|
||||
|
||||
+7
-1
@@ -1,4 +1,10 @@
|
||||
// SPDX-License-Identifier: GPL-3.0-only
|
||||
// Monthly processing: new transfer list entries and free agents, return of loans, monthly expenses
|
||||
// and income, shares and loans, market value and contract demands/offers/bonuses, and the
|
||||
// month change itself.
|
||||
// Reads and writes GameState (transfer list in memory, squad_slots, players, manager records).
|
||||
// Draws from WatcomRandom (list generation, demands); no GameRandom draws are made here.
|
||||
// Interface in month.hpp; called from turn.cpp, weekly steps are in weekly.cpp.
|
||||
#include "formats/executable_layout.hpp"
|
||||
#include "game/environment.hpp"
|
||||
#include "game/month.hpp"
|
||||
@@ -42,7 +48,7 @@ constexpr int kLeagueClubs = 0x8a; // CareerSession_DispatchLineup_RuntimeF
|
||||
// are the extra value above 500 points.
|
||||
constexpr uint8_t kDevelopment[20] = {6, 6, 6, 5, 5, 5, 4, 4, 3, 1, 10, 15, 20, 30, 40, 45, 55, 75, 85, 95};
|
||||
// BalancePlanRuntimeField5: value of the facilities (maintenance per month), u16 per facility.
|
||||
constexpr uint16_t kFacilityValue[22] = {2000, 3000, 3000, 8000, 4000, 3000, 2500, 2500, 2500, 2500, 2600,
|
||||
constexpr uint16_t kFacilityValue[22] = {2000, 10000, 17000, 8000, 4000, 10000, 2500, 2500, 2500, 2500, 2600,
|
||||
2600, 2600, 2600, 13000, 9000, 9000, 8000, 1000, 1500, 1500, 2000};
|
||||
// BalancePlanRuntimeField6: monthly income of facilities 0-5 per level.
|
||||
constexpr uint16_t kFacilityIncome[6] = {0, 5000, 5000, 4800, 2400, 8000};
|
||||
|
||||
@@ -1,4 +1,9 @@
|
||||
// SPDX-License-Identifier: GPL-3.0-only
|
||||
// National team: nomination of players, swapping the national coach record into the spare
|
||||
// manager slot on international days, adding players to a squad and creating board entries.
|
||||
// Reads and writes GameState (manager records, tactics boards, squad_slots, static bytes).
|
||||
// Draws from WatcomRandom when creating board entries and values. Interface in national.hpp;
|
||||
// called from turn.cpp.
|
||||
#include "formats/executable_layout.hpp"
|
||||
#include "game/national.hpp"
|
||||
|
||||
|
||||
@@ -1,4 +1,8 @@
|
||||
// SPDX-License-Identifier: GPL-3.0-only
|
||||
// "Other games" desk view: rows of the results and fixtures of a competition round (group or
|
||||
// knockout), linked pages and club metadata for display. A read-only projection of GameState
|
||||
// and the loaded texts; the parameter named game is the GameState, not a random generator.
|
||||
// Draws no random numbers. Interface in other_games.hpp.
|
||||
#include "formats/executable_layout.hpp"
|
||||
#include "game/other_games.hpp"
|
||||
|
||||
|
||||
@@ -1,4 +1,6 @@
|
||||
// SPDX-License-Identifier: GPL-3.0-only
|
||||
// Interface of the "other games" view: row, club metadata and page types and the const
|
||||
// projection functions implemented in other_games.cpp. Read-only; no random numbers are drawn.
|
||||
#pragma once
|
||||
|
||||
#include <cstdint>
|
||||
|
||||
@@ -1,4 +1,7 @@
|
||||
// SPDX-License-Identifier: GPL-3.0-only
|
||||
// Types for answering pending transfer offers manually (yes / no / unsupported answers, the
|
||||
// question and dispatch context, allocator gate). Absence of an answer never means "no".
|
||||
// Declarations only; the generators are passed in by the caller as shown below.
|
||||
#pragma once
|
||||
|
||||
#include <functional>
|
||||
|
||||
@@ -1,4 +1,8 @@
|
||||
// SPDX-License-Identifier: GPL-3.0-only
|
||||
// Poaching a player from another club: asking percentage of the club, remaining attempts per
|
||||
// manager and the start and finish of a poach attempt.
|
||||
// Reads and writes GameState (manager records attempt list, transfer list in memory, squad_slots).
|
||||
// Draws from WatcomRandom. Interface in poach.hpp.
|
||||
#include "formats/executable_layout.hpp"
|
||||
#include "game/poach.hpp"
|
||||
|
||||
|
||||
@@ -1,4 +1,8 @@
|
||||
// SPDX-License-Identifier: GPL-3.0-only
|
||||
// Table prediction and season bonus: predicted final league position of a team, the season
|
||||
// bonus paid to a manager and the expected bonus for players.
|
||||
// Reads GameState (tables, tactics boards, manager records); season_bonus can book the payment.
|
||||
// Draws no random numbers. Interface in prediction.hpp; included by desk.cpp and balance_plan.cpp.
|
||||
#include "formats/executable_layout.hpp"
|
||||
#include "game/prediction.hpp"
|
||||
|
||||
|
||||
@@ -1,4 +1,9 @@
|
||||
// SPDX-License-Identifier: GPL-3.0-only
|
||||
// Player and team ratings: player_value weighs selected attributes (condition, technique,
|
||||
// skills, form) and team_rating adds corrections for human managers' players and per-position terms.
|
||||
// Reads players and tactics boards in GameState; the generators come from the RatingContext.
|
||||
// Draws from WatcomRandom through that context in the human-board corrections and for teams
|
||||
// without squads. Interface in rating.hpp.
|
||||
#include "game/rating.hpp"
|
||||
|
||||
#include <array>
|
||||
|
||||
@@ -1,4 +1,9 @@
|
||||
// SPDX-License-Identifier: GPL-3.0-only
|
||||
// Reality scene, ball decisions: shot or pass choice and scoring, blockers on a path, duel and
|
||||
// dribble outcomes and applying the result to the scene.
|
||||
// Reads GameState (players, tactics) and the RealitySetup; mutates the owned scene structures.
|
||||
// Draws from WatcomRandom (and takes GameRandom as a parameter). Interface in reality_ball.hpp;
|
||||
// driven by reality_scene.cpp.
|
||||
#include "game/reality_ball.hpp"
|
||||
#include "game/reality_duel.hpp"
|
||||
|
||||
|
||||
@@ -1,4 +1,7 @@
|
||||
// SPDX-License-Identifier: GPL-3.0-only
|
||||
// Interface of the Reality scene ball logic: ball history, decision and outcome types and the
|
||||
// decide/apply functions implemented in reality_ball.cpp. The functions take WatcomRandom (and
|
||||
// GameRandom where declared).
|
||||
#pragma once
|
||||
|
||||
#include "game/rating.hpp"
|
||||
|
||||
@@ -1,4 +1,8 @@
|
||||
// SPDX-License-Identifier: GPL-3.0-only
|
||||
// Reality scene, fouls and duels: decides whether a duel ends in a foul, whistle, card or
|
||||
// injury, and the follow-up steps of the scene. Executes the forced event callback supplied by the
|
||||
// caller instead of substituting a default.
|
||||
// Reads GameState and the RealitySetup; draws from WatcomRandom. Interface in reality_duel.hpp.
|
||||
#include "game/reality_duel.hpp"
|
||||
|
||||
#include <algorithm>
|
||||
|
||||
@@ -1,4 +1,6 @@
|
||||
// SPDX-License-Identifier: GPL-3.0-only
|
||||
// Interface of the Reality scene foul/duel logic: forced-event and sound callbacks, foul cue and
|
||||
// result types, implemented in reality_duel.cpp. Draws use WatcomRandom as declared below.
|
||||
#pragma once
|
||||
|
||||
#include <functional>
|
||||
|
||||
@@ -1,4 +1,9 @@
|
||||
// SPDX-License-Identifier: GPL-3.0-only
|
||||
// Bridge between one real match of the match engine and the Reality scene: validates that the
|
||||
// engine, generators and fixture still own the scene, advances the scene and settles deferred
|
||||
// substitution requests when it ends.
|
||||
// Works on the MatchEngine state and its two generators; the draws are made by the scene code
|
||||
// it calls (reality_scene.cpp). Interface in reality_match.hpp.
|
||||
#include "formats/executable_layout.hpp"
|
||||
#include "game/reality_match.hpp"
|
||||
|
||||
|
||||
Loaded 100 of 331 files, more files were not shown because too many files have changed in this diff.
Show more
Reference in new issue
Block a user