public RageCardGameMainView(IEventAggregator aggregator,
                                    TestOptions test,
                                    RageCardGameVMData model
                                    )
        {
            _aggregator = aggregator;
            _model      = model;
            _aggregator.Subscribe(this);

            _score         = new ScoreBoardWPF();
            _playerHandWPF = new BaseHandWPF <RageCardGameCardInformation, RageCardGameGraphicsCP, CardGraphicsWPF>();

            _trick1 = new SeveralPlayersTrickWPF <EnumColor, RageCardGameCardInformation, RageCardGameGraphicsCP, CardGraphicsWPF, RageCardGamePlayerItem>();


            StackPanel mainStack             = new StackPanel();
            ParentSingleUIContainer?restoreP = null;

            if (test.SaveOption == EnumTestSaveCategory.RestoreOnly)
            {
                restoreP = new ParentSingleUIContainer()
                {
                    Name = nameof(RageCardGameMainViewModel.RestoreScreen)
                };
            }


            PopulateScores(_score);
            SimpleLabelGrid firstInfo = new SimpleLabelGrid();

            firstInfo.AddRow("Turn", nameof(RageCardGameMainViewModel.NormalTurn));
            firstInfo.AddRow("Status", nameof(RageCardGameMainViewModel.Status));
            firstInfo.AddRow("Trump", nameof(RageCardGameMainViewModel.TrumpSuit));
            firstInfo.AddRow("Lead", nameof(RageCardGameMainViewModel.Lead));
            mainStack.Children.Add(_trick1);
            mainStack.Children.Add(_playerHandWPF);
            mainStack.Children.Add(firstInfo.GetContent);
            mainStack.Children.Add(_score);

            if (restoreP != null)
            {
                mainStack.Children.Add(restoreP); //default add to grid but does not have to.
            }
            Content = mainStack;
        }
