Пример #1
0
 public void EndInit()
 {
     if (!DesignMode)
     {
         Animotion.Attach(this);
     }
 }
Пример #2
0
        private void CombineMove(KimbokoCombine combien, MoveAbilityEventInfo movInfo)
        {
            IMoveCommand moveCommand = new IMoveCommand(movInfo, game);

            Invoker.AddNewCommand(moveCommand);
            Invoker.ExecuteCommands();

            Vector3 startPosition = movInfo.fromTile.GetRealWorldLocation();
            Vector3 endPosition   = movInfo.endPosition.GetRealWorldLocation();

            GameObject[] goToMove = new GameObject[combien.kimbokos.Count];

            for (int i = 0; i < goToMove.Length; i++)
            {
                goToMove[i] = combien.kimbokos[i].goAnimContainer.GetGameObject();
            }

            //Motion combineMoveMotion = moveManagerUI.CombineMoveMotion(startPosition, endPosition, goToMove);
            //InvokerMotion.AddNewMotion(combineMoveMotion);
            //InvokerMotion.StartExecution(game);

            Animotion combineMoveMotion = moveManagerUI.CombineMoveAnimotion(startPosition, endPosition, goToMove);

            InvokerAnimotion.AddNewMotion(combineMoveMotion);
            InvokerAnimotion.StartExecution(game);
        }
Пример #3
0
        private void ExecuteNormalSpawn(SpawnAbility spawnAbility, SpawnAbilityEventInfo spwInf)
        {
            spawnAbility.SetRequireGameData(spwInf);
            StartPerform(spawnAbility);
            if (spawnAbility.CanIExecute() == false)
            {
                if (debugOn)
                {
                    Debug.Log("SPAWN ABILITY NO SE PUEDE EJECUTAR");
                }
                return;
            }

            GameObject    goKimboko    = spawnManagerUI.GetKimbokoPrefab();
            ISpawnCommand spawnCommand = new ISpawnCommand(spwInf, goKimboko, game);

            Invoker.AddNewCommand(spawnCommand);
            Invoker.ExecuteCommands();

            Vector3 spawnPosition = spwInf.spawnTile.GetRealWorldLocation();
            //Motion normalSpawnMotion = spawnManagerUI.NormalSpawn(spawnPosition, goKimboko);
            //InvokerMotion.AddNewMotion(normalSpawnMotion);
            //InvokerMotion.StartExecution(spawnManagerUI);


            Animotion normalSpawnMotion = spawnManagerUI.NormalSpawnAnimotion(spawnPosition, goKimboko);

            InvokerAnimotion.AddNewMotion(normalSpawnMotion);
            InvokerAnimotion.StartExecution(spawnManagerUI);


            Perform(spawnAbility);
            EndPerform(spawnAbility);
            spawnIndexID++;
        }
Пример #4
0
 public static void RemoveMotion(Animotion motion)
 {
     motionsToExecute.Remove(motion);
     if (logOn)
     {
         Debug.Log("MOTION REMOVED");
     }
 }
Пример #5
0
 public static void AddNewMotion(Animotion motion)
 {
     motionsToExecute.Add(motion);
     if (logOn)
     {
         Debug.Log("NEW MOTION ADDED");
     }
 }
Пример #6
0
 public void EndInit()
 {
     if (!DesignMode)
     {
         OnInputTagChanged();
         Animotion.Attach(this);
     }
 }
Пример #7
0
        public void OnCardWaitForTargetSelection(Transform cardTransform)
        {
            //Motion twaitMotion = cardManagerUI.OnCardWaitingTarget(cardTransform);
            //InvokerMotion.AddNewMotion(twaitMotion);
            //InvokerMotion.StartExecution(cardManagerUI);

            Animotion twaitMotion = cardManagerUI.OnCardWaitingTargetAnimotion(cardTransform);

            InvokerAnimotion.AddNewMotion(twaitMotion);
            InvokerAnimotion.StartExecution(cardManagerUI);
        }
