public override BT_Status Tick(BT_Tick tick)
{
PathfollowingController controller = tick.Target as PathfollowingController;
if (controller == null)
{
return BT_Status.ERROR;
}
OrientedActor orientedActor = controller.GetComponent<OrientedActor>();
if (orientedActor == null)
{
return BT_Status.ERROR;
}
Grid grid = controller.Grid;
GridNode current = grid.GetGridForPosition(controller.transform.position);
if (current == null)
{
return BT_Status.FAILURE;
}
List<GridNode> path;
if (AStar.GetShortestPath(orientedActor, current, target, grid.diagnoal, out path))
{
tick.Blackboard.Set("path", path, tick.Tree.Id);
tick.Blackboard.Set("pathIndex", 0, tick.Tree.Id);
return BT_Status.SUCCESS;
}
else
{
return BT_Status.FAILURE;
}
}
public override BT_Status Tick(BT_Tick tick)
{
Integer child = tick.Blackboard.Get("runningChild", tick.Tree.Id, id) as Integer;
if (child == null)
{
return BT_Status.ERROR;
}
for (int i = child; i < children.Count; i++)
{
BT_Status status = children[i]._execute(tick);
if (status != BT_Status.SUCCESS)
{
if (status == BT_Status.RUNNING)
{
tick.Blackboard.Set("runningChild", i, tick.Tree.Id, this.id);
}
return status;
}
}
return BT_Status.SUCCESS;
}
public void Tick(object target, BT_BlackBoard blackboard)
{
/* CREATE A TICK OBJECT */
BT_Tick tick = new BT_Tick();
tick.Target = target;
tick.Blackboard = blackboard;
tick.Tree = this;
/* TICK NODE */
root._execute(tick);
/* CLOSE NODES FROM LAST TICK, IF NEEDED */
List<BT_BaseNode> lastOpenNodes = blackboard.Get("openNodes", this.id) as List<BT_BaseNode>;
List<BT_BaseNode> currOpenNodes = tick.OpenNodes as List<BT_BaseNode>;
// does not close if it is still open in this tick
var start = 0;
for (var i = 0; i < Math.Min(lastOpenNodes.Count, currOpenNodes.Count); i++)
{
start = i + 1;
if (lastOpenNodes[i] != currOpenNodes[i])
{
break;
}
}
// close the nodes
for (var i = lastOpenNodes.Count - 1; i >= start; i--)
{
lastOpenNodes[i]._close(tick);
}
/* POPULATE BLACKBOARD */
blackboard.Set("openNodes", currOpenNodes, this.id);
}
public BT_Status _execute(BT_Tick tick)
{
this._enter(tick);
/* OPEN */
Boolean isOpen = tick.Blackboard.Get("isOpen", tick.Tree.Id, this.id) as Boolean;
if (isOpen == null || !isOpen)
{
this._open(tick);
}
/* TICK */
BT_Status status = this._tick(tick);
/* CLOSE */
if (status != BT_Status.RUNNING)
{
this._close(tick);
}
/* EXIT */
_exit(tick);
return status;
}
public override void Open(BT_Tick tick)
{
Boolean lastOpenNodes = tick.Blackboard.Get("isPathValid", tick.Tree.Id) as Boolean;
if (lastOpenNodes == null)
{
tick.Blackboard.Set("isPathValid", false, tick.Tree.Id);
}
}
public override BT_Status Tick(BT_Tick tick)
{
if (EntityManager.Treasure.IsTaken)
{
return BT_Status.SUCCESS;
}
else
{
return BT_Status.FAILURE;
}
}
public override BT_Status Tick(BT_Tick tick)
{
if (EntityManager.Doors[index].IsTaken)
{
return BT_Status.SUCCESS;
}
else
{
return BT_Status.FAILURE;
}
}
public override BT_Status Tick(BT_Tick tick)
{
for (var i = 0; i < children.Count; i++)
{
var status = this.children[i]._execute(tick);
if (status != BT_Status.FAILURE)
{
return status;
}
}
return BT_Status.FAILURE;
}
public override BT_Status Tick(BT_Tick tick)
{
Boolean lastOpenNodes = tick.Blackboard.Get("isPathValid", tick.Tree.Id) as Boolean;
if (lastOpenNodes == null)
{
return BT_Status.ERROR;
}
if (lastOpenNodes)
{
return BT_Status.SUCCESS;
}
else
{
return BT_Status.FAILURE;
}
}
public override BT_Status Tick(BT_Tick tick)
{
List<GridNode> path = tick.Blackboard.Get("path", tick.Tree.Id) as List<GridNode>;
if (path == null)
{
return BT_Status.ERROR;
}
Integer pathIndex = tick.Blackboard.Get("pathIndex", tick.Tree.Id) as Integer;
if (pathIndex == null)
{
return BT_Status.ERROR;
}
PathfollowingController controller = tick.Target as PathfollowingController;
if (controller == null)
{
return BT_Status.ERROR;
}
Grid grid = controller.Grid;
GridNode current = grid.GetGridForPosition(controller.transform.position);
if (current == null)
{
controller.Idle();
return BT_Status.RUNNING;
}
if (current == target)
{
return BT_Status.SUCCESS;
}
if (path.Count > 0)
{
GridNode seeking = path[pathIndex];
if (current == seeking)
{
pathIndex += 1;
seeking = path[pathIndex];
tick.Blackboard.Set("pathIndex", pathIndex, tick.Tree.Id);
}
controller.Seek(seeking);
return BT_Status.RUNNING;
}
else
{
return BT_Status.ERROR;
}
}
public override BT_Status Tick(BT_Tick tick)
{
PathfollowingController controller = tick.Target as PathfollowingController;
if (controller == null)
{
return BT_Status.ERROR;
}
OrientedActor orientedActor = controller.GetComponent<OrientedActor>();
if (orientedActor == null)
{
return BT_Status.ERROR;
}
if (orientedActor.Keys[index] > 0)
{
return BT_Status.SUCCESS;
}
else
{
return BT_Status.FAILURE;
}
}
public override BT_Status Tick(BT_Tick tick)
{
BT_BaseNode child = children[0];
if (child == null)
{
return BT_Status.ERROR;
}
BT_Status status = child._execute(tick);
if (status == BT_Status.SUCCESS)
{
status = BT_Status.FAILURE;
}
else if (status == BT_Status.FAILURE)
{
status = BT_Status.SUCCESS;
}
return status;
}
public BT_Status _tick(BT_Tick tick)
{
tick.TickNode(this);
return Tick(tick);
}
public virtual void Close(BT_Tick tick)
{
}
public override BT_Status Tick(BT_Tick tick)
{
EntityManager.Treasure.IsTaken = true;
EntityManager.Treasure.GridNode.EntityType = EntityType.Nothing;
return BT_Status.SUCCESS;
}
public virtual void Enter(BT_Tick tick)
{
}
public override void Open(BT_Tick tick)
{
tick.Blackboard.Set("runningChild", 0, tick.Tree.Id, this.id);
}
public void _open(BT_Tick tick)
{
tick.OpenNode(this);
tick.Blackboard.Set("isOpen", true, tick.Tree.Id, id);
Open(tick);
}
public virtual void Exit(BT_Tick tick)
{
}
public void _exit(BT_Tick tick)
{
tick.ExitNode(this);
Exit(tick);
}
public virtual void Open(BT_Tick tick)
{
}
public void _enter(BT_Tick tick)
{
tick.EnterNode(this);
Enter(tick);
}
public void _close(BT_Tick tick)
{
tick.CloseNode(this);
tick.Blackboard.Set("isOpen", false, tick.Tree.Id, id);
Close(tick);
}
public virtual BT_Status Tick(BT_Tick tick)
{
return BT_Status.ERROR;
}
