Пример #1
0
        protected override async void OnCurrentNodeChanged(GameTreeNode newNode)
        {
            ITabInfo tabInfo = Mvx.Resolve <ITabProvider>().GetTabForViewModel(this);

            // This method is invoked by an event coming from Controller
            // If we are in the analyze mode, we want to change current node manually.
            if (IsAnalyzeModeEnabled)
            {
                // Notify Timeline VM that the game timeline has changed
                GameTreeViewModel.RaiseGameTreeChanged();
                await PlaySoundIfAppropriate(newNode);

                tabInfo.IsBlinking = true;
                return;
            }

            // TODO (future work)  Martin validate this hotfix
            // With handicap this method is fired much sooned and the ViewModel is not yet set, returning null.
            // Check for this case.
            if (newNode != null && tabInfo != null)
            {
                if (!IsTimelineInPast)
                {
                    RefreshBoard(Game.Controller.GameTree.LastNode); // TODO (future work)  Vita, Aniko: This will not work well with neither timeline nor analyze mode, I think
                }
                UpdateTimeline();
                RefreshInstructionCaption();
                // It is ABSOLUTELY necessary for this to be the last statement in this method,
                // because we need the UpdateTimeline calls to be in order.
                await PlaySoundIfAppropriate(newNode);

                tabInfo.IsBlinking = true;
            }
        }
Пример #2
0
        private static void GameTreeVMChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            GameTreeControl GameTreeControl = d as GameTreeControl;

            if (GameTreeControl != null)
            {
                GameTreeViewModel viewModel = (GameTreeViewModel)e.NewValue;
                viewModel.GameTreeRedrawRequested += GameTreeControl.GameTreeRedrawRequsted;

                // GameTree scrolling
                GameTreeControl.gameTreeRoot.PointerEntered      += GameTreeControl.GameTreeControl_PointerEntered;
                GameTreeControl.gameTreeRoot.PointerExited       += GameTreeControl.GameTreeControl_PointerExited;
                GameTreeControl.gameTreeRoot.PointerWheelChanged += GameTreeControl.GameTreeControl_PointerWheelChanged;

                // Arrows handling
                // This control has public methods to navigate using arrow keys.
                // These methods are being called by owning view.

                // Drawing
                GameTreeControl.canvas.Draw += GameTreeControl.Canvas_Draw;
                // GameTree scrolling and node highlighting
                GameTreeControl.canvas.PointerReleased += GameTreeControl.Canvas_PointerReleased;
                GameTreeControl.canvas.PointerMoved    += GameTreeControl.Canvas_PointerMoved;
                GameTreeControl.canvas.PointerPressed  += GameTreeControl.Canvas_PointerPressed;

                // Relaculate desired GameTree size and redraw
                GameTreeControl.UpdateGameTreeSize();
                GameTreeControl.canvas.Invalidate();
            }
        }
Пример #3
0
        public LiveGameViewModel(IGameSettings gameSettings, IQuestsManager questsManager, IDialogService dialogService)
            : base(gameSettings, questsManager, dialogService)
        {
            BlackPortrait = new PlayerPortraitViewModel(Game.Controller.Players.Black, Game);
            WhitePortrait = new PlayerPortraitViewModel(Game.Controller.Players.White, Game);

            // Register tool services
            ToolServices =
                new GameToolServices(
                    Localizer,
                    dialogService,
                    Game.Controller.Ruleset,
                    Game.Controller.GameTree);
            ToolServices.PassSoundShouldBePlayed      += ToolServices_PassSoundShouldBePlayed;
            ToolServices.StoneCapturesShouldBePlayed  += ToolServices_StoneCapturesShouldBePlayed;
            ToolServices.StonePlacementShouldBePlayed += ToolServices_StonePlacementShouldBePlayed;
            ToolServices.NodeChanged += (s, node) =>
            {
                AnalyzeToolsViewModel.OnNodeChanged();
                RefreshBoard(node);
                GameTreeViewModel.SelectedGameTreeNode = node;
                GameTreeViewModel.RaiseGameTreeChanged();
            };
            Tool = null;

            // Initialize analyze mode and register tools
            BoardViewModel.ToolServices = ToolServices;

            AnalyzeToolsViewModel = new AnalyzeToolsViewModel(ToolServices);
            AnalyzeToolsViewModel.CanGoBackToLiveGame = true;
            RegisterAnalyzeTools();
            _isAnalyzeModeEnabled = false;

            // System log visibility
            _isSystemLogEnabled = false;

            // Set up Timeline
            GameTreeViewModel = new GameTreeViewModel(Game.Controller.GameTree);
            GameTreeViewModel.GameTreeSelectionChanged += (s, e) =>
            {
                ToolServices.Node = e;
                BoardViewModel.BoardControlState.ShowTerritory =
                    e.Equals(Game.Controller.GameTree.LastNode) &&
                    (GamePhase == GamePhaseType.LifeDeathDetermination || GamePhase == GamePhaseType.Finished);
                RefreshBoard(e);
                AnalyzeToolsViewModel.OnNodeChanged();
            };

            _portraitUpdateTimer = Mvx.Resolve <ITimerService>()
                                   .StartTimer(TimeSpan.FromMilliseconds(100), UpdatePortraits);

            Game.Controller.MoveUndone += (s, e) => { UpdateTimeline(); };

            // When timeline selected node changes, check whether its not in the past. If it is then disable shadow stones.
            TimelineChanged += (s, e) => BoardViewModel.BoardControlState.IsShadowDrawingEnabled = !IsTimelineInPast;
        }
