public virtual void Excute(技能环境 环境)
{
环境.施放者.是否准备 = false;
环境.战场.行动顺序.行动(环境.施放者, this);
环境.施放者.守护率 = 0;
环境.施放者.全体守护率 = 0;
}
public override void Excute(技能环境 环境)
{
base.Excute(环境);
foreach (var 角色 in 环境.目标List)
{
if (角色.守护率 > 0)
{
int value = 角色.守护率 > 50 ? 50 : 角色.守护率;
角色.守护率 -= value;
环境.ResultList.Add(new 守护结果()
{
技能 = this,
角色 = 环境.施放者,
角色2 = 角色,
守护率 = 0 - value,
全体守护率 = 0
});
}
else if (角色.全体守护率 > 0)
{
int value = 角色.全体守护率 > 30 ? 30 : 角色.全体守护率;
角色.全体守护率 -= value;
环境.ResultList.Add(new 守护结果()
{
技能 = this,
角色 = 环境.施放者,
角色2 = 角色,
守护率 = 0,
全体守护率 = 0 - value
});
}
}
}
public override void Excute(技能环境 环境)
{
foreach (var 角色 in 环境.目标List)
{
if (角色.守护率 > 0)
{
环境.ResultList.Add(new 守护结果()
{
技能 = this,
角色 = 环境.施放者,
角色2 = 角色,
守护率 = 0 - 角色.守护率,
全体守护率 = 0
});
角色.守护率 = 0;
}
else if (角色.全体守护率 > 0)
{
环境.ResultList.Add(new 守护结果()
{
技能 = this,
角色 = 环境.施放者,
角色2 = 角色,
守护率 = 0,
全体守护率 = 0 - 角色.全体守护率,
});
角色.全体守护率 = 0;
}
}
}
public override void Excute(技能环境 环境)
{
环境.施放者.准备技能 = 准备后执行技能;
准备后执行技能.准备技能目标List = 环境.目标List;
环境.施放者.守护率 = 0;
环境.施放者.全体守护率 = 0;
环境.施放者.是否准备 = true;
环境.战场.行动顺序.行动(环境.施放者, this);
}
public override void Excute(技能环境 环境)
{
base.Excute(环境);
环境.战场.当前回合 += 回合数;
环境.ResultList.Add(new 消耗回合结果()
{
技能 = this,
角色 = 环境.施放者,
回合数 = 回合数
});
}
public override void Excute(技能环境 环境)
{
base.Excute(环境);
环境.战场.战果 += Convert.ToInt32(环境.施放者.实际智 * 基数);
环境.ResultList.Add(new 战果结果()
{
技能 = this,
角色 = 环境.施放者,
战果 = Convert.ToInt32(环境.施放者.实际智 * 基数)
});
}
public override void Excute(技能环境 环境)
{
base.Excute(环境);
环境.施放者.护盾 = true;
环境.ResultList.Add(new 护盾结果()
{
技能 = this,
角色1 = 环境.施放者,
角色2 = 环境.施放者,
});
}
public override void Excute(技能环境 环境)
{
base.Excute(环境);
var temp = 常量.最大战场修正 - 环境.战场.战场修正;
temp = temp > 基数 ? 基数 : temp;
环境.战场.战场修正 += temp;
环境.ResultList.Add(new 战场修正结果()
{
技能 = this,
角色 = 环境.施放者,
战场修正 = temp
});
}
public override void Excute(技能环境 环境)
{
环境.施放者.守护率 = 120;
环境.ResultList.Add(new 守护结果()
{
技能 = this,
角色 = 环境.施放者,
守护率 = 120,
全体守护率 = 0 - 环境.施放者.全体守护率
});
环境.施放者.全体守护率 = 0;
}
public override void Excute(技能环境 环境)
{
foreach (var 角色 in 环境.目标List)
{
角色.护盾 = true;
环境.ResultList.Add(new 护盾结果()
{
技能 = this,
角色1 = 环境.施放者,
角色2 = 角色,
});
}
}
public override void Excute(技能环境 环境)
{
var 赋予 = new 赋予()
{
Level = Level,
是否单回合 = false
};
环境.施放者.攻击赋予 = 赋予;
环境.施放者.防御赋予 = 赋予;
环境.施放者.速度赋予 = 赋予;
环境.施放者.智力赋予 = 赋予;
环境.ResultList.Add(new 赋予结果()
{
赋予 = 赋予,
技能 = this,
Type = "攻击",
角色1 = 环境.施放者,
角色2 = 环境.施放者,
});
环境.ResultList.Add(new 赋予结果()
{
赋予 = 赋予,
技能 = this,
Type = "防御",
角色1 = 环境.施放者,
角色2 = 环境.施放者,
});
环境.ResultList.Add(new 赋予结果()
{
赋予 = 赋予,
技能 = this,
Type = "速度",
角色1 = 环境.施放者,
角色2 = 环境.施放者,
});
环境.ResultList.Add(new 赋予结果()
{
赋予 = 赋予,
技能 = this,
Type = "智力",
角色1 = 环境.施放者,
角色2 = 环境.施放者,
});
}
public override void Excute(技能环境 环境)
{
base.Excute(环境);
int value = 环境.目标List[0].最大行动点 - 环境.目标List[0].行动点;
value = value > 1 ? 1 : value;
环境.目标List[0].行动点 += value;
环境.ResultList.Add(new 行动点结果()
{
技能 = this,
角色1 = 环境.施放者,
角色2 = 环境.目标List[0],
行动点 = value,
});
}
public override void Excute(技能环境 环境)
{
int 回复量 = Convert.ToInt32(环境.施放者.兵力 * 0.5m + 环境.施放者.实际智 * 12);
var 角色 = 环境.目标List[0];
var temp = 环境.施放者.最大兵力 - 环境.施放者.兵力;
if (temp > 回复量)
temp = 回复量;
环境.施放者.兵力 += temp;
环境.ResultList.Add(new 回复结果()
{
角色1 = 环境.施放者,
角色2 = 角色,
技能 = this,
回复量 = temp
});
}
public override void Excute(技能环境 环境)
{
foreach (var 角色 in 环境.目标List)
{
int value = 角色.最大行动点 - 角色.行动点;
value = value > 1 ? 1 : value;
环境.目标List[0].行动点 += value;
环境.ResultList.Add(new 行动点结果()
{
技能 = this,
角色1 = 环境.施放者,
角色2 = 角色,
行动点 = value,
});
}
}
public override void Excute(技能环境 环境)
{
base.Excute(环境);
var 赋予 = new 赋予()
{
Level = Level,
是否单回合 = true
};
环境.施放者.攻击赋予 = 赋予;
环境.ResultList.Add(new 赋予结果()
{
赋予 = 赋予,
技能 = this,
Type = "攻击",
角色1 = 环境.施放者,
角色2 = 环境.施放者,
});
}
public override void Excute(技能环境 环境)
{
if (Roll.Hit(50))
{
var 赋予 = new 赋予()
{
Level = 2,
是否单回合 = false
};
环境.施放者.速度赋予 = 赋予;
环境.ResultList.Add(new 赋予结果()
{
赋予 = 赋予,
技能 = this,
Type = "速度",
角色1 = 环境.施放者,
角色2 = 环境.施放者,
});
}
}
public override void Excute(角色 角色 ,技能环境 环境)
{
if (角色.兵力 * 100 / 角色.最大兵力 < 50)
{
var 赋予 = new 赋予()
{
Level = 3,
是否单回合 = false
};
角色.防御赋予 = 赋予;
环境.ResultList.Add(new 赋予结果()
{
赋予 = 赋予,
技能 = new 团结力(),
Type = "防御",
角色1 = 角色,
角色2 = 角色,
});
}
}
public override void Excute(技能环境 环境)
{
foreach (var 角色 in 环境.战场.己方角色List)
{
var 赋予 = new 赋予()
{
Level = 1,
是否单回合 = false
};
角色.智力赋予 = 赋予;
环境.ResultList.Add(new 赋予结果()
{
赋予 = 赋予,
技能 = this,
Type = "智力",
角色1 = 环境.施放者,
角色2 = 角色,
});
}
}
public override void Excute(技能环境 环境)
{
List<int> list = new List<int>();
int maxItem = 环境.战场.己方角色List.Count;
maxItem = maxItem > 环境.施放者.智/3 ? 环境.施放者.智/3 : maxItem;
Random r = new Random(DateTime.Now.Millisecond);
for (int i = 0; i < maxItem; i++)
{
int index = r.Next(maxItem);
while(list.Contains(index))
index = r.Next(maxItem);
list.Add(index);
}
foreach (var item in list)
{
角色 角色 = 环境.战场.己方角色List[item];
赋予 赋予 = null;
角色.Add(new 自动回复效果());
}
}
public override void Excute(技能环境 环境)
{
base.Excute(环境);
List<int> list = new List<int>();
int maxItem = 4;
int value = 环境.施放者.智 / 2;
maxItem = maxItem > value ? value : maxItem;
Random r = new Random(DateTime.Now.Millisecond);
for (int i = 0; i < maxItem; i++)
{
int index = r.Next(4);
while (list.Contains(index))
index = r.Next(4);
list.Add(index);
}
foreach (var item in list)
{
赋予 赋予 = null;
switch (item)
{
case 0:
赋予 = new 赋予()
{
Level = Level,
是否单回合 = false
};
环境.目标List[0].攻击赋予 = 赋予;
环境.ResultList.Add(new 赋予结果()
{
赋予 = 赋予,
技能 = this,
Type = "攻击",
角色1 = 环境.施放者,
角色2 = 环境.目标List[0],
});
break;
case 1:
赋予 = new 赋予()
{
Level = Level,
是否单回合 = false
};
环境.目标List[0].防御赋予 = 赋予;
环境.ResultList.Add(new 赋予结果()
{
赋予 = 赋予,
技能 = this,
Type = "防御",
角色1 = 环境.施放者,
角色2 = 环境.目标List[0],
});
break;
case 2:
赋予 = new 赋予()
{
Level = Level,
是否单回合 = false
};
环境.目标List[0].速度赋予 = 赋予;
环境.ResultList.Add(new 赋予结果()
{
赋予 = 赋予,
技能 = this,
Type = "速度",
角色1 = 环境.施放者,
角色2 = 环境.目标List[0],
});
break;
case 3:
赋予 = new 赋予()
{
Level = Level,
是否单回合 = false
};
环境.目标List[0].智力赋予 = 赋予;
环境.ResultList.Add(new 赋予结果()
{
赋予 = 赋予,
技能 = this,
Type = "智力",
角色1 = 环境.施放者,
角色2 = 环境.目标List[0],
});
break;
}
}
}
private 技能环境 createEnvironment(角色 施法者, bool isTeamA, List<角色> targetList)
{
技能环境 技能环境 = new 技能环境()
{
施放者 = 施法者,
目标List = targetList,
IsTeamA = isTeamA,
战场 = isTeamA ? teamA战场 : teamA战场.反转()
};
return 技能环境;
}
public override void Excute(技能环境 环境)
{
环境.战场.最大回合数 -= 5;
}
public abstract void Excute(技能环境 环境);
public override void Excute(技能环境 环境)
{
环境.战场.最大回合数 += 10;
}
public override void Excute(技能环境 环境)
{
List<随机赋予Item> list = new List<随机赋予Item>();
int maxItem = 环境.战场.己方角色List.Count * 4;
maxItem = maxItem > 环境.施放者.智 + 2 ? 环境.施放者.智 + 2 : maxItem;
for (int i = 0; i < maxItem; i++)
{
随机赋予Item item = newItem(环境.战场.己方角色List.Count,list);
list.Add(item);
}
foreach (var item in list)
{
角色 角色 = 环境.战场.己方角色List[item.角色Index];
赋予 赋予 = null;
switch (item.赋予Index)
{
case 0:
赋予 = new 赋予()
{
Level = 1,
是否单回合 = false
};
角色.攻击赋予 = 赋予;
环境.ResultList.Add(new 赋予结果()
{
赋予 = 赋予,
技能 = this,
Type = "攻击",
角色1 = 环境.施放者,
角色2 = 角色,
});
break;
case 1:
赋予 = new 赋予()
{
Level = 1,
是否单回合 = false
};
角色.防御赋予 = 赋予;
环境.ResultList.Add(new 赋予结果()
{
赋予 = 赋予,
技能 = this,
Type = "防御",
角色1 = 环境.施放者,
角色2 = 角色,
});
break;
case 2:
赋予 = new 赋予()
{
Level = 1,
是否单回合 = false
};
角色.速度赋予 = 赋予;
环境.ResultList.Add(new 赋予结果()
{
赋予 = 赋予,
技能 = this,
Type = "速度",
角色1 = 环境.施放者,
角色2 = 角色,
});
break;
case 3:
赋予 = new 赋予()
{
Level = 1,
是否单回合 = false
};
角色.智力赋予 = 赋予;
环境.ResultList.Add(new 赋予结果()
{
赋予 = 赋予,
技能 = this,
Type = "智力",
角色1 = 环境.施放者,
角色2 = 角色,
});
break;
}
}
}
public abstract void Excute(角色 角色, 技能环境 环境);
public override void Excute(技能环境 环境)
{
环境.施放者.效果List.Add(new 团结力效果());
}
public override void Excute(技能环境 环境)
{
环境.施放者.是否准备 = false;
环境.战场.行动顺序.行动(环境.施放者, this);
}
public override void Excute(技能环境 环境)
{
int 回复量 = Convert.ToInt32(环境.施放者.兵力 * 兵力系数 + 环境.施放者.实际智 * 8);
foreach (var 角色 in 环境.目标List)
{
var temp = 环境.施放者.最大兵力 - 环境.施放者.兵力;
if (temp > 回复量)
temp = 回复量;
环境.施放者.兵力 += temp;
环境.ResultList.Add(new 回复结果()
{
角色1 = 环境.施放者,
角色2 = 角色,
技能 = this,
回复量 = temp
});
}
}
public override void Excute(技能环境 环境)
{
base.Excute(环境);
var total战果 = 0;
foreach (var target in 环境.目标List)
{
if (target.是否败走)
continue;
攻击结果 攻击结果 = new Battle.攻击结果()
{
角色1 = 环境.施放者,
角色2 = target,
攻击技能 = this,
};
环境.ResultList.Add(攻击结果);
var 目标 = target;
if (this.可被守护)
{
var 守护List = get守护List(环境.战场.敌方角色List, target);
foreach (var 守护者 in 守护List)
{
if (守护者.守护率 > 0)
{
if (Roll.Hit(守护者.守护率))
{
目标 = 守护者;
守护者.守护率 -= 40;
if (守护者.守护率 < 0)
守护者.守护率 = 0;
攻击结果.守护角色 = 守护者;
break;
}
}
else
{
if (Roll.Hit(守护者.全体守护率))
{
目标 = 守护者;
守护者.全体守护率 -= 40;
if (守护者.全体守护率 < 0)
守护者.全体守护率 = 0;
攻击结果.守护角色 = 守护者;
break;
}
}
}
}
//结算主动攻击
var 伤害 = 单角色伤害结算(环境.施放者, target,false,环境.战场.战场修正);
if (目标.兵力 < 伤害)
伤害 = 目标.兵力;
攻击结果.伤害 = 伤害;
if (目标.护盾)
{
伤害 = 0;
目标.护盾 = false;
攻击结果.是否被护盾抵挡 = true;
}
if (目标.兵力 <= 伤害)
{
目标.是否败走 = true;
攻击结果.是否败退 = true;
}
var 战果 = 结算战果(伤害, 目标);
total战果 += 战果;
攻击结果.战果 = 战果;
//结算打断
if (target.准备技能 != null)
{
if (Roll.Hit(打断系数))
{
环境.战场.行动顺序.打断(target);
攻击结果.是否打断 = true;
}
}
//结算反击
else if (this.能否被反击 && 目标.兵种.能否反击)
{
反击结果 反击结果 = new Battle.反击结果()
{
角色1 = 目标,
角色2 = 环境.施放者,
};
环境.ResultList.Add(反击结果);
攻击技能 反击 = new 攻击技能();
var 反击伤害 = Convert.ToInt32(反击.单角色伤害结算(目标, 环境.施放者, true, 环境.战场.战场修正) * 常量.反击比率);
if (环境.施放者.兵力 < 反击伤害)
反击伤害 = 环境.施放者.兵力;
反击结果.伤害 = 反击伤害;
if (环境.施放者.护盾)
{
反击伤害 = 0;
环境.施放者.护盾 = false;
反击结果.是否被护盾抵挡 = true;
}
战果 = 反击.结算战果(反击伤害, 环境.施放者);
total战果 -= 战果;
反击结果.战果 = 战果;
环境.施放者.兵力 -= 反击伤害;
if (环境.施放者.兵力 == 0)
{
环境.施放者.是否败走 = true;
反击结果.是否败退 = true;
break;
}
}
目标.兵力 -= 伤害;
}
环境.战场.战果 += total战果;
}
