// -------------------------------------------

        /*
         * Initialization of the shoot
         */
        public override void Initialize(params object[] _list)
        {
            base.Initialize(_list);
            transform.position = (Vector3)_list[1];

            SoundsConstants.PlayFXBuildTower();
        }
        // -------------------------------------------

        /*
         * Report when the teleportation has been completed
         */
        public override void ChangeState(int _newState)
        {
            base.ChangeState(_newState);

            switch (m_state)
            {
            case STATE_IDLE:
                YourVRUIScreenController.Instance.EnableMoveCamera = true;
                m_pointerReference.SetActive(true);
                m_pointerReference.transform.position = this.gameObject.transform.position + 2 * GameConfiguration.CELL_SIZE * YourVRUIScreenController.Instance.GameCamera.transform.forward;
                break;

            case STATE_TARGETING:
                break;

            case STATE_GO:
                NetworkEventController.Instance.DispatchNetworkEvent(EVENT_LOCALPLAYERCONTROLLER_TELEPORT_POSITION, Utilities.Vector3ToString(m_target), TIME_TO_TELEPORT.ToString());
                SoundsConstants.PlayFXTeleport();
                m_pointerReference.SetActive(false);
                TeleportController.Instance.GetGameObject().SetActive(false);
                iTween.MoveTo(this.gameObject, iTween.Hash("position", m_target,
                                                           "easetype", iTween.EaseType.linear,
                                                           "time", TIME_TO_TELEPORT,
                                                           "oncomplete", "CompletedTeleportation",
                                                           "oncompletetarget", this.gameObject));
                break;
            }
        }
        // -------------------------------------------

        /*
         * Initialization of the element
         */
        public override void Initialize(params object[] _list)
        {
            base.Initialize(_list);

            transform.position = (Vector3)_list[1];
            m_type             = (int)_list[2];
            switch (m_type)
            {
            case POWER_UP_DISTANCE:
                FXController.Instance.NewFXAppearItemJump(transform.position);
                break;

            case POWER_UP_BOMB:
                FXController.Instance.NewFXAppearItemBomb(transform.position);
                break;

            case POWER_UP_SUPER_SHOOT:
                FXController.Instance.NewFXAppearItemSuper(transform.position);
                break;

            case POWER_UP_TOWER:
                FXController.Instance.NewFXAppearItemBomb(transform.position);
                break;
            }
            SoundsConstants.PlayFXItemAppear();

            ChangeState(STATE_IDLE);
        }
Пример #4
0
        // -------------------------------------------

        /*
         * Initialization of the super shoot
         */
        public override void Initialize(params object[] _list)
        {
            base.Initialize(_list);
            m_speed = SPEED;

            if (YourNetworkTools.Instance.GetUniversalNetworkID() == m_networkIDOwner)
            {
                SoundsConstants.PlayFxShootSuper();
            }
        }
