Membuat Game - Part 1

Secara keseluruhan

Tutorial ini akan memberikan petunjuk kepada Anda, bagaimana cara membuat game dengan menggunakan Godot. Anda akan mempelajari bagaimana cara kerja editor pada Godot, bagaimana membuat struktur sebuah project, dan bagaimana cara membuat game 2D dengan Godot.

Catatan:

Project ini adalah pengenalan terhadap Godot Engine. Mengasumsikan bahwa Anda memiliki kemampuan dalam pengalaman pemrograman. Jika Anda belum mengenal pemrograman secara keseluruhan, Saya harap agar membaca artikel sebelumnya tentang: Scripting (Penulisan Scirpt).

Game ini diberi nama "Dodge the Creeps!" (mengindari monster). Karakter Anda harus sebisa mungkin bergerak dan menghindari musuh, semakin lama semakin tinggi pula skor yang akan didapat. Berikut ini adalah contoh jadinya:

Dodge the Creeps

Kenapa 2D? karena Game 3D lebih kompleks dari pada game 2D. Anda harus memulai dari 2D hingga benar-benar memahami proses dalam pengembangan sebuah game.

Pengaturan project

Jalankan Godot dan buat satu project baru. Kemudian, download file berikut: ⏬dodge_assets.zip - berisi gambar, font dan suara yang dibutuhkan kedalam game. Ekstrak ke dalam folder project.

Catatan:

untuk tutorial ini, kita asumsikan Anda telah familiar dengan editor Godot. Jika anda belum pernah tahu sebelumnya tentang Scene dan Nodes, Saya sarankan untuk membacanya terlebih dahulu guna mempermudah Anda untuk memahami konsep pengaturan project.

Game ini akan menggunakan mode portrait, jadi kita butuh untuk mengatur luas jendela dari game. Klik (Menu Utama) Project -> Project Settings -> Display -> Window dan jadikan properti "Width" ke 480 dan "Height" ke 720.

Mengorganisasi project

Dalam project ini, kita akan membuat 3 scene independen, yaitu adalah: Player, Mob, dan HUD, dimana kita akan menggabungkannya di dalam satu scene utama yang adalah scene Main. Dalam sebuah project yang besar, sangat berguna apabila Anda membuat folder spesifik, yang hanya menyimpan suatu bagian scene dan script (misla folder enemies, yang berarti terdapat scene dan script yang berhubungan dengan musuh dalam game). Tetapi dalam game yang relatif kecil seperti ini, Anda bisa menyimpan file scene dan script di root folder, yang adalah res://. Anda bisa melihat folder project Anda di tab FileSystem di bagian kiri atas editor:

FileSystem

Scene player

Yang pertama akan kita buat adalah object pada scene Player. Salah satu kelebihan dari membuat player secara terpisah adalah kita dapat melakukan tes padanya secara terpisah, meski sebelum kita membuat bagian lain dari game sekalipun.

Struktur nodenya

Untuk memulai, klik tombol "Add/Create a New Node" dan tambahkan node Area2D ke scene.

Menambahkan node

Dengan menggunakan Area2D kita bisa mendeteksi object yang menumpang tindih (overlap) terhadap object player. Rubah namanya menjadi Player dengan melakukan klik nama node-nya. Node ini merupakan node utama scene Player. Kita bisa menambahkan node lain kedalamnya untuk (dengan kata lain) menambahkan fungsinya.

Sebelum kita menambah node anakan terhadap node Player, kita ingin memastikan bahwa kita tidak secara sengaja mengubah ukurannya dan/atau memindah posisinya. Maka dari itu silahkan pilih dan klik sekali lagi pada node player lalu pada toolbar silahkan klik ikon yang seperti terlihat pada gambar dibawah ini:

Tooltip "Makes sure the object's children are not selectable (Pastikan object pada node anakan tidak dapat dipilih)"

Simpan scene. klik Scene -> Save, atau tekan Ctrl+S jika di Windows/Linux atau Cmd+S pada Mac.

Catatan:

untuk project ini, kita akan mengikuti tata cara (kebiasaan) penamaan di Godot. Seperti apabila Classes (Node) kita namai dengan PascalCase/UpperCamelCase, variables (variabel) kita namai dengan menggunakan snake_case, dan constants (konstanta) kita namai dengan mengguanakan ALL_CAPS.

Sprite Animasi

Klik pada node Player dan tambahkan node AnimatedSprite sebagai anakannya. AnimatedSprite akan menangani semua penampilan dan animasi dari karakter player kita. Perhatikan ada simbol peringatan muncul disamping nama node. Sebuah AnimatedSprite membutuhkan SpriteFrames, yang merupakan daftar dari animasi yang akan ditampilkan. Untuk membuatnya, cari properti Frames pada inspector dan klik "<null>" -> "New SpriteFrames". Kemudian, di lokasi yang sama, klik <SpriteFrames> untuk membuka panel "SpriteFrames":

Panel SpriteFrames

Di bagian sebelah kiri adalah daftar nama animasi. Klik pada bagian tulisan "default" dan ganti namanya menjadi "right". Kemudian klik tombol "Add" pada pojok kiri atas untuk membuat grup animasi baru, namai dengan "up". Geret (drag) dua gambar untuk tiap animasi dari FileSystem yang bernama playerGrey_up[1/2] dan playerGrey_walk[1/2], kedalam bagian "Animation Frames" pada panel:

Menambahkan animasi

Gambar player sepertinya terlalu besar untuk jendela tampilan game, maka kita butuh mengecilkan ukurannya. Klik node AnimatedSprite dan atur properti Scale pada inspector, rubah propertinya menjadi (0.5, 0.5). Anda bisa menemukan properti tersebut pada bagian Node2D:

Scale

Yang terakhir, tambahkan node CollisionShape2D sebagai anakan dari node Player. Node ini adalah sebagai penentu "hitbox" atau bisa dibilang sebagai penentu area pemicur dari karakter player. Untuk karakter ini, kita akan membuat CapsuleShape2D karena bentuknya yang paling cocok terhadap animasinya. Untuk itu selanjutnya, klik pada bagian samping dari properti "Shape" di inspector, klik "<null>" -> "New CapsuleShape2D". Kemudian Atur besarnya, sesuaikan dengan gambar:

Atur ukuran shape

Peringatan:

Jangan menggunakan titik luar (yang memiliki garis) untuk mengubah skala dari object CollishionShape2D! Pastikan Anda menggunakan titik yang dilingkari merah pada gambar di atas sebagai pengatur ukuran (skala). Karena apabila Anda mengatur ukuran menggunakan skala luaran dari object ini, akan berakibat tidak terdeteksinya perubahan skala/ukuran pada object shape tersebut, yang akhirnya memunculkan Error pada sistem debugger Godot atau bahkan membuat game Anda crash saat dijalankan.

