Esempio n. 1
0
 public override void Update(GameTime gameTime, KeyboardState ks)
 {
     base.Update(gameTime, ks);
     // If result has finished easing
     if (Vector2.Distance(entities[currentIndex].position, resultPos[currentIndex]) < 1.0f)
     {
         // Last result has been eased
         if (currentIndex == 3)
         {
             // Wait  time after displaying last result
             if (waitTime >= maxWaitTime)
             {
                 S_BonusResults bonusResults = new S_BonusResults(parentManager, xPos, yPos);
                 parentManager.AddStateQueue(bonusResults);
                 this.flagForDeletion = true;
             }
             waitTime++;
         }
         else
         {
             // ease next result
             currentIndex++;
         }
     }
     // Continue to ease the current indexed result
     else
     {
         entities[currentIndex].position.Y = MGP_Tools.Ease(entities[currentIndex].position.Y, resultPos[currentIndex].Y, 0.05f);
     }
 }
Esempio n. 2
0
        public static void Follow_Player(GameStateManager parentManager, Player currPlayer)
        {
            // Move camera to current player
            parentManager.boardGame.cameraProperties.setPos(currPlayer.meeple.pos);

            // Make sure camera is still on the board
            MGP_Tools.KeepCameraOnBoard(parentManager);
        }
Esempio n. 3
0
        // Update:
        public override void Update(GameTime gameTime, KeyboardState ks)
        {
            base.Update(gameTime, ks);

            // Move the player
            if (moveNum > 0)
            {
                // Find next space
                E_Space spaceToMoveTo = currPlayer.currSpace.spacesAhead[0];

                // Move the meeple untill it's close enough to space
                if (Vector2.Distance(spaceToMoveTo.getMeepleLocation(), currPlayer.meeple.getPosCenter()) > 1.0F)
                {
                    float newX = MGP_Tools.Ease(currPlayer.meeple.getPosCenter().X, spaceToMoveTo.getMeepleLocation().X, 0.15F);
                    float newY = MGP_Tools.Ease(currPlayer.meeple.getPosCenter().Y, spaceToMoveTo.getMeepleLocation().Y, 0.15F);
                    currPlayer.meeple.setPos(new Vector2(newX, newY));
                    MGP_Tools.Follow_Player(parentManager, currPlayer);

                    // Play space sound effect:
                    if (!soundPlayed)
                    {
                        parentManager.audioEngine.playSound(MGP_Constants.soundEffects.space, 0.7f);
                        soundPlayed = true;
                    }
                }
                // Meeple has arrived at new space
                else
                {
                    moveNum--;
                    currPlayer.currSpace = spaceToMoveTo;

                    // allow sound to play next time:
                    soundPlayed = false;

                    // If player passes a star
                    if (currPlayer.currSpace.type == Entity.typeSpace.star)
                    {
                        S_BuyStar buyStar = new S_BuyStar(parentManager, 0, 0);
                        parentManager.AddStateQueue(buyStar);
                        this.active = false; //pause moving player
                    }
                }
            }
            // finished moving meeple
            else
            {
                // Occupy that space so another meeple doesn't run him/her over:
                currPlayer.currSpace.occupySpace(currPlayer);

                S_LandAction landAction = new S_LandAction(parentManager, 0, 0);
                parentManager.AddStateQueue(landAction);
                this.flagForDeletion = true;
            }

            // Listen for pausing here:
            ListenPause();
        }
Esempio n. 4
0
        // Update:
        public override void Update(GameTime gameTime, KeyboardState ks)
        {
            base.Update(gameTime, ks);

            // If result has finished easing
            if (Vector2.Distance(entities[currentIndex].position, resultPos[currentIndex]) < 1.0f)
            {
                // Last result has been eased
                if (currentIndex == 3)
                {
                    // Wait  time after displaying last result
                    if (waitTime >= maxWaitTime)
                    {
                        // Begin next round:
                        parentManager.round.currRound++;
                        parentManager.round.playerIsPlaying = false;
                        parentManager.round.roundStart      = true;
                        this.flagForDeletion       = true;
                        parentManager.round.active = true;
                    }
                    else if (!changedLastPlayer)
                    {
                        // update last players coins
                        results[currentIndex].coins += entities[currentIndex].changeValue;

                        // Prevent negative coin values
                        if (results[currentIndex].coins < 0)
                        {
                            results[currentIndex].coins = 0;
                        }

                        changedLastPlayer = true;
                    }
                    waitTime++;
                }
                else
                {
                    // update players coins
                    results[currentIndex].coins += entities[currentIndex].changeValue;

                    // Prevent negative coin values
                    if (results[currentIndex].coins < 0)
                    {
                        results[currentIndex].coins = 0;
                    }

                    // ease next result
                    currentIndex++;
                }
            }
            // Continue to ease the current indexed result
            else
            {
                entities[currentIndex].position.Y = MGP_Tools.Ease(entities[currentIndex].position.Y, resultPos[currentIndex].Y, 0.1f);
            }
        }
Esempio n. 5
0
        public override void Update(GameTime gameTime, KeyboardState ks)
        {
            base.Update(gameTime, ks);

            // Buy the star Or acknowledging they suck and cant buy the star, either way move on
            if (parentManager.km.ActionPressed(KeyboardManager.action.select, KeyboardManager.playerIndex.all) || AI_Timer > 60 || moveYPos > 90)
            {
                // start the animation for getting a star
                if (buystar)
                {
                    startAnimation = true;
                }

                // Finished star animation or couldnt buy star
                if (moveYPos > 90 || !buystar)
                {
                    // Move the star to new space
                    if (buystar)
                    {
                        MGP_Tools.Assign_Star(parentManager.boardGame);
                        parentManager.round.currPlayer.currSpace.type = Entity.typeSpace.chance;
                    }

                    this.flagForDeletion = true;
                    // Start moving the player again
                    parentManager.states.Find(s => s.GetType() == typeof(S_MovePlayer)).active = true;
                }
            }
            // If player is buying star, start animation for buying star
            if (startAnimation)
            {
                moveYPos++;
            }

            // If current play is com, increase AI_Timer
            if (!parentManager.round.currPlayer.isHuman)
            {
                AI_Timer++;
            }
        }
Esempio n. 6
0
        // Update:
        public override void Update(GameTime gameTime, KeyboardState ks)
        {
            base.Update(gameTime, ks);

            // do this at the beginning of every round, but only once:
            if (roundStart)
            {
                // Set the player ui's to white at the beginning of each round:
                foreach (Player p in parentManager.gameOptions.players)
                {
                    p.uiColor = Color.White;
                }

                // switch minigames:
                minigame = (minigame == 0) ? 1 : 0;

                // Queue pirate bay music again:
                parentManager.audioEngine.setNextSong(MGP_Constants.music.pirateBay);
                parentManager.audioEngine.playNextSong(85, true);
                Console.WriteLine("Added pirateBay to music queue");

                // only run once each round:
                roundStart = false;
            }

            // Move camera to player
            MGP_Tools.Follow_Player(parentManager, currPlayer);

            // Start next player's turn
            if (!playerIsPlaying)
            {
                // Last player went. Go to minigame
                if (playerIndex == 4)
                {
                    // Queue minigame music:
                    parentManager.audioEngine.setNextSong(MGP_Constants.music.minigame);
                    parentManager.audioEngine.playNextSong(50, true);

                    S_MinigameInstructions minigameInstructions = new S_MinigameInstructions(parentManager, 0, 0, minigame);
                    parentManager.AddStateQueue(minigameInstructions);
                    playerIndex = 0;    // start with player one when round resumes
                    this.active = false;
                }
                // Start next players turn
                else
                {
                    currPlayer = gameOptions.players[playerIndex];      // set current player
                    MGP_Tools.Follow_Player(parentManager, currPlayer); // move camera to current player

                    // start confirm player state
                    S_ConfirmPlayer confirmPlayer = new S_ConfirmPlayer(parentManager, 0, 0);
                    parentManager.AddStateQueue(confirmPlayer);
                    this.active = false;

                    //set vars for next round
                    playerIndex++;
                    playerIsPlaying = true;
                }
            }

            // Listen for and allow for pauses:
            ListenPause();

            // Update player places:
            updatePlayerPlaces();
        } // end Update method
