Example #1
0
        private static MatchDay CreateMatchDayOne(List <Team> teams, Team lastTeam)
        {
            var matchDay = new MatchDay();

            matchDay.Matches = new List <Match>();
            var match = new Match();

            for (var i = 0; i < teams.Count; i++)
            {
                if (i == 0)
                {
                    match.TeamOne = lastTeam;
                    continue;
                }

                if (i % 2 == 1)
                {
                    match.TeamTwo = teams[i - 1];
                    matchDay.Matches.Add(match);
                    match = new Match();
                }
                else
                {
                    match.TeamOne = teams[i - 1];
                }
            }
            return(matchDay);
        }
Example #2
0
        public async Task <MatchDay> UpdateMatchDayHandicaps(MatchDay matchDay)
        {
            var playerResults = GetPlayersResults(matchDay);

            foreach (var playerResult in playerResults)
            {
                var player = (await _playerRepository.Find(p => p.Id == playerResult.PlayerId)).FirstOrDefault();
                if (player != null)
                {
                    if (player.Handicap + playerResult.HandicapToAdd > 90)
                    {
                        player.Handicap = 90;
                    }
                    else if (player.Handicap + playerResult.HandicapToAdd < 0)
                    {
                        player.Handicap = 0;
                    }
                    else
                    {
                        player.Handicap += playerResult.HandicapToAdd;
                    }

                    await _playerRepository.AddOrUpdate(player);
                }
            }

            return(matchDay);
        }
Example #3
0
        //private const string endpoint = "/v2/competitions/2021/matches?matchday=1";
        public IEnumerable <Match> Get()
        {
            if (MatchDay == 0)
            {
                throw new ArgumentOutOfRangeException(nameof(MatchDay));
            }
            if (CompetitionId == 0)
            {
                throw new ArgumentOutOfRangeException(nameof(CompetitionId));
            }

            var request = new RestRequest(endpoint);

            request.AddHeader("X-Auth-Token", "a969a2868cd54854bdbce65c40eb95f0");
            request.AddUrlSegment("competitionid", CompetitionId.ToString());
            request.AddUrlSegment("matchday", MatchDay.ToString());

            var response     = FootballDataApiClient.Execute(request);
            var content      = response.Content;
            var responseData = JsonConvert.DeserializeObject <JObject>(content);
            var comps        = responseData["matches"].ToString();
            var data         = JsonConvert.DeserializeObject <List <Match> >(comps);

            return(data);
        }
Example #4
0
 /// <summary>Play a match day.</summary>
 /// <param name="matchDay">The match day.</param>
 private static void PlayMatchDay(MatchDay matchDay)
 {
     foreach (var match in matchDay.Matches)
     {
         match.Play();
     }
 }
 public void SetTeamForNextGame()
 {
     if (matchNumber >= 1 && matchNumber < 5)
     {
         setSemiFinalTeams(matchNumber);
     }
     else if (matchNumber >= 5 && matchNumber < 7)
     {
         if ((matchNumber - 5) % 2 == 0)
         {
             teamA = new TeamScript(semiFinal[matchNumber - 5].MatchDayResult.Winner);
             string groupName = "Final";
             teamA.Flag = SetFlagSpriteoFTeam(groupName, "TeamA", teamA.Flag.sprite);
         }
         else
         {
             teamB = new TeamScript(semiFinal[matchNumber - 5].MatchDayResult.Winner);
             string groupName = "Final";
             teamB.Flag = SetFlagSpriteoFTeam(groupName, "TeamB", teamB.Flag.sprite);
             final[(matchNumber - 5) / 2] = new MatchDay(teamA, teamB, groupName);
         }
     }
     else if (matchNumber == 7)
     {
         tournamentWinner = new TeamScript(final[0].MatchDayResult.Winner);
         string groupName = "Winner";
         tournamentWinner.Flag   = SetFlagSpriteoFTeam(groupName, "winner", tournamentWinner.Flag.sprite);
         playButton.interactable = false;
         Debug.Log("And we are done");
     }
 }
