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

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.

Key Features

• Responsive Controls: Players can move the paddle left or right using keyboard inputs, allowing for precise control.
• Dynamic Gameplay: Gems fall from the top, and the game increases in difficulty as players progress.
• Sound Effects and Background Music: Enjoy immersive audio as players catch gems and navigate challenges.
• Scoring System: A scoreboard displays the player’s score, adding competitive elements to the gameplay.

Skills

This project demonstrates a variety of programming skills relevant to game development, including:

• Scene Management: Understanding of Godot’s scene system as evidenced by the organization of game elements into separate scenes (e.g., Game, Paddle, Gem).
• Scripting in GDScript: Use of GDScript for handling game logic, including interactions, scoring, and game state management.
• Input Handling: Monitoring and responding to user inputs through detailed configuration settings for keyboard actions.
• Physics and Collision Handling: Implementation of Area2D nodes for detecting collisions between the paddle and gems, showcasing knowledge of Godot’s physics engine.
• Timer and Sound Integration: Utilization of the Timer node to manage gameplay timing and AudioStreamPlayer nodes for sound effects and background music.
• Exporting for Web: Configuration of export settings for deploying the game to web platforms.