mirrors
/
OpenRCT2
mirror of https://github.com/OpenRCT2/OpenRCT2.git
2
0
Fork 0
Code Issues Projects Releases Wiki Activity

Merge pull request #12858 from ju-pinheiro/network-strong-enums 

NETWORK_PERMISSION and NETWORK_AUTH replaced by strong enums
This commit is contained in:
Tulio Leao 2020-09-15 08:07:19 -03:00 committed by GitHub
parent f7348b1f06 214620951f
commit c1729c8a87
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
16 changed files with 129 additions and 122 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/openrct2-ui/windows/Multiplayer.cpp
View File

@ -972,7 +972,7 @@ static void window_multiplayer_groups_scrollpaint(rct_window* w, rct_drawpixelin
int32_t groupindex = network_get_group_index(_selectedGroup);
if (groupindex != -1)
{
if (network_can_perform_action(groupindex, i))
if (network_can_perform_action(groupindex, static_cast<NetworkPermission>(i)))
{
char* lineCh = buffer;
lineCh = utf8_write_codepoint(lineCh, FORMAT_WINDOW_COLOUR_2);

2
src/openrct2-ui/windows/Player.cpp
View File

@ -468,7 +468,7 @@ void window_player_overview_invalidate(rct_window* w)
}
// Only enable kick button for other players
const bool canKick = network_can_perform_action(network_get_current_player_group_index(), NETWORK_PERMISSION_KICK_PLAYER);
const bool canKick = network_can_perform_action(network_get_current_player_group_index(), NetworkPermission::KickPlayer);
const bool isServer = network_get_player_flags(playerIndex) & NETWORK_PLAYER_FLAG_ISSERVER;
const bool isOwnWindow = (network_get_current_player_id() == w->number);
widget_set_enabled(w, WIDX_KICK, canKick && !isOwnWindow && !isServer);

2
src/openrct2/GameState.cpp
View File

@ -112,7 +112,7 @@ void GameState::Update()
network_update();
if (network_get_mode() == NETWORK_MODE_CLIENT && network_get_status() == NETWORK_STATUS_CONNECTED
&& network_get_authstatus() == NETWORK_AUTH_OK)
&& network_get_authstatus() == NetworkAuth::Ok)
{
numUpdates = std::clamp<uint32_t>(network_get_server_tick() - gCurrentTicks, 0, 10);
}

2
src/openrct2/interface/Chat.cpp
View File

@ -42,7 +42,7 @@ static void chat_clear_input();
bool chat_available()
{
return network_get_mode() != NETWORK_MODE_NONE && network_get_status() == NETWORK_STATUS_CONNECTED
&& network_get_authstatus() == NETWORK_AUTH_OK;
&& network_get_authstatus() == NetworkAuth::Ok;
}
void chat_open()

2
src/openrct2/interface/InteractiveConsole.cpp
View File

@ -1364,7 +1364,7 @@ static int32_t cc_save_park([[maybe_unused]] InteractiveConsole& console, [[mayb
static int32_t cc_say(InteractiveConsole& console, const arguments_t& argv)
{
if (network_get_mode() == NETWORK_MODE_NONE || network_get_status() != NETWORK_STATUS_CONNECTED
|| network_get_authstatus() != NETWORK_AUTH_OK)
|| network_get_authstatus() != NetworkAuth::Ok)
{
console.WriteFormatLine("This command only works in multiplayer mode.");
return 0;

14
src/openrct2/network/NetworkAction.cpp
View File

@ -16,7 +16,7 @@
# include <algorithm>
int32_t NetworkActions::FindCommand(int32_t command)
NetworkPermission NetworkActions::FindCommand(int32_t command)
{
auto it = std::find_if(Actions.begin(), Actions.end(), [&command](NetworkAction const& action) {
for (int currentCommand : action.Commands)
@ -30,24 +30,24 @@ int32_t NetworkActions::FindCommand(int32_t command)
});
if (it != Actions.end())
{
return static_cast<int32_t>(it - Actions.begin());
return static_cast<NetworkPermission>(it - Actions.begin());
}
return -1;
return NetworkPermission::Count;
}
int32_t NetworkActions::FindCommandByPermissionName(const std::string& permission_name)
NetworkPermission NetworkActions::FindCommandByPermissionName(const std::string& permission_name)
{
auto it = std::find_if(Actions.begin(), Actions.end(), [&permission_name](NetworkAction const& action) {
return action.PermissionName == permission_name;
});
if (it != Actions.end())
{
return static_cast<int32_t>(it - Actions.begin());
return static_cast<NetworkPermission>(it - Actions.begin());
}
return -1;
return NetworkPermission::Count;
}
const std::array<NetworkAction, NETWORK_PERMISSION_COUNT> NetworkActions::Actions = {
const std::array<NetworkAction, static_cast<size_t>(NetworkPermission::Count)> NetworkActions::Actions = {
NetworkAction{
STR_ACTION_CHAT,
"PERMISSION_CHAT",

56
src/openrct2/network/NetworkAction.h
View File

@ -22,33 +22,33 @@ enum MISC_COMMAND
MISC_COMMAND_PASSWORDLESS_LOGIN = -3,
};
enum NETWORK_PERMISSION
enum class NetworkPermission : uint32_t
{
NETWORK_PERMISSION_CHAT,
NETWORK_PERMISSION_TERRAFORM,
NETWORK_PERMISSION_SET_WATER_LEVEL,
NETWORK_PERMISSION_TOGGLE_PAUSE,
NETWORK_PERMISSION_CREATE_RIDE,
NETWORK_PERMISSION_REMOVE_RIDE,
NETWORK_PERMISSION_BUILD_RIDE,
NETWORK_PERMISSION_RIDE_PROPERTIES,
NETWORK_PERMISSION_SCENERY,
NETWORK_PERMISSION_PATH,
NETWORK_PERMISSION_CLEAR_LANDSCAPE,
NETWORK_PERMISSION_GUEST,
NETWORK_PERMISSION_STAFF,
NETWORK_PERMISSION_PARK_PROPERTIES,
NETWORK_PERMISSION_PARK_FUNDING,
NETWORK_PERMISSION_KICK_PLAYER,
NETWORK_PERMISSION_MODIFY_GROUPS,
NETWORK_PERMISSION_SET_PLAYER_GROUP,
NETWORK_PERMISSION_CHEAT,
NETWORK_PERMISSION_TOGGLE_SCENERY_CLUSTER,
NETWORK_PERMISSION_PASSWORDLESS_LOGIN,
NETWORK_PERMISSION_MODIFY_TILE,
NETWORK_PERMISSION_EDIT_SCENARIO_OPTIONS,
Chat,
Terraform,
SetWaterLevel,
TogglePause,
CreateRide,
RemoveRide,
BuildRide,
RideProperties,
Scenery,
Path,
ClearLandscape,
Guest,
Staff,
ParkProperties,
ParkFunding,
KickPlayer,
ModifyGroups,
SetPlayerGroup,
Cheat,
ToggleSceneryCluster,
PasswordlessLogin,
ModifyTile,
EditScenarioOptions,
NETWORK_PERMISSION_COUNT,
Count
};
class NetworkAction final
@ -62,8 +62,8 @@ public:
class NetworkActions final
{
public:
static const std::array<NetworkAction, NETWORK_PERMISSION_COUNT> Actions;
static const std::array<NetworkAction, static_cast<size_t>(NetworkPermission::Count)> Actions;
static int32_t FindCommand(int32_t command);
static int32_t FindCommandByPermissionName(const std::string& permission_name);
static NetworkPermission FindCommand(int32_t command);
static NetworkPermission FindCommandByPermissionName(const std::string& permission_name);
};

101
src/openrct2/network/NetworkBase.cpp
View File

@ -414,7 +414,7 @@ int32_t NetworkBase::GetStatus()
return status;
}
int32_t NetworkBase::GetAuthStatus()
NetworkAuth NetworkBase::GetAuthStatus()
{
if (GetMode() == NETWORK_MODE_CLIENT)
{
@ -422,9 +422,9 @@ int32_t NetworkBase::GetAuthStatus()
}
else if (GetMode() == NETWORK_MODE_SERVER)
{
return NETWORK_AUTH_OK;
return NetworkAuth::Ok;
}
return NETWORK_AUTH_NONE;
return NetworkAuth::None;
}
uint32_t NetworkBase::GetServerTick()
@ -610,7 +610,7 @@ void NetworkBase::UpdateClient()
if (!ProcessConnection(*_serverConnection))
{
// Do not show disconnect message window when password window closed/canceled
if (_serverConnection->AuthStatus == NETWORK_AUTH_REQUIREPASSWORD)
if (_serverConnection->AuthStatus == NetworkAuth::RequirePassword)
{
context_force_close_window_by_class(WC_NETWORK_STATUS);
}
@ -993,7 +993,7 @@ void NetworkBase::SetupDefaultGroups()
// Spectator group
auto spectator = std::make_unique<NetworkGroup>();
spectator->SetName("Spectator");
spectator->ToggleActionPermission(NETWORK_PERMISSION_CHAT);
spectator->ToggleActionPermission(NetworkPermission::Chat);
spectator->Id = 1;
group_list.push_back(std::move(spectator));
@ -1001,13 +1001,13 @@ void NetworkBase::SetupDefaultGroups()
auto user = std::make_unique<NetworkGroup>();
user->SetName("User");
user->ActionsAllowed.fill(0xFF);
user->ToggleActionPermission(NETWORK_PERMISSION_KICK_PLAYER);
user->ToggleActionPermission(NETWORK_PERMISSION_MODIFY_GROUPS);
user->ToggleActionPermission(NETWORK_PERMISSION_SET_PLAYER_GROUP);
user->ToggleActionPermission(NETWORK_PERMISSION_CHEAT);
user->ToggleActionPermission(NETWORK_PERMISSION_PASSWORDLESS_LOGIN);
user->ToggleActionPermission(NETWORK_PERMISSION_MODIFY_TILE);
user->ToggleActionPermission(NETWORK_PERMISSION_EDIT_SCENARIO_OPTIONS);
user->ToggleActionPermission(NetworkPermission::KickPlayer);
user->ToggleActionPermission(NetworkPermission::ModifyGroups);
user->ToggleActionPermission(NetworkPermission::SetPlayerGroup);
user->ToggleActionPermission(NetworkPermission::Cheat);
user->ToggleActionPermission(NetworkPermission::PasswordlessLogin);
user->ToggleActionPermission(NetworkPermission::ModifyTile);
user->ToggleActionPermission(NetworkPermission::EditScenarioOptions);
user->Id = 2;
group_list.push_back(std::move(user));
@ -1211,7 +1211,7 @@ void NetworkBase::Client_Send_TOKEN()
{
log_verbose("requesting token");
NetworkPacket packet(NetworkCommand::Token);
_serverConnection->AuthStatus = NETWORK_AUTH_REQUESTED;
_serverConnection->AuthStatus = NetworkAuth::Requested;
_serverConnection->QueuePacket(std::move(packet));
}
@ -1226,7 +1226,7 @@ void NetworkBase::Client_Send_AUTH(
assert(signature.size() <= static_cast<size_t>(UINT32_MAX));
packet << static_cast<uint32_t>(signature.size());
packet.Write(signature.data(), signature.size());
_serverConnection->AuthStatus = NETWORK_AUTH_REQUESTED;
_serverConnection->AuthStatus = NetworkAuth::Requested;
_serverConnection->QueuePacket(std::move(packet));
}
@ -1355,12 +1355,12 @@ void NetworkBase::Server_Send_AUTH(NetworkConnection& connection)
}
NetworkPacket packet(NetworkCommand::Auth);
packet << static_cast<uint32_t>(connection.AuthStatus) << new_playerid;
if (connection.AuthStatus == NETWORK_AUTH_BADVERSION)
if (connection.AuthStatus == NetworkAuth::BadVersion)
{
packet.WriteString(network_get_version().c_str());
}
connection.QueuePacket(std::move(packet));
if (connection.AuthStatus != NETWORK_AUTH_OK && connection.AuthStatus != NETWORK_AUTH_REQUIREPASSWORD)
if (connection.AuthStatus != NetworkAuth::Ok && connection.AuthStatus != NetworkAuth::RequirePassword)
{
connection.Socket->Disconnect();
}
@ -1717,7 +1717,7 @@ void NetworkBase::ProcessPacket(NetworkConnection& connection, NetworkPacket& pa
if (it != handlerList.end())
{
auto commandHandler = it->second;
if (connection.AuthStatus == NETWORK_AUTH_OK || !packet.CommandRequiresAuth())
if (connection.AuthStatus == NetworkAuth::Ok || !packet.CommandRequiresAuth())
{
(this->*commandHandler)(connection, packet);
}
@ -2222,39 +2222,39 @@ void NetworkBase::Client_Handle_AUTH(NetworkConnection& connection, NetworkPacke
{
uint32_t auth_status;
packet >> auth_status >> const_cast<uint8_t&>(player_id);
connection.AuthStatus = static_cast<NETWORK_AUTH>(auth_status);
connection.AuthStatus = static_cast<NetworkAuth>(auth_status);
switch (connection.AuthStatus)
{
case NETWORK_AUTH_OK:
case NetworkAuth::Ok:
Client_Send_GAMEINFO();
break;
case NETWORK_AUTH_BADNAME:
case NetworkAuth::BadName:
connection.SetLastDisconnectReason(STR_MULTIPLAYER_BAD_PLAYER_NAME);
connection.Socket->Disconnect();
break;
case NETWORK_AUTH_BADVERSION:
case NetworkAuth::BadVersion:
{
const char* version = packet.ReadString();
connection.SetLastDisconnectReason(STR_MULTIPLAYER_INCORRECT_SOFTWARE_VERSION, &version);
connection.Socket->Disconnect();
break;
}
case NETWORK_AUTH_BADPASSWORD:
case NetworkAuth::BadPassword:
connection.SetLastDisconnectReason(STR_MULTIPLAYER_BAD_PASSWORD);
connection.Socket->Disconnect();
break;
case NETWORK_AUTH_VERIFICATIONFAILURE:
case NetworkAuth::VerificationFailure:
connection.SetLastDisconnectReason(STR_MULTIPLAYER_VERIFICATION_FAILURE);
connection.Socket->Disconnect();
break;
case NETWORK_AUTH_FULL:
case NetworkAuth::Full:
connection.SetLastDisconnectReason(STR_MULTIPLAYER_SERVER_FULL);
connection.Socket->Disconnect();
break;
case NETWORK_AUTH_REQUIREPASSWORD:
case NetworkAuth::RequirePassword:
context_open_window_view(WV_NETWORK_PASSWORD);
break;
case NETWORK_AUTH_UNKNOWN_KEY_DISALLOWED:
case NetworkAuth::UnknownKeyDisallowed:
connection.SetLastDisconnectReason(STR_MULTIPLAYER_UNKNOWN_KEY_DISALLOWED);
connection.Socket->Disconnect();
break;
@ -2507,7 +2507,7 @@ void NetworkBase::Server_Handle_MAPREQUEST(NetworkConnection& connection, Networ
void NetworkBase::Server_Handle_AUTH(NetworkConnection& connection, NetworkPacket& packet)
{
if (connection.AuthStatus != NETWORK_AUTH_OK)
if (connection.AuthStatus != NetworkAuth::Ok)
{
const char* gameversion = packet.ReadString();
const char* name = packet.ReadString();
@ -2517,7 +2517,7 @@ void NetworkBase::Server_Handle_AUTH(NetworkConnection& connection, NetworkPacke
packet >> sigsize;
if (pubkey == nullptr)
{
connection.AuthStatus = NETWORK_AUTH_VERIFICATIONFAILURE;
connection.AuthStatus = NetworkAuth::VerificationFailure;
}
else
{
@ -2548,70 +2548,70 @@ void NetworkBase::Server_Handle_AUTH(NetworkConnection& connection, NetworkPacke
if (gConfigNetwork.known_keys_only && _userManager.GetUserByHash(hash) == nullptr)
{
log_verbose("Hash %s, not known", hash.c_str());
connection.AuthStatus = NETWORK_AUTH_UNKNOWN_KEY_DISALLOWED;
connection.AuthStatus = NetworkAuth::UnknownKeyDisallowed;
}
else
{
connection.AuthStatus = NETWORK_AUTH_VERIFIED;
connection.AuthStatus = NetworkAuth::Verified;
}
}
else
{
connection.AuthStatus = NETWORK_AUTH_VERIFICATIONFAILURE;
connection.AuthStatus = NetworkAuth::VerificationFailure;
log_verbose("Signature verification failed!");
}
}
catch (const std::exception&)
{
connection.AuthStatus = NETWORK_AUTH_VERIFICATIONFAILURE;
connection.AuthStatus = NetworkAuth::VerificationFailure;
log_verbose("Signature verification failed, invalid data!");
}
}
bool passwordless = false;
if (connection.AuthStatus == NETWORK_AUTH_VERIFIED)
if (connection.AuthStatus == NetworkAuth::Verified)
{
const NetworkGroup* group = GetGroupByID(GetGroupIDByHash(connection.Key.PublicKeyHash()));
passwordless = group->CanPerformCommand(MISC_COMMAND_PASSWORDLESS_LOGIN);
}
if (!gameversion || network_get_version() != gameversion)
{
connection.AuthStatus = NETWORK_AUTH_BADVERSION;
connection.AuthStatus = NetworkAuth::BadVersion;
}
else if (!name)
{
connection.AuthStatus = NETWORK_AUTH_BADNAME;
connection.AuthStatus = NetworkAuth::BadName;
}
else if (!passwordless)
{
if ((!password || strlen(password) == 0) && !_password.empty())
{
connection.AuthStatus = NETWORK_AUTH_REQUIREPASSWORD;
connection.AuthStatus = NetworkAuth::RequirePassword;
}
else if (password && _password != password)
{
connection.AuthStatus = NETWORK_AUTH_BADPASSWORD;
connection.AuthStatus = NetworkAuth::BadPassword;
}
}
if (static_cast<size_t>(gConfigNetwork.maxplayers) <= player_list.size())
{
connection.AuthStatus = NETWORK_AUTH_FULL;
connection.AuthStatus = NetworkAuth::Full;
}
else if (connection.AuthStatus == NETWORK_AUTH_VERIFIED)
else if (connection.AuthStatus == NetworkAuth::Verified)
{
const std::string hash = connection.Key.PublicKeyHash();
if (ProcessPlayerAuthenticatePluginHooks(connection, name, hash))
{
connection.AuthStatus = NETWORK_AUTH_OK;
connection.AuthStatus = NetworkAuth::Ok;
Server_Client_Joined(name, hash, connection);
}
else
{
connection.AuthStatus = NETWORK_AUTH_VERIFICATIONFAILURE;
connection.AuthStatus = NetworkAuth::VerificationFailure;
}
}
else if (connection.AuthStatus != NETWORK_AUTH_REQUIREPASSWORD)
else if (connection.AuthStatus != NetworkAuth::RequirePassword)
{
log_error("Unknown failure (%d) while authenticating client", connection.AuthStatus);
}
@ -3283,7 +3283,7 @@ void network_send_tick()
gNetwork.Server_Send_TICK();
}
int32_t network_get_authstatus()
NetworkAuth network_get_authstatus()
{
return gNetwork.GetAuthStatus();
}
@ -3380,7 +3380,7 @@ void network_set_player_last_action(uint32_t index, int32_t command)
{
Guard::IndexInRange(index, gNetwork.player_list);
gNetwork.player_list[index]->LastAction = NetworkActions::FindCommand(command);
gNetwork.player_list[index]->LastAction = static_cast<int32_t>(NetworkActions::FindCommand(command));
gNetwork.player_list[index]->LastActionTime = platform_get_ticks();
}
@ -3596,10 +3596,11 @@ GameActionResult::Ptr network_modify_groups(
}
NetworkGroup* mygroup = nullptr;
NetworkPlayer* player = gNetwork.GetPlayerByID(actionPlayerId);
auto networkPermission = static_cast<NetworkPermission>(permissionIndex);
if (player != nullptr && permissionState == PermissionState::Toggle)
{
mygroup = gNetwork.GetGroupByID(player->Group);
if (mygroup == nullptr || !mygroup->CanPerformAction(permissionIndex))
if (mygroup == nullptr || !mygroup->CanPerformAction(networkPermission))
{
return std::make_unique<GameActionResult>(
GA_ERROR::DISALLOWED, STR_CANT_MODIFY_PERMISSION_THAT_YOU_DO_NOT_HAVE_YOURSELF);
@ -3626,7 +3627,7 @@ GameActionResult::Ptr network_modify_groups(
}
else
{
group->ToggleActionPermission(permissionIndex);
group->ToggleActionPermission(networkPermission);
}
}
}
@ -3731,7 +3732,7 @@ rct_string_id network_get_action_name_string_id(uint32_t index)
}
}
int32_t network_can_perform_action(uint32_t groupindex, uint32_t index)
int32_t network_can_perform_action(uint32_t groupindex, NetworkPermission index)
{
Guard::IndexInRange(groupindex, gNetwork.group_list);
@ -3989,9 +3990,9 @@ int32_t network_get_status()
{
return NETWORK_STATUS_NONE;
}
int32_t network_get_authstatus()
NetworkAuth network_get_authstatus()
{
return NETWORK_AUTH_NONE;
return NetworkAuth::None;
}
uint32_t network_get_server_tick()
{
@ -4146,7 +4147,7 @@ rct_string_id network_get_action_name_string_id(uint32_t index)
{
return -1;
}
int32_t network_can_perform_action(uint32_t groupindex, uint32_t index)
int32_t network_can_perform_action(uint32_t groupindex, NetworkPermission index)
{
return 0;
}

2
src/openrct2/network/NetworkBase.h
View File

@ -107,7 +107,7 @@ public: // Server
public: // Client
void Reconnect();
int32_t GetMode();
int32_t GetAuthStatus();
NetworkAuth GetAuthStatus();
int32_t GetStatus();
uint8_t GetPlayerID();
void ProcessPlayerInfo();

2
src/openrct2/network/NetworkConnection.cpp
View File

@ -131,7 +131,7 @@ bool NetworkConnection::SendPacket(NetworkPacket& packet)
void NetworkConnection::QueuePacket(NetworkPacket&& packet, bool front)
{
if (AuthStatus == NETWORK_AUTH_OK || !packet.CommandRequiresAuth())
if (AuthStatus == NetworkAuth::Ok || !packet.CommandRequiresAuth())
{
packet.Header.Size = static_cast<uint16_t>(packet.Data.size());
if (front)

2
src/openrct2/network/NetworkConnection.h
View File

@ -28,7 +28,7 @@ class NetworkConnection final
public:
std::unique_ptr<ITcpSocket> Socket = nullptr;
NetworkPacket InboundPacket;
NETWORK_AUTH AuthStatus = NETWORK_AUTH_NONE;
NetworkAuth AuthStatus = NetworkAuth::None;
NetworkStats_t Stats = {};
NetworkPlayer* Player = nullptr;
uint32_t PingTime = 0;

24
src/openrct2/network/NetworkGroup.cpp
View File

@ -38,8 +38,8 @@ NetworkGroup NetworkGroup::FromJson(const json_t* json)
{
continue;
}
int32_t action_id = NetworkActions::FindCommandByPermissionName(perm_name);
if (action_id != -1)
NetworkPermission action_id = NetworkActions::FindCommandByPermissionName(perm_name);
if (action_id != NetworkPermission::Count)
{
group.ToggleActionPermission(action_id);
}
@ -55,7 +55,7 @@ json_t* NetworkGroup::ToJson() const
json_t* actionsArray = json_array();
for (size_t i = 0; i < NetworkActions::Actions.size(); i++)
{
if (CanPerformAction(i))
if (CanPerformAction(static_cast<NetworkPermission>(i)))
{
const char* perm_name = NetworkActions::Actions[i].PermissionName.c_str();
json_array_append_new(actionsArray, json_string(perm_name));
@ -95,10 +95,11 @@ void NetworkGroup::Write(NetworkPacket& packet)
}
}
void NetworkGroup::ToggleActionPermission(size_t index)
void NetworkGroup::ToggleActionPermission(NetworkPermission index)
{
size_t byte = index / 8;
size_t bit = index % 8;
size_t index_st = static_cast<size_t>(index);
size_t byte = index_st / 8;
size_t bit = index_st % 8;
if (byte >= ActionsAllowed.size())
{
return;
@ -106,10 +107,11 @@ void NetworkGroup::ToggleActionPermission(size_t index)
ActionsAllowed[byte] ^= (1 << bit);
}
bool NetworkGroup::CanPerformAction(size_t index) const
bool NetworkGroup::CanPerformAction(NetworkPermission index) const
{
size_t byte = index / 8;
size_t bit = index % 8;
size_t index_st = static_cast<size_t>(index);
size_t byte = index_st / 8;
size_t bit = index_st % 8;
if (byte >= ActionsAllowed.size())
{
return false;
@ -119,8 +121,8 @@ bool NetworkGroup::CanPerformAction(size_t index) const
bool NetworkGroup::CanPerformCommand(int32_t command) const
{
int32_t action = NetworkActions::FindCommand(command);
if (action != -1)
NetworkPermission action = NetworkActions::FindCommand(command);
if (action != NetworkPermission::Count)
{
return CanPerformAction(action);
}

6
src/openrct2/network/NetworkGroup.h
View File

@ -16,6 +16,8 @@
#include <jansson.h>
#include <string>
enum class NetworkPermission : uint32_t;
class NetworkGroup final
{
public:
@ -29,8 +31,8 @@ public:
void Read(NetworkPacket& packet);
void Write(NetworkPacket& packet);
void ToggleActionPermission(size_t index);
bool CanPerformAction(size_t index) const;
void ToggleActionPermission(NetworkPermission index);
bool CanPerformAction(NetworkPermission index) const;
bool CanPerformCommand(int32_t command) const;
json_t* ToJson() const;

24
src/openrct2/network/NetworkTypes.h
View File

@ -44,19 +44,19 @@ enum
NETWORK_STATUS_CONNECTED
};
enum NETWORK_AUTH
enum class NetworkAuth : int32_t
{
NETWORK_AUTH_NONE,
NETWORK_AUTH_REQUESTED,
NETWORK_AUTH_OK,
NETWORK_AUTH_BADVERSION,
NETWORK_AUTH_BADNAME,
NETWORK_AUTH_BADPASSWORD,
NETWORK_AUTH_VERIFICATIONFAILURE,
NETWORK_AUTH_FULL,
NETWORK_AUTH_REQUIREPASSWORD,
NETWORK_AUTH_VERIFIED,
NETWORK_AUTH_UNKNOWN_KEY_DISALLOWED,
None,
Requested,
Ok,
BadVersion,
BadName,
BadPassword,
VerificationFailure,
Full,
RequirePassword,
Verified,
UnknownKeyDisallowed
};
enum class NetworkCommand : uint32_t

5
src/openrct2/network/network.h
View File

@ -29,6 +29,7 @@ struct CoordsXYZ;
class GameActionResult;
enum class ModifyGroupType : uint8_t;
enum class PermissionState : uint8_t;
enum class NetworkPermission : uint32_t;
namespace OpenRCT2
{
@ -53,7 +54,7 @@ void network_update();
void network_process_pending();
void network_flush();
int32_t network_get_authstatus();
NetworkAuth network_get_authstatus();
uint32_t network_get_server_tick();
uint8_t network_get_current_player_id();
int32_t network_get_num_players();
@ -87,7 +88,7 @@ std::unique_ptr<GameActionResult> network_kick_player(NetworkPlayerId_t playerId
uint8_t network_get_default_group();
int32_t network_get_num_actions();
rct_string_id network_get_action_name_string_id(uint32_t index);
int32_t network_can_perform_action(uint32_t groupindex, uint32_t index);
int32_t network_can_perform_action(uint32_t groupindex, NetworkPermission index);
int32_t network_can_perform_command(uint32_t groupindex, int32_t index);
void network_set_pickup_peep(uint8_t playerid, Peep* peep);
Peep* network_get_pickup_peep(uint8_t playerid);

5
src/openrct2/scripting/ScNetwork.hpp
View File

@ -69,7 +69,7 @@ namespace OpenRCT2::Scripting
auto permissionIndex = 0;
for (const auto& action : NetworkActions::Actions)
{
if (network_can_perform_action(index, permissionIndex))
if (network_can_perform_action(index, static_cast<NetworkPermission>(permissionIndex)))
{
auto p = TransformPermissionKeyToJS(action.PermissionName);
result.push_back(p);
@ -113,7 +113,8 @@ namespace OpenRCT2::Scripting
for (size_t i = 0; i < enabledPermissions.size(); i++)
{
auto toggle
= (enabledPermissions[i] != (network_can_perform_action(groupIndex, static_cast<uint32_t>(i)) != 0));
= (enabledPermissions[i]
!= (network_can_perform_action(groupIndex, static_cast<NetworkPermission>(i)) != 0));
if (toggle)
{
auto networkAction2 = NetworkModifyGroupAction(