Under review

Minimalist Horizontal Editor UI for taming "visual noise"

mode80 2 months ago in Game Creator updated 1 month ago 4

This is a follow up to the topic originally titled "Using Game Creator actions from C#?"...

I dove into the GUI code with the idea of making a horizontal GUI editor layout without all the labels and other sources of "visual noise" that make it hard to tackle game logic beyond a low-level complexity. 

I determined it was too hairy for me to pull off myself. (Also wow. That well is deep.) 

But I did take some screenshots that might inspire you to include such an option for Version 2. 

This a simple "script" that initializes the inventory with a bunch of test objects (character cards in my case). Even though there are no conditions or other sources of complexity, it takes a few moments of squinting to look past all that UI to see what's going on. 

My vision of the minimalist horizontal editor UI is that no action, trigger or condition would take more than a single vertical row, and all descriptive text would be inside tooltips that only appear when you ask for them. 

Here is a "rough draft" idea of what that looks like for the same script above. 

I find this way easier to read. It's obvious what it does at a glance even without the labels. 

When I tried to make this prettier and extend the idea to triggers and conditions I got overwhelmed. (IMGUI really wants to put properties on separate vertical lines with a ton of labels and it spreads this assumption around over many many places.) Add-ons like Odin would make this a lot easier, but it doesn't play well with pre-existing custom editors. The new Unity UIElements might offer some hope. 

Anyway, I wanted to pass that along in case it inspires you. Thanks

Unity version:
2018 LTS
Game Creator version:
Under review

Hi Mode80! I just answered you back on the other topic, but I see where you go now. I really like where this conversation leads.

Although I can't really force all Actions to be contained in a single line, that's why I created the "summary" text, which is dynamically updated based on the values of what the user has inputed.

If you collapse all Actions, you can see them without all the "noise". Isn't this better? You don't get constrained by the amount of objects in each Action (whereas in your case, you are limited by the horizontal space) and you get a summarized version of what that Action does.

PS: Yeah IMGUI does suck, but once you get used to it, it's kind of easy to work with. UI Elements should make things easier, but it's way too green to assert that yet.


Yes, I probably chose a poor example because the benefits don't really shine until there are conditions and variables in the mix. I may still take a stab at a GC horizontal "code editor" using the new UI Elements as a way to get familiar with that package. Happy to donate it if it goes anywhere. 

In the meantime, I'll keep my fingers crossed for a way to invoke Actions via C#.

Ah understood. Maybe the problem is when you start throwing Conditions & Actions in the mix. We'll look into it for the next GC version. Now that Unity allows polymorphic serialization we may be able to add Conditions at the top of an Actions object. That would cover a lot of cases and would look quite minimalistic.

Yes, conditions and variables are where it starts getting out of hand. Maybe I'm stretching the tool beyond what it's designed for, but it does seem within reach to make all these features usable together. It may be more of a UI challenge than a technical one. 

In case it helps, the makers of Odin have open-sourced their well-tested polymorphic serializer under a commercial use license.

Thanks! We were really excited that Sirenix releasted their Odin Serializer as an open source tool. Unfortunately it's pre-compiled into DLLs and can't work without the Roselyn compiler (a different one that Unity uses). This means we would need to add the library files into Game Creator. This usually means... Trouble. Some Asset Store publishers release their assets in DLLs but we prefer to release plain source code. It makes it so much easier to work around incompatibilities, provide support, ...

We also looked at Full-Serializer (used by Bolt) but we decided to use future-proof tech provided by Unity itself.

Thanks for bringing this up though! :-) And getting back to the original topic, we'll keep investigating.