DEV Community: Pavel Zabelin

2D Physics Engine with c++

Pavel Zabelin — Mon, 06 Jan 2025 07:11:40 +0000

Introduction to the Project

About the Project

About three months ago, I came across a video about a homemade 2D physics engine and immediately got inspired to recreate the project myself. The idea was to build an engine in C++ that can render basic shapes and calculate their collisions. Along the way, I wanted to revisit 9th-grade physics concepts, gain a better understanding of the architecture behind such projects, and most importantly — have some fun.

In this article, I’ll describe the core functionality of my project and how it was implemented. The code is open-source, so feel free to dive into it right away. Here’s the GitHub link: 2DPhysicsEngine

Project Structure and Tools

For this project, I used a template from Cherno’s channel: TheCherno/ProjectTemplate. This template splits the program into two modules right from the start (in my case, ShowCase and Engine) and works out of the box with the Premake build system, which ensures compatibility across different platforms and IDEs. For rendering, I chose the SFML library as it’s one of the simplest and most popular solutions.

This template, with its two-module separation, essentially forces you to write cleaner and more architecturally logical code.

Interaction Between Modules (`ShowCase` and `Engine`)

As mentioned earlier, the project is divided into two modules:

ShowCase This module is responsible for the main loop, handling tasks such as rendering graphics, processing input, and calling the update() method on the engine side.
Engine This module handles all calculations related to rigid bodies and their collisions.

Each shape in the ShowCase module corresponds to a component in the Engine module that represents it in the physical world.

Engine Module

Engine Architecture: Main Loop

The engine stores an array of all physical bodies and iterates through them each frame to:

Check for collisions.
Resolve any collisions if present.
Apply gravity.
Call the Update(DeltaTime) method on each physical body.
Remove marked objects.

void Engine::Update(float DeltaTime)
{
    CheckCollisions();
    for (auto it = RigidBodies.begin(); it != RigidBodies.end(); )
    {
        auto& Body = *it;

        Body->ApplyGravity(Gravity);
        Body->Update(DeltaTime);

        if (Body->IsMarkedForDeletion())
        {
            it = RigidBodies.erase(it);
        }
        else
        {
            ++it;
        }
    }
}

Let's break down how this process works in detail

2.2. Collision System

For each pair of physical objects, separate collision checks are used. For two circles, it's enough to compare the distance between them with the sum of their radii, while for two AABBs (simplified rectangles), the formula will be different.

The first interesting challenge I encountered was determining which pair of objects needed a collision check. Since the engine's array stores a pointer to the base class RigidBodyComponent, and collision pair checks will occur many times every tick, the solution I chose was the double dispatch system. Let me explain how this works.

The base class for physical bodies has a pure virtual overloaded method that can accept a reference to either a base class object or a reference to any of its derived classes in the project.

virtual void CheckCollision(RigidBodyComponent& other) = 0;
virtual void CheckCollision(CircleComponent& other) = 0;
virtual void CheckCollision(AABBComponent& other) = 0;

Now, let's examine how the derived classes should override these methods using the circle as an example:

void CircleComponent::CheckCollision(RigidBodyComponent& other)
{
    other.CheckCollision(*this);
}

void CircleComponent::CheckCollision(CircleComponent& other)
{
    Engine::HandleCollision(*this, other);
}

void CircleComponent::CheckCollision(AABBComponent& other)
{
    Engine::HandleCollision(*this, other);
}

As you can see, if we know which class we need to check for collision with, we call a static method in the engine, passing a reference to the circle and a reference to the second object. However, if we receive a reference to the base class, we pass that object a reference to itself, thus invoking the CheckCollision(CircleComponent& other) method on the second object.

For this to work on the engine side, we also need methods to handle collision checks for all pairs of objects:

static void HandleCollision(CircleComponent& Circle, AABBComponent& aabb);

static void HandleCollision(CircleComponent& Circle1, CircleComponent& Circle2);

static void HandleCollision(AABBComponent& aabb1, AABBComponent& aabb2);

