using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using Il2Cpp;
using Il2CppHurricaneVR.Framework.Core.Grabbers;
using Il2CppInterop.Runtime.InteropTypes.Arrays;
using Il2CppSystem;
using Il2CppSystem.Reflection;
using MelonLoader;
using RedBlueMod;
using UnityEngine;
using UnityEngine.Rendering;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: MelonInfo(typeof(Core), "RedBlueMod", "3.2.0", "YourName", null)]
[assembly: MelonGame("Kubunautilus", "BrutalistickVR")]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyCompany("cursedtechnique")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("cursedtechnique")]
[assembly: AssemblyTitle("cursedtechnique")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace RedBlueMod;
public class Core : MelonMod
{
private enum State
{
Idle,
Charging,
Ready,
Cooldown
}
private enum OrbType
{
Red,
Blue
}
public static HVRHexaBodyInputs playerInputs;
public static HVRHandGrabber leftHand;
public static HVRHandGrabber rightHand;
private State leftState = State.Idle;
private State rightState = State.Idle;
private GameObject leftBall;
private GameObject rightBall;
private float leftCharge;
private float rightCharge;
private bool wasLeftStick;
private bool wasRightStick;
private float leftChargeParticleTimer;
private float rightChargeParticleTimer;
private const float CHARGE_SPEED = 0.5f;
private const float MAX_CHARGE = 1f;
private const float MIN_SIZE = 0.02f;
private const float MAX_SIZE = 0.08f;
private const float COOLDOWN = 0.4f;
private const float MIN_CHARGE_TO_SHOOT = 0.15f;
private const float RED_SHOOT_SPEED = 15f;
private const float BLUE_SHOOT_SPEED = 7.5f;
private const float RED_TRACK_LIFETIME = 5f;
private const float RED_EXPLOSION_RADIUS_MIN = 3f;
private const float RED_EXPLOSION_RADIUS_MAX = 7f;
private const float RED_EXPLOSION_POWER_MIN = 100f;
private const float RED_EXPLOSION_POWER_MAX = 300f;
private const float RED_EXPLOSION_DAMAGE_MIN = 30f;
private const float RED_EXPLOSION_DAMAGE_MAX = 100f;
private const float RED_FLIGHT_PARTICLE_INTERVAL = 0.06f;
private const int RED_EXPLOSION_PARTICLE_COUNT = 30;
private const float BLUE_FLIGHT_TIME = 0.5f;
private const float BLUE_SLOWDOWN_TIME = 1f;
private const float BLUE_COLLISION_CHECK_RADIUS = 0.2f;
private const float BLUE_HOLE_DURATION = 10f;
private const float BLUE_HOLE_GROW_MULTIPLIER = 10f;
private const float BLUE_HOLE_RADIUS_GROW_MULTIPLIER = 3f;
private const float BLUE_PULL_RADIUS_MIN = 2f;
private const float BLUE_PULL_RADIUS_MAX = 5f;
private const float BLUE_PULL_FORCE_MIN = 30f;
private const float BLUE_PULL_FORCE_MAX = 80f;
private const float BLUE_PULL_DAMAGE_PER_SECOND_MIN = 5f;
private const float BLUE_PULL_DAMAGE_PER_SECOND_MAX = 20f;
private const float BLUE_FLIGHT_PARTICLE_INTERVAL = 0.07f;
private const float BLUE_ACTIVATION_PARTICLE_INTERVAL = 0.15f;
private const int BLUE_ACTIVATION_PARTICLE_COUNT = 2;
private const float BLUE_PARTICLE_SIZE_MIN = 0.008f;
private const float BLUE_PARTICLE_SIZE_MAX = 0.025f;
private const float PURPLE_FUSION_DETECTION_RADIUS = 2.5f;
private const float PURPLE_FUSION_COOLDOWN = 30f;
private const float PURPLE_FUSION_MOVE_TO_ORBIT_TIME = 0.2f;
private const float PURPLE_FUSION_HOLD_TIME = 0.5f;
private const float PURPLE_FUSION_ACCEL_TIME = 3f;
private const float PURPLE_FUSION_CONSTANT_ORBIT_TIME = 4f;
private const float PURPLE_FUSION_SPIRAL_TIME = 4f;
private const float PURPLE_FUSION_ORBIT_RADIUS_MIN = 1.2f;
private const float PURPLE_FUSION_ORBIT_RADIUS_MAX = 3f;
private const float PURPLE_FUSION_END_RADIUS = 0.15f;
private const float PURPLE_FUSION_MAX_ROTATIONS_PER_SECOND = 1f;
private const float PURPLE_FUSION_SPIRAL_SPEED_MULTIPLIER = 1.35f;
private const float PURPLE_BALL_SIZE = 1.6f;
private const float PURPLE_GROW_TIME = 5f;
private const float PURPLE_EXPLOSION_RADIUS = 14f;
private const float PURPLE_EXPLOSION_POWER = 1200f;
private const float PURPLE_EXPLOSION_DAMAGE = 400f;
private const float PURPLE_PARTICLE_SIZE_MIN = 0.016f;
private const float PURPLE_PARTICLE_SIZE_MAX = 0.05f;
private const int PURPLE_ACTIVATION_PARTICLE_COUNT = 6;
private const float PURPLE_ACTIVATION_PARTICLE_INTERVAL = 0.15f;
private const int PURPLE_EXPLOSION_PARTICLE_COUNT = 24;
private const float PURPLE_SHOCKWAVE_DURATION = 0.8f;
private const float PURPLE_SHOCKWAVE_START_ALPHA = 0.35f;
private const float CHARGE_PARTICLE_INTERVAL = 0.03f;
private const float READY_PARTICLE_MIN_CHARGE = 0.7f;
private const float READY_BLUE_PARTICLE_INTERVAL = 0.25f;
private const float READY_RED_PARTICLE_INTERVAL = 0.25f;
private const int MAX_PARTICLES = 250;
private int activeParticles;
private Material redParticleMaterial;
private Material blueParticleMaterial;
private Material purpleParticleMaterial;
private bool purpleFusionActive;
private float purpleCooldownEndTime = -1f;
private readonly List<GameObject> activeBlueHoles = new List<GameObject>();
private readonly HashSet<GameObject> fusionLockedRedBalls = new HashSet<GameObject>();
private readonly HashSet<GameObject> fusionLockedBlueBalls = new HashSet<GameObject>();
public override void OnInitializeMelon()
{
((MelonBase)this).LoggerInstance.Msg("RedBlueMod v3.2.0 — зарядные частицы, горизонтальная орбита, взрывная волна.");
}
public override void OnSceneWasLoaded(int buildIndex, string sceneName)
{
ResetState();
if (sceneName == "MainMenuScene")
{
return;
}
GameObject val = GameObject.Find("Hexa4Rig26.10.23");
if ((Object)(object)val == (Object)null)
{
((MelonBase)this).LoggerInstance.Warning("Hexa4Rig26.10.23 не найден!");
return;
}
playerInputs = val.GetComponentInChildren<HVRHexaBodyInputs>();
Transform obj = val.transform.Find("Physics LeftHand");
leftHand = ((obj != null) ? ((Component)obj).GetComponent<HVRHandGrabber>() : null);
Transform obj2 = val.transform.Find("Physics RightHand");
rightHand = ((obj2 != null) ? ((Component)obj2).GetComponent<HVRHandGrabber>() : null);
if ((Object)(object)leftHand == (Object)null || (Object)(object)rightHand == (Object)null)
{
((MelonBase)this).LoggerInstance.Warning("Руки не найдены!");
}
else
{
((MelonBase)this).LoggerInstance.Msg("RedBlueMod v3.2.0 загружен.");
}
}
private void ResetState()
{
leftState = State.Idle;
rightState = State.Idle;
leftBall = null;
rightBall = null;
leftCharge = 0f;
rightCharge = 0f;
wasLeftStick = false;
wasRightStick = false;
leftChargeParticleTimer = 0f;
rightChargeParticleTimer = 0f;
playerInputs = null;
leftHand = null;
rightHand = null;
activeParticles = 0;
if ((Object)(object)redParticleMaterial != (Object)null)
{
Object.Destroy((Object)(object)redParticleMaterial);
}
if ((Object)(object)blueParticleMaterial != (Object)null)
{
Object.Destroy((Object)(object)blueParticleMaterial);
}
if ((Object)(object)purpleParticleMaterial != (Object)null)
{
Object.Destroy((Object)(object)purpleParticleMaterial);
}
redParticleMaterial = null;
blueParticleMaterial = null;
purpleParticleMaterial = null;
purpleFusionActive = false;
purpleCooldownEndTime = -1f;
activeBlueHoles.Clear();
fusionLockedRedBalls.Clear();
fusionLockedBlueBalls.Clear();
}
public override void OnUpdate()
{
//IL_004d: Unknown result type (might be due to invalid IL or missing references)
//IL_0062: Unknown result type (might be due to invalid IL or missing references)
if (!((Object)(object)playerInputs == (Object)null) && !((Object)(object)playerInputs.LeftController == (Object)null) && !((Object)(object)playerInputs.RightController == (Object)null))
{
bool active = playerInputs.LeftController.JoystickButtonState.Active;
bool active2 = playerInputs.RightController.JoystickButtonState.Active;
ProcessHand(isLeft: true, active, wasLeftStick, ref leftState, ref leftBall, ref leftCharge, leftHand, OrbType.Blue);
ProcessHand(isLeft: false, active2, wasRightStick, ref rightState, ref rightBall, ref rightCharge, rightHand, OrbType.Red);
UpdateHandChargeParticles(leftBall, leftState, leftCharge, OrbType.Blue, ref leftChargeParticleTimer);
UpdateHandChargeParticles(rightBall, rightState, rightCharge, OrbType.Red, ref rightChargeParticleTimer);
wasLeftStick = active;
wasRightStick = active2;
}
}
private void ProcessHand(bool isLeft, bool stick, bool wasStick, ref State state, ref GameObject ball, ref float charge, HVRHandGrabber hand, OrbType type)
{
if ((Object)(object)hand == (Object)null)
{
return;
}
if (state == State.Idle)
{
if (stick && !wasStick)
{
state = State.Charging;
ball = CreateBall(((Component)hand).transform, type);
charge = 0f;
}
}
else if (state == State.Charging)
{
if (!stick && wasStick)
{
if (charge < 0.15f)
{
CancelBall(ref ball);
state = State.Cooldown;
MelonCoroutines.Start(ResetAfterCooldown(isLeft));
}
else
{
state = State.Ready;
}
}
else
{
charge += Time.deltaTime * 0.5f;
if (charge > 1f)
{
charge = 1f;
}
UpdateBall(ball, charge, type);
}
}
else if (state == State.Ready && stick && !wasStick)
{
Shoot(ball, ((Component)hand).transform, charge, type);
ball = null;
state = State.Cooldown;
MelonCoroutines.Start(ResetAfterCooldown(isLeft));
}
}
private GameObject CreateBall(Transform hand, OrbType type)
{
//IL_004c: Unknown result type (might be due to invalid IL or missing references)
//IL_005d: Unknown result type (might be due to invalid IL or missing references)
//IL_006e: Unknown result type (might be due to invalid IL or missing references)
//IL_0078: Unknown result type (might be due to invalid IL or missing references)
//IL_019d: Unknown result type (might be due to invalid IL or missing references)
//IL_0166: Unknown result type (might be due to invalid IL or missing references)
//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
//IL_00dd: Expected O, but got Unknown
//IL_011f: Unknown result type (might be due to invalid IL or missing references)
//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
GameObject val = GameObject.CreatePrimitive((PrimitiveType)0);
Object.Destroy((Object)(object)val.GetComponent<Collider>());
((Object)val).name = ((type == OrbType.Red) ? "RedBall" : "BlueBall");
val.transform.SetParent(hand);
val.transform.localPosition = new Vector3(0f, 0.05f, 0.12f);
val.transform.localRotation = Quaternion.identity;
val.transform.localScale = Vector3.one * 0.02f;
Renderer component = val.GetComponent<Renderer>();
if ((Object)(object)component != (Object)null)
{
Shader val2 = Shader.Find("Sprites/Default") ?? Shader.Find("Unlit/Color") ?? Shader.Find("Standard");
if ((Object)(object)val2 != (Object)null)
{
component.material = new Material(val2);
if (type == OrbType.Red)
{
component.material.color = new Color(1f, 0.05f, 0.05f);
}
else
{
component.material.color = new Color(0.1f, 0.3f, 1f);
}
}
component.shadowCastingMode = (ShadowCastingMode)0;
component.receiveShadows = false;
}
Light val3 = val.AddComponent<Light>();
val3.type = (LightType)2;
if (type == OrbType.Red)
{
val3.color = new Color(1f, 0.05f, 0.05f);
val3.intensity = 7f;
val3.range = 3.5f;
}
else
{
val3.color = new Color(0.2f, 0.4f, 1f);
val3.intensity = 5f;
val3.range = 3f;
}
return val;
}
private void UpdateBall(GameObject b, float charge, OrbType type)
{
//IL_0032: Unknown result type (might be due to invalid IL or missing references)
//IL_0038: Unknown result type (might be due to invalid IL or missing references)
//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
//IL_00de: Unknown result type (might be due to invalid IL or missing references)
//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
//IL_008c: Unknown result type (might be due to invalid IL or missing references)
//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
//IL_0171: Unknown result type (might be due to invalid IL or missing references)
//IL_0124: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)b == (Object)null)
{
return;
}
float num = charge / 1f;
float num2 = Mathf.Lerp(0.02f, 0.08f, num);
b.transform.localScale = Vector3.one * num2;
Renderer component = b.GetComponent<Renderer>();
if ((Object)(object)component != (Object)null && (Object)(object)component.material != (Object)null)
{
if (type == OrbType.Red)
{
component.material.color = Color.Lerp(new Color(1f, 0.15f, 0.15f), new Color(1f, 0f, 0f), num);
}
else
{
component.material.color = Color.Lerp(new Color(0.35f, 0.75f, 1f), new Color(0.05f, 0.25f, 1f), num);
}
}
Light component2 = b.GetComponent<Light>();
if ((Object)(object)component2 != (Object)null)
{
if (type == OrbType.Red)
{
component2.color = new Color(1f, 0.05f, 0.05f);
component2.intensity = Mathf.Lerp(7f, 15f, num);
component2.range = Mathf.Lerp(3.5f, 6f, num);
}
else
{
component2.color = new Color(0.2f, 0.4f, 1f);
component2.intensity = Mathf.Lerp(5f, 10f, num);
component2.range = Mathf.Lerp(3f, 5f, num);
}
}
}
private void Shoot(GameObject b, Transform hand, float charge, OrbType type)
{
//IL_007e: Unknown result type (might be due to invalid IL or missing references)
//IL_0084: Unknown result type (might be due to invalid IL or missing references)
//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
//IL_0115: Unknown result type (might be due to invalid IL or missing references)
//IL_011c: Expected O, but got Unknown
//IL_01e2: Unknown result type (might be due to invalid IL or missing references)
//IL_0203: Unknown result type (might be due to invalid IL or missing references)
//IL_018e: Unknown result type (might be due to invalid IL or missing references)
//IL_01af: Unknown result type (might be due to invalid IL or missing references)
//IL_0156: Unknown result type (might be due to invalid IL or missing references)
//IL_0138: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)b == (Object)null)
{
return;
}
b.transform.SetParent((Transform)null);
SphereCollider val = b.AddComponent<SphereCollider>();
val.radius = 0.5f;
((Collider)val).isTrigger = type == OrbType.Blue;
Rigidbody val2 = b.AddComponent<Rigidbody>();
val2.useGravity = false;
val2.collisionDetectionMode = (CollisionDetectionMode)2;
float num = ((type == OrbType.Red) ? 15f : 7.5f);
float num2 = Mathf.Lerp(num * 0.6f, num, charge / 1f);
val2.velocity = hand.forward * num2;
TrailRenderer val3 = b.AddComponent<TrailRenderer>();
val3.time = 0.25f;
val3.startWidth = b.transform.localScale.x * 1.5f;
val3.endWidth = 0.005f;
val3.minVertexDistance = 0.15f;
Shader val4 = Shader.Find("Sprites/Default") ?? Shader.Find("Unlit/Color") ?? Shader.Find("Standard");
if ((Object)(object)val4 != (Object)null)
{
Material val5 = new Material(val4);
if (type == OrbType.Red)
{
val5.color = new Color(1f, 0.05f, 0.05f);
}
else
{
val5.color = new Color(0.25f, 0.55f, 1f);
}
((Renderer)val3).material = val5;
}
if (type == OrbType.Red)
{
val3.startColor = new Color(1f, 0.15f, 0.15f, 0.95f);
val3.endColor = new Color(1f, 0f, 0f, 0f);
MelonCoroutines.Start(RedTrack(b, charge));
}
else
{
val3.startColor = new Color(0.4f, 0.75f, 1f, 0.95f);
val3.endColor = new Color(0.05f, 0.2f, 1f, 0f);
MelonCoroutines.Start(BlueTrack(b, charge));
}
}
private void CancelBall(ref GameObject ball)
{
if ((Object)(object)ball != (Object)null)
{
Object.Destroy((Object)(object)ball);
ball = null;
}
}
private IEnumerator ResetAfterCooldown(bool isLeft)
{
yield return (object)new WaitForSeconds(0.4f);
if (isLeft)
{
leftState = State.Idle;
}
else
{
rightState = State.Idle;
}
}
private void UpdateHandChargeParticles(GameObject ball, State state, float charge, OrbType type, ref float timer)
{
if ((Object)(object)ball == (Object)null || (state != State.Charging && state != State.Ready))
{
timer = 0f;
return;
}
timer -= Time.deltaTime;
if (timer > 0f)
{
return;
}
float num = Mathf.Clamp01(charge / 1f);
switch (state)
{
case State.Charging:
{
int num2 = Mathf.CeilToInt(Mathf.Lerp(2f, 4f, num));
for (int i = 0; i < num2; i++)
{
SpawnChargeImplodeParticle(ball, type, intense: true);
}
timer = 0.03f;
break;
}
case State.Ready:
if (num < 0.7f)
{
timer = 0.1f;
}
else if (type == OrbType.Blue)
{
SpawnChargeImplodeParticle(ball, type, intense: false);
timer = 0.25f;
}
else
{
SpawnReadyRedOutwardParticle(ball);
timer = 0.25f;
}
break;
}
}
private void SpawnChargeImplodeParticle(GameObject ball, OrbType type, bool intense)
{
//IL_009b: Unknown result type (might be due to invalid IL or missing references)
//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
//IL_0124: Unknown result type (might be due to invalid IL or missing references)
//IL_012b: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)ball == (Object)null || activeParticles >= 250)
{
return;
}
Material val = ((type == OrbType.Red) ? GetRedParticleMaterial() : GetBlueParticleMaterial());
if ((Object)(object)val == (Object)null)
{
return;
}
GameObject val2 = GameObject.CreatePrimitive((PrimitiveType)0);
if (!((Object)(object)val2 == (Object)null))
{
activeParticles++;
Object.Destroy((Object)(object)val2.GetComponent<Collider>());
((Object)val2).name = (intense ? "ChargeImplodeParticle" : "ReadyImplodeParticle");
Vector3 position = ball.transform.position;
float x = ball.transform.localScale.x;
float num = (intense ? Mathf.Max(0.18f, x * 3.5f) : Mathf.Max(0.12f, x * 2.5f));
val2.transform.position = position + Random.onUnitSphere * num;
float num2 = (intense ? Random.Range(0.006f, 0.016f) : Random.Range(0.004f, 0.01f));
val2.transform.localScale = Vector3.one * num2;
SetupParticleRenderer(val2, val);
float speed;
float acceleration;
float life;
if (intense)
{
speed = Random.Range(1.2f, 2.6f);
acceleration = Random.Range(6f, 12f);
life = Random.Range(0.22f, 0.45f);
}
else
{
speed = Random.Range(0.15f, 0.35f);
acceleration = Random.Range(0.25f, 0.6f);
life = Random.Range(0.9f, 1.5f);
}
MelonCoroutines.Start(ChargeImplodeParticleRoutine(val2, ball, speed, acceleration, life));
}
}
private IEnumerator ChargeImplodeParticleRoutine(GameObject particle, GameObject targetBall, float speed, float acceleration, float life)
{
if ((Object)(object)particle == (Object)null)
{
if (activeParticles > 0)
{
activeParticles--;
}
yield break;
}
Vector3 startScale = particle.transform.localScale;
float elapsed = 0f;
while ((Object)(object)particle != (Object)null && (Object)(object)targetBall != (Object)null && elapsed < life)
{
float dt = Time.deltaTime;
Vector3 center = targetBall.transform.position;
Vector3 pos = particle.transform.position;
Vector3 direction = center - pos;
float distance = ((Vector3)(ref direction)).magnitude;
if (distance < 0.02f)
{
break;
}
((Vector3)(ref direction)).Normalize();
speed += acceleration * dt;
float moveDistance = Mathf.Min(speed * dt, distance);
particle.transform.position = pos + direction * moveDistance;
elapsed += dt;
float t = elapsed / life;
particle.transform.localScale = startScale * Mathf.Clamp01(1f - t);
yield return null;
}
if ((Object)(object)particle != (Object)null)
{
Object.Destroy((Object)(object)particle);
}
if (activeParticles > 0)
{
activeParticles--;
}
}
private void SpawnReadyRedOutwardParticle(GameObject ball)
{
//IL_0086: Unknown result type (might be due to invalid IL or missing references)
//IL_008b: Unknown result type (might be due to invalid IL or missing references)
//IL_008c: Unknown result type (might be due to invalid IL or missing references)
//IL_0091: Unknown result type (might be due to invalid IL or missing references)
//IL_009d: Unknown result type (might be due to invalid IL or missing references)
//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
//IL_00be: Unknown result type (might be due to invalid IL or missing references)
//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
//IL_0111: Unknown result type (might be due to invalid IL or missing references)
//IL_0114: Unknown result type (might be due to invalid IL or missing references)
//IL_0119: Unknown result type (might be due to invalid IL or missing references)
//IL_012e: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)ball == (Object)null || activeParticles >= 250)
{
return;
}
Material val = GetRedParticleMaterial();
if (!((Object)(object)val == (Object)null))
{
GameObject val2 = GameObject.CreatePrimitive((PrimitiveType)0);
if (!((Object)(object)val2 == (Object)null))
{
activeParticles++;
Object.Destroy((Object)(object)val2.GetComponent<Collider>());
((Object)val2).name = "ReadyRedOutwardParticle";
Vector3 position = ball.transform.position;
Vector3 onUnitSphere = Random.onUnitSphere;
float num = Mathf.Max(0.02f, ball.transform.localScale.x * 0.8f);
val2.transform.position = position + onUnitSphere * num;
float num2 = Random.Range(0.004f, 0.01f);
val2.transform.localScale = Vector3.one * num2;
SetupParticleRenderer(val2, val);
float num3 = Random.Range(0.18f, 0.38f);
Vector3 velocity = onUnitSphere * num3;
float life = Random.Range(0.8f, 1.3f);
MelonCoroutines.Start(OutwardParticleRoutine(val2, velocity, life));
}
}
}
private IEnumerator RedTrack(GameObject ball, float charge)
{
yield return (object)new WaitForSeconds(0.05f);
if ((Object)(object)ball == (Object)null)
{
yield break;
}
Rigidbody rb = ball.GetComponent<Rigidbody>();
float startTime = Time.time;
float checkRadius = 0.4f;
float flightParticleTimer = 0f;
while ((Object)(object)ball != (Object)null && Time.time - startTime < 5f)
{
if (fusionLockedRedBalls.Contains(ball))
{
yield break;
}
Vector3 pos = ball.transform.position;
if (CanStartPurpleFusion())
{
GameObject blue = FindNearestActiveBlueHole(pos, 2.5f);
if ((Object)(object)blue != (Object)null)
{
StartPurpleFusion(ball, blue);
yield break;
}
}
Collider[] hits = Il2CppArrayBase<Collider>.op_Implicit((Il2CppArrayBase<Collider>)(object)Physics.OverlapSphere(pos, checkRadius));
Collider[] array = hits;
foreach (Collider hit in array)
{
if (!((Object)(object)hit == (Object)null) && !((Object)(object)((Component)hit).gameObject == (Object)null) && !((Object)(object)((Component)hit).gameObject == (Object)(object)ball) && !hit.isTrigger && !IsPlayer(((Component)hit).gameObject))
{
RedExplode(pos, charge);
Object.Destroy((Object)(object)ball);
yield break;
}
}
flightParticleTimer -= Time.deltaTime;
if (flightParticleTimer <= 0f)
{
Vector3 velocity = (((Object)(object)rb != (Object)null) ? rb.velocity : Vector3.zero);
SpawnFlightParticle(pos, velocity, GetRedParticleMaterial());
flightParticleTimer = 0.06f;
}
yield return null;
}
if ((Object)(object)ball != (Object)null)
{
Object.Destroy((Object)(object)ball);
}
}
private void RedExplode(Vector3 position, float charge)
{
//IL_0041: Unknown result type (might be due to invalid IL or missing references)
//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
float num = Mathf.Clamp01(charge / 1f);
float num2 = Mathf.Lerp(3f, 7f, num);
float num3 = Mathf.Lerp(100f, 300f, num);
float damage = Mathf.Lerp(30f, 100f, num);
Collider[] array = Il2CppArrayBase<Collider>.op_Implicit((Il2CppArrayBase<Collider>)(object)Physics.OverlapSphere(position, num2));
Collider[] array2 = array;
foreach (Collider val in array2)
{
if (!((Object)(object)val == (Object)null) && !((Object)(object)((Component)val).gameObject == (Object)null) && !IsPlayer(((Component)val).gameObject))
{
Rigidbody component = ((Component)val).GetComponent<Rigidbody>();
if ((Object)(object)component != (Object)null)
{
component.AddExplosionForce(num3, position, num2, 1f, (ForceMode)1);
}
ApplyDamage(((Component)val).gameObject, position, damage, num2);
}
}
SpawnRedExplosionEffect(position, num2);
SpawnRedExplosionParticles(position, num2);
}
private void SpawnRedExplosionEffect(Vector3 position, float radius)
{
//IL_0026: Unknown result type (might be due to invalid IL or missing references)
//IL_0033: Unknown result type (might be due to invalid IL or missing references)
//IL_003d: Unknown result type (might be due to invalid IL or missing references)
//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
//IL_0095: Unknown result type (might be due to invalid IL or missing references)
//IL_009f: Expected O, but got Unknown
//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
GameObject val = GameObject.CreatePrimitive((PrimitiveType)0);
Object.Destroy((Object)(object)val.GetComponent<Collider>());
((Object)val).name = "RedExplosion";
val.transform.position = position;
val.transform.localScale = Vector3.one * 0.1f;
Renderer component = val.GetComponent<Renderer>();
if ((Object)(object)component != (Object)null)
{
Shader val2 = Shader.Find("Sprites/Default") ?? Shader.Find("Unlit/Color") ?? Shader.Find("Standard");
if ((Object)(object)val2 != (Object)null)
{
component.material = new Material(val2);
component.material.color = new Color(1f, 0f, 0f);
}
component.shadowCastingMode = (ShadowCastingMode)0;
component.receiveShadows = false;
}
Light val3 = val.AddComponent<Light>();
val3.type = (LightType)2;
val3.color = new Color(1f, 0.1f, 0.1f);
val3.intensity = 30f;
val3.range = radius * 3f;
MelonCoroutines.Start(RedExplosionAnimation(val, val3, radius));
}
private IEnumerator RedExplosionAnimation(GameObject explosion, Light flash, float radius)
{
float duration = 0.3f;
float elapsed = 0f;
Vector3 startScale = Vector3.one * 0.1f;
Vector3 maxScale = Vector3.one * Mathf.Max(2.5f, radius * 0.5f);
while (elapsed < duration && (Object)(object)explosion != (Object)null)
{
elapsed += Time.deltaTime;
float t = elapsed / duration;
explosion.transform.localScale = Vector3.Lerp(startScale, maxScale, t);
if ((Object)(object)flash != (Object)null)
{
flash.intensity = Mathf.Lerp(30f, 0f, t * t);
}
Renderer r = explosion.GetComponent<Renderer>();
if ((Object)(object)r != (Object)null && (Object)(object)r.material != (Object)null)
{
r.material.color = Color.Lerp(new Color(1f, 0.05f, 0.05f), new Color(0.35f, 0f, 0f), t);
}
yield return null;
}
if ((Object)(object)explosion != (Object)null)
{
Object.Destroy((Object)(object)explosion);
}
}
private void SpawnRedExplosionParticles(Vector3 center, float radius)
{
//IL_007a: Unknown result type (might be due to invalid IL or missing references)
//IL_007f: Unknown result type (might be due to invalid IL or missing references)
//IL_0087: Unknown result type (might be due to invalid IL or missing references)
//IL_0088: Unknown result type (might be due to invalid IL or missing references)
//IL_008f: Unknown result type (might be due to invalid IL or missing references)
//IL_0094: Unknown result type (might be due to invalid IL or missing references)
//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
//IL_012a: Unknown result type (might be due to invalid IL or missing references)
//IL_012b: Unknown result type (might be due to invalid IL or missing references)
Material val = GetRedParticleMaterial();
if ((Object)(object)val == (Object)null)
{
return;
}
for (int i = 0; i < 30; i++)
{
if (activeParticles >= 250)
{
break;
}
GameObject val2 = GameObject.CreatePrimitive((PrimitiveType)0);
if (!((Object)(object)val2 == (Object)null))
{
activeParticles++;
Object.Destroy((Object)(object)val2.GetComponent<Collider>());
((Object)val2).name = "RedExplosionParticle";
Vector3 onUnitSphere = Random.onUnitSphere;
val2.transform.position = center + onUnitSphere * 0.1f;
float num = Random.Range(0.01f, 0.035f);
val2.transform.localScale = Vector3.one * num;
SetupParticleRenderer(val2, val);
float num2 = Random.Range(5f, 11f) + radius * 0.6f;
Vector3 velocity = onUnitSphere * num2;
float outwardTime = Random.Range(0.25f, 0.45f);
float floatTime = Random.Range(0.6f, 1.2f);
float implodeTime = Random.Range(0.5f, 0.9f);
MelonCoroutines.Start(RedExplosionParticleRoutine(val2, center, velocity, outwardTime, floatTime, implodeTime));
}
}
}
private IEnumerator RedExplosionParticleRoutine(GameObject particle, Vector3 center, Vector3 velocity, float outwardTime, float floatTime, float implodeTime)
{
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
//IL_0016: Unknown result type (might be due to invalid IL or missing references)
//IL_001c: Unknown result type (might be due to invalid IL or missing references)
//IL_001d: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)particle == (Object)null)
{
if (activeParticles > 0)
{
activeParticles--;
}
yield break;
}
Vector3 startScale = particle.transform.localScale;
float elapsed = 0f;
while ((Object)(object)particle != (Object)null && elapsed < outwardTime)
{
float dt = Time.deltaTime;
Vector3 pos = particle.transform.position;
particle.transform.position = pos + velocity * dt;
velocity *= 0.88f;
elapsed += dt;
yield return null;
}
elapsed = 0f;
Vector3 drift = Random.insideUnitSphere * 0.3f;
while ((Object)(object)particle != (Object)null && elapsed < floatTime)
{
float dt2 = Time.deltaTime;
Vector3 pos2 = particle.transform.position;
particle.transform.position = pos2 + drift * dt2;
drift *= 0.96f;
elapsed += dt2;
yield return null;
}
elapsed = 0f;
while ((Object)(object)particle != (Object)null && elapsed < implodeTime)
{
float dt3 = Time.deltaTime;
float t = elapsed / implodeTime;
Vector3 pos3 = particle.transform.position;
float distanceToCenter = Vector3.Distance(pos3, center);
float speed = Mathf.Lerp(3f, 18f, t) + distanceToCenter * 2f;
Vector3 newPos = Vector3.MoveTowards(pos3, center, speed * dt3);
particle.transform.position = newPos;
particle.transform.localScale = startScale * Mathf.Clamp01(1f - t);
if (Vector3.Distance(newPos, center) < 0.05f)
{
break;
}
elapsed += dt3;
yield return null;
}
if ((Object)(object)particle != (Object)null)
{
Object.Destroy((Object)(object)particle);
}
if (activeParticles > 0)
{
activeParticles--;
}
}
private IEnumerator BlueTrack(GameObject ball, float charge)
{
if ((Object)(object)ball == (Object)null)
{
yield break;
}
Rigidbody rb = ball.GetComponent<Rigidbody>();
if ((Object)(object)rb == (Object)null)
{
yield break;
}
Collider col = ball.GetComponent<Collider>();
if ((Object)(object)col != (Object)null)
{
col.isTrigger = true;
}
Vector3 startVelocity = rb.velocity;
float flightParticleTimer = 0f;
float elapsed = 0f;
while ((Object)(object)ball != (Object)null && elapsed < 0.5f)
{
if (CheckBlueSolidCollision(ball, rb))
{
StopBlueBall(rb);
MelonCoroutines.Start(BlueHoleRoutine(ball, charge));
yield break;
}
rb.velocity = startVelocity;
flightParticleTimer -= Time.fixedDeltaTime;
if (flightParticleTimer <= 0f)
{
SpawnFlightParticle(ball.transform.position, rb.velocity, GetBlueParticleMaterial());
flightParticleTimer = 0.07f;
}
elapsed += Time.fixedDeltaTime;
yield return (object)new WaitForFixedUpdate();
}
if ((Object)(object)ball == (Object)null)
{
yield break;
}
elapsed = 0f;
while ((Object)(object)ball != (Object)null && elapsed < 1f)
{
if (CheckBlueSolidCollision(ball, rb))
{
StopBlueBall(rb);
MelonCoroutines.Start(BlueHoleRoutine(ball, charge));
yield break;
}
float t = elapsed / 1f;
float speedMultiplier = Mathf.SmoothStep(1f, 0f, t);
rb.velocity = startVelocity * speedMultiplier;
flightParticleTimer -= Time.fixedDeltaTime;
if (flightParticleTimer <= 0f)
{
SpawnFlightParticle(ball.transform.position, rb.velocity, GetBlueParticleMaterial());
flightParticleTimer = 0.105000004f;
}
elapsed += Time.fixedDeltaTime;
yield return (object)new WaitForFixedUpdate();
}
if (!((Object)(object)ball == (Object)null))
{
StopBlueBall(rb);
MelonCoroutines.Start(BlueHoleRoutine(ball, charge));
}
}
private void StopBlueBall(Rigidbody rb)
{
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
if (!((Object)(object)rb == (Object)null))
{
rb.velocity = Vector3.zero;
rb.isKinematic = true;
}
}
private bool CheckBlueSolidCollision(GameObject ball, Rigidbody rb)
{
//IL_0019: Unknown result type (might be due to invalid IL or missing references)
//IL_001e: Unknown result type (might be due to invalid IL or missing references)
//IL_002a: Unknown result type (might be due to invalid IL or missing references)
//IL_0041: Unknown result type (might be due to invalid IL or missing references)
//IL_005d: Unknown result type (might be due to invalid IL or missing references)
//IL_0062: Unknown result type (might be due to invalid IL or missing references)
//IL_007c: Unknown result type (might be due to invalid IL or missing references)
//IL_007e: Unknown result type (might be due to invalid IL or missing references)
//IL_0088: Unknown result type (might be due to invalid IL or missing references)
//IL_008d: Unknown result type (might be due to invalid IL or missing references)
//IL_0092: Unknown result type (might be due to invalid IL or missing references)
//IL_0095: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)ball == (Object)null)
{
return false;
}
Vector3 position = ball.transform.position;
float radius = Mathf.Max(0.2f, ball.transform.localScale.x * 0.5f);
if (HasSolidColliderAt(position, radius, ball))
{
return true;
}
if ((Object)(object)rb != (Object)null)
{
Vector3 velocity = rb.velocity;
if (((Vector3)(ref velocity)).sqrMagnitude > 0.001f)
{
Vector3 position2 = position - rb.velocity * Time.fixedDeltaTime;
if (HasSolidColliderAt(position2, radius, ball))
{
return true;
}
}
}
return false;
}
private bool HasSolidColliderAt(Vector3 position, float radius, GameObject ignore)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
Collider[] array = Il2CppArrayBase<Collider>.op_Implicit((Il2CppArrayBase<Collider>)(object)Physics.OverlapSphere(position, radius));
Collider[] array2 = array;
foreach (Collider val in array2)
{
if (!((Object)(object)val == (Object)null) && !((Object)(object)((Component)val).gameObject == (Object)null) && !((Object)(object)((Component)val).gameObject == (Object)(object)ignore) && !val.isTrigger && !IsPlayer(((Component)val).gameObject))
{
return true;
}
}
return false;
}
private IEnumerator BlueHoleRoutine(GameObject ball, float charge)
{
if ((Object)(object)ball == (Object)null)
{
yield break;
}
if (!activeBlueHoles.Contains(ball))
{
activeBlueHoles.Add(ball);
}
Vector3 center = ball.transform.position;
Vector3 startScale = ball.transform.localScale;
float chargeT = Mathf.Clamp01(charge / 1f);
float baseRadius = Mathf.Lerp(2f, 5f, chargeT);
float baseForce = Mathf.Lerp(30f, 80f, chargeT);
float damagePerSecond = Mathf.Lerp(5f, 20f, chargeT);
float elapsed = 0f;
float damageTimer = 0f;
Light light = ball.GetComponent<Light>();
Renderer renderer = ball.GetComponent<Renderer>();
Color ballColor = new Color(0.1f, 0.3f, 1f);
Color lightColor = new Color(0.2f, 0.4f, 1f);
if ((Object)(object)renderer != (Object)null && (Object)(object)renderer.material != (Object)null)
{
ballColor = renderer.material.color;
}
if ((Object)(object)light != (Object)null)
{
lightColor = light.color;
}
SpawnBlueActivationBurst(center, baseRadius);
float activationParticleTimer = 0f;
while ((Object)(object)ball != (Object)null && elapsed < 10f)
{
if (fusionLockedBlueBalls.Contains(ball))
{
activeBlueHoles.Remove(ball);
yield break;
}
float t = elapsed / 10f;
float grow = Mathf.Lerp(1f, 10f, t);
ball.transform.localScale = startScale * grow;
float radius = baseRadius * Mathf.Lerp(1f, 3f, t);
float force = baseForce * Mathf.Lerp(0.6f, 1f, t);
PullObjects(center, radius, force, ball);
activationParticleTimer -= Time.fixedDeltaTime;
if (activationParticleTimer <= 0f)
{
SpawnBlueActivationBurst(center, radius);
activationParticleTimer = 0.15f;
}
damageTimer -= Time.fixedDeltaTime;
if (damageTimer <= 0f)
{
ApplyAreaDamage(center, radius, damagePerSecond * 0.5f, ball);
damageTimer = 0.5f;
}
if ((Object)(object)light != (Object)null)
{
light.color = lightColor;
light.range = radius * 2f;
light.intensity = Mathf.Lerp(10f, 25f, t);
}
if ((Object)(object)renderer != (Object)null && (Object)(object)renderer.material != (Object)null)
{
renderer.material.color = ballColor;
}
elapsed += Time.fixedDeltaTime;
yield return (object)new WaitForFixedUpdate();
}
activeBlueHoles.Remove(ball);
if ((Object)(object)ball != (Object)null)
{
Object.Destroy((Object)(object)ball);
}
}
private void PullObjects(Vector3 center, float radius, float force, GameObject ignore)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_009c: Unknown result type (might be due to invalid IL or missing references)
//IL_009f: Unknown result type (might be due to invalid IL or missing references)
//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
//IL_0117: Unknown result type (might be due to invalid IL or missing references)
//IL_011b: Unknown result type (might be due to invalid IL or missing references)
Collider[] array = Il2CppArrayBase<Collider>.op_Implicit((Il2CppArrayBase<Collider>)(object)Physics.OverlapSphere(center, radius));
Collider[] array2 = array;
foreach (Collider val in array2)
{
if ((Object)(object)val == (Object)null || (Object)(object)((Component)val).gameObject == (Object)null || (Object)(object)((Component)val).gameObject == (Object)(object)ignore || IsPlayer(((Component)val).gameObject))
{
continue;
}
Rigidbody component = ((Component)val).GetComponent<Rigidbody>();
if ((Object)(object)component == (Object)null || component.isKinematic)
{
continue;
}
Vector3 val2 = center - component.position;
float magnitude = ((Vector3)(ref val2)).magnitude;
if (!(magnitude < 0.1f))
{
((Vector3)(ref val2)).Normalize();
float num = Mathf.Clamp01(magnitude / radius);
float num2 = 1f - num;
float num3 = Mathf.Lerp(0.35f, 1f, num2);
float num4 = force * num3 * 1.5f;
if (!(num4 <= 0f))
{
component.AddForce(val2 * num4, (ForceMode)5);
}
}
}
}
private void ApplyAreaDamage(Vector3 center, float radius, float damage, GameObject ignore)
{
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
if (damage <= 0f)
{
return;
}
Collider[] array = Il2CppArrayBase<Collider>.op_Implicit((Il2CppArrayBase<Collider>)(object)Physics.OverlapSphere(center, radius));
HashSet<GameObject> hashSet = new HashSet<GameObject>();
Collider[] array2 = array;
foreach (Collider val in array2)
{
if (!((Object)(object)val == (Object)null) && !((Object)(object)((Component)val).gameObject == (Object)null) && !((Object)(object)((Component)val).gameObject == (Object)(object)ignore) && !IsPlayer(((Component)val).gameObject) && hashSet.Add(((Component)val).gameObject))
{
ApplyDamage(((Component)val).gameObject, center, damage, radius);
}
}
}
private void SpawnBlueActivationBurst(Vector3 center, float radius)
{
//IL_007a: Unknown result type (might be due to invalid IL or missing references)
//IL_007f: Unknown result type (might be due to invalid IL or missing references)
//IL_009a: Unknown result type (might be due to invalid IL or missing references)
//IL_009b: Unknown result type (might be due to invalid IL or missing references)
//IL_009f: Unknown result type (might be due to invalid IL or missing references)
//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
//IL_0103: Unknown result type (might be due to invalid IL or missing references)
//IL_0118: Unknown result type (might be due to invalid IL or missing references)
Material val = GetBlueParticleMaterial();
if ((Object)(object)val == (Object)null)
{
return;
}
for (int i = 0; i < 2; i++)
{
if (activeParticles >= 250)
{
break;
}
GameObject val2 = GameObject.CreatePrimitive((PrimitiveType)0);
if (!((Object)(object)val2 == (Object)null))
{
activeParticles++;
Object.Destroy((Object)(object)val2.GetComponent<Collider>());
((Object)val2).name = "BlueActivationParticle";
Vector3 onUnitSphere = Random.onUnitSphere;
float num = Mathf.Max(0.05f, radius * 0.08f);
val2.transform.position = center + onUnitSphere * num;
float num2 = Random.Range(0.008f, 0.025f);
val2.transform.localScale = Vector3.one * num2;
SetupParticleRenderer(val2, val);
float num3 = Random.Range(0.4f, 1.4f) + radius * 0.12f;
Vector3 velocity = onUnitSphere * num3;
float life = Random.Range(0.7f, 1.4f);
MelonCoroutines.Start(OutwardParticleRoutine(val2, velocity, life));
}
}
}
private IEnumerator OutwardParticleRoutine(GameObject particle, Vector3 velocity, float life)
{
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
//IL_0016: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)particle == (Object)null)
{
if (activeParticles > 0)
{
activeParticles--;
}
yield break;
}
Vector3 startScale = particle.transform.localScale;
float elapsed = 0f;
while ((Object)(object)particle != (Object)null && elapsed < life)
{
float dt = Time.deltaTime;
Vector3 pos = particle.transform.position;
particle.transform.position = pos + velocity * dt;
velocity *= 0.9f;
elapsed += dt;
float t = elapsed / life;
particle.transform.localScale = startScale * Mathf.Clamp01(1f - t);
yield return null;
}
if ((Object)(object)particle != (Object)null)
{
Object.Destroy((Object)(object)particle);
}
if (activeParticles > 0)
{
activeParticles--;
}
}
private bool CanStartPurpleFusion()
{
return !purpleFusionActive && Time.time >= purpleCooldownEndTime;
}
private GameObject FindNearestActiveBlueHole(Vector3 position, float baseRadius)
{
//IL_0061: Unknown result type (might be due to invalid IL or missing references)
//IL_0079: Unknown result type (might be due to invalid IL or missing references)
//IL_0080: Unknown result type (might be due to invalid IL or missing references)
GameObject result = null;
float num = float.MaxValue;
for (int num2 = activeBlueHoles.Count - 1; num2 >= 0; num2--)
{
GameObject val = activeBlueHoles[num2];
if ((Object)(object)val == (Object)null)
{
activeBlueHoles.RemoveAt(num2);
}
else if (!fusionLockedBlueBalls.Contains(val))
{
float num3 = val.transform.localScale.x * 0.5f;
float num4 = baseRadius + num3;
float num5 = Vector3.Distance(position, val.transform.position);
if (num5 <= num4 && num5 < num)
{
result = val;
num = num5;
}
}
}
return result;
}
private void StartPurpleFusion(GameObject redBall, GameObject blueBall)
{
//IL_0063: Unknown result type (might be due to invalid IL or missing references)
//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
if (!((Object)(object)redBall == (Object)null) && !((Object)(object)blueBall == (Object)null))
{
purpleFusionActive = true;
activeBlueHoles.Remove(blueBall);
fusionLockedRedBalls.Add(redBall);
fusionLockedBlueBalls.Add(blueBall);
Rigidbody component = redBall.GetComponent<Rigidbody>();
if ((Object)(object)component != (Object)null)
{
component.velocity = Vector3.zero;
component.isKinematic = true;
}
Collider component2 = redBall.GetComponent<Collider>();
if ((Object)(object)component2 != (Object)null)
{
component2.isTrigger = true;
}
Rigidbody component3 = blueBall.GetComponent<Rigidbody>();
if ((Object)(object)component3 != (Object)null)
{
component3.velocity = Vector3.zero;
component3.isKinematic = true;
}
Collider component4 = blueBall.GetComponent<Collider>();
if ((Object)(object)component4 != (Object)null)
{
component4.isTrigger = true;
}
MelonCoroutines.Start(PurpleFusionRoutine(redBall, blueBall));
}
}
private IEnumerator PurpleFusionRoutine(GameObject redBall, GameObject blueBall)
{
if ((Object)(object)redBall == (Object)null || (Object)(object)blueBall == (Object)null)
{
CleanupFusion(redBall, blueBall);
yield break;
}
Vector3 center = blueBall.transform.position;
Vector3 redStartScale = redBall.transform.localScale;
Vector3 initialPosition = redBall.transform.position;
Vector3 offset = initialPosition - center;
Vector3 horizontalOffset = new Vector3(offset.x, 0f, offset.z);
if (((Vector3)(ref horizontalOffset)).sqrMagnitude < 0.01f)
{
horizontalOffset = Random.onUnitSphere;
horizontalOffset.y = 0f;
if (((Vector3)(ref horizontalOffset)).sqrMagnitude < 0.01f)
{
horizontalOffset = Vector3.forward;
}
}
((Vector3)(ref horizontalOffset)).Normalize();
Vector3 radial = horizontalOffset;
Vector3 val = Vector3.Cross(Vector3.up, radial);
Vector3 tangent = ((Vector3)(ref val)).normalized;
val = new Vector3(offset.x, 0f, offset.z);
float horizontalDistance = ((Vector3)(ref val)).magnitude;
float orbitRadius = Mathf.Clamp(horizontalDistance, 1.2f, 3f);
Vector3 holdTargetPosition = center + radial * orbitRadius;
holdTargetPosition.y = center.y;
float elapsed = 0f;
while (elapsed < 0.2f)
{
if ((Object)(object)redBall == (Object)null || (Object)(object)blueBall == (Object)null)
{
CleanupFusion(redBall, blueBall);
yield break;
}
float t = elapsed / 0.2f;
float smoothT = Mathf.SmoothStep(0f, 1f, t);
redBall.transform.position = Vector3.Lerp(initialPosition, holdTargetPosition, smoothT);
elapsed += Time.deltaTime;
yield return null;
}
elapsed = 0f;
while (elapsed < 0.5f)
{
if ((Object)(object)redBall == (Object)null || (Object)(object)blueBall == (Object)null)
{
CleanupFusion(redBall, blueBall);
yield break;
}
redBall.transform.position = holdTargetPosition;
elapsed += Time.deltaTime;
yield return null;
}
float angle = 0f;
float maxAngularSpeed = 6.283185f;
elapsed = 0f;
while (elapsed < 3f)
{
if ((Object)(object)redBall == (Object)null || (Object)(object)blueBall == (Object)null)
{
CleanupFusion(redBall, blueBall);
yield break;
}
float t2 = elapsed / 3f;
float smoothT2 = Mathf.SmoothStep(0f, 1f, t2);
float angularSpeed = Mathf.Lerp(0f, maxAngularSpeed, smoothT2);
angle += angularSpeed * Time.deltaTime;
Vector3 pos = center + (radial * Mathf.Cos(angle) + tangent * Mathf.Sin(angle)) * orbitRadius;
pos.y = center.y;
redBall.transform.position = pos;
elapsed += Time.deltaTime;
yield return null;
}
elapsed = 0f;
while (elapsed < 4f)
{
if ((Object)(object)redBall == (Object)null || (Object)(object)blueBall == (Object)null)
{
CleanupFusion(redBall, blueBall);
yield break;
}
angle += maxAngularSpeed * Time.deltaTime;
Vector3 pos2 = center + (radial * Mathf.Cos(angle) + tangent * Mathf.Sin(angle)) * orbitRadius;
pos2.y = center.y;
redBall.transform.position = pos2;
elapsed += Time.deltaTime;
yield return null;
}
elapsed = 0f;
while (elapsed < 4f)
{
if ((Object)(object)redBall == (Object)null || (Object)(object)blueBall == (Object)null)
{
CleanupFusion(redBall, blueBall);
yield break;
}
float t3 = elapsed / 4f;
float smoothT3 = Mathf.SmoothStep(0f, 1f, t3);
float angularSpeed2 = maxAngularSpeed * Mathf.Lerp(1f, 1.35f, smoothT3);
angle += angularSpeed2 * Time.deltaTime;
float currentRadius = Mathf.Lerp(orbitRadius, 0.15f, smoothT3);
Vector3 pos3 = center + (radial * Mathf.Cos(angle) + tangent * Mathf.Sin(angle)) * currentRadius;
pos3.y = center.y;
redBall.transform.position = pos3;
redBall.transform.localScale = Vector3.Lerp(redStartScale, redStartScale * 0.4f, smoothT3);
elapsed += Time.deltaTime;
yield return null;
}
fusionLockedRedBalls.Remove(redBall);
fusionLockedBlueBalls.Remove(blueBall);
Object.Destroy((Object)(object)redBall);
Object.Destroy((Object)(object)blueBall);
GameObject purpleBall = CreatePurpleBall(center);
if ((Object)(object)purpleBall == (Object)null)
{
purpleFusionActive = false;
}
else
{
MelonCoroutines.Start(PurpleGrowRoutine(purpleBall, center));
}
}
private void CleanupFusion(GameObject redBall, GameObject blueBall)
{
if ((Object)(object)redBall != (Object)null)
{
fusionLockedRedBalls.Remove(redBall);
Object.Destroy((Object)(object)redBall);
}
if ((Object)(object)blueBall != (Object)null)
{
fusionLockedBlueBalls.Remove(blueBall);
activeBlueHoles.Remove(blueBall);
Object.Destroy((Object)(object)blueBall);
}
purpleFusionActive = false;
}
private GameObject CreatePurpleBall(Vector3 center)
{
//IL_0026: Unknown result type (might be due to invalid IL or missing references)
//IL_0033: Unknown result type (might be due to invalid IL or missing references)
//IL_003d: Unknown result type (might be due to invalid IL or missing references)
//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
//IL_0095: Unknown result type (might be due to invalid IL or missing references)
//IL_009f: Expected O, but got Unknown
//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
GameObject val = GameObject.CreatePrimitive((PrimitiveType)0);
Object.Destroy((Object)(object)val.GetComponent<Collider>());
((Object)val).name = "PurpleBall";
val.transform.position = center;
val.transform.localScale = Vector3.one * 0.1f;
Renderer component = val.GetComponent<Renderer>();
if ((Object)(object)component != (Object)null)
{
Shader val2 = Shader.Find("Sprites/Default") ?? Shader.Find("Unlit/Color") ?? Shader.Find("Standard");
if ((Object)(object)val2 != (Object)null)
{
component.material = new Material(val2);
component.material.color = new Color(0.6f, 0.15f, 1f);
}
component.shadowCastingMode = (ShadowCastingMode)0;
component.receiveShadows = false;
}
Light val3 = val.AddComponent<Light>();
val3.type = (LightType)2;
val3.color = new Color(0.65f, 0.25f, 1f);
val3.intensity = 15f;
val3.range = 5f;
return val;
}
private IEnumerator PurpleGrowRoutine(GameObject purpleBall, Vector3 center)
{
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
//IL_0016: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)purpleBall == (Object)null)
{
purpleFusionActive = false;
yield break;
}
Light light = purpleBall.GetComponent<Light>();
Renderer renderer = purpleBall.GetComponent<Renderer>();
float elapsed = 0f;
float particleTimer = 0f;
while ((Object)(object)purpleBall != (Object)null && elapsed < 5f)
{
float t = elapsed / 5f;
float smoothT = Mathf.SmoothStep(0f, 1f, t);
float scale = Mathf.Lerp(0.1f, 1.6f, smoothT);
purpleBall.transform.localScale = Vector3.one * scale;
if ((Object)(object)light != (Object)null)
{
light.color = new Color(0.65f, 0.25f, 1f);
light.intensity = Mathf.Lerp(15f, 45f, smoothT);
light.range = Mathf.Lerp(5f, 18f, smoothT);
}
if ((Object)(object)renderer != (Object)null && (Object)(object)renderer.material != (Object)null)
{
renderer.material.color = Color.Lerp(new Color(0.45f, 0.1f, 0.8f), new Color(0.75f, 0.3f, 1f), smoothT);
}
particleTimer -= Time.deltaTime;
if (particleTimer <= 0f)
{
SpawnPurpleActivationBurst(center, scale);
particleTimer = 0.15f;
}
elapsed += Time.deltaTime;
yield return null;
}
if ((Object)(object)purpleBall != (Object)null)
{
Object.Destroy((Object)(object)purpleBall);
PurpleExplode(center);
purpleCooldownEndTime = Time.time + 30f;
}
purpleFusionActive = false;
}
private void SpawnPurpleActivationBurst(Vector3 center, float currentScale)
{
//IL_007a: Unknown result type (might be due to invalid IL or missing references)
//IL_007f: Unknown result type (might be due to invalid IL or missing references)
//IL_009a: Unknown result type (might be due to invalid IL or missing references)
//IL_009b: Unknown result type (might be due to invalid IL or missing references)
//IL_009f: Unknown result type (might be due to invalid IL or missing references)
//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
//IL_0103: Unknown result type (might be due to invalid IL or missing references)
//IL_0118: Unknown result type (might be due to invalid IL or missing references)
Material val = GetPurpleParticleMaterial();
if ((Object)(object)val == (Object)null)
{
return;
}
for (int i = 0; i < 6; i++)
{
if (activeParticles >= 250)
{
break;
}
GameObject val2 = GameObject.CreatePrimitive((PrimitiveType)0);
if (!((Object)(object)val2 == (Object)null))
{
activeParticles++;
Object.Destroy((Object)(object)val2.GetComponent<Collider>());
((Object)val2).name = "PurpleParticle";
Vector3 onUnitSphere = Random.onUnitSphere;
float num = Mathf.Max(0.1f, currentScale * 0.55f);
val2.transform.position = center + onUnitSphere * num;
float num2 = Random.Range(0.016f, 0.05f);
val2.transform.localScale = Vector3.one * num2;
SetupParticleRenderer(val2, val);
float num3 = Random.Range(1.2f, 3.2f) + currentScale * 0.6f;
Vector3 velocity = onUnitSphere * num3;
float life = Random.Range(0.7f, 1.4f);
MelonCoroutines.Start(OutwardParticleRoutine(val2, velocity, life));
}
}
}
private void PurpleExplode(Vector3 center)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
//IL_008d: Unknown result type (might be due to invalid IL or missing references)
//IL_0073: Unknown result type (might be due to invalid IL or missing references)
Collider[] array = Il2CppArrayBase<Collider>.op_Implicit((Il2CppArrayBase<Collider>)(object)Physics.OverlapSphere(center, 14f));
Collider[] array2 = array;
foreach (Collider val in array2)
{
if (!((Object)(object)val == (Object)null) && !((Object)(object)((Component)val).gameObject == (Object)null) && !IsPlayer(((Component)val).gameObject))
{
Rigidbody component = ((Component)val).GetComponent<Rigidbody>();
if ((Object)(object)component != (Object)null)
{
component.AddExplosionForce(1200f, center, 14f, 1f, (ForceMode)1);
}
ApplyDamage(((Component)val).gameObject, center, 400f, 14f);
}
}
SpawnPurpleExplosionEffect(center, 14f);
SpawnPurpleShockwave(center, 14f);
SpawnPurpleExplosionParticles(center, 14f);
}
private void SpawnPurpleExplosionEffect(Vector3 position, float radius)
{
//IL_0026: Unknown result type (might be due to invalid IL or missing references)
//IL_0033: Unknown result type (might be due to invalid IL or missing references)
//IL_003d: Unknown result type (might be due to invalid IL or missing references)
//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
//IL_0095: Unknown result type (might be due to invalid IL or missing references)
//IL_009f: Expected O, but got Unknown
//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
GameObject val = GameObject.CreatePrimitive((PrimitiveType)0);
Object.Destroy((Object)(object)val.GetComponent<Collider>());
((Object)val).name = "PurpleExplosion";
val.transform.position = position;
val.transform.localScale = Vector3.one * 0.1f;
Renderer component = val.GetComponent<Renderer>();
if ((Object)(object)component != (Object)null)
{
Shader val2 = Shader.Find("Sprites/Default") ?? Shader.Find("Unlit/Color") ?? Shader.Find("Standard");
if ((Object)(object)val2 != (Object)null)
{
component.material = new Material(val2);
component.material.color = new Color(0.65f, 0.2f, 1f);
}
component.shadowCastingMode = (ShadowCastingMode)0;
component.receiveShadows = false;
}
Light val3 = val.AddComponent<Light>();
val3.type = (LightType)2;
val3.color = new Color(0.7f, 0.3f, 1f);
val3.intensity = 50f;
val3.range = radius * 3f;
MelonCoroutines.Start(PurpleExplosionAnimation(val, val3, radius));
}
private IEnumerator PurpleExplosionAnimation(GameObject explosion, Light flash, float radius)
{
float duration = 0.45f;
float elapsed = 0f;
Vector3 startScale = Vector3.one * 0.1f;
Vector3 maxScale = Vector3.one * Mathf.Max(4f, radius * 0.4f);
while (elapsed < duration && (Object)(object)explosion != (Object)null)
{
elapsed += Time.deltaTime;
float t = elapsed / duration;
explosion.transform.localScale = Vector3.Lerp(startScale, maxScale, t);
if ((Object)(object)flash != (Object)null)
{
flash.intensity = Mathf.Lerp(50f, 0f, t * t);
}
Renderer r = explosion.GetComponent<Renderer>();
if ((Object)(object)r != (Object)null && (Object)(object)r.material != (Object)null)
{
r.material.color = Color.Lerp(new Color(0.75f, 0.3f, 1f), new Color(0.2f, 0f, 0.35f), t);
}
yield return null;
}
if ((Object)(object)explosion != (Object)null)
{
Object.Destroy((Object)(object)explosion);
}
}
private void SpawnPurpleExplosionParticles(Vector3 center, float radius)
{
//IL_007a: Unknown result type (might be due to invalid IL or missing references)
//IL_007f: Unknown result type (might be due to invalid IL or missing references)
//IL_0087: Unknown result type (might be due to invalid IL or missing references)
//IL_0088: Unknown result type (might be due to invalid IL or missing references)
//IL_008f: Unknown result type (might be due to invalid IL or missing references)
//IL_0094: Unknown result type (might be due to invalid IL or missing references)
//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
//IL_0108: Unknown result type (might be due to invalid IL or missing references)
Material val = GetPurpleParticleMaterial();
if ((Object)(object)val == (Object)null)
{
return;
}
for (int i = 0; i < 24; i++)
{
if (activeParticles >= 250)
{
break;
}
GameObject val2 = GameObject.CreatePrimitive((PrimitiveType)0);
if (!((Object)(object)val2 == (Object)null))
{
activeParticles++;
Object.Destroy((Object)(object)val2.GetComponent<Collider>());
((Object)val2).name = "PurpleExplosionParticle";
Vector3 onUnitSphere = Random.onUnitSphere;
val2.transform.position = center + onUnitSphere * 0.2f;
float num = Random.Range(0.02f, 0.07f);
val2.transform.localScale = Vector3.one * num;
SetupParticleRenderer(val2, val);
float num2 = Random.Range(6f, 12f) + radius * 0.2f;
Vector3 velocity = onUnitSphere * num2;
float life = Random.Range(0.8f, 1.6f);
MelonCoroutines.Start(OutwardParticleRoutine(val2, velocity, life));
}
}
}
private void SpawnPurpleShockwave(Vector3 center, float maxRadius)
{
//IL_0036: Unknown result type (might be due to invalid IL or missing references)
//IL_0043: Unknown result type (might be due to invalid IL or missing references)
//IL_004d: Unknown result type (might be due to invalid IL or missing references)
//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
//IL_00d1: Expected O, but got Unknown
//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
GameObject val = GameObject.CreatePrimitive((PrimitiveType)0);
if ((Object)(object)val == (Object)null)
{
return;
}
Object.Destroy((Object)(object)val.GetComponent<Collider>());
((Object)val).name = "PurpleShockwave";
val.transform.position = center;
val.transform.localScale = Vector3.one * 0.1f;
Renderer component = val.GetComponent<Renderer>();
if ((Object)(object)component != (Object)null)
{
Shader val2 = Shader.Find("Sprites/Default") ?? Shader.Find("UI/Default") ?? Shader.Find("Legacy Shaders/Transparent/Diffuse") ?? Shader.Find("Unlit/Color") ?? Shader.Find("Standard");
if ((Object)(object)val2 != (Object)null)
{
component.material = new Material(val2);
component.material.color = new Color(1f, 1f, 1f, 0.35f);
if (component.material.HasProperty("_Mode"))
{
component.material.SetFloat("_Mode", 3f);
}
if (component.material.HasProperty("_SrcBlend"))
{
component.material.SetFloat("_SrcBlend", 5f);
}
if (component.material.HasProperty("_DstBlend"))
{
component.material.SetFloat("_DstBlend", 10f);
}
if (component.material.HasProperty("_ZWrite"))
{
component.material.SetFloat("_ZWrite", 0f);
}
component.material.renderQueue = 3000;
}
component.shadowCastingMode = (ShadowCastingMode)0;
component.receiveShadows = false;
}
MelonCoroutines.Start(PurpleShockwaveRoutine(val, maxRadius));
}
private IEnumerator PurpleShockwaveRoutine(GameObject wave, float maxRadius)
{
if ((Object)(object)wave == (Object)null)
{
yield break;
}
Renderer r = wave.GetComponent<Renderer>();
float elapsed = 0f;
float targetScale = maxRadius * 2f;
while ((Object)(object)wave != (Object)null && elapsed < 0.8f)
{
float t = elapsed / 0.8f;
float smoothT = Mathf.SmoothStep(0f, 1f, t);
wave.transform.localScale = Vector3.one * Mathf.Lerp(0.1f, targetScale, smoothT);
if ((Object)(object)r != (Object)null && (Object)(object)r.material != (Object)null)
{
Color c = r.material.color;
c.a = Mathf.Lerp(0.35f, 0f, smoothT);
r.material.color = c;
}
elapsed += Time.deltaTime;
yield return null;
}
if ((Object)(object)wave != (Object)null)
{
Object.Destroy((Object)(object)wave);
}
}
private Material GetRedParticleMaterial()
{
//IL_004f: Unknown result type (might be due to invalid IL or missing references)
//IL_0059: Expected O, but got Unknown
//IL_006e: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)redParticleMaterial != (Object)null)
{
return redParticleMaterial;
}
Shader val = Shader.Find("Sprites/Default") ?? Shader.Find("Unlit/Color") ?? Shader.Find("Standard");
if ((Object)(object)val != (Object)null)
{
redParticleMaterial = new Material(val);
redParticleMaterial.color = new Color(1f, 0.05f, 0.05f);
}
return redParticleMaterial;
}
private Material GetBlueParticleMaterial()
{
//IL_004f: Unknown result type (might be due to invalid IL or missing references)
//IL_0059: Expected O, but got Unknown
//IL_006e: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)blueParticleMaterial != (Object)null)
{
return blueParticleMaterial;
}
Shader val = Shader.Find("Sprites/Default") ?? Shader.Find("Unlit/Color") ?? Shader.Find("Standard");
if ((Object)(object)val != (Object)null)
{
blueParticleMaterial = new Material(val);
blueParticleMaterial.color = new Color(0.25f, 0.55f, 1f);
}
return blueParticleMaterial;
}
private Material GetPurpleParticleMaterial()
{
//IL_004f: Unknown result type (might be due to invalid IL or missing references)
//IL_0059: Expected O, but got Unknown
//IL_006e: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)purpleParticleMaterial != (Object)null)
{
return purpleParticleMaterial;
}
Shader val = Shader.Find("Sprites/Default") ?? Shader.Find("Unlit/Color") ?? Shader.Find("Standard");
if ((Object)(object)val != (Object)null)
{
purpleParticleMaterial = new Material(val);
purpleParticleMaterial.color = new Color(0.65f, 0.25f, 1f);
}
return purpleParticleMaterial;
}
private void SetupParticleRenderer(GameObject particle, Material material)
{
if ((Object)(object)particle == (Object)null)
{
return;
}
Renderer component = particle.GetComponent<Renderer>();
if (!((Object)(object)component == (Object)null))
{
if ((Object)(object)material != (Object)null)
{
component.material = material;
}
component.shadowCastingMode = (ShadowCastingMode)0;
component.receiveShadows = false;
}
}
private void SpawnFlightParticle(Vector3 position, Vector3 velocity, Material material)
{
//IL_0062: Unknown result type (might be due to invalid IL or missing references)
//IL_006c: Unknown result type (might be due to invalid IL or missing references)
//IL_0071: Unknown result type (might be due to invalid IL or missing references)
//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
//IL_0086: Unknown result type (might be due to invalid IL or missing references)
//IL_0089: Unknown result type (might be due to invalid IL or missing references)
//IL_008e: Unknown result type (might be due to invalid IL or missing references)
//IL_0098: Unknown result type (might be due to invalid IL or missing references)
//IL_009d: Unknown result type (might be due to invalid IL or missing references)
//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
//IL_013a: Unknown result type (might be due to invalid IL or missing references)
//IL_010a: Unknown result type (might be due to invalid IL or missing references)
//IL_010d: Unknown result type (might be due to invalid IL or missing references)
//IL_0112: Unknown result type (might be due to invalid IL or missing references)
//IL_011c: Unknown result type (might be due to invalid IL or missing references)
//IL_0121: Unknown result type (might be due to invalid IL or missing references)
//IL_0126: Unknown result type (might be due to invalid IL or missing references)
if (activeParticles >= 250 || (Object)(object)material == (Object)null)
{
return;
}
GameObject val = GameObject.CreatePrimitive((PrimitiveType)0);
if (!((Object)(object)val == (Object)null))
{
activeParticles++;
Object.Destroy((Object)(object)val.GetComponent<Collider>());
((Object)val).name = "FlightParticle";
Vector3 val2 = Random.insideUnitSphere * 0.06f;
if (((Vector3)(ref velocity)).sqrMagnitude > 0.001f)
{
val2 += -((Vector3)(ref velocity)).normalized * 0.05f;
}
val.transform.position = position + val2;
float num = Random.Range(0.004f, 0.012f);
val.transform.localScale = Vector3.one * num;
SetupParticleRenderer(val, material);
Vector3 val3 = Random.insideUnitSphere * 0.12f;
if (((Vector3)(ref velocity)).sqrMagnitude > 0.001f)
{
val3 += -((Vector3)(ref velocity)).normalized * 0.08f;
}
float life = Random.Range(0.25f, 0.55f);
MelonCoroutines.Start(FlightParticleRoutine(val, val3, life));
}
}
private IEnumerator FlightParticleRoutine(GameObject particle, Vector3 drift, float life)
{
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
//IL_0016: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)particle == (Object)null)
{
if (activeParticles > 0)
{
activeParticles--;
}
yield break;
}
Vector3 startScale = particle.transform.localScale;
float elapsed = 0f;
while ((Object)(object)particle != (Object)null && elapsed < life)
{
float dt = Time.deltaTime;
Vector3 pos = particle.transform.position;
particle.transform.position = pos + drift * dt;
drift *= 0.94f;
elapsed += dt;
float t = elapsed / life;
particle.transform.localScale = startScale * Mathf.Clamp01(1f - t);
yield return null;
}
if ((Object)(object)particle != (Object)null)
{
Object.Destroy((Object)(object)particle);
}
if (activeParticles > 0)
{
activeParticles--;
}
}
private bool IsPlayer(GameObject go)
{
if ((Object)(object)go == (Object)null)
{
return false;
}
Transform root = go.transform.root;
string text = (((Object)(object)root != (Object)null) ? ((Object)root).name : ((Object)go).name);
if (string.IsNullOrEmpty(text))
{
return false;
}
return text.Contains("Hexa4Rig") || text.Contains("Player");
}
private void ApplyDamage(GameObject target, Vector3 hitPosition, float damage, float radius)
{
//IL_0066: Unknown result type (might be due to invalid IL or missing references)
//IL_006d: Unknown result type (might be due to invalid IL or missing references)
//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
Component val = FindIl2CppComponent(target, "StickHealth");
if ((Object)(object)val == (Object)null && (Object)(object)target.transform.parent != (Object)null)
{
val = FindIl2CppComponent(((Component)target.transform.parent).gameObject, "StickHealth");
}
if ((Object)(object)val == (Object)null)
{
return;
}
Type type = ((object)val).GetType();
float num = Vector3.Distance(hitPosition, target.transform.position);
float num2 = 1f - num / radius;
float num3 = damage * Mathf.Clamp01(num2);
MethodInfo method = type.GetMethod("HitByBullet");
if (method != null)
{
try
{
method.Invoke(val, new object[3] { hitPosition, num3, false });
return;
}
catch
{
}
}
MethodInfo method2 = type.GetMethod("ReceivedGeneralDamage");
if (method2 != null)
{
try
{
Type nestedType = type.GetNestedType("DamageType");
object obj2 = 1;
if (nestedType != null && nestedType.IsEnum)
{
try
{
obj2 = Enum.Parse(nestedType, "Explosion");
}
catch
{
obj2 = Convert.ChangeType(1, nestedType);
}
}
method2.Invoke(val, new object[4] { num3, obj2, "torso", null });
return;
}
catch
{
}
}
MethodInfo method3 = type.GetMethod("KillZoneEntered");
if (!(method3 != null))
{
return;
}
try
{
method3.Invoke(val, null);
}
catch
{
}
}
private Component FindIl2CppComponent(GameObject go, string typeName)
{
if ((Object)(object)go == (Object)null)
{
return null;
}
Il2CppArrayBase<Component> components = go.GetComponents<Component>();
if (components == null)
{
return null;
}
foreach (Component item in components)
{
if ((Object)(object)item == (Object)null || !(((MemberInfo)((Object)item).GetIl2CppType()).Name == typeName))
{
continue;
}
return item;
}
return null;
}
}
