REPORT

CSDX 233 – GAMING TECHNOLOGY

ASSIGNMENT- 2

ALAN BEVIS JP
BASHEERAH BATOOL M
RRN:
220191601006
220191601009

[Link] CSE-(IOT) III-yr

Unity Game Development Report
PIXEL DASH

Table of Contents:

1. Executive Summary
2. Game Concept
3. Development Environment
4. Game Design
5. Graphics and Visual Assets
6. UI/UX Design
7. Game Components
8. Obstacle Implementation
9. Character System
[Link] Design
[Link] Mechanics
[Link] Strategy
[Link] and Quality Assurance
[Link] and Solutions
[Link] Enhancements
Introduction:
The development journey presented in this document encompasses the complete lifecycle of
game creation, from initial concept and design through implementation and testing. By
leveraging Unity Hub and the Unity Editor's robust toolset, this project demonstrates how
classic gameplay mechanics can be reimagined with modern development techniques while
maintaining the core appeal that has made platformers beloved for decades.
This game preserves the essential elements that defined the original—side-scrolling
movement, precise jumping mechanics, coin collection, and obstacle avoidance—while
introducing contemporary features like character customization and a virtual economy. The
development process detailed herein showcases both technical implementation and creative
design decisions that shape the player experience

Executive Summary
This report documents the development
process of a Pixel Dash platformer game
created using Unity Hub and the Unity
Editor. The game follows classic platformer
mechanics where players navigate through
various levels, avoid obstacles, collect
coins, and reach the endpoint to progress to
subsequent stages. The game features a
character shop system where players can
spend collected coins to unlock new
playable characters.

Key features of the game include:

 Side-scrolling 2D platformer gameplay
 Multiple levels with increasing difficulty
 Coin collection system
 Character store with unlockable characters
 Obstacle avoidance mechanics
 No checkpoint system (instant death upon obstacle collision)
 Level progression system
Game Concept
Overview

The game is conceptualized as a modern take on the classic Pixel Dash platformer series.
Players navigate a character through side-scrolling levels, jumping over gaps and avoiding
red obstacles. The primary objective is to reach the end of each level to progress to the next
stage while collecting coins along the way.
Core Loop
1. Navigate through level obstacles
2. Collect coins
3. Reach the end point
4. Progress to next level
5. Spend coins on new characters
6. Repeat with increased difficulty

Differentiation Points
This implementation does not include checkpoints. Once a player touches a red obstacle, they
die and must restart the level from the beginning. Additionally, the game features a character
store where players can spend collected coins to unlock new playable characters,items etc..
each with a unique visual appearance.
Target Audience
The game targets casual gamers and platformer enthusiasts, including:
 Fans of classic platformers like Super Mario
 Casual mobile gamers
 Players who enjoy short, challenging gameplay sessions
 Nostalgic gamers who appreciate retro gaming experiences

Development Environment
Unity Hub Setup

Unity Hub served as the central management tool for the project, offering:
 Project management capabilities
 Unity version control and management
 Template selection for 2D projects
 Asset store integration
Unity Version: 2022.3 LTS (Long Term Support)
Project Template: 2D Core
Unity Editor Components
The following Unity Editor components were essential for development:
Scene View
Used for designing levels, placing objects, and visualizing the game world during
development.
Game View
Provided real-time preview of gameplay, essential for testing mechanics and visual elements.
Hierarchy Panel
Organized all game objects in the scene, structured in a parent-child relationship for better
management.

Project Panel
Managed all assets including sprites, scripts, prefabs, audio files, and other resources.
Inspector Panel
Modified properties of selected game objects, components, and assets.
Console
Monitored debugging information, warnings, and errors during development and testing.
Animation Window
Created and edited animations for character movements, obstacles, and UI elements.
Project Structure
The project was organized with the following folder structure:

Game Design
Design Principles
The game design followed several core principles:
 Simplicity: Easy to understand but challenging to master
 Progressive Difficulty: Gradual increase in challenge across levels
 Clear Feedback: Visual and audio cues for player actions
 Risk vs. Reward: Strategic placement of coins near hazards
 Quick Recovery: Fast restart after failure to maintain engagement
