Designing a Foundational Computer Science Game Development Curriculum

By Andrew Swartz |
Independent Study with Professor Toby Dragon
Topics: Game Development, Computer Science Education, Godot, Software Architecture, Curriculum Design

Introduction

This independent study explored how game development can be used as a framework for reinforcing foundational computer science concepts through interactive, project-based learning. Rather than treating game development as an isolated specialization, I wanted to investigate how the systems required to build games could become a practical way of teaching concepts that appear throughout computer science.

The original goal was to analyze existing university-level game development programs and use that research to design a curriculum that could introduce students with prior programming experience to interactive software development. The project eventually evolved beyond simply studying existing programs. Through prototyping, assignment design, debugging exercises, refactoring projects, and curriculum planning, I developed a complete framework for teaching computer science through game development.

The Core Idea

Students should learn computer science through game systems, rather than simply learning how to make visually impressive games.

Game development provides a practical environment where concepts such as object-oriented programming, modularity, state management, event-driven programming, debugging, and software architecture naturally become necessary.

Initial Goals of the Study

The project began with several specific goals. I wanted to create a foundational course for students who already understood basic programming but had little or no experience with game development.

A major design principle was engine independence. Although Godot became the primary engine used for developing and testing the curriculum, the underlying concepts were intentionally designed to transfer to other engines and programming environments.

Programming Skills

Object-Oriented Programming Modular Design Debugging Game Loops Event Systems

Algorithmic Thinking

Collision Systems Rule Systems State Management Performance Thinking

Game Development Skills

Input Systems Feedback Systems Interactive Design Prototyping

Researching Existing Game Development Programs

To understand how these concepts are currently taught, I examined university game development and computer science programs from several institutions.

Across these programs, several strengths appeared repeatedly. Effective curricula tended to use milestone-based development, iterative prototyping, collaboration, and increasing project complexity.

I also identified several challenges. Some programs placed too much emphasis on visual polish, while others did not consistently emphasize computer science fundamentals. Team projects could also create uneven individual accountability.

A Different Approach

The curriculum I designed emphasizes the idea that the game is the environment for learning, not necessarily the final educational goal. The important outcome is understanding the underlying systems.

Designing Scaffolded Assignments

One of the most important parts of the independent study was developing assignments that gradually increase in complexity. Instead of asking students to immediately build a complete game, each project introduces another layer of software architecture.

Project 1 — Interactive Systems Foundations

Students learn game loops, object spawning, object destruction, real-time updates, player movement, and state tracking. The goal is to help students transition from thinking about linear programs to thinking about continuous interactive systems.

View Project 1 on GitHub →
Project 2 — Behavior and Interaction Systems

Students expand their systems by implementing autonomous enemy behavior, collision systems, camera systems, UI systems, and state transitions.

This introduces event-driven systems, AI logic, and the challenge of managing multiple interacting entities. These ideas begin to resemble the larger software architecture problems students will encounter in more advanced projects.

View Project 2 on GitHub →

Godot Workshop: From Engine to Independent Development

A major component of the independent study was developing a Godot onboarding workshop. The workshop was designed to bridge the gap between learning an unfamiliar engine and being able to independently construct interactive systems.

Students work through scene creation, TileMaps, animation systems, collisions, platforming, top-down systems, combat, and UI systems. Rather than simply following tutorials, the workshop provides a foundation students can use to begin building their own projects.

Godot Workshop

The workshop introduces the engine while reinforcing broader concepts such as scene architecture, reusable systems, interactions, and debugging.

  • Scene creation
  • TileMaps
  • Animation systems
  • Collision systems
  • Platforming
  • Top-down systems
  • Combat systems
  • UI systems

The Anti-Lesson: Refactoring a Bad Project

One of the more unusual assignments I developed was intentionally designed around bad software architecture. Instead of only showing students what good code looks like, the project gives them a deliberately flawed game and asks them to identify and repair its problems.

