public override State Tick(Tick tick)
{
float lastSeenTime = tick.blackBoard.Get<float>("lastSeenTime", tick.tree, this);
float time = Time.time - lastSeenTime;
Player p = Player.player;
Vector2 pPosition = p.transform.position;
Vector2 myPosition = tick.blackBoard.agent.transform.position;
Vector2 delta = pPosition - myPosition;
bool lookingFor = time < lookForPlayerTime;
if (delta.sqrMagnitude <= fieldOfView || lookingFor)
{
if (!Physics2D.Linecast(myPosition, pPosition, 256) || lookingFor)
{
if (!lookingFor)
tick.blackBoard.Set("lastSeenTime", Time.time, tick.tree, this);
return State.Success;
}
}
return State.Failure;
}
public override State Tick(Tick tick)
{
State state = child.Execute(tick);
if (child == null) return State.Error;
if (state == State.Success) return State.Failure;
if (state == State.Failure) return State.Success;
return state;
}
public override State Tick(Tick tick)
{
float lastAproveTime = tick.blackBoard.Get<float>("lastAproveTime", tick.tree, this);
int randomPercent = Random.Range(0, 101);
float time = Time.time - lastAproveTime;
if ((time > minWaitTime && randomPercent < shootProbability) || time >= maxWaitTime)
{
tick.blackBoard.Set("lastAproveTime", Time.time, tick.tree, this);
return State.Success;
}
return State.Failure;
}
public override State Tick(Tick tick)
{
State state = child.Execute(tick);
float startTime = tick.blackBoard.Get<float>("startTime", tick.tree, this);
if (Time.time - startTime > limit)
{
return State.Failure;
}
if (state != State.Running) return state;
return state;
}
public State Execute(Tick tick)
{
_Enter(tick);
if (!tick.blackBoard.Get<bool>("isOpen", tick.tree, this))
_Open(tick);
State state = _Tick(tick);
if (state != State.Running)
_Close(tick);
_Exit(tick);
return state;
}
public override State Tick(Tick tick)
{
int child = tick.blackBoard.Get<int>("runningChild", tick.tree, this);
for (int i = child; i < children.Length; i++)
{
State state = children[i].Execute(tick);
if (state != State.Failure)
{
if (state == State.Running) tick.blackBoard.Set("runningChild", i, tick.tree, this);
return state;
}
}
return State.Failure;
}
public override State Tick(Tick tick)
{
int i;
i = tick.blackBoard.Get<int>("runningChild", tick.tree, this);
if (i == -1)
{
i = Random.Range(0, children.Length);
}
State state = children[i].Execute(tick);
if (state == State.Running) tick.blackBoard.Set("runningChild", i, tick.tree, this);
return state;
}
public void Tick(Blackboard blackBoard)
{
/* TICK */
Tick tick = new Tick(blackBoard, this);
root.Execute(tick);
/* Retrieve info from tick n blackboard */
Node[] lastOpenNodes = blackBoard.Get(this).treeMemory.Get<Node[]>("openNodes");
Node[] openNodes = tick.GetOpenNodes();
/* do not close if still open */
if (lastOpenNodes != null)
{
int start = 0; //pick the difference to start frome the
int min = Mathf.Min(lastOpenNodes.Length, openNodes.Length);
for (int i = 0; i < min; i++)
{
start = i + 1;
if (lastOpenNodes[i] != openNodes[i]) break;
}
/* close nodes */
for (int i = lastOpenNodes.Length - 1; i >= start; i--)
{
lastOpenNodes[i]._Close(tick);
}
}
/* populate the blackboard */
tick.blackBoard.Set("openNodes", openNodes, this);
tick.blackBoard.Set("nodeCount", tick.nodeCount, this);
blackBoard.Set("nodeCount", tick.nodeCount, this);
}
public virtual void Exit(Tick tick)
{
}
public override State Tick(Tick tick)
{
for (int i = 0; i < children.Length; i++)
{
State state = children[i].Execute(tick);
if (state != State.Success) return state;
}
return State.Success;
}
public override State Tick(Tick tick)
{
int i = Random.Range(0, children.Length);
State state = children[i].Execute(tick);
return state;
}
public void _Open(Tick tick)
{
tick.OpenNode(this);
tick.blackBoard.Set("isOpen", true, tick.tree, this);
Open(tick);
}
public State _Tick(Tick tick)
{
tick.TickNode(this);
return Tick(tick);
}
public void _Enter(Tick tick)
{
tick.EnterNode(this);
Enter(tick);
}
public void _Exit(Tick tick)
{
tick.ExitNode(this);
Exit(tick);
}
public virtual State Tick(Tick tick)
{
return State.Error;
}
public void _Close(Tick tick)
{
tick.CloseNode(this);
tick.blackBoard.Set("isOpen", false, tick.tree, this);
Close(tick);
}
public virtual void Open(Tick tick)
{
}
public override void Open(Tick tick)
{
tick.blackBoard.Set("startTime", Time.time, tick.tree, this);
}
public override void Open(Tick tick)
{
tick.blackBoard.Set("runningChild", -1, tick.tree, this);
}
/* override for behaviour */
public virtual void Enter(Tick tick)
{
}
public virtual void Close(Tick tick)
{
}
