Computer Science & Software Engineering

Course Progress 0/0
Week 19 Sprint 6 - CSSE Objectives (Final)

Sprint 6 - CSSE Objectives (Final)

6 min read

Final Project

This Final Project demonstrates your introduction to Computer Science, JavaScript, and Object-Oriented Programming. By building a game, you will apply programming fundamentals and explore the impacts of computing through a topic of personal and social relevance (gaming).

  • Software Engineering Practices: Planning changes, checklists, burndowns, coding with comments, creating mini-lesson/comic style documentation
  • Software Development Lifecycle Practices: Source control, forking, branching, building, testing and verification, pull requests, merging/integrating, deployment
  • Retrospective Engineering Practices: Presentation, live reviews, demos, code reviews, revising plans
  • Data Types: Numbers, strings, booleans, arrays, JSON objects
  • Operators: String operations, mathematical operations, boolean expressions
  • Control Structures: Iteration, conditions, nested conditions
  • Input/Output: Canvas rendering, keyboard event handlers, GameEnv configuration, API calls (Leaderboard/NPC AI)
  • Classes: Extending base classes (Character, Enemy, Platform, Background), overriding lifecycle methods (update(), draw(), handleCollision()), constructor chaining with super(data, gameEnv)
  • Coding Practices:
    • Single Responsibility Principle (methods like update(), draw(), handleCollision(), callbacks)
    • Data-Driven Design (GameBuilder with Object Literals to initialize game objects)
    • Object-Oriented Programming (GameObject base class, inheritance hierarchies)
    • State Management (game loop states, pause conditions, level transitions)
  • Resources: OCS GameEngine, GameBuilder

Mira Costa College

This project and course prepare you for college credit and future Computer Science pathways.

For those that wish to pursue Computer Science this starts you on Math and CS Pathway

CS 111 Course Alignment Rubric

Required Evidence for College Credit

Students must demonstrate competency in all CS 111 learning objectives through their game project. Below is the alignment between CS 111 requirements and project deliverables.

Learning Objective Project Evidence Required Assessment Method
Object-Oriented Programming    
Writing Classes Create minimum 2 custom character classes extending base classes Code review: Player.js, NPC.js, Enemy.js,
Methods & Parameters Implement methods with parameters (e.g., collisionHandler(other, direction)) Code review: Method signatures with 2+ parameters
Instantiation & Objects Instantiate game objects in GameLevel configuration Code review: GameLevel setup objects
Inheritance (Basic) Create class hierarchy with 2+ levels (e.g., GameObject → Character → Player) Code review: extends keyword, inheritance chain
Method Overriding Override parent methods (update(), draw(), handleCollision()) Code review: Polymorphic implementations
Constructor Chaining Use super() to chain constructors Code review: super(data, gameEnv) calls
Control Structures    
Iteration Use loops for game object arrays, animation frames Code review: for, forEach, while loops
Conditionals Implement collision detection, state transitions Code review: if/else, nested conditions
Nested Conditions Complex game logic (e.g., power-up + collision + direction) Code review: Multi-level conditionals
Data Types    
Numbers Position, velocity, score tracking Code review: Numeric properties
Strings Character names, sprite paths, game states Code review: String manipulation
Booleans Flags (isJumping, isPaused, isVulnerable) Code review: Boolean logic
Arrays Game object collections, level data Code review: Array operations
Objects (JSON) Configuration objects, sprite data Code review: Object literals
Operators    
Mathematical Physics calculations (gravity, velocity, collision) Code review: +, -, *, / in physics
String Operations Path concatenation, text display Code review: Template literals, concatenation
Boolean Expressions Compound conditions in game logic Code review: &&, ||, !
Input/Output    
Keyboard Input Arrow keys, space, WASD controls using event listeners Testing: Key event handlers respond correctly
Canvas Rendering Draw sprites, backgrounds, platforms using Canvas API Code review: draw() method implementations
GameEnv Configuration Set canvas size, difficulty levels, game settings Code review: GameEnv.create() and GameSetup.js
API Integration Implement Leaderboard API (POST/GET scores) Code review: Fetch calls with error handling
Asynchronous I/O Use async/await or promises for API calls Code review: async/await or .then() chains
JSON Parsing Parse API responses (leaderboard data, AI responses) Code review: JSON.parse(), object destructuring
Documentation    
Code Comments JSDoc comments for classes and methods Code review: Comment density >10%
Mini-Lesson Documentation Create comic/visual post with embedded runtime game demo Portfolio review: Mini-lesson in personal portfolio
Code Highlights Annotate key code snippets in documentation (OOP, APIs, collision) Portfolio review: Highlighted code examples with explanations
Debugging    
Console Debugging Use console.log to track game state, variables, method calls Code review: Strategic logging in update/collision methods
Hit Box Visualization Draw/visualize collision boundaries to refine detection Demo: Toggle hit box display, adjust collision rectangles
Source-Level Debugging Set breakpoints in DevTools, step through code execution Demo: Use Sources tab to pause and inspect code flow
Network Debugging Examine Network tab for API calls, CORS errors, response status Demo: Inspect fetch requests, response data, error messages
Application Debugging Examine cookies, localStorage, session data for login/state Demo: Application tab inspection of stored data
Element Inspection Use Element Viewer to inspect canvas, DOM elements, styles Demo: Inspect element properties and game object state
Testing & Verification    
Gameplay Testing Test level completion, character interactions, collision detection Live demo: Play through level without critical bugs
Integration Testing Test API integration (Leaderboard, NPC AI) with live backend Demo: Successful score saving and AI responses
API Error Handling Try/catch blocks for API calls, network error handling Code review: Error handling for fetch failures

