private void CmdSpawnExplosionCollider(Vector3 pos, PlayerInfoPacket playerInfoPacket)
{
GameObject col = Instantiate(splashCollider);
col.transform.position = pos;
col.GetComponent<SplashDamagerCollider>().SetOwner(playerInfoPacket);
NetworkServer.Spawn(col); // TODO We might be able to do all collisions on the server?
}
public void OnPlayerJoinGame(PlayerJoinEventArgs playerJoinEvent)
{
IPlayer player = playerJoinEvent.Player;
using var packet = new PlayerInfoPacket(PlayerInfoActionType.Add, player);
IEnumerable <IMinecraftUser> players = _server.ConnectedPlayers.Where(x => x.Player.Id != player.Id);
_server.SendTo(players, packet);
}
public void RegisterPlayer(PlayerInfoPacket playerInfo)
{
if(!playerDetails.ContainsKey(playerInfo.networkID)) {
ServerOnlyPlayerDisplay.instance.Log(playerInfo.playerName + " connected");
playerDetails.Add(playerInfo.networkID, playerInfo);
PlayerInfoPacket[] packets = new PlayerInfoPacket[playerDetails.Count];
playerDetails.Values.CopyTo(packets, 0);
RpcUpdatePlayers(packets);
}
}
private void CmdTellServerPlayerInfo(string name, string team)
{
playerName = name;
playerTeam = team;
gameObject.name = playerName;
modelChanger.SetModelColour(playerTeam);
RpcSetClientPlayerInfo(playerName, playerTeam);
NetworkInstanceId _netID = gameObject.GetComponent<NetworkIdentity>().netId;
PlayerInfoPacket packet = new PlayerInfoPacket(playerName, playerTeam, _netID);
ServerPlayerManager.instance.RegisterPlayer(packet);
}
public void OnPlayerLeaveGame(PlayerLeaveEventArgs playerLeaveEvent)
{
IPlayer player = playerLeaveEvent.Player;
using var packet = new PlayerInfoPacket(PlayerInfoActionType.Remove, player);
using var removePlayerPacket = new DestroyEntitiesPacket(player);
IEnumerable <IMinecraftUser> players = _server.ConnectedPlayers.Where(x => x.Player.Id != player.Id);
_server.SendTo(players, packet);
_server.SendTo(players, removePlayerPacket);
}
public void AddScore(NetworkInstanceId id, int newScore)
{
if(playerDetails.ContainsKey(id)) {
playerDetails[id] = new PlayerInfoPacket( // This doesn't feel right..
playerDetails[id].playerName,
playerDetails[id].playerTeam,
playerDetails[id].networkID,
playerDetails[id].score + newScore
);
RpcUdateScore(playerDetails[id]);
}
}
/// <summary>
/// Updates the player library with data from a <see cref="PlayerInfoPacket"/>
/// </summary>
/// <param name="packet"></param>
public void HandlePlayerInfoPacket(PlayerInfoPacket packet)
{
foreach (var action in packet.Actions)
{
// if removing a player, there's no need to look it up or create it
if (packet.Type == PlayerInfoPacket.ActionType.RemovePlayer)
{
_players.Remove(action.UUID);
continue;
}
// try to lookup player, otherwise add it to the player list
if (!_players.TryGetValue(action.UUID, out Player player))
{
player = new Player();
_players.Add(action.UUID, player);
}
switch (packet.Type)
{
case PlayerInfoPacket.ActionType.AddPlayer:
player.GameMode = action.GameMode;
player.Name = action.Name;
player.Ping = action.Ping;
player.DisplayName = action.DisplayName;
player.UUID = action.UUID;
#if UNITY_EDITOR
Debug.Log($"{player.Name} props: {string.Join(", ", action.Properties?.Select(x => x?.ToString()))}");
#endif
break;
case PlayerInfoPacket.ActionType.UpdateDisplayName:
player.DisplayName = action.DisplayName;
break;
case PlayerInfoPacket.ActionType.UpdateGameMode:
player.GameMode = action.GameMode;
break;
case PlayerInfoPacket.ActionType.UpdateLatency:
player.Ping = action.Ping;
break;
default:
throw new Exception($"Invalid player info action type: {packet.Type}");
}
}
// update player list after handling all actions
PlayerList?.UpdatePlayerList(_players.Values.ToArray());
}
public void ResetAllScores()
{
List<NetworkInstanceId> keyList = new List<NetworkInstanceId> (playerDetails.Keys);
foreach (NetworkInstanceId key in keyList) {
playerDetails[key] = new PlayerInfoPacket( // This doesn't feel right either..
playerDetails[key].playerName,
playerDetails[key].playerTeam,
playerDetails[key].networkID,
0
);
RpcUdateScore(playerDetails[key]);
}
}
static byte[] GetBytesFromPacket(PlayerInfoPacket packet)
{
int size = System.Runtime.InteropServices.Marshal.SizeOf(packet);
byte[] bytes = new byte[size];
IntPtr ptr = Marshal.AllocHGlobal(size);
Marshal.StructureToPtr(packet, ptr, true);
Marshal.Copy(ptr, bytes, 0, size);
Marshal.FreeHGlobal(ptr);
return(bytes);
}
/// <summary>
/// Updates the player library with data from a <see cref="PlayerInfoPacket"/>
/// </summary>
/// <param name="packet"></param>
public void HandlePlayerInfoPacket(PlayerInfoPacket packet)
{
foreach (var action in packet.Actions)
{
// if removing a player, there's no need to look it up or create it
if (packet.Type == PlayerInfoPacket.ActionType.RemovePlayer)
{
Players.Remove(action.UUID);
continue;
}
// try to lookup player, otherwise add it to the player list
if (!Players.TryGetValue(action.UUID, out Player player))
{
player = new Player();
Players.Add(action.UUID, player);
}
switch (packet.Type)
{
case PlayerInfoPacket.ActionType.AddPlayer:
player.GameMode = action.GameMode;
player.Name = action.Name;
player.Ping = action.Ping;
player.DisplayName = action.DisplayName;
player.UUID = action.UUID;
break;
case PlayerInfoPacket.ActionType.UpdateDisplayName:
player.DisplayName = action.DisplayName;
break;
case PlayerInfoPacket.ActionType.UpdateGameMode:
player.GameMode = action.GameMode;
break;
case PlayerInfoPacket.ActionType.UpdateLatency:
player.Ping = action.Ping;
break;
default:
throw new Exception($"Invalid player info action type: {packet.Type}");
}
}
// update player list after handling all actions
PlayerList?.UpdatePlayerList(Players.Values.ToArray());
}
public void CheckKeepAlive(long keepAliveId)
{
if (_keepAliveIdQueue.TryDequeue(out long nextKeepAliveId))
{
if (nextKeepAliveId != keepAliveId)
{
_user.Disconnect("Keep-alive id doesn't match.");
return;
}
Ping = (int)(TimeUtilities.GetElapsedMilliseconds() - nextKeepAliveId);
using var playerInfoLatencyPacket = new PlayerInfoPacket(PlayerInfoActionType.UpdateLatency, this);
World.SendToAll(playerInfoLatencyPacket);
}
}
public void TakeDamageOnServer(int amount, PlayerInfoPacket fromPlayerInfo, bool forceDamage = false)
{
lastPlayerToDamage = fromPlayerInfo;
if(!forceDamage && !string.IsNullOrEmpty(fromPlayerInfo.playerTeam)) { // No friendly damage
if(fromPlayerInfo.playerTeam.Equals(thisPlayerInfo.playerTeam)) {
return;
}
}
NetworkServer.FindLocalObject(lastPlayerToDamage.networkID).GetComponent<PlayerHUD>().RpcShowHitmarker(); // only works on host
if(currentHealth > 0) currentHealth -= amount; // So that it doesn't show negative health for players
if(currentHealth <= 0 && !playerFaint.isFainted) {
playerFaint.FaintOnServer();
}
RpcUpdatePlayerHeath(fromPlayerInfo, currentHealth);
}
// Faint handling
public void PlayerHasFainted(PlayerInfoPacket lastPlayerTohurt)
{
string newRespawnText = "";
// Set respawn text
if(lastPlayerTohurt.playerName == playerInfo.playerName) {
if(playerInfo.playerTeam == Settings.HeroTeam) newRespawnText = "<color=cyan>You</color> destroyed yourself!";
else newRespawnText = "<color=red>You</color> destroyed yourself!";
} else { // Wasn't self-kill
if(playerInfo.playerTeam == Settings.HeroTeam) newRespawnText = "<color=red>" + lastPlayerTohurt.playerName + "</color> destroyed <color=cyan>you!</color>";
else newRespawnText = "<color=cyan>" + lastPlayerTohurt.playerName + "</color> destroyed <color=red>you!</color>";
}
newRespawnText += "\nPress R to respawn";
respawnText.text = newRespawnText;
FadeOutScreen(ingameScreen);
FadeInScreen(respawnScreen);
}
public void LoadProcessors()
{
myServer.AssignProcessor(delegate(Packet P)
{
LoginPacket myPacket = (LoginPacket)P;
Console.WriteLine(myPacket.Username + " attempted to connect!");
IConnectionWrapper myData;
if (myLoginHandler.VerifyPlayerLogin(myPacket.Username, myPacket.Sender, myPacket.GetCreationTime(), myPacket.GetSHA(), out myData))
{
var PDataInfo = (PlayerData)myData.MyExternalData;
if (PDataInfo != null)
{
PlayerInfoPacket myInfo = new PlayerInfoPacket();
myInfo.NewChar = false;
myInfo.myMap = myMapHandler.GetPlayerMap(PDataInfo);
myInfo.Sender = myPacket.Sender;
myServer.Send(myInfo, NetDeliveryMethod.ReliableOrdered);
myMapHandler.Login(myData);
}
else
{
ThreadPool.QueueUserWorkItem(delegate(object State)
{
PlayerInfoPacket myInfo = new PlayerInfoPacket();
myInfo.Sender = myPacket.Sender;
PDataInfo = new PlayerData();
myInfo.NewChar = true;
myInfo.SetPlayerData(PDataInfo);
myInfo.myMap = myMapHandler.PlaceInFirstAvailable(myInfo.Sender, PDataInfo);
PDataInfo.CurrentMapID = PDataInfo.CurrentMapID;
myLoginHandler.UpdateInfo(myPacket.GetSHA(), PDataInfo);
myServer.Send(myInfo, NetDeliveryMethod.ReliableOrdered);
});
}
Console.WriteLine("User Authenticated Successfully!\n Awaiting Character Creation!");
}
else
{
LoginFailedPacket myAck = new LoginFailedPacket();
myAck.Sender = myPacket.Sender;
myServer.Send(myAck, NetDeliveryMethod.ReliableOrdered);
Console.WriteLine("User Authentication Failed!");
}
}, typeof(LoginPacket));
myServer.AssignProcessor(delegate(Packet P)
{
IConnectionWrapper mySender;
if ((mySender = myLoginHandler.isLoggedIn(P.UserID)) != null)
{
AnnounceToMapPacket myPacket = (AnnounceToMapPacket)P;
}
}, typeof(AnnounceToMapPacket));
myServer.AssignProcessor(delegate(Packet P)
{
IConnectionWrapper mySender;
if ((mySender = myLoginHandler.isLoggedIn(P.UserID)) != null)
{
IConnectionWrapper Recipient;
WhisperMessagePlayer myPacket = (WhisperMessagePlayer)P;
if ((Recipient = myLoginHandler.isLoggedIn(myPacket.RecipientUserID)) != null)
{
PlayerData Recip = (PlayerData)Recipient.MyExternalData;
PlayerData Sender = (PlayerData)mySender.MyExternalData;
if (Recip.CurrentMapID.CompareTo(Sender.CurrentMapID) == 0)
{
myPacket.Sender = Recipient.GetConnection();
myServer.Send(myPacket, NetDeliveryMethod.ReliableOrdered);
}
}
else
{
//TODO: send response packet.
}
}
}, typeof(WhisperMessagePlayer));
myServer.AssignProcessor(delegate(Packet P)
{
IConnectionWrapper mySender;
if ((mySender = myLoginHandler.isLoggedIn(P.UserID)) != null)
{
SendMessageLocalAreaPacket myPacket = (SendMessageLocalAreaPacket)P;
}
}, typeof(SendMessageLocalAreaPacket));
myServer.AssignProcessor(delegate(Packet P)
{
IConnectionWrapper mySender;
if ((mySender = myLoginHandler.isLoggedIn(P.UserID)) != null)
{
SendMessageMapAreaPacket myPacket = (SendMessageMapAreaPacket)P;
//List<PlayerData> myData = myMapHandler.GetPlayersOnMap();
}
}, typeof(SendMessageMapAreaPacket));
myServer.AssignProcessor(delegate(Packet P)
{
IConnectionWrapper mySender;
if ((mySender = myLoginHandler.isLoggedIn(P.UserID)) != null)
{
AnnounceToAllMapsPacket myPacket = (AnnounceToAllMapsPacket)P;
}
}, typeof(AnnounceToAllMapsPacket));
myServer.AssignProcessor(delegate(Packet P)
{
IConnectionWrapper Wrapper;
if ((Wrapper = myLoginHandler.isLoggedIn(P.UserID)) != null)
{
myLoginHandler.Logout(P.UserID);
myMapHandler.Logout(Wrapper);
}
}, typeof(DisconnectPacket));
myServer.AssignProcessor(delegate(Packet P)
{
IConnectionWrapper myValue = myLoginHandler.isLoggedIn(P.UserID);
if (myValue != null)
{
Map myMap = myMapHandler.GetPlayerMap((PlayerData)myValue.MyExternalData);
foreach (NetConnection A in myMap.GetPlayerIPs())
{
PlayerMapConnectionPacket myNewPlayer = new PlayerMapConnectionPacket();
myNewPlayer.SetNewPlayerData((PlayerData)myValue.MyExternalData);
myNewPlayer.Sender = A;
myServer.Send(myNewPlayer, NetDeliveryMethod.ReliableOrdered);
}
}
}, typeof(MapLoadedPacket));
myServer.AssignProcessor(delegate(Packet P)
{
CharacterCreationPacket Packet = ((CharacterCreationPacket)P);
IConnectionWrapper myValue = myLoginHandler.isLoggedIn(Packet.UserID);
if (myValue != null)
{
((PlayerData)myValue.MyExternalData).SetAnimation(Packet.GetAnimationInfo());
((PlayerData)myValue.MyExternalData).SetName(Packet.GetName());
Map myMap = myMapHandler.GetPlayerMap(((PlayerData)myValue.MyExternalData));
foreach (NetConnection A in myMap.GetPlayerIPs())
{
PlayerMapConnectionPacket myNewPlayer = new PlayerMapConnectionPacket();
myNewPlayer.SetNewPlayerData(((PlayerData)myValue.MyExternalData));
myNewPlayer.Sender = A;
myServer.Send(myNewPlayer, NetDeliveryMethod.ReliableOrdered);
}
}
}, typeof(CharacterCreationPacket));
}
private static async Task LoginStart(Client client, byte[] data)
{
String username = Utils.ReadString(new MemoryStream(data), 16);
Console.WriteLine("Client attempting to authenticate as " + username);
Guid guid = new Guid();
LoginSuccessPacket loginSuccessPacket = new LoginSuccessPacket(client, guid, username);
await loginSuccessPacket.SendToClient();
client.State = ClientState.Play;
client.Player = new Player(client, username, guid);
JoinGamePacket joinGamePacket = new JoinGamePacket(client, client.Player.EntityId, (byte)client.Player.Gamemode, 0, 0x0000000000000000);
await joinGamePacket.SendToClient();
Console.WriteLine("Client authenticated as " + username);
HeldItemChangePacket heldItemChangePacket = new HeldItemChangePacket(client, 0);
await heldItemChangePacket.SendToClient();
client.Player.Y = 68;
PlayerPositionLookPacket playerPositionLookPacket = new PlayerPositionLookPacket(client, client.Player);
await playerPositionLookPacket.SendToClient();
PlayerInfoPacket playerInfoPacket = new PlayerInfoPacket(client, PlayerInfoAction.AddPlayer);
playerInfoPacket.AddPlayer(client.Player);
await playerInfoPacket.SendToClient();
playerInfoPacket = new PlayerInfoPacket(client, PlayerInfoAction.UpdateLatency);
playerInfoPacket.AddPlayer(client.Player);
await playerInfoPacket.SendToClient();
Region region = new Region(0, 0);
ChunkColumn column = new ChunkColumn(0, 0);
column.FillTest();
ChunkDataPacket chunkDataPacket = new ChunkDataPacket(client, column);
await chunkDataPacket.SendToClient();
column = new ChunkColumn(1, 0);
column.FillTest();
chunkDataPacket = new ChunkDataPacket(client, column);
await chunkDataPacket.SendToClient();
column = new ChunkColumn(1, 1);
column.FillTest();
chunkDataPacket = new ChunkDataPacket(client, column);
await chunkDataPacket.SendToClient();
column = new ChunkColumn(0, 1);
column.FillTest();
chunkDataPacket = new ChunkDataPacket(client, column);
await chunkDataPacket.SendToClient();
column = new ChunkColumn(-1, 1);
column.FillTest();
chunkDataPacket = new ChunkDataPacket(client, column);
await chunkDataPacket.SendToClient();
column = new ChunkColumn(-1, -1);
column.FillTest();
chunkDataPacket = new ChunkDataPacket(client, column);
await chunkDataPacket.SendToClient();
column = new ChunkColumn(1, -1);
column.FillTest();
chunkDataPacket = new ChunkDataPacket(client, column);
await chunkDataPacket.SendToClient();
column = new ChunkColumn(0, -1);
column.FillTest();
chunkDataPacket = new ChunkDataPacket(client, column);
await chunkDataPacket.SendToClient();
column = new ChunkColumn(-1, -0);
column.FillTest();
chunkDataPacket = new ChunkDataPacket(client, column);
await chunkDataPacket.SendToClient();
Console.WriteLine("Sent");
}
public void CmdTakeDamageOnServer(int amount, PlayerInfoPacket fromPlayerInfo, bool forceDmg)
{
TakeDamageOnServer(amount, fromPlayerInfo, forceDmg);
}
public void SetOwner(PlayerInfoPacket infoPacket)
{
playerPacket = infoPacket;
}
public void HandleLogin(Packet aPacket)
{
LoginPacket myPacket = (LoginPacket)aPacket;
Console.WriteLine(myPacket.Username + " attempted to connect!");
if (myWrapper.VerifyUser(myPacket.Username, myPacket.GetCreationTime(), myPacket.GetSHA()))
{
if (File.Exists("./Users/" + myPacket.Username + ".chr"))
{
BinaryFormatter myConverter = new BinaryFormatter();
var Stream = File.Open("./Users/" + myPacket.Username + ".chr", FileMode.Open);//TODO: handle this for threads
PlayerData myData = (PlayerData)myConverter.Deserialize(Stream);
ThreadPool.QueueUserWorkItem(delegate(object State)
{
PlayerInfoPacket myNewPlayerPacket = new PlayerInfoPacket();
myNewPlayerPacket.SetPlayerData(myData);
myNewPlayerPacket.NewChar = false;
String myID = Guid.NewGuid().ToString();
while (myActiveConnectionsByPublicUserID.ContainsKey(myID))
{
myID = Guid.NewGuid().ToString();
}
myActiveConnectionsByUsername.TryAdd(myPacket.Username, myPacket.Sender);
myActiveConnectionsByUserID.TryAdd(myPacket.UserID, myPacket.Sender);
myActiveConnectionsByPublicUserID.TryAdd(myID, myPacket.Sender);
myData.PublicUserID = myID;
SendMapServer(myNewPlayerPacket, NetDeliveryMethod.ReliableOrdered);
Send(myNewPlayerPacket, myNewPlayerPacket.Sender, NetDeliveryMethod.ReliableOrdered);
});
}
else
{
ThreadPool.QueueUserWorkItem(delegate(object State)
{
if (!myActiveConnectionsByUserID.ContainsKey(myPacket.UserID))
{
PlayerInfoPacket myNewPlayerPacket = new PlayerInfoPacket();
myNewPlayerPacket.Sender = myPacket.Sender;
PlayerData myData = new PlayerData();
myNewPlayerPacket.NewChar = true;
myNewPlayerPacket.SetPlayerData(myData);
String myID = Guid.NewGuid().ToString();
while (myActiveConnectionsByPublicUserID.ContainsKey(myID))
{
myID = Guid.NewGuid().ToString();
}
myActiveConnectionsByUsername.TryAdd(myPacket.Username, myPacket.Sender);
myActiveConnectionsByUserID.TryAdd(myPacket.UserID, myPacket.Sender);
myActiveConnectionsByPublicUserID.TryAdd(myID, myPacket.Sender);
myData.PublicUserID = myID;
SendMapServer(myNewPlayerPacket, NetDeliveryMethod.ReliableOrdered);
Send(myNewPlayerPacket, myNewPlayerPacket.Sender, NetDeliveryMethod.ReliableOrdered);
}
});
}
Console.WriteLine("User Authenticated Successfully!");
}
else
{
LoginFailedPacket myAck = new LoginFailedPacket();
myAck.Sender = myPacket.Sender;
Send(myAck, myPacket.Sender, NetDeliveryMethod.ReliableOrdered);
Console.WriteLine("User Authentication Failed!");
}
}
void Start()
{
playerInfo = gameObject.GetComponent<BasePlayerInfo>();
playerHealth = gameObject.GetComponent<PlayerHealth>();
playerCamera = gameObject.GetComponent<PlayerCamera>();
splashCollider = Resources.Load<GameObject>("Prefabs/Physics/SplashDamageCollider");
rapidFireCooldown = Settings.RapidFireCooldownSpeed;
playerCameraTransform = gameObject.GetComponentInChildren<Camera>().transform;
if(isLocalPlayer) {
playerGravityBody = gameObject.GetComponent<PlayerGravityBody>();
playerHUD = gameObject.GetComponent<PlayerHUD> ();
}
localPlayerInfoPacket = new PlayerInfoPacket(playerInfo.playerName, playerInfo.playerTeam, netId);
}
private void CmdRaycastHit(GameObject player, PlayerInfoPacket playerInfoPacket)
{
player.GetComponent<PlayerHealth>().TakeDamageOnServer(20, playerInfoPacket);
}
private void SendPlayerInfo(IMinecraftUser user, PlayerInfoActionType actionType)
{
using var packet = new PlayerInfoPacket(actionType, _server.ConnectedPlayers.Select(x => x.Player));
user.Send(packet);
}
private void RpcRemovePlayer(PlayerInfoPacket playerToRemove)
{
gameObject.DispatchGlobalEvent(NetworkEvent.PlayerDisconnected, new object[]{playerToRemove});
}
private void RpcUdateScore(PlayerInfoPacket updatedPlayerDetails)
{
gameObject.DispatchGlobalEvent(NetworkEvent.UpdatePlayerInfo, new object[]{updatedPlayerDetails});
}
private void RpcUpdatePlayerHeath(PlayerInfoPacket fromPlayerInfo, int newHealthValue)
{
playerHUD.ShowDamageIndicator();
if(isLocalPlayer) AudioKeys.TakeDamage.PlaySound();
playerCamera.ShakeCamera();
lastPlayerToDamage = fromPlayerInfo;
currentHealth = newHealthValue;
UpdateHealthText ();
}
private void RpcUpdatePlayers(PlayerInfoPacket[] playerInfoArray)
{
gameObject.DispatchGlobalEvent(NetworkEvent.NewPlayerConnected, new object[]{playerInfoArray});
}
