DMA-integration improvements

EyeAuras uses LeechCore, which is a fantastic library developed by Ulf Frisk, to integrate with DMA-devices out there. De-facto, LeechCore is a standard with which most devices out there are compatible.

For now, that integration is still in alpha-stage, drop me a message if you want to help with testing and are interested in developing something. Realistically, development using FPGA-board does not differ in any way from using ReadProcessMemory - EyeAuras abstracts you from all the complexities of managing LC API, reconnects, error handling, etc. All you have to focus on is writing a code.

Added more info here

Bugfixes/Improvements

• [Scripting] Fixed a problem with FPGA-plate not being properly released upon script disposal

Enabling conditions changes

Made it so only a subset of all Triggers is not available for selection as Enabling Conditions. Yes, that removes some flexibility from the system, e.g. you no longer can use Image analysis triggers. But. This also makes the system a bit simpler to understand, especially for new users.

Enabling conditions always meant to be global On/Off switches. If you want something more dynamic - use Trees/Macros or Auras with Triggers in them.

Folder properties editor rework

I continue to rework existing EA components 1-by-1 to leverage new UI framework capabilities. Newer version of folder properties editor not only loads faster, but is also more flexible.

Legacy version

New version. For the first revision I just wanted to reach feature-parity with existing functionality.

Default properties in Trees/Macros

Made it so you can set Target Window/Input Simulator for each tree/macro separately. Keep in mind that they also respect the normal properties hierarchy. E.g. if you set Target Window on a folder, in which Tree is located, it will respect that. But will also allow you to override that by setting another value on the tree itself.

Bugfixes/Improvements

• Nothing in this version

Bugfixes/Improvements

• [Scripting] Fixed Export to .csproj
• [UI] Fixed crash which in some cases occured during resizing
• [UI] Improved script cancellation logging - show now print the reason why user script got cancelled, e.g. because of Main window activation

Upgrade to .NET 8

.NET is a platform upon which EyeAuras is built. It affects all the tiny bits - startup, memory allocation, data management, literally every small bit of the program is affected by this change.

NET8 is not the latest version (there is already a preview of .NET 10), but platform upgrade is not something you do "just because", there must be a reason. I've picked .NET8 (and not .NET9/.NET10) because only for that specific version there is a prototype of a new memory management mechanism, which, from the current tests, just blows out of the water literally everything else that we had in .NET since its inception.

That is one of the primary characteristics of this new mechanism in comparison to what we have now ("workstation-sustainedlowlatency"). Basically this is the duration of those "hiccups" which tend to happen and are in worst cases become noticeable.

Memory VS CPU

Traditionally, there is always a tradeoff when you're developing a system - you can spend less CPU time, but it will cost you some extra memory OR you can save some memory, but it will increase CPU consumption. EyeAuras has almost always been picking the first option - memory is cheap and cpu cycles are expensive in consumer PCs (purely my opinion). But, aligning to that strategy also means that any improvements in the very core of memory management system should affect us greatly and that memory management mechanism seems to be a perfect fit. We'll see how it goes, but I am expecting to achieve a measurable performance jump in the nearest future.

Bugfixes/Improvements

• [Scripting] Added ScriptContainerExtension prototype - there will be a separate article on this later. For now it is in alpha-stage.

C# Scripts — Advanced — Referencing Scripts from BT/Macros

This feature lets you link another aura from a BT/macro if that aura contains a C# Script action. In programming terms, this is similar to referencing another project.
All classes and types defined in that script then become available for use in the BT.

The reference mechanism has technically existed for several months, but until now it was mostly hidden because it was incomplete and did not work the way I wanted.

Why use this?

You can now create a C# class that analyzes the game—through computer vision triggers or by reading memory directly—and provides the data your BehaviorTree needs to make decisions.
Instead of cluttering the tree with dozens of variables and checks, you can create a single class, for example TheGame, that encapsulates all data collection.

Bot example

This bot uses exactly the approach described below. It understands its environment, its own stats and the stats of nearby monsters, can build an action plan, and so on.
So far, the only limitation I’ve run into with this approach is my own ceiling.

Aura with the script inside

Let’s look at the "Shared" aura and its files.

TheGame.cs

public sealed class TheGame {
    public TheGame(IFluentLog log){
        Log = log;
    }

    public IFluentLog Log {get;}

    public int IntValue { get; private set; }

    public void Refresh()
    {
        IntValue++; // в реальности здесь может быть чтение из памяти или обновление триггеров
        Log.Info($"Refreshed the state, value: {IntValue}");
    }
}

This class prepares everything needed by the logic: trigger initialization, memory reads, OSD creation—whatever is required.
When Refresh is called, the state is updated.

Script.csx

[Inject] IAuraTreeScriptingApi AuraTree {get; init;}

Log.Info("Bot is being started!");

var tree = AuraTree.GetBehaviorTreeByPath("./New tree");
var game = GetService<TheGame>();
tree["TheGame"] = game;

This is how the TheGame object is passed into the BT through variables.
This is the key part that was missing before. Objects passed through variables are now fully available, without restrictions.

Behavior Tree

Example tree structure:

Updating data

var game = Variables.Get<CheatCrescendo.TheGame>("TheGame").Value;
game.Refresh();

