protected override bool OnEvaluate(IAgent agent, BlackboardMemory workingMemory)
{
Tank t = (Tank)agent;
workingMemory.SetValue((int)EBBKey.MovingTargetPos, Match.instance.GetRebornPos(t.Team));
return(true);
}
protected override ERunningStatus OnExecute(IAgent agent, BlackboardMemory workingMemory)
{
Tank t = (Tank)agent;
var missiles = Match.instance.GetOppositeMissiles(t.Team);
Missile missile = Functions.GetLatestMissile(missiles, t.Team);
Vector3 normal = Vector3.Cross(Vector3.up, missile.Velocity).normalized;
RaycastHit hitInfo1, hitInfo2;
float hitDistance1 = 0, hitDistance2 = 0;
if (Physics.Linecast(t.Position, t.Position + normal * 100, out hitInfo1, PhysicsUtils.LayerMaskScene))
{
hitDistance1 = hitInfo1.distance;
}
if (Physics.Linecast(t.Position, t.Position - normal * 100, out hitInfo2, PhysicsUtils.LayerMaskScene))
{
hitDistance2 = hitInfo2.distance;
}
if (Mathf.Max(hitDistance1, hitDistance2) < 3)
{
return(ERunningStatus.Failed);
}
if (hitDistance1 > hitDistance2)
{
workingMemory.SetValue((int)EBBKey.MovingTargetPos, t.Position + Vector3.ClampMagnitude(normal, hitDistance1 - 1));
return(ERunningStatus.Finished);
}
workingMemory.SetValue((int)EBBKey.MovingTargetPos, t.Position - Vector3.ClampMagnitude(normal, hitDistance2 - 1));
return(ERunningStatus.Finished);
}
public override void Update(BlackboardMemory sensorMemory)
{
Tank t = (Tank)Agent;
//check if can see other tank
int targetOppKey = (int)EBBKey.TargetOppTank;
Tank oppTank = Match.instance.GetOppositeTank(t.Team);
if (oppTank != null && oppTank.IsDead == false && TrySightingTest(oppTank.Position))
{
sensorMemory.SetValue(targetOppKey, oppTank);
}
else
{
sensorMemory.SetValue(targetOppKey, null);
}
//check if star still exists
int cachedStarID = sensorMemory.GetValue <int>((int)EBBKey.CaredStar, -1);
if (cachedStarID >= 0) //has star
{
//move to star position it heard
Vector3 starPos = sensorMemory.GetValue <Vector3>((int)EBBKey.TargetStarPos, default(Vector3));
if (TrySightingTest(starPos))
{
Star cachedStar = Match.instance.GetStarByID(cachedStarID);
if (cachedStar == null)
{
sensorMemory.DelValue((int)EBBKey.CaredStar);
sensorMemory.DelValue((int)EBBKey.TargetStarPos);
}
}
}
}
protected override bool OnEvaluate(IAgent agent, BlackboardMemory workingMemory)
{
Tank t = (Tank)agent;
bool hasStar = false;
float nearestDist = float.MaxValue;
Vector3 nearestStarPos = Vector3.zero;
foreach (var pair in Match.instance.GetStars())
{
Star s = pair.Value;
if (s.IsSuperStar)
{
hasStar = true;
nearestStarPos = s.Position;
break;
}
else if (!Functions.Vector3EqualTo(t.NextDestination, s.Position))
{
float dist = Functions.CalculatePathLength(t.CaculatePath(s.Position), t.Position, s.Position);
if (dist < nearestDist)
{
hasStar = true;
nearestDist = dist;
nearestStarPos = s.Position;
}
}
}
if (hasStar)
{
workingMemory.SetValue((int)EBBKey.MovingTargetPos, nearestStarPos);
}
return(hasStar);
}
protected override ERunningStatus OnExecute(IAgent agent, BlackboardMemory workingMemory)
{
Tank t = (Tank)agent;
t.Move(workingMemory.GetValue <Vector3>((int)EBBKey.MovingTargetPos));
return(ERunningStatus.Finished);
}
protected override ERunningStatus OnExecute(IAgent agent, BlackboardMemory workingMemroy)
{
Tank t = (Tank)agent;
t.Fire();
return(ERunningStatus.Executing);
}
protected override bool OnEvaluate(IAgent agent, BlackboardMemory workingMemory)
{
Tank t = (Tank)agent;
bool hasStar = false;
float nearestDist = float.MaxValue;
Vector3 nearestStarPos = Vector3.zero;
foreach (var pair in Match.instance.GetStars())
{
Star s = pair.Value;
if (s.IsSuperStar)
{
hasStar = true;
nearestStarPos = s.Position;
break;
}
else
{
float dist = (s.Position - t.Position).sqrMagnitude;
if (dist < nearestDist)
{
hasStar = true;
nearestDist = dist;
nearestStarPos = s.Position;
}
}
}
if (hasStar)
{
workingMemory.SetValue((int)EBBKey.MovingTargetPos, nearestStarPos);
}
return(hasStar);
}
protected override ERunningStatus OnExecute(IAgent agent, BlackboardMemory workingMemroy)
{
Tank t = (Tank)agent;
Tank oppTank = Match.instance.GetOppositeTank(t.Team);
//Vector3 targetPos;
float distance;
distance = (oppTank.Position - lastPos).sqrMagnitude;
if (oppTank != null && oppTank.IsDead == false)
{
if (distance < 400)
{
t.TurretTurnTo(oppTank.Position);
}
else if (distance < 2000)
{
//targetPos = 5 * oppTank.Position - lastPos;
t.TurretTurnTo(oppTank.Position);
}
else
{
//targetPos = 10 * oppTank.Position - lastPos;
t.TurretTurnTo(oppTank.Position);
}
lastPos = oppTank.Position;
}
else
{
t.TurretTurnTo(Match.instance.GetRebornPos(oppTank.Team));
}
return(ERunningStatus.Executing);
}
protected override void OnReset(IAgent agent, BlackboardMemory workingMemory)
{
if (m_LastRunningNode != null)
{
m_LastRunningNode.Reset(agent, workingMemory);
}
m_LastRunningNode = null;
}
protected override void OnReset(IAgent agent, BlackboardMemory workingMemory)
{
if (m_ActionStatus == ACTION_Running)
{
OnExit(agent, workingMemory);
}
m_ActionStatus = ACTION_Ready;
}
public ERunningStatus Update(IAgent agent, BlackboardMemory workingMemory)
{
if (m_Precondition != null && m_Precondition.IsTrue(agent) == false)
{
return(ERunningStatus.Failed);
}
return(OnUpdate(agent, workingMemory));
}
protected override void OnReset(IAgent agent, BlackboardMemory workingMemory)
{
for (int i = 0; i < m_Children.Count; ++i)
{
m_Children[i].Reset(agent, workingMemory);
}
m_ChildrenRunning.Clear();
}
protected override void OnReset(IAgent agent, BlackboardMemory workingMemory)
{
if (m_CurrentNodeIndex >= 0 && m_CurrentNodeIndex < m_Children.Count)
{
m_Children[m_CurrentNodeIndex].Reset(agent, workingMemory);
}
m_CurrentNodeIndex = -1;
}
public static void Exec(Node root, IAgent agent, BlackboardMemory workingMemory)
{
ERunningStatus runningStatus = root.Update(agent, workingMemory);
if (runningStatus != ERunningStatus.Executing)
{
root.Reset(agent, workingMemory);
}
}
public override void StimulusReceived(Stimulus stim, BlackboardMemory sensorMemory)
{
Tank t = (Tank)Agent;
Vector3 toTarget = stim.EmitterPos - t.Position;
if (toTarget.sqrMagnitude > m_HearingRadius * m_HearingRadius)
{
return;
}
//star jingle
if (stim.StimulusType == (int)EStimulusType.StarJingle)
{
bool needUpdateCachedStar = false;
int cachedStarKey = (int)EBBKey.CaredStar;
Star star = (Star)stim.TargetObject;
int cachedStarID = sensorMemory.GetValue <int>(cachedStarKey, -1);
if (cachedStarID < 0)
{
needUpdateCachedStar = true;
}
else
{
Star cachedStar = Match.instance.GetStarByID(cachedStarID);
if (cachedStar == null) //no star found, use current
{
needUpdateCachedStar = true;
}
else
{
//check if need update cached star
if ((cachedStar.Position - t.Position).sqrMagnitude > toTarget.sqrMagnitude)
{
needUpdateCachedStar = true;
}
}
}
if (needUpdateCachedStar)
{
//update target to nearer one
sensorMemory.SetValue(cachedStarKey, star.ID);
sensorMemory.SetValue((int)EBBKey.TargetStarPos, star.Position);
}
}
else if (stim.StimulusType == (int)EStimulusType.StarTaken)
{
//if hears star taken, remove it from memory
int cachedStarKey = (int)EBBKey.CaredStar;
Star star = (Star)stim.TargetObject;
int cachedStarID = sensorMemory.GetValue <int>(cachedStarKey, -1);
if (star.ID == cachedStarID)
{
sensorMemory.DelValue(cachedStarKey);
sensorMemory.DelValue((int)EBBKey.TargetStarPos);
}
}
}
protected override void OnStart()
{
base.OnStart();
m_WorkingMemory = new BlackboardMemory();
m_BTNode = new ParallelNode(1).AddChild(
new TurnTurret(),
new Fire().SetPrecondition(new ConditionCanSeeEnemy()),
new SequenceNode().AddChild(
new SelectorNode().AddChild(
new BackToHome(),
new GetStarMove(),
new RandomMove()),
new MoveTo()));
}
protected override ERunningStatus OnExecute(IAgent agent, BlackboardMemory workingMemroy)
{
Tank t = (Tank)agent;
Tank oppTank = Match.instance.GetOppositeTank(t.Team);
if (oppTank != null && oppTank.IsDead == false)
{
t.TurretTurnTo(oppTank.Position);
}
else
{
t.TurretTurnTo(t.Position + t.Forward);
}
return(ERunningStatus.Executing);
}
protected override bool OnEvaluate(IAgent agent, BlackboardMemory workingMemory)
{
Vector3 targetPos;
if (workingMemory.TryGetValue((int)EBBKey.MovingTargetPos, out targetPos))
{
Tank t = (Tank)agent;
if (Vector3.Distance(targetPos, t.Position) >= 1f)
{
return(false);
}
}
workingMemory.SetValue((int)EBBKey.MovingTargetPos, GetNextDestination());
return(true);
}
protected override ERunningStatus OnExecute(IAgent agent, BlackboardMemory workingMemory)
{
Tank t = (Tank)agent;
Tank oppTank = Match.instance.GetOppositeTank(t.Team);
if (oppTank != null && oppTank.IsDead == false)
{
t.TurretTurnTo(oppTank.Position);
}
else
{
Vector3 oppHomeZonePos = Match.instance.GetRebornPos(oppTank.Team);
t.TurretTurnTo(oppHomeZonePos);
}
return(ERunningStatus.Executing);
}
protected override ERunningStatus OnUpdate(IAgent agent, BlackboardMemory workingMemory)
{
if (OnEvaluate(agent, workingMemory) == false)
{
return(ERunningStatus.Failed);
}
ERunningStatus runningStatus = ERunningStatus.Finished;
if (m_ActionStatus == ACTION_Ready)
{
OnEnter(agent, workingMemory);
m_ActionStatus = ACTION_Running;
}
if (m_ActionStatus == ACTION_Running)
{
runningStatus = OnExecute(agent, workingMemory);
}
return(runningStatus);
}
protected override ERunningStatus OnUpdate(IAgent agent, BlackboardMemory workingMemory)
{
float rate = workingMemory.GetValue <float>((int)rateType);
// TODO Test the certainty rate
Node c = rate > 50 || true ? m_Children[0] : m_Children[1];
ERunningStatus runningStatus = c.Update(agent, workingMemory);
Node previousNode = m_LastRunningNode;
m_LastRunningNode = null;
if (runningStatus != ERunningStatus.Failed)
{
m_LastRunningNode = c;
}
if (previousNode != m_LastRunningNode && previousNode != null)
{
previousNode.Reset(agent, workingMemory);
}
return(runningStatus);
}
protected override bool OnEvaluate(IAgent agent, BlackboardMemory workingMemory)
{
//Tank t = (Tank)agent;
foreach (var pair in Match.instance.GetStars())
{
Star s = pair.Value;
if (s.IsSuperStar)
{
workingMemory.SetValue((int)EBBKey.MovingTargetPos, Vector3.zero);
return(true);
}
}
if (Time.time + 7 > 0.5f * Match.instance.GlobalSetting.MatchTime && Time.time - 1 < 0.5f * Match.instance.GlobalSetting.MatchTime)
{
workingMemory.SetValue((int)EBBKey.MovingTargetPos, Vector3.zero);
return(true);
}
return(false);
}
protected override ERunningStatus OnUpdate(IAgent agent, BlackboardMemory workingMemory)
{
if (m_Children.Count == 0)
{
return(ERunningStatus.Finished);
}
m_RequestFinishedCount = Mathf.Clamp(m_RequestFinishedCount, 1, m_Children.Count);
if (m_ChildrenRunning.Count != m_Children.Count)
{
m_ChildrenRunning.AddRange(Enumerable.Repeat(ERunningStatus.Executing, m_Children.Count));
}
int failedCount = 0;
int finishedCount = 0;
for (int i = 0; i < m_Children.Count; ++i)
{
ERunningStatus status = m_ChildrenRunning[i];
if (status == ERunningStatus.Executing)
{
status = m_Children[i].Update(agent, workingMemory);
}
if (status == ERunningStatus.Finished)
{
finishedCount++;
m_ChildrenRunning[i] = status;
if (finishedCount == m_RequestFinishedCount)
{
return(ERunningStatus.Finished);
}
}
else if (status == ERunningStatus.Failed)
{
failedCount++;
if (failedCount > m_Children.Count - m_RequestFinishedCount)
{
return(ERunningStatus.Failed);
}
}
}
return(ERunningStatus.Executing);
}
protected override ERunningStatus OnUpdate(IAgent agent, BlackboardMemory workingMemory)
{
if (m_Children.Count == 0)
{
return(ERunningStatus.Finished);
}
if (m_CurrentNodeIndex < 0)
{
m_CurrentNodeIndex = 0;
}
for (int i = m_CurrentNodeIndex; i < m_Children.Count; ++i)
{
ERunningStatus status = m_Children[i].Update(agent, workingMemory);
if (status != ERunningStatus.Finished)
{
return(status);
}
m_CurrentNodeIndex++;
}
return(ERunningStatus.Finished);
}
protected override bool OnEvaluate(IAgent agent, BlackboardMemory workingMemory)
{
Tank t = (Tank)agent;
Tank oppTank = Match.instance.GetOppositeTank(t.Team);
float SleepTime = 2f;
float LastTime = 0.2f;
if (CanExecute() == false)
{
return(false);
}
else
{
lastExecuteTime = Time.time + SleepTime;
nextExecuteTime = Time.time + LastTime;
Vector3 link = oppTank.Position - t.Position;
Vector3 result = (Quaternion.AngleAxis(90, Vector3.up) * link).normalized * 5;
workingMemory.SetValue((int)EBBKey.MovingTargetPos, t.Position + result);
return(true);
}
}
protected override bool OnEvaluate(IAgent agent, BlackboardMemory workingMemory)
{
Tank t = (Tank)agent;
float nearestDist = float.MaxValue;
foreach (var pair in Match.instance.GetStars())
{
Star s = pair.Value;
float dist = (s.Position - t.Position).sqrMagnitude;
if (dist < nearestDist)
{
nearestDist = dist;
}
}
if (t.HP <= 30 && nearestDist > 300)
{
workingMemory.SetValue((int)EBBKey.MovingTargetPos, Match.instance.GetRebornPos(t.Team));
return(true);
}
return(false);
}
protected override ERunningStatus OnExecute(IAgent agent, BlackboardMemory workingMemory)
{
Tank t = (Tank)agent;
Tank oppTank = Match.instance.GetOppositeTank(t.Team);
if (oppTank != null && oppTank.IsDead == false)
{
if (oppTank.Velocity.magnitude >= 3f)
{
t.TurretTurnTo(Functions.CalculatePredictivePosition(t.FirePos, oppTank.Position, oppTank.Velocity));
}
else
{
t.TurretTurnTo(oppTank.Position);
}
}
else
{
Vector3 oppHomeZonePos = Match.instance.GetRebornPos(oppTank.Team);
t.TurretTurnTo(oppHomeZonePos);
}
return(ERunningStatus.Executing);
}
protected override ERunningStatus OnUpdate(IAgent agent, BlackboardMemory workingMemory)
{
ERunningStatus runningStatus = ERunningStatus.Finished;
Node previousNode = m_LastRunningNode;
//select running node
m_LastRunningNode = null;
foreach (Node c in m_Children)
{
runningStatus = c.Update(agent, workingMemory);
if (runningStatus != ERunningStatus.Failed)
{
m_LastRunningNode = c;
break;
}
}
//clear last running node
if (previousNode != m_LastRunningNode && previousNode != null)
{
previousNode.Reset(agent, workingMemory);
}
return(runningStatus);
}
protected override ERunningStatus OnUpdate(IAgent agent, BlackboardMemory workingMemory)
{
while (true)
{
ERunningStatus status = Child.Update(agent, workingMemory);
if (status == ERunningStatus.Failed)
{
return(ERunningStatus.Failed);
}
else if (status == ERunningStatus.Executing)
{
break;
}
else
{
if (++m_RepeatIndex == m_RepeatCount)
{
return(ERunningStatus.Finished);
}
Child.Reset(agent, workingMemory);
}
}
return(ERunningStatus.Executing);
}
protected override bool OnEvaluate(IAgent agent, BlackboardMemory workingMemory)
{
Tank t = (Tank)agent;
var missiles = Match.instance.GetOppositeMissiles(t.Team);
if (missiles.Count == 0)
{
return(false);
}
Missile missile = Functions.GetLatestMissile(missiles, t.Team);
float dist = (missile.Position - t.Position).magnitude;
if (dist < 8)
{
return(false);
}
float cos = Vector3.Dot(missile.Velocity, t.Velocity) / missile.Velocity.magnitude / t.Velocity.magnitude;
if (Mathf.Abs(cos) < 0.5)
{
return(false);
}
return(true);
}