Esempio n. 7
0
        // Update:
        public override void Update(GameTime gameTime, KeyboardState ks)
        {
            base.Update(gameTime, ks);

            // Move Menu Selection Up:
            if (km.ActionPressed(KeyboardManager.action.up, KeyboardManager.playerIndex.all))
            {
                // SFX:
                parentManager.audioEngine.playSound(MGP_Constants.soundEffects.menuSelect, MGP_Constants.MENU_SFX_VOLUME);

                if (currentMenuItem == 1)
                {
                    currentMenuItem = 0;
                    moveGlove       = true;
                }
            }

            // Move Menu Selection Down:
            if (km.ActionPressed(KeyboardManager.action.down, KeyboardManager.playerIndex.all))
            {
                // SFX:
                parentManager.audioEngine.playSound(MGP_Constants.soundEffects.menuSelect, MGP_Constants.MENU_SFX_VOLUME);

                if (currentMenuItem == 0)
                {
                    currentMenuItem = 1;
                    moveGlove       = true;
                }
            }

            // Press ENTER while some menu item is highlighted:
            if (km.ActionPressed(KeyboardManager.action.select, KeyboardManager.playerIndex.all))
            {
                // SFX:
                parentManager.audioEngine.playSound(MGP_Constants.soundEffects.diceHit, MGP_Constants.MENU_SFX_VOLUME + 0.15f);

                // One Player
                if (currentMenuItem == 0)
                {
                    parentManager.gameOptions.numPlayers = 1;
                    S_CharacterMenu characterMenu = new S_CharacterMenu(parentManager, 0, 0);
                    parentManager.AddStateQueue(characterMenu);
                    this.flagForDeletion = true;
                }

                //Two Players
                if (currentMenuItem == 1)
                {
                    parentManager.gameOptions.numPlayers = 2;
                    S_CharacterMenu characterMenu = new S_CharacterMenu(parentManager, 0, 0);
                    parentManager.AddStateQueue(characterMenu);
                    this.flagForDeletion = true;
                }
            }

            // Press Cancel Key: Goes back to main menu:
            if (km.ActionPressed(KeyboardManager.action.cancel, KeyboardManager.playerIndex.all))
            {
                // SFX:
                parentManager.audioEngine.playSound(MGP_Constants.soundEffects.menuCancel, MGP_Constants.MENU_SFX_VOLUME);

                S_MainMenu mainMenu = new S_MainMenu(parentManager, 0, 0);
                parentManager.AddStateQueue(mainMenu);
                this.flagForDeletion = true;
            }

            // Move glove
            if (moveGlove)
            {
                if (Vector2.Distance(glovePos, new Vector2(items[currentMenuItem].xPos - 60, items[currentMenuItem].yPos - 35)) < 1.0f)
                {
                    moveGlove = false;
                }
                else
                {
                    glovePos.Y = MGP_Tools.Ease(glovePos.Y, items[currentMenuItem].yPos - 35, 0.5f);
                }
            }
        } // End update
Esempio n. 8
0
        // Update:
        public override void Update(GameTime gameTime, KeyboardState ks)
        {
            base.Update(gameTime, ks);

            // Move Menu Selection Up:
            if (km.ActionPressed(KeyboardManager.action.up, KeyboardManager.playerIndex.all))
            {
                // SFX:
                parentManager.audioEngine.playSound(MGP_Constants.soundEffects.menuSelect, MGP_Constants.MENU_SFX_VOLUME);

                currentMenuItem = items[currentMenuItem].above.activeValue;
                moveGlove       = true;
            }

            // Move Menu Selection Down:
            if (km.ActionPressed(KeyboardManager.action.down, KeyboardManager.playerIndex.all))
            {
                // SFX:
                parentManager.audioEngine.playSound(MGP_Constants.soundEffects.menuSelect, MGP_Constants.MENU_SFX_VOLUME);

                currentMenuItem = items[currentMenuItem].below.activeValue;
                moveGlove       = true;
            }

            // Move glove
            if (moveGlove)
            {
                if (Vector2.Distance(glovePos, new Vector2(items[currentMenuItem].xPos - 60, items[currentMenuItem].yPos - 35)) < 1.0f)
                {
                    moveGlove = false;
                }
                else
                {
                    glovePos.Y = MGP_Tools.Ease(glovePos.Y, items[currentMenuItem].yPos - 35, 0.5f);
                }
            }

            // Press ENTER while some menu item is highlighted:
            if (km.ActionPressed(KeyboardManager.action.select, KeyboardManager.playerIndex.all))
            {
                // SFX:
                parentManager.audioEngine.playSound(MGP_Constants.soundEffects.diceHit, MGP_Constants.MENU_SFX_VOLUME + 0.15f);

                // Difficulty: Easy
                if (currentMenuItem == (int)MenuItem.Difficulty.EASY)
                {
                    parentManager.gameOptions.difficulty = MenuItem.Difficulty.EASY;
                }

                // Difficulty: Medium
                if (currentMenuItem == (int)MenuItem.Difficulty.MEDIUM)
                {
                    parentManager.gameOptions.difficulty = MenuItem.Difficulty.MEDIUM;
                }

                // Difficulty: Medium
                if (currentMenuItem == (int)MenuItem.Difficulty.HARD)
                {
                    parentManager.gameOptions.difficulty = MenuItem.Difficulty.HARD;
                }

                // Go to next menu
                S_NumRoundsMenu numRoundsMenu = new S_NumRoundsMenu(parentManager, 0, 0);
                parentManager.AddStateQueue(numRoundsMenu);
                this.flagForDeletion = true;
            }

            // Press Cancel Key: Goes back to Player Count menu:
            if (km.ActionPressed(KeyboardManager.action.cancel, KeyboardManager.playerIndex.all))
            {
                // SFX:
                parentManager.audioEngine.playSound(MGP_Constants.soundEffects.menuCancel, MGP_Constants.MENU_SFX_VOLUME);

                S_PlayerCountMenu playerCountMenu = new S_PlayerCountMenu(parentManager, 0, 0);
                parentManager.AddStateQueue(playerCountMenu);
                this.flagForDeletion = true;
            }
        }
Esempio n. 9
0
        // Update:
        public override void Update(GameTime gameTime, KeyboardState ks)
        {
            base.Update(gameTime, ks);

            if (rollTime == 60 / ROLL_SPEED && isRolling) // update according to roll speed
            {
                rollTime = 0;
                dice.Update(gameTime, ks);

                // if comp is rolling
                if (!currPlayer.isHuman)
                {
                    compRollBegin++;
                }
            }
            else
            {
                rollTime++;
            }

            // Allow the transition to run after select is pressed jsut once
            if (km.ActionPressed(KeyboardManager.action.select, KeyboardManager.playerIndex.one) && currPlayer.isHuman == true)
            {
                playerSelected = true;
            }


            // If human wait till select is pressed. If computer, wait till comp roll ends
            if (playerSelected || compRollBegin == compRollEnd)
            {
                isRolling = false;

                // move meeple up
                if (!bounceUp)
                {
                    if (Vector2.Distance(currPlayer.meeple.pos, dice.pos) <= 50.0f)
                    {
                        bounceUp = true;    // stop moving up

                        // play hit sound effect just once:
                        parentManager.audioEngine.playSound(MGP_Constants.soundEffects.diceHit, 0.8f);
                    }
                    else
                    {
                        currPlayer.meeple.pos.Y = MGP_Tools.Ease(currPlayer.meeple.pos.Y, dice.pos.Y, 0.1f);
                    }
                }
                // move meeple back down
                else if (bounceUp && !bounceDown)
                {
                    if (Vector2.Distance(currPlayer.meeple.getPosCenter(), currPlayer.currSpace.getPosCenter()) <= 10.0f)
                    {
                        bounceDown = true;  // stop moving down
                    }
                    else
                    {
                        currPlayer.meeple.pos.Y = MGP_Tools.Ease(currPlayer.meeple.pos.Y, currPlayer.currSpace.pos.Y, 0.05f);
                    }
                }
                // transistions are finished
                else if (bounceUp && bounceDown)
                {
                    // wait 1/4 of a sec before the meeple starts moving spaces
                    if (waitTime >= 15)
                    {
                        // Start moving the player based on the roll
                        S_MovePlayer movePlayer = new S_MovePlayer(parentManager, 0, 0, parentManager.boardGame.testDice.diceRoll);
                        parentManager.AddStateQueue(movePlayer);
                        this.flagForDeletion = true;
                    }
                    waitTime++;
                }
            } // end if

            // Listen for and allow a pause
            ListenPause();


            // Rolling Sound Effect:
            if (isRolling)
            {
                rollingSoundCounter--;
                if (rollingSoundCounter <= 0)
                {
                    rollingSoundCounter = ROLL_SOUND_LEN;
                    parentManager.audioEngine.playSound(MGP_Constants.soundEffects.diceRolling, 0.4f);
                }
            }
        } // end update
