public async Task Connect(Guid userId, Guid connectionId)
{
EnsureGameIsNotStarted();
if (!_playerListEditor.Contains(userId))
{
var player = _playerListEditor.Add(userId);
var playerJoined = new PlayerJoined(_state.RoomId, player);
if (_playerListEditor.Count == 1)
{
_mapEditor.Generate();
}
if (!_mapEditor.CanPlacePlanet)
{
var options = new GameOptionsData
{
MapWidth = _mapEditor.MapWidth + 1,
MapHeight = _mapEditor.MapHeigth + 1,
NeutralPlanetsCount = _mapEditor.NeutralPlanetsCount
};
_mapEditor.Generate(options);
}
_mapEditor.PlacePlanet(userId);
var mapUpdated = new MapUpdated(_state.RoomId, _state.MapEditor.Map);
await _hub.NotifyEverybodyExcept(userId, playerJoined, mapUpdated);
}
await _hub.Connect(userId, connectionId);
}
public static HostGameRequest Deserialize(HazelBinaryReader reader)
{
var result = new HostGameRequest();
result.gameOptions = GameOptionsData.Deserialize(reader.ReadBytesAndSize());
return(result);
}
public Game(
ILogger <Game> logger,
IServiceProvider serviceProvider,
GameManager gameManager,
IPEndPoint publicIp,
GameCode code,
GameOptionsData options,
ClientManager clientManager,
IEventManager eventManager)
{
_logger = logger;
_serviceProvider = serviceProvider;
_gameManager = gameManager;
_players = new ConcurrentDictionary <int, ClientPlayer>();
_bannedIps = new HashSet <IPAddress>();
PublicIp = publicIp;
Code = code;
HostId = -1;
GameState = GameStates.NotStarted;
GameNet = new GameNet();
Options = options;
_clientManager = clientManager;
_eventManager = eventManager;
Items = new ConcurrentDictionary <object, object>();
}
public async ValueTask <IGame?> CreateAsync(IClient?owner, GameOptionsData options)
{
var @event = new GameCreationEvent(this, owner);
await _eventManager.CallAsync(@event);
if (@event.IsCancelled)
{
return(null);
}
// TODO: Prevent duplicates when using server redirector using INodeProvider.
(bool success, Game? game) = await TryCreateAsync(options, @event.GameCode);
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);
}
/// <summary>
/// Deserialize a packet.
/// </summary>
/// <param name="reader"><see cref="IMessageReader" /> with <see cref="IMessageReader.Tag" /> 0.</param>
/// <param name="chatMode">The chat type selected in the client of the player.</param>
/// <returns>Deserialized <see cref="GameOptionsData" />.</returns>
public static GameOptionsData Deserialize(IMessageReader reader, out QuickChatModes chatMode)
{
var gameOptionsData = GameOptionsData.DeserializeCreate(reader);
chatMode = (QuickChatModes)reader.ReadByte();
return(gameOptionsData);
}
/// <summary>
/// Deserialize a packet.
/// </summary>
/// <param name="reader"><see cref="IMessageReader" /> with <see cref="IMessageReader.Tag" /> 0.</param>
/// <param name="chatType">The chat type selected in the client of the player.</param>
/// <returns>Deserialized <see cref="GameOptionsData" />.</returns>
public static GameOptionsData Deserialize(IMessageReader reader, out ChatType chatType)
{
var gameOptionsData = GameOptionsData.DeserializeCreate(reader);
chatType = (ChatType)reader.ReadByte();
return(gameOptionsData);
}
public static GetGameListV2Request Deserialize(HazelBinaryReader reader)
{
var msg = new GetGameListV2Request();
reader.ReadPackedInt32(); // Hardcoded 0.
msg.options = GameOptionsData.Deserialize(reader.ReadBytesAndSize());
return(msg);
}
public async Task UpdateGameOptions(Guid userId, GameOptionsData options)
{
EnsureUserIsOnline(userId);
EnsureGameIsNotStarted();
_mapEditor.Generate(options);
var mapUpdated = new MapUpdated(_state.RoomId, _state.MapEditor.Map);
await _hub.NotifyEverybody(mapUpdated);
}
public static void Postfix(GameOptionsData OMFKMPLOPPM)
{
if (PlayerControl.AllPlayerControls.Count > 1)
{
MessageWriter writer = AmongUsClient.Instance.StartRpc(PlayerControl.LocalPlayer.NetId, (byte)CustomRPC.SyncCustomSettingsJester, Hazel.SendOption.Reliable);
writer.Write(Jester.jesterEnabled);
writer.EndMessage();
}
}
public static bool Prefix(out GameOptionsData __result)
{
SaveManager.hostOptionsData ??= SaveManager.LoadGameOptions("gameHostOptions");
SaveManager.hostOptionsData.NumImpostors = Mathf.Clamp(SaveManager.hostOptionsData.NumImpostors, 1, SaveManager.hostOptionsData.MaxPlayers - 1);
SaveManager.hostOptionsData.KillDistance = Mathf.Clamp(SaveManager.hostOptionsData.KillDistance, 0, 2);
__result = SaveManager.hostOptionsData;
return(false);
}
/// <summary>
/// Triggered when the connected client requests the game listing.
/// </summary>
/// <param name="options">
/// All options given.
/// At this moment, the client can only specify the map, impostor count and chat language.
/// </param>
private ValueTask OnRequestGameListAsync(GameOptionsData options)
{
using MessageWriter? message = MessageWriter.Get(MessageType.Reliable);
var games = _gameManager.FindListings((MapFlags)options.Map, options.NumImpostors, options.Keywords);
Message16GetGameListS2C.Serialize(message, games);
return(Connection.SendAsync(message));
}
public static RpcSyncSettings Deserialize(HazelBinaryReader reader)
{
var msg = new RpcSyncSettings();
var body = reader.ReadBytesToEnd();
msg.gameOptions = GameOptionsData.Deserialize(body);
return(msg);
}
public void LoadOptions()
{
if (File.Exists(Application.persistentDataPath + "/options.dat"))
{
BinaryFormatter bf = new BinaryFormatter();
FileStream file = File.Open(Application.persistentDataPath + "/options.dat", FileMode.Open);
m_GameOptions = (GameOptionsData)bf.Deserialize(file);
file.Close();
}
}
/// <summary>
/// Triggered when the connected client requests the game listing.
/// </summary>
/// <param name="options">
/// All options given.
/// At this moment, the client can only specify the map, impostor count and chat language.
/// </param>
public void OnRequestGameList(GameOptionsData options)
{
using (var message = MessageWriter.Get(SendOption.Reliable))
{
var games = _gameManager.FindListings((MapFlags)options.MapId, options.NumImpostors, options.Keywords);
Message16GetGameListV2.Serialize(message, games);
Client.Send(message);
}
}
public static bool Prefix(out GameOptionsData __result)
{
SaveManager.hostOptionsData ??= SaveManager.Method_59("gameHostOptions"); // LoadGameOptions
// patched because of impostor clamping
SaveManager.hostOptionsData.NumImpostors =
Mathf.Clamp(SaveManager.hostOptionsData.NumImpostors, 1, SaveManager.hostOptionsData.MaxPlayers - 1);
SaveManager.hostOptionsData.KillDistance = Mathf.Clamp(SaveManager.hostOptionsData.KillDistance, 0, 2);
__result = SaveManager.hostOptionsData;
return(false);
}
public Game(GameManager gameManager, int code, GameOptionsData options)
{
_gameManager = gameManager;
_players = new ConcurrentDictionary <int, ClientPlayer>();
_bannedIps = new HashSet <IPAddress>();
Code = code;
CodeStr = GameCode.IntToGameName(code);
HostId = -1;
GameState = GameStates.NotStarted;
Options = options;
}
public static void Serialize(IMessageWriter writer, GameOptionsData gameOptionsData)
{
writer.StartMessage(MessageFlags.HostGame);
using (var memory = new MemoryStream())
using (var writerBin = new BinaryWriter(memory))
{
gameOptionsData.Serialize(writerBin, GameOptionsData.LatestVersion);
writer.WriteBytesAndSize(memory.ToArray());
}
writer.EndMessage();
}
/// <summary>
/// Triggered when the connected client requests the game listing.
/// </summary>
/// <param name="options">
/// All options given.
/// At this moment, the client can only specify the map, impostor count and chat language.
/// </param>
private ValueTask OnRequestGameListAsync(GameOptionsData options)
{
using var message = MessageWriter.Get(MessageType.Reliable);
var games = _gameManager.FindListings((MapFlags)options.MapId, options.NumImpostors, options.Keywords);
var skeldGameCount = _gameManager.GetGameCount(MapFlags.Skeld);
var miraHqGameCount = _gameManager.GetGameCount(MapFlags.MiraHQ);
var polusGameCount = _gameManager.GetGameCount(MapFlags.Polus);
Message16GetGameListS2C.Serialize(message, skeldGameCount, miraHqGameCount, polusGameCount, games);
return(Connection.SendAsync(message));
}
public Game Create(Client owner, GameOptionsData options)
{
var gameCode = GameCode.GenerateCode(6);
var game = new Game(this, gameCode, options);
if (_games.TryAdd(gameCode, game))
{
Logger.Debug("Created game with code {0} ({1}).", GameCode.IntToGameName(gameCode), gameCode);
return(game);
}
Logger.Warning("Failed to create game.");
return(null);
}
public static void Postfix(GameOptionsData IOFBPLNIJIC)
{
if (PlayerControl.AllPlayerControls.Count > 1)
{
foreach (var opt in lobbyOptions)
{
MessageWriter messageWriter =
AmongUsClient.Instance.StartRpc(PlayerControl.LocalPlayer.NetId, opt.rpcId,
SendOption.Reliable);
messageWriter.WriteBytesAndSize(opt.ToBytes());
messageWriter.EndMessage();
}
}
}
public Task UpdateGameOptions(GameOptionsData options)
{
if (options == null)
{
throw new ArgumentNullException(nameof(options));
}
var command = new UpdateGameOptionsCommand
{
RoomId = _roomId,
Options = options
};
return(_context.Send(command));
}
public static void setLegalSettings()
{
GameOptionsData hostOptions = SaveManager.GameHostOptions;
GameOptionsData searchOptions = SaveManager.GameSearchOptions;
if (searchOptions.MapId == 0)
{
searchOptions.ToggleMapFilter(0); // ToggleMapFilter
}
hostOptions.NumImpostors = searchOptions.NumImpostors = 1; // NumImpostors
hostOptions.MaxPlayers = searchOptions.MaxPlayers = 4; // MaxPlayers
SaveManager.GameHostOptions = hostOptions;
SaveManager.GameSearchOptions = searchOptions;
}
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, GameCode?desiredGameCode = null)
{
GameCode gameCode = desiredGameCode ?? _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 Create(GameOptionsData options)
{
// TODO: Prevent duplicates when using server redirector using INodeProvider.
var gameCode = GameCode.GenerateCode(6);
var gameCodeStr = GameCode.IntToGameName(gameCode);
var game = new Game(this, _nodeLocator, _publicIp, gameCode, options);
if (_nodeLocator.Find(gameCodeStr) == null &&
_games.TryAdd(gameCode, game))
{
_nodeLocator.Save(gameCodeStr, _publicIp);
_logger.LogDebug("Created game with code {0} ({1}).", game.CodeStr, gameCode);
return(game);
}
_logger.LogWarning("Failed to create game.");
return(null);
}
/// <summary>
/// This is used to generate individual GameOptionsData packets.
/// </summary>
/// <param name="data">The options to serialize.</param>
/// <param name="game">The Game's ID.</param>
/// <param name="netId">The NetId of the player (as found in the Character.NetId property).</param>
/// <returns>A packet that can be sent to the client directly.</returns>
public IMessageWriter GenerateDataPacket(GameOptionsData data, int game, uint netId)
{
var writer = Provider.Get(MessageType.Reliable);
writer.StartMessage(Api.Net.Messages.MessageFlags.GameData);
writer.Write(game);
writer.StartMessage((byte)GameDataType.RpcFlag);
writer.WritePacked(netId);
writer.Write((byte)Structures.RpcCalls.SyncSettings);
using (var stream = new MemoryStream())
using (BinaryWriter bWriter = new BinaryWriter(stream))
{
data.Serialize(bWriter, 4);
writer.WriteBytesAndSize(stream.ToArray());
}
writer.EndMessage();
writer.EndMessage();
return(writer);
}
public void Generate(GameOptionsData options)
{
if (options == null)
{
throw new ArgumentNullException(nameof(options));
}
options.EnsureIsValid(new GameOptionsValidator(_state.Players.Count));
var currentOptions = new GameOptionsData
{
MapHeight = _state.Map.Height,
MapWidth = _state.Map.Width,
NeutralPlanetsCount = _state.NeutralPlanetsCount
};
if (currentOptions != options)
{
_state.NeutralPlanetsCount = options.NeutralPlanetsCount;
_map.Reset(options.MapWidth, options.MapHeight);
}
Generate();
}
public static void Deserialize(IMessageReader reader, out GameOptionsData options)
{
reader.ReadPackedInt32(); // Hardcoded 0.
options = GameOptionsData.DeserializeCreate(reader);
}
public override async ValueTask HandleMessageAsync(IMessageReader reader, MessageType messageType)
{
byte flag = reader.Tag;
_logger.LogTrace("[{0}] Server got {1}.", Id, flag);
switch (flag)
{
case MessageFlags.HostGame:
{
// Read game settings.
GameOptionsData gameInfo = Message00HostGameC2S.Deserialize(reader, out _);
// Create game.
IGame?game = await _gameManager.CreateAsync(this, gameInfo);
if (game == null)
{
await DisconnectAsync(DisconnectReason.GameMissing);
return;
}
// Code in the packet below will be used in JoinGame.
using (var writer = MessageWriter.Get(MessageType.Reliable))
{
Message00HostGameS2C.Serialize(writer, game.Code);
await Connection.SendAsync(writer);
}
break;
}
case MessageFlags.JoinGame:
{
Message01JoinGameC2S.Deserialize(reader, out GameCode gameCode);
Game?game = _gameManager.Find(gameCode);
if (game == null)
{
await DisconnectAsync(DisconnectReason.GameMissing);
return;
}
GameJoinResult result = await game.AddClientAsync(this);
switch (result.Error)
{
case GameJoinError.None:
break;
case GameJoinError.InvalidClient:
await DisconnectAsync(DisconnectReason.Custom, "Client is in an invalid state.");
break;
case GameJoinError.Banned:
await DisconnectAsync(DisconnectReason.Banned);
break;
case GameJoinError.GameFull:
await DisconnectAsync(DisconnectReason.GameFull);
break;
case GameJoinError.InvalidLimbo:
await DisconnectAsync(DisconnectReason.Custom, "Invalid limbo state while joining.");
break;
case GameJoinError.GameStarted:
await DisconnectAsync(DisconnectReason.GameStarted);
break;
case GameJoinError.GameDestroyed:
await DisconnectAsync(DisconnectReason.Custom, DisconnectMessages.Destroyed);
break;
case GameJoinError.Custom:
await DisconnectAsync(DisconnectReason.Custom, result.Message);
break;
default:
await DisconnectAsync(DisconnectReason.Custom, "Unknown error.");
break;
}
break;
}
case MessageFlags.StartGame:
{
if (!IsPacketAllowed(reader, true))
{
return;
}
await Player !.Game.HandleStartGame(reader);
break;
}
// No idea how this flag is triggered.
case MessageFlags.RemoveGame:
break;
case MessageFlags.RemovePlayer:
{
if (!IsPacketAllowed(reader, true))
{
return;
}
Message04RemovePlayerC2S.Deserialize(
reader,
out int playerId,
out byte reason);
await Player !.Game.HandleRemovePlayer(playerId, (DisconnectReason)reason);
break;
}
case MessageFlags.GameData:
case MessageFlags.GameDataTo:
{
if (!IsPacketAllowed(reader, false))
{
return;
}
bool toPlayer = flag == MessageFlags.GameDataTo;
int position = reader.Position;
bool verified = await Player !.Game.HandleGameDataAsync(reader, Player, toPlayer);
reader.Seek(position);
if (verified && Player != null)
{
// Broadcast packet to all other players.
using (var writer = MessageWriter.Get(messageType))
{
if (toPlayer)
{
int target = reader.ReadPackedInt32();
reader.CopyTo(writer);
await Player.Game.SendToAsync(writer, target);
}
else
{
reader.CopyTo(writer);
await Player.Game.SendToAllExceptAsync(writer, Id);
}
}
}
break;
}
case MessageFlags.EndGame:
{
if (!IsPacketAllowed(reader, true))
{
return;
}
Message08EndGameC2S.Deserialize(
reader,
out GameOverReason gameOverReason);
await Player !.Game.HandleEndGame(reader, gameOverReason);
break;
}
case MessageFlags.AlterGame:
{
if (!IsPacketAllowed(reader, true))
{
return;
}
Message10AlterGameC2S.Deserialize(
reader,
out AlterGameTags gameTag,
out bool value);
if (gameTag != AlterGameTags.ChangePrivacy)
{
return;
}
await Player !.Game.HandleAlterGame(reader, Player, value);
break;
}
case MessageFlags.KickPlayer:
{
if (!IsPacketAllowed(reader, true))
{
return;
}
Message11KickPlayerC2S.Deserialize(
reader,
out int playerId,
out bool isBan);
await Player !.Game.HandleKickPlayer(playerId, isBan);
break;
}
case MessageFlags.GetGameListV2:
{
Message16GetGameListC2S.Deserialize(reader, out var options, out _);
await OnRequestGameListAsync(options);
break;
}
default:
if (_customMessageManager.TryGet(flag, out var customRootMessage))
{
await customRootMessage.HandleMessageAsync(this, reader, messageType);
break;
}
_logger.LogWarning("Server received unknown flag {0}.", flag);
break;
}
#if DEBUG
if (flag != MessageFlags.GameData &&
flag != MessageFlags.GameDataTo &&
flag != MessageFlags.EndGame &&
reader.Position < reader.Length)
{
_logger.LogWarning(
"Server did not consume all bytes from {0} ({1} < {2}).",
flag,
reader.Position,
reader.Length);
}
#endif
}
public static void showInfoOverlay()
{
if (overlayShown || MapOptions.hideSettings)
{
return;
}
HudManager hudManager = DestroyableSingleton <HudManager> .Instance;
if (ShipStatus.Instance == null || PlayerControl.LocalPlayer == null || hudManager == null || HudManager.Instance.IsIntroDisplayed || (!PlayerControl.LocalPlayer.CanMove && MeetingHud.Instance == null))
{
return;
}
if (!initializeOverlays())
{
return;
}
hideRoleOverlay();
if (MapBehaviour.Instance != null)
{
MapBehaviour.Instance.Close();
}
hudManager.SetHudActive(false);
overlayShown = true;
Transform parent;
if (MeetingHud.Instance != null)
{
parent = MeetingHud.Instance.transform;
}
else
{
parent = hudManager.transform;
}
infoUnderlay.transform.parent = parent;
infoOverlayRules.transform.parent = parent;
infoOverlayRoles.transform.parent = parent;
infoUnderlay.sprite = colorBG;
infoUnderlay.color = new Color(0.1f, 0.1f, 0.1f, 0.88f);
infoUnderlay.transform.localScale = new Vector3(7.5f, 5f, 1f);
infoUnderlay.enabled = true;
TheOtherRolesPlugin.optionsPage = 0;
GameOptionsData o = PlayerControl.GameOptions;
List <string> gameOptions = o.ToString().Split("\n", StringSplitOptions.RemoveEmptyEntries).ToList().GetRange(2, 17);
infoOverlayRules.text = string.Join("\n", gameOptions) + "\n\n" + GameOptionsDataPatch.optionsToString(CustomOptionHolder.specialOptions);
infoOverlayRules.enabled = true;
string rolesText = "";
foreach (RoleInfo r in RoleInfo.getRoleInfoForPlayer(PlayerControl.LocalPlayer))
{
string roleOptions = r.roleOptions;
string roleDesc = r.fullDescription;
rolesText += $"<size=150%>{r.nameColored}</size>" +
(roleDesc != "" ? $"\n{r.fullDescription}" : "") + "\n\n" +
(roleOptions != "" ? $"{roleOptions}\n\n" : "");
}
infoOverlayRoles.text = rolesText;
infoOverlayRoles.enabled = true;
var underlayTransparent = new Color(0.1f, 0.1f, 0.1f, 0.0f);
var underlayOpaque = new Color(0.1f, 0.1f, 0.1f, 0.88f);
HudManager.Instance.StartCoroutine(Effects.Lerp(0.2f, new Action <float>(t =>
{
infoUnderlay.color = Color.Lerp(underlayTransparent, underlayOpaque, t);
infoOverlayRules.color = Color.Lerp(Palette.ClearWhite, Palette.White, t);
infoOverlayRoles.color = Color.Lerp(Palette.ClearWhite, Palette.White, t);
})));
}
public void UpdateUserOptions(GameOptionsData options)
{
if (this.UpdateUserOptions_Callback == null)
{
this.UpdateUserOptions_Callback = new AsyncCallback(this.OurRemoteAsyncCallBack_UpdateUserOptions);
}
RemoteAsyncDelegate_UpdateUserOptions options2 = new RemoteAsyncDelegate_UpdateUserOptions(this.service.UpdateUserOptions);
this.registerRPCcall(options2.BeginInvoke(this.UserID, this.SessionID, options, this.UpdateUserOptions_Callback, null), typeof(UpdateUserOptions_ReturnType));
}
