/// <summary>
/// Vérifie la collision entre la balle et les briques
/// </summary>
/// <param name="game">Le modèle de la partie en cours</param>
public static void CheckBallBricksCollision(Models.Game game)
{
Ball ball = game.Ball;
List <Brick> bricks = game.Bricks;
for (int i = 0; i < bricks.Count; i++)
{
Brick brick = bricks[i];
if (ball.Position.X + ball.Size.Width >= brick.Position.X && ball.Position.X <= brick.Position.X + brick.Size.Width && ball.Position.Y + ball.Size.Width >= brick.Position.Y && ball.Position.Y <= brick.Position.Y + brick.Size.Height)
{
double height = (brick.Position.Y + brick.Size.Height / 2) - (ball.Position.Y + ball.Size.Height / 2);
double width = (brick.Position.X + brick.Size.Width / 2) - (ball.Position.X + ball.Size.Width / 2);
double angle = Math.Atan(height / width);
double angleBox = Math.Atan(brick.Size.Height / brick.Size.Width);
if (Math.Abs(angle) > angleBox)
{
ball.SetDirection(ball.Direction.X, ball.Direction.Y * -1);
}
else
{
ball.SetDirection(ball.Direction.X * -1, ball.Direction.Y);
}
bricks.Remove(brick);
game.Points += 100;
}
}
}
private Game MapGame(ApiContext db, Models.Game dbGame)
{
var dbPlayers = db.Players.Where(p => p.GameId == dbGame.Id).OrderBy(p => p.TurnOrder);
var players = new List <Player>();
foreach (var dbPlayer in dbPlayers)
{
players.Add(
new Player
{
Name = dbPlayer.Name,
TurnOrder = dbPlayer.TurnOrder
}
);
}
return(new Game
{
Date = dbGame.Date,
IsComplete = dbGame.IsComplete,
Key = dbGame.Key,
Name = dbGame.Name,
Players = players,
StartingScore = dbGame.StartingScore
});
}
public Models.Game GetParsedGame(UInt64 id)
{
var dbGame = client.GetIGDBGame(id);
var game = new Models.Game()
{
Name = dbGame.name,
Description = dbGame.summary
};
if (dbGame.cover != null)
{
game.Image = "https:" + dbGame.cover.url.Replace("t_thumb", "t_cover_big");
}
if (dbGame.first_release_date != 0)
{
game.ReleaseDate = DateTimeOffset.FromUnixTimeMilliseconds(dbGame.first_release_date).DateTime;
}
if (dbGame.developers != null && dbGame.developers.Count > 0)
{
game.Developers = new ComparableList <string>();
foreach (var developer in dbGame.developers)
{
game.Developers.Add(client.GetIGDBCompany(developer).name);
}
}
if (dbGame.publishers != null && dbGame.publishers.Count > 0)
{
game.Publishers = new ComparableList <string>();
foreach (var publisher in dbGame.publishers)
{
game.Publishers.Add(client.GetIGDBCompany(publisher).name);
}
}
if (dbGame.developers != null && dbGame.developers.Count > 0)
{
game.Genres = new ComparableList <string>();
foreach (var genre in dbGame.genres)
{
game.Genres.Add(client.GetIGDBGenre(genre).name);
}
}
if (dbGame.websites != null && dbGame.websites.Count > 0)
{
var links = new ObservableCollection <Link>();
foreach (var website in dbGame.websites)
{
links.Add(new Link(website.category.ToString(), website.url));
}
game.Links = links;
}
return(game);
}
public void WhitelistPlayers(ArenaStars.Models.Game _game)
{
try
{
ArenaStarsContext db = new ArenaStarsContext();
var findGame = from x in db.Games
where x.Id == _game.Id
select x;
Models.Game g = findGame.FirstOrDefault();
User playerA = g.Participants.FirstOrDefault();
User playerB = g.Participants.LastOrDefault();
//Add players to the whitelist
string playerAID = "\"" + playerA.SteamId + "\"";
string playerBID = "\"" + playerB.SteamId + "\"";
QueryMaster.GameServer.Server server = ServerQuery.GetServerInstance(EngineType.Source, "217.78.24.8", 28892);
if (server.GetControl("lol"))
{
server.Rcon.SendCommand("sm_whitelist_add " + playerAID);
server.Rcon.SendCommand("sm_whitelist_add " + playerBID);
}
}
catch (Exception ex)
{
using (StreamWriter writer = new StreamWriter(errorsPath, true))
{
writer.WriteLine("Message :" + ex.Message + "<br/>" + Environment.NewLine + "StackTrace :" + ex.StackTrace + Environment.NewLine + "Innerexception :" + ex.InnerException +
"" + Environment.NewLine + "Date :" + DateTime.Now.ToString());
writer.WriteLine(Environment.NewLine + "-----------------------------------------------------------------------------" + Environment.NewLine);
}
}
}
public async Task DoStuff(Models.Game _game)
{
await Task.Run(() =>
{
LongRunningOperation(_game);
});
}
/// <summary>
/// Vérifie toutes les collisions
/// </summary>
/// <param name="game"></param>
public static void CheckAllCollision(Models.Game game)
{
CheckBallBarCollision(game);
CheckBallBorderCollision(game);
CheckBallBricksCollision(game);
CheckBarBorderCollision(game);
}
public bool create(Models.Game game)
{
bool success = false;
string sql = "INSERT INTO games (GAME, TIME, USER_ID, IS_FINISHED, IS_SAVED, DATE) VALUES (@game, @time, @userid, @isFinished, @isSaved, @date)";
using (SqlConnection connection = new SqlConnection(connectionString))
{
SqlCommand command = new SqlCommand(sql, connection);
command.Parameters.AddWithValue("@game", game.BoardJSON);
command.Parameters.AddWithValue("@time", game.Time);
command.Parameters.AddWithValue("@userid", game.Userid);
command.Parameters.AddWithValue("@isFinished", game.IsFinished);
command.Parameters.AddWithValue("@isSaved", game.IsSaved);
command.Parameters.AddWithValue("@date", game.date.ToString("yyyy-MM-dd HH:mm:ss.fff"));
try
{
connection.Open();
int status = command.ExecuteNonQuery();
if (status > 0)
{
success = true;
}
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
}
return(success);
}
public void CreateGAme(Models.Game game)
{
using (GameServiceClient proxy = new GameServiceClient()) {
GameServiceReference.Game serviceGame = GameModelConverter.ConvertFromClientGameToServiceGame(game);
proxy.CreateGame(serviceGame);
}
}
public IEnumerable <Odds> Convert(Models.Game input)
{
var teams = input.Teams;
var homeIndex = Array.IndexOf(teams, input.HomeTeam);
var awayIndex = Array.IndexOf(teams, input.Teams.Single(t => t != input.HomeTeam));
return(input.Sites.Select(s =>
{
var result = new Odds()
{
Site = s.SiteNice,
LastUpdate = s.LastUpdate,
OutcomeOdds = new Dictionary <OutcomeId, decimal>()
{
[OutcomeId.HomeWin] = s.Odds.H2H[homeIndex],
[OutcomeId.AwayWin] = s.Odds.H2H[awayIndex]
}
};
if (s.Odds.H2H.Length > 2)
{
result.OutcomeOdds[OutcomeId.Tie] = s.Odds.H2H[2];
}
return result;
}));
}
public IEnumerable <Bet> HandleBets(Models.Game game, RollResult roll, IEnumerable <Bet> bets)
{
IEnumerable <Bet> openBets = _gameRepository.GetBetsByStatus(BetStatus.Open);
foreach (Bet bet in bets)
{
// handle winning bets
if (game.LastGameEvents.Any(x => x == bet.GameEventId))
{
bet.BetStatusId = BetStatus.Won;
bet.Payout = CalculateBetPayout(bet);
}
else
{
// check if last game event constitutes bet loss
if (DoesGameEventLoseBet(game, roll, bet))
{
bet.BetStatusId = BetStatus.Lost;
bet.Payout = bet.Amount * -1;
}
}
}
return(bets);
}
public void HandleRoll_SubsequentRoll_TwelveRolled_ReturnTrue()
{
// instantiate Game
_game = new Models.Game();
_game.State = GameState.SubsequentRoll;
_game.Point = 9;
// override Game
_game = _gameService.OverrideGame(_game);
// instantiate roll result
RollResult roll = ForceRollResult(6, 6);
// call HandleRoll with a twelve
_game = _gameService.HandleRoll(roll);
// Make sure game isn't marked as completed and correct events are triggered
Assert.True(_game.Completed == false);
Assert.Contains(_game.LastGameEvents, x => x == GameEvent.Twelve);
Assert.Contains(_game.LastGameEvents, x => x == GameEvent.Craps);
Assert.Contains(_game.LastGameEvents, x => x == GameEvent.C);
Assert.Contains(_game.LastGameEvents, x => x == GameEvent.Field);
Assert.DoesNotContain(_game.LastGameEvents, x => x == GameEvent.Pass);
Assert.DoesNotContain(_game.LastGameEvents, x => x == GameEvent.DontPass);
}
public Response processDeckToMana(GameMessage message, Socket sender)
{
Response response = new Response(sender);
Models.Game game = onGoingGamesData.getGameByID(message.GameID);
if (game.isPlayer1(sender))
{
for (int i = 0; i < message.intArguments[0]; i++)
{
response.commandIntArgumentsToSender.Add(game.drawCard(1));
}
response.socketsToNotify.Add(game.Player2Socket);
}
else
{
for (int i = 0; i < message.intArguments[0]; i++)
{
response.commandIntArgumentsToSender.Add(game.drawCard(2));
}
response.socketsToNotify.Add(game.Player1Socket);
}
response.responseCommandToSender = "YOURDECKTOMANA";
response.responseCommandToSockets = "OPPSDECKTOMANA";
response.commandIntArgumentsToSockets = response.commandIntArgumentsToSender.ToList <int>();
return(response);
}
public async Task <IActionResult> Edit(int id, [Bind("GameId,Name,NumPlayers,Desc,GameTypeId")] Models.Game game)
{
if (id != game.GameId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(game);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!GameExists(game.GameId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["GameTypeId"] = new SelectList(_context.GameTypes, "GameTypeId", "GameTypeId", game.GameTypeId);
return(View(game));
}
public Game CreateGame(Guid userId)
{
var newGame = new Models.Game()
{
ID = Guid.NewGuid(),
UserID = userId
};
using (var triviaContext = new Entities())
{
var questions = triviaContext.Questions.Take(20);
foreach (var q in questions)
{
var newGameQuestion = new GameQuestion
{
ID = Guid.NewGuid(),
GameID = newGame.ID,
QuestionID = q.ID
};
newGame.GameQuestions.Add(newGameQuestion);
}
triviaContext.AddToGames(newGame);
triviaContext.SaveChanges();
}
using (var triviaContext = new Entities())
{
var game = triviaContext.Games
.Include("GameQuestions")
.Include("GameQuestions.Question")
.Include("GameQuestions.Question.Answers")
.FirstOrDefault(g => g.ID == newGame.ID);
return game;
}
}
private void GetGame()
{
try
{
// populate teh form with existing data from the database
int GID = Convert.ToInt32(Request.QueryString["GID"]);
// connect to the EF DB
using (DefaultConnectionGM db = new DefaultConnectionGM())
{
// populate a game object instance with the GID from the URL Parameter
Models.Game updatedStudent = (from game in db.Games
where game.GID == GID
select game).FirstOrDefault();
// map the student properties to the form controls
if (updatedStudent != null)
{
txtGameName.Text = updatedStudent.Name;
txtshortdesc.Text = updatedStudent.Description;
btnsubmit.Text = "Update";
}
}
}
catch (Exception e)
{
}
}
/**
* <summary>
* This event handler deletes a game from the db using EF
* </summary>
*
* @method gdGames_RowDeleting
* @param {object} sender
* @param {GridViewDeleteEventArgs} e
* @returns {void}
*/
protected void gdGames_RowDeleting(object sender, GridViewDeleteEventArgs e)
{
// store which row was clicked
int selectedRow = e.RowIndex;
// get the selected GID using the Grid's DataKey collection
int GID = Convert.ToInt32(gdGames.DataKeys[selectedRow].Values["GID"]);
// use EF to find the selected game in the DB and remove it
using (DefaultConnectionGM db = new DefaultConnectionGM())
{
// create object of the Game class and store the query string inside of it
Models.Game deletedGame = (from gameRecords in db.Games
where gameRecords.GID == GID
select gameRecords).FirstOrDefault();
// remove the selected game from the db
db.Games.Remove(deletedGame);
// save my changes back to the database
db.SaveChanges();
Session["GameMsg"] = "Your Record Deleted Succeessfully.";
// refresh the grid
this.GetGames();
getMessage();
}
}
public Response processISurrender(GameMessage message, Socket sender)
{
Response response = new Response(sender);
Models.Game game = onGoingGamesData.getGameByID(message.GameID);
string victorUsername;
string defeatedUsername;
if (game.isPlayer1(sender))
{
victorUsername = lobbyRoomData.getUsernameBySocket(game.Player2Socket);
defeatedUsername = lobbyRoomData.getUsernameBySocket(game.Player1Socket);
response.socketsToNotify.Add(game.Player2Socket);
}
else
{
victorUsername = lobbyRoomData.getUsernameBySocket(game.Player1Socket);
defeatedUsername = lobbyRoomData.getUsernameBySocket(game.Player2Socket);
response.socketsToNotify.Add(game.Player1Socket);
}
db.updateUserData(victorUsername, defeatedUsername);
onGoingGamesData.removeGame(game);
response.responseCommandToSockets = "OPPSURRENDERED";
response.commandIntArgumentsToSockets = message.intArguments;
return(response);
}
public void EndGame(Colors win)
{
Events.Add(black_player.Email, -2);
Events.Add(white_player.Email, -2);
Models.Game g1;
Models.Game g2;
if (win == Colors.WHITE)
{
g1 = new Models.Game()
{
PlayerId = white_player.Id, Date = DateTime.Now, OpponentPlayerId = black_player.Id, color = Colors.WHITE, Win = true
};
g2 = new Models.Game()
{
PlayerId = black_player.Id, Date = DateTime.Now, OpponentPlayerId = white_player.Id, color = Colors.BLACK, Win = false
};
}
else
{
g1 = new Models.Game()
{
PlayerId = white_player.Id, Date = DateTime.Now, OpponentPlayerId = black_player.Id, color = Colors.WHITE, Win = false
};
g2 = new Models.Game()
{
PlayerId = black_player.Id, Date = DateTime.Now, OpponentPlayerId = white_player.Id, color = Colors.BLACK, Win = true
};
}
db.Games.Add(g1);
db.Games.Add(g2);
db.SaveChanges();
Games.Remove(this);
}
internal static List <Models.Game> ParseGames(string html)
{
List <Models.Game> games = new List <Models.Game>();
if (html == null || html.Length < 5)
{
return(games);
}
var doc = buildDoc(html);
foreach (var cardDeck in doc.DocumentNode.SelectNodes("//div[@class='card-deck']"))
{
foreach (var card in cardDeck.SelectNodes("//div[@class='card mb-2 post-card']"))
{
Models.Game game = new Models.Game();
game.Name = card.SelectNodes(".//div[@class='card-body']//a//p").LastOrDefault().InnerText;
game.ImageUrl = card.SelectNodes(".//a//img[@class='card-img-top']").LastOrDefault().Attributes["src"].Value;
game.Fails = parseFails(card.SelectNodes(".//div[@class='card-body']//small[@class='text-muted']").LastOrDefault().InnerText);
games.Add(game);
}
}
return(games);
}
public Response processGetFirstGameState(ClientMessage message, Socket sender)
{
Response response = new Response(sender);
Models.Game game = onGoingGamesData.getGameByID(Int32.Parse(message.stringArguments[0]));
if (game.isPlayer1(sender))
{
if (game.isPlayer1First)
{
response.responseCommandToSender = "YOURTURN";
}
else
{
response.responseCommandToSender = "OPPTURN";
}
}
else
{
if (game.isPlayer1First)
{
response.responseCommandToSender = "OPPTURN";
}
else
{
response.responseCommandToSender = "YOURTURN";
}
}
return(response);
}
public async Task <IHttpActionResult> EditGame([FromUri] int id, [FromBody] Models.Game editGame)
{
if (id != editGame?.ID)
{
return(BadRequest("IDs do not match"));
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
Models.Game game = await _context.Game.FindAsync(id);
if (game is null)
{
return(NotFound());
}
game.GameTitle = editGame.GameTitle;
await _context.SaveChangesAsync();
return(Ok("Game was updated!"));
}
public Models.Game GetGameFromDatabase()
{
int thisGamesId = (int)HttpContext.Session.GetInt32(gameIdKey);
Models.Game thisGame = _context.Games.Include(gtj => gtj.GameTeamJoin).ThenInclude(t => t.Team).SingleOrDefault(game => game.GameId == thisGamesId);
return(thisGame);
}
private void StartFight(Character character, Models.Game game)
{
var currentFight = CreateCurrentFight(character, game);
FightAuth.SetCurrentFight(currentFight);
StaticBooleans.SetHasFightBeenInitializedBool(false);
}
// Function to advance _game progress, depending on situation
public Models.Game AdvanceGameState()
{
// If _game completed (ie. opening roll hits 2/3/7/11/12, point is hit, seven is hit after opening roll) start all over
if (_game.Completed)
{
_game = ResetGame();
}
else
{
switch (_game.State)
{
// After bet period, start with opening roll
case GameState.OpeningRollBets:
_game.State = GameState.OpeningRoll;
break;
// After opening roll completed, start subsequent roll bet period
case GameState.OpeningRoll:
_game.State = GameState.SubsequentRollBets;
break;
// After bet period, start subsequent roll
case GameState.SubsequentRollBets:
_game.State = GameState.SubsequentRoll;
break;
// If on subsequent roll, and _game not completed, stay there until _game completion
default:
break;
}
}
return(_game);
}
private int GetAmountOfMoney(Models.Game game)
{
using (var context = new BattleOfFaithsEntities())
{
var currentGame = context.Games.FirstOrDefault(g => g.Id == game.Id);
return(currentGame.Money);
}
}
public async Task <bool> PostGameAsync(Models.Game game)
{
string uri = AppSettings.GamesEndpoint;
var token = await _loginService.GetOAuthToken();
return(await _requestService.PostAsync <Models.Game, bool>(uri, game, token));
}
private void NewGame()
{
Models.Game currentGame = CreateNewGame();
AddCharactersToGame(currentGame);
GameAuth.SetCurrentGame(currentGame);
StaticBooleans.SetHasNewGame(true);
StaticBooleans.SetIsGameMenuInitializedBool(false);
}
private List <Character> GetAllGameCharacters(Models.Game game)
{
using (var context = new BattleOfFaithsEntities())
{
var currentGame = context.Games.FirstOrDefault(g => g.Id == game.Id);
return(currentGame.Characters.ToList());
}
}
private void BuyIfPossible(Item item, Models.Game game)
{
if (item.Price <= game.Money || game.Items.Count < 4)
{
BuyIt(item.Id, game.Id);
DecreaseMoney(game.Id, item.Price);
}
}
private bool BagOver4(Models.Game game)
{
using (var context = new BattleOfFaithsEntities())
{
var currentGame = context.Games.FirstOrDefault(g => g.Id == game.Id);
return(currentGame.Items.Count >= 4);
}
}
/// <summary>
/// Constructeur
/// </summary>
/// <param name="context">Le modèle du jeu</param>
public PlayState(Models.Game context)
{
this.context = context;
ball = context.Ball;
bar = context.Bar;
bricks = context.Bricks;
ball.SetDirection(0, context.Size.Height / 100);
}
//
// GET: /Sudoku/
public SudokuController()
{
if (Session["sudoku van bert"] == null)
{
// maak sudokucontroller aan en wijs toe aan sessie
// Session["sudoku van bert"] = new SudoukController();
}
// gameController = (..)Session["sudoku van bert"];
gameController = Models.SudokuSingleton.GetController().controller;
model = new Models.Game(gameController.FieldSize, gameController);
initField();
}
public ActionResult Create(CreateGameViewModel gameViewModel)
{
if (ModelState.IsValid)
{
// Auto-map properties or manually?
var game = new Models.Game();
UoW.Games.Add(game);
UoW.SaveChanges();
return RedirectToAction("Index");
}
return View(gameViewModel);
}
public static Models.Game LoadGame(int gameGroupId, string level)
{
if (gameGroupId < 0)
return null;
var dbContext = new Entities();
// var g = dbContext.Games.Where(ga => ga.Name.Equals(gameName, StringComparison.InvariantCultureIgnoreCase)).FirstOrDefault();
var gameGroup = dbContext.GameGroups.Where(g => g.GameGroupId == gameGroupId).FirstOrDefault();
Models.Game game = null;
//if (g != null)
//{
// var gameGroup = g.GameGroups.Where(gg => gg.GameId == g.GameId && gg.Level.Equals(level, StringComparison.InvariantCultureIgnoreCase)).FirstOrDefault();
if (gameGroup != null)
{
var gameVariants = dbContext.GameVariants.Where(gv => gv.GameGroupId == gameGroup.GameGroupId);
game = new Models.Game();
// game.GameWords = new List<Models.>();
foreach (var item in gameVariants)
{
//TODO
//game.Words.Add(new Models.Word
//{
// Word1 = item.Word.Word1,
// //Position = new Position2D
// //{
// // StartWord = new Coordinate { X = item.X1, Y = item.Y1 },
// // EndWord = new Coordinate { X = item.X2, Y = item.Y2 }
// //}
//});
}
}
// }
return game;
}
