Although basic understanding of Stormworks, logic and game components is recommended (and needed), no previous Lua experience is needed. This is a crash-course guide intended for absolute beginners!

• Fundamental terms
  
• Syntax
  
• Input/Output
  
• Data types (NIL, Bool, Number, String, Table)
  
• Tables
  
• Variables
  
• Operators
  
• Statements (if, then, else, elseif, while, do, end)
  
• Functions (onTick, custom functions, onDraw)

The most important thing this guide will teach you, and the purpose of it in the first place, is to learn the fundamentals of the Lua language, allowing you to form a fluency like in any real languages such as Spanish or English. This fluency will let you convert ideas and creativity into working Lua code that serves a purpose.

Think of Lua as the universal language of communication between you and your creations. With Lua scripting, you can interact with your vessels and systems at a granular level, enabling you to craft intricate automation and create immersive experiences.

The potential of Lua in Stormworks is immense. Whether you want to build autonomous drones, intelligent navigation systems, or complex mission scenarios, Lua will be your indispensable companion on this journey.

Want to create your own Stormworks matrix world? With Lua you can! (I think). "Do you think that's air you're breathing now?"

To learn Lua, you will need to create a Lua script that you can write code in. In Stormworks, you do this within a microcontroller.

In the images below, you will be given information on the options you have. Keep in mind that you don't need any logic inputs or outputs to the microcontroller to create a Lua script within it. If we need logic anywhere in the guide, you will be given instructions on what to input and/or output as you get there!

View full image[ibb.co]

View full image[ibb.co]

Here are some commonly used words when Lua scripting (and some within coding in general):

---

• Variable: A named container for storing data. It can hold numbers, strings, tables, or other values.
  
  
• Function: A block of code that performs a specific task. Functions can take input (arguments) and may return a value.
  
  
• Table: A versatile data structure that holds collections of data using key-value pairs. Tables act like arrays, dictionaries, or objects.
  
  
• Object: In Lua, an object is often represented as a table with properties and methods. It's an instance of a class.
  
  
• Method: A function that is associated with an object or a class. Methods can modify the object's data or perform actions related to the object.
  
  
• Class: A blueprint or template for creating objects. It defines the structure and behavior of objects that belong to it.
  
  
• Variable Scope: The region of the code where a variable is accessible. Variables can have local scope (accessible only within a specific block) or global scope (accessible from anywhere in the script).
  
  
• Conditional Statements: Statements that allow the script to make decisions based on conditions. Common conditionals are if, else, and elseif.
  
  
• Loop: A structure that repeats a block of code multiple times. Common loops are for, while, and repeat.
  
  
• Operator: Symbols that perform operations on variables or values. Examples include + (addition), - (subtraction), * (multiplication), / (division), == (equal to), ~= (not equal to), > (greater than), < (less than), and more.
  
  
• Comment: Lines of text in the code that are not executed but serve as notes for the programmer. Comments start with --.
  
  
• Concatenation: Combining strings together using the .. operator.
  
  
• Indexing: Accessing elements in a table using their keys (for associative arrays) or numerical indices (for arrays).

These are some of the fundamental terms you'll encounter in Lua scripting. Remember, Lua is a versatile and beginner-friendly language, so with practice and exploration, you'll become more comfortable using these concepts to create exciting scripts and programs.

Syntax is the way we write the code in order for the computer to understand us. Languages like Java have a very complex and difficult syntax and can often be hard on the eye, whilst Lua on the other hand, is very simple and easy on the eye.

Comments are used to annotate code and are ignored by the interpreter. In Lua, you can add comments with a double hyphen (--).

You can also add multi-line comments in Lua. It starts with two hyphens (--) followed by a set of double square brackets ([[). The comment text is then added on the subsequent lines, and the comment is closed with another set of double square brackets (]]) followed by two hyphens (--).

Variables are used to store values. In Lua, you don't need to specify a variable's type - the interpreter will figure it out based on the value you assign to it.
Example:

Functions are blocks of code that perform a specific task. In Lua, you define a function using the function keyword, and you call a function using its name, followed by parentheses.
Example:

Conditionals are used to make decisions based on the value of a variable or expression. In Lua, you use the keywords if, elseif, and else to create conditionals.
Example:

Loops are used to repeat a block of code multiple times. In Lua, you can use a while loop or a for loop.
Example of while loop:
Example of for loop:

You don't need to understand what loops, variables etc. are yet, and i don't expect you to, but the syntax is still nice to know as it will give you an understanding of how to structure your code. Feel free to come back to this section when you start writing actual code, as it will come in handy!

