炉石传说酒馆战棋（python版)

2023-05-16

详细解释内容请见代码注释XD

import numpy as np


#随从的定义
#随从的星数，攻击力，防御力，属性，圣盾，亡语，嘲讽，在场buff，因其他随从状态变化而造成的效果
class minions():
    def __init__(self, name, star, ATK, DEF, attribute,
                 DivineShield, Deathrattle, Taunt, onboard, feedback):
        self.name = name
        self.star = star
        self.ATK = ATK
        self.DEF = DEF
        self.attribute = attribute
        self.DivineShield = DivineShield
        self.Deathrattle = Deathrattle
        self.onboard = onboard
        self.feedback = feedback
        self.Taunt = Taunt

#玩家场上的七只怪
def player_list(one, two, three, four, five, six, seven):
    player = []
    player.append(one)
    player.append(two)
    player.append(three)
    player.append(four)
    player.append(five)
    player.append(six)
    player.append(seven)
    return player

#英雄的定义
class Heroes():
    def __init__(self, name, ability, bloodvalue, minion):    #英雄的技能、血量和拥有的随从
        self.name = name
        self.ability = ability
        self.bloodvalue = bloodvalue
        self.minion = minion
    def winordefeat(self, player):  #判断获胜的英雄是谁
        for min in self.minion:
            if min.name == player[0].name:
                return True

#1.掷色子，决定哪方先手
def offensiveordifensive(opponent, you):
    dice = np.random.randint(0, 2)
    if dice == 0:   #dice为0，opponent先手，dice为1，you先手
        offensive = opponent
        defensive = you
    else:
        offensive = you
        defensive = opponent
    return offensive, defensive

#检查圣盾被破后的feedback状态
def checkfeedback(player):
    for min in player:
        if min.feedback == 'gain+2+2':  #该情形为龙人执行者
            min.ATK += 2
            min.DEF += 2
            print(min.name, '获得+2+2，', '身材变为', min.ATK, '-', min.DEF)

#两个随从互打,削减生命值，判断圣盾状态，判断因圣盾状态变化而导致其他随从变化的状态（如龙人执行者）
def battle(minion1, minion2, offensive, defensive):
    print(minion1.name, '正在攻击', minion2.name)
    if minion1.DivineShield == True and minion2.DivineShield == None:   #第一个随从有圣盾，第二个随从没有圣盾,第二个随从扣血，第一个随从破圣盾
        minion2.DEF = minion2.DEF-minion1.ATK
        minion1.DivineShield = None
        print(minion2.name, '还剩', minion2.DEF, '点血,', minion1.name, '失去圣盾')
        # 检查圣盾被破后的feedback状态
        checkfeedback(offensive)
    elif minion1.DivineShield == None and minion2.DivineShield == True:   #第一个随从没有圣盾，第二个随从有圣盾,第一个随从扣血，第二个随从破圣盾
        minion1.DEF = minion1.DEF - minion2.ATK
        minion2.DivineShield = None
        print(minion1.name, '还剩', minion1.DEF, '点血,', minion2.name, '失去圣盾')
        checkfeedback(defensive)
    elif minion1.DivineShield == None and minion2.DivineShield == None:   #两个随从都没圣盾
        minion1.DEF = minion1.DEF - minion2.ATK
        minion2.DEF = minion2.DEF - minion1.ATK
        print(minion1.name, '还剩', minion1.DEF, '点血,', minion2.name, '还剩', minion2.DEF, '点血')
    elif minion1.DivineShield == True and minion2.DivineShield == True:   #两个随从都有圣盾
        minion1.DivineShield = None
        minion2.DivineShield = None
        print(minion1.name, '失去圣盾', minion2.name, '失去圣盾')
        checkfeedback(offensive)
        checkfeedback(defensive)

#判断是否有嘲讽随从，若有，则选择一个嘲讽随从，若没有，则随机选择一个随从
def getTaunt(defensive):
    Taunt_list = []
    for i in range(len(defensive)):
        if defensive[i].Taunt == True:
            Taunt_list.append(i)
    if len(Taunt_list) != 0:
        dice = np.random.randint(0, len(Taunt_list))
        dice = Taunt_list[dice]
    else:
        dice = np.random.randint(0, len(defensive))
    return dice

#小鬼囚徒的亡语
def ImprisonerDeathrattle(player, count_minion):
    Imprisoner_token = minions('小鬼', 1, 1, 1, 'demon', None, None, None, None, None)
    player.pop(count_minion)
    player.insert(count_minion, Imprisoner_token)
    #查询在场是否有符合要求的onboard状态的随从，如二王
    for min in player:
        if min.onboard == 'all+2+2':
            player[count_minion].ATK += 2
            player[count_minion].DEF += 2
            print(player[count_minion].name, '受到', min.name, '影响，身材变为', player[count_minion].ATK, '-', player[count_minion].DEF)

#麦田傀儡的亡语，检查feedback状态，主要影响偏折机器人
def HarvestGolemDeathrattle(player, count_minion):
    HarvestGolem_token = minions('损坏的傀儡', 1, 4, 2, 'tech', None, None, None, None, None)
    player.pop(count_minion)
    player.insert(count_minion, HarvestGolem_token)
    #检查feedback状态
    for min in player:
        if min.feedback == 'gain +1ATK and shield' and min.DivineShield != True:
            min.DivineShield = True
            min.ATK += 1
            print(min.name, '获得圣盾和+1攻击力')
        elif min.feedback == 'gain +1ATK and shield' and min.DivineShield == True:
            min.ATK += 1
            print(min.name, '获得+1攻击力')

#邪魔仆从的亡语
def FiendishServentDeathrattle(minion, player):
    dice = np.random.randint(0, len(player)) #随机选择一个随从获得攻击力
    player[dice].ATK += minion.ATK
    print(player[dice].name, '获得了', minion.ATK, '点攻击力，身材变为', player[dice].ATK, '-', player[dice].DEF)