Game Rules
1. Player must navigate from the start to the end of each level
2. Touching any red obstacle results in instant death
3. No checkpoints exist; player must restart the level upon death
4. Coins can be collected and spent in the character shop
5. Completing a level unlocks the next stage
6. Players can replay completed levels to earn more coins
Economy Design
The in-game economy revolves around coin collection:
 Coins are distributed throughout levels
 Higher-risk areas contain more valuable coin placements
 New characters are available for purchase with various coin costs
 Character costs are balanced to require multiple level completions
 Special coin bonuses are awarded for level completion

Graphics and Visual Assets

Art Style
The game employs a bright, colorful 2D pixel art style reminiscent of classic platformers
while incorporating modern visuals. The art style is characterized by:
 Clean, distinct silhouettes for gameplay clarity
 Vibrant color palette to engage players
 Consistent scale and proportion
 Visual distinction between interactive and non-interactive elements

Asset Creation Tools

1. Unity Sprite Editor

 o Used for slicing sprite sheets

o Creating animation frames

o Adjusting sprite pivot points

o Setting sprite collision bounds

2. Sprite Renderer Component

o Configured to display character and environment sprites

o Managed sprite sorting layers and order in layer

o Handled flip X/Y properties for character direction

3. Tile Palette
o Created reusable level elements as tiles

o Painted level layouts efficiently

o Maintained visual consistency across levels

4. Particle System
o Implemented death effects

o Created coin collection animations

o Added environmental details (dust, sparkles)

o Enhanced level completion celebrations

Asset Types
1. Character Sprites

o Main player
character with
idle, run, jump
animations
o Multiple
unlockable
characters with unique
appearances
o Character selection preview
images
 2. Environment Assets

o Ground tiles with variations (grass,

dirt, stone)
o Background elements (clouds,
mountains, trees)
o Decorative elements (bushes,
flowers, rocks)
o Platform variations (solid, moving,
temporary)

3. Interactive Elements
o Coins with shine
animation
o End level flags/portals

o Power-ups and
collectibles

4. Obstacle Elements
o Static red obstacles (spikes, thorns)

o Moving red obstacles (sawblades, fireballs)

o Enemy characters with patrol patterns

5. UI Elements
o Coin counter

o Character selection interface

o Menu buttons and navigation elements

UI/UX Design
Interface Architecture
 1. Main Menu Canvas

2. Game HUD Canvas

3. Pause Menu Canvas
4. Game Over Canvas
5. Level Complete Canvas
6. Character Shop Canvas

UI Components Used

1. Canvas
2. Canvas Scaler
3. Text Components
4. UI Images
5. Buttons
6. Scroll Views
7. Panels and Layout Groups
o Vertical/Horizontal layout groups for organized UI

o Grid layouts for character selection

User Experience Considerations

Several UX principles were applied to enhance player experience:
1. Accessibility
o High contrast between text and backgrounds

o Adequate button sizes for easy interaction

o Clear visual feedback for all interactions

2. Navigation Flow
o Intuitive menu hierarchy

o Minimal clicks to start gameplay

o Consistent back buttons in all screens

3. Feedback Systems
 o Visual highlighting for interactive elements

o Animation feedback for button presses

o Sound effects synchronized with UI interactions

o Screen shake for impactful game events

4. Learning Curve
o Progressive disclosure of game mechanics

o Simple first level design introducing core mechanics

o Visual cues guiding players to objectives

Game Components
Core Components
The game utilizes numerous Unity components to create the gameplay experience:
1. Transform Component
o Position, rotation, and scale of all game objects

o Hierarchical organization of related objects

o Local vs. world space transformations

2. Rigidbody2D
o Physics-based movement for the player character

o Collision response handling

o Gravity and force application

o Configuration:

 Body Type: Dynamic for player, Kinematic for moving platforms

 Collision Detection: Continuous for accurate fast-moving collisions
 Interpolate: Enabled for smooth movement between frames
3. Collider2D Components
o Box Collider 2D for rectangle-shaped collision areas

o Circle Collider 2D for round collision areas

