Files
Dreierpack-Manager/src/cli/console/windows_transfer.cpp
T

489 lines
28 KiB
C++

// SPDX-License-Identifier: GPL-3.0-only
// The transfer market of docs/CLI_CONCEPT/06-verein.md 5 (menu 17): the market list, listing an
// own player for sale or loan, and the offer editor Transfer.Negotiate for a purchase or a loan.
//
// The engine calls are the SDL app's (src/app/controller.cpp serve_transfer_action /
// serve_transfer_offer): CareerSession::dispatch_transfer_market, open_transfer_offer and
// dispatch_transfer_offer through app::TransferActions. Request binding and rollback
// belong to that shared boundary, including aborted questions and acknowledgements. The
// original's notices (agreement, refusal) arrive through the sale hook and are printed as
// i lines after the call.
#include <algorithm>
#include "app/window_actions.hpp"
#include "cli/console/console.hpp"
#include "cli/console/detail.hpp"
#include "game/desk_actions.hpp"
#include "game/human_buyer_sale.hpp"
#include "game/poach.hpp"
#include "game/schedule.hpp"
#include "ui/club_info.hpp"
#include "ui/desk_state.hpp"
#include "ui/league_table.hpp"
#include "ui/outgoing_transfer.hpp"
#include "ui/transfer_market.hpp"
namespace bmh::cli::console {
using namespace detail;
namespace {
// The editor of a market player is closed when his four bid places are taken by other clubs
// (OpenTransferEditor: editor_slot finds no free or own place; the original takes at most four bids).
// Agents read the old "this offer cannot be changed" as a fault (learning session B2-004/005).
constexpr const char* kNoBidSlot =
"four other clubs have bid for this player already - there is no room for another offer "
"(at most four bids per player); try another player or wait until he has decided";
constexpr int kPositionNames = 629; // positionGoalkeeperCaps "TOR", ABW, MIT, STU
const std::vector<std::string> kPositionKeys = {"TOR", "ABW", "MIT", "STU"};
// the ten editor fields in the order of OutgoingTransferField
const std::vector<std::string> kOfferFields = {"Fee", "Salary", "Years", "BonusGoal", "BonusPoints", "BonusAppearance",
"BonusChampion", "Bonus2to5", "Bonus6to10", "BonusAvoidRelegation"};
} // namespace
void Console::register_transfer_commands() {
auto market = [this] {
const auto p = prep();
if (!p.transfer_market) fail("E_MODE_LOCKED", "no transfer market here (national team?)");
return *p.transfer_market;
};
// the original's notices during a transfer call, printed after it
auto notices = std::make_shared<std::vector<std::string>>();
// The yes/no questions of a poaching offer (PresentManagerDialog: the selling manager, the DFB
// fee) come from inside the engine call. The console answers them from `answers`; an
// unanswered one is recorded in `pending` and stops the call (nothing is committed), the
// player is asked and the same call runs again with the answers so far.
struct Questions {
std::vector<bool> answers;
size_t next = 0;
std::optional<std::pair<int, std::string>> pending; // manager, text
};
auto questions = std::make_shared<Questions>();
auto hooks = [notices, questions] {
HumanBuyerSaleHooks h;
h.notice = [notices](const GameState&, const HumanBuyerSaleNotice& n) { notices->push_back(utf8(n.original_message)); };
h.confirm = [questions](const GameState&, int manager, const std::string& text) -> bool {
if (questions->next < questions->answers.size()) return questions->answers[questions->next++];
questions->pending = std::make_pair(manager, utf8(text));
throw std::runtime_error("question to player " + std::to_string(manager + 1));
};
return h;
};
auto flush_notices = [this, notices] {
for (const auto& n : *notices) emit('i', n);
notices->clear();
};
auto filter = std::make_shared<std::array<bool, 4>>(std::array<bool, 4>{true, true, true, true});
auto show_market = [this, market, filter](int page) {
const ui::TransferMarketState m = market();
std::vector<const ui::TransferMarketItem*> items;
for (const auto& item : m.items)
if (item.position >= 0 && item.position < 4 && (*filter)[size_t(item.position)]) items.push_back(&item);
constexpr size_t kPage = 20;
const size_t pages = std::max<size_t>(1, (items.size() + kPage - 1) / kPage);
if (page < 1 || size_t(page) > pages) fail("E_BAD_ARGUMENT", "the market has " + std::to_string(pages) + " pages");
std::vector<std::vector<std::string>> rows;
for (size_t i = (size_t(page) - 1) * kPage; i < items.size() && i < size_t(page) * kPage; ++i) {
const auto& it = *items[i];
std::string mark = it.own_listing ? "[own]" : it.own_bid_pending ? "[your bid]" : "";
rows.push_back({"id:" + std::to_string(it.player), utf8(it.name), text(kPositionNames + it.position), std::to_string(it.age),
std::to_string(it.strength), utf8(it.seller_name), money(it.asking_fee), std::to_string(it.offers), mark});
}
emit_table({"Id", "Player", "Pos", "Age", "Str", "Club", "Fee", "Offers", ""}, rows);
emit('i', "page " + std::to_string(page) + "/" + std::to_string(pages) + ", balance " + money(m.balance) + ", credit line " +
money(m.credit_line));
};
openers_[17] = [this, show_market] {
open_window("Transfer");
show_market(1);
};
add({"Transfer", "ShowMarket", {integer("page", 1, 100, true)}, "the offered players (20 per page)", false},
[show_market](const Values& v) { show_market(int(v.integer("page", 1))); });
Param positions = detail::text("positions");
positions.display = "positions:list(TOR,ABW,MIT,STU)|All";
add({"Transfer", "SetMarketFilter", {positions}, "ALLE / TOR / ABW / MIT / STU", false}, [this, filter, show_market](const Values& v) {
std::string list = v.text("positions");
if (lower(list) == "all") {
filter->fill(true);
} else {
// a single position (TOR) counts as the list [TOR]
if (list.size() >= 2 && list.front() == '[' && list.back() == ']') list = list.substr(1, list.size() - 2);
for (char& c : list) c = char(std::toupper(static_cast<unsigned char>(c)));
filter->fill(false);
size_t start = 0;
while (start <= list.size()) {
const size_t comma = list.find(',', start);
std::string item = list.substr(start, comma == std::string::npos ? std::string::npos : comma - start);
item.erase(0, item.find_first_not_of(' '));
item.erase(item.find_last_not_of(' ') + 1);
const auto it = std::find(kPositionKeys.begin(), kPositionKeys.end(), item);
if (it == kPositionKeys.end()) fail("E_BAD_ARGUMENT", "unknown position " + item);
(*filter)[size_t(it - kPositionKeys.begin())] = true;
if (comma == std::string::npos) break;
start = comma + 1;
}
}
show_market(1);
});
// own squad rows by id:/row:/name, market players by id:/name
auto squad_item = [market](const std::string& reference) {
const ui::TransferMarketState m = market();
std::vector<PlayerRef> refs;
for (const auto& s : m.squad) refs.push_back({s.row, s.player, utf8(s.name)});
return m.squad[resolve_player(reference, refs)];
};
auto market_item = [market](const std::string& reference) {
const ui::TransferMarketState m = market();
std::vector<PlayerRef> refs;
for (const auto& it : m.items) refs.push_back({it.list_entry, it.player, utf8(it.name)});
return m.items[resolve_player(reference, refs)];
};
auto list_player = [this, market, squad_item, hooks, flush_notices](const std::string& reference, bool loan) {
const ui::TransferMarketState m = market();
const ui::TransferMarketSquadItem item = squad_item(reference);
if (item.already_listed) fail("E_RULE", utf8(item.name) + " is already on the list");
const auto r = app::TransferActions::listing(m, item, loan);
std::string error;
std::optional<app::TransferActions::MarketDispatch> outcome;
try {
outcome = app::TransferActions(*session_).market(r, hooks(), revision_, error);
} catch (const std::exception& e) {
fail("E_INTERNAL", std::string("transfer: ") + e.what());
}
if (!outcome) {
require_engine(false, "transfer", error);
}
flush_notices();
emit('+', utf8(item.name) + (loan
? " steht auf der Transferliste; der Entleiher wählt 12 oder 24 Monate im Angebot"
: " is on the transfer list"));
};
Param player = detail::text("player");
player.display = "player:Player";
add({"Transfer", "SellPlayer", {player}, "VER-KAUFEN: put an own player on the list", true},
[list_player](const Values& v) { list_player(v.text("player"), false); });
add({"Transfer", "LoanOutPlayer", {player, integer("months", 12, 24, true)}, "VER-LEIHEN: offer an own player for loan", true},
[list_player](const Values& v) {
if (v.integer("months", 24) != 12 && v.integer("months", 24) != 24)
fail("E_BAD_ARGUMENT", "Leihangebote verwenden 12 oder 24 Monate");
list_player(v.text("player"), true);
});
// --- Transfer.Negotiate: the offer editor (06-verein 5.2) -----------------------------
auto show_offer = [this] {
if (!offer_editor_) fail("E_INTERNAL", "no offer editor");
const auto& e = *offer_editor_;
const auto& p = e.panel;
emit('i', utf8(p.player_name) + (p.seller_name.empty() ? std::string() : " (" + utf8(p.seller_name) + ")") + ", age " + std::to_string(p.age) + ", strength " +
std::to_string(p.strength) + (e.quote_loan ? ", loan" : ""));
std::vector<std::vector<std::string>> rows = {
{"demand", money(p.asking_fee), money(p.asking_monthly_salary), "-"},
{"quote", money(p.quoted_fee), money(p.quoted_monthly_salary), std::to_string(p.quoted_years)},
{"offer", money(e.fee), money(e.monthly_salary), std::to_string(e.duration_years)}};
emit_table({"", "Fee", "Monthly salary", "Years"}, rows);
std::vector<std::vector<std::string>> bonuses;
for (size_t i = 0; i < 7; ++i) bonuses.push_back({kOfferFields[3 + i], std::to_string(e.bonuses[i] * (i >= 3 ? 5 : 1))});
emit_table({"Bonus", "Percent"}, bonuses);
if (!e.editable) emit('i', kNoBidSlot);
};
auto offer_request = [this](ui::OutgoingTransferRequestKind kind, ui::OutgoingTransferField field, uint32_t value) {
return app::TransferActions::editor(*offer_editor_, kind, field, value);
};
auto dispatch_offer = [this, hooks, flush_notices](const ui::OutgoingTransferRequest& r,
const app::TransferOfferTeamInfoPresenter& team_info = {},
const app::TransferOfferPlayerInfoPresenter& player_info = {}) {
std::string error;
std::optional<app::CareerSession::TransferOfferEditorDispatch> result;
try {
result = loan_return_offer_active()
? dispatch_loan_return_offer(r, hooks(), error, team_info, player_info)
: app::TransferActions(*session_).offer(r, hooks(), revision_, error, team_info, player_info);
} catch (const std::exception& e) {
fail("E_INTERNAL", std::string("transfer offer: ") + e.what());
}
if (!result) {
require_engine(false, "transfer offer", error);
}
flush_notices();
return *result;
};
auto open_offer = [this, market, market_item, show_offer, dispatch_offer](
const std::string& reference, bool loan, int months = 24) {
const ui::TransferMarketState m = market();
if (loan && months != 12 && months != 24)
fail("E_BAD_ARGUMENT", "Leihangebote verwenden 12 oder 24 Monate");
if (loan && months == 12 && m.source_market_mode != 3)
fail("E_RULE", "Die Laufzeit kann nur im Original-Verhandlungsmodus III geändert werden");
const ui::TransferMarketItem item = market_item(reference);
if (item.own_listing) fail("E_RULE", "that is your own player");
const auto r = app::TransferActions::opening(m, item, loan);
std::string error;
std::optional<app::CareerSession::TransferOfferEditorDispatch> result;
try {
result = app::TransferActions(*session_).open_offer(r, revision_, error);
} catch (const std::exception& e) {
fail("E_INTERNAL", std::string("transfer offer: ") + e.what());
}
if (!result) {
require_engine(false, "transfer offer", error);
}
offer_editor_ = result->editor;
offer_submitted_ = false;
open_window("Transfer.Negotiate");
if (loan && offer_editor_->editable && offer_editor_->duration_years != months / 12) {
auto updated = *offer_editor_;
updated.duration_years = uint8_t(months / 12);
const auto action = app::TransferActions::editor(updated,
ui::OutgoingTransferRequestKind::quote_change,
ui::OutgoingTransferField::duration_years, uint32_t(months / 12));
offer_editor_ = dispatch_offer(action).editor;
}
show_offer();
};
add({"Transfer", "BuyPlayer", {player}, "VER-KAUFEN on a market player: the offer editor", true},
[open_offer](const Values& v) { open_offer(v.text("player"), false); });
add({"Transfer", "HirePlayer", {player, integer("months", 12, 24, true)}, "VER-LEIHEN on a market player: the loan offer", true},
[open_offer](const Values& v) { open_offer(v.text("player"), true, int(v.integer("months", 24))); });
add({"Transfer.Negotiate", "ShowNegotiation", {}, "demand, quote and your offer", false}, [show_offer](const Values&) { show_offer(); });
auto set_field = [this, offer_request, dispatch_offer, show_offer](int field, uint32_t value) {
if (!offer_editor_) fail("E_INTERNAL", "no offer editor");
if (!offer_editor_->editable) fail("E_RULE", kNoBidSlot);
// a refused value must not stay in the editor: every later request posts the whole row
// and the engine would reject it as differing from its single field event
const auto before = *offer_editor_;
auto& e = *offer_editor_;
// the screen stores the edited value, then asks for a fresh quote (LAB_0001bad7);
// bonuses 4-7 are entered in steps of five and stored divided by five
const auto f = static_cast<ui::OutgoingTransferField>(field);
if (field == 0) e.fee = value;
else if (field == 1) e.monthly_salary = value;
else if (field == 2) e.duration_years = uint8_t(value);
else e.bonuses[size_t(field - 3)] = uint8_t(field >= 6 ? value / 5 : value);
try {
auto result = dispatch_offer(offer_request(ui::OutgoingTransferRequestKind::quote_change, f, value));
offer_editor_ = result.editor;
} catch (...) {
offer_editor_ = before;
throw;
}
};
Param field = choice("field", kOfferFields);
add({"Transfer.Negotiate", "SetOfferField", {field, integer("value", 0, 100000000)}, "change one field (a fresh quote follows)", true},
[set_field, show_offer](const Values& v) {
set_field(v.choice("field"), uint32_t(v.integer("value")));
show_offer();
});
add({"Transfer.Negotiate", "SetOffer",
{integer("fee", 0, 100000000), integer("salary", 0, 10000000), integer("years", 1, 4), integer("bonusGoal", 0, 255),
integer("bonusPoints", 0, 255), integer("bonusAppearance", 0, 255), integer("bonusChampion", 0, 1275),
integer("bonus2to5", 0, 1275), integer("bonus6to10", 0, 1275), integer("bonusAvoidRelegation", 0, 1275)},
"all ten fields", true},
[set_field, show_offer](const Values& v) {
const char* names[10] = {"fee", "salary", "years", "bonusGoal", "bonusPoints", "bonusAppearance", "bonusChampion",
"bonus2to5", "bonus6to10", "bonusAvoidRelegation"};
for (int i = 0; i < 10; ++i) set_field(i, uint32_t(v.integer(names[i])));
show_offer();
});
// ANGEBOT; reruns itself when a poaching question was answered (see Questions)
auto submit = std::make_shared<std::function<void()>>();
*submit = [this, offer_request, dispatch_offer, questions, notices, self = std::weak_ptr<std::function<void()>>(submit)] {
if (!offer_editor_) fail("E_INTERNAL", "no offer editor");
if (!offer_editor_->editable) fail("E_RULE", kNoBidSlot);
questions->next = 0;
questions->pending.reset();
std::optional<app::CareerSession::TransferOfferEditorDispatch> answered;
try {
answered = dispatch_offer(offer_request(ui::OutgoingTransferRequestKind::submit, ui::OutgoingTransferField::fee,
offer_editor_->fee));
} catch (...) {
if (!questions->pending) throw;
notices->clear(); // the call was rolled back; its notices come again
const auto [manager, text] = *questions->pending;
const int previous = player_;
player_ = manager + 1;
ask(text, {"Yes", "No"}, "No", [this, questions, self, previous](const std::string& answer) {
player_ = previous;
questions->answers.push_back(answer == "Yes");
if (const auto again = self.lock()) (*again)();
});
return;
}
questions->answers.clear();
const auto& result = *answered;
// after a low offer the original keeps the editor open for a better one (the engine's
// owner stays); only a closed owner ends Transfer.Negotiate
if (result.editor.closed) {
offer_editor_.reset();
close_window();
} else {
offer_editor_ = result.editor;
}
const char* status = "submitted";
switch (result.action.status) {
case TransferActionStatus::accepted: status = "accepted: the player moves to your club"; break;
case TransferActionStatus::pending:
status = "pending: the player decides in one of the next weeks";
offer_submitted_ = true;
break;
case TransferActionStatus::rejected: status = "rejected"; break;
default: break;
}
emit('+', std::string("offer ") + status);
finish_loan_return_offer();
};
add({"Transfer.Negotiate", "SubmitOffer", {}, "ANGEBOT: hand in the offer", true}, [submit](const Values&) { (*submit)(); });
closers_["Transfer.Negotiate"] = [this, offer_request, dispatch_offer] {
// closing the editor (right button) ends the negotiation screen only: a bid already
// handed in stays on the list until the player decides (Handbuch S. 60)
if (offer_editor_) dispatch_offer(offer_request(ui::OutgoingTransferRequestKind::cancel, ui::OutgoingTransferField::fee, offer_editor_->fee));
offer_editor_.reset();
close_window();
emit('+', offer_submitted_ ? "negotiation closed; your offer stands until the player decides" : "offer cancelled");
offer_submitted_ = false;
finish_loan_return_offer();
};
// TEAM-INFO and SPIELER-INFO of the offer editor (OpenTransferEditor): modal screens the engine
// opens inside the editor event; the console prints them and closes them at once (the
// presenters return true), after which the editor is projected again.
add({"Transfer.Negotiate", "ShowTeamInfo", {}, "TEAM-INFO: your club's squad, as the editor shows it", false},
[this, offer_request, dispatch_offer](const Values&) {
if (!offer_editor_) fail("E_INTERNAL", "no offer editor");
auto presenter = [this](app::ClubModalServices& services, int club, const Image&) {
const ClubInfoEntry entry = services.enter_club(club);
const ui::ClubInfoProjection t = ui::club_info_from_game(services.state(), club, entry, exe_, texts_);
emit('i', utf8(t.original_club_name));
std::vector<std::vector<std::string>> rows;
for (const auto& p : t.players) {
if (p.player_id < 0) continue;
const auto& a = p.attributes;
rows.push_back({"id:" + std::to_string(p.player_id), utf8(p.original_name), text(kPositionNames + a.position()),
std::to_string(a.age()), std::to_string(a.strength())});
}
emit_table({"Id", "Player", "Pos", "Age", "Str"}, rows);
return true;
};
const auto result = dispatch_offer(
offer_request(ui::OutgoingTransferRequestKind::team_info, ui::OutgoingTransferField::fee, offer_editor_->fee), presenter);
offer_editor_ = result.editor;
});
add({"Transfer.Negotiate", "ShowPlayerInfo", {}, "SPIELER-INFO: the player's card with his market value", false},
[this, offer_request, dispatch_offer](const Values&) {
if (!offer_editor_) fail("E_INTERNAL", "no offer editor");
auto presenter = [this](app::ClubModalServices& services, const ClubPlayerDetailSelection& selection, const Image&) {
const ClubPlayerDetailRedraw card = services.redraw_player(selection);
const GameState& g = services.state();
const Player& p = g.players.at(size_t(selection.player_id));
emit_table({"Player", "Value"},
{{"name", utf8(g.player_name(selection.player_id))},
{"position", text(kPositionNames + p.position())},
{"age", std::to_string(p.age())},
{"condition", std::to_string(p.condition())},
{"technique", std::to_string(p.technique())},
{"form", std::to_string(p.form())},
{"strength", std::to_string(p.strength())},
{"marketValue", card.market_value ? money(*card.market_value) : "-"}});
return true;
};
const auto result = dispatch_offer(
offer_request(ui::OutgoingTransferRequestKind::player_info, ui::OutgoingTransferField::fee, offer_editor_->fee), {},
presenter);
offer_editor_ = result.editor;
});
// --- Transfer.Poach: ABWERBEN (06-verein 5.6, src/game/poach.hpp) ----------------------
add({"Transfer", "OpenPoach", {}, "ABWERBEN: pick a player of another club (Transfer.Poach)", false}, [this, market](const Values&) {
market();
open_window("Transfer.Poach");
emit('+', "poach: ListPoachClubs([league]), ListClubPlayers(club), PoachPlayer(player); " +
std::to_string(poach_attempts_left(session_->state(), active_slot())) + " attempts left this season");
});
add({"Transfer.Poach", "ListPoachClubs", {integer("league", 0, kLeagueCount - 1, true)}, "the clubs of a league (default: own)", false},
[this](const Values& v) {
const ui::DeskState d = desk();
const int league = v.has("league") ? int(v.integer("league")) : std::max(0, d.league);
const ui::LeagueTableState t = ui::league_table_from_game(session_->state(), d.manager_slot, league);
std::vector<std::vector<std::string>> rows;
for (const auto& r : t.rows)
if (r.runtime_team_id != d.runtime_club) rows.push_back({"club:" + std::to_string(r.runtime_team_id), r.name});
emit('i', t.league_name);
emit_table({"Club", "Name"}, rows);
});
// the squad of a club (runtime id, as ListPoachClubs prints it)
auto club_squad = [this](const std::string& reference) {
std::string number = lower(reference).rfind("club:", 0) == 0 ? reference.substr(5) : reference;
Arg a;
a.text = number;
const auto id = to_int(a);
if (!id || *id < 0 || *id >= runtime_dimensions.league_teams) fail("E_BAD_ARGUMENT", "club is club:<n> (ListPoachClubs)");
return int(*id);
};
Param club = detail::text("club");
club.display = "club:Club";
add({"Transfer.Poach", "ListClubPlayers", {club}, "the players of the club", false}, [this, club_squad](const Values& v) {
const int team = club_squad(v.text("club"));
const GameState& g = session_->state();
const SquadRange range = squad_range(team);
std::vector<std::vector<std::string>> rows;
for (size_t s = range.first; s < range.first + range.count; ++s) {
const int p = g.squad_slots.at(s) & 0xfff;
if (p == 0xfff) continue;
const Player& pl = g.players.at(size_t(p));
rows.push_back({"id:" + std::to_string(p), utf8(g.player_name(p)), text(kPositionNames + pl.position()), std::to_string(pl.age()),
std::to_string(pl.strength(true))});
}
emit('i', utf8(g.club_name(team)));
emit_table({"Id", "Player", "Pos", "Age", "Str"}, rows);
});
add({"Transfer.Poach", "PoachPlayer", {player}, "the offer to a player of another club (decided at once)", true},
[this, show_offer](const Values& v) {
// id:<player> of ListClubPlayers: his slot in a club squad
const std::string reference = v.text("player");
Arg a;
a.text = lower(reference).rfind("id:", 0) == 0 ? reference.substr(3) : reference;
const auto id = to_int(a);
if (!id) fail("E_BAD_ARGUMENT", "player is id:<n> (ListClubPlayers)");
const GameState& g = session_->state();
int slot = -1;
for (size_t s = 0; s < 0xb70 && slot < 0; ++s)
if ((g.squad_slots.at(s) & 0xfff) == *id) slot = int(s);
if (slot < 0) fail("E_BAD_ARGUMENT", "no club player id:" + std::to_string(*id));
std::string error;
std::optional<app::CareerSession::PoachDispatch> result;
try {
result = app::TransferActions(*session_).poach(active_slot(), slot, revision_, error);
} catch (const std::exception& e) {
fail("E_INTERNAL", std::string("poach: ") + e.what());
}
if (!result) {
require_engine(false, "poach", error);
}
for (const auto& m : result->start.messages) emit('i', utf8(m));
switch (result->start.status) {
case PoachStatus::ready: break;
case PoachStatus::invalid: fail("E_RULE", "not a player of another club");
case PoachStatus::attempts_used: fail("E_RULE", "five poaching attempts this season");
case PoachStatus::transfer_ban: fail("E_RULE", "transfer ban");
default: fail("E_RULE", "the player cannot be poached");
}
offer_editor_ = result->editor->editor;
offer_submitted_ = false;
open_window("Transfer.Negotiate");
emit('+', "asking " + std::to_string(result->start.asking_percent) + " % of his value; SubmitOffer decides at once");
show_offer();
});
// the rest of the market (06-verein 5): later steps of stage 3 or engine gaps
for (const char* name : {"SetSquadView", "SetSquadSheet", "SetMarketVisible", "ShowPlayer", "OpenOffers", "OpenSearch",
"ShowTransferNews", "ShowTeamInfo"})
add({"Transfer", name, {}, "not in the console yet", false},
[name](const Values&) { fail("E_ENGINE_GAP", std::string(name) + " is not in the console yet"); });
}
} // namespace bmh::cli::console