"Work from home" is an interactive storytelling game where players take on the role of the protagonist in a dynamic narrative. The game can be played in the console or in a virtual console in the web-browser. The game is centered around your first remote office day, where every choice you make influences the storyline and leads to different outcomes. Try to find as many endings as possible.

Read below to learn how to deploy the game youself or check out the live-site.

• Technologies Used
  • Languages Used
  • Frameworks, Libraries & Programs Used
• User Experience
  • Target Audience
  • User stories
    • As a New Player:
      • I want clear instructions on how to make choices
      • I want a straightforward and intuitive interface
    • For the game play:
      • I want a compelling and immersive narrative
      • I want my choices to have significant consequences
      • I want to see the immediate and long-term effects of my decisions
      • I want to know how many possible endings there are
      • I want to know how many endings I have found
• Design
  • Story and Inspiration
  • Flowchart
  • Gameplay
  • questionary
  • story telling experience
• Features
  • Existing Features
    • start screen
    • Deleting the current score
    • End the Game
    • Entering a name
    • Story, Chosing an answer
    • Finding an ending
    • SpreadSheet
  • Possible Future Features
    • Accessibility
    • Easier Replay
    • Multiple Accounts
• Testing
  • Validator Testing
    • Lighthouse
    • PEP8
  • Manual Testing
    • Name Input
    • Level Design
    • Delete Score
    • Exit Game
    • Restart or Exit Game after ending is found
  • Unfixed Bugs
    • User input while slow text
  • Fixed Bugs
    • "Inventory takes 1 argument, but 2 were given"
    • "level12() missing 1 requirement positional argument: 'player'""
• Dependencies
• Deployment
  • Local Development
    • How to Clone
    • How to Fork
  • Deployment using Heroku
• Credits

• GitHub – code storage
• Sublime Text - Editor
• Heroku - Deployment

Python (HTML and JavaScript from deployment template)

Github (NodeJS from deployment template)

The taget audience are people who enjoy interactive storytelling and decision-based games. Due to the content of the story I advice a minumum age of 14 years to play along. This game can be played as a casual gamer, who prefer games that can be played in shorter sessions and do not require a significant time commitment, or excessively to find all possible endings.

• So that I can navigate the story easily, even if I'm not familiar with console-based games.

• So that I can easily navigate the game without complex controls.

• So that I can feel engaged and invested in the story.

• So that my decisions feel impactful and meaningful.

• So that I can learn from my choices and adapt my strategy accordingly.

• So that I can strive to experience every outcome and complete the game fully.

• So that I can be happy about my achivement.

In creating the game, my aim was to craft a narrative that starts with a familiar scenario, gradually evolving into an increasingly intricate fantasy realm that rapidly intensifies in complexity and imagination. I took inspiration from Choose Your Own Adventure Books where the palyer is "making choices that determine the main character's actions and the plot's outcome", as well as the indie game "Papers, Please". "The game has a scripted story mode with twenty possible endings depending on the player's actions"

One of the most challenging aspects was maintaining a clear overview of the story and its various plotlines. so it was necessary to create an extensive flowchart to document the progression. Each element within these flowcharts is designated with a star, serving as a marker to indicate the implementation level of the corresponding code (for example objects marked with the star and the number 8 are implemented in the function "level8(player)"). The preview of the board can be seen below. The full Miro board can be inspected online.

If the miro board is down, you can find a low quality version of the board here, a pro miro version would be needed for higher quality.

The game operates in the following manner: Users engage by making decisions, and in the background, a player object of the player class undergoes updates based on these choices. The player's character can experience growth or decline in stats, contingent on the decisions made. Additionally, the narrative takes divergent paths according to these choices. To achieve particular endings or storylines, players must have specific stats. Each player possesses an inventory where they can collect items, adding an extra layer of depth to the game.

The player stats are never shown directly to the player and instead written into the story. While playing the player has to guess if they are strong or otherwise capable enough to undergo different options and the text gives them hints through their journey like "You feel stronger now", or "You are lucky and found ..." to have a sense about their own strengths. This way it isn't obvious what choices are best to make and leaves the player to watch out for story clues.

To make user interaction more user friendly and minimize input errors, the "questionary" library was integrated into the game. This allows users to navigate through options using arrow keys and select their choice with the Enter key. The use of "questionary" serves as a robust error prevention mechanism, ensuring smooth and intuitive decision-making throughout the gameplay. User who haven't used a console before might as well be more familiar with this option, since it's not necessary to enter a lot of text or choose numbers from different options.

To elevate the user experience, the text is deliberately revealed gradually on the screen, simulating the sensation of being written in real-time. This creates an intresting effect, akin to unfolding the pages of an actual story. This is allowing users to engage more deeply with the narrative as if reading a captivating tale, one sentence at a time. This approach aims to enhance the overall storytelling ambiance for a better user experience.

The game commences with a start screen, featuring ASCII art, the title, and a count of the discovered endings. This screen serves as an introduction, providing a brief overview of the game's premise. Users are presented with options to initiate the game, reset their progress, or exit the application.

To reset all endings the user can delete the current scores by choosing this option from the main menu. Feedback about the progress is shown to the user and confirmation is needed before deleting.

To end the game savely this option is offered in the start screen as well as after finishing the run.

