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;
}
public DebugWindow(Graphics graphics, CoreSettings settingsCoreSettings)
{
this.graphics = graphics;
this.settingsCoreSettings = settingsCoreSettings;
graphics.InitImage("menu-background.png");
}
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);
Files = Game.Files;
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;
}