/// <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; }