DEV Community: Hizrawan Dwi Oka

Game Development Diary #11 : Second Day Back

Hizrawan Dwi Oka — Thu, 13 Jun 2024 01:30:15 +0000

13/06/2024 - Thursday

Today I will continue my GameDev.tv course. Here is what I’ve got from it:

Improved Aiming and Smoothing

Vertical camera motion and using interpolate_with to smooth the camera.

Custom Reticles

Learning how to use the _draw() virtual function and other draw functions to create custom 2D shapes for a reticle.

Advanced Jumping

Using projectile motion to make my jumping calculations more precise.

Making a prototyping sandbox

Using CSGShapes to fill out the play area and make a sandbox to test new features.

Introducing Navigation

I was introduced to the NavigationServer, regions, and agents for enemy AI and navigating 3D space.

Enemy Movement

Combining my navigation path and enemy movement script to make the enemy pursue the player.

That’s all for today. Thanks for reading my devlog.

Game Development Diary #10 : Come Back

Hizrawan Dwi Oka — Wed, 12 Jun 2024 07:38:52 +0000

12/06/2024 - Wednesday

After almost 2 weeks I haven't continue my game development journey. either working on my project or continue the course. I have to move to other city, and there is a lot of things to do in life.

But now I will Continue my project. I decided to continue GameDev.tv courses to learn more about Godot instead of working on my project. maybe I will continue my project after finishing this section of the course. and of course I will implement all knowledge and skill I got from the course to my project.

So for the last project in GameDev.tv course, we will try to build a retro FPS game.

Setting Up the Scene

Create a new project and set up the floor and camera.

As usual, to start project first we need to create new project in Godot and set up the game environment.

First Person Movement

Using template scripts to quickly get a player character running and jumping.

Input Events and Aiming

InputEvents and using them to move the camera

Thats all for today, because tomorrow my company held an event, so I need to prepare for that first. *or I will get fired :)

Game Development Diary #9 : Second Course Complete

Hizrawan Dwi Oka — Wed, 29 May 2024 07:00:00 +0000

29/05/2024 - Wednesday

Difficulty Curves

Introducing the curve resource and using timers to increase the difficulty of our level over time.

Scaling Enemy Health

Ending the Game

Using the TreeExited signal to check when the player has won the game.

The Victory Screen

Building a User Interface for when the player wins the game, letting them restart and quit. Introducing a variety of essential Control nodes and Containers.

Rewarding the Player

Rewarding the player with stars based on their performance in the level.

Using GLTF Files

Learning how to use GLTF and GLB files to add premade meshes into your games. Then using them to build the final turrets and home base.

Updating the MeshLibrary

Adding rock and tree meshes to the MeshLibrary to fill out the level and give more control over the environment with the GridMap.

Barbarians and Animations

Learning how to use bundled AnimationPlayer nodes within GLTF/ GLB files to add an animated barbarian enemy.

Polish and Balance

Tweaking Project Settings, adding fonts, and using exported variables to balance the play experience.

Plans for Next Session:

Implementing what I've learn from this course into my project.

Game Development Diary #8 : Still Second Course

Hizrawan Dwi Oka — Tue, 28 May 2024 07:00:00 +0000

28/05/2024 - Tuesday

Clicks and Cursors

Learning how to change the mouse cursor and detecting mouse clicks from the player

Building Towers

Creating a scene for defensive towers and learning how to spawn new scenes in code.

Picking Turret Positions

Connecting the RayPickerCamera and the TurretManager, so we can place the new turret scene onto tiles in the GridMap.

Making Projectiles

Learning about the Area3D and making the turrets able to fire them in a given direction.

Introducing Timers

Introducing the Timer node as a tool for making events happen at specific times. This lets us fire the turrets at regular intervals.

Aiming the Turrets

Using the look_at function and the towers basis, to aim the turrets at enemies on the Path3D.

Damaging Enemies

Using the Area3D node and variables to give the enemies health that is whittled away by projectiles until they are defeated.

For Loops and Targeting

Learning how to use loops to identify the best target for each turret.

Introducing Animations

Learning how to use loops to identify the best target for each turret.

Instantiating Enemies

Ung what we have learned from spawning projectiles to spawn endless waves of enemies.

Control Nodes and UI

Introducing Control nodes to create user interfaces. Adding a label to track the players gold count and positioning it with a container.

Earning and Spending Gold

Finalizing the bank, making the player earn gold when they defeat enemies, and making them spend gold in order to buy turrets.

Plans for Next Session:

Completing GameDevTV's course

Game Development Diary #7 : Second Course