Example #2
0
        public XactikaMainView(IEventAggregator aggregator,
                               TestOptions test,
                               XactikaVMData model,
                               IGamePackageRegister register,
                               StatsBoardCP boardCP
                               )
        {
            _aggregator = aggregator;
            _model      = model;
            _aggregator.Subscribe(this);
            register.RegisterControl(_stats1.Element, "main");
            boardCP.LinkBoard();
            _score         = new ScoreBoardWPF();
            _playerHandWPF = new BaseHandWPF <XactikaCardInformation, XactikaGraphicsCP, CardGraphicsWPF>();
            _shape1        = new ChooseShapeWPF();
            _trick1        = new SeveralPlayersTrickWPF <EnumShapes, XactikaCardInformation, XactikaGraphicsCP, CardGraphicsWPF, XactikaPlayerItem>();

            StackPanel mainStack             = new StackPanel();
            ParentSingleUIContainer?restoreP = null;

            if (test.SaveOption == EnumTestSaveCategory.RestoreOnly)
            {
                restoreP = new ParentSingleUIContainer()
                {
                    Name = nameof(XactikaMainViewModel.RestoreScreen)
                };
            }


            _score.AddColumn("Cards Left", false, nameof(XactikaPlayerItem.ObjectCount)); //very common.
            _score.AddColumn("Bid Amount", false, nameof(XactikaPlayerItem.BidAmount));
            _score.AddColumn("Tricks Won", false, nameof(XactikaPlayerItem.TricksWon));
            _score.AddColumn("Current Score", false, nameof(XactikaPlayerItem.CurrentScore));
            _score.AddColumn("Total Score", false, nameof(XactikaPlayerItem.TotalScore));
            SimpleLabelGrid firstInfo = new SimpleLabelGrid();

            firstInfo.AddRow("Turn", nameof(XactikaMainViewModel.NormalTurn));
            firstInfo.AddRow("Status", nameof(XactikaMainViewModel.Status));
            firstInfo.AddRow("Round", nameof(XactikaMainViewModel.RoundNumber));
            firstInfo.AddRow("Mode", nameof(XactikaMainViewModel.GameModeText));
            StackPanel shapeStack = new StackPanel();

            shapeStack.Children.Add(_shape1);
            ParentSingleUIContainer parent = new ParentSingleUIContainer()
            {
                Name = nameof(XactikaMainViewModel.ShapeScreen)
            };

            shapeStack.Children.Add(parent);
            Grid tempGrid = new Grid();

            AddAutoRows(tempGrid, 1);
            AddLeftOverColumn(tempGrid, 1);
            AddAutoColumns(tempGrid, 2);
            StackPanel tempStack = new StackPanel();

            tempStack.Orientation = Orientation.Horizontal;
            tempStack.Children.Add(_trick1);
            tempStack.Children.Add(shapeStack);
            AddControlToGrid(tempGrid, tempStack, 0, 0);
            parent = new ParentSingleUIContainer()
            {
                Name = nameof(XactikaMainViewModel.BidScreen)
            };
            AddControlToGrid(tempGrid, parent, 0, 0); // if one is visible, then the other is not
            AddControlToGrid(tempGrid, _stats1, 0, 2);
            AddControlToGrid(tempGrid, _score, 0, 1);
            mainStack.Children.Add(tempGrid);
            mainStack.Children.Add(_playerHandWPF);
            mainStack.Children.Add(firstInfo.GetContent);
            if (restoreP != null)
            {
                mainStack.Children.Add(restoreP); //default add to grid but does not have to.
            }
            Content = mainStack;
        }
        public RookMainView(IEventAggregator aggregator,
                            TestOptions test,
                            RookVMData model
                            )
        {
            _aggregator = aggregator;
            _model      = model;
            _aggregator.Subscribe(this);

            _score         = new ScoreBoardWPF();
            _playerHandWPF = new BaseHandWPF <RookCardInformation, RookGraphicsCP, CardGraphicsWPF>();


            _trick1 = new SeveralPlayersTrickWPF <EnumColorTypes, RookCardInformation, RookGraphicsCP, CardGraphicsWPF, RookPlayerItem>();
            _dummy1 = new BaseHandWPF <RookCardInformation, RookGraphicsCP, CardGraphicsWPF>();

            StackPanel mainStack             = new StackPanel();
            ParentSingleUIContainer?restoreP = null;

            if (test.SaveOption == EnumTestSaveCategory.RestoreOnly)
            {
                restoreP = new ParentSingleUIContainer()
                {
                    Name = nameof(RookMainViewModel.RestoreScreen)
                };
            }
            StackPanel otherStack = new StackPanel();

            otherStack.Orientation = Orientation.Horizontal;
            mainStack.Children.Add(otherStack);

            ParentSingleUIContainer parent = new ParentSingleUIContainer()
            {
                Name = nameof(RookMainViewModel.NestScreen)
            };

            mainStack.Children.Add(parent);
            _score.AddColumn("Bid Amount", true, nameof(RookPlayerItem.BidAmount));
            _score.AddColumn("Tricks Won", false, nameof(RookPlayerItem.TricksWon));
            _score.AddColumn("Current Score", false, nameof(RookPlayerItem.CurrentScore));
            _score.AddColumn("Total Score", false, nameof(RookPlayerItem.TotalScore));

            SimpleLabelGrid firstInfo = new SimpleLabelGrid();

            firstInfo.AddRow("Turn", nameof(RookMainViewModel.NormalTurn));
            firstInfo.AddRow("Trump", nameof(RookMainViewModel.TrumpSuit));
            firstInfo.AddRow("Status", nameof(RookMainViewModel.Status));


            mainStack.Children.Add(_playerHandWPF);

            mainStack.Children.Add(_dummy1);
            otherStack.Children.Add(_score);
            otherStack.Children.Add(firstInfo.GetContent);
            parent = new ParentSingleUIContainer()
            {
                Name = nameof(RookMainViewModel.BidScreen)
            };
            otherStack.Children.Add(parent);
            parent = new ParentSingleUIContainer()
            {
                Name = nameof(RookMainViewModel.ColorScreen)
            };
            otherStack.Children.Add(parent);
            otherStack.Children.Add(_trick1);

            if (restoreP != null)
            {
                mainStack.Children.Add(restoreP); //default add to grid but does not have to.
            }
            Content = mainStack;
        }
        public HuseHeartsMainView(IEventAggregator aggregator,
                                  TestOptions test,
                                  HuseHeartsVMData model
                                  )
        {
            _aggregator = aggregator;
            _model      = model;
            _aggregator.Subscribe(this);

            _score                 = new ScoreBoardWPF();
            _playerHandWPF         = new BaseHandWPF <HuseHeartsCardInformation, ts, DeckOfCardsWPF <HuseHeartsCardInformation> >();
            _playerHandWPF.Divider = 1.4;
            _trick1                = new SeveralPlayersTrickWPF <EnumSuitList, HuseHeartsCardInformation, ts, DeckOfCardsWPF <HuseHeartsCardInformation>, HuseHeartsPlayerItem>();
            _dummy1                = new BaseHandWPF <HuseHeartsCardInformation, ts, DeckOfCardsWPF <HuseHeartsCardInformation> >();
            _blind1                = new BaseHandWPF <HuseHeartsCardInformation, ts, DeckOfCardsWPF <HuseHeartsCardInformation> >();

            _trick1.Width   = 350;
            _dummy1.Divider = 1.4;



            StackPanel mainStack             = new StackPanel();
            ParentSingleUIContainer?restoreP = null;

            if (test.SaveOption == EnumTestSaveCategory.RestoreOnly)
            {
                restoreP = new ParentSingleUIContainer()
                {
                    Name = nameof(HuseHeartsMainViewModel.RestoreScreen)
                };
            }
            StackPanel otherStack = new StackPanel();

            otherStack.Orientation = Orientation.Horizontal;
            mainStack.Children.Add(otherStack);



            _score.AddColumn("Cards Left", false, nameof(HuseHeartsPlayerItem.ObjectCount)); //very common.
            _score.AddColumn("Tricks Won", false, nameof(HuseHeartsPlayerItem.TricksWon));
            _score.AddColumn("Current Score", false, nameof(HuseHeartsPlayerItem.CurrentScore));
            _score.AddColumn("Previous Score", false, nameof(HuseHeartsPlayerItem.PreviousScore));
            _score.AddColumn("Total Score", false, nameof(HuseHeartsPlayerItem.TotalScore));
            SimpleLabelGrid firstInfo = new SimpleLabelGrid();

            firstInfo.AddRow("Turn", nameof(HuseHeartsMainViewModel.NormalTurn));
            firstInfo.AddRow("Status", nameof(HuseHeartsMainViewModel.Status));
            firstInfo.AddRow("Round", nameof(HuseHeartsMainViewModel.RoundNumber));

            otherStack.Children.Add(_score);
            otherStack.Children.Add(firstInfo.GetContent);
            otherStack.Children.Add(_trick1);
            ParentSingleUIContainer parent = new ParentSingleUIContainer()
            {
                Name = nameof(HuseHeartsMainViewModel.PassingScreen)
            };

            otherStack.Children.Add(parent);
            parent = new ParentSingleUIContainer()
            {
                Name = nameof(HuseHeartsMainViewModel.MoonScreen)
            };
            otherStack.Children.Add(parent);
            otherStack.Children.Add(_blind1);
            mainStack.Children.Add(_playerHandWPF);
            mainStack.Children.Add(_dummy1);

            if (restoreP != null)
            {
                mainStack.Children.Add(restoreP); //default add to grid but does not have to.
            }
            Content = mainStack;
        }
        public HorseshoeCardGameMainView(IEventAggregator aggregator,
                                         TestOptions test,
                                         HorseshoeCardGameVMData model,
                                         HorseshoeCardGameGameContainer gameContainer
                                         )
        {
            _aggregator    = aggregator;
            _model         = model;
            _gameContainer = gameContainer;
            _aggregator.Subscribe(this);

            _score         = new ScoreBoardWPF();
            _playerHandWPF = new BaseHandWPF <HorseshoeCardGameCardInformation, ts, DeckOfCardsWPF <HorseshoeCardGameCardInformation> >();

            _trick1 = new SeveralPlayersTrickWPF <EnumSuitList, HorseshoeCardGameCardInformation, ts, DeckOfCardsWPF <HorseshoeCardGameCardInformation>, HorseshoeCardGamePlayerItem>();



            StackPanel mainStack = new StackPanel();

            mainStack.Children.Add(_trick1);

            _score.AddColumn("Cards Left", false, nameof(HorseshoeCardGamePlayerItem.ObjectCount)); //very common.
            _score.AddColumn("Tricks Won", true, nameof(HorseshoeCardGamePlayerItem.TricksWon), rightMargin: 10);
            _score.AddColumn("Previous Score", false, nameof(HorseshoeCardGamePlayerItem.PreviousScore));
            _score.AddColumn("Total Score", false, nameof(HorseshoeCardGamePlayerItem.TotalScore));
            SimpleLabelGrid firstInfo = new SimpleLabelGrid();

            firstInfo.AddRow("Turn", nameof(HorseshoeCardGameMainViewModel.NormalTurn));
            firstInfo.AddRow("Status", nameof(HorseshoeCardGameMainViewModel.Status));


            ParentSingleUIContainer?restoreP = null;

            if (test.SaveOption == EnumTestSaveCategory.RestoreOnly)
            {
                restoreP = new ParentSingleUIContainer()
                {
                    Name = nameof(HorseshoeCardGameMainViewModel.RestoreScreen)
                };
            }


            mainStack.Children.Add(_playerHandWPF);
            mainStack.Children.Add(firstInfo.GetContent);

            mainStack.Children.Add(_score);

            Grid finalGrid = new Grid();
            Grid tempGrid  = new Grid();

            AddLeftOverRow(tempGrid, 1);
            AddLeftOverRow(tempGrid, 1);
            AddLeftOverColumn(finalGrid, 1);
            AddAutoColumns(finalGrid, 1);
            AddControlToGrid(finalGrid, mainStack, 0, 0);
            AddControlToGrid(finalGrid, tempGrid, 0, 1);
            AddControlToGrid(tempGrid, _temp1, 0, 0);
            AddControlToGrid(tempGrid, _temp2, 1, 0);



            if (restoreP != null)
            {
                mainStack.Children.Add(restoreP); //default add to grid but does not have to.
            }
            Content = finalGrid;
        }