o Polygon Collider 2D for precise shape collisions

o Composite Collider 2D for combining multiple colliders

 o Implementation details:

 Player uses a capsule collider for better platform interaction

 Triggers used for coin collection and death zones
 Edge colliders for ground surfaces
4. Animator
o Character animation state machines

o Transition conditions between animations

o Animation parameter controls

o Event triggers at specific animation frames

5. Audio Source
o Sound effect playback

o Background music implementation

o 3D sound positioning for environmental audio

o Audio mixing and prioritization

Custom Components
Several custom components were developed using C# scripts:
1. [Link]
o Handles player input

o Controls character movement and jumping

o Manages player state (grounded, jumping, falling)

o Sample code structure:

2. public class PlayerController : MonoBehaviour

3. {
4. [SerializeField] private float moveSpeed = 5f;
5. [SerializeField] private float jumpForce = 10f;
6.
7. private Rigidbody2D rb;
8. private Animator animator;
9. private bool isGrounded;
10.
11. private void Start()
12. {
13. rb = GetComponent<Rigidbody2D>();
14. animator = GetComponent<Animator>();
15. }
16.
17. private void Update()
18. {
19. HandleMovement();
20. HandleJumping();
21. UpdateAnimations();
22. }
23.
24. // Movement, jumping, and animation methods
25. }
26. [Link]
o Detects coin collisions

o Increments player's coin count

o Triggers coin collection effects

o Saves collected coins to player data

27. [Link]
o Manages obstacle behavior (static, moving, patterns)

o Handles collision with player

o Triggers death sequence

28. [Link]
o Controls level loading and transitions

o Tracks level completion status

o Manages level unlock progression

 o Handles player respawn

29. [Link]
o Displays available characters

o Processes character purchases

o Updates player's character selection

o Saves unlocked character data

Prefab System
Unity's prefab system was extensively used for:
 Creating reusable game objects
 Maintaining consistency across levels
 Efficient level design workflow
 Runtime instantiation of objects
Key prefabs included:
 Player character variants
 Coin objects with collection effects
 Various obstacle types
 Platform variations
 Level completion triggers

Obstacle Implementation
Obstacle Types
The game features various red obstacles that cause instant death on contact:
1. Static Obstacles
o Spikes: Fixed position spike formations

o Thorns: Decorative but deadly plant-like obstacles

o Lava pits: Areas that cannot be traversed

o Implementation: Simple colliders with trigger callbacks

2. Moving Obstacles
o Sawblades: Rotating obstacles that move along paths
 o Fireballs: Projectiles that follow patterns

o Falling rocks: Obstacles that drop when triggered

o Implementation: Transform manipulation or physics-based movement

3. Patrol Enemies
o Walking enemies that move back and forth

o Flying enemies with varied movement patterns

o Implementation: Waypoint system or simple AI scripts

Movement Patterns
Several movement systems were implemented for dynamic obstacles:
1. Linear Movement
o Obstacles moving between two points

o Speed and direction control

o Implementation:

2. public class LinearMovement : MonoBehaviour

3. {
4. [SerializeField] private Transform pointA, pointB;
5. [SerializeField] private float speed = 2f;
6. private float t = 0f;
7.
8. private void Update()
9. {
10. t += [Link] * speed;
11. [Link] = [Link]([Link], [Link],
[Link](t, 1f));
12. }
13. }
14. Circular Movement
o Obstacles rotating around a central point

o Customizable radius and speed

 o Direction control

15. Wave Movement

o Sine-wave pattern movement

o Adjustable amplitude and frequency

o Vertical or horizontal orientation options

16. Trigger-Based Movement

o Obstacles that activate when player enters a trigger area

o Delayed activation for anticipation

o One-time or repeating activation cycles

Collision Detection
Obstacle collision detection utilized Unity's 2D physics system:
1. Trigger Colliders
o Used for detecting player contact

o Optimized for performance with appropriate sizes

o Layer-based collision filtering

2. Collision Response
o OnTriggerEnter2D callbacks for instant death

o Visual effects on collision

o Audio feedback on obstacle interaction

o Implementation:

3. private void OnTriggerEnter2D(Collider2D collision)

