private static void CopyFromHeretic(CharacterMaster characterMaster)
{
foreach (var skillDriver in characterMaster.GetComponents <AISkillDriver>())
{
Destroy(skillDriver);
}
var characterAI = characterMaster.GetComponent <BaseAI>();
List <AISkillDriver> newSkillDrivers = new List <AISkillDriver>();
foreach (var skillDriver in hereticSkillDrivers)
{
var newDriver = characterMaster.gameObject.AddComponent <AISkillDriver>();
newSkillDrivers.Add(newDriver);
newDriver.activationRequiresAimConfirmation = skillDriver.activationRequiresAimConfirmation;
newDriver.activationRequiresAimTargetLoS = skillDriver.activationRequiresAimTargetLoS;
newDriver.activationRequiresTargetLoS = skillDriver.activationRequiresTargetLoS;
newDriver.aimType = skillDriver.aimType;
newDriver.buttonPressType = skillDriver.buttonPressType;
newDriver.customName = skillDriver.customName;
newDriver.driverUpdateTimerOverride = skillDriver.driverUpdateTimerOverride;
newDriver.ignoreNodeGraph = skillDriver.ignoreNodeGraph;
newDriver.maxDistance = skillDriver.maxDistance;
newDriver.maxTargetHealthFraction = skillDriver.maxTargetHealthFraction;
newDriver.maxUserHealthFraction = skillDriver.maxUserHealthFraction;
newDriver.minDistance = skillDriver.minDistance;
newDriver.minTargetHealthFraction = skillDriver.minTargetHealthFraction;
newDriver.minUserHealthFraction = skillDriver.minUserHealthFraction;
newDriver.moveInputScale = skillDriver.moveInputScale;
newDriver.movementType = skillDriver.movementType;
newDriver.moveTargetType = skillDriver.moveTargetType;
//newDriver.name = skillDriver.name;
newDriver.nextHighPriorityOverride = skillDriver.nextHighPriorityOverride;
newDriver.noRepeat = skillDriver.noRepeat;
newDriver.requiredSkill = skillDriver.requiredSkill;
newDriver.requireEquipmentReady = skillDriver.requireEquipmentReady;
newDriver.requireSkillReady = skillDriver.requireSkillReady;
newDriver.resetCurrentEnemyOnNextDriverSelection = skillDriver.resetCurrentEnemyOnNextDriverSelection;
newDriver.selectionRequiresAimTarget = skillDriver.selectionRequiresAimTarget;
newDriver.selectionRequiresOnGround = skillDriver.selectionRequiresOnGround;
newDriver.selectionRequiresTargetLoS = skillDriver.selectionRequiresTargetLoS;
newDriver.shouldFireEquipment = skillDriver.shouldFireEquipment;
newDriver.shouldSprint = skillDriver.shouldSprint;
newDriver.shouldTapButton = skillDriver.shouldTapButton;
newDriver.skillSlot = skillDriver.skillSlot;
}
var array = newSkillDrivers.ToArray();
characterAI.skillDrivers = array;
var esm = characterMaster.GetComponent <EntityStateMachine>();
esm.customName = hereticESM.customName;
esm.initialStateType = hereticESM.initialStateType;
esm.mainStateType = hereticESM.mainStateType;
esm.nextState = hereticESM.nextState;
}
private void CharacterMaster_OnInventoryChanged(On.RoR2.CharacterMaster.orig_OnInventoryChanged orig, CharacterMaster self)
{
orig(self);
MysticsItemsLimitedArmorBehavior component = self.GetComponent <MysticsItemsLimitedArmorBehavior>();
if (!component)
{
component = self.gameObject.AddComponent <MysticsItemsLimitedArmorBehavior>();
}
if (!component.skipItemCheck)
{
int itemCount = self.inventory.GetItemCount(itemDef);
var difference = itemCount - component.oldItemCount;
for (var i = 0; i < difference; i++)
{
if (difference > 0)
{
component.AddStock();
}
else
{
component.RemoveStock();
}
}
component.oldItemCount = itemCount;
}
}
// try and setup our character, if we hit an error we set it to false
//TODO: Find a way to stop it from checking whilst in main menu/lobby menu
private static void GetCharacter()
{
try
{
LocalNetworkUser = null;
foreach (NetworkUser readOnlyInstance in NetworkUser.readOnlyInstancesList)
{
//localplayer == you!
if (readOnlyInstance.isLocalPlayer)
{
LocalNetworkUser = readOnlyInstance;
LocalPlayer = LocalNetworkUser.master;
LocalPlayerInv = LocalPlayer.GetComponent <Inventory>(); //gets player inventory
LocalHealth = LocalPlayer.GetBody().GetComponent <HealthComponent>(); //gets players local health numbers
LocalSkills = LocalPlayer.GetBody().GetComponent <SkillLocator>(); //gets current for local character skills
Localbody = LocalPlayer.GetBody().GetComponent <CharacterBody>(); //gets all stats for local character
LocalMotor = LocalPlayer.GetBody().GetComponent <CharacterMotor>();
if (LocalPlayer.alive)
{
_CharacterCollected = true;
}
else
{
_CharacterCollected = false;
}
}
}
}
catch (Exception e)
{
_CharacterCollected = false;
}
}
private void FixedUpdate()
{
BaseAI baseAIComponent = master.GetComponent <BaseAI>();
if (baseAIComponent)
{
SkillLocator skillComponent = gameObject.GetComponent <SkillLocator>();
if (skillComponent)
{
CharacterBody targetBody = baseAIComponent.currentEnemy.characterBody;
if (targetBody && (!targetBody.characterMotor || !targetBody.characterMotor.isGrounded))
{
skillComponent.primary.SetSkillOverride(body, airSkill, GenericSkill.SkillOverridePriority.Replacement);
}
else
{
skillComponent.primary.UnsetSkillOverride(body, airSkill, GenericSkill.SkillOverridePriority.Replacement);
}
}
retargetTimer -= Time.fixedDeltaTime;
if (retargetTimer <= 0)
{
if (!baseAIComponent.currentEnemy.hasLoS)
{
baseAIComponent.currentEnemy.Reset();
baseAIComponent.ForceAcquireNearestEnemyIfNoCurrentEnemy();
SetCooldown();
}
}
}
}
private void CharacterMaster_TransformBody1(On.RoR2.CharacterMaster.orig_TransformBody orig, CharacterMaster self, string bodyName)
{
if (bodyName == "HereticBody" && self.GetComponent <BaseAI>())
{
var newSummon = new MasterSummon()
{
ignoreTeamMemberLimit = true,
inventoryToCopy = self.inventory,
masterPrefab = Resources.Load <GameObject>("prefabs/charactermasters/hereticmonstermaster"),
position = self.GetBody()?.footPosition ?? Vector3.zero,
useAmbientLevel = true,
teamIndexOverride = self.teamIndex
};
var newMaster = newSummon.Perform();
return;
}
orig(self, bodyName);
var body = self.GetBody();
if (body)
{
TeleportHelper.TeleportBody(body, Vector3.zero);
body.healthComponent?.Suicide();
}
}
public void OnPointerClick(PointerEventData eventData)
{
if (master != null && master.playerCharacterMasterController != null)
{
ItemIcon itemIcon = GetComponent <ItemIcon>();
ItemIndex itemIndex = itemIcon.GetFieldValue <ItemIndex>("itemIndex");
if (ItemCatalog.GetItemDef(itemIndex).tier == ItemTier.NoTier)
{
Debug.LogWarning("Trash cannot be dropped :D");
return;
}
if (NetworkServer.active)
{
ServerStuffDropper.DropItem(master, itemIndex);
InventoryLimits limits = master.GetComponent <InventoryLimits>();
if (!limits)
{
return;
}
limits.Count(master.inventory);
}
else
{
if (ClientScene.readyConnection == null)
{
Debug.LogError("Connection is not ready.");
}
ClientScene.readyConnection.Send(ConversionArtifactMod.msgItemDropType, new ItemDropMessage(itemIndex));
}
}
}
private static void CCSpawnAI(ConCommandArgs args)
{
string prefabString = ArgsHelper.GetValue(args.userArgs, 0);
string eliteString = ArgsHelper.GetValue(args.userArgs, 1);
string teamString = ArgsHelper.GetValue(args.userArgs, 2);
string braindeadString = ArgsHelper.GetValue(args.userArgs, 3);
var character = Character.GetCharacter(prefabString);
if (character == null)
{
Debug.LogFormat("Could not spawn {0}, Try: spawn_ai GolemBody", character.body);
return;
}
var prefab = MasterCatalog.FindMasterPrefab(character.master);
var body = BodyCatalog.FindBodyPrefab(character.body);
var bodyGameObject = Instantiate <GameObject>(prefab, args.sender.master.GetBody().transform.position, Quaternion.identity);
CharacterMaster master = bodyGameObject.GetComponent <CharacterMaster>();
NetworkServer.Spawn(bodyGameObject);
master.SpawnBody(body, args.sender.master.GetBody().transform.position, Quaternion.identity);
EliteIndex eliteIndex = EliteIndex.None;
if (Enum.TryParse <EliteIndex>(eliteString, true, out eliteIndex))
{
if ((int)eliteIndex > (int)EliteIndex.None && (int)eliteIndex < (int)EliteIndex.Count)
{
master.inventory.SetEquipmentIndex(EliteCatalog.GetEliteDef(eliteIndex).eliteEquipmentIndex);
}
}
TeamIndex teamIndex = TeamIndex.Neutral;
if (Enum.TryParse <TeamIndex>(teamString, true, out teamIndex))
{
if ((int)teamIndex >= (int)TeamIndex.None && (int)teamIndex < (int)TeamIndex.Count)
{
master.teamIndex = teamIndex;
}
}
bool braindead;
if (bool.TryParse(braindeadString, out braindead))
{
if (braindead)
{
Destroy(master.GetComponent <BaseAI>());
}
}
Debug.Log("Attempting to spawn " + character.body);
}
private void UserStart(On.RoR2.CharacterMaster.orig_OnBodyStart orig, CharacterMaster self, CharacterBody body)
{
RoR2.TeamManager.instance.SetTeamLevel(TeamIndex.Monster, 1);
RoR2.TeamManager.instance.SetTeamLevel(TeamIndex.Player, 1);
if (self.GetComponent <PlayerCharacterMasterController>() != null)
{
GenerateUserTeam(self);
}
orig(self, body);
}
public static void DiscoverPickup(CharacterMaster master, PickupIndex pickupIndex)
{
if (NetworkServer.active)
{
new SyncDiscoverPickup(
master.GetComponent <NetworkIdentity>().netId,
pickupIndex.value
).Send(NetworkDestination.Clients);
}
}
// Token: 0x06002305 RID: 8965 RVA: 0x000A4F14 File Offset: 0x000A3114
private void LateUpdate()
{
string text = "";
Color color = this.baseColor;
bool flag = true;
bool flag2 = false;
bool flag3 = false;
if (this.body)
{
text = this.body.GetDisplayName();
flag = this.body.healthComponent.alive;
flag2 = (!this.body.outOfCombat || !this.body.outOfDanger);
flag3 = (this.body.healthComponent.combinedHealthFraction < HealthBar.criticallyHurtThreshold);
CharacterMaster master = this.body.master;
if (master)
{
PlayerCharacterMasterController component = master.GetComponent <PlayerCharacterMasterController>();
if (component)
{
GameObject networkUserObject = component.networkUserObject;
if (networkUserObject)
{
NetworkUser component2 = networkUserObject.GetComponent <NetworkUser>();
if (component2)
{
text = component2.userName;
}
}
}
else
{
text = Language.GetString(this.body.baseNameToken);
}
}
}
color = (flag2 ? this.combatColor : this.baseColor);
this.aliveObject.SetActive(flag);
this.deadObject.SetActive(!flag);
if (this.criticallyHurtSpriteRenderer)
{
this.criticallyHurtSpriteRenderer.enabled = (flag3 && flag);
this.criticallyHurtSpriteRenderer.color = HealthBar.GetCriticallyHurtColor();
}
if (this.label)
{
this.label.text = text;
this.label.color = color;
}
SpriteRenderer[] array = this.coloredSprites;
for (int i = 0; i < array.Length; i++)
{
array[i].color = color;
}
}
private void CharacterDied(On.RoR2.CharacterMaster.orig_OnBodyDeath orig, CharacterMaster self)
{
orig(self);
var pcmc = self.GetComponent <PlayerCharacterMasterController>();
// Stop the game from ending.
if (pcmc != null)
{
self.preventGameOver = true;
}
}
private void StageRespawnCharacterPrefix(CharacterMaster characterMaster)
{
if (!modDetails.enabled)
{
return;
}
PlayerCharacterMasterController player = characterMaster.GetComponent <PlayerCharacterMasterController>();
string name = player.networkUser.GetNetworkPlayerName().GetResolvedName();
RestoreCharacterPrefab(name);
}
public static void DropItem(CharacterMaster master, ItemIndex itemIndex)
{
var transform = master.GetBodyObject().transform;
var dropVector = UnityEngine.Random.insideUnitCircle;
PickupDropletController.CreatePickupDroplet(PickupCatalog.FindPickupIndex(itemIndex), transform.position, new Vector3(dropVector.x, 0, dropVector.y) * 5f);
master.inventory.RemoveItem(itemIndex);
DropperChat.ItemDropMessage(master.GetBody().GetUserName(), itemIndex);
var limits = master.GetComponent <InventoryLimits>();
DropperChat.ItemCountMessage(master.GetBody().GetUserName(), limits.amount, limits.limit);
}
private void CharacterMaster_OnInventoryChanged(On.RoR2.CharacterMaster.orig_OnInventoryChanged orig, CharacterMaster self)
{
if (self.inventory != null)
{
var limits = self.GetComponent <InventoryLimits>();
if (limits != null)
{
limits.Count(self.inventory);
}
}
orig(self);
}
private void AddBoostsToBot(CharacterBody sender, StatHookEventArgs args)
{
CharacterMaster master = sender.master;
if (master)
{
BotStatTracker tracker = master.GetComponent <BotStatTracker>();
if (tracker)
{
tracker.ApplyTrackerBoosts(args);
//Chat.AddMessage($"HP After: {sender.maxHealth}");
}
}
}
// Token: 0x06001C7F RID: 7295 RVA: 0x00079B77 File Offset: 0x00077D77
public static PlayerStatsComponent FindBodyStatsComponent(CharacterBody characterBody)
{
if (characterBody == null)
{
return(null);
}
CharacterMaster master = characterBody.master;
if (master == null)
{
return(null);
}
return(master.GetComponent <PlayerStatsComponent>());
}
private void Stage_RespawnCharacter(On.RoR2.Stage.orig_RespawnCharacter orig, Stage self, CharacterMaster characterMaster)
{
orig(self, characterMaster);
if (NetworkServer.active)
{
if (Run.instance && Stage.instance && Run.instance.stageClearCount + 1 <= KeepBuffUntilStage) // Toggle buffs until equal KeepBuff var
{
if (characterMaster?.GetComponent <PlayerCharacterMasterController>())
{
Logger.LogInfo("Player spawned, checking for buff toggle");
ToggleBuff();
}
}
}
}
public static void SendConversionMessage(CharacterMaster master, PickupIndex originalPickupIndex, uint originalPickupQuantity, PickupIndex convertedPickupIndex, uint convertedPickupQuantity)
{
if (NetworkServer.active)
{
if (originalPickupQuantity > 0U && convertedPickupQuantity > 0U)
{
new SyncConversionMessage(
master.GetComponent <NetworkIdentity>().netId,
originalPickupIndex.value,
originalPickupQuantity,
convertedPickupIndex.value,
convertedPickupQuantity
).Send(NetworkDestination.Clients);
}
}
}
private static void CCSpawnAI(ConCommandArgs args)
{
if (args.Count == 0)
{
Log.Message(MagicVars.SPAWNAI_ARGS);
return;
}
string character = Alias.Instance.GetMasterName(args[0]);
if (character == null)
{
Log.Message(MagicVars.SPAWN_ERROR + character);
return;
}
var masterprefab = MasterCatalog.FindMasterPrefab(character);
var body = masterprefab.GetComponent <CharacterMaster>().bodyPrefab;
var bodyGameObject = Instantiate <GameObject>(masterprefab, args.sender.master.GetBody().transform.position, Quaternion.identity);
CharacterMaster master = bodyGameObject.GetComponent <CharacterMaster>();
NetworkServer.Spawn(bodyGameObject);
master.SpawnBody(body, args.sender.master.GetBody().transform.position, Quaternion.identity);
if (args.Count > 1)
{
var eliteIndex = Alias.GetEnumFromPartial <EliteIndex>(args[1]);
master.inventory.SetEquipmentIndex(EliteCatalog.GetEliteDef(eliteIndex).eliteEquipmentIndex);
master.inventory.GiveItem(ItemIndex.BoostHp, Mathf.RoundToInt((GetTierDef(eliteIndex).healthBoostCoefficient - 1) * 10));
master.inventory.GiveItem(ItemIndex.BoostDamage, Mathf.RoundToInt((GetTierDef(eliteIndex).damageBoostCoefficient - 1) * 10));
}
if (args.Count > 2 && Enum.TryParse <TeamIndex>(Alias.GetEnumFromPartial <TeamIndex>(args[2]).ToString(), true, out TeamIndex teamIndex))
{
if ((int)teamIndex >= (int)TeamIndex.None && (int)teamIndex < (int)TeamIndex.Count)
{
master.teamIndex = teamIndex;
}
}
if (args.Count > 3 && bool.TryParse(args[3], out bool braindead) && braindead)
{
Destroy(master.GetComponent <BaseAI>());
}
Log.Message(MagicVars.SPAWN_ATTEMPT + character);
}
public CharacterMaster SummonDrone(CharacterBody attackerBody)
{
var transform = attackerBody.transform;
// Spawn drone above player position
Vector3 position = transform.position + Vector3.up * 3f;
Util.PlaySound("Play_drone_repair", attackerBody.gameObject);
CharacterMaster characterMaster = SummonMaster(
Resources.Load <GameObject>("Prefabs/CharacterMasters/DroneBackupMaster"), position, transform.rotation, attackerBody);
if (characterMaster)
{
MinionOwnership ownership = characterMaster.GetComponent <MinionOwnership>();
int stageCount = SacrificeRemix.GetStageCount();
int minStage = stageCount - 1;
int maxStage = stageCount + 2;
int minBaseStats = stageCount - 1;
int maxBaseStats = stageCount * 2;
int randomItemCount = Random.Range(minStage, maxStage);
int lifeTimerOffset = Random.Range(minStage, maxStage);
// Attach to player
if (ownership)
{
ownership.SetOwner(attackerBody.master);
}
// Random items
if (randomItemCount > 0)
{
characterMaster.inventory.GiveRandomItems(randomItemCount);
}
// Base stats
characterMaster.inventory.GiveItem(ItemIndex.BoostDamage, Random.Range(minBaseStats, maxBaseStats));
characterMaster.inventory.GiveItem(ItemIndex.BoostHp, Random.Range(minBaseStats, maxBaseStats));
// Drone lifetime
characterMaster.gameObject.AddComponent <MasterSuicideOnTimer>().lifeTimer = 30f + lifeTimerOffset;
}
return(characterMaster);
}
// Token: 0x06001C7C RID: 7292 RVA: 0x00079B2A File Offset: 0x00077D2A
public static StatSheet FindBodyStatSheet(CharacterBody characterBody)
{
if (characterBody == null)
{
return(null);
}
CharacterMaster master = characterBody.master;
if (master == null)
{
return(null);
}
PlayerStatsComponent component = master.GetComponent <PlayerStatsComponent>();
if (component == null)
{
return(null);
}
return(component.currentStats);
}
// Token: 0x06001CF5 RID: 7413 RVA: 0x00086D30 File Offset: 0x00084F30
private static void OnBodyFirstStart(CharacterBody body)
{
CharacterMaster master = body.master;
if (master)
{
master.onBodyStart -= StatManager.OnBodyFirstStart;
PlayerCharacterMasterController component = master.GetComponent <PlayerCharacterMasterController>();
if (component)
{
PlayerStatsComponent component2 = component.GetComponent <PlayerStatsComponent>();
if (component2)
{
StatSheet currentStats = component2.currentStats;
currentStats.PushStatValue(PerBodyStatDef.timesPicked.FindStatDef(body.name), 1UL);
currentStats.PushStatValue(StatDef.totalGamesPlayed, 1UL);
}
}
}
}
private void GenerateUserTeam(CharacterMaster user)
{
if (teams.ContainsKey(user))
{
return;
}
if (team1 <= team2)
{
teams.Add(user, new PlayerData(TeamIndex.Player));
team1++;
}
else
{
teams.Add(user, new PlayerData(TeamIndex.Monster));
team2++;
}
user.teamIndex = user.GetBody().teamComponent.teamIndex = teams[user].team;
DeathMatch.logger.Log(LogLevel.Info,
String.Format("User {0} assigned team {1}!",
user.GetComponent <PlayerCharacterMasterController>().networkUser.userName, user.teamIndex));
}
public static void GetCharacter()
{
try
{
if (InGameCheck())
{
LocalNetworkUser = null;
foreach (NetworkUser readOnlyInstance in NetworkUser.readOnlyInstancesList)
{
if (readOnlyInstance.isLocalPlayer)
{
LocalNetworkUser = readOnlyInstance;
LocalPlayer = LocalNetworkUser.master;
LocalPlayerInv = LocalPlayer.GetComponent <Inventory>(); //gets player inventory
LocalHealth = LocalPlayer.GetBody().GetComponent <HealthComponent>(); //gets players local health numbers
LocalSkills = LocalPlayer.GetBody().GetComponent <SkillLocator>(); //gets current for local character skills
LocalPlayerBody = LocalPlayer.GetBody().GetComponent <CharacterBody>(); //gets all stats for local character
LocalMotor = LocalPlayer.GetBody().GetComponent <CharacterMotor>();
bool flag = !LocalPlayer.IsDeadAndOutOfLivesServer();
if (flag)
{
characterCollected = true;
//Main.enableRespawnButton = true;
}
else
{
characterCollected = false;
}
}
}
}
}
catch (Exception e)
{
Debug.LogError($"GetCharacter caused an exception: {e}");
characterCollected = false;
}
}
private void UpdateAllTrackers(On.RoR2.CharacterBody.orig_OnInventoryChanged orig, CharacterBody self)
{
orig(self);
CharacterMaster ownerMaster = self.master;
MinionOwnership[] minionOwnerships = Object.FindObjectsOfType <MinionOwnership>();
foreach (MinionOwnership minionOwnership in minionOwnerships)
{
if (minionOwnership && minionOwnership.ownerMaster && minionOwnership.ownerMaster == ownerMaster)
{
CharacterMaster minionMaster = minionOwnership.GetComponent <CharacterMaster>();
if (minionMaster)
{
BotStatTracker tracker = minionMaster.GetComponent <BotStatTracker>();
if (tracker)
{
tracker.UpdateTrackerBoosts();
}
}
}
}
}
// try and setup our character, if we hit an error we set it to false
// TODO: Still tries to collect character after death and returning to lobby/title.
public static void GetCharacter()
{
try
{
if (InGameCheck())
{
LocalNetworkUser = null;
foreach (NetworkUser readOnlyInstance in NetworkUser.readOnlyInstancesList)
{
//localplayer is you!
if (readOnlyInstance.isLocalPlayer)
{
LocalNetworkUser = readOnlyInstance;
LocalPlayer = LocalNetworkUser.master;
LocalPlayerInv = LocalPlayer.GetComponent <Inventory>();
LocalHealth = LocalPlayer.GetBody().GetComponent <HealthComponent>();
LocalSkills = LocalPlayer.GetBody().GetComponent <SkillLocator>();
LocalPlayerBody = LocalPlayer.GetBody().GetComponent <CharacterBody>();
if (LocalHealth.alive)
{
_CharacterCollected = true;
}
else
{
_CharacterCollected = false;
}
}
}
}
}
catch (Exception e)
{
Debug.LogError(e);
_CharacterCollected = false;
}
}
// Token: 0x06001CFE RID: 7422 RVA: 0x0008719C File Offset: 0x0008539C
private static void ProcessGoldEvents()
{
while (StatManager.goldCollectedEvents.Count > 0)
{
StatManager.GoldEvent goldEvent = StatManager.goldCollectedEvents.Dequeue();
CharacterMaster characterMaster = goldEvent.characterMaster;
StatSheet statSheet;
if (characterMaster == null)
{
statSheet = null;
}
else
{
PlayerStatsComponent component = characterMaster.GetComponent <PlayerStatsComponent>();
statSheet = ((component != null) ? component.currentStats : null);
}
StatSheet statSheet2 = statSheet;
if (statSheet2 != null)
{
statSheet2.PushStatValue(StatDef.goldCollected, goldEvent.amount);
statSheet2.PushStatValue(StatDef.maxGoldCollected, statSheet2.GetStatValueULong(StatDef.goldCollected));
}
}
}
private void CharacterMasterOnBodyDeathPostfix(CharacterMaster instance)
{
if (gameover)
{
return;
}
PlayerCharacterMasterController player = instance.GetComponent <PlayerCharacterMasterController>();
if (player != null)
{
if (!instance.preventGameOver)
{
if (modDetails.enabled)
{
var name = player.networkUser.GetNetworkPlayerName().GetResolvedName();
originalBodyNames.Add(name, player.master.bodyPrefab.name);
var prefab = BodyCatalog.FindBodyPrefab("Drone2Body");
FrogtownShared.ChangePrefab(name, prefab);
}
//Still log they are a bot incase the mod was disabled in the middle of the round, so that the game can end properly.
botPlayers.Add(player.networkUser.GetNetworkPlayerName().GetResolvedName());
}
}
}
private void CharacterMaster_AddDeployable(On.RoR2.CharacterMaster.orig_AddDeployable orig, CharacterMaster self, Deployable deployable, DeployableSlot slot)
{
string turretType;
if (RoR2Application.isInSinglePlayer)
{
turretType = currentRule.ToString();
}
else
{
turretType = Facepunch.Steamworks.Client.Instance.Lobby.GetMemberData(self.GetComponent<PlayerCharacterMasterController>().netId.Value, "Turret");
}
if(turretType == "RailGun" || turretType == "2")
{
SetToRail();
}
else if(turretType == "MiniGun" || turretType == "3")
{
SetToMinigun();
}
else
{
SetToDefault();
}
orig(self, deployable, slot);
var turretinventory = self.gameObject.GetComponent<turretinventory>();
if (turretinventory == null)
{
turretinventory = self.gameObject.AddComponent<turretinventory>();
}
turretinventory.deployables = DeployList(self);
turretinventory.characterMaster = self;
}
private static void CCSpawnAI(ConCommandArgs args)
{
GameObject prefab;
GameObject body;
GameObject gameObject = null;
string prefabString = ArgsHelper.GetValue(args.userArgs, 0);
string eliteString = ArgsHelper.GetValue(args.userArgs, 1);
string teamString = ArgsHelper.GetValue(args.userArgs, 2);
string braindeadString = ArgsHelper.GetValue(args.userArgs, 3);
string bodyString = GetBodyMasterLink(prefabString, 0); //prefabString.Replace("Master", "");
string masterString = GetBodyMasterLink(prefabString, 1); //prefabString.Replace("Body", "");
prefab = MasterCatalog.FindMasterPrefab(masterString);
body = BodyCatalog.FindBodyPrefab(bodyString);
if (prefab == null)
{
List <string> array = new List <string>();
foreach (var item in MasterCatalog.allMasters)
{
array.Add(item.name);
}
string list = string.Join("\n", array);
Debug.LogFormat("Could not spawn {0}, Try: spawn_ai GolemBody --- \n{1}", prefabString, list);
return;
}
gameObject = Instantiate <GameObject>(prefab, args.sender.master.GetBody().transform.position, Quaternion.identity);
CharacterMaster master = gameObject.GetComponent <CharacterMaster>();
NetworkServer.Spawn(gameObject);
master.SpawnBody(body, args.sender.master.GetBody().transform.position, Quaternion.identity);
EliteIndex eliteIndex = EliteIndex.None;
if (Enum.TryParse <EliteIndex>(eliteString, true, out eliteIndex))
{
if ((int)eliteIndex > (int)EliteIndex.None && (int)eliteIndex < (int)EliteIndex.Count)
{
master.inventory.SetEquipmentIndex(EliteCatalog.GetEliteDef(eliteIndex).eliteEquipmentIndex);
}
}
TeamIndex teamIndex = TeamIndex.Neutral;
if (Enum.TryParse <TeamIndex>(teamString, true, out teamIndex))
{
if ((int)teamIndex >= (int)TeamIndex.None && (int)teamIndex < (int)TeamIndex.Count)
{
master.teamIndex = teamIndex;
}
}
bool braindead;
if (bool.TryParse(braindeadString, out braindead))
{
if (braindead)
{
Destroy(master.GetComponent <BaseAI>());
}
}
Debug.Log("Attempting to spawn " + prefabString);
}
