public void SubPlayer(MatchPlayer playerOff, MatchPlayer playerOn, int minute)
{
MatchPlayer plOff = context.MatchPlayers
.Where(m => m == playerOff)
.FirstOrDefault();
if (plOff != null)
{
plOff.IsSubbed = true;
plOff.MinuteOff = minute;
context.SaveChanges();
}
MatchPlayer plOn = context.MatchPlayers
.Where(m => m == playerOn)
.FirstOrDefault();
if (plOn != null)
{
plOn.IsSubbed = true;
plOn.MinuteOn = minute;
context.SaveChanges();
}
}
public void EndGame(Global.PLAY_TYPE playType, MatchPlayer local, MatchPlayer other, MatchReport result)
{
UI_InGamePopup.Get().SetViewWaiting(false);
// 인디케이터도 다시 안보이게..
if (UI_InGamePopup.Get().IsIndicatorActive() == true)
{
UI_InGamePopup.Get().ViewGameIndicator(false);
}
StopAllCoroutines();
SoundManager.instance?.StopBGM();
BroadcastMessage("EndGameUnit", SendMessageOptions.DontRequireReceiver);
UI_InGame.Get().ClearUI();
StartCoroutine(EndGameCoroutine(playType, local, other, result));
}
public void SetPopupResult(
Global.PLAY_TYPE playType, MatchPlayer localPlayer, MatchPlayer otherPlayer,
bool view, bool winLose, int winningStreak, bool perfect,
List <ItemBaseInfo> normalReward, List <ItemBaseInfo> streakReward, List <ItemBaseInfo> perfectReward, AdRewardInfo loseReward)
{
popup_Result.gameObject.SetActive(view);
if (view)
{
popup_Result.Initialize(playType, localPlayer, otherPlayer,
winLose, winningStreak, perfect,
normalReward, streakReward, perfectReward, loseReward);
}
ViewGameIndicator(false);
ShowLowHPEffect(false);
SetViewWaiting(false);
}
/* #endregion */
/* ======================================================================================== */
/* #region ==== C R E A T E P L A Y E R S ================================================ */
private void addPlayersToPitch()
{
List <Player> playersList = MatchManager.MatchTeamManager.PlayerTeam.Players;
MatchPlayersList = new List <MatchPlayer>();
Team team = MatchManager.MatchTeamManager.PlayerTeam;
if (playersList.Count < 1 || playersList == null)
{
Debug.Log("The team has no players", this);
}
else
{
int count = 0;
foreach (var player in playersList)
{
count++;
/* #region ---- Get start position -------------------------------------------- */
int coordX = 0;
int coordZ = 0;
foreach (KeyValuePair <Player.StartPos, int> pos in player.startPosition)
{
if (pos.Key == Player.StartPos.X)
{
coordX = pos.Value;
}
if (pos.Key == Player.StartPos.Z)
{
coordZ = pos.Value;
}
}
/* #endregion */
PitchTile pitchTile = MatchManager.PitchManager.GetPitchTile(coordX, coordZ);
GameObject playerObj = (GameObject)Instantiate(playerPrefab);
MatchPlayer matchPlayer = playerObj.GetComponent <MatchPlayer>();
setPlayerInfo(playerObj, matchPlayer, player, team, pitchTile, count, coordX, coordZ);
setPlayerActiveState(playerObj, player);
setVectorPosition(pitchTile, playerObj);
setTileOccupied(pitchTile, matchPlayer);
MatchPlayersList.Add(matchPlayer);
SetCurrentBallHolder(matchPlayer);
}
}
}
public MatchPlayer DeleteMatchPlayer(MatchPlayer pl)
{
MatchPlayer mp = context.MatchPlayers
.Where(p => p == pl)
.FirstOrDefault();
if (mp != null)
{
context.MatchPlayers.Remove(mp);
return mp;
}
else
{
return null;
}
}
public async Task <int> Handle(CreateMatchPlayerCommand request, CancellationToken cancellationToken)
{
var matchPlayer = new MatchPlayer
{
IsHome = request.IsHome,
IsSubstitute = request.IsSubstitute,
ShirtNumber = request.ShirtNumber,
Player = await GetPlayer(request.PlayerId),
Match = await GetMatch(request.MatchId),
};
context.MatchPlayers.Add(matchPlayer);
await context.SaveChangesAsync(cancellationToken);
return(matchPlayer.Id);
}
private static async Task CreateMatchPlayer(IDbConnection c, IDbTransaction t, Match dbMatch, Models.Db.Team team, Models.Db.Player player)
{
// Check apparelnumber
var dbMatchPlayer = new MatchPlayer
{
IdMatch = dbMatch.Id,
IdPlayer = player.Id,
IdTeam = team.Id,
IdUser = player.IdUser,
ApparelNumber = player.TeamData.ApparelNumber,
IdDay = dbMatch.IdDay,
Player = player,
Status = 1
};
await c.InsertAsync(dbMatchPlayer, t);
}
/* #endregion */
/* ======================================================================================== */
/* #region ==== D R A W R O T A T I O N G R I D (Around the active player) ============= */
public void DrawRotationGrid(MatchPlayer Player)
{
if (Player.PlayerMode == PlayerMode.Rotate &&
Player.PlayerActions.RotationCounter < MatchManager.MatchPlayerManager.ActionsApCostSettings.MaxRotationsPerTurn)
{
ClearAll();
foreach (var tile in Player.CurrentTile.NeighbourTiles)
{
tile.ActivateRotateGridOverlay(true);
}
}
else
{
MatchManager.Hud.UpdateGameMessage(MatchManager.Hud.Messages.NoMoreRotations);
}
}
public void SetCharacter(int c)
{
if (NetworkManager.singleton.GetComponent <SanicNetworkManager>().matchManager.Players.Count != 0 && NetworkManager.singleton.GetComponent <SanicNetworkManager>().matchManager.Players[0].BallObject)
{
if (NetworkManager.singleton.GetComponent <SanicNetworkManager>().matchManager.Players[0].BallObject.ballConnection == connectionToClient)
{
AssignedPlayer = NetworkManager.singleton.GetComponent <SanicNetworkManager>().matchManager.Players[0];
}
else
{
Debug.Log("A player was here before you");
}
}
if (AssignedPlayer == null)
{
AssignedPlayer = playerManager.CreatePlayerForControlType(AssignedCtrlType, c);
}
else
{
if (NetworkManager.singleton.GetComponent <SanicNetworkManager>().matchManager.isServer)
{
playerManager.SetCharacter(AssignedPlayer, c);
}
else
{
Debug.Log(AssignedPlayer.BallObject);
GameObject.Find("SanicNetworkManager").GetComponent <SanicNetworkManager>().controlTipo = AssignedPlayer.CtrlType;
GameObject.Find("SanicNetworkManager").GetComponent <SanicNetworkManager>().personaje = c;
GameObject.Find("SanicNetworkManager").GetComponent <SanicNetworkManager>().nickName = AssignedPlayer.Name;
AssignedPlayer.CharacterId = c;
AssignedPlayer.BallObject.CmdSetcharacterFromBall(c);
}
}
if (characterSelectSubpanel.gameObject.activeSelf)
{
characterSelectSubpanel.gameObject.SetActive(false);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="PlayerStatistics"/> class.
/// </summary>
/// <param name="match">The match to calculate the statistics for.</param>
/// <param name="player">The player in the match</param>
public PlayerStatistics(Match match, MatchPlayer player)
: base(match)
{
this.Player = player;
this.TotalSets = this.Match.FinishedRallies
.Where(r => r.IsEndOfSet && r.Winner == this.Player)
.Count();
this.TotalPoints = this.Match.FinishedRallies
.Where(r => r.Winner == this.Player)
.Count();
this.WinningProbability = this.TotalPoints / (double)this.Match.FinishedRallies
.Where(r => r.Winner != MatchPlayer.None)
.Count();
this.ServiceFrequency = this.Match.FinishedRallies
.Where(r => r.Server == this.Player)
.Count();
this.ProbabilityOfWinningAfterService = this.Match.FinishedRallies
.Where(r => r.Server == this.Player && r.Winner == this.Player)
.Count() / (double)this.ServiceFrequency;
var sets = this.Match.FinishedRallies
.Where(r => r.IsEndOfSet)
.ToArray();
var rallyPerformance = sets
.Sum(r => this.Performance(r));
this.CompetitionPerformance = 22 - Math.Sqrt(rallyPerformance / sets.Length);
var scoringProcess = new List <List <int> >()
{
new List <int>()
};
foreach (var rally in this.Match.FinishedRallies)
{
scoringProcess.Last().Add(rally.FinalRallyScore.Of(this.Player));
if (rally.IsEndOfSet)
{
scoringProcess.Add(new List <int>());
}
}
this.ScoringProcess = scoringProcess;
}
public void Play_PenaltiesTaken_WhenDrawNotPermitted()
{
_randomizer.Setup(x => x.HomeTeamWins(It.IsAny <Dictionary <bool, float> >())).Returns(true);
_randomizer.Setup(x => x.HomeScore(It.IsAny <Dictionary <int, float> >())).Returns(0);
_randomizer.Setup(x => x.AwayScore(It.IsAny <Dictionary <int, float> >())).Returns(0);
_penaltyTaker.Setup(x => x.TakePenalties(It.IsAny <Shared.DomainObjects.Match>()));
var match = Helper.GetValidMatch();
match.DrawPermitted = false;
var matchPlayer = new MatchPlayer(_randomizer.Object, _penaltyTaker.Object);
matchPlayer.Play(match);
_penaltyTaker.Verify(x => x.TakePenalties(It.IsAny <Shared.DomainObjects.Match>()), Times.Once);
Assert.AreEqual(MatchStatus.Ended, match.MatchStatus);
}
private void TaskMaker_mapReady3D(MapData map, bool showMap, bool showControls)
{
if (showMap)
{
var viewMode = showControls ? UserViewController.ViewMode.firstPerson : UserViewController.ViewMode.freeLook;
View3DMap(map, viewMode);
if (showControls && MatchInfoPanel.match != null)
{
TaskManagerController.RunAction(() =>
{
MatchPlayer.OpenMatch(MatchInfoPanel.match, false);
});
}
//else if (!showControls)
// View3DMap(map, viewMode);
}
}
public void Play_NoPenaltiesTaken_WhenDrawPermitted()
{
_randomizer.Setup(x => x.HomeTeamWins(It.IsAny <Dictionary <bool, float> >())).Returns(true);
_randomizer.Setup(x => x.HomeScore(It.IsAny <Dictionary <int, float> >())).Returns(0);
_randomizer.Setup(x => x.AwayScore(It.IsAny <Dictionary <int, float> >())).Returns(0);
var match = Helper.GetValidMatch();
match.DrawPermitted = true;
var matchPlayer = new MatchPlayer(_randomizer.Object, _penaltyTaker.Object);
matchPlayer.Play(match);
Assert.IsFalse(match.PenaltiesTaken);
Assert.AreEqual(0, match.HomePenaltyScore);
Assert.AreEqual(0, match.AwayPenaltyScore);
Assert.AreEqual(MatchStatus.Ended, match.MatchStatus);
}
public IActionResult Edit(MatchPlayerViewModel model, int matchId, int teamId)
{
Match match = matchRepository.Matches.FirstOrDefault(c => c.MatchID == matchId);
Team team = teamRepository.Teams.FirstOrDefault(t => t.TeamID == teamId);
if (ModelState.IsValid)
{
model.MatchPlayer.Match = match;
model.MatchPlayer.TeamPlayer = team.Players.FirstOrDefault(tp => tp.TeamPlayerID == model.SelectedTeamPlayerID);
if (model.MatchPlayer.MatchPlayerID == 0)
{
match.MatchPlayers.Add(model.MatchPlayer);
}
else
{
MatchPlayer matchPlayerDb = match.MatchPlayers.First(mp => mp.MatchPlayerID == model.MatchPlayer.MatchPlayerID);
matchPlayerDb.TeamPlayer = model.MatchPlayer.TeamPlayer;
matchPlayerDb.Goals = model.MatchPlayer.Goals;
matchPlayerDb.YellowCards = model.MatchPlayer.YellowCards;
matchPlayerDb.RedCards = model.MatchPlayer.RedCards;
}
calculateGoals(match);
matchRepository.Save(match);
TempData["message"] = $"An event has been created to {model.MatchPlayer.TeamPlayer.Player.FullName} for the match.";
return(RedirectToAction("Detail", "Match", new { matchId }));
}
else
{
MatchPlayerViewModel modelView = new MatchPlayerViewModel
{
MatchPlayer = new MatchPlayer {
Match = match
},
TeamPlayers = team.Players.ToList(),
TeamID = team.TeamID
};
return(View(modelView));
}
}
private void SpawnPlayers(TeamData _team, List <MatchPlayer> _list, Vector2 _spawnPoint, MatchZonesContainer _zones)
{
PlayerData[] players = _team.Squad;
FormationData formation = _team.Formation;
for (int i = 0; i < players.Length; i++)
{
MatchPlayer player = Instantiate(playerTemplate, playersContainer);
player.transform.localPosition = _spawnPoint;
player.Populate(players[i], (i + 1).ToString());
player.gameObject.SetActive(true);
_list.Add(player);
}
for (int j = 0; j < formation.Zones.Length; j++)
{
Zone zone = formation.Zones[j];
_list[j].MoveTo(GetZone(zone, _zones).transform.position, 1f, 0.1f * j);
}
}
/* #endregion */
/* #region ---- Get Active Player --------------------------------------------------------- */
public MatchPlayer GetActivePlayer()
{
MatchPlayer activePlayer = null;
foreach (var player in MatchPlayersList)
{
if (player.IsActive)
{
activePlayer = player;
break;
}
}
if (activePlayer == null)
{
Debug.Log("No player is set to active", this);
}
return(activePlayer);
}
/* #endregion */
/* #region ---- Set Ball position at the BallHolder (depending on BallHolders curren angle)*/
private void setBallPositionInPossession(MatchPlayer Player)
{
BallGridPoint ballPoint = null;
switch (Player.currentAngle)
{
case 0:
ballPoint = Player.CurrentTile.BallGridPoints[7];
break;
case 45:
ballPoint = Player.CurrentTile.BallGridPoints[8];
break;
case 90:
ballPoint = Player.CurrentTile.BallGridPoints[5];
break;
case 135:
ballPoint = Player.CurrentTile.BallGridPoints[2];
break;
case 180:
ballPoint = Player.CurrentTile.BallGridPoints[1];
break;
case 225:
ballPoint = Player.CurrentTile.BallGridPoints[0];
break;
case 270:
ballPoint = Player.CurrentTile.BallGridPoints[3];
break;
case 315:
ballPoint = Player.CurrentTile.BallGridPoints[6];
break;
}
MatchManager.Ball.SetBallPosition(ballPoint);
}
/* #endregion */
/* ======================================================================================== */
/* #region ==== D R A W / C L E A R R O T A T I O N T A R G E T O V E R L A Y ======== */
/* #region ---- Draw Rotation Target Overlay ---------------------------------------------- */
public void DrawRotationTarget(MatchPlayer Player, PitchTile targetTile)
{
if (Player.PlayerMode == PlayerMode.Rotate)
{
ClearRotationTarget(Player);
List <PitchTile> neighbourTiles = Player.CurrentTile.NeighbourTiles;
foreach (var tile in neighbourTiles)
{
if (tile == targetTile)
{
tile.ActivateRotateTargetOverlay(true);
int direction = Player.GetRotationIndicator(targetTile.transform);
int apCost = Player.CalcRotationApCost(direction);
MatchManager.Hud.UpdateAccAPCost(apCost);
break;
}
}
}
}
public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
{
if (Player1 == null || Player2 == null)
{
throw new NullReferenceException("Player 1 or Player 2 properties wasn't set.");
}
MatchPlayer player = (MatchPlayer)value;
switch (player)
{
case MatchPlayer.First:
return(Player1.Name);
case MatchPlayer.Second:
return(Player2.Name);
default:
return("None");
}
}
/* #endregion */
/* #region ---- PitchTile MouseEnter / MouseExit ------------------------------------------ */
public void OnPitchTileMouseEnter(PitchTile tile)
{
MatchPlayer activePlayer = MatchManager.MatchPlayerManager.CurrentActivePlayer;
switch (activePlayer.PlayerMode)
{
case PlayerMode.Idle:
break;
case PlayerMode.Move:
MatchManager.PitchGrid.PathFinding.DrawPathLine.Draw(tile);
break;
case PlayerMode.Rotate:
MatchManager.PitchGrid.RotateGrid.DrawRotationTarget(activePlayer, tile);
break;
case PlayerMode.Pass:
break;
}
}
public async Task <Table> GetTournamentTable(int tournamentId)
{
var players = await _playersRepository.GetTournamentPlayers(tournamentId);
var matches = await _matchesRepository.GetTournamentCurrentOrFinishedMatches(tournamentId);
List <TableRow> rows = new List <TableRow>();
foreach (Player player in players)
{
TableRowBuilder rowbuilder = new TableRowBuilder(player);
foreach (Match match in matches)
{
MatchPlayer matchPlayer = null;
MatchPlayer matchOpponent = null;
if (player.Id == match.Host.PlayerId)
{
matchPlayer = match.Host;
matchOpponent = match.Guest;
}
else if (player.Id == match.Guest.PlayerId)
{
matchPlayer = match.Guest;
matchOpponent = match.Host;
}
if (matchPlayer != null)
{
rowbuilder.AddMatch(matchPlayer.GoalsScored, matchOpponent.GoalsScored);
}
}
TableRow row = rowbuilder.Build();
rows.Add(row);
}
return(new Table(rows));
}
public MatchPlayer CreateMatchPlayer(Player pl, Match match, int playerNumber)
{
MatchPlayer mp = new MatchPlayer();
mp.Player = pl;
mp.Match = match;
mp.PlayerNumber = playerNumber;
mp.Goals = 0;
mp.Penalties = 0;
mp.Points = 0;
mp.Frees = 0;
mp.YellowCards = 0;
mp.BlackCards = 0;
mp.RedCards = 0;
mp.IsSentOff = false;
mp.IsSubbed = false;
context.MatchPlayers.Add(mp);
context.SaveChanges();
return mp;
}
/* #endregion */
/* #region ---- PitchTile Mouse Left click ------------------------------------------------ */
public void OnPitchTileLeftClick(PitchTile targetTile)
{
MatchPlayer activePlayer = MatchManager.MatchPlayerManager.CurrentActivePlayer;
switch (activePlayer.PlayerMode)
{
case PlayerMode.Idle:
break;
case PlayerMode.Move:
MatchManager.MatchPlayerManager.CurrentActivePlayer.PlayerActions.CheckForMovement(targetTile);
break;
case PlayerMode.Rotate:
OnMouseLeftClickRotate(activePlayer, targetTile);
break;
case PlayerMode.Pass:
OnMouseLeftClickPass(activePlayer, targetTile);
break;
}
}
/// <summary>
/// Plots the server dynamics
/// </summary>
/// <returns>The plot.</returns>
private PlotModel PlotByServerDynamics()
{
var players = new MatchPlayer[] { MatchPlayer.First, MatchPlayer.Second };
if (Dynamics.ByServer.Count != players.Length)
{
return(null);
}
var plot = this.CreateDynamicsPlot();
foreach (var player in players)
{
var name = player == MatchPlayer.First ?
this.match.FirstPlayer.Name : this.match.SecondPlayer.Name;
var color = player == MatchPlayer.First ?
this.style.FirstPlayerColor : this.style.SecondPlayerColor;
var series = new LineSeries()
{
Title = name,
Color = color,
Smooth = true,
};
plot.Series.Add(series);
// Join the dynamics with the corresponding rally index.
var points = this.match.FinishedRallies
.Select((r, i) => r.Server == player ? i + 1 : -1)
.Where(i => i != -1)
.Zip(this.Dynamics.ByServer[player], (n, d) => new DataPoint(n, d));
foreach (var point in points)
{
series.Points.Add(point);
}
}
return(plot);
}
public void CompleteMatchPlayer(MatchPlayer matchPlayer)
{
var heroId = matchPlayer.hero_id;
var hero = _db.Heroes.First(h => h.id == heroId);
matchPlayer.hero = hero;
var accountId = matchPlayer.account_id;
var playerInfo = _db.Players.FirstOrDefault(p => p.account_id == matchPlayer.account_id);
matchPlayer.playerInformation = playerInfo;
var matchPlayerItemRepository = new MatchPlayerItemRepository(matchPlayer, _db);
var items = matchPlayerItemRepository.GetItems();
matchPlayer.matchPlayerItems = items;
var matchPlayerAbilities = _db.MatchPlayerAbilities.Where(mpa => mpa.account_id == matchPlayer.account_id &&
mpa.match_id == matchPlayer.match_id &&
mpa.player_slot == matchPlayer.player_slot);
matchPlayer.ability_upgrades = matchPlayerAbilities.ToList();
}
public async Task JoinDefaultAsync()
{
SocketUser sender = Context.User;
UserData user = new UserData(sender.Id);
bool rs = await user.Fetch();
if (rs)
{
Console.WriteLine(user.err);
return;
}
MatchPlayer player = new MatchPlayer(user);
bool didJoin = MatchMaker.Join(player);
if (!didJoin)
{
return;
}
await ReplyAsync($"{sender.Username} has joined the queue! Position {player.joinSlot}");
}
/* #endregion */
/* #region ---- Accumulated AP-Cost (Calculation before action) --------------------------- */
public void UpdateAccAPCost(int accCost)
{
MatchPlayer activePlayer = MatchManager.MatchPlayerManager.CurrentActivePlayer;
DrawPathLine drawPathLine = MatchManager.PitchGrid.PathFinding.DrawPathLine;
if (drawPathLine.AccCostReset)
{
apCost.text = "";
}
else
{
if (activePlayer.PlayerMode == PlayerMode.Move)
{
//TODO: Why accCost != 0 when calculating AP-Cost in Move Mode???
if (accCost <= activePlayer.CurrentActionPoints && accCost != 0)
{
apCost.text = $"-{accCost.ToString()}";
}
else
{
apCost.text = "Not enough AP!";
}
}
else
{
if (accCost <= activePlayer.CurrentActionPoints)
{
apCost.text = $"-{accCost.ToString()}";
}
else
{
apCost.text = "Not enough AP!";
}
}
}
}
/* #endregion */
/* ======================================================================================== */
/* #region ==== C H E C K F O R B A L L P O S S I T I O N U P D A T E ================= */
public void CheckForBallPosUpdate()
{
MatchPlayer ballHolder = null;
// Extra Security if a player is set as BallHolder but not set on MatchPlayerManager
if (MatchManager.MatchPlayerManager.CurrentBallHolder is null)
{
ballHolder = GetBallHolder();
if (ballHolder is null)
{
return;
}
else
{
MatchManager.MatchPlayerManager.SetCurrentBallHolder(ballHolder);
}
}
// If MatchManager is holding a CurrentBallHolder
else
{
ballHolder = MatchManager.MatchPlayerManager.CurrentBallHolder;
setBallPositionInPossession(ballHolder);
}
}
internal override void Handle(ClientSession session, JsonSendToRoomIncomingMessage message)
{
if (!session.IsLoggedIn)
{
return;
}
switch (message.RoomType)
{
case "chat":
{
if (session.MultiplayerMatchSession?.Match.Name != message.RoomName)
{
if (PlatformRacing3Server.ChatRoomManager.TryGet(message.RoomName, out ChatRoom chatRoom))
{
chatRoom.HandleData(session, message.Data, message.SendToSelf);
}
}
else
{
session.MultiplayerMatchSession?.Match.HandleData(session, message.Data, message.SendToSelf);
}
}
break;
case "game":
{
MatchPlayer matchPlayer = session.MultiplayerMatchSession?.MatchPlayer;
if (matchPlayer != null && matchPlayer.Match.Name == message.RoomName)
{
matchPlayer.Match.HandleData(session, message.Data, message.SendToSelf);
}
}
break;
}
}
/// <summary>
/// Gets the number of errors of <paramref name="player"/> in rallies
/// of length <paramref name="n"/>.
/// </summary>
/// <param name="player">The player</param>
/// <param name="n">The rally length</param>
/// <returns>The errors of <paramref name="player"/> in rallies of length <paramref name="n"/></returns>
public double ErrorsAtLength(MatchPlayer player, int n)
{
var errors = this.Transitions.ErrorsAtStrokeByPlayer[player];
if (n < 1 || n >= errors.Count)
{
throw new ArgumentOutOfRangeException("Cannot compute errors for stroke " + n);
}
var otherPoints = this.Transitions.PointsAtStrokeByPlayer[player.Other()];
if (n == 0)
{
return(errors[n]);
}
else if (n == errors.Count - 1)
{
return(errors[n] + otherPoints[n - 1] + otherPoints[n] + this.ErrorsAtLength(player, n - 1));
}
else
{
return(errors[n] + otherPoints[n - 1]);
}
}
/// <summary>
/// Gets the number of scores of <paramref name="player"/> in rallies
/// of length <paramref name="n"/>.
/// </summary>
/// <param name="player">The player.</param>
/// <param name="n">The rally length.</param>
/// <returns>The scores of <paramref name="player"/> in rallies of length <paramref name="n"/></returns>
public double ScoresAtLength(MatchPlayer player, int n)
{
var points = this.Transitions.PointsAtStrokeByPlayer[player];
if (n < 0 || n >= points.Count)
{
throw new ArgumentOutOfRangeException("Cannot compute errors for stroke " + n);
}
var otherErrors = this.Transitions.ErrorsAtStrokeByPlayer[player.Other()];
if (n == points.Count - 1)
{
return(points[n] + otherErrors[n] + points[n - 1]);
}
else if (n == points.Count - 2)
{
return(points[n]);
}
else
{
return(points[n] + otherErrors[n + 1]);
}
}
public override bool CountStroke(Stroke stroke, MatchPlayer player, int strokeNumber = -1, string stat = null)
{
return(stroke.Player == player && stroke.Number == 1);
}
public MatchPlayer UpdateMatchPlayer(MatchPlayer pl, int goals, int pens, int pts, int frees, int yellows,
int blacks, int reds, bool sentOff, int minuteOff)
{
MatchPlayer mp = context.MatchPlayers
.Where(p => p == pl)
.FirstOrDefault();
if (mp != null)
{
mp.Goals = goals;
mp.Penalties = pens;
mp.Points = pts;
mp.Frees = frees;
mp.YellowCards = yellows;
mp.BlackCards = blacks;
mp.RedCards = reds;
mp.IsSentOff = sentOff;
mp.MinuteOff = minuteOff;
context.SaveChanges();
return mp;
}
else
{
return null;
}
}
public void LeaveMatch(MatchPlayer player)
{
manager.RequestPlayerLeave(player.CtrlType);
usedControls.Remove(player.CtrlType);
UpdateHelpText();
}
