public void TestTurtleOffTheBoard()
{
//arrange
var board = new BoardViewModel()
{
N = 2, M = 2
};
var turtle = new TurtleViewModel()
{
Direction = "North", X = 1, Y = 1
};
var exitPoint = new BoardItemViewModel()
{
X = 4, Y = 5
};
var mines = new List <BoardItemViewModel>();
mines.Add(new BoardItemViewModel()
{
X = 2, Y = 2
});
var moves = "mmmmrrrmmmmmmm";
var gameService = new GameService();
//act
var mockGame = gameService.Start(board, turtle, exitPoint, mines);
mockGame = gameService.Move(moves, mockGame);
//assert
Assert.IsTrue(mockGame.Outcome == "Moved off the board!");
Assert.IsTrue(mockGame.IsOver);
}
public void TestTurtleSucceeds()
{
//arrange
var board = new BoardViewModel()
{
N = 10, M = 10
};
var turtle = new TurtleViewModel()
{
Direction = "North", X = 1, Y = 1
};
var exitPoint = new BoardItemViewModel()
{
X = 1, Y = 3
};
var mines = new List <BoardItemViewModel>();
mines.Add(new BoardItemViewModel()
{
X = 4, Y = 5
});
var moves = "mmmm";
var gameService = new GameService();
//act
var mockGame = gameService.Start(board, turtle, exitPoint, mines);
mockGame = gameService.Move(moves, mockGame);
//assert
Assert.IsTrue(mockGame.Outcome == "Success!");
Assert.IsTrue(mockGame.IsOver);
}
public void AddBoard()
{
var ret = new BoardItemViewModel()
{
ItemSource = Boards,
Name = Utils.GetUniqueName("New Board", Boards.Select(x => (x as BoardItemViewModel).Name))
};
Boards.Add(ret);
Selection = ret;
}
private void BoardMouseDown(object sender, MouseButtonEventArgs e)
{
DragItem = sender as Canvas;
BoardItemViewModel board = DragItem.DataContext as BoardItemViewModel;
ViewModelLocator.PreviewTabViewModel.Selection = board;
mouseDownOffset = e.GetPosition(DragItem);
MouseHitType = SetHitType(new Rect(board.XPos, board.YPos, board.Width, board.Height), mouseDownOffset);
if (MouseHitType == HitType.None)
{
return;
}
SetMouseCursor();
mouseDown = true;
boardView.CaptureMouse();
}
public async Task <BoardItemView> AddInBoard(AskViewModel argViewModel)
{
var pItemVM = new BoardItemViewModel {
Numero = NuevoNumeroItem(), AskViewModel = argViewModel
};
var pItemViewObj = Activator.CreateInstance(argViewModel.MenuItem.ViewerType);
if (!(pItemViewObj is BoardItemView pItemView))
{
return(null);
}
pItemView.BindingContext = pItemVM;
await AddInBoard(pItemView);
return(pItemView);
}
static void Main(string[] args)
{
Console.WriteLine("Board?:");
BoardViewModel board = Console.ReadLine();
Console.WriteLine("Starting position?:");
TurtleViewModel turtle = Console.ReadLine();
Console.WriteLine("Exit point?:");
BoardItemViewModel exitPoint = Console.ReadLine();
Console.WriteLine("Mines?:");
var mines = new List <BoardItemViewModel>();
var mineInputs = Console.ReadLine()?.Split(',');
if (mineInputs != null)
{
mines.AddRange(mineInputs.Select(mineInput => (BoardItemViewModel)mineInput));
}
DisplayOutput(StartGame(board, turtle, exitPoint, mines));
}
private void BoardViewMove(object sender, MouseEventArgs e)
{
if (!mouseDown)
{
Canvas itemCanvas = (sender as Canvas).Children[0] as Canvas;
BoardItemViewModel board = itemCanvas.DataContext as BoardItemViewModel;
MouseHitType = SetHitType(new Rect(board.XPos, board.YPos, board.Width, board.Height), e.GetPosition(itemCanvas));
SetMouseCursor();
return;
}
if (DragItem.DataContext is BoardItemViewModel)
{
base.OnMouseMove(e);
e.Handled = true;
var vm = DragItem.DataContext as BoardItemViewModel;
Rect newrect = RectTransform(new Rect(vm.XPos, vm.YPos, vm.Width, vm.Height), e.GetPosition(boardView));
vm.XPos = Convert.ToInt32(newrect.X);
vm.YPos = Convert.ToInt32(newrect.Y);
vm.Width = Convert.ToInt32(newrect.Width);
vm.Height = Convert.ToInt32(newrect.Height);
vm.RefreshValues();
}
}
public PreviewTabViewModel()
{
var _game = ViewModelLocator.GameLoader.Game;
if (_game.GlobalPlayer == null)
{
_game.GlobalPlayer = new GlobalPlayer()
{
Counters = new List <Counter>(),
Groups = new List <Group>()
};
}
Hand = _game.Player.Hand == null ? null : new GroupItemViewModel(_game.Player.Hand);
TableGroup = new GroupItemViewModel(_game.Table);
Piles = new ObservableCollection <IdeListBoxItemBase>();
foreach (var pile in _game.Player.Groups)
{
Piles.Add(new GroupItemViewModel(pile)
{
ItemSource = Piles
});
}
Piles.CollectionChanged += (a, b) =>
{
_game.Player.Groups = Piles.Select(x => (x as GroupItemViewModel)._group).ToList();
RaisePropertyChanged("CollapsedPiles");
RaisePropertyChanged("VisiblePiles");
};
AddPileCommand = new RelayCommand(AddPile);
Counters = new ObservableCollection <IdeListBoxItemBase>();
foreach (var counter in _game.Player.Counters)
{
Counters.Add(new CounterItemViewModel(counter)
{
ItemSource = Counters
});
}
Counters.CollectionChanged += (a, b) =>
{
_game.Player.Counters = Counters.Select(x => (x as CounterItemViewModel)._counter).ToList();
};
AddCounterCommand = new RelayCommand(AddCounter);
GlobalPiles = new ObservableCollection <IdeListBoxItemBase>();
foreach (var pile in _game.GlobalPlayer.Groups)
{
GlobalPiles.Add(new GroupItemViewModel(pile)
{
ItemSource = GlobalPiles
});
}
GlobalPiles.CollectionChanged += (a, b) =>
{
_game.GlobalPlayer.Groups = Piles.Select(x => (x as GroupItemViewModel)._group).ToList();
RaisePropertyChanged("CollapsedGlobalPiles");
RaisePropertyChanged("VisibleGlobalPiles");
};
AddGlobalPileCommand = new RelayCommand(AddGlobalPile);
GlobalCounters = new ObservableCollection <IdeListBoxItemBase>();
foreach (var counter in _game.GlobalPlayer.Counters)
{
GlobalCounters.Add(new CounterItemViewModel(counter)
{
ItemSource = GlobalCounters
});
}
GlobalCounters.CollectionChanged += (a, b) =>
{
_game.GlobalPlayer.Counters = GlobalCounters.Select(x => (x as CounterItemViewModel)._counter).ToList();
};
AddGlobalCounterCommand = new RelayCommand(AddGlobalCounter);
CardSizes = new ObservableCollection <IdeListBoxItemBase>();
foreach (var sizeDef in _game.CardSizes)
{
var size = new SizeItemViewModel(sizeDef.Value)
{
ItemSource = CardSizes
};
if (sizeDef.Key == "")
{
size.IsDefault = true;
size.CanRemove = false;
}
CardSizes.Add(size);
}
CardSizes.CollectionChanged += (a, b) =>
{
UpdateSizes();
};
AddSizeCommand = new RelayCommand(AddSize);
Phases = new ObservableCollection <IdeListBoxItemBase>();
foreach (var phase in _game.Phases)
{
Phases.Add(new PhaseItemViewModel(phase)
{
ItemSource = Phases
});
}
Phases.CollectionChanged += (a, b) =>
{
_game.Phases = Phases.Select(x => (x as PhaseItemViewModel)._phase).ToList();
};
AddPhaseCommand = new RelayCommand(AddPhase);
Boards = new ObservableCollection <IdeListBoxItemBase>();
foreach (var boardDef in _game.GameBoards)
{
var board = new BoardItemViewModel(boardDef.Value)
{
ItemSource = Boards
};
if (boardDef.Key == "")
{
DefaultBoard = board;
}
Boards.Add(board);
}
ActiveBoard = DefaultBoard;
Boards.CollectionChanged += (a, b) =>
{
UpdateBoards();
};
AddBoardCommand = new RelayCommand(AddBoard);
Table = new TableItemViewModel();
Cards = new ObservableCollection <CardViewModel>();
var card = new CardViewModel
{
Size = DefaultSize
};
Cards.Add(card);
RaisePropertyChanged("Cards");
}
public GameViewModel Start(BoardViewModel board, TurtleViewModel turtle, BoardItemViewModel exitPoint, IEnumerable <BoardItemViewModel> mines)
{
return(Game.Create(board.N, board.M, turtle.X, turtle.Y, turtle.Direction, mines.Select(m => new Tuple <int, int>(m.X, m.Y)), exitPoint.X, exitPoint.Y));
}
private static GameViewModel StartGame(BoardViewModel board, TurtleViewModel turtle, BoardItemViewModel exitPoint, IEnumerable <BoardItemViewModel> mines)
{
return(_gameService.Start(board, turtle, exitPoint, mines));
}
private static GameViewModel StartGame(BoardViewModel board, TurtleViewModel turtle, BoardItemViewModel exitPoint, List <BoardItemViewModel> mines)
{
var game = StartGame(board, turtle, exitPoint, (IEnumerable <BoardItemViewModel>)mines);
while (game != null && !game.IsOver && !game.HasErrors)
{
Console.WriteLine("Moves?:");
var moves = Console.ReadLine();
game = Move(moves, game);
}
return(game);
}