In this node, we call Refresh, which updates the game state. By this point, the "TheGame" variable has already been initialized—either by the script or by another node.

Rendering OSD

return Run();

public IEnumerator<NodeStatus> Run(){
    using var osd = GetService<IOnScreenCanvasScriptingApi>().Create();

    var game = Variables.Get<CheatCrescendo.TheGame>("TheGame").Value;

    var textOsd = osd.AddHtmlObject();
    while (!cancellationToken.IsCancellationRequested){
        textOsd.Html = $"{game.IntValue}";
        yield return NodeStatus.Success;
    }
}

This is an example of creating an OSD that displays the current IntValue. It uses the new IEnumerator<NodeStatus> capability, which lets you split a node’s lifecycle into stages. On the first run, the OSD is created; after that, it is simply updated.

Game logic

Under the selector, you can place as many nodes as you want that check the current state.
All you need to do is access TheGame and call its methods.

For example, want to read HP directly from memory? Add a method to TheGame and call it from a BT node.
Need a color check via ColorSearch? Same idea.
Even movement between locations can be moved into a method: open a portal, select an option, click—everything lives in TheGame, and the BT just makes one call.

Performance

A number of performance-related improvements were added. If you notice any issues, please report them.

Fixes / Improvements

• [Behavior Trees] Prototype of parallel node loading — should speed up loading for large trees
• [Scripting] The PoeShared.Blazor.Controls namespace, which contains UI controls, is now available in scripts by default

Bugfixes/Improvements

• [Behavior Trees] Fixed PopOut crash
• [Behavior Trees] Fixed Action nodes not invoking linked Childs
• [Behavior Trees] Fixed "Toggle Nodes" not working properly
• [UI] Drag/Resize improvement - should feel a bit more "snappy" now
• [DMA] Changed DLL loading order - should fix a problem with LeechCore not initializing properly on some OSes/PCs

Behavior Trees - Action Nodes now have outputs

All action nodes (Wait, MouseMove, KeyPres, etc. - all of them) now have Outputs as well. Logic is exactly the same as it was with other nodes - linked node gets executed only if current node succeeded.

Bugfixes/Improvements

• [Behavior Trees] Fixed a bug - CTRL+A sometimes selected more than it should've

Performance - Macros UI optimizations

Done some major changes in how Macros are rendered, the overall UX should be better. Please, report any inconsistentices you may notice. There will be more changes in the following weeks, trying to address initial (first) rendering performance.

C# Scripting - Razor namespaces declaration

Probably it will be easier to show, lets take, for example a very basic Razor component created via :

That is what we get as a result

UserComponent.razor

@namespace GameGrind
@inherits BlazorReactiveComponent
<!-- your Razor/HTML markup here -->

UserComponent.cs

namespace GameGrind;

public partial class UserComponent : BlazorReactiveComponent {
    //some code here
}

Note that random namespace (GameGrind, in this case) which previously was automatically inserted whenever you added a new Razor Component. This is minor, but very inconvenient technical requirement that the scripting system had. One of such inconveniences would be the fact that such code could not be easily copy-pasted to another EyeAuras script - you either had to change the namespace OR had to deal with the fact that you have multiple different non-related namespaces in your code. None of those are good thing to have. From now on, namespace declaration is not a requirement anymore - you can omit namespace declaration in BOTH .razor and .cs files and EyeAuras will automatically insert them during compilation. Less code = less headache = better life.

Bugfixes/Improvements

• [Overlays] Changed how overlay is rendered on the screen (Hide/Show order during startup) - should make things appear on the screen a bit faster
• [UI] Improved responsiveness of drag'n'drop in Macros/BTs
• [Macros] Fixed a problem with Repeat/IfThenElse - drag'n'drop was not working properly
• [Macros] Fixed a problem with Cloning - from now, the entire hierarchy will be preserved and not only the selected node

BTs/Macros - Performance bugfix

In one of the latest changes in 1.6 I've introduced a bug, which made switching between BTs/Macros excruciatingly slow in some cases. Especially if you had multiple macros with a large number of nodes in them.

This patch fixes this. I'll be closely monitoring the situation.

Please report any kind of UI slowness you notice.

C# Scripting in BTs - IEnumerator

Major addition to our library of tools. More details here.

Bugfixes/Improvements

• [UI] Fixed vertical scrollbar in Macros
• [BehaviorTrees] Optimized BTs load times
• [BehaviorTrees] Fixed non-critical(recoverable) crash which happened if you quickly switch between multiple BTs/Macros
• [Scripting] Optimized dependency resolution - should consume less memory and be overall faster
• [Packs] Made is so CheckForUpdates is now disabled by default in Packs. You(author) can still enable it if needed.
• [BehaviorTrees] Added IEnumerator support in BTs

1.7 Day one patch

Following the feedback, this patch fixes a problem which was found in auto-update system - with Security Measures option enabled, the app was not updating properly and reverted to the previous version upon restart.

Unfortunately, for obvious reasons I cannot just release an update which will fix that. There are two solutions:

1. Temporarily disable Security Measures in Settings, update the app and enable it again.
2. Go to Downloads, download the installer and run it. Do not worry, all your settings will be intact.

Please keep reporting found problems!

Bugfixes/Improvements

• [UI] Fixed auto-update, which should now properly work for all 4 modes of operation (standalone, portable and security measures turned on/off)