private void LaserTurbineController_OnStartServer(On.RoR2.LaserTurbineController.orig_OnStartServer orig, LaserTurbineController self)
{
_pseudoInitialSpin = self.minSpin;
_pseudoSnapshotTime = _runNow;
orig(self);
}
private void FireEquipment()
{
if (this.master.GetBody().equipmentSlot.ExecuteIfReady())
{
lastEquipmentUse = Run.FixedTimeStamp.now;
}
}
// Token: 0x060022C4 RID: 8900 RVA: 0x00096F90 File Offset: 0x00095190
private EquipmentIcon.DisplayData GenerateDisplayData()
{
EquipmentIcon.DisplayData result = default(EquipmentIcon.DisplayData);
EquipmentIndex equipmentIndex = EquipmentIndex.None;
if (this.targetInventory)
{
EquipmentState equipmentState;
if (this.displayAlternateEquipment)
{
equipmentState = this.targetInventory.alternateEquipmentState;
result.hideEntireDisplay = (this.targetInventory.GetEquipmentSlotCount() <= 1);
}
else
{
equipmentState = this.targetInventory.currentEquipmentState;
result.hideEntireDisplay = false;
}
Run.FixedTimeStamp now = Run.FixedTimeStamp.now;
Run.FixedTimeStamp chargeFinishTime = equipmentState.chargeFinishTime;
equipmentIndex = equipmentState.equipmentIndex;
result.cooldownValue = (chargeFinishTime.isInfinity ? 0 : Mathf.CeilToInt(chargeFinishTime.timeUntilClamped));
result.stock = (int)equipmentState.charges;
result.maxStock = (this.targetEquipmentSlot ? this.targetEquipmentSlot.maxStock : 1);
}
else if (this.displayAlternateEquipment)
{
result.hideEntireDisplay = true;
}
result.equipmentDef = EquipmentCatalog.GetEquipmentDef(equipmentIndex);
return(result);
}
private void GenerateEntriesServer(Run.FixedTimeStamp startTime)
{
if (!NetworkServer.active)
{
Debug.LogWarning("[Server] function 'System.Void RoR2.RouletteChestController::GenerateEntriesServer(RoR2.Run/FixedTimeStamp)' called on client");
return;
}
Array.Resize <RouletteChestController.Entry>(ref this.entries, this.maxEntries);
for (int i = 0; i < this.entries.Length; i++)
{
RouletteChestController.Entry[] array = this.entries;
int num = i;
array[num].endTime = startTime + this.CalcEntryDuration(i);
startTime = array[num].endTime;
}
PickupIndex b = PickupIndex.none;
for (int j = 0; j < this.entries.Length; j++)
{
RouletteChestController.Entry[] array2 = this.entries;
int num2 = j;
PickupIndex pickupIndex = this.dropTable.GenerateDrop(this.rng);
if (pickupIndex == b)
{
pickupIndex = this.dropTable.GenerateDrop(this.rng);
}
array2[num2].pickupIndex = pickupIndex;
b = pickupIndex;
}
base.SetDirtyBit(RouletteChestController.entriesDirtyBit);
}
// Token: 0x06000D88 RID: 3464 RVA: 0x0003CD18 File Offset: 0x0003AF18
public EquipmentState(EquipmentIndex equipmentIndex, Run.FixedTimeStamp chargeFinishTime, byte charges)
{
this.equipmentIndex = equipmentIndex;
this.chargeFinishTime = chargeFinishTime;
this.charges = charges;
this.dirty = true;
this.equipmentDef = EquipmentCatalog.GetEquipmentDef(equipmentIndex);
}
// Token: 0x06000D8C RID: 3468 RVA: 0x0003CDD4 File Offset: 0x0003AFD4
public static EquipmentState Deserialize(NetworkReader reader)
{
EquipmentIndex equipmentIndex = reader.ReadEquipmentIndex();
Run.FixedTimeStamp fixedTimeStamp = reader.ReadFixedTimeStamp();
byte b = reader.ReadByte();
return(new EquipmentState(equipmentIndex, fixedTimeStamp, b));
}
// Token: 0x06002E6F RID: 11887 RVA: 0x000C55FB File Offset: 0x000C37FB
public override void OnEnter()
{
base.OnEnter();
if (base.isAuthority)
{
this.startTime = Run.FixedTimeStamp.now;
this.readyTime = this.startTime + RechargeState.baseDuration;
}
}
// Token: 0x06001186 RID: 4486 RVA: 0x0004CAE4 File Offset: 0x0004ACE4
private PickupIndex GetPickupIndexForTime(Run.FixedTimeStamp time)
{
int entryIndexForTime = this.GetEntryIndexForTime(time);
if (entryIndexForTime != -1)
{
return(this.entries[entryIndexForTime].pickupIndex);
}
return(PickupIndex.none);
}
// Token: 0x06000DD5 RID: 3541 RVA: 0x0003E13C File Offset: 0x0003C33C
private void FixedUpdate()
{
Run.FixedTimeStamp now = Run.FixedTimeStamp.now;
this.spin = this.spinChargeState.CalcCurrentSpinValue(now, this.spinDecayRate, this.minSpin);
this.charge = this.spinChargeState.CalcCurrentChargeValue(now, this.spinDecayRate, this.minSpin);
if (this.turbineDisplayRoot)
{
this.turbineDisplayRoot.gameObject.SetActive(this.showTurbineDisplay);
}
}
// Token: 0x06000DE4 RID: 3556 RVA: 0x0003E4CC File Offset: 0x0003C6CC
public float CalcCurrentChargeValue(Run.FixedTimeStamp currentTime, float spinDecayRate, float minSpin)
{
float num = currentTime - this.snapshotTime;
float num2 = minSpin * num;
float num3 = this.initialSpin - minSpin;
float t = Mathf.Min(Trajectory.CalculateFlightDuration(num3, -spinDecayRate) * 0.5f, num);
float num4 = Trajectory.CalculatePositionYAtTime(0f, num3, t, -spinDecayRate);
return(Mathf.Min(this.initialCharge + num2 + num4, 1f));
}
//well this was a failure. I am very glad we have a public reference to charge
//at least the spin calculation wasn't a similarly colossal failure
// god f****n dammit now i need this to work so I can calculate the overcharge
private float pseudoCalculateCharge(Run.FixedTimeStamp now, LaserTurbineController self)
{
float num = now - _pseudoSnapshotTime;
float num2 = self.minSpin * num;
float num3 = _pseudoInitialSpin - self.minSpin;
float t = Mathf.Min(Trajectory.CalculateFlightDuration(num3, -self.spinDecayRate) * 0.5f, num);
float num4 = Trajectory.CalculatePositionYAtTime(0f, num3, t, -self.spinDecayRate);
return(Mathf.Min(_pseudoInitialCharge + num2 + num4, 1f));
}
public void LoadEquipment(Inventory inventory, byte equipmentSlot)
{
var chargeTime = new Run.FixedTimeStamp(chargeFinishTime);
var state = new EquipmentState(
(EquipmentIndex)index,
chargeTime,
charges
);
inventory.SetEquipment(state, equipmentSlot);
}
private void UpdateEquipment()
{
if (!NetworkServer.active)
{
Debug.LogWarning("[Server] function 'System.Void RoR2.Inventory::UpdateEquipment()' called on client");
return;
}
Run.FixedTimeStamp now = Run.FixedTimeStamp.now;
int itemCount = this.GetItemCount(ItemIndex.EquipmentMagazine);
byte b = (byte)Mathf.Min(1 + this.GetItemCount(ItemIndex.EquipmentMagazine), 255);
uint num = 0U;
while ((ulong)num < (ulong)((long)this.equipmentStateSlots.Length))
{
EquipmentState equipmentState = this.equipmentStateSlots[(int)num];
if (equipmentState.equipmentIndex != EquipmentIndex.None)
{
if (equipmentState.charges < b)
{
Run.FixedTimeStamp a = equipmentState.chargeFinishTime;
byte b2 = equipmentState.charges;
if (!a.isPositiveInfinity)
{
b2 += 1;
}
if (a.isInfinity)
{
a = now;
}
if (a.hasPassed)
{
int itemCount2 = this.GetItemCount(ItemIndex.AutoCastEquipment);
float num2 = Mathf.Pow(0.85f, (float)itemCount);
if (itemCount2 > 0)
{
num2 *= 0.5f * Mathf.Pow(0.85f, (float)(itemCount2 - 1));
}
float b3 = equipmentState.equipmentDef.cooldown * num2;
this.SetEquipment(new EquipmentState(equipmentState.equipmentIndex, a + b3, b2), num);
}
}
if (equipmentState.charges >= b && !equipmentState.chargeFinishTime.isPositiveInfinity)
{
this.SetEquipment(new EquipmentState(equipmentState.equipmentIndex, Run.FixedTimeStamp.positiveInfinity, b), num);
}
}
num += 1U;
}
}
private void LaserTurbineController_ExpendCharge(On.RoR2.LaserTurbineController.orig_ExpendCharge orig, LaserTurbineController self)
{
Run.FixedTimeStamp now = _runNow;
float spin = pseudoCalculateSpin(now, self);
spin += self.spinPerKill;
_pseudoInitialSpin += spin;
_pseudoInitialCharge = 0f;
_pseudoSnapshotTime = now;
self.spinPerKill = _stackedSpinPerKill;
orig(self);
}
// Token: 0x06000DDB RID: 3547 RVA: 0x0003E31C File Offset: 0x0003C51C
private void OnOwnerKilledOtherServer()
{
Run.FixedTimeStamp now = Run.FixedTimeStamp.now;
float num = this.spinChargeState.CalcCurrentSpinValue(now, this.spinDecayRate, this.minSpin);
float initialCharge = this.spinChargeState.CalcCurrentChargeValue(now, this.spinDecayRate, this.minSpin);
num = Mathf.Min(num + this.spinPerKill, this.maxSpin);
LaserTurbineController.SpinChargeState networkspinChargeState = new LaserTurbineController.SpinChargeState
{
initialSpin = num,
initialCharge = initialCharge,
snapshotTime = now
};
this.NetworkspinChargeState = networkspinChargeState;
}
// Token: 0x06001185 RID: 4485 RVA: 0x0004CA94 File Offset: 0x0004AC94
private int GetEntryIndexForTime(Run.FixedTimeStamp time)
{
for (int i = 0; i < this.entries.Length; i++)
{
if (time < this.entries[i].endTime)
{
return(i);
}
}
if (this.entries.Length != 0)
{
return(this.entries.Length - 1);
}
return(-1);
}
private void LaserTurbineController_OnOwnerKilledOtherServer(On.RoR2.LaserTurbineController.orig_OnOwnerKilledOtherServer orig, LaserTurbineController self)
{
Run.FixedTimeStamp now = _runNow;
float spin = pseudoCalculateSpin(now, self);
float charge = pseudoCalculateCharge(now, self);
spin = Mathf.Min(spin + self.spinPerKill, self.maxSpin);
_pseudoInitialSpin = spin;
_pseudoInitialCharge = charge;
_pseudoSnapshotTime = now;
self.spinPerKill = _stackedSpinPerKill;
orig(self);
}
public void ExpendCharge()
{
if (!NetworkServer.active)
{
Debug.LogWarning("[Server] function 'System.Void RoR2.LaserTurbineController::ExpendCharge()' called on client");
return;
}
Run.FixedTimeStamp now = Run.FixedTimeStamp.now;
float num = this.spinChargeState.CalcCurrentSpinValue(now, this.spinDecayRate, this.minSpin);
num += this.spinPerKill;
LaserTurbineController.SpinChargeState networkspinChargeState = new LaserTurbineController.SpinChargeState
{
initialSpin = num,
initialCharge = 0f,
snapshotTime = now
};
this.NetworkspinChargeState = networkspinChargeState;
}
public void SetEquipmentIndexUnsafe(Inventory inventory, EquipmentIndex newEquipmentIndex, byte equipmentSlot)
{
if (!NetworkServer.active)
{
return;
}
EquipmentState equipment = inventory.GetEquipment(equipmentSlot);
byte charges = equipment.charges;
Run.FixedTimeStamp chargeFinishTime = equipment.chargeFinishTime;
if (equipment.equipmentIndex == EquipmentIndex.None && chargeFinishTime.isNegativeInfinity)
{
charges = 1;
chargeFinishTime = Run.FixedTimeStamp.now;
}
EquipmentState equipmentState = new EquipmentState(newEquipmentIndex, chargeFinishTime, charges);
inventory.SetEquipment(equipmentState, equipmentSlot);
}
public void SetEquipmentIndex(EquipmentIndex newEquipmentIndex)
{
if (!NetworkServer.active)
{
Debug.LogWarning("[Server] function 'System.Void RoR2.Inventory::SetEquipmentIndex(RoR2.EquipmentIndex)' called on client");
return;
}
if (this.currentEquipmentIndex != newEquipmentIndex)
{
EquipmentState equipment = this.GetEquipment((uint)this.activeEquipmentSlot);
byte charges = equipment.charges;
Run.FixedTimeStamp chargeFinishTime = equipment.chargeFinishTime;
if (equipment.equipmentIndex == EquipmentIndex.None && chargeFinishTime.isNegativeInfinity)
{
charges = 1;
chargeFinishTime = Run.FixedTimeStamp.now;
}
EquipmentState equipmentState = new EquipmentState(newEquipmentIndex, chargeFinishTime, charges);
this.SetEquipment(equipmentState, (uint)this.activeEquipmentSlot);
}
}
private void EndCycleServer([CanBeNull] Interactor activator)
{
if (!NetworkServer.active)
{
Debug.LogWarning("[Server] function 'System.Void RoR2.RouletteChestController::EndCycleServer(RoR2.Interactor)' called on client");
return;
}
float b = 0f;
NetworkUser networkUser;
if (activator && (networkUser = Util.LookUpBodyNetworkUser(activator.gameObject)) != null)
{
b = RttManager.GetConnectionRTT(networkUser.connectionToClient);
}
Run.FixedTimeStamp time = Run.FixedTimeStamp.now - b - RouletteChestController.rewindTime;
PickupIndex pickupIndexForTime = this.GetPickupIndexForTime(time);
this.EjectPickupServer(pickupIndexForTime);
this.activationTime = Run.FixedTimeStamp.positiveInfinity;
this.onCycleCompletedServer.Invoke();
}
// Token: 0x060039AE RID: 14766 RVA: 0x000E2980 File Offset: 0x000E0B80
public virtual void BeginMeleeAttackEffect()
{
if (this.meleeAttackStartTime != Run.FixedTimeStamp.positiveInfinity)
{
return;
}
this.meleeAttackStartTime = Run.FixedTimeStamp.now;
Util.PlaySound(this.beginSwingSoundString, base.gameObject);
if (this.swingEffectPrefab)
{
Transform transform = base.FindModelChild(this.swingEffectMuzzleString);
if (transform)
{
this.swingEffectInstance = UnityEngine.Object.Instantiate <GameObject>(this.swingEffectPrefab, transform);
ScaleParticleSystemDuration component = this.swingEffectInstance.GetComponent <ScaleParticleSystemDuration>();
if (component)
{
component.newDuration = component.initialDuration;
}
}
}
}
// Token: 0x0600117B RID: 4475 RVA: 0x0004C6DC File Offset: 0x0004A8DC
public override void OnDeserialize(NetworkReader reader, bool initialState)
{
uint num = reader.ReadPackedUInt32();
if ((num & RouletteChestController.activationTimeDirtyBit) != 0U)
{
this.activationTime = reader.ReadFixedTimeStamp();
}
if ((num & RouletteChestController.entriesDirtyBit) != 0U)
{
Array.Resize <RouletteChestController.Entry>(ref this.entries, (int)reader.ReadPackedUInt32());
Run.FixedTimeStamp endTime = this.activationTime;
for (int i = 0; i < this.entries.Length; i++)
{
RouletteChestController.Entry[] array = this.entries;
int num2 = i;
array[num2].pickupIndex = reader.ReadPickupIndex();
array[num2].endTime = endTime + this.CalcEntryDuration(i);
endTime = array[num2].endTime;
}
}
}
// Token: 0x06001184 RID: 4484 RVA: 0x0004C9E0 File Offset: 0x0004ABE0
private void FixedUpdate()
{
if (this.pickupDisplay)
{
this.pickupDisplay.SetPickupIndex(this.isCycling ? this.GetPickupIndexForTime(Run.FixedTimeStamp.now) : PickupIndex.none, false);
}
if (NetworkClient.active)
{
int entryIndexForTime = this.GetEntryIndexForTime(Run.FixedTimeStamp.now);
if (entryIndexForTime != this.previousEntryIndexClient)
{
this.previousEntryIndexClient = entryIndexForTime;
this.onChangedEntryClient.Invoke();
}
}
if (NetworkServer.active && this.isCycling && this.entries.Length != 0)
{
Run.FixedTimeStamp endTime = this.entries[this.entries.Length - 1].endTime;
if (endTime.hasPassed)
{
this.EndCycleServer(null);
}
}
}
// Token: 0x06000DE3 RID: 3555 RVA: 0x0003E4AD File Offset: 0x0003C6AD
public float CalcCurrentSpinValue(Run.FixedTimeStamp currentTime, float spinDecayRate, float minSpin)
{
return(Mathf.Max(this.initialSpin - spinDecayRate * (currentTime - this.snapshotTime), minSpin));
}
private float pseudoCalculateSpin(Run.FixedTimeStamp now, LaserTurbineController self)
{
return(Mathf.Max(_pseudoInitialSpin - self.spinDecayRate * (_runNow - _pseudoSnapshotTime), self.minSpin));;
}
// Token: 0x060009A7 RID: 2471 RVA: 0x00030A57 File Offset: 0x0002EC57
public static void Write(this NetworkWriter writer, Run.FixedTimeStamp timeStamp)
{
Run.FixedTimeStamp.Serialize(writer, timeStamp);
}
private void ResetBuyingDelay()
{
this.lastBuyCheck = Run.FixedTimeStamp.now;
this.buyingDelay = Random.Range(PlayerBotManager.MinBuyingDelay.Value, PlayerBotManager.MaxBuyingDelay.Value);
}
public void AddInstance(Run.FixedTimeStamp time, HitlagInstance instance)
{
instanceLists.Add(time, instance);
}
// Token: 0x060034E0 RID: 13536 RVA: 0x000E7BF6 File Offset: 0x000E5DF6
public static void _WriteFixedTimeStamp_Run(NetworkWriter writer, Run.FixedTimeStamp value)
{
writer.Write(value.t);
}