This terminal-based Boggle game challenges players to find words with connecting letters on a randomly generated 4x4 board under a timed limit. Using Python and the rich library, the game features a colorful console interface, real-time scoring, and automatic word validation via an online dictionary API. Each round encourages users to discover as many words as possible, following traditional Boggle rules that require connecting adjacent letters.

Key Features:

• Timer & Scoring:
  A countdown timer adds pressure to the game. The score, calculated based on word length per the official rules of Boggle, updated dynamically with each valid word.
• Interactive Console:ß
  Enhanced with Rich for intuitive prompts and board displays.
  ※ Interactive game in this browser uses CSS instead of Rich
• Custom Boggle Dice:
  The game board uses realistic letter distribution based on traditional English Boggle dice.

The project highlights interactive CLI design, game logic development using Object-Oriented Programming, and integration of real-time web API calls for word validation.

This is a command-line Wordle-style game based on the popular game created by Josh Wardle and made popular by The New York Times. It is implemented in Python and the rules for the game are the same as the original. Players guess a hidden word within a set number of attempts. Each guess is evaluated, and feedback is provided through color-coded hints about the accuracy of each letter's position, using ANSI escape codes for colors.

Key Features:

• Hidden Word Generation:
  The game randomly selects a word from the NLTK corpus, based on a specified word length.
• Color-Coded Feedback:
  After each guess, letters are highlighted to indicate their status:
  • Green: Correct letter in the correct position
  • Yellow: Correct letter, in the wrong position
  • Gray: Incorrect letter
• Win/Loss Detection:
The game checks for victory upon guessing the word correctly, or ends with a loss if the maximum attempts are exceeded.

This project demonstrates skills in console-based game design, ANSI color customization, word list filtering, and interaction with NLTK and its corpora. It combines interactive logic with concise feedback for the player.

Jefe’s Adventure is a Pygame platformer designed with object-oriented principles, featuring custom sprites and engaging gameplay. Players control a character navigating levels filled with obstacles and interactive elements, utilizing smooth movement and responsive collision mechanics. Enhanced the efficiency and modularity of the game is executed via Game State Managers and Asset Managers, making it easy to manage and update game assets and scenes.

Key Features:

• Character Movement and Collision Detection:
  The player character can move, jump, and interact with the environment, making for fluid and engaging gameplay. The game uses custom collision mechanics to handle character interactions with platforms, enemies, and other objects.
• Game State Management and Event Handling:
  The Game class manages scenes by setting up initial game states and dynamically changing scenes based on player progress. It uses a dictionary to assign specific assets to each game state, simplifying the flow between levels, menus, and gameplay scenes. Centralized event handling captures user inputs. The loop runs at a controlled frame rate to ensure consistent gameplay and smooth visual updates.
• Custom Sprites and Levels:
  Original sprite artwork was created in GIMP, based off the royalty-free sprites from Kenney, to align with the game's visual style and aesthetic. Levels designed in Tiled Game Map making software.
• OOP Structure with Inheritance:
  Built with object-oriented programming, inheriting from both custom classes and built-in Pygame classes, the game’s structure supports extendable features and organized code for maintainability.
• Asset Loading for Scalability:
  Each manager class is designed to load assets dynamically from directories, which supports scalability by making it easy to add new levels, backgrounds, and sounds without changing the core code.

This design highlights skills in game development using structured asset management, modular scene handling, and responsive Pygame mechanics. The code architecture allows for flexible control over visuals, audio, and gameplay flow, creating a seamless experience.

Phonics Heart Safari is an interactive blaster game that engages players in a fun and educational experience. Built using p5.js, players control a blaster to send hearts toward moving characters representing phonics letters. The game features dynamic gameplay, smooth animations, and an engaging scoring system, providing a lively atmosphere with sound effects and a leaderboard for high scores.

Key Features:

• Dynamic Gameplay:
  Players aim and shoot hearts at characters moving around the screen, making it a fun way to practice phonics sound and letter recognition.
• Scoring System:
  Points are earned for correctly hitting characters, while missing or hitting incorrectly results in point loss, enhancing the competitive aspect of the game.
  ※ Leaderboard functionality has been disabled for this website version.
• Multiple Screens:
  The game includes a start menu, instructions, high score display, and the main gameplay screen for a structured user experience.
• Interactive Controls:
  Players can control the blaster using mouse movements or keyboard inputs, making it accessible and intuitive.
  ※ Key and mouse press functionality has been adjusted from the original code to better suit this demonstrative webpage.

This project showcases skills in object-oriented programming, game design, and user interaction, with a focus on creating an immersive and educational gaming experience.

This interactive constellation guessing game invites players to engage with the night sky while testing their knowledge of lowercase letters. Built using p5.js, the game features smooth star movements and dynamic feedback as players make their guesses. With a vibrant visual design and engaging sound effects, players receive immediate feedback on their performance, creating an immersive gaming experience.

Key Features:

• Smooth Star Movement:
  Stars glide gracefully towards their target positions using linear interpolation (lerp), enhancing the visual appeal of the game.
• Dynamic Scoring System:
  Players receive a score based on correct guesses, with real-time feedback to keep the gameplay engaging.
• Interactive Gameplay:
  Make guesses by clicking on letters that appear after dropping stars, with easy-to-navigate screens for a seamless experience.
  ※ Mouse press functionality has been adjusted from the original code to better suit this demonstrative webpage.

This project showcases skills in creating interactive graphics, implementing user-friendly game mechanics, and designing an engaging audiovisual experience, all while focusing on using game play to help young learners learn to recognize the alphabet.

This browser-based Plinko game combines dynamic physics, interactive gameplay, and vibrant visuals. Built using p5.js and Matter.js, players drop balls onto a peg-filled board to score points based on where the balls land. The game features a realistic physics simulation, scoring mechanics, and interactive sound and graphic feedback to create an engaging experience.

※ Use the SHIFT key to "tilt" the board when a ball becomes stuck.

Key Features:

• Physics-Based Gameplay:
  Balls interact dynamically with pegs and obstacles on the board, simulating realistic movements and collisions powered by Matter.js.
• Scoring System:
  Players score points based on the bucket a ball lands in, with visuals and sound effects enhancing the experience.
• Interactive Controls:
  Drop balls with mouse clicks or the space bar, use the tilt mechanic with SHIFT.
  ※ Key and mouse press functionality has been adjusted from the original code to better suit this demonstrative webpage.

The project demonstrates skills in implementing 2D physics simulations, object-oriented game logic, and intuitive user interaction, with a focus on immersive graphics and sound design.