关于炉石兄弟的目录和文件介绍

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

public enum actionEnum
{
    endturn = 0,
    playcard,
    attackWithHero,
    useHeroPower,
    attackWithMinion
}
public class Action
{
	public actionEnum actionType;
	public Handmanager.Handcard card;
	//public int cardEntitiy;
	public int place; //= target where card/minion is placed
	public Minion own;
	public Minion target;
	public int druidchoice; // 1 left card, 2 right card
	public int penalty;
	public int turn = -1;
	public int prevHpOwn = -1;
	public int prevHpTarget = -1;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

public enum actionEnum
{
    endturn = 0, // 结束此回合
    playcard, // 出一张牌，出的牌在card中
    attackWithHero, // 英雄进行攻击，target作为目标，own通常是我方英雄
    useHeroPower, 
    // 使用英雄技能，target作为目标
    // (英雄技能无攻击目标的英雄则为null，如Mage)
    attackWithMinion // 随从进行攻击，target作为目标，own是用于攻击的随从
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

public class Action
{
    actionEnum actionType; // 用于记录操作的类型。
    Handmanager.Handcard card; 
    // 记录出的牌，在attackWithHero和attackWithMinion操作中为null
    int place;
    // 用于记录位置，如actionType为playcard时就会有内容，
    // 比如出一个随从就会标记出放置的位置（最左边为0），
    // 如果是出一张法术牌的话，具体内容没有研究，应该是有赋值的

    Minion own;
    Minion target; 
    // 这两个成员，顾名思义一个是 我方随从（英雄），另一个是攻击目标。