Пример #5
0
        // -------------------------------------------

        /*
         * Collision of the bullet with an element
         */
        public override void OnTriggerEnter(Collider _collision)
        {
            FXController.Instance.NewFXBombExplosion(transform.position);
            if (m_networkIDOwner == YourNetworkTools.Instance.GetUniversalNetworkID())
            {
                SoundsConstants.PlayFXBombExplosion();
                NetworkEventController.Instance.DispatchNetworkEvent(EVENT_EXPLOSION_POSITION, Utilities.Vector3ToString(transform.position), DAMAGE.ToString(), RANGE_ENEMIES.ToString(), RANGE_BLOCKS.ToString());
            }
            GameEventController.Instance.DispatchGameEvent(EVENT_SHOOT_DESTROY, this.gameObject);
        }
        // -------------------------------------------

        /*
         * Initialization of the element
         */
        public override void Initialize(params object[] _list)
        {
            if ((m_dataEnemy == null) && (_list[0] != null))
            {
                m_dataEnemy = ItemMultiObjectEntry.Parse((string)_list[0]);

                this.gameObject.tag = TAG_ENEMY;
                m_enter             = (int)m_dataEnemy.Objects[1];
                m_exit                = (int)m_dataEnemy.Objects[2];
                m_trajectory          = new Vector2(m_enter, m_exit);
                m_animationDefinition = (string)m_dataEnemy.Objects[3];
                m_speed               = (float)(((float)((int)m_dataEnemy.Objects[4])) / 10f);
                m_life                = (int)m_dataEnemy.Objects[5];

                if (GameEventController.Instance.TotalPlayersInGame > 1)
                {
                    float lastLife = m_life;
                    m_life = m_life * GameEventController.Instance.TotalPlayersInGame;
                    m_life = m_life * 0.9f;
                }

                // SET UP IN FIRST WAYPOINT
                m_waypointIndex = 0;
                List <Vector3> ways = EnemiesController.Instance.WaypointsEnemies(m_trajectory);
                m_waypoints = new List <Vector3>();
                for (int i = 0; i < ways.Count; i++)
                {
                    m_waypoints.Add(Utilities.ClonePoint(ways[i]));
                }
                m_waypointPosition = m_waypoints[m_waypointIndex];
                transform.position = m_waypointPosition;
                FXController.Instance.NewFXAppearEnemy(m_waypointPosition);
                SoundsConstants.PlayFXEnemyAppear();
                transform.localScale = new Vector3(GameConfiguration.CELL_SIZE, GameConfiguration.CELL_SIZE, GameConfiguration.CELL_SIZE);

                // UPDATE TO NEXT WAYPOINT
                UpdateToNextWaypoint();

                InitializeCommon();

                ChangeState(STATE_RUNNING);

                if (IsMine())
                {
                    NetworkEventController.Instance.DispatchNetworkEvent(NetworkEventController.EVENT_WORLDOBJECTCONTROLLER_INITIAL_DATA, NetworkID.GetID(), m_dataEnemy.ToString());
                }
            }
        }
        // -------------------------------------------

        /*
         * Collision of the bullet with an element
         */
        void OnTriggerEnter(Collider _collision)
        {
            if (_collision.gameObject.tag == LocalPlayerController.Instance.GetTag())
            {
                iTween.Stop(this.gameObject);
                FXController.Instance.NewFXDeath(transform.position);
                SoundsConstants.PlayFXItemCollected();
                switch (m_type)
                {
                case POWER_UP_DISTANCE:
                    LocalPlayerController.Instance.DistanceTeleport += GameConfiguration.CELL_SIZE;
                    break;

                case POWER_UP_BOMB:
                    if (GameEventController.Instance.Level > 1)
                    {
                        LocalPlayerController.Instance.BombShoots += 2;
                    }
                    else
                    {
                        LocalPlayerController.Instance.BombShoots += 1;
                    }
                    break;

                case POWER_UP_SUPER_SHOOT:
                    if (GameEventController.Instance.Level > 1)
                    {
                        LocalPlayerController.Instance.SuperShoots += 20;
                    }
                    else
                    {
                        LocalPlayerController.Instance.SuperShoots += 10;
                    }
                    break;

                case POWER_UP_TOWER:
                    LocalPlayerController.Instance.DefenseTowers += 1;
                    break;
                }
                NetworkEventController.Instance.DispatchNetworkEvent(EVENT_POWER_UP_DESTROY, m_id.ToString());
            }
        }