4. {
5. if ([Link]("Player"))
6. {
7. // Trigger player death
8. [Link]<PlayerHealth>().Die();
9.
10. // Spawn death particles
11. Instantiate(deathEffectPrefab, [Link], [Link]);
 12.
13. // Play death sound
14. [Link]("player_death");
15. }
16. }
17. Visual Indicators
o Clear red coloring for all deadly obstacles

o Warning animations for timed obstacles

o Particle effects for enhanced visibility

o Distinctive silhouettes for clear player recognition

Character System
Character Architecture
The game features multiple playable characters that players can purchase with collected
coins:
1. Base Character Class
o Core functionality shared by all characters

o Movement and physics properties

o Collision detection

o Animation controller references

2. Character Variants
o Visual differences through sprite swaps

o Unique animation sets

o Special effects variations

o Same core gameplay mechanics

Character Unlocking System

The character store implementation includes:
1. Currency Management
o Coin tracking across game sessions
 o Persistent data storage using PlayerPrefs

o Coin earning balance across levels

o Implementation:

2. public static class CurrencyManager

3. {
4. private const string COIN_KEY = "PlayerCoins";
5.
6. public static int GetCoins()
7. {
8. return [Link](COIN_KEY, 0);
9. }
10.
11. public static void AddCoins(int amount)
12. {
13. int currentCoins = GetCoins();
14. [Link](COIN_KEY, currentCoins + amount);
15. [Link]();
16. }
17.
18. public static bool SpendCoins(int amount)
19. {
20. int currentCoins = GetCoins();
21. if (currentCoins >= amount)
22. {
23. [Link](COIN_KEY, currentCoins - amount);
24. [Link]();
25. return true;
26. }
27. return false;
28. }
29. }
30. Character Store UI
o Grid layout of available characters

o Visual indication of locked/unlocked status

o Price display for each character

o Preview functionality

31. Purchase Flow

o Coin verification before purchase

o Confirmation dialog to prevent accidental purchases

o Success/failure feedback

o Immediate character unlocking

32. Character Selection

o Visual selection interface

o Persistence of selected character

o Real-time character preview

o Implementation:

33. public class CharacterSelector : MonoBehaviour

34. {
35. [SerializeField] private CharacterData[] availableCharacters;
36. [SerializeField] private Transform characterContainer;
37. [SerializeField] private GameObject characterButtonPrefab;
38.
39. private void Start()
40. {
41. PopulateCharacterSelection();
42. }
43.
44. private void PopulateCharacterSelection()
 45. {
46. foreach (CharacterData character in availableCharacters)
47. {
48. // Create character selection buttons
49. GameObject button = Instantiate(characterButtonPrefab, characterContainer);
50. CharacterButton charButton = [Link]<CharacterButton>();
51. [Link](character);
52. }
53. }
54.
55. // Additional methods for handling selection and unlocking
56. }
Character Data Management
Character information is stored and managed through:
1. ScriptableObjects
o Character data assets for each variant

o Sprite references and animation data

o Purchase cost information

o Unlock requirements

2. Persistent Storage
o PlayerPrefs for saving unlocked characters

o JSON serialization for complex data

o Cloud save integration potential

3. Character Factory
o Runtime character instantiation

o Loading appropriate character based on selection

o Applying visual customizations

Level Design
Level Architecture
The game's levels follow a structured approach:
1. Level Scene Setup
o Individual scenes for each level

o Shared prefabs for consistent gameplay elements

o Level-specific challenges and layout

o Environmental theme variations

2. Level Progression
o Linear level unlocking system

o Level completion tracking

o Difficulty curve across level sequence

o Implementation:

3. public static class LevelProgressManager

4. {
5. private const string LEVEL_UNLOCK_KEY = "LevelUnlock_";
6.
7. public static bool IsLevelUnlocked(int levelIndex)
8. {
9. // Level 1 is always unlocked
10. if (levelIndex == 1) return true;
11.
12. return [Link](LEVEL_UNLOCK_KEY + levelIndex, 0) == 1;
13. }
14.
15. public static void UnlockLevel(int levelIndex)
16. {
17. [Link](LEVEL_UNLOCK_KEY + levelIndex, 1);
18. [Link]();
19. }
 20.
21. // Additional level tracking methods
22. }
23. Level Loading System
o Scene loading with transitions