Ketika semua langkah diatas sudah dijalankna, maka node Player dalam scene akan terlihat seperti gambar dibawah ini:

Scene Player

Menggerakkan karakter player

Sekarang kita butuh untuk menambahkan fungsi tambahan yang tidak bisa kita dapatkan dari kemampuan sebuah node secara bawaan, jadi perlu ditambahkan script untuk hal ini. Klik node Player dan klik tombol "Add Script":

Tombol add script

Di dalam jendela pengaturan script, langsung saja klik tombol "Create":

Catatan:

Jika Anda membuat script menggunakan bahasa pemrograman C#, pilih opsi sesuai dengan bahasa yang diguanakan pada pilihan Language sebelum menekan tombol "Create".

Jendela pengaturan script

Catatan:

Jika Anda belum pernah tahu tentang GDScript sebelumnya, Saya sarankan untuk membaca artikel sebelumnya tentan Penulisan Script sebelum melanjutkan ke tahap ini.

Dimulai dengan membuat member dari variabel yang dibutuhkan oleh object:

extends Area2D

export (int) var speed  # How fast the player will move (pixels/sec).
var screensize  # Size of the game window.

Menggunakan keyword export sebelum variabel speed adalah bertujuan untuk memungkinkan kita agar dapat mengubah nilai variabel tersebut melalui Inspector. Cara ini mempermudah kita agar lebih cepat mengakses properti suatu node, dengan kata lain memberikan kita kemampuan untuk membuat properti secara manual kepada suatu object. Klik pada node Player dan atur speed-nya menjadi 400.

Hasil dari metode export variable

Fungsi _ready() akan dipanggil pada saat awal node memasuki scene tree, dimana merupakan waktu yang tepat untuk mendapatkan ukuran dari jendela game:

func _ready():
    screensize = get_viewport_rect().size

Sekarang kita akan menggunakan fungsi _process() untuk menentukan apa yang karakter (player) akan lakukan. _process() akan dipanggil setiap frame, jadi kita akan menggunakannya sebagai elemen update (pembaruan) pada game kita, disini akan kita gunakan sebagai:

• Memeriksa input (dalam hal ini input yang dilakukan pemain game).
• Menggerakkan sesuai dengan arah yang telah ditentukan.
• Memainkan animasi yang sesuai.

Pertama, kita perlu melakukan pemeriksaan terhadap input (masukan) - apakah pemain menekan tombol keyboard? Untuk game ini, kita memiliki 4 arah input yang harus di cek. Peta input sudah ditentukan pada Project Settings dibawah opsi "Input Map". Anda bisa menentukan sendiri event khusus lalu membuatkannya tombol sendiri, input dari mouse, atau input lain kepada event tersebut. Untuk tutorial ini kita akan menggunakan default event yang telah ditentukan sebelumnya yaitu menggunakan tombol panah pada keyboard.

Anda bisa mendeteksi tombol mana yang ditekan dengan menggunakan metode Input.is_action_pressed(), dimana akan menghasilkan nilai true apabila tombol ditekan atau false apabila tidak ada penekanan pada tombol yang dimaksud.

func _process(delta):
    var velocity = Vector2() # The player's movement vector.
    if Input.is_action_pressed("ui_right"):
        velocity.x += 1
    if Input.is_action_pressed("ui_left"):
        velocity.x -= 1
    if Input.is_action_pressed("ui_down"):
        velocity.y += 1
    if Input.is_action_pressed("ui_up"):
        velocity.y -= 1
    if velocity.length() > 0:
        velocity = velocity.normalized() * speed
        $AnimatedSprite.play()
    else:
        $AnimatedSprite.stop()

Kita lakukan cek setiap input dan melakukan penambahan dari nilai velocity untuk mendapatkan sebuah arah total. Sebagai contoh, jika Anda menekan tombol right dan down pada saat bersamaan, maka hasilnya adalah vector velocity bernilai (1, 1). Dalam kasus ini, apabila kita melakukan penambahan pada pergerakan horizontal dan vertical, maka node player akan bergerak lebih cepat daripada jika node tersebut hanya bergerak secara horizontal saja.

Kita bisa mengatasi hal tersebut menggunakan metode normalize yang diaplikasikan pada velocity-nya, yang berarti kita menjadikan "panjang" velocity selalu bernilai 1, dan mengalikannya dengan speed (kecepatan) yang diinginkan. Dengan begini tidak akan ada penambahan kecepatan padasaat bergerak secara diagonal.

Tips

Jika Anda belum pernah mengetahui perhitungan vector matematik sebelumnya, atau hanya sekedar ingin mengingat kembali, Anda bisa membaca penjelasan tentang penggunaan vector di Godot pada artikel berikut Vector Math. Hanya sebagai referensi saja, belum terlalu dibutuhkan dalam tutorial ini.

Kita juga melakukan cek terhadap pergerakan player, dengan begitu kita bisa mengatur animasinya, dimana saat animasi berhenti, dimana saat animasi dimulai.

Tips

$ merupakan simbol yang bernilai sebuah path relatif terhadap node dimana script dipasang, dan akan bernilai null jika tidak ditemukan node. Karena AnimatedSprite adalah node anakan dari node dimana script dipasang, maka kita bisa menggunakan $AnimatedSprite untuk memanggilnya.

$ adalah code singkat pengganti get_node(). Jadi code diatas yang adalah $AnimatedSprite.play() berarti sama dengan get_node("AnimatedSprite").play()

Sekarang kita memiliki arah bergerak, kita bisa mengubah posisi Player dan tambahkan metode clamp() ke dalam fungsi _process agar menahan node player selalu berada didalam layar game.

position += velocity * delta
position.x = clamp(position.x, 0, screensize.x)
position.y = clamp(position.y, 0, screensize.y)

Tips

Clamping (menjepit) sebuah metode yang berfungsi untuk membatasi suatu nilai, berarti membatasinya sesuai batas yang ditentukan. Dari script diatas bisa kita simpulkan bahwa position.x dan position.y dibatasi mulai dari 0 hingga maksimal seluas ukuran layar.

Klik "Play Scene" (F6) dan pastikan Anda bisa menggerakkan player ke arah manapun.

Peringatan

Apabila Anda mendapati error yang muncul pada panel "Debugger" yang mengacu pada "null instance", hal ini lebih kepada kesalahan Anda dalam mengeja nama node yang dipanggil dalam script. Penamaan node adalah sesuatu yang case-sensitive berarti harus diperhatikan penggunaan tiap hurufnya, jadi $NodeName atau get_node("NodeName") harus benar-benar (secara pengejaan dan besar/kecil hurufnya) sama dengan yang ada di scene tree.

Pemilihan animasi

