public P_BaiQi() : base("白起")
{
Sex = PSex.Male;
Age = PAge.Classic;
Index = 9;
Cost = 25;
Tips = "定位：爆发\n" +
"难度：简单\n" +
"史实：战国时期秦国名将，“战国四大名将”之一，曾在伊阙之战、长平之战中大败三晋军队，歼敌数十万，功封武安君。\n" +
"攻略：\n白起是一个强制命中系武将，白起的存在使得对方无法通过【李代桃僵】、【指桑骂槐】一类的牌免除伤害，或通过【八卦阵】、【龙胆】等方式减少伤害，而必须硬吃下伤害的100%（通常这个数字比伤害值高）。随之带来的损失则是收费地的地价永久性减少，很多时候这是不值的，但在必杀一击上，白起一点都不会含糊。";
PSkill CanSha = new PSkill("残杀");
SkillList.Add(CanSha
.AddTrigger(
(PPlayer Player, PSkill Skill) => {
return(new PTrigger(CanSha.Name)
{
IsLocked = false,
Player = Player,
Time = PTime.Injure.EmitInjure,
AIPriority = 100,
Condition = (PGame Game) => {
PInjureTag InjureTag = Game.TagManager.FindPeekTag <PInjureTag>(PInjureTag.TagName);
return InjureTag.Injure > 0 && InjureTag.ToPlayer != null && Player.Equals(InjureTag.FromPlayer) &&
InjureTag.InjureSource is PBlock && ((PBlock)InjureTag.InjureSource).Price >= 1000;
},
AICondition = (PGame Game) => {
PInjureTag InjureTag = Game.TagManager.FindPeekTag <PInjureTag>(PInjureTag.TagName);
if (InjureTag.ToPlayer.TeamIndex != Player.TeamIndex)
{
int Benefit = PMath.Percent(InjureTag.Injure, 100);
if (Benefit + InjureTag.Injure >= InjureTag.ToPlayer.Money)
{
// 一击必杀
return true;
}
if (Benefit >= 2000)
{
PBlock Source = (PBlock)InjureTag.InjureSource;
int Cost = 1000 + PAiMapAnalyzer.HouseValue(Game, Player, Source) * Source.HouseNumber * 1000 / Source.Price;
if (Cost < Benefit)
{
return true;
}
}
}
return false;
},
Effect = (PGame Game) => {
CanSha.AnnouceUseSkill(Player);
PInjureTag InjureTag = Game.TagManager.FindPeekTag <PInjureTag>(PInjureTag.TagName);
PBlock Source = (PBlock)InjureTag.InjureSource;
Source.Price -= 1000;
PNetworkManager.NetworkServer.TellClients(new PRefreshBlockBasicOrder(Source));
Game.LoseMoney(InjureTag.ToPlayer, PMath.Percent(InjureTag.Injure, 100));
}
});
}));
}
public int AIExpect(PGame Game, PPlayer Player, PBlock Block)
{
int[] dx = { 1, -1, 0, 0 };
int[] dy = { 0, 0, 1, -1 };
int OriginalX = Block.X;
int OriginalY = Block.Y;
int sum, x, y;
sum = PAiMapAnalyzer.HouseValue(Game, Player, Block);
for (int i = 0; i < 4; ++i)
{
x = OriginalX;
y = OriginalY;
do
{
x += dx[i];
y += dy[i];
PBlock TempBlock = Game.Map.FindBlockByCoordinate(x, y);
if (TempBlock != null)
{
if (TempBlock.Lord != null)
{
sum += PAiMapAnalyzer.HouseValue(Game, Player, TempBlock);
}
}
else
{
break;
}
} while (true);
}
return(sum);
}
/// <summary>
/// 弃一座房屋（没有则不弃）
/// </summary>
/// <param name="Player"></param>
/// <param name="TargetPlayer"></param>
/// <param name="Title"></param>
public void ThrowHouse(PPlayer Player, PPlayer TargetPlayer, string Title)
{
if (TargetPlayer.HasHouse)
{
PBlock TargetBlock = null;
if (Player.IsAI)
{
if (Player.TeamIndex == TargetPlayer.TeamIndex)
{
TargetBlock = PAiMapAnalyzer.MinValueHouse(this, TargetPlayer).Key;
}
else
{
TargetBlock = PAiMapAnalyzer.MaxValueHouse(this, TargetPlayer).Key;
}
}
else
{
TargetBlock = PNetworkManager.NetworkServer.ChooseManager.AskToChooseBlock(Player, "[" + Title + "]选择" + TargetPlayer.Name + "的房屋", (PBlock Block) => TargetPlayer.Equals(Block.Lord) && Block.HouseNumber > 0);
}
if (TargetBlock != null)
{
PNetworkManager.NetworkServer.TellClients(new PHighlightBlockOrder(TargetBlock.Index.ToString()));
LoseHouse(TargetBlock, 1);
}
}
}
public override int AIInHandExpectation(PGame Game, PPlayer Player)
{
int Basic = 1000;
int Sum = 0;
List <PPlayer> Targets = AIEmitTargets(Game, Player);
Targets.ForEach((PPlayer _Player) => {
if (!(_Player.Defensor != null && _Player.Defensor.Model is P_YooHsi && Targets.Count > 1))
{
int Cof = (_Player.TeamIndex == Player.TeamIndex ? 1 : -1);
if (_Player.General is P_LiuJi)
{
Sum += 1200 * 6 / 5 * Cof;
}
else
{
int Choose1 = PAiMapAnalyzer.ChangeFaceExpect(Game, _Player);
int Choose2 = _Player.Money <= 1000 ? -30000 : -1000;
int Chosen = Math.Max(Choose1, Choose2);
Sum += Chosen * Cof;
}
}
});
Sum = Sum * 5 / 6;
Basic = Math.Max(Basic, Sum);
return(Math.Max(Basic, base.AIInHandExpectation(Game, Player)));
}
private KeyValuePair <KeyValuePair <PBlock, PBlock>, int> MaxLandPair(PGame Game, PPlayer Player)
{
int Test = int.MinValue;
List <PBlock> LandList = Game.Map.BlockList.FindAll((PBlock Block) => Block.Lord != null && !Block.IsBusinessLand);
PBlock Ans1 = null;
PBlock Ans2 = null;
foreach (PBlock Land1 in LandList)
{
foreach (PBlock Land2 in LandList)
{
if (Land1.Index < Land2.Index)
{
int HouseCount1 = Land1.HouseNumber;
int HouseCount2 = Land2.HouseNumber;
int ValueBefore = PAiMapAnalyzer.HouseValue(Game, Player, Land1) * HouseCount1 +
PAiMapAnalyzer.HouseValue(Game, Player, Land2) * HouseCount2;
int ValueAfter = PAiMapAnalyzer.HouseValue(Game, Player, Land1) * HouseCount2 +
PAiMapAnalyzer.HouseValue(Game, Player, Land2) * HouseCount1;
if (ValueAfter - ValueBefore > Test)
{
Test = ValueAfter - ValueBefore;
Ans1 = Land1;
Ans2 = Land2;
}
}
}
}
return(new KeyValuePair <KeyValuePair <PBlock, PBlock>, int>(new KeyValuePair <PBlock, PBlock>(Ans1, Ans2), Test));
}
public P_ChiaChiihPuTien() : base(CardName)
{
Point = 5;
Index = 27;
foreach (PTime Time in new PTime[] {
PPeriod.FirstFreeTime.During,
PPeriod.SecondFreeTime.During
})
{
MoveInHandTriggerList.Add((PPlayer Player, PCard Card) => {
return(new PTrigger(CardName)
{
IsLocked = false,
Player = Player,
Time = Time,
AIPriority = 10,
Condition = (PGame Game) => {
int MinMoney = PMath.Min(Game.PlayerList.FindAll((PPlayer _Player) => _Player.IsAlive), (PPlayer _Player) => _Player.Money).Value;
return Player.Equals(Game.NowPlayer) && (Player.IsAI || Game.Logic.WaitingForEndFreeTime()) && Player.Money == MinMoney;
},
AICondition = (PGame Game) => {
return PAiMapAnalyzer.OutOfGameExpect(Game, Player, true) > 0 && Game.NowPeriod.Equals(PPeriod.FirstFreeTime.During);
},
Effect = MakeNormalEffect(Player, Card, AIEmitTargets, AIEmitTargets,
(PGame Game, PPlayer User, PPlayer Target) => {
Target.Tags.CreateTag(PTag.OutOfGameTag);
})
});
});
}
}
public override int AIInHandExpectation(PGame Game, PPlayer Player)
{
int Basic = 0;
Basic = Math.Max(Basic, PAiMapAnalyzer.OutOfGameExpect(Game, Player, true, true) - 2000 * (Player.Area.HandCardArea.CardNumber - 1));
return(Math.Max(Basic, base.AIInHandExpectation(Game, Player)));
}
public List<PPlayer> AIEmitTargets(PGame Game, PPlayer Player) {
PPlayer Target = PMath.Max(Game.Enemies(Player).FindAll((PPlayer _Player) => _Player.HasHouse &&
(_Player.Defensor == null || !(_Player.Defensor.Model is P_ChiiHsingPaao)) &&
!_Player.Area.AmbushCardArea.CardList.Exists((PCard _Card) => _Card.Model.Name.Equals(CardName)) &&
!(_Player.General is P_LiuJi)),
(PPlayer _Player) => PAiMapAnalyzer.MinValueHouse(Game, _Player).Value + PMath.RandInt(0, 10)).Key;
return new List<PPlayer>() { Target};
}
public List <PPlayer> AIEmitTargets(PGame Game, PPlayer Player)
{
return(new List <PPlayer>()
{
PMath.Max(Game.Enemies(Player), (PPlayer _Player) => {
return -PAiMapAnalyzer.OutOfGameExpect(Game, _Player);
}, true).Key
});
}
public override int AIInHandExpectation(PGame Game, PPlayer Player)
{
int Basic = PAiMapAnalyzer.MaxValueHouse(Game, Player).Value;
Basic = Math.Max(1000, PMath.Max(Game.Enemies(Player), (PPlayer _Player) => {
return(PAiMapAnalyzer.MaxValueHouse(Game, _Player).Value + Basic);
}, true).Value);
return(Math.Max(Basic, base.AIInHandExpectation(Game, Player)));
}
public override int AIInHandExpectation(PGame Game, PPlayer Player)
{
int Basic = 0;
int OutOfGameExpect = PMath.Max(Game.Enemies(Player), (PPlayer _Player) => {
return(-PAiMapAnalyzer.OutOfGameExpect(Game, _Player));
}, true).Value;
Basic = Math.Max(Basic, OutOfGameExpect);
return(Math.Max(Basic, base.AIInHandExpectation(Game, Player)));
}
private KeyValuePair <PPlayer, int> FindTarget(PGame Game, PPlayer Player)
{
int Basic = PAiMapAnalyzer.MaxValueHouse(Game, Player).Value;
return(PMath.Max(Game.Enemies(Player).FindAll((PPlayer _Player) => _Player.Area.EquipmentCardArea.CardNumber > 0), (PPlayer _Player) => {
int HouseValue = _Player.HasHouse ? PAiMapAnalyzer.MaxValueHouse(Game, _Player).Value + Basic : 30000;
int EquipValue = PMath.Max(_Player.Area.EquipmentCardArea.CardList, (PCard Card ) => Card.Model.AIInEquipExpectation(Game, _Player) + Card.Model.AIInHandExpectation(Game, Player)).Value;
return Math.Min(HouseValue, EquipValue);
}, true));
}
public override int AIInHandExpectation(PGame Game, PPlayer Player)
{
int Basic = 2500;
int Test = PMath.Max(Game.Map.BlockList.FindAll((PBlock Block) => Block.Lord != null && Block.Lord.TeamIndex == Player.TeamIndex), (PBlock Block) => {
return(PAiMapAnalyzer.HouseValue(Game, Block.Lord, Block));
}).Value;
Basic = Math.Max(Basic, Test);
return(Math.Max(Basic, base.AIInHandExpectation(Game, Player)));
}
public override int AIInAmbushExpectation(PGame Game, PPlayer Player) {
if (Player.General is P_LiuJi) {
if (Player.HasHouse) {
return 800;
} else {
return 1200;
}
}
if (Player.HasHouse) {
return -PAiMapAnalyzer.MinValueHouse(Game, Player).Value * 5 / 6;
} else {
return 0;
}
}
public static List <int> DirectionExpectations(PGame Game, PPlayer Player, PBlock Block)
{
/*
* AI决策商业用地类型的机制：
* 购物中心收益：2*（40%*max（1，20*建房次数上限/环长）+20%）*地价*敌方人数
* 研究所收益 ：牌堆期望收益*2*己方人数
* 公园收益 ：（max（1，20*建房次数上限/环长）*60%+50%）*地价
* 城堡收益 ：（50%+敌方人数*20%）*赠送房屋数量*地价
* 当铺收益 ：2000*己方人数
*
* 特殊计算：
* 杨玉环：研究所+4000
*/
int RingLength = PAiMapAnalyzer.GetRingLength(Game, Block);
int MaxOperationCount = Player.PurchaseLimit;
int MikuBias = (Player.General is P_IzayoiMiku && Player.RemainLimit("轮舞曲")) ? 1 : 0;
int ShoppingCenterExpectation = 2 * PMath.Percent(Block.Price, 40 * Math.Max(1, 20 * MaxOperationCount / RingLength) + 20) * Game.Enemies(Player).Count;
int InsituteExpectation = 2000 * 2 * Game.Teammates(Player).Count;
int ParkExpectation = PMath.Percent(Block.Price, 60 * Math.Max(1, 20 * MaxOperationCount / RingLength) + 50);
int CastleExpectation = Game.Enemies(Player).Exists((PPlayer _Player) => _Player.Money > 3000 && _Player.Weapon != null && _Player.Weapon.Model is P_ToouShihChi) ? 0: PMath.Percent(Block.Price, 50 + 20 * Game.Enemies(Player).Count) * Game.GetBonusHouseNumberOfCastle(Player, Block);
if (MikuBias == 1 && Game.GetBonusHouseNumberOfCastle(Player, Block) >= PMath.Max(Game.Map.BlockList.FindAll((PBlock _Block) => _Block.IsBusinessLand && _Block.Lord != null && _Block.Lord.TeamIndex == Player.TeamIndex).ConvertAll((PBlock _Block) => _Block.HouseNumber)))
{
CastleExpectation = PMath.Percent(Block.Price, 50 + 40 * Game.Enemies(Player).Count) * Game.GetBonusHouseNumberOfCastle(Player, Block);
}
int PawnshopExpectation = 2000 * Game.Teammates(Player).Count;
int AltarExpectation = 1000 * 20 * 6 / RingLength * Game.Enemies(Player).Count;
if (Player.General is P_YangYuHuan)
{
InsituteExpectation += 4000;
}
if (Player.General is P_Xdyu || Player.General is P_Gryu)
{
ShoppingCenterExpectation += 4000;
}
List <int> ExpectationList = new List <int>()
{
ShoppingCenterExpectation,
InsituteExpectation,
ParkExpectation,
CastleExpectation,
AltarExpectation
};
return(ExpectationList);
}
public override int AIInHandExpectation(PGame Game, PPlayer Player)
{
int Basic = 2000;
if (!Game.Map.BlockList.Exists((PBlock Block) => Player.Equals(Block.Lord)))
{
return(Basic);
}
int TargetNumber = Game.AlivePlayerNumber - 1;
int Test = PMath.Sum(Game.PlayerList.FindAll((PPlayer _Player) => _Player.IsAlive && !(_Player.Defensor != null && _Player.Defensor.Model is P_YooHsi && TargetNumber > 1) && _Player.HasHouse).ConvertAll((PPlayer _Player) => {
return(PAiMapAnalyzer.MaxValueHouse(Game, Player, true).Value + PAiMapAnalyzer.MinValueHouse(Game, _Player).Value *(_Player.TeamIndex == Player.TeamIndex ? -1 : 1));
}));
Basic = Math.Max(Basic, Test);
return(Math.Max(Basic, base.AIInHandExpectation(Game, Player)));
}
public static KeyValuePair <int, int> LangZiBannedNumber(PGame Game, PPlayer Player)
{
int Original = PAiMapAnalyzer.StartFromExpect(Game, Player, Player.Position);
int Answer = 0;
int AnswerValue = 0;
for (int i = 1; i < 6; ++i)
{
int New = PAiMapAnalyzer.StartFromExpect(Game, Player, Player.Position, i);
if (New - Original > AnswerValue)
{
Answer = i;
AnswerValue = New - Original;
}
}
return(new KeyValuePair <int, int>(Answer, AnswerValue));
}
public P_AnTuCheevnTsaang() : base(CardName)
{
Point = 2;
Index = 8;
foreach (PTime Time in new PTime[] {
PPeriod.FirstFreeTime.End
})
{
MoveInHandTriggerList.Add((PPlayer Player, PCard Card) => {
return(new PTrigger(CardName)
{
IsLocked = false,
Player = Player,
Time = Time,
AIPriority = 120,
Condition = (PGame Game) => {
return Game.NowPlayer.Equals(Player);
},
AICondition = (PGame Game) => {
int Ideal = PMath.Max(Game.Map.BlockList, (PBlock Block) => PAiMapAnalyzer.StartFromExpect(Game, Player, Block)).Value;
int Current = PAiMapAnalyzer.StartFromExpect(Game, Player, Player.Position);
return (Ideal - Current >= 2000) || (-Current >= Player.Money && -Ideal < Player.Money);
},
Effect = MakeNormalEffect(Player, Card, AIEmitTargets, AIEmitTargets,
(PGame Game, PPlayer User, PPlayer Target) => {
PBlock TargetBlock = Target.Position;
if (Target.IsAI)
{
TargetBlock = PMath.Max(Game.Map.BlockList, (PBlock Block) => PAiMapAnalyzer.StartFromExpect(Game, Player, Block)).Key;
}
else
{
TargetBlock = PNetworkManager.NetworkServer.ChooseManager.AskToChooseBlock(Target, "[暗度陈仓]选择目标格子");
}
if (TargetBlock != null)
{
PNetworkManager.NetworkServer.TellClients(new PHighlightBlockOrder(TargetBlock.Index.ToString()));
Game.MovePosition(Target, Target.Position, TargetBlock);
}
})
});
});
}
}
public static bool XianJuTest(PGame Game, PPlayer Player)
{
string XianJu = "闲居";
// 依据闲居，优化使用伤害类计策牌的条件
if (Player.General is P_PanYue && Game.NowPlayer.Equals(Player))
{
if (!Game.NowPeriod.IsAfter(PPeriod.WalkingStage))
{
List <PBlock> NextBlocks = PAiMapAnalyzer.NextBlocks(Game, Player);
return(NextBlocks.Exists((PBlock Block) => Block.Lord != null && Block.Lord.TeamIndex != Player.TeamIndex && Block.Toll >= Player.Money) || !NextBlocks.Exists((PBlock Block) => Block.Lord != null && Block.Lord.TeamIndex == Player.TeamIndex) || !Player.RemainLimit(XianJu));
}
else
{
return(Player.Position.Lord == null || Player.Position.Lord.TeamIndex != Player.TeamIndex || Player.Money <= 2000 || !Player.RemainLimit(XianJu));
}
}
return(true);
}
public static KeyValuePair <PPlayer, int> Target(PGame Game, PPlayer Player, int Base = 0)
{
return(PMath.Max(Game.PlayerList.FindAll((PPlayer _Player) => _Player.IsAlive && !_Player.Equals(Player) && _Player.Distance(Player) <= 3 && !_Player.NoLadder), (PPlayer _Player) => {
PBlock ExpectBlock = _Player.Position;
if (_Player.Traffic != null && _Player.Traffic.Model is P_ChiihTuu)
{
ExpectBlock = ExpectBlock.NextBlock;
}
int Value = PAiMapAnalyzer.Expect(Game, _Player, ExpectBlock);
if (_Player.TeamIndex == Player.TeamIndex)
{
return Value - Base;
}
else
{
return -Value - Base;
}
}, true));
}
static public List <PPlayer> AIEmitTargets(PGame Game, PPlayer Player, int BaseValue)
{
int MaxMoney = PMath.Max(Game.PlayerList, (PPlayer _Player) => _Player.Money).Value;
PPlayer Target = PMath.Max(Game.PlayerList.FindAll((PPlayer _Player) => _Player.Money == MaxMoney), (PPlayer _Player) => {
if (Player.TeamIndex == _Player.TeamIndex)
{
return(PAiMapAnalyzer.ChangeFaceExpect(Game, _Player) - BaseValue);
}
else
{
return(-PAiMapAnalyzer.ChangeFaceExpect(Game, _Player) - BaseValue);
}
}, true).Key;
return(new List <PPlayer>()
{
Target
});
}
public P_Newton() : base("牛顿")
{
Sex = PSex.Male;
Age = PAge.Renaissance;
Index = 19;
Cost = 40;
Tips = "定位：防御\n" +
"难度：中等\n" +
"史实：英国物理学家、数学家。主要贡献包括但不限于发现万有引力定律、牛顿运动定律、光的色散原理，提出微积分、牛顿迭代法、二项式定理，发明反射式望远镜等。代表作《自然哲学的数学原理》。\n" +
"攻略：\n牛顿是一个趣味性十足的武将，技能应用十分灵活，【惯性】的存在使其拥有极强的移动能力，能够灵活规避各种危险，同时在前期迅速攫取土地，中后期能够更快经过奖励处，从而拥有一定的续航能力。牛顿可以配合队友的上屋抽梯或逃避敌人的【剑舞】或【霸王】，需要较强的预判力。";
PSkill Grx_ = new PSkill("惯性");
SkillList.Add(Grx_
.AddTrigger(
(PPlayer Player, PSkill Skill) => {
return(new PTrigger(Grx_.Name)
{
IsLocked = false,
Player = Player,
Time = PPeriod.WalkingStage.Start,
AIPriority = 10,
Condition = (PGame Game) => {
return Game.NowPlayer.Equals(Player) && Player.Position.HouseNumber == 0 &&
Player.Money > 500;
},
AICondition = (PGame Game) => {
PStepCountTag StepCountTag = Game.TagManager.FindPeekTag <PStepCountTag>(PStepCountTag.TagName);
int Current = PAiMapAnalyzer.Expect(Game, Player, Game.Map.NextStepBlock(Player.Position, StepCountTag.StepCount));
PBlock NewtonTarget = Grx_Next(Game, Player.Position).Key;
int Possible = PAiMapAnalyzer.Expect(Game, Player, Game.Map.NextStepBlock(NewtonTarget, StepCountTag.StepCount));
return Possible - Current > 500;
},
Effect = (PGame Game) => {
Grx_.AnnouceUseSkill(Player);
Game.LoseMoney(Player, 500);
Game.MovePosition(Player, Player.Position, Grx_Next(Game, Player.Position).Key);
}
});
}));
}
public override int AIInHandExpectation(PGame Game, PPlayer Player)
{
int Basic = 3000;
int MinValue = int.MaxValue;
int MaxValue = int.MinValue;
PBlock Target = null;
PBlock Block = Player.Position.NextBlock;
for (int i = 0; i < 6; ++i, Block = Block.NextBlock)
{
int Value = PAiMapAnalyzer.Expect(Game, Player, Block);
MinValue = Math.Min(Value, MinValue);
if (Value > MaxValue)
{
Target = Block;
}
MaxValue = Math.Max(Value, MaxValue);
}
Basic = Math.Max(Basic, (MaxValue - MinValue) / 2 + PAiMapAnalyzer.ChangeFaceExpect(Game, Player, Target));
return(Math.Max(Basic, base.AIInHandExpectation(Game, Player)));
}
public override int AIInHandExpectation(PGame Game, PPlayer Player)
{
int Basic = 0;
bool MultiTarget = AIEmitTargets(Game, Player).Count > 1;
Game.Teammates(Player, false).ForEach((PPlayer _Player) => {
KeyValuePair <PBlock, int> Test = PAiMapAnalyzer.MinValueHouse(Game, _Player);
if (Test.Key != null && !(_Player.Defensor != null && _Player.Defensor.Model is P_YooHsi && MultiTarget))
{
Basic -= Test.Value;
}
});
Game.Enemies(Player).ForEach((PPlayer _Player) => {
KeyValuePair <PBlock, int> Test = PAiMapAnalyzer.MinValueHouse(Game, _Player);
if (Test.Key != null && !(_Player.Defensor != null && _Player.Defensor.Model is P_YooHsi && MultiTarget))
{
Basic += Test.Value;
}
});
Basic = Math.Max(Basic, 500);
return(Math.Max(Basic, base.AIInHandExpectation(Game, Player)));
}
/// <summary>
/// 伤害预测收益，无修正情形为基本伤害的2倍or0
/// </summary>
/// <param name="Game"></param>
/// <param name="Player">视点玩家</param>
/// <param name="FromPlayer">造成伤害的玩家</param>
/// <param name="Target"></param>
/// <param name="BaseInjure">基本伤害量</param>
/// <param name="Source">伤害方式</param>
/// <returns></returns>
public static int InjureExpect(PGame Game, PPlayer Player, PPlayer FromPlayer, PPlayer Target, int BaseInjure, PObject Source)
{
#region 防止伤害的情况
if (Player.OutOfGame ||
!Target.CanBeInjured ||
(FromPlayer == null && Target.HasEquipment <P_YinYangChing>()) ||
(BaseInjure <= 1000 && Target.HasEquipment <P_NanManHsiang>()))
{
return(0);
}
#endregion
int FromCof = FromPlayer == null ? 0 : (Player.TeamIndex == FromPlayer.TeamIndex ? 1 : -1);
int ToCof = (Player.TeamIndex != Target.TeamIndex ? 1 : -1);
int Sum = 0;
#region 成伤害时发动的技能：古锭刀，龙胆，太极，苍狼，趁火打劫，女权，怒斩
if (FromPlayer != null)
{
if (FromPlayer.Tags.ExistTag(P_WuZhao.NvQuanTag.Name) && (Source is PBlock || Source is PCard))
{
BaseInjure += 2000;
}
if (FromPlayer.General is P_Gryu && Source is PBlock && FromPlayer.Area.EquipmentCardArea.CardNumber > Target.Area.EquipmentCardArea.CardNumber)
{
BaseInjure += 600;
}
if ((Target.Area.HandCardArea.CardNumber == 0 || (FromPlayer.General is P_IzayoiMiku && FromPlayer.TeamIndex != Target.TeamIndex)) && FromPlayer.HasEquipment <P_KuTingTao>() && Source is PBlock)
{
BaseInjure *= 2;
}
if (FromPlayer.General is P_ZhaoYun && FromPlayer.Tags.ExistTag(P_ZhaoYun.PDanTag.TagName))
{
if (P_ZhaoYun.LongDanICondition(Game, FromPlayer, Target, BaseInjure))
{
BaseInjure = PMath.Percent(BaseInjure, 150);
}
}
if (FromPlayer.General is P_ZhangSanFeng && Player.Tags.ExistTag(P_ZhangSanFeng.PYinTag.Name))
{
BaseInjure += PMath.Percent(BaseInjure, 20);
}
}
if (Target.Area.OwnerCardNumber > 0)
{
if (FromPlayer != null && FromPlayer.HasEquipment <P_TsaangLang>() && Source != null && Source is PCard Card && Card.Model is PSchemeCardModel)
{
Sum += 2000 * FromCof + 2000 * ToCof;
}
if (Player.HasInHand <P_CheevnHuoTaChieh>())
{
Sum += 2000 + 2000 * ToCof;
}
}
#endregion
#region 受到伤害时发动的技能：八卦阵，百花裙，龙胆，太极，霸王，白衣，镇魂曲
if (Target.HasEquipment <P_PaKuaChevn>())
{
// 美九改版，八卦阵有效
if (Target.General is P_LiuJi)
{
Sum -= 1000 * ToCof;
BaseInjure = PMath.Percent(BaseInjure, 50);
}
else
{
BaseInjure = (BaseInjure + PMath.Percent(BaseInjure, 50)) / 2;
}
}
if (Target.HasEquipment <P_PaiHuaChooon>() && FromPlayer != null && !Target.Sex.Equals(FromPlayer.Sex))
{
BaseInjure = PMath.Percent(BaseInjure, 50);
}
if (Target.General is P_ZhaoYun && Target.Tags.ExistTag(P_ZhaoYun.PDanTag.TagName))
{
if (P_ZhaoYun.LongDanIICondition(Game, Target, FromPlayer, BaseInjure))
{
BaseInjure = PMath.Percent(BaseInjure, 50);
}
}
if (Target.General is P_ZhangSanFeng && Target.Tags.ExistTag(P_ZhangSanFeng.PYangTag.Name))
{
BaseInjure -= PMath.Percent(BaseInjure, 20);
}
if (Game.AlivePlayers().Exists((PPlayer _Player) => {
return(!_Player.Equals(Target) && _Player.TeamIndex != Target.TeamIndex && _Player.Distance(Target) <= 1 && _Player.General is P_Xdyu);
}))
{
BaseInjure += 800;
}
if (Target.General is P_LvMeng && Target.Area.EquipmentCardArea.CardNumber > 0 && !(FromPlayer.General is P_IzayoiMiku && FromPlayer.TeamIndex != Target.TeamIndex))
{
BaseInjure = Math.Min(PMath.Percent(BaseInjure, 50) + 2000, BaseInjure);
}
if (Target.General is P_IzayoiMiku && Game.AlivePlayersExist <P_Gabriel>())
{
BaseInjure -= PMath.Percent(BaseInjure, 20);
}
#endregion
int ExpectTargetMoney = Target.Money - BaseInjure;
#region 濒死时发动的技能：蓄谋，精灵加护，圣女
if (ExpectTargetMoney <= 0)
{
bool flag = true;
if (!(FromPlayer.General is P_LvZhi))
{
if (Target.General is P_Gabriel)
{
flag = false;
// 破军歌姬的复活
if (FromPlayer.Equals(Target))
{
// 对自己伤害，不触发复活
}
else if (FromPlayer.TeamIndex == Target.TeamIndex)
{
// 美九自己的伤害，触发复活大利好
Sum += 15000;
}
else
{
// 对方的伤害
if (Game.AlivePlayersExist <P_IzayoiMiku>())
{
// 美九未死，大不利
Sum -= 15000;
}
else
{
flag = true;
}
}
}
else if (Game.AlivePlayersExist <P_JeanneDarc>() && Source is PBlock)
{
PPlayer Jeanne = Game.AlivePlayers().Find((PPlayer _Player) => _Player.General is P_JeanneDarc);
if (Jeanne.TeamIndex == Target.TeamIndex && Jeanne.Area.OwnerCardNumber > 0 && Jeanne.Money > 5000 && ExpectTargetMoney > -10000)
{
flag = false;
Sum += (5000 + (Target.Equals(Jeanne) ? 0 : 2000) - 2000 * Jeanne.Area.OwnerCardNumber) * (Target.TeamIndex == Player.TeamIndex ? 1 : -1);
}
}
}
if (flag)
{
Sum += 30000 * ToCof;
}
}
#endregion
Sum += BaseInjure * ToCof;
Sum += BaseInjure * FromCof;
#region 受到伤害后：离骚
if (Target.General is P_QuYuan)
{
// Sum -= 900 * ToCof;
// 因为离骚总是会发动，其他伤害也会触发，天灾也会触发
// 所以不应该将离骚计入伤害计算
}
#endregion
#region 伤害结束后：风云
if (FromPlayer != null && FromPlayer.General is P_ChenYuanYuan)
{
Sum += 200 * FromCof;
}
if (Target.General is P_ChenYuanYuan)
{
Sum -= 200 * ToCof;
}
#endregion
#region 队友间平衡：自身和目标的合理阈值为50%-200%
if (FromPlayer.TeamIndex == Target.TeamIndex)
{
if (FromPlayer.General is P_IzayoiMiku && Target.General is P_Gabriel)
{
// 美九对破军歌姬的伤害，积极性
Sum += 2000;
}
else if (FromPlayer.General is P_Gabriel && Target.General is P_IzayoiMiku)
{
// 破军歌姬对美九的伤害，消极性
Sum -= 20000;
}
else
{
if (FromPlayer.Money > ExpectTargetMoney * 2)
{
Sum -= 2000;
}
else if (FromPlayer.Money >= Target.Money)
{
Sum -= 100;
}
else if (FromPlayer.Money < Target.Money * 2)
{
Sum += 1000;
}
}
}
#endregion
#region 美九歌厅的翻面效果
if (Source is PBlock Block && Block.BusinessType.Equals(PBusinessType.Club))
{
Sum += PAiMapAnalyzer.ChangeFaceExpect(Game, Target) * (-ToCof);
}
#endregion
#region 贞德设为高嘲讽
if (Game.AlivePlayersExist <P_JeanneDarc>())
{
PPlayer Jeanne = Game.AlivePlayers().Find((PPlayer _Player) => _Player.General is P_JeanneDarc);
if (Jeanne.TeamIndex != Player.TeamIndex)
{
if (Target.Equals(Jeanne) && Sum > 0)
{
Sum += PMath.Percent(Sum, 20);
}
}
}
#endregion
return(Sum);
}
public P_PaaoChuanYinYoo() : base(CardName)
{
Point = 3;
Index = 17;
foreach (PTime Time in new PTime[] {
PPeriod.FirstFreeTime.During,
PPeriod.SecondFreeTime.During
})
{
MoveInHandTriggerList.Add((PPlayer Player, PCard Card) => {
return(new PTrigger(CardName)
{
IsLocked = false,
Player = Player,
Time = Time,
AIPriority = 140,
Condition = (PGame Game) => {
return Player.Equals(Game.NowPlayer) && (Player.IsAI || Game.Logic.WaitingForEndFreeTime()) && Game.Map.BlockList.Exists((PBlock Block) => Player.Equals(Block.Lord)) && (Player.Area.EquipmentCardArea.CardNumber > 0 || Player.Area.HandCardArea.CardList.Exists((PCard _Card) => Card.Type.IsEquipment())) && AIEmitTargets(Game, Player).Count > 0;
},
AICondition = (PGame Game) => {
if (Player.General is P_WuZhao && Player.RemainLimit(PSkillInfo.女权.Name))
{
return false;
}
return Player.Area.HandCardArea.CardList.Exists((PCard _Card) => Card.Type.IsEquipment()) && AIInHandExpectation(Game, Player) > 2000;
},
Effect = MakeNormalEffect(Player, Card, AIEmitTargets, AIEmitTargets,
(PGame Game, PPlayer User, PPlayer Target) => {
if (Target.HasHouse)
{
PBlock TargetBlock = null;
if (Target.IsAI)
{
TargetBlock = PAiMapAnalyzer.MinValueHouse(Game, Target).Key;
}
else
{
TargetBlock = PNetworkManager.NetworkServer.ChooseManager.AskToChooseBlock(Target, "选择一座房屋以交给" + User.Name, (PBlock Block) => Target.Equals(Block.Lord) && Block.HouseNumber > 0);
}
if (TargetBlock != null)
{
Game.LoseHouse(TargetBlock, 1);
TargetBlock = null;
if (User.IsAI)
{
TargetBlock = PAiMapAnalyzer.MaxValueHouse(Game, User, true).Key;
}
else
{
TargetBlock = PNetworkManager.NetworkServer.ChooseManager.AskToChooseBlock(User, "选择一处你的土地放置房屋", (PBlock Block) => User.Equals(Block.Lord));
}
if (TargetBlock != null)
{
Game.GetHouse(TargetBlock, 1);
}
}
}
}, (PGame Game, PPlayer User, List <PPlayer> Targets) => {
PCard TargetCard = null;
if (User.IsAI)
{
TargetCard = PMath.Min(User.Area.HandCardArea.CardList.FindAll((PCard _Card) => _Card.Type.IsEquipment()), (PCard _Card) => _Card.Model.AIInHandExpectation(Game, User)).Key;
}
else
{
do
{
TargetCard = PNetworkManager.NetworkServer.ChooseManager.AskToChooseOwnCard(User, CardName + "[选择一张装备牌]", true, true);
} while (!TargetCard.Type.IsEquipment());
}
Game.CardManager.MoveCard(TargetCard, User.Area.HandCardArea.CardList.Contains(TargetCard) ? User.Area.HandCardArea : User.Area.EquipmentCardArea, Game.CardManager.ThrownCardHeap);
})
});
});
}
}
public P_ChiehTaoShaJevn() : base(CardName)
{
Point = 1;
Index = 3;
foreach (PTime Time in new PTime[] {
PPeriod.FirstFreeTime.During,
PPeriod.SecondFreeTime.During
})
{
MoveInHandTriggerList.Add((PPlayer Player, PCard Card) => {
return(new PTrigger(CardName)
{
IsLocked = false,
Player = Player,
Time = Time,
AIPriority = 110,
Condition = (PGame Game) => {
return Player.Equals(Game.NowPlayer) && (Player.IsAI || Game.Logic.WaitingForEndFreeTime()) && Game.PlayerList.Exists((PPlayer _Player ) => !_Player.Equals(Player) && _Player.Area.EquipmentCardArea.CardNumber > 0);
},
AICondition = (PGame Game) => {
return AIEmitTargets(Game, Player)[0] != null;
},
Effect = MakeNormalEffect(Player, Card, AIEmitTargets, (PGame Game, PPlayer _Player) => {
return !_Player.Equals(Player) && _Player.Area.EquipmentCardArea.CardNumber > 0;
},
(PGame Game, PPlayer User, PPlayer Target) => {
int ChosenResult = -1;
if (!Target.HasHouse || User.LandNumber == 0)
{
if (Target.Area.EquipmentCardArea.CardNumber > 0)
{
ChosenResult = 1;
}
}
else if (Target.Area.EquipmentCardArea.CardNumber == 0)
{
ChosenResult = 0;
}
else
{
if (Target.IsAI)
{
ChosenResult = PAiMapAnalyzer.MaxValueHouse(Game, Target).Value > PAiCardExpectation.FindMostValuable(Game, Target, Target, false).Value ? 1 : 0;
}
else
{
ChosenResult = PNetworkManager.NetworkServer.ChooseManager.Ask(Target, CardName + "-选择一项", new string[] {
"令" + User.Name + "获得你1座房屋",
"令" + User.Name + "获得你1张装备"
});
}
}
if (ChosenResult == 0)
{
PBlock TargetBlock = null;
if (User.IsAI)
{
TargetBlock = PAiMapAnalyzer.MaxValueHouse(Game, Target).Key;
}
else
{
TargetBlock = PNetworkManager.NetworkServer.ChooseManager.AskToChooseBlock(User, "选择一座" + Target.Name + "的房屋", (PBlock Block) => Target.Equals(Block.Lord) && Block.HouseNumber > 0);
}
if (TargetBlock != null)
{
Game.LoseHouse(TargetBlock, 1);
if (User.IsAI)
{
TargetBlock = PAiMapAnalyzer.MaxValueHouse(Game, User, true).Key;
}
else
{
TargetBlock = PNetworkManager.NetworkServer.ChooseManager.AskToChooseBlock(User, "选择一处你的土地放置房屋", (PBlock Block) => User.Equals(Block.Lord));
}
if (TargetBlock != null)
{
Game.GetHouse(TargetBlock, 1);
}
}
}
else if (ChosenResult == 1)
{
PCard Got = Game.GetCardFrom(User, Target, false);
#region 成就：老司机
if (Got.Model is P_ToouShihChi && User.Area.HandCardArea.CardList.Contains(Got))
{
PArch.Announce(Game, User, "老司机");
}
#endregion
}
})
});
});
}
}
public P_WangXu() : base("王诩")
{
Sex = PSex.Male;
Age = PAge.Classic;
Index = 5;
Tips = "定位：全能\n" +
"难度：困难\n" +
"史实：战国时期思想家、纵横家，号“鬼谷子”。\n" +
"攻略：\n王诩具有两个技能，在免费武将里是一个较为难用的武将，建议对游戏有一定了解之后使用。\n【纵横】可以将牌转化成【远交近攻】，但3和6两个点数里有不少高价值的牌，如【借尸还魂】、【欲擒故纵】、【抛砖引玉】、【走为上计】等，是否将这些牌转化成显性1000收益、隐性收益视队友状况而定的【远交近攻】，需要结合场上形势进行把握。\n【隐居】提高了王诩的生存能力，但【隐居】本身是负收益技能，移出游戏的王诩失去了收取过路费的能力，还会亏一座房屋，如果每回合都使用，必定只能苟延残喘片刻。所以，【隐居】的目的地需要给自己留出几个回合较为安全的空间，让自己在【隐居】的间隙可以造成输出。\n对于新手而言，也可以选择无脑【纵横】给大神队友补牌，后期保持【隐居】牵制敌人的打法。";
PSkill ZongHeng = new PSkill("纵横")
{
Initiative = true
};
SkillList.Add(ZongHeng
.AddTimeTrigger(
new PTime[] {
PPeriod.FirstFreeTime.During,
PPeriod.SecondFreeTime.During
},
(PTime Time, PPlayer Player, PSkill Skill) => {
return(new PTrigger(ZongHeng.Name)
{
IsLocked = false,
Player = Player,
Time = Time,
AIPriority = 200,
CanRepeat = true,
Condition = (PGame Game) => {
return Player.Equals(Game.NowPlayer) &&
(Player.IsAI || Game.Logic.WaitingForEndFreeTime()) &&
Player.Area.HandCardArea.CardList.Exists((PCard Card) => Card.Point % 3 == 0);
},
AICondition = (PGame Game) => {
return Player.Area.HandCardArea.CardList.Exists((PCard Card) => {
return Card.Point % 3 == 0 && Card.Model.AIInHandExpectation(Game, Player) < 3000;
}) && P_YooenChiaoChinKung.AIEmitTargets(Game, Player)[0] != null;
},
Effect = (PGame Game) => {
ZongHeng.AnnouceUseSkill(Player);
PCard TargetCard = null;
if (Player.IsAI)
{
TargetCard = PAiCardExpectation.FindLeastValuable(Game, Player, Player, true, false, false, true, (PCard Card) => Card.Point % 3 == 0).Key;
}
else
{
List <PCard> Waiting = Player.Area.HandCardArea.CardList.FindAll((PCard Card) => Card.Point % 3 == 0);
int Result = PNetworkManager.NetworkServer.ChooseManager.Ask(Player, ZongHeng.Name, Waiting.ConvertAll((PCard Card) => Card.Name).Concat(new List <string> {
"取消"
}).ToArray());
if (Result >= 0 && Result < Waiting.Count)
{
TargetCard = Waiting[Result];
}
}
if (TargetCard != null)
{
TargetCard.Model = new P_YooenChiaoChinKung();
PTrigger Trigger = TargetCard.Model.MoveInHandTriggerList.Find((Func <PPlayer, PCard, PTrigger> TriggerGenerator) => TriggerGenerator(Player, TargetCard).Time.Equals(PPeriod.FirstFreeTime.During))?.Invoke(Player, TargetCard);
if (Trigger != null)
{
Game.Logic.StartSettle(new PSettle("纵横[远交近攻]", Trigger.Effect));
}
}
}
});
}));
PSkill YinJu = new PSkill("隐居")
{
Initiative = true
};
SkillList.Add(YinJu
.AnnounceTurnOnce()
.AddTimeTrigger(
new PTime[] {
PPeriod.FirstFreeTime.During,
PPeriod.SecondFreeTime.During
},
(PTime Time, PPlayer Player, PSkill Skill) => {
return(new PTrigger(YinJu.Name)
{
IsLocked = false,
Player = Player,
Time = Time,
AIPriority = 10,
CanRepeat = true,
Condition = (PGame Game) => {
return Player.Equals(Game.NowPlayer) && (Player.IsAI || Game.Logic.WaitingForEndFreeTime()) && Player.RemainLimit(YinJu.Name) && Player.HasHouse;
},
AICondition = (PGame Game) => {
if (!Player.CanBeInjured)
{
return false;
}
if (Game.NowPeriod.Equals(PPeriod.FirstFreeTime))
{
bool CanGo = false;
PAiMapAnalyzer.NextBlocks(Game, Player).ForEach((PBlock Block) => {
if (Block.Lord != null && Block.Lord.TeamIndex != Player.TeamIndex && Block.Toll >= Player.Money)
{
CanGo = true;
}
if (Block.GetMoneyStopSolid < 0 && -Block.GetMoneyStopSolid >= Player.Money)
{
CanGo = true;
}
if (Block.GetMoneyStopPercent < 0 && PMath.Percent(Player.Money, -Block.GetMoneyStopPercent) >= Player.Money)
{
CanGo = true;
}
});
return CanGo || PAiMapAnalyzer.OutOfGameExpect(Game, Player, true) - PAiMapAnalyzer.MinValueHouse(Game, Player).Value > 0;
}
else
{
return false;
}
},
Effect = (PGame Game) => {
YinJu.AnnouceUseSkill(Player);
PBlock Block = null;
if (Player.IsAI)
{
Block = PAiMapAnalyzer.MinValueHouse(Game, Player).Key;
}
else
{
Block = PNetworkManager.NetworkServer.ChooseManager.AskToChooseBlock(Player, YinJu.Name, (PBlock _Block) => {
return Player.Equals(_Block.Lord) && _Block.HouseNumber > 0;
});
}
if (Block != null)
{
Game.MovePosition(Player, Player.Position, Block);
PNetworkManager.NetworkServer.TellClients(new PHighlightBlockOrder(Block.Index.ToString()));
Game.LoseHouse(Block, 1);
Player.Tags.CreateTag(PTag.OutOfGameTag);
YinJu.DeclareUse(Player);
}
}
});
}));
}
public static PBlock AIEmitTarget(PGame Game, PPlayer Player)
{
return(PMath.Max(Game.Map.BlockList.FindAll((PBlock Block) => Block.Lord != null && Block.Lord.TeamIndex == Player.TeamIndex), (PBlock Block) => {
return PAiMapAnalyzer.HouseValue(Game, Block.Lord, Block);
}).Key);
}
public P_ShuShangKaaiHua() : base(CardName)
{
Point = 5;
Index = 29;
foreach (PTime Time in new PTime[] {
PPeriod.FirstFreeTime.During,
PPeriod.SecondFreeTime.During
})
{
MoveInHandTriggerList.Add((PPlayer Player, PCard Card) => {
return(new PTrigger(CardName)
{
IsLocked = false,
Player = Player,
Time = Time,
AIPriority = 100,
Condition = (PGame Game) => {
return Player.Equals(Game.NowPlayer) && (Player.IsAI || Game.Logic.WaitingForEndFreeTime()) && Game.Map.BlockList.Exists((PBlock Block) => Block.Lord != null);
},
AICondition = (PGame Game) => {
return PMath.Max(Game.Map.BlockList.FindAll((PBlock Block) => Block.Lord != null && Block.Lord.TeamIndex == Player.TeamIndex), (PBlock Block) => {
return PAiMapAnalyzer.HouseValue(Game, Block.Lord, Block);
}).Value >= 2500;
},
Effect = (PGame Game) => {
List <PPlayer> Targets = new List <PPlayer>();
Game.Monitor.CallTime(PTime.Card.AfterEmitTargetTime, new PUseCardTag(Card, Player, Targets));
if (Player.Area.EquipmentCardArea.CardList.Contains(Card))
{
Game.CardManager.MoveCard(Card, Player.Area.EquipmentCardArea, Game.CardManager.SettlingArea);
}
else
{
Game.CardManager.MoveCard(Card, Player.Area.HandCardArea, Game.CardManager.SettlingArea);
}
Game.Monitor.CallTime(PTime.Card.AfterBecomeTargetTime, new PUseCardTag(Card, Player, Targets));
PBlock Target = null;
if (Player.IsAI)
{
Target = AIEmitTarget(Game, Player);
}
else
{
Target = PNetworkManager.NetworkServer.ChooseManager.AskToChooseBlock(Player, "树上开花[选择有主土地]", (PBlock Block) => Block.Lord != null);
}
if (Target != null)
{
PNetworkManager.NetworkServer.TellClients(new PHighlightBlockOrder(Target.Index.ToString()));
Game.GetHouse(Target, 1);
#region 成就：花开富贵
if (Target.BusinessType.Equals(PBusinessType.Park))
{
PArch.Announce(Game, Player, "花开富贵");
}
#endregion
}
Game.CardManager.MoveCard(Card, Game.CardManager.SettlingArea, Game.CardManager.ThrownCardHeap);
Game.Monitor.CallTime(PTime.Card.EndSettleTime, new PUseCardTag(Card, Player, Targets));
}
});
});
}
}
