#godot tutorial

Arrays:

_According to our best friend [Godot's Official Documentation], Array's are generic sequence of arbitrary objects (just like dictionaries), they are dynamically expandable (can be added or subtracted data), and are indexed by 0 as its first object and so on:

To create an empty array we assign the opening and closing square brackets as its value: var array = [] This is now an empty array from which data can be stored.

Arrays can also be assigned values: var array = ["String1", "Data2", "Even Integers"]

To access a value from an array you call the array's name and right next to it, you add the square brackets. Inside the brackets you address the index of where your data is: var variable_name = array[1] This line will assigned the value "Data2" string, from the array mentioned above, to the variable variable_name.

We can also use arithmetic inside the square brackets, as long as the resulting value is inside the index range of assigned values inside the array.

_An Example of how an array works:

_Arrays can also hold arrays. This are called 2D Arrays. They are accessed like this: array[0][1] This means that in index 0 (the first stored array) i want to access the second data in the second array stored in the first array..... VISUAL REFERENCE TIME!

_In array[0][1], the first square bracket ([0]), means the data (in this case an array) in index 0 of the main array, while the second bracket ([1]), means data in index 1 of the other array. arra[0] returns us an array, and from that returned value, we access another saved info with brackets as well arr[0][1]. I hope you guys got it this way, because i don't have any other method of explaining.

_Same can be done as many times as you can keep the order of it. These are called nD Arrays were n = n+1 lol.

Array Functions

_We talked about functions on a previous chapter..we're going to have to do it again. First a variable must be assigned as an array in order to access the functions. To do that, we just call the array and use the attribute reference... which is the period. Ex:

var arr = [] array.list_should_appear_here

Function Name Definition append(var value): Add an element at the end of the array (same as push_back(var value)). clear(): Clears the array (resize to 0). count(var value): Returns the amount of repeated values inside the array. empty(): Returns if array size is 0 find(var what, int from=0 ): Searches the array for a value and returns its index or -1 if not found. Optionally, the initial search index can be passed. find_last(var value): Searches the array in reverse order for a value and returns its index or -1 if not found. insert ( int pos, var value ): Insert a new element at a given position in the array. The position must be valid, or at the end of the array (pos==size()). invert ( ): Reverse the order of the elements in the array (so first element will now be the last). pop_back(): Remove the last element of the array. pop_front(): Remove the first element of the array. push_front(var value): Add an element at the beginning of the array. remove(int pos): Remove an element from the array by index. size(): Return the amount of elements in the array.

Built In Basics

Null: An empty value, contains no information.

Numbers: Numbers can be defined in two:

* Integers: Integer numbers both positive or negative. [1, 32, 739, etc] * Floats: Floating point numbers: [0.1, 1.5, 32.55423] 3. Strings: Sequence of Unicode Characters. 4. Boolean: This data type can only contain True Or False:

Vector Type

Vector2: Contains info for the x and y axis. Can be both individually accessed as well in width and height form for readability. Can also be accessed as array.

Engine Types

NodePath: Compiled path to a node used mainly in the scene system. It can be easily assigned to, and from, a String.

_All this info has been derived from the Godot's Official Documentation. Check it out to see the other Data Types.

What Are These "Var-Ee-Ah-Balls"?

_Lets imagine we have a collection of buckets. Each bucket has a different color, and each can have a label with a name. Let's say we took a Blue bucket and we filled it up with water and labeled it, "Water". We took another blue bucket and we filled it with sulfuric acid and labeled it, "Acid". Let's fill more buckets:

Red Bucket, filled with sand, we label: "Sand".

Yellow Bucket, filled with sulfur hexafluoride , we label: "Heavy Gas"

_All buckets are holding something that I can add, or remove from them at any quantity. They are different color, which tell me if they hold a solid, liquid or gas. They are labeled, so that I know what's inside the buckets. Pretty much that's how variables work but not likely. For example to make a variable, we do this:

_Here we have stated we were going to make variable with the keyword: var and we would name them "acid, water, sand, heavyGas" for each variable (bucket). Now, where does the coloring come? The bucket color represents the type of data, that variable contains.

NOTE: Please read this and learn it good! Variable names CANT start with numbers! (1,23,546,5.43, etc).

_To add data to the variable, we just use the operator =. Do not confuse with the comparison operator ==. For example:

_As an example, we will use the printt() function, and another function called typeof() alongside a table called GlobalScope, from the class references in the Official Documentation, from which we can also access inside the Text Editor!.

_Now for the demo! To see what's inside and what type of data is, we shall do this! I will do just one example, and I'd like you to practice the others (:

_And that's pretty much it! In short:

state a variable with var.

name the variable: var variableName

Add the value to that variable or add the data anywhere in the code: var variableName = Data

_Oh almost forgot! There is another type of variable called "Constants". This are variables that must be assigned a value and cannot be changed by external processes, it's value can only be changed manually. They are delcared like this: const variable_name = value

_Now to wrap things up completely, I'll leave you with how all that is done. (: See you in the next part of the chapter where we will discuss basic data structures and how to manage them.

Godspeed!

_Now that the Text Editor is enabled, and the cursor blinks, lets check out what the is the text editor showing us.

_The left hand bar where World_Script.gd is highlighted in red, is the current script file. As more scripts are in your project, they will appear there for easy access. The color highlight represents a "temperature" on how often is that file accessed, Red = most often, blue = rarely often , no hiighlight = least often.

_Right inside the text editor we see this lines of code written:

extends Node2D # member variables here, example: # var a=2 # var b="textvar" func _ready(): # Called every time the node is added to the scene. # Initialization here pass

_Lets break down what it means:

extends Node2D: The keyword "extends" means that this file will have access to a set of functions derived from the Node2D class inside the engines. This is called "Ingeritance". We will talk more about this on the final chapter of the series.

Right after, everything that is shown with a "#" before the statement, it means that inside the code theres a COMMENT! This lines are ignored by the compiler or interpreter and are only for our eyes, and to write down things that will help us out with writting our code!. Read more about this on the link, from TechWelkIn.

func _ready(): Is a function which we will be inputing our info and seeing it get printed out on the Output window we saw before when we were discussion the IDE from Godot.

_Now I will introduce you to the functions we will be using and a quick explanation on how they work. This info comes from the Official Godot Documentation

print ( Variant what, Variant ... ): Print one or more arguments to strings in the best way possible to a console line.

printerr ( Variant what, Variant ... ): PPrint one or more arguments to strings in the best way possible to standard error line.

printraw ( Variant what, Variant ... ): Print one or more arguments to strings in the best way possible to console. No newline is added at the end.

prints ( Variant what, Variant ... ): Print one or more arguments to the console with a space between each argument.

printt ( Variant what, Variant ... ): Print one or more arguments to the console with a tab between each argument.

_Each argument saying "Variant What" means you can add more than one by putting a comma (,) after each literal/variable. (I will explain this in the next chapter)

_Now what does this all mean? In short, functions are a named section of a program from which is done by following a series of specific instructions (lines of code) and excutes a specific task. Remember this for the series based on this. Some functions ask for data, called arguments. Each argument saying "Variant what" means you can add more than one argument by putting a comma (,) after each literal/variable. (I will explain this in the next chapter)... let make an example.

The Actual Coding Part!

_Now, in the text editor,delete all the comments and right after the ready function, type this!:

print("Hello World")

_Now remember to have saved your scene and set it as main scene in Godot. (You know where to go for how to do this.) Now press F5 on your keyboard. As you can see, the very first war cry has been outputed to Godot's.. well.. output window. This is how its supposed to look:

Last (Chapter) Words

_And thats pretty much it! Its up to you now to try out the rest listed above as well as comment what it each one does! To be a good programmer, search ahead, ask questions, practice practice practice! So that's it for this chapter! If you need any help, comment down below! Good luck!

Godspeed!

_I shall only be touching 2D for now since this is for beginners. I shall not explain most of the things in the Editor, for obvious reasons. With this, let us see what parts of the editor we shall touch!

The Workspace!

_When you first open Godot Engine, a default layout, per project will appear like this:

To explain what each thing is:

File System: Your file navigation/folders and files. Here you can access where everything inside your project folder is, and see options for your files.

Scene: Where the nodes and sub-scenes will be layed out, as well as other options with the right-click drop down, drag and drop for parenting and moving, hide and show, and other icons.

Inspector: Options and settings for each node.

Node (Behind Inspector): Here you can set up signals and add nodes to groupings which is VERY USEFUL

_Personally I don't like the defaukt layout. If you don't either, here's how you can change it:

_Now that we have that out of the way, lets start by explaining the IDE (area where you code). IDE stands for Integrated Develpment Environment and it is mainly composed of a text editor (with or without syntax highlighting), build autimation tools and whats going to become your best friend, the debugger. To access the IDE, Debugger and Output inside Godot, at the top, where it says Scripts, you'll access the IDE and on the bottom, you can access the Output (Printing and Information) and the Debugger.

_As for the IDE's Menu Bar, i will only mention the ones we will use most, and the non obvious ones like:

Edit:

* Move Up: Moves line where text cursor is, one line up. * Move Down: Moves line where text cursor is, one line down. * Indent Left: Indent line left. * Indent Right: Indent line right. * Toggle Comment: Makes selected line or block of text into a comment, toggle back again to bring back working code. * Clone Down: Clones line of code below the original one. * Trim Trailing Whitespace: Removes unnecesary indentations. 2. Search: * Find: Finds any word or phrase on code. * Replace: Replaces all words or phrase for new one. 3. Debug: * Toggle Breakpoint: Adds or removes breakpoint from where the text cursor is. * Remove All Breakpoints: Removes all breakpoints... duh lol * Goto Next Breakpoint: Obvious.. * Goto Previous Breakpoint: And obvious again lol

_Well that's pretty much it! On the next post, we will be covering:

Adding a script to a node

Hello World! Commenting and Printing!

Whatever else comes to mind. :D

May you have fun, Brothers and Sisters of the HeptaCode!

Godspeed!