Пример #8
0
        public static IEnumerator ExecuteMotion()
        {
            isExecuting = true;

            while (isExecuting)
            {
                // SI ESTA EJECUTANDO ENTONCES ESPERAMOS
                if (motionController.IsPerforming)
                {
                    if (logOn)
                    {
                        Debug.Log("IS PERFORMING");
                    }
                    yield return(null);
                }
                else
                {
                    // SI NO HAY MAS MOTIONS QUE EXECUTE ENTONCES TERMINAMOS
                    if (motionsToExecute.Count == 0)
                    {
                        if (logOn)
                        {
                            Debug.Log("ACTUAL MOTION HAS FINISH");
                        }
                        isExecuting = false;
                    }
                    else
                    {
                        // SI NO ESTA EJECUTANDO, EJECUTAMOS
                        Animotion motionToExecute = motionsToExecute[0];
                        ReproduceMotion(motionToExecute);
                        RemoveMotion(motionsToExecute[0]);
                        yield return(null);
                    }
                }
            }
            if (logOn)
            {
                Debug.Log("ALL MOTIONS FINISH");
            }

            if (motionsToExecute.Count > 0)
            {
                if (logOn)
                {
                    Debug.Log("SE AGREGO UNA MOTION DESPUES DE FINALIZAR");
                }
            }
        }
Пример #9
0
        public void SendCardToGraveyard(TakeCardAbilityEventInfo tkeCardInfo, RectTransform cardRect)
        {
            ISendCardToGraveyardCommand destroyCardCmd = new ISendCardToGraveyardCommand(tkeCardInfo.cardTaker, tkeCardInfo.card);

            Invoker.AddNewCommand(destroyCardCmd);
            Invoker.ExecuteCommands();

            //Motion sendToGraveyardMotion = cardManagerUI.OnCardSendToGraveyard(cardRect, tkeCardInfo.cardTaker.PlayerID);
            //InvokerMotion.AddNewMotion(sendToGraveyardMotion);
            //InvokerMotion.StartExecution(cardManagerUI);

            Animotion sendToGraveyardMotion = cardManagerUI.OnCardSendToGraveyardAnimotion(cardRect, tkeCardInfo.cardTaker.OwnerPlayerID);

            InvokerAnimotion.AddNewMotion(sendToGraveyardMotion);
            InvokerAnimotion.StartExecution(cardManagerUI);
        }
        public void ExecuteNormalCombine(CombineAbility combineAbility, CombineAbilityEventInfo cmbInfo)
        {
            combineAbility.SetRequireGameData(cmbInfo);
            StartPerform(combineAbility);
            if (combineAbility.CanIExecute() == false)
            {
                if (debugOn)
                {
                    Debug.Log("COMBINE ABILITY NO SE PUEDE EJECUTAR");
                }
                return;
            }

            ICombineCommand combineCommand = new ICombineCommand(cmbInfo, game);

            Invoker.AddNewCommand(combineCommand);
            Invoker.ExecuteCommands();

            Vector3 spawnPosition = game.board2DManager.GetUnitPosition(cmbInfo.combiner).GetRealWorldLocation();

            List <GameObject> combinersGO = new List <GameObject>();

            if (cmbInfo.combiner.UnitType == UNITTYPE.COMBINE)
            {
                KimbokoCombine kimbComb = (KimbokoCombine)cmbInfo.combiner;
                for (int i = 0; i < kimbComb.kimbokos.Count; i++)
                {
                    combinersGO.Add(kimbComb.kimbokos[i].goAnimContainer.GetGameObject());
                }
            }
            else
            {
                combinersGO.Add(cmbInfo.combiner.goAnimContainer.GetGameObject());
            }

            //Motion combineMoveMotion = combineManagerUI.NormalCombineMotion(spawnPosition, cmbInfo.kimbokoToCombine.goAnimContainer.GetGameObject(), combinersGO, game);
            //InvokerMotion.AddNewMotion(combineMoveMotion);
            //InvokerMotion.StartExecution(combineManagerUI);

            Animotion combineMoveMotion = combineManagerUI.NormalCombineAnimotion(spawnPosition, cmbInfo.kimbokoToCombine.goAnimContainer.GetGameObject(), combinersGO, game);

            InvokerAnimotion.AddNewMotion(combineMoveMotion);
            InvokerAnimotion.StartExecution(combineManagerUI);

            Perform(combineAbility);
            EndPerform(combineAbility);
        }