#青铜守卫的亡语
def BronzeWardenDeathrattle(minion):
    minion.name = '青铜守卫'
    minion.star = 3
    minion.ATK = 2
    minion.DEF = 1
    minion.attribute = 'dragon'
    minion.DivineShield = True
    minion.Deathrattle = None
    minion.onboard = None
    minion.feedback = None
    minion.Taunt = None

#发动攻击方偏折机器人的亡语，该亡语也会影响其他偏折机器人，要检查feedback
def DeflectoBotDeathrattle(minion, player, count_minion):
    Microbots = minions('微型机器人', 1, 1, 1, 'tech', None, None, None, None, None)
    player.pop(count_minion)    #这里用了随从的序号
    dif = 7 - len(player)       #战场剩余空位
    if dif > 3:                 #如果有三个以上空位，则只召唤三个机器人
        for i in range(3):
            player.insert(count_minion, Microbots)
        print(minion.name, '召唤 3 个1/1的微型机器人')
        summonnumber = 3
    else:
        for i in range(dif):    #如果小于3个的空位，则有几个空位就招几个
            player.insert(count_minion, Microbots)
        print(minion.name, '召唤', dif, '个1/1的微型机器人')
        summonnumber = dif
    #检查feedback状态
    DeflectobotFeedback(player, summonnumber)

#被攻击方偏折机器人的亡语，该亡语也会影响其他偏折机器人，要检查feedback
def DeflectoBotDeathrattle_defensive(minion, player, count_minion, count_defensive):
    Microbots = minions('微型机器人', 1, 1, 1, 'tech', None, None, None, None, None)
    player.pop(count_minion)
    dif = 7 - len(player)       #战场剩余空位
    if dif > 3:                 #如果有三个以上空位，则只召唤三个机器人
        for i in range(3):
            player.insert(count_minion, Microbots)
        print(minion.name, '召唤 3 个1/1的微型机器人')
        count_defensive = adjustorder(count_minion, count_defensive, 3)
        summonnumber = 3
    else:
        for i in range(dif):    #如果小于3个的空位，则有几个空位就招几个
            player.insert(count_minion, Microbots)
        print(minion.name, '召唤', dif, '个1/1的微型机器人')
        count_defensive = adjustorder(count_minion, count_defensive, dif)
        summonnumber = dif
    #检查feedback状态
    DeflectobotFeedback(player, summonnumber)
    return count_defensive

#偏折机器人的feedback，根据召唤机械的数量增加攻击力
def DeflectobotFeedback(player, summonnumber):
    for min in player:
        if min.feedback == 'gain +1ATK and shield' and min.DivineShield != True:
            min.DivineShield = True
            min.ATK += summonnumber
            print(min.name, '获得圣盾和+', summonnumber, '攻击力')
        elif min.feedback == 'gain +1ATK and shield' and min.DivineShield == True:
            min.ATK += summonnumber
            print(min.name, '获得+', summonnumber, '攻击力')

#发动攻击方坎格尔的学徒的亡语，该亡语也会影响其他偏折机器人，要检查feedback
def KangorsApprenticeDeathrattle(minion, player, count_minion, Deathminion):
    DeflectoBot_new = minions('偏折机器人', 3, 3, 2, 'tech', True, 'summon 3 1/1 tech', None, None, 'gain +1ATK and shield')
    HarvestGolem_new = minions('麦田傀儡', 2, 4, 6, 'tech', None, 'summon a 4/2', None, None, None)
    techminionDeath = []
    for min in Deathminion:     #将死亡随从中的机械存入列表，其中麦田傀儡和偏折机器人应是原身材
        if min.attribute == 'tech':
            if min.Deathrattle == 'summon 3 1/1 tech':
                techminionDeath.append(DeflectoBot_new)
            elif min.name == '麦田傀儡':
                techminionDeath.append(HarvestGolem_new)
            else:
                techminionDeath.append(min)
    summonnumber = 0
    player.pop(count_minion)    #这里用了随从的序号
    if len(techminionDeath) == 1:    #当牺牲的机械随从只有一个时
        player.insert(count_minion, techminionDeath[0])
        summonnumber = 1
    elif len(techminionDeath) >= 2:    #当牺牲的机械随从有两个时
        dif = 7 - len(player)  # 战场剩余空位
        if dif >= 2:                 #如果有两个以上空位，则召唤两个死亡机械
            player.insert(count_minion, techminionDeath[0])     #召唤前两个死亡的机械
            player.insert(count_minion, techminionDeath[1])
            print(minion.name, '复活了', techminionDeath[0].name, '和', techminionDeath[1].name)
            summonnumber = 2
        else:
            player.insert(count_minion, techminionDeath[0])
            print(minion.name, '复活了', techminionDeath[0].name)
            summonnumber = 1
    else:
        print(minion.name, '未复活任何随从')
    # 检查偏折机器人feedback状态
    DeflectobotFeedback(player, summonnumber)

