public MenuInGame2(FSM parentFsm, UIManager2 panel1, UIManager2 panel2)
        : base(parentFsm, panel1, panel2, "MenuInGame2.fsm")
    {
        InitUI();

        int stageCode = (int)parentFsm.Variables["stageId"];
    }

 public UncontrolledFall(FSM fsm)
     : base(fsm)
 {
     // Add Transitions.
     this.gravity = Hero.Gravity;
     this.maxSpeed = 0.0f;
 }

 public void InitCommendSlots(FSM targetFsm, HeroCharacter heroCharacter)
 {
     itemSlotDisplay.Init(targetFsm, heroCharacter);
     /*
     skillDisplay.Init(targetFsm, heroCharacter);
      */
 }

    public void Inizializza(FSM oggetto)
    {
        MioCervello = oggetto;

        if (!MioCervello.DatiPersonaggio.Giocabile)
            elencoPercorsiDisponibili = Statici.databaseInizialePercorsi.trovaPercorsiDaPersonaggio(MioCervello.DatiPersonaggio.miaClasse);

        if (elencoPercorsiDisponibili.Count > 0)
            MioCervello.IndexPercorso = elencoPercorsiDisponibili[Random.Range(0, elencoPercorsiDisponibili.Count)];  //per ora gli assegno percorso casuale...da sistemare e completare

          //  foreach (int elem in elencoPercorsiDisponibili)
          //      Debug.Log("classe" + MioCervello.DatiPersonaggio.miaClasse + " idx " + elem);
          //  Debug.Log("percorso scelto " + MioCervello.IndexPercorso);

        /*
        if (GameManager.dizionarioPercorsi.ContainsKey(MioCervello.gameObject.tag))
            MioCervello.IndexPercorso = GameManager.dizionarioPercorsi[MioCervello.gameObject.tag];
            */
        //-Vedere se meglio con impostazione nostra di indiceDestionazioni oppure fare in modo che a ogni chiamata al Gestore PErcorso si incrementa da solo

        if (MioCervello.IndexPercorso < 0) //
        {
            Debug.LogError("Ue' picio.......Non hai stato assegnato nessun percorso..quindi se ne sta fermo in attesa di Input");
            return;
        }

        Percorso = Statici.padreGestore[MioCervello.IndexPercorso];
        indiceDestinazioni = -1;  //per convenzione ho assegnato il valore -1 per default (percorso no assegnato)
    }

 void Awake()
 {
     _fsm = new FSM<GameStates>();
     AddStates();
     AddTransitons();
     _instance = this;
 }

    // Use this for initialization
    public override void Start()
    {
        StateMachine = new FSM<EnemyChaserCloneScript> ( this, MoveToPlayer.Instance );
        anim = GetComponent<Animator>();

        if (!player) AssignPlayer();
        WaveSystem.EnemiesRemaining++;

        // Set initial stats (should overide by applying an upgrade)
        if (!HasBeenUpgraded)
        {
            Health = 1;
            Velocity = 1;
            Damage = 1;
            AttackRate = 5;
            Experience = 1;
        }

        // Movement
        IsMoving = true;
        TurnVelocity = 5f;

        // Attack
        IsAttacking = false;
        AttackDistance = 2;
        NextAttack = AttackRate;

        //Knockback
        Force = 50f;
        mass = 20;

        //misc
        renderer.material.color = Color.green;
    }

 void Awake()
 {
     _fsm = new FSM<CSTATES>();
     AddStates();
     AddTransitions();
     Instance = this;
 }

    public UIBase AddUI(string path, FSM fsm)
    {
        Assert.IsTrue(!string.IsNullOrEmpty(path));

        path = path.Trim();
        GameObject child = RecycleManager.Instance.Instantiate(path);
        if (child != null)
        {
            Vector3 tempPos = child.transform.position;
            child.transform.parent = panel.transform;
            child.transform.localScale = Vector3.one;
            child.transform.localPosition = tempPos;

            foreach (var entity in child.GetComponentsInChildren<UIButtonMessage>(true))
            {
                entity.fsm = fsm;
            }

            UIBase ret = child.GetComponent<UIBase>();
            if (ret == null)
            {
                ret = child.AddComponent<UIBase>();
            }
            ret.Init(path, fsm, this);
            handles.Add(path, ret);
            return ret;
        }
        return null;
    }

    public BossAlertTrigger(FSM parentFsm)
        : base(OverlapEventType.Trigger, 1, 1, WorldAnchor.BottomLeft)
    {
        Assert.IsTrue(parentFsm != null);

        this.parentFsm = parentFsm;
    }

    public LockObstacle(ObjectField objectField, ObjectStage objectStage, ItemDropManager itemDropManager, FSM parentFsm)
        : base(objectField, objectStage, itemDropManager, parentFsm)
    {
        objectLockObstacle = TableLoader.GetTable<ObjectLockObstacle>().Get(objectStage.ObjectID);
        int lockCount = objectLockObstacle.LockCount;
        this.name = StringTableLoader.Instance.Get(objectField.ObjectName);

        InitStatus<LockStatus>(
            new object[] { LockStatus.Lock, 0, lockCount, lockCount }
        );

        RegisterDeathCondition(
            delegate(Status current)
            {
                return current.Get(LockStatus.Lock) == 0;
            }
        );

        AddAction(Action.E_Type.Unlock,
            delegate(float value, GameInstance firer, string[] param)
            {
                FSMEvent("damage");
                return new ActionHandler.Result(LockStatus.Lock, -value);
            }
        );
        AddAction(Action.E_Type.Attack,
            delegate(float value, GameInstance firer, string[] param)
            {
                FSMEvent("damage");
                return new ActionHandler.Result(LockStatus.Lock, -1);
            }
        );
    }

 public HeroState(FSM fsm)
     : base(fsm)
 {
     Hero = (HeroMotion)fsm;
     animator = gameObject.GetComponent<Animator>();
     InputManager = gameObject.GetComponent<InputManager>();
 }

 public JumpFall(FSM fsm)
     : base(fsm)
 {
     AddTransition<WallRun>(CanWallRun);
     this.gravity = Hero.JumpGravity;
     this.maxSpeed = Hero.MaxAirSpeed;
 }

 public void Inizializza(FSM oggetto)
 {
     Cervello = oggetto;
     agente = Cervello.GetComponent<NavMeshAgent>();
     PersonaggioDaInseguire = GameObject.FindGameObjectWithTag("Player");
     animatore = Cervello.gameObject.GetComponent<Animator>();
 }

    public MenuInGame(FSM parentFsm, UIManager2 panel1, UIManager2 panel2)
        : base(parentFsm, panel1, panel2, "MenuInGame.fsm")
    {
        timeClient = TimeManager.Instance.Create();

        InitUI();

        int stageId = (int)parentFsm.Variables["stageId"];

        /*
        // ddong
        if (stageId < 2000)
        {
            stageId += 2000;
        }
        */

        InitStage(stageId, out stageEntity, out gameEntity);

        Rect fieldArea = UI.GetFieldArea();
        field = CreateField(stageEntity, fieldArea, timeClient, fsm);

        // ddong
        int subClassCode = 11;
        int level = 1;
        int trainLevel = 1;

        this.subClassEntity = TableLoader.GetTable<SubClassEntity>().Get(subClassCode);
        ClassLevelEntity levelEntity = TableLoader.GetTable<ClassLevelEntity>().Get(subClassEntity.classCode, level);
        TrainLevelEntity trainLevelEntity = TableLoader.GetTable<TrainLevelEntity>().Get(subClassEntity.classCode, trainLevel);
        FieldObjectEntity objectField = TableLoader.GetTable<FieldObjectEntity>().Get(subClassEntity.objectCode);

        Rect puzzleArea = UI.GetPuzzleArea();
        CreatePuzzle(puzzleArea, timeClient, subClassCode, out puzzleRecord, out puzzlePanel);

        user = CreateUser(stageEntity, UI, fsm);
        heroCharacter = CreateCharacter(objectField, levelEntity, trainLevelEntity, subClassEntity, user, puzzlePanel, itemDropManager, UI.AddBuffIcon, UI.RemoveBuffIcon, fsm);
        itemDropManager = new ConsumableSpawn(stageEntity.gameModeCode, levelEntity.consumableTier);

        Func<float> getLifeDrainRate = (() => gameEntity.defaultHP);
        new PlayerCharacter(user, heroCharacter, getLifeDrainRate, fsm);
        /*
        heroCharacter.Status.RegisterOnChangeEvent(HeroCharacter.Character.HP, OnCharacterHPChanged);
        heroCharacter.Status.RegisterOnChangeEvent(HeroCharacter.Character.HP, UI.ChangeHP);
        heroCharacter.Status.RegisterOnChangeEvent(HeroCharacter.Character.MP, UI.ChangeMana);
        heroCharacter.Status.RegisterOnChangeEvent(HeroCharacter.Character.Armor, UI.ChangeShield);
        */

        UI.InitCommendSlots(fsm, heroCharacter);

        field.AddPlayerCharacter(heroCharacter);
        field.FocusOnForced(heroCharacter, 0);
        puzzlePanel.SetQueue(user.commandQueue);

        var screenPosTable = TableLoader.GetTable<ScreenPositionEntity2>();
        var hpToPos = screenPosTable.Values.Select(x => new KeyValuePair<float, float>(x.hp, x.screenPos));
        convertHPRatioToScreenPos = new RangeConvertor(hpToPos).Convert;

        SetFocusTarget(heroCharacter);
    }

 public GDGeek.State getState(FSM fsm)
 {
     if(state_ == null){
         state_ = create(fsm);
     }
     return state_;
 }

        protected override void OnStart()
        {
            base.OnStart ();

            this.stateMachine = this.gameObject.AddComponent<FSM> ();
            this.stateMachine.container = this;
        }

 public PlayerCharacter(InGameUser user, HeroCharacter heroCharacter, Func<float> getLifeDrainRate, FSM parentFsm)
 {
     this.user = user;
     this.heroCharacter = heroCharacter;
     this.getLifeDrainRate = getLifeDrainRate;
     this.parentFsm = parentFsm;
     heroCharacter.InitFSM("PlayerCharacter.fsm", this, false);
 }

    public MenuAdventure(FSM parentFsm, UIManager2 panel1, UIManager2 panel2)
        : base(parentFsm, panel1, panel2, "MenuAdventure.fsm")
    {
        this.parentFsm = parentFsm;

        var stages = TableLoader.GetTable<StageEntity2>().Values;
        this.adventureStages = stages.Where(x => x.gameModeCode == 2);
    }

 public override PetriNet CreateOutput(FSM.FiniteStateMachine input, ITransformationContext context)
 {
     var coloredNet = new ColoredPetriNet();
     var defaultColor = new Color();
     coloredNet.Colors.Add(defaultColor);
     context.Bag.DefaultColor = defaultColor;
     return coloredNet;
 }

 public override void Transform(FSM.State input, Place output, ITransformationContext context)
 {
     var colored = output as ColoredPlace;
     if (colored != null && input.IsStartState)
     {
         colored.Tokens.Add(context.Bag.DefaultColor, 1);
     }   
 }