Grading Scale

A (90-100%): Demonstrates mastery of objectives with creative implementation B (80-89%): Meets all CS 111 required objectives with solid understanding

  • ✅ 2+ custom character classes extending base classes (Character, Enemy, or NPC)
  • ✅ 5+ methods with parameters and return values (override update(), draw(), handleCollision(), etc.)
  • ✅ GameLevel configuration using Object Literals to instantiate game objects
  • ✅ JSDoc comments on custom classes and methods (>10% comment density)
  • ✅ API Integration: Leaderboard (POST/GET scores) + NPC AI interaction with error handling
  • ✅ Debugging competency: Use DevTools (Console, Network, Application, Sources) to debug game logic, APIs, and login/state
  • ✅ Mini-lesson documentation in personal portfolio (comic/visual style with embedded runtime demo)
  • ✅ Code highlights showing OOP hierarchy, API calls, collision logic, and state management
  • ✅ Complete, playable custom level tested in GameBuilder and team repository

Schedule

The Final Project will be completed in the last sprint.

CSSE 1 (Trimester 1, Weeks 1-12, Sprints 1-3)

  • Fundamental learning and Engineering Practices
  • All classroom prototype game, due at the end of week 12

CSSE 2 (Trimester 2, Week 13-24, Sprints 4-6)

Project Planning (Weeks 13-16, Sprint 4)

During the planning weeks build individual and group skills.

Individual Portfolio - Create a comic/visual style blog post in your personal portfolio using GameRunner notebook.

  • Embeds a runtime demo of your game feature
  • Highlights and explains key code pieces (classes, methods, APIs)
  • Demonstrates your expertise area with annotated examples

Mini-Lesson - Develop instruction on how to enhance the game:

  • Create a lesson to teach group level expertise topics, groups of 3
  • Submit PRs for instructional level(s) and notebooks/posts

Project Teaching/Homework (Weeks 17,18, Sprint 5)

Individual Portfolio Due (Beginning of Sprint 5):

  • Project expertise, plans, code, and retrospective memories/help system
  • Blogs on homework created and technical topics learned

Group Teaching/Demonstration

  • Teach Lesson on expertise topics, groups of 3
  • Assign homework for students to add expertise topics to their game
  • Grade student homework

Project Development (Weeks 19-24, Sprint 6)

Development weeks focus on building your project. You should:

  • Set and achieve at least one milestone per sprint
  • Continue the iterative cycle of development
  • Integrate features into your team’s custom game

Finals Week -1

  • Wednesday: Demo your team’s custom level to the teacher
  • Thursday: N@tM (Night at the Museum) showcase at 6pm

Finals Week

  • Instructor completes final grading using college articulation guidelines, your blog, code, and analytics

Course Timeline