private void Update()
{
if (Input.GetKeyDown(KeyCode.Space))
{
BoardService.CheckBoard();
}
}
/// <summary>
/// Load tiles to array
/// </summary>
private void LoadTilesToArray()
{
foreach (Transform group in transform)
{
var groupX = (int)char.GetNumericValue(group.name[0]);
var groupY = (int)char.GetNumericValue(group.name[2]);
foreach (Transform tile in group)
{
var tileX = (int)char.GetNumericValue(tile.name[0]);
var tileY = (int)char.GetNumericValue(tile.name[2]);
var x = groupX * 3 + tileX;
var y = groupY * 3 + tileY;
BoardService.TilesView[x, y] = tile.GetComponent <BoardTileView>();
if (!View.constantBoard)
{
BoardService.TilesView[x, y].OnTilePressed += pressedTile =>
{
ShowKeyboardSignal.Dispatch(pressedTile);
};
BoardService.TilesView[x, y].ValueChanged += () => { BoardService.CheckBoard(); };
}
else
{
tile.GetComponent <BoxCollider2D>().enabled = false;
}
}
}
BoardFinishedLoadingSignal.Dispatch();
}
public BoardController(IMapper _mapper)
{
boardService = new BoardService();
mapper = _mapper;
logger = NLog.Web.NLogBuilder.ConfigureNLog(AppConfiguration.NLogPath).GetCurrentClassLogger();
}
internal void InitializeBoard()
{
// Bootstrapper
var boardService = new BoardService();
var gameModel = new GameModel(boardService);
var gameController = new GameController(gameModel);
var boardModel = new BoardModel(boardService);
var boardController = new BoardController(boardModel);
var boardViewModel = new BoardViewModel(BoardCanvas, gameModel, boardModel);
var userMessageController = new UserMessageController(boardViewModel);
var rendererController = new RendererController(boardViewModel);
boardModel.NewPieceAdded += rendererController.DrawNewPiece;
boardModel.NewPieceAdded += gameController.IncreasePieceCount;
boardModel.PieceRemoved += rendererController.DeletePiece;
boardModel.PieceRemoved += gameController.DecreaseOpponentPieceCount;
boardModel.PieceMoved += rendererController.MovePiece;
boardModel.SelectionChanged += rendererController.ChangeSelection;
gameModel.TurnTaken += rendererController.UpdateRendererModel;
rendererController.NotifyUser += userMessageController.SetUserMessage;
boardViewModel.NotifyUser += userMessageController.SetUserMessage;
boardViewModel.SelectPiece += boardController.ChangeSelection;
boardViewModel.RemovePiece += boardController.RemovePiece;
boardViewModel.TakeTurn += gameController.TakeTurn;
boardViewModel.AddPiece += boardController.AddNewPiece;
boardViewModel.MoveSelectedPiece += boardController.MoveSelectedPiece;
DataContext = boardViewModel;
gameController.StartGame();
}
public async void OnSubmit(IEditable model)
{
if (model != null)
{
EditBoard editBoard = model as EditBoard;
if (editBoard != null)
{
if (ActiveUser.IsActive == true)
{
bool succ = await BoardService.UpdateBoard(ActiveUser.Instance.LoggedUser.Token,
editBoard.BoardId, new UpdateBoardDTO(editBoard));
if (succ == true)
{
Name = editBoard.Name;
DestroyPanel();
}
else
{
ShowMessageBox(null, "Error renaming board.");
}
}
else
{
ShowMessageBox(null, "Error getting user.");
}
}
}
}
/// <summary>
/// 게시판
/// </summary>
/// <returns></returns>
public IActionResult Index()
{
var boardService = new BoardService();
var boardList = boardService.List();
return(View(boardList));
}
private BoardService CreateBoardService()
{
var userId = Guid.Parse(User.Identity.GetUserId());
var service = new BoardService(userId);
return(service);
}
public async void LoadBoard()
{
if (ActiveUser.IsActive == true && ShortBoard != null)
{
ReadBoardDTO dto = await BoardService.GetBoard(ActiveUser.Instance.LoggedUser.Token, ShortBoard.BoardId);
if (dto != null)
{
Board = new ReadBoard(dto);
if (Board.IsAdmin == true)
{
DeleteBoardCommandVisible = true;
}
UsersViewModel = new UsersListViewModel(Board.Users, Board.IsAdmin, Board.BoardId);
CardListViewModel = new CardListListViewModel(Board.CardLists, Board.BoardId, this);
//Subscribe to board
MQService.Instance.SubscribeToExchange(ShortBoard.ExchangeName);
}
else
{
ShowMessageBox(null, "Error getting board.");
}
}
else
{
ShowMessageBox(null, "Error getting user.");
}
}
private void FillTree(ChipNode chipNode, int level)
{
if (level >= Deep)
{
return;
}
BoardService boardService = new BoardService();
boardService.InitBoard(new Board(chipNode.Board));
boardService.FlipChips(new Chip(chipNode.Chip), chipNode.Chip.OwnerId);
List <Chip> availableChips = boardService.GetAvailableSteps(Players.
Where(player => player.Id != chipNode.Chip.OwnerId).
Select(player => player.Id).FirstOrDefault());
if (availableChips.Count == 0)
{
return;
}
foreach (Chip chip in availableChips)
{
ChipNode nextChipNode = new ChipNode(new Board(boardService.Board),
new Chip(chip), level);
chipNode.NextChips.Add(nextChipNode);
FillTree(nextChipNode, level + 1);
nextChipNode.SetCoefficient();
}
}
public void Should_GetUsedNumbersBySquare()
{
List <List <int> > board = new List <List <int> >
{
new List <int>()
{
8, 0, 7
},
new List <int>()
{
0, 6, 5
},
new List <int>()
{
3, 4, 0
},
};
IEnumerable <int> retVal = BoardService.GetUsedNumbersBySquare(board, 2, 2);
Assert.AreEqual(true, !retVal.Except(new List <int>()
{
2, 9, 1
}).Any());
}
public ActionResult RemoveBoard(string boardName)
{
BoardService bs = new BoardService();
bs.DeleteBoard(boardName);
return(Redirect("~/ForumAdmin"));
}
//TODO: Unify use of "highlight" vs "background"
private void MoveToPlayingField()
{
var currentVerticalPosition = Mathf.Clamp(CachedTransform.position.y,
BoardContext.BottomLeftBounds.y,
BoardContext.TopRightBounds.y);
CachedTransform.SetParent(pieceAnchor, true);
CachedTransform.localScale = new Vector3(BoardContext.DefaultPieceScaleFactor, BoardContext.DefaultPieceScaleFactor, 0f);
var rt = GetComponent <RectTransform>();
rt.offsetMax = Vector2.zero;
rt.offsetMin = Vector2.zero;
TryMoveBackgroundToBackgroundDisplay();
HideHighlight();
MoveTo(new Vector3(BoardContext.TopRightBounds.x, currentVerticalPosition, 0f));
anchorInPool.gameObject.SetActive(false);
_isOnPlayingField = true;
connectedPieces.Add(this);
BoardService.MarkPieceOnPlayField(this);
MoveToFront();
}
public void OnDrag(PointerEventData eventData)
{
if (Input.touchCount > 1)
{
return;
}
var delta = new Vector3(eventData.delta.x, eventData.delta.y, 0f);
if (_isOnPlayingField)
{
foreach (var piece in connectedPieces)
{
piece.MoveBy(delta);
}
BoardService.ShowPiecesInSnappingDistanceTo(connectedPieces, BoardPosition);
}
else
{
if (delta.x < -PIECE_MOVE_TO_BOARD_HORIZONTAL_THRESHOLD_WORLD_UNITS)
{
MoveToPlayingField();
PuzzlePiecePool.Instance.scrollRect.OnEndDrag(eventData);
}
else
{
PuzzlePiecePool.Instance.scrollRect.OnDrag(eventData);
}
}
}
public ActionResult Index()
{
bool state = false;
string message = string.Empty;
int boardid = Convert.ToInt32(Request["boardid"]);
int pagecount;
//获取版块的信息
ViewBoardIndex boardIndex = new ViewBoardIndex();
//获取版块信息
boardIndex.Board = BoardService.GetBoard(boardid);
boardIndex.ViewPosts = PostService.GetViewPost(1, boardid, out pagecount);
boardIndex.PageCount = pagecount;
sessionModel = UserState.GetCurrentUser(SessionId.GetSessionId());
if (sessionModel != null && sessionModel.User != null)
{
ViewBag.User = UserService.GetViewUser(sessionModel.User);
ViewBag.logined = true;
}
else
{
ViewBag.logined = false;
}
return(View(boardIndex));
}
public void CreateMines_StringCommandInput_ReturnsMineCount(string boardInput, string stringMineInput, int[] mineInput1, int[] mineInput2, int[] mineInput3, int expectedResult)
{
var mineServiceStub = new Mock <IMineService>();
mineServiceStub.Setup(x => x.CreateMine(mineInput1))
.Returns(new Mine {
Position = new Coordinate {
X = mineInput1[0], Y = mineInput1[1]
}
});
mineServiceStub.Setup(x => x.CreateMine(mineInput2))
.Returns(new Mine {
Position = new Coordinate {
X = mineInput2[0], Y = mineInput2[1]
}
});
mineServiceStub.Setup(x => x.CreateMine(mineInput3))
.Returns(new Mine {
Position = new Coordinate {
X = mineInput3[0], Y = mineInput3[1]
}
});
var coordinateServiceStub = new Mock <ICoordinateService>();
var boardService = new BoardService(mineServiceStub.Object, coordinateServiceStub.Object);
boardService.Create(boardInput);
boardService.CreateMines(stringMineInput);
var result = boardService.GetBoard().Mines.Count;
Assert.Equal(expectedResult, result);
}
public void TestAddingShips()
{
BoardService boardService = new BoardService();
TileService tileService = new TileService();
Ship destroyer = new Ship(ShipType.DESTROYER);
Board board = new Board();
boardService.PerformInitialBoardSetup(board);
destroyer.IsHorizontal = true;
destroyer.RootTile = new Tile
{
Row = 2,
Column = 2
};
tileService.PlaceShip(board, destroyer);
Assert.IsTrue(board.TileAt(2, 2).ContainsShip);
Assert.IsTrue(board.TileAt(2, 3).ContainsShip);
Assert.IsFalse(board.TileAt(2, 4).ContainsShip);
Assert.IsFalse(board.TileAt(2, 1).ContainsShip);
Assert.IsFalse(board.TileAt(1, 2).ContainsShip);
Assert.IsFalse(board.TileAt(3, 2).ContainsShip);
}
public object GetBoard(int id)
{
var map = mapper.CreateMapper();
if (id != 0)
{
BoardDTO board = BoardService.Get(id);
BoardViewModel myboard = map.Map <BoardViewModel>(board);
return(JsonConvert.SerializeObject(myboard, Formatting.None, new JsonSerializerSettings()
{
ReferenceLoopHandling = ReferenceLoopHandling.Ignore
}));
}
else
{
IEnumerable <BoardDTO> board = BoardService.GetAll(User.Identity.GetUserId());
IEnumerable <BoardViewModel> myboard = map.Map <IEnumerable <BoardViewModel> >(board);
return(JsonConvert.SerializeObject(myboard.FirstOrDefault(), Formatting.None, new JsonSerializerSettings()
{
ReferenceLoopHandling = ReferenceLoopHandling.Ignore
}));
}
}
public void CreateBoardExpectBoardInStore()
{
var boardService = new BoardService(new BoardPositionConverter(), new MockPositionValidator());
boardService.CreateNewBoard("test", 5, 5);
Assert.NotNull(boardService.GetBoard("test"));
}
public void OnDeleteBoardClick()
{
if (ActiveUser.IsActive == true && ShortBoard != null)
{
Action <MessageBoxResult> yesno = async(MessageBoxResult res) =>
{
if (res == MessageBoxResult.Yes)
{
bool result = await BoardService.DeleteBoard(ActiveUser.Instance.LoggedUser.Token, Board.BoardId);
if (result)
{
BoardDeleted?.Invoke(ShortBoard.BoardId);
}
else
{
ShowMessageBox(null, "Error deleting board.");
}
}
};
ShowMessageBox(yesno, "Are you sure you want to delete this board?", "Warning", MessageBoxButton.YesNo);
}
else
{
ShowMessageBox(null, "Error getting user.");
}
}
public void SetUp()
{
_boardService = new BoardService(_shipCollectionService.Object);
_shipCollectionService.Setup(mock => mock.GetShipModelByLocationId(It.IsAny <string>()))
.Returns((string locationId) => ShipModelTestData.LocationIds.Any(l => l == locationId) ? ShipModelTestData : null);
_boardService.GenerateInitialBoard(new int[] { 5 }, 10);
}
private async void btnSend_Clicked(object sender, System.EventArgs e)
{
if (txtMessage.Text.Trim() == "")
{
await App.Current.MainPage.DisplayAlert("Nada foi enviado", "Mensagem não pode estar em branco", "OK");
return;
}
var user = UserService.GetUser();
var msg = new Models.BoardMessage()
{
Content = txtMessage.Text,
DateTimeSent = DateTime.Now,
Sender = user.Name,
UserId = user.UserId
};
await BoardService.NewMessage(msg);
txtMessage.Text = "";
using (UserDialogs.Instance.Loading("Carregando..."))
{
await vm.LoadMessages();
}
}
public BoardView(CoreUI ui, BoardService boards, ulong id, uint project)
{
InitializeComponent();
UI = ui;
Core = boards.Core;
Boards = boards;
Trust = Core.Trust;
UserID = id;
ProjectID = project;
if (UserID != Core.UserID)
{
PostButton.Visible = false;
RightSplitter.Visible = false;
ArchiveButton.Visible = false;
}
GuiUtils.SetupToolstrip(toolStrip1, new OpusColorTable());
PostHeader.DocumentText = HeaderPage.ToString();
PostView.SmallImageList = new List <Image>();
PostView.SmallImageList.Add(BoardRes.post);
PostView.SmallImageList.Add(BoardRes.higher);
PostView.SmallImageList.Add(BoardRes.lower);
PostView.OverlayImages.Add(BoardRes.high_scope);
PostView.OverlayImages.Add(BoardRes.low_scope);
PostBody.Core = Core;
}
public PlayerService InitPlayers(PlayerColour currentPlayerColor, BoardService boardService,
out int currentPlayerId, out int opponentPlayerId)
{
PlayerService playerService = new PlayerService(boardService);
PlayerColour opponentPlayerColor = colorParser.StringsToPlayerColours
.Where(obj => obj.Value != currentPlayerColor)
.Select(obj => obj.Value).FirstOrDefault();
List <PlayerCreateDTO> playerCreates = new List <PlayerCreateDTO>()
{
new PlayerCreateDTO()
{
Name = "Current Player",
PlayerColour = currentPlayerColor,
PlayerType = PlayerType.PC
},
new PlayerCreateDTO()
{
Name = "Opponent Player",
PlayerColour = opponentPlayerColor,
PlayerType = PlayerType.Human
}
};
playerService.InitPlayers(playerCreates);
currentPlayerId = playerService.Players
.Where(player => player.PlayerType == PlayerType.PC)
.Select(player => player.Id).FirstOrDefault();
opponentPlayerId = playerService.Players
.Where(player => player.PlayerType == PlayerType.Human)
.Select(player => player.Id).FirstOrDefault();
return(playerService);
}
private async void LoadBoardsByUser()
{
if (ActiveUser.IsActive == true)
{
List <ShortBoardDTO> listaDTO = await BoardService.GetBoardsByUser(ActiveUser.Instance.LoggedUser.Token);
if (listaDTO != null)
{
List <ShortBoard> lista = new List <ShortBoard>();
foreach (ShortBoardDTO dto in listaDTO)
{
//Consider refactoring - observable mehanizam se zove svaki put kad dodam novi bord
Boards.Add(new ShortBoard(dto));
}
}
else
{
ShowMessageBox(null, "Error getting boards.");
}
}
else
{
ShowMessageBox(null, "Error getting active user.");
}
}
private static GameService GetGameService()
{
var playerService = new PlayerService();
var boardService = new BoardService(playerService);
return(new GameService(boardService, playerService));
}
public ActionResult GetBoard(int id)
{
var map = mapper.CreateMapper();
BoardDTO board = BoardService.GetByUserId(id, User.Identity.GetUserId());
BoardViewModel myboard = map.Map <BoardViewModel>(board);
return(PartialView("GetBoard", map.Map <BoardViewModel>(myboard)));
}
public int Update(BoardViewModel data)
{
var map = mapper.CreateMapper();
BoardDTO board = map.Map <BoardDTO>(data);
int i = BoardService.Update(board);
return(i);
}
public int Delete(int boardId)
{
var map = mapper.CreateMapper();
BoardDTO board = BoardService.Get(boardId);
int i = BoardService.Delete(board);
return(i);
}
public void TestGetRobotWithNoRobotThrowsException()
{
var boardService = new BoardService(new BoardPositionConverter(), new MockPositionValidator());
var robotService = new RobotService(boardService, new PositionValidator());
boardService.CreateNewBoard("test", 5, 5);
Assert.Throws <RobotPlacedException>(() => robotService.GetRobot("test"));
}
public void TestRobotExistsCheckExpectFalse()
{
var boardService = new BoardService(new BoardPositionConverter(), new MockPositionValidator());
var robotService = new RobotService(boardService, new PositionValidator());
boardService.CreateNewBoard("test", 5, 5);
Assert.False(robotService.RobotExists("test"));
}
public void GetSatusSessionTest()
{
var session = FakeContext.FakeHttpContext(
new Dictionary<string, object> {
{ "boardStatus", 3 },
{ "boardMoves", new List<int> { 0, 1, 0, 0, 2, 0, 0, 2, 0} }
}, "http://localhost:65516/api/").Session;
BoardService servise = new BoardService(session);
Assert.AreEqual(3, servise.GetSatusSession());
}
public void CheckCurrentStatusTest_XWin()
{
var session = FakeContext.FakeHttpContext(
new Dictionary<string, object> {
{ "boardStatus", 0 },
{ "boardMoves", new List<int> { 0, 1, 0, 0, 1, 0, 0, 1, 0} }
}, "http://localhost:65516/api/").Session;
BoardService servise = new BoardService(session);
Assert.AreEqual((int)Statuses.XWin, servise.CheckCurrentStatus());
}
public void ClearBoardTest()
{
var session = FakeContext.FakeHttpContext(
new Dictionary<string, object> {
{ "boardStatus", 3 },
{ "boardMoves", new List<int> { 0, 1, 0, 0, 2, 0, 0, 2, 0} }
}, "http://localhost:65516/api/").Session;
BoardService servise = new BoardService(session);
servise.ClearBoard();
Assert.IsNull(session["boardMoves"]);
Assert.IsNull(session["boardStatus"]);
}
public void MakeAIMoveTest()
{
var session = FakeContext.FakeHttpContext(
new Dictionary<string, object> {
{ "boardStatus", 0 },
{ "boardMoves", new List<int> { 1, 0, 0, 0, 0, 0, 0, 0, 0} }
}, "http://localhost:65516/api/").Session;
BoardService servise = new BoardService(session);
servise.MakeAIMove(Marks.O);
Assert.AreEqual(1, servise.BoardValues.Where(x => x == (int)Marks.O).Count());
}
public void SaveSessionValuesTest()
{
var session = FakeContext.FakeHttpContext(
new Dictionary<string, object> {
{ "boardStatus", 3 },
{ "boardMoves", new List<int> { 0, 1, 0, 0, 2, 0, 0, 2, 0} }
}, "http://localhost:65516/api/").Session;
BoardService servise = new BoardService(session);
servise.BoardValues = Enumerable.Repeat(0, 9);
servise.SaveSessionValues();
Assert.AreEqual(0, ((IEnumerable<int>)session["boardMoves"]).ElementAt(1));
}
public void MakeMoveTest()
{
var session = FakeContext.FakeHttpContext(
new Dictionary<string, object> {
{ "boardStatus", 0 },
{ "boardMoves", new List<int> { 0, 0, 0, 0, 0, 0, 0, 0, 0} }
}, "http://localhost:65516/api/").Session;
BoardService servise = new BoardService(session);
var cellNumber = 2;
servise.MakeMove(cellNumber, Marks.X);
Assert.AreEqual(1, servise.BoardValues.Where(x=>x==1).Count());
Assert.AreEqual((int)Marks.X, servise.BoardValues.ElementAt(cellNumber));
}
