CS105 (Spring 2025) Final Project

Overview

The final project for this course consists of writing a piece of software that makes use of several concepts and techniques learned throughout the course and requires that students synthesize them in a creative (and hopefully fun) way. Final projects will be completed in groups of 2-3 students. For the final project, students may complete the default project (described below) or design their own project, with approval by the deadline.

Deliverables

Students will give a presentation and demonstration of their project on the last week of class. This presentation must be uploaded to Moodle. (The time limit for the presentation will be determined after the total number of groups has been determined). Students who fulfill the requirements by the last day of class have nothing more to do except upload their documents to Moodle.
Students will upload a zip or tar.gz file with all of the files necessary to run their code to Moodle. Students will have until the last final exam date to fix any problems that weren't resolved by the last day of class. When these are completed, students should notify the professor.
Students should submit the following to Moodle:
- Their code (explained above).
- A short report as a PDF with the following:
  - Group members and what each group member contributed.
  - How the project fulfilled the requirements for the point total.
  - How to run the code.
For students who did not finish by the final day of class: a 5-minute-or-less video by the final exam date, uploaded to Moodle, with an updated presentation demonstrating how they obtained points for the assignment and what they fixed (or what they tried if they weren't able to complete everything). Students who do not submit this in time may not receive credit for the changes they made.

Default Project

The default project consists of creating a game in the style of Zork, a text-based adventure game created in 1977, which has influenced countless subsequent games. You can play Zork here. In Zork and similar games, the player navigates around an environment by typing text commands, interacts with the environment, and progresses the story. This project is worth 100 points, but students may accumulate these points in many different ways by completing various parts of the assignment. The program must be written in Python 3. The project is worth 100 points, but skipping the presentation will result in a 25% reduction in score.

The parts of the project marked Required must be completed by everyone who does this project; students can choose which of the others they implement, and students may suggest additions not listed here (with approval) as alternate ways of accumulating points.

Required: Load maps from files (20 pts)

One way to represent a map is with two-dimensional grid. These grids can be stored in one or more plain text files and loaded and thus not require hand-coding inside of the program. For example:

def load_map(filename: str) -> List[List[int]]

Or, if you use classes,

def load_map(filename: str) -> GameMap

Inside of, for example, map1.txt, you might have something like this:

When I read this file into my code, it tells me how large the 2D map array should be (in this case, 7 $\times$ 7). In this example, the 0's represent "walls," where the character cannot travel. The 1's represent paths where the user can walk, and the 2 represents the end state. This is essentially just a maze. Your maps can be as large as you like. They can be conveniently stored in a multidimensional/nested list or dictionary. You can design your mazes in any text editor, and in the game they will be loaded at the appropriate time (for example, if the player reaches the goal in map 1, they would be taken to map 2). You should have at least 3 maps.

Required: Implement movement functions (20 pts)

"""
Returns current player location as an (x,y) tuple.
"""
def getCurrentLocation() -> tuple 

"""
Takes player to new location. Returns True if successful, false otherwise
"""
def setLocation(x: int, y: int) -> bool 

def goalReached() -> bool
def canGoNorth() -> bool
def canGoSouth() -> bool
def canGoEast() -> bool
def canGoWest() -> bool
def goNorth() 
def goSouth() 
def goEast() 
def goWest()

Required: Progressive Map (20 pts)

Often, in games, a map showing where the user has already traveled is displayed to the user in an easily understandable format. Implement this. For example, if the user types print map, a map could be displayed. Alternatively, the map could be always displayed.

Implement a graphical user interface (20 pts)

Use either the blessed or asciimatics Python library to implement a terminal user interface (TUI) and implement one of the following:

Show a persistent map. Rather than show a text-based map, create a graphical map in a window that updates as the user moves around the map.
Show graphical representations of events in the game, such as encountering an enemy.

Implement "battles" or other challenges (20 pts)

Include either random battles or persistent enemies located in the environment, in which the user must make decisions about how to respond to proceed. This will require some kind of subroutine.

Generate random mazes (20 points)

Implement and integrate random, solvable mazes of a specified size (e.g., 50x20) into the game.

Implement game saving and loading (10 pts)

Allow the player to save a game to a file or load it from a file to continue where they left off. At startup, give the option to start a new game or load one from the saved games.

Add graphics (10 pts)

This is separate from the graphical user interface. Incorporate graphical and color elements into the game.

Harder: Make the game real-time (20 pts)

Incorporate a timer in a way that allows enemies or other obstacles in the game to move around in real time, such that the user must act quickly to avoid them. Doing this would also require implementing the GUI (described above)

If using blessed, see:
- keyboard input
- Worms and Snake examples
A more general Python way of accomplishing this is to use time.sleep() inside of the game loop.

Harder: Implement an alternate user interface (20 pts)

This requires implementing the graphical user interface (described above). Implement keyboard navigation in a way that does not require typing in commands directly, instead using, for example arrow keys that allow real-time navigation and immediately updates the screen.

Custom Project (proposal due by Friday, March 21)

Students who want to design their own project have two options:

For an equivalent number of points, they can propose to swap out some aspect of the default project for something they'd rather do (pending approval). There is no hard deadline for this.
They can propose an entirely different project by Friday, March 21.

Acknowledgements

Materials by Alvin Grissom II.