Example #6
0
        public static League CreateLeagueMatches(this List <Team> teams)
        {
            var league = new League();

            league.Matchdays = new List <MatchDay>();
            var lastTeam = teams.Last();

            for (var i = 1; i < teams.Count; i++)
            {
                _ = new MatchDay();
                MatchDay matchDay;

                if (i == 1)
                {
                    matchDay = CreateMatchDayOne(teams, lastTeam);
                }
                else
                {
                    matchDay = CreateMatchDay(teams, lastTeam);
                }

                teams.CreateNewOrder(matchDay);
                league.Matchdays.Add(matchDay);
            }
            return(league);
        }
 // Use this for initialization
 void Start()
 {
     Debug.Log(matchNumber);
     flags = Resources.LoadAll <Sprite>("Flags");
     if (matchNumber == 0)
     {
         for (int i = 0; i < 8; i += 2)
         {
             TeamScript teamA      = null;
             TeamScript teamB      = null;
             String     groupName  = "Group" + (char)('A' + (int)(i / 2));
             Image      imageTeamA = SetFlagSpriteoFTeam(groupName, "TeamA", flags[i]);
             Image      imageTeamB = SetFlagSpriteoFTeam(groupName, "TeamB", flags[i + 1]);
             if (i == 0)
             {
                 teamA = new TeamScript(teamList[i], teamListShort[i], "human", imageTeamA);
                 teamB = new TeamScript(teamList[i + 1], teamListShort[i + 1], "bot", imageTeamB);
             }
             else
             {
                 teamA = new TeamScript(teamList[i], teamListShort[i], "bot", imageTeamA);
                 teamB = new TeamScript(teamList[i + 1], teamListShort[i + 1], "bot", imageTeamB);
             }
             MatchDay matchDay = new MatchDay(teamA, teamB, groupName);
             quarterFinal[i / 2] = matchDay;
         }
     }
 }
Example #8
0
        private MatchDay GetMatchDay()
        {
            var players  = GetPlayerQuery().ToArray();
            var matchDay = new MatchDay
            {
                Date  = new DateTimeOffset(),
                Games = new List <Game> {
                    GetGame()
                },
                Id = "123",
                MatchDayPlayers = new List <MatchDayPlayer>
                {
                    new MatchDayPlayer
                    {
                        Player     = players[0],
                        PlayerId   = players[0].Id,
                        MatchDay   = null,
                        MatchDayId = null
                    }
                },
                TenantId = tenantId
            };

            return(matchDay);
        }
Example #9
0
        private List <(string PlayerId, int HandicapToAdd)> GetPlayersResults(MatchDay matchDay)
        {
            var results = new List <(string PlayerId, int HandicapToAdd)>();

            var playerIds = matchDay.Games.Select(g => g.PlayerOneId).ToList();

            playerIds.AddRange(matchDay.Games.Select(g => g.PlayerTwoId).ToList());

            playerIds = playerIds.Distinct().ToList();



            foreach (var playerId in playerIds)
            {
                var handicapToAdd = 0;
                foreach (var game in matchDay.Games)
                {
                    handicapToAdd += HandicapToAdd(playerId, game);
                }

                results.Add((PlayerId: playerId, HandicapToAdd: handicapToAdd));
            }

            return(results);
        }
Example #10
0
        public async Task <MatchDay> UpdateMatchDayPlayers(MatchDay matchDay)
        {
            if (matchDay == null)
            {
                throw new EntityNotFoundException($"Matchday with id {matchDay.Id} does not exist.");
            }

            var matchDayPlayers = await _context.MatchDayPlayers
                                  .Where(md => md.MatchDayId == matchDay.Id)
                                  .AsNoTracking()
                                  .ToListAsync();

            foreach (var matchDayPlayer in matchDayPlayers)
            {
                var existingMatchDayPlayer = matchDay.MatchDayPlayers
                                             .FirstOrDefault(md => md.PlayerId == matchDayPlayer.PlayerId);

                if (existingMatchDayPlayer != null)
                {
                    continue;
                }
                _context.Remove(matchDayPlayer);
            }

            _context.Update(matchDay);
            return(matchDay);
        }
Example #11
0
        private static ICollection <Player> GetPlayersByGames(this MatchDay matchDay, ICollection <Game> games)
        {
            var players = games.Select(g => g.PlayerOne).ToList();

            players.AddRange(games.Select(g => g.PlayerTwo).ToList());

            return(players);
        }
Example #12
0
        private bool MatchDayHasPlayer(MatchDay matchDay, Player player)
        {
            var tstPlayer = matchDay.MatchDayPlayers
                            .Where(p => p.PlayerId == player.Id)
                            .FirstOrDefault();

            return(tstPlayer != null);
        }