#被攻击方坎格尔的学徒的亡语，该亡语也会影响其他偏折机器人，要检查feedback
def KangorsApprenticeDeathrattle_defensive(minion, player, count_minion, Deathminion, count_defensive):
    DeflectoBot_new = minions('偏折机器人', 3, 3, 2, 'tech', True, None, None, None, 'gain +1ATK and shield')
    HarvestGolem_new = minions('麦田傀儡', 2, 4, 6, 'tech', None, 'summon a 4/2', None, None, None)
    techminionDeath = []
    for min in Deathminion:     #将死亡随从中的机械存入列表，其中麦田傀儡和偏折机器人应是原身材
        if min.attribute == 'tech':
            if min.onboard == 'gain +1ATK and shield':
                techminionDeath.append(DeflectoBot_new)
            elif min.name == '麦田傀儡':
                techminionDeath.append(HarvestGolem_new)
            else:
                techminionDeath.append(min)
    summonnumber = 0
    player.pop(count_minion)    #这里用了随从的序号
    if len(techminionDeath) == 1:    #当牺牲的机械随从只有一个时
        player.insert(count_minion, techminionDeath[0])
        summonnumber = 1
    elif len(techminionDeath) >= 2:    #当牺牲的机械随从有两个时
        dif = 7 - len(player)  # 战场剩余空位
        if dif >= 2:                 #如果有两个以上空位，则召唤两个死亡机械
            player.insert(count_minion, techminionDeath[0])     #召唤前两个死亡的机械
            player.insert(count_minion, techminionDeath[1])
            print(minion.name, '复活了', techminionDeath[0].name, '和', techminionDeath[1].name)
            count_defensive = adjustorder(count_minion, count_defensive, 2) #调整攻击顺序
            summonnumber = 2
        else:
            player.insert(count_minion, techminionDeath[0])
            print(minion.name, '复活了', techminionDeath[0].name)
            count_defensive = adjustorder(count_minion, count_defensive, 1)
            summonnumber = 1
    else:
        print(minion.name, '未复活任何随从')
    # 检查偏折机器人feedback状态
    DeflectobotFeedback(player, summonnumber)
    return count_defensive

#二王的亡语，二王的buff在死后消失，实际上就是亡语效果
def MalGanisonboard(player):
    for min in player:
        if min.attribute == 'demon':
            if min.ATK > 2 and min.DEF > 2:
                min.ATK -= 2
                min.DEF -= 2
                print(min.name, '身材变为', min.ATK, '-', min.DEF)
            if min.ATK <= 2 and min.DEF > 2:
                min.DEF -= 2
                print(min.name, '身材变为', min.ATK, '-', min.DEF)
            if min.ATK > 2 and min.DEF <= 2:
                min.ATK -= 2
                print(min.name, '身材变为', min.ATK, '-', min.DEF)

#灵魂杂耍者的onboard状态,player是喷子对面的阵容集合
def SoulJuggleronboard(player):
    if len(player) != 0:
        SoulJugglerdice = np.random.randint(0, len(player))
        if player[SoulJugglerdice].DivineShield == None:
            player[SoulJugglerdice].DEF -= 3
            print('灵魂杂耍者对', player[SoulJugglerdice].name, '造成3点伤害')
        else:
            player[SoulJugglerdice].DivineShield = None
            print('灵魂杂耍者对', player[SoulJugglerdice].name, '造成3点伤害', player[SoulJugglerdice].name, '失去圣盾')
        return player[SoulJugglerdice], SoulJugglerdice
    else:   #当一方恶魔和对方最后一个随从同归于尽的情况，喷子此时找不到目标
        return True, True

#当对方随从死亡触发召唤衍生物的亡语时，应进行判定：若下一个将进行攻击的随从在死亡随从右边时，则需要调整攻击顺序指针
def adjustorder(dice, count_defensive, summonnumber):
    if dice >= count_defensive:
        return count_defensive
    else:
        count_defensive = count_defensive + summonnumber - 1
        return count_defensive

#交换攻击顺序和墓地
def swaporder(offensive, defensive, Deathminion_offensive, Deathminion_defensive, count_offensive, count_defensive):
    # 交换攻击顺序
    if count_offensive >= len(offensive):  # 当所有随从攻击过一次后，重新从最左边开始，存在最右边随从死亡，同时有一个随从被喷子喷死的情况，此时计数器不变，但实际上已经超出了范围
        count_offensive = 0
    if count_defensive >= len(defensive):
        count_defensive = 0
    temp_count = count_offensive
    count_offensive = count_defensive
    count_defensive = temp_count
    #交换场地
    temp_list = offensive
    offensive = defensive
    defensive = temp_list
    #交换墓地
    temp_deathlist = Deathminion_offensive
    Deathminion_offensive = Deathminion_defensive
    Deathminion_defensive = temp_deathlist

    return offensive, defensive, Deathminion_offensive, Deathminion_defensive, count_offensive, count_defensive