o Level initialization

o Player spawn point management

Level Design Elements

Each level incorporates the following design elements:
1. Tilemaps
o Ground tiles with colliders

o Background decoration layers

o Foreground interactive elements

o Implementation using Unity's Tilemap system:

 Multiple tilemap layers (Ground, Decoration, Foreground)

 Composite colliders for efficient physics
 Rule tiles for automatic tile connections
2. Platform Types
o Solid static platforms

o Moving platforms (horizontal, vertical, circular)

o Temporary platforms (disappearing, crumbling)

o One-way platforms (jump through from below)

3. Level Challenges
o Jump timing sections

o Precision movement areas

o Obstacle avoidance sequences

o Speed-based challenges

4. Coin Placement
o Strategic positioning for exploration incentive
 o Risk/reward placement near obstacles

o Hidden coin stashes for thorough exploration

o Special coin formations for visual guidance

5. Start and End Points

o Clear visual indicators for level entry

o Distinctive end-level objects (flags, portals)

o Celebration effects upon reaching end point

Level Design Principles

The level design follows established platformer design principles:
1. Rhythm-Based Design
o Alternating tension and relief sections

o Consistent jump and movement patterns

o Readable visual rhythm in obstacle placement

2. Progressive Teaching
o Early levels introduce basic mechanics

o New challenges added gradually

o Safe practice areas before difficult sections

3. Visual Communication
o Clear silhouettes for platforms and obstacles

o Color coding for interactive elements

o Visual guides directing player attention

4. Rewarding Exploration
o Secret areas with bonus coins

o Alternative paths with varying difficulty

o Visual rewards for thorough exploration

Game Mechanics
Movement System
The character movement system was implemented with the following features:
1. Horizontal Movement
o Velocity-based movement using Rigidbody2D

o Smooth acceleration and deceleration

o Direction facing based on movement

o Implementation:

2. private void HandleMovement()

3. {
4. float moveInput = [Link]("Horizontal");
5. float targetVelocity = moveInput * moveSpeed;
6.
7. // Apply horizontal movement with smoothing
8. float smoothedVelocityX = [Link](
9. [Link].x,
10. targetVelocity,
11. ref velocityXSmoothing,
12. (isGrounded) ? groundDamping : airDamping
13. );
14.
15. [Link] = new Vector2(smoothedVelocityX, [Link].y);
16.
17. // Handle sprite flipping
18. if (moveInput != 0)
19. {
20. [Link] = (moveInput < 0);
21. }
22. }
23. Jumping Mechanics
o Variable height jumps based on button hold time

o Ground detection using raycasts

 o Coyote time for jump forgiveness

o Jump buffering for responsive controls

24. Air Control

o Reduced movement control while airborne

o Fall gravity multiplier for satisfying jumps

o Terminal velocity limits

Coin Collection
The coin collection system features:
1. Coin Implementation
o Trigger-based collection detection

o Visual and audio feedback

o Floating text showing value

o Animation and particle effects

2. Currency Management
o Runtime coin counter updates

o Persistent storage between sessions

o UI display of current coins

3. Collection Mechanics
o Automatic collection on contact

o Magnetization effect for nearby coins

o Combo system for consecutive collections

Death and Respawn

The game's death mechanics include:
1. Death Detection
o Collision with any red obstacle

o Falling into pits or off-screen

o Implementation using trigger colliders and bounds checking

2. Death Sequence
o Character death animation
 o Particle effects and camera shake

o Brief pause before respawn

o Audio stinger for impact

3. Respawn System
o Level restart from beginning (no checkpoints)

o Quick transition to minimize frustration

o Maintained coin collection from previous attempts

Level Progression
The level completion and progression system includes:
1. End Level Detection
o Trigger area at level end

o Victory animation sequence

o Coin tally and rewards

2. Level Transition
o Smooth scene transition effects

o Level completion data saving

o Unlocking of next level