Пример #11
0
        private void NormalMove(MoveAbilityEventInfo movInfo)
        {
            IMoveCommand moveCommand = new IMoveCommand(movInfo, game);

            Invoker.AddNewCommand(moveCommand);
            Invoker.ExecuteCommands();

            Vector3 endPosition = movInfo.endPosition.GetRealWorldLocation();
            //Motion normalMoveMotion = moveManagerUI.MoveMotion(movInfo.moveOccupy.goAnimContainer.GetGameObject(), endPosition);
            //InvokerMotion.AddNewMotion(normalMoveMotion);
            //InvokerMotion.StartExecution(game);

            Animotion normalMoveMotion = moveManagerUI.MoveAnimotion(movInfo.moveOccupy.goAnimContainer.GetGameObject(), endPosition);

            InvokerAnimotion.AddNewMotion(normalMoveMotion);
            InvokerAnimotion.StartExecution(game);
        }
        public override void OnUpdate()
        {
            if (HaveReachCondition())
            {
                //PositionerDemo.Motion bannerMotion = gmMachine.informationUIManager.SetAndShowBanner("TURN STATE", 0.5f);
                //InvokerMotion.AddNewMotion(bannerMotion);
                //InvokerMotion.StartExecution(gmMachine);

                Animotion bannerMotion = gmMachine.informationUIManager.SetAndShowBannerAnimotion("TURN STATE", 0.5f);
                InvokerAnimotion.AddNewMotion(bannerMotion);
                InvokerAnimotion.StartExecution(gmMachine);


                TurnState turnState        = new TurnState(60, gmMachine);
                IState    changePhaseState = new ChangePhaseState(gmMachine, turnState);
                OnNextState(changePhaseState);
            }
            base.OnUpdate();
        }
Пример #13
0
        public override void OnUpdate()
        {
            if (HaveReachCondition())
            {
                AdministrationState adminState = new AdministrationState(20, gmMachine, 1);
                //Motion bannerMotion = gmMachine.informationUIManager.SetAndShowBanner(adminState.stateName, 0.5f);
                //InvokerMotion.AddNewMotion(bannerMotion);
                //InvokerMotion.StartExecution(gmMachine);

                Animotion bannerMotion = gmMachine.informationUIManager.SetAndShowBannerAnimotion(adminState.stateName, 0.5f);
                InvokerAnimotion.AddNewMotion(bannerMotion);
                InvokerAnimotion.StartExecution(gmMachine);


                IState changePhaseState = new ChangePhaseState(gmMachine, adminState);
                OnNextState(changePhaseState);
                //OnNextState(adminState);
            }
            base.OnUpdate();
        }
        public override void OnUpdate()
        {
            if (logOn)
            {
                Debug.Log("IN STATE " + stateName);
            }
            if (HaveReachCondition())
            {
                //PositionerDemo.Motion bannerMotion = gmMachine.informationUIManager.SetAndShowBanner(nextState.stateName, 0.5f);
                //InvokerMotion.AddNewMotion(bannerMotion);
                //InvokerMotion.StartExecution(gmMachine);

                Animotion bannerMotion = gmMachine.informationUIManager.SetAndShowBannerAnimotion(nextState.stateName, 0.5f);
                InvokerAnimotion.AddNewMotion(bannerMotion);
                InvokerAnimotion.StartExecution(gmMachine);

                IState changePhaseState = new ChangePhaseState(gmMachine, nextState);
                OnNextState(changePhaseState);
            }
            gameTimer.RestTime();
        }
Пример #15
0
        private void TakeCardFromDeck(TakeCardAbilityEventInfo tkeCardInfo)
        {
            IAddCardCommand addCardCmd = new IAddCardCommand(tkeCardInfo.cardTaker, tkeCardInfo.card);

            Invoker.AddNewCommand(addCardCmd);
            Invoker.ExecuteCommands();

            GameObject cardGo = cardManagerUI.CreateNewCardPrefab(tkeCardInfo.card, tkeCardInfo.cardTaker.OwnerPlayerID, this);
            //Motion takeCardMotion = cardManagerUI.AddCard(cardGo, tkeCardInfo.cardTaker.PlayerID);
            //InvokerMotion.AddNewMotion(takeCardMotion);
            //InvokerMotion.StartExecution(cardManagerUI);

            Animotion takeCardMotion = cardManagerUI.AddCardAnimotion(cardGo, tkeCardInfo.cardTaker.OwnerPlayerID);

            InvokerAnimotion.AddNewMotion(takeCardMotion);
            InvokerAnimotion.StartExecution(cardManagerUI);

            // ENTRAMOS EN ESTE ESTADO PARA PODER TOMAR LA CARD Y SOLO VER LA ANIMACION
            TakeCardState spawn = new TakeCardState(game, game.baseStateMachine.currentState);

            game.baseStateMachine.PopState(true);
            game.baseStateMachine.PushState(spawn);
        }