Esempio n. 10
0
        // Update:
        public override void Update(GameTime gameTime, KeyboardState ks)
        {
            base.Update(gameTime, ks);

            // Move Menu Selection Up:
            if (km.ActionPressed(KeyboardManager.action.up, KeyboardManager.playerIndex.all))
            {
                // SFX:
                parentManager.audioEngine.playSound(MGP_Constants.soundEffects.menuSelect, MGP_Constants.MENU_SFX_VOLUME);

                if (currentMenuItem == 1)
                {
                    currentMenuItem = 0;
                }
                moveGlove = true;
            }

            // Move Menu Selection Down:
            if (km.ActionPressed(KeyboardManager.action.down, KeyboardManager.playerIndex.all))
            {
                // SFX:
                parentManager.audioEngine.playSound(MGP_Constants.soundEffects.menuSelect, MGP_Constants.MENU_SFX_VOLUME);

                if (currentMenuItem == 0)
                {
                    currentMenuItem = 1;
                }
                moveGlove = true;
            }

            // Move glove
            if (moveGlove)
            {
                if (Vector2.Distance(glovePos, new Vector2(items[currentMenuItem].xPos - 60, items[currentMenuItem].yPos - 35)) < 1.0f)
                {
                    moveGlove = false;
                }
                else
                {
                    glovePos.Y = MGP_Tools.Ease(glovePos.Y, items[currentMenuItem].yPos - 35, 0.5f);
                }
            }

            // Press ENTER while some menu item is highlighted:
            if (km.ActionPressed(KeyboardManager.action.select, KeyboardManager.playerIndex.all))
            {
                // SFX:
                parentManager.audioEngine.playSound(MGP_Constants.soundEffects.diceHit, MGP_Constants.MENU_SFX_VOLUME + 0.15f);

                // Allow Bonuses
                if (currentMenuItem == 0)
                {
                    parentManager.gameOptions.allowBonus = true;
                }

                // No Bonuses
                if (currentMenuItem == 1)
                {
                    parentManager.gameOptions.allowBonus = false;
                }


                // DEBUG: PRINT GAME OPTIONS
                Console.WriteLine("Map: " + parentManager.gameOptions.mapName +
                                  "\nPlayer Count: " + parentManager.gameOptions.numPlayers);
                int x = 1;
                foreach (Player player in parentManager.gameOptions.players)
                {
                    Console.WriteLine("Character " + x + ": " + player.type);
                    x++;
                }
                Console.WriteLine("Difficulty: " + parentManager.gameOptions.difficulty +
                                  "\nRound Count: " + parentManager.gameOptions.numRounds +
                                  "\nAllow Bonuses: " + parentManager.gameOptions.allowBonus + "\n");



                // Start game based on game options from here.
                S_Board board = new B_PirateBay(parentManager, 0, 0);
                parentManager.AddStateQueue(board);

                // Add UI to game:
                board.playerUI = new S_PlayerUI(parentManager, 0, 0);
                parentManager.AddStateQueue(board.playerUI);

                this.flagForDeletion = true;
            }

            // Press Cancel Key: Goes back one menu:
            if (km.ActionPressed(KeyboardManager.action.cancel, KeyboardManager.playerIndex.all))
            {
                // SFX:
                parentManager.audioEngine.playSound(MGP_Constants.soundEffects.menuCancel, MGP_Constants.MENU_SFX_VOLUME);

                S_NumRoundsMenu numRoundsMenu = new S_NumRoundsMenu(parentManager, 0, 0);
                parentManager.AddStateQueue(numRoundsMenu);
                this.flagForDeletion = true;
            }
        }
