VanguardReMaster/client/Assets/Vanguard/Tests/Editor/GameBoard3DTests.cs

using System.Collections.Generic;
using System.Linq;
using NUnit.Framework;
using UnityEngine;
using Vanguard.Board3D;
using Vanguard.Shared.Protocol;

namespace Vanguard.Tests
{
    public sealed class GameBoard3DTests
    {
        [Test]
        public void Board_Renders_Field_Hand_Guardian_Damage_And_Soul()
        {
            var config = PlaymatLayoutConfig.CreateDefault();
            var board = GameBoard3D.Create(null, config);
            try
            {
                board.SetVisible(true);
                board.Render(BuildView(you: 0), new BoardRenderState());

                var cards = ActiveCards();
                Assert.GreaterOrEqual(cards.Count, 9);

                Assert.IsTrue(cards.Any(card =>
                    card.Ref.Zone == BoardZone.RearGuard
                    && card.Ref.Player == 0
                    && card.Ref.Slot == 3));
                Assert.IsTrue(cards.Any(card =>
                    card.Ref.Zone == BoardZone.Guardian
                    && card.Ref.InstanceId == 7));
                Assert.IsTrue(cards.Any(card =>
                    card.Ref.Zone == BoardZone.Hand
                    && card.Ref.Player == 0));
                Assert.IsTrue(cards.Any(card =>
                    card.Ref.Zone == BoardZone.Damage
                    && card.Ref.Player == 0));

                var rested = cards.Single(card =>
                    card.Ref.Zone == BoardZone.RearGuard
                    && card.Ref.Player == 0
                    && card.Ref.Slot == 3);
                Assert.IsTrue(rested.IsRested);
                Assert.AreEqual(90f, Mathf.Abs(Mathf.DeltaAngle(rested.TargetYaw, 0f)), 0.1f);

                var hiddenDamage = cards.Single(card =>
                    card.Ref.Zone == BoardZone.Damage
                    && card.Ref.Player == 0
                    && card.Ref.Index == 1);
                Assert.IsFalse(hiddenDamage.IsFaceUp);
                Assert.IsTrue(hiddenDamage.IsRested);

                var visibleDamage = cards.Single(card =>
                    card.Ref.Zone == BoardZone.Damage
                    && card.Ref.Player == 0
                    && card.Ref.Index == 0);
                Assert.IsTrue(visibleDamage.IsFaceUp);
                Assert.AreEqual(
                    -90f,
                    Mathf.DeltaAngle(0f, visibleDamage.TargetYaw),
                    0.1f,
                    "Damage cards must rest counter-clockwise");
            }
            finally
            {
                Object.DestroyImmediate(board.gameObject);
            }
        }

        [Test]
        public void Pool_Reuses_Cards_Between_Snapshots()
        {
            var config = PlaymatLayoutConfig.CreateDefault();
            var board = GameBoard3D.Create(null, config);
            try
            {
                board.SetVisible(true);
                var view = BuildView(you: 0);
                board.Render(view, new BoardRenderState());
                var count = ActiveCards().Count;

                board.Render(view, new BoardRenderState());
                Assert.AreEqual(count, ActiveCards().Count);
            }
            finally
            {
                Object.DestroyImmediate(board.gameObject);
            }
        }

        [Test]
        public void Local_Seat_Is_Always_Bottom_Of_The_Board()
        {
            var config = PlaymatLayoutConfig.CreateDefault();
            var board = GameBoard3D.Create(null, config);
            try
            {
                board.SetVisible(true);
                board.Render(BuildView(you: 1), new BoardRenderState());

                var vanguard = ActiveCards().Single(card =>
                    card.Ref.Zone == BoardZone.Vanguard
                    && card.Ref.Player == 1);
                Assert.Less(vanguard.TargetPosition.z, 0f);

                var opponent = ActiveCards().Single(card =>
                    card.Ref.Zone == BoardZone.Vanguard
                    && card.Ref.Player == 0);
                Assert.Greater(opponent.TargetPosition.z, 0f);
            }
            finally
            {
                Object.DestroyImmediate(board.gameObject);
            }
        }

        [Test]
        public void Highlight_And_Selection_State_Is_Applied_To_Cards()
        {
            var config = PlaymatLayoutConfig.CreateDefault();
            var board = GameBoard3D.Create(null, config);
            try
            {
                board.SetVisible(true);
                var state = new BoardRenderState();
                state.Highlights.Add(new BoardSlotKey(0, 3));
                state.SelectedHandInstanceIds.Add(12);
                board.Render(BuildView(you: 0), state);

                var rested = ActiveCards().Single(card =>
                    card.Ref.Zone == BoardZone.RearGuard
                    && card.Ref.Player == 0
                    && card.Ref.Slot == 3);
                Assert.IsTrue(rested.transform.Find("Highlight").gameObject.activeSelf);
            }
            finally
            {
                Object.DestroyImmediate(board.gameObject);
            }
        }

        private static List<Card3D> ActiveCards() =>
            Resources.FindObjectsOfTypeAll<Card3D>()
                .Where(card => card.gameObject.activeInHierarchy)
                .ToList();

        private static MatchView BuildView(int you)
        {
            CardView Card(string id, int instance, bool rested = false, bool faceUp = true) =>
                new CardView
                {
                    PrintingId = id,
                    InstanceId = instance,
                    Rested = rested,
                    FaceUp = faceUp,
                    Power = 8000,
                    BasePower = 8000,
                    Critical = 1,
                    BaseCritical = 1,
                };

            var self = new PlayerView
            {
                Index = you,
                Name = "Self",
                Vanguard = Card("BT01/001EN", 1),
                RearGuards = new CardView[5],
                Hand = new List<CardView>
                {
                    Card("BT01/002EN", 11),
                    Card("BT01/003EN", 12),
                },
                Guardian = new List<CardView> { Card("BT01/004EN", 7) },
                Soul = new List<CardView> { Card("BT01/005EN", 8) },
                FaceUpDamage = new List<CardView> { Card("BT01/006EN", 9) },
                FaceDownDamage = 2,
                DeckCount = 40,
                Drop = new List<CardView>(),
            };
            self.RearGuards[3] = Card("BT01/007EN", 5, rested: true);

            var otherIndex = 1 - you;
            var opponent = new PlayerView
            {
                Index = otherIndex,
                Name = "Opponent",
                Vanguard = Card("BT01/010EN", 21),
                RearGuards = new CardView[5],
                Hand = new List<CardView>(),
                Guardian = new List<CardView>(),
                Soul = new List<CardView>(),
                FaceUpDamage = new List<CardView>(),
                FaceDownDamage = 0,
                DeckCount = 40,
                Drop = new List<CardView>(),
            };
            opponent.RearGuards[4] = Card("BT01/011EN", 22, rested: true);

            return new MatchView
            {
                MatchId = "board-test",
                You = you,
                ActivePlayer = you,
                Phase = GamePhase.Main,
                Players = new List<PlayerView> { self, opponent },
                Clock = new ClockView(),
                LegalIntents = new List<IntentPayload>(),
            };
        }
    }
}