Adds AConsumableModifierBoostsUntilExpiry, ABoughtConsumableActivates and ANonStackableConsumableRefusesASecondActivation. This commit builds; its tests fail until the host cut lands. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
152 lines
6.9 KiB
C#
152 lines
6.9 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using CultMath;
|
|
using GameCult.Caching;
|
|
using Xunit;
|
|
|
|
// A consumable is a cargo item with a timed effect (aetheria-release CS-R1). Its modifiers exist in the resolver
|
|
// exactly while its effect is active: the host (Entity) initialises the effect's behaviours at activation and
|
|
// disposes them at expiry, and ItemManager.CreateInstance is the one way a lot becomes a ConsumableItem.
|
|
public sealed class ConsumableTests : IDisposable
|
|
{
|
|
private readonly string _root = Path.Combine(Path.GetTempPath(), "aetheria-consumable-" + Guid.NewGuid().ToString("N"));
|
|
private string Catalog => Path.Combine(_root, "Aetheria.cc");
|
|
private static readonly int2 EngineCell = new int2(0, 0);
|
|
private static readonly int2 HoldCell = new int2(1, 1);
|
|
|
|
public ConsumableTests() => Directory.CreateDirectory(_root);
|
|
public void Dispose() => Directory.Delete(_root, true);
|
|
|
|
private sealed class Rig
|
|
{
|
|
public CultCache Cache;
|
|
public ItemManager Items;
|
|
public Ship Ship;
|
|
public EquippedItem Engine;
|
|
public PerformanceStat Thrust;
|
|
public ConsumableItemData Consumable;
|
|
public CultRecordKey Key;
|
|
public CultRecordRef<Faction> Maker;
|
|
|
|
public ConsumableItem Mint() => Assert.IsType<ConsumableItem>(Items.CreateInstance(Items.CreateLot(Consumable, Maker, .5f)));
|
|
public EquippedCargoBay Hold => Ship.CargoBays.Single();
|
|
public int InCargo => Hold.Cargo.Keys.Count(i => i is ConsumableItem);
|
|
}
|
|
|
|
// A ship with a thruster (Thrust 10) and a hold; the consumable doubles ThrusterData.Thrust for one second.
|
|
private Rig Build(bool stackable = false)
|
|
{
|
|
var thrust = new PerformanceStat { Min = 10, Max = 10 };
|
|
var cache = AetheriaStores.Open(Catalog, catalogWritable: true);
|
|
cache.Upsert(new TestCatalogGlobal { Name = "Temperament" });
|
|
cache.Upsert(new Faction { Name = "Maker", ShortName = "MKR" });
|
|
var hullShape = new Shape(3, 3);
|
|
foreach (var cell in hullShape.AllCoordinates) hullShape[cell] = true;
|
|
var hullRef = cache.Upsert(new HullData
|
|
{
|
|
Name = "Skiff", HullType = HullType.Ship, Shape = hullShape, Durability = 10,
|
|
Hardpoints = { new HardpointData { Type = HardpointType.Sensors, Position = EngineCell, Shape = new Shape() } }
|
|
});
|
|
var engineRef = cache.Upsert(new GearData
|
|
{
|
|
Name = "Engine", Hardpoint = HardpointType.Sensors, Shape = new Shape(), Durability = 10,
|
|
Behaviors = { new ThrusterData { Thrust = thrust } }
|
|
});
|
|
var interior = new Shape(1, 1);
|
|
foreach (var cell in interior.AllCoordinates) interior[cell] = true;
|
|
var holdRef = cache.Upsert(new CargoBayData { Name = "Hold", Shape = new Shape(), InteriorShape = interior, Durability = 10 });
|
|
var consumableRef = cache.Upsert(new ConsumableItemData
|
|
{
|
|
Name = "Overdrive", Duration = 1f, Stackable = stackable, Shape = new Shape(),
|
|
Behaviors =
|
|
{
|
|
new StatModifierData
|
|
{
|
|
Stat = new StatReference { Target = nameof(ThrusterData), Stat = nameof(ThrusterData.Thrust) },
|
|
Modifier = new PerformanceStat { Min = 2, Max = 2 },
|
|
Type = StatModifierType.Multiplier
|
|
}
|
|
}
|
|
});
|
|
cache.FlushAsync().Wait();
|
|
|
|
var items = new ItemManager(cache, new ProvenanceLedger(), RunSaveTests.TestSettings(), _ => { });
|
|
var makerRef = cache.RefOf(cache.GetByName<Faction>("Maker"));
|
|
EquippableItem Gear(EquippableItemData design) => (EquippableItem) items.CreateInstance(items.CreateLot(design, makerRef, .5f));
|
|
var zone = new Zone(items, new PlanetSettings(), new ZonePack(), new GalaxyZone { Name = "Test Zone", Owner = null }, null);
|
|
var ship = new Ship(items, zone, Gear(cache.Get(hullRef)), new EntitySettings());
|
|
Assert.True(ship.TryEquip(Gear(cache.Get(engineRef)), EngineCell));
|
|
Assert.True(ship.TryEquip(Gear(cache.Get(holdRef)), HoldCell));
|
|
zone.Entities.Add(ship);
|
|
ship.Activate();
|
|
var data = cache.Get(consumableRef);
|
|
return new Rig
|
|
{
|
|
Cache = cache, Items = items, Ship = ship, Thrust = thrust, Consumable = data,
|
|
Key = items.ItemData.RefOf<ItemData>(data).Key,
|
|
Engine = ship.Equipment.Single(e => e.Data.Name == "Engine"),
|
|
Maker = makerRef
|
|
};
|
|
}
|
|
|
|
// Two ticks after activation the modifier has attached (the first tick executes it, the second applies it).
|
|
private static void Tick(Rig rig, int times, float dt)
|
|
{
|
|
for (var i = 0; i < times; i++) rig.Ship.Update(dt);
|
|
}
|
|
|
|
// The rule: a consumable's modifiers exist in the resolver exactly while its effect is active, never after.
|
|
// Observed at the resolved stat and at the resolver's modifier entry count, not at a flag.
|
|
[Fact]
|
|
public void AConsumableModifierBoostsUntilExpiry()
|
|
{
|
|
var rig = Build();
|
|
using var _ = rig.Cache;
|
|
var resolver = rig.Ship.Resolver;
|
|
Assert.Equal(10f, rig.Engine.Evaluate(rig.Thrust), 3);
|
|
var baseline = resolver.ModifierEntryCount;
|
|
|
|
rig.Ship.ActivateConsumable(rig.Mint());
|
|
Tick(rig, 2, .3f); // 0.4s of the 1s remain; the modifier has attached
|
|
Assert.Equal(20f, rig.Engine.Evaluate(rig.Thrust), 3);
|
|
Assert.True(resolver.ModifierEntryCount > baseline);
|
|
|
|
Tick(rig, 3, .3f); // 0.9s elapsed in all: expired on the third of these ticks
|
|
Assert.Equal(10f, rig.Engine.Evaluate(rig.Thrust), 3);
|
|
Assert.Equal(baseline, resolver.ModifierEntryCount);
|
|
}
|
|
|
|
// A lot minted through the one production path is a ConsumableItem, and a hold holding it activates it.
|
|
[Fact]
|
|
public void ABoughtConsumableActivates()
|
|
{
|
|
var rig = Build();
|
|
using var _ = rig.Cache;
|
|
Assert.True(rig.Hold.TryStore(rig.Mint()));
|
|
Assert.Equal(1, rig.InCargo);
|
|
|
|
Assert.True(rig.Ship.TryActivateConsumable(rig.Consumable));
|
|
Assert.Equal(0, rig.InCargo);
|
|
Assert.NotNull(rig.Ship.FindActiveConsumable(rig.Consumable));
|
|
}
|
|
|
|
// CS-R1: a non-stackable design allows one active effect at a time, so its Duration is its cooldown.
|
|
[Fact]
|
|
public void ANonStackableConsumableRefusesASecondActivation()
|
|
{
|
|
var rig = Build();
|
|
using var _ = rig.Cache;
|
|
Assert.True(rig.Hold.TryStore(rig.Mint()));
|
|
Assert.True(rig.Hold.TryStore(rig.Mint()));
|
|
|
|
Assert.True(rig.Ship.TryActivateConsumable(rig.Consumable));
|
|
Assert.False(rig.Ship.TryActivateConsumable(rig.Consumable));
|
|
Assert.Equal(1, rig.InCargo);
|
|
|
|
Tick(rig, 5, .3f); // the first effect has run out
|
|
Assert.True(rig.Ship.TryActivateConsumable(rig.Consumable));
|
|
Assert.Equal(0, rig.InCargo);
|
|
}
|
|
}
|