private void PostProcessBeamTick(BeamController beam, SpeculativeRigidbody spec, float tickRate)
{
GameActor gameActor = spec.gameActor;
if (!gameActor)
{
return;
}
PlayerController player = this.Owner;
if (player.CurrentGun.PickupObjectId == 40)
{
beam.projectile.baseData.damage *= 1.003f;
}
BulletStatusEffectItem frostbullets = PickupObjectDatabase.GetById(278).GetComponent <BulletStatusEffectItem>();
GameActorFreezeEffect frostfreeze = frostbullets.FreezeModifierEffect;
if (player.CurrentGun.PickupObjectId == 464)
{
if (UnityEngine.Random.value < BraveMathCollege.SliceProbability(1f, tickRate))
{
gameActor.ApplyEffect(frostfreeze, 0.015f, null);
}
}
}
private IEnumerator HandleDepartMotion()
{
Transform elevatorTransform = elevatorAnimator.transform;
Vector3 elevatorStartDepartPosition = elevatorTransform.position;
float elapsed = 0f;
float duration = 0.55f;
float yDistance = 20f;
bool hasLayerSwapped = false;
while (elapsed < duration)
{
if (elapsed > 0.15f && !crumblyBumblyAnimator.gameObject.activeSelf)
{
crumblyBumblyAnimator.gameObject.SetActive(true);
crumblyBumblyAnimator.PlayAndDisableObject(string.Empty, null);
}
elapsed += BraveTime.DeltaTime;
float t = Mathf.SmoothStep(0f, 1f, elapsed / duration);
float yOffset = BraveMathCollege.SmoothLerp(0f, -yDistance, t);
if (yOffset < -2f && !hasLayerSwapped)
{
hasLayerSwapped = true;
elevatorAnimator.gameObject.SetLayerRecursively(LayerMask.NameToLayer("BG_Critical"));
}
elevatorTransform.position = elevatorStartDepartPosition + new Vector3(0f, yOffset, 0f);
if (facewallAnimator != null)
{
facewallAnimator.Sprite.UpdateZDepth();
}
yield return(null);
}
yield break;
}
public void SpawnAdditionalProjectile(Projectile proj, SpeculativeRigidbody hitEnemy, bool fatal)
{
if (UnityEngine.Random.value <= 0.35f)
{
float randomAngle = UnityEngine.Random.Range(0f, 360f);
Vector2 spawnPosition = hitEnemy.UnitCenter + BraveMathCollege.DegreesToVector(randomAngle, 3f);
float spawnAngle = randomAngle - 180f;
GameObject obj = SpawnManager.SpawnProjectile(projectileToSpawn.gameObject, spawnPosition, Quaternion.Euler(0f, 0f, spawnAngle), true);
Projectile proj2 = obj.GetComponent <Projectile>();
if (proj2 != null)
{
proj2.Owner = proj.Owner;
proj2.Shooter = proj.Shooter;
if (proj.sprite != null)
{
proj2.shouldRotate = proj.shouldRotate;
proj2.shouldFlipHorizontally = proj.shouldFlipHorizontally;
proj2.shouldFlipVertically = proj.shouldFlipVertically;
proj2.sprite.SetSprite(proj.sprite.Collection, proj.sprite.spriteId);
Vector2 vector = proj2.transform.position.XY() - proj2.sprite.WorldCenter;
proj2.transform.position += vector.ToVector3ZUp(0f);
proj2.specRigidbody.Reinitialize();
}
proj2.baseData.damage = proj.baseData.damage;
proj2.baseData.speed = proj.baseData.speed;
proj2.baseData.force = proj.baseData.force;
}
}
}
private void UpdateReticlePosition()
{
PlayerController user = this.gun.GunPlayerOwner();
if (user)
{
if (BraveInput.GetInstanceForPlayer(user.PlayerIDX).IsKeyboardAndMouse(false))
{
Vector2 vector = user.unadjustedAimPoint.XY();
Vector2 vector2 = vector - this.m_extantReticleQuad.GetBounds().extents.XY();
this.m_extantReticleQuad.transform.position = vector2;
}
else
{
BraveInput instanceForPlayer = BraveInput.GetInstanceForPlayer(user.PlayerIDX);
Vector2 vector3 = user.CenterPosition + (Quaternion.Euler(0f, 0f, this.m_currentAngle) * Vector2.right).XY() * this.m_currentDistance;
vector3 += instanceForPlayer.ActiveActions.Aim.Vector * 12f * BraveTime.DeltaTime;
this.m_currentAngle = BraveMathCollege.Atan2Degrees(vector3 - user.CenterPosition);
this.m_currentDistance = Vector2.Distance(vector3, user.CenterPosition);
this.m_currentDistance = Mathf.Min(this.m_currentDistance, 100);
vector3 = user.CenterPosition + (Quaternion.Euler(0f, 0f, this.m_currentAngle) * Vector2.right).XY() * this.m_currentDistance;
Vector2 vector4 = vector3 - this.m_extantReticleQuad.GetBounds().extents.XY();
this.m_extantReticleQuad.transform.position = vector4;
}
}
}
public override void OnReloadPressedSafe(PlayerController player, Gun gun, bool manualReload)
{
if ((gun.ClipCapacity == gun.ClipShotsRemaining) || (gun.CurrentAmmo == gun.ClipShotsRemaining))
{
if (gun.CurrentAmmo >= 5)
{
if (this.m_extantReticleQuad) //If the cursor is there, then do the teleport
{
gun.CurrentAmmo -= 5;
Vector2 worldCenter = this.m_extantReticleQuad.WorldCenter;
UnityEngine.Object.Destroy(this.m_extantReticleQuad.gameObject);
worldCenter += new Vector2(1.5f, 1.5f);
//worldCenter = new Vector2(Mathf.FloorToInt(worldCenter.x), Mathf.FloorToInt(worldCenter.y));
// UnityEngine.Object.Instantiate<GameObject>((PickupObjectDatabase.GetById(Pencil.pencilID) as Gun).DefaultModule.projectiles[0].gameObject, new Vector3(worldCenter.x, worldCenter.y), Quaternion.identity);
TeleportPlayerToCursorPosition.StartTeleport(player, worldCenter);
}
else //If the cursor is not there, make it
{
GameObject gameObject = UnityEngine.Object.Instantiate <GameObject>(this.reticleQuad);
this.m_extantReticleQuad = gameObject.GetComponent <tk2dBaseSprite>();
this.m_currentAngle = BraveMathCollege.Atan2Degrees(player.unadjustedAimPoint.XY() - player.CenterPosition);
this.m_currentDistance = 5f;
this.UpdateReticlePosition();
}
}
}
}
public string GetAnimationState(PlayerController interactor, out bool shouldBeFlipped)
{
shouldBeFlipped = false;
Vector2 inVec = interactor.CenterPosition - specRigidbody.UnitCenter;
switch (BraveMathCollege.VectorToQuadrant(inVec))
{
case 0:
return("tablekick_down");
case 1:
shouldBeFlipped = true;
return("tablekick_right");
case 2:
return("tablekick_up");
case 3:
return("tablekick_right");
default:
Debug.Log("fail");
return("tablekick_up");
}
}
private Vector2 ModVeloc(Vector2 inVel)
{
Vector2 vector = inVel;
if (m_projectile.GetElapsedDistance() > (distanceLastChecked + 1))
{
float addition;
if (recalcDriftPerCheck)
{
addition = UnityEngine.Random.Range(minDriftPerTile, maxDriftPerTile);
}
else
{
addition = staticAngle;
}
if (randomiseInverseEachCheck && UnityEngine.Random.value <= 0.5f)
{
addition *= -1;
}
float targetAngle = inVel.ToAngle() + addition;
vector = BraveMathCollege.DegreesToVector(targetAngle, inVel.magnitude);
base.transform.rotation = Quaternion.Euler(0f, 0f, targetAngle);
distanceLastChecked = m_projectile.GetElapsedDistance();
}
return(vector);
}
public void OnTileCollision(CollisionData data)
{
if (this.bounces > 0)
{
Vector2 vector = data.Normal;
Vector2 velocity = data.MyRigidbody.Velocity;
float num2 = (-velocity).ToAngle();
float num3 = vector.ToAngle();
float num4 = BraveMathCollege.ClampAngle360(num2 + 2f * (num3 - num2));
this.degrees = num4;
this.bounces--;
}
else
{
//this.ForceBreak();
/*CellData cellData2 = GameManager.Instance.Dungeon.data[data.TilePosition];
* cellData2.breakable = true;
* cellData2.occlusionData.overrideOcclusion = true;
* cellData2.occlusionData.cellOcclusionDirty = true;
* tk2dTileMap map = GameManager.Instance.Dungeon.DestroyWallAtPosition(data.TilePosition.x, data.TilePosition.y, true);
* this.m_owner.CurrentRoom.Cells.Add(cellData2.position);
* this.m_owner.CurrentRoom.CellsWithoutExits.Add(cellData2.position);
* this.m_owner.CurrentRoom.RawCells.Add(cellData2.position);
* if (map)
* {
* GameManager.Instance.Dungeon.RebuildTilemap(map);
* }*/
//base.StartCoroutine(this.HandleCombatRoomExpansion(this.Owner.CurrentRoom, this.Owner.CurrentRoom, null));
this.ForceBreak();
}
}
private void BuildMeshAlongCurve(Vector2 p0, Vector2 p1, Vector2 p2, Vector2 p3, float zOffset)
{
Vector3[] vertices = m_vertices;
Vector2? vector = null;
Vector2 v = p3 - p0;
Vector2 vector2 = (Quaternion.Euler(0f, 0f, 90f) * v).XY();
for (int i = 0; i < 10; i++)
{
Vector2 vector3 = BraveMathCollege.CalculateBezierPoint(i / 9f, p0, p1, p2, p3);
Vector2?vector4 = (i != 9) ? new Vector2?(BraveMathCollege.CalculateBezierPoint(i / 9f, p0, p1, p2, p3)) : null;
Vector2 a = Vector2.zero;
if (vector != null)
{
a += (Quaternion.Euler(0f, 0f, 90f) * (vector3 - vector.Value)).XY().normalized;
}
if (vector4 != null)
{
a += (Quaternion.Euler(0f, 0f, 90f) * (vector4.Value - vector3)).XY().normalized;
}
a = a.normalized;
float d = Mathf.Lerp(StartWidth, EndWidth, i / 9f);
vector3 += vector2.normalized * Mathf.Sin(Time.realtimeSinceStartup * SinSpeed + i * WavelengthMod) * AmplitudeMod * (i / 9f);
vertices[i * 2] = (vector3 + a * d).ToVector3ZisY(zOffset);
vertices[i * 2 + 1] = (vector3 + -a * d).ToVector3ZisY(zOffset);
vector = new Vector2?(vector3);
}
}
// Token: 0x0600489E RID: 18590 RVA: 0x00178EB0 File Offset: 0x001770B0
private void OnTriggerCollision(SpeculativeRigidbody specRigidbody, SpeculativeRigidbody sourceSpecRigidbody, CollisionData collisionData)
{
if ((this.State == WizardSpinShootBehavior2.SpinShootState.Spawn || this.State == WizardSpinShootBehavior2.SpinShootState.Prefire) && collisionData.MyPixelCollider == this.m_bulletCatcher && collisionData.OtherRigidbody != null && collisionData.OtherRigidbody.projectile != null)
{
Projectile projectile = collisionData.OtherRigidbody.projectile;
bool flag = (!this.m_isCharmed) ? (projectile.Owner is PlayerController) : (projectile.Owner is AIActor);
if (flag && projectile.CanBeCaught)
{
projectile.specRigidbody.DeregisterSpecificCollisionException(projectile.Owner.specRigidbody);
projectile.Shooter = this.m_aiActor.specRigidbody;
projectile.Owner = this.m_aiActor;
projectile.specRigidbody.Velocity = Vector2.zero;
projectile.ManualControl = true;
projectile.baseData.SetAll(EnemyDatabase.GetOrLoadByGuid("c4fba8def15e47b297865b18e36cbef8").bulletBank.GetBullet("default").ProjectileData);
projectile.UpdateSpeed();
projectile.specRigidbody.CollideWithTileMap = false;
projectile.ResetDistance();
projectile.collidesWithEnemies = this.m_isCharmed;
projectile.collidesWithPlayer = true;
projectile.UpdateCollisionMask();
projectile.sprite.color = new Color(1f, 0.1f, 0.1f);
projectile.MakeLookLikeEnemyBullet(true);
projectile.RemovePlayerOnlyModifiers();
float second = BraveMathCollege.ClampAngle360((collisionData.Contact - this.ShootPoint.position.XY()).ToAngle());
this.m_bulletPositions.Insert(Mathf.Max(0, this.m_bulletPositions.Count - 1), Tuple.Create <Projectile, float>(projectile, second));
}
}
}
public static Vector2 AdjustInputVector(Vector2 rawInput, float cardinalMagnetAngle, float ordinalMagnetAngle)
{
float num = BraveMathCollege.ClampAngle360(BraveMathCollege.Atan2Degrees(rawInput));
float num2 = num % 90f;
float num3 = (num + 45f) % 90f;
float num4 = 0f;
if (cardinalMagnetAngle > 0f)
{
if (num2 < cardinalMagnetAngle)
{
num4 = -num2;
}
else if (num2 > 90f - cardinalMagnetAngle)
{
num4 = 90f - num2;
}
}
if (ordinalMagnetAngle > 0f)
{
if (num3 < ordinalMagnetAngle)
{
num4 = -num3;
}
else if (num3 > 90f - ordinalMagnetAngle)
{
num4 = 90f - num3;
}
}
num += num4;
return((Quaternion.Euler(0f, 0f, num) * Vector3.right).XY() * rawInput.magnitude);
}
private void UpdatePosition(AIActor targetActor = null)
{
Vector2 unitBottomLeft = m_room.area.UnitBottomLeft;
Vector2 unitTopRight = m_room.area.UnitTopRight;
if (TracksRandomEnemy)
{
if (targetActor != null && targetActor.healthHaver != null)
{
if (!targetActor.healthHaver.IsDead)
{
if (targetActor.specRigidbody)
{
m_LastKnownPosition = targetActor.specRigidbody.GetUnitCenter(ColliderType.Ground);
}
else
{
m_LastKnownPosition = targetActor.sprite.WorldCenter;
}
}
}
}
else
{
m_LastKnownPosition = m_targetPlayer.CenterPosition;
}
m_LastKnownPosition = BraveMathCollege.ClampToBounds(m_LastKnownPosition, unitBottomLeft + Vector2.one, unitTopRight - Vector2.one);
transform.position = (m_LastKnownPosition - m_targetOffset).Quantize(0.0625f);
TargetAnimator.sprite.UpdateZDepth();
sprite.UpdateZDepth();
}
private static void DealDamageToEnemiesInArc(PlayerController owner, Vector2 arcOrigin, float arcAngle, float arcRadius, float overrideDamage, float overrideForce, List <GameActorEffect> statusEffects, float jammedDMGMult, float bossDMGMult, float slashDimensions, List <SpeculativeRigidbody> alreadyHit = null)
{
RoomHandler roomHandler = owner.CurrentRoom;
if (roomHandler == null)
{
return;
}
List <AIActor> activeEnemies = roomHandler.GetActiveEnemies(RoomHandler.ActiveEnemyType.All);
if (activeEnemies == null)
{
return;
}
for (int i = 0; i < activeEnemies.Count; i++)
{
AIActor aiactor = activeEnemies[i];
if (aiactor && aiactor.specRigidbody && aiactor.IsNormalEnemy && !aiactor.IsGone && aiactor.healthHaver)
{
if (alreadyHit == null || !alreadyHit.Contains(aiactor.specRigidbody))
{
for (int j = 0; j < aiactor.healthHaver.NumBodyRigidbodies; j++)
{
SpeculativeRigidbody bodyRigidbody = aiactor.healthHaver.GetBodyRigidbody(j);
PixelCollider hitboxPixelCollider = bodyRigidbody.HitboxPixelCollider;
if (hitboxPixelCollider != null)
{
Vector2 vector = BraveMathCollege.ClosestPointOnRectangle(arcOrigin, hitboxPixelCollider.UnitBottomLeft, hitboxPixelCollider.UnitDimensions);
float num = Vector2.Distance(vector, arcOrigin);
if (ObjectWasHitBySlash(vector, arcOrigin, arcAngle, arcRadius, slashDimensions))
{
bool flag = true;
int rayMask = CollisionMask.LayerToMask(CollisionLayer.HighObstacle, CollisionLayer.BulletBlocker, CollisionLayer.BulletBreakable);
RaycastResult raycastResult;
if (PhysicsEngine.Instance.Raycast(arcOrigin, vector - arcOrigin, num, out raycastResult, true, true, rayMask, null, false, null, null) && raycastResult.SpeculativeRigidbody != bodyRigidbody)
{
flag = false;
}
RaycastResult.Pool.Free(ref raycastResult);
if (flag)
{
float damage = DealSwordDamageToEnemy(owner, aiactor, arcOrigin, vector, arcAngle, overrideDamage, overrideForce, statusEffects, bossDMGMult, jammedDMGMult);
if (alreadyHit != null)
{
if (alreadyHit.Count == 0)
{
StickyFrictionManager.Instance.RegisterSwordDamageStickyFriction(damage);
}
alreadyHit.Add(aiactor.specRigidbody);
}
break;
}
}
}
}
}
}
}
}
// Token: 0x060003CB RID: 971 RVA: 0x00023570 File Offset: 0x00021770
private void Attack()
{
bool flag = this.Owner == null;
bool flag2 = flag;
if (flag2)
{
this.Owner = this.m_aiActor.GetComponent <Winpetster.WinpetsterBehavior>().Owner;
}
float num = -1f;
List <AIActor> activeEnemies = this.Owner.CurrentRoom.GetActiveEnemies(RoomHandler.ActiveEnemyType.All);
bool flag3 = activeEnemies == null | activeEnemies.Count <= 0;
bool flag4 = !flag3;
if (flag4)
{
AIActor nearestEnemy = this.GetNearestEnemy(activeEnemies, this.m_aiActor.sprite.WorldCenter, out num, null);
bool flag5 = nearestEnemy && num < 10f;
bool flag6 = flag5;
if (flag6)
{
bool flag7 = this.IsInRange(nearestEnemy);
bool flag8 = flag7;
if (flag8)
{
bool flag9 = !nearestEnemy.IsHarmlessEnemy && nearestEnemy.IsNormalEnemy && !nearestEnemy.healthHaver.IsDead && nearestEnemy != this.m_aiActor;
bool flag10 = flag9;
if (flag10)
{
Vector2 unitCenter = this.m_aiActor.specRigidbody.UnitCenter;
Vector2 unitCenter2 = nearestEnemy.specRigidbody.HitboxPixelCollider.UnitCenter;
float z = BraveMathCollege.Atan2Degrees((unitCenter2 - unitCenter).normalized);
Projectile projectile = ((Gun)ETGMod.Databases.Items[1]).DefaultModule.projectiles[0];
GameObject gameObject = SpawnManager.SpawnProjectile(projectile.gameObject, this.m_aiActor.sprite.WorldCenter, Quaternion.Euler(0f, 0f, z), true);
Projectile component = gameObject.GetComponent <Projectile>();
bool flag11 = component != null;
bool flag12 = flag11;
bool flag13 = flag12;
if (flag13)
{
component.Owner = this.Owner;
component.Shooter = this.m_aiActor.specRigidbody;
bool flag14 = this.Owner.HasPickupID(402) || this.Owner.HasPickupID(1);
if (flag14)
{
component.baseData.damage = 4f;
component.AdditionalScaleMultiplier = 2f;
}
else
{
component.baseData.damage = 2.5f;
}
component.baseData.force = 1f;
component.collidesWithPlayer = false;
}
}
}
}
}
}
public void Update()
{
if (!m_isActive && SetState(null) == ExpandHammerState.Gone)
{
return;
}
if (m_isActive && SetState(null) == ExpandHammerState.Gone)
{
Vector2 unitBottomLeft = m_room.area.UnitBottomLeft;
Vector2 unitTopRight = m_room.area.UnitTopRight;
int num = 0;
for (int i = 0; i < GameManager.Instance.AllPlayers.Length; i++)
{
PlayerController playerController = GameManager.Instance.AllPlayers[i];
if (playerController && playerController.healthHaver.IsAlive)
{
Vector2 centerPosition = playerController.CenterPosition;
if (BraveMathCollege.AABBContains(unitBottomLeft - Vector2.one, unitTopRight + Vector2.one, centerPosition))
{
num++;
}
}
}
if (num == 0)
{
Deactivate();
}
}
m_timer = Mathf.Max(0f, m_timer - LocalDeltaTime);
UpdateState(SetState(null));
}
public override ContinuousBehaviorResult ContinuousUpdate()
{
base.ContinuousUpdate();
if (this.ContinuesOnPathComplete)
{
this.m_aiAnimator.OverrideIdleAnimation = "idle_shoot";
}
if (this.m_remainingDuration <= 0f || !this.m_aiActor.TargetRigidbody || (this.m_aiActor.PathComplete && !this.ContinuesOnPathComplete))
{
return(ContinuousBehaviorResult.Finished);
}
float remainingPercentage = 1f - this.m_remainingDuration / this.m_totalDuration;
float baseAngle = remainingPercentage * (float)this.SprayIterations % 2f;
float angle = (this.m_aiActor.TargetRigidbody.GetUnitCenter(ColliderType.HitBox) - this.m_aiShooter.volleyShootPosition.position.XY()).ToAngle();
angle = BraveMathCollege.QuantizeFloat(angle, 45f);
angle += -this.SprayAngle / 2f + Mathf.PingPong(baseAngle * this.SprayAngle, this.SprayAngle);
this.m_aiShooter.ShootInDirection(Quaternion.Euler(0f, 0f, angle) * Vector2.right, this.OverrideBulletName);
return(ContinuousBehaviorResult.Continue);
}
protected override void DoEffect(PlayerController player)
{
Vector2 vector = player.unadjustedAimPoint.XY() - player.CenterPosition;
float zRotation = BraveMathCollege.Atan2Degrees(vector);
player.StartCoroutine(this.HandleSwing(player, vector, 1f, 20f));
}
public IEnumerator HandleDash(PlayerController target, Projectile projectile)
{
float duration = 1f;
float elapsed = -BraveTime.DeltaTime;
float angle = gun.CurrentOwner.CurrentGun.CurrentAngle;
float adjSpeed = 100;
this.gun.CanBeDropped = false;
target.inventory.GunLocked.SetOverride("Nen Dash", true, null);
target.ReceivesTouchDamage = false;
target.SetIsFlying(true, "nen fist", true, false);
duration = .15f;
adjSpeed = 90;
SpeculativeRigidbody specRigidbody = target.specRigidbody;
specRigidbody.OnPreRigidbodyCollision = (SpeculativeRigidbody.OnPreRigidbodyCollisionDelegate)Delegate.Combine(specRigidbody.OnPreRigidbodyCollision, new SpeculativeRigidbody.OnPreRigidbodyCollisionDelegate(this.OnPreCollision));
target.healthHaver.IsVulnerable = false;
while (elapsed < duration)
{
elapsed += BraveTime.DeltaTime;
gun.CurrentOwner.specRigidbody.Velocity = BraveMathCollege.DegreesToVector(angle).normalized *adjSpeed;
yield return(null);
}
target.ReceivesTouchDamage = true;
this.gun.CanBeDropped = true;
target.inventory.GunLocked.RemoveOverride("Nen Dash");
if (adjSpeed == 90)
{
target.healthHaver.IsVulnerable = true;
SpeculativeRigidbody specRigidbody2 = target.specRigidbody;
specRigidbody2.OnPreRigidbodyCollision = (SpeculativeRigidbody.OnPreRigidbodyCollisionDelegate)Delegate.Remove(specRigidbody2.OnPreRigidbodyCollision, new SpeculativeRigidbody.OnPreRigidbodyCollisionDelegate(this.OnPreCollision));
}
target.SetIsFlying(false, "nen fist", true, false);
}
public string GetAnimationState(PlayerController interactor, out bool shouldBeFlipped)
{
shouldBeFlipped = false;
Vector2 inVec = interactor.CenterPosition - specRigidbody.UnitCenter;
switch (BraveMathCollege.VectorToQuadrant(inVec))
{
case 0:
return("tablekick_down");
case 1:
shouldBeFlipped = true;
return("tablekick_right");
case 2:
return("tablekick_up");
case 3:
return("tablekick_right");
default:
Debug.Log("[ExpandKickableObject] Failed to find table animation state. Using fall back 'tablekick_up' instead.");
return("tablekick_up");
}
}
private void AimAt(GameObject obj, Vector2 point)
{
Vector2 v = point - obj.transform.position.XY();
float currentAimTarget = BraveMathCollege.Atan2Degrees(v);
obj.transform.rotation = Quaternion.Euler(0f, 0f, currentAimTarget);
}
public static bool PositionBetweenRelativeValidAngles(this Vector2 positionToCheck, Vector2 startPosition, float centerAngle, float range, float validAngleVariation)
{
if (Vector2.Distance(positionToCheck, startPosition) < range)
{
float num7 = BraveMathCollege.Atan2Degrees(positionToCheck - startPosition);
float minRawAngle = Math.Min(validAngleVariation, -validAngleVariation);
float maxRawAngle = Math.Max(validAngleVariation, -validAngleVariation);
bool isInRange = false;
float actualMaxAngle = centerAngle + maxRawAngle;
float actualMinAngle = centerAngle + minRawAngle;
if (num7.IsBetweenRange(actualMinAngle, actualMaxAngle))
{
isInRange = true;
}
if (actualMaxAngle > 180)
{
float Overflow = actualMaxAngle - 180;
if (num7.IsBetweenRange(-180, (-180 + Overflow)))
{
isInRange = true;
}
}
if (actualMinAngle < -180)
{
float Underflow = actualMinAngle + 180;
if (num7.IsBetweenRange((180 + Underflow), 180))
{
isInRange = true;
}
}
return(isInRange);
}
return(false);
}
private IEnumerator HandleFireShortBeam(Projectile projectileToSpawn, float duration)
{
float elapsed = 0f;
float num2 = -1f;
AIActor aiactor2 = this.m_extantOrbital.transform.position.GetAbsoluteRoom().GetNearestEnemy(this.m_extantOrbital.GetComponent <tk2dBaseSprite>().WorldCenter, out num2, true, true);
BeamController beam = this.BeginFiringBeam(projectileToSpawn, this.m_owner, BraveMathCollege.Atan2Degrees(aiactor2.sprite.WorldCenter - this.m_extantOrbital.GetComponent <tk2dSprite>().WorldCenter),
this.m_extantOrbital.GetComponent <tk2dBaseSprite>().WorldCenter);
yield return(null);
while (elapsed < duration)
{
if (!this || !this.m_extantOrbital || this.m_extantOrbital.transform.position.GetAbsoluteRoom() == null)
{
break;
}
float num = -1f;
AIActor aiactor = this.m_extantOrbital.transform.position.GetAbsoluteRoom().GetNearestEnemy(this.m_extantOrbital.GetComponent <tk2dBaseSprite>().WorldCenter, out num, true, true);
if (aiactor == null)
{
break;
}
elapsed += BraveTime.DeltaTime;
this.ContinueFiringBeam(beam, BraveMathCollege.Atan2Degrees(aiactor.sprite.WorldCenter - this.m_extantOrbital.GetComponent <tk2dSprite>().WorldCenter), this.m_extantOrbital.GetComponent <tk2dBaseSprite>().WorldCenter);
yield return(null);
}
this.CeaseBeam(beam);
yield break;
}
private IEnumerator DoDistortionWaveLocal(Vector2 center, float distortionIntensity, float distortionRadius, float maxRadius, float duration)
{
Material distMaterial = new Material(ShaderCache.Acquire("Brave/Internal/DistortionWave"));
Vector4 distortionSettings = GetCenterPointInScreenUV(center, distortionIntensity, distortionRadius);
distMaterial.SetVector("_WaveCenter", distortionSettings);
Pixelator.Instance.RegisterAdditionalRenderPass(distMaterial);
float elapsed = 0f;
while (elapsed < duration)
{
elapsed += BraveTime.DeltaTime;
float t = elapsed / duration;
t = BraveMathCollege.LinearToSmoothStepInterpolate(0f, 1f, t);
distortionSettings = GetCenterPointInScreenUV(center, distortionIntensity, distortionRadius);
distortionSettings.w = Mathf.Lerp(distortionSettings.w, 0f, t);
distMaterial.SetVector("_WaveCenter", distortionSettings);
float currentRadius = Mathf.Lerp(0f, maxRadius, t);
distMaterial.SetFloat("_DistortProgress", currentRadius / maxRadius * (maxRadius / 33.75f));
yield return(null);
}
Pixelator.Instance.DeregisterAdditionalRenderPass(distMaterial);
Destroy(distMaterial);
yield break;
}
private IEnumerator HandleFiringBeam(BeamController beam)
{
float elapsed = 0f;
yield return(null);
while (m_Player && m_Player.IsFiring && this && m_AIActor.sprite && m_AIActor.healthHaver && !m_IsDisconnected)
{
elapsed += BraveTime.DeltaTime;
if (!m_AIActor.TargetRigidbody)
{
m_AIActor.PlayerTarget = m_Player;
}
if (!m_MirrorGunToggle)
{
beam.CeaseAttack();
beam.DestroyBeam();
yield break;
}
if (m_AIActor.CurrentGun)
{
beam.Origin = m_AIActor.CurrentGun.sprite.WorldCenter;
beam.LateUpdatePosition(m_AIActor.CurrentGun.sprite.WorldCenter);
}
else
{
beam.Origin = m_AIActor.specRigidbody.UnitCenter;
beam.LateUpdatePosition(m_AIActor.specRigidbody.UnitCenter);
}
// beam.Origin = m_AIActor.specRigidbody.UnitCenter;
// beam.LateUpdatePosition(m_AIActor.specRigidbody.UnitCenter);
if (m_Player)
{
float angle = ((m_AIActor.TargetRigidbody.GetUnitCenter(ColliderType.HitBox) - m_AIActor.specRigidbody.UnitCenter).ToAngle());
if (m_AIActor.CurrentGun)
{
angle = ((m_AIActor.TargetRigidbody.GetUnitCenter(ColliderType.HitBox) - m_AIActor.CurrentGun.sprite.WorldCenter).ToAngle());
}
if (m_InvertSweepAngle)
{
angle = (angle + m_BeamSweepAngle);
}
else
{
angle = (angle - m_BeamSweepAngle);
}
beam.Direction = BraveMathCollege.DegreesToVector(angle, 1);
if (m_Player.IsDodgeRolling)
{
beam.CeaseAttack();
beam.DestroyBeam();
yield break;
}
}
yield return(null);
}
beam.CeaseAttack();
beam.DestroyBeam();
yield break;
}
private static bool ObjectWasHitBySlash(Vector2 ObjectPosition, Vector2 SlashPosition, float slashAngle, float SlashRange, float SlashDimensions)
{
if (Vector2.Distance(ObjectPosition, SlashPosition) < SlashRange)
{
float num7 = BraveMathCollege.Atan2Degrees(ObjectPosition - SlashPosition);
float minRawAngle = Math.Min(SlashDimensions, -SlashDimensions);
float maxRawAngle = Math.Max(SlashDimensions, -SlashDimensions);
bool isInRange = false;
float actualMaxAngle = slashAngle + maxRawAngle;
float actualMinAngle = slashAngle + minRawAngle;
if (num7.IsBetweenRange(actualMinAngle, actualMaxAngle))
{
isInRange = true;
}
if (actualMaxAngle > 180)
{
float Overflow = actualMaxAngle - 180;
if (num7.IsBetweenRange(-180, (-180 + Overflow)))
{
isInRange = true;
}
}
if (actualMinAngle < -180)
{
float Underflow = actualMinAngle + 180;
if (num7.IsBetweenRange((180 + Underflow), 180))
{
isInRange = true;
}
}
return(isInRange);
}
return(false);
}
void Update()
{
if (projectile)
{
Vector2 position = projectile.specRigidbody.UnitCenter;
Vector2 direction = projectile.LastVelocity.normalized;
int thePointOfTheMaskIs = CollisionMask.LayerToMask(CollisionLayer.HighObstacle, CollisionLayer.BulletBlocker, CollisionLayer.EnemyHitBox, CollisionLayer.BulletBreakable);
PhysicsEngine.Instance.Raycast(position, direction, 100f, out RaycastResult result, true, true, thePointOfTheMaskIs);
if (result != null && result.Contact != null)
{
tk2dTiledSprite component = SpawnManager.SpawnVFX(linkVFXPrefab, false).GetComponent <tk2dTiledSprite>();
PostBeamRender(component);
Vector2 unitCenter = position;
Vector2 unitCenter2 = result.Contact;
component.transform.position = unitCenter;
Vector2 vector = unitCenter2 - unitCenter;
float num = BraveMathCollege.Atan2Degrees(vector.normalized);
int num2 = Mathf.RoundToInt(vector.magnitude / 0.0625f);
component.dimensions = new Vector2((float)num2, component.dimensions.y);
component.transform.rotation = Quaternion.Euler(0f, 0f, num);
component.UpdateZDepth();
ETGMod.StartGlobalCoroutine(doTimerMagic(component.gameObject, wait));
OnBeamHit(result.Contact, projectile);
}
projectile.DieInAir();
}
}
protected override void DoEffect(PlayerController player)
{
if (numberOfUses == 2)
{
Vector2 vector = player.unadjustedAimPoint.XY() - player.CenterPosition;
float zRotation = BraveMathCollege.Atan2Degrees(vector);
player.StartCoroutine(this.HandleSwing(player, vector, 0f, 20f));
}
if (numberOfUses == 1)
{
player.CurrentStoneGunTimer = 1f;
player.MovementModifiers -= this.NoMotionModifier;
player.IsStationary = false;
modifierController = 0;
player.IsEthereal = false;
if (host != null)
{
host.healthHaver.ApplyDamage(99999, Vector2.zero, "unbound", CoreDamageTypes.Magic, DamageCategory.Unstoppable, true, null, false);
host = null;
}
player.SetIsStealthed(false, "cause they just are");
PassiveItem.DecrementFlag(player, typeof(LiveAmmoItem));
this.LastOwner.stats.RecalculateStats(LastOwner, true);
CamToggle = 0;
GameManager.Instance.MainCameraController.StartTrackingPlayer();
GameManager.Instance.MainCameraController.SetManualControl(false, true);
}
}
public void SpawnShards(Vector2 direction, float minAngle, float maxAngle, float verticalSpeed, float minMagnitude, float maxMagnitude)
{
Vector3 position = specRigidbody.GetUnitCenter(ColliderType.HitBox);
if (shardClusters != null && shardClusters.Length > 0)
{
int num = Random.Range(0, 10);
for (int i = 0; i < shardClusters.Length; i++)
{
ShardCluster shardCluster = shardClusters[i];
int num2 = Random.Range(shardCluster.minFromCluster, shardCluster.maxFromCluster + 1);
int num3 = Random.Range(0, shardCluster.clusterObjects.Length);
for (int j = 0; j < num2; j++)
{
float lowDiscrepancyRandom = BraveMathCollege.GetLowDiscrepancyRandom(num);
num++;
float z = Mathf.Lerp(minAngle, maxAngle, lowDiscrepancyRandom);
Vector3 vector = Quaternion.Euler(0f, 0f, z) * (direction.normalized * Random.Range(minMagnitude, maxMagnitude)).ToVector3ZUp(verticalSpeed);
int num4 = (num3 + j) % shardCluster.clusterObjects.Length;
GameObject gameObject = SpawnManager.SpawnDebris(shardCluster.clusterObjects[num4].gameObject, position, Quaternion.identity);
tk2dSprite component = gameObject.GetComponent <tk2dSprite>();
if (sprite.attachParent != null && component != null)
{
component.attachParent = sprite.attachParent;
component.HeightOffGround = sprite.HeightOffGround;
}
DebrisObject component2 = gameObject.GetComponent <DebrisObject>();
vector = Vector3.Scale(vector, shardCluster.forceAxialMultiplier) * shardCluster.forceMultiplier;
component2.Trigger(vector, heightOffGround, shardCluster.rotationMultiplier);
}
}
}
}
protected override void DoActiveEffect(PlayerController user)
{
base.DoActiveEffect(user);
if (user.healthHaver != null)
{
user.healthHaver.TriggerInvulnerabilityPeriod(0.5f);
}
this.m_currentlyHeldEnemy.Dismount();
AIActor aiActor = this.m_currentlyHeldEnemy;
KnockbackDoer knockbackDoer = aiActor.knockbackDoer;
if (aiActor)
{
if (aiActor.specRigidbody != null)
{
aiActor.specRigidbody.AddCollisionLayerOverride(CollisionMask.LayerToMask(CollisionLayer.EnemyHitBox));
aiActor.specRigidbody.OnPreRigidbodyCollision += new SpeculativeRigidbody.OnPreRigidbodyCollisionDelegate(this.HandleHitEnemyHitEnemy);
aiActor.specRigidbody.OnPreTileCollision += new SpeculativeRigidbody.OnPreTileCollisionDelegate(this.HandleHitTile);
}
}
if (knockbackDoer)
{
BraveInput instanceForPlayer = BraveInput.GetInstanceForPlayer(GameManager.Instance.PrimaryPlayer.PlayerIDX);
bool flag2 = instanceForPlayer == null;
if (!flag2)
{
Vector2 vector = GameManager.Instance.PrimaryPlayer.unadjustedAimPoint.XY() - user.CenterPosition;
Vector2 direction = BraveMathCollege.DegreesToVector(BraveMathCollege.Atan2Degrees(vector), 1);
knockbackDoer.ApplyKnockback(direction, 800f, true);
}
}
this.m_currentlyHeldEnemy = null;
}
public override BehaviorResult Update()
{
SpeculativeRigidbody targetRigidbody = this.m_aiActor.TargetRigidbody;
if (!(targetRigidbody != null))
{
return(BehaviorResult.Continue);
}
float desiredCombatDistance = this.m_aiActor.DesiredCombatDistance;
if (this.StopWhenInRange && this.m_aiActor.DistanceToTarget <= desiredCombatDistance)
{
this.m_aiActor.ClearPath();
return(BehaviorResult.Continue);
}
if (this.m_repathTimer <= 0f)
{
Vector2 targetPosition;
if (!this.m_otherBro)
{
m_otherBro = ExpandWesternBroController.GetOtherWesternBros(this.m_aiActor).FirstOrDefault();
}
if (!this.m_otherBro)
{
targetPosition = targetRigidbody.UnitCenter;
}
else
{
Vector2 unitCenter = this.m_aiActor.TargetRigidbody.specRigidbody.GetUnitCenter(ColliderType.HitBox);
Vector2 unitCenter2 = this.m_aiActor.specRigidbody.UnitCenter;
Vector2 unitCenter3 = this.m_otherBro.specRigidbody.UnitCenter;
float num = (unitCenter2 - unitCenter).ToAngle();
float num2 = (unitCenter3 - unitCenter).ToAngle();
float num3 = (num + num2) / 2f;
float angle;
if (BraveMathCollege.ClampAngle180(num - num3) > 0f)
{
angle = num3 + 90f;
}
else
{
angle = num3 - 90f;
}
targetPosition = unitCenter + BraveMathCollege.DegreesToVector(angle, 1f) * this.DesiredCombatDistance;
}
this.m_aiActor.PathfindToPosition(targetPosition, null, true, null, null, null, false);
this.m_repathTimer = this.PathInterval;
}
return(BehaviorResult.SkipRemainingClassBehaviors);
}