Merge conflict

evennia/contrib/tests.py

@@ -671,6 +671,15 @@ class TestGenderSub(CommandTest):
         txt = "Test |p gender"
         self.assertEqual(gendersub._RE_GENDER_PRONOUN.sub(char._get_pronoun, txt), "Test their gender")
 
+# test health bar contrib
+
+from evennia.contrib import health_bar
+
+class TestHealthBar(EvenniaTest):
+    def test_healthbar(self):
+        expected_bar_str = "|[G|w     |n|[B|w       test24 / 200test            |n"
+        self.assertTrue(health_bar.display_meter(24, 200, length=40, pre_text="test", post_text="test", align="center") == expected_bar_str)
+
 # test mail contrib
 
 
@@ -789,7 +798,7 @@ from evennia.contrib import talking_npc
 class TestTalkingNPC(CommandTest):
     def test_talkingnpc(self):
         npc = create_object(talking_npc.TalkingNPC, key="npctalker", location=self.room1)
-        self.call(talking_npc.CmdTalk(), "", "(You walk up and talk to Char.)|")
+        self.call(talking_npc.CmdTalk(), "", "(You walk up and talk to Char.)")
         npc.delete()
 
 
@@ -944,101 +953,637 @@ class TestTutorialWorldRooms(CommandTest):
 
 
 # test turnbattle
-from evennia.contrib import turnbattle
+from evennia.contrib.turnbattle import tb_basic, tb_equip, tb_range, tb_items, tb_magic
 from evennia.objects.objects import DefaultRoom
 
 
-class TestTurnBattleCmd(CommandTest):
+class TestTurnBattleBasicCmd(CommandTest):
 
-    # Test combat commands
+    # Test basic combat commands
     def test_turnbattlecmd(self):
-        self.call(turnbattle.CmdFight(), "", "You can't start a fight if you've been defeated!")
-        self.call(turnbattle.CmdAttack(), "", "You can only do that in combat. (see: help fight)")
-        self.call(turnbattle.CmdPass(), "", "You can only do that in combat. (see: help fight)")
-        self.call(turnbattle.CmdDisengage(), "", "You can only do that in combat. (see: help fight)")
-        self.call(turnbattle.CmdRest(), "", "Char rests to recover HP.")
+        self.call(tb_basic.CmdFight(), "", "You can't start a fight if you've been defeated!")
+        self.call(tb_basic.CmdAttack(), "", "You can only do that in combat. (see: help fight)")
+        self.call(tb_basic.CmdPass(), "", "You can only do that in combat. (see: help fight)")
+        self.call(tb_basic.CmdDisengage(), "", "You can only do that in combat. (see: help fight)")
+        self.call(tb_basic.CmdRest(), "", "Char rests to recover HP.")
 
 
-class TestTurnBattleFunc(EvenniaTest):
+class TestTurnBattleEquipCmd(CommandTest):
+
+    def setUp(self):
+        super(TestTurnBattleEquipCmd, self).setUp()
+        self.testweapon = create_object(tb_equip.TBEWeapon, key="test weapon")
+        self.testarmor = create_object(tb_equip.TBEArmor, key="test armor")
+        self.testweapon.move_to(self.char1)
+        self.testarmor.move_to(self.char1)
+
+    # Test equipment commands
+    def test_turnbattleequipcmd(self):
+        # Start with equip module specific commands.
+        self.call(tb_equip.CmdWield(), "weapon", "Char wields test weapon.")
+        self.call(tb_equip.CmdUnwield(), "", "Char lowers test weapon.")
+        self.call(tb_equip.CmdDon(), "armor", "Char dons test armor.")
+        self.call(tb_equip.CmdDoff(), "", "Char removes test armor.")
+        # Also test the commands that are the same in the basic module
+        self.call(tb_equip.CmdFight(), "", "You can't start a fight if you've been defeated!")
+        self.call(tb_equip.CmdAttack(), "", "You can only do that in combat. (see: help fight)")
+        self.call(tb_equip.CmdPass(), "", "You can only do that in combat. (see: help fight)")
+        self.call(tb_equip.CmdDisengage(), "", "You can only do that in combat. (see: help fight)")
+        self.call(tb_equip.CmdRest(), "", "Char rests to recover HP.")
+
+
+class TestTurnBattleRangeCmd(CommandTest):
+    # Test range commands
+    def test_turnbattlerangecmd(self):
+        # Start with range module specific commands.
+        self.call(tb_range.CmdShoot(), "", "You can only do that in combat. (see: help fight)")
+        self.call(tb_range.CmdApproach(), "", "You can only do that in combat. (see: help fight)")
+        self.call(tb_range.CmdWithdraw(), "", "You can only do that in combat. (see: help fight)")
+        self.call(tb_range.CmdStatus(), "", "HP Remaining: 100 / 100")
+        # Also test the commands that are the same in the basic module
+        self.call(tb_range.CmdFight(), "", "There's nobody here to fight!")
+        self.call(tb_range.CmdAttack(), "", "You can only do that in combat. (see: help fight)")
+        self.call(tb_range.CmdPass(), "", "You can only do that in combat. (see: help fight)")
+        self.call(tb_range.CmdDisengage(), "", "You can only do that in combat. (see: help fight)")
+        self.call(tb_range.CmdRest(), "", "Char rests to recover HP.")
+
+
+class TestTurnBattleItemsCmd(CommandTest):
+
+    def setUp(self):
+        super(TestTurnBattleItemsCmd, self).setUp()
+        self.testitem = create_object(key="test item")
+        self.testitem.move_to(self.char1)
+
+    # Test item commands
+    def test_turnbattleitemcmd(self):
+        self.call(tb_items.CmdUse(), "item", "'Test item' is not a usable item.")
+        # Also test the commands that are the same in the basic module
+        self.call(tb_items.CmdFight(), "", "You can't start a fight if you've been defeated!")
+        self.call(tb_items.CmdAttack(), "", "You can only do that in combat. (see: help fight)")
+        self.call(tb_items.CmdPass(), "", "You can only do that in combat. (see: help fight)")
+        self.call(tb_items.CmdDisengage(), "", "You can only do that in combat. (see: help fight)")
+        self.call(tb_items.CmdRest(), "", "Char rests to recover HP.")
+
+
+class TestTurnBattleMagicCmd(CommandTest):
+
+    # Test magic commands
+    def test_turnbattlemagiccmd(self):
+        self.call(tb_magic.CmdStatus(), "", "You have 100 / 100 HP and 20 / 20 MP.")
+        self.call(tb_magic.CmdLearnSpell(), "test spell", "There is no spell with that name.")
+        self.call(tb_magic.CmdCast(), "", "Usage: cast <spell name> = <target>, <target2>")
+        # Also test the commands that are the same in the basic module
+        self.call(tb_magic.CmdFight(), "", "There's nobody here to fight!")
+        self.call(tb_magic.CmdAttack(), "", "You can only do that in combat. (see: help fight)")
+        self.call(tb_magic.CmdPass(), "", "You can only do that in combat. (see: help fight)")
+        self.call(tb_magic.CmdDisengage(), "", "You can only do that in combat. (see: help fight)")
+        self.call(tb_magic.CmdRest(), "", "Char rests to recover HP and MP.")
+
+
+class TestTurnBattleBasicFunc(EvenniaTest):
+
+    def setUp(self):
+        super(TestTurnBattleBasicFunc, self).setUp()
+        self.testroom = create_object(DefaultRoom, key="Test Room")
+        self.attacker = create_object(tb_basic.TBBasicCharacter, key="Attacker", location=self.testroom)
+        self.defender = create_object(tb_basic.TBBasicCharacter, key="Defender", location=self.testroom)
+        self.joiner = create_object(tb_basic.TBBasicCharacter, key="Joiner", location=None)
+
+    def tearDown(self):
+        super(TestTurnBattleBasicFunc, self).tearDown()
+        self.attacker.delete()
+        self.defender.delete()
+        self.joiner.delete()
+        self.testroom.delete()
+        self.turnhandler.stop()
 
     # Test combat functions
