Beispiel #1
0
 def testWhoInfo(self):
     soul = tale.soul.Soul()
     player = tale.player.Player("julie", "f")
     kate = tale.npc.NPC("kate", "f", title="Kate")
     cat = tale.npc.NPC("cat", "n", title="hairy cat")
     player.move(tale.base.Location("somewhere"))
     cat.move(player.location)
     kate.move(player.location)
     parsed = soul.parse(player, "smile at cat and kate and myself")
     self.assertEqual(["cat", "kate", "myself"], parsed.args)
     self.assertEqual(3, len(parsed.who_order))
     self.assertEqual(3, len(parsed.who_info))
     self.assertTrue(cat in parsed.who_info and kate in parsed.who_info and player in parsed.who_info)
     self.assertEqual(0, parsed.who_info[cat].sequence)
     self.assertEqual(1, parsed.who_info[kate].sequence)
     self.assertEqual(2, parsed.who_info[player].sequence)
     self.assertEqual("at", parsed.who_info[cat].previous_word)
     self.assertEqual("and", parsed.who_info[kate].previous_word)
     self.assertEqual("and", parsed.who_info[player].previous_word)
     self.assertEqual([cat, kate, player], parsed.who_order)
     parsed = soul.parse(player, "smile at myself and kate and cat")
     self.assertEqual(["myself", "kate", "cat"], parsed.args)
     self.assertEqual([player, kate, cat], parsed.who_order)
     parsed = soul.parse(player, "smile at kate, cat and cat")
     self.assertEqual(["kate", "cat", "cat"], parsed.args, "deal with multiple occurences")
     self.assertEqual([kate, cat, cat], parsed.who_order, "deal with multiple occurrences")
     parsed = soul.parse(player, "smile at kate cat myself")
     self.assertEqual("at", parsed.who_info[kate].previous_word, "ony kate has a previous word")
     self.assertEqual(None, parsed.who_info[cat].previous_word, "cat doesn't have a previous word")
     self.assertEqual(None, parsed.who_info[player].previous_word, "player doesn't have a previous word")
Beispiel #2
0
 def testWhoInfo(self):
     soul = tale.soul.Soul()
     player = tale.player.Player("julie", "f")
     kate = tale.npc.NPC("kate", "f", title="Kate")
     cat = tale.npc.NPC("cat", "n", title="hairy cat")
     player.move(tale.base.Location("somewhere"))
     cat.move(player.location)
     kate.move(player.location)
     parsed = soul.parse(player, "smile at cat and kate and myself")
     self.assertEqual(["cat", "kate", "myself"], parsed.args)
     self.assertEqual(3, len(parsed.who_order))
     self.assertEqual(3, len(parsed.who_info))
     self.assertTrue(cat in parsed.who_info and kate in parsed.who_info and player in parsed.who_info)
     self.assertEqual(0, parsed.who_info[cat].sequence)
     self.assertEqual(1, parsed.who_info[kate].sequence)
     self.assertEqual(2, parsed.who_info[player].sequence)
     self.assertEqual("at", parsed.who_info[cat].previous_word)
     self.assertEqual("and", parsed.who_info[kate].previous_word)
     self.assertEqual("and", parsed.who_info[player].previous_word)
     self.assertEqual([cat, kate, player], parsed.who_order)
     parsed = soul.parse(player, "smile at myself and kate and cat")
     self.assertEqual(["myself", "kate", "cat"], parsed.args)
     self.assertEqual([player, kate, cat], parsed.who_order)
     parsed = soul.parse(player, "smile at kate, cat and cat")
     self.assertEqual(["kate", "cat", "cat"], parsed.args, "deal with multiple occurences")
     self.assertEqual([kate, cat, cat], parsed.who_order, "deal with multiple occurrences")
     parsed = soul.parse(player, "smile at kate cat myself")
     self.assertEqual("at", parsed.who_info[kate].previous_word, "ony kate has a previous word")
     self.assertEqual(None, parsed.who_info[cat].previous_word, "cat doesn't have a previous word")
     self.assertEqual(None, parsed.who_info[player].previous_word, "player doesn't have a previous word")
Beispiel #3
0
 def testAdverbWithoutVerb(self):
     soul = tale.soul.Soul()
     player = tale.player.Player("julie", "f")
     with self.assertRaises(tale.soul.UnknownVerbException) as ex:
         soul.parse(player, "forg")     # forgetfully etc.
     self.assertEqual("forg", ex.exception.verb)
     with self.assertRaises(tale.errors.ParseError) as ex:
         soul.parse(player, "giggle forg")     # forgetfully etc.
     self.assertEqual("What adverb did you mean: forgetfully or forgivingly?", str(ex.exception))
