Fungus Unity C With Lua Cream
Tolua
Fungus Unity C With Lua Benefits
Fungus Unity C With Lua C
Fungus Unity C With Lua &

First, let us create three buttons to test with.

Programming in Lua (first edition) contents errata code manual newer editions This is the online version of the first edition of the book Programming in Lua, a detailed and authoritative introduction to all aspects of Lua programming written by Lua's chief architect. FungusLua is an easy way to add Lua scripting to any Unity project. It's based on the MoonSharp project, and works great with the Fungus story telling tool f. LuaBindings: Maps Unity objects & components to Lua variables for use in Lua scripts. LuaScript: Runs Lua code from a text file or from a string property. LuaStore: Stores variables in a global table which persists across scene loads. FungusModule: A set of utility functions for scripting Unity and Fungus from Lua.

Find this & other Tools options on the Unity Asset Store. Get the Lua Framework package from Georges Dimitrov and speed up your game development process. Find this & other Tools options on the Unity Asset Store. Discover 2021 is on now: Dig into this year’s top new assets at 50% off.
After a rocky couple of years I'm back on YouTube with this first installment in what should be a short series making a basic asteroid mining game, using LUA.

Create a new scene, call the new block in the flowchart Buttons, create 3 clickable Sprites, call them button1, button2 and button3, put them inside a new Game Object called BUTTONS, and give them different button textures from the Assets -> Fungus -> Textures pictures.
Now we need to create a new block for when button1 is clicked, we call it Button1clicked and make it execute on event: Sprite -> Clicked -> Button1
make button2 and button3 invisible at the beginning of the block by using ShowSprite twice, one for each.

Plus sign on the variables tab at the bottom of the flowchart window -> different types of variables.

Now, let us use an integer variable instead of a boolean one.

create an integer variable and call it button1Clicks, by default it is set to zero

Now in the new block Button1Clicked, we need to set our if conditions.
To create an if condition, we add it to the commands using:

Plus sign -> flow - > if
Plus sign -> flow - > else

if button2Ontrue (choosing the variable and checking boolean data in the if command)

SetVariable button2On=false (from the variables commands, and choose the variable)

else

ShowSprite(visible) on button2 (checking the visible in the command)

SetVariable button2On=true (checking the boolean in the command)

end

can also change scale to zero and then use iTween -> ScaleTo command (instead of ShowSprite)

we can also add a sound to it

Now to make a sprite invisible but also not detectable (cannot be clicked) we need to go one step further, we use the Sprite command: SetCollider

and instead of targeting only one sprite we can target a certain tag to apply the command to a group of objects which have this tag. (this can be used with SetCollider but cannot be used with ShowSprite right now)

To do this, we set the tag in the inspector of the objects to a new tag by choosing Add tag in the dropdown menu at the top of the inspector.

Now in the commands, we can do a nested if statement, so

Fungus Unity C With Lua Cream

ShowSprite(invisible) on button2

Tolua

ShowSprite(visible) on button2

SetVariable button1Clicks+=1

ShowSprite(visible) on button3

end

Labels:
We can create a label inside a command sequence to jump to it from another command and continue the commands after it.
We create a label from the flow commands (Plus sign -> flow -> label) and call it skip
Then we can jump to it using the flow-> jump command and set the label to skip (so we can skip all the commands inbetween) then we can use a call command to skip the whole scene to the next scene, for example. We can also call a block from another flowchart.
Adding an option for exiting the game using the ESC button:
To let the game end on ESC, just add a block which executes with the key pressed ESC and add to it flow command Quit.

Arbor Interactive projects have an interesting separation of code and data. A given project may be thought of in two “halves”– the “engine” and the “cloud config”. The former is a Unity project with game logic written in C#, and the latter is a google sheet containing the game’s data (characters, statistics, enemies, icons, sound files, stage layouts, etc).

The Benefits of (Cloud-Config) Lua

In addition to storing and processing image files, audio files, and general text data, the Cloud Config may also store Lua code, as a means of treating logic as data too. Unlike the C# and C++ code that makes the “engine” half of the game run, Lua code may be edited in the cloud and re-downloaded by client apps at runtime, making hot-patching fairly easy.

In fact, it’s easy to imagine a host of beneficial properties for a project that is made mostly of “Cloud Config” Lua–

The aforementioned hot-patching.
Accessibility of gameplay systems : Interns and beginning programmers may learn Lua faster than they learn C#.
Decoupling from Unity : Unity is fantastic technology, but it won’t belong to a scrappy startup forever. The company will likely become public within the next half-decade, or be purchased by one. As their competition with Unreal stabilizes, their focus will likely turn towards ROI and a squeeze isn’t out of the question. It would be nice if we were less reliant on Unity’s technology than we are today, and putting more and more of our tech stack into free-and-excellent software like Lua helps with this.

Our Ugly Current Lua Dev Environment

And this already exhibits several big downsides–

No syntax highlighting.
No “Find All References” or “Peek Definition” features.
Tabbing does not work (it moves the cursor to the next cell).
Pressing enter, by default, proceeds to the next cell rather than create a newline (control-enter does this).
Absolutely no error checking– to the spreadsheet, this just looks like text.

In other words, we can edit code within the sheet itself but we’ll be missing out on proper IDE features that boost productivity. It’s easy to imagine that this lack of features will cost us far more productivity than the switch to Lua is worth in the first place.

The answer? We’re going to integrate a popular IDE (Visual Studio Code) with our “Cloud Config” spreadsheet “databases” via a Plugin– a process to be documented in a series of posts. In this first post, we tackle the issue of Lua -> C# bindings.

Fungus Unity C With Lua Benefits

The Problem : “What C# Functions can we Call?”

As a developer writing external scripts, at some point we’re going to wonder what functions are available to us– how can we interface with the game engine?

A cursory glance shows that one common approach is to use hand-made wikis, such as what we see on the Binding of Isaac : Afterbirth wiki.

I’m not a huge fan of this approach, as it requires someone to maintain a website, and it requires the scripter to use their browser to verify something as quick and simple as the correct spelling of an callback event.

The same game also appears to provide a convenient Lua enum that gives the scripter all of the possible event callbacks.

It’s not immediately clear that this code enum is populated by hand, or auto-generated by a script the development team has, and we must avoid the former (because we’re going to be creating a lot of Lua-accessible functions if we’re going to build an entire game from script).

A promising solution then, would be to try and autogenerate things like the above enum, rather than update it by hand.

The auto-generated bindings file

When the auto-generation is finished and working, we would like to produce a file like this–

This file gives us code completion :

This s