Unity Game Development Project

A complete 2D platformer game built from scratch using Unity and C#, featuring procedural level generation, advanced animations, and comprehensive project management methodology. Developed as part of Module 431 with zero prior Unity experience.

Unity EngineC# ProgrammingGame DevelopmentProcedural Generation

Project Overview

Learning Journey & Motivation

Module 431 presented the perfect opportunity to step outside our comfort zone and tackle something we had always wanted to learn: game development with Unity. Despite having no prior experience with Unity or C#, we leveraged our strong Java programming foundation to master a completely new development environment.

Working as a collaborative team, we embarked on creating a 2D platformer from concept to published game, implementing advanced features like procedural level generation, complex animation systems, and professional project management practices.

Technologies Mastered

Unity Engine, C# scripting, animation systems, physics

Project Duration

10 weeks of intensive development and learning

Final Outcome

Published game with procedural generation

Game Concept & Features

"Knightaro" is a 2D action platformer featuring a knight character navigating through procedurally generated levels, battling enemies, collecting coins, and surviving challenging obstacles.

Core Gameplay Features

  • • Smooth character movement and jumping mechanics
  • • Combat system with multiple attack animations
  • • Enemy AI with health systems and dynamic behavior
  • • Collectible coins and health power-ups
  • • High score tracking and persistence
  • • Immersive background music and sound effects

Technical Innovations

  • • Procedural level generation system
  • • Complex state-machine driven animations
  • • Physics-based character controller
  • • Dynamic camera following system
  • • Collision detection and response system
  • • Cross-platform deployment (PC & Android)

Research & Planning Phase

Game Concept Development

Our planning began with extensive brainstorming sessions, exploring various game genres and concepts before settling on our final direction through systematic analysis.

Initial Brainstorming Results

2D Game Concepts
  • • Platform-based movement and jumping
  • • Enemy encounters and combat
  • • Weapon systems and power-ups
  • • Obstacle navigation and environmental hazards
  • • Collectible currency and unlockable content
  • • Progressive difficulty and level advancement
Advanced Features Considered
  • • Dynamic weather systems
  • • Vehicle-based gameplay segments
  • • Environmental storytelling elements
  • • Developer mode for testing and debugging
  • • Procedural level generation algorithms

Unity Engine Mastery

Learning Unity from scratch required understanding its component-based architecture and visual development environment. Key concepts mastered included:

Core Unity Concepts
  • • Scene hierarchy and GameObject management
  • • Inspector window and component attachment
  • • Rigidbody physics and collision detection
  • • Asset Store integration and resource management
  • • Prefab systems for reusable game objects
Advanced Features
  • • Animation state machines and blend trees
  • • Trail renderers for visual effects
  • • Custom C# scripting for game logic
  • • Camera controls and following systems
  • • Audio system integration and management

Project Management Strategy

We implemented professional project management practices using Trello for task organization and Gantt charts for timeline management.

Trello Board Organization

Trello Board Screenshot
Color-Coded Task Categories
General Tasks
Documentation
Enemy Systems
User Interface
Scene / World
Player
Info

Project Timeline (Gantt Chart)

Gantt Chart Screenshot
Administrative Phase
  • • Preference matrix development
  • • Gantt diagram creation
  • • Utility analysis completion
  • • Documentation framework setup
Technical Implementation
  • • Unity fundamentals and C# learning
  • • Core game mechanics implementation
  • • Animation systems and visual effects
  • • Testing and quality assurance

Decision Making & Analysis

Preference Matrix Analysis

We employed a systematic decision-making approach using preference matrices to evaluate project goals across three key stakeholder categories: operational, personal, and coaching objectives.

Stakeholder Goal Categories

Operational Goals
  • • New Learning (13.89%)
  • • Feasibility (13.89%)
Personal Goals
  • • Enjoyment (8.33%)
  • • Presentation Quality (0%)
  • • Cost Management (2.78%)
Coaching Goals
  • • Scalability (11.11%)
  • • Enhancement Capability (8.33%)
  • • Timeline Management (19.44%)
  • • Goal Clarity (22.22%)

Utility Analysis Results

After systematic evaluation of three game concepts, the 2D platformer emerged as the clear winner with a 13.2% advantage over the second-place option.

Final Scoring Results
2D Platformer
880.56 points
Tank Battle Royale
727.78 points
3D Shooter
777.78 points

Decision Rationale

