IEnumerator <float> GetMasterController(NetworkUser networkUser)
{
PlayerCharacterMasterController masterController = networkUser.masterController;
while (masterController == null)
{
masterController = networkUser.masterController;
yield return(0);
}
characterBody = masterController.master.GetBody();
while (characterBody == null)
{
characterBody = masterController.master.GetBody();
yield return(0);
}
if (stageClearCountOld == -1 || stageClearCountOld == 0)
{
float startingTime = Time.time;
while (Time.time - startingTime < 2)
{
yield return(0);
}
}
inventoryLocal = characterBody.inventory;
}
public IEnumerator WatchInventory(PlayerCharacterMasterController pcmc)
{
yield return(new WaitUntil(() => { return pcmc.master.inventory != null; }));
string name = pcmc.GetDisplayName() ?? pcmc.name;
DebugChat("Configuring Player " + name + " inventory");
On.RoR2.Language.GetString_string += (orig, self) =>
{
if (_languageItemPickupRegex.IsMatch(self))
{
var ii = GetItemFromFriendlyName(self);
var ic = GetItemCalculation(ii);
DebugChat("Item Index: " + ii.ToString());
if (ic != null)
{
var results = ic.Evaluate(pcmc.master.inventory.GetItemCount(ii));
var newDescription = orig(self) + Environment.NewLine + Environment.NewLine;
foreach (var r in results)
{
newDescription += String.Format("{0} value is {1}{2}", r.Property, StyleText(r.Result.ToString("0.##") + r.Unit, r.TextStyle), Environment.NewLine);
}
return(newDescription);
}
}
return(orig(self));
};
}
/// <summary>
/// Add functions to be called for given player's action events.
/// </summary>
/// <param name="playerCharArg"></param>
private void AddPlayerEventListening(PlayerCharacterMasterController playerCharArg)
{
//playerCharArg.OnCharDataSecondaryChangedAction += RefreshCharacterPortrait;
//playerCharArg.CharHealth.OnHealthChangedAction += RefreshScreen;
playerCharArg.CharHealth.OnDamageTaken += OnDamageTaken;
playerCharArg.CharHealth.OnHealthHealed += OnHealthHealed;
}
public void FixedUpdate()
{
if (!this.hasChecked && this.playerCharacterMasterController.body)
{
this.hasChecked = true;
if (this.playerCharacterMasterController.body.baseNameToken != Modules.Enemies.Nemry.characterPrefab.GetComponent <CharacterBody>().baseNameToken)
{
Destroy(this);
return;
}
}
if (!this.customInputBank || !this.playerCharacterMasterController.hasEffectiveAuthority)
{
return;
}
bool swapSkillState = false;
if (PlayerCharacterMasterController.CanSendBodyInput(playerCharacterMasterController.networkUser, out _, out var inputPlayer, out _))
{
swapSkillState = inputPlayer.GetButton(RewiredActions.WeaponSwapSkill);
}
this.customInputBank.weaponSwapSkill.PushState(swapSkillState);
}
protected internal override GameObject Instantiate(PlayerCharacterMasterController owner)
{
buttonBindingInfos.Clear();
thetaOffsetDegr = 0f;
foreach (var player in PlayerCharacterMasterController._instancesReadOnly)
{
if (!respondables.ContainsKey(player))
{
continue;
}
var respdat = respondables[player];
if (Time.unscaledTime - respdat.birthday > RESPONDABLE_LIFETIME)
{
continue;
}
var pingType = PingCatalog.Get(respdat.pingTypeIndex);
var sprite = pingType.pingSkins[respdat.pingSkinIndex].sprite;
buttonBindingInfos.Add(new DirectedPingBindingInfo {
iconColor = Color.white,
descriptionToken = $"{player.GetDisplayName()}",
sprite = sprite,
targetPCMC = player,
orderedTypes = new[] { responseMap[responseType] }
});
}
var menuObj = base.Instantiate(owner);
var pingHelper = menuObj.AddComponent <PingMenuHelper>();
pingHelper.owner = owner;
pingHelper.TryUpdatePingInfo();
return(menuObj);
}
public SteamPlayer(PlayerCharacterMasterController player)
{
steamID = player.networkUser.id.steamId;
isReady = false;
networkConnection = player.master.GetComponent <NetworkIdentity>().clientAuthorityOwner;
playerName = player.networkUser.userName;
}
protected internal override GameObject Instantiate(PlayerCharacterMasterController owner)
{
buttonBindingInfos.Clear();
buttonBindingInfos.Add(returnBinding);
var buttonCount = Random.Range(1, 24);
thetaOffsetDegr = -180 / (buttonCount + 1);
for (int i = 0; i < buttonCount; i++)
{
buttonBindingInfos.Add(new BindingInfo {
iconColor = Color.HSVToRGB((float)i / buttonCount, 1f, 1f),
descriptionToken = $"Test Button {i+1}",
sprite = Resources.Load <Sprite>("textures/miscicons/texWIPIcon")
});
}
var menuObj = base.Instantiate(owner);
var pingHelper = menuObj.AddComponent <PingMenuHelper>();
pingHelper.owner = owner;
pingHelper.TryUpdatePingInfo();
return(menuObj);
}
/// <summary>
/// Fully sets up the health bar properties.
/// </summary>
private void RefreshHealthBarFull()
{
// get player char the UI is associated with
PlayerCharacterMasterController playerChar = _uiManager.UiPlayerCharacter;
// if player char found
if (playerChar != null)
{
// get front-facing char data
CharacterData charData = playerChar.CharDataSecondary;
// if valid char data retrieved
if (charData != null)
{
// get the front-facing char data's stats
CharacterStats charStats = charData.characterStats;
// refresh health bar based on char stats
RefreshBarDimensions(charStats.healthCurrent, charStats.
GetTrueMaxHealthWithoutFatigueModifier());
// refreshes the current health fatigue bar's fill
RefreshFatigueBar(charStats);
// turn ON the health bar
SetBarActivation(true);
// DONT continue code
return;
}
}
// getting here means that ammo bar should NOT be used, so turn OFF the health bar
SetBarActivation(false);
}
internal void GiveStartingItems(PlayerCharacterMasterController player)
{
RoR2.Chat.AddMessage($"Giving {player.GetDisplayName()} a care package");
const int whiteItems = 5;
const int greenItems = 3;
const int redItems = 0;
for (int i = 0; i < whiteItems; i++)
{
//And then finally drop it infront of the player.
CreatePickup(player, GetRandomPickup(1));
}
for (int i = 0; i < greenItems; i++)
{
//And then finally drop it infront of the player.
CreatePickup(player, GetRandomPickup(2));
}
for (int i = 0; i < redItems; i++)
{
//And then finally drop it infront of the player.
CreatePickup(player, GetRandomPickup(3));
}
}
private IEnumerator SetPlayerCharacterIfAppropriateInternal(PlayerCharacterMasterController playerCharArg)
{
// wait to ensure that player's network component properties are fully setup
yield return(new WaitForEndOfFrame());
// get net identity comp from player obj
NetworkIdentity netIdentity = playerCharArg.GetComponent <NetworkIdentity>();
// if NO such component found
if (netIdentity == null)
{
// DONT continue code
yield break;
}
// if player is online but NOT associated with the machine running this
if (GeneralMethods.IsNetworkConnectedButNotLocalClient(netIdentity))
{
// DONT continue code
yield break;
}
//set UI player char to given char
uiPlayerCharacter = playerCharArg;
// trigger event to denote that the UI player char has been changed
UiPlayerCharChangedEvent.Trigger(uiPlayerCharacter);
}
private void StageFixedUpdatePrefix(Stage instance)
{
if (gameover)
{
return;
}
//Still end even when disabled in case it was turned off mid round.
if (NetworkServer.active)
{
var sAnyPlayer = Traverse.Create(instance).Field("spawnedAnyPlayer").GetValue() as bool?;
if (sAnyPlayer.HasValue && sAnyPlayer.Value && float.IsInfinity(instance.stageAdvanceTime) && !Run.instance.isGameOverServer)
{
ReadOnlyCollection <PlayerCharacterMasterController> instances = PlayerCharacterMasterController.instances;
bool flag = false;
for (int i = 0; i < instances.Count; i++)
{
PlayerCharacterMasterController player = instances[i];
if (player.isConnected && !botPlayers.Contains(player.networkUser.GetNetworkPlayerName().GetResolvedName()))
{
flag = true;
break;
}
}
if (!flag)
{
RestoreCharacterPrefabsAndKill();
gameover = true;
}
}
}
}
static void Postfix(ref Vector3 __state, ref PlayerCharacterMasterController __instance)
{
var body = __instance.master.GetBodyObject().GetComponent <CharacterBody>();
var inputs = __instance.master.GetBodyObject().GetComponent <InputBankTest>();
inputs.moveVector = __state;
}
public void Update()
{
if (this.hud.targetBodyObject)
{
NemryEnergyComponent energyComponent = this.hud.targetBodyObject.GetComponent <NemryEnergyComponent>();
if (energyComponent)
{
PlayerCharacterMasterController masterController = this.hud.targetMaster ? this.hud.targetMaster.playerCharacterMasterController : null;
if (this.energyGauge)
{
this.energyGauge.gameObject.SetActive(true);
float _fillAmount = energyComponent.currentEnergy / energyComponent.maxEnergy;
this.energyFill.fillAmount = _fillAmount;
}
}
else
{
if (this.energyGauge)
{
this.energyGauge.gameObject.SetActive(false);
}
}
}
}
protected internal override GameObject Instantiate(PlayerCharacterMasterController owner)
{
buttonBindingInfos.Clear();
thetaOffsetDegr = 0f;
foreach (var player in PlayerCharacterMasterController._instancesReadOnly)
{
//if(player == owner) continue;
var srcTex = player.master.GetBody().portraitIcon; //networked
var destSprite = Sprite.Create((Texture2D)srcTex, new Rect(0, 0, srcTex.width, srcTex.height), new Vector2(0.5f, 0.5f));
buttonBindingInfos.Add(new DirectedPingBindingInfo {
iconColor = Color.white,
descriptionToken = $"{player.GetDisplayName()}",
sprite = destSprite,
targetPCMC = player,
orderedTypes = new[] { PlayerPingTypeRecipient, PlayerPingTypeAlly, PlayerPingTypeEnemy, PlayerPingTypePickup, PlayerPingTypeInteractable, PlayerPingTypeNoTarget }
});
}
var menuObj = base.Instantiate(owner);
var pingHelper = menuObj.AddComponent <PingMenuHelper>();
pingHelper.owner = owner;
pingHelper.TryUpdatePingInfo();
return(menuObj);
}
public void FixedUpdate()
{
if (!extraInputBankTest || !playerCharacterMasterController.hasEffectiveAuthority || !extraInputBankTest)
{
return;
}
var skill1State = false;
var skill2State = false;
var skill3State = false;
var skill4State = false;
if (PlayerCharacterMasterController.CanSendBodyInput(playerCharacterMasterController.networkUser, out _, out var inputPlayer, out _))
{
skill1State = inputPlayer.GetButton(RewiredAction.FirstExtraSkill.ActionId);
skill2State = inputPlayer.GetButton(RewiredAction.SecondExtraSkill.ActionId);
skill3State = inputPlayer.GetButton(RewiredAction.ThirdExtraSkill.ActionId);
skill4State = inputPlayer.GetButton(RewiredAction.FourthExtraSkill.ActionId);
}
extraInputBankTest.extraSkill1.PushState(skill1State);
extraInputBankTest.extraSkill2.PushState(skill2State);
extraInputBankTest.extraSkill3.PushState(skill3State);
extraInputBankTest.extraSkill4.PushState(skill4State);
}
// Token: 0x060025D8 RID: 9688 RVA: 0x000B1870 File Offset: 0x000AFA70
private void SetMasterController(PlayerCharacterMasterController newMasterController)
{
if (this.currentMasterController == newMasterController)
{
return;
}
if (this.currentInventory != null)
{
this.currentInventory.onInventoryChanged -= this.OnInventoryChanged;
}
this.currentMasterController = newMasterController;
PlayerCharacterMasterController playerCharacterMasterController = this.currentMasterController;
Inventory inventory;
if (playerCharacterMasterController == null)
{
inventory = null;
}
else
{
CharacterMaster master = playerCharacterMasterController.master;
inventory = ((master != null) ? master.inventory : null);
}
this.currentInventory = inventory;
if (this.currentInventory != null)
{
this.currentInventory.onInventoryChanged += this.OnInventoryChanged;
}
}
private void applySavedTokens(Object source, System.Timers.ElapsedEventArgs e)
{
// This will stay in for now
Logger.LogInfo("Hello my name timer");
// Keep waiting for players to load
if (PlayerCharacterMasterController.instances.Count > PlayerCharacterMasterController.GetPlayersWithBodiesCount())
{
return;
}
// All players are loaded
// Stop the timer
timer.Enabled = false;
ReadOnlyCollection <PlayerCharacterMasterController> players = PlayerCharacterMasterController.instances;
for (int i = 0; i < players.Count; i++)
{
if (players[i].master.hasBody)
{
CharacterBody body = players[i].master.GetBody();
for (int j = 0; j < stackCount[i]; j++)
{
body.AddBuff(RoR2Content.Buffs.BanditSkull);
}
}
}
}
public void OnReceived()
{
GameObject obj = Util.FindNetworkObject(objID);
if (obj)
{
var master = obj.GetComponent <CharacterMaster>();
if (master)
{
PlayerCharacterMasterController pcmc = master.GetComponent <PlayerCharacterMasterController>();
if (pcmc)
{
NetworkUser networkUser = pcmc.networkUser;
if (networkUser)
{
LocalUser localUser = networkUser.localUser;
if (localUser != null)
{
localUser.userProfile.DiscoverPickup(new PickupIndex(pickupIndex));
}
}
}
}
}
}
private void GenericPickupController_AttemptGrant(On.RoR2.GenericPickupController.orig_AttemptGrant orig, GenericPickupController self, CharacterBody body)
{
if (!NetworkServer.active)
{
Debug.LogWarning("[Server] function 'System.Void RoR2.GenericPickupController::AttemptGrant(RoR2.CharacterBody)' called on client");
return;
}
if (!ArtifactEnabled)
{
return;
}
if (!body.masterObject)
{
return;
}
TeamComponent component = body.GetComponent <TeamComponent>();
if (component)
{
Inventory inventory = body.inventory;
if (inventory)
{
PlayerCharacterMasterController isPlayer = body.masterObject.GetComponent <PlayerCharacterMasterController>();
self.consumed = true;
PickupDef pickupDef = PickupCatalog.GetPickupDef(self.pickupIndex);
DropInventoryOnDeath comp = null;
if (!isPlayer && body.teamComponent.teamIndex != TeamIndex.Player)
{
comp = body.gameObject.GetComponent <DropInventoryOnDeath>();
if (!comp)
{
comp = body.gameObject.AddComponent <DropInventoryOnDeath>();
}
}
if (pickupDef.itemIndex != ItemIndex.None)
{
self.GrantItem(body, inventory);
}
if (pickupDef.coinValue != 0U)
{
self.GrantLunarCoin(body, pickupDef.coinValue);
}
if (isPlayer)
{
if (pickupDef.equipmentIndex != EquipmentIndex.None)
{
self.GrantEquipment(body, inventory);
}
if (pickupDef.artifactIndex != ArtifactIndex.None)
{
self.GrantArtifact(body, pickupDef.artifactIndex);
}
}
}
}
}
public IEnumerator OnPlayerAdded(PlayerCharacterMasterController player)
{
while (ui == null)
{
yield return(null);
}
ui.AddBar(player);
}
public void AddBar(PlayerCharacterMasterController player)
{
if (RecountBar.BarInstances.ContainsKey(player))
{
return;
}
barsContainer.AddComponent <RecountBar>().player = player;
}
private CharacterMaster GetCharacterMasterByInvetory(Inventory inventory)
{
PlayerCharacterMasterController playerCharacterMasterController =
PlayerCharacterMasterController.instances.FirstOrDefault((PlayerCharacterMasterController p) =>
p.master.inventory == inventory
);
return((playerCharacterMasterController != null) ? playerCharacterMasterController.master : null);
}
// 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;
}
}
public void RemoveBar(PlayerCharacterMasterController player)
{
RecountBar.BarInstances.Remove(player);
foreach (RecountBar bar in barsContainer.GetComponents <RecountBar>().Reverse())
{
if (bar.player.Equals(player))
{
Destroy(bar);
}
}
}
private bool isNonSurvivor(PlayerCharacterMasterController enumerator)
{
if (enumerator.master.hasBody)
{
if (!enumerator.networkUser.GetCurrentBody().name.Split('(')[0].Equals(BodyCatalog.GetBodyPrefab(enumerator.networkUser.NetworkbodyIndexPreference).name))
{
return(true);
}
}
return(false);
}
public void Start()
{
if (PlayerCharacterMasterController.instances[0])
{
localPlayer = PlayerCharacterMasterController.instances[0];
}
else
{
enabled = false;
}
}
protected internal override GameObject Instantiate(PlayerCharacterMasterController owner)
{
var menuObj = base.Instantiate(owner);
var pingHelper = menuObj.AddComponent <PingMenuHelper>();
pingHelper.owner = owner;
pingHelper.TryUpdatePingInfo();
return(menuObj);
}
IEnumerator <float> GetMasterController(NetworkUser networkUser)
{
PlayerCharacterMasterController masterController = networkUser.masterController;
while (masterController == null)
{
masterController = networkUser.masterController;
yield return(0);
}
GameManager.SetCharacterMaster(networkUser.netId.Value, networkUser.masterController.master);
}
private void StageRespawnCharacterPrefix(CharacterMaster characterMaster)
{
if (!modDetails.enabled)
{
return;
}
PlayerCharacterMasterController player = characterMaster.GetComponent <PlayerCharacterMasterController>();
string name = player.networkUser.GetNetworkPlayerName().GetResolvedName();
RestoreCharacterPrefab(name);
}
// Token: 0x06001C79 RID: 7289 RVA: 0x00079AA0 File Offset: 0x00077CA0
private void Awake()
{
this.playerCharacterMasterController = base.GetComponent <PlayerCharacterMasterController>();
this.characterMaster = base.GetComponent <CharacterMaster>();
PlayerStatsComponent.instancesList.Add(this);
this.currentStats = StatSheet.New();
if (NetworkClient.active)
{
this.recordedStats = StatSheet.New();
this.clientDeltaStatsBuffer = StatSheet.New();
}
}
