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(环境);
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<随机赋予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 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;
}
}
}