Hizrawan Dwi Oka — Mon, 27 May 2024 07:00:00 +0000

27/05/2024 - Monday

Today is my seventh day developing a video game. That means it’s been one week since I started studying Godot, and I think the progress of the last week has been quite satisfying for me. I will try to remain consistent in the future.

Today's Progress:

Learn about gridmap:

Create a MeshLibrary to start placing meshes in a grid with the GridMap node.

Use the gridmap:

Learn how to customize a Gridmap to fit my MeshLibrary and start building a level with them both.

Building Curves With Path3D

Learning how to create 3D paths for the enemy to follow.

PathFollow3D Enemies

Making an enemy that can walk along my Path3D with a simple script.

Making a bas efor the gameplay

Connecting the enemies to a home base so they can deal damage at the end of the path.

Health and Labels

Learn how to track the base’s health and show it to the player with the Label3D node.

Introducing Properties

Using properties to create setter and getter functions. Ensuring code is run when the base’s health changes.

Text, Strings and Colors

Learning how to compose complex strings and create colors in scripts to improve the health label.

Mouse Input and Ray Picking

Learn how to use the Camera3D and the RayCast3D node to find out what objects in the game world the player is clicking on.

Updating Gridmap Cells

Getting familiar with GridMap functions to change tiles dynamically when the player hovers over them with the mouse.

Plans for Next Session:

Continue to my GameDevTV's course

Game Development Diary #6 : Weekend

Hizrawan Dwi Oka — Mon, 27 May 2024 03:41:58 +0000

25/05/2024 - Sunday

Today’s Progress:

No development work was conducted on the game today.

Thoughts:

Even though no direct technical work on the game was done today, I read a book called Theory of Fun for Game Design: Edition 2 by Raph Koster.

Here is what I've got from this book :

Understanding Fun:

Koster examines what makes games fun, suggesting that fun arises from learning, comprehension, and mastery. He proposes that we are evolutionarily programmed to enjoy learning because it has historically improved our chances of survival.

Learning Patterns:

The book discusses how games teach us through patterns. These patterns can range from calculating odds and predicting events to understanding social power and status. Games become boring when there’s nothing new to learn or when they’re too easy or too difficult.

Designing for Engagement:

Koster emphasizes the importance of creating games that are engaging, entertaining, and addictive. He presents ideas on how to improve game designs to incorporate a high degree of fun.

Cultural Influence:

The book also touches on how games serve as powerful learning tools and the influence they have on culture. It encourages designers to think beyond traditional game mechanics and consider the ethical implications of entertainment.

Plans for Next Session:

Continue to my GameDevTV's course

Game Development Diary #5 : Start My "BUMI" Project - Part 1

Hizrawan Dwi Oka — Sat, 25 May 2024 13:43:52 +0000

25/05/2024 - Saturday

To Do List :

*Create a level, just simple plane with some obstacles(just basic shapes).

*Implement collision detection to the level.

*Create 3 Main Character according to the novel(Just use capsule first until I get the 3d model that suitable for the game - because I am not good at art, but I will try to create by myself first.)

*Use Input Mapper to create a button that can switch the playable character.

What's Next?

I will continue to the second section on the course and get more useful knowledge that I can implemented on my project.

Game Development Diary #4 : First Course Complete

Hizrawan Dwi Oka — Fri, 24 May 2024 14:05:18 +0000

24/05/2024 - Friday

Today Progress :

-Continue Collision Detection

Detect RigidBody collisions with signals and identify bodies with Groups

first connect signal to method by clicking this menu

func _on_body_entered(body: Node) -> void:
    if body.name == "LandingPad":
        print('you touch landingpad!')

use this code to detect if the character touch the destination or not

and add detection if user touch the floor then the user lose using the code below

func _on_body_entered(body: Node) -> void:
    if "Goal" in body.get_groups():
        print('you touch landingpad!')
    if "LoseCondition" in body.get_groups():
        print('You Lose!')

-The Export Annotation

Replace ‘magic numbers’ with variables and control them from the inspector.

export a variable so it can be used in the inspector pane

## How much vertical force to when user move the character
@export_range(750.0,3000.0 ) var thrust: float = 1000.0
## How much force to when user move the character
@export_range(50.0,250.0 ) var torque: float = 100.0

and it will show in the inspector toolbar

-Crashing and Respawning

Use functions and get_tree() to respawn when crashing.

func _on_body_entered(body: Node) -> void:
    if "Goal" in body.get_groups():
        complete_level()
    if "LoseCondition" in body.get_groups():
        crash()

func complete_level():
    print('you touch landingpad!')
    get_tree().quit()

