Skip to main content

This package provides simple tools for creating Text Based Games. It allows for player world interaction and battle with enemies, its a great way to turn a story into an interactive game that players can enjoy and still maintain their reading requirements.

Project description

Table of contents

Introduction

This package provides tools for creating simple Text Based Games while still satisfying players reading needs.

It allows book writers to create an interactive games of literature. The tools allow player/readers to explore the worlds from the book and interact with items, people and even have battles with antagonists of the book.

This package was initially designed for RPG and Adventure games but it is not limited to these genres.

Technologies

pygame is only used for playing background music, hopefully future updates do not affect the music functionality but the package is not necessarily required.

The typewriter module is also in use, its use case is for printing individual characters at a specific speed.

The package is developed in pure Python3.8

Scope of functionality

The package provides multiple tools that make it easy to start developing a simple Text Based Game.

Your project folder should include the following modules:

Module: CMD

This module contains the Cmd class. The module allows you to detect multiple synonyms for an action/verb

Class: Cmd

  def __init__(self, name):
     self._command_list = []
     self.name = name
  • On initialization the CMD instance needs a name, its name attribute will be used as the main word of the group of synonyms.
  • Available option include:
    • "eat": Command for eating

    • "ex_help": command for displaying help text for explore environment (The package has default help text, called "default_help.py" inside the script load in 'def_ex_help')

    • "goto": command fro changing location

    • "look_around": command for examining the room

    • "examine_item": command fro examining items

    • "throw": command for disposing items from inventory

    • "talk": command for conversing with NPC objects

    • "take_item": command for taking items from room

    • "search_inv": command for displaying items that in inventory

    • "stats": command for displaying players statistics

    • "my_story": command for displaying player backstory

    • "show_move": command for displaying statistics of a Fight class instance

    • "learn": command for learning new fighting moves

    • "enhance": command for using an object to increase damage of a fight move

    • "equip": command for equipping armor

    • "battle_help": command for displaying help text for battle environment (The package has default help text, called "default_help.py" inside the script load in 'def_bat_help')

    • "attack": command for using a fight move against an opponent

    • "proceed": command to exit the exploration loop

      Example use

      from TBG.CMD import Cmd

      eat = Cmd("eat") print(eat.name)

      'eat'

  • Now we need to provide the object with a list of synonyms related to the name.

  • eg. Lets say the player wants to consume a food item, we have a method that takes care of that process. Our game has multiple functionality we need a way to identify the specific action/verb, also our method needs an argument to identify the food item.

  • To extract the information we will make us of the 're module' it will detect the related synonyms and the argument required

  • your patter must follow this format:

"(synonyms)(\s*)(?P<arg1>[word extractor])(\s)"

      # Example use
      ...
      synonym1 = r"(consume)(\s*)(?P<arg1>[\w\']*)(\s*)"
      synonym2 = r"(chow)(\s*)(?P<arg1>[\w\']*)(\s*)"

      eat.command_list = [synonym1, synonym2]

What we did here is create our pattern that will capture the word "consume" or "chow" which are both words related to eating something. Followed by an optional white space character , lastly the argument which will be passed in to the method.

Always name the argument 'arg1'

You have the option of having all the synonyms in one pattern, but it will have a lot of clutter

   # Example use

   synonym = r"([(chow)(consume)])(\s*)(?P<html>[\w\']*)"

   eat.command_list = [synonym]
  • After creating your pattern list you will be able to use the 'breaker' method. The method takes in the players input and test if their command is related to a specific Cmd object. It will return False if it doesnt find a match and if it does it will return an re.match object.

Method: breaker(self)

  # Example use

  player_input1 = "consume Pizza"
  player_input2 = "fight villian"

  eat.breaker(player_input1)
  >> re.match object; span(0, 13), match="consume Pizza"

  eat.breaker(player_input2)
  >>False