-    def test_turnbattlefunc(self):
-        attacker = create_object(turnbattle.BattleCharacter, key="Attacker")
-        defender = create_object(turnbattle.BattleCharacter, key="Defender")
-        testroom = create_object(DefaultRoom, key="Test Room")
-        attacker.location = testroom
-        defender.loaction = testroom
+    def test_tbbasicfunc(self):
         # Initiative roll
-        initiative = turnbattle.roll_init(attacker)
+        initiative = tb_basic.roll_init(self.attacker)
         self.assertTrue(initiative >= 0 and initiative <= 1000)
         # Attack roll
-        attack_roll = turnbattle.get_attack(attacker, defender)
+        attack_roll = tb_basic.get_attack(self.attacker, self.defender)
         self.assertTrue(attack_roll >= 0 and attack_roll <= 100)
         # Defense roll
-        defense_roll = turnbattle.get_defense(attacker, defender)
+        defense_roll = tb_basic.get_defense(self.attacker, self.defender)
         self.assertTrue(defense_roll == 50)
         # Damage roll
-        damage_roll = turnbattle.get_damage(attacker, defender)
+        damage_roll = tb_basic.get_damage(self.attacker, self.defender)
         self.assertTrue(damage_roll >= 15 and damage_roll <= 25)
         # Apply damage
-        defender.db.hp = 10
-        turnbattle.apply_damage(defender, 3)
-        self.assertTrue(defender.db.hp == 7)
+        self.defender.db.hp = 10
+        tb_basic.apply_damage(self.defender, 3)
+        self.assertTrue(self.defender.db.hp == 7)
         # Resolve attack
-        defender.db.hp = 40
-        turnbattle.resolve_attack(attacker, defender, attack_value=20, defense_value=10)
-        self.assertTrue(defender.db.hp < 40)
+        self.defender.db.hp = 40
+        tb_basic.resolve_attack(self.attacker, self.defender, attack_value=20, defense_value=10)
+        self.assertTrue(self.defender.db.hp < 40)
         # Combat cleanup
-        attacker.db.Combat_attribute = True
-        turnbattle.combat_cleanup(attacker)
-        self.assertFalse(attacker.db.combat_attribute)
+        self.attacker.db.Combat_attribute = True
+        tb_basic.combat_cleanup(self.attacker)
+        self.assertFalse(self.attacker.db.combat_attribute)
         # Is in combat
-        self.assertFalse(turnbattle.is_in_combat(attacker))
+        self.assertFalse(tb_basic.is_in_combat(self.attacker))
         # Set up turn handler script for further tests
-        attacker.location.scripts.add(turnbattle.TurnHandler)
-        turnhandler = attacker.db.combat_TurnHandler
-        self.assertTrue(attacker.db.combat_TurnHandler)
+        self.attacker.location.scripts.add(tb_basic.TBBasicTurnHandler)
+        self.turnhandler = self.attacker.db.combat_TurnHandler
+        self.assertTrue(self.attacker.db.combat_TurnHandler)
+        # Set the turn handler's interval very high to keep it from repeating during tests.
+        self.turnhandler.interval = 10000
         # Force turn order
-        turnhandler.db.fighters = [attacker, defender]
-        turnhandler.db.turn = 0
+        self.turnhandler.db.fighters = [self.attacker, self.defender]
+        self.turnhandler.db.turn = 0
         # Test is turn
-        self.assertTrue(turnbattle.is_turn(attacker))
+        self.assertTrue(tb_basic.is_turn(self.attacker))
         # Spend actions