#判断生命值，并判断是否有亡语需要触发
def checkbloodvalue(offensive, defensive, offensiveminion, defensiveminion, Deathminion_offensive,
                    Deathminion_defensive, count_offensive, dice, count_defensive):
    if offensiveminion.DEF <= 0:
        print(offensiveminion.name, '在战斗中牺牲')
        Deathminion_offensive.append(offensiveminion)   #记录死亡随从
        if offensiveminion.Deathrattle == 'summon a 1/1':  # 小鬼囚徒的亡语
            print(offensiveminion.name, '触发亡语：召唤一个1/1的小鬼')
            ImprisonerDeathrattle(offensive, count_offensive)
        elif offensiveminion.Deathrattle == 'summon a 4/2':  # 麦田傀儡的亡语
            print(offensiveminion.name, '触发亡语：召唤一个4/2的损坏的傀儡')
            HarvestGolemDeathrattle(offensive, count_offensive)
        elif offensiveminion.Deathrattle == 'give ATK':  # 邪魔仆从的亡语
            print(offensiveminion.name, '触发亡语：使一个友方随从获得该随从的攻击力')
            offensive.pop(count_offensive)  # 这里用了随从的序号
            FiendishServentDeathrattle(offensiveminion, offensive)
        elif offensiveminion.Deathrattle == 'reborn':  # 青铜守卫的亡语
            print(offensiveminion.name, '触发复生')
            BronzeWardenDeathrattle(offensiveminion)
        elif offensiveminion.Deathrattle == 'summon 3 1/1 tech':  # 偏折机器人的亡语
            DeflectoBotDeathrattle(offensiveminion, offensive, count_offensive)
        elif offensiveminion.onboard == 'all+2+2':  # 二王的亡语，二王的buff在死后消失，实际上就是亡语效果
            print(offensiveminion.name, 'buff效果消失')
            offensive.pop(count_offensive)  # 这里用了随从的序号
            MalGanisonboard(offensive)
        elif offensiveminion.Deathrattle == 'summon 2 tech':  # 坎格尔的学徒的亡语
            KangorsApprenticeDeathrattle(offensiveminion, offensive, count_offensive, Deathminion_offensive)
        else:
            offensive.pop(count_offensive)  # 这里用了随从的序号
    else:   #当发动攻击的随从未死亡时，攻击顺序计数器+1
        count_offensive += 1
    #触发喷子的onboard效果
    if defensiveminion.attribute == 'demon' and defensiveminion.DEF <= 0:  # 若对面死的是恶魔，这是为了结算我方所有亡语圣盾后才释放对面喷子技能
        for min in defensive:
            if min.name == '灵魂杂耍者':
                minionSoulJuggler, count_SoulJuggler = SoulJuggleronboard(offensive)
                if minionSoulJuggler != True and count_SoulJuggler != True: #喷子对面还有随从的时候
                    if minionSoulJuggler.DEF <= 0:  # 如果这个随从被喷子喷死了
                        print(minionSoulJuggler.name, '在战斗中牺牲')
                        Deathminion_offensive.append(minionSoulJuggler)  # 记录死亡随从
                        if minionSoulJuggler.Deathrattle == 'summon a 4/2':  # 麦田傀儡的亡语
                            print(minionSoulJuggler.name, '触发亡语：召唤一个4/2的损坏的傀儡')
                            HarvestGolemDeathrattle(offensive, count_SoulJuggler)
                        elif minionSoulJuggler.Deathrattle == 'reborn':  # 青铜守卫的亡语
                            print(minionSoulJuggler.name, '触发复生')
                            BronzeWardenDeathrattle(minionSoulJuggler)
                        elif minionSoulJuggler.Deathrattle == 'summon 3 1/1 tech':  # 偏折机器人的亡语
                            count_offensive = DeflectoBotDeathrattle_defensive(minionSoulJuggler, offensive,
                                                                               count_SoulJuggler, count_offensive)
                        elif minionSoulJuggler.Deathrattle == 'summon 2 tech':  # 坎格尔的学徒的亡语
                            count_offensive = KangorsApprenticeDeathrattle_defensive(minionSoulJuggler, offensive,
                                                                                     count_SoulJuggler,
                                                                                     Deathminion_offensive,
                                                                                     count_offensive)
                        else:
                            offensive.pop(count_SoulJuggler)  # 这里用了随从的序号

    if defensiveminion.DEF <= 0:
        print(defensiveminion.name, '在战斗中牺牲')
        Deathminion_defensive.append(defensiveminion)   #记录死亡随从
        if defensiveminion.Deathrattle == 'summon a 1/1':  # 小鬼囚徒的亡语
            print(defensiveminion.name, '触发亡语：召唤一个1/1的小鬼')
            ImprisonerDeathrattle(defensive, dice)
        elif defensiveminion.Deathrattle == 'summon a 4/2':  # 麦田傀儡的亡语
            print(defensiveminion.name, '触发亡语：召唤一个4/2的损坏的傀儡')
            HarvestGolemDeathrattle(defensive, dice)
        elif defensiveminion.Deathrattle == 'give ATK':  # 邪魔仆从的亡语
            print(defensiveminion.name, '触发亡语：使一个友方随从获得该随从的攻击力')
            defensive.pop(dice)
            FiendishServentDeathrattle(defensiveminion, defensive)
        elif defensiveminion.Deathrattle == 'reborn':  # 青铜守卫的亡语
            print(defensiveminion.name, '触发复生')
            BronzeWardenDeathrattle(defensiveminion)
        elif defensiveminion.Deathrattle == 'summon 3 1/1 tech':  # 偏折机器人的亡语
            count_defensive = DeflectoBotDeathrattle_defensive(defensiveminion, defensive, dice, count_defensive)
        elif defensiveminion.onboard == 'all+2+2':  # 二王的亡语，二王的buff在死后消失，实际上就是亡语效果
            print(defensiveminion.name, 'buff效果消失')
            defensive.pop(dice)
            MalGanisonboard(defensive)
        elif defensiveminion.Deathrattle == 'summon 2 tech':  # 坎格尔的学徒的亡语
            count_defensive = KangorsApprenticeDeathrattle_defensive(defensiveminion, defensive, dice, Deathminion_defensive, count_defensive)
        else:
            defensive.pop(dice)
    if offensiveminion.attribute == 'demon' and offensiveminion.DEF <= 0:  # 若己方死的是恶魔，这是为了结算对面所有亡语圣盾后才释放己方喷子技能
        for min in offensive:
            if min.name == '灵魂杂耍者':
                minionSoulJuggler, count_SoulJuggler = SoulJuggleronboard(defensive)
                if minionSoulJuggler != True and count_SoulJuggler != True:  # 喷子对面还有随从的时候
                    if minionSoulJuggler.DEF <= 0:  # 如果这个随从被喷子喷死了
                        print(minionSoulJuggler.name, '在战斗中牺牲')
                        Deathminion_offensive.append(minionSoulJuggler)  # 记录死亡随从
                        if minionSoulJuggler.Deathrattle == 'summon a 4/2':  # 麦田傀儡的亡语
                            print(minionSoulJuggler.name, '触发亡语：召唤一个4/2的损坏的傀儡')
                            HarvestGolemDeathrattle(defensive, count_SoulJuggler)
                        elif minionSoulJuggler.Deathrattle == 'reborn':  # 青铜守卫的亡语
                            print(minionSoulJuggler.name, '触发复生')
                            BronzeWardenDeathrattle(minionSoulJuggler)
                        elif minionSoulJuggler.Deathrattle == 'summon 3 1/1 tech':  # 偏折机器人的亡语
                            count_defensive = DeflectoBotDeathrattle_defensive(minionSoulJuggler, defensive,
                                                                               count_SoulJuggler, count_defensive)
                        elif minionSoulJuggler.Deathrattle == 'summon 2 tech':  # 坎格尔的学徒的亡语
                            count_defensive = KangorsApprenticeDeathrattle_defensive(minionSoulJuggler, defensive,
                                                                                     count_SoulJuggler,
                                                                                     Deathminion_defensive,
                                                                                     count_defensive)
                        else:
                            defensive.pop(count_SoulJuggler)  # 这里用了随从的序号
    return count_offensive, count_defensive, Deathminion_offensive, Deathminion_defensive


#判断是否有一方已无随从
def check_winordefeat(offensive, defensive):
    if len(offensive) == 0 and len(defensive) == 0:
        print('平局！')
        return 4
    if len(offensive) != 0 and len(defensive) == 0:
        star = 0
        print('最后战场上还剩下：')
        for min in offensive:
            star = star + min.star
            print(min.name)
        if Rafaam.winordefeat(offensive) == True:
            restblood = Nozdormu.bloodvalue - star
            if restblood <= 0 :
                print('诺兹多姆被抬走')
                return 0
            else:
                print('诺兹多姆受到', star, '点伤害，还剩', restblood,  '点血')
                return 1
        if Nozdormu.winordefeat(offensive) == True:
            restblood = Rafaam.bloodvalue - star
            if restblood <= 0 :
                print('拉法姆被抬走')
                return 2
            else:
                print('拉法姆受到', star, '点伤害，还剩', restblood,  '点血')
                return 3
        return True
    if len(offensive) == 0 and len(defensive) != 0:
        star = 0
        print('最后战场上还剩下：')
        for min in defensive:
            star = star + min.star
            print(min.name)
        if Rafaam.winordefeat(defensive) == True:
            restblood = Nozdormu.bloodvalue - star
            if restblood <= 0 :
                print('诺兹多姆被抬走')
                return 0
            else:
                print('诺兹多姆受到', star, '点伤害，还剩', restblood,  '点血')
                return 1
        if Nozdormu.winordefeat(defensive) == True:
            restblood = Rafaam.bloodvalue - star
            if restblood <= 0 :
                print('拉法姆被抬走')
                return 2
            else:
                print('拉法姆受到', star, '点伤害，还剩', restblood,  '点血')
                return 3

#棋盘的定义
def begin(opponent, you):



    #1.掷色子，决定哪方先手
    offensive, defensive = offensiveordifensive(opponent, you)
    #死亡随从记录列表，主要针对坎格尔的学徒
    Deathminion_offensive = []
    Deathminion_defensive = []


    count_offensive = 0  # 设置先手方攻击顺序指针，指向下一个将要发动攻击的随从
    count_defensive = 0  # 设置后手方攻击顺序指针，指向下一个将要发动攻击的随从

    # 开始battle直到一方死亡
    active = True
    while active:
    #2.#判断是否有嘲讽随从，若有，则选择一个嘲讽随从，若没有，则随机选择一个随从
        dice = getTaunt(defensive)
    #3.两个随从互打，并针对失去圣盾判断feedback状态
        for min in offensive:
            print('现在场面上有：', min.name)
        for min in defensive:
            print('场面上有：', min.name)

        offensiveminion = offensive[count_offensive]
        defensiveminion = defensive[dice]
        battle(offensiveminion, defensiveminion, offensive, defensive)
    #4.判断生命值，并判断是否有亡语需要触发
        count_offensive, count_defensive, Deathminion_offensive, Deathminion_defensive = checkbloodvalue(offensive, defensive, offensiveminion,
                                defensiveminion, Deathminion_offensive, Deathminion_defensive, count_offensive, dice, count_defensive)
    #5.判断是否有一方已无随从
        checkresult = check_winordefeat(offensive, defensive)
        if checkresult == 0:#诺兹多姆被抬走
            return 0
        if checkresult == 1:#诺兹多姆受到伤害,但没死
            return 1
        if checkresult == 2:#拉法姆被抬走
            return 2
        if checkresult == 3:#拉法姆受到伤害,但没死
            return 3
        if checkresult == 4:#平局
            return 4
    #6.交换攻击顺序并交换墓地
        offensive, defensive, Deathminion_offensive, Deathminion_defensive, count_offensive, count_defensive = swaporder(offensive, defensive, Deathminion_offensive, Deathminion_defensive, count_offensive, count_defensive)


#在场随从
MalGanis13_11 = minions('玛尔加尼斯13_11', 5, 13, 11, 'demon', None, None, None, 'all+2+2', None)
MalGanis11_9 = minions('玛尔加尼斯11_9', 5, 11, 9, 'demon', None, None, None, 'all+2+2', None)
SoulJuggler = minions('灵魂杂耍者', 3, 3, 3, None, None, None, None, None,  'deal 3 damage')
Imprisoner1 = minions('小鬼囚徒1', 2, 7, 7, 'demon', None, 'summon a 1/1', True, None, None)
Imprisoner2 = minions('小鬼囚徒2', 2, 7, 7, 'demon', None, 'summon a 1/1', True, None, None)
FiendishServent = minions('邪魔仆从', 1, 8, 6, 'demon', None, 'give ATK', None, None, None)
WrathWeaver = minions('愤怒编织者', 1, 19, 19, None, None, None, None, None, None)

