LinkedIn

Aeon

Aeon is a top-down, Diablo-style action game developed using TGE, the custom engine of The Game Assembly. The story follows a small hero navigating a world where time and space have been disrupted, requiring them to battle golems and overcome environmental obstacles. As a Gameplay and Tools Programmer, I focused on building the foundational movement and collision systems that defined the player experience within the engine.

Dev Time:

4 Weeks

Group Size:

12

Engine:

TGE, C++

Grid Collision and Level Design Tools dropdown

The Grid Collision system was the backbone of all movement in Aeon, ensuring entities stayed within the boundaries of the game’s floating islands. To make the system accessible for the team, I implemented a simple tagging workflow that allowed level designers to apply collision logic to existing objects and change tiles during runtime. This focus on usability ensured that the technical constraints of the grid never hindered the creative process of level building.

Player Movement and Navigation dropdown

Building upon the grid system, I developed a movement set focused on fluidity and edge-case stability. My goal was to ensure that walking and dashing felt natural despite the strict underlying grid.

One of the More Interesting Challenges: Stairs dropdown

A specific challenge during development was how the player interacted with verticality. I implemented a system that utilized smooth lerping between height layers, but also accounted for side-approach logic. This allowed the player to take their first few steps onto a staircase from the side for a more natural feel, while preventing them from jumping up the entire height of the stairs from the side, which maintained the physical integrity of the level.

Calculated Gaps and Dashing dropdown

I designed the dash mechanic to allow for more than just horizontal movement. When a player attempts to dash over a gap, the system checks in front of the character if there will be any tile to land on. This ensures the player can only dash over empty space if there is a viable tile on the other side, preventing them from dashing into infinite voids while still allowing for aggressive, gap-clearing gameplay.

1 float remainingTime = myDashComponent->GetTimer();
2 Tga::Vector2f remainingDistance = myDashComponent->GetVelocity(remainingTime);
3 Tga::Vector3f finalPosition = aParent.GetPosition() + Tga::Vector3f(remainingDistance.x, 0, remainingDistance.y);
4 Tga::Vector3f velocityPosition = aParent.GetPosition() + Tga::Vector3f(velocity.x, 0, velocity.y);
5 

6 GridTile* tileAtTarget = gridManager->GetTile(Tga::Vector2i(static_cast<int>(finalPosition.x), static_cast<int>(finalPosition.z)));
7 GridTile* tileAtVelocity = gridManager->GetTile(Tga::Vector2i(static_cast<int>(velocityPosition.x), static_cast<int>(velocityPosition.z)));
8 

9 if (!CheckTile(tileAtTarget, aParent, true) && !CheckTile(tileAtVelocity, aParent, true))
10 {
11   Tga::Vector2f extraLength = myDashComponent->GetDirection().GetNormalized() * 200.f;
12   Tga::Vector3f extraLengthPosition = velocityPosition;
13   extraLengthPosition.x += extraLength.x;
14   extraLengthPosition.z += extraLength.y;
15 

16   GridTile* tileAtExtraLengthTarget = gridManager->GetTile(Tga::Vector2f(extraLengthPosition.x, extraLengthPosition.z));
17 

18   if (CheckTile(tileAtExtraLengthTarget, aParent, false)) //Is a tile we can go to
19   {
20     std::cout << "Extra Dash Allowed" << std::endl;
21     //Allow extra length if close
22     myDashComponent->Dash(aParent, myDashComponent->GetDirection().GetNormalized(), myDashComponent->GetSpeed(), myDashComponent->GetDuration());
23 }
24   else
25   {
26     std::cout << "Dash stopped on edge" << std::endl;
27     myDashComponent->CancelDashOnEdge();
28     myStateMachine.SetState(0, &aParent);
29   }
30 }
31 else if (tileAtVelocity != nullptr) //Extra test to make sure we don't dash through walls and such
32 {
33   if (tileAtVelocity->GetTileState() == eTileState::eUnwalkable)
34   {
35     std::cout << "Dash stopped against solid" << std::endl;
36     myDashComponent->CancelDashOnEdge();
37     myStateMachine.SetState(0, &aParent);
38   }
39 

40 }

CPU Particle System dropdown

To enhance the visual feedback of the world, I created a lightweight, CPU-based particle system. While kept simple to maximize development efficiency, it was used effectively for entity trails and environmental destruction. Most importantly, it served a gameplay purpose by providing a clear visual indicator when an enemy noticed the player, bridging the gap between art and mechanical feedback.