Merge branch 'develop' into building_menu
This commit is contained in:
Vincent Le Goff
commit
415322fe1a
60 changed files with 10614 additions and 1566 deletions
|
|
@ -31,6 +31,7 @@ things you want from here into your game folder and change them there.
|
|||
multiple descriptions for time and season as well as details.
|
||||
* GenderSub (Griatch 2015) - Simple example (only) of storing gender
|
||||
on a character and access it in an emote with a custom marker.
|
||||
* Health Bar (Tim Ashley Jenkins 2017) - Tool to create colorful bars/meters.
|
||||
* Mail (grungies1138 2016) - An in-game mail system for communication.
|
||||
* Menu login (Griatch 2011) - A login system using menus asking
|
||||
for name/password rather than giving them as one command.
|
||||
|
|
@ -53,6 +54,9 @@ things you want from here into your game folder and change them there.
|
|||
* Tree Select (FlutterSprite 2017) - A simple system for creating a
|
||||
branching EvMenu with selection options sourced from a single
|
||||
multi-line string.
|
||||
* Turnbattle (Tim Ashley Jenkins 2017) - This is a framework for a turn-based
|
||||
combat system with different levels of complexity, including versions with
|
||||
equipment and magic as well as ranged combat.
|
||||
* Wilderness (titeuf87 2017) - Make infinitely large wilderness areas
|
||||
with dynamically created locations.
|
||||
* UnixCommand (Vincent Le Geoff 2017) - Add commands with UNIX-style syntax.
|
||||
|
|
|
|||
|
|
@ -253,7 +253,7 @@ class CmdMail(default_cmds.MuxCommand):
|
|||
index += 1
|
||||
|
||||
table.reformat_column(0, width=6)
|
||||
table.reformat_column(1, width=17)
|
||||
table.reformat_column(1, width=18)
|
||||
table.reformat_column(2, width=34)
|
||||
table.reformat_column(3, width=13)
|
||||
table.reformat_column(4, width=7)
|
||||
|
|
|
|||
|
|
@ -1088,7 +1088,7 @@ class CmdMask(RPCommand):
|
|||
if self.cmdstring == "mask":
|
||||
# wear a mask
|
||||
if not self.args:
|
||||
caller.msg("Usage: (un)wearmask sdesc")
|
||||
caller.msg("Usage: (un)mask sdesc")
|
||||
return
|
||||
if caller.db.unmasked_sdesc:
|
||||
caller.msg("You are already wearing a mask.")
|
||||
|
|
@ -1111,7 +1111,7 @@ class CmdMask(RPCommand):
|
|||
del caller.db.unmasked_sdesc
|
||||
caller.locks.remove("enable_recog")
|
||||
caller.sdesc.add(old_sdesc)
|
||||
caller.msg("You remove your mask and is again '%s'." % old_sdesc)
|
||||
caller.msg("You remove your mask and are again '%s'." % old_sdesc)
|
||||
|
||||
|
||||
class RPSystemCmdSet(CmdSet):
|
||||
|
|
|
|||
|
|
@ -697,7 +697,7 @@ class TestMail(CommandTest):
|
|||
"You have received a new @mail from TestAccount2(account 2)|You sent your message.", caller=self.account2)
|
||||
self.call(mail.CmdMail(), "TestAccount=Message 1", "You sent your message.", caller=self.account2)
|
||||
self.call(mail.CmdMail(), "TestAccount=Message 2", "You sent your message.", caller=self.account2)
|
||||
self.call(mail.CmdMail(), "", "| ID: From: Subject:", caller=self.account)
|
||||
self.call(mail.CmdMail(), "", "| ID: From: Subject:", caller=self.account)
|
||||
self.call(mail.CmdMail(), "2", "From: TestAccount2", caller=self.account)
|
||||
self.call(mail.CmdMail(), "/forward TestAccount2 = 1/Forward message", "You sent your message.|Message forwarded.", caller=self.account)
|
||||
self.call(mail.CmdMail(), "/reply 2=Reply Message2", "You sent your message.", caller=self.account)
|
||||
|
|
@ -723,9 +723,9 @@ class TestMapBuilder(CommandTest):
|
|||
"evennia.contrib.mapbuilder.EXAMPLE2_MAP evennia.contrib.mapbuilder.EXAMPLE2_LEGEND",
|
||||
"""Creating Map...|≈ ≈ ≈ ≈ ≈
|
||||
|
||||
≈ ♣♣♣ ≈
|
||||
≈ ♣-♣-♣ ≈
|
||||
≈ ♣ ♣ ♣ ≈
|
||||
≈ ♣♣♣ ≈
|
||||
≈ ♣-♣-♣ ≈
|
||||
|
||||
≈ ≈ ≈ ≈ ≈
|
||||
|Creating Landmass...|""")
|
||||
|
|
@ -768,8 +768,8 @@ from evennia.contrib import simpledoor
|
|||
class TestSimpleDoor(CommandTest):
|
||||
def test_cmdopen(self):
|
||||
self.call(simpledoor.CmdOpen(), "newdoor;door:contrib.simpledoor.SimpleDoor,backdoor;door = Room2",
|
||||
"Created new Exit 'newdoor' from Room to Room2 (aliases: door).|Note: A doortype exit was "
|
||||
"created ignored eventual custom returnexit type.|Created new Exit 'newdoor' from Room2 to Room (aliases: door).")
|
||||
"Created new Exit 'newdoor' from Room to Room2 (aliases: door).|Note: A door-type exit was "
|
||||
"created - ignored eventual custom return-exit type.|Created new Exit 'newdoor' from Room2 to Room (aliases: door).")
|
||||
self.call(simpledoor.CmdOpenCloseDoor(), "newdoor", "You close newdoor.", cmdstring="close")
|
||||
self.call(simpledoor.CmdOpenCloseDoor(), "newdoor", "newdoor is already closed.", cmdstring="close")
|
||||
self.call(simpledoor.CmdOpenCloseDoor(), "newdoor", "You open newdoor.", cmdstring="open")
|
||||
|
|
@ -798,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()
|
||||
|
||||
|
||||
|
|
@ -953,13 +953,13 @@ class TestTutorialWorldRooms(CommandTest):
|
|||
|
||||
|
||||
# test turnbattle
|
||||
from evennia.contrib.turnbattle import tb_basic, tb_equip, tb_range
|
||||
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(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)")
|
||||
|
|
@ -967,13 +967,19 @@ class TestTurnBattleCmd(CommandTest):
|
|||
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 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.
|
||||
testweapon = create_object(tb_equip.TBEWeapon, key="test weapon")
|
||||
testarmor = create_object(tb_equip.TBEArmor, key="test armor")
|
||||
testweapon.move_to(self.char1)
|
||||
testarmor.move_to(self.char1)
|
||||
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.")
|
||||
|
|
@ -985,6 +991,8 @@ class TestTurnBattleCmd(CommandTest):
|
|||
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.
|
||||
|
|
@ -1000,257 +1008,531 @@ class TestTurnBattleCmd(CommandTest):
|
|||
self.call(tb_range.CmdRest(), "", "Char rests to recover HP.")
|
||||
|
||||
|
||||
class TestTurnBattleFunc(EvenniaTest):
|
||||
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_tbbasicfunc(self):
|
||||
attacker = create_object(tb_basic.TBBasicCharacter, key="Attacker")
|
||||
defender = create_object(tb_basic.TBBasicCharacter, key="Defender")
|
||||
testroom = create_object(DefaultRoom, key="Test Room")
|
||||
attacker.location = testroom
|
||||
defender.loaction = testroom
|
||||
# Initiative roll
|
||||
initiative = tb_basic.roll_init(attacker)
|
||||
initiative = tb_basic.roll_init(self.attacker)
|
||||
self.assertTrue(initiative >= 0 and initiative <= 1000)
|
||||
# Attack roll
|
||||
attack_roll = tb_basic.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 = tb_basic.get_defense(attacker, defender)
|
||||
defense_roll = tb_basic.get_defense(self.attacker, self.defender)
|
||||
self.assertTrue(defense_roll == 50)
|
||||
# Damage roll
|
||||
damage_roll = tb_basic.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
|
||||
tb_basic.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
|
||||
tb_basic.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
|
||||
tb_basic.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(tb_basic.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(tb_basic.TBBasicTurnHandler)
|
||||
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.
|
||||
turnhandler.interval = 10000
|
||||
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(tb_basic.is_turn(attacker))
|
||||
self.assertTrue(tb_basic.is_turn(self.attacker))
|
||||
# Spend actions
|
||||
attacker.db.Combat_ActionsLeft = 1
|
||||
tb_basic.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(tb_basic.TBBasicCharacter, 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):
|
||||
attacker = create_object(tb_equip.TBEquipCharacter, key="Attacker")
|
||||
defender = create_object(tb_equip.TBEquipCharacter, key="Defender")
|
||||
testroom = create_object(DefaultRoom, key="Test Room")
|
||||
attacker.location = testroom
|
||||
defender.loaction = testroom
|
||||
# Initiative roll
|
||||
initiative = tb_equip.roll_init(attacker)
|
||||
initiative = tb_equip.roll_init(self.attacker)
|
||||
self.assertTrue(initiative >= 0 and initiative <= 1000)
|
||||
# Attack roll
|
||||
attack_roll = tb_equip.get_attack(attacker, defender)
|
||||
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(attacker, defender)
|
||||
defense_roll = tb_equip.get_defense(self.attacker, self.defender)
|
||||
self.assertTrue(defense_roll == 50)
|
||||
# Damage roll
|
||||
damage_roll = tb_equip.get_damage(attacker, defender)
|
||||
damage_roll = tb_equip.get_damage(self.attacker, self.defender)
|
||||
self.assertTrue(damage_roll >= 0 and damage_roll <= 50)
|
||||
# Apply damage
|
||||
defender.db.hp = 10
|
||||
tb_equip.apply_damage(defender, 3)
|
||||
self.assertTrue(defender.db.hp == 7)
|
||||
self.defender.db.hp = 10
|
||||
tb_equip.apply_damage(self.defender, 3)
|
||||
self.assertTrue(self.defender.db.hp == 7)
|
||||
# Resolve attack
|
||||
defender.db.hp = 40
|
||||
tb_equip.resolve_attack(attacker, defender, attack_value=20, defense_value=10)
|
||||
self.assertTrue(defender.db.hp < 40)
|
||||
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
|
||||
attacker.db.Combat_attribute = True
|
||||
tb_equip.combat_cleanup(attacker)
|
||||
self.assertFalse(attacker.db.combat_attribute)
|
||||
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(attacker))
|
||||
self.assertFalse(tb_equip.is_in_combat(self.attacker))
|
||||
# Set up turn handler script for further tests
|
||||
attacker.location.scripts.add(tb_equip.TBEquipTurnHandler)
|
||||
turnhandler = attacker.db.combat_TurnHandler
|
||||
self.assertTrue(attacker.db.combat_TurnHandler)
|
||||
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.
|
||||
turnhandler.interval = 10000
|
||||
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(tb_equip.is_turn(attacker))
|
||||
self.assertTrue(tb_equip.is_turn(self.attacker))
|
||||
# Spend actions
|
||||
attacker.db.Combat_ActionsLeft = 1
|
||||
tb_equip.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_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
|
||||
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(tb_equip.TBEquipCharacter, 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.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):
|
||||
testroom = create_object(DefaultRoom, key="Test Room")
|
||||
attacker = create_object(tb_range.TBRangeCharacter, key="Attacker", location=testroom)
|
||||
defender = create_object(tb_range.TBRangeCharacter, key="Defender", location=testroom)
|
||||
# Initiative roll
|
||||
initiative = tb_range.roll_init(attacker)
|
||||
initiative = tb_range.roll_init(self.attacker)
|
||||
self.assertTrue(initiative >= 0 and initiative <= 1000)
|
||||
# Attack roll
|
||||
attack_roll = tb_range.get_attack(attacker, defender, "test")
|
||||
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(attacker, defender, "test")
|
||||
defense_roll = tb_range.get_defense(self.attacker, self.defender, "test")
|
||||
self.assertTrue(defense_roll == 50)
|
||||
# Damage roll
|
||||
damage_roll = tb_range.get_damage(attacker, defender)
|
||||
damage_roll = tb_range.get_damage(self.attacker, self.defender)
|
||||
self.assertTrue(damage_roll >= 15 and damage_roll <= 25)
|
||||
# Apply damage
|
||||
defender.db.hp = 10
|
||||
tb_range.apply_damage(defender, 3)
|
||||
self.assertTrue(defender.db.hp == 7)
|
||||
self.defender.db.hp = 10
|
||||
tb_range.apply_damage(self.defender, 3)
|
||||
self.assertTrue(self.defender.db.hp == 7)
|
||||
# Resolve attack
|
||||
defender.db.hp = 40
|
||||
tb_range.resolve_attack(attacker, defender, "test", attack_value=20, defense_value=10)
|
||||
self.assertTrue(defender.db.hp < 40)
|
||||
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
|
||||
attacker.db.Combat_attribute = True
|
||||
tb_range.combat_cleanup(attacker)
|
||||
self.assertFalse(attacker.db.combat_attribute)
|
||||
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(attacker))
|
||||
self.assertFalse(tb_range.is_in_combat(self.attacker))
|
||||
# Set up turn handler script for further tests
|
||||
attacker.location.scripts.add(tb_range.TBRangeTurnHandler)
|
||||
turnhandler = attacker.db.combat_TurnHandler
|
||||
self.assertTrue(attacker.db.combat_TurnHandler)
|
||||
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.
|
||||
turnhandler.interval = 10000
|
||||
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(tb_range.is_turn(attacker))
|
||||
self.assertTrue(tb_range.is_turn(self.attacker))
|
||||
# Spend actions
|
||||
attacker.db.Combat_ActionsLeft = 1
|
||||
tb_range.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_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
|
||||
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")
|
||||
# Set up ranges again, since initialize_for_combat clears them
|
||||
attacker.db.combat_range = {}
|
||||
attacker.db.combat_range[attacker] = 0
|
||||
attacker.db.combat_range[defender] = 1
|
||||
defender.db.combat_range = {}
|
||||
defender.db.combat_range[defender] = 0
|
||||
defender.db.combat_range[attacker] = 1
|
||||
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
|
||||
defender.db.Combat_ActionsLeft = 0
|
||||
turnhandler.start_turn(defender)
|
||||
self.assertTrue(defender.db.Combat_ActionsLeft == 2)
|
||||
self.defender.db.Combat_ActionsLeft = 0
|
||||
self.turnhandler.start_turn(self.defender)
|
||||
self.assertTrue(self.defender.db.Combat_ActionsLeft == 2)
|
||||
# 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(tb_range.TBRangeCharacter, key="Joiner", location=testroom)
|
||||
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])
|
||||
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(attacker, defender) == 1)
|
||||
self.assertTrue(tb_range.get_range(self.attacker, self.defender) == 1)
|
||||
# Approach
|
||||
tb_range.approach(attacker, defender)
|
||||
self.assertTrue(tb_range.get_range(attacker, defender) == 0)
|
||||
tb_range.approach(self.attacker, self.defender)
|
||||
self.assertTrue(tb_range.get_range(self.attacker, self.defender) == 0)
|
||||
# Withdraw
|
||||
tb_range.withdraw(attacker, defender)
|
||||
self.assertTrue(tb_range.get_range(attacker, defender) == 1)
|
||||
# Remove the script at the end
|
||||
turnhandler.stop()
|
||||
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
|
||||
|
||||
|
|
@ -1263,6 +1545,7 @@ Bar
|
|||
--Baz 2
|
||||
-Qux"""
|
||||
|
||||
|
||||
class TestTreeSelectFunc(EvenniaTest):
|
||||
|
||||
def test_tree_functions(self):
|
||||
|
|
|
|||
|
|
@ -21,6 +21,19 @@ implemented and customized:
|
|||
the battle system, including commands for wielding weapons and
|
||||
donning armor, and modifiers to accuracy and damage based on
|
||||
currently used equipment.
|
||||
|
||||
tb_items.py - Adds usable items and conditions/status effects, and gives
|
||||
a lot of examples for each. Items can perform nearly any sort of
|
||||
function, including healing, adding or curing conditions, or
|
||||
being used to attack. Conditions affect a fighter's attributes
|
||||
and options in combat and persist outside of fights, counting
|
||||
down per turn in combat and in real time outside combat.
|
||||
|
||||
tb_magic.py - Adds a spellcasting system, allowing characters to cast
|
||||
spells with a variety of effects by spending MP. Spells are
|
||||
linked to functions, and as such can perform any sort of action
|
||||
the developer can imagine - spells for attacking, healing and
|
||||
conjuring objects are included as examples.
|
||||
|
||||
tb_range.py - Adds a system for abstract positioning and movement, which
|
||||
tracks the distance between different characters and objects in
|
||||
|
|
|
|||
1397
evennia/contrib/turnbattle/tb_items.py
Normal file
1397
evennia/contrib/turnbattle/tb_items.py
Normal file
File diff suppressed because it is too large
Load diff
1290
evennia/contrib/turnbattle/tb_magic.py
Normal file
1290
evennia/contrib/turnbattle/tb_magic.py
Normal file
File diff suppressed because it is too large
Load diff
|
|
@ -24,7 +24,7 @@ import random
|
|||
|
||||
from evennia import DefaultObject, DefaultExit, Command, CmdSet
|
||||
from evennia.utils import search, delay
|
||||
from evennia.utils.spawner import spawn
|
||||
from evennia.prototypes.spawner import spawn
|
||||
|
||||
# -------------------------------------------------------------
|
||||
#
|
||||
|
|
@ -674,7 +674,7 @@ class CrumblingWall(TutorialObject, DefaultExit):
|
|||
# we found the button by moving the roots
|
||||
result = ["Having moved all the roots aside, you find that the center of the wall, "
|
||||
"previously hidden by the vegetation, hid a curious square depression. It was maybe once "
|
||||
"concealed and made to look a part of the wall, but with the crumbling of stone around it,"
|
||||
"concealed and made to look a part of the wall, but with the crumbling of stone around it, "
|
||||
"it's now easily identifiable as some sort of button."]
|
||||
elif self.db.exit_open:
|
||||
# we pressed the button; the exit is open
|
||||
|
|
@ -905,19 +905,19 @@ WEAPON_PROTOTYPES = {
|
|||
"magic": False,
|
||||
"desc": "A generic blade."},
|
||||
"knife": {
|
||||
"prototype": "weapon",
|
||||
"prototype_parent": "weapon",
|
||||
"aliases": "sword",
|
||||
"key": "Kitchen knife",
|
||||
"desc": "A rusty kitchen knife. Better than nothing.",
|
||||
"damage": 3},
|
||||
"dagger": {
|
||||
"prototype": "knife",
|
||||
"prototype_parent": "knife",
|
||||
"key": "Rusty dagger",
|
||||
"aliases": ["knife", "dagger"],
|
||||
"desc": "A double-edged dagger with a nicked edge and a wooden handle.",
|
||||
"hit": 0.25},
|
||||
"sword": {
|
||||
"prototype": "weapon",
|
||||
"prototype_parent": "weapon",
|
||||
"key": "Rusty sword",
|
||||
"aliases": ["sword"],
|
||||
"desc": "A rusty shortsword. It has a leather-wrapped handle covered i food grease.",
|
||||
|
|
@ -925,28 +925,28 @@ WEAPON_PROTOTYPES = {
|
|||
"damage": 5,
|
||||
"parry": 0.5},
|
||||
"club": {
|
||||
"prototype": "weapon",
|
||||
"prototype_parent": "weapon",
|
||||
"key": "Club",
|
||||
"desc": "A heavy wooden club, little more than a heavy branch.",
|
||||
"hit": 0.4,
|
||||
"damage": 6,
|
||||
"parry": 0.2},
|
||||
"axe": {
|
||||
"prototype": "weapon",
|
||||
"prototype_parent": "weapon",
|
||||
"key": "Axe",
|
||||
"desc": "A woodcutter's axe with a keen edge.",
|
||||
"hit": 0.4,
|
||||
"damage": 6,
|
||||
"parry": 0.2},
|
||||
"ornate longsword": {
|
||||
"prototype": "sword",
|
||||
"prototype_parent": "sword",
|
||||
"key": "Ornate longsword",
|
||||
"desc": "A fine longsword with some swirling patterns on the handle.",
|
||||
"hit": 0.5,
|
||||
"magic": True,
|
||||
"damage": 5},
|
||||
"warhammer": {
|
||||
"prototype": "club",
|
||||
"prototype_parent": "club",
|
||||
"key": "Silver Warhammer",
|
||||
"aliases": ["hammer", "warhammer", "war"],
|
||||
"desc": "A heavy war hammer with silver ornaments. This huge weapon causes massive damage - if you can hit.",
|
||||
|
|
@ -954,21 +954,21 @@ WEAPON_PROTOTYPES = {
|
|||
"magic": True,
|
||||
"damage": 8},
|
||||
"rune axe": {
|
||||
"prototype": "axe",
|
||||
"prototype_parent": "axe",
|
||||
"key": "Runeaxe",
|
||||
"aliases": ["axe"],
|
||||
"hit": 0.4,
|
||||
"magic": True,
|
||||
"damage": 6},
|
||||
"thruning": {
|
||||
"prototype": "ornate longsword",
|
||||
"prototype_parent": "ornate longsword",
|
||||
"key": "Broadsword named Thruning",
|
||||
"desc": "This heavy bladed weapon is marked with the name 'Thruning'. It is very powerful in skilled hands.",
|
||||
"hit": 0.6,
|
||||
"parry": 0.6,
|
||||
"damage": 7},
|
||||
"slayer waraxe": {
|
||||
"prototype": "rune axe",
|
||||
"prototype_parent": "rune axe",
|
||||
"key": "Slayer waraxe",
|
||||
"aliases": ["waraxe", "war", "slayer"],
|
||||
"desc": "A huge double-bladed axe marked with the runes for 'Slayer'."
|
||||
|
|
@ -976,7 +976,7 @@ WEAPON_PROTOTYPES = {
|
|||
"hit": 0.7,
|
||||
"damage": 8},
|
||||
"ghostblade": {
|
||||
"prototype": "ornate longsword",
|
||||
"prototype_parent": "ornate longsword",
|
||||
"key": "The Ghostblade",
|
||||
"aliases": ["blade", "ghost"],
|
||||
"desc": "This massive sword is large as you are tall, yet seems to weigh almost nothing."
|
||||
|
|
@ -985,7 +985,7 @@ WEAPON_PROTOTYPES = {
|
|||
"parry": 0.8,
|
||||
"damage": 10},
|
||||
"hawkblade": {
|
||||
"prototype": "ghostblade",
|
||||
"prototype_parent": "ghostblade",
|
||||
"key": "The Hawkblade",
|
||||
"aliases": ["hawk", "blade"],
|
||||
"desc": "The weapon of a long-dead heroine and a more civilized age,"
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue