[RELEASED 1.1.1] Panthea VS. Visual Scripting tool and Logic Editor

​

Get it from the AssetStore: http://u3d.as/YHk​

Hello everybody! Do you want to quickly develop games and prototypes? Then welcome to the new system of visual programming and logic editor Panthea.

Who we are: we are the Endemics Studio team with more than 10 years of experience in the gaming industry, we have been working with Unity since version 2.1.
Our website: http://endemics.org
Panthea VS Website: http://panthea.endemics.org
(here you will find documentation, a forum and a description of the key features)

How we differ from other systems:

• The main difference is that the system is built around ScriptableObject, in other words, it does not use the Unity3d component system. Components are used only where they are required, for example, physics, and even in this case everything is done automatically. Thus, all logic and all references to scene objects and prefabs are configured in the diagram. Working with the Unity inspector for the end user is to configure the content.

• Since all logic is inside the diagram and is not directly attached to objects through components, in the Panthea VS system it’s possible to load and execute diagrams (and logic sets) at runtime from anywhere, whether it's Asset Bundle (via WWW or internal link) or a file on the disk. If the diagram does not have references to objects, it can be used as a template in other scenes. Also, the execution of the diagram is possible both from another diagram, and from the code.

• Since we have the ability to execute and load diagrams from the outside, we made it possible to use the diagram as an instance (copy). If the diagram controls some object (for example, an NPC movement), then you can execute / run it for several objects in a loop, and each copy of the diagram will control its own object.

• Most analogues of the BluePrints (UE4) system receive all public methods and properties of classes through reflection, and these methods and properties are the base units operated by the user (in fact the system creates a chain of function calls). In contrast to such systems, Panthea VS is built around an element that is not just regular function, but an entity that implements any functional (in Unity3d component system it would be MonoBehaviour subclass). To be clear, an element is a block that can contain any functional (from simple addition of numbers, to implementation of complete game mechanics) and can have multiple input and output points. For example, we have elements that implement DragAndDrop for Unity GUI, Sprite and GameObject, there are elements for changing color in time, object visibility changing, object tracking, etc.

• An important difference from the analogues is the ability to redefine the appearance of elements in the diagram on multiple levels, from full override to replacement of certain widgets (header, entry and exit points, etc.). The override works in a similar way to Unity CustomEditor. In addition, when working with the element code, it is possible to use the Custom Property Drawer.​
  
  

​

• In Panthea VS system an element can contain multiple input and output points and there can be more than one connection between elements, so we have the ability to customize the call order. This increases the flexibility of logic building, i.e. it is possible to make a linear logic flow or a parallel one.

• The base unit in the Panthea VS system (element) can be configurable by the composition of the input and output points, and it’s also possible to create fully dynamic input points (including the type of data that they accept). For example, in the numbers addition element you can specify as many operands as you want in the element parameters. Also, the input and output points can be visually inverted so that the diagram is more compact, and the element itself can be minimized to take less screen space.

• Despite the fact that an element in our system is ScriptableObject, it supports calls to the methods Start, Update, LateUpdate, FixedUpdate, and also coroutines. More important, all these calls are done in one place, instead of having multiple calls in every element. In addition, you can set the order of calling such methods in the code. A simple example:
  
  
  Code (CSharp):

  1. [ElementDefinition(Name = "Start", Path = "Mono", Tooltip = "Call Start Mono method", Color = VSEColor.Green)]      
  2.  
  3.         public class StartElement : Element
  4.  
  5.         {                      
  6.             public OUTPUT_POINT DoStart = new OUTPUT_POINT();
  7.  
  8.  
  9.             [ExecuteOrder(Order = 1)]
  10.  
  11.             void Start()
  12.  
  13.             {
  14.  
  15.                 DoStart.Execute();      
  16.  
  17.             }
  18.  
  19.         }

• For those who are interested in the technical part, we would like to note that the elements do not use reflection when communicating with each other. Reflection is used only to initialize the diagram and to call the Start, Update, etc. methods and even in this case the calls are optimized so they do not use the slow version via MethodInfo.Invoke.

• We also have very detailed documentation that includes a user's guide to working with the editor, a description of all the elements, a guide to elements programming and API documentation.

About the system current state:

• The system is in the release version 1.1.0 (it was beta 1.0.0b1 before).
• Now there are more than 300 elements in the system, of varying complexity, which in general make it possible to implement the game without using any external code.
• The system is tested on Android, iOS, WebGL, PC / MAC, UWP (IL2CPP)
• The system supports Unity Personal, Plus, and Pro, minimal required version is 5.6.3.

Future plans:

