/// <summary>
/// Constructor.
/// </summary>
/// <param name="netManager">Network manager managing connection to the
/// player.</param> <param name="netWorld">Network world owning this
/// player.</param> <param name="steamId">Player's steam id.</param>
public NetPlayer(
NetManager netManager, NetWorld netWorld, Steamworks.CSteamID steamId)
{
this.netManager = netManager;
this.netWorld = netWorld;
this.steamId = steamId;
}
/// <summary>
/// Process incoming network message.
/// </summary>
/// <param name="messageId">The id of the message.</param>
/// <param name="senderSteamId">Steamid of the sender client.</param>
/// <param name="reader">The binary reader contaning message data.</param>
public void ProcessMessage(byte messageId, Steamworks.CSteamID senderSteamId, BinaryReader reader)
{
if (messageHandlers.ContainsKey(messageId))
{
messageHandlers[messageId](senderSteamId, reader);
}
}
public void CheckSetupAccount(Steamworks.CSteamID id)
{
try
{
MySqlConnection connection = createConnection();
MySqlCommand command = connection.CreateCommand();
int exists = 0;
command.CommandText = "SELECT EXISTS(SELECT 1 FROM `" + SkinChanger.Instance.Configuration.Instance.DatabaseTableName + "` WHERE `steamId` ='" + id + "' LIMIT 1);";
connection.Open();
object result = command.ExecuteScalar();
if (result != null)
{
Int32.TryParse(result.ToString(), out exists);
}
connection.Close();
if (exists == 0)
{
//command.CommandText = "insert ignore into `" + SkinChanger.Instance.Configuration.Instance.DatabaseTableName + "` (balance,steamId,lastUpdated) values(" + SkinChanger.Instance.Configuration.Instance.InitialBalance + ",'" + id.ToString() + "',now())";
connection.Open();
command.ExecuteNonQuery();
connection.Close();
}
}
catch (Exception ex)
{
Logger.LogException(ex);
}
}
public NetManager()
{
this.netManagerCreationTime = DateTime.UtcNow;
netMessageHandler = new NetMessageHandler(this);
netWorld = new NetWorld(this);
p2pSessionRequestCallback = Steamworks.Callback <Steamworks.P2PSessionRequest_t> .Create((Steamworks.P2PSessionRequest_t result) => {
if (!Steamworks.SteamNetworking.AcceptP2PSessionWithUser(result.m_steamIDRemote))
{
Logger.Log("Accepted p2p session with " + result.m_steamIDRemote.ToString());
}
});
gameLobbyJoinRequestedCallback = Steamworks.Callback <Steamworks.GameLobbyJoinRequested_t> .Create(OnGameLobbyJoinRequested);
lobbyCreatedCallResult = new Steamworks.CallResult <Steamworks.LobbyCreated_t>((Steamworks.LobbyCreated_t result, bool ioFailure) => {
if (result.m_eResult != Steamworks.EResult.k_EResultOK)
{
Logger.Log("Oh my f*****g god i failed to create a lobby for you. Please forgive me. (result: " + result.m_eResult + ")");
MPGUI.Instance.ShowMessageBox("Failed to create lobby due to steam error.\n" + result.m_eResult, () => {
MPController.Instance.LoadLevel("MainMenu");
});
return;
}
Logger.Log("Hey you! I have lobby id for you! " + result.m_ulSteamIDLobby);
// Setup local player.
players[0] = new NetLocalPlayer(this, netWorld, Steamworks.SteamUser.GetSteamID());
mode = Mode.Host;
state = State.Playing;
currentLobbyId = new Steamworks.CSteamID(result.m_ulSteamIDLobby);
});
lobbyEnterCallResult = new Steamworks.CallResult <Steamworks.LobbyEnter_t>((Steamworks.LobbyEnter_t result, bool ioFailure) => {
if (result.m_EChatRoomEnterResponse != (uint)Steamworks.EChatRoomEnterResponse.k_EChatRoomEnterResponseSuccess)
{
Logger.Log("Oh my f*****g god i failed to join the lobby for you. Please forgive me. (reponse: " + result.m_EChatRoomEnterResponse + ")");
players[1] = null;
return;
}
// Setup local player.
players[0] = new NetLocalPlayer(this, netWorld, Steamworks.SteamUser.GetSteamID());
Logger.Log("Oh hello! " + result.m_ulSteamIDLobby);
mode = Mode.Player;
state = State.LoadingGameWorld;
currentLobbyId = new Steamworks.CSteamID(result.m_ulSteamIDLobby);
ShowLoadingScreen(true);
SendHandshake();
});
RegisterProtocolMessagesHandlers();
}
/// <summary>
/// Handle result of join lobby operation.
/// </summary>
/// <param name="result">The operation result.</param>
/// <param name="ioFailure">Did IO failure happen?</param>
void OnLobbyEnter(Steamworks.LobbyEnter_t result, bool ioFailure)
{
if (ioFailure || result.m_EChatRoomEnterResponse != (uint)Steamworks.EChatRoomEnterResponse.k_EChatRoomEnterResponseSuccess)
{
Logger.Error("Failed to join lobby. (reponse: {result.m_EChatRoomEnterResponse}, ioFailure: {ioFailure})");
MPGUI.Instance.ShowMessageBox($"Failed to join lobby.\n(reponse: {result.m_EChatRoomEnterResponse}, ioFailure: {ioFailure})");
players[1] = null;
return;
}
// Setup local player.
players[0] = new NetLocalPlayer(this, netWorld, Steamworks.SteamUser.GetSteamID());
Logger.Debug("Entered lobby: " + result.m_ulSteamIDLobby);
MessagesList.AddMessage("Entered lobby.", MessageSeverity.Info);
mode = Mode.Player;
state = State.LoadingGameWorld;
currentLobbyId = new Steamworks.CSteamID(result.m_ulSteamIDLobby);
ShowLoadingScreen(true);
SendHandshake(players[1]);
}
public bool TryDoCommand(Players.Player causedBy, string chattext)
{
var matched = Regex.Match(chattext, @"/spawnprotect (?<access>.+) (?<steamid>.+)");
if (!matched.Success)
{
Chat.Send(causedBy, "Command didn't match, use /spawnprotect [spawn|nospawn|banner|deny] steamid");
return(true);
}
string access = matched.Groups ["access"].Value;
ulong steamid;
if (!ulong.TryParse(matched.Groups ["steamid"].Value, out steamid))
{
Chat.Send(causedBy, "Failed parsing steamid");
return(true);
}
Steamworks.CSteamID csteamid = new Steamworks.CSteamID(steamid);
if (!csteamid.IsValid())
{
Chat.Send(causedBy, "steamid is not valid");
return(true);
}
NetworkID networkId = new NetworkID(csteamid);
Players.Player targetPlayer;
if (!Players.TryGetPlayer(networkId, out targetPlayer))
{
Chat.Send(causedBy, "Player not found or offline");
return(true);
}
if (access.Equals("spawn"))
{
if (!PermissionsManager.CheckAndWarnPermission(causedBy, SpawnProtectModEntries.PERMISSION_SUPER))
{
return(true);
}
PermissionsManager.AddPermissionToUser(causedBy, targetPlayer, SpawnProtectModEntries.PERMISSION_SPAWN_CHANGE);
}
else if (access.Equals("nospawn"))
{
if (PermissionsManager.HasPermission(causedBy, SpawnProtectModEntries.PERMISSION_SUPER))
{
PermissionsManager.RemovePermissionOfUser(causedBy, targetPlayer, SpawnProtectModEntries.PERMISSION_SPAWN_CHANGE);
}
}
else if (access.Equals("banner"))
{
PermissionsManager.AddPermissionToUser(causedBy, targetPlayer, SpawnProtectModEntries.PERMISSION_BANNER_PREFIX + causedBy.ID.steamID);
}
else if (access.Equals("deny"))
{
PermissionsManager.RemovePermissionOfUser(causedBy, targetPlayer, SpawnProtectModEntries.PERMISSION_BANNER_PREFIX + causedBy.ID.steamID);
}
else
{
Chat.Send(causedBy, "Unknown access level, use /spawnprotect [spawn|nospawn|banner|deny] steamid");
}
return(true);
}
void CuffPlayer(SDG.Unturned.Player player, Steamworks.CSteamID Owner)
{
player.animator.captorID = Owner;
player.animator.captorItem = 1197; //**Handcuff**//
player.animator.captorStrength = ushort.MaxValue;
player.animator.sendGesture(SDG.Unturned.EPlayerGesture.ARREST_START, true);
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="netManager">The network manager owning this player.</param>
/// <param name="netWorld">Network world owning this player.</param>
/// <param name="steamId">The steam id of the player.</param>
public NetLocalPlayer(
NetManager netManager, NetWorld netWorld, Steamworks.CSteamID steamId)
: base(netManager, netWorld, steamId)
{
Instance = this;
steamID = steamId;
GameDoorsManager.Instance.onDoorsOpen = (GameObject door) => {
Messages.OpenDoorsMessage msg = new Messages.OpenDoorsMessage();
msg.position = Utils.GameVec3ToNet(door.transform.position);
msg.open = true;
netManager.BroadcastMessage(msg, Steamworks.EP2PSend.k_EP2PSendReliable);
};
GameDoorsManager.Instance.onDoorsClose = (GameObject door) => {
Messages.OpenDoorsMessage msg = new Messages.OpenDoorsMessage();
msg.position = Utils.GameVec3ToNet(door.transform.position);
msg.open = false;
netManager.BroadcastMessage(msg, Steamworks.EP2PSend.k_EP2PSendReliable);
};
LightSwitchManager.Instance.onLightSwitchUsed =
(GameObject lswitch, bool turnedOn) => {
Messages.LightSwitchMessage msg = new Messages.LightSwitchMessage();
msg.pos = Utils.GameVec3ToNet(lswitch.transform.position);
msg.toggle = turnedOn;
netManager.BroadcastMessage(msg, Steamworks.EP2PSend.k_EP2PSendReliable);
};
if (animManager == null)
{
animManager = new PlayerAnimManager();
}
}
internal FriendGamer(
Steamworks.CSteamID id,
string gamertag,
string displayName,
bool online,
bool playing,
bool away,
bool busy,
bool requestingFriend,
bool friendRequesting
) : base(id, gamertag, displayName)
{
IsOnline = online;
IsPlaying = playing;
IsAway = away;
IsBusy = busy;
FriendRequestSentTo = requestingFriend;
FriendRequestReceivedFrom = friendRequesting;
// TODO: Everything below
IsJoinable = false;
InviteAccepted = false;
InviteReceivedFrom = false;
InviteRejected = false;
InviteSentTo = false;
HasVoice = false;
Presence = string.Empty;
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="netManager">The network manager owning this player.</param>
/// <param name="netWorld">Network world owning this player.</param>
/// <param name="steamId">The steam id of the player.</param>
public NetLocalPlayer(NetManager netManager, NetWorld netWorld, Steamworks.CSteamID steamId) : base(netManager, netWorld, steamId)
{
GameDoorsManager.Instance.onDoorsOpen = () => {
Messages.OpenDoorsMessage msg = new Messages.OpenDoorsMessage();
msg.open = true;
netManager.BroadcastMessage(msg, Steamworks.EP2PSend.k_EP2PSendReliable);
};
GameDoorsManager.Instance.onDoorsClose = () => {
Messages.OpenDoorsMessage msg = new Messages.OpenDoorsMessage();
msg.open = false;
netManager.BroadcastMessage(msg, Steamworks.EP2PSend.k_EP2PSendReliable);
};
GameCallbacks.onObjectPickup = (GameObject gameObj) => {
Messages.PickupObjectMessage msg = new Messages.PickupObjectMessage();
msg.netId = netWorld.GetPickupableNetId(gameObj);
netManager.BroadcastMessage(msg, Steamworks.EP2PSend.k_EP2PSendReliable);
};
GameCallbacks.onObjectRelease = (bool drop) => {
Messages.ReleaseObjectMessage msg = new Messages.ReleaseObjectMessage();
msg.drop = drop;
netManager.BroadcastMessage(msg, Steamworks.EP2PSend.k_EP2PSendReliable);
};
}
protected override void execute(Steamworks.CSteamID executorID, string parameter)
{
string[] Params = Parser.getComponentsFromSerial(parameter, '/');
Player caller = GamemodeLoader.Utilities.Tools.GetPlayer(executorID);
Tools.SendChat(C.Configuration.SpicyString, caller);
}
/// <summary>
/// Adds new object to the ObjectIDs Dictionary.
/// </summary>
/// <param name="osc">Object to add.</param>
/// <param name="objectID">Object ID to assign to object.</param>
/// <returns>ObjectID of object.</returns>
public int AddNewObject(ObjectSyncComponent osc, int objectID)
{
// Assign ObjectID automatically.
if (objectID == AUTOMATIC_ID)
{
if (steamID.m_SteamID == 0)
{
steamID = Steamworks.SteamUser.GetSteamID();
}
Logger.Debug($"Added new ObjectID at: {ObjectIDs.Count + 1}");
ObjectIDs.GetOrAdd(ObjectIDs.Count + 1, osc);
return(ObjectIDs.Count);
}
// Assign object a specific ObjectID.
else
{
Logger.Debug($"Force adding new ObjectID at: {objectID}");
if (ObjectIDs.ContainsKey(objectID))
{
ObjectIDs[objectID] = osc;
}
else
{
ObjectIDs.GetOrAdd(objectID, osc);
}
return(objectID);
}
}
public void CheckSetupAccount(Steamworks.CSteamID id)
{
try
{
var connection = createConnection();
var command = connection.CreateCommand();
var exists = 0;
command.CommandText = "SELECT EXISTS(SELECT 1 FROM `" +
AdminSync.Instance.Configuration.Instance.databaseTableName +
"` WHERE `steamId` ='" + id + "' LIMIT 1);";
connection.Open();
var result = command.ExecuteScalar();
if (result != null)
{
int.TryParse(result.ToString(), out exists);
}
connection.Close();
if (exists == 0)
{
command.CommandText = "insert ignore into `" +
AdminSync.Instance.Configuration.Instance.databaseTableName +
"` (isadmin,steamId,lastUpdated) values(" + 0.ToString() + ",'" +
id.ToString() + "',now())";
connection.Open();
command.ExecuteNonQuery();
connection.Close();
}
}
catch (Exception ex)
{
Logger.LogException(ex);
}
}
/// <summary>
/// Lobby list result.
/// </summary>
/// <param name="result">Lobby list.</param>
void OnLobbyList(Steamworks.LobbyMatchList_t result, bool ioFailure)
{
Logger.Log("Found " + result.m_nLobbiesMatching + " lobbies!");
lobbyIDs.Clear();
lobbyNames.Clear();
for (int i = 0; i < result.m_nLobbiesMatching; i++)
{
Steamworks.CSteamID lobbyID = Steamworks.SteamMatchmaking.GetLobbyByIndex(i);
Steamworks.CSteamID lobbyOwner = Steamworks.SteamMatchmaking.GetLobbyOwner(lobbyID);
if (lobbyOwner.m_SteamID != 0)
{
lobbyIDs.Add(lobbyID);
lobbyOwners.Add(lobbyOwner);
Logger.Log("Lobby ID of index " + i + ": " + lobbyID + " - Owner: " + lobbyOwner);
bool success = Steamworks.SteamMatchmaking.RequestLobbyData(lobbyID);
if (!success)
{
Logger.Error("Failed to get lobby info!");
}
// Temp until lobby data callback is fixed!
int numPlayers = Steamworks.SteamMatchmaking.GetNumLobbyMembers(lobbyID);
lobbyNames.Add("Lobby (" + numPlayers + "/16)");
}
}
MPGUI.Instance.LobbyNames = lobbyNames;
}
protected override void execute(Steamworks.CSteamID executorID, string parameter)
{
// Dedicator.isDedicated?
if (!Provider.isServer)
{
CommandWindow.LogError("You are not the server!");
return;
}
Commands sys = UnturnedFreneticMod.Instance.CommandSystem.System;
// TODO: FreneticScript Core methods to ease this.
foreach (ScriptEvent evt in sys.Events.Values)
{
foreach (KeyValuePair <int, CommandScript> handl in new List <KeyValuePair <int, CommandScript> >(evt.Handlers))
{
evt.RemoveEventHandler(handl.Value.Name);
}
}
sys.Functions.Clear();
for (int i = Commander.commands.Count - 1; i >= 0; i--)
{
if (Commander.commands[i] is UnturnedCustomCommand)
{
Commander.commands.RemoveAt(i);
}
}
UnturnedFreneticMod.Instance.PlayerCommands.Clear();
UnturnedFreneticMod.Instance.AutorunScripts();
SysConsole.Output(OutputType.INFO, "Reloaded succesfully!");
}
/// <summary>
/// Invite player with given id to the lobby.
/// </summary>
/// <param name="invitee">The steam id of the player to invite.</param>
/// <returns>true if player was invited, false otherwise</returns>
public bool InviteToMyLobby(Steamworks.CSteamID invitee)
{
if (!IsHost)
{
return(false);
}
return(Steamworks.SteamMatchmaking.InviteUserToLobby(currentLobbyId, invitee));
}
/// <summary>
/// Leave current lobby.
/// </summary>
private void LeaveLobby()
{
Steamworks.SteamMatchmaking.LeaveLobby(currentLobbyId);
currentLobbyId = Steamworks.CSteamID.Nil;
mode = Mode.None;
state = State.Idle;
Logger.Log("Left lobby.");
}
/// <summary>
/// Update friend list.
/// </summary>
void UpdateFriendList()
{
if (inviteCooldown > 0.0f)
{
inviteCooldown -= Time.deltaTime;
}
else
{
// Reset invited friend steam id.
invitedFriendSteamId.Clear();
}
timeToUpdateFriendList -= Time.deltaTime;
if (timeToUpdateFriendList > 0.0f)
{
return;
}
onlineFriends.Clear();
Steamworks.EFriendFlags friendFlags =
Steamworks.EFriendFlags.k_EFriendFlagImmediate;
int friendsCount = Steamworks.SteamFriends.GetFriendCount(friendFlags);
for (int i = 0; i < friendsCount; ++i)
{
Steamworks.CSteamID friendSteamId =
Steamworks.SteamFriends.GetFriendByIndex(i, friendFlags);
if (Steamworks.SteamFriends.GetFriendPersonaState(friendSteamId) ==
Steamworks.EPersonaState.k_EPersonaStateOffline)
{
continue;
}
FriendEntry friend = new FriendEntry();
friend.steamId = friendSteamId;
friend.name = Steamworks.SteamFriends.GetFriendPersonaName(friendSteamId);
Steamworks.FriendGameInfo_t gameInfo;
Steamworks.SteamFriends.GetFriendGamePlayed(friendSteamId, out gameInfo);
friend.playingMSC = (gameInfo.m_gameID.AppID() == Client.GAME_APP_ID);
if (friend.playingMSC)
{
onlineFriends.Insert(0, friend);
}
else
{
onlineFriends.Add(friend);
}
}
timeToUpdateFriendList = FRIENDLIST_UPDATE_INTERVAL;
}
/// <summary>
/// Leave current lobby.
/// </summary>
private void LeaveLobby()
{
Steamworks.SteamMatchmaking.LeaveLobby(currentLobbyId);
currentLobbyId = Steamworks.CSteamID.Nil;
mode = Mode.None;
state = State.Idle;
players[localPlayerID].Dispose();
players.Clear();
Logger.Log("Left lobby.");
}
private void SetPlayersList(byte CurrentPage, Steamworks.CSteamID CallerSteamID)
{
EffectManager.sendUIEffect(8100, 22, true);
byte multiplier = (byte)((CurrentPage - 1) * 24);
for (byte i = multiplier; (i < (24 + multiplier)) && (i < (byte)Provider.clients.Count); i++)
{
EffectManager.sendUIEffectText(22, CallerSteamID, true, $"text{i}", $"{Provider.clients[i].playerID.characterName}");
}
}
/// <summary>
/// Process handshake message received from the given steam id.
/// </summary>
/// <param name="senderSteamId">The steam id of the sender.</param>
/// <param name="msg">Hand shake message.</param>
private void HandleHandshake(Steamworks.CSteamID senderSteamId, Messages.HandshakeMessage msg)
{
if (IsHost)
{
if (players[1] != null)
{
Logger.Log("Received handshake from player but player is already here.");
LeaveLobby();
return;
}
// Setup THE PLAYER
timeSinceLastHeartbeat = 0.0f;
players[1] = new NetPlayer(this, netWorld, senderSteamId);
// Player can be spawned here safely. Host is already in game and all game objects are here.
players[1].Spawn();
SendHandshake();
}
else
{
if (players[1] == null)
{
Logger.Log("Received handshake from host but host is not here.");
LeaveLobby();
return;
}
Logger.Log("CONNECTION ESTABLISHED!");
MPController.Instance.LoadLevel("GAME");
// Host will be spawned when game will be loaded and OnGameWorldLoad callback will be called.
}
// Set player state.
players[1].Teleport(Utils.NetVec3ToGame(msg.spawnPosition), Utils.NetQuatToGame(msg.spawnRotation));
if (msg.occupiedVehicleId != NetVehicle.INVALID_ID)
{
var vehicle = netWorld.GetVehicle(msg.occupiedVehicleId);
Client.Assert(vehicle != null, $"Player {players[1].GetName()} ({players[1].SteamId}) you tried to join reported that he drives car that does not exists in your game. Vehicle id: {msg.occupiedVehicleId}, passenger: {msg.passenger}");
players[1].EnterVehicle(vehicle, msg.passenger);
}
if (msg.pickedUpObject != NetPickupable.INVALID_ID)
{
players[1].PickupObject(msg.pickedUpObject);
}
players[1].hasHandshake = true;
}
/// <summary>
/// Get network player object by steam id.
/// </summary>
/// <param name="steamId">The steam id used to find player for.</param>
/// <returns>Network player object or null if there is not player matching given steam id.</returns>
public NetPlayer GetPlayer(Steamworks.CSteamID steamId)
{
foreach (NetPlayer player in players)
{
if (player?.SteamId == steamId)
{
return(player);
}
}
return(null);
}
/// <summary>
/// Find player ID based on SteamID.
/// </summary>
/// <param name="steamID">Steam ID of player to find.</param>
/// <returns></returns>
public int GetPlayerIDBySteamID(Steamworks.CSteamID steamID)
{
foreach (var player in players)
{
if (player.Value.SteamId == steamID)
{
return(player.Key);
}
}
return(-1);
}
//private void SetCurrentPage(byte page, ulong mSteamID)
//{
// for (byte i = 0; i < Refresh.Refreshes.Length; i++)
// {
// if (Refresh.Refreshes[i].CallerSteamID.m_SteamID == mSteamID)
// {
// Refresh.Refreshes[i].CurrentPage = page;
// return;
// }
// }
//}
private void SetPlayersList(Steamworks.CSteamID CallerSteamID)
{
EffectManager.sendUIEffect(8100, 22, CallerSteamID, true);
byte multiplier = (byte)((currentPage - 1) * 24);//next 24 player start index
for (byte i = multiplier; i < 24 + multiplier && i < (byte)Provider.clients.Count; i++)
{
EffectManager.sendUIEffectText(22, CallerSteamID, true, $"text{i - multiplier}", $"{Provider.clients[i].playerID.characterName}");
}
EffectManager.sendUIEffectText(22, CallerSteamID, true, "pagemax", $"{PagesCountPl}");
EffectManager.sendUIEffectText(22, CallerSteamID, true, "page", $"{currentPage}");
}
public UnturnedPlayer GetPlayerFromLastMessage(UnturnedPlayer player)
{
Steamworks.CSteamID lastMessageFromPlayer = new Steamworks.CSteamID();
// If the player who sent the message is in the dictionary
if (LastMessageFromPlayer.ContainsKey(player.CSteamID))
{
// Get the player who last messaged him
LastMessageFromPlayer.TryGetValue(player.CSteamID, out lastMessageFromPlayer);
}
return(UnturnedPlayer.FromCSteamID(lastMessageFromPlayer));
}
protected override void execute(Steamworks.CSteamID executorID, string parameter)
{
foreach (SDG.Unturned.SteamPlayer i in SDG.Unturned.Provider.players)
{
if (i.playerID.steamID == executorID)
{
i.player.channel.send("askMessage", SDG.Unturned.ESteamCall.OWNER,
SDG.Unturned.ESteamPacket.UPDATE_UNRELIABLE_BUFFER,
new object[] { (byte)89 }); //89 being the message "Busy"
return;
}
}
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="netManager">The network manager owning this player.</param>
/// <param name="netWorld">Network world owning this player.</param>
/// <param name="steamId">The steam id of the player.</param>
public NetLocalPlayer(NetManager netManager, NetWorld netWorld, Steamworks.CSteamID steamId) : base(netManager, netWorld, steamId)
{
GameDoorsManager.Instance.onDoorsOpen = (GameObject door) => {
Messages.OpenDoorsMessage msg = new Messages.OpenDoorsMessage();
msg.position = Utils.GameVec3ToNet(door.transform.position);
msg.open = true;
netManager.BroadcastMessage(msg, Steamworks.EP2PSend.k_EP2PSendReliable);
};
GameDoorsManager.Instance.onDoorsClose = (GameObject door) => {
Messages.OpenDoorsMessage msg = new Messages.OpenDoorsMessage();
msg.position = Utils.GameVec3ToNet(door.transform.position);
msg.open = false;
netManager.BroadcastMessage(msg, Steamworks.EP2PSend.k_EP2PSendReliable);
};
GameCallbacks.onObjectPickup = (GameObject gameObj) => {
Messages.PickupObjectMessage msg = new Messages.PickupObjectMessage();
msg.netId = netWorld.GetPickupableNetId(gameObj);
Client.Assert(msg.netId != NetPickupable.INVALID_ID, "Tried to pickup not network pickupable.");
netManager.BroadcastMessage(msg, Steamworks.EP2PSend.k_EP2PSendReliable);
};
GameCallbacks.onObjectRelease = (bool drop) => {
Messages.ReleaseObjectMessage msg = new Messages.ReleaseObjectMessage();
msg.drop = drop;
netManager.BroadcastMessage(msg, Steamworks.EP2PSend.k_EP2PSendReliable);
};
BeerCaseManager.Instance.onBottleConsumed = (GameObject bcase) => {
Messages.RemoveBottleMessage msg = new Messages.RemoveBottleMessage();
msg.netId = netWorld.GetPickupableNetId(bcase);
Client.Assert(msg.netId != NetPickupable.INVALID_ID, "Tried to drink from not network beercase.");
netManager.BroadcastMessage(msg, Steamworks.EP2PSend.k_EP2PSendReliable);
};
LightSwitchManager.Instance.onLightSwitchUsed = (GameObject lswitch, bool turnedOn) => {
Messages.LightSwitchMessage msg = new Messages.LightSwitchMessage();
msg.pos = Utils.GameVec3ToNet(lswitch.transform.position);
msg.toggle = turnedOn;
netManager.BroadcastMessage(msg, Steamworks.EP2PSend.k_EP2PSendReliable);
};
if (animManager == null)
{
animManager = new PlayerAnimManager();
}
}
/// <summary>
/// Process incomming network messages.
/// </summary>
private void ProcessMessages()
{
uint size = 0;
while (Steamworks.SteamNetworking.IsP2PPacketAvailable(out size))
{
if (size == 0)
{
Logger.Log("Received empty p2p packet");
continue;
}
// TODO: Pre allocate this buffer and reuse it here - we don't want garbage collector to go crazy with that.
byte[] data = new byte[size];
uint msgSize = 0;
Steamworks.CSteamID senderSteamId = Steamworks.CSteamID.Nil;
if (!Steamworks.SteamNetworking.ReadP2PPacket(data, size, out msgSize, out senderSteamId))
{
continue;
}
// TODO: Joining of the messages if are split?
if (msgSize != size || msgSize == 0)
{
Logger.Log("Invalid packet size");
continue;
}
if (players[1] != null && players[1].SteamId != senderSteamId)
{
Logger.Log("Received network message from user that is not in the session. (" + senderSteamId + ")");
continue;
}
MemoryStream stream = new MemoryStream(data);
BinaryReader reader = new BinaryReader(stream);
byte messageId = reader.ReadByte();
if (messageHandlers.ContainsKey(messageId))
{
messageHandlers[messageId](senderSteamId, reader);
}
}
}
/// <summary>
/// Process incomming network messages.
/// </summary>
private void ProcessMessages()
{
uint size = 0;
while (Steamworks.SteamNetworking.IsP2PPacketAvailable(out size))
{
if (size == 0)
{
Logger.Log("Received empty p2p packet");
continue;
}
// TODO: Pre allocate this buffer and reuse it here - we don't want garbage
// collector to go crazy with that.
byte[] data = new byte[size];
uint msgSize = 0;
Steamworks.CSteamID senderSteamId = Steamworks.CSteamID.Nil;
if (!Steamworks.SteamNetworking.ReadP2PPacket(
data, size, out msgSize, out senderSteamId))
{
Logger.Error("Failed to read p2p packet!");
continue;
}
if (msgSize != size || msgSize == 0)
{
Logger.Error("Invalid packet size");
continue;
}
MemoryStream stream = new MemoryStream(data);
BinaryReader reader = new BinaryReader(stream);
uint protocolId = reader.ReadUInt32();
if (protocolId != PROTOCOL_ID)
{
Logger.Error("The received message was not sent by MSCMP network layer.");
continue;
}
byte messageId = reader.ReadByte();
statistics.RecordReceivedMessage(messageId, size);
netMessageHandler.ProcessMessage(messageId, senderSteamId, reader);
}
}
void UnturnedPermissions_OnJoinRequested(Steamworks.CSteamID player, ref SDG.Unturned.ESteamRejection?rejectionReason)
{
int playerCount = Provider.clients.Count;
PreviousMaxPlayers = Provider.maxPlayers;
if (!UnturnedPlayer.FromCSteamID(player).HasPermission("addslot"))
{
return;
}
if (playerCount >= Provider.maxPlayers)
{
Provider.maxPlayers = byte.Parse((playerCount + 1).ToString());
SlotsAddedPlayers.Add(player);
}
}
