Cut 2 fix batch: a broken chunk absorbs no damage
Zone.Wear did not check whether the chunk was already broken. A later hit read wear.Damage starting from 0 (the value ChunkWear carries while BrokenUntil is in the future), stayed under hitpoints, and wrote BrokenUntil = null -- un-breaking a chunk mid-respawn. Damage delivered to a chunk that is currently broken (zone time < BrokenUntil) now changes nothing: Wear returns false (this hit did not break it -- it was already broken) and BrokenUntil, and Damage, are left untouched. The chunk stays absent until its original respawn time, then resumes wear from zero as before. Adds two behavioural tests: a re-hit inside the respawn window, both below and above hitpoints, must not un-break the chunk or move its respawn time; and the same rule survives a save/reload round trip. Confirmed by reverting the fix and watching both new tests fail with the chunk reappearing early, then restoring the fix byte-exactly. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
parent
a9538b205e
commit
34994732d2
2 changed files with 83 additions and 1 deletions
|
|
@ -255,13 +255,18 @@ public class Zone
|
|||
// Cut 2: the only writer of chunk wear. Returns whether this hit broke the chunk. The break threshold is
|
||||
// strictly greater-than, matching the deleted per-tick miner's own comparison against accumulated damage:
|
||||
// damage exactly equal to hitpoints does not yet break the chunk, only damage that exceeds them does.
|
||||
// A chunk that is currently broken (zone time < BrokenUntil) absorbs nothing: this hit did not break it
|
||||
// (it was already broken), and its wear stays zeroed until it respawns and starts fresh.
|
||||
public bool Wear(ChunkId chunk, float damage)
|
||||
{
|
||||
_wear.TryGetValue(chunk, out var wear);
|
||||
if (wear.BrokenUntil.HasValue && wear.BrokenUntil.Value > _time)
|
||||
return false;
|
||||
|
||||
var beltData = (AsteroidBeltData) Planets[chunk.Field];
|
||||
var size = beltData.Asteroids[chunk.Index].Size;
|
||||
var hitpoints = Settings.AsteroidHitpoints.Evaluate(size);
|
||||
|
||||
_wear.TryGetValue(chunk, out var wear);
|
||||
var newDamage = wear.Damage + damage;
|
||||
|
||||
if (newDamage > hitpoints)
|
||||
|
|
|
|||
|
|
@ -312,6 +312,83 @@ public sealed class MiningCut2Tests : IDisposable
|
|||
// separates a same-field-different-index or same-index-different-field pair into different buckets, so a
|
||||
// mutant weakening Equals from `&&` to `||` never got exercised by a lookup. This tests the value equality
|
||||
// directly, the way the operator's ruling actually describes chunk identity: same field AND same index.
|
||||
// Bug (found dormant, confirmed by Soul, on Cut 4's path): Wear did not check whether the chunk was already
|
||||
// broken. A later hit computed newDamage from a fresh 0f (ChunkWear's default Damage after breaking), stayed
|
||||
// under hitpoints, and wrote BrokenUntil = null -- un-breaking a chunk mid-respawn. The rule: damage to a
|
||||
// currently-broken chunk (zone time < BrokenUntil) changes nothing. It stays broken until its original
|
||||
// respawn time regardless of whether the re-hit is above or below hitpoints, and its wear starts from zero
|
||||
// only once it actually respawns.
|
||||
[Fact]
|
||||
public void HittingABrokenChunkDoesNotUnbreakItEitherBelowOrAboveHitpoints()
|
||||
{
|
||||
var f = BuildFixture();
|
||||
const int index = 4;
|
||||
var chunk = new ChunkId(f.BeltA, index);
|
||||
var hp = f.Settings.AsteroidHitpoints.Evaluate(f.AsteroidsA[index].Size);
|
||||
var respawn = f.Settings.AsteroidRespawnTime.Evaluate(f.AsteroidsA[index].Size);
|
||||
|
||||
Assert.True(f.Zone.Wear(chunk, hp + 1f));
|
||||
Assert.False(f.Zone.ChunkExists(chunk));
|
||||
|
||||
// A hit well under hitpoints, inside the respawn window: must not break it (it is already broken) and
|
||||
// must not touch BrokenUntil.
|
||||
f.Zone.Update(respawn * 0.2f);
|
||||
Assert.False(f.Zone.Wear(chunk, hp * 0.1f), "a hit on an already-broken chunk did not break it");
|
||||
Assert.False(f.Zone.ChunkExists(chunk), "must still be absent -- the old bug un-broke it here");
|
||||
Assert.Equal(0f, f.Zone.ChunkRadius(chunk));
|
||||
|
||||
// A second hit, this one alone well over hitpoints, inside the same window: still must not break it
|
||||
// (it is already broken) and must not push BrokenUntil further out.
|
||||
f.Zone.Update(respawn * 0.3f);
|
||||
Assert.False(f.Zone.Wear(chunk, hp + 50f), "a hit on an already-broken chunk did not break it, even when large");
|
||||
Assert.False(f.Zone.ChunkExists(chunk));
|
||||
|
||||
// Just under the original respawn time (measured from the original break, not from either re-hit):
|
||||
// still broken.
|
||||
f.Zone.Update(respawn * 0.45f);
|
||||
Assert.False(f.Zone.ChunkExists(chunk), "must still be broken just under the ORIGINAL respawn time");
|
||||
|
||||
// Crossing the original respawn time: present again, and unworn -- the re-hits left no residue.
|
||||
f.Zone.Update(respawn * 0.1f);
|
||||
Assert.True(f.Zone.ChunkExists(chunk), "must respawn at its original time despite the re-hits");
|
||||
Assert.Equal(f.Zone.AsteroidBelts[f.BeltA].UndamagedSize(index, f.Settings), f.Zone.ChunkRadius(chunk), 4);
|
||||
|
||||
// Worn again from fresh: breaks on the normal threshold, not one warped by the earlier no-op hits.
|
||||
Assert.False(f.Zone.Wear(chunk, hp * 0.9f));
|
||||
Assert.True(f.Zone.ChunkExists(chunk));
|
||||
Assert.True(f.Zone.Wear(chunk, hp * 0.2f));
|
||||
Assert.False(f.Zone.ChunkExists(chunk));
|
||||
}
|
||||
|
||||
// Same rule, checked across a save/reload: a re-hit taken while a chunk is broken must not move BrokenUntil,
|
||||
// and that must survive the pack/unpack round trip -- not just live in the same Zone instance.
|
||||
[Fact]
|
||||
public void ReHitDuringRespawnSurvivesSaveRoundTripAtTheSameAbsoluteTime()
|
||||
{
|
||||
var f = BuildFixture();
|
||||
const int idx = 3;
|
||||
var chunk = new ChunkId(f.BeltB, idx);
|
||||
var hp = f.Settings.AsteroidHitpoints.Evaluate(f.AsteroidsB[idx].Size);
|
||||
var respawn = f.Settings.AsteroidRespawnTime.Evaluate(f.AsteroidsB[idx].Size);
|
||||
|
||||
Assert.True(f.Zone.Wear(chunk, hp + 1f));
|
||||
f.Zone.Update(respawn * 0.4f);
|
||||
Assert.False(f.Zone.Wear(chunk, hp * 0.5f), "re-hit inside the window did not break an already-broken chunk");
|
||||
|
||||
var pack = f.Zone.PackZone();
|
||||
var reloaded = new Zone(f.Items, f.Settings, pack, new GalaxyZone { Name = "MiningCut2ReHitReload", Owner = null }, null);
|
||||
|
||||
Assert.False(reloaded.ChunkExists(chunk), "still broken immediately after reload");
|
||||
|
||||
// Just under the original respawn time (measured from the original break at zone time 0): still broken.
|
||||
reloaded.Update(respawn * 0.59f);
|
||||
Assert.False(reloaded.ChunkExists(chunk), "must still be broken just under the ORIGINAL respawn time after reload");
|
||||
|
||||
reloaded.Update(respawn * 0.02f);
|
||||
Assert.True(reloaded.ChunkExists(chunk), "must respawn at its original absolute time after reload, unmoved by the re-hit");
|
||||
Assert.Equal(f.Zone.AsteroidBelts[f.BeltB].UndamagedSize(idx, f.Settings), reloaded.ChunkRadius(chunk), 4);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void ChunkIdEqualityRequiresBothFieldAndIndex()
|
||||
{
|
||||
|
|
|
|||
Loading…
Reference in a new issue