Example #13
0
        /// <summary>
        /// Get the winner of a match in a specific time of the match
        /// </summary>
        /// <param name="md">The match</param>
        /// <param name="time">The time of the match</param>
        /// <returns>The winner of the match. 0 (draw), 1 (home team), 2 (away team)</returns>
        private static int getWinner(MatchDay md, int time)
        {
            int? homeGoals = getGoals(md, time, true);
            int? awayGoals = getGoals(md, time, false);

            if (homeGoals == awayGoals) return 0;
            else if (homeGoals > awayGoals) return 1;
            else return 2;
        }
Example #14
0
        public async Task Insert(MatchDay matchDay)
        {
            if (_matchDays.SingleOrDefault(md => md.Id == matchDay.Id) != null)
            {
                throw new EntityAlreadyExistsException($"MatchDay with id {matchDay.Id} already exists.");
            }

            await _matchDays.AddAsync(matchDay);
        }
Example #15
0
        /// <summary>
        /// Get the match title for a fb
        /// </summary>
        /// <param name="fb">The football bet</param>
        /// <param name="_context">The database context</param>
        /// <returns>The name of the match</returns>
        private static string getMatchTitle(FootballBet fb, ApplicationDBContext _context)
        {
            _context.Entry(fb).Reference("MatchDay").Load();
            MatchDay md = fb.MatchDay;

            _context.Entry(md).Reference("HomeTeam").Load();
            _context.Entry(md).Reference("AwayTeam").Load();

            return(md.HomeTeam.name + " vs " + md.AwayTeam.name);
        }
Example #16
0
        public async Task <MatchDay> Update(MatchDay matchDay)
        {
            if (matchDay == null)
            {
                throw new EntityNotFoundException($"Matchday with id {matchDay.Id} does not exist.");
            }

            _context.Update(matchDay);
            return(await Task.FromResult(matchDay));
        }
 public void SetTeam(MatchDay matchDay)
 {
     for (int i = 0; i < quarterFinal.Length; i++)
     {
         if (quarterFinal[i].CurrButtonName.Equals(matchDay.CurrButtonName))
         {
             quarterFinal[i] = matchDay;
         }
     }
 }
 public void SetTeams(MatchDay matchDay)
 {
     Debug.Log(matchDay.TeamA.TeamName + " vs " + matchDay.TeamB.TeamName + " in quarter final");
     teamAName.text = matchDay.TeamA.ShortName;
     teamBName.text = matchDay.TeamB.ShortName;
     teamAMode      = matchDay.TeamA.Mode;
     teamBMode      = matchDay.TeamB.Mode;
     teamAFullName  = matchDay.TeamA.TeamName;
     teamBFullName  = matchDay.TeamB.TeamName;
 }
Example #19
0
    void PlayMatch()
    {
        //here we can assume that this is a matchday
        MatchDay currentMatchday = MatchDayController.instance.CurrentMatchDay;

        foreach (Match match in currentMatchday.matches)
        {
            match.SimulateMatch();
        }
        MatchDayController.instance.CurrentMachtesPlayed = true;
    }
Example #20
0
    public Queue <MatchDay> getSeasonMatchDays()
    {
        //here we create the Matchpairs for all Matchdays of one year
        Queue <MatchDay> allMatches = new Queue <MatchDay>();

        //1. create list where all teams have the info about whom they allready
        //played
        List <MatchPairTeam> matchTeams = new List <MatchPairTeam>();

        List <Team> allTeamsTemp = LeagueController.instance.teams;

        foreach (Team team in allTeamsTemp)
        {
            MatchPairTeam newTeam = new MatchPairTeam(team);
            //the team has to play all teams execpt itself
            IEnumerable <Team> iterator = allTeamsTemp.Where(t => t.name != team.name);
            foreach (Team t in iterator)
            {
                newTeam.teamsToPlay.Add(t);
            }

            matchTeams.Add(newTeam);
        }

        //2. create the 7 games
        for (int i = 0; i < 7; i++)
        {
            MatchDay             matchDay         = new MatchDay();;
            List <MatchPairTeam> matchTeamsForDay = new List <MatchPairTeam>(matchTeams);
            while (matchTeamsForDay.Count != 0)
            {
                //take some team
                MatchPairTeam someTeam     = matchTeamsForDay.ElementAtOrDefault(0);
                MatchPairTeam validOponent = matchTeamsForDay.FirstOrDefault(t => t.teamsToPlay.Contains(someTeam.team));

                //create a match with the two teams
                Match newMatch = new Match(someTeam.team, validOponent.team);
                matchDay.matches.Add(newMatch);

                //mark the current combination as done
                someTeam.teamsToPlay.Remove(validOponent.team);
                validOponent.teamsToPlay.Remove(someTeam.team);

                //remove the teams from the candidates for the current matchday
                matchTeamsForDay.Remove(someTeam);
                matchTeamsForDay.Remove(validOponent);
            }

            allMatches.Enqueue(matchDay);
        }

        return(allMatches);
    }
