public override void OnAwake()
{
// Find the correct iCodeBehavior based on the name.
var iCodeBehaviorComponents = targetGameObject != null?targetGameObject.Value.GetComponents <ICodeBehaviour>() : gameObject.GetComponents <ICodeBehaviour>();
if (iCodeBehaviorComponents != null && iCodeBehaviorComponents.Length > 0)
{
iCodeBehavior = iCodeBehaviorComponents[0];
// We don't need the group if there is only one State Machine Behaviour component
if (iCodeBehaviorComponents.Length > 1)
{
for (int i = 0; i < iCodeBehaviorComponents.Length; ++i)
{
if (iCodeBehaviorComponents[i].group == group.Value)
{
// Cache the result when we have a match and stop looping.
iCodeBehavior = iCodeBehaviorComponents[i];
break;
}
}
}
}
// We can't do much if there isn't a ICodeBehaviour.
if (iCodeBehavior == null)
{
Debug.LogError(string.Format("Unable to find State Machine Behaviour with group {0}{1}", group, (targetGameObject.Value != null ? string.Format(" attached to {0}", targetGameObject.Value.name) : "")));
}
}
void Awake()
{
animator = GetComponent <Animator>();
Icodescript = this.GetComponent <ICodeBehaviour>();
if (this.gameObject.GetComponent <AudioSource>() == null)
{
this.gameObject.AddComponent <AudioSource>();
}
sound = this.gameObject.GetComponent <AudioSource>();
if (berry1 == null && berryPrefab != null)
{
int rand = Random.Range(1, 4);
berry1 = Instantiate(berryPrefab, null);
rb1 = berry1.transform.GetChild(0).GetComponent <Rigidbody> ();
berry1.SetActive(false);
if (rand > 1)
{
berry2 = Instantiate(berryPrefab, null);
rb2 = berry2.transform.GetChild(0).GetComponent <Rigidbody> ();
berry2.SetActive(false);
}
if (rand > 2)
{
berry3 = Instantiate(berryPrefab, null);
rb3 = berry3.transform.GetChild(0).GetComponent <Rigidbody> ();
berry3.SetActive(false);
}
}
}
private void AddItems(){
container = GetContainer ();
if (container != null) {
if (clearContainer) {
container.Clear ();
}
if (execute != null) {
if(behaviour == null){
behaviour = gameObject.AddBehaviour(execute);
behaviour.stateMachine.SetVariable ("Items", items);
behaviour.stateMachine.SetVariable ("Container", container.gameObject);
}
return;
}
for (int i=0; i< items.Length; i++) {
if (items [i] != null) {
container.Add (items[i]);
}
}
if(openContainer){
OpenContainer();
}
}
}
private void OnPlayModeStateChanged(){
if (ActiveGameObject != null) {
ICodeBehaviour behaviour=ActiveGameObject.GetComponent<ICodeBehaviour>();
if(behaviour != null){
SelectStateMachine(behaviour.stateMachine);
}
}
}
public void SetTeam(TeamType _Team, GameObject go_hpBar)
{
_icode = gameObject.GetBehaviour();
Team = _Team;
_buffManager = this.GetOrAddComponent <BuffManagerScript>();
SetHpBar(go_hpBar);
}
private void OnReceive(NetworkMessage message)
{
FsmVariableMessage mMessage = new FsmVariableMessage(null);
message.ReadMessage <FsmVariableMessage>(mMessage);
if (execute != null)
{
GameObject go = new GameObject("Handler");
ICodeBehaviour behaviour = go.AddBehaviour(execute);
behaviour.stateMachine.SetVariable("Info", mMessage.variable.GetValue());
}
}
public static void SelectGameObject(GameObject gameObject){
if (FsmEditor.instance == null){ //|| FsmEditor.ActiveGameObject == gameObject) {
return;
}
if (!PreferencesEditor.GetBool(Preference.LockSelection) && gameObject != null) {
ICodeBehaviour behaviour = gameObject.GetComponent<ICodeBehaviour> ();
if(behaviour != null && behaviour.stateMachine != null){
FsmEditor.instance.activeGameObject=behaviour.gameObject;
FsmEditor.SelectStateMachine(behaviour.stateMachine);
}
}
}
public override void OnEnter()
{
ICodeBehaviour behaviour = gameObject.Value.GetBehaviour(group.Value);
if (behaviour != null)
{
mVaraible = behaviour.stateMachine.GetVariable(variable.Value);
if (mVaraible != null)
{
mVaraible.SetValue(_value.GetValue());
}
}
Finish();
}
static void HierarchyWindowItemCallback(int pID, Rect pRect)
{
GameObject go = EditorUtility.InstanceIDToObject(pID) as GameObject;
if (go != null && go.GetComponent <ICodeBehaviour>() != null)
{
Rect rect = new Rect(pRect.x + pRect.width - 25, pRect.y - 3, 25, 25);
GUI.DrawTexture(rect, FsmEditorStyles.iCodeLogo);
ICodeBehaviour[] behaviours = go.GetComponents <ICodeBehaviour>();
for (int i = 0; i < behaviours.Length; i++)
{
ICodeBehaviour behaviour = behaviours[i];
ErrorChecker.CheckForErrors(behaviour.stateMachine);
if (ErrorChecker.HasErrors(behaviour.stateMachine) || behaviour.stateMachine == null)
{
Rect rect1 = new Rect(pRect.x + pRect.width - 25 - rect.width, pRect.y - 3, 25, 25);
GUI.DrawTexture(rect1, EditorGUIUtility.FindTexture("d_console.erroricon"));
}
}
}
Event ev = Event.current;
if (ev.type == EventType.DragPerform)
{
DragAndDrop.AcceptDrag();
var selectedObjects = new List <GameObject>();
foreach (var objectRef in DragAndDrop.objectReferences)
{
if (objectRef is StateMachine)
{
if (pRect.Contains(ev.mousePosition))
{
var gameObject = (GameObject)EditorUtility.InstanceIDToObject(pID);
var componentX = gameObject.AddComponent <ICodeBehaviour>();
componentX.stateMachine = objectRef as StateMachine;
selectedObjects.Add(gameObject);
}
}
}
if (selectedObjects.Count == 0)
{
return;
}
Selection.objects = selectedObjects.ToArray();
ev.Use();
}
}
public override void OnEnter()
{
ICodeBehaviour behaviour = gameObject.Value.GetBehaviour(group.Value);
if (behaviour != null)
{
mVaraible = behaviour.stateMachine.GetVariable(variable.Value);
if (mVaraible != null)
{
mVaraible.onVariableChange.AddListener(DoSync);
}
}
Finish();
}
static void DrawGameObjectName(Transform transform, GizmoType gizmoType)
{
ICodeBehaviour behaviour = transform.GetComponent<ICodeBehaviour> ();
if (behaviour == null) {
return;
}
if (behaviour.showSceneIcon) {
Handles.Label (transform.position, FsmEditorStyles.iCodeLogo);
}
if ( behaviour.showStateGizmos && behaviour.stateMachine!= null ) {
Node activeNode=behaviour.ActiveNode;
if(activeNode != null){
Handles.Label (transform.position, activeNode.Name,FsmEditorStyles.stateLabelGizmo);
}
}
}
public static void ICodeFinished(this BehaviorManager behaviorManager, ICodeBehaviour iCodeBehavior, TaskStatus status)
{
if (behaviorManager == null)
{
return;
}
var task = behaviorManager.TaskForObject(iCodeBehavior);
if (task is Tasks.ICode.StartStateMachine)
{
var iCodeTask = task as Tasks.ICode.StartStateMachine;
iCodeTask.ICodeFinished(status);
}
else if (task is RunConditionalStateMachine)
{
var iCodeTask = task as RunConditionalStateMachine;
iCodeTask.ICodeFinished(status);
}
}
// Use this for initialization
// Spine.TrackEntry
void Start()
{
//mSkeletonAnimation = gameObject.GetComponent<SkeletonAnimation> ();
//mSkeletonAnimation.AnimationName = walkName;
mAnimationState = mSkeletonAnimation.state;
mAnimationState.SetAnimation(0, blinkName, true);
cb = gameObject.GetBehaviour(0);
Debug.Log("cb is " + cb);
// cb.stateMachine.
FsmVariable move = cb.stateMachine.GetVariable("state");
move.onVariableChange.AddListener(onFsmStateChange);
moveTartget = new Vector3(direction == 1 ? pointRight.position.x : pointLeft.position.x, transform.position.y, transform.position.z);
meshRender = GetComponent <MeshRenderer> ();
}
void Start()
{
initHealth = health;
if (anim == null && this.gameObject.GetComponent <Animator>() != null)
{
anim = this.gameObject.GetComponent <Animator>();
}
if (anim != null)
{
foreach (AnimatorControllerParameter pa in anim.parameters)
{
if (pa.name == "Hurt")
{
hasParam = true;
}
}
}
if (this.gameObject.GetComponent <Rigidbody>())
{
rb = this.gameObject.GetComponent <Rigidbody>();
}
if (this.gameObject.GetComponent <BoxCollider>() != null)
{
boxCol = this.gameObject.GetComponent <BoxCollider>();
}
if (this.gameObject.GetComponent <SphereCollider>() != null)
{
sphereCol = this.gameObject.GetComponent <SphereCollider>();
}
if (renderers.Length == 0)
{
renderers = this.gameObject.GetComponentsInChildren <Renderer>();
}
foreach (Renderer r in renderers)
{
foreach (Material m in r.materials)
{
if (m.HasProperty("_RimColor") && m.HasProperty("_RimIntensityF"))
{
origRimCol.Add(m.GetColor("_RimColor"));
origRimInt.Add(m.GetFloat("_RimIntensityF"));
}
}
}
if (this.GetComponent <ICodeBehaviour>() != null)
{
icodescript = this.GetComponent <ICodeBehaviour>();
}
if (!damageOnly)
{
if (this.transform.parent.parent != null && this.transform.parent.parent.GetComponent <IActivablePrefab>() != null)
{
sound = this.transform.parent.parent.gameObject.AddComponent <AudioSource>();
}
else
{
sound = this.transform.parent.gameObject.AddComponent <AudioSource>();
}
sound.playOnAwake = false;
}
if (infiniteHealth || damageOnly)
{
endCol = new Color(1f, 1f, 1f, 0f);
}
if (collidersToIgnore.Length > 0)
{
foreach (Collider c in collidersToIgnore)
{
if (sphereCol != null)
{
Physics.IgnoreCollision(sphereCol, c, true);
}
if (boxCol != null)
{
Physics.IgnoreCollision(boxCol, c, true);
}
}
}
if (infiniteHealth && instantKill && damageOnly)
{
this.enabled = false;
}
}
protected override void CanvasContextMenu ()
{
if (currentEvent.type != EventType.MouseDown || currentEvent.button != 1 || currentEvent.clickCount != 1 || FsmEditor.Active == null){
return;
}
GenericMenu canvasMenu = new GenericMenu ();
canvasMenu.AddItem (FsmContent.createState, false, delegate() {
State state= FsmEditorUtility.AddNode<State>(mousePosition,FsmEditor.Active);
state.IsStartNode=FsmEditor.Active.GetStartNode() == null;
FsmEditorUtility.UpdateNodeColor(state);
});
canvasMenu.AddItem (FsmContent.createSubFsm, false, delegate() {
StateMachine stateMachine=FsmEditorUtility.AddNode<StateMachine>(mousePosition,FsmEditor.Active);
stateMachine.IsStartNode=FsmEditor.Active.GetStartNode() == null;
FsmEditorUtility.UpdateNodeColor(stateMachine);
});
canvasMenu.AddItem (FsmContent.copy, false, delegate() {
Pasteboard.Copy(new List<Node>(){FsmEditor.Active});
});
if (Pasteboard.CanPaste ()) {
canvasMenu.AddItem (FsmContent.paste, false, delegate() {
Pasteboard.Paste(mousePosition,FsmEditor.Active);
});
}
canvasMenu.AddSeparator ("");
if (Selection.activeGameObject != null) {
canvasMenu.AddItem (FsmContent.addToSelection, false, delegate() {
foreach(GameObject go in Selection.gameObjects){
ICodeBehaviour behaviour = go.AddComponent<ICodeBehaviour>();
behaviour.stateMachine = FsmEditor.Active.Root;
EditorUtility.SetDirty(behaviour);
}
SelectGameObject(Selection.activeGameObject);
});
canvasMenu.AddItem (FsmContent.bindToGameObject, false, delegate() {
foreach(GameObject go in Selection.gameObjects){
ICodeBehaviour behaviour = go.AddComponent<ICodeBehaviour>();
behaviour.stateMachine = (StateMachine)FsmUtility.Copy(FsmEditor.Active.Root);//FsmEditor.Active.Root;
EditorUtility.SetDirty(behaviour);
}
SelectGameObject(Selection.activeGameObject);
});
} else {
canvasMenu.AddDisabledItem(FsmContent.addToSelection);
canvasMenu.AddDisabledItem(FsmContent.bindToGameObject);
}
if (FsmEditor.Active.Root != null && !EditorUtility.IsPersistent(FsmEditor.Active.Root)) {
canvasMenu.AddItem (FsmContent.saveAsAsset, false, delegate() {
string mPath = EditorUtility.SaveFilePanelInProject (
"Save StateMachine as Asset",
"New StateMachine.asset",
"asset", "");
if(mPath != null){
StateMachine stateMachine=(StateMachine)FsmUtility.Copy(FsmEditor.Active.Root);
AssetDatabase.CreateAsset(stateMachine,mPath);
AssetDatabase.SaveAssets();
FsmEditorUtility.ParentChilds(stateMachine);
}
});
} else {
canvasMenu.AddDisabledItem(FsmContent.saveAsAsset);
}
canvasMenu.ShowAsContext ();
}
protected override void Init()
{
base.Init();
behavior = gameObject.GetBehaviour();
}
public void Init(ICodeBehaviour component){
this.owner = component;
this.Root.SetVariable ("Owner", this.owner.gameObject);
this.isInitialized = true;
}
public static bool ObjectTitlebar(UnityEngine.Object targetObject, bool foldout, ref bool enabled, GenericMenu settings)
{
int controlID = EditorGUIUtility.GetControlID(FocusType.Passive);
GUIContent content = new GUIContent(targetObject.name.Replace("/", "."), targetObject.GetTooltip());
Debug.Log(FsmEditorStyles.inspectorTitle.fixedWidth);
Rect position = GUILayoutUtility.GetRect(GUIContent.none, FsmEditorStyles.inspectorTitle);
position.x += 1f;
position.width -= 3f;
Rect rect = new Rect(position.x + (float)FsmEditorStyles.inspectorTitle.padding.left, position.y + (float)FsmEditorStyles.inspectorTitle.padding.top, 16f, 16f);
Rect rect1 = new Rect(position.xMax - (float)FsmEditorStyles.inspectorTitle.padding.right - 2f - 16f, rect.y, 16f, 16f);
Rect rect4 = rect1;
rect4.x = rect4.x - 18f;
Rect rect2 = new Rect(position.x + 2f + 2f + 16f * 2, rect.y, 100f, rect.height)
{
xMax = rect4.xMin - 2f
};
Rect rect3 = new Rect(position.x + 16f, rect.y, 16f, 16f);
enabled = GUI.Toggle(rect3, enabled, GUIContent.none);
string url = targetObject.GetHelpUrl();
if (ErrorChecker.HasErrors(targetObject))
{
Rect rect5 = rect4;
rect5.y += 1.0f;
if (!string.IsNullOrEmpty(url))
{
rect5.x = rect5.x - 18f;
rect2.xMax = rect5.x;
}
GUI.Label(rect5, FsmEditorStyles.errorIcon, FsmEditorStyles.inspectorTitleText);
}
if (GUI.Button(rect1, FsmEditorStyles.popupIcon, FsmEditorStyles.inspectorTitleText))
{
settings.ShowAsContext();
}
if (!string.IsNullOrEmpty(url) && GUI.Button(rect4, FsmEditorStyles.helpIcon, FsmEditorStyles.inspectorTitleText))
{
Application.OpenURL(url);
}
EventType eventType = Event.current.type;
if (eventType != EventType.MouseDown)
{
if (eventType == EventType.Repaint)
{
FsmEditorStyles.inspectorTitle.Draw(position, GUIContent.none, controlID, foldout);
Color color = GUI.contentColor;
if (FsmEditor.Active != null && FsmEditor.Active.Owner != null)
{
ICodeBehaviour behaviour = FsmEditor.Active.Owner;
if (behaviour.ActiveNode is State && (behaviour.ActiveNode as State).ActiveAction == targetObject)
{
GUI.contentColor = Color.green;
}
}
FsmEditorStyles.inspectorTitleText.Draw(rect2, content, controlID, foldout);
GUI.contentColor = color;
}
}
position.width = 15;
bool flag = FsmGUIUtility.DoToggleForward(position, controlID, foldout, GUIContent.none, GUIStyle.none);
return(flag);
}
private void Start()
{
_codeBehaviour = gameObject.transform.parent.gameObject.GetBehaviour();
}
