Would really love verse to have an interface to write scripts fast and easy, without loss of the engine flexibility.
So I made a concept that details a fine balance between the power of Verse and the agility of Creative mode.
Bit of my background so you know where I stand. I am an artist with game design in heart. Even though I have programmed games before (made my first game 20 years ago), I only used interfaces and never code. In my mind, everything can be turned into a visual-scripting interface, as everything is a visual scripting interface already.
OBJECTIVES
-Do not pass development issues/hurdles to the user, let them worry about their own
-Visualize code in scripts with icons and colors (to help identify logic - an image is a thousand words they say)
-Agile workflow, tiles act as “macros”, with further customization appearing as a context-sensitive menu (think Project Spark brain editor, after you add a tile you get modifiers). This helps avoid superfluous initialization and syntax.
-Help younger ages get compelled by programming by keeping the fun elements of it.
-Instead of always having to script X to be able to have a niche feature you need once, you only script the absolute necessary, and all niche features are added as modifiers past the default behavior (relates to point 3).
-Help users gain more creativity and let them focus on their projects
-Regardless of how a user scripts, the code looks clean (due to the structure of the interface)
-Creating a game should be a matter of hours and 2 weeks max for large projects.
THE CONCEPT
Loading scripts from Creative. Verse Simplification and Interface (or VESI) can run from inside Creative and will create verse scripts that can be accessed directly from UEFN (through VS Code). The folder system for scripts is shared between the two (Creative and UEFN). Anything made in verse will also show in interface format in VESI.
In VESI, any logic file has an icon next to it that indicates the file or script type (like a device, an event, or a music track).
There is also a preview window on the right that will allow the user to quickly glance at logic, so they can reference their logic without opening the script editor interface. The preview window remembers the scroll location, so you can quickly toggle it by Tab, or hold with ALT while in Creative (existing functionality). This helps debug gameplay mechanics and cutscenes and also allows less clutter inside the level itself.
Similar to how UEFN/Verse works, you cannot edit a script from this screen and any changes made to it in the file while you are previewing will update live, similar to how prop transformation works.
Helping the agile flow, this interface is also designed for all platforms (+consoles +mobile)
For example, the scroll locations on PC will work when you move the mouse inside them, in consoles users can use the two thumbsticks, and in mobile its a finger drag gesture.
Creating something in VESI should be simple and provide icons to help users unfamiliar with technical terms (even the simple ones) understand what they mean (specifically kids and people with language barriers past the supported languages in FN)
THE SCRIPT EDITOR
After you create a new device logic, you are greeted with the script editor, where all the magic happens. In a perfect world, anything that can be scripted on VS code in Verse, can also be found here.
This links Verse with all platforms and open up immense possibilities for teams working on the same project.
Version control will restrict a user from accessing a script that is currently being edited by another user (if they are both in the same party building together), but will allow live preview (from the preview window in image 1) helping them collaborate together in code, and they can always switch places by having the user save the script and exit into Creative/UEFN, then the other user opens it (doesn’t count VS Code, both users are in VESI).
Allow me to explain a few more points about the script editor shown above.
Script editor has a line format, where each code is shown on its respective line of code. The user can interact with the line number to insert new lines up or down, or embed the line to the line above. Hovering to the line number will swap the cursor to a holding hand, and pressing it will allow them to move the line up/down, then place it again to exit movement mode.
On top of the code you can see pages and page titles. This is a feature that Project Spark had and it is great to organize your code into different functions within the same device, so you don’t have to search and toggle other scripts all the time. This also helps with dialogue systems, as you can copy-paste pages that act as the character dialogue logic.
Moving into the actual scripting, there are multiple elements transferred directly from Verse, with some making it as icons, and others as a simplified version of the existing functionality.
First of all, there is no “using” line required by default Verse modules. Instead, the moment you use functionality that requires a module, the module is added to that interface automatically (hidden from view, only seen through VS Code). However, the user can utilize “using” if they want, referencing their own scripts. This is done by adding the “using” tile and selecting a script from their folder structure.
Class declaring is done by adding a page name to the script. If a user adds no name, a name is selected based on the name of that device (handled by “rename” button on Creative).
Device settings can also be exposed in Script editor, so you can change elements during gameplay. An example is player class selection, currently in Creative you only have the option to set all player values together, and changing one requires you to change player class, affecting all other values (like HP, Shields, movement speed, sprint, auto-reload). With this interface, you can selectively change class values on demand, during gameplay (so for example you can create a leveling system that increases your HP without affecting other stats that have their own leveling systems).
The interface extends and scrolls to the right through the bar on the bottom of the line for PC, pressing right on the thumbstick while on the line will snap a hand cursor (animation if any has to be extremely fast to not slow down the process) into each tile/modifier selectively, and on mobile, you can drag to the left to see more elements in that line.
Adding new tiles needs to be super fast. Opening the tile catalog should have no animation, it just pops open (any visual elements like animation or menu VFX can be added past its opening) because that action will be done millions of times by users, so even a 0.1-sec delay adds up pretty fast in the long term.
EPILOGUE
If you liked this concept and want me to detail more areas of how VESI would work (sequencer timeline and music editor, as well as a more detailed view on the script editor) let me know and I can get to writing. This took a long time to make, but even if one thing makes I will be incredibly happy because I know UEFN will be a tool I will be using for a long time, so any agile workflow is greatly appreciated. Thanks for reading and keep up the awesome work!
P.S. For more details on a similar implementation of a script editor, this YT playlist shows examples of how Project Spark handled a scripting interface (called the brain editor), similar to what I am detailing here: Project Spark Tutorials - YouTube
