Пример #1
0
        public MultiPlayerSelector(MainLayer mainLayer)
        {
            _mainLayer = mainLayer;

            backGround = new Button("background_1")
            {
                Position = new CCPoint(192, 120)
            };
            AddChild(backGround);

            Standard = new Button("Standard") // Single Player létrehozása
            {
                Scale    = 2,
                Position = new CCPoint(192, 180)
            };
            AddChild(Standard);

            GoldRush = new Button("GoldRush") // Multi Player létrehozása
            {
                Scale    = 2,
                Position = new CCPoint(192, 120)
            };
            AddChild(GoldRush);

            custom          = new Button("Custom");
            custom.Scale    = 2;
            custom.Position = new CCPoint(192, 60);
            AddChild(custom);
        }
Пример #2
0
        private void drawBackDialog(TimeSpan elapsedGameTime)
        {
            MainLayer.Save();
            GameService.ClassicGameState.Board.Render(elapsedGameTime, MainLayer, disabled: true);

            MainLayer.DrawRectangle(new Color(10, 10, 10, 180), 0, 0, BoardConstants.TotalWidth, BoardConstants.TotalHeight);


            var nsBoard = new Rectangle(Positions.BackLayout.BackBoxPosition.X, Positions.BackLayout.BackBoxPosition.Y, Positions.BackLayout.BackBoxSize.X, Positions.BackLayout.BackBoxSize.Y, true);

            MainLayer.DrawRectangle(white, nsBoard, true);

            MainLayer.Translate(nsBoard.X, nsBoard.Y);

            MainLayer.DrawString((Assets.Fonts.BabyDoll._72), "Are you sure you would like\nto go back?\nYour progress will be lost.", Positions.BackLayout.BackTextPosition.X, Positions.BackLayout.BackTextPosition.Y, Colors.DarkFontColor);


            var cancelButtonRect = new Rectangle(Positions.BackLayout.BackCancelButtonPosition.X, Positions.BackLayout.BackCancelButtonPosition.Y, Positions.BackLayout.BackCancelBoxSize.X, Positions.BackLayout.BackCancelBoxSize.Y);

            MainLayer.DrawRectangle(buttonBlue, cancelButtonRect);
            MainLayer.DrawString((Assets.Fonts.BabyDoll._100), "Cancel", cancelButtonRect.Center.X, cancelButtonRect.Center.Y);


            var continueButtonRect = new Rectangle(Positions.BackLayout.BackContinueButtonPosition.X, Positions.BackLayout.BackContinueButtonPosition.Y, Positions.BackLayout.BackContinueBoxSize.X, Positions.BackLayout.BackContinueBoxSize.Y);

            MainLayer.DrawRectangle(buttonBlue, continueButtonRect);

            MainLayer.DrawString((Assets.Fonts.BabyDoll._100), "Continue", continueButtonRect.Center.X, continueButtonRect.Center.Y);

            MainLayer.Restore();
        }
Пример #3
0
        public MenuLayer(MainLayer gameLayer)
            : base(CCColor4B.Blue)
        {
            _mainLayer = gameLayer;

            backGround          = new Button("background");
            backGround.Position = new CCPoint(192, 120);
            AddChild(backGround);

            levels          = new Button("LevelSelect");
            levels.Scale    = 2;
            levels.Position = new CCPoint(192, 150);
            AddChild(levels);

            highscores          = new Button("HighScores");
            highscores.Scale    = 2;
            highscores.Position = new CCPoint(192, 90);
            AddChild(highscores);

            howtoplay          = new Button("HowToPlay");
            howtoplay.Scale    = 2;
            howtoplay.Position = new CCPoint(192, 30);
            AddChild(howtoplay);

            //Connect to server
            System.Net.Sockets.TcpClient clientSocket = new System.Net.Sockets.TcpClient();
            //clientSocket.Connect("127.0.0.1", 8888);
            var tcpClient = new TcpClient("10.0.2.2", 8888);

            serverStream = tcpClient.GetStream();
        }
Пример #4
0
    public void Run()
    {
        // Altseedを初期化する。
        asd.Engine.Initialize("Pause_Basic", 640, 480, new asd.EngineOption());

        // シーンを生成する
        var scene = new asd.Scene();

        // ゲームの挙動を描画するレイヤーを生成する
        var layer = new MainLayer();

        // シーンにレイヤーを追加する
        scene.AddLayer(layer);

        // シーンを切り替える
        asd.Engine.ChangeScene(scene);

        // Altseedのウインドウが閉じられていないか確認する。
        while (asd.Engine.DoEvents())
        {
            // Altseedを更新する。
            asd.Engine.Update();
            Recorder.TakeScreenShot("Pause_Basic", 60);
        }

        // Altseedの終了処理をする。
        asd.Engine.Terminate();
    }
