Exemple #1
0
        /// <inheritdoc />
        public override void UpdateInput()
        {
            base.UpdateInput();

            if (touchHandler != null)
            {
                touchHandler.Update();
                // Unity adds mouse events from touches resulting in duplicated pointers.
                // Don't update mouse if touch input is present.
                if (mouseHandler != null)
                {
                    if (touchHandler.HasTouches)
                    {
                        mouseHandler.EndTouches();
                    }
                    else
                    {
                        mouseHandler.Update();
                    }
                }
            }
            else if (mouseHandler != null)
            {
                mouseHandler.Update();
            }
        }
Exemple #2
0
        /// <inheritdoc />
        public override void UpdateInput()
        {
            base.UpdateInput();

            if (touchHandler != null)
            {
                touchHandler.Update();
            }
        }
Exemple #3
0
        /// <summary>
        /// Allows the game to run logic such as updating the world,
        /// checking for collisions, gathering input, and playing audio.
        /// </summary>
        /// <param name="gameTime">Provides a snapshot of timing values.</param>
        protected override void Update(GameTime gameTime)
        {
            // Allows the game to exit
            if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed)
            {
                this.Exit();
            }

            TouchHandler.Update();

            if (null != currentGameScreen)
            {
                currentGameScreen.Update();
            }

            base.Update(gameTime);
        }
Exemple #4
0
        public override void Update(ref TouchHandler touchHandler_, GameTime gameTime_)
        {
            // Update in game state
            // ================

            // Update touch input handler
            touchHandler_.Update();

            // Create lists to contain touches for each player
            List <List <TouchLocation> > playerTouches = new List <List <TouchLocation> >();

            for (int p = 0; p < m_players.Count; ++p)
            {
                playerTouches.Add(new List <TouchLocation>());
            }

            // Iterate through each player and sort out which touches are for which player
            foreach (TouchLocation tl in touchHandler_.GetTouches())
            {
                for (int index = 0; index < playerTouches.Count; ++index)
                {
                    if (m_players[index].m_controlScheme.GetTouchZone().IsInsideZone(tl.Position))
                    {
                        playerTouches[index].Add(tl);
                    }
                }
            }

            //only want to do this when the main game isnt running
            if (!PlayersReady)
            {
                //check if a players ready up button has been pressed
                foreach (TouchLocation tl in touchHandler_.GetTouches())
                {
                    for (int index = 0; index < m_players.Count; ++index)
                    {
                        if (m_players[index].m_ReadyButton.Activated(tl.Position))
                        {
                            m_players[index].m_ReadyUp = true;
                            m_players[index].m_ReadyButton.m_sprite.SetTexture(TextureHandler.readySelectedButton);
                        }
                    }
                }

                //Set to 0 every run, so that it doesnt count multiple touches from same person
                NoPlayersReady = 0;

                foreach (Player p in m_players)
                {
                    if (p.m_ReadyUp == true)
                    {
                        NoPlayersReady += 1;
                    }
                }

                //When all players have readied up, start main game
                if (NoPlayersReady == m_players.Count)
                {
                    countdownBeeps.IsLooped = false;
                    countdownBeeps.Play();
                    PlayersReady = true;
                }
                h_trackHandler.Update(m_players, ref m_rankings);
            }
            else if (PlayersReady)
            {
                startTimer.Update(gameTime_.ElapsedGameTime.Milliseconds);
                if (startTimer.timerFinished)
                {
                    for (int i = 0; i < m_players.Count; ++i)
                    {
                        if (m_players[i].m_currentLap == Settings.m_number_laps)
                        {
                            m_players[i].SetFinished(true);
                            m_players[i].GetVehicle().SetToSensor();
                            m_players[i].AddFinishTime(gameTime_.ElapsedGameTime.Milliseconds);
                            if (m_winner == 0)
                            {
                                m_winner = m_players[i].GetID();
                            }
                        }
                        if (!m_players[i].GetFinished() || (m_players[i].GetFinished() && m_players[i].GetFinishTime() < 500))
                        {
                            bool left  = false;
                            bool right = false;
                            bool brake = false;
                            if (Keyboard.GetState().IsKeyDown(Keys.Left))
                            {
                                left = true;
                            }
                            if (Keyboard.GetState().IsKeyDown(Keys.Right))
                            {
                                right = true;
                            }
                            if (Keyboard.GetState().IsKeyDown(Keys.Space) || Keyboard.GetState().IsKeyDown(Keys.Down))
                            {
                                brake = true;
                            }

                            m_players[i].KeyboardMove(left, right, brake);
                            m_players[i].Update(playerTouches[i], m_rankings[i]);
                            m_players[i].AddRaceTime(gameTime_.ElapsedGameTime.Milliseconds);
                        }
                    }
                }
                // Victory state

                finished = true;
                foreach (Player p in m_players)
                {
                    if (!p.GetFinished())
                    {
                        finished = false;
                        break;
                    }
                }
                if (finished)
                {
                    m_currentExecutionState = ExecutionState.CHANGING;
                }

                // Update game objects

                float turn = 0;
                if (Keyboard.GetState().IsKeyDown(Keys.Left))
                {
                    turn--;
                }
                if (Keyboard.GetState().IsKeyDown(Keys.Right))
                {
                    turn++;
                }
                bool braked = Keyboard.GetState().IsKeyDown(Keys.Down);


                h_trackHandler.Update(m_players, ref m_rankings);

                // Update sprites
                foreach (AnimatedSprite anim in m_animatedSprites)
                {
                    // If currently animating
                    if (anim.GetCurrentState() == 1)
                    {
                        // Change the frame
                        if (gameTime_.TotalGameTime.TotalMilliseconds - anim.GetLastTime() > anim.GetFrameTime())
                        {
                            anim.ChangeFrame(gameTime_.TotalGameTime.TotalMilliseconds);
                        }
                    }
                }

                foreach (CheckpointContainer cp in h_trackHandler.m_checkpoints)
                {
                    cp.GetEntity().UpdateSprites();
                }

                //this set the sprite for the rankings, to the players to the corresponding rank
                for (int i = 0; i < m_rankings.Count; i++)
                {
                    m_rankingSprites[i].SetTexture(m_players[m_rankings[i] - 1].GetVehicle().m_vehicleBody.GetSprite().GetTexture());
                }

                // Update particles
                m_particles = GraphicsHandler.UpdatePFX(gameTime_.ElapsedGameTime.TotalMilliseconds);

                fs_world.Step((float)gameTime_.ElapsedGameTime.TotalMilliseconds * .001f);
            }
        }