Esempio n. 11
0
        } // end constructor

        public override void Update(GameTime gameTime, KeyboardState ks)
        {
            base.Update(gameTime, ks);


            // DEBUG: Cancel out:
            if (km.ActionPressed(KeyboardManager.action.cancel, KeyboardManager.playerIndex.all))
            {
                closeChanceTime();
            }


            // HUMAN CONTROLS:
            // Hit dices #1, #2, and #3
            if (km.ActionPressed(KeyboardManager.action.select, p.playerControlsIndex) && p.isHuman == true)
            {
                diceNum++;
                hit = true;
            } // end if pressed and human



            // AI SCRIPTING:
            if (!p.isHuman)
            {
                this.aiTimer++;
                if (aiTimer >= this.aiHitTime)
                {
                    diceNum++; // Next die

                    // reset timer and new timer window:
                    this.aiHitTime = parentManager.random.Next(AI_HIT_TIMER_MIN, AI_HIT_TIMER_MAX);
                    aiTimer        = 0;
                    hit            = true;
                }
            }


            if (hit)
            {
                // LEFT die (player) --------------------------------------------
                if (diceNum == 1)
                {
                    suspenseLevel += 0.2f;
                    delayDrum      = (int)(delayDrum * 0.75);
                    delayString    = (int)(delayString * 0.75);

                    // left block chosen, other blocks faster now:
                    leftBlock.hitBlock();
                    leftBlock.newBlockColor(Color.Tan);
                    leftPlayer = leftBlock.getCurrentPlayer(); // get the left chosen player
                    leftBlock.newHighlightColor(leftPlayer.characterColor);
                    middleBlock.increaseFaceChangeSpeed(0.6f);
                    rightBlock.increaseFaceChangeSpeed(0.6f);
                    rightBlock.removePlayerFace(leftPlayer); // REMOVE THIS PLAYER FROM RIGHT BLOCK

                    // Create player meeple:
                    leftMeeple = new E_Meeple(parentManager, leftMeepleStartPos, leftPlayer.type);
                    leftMeeple.setPos(leftMeepleStartPos);
                    leftMeeple.drawToScreen = true; // draw coordinates directly on screen
                    leftMeepleMove          = true;

                    // Play SFX for finished!
                    parentManager.audioEngine.playSound(MGP_Constants.soundEffects.diceRolling, 0.35f);
                }

                // RIGHT die (player) --------------------------------------------
                else if (diceNum == 2)
                {
                    suspenseLevel += 0.2f;
                    delayDrum      = (int)(delayDrum * 0.75);
                    delayString    = (int)(delayString * 0.75);

                    rightBlock.hitBlock();
                    rightBlock.newBlockColor(Color.Tan);
                    rightPlayer = rightBlock.getCurrentPlayer(); // get the right chosen player
                    rightBlock.newHighlightColor(rightPlayer.characterColor);
                    middleBlock.increaseFaceChangeSpeed(0.6f);

                    // Create player meeple:
                    rightMeeple = new E_Meeple(parentManager, rightMeepleStartPos, rightPlayer.type);
                    rightMeeple.setPos(rightMeepleStartPos);
                    rightMeeple.drawToScreen = true; // draw coordinates directly on screen
                    rightMeepleMove          = true;

                    // Play SFX for finished!
                    parentManager.audioEngine.playSound(MGP_Constants.soundEffects.diceRolling, 0.35f);
                }

                // MIDDLE die (condition) ----------------------------------------
                else
                {
                    middleBlock.newBlockColor(Color.Tan);
                    middleBlock.newHighlightColor(Color.Yellow);
                    finishTransition = true;
                    middleBlock.hitBlock();
                    chanceEvent = middleBlock.getCurrentCondition(); // get the right chosen player

                    // Play SFX for finished!
                    parentManager.audioEngine.playSound(MGP_Constants.soundEffects.chanceTimeCymbal, 1.0f);
                }
                hit = false;
            } // end if hit


            // EASE the left meeple to his spot for shame:
            if (leftMeepleMove)
            {
                if (Vector2.Distance(leftMeeple.getPos(), leftMeepleEndPos) > 1.0F)
                {
                    float newX = MGP_Tools.Ease(leftMeeple.getPos().X, leftMeepleEndPos.X, 0.15F);
                    float newY = MGP_Tools.Ease(leftMeeple.getPos().Y, leftMeepleEndPos.Y, 0.15F);
                    leftMeeple.setPos(new Vector2(newX, newY));
                }
            }

            // EASE the right meeple to his spot for shame:
            if (rightMeepleMove)
            {
                if (Vector2.Distance(rightMeeple.getPos(), RightMeepleEndPos) > 1.0F)
                {
                    float newX = MGP_Tools.Ease(rightMeeple.getPos().X, RightMeepleEndPos.X, 0.15F);
                    float newY = MGP_Tools.Ease(rightMeeple.getPos().Y, RightMeepleEndPos.Y, 0.15F);
                    rightMeeple.setPos(new Vector2(newX, newY));
                }
            }


            // THE EVENT WAS CHOSEN, IT MUUUUST BE DONEEEE AHAHAHAHHAA:
            if (finishTransition && !implementedEvent)
            {
                int amount = 0;
                switch (chanceEvent)
                {
                // COINS
                case condition.leftCoin10:

                    amount = 10;
                    if (rightPlayer.coins < amount)
                    {
                        amount = rightPlayer.coins;
                    }

                    leftPlayer.coins            += amount;
                    leftPlayer.totalCoinsGained += amount;
                    rightPlayer.coins            = MGP_Tools.NonNegSub(rightPlayer.coins, amount);
                    rightPlayer.totalCoinsLost  += amount;
                    break;

                case condition.leftCoin20:
                    amount = 20;
                    if (rightPlayer.coins < amount)
                    {
                        amount = rightPlayer.coins;
                    }

                    leftPlayer.coins            += amount;
                    leftPlayer.totalCoinsGained += amount;
                    rightPlayer.coins            = MGP_Tools.NonNegSub(rightPlayer.coins, amount);
                    rightPlayer.totalCoinsLost  += amount;
                    break;

                case condition.leftCoin30:
                    amount = 30;
                    if (rightPlayer.coins < amount)
                    {
                        amount = rightPlayer.coins;
                    }

                    leftPlayer.coins            += amount;
                    leftPlayer.totalCoinsGained += amount;
                    rightPlayer.coins            = MGP_Tools.NonNegSub(rightPlayer.coins, amount);
                    rightPlayer.totalCoinsLost  += amount;
                    break;

                case condition.rightCoin10:
                    amount = 10;
                    if (leftPlayer.coins < amount)
                    {
                        amount = leftPlayer.coins;
                    }

                    rightPlayer.coins            += amount;
                    rightPlayer.totalCoinsGained += amount;
                    leftPlayer.coins              = MGP_Tools.NonNegSub(leftPlayer.coins, amount);
                    leftPlayer.totalCoinsLost    += amount;
                    break;

                case condition.rightCoin20:
                    amount = 20;
                    if (leftPlayer.coins < amount)
                    {
                        amount = leftPlayer.coins;
                    }

                    rightPlayer.coins            += amount;
                    rightPlayer.totalCoinsGained += amount;
                    leftPlayer.coins              = MGP_Tools.NonNegSub(leftPlayer.coins, amount);
                    leftPlayer.totalCoinsLost    += amount;
                    break;

                case condition.rightCoin30:
                    amount = 30;
                    if (leftPlayer.coins < amount)
                    {
                        amount = leftPlayer.coins;
                    }

                    rightPlayer.coins            += amount;
                    rightPlayer.totalCoinsGained += amount;
                    leftPlayer.coins              = MGP_Tools.NonNegSub(leftPlayer.coins, amount);
                    leftPlayer.totalCoinsLost    += amount;
                    break;

                // STARS
                case condition.rightStar1:
                    amount = 1;
                    if (leftPlayer.stars < amount)
                    {
                        amount = leftPlayer.stars;
                    }

                    leftPlayer.stars   = MGP_Tools.NonNegSub(leftPlayer.stars, amount);
                    rightPlayer.stars += amount;
                    break;

                case condition.rightStar2:
                    amount = 2;
                    if (leftPlayer.stars < amount)
                    {
                        amount = leftPlayer.stars;
                    }

                    leftPlayer.stars   = MGP_Tools.NonNegSub(leftPlayer.stars, amount);
                    rightPlayer.stars += amount;
                    break;

                case condition.leftStar1:
                    amount = 1;
                    if (rightPlayer.stars < amount)
                    {
                        amount = rightPlayer.stars;
                    }

                    rightPlayer.stars = MGP_Tools.NonNegSub(rightPlayer.stars, amount);
                    leftPlayer.stars += amount;
                    break;

                case condition.leftStar2:
                    amount = 2;
                    if (rightPlayer.stars < amount)
                    {
                        amount = rightPlayer.stars;
                    }

                    rightPlayer.stars = MGP_Tools.NonNegSub(rightPlayer.stars, amount);
                    leftPlayer.stars += amount;
                    break;

                // SWAPS:
                case condition.swapCoins:
                    int leftCoins  = leftPlayer.coins;
                    int rightCoins = rightPlayer.coins;

                    leftPlayer.coins  = rightCoins;
                    rightPlayer.coins = leftCoins;

                    if (leftCoins < rightCoins)
                    {
                        rightPlayer.totalCoinsLost += (rightCoins - leftCoins);
                    }
                    else if (rightCoins < leftCoins)
                    {
                        leftPlayer.totalCoinsLost += (leftCoins - rightCoins);
                    }
                    break;

                case condition.swapStars:
                    int leftStars  = leftPlayer.stars;
                    int rightStars = rightPlayer.stars;

                    leftPlayer.stars  = rightStars;
                    rightPlayer.stars = leftStars;
                    break;

                // BOTH LOSE:
                case condition.bothLoseCoin10:
                    leftPlayer.coins            = MGP_Tools.NonNegSub(leftPlayer.coins, 10);
                    leftPlayer.totalCoinsLost  += 10;
                    rightPlayer.coins           = MGP_Tools.NonNegSub(rightPlayer.coins, 10);
                    rightPlayer.totalCoinsLost += 10;
                    break;

                case condition.bothLoseCoin20:
                    leftPlayer.coins            = MGP_Tools.NonNegSub(leftPlayer.coins, 20);
                    leftPlayer.totalCoinsLost  += 20;
                    rightPlayer.coins           = MGP_Tools.NonNegSub(rightPlayer.coins, 20);
                    rightPlayer.totalCoinsLost += 20;
                    break;

                case condition.bothLoseCoin30:
                    leftPlayer.coins            = MGP_Tools.NonNegSub(leftPlayer.coins, 30);
                    leftPlayer.totalCoinsLost  += 30;
                    rightPlayer.coins           = MGP_Tools.NonNegSub(rightPlayer.coins, 30);
                    rightPlayer.totalCoinsLost += 30;
                    break;

                case condition.bothLoseStar:
                    leftPlayer.stars  = MGP_Tools.NonNegSub(leftPlayer.stars, 1);
                    rightPlayer.stars = MGP_Tools.NonNegSub(rightPlayer.stars, 1);
                    break;

                // BOTH WIN:
                case condition.bothGainCoin20:
                    leftPlayer.coins             += 20;
                    leftPlayer.totalCoinsGained  += 20;
                    rightPlayer.coins            += 20;
                    rightPlayer.totalCoinsGained += 20;
                    break;

                case condition.bothGainStar:
                    leftPlayer.stars  += 1;
                    rightPlayer.stars += 1;
                    break;

                default:
                    Console.WriteLine("Error, default value in S_ChanceTime for implementedEvent");
                    break;
                } // end switch

                implementedEvent = true;
            } // finish implementation


            // Give the player time to celebrate/grieve their gains/losses:
            if (finishTransition)
            {
                finishTimer++;
                if (finishTimer >= FINISH_TIMER_COMPLETE)
                {
                    closeChanceTime();
                }
            }


            // Update Dice Entities:
            if (!finishTransition)
            {
                leftBlock.Update(gameTime, ks);
                middleBlock.Update(gameTime, ks);
                rightBlock.Update(gameTime, ks);
            }



            // ------------------ Music designed algorithmically with SFX: --------------------------------
            if (!finishTransition)
            {
                musicCounter++;

                // Drum:
                if (musicCounter % delayDrum == 0)
                {
                    parentManager.audioEngine.playSound(MGP_Constants.soundEffects.chanceTimeDrum, drumVolume + suspenseLevel);
                }

                // String:
                if (musicCounter % delayString == 0)
                {
                    if (this.highString)
                    {
                        parentManager.audioEngine.playSound(MGP_Constants.soundEffects.chanceTimeHigh, 0.4f + suspenseLevel);
                        this.highString = false;
                    }
                    else
                    {
                        parentManager.audioEngine.playSound(MGP_Constants.soundEffects.chanceTimeLow, 0.4f + suspenseLevel);
                        this.highString = true;
                    }
                }

                // change accent if needed:
                if (musicCounter % DRUM_ACCENT == 0)
                {
                    drumVolume = DRUM_ACCENT_VOLUME;
                }
                else
                {
                    drumVolume = DRUM_NORMAL_VOLUME;
                }
            }
            // ------------------------------------ END PROGRAMATIC MUSIC ------------------------------
        } // end update