Beispiel #4
0
 def testAdverbWithoutVerb(self):
     soul = tale.soul.Soul()
     player = tale.player.Player("julie", "f")
     with self.assertRaises(tale.soul.UnknownVerbException) as ex:
         soul.parse(player, "forg")     # forgetfully etc.
     self.assertEqual("forg", ex.exception.verb)
     with self.assertRaises(tale.errors.ParseError) as ex:
         soul.parse(player, "giggle forg")     # forgetfully etc.
     self.assertEqual("What adverb did you mean: forgetfully or forgivingly?", str(ex.exception))
Beispiel #5
0
 def testEnterExits(self):
     soul = tale.soul.Soul()
     player = tale.player.Player("julie", "f")
     room = tale.base.Location("somewhere")
     gate = tale.base.Exit("gate", room, "gate")
     east = tale.base.Exit("east", room, "east")
     door1 = tale.base.Exit("door one", room, "door number one")
     room.add_exits([gate, door1, east])
     player.move(room)
     # known actions: enter/go/climb/crawl
     with self.assertRaises(tale.soul.NonSoulVerb) as x:
         soul.parse(player, "enter door one")
     parsed = x.exception.parsed
     self.assertEqual("door one", parsed.verb)
     self.assertEqual([door1], parsed.who_order)
     with self.assertRaises(tale.soul.NonSoulVerb) as x:
         soul.parse(player, "climb gate")
     parsed = x.exception.parsed
     self.assertEqual("gate", parsed.verb)
     with self.assertRaises(tale.soul.NonSoulVerb) as x:
         soul.parse(player, "go east")
     parsed = x.exception.parsed
     self.assertEqual("east", parsed.verb)
     with self.assertRaises(tale.soul.NonSoulVerb) as x:
         soul.parse(player, "crawl east")
     parsed = x.exception.parsed
     self.assertEqual("east", parsed.verb)
     parsed = soul.parse(player, "jump west")
     self.assertEqual("jump", parsed.verb)
     self.assertEqual("westwards", parsed.adverb)
Beispiel #6
0
 def testEnterExits(self):
     soul = tale.soul.Soul()
     player = tale.player.Player("julie", "f")
     room = tale.base.Location("somewhere")
     gate = tale.base.Exit("gate", room, "gate")
     east = tale.base.Exit("east", room, "east")
     door1 = tale.base.Exit("door one", room, "door number one")
     room.add_exits([gate, door1, east])
     player.move(room)
     # known actions: enter/go/climb/crawl
     with self.assertRaises(tale.soul.NonSoulVerb) as x:
         soul.parse(player, "enter door one")
     parsed = x.exception.parsed
     self.assertEqual("door one", parsed.verb)
     self.assertEqual([door1], parsed.who_order)
     with self.assertRaises(tale.soul.NonSoulVerb) as x:
         soul.parse(player, "climb gate")
     parsed = x.exception.parsed
     self.assertEqual("gate", parsed.verb)
     with self.assertRaises(tale.soul.NonSoulVerb) as x:
         soul.parse(player, "go east")
     parsed = x.exception.parsed
     self.assertEqual("east", parsed.verb)
     with self.assertRaises(tale.soul.NonSoulVerb) as x:
         soul.parse(player, "crawl east")
     parsed = x.exception.parsed
     self.assertEqual("east", parsed.verb)
     parsed = soul.parse(player, "jump west")
     self.assertEqual("jump", parsed.verb)
     self.assertEqual("westwards", parsed.adverb)
Beispiel #7
0
 def testPronounReferences(self):
     soul = tale.soul.Soul()
     player = tale.player.Player("julie", "f", "human")
     room = tale.base.Location("somewhere")
     room2 = tale.base.Location("somewhere else")
     player.move(room)
     max_npc = tale.npc.NPC("Max", "m")
     kate_npc = tale.npc.NPC("Kate", "f")
     dino_npc = tale.npc.NPC("dinosaur", "n")
     targets = [max_npc, kate_npc, dino_npc]
     player.location.livings = targets
     newspaper = tale.base.Item("newspaper")
     player.location.insert(newspaper, player)
     # her
     parsed = soul.parse(player, "hug kate")
     soul.previously_parsed = parsed
     parsed = soul.parse(player, "kiss her")
     self.assertEqual(["(By 'her', it is assumed you mean Kate.)\n"], player.test_get_output_paragraphs())
     self.assertEqual(kate_npc, parsed.who_order[0])
     # it
     parsed = soul.parse(player, "hug dinosaur")
     soul.previously_parsed = parsed
     parsed = soul.parse(player, "kiss it")
     self.assertEqual(["(By 'it', it is assumed you mean dinosaur.)\n"], player.test_get_output_paragraphs())
     self.assertEqual(dino_npc, parsed.who_order[0])
     with self.assertRaises(tale.errors.ParseError) as x:
         parsed = soul.parse(player, "kiss her")
     self.assertEqual("It is not clear who you're referring to.", str(x.exception))
     # them
     parsed = soul.parse(player, "hug kate and dinosaur")
     soul.previously_parsed = parsed
     parsed = soul.parse(player, "kiss them")
     self.assertEqual(
         ["(By 'them', it is assumed you mean: Kate and dinosaur.)\n"], player.test_get_output_paragraphs()
     )
     self.assertEqual([kate_npc, dino_npc], parsed.who_order)
     # when no longer around
     parsed = soul.parse(player, "hug kate")
     soul.previously_parsed = parsed
     player.move(room2)
     with self.assertRaises(tale.errors.ParseError) as x:
         parsed = soul.parse(player, "kiss her")
     self.assertEqual("She is no longer around.", str(x.exception))
