public BattleCharacter CreateCharacter(
int level,
CharacterData data,
List <CharacterMagicData> magics,
int teamIndex,
UVector3 position,
UVector3 forward, long userID)
{
var res = data.ResourcesPath;
var view = View.CreateBattleCharacterView(res, position, forward);
var battleCharacter = new BattleCharacter(data.ID, magics, this.BattleCharacterControllor, view, userID);
battleCharacter[HeroPropertyType.MaxHP].SetBaseValue(data.HPMax);
battleCharacter[HeroPropertyType.MaxMP].SetBaseValue(data.MPMax);
battleCharacter[HeroPropertyType.Defance].SetBaseValue(data.Defance);
battleCharacter[HeroPropertyType.DamageMin].SetBaseValue(data.DamageMin);
battleCharacter[HeroPropertyType.DamageMax].SetBaseValue(data.DamageMax);
battleCharacter[HeroPropertyType.Agility].SetBaseValue(data.Agility + (int)(level * data.AgilityGrowth));
battleCharacter[HeroPropertyType.Force].SetBaseValue(data.Force + (int)(level * data.ForceGrowth));
battleCharacter[HeroPropertyType.Knowledge].SetBaseValue(data.Knowledge + (int)(level * data.KnowledgeGrowth));
battleCharacter[HeroPropertyType.MagicWaitTime].SetBaseValue((int)(data.AttackSpeed * 1000));
battleCharacter[HeroPropertyType.ViewDistance].SetBaseValue((int)(data.ViewDistance * 100));
battleCharacter.Level = level;
battleCharacter.TDamage = (Proto.DamageType)data.DamageType;
battleCharacter.TDefance = (DefanceType)data.DefanceType;
battleCharacter.Category = (HeroCategory)data.Category;
battleCharacter.Name = data.Name;
battleCharacter.TeamIndex = teamIndex;
battleCharacter.Speed = data.MoveSpeed;
view.SetPriorityMove(data.PriorityMove);
battleCharacter.Init();
this.JoinElement(battleCharacter);
return(battleCharacter);
}
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);
}
void IBattleCharacter.MoveTo(UVector3 position)
{
if (!Agent || !Agent.enabled)
{
return;
}
IsStop = false;
this.Agent.Resume();
var pos = position.ToUVer3();
UnityEngine.AI.NavMeshHit hit;
if (UnityEngine.AI.NavMesh.SamplePosition(pos, out hit, 10000, this.Agent.areaMask))
{
targetPos = hit.position;
}
else
{
return;
}
if (Vector3.Distance(targetPos.Value, this.transform.position) < 0.2f)
{
stopMove();
return;
}
this.Agent.SetDestination(targetPos.Value);
}
public static Vector3ShortIndex ToSV3(this UVector3 v3)
{
return(new Vector3ShortIndex()
{
x = (byte)v3.x, y = (byte)v3.y, z = (byte)v3.z
});
}
void IBattleCharacter.SetForward(UVector3 forward)
{
var v = forward;
v.Normalized();
transform.forward = v;
}
public void SetWorldSize(Vector3 center, Vector3 extents, UVector3 div)
{
world_center = center;
world_extents = extents;
div.x = MSB(div.x);
div.y = MSB(div.y);
div.z = MSB(div.z);
world_div_bits.x = (int)div.x;
world_div_bits.y = (int)div.y;
world_div_bits.z = (int)div.z;
world_div.x = (int)(1U << (int)div.x);
world_div.y = (int)(1U << (int)div.y);
world_div.z = (int)(1U << (int)div.z);
world_div_shift.x = 1U;
world_div_shift.y = 1U << (int)(div.x);
world_div_shift.z = 1U << (int)(div.x + div.y);
world_cellsize = new Vector3(
world_extents.x * 2.0f / world_div.x,
world_extents.y * 2.0f / world_div.y,
world_extents.z * 2.0f / world_div.z);
rcp_world_cellsize = new Vector3(
1.0f / world_cellsize.x,
1.0f / world_cellsize.y,
1.0f / world_cellsize.z);
}
internal void CharacterMoveTo(BattleCharacter character, UVector3 pos)
{
if (character.Lock.IsLock(ActionLockType.NOMOVE))
{
return;
}
character.View.MoveTo(pos);
}
public BattleCharactorView(UVector3 pos,
UVector3 forword, BattlePerceptionView view,
Pathfinder pathfiner) : base(view)
{
transform = new UTransform();
transform.position = pos;
transform.forward = forword;
Finder = pathfiner;
//lastPost = pos.ToVector3();
}
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 GAction GetAction(GTime time, GObject current)
{
//var per = this.Perception as BattlePerception;
var missile = current as BattleMissile;
switch (missile.State)
{
case MissileState.NoStart:
{
var distance = UVector3.Distance(
missile.Releaser.ReleaserTarget.Releaser.View.Transform.position,
missile.Releaser.ReleaserTarget.ReleaserTarget.View.Transform.position);
missile.TotalTime = distance / missile.Layout.speed;
missile.TimeStart = time.Time;
missile.State = MissileState.Moving;
missile.Releaser.OnEvent(Layout.EventType.EVENT_MISSILE_CREATE);
}
break;
case MissileState.Moving:
{
if ((time.Time - missile.TimeStart) >= missile.TotalTime)
{
missile.Releaser.OnEvent(Layout.EventType.EVENT_MISSILE_HIT);
missile.State = MissileState.Hit;
}
}
break;
case MissileState.Hit:
{
missile.Releaser.OnEvent(Layout.EventType.EVENT_MISSILE_DEAD);
missile.State = MissileState.Death;
}
break;
case MissileState.Death:
GObject.Destory(missile);
break;
}
return(GAction.Empty);
}
IBattleCharacter IBattlePerception.CreateBattleCharacterView(string resources, UVector3 pos, UVector3 forward)
{
var character = ResourcesManager.Singleton.LoadResourcesWithExName <GameObject> (resources);
var tPos = new Vector3(pos.x, pos.y, pos.z);
var qu = Quaternion.Euler(forward.x, forward.y, forward.z);
var ins = GameObject.Instantiate(character) as GameObject;
var root = new GameObject(resources);
root.transform.SetParent(this.transform, false);
root.transform.position = tPos;
root.transform.rotation = Quaternion.identity;
ins.transform.parent = root.transform;
ins.transform.localPosition = Vector3.zero;
ins.transform.localRotation = Quaternion.identity;
ins.name = "Character";
var view = root.AddComponent <UCharacterView> ();
view.targetLookQuaternion = qu;
view.SetCharacter(ins);
return(view);
}
void IBattleCharacter.MoveTo(UVector3 position)
{
//_findStarted = DateTime.Now;
isMoving = true;
nextWaypoint = 0;
lastWaypoint = 0;
finalWaypoint = 0;
syncIndex = 0;
CurrentPath = null;
var pos = this.transform.position;
var nodeStart = Finder.WorldPosToNode(pos.x, 0, pos.z);
var nodeEnd = Finder.WorldPosToNode(position.x, 0, position.z);
var path = Finder.FindPathActual(nodeStart, nodeEnd);
if (path != null && path.Count > 0)
{
CurrentPath = path.Select(t => GetNodeVer(t)).ToList();
if (CurrentPath.Count > 0)
{
CurrentPath.RemoveAt(0);
CurrentPath.Insert(0, this.transform.position);
}
finalWaypoint = CurrentPath.Count - 1;
nextWaypoint = 1;
lastWaypoint = 0;
faction_of_path_traveled = 0;
isMoving = true;
}
else
{
CurrentPath = null;
isMoving = false;
//this.SetPosition(position);
}
}
private static UnityEngine.AnimationClip Convert(Clip animation, FrameContainer frames,
out UVector3 rootStart, out UVector3 rootEnd)
{
var clip = new UnityEngine.AnimationClip();
clip.legacy = true;
var rotateAxes = new[] {
new { Name = "x", Mask = new UVector4(1f, 0f, 0f, 0f) },
new { Name = "y", Mask = new UVector4(0f, 1f, 0f, 0f) },
new { Name = "z", Mask = new UVector4(0f, 0f, 1f, 0f) },
new { Name = "w", Mask = new UVector4(0f, 0f, 0f, 1f) }
};
var translateAxes = new[] {
new { Name = "x", Mask = new UVector3(1f, 0f, 0f) },
new { Name = "y", Mask = new UVector3(0f, 1f, 0f) },
new { Name = "z", Mask = new UVector3(0f, 0f, 1f) },
};
var root = animation.Bones.FirstOrDefault(x => x.BoneId == 0);
if (root != null && root.FrameCount > 0)
{
rootStart = Types.Convert(root.Frames.First().Translation);
rootEnd = Types.Convert(root.Frames.Last().Translation);
}
else
{
rootStart = rootEnd = UVector3.zero;
}
foreach (var bone in animation.Bones)
{
var bFrames = bone.Frames;
var frame = frames.GetByBoneId(bone.BoneId);
string bonePath = frame.Path;
var axisAngle = bFrames.ToDictionary(x => x, x =>
{
var q = Types.Convert(x.Rotation);
float ang; UnityEngine.Vector3 axis;
q.ToAngleAxis(out ang, out axis);
return(new UVector4(q.x, q.y, q.z, q.w));
});
foreach (var axis in rotateAxes)
{
var keys = bFrames
.Select(x => new Keyframe(x.Time * TimeScale,
UVector4.Dot(axisAngle[x], axis.Mask)))
.ToArray();
clip.SetCurve(bonePath, typeof(Transform), "localRotation." + axis.Name,
new UnityEngine.AnimationCurve(keys));
}
var converted = bFrames.Select(x => Types.Convert(x.Translation)).ToArray();
if (!converted.Any(x => !x.Equals(UVector3.zero)))
{
continue;
}
var anyVelocities = false;
var deltaVals = converted.Select((x, i) =>
{
var prev = Math.Max(0, i - 1);
var next = Math.Min(i + 1, converted.Length - 1);
var prevTime = bFrames[prev].Time * TimeScale;
var nextTime = bFrames[next].Time * TimeScale;
return(prevTime == nextTime || !(anyVelocities = true) ? UVector3.zero
: (converted[next] - converted[prev]) / (nextTime - prevTime));
}).ToArray();
foreach (var translateAxis in translateAxes)
{
var positions = bFrames
.Select((x, i) => new Keyframe(x.Time * TimeScale,
UVector3.Dot(frame.transform.localPosition + converted[i], translateAxis.Mask)))
.ToArray();
var deltas = bFrames.Select((x, i) => new Keyframe(x.Time * TimeScale,
UVector3.Dot(deltaVals[i], translateAxis.Mask))).ToArray();
clip.SetCurve(bonePath, typeof(Transform), "localPosition." + translateAxis.Name,
new UnityEngine.AnimationCurve(positions));
if (!anyVelocities)
{
continue;
}
clip.SetCurve(bonePath, typeof(BFrame), "LocalVelocity." + translateAxis.Name,
new UnityEngine.AnimationCurve(deltas));
}
}
clip.wrapMode = WrapMode.Loop;
clip.EnsureQuaternionContinuity();
return(clip);
}
public static Vector3 ToV3(this UVector3 v3)
{
return(new Vector3 {
x = v3.x, y = v3.y, z = v3.z
});
}
void IBattleCharacter.SetPosition(UVector3 pos)
{
transform.position = pos;
}
IBattleCharacter IBattlePerception.CreateBattleCharacterView(string res, UVector3 pos, UVector3 forword)
{
return(new BattleCharactorView(pos, forword, this, Finder));
}
public static void DamageActive(TimeLinePlayer linePlayer, LayoutBase layoutBase)
{
var releaser = linePlayer.Releaser;
var layout = layoutBase as DamageLayout;
BattleCharacter orginTarget = null;
if (layout.target == Layout.TargetType.Releaser)
{
orginTarget = releaser.ReleaserTarget.Releaser;
}
else if (layout.target == Layout.TargetType.Target)
{
//release At Position?
if (releaser.ReleaserTarget.ReleaserTarget == null)
{
return;
}
orginTarget = releaser.ReleaserTarget.ReleaserTarget;
}
if (orginTarget == null)
{
throw new Exception("Do not have target of orgin. type:" + layout.target.ToString());
}
var offsetPos = new UVector3(layout.offsetPosition.x,
layout.offsetPosition.y, layout.offsetPosition.z);
var per = releaser.Controllor.Perception as BattlePerception;
var targets = per.FindTarget(orginTarget,
layout.fiterType,
layout.damageType,
layout.radius,
layout.angle,
layout.offsetAngle,
offsetPos, releaser.ReleaserTarget.Releaser.TeamIndex);
if (string.IsNullOrEmpty(layout.effectKey))
{
return;
//throw new Exception ("No Found effect key!");
}
//完成一次目标判定
if (targets.Count > 0)
{
if (layout.effectType == EffectType.EffectGroup)
{
var group = linePlayer.TypeEvent.FindGroupByKey(layout.effectKey);
if (group == null)
{
return;
}
//相应效果处理
foreach (var i in group.effects)
{
foreach (var t in targets)
{
EffectBaseLogic.EffectActive(t, i, releaser);
}
}
}
}
}
void IBattleCharacter.SetPosition(UVector3 pos)
{
this.transform.localPosition = pos.ToUVer3();
}
public void SetPosition(UVector3 pos)
{
transform.position = pos;
}
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 static UnityEngine.Vector3 ToUVer3(this UVector3 v3)
{
return(new Vector3(v3.x, v3.y, v3.z));
}
/// <summary>
/// Finds the target.
/// </summary>
/// <returns>The target.</returns>
/// <param name="character">Character.</param>
/// <param name="fitler">Fitler.</param>
/// <param name="damageType">Damage type.</param>
/// <param name="radius">Radius.</param>
/// <param name="angle">Angle.</param>
/// <param name="offsetAngle">Offset angle.</param>
/// <param name="offset">Offset.</param>
/// <param name="teamIndex">team</param>
public List <BattleCharacter> FindTarget(
BattleCharacter character,
FilterType fitler,
Layout.LayoutElements.DamageType damageType,
float radius, float angle, float offsetAngle,
UVector3 offset, int teamIndex)
{
var sqrRadius = radius * radius;
switch (damageType)
{
case Layout.LayoutElements.DamageType.Single: //单体直接对目标
return(new List <BattleCharacter> {
character
});
case Layout.LayoutElements.DamageType.Rangle:
{
var orgin = character.View.Transform.position + offset;
var forward = character.View.Transform.forward;
var q = UQuaternion.Euler(0, angle, 0);
forward = q * forward;
var list = new List <BattleCharacter>();
State.Each <BattleCharacter>((t) =>
{
//过滤
switch (fitler)
{
case FilterType.Alliance:
case FilterType.OwnerTeam:
if (teamIndex != t.TeamIndex)
{
return(false);
}
break;
case FilterType.EmenyTeam:
if (teamIndex == t.TeamIndex)
{
return(false);
}
break;
}
//不在目标区域内
if ((orgin - t.View.Transform.position).sqrMagnitude > sqrRadius)
{
return(false);
}
if (angle < 360)
{
if (UVector3.Angle(forward, t.View.Transform.forward) > (angle / 2))
{
return(false);
}
}
list.Add(t);
return(false);
});
return(list);
}
}
return(new List <BattleCharacter>());
}
// Update is called once per frame
void Update()
{
//return;
if (rotangle > 360)
{
rotangle = 0;
}
rotangle += Time.deltaTime * 5f;
this.mtransfrom.setParent(mparent);
this.transform.localRotation = Quaternion.Euler(0, rotangle, 0);
id = Quaternion.identity;
idm = UQuaternion.identity;
midM = UMatrix4x4.identity;
mid = Matrix4x4.identity;
cForward = this.transform.forward;
uForward = new UQuaternion(this.transform.rotation.x,
this.transform.rotation.y,
this.transform.rotation.z,
this.transform.rotation.w)
* UVector3.forward;
var inputUv = new UVector3(inputVer.x, inputVer.y, inputVer.z);
var s = new UVector3(scale.x, scale.y, scale.z);
var t = new UVector3(trans.x, trans.y, trans.z);
q = Quaternion.AngleAxis(angle, inputVer);
mq = UQuaternion.AngleAxis(angle, inputUv);
qEuler = Quaternion.Euler(inputVer);
qToEuler = qEuler.eulerAngles;
mqEuler = UQuaternion.Euler(inputUv);
mqToEuler = mqEuler.eulerAngles;
m = Matrix4x4.TRS(trans, q, scale);
mm = UMatrix4x4.TRS(t, mq, s);
Determinant = m.determinant;
mDeterminant = mm.Determinant;
exScale = mm.Scale;
exTrans = mm.Translate;
exRotation = mm.Rotation;
lookat = Quaternion.LookRotation(inputVer);
mlookat = UQuaternion.LookRotation(inputUv);
mforwardLookat = mlookat * UVector3.forward;
forwardLookat = lookat * Vector3.forward;
mangle = UQuaternion.LookRotation(inputUv).eulerAngles;
rangle = Quaternion.LookRotation(inputVer).eulerAngles;
mlookatMat = UMatrix4x4.LookAt(UVector3.zero, inputUv, UVector3.up);
lookatMat = Matrix4x4.TRS(
Vector3.zero,
Quaternion.LookRotation(inputVer, Vector3.up),
Vector3.one);
var v = this.transform.forward;
angleY = MathHelper.CalAngleWithAxisY(new UVector3(v.x, v.y, v.z));
adm = MathHelper.DeltaAngle(angleY, angle);
ad = Mathf.DeltaAngle(angleY, angle);
angleDeltaM = MathHelper.MoveTowardsAngle(angleY, angle, adm * Time.deltaTime);
angleDelta = Mathf.MoveTowardsAngle(angleY, angle, ad * Time.deltaTime);
this.mparent.localPosition = this.transform.parent.localPosition.ToUV3();
this.mparent.localRotation = this.transform.parent.localRotation.ToUQ();
this.mparent.localScale = this.transform.parent.localScale.ToUV3();
this.mtransfrom.localPosition = this.transform.localPosition.ToUV3();
this.mtransfrom.localRotation = this.transform.localRotation.ToUQ();
this.mtransfrom.localScale = this.transform.localScale.ToUV3();
dir = this.transform.TransformDirection(Vector3.forward);
dirU = mtransfrom.TransformDirection(UVector3.forward);
point = transform.TransformPoint(Vector3.forward);
pointU = mtransfrom.TransformPoint(UVector3.forward);
}
public static Vector3 ToV3(this UVector3 v)
{
return(new Vector3(v.x, v.y, v.z));
}
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);
}
void IBattleCharacter.SetForward(UVector3 forward)
{
this.transform.forward = forward.ToUVer3();
}
public static Vector3 ToNetVer3(this UVector3 ver)
{
return(new Vector3 {
x = ver.x, y = ver.y, z = ver.z
});
}