-        attacker.db.Combat_ActionsLeft = 1
-        turnbattle.spend_action(attacker, 1, action_name="Test")
-        self.assertTrue(attacker.db.Combat_ActionsLeft == 0)
-        self.assertTrue(attacker.db.Combat_LastAction == "Test")
+        self.attacker.db.Combat_ActionsLeft = 1
+        tb_basic.spend_action(self.attacker, 1, action_name="Test")
+        self.assertTrue(self.attacker.db.Combat_ActionsLeft == 0)
+        self.assertTrue(self.attacker.db.Combat_LastAction == "Test")
         # Initialize for combat
-        attacker.db.Combat_ActionsLeft = 983
-        turnhandler.initialize_for_combat(attacker)
-        self.assertTrue(attacker.db.Combat_ActionsLeft == 0)
-        self.assertTrue(attacker.db.Combat_LastAction == "null")
+        self.attacker.db.Combat_ActionsLeft = 983
+        self.turnhandler.initialize_for_combat(self.attacker)
+        self.assertTrue(self.attacker.db.Combat_ActionsLeft == 0)
+        self.assertTrue(self.attacker.db.Combat_LastAction == "null")
         # Start turn
-        defender.db.Combat_ActionsLeft = 0
-        turnhandler.start_turn(defender)
-        self.assertTrue(defender.db.Combat_ActionsLeft == 1)
+        self.defender.db.Combat_ActionsLeft = 0
+        self.turnhandler.start_turn(self.defender)
+        self.assertTrue(self.defender.db.Combat_ActionsLeft == 1)
         # Next turn
-        turnhandler.db.fighters = [attacker, defender]
-        turnhandler.db.turn = 0
-        turnhandler.next_turn()
-        self.assertTrue(turnhandler.db.turn == 1)
+        self.turnhandler.db.fighters = [self.attacker, self.defender]
+        self.turnhandler.db.turn = 0
+        self.turnhandler.next_turn()
+        self.assertTrue(self.turnhandler.db.turn == 1)
         # Turn end check
-        turnhandler.db.fighters = [attacker, defender]
-        turnhandler.db.turn = 0
-        attacker.db.Combat_ActionsLeft = 0
-        turnhandler.turn_end_check(attacker)
-        self.assertTrue(turnhandler.db.turn == 1)
+        self.turnhandler.db.fighters = [self.attacker, self.defender]
+        self.turnhandler.db.turn = 0
+        self.attacker.db.Combat_ActionsLeft = 0
+        self.turnhandler.turn_end_check(self.attacker)
+        self.assertTrue(self.turnhandler.db.turn == 1)
         # Join fight