BronzeWarden = minions('青铜守卫', 3, 6, 5, 'dragon', True, 'reborn', None, None, None)
HarvestGolem = minions('麦田傀儡', 2, 10, 10, 'tech', True, 'summon a 4/2', True, None, None)
AnnihilanBattlemaster = minions('安尼赫兰战场军官', 5, 3, 31, 'demon', None, None, None, None, None)
KangorsApprentice = minions('坎格尔的学徒', 6, 3, 6, None, None, 'summon 2 tech', None, None, None)
DrakonidEnforcer = minions('龙人执行者', 4, 3, 6, 'dragon', None, None, None, None, 'gain+2+2')
DeflectoBot1 = minions('偏折机器人1', 3, 8, 3, 'tech', True, 'summon 3 1/1 tech', None, None, 'gain +1ATK and shield')
DeflectoBot2 = minions('偏折机器人2', 3, 8, 3, 'tech', True, 'summon 3 1/1 tech', None, None, 'gain +1ATK and shield')


#衍生物
Imprisoner_token = minions('小鬼', 1, 1, 1, 'demon', None, None, None, None, None)
Microbots = minions('微型机器人', 1, 1, 1, 'tech', None, None, None, None, None)
HarvestGolem_token = minions('损坏的傀儡', 1, 4, 2, 'tech', None, None, None, None, None)
DeflectoBot_new = minions('偏折机器人', 3, 3, 2, 'tech', True, None, None, None, 'gain +1ATK and shield')

#英雄
Rafaam = Heroes('拉法姆', None, 2, [FiendishServent, Imprisoner1, Imprisoner2, MalGanis13_11, WrathWeaver, MalGanis11_9, SoulJuggler, Imprisoner_token])
Nozdormu = Heroes('诺兹多姆', None, 10, [DeflectoBot1, DeflectoBot2, BronzeWarden, HarvestGolem, AnnihilanBattlemaster, DrakonidEnforcer, KangorsApprentice, Microbots, HarvestGolem_token, DeflectoBot_new])

#场面
opponent = player_list(FiendishServent, Imprisoner1, Imprisoner2, MalGanis13_11, WrathWeaver, MalGanis11_9, SoulJuggler)
you = player_list(DeflectoBot1, DeflectoBot2, BronzeWarden, HarvestGolem, AnnihilanBattlemaster, DrakonidEnforcer, KangorsApprentice)

#开始战斗
def battlenumber(number):
    count_0 = 0  # 诺兹多姆被抬走
    count_1 = 0  # 诺兹多姆受到伤害,但没死
    count_2 = 0  # 拉法姆被抬走
    count_3 = 0  # 拉法姆受到伤害,但没死
    count_4 = 0  # 平局
    for i in range(number):
        # 在场随从
        MalGanis13_11 = minions('玛尔加尼斯13_11', 5, 13, 11, 'demon', None, None, None, 'all+2+2', None)
        MalGanis11_9 = minions('玛尔加尼斯11_9', 5, 11, 9, 'demon', None, None, None, 'all+2+2', None)
        SoulJuggler = minions('灵魂杂耍者', 3, 3, 3, None, None, None, None, None, 'deal 3 damage')
        Imprisoner1 = minions('小鬼囚徒1', 2, 7, 7, 'demon', None, 'summon a 1/1', True, None, None)
        Imprisoner2 = minions('小鬼囚徒2', 2, 7, 7, 'demon', None, 'summon a 1/1', True, None, None)
        FiendishServent = minions('邪魔仆从', 1, 8, 6, 'demon', None, 'give ATK', None, None, None)
        WrathWeaver = minions('愤怒编织者', 1, 19, 19, None, None, None, None, None, None)

        BronzeWarden = minions('青铜守卫', 3, 6, 5, 'dragon', True, 'reborn', None, None, None)
        HarvestGolem = minions('麦田傀儡', 2, 10, 10, 'tech', True, 'summon a 4/2', True, None, None)
        AnnihilanBattlemaster = minions('安尼赫兰战场军官', 5, 3, 31, 'demon', None, None, None, None, None)
        KangorsApprentice = minions('坎格尔的学徒', 6, 3, 6, None, None, 'summon 2 tech', None, None, None)
        DrakonidEnforcer = minions('龙人执行者', 4, 3, 6, 'dragon', None, None, None, None, 'gain+2+2')
        DeflectoBot1 = minions('偏折机器人1', 3, 8, 3, 'tech', True, 'summon 3 1/1 tech', None, None,
                               'gain +1ATK and shield')
        DeflectoBot2 = minions('偏折机器人2', 3, 8, 3, 'tech', True, 'summon 3 1/1 tech', None, None,
                               'gain +1ATK and shield')

        # 衍生物
        Imprisoner_token = minions('小鬼', 1, 1, 1, 'demon', None, None, None, None, None)
        Microbots = minions('微型机器人', 1, 1, 1, 'tech', None, None, None, None, None)
        HarvestGolem_token = minions('损坏的傀儡', 1, 4, 2, 'tech', None, None, None, None, None)
        DeflectoBot_new = minions('偏折机器人', 3, 3, 2, 'tech', True, None, None, None, 'gain +1ATK and shield')

        # 英雄
        Rafaam = Heroes('拉法姆', None, 2,
                        [FiendishServent, Imprisoner1, Imprisoner2, MalGanis13_11, WrathWeaver, MalGanis11_9,
                         SoulJuggler, Imprisoner_token])
        Nozdormu = Heroes('诺兹多姆', None, 10,
                          [DeflectoBot1, DeflectoBot2, BronzeWarden, HarvestGolem, AnnihilanBattlemaster,
                           DrakonidEnforcer, KangorsApprentice, Microbots, HarvestGolem_token, DeflectoBot_new])

        # 场面
        opponent = player_list(FiendishServent, Imprisoner1, Imprisoner2, MalGanis13_11, WrathWeaver, MalGanis11_9,
                               SoulJuggler)
        you = player_list(DeflectoBot1, DeflectoBot2, BronzeWarden, HarvestGolem, AnnihilanBattlemaster,
                          DrakonidEnforcer, KangorsApprentice)

        count = begin(opponent, you)
        if count == 0:
            count_0 += 1
        if count == 1:
            count_1 += 1
        if count == 2:
            count_2 += 1
        if count == 3:
            count_3 += 1
        if count == 4:
            count_4 += 1
    print(count_0, count_1, count_2, count_3, count_4)