Beispiel #8
0
 def testUnparsed(self):
     soul = tale.soul.Soul()
     player = tale.player.Player("julie", "f", "human")
     parsed = soul.parse(player, "fart")
     self.assertEqual("", parsed.unparsed)
     parsed = soul.parse(player, "grin sadistically")
     self.assertEqual("sadistically", parsed.unparsed)
     parsed = soul.parse(player, "fail sit zen")
     self.assertEqual("zen", parsed.unparsed)
     parsed = soul.parse(player, "pat myself comfortingly on the shoulder")
     self.assertEqual("myself comfortingly on the shoulder", parsed.unparsed)
     parsed = soul.parse(player, "take the watch and the key from the box", external_verbs={"take"})
     self.assertEqual("the watch and the key from the box", parsed.unparsed)
     parsed = soul.parse(player, "fail to _undefined_verb_ on the floor", external_verbs={"_undefined_verb_"})
     self.assertEqual("on the floor", parsed.unparsed)
     parsed = soul.parse(player, "say 'red or blue'", external_verbs={"say"})
     self.assertEqual("'red or blue'", parsed.unparsed)
     parsed = soul.parse(player, "say red or blue", external_verbs={"say"})
     self.assertEqual("red or blue", parsed.unparsed)
     parsed = soul.parse(player, "say hastily red or blue", external_verbs={"say"})
     self.assertEqual("hastily red or blue", parsed.unparsed)
     parsed = soul.parse(player, "fail say hastily red or blue on your head", external_verbs={"say"})
     self.assertEqual("hastily red or blue on your head", parsed.unparsed)
Beispiel #9
0
 def testUnparsed(self):
     soul = tale.soul.Soul()
     player = tale.player.Player("julie", "f", "human")
     parsed = soul.parse(player, "fart")
     self.assertEqual("", parsed.unparsed)
     parsed = soul.parse(player, "grin sadistically")
     self.assertEqual("sadistically", parsed.unparsed)
     parsed = soul.parse(player, "fail sit zen")
     self.assertEqual("zen", parsed.unparsed)
     parsed = soul.parse(player, "pat myself comfortingly on the shoulder")
     self.assertEqual("myself comfortingly on the shoulder", parsed.unparsed)
     parsed = soul.parse(player, "take the watch and the key from the box", external_verbs={"take"})
     self.assertEqual("the watch and the key from the box", parsed.unparsed)
     parsed = soul.parse(player, "fail to _undefined_verb_ on the floor", external_verbs={"_undefined_verb_"})
     self.assertEqual("on the floor", parsed.unparsed)
     parsed = soul.parse(player, "say 'red or blue'", external_verbs={"say"})
     self.assertEqual("'red or blue'", parsed.unparsed)
     parsed = soul.parse(player, "say red or blue", external_verbs={"say"})
     self.assertEqual("red or blue", parsed.unparsed)
     parsed = soul.parse(player, "say hastily red or blue", external_verbs={"say"})
     self.assertEqual("hastily red or blue", parsed.unparsed)
     parsed = soul.parse(player, "fail say hastily red or blue on your head", external_verbs={"say"})
     self.assertEqual("hastily red or blue on your head", parsed.unparsed)
