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.