Sekarang node player bisa bergerak, kita butuh menentukan animasi mana yang AnimationSprite akan mainkan sesuai dengan arah dari node bergerak. Kita memiliki animasi "right" (kanan), yang tentunya harus dibalik agar sesuai jika node bergerak ke "left" (kiri), untuk itu kita gunakan metode flip_h yang berarti membalik secara horizontal (flipped horizontally). Sedangkan untuk animasi "up", agar kita memiliki animasi "down" (bawah), maka harus dibalik menggunakan flip_v (flipped_vertically). Mari kita tanamkan code ini di paling bawah dari fungsi _process():

if velocity.x != 0:
    $AnimatedSprite.animation = "right"
    $AnimatedSprite.flip_v = false
    $AnimatedSprite.flip_h = velocity.x < 0
elif velocity.y != 0:
    $AnimatedSprite.animation = "up"
    $AnimatedSprite.flip_v = velocity.y > 0

Tekan Play Scene sekali lagi dan pastikan bahwa animasinya sudah benar sesuai dengan arah pergerakan player. Ketika Anda sudah yakin semuanya berjalan dengan baik, tambahkan code dibawah ini kedalam fungsi _ready(), untuk menyembunyikan player saat awal game dijalankan:

hide()

Mempersiapkan hambatan (collisions)

Kita ingin Player untuk mendeteksi ketika sedang bertabrakan dengan musuh, tapi kita belum membuat satu musuh sekalipun. Bukan suatu masalah, karena kita akan menggunakan fungsi signal dari Godot untuk membuatnya bekerja.

Tambahkan code berikut ini di dalam scritp, taruh dibawah code extends Area2d:

signal hit

Code diatas merupakan metode untuk membuat sebuah custom signal yang diberi nama "hit", yang dimana akan dipancarkan oleh node player ketika nantinya berbenturan dengan node enemy (musuh). Kita akan menggunakan Area2D untuk mendeteksi rintangan. Pilih node Player dan klik pada tab "Node" (disamping tab Inspector) untuk melihat list signal yang bisa dipancarkan oleh node player:

Signal yang (mungkin) dipancarkan oleh node player

Perhatikan pada signal buatan kita sendiri yaitu signal "hit" yang muncul juga pada kumpulan signal node ini. Karena nantinya kita akan membuat enemy menggunakan node RigidBody2D, maka akan kita gunakan signal body_entered( Object body ) yang terdapat pada Area2D; signal ini akan memancar ketika sebuah object body memasuki Area2D (dalam hal ini adalah player). Untuk itu klik signal tersebut, lalu klik "Connect.." dan "Connect" lagi di jendela "Connecting Signal", kita tidak perlu mengganti pengaturan apapun yang ada dalam jendela tersebut. Selanjutnya Godot akan secara otomatis membuat satu fungsi baru yaitu _on_Player_body_entered di dalam script.

Tips

Ketika melakukan koneksi signal, Anda bisa membuat sendiri nama fungsi yang digunakan dalam penyambungan signal ke node, dengan cara mengganti nama fungsinya pada kolom "Method in Node".

Setelah itu tambahkan code dibawah ini pada fungsi signal:

func _on_Player_body_entered(body):
    hide() # Player disappears after being hit.
    emit_signal("hit")
    $CollisionShape2D.disabled = true

Catatan:

Menonaktifkan (disabling) collision shape dari area berarti membuatnya tidak bisa mendeteksi node lain yang menabraknya. Dengan mematikan fungsi tersebut, berarti memastikan agar signal tidak terpicu (memancar) lebih dari satu kali.

Bagian terakhir dalam scene player adalah membuat fungsi untuk mereset ulang Player pada saat awal game diload/dimainkan.

Sampai disini Anda telah menguasai beberapa poin yang merupakan fundamental dalam membuat sebuah game menggunakan Godot. Untuk part selanjutnya akan membahas tentang membuat scene enemy (musuh). Bersambung...

Read More

Penulisan Script - Part 2

Beberapa aksi dalam Godot dipicu melalui callback atau fungis virtual, maka dari itu tidak selalu diperlukan (menulis sendiri) code untuk menjalankannya.

Bagaimanapun juga, secara umum masih dibutuhkan script untuk melakukan proses terhadap setiap frame. Ada dua tipe pemrosesan (processing): idle processing dan physics processing.

Idle processing akan aktif ketika metode Node._process() terdapat di dalam script. Bisa diatur, dimatikan dan dihidupkan menggunakan fungsi Node.set_process().

Metode ini akan diproses setiap saat frame terload, jadi hal ini sangat berpengaruh terhadap FPS (Frame Per Second).

func _process(delta):
    # Do something...
    pass

Parameter "delta" berisi waktu yang berlalu dalam hitungan detik, yang merupakan titik penting terhadap fungsi _process().

Parameteri ini bisa digunakan untuk memastikan semuanya berjalan selalu pada saat bersamaan, mengesampingkan FPS dari game itu sendiri.

Sebagai contoh, pergerakan suatu object (movement) biasanya dikalikan dengan waktu "delta" untuk memaksa pergerakannya memiliki kecepatan yang sama dan terbebas dari rate (rata-rata) kecepatan frame.

Physics processing dengan menggunakan _physics_process() adalah mirip cara kerjanya, hanya saja metode ini lebih digunakan untuk memproses langkah (dengan suatu pengaruh) fisika pada suatu objek (dalam hal ini adalah node), seperti misal mengontrol sebuah karakter. Semua code yang berada didalam fungsi _physics_process() akan selalu diproses seiring dengan proses fisika dan selalu berjalan pada interval waktu: 60 kali per detik secara default. Anda bisa mengganti interval tersebut pada menu Project Settings, dibawah opsi Physics -> Common -> Physics Fps.

Fungsi _process() sendiri, bagaimanapun tidak tersingkronisasi dengan fisika. Frame rate-nya tidak memiliki nilai konstan dan bergantung terhadap hardware dan optimisasi game.

Cara sederhana untuk melakukan tes pada metode ini adalah dengan cara membuat satu node Label, dengan berisi script sebagai berikut:

extends Label

var accum = 0

func _process(delta):
    accum += delta
    text = str(accum) # 'text' is a built-in label property.

Dimana scene tersebut apabila dijalankan akan memperlihatkan angka yang akan selalu bertambah di setiap frame update.

Grup

Node bisa ditambahkan ke dalam grup (dikelompokkan), sebanyak yang diinginkan per node, dan sangat berguna kedepannya saat mengorganisasi banyak scene. Ada dua cara untuk melakukan ini. Cara pertama mengguanakan visual interface Godot, dari tombol Groups dibawah panel Node, seperti gambar dibawah ini:

Menambahkan ke grup

Cara kedua adalah tentunya menggunakan script, melalui code. Satu contoh adalah menandai scene yang termasuk dalam grup enemies (musuh):