from the re.match object we can extract our argument value

   # Example use

   match = eat.breaker(player_input1)

   print(match.group("arg1"))
   >>Pizza

Module: fight_move

The module provides the class for creating fighting moves with their essential attributes

Used by the Player class instance and the Enemy class instance to battle each other

Class: Fight

 def __init__(self, name, style="Normal", damage=0):
     self.name = name
     self.damage = damage
     self._desc = "None"
     self._atck_desc = []
     self.style = style
  • self.name: Used to identify the fight move

  • self.damage: Value used to subtract from opponent's hp attribute

  • self._desc: Description of the fight move. This attribute has a property method for changing its value, the name of the property is similar to the name of the particular attribute excluding the underscore

  • self.style: Used to specify the style of the fight move, default is "Normal

      # Example use
    
      from TBG.fight_move import Fight
    
      kick = Fight("Kick", style="Normal", damage="50")
      kick.desc = "Normal human kick"
    
  • self._atck_desc: The list of descriptive sentences of how the fight move was used, has a property method for setting the list. The name of the property method is similar to the attribute name excluding the underscore

       ...
       # Example use
    
       list = ["Very hard blow on the oponent's head", "slide kick on the legs", "Deadly kick on the chest, rndering the oponent breath less"]
       kick.atck_desc = list
       ...
    

Module: item

Contains classes for creating objects with unique uses.

  • Food: Increases Player class instance's hp attribute
  • Scroll: Changing Player class instance's fight_moves dictionary of Fight class instances
  • Enhancement: Increase damage attribute for Player class instance's fight moves
  • Armor: Changing Player class instance's defence attribute

Class: Item

Has no special use in th game, contains the basic attribute of an item of the game.

 def __init__(self, name):
    self.name = name
    self._desc = "None" 
    self.type = "None"  
  • All object will inherit the following values:

    • self.name: name of the item
    • self._desc: The description of the item, has a property method for changing its value, the name of the property is similar to the name of the particular attribute excluding the underscore
    • self.type: Used for determining the use case of the item Shouldn't be changed

    Example use

    from TBG.item import Item

    stone = Item("Stone") stone.desc = "Stone amomgst a group of stone on the floor"

Class: Food(Item)

def __init__(self, name, regeneration=0):
   super(Food, self).__init__(name)
   self.regen = regeneration
   self.type = "Consumable"

The Food class inherits from Item class and has the basic attributes of an item.

  • self.regen: Value used to increase Player class instance's hp attribute

  • self.type: To identify that the object can be consumed. Shouldn't be changed

    # Example use 
    
    from TBG.item import Food
    
    pizza = Food("Pizza", regeneration=50)
    

Method: full_desc(self)

Takes no positional arguments.

This method will print out the useful info about the Food instances.

The typewriter module is used here to print the individual characters at a specific speed

Class: Scroll(Item)

The Scroll class inherits from Item class the basic attributes of an item.

def __init__(self, name):
   super(Scroll, self).__init__(name)
   self.type = "Learn"
   self._fight_moves = {}
  • self.type: To identify that this object contains a dictionary of Fight class instances. Shouldn't be changed

  • self._fight_moves: The dictionary of Fight class instances, has a property method for changing its value, the name of the property is similar to the name of the particular attribute excluding the underscore

    Example use

    from TBG.item import Scroll from TBG.fight_move import Fight

    Dragon_book = Scroll("Dragon_book") Dragon_book.desc = "This scroll will teach you the moves of the amazing kunfu master, Dragon bokie."

    Our dictionary of Fight class instances

    punch = Fight("punch", damage=10)

    dict = {punch.name: punch}

    Dragon_book.fight_moves = dict

Method: full_desc(self)

Take no positional arguments

Prints out the Scroll class instance's description and displays the attributes of it's dictionary of Fight class instances

The typewriter module is used here to print the individual characters at a specific speed

Class: Enhancement(Item)

The Enhancement class inherits from Item class the basic attributes of an item.

