Overview

Snow Surfer is a dynamic 2D game developed in Unity, where players can choose between two characters, Rex or Flo, and navigate through snow-covered landscapes. The game emphasizes fast-paced, action-oriented gameplay, incorporating power-ups, and various gameplay mechanics including scoring based on flips and airtime. The goal is to reach the finish line while avoiding obstacles and managing character abilities with collectable power-ups.

Key Features

• Character Selection: Players can select between two characters, Rex or Flo, each providing unique gameplay experiences.
• Gameplay Mechanics: The game allows players to earn scores by performing flips and staying airborne while managing speed and torque.
• Power-ups: Collect and utilize various power-ups to enhance characters’ abilities, offering temporary boosts in speed and rotation.
• User Interface: The game includes a comprehensive UI that displays game scores, airtime, flip counts, and other important feedback to the player throughout their experience.
• Audio and Visual Effects: Rich audio feedback and particle effects are integrated to enhance gameplay immersion, including collision effects and environment sounds.

Technologies Used

• Unity: The game is built using the Unity engine utilizing its powerful 2D game development tools.
• Cinemachine: For enhanced camera controls that provide a smooth pursuit of the player character.
• Scriptable Objects: Power-ups are implemented with Scriptable Objects, allowing easy management and instancing of game data.

Skills

This project showcases various programming skills, including:

• Object-Oriented Programming: Effective use of classes and inheritance to manage game states, characters, and UI.
• Unity Scripting: Proficient usage of Unity scripting in C# to handle game logic, character dynamics, and events (e.g., collisions, scoring).
• Data Management: Utilization of Scriptable Objects for clean, reusable game data management (e.g., power-up definitions).
• Event Handling: Implementation of event-driven programming where game events (like finishing a level or player collisions) trigger specific methods.
• UI Development: Creating responsive user interfaces to display game states, scores, and player information dynamically.
• Game State Management: Comprehensive management of the game state (e.g., handling game over and level won scenarios) through Singleton patterns and static variables.

Project Overview

The Delivery-Dash project consists of several essential components that work together to create an immersive gaming experience. The core features are implemented in C#, utilizing the Unity game engine. Here are some of the key components:

• GameManager.cs: This script manages the overall game state, keeping track of the packages delivered, spawning new packages and boosts, handling game over conditions, and displaying relevant UI elements such as scores and timer.

• GameTimer.cs: This class manages countdown timers for different game states (e.g., searching for packages, delivering them), updating the UI with the remaining time, and triggering end-of-timer events.

• Constants.cs: Contains a collection of constants used throughout the project, such as tags for various game objects, maximum allowed packages and boosts, and scene names.

• Utils.cs: A utility class providing helpful static methods, such as logging messages for debugging.

• Car.prefab: A Unity prefab file that defines the car object within the game, including its components and properties.

Skills

This project showcases a variety of programming skills and concepts, including:

• Object-Oriented Programming: Implementation of classes and interfaces, using inheritance, encapsulation, and polymorphism.

• Game Development with Unity: Proficient use of Unity’s ecosystem for creating game objects, handling physics, implementing collision detection, and managing game states.

• C# Scripting: Writing C# scripts to control game logic, manage interactions, and handle user input.

• Event Management: Utilizing events and method callbacks to maintain responsiveness in the game, such as triggering actions when timers expire.

• User Interface Design: Creating and managing dynamic user interfaces using Unity’s UI toolkit, including text updates, button interactions, and animations.

• Debugging Techniques: Applying effective debugging practices, such as logging messages to track game state changes and user interactions.

Other Features

• Use of the Particle System to generate a smoke effect for the designated drop-off point, and pink trail effect for the ice cream truck

• Use of multiple cameras to create a Picture-in-Picture view of the target customer

Overview

WarehouseWreckage is a project focused on creating a realistic warehouse environment using Unreal Engine 5.6. This demo is a basic Unreal Engine 3D, first-person shooter. All logic was built using the Blueprint Editors.

Key Features

• Scene Profiles: The project showcases multiple shared profiles for different lighting scenarios, including collaborations with advanced post-processing techniques.
• Custom Lighting: It allows for adjustments to ambient light, directional lighting, and sky lighting to create immersive atmospheres.
• Post-Processing Effects: The configuration includes parameters for color grading, bloom effects, and depth of field to enhance visual storytelling.

Skills

• Unreal Engine Proficiency: Understanding of setting up and configuring projects, utilizing plugins, and creating realistic environments within the Unreal Engine.
• Shader and Post-Processing Knowledge: Experience with lighting and visual effects, showcasing an ability to enhance graphics quality and atmosphere.
• Configuration Management: Ability to manage and edit ini files for ideal performance tuning and optimization.
• Environment Design: Knowledge in creating immersive 3D environments that utilize advanced graphic features.

Features

• Catch Mechanic: The player controls a character that catches falling eggs.
• Leaderboard Implementation: High scores are tracked and displayed after each game session.
• Health System: A health bar that depletes when missing eggs.
• Dynamic Gameplay: Variable egg drop speeds and gameplay mechanics based on player actions.
• Responsive UI: Interactive UI elements that reflect the game state.