Пример #8
0
        // -------------------------------------------

        /*
         * Set the state of the main manager
         */
        private void SetState(int _newState)
        {
            List <PageInformation> pages = new List <PageInformation>();

            base.ChangeState(_newState);

            switch (m_state)
            {
            /////////////////////////////////
            case STATE_GAME_LOADING:
                m_playersLoadedInitialData = 0;
#if DEBUG_MODE_DISPLAY_LOG
                Debug.LogError("+++++++STATE_GAME_LOADING");
#endif
                GameEventController.instance.DispatchGameEvent(LocalPlayerController.EVENT_LOCALPLAYERCONTROLLER_FREEZE_PHYSICS);

                UIEventController.Instance.DispatchUIEvent(UIEventController.EVENT_SCREENMANAGER_DESTROY_ALL_SCREEN);

                GameEventController.instance.DispatchGameEvent(ScreenVRHUDView.EVENT_HUD_ACTIVATION, false);

                if (!YourNetworkTools.Instance.IsLocalGame)
                {
#if ENABLE_PHOTON
                    BasicSystemEventController.Instance.DelayBasicSystemEvent(PhotonController.EVENT_PHOTONCONTROLLER_GAME_STARTED, 0.2f);
#endif
                }
                CreateLoadingScreen();
                break;

            /////////////////////////////////
            case STATE_GAME_PRESENTATION:
#if DEBUG_MODE_DISPLAY_LOG
                Debug.LogError("+++++++STATE_GAME_PRESENTATION");
#endif
                UIEventController.Instance.DispatchUIEvent(UIEventController.EVENT_SCREENMANAGER_DESTROY_ALL_SCREEN);

                // LEVEL PRESENTATION
                GameEventController.Instance.DelayGameEvent(EVENT_GAMEEVENT_SHOW_PRESENTATION_SCREEN, 0.2f);
                break;

            /////////////////////////////////
            case STATE_GAME_RUNNING:
#if DEBUG_MODE_DISPLAY_LOG
                Debug.LogError("+++++++STATE_GAME_RUNNING");
#endif

                UIEventController.Instance.DispatchUIEvent(UIEventController.EVENT_SCREENMANAGER_DESTROY_ALL_SCREEN);

                // ASSIGN INITIAL POSITIONS
                GameEventController.instance.DelayGameEvent(PlayersController.EVENT_PLAYERSCONTROLLER_ASSIGN_INITIAL_POSITION, 0.1f);

                // HUD ACTIVATION
                CreateGameHUD();
                GameEventController.instance.DispatchGameEvent(ScreenVRHUDView.EVENT_HUD_ACTIVATION, true);
                SoundsConstants.PlayMelodyGameplay();

                // PLAYER ACTIVATION
                LocalPlayerController.Instance.StartLocalPlayer();

                YourNetworkTools.Instance.ActivateTransformUpdate = true;
                break;

            /////////////////////////////////
            case STATE_GAME_VICTORY:
#if DEBUG_MODE_DISPLAY_LOG
                Debug.LogError("+++++++STATE_GAME_VICTORY");
#endif

                m_level++;
                LocalPlayerController.Instance.StopLocalPlayer();
                CreateVictoryScreen();
                SoundsController.Instance.StopAllSounds();
                SoundsConstants.PlayMelodyWin();
                m_localDataInitialized = false;
                GameEventController.instance.DispatchGameEvent(ScreenVRHUDView.EVENT_HUD_ACTIVATION, false);

                YourNetworkTools.Instance.ActivateTransformUpdate = false;
                break;

            /////////////////////////////////
            case STATE_GAME_DEFEAT:
#if DEBUG_MODE_DISPLAY_LOG
                Debug.LogError("+++++++STATE_GAME_DEFEAT");
#endif

                m_level       = 0;
                m_globalLifes = 10;
                LocalPlayerController.Instance.StopLocalPlayer();
                LocalPlayerController.Instance.ResetValues();
                CreateDefeatScreen();
                SoundsController.Instance.StopAllSounds();
                SoundsConstants.PlayMelodyLose();
                m_localDataInitialized = false;
                GameEventController.instance.DispatchGameEvent(ScreenVRHUDView.EVENT_HUD_ACTIVATION, false);

                YourNetworkTools.Instance.ActivateTransformUpdate = false;
                break;

            /////////////////////////////////
            case STATE_GAME_COMPLETED:
#if DEBUG_MODE_DISPLAY_LOG
                Debug.LogError("+++++++STATE_GAME_COMPLETED");
#endif

                m_level       = 0;
                m_globalLifes = 10;
                LocalPlayerController.Instance.StopLocalPlayer();
                m_localDataInitialized = false;
                CreateGameCompletedScreen();
                SoundsController.Instance.StopAllSounds();
                SoundsConstants.PlayMelodyWin();
                m_localDataInitialized = false;
                GameEventController.instance.DispatchGameEvent(ScreenVRHUDView.EVENT_HUD_ACTIVATION, false);

                YourNetworkTools.Instance.ActivateTransformUpdate = false;
                break;

            /////////////////////////////////
            case STATE_GAME_DISCONNECTED:
#if DEBUG_MODE_DISPLAY_LOG
                Debug.LogError("+++++++STATE_GAME_DISCONNECTED");
#endif
                YourNetworkTools.Instance.ActivateTransformUpdate = false;
                try
                {
                    LocalPlayerController.Instance.StopLocalPlayer();
                    CreateDisconnectionScreen();
                    SoundsController.Instance.StopAllSounds();
                    GameEventController.instance.DispatchGameEvent(ScreenVRHUDView.EVENT_HUD_ACTIVATION, false);
                }
                catch (Exception err) { };
                break;
            }
        }
