public override void Run(Combat.Character character)
{
Int32 time = EvaluationHelper.AsInt32(character, Time, 1);
Int32 target_id = EvaluationHelper.AsInt32(character, TargetId, Int32.MinValue);
Vector2 offset = EvaluationHelper.AsVector2(character, Position, new Vector2(0, 0));
foreach (Combat.Character target in character.GetTargets(target_id))
{
switch (BindPosition)
{
case BindToTargetPostion.Mid:
offset += target.BasePlayer.Constants.Midposition;
break;
case BindToTargetPostion.Head:
offset += target.BasePlayer.Constants.Headposition;
break;
case BindToTargetPostion.None:
case BindToTargetPostion.Foot:
default:
break;
}
character.Bind.Set(target, offset, time, 0, false);
break;
}
}
public override void Run(Combat.Character character)
{
var amount = EvaluationHelper.AsInt32(character, Amount, null);
var targetId = EvaluationHelper.AsInt32(character, TargetId, int.MinValue);
var cankill = EvaluationHelper.AsBoolean(character, CanKill, true);
var absolute = EvaluationHelper.AsBoolean(character, Absolute, false);
if (amount == null)
{
return;
}
foreach (var target in character.GetTargets(targetId))
{
var newamount = amount.Value;
if (absolute == false && newamount < 0)
{
newamount = (int)(newamount * character.OffensiveInfo.AttackMultiplier);
newamount = (int)(newamount / target.DefensiveInfo.DefenseMultiplier);
}
target.Life += newamount;
if (target.Life == 0 && cankill == false)
{
target.Life = 1;
}
}
}
public override void Run(Combat.Character character)
{
var time = EvaluationHelper.AsInt32(character, Time, 1);
var targetId = EvaluationHelper.AsInt32(character, TargetId, int.MinValue);
var position = EvaluationHelper.AsVector2(character, Position, new Vector2(0, 0));
foreach (var target in character.GetTargets(targetId))
{
target.Bind.Set(character, position, time, 0, true);
}
}
public override void Run(Combat.Character character)
{
var amount = EvaluationHelper.AsInt32(character, Amount, null);
var targetId = EvaluationHelper.AsInt32(character, TargetId, int.MinValue);
if (amount == null)
{
return;
}
foreach (var target in character.GetTargets(targetId))
{
target.BasePlayer.Power += amount.Value;
}
}
public override void Run(Combat.Character character)
{
Int32?statenumber = EvaluationHelper.AsInt32(character, StateNumber, null);
Int32 target_id = EvaluationHelper.AsInt32(character, TargetId, Int32.MinValue);
if (statenumber == null)
{
return;
}
foreach (Combat.Character target in character.GetTargets(target_id))
{
target.StateManager.ForeignManager = character.StateManager;
target.StateManager.ChangeState(statenumber.Value);
}
}
public override void Run(Combat.Character character)
{
Int32 exclude_id = EvaluationHelper.AsInt32(character, Id, -1);
Boolean keepone = EvaluationHelper.AsBoolean(character, KeepOne, true);
List <Combat.Character> removelist = new List <Combat.Character>();
foreach (Combat.Character target in character.GetTargets(Int32.MinValue))
{
if (exclude_id != -1 && target.DefensiveInfo.HitDef.TargetId == exclude_id)
{
continue;
}
removelist.Add(target);
}
if (removelist.Count > 0 && keepone == true)
{
removelist.RemoveAt(0);
}
foreach (Combat.Character target in removelist)
{
character.OffensiveInfo.TargetList.Remove(target);
}
/*
* Boolean keptone = false;
* foreach (Combat.Entity entity in character.Engine.Entities)
* {
* Combat.Character target = character.FilterEntityAsTarget(entity, Int32.MinValue);
* if (target == null) continue;
*
* if (exclude_id != -1 && target.DefensiveInfo.HitDef.TargetId == exclude_id) continue;
*
* if (keptone == false)
* {
* keptone = true;
* continue;
* }
*
* character.OffensiveInfo.TargetList.Remove(target);
* }
*/
}
public override void Run(Combat.Character character)
{
Int32 facing = EvaluationHelper.AsInt32(character, Facing, 0);
Int32 target_id = EvaluationHelper.AsInt32(character, TargetId, Int32.MinValue);
foreach (Combat.Character target in character.GetTargets(target_id))
{
if (facing > 0)
{
target.CurrentFacing = character.CurrentFacing;
}
else if (facing < 0)
{
target.CurrentFacing = Misc.FlipFacing(character.CurrentFacing);
}
}
}
public static Object RedirectState(Object state, ref Boolean error, Int32 target_id)
{
Combat.Character character = state as Combat.Character;
if (character == null)
{
error = true;
return(null);
}
foreach (Combat.Character target in character.GetTargets(target_id))
{
return(target);
}
error = true;
return(null);
}
public static Int32 Evaluate(Object state, ref Boolean error, Int32 target_id)
{
Combat.Character character = state as Combat.Character;
if (character == null)
{
error = true;
return(0);
}
Int32 count = 0;
foreach (Combat.Character target in character.GetTargets(target_id))
{
++count;
}
return(count);
}
public override void Run(Combat.Character character)
{
Single?x = EvaluationHelper.AsSingle(character, X, null);
Single?y = EvaluationHelper.AsSingle(character, Y, null);
Int32 target_id = EvaluationHelper.AsInt32(character, TargetId, Int32.MinValue);
foreach (Combat.Character target in character.GetTargets(target_id))
{
Vector2 velocity = new Vector2(0, 0);
if (x != null)
{
velocity.X = x.Value;
}
if (y != null)
{
velocity.Y = y.Value;
}
target.CurrentVelocity += velocity;
}
}
public override void Run(Combat.Character character)
{
var x = EvaluationHelper.AsSingle(character, X, null);
var y = EvaluationHelper.AsSingle(character, Y, null);
var targetId = EvaluationHelper.AsInt32(character, TargetId, int.MinValue);
foreach (var target in character.GetTargets(targetId))
{
var velocity = target.CurrentVelocity;
if (x != null)
{
velocity.X = x.Value;
}
if (y != null)
{
velocity.Y = y.Value;
}
target.CurrentVelocity = velocity;
}
}
