RectangleShape2D in Godot – Complete Guide

Diving into the realm of game development can be a thrilling adventure, and one of the most versatile tools at a creator’s disposal is Godot Engine. Specifically, Godot 4 introduces the RectangleShape2D class — a fundamental building block for 2D physics in games. Whether you’re looking to construct bounding boxes, define character collision areas, or create interactive objects, understanding RectangleShape2D is essential. Join us as we take an engaging journey through the capabilities of this class, unraveling the mysteries of 2D collision and physics along the way.

What Is RectangleShape2D?

The RectangleShape2D class in Godot 4 is a two-dimensional shape that is primarily used in physics-based collision detection. This versatile class provides a simple yet powerful way to define the boundaries for various objects in a game, such as platforms, walls, or characters.

What Is It For?

The primary role of RectangleShape2D is to be associated with a CollisionShape2D node, thereby bestowing physical properties to 2D elements. It acts as an invisible mold that tells the game engine exactly where and how objects can collide and interact with one another.

Why Should I Learn It?

Understanding RectangleShape2D is crucial for any budding game developer, as collision detection is a core aspect of gameplay dynamics. Here’s why you should add this to your toolkit:

– It’s fundamental to creating solid and interactive objects controlled by the physics system.
– You gain more control over game mechanics, enhancing the player’s experience.
– It’s a building block skill that will carry forward as you tackle more complex game development challenges.

Mastering RectangleShape2D is not just about learning a specific class; it’s about empowering yourself with the knowledge to design dynamic, interactive 2D worlds that resonate with players. Let’s move forward and start shaping your game development skills!

CTA Small Image

Creating a Basic RectangleShape2D

To start with, let’s see how we can create a basic RectangleShape2D for our game. The following example assumes we have a CollisionShape2D node, which we will add our rectangle to.

var rect_shape =
rect_shape.extents = Vector2(100, 50)
$CollisionShape2D.shape = rect_shape

In the code above, we create a new instance of RectangleShape2D and then set its extents, which define the width and height of the rectangle. The extents property is half the width and half the height of the rectangle, so in our example, the full dimensions would be 200×100 pixels. Lastly, we assign this rectangle shape to our CollisionShape2D node’s shape property.

Positioning a RectangleShape2D

Once you’ve created the shape, you might want to position it appropriately in your game world. Positioning in Godot is handled by the parent node, so if you want to position the RectangleShape2D, you have to position the CollisionShape2D node.

$CollisionShape2D.position = Vector2(400, 300)

This line of code positions the center of the CollisionShape2D (and thus our rectangle) at the coordinates (400, 300) in the game’s 2D space.

Modifying the Extents

You can dynamically modify the extents of your RectangleShape2D during gameplay to achieve various effects, such as objects changing size. This can be done with a simple script that alters the extents property.

# Increase the width and height
rect_shape.extents += Vector2(10, 5)

# Decrease the width and height
rect_shape.extents -= Vector2(10, 5)

In these code examples, we are incrementing and decrementing the extents to change the size. Always remember that this property holds half the actual width and height values.

Rotating a RectangleShape2D

Rotation of the RectangleShape2D is again a function of the CollisionShape2D node. Using Godot’s node transformation properties, we can rotate our shape to fit inclined surfaces or to simulate object orientation changes.

# Rotate CollisionShape2D by 45 degrees
$CollisionShape2D.rotation_degrees += 45

The rotation is in degrees in the line above, but Godot also supports radians, depending on your preference or requirements.

Remember that while these code examples show you how to manipulate the RectangleShape2D, the visual feedback will depend on the nodes it’s associated with, and to see changes in the game window, you’ll need to attach this shape to visible nodes or debug the shape visibility within the Godot engine settings.

Through these fundamental examples, you’re well on your way to understanding how to create and manipulate 2D collision objects with the RectangleShape2D class in Godot 4. In the next section, we’ll look at more complex examples and how to apply these basics to build a simple gameplay element.Continuing from the basics, let’s delve deeper into the functionality of the RectangleShape2D. We’ll explore some advanced usage scenarios that can add complexity and polish to your game mechanics.

