public override bool FormatOutput(IProcessorContext outgoing)
{
object source = outgoing.Source;
if (source == null) return true;
string output = source as string;
if (output == null) return false;
string mark = "-";
if (output == null) return false;
string buffer;
if (output.Length == 10)
{
// 012-345-6789
string buffer1 = output.Insert(6, mark);
buffer = buffer1.Insert(3, mark);
}
else if (output.Length == 7)
{
// 012-3456
buffer = output.Insert(3, mark);
}
else buffer = output;
outgoing.Target = buffer;
return true;
}
public override void ProcessPacket(Guid sourcePlayerId, Packet packet, IProcessorContext context)
{
UpdateDisasterPacket updateDisasterPacket = (UpdateDisasterPacket)packet;
ClientProcessorContext processorContext = (ClientProcessorContext)context;
processorContext.Client.DisasterManager.OnUpdateDisaster(updateDisasterPacket.CurrentTime);
}
public override void ProcessPacket(Guid sourcePlayerId, Packet packet, IProcessorContext context)
{
SessionDataPacket sessionDataPacket = (SessionDataPacket)packet;
ClientProcessorContext processorContext = (ClientProcessorContext)context;
processorContext.Client.OnSessionDataReceived(sessionDataPacket.SessionData);
}
public override void ProcessPacket(Guid sourcePlayerId, Packet packet, IProcessorContext context)
{
UpdateEnvironmentDataPacket updateEnvironmentDataPacket = (UpdateEnvironmentDataPacket)packet;
ClientProcessorContext processorContext = (ClientProcessorContext)context;
processorContext.Client.EnvironmentManager.OnUpdateEnvironmentData(updateEnvironmentDataPacket.Time, updateEnvironmentDataPacket.WindLevel, updateEnvironmentDataPacket.WindDirection);
}
public override void ProcessPacket(Guid sourcePlayerId, Packet packet, IProcessorContext context)
{
PlayerDisconnectedPacket playerDisconnectedPacket = (PlayerDisconnectedPacket)packet;
ClientProcessorContext processorContext = (ClientProcessorContext)context;
if (processorContext.Client.LocalPlayer.HasValue)
{
if (processorContext.Client.LocalPlayer.Value.Id != playerDisconnectedPacket.PlayerId)
{
Player player = processorContext.Client.PlayerManager.GetPlayer(playerDisconnectedPacket.PlayerId);
string reason = DisconnectReasonUtils.ReasonToString(playerDisconnectedPacket.Reason);
MessageLog.Show($"Player {player.Name} left the game: {reason}", null, MessageLogFlags.MessageSoundNormal);
}
if (processorContext.Client.LocalPlayer.Value.Id == playerDisconnectedPacket.PlayerId)
{
// The server has freed up resources associated with our player
// This may mean that we requested a disconnect
// or we're in for a big surprise
processorContext.Client.LocalPlayer = null;
}
}
processorContext.Client.PlayerManager.OnPlayerRemoved(playerDisconnectedPacket.PlayerId);
}
public override void Parse(System.IO.TextReader reader, IProcessorContext context)
{
lock (_syncRoot)
{
context.Output.Write(_compiler.CompileString(reader.ReadToEnd()));
}
}
public override void ProcessPacket(Guid sourcePlayerId, Packet packet, IProcessorContext context)
{
CreateDisasterPacket createDisasterPacket = (CreateDisasterPacket)packet;
ClientProcessorContext processorContext = (ClientProcessorContext)context;
processorContext.Client.DisasterManager.OnCreateDisaster(createDisasterPacket.Disaster);
}
public override void ProcessPacket(Guid sourcePlayerId, Packet packet, IProcessorContext context)
{
TimeScaleUpdatePacket timeScaleUpdatedPacket = (TimeScaleUpdatePacket)packet;
ClientProcessorContext processorContext = (ClientProcessorContext)context;
processorContext.Client.TimeManager.OnTimeScaleUpdated(timeScaleUpdatedPacket.TimeScale, timeScaleUpdatedPacket.IsPaused);
}
public virtual bool ExecuteFormat(IProcessorContext context)
{
bool okay = false;
string id = context.FieldKey;
object source = context.Source;
IFieldTable table = context.FieldTable;
IFieldContext fieldContext = table.GetFieldContext(id); // Enforces Strict
if ((fieldContext == null))
{
if (source == null)
context.Target = null;
else okay = FormatOutput(context);
return okay;
}
IProcessor processor = fieldContext.Processor;
if (processor == null)
okay = FormatOutput(context);
else
{
okay = processor.FormatOutput(context);
}
return okay;
}
public StringResourceIdProcessingStep(
IProcessorContext context,
[ContextGet(ProcessorContextKeys.MessageParameters)] IDictionary <string, string> parameters)
{
var resourceId = parameters[ProcessorContextKeys.ResourceId];
context.Set(resourceId, ProcessorContextKeys.ResourceId);
}
public override Task InitializeInstructionAsync(IProcessorContext context, params string[] parameters)
{
foreach (var file in Directory.EnumerateFiles(context.OutputDirectory, parameters.First(), SearchOption.AllDirectories))
{
File.Delete(file);
}
return(Task.CompletedTask);
}
public GuidResourceIdProcessingStep(
IProcessorContext context,
[ContextGet(ProcessorContextKeys.MessageParameters)] IDictionary <string, string> parameters)
{
var resourceId = parameters[ProcessorContextKeys.ResourceId];
var guid = Guid.Parse(resourceId);
context.Set(guid, ProcessorContextKeys.ResourceId);
}
public static bool TryGet(this IProcessorContext context, Type type, out object value)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
var result = context.TryGet(type, out value, ProcessorContextKeys.Default);
return(result);
}
public static bool TryReset <T>(this IProcessorContext context, string key)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
var result = context.TryReset(typeof(T), key);
return(result);
}
public static TDao AsModifiedAuditable <TDao>(this TDao dao, IProcessorContext context)
where TDao : AuditableDao
{
var userId = context.Get <string>(ProcessorContextKeys.UserId);
var utcTime = context.Get <DateTime>(ProcessorContextKeys.UTCTime);
dao.ModifiedByUserId = userId;
dao.ModificationDate = utcTime;
return(dao);
}
public override void ProcessPacket(Guid sourcePlayerId, Packet packet, IProcessorContext context)
{
ServerProcessorContext processorContext = (ServerProcessorContext)context;
PlayerManager playerManager = processorContext.Server.PlayerManager;
ServerSettings serverSettings = processorContext.Server.Settings;
SessionData sessionData = new SessionData(serverSettings.Name, serverSettings.PasswordProtected, playerManager.GetPlayerCount());
SessionDataPacket sessionDataPacket = new SessionDataPacket(sessionData);
processorContext.Server.SendPacketToPlayer(sessionDataPacket, sourcePlayerId);
}
public static void Reset(this IProcessorContext context, Type type, string key)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
if (!context.TryReset(type, key))
{
throw new ArgumentOutOfRangeException("key", key, string.Format(Resources.KeyNotFoundForGivenType, key, type.FullName));
}
}
public override void Parse(TextReader reader, IProcessorContext context)
{
if (AssetPipeline.MinifyJs)
{
var compressor = new JavaScriptCompressor(reader.ReadToEnd());
context.Output.Write(compressor.Compress());
}
else
{
context.Output.Write(reader.ReadToEnd());
}
}
public override void ProcessPacket(Guid sourcePlayerId, Packet packet, IProcessorContext context)
{
WorldDataPacket worldDataPacket = (WorldDataPacket)packet;
ClientProcessorContext processorContext = (ClientProcessorContext)context;
processorContext.Client.WorldStateManager.UpdateWorldData(worldDataPacket.World);
Debug.Log("Informing the server that we've started loading the world data");
ClientLoadingStartedPacket clientLoadingStartedPacket = new ClientLoadingStartedPacket();
processorContext.Client.SendPacket(clientLoadingStartedPacket);
}
public override void ProcessPacket(Guid sourcePlayerId, Packet packet, IProcessorContext context)
{
PlayerDataUpdatedPacket playerDataUpdatedPacket = (PlayerDataUpdatedPacket)packet;
ClientProcessorContext processorContext = (ClientProcessorContext)context;
processorContext.Client.PlayerManager.OnPlayerUpdated(playerDataUpdatedPacket.PlayerId, playerDataUpdatedPacket.Player);
if (playerDataUpdatedPacket.Player == processorContext.Client.LocalPlayer)
{
// Update the local client data
processorContext.Client.LocalPlayer = playerDataUpdatedPacket.Player;
}
}
public override void ProcessPacket(Guid sourcePlayerId, Packet packet, IProcessorContext context)
{
ServerProcessorContext processorContext = (ServerProcessorContext)context;
PlayerManager playerManager = processorContext.Server.PlayerManager;
if (!playerManager.PlayerExists(sourcePlayerId))
{
return; // what
}
Player player = playerManager.GetPlayer(sourcePlayerId);
player.State = PlayerState.ConnectedLoadingData;
playerManager.UpdatePlayer(player);
}
public static object Get(this IProcessorContext context, Type type, string key)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
object value;
if (!context.TryGet(type, out value, key))
{
throw new ArgumentOutOfRangeException("key", key, string.Format(Resources.KeyNotFoundForGivenType, key, type.FullName));
}
return(value);
}
public static bool TrySet <T>(this IProcessorContext context, T value, string key)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
if (ReferenceEquals(value, null))
{
throw new ArgumentNullException("value");
}
var result = context.TrySet(typeof(T), value, key);
return(result);
}
public static void Set(this IProcessorContext context, Type type, object value, string key)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
if (value == null)
{
throw new ArgumentNullException("value");
}
if (!context.TrySet(type, value, key))
{
throw new ArgumentOutOfRangeException("key", key, string.Format(Resources.KeyAlreadySetForGivenType, key, type.FullName));
}
}
public override void ProcessPacket(Guid sourcePlayerId, Packet packet, IProcessorContext context)
{
ServerProcessorContext processorContext = (ServerProcessorContext)context;
WorldDataPacket worldDataPacket = (WorldDataPacket)packet;
Player?simulationOwner = processorContext.Server.SimulationManager.GetSimulationOwner();
if (simulationOwner == null || sourcePlayerId != simulationOwner.Value.Id)
{
//Deny request if client isn't the simulation owner
return;
}
processorContext.Server.WorldStateManager.OnWorldDataReceived(worldDataPacket.World);
}
public override void ProcessPacket(Guid sourcePlayerId, Packet packet, IProcessorContext context)
{
ServerProcessorContext processorContext = (ServerProcessorContext)context;
SimulationManager simulationManager = processorContext.Server.SimulationManager;
DisasterManager disasterManager = processorContext.Server.DisasterManager;
Player?simulationOwner = simulationManager.GetSimulationOwner();
if (simulationOwner == null || sourcePlayerId != simulationOwner.Value.Id)
{
//Deny request if client isn't the simulation owner
return;
}
disasterManager.EndDisaster();
}
public override void ProcessPacket(Guid sourcePlayerId, Packet packet, IProcessorContext context)
{
UpdateEnvironmentDataPacket updateEnvironmentDataPacket = (UpdateEnvironmentDataPacket)packet;
ServerProcessorContext processorContext = (ServerProcessorContext)context;
SimulationManager simulationManager = processorContext.Server.SimulationManager;
EnvironmentManager environmentManager = processorContext.Server.EnvironmentManager;
Player?simulationOwner = simulationManager.GetSimulationOwner();
if (simulationOwner == null || sourcePlayerId != simulationOwner.Value.Id)
{
//Deny request if client isn't the simulation owner
return;
}
environmentManager.UpdateEnvironmentData(updateEnvironmentDataPacket.Time, updateEnvironmentDataPacket.WindLevel, updateEnvironmentDataPacket.WindDirection);
}
public static bool TryGet <T>(this IProcessorContext context, out T value, string key)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
object obj;
var result = context.TryGet(typeof(T), out obj, key);
if (result && obj is T)
{
value = (T)obj;
return(true);
}
value = default(T);
return(result);
}
public override bool FormatOutput(IProcessorContext outgoing)
{
ProcessorCommand formatter = new FormatOutput();
IList source = outgoing.Source as IList;
foreach (IKeyValue row in source)
{
string key = Key;
IRequestContext context = new RequestContext();
context[key] = row.Value;
context.FieldTable = outgoing.FieldTable;
IProcessorContext _context = new ProcessorContext(key, context);
formatter.ExecuteProcess(_context);
row.Value = _context.Target;
}
outgoing.Target = outgoing.Source;
return true;
}
public override bool ConvertInput(IProcessorContext incoming)
{
object source = incoming.Source;
if (source == null) return true;
string input = source as string;
if (input == null) return false;
char[] marks = {'-'};
string[] splits = input.Split(marks);
StringBuilder sb = new StringBuilder(input.Length);
foreach (string s in splits)
{
sb.Append(s);
}
incoming.Target = sb.ToString();
return true;
}
public override void ProcessPacket(Guid sourcePlayerId, Packet packet, IProcessorContext context)
{
ServerProcessorContext processorContext = (ServerProcessorContext)context;
AuthenticateRequestPacket authenticateRequestPacket = (AuthenticateRequestPacket)packet;
ServerSettings serverSettings = processorContext.Server.Settings;
PlayerManager playerManager = processorContext.Server.PlayerManager;
SimulationManager simulationManager = processorContext.Server.SimulationManager;
AuthenticatePacket authenticateResponsePacket;
if (playerManager.PlayerExists(sourcePlayerId))
{
return; // Player already authenticated
}
// Will fail if the requested username contains disallowed characters/does not meet length requirements/etc.
if (!playerManager.IsUsernameAllowed(authenticateRequestPacket.Username))
{
authenticateResponsePacket = new AuthenticatePacket(false, AuthenticationErrorReason.IllegalUsername, null, null, null);
Console.WriteLine($"Player {sourcePlayerId} attempted joining with an illegal username");
}
// Will fail if a player with the same nickname is already connected.
else if (playerManager.IsUsernameTaken(authenticateRequestPacket.Username))
{
authenticateResponsePacket = new AuthenticatePacket(false, AuthenticationErrorReason.UsernameTaken, null, null, null);
Console.WriteLine($"Player {sourcePlayerId} attempted joining with an already taken username: {authenticateRequestPacket.Username}");
}
// Will fail if the authenticating client provided an incorrect server password.
else if (serverSettings.PasswordProtected && serverSettings.Password != authenticateRequestPacket.Password)
{
authenticateResponsePacket = new AuthenticatePacket(false, AuthenticationErrorReason.IncorrectPassword, null, null, null);
Console.WriteLine($"Player {sourcePlayerId} attempted joining with an incorrect password");
}
// Approve authentication request and let other players know that a player joined.
else
{
Player client = playerManager.CreatePlayer(sourcePlayerId, authenticateRequestPacket.Username, state: PlayerState.ConnectedMainMenu);
Player[] players = playerManager.GetPlayers().ToArray();
Player? simulationOwner = simulationManager.GetSimulationOwner();
authenticateResponsePacket = new AuthenticatePacket(true, null, client, players, simulationOwner);
Console.WriteLine($"Player {sourcePlayerId} successfully authenticated!");
}
processorContext.Server.SendPacketToPlayer(authenticateResponsePacket, sourcePlayerId);
}
public override void ProcessPacket(Guid sourcePlayerId, Packet packet, IProcessorContext context)
{
WorldDataRequestPacket worldDataRequestPacket = (WorldDataRequestPacket)packet;
ServerProcessorContext processorContext = (ServerProcessorContext)context;
PlayerManager playerManager = processorContext.Server.PlayerManager;
SimulationManager simulationManager = processorContext.Server.SimulationManager;
TimeManager timeManager = processorContext.Server.TimeManager;
WorldRequestQueueManager worldRequestQueueManager = processorContext.Server.WorldRequestQueueManager;
WorldStateManager worldStateManager = processorContext.Server.WorldStateManager;
if (!playerManager.PlayerExists(sourcePlayerId))
{
// Players can not ask for a copy of the world before they authenticate
return;
}
Player sourcePlayer = playerManager.GetPlayer(sourcePlayerId);
if (sourcePlayer.State != PlayerState.ConnectedMainMenu)
{
// Invalid state
return;
}
// We pause the game and lock time management until everyone has finished loading
timeManager.FreezeTime();
Player?simulationOwner = simulationManager.GetSimulationOwner();
if (simulationOwner != null && simulationOwner.Value != sourcePlayer && worldStateManager.RequestWorldData())
{
// The server can get a newer world state
// add the client to the queue and wait
worldRequestQueueManager.EnqueuePlayer(sourcePlayer);
}
else
{
// The state we have is already the newest
WorldStateData worldStateData = worldStateManager.GetWorldData();
WorldDataPacket worldDataPacket = new WorldDataPacket(worldStateData);
processorContext.Server.SendPacketToPlayer(worldDataPacket, sourcePlayerId);
}
}
public override void ProcessPacket(Guid sourcePlayerId, Packet packet, IProcessorContext context)
{
ClientProcessorContext clientProcessor = (ClientProcessorContext)context;
SimulationManager simulationManager = clientProcessor.Client.SimulationManager;
Player?player = simulationManager.GetSimulationOwner();
if (player.HasValue && clientProcessor.Client.LocalPlayer.HasValue && clientProcessor.Client.LocalPlayer.Value != player.Value)
{
return; // Not the simulation owner
}
GameStateGame gameStateGame = GameManager.getInstance().getGameState() as GameStateGame;
string xmlData = WorldSerializer.Serialize(gameStateGame);
WorldStateData worldStateData = new WorldStateData(xmlData);
WorldDataPacket worldDataPacket = new WorldDataPacket(worldStateData);
clientProcessor.Client.SendPacket(worldDataPacket);
}
public override void ProcessPacket(Guid sourcePlayerId, Packet packet, IProcessorContext context)
{
ClientProcessorContext processorContext = (ClientProcessorContext)context;
DisconnectRequestPacket disconnectRequestPacket = (DisconnectRequestPacket)packet;
void OnExitConfirm(object parameter)
{
GameManager.getInstance().setGameStateTitle();
processorContext.Client.Disconnect();
}
GuiDefinitions.Callback callback = new GuiDefinitions.Callback(OnExitConfirm);
switch (disconnectRequestPacket.Reason)
{
case DisconnectReason.DisconnectRequestResponse:
Debug.Log("Graceful disconnect response received, disconnecting.");
OnExitConfirm(null);
break;
case DisconnectReason.KickedOut:
if (!MessageBoxOk.Show(callback, "Disconnected from server", "You have been kicked out of the game."))
{
OnExitConfirm(null); // Failed to show window
}
break;
case DisconnectReason.ServerClosing:
if (!MessageBoxOk.Show(callback, "Disconnected from server", "Server is shutting down."))
{
OnExitConfirm(null); // Failed to show window
}
break;
default:
if (!MessageBoxOk.Show(callback, "Disconnected from server", "Unknown reason."))
{
OnExitConfirm(null); // Failed to show window
}
break;
}
}
public override void ProcessPacket(Guid sourcePlayerId, Packet packet, IProcessorContext context)
{
ServerProcessorContext processorContext = (ServerProcessorContext)context;
PlayerManager playerManager = processorContext.Server.PlayerManager;
TimeManager timeManager = processorContext.Server.TimeManager;
if (!playerManager.PlayerExists(sourcePlayerId))
{
return; // what
}
Player player = playerManager.GetPlayer(sourcePlayerId);
player.State = PlayerState.ConnectedReady;
playerManager.UpdatePlayer(player);
if (playerManager.GetPlayers().Count(p => p.State == PlayerState.ConnectedLoadingData) == 0)
{
timeManager.UnfreezeTime();
}
}
public override bool ExecuteProcess(IProcessorContext incoming)
{
string key = incoming.FieldKey;
IRequestContext context = incoming.Context;
IDictionary criteria = incoming.Criteria;
bool have = (criteria.Contains(key));
if (have)
{
incoming.Source = criteria[key];
bool okay = ExecuteConvert(incoming);
if (okay)
// set to main context
context[key] = incoming.Target;
else context.AddAlertForField(key);
return STOP;
}
return CONTINUE;
}
public override bool ExecuteProcess(IProcessorContext outgoing)
{
string key = outgoing.FieldKey;
IRequestContext context = outgoing.Context;
IDictionary criteria = outgoing.Criteria;
bool have = (context.Contains(key));
if (have)
{
outgoing.Source = context[key];
bool okay = ExecuteFormat(outgoing);
if (okay)
// set to field buffer
criteria[key] = outgoing.Target;
else context.AddAlertForField(key);
return STOP;
}
return CONTINUE;
}
public override void ProcessPacket(Guid sourcePlayerId, Packet packet, IProcessorContext context)
{
PlayerJoinedPacket playerJoinedPacket = (PlayerJoinedPacket)packet;
ClientProcessorContext processorContext = (ClientProcessorContext)context;
processorContext.Client.PlayerManager.OnPlayerAdded(playerJoinedPacket.Player);
MessageLogFlags flags;
if (playerJoinedPacket.Player.Name.ToLower() == "freddy")
{
flags = MessageLogFlags.MessageSoundPowerDown;
}
else
{
flags = MessageLogFlags.MessageSoundNormal;
}
MessageLog.Show($"Player is joining game: {playerJoinedPacket.Player.Name}", null, flags);
}
public override bool FormatOutput(IProcessorContext outgoing)
{
ProcessorCommand formatter = new FormatOutput();
IList source = outgoing.Source as IList;
IEntryList target = NewEntryList();
foreach (IDictionary row in source)
{
IRequestContext context = new RequestContext(row);
context.FieldTable = outgoing.FieldTable;
ICollection keys = row.Keys;
foreach (string key in keys)
{
IProcessorContext _context = new ProcessorContext(key, context);
formatter.ExecuteProcess(_context);
}
target.AddEntry(context.Criteria);
}
outgoing.Target = target;
return true;
}
public virtual bool ExecuteConvert(IProcessorContext context)
{
bool okay;
string id = context.FieldKey;
IFieldTable table = context.FieldTable;
IFieldContext fieldContext = table.GetFieldContext(id); // enforces Strict
if ((fieldContext == null))
{
ConvertInput(context);
return true;
}
IProcessor processor = fieldContext.Processor;
if (processor == null)
okay = ConvertInput(context);
else
{
okay = processor.ConvertInput(context);
}
return okay;
}
public override bool ConvertInput(IProcessorContext incoming)
{
incoming.Target = incoming.Source;
return true;
}
public abstract bool ConvertInput(IProcessorContext incoming);
public abstract bool FormatOutput(IProcessorContext outgoing);
public abstract void Parse(TextReader reader, IProcessorContext context);
public override bool ConvertInput(IProcessorContext incoming)
{
string source = incoming.Source as string;
incoming.Target = String_Convert(source);
return true;
}
/// <summary>
/// Format output for fields that do not have a Processor.
/// </summary>
/// <remarks>
/// The default behavior is to pass through nulls and ICollection types
/// and to call ToString on everything else.
/// </remarks>
/// <param name="context">The IProcessorContext</param>
public virtual bool FormatOutput(IProcessorContext context)
{
if (context.Source != null)
{
Type sourceType = context.Source.GetType();
if (IsCollectionType(sourceType)) context.Target = context.Source;
else context.Target = context.Source.ToString();
}
return true;
}
public abstract bool ExecuteProcess(IProcessorContext context);
/// <summary>
/// Convert input for fields that do not have a Processor.
/// </summary>
/// <remarks>
/// The default behavior is to pass through the objects, verbatim.
/// </remarks>
/// <param name="context">The IProcessorContext</param>
public virtual bool ConvertInput(IProcessorContext context)
{
context.Target = context.Source;
return true;
}
public void Parse(TextReader reader, IProcessorContext context)
{
context.Output.Write("A");
}
public override bool FormatOutput(IProcessorContext outgoing)
{
object source = outgoing.Source;
outgoing.Target = String_Format(source);
return true;
}