As I understand it, this works because in order to call the CheckCollision method with a reference to the base class from within the object, an upcast must be performed. This results in the method that accepts a reference to the derived class taking priority.

2.3. Collision Response

In the case of a "successful" collision, we calculate the collision normal and the depth of penetration between the objects, then call the ResolveCollision method, where we calculate and apply the impulse to the objects based on their velocities.

void Engine::ResolveCollision(RigidBodyComponent& BodyA, RigidBodyComponent& BodyB, const FVector2D& CollisionNormal)
{
    if (!BodyA.IsDynamic() && !BodyB.IsDynamic())
    {
        return;
    }

    float MassA = BodyA.IsDynamic() ? BodyA.GetMass() : FLT_MAX;
    float MassB = BodyB.IsDynamic() ? BodyB.GetMass() : FLT_MAX;

    FVector2D RelativeVelocity = BodyA.GetVelocity() - BodyB.GetVelocity();

    float VelocityAlongNormal = RelativeVelocity.Dot(CollisionNormal);

    if (VelocityAlongNormal > 0)
    {
        return;
    }

    float ImpulseMagnitude = -VelocityAlongNormal / (1.0f / MassA + 1.0f / MassB);

    FVector2D Impulse = CollisionNormal * ImpulseMagnitude;

    if (BodyA.IsDynamic())
    {
        BodyA.SetVelocity(BodyA.GetVelocity() + Impulse / MassA);
    }

    if (BodyB.IsDynamic())
    {
        BodyB.SetVelocity(BodyB.GetVelocity() - Impulse / MassB);
    }
}

Then, we call the PositionalCorrection method to fix any objects getting stuck inside each other, which can happen due to high velocities or during spawning.

void Engine::PositionalCorrection(RigidBodyComponent& BodyA, RigidBodyComponent& BodyB, const FVector2D& CollisionNormal, float PenetrationDepth)
{
    const float CorrectionFactor = 0.5f;
    FVector2D Correction = CollisionNormal * PenetrationDepth * CorrectionFactor;

    if (!BodyA.IsDynamic() || !BodyB.IsDynamic())
    {
        Correction = Correction * 2.f;
    }

    if (BodyA.IsDynamic())
    {
        BodyA.SetPosition(BodyA.GetPosition() + Correction);
    }

    if (BodyB.IsDynamic())
    {
        BodyB.SetPosition(BodyB.GetPosition() - Correction);
    }
}

2.4. The Update Method for Physical Bodies

Every tick, the engine calls the Update method for all physical bodies, where the velocity and position are updated, acceleration is reset, and the object is marked for destruction if necessary.

void RigidBodyComponent::Update(float DeltaTime)
{
    if (!bIsDynamic)
    {
        return;
    }

    Velocity += Acceleration * DeltaTime;

    Velocity = Velocity * (1.0f - EngineConfig::DAMPING_FACTOR * DeltaTime);

    Position += Velocity * DeltaTime;

    Acceleration = FVector2D(0.f, 0.f);

    NotifyPositionObservers();

    if (IsOutOfBounds())
    {
        MarkForDeletion();
    }
}

In this article, I don't delve into the physics of these processes. In this case, we use conclusions drawn from basic dynamics formulas.

2.5. Observers

You might have already noticed the call to the NotifyPositionObservers() method in your project. To notify about changes on the engine side, I decided to use the Observer pattern. In fact, I even have an article on this topic: Delegates & Observer Pattern Implementation in Unreal Engine.

Let's break it down with the position observer example. Anyone who wants to receive information about the position of a physical object must implement the following interface:

class IRigidBodyPositionObserver
{
public:
    virtual void OnRigidBodyPositionUpdated(const FVector2D& NewPosition) = 0;
};

To "subscribe" to updates, you need to call the method void AddPositionObserver(IRigidBodyPositionObserver* Observer) on the object you're interested in and pass this (the current instance) as the observer.

Meanwhile, the physical body, when updating its position, will loop through the list of subscribers and call the interface method on each of them.

