public void GameRepository_Create()
{
var context = new Mock <IGameContext>();
var gameSet = new Mock <IDbSet <Game> >();
var tokenSet = new Mock <IDbSet <Token> >();
var players = new[] {
new Model.Player("1", "player1", false),
new Model.Player("2", "player2", true),
};
gameSet.ConfigureDbSet(new List <Game>());
tokenSet.ConfigureDbSet(new List <Token>());
context.SetupGet(x => x.Games).Returns(gameSet.Object);
context.SetupGet(x => x.Tokens).Returns(tokenSet.Object);
gameSet.Setup(x => x.Add(It.IsAny <Game>()))
.Callback <Game>(g => g.ID = 1);
var repo = new GameRepository(context.Object);
var game = new Model.Game(
0,
players[0],
players[1],
Model.GameStatus.CreateActive(players[0], players[1]),
new Model.GameBoard(new Model.GameProperties(), Enumerable.Empty <Model.Token>()));
var result = repo.CreateAsync(game).Result;
gameSet.Verify(x => x.Add(It.IsAny <Game>()));
context.Verify(x => x.SaveChangesAsync());
Assert.AreNotEqual(result, game, "Result should be a new Game");
Assert.AreEqual(1, result.ID, "ID should be set");
}
public void GameRepository_Create()
{
var context = new Mock<IGameContext>();
var gameSet = new Mock<IDbSet<Game>>();
var tokenSet = new Mock<IDbSet<Token>>();
var players = new[] {
new Model.Player("1", "player1", false),
new Model.Player("2", "player2", true),
};
gameSet.ConfigureDbSet(new List<Game>());
tokenSet.ConfigureDbSet(new List<Token>());
context.SetupGet(x => x.Games).Returns(gameSet.Object);
context.SetupGet(x => x.Tokens).Returns(tokenSet.Object);
gameSet.Setup(x => x.Add(It.IsAny<Game>()))
.Callback<Game>(g => g.ID = 1);
var repo = new GameRepository(context.Object);
var game = new Model.Game(
0,
players[0],
players[1],
Model.GameStatus.CreateActive(players[0], players[1]),
new Model.GameBoard(new Model.GameProperties(), Enumerable.Empty<Model.Token>()));
var result = repo.CreateAsync(game).Result;
gameSet.Verify(x => x.Add(It.IsAny<Game>()));
context.Verify(x => x.SaveChangesAsync());
Assert.AreNotEqual(result, game, "Result should be a new Game");
Assert.AreEqual(1, result.ID, "ID should be set");
}
public static SpotifyGetTracksResponse GetTracks(Model.Game game, string[] trackIds)
{
var client = GetClient();
using (var user = StateManager.Db.GetUser(game.UserId))
{
client.Headers.Add("Authorization", "Bearer " + user.SpotifyAuthTokens.AccessToken);
}
if (trackIds == null || trackIds.Length == 0)
{
return(null);
}
var trackidsJoined = string.Join(",", trackIds
.Where(trackId => !string.IsNullOrWhiteSpace(trackId))
.Take(50) //API is limited to 50 tracks per request
);
if (string.IsNullOrWhiteSpace(trackidsJoined))
{
return(null);
}
var tracksUrl = string.Format(
Constants.SpotifyUrls.SpotifyTracksUrl,
trackidsJoined
);
var result = client.DownloadString(tracksUrl);
var deserialized = Newtonsoft.Json.JsonConvert.DeserializeObject <SpotifyGetTracksResponse>(result);
return(deserialized);
}
private static void UpdateSpotifyList(Model.Game game)
{
List <string> trackIds = new List <string>();
Dictionary <string, int> tracksCountPerPlayer = new Dictionary <string, int>();
int maxTracksPerPlayer = (int)Math.Floor(100.0 / game.Players.Count);
foreach (Nominee nominee in game.Nominees
.Where(nominee => nominee.UpVotes.Count + nominee.NominatingPlayerIds.Count > nominee.DownVotes.Count)
.OrderByDescending(
nominee => nominee.UpVotes.Count + nominee.NominatingPlayerIds.Count - nominee.DownVotes.Count))
{
string nominatingPlayer = nominee.NominatingPlayerIds.FirstOrDefault();
if (tracksCountPerPlayer.ContainsKey(nominatingPlayer))
{
if (tracksCountPerPlayer[nominatingPlayer] < maxTracksPerPlayer)
{
tracksCountPerPlayer[nominatingPlayer]++;
trackIds.Add(nominee.TrackId);
}
}
else
{
tracksCountPerPlayer[nominatingPlayer] = 1;
trackIds.Add(nominee.TrackId);
}
}
SpotifyServices.ReOrderPlaylist(game, trackIds.ToArray());
}
public GameFieldViewModel()
{
Game = new Model.Game();
_canExecuteSelect = true;
_canExecutePauseResume = true;
_canExecuteStop = true;
_canExecuteBackToMenu = true;
Game.OnOver += Game_OnOver;
CallClose = true;
}
public async Task <Model.Game> AddAsync(Model.Game game)
{
var id = _gameContext.Games.Select(x => x.Id).ToList().Max() + 1;
game.SetId(id);
_gameContext.Games.Add(game);
await _gameContext.SaveChangesAsync();
return(await GetAsync(game.Id));
}
public static Model.Game CreateGame(string title, string description, string platform)
{
Model.Game newGame = new Model.Game();
newGame.Id = Guid.NewGuid();
newGame.Title = title;
newGame.Description = description;
newGame.Platform = platform;
newGame.CoverImagePath = "";
return(newGame);
}
public void OnGet()
{
Games = _igame.GetCurrentGame();
UserGames = _igame.GetUserGames();
for (int board = 0; board < UserGames.Count(); board++)
{
IList <NavyBattlePiece> navyBattlePieces = _igame.GetNavyBattlePieces(UserGames[board].Id);
GameBoardModel newBoard = new GameBoardModel(navyBattlePieces, UserGames[board], _igame.GetActiveUserId());
GameBoardModels.Add(newBoard);
}
}
public static void UpdateGameTick(Model.Game game)
{
long newTick = 0;
if (game.GameStateUpdateTime.HasValue)
{
newTick = game.GameStateUpdateTime.Value.Ticks;
}
FakeGameTicks[game.GameId] = newTick;
}
public async Task <IActionResult> Put([FromBody] Model.Game amigo)
{
if (amigo == default(Model.Game))
{
return(BadRequest());
}
var item = await _gameRepository.UpdateAsync(amigo);
return(Accepted(item));
}
//绑定数据
private void ShowInfo()
{
Model.User userMod = new Model.User();
BLL.User userBll = new BLL.User();
Model.Game gMod = new Model.Game();
BLL.Game gBll = new BLL.Game();
//gMod = gBll.GetModel(Convert.ToInt32(modelExtend.gameID));
this.lbChanelName.Text = modelExtend.ChanelName;
this.lbgamename.Text = modelExtend.gameName;
}
public void SaveGame(Model.Game game)
{
var existingGame = Games.Find(storedGame => storedGame.GameId == game.GameId).FirstOrDefault();
if (existingGame == null)
{
Games.InsertOne(game);
}
else
{
Games.ReplaceOne(storedGame => storedGame.GameId == game.GameId, game);
}
}
public string UpdateGameState(Model.Game gameSession, int x, int y)
{
if (gameSession.State == Model.Game.GameState.Finished)
{
throw new ReversiException($"Game has finished, scores are: {gameSession.PlayerOne}={gameSession.PlayerOneScore} - {gameSession.PlayerTwo}={gameSession.PlayerTwoScore}");
}
gameSession.State = Model.Game.GameState.Ongoing;
var disc = gameSession.NextPlayer == gameSession.PlayerOne ? 'X' : 'O';
try
{
if (x == -1 && y == -1)
{
var moves = Reversi.GetMoves(gameSession.Board as char[, ], disc);
if (moves.Length != 0)
{
throw new ReversiException("Only allowed to skip when no moves are available");
}
// Two skips in a row = game finished
var lastMove = gameSession.Moves.Last();
if (lastMove.X == -1 && lastMove.Y == -1)
{
gameSession.State = Model.Game.GameState.Finished;
}
}
else
{
gameSession.Board = Reversi.Move(gameSession.Board as char[, ], x, y, disc);
}
gameSession.Turn++;
gameSession.Moves.Add(new Model.Game.Move {
Disc = disc, X = x, Y = y
});
var otherDisc = disc == 'X' ? 'O' : 'X';
if (GetPossibleMoves(gameSession.Board as char[, ], disc).Length == 0 && GetPossibleMoves(gameSession.Board as char[, ], otherDisc).Length == 0)
{
gameSession.State = Model.Game.GameState.Finished;
}
return(null);
}
catch (ReversiException e)
{
return($"You did somthing you shouldn't have done...{Environment.NewLine}{e.Message}");
}
}
public GameViewModel()
{
Gameliste = new Model.obsGamesList();
AddGameCommand = new AddGameCommand(AddNewGame);
NewGame = new Model.Game();
DeleteGameCommand = new DeleteGameCommand(DeleteGame);
SaveGameCommand = new SaveGameCommand(GemDataTilDiskAsnc);
HentDataCommand = new HentDataCommand(HentdataFraDiscAsync);
localfolder = ApplicationData.Current.LocalFolder;
//AddGameCommand = new RelayCommand(AddNewGame,null);
}
public void StartNewGame()
{
Model.Game CurrentGame = GameHandler.instance.GetCurrentGame();
if (CurrentGame == null || CurrentGame.TimeStarted != DateTime.MinValue)
{
GameHandler.instance.SetAllGamesToFinished();
TeamHandler.instance.SetAllTeamsCurrentPlayerIDToNull();
PlayerHandler.instance.SetAllPlayesToStartState();
Model.Game NewGame = new Model.Game();
GameHandler.instance.AddNewGame(NewGame);
}
}
public void StartNewGame()
{
Model.Game CurrentGame = GameHandler.instance.GetCurrentGame();
if (CurrentGame == null || CurrentGame.TimeStarted != DateTime.MinValue)
{
GameHandler.instance.SetAllGamesToFinished();
TeamHandler.instance.SetAllTeamsCurrentPlayerIDToNull();
PlayerHandler.instance.SetAllPlayesToStartState();
Model.Game NewGame = new Model.Game();
GameHandler.instance.AddNewGame(NewGame);
}
}
public State()
{
Model = new Model.Game(
ImmutableList <string> .Empty.Add("Welcome to Scape."),
new Model.Mob("@", 40, 12),
new Model.Mob[]
{
new Model.Mob("d", 1, 21),
new Model.Mob("d", 4, 6),
new Model.Mob("d", 11, 2),
},
LastKey: ""
);
}
public void Key(string keyCode)
{
var input = keyCode switch
{
"KeyW" or "Numpad8" or "ArrowUp" => new Input.Move(0, +1),
"KeyA" or "Numpad4" or "ArrowLeft" => new Input.Move(-1, 0),
"KeyS" or "Numpad2" or "ArrowDown" => new Input.Move(0, -1),
"KeyD" or "Numpad6" or "ArrowRight" => new Input.Move(+1, 0),
"Space" or "Numpad5" => new Input.Wait(),
_ => default(Input)
};
switch (input)
{
case Input.Wait:
Log("You wait.");
break;
case Input.Move m:
Exec(new Command.MoveTo(Model.Player, Model.Player.X + m.DX, Model.Player.Y + m.DY));
break;
}
Model = Model with {
LastKey = keyCode
};
}
void Exec(Command cmd)
{
switch (cmd)
{
// XXX assumes player
case Command.MoveTo m:
Model = Model with {
Player = Model.Player with {
X = Math.Clamp(m.X, 1, 78),
Y = Math.Clamp(m.Y, 1, 22)
}
};
break;
}
}
void Log(string line) => Model = Model with
{
Log = Model.Log.Add(line)
};
}
}
public async Task <Model.Game> UpdateAsync(Model.Game game)
{
var am = await _gameContext.Games.FirstOrDefaultAsync(x => x.Id == game.Id);
if (am == default(Model.Game))
{
return(default(Model.Game));
}
_gameContext.Entry(am).CurrentValues.SetValues(game);
await _gameContext.SaveChangesAsync();
return(await GetAsync(game.Id));
}
public void Update_InputIsValid_UpdateForRepositoryIsCalledAndRedirectWorks()
{
// Arrange
var mock = new Mock <IGameRepository>();
var controller = new GamesController(mock.Object);
var game = new Model.Game();
// Act
var result = controller.Update(game) as RedirectToRouteResult;
// Assert
Assert.IsNotNull(result);
mock.Verify(a => a.Update(game), Times.Once);
Assert.AreEqual("Index", result.RouteValues["action"]);
}
public static Model.Game FromDal(this GameRuntime.Game game)
{
if (game == null)
{
return(null);
}
var result = new Model.Game()
{
Guid = game.Guid,
Name = game.Name,
CanJoin = game.CanJoin,
CreateTime = game.CreateTime
};
return(result);
}
private void RandyMove(Model.Game session)
{
var possibleMoves = _gameLogic.GetPossibleMoves(session.Board as char[, ], 'O');
if (possibleMoves.Length == 0)
{
System.Diagnostics.Debug.WriteLine($"No moves, skipping turn.");
_gameLogic.UpdateGameState(session, -1, -1);
}
else
{
var r = new Random();
var oneMove = possibleMoves[r.Next(possibleMoves.Length)];
System.Diagnostics.Debug.WriteLine($"Making move {oneMove.x}, {oneMove.y}.");
_gameLogic.UpdateGameState(session, oneMove.x, oneMove.y);
}
}
public async Task <IGame> GetGameById(int gameId)
{
IGame game = new Model.Game();
try
{
var response = await _client.GetAsync(url + $"/games/{gameId}");
if (response.IsSuccessStatusCode)
{
var content = await response.Content.ReadAsStringAsync();
game = JsonConvert.DeserializeObject <Model.Game>(content);
}
}
catch (Exception e) { throw new Exception("Не удалось получить данные:.\n" + e.ToString()); }
return(game);
}
public static SpotifySearchResponse SearchForTracks(Model.Game game, string query)
{
var client = GetClient();
using (User user = StateManager.Db.GetUser(game.UserId))
{
client.Headers.Add("Authorization", "Bearer " + user.SpotifyAuthTokens.AccessToken);
}
var searchUrl = string.Format(
Constants.SpotifyUrls.SpotifySearchUrl,
HttpUtility.UrlEncode(query)
);
var result = client.DownloadString(searchUrl);
var deserialized = Newtonsoft.Json.JsonConvert.DeserializeObject <SpotifySearchResponse>(result);
return(deserialized);
}
public string AssignGameAgainstRandomBot(string playerKey)
{
var gameKey = Guid.NewGuid().ToString();
var g = new Model.Game {
Board = Reversi.GetInitialState(), PlayerOne = playerKey
};
var added = _database.TryAdd(gameKey, g);
if (!added)
{
throw new ApplicationException("Game already added");
}
var botName = $"randy_{Guid.NewGuid().ToString().Replace("-", "")}";
g.PlayerTwo = botName;
return(gameKey);
}
public async Task <Model.Game> CreateAsync(Model.Game game)
{
var timestamp = DateTime.UtcNow;
var model = new Game
{
Player1ID = game.Player1.ID,
Player1Name = game.Player1.Name,
Player2ID = game.Player2.ID,
Player2Name = game.Player2.Name,
SinglePlayerMode = game.Player2.IsComputerControlled,
CreatedAtUtc = timestamp,
UpdatedAtUtc = timestamp,
NumRows = game.GameBoard.NumRows,
NumCols = game.GameBoard.NumCols,
RowsPerPlayer = game.GameBoard.Properties.RowsPerPlayer,
BombsPerPlayer = game.GameBoard.Properties.BombsPerPlayer,
CurrentPlayerID = game.Player1.ID,
Active = true,
Tokens = (from token in game.GameBoard.GetTokens()
select new Token
{
ID = token.ID,
PlayerID = token.PlayerID,
Row = token.Row,
Col = token.Col,
TokenType = (int)token.TokenType,
CreatedAtUtc = timestamp,
UpdatedAtUtc = timestamp
}).ToList()
};
context.Games.Add(model);
await context.SaveChangesAsync();
var players = new[] { game.Player1, game.Player2 };
return(new Model.Game(model.ID, game.Player1, game.Player2, Model.GameStatus.CreateFromEntity(model, players), game.GameBoard));
}
//绑定数据
private void ShowInfo()
{
Model.User userMod = new Model.User();
BLL.User userBll = new BLL.User();
Model.Game gMod = new Model.Game();
BLL.Game gBll = new BLL.Game();
//gMod = gBll.GetModel(Convert.ToInt32(model.gameID));
this.lbChanel.Text = model.ChanelName;
this.lbGameName.Text = model.gameName;
this.ddlStatus.SelectedValue = model.Status;
this.ddlUpdateType.SelectedValue = model.UpdateType;
this.txtBak1.Text = model.Bak1;
this.txtVersion.Text = model.version;
if (model.Bak2 != "")
{
this.ddlMenu.SelectedValue = model.Bak2;
this.ddlChanel.SelectedValue = model.Bak3;
this.ddlGame.SelectedValue = model.Bak4;
}
this.txtScale.Text = model.Bak5;
}
public async Task<Model.Game> GetAsync(long id)
{
// Fetch data
var entity = await context.Games.AsNoTracking().SingleAsync(x => x.ID == id);
entity.Tokens = await context.Tokens.AsNoTracking().Where(x => x.GameID == id).ToListAsync();
var players = new[] {
new Model.Player(entity.Player1ID, entity.Player1Name, false),
new Model.Player(entity.Player2ID, entity.Player2Name, entity.SinglePlayerMode)
};
var bounds = new Model.Bounds(entity.NumRows, entity.NumCols);
var properties = new Model.GameProperties(bounds, entity.RowsPerPlayer, entity.BombsPerPlayer);
var status = Model.GameStatus.CreateFromEntity(entity, players);
var tokens = entity.Tokens.Select(x => new Model.Token(x.ID, x.PlayerID, (Model.TokenType)x.TokenType, x.Row, x.Col));
var gameBoard = new Model.GameBoard(properties, tokens);
var game = new Model.Game(entity.ID, players[0], players[1], status, gameBoard);
return game;
}
public static void AppendTrackToPlaylist(Model.Game game, string bestTrackId)
{
var client = GetClient();
string spotifyUserId = null;
using (User user = StateManager.Db.GetUser(game.UserId))
{
client.Headers.Add("Authorization", "Bearer " + user.SpotifyAuthTokens.AccessToken);
spotifyUserId = user.SpotifyUser.Id;
}
var addTrackToPlaylistUrl = string.Format(
Constants.SpotifyUrls.SpotifyAddToPlaylistUrl,
spotifyUserId,
game.SpotifyPlaylistId,
bestTrackId
);
var result = client.UploadData(new Uri(addTrackToPlaylistUrl), new byte[0]);
var stringifiedResult = client.Encoding.GetString(result);
}
public static void ReOrderPlaylist(Model.Game game, string[] trackIds)
{
var client = GetClient();
string spotifyUserId = null;
using (User user = StateManager.Db.GetUser(game.UserId))
{
client.Headers.Add("Authorization", "Bearer " + user.SpotifyAuthTokens.AccessToken);
spotifyUserId = user.SpotifyUser.Id;
}
var addTrackToPlaylistUrl = string.Format(
Constants.SpotifyUrls.SpotifyReorderPlaylistUrl,
spotifyUserId,
game.SpotifyPlaylistId,
string.Join(",", trackIds.Where(id => !string.IsNullOrWhiteSpace(id)).Select(id => "spotify:track:" + id))
);
var result = client.UploadData(new Uri(addTrackToPlaylistUrl), "PUT", new byte[0]);
var stringifiedResult = client.Encoding.GetString(result);
}
public async Task <Model.Game> GetAsync(long id)
{
// Fetch data
var entity = await context.Games.AsNoTracking().SingleAsync(x => x.ID == id);
entity.Tokens = await context.Tokens.AsNoTracking().Where(x => x.GameID == id).ToListAsync();
var players = new[] {
new Model.Player(entity.Player1ID, entity.Player1Name, false),
new Model.Player(entity.Player2ID, entity.Player2Name, entity.SinglePlayerMode)
};
var bounds = new Model.Bounds(entity.NumRows, entity.NumCols);
var properties = new Model.GameProperties(bounds, entity.RowsPerPlayer, entity.BombsPerPlayer);
var status = Model.GameStatus.CreateFromEntity(entity, players);
var tokens = entity.Tokens.Select(x => new Model.Token(x.ID, x.PlayerID, (Model.TokenType)x.TokenType, x.Row, x.Col));
var gameBoard = new Model.GameBoard(properties, tokens);
var game = new Model.Game(entity.ID, players[0], players[1], status, gameBoard);
return(game);
}
public string AssignGame(string playerKey)
{
var game = _database.FirstOrDefault(x => string.IsNullOrEmpty(x.Value.PlayerTwo));
if (game.Key is default(string))
{
var gameKey = Guid.NewGuid().ToString();
var g = new Model.Game {
Board = Reversi.GetInitialState(), PlayerOne = playerKey
};
var added = _database.TryAdd(gameKey, g);
if (!added)
{
throw new ApplicationException("Game already added");
}
return(gameKey);
}
game.Value.PlayerTwo = playerKey;
return(game.Key);
}
public static bool PlaceVote(string gameId, string playerId, string trackId, bool isUpVote)
{
lock (GameLogicLock)
{
Model.Game game = StateManager.Db.GetGame(gameId);
if (game == null)
{
return(false);
}
var trackToUpvote = game.Nominees.FirstOrDefault(nomineeItem => nomineeItem.TrackId == trackId);
if (trackToUpvote != null)
{
//ensure that vote is not for track nominated by player
if (trackToUpvote.NominatingPlayerIds.Contains(playerId))
{
return(false);
}
if (isUpVote && !trackToUpvote.UpVotes.Contains(playerId))
{
trackToUpvote.UpVotes.Add(playerId);
}
if (!isUpVote && !trackToUpvote.DownVotes.Contains(playerId))
{
trackToUpvote.DownVotes.Add(playerId);
}
game.GameStateUpdateTime = DateTime.UtcNow;
StateManager.Db.SaveGame(game);
UpdateSpotifyList(game);
}
return(false);
}
}
public void GameRepository_Save()
{
var context = new Mock <IGameContext>();
var gameSet = new Mock <IDbSet <Game> >();
var tokenSet = new Mock <IDbSet <Token> >();
var players = new[] {
new Model.Player("1", "player1", false),
new Model.Player("2", "player2", true),
};
var games = new List <Game>
{
new Repository.Entity.Game {
ID = 1
}
};
var tokens = new List <Token>
{
new Repository.Entity.Token {
GameID = 1, ID = 100
},
new Repository.Entity.Token {
GameID = 1, ID = 200
}
};
gameSet.ConfigureDbSet(games);
tokenSet.ConfigureDbSet(tokens);
context.SetupGet(x => x.Games).Returns(gameSet.Object);
context.SetupGet(x => x.Tokens).Returns(tokenSet.Object);
gameSet.Setup(x => x.Add(It.IsAny <Game>()))
.Callback <Game>(g => g.ID = 1);
var repo = new GameRepository(context.Object);
var game = new Model.Game(
1,
players[0],
players[1],
Model.GameStatus.CreateActive(players[0], players[1]),
new Model.GameBoard(new Model.GameProperties(new Model.Bounds(4, 4), 1, 1), new List <Model.Token>
{
new Model.Token(100, "player1", Model.TokenType.Bomb, 1, 2),
new Model.Token(101, "player1", Model.TokenType.Rock, 0, 3)
}));
repo.SaveAsync(game).Wait();
context.Verify(x => x.SaveChangesAsync());
tokenSet.Verify(x => x.Add(It.Is <Token>(t => t.ID == 101)));
tokenSet.Verify(x => x.Remove(It.Is <Token>(t => t.ID == 200)));
Assert.AreEqual("1", games[0].Player1ID, "player1 ID should be set");
Assert.AreEqual("player1", games[0].Player1Name, "player1 Name should be set");
Assert.AreEqual("2", games[0].Player2ID, "player2 ID should be set");
Assert.AreEqual("player2", games[0].Player2Name, "player2 Name should be set");
Assert.AreEqual(game.GameBoard.NumRows, games[0].NumRows, "NumRows should be set");
Assert.AreEqual(game.GameBoard.NumCols, games[0].NumCols, "NumCols should be set");
Assert.AreEqual(game.GameStatus.GameActive, games[0].Active, "GameOver should be set");
Assert.AreEqual(1, tokens[0].Row, "Row should be set");
Assert.AreEqual(2, tokens[0].Col, "Col should be set");
Assert.AreEqual("player1", tokens[0].PlayerID, "PlayerID should be set");
Assert.IsTrue(tokens[0].UpdatedAtUtc > DateTime.MinValue, "UpdatedAtUtc should be set");
}
/// <summary>
/// 得到一个对象实体
/// </summary>
public Model.Game GetModel(int ID)
{
StringBuilder strSql = new StringBuilder();
strSql.Append("select top 1 ID,Name,version,Platform,Status,UpdateType,UpdateDate,OnTime,FirstLetter,IsLock,Bak1,Bak2,Bak3 from Game ");
strSql.Append(" where ID=@ID");
SqlParameter[] parameters = {
new SqlParameter("@ID", SqlDbType.Int,4)
};
parameters[0].Value = ID;
Model.Game model = new Model.Game();
DataSet ds = DbHelper.Query(strSql.ToString(), parameters);
if (ds.Tables[0].Rows.Count > 0)
{
return DataRowToModel(ds.Tables[0].Rows[0]);
}
else
{
return null;
}
}
/// <summary>
/// 得到一个对象实体
/// </summary>
public Model.Game DataRowToModel(DataRow row)
{
Model.Game model = new Model.Game();
if (row != null)
{
if (row["ID"] != null && row["ID"].ToString() != "")
{
model.ID = int.Parse(row["ID"].ToString());
}
if (row["Name"] != null)
{
model.Name = row["Name"].ToString();
}
if (row["version"] != null)
{
model.version = row["version"].ToString();
}
if (row["Platform"] != null)
{
model.Platform = row["Platform"].ToString();
}
if (row["Status"] != null)
{
model.Status = row["Status"].ToString();
}
if (row["UpdateType"] != null)
{
model.UpdateType = row["UpdateType"].ToString();
}
if (row["UpdateDate"] != null && row["UpdateDate"].ToString() != "")
{
model.UpdateDate = DateTime.Parse(row["UpdateDate"].ToString());
}
if (row["OnTime"] != null && row["OnTime"].ToString() != "")
{
model.OnTime = DateTime.Parse(row["OnTime"].ToString());
}
if (row["FirstLetter"] != null)
{
model.FirstLetter = row["FirstLetter"].ToString();
}
if (row["IsLock"] != null && row["IsLock"].ToString() != "")
{
if ((row["IsLock"].ToString() == "1") || (row["IsLock"].ToString().ToLower() == "true"))
{
model.IsLock = true;
}
else
{
model.IsLock = false;
}
}
if (row["Bak1"] != null)
{
model.Bak1 = row["Bak1"].ToString();
}
if (row["Bak2"] != null)
{
model.Bak2 = row["Bak2"].ToString();
}
if (row["Bak3"] != null)
{
model.Bak3 = row["Bak3"].ToString();
}
}
return model;
}
public void GameRepository_Save()
{
var context = new Mock<IGameContext>();
var gameSet = new Mock<IDbSet<Game>>();
var tokenSet = new Mock<IDbSet<Token>>();
var players = new[] {
new Model.Player("1", "player1", false),
new Model.Player("2", "player2", true),
};
var games = new List<Game>
{
new Repository.Entity.Game { ID = 1 }
};
var tokens = new List<Token>
{
new Repository.Entity.Token { GameID = 1, ID = 100 },
new Repository.Entity.Token { GameID = 1, ID = 200 }
};
gameSet.ConfigureDbSet(games);
tokenSet.ConfigureDbSet(tokens);
context.SetupGet(x => x.Games).Returns(gameSet.Object);
context.SetupGet(x => x.Tokens).Returns(tokenSet.Object);
gameSet.Setup(x => x.Add(It.IsAny<Game>()))
.Callback<Game>(g => g.ID = 1);
var repo = new GameRepository(context.Object);
var game = new Model.Game(
1,
players[0],
players[1],
Model.GameStatus.CreateActive(players[0], players[1]),
new Model.GameBoard(new Model.GameProperties(new Model.Bounds(4, 4), 1, 1), new List<Model.Token>
{
new Model.Token(100, "player1", Model.TokenType.Bomb, 1, 2),
new Model.Token(101, "player1", Model.TokenType.Rock, 0, 3)
}));
repo.SaveAsync(game).Wait();
context.Verify(x => x.SaveChangesAsync());
tokenSet.Verify(x => x.Add(It.Is<Token>(t => t.ID == 101)));
tokenSet.Verify(x => x.Remove(It.Is<Token>(t => t.ID == 200)));
Assert.AreEqual("1", games[0].Player1ID, "player1 ID should be set");
Assert.AreEqual("player1", games[0].Player1Name, "player1 Name should be set");
Assert.AreEqual("2", games[0].Player2ID, "player2 ID should be set");
Assert.AreEqual("player2", games[0].Player2Name, "player2 Name should be set");
Assert.AreEqual(game.GameBoard.NumRows, games[0].NumRows, "NumRows should be set");
Assert.AreEqual(game.GameBoard.NumCols, games[0].NumCols, "NumCols should be set");
Assert.AreEqual(game.GameStatus.GameActive, games[0].Active, "GameOver should be set");
Assert.AreEqual(1, tokens[0].Row, "Row should be set");
Assert.AreEqual(2, tokens[0].Col, "Col should be set");
Assert.AreEqual("player1", tokens[0].PlayerID, "PlayerID should be set");
Assert.IsTrue(tokens[0].UpdatedAtUtc > DateTime.MinValue, "UpdatedAtUtc should be set");
}
/*************************************
* Start new game
*************************************/
private void startNewGame()
{
titleInstance.Stop();
game = new Model.Game(camera, spriteBatch);
gameView = new View.GameView(spriteBatch, camera, game.getLevel(), game.getPlayer(), graphics.GraphicsDevice);
game.LoadContent(Content);
gameView.LoadContent(Content);
backgroundMusic = Content.Load<SoundEffect>("level1");
playingInstance = backgroundMusic.CreateInstance();
playingInstance.IsLooped = true;
playingInstance.Pan = .5f;
playingInstance.Play();
currentGameState = GameState.GameStarted;
}
public async Task <IActionResult> Post([FromBody] Model.Game game)
{
var createdGame = GameRepository.CreateGame(game.Name);
return(Ok(createdGame.FromDal()));
}
