🎮 Sprint 6 Engineering Portfolio

Author: Anika Seksaria | Role: Scrummer | Sprint: 6 Course: Mira Costa CS. 111

Page	What’s Inside	Link
🏠 Main Page	SDLC, OOP Rubric, Engineering Practices	You are here
📝 Homework Lessons	All assignments mapped to rubric	Open Hub
🏰 FA1 & FA2	SkyKingdom + Interaction Design	Open
🐺 Red Riding Hood	Final Project — Full Engine Architecture	Open

🛠️ Software Engineering Practices

Planning & Agile Workflow

As Scrummer, I showcased various skills across CSSE 1 and 2:

Tracking: Maintained a Kanban board to ensure the team hit weekly milestones on time
Scope Management: Revised sprint plans to prioritize fixing core collision and level transition bugs before adding new features
Documentation: Wrote comic-style comments on major methods to explain logic

Software Development Lifecycle (SDLC)

Phase	What I Did
Source Control	Committed only after verifying each change worked locally
Forking	Maintained a fork of the instructor repo with regular upstream syncs
Branching	Isolated `level-transition` and `npc-reaction` into separate branches
Testing	Ran test builds on localhost before every push
Pull Requests	Submitted selective PRs to the instructor fork for grading
Deployment	Final build deployed via GitHub Pages

Retrospective Engineering

Live Reviews: submitted SkyKingdom and Red Riding Hood for reflection
Code Reviews: Found and fixed collision positions
Revising Plans: Updated speed of Red Riding Hood after feedback

🏗️ OOP Evidence

Inheritance Hierarchy

GameObject        ← Level 1: shared position and draw logic
  └── Character   ← Level 2: adds movement and gravity
        ├── Player  ← Level 3: handles user keyboard input
        └── Wolf    ← Level 3: handles hostile logic

Classes & Constructor Chaining

class Wolf extends Character {
    constructor(data, gameEnv) {
        super(data, gameEnv);  // passes setup data to parent class
        this.type = "Wolf";
        this.isHostile = true; // boolean flag
    }

    handleCollision(other, direction) { // 2 parameters
        if (other instanceof Player) {       // condition
            if (this.distanceTo(other) < 50) { // nested condition
                this.reaction("hostile");
            }
        }
    }

    update() {
        super.update(); // calls parent update, then adds wolf behavior
        this.checkProximity();
    }
}

OOP Checklist

Requirement	Evidence	✅
2+ custom classes	`Player`, `Wolf` both extend `Character`	✅
Methods with 2+ params	`handleCollision(other, direction)`	✅
3-level inheritance	`GameObject → Character → Player/Wolf`	✅
Method overriding	`update()`, `draw()`, `handleCollision()`	✅
Constructor chaining	`super(data, gameEnv)` in all subclasses	✅

🔢 Data Types, Operators & Control Structures

Data Types

Type	Example	Where Used
`Number`	`velocity: 3`	Physics and movement
`String`	`"hostile"`	NPC state and sprite paths
`Boolean`	`isPaused: true`	Game loop control flags
`Array`	`gameObjects[]`	Collection of sprites used
`JSON Object`	`{ hitbox: { width: 40 } }`	NPC configuration

Operators

// Mathematical — movement physics
this.x += this.velocity;

// String — building sprite file paths
const path = `${baseUrl}/assets/${this.name}.png`;

// Boolean expression — compound condition
if (this.isColliding && !this.isPaused) {
    this.handleCollision(other, direction);
}

Control Structures

// Iteration — update every object each frame
gameObjects.forEach(obj => {
    obj.update();
    obj.draw();
});

// Nested conditions — NPC reaction logic
if (other.type === "Player") {
    if (this.distanceTo(other) < 50) {
        this.reaction("hostile");
    }
}

📝 Retrospective: CSSE Progression

Project Management Background

My introduction to project management started in CSSE 1 with the Haunted Mansion Game prototype, where I worked with Sophie, Niha, Adya, and Salma. I learned Agile and Scrum coordination on VSCode, which built the workflow foundation I used throughout Sprint 6.

Sprint 6 Technical Growth

This sprint moved me from simple class-based prototypes into the full OCS GameEngine. I used GameBuilder to build my formatives and applied CS 111 concept — data types, control structures, OOP, and SDLC in projects. CSSE 1 and 2 have been my foundation as I move toward AP Computer Science Principles.

Anika Seksaria · CSSE Sprint 6 · Spring 2026 · Mira Costa CS 111

CS111 Review 1: Sprint 6 Final Portfolio