Esempio n. 1
0
        private void App_Startup(object sender, StartupEventArgs e)
        {
            // modell létrehozása
            _model           = new SudokuGameModel(new SudokuFileDataAccess());
            _model.GameOver += new EventHandler <SudokuEventArgs>(Model_GameOver);
            _model.NewGame();

            // nézemodell létrehozása
            _viewModel           = new SudokuViewModel(_model);
            _viewModel.NewGame  += new EventHandler(ViewModel_NewGame);
            _viewModel.ExitGame += new EventHandler(ViewModel_ExitGame);
            _viewModel.LoadGame += new EventHandler(ViewModel_LoadGame);
            _viewModel.SaveGame += new EventHandler(ViewModel_SaveGame);

            // nézet létrehozása
            _view             = new MainWindow();
            _view.DataContext = _viewModel;
            _view.Closing    += new System.ComponentModel.CancelEventHandler(View_Closing); // eseménykezelés a bezáráshoz
            _view.Show();

            // időzítő létrehozása
            _timer          = new DispatcherTimer();
            _timer.Interval = TimeSpan.FromSeconds(1);
            _timer.Tick    += new EventHandler(Timer_Tick);
            _timer.Start();
        }
Esempio n. 2
0
        /// <summary>
        /// Játékablak betöltésének eseménykezelője.
        /// </summary>
        private void GameForm_Load(Object sender, EventArgs e)
        {
            // adatelérés példányosítása
            _dataAccess = new SudokuFileDataAccess();

            // modell létrehozása és az eseménykezelők társítása
            _model = new SudokuGameModel(_dataAccess);
            _model.GameAdvanced += new EventHandler <SudokuEventArgs>(Game_GameAdvanced);
            _model.GameOver     += new EventHandler <SudokuEventArgs>(Game_GameOver);

            // időzítő létrehozása
            _timer          = new Timer();
            _timer.Interval = 1000;
            _timer.Tick    += new EventHandler(Timer_Tick);

            // játéktábla és menük inicializálása
            GenerateTable();
            SetupMenus();

            // új játék indítása
            _model.NewGame();
            SetupTable();

            _timer.Start();
        }
Esempio n. 3
0
        /// <summary>
        /// Sudoku nézetmodell példányosítása.
        /// </summary>
        /// <param name="model">A modell típusa.</param>
        public SudokuViewModel(SudokuGameModel model)
        {
            // játék csatlakoztatása
            _model = model;
            _model.GameAdvanced += new EventHandler <SudokuEventArgs>(Model_GameAdvanced);
            _model.GameOver     += new EventHandler <SudokuEventArgs>(Model_GameOver);
            _model.GameCreated  += new EventHandler <SudokuEventArgs>(Model_GameCreated);

            // parancsok kezelése
            NewGameCommand  = new DelegateCommand(param => OnNewGame());
            LoadGameCommand = new DelegateCommand(param => OnLoadGame());
            SaveGameCommand = new DelegateCommand(param => OnSaveGame());
            ExitCommand     = new DelegateCommand(param => OnExitGame());

            // játéktábla létrehozása
            Fields = new ObservableCollection <SudokuField>();
            for (Int32 i = 0; i < _model.Table.Size; i++) // inicializáljuk a mezőket
            {
                for (Int32 j = 0; j < _model.Table.Size; j++)
                {
                    Fields.Add(new SudokuField
                    {
                        IsLocked    = true,
                        Text        = String.Empty,
                        X           = i,
                        Y           = j,
                        Number      = i * _model.Table.Size + j, // a gomb sorszáma, amelyet felhasználunk az azonosításhoz
                        StepCommand = new DelegateCommand(param => StepGame(Convert.ToInt32(param)))
                                                                 // ha egy mezőre léptek, akkor jelezzük a léptetést, változtatjuk a lépésszámot
                    });
                }
            }

            RefreshTable();
        }
Esempio n. 4
0
        public void Initialize()
        {
            _model = new SudokuGameModel(null);
            // perzisztencia nélküli modellt hozunk létre

            _model.GameAdvanced += new EventHandler <SudokuEventArgs>(Model_GameAdvanced);
            _model.GameOver     += new EventHandler <SudokuEventArgs>(Model_GameOver);
        }
Esempio n. 5
0
        public void Initialize()
        {
            _mockedTable = new SudokuTable();
            _mockedTable.SetValue(1, 2, 3, false);
            _mockedTable.SetValue(4, 5, 6, true);
            _mockedTable.SetValue(7, 8, 9, false);
            // előre definiálunk egy játéktáblát a perzisztencia mockolt teszteléséhez

            _mock = new Mock <ISudokuDataAccess>();
            _mock.Setup(mock => mock.LoadAsync(It.IsAny <String>()))
            .Returns(() => Task.FromResult(_mockedTable));
            // a mock a LoadAsync műveletben bármilyen paraméterre az előre beállított játéktáblát fogja visszaadni

            _model = new SudokuGameModel(_mock.Object);
            // példányosítjuk a modellt a mock objektummal

            _model.GameAdvanced += new EventHandler <SudokuEventArgs>(Model_GameAdvanced);
            _model.GameOver     += new EventHandler <SudokuEventArgs>(Model_GameOver);
        }