The Logic Input and Output system is a way for Lua scripts to interact with the game's logical systems. The Logic Input system allows you to read the state of logical inputs in the game (like switches or buttons), while the Logic Output system allows you to set the state of logical outputs (like lights or motors).
How to use it:

In this example, we're using two built-in functions to interact with the game's logical systems.

input.getBool(1) reads the state of the logical input connected to input number 1 and returns a boolean value (true or false) indicating whether the input is active or not.

output.setBool(1, true) sets the state of the logical output connected to output number 1 to true. You can replace true with false to turn the output off instead.

You can use these functions in combination with other Lua code to create complex logic circuits and systems within your StormWorks creations. For example, you might use the input.getBool function to check the state of a switch, and then use an if statement to run different code depending on whether the switch is on or off. Or you might use the output.setBool function to turn on or off a set of lights depending on some other condition in your script.

Lua has several data types used to represent data to use in your script. By understanding the basics of the 5 data types explained below, you will be able to use them when learning about more advanced Lua functionality.

These examples are simply to show how these data types look and are written. We will dig more into how to USE data types as variables in functions later.

Before we start, at the top of your Lua script, type "function onTick()". With this function, you can freely test Lua functionality. If you put code outside this function, you might run into errors. Remember to put an "end" statement at the bottom of all your code that you want within your onTick function.

Example to get started:

---

NIL is nothing. The value of the NIL data type will always be nil.

Bools represent one of two values: True or False. If something is True, something in Stormworks is on, if something is False, something in Stormworks is off.

Numbers are floats, meaning they always have decimals. You can define a number as 10, but it will still be interpreted by Lua as having decimals, sort of like 10,000...

Strings of characters forming as text.

• Let's define a string with the text hello:

• Or with the number 10:

Strings can be True/False (booleans), numbers, text, etc. It's important to remember that text needs to have quotation marks before and after it, while numbers, booleans, etc. do not.

Tables are the only data structure available in Lua that helps us create different types like arrays and dictionaries. Lua uses associative arrays and which can be indexed with not only numbers but also with strings except nil. Tables have no fixed size and can grow based on our need.

This can be useful in creating loops, etc. Note: Remember to use curly brackets, not square brackets!

Example of a table:

---

Here is a simple example to show how to use data types. We will use a function called print, more on functions later in the guide! For now, focus on the data types.

Let's print some values. We use the type() function within the print() function. The output will be what data type the value within the type() function is. For example, type(true) when within the print function will print boolean. Here is how it looks:

Let's use variables to print. The data type here will be number, since dailyApples is defined with the value of 13 without quotation marks. If it was "13", it would be a string. Here is how it looks:
As you can see, we define the variable "dailyApples" as 13, then we use it within the variable "weeklyApples" where we multiply dailyApples by 7. dailyApples is already defined as 13, so it's the same as writing 13*7 since the data type of dailyApples is number.

After defining the weeklyApples variable, we then print it with the print() function. Since weeklyApples is defined as dailyApples, which is 13, times 7, the output to console will be 91.

You now have a grasp over the basics of the different data types, including tables, but due to the complexity of them a further explanation is required.

Tables are a fundamental data structure that allow you to organize and store collections of data. Think of them as containers or boxes that can hold various items, and each item has a unique label (key) for easy identification.

---

Imagine you have a toolbox with different tools inside. Each tool has its name written on it. In Lua, you can represent this toolbox with a table:
In this example, 'toolbox' is a table with three items (tools). We use the tool names as keys to access the corresponding tools' descriptions.

Let's say you want to add more tools to your toolbox or change the description of a tool. You can do it like this:
In this example, we added a "saw" to the toolbox and updated the description of the "hammer."

Let's say you want to go through each tool in the toolbox and do something with them. You can use a loop to iterate through the table:
The 'pairs' function allows us to loop through all the elements in the table. The 'key' variable represents the tool name (e.g., "hammer"), and the 'value' variable represents the description (e.g., "steel hammer").

Tables can hold various data types, not just strings. Let's create a table with numbers and strings:
In this example, 'mixedTable' contains a string, a number, and another table holding scores.

---

In Lua, classes can be implemented using tables to represent objects and functions as methods. Here's a short example of how you can create a simple class using tables:
In this example, we create a simple class 'MyClass' using a table. The class has a constructor function 'new', which creates a new instance of the class and sets its properties. We also have a method 'printDetails' that prints the object's name and age.