Beispiel #10
0
 def testVerbTarget(self):
     soul = tale.soul.Soul()
     player = tale.player.Player("julie", "f")
     player.title = "the great Julie, destroyer of worlds"
     player.move(tale.base.Location("somewhere"))
     npc_max = tale.npc.NPC("max", "m")
     player.location.livings = {npc_max, player}
     verb, (who, player_msg, room_msg, target_msg) = soul.process_verb(player, "grin")
     self.assertEqual("grin", verb)
     self.assertTrue(len(who) == 0)
     self.assertIsInstance(who, (set, frozenset), "targets must be a set for O(1) lookups")
     self.assertEqual("You grin evilly.", player_msg)
     self.assertEqual("The great Julie, destroyer of worlds grins evilly.", room_msg)
     verb, (who, player_msg, room_msg, target_msg) = soul.process_verb(player, "grin at max")
     self.assertEqual("grin", verb)
     self.assertTrue(len(who) == 1)
     self.assertIsInstance(who, (set, frozenset), "targets must be a set for O(1) lookups")
     self.assertEqual("max", list(who)[0].name)
     self.assertEqual("You grin evilly at max.", player_msg)
     self.assertEqual("The great Julie, destroyer of worlds grins evilly at max.", room_msg)
     self.assertEqual("The great Julie, destroyer of worlds grins evilly at you.", target_msg)
     # parsed results
     parsed = soul.parse(player, "grin at all")
     self.assertEqual("grin", parsed.verb)
     self.assertEqual([npc_max], parsed.who_order, "parse('all') must result in only the npc, not the player")
     who, player_msg, room_msg, target_msg = soul.process_verb_parsed(player, parsed)
     self.assertTrue(len(who) == 1)
     self.assertIsInstance(who, (set, frozenset), "targets must be a set for O(1) lookups")
     self.assertEqual("max", list(who)[0].name)
     self.assertEqual("You grin evilly at max.", player_msg)
     parsed = soul.parse(player, "grin at all and me")
     self.assertEqual("grin", parsed.verb)
     self.assertEqual([npc_max, player], parsed.who_order, "parse('all and me') must include npc and the player")
     who, player_msg, room_msg, target_msg = soul.process_verb_parsed(player, parsed)
     self.assertEqual({npc_max}, who, "player should no longer be part of the remaining targets")
     self.assertTrue("yourself" in player_msg and "max" in player_msg)
Beispiel #11
0
 def testVerbTarget(self):
     soul = tale.soul.Soul()
     player = tale.player.Player("julie", "f")
     player.title = "the great Julie, destroyer of worlds"
     player.move(tale.base.Location("somewhere"))
     npc_max = tale.npc.NPC("max", "m")
     player.location.livings = {npc_max, player}
     verb, (who, player_msg, room_msg, target_msg) = soul.process_verb(player, "grin")
     self.assertEqual("grin", verb)
     self.assertTrue(len(who) == 0)
     self.assertIsInstance(who, (set, frozenset), "targets must be a set for O(1) lookups")
     self.assertEqual("You grin evilly.", player_msg)
     self.assertEqual("The great Julie, destroyer of worlds grins evilly.", room_msg)
     verb, (who, player_msg, room_msg, target_msg) = soul.process_verb(player, "grin at max")
     self.assertEqual("grin", verb)
     self.assertTrue(len(who) == 1)
     self.assertIsInstance(who, (set, frozenset), "targets must be a set for O(1) lookups")
     self.assertEqual("max", list(who)[0].name)
     self.assertEqual("You grin evilly at max.", player_msg)
     self.assertEqual("The great Julie, destroyer of worlds grins evilly at max.", room_msg)
     self.assertEqual("The great Julie, destroyer of worlds grins evilly at you.", target_msg)
     # parsed results
     parsed = soul.parse(player, "grin at all")
     self.assertEqual("grin", parsed.verb)
     self.assertEqual([npc_max], parsed.who_order, "parse('all') must result in only the npc, not the player")
     who, player_msg, room_msg, target_msg = soul.process_verb_parsed(player, parsed)
     self.assertTrue(len(who) == 1)
     self.assertIsInstance(who, (set, frozenset), "targets must be a set for O(1) lookups")
     self.assertEqual("max", list(who)[0].name)
     self.assertEqual("You grin evilly at max.", player_msg)
     parsed = soul.parse(player, "grin at all and me")
     self.assertEqual("grin", parsed.verb)
     self.assertEqual([npc_max, player], parsed.who_order, "parse('all and me') must include npc and the player")
     who, player_msg, room_msg, target_msg = soul.process_verb_parsed(player, parsed)
     self.assertEqual({npc_max}, who, "player should no longer be part of the remaining targets")
     self.assertTrue("yourself" in player_msg and "max" in player_msg)