Simulating Interaction and Response

Beyond static collision, we might want our rectangle shapes to respond to interactions. Below is a code snippet showing how you could simulate a simple interactive button by changing its color when collided with another object.

# Imagine this function gets called when something collides with our button
func on_button_collision():
    var collision_color = Color(1, 0, 0) # Red
    $CollisionShape2D.get_parent().modulate = collision_color

Custom reactions to collisions might involve changing physics properties, something that can be quite dynamic and game-enhancing.

# Increase the bounciness of our collision shape
var physics_material =
physics_material.bounce = 0.8 # More bouncy
$CollisionShape2D.shape.material = physics_material

Creating a Kinematic Platform

Another exciting aspect is creating platforms that can move or be interactive. Let’s look at how you might set that up with RectangleShape2D and a parent KinematicBody2D.

func move_platform(direction, distance, speed):
    var motion = direction.normalized() * speed

This function can be called with a direction vector, the distance you intend to move the platform, and the velocity of movement.

Checking for Dynamic Collisions

Detecting dynamic collisions can be a bit more complex. Here’s how you can check if the RectangleShape2D is colliding with other objects dynamically using a script on the parent Area2D node.

func _on_Area2D_body_entered(body):
    print("Collided with ",

This function relies on Godot’s signal system and will print the name of any body that enters the area of our RectangleShape2D.

Implementing Drag-and-Drop

You might also want objects that users can interact with by dragging and dropping them within the game. We’ll start by detecting mouse clicks on a CollisionShape2D node with an attached RectangleShape2D shape.

# In a script attached to a CollisionShape2D
func _input(event):
    if event is InputEventMouseButton && event.button_index == BUTTON_LEFT && event.pressed:
        if $RectangleShape2D.get_rect().has_point(to_local(event.position)):
            print("Rectangle Clicked!")

This code would detect a left mouse button click within the RectangleShape2D‘s area and print a message to the console.

And here’s how you might script dragging:

var dragging = false

func _input(event):
    if event is InputEventMouseButton && event.button_index == BUTTON_LEFT:
        if $RectangleShape2D.get_rect().has_point(to_local(event.position)):
            dragging = event.pressed

    if dragging and event is InputEventMouseMotion:
        global_position += event.relative

With this code added to your object, you’re able to click and drag your rectangle around the screen.

The versatility of the RectangleShape2D in Godot Engine is immense, and understanding its full functionality allows greater creative freedom and interactivity in your 2D game projects. With these examples, we at Zenva hope to inspire you to experiment and integrate RectangleShape2D into your game design, adding a layer of depth that can greatly enhance the player experience.Certainly! Let’s dig even deeper into the uses of the RectangleShape2D with some practical and advanced examples.

Implementing Platform Boundaries

In a platformer game, you might want to keep your character restricted to the play area. Here’s how we can check if the player is within bounds and reset their position if they’re not:

# Game boundaries (assuming the boundaries are at x=0, x=800, y=0, y=600)
var left_boundary = 0
var right_boundary = 800
var top_boundary = 0
var bottom_boundary = 600

func _process(delta):
    if $Player.global_position.x  right_boundary:
        $Player.global_position.x = right_boundary

    if $Player.global_position.y  bottom_boundary:
        $Player.global_position.y = bottom_boundary

This code would ensure that the player character, which should have a RectangleShape2D attached, does not move outside the specified boundaries.

Reacting to Environmental Changes

Perhaps some interactive elements can alter the game environment. Let’s create a script for a switch that, when pressed, will open a door:

# Assuming we have a signal 'switch_activated' connected to this function
func _on_switch_activated():
    $Door/CollisionShape2D.disabled = true
    $Door/Sprite.visible = false

This script would disable the door’s collision and make it invisible, effectively “opening” it when the switch is activated.

Checkpoint System

A checkpoint system can be implemented using RectangleShape2D to define the checkpoint area. Here’s a simple way to set the player’s spawn point when they enter a checkpoint:

# Assuming this is connected to the body_entered signal of a checkpoint's Area2D node
var checkpoint_position = Vector2()

func _on_Checkpoint_body_entered(body):
    if == "Player":
        checkpoint_position = global_position

This would store the checkpoint’s position as the player’s new spawn point upon collision.

Timed Platform Disappearance

Now, let’s say we have a disappearing platform. We’d want the platform to become non-solid after a certain period when the player steps on it:

# Platform timer
var platform_timer = 1.0 # seconds

func _on_platform_body_entered(body):
    if == "Player":
        yield(get_tree().create_timer(platform_timer), "timeout")
        $CollisionShape2D.disabled = true

This would start a countdown when the player steps on the platform and disable the collision shape after 1 second, using Godot’s built-in timer functionality.

Interactive Objects: Pushable Blocks

Let’s say we want to create pushable blocks within our game — objects that the player can move around by walking into them. This could be done by checking for a collision on one side and then moving the block incrementally in that direction:

var push_strength = 10
var pushable = true

# In the block's script, which should be a KinematicBody2D
func _physics_process(delta):
    if pushable and is_colliding_with_player():
        global_position.x += push_strength * delta

func is_colliding_with_player():
    # Logic to detect collision with the player, possibly using an Area2D node
    # This function should return true if the player is pressing against the block
    return $CollisionShape2D.is_colliding()

Pushable blocks can add a puzzle element to your games, offering players a physical way to interact with the environment.

Enhanced Player Collision

Lastly, we might want our player character to have different collision responses based on the part of their body that is hit. For instance, landing on an enemy’s head could defeat the enemy, while a side collision might hurt the player. We could configure this using multiple RectangleShape2D instances:

# Player's script using different collision layers
func _on_Player_feet_area_entered(area):
    if area.is_in_group("Enemies"):
        # Defeat the enemy

func _on_Player_body_area_entered(area):
    if area.is_in_group("Enemies"):
        # Hurt the player

In this code, `feet_area` and `body_area` are separate Area2D nodes that detect different types of collisions, each with its own RectangleShape2D defining its boundaries. This allows for nuanced collision detection and response.

These examples showcase just how versatile the RectangleShape2D class is in Godot 4. It is our goal at Zenva to provide you with the knowledge and tools necessary to unlock your creative potential and enable you to build captivating and sophisticated 2D games. Armed with these skills, you’re well-prepared to take on the challenges of game development and create something truly remarkable.

Continue Your Game Development Journey

Embarking on the path of game development with Godot 4 is just the beginning. While RectangleShape2D is an integral piece of the puzzle, there’s much more to discover and craft in the world of game making. We at Zenva understand the excitement and the challenges that come along this journey, and that’s why our Godot Game Development Mini-Degree is tailored to equip you with the knowledge and real-world practice you need to evolve from a beginner to a professional game developer.

Our expertly curated courses delve into a multitude of topics, covering everything from 2D and 3D game creation, essential game mechanics, up to advanced features of the Godot Engine. Whether you’re a novice looking to take the first step or an experienced developer aiming to expand your skill set, our mini-degree is structured to offer a comprehensive learning experience. And with the flexibility to learn at your own pace on any device, you’ll find it seamlessly fits into your life.

Why stop here? Propel your game development skills to new horizons with our wide range of Godot courses. With Zenva, the next level of your game development adventure is just a click away.


The world of game development is vast and enthralling, and mastering tools like the RectangleShape2D in Godot 4 can give you a significant edge in creating your own 2D games. Whether you’re interested in building vast worlds, intricate puzzles, or thrilling platformers, the skills you’ve started to develop here are a critical step in your game creation journey.

At Zenva, we’re proud to be your guides on this exciting path. With dedication and practice, facilitated by our Godot Game Development Mini-Degree, you’ll be well-equipped to turn your dream game concepts into playable realities. We can’t wait to see the amazing games you’ll build—and remember, we’re here to help you learn, create, and thrive. Let the adventure continue!

Python Blog Image

FINAL DAYS: Unlock coding courses in Unity, Godot, Unreal, Python and more.