public static SurvivorIndex GetCurrentCharacter()
{
var bodyIndex = BodyCatalog.FindBodyIndex(Main.LocalPlayerBody);
var survivorIndex = SurvivorCatalog.GetSurvivorIndexFromBodyIndex(bodyIndex);
return(survivorIndex);
}
public static void ConvertBodyNamesToBodyIndices()
{
foreach (var entry in characterNames_to_teamName)
{
List <BodyIndex> bodyIndices = new List <BodyIndex>();
foreach (var bodyName in entry.Key)
{
bodyIndices.Add(BodyCatalog.FindBodyIndex(bodyName));
}
bodyIndices_to_teamName.Add(bodyIndices.ToArray(), entry.Value);
}
var index = 0;
foreach (var a in bodyIndices_to_teamName)
{
var text = $"{index} : ";
foreach (var b in a.Key)
{
text += $"{b}, ";
}
text += $"{a.Value}";
Debug.Log(text);
}
Debug.Log($"Team Count: {bodyIndices_to_teamName.Count}");
}
private void RebuildLocal_Il(ILContext il)
{
ILCursor c = new ILCursor(il);
var label = default(ILLabel);
c.GotoNext(MoveType.Before,
x => x.MatchStloc(7),
x => x.MatchLdloc(2),
x => x.MatchLdcI4(-1),
x => x.MatchBeq(out label)
);
c.GotoLabel(label);
c.Emit(OpCodes.Ldloc_2);
c.Emit(OpCodes.Ldarg_0);
c.EmitDelegate <Action <Int32, CharacterSelectController> >((bodyIndex, controller) =>
{
if (bodyIndex == BodyCatalog.FindBodyIndex(this.RW_body))
{
ApplyMenuEdits(bodyIndex, controller);
}
else
{
RemoveMenuEdits(controller);
}
});
}
void SetCharacter(int num)
{
CharacterBody body = BodyCatalog.GetBodyPrefabBodyComponent(BodyCatalog.FindBodyIndex(CharacterDropdown.options[num].text));
Settings.PlayableCharactersList[Slot] = body.name;
CharacterIcon.sprite = Sprite.Create((Texture2D)body.portraitIcon, new Rect(0.0f, 0.0f, body.portraitIcon.width, body.portraitIcon.height), new Vector2(0.5f, 0.5f), 100.0f);
}
public void RandomizeCharacter()
{
if ((!PreGameController.instance || !PreGameController.instance.IsCharacterSwitchingCurrentlyAllowed() || !characterSelectController) && !eclipseRunScreenController)
{
return;
}
var localUser = ((MPEventSystem)EventSystem.current).localUser;
var currentIndex = characterSelectController?.selectedSurvivorIndex ?? (SurvivorIndex)EclipseRun.cvEclipseSurvivorIndex.value;
var canSelectSameCharacter = ConfigHelper.CanSelectSameCharacter.Value;
var survivors = SurvivorCatalog.orderedSurvivorDefs.Where(survivorDef => (canSelectSameCharacter || currentIndex != survivorDef.survivorIndex) && !survivorDef.hidden && SurvivorCatalog.SurvivorIsUnlockedOnThisClient(survivorDef.survivorIndex));
var randomIndex = survivors.ElementAt(UnityEngine.Random.Range(0, survivors.Count())).survivorIndex;
if (characterSelectController)
{
characterSelectController.SelectSurvivor(randomIndex);
characterSelectController.SetSurvivorInfoPanelActive(true);
}
if (eclipseRunScreenController)
{
eclipseRunScreenController.SelectSurvivor(randomIndex);
}
if (RandomCharacterSelectionPlugin.ScrollableLobbyUILoaded)
{
ScrollableLobbyUISelectCharacter(randomIndex);
}
localUser.currentNetworkUser?.CallCmdSetBodyPreference(BodyCatalog.FindBodyIndex(SurvivorCatalog.GetSurvivorDef(randomIndex).bodyPrefab));
}
public static void SetupDictionary()
{
_logger.LogMessage("Setting up!");
//Delimiter credit: https://github.com/KomradeSpectre/AetheriumMod/blob/c6fe6e8a30c3faf5087802ad7e5d88020748a766/Aetherium/Items/AccursedPotion.cs#L349
TeamIndex teamIndex = TeamIndex.None;
foreach (var value in new string[] { cfgNone.Value, cfgNeutral.Value, cfgPlayer.Value, cfgMonster.Value, cfgLunar.Value })
{
_logger.LogMessage($"Adding bodies to TeamIndex: {teamIndex}");
var valueArray = value.Split(',');
if (valueArray.Length > 0)
{
foreach (string valueToTest in valueArray)
{
var bodyIndex = BodyCatalog.FindBodyIndex(valueToTest);
if (bodyIndex == BodyIndex.None)
{
continue;
}
bodyIndex_to_teamIndex.Add(bodyIndex, teamIndex);
_logger.LogMessage(valueToTest);
}
}
teamIndex++;
}
//bodyIndex_to_teamIndex.Add(BodyCatalog.FindBodyIndex("ImpBody"), TeamIndex.Lunar);
//bodyIndex_to_teamIndex.Add(BodyCatalog.FindBodyIndex("ImpBossBody"), TeamIndex.Lunar);
}
private void CreateDoppelganger_Il(ILContext il)
{
ILCursor c = new ILCursor(il);
_ = c.GotoNext(MoveType.After, x => x.MatchCallOrCallvirt <RoR2.DirectorCore>(nameof(DirectorCore.TrySpawnObject)), x => x.MatchPop());
c.Index--;
_ = c.Remove();
_ = c.EmitDelegate <Action <GameObject> >((obj) =>
{
if (obj != null && obj)
{
var master = obj.GetComponent <CharacterMaster>();
if (master != null && master)
{
var loadout = master.loadout;
if (loadout != null)
{
var bodyInd = BodyCatalog.FindBodyIndex(master.bodyPrefab);
if (bodyInd >= 0 && bodyInd == Main.rogueWispBodyIndex)
{
var bodyLoadoutManager = loadout.bodyLoadoutManager;
var skinInd = bodyLoadoutManager.GetSkinIndex(bodyInd);
UInt32 newSkinInd;
try
{
var skin = ~Helpers.WispBitSkin.GetWispSkin(skinInd);
newSkinInd = skin.EncodeToSkinIndex();
} catch
{
Main.LogE("Error inverting skin for wisp clone, please copy the line of 1s and 0s below and send them to me.");
Main.LogE(Convert.ToString(skinInd, 2).PadLeft(32, '0'));
newSkinInd = 0b0000_0000_0000_0000_0000_0000_0000_1000u;
}
bodyLoadoutManager.SetSkinIndex(bodyInd, newSkinInd);
if (master.hasBody)
{
var body = master.GetBody();
body.skinIndex = newSkinInd;
if (body != null && body)
{
var ml = body.modelLocator;
if (ml != null && ml)
{
var model = ml.modelTransform;
if (model != null && model)
{
var skinController = model.GetComponent <Helpers.WispModelBitSkinController>();
skinController?.Apply(Helpers.WispBitSkin.GetWispSkin(newSkinInd));
}
}
}
}
}
}
}
}
});
}
// Token: 0x060028B5 RID: 10421 RVA: 0x000ACD1D File Offset: 0x000AAF1D
public override void OnInstall()
{
base.OnInstall();
this.impBossBodyIndex = BodyCatalog.FindBodyIndex("ImpBossBody");
this.bfgProjectileIndex = ProjectileCatalog.FindProjectileIndex("BeamSphere");
GlobalEventManager.onCharacterDeathGlobal += this.OnCharacterDeath;
}
private static void AddSurvivorAction(List <SurvivorDef> survivorDefinitions)
{
// Set this to true so no more survivors can be added to the list while this is happening, or afterwards
survivorsAlreadyAdded = true;
// Get the count of the new survivors added, and the number of vanilla survivors
var newSurvivorCount = SurvivorDefinitions.Count;
var exisitingSurvivorCount = SurvivorCatalog.idealSurvivorOrder.Length;
// Increase the size of the order array to accomodate the added survivors
Array.Resize(ref SurvivorCatalog.idealSurvivorOrder, exisitingSurvivorCount + newSurvivorCount);
// Increase the max survivor count to ensure there is enough space on the char select bar
SurvivorCatalog.survivorMaxCount += newSurvivorCount;
foreach (var survivor in SurvivorDefinitions)
{
//Check if the current survivor has been registered in bodycatalog. Log if it has not, but still add the survivor
if (BodyCatalog.FindBodyIndex(survivor.bodyPrefab) == -1 || BodyCatalog.GetBodyPrefab(BodyCatalog.FindBodyIndex(survivor.bodyPrefab)) != survivor.bodyPrefab)
{
R2API.Logger.LogWarning($"Survivor: {survivor.displayNameToken} is not properly registered in {nameof(BodyCatalog)}");
}
R2API.Logger.LogInfo($"Survivor: {survivor.displayNameToken} added");
survivorDefinitions.Add(survivor);
// Add that new survivor to the order array so the game knows where to put it in character select
SurvivorCatalog.idealSurvivorOrder[exisitingSurvivorCount++] = (SurvivorIndex)exisitingSurvivorCount;
}
}
public override void SetupLate()
{
base.SetupLate();
BodyIndexLunarGolem = BodyCatalog.FindBodyIndex("LUNARGOLEM");
BodyIndexLunarWisp = BodyCatalog.FindBodyIndex("LUNARWISP");
BodyIndexLunarExploder = BodyCatalog.FindBodyIndex("EXPLODER");
}
private static void CreateCostDefGurrenSummon()
{
costTypeDefGurrenSummon = new CostTypeDef();
costTypeDefGurrenSummon.costStringFormatToken = "COST_LUNARCOIN_FORMAT";
costTypeDefGurrenSummon.isAffordable = delegate(CostTypeDef costTypeDef, CostTypeDef.IsAffordableContext context)
{
CharacterBody characterBody = context.activator.GetComponent <CharacterBody>();
bool result = false;
if (characterBody && characterBody.bodyIndex == BodyCatalog.FindBodyIndex("LagannBody"))
{
var master = characterBody.master;
if (master)
{
var gurrenMinionCache = GurrenMinionCache.GetOrSetGurrenStatusCache(master);
NetworkUser networkUser = Util.LookUpBodyNetworkUser(context.activator.gameObject);
result = (networkUser &&
(ulong)networkUser.lunarCoins >= (ulong)((long)context.cost) &&
!gurrenMinionCache.gurrenMinion);
}
}
return(result);
};
costTypeDefGurrenSummon.payCost = delegate(CostTypeDef costTypeDef, CostTypeDef.PayCostContext context)
{
NetworkUser networkUser = Util.LookUpBodyNetworkUser(context.activator.gameObject);
bool flag = networkUser;
if (flag)
{
networkUser.DeductLunarCoins((uint)context.cost);
}
};
costTypeDefGurrenSummon.colorIndex = ColorCatalog.ColorIndex.LunarCoin;
CostTypeDefs.Add(costTypeDefGurrenSummon);
}
public void CreateTemporaryNetworkUsers()
{
if (!debug)
{
return;
}
GameObject meUser = LocalUserManager.GetFirstLocalUser().currentNetworkUser.gameObject;
List <string> bodyNamesToCopy = new List <string>(DD2LobbySetupComponent.debug_characters);
bodyNamesToCopy.RemoveAt(0);
foreach (string bodyName in bodyNamesToCopy)
{
if (InstanceTracker.GetInstancesList <FakeNetworkUserMarker>().Count == 3)
{
break;
}
var copy = Instantiate(meUser);
var nU = copy.GetComponent <NetworkUser>();
nU.SetBodyPreference(BodyCatalog.FindBodyIndex(bodyName));
nU.id = new NetworkUserId()
{
value = GetNetworkName(bodyName)
};
copy.name = bodyName;
copy.AddComponent <FakeNetworkUserMarker>();
Debug.Log($"Adding fake NetworkUser as {bodyName}");
}
}
/// <summary>
/// Attempts to look up a name in the BodyCatalog, then find the SkillFamily instance used for one of its slots (by slot enum type). Returns null on failure.
/// </summary>
/// <param name="bodyName">The body name to search for. Case sensitive.</param>
/// <param name="slot">The skillslot name to search for.</param>
/// <returns>The resultant SkillFamily if lookup was successful, null otherwise.</returns>
public static SkillFamily FindSkillFamilyFromBody(string bodyName, SkillSlot slot)
{
var targetBodyIndex = BodyCatalog.FindBodyIndex(bodyName);
if (targetBodyIndex == BodyIndex.None)
{
AncientScepterMain._logger.LogError($"FindSkillFamilyFromBody: Couldn't find body with name {bodyName}");
return(null);
}
var allSlots = BodyCatalog.GetBodyPrefabSkillSlots(targetBodyIndex);
var skLoc = BodyCatalog.GetBodyPrefab(targetBodyIndex).GetComponentInChildren <SkillLocator>();
if (!skLoc)
{
AncientScepterMain._logger.LogError($"FindSkillFamilyFromBody: Body with name {bodyName} has no SkillLocator");
return(null);
}
foreach (var skillInstance in BodyCatalog.GetBodyPrefabSkillSlots(targetBodyIndex))
{
var targetSlot = skLoc.FindSkillSlot(skillInstance);
if (targetSlot == slot)
{
return(skillInstance.skillFamily);
}
}
AncientScepterMain._logger.LogError($"FindSkillFamilyFromBody: Body with name {bodyName} has no skill in slot {slot}");
return(null);
}
// Token: 0x06002892 RID: 10386 RVA: 0x000AC8FC File Offset: 0x000AAAFC
public override void OnInstall()
{
base.OnInstall();
this.clayBossBodyIndex = BodyCatalog.FindBodyIndex("ClayBossBody");
this.requiredSceneDef = SceneCatalog.GetSceneDefFromSceneName("goolake");
GlobalEventManager.onCharacterDeathGlobal += this.OnCharacterDeathGlobal;
}
private new void Start()
{
defaultMasterIndex = MasterCatalog.FindAiMasterIndexForBody(BodyCatalog.FindBodyIndex("CommandoBody"));
base.Start();
this.isEnabled = base.run.selectedDifficulty >= DifficultyIndex.Eclipse3 /* is EclipseRun && EclipseRun.cvEclipseLevel.value >= 3*/;
}
private void UpdateGurrenPassive()
{
checkGurrenPassiveStopWatch += Time.fixedDeltaTime;
if (checkGurrenPassiveStopWatch > checkGurrenPassiveInterval)
{
checkGurrenPassiveStopWatch = 0f;
if (this.body)
{
int buffCounts = 0;
var gurrenBodyIndex = BodyCatalog.FindBodyIndex("GurrenBody");
var allies = TeamComponent.GetTeamMembers(TeamIndex.Player);
foreach (var ally in allies)
{
var allyBody = ally.body;
if (allyBody && allyBody != this.body &&
allyBody.bodyIndex == gurrenBodyIndex &&
(Vector3.Distance(allyBody.transform.position, this.body.transform.position) <= Components.GurrenController.passiveDistance))
{
buffCounts++;
}
}
this.body.SetBuffCount(Buffs.kaminaBuff.buffIndex, buffCounts);
}
}
}
private static void SceneDirector_PopulateScene(On.RoR2.SceneDirector.orig_PopulateScene orig, SceneDirector self)
{
if (gurrenInteractSpawnCard && Run.instance.userMasters.Values.Any((x) =>
{
if (x != null && x.bodyPrefab != null)
{
var body = x.bodyPrefab.GetComponent <CharacterBody>();
if (body)
{
var found = body.bodyIndex == BodyCatalog.FindBodyIndex("LagannBody");
if (found)
{
var gurrenMinionCache = GurrenMinionCache.GetOrSetGurrenStatusCache(x);
if (!gurrenMinionCache.gurrenMinion)
{
return(true);
}
}
}
}
return(false);
}))
{
TTGL_SurvivorPlugin.instance.Logger.LogMessage("Added Gurren On Level");
DirectorCore.instance.TrySpawnObject(new DirectorSpawnRequest(gurrenInteractSpawnCard, new DirectorPlacementRule
{
placementMode = DirectorPlacementRule.PlacementMode.Random
}, self.rng));
}
orig(self);
}
private string GetTeamName2(SurvivorIndex firstSurvivorIndex = SurvivorIndex.None)
{
var networkUsers = characterSelectController.GetSortedNetworkUsersList();
List <string> bodyNames = new List <string>();
List <BodyIndex> bodyIndices = new List <BodyIndex>();
if (!debug)
{
if (networkUsers.Count <= 3)
{
return(string.Empty);
}
foreach (var networkUser in networkUsers)
{
bodyIndices.Add(networkUser.NetworkbodyIndexPreference);
bodyNames.Add(BodyCatalog.GetBodyName(networkUser.NetworkbodyIndexPreference));
}
}
else
{
bodyNames = debug_characters.ToList();
foreach (var bodyName in debug_characters)
{
bodyIndices.Add(BodyCatalog.FindBodyIndex(bodyName));
}
}
if (firstSurvivorIndex != SurvivorIndex.None)
{
bodyIndices[0] = SurvivorCatalog.GetBodyIndexFromSurvivorIndex(firstSurvivorIndex);
bodyNames[0] = SurvivorCatalog.GetSurvivorDef(firstSurvivorIndex).bodyPrefab.name;
}
/*
* if (characterNames_to_teamName.TryGetValue(bodyNames.ToArray(), out string output))
* {
* Debug.Log(output);
* }*/
foreach (var name in bodyNames)
{
Debug.Log(name);
}
foreach (var entry in characterNames_to_teamName)
{
var key = entry.Key;
if (
key[0] == bodyNames[0] &&
key[1] == bodyNames[1] &&
key[2] == bodyNames[2] &&
key[3] == bodyNames[3]
)
{
return(entry.Value);
}
}
return(string.Empty);
}
public override void OnInstall()
{
base.OnInstall();
GenericGameEvents.OnTakeDamage += OnTakeDamage;
projectileIndex = ProjectileCatalog.FindProjectileIndex("Sawmerang");
bodyIndex = BodyCatalog.FindBodyIndex("EquipmentDroneBody");
}
// Token: 0x060028A8 RID: 10408 RVA: 0x000ACB64 File Offset: 0x000AAD64
public override void OnInstall()
{
base.OnInstall();
TeleporterInteraction.onTeleporterBeginChargingGlobal += this.OnTeleporterBeginCharging;
TeleporterInteraction.onTeleporterChargedGlobal += this.OnTeleporterCharged;
this.killCount = 0;
this.beetleQueenBodyIndex = BodyCatalog.FindBodyIndex("BeetleQueen2Body");
}
private void RegisterSephiroth()
{
// gather our prefabs
var sephPrefab = Resources.Load <GameObject>("prefabs/characterbodies/commandobody").InstantiateClone("SephBody");
var commandoPrefab = Resources.Load <GameObject>("prefabs/characterbodies/commandobody");
var sephDisplayPrefab = Resources.Load <GameObject>("prefabs/characterdisplays/commandodisplay").InstantiateClone("SephDisplay", false);
// swap the models
RegisterModelSwap(sephPrefab, sephDisplayPrefab);
// Register sephs Skills
RegisterSkills(sephPrefab);
// register in body catalog
var sephBody = sephPrefab.GetComponentInChildren <CharacterBody>();
BodyCatalog.getAdditionalEntries += (list) => list.Add(sephPrefab);
sephBody.baseNameToken = "Sephiroth";
// Register sephs stats
RegisterStats(sephBody);
// character needs pod?
if (sephBody.preferredPodPrefab == null)
{
sephBody.preferredPodPrefab = commandoPrefab.GetComponentInChildren <CharacterBody>().preferredPodPrefab;
}
// register sephs genericcharactermain
var stateMachine = sephBody.GetComponent <EntityStateMachine>();
stateMachine.mainStateType = new EntityStates.SerializableEntityStateType(typeof(EntityStates.Sephiroth.Sephiroth));
// register icon
sephBody.portraitIcon = Assets.SephIcon.texture;
// register survivor info
SurvivorDef item = new SurvivorDef
{
name = "SEPHIROTH_BODY",
bodyPrefab = sephPrefab,
descriptionToken = "Kingdom Hearts, is light...",
displayPrefab = sephDisplayPrefab,
primaryColor = new Color(0.0f, 0.0f, 0.0f),
unlockableName = "Sephiroth",
survivorIndex = SurvivorIndex.Count + 1
};
SurvivorAPI.AddSurvivor(item);
On.RoR2.BodyCatalog.Init += orig =>
{
orig();
var bodyIndex = BodyCatalog.FindBodyIndex("SephBody");
BodyCatalog.GetBodyPrefab(bodyIndex).GetComponent <CharacterBody>().baseNameToken = "Sephiroth";
};
}
private void Class1_OnInstall(orig_OnInstall orig, RoR2.Achievements.BaseServerAchievement self)
{
orig(self);
allowedBodyIndicies = new List <BodyIndex>
{
BodyCatalog.FindBodyIndex("ScavLunar1Body"),
BodyCatalog.FindBodyIndex("ScavLunar2Body"),
BodyCatalog.FindBodyIndex("ScavLunar3Body"),
BodyCatalog.FindBodyIndex("ScavLunar4Body")
};
}
// Find all relevant prefabs within the content pack, per SurvivorDefs.
private static void GetPrefabs() //wack
{
var d = Assets.mainContentPack.survivorDefs;
foreach (SurvivorDef s in d)
{
bodyPrefabs.Add(s.bodyPrefab);
bodyIndexes.Add(BodyCatalog.FindBodyIndex(s.bodyPrefab));
displayPrefabs.Add(s.displayPrefab);
}
}
private ModelSkinController AddDefaultSkin(GameObject def)
{
base.Logger.LogInfo("Adding default skin to " + def);
ModelSkinController component = def.GetComponentInChildren <ModelLocator>().modelTransform.gameObject.AddComponent <ModelSkinController>();
CharacterModel model = def.GetComponentInChildren <ModelLocator>().modelTransform.GetComponentInChildren <CharacterModel>();
LoadoutAPI.SkinDefInfo skinDefInfo = default(LoadoutAPI.SkinDefInfo);
skinDefInfo.BaseSkins = new SkinDef[0];
skinDefInfo.Icon = LoadoutAPI.CreateSkinIcon(Color.black, Color.white, Color.black, Color.white);
skinDefInfo.NameToken = "Default";
skinDefInfo.UnlockableName = "";
skinDefInfo.RootObject = def.GetComponentInChildren <ModelLocator>().modelTransform.gameObject;
skinDefInfo.RendererInfos = model.baseRendererInfos;
skinDefInfo.MeshReplacements = new SkinDef.MeshReplacement[0];
skinDefInfo.GameObjectActivations = new SkinDef.GameObjectActivation[1] {
new SkinDef.GameObjectActivation()
{
gameObject = def, shouldActivate = true
}
};
skinDefInfo.Name = "DEFAULT_" + def.name + "_SKIN";
if (model)
{
skinDefInfo.RendererInfos = model.baseRendererInfos;
for (int i = 0; i < skinDefInfo.RendererInfos.Length; i++)
{
skinDefInfo.RendererInfos[i].defaultMaterial.enableInstancing = true;
skinDefInfo.RendererInfos[i].renderer.material.enableInstancing = true;
skinDefInfo.RendererInfos[i].renderer.sharedMaterial.enableInstancing = true;
}
SkinDef skinDef3 = LoadoutAPI.CreateNewSkinDef(skinDefInfo);
component.skins = new SkinDef[1] {
skinDef3
};
LoadoutAPI.AddSkinToCharacter(def, skinDef3);
SkinDef[] skins = component.skins;
SkinDef[][] newSkins = typeof(BodyCatalog).GetFieldValue <SkinDef[][]>("skins");
newSkins[BodyCatalog.FindBodyIndex(def)] = skins;
typeof(BodyCatalog).SetFieldValue <SkinDef[][]>("skins", newSkins);
}
else
{
base.Logger.LogError("Unable to create new skin for " + def);
}
return(component);
}
// Find all relevant prefabs within the content pack, per SurvivorDefs.
private static void GetContent()
{
var survs = Assets.serialContentPack.survivorDefs;
foreach (SurvivorDef s in survs)
{
bodyPrefabs.Add(s.bodyPrefab);
bodyIndexes.Add(BodyCatalog.FindBodyIndex(s.bodyPrefab));
displayPrefabs.Add(s.displayPrefab);
}
}
private void Rebuild_Il(ILContext il)
{
ILCursor c = new ILCursor(il);
c.GotoNext(MoveType.Before, x => x.MatchCall(typeof(RoR2.BodyCatalog), nameof(RoR2.BodyCatalog.GetBodySkins)));
c.Remove();
c.EmitDelegate <Func <Int32, Boolean> >((index) =>
{
return(index != BodyCatalog.FindBodyIndex(this.RW_body));
});
c.RemoveRange(4);
}
// Token: 0x0600234B RID: 9035 RVA: 0x000A64C8 File Offset: 0x000A46C8
private void LateUpdate()
{
this.image.sprite = this.disabledSprite;
ReadOnlyCollection <NetworkUser> readOnlyLocalPlayersList = NetworkUser.readOnlyLocalPlayersList;
for (int i = 0; i < readOnlyLocalPlayersList.Count; i++)
{
if (readOnlyLocalPlayersList[i].bodyIndexPreference == BodyCatalog.FindBodyIndex(this.characterBodyPrefab))
{
this.image.sprite = this.enabledSprite;
return;
}
}
}
void OnLoad()
{
BodyIndex bodyIndex = BodyCatalog.FindBodyIndex(Settings.PlayableCharactersList[Slot]);
if (bodyIndex != BodyIndex.None)
{
CharacterDropdown.value = DropDownMap[bodyIndex];
}
else
{
SetCharacter(0);
Debug.LogWarning($"Warning! Custom character load could not find index for body of \"{Settings.PlayableCharactersList[Slot]}\", using default @RoR2PVP");
}
}
private bool checkMoonNames(CharacterBody self)
{
bool isMoon = false;
for (int i = 0; i < _moonGuyNames.Length; i++)
{
if (self.bodyIndex == BodyCatalog.FindBodyIndex(_moonGuyNames[i]))
{
isMoon = true;
}
}
return(isMoon);
}
private bool checkScavengerNames(CharacterBody self)
{
bool isScavenger = false;
for (int i = 0; i < _scavGuyNames.Length; i++)
{
if (self.bodyIndex == BodyCatalog.FindBodyIndex(_scavGuyNames[i]))
{
isScavenger = true;
}
}
return(isScavenger);
}