func _ready():
    add_to_group("enemies")

Dengan cara ini, jika player ditemukan sedang menyelinap kedalam markas rahasia musuh, maka semua musuh akan diberitahukan tentang hal ini dengan menggunakan metode SceneTree.call_group():

func _on_discovered(): # This is a purely illustrative function.
    get_tree().call_group("enemies", "player_was_discovered")

Code diatas memanggil fungsi player_was_discovered di setiap member grup enemies.

Juga sangat mungkin untuk mendapat semua daftar node dari grup enemies dengan memanggil metode SceneTree.get_nodes_in_group():

var enemies = get_tree().get_nodes_in_group("enemies")

Class SceneTree menyediakan banyak metode yang berguna. Memudahkan Anda untuk berpindah scene atau melakukan reload, untuk keluar dari game atau pause/unpause.

Notifikasi

Godot memiliki sistem notifikasi. Notifikasi biasanya tidak memerlukan script, sebagaimana hal ini adalah merupakan low-level dan fungsi virtual biasanya yang lebih diperlukan. Hanya perlu Anda ketahui saja bahwa notifikasi ini ada. Sebagai contoh, Anda bisa menambahkan fungsi Object._notification() di dalam script Anda:

func _notification(what):
    match what:
        NOTIFICATION_READY:
            print("This is the same as overriding _ready()...")
        NOTIFICATION_PROCESS:
            print("This is the same as overriding _process()...")

Dokumentasi setiap class-nya bisa Anda baca di Class Reference. Meskipun pada dasarnya GDScript memberikan fungsi pengganti yang lebih sederhana.

Fungsi pengganti

Berikut ini merupakan beberapa yang disebut sebagai fungsi pengganti:

func _enter_tree():
    # When the node enters the _Scene Tree_, it becomes active
    # and  this function is called. Children nodes have not entered
    # the active scene yet. In general, it's better to use _ready()
    # for most cases.
    pass

func _ready():
    # This function is called after _enter_tree, but it ensures
    # that all children nodes have also entered the _Scene Tree_,
    # and became active.
    pass

func _exit_tree():
    # When the node exits the _Scene Tree_, this function is called.
    # Children nodes have all exited the _Scene Tree_ at this point
    # and all became inactive.
    pass

func _process(delta):
    # This function is called every frame.
    pass

func _physics_process(delta):
    # This is called every physics frame.
    pass

Seperti yang dibicarakan sebelumnya, bahwa lebih baik menggunakan fungsi diatas dari pada menggunakan cara notifikasi. Yang bagaimana outputnya adalah sama, hanya saja lebih sederhana.

Membuat node

Untuk membuat sebuah node dengan menggunakan code, gunakan metode .new(), seperti dataype class-based lain. Contoh:

var s
func _ready():
    s = Sprite.new() # Create a new sprite!
    add_child(s) # Add it as a child of this node.

Untuk menghapus sebuah node, berada di dalam atau diluar scene, gunakan .free(). Contoh:

func _someaction():
    s.free() # Immediately removes the node from the scene and frees it.

Ketika node terbebaskan (dalam hal ini terhapus), node tersebut juga selalu menghapus node anakannya (apabila ada). Karena itu, menghapus node secara manual lebih mudah dilakukan daripada memunculkannya. Menghapus node utama akan menghapus semua yang melekat terhadapnya.

Sesuatu mungkin saja "mencegah" node kita terhapus pada saat ingin menghapusnya, dikarenakan sedang memancarkan signal atau sedang melakukan panggilan terhadap sebuah fungsi. Hal ini akan membuat game kita berhenti (crash). Menjalankan Godot dengan debugger akan selalu memonitor setiap kasus yang dialami game Anda.

Cara paling aman dalam menghapus sebuah node adalah dengan Node.queue_free(). Ini akan menghapus node secara aman selama idle.

func _someaction():
    s.queue_free() # Queues the Node for deletion at the end of the current Frame.

Membuat instance sebuah scene

Membuat instance menggunakan code bisa dilakukan dengan dua cara. Yang pertama adlah dengan me load scene dari hard drive Anda:

var scene = load("res://myscene.tscn") # Will load when the script is instanced.

Menggunakan preload bisa dibilang lebih mempermudah kerja sistem, karena code ini dieksekusi secara lokal  (pada waktu awal sebelum scene di load) oleh Godot:

var scene = preload("res://myscene.tscn") # Will load when parsing the script.

Tapi scene belum bisa disebut sebuah node. Scene merupakan resource lain yang disebut PackedScene. Untuk membuat node dari sebuah scene, bisa digunakan metode berikut PackedScene.instance(). Metode ini akan membuat tree sebuah node bisa ditambahkan ke scene aktif:

var node = scene.instance()
add_child(node)

Kelebihan dari dua-langkah proses diatas adalah PackedScene yang ter-load akan selalu siap untuk di-load ulang sebanyak apapun sesuai keinginan Anda. Hal ini sangat berguna untuk meng-instance musuh, peluru, dan banyak objek lain secara masal di dalam sebuah scene aktif.

Read More

Penulisan Script - Part 1

Sebelum Godot versi 3.0, satu-satunya pilihan bahasa untuk penulisan script adalah dengan bahasa GDScript. Saat ini, Godot memiliki empat bahasa pemrograman yang bisa digunakan untuk penulisan script.

Bahasa pemrograman utama pada Godot adalah GDScript dan VisualScript. Alasan utama memilih kedua bahasa tersebut adalah kemudahan integrasi mereka terhadap Godot; keduanya sama-sama bisa langsung dituliskan di dalam script editor Godot, berbeda dengan C# dan C++ yang harus ditulis menggunakan IDE (Integrated Development Environment) terpisah.

GDScript

GDScript adalah, seperti yang dijelaskan sebelumnya, merupakan bahasa utama dari Godot. Memiliki kelebihan saat menggunakannya dibanding dengan bahasa yang lain dikarenakan kemudahannya berintegrasi dengan Godot:

• Sederhana, elegan, dan didesain agar lebih bisa mudah dipahami oleh pengguna yang mengetahui/menguasai bahasa pemrograman seperti Lua, Python, Squirrel, dan lain sebagainya.
• Sangat cepat untuk di-load dan di-compile.
• Integrasi terhadap editor Godot sangat mempermudah penggunaannya. Dilengkapi dengan auto completion (pelengkap otomatis), signals (sinyal), dan beberapa item lain tentang pengeditan scene.
• Memiliki vektor bawaan (seperti Vectors, transforms, dan lain sebagainya), membuatnya semakin efisien saat digunakan untuk penghitungan dan/atau pengaplikasian aljabar linier.
• Mendukung banyak thread secara efisien seperti bahasa yang diketik secara statis - salah satu batasan yang membuat kami menghindari VM (Virtual Machine) seperti Lua, Squirrel, dan lain sebagainya.
• Tidak menggunakan garbage collector, hal tersebut berpengaruh terhadap auto-completion (tidak terlalu signifikan).

