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.
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.
Unity Engine, C# scripting, animation systems, physics
10 weeks of intensive development and learning
Published game with procedural generation
"Knightaro" is a 2D action platformer featuring a knight character navigating through procedurally generated levels, battling enemies, collecting coins, and surviving challenging obstacles.
Our planning began with extensive brainstorming sessions, exploring various game genres and concepts before settling on our final direction through systematic analysis.
Learning Unity from scratch required understanding its component-based architecture and visual development environment. Key concepts mastered included:
We implemented professional project management practices using Trello for task organization and Gantt charts for timeline management.
We employed a systematic decision-making approach using preference matrices to evaluate project goals across three key stakeholder categories: operational, personal, and coaching objectives.
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.
The 2D platformer scored highest due to its optimal balance of learning opportunities, technical feasibility, and scalability potential. Key factors included:
The game features a sophisticated animation system using Unity's Animator component with state machines, conditional transitions, and blend trees for smooth character movement.
Complete animation flow showing idle, movement, jumping, attacking, and death states with conditional transitions.
Smooth running animation with leg and arm movement, sword swinging effects
Dual attack animations with random selection, F-key and mouse input support
Realistic leg positioning during jumps, multiple input key support
Idle patrol movement with player detection and engagement systems
Dynamic health bars, damage feedback, and death animations
Directional awareness, player tracking, and attack coordination
Animation states are controlled through conditional parameters and state machine logic, ensuring smooth transitions and responsive character behavior.
if ((Input.GetButtonDown("Jump") && IsGrounded()) ||
(Input.GetButtonDown("Vertical") && IsGrounded())) {
anim.SetTrigger("jump");
Jump();
}
One of the most technically challenging features implemented was the procedural level generation system, creating infinite, varied gameplay experiences.
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);
}
Initializes end position tracking and spawns initial platform segments based on startingSpawnLevelParts variable
Continuously monitors player proximity to level boundaries and triggers new segment generation when needed
Platforms were overlapping and interfering with each other during generation. Solved through precise offset calculations and collision detection improvements.
Infinite generation could lead to memory issues. Implemented cleanup systems and optimized spawning distance calculations.
We implemented a systematic testing approach using true/false positive/negative methodology to ensure robust game functionality across all features and edge cases.
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)
Core Functionality
Game Systems
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
Animation State Management:
Animation timing inconsistencies when multiple actions are triggered in rapid succession, requiring state machine refinement
Our collaborative development process emphasized continuous communication, shared decision-making, and agile adaptation to challenges while maintaining high code quality standards.
Discuss daily objectives, review Trello board, assign specific features and implementations
Continuous voice communication, muted during focused work, immediate collaboration on errors
Regular Trello updates, milestone validation, and adaptive timeline management
Throughout development, we encountered various technical and logistical challenges that strengthened our problem-solving abilities and collaborative skills.
Late-stage Unity installation failure required rapid task redistribution and workflow adaptation. Resolved through role reassignment and documentation focus for affected team member.
Numerous programming errors emerged during implementation. Strengthened debugging skills and collaborative problem-solving through systematic error analysis.
Timeline pressure in final week required feature prioritization and rapid development cycles to achieve playable game state for demonstration.
Based on timeline challenges, we identified the importance of building project buffers for future work:
The project culminated in a fully functional, published game that exceeded initial expectations and demonstrated comprehensive mastery of game development principles.
Game released on Google Play Store as "Knightaro"
Completed within existing resources and developer accounts
Exceeded baseline requirements with advanced systems
Community feedback validated our technical achievements and design decisions, highlighting the project's success in creating engaging gameplay experiences.
"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
This project demonstrated the effectiveness of self-directed learning combined with systematic project management in mastering complex technical domains.
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.