Mockup made with REXPaint; hero (@) is next to landslide with live big monster (M), dead small monster (m), and a potion (¡)

Introduction

In Trapped in Time (working title), an amnesiac hero must escape from a perilous dungeon, armed only with his wits and a mysterious watch capable of traveling through time. The game is designed for desktop as a single-player roguelike with retro sprite and ASCII graphics. With permadeath, a character progression system, and carefully-crafted levels, Trapped in Time offers a “live fast, die fast” experience designed for players of different skill levels through quick play sessions.

Game

Game Concept

The team members each selected a single game mechanic, and then focused on combining them into a potential game concept. After coming up with a solid game idea, it was then refined to fit within the scope of the course. The process can be seen below, as various game mechanics were iterated on to come up with the final concept:

• Roguelike + progression + key/locked door
• Roguelike + progression + key on monster/locked door
  • Monster ecosystem?
• Roguelike + progression + key/locked door + time-travel
  • Generate rooms Binding-of-Isaac-style? Save rooms for reuse through time manipulation?
  • “Dumb” form of time travel implementation? (Local time manipulation of things; no timelines)
  • Hostile AI with time manipulation too?
• Roguelike + progression + locked door + time-travel to other timelines

Ultimately, the team decided on a roguelike with some form of progression system and time travel. The goal would be to escape through each floor’s locked door and ultimately, escape the dungeon.

Story/Setting

The team then used the game concept to find the game’s story and setting (listed below). It was decided at this point in time to keep most of the details open, in case the team later came up with something better suited to a specific theme. This flexibility was only possible thanks to the game’s roguelike genre.

• Concept: Hero wakes in monster-filled dungeon, and traverses timelines to escape.
• Setting/Location: Low-key fantasy/science-fiction (could be either or neither) in a “dungeon”.
• Story: Hero wakes up in an underground facility with amnesia. He possesses a mysterious watch that enables him to travel to other timelines. As he progresses, they learn more about the watch and use it to break out of a facility filled with enemies.

Genre

A roguelike is a (sub)genre of game dating back to the 1980s, when Rogue was released. Today, the genre features in many games, both as a genre and subgenre, with the purely-genred games ranging from old-school roguelikes (e.g., NetHack) to new “roguelites” which relax some of the genre’s rules in favor of a more “modern” experience (e.g., Rogue Legacy). In general, roguelikes have features like the ones listed below.

• Permadeath: When the player dies, the game ends. There is no “reload from the last save point to try again”. Progress also does not carry over between games for future advantages. As many roguelikes are also very difficult, this feature can lead to the loss of hours or days of gameplay, which makes it a feature more appealing to more “hardcore” gamers.
• Procedural generation: Map layouts are generated randomly. While certain general details might be the same (e.g., “forest”-type maps have wolf enemies), the specific arrangement differs between playthroughs. Some games also remix item descriptions, resulting in a “red bubbling” potion healing in one playthrough and harming in another.
• Turn-based combat: Fighting occurs in a discrete, rather than continuous, manner. The player can take anywhere from one second to several hours real-time to make a move. However, actions in the game still use a turn-based system, with one character acting after another, rather than acting simultaneously. Many games use speed/time-based turn systems, resulting in a fast thief acting before a slow ogre.
• Spatial consistency: Combat and exploration occur on the same screen, rather than using a separate screen (e.g., Pokemon) or mode (e.g., Chrono Trigger) dedicated to combat. Players can fight, sleep, and often even shop in the same map (though some games separate shopping because of buying/selling). The map is depicted as a grid of equally-sized cells, each of which can fit one mouse as easily as one dragon.
• ASCII/simple 2D graphics: Many roguelikes feature “retro” graphics in the form of ASCII characters, where a red “D” might be a fire dragon or a demon, or 2D sprites, which offer more individual detail but still tend to be much smaller than modern sprite sizes. The former is particularly easy to implement and extend, as the most popular set of ASCII characters uses Code Page 437, with many available fonts free for use.

Trapped in Time is designed around the classic roguelike features listed above. As a “coffeebreak” roguelike designed for short play times, permadeath is not devastating, since the player can quickly progress to the previous game’s (equivalent) floor. The relatively light consequences for failure also encourages newer players to try the game (even if they are unfamiliar with roguelikes), while the nature of permadeath keeps veterans from becoming complacent. Procedural generation helps to keep gameplay fresh, though the emphasis on map “depth” (i.e., timelines) will likely also utilize hand-crafted map components to increase variety. Combat and exploration occur on the same map, one turn at a time. Finally, using ASCII and simple sprites allows offers retro aesthetics and high map legibility.

Gameplay

