incentive/psopeeps-newserv
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

add default cheat mode behavior flag

Browse Source
This commit is contained in:
Martin Michelsen
2023-06-12 19:20:49 -07:00
parent 276284cd39
commit e18c3fc43d
5 changed files with 105 additions and 58 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/ChatCommands.cc
+57 -43
View File
@@ -70,8 +70,11 @@ static void check_is_ep3(shared_ptr<Client> c, bool is_ep3) {
} }
} }
static void check_cheats_enabled(shared_ptr<Lobby> l) { static void check_cheats_enabled(shared_ptr<ServerState> s, shared_ptr<Lobby> l = nullptr) {
if (!(l->flags & Lobby::Flag::CHEATS_ENABLED)) { if (s->cheat_mode_behavior == ServerState::CheatModeBehavior::OFF) {
throw precondition_failed(u"$C6Cheats are disabled.");
}
if (l && !(l->flags & Lobby::Flag::CHEATS_ENABLED)) {
throw precondition_failed(u"$C6This command can\nonly be used in\ncheat mode."); throw precondition_failed(u"$C6This command can\nonly be used in\ncheat mode.");
} }
} }
@@ -438,16 +441,21 @@ static void proxy_command_send_server(shared_ptr<ServerState>,
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
// Lobby commands // Lobby commands
static void server_command_cheat(shared_ptr<ServerState>, shared_ptr<Lobby> l, static void server_command_cheat(shared_ptr<ServerState> s, shared_ptr<Lobby> l,
shared_ptr<Client> c, const std::u16string&) { shared_ptr<Client> c, const std::u16string&) {
check_is_game(l, true); check_is_game(l, true);
check_is_leader(l, c); check_is_leader(l, c);
if (s->cheat_mode_behavior == ServerState::CheatModeBehavior::OFF) {
send_text_message(c, u"$C6Cheat mode cannot\nbe enabled on this\nserver");
return;
}
l->flags ^= Lobby::Flag::CHEATS_ENABLED; l->flags ^= Lobby::Flag::CHEATS_ENABLED;
send_text_message_printf(l, "Cheat mode %s", send_text_message_printf(l, "Cheat mode %s",
(l->flags & Lobby::Flag::CHEATS_ENABLED) ? "enabled" : "disabled"); (l->flags & Lobby::Flag::CHEATS_ENABLED) ? "enabled" : "disabled");
// if cheat mode was disabled, turn off all the cheat features that were on // If cheat mode was disabled, turn off all the cheat features that were on
if (!(l->flags & Lobby::Flag::CHEATS_ENABLED)) { if (!(l->flags & Lobby::Flag::CHEATS_ENABLED)) {
for (size_t x = 0; x < l->max_clients; x++) { for (size_t x = 0; x < l->max_clients; x++) {
auto c = l->clients[x]; auto c = l->clients[x];
@@ -964,9 +972,9 @@ static void server_command_ban(shared_ptr<ServerState> s, shared_ptr<Lobby> l,
// Cheat commands // Cheat commands
static void server_command_warp( static void server_command_warp(
shared_ptr<Lobby> l, shared_ptr<Client> c, const std::u16string& args, bool is_warpall) { shared_ptr<ServerState> s, shared_ptr<Lobby> l, shared_ptr<Client> c, const std::u16string& args, bool is_warpall) {
check_is_game(l, true); check_is_game(l, true);
check_cheats_enabled(l); check_cheats_enabled(s, l);
uint32_t area = stoul(encode_sjis(args), nullptr, 0); uint32_t area = stoul(encode_sjis(args), nullptr, 0);
if (c->area == area) { if (c->area == area) {
@@ -988,18 +996,19 @@ static void server_command_warp(
} }
} }
static void server_command_warpme(shared_ptr<ServerState>, shared_ptr<Lobby> l, static void server_command_warpme(
shared_ptr<Client> c, const std::u16string& args) { shared_ptr<ServerState> s, shared_ptr<Lobby> l, shared_ptr<Client> c, const std::u16string& args) {
server_command_warp(l, c, args, false); server_command_warp(s, l, c, args, false);
} }
static void server_command_warpall(shared_ptr<ServerState>, shared_ptr<Lobby> l, static void server_command_warpall(
shared_ptr<Client> c, const std::u16string& args) { shared_ptr<ServerState> s, shared_ptr<Lobby> l, shared_ptr<Client> c, const std::u16string& args) {
server_command_warp(l, c, args, true); server_command_warp(s, l, c, args, true);
} }
static void proxy_command_warp( static void proxy_command_warp(
ProxyServer::LinkedSession& session, const std::u16string& args, bool is_warpall) { shared_ptr<ServerState> s, ProxyServer::LinkedSession& session, const std::u16string& args, bool is_warpall) {
check_cheats_enabled(s);
if (!session.is_in_game) { if (!session.is_in_game) {
send_text_message(session.client_channel, u"$C6You must be in a\ngame to use this\ncommand"); send_text_message(session.client_channel, u"$C6You must be in a\ngame to use this\ncommand");
return; return;
@@ -1012,20 +1021,20 @@ static void proxy_command_warp(
session.area = area; session.area = area;
} }
static void proxy_command_warpme(shared_ptr<ServerState>, static void proxy_command_warpme(
ProxyServer::LinkedSession& session, const std::u16string& args) { shared_ptr<ServerState> s, ProxyServer::LinkedSession& session, const std::u16string& args) {
proxy_command_warp(session, args, false); proxy_command_warp(s, session, args, false);
} }
static void proxy_command_warpall(shared_ptr<ServerState>, static void proxy_command_warpall(
ProxyServer::LinkedSession& session, const std::u16string& args) { shared_ptr<ServerState> s, ProxyServer::LinkedSession& session, const std::u16string& args) {
proxy_command_warp(session, args, true); proxy_command_warp(s, session, args, true);
} }
static void server_command_next(shared_ptr<ServerState>, shared_ptr<Lobby> l, static void server_command_next(shared_ptr<ServerState> s, shared_ptr<Lobby> l,
shared_ptr<Client> c, const std::u16string&) { shared_ptr<Client> c, const std::u16string&) {
check_is_game(l, true); check_is_game(l, true);
check_cheats_enabled(l); check_cheats_enabled(s, l);
size_t limit = area_limit_for_episode(l->episode); size_t limit = area_limit_for_episode(l->episode);
if (limit == 0) { if (limit == 0) {
@@ -1034,8 +1043,9 @@ static void server_command_next(shared_ptr<ServerState>, shared_ptr<Lobby> l,
send_warp(c, (c->area + 1) % limit, true); send_warp(c, (c->area + 1) % limit, true);
} }
static void proxy_command_next(shared_ptr<ServerState>, static void proxy_command_next(
ProxyServer::LinkedSession& session, const std::u16string&) { shared_ptr<ServerState> s, ProxyServer::LinkedSession& session, const std::u16string&) {
check_cheats_enabled(s);
if (!session.is_in_game) { if (!session.is_in_game) {
send_text_message(session.client_channel, u"$C6You must be in a\ngame to use this\ncommand"); send_text_message(session.client_channel, u"$C6You must be in a\ngame to use this\ncommand");
return; return;
@@ -1098,52 +1108,55 @@ static void proxy_command_song(shared_ptr<ServerState>,
send_ep3_change_music(session.client_channel, song); send_ep3_change_music(session.client_channel, song);
} }
static void server_command_infinite_hp(shared_ptr<ServerState>, shared_ptr<Lobby> l, static void server_command_infinite_hp(
shared_ptr<Client> c, const std::u16string&) { shared_ptr<ServerState> s, shared_ptr<Lobby> l, shared_ptr<Client> c, const std::u16string&) {
check_is_game(l, true); check_is_game(l, true);
check_cheats_enabled(l); check_cheats_enabled(s, l);
c->options.infinite_hp = !c->options.infinite_hp; c->options.infinite_hp = !c->options.infinite_hp;
send_text_message_printf(c, "$C6Infinite HP %s", send_text_message_printf(c, "$C6Infinite HP %s",
c->options.infinite_hp ? "enabled" : "disabled"); c->options.infinite_hp ? "enabled" : "disabled");
} }
static void proxy_command_infinite_hp(shared_ptr<ServerState>, static void proxy_command_infinite_hp(
ProxyServer::LinkedSession& session, const std::u16string&) { shared_ptr<ServerState> s, ProxyServer::LinkedSession& session, const std::u16string&) {
check_cheats_enabled(s);
session.options.infinite_hp = !session.options.infinite_hp; session.options.infinite_hp = !session.options.infinite_hp;
send_text_message_printf(session.client_channel, "$C6Infinite HP %s", send_text_message_printf(session.client_channel, "$C6Infinite HP %s",
session.options.infinite_hp ? "enabled" : "disabled"); session.options.infinite_hp ? "enabled" : "disabled");
} }
static void server_command_infinite_tp(shared_ptr<ServerState>, shared_ptr<Lobby> l, static void server_command_infinite_tp(
shared_ptr<Client> c, const std::u16string&) { shared_ptr<ServerState> s, shared_ptr<Lobby> l, shared_ptr<Client> c, const std::u16string&) {
check_is_game(l, true); check_is_game(l, true);
check_cheats_enabled(l); check_cheats_enabled(s, l);
c->options.infinite_tp = !c->options.infinite_tp; c->options.infinite_tp = !c->options.infinite_tp;
send_text_message_printf(c, "$C6Infinite TP %s", send_text_message_printf(c, "$C6Infinite TP %s",
c->options.infinite_tp ? "enabled" : "disabled"); c->options.infinite_tp ? "enabled" : "disabled");
} }
static void proxy_command_infinite_tp(shared_ptr<ServerState>, static void proxy_command_infinite_tp(
ProxyServer::LinkedSession& session, const std::u16string&) { shared_ptr<ServerState> s, ProxyServer::LinkedSession& session, const std::u16string&) {
check_cheats_enabled(s);
session.options.infinite_tp = !session.options.infinite_tp; session.options.infinite_tp = !session.options.infinite_tp;
send_text_message_printf(session.client_channel, "$C6Infinite TP %s", send_text_message_printf(session.client_channel, "$C6Infinite TP %s",
session.options.infinite_tp ? "enabled" : "disabled"); session.options.infinite_tp ? "enabled" : "disabled");
} }
static void server_command_switch_assist(shared_ptr<ServerState>, shared_ptr<Lobby> l, static void server_command_switch_assist(
shared_ptr<Client> c, const std::u16string&) { shared_ptr<ServerState> s, shared_ptr<Lobby> l, shared_ptr<Client> c, const std::u16string&) {
check_is_game(l, true); check_is_game(l, true);
check_cheats_enabled(l); check_cheats_enabled(s, l);
c->options.switch_assist = !c->options.switch_assist; c->options.switch_assist = !c->options.switch_assist;
send_text_message_printf(c, "$C6Switch assist %s", send_text_message_printf(c, "$C6Switch assist %s",
c->options.switch_assist ? "enabled" : "disabled"); c->options.switch_assist ? "enabled" : "disabled");
} }
static void proxy_command_switch_assist(shared_ptr<ServerState>, static void proxy_command_switch_assist(
ProxyServer::LinkedSession& session, const std::u16string&) { shared_ptr<ServerState> s, ProxyServer::LinkedSession& session, const std::u16string&) {
check_cheats_enabled(s);
session.options.switch_assist = !session.options.switch_assist; session.options.switch_assist = !session.options.switch_assist;
send_text_message_printf(session.client_channel, "$C6Switch assist %s", send_text_message_printf(session.client_channel, "$C6Switch assist %s",
session.options.switch_assist ? "enabled" : "disabled"); session.options.switch_assist ? "enabled" : "disabled");
@@ -1157,10 +1170,10 @@ static void server_command_drop(shared_ptr<ServerState>, shared_ptr<Lobby> l,
send_text_message_printf(l, "Drops %s", (l->flags & Lobby::Flag::DROPS_ENABLED) ? "enabled" : "disabled"); send_text_message_printf(l, "Drops %s", (l->flags & Lobby::Flag::DROPS_ENABLED) ? "enabled" : "disabled");
} }
static void server_command_item(shared_ptr<ServerState>, shared_ptr<Lobby> l, static void server_command_item(
shared_ptr<Client> c, const std::u16string& args) { shared_ptr<ServerState> s, shared_ptr<Lobby> l, shared_ptr<Client> c, const std::u16string& args) {
check_is_game(l, true); check_is_game(l, true);
check_cheats_enabled(l); check_cheats_enabled(s, l);
string data = parse_data_string(encode_sjis(args)); string data = parse_data_string(encode_sjis(args));
if (data.size() < 2) { if (data.size() < 2) {
@@ -1188,8 +1201,9 @@ static void server_command_item(shared_ptr<ServerState>, shared_ptr<Lobby> l,
send_text_message(c, u"$C7Item created:\n" + decode_sjis(name)); send_text_message(c, u"$C7Item created:\n" + decode_sjis(name));
} }
static void proxy_command_item(shared_ptr<ServerState>, static void proxy_command_item(
ProxyServer::LinkedSession& session, const std::u16string& args) { shared_ptr<ServerState> s, ProxyServer::LinkedSession& session, const std::u16string& args) {
check_cheats_enabled(s);
if (session.version == GameVersion::BB) { if (session.version == GameVersion::BB) {
send_text_message(session.client_channel, send_text_message(session.client_channel,
u"$C6This command cannot\nbe used on the proxy\nserver in BB games"); u"$C6This command cannot\nbe used on the proxy\nserver in BB games");
src/ReceiveCommands.cc
+15 -12
View File
@@ -53,17 +53,19 @@ static shared_ptr<const Menu> proxy_options_menu_for_client(
u"Player notifs", u"Show a message\nwhen other players\njoin or leave"); u"Player notifs", u"Show a message\nwhen other players\njoin or leave");
add_option(ProxyOptionsMenuItemID::BLOCK_PINGS, c->options.suppress_client_pings, add_option(ProxyOptionsMenuItemID::BLOCK_PINGS, c->options.suppress_client_pings,
u"Block pings", u"Block ping commands\nsent by the client"); u"Block pings", u"Block ping commands\nsent by the client");
if (!(c->flags & Client::Flag::IS_EPISODE_3)) { if (s->cheat_mode_behavior != ServerState::CheatModeBehavior::OFF) {
add_option(ProxyOptionsMenuItemID::INFINITE_HP, c->options.infinite_hp, if (!(c->flags & Client::Flag::IS_EPISODE_3)) {
u"Infinite HP", u"Enable automatic HP\nrestoration when\nyou are hit by an\nenemy or trap\n\nCannot revive you\nfrom one-hit kills"); add_option(ProxyOptionsMenuItemID::INFINITE_HP, c->options.infinite_hp,
add_option(ProxyOptionsMenuItemID::INFINITE_TP, c->options.infinite_tp, u"Infinite HP", u"Enable automatic HP\nrestoration when\nyou are hit by an\nenemy or trap\n\nCannot revive you\nfrom one-hit kills");
u"Infinite TP", u"Enable automatic TP\nrestoration when\nyou cast any\ntechnique"); add_option(ProxyOptionsMenuItemID::INFINITE_TP, c->options.infinite_tp,
add_option(ProxyOptionsMenuItemID::SWITCH_ASSIST, c->options.switch_assist, u"Infinite TP", u"Enable automatic TP\nrestoration when\nyou cast any\ntechnique");
u"Switch assist", u"Automatically try\nto unlock 2-player\ndoors when you step\non both switches\nsequentially"); add_option(ProxyOptionsMenuItemID::SWITCH_ASSIST, c->options.switch_assist,
} else { u"Switch assist", u"Automatically try\nto unlock 2-player\ndoors when you step\non both switches\nsequentially");
// Note: This option's text is the maximum possible length for any menu item } else {
add_option(ProxyOptionsMenuItemID::EP3_INFINITE_MESETA, c->options.ep3_infinite_meseta, // Note: This option's text is the maximum possible length for any menu item
u"Infinite Meseta", u"Fix Meseta value\nat 1,000,000"); add_option(ProxyOptionsMenuItemID::EP3_INFINITE_MESETA, c->options.ep3_infinite_meseta,
u"Infinite Meseta", u"Fix Meseta value\nat 1,000,000");
}
} }
add_option(ProxyOptionsMenuItemID::BLOCK_EVENTS, (c->options.override_lobby_event >= 0), add_option(ProxyOptionsMenuItemID::BLOCK_EVENTS, (c->options.override_lobby_event >= 0),
u"Block events", u"Disable seasonal\nevents in the lobby\nand in games"); u"Block events", u"Disable seasonal\nevents in the lobby\nand in games");
@@ -3161,7 +3163,8 @@ shared_ptr<Lobby> create_game_generic(
game->flags = flags | game->flags = flags |
Lobby::Flag::GAME | Lobby::Flag::GAME |
(item_tracking_enabled ? Lobby::Flag::ITEM_TRACKING_ENABLED : 0) | (item_tracking_enabled ? Lobby::Flag::ITEM_TRACKING_ENABLED : 0) |
(drops_enabled ? Lobby::Flag::DROPS_ENABLED : 0); (drops_enabled ? Lobby::Flag::DROPS_ENABLED : 0) |
((s->cheat_mode_behavior == ServerState::CheatModeBehavior::ON_BY_DEFAULT) ? Lobby::Flag::CHEATS_ENABLED : 0);
game->password = password; game->password = password;
game->version = c->version(); game->version = c->version();
game->section_id = c->options.override_section_id >= 0 game->section_id = c->options.override_section_id >= 0
src/ServerState.cc
+15
View File
@@ -29,6 +29,7 @@ ServerState::ServerState(const char* config_filename, bool is_replay)
catch_handler_exceptions(true), catch_handler_exceptions(true),
ep3_behavior_flags(0), ep3_behavior_flags(0),
run_shell_behavior(RunShellBehavior::DEFAULT), run_shell_behavior(RunShellBehavior::DEFAULT),
cheat_mode_behavior(CheatModeBehavior::OFF_BY_DEFAULT),
ep3_card_auction_points(0), ep3_card_auction_points(0),
ep3_card_auction_min_size(0), ep3_card_auction_min_size(0),
ep3_card_auction_max_size(0), ep3_card_auction_max_size(0),
@@ -744,6 +745,20 @@ void ServerState::parse_config(shared_ptr<const JSONObject> config_json) {
} catch (const out_of_range&) { } catch (const out_of_range&) {
} }
try {
const string& behavior = d.at("CheatModeBehavior")->as_string();
if (behavior == "Off") {
this->cheat_mode_behavior = CheatModeBehavior::OFF;
} else if (behavior == "OffByDefault") {
this->cheat_mode_behavior = CheatModeBehavior::OFF_BY_DEFAULT;
} else if (behavior == "OnByDefault") {
this->cheat_mode_behavior = CheatModeBehavior::ON_BY_DEFAULT;
} else {
throw runtime_error("invalid value for CheatModeBehavior");
}
} catch (const out_of_range&) {
}
try { try {
auto v = d.at("LobbyEvent"); auto v = d.at("LobbyEvent");
uint8_t event = v->is_int() ? v->as_int() : event_for_name(v->as_string()); uint8_t event = v->is_int() ? v->as_int() : event_for_name(v->as_string());
src/ServerState.hh
+6
View File
@@ -40,6 +40,11 @@ struct ServerState {
ALWAYS, ALWAYS,
NEVER, NEVER,
}; };
enum class CheatModeBehavior {
OFF = 0,
OFF_BY_DEFAULT,
ON_BY_DEFAULT,
};
std::string config_filename; std::string config_filename;
bool is_replay; bool is_replay;
@@ -60,6 +65,7 @@ struct ServerState {
bool catch_handler_exceptions; bool catch_handler_exceptions;
uint32_t ep3_behavior_flags; uint32_t ep3_behavior_flags;
RunShellBehavior run_shell_behavior; RunShellBehavior run_shell_behavior;
CheatModeBehavior cheat_mode_behavior;
std::vector<std::shared_ptr<const PSOBBEncryption::KeyFile>> bb_private_keys; std::vector<std::shared_ptr<const PSOBBEncryption::KeyFile>> bb_private_keys;
std::shared_ptr<const FunctionCodeIndex> function_code_index; std::shared_ptr<const FunctionCodeIndex> function_code_index;
std::shared_ptr<const PatchFileIndex> pc_patch_file_index; std::shared_ptr<const PatchFileIndex> pc_patch_file_index;
system/config.example.json
+9
View File
@@ -343,6 +343,15 @@
[0x40, "e", "", "Download", "$E$C6Quests to download\nto your Memory Card"], [0x40, "e", "", "Download", "$E$C6Quests to download\nto your Memory Card"],
], ],
// Cheat mode behavior. There are three values:
// "Off": Cheat mode is disabled on the entire server. This also disables
// cheat commands on the proxy server.
// "OffByDefault": Cheat mode is disabled on the entire server, but can be
// enabled in each game and proxy session.
// "OnByDefault": Cheat mode is enabled on the entire server, but can be
// disabled in each game and proxy session.
"CheatModeBehavior": "OnByDefault",
// Whether to enable patches on Episode 3 USA. This functionality depends on // Whether to enable patches on Episode 3 USA. This functionality depends on
// exploiting a bug in Episode 3, and while it seems to work reliably on // exploiting a bug in Episode 3, and while it seems to work reliably on
// Dolphin, it hasn't been tested on a real GameCube. So, newserv doesn't // Dolphin, it hasn't been tested on a real GameCube. So, newserv doesn't