Jika Anda tidak memiliki pengalaman terhadap pemrograman sebelumnya, GDScript merupakan bahasa pemrograman yang sangat mudah dipelajari.

Scripting sebuah scene

Untuk tutorial yang akan kita bahas kali ini, kita akan membuat sebuah GUI (Graphical User Interface) yang terdiri dari sebuah tombol dan sebuah label, dimana ketika tombol di tekan akan mengubah properti label. Tutorial ini akan meliputi:

• Penulisan script(Scripting/Coding) dan menghubungkannya kedalam sebuah node.
• Menghubungkan elemen UI menggunakan signal.
• Menulis script yang akan mengakses node lain di dalam scene.

Sebelum dilanjutkan, Saya harap Anda membaca GDScript* sebagai referensi agar Anda mendapatkan gambaran secara luas tentang konsepnya. 

*) Untuk sementara link Saya arahkan ke dokumentasi Godot. Kedepannya akan Saya buat terjemahannya kedalam blog ini.

Pengaturan Scene

klik Add Child Node (tanda "+" pada tab scene) atau tekan Ctrl+A untuk membuat susunan sesuai dengan node berikut:

• Panel
• Label
• Button

Scene tree akan terlihat seperti gambar dibawah ini:

Scene tree

Gunakan editor 2D untuk mengubah posisi serta mengubah ukuran tombol dan label sehingga mereka terlihat seperti gambar dibawah ini:

Tombol dan label

Terakhir, simpan scene dengan nama "sayhello.tscn" (tanpa tanda petik).

Menambahkan script

Klik kanan pada panel node, kemudian pilih Attach Script seperti gambar dibawah ini:

Attach script

Dialog pembuatan script akan muncul. Di dalam dialog ini, memungkinkan Anda untuk mengatur bahasa yang akan digunakan didalam script, nama class, dan beberapa opsi pengaturan terkait.

Dalam GDScript, filenya itu sendiri merepresentasikan class-nya, jadi kolom nama class tidak bisa diedit.

Node yang terpilih untuk dihubungkan ke script sebelumnya adalah node "Panel", jadi kolom Inherinits akan otomatis terisi "Panel". Inilah yang kita harapkan, sebagaimana tujuan dibuatnya script terhadap node panel ini adalah untuk memberikan fungsi tambahan ke node panel.

terakhir, isi kolom path untuk script lalu kemudian klik tombol Create:

Dialog pembuatan script

Sekarang Anda akan melihat ikon "Open Script" disebelah node pada tab scene, juga dibagian properti Script pada inspector.

Script telah terpasang pada node

Untuk mengedit script, pilih salah satu dari dua tombol yang ditandai di atas. Setelah diklik maka akan terbuka editor script, dengan berisi template default dari script.

Script template

Tidak banyak yang tertulis disini. Fungsi _ready() diproses ketika node, dan semua turunannya, berada pada scene aktif. Catatan: _ready() bukan merupakan constructor; melainkan _init().

Peranan sebuah script

Sebuah script menambahkan kemampuan sebuah node. Script digunakan untuk mengontrol bagaimana fungsi dari sebuah node sebagaimana berinteraksi dengan node lain; children, parent, siblings, dan seterusnya. Dengan kata lain, script merupakan turunan dari fungsi yang disediakan sebuah node.

Perumpamaan sebuah script terhadap node

Menangani sebuah signal

Signal "dipancarkan" ketika suatu aksi secara spesifik berlangsung, dan mereka bisa terhubung dengan semua fungsi dari semua instance script. Signal biasanya digunakan untuk keperluan node GUI, meskipun beberapa node memiliki signal juga, dan Anda bisa membuat sendiri signal sesuai dengan kebutuhan dalam script Anda.

Dalam step ini, kita akan menghubungkan signal "pressed" ke sebuah fungsi buatan. Membuat koneksi adalah langkah pertama dan menentukan fungsi buatan adalah langkah kedua. Untuk langkah pertama, Godot menyediakan dua cara untuk membuat koneksi: melalui interface editor atau melalui penulisan code.

Kita akan menggunakan metode penulisan code untuk memastikan seri tutorial ini yaitu mengenai scripting (penulisa code), sebelumnya kita bahas tentang bagaimana melakukan langkah ini melalui metode interface editor untuk sekedar referensi kedepannya.

Pilih node "Button" pada scene tree. Kemudian pilih tab Node (seperti gambar dibawah ini). Selanjutnya, pastikan tombol "Signals" terpilih.

Signals

Kemudian pilih signal pressed() dibawah kategori BaseButton dan klik tombol Connect... di bagian kanan bawah, Anda akan membuka dialog connection creation.

Dialog connection creation

Di bagian bawah terdapat kolom Path to Node dan Method In Node. Path to Node merupakan node yang akan mengimplementasikan signal sedangkan Method In Node adalah metode pemicu signal yang digunakan.

Di bagian atas kiri memperlihatkan daftar node yang terdapat pada scene dengan nama node berwarna merah yang adalah node pemancar signal.

Secara default, nama metode akan berisi node pemancar signal (dalam tutorial ini "Button"), menjadi seperti "_on_[EmitterNode]_[signal_name]". Jika Anda memilih "ON" pada "Make Function", maka secara otomatis akan terbuat fungsi terkait dengan pemancar signal tersebut kedalam editor script.

Begitulah cara membuat signal melalui visual interface Godot. Bagaimanapun, tutorial kali ini membahas tentang scripting. Jadi mari kita bahas bagaimana cara membuat koneksi signal melalui script atau biasa dikatakan sebagai cara manual.

Untuk mempermudah, kita akan memperkenalkan fungsi yang mungkin sangat sering digunakan oleh programer Godot yaitu: Node.get_node(). Fungsi ini mengguanakan path untuk mengakses sebuah dari node manapun didalam sebuah scene, relatif terhadap node pemilik script.

Untuk memudahkan, hapus semua tulisan yang ada di bawah extends Panel. Selanjutnya Anda akan mengisi script secara manual.

Karena node "Label" dan "Button" merupakan node anakan dari node "Panel" maka untuk mengaksesnya cukup menuliskan script dibawah ini pada fugsi _ready():

func _ready():
    get_node("Button")

Kemudian, tulis fungsi yang akan dipanggil ketika tombol "Button" di tekan:

func _on_Button_pressed():
    get_node("Label").text = "HELLO!"

Dan yang terakhir, hubungkan signal "Button pressed" ke dalam _ready(): dengan menggunakan Object.connect().

func _ready():
    get_node("Button").connect("pressed", self, "_on_Button_pressed")

hasil akhirnya script akan terlihat seperti dibawah ini:

