private static void Init()
{
RuleBook.defaultValues = new byte[RuleCatalog.ruleCount];
for (int i = 0; i < RuleCatalog.ruleCount; i++)
{
RuleBook.defaultValues[i] = (byte)RuleCatalog.GetRuleDef(i).defaultChoiceIndex;
}
}
// Token: 0x0600106B RID: 4203 RVA: 0x00048280 File Offset: 0x00046480
private void SetVotesFromRuleBookForSinglePlayer()
{
for (int i = 0; i < this.votes.Length; i++)
{
RuleDef ruleDef = RuleCatalog.GetRuleDef(i);
this.votes[i].choiceValue = this.GetDefaultChoice(ruleDef).localIndex;
}
base.SetDirtyBit(2U);
}
// Token: 0x06001970 RID: 6512 RVA: 0x00079A38 File Offset: 0x00077C38
static RuleBook()
{
RuleCatalog.availability.CallWhenAvailable(delegate
{
RuleBook.defaultValues = new byte[RuleCatalog.ruleCount];
for (int i = 0; i < RuleCatalog.ruleCount; i++)
{
RuleBook.defaultValues[i] = (byte)RuleCatalog.GetRuleDef(i).defaultChoiceIndex;
}
});
}
// Token: 0x0600189F RID: 6303 RVA: 0x00069FD0 File Offset: 0x000681D0
public DifficultyIndex FindDifficulty()
{
for (int i = 0; i < this.ruleValues.Length; i++)
{
RuleChoiceDef ruleChoiceDef = RuleCatalog.GetRuleDef(i).choices[(int)this.ruleValues[i]];
if (ruleChoiceDef.difficultyIndex != DifficultyIndex.Invalid)
{
return(ruleChoiceDef.difficultyIndex);
}
}
return(DifficultyIndex.Invalid);
}
// Token: 0x06001034 RID: 4148 RVA: 0x00047468 File Offset: 0x00045668
private void TestRuleValues()
{
RuleBook ruleBook = new RuleBook();
ruleBook.Copy(this.networkRuleBookComponent.ruleBook);
RuleDef ruleDef = RuleCatalog.GetRuleDef(UnityEngine.Random.Range(0, RuleCatalog.ruleCount));
RuleChoiceDef choiceDef = ruleDef.choices[UnityEngine.Random.Range(0, ruleDef.choices.Count)];
ruleBook.ApplyChoice(choiceDef);
this.networkRuleBookComponent.SetRuleBook(ruleBook);
base.Invoke("TestRuleValues", 0.5f);
}
// Token: 0x060018A2 RID: 6306 RVA: 0x0006A0CC File Offset: 0x000682CC
public EquipmentMask GenerateEquipmentMask()
{
EquipmentMask result = default(EquipmentMask);
for (int i = 0; i < this.ruleValues.Length; i++)
{
RuleChoiceDef ruleChoiceDef = RuleCatalog.GetRuleDef(i).choices[(int)this.ruleValues[i]];
if (ruleChoiceDef.equipmentIndex != EquipmentIndex.None)
{
result.AddEquipment(ruleChoiceDef.equipmentIndex);
}
}
return(result);
}
// Token: 0x060018A1 RID: 6305 RVA: 0x0006A074 File Offset: 0x00068274
public ItemMask GenerateItemMask()
{
ItemMask result = default(ItemMask);
for (int i = 0; i < this.ruleValues.Length; i++)
{
RuleChoiceDef ruleChoiceDef = RuleCatalog.GetRuleDef(i).choices[(int)this.ruleValues[i]];
if (ruleChoiceDef.itemIndex != ItemIndex.None)
{
result.AddItem(ruleChoiceDef.itemIndex);
}
}
return(result);
}
// Token: 0x060018A0 RID: 6304 RVA: 0x0006A01C File Offset: 0x0006821C
public ArtifactMask GenerateArtifactMask()
{
ArtifactMask result = default(ArtifactMask);
for (int i = 0; i < this.ruleValues.Length; i++)
{
RuleChoiceDef ruleChoiceDef = RuleCatalog.GetRuleDef(i).choices[(int)this.ruleValues[i]];
if (ruleChoiceDef.artifactIndex != ArtifactIndex.None)
{
result.AddArtifact(ruleChoiceDef.artifactIndex);
}
}
return(result);
}
public void EnforceValidRuleChoices()
{
if (!NetworkServer.active)
{
Debug.LogWarning("[Server] function 'System.Void RoR2.PreGameController::EnforceValidRuleChoices()' called on client");
return;
}
this.ruleBookBuffer.Copy(this.readOnlyRuleBook);
for (int i = 0; i < RuleCatalog.ruleCount; i++)
{
if (!this.resolvedRuleChoiceMask[this.ruleBookBuffer.GetRuleChoice(i)])
{
RuleDef ruleDef = RuleCatalog.GetRuleDef(i);
RuleChoiceDef choiceDef = ruleDef.choices[ruleDef.defaultChoiceIndex];
int num = 0;
int j = 0;
int count = ruleDef.choices.Count;
while (j < count)
{
if (this.resolvedRuleChoiceMask[ruleDef.choices[j]])
{
num++;
}
j++;
}
if (this.resolvedRuleChoiceMask[choiceDef] || num == 0)
{
this.ruleBookBuffer.ApplyChoice(choiceDef);
}
else
{
int k = 0;
int count2 = ruleDef.choices.Count;
while (k < count2)
{
if (this.resolvedRuleChoiceMask[ruleDef.choices[k]])
{
this.ruleBookBuffer.ApplyChoice(ruleDef.choices[k]);
break;
}
k++;
}
}
}
}
this.networkRuleBookComponent.SetRuleBook(this.ruleBookBuffer);
this.UpdatePersistentRulebook();
}
// Token: 0x060018A3 RID: 6307 RVA: 0x0006A124 File Offset: 0x00068324
public static void ToXml(XElement element, RuleBook src)
{
byte[] array = src.ruleValues;
RuleBook.< > c__DisplayClass28_0 CS$ < > 8__locals1;
CS$ < > 8__locals1.choiceNamesBuffer = new string[array.Length];
CS$ < > 8__locals1.choiceNamesCount = 0;
for (int i = 0; i < array.Length; i++)
{
RuleDef ruleDef = RuleCatalog.GetRuleDef(i);
byte b = array[i];
if ((ulong)b < (ulong)((long)ruleDef.choices.Count))
{
RuleBook.< ToXml > g__AddChoice | 28_0 (ruleDef.choices[(int)b].globalName, ref CS$ < > 8__locals1);
}
}
element.Value = string.Join(" ", CS$ < > 8__locals1.choiceNamesBuffer, 0, CS$ < > 8__locals1.choiceNamesCount);
}
private static void CCRulesDump(ConCommandArgs args)
{
List <string> list = new List <string>();
List <string> list2 = new List <string>();
for (int i = 0; i < RuleCatalog.ruleCount; i++)
{
RuleDef ruleDef = RuleCatalog.GetRuleDef(i);
for (int j = 0; j < ruleDef.choices.Count; j++)
{
RuleChoiceDef ruleChoiceDef = ruleDef.choices[j];
string item = string.Format(" {{localChoiceIndex={0} globalChoiceIndex={1} localName={2}}}", ruleChoiceDef.localIndex, ruleChoiceDef.globalIndex, ruleChoiceDef.localName);
list2.Add(item);
}
string str = string.Join("\n", list2);
list2.Clear();
string str2 = string.Format("[{0}] {1} defaultChoiceIndex={2}\n", i, ruleDef.globalName, ruleDef.defaultChoiceIndex);
list.Add(str2 + str);
}
Debug.Log(string.Join("\n", list));
}
// Token: 0x06001898 RID: 6296 RVA: 0x00069E9E File Offset: 0x0006809E
public RuleChoiceDef GetRuleChoice(int ruleIndex)
{
return(RuleCatalog.GetRuleDef(ruleIndex).choices[(int)this.ruleValues[ruleIndex]]);
}
// Token: 0x06001065 RID: 4197 RVA: 0x00047FA8 File Offset: 0x000461A8
private static void UpdateGameVotes()
{
int i = 0;
int choiceCount = RuleCatalog.choiceCount;
while (i < choiceCount)
{
PreGameRuleVoteController.votesForEachChoice[i] = 0;
i++;
}
int j = 0;
int ruleCount = RuleCatalog.ruleCount;
while (j < ruleCount)
{
RuleDef ruleDef = RuleCatalog.GetRuleDef(j);
int count = ruleDef.choices.Count;
foreach (PreGameRuleVoteController preGameRuleVoteController in PreGameRuleVoteController.instancesList)
{
PreGameRuleVoteController.Vote vote = preGameRuleVoteController.votes[j];
if (vote.hasVoted && vote.choiceValue < count)
{
RuleChoiceDef ruleChoiceDef = ruleDef.choices[vote.choiceValue];
PreGameRuleVoteController.votesForEachChoice[ruleChoiceDef.globalIndex]++;
}
}
j++;
}
if (NetworkServer.active)
{
int k = 0;
int ruleCount2 = RuleCatalog.ruleCount;
while (k < ruleCount2)
{
RuleDef ruleDef2 = RuleCatalog.GetRuleDef(k);
int count2 = ruleDef2.choices.Count;
PreGameController.instance.readOnlyRuleBook.GetRuleChoiceIndex(ruleDef2);
int ruleChoiceIndex = -1;
int num = 0;
bool flag = false;
for (int l = 0; l < count2; l++)
{
RuleChoiceDef ruleChoiceDef2 = ruleDef2.choices[l];
int num2 = PreGameRuleVoteController.votesForEachChoice[ruleChoiceDef2.globalIndex];
if (num2 == num)
{
flag = true;
}
else if (num2 > num)
{
ruleChoiceIndex = ruleChoiceDef2.globalIndex;
num = num2;
flag = false;
}
}
if (num == 0)
{
ruleChoiceIndex = ruleDef2.choices[ruleDef2.defaultChoiceIndex].globalIndex;
}
if (!flag || num == 0)
{
PreGameController.instance.ApplyChoice(ruleChoiceIndex);
}
k++;
}
}
Action action = PreGameRuleVoteController.onVotesUpdated;
if (action == null)
{
return;
}
action();
}