    int druidchoice; 
    // 用于抉择牌选择
    // 如果是未修改过的兄弟，抉择牌的编号分别是（0：中间 1：左边 2：右边）
    int penalty; 
    // 惩罚值，对于这个操作给出多少的惩罚
    // 值越大越不推荐这样下，如果值为负数则是非常推荐。
    int turn = -1; 
    // 记录的应该是此回合中的第几步操作，初始值为-1 (不确定)
    int prevHpOwn = -1; // 不确定
    int prevHpTarget = -1; // 不确定
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68

private void doallmoves(bool test, bool isLethalCheck)
{
    //set maxwide to the value for the first-turn-sim.
    foreach (EnemyTurnSimulator ets in enemyTurnSim)
    {
        ets.setMaxwide(true);
    }
    foreach (EnemyTurnSimulator ets in enemySecondTurnSim)
    {
        ets.setMaxwide(true);
    }

    //if (isLethalCheck) this.posmoves[0].enemySecretList.Clear();
    this.posmoves[0].isLethalCheck = isLethalCheck;
    this.mainTurnSimulator.doallmoves(this.posmoves[0]);

    bestplay = this.mainTurnSimulator.bestboard;
    float bestval = this.mainTurnSimulator.bestmoveValue;

    help.loggonoff(true);
    help.logg("-------------------------------------");
    if (bestplay.ruleWeight != 0) help.logg("ruleWeight " + bestplay.ruleWeight * -1);
    if (settings.printRules > 0)
    {
        String[] rulesStr = bestplay.rulesUsed.Split('@');
        foreach (string rs in rulesStr)
        {
            if (rs == "") continue;
            help.logg("rule: " + rs);
        }
    }
    help.logg("value of best board " + bestval);

    this.bestActions.Clear();
    this.bestmove = null;
    ActionNormalizer an = new ActionNormalizer();
    //an.checkLostActions(bestplay, isLethalCheck);
    if (settings.adjustActions > 0) an.adjustActions(bestplay, isLethalCheck);
    foreach (Action a in bestplay.playactions)
    {
        this.bestActions.Add(new Action(a));
        a.print();
    }

    if (this.bestActions.Count >= 1)
    {
        this.bestmove = this.bestActions[0];
        this.bestActions.RemoveAt(0);
    }
    this.bestmoveValue = bestval;

    if (bestmove != null && bestmove.actionType != actionEnum.endturn) // save the guessed move, so we doesnt need to recalc!
    {
        this.nextMoveGuess = new Playfield();

        this.nextMoveGuess.doAction(bestmove);
    }
    else
    {
        nextMoveGuess.mana = -100;
    }

    if (isLethalCheck)
    {
        this.lethalMissing = bestplay.enemyHero.armor + bestplay.enemyHero.Hp;//RR
        help.logg("missing dmg to lethal " + this.lethalMissing);
    }
}

1

private void doallmoves(bool test, bool isLethalCheck)

1
2
3
4
5
6
7
8
9

//set maxwide to the value for the first-turn-sim.
foreach (EnemyTurnSimulator ets in enemyTurnSim)
{
    ets.setMaxwide(true);
}
foreach (EnemyTurnSimulator ets in enemySecondTurnSim)
{
    ets.setMaxwide(true);
}

1
2

this.posmoves[0].isLethalCheck = isLethalCheck;
this.mainTurnSimulator.doallmoves(this.posmoves[0]);

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144

bestplay = this.mainTurnSimulator.bestboard; // 上面函数计算之后的最优场面
float bestval = this.mainTurnSimulator.bestmoveValue; // 上面最优场面的评分

// 输出与rule相关信息
help.loggonoff(true);
help.logg("-------------------------------------");
if (bestplay.ruleWeight != 0) help.logg("ruleWeight " + bestplay.ruleWeight * -1); 
if (settings.printRules > 0)
{
    String[] rulesStr = bestplay.rulesUsed.Split('@');
    foreach (string rs in rulesStr)
    {
        if (rs == "") continue;
        help.logg("rule: " + rs);
    }
}
// 输出与rule相关信息结束
help.logg("value of best board " + bestval);// 输出最优场面评分

this.bestActions.Clear();// 清除上次回合计算的操作方法
this.bestmove = null;// 清除上次回合计算的操作方法

//接下来两行是对操作重排使得其先打出AOE伤害，在_setting.txt中设定，默认关闭，实际使用效果并不好
ActionNormalizer an = new ActionNormalizer();
if (settings.adjustActions > 0) an.adjustActions(bestplay, isLethalCheck);



foreach (Action a in bestplay.playactions)
{
    this.bestActions.Add(new Action(a));
    a.print();
}
//输出场面信息
if (this.bestActions.Count >= 1)
{
    this.bestmove = this.bestActions[0];
    this.bestActions.RemoveAt(0);
}
this.bestmoveValue = bestval;

//如果不是回合结束操作，则模拟一下下一个操作
if (bestmove != null && bestmove.actionType != actionEnum.endturn) // save the guessed move, so we doesnt need to recalc!
{
    this.nextMoveGuess = new Playfield();
    this.nextMoveGuess.doAction(bestmove);
}
else
{
    //如果是回合结束操作，下一个操作则不进行（不进行的方法是让法力值-100，使其无操作可做）
    nextMoveGuess.mana = -100;
}

//斩杀信息输出，输出斩杀所需的伤害
if (isLethalCheck)
{
    this.lethalMissing = bestplay.enemyHero.armor + bestplay.enemyHero.Hp;//RR
    help.logg("missing dmg to lethal " + this.lethalMissing);
}

这个文件中另一个重要的函数与调试AI息息相关。这里我直接在注释中写出我的一些理解
public List<double> autoTester(bool printstuff, string data = "", int mode = 0) //-mode: 0-all, 1-lethalcheck, 2-normal
{
    //游戏信息（场面）还原，
    List<double> retval = new List<double>();
    double calcTime = 0;
    help.logg("simulating board ");

    BoardTester bt = new BoardTester(data);
    if (!bt.datareaded) return retval;
    hp.printHero();
    hp.printOwnMinions();
    hp.printEnemyMinions();
    hm.printcards();


    //开始计算
    posmoves.Clear();
    Playfield pMain = new Playfield();
    pMain.print = printstuff;
    posmoves.Add(pMain);
    //输出场面信息
    foreach (Playfield p in this.posmoves)
    {
        p.printBoard();
    }
    help.logg("ownminionscount " + posmoves[0].ownMinions.Count);
    help.logg("owncardscount " + posmoves[0].owncards.Count);

    foreach (var item in this.posmoves[0].owncards)
    {
        help.logg("card " + item.card.name + " is playable :" + item.canplayCard(posmoves[0], true) + " cost/mana: " + item.manacost + "/" + posmoves[0].mana);
    }
    help.logg("ability " + posmoves[0].ownHeroAblility.card.name + " is playable :" + posmoves[0].ownHeroAblility.card.canplayCard(posmoves[0], 2, true) + " cost/mana: " + posmoves[0].ownHeroAblility.card.getManaCost(posmoves[0], 2) + "/" + posmoves[0].mana);
    //输出场面信息结束
    DateTime strt = DateTime.Now;
    // 斩杀判定
    if (mode == 0 || mode == 1)
    {
        // 可以看到这个函数正是我们上面所讲的，这里第二个参数传入了true
        // 则说明这里这个分支则是兄弟进行扎煞判定的地方
        doallmoves(false, true);
        calcTime = (DateTime.Now - strt).TotalSeconds;
        help.logg("calculated " + calcTime);
        retval.Add(calcTime);
    }
    // 这里要补充一下，如果兄弟判定对面血量为负数(已斩杀)，则会将场面评分提升到10000以上。
    // 而这里的bestmoveValue > 5000，则说明场面已经大概可以斩杀了。
    // 但是为什么是五千不是一万？
    // 这个问题的原因在于兄弟是会对当前回合和我方下一回合进行模拟的，而默认的权重分配是0.5
    // 如果这个回合斩杀了，兄弟可能就不会对下个回合进行模拟，所以如果这个回合评分为10000 * 0.5 + 0 * 0.5 = 5000
    // 以上只是个人猜测，有少量的代码可证明，知道原因的可以在下面评论哦
    if (Settings.Instance.berserkIfCanFinishNextTour > 0 && bestmoveValue > 5000)
    {

    }
    else if (bestmoveValue < 10000)
    {
        // 到了这里，就是正常的模拟了，会正常模拟所有可能的操作方法。
        // 如果是调试，应该进入这里的**doallmoves(false, false);**函数进行调试。
        // normal
        if (mode == 0 || mode == 2)
        {
            posmoves.Clear();
            pMain = new Playfield();
            pMain.print = printstuff;
            posmoves.Add(pMain);
            strt = DateTime.Now;
            doallmoves(false, false);
            calcTime = (DateTime.Now - strt).TotalSeconds;
            help.logg("calculated " + calcTime);
            retval.Add(calcTime);
        }
    }

    if (printstuff)
    {
        this.mainTurnSimulator.printPosmoves();
        simmulateWholeTurn();
        help.logg("calculated " + calcTime);
    }

    return retval;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

public enum cardtype
{
    NONE, //未知
    MOB = 4, //随从
    SPELL = 5, //法术
    WEAPON = 7, //武器
    HEROPWR = 10, //英雄技能
    ENCHANTMENT = 6, //增幅（例如：变形术，救赎，力量的代价，自然之力的附加效果）
    HERO = 3, //英雄卡
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

public enum ErrorType2
{
    REQ_MINION_TARGET = 1, 随从目标
    REQ_FRIENDLY_TARGET = 2, 友方目标
    REQ_ENEMY_TARGET = 3, 敌方目标
    REQ_DAMAGED_TARGET = 4, 损伤目标
    REQ_MAX_SECRETS = 5, 最大奥秘
    REQ_FROZEN_TARGET = 6, 冻结目标
    REQ_CHARGE_TARGET = 7, 冲锋目标
    REQ_TARGET_MAX_ATTACK = 8, 最大攻击力目标 有param=
    REQ_NONSELF_TARGET = 9, 非自己目标
    REQ_TARGET_WITH_RACE = 10, 种族目标 有param=
    REQ_TARGET_TO_PLAY = 11, 需要目标
    REQ_NUM_MINION_SLOTS = 12, 随从数目插槽 有param=
    REQ_WEAPON_EQUIPPED = 13, 武器装备，需要武器
    REQ_HERO_TARGET = 17, 英雄目标
    REQ_TARGET_IF_AVAILABLE = 22, 有目标如果用（抉择星辰降落，巫医）
    REQ_MINIMUM_ENEMY_MINIONS = 23, 最少的敌方随从 有param=
    REQ_TARGET_FOR_COMBO = 24, 连击有目标
    REQ_HERO_OR_MINION_TARGET = 33, 英雄或随从目标
    REQ_TARGET_MIN_ATTACK = 41, 最小攻击力，有param=
    REQ_MINIMUM_TOTAL_MINIONS = 45, 需要最少随从数目，有param=
    REQ_MUST_TARGET_TAUNTER = 46, 目标必须是嘲讽
    REQ_UNDAMAGED_TARGET = 47, 目标必须是未受伤的
    REQ_TARGET_IF_AVAILABLE_AND_DRAGON_IN_HAND = 51, 有龙牌在手才有目标
    REQ_LEGENDARY_TARGET = 52, 传说目标
    REQ_FRIENDLY_MINION_DIED_THIS_TURN = 53,需要一个死亡的友方随从在当前回合死亡
    REQ_FRIENDLY_MINION_DIED_THIS_GAME = 54, 需要一个死亡的友方随从
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

public class Card
{
    public cardName name = cardName.unknown;//名称
    public int race = 0;//种族
    //14鱼人 15恶魔 17机械 18元素 20野兽 21图腾 23海盗 24龙
    public int rarity = 0;//稀有度
    //1普通白 2基础无 3稀有蓝 4史诗紫 5传说橙
    public int cost = 0;//费用
    public int Class = 0;//职业
    //2德鲁伊 3猎人 4法师 5圣骑士 6牧师 7潜行者 8萨满 9术士 10战士 11梦境牌 12中立
    public cardtype type = CardDB.cardtype.NONE;//类别
    public int Attack = 0; //攻击力
    public int Health = 0; //血量
    public int Durability = 0; //耐久值
    public bool tank = false; //嘲讽
    public bool Silence = false; //沉默
    public bool choice = false; //抉择
    public bool windfury = false; //风怒
    public bool poisonous = false; //剧毒
    public bool lifesteal = false; //吸血
    public bool reborn = false; //复生
    public bool deathrattle = false; //亡语
    public bool battlecry = false; //战吼
    public bool discover = false; //发现
    public bool oneTurnEffect = false;
    public bool Enrage = false; //愤怒
    public bool Aura = false; //光环
    public bool Combo = false; //连击
    public int overload = 0; //超载
    public bool untouchable = false; //不可被攻击
    public bool Stealth = false; //潜行
    public bool Freeze = false; //冰冻
    public bool Shield = false; //圣盾
    public bool Charge = false; //突袭
    public bool Modular = false; //磁力
    public bool Rush = false; //冲锋
    public bool Secret = false; //奥秘
    public bool Quest = false; //任务
    public bool Morph = false; //变形
    public bool Spellpower = false; //法术伤害
    public bool Inspire = false; //激励
}

1
2

public int getManaCost(Playfield p, int currentcost)
public int calculateManaCost(Playfield p)

1
2

public List<Minion> getTargetsForCard(Playfield p, bool isLethalCheck, bool own)
public List<Minion> getTargetsForHeroPower(Playfield p, bool own)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

while ((index1 = s.IndexOf("<enUS>")) == -1)
{
    s = reader.ReadLine();
}
index1 += 6;
index2 = s.IndexOf("</enUS>", index1);
temp = s.Substring(index1, index2 - index1);	
sb.Clear();
sb.Append(temp);
sb.Replace("&lt;", "");
sb.Replace("b&gt;", "");
sb.Replace("/b&gt;", "");
sb.Replace("'", "");
sb.Replace(" ", "");
sb.Replace(":", "");
sb.Replace(".", "");
sb.Replace("!", "");
sb.Replace("?", "");
sb.Replace("-", "");
sb.Replace("_", "");
sb.Replace(",", "");
sb.Replace("(", "");
sb.Replace(")", "");
sb.Replace("/", "");
sb.Replace("\"", "");
sb.Replace("·", "");
c.name = this.cardNamestringToEnum(sb.ToString().ToLower());
if(c.name == CardDB.cardName.unknown)
{
    // try chinese

    while ((index1 = s.IndexOf("<zhCN>")) == -1)
    {
        s = reader.ReadLine();
    }
    index1 += 6;
    index2 = s.IndexOf("</zhCN>", index1);
    temp = s.Substring(index1, index2 - index1);	
    sb.Clear();
    sb.Append(temp);
    sb.Replace("&lt;", "");
    sb.Replace("b&gt;", "");
    sb.Replace("/b&gt;", "");
    sb.Replace("'", "");
    sb.Replace(" ", "");
    sb.Replace(":", "");
    sb.Replace(".", "");
    sb.Replace("!", "");
    sb.Replace("?", "");
    sb.Replace("-", "");
    sb.Replace("_", "");
    sb.Replace(",", "");
    sb.Replace("(", "");
    sb.Replace(")", "");
    sb.Replace("/", "");
    sb.Replace("·", "");
    sb.Replace("\"", "");
    c.name = this.cardNamestringToEnum(sb.ToString().ToLower());  
}

1

case 59: c.needControlaSecret           = param; continue;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

public class Handcard
{
    public int position = 0; //手牌的位置
    public int entity = -1; //炉石传说内部entity编号
    public int manacost = 1000; //花费费用，但获取卡牌费用要用getManaCost(Playfield p)函数
    public int addattack = 0; //增加的攻击力，如风驰电掣的SIM中就使其 +1
    public int addHp = 0; //增加的血量
    public CardDB.Card card; //卡牌，指向CardDB.cs
    public Minion target; //目标
    public int elemPoweredUp = 0; //上回合是否使用元素牌
    public int extraParam2 = 0; //扩展参数2，可以用来记录一些此卡需要的特殊数据
    public bool extraParam3 = false; //扩展参数3
    //读取卡牌法力值
    public int getManaCost(Playfield p)
    {
        return this.card.getManaCost(p, this.manacost);
    }
    //判定卡牌是否能够使用
    public bool canplayCard(Playfield p, bool own)
    {
        return this.card.canplayCard(p, this.manacost, own);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85

public class Hrtprozis
{
    public int pId = 0; //唯一id
    public int attackFaceHp = 15; //打脸血量
    public int ownHeroFatigue = 0; //我方疲劳
    public int ownDeckSize = 30; //我方牌库数量
    public int enemyDeckSize = 30; //敌方牌库数量
    public int enemyHeroFatigue = 0; //敌方疲劳 
    public int gTurn = 0; //第几回合
    public int gTurnStep = 0; //第几个操作

    public int ownHeroEntity = -1; //我方英雄Entity
    public int enemyHeroEntitiy = -1; //敌方英雄Entity
    public DateTime roundstart = DateTime.Now; //回合开始时间
    public int currentMana = 0; //当前法力值

    public int heroHp = 30, enemyHp = 30; //我方英雄血量，敌方英雄血量
    public int heroAtk = 0, enemyAtk = 0; //我方英雄攻击力，敌方英雄攻击力
    public int heroDefence = 0, enemyDefence = 0; //我方英雄护甲，敌方英雄护甲
    public bool ownheroisread = false; //我方英雄是否可以攻击
    public int ownHeroNumAttacksThisTurn = 0; //我方英雄此回合攻击了几次
    public bool ownHeroWindfury = false; //我方英雄是否风怒
    public bool herofrozen = false; //我方英雄是否冻结
    public bool enemyfrozen = false; //敌方英雄是否冻结

    public List<CardDB.cardIDEnum> ownSecretList = new List<CardDB.cardIDEnum>(); //我方奥秘列表
    public int enemySecretCount = 0; //敌方奥秘数量
    public Dictionary<int, CardDB.cardIDEnum> DiscoverCards = new Dictionary<int, CardDB.cardIDEnum>(); //发现的卡牌
    public Dictionary<CardDB.cardIDEnum, int> turnDeck = new Dictionary<CardDB.cardIDEnum, int>(); //牌库的卡牌
    private Dictionary<int, CardDB.cardIDEnum> deckCardForCost = new Dictionary<int, CardDB.cardIDEnum>(); //指定费用的卡牌
    public bool noDuplicates = false; //牌库无重复（宇宙）

    private int numTauntCards = -1; //牌库有几张嘲讽卡
    private int numDivineShieldCards = -1; //牌库有几张圣盾卡
    private int numLifestealCards = -1;  //牌库有几张吸血卡
    private int numWindfuryCards = -1; //牌库有几张风怒卡

    public bool setGameRule = false; //设置Rule

    public HeroEnum heroname = HeroEnum.None, enemyHeroname = HeroEnum.None; //我方英雄职业，敌方英雄职业
    public string heronameingame = "", enemyHeronameingame = ""; //我方英雄名称，敌方英雄名称
    public TAG_CLASS ownHeroStartClass = TAG_CLASS.INVALID; //我方英雄职业
    public TAG_CLASS enemyHeroStartClass = TAG_CLASS.INVALID; //敌方英雄职业
    public CardDB.Card heroAbility; //我方英雄技能
    public bool ownAbilityisReady = false; //我方英雄技能是否准备完成
    public int ownHeroPowerCost = 2; //我方英雄技能费用
    public CardDB.Card enemyAbility; //敌方英雄技能
    public int enemyHeroPowerCost = 2; //敌方英雄技能费用
    public int numOptionsPlayedThisTurn = 0; //此回合中的操作数
    public int numMinionsPlayedThisTurn = 0; //此回合中的随从数
    public CardDB.cardIDEnum OwnLastDiedMinion = CardDB.cardIDEnum.None; //我方最后死亡的随从

    public int cardsPlayedThisTurn = 0; //此回合中的出牌数，可以用于判定连击
    public int ueberladung = 0; //过载水晶
    public int lockedMana = 0; //锁定水晶
    public int ownMaxMana = 0; //我方最大法力值
    public int enemyMaxMana = 0; //敌方最大法力值

    public Minion ownHero = new Minion(); //我方英雄
    public Minion enemyHero = new Minion(); //敌方英雄
    public Weapon ownWeapon = new Weapon(); //我方武器
    public Weapon enemyWeapon = new Weapon(); //敌方武器
    public List<Minion> ownMinions = new List<Minion>(); //我方随从
    public List<Minion> enemyMinions = new List<Minion>(); //敌方随从
    public Dictionary<int, IDEnumOwner> LurkersDB = new Dictionary<int, IDEnumOwner>(); //潜行随从

    public int anzOgOwnCThunHpBonus = 0; //克苏恩血量
    public int anzOgOwnCThunAngrBonus = 0; //克苏恩攻击力
    public int anzOgOwnCThunTaunt = 0; //克苏恩嘲讽
    public int anzOwnJadeGolem = 0; //我方魔像计数器
    public int anzEnemyJadeGolem = 0; //敌方魔像计数器
    public int OwnInvoke = 0; //我方祈求数
    public int EnemyInvoke = 0; //敌方祈求数
    public int ownCrystalCore = 0; //魔王的骑士：水晶核心，任务贼的任务奖励，在本局对战的剩余时间内，你的所有随从变为 4/4。
    public bool ownMinionsInDeckCost0 = false; //我方牌库中是否有0费随从
    public int anzOwnElementalsThisTurn = 0; //在此回合中使用元素牌
    public int anzOwnElementalsLastTurn = 0; //上一回合使用元素牌
    public int ownElementalsHaveLifesteal = 0; //我方元素牌具有吸血
    private int ownPlayerController = 0; //我方玩家控制？

    public PenalityManager penman; //惩罚管理
    public Settings settings; //设置管理
    Helpfunctions help; //调试输出
    CardDB cdb; //卡牌数据
}

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149

//英雄ID转到名称
public string heroIDtoName(string s)

//英雄名称转到枚举，留牌文件就是用这个函数进行转换的，由此可见圣骑士的名称用pala和paladin是一样的
public HeroEnum heroNametoEnum(string s)
{
    switch (s)
    {
        case "all": return HeroEnum.all;
        case "druid": return HeroEnum.druid;
        case "hunter": return HeroEnum.hunter;
        case "mage": return HeroEnum.mage;
        case "pala": return HeroEnum.pala;
        case "paladin": return HeroEnum.pala;
        case "priest": return HeroEnum.priest;
        case "shaman": return HeroEnum.shaman;
        case "thief": return HeroEnum.thief;
        case "rogue": return HeroEnum.thief;
        case "maievshadowsong": return HeroEnum.thief;
        case "warlock": return HeroEnum.warlock;
        case "warrior": return HeroEnum.warrior;
        case "lordjaraxxus": return HeroEnum.lordjaraxxus;
        case "ragnarosthefirelord": return HeroEnum.ragnarosthefirelord;
        default: return HeroEnum.None;
    }
}

//英雄枚举转到种类
public TAG_CLASS heroEnumtoTagClass(HeroEnum he)

//英雄种类转到枚举
public HeroEnum heroTAG_CLASSstringToEnum(string s)

//读取牌库中X费的卡牌
public CardDB.cardIDEnum getDeckCardsForCost(int cost)

//读取牌库中指定特性的卡牌(GAME_TAGs.TAUNT,GAME_TAGs.DIVINE_SHIELD,GAME_TAGs.LIFESTEAL,GAME_TAGs.WINDFURY)
public int numDeckCardsByTag(GAME_TAGs tag)

//输出当前场面上的信息到日志
public void printHero()

//输出我方随从信息到日志
public void printOwnMinions()

//输出敌方随从信息到日志
public void printEnemyMinions()

//输出我方牌库信息(兄弟的牌库读取时好时坏)
public void printOwnDeck()
[/collapse]

[collapse title="Minion.cs(随从信息)"]
public class Minion
{
    public int anzGotDmg = 0; //受到伤害次数
    public int GotDmgValue = 0; //受到伤害总和
    public int anzGotHealed = 0; //受到治疗次数
    public int GotHealedValue = 0; //受到治疗总和
    public bool gotInspire = false; //得到激励
    public bool isHero = false; //是否为英雄
    public bool own; //是否为己方
    public int pID = 0; //PID
    public CardDB.cardName name = CardDB.cardName.unknown; //随从名称
    public TAG_CLASS cardClass = TAG_CLASS.INVALID; //随从归属职业
    public int synergy = 0; //职业契合度，即各种族（机械鱼人恶魔野兽）与职业相关性
    public Handmanager.Handcard handcard; //手牌信息，如果Minion中储存的内容不够的话，可以调用这个获取更多的信息，例如 m.handcard.card
    public int entitiyID = -1; //实例ID
    public int zonepos = 0; //随从放置位置
    public CardDB.Card deathrattle2; //亡语2号，比如其他随从的亡语技能转移
    public bool playedThisTurn = false; //在这回合使用
    public bool playedPrevTurn = false; //在上回合使用
    public int numAttacksThisTurn = 0; //这回合攻击了几次
    public bool immuneWhileAttacking = false; //攻击时免疫
    public bool allreadyAttacked = false; //已经攻击过
    public bool shadowmadnessed = false; //暗影狂乱，直到回合结束，获得一个攻击力小于或等于3的敌方随从的控制权
    public bool destroyOnOwnTurnStart = false; //我方回合开始被消灭
    public bool destroyOnEnemyTurnStart = false; //敌方回合开始被消灭
    public bool destroyOnOwnTurnEnd = false; //我方回合结束被消灭
    public bool destroyOnEnemyTurnEnd = false; //敌方回合结束被消灭
    public bool changeOwnerOnTurnStart = false; //回合开始时变更所有权，如暗影狂乱结束后的归还
    public bool conceal = false; //隐藏（直到你的下个回合，使所有友方随从获得潜行）
    public int ancestralspirit = 0; //先祖之魂，使一个随从获得“亡语：再次召唤该随从。
    public int desperatestand = 0; //殊死一搏，使一个随从获得“亡语：回到战场，并具有1点生命值。”
    public int souloftheforest = 0; //丛林之魂，使你的所有随从获得“亡语：召唤一个2/2的树人”。
    public int stegodon = 0; //剑龙
    public int livingspores = 0; //活性孢子 亡语：召唤两个1/1的植物。
    public int explorershat = 0; //探险帽 使一个随从获得 + 1/+1，亡语：将一个探险帽置入你的手牌。
    public int returnToHand = 0; //回到手牌
    public int infest = 0; //寄生感染 使你的所有随从获得 “亡语：随机将一张野兽牌置入你的手牌”。

    public int ownBlessingOfWisdom = 0; //我方智慧祝福
    public int enemyBlessingOfWisdom = 0; //敌方智慧祝福
    public int ownPowerWordGlory = 0; //我方真言术：耀
    public int enemyPowerWordGlory = 0; //敌方真言术：耀
    public int spellpower = 0; //法术强度

    public bool cantBeTargetedBySpellsOrHeroPowers = false; //无法成为法术或英雄技能的目标
    public bool cantAttackHeroes = false; //无法攻击英雄
    public bool cantAttack = false; //无法攻击

    public int Hp = 0; //当前血量
    public int maxHp = 0; //最大血量
    public int armor = 0; //护甲值（英雄）

    public int Angr = 0; //攻击力
    public int AdjacentAngr = 0; //相邻buff攻击力加成
    public int tempAttack = 0; //一回合攻击力加成
    public int justBuffed = 0; //?

    public bool Ready = false; //攻击准备就绪

    public bool taunt = false; //嘲讽
    public bool wounded = false; //受伤

    public bool divineshild = false; //圣盾
    public bool windfury = false; //风怒
    public bool frozen = false; //冻结
    public bool stealth = false; //隐身
    public bool immune = false; //免疫
    public bool untouchable = false; //无法被攻击
    public bool exhausted = false; //无法攻击？
    public bool lifesteal = false; //吸血
    public bool modular = false; //磁力
    public int charge = 0; //冲锋
    public int rush = 0; //突袭
    public int hChoice = 0; //？
    public bool poisonous = false; //剧毒
    public bool cantLowerHPbelowONE = false; //血量无法低于1

    public bool silenced = false; //沉默
    public bool playedFromHand = false; //从手牌中打出
    public bool extraParam = false; //扩展参数1
    public int extraParam2 = 0; //扩展参数2
}

下面还有几个常用的函数
//受到伤害
public void getDamageOrHeal(int dmg, Playfield p, bool isMinionAttack, bool dontCalcLostDmg)
//随从死亡
public void minionDied(Playfield p)
//更新状态
public void updateReadyness()
//被沉默
public void becomeSilence(Playfield p)
//攻击之后的状态
public Minion GetTargetForMinionWithSurvival(Playfield p, bool own)
//特殊随从的特效添加位置
public void loadEnchantments(List<miniEnch> enchants, int ownPlayerControler)

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186

//val是value的简称
public float doallmoves(Playfield playf)
{
    print = playf.print; //确定是否输出场面，记录在print中
    this.isLethalCheck = playf.isLethalCheck; //是否为伤害检查
    enoughCalculations = false; //计算是否足够，深度大于最大深度，计算场面数大于最大宽度时为true
    botBase = Ai.Instance.botBase; //策略文件类
    this.addToPosmoves(playf); //将当前场面加入到状态队列
    bool havedonesomething = true; //是否无步骤可出，例如：法力值不够出任何牌，随从全部已经攻击
    List<Playfield> temp = new List<Playfield>(); //这一回合的状态队列
    int deep = 0; //深度
    bestoldval = -20000000; //最小的val，用于标记是否已经计算过场面val
    while (havedonesomething)
    { 
        temp.AddRange(this.posmoves);
        havedonesomething = false;
        //startEnemyTurnSimThread 函数非常重要，AI的核心内容，看下面的介绍
        if (print) startEnemyTurnSimThread(temp, 0, temp.Count);
        else
        {
            //似乎是启用多线程的形式计算
            Parallel.ForEach(Partitioner.Create(0, temp.Count),
                 range =>
                 {
                     startEnemyTurnSimThread(temp, range.Item1, range.Item2);
                 });
        }

        foreach (Playfield p in temp)
        {
            if (this.totalboards > 0) this.calculated += p.nextPlayfields.Count; //计算总的场面数，用于剪枝
            if (this.calculated <= this.totalboards) //如果宽度小于设定值则继续计算
            {
                this.posmoves.AddRange(p.nextPlayfields); //将操作后的PlayField进入队列，方便下一次运算
            }

            float pVal = botBase.getPlayfieldValue(p);
            //计算场面的val，如果是调试的话跟可以进去看看，不在调试中跟进去的是模版文件
            //里面开头的第一句话便是  if (p.value >= -2000000) return p.value;
            //和上面的bestoldval = -20000000;对应来看就能理解
            //意思就是防止多次运算，这个场面的val如果大于-2000000(已经计算过val)则直接返回

            if (pVal > bestoldval)
            {
                //如果新计算的val大于以前记录的最大val，则更新最大的val，并且记录场面信息
                bestoldval = pVal;
                bestold = p;
                bestoldDuplicates.Clear();
            }
            else if (pVal == bestoldval) bestoldDuplicates.Add(p); //如果val相等则加入bestoldDuplicates，方便之后调用
        }

        if (isLethalCheck && bestoldval >= 10000) this.posmoves.Clear(); 
        //如果bestval大于等于10000则意味着兄弟计算出当前场面可以斩杀
        //对应的策略中的代码是 if (p.enemyHero.Hp <= 0) retval = 10000;

        if (this.posmoves.Count > 0) havedonesomething = true; //如果还有其他状态可以模拟，则继续运算

        cuttingposibilities(isLethalCheck); //去除重复的PlayField，下面会讲解
        deep++;
        //下面两行就是判断计算的数量有没有大于设定的值，如果大于则不进行运算了
        if (this.calculated > this.totalboards) enoughCalculations = true;
        if (deep >= this.maxdeep) enoughCalculations = true;
    }

    if (this.dirtyTwoTurnSim > 0 && !twoturnfields.Contains(bestold)) twoturnfields.Add(bestold);
    if (!isLethalCheck && bestoldval < 10000) doDirtyTwoTurnsim();

    if (posmoves.Count >= 1)
    {
        //把所有的场面根据val进行排序，将高分的排在前面
        posmoves.Sort((a, b) => botBase.getPlayfieldValue(b).CompareTo(botBase.getPlayfieldValue(a)));
        Playfield bestplay = posmoves[0];
        float bestval = botBase.getPlayfieldValue(bestplay);
        int pcount = posmoves.Count;
        for (int i = 1; i < pcount; i++)
        {
            float val = botBase.getPlayfieldValue(posmoves[i]);
            if (bestval > val) break;
            if (posmoves[i].cardsPlayedThisTurn > bestplay.cardsPlayedThisTurn) continue; 
            else if (posmoves[i].cardsPlayedThisTurn == bestplay.cardsPlayedThisTurn)
            {
                if (bestplay.optionsPlayedThisTurn > posmoves[i].optionsPlayedThisTurn) continue; 
                else if (bestplay.optionsPlayedThisTurn == posmoves[i].optionsPlayedThisTurn && bestplay.enemyHero.Hp <= posmoves[i].enemyHero.Hp) continue;
            }
            bestplay = posmoves[i];
            bestval = val;
        }
        this.bestmove = bestplay.getNextAction();
        this.bestmoveValue = bestval;
        this.bestboard = new Playfield(bestplay);
        this.bestboard.guessingHeroHP = bestplay.guessingHeroHP;
        this.bestboard.value = bestplay.value;
        this.bestboard.hashcode = bestplay.hashcode;
        bestoldDuplicates.Clear();
        //正常退出从这里返回
        return bestval;
    }
    this.bestmove = null;
    this.bestmoveValue = -100000;
    this.bestboard = playf;
    //这里是异常退出返回的值
    return -10000;
}
//对于这个函数名称我不是特别的理解，似乎应该是ownTurnSimThread
private void startEnemyTurnSimThread(List<Playfield> source, int startIndex, int endIndex)
{
    int berserk = Settings.Instance.berserkIfCanFinishNextTour;
    int printRules = Settings.Instance.printRules;
    for (int i = startIndex; i < endIndex; i++)
    {
        Playfield p = source[i];
        if (p.complete || p.ownHero.Hp <= 0) { }
        else if (!enoughCalculations)
        {
            //从这里进入调用getMoveList函数，这个函数返回的是兄弟下一步所有可以做的操作
            //如果调试到这里，输出actions，发现没有你想要的Action就可以跟进去看看
            //一般来说，法力值不够出的牌会直接省略，如果正常操作能够出的牌没出，
            //则说明，惩罚值大于500，操作直接被省略，这是我调试的经验
            //建议直接跟进去看寻找原因，可以加深理解
            List<Action> actions = movegen.getMoveList(p, usePenalityManager, useCutingTargets, true);

            if (printRules > 0) p.endTurnState = new Playfield(p);
            //读取到actions后接下来对每个步骤进行模拟
            //从而得到操作之后的场面并且计算val值
            foreach (Action a in actions)
            {
                Playfield pf = new Playfield(p);
                pf.doAction(a);
                pf.evaluatePenality += - pf.ruleWeight + RulesEngine.Instance.getRuleWeight(pf);
                if (pf.ownHero.Hp > 0 && pf.evaluatePenality < 500) p.nextPlayfields.Add(pf);
            }
        }

        if (this.isLethalCheck)
        {
            //可以斩杀
            if (berserk > 0)
            {
                //结束回合，接下来模拟敌方下一回合的操作
                p.endTurn();
                if (p.enemyHero.Hp > 0)
                {
                    bool needETS = true;
                    //如果对面没有嘲讽且我方随从全部可以攻击则进行不模拟
                    if (p.anzEnemyTaunt < 1) foreach (Minion m in p.ownMinions) { if (m.Ready) { needETS = false; break; } }
                    else
                    {
                        if (p.anzOwnTaunt < 1) foreach (Minion m in p.ownMinions) { if (m.Ready) { needETS = false; break; } }
                    }
                    //从这里进入模拟敌方下一回合的操作
                    if (needETS) Ai.Instance.enemyTurnSim[threadnumber].simulateEnemysTurn(p, this.simulateSecondTurn, playaround, false, playaroundprob, playaroundprob2);
                }
            }

            p.complete = true;

        }
        else
        {
            p.endTurn();
            //这里和上面的区别就在于不进行判定是否需要模拟敌方的下个回合和一些判定
            if (p.enemyHero.Hp > 0)
            {
                Ai.Instance.enemyTurnSim[threadnumber].simulateEnemysTurn(p, this.simulateSecondTurn, playaround, false, playaroundprob, playaroundprob2);
                //如果val <= -10000　再进入判断
                if (p.value <= -10000)
                {
                    bool secondChance = false;
                    foreach (Action a in p.playactions)
                    {
                        if (a.actionType == actionEnum.playcard)
                        {
                            //这里判定一下是否出了战吼相关的牌，如果有的话 val += 1500
                            if (pen.cardDrawBattleCryDatabase.ContainsKey(a.card.card.name)) secondChance = true;
                        }
                    }
                    if (secondChance) p.value += 1500;
                }
            }
            p.complete = true;
        }
        //计算一下p的val值
        botBase.getPlayfieldValue(p);
    }
}