private static void RunServer([NotNull] IEnumerable <string> args) { var staticContentPath = GetStaticContentDir(); var settings = GetSettingsFile(args); var httpListenerPrefix = settings.HttpListenerPrefix; var warriorProgramParser = new WarriorParser(); var playersRepo = new PlayersRepo(new DirectoryInfo("../players"), warriorProgramParser); var gamesRepo = new CachingGamesRepo(new GamesRepo(new DirectoryInfo("../games"))); var sessionManager = new SessionManager("../sessions"); var gameServer = new GameServer(); var debuggerManager = new DebuggerManager(gameServer); var battleRunner = new BattleRunner(); var countdownProvider = new CountdownProvider(settings.ContestStartTimestamp, TimeSpan.FromHours(settings.ContestDurationInHours)); var arenaState = new ArenaState(playersRepo, gamesRepo, countdownProvider, settings.GodModeSecret, settings.GodAccessOnly, settings.SubmitIsAllowed, settings.EnableDeepNavigation); var tournamentRunner = new TournamentRunner(arenaState, battleRunner, settings.BattlesPerPair); var httpServer = new GameHttpServer(httpListenerPrefix, arenaState, sessionManager, debuggerManager, tournamentRunner, staticContentPath); Runtime.SetStopHandler(() => { log.InfoFormat("Stopping..."); httpServer.Stop(); tournamentRunner.Stop(); }); tournamentRunner.Start(); httpServer.Run(); log.InfoFormat("Listening on: {0}", httpListenerPrefix); if (!settings.ProductionMode) { Process.Start(httpServer.DefaultUrl); } httpServer.WaitForTermination(); tournamentRunner.WaitForTermination(); log.InfoFormat("Stopped"); }
/// <summary> /// Walks through the set of tasks for this target and processes them by handing them off to the TaskBuilder. /// </summary> /// <returns> /// The result of the tasks, based on the last task which ran. /// </returns> private async Task <WorkUnitResult> ProcessBucket(ITaskBuilder taskBuilder, TargetLoggingContext targetLoggingContext, TaskExecutionMode mode, Lookup lookupForInference, Lookup lookupForExecution) { WorkUnitResultCode aggregatedTaskResult = WorkUnitResultCode.Success; WorkUnitActionCode finalActionCode = WorkUnitActionCode.Continue; WorkUnitResult lastResult = new WorkUnitResult(WorkUnitResultCode.Success, WorkUnitActionCode.Continue, null); try { // Grab the task builder so if cancel is called it will have something to operate on. _currentTaskBuilder = taskBuilder; int currentTask = 0; // Walk through all of the tasks and execute them in order. for (; (currentTask < _target.Children.Count) && !_cancellationToken.IsCancellationRequested; ++currentTask) { ProjectTargetInstanceChild targetChildInstance = _target.Children[currentTask]; if (DebuggerManager.DebuggingEnabled) { DebuggerManager.EnterState(targetChildInstance.Location, lookupForExecution.GlobalsForDebugging /* does not matter which lookup we get this from */); } // Execute the task. lastResult = await taskBuilder.ExecuteTask(targetLoggingContext, _requestEntry, _targetBuilderCallback, targetChildInstance, mode, lookupForInference, lookupForExecution, _cancellationToken); if (DebuggerManager.DebuggingEnabled) { DebuggerManager.LeaveState(targetChildInstance.Location); } if (lastResult.ResultCode == WorkUnitResultCode.Failed) { aggregatedTaskResult = WorkUnitResultCode.Failed; } else if (lastResult.ResultCode == WorkUnitResultCode.Success && aggregatedTaskResult != WorkUnitResultCode.Failed) { aggregatedTaskResult = WorkUnitResultCode.Success; } if (lastResult.ActionCode == WorkUnitActionCode.Stop) { finalActionCode = WorkUnitActionCode.Stop; break; } } if (_cancellationToken.IsCancellationRequested) { aggregatedTaskResult = WorkUnitResultCode.Canceled; finalActionCode = WorkUnitActionCode.Stop; } } finally { _currentTaskBuilder = null; } return(new WorkUnitResult(aggregatedTaskResult, finalActionCode, lastResult.Exception)); }
private void EndRun(DebuggerManager obj) { Common.RunInUI(() => { m_view.m_leftLayoutAnchorablePane.Children.Remove(m_layoutAnchorable); m_layoutAnchorable = null; }); }
public void UpdateElements() { treeControl.Tree.BeginUpdate(); treeControl.Nodes.Clear(); DebuggerManager debugManager = PluginMain.debugManager; foreach (String item in watches) { DataNode node = new DataNode(item); // todo, introduce new Node types. try { Variable var = debugManager.EvaluateCurrent(item); if (var != null) { node = new DataNode(var); } } catch { } node.Text = item; treeControl.AddNode(node); } treeControl.Tree.EndUpdate(); treeControl.Enabled = true; }
private void OnDestroy() { if (m_DebuggerManager != null) { m_DebuggerManager.Shutdown(); m_DebuggerManager = null; } }
private void BeginRun(DebuggerManager obj) { m_layoutAnchorable = new LayoutAnchorable(); m_layoutAnchorable.CanClose = false; m_layoutAnchorable.CanHide = false; m_layoutAnchorable.Title = ResxIF.GetString("VariableTracking"); // 变量跟踪 m_layoutAnchorable.IsActive = true; m_layoutAnchorable.Content = new LocalsContent(); m_view.m_leftLayoutAnchorablePane.Children.Add(m_layoutAnchorable); }
private void BeginRun(DebuggerManager obj) { m_layoutAnchorable = new LayoutAnchorable(); m_layoutAnchorable.CanClose = false; m_layoutAnchorable.CanHide = false; m_layoutAnchorable.Title = "变量跟踪"; m_layoutAnchorable.IsActive = true; m_layoutAnchorable.Content = new LocalsContent(); m_view.m_leftLayoutAnchorablePane.Children.Add(m_layoutAnchorable); }
/// <summary> /// 游戏框架组件初始化。 /// </summary> private void Awake() { DontDestroyOnLoad(gameObject); //Todo 默认窗口大小适配 DefaultWindowScale = (float)Screen.height / DefaultWindowRect.height; m_DebuggerManager = new DebuggerManager(); if (m_ActiveWindow == DebuggerActiveWindowType.Auto) { ActiveWindow = Debug.isDebugBuild; } else { ActiveWindow = (m_ActiveWindow == DebuggerActiveWindowType.Open); } m_FpsCounter = new FpsCounter(0.5f); }
public void Update() { if (_gameState == GameState.InGame && _uiState == InGameInterfaceDisplayState.Dialogue) { if ((Input.GetMouseButtonDown(0) && _needDisableClick == false) || Input.GetKeyDown(KeyCode.Space)) { Next(); } } if (Input.GetKeyDown(KeyCode.Escape)) { if (_debuggerPanel.activeSelf == true) { _debuggerPanel.SetActive(false); } else { _debuggerPanel.SetActive(true); DebuggerManager.GetInstance().Init(); } } }
internal static void Init() { Logger.Info("Game initializing."); DataModel.Workspace = Workspace = DataModel.GetService <Workspace>(); Workspace.SetGame(DataModel); DataModel.GetService <RunService>(); DataModel.GetService <ContentProvider>(); DataModel.GetService <InputService>(); DataModel.GetService <SoundService>(); DataModel.GetService <ReplicatedStorage>(); DataModel.GetService <ServerStorage>(); DataModel.GetService <ServerScriptService>(); DataModel.GetService <ReplayService>(); DataModel.GetService <HistoryService>(); DataModel.GetService <SocialService>(); DataModel.GetService <ContextActionService>(); Analytics = DataModel.GetService <AnalyticsService>(); Players = DataModel.GetService <Players>(); Lighting = DataModel.GetService <Lighting>(); Selection = DataModel.GetService <SelectionService>(); Selection.Name = "Selection"; CoreEnvironment = new CoreEnvironment(); StarterGui = new StarterGui { Parent = DataModel, ParentLocked = true }; DebuggerManager = new DebuggerManager(); DataModel.IsLoaded = true; DataModel.Loaded.Fire(); IsInitialized = true; Initialized?.Invoke(null, null); Logger.Info("Game initialized."); }
public ushort invokeReadMemory16BitViaRegistryValue(string registryName) { return(readMemory16BitDelegate(DebuggerManager.getRegistryValueByName(a_Z80Registers, registryName))); }
public static Func <bool> EmitCondition(ref IDebuggable i_spectrum, BreakpointInfo i_breakpointInfo) { Func <bool> o_ILOut = null; if (i_breakpointInfo.AccessType == BreakPointConditionType.registryVsValue) { //e.g. PC == #0038 Type[] args = { typeof(CpuRegs) }; DynamicMethod dynamicMethod = new DynamicMethod( "RegVsValue", typeof(bool), //return type args, //arguments for the method typeof(CpuRegs).Module); //module as input ILGenerator il = dynamicMethod.GetILGenerator(); //1.Arg0 - registry il.Emit(OpCodes.Ldarg_0); // load m_spectrum.CPU.regs on stack FieldInfo testInfo1 = typeof(CpuRegs).GetField(i_breakpointInfo.LeftCondition, BindingFlags.Public | BindingFlags.Instance); il.Emit(OpCodes.Ldfld, testInfo1); //2.Arg1 - number il.Emit(OpCodes.Ldc_I4, (int)i_breakpointInfo.RightValue); //3.Compare EmitComparison(il, i_breakpointInfo.ConditionTypeSign); il.Emit(OpCodes.Ret); //Return: 1 => true(breakpoint is reached) otherwise 0 => false o_ILOut = (Func <bool>)dynamicMethod.CreateDelegate(typeof(Func <bool>), i_spectrum.CPU.regs); } else if (i_breakpointInfo.AccessType == BreakPointConditionType.flagVsValue) { //e.g.: fZ == 1 Type[] args = { typeof(CpuRegs) }; DynamicMethod dynamicMethod = new DynamicMethod( "FlagVsValue", typeof(bool), //return type args, //arguments for the method typeof(CpuRegs).Module); //module as input ILGenerator il = dynamicMethod.GetILGenerator(); //1.Arg0 - flag il.Emit(OpCodes.Ldarg_0); // load m_spectrum.CPU.regs on stack FieldInfo testInfo1 = typeof(CpuRegs).GetField("AF", BindingFlags.Public | BindingFlags.Instance); il.Emit(OpCodes.Ldfld, testInfo1); //get flag value(0 or 1) switch (i_breakpointInfo.LeftCondition) { case "FS": il.Emit(OpCodes.Ldc_I4, 0x80); break; case "FZ": il.Emit(OpCodes.Ldc_I4, 0x40); break; case "FH": il.Emit(OpCodes.Ldc_I4, 0x10); break; case "FPV": il.Emit(OpCodes.Ldc_I4, 0x04); break; case "FN": il.Emit(OpCodes.Ldc_I4, 0x02); break; case "FC": il.Emit(OpCodes.Ldc_I4, 0x01); break; default: throw new CommandParseException("Incorrect flag in condition emit..."); } il.Emit(OpCodes.And); //get flag value from F registry if (i_breakpointInfo.ConditionTypeSign == "==" && i_breakpointInfo.RightValue > 0) { i_breakpointInfo.RightValue = 0; i_breakpointInfo.ConditionTypeSign = "!="; } //2. Arg1 - right condition(must a number) il.Emit(OpCodes.Ldc_I4, (int)i_breakpointInfo.RightValue); //3. Compare EmitComparison(il, i_breakpointInfo.ConditionTypeSign); il.Emit(OpCodes.Ret); //Return: 1 => true(breakpoint is reached) otherwise 0 => false o_ILOut = (Func <bool>)dynamicMethod.CreateDelegate(typeof(Func <bool>), i_spectrum.CPU.regs); } else if (i_breakpointInfo.AccessType == BreakPointConditionType.memoryVsValue) { //e.g. (16384) == #FF00 //ToDo: Because it is not possible to dynamically emit code for interface method(IDebuggable.ReadMemory) // I temporary wrapped it into custom wrapper. InterfaceWrapper middleMan = new InterfaceWrapper(); middleMan.wrapInterface(i_spectrum); MethodInfo ReadMemoryMethod; if (i_breakpointInfo.RightValue > 0xFF) { ReadMemoryMethod = typeof(InterfaceWrapper).GetMethod("invokeReadMemory16Bit", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic , null , new Type[] { typeof(ushort) } , null); } else { ReadMemoryMethod = typeof(InterfaceWrapper).GetMethod("invokeReadMemory8Bit", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic , null , new Type[] { typeof(ushort) } , null); } DynamicMethod dynamicMethod = new DynamicMethod("ReadMemory" , typeof(bool) , new Type[] { typeof(InterfaceWrapper) } , typeof(InterfaceWrapper).Module ); ILGenerator IL = dynamicMethod.GetILGenerator(); //Arg0 - memory reference(static), e.g. (16384) IL.Emit(OpCodes.Ldarg_0); // load InterfaceWrapper on stack IL.Emit(OpCodes.Ldc_I4, i_breakpointInfo.LeftValue); // method parameter(for ReadMemoryMethod) IL.Emit(OpCodes.Call, ReadMemoryMethod); //Arg1 IL.Emit(OpCodes.Ldc_I4, i_breakpointInfo.RightValue); // <- compare to 8 or 16bit EmitComparison(IL, i_breakpointInfo.ConditionTypeSign); IL.Emit(OpCodes.Ret); //Return: 1 => true(breakpoint is reached) otherwise 0 => false o_ILOut = (Func <bool>)dynamicMethod.CreateDelegate(typeof(Func <bool>), middleMan); } else if (i_breakpointInfo.AccessType == BreakPointConditionType.registryMemoryReferenceVsValue) { // e.g.: (PC) == #D155 - instruction breakpoint //ToDo: Because it is not possible to dynamically emit code for interface method(IDebuggable.ReadMemory) // I temporary wrapped it into custom wrapper. InterfaceWrapper middleMan = new InterfaceWrapper(); middleMan.wrapInterface(i_spectrum); middleMan.wrapFields(i_spectrum.CPU.regs); MethodInfo ReadMemoryMethod; //Type[] args = { typeof(REGS) }; if (i_breakpointInfo.RightValue > 0xFF) { ReadMemoryMethod = typeof(InterfaceWrapper).GetMethod("invokeReadMemory16BitViaRegistryValue", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic , null , new Type[] { typeof(string) } , null); } else { ReadMemoryMethod = typeof(InterfaceWrapper).GetMethod("invokeReadMemory8BitViaRegistryValue", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic , null , new Type[] { typeof(string) } , null); } DynamicMethod dynamicMethod = new DynamicMethod("ReadMemoryViaRegistry", typeof(bool), new Type[] { typeof(InterfaceWrapper) }); ILGenerator IL = dynamicMethod.GetILGenerator(); //Arg0, e.g. (PC) IL.Emit(OpCodes.Ldarg_0); // load InterfaceWrapper on stack string registry = DebuggerManager.getRegistryFromReference(i_breakpointInfo.LeftCondition); IL.Emit(OpCodes.Ldstr, registry); IL.Emit(OpCodes.Call, ReadMemoryMethod); //Arg1, number(right condition) IL.Emit(OpCodes.Ldc_I4, i_breakpointInfo.RightValue); // <- compare to 8 or 16bit EmitComparison(IL, i_breakpointInfo.ConditionTypeSign); IL.Emit(OpCodes.Ret); //Return: 1 => true(breakpoint is reached) otherwise 0 => false o_ILOut = (Func <bool>)dynamicMethod.CreateDelegate(typeof(Func <bool>), middleMan); } return(o_ILOut); }