o Implementation:

3. private void OnTriggerEnter2D(Collider2D collision)

4. {
5. if ([Link]("Player"))
6. {
7. // Register level completion
8. int currentLevel = [Link]().buildIndex;
9. [Link](currentLevel);
10.
11. // Unlock next level
12. [Link](currentLevel + 1);
13.
 14. // Show completion UI
15. [Link](true);
16.
17. // Play victory effects
18. [Link]();
19. [Link]("level_complete");
20. }
21. }
22. Progress Tracking
o Persistent storage of completed levels

o Star rating system based on performance

o Statistics tracking (completion time, deaths, coins)

Monetization Strategy
Although the current implementation focuses on gameplay, the coin system provides a
foundation for potential monetization strategies:
1. In-Game Economy
o Coin collection as primary currency

o Balance tuned for engagement

o Rewarding gameplay loop

2. Future Monetization Options

o Premium characters with special abilities

o Level packs with unique themes

o Double coin boosters or multipliers

o Remove ads option (if ads implemented)

3. Virtual Economy Balance

o Coin distribution balanced across levels

o Character prices set for progression pacing

o Regular content updates to maintain engagement

Testing and Quality Assurance
Testing Methodology
The game underwent several testing phases:
1. Unit Testing
o Individual script functionality testing

o Component isolation testing

o Error condition handling

2. Integration Testing
o Character interaction with environment

o Physics system reliability

o Scene transitions and data persistence

3. Playtesting
o Difficulty curve assessment

o Control responsiveness feedback

o Level design iteration based on player behavior

4. Performance Testing
o Frame rate monitoring

o Memory usage optimization

o Load time measurements

Bug Tracking and Resolution

Bug management followed a structured approach:
 Issue tracking using project management tools
 Categorization by severity and impact area
 Regular bug-fixing sprints
 Regression testing after fixes
Quality Standards
The following quality criteria were maintained:
 Minimum 60fps performance on target devices
  Sub-100ms input response time
 Consistent art style across all assets
 Clear communication of game state to player
 Intuitive controls with high responsiveness

Challenges and Solutions

Technical Challenges
1. Character Controller Responsiveness
o Challenge: Achieving tight, responsive controls while maintaining physics-
based movement.
o Solution: Implemented custom physics handling with raycasts for ground
detection and manual velocity adjustments for improved control.
2. Performance on Various Devices
o Challenge: Maintaining consistent performance across different hardware
specifications.
o Solution: Implemented object pooling for frequently instantiated objects
(coins, particles), used sprite atlases to reduce draw calls, and optimized
colliders with composite colliders.
3. Level Loading Times
o Challenge: Reducing load times between levels for better player experience.

o Solution: Implemented asynchronous scene loading with visual loading

indicators, reduced texture sizes, and used progressive loading of assets.
Design Challenges
1. Difficulty Balancing
o Challenge: Creating challenging but fair levels without checkpoints.

o Solution: Implemented careful level pacing with rest areas between difficult
sections, used playtesting feedback for adjustments, and ensured coin
placement rewarded skill.
2. Character Unlocking Pacing
o Challenge: Balancing coin collection and character prices to maintain player
engagement.
 o Solution: Structured character costs to provide early unlocks for engagement
while saving premium characters for dedicated players.
3. Visual Clarity
o Challenge: Ensuring players could clearly distinguish between safe platforms
and deadly obstacles.
o Solution: Consistent color coding (red for obstacles), distinct silhouettes, and
clear visual language throughout the game.

Future Enhancements
The following enhancements could further improve the game:
1. Gameplay Extensions
o Power-up system with temporary abilities

o Boss fights at milestone levels

o Secret levels unlocked by special conditions

o Multiplayer competitive modes

2. Technical Improvements
o Cloud save implementation

o Cross-platform progression

o Achievement system integration

o Analytics for gameplay optimization

3. Content Expansions
o Themed level packs (desert, ice, space)

o Season pass with timed exclusive content

o Special event challenges

o Daily rewards system

4. Player Engagement
o Leaderboards for level completion times

o Social sharing of achievements

o Friend challenge system

o Custom level editor