public override EBTTaskState OnTaskStart(BehaviourTreeRunner btree)
{
mAbort = false;
Debug.Log("Start Test Task: " + mInformation);
mTargetSetter.SetValue(new Vector3(10, 201, 10));
return(EBTTaskState.running);
}
public override void OnInitData(BehaviourTreeRunner btree, string jsonData)
{
JObject obj = JsonConvert.DeserializeObject <JObject>(jsonData);
mTargetSetter = btree.Blackboard.Setter <Vector3>("test");
mInformation = obj.Value <string>("INFO.");
}
public void InitWith(BehaviourTreeRunner runner)
{
if (EditorApplication.isPlaying)
{
BindBehaviourTreeEvent(false);
}
ContextMenu.Hide();
Runner = runner;
BehaviourAsset = Runner == null ? (Selection.activeObject as BehaviourTreeAsset) : Runner.SourceAsset;
TreeCanvas.ClearElements();
CommentCanvas.ClearElements();
TreeGraph.Clear();
mRootGUI = new BehaviourRootGUI(this);
mRootGUI.UpdateLocalData();
TreeCanvas.AddElement(mRootGUI);
TreeGraph.AddNode(mRootGUI);
if (BehaviourAsset != null)
{
ImportTreeData();
}
ResetIdCounter();
RebuildExecutionOrder();
UpdateStateInfo();
if (EditorApplication.isPlaying)
{
BindBehaviourTreeEvent(true);
}
}
public override EBTTaskState OnTaskStart(BehaviourTreeRunner btree)
{
mAbort = false;
mTimer = 0;
mSign = Mathf.Sign(Random.value - 0.5f);
return(EBTTaskState.running);
}
public void SetBehaviourTreeAsset(BehaviourTreeAsset asset)
{
if (asset == tree)
{
return;
}
if (tmpAsset != null)
{
BehaviourTreeAsset.DestroyAsset(tmpAsset, true);
tmpAsset = null;
}
tree = asset;
var bind = runner == null || asset == null ? null : runner.GetBinder(asset);
if (bind != null)
{
runner = bind.Runner;
}
runtimeBinder = bind;
if (tree != null)
{
tmpAsset = tree.Clone();
}
if (updateTreeAsset != null)
{
updateTreeAsset();
}
}
public bool SetSelectedAsset()
{
BehaviourTreeRunner tmprunner = null;
BehaviourTreeAsset tmpasset = null;
if (Selection.activeGameObject != null)
{
tmprunner = Selection.activeGameObject.GetComponent <BehaviourTreeRunner>();
}
else if (Selection.activeObject != null)
{
tmpasset = Selection.activeObject as BehaviourTreeAsset;
}
if (tmprunner != null)
{
SetBehaviourTreeRunner(tmprunner);
return(true);
}
if (tmpasset == null && BehaviourTreeEditor.ActiveBTEditor != null)
{
var his = BehaviourTreeEditor.ActiveBTEditor.LastAssetInHistory;
if (!string.IsNullOrEmpty(his))
{
tmpasset = AssetDatabase.LoadAssetAtPath <BehaviourTreeAsset>(his);
}
}
if (tmpasset != null)
{
SetBehaviourTreeAsset(tmpasset);
return(true);
}
return(false);
}
public static void OpenEditor()
{
GameObject obj = Selection.activeGameObject;
BehaviourTreeRunner r = obj == null ? null : obj.GetComponent <BehaviourTreeRunner>();
OpenEditor(r);
}
private void OnBehaviourTreeBegin(BehaviourTreeRunner btree)
{
if (btree == Runner)
{
SetNodeRuntimeState(btree.RootNode);
}
}
public static void OpenEditor(BehaviourTreeRunner runner)
{
BehaviourTreeDesignerWindow window = GetWindow <BehaviourTreeDesignerWindow>();
window.InitWith(runner);
window.Show();
}
public void SyncRuntimeState(BehaviourTreeRunner btree)
{
if (RuntimeNode == null)
{
Self.BTRuntimeState = EBTTaskState.inactive;
for (int i = 0; i < conditions.Count; i++)
{
conditions[i].BTRuntimeState = EBTTaskState.inactive;
}
for (int i = 0; i < services.Count; i++)
{
services[i].BTRuntimeState = EBTTaskState.inactive;
}
}
else
{
Self.BTRuntimeState = RuntimeNode.State;
for (int i = 0; i < RuntimeNode.ConditionBuffer.Length; i++)
{
conditions[i].BTRuntimeState = RuntimeNode.State == EBTTaskState.inactive ? EBTTaskState.inactive
: (RuntimeNode.ConditionBuffer[i] ? EBTTaskState.success : EBTTaskState.faild);
}
for (int i = 0; i < services.Count; i++)
{
EBTTaskState stat = services[i].BTRuntimeState;
services[i].BTRuntimeState = btree.IsServiceActive(services[i].BTId) ? EBTTaskState.running : EBTTaskState.inactive;
if (stat != EBTTaskState.running && services[i].BTRuntimeState == EBTTaskState.running)
{
services[i].TimeOffset = btree.BehaviourTime;
}
}
}
}
public override EBTTaskState OnTaskTick(BehaviourTreeRunner btree, float deltaTime)
{
if (mCharactor.IsGrounded && btree.TaskTime > 0.2f)
{
mCharactor.Move(Vector3.zero, false, true);
}
return(btree.TaskTime > 3 ? EBTTaskState.success : EBTTaskState.running);
}
public override EBTTaskState OnTaskTick(BehaviourTreeRunner btree, float deltaTime)
{
if (mAbort)
{
return(EBTTaskState.faild);
}
return(EBTTaskState.running);
}
public override EBTTaskState OnTaskStart(BehaviourTreeRunner btree)
{
if (mText == null)
{
return(EBTTaskState.faild);
}
mText.gameObject.SetActive(true);
return(EBTTaskState.running);
}
public override EBTTaskState OnTaskTick(BehaviourTreeRunner btree, float deltaTime)
{
if (mAbort)
{
return(EBTTaskState.faild);
}
mTimer += deltaTime;
if (mTimer >= mUpdateInterval)
{
if (mTargetTrans != null)
{
Transform trans = mTargetTrans.Value;
if (trans == null)
{
return(EBTTaskState.faild);
}
mTargetPos = trans.position;
}
else
{
mTargetPos = mTarget.Value;
}
mPath.ClearCorners();
NavMesh.CalculatePath(mPlayer.transform.position, mTargetPos, 1, mPath);
mCornnerPtr = 1;
mTimer = 0;
}
Vector3[] points = mPath.corners;
if (mCornnerPtr < points.Length)
{
Vector3 p = points[mCornnerPtr];
Vector3 dir = p - mPlayer.transform.position;
mPlayer.Move(dir.normalized * mSpeedPercentage * Mathf.Min(1, dir.magnitude * 3));
float rad;
if (mCornnerPtr == points.Length - 1 && mPath.status == NavMeshPathStatus.PathComplete)
{
rad = mStopDistance * mStopDistance;
}
else
{
rad = 0.009f;
}
if (dir.sqrMagnitude < rad)
{
mCornnerPtr++;
}
return(EBTTaskState.running);
}
else
{
if (mPath.status == NavMeshPathStatus.PathPartial)
{
mPlayer.Move(mPlayer.transform.forward * mSpeedPercentage);
}
return(mPath.status == NavMeshPathStatus.PathComplete ? EBTTaskState.success : EBTTaskState.running);
}
}
public override EBTTaskState OnTaskStart(BehaviourTreeRunner btree)
{
if (mCheckPoints.Length < 2)
{
return(EBTTaskState.faild);
}
mPtr = (mPtr + 1) % mCheckPoints.Length;
mTarget.SetValue(mCheckPoints[mPtr].position);
return(EBTTaskState.success);
}
public override EBTTaskState OnTaskTick(BehaviourTreeRunner btree, float deltaTime)
{
if (!mTarget.IsSet || mTarget.Value == null)
{
return(EBTTaskState.faild);
}
Vector3 p = mTarget.Value.position + Vector3.up * 1.6f;
mPlayer.LookAt(p);
return(EBTTaskState.running);
}
public void Dispose()
{
if (tmpAsset != null)
{
BehaviourTreeAsset.DestroyAsset(tmpAsset, true);
tmpAsset = null;
}
runner = null;
tree = null;
EditorApplication.playModeStateChanged -= OnPlayModeChanged;
}
public override EBTTaskState OnTaskStart(BehaviourTreeRunner btree)
{
if (!mTarget.IsSet && mTargetTrans == null)
{
return(EBTTaskState.faild);
}
mAbort = false;
mTimer = mUpdateInterval;
Debug.Log("move to " + mTarget.Value);
return(EBTTaskState.running);
}
public override void OnInitData(BehaviourTreeRunner btree, string jsonData)
{
GameObject go = GameObject.Find("FoundYouText");
if (go == null)
{
return;
}
mText = go.GetComponent <Text>();
mText.gameObject.SetActive(false);
mStartColor = mText.color;
}
public override EBTTaskState OnTaskTick(BehaviourTreeRunner btree, float deltaTime)
{
if (mAbort)
{
return(EBTTaskState.success);
}
mTimer += deltaTime;
if (mTimer > mSearchTime)
{
return(EBTTaskState.success);
}
btree.transform.Rotate(Vector3.up, mSign * 100 * deltaTime);
return(EBTTaskState.running);
}
public static void OpenBTEditor(BehaviourTreeRunner runner)
{
var window = ActiveBTEditor;
if (window == null)
{
window = GetWindow <BehaviourTreeEditor>(typeof(SceneView));
window.Show();
}
else
{
window.AddDelayTask(ACT_OPEN_ASSET, () => window.mAssetBinder.SetBehaviourTreeRunner(runner));
}
}
private void OnBehaviourTreeFrame(BehaviourTreeRunner btree)
{
if (btree == Runner)
{
for (int i = 0; i < TreeCanvas.ElementCount; i++)
{
BehaviourNodeGUI node = TreeCanvas.GetElement <BehaviourNodeGUI>(i);
if (node != null)
{
node.SyncRuntimeState(btree);
}
}
}
}
public override void OnInitData(BehaviourTreeRunner btree, string jsonData)
{
mTarget = btree.Blackboard.Getter <Vector3>("targetPos");
JObject obj = JsonConvert.DeserializeObject <JObject>(jsonData);
mStopDistance = obj.Value <float>("mStopDistance");
mSpeedPercentage = obj.Value <float>("mSpeedPercentage");
mBlackboardTarget = obj.Value <string>("mBlackboardTarget");
if (!string.IsNullOrEmpty(mBlackboardTarget))
{
mTargetTrans = btree.Blackboard.Getter <Transform>(mBlackboardTarget);
}
mPlayer = btree.GetComponent <PlayerController>();
mPath = new NavMeshPath();
}
public override EBTTaskState OnTaskTick(BehaviourTreeRunner btree, float deltaTime)
{
Color color = Color.Lerp(mStartColor, Color.red, Mathf.PingPong(btree.TaskTime * 2f, 1));
mText.color = color;
if (btree.TaskTime > 2)
{
mText.gameObject.SetActive(false);
return(EBTTaskState.success);
}
else
{
return(EBTTaskState.running);
}
}
public void SetBehaviourTreeRunner(BehaviourTreeRunner runner)
{
if (runner == null)
{
this.runner = null;
this.runtimeBinder = null;
return;
}
if (this.runner == null)
{
this.runner = null;
}
var asset = runner == null ? tree : runner.SourceAsset;
if (asset == null)
{
asset = tree;
}
var bind = runner == null ? null : runner.GetBinder(asset);
if (asset == tree && this.runner == runner && runtimeBinder == bind)
{
return;
}
this.runner = runner;
this.tree = asset;
runtimeBinder = bind;
if (tmpAsset != null)
{
BehaviourTreeAsset.DestroyAsset(tmpAsset, true);
tmpAsset = null;
}
if (tree != null)
{
if (tree != null)
{
tmpAsset = tree.Clone();
}
if (updateTreeAsset != null)
{
updateTreeAsset();
}
}
}
public override void OnInitData(BehaviourTreeRunner btree, string jsonData)
{
mTarget = btree.Blackboard.Setter <Vector3>("targetPos");
GameObject obj = GameObject.Find("CheckPoints");
if (obj)
{
Transform trans = obj.transform;
mCheckPoints = new Transform[trans.childCount];
for (int i = 0; i < mCheckPoints.Length; i++)
{
mCheckPoints[i] = trans.GetChild(i);
}
mPtr = Mathf.FloorToInt(Random.value * (mCheckPoints.Length - 0.1f));
}
else
{
mCheckPoints = new Transform[0];
}
}
private void OnPlayModeChanged(PlayModeStateChange stat)
{
if (stat == PlayModeStateChange.EnteredPlayMode || stat == PlayModeStateChange.EnteredEditMode)
{
if (runner == null)
{
runner = null;
}
if (tree == null)
{
tree = null;
}
if (tmpAsset != null)
{
BehaviourTreeAsset.DestroyAsset(tmpAsset, true);
tmpAsset = null;
}
if (tree == null)
{
if (SetSelectedAsset())
{
return;
}
}
else
{
var go = Selection.activeGameObject;
var tmpru = go == null ? null : go.GetComponent <BehaviourTreeRunner>();
if (tmpru != null && tmpru.SourceAsset == tree)
{
runner = tmpru;
}
}
runtimeBinder = runner == null ? null : runner.ActiveBinder;
if (updateTreeAsset != null)
{
updateTreeAsset();
}
}
}
public void SetBehaviourBinder(AssetBinder binder)
{
if (binder == null || runtimeBinder == binder)
{
return;
}
if (tmpAsset != null)
{
BehaviourTreeAsset.DestroyAsset(tmpAsset, true);
tmpAsset = null;
}
runner = binder.Runner;
tree = binder.Source;
runtimeBinder = binder;
if (tree != null)
{
tmpAsset = tree.Clone();
}
if (updateTreeAsset != null)
{
updateTreeAsset();
}
}
protected override void OnUpdate()
{
BehaviourTreeRunner.Exec(m_BTNode, this, m_WorkingMemory);
}
public override void OnAbort(BehaviourTreeRunner btree)
{
mAbort = true;
}