Пример #5
0
        public MenuLayer(MainLayer gameLayer, NetworkStream serverStream)
            : base(CCColor4B.Blue)
        {
            _mainLayer    = gameLayer;
            _serverStream = serverStream;

            backGround          = new Button("background");
            backGround.Position = new CCPoint(192, 120);
            AddChild(backGround);

            play          = new Button("Play");
            play.Scale    = 2;
            play.Position = new CCPoint(192, 150);
            AddChild(play);

            highscores = new Button("HighScores")
            {
                Scale    = 2,
                Position = new CCPoint(192, 90)
            };
            AddChild(highscores);

            howtoplay          = new Button("HowToPlay");
            howtoplay.Scale    = 2;
            howtoplay.Position = new CCPoint(192, 30);
            AddChild(howtoplay);
        }
Пример #6
0
    public void Run()
    {
        // Altseedを初期化する。
        asd.Engine.Initialize("Pause_Basic", 640, 480, new asd.EngineOption());

        // シーンを生成する
        var scene = new asd.Scene();

        // ゲームの挙動を描画するレイヤーを生成する
        var layer = new MainLayer();

        // シーンにレイヤーを追加する
        scene.AddLayer(layer);

        // シーンを切り替える
        asd.Engine.ChangeScene(scene);

        // Altseedのウインドウが閉じられていないか確認する。
        while (asd.Engine.DoEvents())
        {
            // Altseedを更新する。
            asd.Engine.Update();
            Recorder.TakeScreenShot("Pause_Basic", 60);
        }

        // Altseedの終了処理をする。
        asd.Engine.Terminate();
    }
        public override void Render(TimeSpan elapsedGameTime)
        {
            MainLayer.Begin();
            MainLayer.Save();

            MainLayer.DrawRectangle(new Color(252, 252, 252), 0, 0, MainLayer.Layout.Width, MainLayer.Layout.Height);

            GameService.ClassicGameState.Board.Render(elapsedGameTime, MainLayer);


            MainLayer.Save();
            MainLayer.DrawImage(Assets.Images.Layouts.StagingArea, 0, BoardConstants.TopAreaHeight);
            if (State.Congrats && !GameService.ClassicGameState.Board.IsMoving)
            {
                drawBottomChoosePlayers();
            }
            else
            {
                drawBottomInfo();
            }
            MainLayer.Restore();

            if (State.Congrats && !GameService.ClassicGameState.Board.IsMoving)
            {
                MainLayer.DrawImage(Assets.Images.Character.LabelBox.CharacterBox[State.CurrentChosenNumber.Character.CharacterNumber + 1], Positions.CongratsPosition, true);
                MainLayer.DrawString((Assets.Fonts.BabyDoll._130), string.Format("Congrats\nPlayer {0}!", (State.CurrentChosenNumber.Character.CharacterNumber + 1)), Positions.CongratsPosition);
            }
            MainLayer.Restore();

            TouchManager.Render(MainLayer);
            MainLayer.End();
        }
Пример #8
0
        public override void ApplicationDidFinishLaunching(CCApplication application, CCWindow mainWindow)
        {
            application.PreferMultiSampling  = false;
            application.ContentRootDirectory = "Content";
            application.ContentSearchPaths.Add("animations");
            application.ContentSearchPaths.Add("fonts");
            application.ContentSearchPaths.Add("sounds");

            CCSize windowSize = mainWindow.WindowSizeInPixels;

            float desiredWidth  = 1024.0f;
            float desiredHeight = 768.0f;

            CCScene.SetDefaultDesignResolution(desiredWidth, desiredHeight, CCSceneResolutionPolicy.ShowAll);

            application.ContentSearchPaths.Add("images/hd");
            CCSprite.DefaultTexelToContentSizeRatio = 2.0f;

            CCScene.SetDefaultDesignResolution(384, 240, CCSceneResolutionPolicy.ShowAll);

            scene = new CCScene(mainWindow);
            MainLayer mainLayer = new MainLayer();

            scene.AddChild(mainLayer);
            mainWindow.RunWithScene(scene);
        }
Пример #9
0
        public override void ApplicationDidFinishLaunching(CCApplication application, CCWindow mainWindow)
        {
            application.PreferMultiSampling  = false;
            application.ContentRootDirectory = "Content";
            application.ContentSearchPaths.Add("animations");
            application.ContentSearchPaths.Add("fonts");
            application.ContentSearchPaths.Add("sounds");

            IGraphicsDeviceService service = (IGraphicsDeviceService)application.Game.Services.GetService(typeof(IGraphicsDeviceService));
            var xnaDeviceManager           = (GraphicsDeviceManager)service;

            xnaDeviceManager.SupportedOrientations = DisplayOrientation.LandscapeLeft;
            xnaDeviceManager.ApplyChanges();

            CCSize windowSize = mainWindow.WindowSizeInPixels;

            float desiredWidth  = 1024.0f;
            float desiredHeight = 768.0f;

            CCScene.SetDefaultDesignResolution(desiredWidth, desiredHeight, CCSceneResolutionPolicy.ShowAll);

            application.ContentSearchPaths.Add("images/hd");
            CCSprite.DefaultTexelToContentSizeRatio = 2.0f;

            CCScene.SetDefaultDesignResolution(384, 240, CCSceneResolutionPolicy.ShowAll);

            scene = new CCScene(mainWindow);
            MainLayer mainLayer = new MainLayer();

            scene.AddChild(mainLayer);
            //mainWindow.SupportedDisplayOrientations = CCDisplayOrientation.LandscapeLeft;
            mainWindow.RunWithScene(scene);
        }
