public void Load()
{
if (savedVessel != null && savedSubspace != null)
{
if ((UnityEngine.Time.realtimeSinceStartup - lastLoadTime) > 5f)
{
lastLoadTime = UnityEngine.Time.realtimeSinceStartup;
TimeSyncer.fetch.UnlockSubspace();
long serverClock = TimeSyncer.fetch.GetServerClock();
int newSubspace = TimeSyncer.fetch.LockNewSubspace(serverClock, savedSubspace.planetTime, savedSubspace.subspaceSpeed);
using (MessageWriter mw = new MessageWriter())
{
mw.Write<int>((int)WarpMessageType.NEW_SUBSPACE);
mw.Write<string>(Settings.fetch.playerName);
mw.Write<int>(newSubspace);
mw.Write<long>(serverClock);
mw.Write<double>(savedSubspace.planetTime);
mw.Write<float>(savedSubspace.subspaceSpeed);
NetworkWorker.fetch.SendWarpMessage(mw.GetMessageBytes());
}
TimeSyncer.fetch.LockSubspace(newSubspace);
VesselWorker.fetch.LoadVessel(savedVessel);
ScreenMessages.PostScreenMessage("Quickloaded!", 3f, ScreenMessageStyle.UPPER_CENTER);
}
}
else
{
ScreenMessages.PostScreenMessage("No current quicksave to load from!", 3f, ScreenMessageStyle.UPPER_CENTER);
}
}
/// <summary>
/// Write the constraint description to a MessageWriter
/// </summary>
/// <param name="writer">The writer on which the description is displayed</param>
public override void WriteDescriptionTo(MessageWriter writer)
{
writer.WritePredicate("String starting with");
writer.WriteExpectedValue(MsgUtils.ClipString(expected, writer.MaxLineLength - 40, 0));
if (this.caseInsensitive)
writer.WriteModifier("ignoring case");
}
public override void WriteDescriptionTo(MessageWriter writer)
{
foreach (var msg in messages)
{
msg.Invoke(writer);
}
}
public static void SendScenarioModules(ClientObject client)
{
int numberOfScenarioModules = Directory.GetFiles(Path.Combine(Server.universeDirectory, "Scenarios", client.playerName)).Length;
int currentScenarioModule = 0;
string[] scenarioNames = new string[numberOfScenarioModules];
byte[][] scenarioDataArray = new byte[numberOfScenarioModules][];
foreach (string file in Directory.GetFiles(Path.Combine(Server.universeDirectory, "Scenarios", client.playerName)))
{
//Remove the .txt part for the name
scenarioNames[currentScenarioModule] = Path.GetFileNameWithoutExtension(file);
scenarioDataArray[currentScenarioModule] = File.ReadAllBytes(file);
currentScenarioModule++;
}
ServerMessage newMessage = new ServerMessage();
newMessage.type = ServerMessageType.SCENARIO_DATA;
using (MessageWriter mw = new MessageWriter())
{
mw.Write<string[]>(scenarioNames);
foreach (byte[] scenarioData in scenarioDataArray)
{
if (client.compressionEnabled)
{
mw.Write<byte[]>(Compression.CompressIfNeeded(scenarioData));
}
else
{
mw.Write<byte[]>(Compression.AddCompressionHeader(scenarioData, false));
}
}
newMessage.data = mw.GetMessageBytes();
}
ClientHandler.SendToClient(client, newMessage, true);
}
/// <summary>
/// Writes the <see cref="UpgradeBuildingCommand"/> to the specified <see cref="MessageWriter"/>.
/// </summary>
/// <param name="writer">
/// <see cref="MessageWriter"/> that will be used to write the <see cref="UpgradeBuildingCommand"/>.
/// </param>
public override void WriteCommand(MessageWriter writer)
{
writer.Write(BuildingGameIndex);
writer.Write(Unknown1);
writer.Write(Unknown2);
}
public static void SendAllPlayerColors(ClientObject client)
{
Dictionary<string,float[]> sendColors = new Dictionary<string, float[]>();
foreach (ClientObject otherClient in ClientHandler.GetClients())
{
if (otherClient.authenticated && otherClient.playerColor != null)
{
if (otherClient != client)
{
sendColors[otherClient.playerName] = otherClient.playerColor;
}
}
}
ServerMessage newMessage = new ServerMessage();
newMessage.type = ServerMessageType.PLAYER_COLOR;
using (MessageWriter mw = new MessageWriter())
{
mw.Write<int>((int)PlayerColorMessageType.LIST);
mw.Write<int>(sendColors.Count);
foreach (KeyValuePair<string, float[]> kvp in sendColors)
{
mw.Write<string>(kvp.Key);
mw.Write<float[]>(kvp.Value);
}
newMessage.data = mw.GetMessageBytes();
}
ClientHandler.SendToClient(client, newMessage, true);
}
public PageUrlValidator(NameValueCollection queryString, DataManager manager)
{
_queryString = queryString;
_isValid = false;
_manager = manager;
_writer = new MessageWriter();
}
public async Task WritesMessage()
{
MemoryStream outputStream = new MemoryStream();
MessageWriter messageWriter =
new MessageWriter(
outputStream,
this.messageSerializer);
// Write the message and then roll back the stream to be read
// TODO: This will need to be redone!
await messageWriter.WriteMessage(Message.Event("testEvent", null));
outputStream.Seek(0, SeekOrigin.Begin);
string expectedHeaderString =
string.Format(
Constants.ContentLengthFormatString,
ExpectedMessageByteCount);
byte[] buffer = new byte[128];
await outputStream.ReadAsync(buffer, 0, expectedHeaderString.Length);
Assert.Equal(
expectedHeaderString,
Encoding.ASCII.GetString(buffer, 0, expectedHeaderString.Length));
// Read the message
await outputStream.ReadAsync(buffer, 0, ExpectedMessageByteCount);
Assert.Equal(
TestEventString,
Encoding.UTF8.GetString(buffer, 0, ExpectedMessageByteCount));
outputStream.Dispose();
}
/// <summary>
/// Write the constraint description to a MessageWriter
/// </summary>
/// <param name="writer">The writer on which the description is displayed</param>
public override void WriteDescriptionTo(MessageWriter writer)
{
writer.WritePredicate("String ending with");
writer.WriteExpectedValue(expected);
if (this.caseInsensitive)
writer.WriteModifier("ignoring case");
}
public static void RunNukeKSC(string commandText)
{
lock (Server.universeSizeLock)
{
string[] vesselList = Directory.GetFiles(Path.Combine(Server.universeDirectory, "Vessels"));
int numberOfRemovals = 0;
foreach (string vesselFile in vesselList)
{
string vesselID = Path.GetFileNameWithoutExtension(vesselFile);
bool landedAtKSC = false;
bool landedAtRunway = false;
using (StreamReader sr = new StreamReader(vesselFile))
{
string currentLine = sr.ReadLine();
while (currentLine != null && !landedAtKSC && !landedAtRunway)
{
string trimmedLine = currentLine.Trim();
if (trimmedLine.StartsWith("landedAt = "))
{
string landedAt = trimmedLine.Substring(trimmedLine.IndexOf("=") + 2);
if (landedAt == "KSC")
{
landedAtKSC = true;
}
if (landedAt == "Runway")
{
landedAtRunway = true;
}
}
currentLine = sr.ReadLine();
}
}
if (landedAtKSC | landedAtRunway)
{
DarkLog.Normal("Removing vessel: " + vesselID);
//Delete it from the universe
if (File.Exists(vesselFile))
{
File.Delete(vesselFile);
}
//Send a vessel remove message
ServerMessage newMessage = new ServerMessage();
newMessage.type = ServerMessageType.VESSEL_REMOVE;
using (MessageWriter mw = new MessageWriter())
{
//Send it with a delete time of 0 so it shows up for all players.
mw.Write<int>(0);
mw.Write<double>(0);
mw.Write<string>(vesselID);
mw.Write<bool>(false);
newMessage.data = mw.GetMessageBytes();
}
ClientHandler.SendToAll(null, newMessage, false);
numberOfRemovals++;
}
}
DarkLog.Normal("Nuked " + numberOfRemovals + " vessels around the KSC");
}
}
/// <summary>
/// Writes the <see cref="BuyBuildingCommand"/> to the specified <see cref="MessageWriter"/>.
/// </summary>
/// <param name="writer">
/// <see cref="MessageWriter"/> that will be used to write the <see cref="BuyBuildingCommand"/>.
/// </param>
public override void WriteCommand(MessageWriter writer)
{
writer.Write(X);
writer.Write(Y);
writer.Write(BuildingDataIndex);
writer.Write(Unknown1);
}
/// <summary>
/// Writes the <see cref="BuyDecoration"/> to the specified <see cref="MessageWriter"/>.
/// </summary>
/// <param name="writer">
/// <see cref="MessageWriter"/> that will be used to write the <see cref="BuyDecoration"/>.
/// </param>
public override void WriteCommand(MessageWriter writer)
{
writer.Write(X);
writer.Write(Y);
writer.Write(DecorationDataIndex);
writer.Write(Unknown1);
}
public async Task<StreamResponse> HandleAsync(MessageWriter messageWriter, CancellationToken cancellationToken)
{
if (messageWriter == null)
{
throw new ArgumentNullException("messageWriter");
}
if (cancellationToken == null)
{
throw new ArgumentNullException("cancellationToken");
}
this.messageWriter = messageWriter;
log.Trace("HandleAsync: '{0}' JobId: '{1}''", request.Handle, request.JobId);
StreamResponse streamResponse = null;
Job job = GetJobById(request.JobId, ref streamResponse); // if job is null, streamResponse is set to error
if (job != null)
{
if (job.HasStatus)
{
var awaitables = new List<Task>();
foreach (IJobStatus status in job.RetrieveStatus())
{
awaitables.Add(ListenStatusAsync(status));
}
await Task.WhenAll(awaitables);
}
try
{
if (job.IsCompleted)
{
if (job.Result == null)
{
streamResponse = ToStreamResponse(GetResponseData(true, "Error! Job with ID '{0}' is completed but no result is available!\n", request.JobId));
}
else
{
streamResponse = ToStreamResponse(job.Result);
}
}
else
{
job.AttachListener(this);
IJobResult result = await job.ListenAsync();
streamResponse = StreamResponse.Create(result.ExitCode);
}
}
finally
{
jobManager.RemoveJob(request.JobId);
}
}
return streamResponse;
}
public override void WriteDescriptionTo(MessageWriter writer)
{
if (!(actual is SilverFunction)) {
writer.WriteLine("Expected SilverFunction, but got {0} instead", actual.GetType());
}
else {
writer.WriteLine("Expected {0}, but got {1} instead", actual, Expected);
}
}
public override void WriteActualValueTo(MessageWriter writer)
{
if (this.propertyExists) {
writer.WriteActualValue(this.propValue);
}
else {
writer.WriteActualValue(String.Format("The property {0} was not found on type {1}", name, base.actual.GetType()));
}
}
/// <summary>
/// Writes the <see cref="OwnHomeDataMessage"/> to the specified <see cref="MessageWriter"/>.
/// </summary>
/// <param name="writer">
/// <see cref="MessageWriter"/> that will be used to write the <see cref="OwnHomeDataMessage"/>.
/// </param>
public override void WriteMessage(MessageWriter writer)
{
if (OwnAvatarData == null) // quit early just not to mess up the stream
throw new NullReferenceException("OwnAvatarData was null.");
writer.Write((int)LastVisit.TotalSeconds);
writer.Write(Unknown1); // -1
writer.Write((int)DateTimeConverter.ToUnixTimestamp(Timestamp));
OwnAvatarData.Write(writer);
}
/// <summary>
/// Constructor for ClientConnection
/// </summary>
/// <param name="id">ClientID is an id representing this connection</param>
/// <param name="connection">This is a TCPConnection representing the connection to the client</param>
/// <param name="MessageReceived">This is a delegate representing the method to be called when a message is received</param>
/// <param name="ConnectionFailed">This is a delegate representing the method to be called when the connection fails</param>
/// <param name="MessageFailed">This is a delegate representing the method to be called when a corrupt message is received</param>
public ClientConnection(TCPConnection connection)
{
this.buffer = new Buffer<AbstractMessage>();
this.connection = connection;
ClientID = new ClientID();
terminating = false;
hasStarted = false;
writer = new MessageWriter(this, connection);
reader = new MessageReader(this, connection);
}
public void Write_WritesMessageToStorage()
{
var message = new Message("This is my message");
var mockStorage = Substitute.For<IPersistentStorage>();
var messageWriter = new MessageWriter(mockStorage);
messageWriter.Write(message);
mockStorage.Received(1).Write(Arg.Any<byte[]>());
}
/// <summary>
/// Writes the <see cref="NewClientEncryptionMessage"/> to the specified <see cref="MessageWriter"/>.
/// </summary>
/// <param name="writer">
/// <see cref="MessageWriter"/> that will be used to write the <see cref="NewClientEncryptionMessage"/>.
/// </param>
public override void WriteMessage(MessageWriter writer)
{
writer.Write(Unknown1);
writer.Write(Unknown2);
writer.Write(MajorVersion);
writer.Write(Unknown4);
writer.Write(MinorVersion);
writer.Write(Hash);
writer.Write(Unknown6);
writer.Write(Unknown7);
}
/// <summary>
/// Writes the <see cref="MoveVillageObjectCommand"/> to the specified <see cref="MessageWriter"/>.
/// </summary>
/// <param name="writer">
/// <see cref="MessageWriter"/> that will be used to write the <see cref="MoveVillageObjectCommand"/>.
/// </param>
/// <exception cref="NullReferenceException">MoveData is null.</exception>
public override void WriteCommand(MessageWriter writer)
{
if (MoveData == null)
throw new NullReferenceException("MoveData cannot be null");
writer.Write(MoveData.X);
writer.Write(MoveData.Y);
writer.Write(MoveData.VillageObjectGameIndex);
writer.Write(Unknown1);
}
public static void SendConnectionEnd(ClientObject client, string reason)
{
ServerMessage newMessage = new ServerMessage();
newMessage.type = ServerMessageType.CONNECTION_END;
using (MessageWriter mw = new MessageWriter())
{
mw.Write<string>(reason);
newMessage.data = mw.GetMessageBytes();
}
ClientHandler.SendToClient(client, newMessage, true);
}
public static void SendConsoleMessageToClient(ClientObject client, string message)
{
ServerMessage newMessage = new ServerMessage();
newMessage.type = ServerMessageType.CHAT_MESSAGE;
using (MessageWriter mw = new MessageWriter())
{
mw.Write<int>((int)ChatMessageType.CONSOLE_MESSAGE);
mw.Write<string>(message);
newMessage.data = mw.GetMessageBytes();
}
ClientHandler.SendToClient(client, newMessage, false);
}
public static MessageWriter CreateAndInitWriter(CloudBlobContainer container)
{
container.CreateIfNotExists();
var dataBlob = container.GetPageBlobReference(Constants.StreamFileName);
var posBlob = container.GetPageBlobReference(Constants.PositionFileName);
var pageWriter = new CloudPageWriter(dataBlob);
var posWriter = new CloudCheckpointWriter(posBlob);
var writer = new MessageWriter(pageWriter, posWriter);
writer.Init();
return writer;
}
internal void WriteHeaderToMessage (MessageWriter writer)
{
writer.Write ((byte)Endianness);
writer.Write ((byte)MessageType);
writer.Write ((byte)Flags);
writer.Write (MajorVersion);
writer.Write (Length);
writer.Write (Serial);
writer.WriteHeaderFields (fields);
writer.CloseWrite ();
}
public static void SendDMPModMessageToAll(ClientObject excludeClient, string modName, byte[] messageData, bool highPriority)
{
ServerMessage newMessage = new ServerMessage();
newMessage.type = ServerMessageType.MOD_DATA;
using (MessageWriter mw = new MessageWriter())
{
mw.Write<string>(modName);
mw.Write<byte[]>(messageData);
newMessage.data = mw.GetMessageBytes();
}
ClientHandler.SendToAll(excludeClient, newMessage, highPriority);
}
public static void SendAllAdmins(ClientObject client)
{
ServerMessage newMessage = new ServerMessage();
newMessage.type = ServerMessageType.ADMIN_SYSTEM;
using (MessageWriter mw = new MessageWriter())
{
mw.Write((int)AdminMessageType.LIST);
mw.Write<string[]>(DarkMultiPlayerServer.AdminSystem.fetch.GetAdmins());
newMessage.data = mw.GetMessageBytes();
}
ClientHandler.SendToClient(client, newMessage, true);
}
/// <summary>
/// Writes the <see cref="MoveVillageObjectCommand"/> to the specified <see cref="MessageWriter"/>.
/// </summary>
/// <param name="writer">
/// <see cref="MessageWriter"/> that will be used to write the <see cref="MoveVillageObjectCommand"/>.
/// </param>
/// <exception cref="NullReferenceException">MovesData is null.</exception>
public override void WriteCommand(MessageWriter writer)
{
if (MovesData == null)
throw new NullReferenceException("MovesData cannot be null");
for (int i = 0; i < MovesData.Length; i++)
{
writer.Write(MovesData[i].X);
writer.Write(MovesData[i].Y);
writer.Write(MovesData[i].VillageObjectGameIndex);
}
writer.Write(Unknown1);
}
public static void SendHandshakeChallange(ClientObject client)
{
client.challange = new byte[1024];
Random rand = new Random();
rand.NextBytes(client.challange);
ServerMessage newMessage = new ServerMessage();
newMessage.type = ServerMessageType.HANDSHAKE_CHALLANGE;
using (MessageWriter mw = new MessageWriter())
{
mw.Write<byte[]>(client.challange);
newMessage.data = mw.GetMessageBytes();
}
ClientHandler.SendToClient(client, newMessage, true);
}
public static void SendChatMessageToClient(ClientObject client, string messageText)
{
ServerMessage newMessage = new ServerMessage();
newMessage.type = ServerMessageType.CHAT_MESSAGE;
using (MessageWriter mw = new MessageWriter())
{
mw.Write<int>((int)ChatMessageType.PRIVATE_MESSAGE);
mw.Write<string>(Settings.settingsStore.consoleIdentifier);
mw.Write<string>(client.playerName);
mw.Write(messageText);
newMessage.data = mw.GetMessageBytes();
}
ClientHandler.SendToClient(client, newMessage, true);
}
public void AcquireLock(string lockName, bool force)
{
lock (lockObject)
{
using (MessageWriter mw = new MessageWriter())
{
mw.Write<int>((int)LockMessageType.ACQUIRE);
mw.Write<string>(Settings.fetch.playerName);
mw.Write<string>(lockName);
mw.Write<bool>(force);
NetworkWorker.fetch.SendLockSystemMessage(mw.GetMessageBytes());
}
}
}
new public static compilation visit(compilation ast, TextWriter w, string[] args, MessageWriter msg)
{
if (msg.Count == 0)
{
(new typeswitch_ilgen(w, msg)).compilation(ast);
}
return(ast);
}
/// <summary>
/// Write the failure message to the MessageWriter provided
/// as an argument. The default implementation simply passes
/// the constraint and the actual value to the writer, which
/// then displays the constraint description and the value.
///
/// Constraints that need to provide additional details,
/// such as where the error occured can override this.
/// </summary>
/// <param name="writer">The MessageWriter on which to display the message</param>
public virtual void WriteMessageTo(MessageWriter writer)
{
writer.DisplayDifferences(this);
}
public override void WriteDescriptionTo(MessageWriter writer)
{
throw new System.NotImplementedException();
}
public override void WriteDescriptionTo(MessageWriter writer)
{
writer.WriteExpectedValue(failingExpected);
}
public override void WriteDescriptionTo(MessageWriter writer)
{
writer.WriteExpectedValue("an adult person at the age of at least 18");
}
public override async ValueTask HandleMessageAsync(IMessageReader reader, MessageType messageType)
{
var flag = reader.Tag;
_logger.LogTrace("[{0}] Server got {1}.", Id, flag);
switch (flag)
{
case MessageFlags.HostGame:
{
// Read game settings.
var gameInfo = Message00HostGameC2S.Deserialize(reader);
// Create game.
var game = await _gameManager.CreateAsync(gameInfo);
// 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 var gameCode,
out _);
var game = _gameManager.Find(gameCode);
if (game == null)
{
await DisconnectAsync(DisconnectReason.GameMissing);
return;
}
var 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 var playerId,
out var reason);
await Player.Game.HandleRemovePlayer(playerId, (DisconnectReason)reason);
break;
}
case MessageFlags.GameData:
case MessageFlags.GameDataTo:
{
if (!IsPacketAllowed(reader, false))
{
return;
}
var toPlayer = flag == MessageFlags.GameDataTo;
// Handle packet.
using var readerCopy = reader.Copy();
// TODO: Return value, either a bool (to cancel) or a writer (to cancel (null) or modify/overwrite).
try
{
var verified = await Player.Game.HandleGameDataAsync(readerCopy, Player, toPlayer);
if (verified)
{
// Broadcast packet to all other players.
using (var writer = MessageWriter.Get(messageType))
{
if (toPlayer)
{
var target = reader.ReadPackedInt32();
reader.CopyTo(writer);
await Player.Game.SendToAsync(writer, target);
}
else
{
reader.CopyTo(writer);
await Player.Game.SendToAllExceptAsync(writer, Id);
}
}
}
}
catch (ImpostorCheatException e)
{
if (_antiCheatConfig.BanIpFromGame)
{
Player.Game.BanIp(Connection.EndPoint.Address);
}
await DisconnectAsync(DisconnectReason.Hacking, e.Message);
}
break;
}
case MessageFlags.EndGame:
{
if (!IsPacketAllowed(reader, true))
{
return;
}
await Player.Game.HandleEndGame(reader);
break;
}
case MessageFlags.AlterGame:
{
if (!IsPacketAllowed(reader, true))
{
return;
}
Message10AlterGameC2S.Deserialize(
reader,
out var gameTag,
out var 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 var playerId,
out var isBan);
await Player.Game.HandleKickPlayer(playerId, isBan);
break;
}
case MessageFlags.GetGameListV2:
{
Message16GetGameListC2S.Deserialize(reader, out var options);
await OnRequestGameListAsync(options);
break;
}
default:
_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 override void WriteDescriptionTo(MessageWriter writer)
{
writer.Write(Status);
}
public static void Postfix(Il2CppReferenceArray <GameData.PlayerInfo> JPGEIBIBJPJ)
{
Main.Logic.AllModPlayerControl.Clear();
Main.Logic.WinReason = WinReasons.Crewmates;
MessageWriter writer = AmongUsClient.Instance.StartRpcImmediately(PlayerControl.LocalPlayer.NetId,
(byte)CustomRPC.ResetVariables, Hazel.SendOption.None, -1);
AmongUsClient.Instance.FinishRpcImmediately(writer);
List <PlayerControl> crewmates = PlayerTools.getCrewMates();
foreach (PlayerControl player in PlayerControl.AllPlayerControls.ToArray())
{
Main.Logic.AllModPlayerControl.Add(new ModPlayerControl {
PlayerControl = player, Role = "Impostor", reportsLeft = MaxReportCount.GetValue(), LastAbilityTime = null
});
}
foreach (PlayerControl player in crewmates)
{
player.getModdedControl().Role = "Crewmate";
}
if (crewmates.Count > 0 && (rng.Next(0, 100) <= JesterSpawnChance.GetValue()))
{
var idx = rng.Next(0, crewmates.Count);
crewmates[idx].getModdedControl().Role = "Jester";
byte JesterId = crewmates[idx].PlayerId;
crewmates.RemoveAt(idx);
writer = AmongUsClient.Instance.StartRpcImmediately(PlayerControl.LocalPlayer.NetId,
(byte)CustomRPC.SetJester, Hazel.SendOption.None, -1);
writer.Write(JesterId);
AmongUsClient.Instance.FinishRpcImmediately(writer);
}
if (crewmates.Count > 0 && (rng.Next(0, 100) <= SheriffSpawnChance.GetValue()))
{
var idx = rng.Next(0, crewmates.Count);
crewmates[idx].getModdedControl().Role = "Sheriff";
byte SheriffId = crewmates[idx].PlayerId;
crewmates.RemoveAt(idx);
writer = AmongUsClient.Instance.StartRpcImmediately(PlayerControl.LocalPlayer.NetId,
(byte)CustomRPC.SetSheriff, Hazel.SendOption.None, -1);
writer.Write(SheriffId);
AmongUsClient.Instance.FinishRpcImmediately(writer);
}
localPlayers.Clear();
localPlayer = PlayerControl.LocalPlayer;
foreach (PlayerControl player in PlayerControl.AllPlayerControls)
{
if (player.Data.IsImpostor)
{
continue;
}
localPlayers.Add(player);
}
var localPlayerBytes = new List <byte>();
foreach (PlayerControl player in localPlayers)
{
localPlayerBytes.Add(player.PlayerId);
}
writer = AmongUsClient.Instance.StartRpcImmediately(PlayerControl.LocalPlayer.NetId, (byte)CustomRPC.SetLocalPlayers, Hazel.SendOption.None, -1);
writer.WriteBytesAndSize(localPlayerBytes.ToArray());
AmongUsClient.Instance.FinishRpcImmediately(writer);
}
/// <summary>
/// Writes the <see cref="AvatarMessageComponent"/> to the specified <see cref="MessageWriter"/>.
/// </summary>
/// <param name="writer">
/// <see cref="MessageWriter"/> that will be used to write the <see cref="AvatarMessageComponent"/>.
/// </param>
/// <exception cref="ArgumentNullException"><paramref name="writer"/> is null.</exception>
public override void WriteMessageComponent(MessageWriter writer)
{
ThrowIfWriterNull(writer);
writer.Write(UserId);
writer.Write(HomeId);
writer.Write(ClanData != null);
if (ClanData != null)
{
writer.Write(ClanData.Id);
writer.Write(ClanData.Name);
writer.Write(ClanData.Badge);
writer.Write((int)ClanData.Role);
writer.Write(ClanData.Level);
writer.Write(ClanData.Unknown1);
if (ClanData.Unknown1 == 1)
{
writer.Write(ClanData.Unknown2);
}
}
writer.Write(LegendaryTrophy);
writer.Write(BestSeasonEnabled);
writer.Write(BestSeasonMonth);
writer.Write(BestSeasonYear);
writer.Write(BestSeasonPosition);
writer.Write(BestSeasonTrophies);
writer.Write(LastSeasonEnabled);
writer.Write(LastSeasonMonth);
writer.Write(LastSeasonYear);
writer.Write(LastSeasonPosition); // 1
writer.Write(LastSeasonTrophies);
writer.Write(LeagueLevel);
writer.Write(AllianceCastleLevel);
writer.Write(AllianceCastleTotalCapacity);
writer.Write(AllianceCastleUsedCapacity);
writer.Write(Unknown13); // 1 = 8.x.x
writer.Write(Unknown14); // 0 = 8.x.x
writer.Write(TownHallLevel);
writer.Write(Name);
writer.Write(Unknown15); // -1
writer.Write(ExpLevels);
writer.Write(ExpPoints);
writer.Write(Gems);
writer.Write(FreeGems);
writer.Write(Unknown16); // 1200
writer.Write(Unknown17); // 60
writer.Write(Trophies);
writer.Write(AttacksWon);
writer.Write(AttacksLost);
writer.Write(DefensesWon);
writer.Write(DefensesLost);
writer.Write(Unknown18);
writer.Write(Unknown19);
writer.Write(Unknown20);
// 8.551.4
writer.Write(Unknown29);
writer.Write(Unknown21); // 1, might be a bool
writer.Write(Unknown22); // 946720861000
writer.Write(IsNamed);
writer.Write(Unknown23);
writer.Write(Unknown24);
writer.Write(Unknown25);
writer.Write(Unknown26); // 1
writer.Write(Unknown27); // 1 = 8.x.x
writer.Write(Unknown28); // 0 = 8.x.x
// 8.551.4
writer.Write(Unknown30);
writer.WriteSlotCollection(ResourcesCapacity);
writer.WriteSlotCollection(ResourcesAmount);
writer.WriteSlotCollection(Units);
writer.WriteSlotCollection(Spells);
writer.WriteSlotCollection(UnitUpgrades);
writer.WriteSlotCollection(SpellUpgrades);
writer.WriteSlotCollection(HeroUpgrades);
writer.WriteSlotCollection(HeroHealths);
writer.WriteSlotCollection(HeroStates);
writer.WriteSlotCollection(AllianceUnits);
writer.WriteSlotCollection(TutorialProgress);
writer.WriteSlotCollection(Achievements);
writer.WriteSlotCollection(AchievementProgress);
writer.WriteSlotCollection(NpcStars);
writer.WriteSlotCollection(NpcGold);
writer.WriteSlotCollection(NpcElixir);
writer.Write(Unknown31);
writer.WriteSlotCollection(UnknownSlot1);
writer.WriteSlotCollection(UnknownSlot2);
writer.WriteSlotCollection(UnknownSlot3);
writer.WriteSlotCollection(UnknownSlot4);
writer.WriteSlotCollection(UnknownSlot5);
writer.WriteSlotCollection(UnknownSlot6);
writer.WriteSlotCollection(UnknownSlot7);
writer.WriteSlotCollection(UnknownSlot8);
}
public override void WriteDescriptionTo(MessageWriter writer)
{
writer.WritePredicate("A fake object wrapper.");
}
public void GetLittleEndian()
{
Assert.IsTrue(MessageWriter.IsLittleEndian());
}
public override void WriteDescriptionTo(MessageWriter writer)
{
writer.WritePredicate("Path matching");
writer.WriteExpectedValue(expected);
}
public typeswitch_ilgen(TextWriter w, MessageWriter msg) : base(w, msg)
{
}
public override void WriteDescriptionTo(MessageWriter writer)
{
writer.Write(JToken.FromObject(Expected));
}
public void SendOutputMessage()
{
MessageWriter.ShipDataOutputMessage(Ship);
}
public void Send(MessageWriter writer)
{
Connection.Send(writer);
}
public override void WriteActualValueTo(MessageWriter writer)
{
writer.Write(actual);
}
public override void Write(MessageWriter writer, bool data)
{
writer.Write(data);
}
public static void Postfix(PlayerControl __instance, [HarmonyArgument(0)] PlayerControl target)
{
// Collect dead player info
DeadPlayer deadPlayer = new DeadPlayer(target, DateTime.UtcNow, DeathReason.Kill, __instance);
GameHistory.deadPlayers.Add(deadPlayer);
// Reset killer to crewmate if resetToCrewmate
if (resetToCrewmate)
{
__instance.Data.IsImpostor = false;
}
if (resetToDead)
{
__instance.Data.IsDead = true;
}
// Remove fake tasks when player dies
if (target.hasFakeTasks())
{
target.clearAllTasks();
}
// Lover suicide trigger on murder
if ((Lovers.lover1 != null && target == Lovers.lover1) || (Lovers.lover2 != null && target == Lovers.lover2))
{
PlayerControl otherLover = target == Lovers.lover1 ? Lovers.lover2 : Lovers.lover1;
if (PlayerControl.LocalPlayer == target && otherLover != null && !otherLover.Data.IsDead && Lovers.bothDie) // Only the dead lover sends the rpc
{
MessageWriter writer = AmongUsClient.Instance.StartRpcImmediately(PlayerControl.LocalPlayer.NetId, (byte)CustomRPC.LoverSuicide, Hazel.SendOption.Reliable, -1);
writer.Write(otherLover.PlayerId);
AmongUsClient.Instance.FinishRpcImmediately(writer);
RPCProcedure.loverSuicide(otherLover.PlayerId);
}
}
// Sidekick promotion trigger on murder
if (Sidekick.promotesToJackal && Sidekick.sidekick != null && !Sidekick.sidekick.Data.IsDead && target == Jackal.jackal && Jackal.jackal == PlayerControl.LocalPlayer)
{
MessageWriter writer = AmongUsClient.Instance.StartRpcImmediately(PlayerControl.LocalPlayer.NetId, (byte)CustomRPC.SidekickPromotes, Hazel.SendOption.Reliable, -1);
AmongUsClient.Instance.FinishRpcImmediately(writer);
RPCProcedure.sidekickPromotes();
}
// Cleaner Button Sync
if (Cleaner.cleaner != null && PlayerControl.LocalPlayer == Cleaner.cleaner && __instance == Cleaner.cleaner && HudManagerStartPatch.cleanerCleanButton != null)
{
HudManagerStartPatch.cleanerCleanButton.Timer = Cleaner.cleaner.killTimer;
}
// Warlock Button Sync
if (Warlock.warlock != null && PlayerControl.LocalPlayer == Warlock.warlock && __instance == Warlock.warlock && HudManagerStartPatch.warlockCurseButton != null)
{
if (Warlock.warlock.killTimer > HudManagerStartPatch.warlockCurseButton.Timer)
{
HudManagerStartPatch.warlockCurseButton.Timer = Warlock.warlock.killTimer;
}
}
// Seer show flash and add dead player position
if (Seer.seer != null && PlayerControl.LocalPlayer == Seer.seer && !Seer.seer.Data.IsDead && Seer.seer != target && Seer.mode <= 1)
{
HudManager.Instance.FullScreen.enabled = true;
HudManager.Instance.StartCoroutine(Effects.Lerp(1f, new Action <float>((p) => {
var renderer = HudManager.Instance.FullScreen;
if (p < 0.5)
{
if (renderer != null)
{
renderer.color = new Color(42f / 255f, 187f / 255f, 245f / 255f, Mathf.Clamp01(p * 2 * 0.75f));
}
}
else
{
if (renderer != null)
{
renderer.color = new Color(42f / 255f, 187f / 255f, 245f / 255f, Mathf.Clamp01((1 - p) * 2 * 0.75f));
}
}
if (p == 1f && renderer != null)
{
renderer.enabled = false;
}
})));
}
if (Seer.deadBodyPositions != null)
{
Seer.deadBodyPositions.Add(target.transform.position);
}
// Child set adapted kill cooldown
if (Child.child != null && PlayerControl.LocalPlayer == Child.child && Child.child.Data.IsImpostor && Child.child == __instance)
{
var multiplier = Child.isGrownUp() ? 0.66f : 2f;
Child.child.SetKillTimer(PlayerControl.GameOptions.KillCooldown * multiplier);
}
}
public override void WriteDescriptionTo(MessageWriter writer)
{
}
private void OnMessageReceived(MessageReader message, SendOption sendOption)
{
var flag = (RequestFlag)message.Tag;
Logger.Verbose("[{0}] Server got {1}.", Id, flag);
switch (flag)
{
case RequestFlag.HostGame:
{
// Read game settings.
var gameInfoBytes = message.ReadBytesAndSize();
var gameInfo = GameOptionsData.Deserialize(gameInfoBytes);
// Create game.
var game = _gameManager.Create(this, gameInfo);
if (game == null)
{
Connection.Send(new Message1DisconnectReason(DisconnectReason.ServerFull));
return;
}
// Code in the packet below will be used in JoinGame.
using (var writer = MessageWriter.Get(SendOption.Reliable))
{
writer.StartMessage(0);
writer.Write(game.Code);
writer.EndMessage();
Connection.Send(writer);
}
break;
}
case RequestFlag.JoinGame:
{
var gameCode = message.ReadInt32();
var unknown = message.ReadByte();
var game = _gameManager.Find(gameCode);
if (game == null)
{
Connection.Send(new Message1DisconnectReason(DisconnectReason.GameMissing));
return;
}
game.HandleJoinGame(Player);
break;
}
case RequestFlag.StartGame:
{
if (!IsPacketAllowed(message, true))
{
return;
}
Player.Game.HandleStartGame(message);
break;
}
// No idea how this flag is triggered.
case RequestFlag.RemoveGame:
break;
case RequestFlag.RemovePlayer:
{
if (!IsPacketAllowed(message, true))
{
return;
}
var playerId = message.ReadPackedInt32();
var reason = message.ReadByte();
Player.Game.HandleRemovePlayer(playerId, (DisconnectReason)reason);
break;
}
case RequestFlag.GameData:
case RequestFlag.GameDataTo:
{
if (!IsPacketAllowed(message, false))
{
return;
}
// Broadcast packet to all other players.
using (var writer = MessageWriter.Get(sendOption))
{
if (flag == RequestFlag.GameDataTo)
{
var target = message.ReadPackedInt32();
writer.CopyFrom(message);
Player.Game.SendTo(writer, target);
}
else
{
writer.CopyFrom(message);
Player.Game.SendToAllExcept(writer, Player);
}
}
break;
}
case RequestFlag.EndGame:
{
if (!IsPacketAllowed(message, true))
{
return;
}
Player.Game.HandleEndGame(message);
break;
}
case RequestFlag.AlterGame:
{
if (!IsPacketAllowed(message, true))
{
return;
}
if (message.ReadByte() != (byte)AlterGameTags.ChangePrivacy)
{
return;
}
var isPublic = message.ReadByte() == 1;
Player.Game.HandleAlterGame(message, Player, isPublic);
break;
}
case RequestFlag.KickPlayer:
{
if (!IsPacketAllowed(message, true))
{
return;
}
var playerId = message.ReadPackedInt32();
var isBan = message.ReadBoolean();
Player.Game.HandleKickPlayer(playerId, isBan);
break;
}
default:
Logger.Warning("Server received unknown flag {0}.", flag);
break;
}
if (flag != RequestFlag.GameData &&
flag != RequestFlag.GameDataTo &&
flag != RequestFlag.EndGame &&
message.Position < message.Length)
{
Logger.Warning("Server did not consume all bytes from {0} ({1} < {2}).",
flag,
message.Position,
message.Length);
}
}
/// <summary>
/// Write the constraint description to a MessageWriter
/// </summary>
/// <param name="writer">The writer on which the description is displayed</param>
public override void WriteDescriptionTo(MessageWriter writer)
{
writer.WriteExpectedValue(this.expected);
writer.WriteConnector("+/-");
writer.WriteExpectedValue(this.tolerance);
}
public override void WriteActualValueTo(MessageWriter writer)
{
writer.WriteActualValue(failingActual);
writer.WriteLine();
writer.Write(" On Property: " + failingPropertyName);
}
public async ValueTask <bool> HandleGameDataAsync(IMessageReader parent, ClientPlayer sender, bool toPlayer)
{
// Find target player.
ClientPlayer target = null;
if (toPlayer)
{
var targetId = parent.ReadPackedInt32();
if (targetId == FakeClientId && !_gamedataFakeReceived && sender.IsHost)
{
_gamedataFakeReceived = true;
// Remove the fake client, we received the data.
using (var message = MessageWriter.Get(MessageType.Reliable))
{
WriteRemovePlayerMessage(message, false, FakeClientId, (byte)DisconnectReason.ExitGame);
await sender.Client.Connection.SendAsync(message);
}
}
else if (!TryGetPlayer(targetId, out target))
{
_logger.LogWarning("Player {0} tried to send GameData to unknown player {1}.", sender.Client.Id, targetId);
return(false);
}
_logger.LogTrace("Received GameData for target {0}.", targetId);
}
// Parse GameData messages.
while (parent.Position < parent.Length)
{
using var reader = parent.ReadMessage();
switch (reader.Tag)
{
case GameDataTag.DataFlag:
{
var netId = reader.ReadPackedUInt32();
if (_allObjectsFast.TryGetValue(netId, out var obj))
{
await obj.DeserializeAsync(sender, target, reader, false);
}
else
{
_logger.LogWarning("Received DataFlag for unregistered NetId {0}.", netId);
}
break;
}
case GameDataTag.RpcFlag:
{
var netId = reader.ReadPackedUInt32();
if (_allObjectsFast.TryGetValue(netId, out var obj))
{
if (!await obj.HandleRpc(sender, target, (RpcCalls)reader.ReadByte(), reader))
{
return(false);
}
}
else
{
_logger.LogWarning("Received RpcFlag for unregistered NetId {0}.", netId);
}
break;
}
case GameDataTag.SpawnFlag:
{
// Only the host is allowed to despawn objects.
if (!sender.IsHost)
{
if (await sender.Client.ReportCheatAsync(new CheatContext(nameof(GameDataTag.SpawnFlag)), "Tried to send SpawnFlag as non-host."))
{
return(false);
}
}
var objectId = reader.ReadPackedUInt32();
if (objectId < SpawnableObjects.Length)
{
var innerNetObject = (InnerNetObject)ActivatorUtilities.CreateInstance(_serviceProvider, SpawnableObjects[objectId], this);
var ownerClientId = reader.ReadPackedInt32();
// Prevent fake client from being broadcasted.
// TODO: Remove message from stream properly.
if (ownerClientId == FakeClientId)
{
return(false);
}
innerNetObject.SpawnFlags = (SpawnFlags)reader.ReadByte();
var components = innerNetObject.GetComponentsInChildren <InnerNetObject>();
var componentsCount = reader.ReadPackedInt32();
if (componentsCount != components.Count)
{
_logger.LogError(
"Children didn't match for spawnable {0}, name {1} ({2} != {3})",
objectId,
innerNetObject.GetType().Name,
componentsCount,
components.Count);
continue;
}
_logger.LogDebug(
"Spawning {0} components, SpawnFlags {1}",
innerNetObject.GetType().Name,
innerNetObject.SpawnFlags);
for (var i = 0; i < componentsCount; i++)
{
var obj = components[i];
obj.NetId = reader.ReadPackedUInt32();
obj.OwnerId = ownerClientId;
_logger.LogDebug(
"- {0}, NetId {1}, OwnerId {2}",
obj.GetType().Name,
obj.NetId,
obj.OwnerId);
if (!AddNetObject(obj))
{
_logger.LogTrace("Failed to AddNetObject, it already exists.");
obj.NetId = uint.MaxValue;
break;
}
using var readerSub = reader.ReadMessage();
if (readerSub.Length > 0)
{
await obj.DeserializeAsync(sender, target, readerSub, true);
}
await OnSpawnAsync(obj);
}
continue;
}
_logger.LogError("Couldn't find spawnable object {0}.", objectId);
break;
}
// Only the host is allowed to despawn objects.
case GameDataTag.DespawnFlag:
{
var netId = reader.ReadPackedUInt32();
if (_allObjectsFast.TryGetValue(netId, out var obj))
{
if (sender.Client.Id != obj.OwnerId && !sender.IsHost)
{
_logger.LogWarning(
"Player {0} ({1}) tried to send DespawnFlag for {2} but was denied.",
sender.Client.Name,
sender.Client.Id,
netId);
return(false);
}
RemoveNetObject(obj);
await OnDestroyAsync(obj);
_logger.LogDebug("Destroyed InnerNetObject {0} ({1}), OwnerId {2}", obj.GetType().Name, netId, obj.OwnerId);
}
else
{
_logger.LogDebug(
"Player {0} ({1}) sent DespawnFlag for unregistered NetId {2}.",
sender.Client.Name,
sender.Client.Id,
netId);
}
break;
}
case GameDataTag.SceneChangeFlag:
{
// Sender is only allowed to change his own scene.
var clientId = reader.ReadPackedInt32();
if (clientId != sender.Client.Id)
{
_logger.LogWarning(
"Player {0} ({1}) tried to send SceneChangeFlag for another player.",
sender.Client.Name,
sender.Client.Id);
return(false);
}
sender.Scene = reader.ReadString();
_logger.LogTrace("> Scene {0} to {1}", clientId, sender.Scene);
break;
}
case GameDataTag.ReadyFlag:
{
var clientId = reader.ReadPackedInt32();
_logger.LogTrace("> IsReady {0}", clientId);
break;
}
default:
{
_logger.LogTrace("Bad GameData tag {0}", reader.Tag);
break;
}
}
if (sender.Client.Player == null)
{
// Disconnect handler was probably invoked, cancel the rest.
return(false);
}
}
return(true);
}
public abstract void UnsafeWrite(MessageWriter writer, object data);
public override async void Informar(string msg)
{
MessageWriter.WriteString(msg);
await MessageWriter.StoreAsync();
}
/// <summary> /// Write the constraint description to a MessageWriter /// </summary> /// <param name="writer">The writer on which the description is displayed</param> public abstract void WriteDescriptionTo(MessageWriter writer);
/// <summary>
/// Write a failure message. Overridden to provide custom failure
/// messages for EqualConstraint.
/// </summary>
/// <param name="writer">The MessageWriter to write to</param>
public override void WriteMessageTo(MessageWriter writer)
{
DisplayDifferences(writer, _expected, Actual, 0);
}
/// <summary>
/// Write the actual value for a failing constraint test to a
/// MessageWriter. The default implementation simply writes
/// the raw value of actual, leaving it to the writer to
/// perform any formatting.
/// </summary>
/// <param name="writer">The writer on which the actual value is displayed</param>
public virtual void WriteActualValueTo(MessageWriter writer)
{
writer.WriteActualValue(actual);
}
private static void SendNetworkMessage(ClientObject client, ServerMessage message)
{
//Write the send times down in SYNC_TIME_REPLY packets
if (message.type == ServerMessageType.SYNC_TIME_REPLY)
{
try
{
using (MessageWriter mw = new MessageWriter())
{
using (MessageReader mr = new MessageReader(message.data))
{
client.bytesQueuedOut += 8;
//Client send time
mw.Write <long>(mr.Read <long>());
//Server receive time
mw.Write <long>(mr.Read <long>());
//Server send time
mw.Write <long>(DateTime.UtcNow.Ticks);
message.data = mw.GetMessageBytes();
}
}
}
catch (Exception e)
{
DarkLog.Debug("Error rewriting SYNC_TIME packet, Exception " + e);
}
}
//Continue sending
byte[] messageBytes = Common.PrependNetworkFrame((int)message.type, message.data);
client.lastSendTime = Server.serverClock.ElapsedMilliseconds;
client.bytesQueuedOut -= messageBytes.Length;
client.bytesSent += messageBytes.Length;
if (client.connectionStatus == ConnectionStatus.CONNECTED)
{
try
{
client.connection.GetStream().Write(messageBytes, 0, messageBytes.Length);
}
catch (Exception e)
{
HandleDisconnectException("Send Network Message", client, e);
return;
}
}
DMPPluginHandler.FireOnMessageSent(client, message);
if (message.type == ServerMessageType.CONNECTION_END)
{
using (MessageReader mr = new MessageReader(message.data))
{
string reason = mr.Read <string>();
DarkLog.Normal("Disconnecting client " + client.playerName + ", sent CONNECTION_END (" + reason + ") to endpoint " + client.endpoint);
client.disconnectClient = true;
DisconnectClient(client);
}
}
if (message.type == ServerMessageType.HANDSHAKE_REPLY)
{
using (MessageReader mr = new MessageReader(message.data))
{
int response = mr.Read <int>();
string reason = mr.Read <string>();
if (response != 0)
{
DarkLog.Normal("Disconnecting client " + client.playerName + ", sent HANDSHAKE_REPLY (" + reason + ") to endpoint " + client.endpoint);
client.disconnectClient = true;
DisconnectClient(client);
}
}
}
}
