I will be doing the next series of tutorials code only, unless an example is needed or a process needs to be shown. This is because i have very little time and i still want to finish the series. Sorry for this v.v You can always message me or find me at my contacts or help.
Learn To Code With Godot Engine: Data Containers [Dictionaries]
What are these beautiful things?!
var arr = [] #This is an array [] var dict = {} #This is a dictionary {}
How do they work?
_Dictionaries differ from arrays by naming the data with a key, and then adding a data we are going to be storing. The key is used to identify and access your data. To start using a dictionary, there are two ways of adding data. The first way is by structuring the dictionary:
var dict = {"string":"This is a string", "integer":12, "float":0.21, "boolean":true, "array":[1,2,3], "dictionary":{"key":"value"}}
_The second way to adding data is the dynamic way. Since Dictionaries are kind of like "Named-Data-Arrays", you can also do this:
var dict = {} dict["KeyName"] = DataValue
_Doing it this way makes it so that you can dynamically add data by just setting a KeyName variable and a DataVariable. Try this code:
extends Node var dict = {} var keyName = "" var data = null #Making it empty func _ready(): keyName = "Test1" data = Vector2(92,-89) #Vector Data dict[keyName] = data keyName = "Test2" data = [1,2,3] #Array Data dict[keyName] = data keyName = "Test3" data = {"Key":123} #Another Dictionary Data dict[keyName] = data print(dict)
_As you can see, each data is named for easy access. Now how do we access it? With the attribute reference: x.attribute.
var dict = {"string":"This is a string", "integer":12, "float":0.21, "boolean":true, "array":[1,2,3], "dictionary":{"key":"value"}} dict.string dict.integer dict.boolean dict.array dict.dictionary
_You can name your keys however you want, or according the use of it. This is incredibly useful for serializing data for saving/loading systems since it uses the same format as JSON files. Yes, dictionary class has a method for converting its data into json and to parse it:
dict.pasrse_json() _This function returns a string of its content as pre-formatted JSON
dict.to_json(string) _This function converts a json string, back to data and stores it.
_For other functions on this class, go here.
_Dictionaries can also be written as Lua tables:
var dict = {varName = String(), varName2 = Vector2()}
_To iterate its content, you can do it in two ways: By key or by value. Only downside to the current version (i'm using 2.1.2 Stable), is that iteration is not in order. For the next version it will. To iterate a dictionary:
var dict = {"string":"This is a string", "integer":12, "float":0.21, "boolean":true, "array":[1,2,3], "dictionary":{"key":"value"}} func _ready(): for item in dict: #this will only iterate keys. print(item) for item in dict.values(): #this will only iterate values. print(item)
_And that's it! For the next chapter, let's talk about operators and how they work.
When I was looking for an area of superior study after high school, i really didn't know what i wanted to be. I was introduced to 3D modelling and composition from a friend; it was in 11th grade when I first saw a modelling software. Cinema 4D was the first one I've ever used to create some "pretty graphics" on a computer, and from that I just had to know more. I practiced and searched on the net and well we decided to start some kind of company revolving around CG, but we were not sure what exactly.
I came across this local college where they teach computer animation and stuff, so i said: "Hey! that's what i want to do!". Little did i know, what was in store for me. I enrolled only thinking about pretty computer stuff, without any research or advice from anybody. When I started, I then realized, art isn't my fortitude. My hand/mind coordination is not that bad, I could draw, but i don't know why, instead of being therapeutic like many people say, to me, it only brings anxiety and desperation... so, i changed mayor to video game programming.
When I finally started programming, I loved it. As weirdly as it sounds. we only had 4 programming classes, the rest were "general professional classes" like modelling, rigging, texturing, etc. My main focus was not art, but by then I did not really understood enough. Those 4 programming classes, two of them were mere introductions to C++ and the other two were just a simple intro to UE4 C++ coding. By the time i started to first see how C++ in Unreal worked, all i could do was try to see the reactions of the rest of the class. NOBODY understood how the engine worked, nobody knew what API meant, and when introduced to the layout of the cpp's, nobody knew what to do because we were never teached how structured classes looked; we were only working on the int main(){} and never did projects that went beyond that main.cpp file. I hardly managed to grasp UE4's C++ inside class hours and only understood it by myself with other sources online.
We were not teached proper ways of programming, different types of programming, working with logic, organize code, patterns, algorithms, how a game engine works, how graphics works, simple AI, or stuff like that. Then we were stuck with one of the hardest languages to learn with little knowledge of the language and its features. Most difficult thing i could remember were linked lists and sorting algorithms, but once the english pseudo code was written, there was no more magic and everything became simple again. MATH! was boring and what I learned was pretty much what i already knew from high school (i studied industrial-electronics at a vocational high school). But to learn where to apply formulas, when to apply them and how to do stuff with them was not explained or clarified at all. Math examples where just a topic, an example and a problem to resolve. No breaking apart the problem and explain the why's and how's, the do's and dont's; I still wanted to keep up so i worked as hard as i could and the more i knew, i was not being taught what I knew I should've been taught.
I understand that for an "all rounder" game developer, we should atleast know how to model/texture/rig/animate, work with it in the engine and then program it. But most of the people that i know of, won't touch a model or paint after that because they're too busy expanding their programming logic and won't find these knowledge useful on that time because they are busy working with other teammates who are ARTISTS. In the industry, programmers won't be touching art (unless your indy AS-FCK) and artists wont touch hard code because to each its own! Now, the time "we wasted" on learning to animate, rig, texture, model.. we could of used it to deepen our knowledge of writting good, clean and well structured code, plus being able to write most mechanics/features on a game.
Now one thing i could say about college that i do not regret: Friends. I met a lot of people, made many connections, changed a lot of things from myself and made deep and beautiful bonds with others. And for that, i will never ever regret going to this college.
I will continue Godot tuts and any other blog work by mid February. Ive been rather busy with college work and other matters! Also, hoping for the new update on Godot Engine so that i can continue on with the tutorials with the new version :).
Learn To Code With Godot Engine: Data Containers [Arrays]
How is this useful?
_Are you tired of having a bunch of variables around without being used? Do you need to "dynamically" store all your relevant data in a single "package"? Then data structures is what you need. [End of commercial voice.]
_Data structures are a way of organizing your data so that it can be used efficiently. The ones we will be using are Dictionaries (Maps), and Arrays. There are other more advanced data structures, with different access methods, but these are the most common ones. In Godot, we have different types of arrays which store different data types but in essence, they work the same way. In this chapter, we will be exploring arrays. Now let's check out how they work:
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.
_The complete list of the functions and what they do, can be found ---> here
Learn To Code With Godot Engine: Data Types and Variables
The Continuation
_To continue with what we have been doing in the last chapter, we will be talking today about data types and variables. A Data Type is pretty much, what the kind of data we are working with, be it numbers, text, truths, or other more specialized types. Variables are, in a way, a place in memory where we will be saving our information for later use and overwrite. There are also constant variables which cannot be overwritten. Now, lets check out the data types we will be using:
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.
_Now is when you will start to transition from the human world, into the world of digital creation. Your preparation is now complete and it is time for you to start learning the logic of digital life. Let us begin the rite.
Your First Steps!
_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!
_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!
_Meet Godot Engine! Sleek, small in size, simple, elegant and powerful! Full featured 2D and 3D, its own simplified shader language (2D, 3D, Post Process in code and shader graph), Networking, Animator, Debugger, multi-platform and OPEN SOURCE~ YES!.. *ahem*... Ok, back to business. You can read more over here!
Right to the point! But First...
_I won't drag this intro too long, we all know you want to learn to code! First allow me to start by saying that we will be using the engine's documentation A-LOT! because why talk about something thats already been written with more detail? Now, I'll address some key aspects of Godot before we get down to the juicy bits!
_Godot Engine is based on scenes who in part, contain subscenes and all of these are based on nodes and the parenting of such... What? Yeah, ill explain:
Nodes And Scenes:
_In summary, nodes work pretty much like classes or objects. Scenes are a collection of sub-scenes, and a sub-scene is a collection of nodes. For example:
_ This is a Scene which contains 1 instanced sub-scene called Player. We can also call sub-scenes, "pre-fabs". Not really, but they kind of work the same. In my opinion, Godot's node system works as a true object oriented system. Because you encapsulate the things you need (classes/nodes) where you need them.. bad explanation, i know..
_I will not go into detail on this because the point is to teach newcomers how to code and use GDScript on Godot Engine. For more info on Nodes, Scenes, etc, please go to the documentation of the engine where everything will be in detail! "Go Here For Node and Scene Explanation"
What language shall I speak?
GDScript is a high level, dynamically typed programming language used to create content. It uses a syntax similar to Python (blocks are indent-based and many keywords are similar). Its goal is to be optimized for and tightly integrated with Godot Engine, allowing great flexibility for content creation and integration.
Godot embeds scripts in nodes. Most languages are not designed with this in mind.
Godot uses several built-in data types for 2D and 3D math. Script languages do not provide this, and binding them is inefficient.
Godot uses threads heavily for lifting and initializing data from the net or disk. Script interpreters for common languages are not friendly to this.
Godot already has a memory management model for resources, most script languages provide their own, which results in duplicate effort and bugs.
Binding code is always messy and results in several failure points, unexpected bugs and generally low maintainability.
Language intro taken from the official documentation. Couldn't explain it better or shorter!
Whats Next On The Series?
_After you have the important bits down and you understand how they work! Your next step will be:
The Godot Coding Environment
Hello World! Printing and Comments [Next!]
Data Types and Variables
Data Containers
Operators
Statements and Control Flow
Loops
Functions
Input and Outputs
Classes
Resource Links!
_I wish you a good learning experience, and I'll try to make you guys be programmers by the end of the series! Any doubts or questions, message me or leave a comment so if others share a similar doubt, we can all benefit!
_Hello! :) My name is Victor Hernandez, I'm a starting Indie Developer, student in multimedia programming and all out philomath! I love sciences (mostly physics), technology (hardware, software), and everything entertainment, art and entrepreneurship!
_To share your own cyber arcana, the link is in the menu bar, or go here!
_I hope this becomes helpful to all of you! If you have any doubts or questions, feel free to ask me and I'll try to answer as fast as possible! If somehow I cant be able to answer your questions, I'll do my research! :)
jacobvanloon
izzy806
turnnoffyourmind
andulkaphoto
prguitarman
titsay
stormborns