Esempio n. 12
0
        public override void Update(GameTime gameTime, KeyboardState ks)
        {
            base.Update(gameTime, ks);

            if (timer >= maxTime && !animation)
            {
                // Move onto final results
                if (textIndex == text.Count - 1)
                {
                    S_FinalResults finalResults = new S_FinalResults(parentManager, xPos, yPos);
                    parentManager.AddStateQueue(finalResults);
                    this.flagForDeletion = true;
                }
                // Show next text
                else
                {
                    textIndex++;
                    timer = 0;
                }
            }
            // Start animation
            else if (textIndex == 2 || textIndex == 4)
            {
                if (textIndex == 2)
                {
                    winnerIndex = minigameWinnerIndex;
                }
                else
                {
                    winnerIndex = mostCoinsWinnerIndex;
                }
                animation = true;

                // move the player towards center
                if (!movedPlayer)
                {
                    if (Vector2.Distance(currMeeplePos[winnerIndex], awardPos) < 5.0f)
                    {
                        movedPlayer = true;
                        timer       = 0;
                    }
                    else
                    {
                        Vector2 temp = currMeeplePos[winnerIndex];
                        temp.X = MGP_Tools.Ease(currMeeplePos[winnerIndex].X, awardPos.X, 0.05f);
                        temp.Y = MGP_Tools.Ease(currMeeplePos[winnerIndex].Y, awardPos.Y, 0.05f);
                        currMeeplePos[winnerIndex] = new Vector2(temp.X, temp.Y);
                    }
                }
                // move the star
                else if (!movedStar)
                {
                    if (Math.Abs(curStarPos.Y - starAwardPos.Y) < 10 && timer > maxTime)
                    {
                        movedStar = true;
                    }
                    else
                    {
                        curStarPos.Y = (int)MGP_Tools.Ease(curStarPos.Y, starAwardPos.Y, 0.1f);
                    }
                }

                // move player back
                else
                {
                    // move star back up
                    curStarPos = origStarPos;

                    // Finished all animations
                    if (Vector2.Distance(currMeeplePos[winnerIndex], origMeeplePos[winnerIndex]) < 5.0f)
                    {
                        animation   = false;
                        movedStar   = false;
                        movedPlayer = false;
                    }
                    // ease player back to orig spot
                    else
                    {
                        Vector2 temp = currMeeplePos[winnerIndex];
                        temp.X = MGP_Tools.Ease(currMeeplePos[winnerIndex].X, origMeeplePos[winnerIndex].X, 0.1f);
                        temp.Y = MGP_Tools.Ease(currMeeplePos[winnerIndex].Y, origMeeplePos[winnerIndex].Y, 0.1f);
                        currMeeplePos[winnerIndex] = new Vector2(temp.X, temp.Y);
                    }
                } // End of moving player back
            }     // End of animation

            // Spin the star!
            if (timer % 30 < 6)
            {
                starIndex = 0;
            }
            else if (timer % 30 >= 6 && timer % 30 < 12)
            {
                starIndex = 1;
            }
            else if (timer % 30 >= 12 && timer % 30 < 18)
            {
                starIndex = 2;
            }
            else if (timer % 30 >= 18 && timer % 30 < 24)
            {
                starIndex = 3;
            }
            else
            {
                starIndex = 4;
            }


            timer++;
        }
Esempio n. 13
0
        // Update:
        public override void Update(GameTime gameTime, KeyboardState ks)
        {
            base.Update(gameTime, ks);

            // Move Menu Selection Up:
            if (km.ActionPressed(KeyboardManager.action.up, KeyboardManager.playerIndex.all))
            {
                // SFX:
                parentManager.audioEngine.playSound(MGP_Constants.soundEffects.menuSelect, MGP_Constants.MENU_SFX_VOLUME);

                currentMenuItem = items[currentMenuItem].above.activeValue;
                moveGlove       = true;
            }

            // Move Menu Selection Down:
            if (km.ActionPressed(KeyboardManager.action.down, KeyboardManager.playerIndex.all))
            {
                // SFX:
                parentManager.audioEngine.playSound(MGP_Constants.soundEffects.menuSelect, MGP_Constants.MENU_SFX_VOLUME);

                currentMenuItem = items[currentMenuItem].below.activeValue;
                moveGlove       = true;
            }

            // Move glove
            if (moveGlove)
            {
                if (Vector2.Distance(glovePos, new Vector2(items[currentMenuItem].xPos - 60, items[currentMenuItem].yPos - 35)) < 1.0f)
                {
                    moveGlove = false;
                }
                else
                {
                    glovePos.Y = MGP_Tools.Ease(glovePos.Y, items[currentMenuItem].yPos - 35, 0.5f);
                }
            }

            // Press ENTER while some menu item is highlighted:
            if (km.ActionPressed(KeyboardManager.action.select, KeyboardManager.playerIndex.all))
            {
                // SFX:
                parentManager.audioEngine.playSound(MGP_Constants.soundEffects.diceHit, MGP_Constants.MENU_SFX_VOLUME + 0.15f);

                // Seven Rounds Selected
                if (currentMenuItem == 0)
                {
                    parentManager.gameOptions.numRounds = 7;
                }
                //parentManager.gameOptions.numRounds = 1; // DEBUG DEBUG DEBUG DEBUG DEBUG

                // Twelve Rounds Selected
                else if (currentMenuItem == 1)
                {
                    parentManager.gameOptions.numRounds = 12;
                }

                // Twenty Rounds Selected
                else
                {
                    parentManager.gameOptions.numRounds = 20;
                }

                // Go to next menu
                S_BonusMenu bonusMenu = new S_BonusMenu(parentManager, 0, 0);
                parentManager.AddStateQueue(bonusMenu);
                this.flagForDeletion = true;
            }

            // Press Cancel Key: Goes back to difficulty menu:
            if (km.ActionPressed(KeyboardManager.action.cancel, KeyboardManager.playerIndex.all))
            {
                // SFX:
                parentManager.audioEngine.playSound(MGP_Constants.soundEffects.menuCancel, MGP_Constants.MENU_SFX_VOLUME);

                S_DifficultyMenu difficultyMenu = new S_DifficultyMenu(parentManager, 0, 0);
                parentManager.AddStateQueue(difficultyMenu);
                this.flagForDeletion = true;
            }
        }