Students examine giant scripts, hardcoded references, duplicated logic, poor scalability, and other architectural problems. They then refactor the project into a more maintainable structure.

Why Teach Through a Broken Project?

Real software engineering rarely involves building everything from scratch. Developers frequently inherit existing codebases, identify problems, and gradually improve systems. The anti-lesson introduces students to that reality earlier in their education.

View the Bad Project on GitHub →

Incomplete Quest: Working Inside an Existing Codebase

Another assignment focuses on a partially completed project. Instead of creating everything themselves, students enter an existing codebase and finish missing systems.

Students complete player systems, bug systems, NPC interactions, door systems, UI systems, and GameManager integration.

Professional Development Through Game Development

This assignment addresses a skill that is especially important outside of the classroom: the ability to understand and modify software that someone else has already written.

Working inside an existing codebase gives students experience that more closely resembles collaborative development and professional software environments.

View the Quest Assignment on GitHub →

Collaborative Final Project

The final stage of the curriculum brings the individual systems together into a larger collaborative game project. Students combine the concepts introduced throughout the earlier assignments and begin working with a larger software architecture.

The goal is not simply to produce a finished game. The final project requires students to think about how multiple systems communicate and how a growing codebase can remain organized.

View the Final Project Framework on GitHub →

The Personal Game Prototype

The curriculum was also informed by my own experience developing a game prototype. The original prototype included movement, rolling, combat, bug catching, bosses, doors, progression systems, UI systems, and exploration mechanics.

While developing the prototype, I encountered architectural problems that later inspired the anti-lesson assignment. This became an important part of the study because the curriculum was not designed entirely theoretically. Problems encountered during actual development directly influenced how I approached teaching software architecture.

From Building Games to Teaching Game Development

One of the biggest shifts during the independent study was realizing that my own development mistakes could become educational material. Instead of hiding architectural problems, I could turn them into exercises that teach students why certain approaches fail.

Technical Skills Developed

The independent study helped me develop skills across both software engineering and educational design.

Software Architecture

Modularity Inheritance Separation of Concerns Scene Architecture

Debugging and Systems

Signals Collision Systems Scene References Debugging

Curriculum and Educational Design

Assignment Scaffolding Pacing Difficulty Design Assessment Technical Communication

Challenges

Designing the curriculum required balancing several competing goals. Game development naturally encourages creativity and experimentation, while a computer science course needs to maintain technical rigor.

Some of the biggest challenges involved determining the appropriate difficulty for each assignment, ensuring projects remained achievable, and figuring out how to intentionally teach debugging rather than treating it as something students would simply discover on their own.

The Central Design Problem

How do you give students enough freedom to be creative while still ensuring that every project reinforces meaningful computer science concepts?

Final Deliverables

By the end of the study, the project had developed into a substantial collection of curriculum materials and working prototypes.

Final Reflection

This study began as an exploration of game development education. It evolved into designing a full curriculum that teaches computer science principles through interactive systems.

I created a framework that helps students understand architecture, debugging, modular design, event systems, collaboration, and iterative development through projects that they can actually interact with and modify.

The experience also reinforced an important connection between computer science and game development. A game is ultimately a collection of interacting software systems. Movement, enemies, dialogue, UI, state transitions, input, and progression all require the same kinds of computational thinking that appear throughout computer science.

My goal going forward is to continue developing these ideas through Godot and other engines while exploring how the same foundational concepts can transfer across development environments. The work could realistically be adapted into an actual introductory game development course and provides a foundation for continuing to experiment with interactive computer science education.

Acknowledgements

This independent study was completed with Professor Toby Dragon at Ithaca College during Spring 2026. The project combined academic research, curriculum development, game programming, prototyping, debugging, and educational design.

The independent study's final report, Designing a Foundational Computer Science Game Development Curriculum, documents the research, assignments, prototypes, and curriculum framework developed throughout the project.