1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
|
using System.Linq;
using System.Threading.Tasks;
using Impostor.Api;
using Impostor.Api.Innersloth;
using Impostor.Api.Net;
using Impostor.Api.Net.Messages;
using Impostor.Hazel;
using Impostor.Server.Events;
using Impostor.Server.Net.Hazel;
using Microsoft.Extensions.Logging;
namespace Impostor.Server.Net.State
{
internal partial class Game
{
private async ValueTask PlayerAdd(ClientPlayer player)
{
// Store player.
if (!_players.TryAdd(player.Client.Id, player))
{
throw new ImpostorException("Failed to add player to game.");
}
// Assign hostId if none is set.
if (HostId == -1)
{
HostId = player.Client.Id;
await InitGameDataAsync(player);
}
await _eventManager.CallAsync(new GamePlayerJoinedEvent(this, player));
}
private async ValueTask<bool> PlayerRemove(int playerId, bool isBan = false)
{
if (!_players.TryRemove(playerId, out var player))
{
return false;
}
_logger.LogInformation("{0} - Player {1} ({2}) has left.", Code, player.Client.Name, playerId);
if (GameState == GameStates.Starting || GameState == GameStates.Started)
{
if (player.Character?.PlayerInfo != null)
{
player.Character.PlayerInfo.Disconnected = true;
player.Character.PlayerInfo.LastDeathReason = DeathReason.Disconnect;
}
}
player.Client.Player = null;
// Game is empty, remove it.
if (_players.IsEmpty)
{
GameState = GameStates.Destroyed;
// Remove instance reference.
await _gameManager.RemoveAsync(Code);
return true;
}
// Host migration.
if (HostId == playerId)
{
await MigrateHost();
}
if (isBan && player.Client.Connection != null)
{
BanIp(player.Client.Connection.EndPoint.Address);
}
await _eventManager.CallAsync(new GamePlayerLeftEvent(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 && player.Client.Connection is HazelConnection hazel)
{
_logger.LogInformation("{0} - Player {1} ({2}) kept connection open after leaving, disposing.", Code, player.Client.Name, playerId);
hazel.DisposeInnerConnection();
}
});
return true;
}
private async ValueTask MigrateHost()
{
// Pick the first player as new host.
var host = _players
.Select(p => p.Value)
.FirstOrDefault();
if (host == null)
{
await EndAsync();
return;
}
HostId = host.Client.Id;
_logger.LogInformation("{0} - Assigned {1} ({2}) as new host.", Code, host.Client.Name, host.Client.Id);
// Check our current game state.
if (GameState == GameStates.Ended && host.Limbo == LimboStates.WaitingForHost)
{
GameState = GameStates.NotStarted;
// Spawn the host.
await HandleJoinGameNew(host, false);
// Pull players out of limbo.
await CheckLimboPlayers();
}
}
private async ValueTask CheckLimboPlayers()
{
using var message = MessageWriter.Get(MessageType.Reliable);
foreach (var (_, player) in _players.Where(x => x.Value.Limbo == LimboStates.WaitingForHost))
{
WriteJoinedGameMessage(message, true, player);
WriteAlterGameMessage(message, false, IsPublic);
player.Limbo = LimboStates.NotLimbo;
await SendToAsync(message, player.Client.Id);
}
}
}
}
|
