Small Video Games

You can click on the different images to go to the appropriate section

Bubble Market a 2025 Global Game Jam Game

where I was Developer.

Eco campus VR an arcade VR game that put a point on recycling.

The Green Cat an A*/Djikstra survivor

Sheepy a boids herding game

Goblin rush a finite state boss game

Death Canyon is a C terminal game

Brick Break is brick breacker game made in C++ in 4 hours.

Pablothello is a C++ othello game made with multiple game modes.

Planning Poker is a planning poker game made in python

The Green Cat: A* and Dijkstra - Pathfinding Demonstration

The Green Cat is a 2D survival game where the player controls a young woman accompanied by an alien cat, attempting to evade inspectors until the end of the level.

This project was developed as part of the AI for Video Games course, with a focus on pathfinding algorithms.

All aspects of the project (scripts, visual assets) were created by me, except for the running animations, which were inspired by the Ninja Adventure asset pack by Pixel Boy. I also used its audio for music and sound effects.

Overview

The Green Cat features two levels where the goal is to evade inspectors by eliminating some of them. There are two types of inspectors:

Purple Inspectors: Use the A* algorithm to track the player.

Blue Inspectors: Use Dijkstra's algorithm.

In the first level, only floors and walls are present. The second level introduces water zones that slow down both the player and inspectors. These zones add complexity to the pathfinding, as they have a higher traversal cost.

Features and Controls

Player Movement: Use the arrow keys to move.
Pathfinding Algorithms: A* for purple enemies and Dijkstra for blue enemies.
Dialogue System: Advance dialogues using the spacebar.
Collision System: Prevents the player and enemies from walking through walls.
Animations: Four-directional movement for both the player and enemies, as well as death animations for enemies.
User Interface: Score counter, health bar, pause menu, game over screen, and level completion menu.
Sound Effects and Music: Audio for key actions (damage, collisions, etc.) and background music.
Reset System: Allows players to restart the current level with regenerated enemies and obstacles.

Usage

Launch the Game: Click "Play" in the Unity editor to test the game.
Controls:
- Movement: Use the arrow keys.
- Dialogue: Advance dialogues using the spacebar.
- Pause: Press Escape to pause or resume.
- Restart: Click "Restart" in the pause menu to restart the level.

Project Structure

Assets/Scripts: C# scripts for game behaviors and features.
Assets/Prefabs: Reusable objects like enemies and tiles.
Assets/Scenes: Game scenes.
Assets/Musics: Sound effects and music.
Assets/sprite-test-random: Sprites and animations.

Suggested Improvements

While the game is functional, several potential improvements could enhance the experience:

Enhanced Pathfinding: Add an option for constant pursuit rather than intermittent tracking. This was a design choice but could be offered as a toggleable feature.
Spawn Management: Prevent enemies from spawning inside walls or too close to the player.
Sound Transitions: Smooth out the endings of sound effects for a more natural feel when objects are destroyed.
Player Animations: Improve animation smoothness for better fluidity.
Additional Levels: Incorporate more levels for extended gameplay.
Dialogue Management: Avoid re-displaying all dialogues when restarting a level.

You can find it on Itch here

greencat

Sheepy: A Boids Demonstration Game

Sheepy is a 2D herding game where you play as a dog, tasked with herding sheep back into a pen before time runs out.

Developed as part of a course on AI for video games, Sheepy demonstrates the use of boid algorithms. All elements of the game—from scripts to visual assets—were created by me, except for the royalty-free music.

Features

Player Movement: Control the dog using the arrow keys.
Boid Behavior: Sheep exhibit group dynamics with additional mechanics:
- Obstacle avoidance
- Wall bouncing
- Fleeing when the dog gets too close
Collision System: Ensures animals and the player cannot pass through walls.
User Interface: Includes a score counter, pause menu, and fail/victory screens.
Music: Features an ambient soundtrack using royalty-free music.

Gameplay Overview

Sheepy consists of 3 progressively challenging levels:

Animals:
- Dog (Player): Control the dog with simple keyboard inputs.
- Sheep (Boids): Exhibit group behavior with dynamic reactions.
Level Challenges:
- Increasing numbers of obstacles and varied placements
- More sheep to herd
- Tighter time limits as levels progress

Objective:

Herd all the sheep into the pen before time runs out!

You can find it on Itch here

sheepy

Goblin Rush

Goblin Rush was a Unity game designed to showcase finite state machine (FSM) mechanics.

The goal was to develop a small game featuring gameplay elements with multiple states.

I decided to create a boss rush game where the player must defeat a boss. Initially, I wanted to focus on the boss's states, but since I only had a week to complete the project while also attending classes, designing a boss with complex patterns and multiple attacks was too ambitious.

Instead, I implemented FSM mechanics in the playable character’s actions and animations. The character transitions between states such as idle, running, jumping, shooting while idle, shooting while moving, and taking damage.

This project was completed for the AI course in my Master 2 program at Gamagora.

To access the source code, click on the torch to visit my GitHub directly.

goblin rush

Death Canyon

The Death Canyon project involved creating a game in C

designed to run in the terminal.

The goal was to develop an infinitely generated canyon,

where a character moves through it and must avoid crashing

into the walls.

Everything had to be built from scratch, with the only external

library used being one that handles keyboard input without

delays, ensuring functional controls.

We built the canyon, set up the random generation, managed character movement, and implemented player death. After that,

we added some fun extras: colors, a dynamic difficulty system,

scores, and even a story mode with a boss.

This project was completed in collaboration with Vivien Chambe during our third year of Math-Computer Science at Grenoble.

To access the source code, click on the cactus or visit my GitHub directly.

Death Canyon

Brick Break

The Brick Breaker project involved developing a brick-breaking

game in C++ within just 4 hours of programming, while also

exploring different libraries.

We started by creating a block generation system that adapts to the

screen size, and then focused on the ball's physics and movement.

After that, we added lives for the player and health for the blocks,

each with different colors. Later, we integrated power-ups to increase

the number of balls in play, their speed, and the size of the paddle

the player controls.

Brick Break

Pablothello

The Pablothello project is an Othello game developed in C++ during my third

year of Math-Computer Science, in collaboration with Vivien Chambe.

The goal was to fully create a game with all its mechanics, as well as

features like saving progress and tracking scores.

We also needed to include several game modes:

1v1, 1vEasy AI, 1vHard AI, and AI vs AI.

The easy and hard AIs use different gameplay strategies and resolutions.

I also worked on the visuals and brought back Pablo, our enemy from the Death Canyon project, as a character in the game.

If you want to explore the code and run it on your computer click on the cactus to go the Github repositories

Pablothello

Planning Poker

The Planning Poker project is a task organization game developed

in Python using Pygame. This was my first time using Pygame, which

required a lot of experimentation.

I had to implement different types of rules: some requiring absolute

majorities, and others using the average of the votes.

Next, we needed to add the players we wanted and select the task file (either an empty one where tasks can be manually entered, or load an existing file). If starting without tasks not voted, it had to be possible to manually add them.

Once everything is set up, the game can begin. Each player takes turns voting on the current task using the traditional planning poker values.

After everyone has voted, the results are displayed, and depending on the chosen rules, we either move to the next task, repeat the current task, or take a break and save the file.