#begin(opponent, you)
battlenumber(1000)

本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)

炉石传说酒馆战棋（python版) 的相关文章

Vue3 中setup()和＜script setup＞＜script＞

setup 方法在组件创建之前执行 xff0c 是组合式 API 的入口方法可以接受两个参数 props 和 context setup方法中 xff0c 要将数据暴露给页面模板 xff0c 需要结合ref 和reactive xff0
NLP实践项目三：基于BiLSTM-CRF的实体识别（pytorch实现）

直接看代码 xff1a github传送门数据集 xff1a Conll2003 1 数据预处理将txt中的文件读出然后将句子和对应的标签序列存入csv文件中 xff0c 便于使用torchtext完成数据读取 2 模型定义上图是Bi
NLP实践项目五：基于GRU的古诗生成（pytorch实现）

直接看代码 xff1a github传送门数据集 xff1a 古诗数据集 1 数据预处理 xff1a 将古诗存为上图的格式 xff0c 每行一首诗 xff0c 便于使用torchtext读取 2 模型定义模型就是一个简单的GRU模型 x
第17周算法思想-二分搜索

算法思想二分查找二分查找应用场景 xff1a 寻找一个数寻找满足条件的某个区间的左侧边界寻找满足条件的某个区间的右侧边界建议学习 xff1a 二分查找详解二分查找的基本框架 span class token keyword in
第18周算法思想-搜索（BFS）

文章目录 BFS计算在网格中从原点到特定点的最短路径长度组成整数的最小平方数数量最短单词路径 BFS 计算在网格中从原点到特定点的最短路径长度 1091 Shortest Path in Binary Matrix Medium 组成整数的
第19周算法思想搜索（BFS&DFS）

文章目录 BFS最短单词路径 xff08 输出所有路径 xff09 到离得最近的0的距离 DFS查找最大的连通面积填充封闭区域括号生成最短单词路径 xff08 输出所有路径 xff09 126 Word Ladder II Hard 到离
c++ 正则表达式-基础操作

正则表达式是一个非常强大的工具 xff0c 主要用于字符串匹配如何在c 43 43 中使用正则表达式 xff1f 下面就简要介绍一下c 43 43 中正则表达式相关函数的用法本篇博客中所涉及到的函数及其功能如下表所示 xff1a 函数功
机器学习，计算机视觉和模式识别分别有何联系？

目录 1 定义1 0 模式识别 xff1a 1 1 机器学习 xff1a 1 2 计算机视觉 xff1a 2 联系2 0 模式识别 vs 机器学习 2 1 模式识别 vs 计算机视觉 3 参考链接 xff1a 1 定义 1 0 模式识别 x
idea maven 编译本地jar包的问题

maven 编译的时候一直报这个错误搞的我云里雾里的 pom xml中配置如下 span class token tag span class token tag span class token punctuation lt span
linux 管理gui工具

3 Webmin Webmin是一款基于Web的一站式工具 xff0c 可用来管理Linux服务器有了Webmin xff0c 你就能管理服务器的几乎每一个方面 xff1a 用户帐户 Apache DNS 文件共享安全和数据库等等而如
Windows10配置Hadoop

资源下载 hadoop 3 1 3 tar gz 百度网盘链接 xff1a https pan baidu com s 1umVgYdZ8KWMikjyHtZ2rCA xff08 提取码 xff1a 0000 xff09 apache ha
最大似然估计和最小二乘法怎么理解？

最大似然估计和最小二乘法怎么理解 xff1f 数据是由模型的真实输出叠加上高斯噪声得到的 xff0c 即 xff1a 那么对模型参数的最大似然估计和最小二乘估计是等价的简单的推导我们知道 xff0c 模型的似然函数是同时 xf
CentOS 退出江湖，服务器操作系统该选择 Debian 还是 Ubuntu

CentOS是一种流行的Linux服务器操作系统 xff0c 但近期宣布停止支持 xff0c 并且停止更新发布因此 xff0c 许多用户和管理员开始考虑其他替代品两个最受欢迎的替代选项是Debian和Ubuntu 在选择新的服务器操作系
远程文件包含

远程文件包含 xff08 Remote File Inclusion xff09 xff0c 简称RFI xff0c 与其对应的是本地文件包含 xff08 Local File Inclusion xff0c LFI xff09 xff0c
Android模拟器实现windows虚拟串口通信调试

1 下载 Virtual Serial Port Driver 安装后好后创建一对虚拟串口 2 打开计算机管理查看设备管理 gt 端口查看是否生成虚拟端口如果没有生成重启试下 3 下载 lt lt 友善串口调试助手 gt gt 使
查找

题目描述输入一组数据 xff08 整数 xff0c 不多于20个 xff09 xff0c 查找指定的数据项是否存在输入正整数N xff08 1 N 20 xff0c 之后是N个整数 xff0c 以及需要查找的数据输出如果找到指定的
proxmox waiting for quorum ... 与 INFO: unable to open file '/etc/pve/nodes/*/qemu-server/*.conf.错误解决

