Aetheria/Assets/Scripts/Gameplay/Weapons/Mine.cs

using System;
using System.Collections;
using System.Collections.Generic;
using CultMath;
using static CultMath.math;
using UnityEngine;
using Random = UnityEngine.Random;

public class Mine : MonoBehaviour
{
    public GridObject GridObject;
    public MeshRenderer MeshRenderer;
    public int EmissionSubmesh;
    public AnimationCurve EmissionCurve;
    public float ActiveCycleDuration;
    public float ArmedCycleDuration;
    public float ActiveEmission;
    public float ArmedEmission;
    public Prototype HitEffect;
    public float Lifetime;

    public float ActivationDelay;
    public float BlastRange;
    public float BlastDelay;

    private float _startTime;
    private float _blastTime;
    private bool _blastCountdown;
    private bool _active;
    private Material _material;
    private float _pulseLerp;
    private float _emission;
    public float Damage { get; set; }
    public DamageType DamageType { get; set; }
    public EntityInstance Source { get; set; }
    public float Range { get; set; }

    private void Start()
    {
        _material = MeshRenderer.materials[EmissionSubmesh];
    }

    private void OnEnable()
    {
        _startTime = Time.time;
        _blastCountdown = false;
        _active = false;
        _emission = 0;
    }

    // Update is called once per frame
    void Update()
    {
        var position = transform.position;
        
        if (Time.time - _startTime > ActivationDelay && !_active)
        {
            _active = true;
        }
        
        if(_active)
        {
            _emission = lerp(_emission, _blastCountdown ? ArmedEmission : ActiveEmission, Time.deltaTime * 10);
            _pulseLerp += Time.deltaTime / (_blastCountdown ? ArmedCycleDuration : ActiveCycleDuration);
            _pulseLerp %= 1;
            if(!_blastCountdown)
            {
                foreach (var collider in Physics.OverlapSphere(position, BlastRange, 1))
                {
                    var hull = collider.GetComponent<HullCollider>();
                    if (hull)
                    {
                        _blastCountdown = true;
                        _blastTime = Time.time + BlastDelay;
                    }
                }
            }

            if ((position - Source.transform.position).magnitude > Range ||
                Time.time - _startTime > Lifetime ||
                _blastCountdown && Time.time > _blastTime)
            {
                Explode();
            }
        }
        _material.SetFloat("_Emission", _emission * EmissionCurve.Evaluate(_pulseLerp));
    }

    public void Explode()
    {
        var position = transform.position;
        foreach (var collider in Physics.OverlapSphere(position, BlastRange, 1 | (1 << 17)))
        {
            var shield = collider.GetComponent<ShieldManager>();
            if (shield)
            {
                var shieldBehavior = shield.Entity.Shield;
                var shieldActive = shieldBehavior != null && shieldBehavior.Item.Active.Value;
                var shieldAbsorbs = shieldActive && shieldBehavior.CanTakeHit(DamageType, Damage);
                // F5 (docs/stats-and-power-cut.md, Soul pass 2026-09-19): CanTakeHit is a pure query now -- read
                // once into shieldAbsorbs, and break the shield exactly once, right here, at the point this hit
                // is actually decided to route past it (to the hull collider OverlapSphere returns as a
                // separate entry in this same loop) instead of being absorbed. The hull branch below re-queries
                // CanTakeHit safely -- it is side-effect-free -- and will see Broken already true.
                if (shieldActive && !shieldAbsorbs) shieldBehavior.Break();
                if (shieldAbsorbs)
                {
                    shieldBehavior.TakeHit(DamageType, Damage);
                    shield.ShowHit(position, sqrt(Damage));
                }
            }
            var hull = collider.GetComponent<HullCollider>();
            if (hull && !(hull.Entity.Shield != null && hull.Entity.Shield.Item.Active.Value && hull.Entity.Shield.CanTakeHit(DamageType, Damage)))
            {
                hull.SendSplash(Damage, DamageType, Source.Entity, (collider.transform.position - position).normalized);
            }
        }

        var ht = HitEffect.Instantiate<Transform>();
        ht.position = position;
        GetComponent<Prototype>().ReturnToPool();
    }
}