Beispiel #12
0
 def testPronounReferences(self):
     soul = tale.soul.Soul()
     player = tale.player.Player("julie", "f", "human")
     room = tale.base.Location("somewhere")
     room2 = tale.base.Location("somewhere else")
     player.move(room)
     max_npc = tale.npc.NPC("Max", "m")
     kate_npc = tale.npc.NPC("Kate", "f")
     dino_npc = tale.npc.NPC("dinosaur", "n")
     targets = [max_npc, kate_npc, dino_npc]
     player.location.livings = targets
     newspaper = tale.base.Item("newspaper")
     player.location.insert(newspaper, player)
     # her
     parsed = soul.parse(player, "hug kate")
     soul.previously_parsed = parsed
     parsed = soul.parse(player, "kiss her")
     self.assertEqual(["(By 'her', it is assumed you mean Kate.)\n"], player.test_get_output_paragraphs())
     self.assertEqual(kate_npc, parsed.who_order[0])
     # it
     parsed = soul.parse(player, "hug dinosaur")
     soul.previously_parsed = parsed
     parsed = soul.parse(player, "kiss it")
     self.assertEqual(["(By 'it', it is assumed you mean dinosaur.)\n"], player.test_get_output_paragraphs())
     self.assertEqual(dino_npc, parsed.who_order[0])
     with self.assertRaises(tale.errors.ParseError) as x:
         parsed = soul.parse(player, "kiss her")
     self.assertEqual("It is not clear who you're referring to.", str(x.exception))
     # them
     parsed = soul.parse(player, "hug kate and dinosaur")
     soul.previously_parsed = parsed
     parsed = soul.parse(player, "kiss them")
     self.assertEqual(["(By 'them', it is assumed you mean: Kate and dinosaur.)\n"], player.test_get_output_paragraphs())
     self.assertEqual([kate_npc, dino_npc], parsed.who_order)
     # when no longer around
     parsed = soul.parse(player, "hug kate")
     soul.previously_parsed = parsed
     player.move(room2)
     with self.assertRaises(tale.errors.ParseError) as x:
         parsed = soul.parse(player, "kiss her")
     self.assertEqual("She is no longer around.", str(x.exception))
Beispiel #13
0
 def testIgnorewords(self):
     soul = tale.soul.Soul()
     player = tale.player.Player("fritz", "m")
     with self.assertRaises(tale.errors.ParseError):
         soul.parse(player, "in")
     with self.assertRaises(tale.errors.ParseError):
         soul.parse(player, "and")
     with self.assertRaises(tale.errors.ParseError):
         soul.parse(player, "fail")
     with self.assertRaises(tale.errors.ParseError):
         soul.parse(player, "fail in")
     with self.assertRaises(tale.soul.UnknownVerbException) as x:
         soul.parse(player, "in fail")
     self.assertEqual("fail", x.exception.verb)
     parsed = soul.parse(player, "in sit")
     self.assertIsNone(parsed.qualifier)
     self.assertIsNone(parsed.adverb)
     self.assertEqual("sit", parsed.verb)
     parsed = soul.parse(player, "fail in sit")
     self.assertEqual("fail", parsed.qualifier)
     self.assertIsNone(parsed.adverb)
     self.assertEqual("sit", parsed.verb)