• New elements (working with IAP, working with new Unity subsystems and more).
• New complex elements for game mechanics (Match3 (with AI), simple mechanics (Cards, Sorting, Pictures comparison, Puzzles), mechanics for FPS / TPS shooters, strategies, etc.
• Support and integration of third-party plugins (we will look at requests, at least Prime31 plugins and social networks).
• UML analog for diagrams. Configuration of meta logic (creating diagrams, connections between them, both direct and via global events), viewing the current state in debug mode (position in the diagram, transition to another state).

Who can use the Panthea VS system:

If you are the Game Designer:

• Prototyping without the participation of programmers.
• Testing ideas, mechanics, logic.
• Creating simple (or not so simple) games.
• The implementation of abstract mechanics (calculations, behavioral algorithms, AI, etc.), which can then be used by programmers in the code by calling and executing the diagram while the application is running

If you are the Artist:

• Ability to create effects chain without the participation of programmers.
• Creation of an abstract logic for the visual effects behavior that can be used by programmers in the code by calling and executing a diagram while the application is running.
• Creating simple (or not so simple) games.

If you are the Programmer:

• Creating elements of any complexity and taking out events that require visual effects, so that they can be customized by artists or game designers.
• Creating elements to support the work of artists and game designers.
• Rapid construction of prototypes and game and mechanics.
• Support for changing the logic behavior on the fly (by running the required diagrams)
• Updating the logic without updating the application (downloading new diagrams over the network).

PS: we welcome third-party development of elements and their free distribution through the Asset Store (also you can post them on our forum).

If you like Panthea VS system, get it from the AssetStore: http://u3d.as/YHk

List of changes compared to version 1.0.0b1

• Added ability to group elements:
  • Set group for selected elements.
  • Group name and group color settings.
  • Adding new elements to the group via drag and drop or the context menu.
  • Removing elements from a group.
  • Search by group
• Optimization of calling methods obtained through reflection (exclusion of a call through MethodInfo.Invoke)
• The work of the editor is optimized.
• Added support for Unity 2017.2 in the editor (playModeStateChanged events)
• Bugs fixes for the editor
  • Grid snap error.
  • Incorrectly displayed links between diagrams
  • Failed to set the serial number, if only one link number is set.
  • Errors when copying elements via the menu buttons of the diagram editor.
  • Removed blurring of fonts when outputting data between elements in debug mode.
• Fixed errors in the elements
  • An error in the GameObjectAddComponent and GameObjectGetComponent elements in Unity 2017.2
  • Sampling error of array element and a list element for a random mode.
• Added support for Retina displays for icons in the diagram editor menu.
• New icons for a pro editor skin.
• The window of diagrams communication scheme is updated.
• Added the ability to open diagrams by double-clicking directly from the diagram communication scheme.
• Added new elements:
  • UnityAds – element for working with Unity Ads
  • UnityAnalyticsCustomEvent, UnityAnalyticsMonetization, UnityAnalyticsUseAttribute – elements for working with Unity Analytics.
  • AutoHideSceneObject – element for hiding objects that are between the camera and the target through the replacement of materials.
  • CheckingObjectInViewPort – element for checking the location of the object in the scope of the camera.
  • FPSWalker – element controller for first person shooter.
  • FPSLook – look controller element for a first person shooter.
• Changes have been made to optimize and expand the settings in the number of elements (GameObjectCreate, etc.)
• Added an example of the game Find a Pair (Memory) with content.
• Added output of information about the data contained in the localization asset.
• Refactored the system of redefining the appearance of elements.

Future plans:

Features on the list:

• Improved search in diagram.
• Improvement in the interface of the diagram editor.
• Adding the ability to create an element script from the menu.
• Open an element script from the catalog.
• Adding a new attribute that will allow you to view the value of the private fields of the element in debug mode.
• Adding the ability to redefine the appearance of all the child’s of an element class in the diagram editor.
• Optimize the size of the diagram on the disk and in the memory.
• Adding a UML analog to create diagrams and relationships between them (will allow to implement the FSM, where the diagram appears as the state)
• Adding the ability to view the state of the logic flow (which diagram is active at the moment) in debug mode

Also there will be features, which we don't ready to annonce yet.

 

Nice One

 

Thank you!

 

Here is the place, where we will write about new features in progress for the next versions:
https://forum.unity.com/threads/wip-released-panthea-vs-new-visual-scripting-system.502497/

 

Panthea VS Tips & Tricks: Fast Drag & Drop mechanics.

 

Panthea VS Examples: The diagram of game controller for "Find a pair" game

 

Hi guys!
We just rolled out release version with improvements and fixes.
Look in the thread header for details.

 

An example of a simple game (Memory) made with Pantnea VS (without writing code) http://panthea.endemics.org/WebGL/index.html

Follow our twitter https://twitter.com/EndemicsS

 

Welcome to the Pantea VS lessons. Look for more at our YouTube channel

 

Panthea VS Tips & Tricks: Fast FPS prototype (walk, run, look and shooting)

 

Hi everybody,
We've just released Panthea VS version 1.1.1!
Here are the list of changes:

New elements:
- in-game console (intercepts and shows the logs).
- converting viewport coordinates to a ray for casting.

Changes in elements:
- added input points for setting position and rotation of created object to the GameObjectCreate element.

Fixes:
- fixed the error with opening element script window, in case the name of class is partially match the other class.
- small fixes and refactoring in the diagram editor.
- hotfix for one element for 2017.3

 

Nice VS tool. Do you have any Roadmap to show off, just to see what future implementation we can expect...

 

We have many plans, but little time, so, unfortunatelly, can't specify exact dates yet.
Features on the list:
- Improved search in diagram.
- Improvement in the interface of the diagram editor.
- Adding the ability to create an element script from the menu.
- Open an element script from the catalog.
- Adding a new attribute that will allow you to view the value of the private fields of the element in debug mode.
- Adding the ability to redefine the appearance of all the child’s of an element class in the diagram editor.
- Optimize the size of the diagram on the disk and in the memory.
- Adding a UML analog to create diagrams and relationships between them (will allow to implement the FSM, where the diagram appears as the state)
- Adding the ability to view the state of the logic flow (which diagram is active at the moment) in debug mode

Also there will be features, which we don't ready to annonce yet.

 

Many features !
What does this here mean :
- Adding the ability to create an element script from the menu.

 

This means - create a C# template for a new element with basic structure.