Ashhuby

Nix The Goblinette
[In Progress]

Description:

This project is a fast-paced 2D bullet-hell boss rush game where players embody Nix the Goblinette on a quest for vengeance against the King. The game is designed to provide an intense combat experience through a series of challenging boss encounters. It features dynamic battles using Nix's crystal-powered glider, equipped with a versatile arsenal of rockets, guns, and bombs, all aimed at defeating the sinister six knights of the kingdom. So far I have a small library of devleoped simple games, Nix marks the first ambitious full title I am building. I am so excited to explore complex 2D combat mechanics, design engaging bullet-hell boss patterns, and create an engaging fun world.

Technologies Used:

Godot, C#

Key Features:

• Intense Bullet-Hell Boss Fights: Engage in challenging encounters against six unique knights, each featuring distinct personalities and intricate bullet-hell mechanics.
• Versatile Glider Combat: Pilot Nix's crystal-powered glider, utilizing a powerful and diverse arsenal including rockets, guns, and bombs.
• Robust Boss AI with State Machine System: Utilizes a custom-built state machine framework (comprising a base `State` class and `StateMachine` manager) to enable complex, modular, and easily extensible boss behaviors and attack phases, ensuring dynamic and engaging boss encounters.
• Epic Boss Rush Structure: Progress through a series of escalating boss battles, culminating in the ultimate showdown with the King.

Challenges & Solutions:

One significant challenge involved designing and implementing the complex and varied bullet-hell patterns for each of the six unique bosses. I am overcoming this by developing a flexible, modular projectile-spawning system, combined with the aforementioned state machine to manage boss behaviors and phase transitions. Creating boss fights is Hard, very hard; A bunch of planning has gone into the few currently being worked on to esnure they feel distict and remain fun to encounter. Another challenge is balancing player abilities (glider movement, weapon power) against the difficulty of each knight's encounter to ensure a fair yet challenging progression. This is being addressed through continuous playtesting and iterative adjustments to weapon damage, fire rates, player maneuverability, and boss health/attack frequencies, alongside careful design of hitboxes and collision detection.

Nits
[Submission to 'Mini Jame Gam 43' game jam]

Description:

This project is a fast-paced, gesture-based casual game developed for the 'Mini Jame Gam 43' game jam over a weekend earning a top 5 place amongst 65 entries. The player's goal is to defend 'Nick's hair' from an escalating invasion of 'Nits' by drawing specific gestures corresponding to the Nit types. As time progresses, the difficulty increases, requiring quicker reflexes and precise drawing. The game tracks the player's score and 'hair health', aiming to provide an engaging and challenging experience within the constraints of a game jam.

Technologies Used:

Godot, C#, PixelStudios

Key Features:

• Intuitive Gesture-Based Combat: Players draw specific shapes (e.g., horizontal lines, V-shapes) to eliminate different types of Nits.
• Dynamic Difficulty Scaling: Nits spawn faster and the game becomes more challenging over time, indicated by visual and auditory cues (e.g., camera shake, "Faster!" label).
• Interactive Game State Feedback: Real-time display of score and 'hair health', with visual effects for Nit elimination (e.g., lightning particles, animations).

Challenges & Solutions:

One significant challenge was accurately recognizing player-drawn gestures in real-time while maintaining fluid gameplay, especially given the varying drawing styles of users. I overcame this by implementing a simplified gesture recognition algorithm that checks for key points and overall shape direction rather than pixel-perfect matches. Another challenge involved optimizing the spawning and management of numerous Nit instances to prevent performance degradation as difficulty increased. This was addressed by efficiently managing object lifetimes and utilizing Godot's scene instancing for rapid Nit deployment.

Snitches Get Stitches
[Submission to 'Three Thing Game' game jam]

Description:

Snitches Get Stitches is a fast-paced 2D runner game and winner of the 'Three Thing Game' game jam developed in a week. In this project, players take on the role of a mischievous student 'Calvin' navigating a school environment, where the primary objective is to reach the teacher, dodging hazardious elements and collect valuable homework assignments. The game combines quick reflexes with strategic movement to survive the endless halls of academic peril.

Technologies Used:

Godot, C#, PixelStudios

Key Features:

• Dynamic School Environment: Navigate a continuously scrolling school setting filled with unique hazards and collectible items.
• Core Runner Mechanics: Utilize responsive controls for running, jumping, and sliding to effectively dodge obstacles and collect homework.
• Health & Scoring System: Track your character's health and aim for high scores by successfully avoiding dangers and gathering assignments.
• Adjustable Difficulty: Engage with a challenging 'Hard Mode' that increases game speed and hazard frequency for a more intense experience.

Challenges & Solutions:

One significant challenge was implementing a dynamic and endless environment that felt varied yet performant. This was solved by utilizing Godot's parallax background features for continuous scrolling and developing an `ObjectSpawner` script to manage the random generation of diverse hazards and collectables. Another challenge involved balancing game difficulty to provide a fair yet challenging experience , especially with the introduction of 'Hard Mode'. This was addressed by creating configurable spawn rates and hazard speeds within the `ObjectSpawner.cs` and less sliding/jumping end lag, allowing for flexible adjustments.

ShubsBot
[Early Access]

Description:

This project is a multi-functional Discord bot designed to enhance server interaction and entertainment. It features audio streaming, a personalized Itch.io game library display, and a coin flip betting game. I built this to deepen my understanding of Discord API integration, asynchronous programming, and external API interactions (Itch.io, YouTube) in Python.

Technologies Used:

Python, Discord API, Itch API, yt_dlp, ffmpeg, python-dotenv

Key Features:

• Music Playback: Users can play, pause, resume, and stop music from YouTube within voice channels.
• Itch.io Game Library Display: Integrates with the Itch.io API to showcase my uploaded game library directly in Discord.
• Interactive Coin Flip Game: A simple betting game for server members to play.
• Modular Command Structure: Utilizes `discord.ext.commands` for organized and extensible command handling means any future additions are simplier to implement.
• Secure Credential Management: Implements `python-dotenv` for securely managing API keys and tokens, keeping sensitive information out of the main codebase.

Challenges & Solutions:

One significant challenge was handling audio streaming reliably and efficiently within Discord voice channels, especially managing YouTube content with `yt_dlp` and `ffmpeg`. I overcame this by carefully configuring `yt_dlp` options and ensuring robust error handling for voice connections and playback states, as well as integrating `ffmpeg` for audio processing. Another aspect was securely managing API keys and tokens using `python-dotenv` to keep sensitive information out of the main codebase.

To-Do-List Android Application
[In Development]

Description:

Technologies Used:

Android Studio, Kotlin

Key Features:

Challenges & Solutions:

Buket Katch
[Released]

Description:

My first project was a simple catcher-style game where players control a bucket to catch falling objects. The goal is to catch as many objects as possible while avoiding letting them fall past the bucket, which loses the player a life.

Technologies Used:

Godot, C#

Key Features:

• Intuitive Catching Mechanics: Players control a bucket to collect falling objects.
• Scoring and Health System: Tracks player score for caught objects and manages health based on missed objects.
• Dynamic Object Spawning: Objects fall from various points at a controlled rate.

Challenges & Solutions:

A primary challenge was implementing the core game loop, specifically managing object spawning and interactions. This was addressed by creating a dedicated `ObjectSpawner` to handle object generation and a `KillZone` to detect missed objects, which then reduces player health and triggers game over conditions.