The 2D platformer scored highest due to its optimal balance of learning opportunities, technical feasibility, and scalability potential. Key factors included:

  • Goal Clarity (22.22% weight): Clear, achievable objectives with measurable outcomes
  • Timeline Management (19.44% weight): Realistic scope for 10-week development cycle
  • Learning Value (13.89% weight): Comprehensive Unity and C# skill development
  • Scalability (11.11% weight): Extensible architecture for future enhancements

Technical Implementation

Animation System Architecture

The game features a sophisticated animation system using Unity's Animator component with state machines, conditional transitions, and blend trees for smooth character movement.

Unity Animator State Machine

Animator State Machine

Complete animation flow showing idle, movement, jumping, attacking, and death states with conditional transitions.

Character Animations

Movement System

Smooth running animation with leg and arm movement, sword swinging effects

Combat System

Dual attack animations with random selection, F-key and mouse input support

Jump Mechanics

Realistic leg positioning during jumps, multiple input key support

Enemy AI System

Behavior Patterns

Idle patrol movement with player detection and engagement systems

Health Management

Dynamic health bars, damage feedback, and death animations

Combat Response

Directional awareness, player tracking, and attack coordination

Animation Implementation

Animation states are controlled through conditional parameters and state machine logic, ensuring smooth transitions and responsive character behavior.

C# - Jump Animation Controller
if ((Input.GetButtonDown("Jump") && IsGrounded()) || 
    (Input.GetButtonDown("Vertical") && IsGrounded())) {
    
    anim.SetTrigger("jump");
    Jump();
}
Idle Animation GIF

Procedural Level Generation

One of the most technically challenging features implemented was the procedural level generation system, creating infinite, varied gameplay experiences.

Level Generator Architecture

C# - Procedural Generation Core
void Update() {
    // Check if player is close to the end of generated platforms
    if (Vector3.Distance(player.position, lastEndPosition) < PLAYER_DISTANCE_SPAWN_LEVEL_PART) {
        SpawnLevelPart();
    }
}

void SpawnLevelPart() {
    Transform selectedPlatform = levelPartList[Random.Range(0, levelPartList.Length)];
    SpawnLevelPart(selectedPlatform, lastEndPosition);
    lastEndPosition = GetEndPosition(selectedPlatform);
}

void SpawnLevelPart(Transform levelPart, Vector3 spawnPosition) {
    GameObject newPlatform = Instantiate(levelPart, spawnPosition + offset, Quaternion.identity);
    newPlatform.transform.SetParent(levelGrid.transform);
}

System Components

Awake() Method

Initializes end position tracking and spawns initial platform segments based on startingSpawnLevelParts variable

Update() Method

Continuously monitors player proximity to level boundaries and triggers new segment generation when needed

Technical Challenges & Solutions

Platform Collision Issues

Platforms were overlapping and interfering with each other during generation. Solved through precise offset calculations and collision detection improvements.

Performance Optimization

Infinite generation could lead to memory issues. Implemented cleanup systems and optimized spawning distance calculations.

Quality Assurance & Testing

Comprehensive Testing Strategy

We implemented a systematic testing approach using true/false positive/negative methodology to ensure robust game functionality across all features and edge cases.

Testing Methodology Framework

Testing Categories
  • True Positive: Prediction correct, technically correct
  • True Negative: Prediction incorrect, technically correct
  • False Positive: Prediction correct, technically incorrect
  • False Negative: Prediction incorrect, technically incorrect
Custom Testing Tool
Python - Testing Classification
while True:
    working = input("Funktioniert es? ")
    predictionright = input("Vorhersage richtig? ")
    
    if (working == "ja"):
        output = "True"
    else:
        output = "False"
    if (predictionright == "ja"):
        output += " Positive"
    else:
        output += " Negative"
    print(output)

Test Results Summary

True Positive Tests (✓)

Core Functionality

  • • Menu navigation (Quit/Play)
  • • Character control systems
  • • Combat damage mechanics
  • • Physics and collision detection

Game Systems

  • • Audio integration and management
  • • High score persistence
  • • Game over conditions
  • • Cross-session data retention
Issues Identified (⚠)

Animation Conflicts:

When multiple animations trigger simultaneously, they queue rather than blend properly

UI Scaling Issues:

Coin counter display truncates when scores exceed 99 points

Platform Compatibility:

APK build has limited keyboard input support in emulators

Critical Issues (❌)

Animation State Management:

Animation timing inconsistencies when multiple actions are triggered in rapid succession, requiring state machine refinement

Project Management & Collaboration

Development Workflow