Beispiel #14
0
 def testParse(self):
     soul = tale.soul.Soul()
     player = tale.player.Player("julie", "f", "human")
     room = tale.base.Location("somewhere")
     south_exit = tale.base.Exit("south", room, "a door to the south")
     east_exit = tale.base.Exit("east", room, "a door to the east")
     room.add_exits([east_exit, south_exit])
     player.move(room)
     max_npc = tale.npc.NPC("max", "m")
     kate_npc = tale.npc.NPC("kate", "f")
     dino_npc = tale.npc.NPC("dinosaur", "n")
     targets = [max_npc, kate_npc, dino_npc]
     targets_with_player = targets + [player]
     player.location.livings = targets
     newspaper = tale.base.Item("newspaper")
     player.location.insert(newspaper, player)
     parsed = soul.parse(player, "fail grin sickly at everyone head")
     self.assertEqual("fail", parsed.qualifier)
     self.assertEqual("grin", parsed.verb)
     self.assertEqual("sickly", parsed.adverb)
     self.assertEqual("head", parsed.bodypart)
     self.assertEqual("", parsed.message)
     self.assertTrue(len(parsed.who_order) == 3)
     self.assertTrue(all(isinstance(x, tale.base.Living) for x in parsed.who_order), "parse must return Livings in 'who'")
     self.assertEqual(targets, parsed.who_order)
     parsed = soul.parse(player, "slap myself")
     self.assertEqual(None, parsed.qualifier)
     self.assertEqual("slap", parsed.verb)
     self.assertEqual(None, parsed.adverb)
     self.assertEqual(None, parsed.bodypart)
     self.assertEqual("", parsed.message)
     self.assertEqual([player], parsed.who_order, "myself should be player")
     parsed = soul.parse(player, "slap all")
     self.assertEqual(None, parsed.qualifier)
     self.assertEqual("slap", parsed.verb)
     self.assertEqual(None, parsed.adverb)
     self.assertEqual(None, parsed.bodypart)
     self.assertEqual("", parsed.message)
     self.assertEqual(3, len(parsed.who_info), "all should not include player")
     self.assertEqual(targets, parsed.who_order, "all should not include player")
     parsed = soul.parse(player, "slap all but kate")
     self.assertEqual(2, len(parsed.who_info), "all but kate should only be max and the dino")
     self.assertEqual([max_npc, dino_npc], parsed.who_order, "all but kate should only be max and the dino")
     parsed = soul.parse(player, "slap all and myself")
     self.assertEqual(targets_with_player, parsed.who_order, "all and myself should include player")
     parsed = soul.parse(player, "slap newspaper")
     self.assertEqual([newspaper], parsed.who_order, "must be able to perform soul verb on item")
     with self.assertRaises(tale.errors.ParseError) as x:
         soul.parse(player, "slap dino")
     self.assertEqual("Perhaps you meant dinosaur?", str(x.exception), "must suggest living with prefix")
     with self.assertRaises(tale.errors.ParseError) as x:
         soul.parse(player, "slap news")
     self.assertEqual("Perhaps you meant newspaper?", str(x.exception), "must suggest item with prefix")
     with self.assertRaises(tale.errors.ParseError) as x:
         soul.parse(player, "slap undefined")
     self.assertEqual("It's not clear what you mean by 'undefined'.", str(x.exception))
     parsed = soul.parse(player, "smile west")
     self.assertEqual("westwards", parsed.adverb)
     with self.assertRaises(tale.errors.ParseError) as x:
         soul.parse(player, "smile north")
     self.assertEqual("What adverb did you mean: northeastwards, northwards, or northwestwards?", str(x.exception))
     parsed = soul.parse(player, "smile south")
     self.assertEqual(["south"], parsed.args, "south must be parsed as a normal arg because it's an exit in the room")
     parsed = soul.parse(player, "smile kate dinosaur and max")
     self.assertEqual(["kate", "dinosaur", "max"], parsed.args, "must be able to skip comma")
     self.assertEqual(3, len(parsed.who_order), "must be able to skip comma")
     parsed = soul.parse(player, "reply kate ofcourse,  darling.")
     self.assertEqual(["kate", "ofcourse,", "darling."], parsed.args, "must be able to skip comma")
     self.assertEqual(1, len(parsed.who_order))
     # check movement parsing for room exits
     with self.assertRaises(tale.soul.NonSoulVerb) as x:
         soul.parse(player, "crawl south")
     self.assertEqual("south", x.exception.parsed.verb, "just the exit is the verb, not the movement action")
     self.assertEqual([south_exit], x.exception.parsed.who_order, "exit must be in the who set")
     parsed_str = str(x.exception.parsed)
     self.assertTrue("verb=south" in parsed_str)
     with self.assertRaises(tale.errors.ParseError) as x:
         soul.parse(player, "crawl somewherenotexisting")
     self.assertEqual("You can't crawl there.", str(x.exception))
     with self.assertRaises(tale.errors.ParseError) as x:
         soul.parse(player, "crawl")
     self.assertEqual("Crawl where?", str(x.exception))
     room = tale.base.Location("somewhere")  # no exits in this new room
     player.move(room)
     with self.assertRaises(tale.soul.UnknownVerbException):
         soul.parse(player, "crawl")   # must raise unknownverb if there are no exits in the room
Beispiel #15
0
 def testCheckNamesWithSpacesParsing(self):
     soul = tale.soul.Soul()
     player = tale.player.Player("julie", "f")
     bird = tale.npc.NPC("brown bird", "f")
     room = tale.base.Location("somewhere")
     gate = tale.base.Exit("gate", room, "the gate")
     door1 = tale.base.Exit("door one", room, "door number one")
     door2 = tale.base.Exit("door two", room, "door number two")
     room.add_exits([gate, door1, door2])
     bird.move(room)
     player.move(room)
     with self.assertRaises(tale.errors.ParseError) as x:
         soul.parse(player, "hug bird")
     self.assertEqual("It's not clear what you mean by 'bird'.", str(x.exception))
     parsed = soul.parse(player, "hug brown bird affection")
     self.assertEqual("hug", parsed.verb)
     self.assertEqual("affectionately", parsed.adverb)
     self.assertEqual([bird], parsed.who_order)
     # check spaces in exit names
     parsed = soul.parse(player, "gate", external_verbs=frozenset(room.exits))
     self.assertEqual("gate", parsed.verb)
     parsed = soul.parse(player, "frobnizz gate", external_verbs={"frobnizz"})
     self.assertEqual("frobnizz", parsed.verb)
     self.assertEqual(["gate"], parsed.args)
     self.assertEqual([gate], parsed.who_order)
     with self.assertRaises(tale.soul.UnknownVerbException):
         soul.parse(player, "door")
     parsed = soul.parse(player, "enter door two", external_verbs={"enter"})
     self.assertEqual("enter", parsed.verb)
     self.assertEqual(["door two"], parsed.args)
     self.assertEqual([door2], parsed.who_order)
     with self.assertRaises(tale.soul.NonSoulVerb) as x:
         soul.parse(player, "door one")
     parsed = x.exception.parsed
     self.assertEqual("door one", parsed.verb)
     self.assertEqual([door1], parsed.who_order)
     with self.assertRaises(tale.soul.NonSoulVerb) as x:
         soul.parse(player, "door two")
     parsed = x.exception.parsed
     self.assertEqual("door two", parsed.verb)
     self.assertEqual([door2], parsed.who_order)