Example #21
0
        public async Task <MatchDay> CreateMatchDay(string tenantId)
        {
            var matchDay = new MatchDay();

            matchDay.TenantId = tenantId;

            await _matchDayRepository.Insert(matchDay);

            await _matchDayRepository.SaveChangesAsync();

            return(matchDay);
        }
Example #22
0
        //Create list of teams based on previous matchday
        private static List <Team> CreateNewOrder(this List <Team> teams, MatchDay matchDay)
        {
            teams.RemoveAll(x => true);
            var iterableList = matchDay.Matches.ToList();

            for (var i = 0; i < iterableList.Count; i++)
            {
                teams.Add(iterableList[i].TeamOne);
                teams.Add(iterableList[i].TeamTwo);
            }

            return(teams);
        }
Example #23
0
        public void GetNextPlayersReturnsFirstPlayersIfNoGamesExist()
        {
            var matchDay = new MatchDay
            {
                Date            = DateTimeOffset.Now,
                Id              = "md",
                Games           = new List <Game>(),
                TenantId        = "tenant",
                MatchDayPlayers = new List <MatchDayPlayer>()
                {
                    new MatchDayPlayer
                    {
                        PlayerId = "p1",
                        Player   = new Player
                        {
                            FirstName       = "a",
                            LastName        = "b",
                            Handicap        = 5,
                            TenantId        = "tenant",
                            MatchDayPlayers = new List <MatchDayPlayer>(),
                            Id = "1",
                        },
                        MatchDay   = null,
                        MatchDayId = null
                    },
                    new MatchDayPlayer
                    {
                        PlayerId = "p2",
                        Player   = new Player
                        {
                            FirstName       = "c",
                            LastName        = "d",
                            Handicap        = 5,
                            TenantId        = "tenant",
                            MatchDayPlayers = new List <MatchDayPlayer>(),
                            Id = "2",
                        },
                        MatchDay   = null,
                        MatchDayId = null
                    }
                }
            };

            var nextPlayers = matchDay.GetNextPlayers(matchDay.Games);

            nextPlayers.Should().NotBeNull();
            nextPlayers.PlayerOneId.Should().Be("1");
            nextPlayers.PlayerTwoId.Should().Be("2");
        }
Example #24
0
        private static ICollection <Player> GetNextRoundPlayers(this MatchDay matchDay, ICollection <Game> games)
        {
            var availablePlayers = matchDay.GetAvailablePlayers();
            var players          = matchDay.GetPlayersByGames(games);

            foreach (var player in players)
            {
                var playerExists = availablePlayers.FirstOrDefault(p => p.Id == player.Id) != null;
                if (playerExists)
                {
                    availablePlayers.Add(player);
                }
            }

            return(availablePlayers);
        }
 public void setSemiFinalTeams(int i)
 {
     i = (i - 1);
     if (i % 2 == 0)
     {
         teamA = new TeamScript(quarterFinal[i].MatchDayResult.Winner);
         string groupName = "Semi" + (char)('A' + (int)(i / 2));
         teamA.Flag = SetFlagSpriteoFTeam(groupName, "TeamA", teamA.Flag.sprite);
     }
     else
     {
         teamB = new TeamScript(quarterFinal[i].MatchDayResult.Winner);
         string groupName = "Semi" + (char)('A' + (int)(i / 2));
         teamB.Flag       = SetFlagSpriteoFTeam(groupName, "TeamB", teamB.Flag.sprite);
         semiFinal[i / 2] = new MatchDay(teamA, teamB, groupName);
     }
 }
        //
        // ──────────────────────────────────────────────────────────────────────────────────
        //   :::::: P U B L I C   F U N C T I O N S : :  :   :    :     :        :          :
        // ──────────────────────────────────────────────────────────────────────────────────
        //

        /// <summary>
        /// Get the matchday that the fb is going to be
        /// </summary>
        /// <param name="match">A new matchday object, to save the matchday on it</param>
        /// <param name="matchday">The id of the matchday</param>
        /// <returns>True if the matchday exists, false otherwise</returns>
        private bool getMatchDay(ref MatchDay match, string matchday)
        {
            List <MatchDay> matchs = _context.MatchDays.Where(md => md.id.ToString() == matchday).ToList();

            if (matchs.Count() != 1)
            {
                return(false);
            }
            match = matchs.First();

            if (DateTime.Now > match.date || DateTime.Now.AddDays(8) < match.date)
            {
                return(false);
            }

            return(true);
        }
