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