tiny_tackle_heroes/Assets/_Project/Tests/EditMode/PassiveRelicRulesTests.cs

using System.Reflection;
using BumpCombat.Enemies;
using BumpCombat.Progression;
using BumpCombat.Player;
using NUnit.Framework;
using UnityEngine;

namespace BumpCombat.Tests
{
    public sealed class PassiveRelicRulesTests
    {
        [TestCase(0.149f, true)]
        [TestCase(0.15f, false)]
        [TestCase(0.99f, false)]
        public void RollChance_UsesExclusiveUpperThreshold(float roll, bool expected)
        {
            Assert.That(PassiveRelicRules.RollsChance(0.15f, roll), Is.EqualTo(expected));
        }

        [TestCase(true, true, false, 0.1f, 20f)]
        [TestCase(true, false, false, 0.1f, 10f)]
        [TestCase(true, true, true, 0.1f, 10f)]
        [TestCase(false, true, false, 0.1f, 10f)]
        public void TwinHorn_DoublesOnlyOwnedOrdinaryBumps(
            bool ownsRelic,
            bool ordinaryBump,
            bool artifactHit,
            float roll,
            float expected)
        {
            Assert.That(PassiveRelicRules.ApplyTwinHornDamage(
                10f, ownsRelic, ordinaryBump, artifactHit, 0.15f, roll),
                Is.EqualTo(expected));
        }

        [Test]
        public void ZeroDamagePulseEcho_HasNoCastOrPlayerSideEffects()
        {
            GameObject owner = new("Passive Relic Echo Test Player");
            ActiveArtifactDefinition pulse = ScriptableObject.CreateInstance<ActiveArtifactDefinition>();
            try
            {
                owner.AddComponent<PlayerStats>();
                owner.AddComponent<Rigidbody2D>();
                ActiveArtifactController artifacts = owner.AddComponent<ActiveArtifactController>();
                SetField(pulse, "artifactId", "pulse-test");
                SetField(pulse, "effect", ActiveArtifactEffect.Pulse);
                SetField(pulse, "normalDamage", 0f);
                artifacts.Configure(new[] { pulse });
                Assert.That(artifacts.TryAddArtifact(pulse), Is.True);

                typeof(ActiveArtifactController)
                    .GetField("<CurrentGauge>k__BackingField", BindingFlags.Instance | BindingFlags.NonPublic)
                    ?.SetValue(artifacts, 12f);
                float gaugeBefore = artifacts.CurrentGauge;
                Vector3 positionBefore = owner.transform.position;
                int successfulUses = 0;
                artifacts.OnArtifactUseSucceeded += (_, _) => successfulUses++;

                bool emitted = artifacts.TryEmitPassiveRelicEcho(owner.transform.position, Vector2.right, 0.5f);

                Assert.That(emitted, Is.False);
                Assert.That(artifacts.CurrentGauge, Is.EqualTo(gaugeBefore));
                Assert.That(owner.transform.position, Is.EqualTo(positionBefore));
                Assert.That(artifacts.LocksMovement, Is.False);
                Assert.That(artifacts.IsExecutingArtifact, Is.False);
                Assert.That(successfulUses, Is.Zero);
            }
            finally
            {
                Object.DestroyImmediate(owner);
                Object.DestroyImmediate(pulse);
            }
        }

        [TestCase(EnemyDamageSource.Player, true)]
        [TestCase(EnemyDamageSource.PassiveRelicAttack, true)]
        [TestCase(EnemyDamageSource.PassiveRelicExplosion, true)]
        [TestCase(EnemyDamageSource.PassiveRelicTransferredIgnite, true)]
        [TestCase(EnemyDamageSource.Tower, false)]
        public void RewardKillCredit_ExcludesTowers(
            EnemyDamageSource source,
            bool expected)
        {
            Assert.That(PassiveRelicRules.IsPlayerRewardKill(source),
                Is.EqualTo(expected));
        }

        private static void SetField<T>(ActiveArtifactDefinition definition, string fieldName, T value)
        {
            typeof(ActiveArtifactDefinition)
                .GetField(fieldName, BindingFlags.Instance | BindingFlags.NonPublic)
                ?.SetValue(definition, value);
        }
        [Test]
        public void AvailableRelics_ExcludesOwnedIdsAndPreservesCatalogOrder()
        {
            PassiveRelicId[] catalog = PassiveRelicRules.GetAvailableRelics(
                System.Array.Empty<PassiveRelicId>());
            PassiveRelicId[] expected = (PassiveRelicId[])
                System.Enum.GetValues(typeof(PassiveRelicId));
            Assert.That(catalog, Is.EqualTo(expected));
            Assert.That(catalog.Length, Is.EqualTo(20));

            PassiveRelicId[] afterOne = PassiveRelicRules.GetAvailableRelics(
                new[] { PassiveRelicId.ResonanceCore });
            Assert.That(afterOne, Has.None.EqualTo(PassiveRelicId.ResonanceCore));
            Assert.That(afterOne.Length, Is.EqualTo(19));
            Assert.That(PassiveRelicRules.GetAvailableRelics(expected), Is.Empty);
        }
        [Test]
        public void RuptureDamageAndRadiusScaleFromEnemyHealthAndPlayerBody()
        {
            Assert.That(PassiveRelicRules.GetExplosionDamage(1000f, 0.1f), Is.EqualTo(100f));
            Assert.That(PassiveRelicRules.GetExplosionRadius(1.2f, 3f), Is.EqualTo(3.6f).Within(0.0001f));
        }

        [TestCase(EnemyDamageSource.Player, true)]
        [TestCase(EnemyDamageSource.PassiveRelicAttack, true)]
        [TestCase(EnemyDamageSource.Tower, false)]
        [TestCase(EnemyDamageSource.PassiveRelicExplosion, false)]
        [TestCase(EnemyDamageSource.None, false)]
        public void PlayerKillCredit_ExcludesTowerAndRelicExplosion(EnemyDamageSource source, bool expected)
        {
            Assert.That(PassiveRelicRules.IsPlayerCreditedKill(source), Is.EqualTo(expected));
        }
    }
}