func crash():
    print('JEDER BOOM DUAR!!')
    get_tree().reload_current_scene()

i create two function that called when user touch floor or landing page. and i called get_tree function to reload the current scene or quit the game.

-Loading the Next Level

Making two new levels and using the landing pads to load them.

First i create the other level scene
On the previous level landing page, create script to select thescene destination

extends CSGBox3D

@export_file("*.tscn") var file_path

on the toolbar, select the next level file path

and we can continue to next level if we landed in the launching pad.

-Learning Tweens

Use tweens to sequence and delay function calls.


func complete_level(next_level: String) -> void:
    print('you touch landingpad!')
    set_process(false)
    is_transitioning = true
    var tween = create_tween()
    tween.tween_interval(1.0)
    tween.tween_callback(
        get_tree().change_scene_to_file.bind(next_level)
        )


func crash():
    print('JEDER BOOM DUAR!!')
    set_process(false)
    is_transitioning = true
    var tween = create_tween()
    tween.tween_interval(1.0)
    tween.tween_callback(get_tree().reload_current_scene)

add tween to delay the function. so it give 1 second delay after the character touch the landing page or crash.

-Tweening Hazards

Use the AnimatableBody3D node and Tweens to create moving obstacles for the player to dodge.

so the code will lookike this :

@export var destination:Vector3
@export var duration: float = 1.0

# Called when the node enters the scene tree for the first time.
func _ready() -> void:
    var tween = create_tween()
    tween.tween_property(self, "global_position", global_position+destination, duration)

-Learning Audio

Use the AudioStreamPlayer node to play one off sound effects when the player crashes and completes levels.

-Controlling Audio With Scripts

Use the AudioStreamPlayer 3D and else statements to play sounds when the player is boosting.

-Learning Particles

Learning how to use the GPUParticles3D node and control its emitting property for the character boosters.

-One Shot Particles

Learn how to use one shot particles for an explosion and to show the player has reached the goal.

-change the character with complex shape / model

Use the MeshInstance3D node and a variety of shapes to customize your player rocket

-Coloring the character

Saving and reusing the StandardMaterial3D node to color in the player ship.

-Building Backgrounds

Learning to use Constructive Solid Geometry to build walls and background objects for our levels.

-Lighting the Scene

Improving the WorldEnvironment DirectionalLight3D and adding Omnilights to improve the levels appearance.

-Exporting Game

Learn how to create files players can run by downloading templates and exporting the project.

Resources :

Complete Godot 3D: Code Your Own 3D Games In Godot 4! - GameDevTv Courses

Next Step :

I will implement all knowledge I gain from this course to start developing my game!!

To Do List :

*Create a level, just simple plane with some obstacles(just basic shapes).
*Implement collision detection to the level.
*Create 3 Main Character according to the novel(Just use capsule first until I get the 3d model that suitable for the game - because I am not good at art, but I will try to create by myself first.)
*Use Input Mapper to create a button that can switch the playable character.

*After I complete all item in the To Do List, I will continue the courses.

Game Development Diary #3 : Still GameDev.tv Course

Hizrawan Dwi Oka — Thu, 23 May 2024 13:34:36 +0000

23/05/2024 - Thursday

Day Three

Today's Progress:

-> Make the level out of CSGShapes to give a basic environment to work with.

You can choose color for the material using this tools

-> Add the player to the blockout level and finish setting up the camera and environment.

-> Convert the player into a RigidBody3D and control it with forces.

   A RigidBody3D is a 3D physics body that is moved by a physics simulation.

extends Node3D


# Called every frame. 'delta' is the elapsed time since the previous frame.
func _process(delta: float) -> void:
    if Input.is_action_pressed("ui_accept"):
        #Move the character posistion
        position.y += delta
    if Input.is_action_pressed("ui_left"):
        rotate_z(delta)
    if Input.is_action_pressed("ui_right"):
        rotate_z(-delta)

this is the previous code

extends RigidBody3D


# Called every frame. 'delta' is the elapsed time since the previous frame.
func _process(delta: float) -> void:
    if Input.is_action_pressed("ui_accept"):
        apply_central_force(basis.y * delta * 1000.0)
    if Input.is_action_pressed("ui_right"):
        apply_torque(Vector3(0.0,0.0,100.0 * delta))
    if Input.is_action_pressed("ui_left"):
        apply_torque(Vector3(0.0,0.0,-100.0 * delta))

this is the new code

this code make the character move according to the user input. But instead of transforming the position manually like the previous code, we use apply central force to move the character against the gravity and apply torque to rotate the character

