def kill_player(self, player: Player, ctx: Context) -> None:
# player can only be killed if she is still here, obviously
if self.attacking and player in self.location.livings:
player.tell_text_file(
ctx.resources["messages/completion_failed.txt"])
raise StoryCompleted
self.attacking = False
def test_with_key(self):
player = Player("julie", "f")
key = Key("key", "door key")
key.key_for(code=12345)
hall = Location("hall")
door = Door("north", hall, "a locked door", locked=True, opened=False)
door2 = Door("south", hall, "another locked door", locked=True, opened=False)
with self.assertRaises(ActionRefused):
door.unlock(player)
with self.assertRaises(ActionRefused):
door.unlock(player, key)
door.key_code = 12345
door2.key_code = 9999
key.key_for(door)
self.assertTrue(door.locked)
door.unlock(player, key)
self.assertFalse(door.locked)
with self.assertRaises(ActionRefused):
door2.unlock(key)
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)
door.unlock(player)
player.remove(key, player)
with self.assertRaises(ActionRefused):
door.lock(player)
door.key_code = None
with self.assertRaises(LocationIntegrityError):
key.key_for(door)
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_move_notify(self):
class LocationNotify(Location):
def notify_npc_left(self, npc, target_location):
self.npc_left = npc
self.npc_left_target = target_location
def notify_npc_arrived(self, npc, previous_location):
self.npc_arrived = npc
self.npc_arrived_from = previous_location
def notify_player_left(self, player, target_location):
self.player_left = player
self.player_left_target = target_location
def notify_player_arrived(self, player, previous_location):
self.player_arrived = player
self.player_arrived_from = previous_location
player = Player("julie", "f")
room1 = LocationNotify("room1")
room2 = LocationNotify("room2")
room1.insert(player, player)
player.move(room2)
pubsub.sync()
self.assertEqual(room2, player.location)
self.assertEqual(player, room1.player_left)
self.assertEqual(room2, room1.player_left_target)
self.assertEqual(player, room2.player_arrived)
self.assertEqual(room1, room2.player_arrived_from)
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_move_notify(self):
class LocationNotify(Location):
def notify_npc_left(self, npc, target_location):
self.npc_left = npc
self.npc_left_target = target_location
def notify_npc_arrived(self, npc, previous_location):
self.npc_arrived = npc
self.npc_arrived_from = previous_location
def notify_player_left(self, player, target_location):
self.player_left = player
self.player_left_target = target_location
def notify_player_arrived(self, player, previous_location):
self.player_arrived = player
self.player_arrived_from = previous_location
player = Player("julie", "f")
room1 = LocationNotify("room1")
room2 = LocationNotify("room2")
room1.insert(player, player)
player.move(room2)
pubsub.sync()
self.assertEqual(room2, player.location)
self.assertEqual(player, room1.player_left)
self.assertEqual(room2, room1.player_left_target)
self.assertEqual(player, room2.player_arrived)
self.assertEqual(room1, room2.player_arrived_from)
def test_write_output(self):
player = Player("julie", "f")
with WrappedConsoleIO(None) as io:
pc = PlayerConnection(player, io)
player.tell("hello 1", end=True)
player.tell("hello 2", end=True)
pc.write_output()
self.assertEqual(" hello 2", pc.last_output_line)
self.assertEqual(" hello 1\n hello 2\n", sys.stdout.getvalue())
def welcome(self, player: Player) -> str:
"""
Welcome text when player enters a new game
If you return a string, it is used as an input prompt before continuing (a pause).
"""
player.tell("<bright>Hello, %s!</> Welcome to the land of `%s'. May your visit here be... interesting."
% (player.title, self.config.name), end=True)
player.tell("--", end=True)
return ""
def test_tell_emptystring(self):
player = Player("fritz", "m")
player.tell("", end=False)
self.assertEqual([], player.test_get_output_paragraphs())
player.tell("", end=True)
self.assertEqual(["\n"], player.test_get_output_paragraphs())
player.tell("", end=True)
player.tell("", end=True)
self.assertEqual(["\n", "\n"], player.test_get_output_paragraphs())
def test_input(self):
player = Player("julie", "f")
with WrappedConsoleIO(None) as io:
pc = PlayerConnection(player, io)
player.tell("first this text")
player.store_input_line(" input text \n")
x = pc.input_direct("inputprompt")
self.assertEqual("input text", x)
self.assertEqual(" first this text\ninputprompt ", sys.stdout.getvalue()) # should have outputted the buffered text
def notify_player_arrived(self, player: Player,
previous_location: Location) -> None:
# player has entered, and thus the story ends
player.tell("\n")
player.tell("\n")
player.tell(
"<bright>Congratulations on escaping the house!</> Someone else has to look after Garfield now though..."
)
raise StoryCompleted
def test_write_output(self):
player = Player("julie", "f")
with WrappedConsoleIO(None) as io:
pc = PlayerConnection(player, io)
player.tell("hello 1", end=True)
player.tell("hello 2", end=True)
pc.write_output()
self.assertEqual(" hello 2", pc.last_output_line)
self.assertEqual(" hello 1\n hello 2\n", sys.stdout.getvalue())
def test_init(self):
player = Player("fritz", "m")
player.title = "Fritz the great"
self.assertEqual("fritz", player.name)
self.assertEqual("Fritz the great", player.title)
self.assertEqual("", player.description)
self.assertEqual("human", player.race)
self.assertEqual("m", player.gender)
self.assertEqual(set(), player.privileges)
self.assertTrue(1 < player.stats["agi"] < 100)
def test_peek_output(self):
player = Player("fritz", "m")
pc = PlayerConnection(player, ConsoleIo(None))
player.set_screen_sizes(0, 100)
player.tell("line1")
player.tell("line2", 42)
self.assertEqual(["line1\nline2 42\n"],
player.test_peek_output_paragraphs())
self.assertEqual("line1 line2 42\n", pc.get_output())
self.assertEqual([], player.test_peek_output_paragraphs())
def welcome(self, player: Player) -> Optional[str]:
"""
Welcome text when player enters a new game
If you return a string, it is used as an input prompt before continuing (a pause).
"""
player.tell(
"<bright>Hello, %s!</> Welcome to the land of `%s'. May your visit here be... interesting."
% (player.title, self.config.name),
end=True)
player.tell("--", end=True)
return None
def test_init(self):
player = Player("fritz", "m")
player.title = "Fritz the great"
self.assertEqual("fritz", player.name)
self.assertEqual("Fritz the great", player.title)
self.assertEqual("", player.description)
self.assertEqual("human", player.stats.race)
self.assertEqual("m", player.gender)
self.assertEqual(set(), player.privileges)
self.assertTrue(1 < player.stats.agi < 100)
self.assertGreater(player.output_line_delay, 1)
def test_idle(self):
p = Player("dummy", "f")
c = PlayerConnection(p, WrappedConsoleIO(None))
self.assertLess(p.idle_time, 0.1)
self.assertLess(c.idle_time, 0.1)
time.sleep(0.2)
self.assertGreater(p.idle_time, 0.1)
self.assertGreater(c.idle_time, 0.1)
p.store_input_line("input")
self.assertLess(p.idle_time, 0.1)
self.assertLess(c.idle_time, 0.1)
def test_init(self):
player = Player("fritz", "m")
player.title = "Fritz the great"
self.assertEqual("fritz", player.name)
self.assertEqual("Fritz the great", player.title)
self.assertEqual("", player.description)
self.assertEqual("human", player.stats.race)
self.assertEqual("m", player.gender)
self.assertEqual(set(), player.privileges)
self.assertTrue(1 < player.stats.agi < 100)
self.assertGreater(player.output_line_delay, 1)
def test_idle(self):
p = Player("dummy", "f")
c = PlayerConnection(p, WrappedConsoleIO(None))
self.assertLess(p.idle_time, 0.1)
self.assertLess(c.idle_time, 0.1)
time.sleep(0.2)
self.assertGreater(p.idle_time, 0.1)
self.assertGreater(c.idle_time, 0.1)
p.store_input_line("input")
self.assertLess(p.idle_time, 0.1)
self.assertLess(c.idle_time, 0.1)
def test_peek_output(self):
player = Player("fritz", "m")
pc = PlayerConnection(player, ConsoleIo(None))
player.set_screen_sizes(0, 100)
player.tell("line1")
player.tell("line2", 42)
self.assertEqual(["line1\nline2 42\n"], player.test_peek_output_paragraphs())
self.assertEqual("line1 line2 42\n", pc.get_output())
self.assertEqual([], player.test_peek_output_paragraphs())
def test_tell_sep(self):
player = Player("fritz", "m")
pc = PlayerConnection(player, ConsoleIo(None))
player.set_screen_sizes(0, 10)
player.tell("apple", "bee", "zinc", "rose")
self.assertEqual(["apple bee zinc rose\n"],
player.test_get_output_paragraphs())
pc.get_output()
player.tell("apple", "bee", "zinc", "rose", format=False)
self.assertEqual("apple\nbee\nzinc\nrose\n", pc.get_output())
def welcome(self, player: Player) -> Optional[str]:
"""welcome text when player enters a new game"""
player.tell("<bright>Hello, %s! Welcome to %s.</>" % (player.title, self.config.name), end=True)
player.tell("\n")
player.tell(self.driver.resources["messages/welcome.txt"].text)
player.tell("\n")
return None
def welcome(self, player: Player) -> str:
player.tell("<bright>Welcome to `%s'.</>" % self.config.name, end=True)
player.tell("This is a tiny embedded story to check out a running Tale environment.")
player.tell("Try to communicate with your pet, and exit the house to win the game.")
player.tell("\n")
player.tell("\n")
return ""
def welcome_savegame(self, player: Player) -> Optional[str]:
"""welcome text when player enters the game after loading a saved game"""
player.tell("<bright>Hello %s, welcome back to %s.</>" % (player.title, self.config.name), end=True)
player.tell("\n")
player.tell(self.driver.resources["messages/welcome.txt"].text)
player.tell("\n")
return None
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 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_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_complete_one(self):
player = Player("fritz", "m")
driver = TestDriver()
conn = PlayerConnection(player)
io = IoAdapterBase(conn)
conn.io = io
self.assertEqual(["criticize"], io.tab_complete("critic", driver))
def test_init(self):
player = Player("fritz", "m")
player.title = "Fritz the great"
self.assertEqual("fritz", player.name)
self.assertEqual("Fritz the great", player.title)
self.assertEqual("", player.description)
self.assertEqual("human", player.stats.race)
self.assertEqual("m", player.gender)
self.assertEqual("m", player.stats.gender)
self.assertEqual("he", player.subjective)
self.assertEqual(set(), player.privileges)
self.assertGreater(player.output_line_delay, 1)
player.init_gender("f")
self.assertEqual("f", player.gender)
self.assertEqual("f", player.stats.gender)
self.assertEqual("she", player.subjective)
def test_tell_sep(self):
player = Player("fritz", "m")
pc = PlayerConnection(player, ConsoleIo(None))
player.set_screen_sizes(0, 10)
player.tell("apple", "bee", "zinc", "rose")
self.assertEqual(["apple bee zinc rose\n"], player.test_get_output_paragraphs())
pc.get_output()
player.tell("apple", "bee", "zinc", "rose", format=False)
self.assertEqual("apple\nbee\nzinc\nrose\n", pc.get_output())
def test_others(self):
attic = Location("Attic", "A dark attic.")
player = Player("merlin", "m")
player.title = "wizard Merlin"
julie = MsgTraceNPC("julie", "f", "human")
fritz = MsgTraceNPC("fritz", "m", "human")
julie.move(attic, silent=True)
fritz.move(attic, silent=True)
player.move(attic, silent=True)
player.tell_others("one", "two", "three")
self.assertEqual([], player.test_get_output_paragraphs())
self.assertEqual(["one", "two", "three"], fritz.messages)
self.assertEqual(["one", "two", "three"], julie.messages)
fritz.clearmessages()
julie.clearmessages()
player.tell_others("{title} and {Title}")
self.assertEqual(["wizard Merlin and Wizard Merlin"], fritz.messages)
def welcome(self, player: Player) -> str:
"""
Welcome text when player enters a new game
If you return a string, it is used as an input prompt before continuing (a pause).
"""
player.tell("<bright>Welcome to `%s'.</>" % self.config.name, end=True)
player.tell("\n")
player.tell_text_file(self.driver.resources["messages/welcome.txt"])
player.tell("\n")
return "<bright>Press enter to continue.</>"
def welcome_savegame(self, player: Player) -> str:
"""
Welcome text when player enters the game after loading a saved game
If you return a string, it is used as an input prompt before continuing (a pause).
"""
player.tell("<bright>Welcome back to `%s'.</>" % self.config.name, end=True)
player.tell("\n")
player.tell_text_file(self.driver.resources["messages/welcome.txt"])
player.tell("\n")
return "<bright>Press enter to continue where you were before.</>"
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 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 welcome(self, player: Player) -> str:
player.tell("<bright>Welcome to `%s'.</>" % self.config.name, end=True)
player.tell(
"This is a tiny embedded story to check out a running Tale environment."
)
player.tell(
"Try to communicate with your pet, and exit the house to win the game."
)
player.tell("\n")
player.tell("\n")
return ""
def test_notify(self):
room = Location("room")
room2 = Location("room2")
player = Player("julie", "f")
room.notify_player_arrived(player, room2)
room.notify_player_left(player, room2)
room.notify_npc_arrived(player, room2)
room.notify_npc_left(player, room2)
parsed = ParseResult("verb")
room.notify_action(parsed, player)
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_others(self):
attic = Location("Attic", "A dark attic.")
player = Player("merlin", "m")
player.title = "wizard Merlin"
julie = MsgTraceNPC("julie", "f", "human")
fritz = MsgTraceNPC("fritz", "m", "human")
julie.move(attic, silent=True)
fritz.move(attic, silent=True)
player.move(attic, silent=True)
player.tell_others("one", "two", "three")
self.assertEqual([], player.test_get_output_paragraphs())
self.assertEqual(["one", "two", "three"], fritz.messages)
self.assertEqual(["one", "two", "three"], julie.messages)
fritz.clearmessages()
julie.clearmessages()
player.tell_others("{title} and {Title}")
self.assertEqual(["wizard Merlin and Wizard Merlin"], fritz.messages)
def test_destroy_loc(self):
ctx = Context()
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_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_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_complete_c(self):
player = Player("fritz", "m")
driver = TestDriver()
conn = PlayerConnection(player)
io = IoAdapterBase(conn)
conn.io = io
result = io.tab_complete("c", driver)
self.assertGreater(len(result), 20)
self.assertTrue("cackle" in result)
self.assertTrue("criticize" in result)
result = io.tab_complete("h", driver)
self.assertGreater(len(result), 10)
self.assertTrue("hiss" in result)
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_input(self):
player = Player("julie", "f")
player.prompt_toolkit_enabled = False
with WrappedConsoleIO(None) as io:
pc = PlayerConnection(player, io)
player.tell("first this text")
player.store_input_line(" input text \n")
x = pc.input_direct("inputprompt")
self.assertEqual("input text", x)
self.assertEqual(" first this text\ninputprompt ",
sys.stdout.getvalue()
) # should have outputted the buffered text
def test_with_key(self):
player = Player("julie", "f")
key = Key("key", "door key")
key.key_for(code=12345)
hall = Location("hall")
door = Door("north", hall, "a locked door", locked=True, opened=False)
door2 = Door("south",
hall,
"another locked door",
locked=True,
opened=False)
with self.assertRaises(ActionRefused):
door.unlock(player)
with self.assertRaises(ActionRefused):
door.unlock(player, key)
door.key_code = 12345
door2.key_code = 9999
key.key_for(door)
self.assertTrue(door.locked)
door.unlock(player, key)
self.assertFalse(door.locked)
with self.assertRaises(ActionRefused):
door2.unlock(key)
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)
door.unlock(player)
player.remove(key, player)
with self.assertRaises(ActionRefused):
door.lock(player)
door.key_code = None
with self.assertRaises(LocationIntegrityError):
key.key_for(door)
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_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):
util.print_object_location(p, None, None)
util.print_object_location(p, key, None)
self.assertEqual(["(It's not clear where key is).\n"], p.test_get_output_paragraphs())
util.print_object_location(p, key, None, print_parentheses=False)
self.assertEqual(["It's not clear where key is.\n"], p.test_get_output_paragraphs())
util.print_object_location(p, key, bag)
result = "".join(p.test_get_output_paragraphs())
self.assertTrue("in bag" in result and "in your inventory" in result)
util.print_object_location(p, key, room)
self.assertTrue("in your current location" in "".join(p.test_get_output_paragraphs()))
util.print_object_location(p, bag, p)
self.assertTrue("in your inventory" in "".join(p.test_get_output_paragraphs()))
util.print_object_location(p, p, room)
self.assertTrue("in your current location" in "".join(p.test_get_output_paragraphs()))
def test_input(self):
player = Player("julie", "f")
player.io = ConsoleIo(None)
old_stdout = sys.stdout
sys.stdout = StringIO()
try:
player.tell("first this text")
player.store_input_line("input text\n")
x = player.input("inputprompt")
self.assertEqual("input text", x)
self.assertEqual(" first this text\ninputprompt", sys.stdout.getvalue()) # should have outputted the buffered text
finally:
sys.stdout = old_stdout
def test_destroy_player(self):
ctx = Context()
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_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_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_write_output(self):
player = Player("julie", "f")
player.io = ConsoleIo(None)
old_stdout = sys.stdout
sys.stdout = StringIO()
try:
player.tell("hello 1", end=True)
player.tell("hello 2", end=True)
player.write_output()
self.assertEqual(" hello 1\n hello 2\n", sys.stdout.getvalue())
finally:
sys.stdout = old_stdout
def spawn_cvnum(player: Player, parsed: ParseResult, ctx: util.Context) -> None:
"""Spawn an item or monster with the given circle-vnum (or both if the circle-vnum is the same)."""
if len(parsed.args) != 1:
raise ParseError("You have to give the item or monster's circle-vnum.")
vnum = int(parsed.args[0])
try:
item = make_item(vnum)
except KeyError:
player.tell("There's no item with that circle-vnum.")
else:
player.tell("Spawned " + repr(item) + " (into your inventory)")
item.move(player, actor=player)
try:
mob = make_mob(vnum)
except KeyError:
player.tell("There's no monster with that circle-vnum.")
else:
player.tell("Spawned " + repr(mob) + " (into your current location)")
mob.move(player.location, actor=player)
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):
util.print_object_location(p, None, None)
util.print_object_location(p, key, None)
self.assertEqual(["(It's not clear where key is).\n"], p.test_get_output_paragraphs())
util.print_object_location(p, key, None, print_parentheses=False)
self.assertEqual(["It's not clear where key is.\n"], p.test_get_output_paragraphs())
util.print_object_location(p, key, bag)
result = "".join(p.test_get_output_paragraphs())
self.assertTrue("in bag" in result and "in your inventory" in result)
util.print_object_location(p, key, room)
self.assertTrue("in your current location" in "".join(p.test_get_output_paragraphs()))
util.print_object_location(p, bag, p)
self.assertTrue("in your inventory" in "".join(p.test_get_output_paragraphs()))
util.print_object_location(p, p, room)
self.assertTrue("in your current location" in "".join(p.test_get_output_paragraphs()))
def show_cvnum(player: Player, parsed: ParseResult, ctx: util.Context) -> None:
"""Show the circle-vnum of a location (.) or an object/living,
or when you provide a circle-vnum as arg, show the object(s) with that circle-vnum."""
if not parsed.args:
raise ParseError("From what should I show the circle-vnum?")
name = parsed.args[0]
obj = None # type: Union[Location, Living, Item, Exit]
if name == ".":
obj = player.location
elif parsed.who_info:
obj = parsed.who_1
else:
try:
vnum = int(parsed.args[0])
except ValueError as x:
raise ActionRefused(str(x))
objects = [] # type: List[Union[Location, Living, Item, Exit]]
try:
objects.append(make_item(vnum))
except KeyError:
pass
try:
objects.append(make_location(vnum))
except KeyError:
pass
try:
objects.append(make_mob(vnum))
except KeyError:
pass
player.tell("Objects with circle-vnum %d:" % vnum + " " + (lang.join(str(o) for o in objects) or "none"))
return
try:
vnum = obj.circle_vnum
player.tell("Circle-Vnum of %s = %d." % (obj, vnum))
except AttributeError:
player.tell(str(obj) + " has no circle-vnum.")
def test_tell_chain(self):
player = Player("fritz", "m")
player.tell("hi").tell("there")
self.assertEqual(["hi\nthere\n"], player.test_get_output_paragraphs())
def test_tell(self):
player = Player("fritz", "m")
player.tell(5)
self.assertEqual(["5\n"], player.test_get_output_paragraphs())
player.tell("")
self.assertEqual([], player.test_get_output_paragraphs())
player.tell("")
player.tell("")
self.assertEqual([], player.test_get_output_paragraphs())
player.tell("")
player.tell("line1")
player.tell("line2")
player.tell("")
self.assertEqual(["line1\nline2\n"], player.test_get_output_paragraphs())
player.tell("", format=False)
player.tell("line1", format=False)
player.tell("", format=False)
player.tell("line2", format=False)
player.tell("", format=False)
self.assertEqual(["\nline1\n\nline2\n\n"], player.test_get_output_paragraphs())
player.tell("\n")
self.assertEqual(["\n"], player.test_get_output_paragraphs())
player.tell("line1")
player.tell("line2")
player.tell("hello\nnewline")
player.tell("\n")
player.tell("ints", 42, 999)
self.assertEqual(["line1\nline2\nhello\nnewline\n", "ints 42 999\n"], player.test_get_output_paragraphs())
self.assertEqual([], player.test_get_output_paragraphs())
player.tell("para1", end=False)
player.tell("para2", end=True)
player.tell("para3")
player.tell("\n")
player.tell("para4", "\n", "para5")
self.assertEqual(["para1\npara2\n", "para3\n", "para4 \n para5\n"], player.test_get_output_paragraphs())
player.tell(" xyz \n 123", format=False)
self.assertEqual([" xyz \n 123\n"], player.test_get_output_paragraphs())
player.tell("line1", end=True)
player.tell("\n")
player.tell("line2", end=True)
player.tell("\n")
player.tell("\n")
self.assertEqual(["line1\n", "\n", "line2\n", "\n", "\n"], player.test_get_output_paragraphs())