When we call the constructor 'MyClass.new()', it returns a new instance of the class (represented by the 'self' table). We can then call the method 'printDetails()' on each object to display their details.

Output:

In the example at the bottom of the data types section, you could see that we used variables to define a value to print to console. Let's actually understand what a variable is, and how we can use it!

Variables are a way to store and manipulate data in your scripts. You can use variables to hold numbers, strings, booleans, and other types of data, and then use them in your code to perform calculations, make decisions, or output information.
Example:
In this example, we're using variables to hold the values of x and y, which are both set to integers (10 and 5, respectively). We then perform some calculations using these variables and store the results in two new variables, z and w. Finally, we output the results of these calculations using the print function, which writes text to the game's console.

Variables can also be used to store more complex data types, like tables (which are similar to arrays or dictionaries in other programming languages). Here's an example of how to create and use a table variable:
In this example, we're creating a table variable called myTable and initializing it with three string values ("apple", "banana", and "orange"). We can then access elements of the table using the [ ] operator, which takes an index (starting from 1 for the first element) and returns the corresponding value.

By using variables effectively, you can create more complex and flexible scripts for your creations.

Now that you know what variables are, we will use operators to perform modifications to the variables.

Operators are symbols or keywords that you can use to perform operations on variables and other data types. There are several types of operators in Lua, including arithmetic operators, comparison operators, and logical operators.
Example:
In this example, we're using several different types of operators to perform different operations.

Arithmetic operators (+, -, *, and /) are used to perform basic arithmetic operations on numeric variables. We're using these operators to add, subtract, multiply, and divide the x and y variables and store the results in new variables.

Comparison operators (==, ~=, >, and <) are used to compare the values of two variables and return a boolean value indicating whether the comparison is true or false. In this example, we're using comparison operators to compare the values of x and y and store the results in new boolean variables.

Logical operators (and, or, and not) are used to combine boolean values and return a new boolean value. In this example, we're using logical operators to combine boolean values and store the results in new boolean variables.

Great! You now know the basics of operators. Operators can be used in statements, and here's, in simple terms, how statements work!

Statements are commands or instructions that perform a specific action. Statements in Lua scripting are often used to control the flow of execution of a program based on certain conditions.

Examples:

The if...then...else statement allows you to execute one block of code if a condition is true, and another block of code if the condition is false. Here's an example:

The elseif statement allows you to test multiple conditions and execute different blocks of code based on the result. Here's an example:
In this example, if the speed is greater than 50, the first block of code is executed. If the speed is greater than 30 but less than or equal to 50, the second block of code is executed. Otherwise, the third block of code is executed.

The while...do...end statement allows you to repeat a block of code while a certain condition is true. Here's an example:
In this example, the code inside the while loop will be executed repeatedly as long as the speed is less than 100. The code inside the loop increases the speed by 10 and prints a message to the console.

These are just a few examples of the conditional statements available in Lua scripting in Stormworks. These statements are used to control the flow of execution of a program based on certain conditions and make the program more dynamic and responsive to changes in the environment or user input.

The onTick function is a built-in function in StormWorks that gets called every game tick (which is a tiny unit of time in the game). You can use this function to run code that you want to execute repeatedly, like checking the status of a sensor or updating the position of an object.
Example:
In this example, the onTick function is used to check the value of a sensor connected to input number 1, and then set the output number 1 to either 100 or 0 depending on the sensor value.

The onDraw function is another built-in function in StormWorks that gets called every time the game needs to draw something to the screen (like a text label or an image). You can use this function to draw custom graphics or text on the screen based on the current state of your game.
Example:
In this example, the onDraw function is used to draw text on the screen displaying the current score of the game. The drawText function is a built-in function in StormWorks that takes in a string of text and two numbers (representing the x and y coordinates of where to draw the text on the screen).

Custom functions, on the other hand, are functions that you create yourself to perform specific tasks. You can define these functions using the function keyword and then call them later in your code whenever you need them. For example, you might create a function called calculateSpeed that takes in the current velocity and acceleration of an object and returns its speed.
Example:
In this example, we define a custom function called calculateSpeed that takes in two arguments (velocity and acceleration) and returns their sum as the calculated speed. We then call this function and pass in some example values for velocity and acceleration.

Hope you found this guide helpful. Lots of good luck on your journey with Lua in Stormworks! I really appreciate any comments, likes, favorites and awards you may leave, but this is up to you! Keep in mind that feedback and suggestions are more than welcome in the comment section.

- Griz