-        joiner = create_object(turnbattle.BattleCharacter, key="Joiner")
-        turnhandler.db.fighters = [attacker, defender]
-        turnhandler.db.turn = 0
-        turnhandler.join_fight(joiner)
-        self.assertTrue(turnhandler.db.turn == 1)
-        self.assertTrue(turnhandler.db.fighters == [joiner, attacker, defender])
-        # Remove the script at the end
-        turnhandler.stop()
+        self.joiner.location = self.testroom
+        self.turnhandler.db.fighters = [self.attacker, self.defender]
+        self.turnhandler.db.turn = 0
+        self.turnhandler.join_fight(self.joiner)
+        self.assertTrue(self.turnhandler.db.turn == 1)
+        self.assertTrue(self.turnhandler.db.fighters == [self.joiner, self.attacker, self.defender])
 
 
+class TestTurnBattleEquipFunc(EvenniaTest):
+
+    def setUp(self):
+        super(TestTurnBattleEquipFunc, self).setUp()
+        self.testroom = create_object(DefaultRoom, key="Test Room")
+        self.attacker = create_object(tb_equip.TBEquipCharacter, key="Attacker", location=self.testroom)
+        self.defender = create_object(tb_equip.TBEquipCharacter, key="Defender", location=self.testroom)
+        self.joiner = create_object(tb_equip.TBEquipCharacter, key="Joiner", location=None)
+
+    def tearDown(self):
+        super(TestTurnBattleEquipFunc, self).tearDown()
+        self.attacker.delete()
+        self.defender.delete()
+        self.joiner.delete()
+        self.testroom.delete()
+        self.turnhandler.stop()
+
+    # Test the combat functions in tb_equip too. They work mostly the same.
+    def test_tbequipfunc(self):
+        # Initiative roll
+        initiative = tb_equip.roll_init(self.attacker)
+        self.assertTrue(initiative >= 0 and initiative <= 1000)
+        # Attack roll
+        attack_roll = tb_equip.get_attack(self.attacker, self.defender)
+        self.assertTrue(attack_roll >= -50 and attack_roll <= 150)
+        # Defense roll
+        defense_roll = tb_equip.get_defense(self.attacker, self.defender)
+        self.assertTrue(defense_roll == 50)
+        # Damage roll
+        damage_roll = tb_equip.get_damage(self.attacker, self.defender)
+        self.assertTrue(damage_roll >= 0 and damage_roll <= 50)
+        # Apply damage
+        self.defender.db.hp = 10
+        tb_equip.apply_damage(self.defender, 3)
+        self.assertTrue(self.defender.db.hp == 7)
+        # Resolve attack
+        self.defender.db.hp = 40
+        tb_equip.resolve_attack(self.attacker, self.defender, attack_value=20, defense_value=10)
+        self.assertTrue(self.defender.db.hp < 40)
+        # Combat cleanup
+        self.attacker.db.Combat_attribute = True
+        tb_equip.combat_cleanup(self.attacker)
+        self.assertFalse(self.attacker.db.combat_attribute)
+        # Is in combat
+        self.assertFalse(tb_equip.is_in_combat(self.attacker))
+        # Set up turn handler script for further tests
+        self.attacker.location.scripts.add(tb_equip.TBEquipTurnHandler)
+        self.turnhandler = self.attacker.db.combat_TurnHandler
+        self.assertTrue(self.attacker.db.combat_TurnHandler)
+        # Set the turn handler's interval very high to keep it from repeating during tests.
+        self.turnhandler.interval = 10000
+        # Force turn order
+        self.turnhandler.db.fighters = [self.attacker, self.defender]
+        self.turnhandler.db.turn = 0
+        # Test is turn
+        self.assertTrue(tb_equip.is_turn(self.attacker))
+        # Spend actions
+        self.attacker.db.Combat_ActionsLeft = 1
+        tb_equip.spend_action(self.attacker, 1, action_name="Test")
+        self.assertTrue(self.attacker.db.Combat_ActionsLeft == 0)
+        self.assertTrue(self.attacker.db.Combat_LastAction == "Test")
+        # Initialize for combat
+        self.attacker.db.Combat_ActionsLeft = 983
+        self.turnhandler.initialize_for_combat(self.attacker)
+        self.assertTrue(self.attacker.db.Combat_ActionsLeft == 0)
+        self.assertTrue(self.attacker.db.Combat_LastAction == "null")
+        # Start turn
+        self.defender.db.Combat_ActionsLeft = 0
+        self.turnhandler.start_turn(self.defender)
+        self.assertTrue(self.defender.db.Combat_ActionsLeft == 1)
+        # Next turn
+        self.turnhandler.db.fighters = [self.attacker, self.defender]
+        self.turnhandler.db.turn = 0
+        self.turnhandler.next_turn()
+        self.assertTrue(self.turnhandler.db.turn == 1)
+        # Turn end check
+        self.turnhandler.db.fighters = [self.attacker, self.defender]
+        self.turnhandler.db.turn = 0
+        self.attacker.db.Combat_ActionsLeft = 0
+        self.turnhandler.turn_end_check(self.attacker)
+        self.assertTrue(self.turnhandler.db.turn == 1)
+        # Join fight
+        self.turnhandler.db.fighters = [self.attacker, self.defender]
+        self.turnhandler.db.turn = 0
+        self.turnhandler.join_fight(self.joiner)
+        self.assertTrue(self.turnhandler.db.turn == 1)
+        self.assertTrue(self.turnhandler.db.fighters == [self.joiner, self.attacker, self.defender])
+
+
+class TestTurnBattleRangeFunc(EvenniaTest):
+
+    def setUp(self):
+        super(TestTurnBattleRangeFunc, self).setUp()
+        self.testroom = create_object(DefaultRoom, key="Test Room")
+        self.attacker = create_object(tb_range.TBRangeCharacter, key="Attacker", location=self.testroom)
+        self.defender = create_object(tb_range.TBRangeCharacter, key="Defender", location=self.testroom)
+        self.joiner = create_object(tb_range.TBRangeCharacter, key="Joiner", location=self.testroom)
+
+    def tearDown(self):
+        super(TestTurnBattleRangeFunc, self).tearDown()
+        self.attacker.delete()
+        self.defender.delete()
+        self.joiner.delete()
+        self.testroom.delete()
+        self.turnhandler.stop()
+
+    # Test combat functions in tb_range too.
+    def test_tbrangefunc(self):
+        # Initiative roll
+        initiative = tb_range.roll_init(self.attacker)
+        self.assertTrue(initiative >= 0 and initiative <= 1000)
+        # Attack roll
+        attack_roll = tb_range.get_attack(self.attacker, self.defender, "test")
+        self.assertTrue(attack_roll >= 0 and attack_roll <= 100)
+        # Defense roll
+        defense_roll = tb_range.get_defense(self.attacker, self.defender, "test")
+        self.assertTrue(defense_roll == 50)
+        # Damage roll
+        damage_roll = tb_range.get_damage(self.attacker, self.defender)
+        self.assertTrue(damage_roll >= 15 and damage_roll <= 25)
+        # Apply damage
+        self.defender.db.hp = 10
+        tb_range.apply_damage(self.defender, 3)
+        self.assertTrue(self.defender.db.hp == 7)
+        # Resolve attack
+        self.defender.db.hp = 40
+        tb_range.resolve_attack(self.attacker, self.defender, "test", attack_value=20, defense_value=10)
+        self.assertTrue(self.defender.db.hp < 40)
+        # Combat cleanup
+        self.attacker.db.Combat_attribute = True
+        tb_range.combat_cleanup(self.attacker)
+        self.assertFalse(self.attacker.db.combat_attribute)
+        # Is in combat
+        self.assertFalse(tb_range.is_in_combat(self.attacker))
+        # Set up turn handler script for further tests
+        self.attacker.location.scripts.add(tb_range.TBRangeTurnHandler)
+        self.turnhandler = self.attacker.db.combat_TurnHandler
+        self.assertTrue(self.attacker.db.combat_TurnHandler)
+        # Set the turn handler's interval very high to keep it from repeating during tests.
+        self.turnhandler.interval = 10000
+        # Force turn order
+        self.turnhandler.db.fighters = [self.attacker, self.defender]
+        self.turnhandler.db.turn = 0
+        # Test is turn
+        self.assertTrue(tb_range.is_turn(self.attacker))
+        # Spend actions
+        self.attacker.db.Combat_ActionsLeft = 1
+        tb_range.spend_action(self.attacker, 1, action_name="Test")
+        self.assertTrue(self.attacker.db.Combat_ActionsLeft == 0)
+        self.assertTrue(self.attacker.db.Combat_LastAction == "Test")
+        # Initialize for combat
+        self.attacker.db.Combat_ActionsLeft = 983
+        self.turnhandler.initialize_for_combat(self.attacker)
+        self.assertTrue(self.attacker.db.Combat_ActionsLeft == 0)
+        self.assertTrue(self.attacker.db.Combat_LastAction == "null")
+        # Set up ranges again, since initialize_for_combat clears them
+        self.attacker.db.combat_range = {}
+        self.attacker.db.combat_range[self.attacker] = 0
+        self.attacker.db.combat_range[self.defender] = 1
+        self.defender.db.combat_range = {}
+        self.defender.db.combat_range[self.defender] = 0
+        self.defender.db.combat_range[self.attacker] = 1
+        # Start turn
+        self.defender.db.Combat_ActionsLeft = 0
+        self.turnhandler.start_turn(self.defender)
+        self.assertTrue(self.defender.db.Combat_ActionsLeft == 2)
+        # Next turn
+        self.turnhandler.db.fighters = [self.attacker, self.defender]
+        self.turnhandler.db.turn = 0
+        self.turnhandler.next_turn()
+        self.assertTrue(self.turnhandler.db.turn == 1)
+        # Turn end check
+        self.turnhandler.db.fighters = [self.attacker, self.defender]
+        self.turnhandler.db.turn = 0
+        self.attacker.db.Combat_ActionsLeft = 0
+        self.turnhandler.turn_end_check(self.attacker)
+        self.assertTrue(self.turnhandler.db.turn == 1)
+        # Join fight
+        self.turnhandler.db.fighters = [self.attacker, self.defender]
+        self.turnhandler.db.turn = 0
+        self.turnhandler.join_fight(self.joiner)
+        self.assertTrue(self.turnhandler.db.turn == 1)
+        self.assertTrue(self.turnhandler.db.fighters == [self.joiner, self.attacker, self.defender])
+        # Now, test for approach/withdraw functions
+        self.assertTrue(tb_range.get_range(self.attacker, self.defender) == 1)
+        # Approach
+        tb_range.approach(self.attacker, self.defender)
+        self.assertTrue(tb_range.get_range(self.attacker, self.defender) == 0)
+        # Withdraw
+        tb_range.withdraw(self.attacker, self.defender)
+        self.assertTrue(tb_range.get_range(self.attacker, self.defender) == 1)
+
+
+class TestTurnBattleItemsFunc(EvenniaTest):
+
+    @patch("evennia.contrib.turnbattle.tb_items.tickerhandler", new=MagicMock())
+    def setUp(self):
+        super(TestTurnBattleItemsFunc, self).setUp()
+        self.testroom = create_object(DefaultRoom, key="Test Room")
+        self.attacker = create_object(tb_items.TBItemsCharacter, key="Attacker", location=self.testroom)
+        self.defender = create_object(tb_items.TBItemsCharacter, key="Defender", location=self.testroom)
+        self.joiner = create_object(tb_items.TBItemsCharacter, key="Joiner", location=self.testroom)
+        self.user = create_object(tb_items.TBItemsCharacter, key="User", location=self.testroom)
+        self.test_healpotion = create_object(key="healing potion")
+        self.test_healpotion.db.item_func = "heal"
+        self.test_healpotion.db.item_uses = 3
+
+    def tearDown(self):
+        super(TestTurnBattleItemsFunc, self).tearDown()
+        self.attacker.delete()
+        self.defender.delete()
+        self.joiner.delete()
+        self.user.delete()
+        self.testroom.delete()
+        self.turnhandler.stop()
+
+    # Test functions in tb_items.
+    def test_tbitemsfunc(self):
+        # Initiative roll
+        initiative = tb_items.roll_init(self.attacker)
+        self.assertTrue(initiative >= 0 and initiative <= 1000)
+        # Attack roll
+        attack_roll = tb_items.get_attack(self.attacker, self.defender)
+        self.assertTrue(attack_roll >= 0 and attack_roll <= 100)
+        # Defense roll
+        defense_roll = tb_items.get_defense(self.attacker, self.defender)
+        self.assertTrue(defense_roll == 50)
+        # Damage roll
+        damage_roll = tb_items.get_damage(self.attacker, self.defender)
+        self.assertTrue(damage_roll >= 15 and damage_roll <= 25)
+        # Apply damage
+        self.defender.db.hp = 10
+        tb_items.apply_damage(self.defender, 3)
+        self.assertTrue(self.defender.db.hp == 7)
+        # Resolve attack
+        self.defender.db.hp = 40
+        tb_items.resolve_attack(self.attacker, self.defender, attack_value=20, defense_value=10)
+        self.assertTrue(self.defender.db.hp < 40)
+        # Combat cleanup
+        self.attacker.db.Combat_attribute = True
+        tb_items.combat_cleanup(self.attacker)
+        self.assertFalse(self.attacker.db.combat_attribute)
+        # Is in combat
+        self.assertFalse(tb_items.is_in_combat(self.attacker))
+        # Set up turn handler script for further tests
+        self.attacker.location.scripts.add(tb_items.TBItemsTurnHandler)
+        self.turnhandler = self.attacker.db.combat_TurnHandler
+        self.assertTrue(self.attacker.db.combat_TurnHandler)
+        # Set the turn handler's interval very high to keep it from repeating during tests.
+        self.turnhandler.interval = 10000
+        # Force turn order
+        self.turnhandler.db.fighters = [self.attacker, self.defender]
+        self.turnhandler.db.turn = 0
+        # Test is turn
+        self.assertTrue(tb_items.is_turn(self.attacker))
+        # Spend actions
+        self.attacker.db.Combat_ActionsLeft = 1
+        tb_items.spend_action(self.attacker, 1, action_name="Test")
+        self.assertTrue(self.attacker.db.Combat_ActionsLeft == 0)
+        self.assertTrue(self.attacker.db.Combat_LastAction == "Test")
+        # Initialize for combat
+        self.attacker.db.Combat_ActionsLeft = 983
+        self.turnhandler.initialize_for_combat(self.attacker)
+        self.assertTrue(self.attacker.db.Combat_ActionsLeft == 0)
+        self.assertTrue(self.attacker.db.Combat_LastAction == "null")
+        # Start turn
+        self.defender.db.Combat_ActionsLeft = 0
+        self.turnhandler.start_turn(self.defender)
+        self.assertTrue(self.defender.db.Combat_ActionsLeft == 1)
+        # Next turn
+        self.turnhandler.db.fighters = [self.attacker, self.defender]
+        self.turnhandler.db.turn = 0
+        self.turnhandler.next_turn()
+        self.assertTrue(self.turnhandler.db.turn == 1)
+        # Turn end check
+        self.turnhandler.db.fighters = [self.attacker, self.defender]
+        self.turnhandler.db.turn = 0
+        self.attacker.db.Combat_ActionsLeft = 0
+        self.turnhandler.turn_end_check(self.attacker)
+        self.assertTrue(self.turnhandler.db.turn == 1)
+        # Join fight
+        self.turnhandler.db.fighters = [self.attacker, self.defender]
+        self.turnhandler.db.turn = 0
+        self.turnhandler.join_fight(self.joiner)
+        self.assertTrue(self.turnhandler.db.turn == 1)
+        self.assertTrue(self.turnhandler.db.fighters == [self.joiner, self.attacker, self.defender])
+        # Now time to test item stuff.
+        # Spend item use
+        tb_items.spend_item_use(self.test_healpotion, self.user)
+        self.assertTrue(self.test_healpotion.db.item_uses == 2)
+        # Use item
+        self.user.db.hp = 2
+        tb_items.use_item(self.user, self.test_healpotion, self.user)
+        self.assertTrue(self.user.db.hp > 2)
+        # Add contition
+        tb_items.add_condition(self.user, self.user, "Test", 5)
+        self.assertTrue(self.user.db.conditions == {"Test":[5, self.user]})
+        # Condition tickdown
+        tb_items.condition_tickdown(self.user, self.user)
+        self.assertTrue(self.user.db.conditions == {"Test":[4, self.user]})
+        # Test item functions now!
+        # Item heal
+        self.user.db.hp = 2
+        tb_items.itemfunc_heal(self.test_healpotion, self.user, self.user)
+        # Item add condition
+        self.user.db.conditions = {}
+        tb_items.itemfunc_add_condition(self.test_healpotion, self.user, self.user)
+        self.assertTrue(self.user.db.conditions == {"Regeneration":[5, self.user]})
+        # Item cure condition
+        self.user.db.conditions = {"Poisoned":[5, self.user]}
+        tb_items.itemfunc_cure_condition(self.test_healpotion, self.user, self.user)
+        self.assertTrue(self.user.db.conditions == {})
+
+
+class TestTurnBattleMagicFunc(EvenniaTest):
+
+    def setUp(self):
+        super(TestTurnBattleMagicFunc, self).setUp()
+        self.testroom = create_object(DefaultRoom, key="Test Room")
+        self.attacker = create_object(tb_magic.TBMagicCharacter, key="Attacker", location=self.testroom)
+        self.defender = create_object(tb_magic.TBMagicCharacter, key="Defender", location=self.testroom)
+        self.joiner = create_object(tb_magic.TBMagicCharacter, key="Joiner", location=self.testroom)
+
+    def tearDown(self):
+        super(TestTurnBattleMagicFunc, self).tearDown()
+        self.attacker.delete()
+        self.defender.delete()
+        self.joiner.delete()
+        self.testroom.delete()
+        self.turnhandler.stop()
+
+    # Test combat functions in tb_magic.
+    def test_tbbasicfunc(self):
+        # Initiative roll
+        initiative = tb_magic.roll_init(self.attacker)
+        self.assertTrue(initiative >= 0 and initiative <= 1000)
+        # Attack roll
+        attack_roll = tb_magic.get_attack(self.attacker, self.defender)
+        self.assertTrue(attack_roll >= 0 and attack_roll <= 100)
+        # Defense roll
+        defense_roll = tb_magic.get_defense(self.attacker, self.defender)
+        self.assertTrue(defense_roll == 50)
+        # Damage roll
+        damage_roll = tb_magic.get_damage(self.attacker, self.defender)
+        self.assertTrue(damage_roll >= 15 and damage_roll <= 25)
+        # Apply damage
+        self.defender.db.hp = 10
+        tb_magic.apply_damage(self.defender, 3)
+        self.assertTrue(self.defender.db.hp == 7)
+        # Resolve attack
+        self.defender.db.hp = 40
+        tb_magic.resolve_attack(self.attacker, self.defender, attack_value=20, defense_value=10)
+        self.assertTrue(self.defender.db.hp < 40)
+        # Combat cleanup
+        self.attacker.db.Combat_attribute = True
+        tb_magic.combat_cleanup(self.attacker)
+        self.assertFalse(self.attacker.db.combat_attribute)
+        # Is in combat
+        self.assertFalse(tb_magic.is_in_combat(self.attacker))
+        # Set up turn handler script for further tests
+        self.attacker.location.scripts.add(tb_magic.TBMagicTurnHandler)
+        self.turnhandler = self.attacker.db.combat_TurnHandler
+        self.assertTrue(self.attacker.db.combat_TurnHandler)
+        # Set the turn handler's interval very high to keep it from repeating during tests.
+        self.turnhandler.interval = 10000
+        # Force turn order
+        self.turnhandler.db.fighters = [self.attacker, self.defender]
+        self.turnhandler.db.turn = 0
+        # Test is turn
+        self.assertTrue(tb_magic.is_turn(self.attacker))
+        # Spend actions
+        self.attacker.db.Combat_ActionsLeft = 1
+        tb_magic.spend_action(self.attacker, 1, action_name="Test")
+        self.assertTrue(self.attacker.db.Combat_ActionsLeft == 0)
+        self.assertTrue(self.attacker.db.Combat_LastAction == "Test")
+        # Initialize for combat
+        self.attacker.db.Combat_ActionsLeft = 983
+        self.turnhandler.initialize_for_combat(self.attacker)
+        self.assertTrue(self.attacker.db.Combat_ActionsLeft == 0)
+        self.assertTrue(self.attacker.db.Combat_LastAction == "null")
+        # Start turn
+        self.defender.db.Combat_ActionsLeft = 0
+        self.turnhandler.start_turn(self.defender)
+        self.assertTrue(self.defender.db.Combat_ActionsLeft == 1)
+        # Next turn
+        self.turnhandler.db.fighters = [self.attacker, self.defender]
+        self.turnhandler.db.turn = 0
+        self.turnhandler.next_turn()
+        self.assertTrue(self.turnhandler.db.turn == 1)
+        # Turn end check
+        self.turnhandler.db.fighters = [self.attacker, self.defender]
+        self.turnhandler.db.turn = 0
+        self.attacker.db.Combat_ActionsLeft = 0
+        self.turnhandler.turn_end_check(self.attacker)
+        self.assertTrue(self.turnhandler.db.turn == 1)
+        # Join fight
+        self.turnhandler.db.fighters = [self.attacker, self.defender]
+        self.turnhandler.db.turn = 0
+        self.turnhandler.join_fight(self.joiner)
+        self.assertTrue(self.turnhandler.db.turn == 1)
+        self.assertTrue(self.turnhandler.db.fighters == [self.joiner, self.attacker, self.defender])
+
+
+# Test tree select
+
+from evennia.contrib import tree_select
+
+TREE_MENU_TESTSTR = """Foo
+Bar
+-Baz
+--Baz 1
+--Baz 2
+-Qux"""
+
+
+class TestTreeSelectFunc(EvenniaTest):
+
+    def test_tree_functions(self):
+        # Dash counter
+        self.assertTrue(tree_select.dashcount("--test") == 2)
+        # Is category
+        self.assertTrue(tree_select.is_category(TREE_MENU_TESTSTR, 1) == True)
+        # Parse options
+        self.assertTrue(tree_select.parse_opts(TREE_MENU_TESTSTR, category_index=2) == [(3, "Baz 1"), (4, "Baz 2")])
+        # Index to selection
+        self.assertTrue(tree_select.index_to_selection(TREE_MENU_TESTSTR, 2) == "Baz")
+        # Go up one category
+        self.assertTrue(tree_select.go_up_one_category(TREE_MENU_TESTSTR, 4) == 2)
+        # Option list to menu options
+        test_optlist = tree_select.parse_opts(TREE_MENU_TESTSTR, category_index=2)
+        optlist_to_menu_expected_result = [{'goto': ['menunode_treeselect', {'newindex': 3}], 'key': 'Baz 1'},
+        {'goto': ['menunode_treeselect', {'newindex': 4}], 'key': 'Baz 2'},
+        {'goto': ['menunode_treeselect', {'newindex': 1}], 'key': ['<< Go Back', 'go back', 'back'], 'desc': 'Return to the previous menu.'}]
+        self.assertTrue(tree_select.optlist_to_menuoptions(TREE_MENU_TESTSTR, test_optlist, 2, True, True) == optlist_to_menu_expected_result)
+
+# Test field fill
+
+from evennia.contrib import fieldfill
+
+FIELD_TEST_TEMPLATE = [
+{"fieldname":"TextTest", "fieldtype":"text"},
+{"fieldname":"NumberTest", "fieldtype":"number", "blankmsg":"Number here!"},
+{"fieldname":"DefaultText", "fieldtype":"text", "default":"Test"},
+{"fieldname":"DefaultNum", "fieldtype":"number", "default":3}
+]
+
+FIELD_TEST_DATA = {"TextTest":None, "NumberTest":None, "DefaultText":"Test", "DefaultNum":3}
+
+class TestFieldFillFunc(EvenniaTest):
+
+    def test_field_functions(self):
+        self.assertTrue(fieldfill.form_template_to_dict(FIELD_TEST_TEMPLATE) == FIELD_TEST_DATA)
+
 # Test of the unixcommand module
 
 from evennia.contrib.unixcommand import UnixCommand
