def test_destroy_item(self):
thing = Item("thing")
ctx = Context(driver=mud_context.driver,
clock=None,
config=None,
player_connection=None)
thing.destroy(ctx)
def test_custom_verbs(self):
player = Player("julie", "f")
player.verbs["xywobble"] = "p1"
room = Location("room")
chair1 = Item("chair1")
chair1.verbs["frobnitz"] = "c1"
chair2 = Item("chair2")
chair2.verbs["frobnitz"] = "c2"
chair_in_inventory = Item("chair3")
chair_in_inventory.verbs["kowabooga"] = "c3"
room.init_inventory([chair1, player, chair2])
# check inventory NOT affecting player custom verbs, but DOES affect location verbs
self.assertEqual({"xywobble": "p1"}, player.verbs)
self.assertEqual({"frobnitz": "c2", "xywobble": "p1"}, room.verbs)
player.insert(chair_in_inventory, player)
self.assertEqual({"xywobble": "p1"}, player.verbs)
self.assertEqual({"frobnitz": "c2", "xywobble": "p1", "kowabooga": "c3"}, room.verbs)
player.remove(chair_in_inventory, player)
self.assertEqual({"frobnitz": "c2", "xywobble": "p1"}, room.verbs)
player.insert(chair_in_inventory, player)
self.assertEqual({"frobnitz": "c2", "xywobble": "p1", "kowabooga": "c3" }, room.verbs)
room2 = Location("room2")
self.assertEqual({}, room2.verbs)
chair1.move(room2, player)
self.assertEqual({"xywobble": "p1", "kowabooga": "c3" }, room.verbs)
self.assertEqual({"frobnitz": "c1"}, room2.verbs)
chair2.move(room2, player)
self.assertEqual({"xywobble": "p1", "kowabooga": "c3"}, room.verbs)
self.assertEqual({"frobnitz": "c2"}, room2.verbs)
player.move(room2)
self.assertEqual({}, room.verbs)
self.assertEqual({"frobnitz": "c2", "xywobble": "p1", "kowabooga": "c3"}, room2.verbs)
def test_sortedby(self):
a = Item("a", "big A")
b = Item("b", "micro B")
c = Item("c", "epic C")
stuff = [c, b, a]
self.assertEqual([a, b, c], util.sorted_by_name(stuff))
self.assertEqual([a, c, b], util.sorted_by_title(stuff))
def do_buy_pills(self, actor: Living, pills: Item, price: float) -> None:
if actor.money < price:
raise ActionRefused("You don't have enough money!")
actor.money -= price
self.money += price
pills.move(actor, self)
price_str = mud_context.driver.moneyfmt.display(price)
actor.tell("After handing %s the %s, %s gives you the %s." % (self.objective, price_str, self.subjective, pills.title))
self.tell_others("{Actor} says: \"Here's your medicine, now get out of here!\"")
def test_name(self):
item = Item("key")
self.assertEqual("key", item.name)
self.assertEqual("key", item.title)
self.assertEqual("", item.description)
item = Item("KEY")
self.assertEqual("key", item.name)
self.assertEqual("KEY", item.title)
self.assertEqual("", item.description)
def do_buy_ammo(self, actor: Living, ammo: Item, price: float) -> None:
if actor.money < price:
raise ActionRefused("You don't have enough money!")
actor.money -= price
self.money += price
ammo.move(actor, self)
price_str = mud_context.driver.moneyfmt.display(price)
actor.tell("After handing %s the %s, %s gives you the %s." % (self.objective, price_str, self.subjective, ammo.title))
self.tell_others("{Actor} says: \"Here's your ammo, now get out of here!\"")
def test_init_inventory(self):
rat = NPC("rat", "n", race="rodent")
rat.insert(Item("thing"), None)
wizz = Player("wizard", "f")
wizz.privileges.add("wizard")
rat.insert(Item("thing2"), wizz)
self.assertEqual(2, rat.inventory_size)
stuff = [Item("thing")]
with self.assertRaises(AssertionError):
rat.init_inventory(stuff)
rat = NPC("rat", "n", race="rodent")
rat.init_inventory(stuff)
self.assertEqual(1, rat.inventory_size)
def test_description(self):
item = Item("key", "rusty old key", "a small old key that's rusted")
self.assertEqual("key", item.name)
self.assertEqual("rusty old key", item.title)
self.assertEqual("a small old key that's rusted", item.description)
item = Item(
"key", "rusty old key", """
a very small, old key that's rusted
""")
self.assertEqual("key", item.name)
self.assertEqual("rusty old key", item.title)
self.assertEqual("a very small, old key that's rusted",
item.description)
def test_title(self):
bag = Container("bag", "leather bag", "a small leather bag")
stone = Item("stone")
player = Player("julie", "f")
self.assertEqual("bag", bag.name)
self.assertEqual("leather bag", bag.title)
self.assertEqual("a small leather bag", bag.description)
bag.move(player, player)
self.assertEqual("bag", bag.name)
self.assertEqual("leather bag", strip_text_styles(bag.title))
self.assertEqual("a small leather bag", strip_text_styles(bag.description))
stone.move(bag, player)
self.assertEqual("bag", bag.name)
self.assertEqual("leather bag", strip_text_styles(bag.title))
self.assertEqual("a small leather bag", strip_text_styles(bag.description))
def test_clone(self):
item = Item("thing", "description")
item.aliases = ["a1", "a2"]
item2 = util.clone(item)
self.assertNotEqual(item, item2)
item2.aliases.append("a3")
self.assertNotEqual(item.aliases, item2.aliases)
player = Player("julie", "f")
player.insert(item, player)
player2 = util.clone(player)
player2.insert(item2, player2)
self.assertNotEqual(player.inventory_size, player2.inventory_size)
self.assertNotEqual(player.inventory, player2.inventory)
self.assertTrue(item in player)
self.assertFalse(item in player2)
def test_destroy_deferreds(self):
ctx = Context(driver=mud_context.driver, clock=None, config=None, player_connection=None)
thing = Item("thing")
player = Player("julie", "f")
wolf = NPC("wolf", "m")
loc = Location("loc")
mud_context.driver.defer(datetime.datetime.now(), thing.move)
mud_context.driver.defer(datetime.datetime.now(), player.move)
mud_context.driver.defer(datetime.datetime.now(), wolf.move)
mud_context.driver.defer(datetime.datetime.now(), loc.move)
self.assertEqual(4, len(mud_context.driver.deferreds))
thing.destroy(ctx)
player.destroy(ctx)
wolf.destroy(ctx)
loc.destroy(ctx)
self.assertEqual(0, len(mud_context.driver.deferreds), "all deferreds must be removed")
def test_print_location(self):
p = Player("julie", "f")
key = Item("key")
bag = Container("bag")
room = Location("room")
bag.insert(key, p)
p.insert(bag, p)
room.insert(p, p)
with self.assertRaises(Exception):
p.tell_object_location(None, None)
p.tell_object_location(key, None)
self.assertEqual(["(It's not clear where key is).\n"],
p.test_get_output_paragraphs())
p.tell_object_location(key, None, print_parentheses=False)
self.assertEqual(["It's not clear where key is.\n"],
p.test_get_output_paragraphs())
p.tell_object_location(key, bag)
result = "".join(p.test_get_output_paragraphs())
self.assertTrue("in bag" in result and "in your inventory" in result)
p.tell_object_location(key, room)
self.assertTrue("in your current location" in "".join(
p.test_get_output_paragraphs()))
p.tell_object_location(bag, p)
self.assertTrue(
"in your inventory" in "".join(p.test_get_output_paragraphs()))
p.tell_object_location(p, room)
self.assertTrue("in your current location" in "".join(
p.test_get_output_paragraphs()))
def test_destroy_deferreds(self):
ctx = Context(driver=mud_context.driver)
thing = Item("thing")
player = Player("julie", "f")
wolf = Monster("wolf", "m")
loc = Location("loc")
mud_context.driver.defer(datetime.datetime.now(), thing, "method")
mud_context.driver.defer(datetime.datetime.now(), player, "method")
mud_context.driver.defer(datetime.datetime.now(), wolf, "method")
mud_context.driver.defer(datetime.datetime.now(), loc, "method")
self.assertEqual(4, len(mud_context.driver.deferreds))
thing.destroy(ctx)
player.destroy(ctx)
wolf.destroy(ctx)
loc.destroy(ctx)
self.assertEqual(0, len(mud_context.driver.deferreds), "all deferreds must be removed")
def test_show_inventory(self):
class Ctx(object):
class Config(object):
pass
config = Config()
class MoneyDriverDummy(object):
pass
ctx = Ctx()
ctx.config.money_type = "modern"
ctx.driver = MoneyDriverDummy()
ctx.driver.moneyfmt = MoneyFormatter(ctx.config.money_type)
julie = Living("julie", "f", race="human")
tap = julie.get_wiretap()
collector = PubsubCollector()
tap.subscribe(collector)
item1 = Item("key")
julie.init_inventory([item1])
julie.money = 9.23
julie.show_inventory(julie, ctx)
pubsub.sync()
text = " ".join(msg.strip() for msg in collector.messages)
self.assertEqual(
"Julie is carrying: key Money in possession: 9 dollars and 23 cents.",
text)
ctx.config.money_type = None
ctx.driver.moneyfmt = None
collector.clear()
julie.show_inventory(julie, ctx)
pubsub.sync()
text = " ".join(msg.strip() for msg in collector.messages)
self.assertEqual("Julie is carrying: key", text)
def test_title(self):
bag = Container("bag", "leather bag", "a small leather bag")
stone = Item("stone")
player = Player("julie", "f")
self.assertEqual("bag", bag.name)
self.assertEqual("leather bag", bag.title)
self.assertEqual("a small leather bag", bag.description)
bag.move(player, player)
self.assertEqual("bag", bag.name)
self.assertEqual("leather bag", strip_text_styles(bag.title))
self.assertEqual("a small leather bag",
strip_text_styles(bag.description))
stone.move(bag, player)
self.assertEqual("bag", bag.name)
self.assertEqual("leather bag", strip_text_styles(bag.title))
self.assertEqual("a small leather bag",
strip_text_styles(bag.description))
def test_allowance(self):
bag = Container("bag")
key = Item("key")
player = Player("julie", "f")
with self.assertRaises(Exception):
bag.insert(None, player)
bag.insert(key, player)
with self.assertRaises(KeyError):
bag.remove(None, player)
bag.remove(key, player)
bag.allow_item_move(player)
with self.assertRaises(ActionRefused):
key.insert(bag, player)
with self.assertRaises(ActionRefused):
key.remove(bag, player)
self.assertFalse(key in bag)
with self.assertRaises(ActionRefused):
bag in key
def test_clone(self):
item = Item("thing", "description")
item.aliases = ["a1", "a2"]
item2 = clone(item)
self.assertNotEqual(item, item2)
item2.aliases.append("a3")
self.assertNotEqual(item.aliases, item2.aliases)
player = Player("julie", "f")
player.insert(item, player)
with self.assertRaises(ValueError):
clone(player) # can't clone something with stuff in it
player.remove(item, player)
player2 = clone(player)
player2.insert(item2, player2)
self.assertNotEqual(player.inventory_size, player2.inventory_size)
self.assertNotEqual(player.inventory, player2.inventory)
self.assertFalse(item in player)
self.assertFalse(item in player2)
def test_clone(self):
item = Item("thing", "description")
item.aliases = ["a1", "a2"]
item2 = clone(item)
self.assertNotEqual(item, item2)
item2.aliases.append("a3")
self.assertNotEqual(item.aliases, item2.aliases)
player = Player("julie", "f")
player.insert(item, player)
with self.assertRaises(ValueError):
clone(player) # can't clone something with stuff in it
player.remove(item, player)
player2 = clone(player)
player2.insert(item2, player2)
self.assertNotEqual(player.inventory_size, player2.inventory_size)
self.assertNotEqual(player.inventory, player2.inventory)
self.assertFalse(item in player)
self.assertFalse(item in player2)
def test_inventory(self):
bag = Container("bag")
key = Item("key")
thing = Item("gizmo")
player = Player("julie", "f")
with self.assertRaises(ActionRefused):
thing in key # can't check for containment in an Item
self.assertFalse(thing in bag)
with self.assertRaises(ActionRefused):
key.insert(thing, player) # can't add stuf to an Item
bag.insert(thing, player)
self.assertTrue(thing in bag)
self.assertTrue(isinstance(bag.inventory, (set, frozenset)))
self.assertEqual(1, bag.inventory_size)
with self.assertRaises(AttributeError):
bag.inventory_size = 5
with self.assertRaises(AttributeError):
bag.inventory = None
with self.assertRaises(AttributeError):
bag.inventory.add(5)
def test_destroy_deferreds(self):
ctx = Context(driver=mud_context.driver,
clock=None,
config=None,
player_connection=None)
thing = Item("thing")
player = Player("julie", "f")
wolf = NPC("wolf", "m")
loc = Location("loc")
mud_context.driver.defer(datetime.datetime.now(), thing.move)
mud_context.driver.defer(datetime.datetime.now(), player.move)
mud_context.driver.defer(datetime.datetime.now(), wolf.move)
mud_context.driver.defer(datetime.datetime.now(), loc.move)
self.assertEqual(4, len(mud_context.driver.deferreds))
thing.destroy(ctx)
player.destroy(ctx)
wolf.destroy(ctx)
loc.destroy(ctx)
self.assertEqual(0, len(mud_context.driver.deferreds),
"all deferreds must be removed")
def test_inventory(self):
bag = Container("bag")
key = Item("key")
thing = Item("gizmo")
player = Player("julie", "f")
with self.assertRaises(ActionRefused):
thing in key # can't check for containment in an Item
self.assertFalse(thing in bag)
with self.assertRaises(ActionRefused):
key.insert(thing, player) # can't add stuf to an Item
bag.insert(thing, player)
self.assertTrue(thing in bag)
self.assertTrue(isinstance(bag.inventory, (set, frozenset)))
self.assertEqual(1, bag.inventory_size)
with self.assertRaises(AttributeError):
bag.inventory_size = 5
with self.assertRaises(AttributeError):
bag.inventory = None
with self.assertRaises(AttributeError):
bag.inventory.add(5)
def test_with_key(self):
player = Player("julie", "f")
key = Item("key", "door key")
key.door_code = 12345
hall = Location("hall")
door = Door("north", hall, "a locked door", locked=True, opened=False)
with self.assertRaises(ActionRefused):
door.unlock(player)
with self.assertRaises(ActionRefused):
door.unlock(player, key)
door.door_code = 12345
self.assertTrue(door.locked)
door.unlock(player, key)
self.assertFalse(door.locked)
door.locked = True
with self.assertRaises(ActionRefused):
door.unlock(player)
key.move(player, player)
door.unlock(player)
self.assertFalse(door.locked)
door.lock(player)
self.assertTrue(door.locked)
def test_container_contains(self):
bag = Container("bag")
key = Item("key")
self.assertEqual(0, len(bag.inventory))
self.assertEqual(0, bag.inventory_size)
npc = NPC("julie", "f")
bag.insert(key, npc)
self.assertTrue(key in bag)
self.assertEqual(1, bag.inventory_size)
bag.remove(key, npc)
self.assertEqual(0, bag.inventory_size)
self.assertFalse(key in bag)
with self.assertRaises(KeyError):
bag.remove("not_existing", npc)
def test_destroy_player(self):
ctx = Context(None, None, None, None)
loc = Location("loc")
player = Player("julie", "f")
player.privileges = {"wizard"}
player.create_wiretap(loc)
player.insert(Item("key"), player)
loc.init_inventory([player])
self.assertEqual(loc, player.location)
self.assertTrue(len(player.inventory) > 0)
self.assertTrue(player in loc.livings)
player.destroy(ctx)
import gc
gc.collect()
self.assertTrue(len(player.inventory) == 0)
self.assertFalse(player in loc.livings)
self.assertIsNone(player.location,
"destroyed player should end up nowhere (None)")
def test_destroy_loc(self):
ctx = Context(None, None, None, None)
loc = Location("loc")
i = Item("item")
liv = Living("rat", "n", race="rodent")
loc.add_exits([Exit("north", "somewhere", "exit to somewhere")])
player = Player("julie", "f")
player.privileges = {"wizard"}
player.create_wiretap(loc)
loc.init_inventory([i, liv, player])
self.assertTrue(len(loc.exits) > 0)
self.assertTrue(len(loc.items) > 0)
self.assertTrue(len(loc.livings) > 0)
self.assertEqual(loc, player.location)
self.assertEqual(loc, liv.location)
loc.destroy(ctx)
self.assertTrue(len(loc.exits) == 0)
self.assertTrue(len(loc.items) == 0)
self.assertTrue(len(loc.livings) == 0)
self.assertEqual(_limbo, player.location)
self.assertEqual(_limbo, liv.location)
def test_custom_verbs(self):
player = Player("julie", "f")
player.verbs["xywobble"] = "p1"
monster = NPC("snake", "f")
monster.verbs["snakeverb"] = "s1"
room = Location("room")
chair1 = Item("chair1")
chair1.verbs["frobnitz"] = "c1"
chair2 = Item("chair2")
chair2.verbs["frobnitz"] = "c2"
chair_in_inventory = Item("chair3")
chair_in_inventory.verbs["kowabooga"] = "c3"
box_in_inventory = Item("box")
box_in_inventory.verbs["boxverb"] = "c4"
player.init_inventory([box_in_inventory, chair_in_inventory])
exit = Exit("e", "dummy", None, None)
exit.verbs["exitverb"] = "c5"
room.init_inventory([chair1, player, chair2, monster])
room.add_exits([exit])
custom_verbs = mud_context.driver.current_custom_verbs(player)
all_verbs = mud_context.driver.current_verbs(player)
self.assertEqual({"xywobble", "snakeverb", "frobnitz", "kowabooga", "boxverb", "exitverb"}, set(custom_verbs))
self.assertEqual(set(), set(custom_verbs) - set(all_verbs))
def test_location(self):
thingy = Item("thing")
with self.assertRaises(TypeError):
thingy.location = "foobar"
hall = Location("hall")
thingy.location = hall
self.assertEqual(hall, thingy.contained_in)
self.assertEqual(hall, thingy.location)
person = Living("person", "m", race="human")
key = Item("key")
backpack = Container("backpack")
person.insert(backpack, person)
self.assertIsNone(key.contained_in)
self.assertIsNone(key.location)
self.assertTrue(backpack in person)
self.assertEqual(person, backpack.contained_in)
self.assertEqual(_limbo, backpack.location)
hall.init_inventory([person, key])
self.assertEqual(hall, key.contained_in)
self.assertEqual(hall, key.location)
self.assertEqual(hall, backpack.location)
key.move(backpack, person)
self.assertEqual(backpack, key.contained_in)
self.assertEqual(hall, key.location)
def test_allowance(self):
bag = Container("bag")
key = Item("key")
player = Player("julie", "f")
with self.assertRaises(Exception):
bag.insert(None, player)
bag.insert(key, player)
with self.assertRaises(KeyError):
bag.remove(None, player)
bag.remove(key, player)
bag.allow_item_move(player)
with self.assertRaises(ActionRefused):
key.insert(bag, player)
with self.assertRaises(ActionRefused):
key.remove(bag, player)
self.assertFalse(key in bag)
with self.assertRaises(ActionRefused):
bag in key
def setUp(self):
mud_context.driver = TestDriver()
mud_context.config = DemoStory()._get_config()
self.hall = Location("Main hall", "A very large hall.")
self.attic = Location("Attic", "A dark attic.")
self.street = Location("Street", "An endless street.")
e1 = Exit("up", self.attic, "A ladder leads up.")
e2 = Exit(
["door", "east"], self.street,
"A heavy wooden door to the east blocks the noises from the street outside."
)
self.hall.add_exits([e1, e2])
self.table = Item(
"table", "oak table",
"a large dark table with a lot of cracks in its surface")
self.key = Item("key",
"rusty key",
"an old rusty key without a label",
short_description="Someone forgot a key.")
self.magazine = Item("magazine", "university magazine")
self.magazine2 = Item("magazine", "university magazine")
self.rat = NPC("rat", "n", race="rodent")
self.rat2 = NPC("rat", "n", race="rodent")
self.fly = NPC("fly",
"n",
race="insect",
short_description="A fly buzzes around your head.")
self.julie = NPC("julie",
"f",
title="attractive Julie",
description="She's quite the looker.")
self.julie.aliases = {"chick"}
self.player = Player("player", "m")
self.pencil = Item("pencil", title="fountain pen")
self.pencil.aliases = {"pen"}
self.bag = Container("bag")
self.notebook_in_bag = Item("notebook")
self.bag.insert(self.notebook_in_bag, self.player)
self.player.insert(self.pencil, self.player)
self.player.insert(self.bag, self.player)
self.hall.init_inventory([
self.table, self.key, self.magazine, self.magazine2, self.rat,
self.rat2, self.julie, self.player, self.fly
])
def test_location(self):
thingy = Item("thing")
with self.assertRaises(TypeError):
thingy.location = "foobar"
hall = Location("hall")
thingy.location = hall
self.assertEqual(hall, thingy.contained_in)
self.assertEqual(hall, thingy.location)
person = Living("person", "m", race="human")
key = Item("key")
backpack = Container("backpack")
person.insert(backpack, person)
self.assertIsNone(key.contained_in)
self.assertIsNone(key.location)
self.assertTrue(backpack in person)
self.assertEqual(person, backpack.contained_in)
self.assertEqual(_Limbo, backpack.location)
hall.init_inventory([person, key])
self.assertEqual(hall, key.contained_in)
self.assertEqual(hall, key.location)
self.assertEqual(hall, backpack.location)
key.move(backpack, person)
self.assertEqual(backpack, key.contained_in)
self.assertEqual(hall, key.location)
def test_move(self):
hall = Location("hall")
person = Living("person", "m", race="human")
monster = Monster("dragon", "f", race="dragon")
key = Item("key")
stone = Item("stone")
hall.init_inventory([person, key])
stone.move(hall, person)
wiretap = Wiretap(hall)
self.assertTrue(person in hall)
self.assertTrue(key in hall)
key.contained_in = person # hack to force move to actually check the source container
with self.assertRaises(KeyError):
key.move(person, person)
key.contained_in = hall # put it back as it was
key.move(person, person)
self.assertFalse(key in hall)
self.assertTrue(key in person)
self.assertEqual([], wiretap.msgs, "item.move() should be silent")
with self.assertRaises(ActionRefused) as x:
key.move(monster, person)
self.assertTrue("not a good idea" in str(x.exception))
# creatures (NPCs) arriving in the shop.
# You could sniff the location's messages via a wiretap, but that often requires
# nasty string parsing because they are messages meant for humans really.
# We use pubsub to notify anyone interested.
if npc.name == "rat":
topic("shoppe-rat-arrival").send(npc)
def notify_player_arrived(self, player: Player,
previous_location: Location) -> None:
# same as above, but for players entering the scene
topic("shoppe-player-arrival").send(player)
# create the Olde Shoppe and its owner
shopinfo = ShopBehavior()
toothpick = Item("toothpick", "pointy wooden toothpick")
toothpick.value = 0.12
shopinfo.forsale.add(toothpick) # never run out of toothpicks
shopinfo.banks_money = True
shopkeeper = ShoppeShopkeeper(
"Lucy",
"f",
short_descr=
"Lucy, the shop owner, is looking happily at her newly arrived customer.")
shopkeeper.money = 14000
shop = Shoppe("Curiosity Shoppe", "A weird little shop. It sells odd stuff.")
shop.insert(shopkeeper, None)
shop.get_wiretap().subscribe(
shopkeeper
) # the shopkeeper wants to act on certain things happening in her shop.
shop.add_exits([
def test_title(self):
item = Item("key", "rusty old key")
self.assertEqual("key", item.name)
self.assertEqual("rusty old key", item.title)
self.assertEqual("", item.description)
[Exit(["w", "west"], "hallways.north_hallway", "The hallway to the west offers the possibility of escape.")]
)
class ForDummies(Note):
def init(self):
super(Note, self).init()
self._text = """
"Divide by 2" is scrawled in the margin of the book in your handwriting.
"""
def read(self, actor):
actor.tell(self.text)
cubby = Item("cubby", "study cubby")
cubby.add_extradesc(
{"cubby", "study cubby"},
"Your typical wooden study cubby. Generations of students in detention have scratched various messages into the aging wood. ",
)
cubby.add_extradesc(
{"scratches", "messages"}, "The cubby's wooden desk has a series of numbers freshly scratched into it: 16-32-64."
)
book = ForDummies("book", "dog-eared book")
book.add_extradesc(
{"book"},
"The book's title is Cryptography for Dummies. You remember skimming it during detention yesterday but that was a long time ago.",
)
book.aliases = {"library book", "cryptography book", "cryptography for dummies", "dog-eared book"}
def test_destroy_item(self):
thing = Item("thing")
ctx = Context(driver=mud_context.driver, clock=None, config=None, player_connection=None)
thing.destroy(ctx)
# register some custom verbs. You can redefine existing verbs, so be careful.
"clean": "Clean up the puke.",
"cover": "Clean up the puke."
# "put": "Put something on something else.",
}
vomit.add_extradesc(
{"puddle", "sick", "vomit", "puke"},
"""
Someone appears to have had tummy troubles; a puddle of sick lies in the middle of the corridor.
The puddle is . . . kinda gross. It was Salisbury Steak Day.
""",
)
south_hallway.init_inventory([vomit])
english_paper = Item("english homework", "english paper")
english_paper.aliases = {"english paper", "paper", "homework"}
english_paper.add_extradesc({"paper", "english paper", "homework"}, "You paid good money for this!")
class Locker(Boxlike):
def init(self, locked=True, opened=False, combo="8-16-32"):
super(Boxlike, self).init()
self.txt_title_closed = self._title
self.txt_title_open_filled = self._title
self.txt_title_open_empty = "empty " + self._title
self.txt_descr_closed = "The locker is closed."
self.txt_descr_open_filled = "There's something inside {}.".format(self._title)
self.txt_descr_open_empty = "There's nothing inside {}.".format(self._title)
self.locked = locked
self.opened = opened
def test_custom_verbs(self):
player = Player("julie", "f")
player.verbs["xywobble"] = "p1"
monster = NPC("snake", "f")
monster.verbs["snakeverb"] = "s1"
room = Location("room")
chair1 = Item("chair1")
chair1.verbs["frobnitz"] = "c1"
chair2 = Item("chair2")
chair2.verbs["frobnitz"] = "c2"
chair_in_inventory = Item("chair3")
chair_in_inventory.verbs["kowabooga"] = "c3"
box_in_inventory = Item("box")
box_in_inventory.verbs["boxverb"] = "c4"
player.init_inventory([box_in_inventory, chair_in_inventory])
exit = Exit("e", "dummy", None, None)
exit.verbs["exitverb"] = "c5"
room.init_inventory([chair1, player, chair2, monster])
room.add_exits([exit])
custom_verbs = mud_context.driver.current_custom_verbs(player)
all_verbs = mud_context.driver.current_verbs(player)
self.assertEqual(
{
"xywobble", "snakeverb", "frobnitz", "kowabooga", "boxverb",
"exitverb"
}, set(custom_verbs))
self.assertEqual(set(), set(custom_verbs) - set(all_verbs))
def test_insertremove(self):
key = Item("key")
thing = Item("gizmo")
player = Player("julie", "f")
with self.assertRaises(ActionRefused):
key.remove(None, player)
with self.assertRaises(ActionRefused):
key.remove(thing, player)
with self.assertRaises(ActionRefused):
key.insert(None, player)
with self.assertRaises(ActionRefused):
key.insert(thing, player)
key.allow_item_move(player)
with self.assertRaises(ActionRefused):
key.inventory
with self.assertRaises(ActionRefused):
key.inventory_size
def test_destroy_item(self):
thing = Item("thing")
ctx = Context(driver=mud_context.driver)
thing.destroy(ctx)
def test_lang(self):
thing = Item("thing")
self.assertEqual("it", thing.objective)
self.assertEqual("its", thing.possessive)
self.assertEqual("it", thing.subjective)
self.assertEqual("n", thing.gender)
class Glasses(Wearable):
def init(self, wearing=False):
super(Glasses, self).init()
self.wearing = wearing
def wearing_glasses(self):
while self.wearing:
pass
def vision_problems(self):
pass
glasses = Item("glasses", "glasses", "pair of ladies eyeglasses.")
glasses.aliases = {"glasses"}
glasses.add_extradesc({"glasses"}, "The horn-rimmed glasses aren't really your style.")
glasses_case = GlassesCase("case", "clamshell case for eyeglasses")
glasses_case.aliases = {"case", "clamshell case", "eyeglasses case"}
glasses_case.init_inventory([glasses])
gym.init_inventory([glasses_case])
freshman = NPC("freshman", "m", title="freshman", description="It's a freshman. They all look the same.")
# sawdust = Item("sawdust", "sawdust")
# sawdust.add_extradesc({"sawdust", "pink sawdust"}, "It's pink sawdust, the kind used to soak up spills and messes.")
# bucket = Container("bucket", "bucket")
# Using this notification override his is the best way to react to a certain
# creatures (NPCs) arriving in the shop.
# You could sniff the location's messages via a wiretap, but that often requires
# nasty string parsing because they are messages meant for humans really.
# We use pubsub to notify anyone interested.
if npc.name == "rat":
topic("shoppe-rat-arrival").send(npc)
def notify_player_arrived(self, player: Player, previous_location: Location) -> None:
# same as above, but for players entering the scene
topic("shoppe-player-arrival").send(player)
# create the Olde Shoppe and its owner
shopinfo = ShopBehavior()
toothpick = Item("toothpick", "pointy wooden toothpick")
toothpick.value = 0.12
shopinfo.forsale.add(toothpick) # never run out of toothpicks
shopinfo.banks_money = True
shopkeeper = ShoppeShopkeeper("Lucy", "f", short_descr="Lucy, the shop owner, is looking happily at her newly arrived customer.")
shopkeeper.money = 14000
shop = Shoppe("Curiosity Shoppe", "A weird little shop. It sells odd stuff.")
shop.insert(shopkeeper, None)
shop.get_wiretap().subscribe(shopkeeper) # the shopkeeper wants to act on certain things happening in her shop.
shop.add_exits([Exit(["door", "out"], "town.lane", "A fancy door provides access back to the lane outside.")])
# provide some items in the shop
clock = gameclock.clone()
clock.value = 500
paper = newspaper.clone()
deli = Location(
"Deli",
"A deli. It is completely empty, all the food and items seem to be gone.")
Exit.connect(deli, ["lake drive", "outside", "street", "back"],
"Lake drive is the street you came from.", None, street1,
["deli", "east"], "The east end of the street leads to a deli.",
None)
Exit.connect(lot, ["back"], "Go back home.", None, street1, ["lot", "parking"],
"There is a parking lot next to the deli.", None)
zombie = w = Zombie("zombie",
random.choice("mf"),
descr="A bloody zombie lingering around.")
street1.insert(zombie, None)
trader = Trader("Creepy Trader", "m", title="Creepy Trader")
trader.extra_desc[
"bullets"] = "It is a a box of rounds with 5 bullets in it for your gun."
trader.extra_desc["ammo"] = trader.extra_desc["bullets"]
trader.aliases.add("trader")
# ammo
ammo = Item("ammo",
"5 pistol bullets",
descr="It looks like the ammo for your gun.")
ammo.value = Trader.ammo_price
ammo.aliases = {"bullets", "ammo"}
trader.init_inventory([ammo])
deli.insert(trader, None)
from tale.base import Location, Exit, Item, heartbeat
from tale.npc import NPC
import tale.lang
def init(driver):
# called when zone is first loaded
pass
hall = Location("Main hall of the Tower of Magic",
"""
The main hall of this ancient wizard tower sparkles with traces of magic.
Everything seems to glow a little from within. You can hear a very faint hum.
""")
table = Item("table", "oak table", "A large dark table with a lot of cracks in its surface.")
key = Item("key", "rusty key", "An old rusty key without a label.")
@heartbeat
class Drone(NPC):
def heartbeat(self, ctx):
rand = random.random()
if rand < 0.07:
self.do_socialize("twitch erra")
elif rand < 0.14:
self.do_socialize("rotate random")
elif rand < 0.21:
self.location.tell("%s hums softly." % tale.lang.capital(self.title))
Door.connect(street2,
["north", "gate", "playground"],
"To the north there is a small gate that connects to the children's playground.", None,
rose_st.playground,
["gate", "south"],
"The gate that leads back to Magnolia Street is south.", None)
Exit.connect(street2, ["south", "house", "neighbors"], "You can see the house from the neighbors across the street, to the south.", None,
houses.neighbors_house, ["street", "north"], "The street is back north.", None)
street2.add_exits([
Exit(["east", "crossing"], "rose_st.crossing", "There's a crossing to the east."),
])
street3.add_exits([
Exit(["west", "crossing"], "rose_st.crossing", "There's a crossing to the west.")
])
apothecary = Apothecary("carla", "f", title="apothecary Carla")
apothecary.extra_desc["bottle"] = "It is a small bottle of the pills that your friend Peter needs for his illness."
apothecary.extra_desc["pills"] = apothecary.extra_desc["bottle"]
apothecary.aliases.add("apothecary")
# the medicine Peter needs
medicine = Item("pills", "bottle of pills", descr="It looks like the medicine your friend Peter needs for his illness.")
medicine.value = Apothecary.pills_price
medicine.aliases = {"bottle", "medicine"}
apothecary.init_inventory([medicine])
pharmacy.insert(apothecary, None)
def make_item(vnum):
"""Create an instance of an item for the given vnum"""
c_obj = objs[vnum]
aliases = list(c_obj.aliases)
name = aliases[0]
aliases = set(aliases[1:])
title = c_obj.shortdesc
if title.startswith("the ") or title.startswith("The "):
title = title[4:]
if title.startswith("a ") or title.startswith("A "):
title = title[2:]
if vnum in circle_bulletin_boards:
# it's a bulletin board
item = BulletinBoard(name, title, short_description=c_obj.longdesc)
item.storage_file = circle_bulletin_boards[
vnum] # note that some instances reuse the same board
item.load()
# remove the item name from the extradesc
c_obj.extradesc = [
ed for ed in c_obj.extradesc if item.name not in ed["keywords"]
]
elif c_obj.type == "container":
if c_obj.typespecific.get("closeable"):
item = Boxlike(name, title, short_description=c_obj.longdesc)
item.opened = True
if "closed" in c_obj.typespecific:
item.opened = not c_obj.typespecific["closed"]
else:
item = Container(name, title, short_description=c_obj.longdesc)
elif c_obj.type == "weapon":
item = Weapon(name, title, short_description=c_obj.longdesc)
# @todo weapon attrs
elif c_obj.type == "armor":
item = Armour(name, title, short_description=c_obj.longdesc)
# @todo armour attrs
elif c_obj.type == "key":
item = Key(name, title, short_description=c_obj.longdesc)
item.key_for(code=vnum) # the key code is just the item's vnum
elif c_obj.type == "note": # doesn't yet occur in the obj files though
item = Note(name, title, short_description=c_obj.longdesc)
elif c_obj.type == "food":
item = Food(name, title, short_description=c_obj.longdesc)
item.affect_fullness = c_obj.typespecific["filling"]
item.poisoned = c_obj.typespecific.get("ispoisoned", False)
elif c_obj.type == "light":
item = Light(name, title, short_description=c_obj.longdesc)
item.capacity = c_obj.typespecific["capacity"]
elif c_obj.type == "scroll":
item = Scroll(name, title, short_description=c_obj.longdesc)
item.spell_level = c_obj.typespecific["level"]
item.spells.add(c_obj.typespecific["spell1"])
if "spell2" in c_obj.typespecific:
item.spells.add(c_obj.typespecific["spell2"])
if "spell3" in c_obj.typespecific:
item.spells.add(c_obj.typespecific["spell3"])
elif c_obj.type in ("staff", "wand"):
item = MagicItem(name, title, short_description=c_obj.longdesc)
item.level = c_obj.typespecific["level"]
item.capacity = c_obj.typespecific["capacity"]
item.remaining = c_obj.typespecific["remaining"]
item.spell = c_obj.typespecific["spell"]
elif c_obj.type == "trash":
item = Trash(name, title, short_description=c_obj.longdesc)
elif c_obj.type == "drinkcontainer":
item = Drink(name, title, short_description=c_obj.longdesc)
item.capacity = c_obj.typespecific["capacity"]
item.quantity = c_obj.typespecific["remaining"]
item.contents = c_obj.typespecific["drinktype"]
drinktype = Drink.drinktypes[item.contents]
item.affect_drunkness = drinktype.drunkness
item.affect_fullness = drinktype.fullness
item.affect_thirst = drinktype.thirst
item.poisoned = c_obj.typespecific.get("ispoisoned", False)
elif c_obj.type == "potion":
item = Potion(name, title, short_description=c_obj.longdesc)
item.spell_level = c_obj.typespecific["level"]
item.spells.add(c_obj.typespecific["spell1"])
if "spell2" in c_obj.typespecific:
item.spells.add(c_obj.typespecific["spell2"])
if "spell3" in c_obj.typespecific:
item.spells.add(c_obj.typespecific["spell3"])
elif c_obj.type == "money":
item = Money(name, title, short_description=c_obj.longdesc)
item.value = c_obj.typespecific["amount"]
elif c_obj.type == "boat":
item = Boat(name, title, short_description=c_obj.longdesc)
elif c_obj.type == "worn":
item = Wearable(name, title, short_description=c_obj.longdesc)
# @todo worn attrs
elif c_obj.type == "fountain":
item = Fountain(name, title, short_description=c_obj.longdesc)
item.capacity = c_obj.typespecific["capacity"]
item.quantity = c_obj.typespecific["remaining"]
item.contents = c_obj.typespecific["drinktype"]
item.poisoned = c_obj.typespecific.get("ispoisoned", False)
elif c_obj.type in ("treasure", "other"):
item = Item(name, title, short_description=c_obj.longdesc)
else:
raise ValueError("invalid obj type: " + c_obj.type)
for ed in c_obj.extradesc:
item.add_extradesc(ed["keywords"], ed["text"])
item.vnum = vnum # keep the vnum
item.aliases = aliases
item.value = c_obj.cost
item.rent = c_obj.rent
item.weight = c_obj.weight
# @todo: affects, effects, wear
converted_items.add(vnum)
return item
def test_insertremove(self):
key = Item("key")
thing = Item("gizmo")
player = Player("julie", "f")
with self.assertRaises(ActionRefused):
key.remove(None, player)
with self.assertRaises(ActionRefused):
key.remove(thing, player)
with self.assertRaises(ActionRefused):
key.insert(None, player)
with self.assertRaises(ActionRefused):
key.insert(thing, player)
key.allow_item_move(player)
with self.assertRaises(ActionRefused):
key.inventory
with self.assertRaises(ActionRefused):
key.inventory_size
def test_move(self):
hall = Location("hall")
person = Living("person", "m", race="human")
monster = NPC("dragon", "f", race="dragon")
monster.aggressive = True
key = Item("key")
stone = Item("stone")
hall.init_inventory([person, key])
stone.move(hall, person)
wiretap = Wiretap(hall)
self.assertTrue(person in hall)
self.assertTrue(key in hall)
key.contained_in = person # hack to force move to actually check the source container
with self.assertRaises(KeyError):
key.move(person, person)
key.contained_in = hall # put it back as it was
key.move(person, person)
self.assertFalse(key in hall)
self.assertTrue(key in person)
self.assertEqual([], wiretap.msgs, "item.move() should be silent")
with self.assertRaises(ActionRefused) as x:
key.move(monster, person) # aggressive monster should fail
self.assertTrue("not a good idea" in str(x.exception))
monster.aggressive = False
key.move(monster, person) # non-aggressive should be ok
# define items and NPCs
class Cat(NPC):
def init(self):
self.aliases={"cat"}
mud_context.driver.defer(4, self, self.do_purr)
def do_purr(self, driver):
if random.random() > 0.5:
self.location.tell("%s purrs happily." % capital(self.title))
else:
self.location.tell("%s yawns sleepily." % capital(self.title))
driver.defer(random.randint(5, 20), self, self.do_purr)
def notify_action(self, parsed, actor):
if parsed.verb in ("pet", "stroke", "tickle", "cuddle", "hug"):
self.tell_others("{Title} curls up in a ball and purrs contently.")
elif parsed.verb in ("hello", "hi", "greet"):
self.tell_others("{Title} stares at you incomprehensibly.")
else:
message = (parsed.message or parsed.unparsed).lower()
if self.name in message:
self.tell_others("{Title} looks up at you.")
cat = Cat("garfield", "m", race="cat", description="A very obese cat, orange and black. It looks tired, but glances at you happily.")
livingroom.insert(cat, None)
key = Item("key", "small rusty key", "This key is small and rusty. It has a label attached, reading \"garden door\".")
key.door_code = 1
closet.insert(key, None)
def remove(self, item, actor):
raise ActionRefused("The box is cursed! You can't take anything out of it!")
class RemoveOnlyBox(Container):
def insert(self, item, actor):
raise ActionRefused("No matter how hard you try, you can't fit %s in the box." % item.title)
insertonly_box = InsertOnlyBox("box1", "box1 (a black box)")
removeonly_box = RemoveOnlyBox("box2", "box2 (a white box)")
normal_gem = clone(gem)
removeonly_box.init_inventory([normal_gem])
cursed_gem = CursedGem("black gem", "a black gem")
cursed_gem.aliases={"gem"}
normal_gem = Item("blue gem", "a blue gem")
normal_gem.aliases={"gem"}
lane.add_exits([Exit("south", square, "The town square lies to the south.")])
class WizardTowerEntry(Exit):
def allow_passage(self, actor):
if "wizard" in actor.privileges:
actor.tell("You pass through the force-field.")
else:
raise ActionRefused("You can't go that way, the force-field is impenetrable.")
lane.add_exits([WizardTowerEntry("west", "wizardtower.hall", "To the west is the wizard's tower. It seems to be protected by a force-field.")])
towncrier = TownCrier("laish", "f", title="Laish the town crier", description="The town crier of Essglen is awfully quiet today. She seems rather preoccupied with something.")
class RemoveOnlyBox(Container):
def insert(self, item: Union[Living, Item],
actor: Optional[Living]) -> None:
raise ActionRefused(
"No matter how hard you try, you can't fit %s in the box." %
item.title)
insertonly_box = InsertOnlyBox("box1", "box1 (a black box)")
removeonly_box = RemoveOnlyBox("box2", "box2 (a white box)")
normal_gem = gem.clone()
removeonly_box.init_inventory([normal_gem])
cursed_gem = CursedGem("black gem")
cursed_gem.aliases = {"gem"}
normal_gem = Item("blue gem")
normal_gem.aliases = {"gem"}
lane.add_exits([
Exit(["shop", "north east", "northeast", "ne"], "shoppe.shop",
"There's a curiosity shop to the north-east.")
])
class WizardTowerEntry(Exit):
def allow_passage(self, actor: Living) -> None:
if "wizard" in actor.privileges:
actor.tell("You pass through the force-field.", end=True)
else:
raise ActionRefused(
"You can't go that way, the force-field is impenetrable.")
"You can see the house from the neighbors across the street, to the south.",
None, houses.neighbors_house, ["street", "north"],
"The street is back north.", None)
street2.add_exits([
Exit(["east", "crossing"], "rose_st.crossing",
"There's a crossing to the east."),
])
street3.add_exits([
Exit(["west", "crossing"], "rose_st.crossing",
"There's a crossing to the west.")
])
apothecary = Apothecary("carla", "f", title="apothecary Carla")
apothecary.extra_desc[
"bottle"] = "It is a small bottle of the pills that your friend Peter needs for his illness."
apothecary.extra_desc["pills"] = apothecary.extra_desc["bottle"]
apothecary.aliases.add("apothecary")
# the medicine Peter needs
medicine = Item(
"pills",
"bottle of pills",
descr="It looks like the medicine your friend Peter needs for his illness."
)
medicine.value = Apothecary.pills_price
medicine.aliases = {"bottle", "medicine"}
apothecary.init_inventory([medicine])
pharmacy.insert(apothecary, None)