Beispiel #16
0
 def testCheckNamesWithSpacesParsing(self):
     soul = tale.soul.Soul()
     player = tale.player.Player("julie", "f")
     bird = tale.npc.NPC("brown bird", "f")
     room = tale.base.Location("somewhere")
     gate = tale.base.Exit("gate", room, "the gate")
     door1 = tale.base.Exit("door one", room, "door number one")
     door2 = tale.base.Exit("door two", room, "door number two")
     room.add_exits([gate, door1, door2])
     bird.move(room)
     player.move(room)
     with self.assertRaises(tale.errors.ParseError) as x:
         soul.parse(player, "hug bird")
     self.assertEqual("It's not clear what you mean by 'bird'.", str(x.exception))
     parsed = soul.parse(player, "hug brown bird affection")
     self.assertEqual("hug", parsed.verb)
     self.assertEqual("affectionately", parsed.adverb)
     self.assertEqual([bird], parsed.who_order)
     # check spaces in exit names
     parsed = soul.parse(player, "gate", external_verbs=frozenset(room.exits))
     self.assertEqual("gate", parsed.verb)
     parsed = soul.parse(player, "frobnizz gate", external_verbs={"frobnizz"})
     self.assertEqual("frobnizz", parsed.verb)
     self.assertEqual(["gate"], parsed.args)
     self.assertEqual([gate], parsed.who_order)
     with self.assertRaises(tale.soul.UnknownVerbException):
         soul.parse(player, "door")
     parsed = soul.parse(player, "enter door two", external_verbs={"enter"})
     self.assertEqual("enter", parsed.verb)
     self.assertEqual(["door two"], parsed.args)
     self.assertEqual([door2], parsed.who_order)
     with self.assertRaises(tale.soul.NonSoulVerb) as x:
         soul.parse(player, "door one")
     parsed = x.exception.parsed
     self.assertEqual("door one", parsed.verb)
     self.assertEqual([door1], parsed.who_order)
     with self.assertRaises(tale.soul.NonSoulVerb) as x:
         soul.parse(player, "door two")
     parsed = x.exception.parsed
     self.assertEqual("door two", parsed.verb)
     self.assertEqual([door2], parsed.who_order)
