示例#1
0
def game_loop(t): #(turns)
    
#this loop puts one unit against another until destroyed or out of turns. 
#need to change it so unit take turns to attack each other

    num_turns = t

    while num_turns > 0: # while win == false:

        player = Unit("") # name
        enemy = Unit("") # enemy

        print("Number of turns:", num_turns)
        
        player.name=input("Unit 1 name: ")
        enemy.name=input("Unit 2 name: ")
    
        while enemy.is_alive(): # ==True
           
            player.unit_status()
            enemy.unit_status()

            dice = dice_roll() #10 side die
            result = player.attack(dice, enemy)
          
            num_turns -=1

            f= open("results.txt", "a+")
            f.write(f"attack result {result} \r\n")
            f.close()
        else:
            print(enemy.name, "Destroyed!")
        
    else:
        print("Game Over")
示例#2
0
文件: main.py 项目: Mongoose556/RSR
def game_loop(t):  #(turns)
    ''' this loop puts one unit against another until destroyed or out of turns. '''

    # turn 1, player attacks,
    # if enemy alive then
    # enemy attack else win = true
    # if player alive then
    # turn 2

    num_turns = t
    win = False
    player_unit = Unit("BLUE")  # name
    enemy_unit = Unit("RED")  # enemy

    while player_unit.is_alive and num_turns > 0:
        print(player_unit.name, " turn:")
        player_unit.attack(dice_roll(), enemy_unit)
        print("Status: ", player_unit.unit_status())

        num_turns -= 1

        print("Turns remaining: ", num_turns)
        input("Press a key.")

        if enemy_unit.is_alive:
            # win = False
            print(enemy_unit.name, " turn:")
            enemy_unit.attack(dice_roll(), player_unit)

            print("Status: ", enemy_unit.unit_status())
        else:
            win = True
            print("You Win")

    else:
        print("Game Over")
示例#3
0
## custom class instances
myMainMenu = MainMenu()

myBattleForcast = BattleForcast(gameWidth)
mainCursor = Cursor(tileSize, mapWidth, mapHeight, gameWidth, gameHeight)
myCombatUI = CombatUI(0, gameHeight - 385)
myUnitInfo = UnitInfo()
myMapUnitUI = MapUnitUI(gameWidth, gameHeight)
myExp = Exp()
myLevelUp = LevelUp(gameWidth, gameHeight)

## creating units
protag = Unit(3, 3, tileSize)
protag.inventory.addItem(Bow())
protag.attack = 7
protag.defense = 6
protag.speed = 5
protag.skill = 7
protag.luck = 8

Jagen = Unit(3, 5, tileSize)
Jagen.inventory.addItem(Sword())
Jagen.inventory.addItem(Javelin())
Jagen.inventory.addItem(HealingItem())
Jagen.name = 'Jagen'
Jagen.attack = 15
Jagen.defense = 10
Jagen.speed = 9
Jagen.skill = 8
Jagen.luck = 8
示例#4
0
    data = json.load(f)

game_scenario = GameScenario(a_army_size=1, b_army_size=1, luck=0)

a = Unit(team=1,
         type='A',
         hp=data['classes']['A']['hp'],
         ATK=data['classes']['A']['ATK'],
         DEF=data['classes']['A']['DEF'],
         game_scenario=game_scenario,
         prob_hit=0.8)
b = Unit(team=1,
         type='B',
         hp=data['classes']['B']['hp'],
         ATK=data['classes']['B']['ATK'],
         DEF=data['classes']['B']['DEF'],
         game_scenario=game_scenario,
         multiple=3)

while True:
    if a.is_dead():
        print("B vence!")
        print(b.multiple)
        break
    a.attack(b)
    if b.is_dead():
        print("A vence!")
        print(a.multiple)
        break
    b.attack(a)
示例#5
0
class unit_test(unittest.TestCase):
    def setUp(self):
        self.unit = Unit(health=100, mana=100, mana_regeneration_rate=5)

    def test_init(self):
        self.assertEqual(self.unit.health, 100)
        self.assertEqual(self.unit.mana, 100)
        self.assertEqual(self.unit._max_health, 100)
        self.assertEqual(self.unit._max_mana, 100)
        self.assertEqual(self.unit.mana_regeneration, 5)

    def test_get_health(self):
        self.assertEqual(self.unit.get_health(), 100)

    def test_get_mana(self):
        self.assertEqual(self.unit.get_mana(), 100)

    def test_is_alive(self):
        self.unit.health = 0
        self.assertFalse(self.unit.is_alive())

    def test_take_healing(self):
        self.unit.health = 0
        self.assertFalse(self.unit.take_healing(30))
        self.unit.health = 50
        self.unit.take_healing(100)
        self.assertEqual(self.unit.health, 100)
        self.unit.take_healing(-50)
        self.assertEqual(self.unit.get_health(), 100)

    def test_take_mana(self):
        self.unit.mana = 0
        self.unit.take_mana(moved=True)
        self.assertEqual(self.unit.mana, 5)
        self.unit.take_mana(120)
        self.assertEqual(self.unit.mana, 100)

    def test_equip_weapon(self):
        weapon = Weapon("Weapon name", 20)
        self.unit.equip(weapon)
        self.assertEqual(self.unit.weapon, weapon)

    def test_learn_spell(self):
        spell = Spell("Spell name", 100, 50, 3)
        self.unit.learn(spell)
        self.assertEqual(self.unit.spell, spell)

    def test_attack_without_weapon_or_spell(self):
        self.assertEqual(self.unit.attack()[1], 0)

    def test_attack_with_better_weapon(self):
        spell = Spell("S", 10, 20, 5)
        weapon = Weapon('W', 50)
        self.unit.learn(spell)
        self.unit.equip(weapon)
        self.assertEqual(self.unit.attack()[1], 50)

    def test_attack_with_equal_weapon_and_spell(self):
        spell = Spell("S", 50, 50, 5)
        weapon = Weapon('W', 50)
        self.unit.learn(spell)
        self.unit.equip(weapon)
        self.assertEqual(self.unit.attack()[1], 50)
        self.assertEqual(self.unit.mana, 50)

    # def test_cant_attack_with_weapon_from_distance(self):
    #     weapon = Weapon('W', 50)
    #     self.unit.equip(weapon)
    #     # self.assertEqual(self.unit.attack(distance=2), 0)
    #     self.assertEqual(self.unit.attack()[1], 0)

    def test_attack_by_weapon(self):
        weapon = Weapon("Weapon name", 20)
        self.assertEqual(self.unit.attack(by="weapon")[1], 0)
        self.unit.equip(weapon)
        self.assertEqual(self.unit.attack(by="weapon")[1], 20)

    def test_attack_by_spell(self):
        spell = Spell("Spell name", 100, 50, 3)
        self.assertEqual(self.unit.attack(by="spell")[1], 0)
        self.unit.learn(spell)
        # self.assertEqual(self.unit.attack(by="spell"), 100)

    def test_take_damage(self):
        self.unit.take_damage(20)
        self.assertEqual(self.unit.health, 80)
        self.unit.take_damage(90)
        self.assertEqual(self.unit.health, 0)

    def test_can_cast(self):
        # self.assertFalse(self.unit.can_cast())
        self.unit.learn(Spell('a', 10, 10, 3))
        # self.assertTrue(self.unit.can_cast(1))
        # self.assertTrue(self.unit.can_cast(3))
        # self.assertFalse(self.unit.can_cast(4))
        self.assertTrue(self.unit.can_cast())
        self.unit.mana = 5
        # self.assertFalse(self.unit.can_cast(1))
        self.assertFalse(self.unit.can_cast())