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); }