public async Task PlaySimultaneousGamesCallbackCalled()
{
var board = new BoardContent(SquareContent.Water);
board["A1"] = board["C1"] = board["E1"] = SquareContent.Ship;
var shootingBoard = new BoardContent(SquareContent.Unknown);
var game = new SinglePlayerGame(Guid.Empty, 0, board, shootingBoard);
var games = new[] { game };
var playerClientMock = new Mock <IPlayerClient>();
playerClientMock.Setup(m => m.GetShots(It.IsAny <string>(),
It.IsAny <IEnumerable <ISinglePlayerGame> >(), It.IsAny <string?>()))
.ReturnsAsync(new[] { new BoardIndex() });
var callbackCalls = 0;
var client = new GameClient(playerClientMock.Object, Mock.Of <ISinglePlayerGameFactory>());
Task Callback()
{
callbackCalls++;
return(Task.CompletedTask);
}
await client.PlaySimultaneousGames("https://someserver.com/api/", games, 2, Callback, "key", new[] { 1, 1, 1 });
Assert.Equal(2, callbackCalls);
}
public void SerializeDeserialize()
{
var board = new BoardContent(SquareContent.Water);
var shootingBoard = new BoardContent(SquareContent.Unknown);
var spg = new SinglePlayerGame(Guid.Empty, 42, board, shootingBoard)
{
log = new List <SinglePlayerGameLogRecord>()
{
new("A1", SquareContent.HitShip), new("B1", SquareContent.HitShip)
}
};
var serializeOptions = new JsonSerializerOptions();
serializeOptions.Converters.Add(new BoardContentJsonConverter());
serializeOptions.Converters.Add(new SinglePlayerGameJsonConverter());
var jsonString = JsonSerializer.Serialize(spg, serializeOptions);
var spgResult = JsonSerializer.Deserialize <SinglePlayerGame>(jsonString);
Assert.NotNull(spgResult);
Assert.Equal(spg.GameId, spgResult !.GameId);
Assert.Equal(spg.PlayerIndex, spgResult.PlayerIndex);
Assert.Equal(spg.NumberOfShots, spgResult.NumberOfShots);
Assert.Equal(spg.Board.ToShortString(), spgResult.Board.ToShortString());
Assert.Equal(spg.ShootingBoard.ToShortString(), spgResult.ShootingBoard.ToShortString());
Assert.Equal(spg.Log, spgResult.Log);
}
/// <summary>
///
/// </summary>
/// <param name="bpData"></param>
/// <param name="uiData"></param>
/// <param name="uiData_Forwarding"></param>
/// <param name="bcData"></param>
public void Reset(BoardPost bpData
, UserInfo uiData
, UserInfo uiData_Forwarding
, BoardContent bcData)
{
this.idBoardPost = bpData.idBoardPost;
this.idBoard = bpData.idBoard;
this.idBoardCategory = bpData.idBoardCategory;
this.Title = bpData.Title;
this.idUser = bpData.idUser;
this.idUser_Forwarding = bpData.idUser_Forwarding;
this.ViewCount = bpData.ViewCount;
this.ViewCountNone = bpData.ViewCountNone;
this.WriteDate = bpData.WriteDate;
this.EditDate = bpData.EditDate;
this.UserName = uiData.ViewName;
if (null != uiData_Forwarding)
{
this.UserName_Forwarding = uiData_Forwarding.ViewName;
}
this.Content = bcData.Content;
}
public void HasLost()
{
var board = new BoardContent();
board[0] = SquareContent.HitShip;
Assert.True(board.HasLost(1));
}
public void ThrowIfTooManyShots()
{
var board = new BoardContent(SquareContent.Water);
var player = new Sequential();
Assert.ThrowsAsync <InvalidOperationException>(() => player.GetShot(Guid.Empty, string.Empty, board, _ => Task.FromResult(SquareContent.Water)));
}
/// <summary>
///
/// </summary>
/// <param name="bpData"></param>
/// <param name="uiData"></param>
/// <param name="bcData"></param>
public BoardPostViewResultModel(BoardPost bpData
, UserInfo uiData
, BoardContent bcData)
{
this.ReplyList = false;
this.ReplyWrite = false;
this.Reset(bpData, uiData, bcData);
}
private static BoardContent CreateBoard()
{
var board = new BoardContent(SquareContent.Unknown);
board["A1"] = SquareContent.Water;
board["B1"] = SquareContent.Ship;
board["C1"] = SquareContent.HitShip;
return(board);
}
public void GetWinner_Player2()
{
var shooterBoard2 = new BoardContent(SquareContent.Unknown);
var game = CreateGame() with {
ShootingBoards = new[] { new BoardContent(SquareContent.Unknown), shooterBoard2 }
};
shooterBoard2[new BoardIndex(0, 0)] = SquareContent.HitShip;
Assert.Equal(Winner.Player1, game.GetWinner(1));
}
private BoardContent GetBoard(string board)
{
var result = new BoardContent();
for (var i = 0; i < 100; i++)
{
result[new BoardIndex(i)] = BoardContentJsonConverter.CharToSquareContent(board[i]);
}
return(result);
}
public void ToShortString()
{
var board = new BoardContent(SquareContent.Water);
board[0] = SquareContent.Ship;
board[1] = SquareContent.Unknown;
board[2] = SquareContent.SunkenShip;
board[3] = SquareContent.HitShip;
var result = board.ToShortString();
Assert.Equal("S XH", result[0..4]);
public ActionResult <ApiResultBaseModel> TestPostAdd(
[FromForm] int nBoardId)
{
ApiResultReady rrResult = new ApiResultReady(this);
DateTime dtNow = DateTime.Now;
int nCount = 0;
//유저 정보 추출
ClaimModel cm = new ClaimModel(((ClaimsIdentity)User.Identity).Claims);
//이 유저가 해당 관리 등급이 있는지 확인한다.
ManagementClassCheckType typePC
= GlobalStatic.MgtA.MgtClassCheck(cm.id_int
, ManagementClassType.Admin);
if (typePC == ManagementClassCheckType.Ok)
{
using (SpaNetCoreFoundationContext db1 = new SpaNetCoreFoundationContext())
{
for (int i = 0; i < 300; ++i)
{
++nCount;
//포스트
BoardPost newBP = new BoardPost();
newBP.idBoard = nBoardId;
newBP.idUser = cm.id_int;
newBP.Title = string.Format("테스트용 데이터 {0} - {1} ", nCount, dtNow);
newBP.WriteDate = dtNow;
db1.BoardPost.Add(newBP);
db1.SaveChanges();
//컨탠츠
BoardContent newBC = new BoardContent();
newBC.idBoard = newBP.idBoard;
newBC.idBoardPost = newBP.idBoardPost;
newBC.Content = string.Format("테스트용 내용 {0} - {1} ", nCount, dtNow);
db1.BoardContent.Add(newBC);
db1.SaveChanges();
}
}//end using db1
}
else
{
//에러
rrResult.InfoCode = ApiResultType.PermissionCheckError.ToString();
}
return(rrResult.ToResult());
}
public void Shoot_Into_Water()
{
var shooterBoard = new BoardContent(SquareContent.Unknown);
// Note with expression for record. See also
// https://devblogs.microsoft.com/dotnet/welcome-to-c-9-0/#with-expressions
var game = CreateGame() with {
ShootingBoards = new[] { shooterBoard, new BoardContent(SquareContent.Unknown) }
};
Assert.Equal(SquareContent.Water, game.Shoot(1, "A1"));
Assert.Equal(SquareContent.Water, shooterBoard[new BoardIndex(0, 0)]);
}
public void SequentialShots()
{
var board = new BoardContent(SquareContent.Unknown);
var player = new Sequential();
Assert.Equal("A1", Shoot(board, player));
Assert.Equal("B1", Shoot(board, player));
for (var i = 0; i < 8; i++)
{
Shoot(board, player);
}
Assert.Equal("A2", Shoot(board, player));
}
private string Shoot(BoardContent board, PlayerBase player)
{
BoardIndex?location = null;
Task <SquareContent> shoot(string l)
{
location = l;
board[l] = SquareContent.Water;
return(Task.FromResult(SquareContent.Water));
}
player.GetShot(Guid.Empty, string.Empty, board, shoot);
Assert.NotNull(location);
return(location !);
}
public void Shoot_Ship()
{
var board = new BoardContent(SquareContent.Water);
board[new BoardIndex(0, 0)] = SquareContent.Ship;
var shooterBoard = new BoardContent(SquareContent.Unknown);
var game = CreateGame() with
{
Boards = new[] { board, new BoardContent(SquareContent.Water) },
ShootingBoards = new[] { new BoardContent(SquareContent.Unknown), shooterBoard }
};
Assert.Equal(SquareContent.HitShip, game.Shoot(2, "A1"));
Assert.Equal(SquareContent.HitShip, shooterBoard[new BoardIndex(0, 0)]);
}
public void Content_To_String()
{
var bc = new BoardContent();
bc.Clear(SquareContent.Unknown);
bc[new BoardIndex(0, 0)] = SquareContent.Ship;
bc[new BoardIndex(1, 0)] = SquareContent.HitShip;
bc[new BoardIndex(2, 0)] = SquareContent.Water;
var output = bc.ToString();
Assert.Equal((1 + 10 + 9 + 1) * (1 + 10 * 3 + 1), output.Length);
Assert.Equal(2, output.Count(c => c == '█'));
Assert.Equal(2, output.Count(c => c == 'X'));
Assert.Equal(2, output.Count(c => c == '~'));
Assert.Equal(97 * 2, output.Count(c => c == ' '));
}
public void DoubleshotTests()
{
var board = new BoardContent(SquareContent.Water);
board[0] = board[1] = SquareContent.Ship;
var shooterBoard = new BoardContent(SquareContent.Unknown);
var game = CreateGame() with
{
Boards = new[] { board, new BoardContent(SquareContent.Water) },
ShootingBoards = new[] { new BoardContent(SquareContent.Unknown), shooterBoard }
};
Assert.Equal(SquareContent.HitShip, game.Shoot(2, "A1"));
Assert.Equal(SquareContent.SunkenShip, game.Shoot(2, "B1"));
Assert.Equal(SquareContent.SunkenShip, game.Shoot(2, "A1"));
Assert.Equal(SquareContent.SunkenShip, game.Shoot(2, "B1"));
Assert.Equal(SquareContent.SunkenShip, shooterBoard[new BoardIndex(0)]);
Assert.Equal(SquareContent.SunkenShip, shooterBoard[new BoardIndex(1)]);
}
public Board Convert(BoardModel boardModel)
{
var stickers = new List <Sticker>();
boardModel.Content ??= new BoardContentModel();
boardModel.Content.Stickers ??= new List <StickerModel>();
foreach (var stickerModel in boardModel.Content.Stickers)
{
var stickerContent = new StickerContent(stickerModel.Content.Text, stickerModel.Content.TimeTable);
var sticker = new Sticker(stickerContent);
stickers.Add(sticker);
}
var boardContent = new BoardContent(stickers);
IAccessParameters accessParameters;
switch (boardModel.AccessType)
{
case "Public":
accessParameters = new PublicAccessParameters();
break;
case "Private":
var accessed = new List <Guid>();
foreach (var login in boardModel.GetLoginsOfAccessedUsers())
{
if (userService.TryGetUser(login, out var user))
{
accessed.Add(user.Id);
}
}
accessParameters = new PrivateAccessParameters(accessed);
break;
default:
throw new NotImplementedException();
}
return(new Board(boardContent, accessParameters));
}
public async Task PlaySimultaneousGamesMaximumShots()
{
var board = new BoardContent(SquareContent.Water);
board["A1"] = board["C1"] = board["E1"] = SquareContent.Ship;
var shootingBoard = new BoardContent(SquareContent.Unknown);
var game = new SinglePlayerGame(Guid.Empty, 0, board, shootingBoard);
var games = new[] { game };
var playerClientMock = new Mock <IPlayerClient>();
playerClientMock.Setup(m => m.GetShots("https://someserver.com/api/",
It.Is <IEnumerable <ISinglePlayerGame> >(g => g.Count() == 1), "key"))
.ReturnsAsync(new[] { new BoardIndex() });
var client = new GameClient(playerClientMock.Object, Mock.Of <ISinglePlayerGameFactory>());
await client.PlaySimultaneousGames("https://someserver.com/api/", games, 2, null, "key", new[] { 1, 1, 1 });
playerClientMock.Verify(m => m.GetShots("https://someserver.com/api/",
It.Is <IEnumerable <ISinglePlayerGame> >(g => g.Count() == 1), "key"), Times.Exactly(2));
}
public ActionResult <BoardIndex[]> GetShots([FromBody] ShotRequest[] shotRequests)
{
// Create a helper variable that will receive our calculated
// shots for each shot request.
var shots = new BoardIndex[shotRequests.Length];
Parallel.For(0, shotRequests.Length, index =>
{
var board = new BoardContent(shotRequests[index].Board.Select(d => (byte)BoardContentJsonConverter.CharToSquareContent(d)));
#if DEBUG
Console.WriteLine(board);
Console.WriteLine(board.ToShortString());
#endif
shots[index] = BattleshipHelper.GetNextShot(board);
#if DEBUG
Console.WriteLine($"Next shot:{(string)shots[index]}");
////Thread.Sleep(500);
#endif
});
return(shots);
}
/// <summary>
///
/// </summary>
/// <param name="bpData"></param>
/// <param name="uiData"></param>
/// <param name="bcData"></param>
public void Reset(BoardPost bpData
, UserInfo uiData
, BoardContent bcData)
{
this.idBoardPost = bpData.idBoardPost;
this.idBoard = bpData.idBoard;
this.idBoardCategory = bpData.idBoardCategory;
this.Title = bpData.Title;
this.idUser = bpData.idUser;
this.ViewCount = bpData.ViewCount;
this.PostState = bpData.PostState;
this.WriteDate = bpData.WriteDate;
this.EditDate = bpData.EditDate;
this.UserName = uiData.ViewName;
this.Content = bcData.Content;
this.FileInfoList = new List <FileInfoModel>();
}
public void Parameterless_Constructor()
{
var bc = new BoardContent();
Assert.Empty(bc.Where(c => c != SquareContent.Water));
}
public void From_Byte_Array()
{
var bc = new BoardContent(Enumerable.Range(0, 100).Select(n => (byte)(n % 4)));
Assert.Equal(25, bc.Count(c => c == SquareContent.Ship));
}
public void Initializing_Constructor()
{
var bc = new BoardContent(SquareContent.Unknown);
Assert.Empty(bc.Where(c => c != SquareContent.Unknown));
}
/// <summary>
///
/// </summary>
/// <param name="bpData"></param>
/// <param name="uiData"></param>
/// <param name="bcData"></param>
public BoardPostEditResultModel(BoardPost bpData
, UserInfo uiData
, BoardContent bcData)
{
this.Reset(bpData, uiData, bcData);
}
