CSC 1001 — Final Project

Inherited Code: Rescue Mission

Project Philosophy

This project is not "build something impressive from scratch." It is "join a team, inherit someone else's unfinished code, and make it better." That is the software engineering experience this course has been building toward: reading other people's code, tracing and debugging it, using AI agents against structured requirements, and collaborating through disagreement — not writing flawless Python solo.

Every team receives the identical starter codebase on Canvas. Nobody on the team wrote it. Everyone starts as an outsider to it. Grading rewards process — comprehension, collaboration, and documented decision-making — over a polished final program.

The Starter Codebase

You will be given a working text adventure ("Rescue Mission"): a player explores rooms of a derelict station to find a shut-down robot. It runs — but it was clearly written under time pressure, and not everything in it works the way a player would expect.

FilePurpose
main.pyGame loop, entry point
world.pyRoom definitions & exits
player.pyInventory & health
items.pyItem descriptions & the door lock
commands.pyParses what the player types

Somewhere across these five files: 3 bugs, 1 feature that was started but never finished, and 1 command a player would reasonably expect that doesn't exist yet. No file is guaranteed to be clean just because it isn't obviously broken. Finding these is part of the assignment — trace the code and play the game before you touch anything.

Everyone on the team gets an identical copy. What happens to it from here is up to your team — and no two teams will finish with the same program.

Team Roles: Rotate, Don't Assign

Instead of locking one person into "the debugger" and another into "the writer" for three weeks, roles rotate every work session so each person practices each mode of working. This is deliberate — it's your mechanism for making sure quieter teammates end up driving and typing, and for keeping any one person from quietly doing everything.

RoleResponsibility this sessionRotates to →
DriverTypes and runs the code; tests hypotheses out loudNavigator next session
NavigatorReads code aloud, explains what they think it does, catches mistakesScribe next session
ScribeKeeps the shared team log: what we think this does, what's broken, open questions, decisions madeDriver next session

The Scribe log is a running document, not an afterthought — it is what makes the forced handoff (below) possible, and it is graded as evidence of collaboration. You will have to submit this.

Required Work

Every team must complete all of the following. This baseline is what makes teams comparable at grading time even though their added features will differ.

Required AI-Agent Feature

This is the course's AI-agent learning outcome in action: you are not asking an AI to "write the game," you are handing it a structured spec and evaluating what comes back. As a team, fill out the spec card below for one new room, puzzle, or NPC interaction, then have one teammate use an AI agent to implement it against that exact spec.

Spec fieldYour team fills this in
Feature name
Where it lives (room/file)
Inputs (what the player can do/type)
Expected behavior / output
Constraints (must not break existing rooms/items)
Test cases it must pass

After the AI agent produces code: critique it against the spec, run it, and revise manually. Your README (below) records what the AI suggested, what you accepted, what you rejected, and why.

Added Feature Menu - Pick Two

Pick two. Different teams choosing different pairs is intentional — it means no team finishes with an identical program, and it means at your demo, someone on the team will genuinely be the only person who understands a given feature.

DifficultyFeatureNotes
EasyInventory display polish (show item descriptions, not just names)Good first added feature
EasyConfirmation messages (e.g., "You already have that.")Low risk, good for the forced-handoff exercise
MediumScoring/turn counterAdds new logic to the main game loop
MediumA second locked door with a different key/conditionReuses the game's existing lock-and-key mechanism
HardSave/load game state to a fileTies directly to the File I/O unit — recommended if your team is comfortable with dictionaries

Timeline (Weeks 13–15, ~15 hours/student)

Note on scheduling: Week 13 falls on Thanksgiving week and meets only once (lecture, no lab), so Week 13 work is solo only. Week 14's lab devotes 2 hours of in-class time to this project — enough for the team to sync up and take a first pass at the bugs together. Everything after that — finishing the fixes, the AI-agent feature, the forced handoff, merging, final integration, and demo prep — happens outside of class, on the team's own time. The only other in-class time is the Week 15 demo itself, which happens in lab, not lecture.

WeekSessionWhat happensHours
13In class (lecture only)Cold handoff — no walkthrough from the instructor. Read the codebase individually; note first impressions.1
13 or 14 (in class)Code Mapping (solo, async — see separate assignment)Each student writes a plain-English "code map" of one assigned file: what it does, what's unclear, what looks broken. Use an AI agent to help decode unfamiliar syntax only — no fixing yet.2
14 (in lab)Team syncCompare code maps, sketch a state/flow diagram of the current game, confirm what's actually broken, choose your 2 added features.1
14 (in lab)Team workFirst pass on the required bug fixes, Driver/Navigator/Scribe roles rotating.1
Outside class, before Week 15 labTeam workFinish required bug fixes and the unfinished feature.1.5
Outside class, before Week 15 labAI-agent sessionFill out the feature spec card; one teammate runs it through an AI agent; team critiques, tests, and revises the result together.2
Outside class, before Week 15 labForced handoff (solo, staggered)Set aside your own piece. Pick up a teammate's unfinished piece and extend or test it, using only what's in the shared Scribe log — no explanation from the owner.1.5
Outside class, before Week 15 labMergeBring every piece back together; resolve conflicts and duplicated fixes.2
Outside class, before Week 15 labIntegrationFinal integration testing across all merged features.1
Outside class, before Week 15 labPrepPrepare the demo and finish the README and dev log. Decide who presents which teammate's feature.1
15 (in lab)DemoPresent and submit.1

Week 13: 3 hrs · Week 14 lab: 2 hrs · Outside-class team window: 9 hrs · Week 15 lab: 1 hr — 15 hrs total, unchanged from the original plan.

Deliverables

Grading (Process Over Polish)

CategoryWeightWhat this looks for
Team collaboration30%Scribe log quality, evidence of role rotation, evidence the team planned before coding
Code comprehension & documentation20%README clarity; accuracy when explaining a teammate's feature at the demo
Completed features25%Required fixes + AI-agent feature + 2 chosen features all functioning
Testing & debugging15%Evidence of test cases, including normal and edge-case inputs
Reflection10%Individual reflection quality and honesty

Notice collaboration and comprehension together outweigh raw feature count (50% vs. 25%). A team that deeply understands and clearly documents a smaller working program should outscore a team that bolted on every feature without anyone being able to explain how it works.