public void CreateNew()
{
var player = new TournamentUser();
team.Players.Add(player);
flow.Add(new PlayerRow(team, player));
}
public PlayerRow(TournamentTeam team, TournamentUser user)
{
this.user = user;
Margin = new MarginPadding(10);
RelativeSizeAxes = Axes.X;
AutoSizeAxes = Axes.Y;
Masking = true;
CornerRadius = 5;
InternalChildren = new Drawable[]
{
new Box
{
Colour = OsuColour.Gray(0.2f),
RelativeSizeAxes = Axes.Both,
},
new FillFlowContainer
{
Margin = new MarginPadding(5),
Padding = new MarginPadding {
Right = 160
},
Spacing = new Vector2(5),
Direction = FillDirection.Horizontal,
AutoSizeAxes = Axes.Both,
Children = new Drawable[]
{
new SettingsNumberBox
{
LabelText = "User ID",
RelativeSizeAxes = Axes.None,
Width = 200,
Current = playerId,
},
drawableContainer = new Container
{
Size = new Vector2(100, 70),
},
}
},
new DangerousSettingsButton
{
Anchor = Anchor.CentreRight,
Origin = Anchor.CentreRight,
RelativeSizeAxes = Axes.None,
Width = 150,
Text = "Delete Player",
Action = () =>
{
Expire();
team.Players.Remove(user);
},
}
};
}
public void PopulatePlayer(TournamentUser user, Action success = null, Action failure = null, bool immediate = false)
{
var req = new GetUserRequest(user.OnlineID, ladder.Ruleset.Value);
if (immediate)
{
API.Perform(req);
populate();
}
else
{
req.Success += res => { populate(); };
req.Failure += _ =>
{
user.OnlineID = 1;
failure?.Invoke();
};
API.Queue(req);
}
void populate()
{
var res = req.Response;
if (res == null)
{
return;
}
user.OnlineID = res.Id;
user.Username = res.Username;
user.CoverUrl = res.CoverUrl;
user.Country = res.Country;
user.Rank = res.Statistics?.GlobalRank;
success?.Invoke();
}
}
public async Task <TournamentUser> AddUser(AddUserToTournamentDto addUser)
{
var Tournament = await _context.Tournaments.FirstOrDefaultAsync(x => x.TournamentId == addUser.TournamentId);
if (Tournament.PlayerCount < 5)
{
var checkTournamentUser = await _context.TournamentUsers.FirstOrDefaultAsync(x => x.UserID == addUser.PersonJoiningTournament && x.TournamentID == addUser.TournamentId);
if (checkTournamentUser == null)
{
var TournamentUser = new TournamentUser
{
UserID = addUser.PersonJoiningTournament,
TournamentID = Tournament.TournamentId
};
await _context.TournamentUsers.AddAsync(TournamentUser);
await _context.SaveChangesAsync();
return(TournamentUser);
}
}
return(null);
}
public async Task <IActionResult> IndividualRegistration(int tournamentId, string applicationId)
{
/* Create a new instance of a TournamentUser */
TournamentUser tu = new TournamentUser();
/* Sets it's properties */
tu.User = await userManager.FindByIdAsync(applicationId);
tu.Tournament = await db.Tournament.
Include(s => s.SportType).
Include(r => r.RegisterType).
Include(t => t.TournamentType).
Include(g => g.GenderType).
FirstOrDefaultAsync(t => t.TournamentId == tournamentId);
tu.Joined = DateTime.Now;
/* Save the new instance to the database */
db.TournamentUser.Add(tu);
db.SaveChanges();
/* Redirect to userprofile */
return(RedirectToAction(nameof(UserProfileController.ShowUserProfile), "UserProfile", new { Message = MessageStatus.IndividualRegistrationSuccess }));
}
public void Update(SqlTransaction t)
{
if (!game.IsRated)
{
return;
}
//Get both players datat
UserGameType whiteUserData;
UserGameType blackUserData;
if (game.WhiteChessTypeID == 3)
{
whiteUserData = UserGameType.GetUserCentaurGameRating(game.Cxt, game.WhiteChessTypeID, game.GameTypeID, game.WhiteUserID);
}
else
{
whiteUserData = UserGameType.GetUserGameRating(game.Cxt, game.WhiteChessTypeID, game.GameTypeID, game.WhiteUserID);
}
if (game.BlackChessTypeID == 3)
{
blackUserData = UserGameType.GetUserCentaurGameRating(game.Cxt, game.BlackChessTypeID, game.GameTypeID, game.BlackUserID);
}
else
{
blackUserData = UserGameType.GetUserGameRating(game.Cxt, game.BlackChessTypeID, game.GameTypeID, game.BlackUserID);
}
//Calculate Wining Probablity of both players
double eResultWhite = 0;
double eResultBlack = 0;
RatingWinProbablity winProbablity = RatingWinProbablities.Instance.GetRatingWinProbablity(game.EloWhiteBefore, game.EloBlackBefore);
if (game.EloWhiteBefore >= game.EloBlackBefore)
{
eResultWhite = winProbablity.StrongerPlayer;
eResultBlack = winProbablity.WeakerPlayer;
}
else
{
eResultBlack = winProbablity.StrongerPlayer;
eResultWhite = winProbablity.WeakerPlayer;
}
//Calculate K-Factor -> Calculate Rating -> Save Rating -> Calculate Ranking -> Save Ranking
switch (game.GameResultIDE)
{
case GameResultE.WhiteWin:
whiteUserData = CalculateRating(whiteUserData, 1, eResultWhite, game.WhiteUserID, t);
blackUserData = CalculateRating(blackUserData, 0, eResultBlack, game.BlackUserID, t);
break;
case GameResultE.WhiteLose:
whiteUserData = CalculateRating(whiteUserData, 0, eResultWhite, game.WhiteUserID, t);
blackUserData = CalculateRating(blackUserData, 1, eResultBlack, game.BlackUserID, t);
break;
case GameResultE.Draw:
whiteUserData = CalculateRating(whiteUserData, 0.5, eResultWhite, game.WhiteUserID, t);
blackUserData = CalculateRating(blackUserData, 0.5, eResultBlack, game.BlackUserID, t);
break;
}
//***********************************************************************
if (Game.IsTournamentMatch)
{
TournamentUser.UpdateUsersEloAfter(t, Game.TournamentMatch.WhiteUserID, Game.TournamentMatch.BlackUserID, whiteUserData.EloRating, blackUserData.EloRating, Game.TournamentMatch.TournamentID);
}
}
public async Task <IActionResult> TeamRegistration(int tournamentId, int teamId, string applicationId)
{
/* Create a new instance of a TournamentUser */
TournamentTeam tt = new TournamentTeam();
/* Sets it's properties */
/* Set the team */
tt.Team = await db.Team.Include(a => a.User).FirstOrDefaultAsync(t => t.TeamId == teamId);
/* Set the tournament */
tt.Tournament = await db.Tournament.
Include(s => s.SportType).
Include(r => r.RegisterType).
Include(t => t.TournamentType).
Include(g => g.GenderType).
FirstOrDefaultAsync(t => t.TournamentId == tournamentId);
/* Set time when team joined tournament */
tt.TeamJoined = DateTime.Now;
/* If the user allready has a team registrated in the tournament we replace it with the new selected team */
var result = db.TournamentTeam.Include(u => u.Tournament).Include(t => t.Team).ThenInclude(p => p.User).Where(t => t.Tournament.TournamentId == tournamentId && t.Team.User.Id == applicationId).FirstOrDefault();
if (result != null)
{
/* We remove the earlier tournamentusers (because the number of members can be different on the different team) */
/* Get the previous teamusers */
var PreviousTeamId = result.Team.TeamId;
var PreviousTeamUsers = db.TeamUser.Include(u => u.User).Where(t => t.Team.TeamId == PreviousTeamId).ToList();
/* Remove the tournamentusers */
for (int i = 0; i < PreviousTeamUsers.Count; i++)
{
/* Get a tournamentuser and remove it */
var PreviousTournamentUser = db.TournamentUser.Include(u => u.User).Include(u => u.Tournament).Where(t => t.User.Id == PreviousTeamUsers.ElementAt(i).User.Id).Where(t => t.Tournament.TournamentId == tournamentId).FirstOrDefault();
if (PreviousTournamentUser != null)
{
db.TournamentUser.Remove(PreviousTournamentUser);
db.SaveChanges();
}
}
/* Change the existing tournament team properties in the tournament team table */
result.Team = tt.Team;
result.TeamJoined = DateTime.Now;
result.Tournament = tt.Tournament;
db.SaveChanges();
/* Save the new team members to the tournament user table */
var NewTeamUsers = db.TeamUser.Include(u => u.User).Where(t => t.Team.TeamId == teamId).ToList();
/* Add each of the tournamentusers to the table */
for (int i = 0; i < NewTeamUsers.Count; i++)
{
TournamentUser TournamentUser = new TournamentUser();
var NewTeamUser = NewTeamUsers.ElementAt(i);
TournamentUser.User = NewTeamUser.User;
TournamentUser.Tournament = tt.Tournament;
TournamentUser.Joined = DateTime.Now;
db.TournamentUser.Add(TournamentUser);
db.SaveChanges();
}
}
else /* The contactperson/user has not registrated a team in the tournament yet */
{
/* Save the team members to the tournament user table */
var NewTeamUsers = db.TeamUser.Include(u => u.User).Where(t => t.Team.TeamId == teamId).ToList();
/* Add the new tournamentusers */
for (int i = 0; i < NewTeamUsers.Count; i++)
{
TournamentUser TournamentUser = new TournamentUser();
var NewTeamUser = NewTeamUsers.ElementAt(i);
TournamentUser.User = NewTeamUser.User;
TournamentUser.Tournament = tt.Tournament;
TournamentUser.Joined = DateTime.Now;
db.TournamentUser.Add(TournamentUser);
db.SaveChanges();
}
/* Add the new tournament team to the tournament team table */
db.TournamentTeam.Add(tt);
db.SaveChanges();
}
/* Redirect to userprofile */
return(RedirectToAction(nameof(UserProfileController.ShowUserProfile), "UserProfile", new { Message = MessageStatus.TeamRegistrationSuccess }));
}
