public bool IsEgligible(RunAggregateData runData)
{
// If no clan is defined, it doesn't matter which role it shall play.
if (Clan == CLAN_ANY)
{
return(true);
}
// Otherwise, try to find both clan ids ...
int primary = 0; int secondary = 0;
if (!clanKeys.TryGetValue(runData.GetMainClassID(), out primary))
{
AdvancedRunHistory.Log("Can't find primary clan ID " + runData.GetMainClassID(), LogLevel.Warning);
}
if (!clanKeys.TryGetValue(runData.GetSubClassID(), out secondary))
{
AdvancedRunHistory.Log("Can't find secondary clan ID " + runData.GetSubClassID(), LogLevel.Warning);
}
// ... and check whether they are the desired ones.
switch (Role)
{
case AS_ANY:
return(primary == Clan || secondary == Clan);
case AS_PRIMARY:
return(primary == Clan);
case AS_SECONDARY:
return(secondary == Clan);
default:
return(false);
}
}
public bool IsEgligible(RunAggregateData runData)
{
RunType runType = runData.GetRunTypeEnum();
switch (SelectedRunType)
{
case TYPE_STANDARD:
return(runType == RunType.Class && runData.GetSpChallengeId().IsNullOrEmpty());
case TYPE_EXPERT:
return(runType == RunType.Class && !runData.GetSpChallengeId().IsNullOrEmpty());
case TYPE_DAILY:
return(runType == RunType.Daily);
case TYPE_HELLRUSH:
return(runType == RunType.Matchmaker);
case TYPE_CUSTOM:
return(runType == RunType.Custom);
case TYPE_SHARE:
return(runType == RunType.Share);
default:
return(true);
}
}
public bool IsEgligible(RunAggregateData runData)
{
switch (Outcome)
{
case OUTCOME_VICTORY:
return(runData.GetVictory());
case OUTCOME_DEFEAT:
return(!runData.GetVictory());
default:
return(true);
}
}
protected override int GetCheckedValue(RunAggregateData runData)
{
return(runData.GetAscensionLevel());
}
public bool IsEgligible(RunAggregateData runData)
{
int check = GetCheckedValue(runData);
return(check >= minValue && check <= maxValue);
}
/// <summary> /// Extract the value from the run data that shall be checked against the specified range. /// </summary> /// <param name="runData">The run data</param> /// <returns>The value that shall be checked against the specified range.</returns> protected abstract int GetCheckedValue(RunAggregateData runData);
public static bool Prefix(ref RunAggregateDatas __result,
ref string database,
ref string userId,
ref string altUserId,
ref int page,
ref int numPerPage,
ref HadesNetworkCaller.SortFieldName sortFieldName,
ref HadesNetworkCaller.SortDirection sortDirection)
{
// Get the filter manager. I don't think there's a way to pass this as an argument, so we'll have to
// set it manually.
FilterManager manager = AdvancedRunHistory.filterManager;
// This is just vanilla code.
altUserId = altUserId ?? string.Empty;
int environment = (int)AppManager.EnvironmentConfig.Environment;
string commandText = string.Format("SELECT {0} FROM '{1}' WHERE ({2} = '{3}' OR {4} = '{5}') AND {6} = {7} ORDER BY {8} {9}", "runId", "runHistoryTable", "userId", userId, "userId", altUserId, "env", environment, sortFieldName, sortDirection);
List <string> runIds = new List <string>();
if (!SqlUtil.ExecuteReader(database, commandText, ErrorFile.RunMinDbEntry, 3, delegate(SqliteDataReader reader)
{
while (reader.Read())
{
runIds.Add(reader.GetString(0));
}
return(true);
}, exactlyOneRead: false))
{
__result = null;
return(false);
}
// The actual patch; start by assuming we don't want to filter.
List <string> filteredRunIds = runIds;
// Only filter runs if the manager is active-
if (manager.Active)
{
// Make a new list of runIds.
filteredRunIds = new List <String>();
// Go through all runIds in the original list.
foreach (string runId in runIds)
{
// Try to read the run from the DB.
RunMinDbEntry runMinDbEntry = RunMinDbEntry.ReadFromDb(database, runId);
if (runMinDbEntry != null)
{
// Create a RunAggregateData. Assume it's eglibile.
RunAggregateData runAggregateData = runMinDbEntry.minimalRunData.CreateRunAggregateData();
bool isEgligible = true;
// Go through all filters and make the run uneglibile if it doesn't pass.
foreach (IRunDataFilter filter in manager.Filters)
{
if (!filter.IsEgligible(runAggregateData))
{
isEgligible = false;
break;
}
}
// The run has passed all filters, add it to the filtered list.
if (isEgligible)
{
filteredRunIds.Add(runId);
}
}
}
}
// Back to vanilla code, but changing runIds --> filteredRunIds.
List <string> list = new List <string>();
List <RunAggregateData> list2 = new List <RunAggregateData>();
for (int i = (page - 1) * numPerPage; i < filteredRunIds.Count; i++)
{
if (list2.Count >= numPerPage)
{
break;
}
RunMinDbEntry runMinDbEntry = RunMinDbEntry.ReadFromDb(database, filteredRunIds[i]);
if (runMinDbEntry != null)
{
RunAggregateData runAggregateData = runMinDbEntry.minimalRunData.CreateRunAggregateData();
string item = JsonUtility.ToJson(runAggregateData);
list.Add(item);
list2.Add(runAggregateData);
}
}
int pageCount = filteredRunIds.Count / numPerPage + Math.Min(filteredRunIds.Count % numPerPage, 1);
RunAggregateDatas runAggregateDatas = new RunAggregateDatas(list.ToArray(), pageCount, page);
runAggregateDatas.SetRuns(list2.ToArray());
__result = runAggregateDatas;
return(false);
}
