public override async ValueTask DeserializeAsync(IClientPlayer sender, IClientPlayer?target, IMessageReader reader, bool initialState)
{
var sequenceId = reader.ReadUInt16();
if (initialState)
{
_lastSequenceId = sequenceId;
await SetPositionAsync(sender, reader.ReadVector2(), reader.ReadVector2());
}
else
{
if (!await ValidateOwnership(CheatContext.Deserialize, sender) || !await ValidateBroadcast(CheatContext.Deserialize, sender, target))
{
return;
}
if (!SidGreaterThan(sequenceId, _lastSequenceId))
{
return;
}
_lastSequenceId = sequenceId;
await SetPositionAsync(sender, reader.ReadVector2(), reader.ReadVector2());
}
}
public override async ValueTask DeserializeAsync(IClientPlayer sender, IClientPlayer?target, IMessageReader reader, bool initialState)
{
if (!await ValidateHost(CheatContext.Deserialize, sender) || !await ValidateBroadcast(CheatContext.Deserialize, sender, target))
{
return;
}
if (initialState)
{
// TODO: (_systems[SystemTypes.Doors] as DoorsSystemType).SetDoors();
foreach (var systemType in SystemTypeHelpers.AllTypes)
{
if (_systems.TryGetValue(systemType, out var system))
{
system.Deserialize(reader, true);
}
}
}
else
{
var count = reader.ReadPackedUInt32();
foreach (var systemType in SystemTypeHelpers.AllTypes)
{
// TODO: Not sure what is going on here, check.
if ((count & 1 << (int)(systemType & (SystemTypes.ShipTasks | SystemTypes.Doors))) != 0L)
{
if (_systems.TryGetValue(systemType, out var system))
{
system.Deserialize(reader, false);
}
}
}
}
}
public override async ValueTask DeserializeAsync(IClientPlayer sender, IClientPlayer?target, IMessageReader reader, bool initialState)
{
if (!await ValidateHost(CheatContext.Deserialize, sender))
{
return;
}
var votes = _votes;
var unknown = reader.ReadByte();
if (unknown != 0)
{
for (var i = 0; i < unknown; i++)
{
var v4 = reader.ReadInt32();
if (v4 == 0)
{
break;
}
if (!votes.TryGetValue(v4, out var v12))
{
v12 = new int[3];
votes[v4] = v12;
}
for (var j = 0; j < 3; j++)
{
v12[j] = reader.ReadPackedInt32();
}
}
}
}
public override async ValueTask DeserializeAsync(IClientPlayer sender, IClientPlayer?target, IMessageReader reader, bool initialState)
{
if (!await ValidateHost(CheatContext.Deserialize, sender) || !await ValidateBroadcast(CheatContext.Deserialize, sender, target))
{
return;
}
if (initialState)
{
PopulateButtons(0);
foreach (var playerState in _playerStates)
{
playerState.Deserialize(reader);
if (playerState.DidReport)
{
ReporterId = playerState.TargetPlayerId;
}
}
}
else
{
uint num = reader.ReadPackedUInt32();
for (int i = 0; i < _playerStates.Length; i++)
{
if ((num & 1 << i) != 0)
{
_playerStates[i].Deserialize(reader);
}
}
}
}
public override async ValueTask DeserializeAsync(IClientPlayer sender, IClientPlayer?target, IMessageReader reader, bool initialState)
{
if (!await ValidateHost(CheatContext.Deserialize, sender))
{
return;
}
if (initialState)
{
var num = reader.ReadPackedInt32();
for (var i = 0; i < num; i++)
{
var playerId = reader.ReadByte();
var playerInfo = new InnerPlayerInfo(playerId);
playerInfo.Deserialize(reader);
if (!_allPlayers.TryAdd(playerInfo.PlayerId, playerInfo))
{
throw new ImpostorException("Failed to add player to InnerGameData.");
}
}
}
else
{
throw new NotImplementedException("This shouldn't happen, according to Among Us disassembly.");
}
}
public override async ValueTask DeserializeAsync(IClientPlayer sender, IClientPlayer?target, IMessageReader reader, bool initialState)
{
if (!await ValidateHost(CheatContext.Deserialize, sender))
{
return;
}
if (initialState)
{
IsNew = reader.ReadBoolean();
}
PlayerId = reader.ReadByte();
}
public override void Deserialize(IClientPlayer sender, IClientPlayer?target, IMessageReader reader, bool initialState)
{
if (!sender.IsHost)
{
// throw new ImpostorCheatException($"Client attempted to send data for {nameof(InnerPlayerControl)} as non-host");
}
if (initialState)
{
IsNew = reader.ReadBoolean();
}
PlayerId = reader.ReadByte();
}
public override async ValueTask DeserializeAsync(IClientPlayer sender, IClientPlayer?target, IMessageReader reader, bool initialState)
{
if (!await ValidateHost(CheatContext.Deserialize, sender))
{
return;
}
if (initialState)
{
var num = reader.ReadPackedInt32();
for (var i = 0; i < num; i++)
{
var playerId = reader.ReadByte();
var playerInfo = new InnerPlayerInfo(playerId);
playerInfo.Deserialize(reader);
if (!_allPlayers.TryAdd(playerInfo.PlayerId, playerInfo))
{
throw new ImpostorException("Failed to add player to InnerGameData.");
}
}
}
else
{
while (reader.Position < reader.Length)
{
var inner = reader.ReadMessage();
var playerInfo = this.GetPlayerById(inner.Tag);
if (playerInfo != null)
{
playerInfo.Deserialize(inner);
}
else
{
playerInfo = new InnerPlayerInfo(inner.Tag);
playerInfo.Deserialize(inner);
if (!_allPlayers.TryAdd(playerInfo.PlayerId, playerInfo))
{
throw new ImpostorException("Failed to add player to InnerGameData.");
}
}
}
}
}
public override async ValueTask DeserializeAsync(IClientPlayer sender, IClientPlayer?target, IMessageReader reader, bool initialState)
{
if (!sender.IsHost)
{
if (await sender.Client.ReportCheatAsync(CheatContext.Deserialize, $"Client attempted to send data for {nameof(InnerShipStatus)} as non-host"))
{
return;
}
}
if (target != null)
{
if (await sender.Client.ReportCheatAsync(CheatContext.Deserialize, $"Client attempted to send {nameof(InnerShipStatus)} data to a specific player, must be broadcast"))
{
return;
}
}
if (initialState)
{
// TODO: (_systems[SystemTypes.Doors] as DoorsSystemType).SetDoors();
foreach (var systemType in SystemTypeHelpers.AllTypes)
{
if (_systems.TryGetValue(systemType, out var system))
{
system.Deserialize(reader, true);
}
}
}
else
{
var count = reader.ReadPackedUInt32();
foreach (var systemType in SystemTypeHelpers.AllTypes)
{
// TODO: Not sure what is going on here, check.
if ((count & 1 << (int)(systemType & (SystemTypes.ShipTasks | SystemTypes.Doors))) != 0L)
{
if (_systems.TryGetValue(systemType, out var system))
{
system.Deserialize(reader, false);
}
}
}
}
}
public override async ValueTask DeserializeAsync(IClientPlayer sender, IClientPlayer?target, IMessageReader reader, bool initialState)
{
if (!sender.IsHost)
{
if (await sender.Client.ReportCheatAsync(CheatContext.Deserialize, $"Client attempted to send data for {nameof(InnerPlayerControl)} as non-host"))
{
return;
}
}
if (initialState)
{
IsNew = reader.ReadBoolean();
}
PlayerId = reader.ReadByte();
}
public override async ValueTask DeserializeAsync(IClientPlayer sender, IClientPlayer?target, IMessageReader reader, bool initialState)
{
if (!await ValidateHost(CheatContext.Deserialize, sender) || !await ValidateBroadcast(CheatContext.Deserialize, sender, target))
{
return;
}
while (reader.Position < reader.Length)
{
var messageReader = reader.ReadMessage();
var type = (SystemTypes)messageReader.Tag;
if (_systems.TryGetValue(type, out var value))
{
value.Deserialize(messageReader, initialState);
}
}
}
public override async ValueTask DeserializeAsync(IClientPlayer sender, IClientPlayer?target, IMessageReader reader, bool initialState)
{
if (!sender.IsHost)
{
if (await sender.Client.ReportCheatAsync(CheatContext.Deserialize, $"Client attempted to send data for {nameof(InnerMeetingHud)} as non-host"))
{
return;
}
}
if (target != null)
{
if (await sender.Client.ReportCheatAsync(CheatContext.Deserialize, $"Client attempted to send {nameof(InnerMeetingHud)} data to a specific player, must be broadcast"))
{
return;
}
}
if (initialState)
{
PopulateButtons(0);
foreach (var playerState in _playerStates)
{
playerState.Deserialize(reader);
if (playerState.DidReport)
{
ReporterId = playerState.TargetPlayerId;
}
}
}
else
{
var num = reader.ReadPackedUInt32();
for (var i = 0; i < _playerStates.Length; i++)
{
if ((num & 1 << i) != 0)
{
_playerStates[i].Deserialize(reader);
}
}
}
}
public override ValueTask DeserializeAsync(IClientPlayer sender, IClientPlayer?target, IMessageReader reader, bool initialState)
{
if (!sender.IsHost)
{
throw new ImpostorCheatException($"Client attempted to send data for {nameof(InnerShipStatus)} as non-host");
}
if (target != null)
{
throw new ImpostorCheatException($"Client attempted to send {nameof(InnerShipStatus)} data to a specific player, must be broadcast");
}
if (initialState)
{
// TODO: (_systems[SystemTypes.Doors] as DoorsSystemType).SetDoors();
foreach (var systemType in SystemTypeHelpers.AllTypes)
{
if (_systems.TryGetValue(systemType, out var system))
{
system.Deserialize(reader, true, _eventManager);
}
}
}
else
{
var count = reader.ReadPackedUInt32();
foreach (var systemType in SystemTypeHelpers.AllTypes)
{
// TODO: Not sure what is going on here, check.
if ((count & 1 << (int)(systemType & (SystemTypes.ShipTasks | SystemTypes.Doors))) != 0L)
{
if (_systems.TryGetValue(systemType, out var system))
{
system.Deserialize(reader, false, _eventManager);
}
}
}
}
return(ValueTask.CompletedTask);
}
public override async ValueTask DeserializeAsync(IClientPlayer sender, IClientPlayer?target, IMessageReader reader, bool initialState)
{
var sequenceId = reader.ReadUInt16();
if (initialState)
{
_lastSequenceId = sequenceId;
await SetPositionAsync(sender, reader.ReadVector2());
_targetSyncVelocity = reader.ReadVector2();
}
else
{
if (!sender.IsOwner(this))
{
if (await sender.Client.ReportCheatAsync(CheatContext.Deserialize, $"Client attempted to send unowned {nameof(InnerCustomNetworkTransform)} data"))
{
return;
}
}
if (target != null)
{
if (await sender.Client.ReportCheatAsync(CheatContext.Deserialize, $"Client attempted to send {nameof(InnerCustomNetworkTransform)} data to a specific player, must be broadcast"))
{
return;
}
}
if (!SidGreaterThan(sequenceId, _lastSequenceId))
{
return;
}
_lastSequenceId = sequenceId;
await SetPositionAsync(sender, reader.ReadVector2());
_targetSyncVelocity = reader.ReadVector2();
}
}
public override void Deserialize(IClientPlayer sender, IClientPlayer? target, IMessageReader reader, bool initialState)
{
if (!sender.IsHost)
{
throw new ImpostorCheatException($"Client attempted to send data for {nameof(InnerMeetingHud)} as non-host");
}
if (target != null)
{
throw new ImpostorCheatException($"Client attempted to send {nameof(InnerMeetingHud)} data to a specific player, must be broadcast");
}
if (initialState)
{
PopulateButtons(0);
foreach (var playerState in _playerStates)
{
playerState.Deserialize(reader);
if (playerState.DidReport)
{
ReporterId = playerState.TargetPlayerId;
}
}
}
else
{
var num = reader.ReadPackedUInt32();
for (var i = 0; i < _playerStates.Length; i++)
{
if ((num & 1 << i) != 0)
{
_playerStates[i].Deserialize(reader);
}
}
}
}
public override async ValueTask DeserializeAsync(IClientPlayer sender, IClientPlayer?target, IMessageReader reader, bool initialState)
{
if (!sender.IsHost)
{
if (await sender.Client.ReportCheatAsync(CheatContext.Deserialize, $"Client attempted to send data for {nameof(InnerShipStatus)} as non-host"))
{
return;
}
}
var votes = _votes;
var unknown = reader.ReadByte();
if (unknown != 0)
{
for (var i = 0; i < unknown; i++)
{
var v4 = reader.ReadInt32();
if (v4 == 0)
{
break;
}
if (!votes.TryGetValue(v4, out var v12))
{
v12 = new int[3];
votes[v4] = v12;
}
for (var j = 0; j < 3; j++)
{
v12[j] = reader.ReadPackedInt32();
}
}
}
}
public override void Deserialize(IClientPlayer sender, IClientPlayer?target, IMessageReader reader, bool initialState)
{
throw new System.NotImplementedException();
}
public ValueTask <bool> HandleAsync(IInnerNetObject innerNetObject, IClientPlayer sender, IClientPlayer?target, IMessageReader reader)
{
return(HandleAsync((T)innerNetObject, sender, target, reader));
}
public abstract ValueTask <bool> HandleAsync(T player, IClientPlayer sender, IClientPlayer?target, IMessageReader reader);
public abstract ValueTask DeserializeAsync(IClientPlayer sender, IClientPlayer?target, IMessageReader reader, bool initialState);
public abstract void Deserialize(IClientPlayer sender, IClientPlayer?target, IMessageReader reader, bool initialState);
private GameJoinResult(GameJoinError error, string?message = null, IClientPlayer?player = null)
{
Error = error;
Message = message;
Player = player;
}
public override async ValueTask <bool> HandleAsync(IInnerPlayerControl player, IClientPlayer sender, IClientPlayer?target, IMessageReader reader)
{
Deserialize(reader, out var text);
_logger.LogInformation("{player} said {text}", player.PlayerInfo.PlayerName, text);
await SendAsync(player, $"Send: from server responding to {player.PlayerInfo.PlayerName}");
return(true);
}
protected async ValueTask <bool> ValidateCmd(CheatContext context, IClientPlayer sender, IClientPlayer?target)
{
if (target == null || !target.IsHost)
{
if (await sender.Client.ReportCheatAsync(context, "Failed cmd check"))
{
return(false);
}
}
return(true);
}
protected async ValueTask <bool> ValidateBroadcast(CheatContext context, IClientPlayer sender, IClientPlayer?target)
{
if (target != null)
{
if (await sender.Client.ReportCheatAsync(context, "Failed broadcast check"))
{
return(false);
}
}
return(true);
}
public GameHostChangedEvent(IGame game, IClientPlayer previousHost, IClientPlayer?newHost)
{
Game = game;
PreviousHost = previousHost;
NewHost = newHost;
}
public ValueTask <bool> HandleAsync(IInnerNetObject innerNetObject, IClientPlayer sender, IClientPlayer?target, IMessageReader reader)
{
throw new NotSupportedException();
}
public override ValueTask DeserializeAsync(IClientPlayer sender, IClientPlayer?target, IMessageReader reader, bool initialState)
{
throw new NotImplementedException();
}
public async ValueTask <bool> HandleRpcAsync(IInnerNetObject innerNetObject, IClientPlayer sender, IClientPlayer?target, IMessageReader reader)
{
var clientInfo = sender.Client.GetReactor();
if (clientInfo == null)
{
await sender.Client.ReportCheatAsync(new CheatContext(nameof(Rpc255Reactor)), "Client tried to send reactor custom rpc without completing handshake");
return(false);
}
Deserialize(reader, out var modNetId, out var rpcId);
var mod = clientInfo.Mods.Single(x => x.NetId == modNetId);
_logger.LogTrace("Received custom rpc: {rpcId} from mod {mod}", rpcId, mod.Id);
var relay = true;
var messageReader = reader.ReadMessage();
var customRpc = _manager.Rpcs.SingleOrDefault(x => x.ModId == mod.Id && x.Id == rpcId);
if (customRpc != null)
{
if (!await customRpc.HandleAsync(innerNetObject, sender, target, messageReader.Copy()))
{
relay = false;
}
}
customRpc ??= new DummyReactorCustomRpc(mod.Id, rpcId);
if (relay)
{
var game = innerNetObject.Game;
var data = _writerProvider.Get();
Buffer.BlockCopy(messageReader.Buffer, messageReader.Offset, data.Buffer, data.Position, messageReader.Length);
data.Position += messageReader.Length;
if (data.Position > data.Length)
{
data.Length = data.Position;
}
if (target != null)
{
await innerNetObject.SendReactorRpcAsync(target.Client, customRpc, data, target.Client.Id);
}
else
{
foreach (var targetPlayer in game.Players.Where(x => x != sender))
{
await innerNetObject.SendReactorRpcAsync(targetPlayer.Client, customRpc, data);
}
}
}
return(false);
}