Exemplo n.º 1
0
        public MainViewModel()
        {
            //var connectionManager = new ConnectionManager();
            //Logging.Instance.DisableLevel(LoggingLevel.Trace); // Message logging floods the logs if enabled
            var connectionManager = new LoggingConnectionManagerAdapter(new LoggingConnectionManager(Logging.Instance));

            Game = new Core.NoOpRunner(connectionManager);
            SettingsViewModel = new SettingsViewModel(this);

            Game.OnMessageReceived += HandleMessageReceived;
        }
Exemplo n.º 2
0
        public MainWindow()
        {
            InitializeComponent();

            play_button.Click += (s, e) =>
            {
                SetUpBackground();

                var viewModel = (MainViewModel)DataContext;

                Game = viewModel.Game;


                InputHandlerImplementor inputHandlerImpl;
                if (Game.IsHost)
                {
                    renderingFacade = new HostRenderingFacade();

                    inputHandlerImpl = new InputHandlerImplementorPlayerOne(Game.Player);
                }
                else
                {
                    renderingFacade = new ClientRenderingFacade();

                    inputHandlerImpl = new InputHandlerImplementorPlayerTwo();
                }


                inputHandler = new InputHandlerAbstractionArrows(inputHandlerImpl);
                //inputHandler = new InputHandlerAbstractionWasd(inputHandlerImpl);

                ConfigureKeys();

                timer          = new DispatcherTimer();
                timer.Interval = TimeSpan.FromMilliseconds(GameSettings.TimeBetweenFramesMs);
                timer.Tick    += async(o, a) => { await TriggerRender(); };

                timer.Start();
                Game.IsGameStarted = true;

                background_panel.MouseLeftButtonDown += (o, a) =>
                {
                    var pos        = a.GetPosition(background_panel);
                    var cellWidth  = (int)background_panel.ActualWidth / GameSettings.HorizontalCellCount;
                    var cellHeight = (int)background_panel.ActualHeight / GameSettings.VerticalCellCount;

                    Game.HandleMouseClick((int)pos.X / cellWidth, (int)(background_panel.ActualHeight - pos.Y) / cellHeight);
                };
            };
        }
Exemplo n.º 3
0
        public override async Task CycleGameFrames(Core.NoOpRunner game, Canvas playerCanvas, Canvas powerUpsCanvas,
                                                   Canvas platformsCanvas)
        {
            Logging.Instance.Write("Facade pattern: Host", LoggingLevel.Pattern);

            if (CountBetweenFrames == GameSettings.TimeBetweenMapStep)
            {
                CountBetweenFrames = 0;

                await game.OnMapMoveLoopFired();
            }

            CountBetweenFrames++;

            game.Player.OnLoopFired((WindowPixel[, ])game.PlatformsContainer.GetShapes().Clone());

            await game.UpdateClientsGame();

            BaseCycle(game, playerCanvas, platformsCanvas, powerUpsCanvas);
        }
Exemplo n.º 4
0
        protected void BaseCycle(Core.NoOpRunner game, Canvas playerCanvas, Canvas platformsCanvas, Canvas powerUpsCanvas)
        {
            if (PlayerRenderer == null || PlatformsRenderer == null || PowerUpsRenderer == null)
            {
                PlayerRenderer = new PlayerRenderer(game.Player);

                PlatformsRenderer = new PlatformsRenderer(game.PlatformsContainer);

                PowerUpsRenderer = new PowerUpsRenderer(game.PowerUpsContainer);
            }

            game.Player.LoopPowerUps();

            var powerUp = game.PowerUpsContainer.GetPowerUpAt(game.Player.CenterPosX, game.Player.CenterPosY);

            if (powerUp != null)
            {
                if (powerUp.PowerUpType == PowerUps.Double_Jump)
                {
                    AddDecoratorLayer(powerUp.PowerUpType); //Add decorator layer
                }

                if (game.IsHost)
                {
                    game.Player.TakePowerUp(powerUp.PowerUpType); //Player pick up power up
                }

                game.PowerUpsContainer.RemovePowerUp(game.Player.CenterPosX,
                                                     game.Player.CenterPosY); //Remove power up from display
            }

            foreach (var usingPowerUp in game.Player.ActivePowerUps)
            {
                if (DisplayingPlayerOnePowerUps.Contains(usingPowerUp))
                {
                    continue;
                }

                DisplayingPlayerOnePowerUps.Add(usingPowerUp);

                AddDecoratorLayer(usingPowerUp);
            }

            var playerUsedPowerUp = game.Player.ExhaustedPowerUp;

            if (playerUsedPowerUp != null)
            {
                DisplayingPlayerOnePowerUps.Remove((PowerUps)playerUsedPowerUp);

                GifImage animation;
                //Remove layer
                switch (playerUsedPowerUp)
                {
                case PowerUps.Speed_Boost:
                    PlayerRenderer = ((PlayerDecorator)PlayerRenderer).RemoveLayer(VisualElementType.SpeedBoost);

                    animation = playerCanvas.Children.OfType <GifImage>()
                                .FirstOrDefault(x => x.VisualType == VisualElementType.SpeedBoost);

                    playerCanvas.Children.Remove(animation);
                    break;

                case PowerUps.Invisibility:

                    break;

                case PowerUps.Invulnerability:
                    PlayerRenderer =
                        ((PlayerDecorator)PlayerRenderer).RemoveLayer(VisualElementType.Invulnerability);

                    animation = playerCanvas.Children.OfType <GifImage>()
                                .FirstOrDefault(x => x.VisualType == VisualElementType.Invulnerability);

                    playerCanvas.Children.Remove(animation);
                    break;

                case PowerUps.Double_Jump:
                    PlayerRenderer = ((PlayerDecorator)PlayerRenderer).RemoveLayer(VisualElementType.DoubleJump);

                    animation = playerCanvas.Children.OfType <GifImage>()
                                .FirstOrDefault(x => x.VisualType == VisualElementType.DoubleJump);

                    playerCanvas.Children.Remove(animation);

                    break;

                default:
                    throw new ArgumentOutOfRangeException();
                }
            }

            PowerUpsRenderer.Display(platformsCanvas);

            PlatformsRenderer.Display(powerUpsCanvas);

            PlayerRenderer.Display(playerCanvas);
        }
Exemplo n.º 5
0
 public abstract Task CycleGameFrames(Core.NoOpRunner game, Canvas playerCanvas, Canvas powerUpsCanvas,
                                      Canvas platformsCanvas);
Exemplo n.º 6
0
        public override async Task CycleGameFrames(Core.NoOpRunner game, Canvas playerCanvas, Canvas powerUpsCanvas, Canvas platformsCanvas)
        {
            Logging.Instance.Write("Facade pattern: Client", LoggingLevel.Pattern);

            BaseCycle(game, playerCanvas, platformsCanvas, powerUpsCanvas);
        }