{
PlayerInfo.IsDead = true;
PlayerInfo.LastDeathReason = reason;
-
- Console.WriteLine($"{PlayerInfo.PlayerName,-15} died {reason}");
}
}
}
\ No newline at end of file
/// <param name="writer">The message.</param>
/// <returns></returns>
ValueTask SendAsync(IMessageWriter writer);
+
+ /// <summary>
+ /// Disconnects the client and invokes the disconnect handler.
+ /// </summary>
+ /// <param name="reason">A reason.</param>
+ /// <returns></returns>
+ ValueTask DisconnectAsync(string reason);
}
}
\ No newline at end of file
/// </returns>
public static float Clamp(float value, float min, float max)
{
- if ((double) value < (double) min)
+ if (value < (double)min)
+ {
value = min;
- else if ((double) value > (double) max)
+ }
+ else if (value > (double)max)
+ {
value = max;
+ }
+
return value;
}
/// <summary>
/// <para>Clamps value between 0 and 1 and returns value.</para>
/// </summary>
- /// <param name="value"></param>
+ /// <param name="value">Value.</param>
+ /// <returns>Clamped value.</returns>
public static float Clamp01(float value)
{
- if ((double) value < 0.0)
+ if (value < 0.0)
+ {
return 0.0f;
- return (double) value > 1.0 ? 1f : value;
+ }
+
+ return (double)value > 1.0 ? 1f : value;
}
/// <summary>
/// <returns>
/// <para>The interpolated float result between the two float values.</para>
/// </returns>
- public static float Lerp(float a, float b, float t) => a + (b - a) * Mathf.Clamp01(t);
+ public static float Lerp(float a, float b, float t) => a + ((b - a) * Clamp01(t));
}
}
\ No newline at end of file
--- /dev/null
+namespace Impostor.Server
+{
+ internal static class Constants
+ {
+ public const int SpawnTimeout = 2500;
+ public const int ConnectionTimeout = 2500;
+ }
+}
\ No newline at end of file
return InnerConnection.SendAsync(writer);
}
+ public ValueTask DisconnectAsync(string reason)
+ {
+ return InnerConnection.Disconnect(reason);
+ }
+
+ public void DisposeInnerConnection()
+ {
+ InnerConnection.Dispose();
+ }
+
private async ValueTask ConnectionOnDisconnected(DisconnectedEventArgs e)
{
if (Client != null)
-using System.Threading.Tasks;
+using System;
+using System.Threading;
+using System.Threading.Tasks;
using Impostor.Api.Innersloth.Net;
using Impostor.Api.Innersloth.Net.Objects;
using Impostor.Api.Net;
+using Microsoft.Extensions.Logging;
namespace Impostor.Server.Net.State
{
internal partial class ClientPlayer : IClientPlayer
{
- public ClientPlayer(ClientBase client, Game game)
+ private readonly ILogger<ClientPlayer> _logger;
+
+ private Timer _spawnTimeout;
+
+ public ClientPlayer(ILogger<ClientPlayer> logger, ClientBase client, Game game)
{
+ _logger = logger;
+ _spawnTimeout = new Timer(RunSpawnTimeout, null, -1, -1);
+
Game = game;
Client = client;
Limbo = LimboStates.PreSpawn;
public string Scene { get; internal set; }
+ public void InitializeSpawnTimeout()
+ {
+ _spawnTimeout.Change(Constants.SpawnTimeout, -1);
+ }
+
+ public void DisableSpawnTimeout()
+ {
+ _spawnTimeout.Dispose();
+ _spawnTimeout = null;
+ }
+
/// <inheritdoc />
public bool IsOwner(InnerNetObject netObject)
{
{
return Game.HandleKickPlayer(Client.Id, true);
}
+
+ private async void RunSpawnTimeout(object state)
+ {
+ try
+ {
+ if (Character == null)
+ {
+ _logger.LogInformation("{0} - Player {1} spawn timed out, kicking.", Game.Code, Client.Id);
+
+ await KickAsync();
+ }
+ }
+ catch (Exception e)
+ {
+ _logger.LogError(e, "Exception caught while kicking player for spawn timeout.");
+ }
+ finally
+ {
+ await _spawnTimeout.DisposeAsync();
+ }
+ }
}
}
\ No newline at end of file
if (TryGetPlayer(control.OwnerId, out var player))
{
player.Character = control;
+ player.DisableSpawnTimeout();
}
// Hook up InnerPlayerControl <-> InnerPlayerControl.PlayerInfo.
using Impostor.Api.Net;
using Impostor.Api.Net.Messages;
using Impostor.Hazel;
+using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
namespace Impostor.Server.Net.State
if (player == null || player.Game != this)
{
- var clientPlayer = new ClientPlayer(client, this);
+ var clientPlayer = new ClientPlayer(_serviceProvider.GetRequiredService<ILogger<ClientPlayer>>(), client, this);
if (!_clientManager.Validate(client))
{
using Impostor.Api.Net;
using Impostor.Api.Net.Messages;
using Impostor.Hazel;
+using Impostor.Server.Net.Hazel;
using Microsoft.Extensions.Logging;
namespace Impostor.Server.Net.State
await InitGameDataAsync(player);
}
+ player.InitializeSpawnTimeout();
+
await _eventManager.CallAsync(new PlayerJoinedGameEvent(this, player));
}
await _eventManager.CallAsync(new PlayerLeftGameEvent(this, player, isBan));
+ // Player can refuse to be kicked and keep the connection open, check for this.
+ _ = Task.Run(async () =>
+ {
+ await Task.Delay(Constants.ConnectionTimeout);
+
+ if (player.Client.Connection.IsConnected)
+ {
+ _logger.LogInformation("{0} - Player {1} ({2}) kept connection open after leaving, disposing.", Code, player.Client.Name, playerId);
+ ((HazelConnection) player.Client.Connection).DisposeInnerConnection();
+ }
+ });
+
return true;
}
private static async Task Main(string[] args)
{
- // Log.Logger = new LoggerConfiguration()
- // // .MinimumLevel.Verbose()
- // .MinimumLevel.Debug()
- // .WriteTo.Console()
- // .CreateLogger();
+ Log.Logger = new LoggerConfiguration()
+ // .MinimumLevel.Verbose()
+ .MinimumLevel.Debug()
+ .WriteTo.Console()
+ .CreateLogger();
var stopwatch = Stopwatch.StartNew();
projects / rhonda / impostor.git / commitdiff