-> Remap some of input to more intuitive controls.

    In the project setting there are inputmap tab, this menu allows us to set all the input we need for the game

-> Detect RigidBody collisions with signals and identify bodies with Groups.

Signal let the game objects communicate with each other.

Resource:

Complete Godot 3D: Code Your Own 3D Games In Godot 4! - GameDevTv Courses.

Next Steps:

-> Learn about tween and implement it in the tutorial's game
-> Adding audio
-> Controlling Audio with script
-> Learn about particle and implement it

Game Development Diary #2 : GameDev.tv Course

Hizrawan Dwi Oka — Wed, 22 May 2024 00:19:35 +0000

22/05/2024 - Wednesday

Day Two

Today's Progress:

-Interface Navigation: Spent time navigating around Godot's interface. The split-screen view and the drag-and-drop functionality are quite user-friendly.

Imported Scenes: Successfully imported my first scene into Godot. Understanding the scene system was crucial as it forms the building blocks of Godot's architecture.
3D Mesh Creation: Created a new 3D mesh. It was a bit challenging at first, but the intuitive interface made the process smoother. I also learn how to transform the mesh, create a shape for this mesh.
3D Mesh Creation: Created Lighting, environment, and camerafor this scene so when i run the game it will show something on the screen.

GDScript Basics: -Dived into GDScript scripting. -Wrote a simple script to print strings in the console. -Learn the difference between func _ready and func _process(delta). -Learn GDsripts variable -Learn about strong typing to get better performance and make code more readable

extends Node3D


# Called every frame. 'delta' is the elapsed time since the previous frame.
func _process(delta: float) -> void:
    if Input.is_action_pressed("ui_accept"):
        #Move the character posistion
        position.y += delta
    if Input.is_action_pressed("ui_left"):
        rotate_z(delta)
    if Input.is_action_pressed("ui_right"):
        rotate_z(-delta)

Thoughts:

I'm amazed at how flexible and powerful Godot is as a game engine. The community support and documentation are incredibly helpful. The more I explore, the more I realize the potential of this engine for solo indie game developers like myself.

Next Steps:

Delve deeper into GDScripts. I want to make collision detection, and learn about rigidbody3d and physics

Resources Used:

Complete Godot 3D: Code Your Own 3D Games In Godot 4! - Course

Game Development Diary #1 : My Journey into Game Development

Hizrawan Dwi Oka — Tue, 21 May 2024 07:56:09 +0000

21/05/2024 - Tuesday

Background

One day, I found myself bored of spending my weekends sleeping or merely wandering around. I contemplated spending my weekends on productive activities. Somehow, I was inspired to start writing a fiction novel about adventures. From there, I began my research, reading various novels, one of which inspired me to start game development. However, when I started trying to write, I changed my mind. As a software engineer, I wanted to create something related to my job, something that could also serve as my portfolio. Therefore, I decided to create a game instead of writing fiction novel. I decided to Adapting Tere Liye's novel called BUMI into a video game because I really like the story.

And this is my journey to develop that game :

Day one

Designing the Game

After I make my decision, I start to make a plan about how the game would look like, the art style, the characters, etc. I put all of those ideas into a document called GDD (Game Design Document) I use notion template by Game Dev Tales called 'One Page - Game Design'

Here is the link to my GDD:
https://www.notion.so/BUMI-Game-Design-8eb634feb21a4ce19580c557ea2ac231?pvs=4

Downloading and Installing Godot

The second step after I have designed the game, I need to choose a game engine because it will take a really long time to create my own engine. There are three engine that I considered to choose. Unity, Unreal, and Godot. After doing some research on those engines, I found out that Godot is portable, have small size, and not less powerful than other options. That is why I decided to use Godot for starting my game development journey.

So, after choosing the right engine, what I need to do next is to download the Godot Engine from the official website. The installation process was straightforward and didn't take much time.

Exploring the Interface

Once Godot was installed, I launched it and spent some time exploring the interface. I learned about the different panels such as the Scene panel, the Inspector panel, and the FileSystem panel. I also learned how to navigate within the 2D and 3D viewport.

Dev Log #1 End

That concludes my first game development log. Today, I’ve made the initial steps in my journey by choosing Godot as my game engine and installing it. As I move forward, I’ll start to delve into the actual development process, adapting the novel “BUMI” into an interactive gaming experience.

I’m excited about the journey ahead and I look forward to sharing more of my progress with you. If you have any suggestions, questions, or feedback, please feel free to share. Your input is greatly appreciated!

Stay tuned for more updates on my game development journey. Until next time!