Technologies Used

This project is implemented using Godot Engine with the following programming skills exemplified:

• GDScript Programming: The primary language for scripting game logic, including player controls, score tracking, and game state management.
• Resource Management: Handling custom resources for managing high scores and various game objects.
• Signal System: Utilizing Godot’s built-in signal system to manage communication between game objects, such as events when an egg is caught or a player dies.
• Scene Management: Creating and managing multiple scenes (Levels, Menus, UI components) and transitioning between them based on player actions.
• Game Physics: Implementing physics interactions for player movements and collisions with egg objects.
• UI Design: Crafting intuitive user interfaces using Control nodes, including health bars and leaderboard displays.

Overview

TappyPlane is a lightweight 2D side-scrolling game developed using the Godot engine. In this game, players control an airplane, navigating through various obstacles while collecting points. The game features engaging mechanics such as scoring, high scores, and scene transitions, presenting players with an entertaining flying challenge.

Features

• High Score Tracking: The game maintains a record of the highest score achieved, implementing a system to save and load scores.
• Scene Management: The game seamlessly transitions between multiple scenes: a main menu and the main gameplay screen.
• Obstacle Generation: Players navigate through an ever-increasing number of obstacles, which are dynamically spawned in the game environment.
• User Interface: A clean and intuitive UI displays scores and game status, enhancing the player experience.
• Audio Effects: Game sound effects enhance the gameplay experience, providing feedback on player actions.

Skills

This project showcases the following skills and programming concepts:

• Object-Oriented Programming (OOP): Utilizing classes, inheritance, and encapsulation through GDScript, promoting code reuse and organization.
• Signal and Slot Mechanism: Effective use of Godot’s signal system to decouple components and facilitate communication between game objects.
• State Management: Managing game states via scene transitions and a game manager, demonstrating skills in flow control and game state logic.
• Resource Management: Loading and saving game data using Godot’s resource system to track player progress.
• Event Handling: Implementing user input handling to control game interactions efficiently and responsively.

Project Structure

The project is comprised of several key components:

• Scripts: The game logic is encapsulated within various GDScript files, including:

  • GameManager.gd: Handles scene transitions and manages game workflow.
  • ScoreManager.gd: Manages high score tracking and saving/loading functionality.
  • SignalHub.gd: Centralized signal handling to communicate between game elements.
  • Various scripts defining behaviors for gameplay elements such as the airplane, pipes, and UI components.

• Scenes: Organized in a hierarchical structure to facilitate efficient game state management. Key scenes include:

  • Main.tscn: The game’s main menu.
  • Game.tscn: The core gameplay scene featuring obstacles and player controls.
  • Game_UI.tscn: UI elements for score display and player notifications.

Features

• Scene Management: The game features multiple scenes including main menus, level layouts, and game over screens.
• Player Interactions: Players can move, collect items, avoid enemies, and eventually reach the exit.
• NPC Behavior: Non-player characters can patrol, chase the player, and react to player inputs, showcasing AI features.
• Signal System: Uses a signal hub for event-driven programming, handling events such as item collection, player death, and game victory.
• Dynamic UI: User interface elements that display scores, game status, and respond to player actions.

Skills Exemplified

This project exemplifies a variety of programming skills necessary for game development:

• GDScript Proficiency: Coding game logic using GDScript, including classes, signals, variables, and functions.
• Scene Management: Efficiently managing different game scenes and transitions.
• Event-driven Programming: Utilizing the signaling mechanism in Godot for asynchronous event handling.
• Environmental Interactions: Implementing collision detection and interaction logic with objects and NPCs.
• Game Design Principles: Basic understanding of game mechanics, level design, and user experience considerations.

Overview

Sokoban is a classic puzzle game where the player pushes boxes onto designated target spaces within a bounded area. The goal is to move all the boxes to their target locations while minimizing the number of moves. The project implements key gameplay mechanics, level design, and score management tailored for an engaging user experience.

Features

• Multiple Levels: The game includes various levels with increasing difficulty, each designed with specific layouts of floors, walls, boxes, and targets.
• High Score Tracking: Players can save their scores and track their progress across different levels.
• Dynamic Level Layouts: Each level’s configuration, including the placements of walls, boxes, targets, and the starting position of the player, is defined via a JSON file, allowing for easy updates and new level designs without modifying the codebase.

Technical Details

The Sokoban game is developed using the Godot Engine, leveraging GDScript for scripting various game components. Key scripts include:

• HighScoresResource.gd: Manages player score data, saving and retrieving the best scores for levels. It employs a dictionary structure to hold scores against level names, ensuring that players can see their best achievements.

• LevelLayout.gd: Defines the layout of each level, handles the placement of tiles for various layer types such as floors, walls, and boxes. It utilizes vector mathematics to manage positions on the grid.

• TileLayers.gd: Represents different layers of tiles, enabling organized management of various elements in the game environment. This includes categorization into floors, walls, boxes, and target boxes.