Пример #10
0
        private void drawBottomInfo()
        {
            IImage baseImage = GoalPiece.GetBaseImage(GameService.ClassicGameState.CurrentGoal);
            IImage goalImage = GoalPiece.GetGoalImage(GameService.ClassicGameState.CurrentGoal);

            IImage goalArrow      = Assets.Images.Layouts.Arrow;
            IImage smallGoalArrow = Assets.Images.Layouts.Arrow;

            if ((GameService.ClassicGameState.GameState == GameSelectionState.ChooseNumber && GameService.ClassicGameState.ChosenNumbers.Count == 0) || GameService.ClassicGameState.GameState == GameSelectionState.SearchingBoard)
            {
                MainLayer.DrawImage(Assets.Images.Layouts.HelperImage1, Positions.Help1Position, true);

                MainLayer.DrawImage(goalArrow, Positions.CardArrowPosition.X, Positions.CardArrowPosition.Y, true);

                MainLayer.DrawImage(baseImage, Positions.CardCharacterPosition.X, Positions.CardCharacterPosition.Y, 192, 192, true);

                MainLayer.DrawImage(goalImage, Positions.CardGoalPosition.X, Positions.CardGoalPosition.Y, 192, 192, true);

                MainLayer.DrawImage(Assets.Images.Layouts.HelperImage2, Positions.Help2Position, true);
            }
            else
            {
                int index = 0;
                for (int chosenNumberIndex = Math.Max(GameService.ClassicGameState.ChosenNumbers.Count - 4, 0); chosenNumberIndex < GameService.ClassicGameState.ChosenNumbers.Count; chosenNumberIndex++)
                {
                    ChosenNumber chosenNumber = GameService.ClassicGameState.ChosenNumbers[chosenNumberIndex];
                    if (chosenNumberIndex == GameService.ClassicGameState.ChosenNumbers.Count - 1)
                    {
                        IImage flagImage = Assets.Images.Character.Banners.Big.LongBanner[chosenNumber.Character.CharacterNumber + 1];
                        MainLayer.DrawImage(flagImage, Positions.FlagLongPositions[index].X, Positions.FlagLongPositions[index].Y, true);

                        MainLayer.DrawString((Assets.Fonts.BabyDoll._90), chosenNumber.Number.ToString(), Positions.FlagLongPositionNumbers[index].X, Positions.FlagLongPositionNumbers[index].Y);
                    }
                    else
                    {
                        IImage flagImage = Assets.Images.Character.Banners.Small.ShortBanner[chosenNumber.Character.CharacterNumber + 1];
                        MainLayer.DrawImage(flagImage, Positions.FlagPositions[index].X, Positions.FlagPositions[index].Y, true);

                        MainLayer.DrawString((Assets.Fonts.BabyDoll._90), chosenNumber.Number.ToString(), Positions.FlagPositionNumbers[index].X, Positions.FlagPositionNumbers[index].Y);
                    }
                    if (GameService.ClassicGameState.GameState != GameSelectionState.ChooseNumber)
                    {
                        long timeLeft = Math.Max(GetTimeLeft(), 0);

                        MainLayer.DrawString((Assets.Fonts.BabyDoll._240), timeLeft.ToString(), Positions.TimePosition.X, Positions.TimePosition.Y, Positions.BlackColor);
                        MainLayer.DrawString((Assets.Fonts.BabyDoll._48), "time left", Positions.TimePosition.X, Positions.TimePosition.Y + 100, Positions.BlackColor);
                    }
                    index++;
                }

                MainLayer.DrawImage(baseImage, Positions.SmallCardCharacterPosition.X, Positions.SmallCardCharacterPosition.Y, 150, 150, true);
                MainLayer.DrawImage(smallGoalArrow, Positions.SmallCardArrowPosition.X, Positions.SmallCardArrowPosition.Y, 50, 30, true);
                MainLayer.DrawImage(goalImage, Positions.SmallCardGoalPosition.X, Positions.SmallCardGoalPosition.Y, 150, 150, true);
            }
        }
 public void Move(Vector3 distance)
 {
     MainLayer.Move(distance);
     foreach (IGameLayer layer in Layers2D)
     {
         layer.Move(distance);
     }
     foreach (IGameLayer layer in Layers3D)
     {
         layer.Move(distance);
     }
 }
        private void drawBottomChoosePlayers()
        {
            MainLayer.Save();
            MainLayer.Translate(0, BoardConstants.TopAreaHeight);

            MainLayer.DrawImage(Assets.Images.Layouts.StagingArea, 0, 0);

            MainLayer.DrawImage(Assets.Images.Layouts.TextBoard, Positions.PlaceYourCharacterPosition, true);

            switch (GameService.ClassicGameState.GameState)
            {
            case GameSelectionState.PlayerChoose:
                MainLayer.DrawString((Assets.Fonts.BabyDoll._72), string.Format("Player {0}, Choose Your Penguin", (State.CurrentPlayerChoosing + 1)), Positions.PlaceYourCharacterPosition);
                break;

            case GameSelectionState.PlayerPlace:
                MainLayer.DrawString((Assets.Fonts.BabyDoll._72), string.Format("Player {0}, Place Your Penguin", (State.CurrentPlayerChoosing + 1)), Positions.PlaceYourCharacterPosition);
                break;
            }

            for (int i = 0; i < 6; i++)
            {
                Character character           = GameService.ClassicGameState.Characters[i];
                var       realCharacterNumber = i + 1;
                if (character.Playing)
                {
                    MainLayer.DrawImage(Assets.Images.Character.Placement.CharacterPlacement[realCharacterNumber], Positions.CharacterShadowPosition[i].X, Positions.CharacterShadowPosition[i].Y, true);
                }
                else
                {
                    MainLayer.DrawImage(Assets.Images.Character.CharacterShadow, Positions.CharacterShadowPosition[i].X, Positions.CharacterShadowPosition[i].Y, true);


                    MainLayer.Save();

                    var animatedCharacterSubLayout = CharacterAnimations[realCharacterNumber];
                    animatedCharacterSubLayout.Selected = character.Selected;
                    if (character.Selected)
                    {
                        MainLayer.Translate(Positions.CharacterPositions[character.CharacterNumber].X, Positions.CharacterPositions[character.CharacterNumber].Y - 20);
                    }
                    else
                    {
                        MainLayer.Translate(Positions.CharacterPositions[character.CharacterNumber].X, Positions.CharacterPositions[character.CharacterNumber].Y);
                    }


                    animatedCharacterSubLayout.Render(MainLayer);
                    MainLayer.Restore();
                }
            }
            MainLayer.Restore();
        }
        private void drawBottomInfo()
        {
            MainLayer.Save();
            MainLayer.Translate(0, BoardConstants.TopAreaHeight);
            IImage smallGoalArrow = Assets.Images.Layouts.Arrow;
            int    index          = 0;

            for (int chosenNumberIndex = Math.Max(GameService.ClassicGameState.ChosenNumbers.Count - 4, 0); chosenNumberIndex < GameService.ClassicGameState.ChosenNumbers.Count; chosenNumberIndex++)
            {
                ChosenNumber chosenNumber = GameService.ClassicGameState.ChosenNumbers[chosenNumberIndex];
                if (chosenNumberIndex == GameService.ClassicGameState.ChosenNumbers.Count - 1)
                {
                    IImage flagImage = Assets.Images.Character.Banners.Big.LongBanner[chosenNumber.Character.CharacterNumber + 1];
                    MainLayer.DrawImage(flagImage, Positions.FlagLongPositions[index].X, Positions.FlagLongPositions[index].Y, true);

                    MainLayer.DrawString((Assets.Fonts.BabyDoll._90), chosenNumber.Number.ToString(), Positions.FlagLongPositionNumbers[index].X, Positions.FlagLongPositionNumbers[index].Y);
                }
                else
                {
                    IImage flagImage = Assets.Images.Character.Banners.Small.ShortBanner[chosenNumber.Character.CharacterNumber + 1];
                    MainLayer.DrawImage(flagImage, Positions.FlagPositions[index].X, Positions.FlagPositions[index].Y, true);

                    MainLayer.DrawString((Assets.Fonts.BabyDoll._90), chosenNumber.Number.ToString(), Positions.FlagPositionNumbers[index].X, Positions.FlagPositionNumbers[index].Y);
                }

                MainLayer.DrawString((Assets.Fonts.BabyDoll._240), getMovesLeft().ToString(), Positions.NumberPosition, Positions.BlackColor);
                MainLayer.DrawString((Assets.Fonts.BabyDoll._48), "total moves", Positions.NumberPosition.X, Positions.NumberPosition.Y + 100, Positions.BlackColor);
                index++;
            }


            MainLayer.DrawImage(smallGoalArrow, Positions.SmallCardArrowPosition.X, Positions.SmallCardArrowPosition.Y, true);

            IImage baseImage = GoalPiece.GetBaseImage(GameService.ClassicGameState.CurrentGoal);

            IImage goalImage = GoalPiece.GetGoalImage(GameService.ClassicGameState.CurrentGoal);

            MainLayer.DrawImage(baseImage, Positions.SmallCardCharacterPosition.X, Positions.SmallCardCharacterPosition.Y, 150, 150, true);
            MainLayer.DrawImage(smallGoalArrow, Positions.SmallCardArrowPosition.X, Positions.SmallCardArrowPosition.Y, 50, 30, true);
            MainLayer.DrawImage(goalImage, Positions.SmallCardGoalPosition.X, Positions.SmallCardGoalPosition.Y, 150, 150, true);
            MainLayer.Restore();

            MainLayer.DrawRectangle(new Color(252, 252, 252), 0, Positions.UndoButtonRect.Y, Layout.Width, Positions.UndoButtonRect.Height);

            MainLayer.DrawRectangle(new Color(37, 170, 255), Positions.UndoButtonRect);
            MainLayer.DrawString((Assets.Fonts.BabyDoll._120), "Undo", Positions.UndoButtonRect.Center);

            MainLayer.DrawRectangle(new Color(37, 170, 255), Positions.PassButtonRect);
            MainLayer.DrawString((Assets.Fonts.BabyDoll._120), "Pass", Positions.PassButtonRect.Center);
        }
        private void drawBottomChoosePlayers()
        {
            if (State.CardAnimationMotion != null)
            {
                State.CardAnimationMotion.Render(MainLayer);
            }


            MainLayer.Save();
            MainLayer.Translate(0, BoardConstants.TopAreaHeight);
            foreach (Character character in GameService.ClassicGameState.Characters)
            {
                var realCharacterNumber = character.CharacterNumber + 1;
                if (!character.Playing)
                {
                    MainLayer.DrawImage(Assets.Images.Character.Placement.CharacterPlacement[realCharacterNumber], Positions.CharacterShadowPositions[character.CharacterNumber], true);
                }

                else
                {
                    MainLayer.DrawImage(Assets.Images.Character.CharacterShadow, Positions.CharacterShadowPositions[character.CharacterNumber], true);

                    MainLayer.Save();

                    var animatedCharacterSubLayout = CharacterAnimations[realCharacterNumber];
                    animatedCharacterSubLayout.Selected = character.Selected;
                    if (character.Selected)
                    {
                        MainLayer.Translate(Positions.CharacterPositions[character.CharacterNumber].X, Positions.CharacterPositions[character.CharacterNumber].Y - 20);
                    }
                    else
                    {
                        MainLayer.Translate(Positions.CharacterPositions[character.CharacterNumber].X, Positions.CharacterPositions[character.CharacterNumber].Y);
                    }


                    animatedCharacterSubLayout.Render(MainLayer);
                    MainLayer.Restore();


                    var characterScorePosition = Positions.CharacterScorePositions[character.CharacterNumber];
                    MainLayer.DrawString((Assets.Fonts.BabyDoll._36), "x", characterScorePosition.X, characterScorePosition.Y + 13, Positions.DarkColor, false);
                    MainLayer.DrawString((Assets.Fonts.BabyDoll._60), character.Score.ToString(), characterScorePosition.X + 25, characterScorePosition.Y, Positions.DarkColor, false);
                }
            }
            MainLayer.Restore();
        }
        private void drawBottomCards()
        {
            MainLayer.Save();

            IImage image = Assets.Images.Cards.CardsBack;


            Goal[] goalCards = GameService.ClassicGameState.UnusedGoals;


            int topRow    = goalCards.Length / 2;
            int bottomRow = goalCards.Length / 2 + goalCards.Length % 2;

            if (topRow != 0)
            {
                int topCenterOffset = (Positions.BottomCardAreaWidth / (topRow)) / 2;
                for (int index = 0; index < topRow; index++)
                {
                    if (goalCards[index] == State.CurrentlySelectedGoal)
                    {
                        continue;
                    }
                    MainLayer.DrawImage(image, (Positions.BottomCardAreaWidth / topRow * index) + topCenterOffset, Positions.BottomCardSize / 2 - Positions.CardShadowHeight, Positions.BottomCardSize, Positions.BottomCardSize, true);
                }
            }

            int bottomCenterOffset = (Positions.BottomCardAreaWidth / (bottomRow)) / 2;

            for (int index = topRow; index < topRow + bottomRow; index++)
            {
                if (goalCards[index] == State.CurrentlySelectedGoal)
                {
                    continue;
                }
                MainLayer.DrawImage(image, (Positions.BottomCardAreaWidth / bottomRow * (index - topRow)) + bottomCenterOffset, Positions.BottomCardSize - 40 + Positions.BottomCardSize / 2 - Positions.CardShadowHeight, Positions.BottomCardSize, Positions.BottomCardSize, true);
            }

            if (State.CardAnimationMotion != null)
            {
                State.CardAnimationMotion.Render(MainLayer);
            }

            MainLayer.Restore();
        }
        private void PlayerWon(GoalPiece goal)
        {
            Point pos = Positions.CharacterPositions[State.CurrentChosenNumber.Character.CharacterNumber];

            State.Congrats = true;
            IImage goalImage = GoalPiece.GetGoalImage(GameService.ClassicGameState.CurrentGoal);

            State.CardAnimationMotion = MotionManager.StartMotion(Positions.CongratsPosition.X, Positions.CongratsPosition.Y, new WaitMotion(200))
                                        .Motion(new AnimationMotion(pos.X + 0, pos.Y + BoardConstants.TopAreaHeight, 2000, AnimationEasing.BounceEaseOut))
                                        .OnRender((layer, posX, posY, animationIndex, percentDone) =>
            {
                MainLayer.Save();
                MainLayer.SetDrawingTransparency(1 - percentDone);
                MainLayer.DrawImage(goalImage, posX, posY, 220, 220, true);
                MainLayer.Restore();
            }).OnComplete(() =>
            {
                GameService.ClassicGameState.Board.SquarePieces.Remove(goal);

                GameService.ClassicGameState.CharacterWon(State.CurrentChosenNumber.Character);
                ScreenTransitioner.ChangeToBoardCardSelectionScreen();
            });
        }