@@ -1850,3 +2395,148 @@ class TestPuzzles(CommandTest):
             'pasta': 2,
             'boiled egg': 1,
         })
+
+# Tests for the building_menu contrib
+from evennia.contrib.building_menu import BuildingMenu, CmdNoInput, CmdNoMatch
+
+class Submenu(BuildingMenu):
+    def init(self, exit):
+        self.add_choice("title", key="t", attr="key")
+
+class TestBuildingMenu(CommandTest):
+
+    def setUp(self):
+        super(TestBuildingMenu, self).setUp()
+        self.menu = BuildingMenu(caller=self.char1, obj=self.room1, title="test")
+        self.menu.add_choice("title", key="t", attr="key")
+
+    def test_quit(self):
+        """Try to quit the building menu."""
+        self.assertFalse(self.char1.cmdset.has("building_menu"))
+        self.menu.open()
+        self.assertTrue(self.char1.cmdset.has("building_menu"))
+        self.call(CmdNoMatch(building_menu=self.menu), "q")
+        # char1 tries to quit the editor
+        self.assertFalse(self.char1.cmdset.has("building_menu"))
+
+    def test_setattr(self):
+        """Test the simple setattr provided by building menus."""
+        key = self.room1.key
+        self.menu.open()
+        self.call(CmdNoMatch(building_menu=self.menu), "t")
+        self.assertIsNotNone(self.menu.current_choice)
+        self.call(CmdNoMatch(building_menu=self.menu), "some new title")
+        self.call(CmdNoMatch(building_menu=self.menu), "@")
+        self.assertIsNone(self.menu.current_choice)
+        self.assertEqual(self.room1.key, "some new title")
+        self.call(CmdNoMatch(building_menu=self.menu), "q")
+
+    def test_add_choice_without_key(self):
+        """Try to add choices without keys."""
+        choices = []
+        for i in range(20):
+            choices.append(self.menu.add_choice("choice", attr="test"))
+        self.menu._add_keys_choice()
+        keys = ["c", "h", "o", "i", "e", "ch", "ho", "oi", "ic", "ce", "cho", "hoi", "oic", "ice", "choi", "hoic", "oice", "choic", "hoice", "choice"]
+        for i in range(20):
+            self.assertEqual(choices[i].key, keys[i])
+
+        # Adding another key of the same title would break, no more available shortcut
+        self.menu.add_choice("choice", attr="test")
+        with self.assertRaises(ValueError):
+            self.menu._add_keys_choice()
+
+    def test_callbacks(self):
+        """Test callbacks in menus."""
+        self.room1.key = "room1"
+        def on_enter(caller, menu):
+            caller.msg("on_enter:{}".format(menu.title))
+        def on_nomatch(caller, string, choice):
+            caller.msg("on_nomatch:{},{}".format(string, choice.key))
+        def on_leave(caller, obj):
+            caller.msg("on_leave:{}".format(obj.key))
+        self.menu.add_choice("test", key="e", on_enter=on_enter, on_nomatch=on_nomatch, on_leave=on_leave)
+        self.call(CmdNoMatch(building_menu=self.menu), "e", "on_enter:test")
+        self.call(CmdNoMatch(building_menu=self.menu), "ok", "on_nomatch:ok,e")
+        self.call(CmdNoMatch(building_menu=self.menu), "@", "on_leave:room1")
+        self.call(CmdNoMatch(building_menu=self.menu), "q")
+
+    def test_multi_level(self):
+        """Test multi-level choices."""
+        # Creaste three succeeding menu (t2 is contained in t1, t3 is contained in t2)
+        def on_nomatch_t1(caller, menu):
+            menu.move("whatever") # this will be valid since after t1 is a joker
+
+        def on_nomatch_t2(caller, menu):
+            menu.move("t3") # this time the key matters
+
+        t1 = self.menu.add_choice("what", key="t1", on_nomatch=on_nomatch_t1)
+        t2 = self.menu.add_choice("and", key="t1.*", on_nomatch=on_nomatch_t2)
+        t3 = self.menu.add_choice("why", key="t1.*.t3")
+        self.menu.open()
+
+        # Move into t1
+        self.assertIn(t1, self.menu.relevant_choices)
+        self.assertNotIn(t2, self.menu.relevant_choices)
+        self.assertNotIn(t3, self.menu.relevant_choices)
+        self.assertIsNone(self.menu.current_choice)
+        self.call(CmdNoMatch(building_menu=self.menu), "t1")
+        self.assertEqual(self.menu.current_choice, t1)
+        self.assertNotIn(t1, self.menu.relevant_choices)
+        self.assertIn(t2, self.menu.relevant_choices)
+        self.assertNotIn(t3, self.menu.relevant_choices)
+
+        # Move into t2
+        self.call(CmdNoMatch(building_menu=self.menu), "t2")
+        self.assertEqual(self.menu.current_choice, t2)
+        self.assertNotIn(t1, self.menu.relevant_choices)
+        self.assertNotIn(t2, self.menu.relevant_choices)
+        self.assertIn(t3, self.menu.relevant_choices)
+
+        # Move into t3
+        self.call(CmdNoMatch(building_menu=self.menu), "t3")
+        self.assertEqual(self.menu.current_choice, t3)
+        self.assertNotIn(t1, self.menu.relevant_choices)
+        self.assertNotIn(t2, self.menu.relevant_choices)
+        self.assertNotIn(t3, self.menu.relevant_choices)
+
+        # Move back to t2
+        self.call(CmdNoMatch(building_menu=self.menu), "@")
+        self.assertEqual(self.menu.current_choice, t2)
+        self.assertNotIn(t1, self.menu.relevant_choices)
+        self.assertNotIn(t2, self.menu.relevant_choices)
+        self.assertIn(t3, self.menu.relevant_choices)
+
+        # Move back into t1
+        self.call(CmdNoMatch(building_menu=self.menu), "@")
+        self.assertEqual(self.menu.current_choice, t1)
+        self.assertNotIn(t1, self.menu.relevant_choices)
+        self.assertIn(t2, self.menu.relevant_choices)
+        self.assertNotIn(t3, self.menu.relevant_choices)
+
+        # Moves back to the main menu
+        self.call(CmdNoMatch(building_menu=self.menu), "@")
+        self.assertIn(t1, self.menu.relevant_choices)
+        self.assertNotIn(t2, self.menu.relevant_choices)
+        self.assertNotIn(t3, self.menu.relevant_choices)
+        self.assertIsNone(self.menu.current_choice)
+        self.call(CmdNoMatch(building_menu=self.menu), "q")
+
+    def test_submenu(self):
+        """Test to add sub-menus."""
+        def open_exit(menu):
+            menu.open_submenu("evennia.contrib.tests.Submenu", self.exit)
+            return False
+
+        self.menu.add_choice("exit", key="x", on_enter=open_exit)
+        self.menu.open()
+        self.call(CmdNoMatch(building_menu=self.menu), "x")
+        self.menu = self.char1.ndb._building_menu
+        self.call(CmdNoMatch(building_menu=self.menu), "t")
+        self.call(CmdNoMatch(building_menu=self.menu), "in")
+        self.call(CmdNoMatch(building_menu=self.menu), "@")
+        self.call(CmdNoMatch(building_menu=self.menu), "@")
+        self.menu = self.char1.ndb._building_menu
+        self.assertEqual(self.char1.ndb._building_menu.obj, self.room1)
+        self.call(CmdNoMatch(building_menu=self.menu), "q")
+        self.assertEqual(self.exit.key, "in")