Esempio n. 14
0
        // Collection of Spaces:
        //public List<E_Space> spaces;

        // Constructor:
        public B_PirateBay(GameStateManager creator, float xPos, float yPos) : base(creator, xPos, yPos)
        {
            // --------------------------- Create Spaces: ----------------------------------
            // initialize list of spaces:
            spaces = new List <E_Space>();
            E_Space curSpace;
            E_Space prevSpace;

            // STARTING WITH BOTTOM RIGHT
            // <<---- MOVING LEFT NOW: ----->>
            // Bottom right space:
            curSpace = new E_Space(this, GetTilePosCenter(21, 16), Entity.typeSpace.blue);
            curSpace.setOverlapPositions(E_Space.direction.left);
            spaces.Add(curSpace);
            this.startingSpace = curSpace; // STARTING SPACE
            prevSpace          = curSpace;



            // 20, 16
            // Blue
            curSpace = new E_Space(this, GetTilePosCenter(20, 16), Entity.typeSpace.blue);
            curSpace.setOverlapPositions(E_Space.direction.left);
            spaces.Add(curSpace); // add to overall list
            curSpace.assignSpaces(prevSpace);
            prevSpace = curSpace;

            // 19, 16
            // Blue
            curSpace = new E_Space(this, GetTilePosCenter(19, 16), Entity.typeSpace.blue);
            curSpace.setOverlapPositions(E_Space.direction.left);
            spaces.Add(curSpace); // add to overall list
            curSpace.assignSpaces(prevSpace);
            prevSpace = curSpace;

            // 17, 16
            // Red
            curSpace = new E_Space(this, GetTilePosCenter(17, 16), Entity.typeSpace.red);
            curSpace.setOverlapPositions(E_Space.direction.left);
            spaces.Add(curSpace); // add to overall list
            curSpace.assignSpaces(prevSpace);
            prevSpace = curSpace;

            // 16, 15
            // Blue
            curSpace = new E_Space(this, GetTilePosCenter(16, 15), Entity.typeSpace.blue);
            curSpace.setOverlapPositions(E_Space.direction.left);
            spaces.Add(curSpace); // add to overall list
            curSpace.assignSpaces(prevSpace);
            prevSpace = curSpace;

            // 15, 15
            // Blue
            curSpace = new E_Space(this, GetTilePosCenter(15, 15), Entity.typeSpace.blue);
            curSpace.setOverlapPositions(E_Space.direction.left);
            spaces.Add(curSpace); // add to overall list
            curSpace.assignSpaces(prevSpace);
            prevSpace = curSpace;

            // 14, 15
            // Red
            curSpace = new E_Space(this, GetTilePosCenter(14, 15), Entity.typeSpace.red);
            curSpace.setOverlapPositions(E_Space.direction.left);
            spaces.Add(curSpace); // add to overall list
            curSpace.assignSpaces(prevSpace);
            prevSpace = curSpace;

            // 12, 15
            // Blue
            curSpace = new E_Space(this, GetTilePosCenter(12, 15), Entity.typeSpace.blue);
            curSpace.setOverlapPositions(E_Space.direction.left);
            spaces.Add(curSpace); // add to overall list
            curSpace.assignSpaces(prevSpace);
            prevSpace = curSpace;

            // 12, 16
            // Blue
            curSpace = new E_Space(this, GetTilePosCenter(12, 16), Entity.typeSpace.blue);
            curSpace.setOverlapPositions(E_Space.direction.left);
            spaces.Add(curSpace); // add to overall list
            curSpace.assignSpaces(prevSpace);
            prevSpace = curSpace;

            // 10, 16
            curSpace = new E_Space(this, GetTilePosCenter(10, 16), Entity.typeSpace.red);
            curSpace.setOverlapPositions(E_Space.direction.left);
            spaces.Add(curSpace); // add to overall list
            curSpace.assignSpaces(prevSpace);
            prevSpace = curSpace;

            // 7, 16
            curSpace = new E_Space(this, GetTilePosCenter(7, 16), Entity.typeSpace.blue);
            curSpace.setOverlapPositions(E_Space.direction.left);
            spaces.Add(curSpace); // add to overall list
            curSpace.assignSpaces(prevSpace);
            prevSpace = curSpace;

            // 6, 16 CHANCE TIME
            curSpace = new E_Space(this, GetTilePosCenter(6, 16), Entity.typeSpace.chance);
            curSpace.setOverlapPositions(E_Space.direction.left);
            spaces.Add(curSpace); // add to overall list
            curSpace.assignSpaces(prevSpace);
            prevSpace = curSpace;


            // <<---- MOVING UP NOW: ----->>
            // 6, 15
            curSpace = new E_Space(this, GetTilePosCenter(6, 15), Entity.typeSpace.blue);
            curSpace.setOverlapPositions(E_Space.direction.up);
            spaces.Add(curSpace); // add to overall list
            curSpace.assignSpaces(prevSpace);
            prevSpace = curSpace;

            // 6, 13
            curSpace = new E_Space(this, GetTilePosCenter(6, 13), Entity.typeSpace.red);
            curSpace.setOverlapPositions(E_Space.direction.up);
            spaces.Add(curSpace); // add to overall list
            curSpace.assignSpaces(prevSpace);
            prevSpace = curSpace;

            // 6, 10
            curSpace = new E_Space(this, GetTilePosCenter(6, 10), Entity.typeSpace.blue);
            curSpace.setOverlapPositions(E_Space.direction.up);
            spaces.Add(curSpace); // add to overall list
            curSpace.assignSpaces(prevSpace);
            prevSpace = curSpace;

            // 6, 9
            curSpace = new E_Space(this, GetTilePosCenter(6, 9), Entity.typeSpace.blue);
            curSpace.setOverlapPositions(E_Space.direction.up);
            spaces.Add(curSpace); // add to overall list
            curSpace.assignSpaces(prevSpace);
            prevSpace = curSpace;

            // 4, 9
            curSpace = new E_Space(this, GetTilePosCenter(4, 9), Entity.typeSpace.blue);
            curSpace.setOverlapPositions(E_Space.direction.up);
            spaces.Add(curSpace); // add to overall list
            curSpace.assignSpaces(prevSpace);
            prevSpace = curSpace;

            // 3, 9
            curSpace = new E_Space(this, GetTilePosCenter(3, 9), Entity.typeSpace.chance);
            curSpace.setOverlapPositions(E_Space.direction.up);
            spaces.Add(curSpace); // add to overall list
            curSpace.assignSpaces(prevSpace);
            prevSpace = curSpace;

            // 3, 8
            curSpace = new E_Space(this, GetTilePosCenter(3, 8), Entity.typeSpace.blue);
            curSpace.setOverlapPositions(E_Space.direction.up);
            spaces.Add(curSpace); // add to overall list
            curSpace.assignSpaces(prevSpace);
            prevSpace = curSpace;

            // 3, 7
            curSpace = new E_Space(this, GetTilePosCenter(3, 7), Entity.typeSpace.blue);
            curSpace.setOverlapPositions(E_Space.direction.up);
            spaces.Add(curSpace); // add to overall list
            curSpace.assignSpaces(prevSpace);
            prevSpace = curSpace;

            // 3, 3
            curSpace = new E_Space(this, GetTilePosCenter(3, 3), Entity.typeSpace.red);
            curSpace.setOverlapPositions(E_Space.direction.up);
            spaces.Add(curSpace); // add to overall list
            curSpace.assignSpaces(prevSpace);
            prevSpace = curSpace;

            // 3, 2
            curSpace = new E_Space(this, GetTilePosCenter(3, 2), Entity.typeSpace.blue);
            curSpace.setOverlapPositions(E_Space.direction.up);
            spaces.Add(curSpace); // add to overall list
            curSpace.assignSpaces(prevSpace);
            prevSpace = curSpace;



            // <<---- MOVING RIGHT NOW: ----->>
            // 4, 1
            curSpace = new E_Space(this, GetTilePosCenter(4, 1), Entity.typeSpace.blue);
            curSpace.setOverlapPositions(E_Space.direction.right);
            spaces.Add(curSpace); // add to overall list
            curSpace.assignSpaces(prevSpace);
            prevSpace = curSpace;

            // 5, 1
            curSpace = new E_Space(this, GetTilePosCenter(5, 1), Entity.typeSpace.blue);
            curSpace.setOverlapPositions(E_Space.direction.right);
            spaces.Add(curSpace); // add to overall list
            curSpace.assignSpaces(prevSpace);
            prevSpace = curSpace;

            // 7, 1
            curSpace = new E_Space(this, GetTilePosCenter(7, 1), Entity.typeSpace.blue);
            curSpace.setOverlapPositions(E_Space.direction.right);
            spaces.Add(curSpace); // add to overall list
            curSpace.assignSpaces(prevSpace);
            prevSpace = curSpace;

            // 8, 2
            curSpace = new E_Space(this, GetTilePosCenter(8, 2), Entity.typeSpace.red);
            curSpace.setOverlapPositions(E_Space.direction.right);
            spaces.Add(curSpace); // add to overall list
            curSpace.assignSpaces(prevSpace);
            prevSpace = curSpace;

            // 9, 2
            curSpace = new E_Space(this, GetTilePosCenter(9, 2), Entity.typeSpace.red);
            curSpace.setOverlapPositions(E_Space.direction.right);
            spaces.Add(curSpace); // add to overall list
            curSpace.assignSpaces(prevSpace);
            prevSpace = curSpace;

            // 10, 3
            curSpace = new E_Space(this, GetTilePosCenter(10, 3), Entity.typeSpace.red);
            curSpace.setOverlapPositions(E_Space.direction.right);
            spaces.Add(curSpace); // add to overall list
            curSpace.assignSpaces(prevSpace);
            prevSpace = curSpace;

            // 12, 3
            curSpace = new E_Space(this, GetTilePosCenter(12, 3), Entity.typeSpace.blue);
            curSpace.setOverlapPositions(E_Space.direction.right);
            spaces.Add(curSpace); // add to overall list
            curSpace.assignSpaces(prevSpace);
            prevSpace = curSpace;

            // 13, 3
            curSpace = new E_Space(this, GetTilePosCenter(13, 3), Entity.typeSpace.blue);
            curSpace.setOverlapPositions(E_Space.direction.right);
            spaces.Add(curSpace); // add to overall list
            curSpace.assignSpaces(prevSpace);
            prevSpace = curSpace;

            // 14, 3
            curSpace = new E_Space(this, GetTilePosCenter(14, 3), Entity.typeSpace.chance);
            curSpace.setOverlapPositions(E_Space.direction.right);
            spaces.Add(curSpace); // add to overall list
            curSpace.assignSpaces(prevSpace);
            prevSpace = curSpace;

            // 16, 3
            curSpace = new E_Space(this, GetTilePosCenter(16, 3), Entity.typeSpace.red);
            curSpace.setOverlapPositions(E_Space.direction.right);
            spaces.Add(curSpace); // add to overall list
            curSpace.assignSpaces(prevSpace);
            prevSpace = curSpace;

            // 17, 4
            curSpace = new E_Space(this, GetTilePosCenter(17, 4), Entity.typeSpace.blue);
            curSpace.setOverlapPositions(E_Space.direction.right);
            spaces.Add(curSpace); // add to overall list
            curSpace.assignSpaces(prevSpace);
            prevSpace = curSpace;

            // 18, 4
            curSpace = new E_Space(this, GetTilePosCenter(18, 4), Entity.typeSpace.blue);
            curSpace.setOverlapPositions(E_Space.direction.right);
            spaces.Add(curSpace); // add to overall list
            curSpace.assignSpaces(prevSpace);
            prevSpace = curSpace;



            // <<---- MOVING DOWN NOW: ----->>
            // 19, 5
            curSpace = new E_Space(this, GetTilePosCenter(19, 5), Entity.typeSpace.blue);
            curSpace.setOverlapPositions(E_Space.direction.down);
            spaces.Add(curSpace); // add to overall list
            curSpace.assignSpaces(prevSpace);
            prevSpace = curSpace;

            // 19, 7
            curSpace = new E_Space(this, GetTilePosCenter(19, 7), Entity.typeSpace.blue);
            curSpace.setOverlapPositions(E_Space.direction.down);
            spaces.Add(curSpace); // add to overall list
            curSpace.assignSpaces(prevSpace);
            prevSpace = curSpace;

            // 19, 8
            curSpace = new E_Space(this, GetTilePosCenter(19, 8), Entity.typeSpace.red);
            curSpace.setOverlapPositions(E_Space.direction.down);
            spaces.Add(curSpace); // add to overall list
            curSpace.assignSpaces(prevSpace);
            prevSpace = curSpace;

            // 19, 10
            curSpace = new E_Space(this, GetTilePosCenter(19, 10), Entity.typeSpace.chance);
            curSpace.setOverlapPositions(E_Space.direction.down);
            spaces.Add(curSpace); // add to overall list
            curSpace.assignSpaces(prevSpace);
            prevSpace = curSpace;

            // 19, 11
            curSpace = new E_Space(this, GetTilePosCenter(19, 11), Entity.typeSpace.blue);
            curSpace.setOverlapPositions(E_Space.direction.down);
            spaces.Add(curSpace); // add to overall list
            curSpace.assignSpaces(prevSpace);
            prevSpace = curSpace;

            // 19, 13
            curSpace = new E_Space(this, GetTilePosCenter(19, 13), Entity.typeSpace.red);
            curSpace.setOverlapPositions(E_Space.direction.down);
            spaces.Add(curSpace); // add to overall list
            curSpace.assignSpaces(prevSpace);
            prevSpace = curSpace;

            // 21, 13
            curSpace = new E_Space(this, GetTilePosCenter(21, 13), Entity.typeSpace.blue);
            curSpace.setOverlapPositions(E_Space.direction.down);
            spaces.Add(curSpace); // add to overall list
            curSpace.assignSpaces(prevSpace);
            prevSpace = curSpace;

            // 22, 13
            curSpace = new E_Space(this, GetTilePosCenter(22, 13), Entity.typeSpace.red);
            curSpace.setOverlapPositions(E_Space.direction.down);
            spaces.Add(curSpace); // add to overall list
            curSpace.assignSpaces(prevSpace);
            prevSpace = curSpace;

            // 22, 15 FINAL PIECE
            curSpace = new E_Space(this, GetTilePosCenter(22, 15), Entity.typeSpace.chance);
            curSpace.setOverlapPositions(E_Space.direction.down);
            spaces.Add(curSpace);       // add to overall list
            curSpace.assignSpaces(prevSpace);
            this.finalSpace = curSpace; // FINAL SPACE

            // Finally, link up last space and first space:
            this.startingSpace.assignSpaces(this.finalSpace);

            // Assign the star space to a random space
            MGP_Tools.Assign_Star(this);

            // Assign starting space to all players
            foreach (Player p in this.gameOptions.players)
            {
                p.currSpace = this.startingSpace;
                p.meeple.setPos(p.currSpace.getMeepleLocation());

                // Occupy that space so another meeple doesn't run him/her over:
                p.currSpace.occupySpace(p);
            }
        } // end constructor
