public void Play()
{
homeLineup = HomeTeam.ChooseLineupHungarian();
awayLineup = AwayTeam.ChooseLineupHungarian();
Stats = new MatchFSM(HomeLineup, AwayLineup).Start();
hasPlayed = true;
}
private void NextInning()
{
if (HomeScore > AwayScore && Inning.Num >= 9)
{
EndGame();
return;
}
else if (AwayScore > HomeScore && Inning.Num >= 9 && Inning.Half == Inning.Side.Bottom)
{
EndGame();
return;
}
else
{
Inning++;
}
Outs = 0;
ResetCount();
ClearBases();
if (Inning.Half == Inning.Side.Bottom)
{
HomeTeam.NextInning();
}
else
{
AwayTeam.NextInning();
}
}
private AwayTeam ParseAwayTeamNode(XmlNode awayTeamNode)
{
try
{
AwayTeam awayTeam = new AwayTeam();
if (awayTeamNode.ChildNodes != null)
{
foreach (XmlNode xmlNode in awayTeamNode.ChildNodes)
{
switch (xmlNode.Name)
{
case Tags.AwayTeamID:
awayTeam.awayTeamIdField = GenericFunctions.ConvertStringToUInt(xmlNode.InnerText);
break;
case Tags.AwayTeamName:
awayTeam.awayTeamNameField = xmlNode.InnerText;
break;
}
}
}
return(awayTeam);
}
catch (Exception ex)
{
throw ex;
}
}
public void Clean()
{
HomeTeam = HomeTeam.Trim();
AwayTeam = AwayTeam.Trim();
var timeSplit = KickOffTimeString.Split(':');
KickOffHours = int.Parse(timeSplit[0]);
KickOffMintutes = int.Parse(timeSplit[1]);
var scoreSplit = Score.Replace(" - ", "-").Split('-');
HomeTeamScore = int.Parse(scoreSplit[0]);
AwayTeamScore = int.Parse(scoreSplit[1]);
if (League == "Barclays Prem")
{
LeagueEnum = Model.LeagueEnum.Premier;
}
else if (League == "Sky Bet Ch'ship")
{
LeagueEnum = Model.LeagueEnum.Championship;
}
else if (League == "Sky Bet League 1")
{
LeagueEnum = Model.LeagueEnum.League1;
}
else
{
LeagueEnum = Model.LeagueEnum.League2;
}
}
internal IEnumerable <EventOfMatch> GetFullEventsOfMatch(IEnumerable <EventOfMatch> eventsList)
{
int homeScore = 0;
int awayScore = 0;
foreach (var eventOfMatch in eventsList ?? Enumerable.Empty <EventOfMatch>())
{
eventOfMatch.HomeTeamScore = 0;
eventOfMatch.AwayTeamScore = 0;
eventOfMatch.HomeTeam = eventOfMatch?.EventTeam == HomeTeam ? HomeTeam : string.Empty;
eventOfMatch.AwayTeam = eventOfMatch?.EventTeam == AwayTeam ? AwayTeam : string.Empty;
eventOfMatch.HomeMainPlayer = GetEventPlayer(eventOfMatch?.EventTeam.ToUpper().Trim() == HomeTeam.ToUpper().Trim() ? eventOfMatch?.MainPlayerOfMatchID : null);
eventOfMatch.HomeSecondPlayer = GetEventPlayer(eventOfMatch?.EventTeam.ToUpper().Trim() == HomeTeam.ToUpper().Trim() ? eventOfMatch?.SecondPlayerOfMatchID : null);
eventOfMatch.AwayMainPlayer = GetEventPlayer(eventOfMatch?.EventTeam.ToUpper().Trim() == AwayTeam.ToUpper().Trim() ? eventOfMatch?.MainPlayerOfMatchID : null);
eventOfMatch.AwaySecondPlayer = GetEventPlayer(eventOfMatch?.EventTeam.ToUpper().Trim() == AwayTeam.ToUpper().Trim() ? eventOfMatch?.SecondPlayerOfMatchID : null);
eventOfMatch.HomeTeamVisible = eventOfMatch.HomeTeamVisible = !string.IsNullOrEmpty(eventOfMatch.HomeTeam);
eventOfMatch.AwayTeamVisible = eventOfMatch.AwayTeamVisible = !string.IsNullOrEmpty(eventOfMatch.AwayTeam);
if (IsGoal(eventOfMatch))
{
if (eventOfMatch.EventTeam.ToUpper().Trim() == HomeTeam.ToUpper().Trim())
{
homeScore += 1;
}
if (eventOfMatch.EventTeam.ToUpper().Trim() == AwayTeam.ToUpper().Trim())
{
awayScore += 1;
}
}
eventOfMatch.HomeTeamScore = homeScore;
eventOfMatch.AwayTeamScore = awayScore;
if (eventOfMatch.EventName == "GOAL")
{
int eventIndex = eventsList.ToList().IndexOf(eventOfMatch);
if (eventIndex + 1 < eventsList.Count())
{
EventOfMatch nextEvent = eventsList.ToList()[eventIndex + 1];
if (nextEvent.EventName == "ASSIST")
{
if (eventOfMatch.EventTeam.ToUpper().Trim() == HomeTeam.ToUpper().Trim())
{
eventOfMatch.HomeSecondPlayer = GetEventPlayer(nextEvent?.EventTeam.ToUpper().Trim() == HomeTeam.ToUpper().Trim() ? nextEvent?.MainPlayerOfMatchID : null);
}
if (eventOfMatch.EventTeam.ToUpper().Trim() == AwayTeam.ToUpper().Trim())
{
eventOfMatch.AwaySecondPlayer = GetEventPlayer(nextEvent?.EventTeam.ToUpper().Trim() == AwayTeam.ToUpper().Trim() ? nextEvent?.MainPlayerOfMatchID : null);
}
}
}
}
}
return(eventsList);
}
public string OpponentOf(
string teamCode)
{
if (AwayTeam.Equals(teamCode))
{
return(HomeTeam);
}
return(AwayTeam);
}
public void ChangeSides()
{
if (Stats.IsFinished)
{
return;
}
Stats.ResetScore();
HomeTeam.ChangeSides();
AwayTeam.ChangeSides();
}
internal bool LossFor(string teamCode)
{
if (HomeTeam.Equals(teamCode) && AwayScore > HomeScore)
{
return(true);
}
if (AwayTeam.Equals(teamCode) && HomeScore > AwayScore)
{
return(true);
}
return(false);
}
public override int GetHashCode()
{
unchecked
{
int hashCode = Id.GetHashCode();
hashCode = (hashCode * 397) ^ DateTime.GetHashCode();
hashCode = (hashCode * 397) ^ (Sport != null ? Sport.GetHashCode() : 0);
hashCode = (hashCode * 397) ^ (HomeTeam != null ? HomeTeam.GetHashCode() : 0);
hashCode = (hashCode * 397) ^ (AwayTeam != null ? AwayTeam.GetHashCode() : 0);
hashCode = (hashCode * 397) ^ (Comments != null ? Comments.GetHashCode() : 0);
return(hashCode);
}
}
internal bool Involves(
string teamCode)
{
if (HomeTeam.Equals(teamCode))
{
return(true);
}
if (AwayTeam.Equals(teamCode))
{
return(true);
}
return(false);
}
//public Match(MatchInfo matchInfo)
//{
// Date = matchInfo.Date;
// HomeTeamId = matchInfo.;
// AwayTeamId = awayTeamId;
// TourId = tourId;
// Score = String.Empty;
//}
public MatchDto GetDto()
{
if (HomeTeam == null)
{
throw new ArgumentNullException("HomeTeam cannot be null");
}
if (AwayTeam == null)
{
throw new ArgumentNullException("AwayTeam cannot be null");
}
return(new MatchDto(Date, HomeTeam.GetDto(), AwayTeam.GetDto()));
}
private void Run()
{
if (Inning.Half == Inning.Side.Top)
{
AwayTeam.Run(Inning.Num);
AwayScore++;
}
else
{
HomeTeam.Run(Inning.Num);
HomeScore++;
CheckEndGame();
}
}
public override int GetHashCode()
{
unchecked
{
var hashCode = MatchDay;
hashCode = (hashCode * 397) ^ DateTime.GetHashCode();
hashCode = (hashCode * 397) ^ HomeTeamScore;
hashCode = (hashCode * 397) ^ AwayTeamScore;
hashCode = (hashCode * 397) ^ (HomeTeam != null ? HomeTeam.GetHashCode() : 0);
hashCode = (hashCode * 397) ^ (AwayTeam != null ? AwayTeam.GetHashCode() : 0);
hashCode = (hashCode * 397) ^ (Season != null ? Season.GetHashCode() : 0);
return(hashCode);
}
}
public override int GetHashCode()
{
unchecked
{
int hash = 23;
hash = hash * 37 + PlayDay.GetHashCode();
hash = hash * 37 + GameId.GetHashCode();
hash = hash * 37 + SeasonId.GetHashCode();
hash = hash * 37 + Date.GetHashCode();
hash = hash * 37 + (HomeTeam != null ? HomeTeam.GetHashCode() : 0);
hash = hash * 37 + (AwayTeam != null ? AwayTeam.GetHashCode() : 0);
hash = hash * 37 + (Arena != null ? Arena.GetHashCode() : 0);
return(hash);
}
}
private void EndGame()
{
if (HomeTeam.Runs > AwayTeam.Runs)
{
HomeTeam.Win();
AwayTeam.Lose();
}
else
{
AwayTeam.Win();
HomeTeam.Lose();
}
GameOver = true;
Result = AwayTeam.DisplayName + " " + AwayScore + " - " + HomeScore + " " + HomeTeam.DisplayName + '\n';
GameFeed.Text = "";
}
public void ApproveServe()
{
if (!HomeTeam.IsWaitingForServe() && !AwayTeam.IsWaitingForServe())
{
return;
}
List <Player> players = GetAllPlayers();
var playerWaiting = players.FirstOrDefault(p => p.ServeState == ServeStateEnum.AwaitingApproval);
if (playerWaiting == null)
{
return;
}
playerWaiting.ServeState = ServeStateEnum.Approved;
}
public void Initialize()
{
HomeTeam.NewGame();
AwayTeam.NewGame();
AwayTeam.Box.Insert(0, 0);
GameFeed = new TextBox();
GameFeed.Text = "";
Bases = new bool[3];
for (int i = 0; i < 3; i++)
{
Bases[i] = false;
}
Initialized = true;
}
public void StartGame_Add_NotEmpty()
{
var scoreBoard = new ScoreBoard();
var GameStarter = new GameStarter(scoreBoard);
var homeTeam = new HomeTeam()
{
Name = "Barcelona"
};
var awayTeam = new AwayTeam()
{
Name = "Madrid"
};
GameStarter.StartGame(homeTeam, awayTeam);
Assert.NotEmpty(scoreBoard.Games);
}
private AwayTeam ParseAwayTeamNode(XmlNode awayTeamNode)
{
AwayTeam awayTeam = new AwayTeam();
foreach (XmlNode xmlNodeAwayTeam in awayTeamNode.ChildNodes)
{
switch (xmlNodeAwayTeam.Name)
{
case Tags.AwayTeamID:
awayTeam.awayTeamIdField = GenericFunctions.ConvertStringToUInt(xmlNodeAwayTeam.InnerText);
break;
case Tags.AwayTeamName:
awayTeam.awayTeamNameField = xmlNodeAwayTeam.InnerText;
break;
}
}
return awayTeam;
}
void ReleaseDesignerOutlets()
{
if (AwayScore != null)
{
AwayScore.Dispose();
AwayScore = null;
}
if (AwayTeam != null)
{
AwayTeam.Dispose();
AwayTeam = null;
}
if (Date != null)
{
Date.Dispose();
Date = null;
}
if (HomeScore != null)
{
HomeScore.Dispose();
HomeScore = null;
}
if (HomeTeam != null)
{
HomeTeam.Dispose();
HomeTeam = null;
}
if (Indicator != null)
{
Indicator.Dispose();
Indicator = null;
}
if (Time != null)
{
Time.Dispose();
Time = null;
}
}
private AwayTeam ParseAwayTeamNode(XmlNode awayTeamNode)
{
AwayTeam awayTeam = new AwayTeam();
foreach (XmlNode xmlNodeAwayTeam in awayTeamNode.ChildNodes)
{
switch (xmlNodeAwayTeam.Name)
{
case Tags.AwayTeamID:
awayTeam.awayTeamIdField = GenericFunctions.ConvertStringToUInt(xmlNodeAwayTeam.InnerText);
break;
case Tags.AwayTeamName:
awayTeam.awayTeamNameField = xmlNodeAwayTeam.InnerText;
break;
}
}
return(awayTeam);
}
public bool MarkPicked(Pick pick, Mlb5Context db)
{
Picked = true;
PickId = pick.Id;
if (AwayTeam.Code == pick.TeamCode)
{
AwayTeam.MarkPicked();
}
else
{
HomeTeam.MarkPicked();
}
if (Status == GameStatus.Completed && pick.Status == PickStatus.New)
{
var pickToUpdate = db.Picks.Single(x => x.Id == pick.Id);
// if pick won then mark run and calculate runs
if (AwayTeam.Runs > HomeTeam.Runs && AwayTeam.Picked)
{
pickToUpdate.Status = PickStatus.Won;
pickToUpdate.Runs = AwayTeam.Runs - HomeTeam.Runs;
}
else if (HomeTeam.Runs > AwayTeam.Runs && HomeTeam.Picked)
{
pickToUpdate.Status = PickStatus.Won;
pickToUpdate.Runs = HomeTeam.Runs - AwayTeam.Runs;
}
else
{
pickToUpdate.Status = PickStatus.Lost;
}
// add homers and strikeouts
var myPick = GetPickedTeam();
pickToUpdate.Homeruns = myPick.Homeruns;
pickToUpdate.Strikeouts = myPick.Strikeouts;
db.SaveChanges();
return(true);
}
return(false);
}
public void Hit(int hitSuccess)
{
if (hitSuccess < 9)
{
int hitType = random.Next(101);
if (hitType < 65)
{
AdvanceBases(1);
UpdateFeed(1);
}
else if (hitType < 85)
{
AdvanceBases(2);
UpdateFeed(2);
}
else if (hitType < 90)
{
AdvanceBases(3);
UpdateFeed(3);
}
else
{
AdvanceBases(4);
UpdateFeed(4);
}
if (Inning.Half == Inning.Side.Top)
{
AwayTeam.Hit();
}
else
{
HomeTeam.Hit();
}
}
else
{
Out(hitSuccess);
}
ResetCount();
}
private void LoadMatches()
{
foreach (Match match in matches)
{
if (match.home_team_country == country || match.away_team_country == country)
{
Match specificMatch = new Match();
HomeTeam ht = new HomeTeam();
AwayTeam at = new AwayTeam();
ht.country = match.home_team.country;
ht.code = match.home_team.code;
at.country = match.away_team.country;
at.code = match.away_team.code;
specificMatch.venue = match.venue;
specificMatch.attendance = match.attendance;
ht.goals = match.home_team.goals;
at.goals = match.away_team.goals;
specificMatch.home_team = ht;
specificMatch.away_team = at;
chosenMatches.Add(specificMatch);
}
}
}
protected override void ExecuteImpl(object args)
{
this.attackArgs = this.ConvertArgs <AttackArgs>(args);
var projectileEnd = AwayTeam.GridToGlobal(attackArgs.TargetedLocation);
var projectileStart = AwayTeam.GridToGlobal(attackArgs.Actor.GridPosition);
var actor = attackArgs.Actor;
var weapon = attackArgs.Actor.EquippedItem as WeaponProperties;
bool hits = false;
var squareHit = this.GetSquareHit(attackArgs.Actor, attackArgs.TargetedLocation);
if (attackArgs.Map.TryGetActor(attackArgs.TargetedLocation, out hitActor))
{
var hitChance = GetChanceToHitActor(attackArgs.Actor, hitActor, weapon);
var hitRoll = UnityEngine.Random.Range(0.0f, 1.0f);
if (hitRoll <= hitChance)
{
hits = true;
this.damage = this.GetDamageOnHit(attackArgs.Actor, hitActor, weapon);
}
}
this.shootLaser(projectileStart, projectileEnd, hits, this.damage);
}
public MatchProtocolPage(Match match, League league)
{
var matchEventService = new MatchEventService();
_teamService = new TeamService();
_personService = new PersonService();
_matchService = new MatchService();
var str = league.Name.ToString();
Match = match;
AwayTeam = _teamService.FindById(match.AwayTeamId);
HomeTeam = _teamService.FindById(match.HomeTeamId);
HomeTeamPlayers =
HomeTeam.PlayerIds.Select(playerId => _personService.FindPlayerById(playerId)).ToList();
AwayTeamPlayers =
AwayTeam.PlayerIds.Select(playerId => _personService.FindPlayerById(playerId)).ToList();
//this needs to be before adding the list to WPF.. DHOOO!
InitializeComponent();
LeagueNameHeader.Text = str;
HomeTeamName.Text = HomeTeam.ToString();
AwayTeamName.Text = AwayTeam.ToString();
var homeTeamEvents = match.MatchEventIds
.Select(matchEventService.FindById)
.Where(mEvent => match.HomeTeamSquadId.Contains(mEvent.PlayerId));
var awayTeamEvents = match.MatchEventIds
.Select(matchEventService.FindById)
.Where(mEvent => match.AwayTeamSquadId.Contains(mEvent.PlayerId));
var homeMatchEvents = homeTeamEvents as IList <MatchEvent> ?? homeTeamEvents.ToList();
var awayMatchEvents = awayTeamEvents as IList <MatchEvent> ?? awayTeamEvents.ToList();
var homeGoal = homeMatchEvents.Where(e => e.GetType() == MatchEvents.Goal);
var awayGoal = awayMatchEvents.Where(e => e.GetType() == MatchEvents.Goal);
_matchEventsAway = new ObservableCollection <MatchEvent>(awayMatchEvents);
_matchEventsHome = new ObservableCollection <MatchEvent>(homeMatchEvents);
AwayTeamMatchEvents.ItemsSource = _matchEventsAway;
HomeTeamMatchEvents.ItemsSource = _matchEventsHome;
HomeTeamGoals.Text = homeGoal.ToList().Count.ToString();
AwayTeamGoals.Text = awayGoal.ToList().Count.ToString();
DatePicker.DisplayDate = match.MatchDate;
if (match.AwayTeamSquadId != null)
{
_awayTeamSquadIds = match.AwayTeamSquadId.Select(_personService.FindPlayerById).ToList();
AwayTeamList.ItemsSource = new ObservableCollection <Player>(_awayTeamSquadIds);
}
if (match.HomeTeamSquadId != null)
{
_homeTeamSquadIds = match.HomeTeamSquadId.Select(_personService.FindPlayerById).ToList();
HomeTeamList.ItemsSource = new ObservableCollection <Player>(_homeTeamSquadIds);
}
_matchEventsTemp = new List <MatchEvent>(Match.MatchEventIds.Select(new MatchEventService().FindById));
}
protected override void DisposeManagedResources()
{
HomeTeam.Dispose();
AwayTeam.Dispose();
base.DisposeManagedResources();
}
private ObservableCollection <EventOfMatch> SortEventOfMatch(ObservableCollection <EventOfMatch> eventOfMatches)
{
ObservableCollection <EventOfMatch> sortEvents = new ObservableCollection <EventOfMatch>();
foreach (EventOfMatch eventOfMatch in eventOfMatches)
{
eventOfMatch.HomeTeamVisible = eventOfMatch.EventTeam?.Trim().ToUpper() == HomeTeam?.Trim().ToUpper();
eventOfMatch.AwayTeamVisible = eventOfMatch.EventTeam?.Trim().ToUpper() == AwayTeam?.Trim().ToUpper();
EventOfMatch findEvent = eventOfMatches.FirstOrDefault(x => x.EventOfMatchID == eventOfMatch.SecondPlayerOfMatchID);
if (findEvent != null)
{
eventOfMatch.AdditionalText = findEvent.EventName;
}
if (eventOfMatch.EventName != "BIGCHANCE")
{
sortEvents.Add(eventOfMatch);
}
switch (eventOfMatch.EventName)
{
case "GOAL":
case "OWNGOAL":
case "PENALTYSCORED":
eventOfMatch.EventBackgroundColor = Application.Current.Resources["LineUpGreen"];
break;
case "YELLOW":
eventOfMatch.EventBackgroundColor = Application.Current.Resources["LineUpYellow"];
break;
case "RED":
eventOfMatch.EventBackgroundColor = Application.Current.Resources["LineUpRed"];
break;
default:
eventOfMatch.EventBackgroundColor = Application.Current.Resources["LightBackgroundColor"];
break;
}
}
return(new ObservableCollection <EventOfMatch>(sortEvents.Reverse()));
}
internal bool IsServing()
{
return(HomeTeam.IsServing() || AwayTeam.IsServing());
}
private AwayTeam ParseAwayTeamNode(XmlNode xmlNode)
{
try
{
AwayTeam awayTeam = new AwayTeam();
if (xmlNode.ChildNodes != null)
{
foreach (XmlNode awayTeamNode in xmlNode.ChildNodes)
{
switch (awayTeamNode.Name)
{
case Tags.AwayTeamID:
awayTeam.awayTeamIdField = GenericFunctions.ConvertStringToUInt(awayTeamNode.InnerText);
break;
case Tags.AwayTeamName:
awayTeam.awayTeamNameField = awayTeamNode.InnerText;
break;
case Tags.Dress:
awayTeam.dressField = awayTeamNode.InnerText;
break;
case Tags.Formation:
awayTeam.formationField = awayTeamNode.InnerText;
break;
case Tags.AwayGoals:
awayTeam.awayGoalsField = GenericFunctions.ConvertStringToByte(awayTeamNode.InnerText);
break;
case Tags.TacticType:
awayTeam.tacticTypeField = (TacticType)Convert.ToInt32(awayTeamNode.InnerText);
break;
case Tags.TacticSkill:
awayTeam.tacticSkillField = (TacticSkill)Convert.ToInt32(awayTeamNode.InnerText);
break;
case Tags.RatingMidfield:
awayTeam.ratingMidfieldField = (SectorRating)Convert.ToInt32(awayTeamNode.InnerText);
break;
case Tags.RatingRightDef:
awayTeam.ratingRightDefField = (SectorRating)Convert.ToInt32(awayTeamNode.InnerText);
break;
case Tags.RatingMidDef:
awayTeam.ratingMidDefField = (SectorRating)Convert.ToInt32(awayTeamNode.InnerText);
break;
case Tags.RatingLeftDef:
awayTeam.ratingLeftDefField = (SectorRating)Convert.ToInt32(awayTeamNode.InnerText);
break;
case Tags.RatingRightAtt:
awayTeam.ratingRightAttField = (SectorRating)Convert.ToInt32(awayTeamNode.InnerText);
break;
case Tags.RatingMidAtt:
awayTeam.ratingMidAttField = (SectorRating)Convert.ToInt32(awayTeamNode.InnerText);
break;
case Tags.RatingLeftAtt:
awayTeam.ratingLeftAttField = (SectorRating)Convert.ToInt32(awayTeamNode.InnerText);
break;
case Tags.TeamAttitude:
awayTeam.teamAttitudeField = (TeamAttitude)Convert.ToInt32(awayTeamNode.InnerText);
break;
}
}
}
return(awayTeam);
}
catch (Exception ex)
{
throw ex;
}
}
public bool IsTeamInRotation()
{
return(HomeTeam.InRotation() || AwayTeam.InRotation());
}