extends Panel

func _ready():
    get_node("Button").connect("pressed", self, "_on_Button_pressed")

func _on_Button_pressed():
    get_node("Label").text = "HELLO!"

Jalankan scenenya dan tekan tombolnya. Anda akan mendapat hasil seperti berikut:

Hasil akhir

Selamat! Anda telah berhasil membuat script pertama menggunakan Godot.

Catatan: banyak kesalah pahaman terhadap tutorial ini berhubungan dengan cara kerja get_node(path). Pada node utama, get_node(path) selalu mencari node anakannya. Dari script diatas, node "Button" merupakan anakan dari node "Panel". Apabila "Button" adalah node child dari "Label" maka script nya akan berubah seperti dibawah ini:

# Not for this case,
# but just in case.
get_node("Label/Button")

Dan perlu ingat, bahwa "path" pada code tersebut merupakah nama dari node, bukan tipe dari node.

Source: http://docs.godotengine.org/en/3.0/getting_started/step_by_step/scripting.html

Read More

Instancing - Part 2

Instancing memiliki banyak kegunaan. Sekilas, dengan instancing Anda memiliki:

• Kemampuan membagi scene agar lebih mudah untuk dikelola.
• Alternatif yang lebih fleksibel untuk membuat duplikasi.
• Salah satu jalan untuk mengorganisasi dan menanamkan alur komplek sebuah game atau bahkan sebuah UI (user interface). Di Godot, elemen UI adalah merupakan node.

Sebagai alat desain

Dan yang paling "keren"-nya dari instancing ini adalah bisa digunakan sebagai patokan desain suatu project. Hal ini merupakan pembeda Godot dari mesin lain. Godot didesain menyerupai konsep instancing.

Ketika membuat game menggunakan Godot, direkomendasikan untuk tidak memperdulikan motif penyusunan struktur desain secara umum, seperti menggunakan MVC (Model View Controller) atau diagram Entity-Relationship, tetapi disarankan untuk lebih secara langsung memikirkan struktur satu scene secara natural. Dimulai dengan membayangkan elemen yang jelas di dalam game Anda, yang bisa dilakukan bukan hanya oleh seorang programmer, melainkan semua orang.

Seperti contoh, dibawah ini merupakan penggambaran yang cukup sederhana dalam sebuah konsep game tembak-tembakan.

Diagram penggambaran konsep game tembak-tembakan secara sederhana

Anda bisa membuat diagram seperti ini untuk semua jenis game. Tulis semua bagian game yang bisa Anda bayangkan, lalu kemudian tambahkan tanda panah di setiapnya agar memperlihatkan keterkaitan antar setiap bagian dengan bagian lainnya.

Saat Anda memiliki diagram seperti ini, proses selanjutnya adadalah membuat scene dari tiap elemen yang sebelumnya dibuat. Anda akan menggunakan instancing (entah dengan melalui kode skrip atau melalui editor) sebagai pengait antar tiap-tiap bagian elemennya.

Dalam pembuatan game (atau software pada umumnya) memakan banyak waktu dalam pengerjaan desain dan menyesuaikan komponen game terhadap desainnya. Mendesain sesuai scene pada Godot menghilangkan hal tersebut, dan membuat pengembangan (pembuatan) game menjadi lebih cepat dan mudah, memungkinkan Anda untuk lebih memperhatikan logika kerja game itu sendiri. Karena sebagian besar komponen game menjadi satu kesatuan terhadap scene, maka berarti lebih sedikit dibutuhkan penulisan kode. 

Mari Kita lihat satu contoh lain, sedikit lebih kompleks dari sebelumnya. Adalah sebuah game bergenre open-world dengan banyak aset dan instanced element.

Konsep game open world

Lihat pada bagian elemen ruangan (Room). Katakan Kita mulai dari sana. Kita bisa membuat beberapa scene ruangan yang berbeda, dengan susunan perabotan (ruangan) yang berbeda. Kedepannya Kita bisa membuat scene rumah, dan menghubungkan scene ruangan untuk mengatur interiornya.

Lalu, Kita bisa membuat scene benteng (Citadel), dimana terbuat dari kumpulan (instanced) scene rumah. Kemudian, Kita bisa mulai untuk membuat daratan yang luas (world map terrain), dan menambahkan scene benteng didalamnya.

Selanjutnya, Kita bisa membuat scene penjaga (guards) dan NPC (Non-Player Character) lainnya, lalu Kita tambahkan ke dalam scene benteng. Dan hasilnya, adalah sebuah satu kesatuan dunia didalam game.

Dengan Godot, yang Anda butuhkan adalah buat satu elemen dan tambahkan elemen lainnya dengan instancing. Selain itu, UI di ruang editor Godot juga didesain agar mudah digunakan oleh programmer (maupun orang yang bukan programmer). Satu tim pengembangan game biasanya membutuhkan artis 2D atau 3D, desainer level, desainer game, dan animator, semua bekerja menggunakan interface editor yang sama.

Information overload!

Hal yang Kita bahas tadi adalah merupakan hal level tinggi yang Anda baca sekaligus. Bagaimanapun, tujuan dibuatnya part dari tutorial ini adalah agar Anda sadar akan bagaimana scene dan instancing diimplementasikan dalam suatu project sesungguhnya.

Segala hal yang dibahas disini diharapkan akan menjadi kebiasaan bagi Anda agar suatu saat pada saat Anda membuat sebuah game, Anda akan mempraktekan konsep ini. Untuk saat ini, jangan terlalu khawatir apabila belum begitu paham dan lanjutkan ke tutorial berikutnya!

Source: http://docs.godotengine.org/en/3.0/getting_started/step_by_step/instancing_continued.html

Read More

Instancing - Part 1

Hanya membuat satu scene dengan banyak node di dalamnya memungkinkan untuk sebuah project kecil, tetapi sejalan dengan berkembang serta semakin kompleksnya project yang Anda kerjakan, terlalu banyak node dalam satu scene akan semakin membuat project Anda susah untuk dikelola. Untuk mengatasi masalah ini, Godot memungkinkan Kita untuk membuat sebanyak mungkin scene ke dalam satu project. Hal ini dapat sangat membantu Anda mengorganisasi komponen-komponen yang dibutuhkan dalam game Anda.

Dalam postingan sebelumnya Scenes dan Nodes Anda telah mempelajari bahwa scene adalah gabungan dari kumpulan beberapa node dalam bentuk tree (pohon biner), dengan satu node utama.

Tree

Anda bisa membuat sebanyak mungkin scene sesuai dengan yang Anda inginkan dan menyimpan mereka menjadi sebuah file. File tersebut biasa disebut "Packed Scenes" (Paket Scene) dan memiliki  ekstensi file.tscn.

Pre-instancing