Used to increase the damage attribute of specific Fight class instances

def __init__(self, name, style, damage_increase=0):
   super(Enhancement, self).__init__(name, damage_increase)
   self.style = style
   self.type = "Improve"
  • self.style: For identifying the style of the Fight class instance that it will affect

  • self.type: to identify that the object can be used to improve the Fight class instance's damage attribute Shouldn't be changed

  • self.damage: damage_increase: This attribute is the value of damage that a specific Fight class instance's damage attribute will be increased by.

     # Example use
    
     from TBG.item import Enhancement
    
     dumbbell = Enhancement("dumbbell", style="Normal", damage_increase=5)
     dumbbell.desc = "rusty but still does the job"
    

Method: full_desc(self)

Takes no positional arguments

Displays the instances name, damage and style attributes

# Example use
...
dumbbell.full_desc()
...

The typewriter module is used here to print the individual characters at a specific speed

Class: Armor(Item)

The Armor class inherits from Item class the basic attributes of an item.

Instances of this class are used to replace the defence attribute of Player class instance

   def __init__(self, name, defence=0):
       super(Armor, self).__init__(name)
       self.defence = defence
       self.type = "Armor" to identify that the item can be used to change defence value o the player
  • self.defence: The value that will be used to replace the Player class instance's defence attribute

  • self.type: To identify that the item can be used to change defence value of the player class instance

     # Example use
    
     from TBG.item import Armor
    
     chestplate = Armor("chestplate", 10)
     chestplate.desc = "Normal peace of armor"
    

Method: full_desc(self)

Takes no positional arguments

Displays the instances description and defence attribute

# Example use

chestplate.full_desc()

The typewriter module is used here to print the individual characters at a specific speed

Module: room

The room module contains the Room class.

The class is used to create different environments that can be explored by Player class instance.

The class is not restricted for making closed rooms, it is designed to fit any type of setting outdoor and indoor.

Class: Room

 def __init__(self, name):
    self.name = name
    self._desc = "None"  # The description of the room
    self._items = {}  # The dictionary of Item class instance
    self._near_rooms = {}  # The dictionary of related Room class instances
    self._people = {}  # The dictionary of NPC's in the room
  • self.name: The name of the room

  • self._desc: The description of the Room instance

  • self._items: This is a dictionary of item class instances. It has a property method for setting its values

  • self._near_room: The dictionary of related Room instances. It has a property method for setting its values

  • self._people: This is the dictionary of instances of NPC class from the player module

    # Example use 
    
    from TBG.item import Food
    from TBG.item import Armor
    from TBG.player import NPC
    from TBG.room import Room
    
    # main room
    bedroom = Room("My_room")
    
    #item for the main room
    shirt =  Armor("T-shirt", 2)
    soda = Food("Soda")
    
    # Related rooms
    bathroom =  Room("bathroom")
    kitchen = Room("kitchen")
    
    # connecting rooms
    kitchen.near_rooms = {bathroom.name: bathroom, bedroom.name: bedroom}
    bedroom.near_rooms = {bathroom.name: bathroom, kitchen.name: kitchen}
    bathroom.near_rooms = {bedroom.name: bedroom, kitchen.name: kitchen}
    
    # NPC's
    mum = NPC("Mum")
    dad = NPC("Dad")
    
    bedroom.items = {shirt.name: shirt, soda.name: soda}
    bedroom.people = {mum.name: mum, dad.name: dad}
    

Just remember that since the _near_rooms attribute contains instances of Room class, those rooms also require item, NPC, and Room instances

Module: player

This module contains the classes for creating characters that can be interacted with.

  • Enemy class
  • NPC class
  • Player class

Class: NPC

This class is used for creating non-playable characters

