The Differences Between Iterables

The Tower of Konpyuta

Lists	Dictionaries	Tuples	Sets
Mutable	Mutable	Immutable	Mutable
Can grow and shrink in size	Can grow and shrink in size	x	Can grow and shrink in size
Non-homogenous	Non-homogenous	Non-homogenous	Non-homogenous
Can be nested	Can be nested	Can be nested	Can be nested
Ordered	Ordered	Ordered	Unordered
Allows duplicates	Allows duplicates	Allows duplicates	Does not allow duplicates

---

Imagine…

Imagine that you had an idea for a text-adventure game and you’re idea was that each year, a tower-like dungeon materializes somewhere on the continent of Konpyuta. This mysterious tower exists for only a month, offering untold riches to those brave enough to conquer it. The prize is proportional to the number of people the victor serves—be it a family, a village, or an entire kingdom.

Kings, warriors, and adventurers pour their resources into training and strategies to best the dungeon. But beware: the tower is perilous, and many have met their doom within its walls.

For monarchs, the stakes are even higher—, their survival and wealth hinge on their ability to triumph, lest they fail their kingdoms and families…

Great Idea! Now let’s say you know some basic things you want in the game.

• An inventory system

• NPCs met in the dungeon that seem at least a little life-life

• A monster-populating-per-dungeon-room system

• A leaderboard for past victors

Lets go down these 1-by-1 and talk about the best data structures to use for each one, why, and how.

---

An Inventory System (List)

Because lists are immutable, non-homogenous, and not-size-restricted, a list here would be a good choice. We can add and remove items whenever we want. Lists can also be used to see if the player contains a specific item in their inventory for a puzzle or quest.

💡Something to keep in mind though is that, sometimes using a dictionary might be better for an inventory, where the key;value pair is name_of_item;item_amount to keep track of quantity. However, we’ve establish earlier in our “design document” that monsters will no repeat and we can design around potential numerous monster drops by making no monster_drops in their profiles duplicates of any other monster drops.

The player will need to have the ability to carry and use equipment, items, and treasures they find along the way. The inventory system should be a List:

We are using Lists because…

• Items like potions, weapons, monster_drops can be added or removed as they are found or used.

• We can easily check to see if the player has an item based of puzzle-requirements or NPC trades, etc…

Example:

# YOU BEAT ROOM 54

monster_drop = (monster_dict["inventory"][random.randint(len(monster["inventory"]])
print(f"Monster defeated! You picked up {monster_drop}!"
player.inventory.append(monster_drop) # Adding a monster_drop to the inventory.
print(player.inventory)
# inventory = ["sword", "shield", "health_potion", "goblin_ear"]

---

NPC System with Realistic Qualities (Dictionary)

The adventurers will encounter various NPCs throughout the dungeon, each with unique traits and backstories. A Dictionary is perfect for managing these:

• Store NPC attributes like name, role, and stats as key-value pairs.

• Keys can include "name" or "class," and values can hold detailed data.

Example:

merchant = {
    "name": "Eldrigde",
    "occupation": "Traveling Merchant",
    "stats": {
	      "health": 100, 
	      "mana": 800, 
	      "sellable_goods": {
			      "potion": 20, 
			      "rusty_sword": 40,
			      "mysterious_necklace": 400,
		    }
		    "stealalble_goods": ["puppy", "old ring", "worshipping stone"],
		    "dialogue_options": ["What'rya buyin?", "Stop bothering me and buy something already...", "Still alive, huh?", ...]
		 }
 }
print(npc["name"])  # Output: Eldrigde

---

Random Monster Encounters (Set)

It’s important to know that we use the set.add() function to “add” items to a set.

Each room in the dungeon has a random monster with unique stats. Monsters should never repeat. Using Sets ensures uniqueness:

• When a monster is generated or picked from a pool of monsters, check the intersection of the existing set of monsters with the new set.

• If the length changes, a duplicate monster was found, and a new one must be generated

A word of caution about the above set{} example.

The current implementation has a possibility of leading to a infinite-loop-situation. It’s possible that the random function will continuously input a single monster that has been used previously in another room. In which case, even if one of the three monsters is reused, the entire thing must be redone. This is not efficient at all. However, I’m trying to show an example of how we can use sets to specify specific parameters of uniqueness throughout a program.

A better way to do this here is to define the monsters array in the beginning of the program and then systemically remove the monsters that were picked from the array one-by-one. This way the monsters array will get smaller, take up less memory and space, and we won’t have to worry about duplicates being picked for each room. The set could still be useful though to make sure the random function does not add the same monster twice on in the same round of populating a room.

Example:

# All monsters in the monsters array are objects.
import random

# previous_chosen_monsters = {Slug, Monkeyman, BloodThirstyCaterpillar}
monsters_array = [Goblin, Gargoyle, Troll, Anaconda, Bat, Dragon, etc...]

def next_room_enemies(monsters_array):
	# old_room_set = {"Goblin", "Troll", "Dragon"}
	new_monster_room = set()
	repeat = True
	while repeat == True:
		while len(new_monster_room) < 3:
			new_monster = monsters_array[random.randint(0, len(monsters_array) - 1])
			new_monster_room.add(new_monster)
		monsters_previously_used = new_monster_room.intersection(previous_chosen_monsters)
		if len(monsters_previously_used) > 1:
			continue
		else:
			repeat = False
			
		return new_monster_room
		
# old_monster_room = {Dragon, Gargoyle, Bat}
# new_monster_room = {Goblin, Troll, Anaconda}

---

Eternal Glory for Winners (Tuple)

The dungeon keeps an immutable record of its winners. Tuples are ideal for this:

• Store each winner’s name alongside the year they triumphed.

• The list of winners cannot be changed, ensuring the record is secure.

• If cheating is detected, the entry can be removed and updated.

Example:

winners = (("Arulia The Assassin", 503), ("Sisson The Warlord", 504))
print(winners[1])  # Output: ('Sisson The Warlord', 503)