ShowCase Module

3.1. Component Initialization

I prefer a minimalist main, so everything related to initialization (including the physics engine, window creation, and font loading) is contained within the ShowCase class.

3.2. Main Loop of ShowCase

After initialization, we enter the main loop, where rendering, updating, and processing of input and other events occur.

void ShowCase::Run() 
{
    SpawnLevel();

    while (Window.isOpen()) 
    {
        ProcessEvents();
        Update();
        Render();
    }
}

ShowCase also has an array of all the shapes that need to be rendered, and their Draw method is called every frame.

In the Update method, we calculate the DeltaTime variable and pass it to the engine by calling PhysicsEngine.Update(DeltaTime).

We also clean our array of shapes to be rendered, similar to how it's done in the engine, and handle shape spawning here as well. Since spawning occurs 20 times per second, in the input processing, we only change boolean variables that indicate whether mouse buttons are held down.

void ShowCase::Update()
{
    float DeltaTime = Clock.restart().asSeconds();
    PhysicsEngine.Update(DeltaTime);
    ClearMarkedShapes();

    TryToSpawnShape(DeltaTime);
}

4. Conclusion

4.1. Future Plans

In the future, I plan to optimize collision calculations between objects. There's no need to calculate collisions for every object with every other object. For example, we could divide the area into a grid and then determine which objects need collision checks with each other. Additionally, multithreading could be used to improve performance. Another idea is to add new shapes or combinations of shapes, such as chains of multiple bodies.

4.2. Recommendations to Readers

I highly recommend writing your own project with the implementation of some basic game engine module, whether it's physics, rendering, or something else.

Aside from improving your skills as a developer, it brings a lot of satisfaction. Seriously, I had almost forgotten the magic of development—when you first draw something on the screen or two circles start bouncing off each other correctly. I hope my article helps you take your first steps.

Project Zomboid: A Decade-Long Adventure

Pavel Zabelin — Thu, 26 Dec 2024 12:14:39 +0000

1. Introduction

Recently, the 42nd build of Project Zomboid was released, and as a player who first encountered the project 10 years ago, I decided to write an introductory article about it.

Zomboid is an isometric sandbox set in a zombie apocalypse world. And I ask you not to jump to conclusions—this is not at all the type of zombie survival game you might be thinking of. While you can experience something grind-heavy like DayZ or similar projects, this is just a small part of Zomboid, which can only be found on specific servers that I highly do not recommend playing on.

Zomboid is about a well-developed and deeply engaging gameplay. Here, any mistake can be your last.

The interaction with characters, enemies, and the surrounding world is astonishingly unique (though not without some frustrating flaws). I would compare it to a combination of third-person action and old console quest games, where you had to input your actions via text.

2. Meeting the Author and the Game

The author first encountered the project as a child back in 2014, when he saw it on a friend's laptop screen. What impressed the 11-year-old boy the most was the need to close windows with curtains so zombies wouldn’t react to the light, the ability to throw a blanket over the windows, and the necessity of barricading windows and doors with planks.

Combined with resource management for food, the ability to craft and modify weapons, it felt like the perfect survival sandbox—despite the lack of full 3D and outdated graphics. Unfortunately, it wasn’t possible to play it back then, but the memory of such an unusual game stayed with me for a long time.

3. Why You Always Want to Return to PZ

An important factor in an interesting project is the regular desire to return to it, and this is true for Zomboid. The intensity of gameplay in the early stages, along with a whole list of challenges for a character who knows nothing, has no gear, weapons, or anything else, combined with the unique take on basic mechanics, literally sucks you into the game.

Perhaps the first stage of the game, where you’re naked and trying to find at least a dead rat (stale and raw) to quench your hunger, is the core gameplay of Zomboid. In it, you gather loot, improve your skills, develop a base, find a car, and more. You can add mods, change world settings (zombie generation, their behavior and strength, loot spawn, etc.), invite friends to your party, but the essence of Zomboid lies in what I’ve mentioned above.

