Re usable logic node macros

This is not a request

We should be able select logic nodes and turn them into a macro.
Similar to coding apis or classes you can instanciate or call.

  • Those macros would be be represented as some single logic node with inputs and outputs.
  • We could export macros to files, anyone could include them in their project adding them to “lib” folder or some “macros” folder.

For the twin stick demo there is lot of big logic node that should be divided in macros.

For example “pursue player” macro :
Inputs :

  • object that pursue
  • player object
  • distance minimum pursue
  • distance attack
  • walk speed
  • walk animation name to play
  • attack animation name to play
  • action done output to call another action if needed

Another example, moving platform :
Input :

  • object to move
  • empty object start position
  • empty object goal position
  • speed
  • mode loop
  • mode ping pong

This way people that does not know coding and logic nodes, could have a library of high level macros to create gameplay.
Similar to 2D engine like construct, users assemble logic bricks without knowing code.

Example macros library specific to fps games :

  • fully customizable advanced player controller macros for controls, animations, effects
  • HUD macros to display health, radar, objectives
  • Ai macros fully customizable, different type of ai , customize models, animations ,effects
  • many customizable interactive objects, for example ladders, platforms, devices and buttons
  • save load game macro.

Anyone could bring a game using macros as they do in construct without logic node deep understanding.

There is many benefits :

  1. avoid spaghetti nodes, macros hide the complexity
  2. users without programming knowledge could create their own gameplay
  3. Fast prototyping using macros for experienced logic node users, before creating their own logic nodes functionality.

What do you think ?


I agree with the general idea completely. Is this able to be done with the call/end/return/start function nodes in the logic pack and then saved as blend files and distributed?

Some of the UI ideas are great too but I am not sure they are functional at this time. For example I can’t find any way to change the slider position of the ZUI slider from a variable. But I guess that would all come in creating the functionality.

I personally think this is exactly the thing that the community could work together and make armory better from a user stand point while Lobos continues to work on the “under the hood” stuff. I would love to hear from the coder guys in the group to see what is possible and what is not.

I have sent a message asking if we could add some categories to the forums for exactly things like this. That way we could have a thread for each idea. (i know we can now but it would be nice to separate these projects out of the general section.

1 Like

I hope there will be a way to get macros.

This is best for re usability, quick prototype games (good for users that does not know logic nodes programming).

And to avoid spaghetti code, for example the twin stick logic nodes could become three macros.
From this :

To something like this made of re usable macros, high level logic, combined with logic nodes data variables.

When needed anyone could modify macros to create new ones better suited for their needs.

Yes, I think that this is a great idea. :slight_smile:

I’ve done some work in the logic node system now, and it should be within reach. I don’t think I have enough knowledge of the Blender API to implement it yet, though. I might try it sometime though.


It’s not a request, you don’t have to work on it.

Perhaps Lubos knows if this can be done or anther way ?
Anyone is free to propose new ways to make re usable content.

The Construct way using logic bricks to get a full game without knowing programming is the goal.
Bricks to make fps games, runner games, space ship games or any genre.

I know. :slight_smile: I am going to be building a large amount of my game with nodes because it is supposed to be moddable and very easy to get into, even for non-programmers. I’m trying to mature the logic node system as necessary to facilitate that.

Also I think that Lubose can use all the help he can get. If there is something that I can work on, it will let him work on the stuff that I can’t, at the same time. Let’s get Armory moving even faster, right? :wink:


This sounds like node groups, or am I getting this wrong?
Unfortunately, node groups are not implemented in armory (yet). Another idea would be to abuse the init function of a node to add multiple nodes, just like adding a group.
This way one could, for example, make a node “LookAtPlayer”, which, when added, adds all of the nodes which you have in your LOOK AT PLAYER frame in the screenshot. It would then connect the nodes, frame them and select them, so one can move it around and place it just like a regular node.
A problem of this approach is obviously that it still requires a lot of space in the editor and it cannot be done on-the-fly or without programming knowlegde. However, as a user, one could easily modify the behaviour of the new node if one wants to and the new node can easily be distributed just like any other node.

The macros is to replace your logic nodes frames or group by one node with corresponding inputs and outputs.
The advantages it hides all complexity , it’s high level , it’s avoid all spaghetti code compares to frames or groups.

Yeah, I think it pretty much is. Maybe we should just try to clone this from the cycles material node groups.

Great example explanation is always better