public GameWindow([NotNull] ILogger logger, [NotNull] IOpeningBookProvider openingBookProvider)
{
if (logger is null)
{
throw new ArgumentNullException(nameof(logger));
}
if (openingBookProvider is null)
{
throw new ArgumentNullException(nameof(openingBookProvider));
}
ViewModel = new GameWindowViewModel(logger, openingBookProvider);
DataContext = ViewModel;
InitializeComponent();
_canExecuteCopyFenToClipboard = true;
_canExecuteCopyHistoryToClipboard = true;
Title = AppConstants.FullTitle;
InitializeControls(false);
InitializePromotionControls();
ViewModel.SubscribeToChangeOf(() => ViewModel.CurrentGameBoard, OnCurrentGameBoardChanged);
ViewModel.SubscribeToChangeOf(() => ViewModel.IsReversedView, OnIsReversedViewChanged);
ViewModel.SubscribeToChangeOf(() => ViewModel.IsComputerPlayerActive, OnIsComputerPlayerActiveChanged);
Thread.CurrentThread.Priority = ThreadPriority.AboveNormal;
}
public GameWindow(Hero firstPlayer, Hero secondPlayer)
{
InitializeComponent();
viewModel = new GameWindowViewModel(firstPlayer, secondPlayer);
DataContext = viewModel;
hp1.Value = hp1.Maximum = firstPlayer.Hp;
hp2.Value = hp2.Maximum = secondPlayer.Hp;
try
{
BitmapImage bitmap = new BitmapImage();
bitmap.BeginInit();
bitmap.UriSource = new Uri(firstPlayer.ImageUrl, UriKind.Absolute);
bitmap.EndInit();
LeftHero.Source = bitmap;
}
catch { }
try
{
BitmapImage bitmap = new BitmapImage();
bitmap.BeginInit();
bitmap.UriSource = new Uri(secondPlayer.ImageUrl, UriKind.Absolute);
bitmap.EndInit();
RightHero.Source = bitmap;
}
catch { }
}
public void BonusScore_PlayerPicksAllSimpleCategoriesAndScoreIsGreaterThan62_ReturnsBonusScore()
{
GameWindowViewModel vm = new GameWindowViewModel(_randomizer, "A");
ICommand rollDiceCommand = vm.RollDiceCommand;
ICommand pickCategoryCommand = vm.PickCategoryCommand;
_randomizer.GetRandomNumber(1, 6).Returns(1);
rollDiceCommand.Execute(null);
pickCategoryCommand.Execute("Aces");
_randomizer.GetRandomNumber(1, 6).Returns(2);
rollDiceCommand.Execute(null);
pickCategoryCommand.Execute("Twos");
_randomizer.GetRandomNumber(1, 6).Returns(3);
rollDiceCommand.Execute(null);
pickCategoryCommand.Execute("Threes");
_randomizer.GetRandomNumber(1, 6).Returns(4);
rollDiceCommand.Execute(null);
pickCategoryCommand.Execute("Fours");
_randomizer.GetRandomNumber(1, 6).Returns(5);
rollDiceCommand.Execute(null);
pickCategoryCommand.Execute("Fives");
_randomizer.GetRandomNumber(1, 6).Returns(6);
rollDiceCommand.Execute(null);
pickCategoryCommand.Execute("Sixes");
var result = vm.BonusScore[0];
Assert.AreEqual(35, result);
}
public void RollDiceCommand_CommandExecutedAfterOneCategoryAlreadyPicked_ScoreTableReturnsAvailableCategoriesCombinedWithPreviousScores()
{
var vm = new GameWindowViewModel(_randomizer, "A");
_randomizer.GetRandomNumber(1, 6).Returns(1);
ICommand rollDiceCommand = vm.RollDiceCommand;
ICommand pickCategoryCommand = vm.PickCategoryCommand;
rollDiceCommand.Execute(null);
pickCategoryCommand.Execute("Aces");
_randomizer.GetRandomNumber(1, 6).Returns(2);
rollDiceCommand.Execute(null);
var expected = new Dictionary <Category, int?>
{
{ Category.Aces, 5 },
{ Category.Twos, 10 },
{ Category.Threes, 0 },
{ Category.Fours, 0 },
{ Category.Fives, 0 },
{ Category.Sixes, 0 },
{ Category.ThreeOfKind, 10 },
{ Category.FourOfKind, 10 },
{ Category.FullHouse, 0 },
{ Category.SmallStraight, 0 },
{ Category.LargeStraight, 0 },
{ Category.Chance, 10 },
{ Category.Yahtzee, 50 },
};
var result = vm.ScoreTable[0];
Assert.AreEqual(expected, result);
}
public ClientNet(MenuWindowViewModel mw)
{
tcp = new TcpClient();
brickbreaker = new GameWindow();
brickbreakermodel = brickbreaker.DataContext as GameWindowViewModel;
menuwindowmodel = mw;
SetPauseParams();
}
public void Setup()
{
_randomizer = Substitute.For <IRandomizer>();
_players = new[] { "A", "B", "C", "D" };
_vm = new GameWindowViewModel(_randomizer, _players);
_rollDiceCommand = _vm.RollDiceCommand;
_pickCategoryCommand = _vm.PickCategoryCommand;
_toggleDiceLockCommand = _vm.ToggleDiceLockCommand;
}
public void GameWindowViewModel_WhenCreated_PlayerNamesAreStored()
{
var expected = new[] { "A", "B", "C", "D" };
GameWindowViewModel vm = new GameWindowViewModel(_randomizer, expected);
var result = vm.Players;
Assert.AreEqual(expected, result);
}
/// <summary>
/// Init view method
/// </summary>
private void initView()
{
GameWindowModel = new GameWindowViewModel();
_lastMoveTime = DateTime.Now;
_lastMoveDownTime = DateTime.Now;
GameWindowModel.NeedRefreshVisualControl += GameWindow_NeedRefreshVisualControl;
CompositionTarget.Rendering += CompositionTarget_Rendering;
KeyDown += GameWindowView_KeyDown;
}
public void IsPickCategoryCommandAvailable_RollDiceCommandExecuted_ReturnsTrue()
{
GameWindowViewModel vm = new GameWindowViewModel(_randomizer, "A");
ICommand rollDiceCommand = vm.RollDiceCommand;
rollDiceCommand.Execute(null);
var result = vm.IsPickCategoryCommandAvailable.All(x => x.All(y => y.Value == true));
Assert.IsTrue(result);
}
public void IsPickCategoryCommandAvailable_RollDiceCommandExecutedAfterOneCategoryTaken_ReturnsFalseForThatCategory()
{
GameWindowViewModel vm = new GameWindowViewModel(_randomizer, "A", "B");
ICommand rollDiceCommand = vm.RollDiceCommand;
ICommand pickCategoryCommand = vm.PickCategoryCommand;
rollDiceCommand.Execute(null);
pickCategoryCommand.Execute("Aces");
var result = vm.IsPickCategoryCommandAvailable[0][Category.Aces];
Assert.IsFalse(result);
}
static void Main(string[] args)
{
VictoryValidator victoryValidator = new VictoryValidator();
PlayerFactory playerFactory = new PlayerFactory(victoryValidator);
ScenarioFactory scenarioFactory = new ScenarioFactory(playerFactory);
TicTacToeControlsViewModel TicTacToeControlsViewModel = new TicTacToeControlsViewModel(new TicTacToeControlsModel(), scenarioFactory);
TicTacToeGridViewModel TicTacToeGridViewModel = new TicTacToeGridViewModel(new TicTacToeGridModel(), TicTacToeControlsViewModel);
GameWindowViewModel GameWindowViewModel = new GameWindowViewModel(TicTacToeControlsViewModel, TicTacToeGridViewModel);
GameWindow gameWindow = new GameWindow(GameWindowViewModel);
gameWindow.ShowDialog();
}
public void IsPickCategoryCommandAvailable_OneCategoryTaken_ReturnsTrueForOtherCategory()
{
GameWindowViewModel vm = new GameWindowViewModel(_randomizer, "A");
ICommand rollDiceCommand = vm.RollDiceCommand;
ICommand pickCategoryCommand = vm.PickCategoryCommand;
rollDiceCommand.Execute(null);
pickCategoryCommand.Execute("Aces");
rollDiceCommand.Execute(null);
var result1 = vm.IsPickCategoryCommandAvailable[0][Category.Aces];
var result2 = vm.IsPickCategoryCommandAvailable[0][Category.Twos];
Assert.IsFalse(result1);
Assert.IsTrue(result2);
}
public static Window GetGameWindow(string gamePartnerName)
{
if (GameWindowPerContact.ContainsKey(gamePartnerName))
{
GameWindowViewModel ExistchatWindow = GameWindowPerContact[gamePartnerName].Key;
return(GameWindowPerContact[gamePartnerName].Value);
}
GameWindowViewModel gameWindowViewModel = new GameWindowViewModel(new UserDTO {
UserName = gamePartnerName
});
Window gameWindow = WindowService.ShowGameWindow(gameWindowViewModel);
gameWindow.Closing += OnWindowClosing;
GameWindowPerContact.Add(gamePartnerName, new KeyValuePair <GameWindowViewModel, Window>(gameWindowViewModel, gameWindow));
return(gameWindow);
}
public void MessageInfo_GameIsOverForOnePlayer_ReturnsWinner()
{
GameWindowViewModel vm = new GameWindowViewModel(_randomizer, "A");
ICommand rollDiceCommand = vm.RollDiceCommand;
ICommand pickCategoryCommand = vm.PickCategoryCommand;
_randomizer.GetRandomNumber(1, 6).Returns(1);
rollDiceCommand.Execute(null);
pickCategoryCommand.Execute("Aces");
rollDiceCommand.Execute(null);
pickCategoryCommand.Execute("Twos");
rollDiceCommand.Execute(null);
pickCategoryCommand.Execute("Threes");
rollDiceCommand.Execute(null);
pickCategoryCommand.Execute("Fours");
rollDiceCommand.Execute(null);
pickCategoryCommand.Execute("Fives");
rollDiceCommand.Execute(null);
pickCategoryCommand.Execute("Sixes");
rollDiceCommand.Execute(null);
pickCategoryCommand.Execute("ThreeOfKind");
rollDiceCommand.Execute(null);
pickCategoryCommand.Execute("FourOfKind");
rollDiceCommand.Execute(null);
pickCategoryCommand.Execute("FullHouse");
rollDiceCommand.Execute(null);
pickCategoryCommand.Execute("SmallStraight");
rollDiceCommand.Execute(null);
pickCategoryCommand.Execute("LargeStraight");
rollDiceCommand.Execute(null);
pickCategoryCommand.Execute("Chance");
rollDiceCommand.Execute(null);
pickCategoryCommand.Execute("Yahtzee");
var expected = "Player A is the winner!";
var result = vm.MessageInfo;
StringAssert.AreEqualIgnoringCase(expected, result);
}
public void RollDiceCommand_GameIsOver_CommandIsDisabled()
{
GameWindowViewModel vm = new GameWindowViewModel(_randomizer, "A");
ICommand rollDiceCommand = vm.RollDiceCommand;
ICommand pickCategoryCommand = vm.PickCategoryCommand;
_randomizer.GetRandomNumber(1, 6).Returns(1);
rollDiceCommand.Execute(null);
pickCategoryCommand.Execute("Aces");
rollDiceCommand.Execute(null);
pickCategoryCommand.Execute("Twos");
rollDiceCommand.Execute(null);
pickCategoryCommand.Execute("Threes");
rollDiceCommand.Execute(null);
pickCategoryCommand.Execute("Fours");
rollDiceCommand.Execute(null);
pickCategoryCommand.Execute("Fives");
rollDiceCommand.Execute(null);
pickCategoryCommand.Execute("Sixes");
rollDiceCommand.Execute(null);
pickCategoryCommand.Execute("ThreeOfKind");
rollDiceCommand.Execute(null);
pickCategoryCommand.Execute("FourOfKind");
rollDiceCommand.Execute(null);
pickCategoryCommand.Execute("FullHouse");
rollDiceCommand.Execute(null);
pickCategoryCommand.Execute("SmallStraight");
rollDiceCommand.Execute(null);
pickCategoryCommand.Execute("LargeStraight");
rollDiceCommand.Execute(null);
pickCategoryCommand.Execute("Chance");
rollDiceCommand.Execute(null);
pickCategoryCommand.Execute("Yahtzee");
var result = rollDiceCommand.CanExecute(null);
Assert.IsFalse(result);
}
public void TotalScore_AllCategoriesAreTaken_ReturnsTotalScore()
{
GameWindowViewModel vm = new GameWindowViewModel(_randomizer, "A");
ICommand rollDiceCommand = vm.RollDiceCommand;
ICommand pickCategoryCommand = vm.PickCategoryCommand;
_randomizer.GetRandomNumber(1, 6).Returns(1);
rollDiceCommand.Execute(null);
pickCategoryCommand.Execute("Aces");
rollDiceCommand.Execute(null);
pickCategoryCommand.Execute("Twos");
rollDiceCommand.Execute(null);
pickCategoryCommand.Execute("Threes");
rollDiceCommand.Execute(null);
pickCategoryCommand.Execute("Fours");
rollDiceCommand.Execute(null);
pickCategoryCommand.Execute("Fives");
rollDiceCommand.Execute(null);
pickCategoryCommand.Execute("Sixes");
rollDiceCommand.Execute(null);
pickCategoryCommand.Execute("ThreeOfKind");
rollDiceCommand.Execute(null);
pickCategoryCommand.Execute("FourOfKind");
rollDiceCommand.Execute(null);
pickCategoryCommand.Execute("FullHouse");
rollDiceCommand.Execute(null);
pickCategoryCommand.Execute("SmallStraight");
rollDiceCommand.Execute(null);
pickCategoryCommand.Execute("LargeStraight");
rollDiceCommand.Execute(null);
pickCategoryCommand.Execute("Chance");
rollDiceCommand.Execute(null);
pickCategoryCommand.Execute("Yahtzee");
var result = vm.TotalScore[0];
Assert.AreEqual(20 + 50, result);
}
/// <summary>
/// confirms the selection of the room by the player
/// if there are 2 players in the room, opens the playing field
/// </summary>
private void SelectRoom()
{
var br = new BinaryReader(tcp.GetStream());
bool freeroom = br.ReadBoolean();
bool temp = br.ReadBoolean();
if (freeroom)
{
if (temp)
{
brickbreaker.Dispatcher.Invoke(() =>
{
brickbreaker = new GameWindow();
brickbreakermodel = brickbreaker.DataContext as GameWindowViewModel;
brickbreakermodel.con = this;
brickbreaker.Show();
});
}
}
else
{
MessageBox.Show("This room is busy.", "System information", MessageBoxButton.OK, MessageBoxImage.Stop);
}
}
public void PickCategoryCommand_PlayerPicksAllSimpleCategories_PartialScoreReturnsScore()
{
GameWindowViewModel vm = new GameWindowViewModel(_randomizer, "A");
ICommand rollDiceCommand = vm.RollDiceCommand;
ICommand pickCategoryCommand = vm.PickCategoryCommand;
_randomizer.GetRandomNumber(1, 6).Returns(1);
rollDiceCommand.Execute(null);
pickCategoryCommand.Execute("Aces");
rollDiceCommand.Execute(null);
pickCategoryCommand.Execute("Twos");
rollDiceCommand.Execute(null);
pickCategoryCommand.Execute("Threes");
rollDiceCommand.Execute(null);
pickCategoryCommand.Execute("Fours");
rollDiceCommand.Execute(null);
pickCategoryCommand.Execute("Fives");
rollDiceCommand.Execute(null);
pickCategoryCommand.Execute("Sixes");
var result = vm.PartialScore[0];
Assert.AreEqual(5, result);
}
//DispatcherTimer dispatcherTimer = new DispatcherTimer();
//private int seconds = 30;
//private DateTime deadline;
public GameWindow(GameWindowViewModel gameVM)
{
InitializeComponent();
DataContext = gameVM;
}
public GameWindow(GameWindowViewModel GameWindowViewModel)
{
DataContext = GameWindowViewModel;
InitializeComponent();
}
public GameWindow()
{
InitializeComponent();
viewModel = new GameWindowViewModel();
DataContext = viewModel;
}
public GameWindowPage()
{
InitializeComponent();
gameWindowViewModel = new GameWindowViewModel(rectangleUI, rectangleBS, rectangleSub);
DataContext = gameWindowViewModel;
}
public void GameWindowViewModel_CanBeCreated()
{
GameWindowViewModel vm = new GameWindowViewModel(_randomizer, _players);
}
public GameWindow(GameWindowViewModel data) : this()
{
_gameVm = data;
DataContext = _gameVm;
}
/// <summary>
/// Opens the game field.
/// </summary>
private void OpenGameField()
{
const int WindowBorderOffset = 2;
double maxWindowRow = this.CurrentGame.Map.Windows.Max(window => window.Y);
double maxWindowCol = this.CurrentGame.Map.Windows.Max(window => window.X);
var gameFieldHeight = (maxWindowRow + 1) * GameConfiguration.GameWindowHeight;
var gameFieldWidth = (maxWindowCol + 1) * GameConfiguration.GameWindowWidth;
var initialVerticalOffset = (SystemParameters.WorkArea.Height / 2) - (gameFieldHeight / 2)
- ((maxWindowRow * WindowBorderOffset) / 2);
var initialHorizontalOffset = (SystemParameters.WorkArea.Width / 2) - (gameFieldWidth / 2)
- ((maxWindowCol * WindowBorderOffset) / 2);
var verticalOffset = initialVerticalOffset;
for (var currentRow = 0; currentRow <= maxWindowRow; currentRow++)
{
var horizontalOffset = initialHorizontalOffset;
var windowsInRow =
this.CurrentGame.Map.Windows.Where(window => window.Y == currentRow)
.OrderBy(window => window.X)
.ToList();
for (var currentCol = 0; currentCol <= maxWindowCol; currentCol++)
{
var currentWindow = windowsInRow.FirstOrDefault(window => window.X == currentCol);
if (currentWindow != null)
{
var gameWindow = new GameWindow();
gameWindow.Top = verticalOffset;
gameWindow.Left = horizontalOffset;
gameWindow.MinHeight = GameConfiguration.GameWindowHeight + WindowBorderOffset;
gameWindow.MinWidth = GameConfiguration.GameWindowWidth + WindowBorderOffset;
gameWindow.MaxHeight = gameWindow.MinHeight;
gameWindow.MaxWidth = gameWindow.MinWidth;
gameWindow.ResizeMode = ResizeMode.NoResize;
gameWindow.WindowStyle = WindowStyle.None;
gameWindow.BorderBrush = new SolidColorBrush(Colors.Black);
// Calculate the game field borders
var borderThickness = new Thickness();
if (
this.CurrentGame.Map.Windows.FirstOrDefault(
w => w.X == currentWindow.X - 1 && w.Y == currentWindow.Y) == null)
{
borderThickness.Left = 1;
}
if (
this.CurrentGame.Map.Windows.FirstOrDefault(
w => w.X == currentWindow.X + 1 && w.Y == currentWindow.Y) == null)
{
borderThickness.Right = 1;
}
if (
this.CurrentGame.Map.Windows.FirstOrDefault(
w => w.X == currentWindow.X && w.Y == currentWindow.Y - 1) == null)
{
borderThickness.Top = 1;
}
if (
this.CurrentGame.Map.Windows.FirstOrDefault(
w => w.X == currentWindow.X && w.Y == currentWindow.Y + 1) == null)
{
borderThickness.Bottom = 1;
}
gameWindow.BorderThickness = borderThickness;
var gameWindowViewModel = new GameWindowViewModel(currentWindow);
gameWindow.DataContext = gameWindowViewModel;
gameWindowViewModel.GameFieldClicked += this.GameFieldClicked;
gameWindowViewModel.AnimationFinished += this.AnimationFinished;
this.gameWindowViewModels.Add(gameWindowViewModel);
this.gameWindows.Add(gameWindow);
if (currentWindow.IsOwnWindow)
{
gameWindow.Show();
}
}
horizontalOffset += GameConfiguration.GameWindowWidth + WindowBorderOffset;
}
verticalOffset += GameConfiguration.GameWindowHeight + WindowBorderOffset;
}
}
