public override int GetHashCode()
{
unchecked
{
return(((MasterGame != null ? MasterGame.GetHashCode() : 0) * 397) ^ Year);
}
}
public MasterGameYear(MasterGame masterGame, int year, decimal percentStandardGame, decimal percentCounterPick, decimal averageDraftPosition)
{
MasterGame = masterGame;
Year = year;
PercentStandardGame = percentStandardGame;
PercentCounterPick = percentCounterPick;
AverageDraftPosition = averageDraftPosition;
}
public DropRequest(Guid dropRequestID, Publisher publisher, LeagueYear leagueYear, MasterGame masterGame, Instant timestamp, bool?successful)
{
DropRequestID = dropRequestID;
Publisher = publisher;
LeagueYear = leagueYear;
MasterGame = masterGame;
Timestamp = timestamp;
Successful = successful;
}
public PickupBid(Guid bidID, Publisher publisher, MasterGame masterGame, uint bidAmount, int priority, Instant timestamp, bool?successful)
{
BidID = bidID;
Publisher = publisher;
MasterGame = masterGame;
BidAmount = bidAmount;
Priority = priority;
Timestamp = timestamp;
Successful = successful;
}
public IReadOnlyList <ClaimError> GameIsEligible(MasterGame masterGame)
{
List <ClaimError> claimErrors = new List <ClaimError>();
bool remakeEligible = masterGame.EligibilitySettings.EligibilityLevel.Level <= EligibilityLevel.Level;
if (!remakeEligible)
{
claimErrors.Add(new ClaimError("That game is not eligible under this league 'remake level' settings.", true));
}
bool earlyAccessEligible = (!masterGame.EligibilitySettings.EarlyAccess || EarlyAccess);
if (!earlyAccessEligible)
{
claimErrors.Add(new ClaimError("That game is not eligible under this league's early access settings.", true));
}
bool yearlyInstallmentEligible = (!masterGame.EligibilitySettings.YearlyInstallment || YearlyInstallment);
if (!yearlyInstallmentEligible)
{
claimErrors.Add(new ClaimError("That game is not eligible under this league's yearly installment settings.", true));
}
bool freeToPlayEligible = (!masterGame.EligibilitySettings.FreeToPlay || FreeToPlay);
if (!freeToPlayEligible)
{
claimErrors.Add(new ClaimError("That game is not eligible under this league's free to play settings.", true));
}
bool releasedInternationallyEligible = (!masterGame.EligibilitySettings.ReleasedInternationally || ReleasedInternationally);
if (!releasedInternationallyEligible)
{
claimErrors.Add(new ClaimError("That game is not eligible under this league's international release settings.", true));
}
bool expansionEligible = (!masterGame.EligibilitySettings.ExpansionPack || ExpansionPack);
if (!expansionEligible)
{
claimErrors.Add(new ClaimError("That game is not eligible under this league's expansion pack settings.", true));
}
bool unannouncedEligible = (!masterGame.EligibilitySettings.UnannouncedGame || UnannouncedGame);
if (!unannouncedEligible)
{
claimErrors.Add(new ClaimError("That game is not eligible under this league's unannounced game settings.", true));
}
return(claimErrors);
}
public bool?GetOverriddenEligibility(MasterGame masterGame)
{
bool found = _eligibilityOverridesDictionary.TryGetValue(masterGame, out var eligibilityOverride);
if (!found)
{
return(null);
}
return(eligibilityOverride.Eligible);
}
public bool GameIsEligible(MasterGame masterGame)
{
bool found = _eligibilityOverridesDictionary.TryGetValue(masterGame, out var eligibilityOverride);
if (found)
{
return(eligibilityOverride.Eligible);
}
var claimErrors = Options.LeagueTags.GameIsEligible(masterGame);
return(!claimErrors.Any());
}
public MasterGameChangeRequest(Guid requestID, FantasyCriticUser user, Instant requestTimestamp, string requestNote,
MasterGame masterGame, int?openCriticID, bool answered, Instant?responseTimestamp, string responseNote, bool hidden)
{
RequestID = requestID;
User = user;
RequestTimestamp = requestTimestamp;
RequestNote = requestNote;
MasterGame = masterGame;
OpenCriticID = openCriticID;
Answered = answered;
ResponseTimestamp = responseTimestamp;
ResponseNote = responseNote;
Hidden = hidden;
}
public decimal?CalculateFantasyPoints(ScoringSystem scoringSystem, bool counterPick, IClock clock, bool mustBeReleased)
{
if (!WillRelease())
{
return(0m);
}
if (mustBeReleased && !MasterGame.IsReleased(clock.GetCurrentInstant()))
{
return(null);
}
if (MasterGame.CriticScore.HasValue)
{
return(scoringSystem.GetPointsForScore(MasterGame.CriticScore.Value, counterPick));
}
return(null);
}
public MasterGameYear(MasterGame masterGame, int year, double percentStandardGame, double percentCounterPick, double eligiblePercentStandardGame,
double eligiblePercentCounterPick, int numberOfBids, int totalBidAmount, double bidPercentile, double?averageDraftPosition, double?averageBidAmount,
double hypeFactor, double dateAdjustedHypeFactor, double linearRegressionHypeFactor)
{
MasterGame = masterGame;
Year = year;
PercentStandardGame = percentStandardGame;
PercentCounterPick = percentCounterPick;
EligiblePercentStandardGame = eligiblePercentStandardGame;
EligiblePercentCounterPick = eligiblePercentCounterPick;
NumberOfBids = numberOfBids;
TotalBidAmount = totalBidAmount;
BidPercentile = bidPercentile;
AverageDraftPosition = averageDraftPosition;
AverageWinningBid = averageBidAmount;
HypeFactor = hypeFactor;
DateAdjustedHypeFactor = dateAdjustedHypeFactor;
LinearRegressionHypeFactor = linearRegressionHypeFactor;
}
public static IReadOnlyList <ClaimError> GameIsEligible(this IEnumerable <LeagueTagStatus> leagueTags, MasterGame masterGame)
{
var bannedTags = leagueTags.Where(x => x.Status == TagStatus.Banned).Select(x => x.Tag);
var requiredTags = leagueTags.Where(x => x.Status == TagStatus.Required).Select(x => x.Tag);
var bannedTagsIntersection = masterGame.Tags.Intersect(bannedTags);
var missingRequiredTags = requiredTags.Except(masterGame.Tags);
var bannedClaimErrors = bannedTagsIntersection.Select(x => new ClaimError($"That game is not eligible because the {x.ReadableName} tag has been banned.", true));
var requiredClaimErrors = missingRequiredTags.Select(x => new ClaimError($"That game is not eligible because it does not have the required {x.ReadableName} tag.", true));
var allErrors = bannedClaimErrors.Concat(requiredClaimErrors).ToList();
return(allErrors);
}
public MasterGameYear(MasterGame masterGame, int year)
{
MasterGame = masterGame;
Year = year;
}
public Maybe <PublisherGame> GetPublisherGame(MasterGame masterGame)
{
return(PublisherGames.SingleOrDefault(x => x.MasterGame.HasValue && x.MasterGame.Value.MasterGame.MasterGameID == masterGame.MasterGameID));
}
public EligibilityOverride(MasterGame masterGame, bool eligible)
{
MasterGame = masterGame;
Eligible = eligible;
}
public QueuedGame(Publisher publisher, MasterGame masterGame, int rank)
{
Publisher = publisher;
MasterGame = masterGame;
Rank = rank;
}