Пример #17
0
        public override void Render(TimeSpan elapsedGameTime)
        {
            MainLayer.Begin();
            MainLayer.Save();

            MainLayer.DrawRectangle(new Color(252, 252, 252), 0, 0, MainLayer.Layout.Width, MainLayer.Layout.Height);

            if (GameService.ClassicGameState.GameState != GameSelectionState.ChooseNumber)
            {
                GameService.ClassicGameState.Board.Render(elapsedGameTime, MainLayer);
            }
            else
            {
                drawNumberSelection(elapsedGameTime);
            }


            MainLayer.Translate(0, BoardConstants.TopAreaHeight);

            MainLayer.DrawImage(Assets.Images.Layouts.StagingArea, 0, 0);

            drawBottomInfo();

            drawBottomChoosePlayers();
            MainLayer.Restore();

            MainLayer.DrawImage(Assets.Images.Layouts.BackButton, Positions.BackPosition);


            if (State.BackDialogVisible)
            {
                drawBackDialog(elapsedGameTime);
            }

            TouchManager.Render(MainLayer);
            MainLayer.End();
        }
Пример #18
0
        public void PlayMainTrackOnMainLayer()
        {
            CustomAudioTrack fcMain = new CustomAudioTrack(BackgroundMusic, 90.35f, PlayMainTrackLoopOnIntroLayer);

            MainLayer.AddToQueue(fcMain);
        }
        public override void Render(TimeSpan elapsedGameTime)
        {
            MainLayer.Begin();
            MainLayer.Save();

            MainLayer.DrawRectangle(new Color(252, 252, 252), 0, 0, MainLayer.Layout.Width, MainLayer.Layout.Height);


            GameService.ClassicGameState.Board.Render(elapsedGameTime, MainLayer, (layer, x, y) =>
            {
                switch (GameService.ClassicGameState.GameState)
                {
                case GameSelectionState.PlayerPlace:
                    if (x == State.CurrentCharacter.X && y == State.CurrentCharacter.Y)
                    {
                        MainLayer.DrawImage(
                            Assets.Images.Character.Box.CharacterBox[State.CurrentCharacter.CharacterNumber + 1],
                            State.CurrentCharacter.X * BoardConstants.SquareSize + BoardConstants.SquareSize / 2,
                            State.CurrentCharacter.Y * BoardConstants.SquareSize + BoardConstants.SquareSize / 2,
                            BoardConstants.SquareSize,
                            BoardConstants.SquareSize,
                            true);

                        return;
                    }
                    if (State.CurrentCharacter.Y >= BoardConstants.SquareHeight / 2 && x == State.CurrentCharacter.X && y == State.CurrentCharacter.Y + 1)
                    {
                        MainLayer.DrawImage(
                            Assets.Images.Character.Arrow.PlaceCharacterArrow[State.CurrentCharacter.CharacterNumber + 1],
                            State.CurrentCharacter.X * BoardConstants.SquareSize + BoardConstants.SquareSize / 2,
                            (State.CurrentCharacter.Y - 1) * BoardConstants.SquareSize + BoardConstants.SquareSize / 2,
                            BoardConstants.SquareSize,
                            BoardConstants.SquareSize,
                            true);

                        return;
                    }
                    if (State.CurrentCharacter.Y < BoardConstants.SquareHeight / 2 && x == State.CurrentCharacter.X && y == State.CurrentCharacter.Y - 1)
                    {
                        MainLayer.Save();
                        MainLayer.SetDrawingEffects(DrawingEffects.FlipVertically);
                        MainLayer.DrawImage(
                            Assets.Images.Character.Arrow.PlaceCharacterArrow[State.CurrentCharacter.CharacterNumber + 1],
                            State.CurrentCharacter.X * BoardConstants.SquareSize + BoardConstants.SquareSize / 2,
                            (State.CurrentCharacter.Y + 1) * BoardConstants.SquareSize + BoardConstants.SquareSize / 2,
                            BoardConstants.SquareSize,
                            BoardConstants.SquareSize,
                            true);
                        MainLayer.Restore();
                    }
                    break;
                }
            });

            MainLayer.Save();
            MainLayer.Translate(BoardConstants.SideOffset, BoardConstants.TopOffset);
            switch (GameService.ClassicGameState.GameState)
            {
            case GameSelectionState.PlayerPlace:
                if (State.CurrentCharacter.X > -1)
                {
                    IImage image = Assets.Images.Character.Stationary.Big.StationaryCharacters[State.CurrentCharacter.CharacterNumber + 1];
                    if (State.CurrentCharacter.Y < BoardConstants.SquareHeight / 2)
                    {
                        MainLayer.DrawImage(image, State.CurrentCharacter.X * BoardConstants.SquareSize + BoardConstants.SquareSize / 2, (State.CurrentCharacter.Y + 2) * BoardConstants.SquareSize + BoardConstants.SquareSize / 2 + BoardConstants.SquareSize / 2, 180 * Math.PI / 180, true);
                    }
                    else
                    {
                        MainLayer.DrawImage(image, State.CurrentCharacter.X * BoardConstants.SquareSize + BoardConstants.SquareSize / 2, (State.CurrentCharacter.Y - 2) * BoardConstants.SquareSize + BoardConstants.SquareSize / 2 - BoardConstants.SquareSize / 2, true);
                    }
                }
                break;
            }
            MainLayer.Restore();


            if (GameService.ClassicGameState.GameState == GameSelectionState.PlayerChoose || GameService.ClassicGameState.GameState == GameSelectionState.PlayerPlace)
            {
                drawBottomChoosePlayers();
            }


            MainLayer.Restore();
            if (State.ShowingTutorial > 0 && State.ShowingTutorial < 3)
            {
                MainLayer.DrawImage(Assets.Images.Layouts.Tutorials.Tutorial[State.ShowingTutorial], Positions.TutorialPosition, true);
            }


            TouchManager.Render(MainLayer);

            MainLayer.End();
        }
        public override void Render(TimeSpan elapsedGameTime)
        {
            MainLayer.Begin();

            MainLayer.Save();
            MainLayer.DrawRectangle(new Color(252, 252, 252), 0, 0, MainLayer.Layout.Width, MainLayer.Layout.Height);


            GameService.ClassicGameState.Board.Render(elapsedGameTime, MainLayer);

            if (GameService.ClassicGameState.GameState == GameSelectionState.PickCard)
            {
                if (GameService.ClassicGameState.UnusedGoals.Length == 0)
                {
                    var winningChars = new List <Character>();
                    int winningScore = -1;
                    foreach (Character character in GameService.ClassicGameState.Characters)
                    {
                        if (!character.Playing)
                        {
                            continue;
                        }
                        if (character.Score > winningScore)
                        {
                            winningChars.Clear();
                            winningChars.Add(character);
                        }
                        else
                        {
                            if (winningChars.Count > 0)
                            {
                                if (winningChars[0].Score == character.Score)
                                {
                                    winningChars.Add(character);
                                }
                            }
                        }
                    }
                    Character ch = winningChars.First();

                    MainLayer.DrawImage(Assets.Images.Character.LabelBox.CharacterBox[ch.CharacterNumber + 1], Positions.CongratsPosition, true);

                    string charWinningString;
                    if (winningChars.Count == 1)
                    {
                        charWinningString = string.Format("Player {0}\nHas Won!", (ch.CharacterNumber + 1));
                    }
                    else
                    {
                        string plc = (winningChars[0].CharacterNumber + 1).ToString();

                        for (int index = 1; index < winningChars.Count - 1; index++)
                        {
                            Character winningChar = winningChars[index];
                            plc += ", " + (winningChar.CharacterNumber + 1);
                        }
                        plc = "And " + (winningChars[0].CharacterNumber + 1);

                        charWinningString = string.Format("Players {0}\nHave Won!", plc);
                    }
                    MainLayer.DrawString((Assets.Fonts.BabyDoll._130), charWinningString, Positions.CongratsPosition);
                }
                else
                {
                    if (State.CardAnimationMotion == null)
                    {
                        MainLayer.DrawImage(Assets.Images.Layouts.TextBoard, Positions.SelectACardPosition, true);
                        MainLayer.DrawString((Assets.Fonts.BabyDoll._72), "Please Select A Card", Positions.SelectACardPosition);
                    }

                    MainLayer.Translate(0, BoardConstants.TopAreaHeight);
                    drawBottomCards();
                }
            }


            MainLayer.Restore();

            TouchManager.Render(MainLayer);
            MainLayer.End();
        }
        private bool tapCard(TouchType eventtype, TouchRect touchbox, int x, int y, bool collide)
        {
            if (eventtype == TouchType.TouchDown)
            {
                if (State.CardAnimationMotion != null)
                {
                    return(false);
                }

                Client.PlaySoundEffect(Assets.Sounds.Click);
                var    gc        = (Goal)touchbox.State;
                IImage goalImage = GoalPiece.GetGoalImage(gc);


                Goal[] goals = GameService.ClassicGameState.UnusedGoals;
                int    topRow = goals.Length / 2;
                int    bottomRow = goals.Length / 2 + goals.Length % 2;
                int    posx, posy;
                int    index = Array.IndexOf(goals, gc);

                int yAnimateOffset = 0;
                if (index < topRow)
                {
                    int centerOffset = (Positions.BottomCardAreaWidth / (topRow)) / 2;

                    posx           = ((Positions.BottomCardAreaWidth / topRow * (index))) + centerOffset;
                    posy           = (Positions.BottomCardSize / 2) - Positions.CardShadowHeight;
                    yAnimateOffset = 0;
                }
                else
                {
                    int centerOffset = (Positions.BottomCardAreaWidth / (bottomRow)) / 2;

                    posx           = ((Positions.BottomCardAreaWidth / bottomRow * (index - topRow))) + centerOffset;
                    posy           = Positions.BottomCardSize - 40 + Positions.BottomCardSize / 2 - Positions.CardShadowHeight;
                    yAnimateOffset = 300;
                }

                State.CurrentlySelectedGoal = gc;

                State.CardAnimationMotion = MotionManager.StartMotion(posx, posy, new AnimationMotion(Positions.Layout.Width / 2, posy - 850 - yAnimateOffset, 1500, AnimationEasing.BounceEaseIn))
                                            .Motion(new WaitMotion(1000))
                                            .Motion(new AnimationMotion(Positions.Layout.Width / 2, -3000, 1000, AnimationEasing.CubicEaseOut))
                                            .OnRender((layer, posX, posY, animationIndex, percentDone) => { MainLayer.DrawImage(goalImage, posX, posY, true); })
                                            .OnComplete(() =>
                {
                    gc.Used = true;

                    GameService.ClassicGameState.CurrentGoal = gc;
                    State.CardAnimationMotion = null;

                    GameService.ClassicGameState.GameState = GameSelectionState.SearchingBoard;
                    ScreenTransitioner.ChangeToBoardViewingScreen();
                });

                return(false);
            }
            return(true);
        }
