private async void SynchronizeWithPlayer(IPlayer player)
{
var cp1 = PacketUtility.TakePacket <CustomPacket>();
cp1.Label = _clearTempPacketLabel;
cp1.Sc = SendCategory.FileTransfer;
Game.Network.SendPacket(player.ClientIndex, cp1);
foreach (var file in _filesToSync)
{
if (file.FullPath.IsSubPathOf(Structure.PluginsPath))
{
var result = await Game.FileTransfer.UploadFileAsync(player, file, true);
if (result != FileTransfer.TransferStatus.Success)
{
UnityEngine.Debug.LogError("Failed to transfer plugin file: " + file.RelativePath);
}
}
}
var cp = PacketUtility.TakePacket <CustomPacket>();
cp.Label = _loadTemplPacketLabel;
cp.Sc = SendCategory.FileTransfer;
Game.Network.SendPacket(player.ClientIndex, cp);
}
protected override void OnPlayerIntroduced(IPlayer player)
{
if (!Game.IsHost)
{
return;
}
var replStr = string.Empty;
var vars = DevConsole.GetVariablesWithFlags(ConVarFlags.Replicator);
foreach (var var in vars)
{
var str = var + " " + DevConsole.GetVariableAsString(var);
if (replStr == string.Empty)
{
replStr = str;
}
else
{
replStr += "&" + str;
}
}
var cp = PacketUtility.TakePacket <CustomPacket>();
cp.Sc = SendCategory.UI_Important;
cp.AddString(replStr);
cp.Label = "Replicate";
Game.Network.SendPacket(player.ClientIndex, cp);
}
protected override void _Update()
{
if (Game.IsHost || !SteamUser.VoiceRecord)
{
return;
}
_readTime -= UnityEngine.Time.deltaTime;
if (_readTime > 0)
{
return;
}
_readTime = _audioReadTime;
var data = SteamUser.ReadVoiceDataBytes();
if (data != null && data.Length > 0)
{
var voicePacket = PacketUtility.TakePacket <CompressedVoiceData>();
voicePacket.ClientIndex = Game.ClientIndex;
voicePacket.SetData(data, data.Length);
Client.GameClient.Instance.Socket.BroadcastPacket(voicePacket);
}
}
private void SendChunk(IPlayer player, UploadState state)
{
long remaining = state.InputStream.Length - state.SentOffset;
int sendBytes = (remaining > state.ChunkLength ? state.ChunkLength : (int)remaining);
var chunk = PacketUtility.TakePacket <FileChunk>();
chunk.Data = new byte[sendBytes];
chunk.ChunkLength = sendBytes;
chunk.File = state.File.RelativePath;
chunk.TotalLength = state.InputStream.Length;
chunk.Temporary = state.IsTemporaryFile;
state.InputStream.Read(chunk.Data, 0, sendBytes);
Game.Network.SendPacket(player.ClientIndex, chunk);
state.SentOffset += sendBytes;
if (remaining - sendBytes <= 0)
{
state.InputStream.Close();
state.InputStream.Dispose();
state.Status = TransferStatus.Success;
}
}
public void SendPlayerBackfill(IPlayer player)
{
foreach (var playerToSend in Game.PlayerManager.Players)
{
if (playerToSend.ClientIndex != player.ClientIndex)
{
var ev = PacketUtility.TakePacket <PlayerEvent>();
ev.Sc = SendCategory.UI_Important;
ev.EventType = PlayerEventType.Backfill;
ev.ClientIndex = playerToSend.ClientIndex;
ev.DisplayName = playerToSend.DisplayName;
ev.TeamNumber = playerToSend.Team;
ev.Latency = playerToSend.Latency;
ev.SteamID = playerToSend.SteamId;
Game.GetFSComponent <SocketManager>().SendPacketBrute(player.ClientIndex, ev);
}
}
foreach (var ent in Game.EntityManager.Entities)
{
if (ent.IsValid())
{
var updatePacket = PacketUtility.TakePacket <EntityUpdate>();
updatePacket.Sc = SendCategory.UI_Important;
updatePacket.Load(ent);
Game.GetFSComponent <SocketManager>().SendPacketBrute(player.ClientIndex, updatePacket);
}
}
}
protected override void OnPlayerPacketReceived(IPlayer player, IBasePacket packet)
{
if (packet is ChatMessage chatMessage)
{
if (chatMessage.Message.Length < 1)
{
return;
}
if (Game.IsHost)
{
if (chatMessage.Message.Length > MaxMessageLength)
{
chatMessage.Message = chatMessage.Message.Substring(0, MaxMessageLength);
}
if (chatMessage.Message[0] == CommandChar)
{
ParseCommand(player, chatMessage.Message);
}
else
{
var msgToSend = PacketUtility.TakePacket <ChatMessage>();
msgToSend.ClientIndex = player.ClientIndex;
msgToSend.Name = player.DisplayName;
msgToSend.Message = chatMessage.Message;
msgToSend.Scope = chatMessage.Scope;
msgToSend.SupporterLevel = chatMessage.SupporterLevel;
Game.Network.BroadcastPacket(msgToSend);
}
}
OnMessageReceived?.Invoke(chatMessage, chatMessage.Name, chatMessage.Message, chatMessage.ClientIndex == -1);
}
}
protected override void OnPlayerDisconnected(IPlayer player)
{
var ev = PacketUtility.TakePacket <PlayerEvent>();
ev.EventType = PlayerEventType.Disconnected;
ev.ClientIndex = player.ClientIndex;
Game.GetFSComponent <SocketManager>().BroadcastPacket(ev);
}
protected override void OnPlayerChangedName(IPlayer player)
{
var ev = PacketUtility.TakePacket <PlayerEvent>();
ev.EventType = PlayerEventType.ChangedName;
ev.ClientIndex = player.ClientIndex;
ev.DisplayName = player.DisplayName;
Game.GetFSComponent <SocketManager>().BroadcastPacket(ev);
}
protected override void OnPlayerSpectate(IPlayer spectator, IPlayer target)
{
var ev = PacketUtility.TakePacket <PlayerEvent>();
ev.EventType = PlayerEventType.Spectate;
ev.ClientIndex = spectator.ClientIndex;
ev.SpecTarget = target == null ? -1 : target.ClientIndex;
Game.GetFSComponent <SocketManager>().BroadcastPacket(ev);
}
private void SendMapChange(ServerPlayer player)
{
var mapChange = PacketUtility.TakePacket <MapChange>();
mapChange.MapName = MapLoader.Instance.CurrentMap.Name;
mapChange.Gamemode = Game.GamemodeLoader.Gamemode.Name;
mapChange.ClientIndex = player.ClientIndex;
Game.GetFSComponent <SocketManager>().SendPacketBrute(player, mapChange);
}
private void SendFileSync(ServerPlayer player)
{
var fileSync = PacketUtility.TakePacket <FileSync>();
fileSync.SyncType = FileSync.FileSyncType.Manifest;
fileSync.DownloadUrl = DevConsole.GetVariable <string>("net.downloadurl") ?? string.Empty;
fileSync.Files = new System.Collections.Generic.List <FSFileInfo>(FileSystem.DownloadList);
Game.GetFSComponent <SocketManager>().SendPacketBrute(player, fileSync);
}
protected override void OnPlayerLatencyUpdated(IPlayer player)
{
var ev = PacketUtility.TakePacket <PlayerEvent>();
ev.Sc = SendCategory.Unreliable;
ev.EventType = PlayerEventType.LatencyUpdated;
ev.ClientIndex = player.ClientIndex;
ev.Latency = player.Latency;
Game.GetFSComponent <SocketManager>().BroadcastPacket(ev);
}
private ChatMessage GetChatPacket(string message)
{
var packet = PacketUtility.TakePacket <ChatMessage>();
packet.ClientIndex = Game.ClientIndex;
packet.Message = message;
packet.Name = Game.IsHost ? ServerName : Steamworks.SteamClient.Name;
packet.SupporterLevel = 0;
return(packet);
}
public void HandleIncomingData(NetBuffer buffer)
{
var packetType = buffer.ReadByte();
var packet = PacketUtility.TakePacket(packetType);
ProcessPacket(buffer, packetType, packet);
if (packet != null && !PacketIsWaiting(packet))
{
PacketUtility.PutPacket(packet);
}
}
private void BroadcastPlayerIntroduced(IPlayer player)
{
var ev = PacketUtility.TakePacket <PlayerEvent>();
ev.EventType = PlayerEventType.Introduced;
ev.ClientIndex = player.ClientIndex;
ev.DisplayName = player.DisplayName;
ev.TeamNumber = player.Team;
ev.Latency = player.Latency;
ev.SteamID = player.SteamId;
Game.GetFSComponent <SocketManager>().BroadcastPacket(ev);
}
public void EmitToPlayer(IPlayer player, string eventPath, Vector3 position = default)
{
if (!Game.IsHost)
{
return;
}
var sound = PacketUtility.TakePacket <PlaySound>();
sound.Event = eventPath;
sound.Position = position;
sound.Twod = position == Vector3.zero;
Game.Network.SendPacket(player.ClientIndex, sound);
}
public void EmitToAll(string eventPath, Vector3 position = default)
{
if (!Game.IsHost)
{
return;
}
var sound = PacketUtility.TakePacket <PlaySound>();
sound.Event = eventPath;
sound.Position = position;
sound.Twod = position == Vector3.zero;
Game.Network.BroadcastPacket(sound);
}
private void SendCommand(string name, params object[] args)
{
var packet = PacketUtility.TakePacket <EntityCommand>();
packet.CommandName = name;
packet.EntityId = EntityId;
packet.ArgsJson = JsonConvert.SerializeObject(args, new JsonSerializerSettings()
{
ReferenceLoopHandling = ReferenceLoopHandling.Ignore
});
Game.Network.BroadcastPacket(packet);
}
protected unsafe override void OnPlayerPacketReceived(IPlayer player, IBasePacket packet)
{
if (!(packet is CompressedVoiceData voicePacket))
{
return;
}
if (Game.IsHost)
{
var packetToSend = PacketUtility.TakePacket <CompressedVoiceData>();
packetToSend.SetData(voicePacket.Data, voicePacket.DataLength);
packetToSend.ClientIndex = player.ClientIndex;
Server.GameServer.Instance.Socket.BroadcastPacket(packetToSend);
}
else
{
var vol = DevConsole.GetVariable <float>("audio.voiceoutput");
if (vol == 0)
{
return;
}
var clientIndex = voicePacket.ClientIndex;
if (clientIndex == Game.ClientIndex && !_loopback)
{
return;
}
int uncompressedDataLength = 0;
var speakingPlayer = Game.PlayerManager.FindPlayer(clientIndex);
fixed(byte *src = voicePacket.Data)
{
fixed(byte *dst = _data)
{
uncompressedDataLength = SteamUser.DecompressVoice((IntPtr)src, voicePacket.DataLength, (IntPtr)dst, _data.Length);
}
}
if (uncompressedDataLength == 0 || speakingPlayer == null)
{
return;
}
throw new System.NotImplementedException();
// _data to audio..
//UnityEngine.Debug.Log($"size: {data.Length} - group: {getChannelGroupResult} - create: {createSoundResult} - play: {playSoundResult}");
}
}
private void HandleRunCommand(IPlayer player, UserCmd cmd, bool isPrediction = false)
{
if (!(player.Entity is Human human))
{
return;
}
human.RunCommand(cmd, isPrediction);
if (Game.IsHost || isPrediction)
{
Game.PlayerManager.RaiseRunCommand(player);
}
if (Game.IsHost && !isPrediction)
{
UserCmd newCmd;
if (_finalCmds.ContainsKey(player))
{
newCmd = _finalCmds[player];
}
else
{
newCmd = PacketUtility.TakePacket <UserCmd>();
_finalCmds[player] = newCmd;
}
newCmd.Copy(cmd);
newCmd.ClientIndex = player.ClientIndex;
newCmd.Origin = human.Origin;
newCmd.Velocity = human.Velocity;
newCmd.BaseVelocity = human.BaseVelocity;
// usercmd is ReliableSequenced by default so clients don't lose inputs
// but we don't want the host to clog up with this shit so switch to to UnreliableSequenced just to send it back to the client
newCmd.Sc = SendCategory.Gameplay;
// broadcast
//ServerLoop.Instance.BetterGameServer.BroadcastPacketEnqueue(newCmd);
}
else if (!Game.IsHost && isPrediction)
{
cmd.Origin = human.Origin;
cmd.Velocity = human.Velocity;
cmd.BaseVelocity = human.BaseVelocity;
var cmdToSend = PacketUtility.TakePacket <UserCmd>();
cmdToSend.Copy(cmd);
Game.Network.BroadcastPacket(cmdToSend);
}
}
private void FSConsole_OnVariableChanged(string varName)
{
if (!Game.IsHost ||
!DevConsole.VariableHasFlags(varName, ConVarFlags.Replicator))
{
return;
}
var replStr = varName + " " + DevConsole.GetVariableAsString(varName);
var cp = PacketUtility.TakePacket <CustomPacket>();
cp.Sc = SendCategory.UI_Important;
cp.AddString(replStr);
cp.Label = "Replicate";
Game.Network.BroadcastPacket(cp);
}
private bool SendChunk(FileUpload fu)
{
//if (!fu.Connection.CanSendImmediately(SendCategory.UI_Important.DeliveryMethod, SendCategory.UI_Important.SequenceChannel))
//{
// return false;
//}
// send another part of the file!
long remaining = fu.InputStream.Length - fu.SentOffset;
int sendBytes = (remaining > fu.ChunkLength ? fu.ChunkLength : (int)remaining);
var chunk = PacketUtility.TakePacket <FileChunk>();
chunk.Data = new byte[sendBytes];
chunk.ChunkLength = sendBytes;
chunk.File = fu.File;
chunk.TotalLength = fu.InputStream.Length;
// just assume we can read the whole thing in one Read()
fu.InputStream.Read(chunk.Data, 0, sendBytes);
// send it
GameServer.Instance.Socket.SendPacketBrute(fu.ClientIndex, chunk);
fu.SentOffset += sendBytes;
if (remaining - sendBytes <= 0)
{
fu.InputStream.Close();
fu.InputStream.Dispose();
fu.InputStream = null;
return(true);
}
return(false);
}
private async Task <GameLoadResult> _JoinGameAsync(string address, int port = 0, string password = null)
{
if (Game.IsHost)
{
return(GameLoadResult.None);
}
// 1. Connect
LoadingHint = "Connecting to host";
if (_cancelled)
{
return(GameLoadResult.Cancelled);
}
var connectionResult = await(Game.Network as ClientSocketManager).ConnectAsync(address, port, password);
if (connectionResult != ClientSocketStatus.Connected)
{
return(GameLoadResult.FailedToConnect);
}
// 2. Sync files
//LoadingHint = "Synchronizing files";
//if (_cancelled) { return GameLoadResult.Cancelled; }
//_cts?.Dispose();
//_cts = new CancellationTokenSource();
//var syncResult = await Game.GetFSComponent<FileDownloader>().SyncWithHostAsync(_cts);
//_cts?.Dispose();
//if (syncResult != FileDownloader.SyncState.Completed)
//{
// return GameLoadResult.FailedToSync;
//}
// 3. Request ClientIndex and what map, gamemode to load
LoadingHint = "Requesting game info";
if (_cancelled)
{
return(GameLoadResult.Cancelled);
}
Game.Network.BroadcastPacket(PacketUtility.TakePacket <MapChange>());
var mapChange = await(Game.Network as ClientSocketManager).WaitForPacketAsync <MapChange>(5000);
if (mapChange == null)
{
return(GameLoadResult.MissingMapChange);
}
Game.ClientIndex = mapChange.ClientIndex;
State = GameLoaderState.ChangingMap;
// 5. Load the map
LoadingHint = "Loading the map: " + mapChange.MapName;
if (_cancelled)
{
return(GameLoadResult.Cancelled);
}
// with a local server the map should already be loaded, so let's check first
if (MapLoader.Instance.CurrentMap == null || MapLoader.Instance.CurrentMap.Name != mapChange.MapName)
{
var mapLoadResult = await MapLoader.Instance.LoadMapAsync2(mapChange.MapName);
if (mapLoadResult != MapLoadState.Loaded)
{
return(GameLoadResult.FailedToLoadMap);
}
}
PreGameLoaded?.Invoke();
// 6. Load the gamemode
LoadingHint = "Loading the gamemode: " + mapChange.Gamemode;
if (_cancelled)
{
return(GameLoadResult.Cancelled);
}
var gamemodeLoaded = Game.GamemodeLoader.LoadGamemode(mapChange.Gamemode);
if (!gamemodeLoaded)
{
return(GameLoadResult.FailedToLoadGamemode);
}
GameLoaded?.Invoke();
// 7. Notify server we're in
LoadingHint = "Done, entering game";
if (_cancelled)
{
return(GameLoadResult.Cancelled);
}
var pi2 = PacketUtility.TakePacket <PlayerIntroduction>();
pi2.Step = PlayerIntroduction.JoinStep.Introduce;
Game.Network.BroadcastPacket(pi2);
State = GameLoaderState.Playing;
return(GameLoadResult.Success);
}
public async Task <SyncState> SyncWithHostAsync(CancellationTokenSource cts = null)
{
_filesToSync = null;
var initiateSync = PacketUtility.TakePacket <FileSync>();
initiateSync.SyncType = FileSync.FileSyncType.Initiate;
Game.Network.BroadcastPacket(initiateSync);
var timeout = 10000f;
var rebuild = false;
while (timeout > 0)
{
await Task.Delay(100);
timeout -= 100f;
if (_filesToSync != null)
{
break;
}
if (timeout <= 0)
{
return(SyncState.TimedOut);
}
}
foreach (var file in _filesToSync)
{
if (file.WorkshopId == 0)
{
continue;
}
var item = await Item.GetAsync(file.WorkshopId);
if (!item.HasValue)
{
return(SyncState.Failed);
}
Item = item.Value;
if (!await Item.Subscribe())
{
return(SyncState.Failed);
}
if (cts == null)
{
cts = new CancellationTokenSource();
}
try
{
var downloadResult = await Item.DownloadAsync((v) => DownloadProgress = (int)(v * 100), 60, cts.Token);
cts?.Dispose();
if (!downloadResult)
{
return(SyncState.Failed);
}
}
catch
{
return(SyncState.Failed);
}
rebuild = true;
}
if (rebuild)
{
await FileSystem.BuildAsync();
}
return(SyncState.Completed);
}
