public override TaskResult OnExecute(MoonAI ai)
{
if (obj != null)
{
Object Clone = Instantiate(obj, Position.GetValue <Vector3>(ai.Memory),
Quaternion.Euler(Rotation.GetValue <Vector3>(ai.Memory)));
if (Clone is GameObject)
{
string key = SaveKey.GetValue <string>(ai.Memory);
if (!string.IsNullOrEmpty(key))
{
ai.Memory.SetValue(key, Clone);
}
return(TaskResult.Success);
}
#if UNITY_EDITOR
else
{
Debug.LogError("[MoonBehavior] Instantiate node only supports GameObject!");
}
#endif
}
return(TaskResult.Failure);
}
public override void OnEnter(MoonAI ai)
{
velocity = Vector3.zero;
agent = ai.GetComponent <NavMeshAgent>();
speed = Speed.GetValue <float>(ai.Memory);
TargetGo = ai.Memory.GetValue <GameObject>(Target.key);
}
public override TaskResult OnExecute(MoonAI ai)
{
float x = _x.GetValue <float>(ai.Memory);
float y = _y.GetValue <float>(ai.Memory);
float z = _z.GetValue <float>(ai.Memory);
if (!string.IsNullOrEmpty(SaveKey))
{
switch (BuildType)
{
case VectorType.Vector2:
ai.Memory.SetValue(SaveKey, new Vector2(x, y));
break;
case VectorType.Vector3:
ai.Memory.SetValue(SaveKey, new Vector3(x, y, z));
break;
}
return(TaskResult.Success);
}
return(TaskResult.Failure);
}
Task ChooseOne(MoonAI ai)
{
if (Childs.Length <= 0)
{
return(null);
}
float total = 0;
foreach (Task t in Childs)
{
total += t.GetPriority(ai);
}
float randomPoint = Random.value * total;
for (int i = 0; i < Childs.Length; i++)
{
if (randomPoint < (Childs[i].GetPriority(ai)))
{
return(Childs[i]);
}
else
{
randomPoint -= Childs[i].GetPriority(ai);
}
}
return(Childs[Childs.Length - 1]);
}
public override TaskResult OnExecute(MoonAI ai)
{
if (Path != null && Path.Length > 0 && !string.IsNullOrEmpty(m_saveKey))
{
while (Index < Path.Length)
{
Vector3 Target = Path[Index];
Vector3 Dir = (Target - ai.transform.position);
ai.Memory.SetValue(m_saveKey, Target);
ai.Memory.SetValue(m_currdistkey, Dir.magnitude);
if (Dir.magnitude <= m_NextWaypoint)
{
Index++;
}
return(TaskResult.Running);
}
Index = 0;
if (Mode == PatrolMode.PingPong)
{
System.Array.Reverse(Path);
}
return(TaskResult.Success);
}
return(TaskResult.Failure);
}
public override void OnEnter(MoonAI ai)
{
string key = AudioSoruceKey.GetValue <string>(ai.Memory);
Source = ai.Memory.GetValue <AudioSource>(key);
clip = SoundClip.GetValue <AudioClip>(ai.Memory);
}
public override TaskResult OnExecute(MoonAI ai)
{
if (Bt != null)
{
return(Bt.Root.Execute(ai));
}
return(TaskResult.Failure);
}
public override TaskResult OnExecute(MoonAI ai)
{
for (int i = 0; i < Childs.Length; i++)
{
Childs[i].Execute(ai);
}
return(TaskResult.Running);
}
public override void OnEnter(MoonAI ai)
{
string gokey = _gameObjectKey.GetValue <string>(ai.Memory);
if (!string.IsNullOrEmpty(gokey))
{
m_gameObject = ai.Memory.GetValue <GameObject>(gokey);
}
}
public override void OnEnter(MoonAI ai)
{
string rbkey = _rigidbodyKey.GetValue <string>(ai.Memory);
if (!string.IsNullOrEmpty(rbkey))
{
rb = ai.Memory.GetValue <Rigidbody>(rbkey);
}
}
public override void OnEnter(MoonAI ai)
{
Timer = 0;
WaitTime = Seconds.GetValue <float>(ai.Memory);
if (WaitTime < 0)
{
WaitTime = 0;
}
}
public override void OnEnter(MoonAI ai)
{
MoonBT loadedbt = BehaviorTree.GetValue <MoonBT>(ai.Memory);
if (loadedbt != null && (loadedbt != ai.BehaviorTree) && loadedbt.Root != null)
{
Bt = MoonBT.CopyBT(loadedbt);
}
}
public override TaskResult OnExecute(MoonAI ai)
{
if (anim != null)
{
anim.speed = Speed.GetValue <float>(ai.Memory);
return(TaskResult.Success);
}
return(TaskResult.Failure);
}
public override TaskResult OnExecute(MoonAI ai)
{
if (rb != null)
{
Vector3 f = force.GetValue <Vector3>(ai.Memory);
float delta = (useDeltaTime.GetValue <bool>(ai.Memory)) ? Time.deltaTime : 1;
rb.AddForce(f * delta, forceMode);
}
return(TaskResult.Failure);
}
public override TaskResult OnExecute(MoonAI ai)
{
Task choosed = ChooseOne(ai);
if (choosed != null)
{
return(choosed.Execute(ai));
}
return(TaskResult.Failure);
}
public override TaskResult OnExecute(MoonAI ai)
{
if (Childs.Length > 0)
{
if (MoonCondition.Evaluate(ai.Memory, conditions.ToArray()))
{
return(Childs[0].Execute(ai));
}
}
return(TaskResult.Failure);
}
public override TaskResult OnExecute(MoonAI ai)
{
float speed = Speed.GetValue <float>(Mem);
if (Agent != null)
{
Agent.speed = speed;
return(TaskResult.Success);
}
return(TaskResult.Failure);
}
public override TaskResult OnExecute(MoonAI ai)
{
if (Timer >= WaitTime)
{
return(TaskResult.Success);
}
else
{
Timer += Time.deltaTime;
return(TaskResult.Running);
}
}
// Called when the task is executed
public override TaskResult OnExecute(MoonAI ai)
{
float Aval = AValue.GetValue <float>(ai.Memory);
float BVal = BValue.GetValue <float>(ai.Memory);
string mSaveKey = SaveKey.GetValue <string>(ai.Memory);
ai.Memory.SetValue(mSaveKey, Compute(Aval, BVal));
return(TaskResult.Success);
}
public override TaskResult OnExecute(MoonAI ai)
{
string _key = Key.GetValue <string>(ai.Memory);
if (!string.IsNullOrEmpty(_key))
{
object val = Value.GetValue <object>(null);
ai.Memory.SetValue(_key, val);
return(TaskResult.Success);
}
return(TaskResult.Failure);
}
public override TaskResult OnExecute(MoonAI ai)
{
if (!string.IsNullOrEmpty(MethodName) & !string.IsNullOrEmpty(TargetGoKey))
{
GameObject target = ai.Memory.GetValue <GameObject>(TargetGoKey);
if (target != null)
{
target.SendMessage(MethodName, Options);
}
}
return(TaskResult.Failure);
}
public override TaskResult OnExecute(MoonAI ai)
{
string savek = SaveKey.GetValue <string>(ai.Memory);
if (!string.IsNullOrEmpty(savek) && m_gameObject != null)
{
ai.Memory.SetValue(savek, m_gameObject.transform.position);
return(TaskResult.Success);
}
return(TaskResult.Failure);
}
public override TaskResult OnExecute(MoonAI ai)
{
string axisName = AxisName.GetValue <string>(ai.Memory);
string savekey = SaveKey.GetValue <string>(ai.Memory);
if (!string.IsNullOrEmpty(axisName) & !string.IsNullOrEmpty(savekey))
{
ai.Memory.SetValue(savekey, (Mode == AxisMode.Normal) ? Input.GetAxis(axisName) : Input.GetAxisRaw(axisName));
return(TaskResult.Success);
}
return(TaskResult.Failure);
}
public override TaskResult OnExecute(MoonAI ai)
{
string _tag = Tag.GetValue <string>(Mem);
if (!string.IsNullOrEmpty(_tag) && !string.IsNullOrEmpty(Savekey))
{
GameObject obj = GameObject.FindGameObjectWithTag(_tag);
Mem.SetValue(Savekey, obj);
return(TaskResult.Success);
}
return(TaskResult.Failure);
}
public override TaskResult OnExecute(MoonAI ai)
{
Vector3 forward = ForwardVector.GetValue <Vector3>(ai.Memory);
float speed = LookSpeed.GetValue <float>(ai.Memory);
if (forward != Vector3.zero)
{
Quaternion tres = Quaternion.LookRotation(forward);
ai.transform.rotation = Quaternion.Slerp(ai.transform.rotation, tres, speed * Time.deltaTime);
}
return(TaskResult.Success);
}
public override TaskResult OnExecute(MoonAI ai)
{
if (!Running && Vision != null && !DetectSomething)
{
ai.StartCoroutine(DoDetect(ai));
}
if (string.IsNullOrEmpty(SearchTag) | string.IsNullOrEmpty(SaveName) | Vision == null)
{
return(TaskResult.Failure);
}
return(DetectSomething ? TaskResult.Success : TaskResult.Running);
}
public override TaskResult OnExecute(MoonAI ai)
{
while (count < MaxCount)
{
TaskResult tres = Childs[0].Execute(ai);
if (tres == TaskResult.Failure || tres == TaskResult.Success)
{
count++;
}
return(TaskResult.Running);
}
return(TaskResult.Success);
}
public override TaskResult OnExecute(MoonAI ai)
{
if ((Mode == GetButtun.ButtunMode.Hold && Input.GetKey(key)) ||
(Mode == GetButtun.ButtunMode.Down && Input.GetKeyDown(key)) || (Mode == GetButtun.ButtunMode.Up && Input.GetKeyUp(key)))
{
Task child = Childs[0];
if (child != null)
{
return(child.Execute(ai));
}
}
return(TaskResult.Failure);
}
public override TaskResult OnExecute(MoonAI ai)
{
Animator anim = ai.GetComponent <Animator>();
string _param = Parameter.GetValue <string>(ai.Memory);
if (anim != null && !string.IsNullOrEmpty(_param))
{
anim.SetTrigger(_param);
return(TaskResult.Success);
}
return(TaskResult.Failure);
}
public override TaskResult OnExecute(MoonAI ai)
{
string btnName = ButtunName.GetValue <string>(ai.Memory);
if (!string.IsNullOrEmpty(btnName) && ((Mode == ButtunMode.Hold && Input.GetButton(btnName)) || (Mode == ButtunMode.Down &&
Input.GetButtonDown(btnName)) || (Mode == ButtunMode.Up && Input.GetButtonUp(btnName))))
{
Task child = Childs[0];
if (child != null)
{
return(child.Execute(ai));
}
}
return(TaskResult.Failure);
}
