The node formerly known as KinematicBody

When making 3D games in Godot 3 it was very common to base the player character on the KinematicBody node as they are a special type of Physics Body ment to be user controlled. The equivalent for 2D games was the KinematicBody2D.

One goal in Godot 4's development was to simplify the node tree and make the naming more consistent. To that effort, KinematicBody was renamed to CharacterBody3D and KinematicBody2D was renamed to CharacterBody2D. This was a common change for nodes with 2D/3D counterparts. No longer is the lack of a suffix equated to implied 3D, the 3D is now explicitly appended. The documentation lists some of these renamings.

This class consistency renaming is also apparent if you compare the the class hierarchies of KinematicBody and CharacterBody3D.

New functionality in CharacterBody

For the remainder of this article we'll focus on CharacterBody3D specifically but much/most of this is relevant to CharacterBody2D also.

Few more methods

If we compare the methods exposed for KinematicBody vs CharacterBody3D we see some expansion. For instance in addition to is_on_floor, we have is_on_floor_only. The former returns true if the body collided only with the floor on the last call of move_and_slide.

Changes with move_and_... methods

In Godot 3 methods such as move_and_slide had gotten a bit unruly with regards to their method signatures.

# KinematicBody

move_and_slide ( Vector3 linear_velocity, Vector3 up_direction=Vector3( 0, 0, 0 ), bool stop_on_slope=false, int max_slides=4, float floor_max_angle=0.785398, bool infinite_inertia=true )

With this function centric approach, as more features were added to the engine for which move and slide would need to be informed of, we would need to add yet another param to the method with a default value to protect backwards compatibility. This doesn't scale well and makes the method overly complex.

In Godot 4, in a more object oriented design, these parameters have been moved out to first class properties of the CharacterBody3D class.

So now in CharacterBody3D we manipulate these properties on the object prior to calling move_and_slide which now has zero parameters and simply returns true if the body collided, otherwise, returns false.

We can see this in play in the new Godot provided CharacterBody3D script template for basic movement.

extends CharacterBody3D

const SPEED = 5.0 const JUMP_VELOCITY = 4.5

# Get the gravity from the project settings to be synced with RigidBody nodes. var gravity: float = ProjectSettings.get_setting("physics/3d/default_gravity")

func _physics_process(delta: float) -> void: # Add the gravity. if not is_on_floor(): velocity.y -= gravity * delta

# Handle Jump. if Input.is_action_just_pressed("ui_accept") and is_on_floor(): velocity.y = JUMP_VELOCITY

# Get the input direction and handle the movement/deceleration. # As good practice, you should replace UI actions with custom gameplay actions. var input_dir := Input.get_vector("ui_left", "ui_right", "ui_up", "ui_down") var direction := (transform.basis * Vector3(input_dir.x, 0, input_dir.y)).normalized() if direction: velocity.x = direction.x * SPEED velocity.z = direction.z * SPEED else: velocity.x = move_toward(velocity.x, 0, SPEED) velocity.z = move_toward(velocity.z, 0, SPEED)

# Note, now zero parameters for move_and_slide move_and_slide()

Wrap up

As you can see core classes such as the formerly named Kinematic Bodies have been unified and simplified in Godot 4 in the form of the Character Body classes. This is only one small piece of the improvements of Godot 4 and you can find a few more details in the docs here.

I hope you found this useful and I encourage you to subscribe to this newsletter and the ExploreGameDev YouTube channel to get notified of new posts here and tutorial videos on YouTube.

Working with meshes and textures in Godot 4

Hello, I’ve published another video game development tutorial on Youtube. In this edition there is a gentle yet thorough introduction to the concept of polygon meshes and their applied textures. There is background covered on the concepts then we’re shown how to leverage them in you own game building in Godot 4.

These are important concepts to understand when starting game development, so be sure to check it out if you are interested in getting started with creating your own games. Thanks for watching.

Subscribe

Hello, after finishing my 10 part series on an introduction to 2D game development in Godot, I’ve decided to return to the topic of 3D.

Also I’ve decided to retire Godot 3, all future videos will use Godot 4 (until 5 comes out 😉)

The first installment is a quick intro showing the basics of importing a 3D model and then adding a character controller to it. I was amazed at how simple this was to accomplish using Godot 4. Hope you find it useful, be sure to add any feedback you might have in the Youtube comments.

Subscribe

Really excited to release this final lesson, part 10. It feels great to complete these sorts of personal projects.

I learned a lot in this process, not only Godot game development, but probably more so in regards to video editing. That was a new learned skill for me and I have a new admiration for those who do it professionally.