• GameManager.gd: Orchestrates game flow, including scene transitions between the main menu and individual levels, and manages the loading of high score data.

• LevelData.gd: Responsible for loading and interpreting level data from a JSON file, converting it into usable game layouts.

Skills

• Game Design Principles: Understanding of how to design levels that provide both challenge and enjoyment.

• Data Management: Utilizing dictionaries and JSON parsing for managing game state and level design.

• Object-oriented Programming: Use of classes and GDScript extends to represent game objects logically, encapsulating behavior and data.

• Game State Management: Handling transitions between menus and gameplay, including managing inputs and responses.

• Debugging and Problem Solving: Implementing features to track high scores required algorithmic thinking to ensure accuracy and efficiency.

• User Interface Interaction: Designing user interactions, such as scene transitions and input handling, that facilitate a seamless player experience.

Overview

The game is designed to test players’ memory by matching pairs of images. As players select tiles, the game tracks the number of moves, game time, and handles game logic. Various levels with unique configurations enhance the gameplay experience, enabling players to increase difficulty as they progress.

Key Functionalities:

• Dynamic Level Loading: Levels are defined in a resource format that allows the game to preload level data and settings.
• Image Management: The project allows for easy addition and management of image files used in the game, showcasing efficient resource handling.
• Game Logic: Implements key game mechanics, including move counting, match checking, and game-over conditions.
• Responsive UI: The gameplay UI is built with flexibility, enabling easy transitions between game states (main menu, active game, and game over).
• Signals: Utilizes Godot’s signal system for communication between different components, such as game states and UI interactions.

Skills:

• GDScript Proficiency: Demonstrating knowledge of GDScript, Godot’s scripting language for game development.
• Object-Oriented Design: Utilizing classes and resources to create modular and reusable code.
• Event-Driven Programming: Efficiently employing Godot’s signal and slot system to manage events across different game states and components.
• Game Design Principles: Implementing gameplay mechanics, user experience considerations, and level design strategies.
• File Management: Understanding resource loading and handling in a game environment, allowing for scalability as more assets and levels are added.

Key Features

• Intuitive Gameplay: Players drag and release their characters to interact with various in-game objects.
• Level-Based Scoring: Players can track their best scores for each level, fostering competitive gameplay.
• Signal System: An event-driven architecture ensures efficient communication between game objects.
• Visual and Audio Feedback: The game includes animations and sound effects to enhance player experience.

Skills

This project showcases a variety of essential programming skills:

• Object-Oriented Programming: The use of classes and inheritance in GDScript demonstrates fundamental OOP principles.
• Event-Driven Programming: Implementing signals for inter-object communication highlights an understanding of decoupled applications.
• Data Management: Using dictionaries for score tracking and resource loading shows data handling skills.
• Game Logic Implementation: Understanding of physics, input handling, and game state management in a 2D space demonstrates game development expertise.
• UI Development: Creating dynamic user interfaces that respond to game events and user actions reflects good practices in frontend development for games.

Overview

Vixen Vault is a 2D action-adventure game built with the Godot Engine. The game showcases various mechanics commonly found in platformers, including enemy interactions, level transitions, scoring systems, and animated character behaviors. Players navigate through different levels, engage with enemies, and collect power-ups while aiming to achieve high scores.

Features

• Dynamic Scene Management: The game can load different levels and handle scene transitions smoothly.
• Scoring System: Players earn points by defeating enemies or collecting items, with a high score leaderboard to keep track of achievements.
• Animated Characters: Utilizing an animation tree structure, characters have smooth animations for actions such as attacking, moving, and dying.
• Signals and Events: The game employs a signal system for managing game state changes, such as player death or level completion, ensuring loose coupling between game components.
• Physics-Based Interaction: 2D physics are integrated to manage actions like jumping and collision responses effectively.

Skills

This project serves as a rich resource for developing and enhancing various programming skills within the context of game development, particularly using Godot. The following skills are exemplified through the project:

1. GDScript Proficiency: Deep understanding of GDScript, the scripting language used in Godot, is essential for creating game logic, managing state, and building reusable classes.
2. Object-Oriented Programming: The game uses classes and inheritance extensively (e.g., EnemyBase, Boss, Player), demonstrating principles of OOP such as encapsulation and polymorphism.
3. Event-Driven Programming: Through the signal system, developers can learn how to manage events and callbacks, which are vital for inter-component communication in games.
4. Game Physics and Collision Detection: Skills in using the Godot physics engine with built-in nodes like RigidBody2D and Area2D are critical for managing game interactions.
5. Animation Management: Knowledge of creating and managing animations using AnimationTree and AnimationPlayer helps in enhancing the visual appeal of games.
6. Resource Management: The project illustrates the effective loading, saving, and management of game resources, such as scores and settings, highlighting best practices in resource handling in game development.
7. UI Design & Interaction: Basic skills in designing user interfaces and handling input methods, which are crucial for creating an engaging player experience.