Exemple #5
0
        public override void Update(ref TouchHandler touchHandler_, GameTime gameTime_)
        {
            // Update menu state
            // ================

            // NOTE: Debug Purposes
            if (Keyboard.GetState().IsKeyDown(Keys.Q))
            {
                m_currentScreen = MenuScreenState.MAIN_MENU;
            }
            if (Keyboard.GetState().IsKeyDown(Keys.W))
            {
                m_currentScreen = MenuScreenState.PLAYER_SELECT;
            }
            if (Keyboard.GetState().IsKeyDown(Keys.R))
            {
                m_currentScreen = MenuScreenState.OPTIONS;
            }
            if (Keyboard.GetState().IsKeyDown(Keys.T))
            {
                m_currentScreen = MenuScreenState.CREDITS;
            }
            if (Keyboard.GetState().IsKeyDown(Keys.Y))
            {
                bool ready      = true;
                int  readyCount = 0;

                // Loop through each player
                for (int i = 0; i < players.Count; i++)
                {
                    if (players[i].m_playerState == PlayerState.JOINED || players[i].m_playerState == PlayerState.VEHICLE_SELECTED)
                    {
                        ready = false;
                    }
                    else if (players[i].m_playerState == PlayerState.READY)
                    {
                        readyCount++;
                    }
                }
                Settings.m_numberOfPlayers = readyCount;
                m_currentExecutionState    = ExecutionState.CHANGING;
            }
            if (Keyboard.GetState().IsKeyDown(Keys.A))
            {
                m_currentScreen = MenuScreenState.CONTROLS;
            }
            if (Keyboard.GetState().IsKeyDown(Keys.D))
            {
                m_nextState             = GameState.VICTORY_SCREEN;
                m_currentExecutionState = ExecutionState.CHANGING;
            }

            // Change player count with keys - TEMP
            if (Keyboard.GetState().IsKeyDown(Keys.D1))
            {
                Settings.m_numberOfPlayers = 1;
            }
            else if (Keyboard.GetState().IsKeyDown(Keys.D2))
            {
                Settings.m_numberOfPlayers = 2;
            }
            else if (Keyboard.GetState().IsKeyDown(Keys.D3))
            {
                Settings.m_numberOfPlayers = 3;
            }
            else if (Keyboard.GetState().IsKeyDown(Keys.D4))
            {
                Settings.m_numberOfPlayers = 4;
            }



            Debug.AddText("7 for white cow, 8 for highland", new Vector2(20, 850));
            Debug.AddText("C for car, B for tractor, V for tank", new Vector2(20, 900));

            // NOTE: Debug keys
            if (Keyboard.GetState().IsKeyDown(Keys.M))
            {
                // Add player to game
                players[0].m_playerState = PlayerState.JOINED;
                players[0].m_actionButton.m_sprite.SetTexture(TextureHandler.readyUnselectedButton);
            }
            if (Keyboard.GetState().IsKeyDown(Keys.NumPad2))
            {
                players[0].m_playerState = PlayerState.VEHICLE_SELECTED;
                players[0].m_vehicleChoice.SetTexture(TextureHandler.vehicleLargeCarBlue);
                TextureHandler.player1Vehicle = TextureHandler.vehicleSmallCarBlue;
            }
            if (Keyboard.GetState().IsKeyDown(Keys.NumPad3))
            {
                players[0].m_playerState = PlayerState.READY;
            }
            if (Keyboard.GetState().IsKeyDown(Keys.NumPad7))
            {
                players[1].m_playerState    = PlayerState.READY;
                Settings.m_joinedPlayers[1] = true;
            }
            if (Keyboard.GetState().IsKeyDown(Keys.NumPad8))
            {
                players[2].m_playerState    = PlayerState.READY;
                Settings.m_joinedPlayers[2] = true;
            }
            if (Keyboard.GetState().IsKeyDown(Keys.NumPad9))
            {
                players[3].m_playerState    = PlayerState.READY;
                Settings.m_joinedPlayers[3] = true;
            }

            // Update touch input handler
            touchHandler_.Update();

            // If there is a touch on the screen
            if (touchHandler_.GetTouches().Count > 0)
            {
                // Get the position of the last touch
                m_touchState   = TouchState.TOUCHING;
                m_lastPosition = touchHandler_.GetTouches()[touchHandler_.GetTouches().Count - 1].Position;
            }

            for (int i = 0; i < players.Count; i++)
            {
                // If the player has joined
                if (players[i].m_playerState == PlayerState.JOINED)
                {
                    Settings.m_joinedPlayers[i] = true;
                }
            }

            // If there are no touches on the screen (finger released button)
            if (touchHandler_.GetTouches().Count == 0 && m_touchState == TouchState.TOUCHING)
            {
                switch (m_currentScreen)
                {
                case MenuScreenState.MAIN_MENU:
                    // Main Menu screen

                    if (m_playButton.Activated(m_lastPosition))
                    {
                        // Go to Player Select
                        m_currentScreen = MenuScreenState.PLAYER_SELECT;
                    }
                    if (m_exitButton.Activated(m_lastPosition))
                    {
                        // Close app
                    }
                    if (m_creditsButton.Activated(m_lastPosition))
                    {
                        // Go to Credits
                        m_currentScreen = MenuScreenState.CREDITS;
                    }
                    if (m_controlsButton.Activated(m_lastPosition))
                    {
                        // Go to control scheme screen
                        m_currentScreen = MenuScreenState.CONTROLS;
                    }
                    break;

                case MenuScreenState.PLAYER_SELECT:
                    // Player Select screen

                    //counter for amount of players
                    //so we can assign the proper texture

                    // Loop logic for each player
                    foreach (PlayerSelectStruct pss in players)
                    {
                        // Check player's join state
                        if (pss.m_playerState == PlayerState.NONE)
                        {
                            // If action button has been pressed
                            if (pss.m_actionButton.Activated(m_lastPosition))
                            {
                                // Add player to game
                                pss.m_playerState = PlayerState.JOINED;
                                pss.m_actionButton.m_sprite.SetTexture(TextureHandler.readyUnselectedButton);
                            }
                        }
                        else if (pss.m_playerState == PlayerState.JOINED)
                        {
                            // If vehicle button is pressed
                            if (pss.m_choice1Button.Activated(m_lastPosition))
                            {
                                // TODO: Check if the vehicle has already been chosen
                                pss.m_playerState = PlayerState.VEHICLE_SELECTED;

                                #region PickCorrectColour

                                if (pss.ID == 0)
                                {
                                    pss.m_vehicleChoice.SetTexture(TextureHandler.vehicleLargeCarBlue);
                                    TextureHandler.player1Vehicle = TextureHandler.vehicleSmallCarBlue;
                                }
                                else if (pss.ID == 1)
                                {
                                    pss.m_vehicleChoice.SetTexture(TextureHandler.vehicleLargeCarOrange);
                                    TextureHandler.player2Vehicle = TextureHandler.vehicleSmallCarOrange;
                                }
                                else if (pss.ID == 2)
                                {
                                    pss.m_vehicleChoice.SetTexture(TextureHandler.vehicleLargeCarPurple);
                                    TextureHandler.player3Vehicle = TextureHandler.vehicleSmallCarPurple;
                                }
                                else if (pss.ID == 3)
                                {
                                    pss.m_vehicleChoice.SetTexture(TextureHandler.vehicleLargeCarYellow);
                                    TextureHandler.player4Vehicle = TextureHandler.vehicleSmallCarYellow;
                                }

                                #endregion
                            }
                            else if (pss.m_choice2Button.Activated(m_lastPosition))
                            {
                                // TODO: Check if the vehicle has already been chosen
                                pss.m_playerState = PlayerState.VEHICLE_SELECTED;

                                #region PickCorrectColour

                                if (pss.ID == 0)
                                {
                                    pss.m_vehicleChoice.SetTexture(TextureHandler.vehicleLargeTractorBlue);
                                    TextureHandler.player1Vehicle = TextureHandler.vehicleSmallTractorBlue;
                                }
                                else if (pss.ID == 1)
                                {
                                    pss.m_vehicleChoice.SetTexture(TextureHandler.vehicleLargeTractorOrange);
                                    TextureHandler.player2Vehicle = TextureHandler.vehicleSmallTractorOrange;
                                }
                                else if (pss.ID == 2)
                                {
                                    pss.m_vehicleChoice.SetTexture(TextureHandler.vehicleLargeTractorPurple);
                                    TextureHandler.player3Vehicle = TextureHandler.vehicleSmallTractorPurple;
                                }
                                else if (pss.ID == 3)
                                {
                                    pss.m_vehicleChoice.SetTexture(TextureHandler.vehicleLargeTractorGreen);
                                    TextureHandler.player4Vehicle = TextureHandler.vehicleSmallTractorGreen;
                                }

                                #endregion
                            }
                            else if (pss.m_choice3Button.Activated(m_lastPosition))
                            {
                                // TODO: Check if the vehicle has already been chosen
                                pss.m_playerState = PlayerState.VEHICLE_SELECTED;

                                #region PickCorrectColour

                                if (pss.ID == 0)
                                {
                                    pss.m_vehicleChoice.SetTexture(TextureHandler.vehicleLargeTankBlue);
                                    TextureHandler.player1Vehicle = TextureHandler.vehicleSmallTankBlue;
                                }
                                else if (pss.ID == 1)
                                {
                                    pss.m_vehicleChoice.SetTexture(TextureHandler.vehicleLargeTankOrange);
                                    TextureHandler.player2Vehicle = TextureHandler.vehicleSmallTankOrange;
                                }
                                else if (pss.ID == 2)
                                {
                                    pss.m_vehicleChoice.SetTexture(TextureHandler.vehicleLargeTankPurple);
                                    TextureHandler.player3Vehicle = TextureHandler.vehicleSmallTankPurple;
                                }
                                else if (pss.ID == 3)
                                {
                                    pss.m_vehicleChoice.SetTexture(TextureHandler.vehicleLargeTankGreen);
                                    TextureHandler.player4Vehicle = TextureHandler.vehicleSmallTankGreen;
                                }

                                #endregion
                            }
                            else if (pss.m_choice4Button.Activated(m_lastPosition))
                            {
                                // TODO: Check if the vehicle has already been chosen
                                pss.m_playerState = PlayerState.VEHICLE_SELECTED;

                                if (pss.ID == 0)
                                {
                                    pss.m_vehicleChoice.SetTexture(TextureHandler.vehicleLargeBuggyBlue);
                                    TextureHandler.player1Vehicle = TextureHandler.vehicleSmallBuggyBlue;
                                }
                                else if (pss.ID == 1)
                                {
                                    pss.m_vehicleChoice.SetTexture(TextureHandler.vehicleLargeBuggyOrange);
                                    TextureHandler.player2Vehicle = TextureHandler.vehicleSmallBuggyOrange;
                                }
                                else if (pss.ID == 2)
                                {
                                    pss.m_vehicleChoice.SetTexture(TextureHandler.vehicleLargeBuggyPurple);
                                    TextureHandler.player3Vehicle = TextureHandler.vehicleSmallBuggyPurple;
                                }
                                else if (pss.ID == 3)
                                {
                                    pss.m_vehicleChoice.SetTexture(TextureHandler.vehicleLargeBuggyYellow);
                                    TextureHandler.player4Vehicle = TextureHandler.vehicleSmallBuggyYellow;
                                }
                            }
                        }
                        else if (pss.m_playerState == PlayerState.VEHICLE_SELECTED)
                        {
                            if (pss.m_actionButton.Activated(m_lastPosition))
                            {
                                pss.m_actionButton.m_sprite.SetTexture(TextureHandler.readySelectedButton);
                                pss.m_playerState = PlayerState.READY;
                            }
                        }
                    }

                    // Check if all players are ready
                    if (m_playerBackButton.Activated(m_lastPosition))
                    {
                        /*// Check if players are ready
                         * if (ready && readyCount > 0) {
                         *  Settings.m_numberOfPlayers = readyCount;
                         *  m_currentExecutionState = ExecutionState.CHANGING;
                         * }*/
                    }
                    if (m_playerGoButton.Activated(m_lastPosition))
                    {
                        bool ready      = true;
                        int  readyCount = 0;

                        // Loop through each player
                        for (int i = 0; i < players.Count; i++)
                        {
                            if (players[i].m_playerState == PlayerState.JOINED || players[i].m_playerState == PlayerState.VEHICLE_SELECTED)
                            {
                                ready = false;
                                // If the player has joined
                                if (players[i].m_playerState == PlayerState.JOINED)
                                {
                                    Settings.m_joinedPlayers[i] = true;
                                }
                            }
                            else if (players[i].m_playerState == PlayerState.READY)
                            {
                                readyCount++;
                            }
                        }
                        if (ready && readyCount > 0)
                        {
                            MediaPlayer.Stop();
                            Settings.m_numberOfPlayers = readyCount;
                            m_currentExecutionState    = ExecutionState.CHANGING;
                        }
                    }

                    break;

                case MenuScreenState.OPTIONS:
                    // Options screen

                    if (m_backButton.Activated(m_lastPosition))
                    {
                        // Go back to Main Menu
                        m_currentScreen = MenuScreenState.MAIN_MENU;
                    }
                    break;

                case MenuScreenState.CONTROLS:
                    // Controls Screen
                    if (m_backButton.Activated(m_lastPosition))
                    {
                        // Go back to the main Menu
                        m_currentScreen = MenuScreenState.MAIN_MENU;
                    }
                    break;

                case MenuScreenState.CREDITS:
                    // Credits screen

                    if (m_MenuButton.Activated(m_lastPosition))
                    {
                        // Go back to Main Menu
                        m_currentScreen = MenuScreenState.MAIN_MENU;
                    }
                    break;
                }
                m_touchState = TouchState.IDLE;
            }
        }