Esempio n. 15
0
        // Update:
        public override void Update(GameTime gameTime, KeyboardState ks)
        {
            base.Update(gameTime, ks);

            if (!loadedSong)
            {
                parentManager.audioEngine.setNextSong(MGP_Constants.music.mainMenu);
                parentManager.audioEngine.playNextSong(2, true);
                Console.WriteLine("Added mainMenu to music queue");
                loadedSong = true;
            }


            // Move Menu Selection Up:
            if (km.ActionPressed(KeyboardManager.action.up, KeyboardManager.playerIndex.all))
            {
                currentMenuItem = items[currentMenuItem].above.activeValue;
                moveGlove       = true;

                // SFX:
                parentManager.audioEngine.playSound(MGP_Constants.soundEffects.menuSelect, MGP_Constants.MENU_SFX_VOLUME);
            }

            // Move Menu Selection Down:
            if (km.ActionPressed(KeyboardManager.action.down, KeyboardManager.playerIndex.all))
            {
                currentMenuItem = items[currentMenuItem].below.activeValue;
                moveGlove       = true;

                // SFX:
                parentManager.audioEngine.playSound(MGP_Constants.soundEffects.menuSelect, MGP_Constants.MENU_SFX_VOLUME);
            }

            // Move glove
            if (moveGlove)
            {
                if (Vector2.Distance(glovePos, new Vector2(items[currentMenuItem].xPos - 60, items[currentMenuItem].yPos - 35)) < 1.0f)
                {
                    moveGlove = false;
                }
                else
                {
                    glovePos.Y = MGP_Tools.Ease(glovePos.Y, items[currentMenuItem].yPos - 35, 0.5f);
                }
            }

            // Press ENTER while some menu item is highlighted:
            if (km.ActionPressed(KeyboardManager.action.select, KeyboardManager.playerIndex.all))
            {
                parentManager.audioEngine.playSound(MGP_Constants.soundEffects.diceHit, MGP_Constants.MENU_SFX_VOLUME + 0.15f);

                // Map: Pirate Bay
                if (currentMenuItem == (int)MenuItem.MainMenu.PIRATE)
                {
                    parentManager.gameOptions.mapName = MenuItem.MainMenu.MOUNTAIN;
                    S_PlayerCountMenu playerCountMenu = new S_PlayerCountMenu(parentManager, 0, 0);
                    parentManager.AddStateQueue(playerCountMenu);
                    this.flagForDeletion = true;
                }

                // Option: Controls
                if (currentMenuItem == (int)MenuItem.MainMenu.MOUNTAIN)
                {
                    S_Controls controls = new S_Controls(parentManager, 0, 0);
                    parentManager.AddStateQueue(controls);
                    this.active = false;
                }

                // Option: About
                if (currentMenuItem == (int)MenuItem.MainMenu.ABOUT)
                {
                    S_About about = new S_About(parentManager, 0, 0, this);
                    parentManager.AddStateQueue(about);
                    this.active  = false;
                    this.visible = false;
                }

                // Option: Exit
                if (currentMenuItem == (int)MenuItem.MainMenu.EXIT)
                {
                    parentManager.game.Exit();
                }
            } // end pressed 'select' button
        }     // end update function
