public void DisconnectClient(Identity ident, bool sendKicked = true)
{
PlayerQuitEvent @event = new PlayerQuitEvent(ident.Owner.Player);
var user = ident.GetUser();
@event.QuitMessage = "<b>" + user.Name + "</b> disconnected.";
byte index = GetUserIndex(ident);
RemovePlayer(index);
byte[] packet = ObjectSerializer.GetBytes(0, index);
AnnounceToAll(EPacket.DISCONNECTED, packet, 0);
if (sendKicked)
{
Send(ident, EPacket.KICKED, new byte[0], 0);
}
((ServerMultiplayerProvider)Provider).RemoveClient(ident);
EventManager.Instance.CallEvent(@event);
if (string.IsNullOrEmpty(@event.QuitMessage))
{
return;
}
Chat.Instance.SendServerMessage(@event.QuitMessage);
}
public void ConnectToServer()
{
LogUtils.Debug("<b>Connecting to local server</b>");
ulong group = 1;
object[] args = { ClientName, group, GameInfo.VERSION, 0f };
byte[] packet = ObjectSerializer.GetBytes(0, args);
Send(ServerID, EPacket.CONNECT, packet, 0);
}
protected override void OnChannelCountUpdate()
{
object[] objects = { ChannelCount };
byte[] data = ObjectSerializer.GetBytes(0, objects);
foreach (User u in Clients.Where(u => u.Identity != ServerID))
{
Send(u.Identity, EPacket.UPDATE_CHANNELS, data, 0);
}
}
public byte[] Serialize()
{
if (Value == null)
{
return(new byte[0]);
}
var data = ObjectSerializer.GetBytes(0, Value);
return(data);
}
protected override void OnLevelWasLoaded(int level)
{
base.OnLevelWasLoaded(level);
//skip first OnLevelWasLoaded since its the loading scene
if (_levelLoadedCalled)
{
return;
}
_levelLoadedCalled = true;
ulong group = 1; //Todo
object[] args = { ClientName, group, GameInfo.VERSION, CurrentServerInfo.Ping / 1000f };
byte[] packet = ObjectSerializer.GetBytes(0, args);
Send(ServerID, EPacket.CONNECT, packet, packet.Length, 0);
}
public static void Dropped(GameObject gameObject, TechType tech, Vector3 position)
{
var res = new ClientItemDropped();
res.itemGuid = GuidHelper.Get(gameObject);
res.waterParkGuid = GuidHelper.Get(Player.main?.currentWaterPark?.gameObject);
res.tech = tech;
res.position = position;
res.data = ObjectSerializer.GetBytes(gameObject);
if (res.data == null)
{
return;
}
Multiplayer.main.Send(res);
SyncedObject.ApplyTo(gameObject);
}
public static void Equip(Pickupable pickupable, GameObject owner, string slot)
{
if (Multiplayer.main.blocked)
{
return;
}
var res = new ClientEquipmentAddItem();
res.ownerGuid = GuidHelper.Get(owner);
res.itemGuid = GuidHelper.Get(pickupable.gameObject);
res.slot = slot;
res.position = owner.transform.position;
res.data = ObjectSerializer.GetBytes(pickupable.gameObject, true);
if (res.data == null)
{
return;
}
Multiplayer.main.Send(res);
}
public static void AddItem(Pickupable pickupable, GameObject owner)
{
if (Multiplayer.main.blocked)
{
return;
}
var res = new ClientContainerAddItem();
res.ownerGuid = GuidHelper.Get(owner);
res.itemGuid = GuidHelper.Get(pickupable.gameObject);
res.tech = pickupable.GetTechType();
res.position = owner.transform.position;
GuidHelper.GetChildGuids(pickupable.gameObject);
res.data = ObjectSerializer.GetBytes(pickupable.gameObject, true);
if (res.data == null)
{
return;
}
Multiplayer.main.Send(res);
}
internal override void Receive(Identity id, byte[] packet, int size, int channel)
{
base.Receive(id, packet, size, channel);
EPacket parsedPacket = (EPacket)packet[0];
StripPacketByte(ref packet, ref size);
if (parsedPacket.IsUpdate())
{
foreach (Channel ch in Receivers.Where(ch => ch.ID == channel))
{
ch.Receive(id, packet, 0, size);
}
return;
}
if (id != ServerID)
{
return;
}
switch (parsedPacket)
{
case EPacket.WORKSHOP:
//todo
break;
case EPacket.TICK:
{
var data = ObjectSerializer.GetBytes(0, Time.realtimeSinceStartup);
Send(ServerID, EPacket.TIME, data, 0);
break;
}
case EPacket.TIME:
{
object[] args = ObjectSerializer.GetObjects(0, 0, packet, typeof(float));
LastNet = Time.realtimeSinceStartup;
OffsetNet = ((float)args[0]) + ((Time.realtimeSinceStartup - LastPing) / 2f);
Lag(Time.realtimeSinceStartup - LastPing);
break;
}
case EPacket.SHUTDOWN:
Disconnect();
break;
case EPacket.CONNECTED:
{
{
Type[] argTypes =
{
//[0] id, [1] name, [2] group, [3] position, [4], angle, [5] channel
typeof(Identity), typeof(string), typeof(ulong), typeof(Vector3), typeof(Vector3),
typeof(int), typeof(bool)
};
object[] args = ObjectSerializer.GetObjects(0, 0, packet, argTypes);
if (IsSinglePlayer)
{
return;
}
if (World.Loaded)
{
AddPlayer(Provider.Deserialilze((Identity)args[0]), (string)args[1], (ulong)args[2],
(Vector3)args[3], (Vector3)args[4], (int)args[5], (bool)args[6]);
}
else
{
QueuePlayer(Provider.Deserialilze((Identity)args[0]), (string)args[1], (ulong)args[2],
(Vector3)args[3], (Vector3)args[4], (int)args[5], (bool)args[6]);
}
break;
}
}
case EPacket.VERIFY:
LogUtils.Debug("Opening ticket");
byte[] ticket = ((ClientMultiplayerProvider)Provider).OpenTicket();
if (ticket == null)
{
LogUtils.Debug("ticket equals null");
Disconnect();
break;
}
Send(ServerID, EPacket.AUTHENTICATE, ticket, ticket.Length, 0);
break;
case EPacket.DISCONNECTED:
{
//If singleplayer (local server) we will already do this at ServerConnection
if (IsSinglePlayer)
{
return;
}
object[] args = ObjectSerializer.GetObjects(0, 0, packet, typeof(byte));
var index = (byte)args[0];
var user = GetUser(index);
PlayerQuitEvent @event = new PlayerQuitEvent(user.Player);
EventManager.Instance.CallEvent(@event);
RemovePlayer(index);
break;
}
case EPacket.REJECTED:
case EPacket.KICKED:
Disconnect();
break;
case EPacket.ACCEPTED:
{
object[] args = ObjectSerializer.GetObjects(0, 0, packet, typeof(ulong), typeof(int));
LogUtils.Debug("Setting MainPlayer channel to: " + (int)args[1]);
((ClientMultiplayerProvider)Provider).SetIdentity((ulong)args[0]);
((ClientMultiplayerProvider)Provider).AdvertiseGame(ServerID, _currentIp, _currentPort);
((ClientMultiplayerProvider)Provider).SetConnectInfo(_currentIp, _currentPort);
IsFavoritedServer = ((ClientMultiplayerProvider)Provider).IsFavoritedServer(_currentIp, _currentPort);
((ClientMultiplayerProvider)Provider).FavoriteServer(_currentIp, _currentPort);
break;
}
case EPacket.UPDATE_CHANNELS:
{
object[] args = ObjectSerializer.GetObjects(0, 0, packet, ChannelCount.GetType());
ChannelCount = (int)args[0];
break;
}
default:
LogUtils.LogWarning("Couldn't handle packet: " + parsedPacket);
break;
}
}
internal override void Receive(Identity source, byte[] packet, int size, int channel)
{
base.Receive(source, packet, size, channel);
var net = ((OffsetNet + Time.realtimeSinceStartup) - LastNet);
EPacket parsedPacket = (EPacket)packet[0];
StripPacketByte(ref packet, ref size);
if (parsedPacket.IsUpdate())
{
if (source == ServerID)
{
foreach (Channel ch in Receivers)
{
ch.Receive(source, packet, 0, size);
}
}
else
{
if (Clients.All(client => client.Identity != source))
{
return;
}
foreach (Channel ch in Receivers.Where(ch => ch.ID == channel))
{
ch.Receive(source, packet, 0, size);
}
}
return;
}
PendingUser currentPending;
switch (parsedPacket)
{
case EPacket.WORKSHOP:
{
//workshop list {none for now}
List <ulong> workshoplist = new List <ulong>();
byte[] args = new byte[1 + (workshoplist.Count * 8)];
args[0] = (byte)workshoplist.Count;
for (byte i = 0; i < workshoplist.Count; i = (byte)(i + 1))
{
BitConverter.GetBytes(workshoplist[i]).CopyTo(args, (1 + (i * 8)));
}
Send(source, EPacket.WORKSHOP, args, args.Length, 0);
return;
}
case EPacket.TICK:
{
object[] objects = { net };
byte[] buffer2 = ObjectSerializer.GetBytes(0, objects);
Send(source, EPacket.TIME, buffer2, 0);
return;
}
case EPacket.TIME:
foreach (User c in Clients.Where(c => c.Identity == source))
{
if (!(c.LastPing > 0f))
{
return;
}
c.LastNet = Time.realtimeSinceStartup;
c.Lag(Time.realtimeSinceStartup - c.LastPing);
c.LastPing = -1f;
return;
}
return;
case EPacket.CONNECT:
{
if (_pendingPlayers.Any(p => p.Identity == source))
{
Reject(source, ERejectionReason.ALREADY_PENDING);
return;
}
if (Clients.Any(c => c.Identity == source))
{
Reject(source, ERejectionReason.ALREADY_CONNECTED);
return;
}
Type[] argTypes =
{
// [0] name, [1] group, [2] version, [3] ping
typeof(string), typeof(ulong), typeof(string), typeof(float)
};
var args = ObjectSerializer.GetObjects(0, 0, packet, argTypes);
var playerName = (string)args[0];
var group = (ulong)args[1];
var version = (string)args[2];
var ping = (float)args[3];
LogUtils.Log("Player connecting: " + playerName);
if (version != GameInfo.VERSION)
{
Reject(source, ERejectionReason.WRONG_VERSION);
return;
}
if ((Clients.Count + 1) > MultiplayerProvider.MultiplayerProvider.MAX_PLAYERS)
{
Reject(source, ERejectionReason.SERVER_FULL);
return;
}
var pendingPlayer = new PendingUser(source, playerName, group, ping);
_pendingPlayers.Add(pendingPlayer);
if (Provider.SupportsAuthentification)
{
Send(source, EPacket.VERIFY, new byte[] { }, 0, 0);
return;
}
pendingPlayer.HasAuthentication = true;
Accept(pendingPlayer);
return;
}
default:
if (parsedPacket != EPacket.AUTHENTICATE)
{
LogUtils.LogError("Failed to handle message: " + parsedPacket);
return;
}
currentPending = _pendingPlayers.FirstOrDefault(p => p.Identity == source);
break;
}
if (currentPending == null)
{
Reject(source, ERejectionReason.NOT_PENDING);
}
else if ((Clients.Count + 1) > MultiplayerProvider.MultiplayerProvider.MAX_PLAYERS)
{
Reject(source, ERejectionReason.SERVER_FULL);
}
else
{
object[] args = ObjectSerializer.GetObjects(0, 0, packet, typeof(byte[]));
if (!((ServerMultiplayerProvider)Provider).VerifyTicket(source, (byte[])args[0]))
{
Reject(source, ERejectionReason.AUTH_VERIFICATION);
}
}
}
public void LoadQueuedPlayers(Chat chat)
{
foreach (PendingUser user in _queuedUsers)
{
Identity ident = user.Identity;
Vector3? spawn = World.Instance.DefaultSpawnPosition?.position ?? Vector3.zero;
LogUtils.Debug("Adding player");
var angle = new Vector3(0, 90, 0);
int chCount = ChannelCount;
Transform player = AddPlayer(ident, user.Name, user.Group, spawn.Value, angle, chCount,
user.Identity == ServerID);
var container = player.GetChild(0);
var ch = container.GetComponent <Channel>();
ch.Owner = user.Identity;
container.BroadcastMessage("OnPlayerLoaded");
if (!IsDedicated && user.Identity == ServerID)
{
ClientConnection.SetupMainPlayer(player);
}
object[] data;
byte[] packet;
//Send all connected players to the accepted player
//[0] id, [1] name, [2] group, [3] position, [4], angle, [5] channel, [6] isSelf
LogUtils.Debug("Sending connected to all clients");
foreach (var c in Clients.ToList().Where(c => c.Identity != ident))
{
data = new object[]
{
user.Identity.Serialize(), user.Name, user.Group, spawn,
angle, chCount, false
};
packet = ObjectSerializer.GetBytes(0, data);
Send(c.Identity, EPacket.CONNECTED, packet, 0);
}
LogUtils.Debug("Sending connected player data to client");
foreach (var c in Clients.ToList().Where(c => c.Identity != ident))
{
data = new object[]
{
c.Identity.Serialize(), c.Name, c.Group, c.Model.transform.position,
c.Model.transform.rotation.eulerAngles, c.Player.GetComponent <Channel>().ID, false
};
packet = ObjectSerializer.GetBytes(0, data);
Send(user.Identity, EPacket.CONNECTED, packet, 0);
}
LogUtils.Debug("Sending accepted data to client");
data = new object[]
{ ident.Serialize(), user.Name, user.Group, spawn.Value, angle, chCount, true };
packet = ObjectSerializer.GetBytes(0, data);
Send(user.Identity, EPacket.CONNECTED, packet, 0);
data = new object[] { ident.Serialize(), chCount };
packet = ObjectSerializer.GetBytes(0, data);
Send(user.Identity, EPacket.ACCEPTED, packet, 0);
WeatherManager.Instance.SendWeatherTimeUpdate(ident);
NetvarManager.Instance.SendAllNetvars(ident);
PlayerJoinEvent @event = new PlayerJoinEvent(ident.GetUser().Player);
@event.JoinMessage = "<b>" + user.Name + "</b> connected.";
EventManager.Instance.CallEvent(@event);
if (string.IsNullOrEmpty(@event.JoinMessage))
{
return;
}
chat?.SendServerMessage(@event.JoinMessage);
}
_queuedUsers.Clear();
}
private void GetPacket(EPacket type, int index, out byte[] packet, params object[] arguments)
{
packet = ObjectSerializer.GetBytes(2, arguments);
packet[0] = (byte)type;
packet[1] = (byte)index;
}
