public PlayerResult Get(int id)
{
var dataCache = new DataCache();
var player = PlayersService.GetInstance().GetPlayer(id, dataCache);
var sports = SportsService.GetInstance().GetSports();
var leagues = LeaguesService.GetInstance().GetLeagues();
var stats = StatsService.GetInstance().GetAllStats(playerID: id, dataCache: dataCache);
var statTypes = GamesService.GetInstance().GetStatTypes().OrderBy(s => s.GridDisplayOrder);
var playerResult = new PlayerResult()
{
ID = player.ID,
Name = player.Name,
Games = player.Games?.Select(g => new PlayerGameResult()
{
ID = g.ID,
GameDate = g.GameDate,
Team1Score = g.Team1Score,
Team2Score = g.Team2Score
}).ToList(),
Teams = player.Teams?.Select(t =>
{
var league = leagues.First(l => l.ID == t.LeagueID);
var sport = sports.First(s => s.ID == league.SportID);
return(new PlayerTeamResult()
{
ID = t.ID,
Name = t.Name,
LeagueID = t.LeagueID,
Number = t.PlayerNumber,
SportID = league.SportID,
LeagueName = string.Format("{0} - {1} {2} - {3}", sport.Name, league.StartDate.Year, league.Season.ToString(), league.Name)
});
}).OrderBy(t => t.LeagueName).ToList(),
HockeyStats = stats
.Select(s => ConvertObjects.ConvertType(s))
.Where(s => s.Sport == SportsList.Hockey && leagues.Exists(l => l.ID == s.LeagueID))
.OrderBy(s => leagues.First(l => l.ID == s.LeagueID).StartDate)
.ToList(),
BaseballStats = stats
.Select(s => ConvertObjects.ConvertType(s))
.Where(s => s.Sport == SportsList.Baseball && leagues.Exists(l => l.ID == s.LeagueID))
.OrderBy(s => leagues.First(l => l.ID == s.LeagueID).StartDate)
.ToList(),
BasketballStats = stats
.Select(s => ConvertObjects.ConvertType(s))
.Where(s => s.Sport == SportsList.Basketball && leagues.Exists(l => l.ID == s.LeagueID))
.OrderBy(s => leagues.First(l => l.ID == s.LeagueID).StartDate)
.ToList(),
HockeyStatTypes = statTypes.Select(s => ConvertObjects.ConvertType(s)).Where(st => st.Sport == SportsList.Hockey).ToList(),
BaseballStatTypes = statTypes.Select(s => ConvertObjects.ConvertType(s)).Where(st => st.Sport == SportsList.Baseball).ToList(),
BasketballStatTypes = statTypes.Select(s => ConvertObjects.ConvertType(s)).Where(st => st.Sport == SportsList.Basketball).ToList(),
};
UpdateStatRow(playerResult.HockeyStats, player, leagues);
UpdateStatRow(playerResult.BaseballStats, player, leagues);
UpdateStatRow(playerResult.BasketballStats, player, leagues);
return(playerResult);
}
static void Main(string[] args)
{
Console.Title = "YGCore GameServer";
Console.WriteLine("Authors: Jenose\n"
+ "Authorized representative: netgame.in.th\n\n"
+ "-------------------------------------------\n");
Stopwatch sw = Stopwatch.StartNew();
Opcode.Init();
Configuration.GetInstance();
Data.LoadAll();
StatsService.GetInstance();
ClientManager.GetInstance();
LSClient.GetInstance();
foreach (var channel in Configuration.GetInstance().Channels)
{
NetworkFactory.NewInstance(channel.Port);
}
sw.Stop();
Thread.Sleep(100);
Console.WriteLine("-------------------------------------------");
Console.WriteLine(" Server start in {0}", (sw.ElapsedMilliseconds / 1000.0).ToString("0.00s"));
Console.WriteLine("-------------------------------------------");
Process.GetCurrentProcess().WaitForExit();
}
public NextBatterResult SaveNewGameState([FromBody] BaseballGameStateResult gameState)
{
var dataCache = new DataCache();
if (gameState.GameStat != null)
{
var originalState = BaseballService.GetInstance().GetExistingGameState(gameID: gameState.GameID, leagueID: gameState.LeagueID, dataCache: dataCache);
GamesService.GetInstance().AddStat(ConvertObjects.ConvertType(gameState.GameStat), originalState);
int rbis = 0;
foreach (var player in gameState.RunnersScored)
{
rbis++;
GamesService.GetInstance().AddStat(ConvertObjects.ConvertType(new StatRequest()
{
GameID = gameState.GameID,
PlayerID = player.ID,
StatTypeID = (int)CalculatedStatTypes.Runs,
TeamID = gameState.GameStat.TeamID,
Value = 1,
GroupID = gameState.GameStat.GroupID,
}));
}
if (rbis > 0)
{
GamesService.GetInstance().AddStat(ConvertObjects.ConvertType(new StatRequest()
{
GameID = gameState.GameID,
PlayerID = gameState.GameStat.PlayerID,
StatTypeID = (int)CalculatedStatTypes.RBI,
TeamID = gameState.GameStat.TeamID,
Value = rbis,
GroupID = gameState.GameStat.GroupID,
}), originalState);
}
}
bool manualAdjustment = gameState.GameStat == null;
var result = BaseballService.GetInstance().SaveNewGameState(ConvertObjects.ConvertType(gameState), manualAdjustment, dataCache: dataCache);
if (gameState.GameStat != null)
{
//Create new at bat group for player
StatsService.GetInstance().CreateNewStatGroup((int)SportsList.Baseball, gameState.GameID, gameState.GameStat.PlayerID, gameState.GameStat.TeamID);
}
return(ConvertObjects.ConvertType(result));
}
public BaseballGameStateResult AddStat([FromBody] StatRequest statRequest)
{
var dataCache = new DataCache();
var gameStat = ConvertObjects.ConvertType(statRequest);
AtBatStates gameStates = null;
if (statRequest.IsBaseball)
{
gameStates = BaseballService.GetInstance().GetGameStates(gameStat, statRequest.IsLatestGroup, dataCache);
}
NextBatterResult nextBatter = null;
bool dataSaved = false;
if (gameStates == null || (!gameStates.NewState.PotentialAdjustment && !gameStates.NewState.InningChanged))
{
dataSaved = true;
GamesService.GetInstance().AddStat(gameStat, gameStates?.OriginalState);
if (statRequest.IsBaseball && gameStates.NewState.ChangeState)
{
nextBatter = ConvertObjects.ConvertType(BaseballService.GetInstance().SaveNewGameState(gameStates.NewState, false, dataCache: dataCache));
//Create new at bat group for player
StatsService.GetInstance().CreateNewStatGroup((int)SportsList.Baseball, gameStat.GameID, gameStat.PlayerID, gameStat.TeamID);
}
}
if (statRequest.IsBaseball)
{
var gameStateResult = ConvertObjects.ConvertType(gameStates.NewState);
gameStateResult.GameStat = statRequest;
gameStateResult.NextBatter = nextBatter;
gameStateResult.DataSaved = dataSaved;
gameStateResult.IsStatsPage = true;
return(gameStateResult);
}
else
{
return(new BaseballGameStateResult()
{
DataSaved = true
});
}
}
private TeamResult GetTeamResult(int teamID, int leagueID)
{
var dataCache = new DataCache();
var team = TeamsService.GetInstance().GetTeam(teamID, leagueID, dataCache: dataCache);
var teams = TeamsService.GetInstance().GetTeams(leagueID: team.LeagueID, showAll: true, dataCache: dataCache);
var players = PlayersService.GetInstance().GetPlayers(dataCache: dataCache);
var playerStats = StatsService.GetInstance().GetAllStats(teamID, team.SportID, leagueID, dataCache: dataCache);
var statTypes = GamesService.GetInstance().GetStatTypes(team.SportID).OrderBy(s => s.GridDisplayOrder);
var teamResult = new TeamResult()
{
ID = team.ID,
Name = team.Name,
Games = team.Games.Select(g => new TeamGameResult()
{
ID = g.ID,
GameDate = g.GameDate,
OtherTeamName = g.Team1ID == team.ID ? teams.First(t => t.ID == g.Team2ID).Name : teams.First(t => t.ID == g.Team1ID).Name,
DidWin = DidWin(g.Team1ID == team.ID, g.Team1Score, g.Team2Score),
HighScore = Math.Max(g.Team1Score, g.Team2Score),
LowScore = Math.Min(g.Team1Score, g.Team2Score),
}).ToList(),
Teams = teams.Select(t => new TeamsResult()
{
ID = t.ID,
Name = t.Name
}).ToList(),
AvailablePlayers = players.Where(p => !team.Players.Exists(tp => tp.ID == p.ID)).Select(p => new PlayersResult()
{
ID = p.ID,
Name = p.Name,
}).ToList(),
TeamPlayerStats = playerStats.Select(s => ConvertObjects.ConvertType(s)).ToList(),
StatTypes = statTypes.Select(s => ConvertObjects.ConvertType(s)).ToList(),
};
return(teamResult);
}
private StatsResult GetStatTypes(int sportID, int?playerID, int gameID, int teamID, int?groupID, int leagueID)
{
var dataCache = new DataCache();
var statTypes = GamesService.GetInstance().GetStatTypes(sportID, dataCache: dataCache);
var playerStats = StatsService.GetInstance().GetStats(sportID, gameID, playerID, teamID, leagueID, dataCache: dataCache);
var game = GamesService.GetInstance().GetGame(gameID, dataCache: dataCache);
int?statGroupID = null;
if (groupID.HasValue)
{
statGroupID = groupID.Value;
}
else
{
statGroupID = StatsService.GetInstance().GetStatGroup(sportID, gameID, playerID, teamID)?.GroupID;
}
var statGroups = StatsService.GetInstance().GetStatGroups(sportID, gameID, playerID);
var states = StatsService.GetInstance().GetStates(sportID);
var statTypesResult = statTypes
.Where(st => !st.IsCalculated)
.Select(t => new StatTypesResult()
{
ID = t.ID,
Name = t.Name,
DisplayName = t.DisplayName,
DefaultShow = t.DefaultShow,
CurrentValue = playerStats.Stats
.Where(ps => ps.StatType?.ID == t.ID && IsValidStatWithGroup(ps.StatType, statGroupID, ps.GroupID))
.Sum(ps => ps.Value),
GridDisplayOrder = t.GridDisplayOrder,
SelectionDisplayOrder = t.SelectionDisplayOrder,
AutoGenerated = t.AutoGenerated
})
.OrderBy(s => s.SelectionDisplayOrder);
var statGroupsResult = statGroups.Select(s => new StatGroupResult()
{
GroupID = s.GroupID
}).ToList();
int i = 1;
foreach (var result in statGroupsResult)
{
result.GroupName = "AB " + i++;
}
return(new StatsResult()
{
GroupID = statGroupID,
PlayerID = playerStats.PlayerID,
PlayerNumber = playerStats.PlayerNumber,
PlayerName = playerStats.PlayerName,
StatTypes = statTypesResult.ToList(),
StatGroups = statGroupsResult,
GameResult = ConvertObjects.ConvertType2(game),
LeagueID = game.LeagueID
});
}
public bool NewGroup([FromBody] StatRequest statRequest)
{
return(StatsService.GetInstance().CreateNewStatGroup((int)SportsList.Baseball, statRequest.GameID, statRequest.PlayerID, statRequest.TeamID));
}