Example #6
0
        public SnagCardGameMainView(IEventAggregator aggregator,
                                    TestOptions test,
                                    SnagCardGameVMData model
                                    )
        {
            _aggregator = aggregator;
            _model      = model;
            _aggregator.Subscribe(this);

            _deckGPile     = new BaseDeckWPF <SnagCardGameCardInformation, ts, DeckOfCardsWPF <SnagCardGameCardInformation> >();
            _discardGPile  = new BasePileWPF <SnagCardGameCardInformation, ts, DeckOfCardsWPF <SnagCardGameCardInformation> >();
            _score         = new ScoreBoardWPF();
            _playerHandWPF = new BaseHandWPF <SnagCardGameCardInformation, ts, DeckOfCardsWPF <SnagCardGameCardInformation> >();

            _trick1 = new SeveralPlayersTrickWPF <EnumSuitList, SnagCardGameCardInformation, ts, DeckOfCardsWPF <SnagCardGameCardInformation>, SnagCardGamePlayerItem>();

            _bar1                   = new BaseHandWPF <SnagCardGameCardInformation, ts, DeckOfCardsWPF <SnagCardGameCardInformation> >();
            _human1                 = new BaseHandWPF <SnagCardGameCardInformation, ts, DeckOfCardsWPF <SnagCardGameCardInformation> >();
            _opponent1              = new BaseHandWPF <SnagCardGameCardInformation, ts, DeckOfCardsWPF <SnagCardGameCardInformation> >();
            _bar1.HandType          = HandObservable <SnagCardGameCardInformation> .EnumHandList.Vertical;
            _bar1.ExtraControlSpace = 20;


            StackPanel mainStack             = new StackPanel();
            ParentSingleUIContainer?restoreP = null;

            if (test.SaveOption == EnumTestSaveCategory.RestoreOnly)
            {
                restoreP = new ParentSingleUIContainer()
                {
                    Name = nameof(SnagCardGameMainViewModel.RestoreScreen)
                };
            }


            StackPanel otherStack = new StackPanel();

            otherStack.Orientation = Orientation.Horizontal;


            StackPanel tempStack = new StackPanel();

            otherStack.Children.Add(_trick1);
            tempStack.Children.Add(_human1);
            tempStack.Children.Add(_opponent1);
            otherStack.Children.Add(tempStack);
            mainStack.Children.Add(otherStack);
            _score.AddColumn("Cards Won", true, nameof(SnagCardGamePlayerItem.CardsWon));
            _score.AddColumn("Current Points", true, nameof(SnagCardGamePlayerItem.CurrentPoints));
            _score.AddColumn("Total Points", true, nameof(SnagCardGamePlayerItem.TotalPoints));
            SimpleLabelGrid firstInfo = new SimpleLabelGrid();

            firstInfo.AddRow("Turn", nameof(SnagCardGameMainViewModel.NormalTurn));
            firstInfo.AddRow("Status", nameof(SnagCardGameMainViewModel.Status));
            firstInfo.AddRow("Instructions", nameof(SnagCardGameMainViewModel.Instructions));
            mainStack.Children.Add(_playerHandWPF);
            mainStack.Children.Add(firstInfo.GetContent);
            mainStack.Children.Add(_score);
            Grid otherGrid = new Grid();

            AddLeftOverColumn(otherGrid, 20);
            AddLeftOverColumn(otherGrid, 80); // can always be adjusted
            AddControlToGrid(otherGrid, _bar1, 0, 0);
            AddControlToGrid(otherGrid, mainStack, 0, 1);


            _deckGPile.Margin = new Thickness(5, 5, 5, 5);

            _discardGPile.Margin = new Thickness(5, 5, 5, 5);


            if (restoreP != null)
            {
                mainStack.Children.Add(restoreP); //default add to grid but does not have to.
            }
            Content = otherGrid;
        }