public static void SubmitTeam(string teamName, List <Players> selectedPlayers)
{
using var db = new FootballContext();
Teams newTeam = new Teams
{
TeamName = teamName
};
db.Teams.Add(newTeam);
db.SaveChanges();
foreach (var selectedplayer in selectedPlayers)
{
PlayerTeams newEntry = new PlayerTeams
{
TeamId = newTeam.TeamId,
PlayerId = selectedplayer.PlayerId
};
db.PlayerTeams.Add(newEntry);
}
TeamStatistics newStatistics = new TeamStatistics
{
TeamId = newTeam.TeamId,
MatchesPlayed = 0,
Wins = 0,
Draws = 0,
Losses = 0,
GoalsScored = 0,
GoalsConceded = 0
};
db.TeamStatistics.Add(newStatistics);
db.SaveChanges();
}
public List <TeamStatistics> GetRaceStatisticsForTesting(Guid raceId, DateTime now)
{
var race = this._raceRepository.Get(raceId);
var lapStatistics = this._lapStatisticRepository.Find(raceId);
var teamsLapStatistics = lapStatistics.GroupBy(x => x.TeamId);
var teamsStatistics = new List <TeamStatistics>();
foreach (var teamLapStatistics in teamsLapStatistics)
{
var teamId = teamLapStatistics.Key;
var teamName = teamLapStatistics.First().TeamName;
var totalDistanceInMeters = 0;
var numberOfLaps = teamLapStatistics.Count();
foreach (var teamLapStatistic in teamLapStatistics)
{
totalDistanceInMeters += teamLapStatistic.DistanceInMeters;
}
var teamStatistics = new TeamStatistics(
teamId,
teamName,
totalDistanceInMeters,
numberOfLaps,
race.ElapsedForTesting(now));
teamsStatistics.Add(teamStatistics);
}
return(teamsStatistics);
}
/**
* Team statistics view model
* WinDrawLossViewModel[0] - Host matches
* WinDrawLossViewModel[1] - Guest matches
*/
private List <TeamStatistics> ParseTeamStatistics(List <Team> rawTeamsData)
{
List <TeamStatistics> allTeamsStatistics = new List <TeamStatistics>();
foreach (Team team in rawTeamsData)
{
WinDrawLossViewModel hostScores = ParseHostScores(team.HostMatches);
WinDrawLossViewModel guestScores = ParseGuestScores(team.GuestMatches);
//WinDrawLossViewModel totalScores = new WinDrawLossViewModel()
//{
// Win = hostScores.Win + guestScores.Win,
// Draw = hostScores.Draw + guestScores.Draw,
// Loss = hostScores.Loss + guestScores.Loss
//};
TeamStatistics teamStats = new TeamStatistics()
{
TeamId = team.Id,
TeamName = team.Name,
Statistics = new WinDrawLossViewModel
{
Win = hostScores.Win + guestScores.Win,
Draw = hostScores.Draw + guestScores.Draw,
Loss = hostScores.Loss + guestScores.Loss
}
};
allTeamsStatistics.Add(teamStats);
}
return(allTeamsStatistics);
}
protected override void EmitInternal(TextWriter tw, DataStore data)
{
var matches = (data.Matches.Select((m) => new { Team = m.TeamWinner, Win = true })).Concat(data.Matches.Select((m) => new { Team = m.TeamLoser, Win = false }));
var players = (data.Records.Select((r) => new { Player = r.Winner, Win = true })).Concat(data.Records.Select((r) => new { Player = r.Loser, Win = false }));
var table = from g in matches.GroupBy((m) => m.Team)
let allKills = (from m in data.Matches
where m.Games.Count > 0 &&
m.TeamWinner == g.Key &&
m.Games.All((s) => s.Winner.Equals(m.Games.Last().Winner) || s.Winner.Team != g.Key)
select m).Count()
let matchCount = WL.Fill(g, (p) => p.Win)
let games = (from r in data.Records
where r.Winner.Team == g.Key || r.Loser.Team == g.Key
select r.Winner.Team == g.Key)
let gameCount = WL.Fill(games, (p) => p)
let diff = gameCount.Wins - gameCount.Losses
orderby matchCount.Wins descending, matchCount.Losses, diff descending
select new Bag(
"team", g.Key,
"allkills", "{{AllKillIcon}}".Repeat(allKills),
"matchCount", matchCount.Total.ToString(),
"matches", matchCount.ToString(),
"gameCount", gameCount.Total.ToString(),
"games", gameCount.ToString(),
"gameDiff", diff.ToStringWithSign(true)
);
var template = new TeamStatistics();
template.IncludeAllKills = this.IncludeAllKillsColumn;
template.Rows = table.Index((a, b) => false);
tw.Write(template.TransformText());
}
private void InsertTeamStatistics(TransactionManager transactionManager, List <Team> teams)
{
foreach (var team in teams)
{
var teamStatistics = new TeamStatistics(team);
transactionManager.RegisterInsert(teamStatistics);
}
}
public TeamMatchData(string _teamId, TeamAttributes _attributes)
{
TeamId = _teamId;
Statistics = new TeamStatistics();
Scorers = new List <PlayerData>();
YellowCards = new List <PlayerData>();
RedCards = new List <PlayerData>();
}
public void Reset()
{
TeamId = "";
Statistics = new TeamStatistics();
Scorers = new List <PlayerData>();
YellowCards = new List <PlayerData>();
RedCards = new List <PlayerData>();
}
public TeamStatistics CreateStatistics()
{
List <Game> games = this.dataAccess.LoadGamesOfSeasonForTeam(this.season.ID, this.team.ID);
TeamStatistics teamStatistics = new TeamStatistics(this.season, this.team);
foreach (Game game in games)
{
teamStatistics.AddGame(game);
}
return(teamStatistics);
}
private async void OnRefresh()
{
if (CurrentTeam != null)
{
await IgnoreExceptions(async () =>
{
var teamStatistics = await _statisticsClient.GetTeamStatistics(CurrentTeam.Name, _cacheService.Load<String>("PSWD"));
TeamStatistics.Clear();
teamStatistics.ForEach(ts => TeamStatistics.Add(ts));
});
}
}
//Constructor
public Team(string cityName = "Seoul", string teamName = "Bears", string shortName = "SLB", int year = 1990, int month = 1, int day = 1, List <KeyValuePair <int, Player> > playerList = null)
{
teamData = new TeamData(cityName, teamName, shortName, year, month, day);
teamStats = new TeamStatistics();
players = new SerializableList <KeyValuePair <int, Player> >();
if (playerList != null)
{
players.d = playerList;
}
startingMembers = new SerializableList <KeyValuePair <Player.Position, Player> >();
battingOrder = new SerializableList <Batter>();
startPitchOrder = new SerializableList <Pitcher>();
}
public void UpdateLifeTimeStats(string _tournamentId)
{
TeamStatistics data = MatchStats;
UpdateStats(LifeTimeStats, data);
UpdateTournamentStatistics(data, _tournamentId);
//Update players statistics
foreach (PlayerData player in AllPlayers)
{
player.UpdateLifeTimeStats(_tournamentId);
}
ResetStatistics("Match");
}
void UpdateTournamentStatistics(TeamStatistics _stats, string _tournamentId)
{
if (TournamentStatistics == null)
{
Attributes.TournamentStatistics = new TeamTournamentStats();
}
if (!TournamentStatistics.ContainsKey(_tournamentId))
{
TournamentStatistics.Add(_tournamentId, new TeamStatistics());
}
TeamStatistics tStats = GetTournamentStatistics(_tournamentId);
UpdateStats(tStats, _stats);
}
public List <TeamStatistics> GetRaceStatistics(Guid raceId)
{
var stopWatch = new Stopwatch();
stopWatch.Start();
var race = this._raceRepository.Get(raceId);
stopWatch.Stop();
//StatsPrinter.Print("GetRace", stopWatch.ElapsedMilliseconds);
StatsPrinter.AddGetRace(stopWatch.ElapsedMilliseconds);
stopWatch.Reset();
stopWatch.Start();
var lapStatistics = this._lapStatisticRepository.Find(raceId);
stopWatch.Stop();
//StatsPrinter.Print("FindLapStatistic", stopWatch.ElapsedMilliseconds);
StatsPrinter.AddFindLapStatistics(stopWatch.ElapsedMilliseconds);
var teamsLapStatistics = lapStatistics.GroupBy(x => x.TeamId);
var teamsStatistics = new List <TeamStatistics>();
foreach (var teamLapStatistics in teamsLapStatistics)
{
var teamId = teamLapStatistics.Key;
var teamName = teamLapStatistics.First().TeamName;
var totalDistanceInMeters = 0;
var numberOfLaps = teamLapStatistics.Count();
foreach (var teamLapStatistic in teamLapStatistics)
{
totalDistanceInMeters += teamLapStatistic.DistanceInMeters;
}
var teamStatistics = new TeamStatistics(
teamId,
teamName,
totalDistanceInMeters,
numberOfLaps,
race.Elapsed());
teamsStatistics.Add(teamStatistics);
}
return(teamsStatistics);
}
public void ResetStatistics(string _type, string _id = "")
{
switch (_type)
{
case "Match": MatchStats = new TeamStatistics(); break;
case "LifeTime": LifeTimeStats = new TeamStatistics(); break;
case "Tournament":
TournamentStatistics[_id] = new TeamStatistics();
foreach (PlayerData player in AllPlayers)
{
player.ResetStatistics("Tournament", _id);
}
break;
}
}
public void UpdateStats(TeamStatistics _stats, TeamStatistics _data)
{
_stats.Points += _data.Points;
_stats.Wins += _data.Wins;
_stats.Losts += _data.Losts;
_stats.Draws += _data.Draws;
_stats.Goals += _data.Goals;
_stats.GoalsAgainst += _data.GoalsAgainst;
_stats.Shots += _data.Shots;
_stats.Headers += _data.Headers;
_stats.Steals += _data.Steals;
_stats.Passes += _data.Passes;
_stats.LongPasses += _data.LongPasses;
_stats.PassesMissed += _data.PassesMissed;
_stats.BoxCrosses += _data.BoxCrosses;
_stats.Faults += _data.Faults;
_stats.CounterAttacks += _data.CounterAttacks;
}
public ObjectResult Get(long seasonID, long teamID)
{
ObjectResult response = null;
Season season = this.dataAccess.LoadSeason(seasonID);
Team team = this.dataAccess.LoadTeam(teamID);
if ((season == null) || (team == null))
{
response = this.StatusCode(StatusCodes.Status404NotFound, "Not Found");
}
else
{
TeamAnalizer teamAnalizer = new TeamAnalizer(season, team, this.dataAccess);
TeamStatistics statistics = teamAnalizer.CreateStatistics();
response = this.StatusCode(StatusCodes.Status200OK, statistics);
}
return(response);
}
static void Main(string[] args)
{
var mlContext = new MLContext();
var modelo = mlContext.Model.Load(args[0], out var schema);
var predictor = mlContext.Model.CreatePredictionEngine <TeamStatistics, ManOfTheMatchPrediction>(modelo);
for (int i = 0; i < 10; i++)
{
var statistics = new TeamStatistics
{
GoalScored = i
};
var prediction = predictor.Predict(statistics);
Console.WriteLine($"Prediction for goals {statistics.GoalScored} {prediction.ManOfTheMatch} - {prediction.Score} - {prediction.Probability}");
}
}
async Task ICeaSubCommand.Run(SocketSlashCommand command, DiscordSocketClient client, IReadOnlyDictionary <SlashCommandOptions, string> options, Lazy <List <Team> > lazyTeams)
{
BracketSet currentBrackets = LeagueManager.League.Bracket;
BracketRound currentRound = currentBrackets.Rounds.Last().First();
string currentStage = StageMatcher.Lookup(currentRound.RoundName);
List <StageGroup> stageGroups = ConfigurationManager.Configuration.stageGroups.ToList();
List <StageGroup> currentStageGroups = stageGroups.Where(g => g.Stage.Equals(currentStage)).ToList();
List <Embed> embeds = new();
foreach (StageGroup group in currentStageGroups)
{
EmbedBuilder builder = new();
StringBuilder result = new StringBuilder();
int page = 0;
List <Team> teams = group.Teams.OrderBy(t => t.RoundRanking[currentRound]).ToList();
foreach (Team team in teams)
{
TeamStatistics stats = team.StageStats[currentStage];
result.AppendLine($"{team.RoundRanking[currentRound]} {team} [**{stats.MatchWins}**-{stats.MatchLosses}] GoalDiff: {stats.TotalGoalDifferential}");
if (result.Length > 800)
{
builder.AddField(page == 0 ? $"{group.Name} Standings" : $"{group.Name} Continued", result.ToString());
result = new StringBuilder();
page++;
}
}
if (result.Length > 0)
{
builder.AddField(page == 0 ? $"{group.Name} Standings" : $"{group.Name} Continued", result.ToString());
}
embeds.Add(builder.Build());
}
bool ephemeral = !options.ContainsKey(SlashCommandOptions.post) || !options[SlashCommandOptions.post].Equals("True");
await command.RespondAsync(embeds : embeds.ToArray(), ephemeral : ephemeral);
}
private void Awake()
{
MatchStats = new TeamStatistics();
}
public TeamStatistics GetTournamentStatistics(string _key)
{
TeamStatistics stats = TournamentStatistics[_key];
return(stats);
}
public TeamStatistics GetTeamStatistics(IList <TeamDetail> teams)
{
var teamsStatistics = new TeamStatistics();
return(teamsStatistics);
}
private void EndGame()
{
StopAllCoroutines();
if (homeTeam.MatchStats.Goals > awayTeam.MatchStats.Goals)
{
homeTeam.MatchStats.Wins++;
awayTeam.MatchStats.Losts++;
homeTeam.MatchStats.Points += 3;
}
else if (awayTeam.MatchStats.Goals > homeTeam.MatchStats.Goals)
{
awayTeam.MatchStats.Wins++;
homeTeam.MatchStats.Losts++;
awayTeam.MatchStats.Points += 3;
}
else
{
homeTeam.MatchStats.Draws++;
awayTeam.MatchStats.Draws++;
homeTeam.MatchStats.Points++;
awayTeam.MatchStats.Points++;
}
homeTeam.MatchStats.GoalsAgainst += awayTeam.MatchStats.Goals;
awayTeam.MatchStats.GoalsAgainst += homeTeam.MatchStats.Goals;
currentMatch.HomeTeam.Statistics = homeTeam.MatchStats;
currentMatch.AwayTeam.Statistics = awayTeam.MatchStats;
currentMatch.isPlayed = true;
homeTeam.UpdateLifeTimeStats(currentMatch.TournamentId);
awayTeam.UpdateLifeTimeStats(currentMatch.TournamentId);
screen.AddSimulatedMatch(currentMatch);
//Save tournament match data
TournamentData currentTournament = MainController.Instance.GetTournamentById(currentMatch.TournamentId);
if (currentTournament != null)
{
TeamStatistics homeTeamStats = homeTeam.GetTournamentStatistics(currentTournament.Id);
TeamStatistics awayTeamStats = awayTeam.GetTournamentStatistics(currentTournament.Id);
/*
* nextMatch = currentTournament.GetNextMatchInCurrentRound();
* Sequence seq = DOTween.Sequence();
* if (nextMatch != null)
* {
* screen.ShowButtons(false);
* seq.AppendInterval(1f).AppendCallback(StartNextMatch);
* }
* else
* {
* seq.AppendInterval(1f).AppendCallback(ExitSimulation);
* }*/
}
Sequence seq = DOTween.Sequence();
if (isSimulatingMatch)
{
UpdateCalendar();
}
else
{
seq.AppendInterval(1f).AppendCallback(UpdateCalendar);
}
}
private async void CboOppositeTeam_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
if (cboOppositeTeam.SelectedIndex == -1 || cboFavoriteTeam.SelectedIndex == -1)
{
return;
}
SoccerCanvas.Children.Clear();
string favoritecode = (cboFavoriteTeam.SelectedItem as TeamFifaData).FifaCode;
string oppositioncode = (cboOppositeTeam.SelectedItem as TeamFifaData).FifaCode;
bool home = false;
var MatchesData = await repo.FetchTeamMatchesDataAsyc(favoritecode);
TeamMatchesData MatchData = null;
TeamStatistics fav = new TeamStatistics();
TeamStatistics opp = new TeamStatistics();
foreach (var Match in MatchesData)
{
if (Match.AwayTeam.Code == oppositioncode)
{
home = true;
opp = Match.AwayTeamStatistics;
fav = Match.HomeTeamStatistics;
MatchData = Match;
}
else if (Match.HomeTeam.Code == oppositioncode)
{
home = false;
opp = Match.HomeTeamStatistics;
fav = Match.AwayTeamStatistics;
MatchData = Match;
}
}
int[] sequence = new int[] { 2, 3, 1, 4, 0, 0, 0 };
Dictionary <string, int[]> dicseq = new Dictionary <string, int[]>();
int g = 0;
int d = 0;
int m = 0;
int f = 0;
foreach (var player in fav.StartingEleven)
{
PlayerDisplay pd = new PlayerDisplay(player, MatchData);
SoccerCanvas.Children.Add(pd);
switch (player.Position)
{
case "Goalie":
Grid.SetRow(pd, sequence[g]);
Grid.SetColumn(pd, 0);
g++;
break;
case "Defender":
Grid.SetRow(pd, sequence[d]);
Grid.SetColumn(pd, 1);
d++;
break;
case "Midfield":
Grid.SetRow(pd, sequence[m]);
Grid.SetColumn(pd, 2);
m++;
break;
case "Forward":
Grid.SetRow(pd, sequence[f]);
Grid.SetColumn(pd, 3);
f++;
break;
default:
break;
}
}
g = 0;
d = 0;
m = 0;
f = 0;
foreach (var player in opp.StartingEleven)
{
PlayerDisplay pd = new PlayerDisplay(player, MatchData);
SoccerCanvas.Children.Add(pd);
switch (player.Position)
{
case "Goalie":
Grid.SetRow(pd, sequence[g]);
Grid.SetColumn(pd, 7);
g++;
break;
case "Defender":
Grid.SetRow(pd, sequence[d]);
Grid.SetColumn(pd, 6);
d++;
break;
case "Midfield":
Grid.SetRow(pd, sequence[m]);
Grid.SetColumn(pd, 5);
m++;
break;
case "Forward":
Grid.SetRow(pd, sequence[f]);
Grid.SetColumn(pd, 4);
f++;
break;
default:
break;
}
}
}