They don't have special functionality other saying random text.

 def __init__(self, name):
    self._text_opt = [] 
    self.name = name 
  • self.name: Name of NPC

  • self.text_opt: List of different replies of the NPC, It has a property method for setting its values

    # Example use
    
    from TBG.player import NPC
    
    Mum = NPC("Mum")
    Dad = NPC("Dad")
    
    # List of replies
    Mum_reply = ["Hello Dear, hows your day going so far", "I hope your room is clean, I'm coming to check as soon as I'm lifting these weights"]
    Dad_reply = ["Hay son wanna go play some games", "I juts wanna go sleep ,YAAAAAWN."]
    
    Mum.text_opt = Mum_reply
    Dad.text_opt = Dad_reply
    

Class: Enemy

This class is used to make enemies that will battle with Player class instances

 def __init__(self, name, hp=100, defence=0):
    self.name = name
    self.hp = hp
    self.defence = defence 
    self._fight_moves = {}  
  • self.name: The name of the Enemy instance

  • self.hp: The Health of the Enemy instance

  • self.defence: The value that an attack damage will be reduced by

  • self._fight_moves: Dictionary of Fight class instances, It has a property method for setting its values

    # Example use
    
    from TBG.player import Enemy
    from TBG.fight_move import Fight
    
    Loki = Enemy("Loki", defence=1000)
    
    # Fight class instances
    
    Slap = Fight("Slap", damage=10)
    headbutt = Fight("Headbutt", damage=100)
    
    Loki.fight_moves = {Slap.name: Slap, headbutt.name: headbutt}
    

Class: Player

The Player class is used to make gama characters/main character of the story.

Instances of this class have thr ability to interact with their environment and make use of the class instances and change their attribute value

BAG_CAP = 10  

def __init__(self, name, max_hp=100, defence=0):
    self.name = name  
    self._MAX_HP = max_hp
    self.hp = self._MAX_HP 
    self.defence = defence 
    self._fight_moves = {} 
    self._location = None 
    self._bag = {}  
    self._backstory = "None"  
  • BAG_CAP: The maximum capacity of the Player's bag attribute

  • self.name: The name of the Player instances

  • self._MAX_HP: The max hp value

  • self.hp: The Health of the player

  • self.defence: The value that an attack damage will be reduced by

  • self._fight_moves: Dictionary of Fight class instances, It has a property method for setting its values

  • self._location: This attribute is used to identify the room that the Player instance is in, the value is a Room class Instance

  • self._bag: Dictionary of instances from item module

  • self._backstory: The Player instance's back story i.e autobiography

    # Example use
    
    from TBG.player import Player
    
    James = Player("James", max_hp=50, defence=100)
    

Method: take_item(self, item)

  • The functions controls the act of removing an item instance from a Room instance's items dictionary.

  • The argument 'item' is the key to the dictionary of items in the Player instance's current location.

  • The function uses the location attribute to identify the current Room the Player instance is an removes the item from the items attribute and appends is to Player instances bad attribute

    # Example use
    
    from TBG.player import Player 
    from TBG.room import Room
    from TBG.item import Food
    
    # Room instance
    Bedroom =  Room("Bedroom")
    
    # Food instance
    Pizza = Food("Pizza", regeneration=10)
    
    # adding item to the room
    Bedroom.items = {Pizza.name:Pizza}
    
    # connecting rooms
    kitchen.near_rooms = {bathroom.name: bathroom, Bedroom.name: Bedroom}
    Bedroom.near_rooms = {bathroom.name: bathroom, kitchen.name: kitchen}
    bathroom.near_rooms = {Bedroom.name: Bedroom, kitchen.name: kitchen}
    
    # setting players location
    James.location = Bedroom
    
    # take_item
    James.take_item("Pizza")
    

Method: search_inv(self)

  • The function controls the act of displaying the item Player instances bag attribute.

  • The function will iterate through all the item instances of the Player instance bag attribute.

    # Example use
    ...
    James.search_inv()
    ...
    

Method: def examine_item(self, item)

  • The function calls the full_desc() method of instances from item module

  • The argument 'item' is used as the key for finding the item instance in the Player instances bag attribute.

    # Example use
     ...
    James.examine_item("Pizza")
     ...
    