No matter how I think about it, Zomboid can be called a true sandbox, offering completely different gameplay experiences to anyone who wants it. If surviving in the urban outskirts isn’t for you, you can always head into the woods, sleep in a tent, and survive by foraging or hunting (which, by the way, has been revamped in the 42nd build). Don’t like tents? You can build your own house, paint the walls, set up plumbing, drag in a generator with a stove, and even organize a garden on the roof.

Also, it’s important to mention the difficulty of the project. The loading slogan “This is the story of your death” is very self-descriptive. To get used to its somewhat unique mechanics, you’ll need time, effort, and many new characters. Bites here are lethal unless you disable that in the settings (which I highly do not recommend, and generally, don’t mess with those settings early on). And it’s the difficulty of survival in the world of Zomboid that makes all your achievements in it so valuable, from the first axe you find to a car that’s in good enough condition to drive to the nearest warehouse outside the city.

Although I’ve spent most of my time in Zomboid playing solo or with a friend, I can’t help but mention the wide selection of multiplayer servers. You can find practically anything, from grind-heavy projects like DayZ or Rust, with regular PvP content, resource gathering, and many bandits (ranging from entire clans to groups of 3 survivors), to unique RP servers without the disgusting casinos and monotonous earning for a fancy car.

I’ve even seen ads for RP servers with invisible game masters, almost like in D&D. They are responsible for random events, zombie spawns, and the intensity of the adventure.

4. Development of Project Zomboid

Project Zomboid has come a long way since its early access release in 2013. When the first beta was released, there was no full 3D or sandbox mode. There was only a small story where the player had to take care of their bitten wife until her death.

Now, this story remains only as a background image in the main menu.

Personally, I consider the key changes to be those of the 41st build, as if the mass player base discovered the project because of it. The reworked animations, fully realized 3D characters with visible clothing and equipment, and much more. I’ve never been a very attentive person and didn’t follow the dev blog, so I found out about the beta of the new build somewhere a year after its release, during a stream by one of the PZ streamers. :-)

And as much as I was excited about the new features, I was just as disappointed by the lack of multiplayer. And the PZ community had to endure a lot of grief, as the beta test of the 41st build lasted four long years. I still remember how I’d visit the discussion page on Steam every year, hoping for good news, scrolling through all the messages, even those I had read a year ago.

As for the 42nd build – I haven’t played enough hours yet, but the impressions are pleasant. It’s the same PZ, just polished and much more refined in many ways. The rebalancing of the fighting system, the character skill system, and the improved sounds and lighting.

5. Community Modding Involvement

When discussing Project Zomboid, it’s impossible not to mention the Steam Workshop and the variety of modifications available. There is literally everything. You can expand the weaponry options, add clothes and gear, and there are many mods that solve logical problems in Zomboid, which are often added to the next builds, like the mod that allows you to light cigarettes from a stove.

Just, my god, there’s even a furry mod here.

The key is not to overdo it; this can negatively affect performance.

6. Conclusion

In conclusion, I highly recommend you try Project Zomboid yourself. The entry barrier might be high, so it’s better to try it in a party with a friend who is familiar with the game. If you manage to push through and not give up after the first ten deaths, Zomboid can offer you adventures for dozens, if not hundreds, of hours.

# Delegates: Observer Pattern Implementation in Unreal Engine

Pavel Zabelin — Wed, 18 Dec 2024 12:13:12 +0000

Delegates are an implementation of the Observer pattern in Unreal Engine, a behavioral design pattern that allows an object (the publisher) to inform its subscribed objects (observers) of important changes while maintaining low coupling between objects. This enables changes in the logic of different modules without worrying about unwanted consequences.

It is likely that Unreal Engine developers first encountered delegates when using the UShapeComponent, where they subscribed to the OnComponentBeginOverlap or OnComponentEndOverlap event.

Example with addDynamic subscription to callback