Upon initiation, the game prompts the user to provide their name and validates the input received. Following this, the user is greeted by name, establishing a personalized connection. While the name isn't presently integrated into the gameplay, it is intended to utilize the player's name in conjunction with the discovered endings to formulate a leaderboard.

At the core of the game lies the text-based storytelling. The interactive nature of the game unfolds through the selection of options that shape the story's progression. The user is prompted for feedback, and a set of options is presented, inviting the player to actively participate and make decisions that influence the direction of the narrative. This dynamic interaction not only engages the player in the unfolding tale but also empowers them to be a key architect of the story and explore different options. The whole story is written by myself.

When an ending is found the user is presented with "the end" in ascii art as well as the number and name of the ending.

The google sheet works as a database, designed to store the endings found by the user. Each ending gets written into the google sheet when found and reset to the default value when deleted.

• It would be great to support text-to-speech functionality, so that players with visual impairments can enjoy the game.
• It would be cool to customizable text size and contrast options, so that players with different visual preferences can comfortably play the game.

• As a player that returns to the story multiple time, the slow text can be annoying. I would love to have a fast-forward option for previously read text, so that the player can explore alternative paths without re-reading entire sections, or getting them faster.
• To find specific endings it would be great to save mid decision, so the player can explore paths later.

• Currently the game is build with one sheet that saves all the progress for everyone playing this game. It would be great to implement a login, so each player has there own save.
• The inclusion of a highscore board adds a competitive and goal-oriented dimension to the gaming experience. Players can compare their achievements, such as the number of endings discovered or other relevant metrics, fostering a sense of accomplishment and encouraging replayability.

The site pass the lighthouse test without Problems. Only SEO could be better.

All python code has been validated with the pep8ci CI Python Linter. There are no errors.

To test the level design, each potential ending undergoes a examination to ensure it can be reached through the intended pathway. This involves manual testing, where every conceivable route leading to an ending is carefully evaluated and documented in the corresponding test files. The path is represented by the sequence of options chosen during gameplay, with each number denoting the position of the respective answers. For instance, "4 - 2 - 1" signifies selecting the 4th option, followed by the 2nd, and finally the 1st option in the given context. This protocol ensures a comprehensive validation of the game's various storylines and endings. Due to the size of the file, the results can be found in a seperate file called "level-testen", which is saved in CSV and PDF Version.

While the text is slowly printed on the screen, every input made by the user is displayed in the text. One potential solution is to temporarily disable keyboard input during the slow printing process. By implementing this approach, you ensure that user inputs are not inadvertently displayed in the text until the printing is complete.

After implementing the is_in_inventory it looked like this:

    # --- Check inventory --- #
    def is_in_inventory(obj):
        """
        Returns true if given object is in the players inventory.
        Returns false if given objects is NOT in the players inventory.
        """
        if obj in self.inventory:
            return True
        else:
            return False

Taking only on argument, the obj to check for, into account. But since multiple instances of a player object can be build, the code needs to be given a self to check.

Solution:

    # --- Check inventory --- #
    def is_in_inventory(self, obj):
        """
        Returns true if given object is in the players inventory.
        Returns false if given objects is NOT in the players inventory.
        """
        if obj in self.inventory:
            return True
        else:
            return False

To transfer the current player object that contains the stats of the player from level to level it need to be handed down from function to function.

Here I have missed to call the function level12() with the player object:

level12()

By giving it the current player, it can get and update stats inside the player object.

level12(player)

To start the python program succesfully, the following Dependencies are needed:

• google-auth==2.22.0
• google-auth-oauthlib==1.0.0
• gspread==5.10.0
• questionary==2.0.1

1. Click the code button and copy the link of your preferred clone option.
2. Open the terminal in your code editor and change the current working directory to the location you want to use for the cloned directory.
3. Type 'git clone' into the terminal, paste the link you copied in step 1 and press enter.

To run the program directly in your terminal, you have to navigate into the folder you just cloned and runt the comman:

python3 run.py

Make sure to have python installed.

To fork the repository:

1. Log in (or sign up) to Github.
2. Go to the repository for this project.
3. Click the Fork button in the top right corner.
4. Under "Owner," select the dropdown menu and click an owner for the forked repository.
5. By default, forks are named the same as their upstream repositories. Optionally, to further distinguish your fork, in the "Repository name" field, type a name.
6. Optionally, in the "Description" field, type a description of your fork.
7. Optionally, select Copy the DEFAULT branch only.
8. For many forking scenarios, such as contributing to open-source projects, you only need to copy the default branch. If you do not select this option, all branches will be copied into the new fork.
9. Click Create fork.

1. Register for an account on Heroku or sign in.
2. Create a new app.
3. Name your App.
4. Add Node JS and Python packages to app setting.
5. Connect github repository to Heroku app
6. Add creds.json content for a given google sheet
7. Deploy from "deploy", or choose an automatic deploy option.

• Markdown Table of Content by Jon Schlinkert
• All Ascii Art is from asciiart.eu
• The Libary questionary and there docs can be found here
• After some trouble with displaying the slow text, this youtube video was used.
• I used AutoPEP8 as a Formatter in Sublime Text
• The background CSS Art is from css-pattern.com
• To make pretty markdown tables, tablesgenerator.com was used.