public override IEnumerable <RunStatus> Execute(ITreeRoot context)
{
var root = context as AITreeRoot;
var message = root[AITreeRoot.ACTION_MESSAGE] as Proto.Action_ClickMapGround;
if (message == null)
{
yield return(RunStatus.Failure);
yield break;
}
root[AITreeRoot.ACTION_MESSAGE] = null;
var target = new UVector3(message.TargetPosition.x,
message.TargetPosition.y,
message.TargetPosition.z);
root.Character.View.MoveTo(target);
while (root.Character.View.IsMoving)
{
yield return(RunStatus.Running);
}
var time = root.Time;
if (time + 0.2f < root.Time)
{
yield return(RunStatus.Running);
}
root.Character.View.StopMove();
yield return(RunStatus.Success);
}
public override IEnumerable <RunStatus> Execute(ITreeRoot context)
{
if (DecoratedChild == null)
{
yield return(RunStatus.Failure);
yield break;
}
DecoratedChild.Start(context);
while (true)
{
DecoratedChild.Tick(context);
if (DecoratedChild.LastStatus.HasValue && DecoratedChild.LastStatus.Value == RunStatus.Running)
{
yield return(RunStatus.Running);
continue;
}
DecoratedChild.Stop(context);
if (DecoratedChild.LastStatus.HasValue && DecoratedChild.LastStatus.Value == RunStatus.Failure)
{
yield return(RunStatus.Failure);
yield break;
}
DecoratedChild.Start(context);
yield return(RunStatus.Running);
}
}
public RunStatus Tick(ITreeRoot context)
{
if (LastStatus.HasValue && LastStatus.Value != RunStatus.Running)
{
return(LastStatus.Value);
}
if (_current == null)
{
throw new Exception("You Must start it!");
}
if (_current.MoveNext())
{
LastStatus = _current.Current;
}
else
{
throw new Exception("Nothing to run? Somethings gone terribly, terribly wrong!");
}
if (LastStatus != RunStatus.Running)
{
Stop(context);
}
return(this.LastStatus.Value);
}
public override IEnumerable <BehaviorTree.RunStatus> Execute(ITreeRoot context)
{
if (DecoratedChild == null)
{
yield return(RunStatus.Failure);
yield break;
}
DecoratedChild.Start(context);
while (DecoratedChild.Tick(context) == RunStatus.Running)
{
yield return(RunStatus.Running);
}
DecoratedChild.Stop(context);
var last = DecoratedChild.LastStatus.Value;
if (last == RunStatus.Success)
{
yield return(RunStatus.Failure);
}
else
{
yield return(RunStatus.Success);
}
}
public override IEnumerable <RunStatus> Execute(ITreeRoot context)
{
foreach (Composite node in Children)
{
node.Start(context);
while (node.Tick(context) == RunStatus.Running)
{
//Selection = node;
yield return(RunStatus.Running);
}
//Selection = null;
node.Stop(context);
if (node.LastStatus == RunStatus.Failure)
{
yield return(RunStatus.Failure);
yield break;
}
}
yield return(RunStatus.Success);
yield break;
}
public override IEnumerable <RunStatus> Execute(ITreeRoot context)
{
var root = context as AITreeRoot;
var message = root[AITreeRoot.ACTION_MESSAGE] as Proto.Action_ClickSkillIndex;
if (message == null)
{
yield return(RunStatus.Failure);
yield break;
}
root[AITreeRoot.ACTION_MESSAGE] = null;
if (!root.Character.HasMagicKey(message.MagicKey))
{
yield return(RunStatus.Failure);
yield break;
}
var magic = root.Character.GetMagicByKey(message.MagicKey);
if (!root.Character.IsCoolDown(magic.ID, root.Time, false))
{
yield return(RunStatus.Failure);
yield break;
}
root[AITreeRoot.SELECT_MAGIC_ID] = magic.ID;
yield return(RunStatus.Success);
}
public override IEnumerable <BehaviorTree.RunStatus> Execute(ITreeRoot context)
{
float lastTime = context.Time;
while (true)
{
if (lastTime + (TickTime) >= context.Time)
{
yield return(BehaviorTree.RunStatus.Running);
}
lastTime = context.Time;
DecoratedChild.Start(context);
while (DecoratedChild.Tick(context) == RunStatus.Running)
{
yield return(RunStatus.Running);
}
DecoratedChild.Stop(context);
if (DecoratedChild.LastStatus.HasValue)
{
if (DecoratedChild.LastStatus.Value == RunStatus.Success)
{
yield return(BehaviorTree.RunStatus.Success);
yield break;
}
}
}
}
public override IEnumerable <RunStatus> Execute(ITreeRoot context)
{
//实现随机分布
var total = 0;
foreach (var i in PossibleBranches)
{
total += i.ChanceToExecute;
}
var rand = Randomizer.Next(total);
int current = 0;
for (var i = 0; i < PossibleBranches.Length; i++)
{
var before = current;
current += PossibleBranches[i].ChanceToExecute;
if (rand >= before && rand < current)
{
PossibleBranches[i].Branch.Start(context);
while (PossibleBranches[i].Branch.Tick(context) == RunStatus.Running)
{
yield return(RunStatus.Running);
}
PossibleBranches[i].Branch.Stop(context);
yield return(PossibleBranches[i].Branch.LastStatus.Value);
yield break;
}
}
yield return(RunStatus.Failure);
}
public override void Stop(ITreeRoot context)
{
base.Stop(context);
if (LastStatus == RunStatus.Running)
{
var root = context as AITreeRoot;
root.Character.View.StopMove();
}
}
public override void Stop(ITreeRoot context)
{
if (LastStatus.HasValue && LastStatus.Value == RunStatus.Running)
{
var root = context as AITreeRoot;
var per = root.Perception as BattlePerception;
per.CharacterStopMove(root.Character);
}
base.Stop(context);
}
public override IEnumerable <RunStatus> Execute(ITreeRoot context)
{
var root = context as AITreeRoot;
var index = root["TargetIndex"];
if (index == null)
{
yield return(RunStatus.Failure);
yield break;
}
var target = root.Perception.State[(int)index] as BattleCharacter;
if (target == null)
{
yield return(RunStatus.Failure);
yield break;
}
float distance;
if (!root.GetDistanceByValueType(Node.valueOf, Node.distance, out distance))
{
yield return(RunStatus.Failure);
yield break;
}
switch (Node.compareType)
{
case CompareType.Less:
if (root.Perception.Distance(target, root.Character) > distance)
{
yield return(RunStatus.Failure);
}
else
{
yield return(RunStatus.Success);
}
break;
case CompareType.Greater:
if (root.Perception.Distance(target, root.Character) > distance)
{
yield return(RunStatus.Success);
}
else
{
yield return(RunStatus.Failure);
}
break;
}
}
public override void Stop(ITreeRoot context)
{
base.Stop(context);
foreach (var i in PossibleBranches)
{
if (i.Branch.LastStatus == RunStatus.Running)
{
i.Branch.Stop(context);
}
}
}
public override void Stop(ITreeRoot context)
{
base.Stop(context);
foreach (var i in Children)
{
if (i.LastStatus.HasValue && i.LastStatus == RunStatus.Running)
{
i.Stop(context);
}
}
}
public override void Stop(ITreeRoot context)
{
if (LastStatus.HasValue && LastStatus.Value == RunStatus.Running)
{
if (!releaser.IsLayoutStartFinish)
{
releaser.StopAllPlayer();
}
releaser.SetState(ReleaserStates.ToComplete);
}
base.Stop(context);
}
public override IEnumerable <RunStatus> Execute(ITreeRoot context)
{
if (DecoratedChild == null)
{
yield return(RunStatus.Failure);
yield break;
}
context.Chanage(this.DecoratedChild);
yield return(RunStatus.Success);
}
public virtual void Stop(ITreeRoot context)
{
if (_current != null)
{
_current.Dispose();
_current = null;
}
if (LastStatus.HasValue && LastStatus.Value == RunStatus.Running)
{
Attach("failure", "block by other");
LastStatus = RunStatus.Failure;
}
}
public override IEnumerable <RunStatus> Execute(ITreeRoot context)
{
var root = context as AITreeRoot;
var character = root.Perception.GetSingleTargetUseRandom(root.Character);
if (character == null)
{
yield return(RunStatus.Failure);
yield break;
}
var target = character;
var per = root.Perception as BattlePerception;
var pos = target.View.Transform.position;
per.CharacterMoveTo(root.Character, pos);
var view = root.Character.View;
var last = root.Time;
while (root.Perception.Distance(target, root.Character) > 0f)
{
if ((root.Time - last) > 3 && UVector3.Distance(pos, target.View.Transform.position) > 1f)
{
per.CharacterMoveTo(root.Character, target.View.Transform.position);
pos = target.View.Transform.position;
}
if (!target.Enable)
{
per.CharacterStopMove(root.Character);
yield return(RunStatus.Failure);
yield break;
}
yield return(RunStatus.Running);
}
var time = root.Time;
if (time + 0.2f < root.Time)
{
yield return(RunStatus.Running);
}
per.CharacterStopMove(root.Character);
yield return(RunStatus.Success);
}
public override IEnumerable <RunStatus> Execute(ITreeRoot context)
{
var root = context as AITreeRoot;
var per = root.Perception as BattlePerception;
var distance = Node.distance;
if (!root.GetDistanceByValueType(Node.valueOf, distance, out distance))
{
yield return(RunStatus.Failure);
yield break;
}
UVector3 target;
var targetIndex = root[AITreeRoot.TRAGET_INDEX];
if (targetIndex == null)
{
yield return(RunStatus.Failure);
yield break;
}
var targetCharacter = root.Perception.State[(int)targetIndex] as BattleCharacter;
if (targetCharacter == null)
{
yield return(RunStatus.Failure);
yield break;
}
var noraml = (root.Character.View.Transform.position - targetCharacter.View.Transform.position).normalized;
target = noraml * distance + root.Character.View.Transform.position;
per.CharacterMoveTo(root.Character, target);
while ((root.Character.View.Transform.position - target).magnitude > 0.2f)
{
yield return(RunStatus.Running);
}
root.Character.View.StopMove();
yield return(RunStatus.Success);
}
public override IEnumerable <RunStatus> Execute(ITreeRoot context)
{
foreach (var i in Children)
{
i.Start(context);
}
var status = RunStatus.Running;
//如果没有为failure的返回
while (status == RunStatus.Running)
{
//默认执行完成
status = RunStatus.Success;
foreach (var i in Children)
{
//如果已经执行完跳过
if (i.LastStatus.HasValue && i.LastStatus.Value != RunStatus.Running)
{
continue;
}
//运行结束
if (i.Tick(context) != RunStatus.Running)
{
i.Stop(context);
if (i.LastStatus.Value == RunStatus.Failure)
{
status = RunStatus.Failure;
break;
}
}
else
{
status = RunStatus.Running;
}
}
yield return(status);
if (status != RunStatus.Running)
{
yield break;
}
}
yield return(status);
}
public override IEnumerable <BehaviorTree.RunStatus> Execute(ITreeRoot context)
{
float lastTime = context.Time;
while (true)
{
if (lastTime + (TickTime / 1000f) <= context.Time)
{
lastTime = context.Time;
DecoratedChild.Start(context);
while (DecoratedChild.Tick(context) == RunStatus.Running)
{
yield return(RunStatus.Running);
}
DecoratedChild.Stop(context);
}
yield return(BehaviorTree.RunStatus.Running);
}
}
public override IEnumerable <RunStatus> Execute(ITreeRoot context)
{
// Keep in mind; we ARE an enumerator here. So we do execute each child in tandem.
foreach (Composite node in Children)
{
// All behaviors are 'Decorators' by default. This just makes it simple.
// and allows us to not have another class that is nothing but a Decorator : Behavior
// Though; it may be a good idea in the future to add.
// Keep in mind!!!
// Start is called EVERY time we check a behavior! REGARDLESS OF IT'S RETURN VALUE!
// This makes sure we don't end up with a corrupted state that always returns 'Running'
// when it's actualled 'Success' or 'Failed'
node.Start(context);
// If the current node is still running; return so. Don't 'break' the enumerator
while (node.Tick(context) == RunStatus.Running)
{
//Selection = node;
yield return(RunStatus.Running);
}
// Clear the selection... since we don't have one! Duh.
//Selection = null;
// Call Stop to allow the node to cleanup anything. Since we don't need it anymore.
node.Stop(context);
// If it succeeded (since we're a selector) we return that this GroupNode
// succeeded in executing.
if (node.LastStatus == RunStatus.Success)
{
yield return(RunStatus.Success);
yield break;
}
// XXX - Removed. This would make us use an extra 'tick' just to get to the next child composite.
// Still running, so continue on!
//yield return RunStatus.Running;
}
// We ran out of children, and none succeeded. Return failed.
yield return(RunStatus.Failure);
// Make sure we tell our parent composite, that we're finished.
yield break;
}
public override IEnumerable <BehaviorTree.RunStatus> Execute(ITreeRoot context)
{
float Seconds = Node.seconds;
var root = context as AITreeRoot;
switch (Node.valueOf)
{
case WaitTimeValueOf.AttackSpeed:
{
Seconds = root.Character.AttackSpeed;
}
break;
}
float time = context.Time;
//var lastTime = time;
while (time + Seconds >= context.Time)
{
yield return(BehaviorTree.RunStatus.Running);
}
yield return(BehaviorTree.RunStatus.Success);
}
public override IEnumerable <RunStatus> Execute(ITreeRoot context)
{
var root = context as AITreeRoot;
var index = root[AITreeRoot.TRAGET_INDEX];
if (index == null)
{
yield return(RunStatus.Failure);
yield break;
}
var target = root.Perception.State[(int)index] as BattleCharacter;
if (target == null)
{
yield return(RunStatus.Failure);
yield break;
}
float stopDistance;
if (!root.GetDistanceByValueType(Node.valueOf, Node.distance, out stopDistance))
{
yield return(RunStatus.Failure);
yield break;
}
var per = root.Perception as BattlePerception;
//var offset = new GVector3(r);
//float lastTime = root.Time-2;
var pos = target.View.Transform.position;
per.CharacterMoveTo(root.Character, pos);
view = root.Character.View;
while (root.Perception.Distance(target, root.Character) > stopDistance)
{
if (UVector3.Distance(pos, target.View.Transform.position) > stopDistance)
{
per.CharacterMoveTo(root.Character, target.View.Transform.position);
pos = target.View.Transform.position;
}
if (!target.Enable)
{
per.CharacterStopMove(root.Character);
yield return(RunStatus.Failure);
yield break;
}
yield return(RunStatus.Running);
}
var time = root.Time;
if (time + 0.2f < root.Time)
{
yield return(RunStatus.Running);
}
per.CharacterStopMove(root.Character);
yield return(RunStatus.Success);
}
public override void Stop(ITreeRoot context)
{
base.Stop(context);
DecoratedChild.Stop(context);
}
public abstract override IEnumerable <RunStatus> Execute(ITreeRoot context);
public override IEnumerable <RunStatus> Execute(ITreeRoot context)
{
var root = context as AITreeRoot;
key = string.Empty;
var magics = root.Character.Magics;
if (magics == null || magics.Count == 0)
{
yield return(RunStatus.Failure);
yield break;
}
var list = new List <CharacterMagicData>();
foreach (var i in magics)
{
if (i.ReleaseType == (int)Proto.MagicReleaseType.NormalAttack)
{
if (root.Character.IsCoolDown(i.ID, root.Time, false))
{
list.Add(i);
}
}
}
if (list.Count == 0)
{
yield return(RunStatus.Failure);
yield break;
}
int result = -1;
switch (Node.resultType)
{
case MagicResultType.Random:
result = GRandomer.RandomList(list).ID;
break;
case MagicResultType.Frist:
result = list[0].ID;
break;
case MagicResultType.Sequence:
foreach (var i in list)
{
if (releaseHistorys.Contains(i.ID))
{
continue;
}
result = i.ID;
}
if (result == -1)
{
releaseHistorys.Clear();
result = list[0].ID;
}
releaseHistorys.Add(result);
break;
}
if (result == -1)
{
yield return(RunStatus.Failure);
yield break;
}
root[AITreeRoot.SELECT_MAGIC_ID] = result;
var config = ExcelToJSONConfigManager.Current.GetConfigByID <CharacterMagicData>(result);
if (config != null)
{
key = config.MagicKey;
}
yield return(RunStatus.Success);
}
public override IEnumerable <RunStatus> Execute(ITreeRoot context)
{
var root = context as AITreeRoot;
var index = root[AITreeRoot.TRAGET_INDEX];
if (index == null)
{
yield return(RunStatus.Failure);
yield break;
}
var target = root.Perception.State[(int)index] as BattleCharacter;
if (target == null)
{
yield return(RunStatus.Failure);
yield break;
}
string key = Node.magicKey;
switch (Node.valueOf)
{
case MagicValueOf.BlackBoard:
{
var id = root[AITreeRoot.SELECT_MAGIC_ID];
if (id == null)
{
yield return(RunStatus.Failure);
yield break;
}
var magicData = ExcelToJSONConfigManager.Current
.GetConfigByID <CharacterMagicData>((int)id);
key = magicData.MagicKey;
var attackSpeed = root.Character.AttackSpeed;
root.Character.AttachMagicHistory(magicData.ID, root.Time);
}
break;
case MagicValueOf.MagicKey:
{
key = Node.magicKey;
}
break;
}
if (!root.Perception.View.ExistMagicKey(key))
{
yield return(RunStatus.Failure);
yield break;
}
releaser = root.Perception.CreateReleaser(
key,
new ReleaseAtTarget(root.Character, target),
ReleaserType.Magic
);
var time = root.Time;
while (time + root.Character.AttackSpeed > root.Time)
{
yield return(RunStatus.Running);
}
yield return(RunStatus.Success);
}
public override IEnumerable <RunStatus> Execute(ITreeRoot context)
{
var root = context as AITreeRoot;
var per = root.Perception;
var targets = new List <BattleCharacter>();
float distance = Node.Distance;
if (!root.GetDistanceByValueType(Node.valueOf, distance, out distance))
{
yield return(RunStatus.Failure);
yield break;
}
per.State.Each <BattleCharacter>(t =>
{
switch (Node.teamType)
{
case TargetTeamType.Enemy:
if (t.TeamIndex == root.Character.TeamIndex)
{
return(false);
}
break;
case TargetTeamType.OwnTeam:
if (t.TeamIndex != root.Character.TeamIndex)
{
return(false);
}
break;
}
if (per.Distance(t, root.Character) <= distance)
{
targets.Add(t);
}
return(false);
});
int count = Node.compareValue;
switch (Node.compareType)
{
case CompareType.Greater:
if (count < targets.Count)
{
yield return(RunStatus.Success);
}
else
{
yield return(RunStatus.Failure);
}
break;
case CompareType.Less:
if (count > targets.Count)
{
yield return(RunStatus.Success);
}
else
{
yield return(RunStatus.Failure);
}
break;
}
yield break;
}
//public Composite Selection { get; protected set; }
public override void Start(ITreeRoot context)
{
base.Start(context);
}
public override IEnumerable <RunStatus> Execute(ITreeRoot context)
{
//state =LastStatus.HasValue? LastStatus.Value:RunStatus.Failure;
var character = context.UserState as BattleCharacter;
var per = character.Controllor.Perception as BattlePerception;
var root = context as AITreeRoot;
var list = new List <BattleCharacter>();
var distance = node.Distance;
if (!root.GetDistanceByValueType(node.valueOf, distance, out distance))
{
getDistanceValue = -1;
yield return(RunStatus.Failure);
yield break;
}
getDistanceValue = distance;
//是否保留之前目标
if (!node.findNew)
{
var older = root[AITreeRoot.TRAGET_INDEX];
if (older != null)
{
var targetCharacter = per.State[(int)older] as BattleCharacter;
if (targetCharacter != null)
{
if (per.Distance(targetCharacter, root.Character) <= distance)
{
yield return(RunStatus.Success);
yield break;
}
}
}
}
//清除
root[AITreeRoot.TRAGET_INDEX] = -1L;
var type = node.teamType;
//处理使用魔法目标
if (node.useMagicConfig)
{
var magicID = root[AITreeRoot.SELECT_MAGIC_ID];
if (magicID == null)
{
yield return(RunStatus.Failure);
yield break;
}
var data = ExcelToJSONConfigManager.Current.GetConfigByID <CharacterMagicData>((int)magicID);
if (data == null)
{
yield return(RunStatus.Failure);
yield break;
}
type = (TargetTeamType)data.ReleaseAITargetType;
}
per.State.Each <BattleCharacter>(t =>
{
//隐身的不进入目标查找
if (t.Lock.IsLock(ActionLockType.INHIDEN))
{
return(false);
}
switch (type)
{
case TargetTeamType.Enemy:
if (character.TeamIndex == t.TeamIndex)
{
return(false);
}
break;
case TargetTeamType.OwnTeam:
if (character.TeamIndex != t.TeamIndex)
{
return(false);
}
break;
case TargetTeamType.OwnTeamWithOutSelf:
if (character.Index == t.Index)
{
return(false);
}
if (character.TeamIndex != t.TeamIndex)
{
return(false);
}
break;
case TargetTeamType.Own:
{
if (character.Index != t.Index)
{
return(false);
}
}
break;
case TargetTeamType.ALL:
{
//all
}
break;
default:
return(false);
}
if (per.Distance(t, root.Character) > distance)
{
return(false);
}
switch (node.filter)
{
case TargetFilterType.Hurt:
if (t.HP == t.MaxHP)
{
return(false);
}
break;
}
list.Add(t);
return(false);
});
//getTargets = list.Count;
if (list.Count == 0)
{
yield return(RunStatus.Failure);
yield break;
}
BattleCharacter target = null;
switch (node.selectType)
{
case TargetSelectType.Nearest:
{
target = list[0];
var d = UVector3.Distance(target.View.Transform.position, character.View.Transform.position);
foreach (var i in list)
{
var temp = UVector3.Distance(i.View.Transform.position, character.View.Transform.position);
if (temp < d)
{
d = temp;
target = i;
}
}
}
break;
case TargetSelectType.Random:
target = GRandomer.RandomList(list);
break;
case TargetSelectType.HPMax:
{
target = list[0];
var d = target.HP;
foreach (var i in list)
{
var temp = i.HP;
if (temp > d)
{
d = temp;
target = i;
}
}
}
break;
case TargetSelectType.HPMin:
{
target = list[0];
var d = target.HP;
foreach (var i in list)
{
var temp = i.HP;
if (temp < d)
{
d = temp;
target = i;
}
}
}
break;
case TargetSelectType.HPRateMax:
{
target = list[0];
var d = (float)target.HP / (float)target.MaxHP;
foreach (var i in list)
{
var temp = (float)i.HP / (float)i.MaxHP;;
if (temp > d)
{
d = temp;
target = i;
}
}
}
break;
case TargetSelectType.HPRateMin:
{
target = list[0];
var d = (float)target.HP / (float)target.MaxHP;
foreach (var i in list)
{
var temp = (float)i.HP / (float)i.MaxHP;
if (temp < d)
{
d = temp;
target = i;
}
}
}
break;
}
index = target.Index;
root[AITreeRoot.TRAGET_INDEX] = target.Index;
yield return(RunStatus.Success);
}