Пример #9
0
        // -------------------------------------------

        /*
         * Initialization of the super shoot
         */
        public override void Initialize(params object[] _list)
        {
            base.Initialize(_list);
            m_speed = SPEED;
            SoundsConstants.PlayFxShootBomb();
        }
Пример #10
0
        // -------------------------------------------

        /*
         * Element's logic
         */
        public override void Logic()
        {
            base.Logic();

            switch (m_state)
            {
            case STATE_RUNNING:
                if (GameEventController.Instance.IsGameMaster())
                {
                    CheckToNextWaypoint();
                    MoveToTarget(m_waypointPosition, m_speed, 0.1f);

                    // TIMEOUT WAYPOINT
                    m_timeAcum += Time.deltaTime;
                    if (m_timeAcum >= 3)
                    {
                        m_timeAcum = 0;
                        UpdateToNextWaypoint();
                    }
                }
                break;

            case STATE_DIE:
                m_timeAcum += Time.deltaTime;
                if (m_timeAcum > 1)
                {
                    if (GameEventController.Instance.IsGameMaster())
                    {
                        NetworkEventController.Instance.DispatchNetworkEvent(FXController.EVENT_FXCONTROLLER_CREATE_NEW_FX, FXController.TYPE_FX_DEATH.ToString(), transform.position.x.ToString(), transform.position.y.ToString(), transform.position.z.ToString());
                    }
                    SoundsConstants.PlayFxDeathEnemy();
                    GameEventController.Instance.DispatchGameEvent(EVENT_ENEMY_DESTROY, NetworkID.NetID, NetworkID.UID);
                }
                break;

            case STATE_DIE_BY_EXPLOSION:
                m_timeAcum += Time.deltaTime;
                if (m_timeAcum > 3)
                {
                    if (GameEventController.Instance.IsGameMaster())
                    {
                        NetworkEventController.Instance.DispatchNetworkEvent(FXController.EVENT_FXCONTROLLER_CREATE_NEW_FX, FXController.TYPE_FX_DEATH.ToString(), transform.position.x.ToString(), transform.position.y.ToString(), transform.position.z.ToString());
                    }
                    SoundsConstants.PlayFxDeathEnemy();
                    GameEventController.Instance.DispatchGameEvent(EVENT_ENEMY_DESTROY, NetworkID.NetID, NetworkID.UID);
                }
                break;

            case STATE_DISAPPEAR:
                if (m_iterator == 1)
                {
                    if (GameEventController.Instance.IsGameMaster())
                    {
                        NetworkEventController.Instance.DispatchNetworkEvent(FXController.EVENT_FXCONTROLLER_CREATE_NEW_FX, FXController.TYPE_FX_DEATH.ToString(), transform.position.x.ToString(), transform.position.y.ToString(), transform.position.z.ToString());
                    }
                    m_life = 0;
                    SoundsConstants.PlayFxDeathEnemy();
                    GameEventController.Instance.DispatchGameEvent(EVENT_ENEMY_DESTROY, NetworkID.NetID, NetworkID.UID);
                    if (GameEventController.Instance.IsGameMaster())
                    {
                        NetworkEventController.Instance.DispatchNetworkEvent(GameEventController.EVENT_GAMEEVENT_DECREASE_GLOBAL_LIFES);
                    }
                }
                break;
            }
        }