public override int Excute(角色 角色1, 角色 角色2, int 伤害, bool 是否反击)
{
if (是否反击)
return 伤害 * 2;
else
return 伤害;
}
public override decimal Get武将加成(角色 角色1, 角色 角色2)
{
var value = base.Get武将加成(角色1, 角色2);
if (角色2.兵种.Name == "怪物")
value *= 2.5m;
return value;
}
public override decimal Get基础伤害(角色 角色1, 角色 角色2)
{
var value = base.Get基础伤害(角色1, 角色2);
value = value * 基数;
return value;
}
public override decimal Get基础伤害(角色 角色1, 角色 角色2)
{
var value = base.Get基础伤害(角色1, 角色2);
value += 角色1.最大兵力 - 角色1.兵力;
return value;
}
public override int 单角色伤害结算(角色 角色1, 角色 角色2, bool 是否反击, int 战场修正)
{
int 击倒几率 = Convert.ToInt32(角色1.兵力 / 角色2.兵力 * 100 / 10 + 角色1.实际智 * 4 + 击倒系数);
if (Roll.Hit(击倒几率))
角色2.是否败走 = true;
return 0;
}
public override decimal Get基础伤害(角色 角色1,角色 角色2)
{
角色1.临时防 = 0;
var value = base.Get基础伤害(角色1, 角色2);
value = Convert.ToInt32(value * 基数);
return value;
}
public override int 单角色伤害结算(角色 角色1, 角色 角色2, bool 是否反击, int 战场修正)
{
var 伤害 = base.单角色伤害结算(角色1, 角色2, 是否反击, 战场修正);
int 击倒几率 = Convert.ToInt32(伤害 * 伤害击倒系数 / 角色2.兵力 + 击倒系数 + 角色1.实际智 * 智力击倒系数);
if (Roll.Hit(击倒几率))
角色2.是否败走 = true;
return 伤害;
}
public override void Excute(角色 角色 ,技能环境 环境)
{
if (角色.兵力 * 100 / 角色.最大兵力 < 50)
{
var 赋予 = new 赋予()
{
Level = 3,
是否单回合 = false
};
角色.防御赋予 = 赋予;
环境.ResultList.Add(new 赋予结果()
{
赋予 = 赋予,
技能 = new 团结力(),
Type = "防御",
角色1 = 角色,
角色2 = 角色,
});
}
}
public virtual decimal Get武将加成(角色 角色1, 角色 角色2)
{
if (物理系)
{
var result = (角色1.实际攻 - 角色2.实际防) * 常量.武将减伤系数 + 1m;
if (result < 0m)
result = 0m;
return result;
}
else
{
var result = (角色1.实际智 - 角色2.实际智) * 常量.武将减伤系数 + 1m;
if (result < 0m)
result = 0m;
return result;
}
}
public void 行动(角色 角色, 主动技能 技能)
{
角色.顺序值 += 技能.技能速度 * 0.6m + (11 - 角色.实际速) * 8;
}
public void 打断(角色 角色)
{
角色.准备技能 = null;
角色.顺序值 += 常量.打断延迟;
}
public override int 结算战果(int 伤害, 角色 角色)
{
return base.结算战果(伤害, 角色) * 2;
}
private 技能环境 createEnvironment(角色 施法者, bool isTeamA, List<角色> targetList)
{
技能环境 技能环境 = new 技能环境()
{
施放者 = 施法者,
目标List = targetList,
IsTeamA = isTeamA,
战场 = isTeamA ? teamA战场 : teamA战场.反转()
};
return 技能环境;
}
public static 角色 Create(string name, string 兵种, int 攻, int 防, int 智, int 速, int 行动点, int 兵力, int 最大兵力, int 排, int 列, string 基础攻击技能, string 技能1, string 技能2, string 被动技能, string 特殊技能)
{
角色 角色 = new 角色()
{
Name = name,
攻 = 攻,
临时攻 = 攻,
防 = 防,
临时防 = 防,
速 = 速,
临时速 = 速,
智 = 智,
临时智 = 智,
行动点 = 行动点,
最大行动点 = 行动点,
兵力 = 兵力,
最大兵力 = 最大兵力,
排 = 排,
列 = 列
};
switch (兵种)
{
case "剑士":
角色.兵种 = Battle.兵种.剑士;
break;
case "盾兵":
角色.兵种 = Battle.兵种.盾兵;
break;
case "火枪":
角色.兵种 = Battle.兵种.火枪;
break;
case "和尚":
角色.兵种 = Battle.兵种.和尚;
break;
case "忍者":
角色.兵种 = Battle.兵种.忍者;
break;
case "军师":
角色.兵种 = Battle.兵种.军师;
break;
case "弓兵":
角色.兵种 = Battle.兵种.弓兵;
break;
case "炮兵":
角色.兵种 = Battle.兵种.炮兵;
break;
case "骑兵":
角色.兵种 = Battle.兵种.骑兵;
break;
case "阴阳":
角色.兵种 = Battle.兵种.阴阳;
break;
case "巫女":
角色.兵种 = Battle.兵种.巫女;
break;
}
if (!string.IsNullOrEmpty(基础攻击技能))
角色.基础攻击技能 = create技能(基础攻击技能) as 主动技能;
if (!string.IsNullOrEmpty(技能1))
角色.技能1 = create技能(技能1) as 主动技能;
if (!string.IsNullOrEmpty(技能2))
角色.技能2 = create技能(技能2) as 主动技能;
if (!string.IsNullOrEmpty(被动技能))
角色.被动技能 = create技能(被动技能) as 被动技能;
if (!string.IsNullOrEmpty(特殊技能))
角色.特殊技能 = create技能(特殊技能) as 主动技能;
角色.待机 = 待机.Instance;
return 角色;
}
public List<ActionResult> Action(角色 角色, string action, List<角色> targetList)
{
if (this.teamA战场.行动顺序.List[0] != 角色)
throw new Exception("不是这个角色的行动轮");
角色.临时攻 = 角色.攻;
角色.临时防 = 角色.防;
角色.临时速 = 角色.速;
角色.临时智 = 角色.智;
技能环境 技能环境 = createEnvironment(角色, teamA战场.己方角色List.Contains(角色), targetList);
if (角色.基础攻击技能 != null && 角色.基础攻击技能.Name == action)
{
角色.基础攻击技能.Excute(技能环境);
角色.行动点 -= 角色.基础攻击技能.消耗行动点;
}
if (角色.技能1 != null)
{
if (角色.技能1.Name == action)
{
角色.技能1.Excute(技能环境);
角色.行动点 -= 角色.技能1.消耗行动点;
}
else if (角色.技能1 is 准备技能)
{
准备技能 准备技能 = (准备技能)角色.技能1;
if (准备技能.准备后执行技能.Name == action)
{
准备技能.准备后执行技能.Excute(技能环境);
准备技能.准备技能目标List = null;
准备技能.准备后执行技能 = null;
}
}
}
if (角色.技能2 != null)
{
if (角色.技能2.Name == action)
{
角色.技能2.Excute(技能环境);
角色.行动点 -= 角色.技能2.消耗行动点;
}
else if (角色.技能2 is 准备技能)
{
准备技能 准备技能 = (准备技能)角色.技能2;
if (准备技能.准备后执行技能.Name == action)
{
准备技能.准备后执行技能.Excute(技能环境);
准备技能.准备技能目标List = null;
准备技能.准备后执行技能 = null;
}
}
}
if (角色.特殊技能 != null && 角色.特殊技能.Name == action)
{
if (角色.特殊技能 is 主动技能)
{
主动技能 技能 = (主动技能)角色.特殊技能;
技能.Excute(技能环境);
角色.行动点 -= 技能.消耗行动点;
}
}
if (action == "待机")
{
角色.待机.Excute(技能环境);
角色.行动点 -= 角色.待机.消耗行动点;
}
if (角色.行动点 < 0)
角色.行动点 = 0;
if (teamA战场.战果 > 常量.最大战果)
teamA战场.战果 = 常量.最大战果;
if (teamA战场.战果 < 常量.最小战果)
teamA战场.战果 = 常量.最小战果;
if (teamA战场.战场修正 > 常量.最大战场修正)
teamA战场.战场修正 = 常量.最大战场修正;
if (teamA战场.战场修正 < 常量.最小战场修正)
teamA战场.战场修正 = 常量.最小战场修正;
foreach (var 效果 in 角色.效果List.ToArray())
{
if (效果.持续类型 == 持续类型.一回合)
{
if (效果.回合数 == 0)
效果.回合数++;
else if (效果.回合数 == 1)
角色.效果List.Remove(效果);
}
}
if (角色.行动点 == 0)
角色.是否完结 = true;
if (teamA战场.当前回合 >= teamA战场.最大回合数)
{
teamA战场.当前回合 = teamA战场.最大回合数;
teamA战场.IsEnd = true;
}
foreach (var 效果 in 角色.效果List)
{
if (效果 is 自己回合结束效果)
{
自己回合结束效果 自己回合结束效果 = (自己回合结束效果)效果;
自己回合结束效果.Excute(角色, 技能环境);
}
}
bool isAllDead = true;
foreach (var item in teamA战场.己方角色List)
{
if (!item.是否败走)
{
isAllDead = false;
foreach (var 效果 in item.效果List)
{
if (效果 is 回合结束效果 && !(效果 is 自己回合结束效果))
{
回合结束效果 回合结束效果 = (回合结束效果)效果;
回合结束效果.Excute(item,技能环境);
}
}
break;
}
}
if (isAllDead)
teamA战场.IsEnd = true;
else
{
isAllDead = true;
foreach (var item in teamA战场.敌方角色List)
{
if (!item.是否败走)
{
isAllDead = false;
foreach (var 效果 in item.效果List)
{
if (效果 is 回合结束效果 && !(效果 is 自己回合结束效果))
{
回合结束效果 回合结束效果 = (回合结束效果)效果;
回合结束效果.Excute(item, 技能环境);
}
}
break;
}
}
if (isAllDead)
teamA战场.IsEnd = true;
}
技能环境.战场.当前回合++;
if (teamA战场.当前回合 >= teamA战场.最大回合数)
teamA战场.IsEnd = true;
if (teamA战场.行动顺序.List.Count == 0)
teamA战场.IsEnd = true;
if (!teamA战场.己方角色List.Contains(角色))
teamA战场.反转Save();
return 技能环境.ResultList;
}
public virtual decimal Get基础伤害(角色 角色1, 角色 角色2)
{
if (物理系)
return 角色1.实际兵力 * 角色1.兵种.攻 * 常量.物理伤害系数 * 伤害系数 / 10;
else
return 角色1.实际兵力 * 角色1.兵种.智 * 常量.法术伤害系数 * 伤害系数 / 10;
}
public virtual decimal Get兵种减伤(角色 角色,int 战场修正)
{
if (物理系)
return 常量.兵种减伤系数 / (常量.兵种减伤系数 + 角色.兵种.防 * (100 - 战场修正)/100);
else
return 常量.兵种减伤系数 / (常量.兵种减伤系数 + 角色.兵种.智 * (100 - 战场修正) / 100);
}
public abstract void Excute(角色 角色, 技能环境 环境);
public virtual int 单角色伤害结算(角色 角色1, 角色 角色2,bool 是否反击,int 战场修正)
{
var 基础伤害 = Get基础伤害(角色1, 角色2);
var 兵种减伤 = Get兵种减伤(角色2, 战场修正);
var 武将加成 = Get武将加成(角色1, 角色2);
int 伤害 = 计算最终伤害(基础伤害 * 兵种减伤 * 武将加成);
foreach (效果 效果 in 角色1.效果List.ToArray())
{
if (!(效果 is 伤害结算效果))
continue;
伤害结算效果 伤害结算效果 = (伤害结算效果)效果;
伤害 = 伤害结算效果.Excute(角色1, 角色2, 伤害, 是否反击);
if (伤害结算效果.持续类型 == 持续类型.一次)
角色1.效果List.Remove(伤害结算效果);
}
foreach (效果 效果 in 角色2.效果List.ToArray())
{
if (!(效果 is 被伤害结算效果))
continue;
被伤害结算效果 被伤害结算效果 = (被伤害结算效果)效果;
伤害 = 被伤害结算效果.Excute(角色1, 角色2, 伤害);
if (被伤害结算效果.持续类型 == 持续类型.一次)
角色2.效果List.Remove(被伤害结算效果);
}
return 伤害;
}
public virtual int 结算战果(int 伤害, 角色 角色)
{
var i1 = Convert.ToInt32(Convert.ToDecimal(伤害) / 角色.最大兵力 * 常量.战果系数);
var i2 = 0;
if (角色.是否败走)
i2 = 200;
return i1 + i2;
}
private void copy(角色 角色, UI角色 ui角色)
{
ui角色.败退 = 角色.是否败走;
ui角色.兵力 = 角色.兵力;
ui角色.攻赋予 = 角色.攻击赋予 != null;
ui角色.防赋予 = 角色.防御赋予 != null;
ui角色.速赋予 = 角色.速度赋予 != null;
ui角色.智赋予 = 角色.智力赋予 != null;
ui角色.行动点 = 角色.行动点;
ui角色.守护率 = 角色.守护率;
ui角色.全体守护率 = 角色.全体守护率;
ui角色.护盾 = 角色.护盾;
ui角色.准备 = 角色.是否准备;
}
private List<角色> get守护List(List<角色> list, 角色 角色)
{
List<角色> resultList = new List<角色>();
var temp = (from q in list
where q.守护率 > 0 &&
q.列 == 角色.列 &&
q != 角色
orderby q.排
select q);
resultList.AddRange(temp);
temp = (from q in list
where q.全体守护率 > 0 &&
q != 角色
orderby q.列 descending, q.排
select q);
resultList.AddRange(temp);
return resultList;
}
public abstract int Excute(角色 角色1, 角色 角色2, int 伤害);
public abstract int Excute(角色 角色1,角色 角色2,int 伤害,bool 是否反击);