故障1 waiting for quorum 故障2 INFO unable to open file etc pve nodes qemu server conf tmp Permission denied 一般出现这玩意就是Corsyn
pvetools使用教程

如果你是PVE6 请执行 rm etc apt sources list d pve enterprise list export LC ALL 61 en US UTF 8 apt update amp amp apt y install
proxmox集群故障处理 -中文版-剔除掉所有集群主机,让pve单独运行

首先可以检查集群状态 pvecm status 可以看到 Error Corosync config etc pve corosync conf does not exist is this node part of a cluster
centos8 lxc 虚拟化安装redis

yum install wget y 下载最新的redis 这个更新比较慢 http www redis cn download html 官网 https redis io download yum span class token fu

随机推荐

“permission denied - invalid PVE ticket (401)“错误的解决方式

1 xff0c 登陆web后 xff0c 看点击其他集群的shell看看进不进的去 2 xff0c 进不去就重新启动下集群服务
pve proxmox ve导入或者挂载qcow2的文件方式安装dell openmanage enterprise

下载3 5的 https www dell com support home zh cn drivers driversdetails driverid 61 6k52n 新建一个kvm的虚拟主机 xff0c 然后找个目录上传openma
cmake命令行使用

生成项目构建系统 cmake lt 选项 gt lt 源路径 gt cmake lt 选项 gt lt 现有构建路径 gt cmake lt 选项 gt S lt 源路径 gt B lt 构建路径 gt 建立一个项目 cmake build
群晖部署nps的客户端npc in docker

先下载一个npc的容器注意是npc 启动然后高级设置 3 点击高级设置 4 点击添加文件夹 5 选择一个NAS本地文件夹要记住待会用到 6 装载路径为 conf 注意这个是配置文件所在地网络选择本地hosts网络然后创建后
DIY win10 ESD镜像并安装

1 使用ampe的系统工具箱 xff0c 进入pe后选择系统盘备份系统所在分区 xff08 MBR xff09 2 保存为ESD文件 3 安装使用winntstep 或者使用dism 43 43 工具箱备份系统备注只用过MBR的 ES
kangle安装php5.4 替代easypanel的php5.3 解决kangle ep504的问题

执行 span class token function wget span http github itzmx com 1265578519 kangle master php 5 6 5640 completed tpl php5640
kangle 支持ssi最后的版本

kangle ent 3 5 14 13 6 x64 tar gz 这个版本为最后支持ssi的版本
Flutter Web CORS解决方案1-禁用浏览器安全策略

Flutter Web CORS解决方案1 设置CHROME EXECUTABLE关于 CHROME EXECUTABLE创建 CHROME EXECUTABLE 修改 chrome dart 禁用安全策略升级 flutterSDK 后需重
Linux 环境下，查看 MySQL 使用的配置文件

通过 which 命令可以查看 mysql 安装路径 xff0c 如下所示 span class token function which span mysql usr bin mysql 如果服务器没有安装 mysql 命令 xff0c
ubuntu: cargo build error: failed to run custom build command for `openssl-sys v0.9.39`

cargo build error failed to run custom build command for 96 openssl sys v0 9 39 96 解决方法 xff1a 1 输入命令 sudo apt install li
Zeal一个好用的开源离线开发文档浏览器

Zeal的官网是https zealdocs org xff0c 其自我介绍是Zeal is anoffline documentation browser for software developers Zeal是为软件开发人员准备的离线
VScode如何在浏览器中打开html文件

关注我的个人博客 pinbolei cn xff0c 获取更多内容 Vscode默认是在控制台下查看html文件 xff0c 对于我们查看和调试都很不方便 xff0c 那如何在浏览器中打开呢 xff1f 1 新建一个HTML文件 2 点击左
windows远程连接Ubuntu蓝屏

Ubuntu18 04和win10使用zerotier one进行mstsc远程连接小王同学w的博客 CSDN博客 win10 zerotier安装后无法链接这位大佬写的特别详细 xff0c 但是实际操作的时候可能还会有一些问题 xff
Boost库的安装

说明 windows下的安装和linux下安装实际上大同小异 xff0c 主要是弄清楚一些配置选项 xff0c 和可执行文件的作用 Windows下安装配置环境 xff1a win8 1 64bit 43 VS2015 Step1 xff
Rust交叉编译问题(mac to linux) 2023

Rust本身是支持跨平台编译的看资料是只需要简单的跨平台编译命令就好了一官方给出的资料是 rustup target add x86 64 unknown linux gnu cargo build release target x8
linux防火墙iptables常用命令与基础知识

1 iptables常用命令 1 1查看是否已经安装了iptables以及iptables版本号 iptables V 注意 xff1a V是大写字母V xff09 1 2 关闭iptables service iptables stop
简化开发: mybatis-plus 代码自动生成以及常见问题

目录 1 MP自动代码生成和解析 1 1 getProperty 方法中的key到底是什么 1 2 源码中 System 中左边是key 调用上面方法能获取到后面内 1 3 测试用例 user dir java version 2 全部自
PyCharm import torch包失败的问题解决

Anaconda3 5 1 0 MacOSX x86 64 pkg 下载安装后 xff0c 附带安装了pytorch包需要将环境调整到新的python3 6目录下 1 在Project Interpreter选择 Show All 菜单
Virtualbox安装Debian 安装VBoxGuestAdditions增强工具

1 按照以下两个网站安装Debian https www myxzy com post 470 html https www linuxidc com Linux 2017 11 148909p2 htm 2 按照以下网站修改用户权限 xf
炉石传说酒馆战棋（python版)

详细解释内容请见代码注释XD span class token keyword import span numpy span class token keyword as span np span class token comment 随

炉石传说酒馆战棋（python版)

炉石传说酒馆战棋（python版) 的相关文章

随机推荐

热门标签