Our collaborative development process emphasized continuous communication, shared decision-making, and agile adaptation to challenges while maintaining high code quality standards.

Daily Development Process

1
Morning Planning Sessions

Discuss daily objectives, review Trello board, assign specific features and implementations

2
Synchronized Development

Continuous voice communication, muted during focused work, immediate collaboration on errors

3
Progress Tracking

Regular Trello updates, milestone validation, and adaptive timeline management

Technical Achievements

  • • Mastered Unity development environment
  • • Implemented complex C# scripting solutions
  • • Created sophisticated animation systems
  • • Developed procedural generation algorithms
  • • Achieved cross-platform deployment

Project Management Success

  • • Delivered on schedule within 10-week timeline
  • • Maintained zero-budget development cost
  • • Exceeded initial scope with advanced features
  • • Implemented comprehensive testing protocols
  • • Published game to Google Play Store

Challenge Resolution

Throughout development, we encountered various technical and logistical challenges that strengthened our problem-solving abilities and collaborative skills.

Technical Obstacles Overcome

Unity Environment Corruption

Late-stage Unity installation failure required rapid task redistribution and workflow adaptation. Resolved through role reassignment and documentation focus for affected team member.

Complex Bug Resolution

Numerous programming errors emerged during implementation. Strengthened debugging skills and collaborative problem-solving through systematic error analysis.

Scope Management

Timeline pressure in final week required feature prioritization and rapid development cycles to achieve playable game state for demonstration.

Learning Buffer Implementation

Based on timeline challenges, we identified the importance of building project buffers for future work:

  • • Minimum one-day buffer for unexpected complications
  • • Earlier milestone validation to catch issues sooner
  • • Alternative workflow strategies for technical failures
  • • Enhanced documentation practices for knowledge preservation

Project Outcomes & Impact

Final Deliverables

The project culminated in a fully functional, published game that exceeded initial expectations and demonstrated comprehensive mastery of game development principles.

Published

Game released on Google Play Store as "Knightaro"

Zero Cost

Completed within existing resources and developer accounts

Full Features

Exceeded baseline requirements with advanced systems

Player Feedback & Reception

Community feedback validated our technical achievements and design decisions, highlighting the project's success in creating engaging gameplay experiences.

Community Reviews

"I find your game very interesting. The level generator impressed me the most. The character and animations are extremely admirable. The game has great potential :D"

— Manuel Andres, 16 years

"Very interesting to see what's possible in just 8 weeks. I work in IT myself and have never ventured into game development. The game convinced me and sparked my interest."

— Danijel Pavlovic, 18 years

"Cool animations, I believe you worked well as a team and delivered a very good product. I like the style of your game and the concept itself very much."

— Sascha Buthelezi, 16 years

Technical Skills Developed

Game Development Mastery

  • • Unity engine proficiency and workflow optimization
  • • C# programming with object-oriented design patterns
  • • Physics-based character controller implementation
  • • Complex animation state machine architecture
  • • Procedural content generation algorithms
  • • Cross-platform deployment and optimization

Professional Development

  • • Systematic project planning and execution
  • • Collaborative development workflows
  • • Comprehensive testing and quality assurance
  • • Technical documentation and knowledge transfer
  • • Problem-solving and adaptive planning skills
  • • Stakeholder communication and feedback integration

Learning Methodology Impact

This project demonstrated the effectiveness of self-directed learning combined with systematic project management in mastering complex technical domains.

Key Success Factors

Learning Strategy
  • • Leveraged existing Java knowledge for C# transition
  • • Extensive tutorial research and implementation
  • • Hands-on experimentation with Unity features
  • • Iterative skill building through feature development
Project Execution
  • • Clear goal definition and systematic evaluation
  • • Agile adaptation to technical challenges
  • • Comprehensive documentation throughout development
  • • Community engagement and feedback integration

Professional Portfolio Value

This Module 431 project serves as a comprehensive demonstration of technical learning agility, collaborative development skills, and the ability to deliver complete software products from concept to publication.

Demonstrated Competencies

  • Rapid Technology Adoption: Mastered Unity and C# within project timeline despite zero prior experience
  • Systems Thinking: Designed and implemented complex, interconnected game systems with proper architecture
  • Quality Focus: Delivered polished product with comprehensive testing and user feedback integration
  • Project Leadership: Successfully managed timeline, scope, and technical challenges in collaborative environment
  • Documentation Excellence: Created thorough project documentation following professional methodologies
  • Innovation Capability: Implemented advanced features like procedural generation beyond basic requirements