Method: my_story(self)

  • This attribute displays the Player instance's backstory attribute.

    # Example use 
    ...
    James.backstory = "Just a young boy from Capetown"
    James.my_story()
    ...
    

Method: stats(self)

  • Displays certain attributes of the Player instance that are related to its condition.

    # Exampale use
    ...
    James.stats()
    ...
    

Method: throw(self, item)

  • This function controls the act of disposing item from inventory

  • The argument 'item' is used as a key to access the item from the bag attribute.

  • The function will remove the item from Player's bag attribute and will append the item into the items attribute of the Player's location attribute, which is a Room instances.

    # Example use
    ...
    James.throw("Pizza")
    ... 
    

Method: goto(self, new_location)

  • This function controls the act of changing location

  • The argument 'new_location' is used as a key to access a Room instance from Player's location near_rooms attribute

  • Player's location is changed to the Room instances, Player can only travel to rooms that are in the near_room attribute of their current location

    # Example use
    ...
    James.goto("bathroom")
    ... 
    

Method: look_around(self)

  • This function controls the act of examining your surroundings

  • The function displays the description of the Player's current location, items, and the NPC instances

    # Example use
    
    ...
    James.look_around()
    ...
    

Method: eat(self, food)

  • Controls the act of eating food

  • The argument 'food' is used as a key to access the Food instance in the Player's bag attribute.

  • It will increase Player's hp attribute with the Food instance's regen attribute, then the Food instances will be deleted

    # Example use
    ...
    James.eat("Pizza")
    ...
    

Method: equip(self, armor)

  • Controls the act of equipping equipment

  • The argument 'armor' is used as a key to access the Armor instance in the Player's bag attribute.

  • It will switch the Player defence attribute with the Armor instance's defence value, then the Armor instance will be deleted

    # Examlple use
    ...
    from TBG.item import Armor
    
    shirt = Armor("Shirt", defence=2)
    
    James.bag[shirt.name] = shirt
    James.equip("Shirt")
    ...
    

Method: learn(self, scroll)

  • Controls act of learning the moves from a scroll

  • The argument 'scroll' is used as a key to access the Scroll instance in the Player's bag attribute.

  • It will replace the Player instance's fighting_move attribute will the Scroll instances fighting_move attribute, then it will be deleted

     # Example use
    
     from TBG.item import Scroll
     from TBG.fight_move import Fight
    
     Dragon_book = Scroll("Dragon_book")
     Dragon_book.desc = "This scroll will teach you the moves of the amazing kunfu master, Dragon bokie."
    
     # Our dictionary of Fight class instances
     punch = Fight("punch", damage_increase=10)
    
     dict =  {punch.name: punch}
    
     Dragon_book.fight_moves = dict
    
     James.bag[Dragon_book.name] = Dragon_book
    
     James.learn("Dragon_book")
     ...
    

Method: enhance(self, enhancer)

  • Controls the act of increasing the damage dealt of a specific Fight class instance.

  • The argument 'enhancer' is used as a key to access the Enhancement instance in the Player's bag attribute.

  • The function uses the Enhancement instance's damage attribute to increase the damage of Fight class instances that have the same value for the style attribute, then it will be deleted.

    # Example use
    
    from TBG.fight_move import Fight
    from TBG.item import Enhancement 
    
    punch = Fight("punch", damage=10, style="Normal")
    dumbbell = Enhancement("Dumbbell", damage_increase=10, style="Normal")
    
    James.fight_moves[punch.name] = punch
    James.bag[dumbbell.name] = dumbbell
    
    James.enhance("Dumbbell")
    

Method: show_move(self, move)

  • For displaying useful info about a Fight move.

  • The argument 'move' is used as a key to access the Fight instance in the Player's fight_moves attribute.

    # Example use
    
    ...
    James.show_move("punch")
    ...
    