Пример #16
0
        public IEnumerator InitializeGame()
        {
            // ACA DEBERIA RECIBIR LA CONFIGURATION DATA DE CADA UNO
            // UNA VEZ QUE MIRROR ME DIGA "OK HERMANO", LOS DOS JUGADORES MANDARON SU CONFIGURATION DATA
            // ENTONCES AHI PUEDO VENIR A INITIALIZE GAME Y COMPROBAR LA PARTE DE FIREBASE Y SUS CONEXIONES

            // 0d- CHEQUEAR QUE LA BASE DE DATOS ESTE INITIALIZED
            //yield return WaitForDatabaseToLoad(); // REACTIVAR CUANDO FUNCIONE BIEN LA DB
            // 0- CHEQUEAR QUE LOS DOS JUGADORES ESTEN EN LINEA Y LISTOS PARA JUGAR.
            // 0b- CHEQUEAR QUE LOS DOS JUGADORES EXISTAN

            // 4- CARGAR EL DECK SELECCIONADO DE CADA JUGADOR
            // 4b- CHEQUEAR QUE SEA UN DECK VALIDO
            // 4c- SI ES INVALIDO SACAMOS TODO A LA MIERDA, SI ES VALID CREAMOS LOS DECKS DE CADA PLAYER


            // CREATE PLAYERS STATE
            // 1 - CREAR PLAYERS Y USERS
            // 0c- SEGUN EL JUGADOR QUE HAYA CREADO LA PARTIDA ESE SERA EL PLAYER ONE, NO SIGNIFICA QUE VA A EMPEZAR PRIMERO
            playerManager = new PlayerManager();
            playerManager.CreatePlayers();
            playerManager.CreateNewUser(null);


            // CREATE BOARD STATE
            // 3- IR CREANDO EL BOARD
            board2DManager = new Board2DManager(board2DManagerUI, 5, 7);
            //Motion motion = board2DManager.CreateBoard(playerManager.GetPlayer(), OnBoardComplete);
            //InvokerMotion.AddNewMotion(motion);
            //InvokerMotion.StartExecution(this);

            Animotion motion = board2DManager.CreateBoardAnimotion(playerManager.GetPlayer(), OnBoardComplete);

            InvokerAnimotion.AddNewMotion(motion);
            InvokerAnimotion.StartExecution(this);



            // CREATE TURNS STATE => ESTO LO DEBERIA HACER EL SERVER PARA QUE NO LO HAGA CADA JUGADOR Y SE PUEDE HACKEAR
            // 2- ASIGNAR LOS PLAYER AL TURN MANAGER
            turnController = new TurnController(playerManager.GetPlayer());
            // 2b - DECIDIR QUE PLAYER COMIENZA PRIMERO
            turnController.DecideStarterPlayer();


            // CREATE MANAGER STATE
            // 3b - Inicializar los managers generales  ESTOS LOS VA A TENER EL GAME... ASI QUE SEGURO LO HAGAMOS DESDE AHI
            spawnManager    = new SpawnManager(spawnManagerUI, this);
            combineManager  = new CombineManager(this, combineManagerUI);
            movementManager = new MovementManager(this, moveManagerUI);
            actionsManager  = new ActionsManager();
            yield return(null);


            // LOADCOLLECTIONSTATE  => LAS COLLECTION LAS DEBERIA TENER EL SERVER Y PASARSELAS A CADA JUGADOR
            // 3- CARGAR LA GAME COLLECTION
            InGameCardCollectionManager inGameCardCollectionManager = new InGameCardCollectionManager(this, OnCardCollectionLoadComplete);

            //inGameCardCollectionManager.LoadAllCollection(users);// REACTIVAR CUANDO FUNCIONE BIEN LA DB
            inGameCardCollectionManager.LoadAllCollectionJson(playerManager.GetUsers().ToArray());
            while (isCardCollectionLoaded == false)
            {
                if (logOn)
                {
                    Debug.Log("WAITING FOR CARD COLLECTION TO LOAD");
                }
                yield return(null);
            }
            if (logOn)
            {
                Debug.Log("GAME CARD COLLECTION LOADED");
            }


            // CREATEDECKSTATE
            cardManager = new CardController(inGameCardCollectionManager, cardManagerUI, this);
            // VOLVER A ACTIVAR QUE ESTA ES LA FORMA DE CARGAR EL DECK SEGUN LA INFO DE LOS PLAYERS
            //cardManager.LoadDeckFromConfigurationData(playerManager.GetPlayer()[0], playerManager.playerConfigurationData);
            //cardManager.LoadDeckFromConfigurationData(playerManager.GetPlayer()[1], playerManager.playerConfigurationData);
            cardManager.LoadDeckTest(playerManager.GetPlayer()[0]);
            cardManager.LoadDeckTest(playerManager.GetPlayer()[1]);


            // WAIT FOR BOARD TO LOAD STATE
            while (isBoardLoaded == false)
            {
                if (logOn)
                {
                    Debug.Log("WAITING FOR BOARD TO LOAD");
                }
                yield return(null);
            }



            // INITIALIZECONTROLLERSTATE
            // 5 - INICIALIZAMOS LOS CONTROLES
            mouseController    = new MouseController(0, board2DManager, Camera.main);
            keyBoardController = new KeyBoardController(0, board2DManager, Camera.main);
            tileSelectionManagerUI.SetController(board2DManager, mouseController, keyBoardController);


            // STARTGAMESTATE => ACA DEBERIA MANDAR CADA JUGADOR QUE ESTA READY, Y AHI EL SERVER EMITIRIA EL NUEVO STATE PARA CADA UNO
            // CREAMOS EL STATE INICIAL
            AdministrationState AdminState = new AdministrationState(10, this, 1);
            TurnState           turnState  = new TurnState(50, this);

            InitialAdministrationStateA initialAdminStateA = new InitialAdministrationStateA(40, this, 4);
            //Motion bannerMotion = informationUIManager.SetAndShowBanner(initialAdminStateA.stateName, 0.5f);
            //InvokerMotion.AddNewMotion(bannerMotion);
            //InvokerMotion.StartExecution(this);
            //Debug.Log("CREATING BANNER");
            Animotion bannerMotion = informationUIManager.SetAndShowBannerAnimotion(initialAdminStateA.stateName, 0.5f);

            InvokerAnimotion.AddNewMotion(bannerMotion);
            InvokerAnimotion.StartExecution(this);

            IState changePhaseState = new ChangePhaseState(this, initialAdminStateA);

            baseStateMachine = new BaseStateMachine(this);
            baseStateMachine.PushState(changePhaseState, true);
            baseStateMachine.Initialize();



            // DEBERIA DIVIR PLAYER == BASE NEXUS Y GAME PLAYER == JUGADOR EN SI QUE VA A ENVIAR LOS COMANDOS...
            // PODRIAMOS TENER UN GAME PLAYER QUE LO UNICA QUE VA A TENER ES UNA ID
            // ENTONCES CUANDO
            // game.actionsManager.IncrementPlayerActions(game.turnController.CurrentPlayerTurn, managmentPoints);
            // ESTO DEBARA CAMBIARSE game.turnController.CurrentPlayerTurn
            // SI UN JUGADOR APRETA UNA UNIDAD... COMO SABEMOS SI MOSTRAR O NO LA UI DE LOS BOTONES
            // POR QUE SOLO PODEMOS MOSTRARLA EN TURN STATE, OK, Y SOLO CON UNIDADES NUESTRAS OK
            // Y SI ACTIVAMOS EL BOTON ENTONCES IGUAL SIEMPRE VAMOS A SER NOSOTROS TECNICAMENTE...
            // POR QUE EL BOTON SE CREA CON EL OCUPIER O CON EL PLAYER EN ESTE CASO...
            //
            //
            // YA QUE ESTOY ENTRANDO A UN NUEVO STATE game.actionsManager.IncrementPlayerActions LO DEBARIA REALIZAR EL SERVER
            //

            // REALIZA SI O SI JUGADOR
            //// 1 - SUSCRIBIRSE AL EVENTO DE SELECCION ESTO SI LO TIENE QUE HACER EL JUGADOR
            //gmMachine.tileSelectionManagerUI.onTileSelected += ExecuteAction;
            //ExecuteAction(Tile action)
            //if (action == null)
            //{
            //    gmMachine.abilityButtonCreationUI.SetUnit(game.turnController.CurrentPlayerTurn);
            //}
            // ESTO LO HACE EL SERVER, VUELVE A REAHBILITAR LOS BOTONES DEL JUGADOR PARA SPAWN O TAKE CARD

            // SOLO JUGADOR YA QUE ES PARA LA UI
            //// NOS SUSCRIBIMOS AL EVENTO DE CAMBIAR EL TIEMPO
            //gameTimer.OnTimePass += gmMachine.uiGeneralManagerInGame.UpdateTime;



            // DEBE REALIZARLO SERVER
            //// 2 - TENGO QUE SETEAR LOS ACTIONS POINTS PARA ESTE JUGADOR
            //game.actionsManager.IncrementPlayerActions(game.turnController.CurrentPlayerTurn, managmentPoints);

            // DEBE REALIZARLO SERVER Y ENVIAR EL END STATE EN TODO CASO
            //// COMENZAMOS EL CONTADOR DE TIEMPO
            //base.OnEnter();

            // DEBE REALIZARLO SERVER ????
            //gmMachine.abilityButtonCreationUI.SetUnit(game.turnController.CurrentPlayerTurn);
        }
