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