Method: talk(self, npc)

  • Controls the sct of conversing with NPC in the game

  • The argument 'npc' is used as a key to access the NPC instance in the Player's location's people attribute.

  • Function will access the NPC's text_opt attribute and randomly select text to say back.

    # Example use 
    ...
    James.talk("Mum")
    ...
    

Module: level

  • Contains the level class

Class: Level

This class join s everything together and will allow us to explore the world and battle enemies.

 def __init__(self):
        self._level_rooms = None 
        self._command_variant = []  
        self._explore_help = "None"  # Help text for exploration method
        self._battle_help = "None"  # Help text for battle method 
  • self._level_rooms: Room instance, the first room that the player will be loaded in at the start of the level.
  • self._command_variant: A list of Cmd instances.
  • self._battle_help: Guide of how to play the game, explains the functionality of various verbs for exploring.
  • self._explore_help: Guide of how to play the game, explains the functionality of various verbs for battle.

Method: explore_loop(self, player, music_dir=None)

  • Handles "player" input and functionality for verbs

  • Argument player must be a Player instance.

  • Argument music_dir must be a directory to the music file that will play in the background.

The function will request the player for input, the input is processed through the list of Cmd instances breaker method, if match is found the corresponding function will b executed.

from TBG.CMD import Cmd
from TBG.level import Level
from TBG.room import Room
from TBG.item import Food

# Cmd instance
eat = Cmd("eat")
eat.command_list = [r"(chow)(\s*)(?P<arg1>[\w\']*)", r"(consume)(\s*)(?P<arg1>[\w\']*)"]    

# Room instance
Bedroom =  Room("Bedroom")

# Food instance
Pizza = Food("Pizza", regeneration=10)
James.bag[Pizza.name] = Pizza

# level instance
level1 = Level()

# rooms of level
level1.level_rooms = Bedroom

# List of Cmd objects
level1.command_variant = [eat]

# explore_loop
level1.explore_loop(James)

>>> player_input =  "chow Pizza"
    command_verb = "eat"
    arg1 = "Pizza"

>>> James.eat(arg1)

Method: battle_loop(self, player, enemy, music_dir=None)

  • Handles player input and functionality for verbs
  • Argument "player" must be a Player instance and the "enemy" argument must be an Enemy instance.
  • Argument music_dir must be a directory to the music file that will play in the background.

The function will request the player for input, the input is processed through the list of Cmd instances breaker method, if match is found the corresponding function will b executed.

The functionality is based on battling the enemy

# Example use
...
from TBG.fight_move import Fight
from TBG.player import Enemy
from TBG.CMD import Cmd

# Cmd instance for battling
attack = Cmd("attack")
attack.command_list =  [r"(attack[\s]*with)(\s*)(?P<arg1>[\w\']*)", r"(use)(\s*)(?P<arg1>[\w\']*)"]

punch = Fight("punch", damage=10, style="Normal")
James.fight_moves[punch.name] = punch

# enemy instance
BadGuy = Enemy("BadGuy")
BadGuy.fight_moves[punch.name] = punch

level1.command_variant.append(attack)
level1.battle_loop(player=James, enemy=BadGuy)

Default help text

Explaining what each command does is quite redundant on your side, so I've created default help text that you can used how your version of the game works.