Example #27
0
        private static MatchDay CreateMatchDay(List <Team> teams, Team lastTeam)
        {
            var matchDay = new MatchDay();

            matchDay.Matches = new List <Match>();
            var match = new Match();
            var len   = teams.Count;

            for (var i = 0; i < len; i++)
            {
                if (i == 0)
                {
                    match.TeamOne = lastTeam;
                    teams.Remove(lastTeam);
                    continue;
                }


                if (i == 1)
                {
                    match.TeamTwo = teams.Last();
                    matchDay.Matches.Add(match);
                    match = new Match();
                    continue;
                }

                var firstTeam = teams.First();

                if (i % 2 == 1)
                {
                    match.TeamTwo = firstTeam;
                    matchDay.Matches.Add(match);
                    match = new Match();
                }
                else
                {
                    match.TeamOne = firstTeam;
                }

                teams.Remove(firstTeam);
            }

            return(matchDay);
        }
        public virtual ActionResult Create(MatchDayViewModel model)
        {
            if (ModelState.IsValid)
            {
                var matchDay = new MatchDay()
                {
                    LeagueId = model.LeagueId,
                    SeasonId = model.SeasonId,
                    Number   = model.Number,
                    Round    = model.Round
                };

                _matchDayService.Create(matchDay);

                return(RedirectToAction(MVC.Admin.MatchDays.List(model.SeasonId, model.LeagueId)));
            }

            return(View(model));
        }
Example #29
0
        /// <summary>
        /// Add a football match to the array of available matchdays
        /// </summary>
        /// <param name="mainArray">The id with the avaiable matchdays</param>
        /// <param name="md">The matchday to add</param>
        /// <param name="allowedTypes">The available fb types on this matchday</param>
        private void addFootballMatch(List <FootballMatch> mainArray, MatchDay md, List <TypeFootballBet> allowedTypes)
        {
            if (allowedTypes.Count() == 0)
            {
                return;
            }

            _context.Entry(md).Reference("HomeTeam").Load();
            _context.Entry(md).Reference("AwayTeam").Load();
            _context.Entry(md).Reference("Competition").Load();

            mainArray.Add(new FootballMatch
            {
                competition     = md.Competition.name,
                match_name      = md.HomeTeam.name + " vs " + md.AwayTeam.name,
                matchday        = md.id.ToString(),
                date            = md.date,
                allowedTypeBets = getIdsFromTypeBets(allowedTypes),
            });
        }
Example #30
0
        public static (string PlayerOneId, string PlayerTwoId) GetNextPlayers(this MatchDay matchDay, ICollection <Game> games)
        {
            var nextPlayers = (PlayerOneId : "", PlayerTwoId : "");
            var players     = matchDay.GetNextRoundPlayers(games);

            if (players.Count < 2)
            {
                throw new NotEnoughPlayersException($"MatchDay {matchDay.Id} has not enough Players to start a match. Add some players to the MatchDay.");
            }

            if (players.Count == 2)
            {
                nextPlayers.PlayerOneId = players.ElementAt(0).Id;
                nextPlayers.PlayerTwoId = players.ElementAt(1).Id;
                return(nextPlayers);
            }

            if (matchDay.Games.Count == 0)
            {
                nextPlayers.PlayerOneId = players.ElementAt(0).Id;
                nextPlayers.PlayerTwoId = players.ElementAt(1).Id;
                return(nextPlayers);
            }

            players = players.GroupBy(p => p.Id)
                      .OrderBy(g => g.Count())
                      .SelectMany(p => p)
                      .ToList();

            nextPlayers.PlayerOneId = players.ElementAt(0).Id;
            players = players.Where(p => p.Id != nextPlayers.PlayerOneId).ToList();

            var groups = players.GroupBy(p => p.Id)
                         .OrderBy(g => g.Count());

            nextPlayers.PlayerTwoId = GetRandomSecondPlayer(groups);

            return(nextPlayers);
        }