Exemple #6
0
        public override void Update(ref TouchHandler touchHandler_, GameTime gameTime_)
        {
            // Update victory state
            // ================


            // Set cow textures for victory podium
            m_playerFirst.SetTexture(m_players[m_rankings[0] - 1].GetCow().GetTexture());
            if (Settings.m_numberOfPlayers > 1)
            {
                m_playerSecond.SetTexture(m_players[m_rankings[1] - 1].GetCow().GetTexture());
            }
            if (Settings.m_numberOfPlayers > 2)
            {
                m_playerThird.SetTexture(m_players[m_rankings[2] - 1].GetCow().GetTexture());
            }

            // Update touch input handler
            touchHandler_.Update();

            foreach (TouchLocation tl in touchHandler_.GetTouches())
            {
                // TODO: Implement a check to see if the player has released their finger from the screen
                //       perform action when player releases their finger -Dean
            }
            if (touchHandler_.GetTouches().Count > 0)
            {
                m_touchState   = TouchState.TOUCHING;
                m_lastPosition = touchHandler_.GetTouches()[touchHandler_.GetTouches().Count - 1].Position;
            }
            if (touchHandler_.GetTouches().Count == 0 && m_touchState == TouchState.TOUCHING)
            {
                // If play button is pressed, launch back into race
                if (m_Race_Again_Button.Activated(m_lastPosition))
                {
                    m_nextState = GameState.IN_GAME;
                }
                // If Menu button is pressed, go back to the main menu
                if (m_Main_Menu_Button.Activated(m_lastPosition))
                {
                    m_nextState = GameState.MAIN_MENU;
                }
                // Change to the appropriate screen
                m_currentExecutionState = ExecutionState.CHANGING;

                m_touchState = TouchState.IDLE;
            }

            // Isn't used for the victory screen, i think
            // Update sprites
            //        foreach (AnimatedSprite anim in m_animatedSprites) {
            //          // If currently animating
            //            if (anim.GetCurrentState() == 1) {
            //                // Change the frame
            //                if (gameTime_.TotalGameTime.TotalMilliseconds - anim.GetLastTime() > anim.GetFrameTime()) {
            //                    anim.ChangeFrame(gameTime_.TotalGameTime.TotalMilliseconds);
            //                }
            //            }
            //        }

            // Update particles
            //        m_particles = GraphicsHandler.UpdatePFX(gameTime_.ElapsedGameTime.TotalMilliseconds);
        }