Saat sebuah scene telah menjadi sebuah file, file tersebut bisa di-instanced ke scene lain selayaknya sebuah node (bisa dibilang sebuah file scene adalah node baru yang Anda buat sendiri).

Instancing

Dalam gambar di atas, Scene B ditambahkan ke Scene A sebagai instance.

Contoh Instancing

Untuk mempelajari bagaimana cara kerja instancing, mari Kita mulai dengan mengunduh project sederhana berikut: ⏬instancing.zip.

Ekstrak project tersebut ke dalam direktori manapun. Lalu buka aplikasi Godot dan tambahkan project baru melalui tombol import.

Godot Project Manager

Akan terbuka panel dialog untuk memilih folder data project, arahkan ke dalam folder yang sudah Anda ekstrak sebelumnya. Lalu pilih "project.godot" yang ada di dalam folder tersebut, selanjutnya tekan Open dan tekan Import & Edit.

Project ini memiliki dua scene: "Ball.tscn" dan "Main.tscn". Ball scene menggunakan RigidBody2D untuk mengaplikasikan physics behavior (perilaku fisika) dalam sebuah bola sedangkan main scene memiliki obstacles (rintangan) yang dibuat dengan menggunakan node StaticBody2D.

Ball.tscn

Main.tscn

Buka Main.tscn (Main scene), lalu kemudian pilih root node -nya (node utama).

Pilih root node pada main scene

Kita akan tambahkan scene Ball sebagai instance child node untuk Main node. Klik tombol yang berbentuk seperti simbol link (akan muncul keterangan bertuliskan "Instance a scene file as Node.") dan pilih file Ball.tscn.

Tombol instance

Akan muncul objek bola yang terdapat di scene Ball kedalam Main scene. Bola tersebut secara otomatis berada di pojok kiri atas viewport (merupakan posisi default saat pertama kali sebuah node/instance scene dibuat yaitu kordinat (0,0)). Klik dan drag bola tersebut di suatu tempat dekat bagian tengah atas dari scene. Semacam gambar dibawah ini.

Atur posisi bola

Tekan Play dan lihatlah bola akan terjatuh ke arah bawah layar.

Tombol play

Multiple Instances (melakukan Instance lebih dari satu)

Anda bisa melakukan instance sebanyak mungkin lebih dari satu sesuai keinginan, entah dengan menggunakan tombol instance, atau dengan klik kanan di bagian node bola lalu pilih "Duplicate", atau hanya dengan menekan Ctrl+D (Cmd+D jika menggunakan Mac).

Memperbanyak instance

Jalankan sekali lagi dan semua bola akan jatuh, seperti gambar dibawah ini.

Multiple Instance

Melakukan Edit Pada Instance

Buka scene Ball dan rubah properti Bounce di inspector menjadi 1. Tekan Play dan perhatikan semua bola yang di instance sebelumnya akan menjadi lebih membal (bouncy). Karena bola-bola yang di-instance sebelumnya adalah merupakan satu file scene, meruba properti di scene tersebut akan berakibat ke semua node instance-annya.

Apabila Anda ingin merubah properti secara individual, maka lakukan perubahan di dalam scene Main, sebelumnya coba kembalikan properti Bounce di scene Ball menjadi 0.5. Lalu kembali ke main scene, pilih satu bola dan rubah Bounce nya menjadi 1 dan tekan play.

Inspector properties

Perhatikan di bagian sebelah kanan akan muncul tombol "revert" (simbol tanda panah melingkar), ketika tombol ini muncul, berarti Anda telah merubah nilai properti yang akan menggantikan nilai dari file scene sumbernya. Saat seperti ini, meskipun properti scene sumbernya dirubah, nilai yang ada di scene (tempat Anda melakukan perubahan sebelumnya) akan tetap, kecuali Anda menekan tombol revert yang berarti mengembalikan nilai properti sesuai dengan scene sumbernya.

Konklusi

Instancing merupakan metode yang sangat berguna ketika Anda ingin membuat duplikat dari suatu objek (instanced scene/node).

Source: http://docs.godotengine.org/en/3.0/getting_started/step_by_step/instancing.html

Read More

Scenes dan Nodes

Pengenalan

Chef

Untuk sejenak, silahkan Anda bayangkan bahwa Anda adalah seorang koki handal sebuah restoran. Berarti, bukan game yang Anda ciptakan, melainkan sebuah resep makanan baru untuk tamu Anda.

Jadi, bagaimana cara koki membuat resep? Sebuah resep terdiri dari dua bagian: yang pertama adalah bahan, dan yang kedua adalah petunjuk untuk membuat/menyajikannya. Dengan begitu, semua orang dapat mengikuti resepnya dan menikmati hasil dari resep tersebut yaitu sebuah masakan.

Membuat game menggunakan Godot Engine ini sama persis dengan cara koki mempersiapkan masakannya. Anda seolah berada di dapur saat menggunakan Godot. Dimana di "dapur" Godot, nodes bagaikan sebuah kulkas yang berisi bahan yang berguna untuk membantu Anda membuat masakan.

Banyak macam dari nodes ini. Ada yang untuk menampilkan gambar, memutar audio/musik, menampilkan model 3D, dan lain sebagainya.

Nodes

Mari Kita mulai dari dasar terlebih dahulu. Nodes adalah fundamental dari pembuatan game di Godot. Seperti yang sudah disebutkan sebelumnya, setiap node bisa melakukan beberapa macam fungsi yang sesuai dengan spesialisasinya. Di setiap node selalu memiliki beberapa atribut seperti berikut:

• Selalu memiliki nama.
• Memiliki properties yang bisa dirubah sesuai dengan keinginan.
• Bisa menerima callback untuk diproses setiap framenya.
• Bisa diperluas secara fungsional (memiliki function lebih dari default).
• Bisa dijadikan child node untuk node lain.

Tree

Poin yang terakhir adalah yang terpenting, dimana sebuah Node bisa menjadi child node untuk node lain. Sama halnya seperti menaruh folder didalam folder. Dengan demikian sebuah node yang memiliki child node bisa disebut sebagai tree (pohon biner).

Di dalam Godot, kemampuan untuk menentukan posisi nodes seperti ini menjadikan Godot sebagai mesin yang sangat powerful untuk merancang sebuah game. Berbeda node berbeda pula fungsi pengimplementasian. Menggabungkannya sama halnya menambahkan beberapa fungsi yang dapat saling mengisi satu sama lain, sehingga menjadikannya lebih kompleks dan lebih bisa berkembang dengan tanpa batasan.

Jangan khawatir apabila belum memahami penjelasan diatas. Yang terpenting untuk sekarang adalah Anda sudah setidaknya mengetahui bahwa Nodes dalam Godot memiliki peranan penting dalam penggunaannya.

Scenes

Scenes