/** Code for when something overlaps this component */
UFUNCTION()
void OnSphereBeginOverlap(UPrimitiveComponent* OverlappedComponent, AActor* OtherActor,
    UPrimitiveComponent* OtherComp, int32 OtherBodyIndex, bool bFromSweep, const FHitResult& SweepResult);

void UTP_PickUpComponent::BeginPlay()
{
    Super::BeginPlay();

    // Register our Overlap Event
    OnComponentBeginOverlap.AddDynamic(this, &UTP_PickUpComponent::OnSphereBeginOverlap);
}

Even if this happens through the Event Dispatcher, which provides the same functionality as delegates but in the Blueprint editor.

Screenshot of Event Dispatcher from OnComponentBeginOverlap

To start using delegates, you need to:

1 Declare it using a macro, at the end of which you specify the number of parameters that the delegate will pass.

Example of delegate with explained parameters

DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FOnPickUp, AObserverExampleCharacter*, PickUpCharacter);

2 Declare the presence of an instance of this delegate. To make the delegate work in Blueprints, use UPROPERTY(BlueprintAssignable).

Example of the delegate object

/** Delegate to whom anyone can subscribe to receive this event */
UPROPERTY(BlueprintAssignable, Category = "Interaction")
FOnPickUp OnPickUp;

3 Design and implement the logic where the delegate will notify subscribers about an event and use the Broadcast() method at this point.

Example with broadcast

OnPickUp.Broadcast(Character);

Use the AddDynamic() method in all subscribers, passing the subscriber object and callback function. The method must accept the same parameters that the delegate will send. It should also be marked with UFUNCTION.

Example with subscription to the event and callback method declaration

UFUNCTION() 
void HandlePickUp(AObserverExampleCharacter* PickUpCharacter);

void UExampleComponent::BeginPlay()
{
    Super::BeginPlay();

    AActor* Owner = GetOwner();
    if (Owner)
    {
        UTP_PickUpComponent* PickUpComponent = Owner->FindComponentByClass<UTP_PickUpComponent>();
        if (PickUpComponent)
        {
            PickUpComponent->OnPickUp.AddDynamic(this, &UYourComponent::HandlePickUp);
        }
    }
}

Now let's repeat it with an example

Let's develop a health system and a response to damage received. We'll start with the health component, which will store variables related to health, handle taking damage, and also notify about the damage received using a delegate.

We also want to spawn a camera shake when damage is taken. Let's delegate this to the DamageVisualizationComponent. In the BeginPlay, we'll find the health component on the owner and subscribe to the OnDamageReceived event.

Additionally, let's make the damage apply effects to the character. We'll create an Effects Component, do the same as before—subscribe in BeginPlay and handle the OnDamageReceived event.

For the example, we also need to figure out how to take damage. Let's create a platform, where stepping on it will cause the player to take damage.

And here's the result: the health component notifies all of its subscribers, who can then implement the necessary logic.

In some cases, using delegates may be excessive, but an architecture where responsibility is divided between modules is always convenient.

Types of Delegates

In this article, only the Dynamic_Multicast delegate was used, but this is not always necessary. Use Dynamic if the delegate will be used in Blueprints. If there will only be one subscriber, use Single instead of Multicast when declaring the delegate.

Conclusion

Why use the Observer pattern:

The Observer pattern is useful in complex applications and games because it enhances modularity and minimizes coupling between components. Instead of interacting directly with each other, components can subscribe to events occurring in other parts of the system. This reduces dependencies between components, making them easier to test and modify since one component can be changed or replaced without rewriting the other parts of the system. In games, this is especially important because the logic often changes based on the game state or player actions, and the Observer pattern allows such changes to be handled easily.

Summary:

Delegates in Unreal Engine are a powerful tool for implementing the Observer pattern, which helps manage notifications between different components of the system with minimal coupling. Although delegates may be unnecessary in some cases, their use promotes a cleaner and more structured architecture, making it easier to maintain and expand the project. Thus, delegates play a key role in simplifying and improving the architecture of gameplay in Unreal Engine, making the system more flexible and easily modifiable.