Пример #4
0
        public AnalyzeOnlyViewModel(IGameSettings gameSettings, IQuestsManager questsManager, IDialogService dialogService)
        {
            _dialogService = dialogService;
            var analyzeBundle = Mvx.Resolve <NavigationBundle>();

            LibraryItem   = analyzeBundle.LibraryItem;
            GameTree      = analyzeBundle.GameTree;
            GameInfo      = analyzeBundle.GameInfo;
            BlackPortrait = new PlayerPortraitViewModel(analyzeBundle.GameInfo.Black);
            WhitePortrait = new PlayerPortraitViewModel(analyzeBundle.GameInfo.White);

            _ruleset = new ChineseRuleset(analyzeBundle.GameInfo.BoardSize);

            // Register tool services
            ToolServices              = new GameToolServices(Localizer, dialogService, _ruleset, analyzeBundle.GameTree);
            ToolServices.NodeChanged += (s, node) =>
            {
                AnalyzeToolsViewModel.OnNodeChanged();
                RefreshBoard(node);
                GameTreeViewModel.SelectedGameTreeNode = node;
                GameTreeViewModel.RaiseGameTreeChanged();
            };
            ToolServices.PassSoundShouldBePlayed      += ToolServices_PassSoundShouldBePlayed;
            ToolServices.StoneCapturesShouldBePlayed  += ToolServices_StoneCapturesShouldBePlayed;
            ToolServices.StonePlacementShouldBePlayed += ToolServices_StonePlacementShouldBePlayed;
            Tool = null;

            BoardViewModel                        = new BoardViewModel(analyzeBundle.GameInfo.BoardSize);
            BoardViewModel.BoardTapped           += (s, e) => OnBoardTapped(e);
            BoardViewModel.GameTreeNode           = GameTree.GameTreeRoot;
            BoardViewModel.IsMarkupDrawingEnabled = true;
            BoardViewModel.IsShadowDrawingEnabled = true;


            // Initialize analyze mode and register tools
            BoardViewModel.ToolServices = ToolServices;

            ToolServices.Node = GameTree.GameTreeRoot;

            AnalyzeToolsViewModel = new AnalyzeToolsViewModel(ToolServices);
            AnalyzeToolsViewModel.CanGoBackToLiveGame = false;
            RegisterAnalyzeTools();
            Tool = AnalyzeToolsViewModel.StonePlacementTool;
            AnalyzeToolsViewModel.SelectedTool = Tool;

            // Set up Timeline
            GameTreeViewModel = new GameTreeViewModel(GameTree);
            GameTreeViewModel.GameTreeSelectionChanged += (s, e) =>
            {
                ToolServices.Node = e;
                RefreshBoard(e);
                AnalyzeToolsViewModel.OnNodeChanged();
            };
            GameTreeViewModel.SelectedGameTreeNode = GameTree.GameTreeRoot;
        }