The text is located in default_help script, inside you will find 'def_ex_help' and 'def_b_help'. They contain text explaining each command synonymy's use

    def_bat_help = """
    >> How to play?

    On playing the game you will see this 'Command: ' here you will
    input what you want to do next. There are multiple options to pick from
    based on your needs of battle.

    Command types:

    1.  Command: attack Name_of_fighting_move
    >   This command allows the user to used their fight move against an enemy.
        Input the command followed by the name of the fight move
    eg. Command: attack with Dragon_kick

    2. Command: eat Name_of_item
    >   This command is used to eat food from the game. 
        Input the command followed by the name of the item
    eg. Command: eat Pizza

    3.  Command: stats
    >   This command is used to display the attribute of the player.
    eg Command: abilities

    4. Command: show_move Name_of_fighting_move
    >   This command is used to display the attribute of a player's fighting move.
        Input the command followed by the name of the fight move
    eg. Command: skill Dragon_kick
        """

       def_ex_help = """
    >> How to play?

    On playing the game you will see this 'Command: ' here you will
    input what you want to do next. There are multiple options to pick from
    based on your needs of exploration.

    Command types:

    1.  Command: look around 
    >   This command is used to display the items, people, exits available a Room.
    eg. Command: look around

    2.  Command: goto Name_of_Room
    >   This command is used to change the player's location/Room.
        Input the command followed by the name of the Room
    eg. Command: enter Johnny's_House

    3.  Command: take_item Name_of_item
    >   This command is used to take items from a Room.
        Input the command followed by the name of the item
    eg. Command: take Phone

    4.  Command: throw Name_of_item
    >   This command is used to throw away items from your inventory.
        Input the command followed by the name of the item
    eg. Command: throw away Phone

    5.  Command: examine/look at Name_of_item
    >   This command is used to display the attribute of an item from your inventory.
        Input the command followed by the name of the item.
    eg. Command: examine Phone 

    6.  Command: search_inv
    > This command is used to display the names of items that are in your inventory.
    eg. Command: search inventory

    7.  Command: stats
    >   This command is used to display the attribute of the player.
    eg Command: abilities

    8.  Command: my_story
    >   This command is used to display the players back story.
    eg Command: back story

    9.  Command: learn Name_of_item
    >   This command is used to give player a new set of fighting moves
        Input the command followed by the name of the item
    eg. Command: study Dragon_scroll

    10. Command: enhance Name_of_item
    >   This command is used to increase damage of player's fighting move set, provided
        that they are of the same style.
        Input the command followed by the name of the item
    eg. Command: train Dumbbell

    11. Command: show_move Name_of_fighting_move
    >   This command is used to display the attribute of a player's fighting move.
        Input the command followed by the name of the fight move
    eg. Command: skill Dragon_kick

    12. Command: equip Name_of_armor
    >   This command is allows the player to equip armor.
        Input the command followed by the name of the armor
    eg. Command: wear T-shirt

    13. Command: talk Name_of_NPC
    >   This command is used for talking to NPCs in the game
        Input the command followed by the name of NPC
    eg. Command: approach Mummy

    14. Command: eat
    >   This command is used to eat food from the game. 
        Input the command followed by the name of the item
    eg. Command: eat Pizza

    15. Command: proceed
    >   This command will end the game loop inorder to proceed.
    eg. Command: proceed

    """

The text explains what the commands will do when playing the game. This section of the text '#No. Command: <replace with your synonyms>'

>   eg.  14. Command: chow/munch/consume Name_of_item
         >   This command is used to eat food from the game. 
             Input the command followed by the name of the item
      eg.Command: eat Pizza 

Project details


Download files

Download the file for your platform. If you're not sure which to choose, learn more about installing packages.

Files for Futshane-TBG, version 1.0.0
Filename, size File type Python version Upload date Hashes
Filename, size Futshane_TBG-1.0.0-py3-none-any.whl (21.2 kB) File type Wheel Python version py3 Upload date Hashes View
Filename, size Futshane_TBG-1.0.0.tar.gz (34.1 kB) File type Source Python version None Upload date Hashes View

Supported by

AWS AWS Cloud computing Datadog Datadog Monitoring Facebook / Instagram Facebook / Instagram PSF Sponsor Fastly Fastly CDN Google Google Object Storage and Download Analytics Huawei Huawei PSF Sponsor Microsoft Microsoft PSF Sponsor Pingdom Pingdom Monitoring Salesforce Salesforce PSF Sponsor Sentry Sentry Error logging StatusPage StatusPage Status page