Setelah Kita membahas konsep dari nodes, selanjutnya adalah pembahasan Scenes.

Scene merupakan kumpulan beberapa node yang tersusun menjadi sebuah tree. Lebih lengkapnya, tentang scene:

• Selalu hanya memiliki satu root node (terdiri dari satu node utama).
• Bisa di simpan (menjadi sebuah file)
• Bisa dijadikan instance (penjelasan lebihnya nanti)

Menjalankan sebuah game berarti menjalankan sebuah scene. Sebuah project bisa memiliki beberapa scene didalamnya, tetapi supaya game dapat berjalan, salah satu dari kumpulan scene tersebut harus dipilih menjadi scene utama - main scene.

Pada dasarnya, Editor Godot secara general adalah Editor Scene itu sendiri.

Membuat Project Baru

Mengikuti susunan tutorial secara umum, mari Kita mulai dengan membuat project sederhana "Hello World".

Pertama, silahkan jalankan aplikasi Godot.

Project Manager

Seperti yang sudah dijelaskan pada artikel sebelumnya. Apabila Anda belum membaca artikel sebelumnya tentang Pengenalan Editor Godot Saya sarankan untuk membacanya terlebih dahulu sebelum melanjutkan ke tahap ini. Untuk membuat project baru silahkan pilih dan klik tombol New Project. Buat nama project "Hello World" (tanpa tanda petik) dan klik Create Folder untuk membuat folder baru ke dalam Project Path yang sudah ditentukan.

Create New Project

Kemudian tekan tombol Create & Edit.

Editor

Setelah beberapa tahapan diatas Anda lakukan, maka akan muncul jendela editor Godot seperti dibawah ini:

Godot Editor

Seperti yang sudah dijelaskan sebelumnya, membuat game dengan Godot terasa seperti sedang berada di dapur, jadi mari kita buka kulkasnya dan tambahkan beberapa bahan segar ke dalam project ini. Kita mulai dengan pesan "Hello World!" yang akan dimunculkan di layar.

Untuk melakukan hal ini, tekan tombol + (New Node) yang ada di bagian kanan pojok atas dibawah tab Scene.

New Node

Selanjutnya akan terbuka jendela baru berjudul Create New Node, menampilkan banyak pilihan node yang bisa digunakan.

Jendela Create New Node

Pilih node "Label". Ketikan nama node yang dalam hal ini adala "Label" pada kolom search untuk mempercepat proses pencarian node.

Search Node

Lalu klik tombol Create. Selanjutnya jendela kerja Anda akan terlihat seperti ini.

viewport 2D & node label

Pertama, terdapat perubahan viewport yang sebelumnya 3D menjadi 2D, hal tersebut dikarenakan node label adalah merupakan node bertipe 2D. Dan muncul label dibagian pojok kiri atas viewport.

Di tab scene sebelah kanan bagian atas muncul node yang terpilih. Sedangkan di bawah tab scene adalah properties dari node tersebut (tab inspector).

Step berikutnya adalah untuk mengganti property "Text" dari label, menjadi "Hello World!"

Mengganti property text pada label

Sekarang untuk mengetahui hasil dari kerja keras Kita selama ini. Tekan tombol Play Scene yang ada di pojok kanan atas (di atas tab scene), atau dengan menekan tombol F6 pada keyboard.

Play

Dan...

Pastikan untuk menyimpan scene sebelum menjalankannya

Anda diharuskan untuk menyimpan scene sebelum menjalankannya. Jadi, simpan scene tersebut dengan cara pilih menu Scene di pilihan menu utama dan klik Save (Scene -> Save). Beri nama file "hello.tscn" tanpa tanda petik.

Tampilan jendela save scene

Apabila aplikasi pada umumnya menggunakan jendela pengaturan file dialog bawaan dari operating system. Berbeda dengan Godot, dialog pengaturan file yang digunakan merupakan jendela dialog khusus. Fungsinya sama, melainkan di dalamnya Anda hanya diperbolehkan untuk menyimpan file dari editor ke dalam "resource path" yang dipilih. Seperti yang terlihat di kolom Path yang bertuliskan "res://" adalah berarti resource path. Jadi perlu diingat, setiap file yang Anda simpan/edit/load dari dan ke editor Godot adalah selalu dari resource path. Kedepannya, apabila Anda ingin melakukan import  file secara manual yang bertujuan untuk menambahkan file ke dalam game yang Anda bangun, cukup dengan menaruhnya ke dalam folder resource path project Anda.

Setelah menyimpan scene dan sekalilagi menjalankan scene, akan muncul Jendela uji coba seperti dibawah ini.

Project Hello World

Sukses!

Pengaturan Project

Baiklah, sekarang saatnya untuk melakukan pengaturan di project Anda. Untuk saat ini, pada saat Anda menekan tombol play, maka jendela uji coba muncul dan langsung menjalankan scene yang sebelumnya Anda edit. Karena project ini hanya memiliki satu scene. Bagaimanapun, biasanya satu project bisa memiliki lebih dari satu scene. Maka dari itu perlu dilakukan pengaturan scene utama - main scene sebelum menjalankan uji coba project.

Pengaturan ini tersimpan di satu file project.godot, yang merupakan file plaintext ber-extensi "win.ini" (file konfigurasi, untuk penjelasan lebih lengkap tentang file ".ini" bisa dibaca di Wikipedia). Di file tersebut terdapat banyak sekali pengaturan yang dapat mempengaruhi project Anda. Untuk menyederhanakan proses ini, Godot menyediakan settings dialog, dimana berfungsi sama seperti halnya Anda melakukan peng-edit-an file tersebut.

Untuk mengakses settings dialog tersebut, pilih Project -> Project Settings (di bagian menu utama).

Setelah jendela pengaturan terbuka. Arahkan ke tab General di bagian Application/Run lalu klik pada kolom Main Scene dan pilih "Hello.tscn" yang sebelumnya sudah dibuat.

Pengaturan Main Scene

Sekarang, setelah dilakukan pengaturan main scene, ketika Anda menekan tombol Play atau menekan tombol F5. Scene yang terpilih akan selalu menjadi scene yang berjalan di jendela uji coba project, tidak peduli scene mana yang sedang aktif.

Dialog Project Settings menyediakan berbagai macam pilihan yang akan secara langsung terhubung dengan  file project.godot. Jadi pengaturan apapun yang Anda lakukan dan simpan melalui dialog tersebut akan tersimpan dan diingat didalam file project.godot.

Bersambung...

Tutorial ini membahas tentang "Scenes dan Nodes", tetapi sejauh ini hanya membahas satu scene dan satu node. Jangan khawatir, karena Kita akan bahas selebihnya di tutorial berikutnya...

Source: http://docs.godotengine.org/en/3.0/getting_started/step_by_step/scenes_and_nodes.html

Read More