95d6fd3b14
F4: a hit that breaks the shield usually also cooks it (TakeHit's own AddHeat), which can knock the item thermally offline in the same tick. The reserve's recharge and its Broken-clearing check lived inside Execute, which Entity.Update only runs while Item.Active is true -- so a shield broken by a hit that also shuts it down could never come back, no matter how long RestoreDuration allows for. That logic now lives in Shield.Update (IAlwaysUpdatedBehavior), which Entity.Update calls every tick unconditionally (Cooldown.cs already relies on the same interface for the same reason). F5: CanTakeHit broke the shield and drained the reserve as a side effect of the query itself, on the premise that every caller queries it exactly once per hit. That premise was false: RaycastAll/SphereCastAll/OverlapSphere hand every caller under Assets/Scripts/Gameplay/Weapons both the shield collider and the hull collider for one shot, so the same shield's CanTakeHit was queried twice per hit. CanTakeHit is now a pure read (Broken + the reserve's own CanSpend); the mutation moved to a new Shield.Break(), idempotent, called by each weapon file exactly where it already decided to route a hit past the shield instead of absorbing it. Pinned in tests/Aetheria.Shared.Tests/ShieldReserveTests.cs: RestorationProceedsWhileTheItemIsInactive (F4), CanTakeHitNeverMutatesRegardlessOfHowManyTimesItIsCalled and BreakIsIdempotentAcrossRepeatedCalls (F5). Updated every existing test that relied on CanTakeHit's old mutating side effect to call Break() explicitly, matching the new caller pattern. Cannot compile-verify Assets/Scripts/Gameplay/Weapons/*.cs here (UnityEngine, Unity batchmode unavailable in this environment) -- reviewed by hand for brace/control-flow correctness; Self or a Unity batchmode pass should confirm. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
81 lines
3.3 KiB
C#
81 lines
3.3 KiB
C#
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using UnityEngine;
|
|
using static CultMath.math;
|
|
|
|
public class Laser : MonoBehaviour
|
|
{
|
|
public AnimationCurve IntensityCurve;
|
|
public float Duration;
|
|
public LineRenderer LineRenderer;
|
|
|
|
public float Damage { get; set; }
|
|
public float Penetration { get; set; }
|
|
public float Spread { get; set; }
|
|
public DamageType DamageType { get; set; }
|
|
public Entity SourceEntity { get; set; }
|
|
public float Range { get; set; }
|
|
|
|
private float _startTime;
|
|
private readonly Vector3[] _zeros = {Vector3.zero, Vector3.zero};
|
|
|
|
private void OnEnable()
|
|
{
|
|
_startTime = Time.time;
|
|
LineRenderer.SetPositions(_zeros);
|
|
}
|
|
|
|
private void Update()
|
|
{
|
|
var lerp = (Time.time - _startTime) / Duration;
|
|
if (lerp > 1)
|
|
{
|
|
GetComponent<Prototype>().ReturnToPool();
|
|
return;
|
|
}
|
|
|
|
LineRenderer.SetPosition(0, transform.position);
|
|
bool hitFound = false;
|
|
foreach (var hit in Physics.RaycastAll(new Ray(transform.position, transform.forward), Range, 1 | (1 << 17)))
|
|
{
|
|
var shield = hit.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 RaycastAll returns further down
|
|
// 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) continue;
|
|
if (shield.Entity != SourceEntity)
|
|
{
|
|
shieldBehavior.TakeHit(DamageType, Damage);
|
|
shield.ShowHit(hit.point, sqrt(Damage));
|
|
LineRenderer.SetPosition(1, hit.point);
|
|
hitFound = true;
|
|
break;
|
|
}
|
|
}
|
|
var hull = hit.collider.GetComponent<HullCollider>();
|
|
if (hull && !(hull.Entity.Shield != null && hull.Entity.Shield.Item.Active.Value && hull.Entity.Shield.CanTakeHit(DamageType, Damage)))
|
|
{
|
|
if (hull.Entity != SourceEntity)
|
|
{
|
|
hull.SendHit(Damage * (Time.deltaTime / Duration), Penetration, Spread, DamageType, SourceEntity, hit.textureCoord, transform.forward);
|
|
LineRenderer.SetPosition(1, hit.point);
|
|
hitFound = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if(!hitFound)
|
|
LineRenderer.SetPosition(1, transform.position + transform.forward * Range);
|
|
|
|
LineRenderer.widthMultiplier = IntensityCurve.Evaluate(lerp);
|
|
}
|
|
}
|