I’m excited to take what I learned in this 10 part series and leverage it in the next tutorials. I plan to stay with Godot, but maybe move into 3D game development.

In this final episode we tackle adding SoundFX and Music to finish off the TicTacToe game.

Subscribe

I’ve done most of the editing on episode’s 9 and 10 so they should come in short order, bringing an end to this series. I’m considering stepping into 3D game development in Godot, in the new version 4. Going to experiment with even shorter videos, 4-5 minutes, see if that helps me to maintain momentum.

In part 8 we introduce the user to custom fonts and applying a color scheme in the UI menus and the game board.

Subscribe

In this lesson we cover adding a game state storage class. This enables state to be recorded on one scene, then retrieved on any other scene in the game.

At this point, this TicTacToe game has all the needed functionality. In the next and final three videos we will cover visual polish, effects and sound.

We are up to episode 6 of 10. In lesson 6, a simple computer opponent is developed in this evolving 2D Tic Tac Toe game. As with other lessons, we leverage the GUT testing framework to do some test driven development. This enables single player mode in addition to the current two player mode.

As with all lessons, you’ll find a link to the source code of the game at the state it is in for that lesson.

Episode 7 will be out in a couple of weeks (this is a nights and weekends thing for me). In that episode we add global game state persistence. Then in 8, 9, and finally 10, we improve the visual look and feel of the game and add soundFX and music.

I’m learning a lot in both using Godot and video editing for the lessons. Can’t wait to finish up this series and then start something new.

Subscribe

This video introduces the learner to using Test Driven Development to add features, in this case; simple player turn management.

Alterations made as a part of video three’s release

I scheduled the Video to go public on USA, Sat morning

I plan to do this going forward to give consistency to the release cycle. I’m also paring this with a scheduled tweet to announce the video.

I adapted the title format (and back ported to previous videos

Previous format was: Game dev intro with TicTacToe, Part 3, Unit testing with GUT

I realized no one really cares that this is about TicTacToe, this important part is that it is about an introduction to video game development in Godot

So, the new format is: Intro to Game Development in Godot, part 3, Unit testing with GUT

I’ve renamed all previously released videos in this format

Updated thumbnails

All the thumbs were looking quite similar without a distinction. I adjusted the series part label to call it out more. I think it is better, but still needs improvement. I’ll spend some more time on it this week.

Original thumb style

New style

This has been a great learning experience thus far. I’m sure I’ll have plenty more realizations by the time I get to video 10.

I this latest lesson, we add winning move detection to the TicTacToe prototype. Moving it closer to what will eventually be a two player game.

This is a series of 10 lessons in total so we are just getting started. Stay tuned for a new episode each week.

In this set of videos, we’ll be using a simple game design; Tic Tac Toe, to demonstrate such aspects of game development as:

• Breaking down your game into domain objects and implementing them in GDScript

• Developing algorithms for Win detection

• Testing core logic with Godot unit test framework (GUT) unit tests

• Implementing turn management between player1 and player2

• Implementing single player agains the computer

• Tracking game state between multiple game rounds of a play session

• Adding start and end screens and managing the flow between them

• Improving game look with custom fonts an color scheme

• Adding particle effects

• Adding soundFX and music

Videos will be released about once a week, with an intro to the series here and the first lesson video here on Youtube.

Enjoy the video and let me know if there are other Godot topics you would like me to cover.

I’ve created an in depth guide to porting one of the official Godot 3 demo games; Dodge the creeps.

After watching this video, you’ll have a good sense as to the effort involved, plus a summarized guide to utilize in porting your own games.

With Godot 4 and the accompanying GDScript 2.0 on the horizon, I’ve taken some time to investigate the changes that come in with GDScript 2.0. I made a video covering the highlights of the new annotations feature plus the effect annotations have on export syntax.

What’s your template look like, or do you some other planning tool?

Summary

• Key message

Title

• Think of keywords used when googling

• Use google search, tube-buddy

Outline

Filming punch-list

From the outline, I’ll break down each scene and determine what A (A00) and B (B00) role shots will be needed.

• [ ] ::A01 Intro

• [ ] ::A02 Outro

• [ ] ::B02 Image of device

Editing

• Import into FCPX

  • New Library

  • Import media (let it bake: + 9)

  • Create new Project

• Trim clips into Project

• Fine trimming

• Audio Adjustments

• Color correction

  • Window -> WorkSpaces -> Color and effects

• Overlays / Effects

• Scene Transitions

• Music

• Export

Thumbnail

Publish to Youtube

• Keywords

• Description

Promote