"Pampam Tales: The Jelly Jelly Kingdom" is an action roguelike game with procedurally generated dungeons which the main characteristic of the gameplay is the usage of Slimes as the primary way of attack.
In this game, each slime has it's own unique abilities and the player may find them while advancing through the dungeon. In addition, the player can also buy upgrades in shops that may also be found through the dungeon.
Programming Highlights
- Procedurally generated dungeons using:
- Binary Space Partitioning algorithm;
- Random Walk (Drunkward Walk) algorithm;
- Djikstra algorithm;
- Upgrade system;
- Skill system for the slimes effects;
- Randomically generated Shop system for the upgrades;
- Bouncing ball (slime) physics;
- Object Pooling;
- Aiming preview system using the cursor;
- Time management and VFXs for game juiciness;
- Target Group using Cinemachine;
Other Skills Highlights
- Shaders, VFXs and Post Processing effects using Unity Shader Graphs;
- Screen Ripple shader;
- Damage Flash shader;
- Color Adjustement Post Processing;
- Aiming Preview shader;
- Camera Shake VFX;
- Game design made by myself;
- Art and animations made by myself;
Procedurally Generated Dungeon System
The Procedurally Generated Dungeon system functions based on 3 distincts AI algorithms, each one of them being responsible for different parts of the system. The 3 algorithms are: Random Walk (more specifically the Drunkward Walk), the Binary Space Partitioning and, at last, the Djikstra algorthm.
The Drunkward Walk's utility is to create tiled paths, allowing to create dungeons that are walkable by the player or other entities. After filling the stage with floor tiles, the system fills the surrounding areas with wall tiles in order to close the dungeon. Also, in the end of the process, we use the same system of filling the tileset with floors and walls to connect rooms using corridors.
Using this system, we are also able to create a dungeon using the "Corridors First" logic, which generates dungeons with longer and more complex corridors and giving less attention to the format of the rooms.
Dungeon created using the Random Walk algorithm
In addition, the Binary Space Partitioning, an algorithm which recursively subdivides an Euclidean space into two convex sets by using hyperplanes as partitions, is used in order to specify the max size of the dungeon and divide it in rooms. This algorithm is very important for the system since it defines exactly where each of the rooms of the dungeon are located, making it easier to spawn NPCs and other objects and also define the utility of each room.
We also use this system to create dungeons with the "Rooms First" logic, which prioritizes uniform shapes for the rooms and have smaller corridors. In the end of the project, this is the logic used in the game to generate the rooms.
Binary Space Partitioning
Binary Space Partitioning
Rooms First logic
Rooms First logic
Rooms First logic
Rooms First logic
Rooms First logic
Dungeon created using the "Rooms First" logic, using the Binary Space Partitioning algorithm
Dungeon created using both Binary Space Partioning and Random Walk simultaneosly in order to make a "Rooms First" dungeon
At last, but not least, we have the Djikstra algorithm, a path finding algorithm with it's main difference being the usage of weights to determine the path. For this system, this algorithm was choosen to give a value (weight) to each of the dungoeon's room and determine each room's utility.
The logic to use this algorithm is: After creating the rooms of the dungeon, we randomically choose which room will be the starter one (the one that we're going to spawn the player in); Then, using the Djkstra algorithm, we add a weight to each of the rooms in the dungeon based on how distant each one of them is from the starter room; Finally, we give roles for each of the rooms based on their weights.
By the end of the process, we spawn the necessary objects for each room.
Upgrades System
The Upgrades System is handled by two main classes: the Upgrade class and the EntityUpgradesManager class (for instance called PlayerUpgrades since we still don't have the enemies in the game).
The Upgrade class is the base for all the upgrades created in the game. It inherits from the Scriptable Object class from Unity and contains informations for the upgrades, such as the name, if it does stack or not, the type of the upgrade, etc. Also, the most important thing about this class is the public virtual TriggerEffect function, which is overridden by every upgrade in order to make it's own unique functionality.
The EntityUpgradesManager is a class responsible for handling the activation and implementation of each upgrade on the entity. In this class, we're able to dynamically add, remove and trigger the upgrades. The upgrades are handled using a Dictionary with keys as Upgrade and values as int. The key represents the upgrade itself and the value represents the stack of the upgrade, if it stacks.
"Upgrade" class
Adding and Removing upgrades in the EntityUpgrades class
Triggering upgrades in the EntityUpgrades class
Triggering upgrades of specific types in the EntityUpgrades class
Upgrades Shop System
The Upgrades Shop system works with two main classes: the UpgradesShop and SellingUpgrade classes.
The UpgradesShop is responsible for randomizing the three upgrades that will to be sold in the shop and instantiating the upgrades.
The SellingUpgrade class is responsible for storing the data of the upgrade and handling the collisions of the object with the player in order to check if the player is able to buy the upgrade or not.
Also, when the player is able to buy the upgrade, using the Screen Stack system, a screen asking the player if they really want to buy the upgrade appears. If "Yes" is the answer, the upgrade is added to the player.
Slimes Effects System
The Slime Effects System is similar to a skill system. Each slime triggers a "skill" when hitting an obstacle or an enemy. The main class of the slimes is the "SlimeBall" class, which inherits from the BouncingBall class, the class containing the physics of the slimes, and the ISlimeEffect, the interface with the method that triggers the effect.