Пример #17
0
 private static void ReproduceMotion(Animotion motion)
 {
     motionController.SetUpMotion(motion);
     motionController.TryReproduceMotion();
 }
Пример #18
0
        private void ExecuteSpawnCombine(Kimboko actualCombiner, SpawnAbility spawnAbility, SpawnAbilityEventInfo spwInf)
        {
            CombineAbility combineAbility = (CombineAbility)actualCombiner.Abilities[ABILITYTYPE.COMBINE];

            if (combineAbility == null)
            {
                if (debugOn)
                {
                    Debug.Log("ERROR HABILIDAD COMBINE NULL");
                }
                return;
            }
            Kimboko spawnedKimboko = GetNewKimboko(spwInf);

            CombineAbilityEventInfo cmbInfo = new CombineAbilityEventInfo(actualCombiner, spawnedKimboko, spwInf.spawnerPlayer, spwInf.spawnIndexID);

            spawnAbility.SetRequireGameData(spwInf);
            combineAbility.SetRequireGameData(cmbInfo);

            StartPerform(spawnAbility);
            if (spawnAbility.CanIExecute() == false)
            {
                if (debugOn)
                {
                    Debug.Log("SPAWN ABILITY NO SE PUEDE EJECUTAR");
                }
                return;
            }

            game.combineManager.StartPerform(combineAbility);
            // NO VOY A GENERAR ESTE CHEQUEO, YA QUE EL SPAWN GENERA AUTOMATICAMENTE LA COMBINACION
            //if (combineAbility.CanIExecute() == false)
            //{
            //    if (debugOn) Debug.Log("COMBINE ABILITY NO SE PUEDE EJECUTAR");
            //    return;
            //}

            // C - CombineSpawn(Kimboko actualCombiner, SpawnAbilityEventInfo spwInf)
            GameObject goKimboko = spawnManagerUI.GetKimbokoPrefab();

            spawnedKimboko.SetGoAnimContainer(new GameObjectAnimatorContainer(goKimboko, goKimboko.GetComponent <Animator>()));
            ISpawnCombineCommand spawnCombineCmd = new ISpawnCombineCommand(spawnedKimboko, spwInf, actualCombiner, game);

            Invoker.AddNewCommand(spawnCombineCmd);
            Invoker.ExecuteCommands();
            Vector3           spawnPosition = spwInf.spawnTile.GetRealWorldLocation();
            List <GameObject> combinersGO   = new List <GameObject>();

            if (actualCombiner.UnitType == UNITTYPE.COMBINE)
            {
                KimbokoCombine kimbComb = (KimbokoCombine)actualCombiner;
                for (int i = 0; i < kimbComb.kimbokos.Count; i++)
                {
                    combinersGO.Add(kimbComb.kimbokos[i].goAnimContainer.GetGameObject());
                }
            }
            else
            {
                combinersGO.Add(actualCombiner.goAnimContainer.GetGameObject());
            }

            //Motion combineSpawnMotion = spawnManagerUI.CombineSpawn(spawnPosition, goKimboko, combinersGO, game);
            //InvokerMotion.AddNewMotion(combineSpawnMotion);
            //InvokerMotion.StartExecution(spawnManagerUI);


            Animotion combineSpawnMotion = spawnManagerUI.CombineSpawnAnimotion(spawnPosition, goKimboko, combinersGO, game);

            InvokerAnimotion.AddNewMotion(combineSpawnMotion);
            InvokerAnimotion.StartExecution(spawnManagerUI);

            // D - Perform(spawnAbility);
            //     Perform(combineAbility);
            Perform(spawnAbility);
            game.combineManager.Perform(combineAbility);
            // E - EndPerform(spawnAbility);
            //     EndPerform(combineAbility);
            EndPerform(spawnAbility);
            game.combineManager.EndPerform(combineAbility);
            // F - spawnIndexID++;
            spawnIndexID++;
        }