In Trapped in Time, the player controls the amnesiac hero, guiding him through the dungeon and fighting (or avoiding) monsters along the way. The player views the world in standard roguelike top-down view, centered around the hero in 360° vision.

The player is tasked with navigating a hostile, maze-like environment to reach higher dungeon floors, and eventually escape by reaching the surface. Along the way, they will encounter various challenges in the way between them and victory (listed below).

Challenges:

• Monsters: Killing monsters gives experience points for leveling. However, some monsters are too dangerous to fight and must be avoided.
• Obstacles: Obstacles prevent free movement through the map; navigation through timelines is the only way to bypass them.
• Items: While not all items are bad, some have detrimental effects, and should therefore be avoided by the player. Many items are also protected by their placement, due to nearby monsters or obstacles.
• Stairs: They are placed somewhere in the floor, and the player must overcome other challenges to reach them.

Victory conditions:

• Ascend to higher dungeon levels by using stairs
• Escape dungeon by ascending to surface

Game Mechanics

There are two major game mechanics in Trapped in Time: time travel and character progression. Time travel is used to move throughout the map, while character progression allows the player to survive and kill increasingly powerful monsters. Character progression works through two methods: leveling up and using items.

Time travel:

• The player can travel to different “timelines” to bypass obstacles and avoid monsters
  • Controlled through number keys (1-9)
  • One of these “timelines” has the correct path around the obstacle (e.g., a locked door may be open in another timeline)
  • As the player gets closer to the surface, the number of accessible timelines increases from the initial two timelines, making navigation longer and more difficult

Character progression:

1. Level-up system: Experience points are earned through killing monsters, allowing the hero to level up. The player has the choice of increasing one of a few stats upon leveling (e.g., Strength, Defense).
2. Items: Some items increase stats (e.g., “Potion of Strength”).

Technical Details

Trapped in Time will be programmed in Python 3 with tcod, which is a library for roguelike development (e.g. virtual console, keybinds, field-of-view calculation).  As an offline single-player game, Trapped in Time has minimal system requirements (listed below).

System requirements:

• Desktop operating system (Linux, Mac, and Windows) with Python 3 installed: For running the game.
• Keyboard: For playing the game.
• Computer monitor: For displaying the game.

Project Goals

Team and Project Timeline

The team is comprised of one IST major and three ME majors, with only the IST major possessing any prior experience with game design and programming in Python. Deadlines for project goals have been chosen with this lack of experience in mind, and are therefore designed around completing a basic proof of concept, followed by optional “bonus” goals to be completed if any extra time is available. No specific team members are explicitly assigned at this point in time, as many of the parts of the game were ultimately refined by multiple people.

Project timeline:

1. (March 11) Get familiar with language/library: player walking around
   1. (March 11) Set up GitHub and coding standards
2. (March 18) Implement core mechanic and basic two-timeline floor: player time-traveling
   1. (March 25) Implement win condition
3. (March 25) Implement combat: player fighting/killing/dying to monster
   1. (April 1) Implement lose condition
   2. (April 8) Implement leveling/items/stats
4. (April 15 or so, depending on state of BONUS goals) Final testing, documentation, and packaging of demo for public release
5. (BONUS) Implement procedural level generation, multiple levels
6. (BONUS) Implement 2D sprites
7. (BONUS) Implement main menu
   1. (BONUS) Implement save/load system

Peer Reviews

Peer reviews by fellow students was generally positive. The in-class presentation was praised for its attention to detail. The game concept itself was well-received, between the mystery inherent in the story and the time-travel mechanic placed in an otherwise “classic” roguelike. One student compared the game to Radiant Historia and The Legend of Zelda: Ocarina of Time, which are both video games that prominently feature time travel.

Other students had questions or concerns about the game, such as the apparent lack of graphics in the mockup. While the basic demo is designed for only ASCII characters (as is common for classic roguelikes), the tcod library offers an easy way to add simple sprites to the game. Another benefit of using extremely simple graphics and turn-based gameplay is a smooth and stable framerate, as the game requires an extremely light amount of system resources.

Another student wanted to know about alternative methods of gaining experience. Unfortunately, preliminary research suggests that receiving experience for successfully fleeing from monsters would require careful design and balancing, placing it outside of the demo’s scope. Similarly, the complications caused by time-traveling to the past/future (as mentioned by a different student) are mitigated by limiting the demo to alternate timelines, thereby removing cause and effect altogether.

Hero and monster names are to be determined in the future, but will probably use theme-appropriate placeholder names. The average length and difficulty of a single “run” of the game, as experienced by newbies and veterans cannot be determined in the demo, and is intended to be assessed in a later phase of development.

Flowchart

The flowchart below illustrates gameplay for a completed demo of Trapped in Time with all bonus goals met.