Пример #22
0
        private void Init()
        {
            var layer = new MainLayer();

            this.AddChind(layer);
        }
Пример #23
0
        private void drawNumberSelection(TimeSpan elapsedGameTime)
        {
            MainLayer.Save();
            GameService.ClassicGameState.Board.Render(elapsedGameTime, MainLayer, disabled: true);
            MainLayer.DrawRectangle(new Color(10, 10, 10, 120), 0, 0, BoardConstants.TotalWidth, BoardConstants.TopAreaHeight);


            var nsBoard = new Rectangle(Positions.NumberSelectionBoxPosition.X, Positions.NumberSelectionBoxPosition.Y, Positions.NumberSelectionBoxSize.X, Positions.NumberSelectionBoxSize.Y, true);

            MainLayer.DrawRectangle(white, nsBoard);

            MainLayer.Translate(nsBoard.X, nsBoard.Y);


            var selectButtonRect = new Rectangle(Positions.NumberSelectionSelectButtonPosition.X, Positions.NumberSelectionSelectButtonPosition.Y, Positions.NumberSelectionSelectBoxSize.X, Positions.NumberSelectionSelectBoxSize.Y);

            MainLayer.DrawRectangle(buttonBlue, selectButtonRect);

            MainLayer.DrawString((Assets.Fonts.BabyDoll._100), "Select", selectButtonRect.Center.X, selectButtonRect.Center.Y);

            IImage barImage = Assets.Images.Layouts.NumberSelectBar;

            MainLayer.DrawImage(barImage, Positions.TopBarPosition, true);

            MainLayer.DrawImage(barImage, Positions.BottomBarPosition, true);

            for (int i = Math.Max(State.CurrentNumber - 2, 1); i <= Math.Min(State.CurrentNumber + 2, 60); i++)
            {
                Point numberPosition = null;
                Color color          = null;
                switch (i - State.CurrentNumber + 2)
                {
                case 0:
                    color          = Positions.DarkColorLighter;
                    numberPosition = Positions.NSFirstShadowPosition.Center;
                    break;

                case 1:
                    color          = Positions.DarkColorLight;
                    numberPosition = Positions.NSSecondShadowPosition.Center;
                    break;

                case 2:
                    color          = Positions.DarkColor;
                    numberPosition = Positions.NSMiddleNumberPosition;
                    break;

                case 3:
                    color          = Positions.DarkColorLight;
                    numberPosition = Positions.NSThirdShadowPosition.Center;
                    break;

                case 4:
                    color          = Positions.DarkColorLighter;
                    numberPosition = Positions.NSForthShadowPosition.Center;
                    break;
                }
                MainLayer.DrawString((Assets.Fonts.MyriadPro._100), i.ToString(), numberPosition, color);
            }
            MainLayer.Restore();
        }