Esempio n. 16
0
        // Update:
        public override void Update(GameTime gameTime, KeyboardState ks)
        {
            base.Update(gameTime, ks);

            // Only the current player can press buttons
            if (players.Count == 1)
            {
                currPlayer = KeyboardManager.playerIndex.two;
            }
            else
            {
                currPlayer = KeyboardManager.playerIndex.one;
            }


            // Move Menu Selection Up:
            if (km.ActionPressed(KeyboardManager.action.up, currPlayer))
            {
                // SFX:
                parentManager.audioEngine.playSound(MGP_Constants.soundEffects.menuSelect, MGP_Constants.MENU_SFX_VOLUME);

                if (items[currentMenuItem].above != null && (players.Count == 0 || items[currentMenuItem].above.activeValue != (int)players[0]))
                {
                    currentMenuItem = items[currentMenuItem].above.activeValue;
                    moveGlove       = true;
                }
            }

            // Move Menu Selection Down:
            if (km.ActionPressed(KeyboardManager.action.down, currPlayer))
            {
                // SFX:
                parentManager.audioEngine.playSound(MGP_Constants.soundEffects.menuSelect, MGP_Constants.MENU_SFX_VOLUME);

                if (items[currentMenuItem].below != null && (players.Count == 0 || items[currentMenuItem].below.activeValue != (int)players[0]))
                {
                    currentMenuItem = items[currentMenuItem].below.activeValue;
                    moveGlove       = true;
                }
            }

            // Move Menu Selection Left:
            if (km.ActionPressed(KeyboardManager.action.left, currPlayer))
            {
                // SFX:
                parentManager.audioEngine.playSound(MGP_Constants.soundEffects.menuSelect, MGP_Constants.MENU_SFX_VOLUME);

                if (items[currentMenuItem].left != null && (players.Count == 0 || items[currentMenuItem].left.activeValue != (int)players[0]))
                {
                    currentMenuItem = items[currentMenuItem].left.activeValue;
                    moveGlove       = true;
                }
            }

            // Move Menu Selection Right:
            if (km.ActionPressed(KeyboardManager.action.right, currPlayer))
            {
                // SFX:
                parentManager.audioEngine.playSound(MGP_Constants.soundEffects.menuSelect, MGP_Constants.MENU_SFX_VOLUME);

                if (items[currentMenuItem].right != null && (players.Count == 0 || items[currentMenuItem].right.activeValue != (int)players[0]))
                {
                    currentMenuItem = items[currentMenuItem].right.activeValue;
                    moveGlove       = true;
                }
            }

            // Move glove
            if (moveGlove)
            {
                if (Vector2.Distance(glovePos, new Vector2(items[currentMenuItem].xPos - (cloudWidth / 2 + 60), items[currentMenuItem].yPos + 40)) < 1.0f)
                {
                    moveGlove = false;
                }
                else
                {
                    glovePos.X = MGP_Tools.Ease(glovePos.X, items[currentMenuItem].xPos - (cloudWidth / 2 + 60), 0.5f);
                    glovePos.Y = MGP_Tools.Ease(glovePos.Y, items[currentMenuItem].yPos - 40, 0.5f);
                }
            }


            // Press ENTER while some menu item is highlighted:
            if (km.ActionPressed(KeyboardManager.action.select, currPlayer))
            {
                // SFX:
                parentManager.audioEngine.playSound(MGP_Constants.soundEffects.diceHit, MGP_Constants.MENU_SFX_VOLUME + 0.15f);

                // Add character to List
                players.Add((Player.Type)items[currentMenuItem].activeValue);

                // If only one player or both players have made selections
                if (numOfPlayers == 1 || players.Count == 2)
                {
                    // Add the computer players at random
                    while (players.Count < 4)
                    {
                        comPlayer = parentManager.random.Next(0, 5);
                        if (!players.Contains((Player.Type)comPlayer))
                        {
                            players.Add((Player.Type)comPlayer);
                        }
                    }

                    // Create player entitities and add to game options
                    for (int i = 0; i < players.Count; i++)
                    {
                        // add as a human player
                        if (i == 0)
                        {
                            parentManager.gameOptions.players.Add(new Player(this.creator, players[i], true, KeyboardManager.playerIndex.one));
                        }
                        else if (i == numOfPlayers - 1)
                        {
                            parentManager.gameOptions.players.Add(new Player(this.creator, players[i], true, KeyboardManager.playerIndex.two));
                        }
                        // add a comp player
                        else
                        {
                            parentManager.gameOptions.players.Add(new Player(this.creator, players[i], false, KeyboardManager.playerIndex.none));
                        }
                    }

                    // Move onto next menu
                    S_DifficultyMenu diffMenu = new S_DifficultyMenu(parentManager, 0, 0);
                    parentManager.AddStateQueue(diffMenu);
                    this.flagForDeletion = true;
                }
                // Begin character selection for player 2
                else
                {
                    // Move selection to first availble character for player two
                    if (currentMenuItem == 0)
                    {
                        currentMenuItem = 1;
                    }
                    else
                    {
                        currentMenuItem = 0;
                    }
                    moveGlove = true;
                }
            } // end of enter action key press

            // Option: Cancel Key
            if (km.ActionPressed(KeyboardManager.action.cancel, currPlayer))
            {
                // SFX:
                parentManager.audioEngine.playSound(MGP_Constants.soundEffects.menuCancel, MGP_Constants.MENU_SFX_VOLUME);

                // If first player has made a choice
                if (players.Count == 1)
                {
                    // Remove the character choice so they can choose again
                    players.RemoveAt(0);
                }
                // No selections have been made and we return to the player count menu
                else
                {
                    S_PlayerCountMenu playerCountMenu = new S_PlayerCountMenu(parentManager, 0, 0);
                    parentManager.AddStateQueue(playerCountMenu);
                    this.flagForDeletion = true;
                }
            } // end of cancel key
        }     // end of update