{
public interface IManualEventListener : IEventListener
{
+ EventPriority Priority { get; set; }
+
public bool CanExecute<T>();
public ValueTask Execute(IEvent @event);
-
- EventPriority Priority { get; set; }
}
-}
\ No newline at end of file
+}
{
}
- protected ImpostorConfigException(SerializationInfo info, StreamingContext context) : base(info, context)
+ public ImpostorConfigException(string? message) : base(message)
{
}
- public ImpostorConfigException(string? message) : base(message)
+ public ImpostorConfigException(string? message, Exception? innerException) : base(message, innerException)
{
}
- public ImpostorConfigException(string? message, Exception? innerException) : base(message, innerException)
+ protected ImpostorConfigException(SerializationInfo info, StreamingContext context) : base(info, context)
{
}
}
{
}
- protected ImpostorException(SerializationInfo info, StreamingContext context) : base(info, context)
+ public ImpostorException(string? message) : base(message)
{
}
- public ImpostorException(string? message) : base(message)
+ public ImpostorException(string? message, Exception? innerException) : base(message, innerException)
{
}
- public ImpostorException(string? message, Exception? innerException) : base(message, innerException)
+ protected ImpostorException(SerializationInfo info, StreamingContext context) : base(info, context)
{
}
}
-}
\ No newline at end of file
+}
{
}
- protected ImpostorProtocolException(SerializationInfo info, StreamingContext context) : base(info, context)
+ public ImpostorProtocolException(string? message) : base(message)
{
}
- public ImpostorProtocolException(string? message) : base(message)
+ public ImpostorProtocolException(string? message, Exception? innerException) : base(message, innerException)
{
}
- public ImpostorProtocolException(string? message, Exception? innerException) : base(message, innerException)
+ protected ImpostorProtocolException(SerializationInfo info, StreamingContext context) : base(info, context)
{
}
}
int HostId { get; }
- IClientPlayer GetClientPlayer(int clientId);
+ IClientPlayer? GetClientPlayer(int clientId);
T? FindObjectByNetId<T>(uint netId)
where T : IInnerNetObject;
<PropertyGroup>
<TargetFramework>netstandard2.1</TargetFramework>
- <CodeAnalysisRuleSet>ProjectRules.ruleset</CodeAnalysisRuleSet>
+ <CodeAnalysisRuleSet>../ProjectRules.ruleset</CodeAnalysisRuleSet>
<LangVersion>9</LangVersion>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<Nullable>enable</Nullable>
</PackageReference>
</ItemGroup>
-</Project>
\ No newline at end of file
+</Project>
public enum DisconnectReason
{
ExitGame = 0,
+ Destroy = 16,
+
// The game you tried to join is full.
// Check with the host to see if you can join next round.
GameFull = 1,
+
// The game you tried to join already started.
// Check with the host to see if you can join next round.
GameStarted = 2,
- // Could not find the game you're looking for.
+
+ // Could not find the game you're looking for..
GameMissing = 3,
IncorrectGame = 18,
- // For these a message can be given, specifying an empty message shows
+
+ // For this a message can be given, specifying an empty message shows
// "An unknown error disconnected you from the server."
- CustomMessage1 = 4,
+ // 4, 12, 13, 14, 15 also count as Custom
Custom = 8,
- // CustomMessage3 = 11,
- // CustomMessage4 = 12,
- // CustomMessage5 = 13,
- // CustomMessage6 = 14,
- // CustomMessage7 = 15,
+
// You are running an older version of the game.
// Please update to play with others.
IncorrectVersion = 5,
+
+ // You were banned from { GameCode ?? "the room" }
// You cannot rejoin that room.
- // You were banned
Banned = 6,
- // You can rejoin if the room hasn't started
- // You were kicked
+
+ // You were kicked from { GameCode ?? "the room" }
+ // You can rejoin if the room hasn't started.
Kicked = 7,
+
// You were banned for hacking.
// Please stop.
Hacking = 10,
- Destroy = 16,
+
+ // GameModes.LocalGame:
// You disconnected from the host.
// If this happens often, check your WiFi strength.
//
+ // GameModes.OnlineGame:
// You disconnected from the server.
// If this happens often, check your network strength.
// This may also be a server issue.
Error = 17,
+
// The server stopped this game. Possibly due to inactivity.
ServerRequest = 19,
+
// The Among Us servers are overloaded.
// Sorry! Please try again later!
ServerFull = 20,
+
FocusLostBackground = 207,
+
+ // You may not join another game for another { BanMinutesLeft } minutes after intentionally disconnecting.
IntentionalLeaving = 208,
+
+ // You were disconnected because Among Us was suspended by another app.
FocusLost = 209,
+
NewConnection = 210,
}
-}
\ No newline at end of file
+}
public static class GameCodeParser
{
private const string V2 = "QWXRTYLPESDFGHUJKZOCVBINMA";
- private static readonly int[] V2Map = {
- 25,
- 21,
- 19,
- 10,
- 8,
- 11,
- 12,
- 13,
- 22,
- 15,
- 16,
- 6,
- 24,
- 23,
- 18,
- 7,
- 0,
- 3,
- 9,
- 4,
- 14,
- 20,
- 1,
- 2,
- 5,
- 17
- };
+
+ private static readonly int[] V2Map = Enumerable.Range(65, 26).Select(v => V2.IndexOf((char)v)).ToArray();
+
private static readonly RNGCryptoServiceProvider Random = new RNGCryptoServiceProvider();
-
+
public static string IntToGameName(int input)
{
// V2.
#endif
}
- private static string IntToGameNameV2(int input)
- {
- var a = input & 0x3FF;
- var b = (input >> 10) & 0xFFFFF;
-
- return new string(new []
- {
- V2[a % 26],
- V2[a / 26],
- V2[b % 26],
- V2[b / 26 % 26],
- V2[b / (26 * 26) % 26],
- V2[b / (26 * 26 * 26) % 26]
- });
- }
-
public static int GameNameToInt(string code)
{
var upper = code.ToUpperInvariant();
{
return -1;
}
-
+
var len = code.Length;
if (len == 6)
{
{
return code[0] | ((code[1] | ((code[2] | (code[3] << 8)) << 8)) << 8);
}
-
- return -1;
- }
-
- private static int GameNameToIntV2(string code)
- {
- var a = V2Map[code[0] - 65];
- var b = V2Map[code[1] - 65];
- var c = V2Map[code[2] - 65];
- var d = V2Map[code[3] - 65];
- var e = V2Map[code[4] - 65];
- var f = V2Map[code[5] - 65];
-
- var one = (a + 26 * b) & 0x3FF;
- var two = (c + 26 * (d + 26 * (e + 26 * f)));
- return (int) (one | ((two << 10) & 0x3FFFFC00) | 0x80000000);
+ return -1;
}
public static int GenerateCode(int len)
{
throw new ArgumentException("should be 4 or 6", nameof(len));
}
-
+
// Generate random bytes.
#if NETSTANDARD2_0
var data = new byte[len];
Span<byte> data = stackalloc byte[len];
#endif
Random.GetBytes(data);
-
+
// Convert to their char representation.
Span<char> dataChar = stackalloc char[len];
for (var i = 0; i < len; i++)
return GameNameToInt(new string(dataChar));
#endif
}
+
+ private static string IntToGameNameV2(int input)
+ {
+ var a = input & 0x3FF;
+ var b = (input >> 10) & 0xFFFFF;
+
+ return new string(new[]
+ {
+ V2[a % 26],
+ V2[a / 26],
+ V2[b % 26],
+ V2[(b / 26) % 26],
+ V2[(b / (26 * 26)) % 26],
+ V2[(b / (26 * 26 * 26)) % 26],
+ });
+ }
+
+ private static int GameNameToIntV2(string code)
+ {
+ var a = V2Map[code[0] - 65];
+ var b = V2Map[code[1] - 65];
+ var c = V2Map[code[2] - 65];
+ var d = V2Map[code[3] - 65];
+ var e = V2Map[code[4] - 65];
+ var f = V2Map[code[5] - 65];
+
+ var one = (a + (26 * b)) & 0x3FF;
+ var two = c + (26 * (d + (26 * (e + (26 * f)))));
+
+ return (int)(one | ((two << 10) & 0x3FFFFC00) | 0x80000000);
+ }
}
-}
\ No newline at end of file
+}
ImpostorByVote = 2,
ImpostorByKill = 3,
ImpostorBySabotage = 4,
-
- // Unused (?)
ImpostorDisconnect = 5,
HumansDisconnect = 6,
}
-}
\ No newline at end of file
+}
}
public string Name { get; }
- public string Ping { get; }
- public IReadOnlyList<ServerInfo> Servers { get; }
- public void Serialize(BinaryWriter writer)
- {
- writer.Write(0);
- writer.Write(Name);
- writer.Write(Ping);
- writer.Write(Servers.Count);
+ public string Ping { get; }
- foreach (var server in Servers)
- {
- server.Serialize(writer);
- }
- }
+ public IReadOnlyList<ServerInfo> Servers { get; }
public static RegionInfo Deserialize(BinaryReader reader)
{
return new RegionInfo(name, ping, servers);
}
+
+ public void Serialize(BinaryWriter writer)
+ {
+ writer.Write(0);
+ writer.Write(Name);
+ writer.Write(Ping);
+ writer.Write(Servers.Count);
+
+ foreach (var server in Servers)
+ {
+ server.Serialize(writer);
+ }
+ }
}
-}
\ No newline at end of file
+}
{
public class ServerInfo
{
- public string Name { get; }
- public string Ip { get; }
- public ushort Port { get; }
-
public ServerInfo(string name, string ip, ushort port)
{
Name = name;
Ip = ip;
Port = port;
}
-
- public void Serialize(BinaryWriter writer)
- {
- writer.Write(Name);
- writer.Write(IPAddress.Parse(Ip).GetAddressBytes());
- writer.Write(Port);
- writer.Write(0);
- }
+
+ public string Name { get; }
+
+ public string Ip { get; }
+
+ public ushort Port { get; }
public static ServerInfo Deserialize(BinaryReader reader)
{
var ip = new IPAddress(reader.ReadBytes(4)).ToString();
var port = reader.ReadUInt16();
var unknown = reader.ReadInt32();
-
+
return new ServerInfo(name, ip, port);
}
+
+ public void Serialize(BinaryWriter writer)
+ {
+ writer.Write(Name);
+ writer.Write(IPAddress.Parse(Ip).GetAddressBytes());
+ writer.Write(Port);
+ writer.Write(0);
+ }
}
-}
\ No newline at end of file
+}
public enum SystemTypes : byte
{
Hallway = 0,
+
Storage = 1,
+
Cafeteria = 2,
+
Reactor = 3,
+
UpperEngine = 4,
+
Nav = 5,
+
Admin = 6,
+
Electrical = 7,
+
LifeSupp = 8,
+
Shields = 9,
+
MedBay = 10,
+
Security = 11,
+
Weapons = 12,
+
LowerEngine = 13,
+
Comms = 14,
+
ShipTasks = 15,
+
Doors = 16,
+
Sabotage = 17,
+
/// <summary>
/// Decontam on Mira and bottom decontam on Polus
/// </summary>
Decontamination = 18,
+
Launchpad = 19,
+
LockerRoom = 20,
+
Laboratory = 21,
+
Balcony = 22,
+
Office = 23,
+
Greenhouse = 24,
+
Dropship = 25,
+
/// <summary>
/// Top decontam on Polus
/// </summary>
Decontamination2 = 26,
+
Outside = 27,
+
Specimens = 28,
- BoilerRoom = 29
+
+ BoilerRoom = 29,
}
-}
\ No newline at end of file
+}
{
Always = 0,
Meetings = 1,
- Never = 2
+ Never = 2,
}
-}
\ No newline at end of file
+}
{
public interface IConnection
{
-
}
-}
\ No newline at end of file
+}
/// </summary>
public interface IGameNet
{
- IInnerLobbyBehaviour LobbyBehaviour { get; }
+ IInnerLobbyBehaviour? LobbyBehaviour { get; }
- IInnerGameData GameData { get; }
+ IInnerGameData? GameData { get; }
- IInnerVoteBanSystem VoteBan { get; }
+ IInnerVoteBanSystem? VoteBan { get; }
- IInnerShipStatus ShipStatus { get; }
+ IInnerShipStatus? ShipStatus { get; }
}
-}
\ No newline at end of file
+}
{
public interface IInnerShipStatus : IInnerNetObject
{
-
}
-}
\ No newline at end of file
+}
{
public interface IInnerVoteBanSystem : IInnerNetObject
{
-
}
-}
\ No newline at end of file
+}
RepairSystem = 28,
SetTasks = 29,
UpdateGameData = 30,
- CustomRpc = byte.MaxValue
+ CustomRpc = byte.MaxValue,
}
-}
\ No newline at end of file
+}
+++ /dev/null
-<RuleSet Name="Rules for Hello World project" Description="These rules focus on critical issues for the Hello World app." ToolsVersion="10.0">
- <Rules AnalyzerId="StyleCop.Analyzers" RuleNamespace="StyleCop.CSharp.OrderingRules">
- <Rule Id="SA1200" Action="None" />
- </Rules>
- <Rules AnalyzerId="StyleCop.Analyzers" RuleNamespace="StyleCop.CSharp.DocumentationRules">
- <Rule Id="SA1600" Action="None" />
- <Rule Id="SA1601" Action="None" />
- <Rule Id="SA1602" Action="None" />
- <Rule Id="SA1633" Action="None" />
- </Rules>
- <Rules AnalyzerId="StyleCop.Analyzers" RuleNamespace="StyleCop.CSharp.ReadabilityRules">
- <Rule Id="SA1101" Action="None" />
- <Rule Id="SA1111" Action="None" />
- </Rules>
- <Rules AnalyzerId="StyleCop.Analyzers" RuleNamespace="StyleCop.CSharp.NamingRules">
- <Rule Id="SA1309" Action="None" />
- </Rules>
-</RuleSet>
\ No newline at end of file
{
public class MessageWriter
{
- private static int BufferSize = 64000;
-
public MessageType SendOption { get; private set; }
private Stack<int> messageStarts = new Stack<int>();
<Project Sdk="Microsoft.NET.Sdk">
- <OutputType>Exe</OutputType>
- <TargetFramework>net5.0</TargetFramework>
- </PropertyGroup>
+ <PropertyGroup>
+ <OutputType>Exe</OutputType>
+ <TargetFramework>net5.0</TargetFramework>
+ </PropertyGroup>
- <ItemGroup>
-
<ProjectReference Include="..\Impostor.Client\Impostor.Client.csproj" />
- </ItemGroup>
+ <ItemGroup>
+ <ProjectReference Include="..\Impostor.Client\Impostor.Client.csproj" />
+ </ItemGroup>
- <ItemGroup>
-
<PackageReference Include="Serilog.Sinks.Console" Version="3.1.1" />
- </ItemGroup>
+ <ItemGroup>
+ <PackageReference Include="Serilog.Sinks.Console" Version="3.1.1" />
+ </ItemGroup>
</Project>
<Project Sdk="Microsoft.NET.Sdk">
- <TargetFramework>net5.0</TargetFramework>
- </PropertyGroup>
+ <PropertyGroup>
+ <TargetFramework>net5.0</TargetFramework>
+ </PropertyGroup>
- <ItemGroup>
-
<ProjectReference Include="..\Impostor.Api\Impostor.Api.csproj" />
-
<ProjectReference Include="..\Impostor.Hazel\Impostor.Hazel.csproj" />
- </ItemGroup>
+ <ItemGroup>
+ <ProjectReference Include="..\Impostor.Api\Impostor.Api.csproj" />
+ <ProjectReference Include="..\Impostor.Hazel\Impostor.Hazel.csproj" />
+ </ItemGroup>
</Project>
<Project Sdk="Microsoft.NET.Sdk">
-
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
- <TargetFramework>net5.0</TargetFramework>
- <DefineConstants>HAZEL_BAG</DefineConstants>
- </PropertyGroup>
+ <PropertyGroup>
+ <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+ <TargetFramework>net5.0</TargetFramework>
+ <DefineConstants>HAZEL_BAG</DefineConstants>
+ </PropertyGroup>
- <ItemGroup>
- <PackageReference Include="Microsoft.Extensions.ObjectPool" Version="5.0.0" />
-
<PackageReference Include="Serilog" Version="2.10.0" />
- </ItemGroup>
+ <ItemGroup>
+ <PackageReference Include="Microsoft.Extensions.ObjectPool" Version="5.0.4" />
+ <PackageReference Include="Serilog" Version="2.10.0" />
+ </ItemGroup>
- <ItemGroup>
-
<ProjectReference Include="..\Impostor.Api\Impostor.Api.csproj" />
- </ItemGroup>
+ <ItemGroup>
+ <ProjectReference Include="..\Impostor.Api\Impostor.Api.csproj" />
+ </ItemGroup>
</Project>
public long GetIP4Address()
{
- if (IPMode == IPMode.IPv4)
- {
- return ((IPEndPoint)this.RemoteEndPoint).Address.Address;
- }
- else
- {
- var bytes = ((IPEndPoint)this.RemoteEndPoint).Address.GetAddressBytes();
- return BitConverter.ToInt64(bytes, bytes.Length - 8);
- }
+ var bytes = this.RemoteEndPoint.Address.GetAddressBytes();
+
+ return IPMode == IPMode.IPv4
+ ? (uint)((bytes[3] << 24 | bytes[2] << 16 | bytes[1] << 8 | bytes[0]) & 0x0FFFFFFFF)
+ : BitConverter.ToInt64(bytes, bytes.Length - 8);
}
/// <summary>
if (disposing)
{
- SendDisconnect();
+ _ = SendDisconnect();
}
base.Dispose(disposing);
<Project Sdk="Microsoft.NET.Sdk">
-
<AssemblyName>Impostor.Cli</AssemblyName>
- <TargetFramework>net5.0</TargetFramework>
- <RuntimeIdentifiers>win-x64;linux-x64;linux-arm;linux-arm64;osx-x64</RuntimeIdentifiers>
- <OutputType>Exe</OutputType>
- <IncludeNativeLibrariesForSelfExtract>true</IncludeNativeLibrariesForSelfExtract>
- </PropertyGroup>
+ <PropertyGroup>
+ <AssemblyName>Impostor.Cli</AssemblyName>
+ <TargetFramework>net5.0</TargetFramework>
+ <RuntimeIdentifiers>win-x64;linux-x64;linux-arm;linux-arm64;osx-x64</RuntimeIdentifiers>
+ <OutputType>Exe</OutputType>
+ <IncludeNativeLibrariesForSelfExtract>true</IncludeNativeLibrariesForSelfExtract>
+ </PropertyGroup>
- <ItemGroup>
-
<ProjectReference Include="..\Impostor.Patcher.Shared\Impostor.Patcher.Shared.csproj" />
- </ItemGroup>
+ <ItemGroup>
+ <ProjectReference Include="..\Impostor.Patcher.Shared\Impostor.Patcher.Shared.csproj" />
+ </ItemGroup>
- <ItemGroup>
-
<PackageReference Include="System.CommandLine" Version="2.0.0-beta1.20478.1" />
- </ItemGroup>
+ <ItemGroup>
+ <PackageReference Include="System.CommandLine" Version="2.0.0-beta1.20478.1" />
+ </ItemGroup>
</Project>
<Project Sdk="Microsoft.NET.Sdk">
- <PropertyGroup>
- <TargetFrameworks>netstandard2.0;netstandard2.1</TargetFrameworks>
- </PropertyGroup>
+ <PropertyGroup>
+ <TargetFrameworks>netstandard2.0;netstandard2.1</TargetFrameworks>
+ </PropertyGroup>
+
+ <ItemGroup>
+ <PackageReference Include="Gameloop.Vdf" Version="0.6.1" />
+ </ItemGroup>
- <ItemGroup>
- <PackageReference Include="Gameloop.Vdf" Version="0.6.1" />
- </ItemGroup>
-
</Project>
<Project Sdk="Microsoft.NET.Sdk.WindowsDesktop">
-
- <PropertyGroup>
- <AssemblyName>Impostor</AssemblyName>
- <ProjectGuid>{804CF172-0C87-4423-9688-BD97D549891E}</ProjectGuid>
- <OutputType>WinExe</OutputType>
- <TargetFramework>net472</TargetFramework>
- <UseWindowsForms>true</UseWindowsForms>
- <Copyright>Copyright © AeonLucid 2020</Copyright>
- <ApplicationIcon>icon.ico</ApplicationIcon>
- <AutoGenerateBindingRedirects>true</AutoGenerateBindingRedirects>
- <GenerateResourceUsePreserializedResources>true</GenerateResourceUsePreserializedResources>
- </PropertyGroup>
- <ItemGroup>
- <ProjectReference Include="..\Impostor.Patcher.Shared\Impostor.Patcher.Shared.csproj" />
- <PackageReference Include="System.Resources.Extensions" Version="5.0.0" />
- <Reference Include="System.Runtime.InteropServices.RuntimeInformation" />
- <Reference Include="System.Windows.Forms" />
- </ItemGroup>
+ <PropertyGroup>
+ <AssemblyName>Impostor</AssemblyName>
+ <ProjectGuid>{804CF172-0C87-4423-9688-BD97D549891E}</ProjectGuid>
+ <OutputType>WinExe</OutputType>
+ <TargetFramework>net472</TargetFramework>
+ <UseWindowsForms>true</UseWindowsForms>
+ <Copyright>Copyright © AeonLucid 2020</Copyright>
+ <ApplicationIcon>icon.ico</ApplicationIcon>
+ <AutoGenerateBindingRedirects>true</AutoGenerateBindingRedirects>
+ <GenerateResourceUsePreserializedResources>true</GenerateResourceUsePreserializedResources>
+ </PropertyGroup>
-</Project>
\ No newline at end of file
+ <ItemGroup>
+ <ProjectReference Include="..\Impostor.Patcher.Shared\Impostor.Patcher.Shared.csproj" />
+ <PackageReference Include="System.Resources.Extensions" Version="5.0.0" />
+ <Reference Include="System.Runtime.InteropServices.RuntimeInformation" />
+ <Reference Include="System.Windows.Forms" />
+ </ItemGroup>
+
+</Project>
<Project Sdk="Microsoft.NET.Sdk.Web">
- <TargetFramework>net5.0</TargetFramework>
- <OutputType>Library</OutputType>
- </PropertyGroup>
+ <PropertyGroup>
+ <TargetFramework>net5.0</TargetFramework>
+ <OutputType>Library</OutputType>
+ </PropertyGroup>
- <ItemGroup>
-
<ProjectReference Include="..\Impostor.Api\Impostor.Api.csproj" />
- </ItemGroup>
+ <ItemGroup>
+ <ProjectReference Include="..\Impostor.Api\Impostor.Api.csproj" />
+ </ItemGroup>
- <ItemGroup>
- <Folder Include="Properties\" />
- </ItemGroup>
+ <ItemGroup>
+ <Folder Include="Properties\" />
+ </ItemGroup>
-</Project>
\ No newline at end of file
+</Project>
<PropertyGroup>
<TargetFramework>netstandard2.1</TargetFramework>
</PropertyGroup>
-
+
<ItemGroup>
<ProjectReference Include="..\Impostor.Api\Impostor.Api.csproj" />
</ItemGroup>
-using Impostor.Server.Utils;
+using System.Text.Json.Serialization;
+using Impostor.Server.Utils;
namespace Impostor.Server.Config
{
internal class AnnouncementsServerConfig
{
+ public const string Section = "AnnouncementsServer";
+
private string? _resolvedListenIp;
- public const string Section = "AnnouncementsServer";
+ [JsonConstructor]
+ public AnnouncementsServerConfig(bool enabled = true, string listenIp = "0.0.0.0", ushort listenPort = 22024)
+ {
+ Enabled = enabled;
+ ListenIp = listenIp;
+ ListenPort = listenPort;
+ }
- public bool Enabled { get; set; } = true;
+ public bool Enabled { get; }
- public string ListenIp { get; set; } = "0.0.0.0";
+ public string ListenIp { get; }
- public ushort ListenPort { get; set; } = 22024;
+ public ushort ListenPort { get; }
public string ResolveListenIp()
{
-namespace Impostor.Server.Config
+using System.Text.Json.Serialization;
+
+namespace Impostor.Server.Config
{
public class DebugConfig
{
public const string Section = "Debug";
- public bool GameRecorderEnabled { get; set; }
+ [JsonConstructor]
+ public DebugConfig(bool gameRecorderEnabled = false, string? gameRecorderPath = null)
+ {
+ GameRecorderEnabled = gameRecorderEnabled;
+ GameRecorderPath = gameRecorderPath;
+ }
+
+ public bool GameRecorderEnabled { get; }
- public string GameRecorderPath { get; set; }
+ public string? GameRecorderPath { get; }
}
-}
\ No newline at end of file
+}
{
internal class ServerConfig
{
+ public const string Section = "Server";
+
private string? _resolvedPublicIp;
private string? _resolvedListenIp;
- public const string Section = "Server";
-
public string PublicIp { get; set; } = "127.0.0.1";
public ushort PublicPort { get; set; } = 22023;
using System.Collections.Generic;
+using System.Text.Json.Serialization;
namespace Impostor.Server.Config
{
{
public const string Section = "ServerRedirector";
- public bool Enabled { get; set; }
+ [JsonConstructor]
+ public ServerRedirectorConfig(bool enabled = false, bool master = false, NodeLocator? locator = null, List<ServerRedirectorNode>? nodes = null)
+ {
+ Enabled = enabled;
+ Master = master;
+ Locator = locator;
+ Nodes = nodes;
+ }
- public bool Master { get; set; }
+ public bool Enabled { get; }
- public NodeLocator Locator { get; set; }
+ public bool Master { get; }
- public List<ServerRedirectorNode> Nodes { get; set; }
+ public NodeLocator? Locator { get; }
+
+ public List<ServerRedirectorNode>? Nodes { get; }
public class NodeLocator
{
- public string Redis { get; set; }
+ [JsonConstructor]
+ public NodeLocator(string redis, string udpMasterEndpoint)
+ {
+ Redis = redis;
+ UdpMasterEndpoint = udpMasterEndpoint;
+ }
+
+ public string Redis { get; }
- public string UdpMasterEndpoint { get; set; }
+ public string UdpMasterEndpoint { get; }
}
}
-}
\ No newline at end of file
+}
-namespace Impostor.Server.Config
+using System.Text.Json.Serialization;
+
+namespace Impostor.Server.Config
{
public class ServerRedirectorNode
{
- public string Ip { get; set; }
+ [JsonConstructor]
+ public ServerRedirectorNode(string ip, ushort port)
+ {
+ Ip = ip;
+ Port = port;
+ }
+
+ public string Ip { get; }
- public ushort Port { get; set; }
+ public ushort Port { get; }
}
-}
\ No newline at end of file
+}
{
internal readonly struct EventHandler
{
- public EventHandler(IEventListener o, IRegisteredEventListener listener)
+ public EventHandler(IEventListener? o, IRegisteredEventListener listener)
{
Object = o;
Listener = listener;
}
- public IEventListener Object { get; }
+ public IEventListener? Object { get; }
public IRegisteredEventListener Listener { get; }
- public void Deconstruct(out IEventListener o, out IRegisteredEventListener listener)
+ public void Deconstruct(out IEventListener? o, out IRegisteredEventListener listener)
{
o = Object;
listener = Listener;
}
}
-}
\ No newline at end of file
+}
}
/// <inheritdoc />
- public IDisposable RegisterListener<TListener>(TListener listener, Func<Func<Task>, Task> invoker = null)
+ public IDisposable RegisterListener<TListener>(TListener listener, Func<Func<Task>, Task>? invoker = null)
where TListener : IEventListener
{
if (listener == null)
}
public IGame Game { get; }
-
+
public GameOverReason GameOverReason { get; }
}
}
EventPriority Priority { get; }
- ValueTask InvokeAsync(object eventHandler, object @event, IServiceProvider provider);
+ ValueTask InvokeAsync(object? eventHandler, object @event, IServiceProvider provider);
}
-}
\ No newline at end of file
+}
public EventPriority Priority => _innerObject.Priority;
- public ValueTask InvokeAsync(object eventHandler, object @event, IServiceProvider provider)
+ public ValueTask InvokeAsync(object? eventHandler, object @event, IServiceProvider provider)
{
return new ValueTask(_invoker(() => _innerObject.InvokeAsync(eventHandler, @event, provider).AsTask()));
}
}
-}
\ No newline at end of file
+}
{
internal class ManualRegisteredEventListener : IRegisteredEventListener
{
- public Type EventType { get; } = typeof(object);
-
private readonly IManualEventListener _manualEventListener;
public ManualRegisteredEventListener(IManualEventListener manualEventListener)
_manualEventListener = manualEventListener;
}
+ public Type EventType { get; } = typeof(object);
+
public EventPriority Priority => _manualEventListener.Priority;
- public ValueTask InvokeAsync(object eventHandler, object @event, IServiceProvider provider)
+ public ValueTask InvokeAsync(object? eventHandler, object @event, IServiceProvider provider)
{
if (@event is IEvent typedEvent)
{
private static readonly PropertyInfo IsCancelledProperty = typeof(IEventCancelable).GetProperty(nameof(IEventCancelable.IsCancelled))!;
private static readonly ConcurrentDictionary<Type, RegisteredEventListener[]> Instances = new ConcurrentDictionary<Type, RegisteredEventListener[]>();
- private readonly Func<object, object, IServiceProvider, ValueTask> _invoker;
+ private readonly Func<object?, object, IServiceProvider, ValueTask> _invoker;
private readonly Type _eventListenerType;
public RegisteredEventListener(Type eventType, MethodInfo method, EventListenerAttribute attribute, Type eventListenerType)
public string Method { get; }
- public ValueTask InvokeAsync(object eventHandler, object @event, IServiceProvider provider)
+ public static IReadOnlyList<RegisteredEventListener> FromType(Type type)
+ {
+ return Instances.GetOrAdd(type, t =>
+ {
+ return t.GetMethods()
+ .Where(m => !m.IsStatic && m.GetCustomAttributes(typeof(EventListenerAttribute), false).Any())
+ .SelectMany(m => FromMethod(t, m))
+ .ToArray();
+ });
+ }
+
+ public static IEnumerable<RegisteredEventListener> FromMethod(Type listenerType, MethodInfo methodType)
+ {
+ // Get the return type.
+ var returnType = methodType.ReturnType;
+
+ if (returnType != typeof(void) && returnType != typeof(ValueTask))
+ {
+ throw new InvalidOperationException($"The method {methodType.GetFriendlyName()} does not return void or ValueTask.");
+ }
+
+ // Register the event.
+ foreach (var attribute in methodType.GetCustomAttributes<EventListenerAttribute>(false))
+ {
+ var eventType = attribute.Event;
+
+ if (eventType == null)
+ {
+ if (methodType.GetParameters().Length == 0 || !typeof(IEvent).IsAssignableFrom(methodType.GetParameters()[0].ParameterType))
+ {
+ throw new InvalidOperationException($"The first parameter of the method {methodType.GetFriendlyName()} should be the type {nameof(IEvent)}.");
+ }
+
+ eventType = methodType.GetParameters()[0].ParameterType;
+ }
+
+ yield return new RegisteredEventListener(eventType, methodType, attribute, listenerType);
+ }
+ }
+
+ public ValueTask InvokeAsync(object? eventHandler, object @event, IServiceProvider provider)
{
return _invoker(eventHandler, @event, provider);
}
- private Func<object, object, IServiceProvider, ValueTask> CreateInvoker(MethodInfo method, bool ignoreCancelled)
+ private Func<object?, object, IServiceProvider, ValueTask> CreateInvoker(MethodInfo method, bool ignoreCancelled)
{
var instance = Expression.Parameter(typeof(object), "instance");
var eventParameter = Expression.Parameter(typeof(object), "event");
throw new InvalidOperationException($"The method {method.GetFriendlyName()} must return void or ValueTask.");
}
- return Expression.Lambda<Func<object, object, IServiceProvider, ValueTask>>(invoke, instance, eventParameter, provider)
+ return Expression.Lambda<Func<object?, object, IServiceProvider, ValueTask>>(invoke, instance, eventParameter, provider)
.Compile();
}
-
- public static IReadOnlyList<RegisteredEventListener> FromType(Type type)
- {
- return Instances.GetOrAdd(type, t =>
- {
- return t.GetMethods()
- .Where(m => !m.IsStatic && m.GetCustomAttributes(typeof(EventListenerAttribute), false).Any())
- .SelectMany(m => FromMethod(t, m))
- .ToArray();
- });
- }
-
- public static IEnumerable<RegisteredEventListener> FromMethod(Type listenerType, MethodInfo methodType)
- {
- // Get the return type.
- var returnType = methodType.ReturnType;
-
- if (returnType != typeof(void) && returnType != typeof(ValueTask))
- {
- throw new InvalidOperationException($"The method {methodType.GetFriendlyName()} does not return void or ValueTask.");
- }
-
- // Register the event.
- foreach (var attribute in methodType.GetCustomAttributes<EventListenerAttribute>(false))
- {
- var eventType = attribute.Event;
-
- if (eventType == null)
- {
- if (methodType.GetParameters().Length == 0 || !typeof(IEvent).IsAssignableFrom(methodType.GetParameters()[0].ParameterType))
- {
- throw new InvalidOperationException($"The first parameter of the method {methodType.GetFriendlyName()} should be the type {nameof(IEvent)}.");
- }
-
- eventType = methodType.GetParameters()[0].ParameterType;
- }
-
- yield return new RegisteredEventListener(eventType, methodType, attribute, listenerType);
- }
- }
}
}
public EventPriority Priority => _innerObject.Priority;
- public ValueTask InvokeAsync(object eventHandler, object @event, IServiceProvider provider)
+ public ValueTask InvokeAsync(object? eventHandler, object @event, IServiceProvider provider)
{
return _innerObject.InvokeAsync(_object, @event, provider);
}
}
-}
\ No newline at end of file
+}
<RuntimeIdentifiers>win-x64;linux-x64;linux-arm;linux-arm64;osx-x64</RuntimeIdentifiers>
<IncludeNativeLibrariesForSelfExtract>true</IncludeNativeLibrariesForSelfExtract>
<ApplicationIcon>icon.ico</ApplicationIcon>
- <CodeAnalysisRuleSet>ProjectRules.ruleset</CodeAnalysisRuleSet>
+ <CodeAnalysisRuleSet>../ProjectRules.ruleset</CodeAnalysisRuleSet>
<Nullable>enable</Nullable>
<SelfContained>false</SelfContained>
</PropertyGroup>
</ItemGroup>
<ItemGroup>
- <PackageReference Include="Microsoft.Extensions.Caching.StackExchangeRedis" Version="5.0.0" />
+ <PackageReference Include="Microsoft.Extensions.Caching.StackExchangeRedis" Version="5.0.1" />
<PackageReference Include="Microsoft.Extensions.FileSystemGlobbing" Version="5.0.0" />
<PackageReference Include="Microsoft.Extensions.Hosting" Version="5.0.0" />
- <PackageReference Include="Microsoft.Extensions.ObjectPool" Version="5.0.0" />
- <PackageReference Include="Serilog.Extensions.Hosting" Version="3.1.0" />
+ <PackageReference Include="Microsoft.Extensions.ObjectPool" Version="5.0.4" />
+ <PackageReference Include="Serilog.Extensions.Hosting" Version="4.1.2" />
<PackageReference Include="Serilog.Sinks.Console" Version="3.1.1" />
- <PackageReference Include="StyleCop.Analyzers" Version="1.1.118">
+ <PackageReference Include="StyleCop.Analyzers.Unstable" Version="1.2.0.333">
<PrivateAssets>all</PrivateAssets>
<IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
</PackageReference>
private readonly AnnouncementsServerConfig _config;
private readonly ObjectPool<MessageReader> _readerPool;
private readonly IEventManager _eventManager;
- private UdpConnectionListener _connection;
+ private UdpConnectionListener? _connection;
public AnnouncementsService(ILogger<AnnouncementsService> logger, IOptions<AnnouncementsServerConfig> config, ObjectPool<MessageReader> readerPool, IEventManager eventManager)
{
{
AddressFamily.InterNetwork => IPMode.IPv4,
AddressFamily.InterNetworkV6 => IPMode.IPv6,
- _ => throw new InvalidOperationException()
+ _ => throw new InvalidOperationException(),
};
_connection = new UdpConnectionListener(endpoint, _readerPool, mode)
public async Task StopAsync(CancellationToken cancellationToken)
{
_logger.LogWarning("Announcements server is shutting down!");
- await _connection.DisposeAsync();
+
+ if (_connection != null)
+ {
+ await _connection.DisposeAsync();
+ }
}
private async ValueTask OnNewConnection(NewConnectionEventArgs e)
return;
}
- await Player.Game.HandleStartGame(reader);
+ await Player!.Game.HandleStartGame(reader);
break;
}
out var playerId,
out var reason);
- await Player.Game.HandleRemovePlayer(playerId, (DisconnectReason)reason);
+ await Player!.Game.HandleRemovePlayer(playerId, (DisconnectReason)reason);
break;
}
// Handle packet.
using var readerCopy = reader.Copy();
- var verified = await Player.Game.HandleGameDataAsync(readerCopy, Player, toPlayer);
+ var verified = await Player!.Game.HandleGameDataAsync(readerCopy, Player, toPlayer);
if (verified)
{
// Broadcast packet to all other players.
reader,
out var gameOverReason);
- await Player.Game.HandleEndGame(reader, gameOverReason);
+ await Player!.Game.HandleEndGame(reader, gameOverReason);
break;
}
return;
}
- await Player.Game.HandleAlterGame(reader, Player, value);
+ await Player!.Game.HandleAlterGame(reader, Player, value);
break;
}
out var playerId,
out var isBan);
- await Player.Game.HandleKickPlayer(playerId, isBan);
+ await Player!.Game.HandleKickPlayer(playerId, isBan);
break;
}
public abstract ValueTask HandleDisconnectAsync(string reason);
-
public async ValueTask DisconnectAsync(DisconnectReason reason, string? message = null)
{
if (!Connection.IsConnected)
public bool IsConnected => InnerConnection.State == ConnectionState.Connected;
- public IClient Client { get; set; }
+ public IClient? Client { get; set; }
public ValueTask SendAsync(IMessageWriter writer)
{
return InnerConnection.SendAsync(writer);
}
- public ValueTask DisconnectAsync(string reason)
+ public ValueTask DisconnectAsync(string? reason)
{
return InnerConnection.Disconnect(reason);
}
public abstract ValueTask<bool> HandleRpcAsync(ClientPlayer sender, ClientPlayer? target, RpcCalls call, IMessageReader reader);
+ // TODO move to Reactor.Impostor plugin
protected ValueTask<bool> HandleCustomRpc(IMessageReader reader, Game game)
{
var lengthOrShortId = reader.ReadPackedInt32();
var id = reader.ReadPackedInt32();
- // TODO handle custom rpcs
-
return ValueTask.FromResult(true);
}
}
var minSid = (ushort)(_lastSequenceId + 5U);
// Snap in the server.
- await SnapToAsync(_game.GetClientPlayer(OwnerId), position, minSid);
+ await SnapToAsync(_game.GetClientPlayer(OwnerId)!, position, minSid);
// Broadcast to all clients.
using (var writer = _game.StartRpc(NetId, RpcCalls.SnapTo))
private ushort _lastSequenceId;
- public Vector2 Position { get; private set; }
-
- public Vector2 Velocity { get; private set; }
-
public InnerCustomNetworkTransform(ILogger<InnerCustomNetworkTransform> logger, InnerPlayerControl playerControl, Game game, IEventManager eventManager, ObjectPool<PlayerMovementEvent> pool)
{
_logger = logger;
_pool = pool;
}
- private static bool SidGreaterThan(ushort newSid, ushort prevSid)
- {
- var num = (ushort)(prevSid + (uint)short.MaxValue);
+ public Vector2 Position { get; private set; }
- return (int)prevSid < (int)num
- ? newSid > prevSid && newSid <= num
- : newSid > prevSid || newSid <= num;
- }
+ public Vector2 Velocity { get; private set; }
public override ValueTask<bool> SerializeAsync(IMessageWriter writer, bool initialState)
{
_pool.Return(playerMovementEvent);
}
+ private static bool SidGreaterThan(ushort newSid, ushort prevSid)
+ {
+ var num = (ushort)(prevSid + (uint)short.MaxValue);
+
+ return (int)prevSid < (int)num
+ ? newSid > prevSid && newSid <= num
+ : newSid > prevSid || newSid <= num;
+ }
+
private ValueTask SnapToAsync(IClientPlayer sender, Vector2 position, ushort minSid)
{
if (!SidGreaterThan(minSid, _lastSequenceId))
{
internal partial class InnerMeetingHud : IInnerMeetingHud
{
-
}
-}
\ No newline at end of file
+}
public sbyte VotedFor { get; private set; }
- internal void SetDead(bool didReport, bool isDead)
- {
- DidReport = didReport;
- IsDead = isDead;
- }
-
public void Deserialize(IMessageReader reader)
{
var num = reader.ReadByte();
DidVote = (num & VotedBit) > 0;
DidReport = (num & ReportedBit) > 0;
}
+
+ internal void SetDead(bool didReport, bool isDead)
+ {
+ DidReport = didReport;
+ IsDead = isDead;
+ }
}
}
-}
\ No newline at end of file
+}
using System;
using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
using System.Linq;
using System.Threading.Tasks;
using Impostor.Api;
private readonly IEventManager _eventManager;
private readonly Game _game;
private readonly GameNet _gameNet;
+
+ [AllowNull]
private PlayerVoteArea[] _playerStates;
public InnerMeetingHud(ILogger<InnerMeetingHud> logger, IEventManager eventManager, Game game)
public byte ReporterId { get; private set; }
- private void PopulateButtons(byte reporter)
- {
- _playerStates = _gameNet.GameData.Players
- .Select(x =>
- {
- var area = new PlayerVoteArea(this, x.Key);
- area.SetDead(x.Value.PlayerId == reporter, x.Value.Disconnected || x.Value.IsDead);
- return area;
- })
- .ToArray();
- }
-
public override ValueTask<bool> SerializeAsync(IMessageWriter writer, bool initialState)
{
throw new NotImplementedException();
return true;
}
+ private void PopulateButtons(byte reporter)
+ {
+ _playerStates = _gameNet.GameData!.Players
+ .Select(x =>
+ {
+ var area = new PlayerVoteArea(this, x.Key);
+ area.SetDead(x.Value.PlayerId == reporter, x.Value.Disconnected || x.Value.IsDead);
+ return area;
+ })
+ .ToArray();
+ }
+
private async ValueTask HandleVotingComplete(ClientPlayer sender, ReadOnlyMemory<byte> states, byte playerId, bool tie)
{
if (playerId != byte.MaxValue)
{
- var player = _game.GameNet.GameData.GetPlayerById(playerId);
- if (player != null)
+ var player = _game.GameNet.GameData!.GetPlayerById(playerId);
+ if (player?.Controller != null)
{
player.Controller.Die(DeathReason.Exile);
await _eventManager.CallAsync(new PlayerExileEvent(_game, sender, player.Controller));
Rpc12MurderPlayer.Serialize(writer, target);
await _game.FinishRpcAsync(writer);
- await _eventManager.CallAsync(new PlayerMurderEvent(_game, _game.GetClientPlayer(OwnerId), this, target));
+ await _eventManager.CallAsync(new PlayerMurderEvent(_game, _game.GetClientPlayer(OwnerId)!, this, target));
}
public async ValueTask ExileAsync()
await _game.FinishRpcAsync(writer);
// Notify plugins.
- await _eventManager.CallAsync(new PlayerExileEvent(_game, _game.GetClientPlayer(OwnerId), this));
+ await _eventManager.CallAsync(new PlayerExileEvent(_game, _game.GetClientPlayer(OwnerId)!, this));
}
}
}
using System;
using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
using System.Linq;
using System.Threading.Tasks;
using Impostor.Api;
{
internal partial class InnerPlayerControl : InnerNetObject
{
+ private static readonly byte ColorsCount = (byte)Enum.GetValues<ColorType>().Length;
+
private readonly ILogger<InnerPlayerControl> _logger;
private readonly IEventManager _eventManager;
private readonly Game _game;
public InnerCustomNetworkTransform NetworkTransform { get; }
+ [AllowNull]
public InnerPlayerInfo PlayerInfo { get; internal set; }
internal Queue<string> RequestedPlayerName { get; } = new Queue<string>();
PlayerId = reader.ReadByte();
}
- internal void Die(DeathReason reason)
- {
- PlayerInfo.IsDead = true;
- PlayerInfo.LastDeathReason = reason;
- }
-
public override async ValueTask<bool> HandleRpcAsync(ClientPlayer sender, ClientPlayer? target, RpcCalls call, IMessageReader reader)
{
switch (call)
return true;
}
+ internal void Die(DeathReason reason)
+ {
+ PlayerInfo.IsDead = true;
+ PlayerInfo.LastDeathReason = reason;
+ }
+
private async ValueTask HandleCompleteTask(ClientPlayer sender, uint taskId)
{
var task = PlayerInfo.Tasks.ElementAtOrDefault((int)taskId);
{
for (var i = 0; i < infectedIds.Length; i++)
{
- var player = _game.GameNet.GameData.GetPlayerById(infectedIds.Span[i]);
+ var player = _game.GameNet.GameData!.GetPlayerById(infectedIds.Span[i]);
if (player != null)
{
player.IsImpostor = true;
return true;
}
- private static readonly byte ColorsCount = (byte)Enum.GetValues<ColorType>().Length;
-
private async ValueTask<bool> HandleCheckColor(ClientPlayer sender, ColorType color)
{
if ((byte)color > ColorsCount)
PlayerInfo.LastMurder = _dateTimeProvider.UtcNow;
- if (!target.PlayerInfo.IsDead)
+ if (target != null && !target.PlayerInfo.IsDead)
{
((InnerPlayerControl)target).Die(DeathReason.Kill);
await _eventManager.CallAsync(new PlayerMurderEvent(_game, sender, this, target));
private async ValueTask HandleStartMeeting(byte targetId)
{
- var deadPlayer = _game.GameNet.GameData.GetPlayerById(targetId)?.Controller;
- await _eventManager.CallAsync(new PlayerStartMeetingEvent(_game, _game.GetClientPlayer(this.OwnerId), this, deadPlayer));
+ var deadPlayer = _game.GameNet.GameData!.GetPlayerById(targetId)?.Controller;
+ await _eventManager.CallAsync(new PlayerStartMeetingEvent(_game, _game.GetClientPlayer(this.OwnerId)!, this, deadPlayer));
}
private async ValueTask<bool> HandleSetPet(ClientPlayer sender, PetType pet)
PlayerId = playerId;
}
- public InnerPlayerControl Controller { get; internal set; }
+ public InnerPlayerControl? Controller { get; internal set; }
public byte PlayerId { get; }
- public string PlayerName { get; internal set; }
+ public string PlayerName { get; internal set; } = string.Empty;
public ColorType Color { get; internal set; }
public DeathReason LastDeathReason { get; internal set; }
- public List<InnerGameData.TaskInfo> Tasks { get; internal set; }
+ public List<InnerGameData.TaskInfo> Tasks { get; internal set; } = new List<InnerGameData.TaskInfo>(0);
public DateTimeOffset LastMurder { get; set; }
MapTypes.Skeld => 13,
MapTypes.MiraHQ => 2,
MapTypes.Polus => 12,
- _ => throw new ArgumentOutOfRangeException()
+ _ => throw new ArgumentOutOfRangeException(),
};
_doors = new Dictionary<int, bool>(doorCount);
}
}
}
-}
\ No newline at end of file
+}
{
internal partial class ClientManager
{
- private static HashSet<int> SupportedVersions { get; } = new HashSet<int>
+ private static readonly HashSet<int> SupportedVersions = new HashSet<int>
{
GameVersion.GetVersion(2021, 3, 5), // 2021.3.5
};
- private static string ServerBrand { get; } = $"Impostor {DotnetUtils.GetVersion()}";
+ private static readonly string ServerBrand = $"Impostor {DotnetUtils.GetVersion()}";
private readonly ILogger<ClientManager> _logger;
private readonly ConcurrentDictionary<int, ClientBase> _clients;
IEnumerable<IGame> IGameManager.Games => _games.Select(kv => kv.Value);
- IGame IGameManager.Find(GameCode code) => Find(code);
+ IGame? IGameManager.Find(GameCode code) => Find(code);
- public async ValueTask<IGame> CreateAsync(GameOptionsData options)
- {
- // TODO: Prevent duplicates when using server redirector using INodeProvider.
- var (success, game) = await TryCreateAsync(options);
-
- for (int i = 0; i < 10 && !success; i++)
- {
- (success, game) = await TryCreateAsync(options);
- }
-
- if (!success)
- {
- throw new ImpostorException("Could not create new game"); // TODO: Fix generic exception.
- }
-
- return game;
- }
-
- private async ValueTask<(bool success, Game game)> TryCreateAsync(GameOptionsData options)
- {
- var gameCode = _gameCodeFactory.Create();
- var gameCodeStr = gameCode.Code;
- var game = ActivatorUtilities.CreateInstance<Game>(_serviceProvider, _publicIp, gameCode, options);
-
- if (await _nodeLocator.ExistsAsync(gameCodeStr) || !_games.TryAdd(gameCode, game))
- {
- return (false, null);
- }
-
- await _nodeLocator.SaveAsync(gameCodeStr, _publicIp);
- _logger.LogDebug("Created game with code {0}.", game.Code);
-
- await _eventManager.CallAsync(new GameCreatedEvent(game));
-
- return (true, game);
- }
-
- public Game Find(GameCode code)
+ public Game? Find(GameCode code)
{
_games.TryGetValue(code, out var game);
return game;
await _eventManager.CallAsync(new GameDestroyedEvent(game));
}
+
+ public async ValueTask<IGame> CreateAsync(GameOptionsData options)
+ {
+ // TODO: Prevent duplicates when using server redirector using INodeProvider.
+ var (success, game) = await TryCreateAsync(options);
+
+ for (int i = 0; i < 10 && !success; i++)
+ {
+ (success, game) = await TryCreateAsync(options);
+ }
+
+ if (!success || game == null)
+ {
+ throw new ImpostorException("Could not create new game"); // TODO: Fix generic exception.
+ }
+
+ return game;
+ }
+
+ private async ValueTask<(bool Success, Game? Game)> TryCreateAsync(GameOptionsData options)
+ {
+ var gameCode = _gameCodeFactory.Create();
+ var gameCodeStr = gameCode.Code;
+ var game = ActivatorUtilities.CreateInstance<Game>(_serviceProvider, _publicIp, gameCode, options);
+
+ if (await _nodeLocator.ExistsAsync(gameCodeStr) || !_games.TryAdd(gameCode, game))
+ {
+ return (false, null);
+ }
+
+ await _nodeLocator.SaveAsync(gameCodeStr, _publicIp);
+ _logger.LogDebug("Created game with code {0}.", game.Code);
+
+ await _eventManager.CallAsync(new GameCreatedEvent(game));
+
+ return (true, game);
+ }
}
}
private readonly ObjectPool<MessageReader> _readerPool;
private readonly ILogger<Matchmaker> _logger;
private readonly ILogger<HazelConnection> _connectionLogger;
- private UdpConnectionListener _connection;
+ private UdpConnectionListener? _connection;
public Matchmaker(
ILogger<Matchmaker> logger,
{
AddressFamily.InterNetwork => IPMode.IPv4,
AddressFamily.InterNetworkV6 => IPMode.IPv6,
- _ => throw new InvalidOperationException()
+ _ => throw new InvalidOperationException(),
};
- _connection = new UdpConnectionListener(ipEndPoint, _readerPool, mode);
- _connection.NewConnection = OnNewConnection;
+ _connection = new UdpConnectionListener(ipEndPoint, _readerPool, mode)
+ {
+ NewConnection = OnNewConnection,
+ };
await _connection.StartAsync();
}
public async ValueTask StopAsync()
{
- await _connection.DisposeAsync();
+ if (_connection != null)
+ {
+ await _connection.DisposeAsync();
+ }
}
private async ValueTask OnNewConnection(NewConnectionEventArgs e)
{
public interface INodeLocator
{
- ValueTask<IPEndPoint> FindAsync(string gameCode);
+ ValueTask<IPEndPoint?> FindAsync(string gameCode);
ValueTask SaveAsync(string gameCode, IPEndPoint endPoint);
ValueTask RemoveAsync(string gameCode);
}
-}
\ No newline at end of file
+}
{
public class NodeLocatorNoOp : INodeLocator
{
- public ValueTask<IPEndPoint> FindAsync(string gameCode) => ValueTask.FromResult(default(IPEndPoint));
+ public ValueTask<IPEndPoint?> FindAsync(string gameCode) => ValueTask.FromResult(default(IPEndPoint));
public ValueTask SaveAsync(string gameCode, IPEndPoint endPoint) => ValueTask.CompletedTask;
public ValueTask RemoveAsync(string gameCode) => ValueTask.CompletedTask;
}
-}
\ No newline at end of file
+}
_cache = cache;
}
- public async ValueTask<IPEndPoint> FindAsync(string gameCode)
+ public async ValueTask<IPEndPoint?> FindAsync(string gameCode)
{
var entry = await _cache.GetStringAsync(gameCode);
if (entry == null)
await _cache.RemoveAsync(gameCode);
}
}
-}
\ No newline at end of file
+}
{
private readonly ILogger<NodeLocatorUdp> _logger;
private readonly bool _isMaster;
- private readonly IPEndPoint _server;
- private readonly UdpClient _client;
- private readonly ConcurrentDictionary<string, AvailableNode> _availableNodes;
+ private readonly IPEndPoint? _server;
+ private readonly UdpClient? _client;
+ private readonly ConcurrentDictionary<string, AvailableNode>? _availableNodes;
public NodeLocatorUdp(ILogger<NodeLocatorUdp> logger, IOptions<ServerRedirectorConfig> config)
{
{
_isMaster = false;
- if (!IPEndPoint.TryParse(config.Value.Locator.UdpMasterEndpoint, out var endpoint))
+ if (!IPEndPoint.TryParse(config.Value.Locator!.UdpMasterEndpoint, out var endpoint))
{
throw new ArgumentException("UdpMasterEndpoint should be in the ip:port format.");
}
{
_logger.LogDebug("Received update {0} -> {1}", gameCode, ip);
- _availableNodes.AddOrUpdate(
+ _availableNodes!.AddOrUpdate(
gameCode,
- s => new AvailableNode
- {
- Endpoint = ip,
- LastUpdated = DateTimeOffset.UtcNow,
- },
+ s => new AvailableNode(ip, DateTimeOffset.UtcNow),
(s, node) =>
{
node.Endpoint = ip;
}
}
- public ValueTask<IPEndPoint> FindAsync(string gameCode)
+ public ValueTask<IPEndPoint?> FindAsync(string gameCode)
{
if (!_isMaster)
{
return ValueTask.FromResult(default(IPEndPoint));
}
- if (_availableNodes.TryGetValue(gameCode, out var node))
+ if (_availableNodes!.TryGetValue(gameCode, out var node))
{
if (node.Expired)
{
return ValueTask.FromResult(default(IPEndPoint));
}
- return ValueTask.FromResult(node.Endpoint);
+ return ValueTask.FromResult(node.Endpoint)!;
}
return ValueTask.FromResult(default(IPEndPoint));
return ValueTask.CompletedTask;
}
- _availableNodes.TryRemove(gameCode, out _);
+ _availableNodes!.TryRemove(gameCode, out _);
return ValueTask.CompletedTask;
}
public ValueTask SaveAsync(string gameCode, IPEndPoint endPoint)
{
var data = Encoding.UTF8.GetBytes($"{gameCode},{endPoint}");
- _client.Send(data, data.Length, _server);
+ _client!.Send(data, data.Length, _server);
return ValueTask.CompletedTask;
}
private class AvailableNode
{
+ public AvailableNode(IPEndPoint endpoint, DateTimeOffset lastUpdated)
+ {
+ Endpoint = endpoint;
+ LastUpdated = lastUpdated;
+ }
+
public IPEndPoint Endpoint { get; set; }
public DateTimeOffset LastUpdated { get; set; }
_nodeLocator = (NodeLocatorUdp)nodeLocator;
_logger = logger;
- if (!IPEndPoint.TryParse(options.Value.Locator.UdpMasterEndpoint, out var endpoint))
+ if (!IPEndPoint.TryParse(options.Value.Locator!.UdpMasterEndpoint, out var endpoint))
{
throw new ArgumentException("UdpMasterEndpoint should be in the ip:port format.");
}
public ClientPlayer(ILogger<ClientPlayer> logger, ClientBase client, Game game)
{
_logger = logger;
- _spawnTimeout = new Timer(RunSpawnTimeout, null, -1, -1);
+ _spawnTimeout = new Timer(RunSpawnTimeout!, null, -1, -1);
Game = game;
Client = client;
public bool IsHost => Game?.Host == this;
- public string Scene { get; internal set; }
+ public string? Scene { get; internal set; }
public RuntimePlatform? Platform { get; internal set; }
public async ValueTask SyncSettingsAsync()
{
- if (Host.Character == null)
+ if (Host?.Character == null)
{
throw new ImpostorException("Attempted to set infected when the host was not spawned.");
}
};
private readonly List<InnerNetObject> _allObjects = new List<InnerNetObject>();
- private readonly Dictionary<uint, InnerNetObject> _allObjectsFast = new Dictionary<uint, InnerNetObject>();
- private int _gamedataInitialized;
+ private readonly Dictionary<uint, InnerNetObject> _allObjectsFast = new Dictionary<uint, InnerNetObject>();
- private async ValueTask OnSpawnAsync(InnerNetObject netObj)
+ public T? FindObjectByNetId<T>(uint netId)
+ where T : IInnerNetObject
{
- switch (netObj)
+ if (_allObjectsFast.TryGetValue(netId, out var obj))
{
- case InnerLobbyBehaviour lobby:
- {
- GameNet.LobbyBehaviour = lobby;
- break;
- }
-
- case InnerGameData data:
- {
- GameNet.GameData = data;
- break;
- }
-
- case InnerVoteBanSystem voteBan:
- {
- GameNet.VoteBan = voteBan;
- break;
- }
-
- case InnerShipStatus shipStatus:
- {
- GameNet.ShipStatus = shipStatus;
- break;
- }
-
- case InnerPlayerControl control:
- {
- // Hook up InnerPlayerControl <-> IClientPlayer.
- if (!TryGetPlayer(control.OwnerId, out var player))
- {
- throw new ImpostorException("Failed to find player that spawned the InnerPlayerControl");
- }
-
- player.Character = control;
- player.DisableSpawnTimeout();
-
- // Hook up InnerPlayerControl <-> InnerPlayerControl.PlayerInfo.
- control.PlayerInfo = GameNet.GameData.GetPlayerById(control.PlayerId)!;
-
- if (control.PlayerInfo == null)
- {
- GameNet.GameData.AddPlayer(control);
- }
-
- if (control.PlayerInfo != null)
- {
- control.PlayerInfo!.Controller = control;
- }
-
- await _eventManager.CallAsync(new PlayerSpawnedEvent(this, player, control));
-
- break;
- }
-
- case InnerMeetingHud meetingHud:
- {
- await _eventManager.CallAsync(new MeetingStartedEvent(this, meetingHud));
- break;
- }
+ return (T)(IInnerNetObject)obj;
}
- }
-
- private async ValueTask OnDestroyAsync(InnerNetObject netObj)
- {
- switch (netObj)
- {
- case InnerLobbyBehaviour:
- {
- GameNet.LobbyBehaviour = null;
- break;
- }
-
- case InnerGameData:
- {
- GameNet.GameData = null;
- break;
- }
-
- case InnerVoteBanSystem:
- {
- GameNet.VoteBan = null;
- break;
- }
-
- case InnerShipStatus:
- {
- GameNet.ShipStatus = null;
- break;
- }
- case InnerPlayerControl control:
- {
- // Remove InnerPlayerControl <-> IClientPlayer.
- if (TryGetPlayer(control.OwnerId, out var player))
- {
- player.Character = null;
- }
-
- await _eventManager.CallAsync(new PlayerDestroyedEvent(this, player, control));
-
- break;
- }
-
-
- }
+ return default;
}
public async ValueTask<bool> HandleGameDataAsync(IMessageReader parent, ClientPlayer sender, bool toPlayer)
{
// Find target player.
- ClientPlayer target = null;
+ ClientPlayer? target = null;
if (toPlayer)
{
var objectId = reader.ReadPackedUInt32();
if (objectId < SpawnableObjects.Length)
{
- var innerNetObject = (InnerNetObject) ActivatorUtilities.CreateInstance(_serviceProvider, SpawnableObjects[objectId], this);
+ var innerNetObject = (InnerNetObject)ActivatorUtilities.CreateInstance(_serviceProvider, SpawnableObjects[objectId], this);
var ownerClientId = reader.ReadPackedInt32();
// Prevent fake client from being broadcasted.
return false;
}
- innerNetObject.SpawnFlags = (SpawnFlags) reader.ReadByte();
+ innerNetObject.SpawnFlags = (SpawnFlags)reader.ReadByte();
var components = innerNetObject.GetComponentsInChildren<InnerNetObject>();
var componentsCount = reader.ReadPackedInt32();
return true;
}
+ private async ValueTask OnSpawnAsync(InnerNetObject netObj)
+ {
+ switch (netObj)
+ {
+ case InnerLobbyBehaviour lobby:
+ {
+ GameNet.LobbyBehaviour = lobby;
+ break;
+ }
+
+ case InnerGameData data:
+ {
+ GameNet.GameData = data;
+ break;
+ }
+
+ case InnerVoteBanSystem voteBan:
+ {
+ GameNet.VoteBan = voteBan;
+ break;
+ }
+
+ case InnerShipStatus shipStatus:
+ {
+ GameNet.ShipStatus = shipStatus;
+ break;
+ }
+
+ case InnerPlayerControl control:
+ {
+ // Hook up InnerPlayerControl <-> IClientPlayer.
+ if (!TryGetPlayer(control.OwnerId, out var player))
+ {
+ throw new ImpostorException("Failed to find player that spawned the InnerPlayerControl");
+ }
+
+ player.Character = control;
+ player.DisableSpawnTimeout();
+
+ // Hook up InnerPlayerControl <-> InnerPlayerControl.PlayerInfo.
+ var playerInfo = GameNet.GameData!.GetPlayerById(control.PlayerId);
+
+ if (playerInfo != null)
+ {
+ playerInfo.Controller = control;
+ control.PlayerInfo = playerInfo;
+ }
+ else
+ {
+ GameNet.GameData.AddPlayer(control);
+ }
+
+ await _eventManager.CallAsync(new PlayerSpawnedEvent(this, player, control));
+
+ break;
+ }
+
+ case InnerMeetingHud meetingHud:
+ {
+ await _eventManager.CallAsync(new MeetingStartedEvent(this, meetingHud));
+ break;
+ }
+ }
+ }
+
+ private async ValueTask OnDestroyAsync(InnerNetObject netObj)
+ {
+ switch (netObj)
+ {
+ case InnerLobbyBehaviour:
+ {
+ GameNet.LobbyBehaviour = null;
+ break;
+ }
+
+ case InnerGameData:
+ {
+ GameNet.GameData = null;
+ break;
+ }
+
+ case InnerVoteBanSystem:
+ {
+ GameNet.VoteBan = null;
+ break;
+ }
+
+ case InnerShipStatus:
+ {
+ GameNet.ShipStatus = null;
+ break;
+ }
+
+ case InnerPlayerControl control:
+ {
+ // Remove InnerPlayerControl <-> IClientPlayer.
+ if (TryGetPlayer(control.OwnerId, out var player))
+ {
+ player.Character = null;
+ await _eventManager.CallAsync(new PlayerDestroyedEvent(this, player, control));
+ }
+
+ break;
+ }
+ }
+ }
+
private bool AddNetObject(InnerNetObject obj)
{
if (_allObjectsFast.ContainsKey(obj.NetId))
obj.NetId = uint.MaxValue;
}
-
- public T? FindObjectByNetId<T>(uint netId)
- where T : IInnerNetObject
- {
- if (_allObjectsFast.TryGetValue(netId, out var obj))
- {
- return (T)(IInnerNetObject)obj;
- }
-
- return default;
- }
}
}
await _eventManager.CallAsync(new GameStartingEvent(this));
}
+ public async ValueTask HandleEndGame(IMessageReader message, GameOverReason gameOverReason)
+ {
+ GameState = GameStates.Ended;
+
+ // Broadcast end of the game.
+ using (var packet = MessageWriter.Get(MessageType.Reliable))
+ {
+ message.CopyTo(packet);
+ await SendToAllAsync(packet);
+ }
+
+ // Put all players in the correct limbo state.
+ foreach (var player in _players)
+ {
+ player.Value.Limbo = LimboStates.PreSpawn;
+ }
+
+ await _eventManager.CallAsync(new GameEndedEvent(this, gameOverReason));
+ }
+
+ public async ValueTask HandleAlterGame(IMessageReader message, IClientPlayer sender, bool isPublic)
+ {
+ IsPublic = isPublic;
+
+ using var packet = MessageWriter.Get(MessageType.Reliable);
+ message.CopyTo(packet);
+ await SendToAllExceptAsync(packet, sender.Client.Id);
+
+ await _eventManager.CallAsync(new GameAlterEvent(this, isPublic));
+ }
+
+ public async ValueTask HandleRemovePlayer(int playerId, DisconnectReason reason)
+ {
+ await PlayerRemove(playerId);
+
+ // It's possible that the last player was removed, so check if the game is still around.
+ if (GameState == GameStates.Destroyed)
+ {
+ return;
+ }
+
+ using var packet = MessageWriter.Get(MessageType.Reliable);
+ WriteRemovePlayerMessage(packet, false, playerId, reason);
+ await SendToAllExceptAsync(packet, playerId);
+ }
+
+ public async ValueTask HandleKickPlayer(int playerId, bool isBan)
+ {
+ _logger.LogInformation("{0} - Player {1} has left.", Code, playerId);
+
+ using var message = MessageWriter.Get(MessageType.Reliable);
+
+ // Send message to everyone that this player was kicked.
+ WriteKickPlayerMessage(message, false, playerId, isBan);
+
+ await SendToAllAsync(message);
+ await PlayerRemove(playerId, isBan);
+
+ // Remove the player from everyone's game.
+ WriteRemovePlayerMessage(
+ message,
+ true,
+ playerId,
+ isBan ? DisconnectReason.Banned : DisconnectReason.Kicked);
+
+ await SendToAllExceptAsync(message, playerId);
+ }
+
public async ValueTask<GameJoinResult> AddClientAsync(ClientBase client)
{
var hasLock = false;
return GameJoinResult.FromError(GameJoinError.InvalidClient);
}
+ private async ValueTask HandleJoinGameNew(ClientPlayer sender, bool isNew)
+ {
+ _logger.LogInformation("{0} - Player {1} ({2}) is joining.", Code, sender.Client.Name, sender.Client.Id);
+
+ // Add player to the game.
+ if (isNew)
+ {
+ await PlayerAdd(sender);
+ }
+
+ sender.InitializeSpawnTimeout();
+
+ using (var message = MessageWriter.Get(MessageType.Reliable))
+ {
+ WriteJoinedGameMessage(message, false, sender);
+ WriteAlterGameMessage(message, false, IsPublic);
+
+ sender.Limbo = LimboStates.NotLimbo;
+
+ await SendToAsync(message, sender.Client.Id);
+ await BroadcastJoinMessage(message, true, sender);
+ }
+ }
+
private async ValueTask<GameJoinResult> AddClientSafeAsync(ClientBase client)
{
// Check if the IP of the player is banned.
- if (client.Connection != null && _bannedIps.Contains(client.Connection.EndPoint.Address))
+ if (_bannedIps.Contains(client.Connection.EndPoint.Address))
{
return GameJoinResult.FromError(GameJoinError.Banned);
}
return GameJoinResult.CreateSuccess(player);
}
- public async ValueTask HandleEndGame(IMessageReader message, GameOverReason gameOverReason)
- {
- GameState = GameStates.Ended;
-
- // Broadcast end of the game.
- using (var packet = MessageWriter.Get(MessageType.Reliable))
- {
- message.CopyTo(packet);
- await SendToAllAsync(packet);
- }
-
- // Put all players in the correct limbo state.
- foreach (var player in _players)
- {
- player.Value.Limbo = LimboStates.PreSpawn;
- }
-
- await _eventManager.CallAsync(new GameEndedEvent(this, gameOverReason));
- }
-
- public async ValueTask HandleAlterGame(IMessageReader message, IClientPlayer sender, bool isPublic)
- {
- IsPublic = isPublic;
-
- using var packet = MessageWriter.Get(MessageType.Reliable);
- message.CopyTo(packet);
- await SendToAllExceptAsync(packet, sender.Client.Id);
-
- await _eventManager.CallAsync(new GameAlterEvent(this, isPublic));
- }
-
- public async ValueTask HandleRemovePlayer(int playerId, DisconnectReason reason)
- {
- await PlayerRemove(playerId);
-
- // It's possible that the last player was removed, so check if the game is still around.
- if (GameState == GameStates.Destroyed)
- {
- return;
- }
-
- using var packet = MessageWriter.Get(MessageType.Reliable);
- WriteRemovePlayerMessage(packet, false, playerId, reason);
- await SendToAllExceptAsync(packet, playerId);
- }
-
- public async ValueTask HandleKickPlayer(int playerId, bool isBan)
- {
- _logger.LogInformation("{0} - Player {1} has left.", Code, playerId);
-
- using var message = MessageWriter.Get(MessageType.Reliable);
-
- // Send message to everyone that this player was kicked.
- WriteKickPlayerMessage(message, false, playerId, isBan);
-
- await SendToAllAsync(message);
- await PlayerRemove(playerId, isBan);
-
- // Remove the player from everyone's game.
- WriteRemovePlayerMessage(
- message,
- true,
- playerId,
- isBan ? DisconnectReason.Banned : DisconnectReason.Kicked);
-
- await SendToAllExceptAsync(message, playerId);
- }
-
- private async ValueTask HandleJoinGameNew(ClientPlayer sender, bool isNew)
- {
- _logger.LogInformation("{0} - Player {1} ({2}) is joining.", Code, sender.Client.Name, sender.Client.Id);
-
- // Add player to the game.
- if (isNew)
- {
- await PlayerAdd(sender);
- }
-
- sender.InitializeSpawnTimeout();
-
- using (var message = MessageWriter.Get(MessageType.Reliable))
- {
- WriteJoinedGameMessage(message, false, sender);
- WriteAlterGameMessage(message, false, IsPublic);
-
- sender.Limbo = LimboStates.NotLimbo;
-
- await SendToAsync(message, sender.Client.Id);
- await BroadcastJoinMessage(message, true, sender);
- }
- }
-
private async ValueTask HandleJoinGameNext(ClientPlayer sender, bool isNew)
{
_logger.LogInformation("{0} - Player {1} ({2}) is rejoining.", Code, sender.Client.Name, sender.Client.Id);
await MigrateHost();
}
- if (isBan && player.Client.Connection != null)
+ if (isBan)
{
BanIp(player.Client.Connection.EndPoint.Address);
}
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
using System.Linq;
using System.Net;
using System.Numerics;
public GameStates GameState { get; private set; }
- internal GameNet GameNet { get; }
-
public GameOptionsData Options { get; }
public IDictionary<object, object> Items { get; }
public IEnumerable<IClientPlayer> Players => _players.Select(p => p.Value);
- public bool TryGetPlayer(int id, out ClientPlayer player)
+ internal GameNet GameNet { get; }
+
+ public bool TryGetPlayer(int id, [MaybeNullWhen(false)] out ClientPlayer player)
{
if (_players.TryGetValue(id, out var result))
{
return false;
}
- public IClientPlayer GetClientPlayer(int clientId)
+ public IClientPlayer? GetClientPlayer(int clientId)
{
return _players.TryGetValue(clientId, out var clientPlayer) ? clientPlayer : null;
}
+ public ValueTask EndAsync()
+ {
+ return _gameManager.RemoveAsync(Code);
+ }
+
internal async ValueTask StartedAsync()
{
if (GameState == GameStates.Starting)
}
}
- public ValueTask EndAsync()
- {
- return _gameManager.RemoveAsync(Code);
- }
-
private ValueTask BroadcastJoinMessage(IMessageWriter message, bool clear, ClientPlayer player)
{
Message01JoinGameS2C.SerializeJoin(message, clear, Code, player.Client.Id, HostId);
{
return Players
.Where(filter)
- .Select(p => p.Client.Connection);
+ .Select(p => p.Client.Connection)!;
}
}
}
/// <inheritdoc />
internal partial class GameNet : IGameNet
{
- IInnerLobbyBehaviour IGameNet.LobbyBehaviour => LobbyBehaviour;
+ IInnerLobbyBehaviour? IGameNet.LobbyBehaviour => LobbyBehaviour;
- IInnerGameData IGameNet.GameData => GameData;
+ IInnerGameData? IGameNet.GameData => GameData;
- IInnerVoteBanSystem IGameNet.VoteBan => VoteBan;
+ IInnerVoteBanSystem? IGameNet.VoteBan => VoteBan;
- IInnerShipStatus IGameNet.ShipStatus => ShipStatus;
+ IInnerShipStatus? IGameNet.ShipStatus => ShipStatus;
}
-}
\ No newline at end of file
+}
{
internal partial class GameNet
{
- public InnerLobbyBehaviour LobbyBehaviour { get; internal set; }
+ public InnerLobbyBehaviour? LobbyBehaviour { get; internal set; }
- public InnerGameData GameData { get; internal set; }
+ public InnerGameData? GameData { get; internal set; }
- public InnerVoteBanSystem VoteBan { get; internal set; }
+ public InnerVoteBanSystem? VoteBan { get; internal set; }
- public InnerShipStatus ShipStatus { get; internal set; }
+ public InnerShipStatus? ShipStatus { get; internal set; }
}
-}
\ No newline at end of file
+}
{
public class AssemblyInformation : IAssemblyInformation
{
- private Assembly _assembly;
+ private Assembly? _assembly;
public AssemblyInformation(AssemblyName assemblyName, string path, bool isPlugin)
{
return _assembly;
}
}
-}
\ No newline at end of file
+}
{
private readonly ImpostorPluginAttribute _attribute;
- public PluginInformation(IPluginStartup startup, Type pluginType)
+ public PluginInformation(IPluginStartup? startup, Type pluginType)
{
- _attribute = pluginType.GetCustomAttribute<ImpostorPluginAttribute>();
+ _attribute = pluginType.GetCustomAttribute<ImpostorPluginAttribute>()!;
Startup = startup;
PluginType = pluginType;
public string Version => _attribute.Version;
- public IPluginStartup Startup { get; }
+ public IPluginStartup? Startup { get; }
public Type PluginType { get; }
- public IPlugin Instance { get; set; }
+ public IPlugin? Instance { get; set; }
public override string ToString()
{
return $"{Package} {Name} ({Version}) by {Author}";
}
}
-}
\ No newline at end of file
+}
// Some plugins may be referencing another Impostor.Api version and try to load it.
// We want to only use the one shipped with the server.
- if (name.Name.Equals("Impostor.Api"))
+ if (name.Name == "Impostor.Api")
{
return typeof(IPlugin).Assembly;
}
plugin.First()));
}
- foreach (var plugin in plugins.Where(plugin => plugin.Startup != null))
+ foreach (var plugin in plugins)
{
- plugin.Startup.ConfigureHost(builder);
+ plugin.Startup?.ConfigureHost(builder);
}
builder.ConfigureServices(services =>
{
services.AddHostedService(provider => ActivatorUtilities.CreateInstance<PluginLoaderService>(provider, plugins));
- foreach (var plugin in plugins.Where(plugin => plugin.Startup != null))
+ foreach (var plugin in plugins)
{
- plugin.Startup.ConfigureServices(services);
+ plugin.Startup?.ConfigureServices(services);
}
});
{
}
- protected PluginLoaderException(SerializationInfo info, StreamingContext context) : base(info, context)
+ public PluginLoaderException(string? message) : base(message)
{
}
- public PluginLoaderException(string? message) : base(message)
+ public PluginLoaderException(string? message, Exception? innerException) : base(message, innerException)
{
}
- public PluginLoaderException(string? message, Exception? innerException) : base(message, innerException)
+ protected PluginLoaderException(SerializationInfo info, StreamingContext context) : base(info, context)
{
}
}
-}
\ No newline at end of file
+}
_logger.LogInformation("Enabling plugin {0}.", plugin);
// Create instance and inject services.
- plugin.Instance = (IPlugin) ActivatorUtilities.CreateInstance(_serviceProvider, plugin.PluginType);
+ plugin.Instance = (IPlugin)ActivatorUtilities.CreateInstance(_serviceProvider, plugin.PluginType);
// Enable plugin.
await plugin.Instance.EnableAsync();
_logger.LogInformation(
_plugins.Count == 1
? "Loaded {0} plugin."
- : "Loaded {0} plugins.", _plugins.Count);
+ : "Loaded {0} plugins.",
+ _plugins.Count
+ );
}
public async Task StopAsync(CancellationToken cancellationToken)
{
// Disable all plugins with a valid instance set.
// In the case of a failed startup, some can be null.
- foreach (var plugin in _plugins.Where(plugin => plugin.Instance != null))
+ foreach (var plugin in _plugins)
{
- _logger.LogInformation("Disabling plugin {0}.", plugin);
+ if (plugin.Instance != null)
+ {
+ _logger.LogInformation("Disabling plugin {0}.", plugin);
- // Disable plugin.
- await plugin.Instance.DisableAsync();
+ // Disable plugin.
+ await plugin.Instance.DisableAsync();
+ }
}
}
}
-}
\ No newline at end of file
+}
if (redirector.Enabled)
{
- if (!string.IsNullOrEmpty(redirector.Locator.Redis))
+ if (!string.IsNullOrEmpty(redirector.Locator?.Redis))
{
// When joining a game, it retrieves the game server ip from redis.
// When a game has been created on this node, it stores the game code with its ip in redis.
options.InstanceName = "ImpostorRedis";
});
}
- else if (!string.IsNullOrEmpty(redirector.Locator.UdpMasterEndpoint))
+ else if (!string.IsNullOrEmpty(redirector.Locator?.UdpMasterEndpoint))
{
services.AddSingleton<INodeLocator, NodeLocatorUdp>();
+++ /dev/null
-<RuleSet Name="Rules for Hello World project" Description="These rules focus on critical issues for the Hello World app." ToolsVersion="10.0">
- <Rules AnalyzerId="StyleCop.Analyzers" RuleNamespace="StyleCop.CSharp.OrderingRules">
- <Rule Id="SA1200" Action="None" />
- </Rules>
- <Rules AnalyzerId="StyleCop.Analyzers" RuleNamespace="StyleCop.CSharp.DocumentationRules">
- <Rule Id="SA1600" Action="None" />
- <Rule Id="SA1601" Action="None" />
- <Rule Id="SA1615" Action="None" />
- <Rule Id="SA1633" Action="None" />
- </Rules>
- <Rules AnalyzerId="StyleCop.Analyzers" RuleNamespace="StyleCop.CSharp.ReadabilityRules">
- <Rule Id="SA1101" Action="None" />
- <Rule Id="SA1111" Action="None"/>
- </Rules>
- <Rules AnalyzerId="StyleCop.Analyzers" RuleNamespace="StyleCop.CSharp.NamingRules">
- <Rule Id="SA1309" Action="None" />
- </Rules>
- <Rules AnalyzerId="StyleCop.Analyzers" RuleNamespace="StyleCop.CSharp.SpacingRules">
- <Rule Id="SA1003" Action="None" />
- <Rule Id="SA1009" Action="None" />
- </Rules>
-</RuleSet>
\ No newline at end of file
{
var name = $"session_{DateTimeOffset.UtcNow.ToUnixTimeMilliseconds()}.dat";
- _path = Path.Combine(options.Value.GameRecorderPath, name);
+ _path = Path.Combine(options.Value.GameRecorderPath!, name);
_logger = logger;
_pool = pool;
});
}
- protected override async Task ExecuteAsync(CancellationToken stoppingToken)
- {
- _startTime = DateTimeOffset.UtcNow;
- _logger.LogInformation("PacketRecorder is enabled, writing packets to {0}.", _path);
-
- var writer = File.Open(_path, FileMode.CreateNew, FileAccess.Write, FileShare.Read);
-
- await WriteFileHeaderAsync();
-
- // Handle messages.
- try
- {
- while (!stoppingToken.IsCancellationRequested)
- {
- var result = await _channel.Reader.ReadAsync(stoppingToken);
-
- await writer.WriteAsync(result, stoppingToken);
- await writer.FlushAsync(stoppingToken);
- }
- }
- catch (TaskCanceledException)
- {
- }
-
- // Clean up.
- await writer.DisposeAsync();
- }
-
public async Task WriteConnectAsync(ClientRecorder client)
{
_logger.LogTrace("Writing Connect.");
WriteClient(context, client, true);
WriteLength(context);
- await WriteAsync(context.Stream);
+ await WriteAsync(context.Stream!);
}
finally
{
context.Writer.Write(reason);
WriteLength(context);
- await WriteAsync(context.Stream);
+ await WriteAsync(context.Stream!);
}
finally
{
WritePacket(context, reader, messageType);
WriteLength(context);
- await WriteAsync(context.Stream);
+ await WriteAsync(context.Stream!);
}
finally
{
WriteGameCode(context, gameCode);
WriteLength(context);
- await WriteAsync(context.Stream);
+ await WriteAsync(context.Stream!);
}
finally
{
}
}
+ protected override async Task ExecuteAsync(CancellationToken stoppingToken)
+ {
+ _startTime = DateTimeOffset.UtcNow;
+ _logger.LogInformation("PacketRecorder is enabled, writing packets to {0}.", _path);
+
+ var writer = File.Open(_path, FileMode.CreateNew, FileAccess.Write, FileShare.Read);
+
+ await WriteFileHeaderAsync();
+
+ // Handle messages.
+ try
+ {
+ while (!stoppingToken.IsCancellationRequested)
+ {
+ var result = await _channel.Reader.ReadAsync(stoppingToken);
+
+ await writer.WriteAsync(result, stoppingToken);
+ await writer.FlushAsync(stoppingToken);
+ }
+ }
+ catch (TaskCanceledException)
+ {
+ }
+
+ // Clean up.
+ await writer.DisposeAsync();
+ }
+
private async Task WriteFileHeaderAsync()
{
var context = _pool.Get();
context.Writer.Write(_startTime.ToUnixTimeMilliseconds());
context.Writer.Write(DotnetUtils.GetVersion());
- await WriteAsync(context.Stream);
+ await WriteAsync(context.Stream!);
}
finally
{
context.Writer.Write((byte)type);
}
- private static void WriteClient(PacketSerializationContext context, ClientBase client, bool full)
+ private void WriteClient(PacketSerializationContext context, ClientBase client, bool full)
{
var address = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 12345);
var addressBytes = address.Address.GetAddressBytes();
}
}
- private static void WritePacket(PacketSerializationContext context, IMessageReader reader, MessageType messageType)
+ private void WritePacket(PacketSerializationContext context, IMessageReader reader, MessageType messageType)
{
context.Writer.Write((byte)messageType);
context.Writer.Write((byte)reader.Tag);
context.Writer.Write(reader.Buffer, reader.Offset, reader.Length);
}
- private static void WriteGameCode(PacketSerializationContext context, in GameCode gameCode)
+ private void WriteGameCode(PacketSerializationContext context, in GameCode gameCode)
{
context.Writer.Write(gameCode.Code);
}
- private static void WriteLength(PacketSerializationContext context)
+ private void WriteLength(PacketSerializationContext context)
{
var length = context.Stream.Position;
-using System.IO;
+using System.Diagnostics.CodeAnalysis;
+using System.IO;
using System.Text;
namespace Impostor.Server.Recorder
private const int InitialStreamSize = 0x100;
private const int MaximumStreamSize = 0x100000;
- private MemoryStream _memory;
- private BinaryWriter _writer;
+ private MemoryStream? _memory;
+ private BinaryWriter? _writer;
+ [AllowNull]
public MemoryStream Stream
{
get
{
- if (_memory == null)
- {
- _memory = new MemoryStream(InitialStreamSize);
- }
-
- return _memory;
+ return _memory ??= new MemoryStream(InitialStreamSize);
}
private set => _memory = value;
}
+ [AllowNull]
public BinaryWriter Writer
{
get
{
- if (_writer == null)
- {
- _writer = new BinaryWriter(Stream, Encoding.UTF8, true);
- }
-
- return _writer;
+ return _writer ??= new BinaryWriter(Stream, Encoding.UTF8, true);
}
private set => _writer = value;
}
}
}
}
-}
\ No newline at end of file
+}
Connect = 1,
Disconnect = 2,
Message = 3,
- GameCreated = 4
+ GameCreated = 4,
}
-}
\ No newline at end of file
+}
<Project Sdk="Microsoft.NET.Sdk">
- <TargetFramework>net5.0</TargetFramework>
- <IsPackable>false</IsPackable>
- </PropertyGroup>
+ <PropertyGroup>
+ <TargetFramework>net5.0</TargetFramework>
+ <IsPackable>false</IsPackable>
+ </PropertyGroup>
- <ItemGroup>
- <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.8.0" />
- <PackageReference Include="xunit" Version="2.4.1" />
- <PackageReference Include="xunit.runner.reporters" Version="2.4.1" />
- <PackageReference Include="xunit.runner.visualstudio" Version="2.4.3" />
- <PackageReference Include="coverlet.collector" Version="1.3.0" />
- </ItemGroup>
+ <ItemGroup>
+ <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.9.1" />
+ <PackageReference Include="xunit" Version="2.4.1" />
+ <PackageReference Include="xunit.runner.reporters" Version="2.4.1" />
+ <PackageReference Include="xunit.runner.visualstudio" Version="2.4.3" />
+ <PackageReference Include="coverlet.collector" Version="3.0.3">
+ <PrivateAssets>all</PrivateAssets>
+ <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+ </PackageReference>
+ </ItemGroup>
- <ItemGroup>
-
<ProjectReference Include="..\Impostor.Server\Impostor.Server.csproj" />
- </ItemGroup>
+ <ItemGroup>
+ <ProjectReference Include="..\Impostor.Server\Impostor.Server.csproj" />
+ </ItemGroup>
</Project>
<Project Sdk="Microsoft.NET.Sdk">
- <OutputType>Exe</OutputType>
- <TargetFramework>net5.0</TargetFramework>
- </PropertyGroup>
+ <PropertyGroup>
+ <OutputType>Exe</OutputType>
+ <TargetFramework>net5.0</TargetFramework>
+ </PropertyGroup>
- <ItemGroup>
- <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="5.0.0" />
- <PackageReference Include="Pcap.Net.x64" Version="1.0.4.1" />
- </ItemGroup>
+ <ItemGroup>
+ <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="5.0.1" />
+ <PackageReference Include="Pcap.Net.x64" Version="1.0.4.1">
+ <NoWarn>NU1701</NoWarn>
+ </PackageReference>
+ </ItemGroup>
+
+ <ItemGroup>
+ <ProjectReference Include="..\Impostor.Hazel\Impostor.Hazel.csproj" />
+ </ItemGroup>
- <ItemGroup>
- <ProjectReference Include="..\Impostor.Hazel\Impostor.Hazel.csproj" />
- </ItemGroup>
-
</Project>
</PropertyGroup>
<ItemGroup>
- <ProjectReference Include="..\Impostor.Server\Impostor.Server.csproj"/>
+ <ProjectReference Include="..\Impostor.Server\Impostor.Server.csproj" />
</ItemGroup>
<ItemGroup>
- <PackageReference Include="Serilog.Sinks.Console" Version="3.1.1"/>
+ <PackageReference Include="Serilog.Sinks.Console" Version="3.1.1" />
</ItemGroup>
</Project>
public IPEndPoint EndPoint { get; }
public bool IsConnected { get; }
- public IClient? Client { get; set; }
+ public IClient Client { get; set; }
public ValueTask SendAsync(IMessageWriter writer)
{
return ValueTask.CompletedTask;
}
}
-}
\ No newline at end of file
+}
--- /dev/null
+<RuleSet Name="Impostor" ToolsVersion="10.0">
+ <Rules AnalyzerId="StyleCop.Analyzers" RuleNamespace="StyleCop.CSharp.OrderingRules">
+ <Rule Id="SA1200" Action="None" />
+ </Rules>
+ <Rules AnalyzerId="StyleCop.Analyzers" RuleNamespace="StyleCop.CSharp.DocumentationRules">
+ <Rule Id="SA1600" Action="None" />
+ <Rule Id="SA1601" Action="None" />
+ <Rule Id="SA1602" Action="None" />
+ <Rule Id="SA1633" Action="None" />
+ </Rules>
+ <Rules AnalyzerId="StyleCop.Analyzers" RuleNamespace="StyleCop.CSharp.ReadabilityRules">
+ <Rule Id="SA1101" Action="None" />
+ <Rule Id="SA1111" Action="None" />
+ <Rule Id="SA1128" Action="None" />
+ </Rules>
+ <Rules AnalyzerId="StyleCop.Analyzers" RuleNamespace="StyleCop.CSharp.NamingRules">
+ <Rule Id="SA1309" Action="None" />
+ </Rules>
+ <Rules AnalyzerId="StyleCop.Analyzers" RuleNamespace="StyleCop.CSharp.SpacingRules">
+ <Rule Id="SA1003" Action="None" />
+ <Rule Id="SA1009" Action="None" />
+ </Rules>
+</RuleSet>
projects / rhonda / impostor.git / commitdiff