public EntityListWrapper(GameController gameController, CoreSettings settings, MultiThreadManager multiThreadManager)
{
this.gameController = gameController;
_settings = settings;
// EntitiesStack = new MultiThreadProp<Stack<Entity>>();
entityCache = new Dictionary <uint, Entity>(1000);
gameController.Area.OnAreaChange += AreaChanged;
EntitiesVersion = 0;
updateEntity =
new Coroutine(RefreshState, new WaitTime(coroutineTimeWait), null, "Update Entity")
{
Priority = CoroutinePriority.High, SyncModWork = true
};
var collectEntitiesDebug = new DebugInformation("Collect Entities");
/*parallelUpdateDictionary = new Coroutine(() =>
* {
* if (!EntitiesStack.CanUpdate) return;
* collectEntitiesDebug.TickAction(() =>
* {
* gameController.Game.IngameState.Data.EntityList.CollectEntities(EntitiesStack.Write(), entityCache, multiThreadManager,
* settings.ParseServerEntities,
* settings.MyMultiOrAsParallel,
* settings.CollectEntitiesInParallelWhenMoreThanX,
* gameController.IngameState.Data.EntitiesCount,
* _entitiesVersion);
* _entitiesVersion++;
* });
* }, new WaitTime(coroutineTimeWait), null, "EntitiesAsDictionary") {Priority = CoroutinePriority.High};*/
/*parallelUpdateDictionary = new Coroutine(() =>
* {
* if (!needUpdate) return;
* collectEntitiesDebug.TickAction(() =>
* {
* gameController.Game.IngameState.Data.EntityList.CollectEntities(Simple, keysForDelete, entityCache, multiThreadManager,
* settings.ParseServerEntities,
* settings.MyMultiOrAsParallel,
* settings.CollectEntitiesInParallelWhenMoreThanX,
* gameController.IngameState.Data.EntitiesCount,
* EntitiesVersion);
*
* EntitiesVersion++;
* needUpdate = false;
* });
* }, new WaitTime(coroutineTimeWait), null, "EntitiesAsDictionary") {Priority = CoroutinePriority.High};*/
entityCollectSettingsContainer = new EntityCollectSettingsContainer();
entityCollectSettingsContainer.Simple = Simple;
entityCollectSettingsContainer.KeyForDelete = keysForDelete;
entityCollectSettingsContainer.EntityCache = entityCache;
entityCollectSettingsContainer.MultiThreadManager = multiThreadManager;
entityCollectSettingsContainer.ParseServer = () => settings.ParseServerEntities;
entityCollectSettingsContainer.ParseEntitiesInMultiThread = () => settings.ParseEntitiesInMultiThread;
entityCollectSettingsContainer.EntitiesCount = () => gameController.IngameState.Data.EntitiesCount;
entityCollectSettingsContainer.EntitiesVersion = EntitiesVersion;
entityCollectSettingsContainer.CollectEntitiesInParallelWhenMoreThanX = settings.CollectEntitiesInParallelWhenMoreThanX;
entityCollectSettingsContainer.DebugInformation = collectEntitiesDebug;
IEnumerator Test()
{
while (true)
{
yield return(gameController.IngameState.Data.EntityList.CollectEntities(entityCollectSettingsContainer));
yield return(new WaitTime(1000 / settings.EntitiesUpdate));
parallelUpdateDictionary.UpdateTicks((uint)(parallelUpdateDictionary.Ticks + 1));
}
}
parallelUpdateDictionary = new Coroutine(Test(), null, "Collect entites")
{
SyncModWork = true
};
UpdateCondition(1000 / settings.EntitiesUpdate);
settings.EntitiesUpdate.OnValueChanged += (sender, i) => { UpdateCondition(1000 / i); };
var enumValues = typeof(EntityType).GetEnumValues();
ValidEntitiesByType = new Dictionary <EntityType, List <Entity> >(enumValues.Length);
// NotValidEntitiesByType = new Dictionary<EntityType, List<Entity>>(enumValues.Length);
foreach (EntityType enumValue in enumValues)
{
ValidEntitiesByType[enumValue] = new List <Entity>(8);
}
// NotValidEntitiesByType[enumValue] = new List<Entity>(8);
PlayerUpdate += (sender, entity) => Entity.Player = entity;
}
/// <summary>
/// Dump the registers to the debug output stream.
/// </summary>
public void DisplayRegisters()
{
var registers = _adxl345.ReadRegisters(Registers.TAPThreshold, 29);
DebugInformation.DisplayRegisters(Registers.TAPThreshold, registers);
}
public GameController(Memory memory, SoundController soundController, SettingsContainer settings,
MultiThreadManager multiThreadManager)
{
_settings = settings.CoreSettings;
Memory = memory;
SoundController = soundController;
Settings = settings;
MultiThreadManager = multiThreadManager;
try
{
Cache = new Cache();
Game = new TheGame(memory, Cache);
Area = new AreaController(Game);
Window = new GameWindow(memory.Process);
WasInGame = Game.InGame;
EntityListWrapper = new EntityListWrapper(this, _settings, multiThreadManager);
}
catch (Exception e)
{
DebugWindow.LogError(e.ToString());
}
PluginBridge = new PluginBridge();
IsForeGroundCache = WinApi.IsForegroundWindow(Window.Process.MainWindowHandle);
var values = Enum.GetValues(typeof(IconPriority));
LeftPanel = new PluginPanel(GetLeftCornerMap());
UnderPanel = new PluginPanel(GetUnderCornerMap());
var debParseFile = new DebugInformation("Parse files", false);
debClearCache = new DebugInformation("Clear cache", false);
// Core.DebugInformations.Add(debParseFile);
/*Area.OnAreaChange += controller =>
* {
*
* debParseFile.TickAction(() =>
* {
* Files.LoadFiles();
* });
* };*/
debDeltaTime = Core.DebugInformations.FirstOrDefault(x => x.Name == "Delta Time");
NativeMethods.LogError = _settings.LogReadMemoryError;
_settings.LogReadMemoryError.OnValueChanged +=
(obj, b) => NativeMethods.LogError = _settings.LogReadMemoryError;
LeftCornerMap = new TimeCache <Vector2>(GetLeftCornerMap, 500);
UnderCornerMap = new TimeCache <Vector2>(GetUnderCornerMap, 500);
eIsForegroundChanged += b =>
{
if (b)
{
Core.MainRunner.ResumeCoroutines(Core.MainRunner.Coroutines);
Core.ParallelRunner.ResumeCoroutines(Core.ParallelRunner.Coroutines);
}
else
{
Core.MainRunner.PauseCoroutines(Core.MainRunner.Coroutines);
Core.ParallelRunner.PauseCoroutines(Core.ParallelRunner.Coroutines);
}
// DebugWindow.LogMsg($"Foreground: {b}");
};
_settings.RefreshArea.OnPressed += () => { Area.ForceRefreshArea(_settings.AreaChangeMultiThread); };
Area.RefreshState();
EntityListWrapper.StartWork();
Initialized = true;
}
public void ResetVariables()
{
_listView.Enabled = false;
_displayedLocalsSource = null;
}
private void OnBreakEvent(object sender, DebugInformation e)
{
Debugger.OnBreak(sender, e);
}
public EntityListWrapper(GameController gameController, CoreSettings settings, MultiThreadManager multiThreadManager)
{
_instance = this;
this.gameController = gameController;
_settings = settings;
entityCache = new Dictionary <uint, Entity>(1000);
gameController.Area.OnAreaChange += AreaChanged;
EntitiesVersion = 0;
updateEntity =
new Coroutine(RefreshState, new WaitTime(coroutineTimeWait), null, "Update Entity")
{
Priority = CoroutinePriority.High, SyncModWork = true
};
var collectEntitiesDebug = new DebugInformation("Collect Entities");
entityCollectSettingsContainer = new EntityCollectSettingsContainer();
entityCollectSettingsContainer.Simple = Simple;
entityCollectSettingsContainer.KeyForDelete = keysForDelete;
entityCollectSettingsContainer.EntityCache = entityCache;
entityCollectSettingsContainer.MultiThreadManager = multiThreadManager;
entityCollectSettingsContainer.ParseServer = () => settings.ParseServerEntities;
entityCollectSettingsContainer.ParseEntitiesInMultiThread = () => settings.ParseEntitiesInMultiThread;
entityCollectSettingsContainer.EntitiesCount = () => gameController.IngameState.Data.EntitiesCount;
entityCollectSettingsContainer.EntitiesVersion = EntitiesVersion;
entityCollectSettingsContainer.CollectEntitiesInParallelWhenMoreThanX = settings.CollectEntitiesInParallelWhenMoreThanX;
entityCollectSettingsContainer.DebugInformation = collectEntitiesDebug;
IEnumerator Test()
{
while (true)
{
yield return(gameController.IngameState.Data.EntityList.CollectEntities(entityCollectSettingsContainer));
yield return(new WaitTime(1000 / settings.EntitiesUpdate));
parallelUpdateDictionary.UpdateTicks((uint)(parallelUpdateDictionary.Ticks + 1));
}
}
parallelUpdateDictionary = new Coroutine(Test(), null, "Collect entites")
{
SyncModWork = true
};
UpdateCondition(1000 / settings.EntitiesUpdate);
settings.EntitiesUpdate.OnValueChanged += (sender, i) => { UpdateCondition(1000 / i); };
var enumValues = typeof(EntityType).GetEnumValues();
ValidEntitiesByType = new Dictionary <EntityType, List <Entity> >(enumValues.Length);
foreach (EntityType enumValue in enumValues)
{
ValidEntitiesByType[enumValue] = new List <Entity>(8);
}
PlayerUpdate += (sender, entity) => Entity.Player = entity;
}
public void OnNext(byte[] value)
{
Console.WriteLine($"From IObserver - Tag value is {DebugInformation.Hexadecimal(value)}");
}
private void LoadTabs(DebugInformation debug)
{
_localsControl.LoadVariables(debug, VariablesMode.Locals);
_globalsControl.LoadVariables(debug, VariablesMode.Globals);
_callStackControl.LoadCallStack(debug);
}
private void InstrumentConcreteCollectionCasts(MethodDefinition methodDefinition)
{
foreach (Instruction cast in CastsToSupportedCollections(methodDefinition.Body))
{
StackAnalysisResult result = StackAnalyzer.IsConsumedBy(MethodCallOnSupportedCollections, cast, methodDefinition.DeclaringType.Module);
if (!result.Match)
{
throw new InvalidOperationException(string.Format("Error: [{0}] Invalid use of cast result: '{1}'.\r\nCasts to {2} are only allowed for property access/method calls.", methodDefinition, DebugInformation.InstructionInformationFor(result.Consumer, methodDefinition.Body.Instructions), cast.Operand));
}
TypeReference castTarget = (TypeReference)cast.Operand;
ReplaceCastAndCalleeDeclaringType(cast, result.Consumer, _collectionReplacements[castTarget.Resolve().FullName]);
}
}
private static void Debugger_Pause(DebugInformation info)
{
// We're being called from the Jint thread. Execute on UI thread:
Dispatcher.Invoke(() => UpdateDisplay(info));
}
public MenuWindow(Core core, SettingsContainer settingsContainer, Dictionary <string, FontContainer> fonts, ref VersionChecker versionChecker)
{
this.Core = core;
_settingsContainer = settingsContainer;
CoreSettings = settingsContainer.CoreSettings;
Fonts = fonts;
CoreSettingsDrawers = new List <ISettingsHolder>();
SettingsParser.Parse(CoreSettings, CoreSettingsDrawers);
PluginsUpdateSettings = settingsContainer.PluginsUpdateSettings;
PluginsUpdateSettingsDrawers = new List <ISettingsHolder>();
SettingsParser.Parse(PluginsUpdateSettings, PluginsUpdateSettingsDrawers);
VersionChecker = versionChecker;
Selected = CoreSettingsAction;
CoreSettingsAction = () =>
{
foreach (var drawer in CoreSettingsDrawers)
{
drawer.Draw();
}
};
_index = -1;
Selected = CoreSettingsAction;
Core.DebugInformations.CollectionChanged += OnDebugInformationsOnCollectionChanged;
debugInformation = new DebugInformation("DebugWindow", false);
OpenWindow = Windows.MainDebugs;
WindowsName = Enum.GetValues(typeof(Windows));
OnWindowChange += () =>
{
MoreInformation = null;
selectedName = "";
};
Input.RegisterKey(CoreSettings.MainMenuKeyToggle);
CoreSettings.MainMenuKeyToggle.OnValueChanged += () => { Input.RegisterKey(CoreSettings.MainMenuKeyToggle); };
CoreSettings.Enable.OnValueChanged += (sender, b) =>
{
if (!CoreSettings.Enable)
{
try
{
_settingsContainer.SaveCoreSettings();
try
{
_settingsContainer.SavePluginAutoUpdateSettings();
}
catch (Exception e)
{
DebugWindow.LogError($"SaveSettings for PluginAutoUpdate error: {e}");
}
foreach (var plugin in core.pluginManager.Plugins)
{
try
{
_settingsContainer.SaveSettings(plugin.Plugin);
}
catch (Exception e)
{
DebugWindow.LogError($"SaveSettings for plugin error: {e}");
}
}
}
catch (Exception e)
{
DebugWindow.LogError($"SaveSettings error: {e}");
}
}
};
}
StepMode engine_Step(object sender, DebugInformation e)
{
return(ProcessStep(sender, e, BreakType.Step));
}
private StepMode DebugHandler_Step(object sender, DebugInformation e)
{
Pause(e);
return(stepMode);
}
protected void OnBreak(object sender, DebugInformation info)
{
if (Break != null) {
Break(this, info);
}
}
/// <summary>
/// Display the registers.
/// </summary>
public void DisplayRegisters()
{
var data = _ds323x.ReadRegisters(0, 0x12);
DebugInformation.DisplayRegisters(0, data);
}
protected void OnStep(object sender, DebugInformation info)
{
if (Step != null) {
Step(this, info);
}
if (Break != null) {
BreakPoint breakpoint = BreakPoints.Find(l => {
bool afterStart, beforeEnd;
afterStart = l.Line > info.CurrentStatement.Source.Start.Line
|| (l.Line == info.CurrentStatement.Source.Start.Line && l.Char >= info.CurrentStatement.Source.Start.Char);
if (!afterStart) {
return false;
}
beforeEnd = l.Line < info.CurrentStatement.Source.Stop.Line
|| (l.Line == info.CurrentStatement.Source.Stop.Line && l.Char <= info.CurrentStatement.Source.Stop.Char);
if (!beforeEnd) {
return false;
}
if (!String.IsNullOrEmpty(l.Condition)) {
return Convert.ToBoolean(this.Run(l.Condition));
}
return true;
});
if (breakpoint != null) {
Break(this, info);
}
}
}
public MenuWindow(Core core, SettingsContainer settingsContainer, Dictionary <string, FontContainer> fonts)
{
this.core = core;
_settingsContainer = settingsContainer;
_CoreSettings = settingsContainer.CoreSettings;
Fonts = fonts;
themeEditor = new ThemeEditor(_CoreSettings);
/*Input.RegisterKey(Keys.F12);
* Input.ReleaseKey += (sender, keys) =>
* {
* if (keys== SettingsCoreSettings.MainMenuKeyToggle.Value)
* {
* Enable = !Enable;
* }
* };*/
CoreSettingsDrawers = new List <ISettingsHolder>();
SettingsParser.Parse(_CoreSettings, CoreSettingsDrawers);
Selected = CoreSettings;
CoreSettings = () =>
{
foreach (var drawer in CoreSettingsDrawers)
{
drawer.Draw();
}
};
_index = -1;
Selected = CoreSettings;
Core.DebugInformations.CollectionChanged += OnDebugInformationsOnCollectionChanged;
debugInformation = new DebugInformation("DebugWindow", false);
OpenWindow = Windows.MainDebugs;
WindowsName = Enum.GetValues(typeof(Windows));
OnWindowChange += () =>
{
MoreInformation = null;
selectedName = "";
};
Input.RegisterKey(_CoreSettings.MainMenuKeyToggle);
_CoreSettings.MainMenuKeyToggle.OnValueChanged += () => { Input.RegisterKey(_CoreSettings.MainMenuKeyToggle); };
_CoreSettings.Enable.OnValueChanged += (sender, b) =>
{
if (!_CoreSettings.Enable)
{
try
{
_settingsContainer.SaveCoreSettings();
foreach (var plugin in core.pluginManager.Plugins)
{
try
{
_settingsContainer.SaveSettings(plugin.Plugin);
}
catch (Exception e)
{
DebugWindow.LogError($"SaveSettings for plugin error: {e}");
}
}
}
catch (Exception e)
{
DebugWindow.LogError($"SaveSettings error: {e}");
}
}
};
}