Beispiel #17
0
 def testParse(self):
     soul = tale.soul.Soul()
     player = tale.player.Player("julie", "f", "human")
     room = tale.base.Location("somewhere")
     south_exit = tale.base.Exit("south", room, "a door to the south")
     east_exit = tale.base.Exit("east", room, "a door to the east")
     room.add_exits([east_exit, south_exit])
     player.move(room)
     max_npc = tale.npc.NPC("max", "m")
     kate_npc = tale.npc.NPC("kate", "f")
     dino_npc = tale.npc.NPC("dinosaur", "n")
     targets = [max_npc, kate_npc, dino_npc]
     targets_with_player = targets + [player]
     player.location.livings = targets
     newspaper = tale.base.Item("newspaper")
     player.location.insert(newspaper, player)
     parsed = soul.parse(player, "fail grin sickly at everyone head")
     self.assertEqual("fail", parsed.qualifier)
     self.assertEqual("grin", parsed.verb)
     self.assertEqual("sickly", parsed.adverb)
     self.assertEqual("head", parsed.bodypart)
     self.assertEqual("", parsed.message)
     self.assertTrue(len(parsed.who_order) == 3)
     self.assertTrue(all(isinstance(x, tale.base.Living) for x in parsed.who_order), "parse must return Livings in 'who'")
     self.assertEqual(targets, parsed.who_order)
     parsed = soul.parse(player, "slap myself")
     self.assertEqual(None, parsed.qualifier)
     self.assertEqual("slap", parsed.verb)
     self.assertEqual(None, parsed.adverb)
     self.assertEqual(None, parsed.bodypart)
     self.assertEqual("", parsed.message)
     self.assertEqual([player], parsed.who_order, "myself should be player")
     parsed = soul.parse(player, "slap all")
     self.assertEqual(None, parsed.qualifier)
     self.assertEqual("slap", parsed.verb)
     self.assertEqual(None, parsed.adverb)
     self.assertEqual(None, parsed.bodypart)
     self.assertEqual("", parsed.message)
     self.assertEqual(3, len(parsed.who_info), "all should not include player")
     self.assertEqual(targets, parsed.who_order, "all should not include player")
     parsed = soul.parse(player, "slap all but kate")
     self.assertEqual(2, len(parsed.who_info), "all but kate should only be max and the dino")
     self.assertEqual([max_npc, dino_npc], parsed.who_order, "all but kate should only be max and the dino")
     parsed = soul.parse(player, "slap all and myself")
     self.assertEqual(targets_with_player, parsed.who_order, "all and myself should include player")
     parsed = soul.parse(player, "slap newspaper")
     self.assertEqual([newspaper], parsed.who_order, "must be able to perform soul verb on item")
     with self.assertRaises(tale.errors.ParseError) as x:
         soul.parse(player, "slap dino")
     self.assertEqual("Perhaps you meant dinosaur?", str(x.exception), "must suggest living with prefix")
     with self.assertRaises(tale.errors.ParseError) as x:
         soul.parse(player, "slap news")
     self.assertEqual("Perhaps you meant newspaper?", str(x.exception), "must suggest item with prefix")
     with self.assertRaises(tale.errors.ParseError) as x:
         soul.parse(player, "slap undefined")
     self.assertEqual("It's not clear what you mean by 'undefined'.", str(x.exception))
     parsed = soul.parse(player, "smile west")
     self.assertEqual("westwards", parsed.adverb)
     with self.assertRaises(tale.errors.ParseError) as x:
         soul.parse(player, "smile north")
     self.assertEqual("What adverb did you mean: northeastwards, northwards, or northwestwards?", str(x.exception))
     parsed = soul.parse(player, "smile south")
     self.assertEqual(["south"], parsed.args, "south must be parsed as a normal arg because it's an exit in the room")
     parsed = soul.parse(player, "smile kate dinosaur and max")
     self.assertEqual(["kate", "dinosaur", "max"], parsed.args, "must be able to skip comma")
     self.assertEqual(3, len(parsed.who_order), "must be able to skip comma")
     parsed = soul.parse(player, "reply kate ofcourse,  darling.")
     self.assertEqual(["kate", "ofcourse,", "darling."], parsed.args, "must be able to skip comma")
     self.assertEqual(1, len(parsed.who_order))
     # check movement parsing for room exits
     with self.assertRaises(tale.soul.NonSoulVerb) as x:
         soul.parse(player, "crawl south")
     self.assertEqual("south", x.exception.parsed.verb, "just the exit is the verb, not the movement action")
     self.assertEqual([south_exit], x.exception.parsed.who_order, "exit must be in the who set")
     parsed_str = str(x.exception.parsed)
     self.assertTrue("verb=south" in parsed_str)
     with self.assertRaises(tale.errors.ParseError) as x:
         soul.parse(player, "crawl somewherenotexisting")
     self.assertEqual("You can't crawl there.", str(x.exception))
     with self.assertRaises(tale.errors.ParseError) as x:
         soul.parse(player, "crawl")
     self.assertEqual("Crawl where?", str(x.exception))
     room = tale.base.Location("somewhere")  # no exits in this new room
     player.move(room)
     with self.assertRaises(tale.soul.UnknownVerbException):
         soul.parse(player, "crawl")   # must raise unknownverb if there are no exits in the room
Beispiel #18
0
 def testIgnorewords(self):
     soul = tale.soul.Soul()
     player = tale.player.Player("fritz", "m")
     with self.assertRaises(tale.errors.ParseError):
         soul.parse(player, "in")
     with self.assertRaises(tale.errors.ParseError):
         soul.parse(player, "and")
     with self.assertRaises(tale.errors.ParseError):
         soul.parse(player, "fail")
     with self.assertRaises(tale.errors.ParseError):
         soul.parse(player, "fail in")
     with self.assertRaises(tale.soul.UnknownVerbException) as x:
         soul.parse(player, "in fail")
     self.assertEqual("fail", x.exception.verb)
     parsed = soul.parse(player, "in sit")
     self.assertIsNone(parsed.qualifier)
     self.assertIsNone(parsed.adverb)
     self.assertEqual("sit", parsed.verb)
     parsed = soul.parse(player, "fail in sit")
     self.assertEqual("fail", parsed.qualifier)
     self.assertIsNone(parsed.adverb)
     self.assertEqual("sit", parsed.verb)