itai.sharim/TagFight - Change W42U55HSXS45MZUEXGCSKLO5UV4CWBQN2IZPCKZPWPDSB56FVZDAC

Integrate ReleaseWeave with EffectSystem. Effect seems to fire incorrectly?

Created by itai.sharim on October 5, 2023

W42U55HSXS45MZUEXGCSKLO5UV4CWBQN2IZPCKZPWPDSB56FVZDAC

Dependencies

In channels

main

Change contents

Replacement in Assets/Scripts/Systems/Effects/IEffectSystem.cs at line 1 [4.1742]

B:BD[4.1742] → [5.15595:16137]

using System.Collections.Generic;
using TagFighter.Resources;
using UnityEngine;
using System;
public interface IEffectSystem
{
    void ApplyTagsEffect(IEnumerable<(Type, IUnit)> tags, Transform origin, Quaternion direction, IAreaOfEffect areaOfEffect);
    Color GetEffectColor(IEnumerable<(Type, IUnit)> tags);
    Mesh CreateArcMesh(Vector3 direction, float arc, float length, int numberOfVerticesInArc, Vector3 rotationAxis);
    Mesh CreateQuadMesh(Vector3 direction, float width, float length, Vector3 rotationAxis);
}

[4.1742]

using System.Collections.Generic;
using TagFighter.Resources;
using UnityEngine;
using System;
public interface IEffectSystem
{
    void ApplyTagsEffect(IEnumerable<(Type, IUnit)> tags, Transform origin, Quaternion direction, IAreaOfEffect areaOfEffect);
    void ApplyTagsEffect(IEnumerable<(Type, IUnit)> tags, Transform origin, Transform effectLocation, IAreaOfEffect areaOfEffect);
    Color GetEffectColor(IEnumerable<(Type, IUnit)> tags);
    Mesh CreateArcMesh(Vector3 direction, float arc, float length, int numberOfVerticesInArc, Vector3 rotationAxis);
    Mesh CreateQuadMesh(Vector3 direction, float width, float length, Vector3 rotationAxis);
}

Replacement in Assets/Scripts/Systems/Effects/EffectSystem.cs at line 1 [4.2503]

B:BD[4.2503] → [2.359:8253]

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using CareBoo.Serially;
using TagFighter.Resources;
using UnityEngine;
[ProvideSourceInfo]
[Serializable]
public class EffectSystem : IEffectSystem
{
    ParticleSystem _rippleOutVfx;
    [SerializeField] TagFighter.Effects.EffectColors _colorMapping;
    const string PulseMaterial = "Materials/PulseMaterial2";
    class EffectRunner : MonoBehaviour
    {
        public GameObject EffectObj;
        public Material Material;
        public float PlayTime;
        public void Run(GameObject effectObj, Material material, float playTime) {
            EffectObj = effectObj;
            Material = material;
            PlayTime = playTime;
            Material.SetFloat("_Phase", 0);
            EffectObj.SetActive(true);
            StartCoroutine("PlayEffect");
        }
        public IEnumerator PlayEffect() {
            float totalTime = 0;
            float phase = 0;
            while (phase < 0.98) {
                totalTime += Time.deltaTime;
                phase = totalTime / PlayTime;
                Material.SetFloat("_Phase", phase);
                yield return null;
            }
            Destroy(EffectObj);
        }
    }
    public EffectSystem() {
    }
    public void ApplyTagsEffect(IEnumerable<(Type, IUnit)> tags, Transform origin, Quaternion direction, IAreaOfEffect areaOfEffect) {
        switch (areaOfEffect) {
            case SingleTarget: ApplyTagsEffectSingle(); break;
            case CircleArea aoe: ApplyTagsEffectRadius(tags, origin, direction, aoe); break;
            case ConeArea aoe: ApplyTagsEffectCone(tags, origin, direction, aoe); break;
            case PathArea aoe: ApplyTagsEffectPath(tags, origin, direction, aoe); break;
        }
    }
    void ApplyTagsEffectSingle() {
        Debug.Log("ApplyTagsEffectSingle");
    }
    void ApplyTagsEffectPath(IEnumerable<(Type, IUnit)> tags, Transform origin, Quaternion direction, PathArea areaOfEffect) {
        var color = GetEffectColor(tags);
        var mesh = CreateQuadMeshForUnit(origin, areaOfEffect.Width, areaOfEffect.Length);
        // Add a new to clone the shared resource
        Material material = new(Resources.Load<Material>(PulseMaterial));
        material.SetColor("_Color", color);
        DisplayEffect(origin, direction, mesh, material);
    }
    void ApplyTagsEffectRadius(IEnumerable<(Type, IUnit)> tags, Transform origin, Quaternion direction, CircleArea areaOfEffect) {
        var color = GetEffectColor(tags);
        var mesh = CreateArcMeshForUnit(origin, 360, areaOfEffect.Radius);
        // Add a new to clone the shared resource
        Material material = new(Resources.Load<Material>(PulseMaterial));
        material.SetColor("_Color", color);
        DisplayEffect(origin, direction, mesh, material);
    }
    void ApplyTagsEffectCone(IEnumerable<(Type, IUnit)> tags, Transform origin, Quaternion direction, ConeArea areaOfEffect) {
        Debug.Log("ApplyTagsEffectCone");
        var color = GetEffectColor(tags);
        var mesh = CreateArcMeshForUnit(origin, areaOfEffect.Angle, areaOfEffect.Radius);
        // Add a new to clone the shared resource
        Material material = new(Resources.Load<Material>(PulseMaterial));
        material.SetColor("_Color", color);
        DisplayEffect(origin, direction, mesh, material);
    }
    public Color GetEffectColor(IEnumerable<(Type, IUnit)> tags) {
        Debug.Log("GetEffectColor");
        var color = new Color();
        Debug.Log($"GetEffectColor length {tags.Count()}");
        if (_colorMapping != null) {
            foreach (var tag in tags) {
                Debug.Log("GetEffectColor tag");
                if (_colorMapping.ContainsKey(tag.Item1)) {
                    Debug.Log("GetEffectColor mapping found");
                    var mappedColor = _colorMapping[tag.Item1];
                    // TODO: scale color by amount
                    color += mappedColor;
                }
            }
        }
        Debug.Log("GetEffectColor Finished");
        return color;
    }
    public Mesh CreateArcMeshForUnit(Transform unit, float arc, float length, int numberOfVerticesInArc = 100) {
        return CreateArcMesh(unit.forward, arc, length, numberOfVerticesInArc, Vector3.up);
    }
    public Mesh CreateQuadMeshForUnit(Transform unit, float width, float length) {
        return CreateQuadMesh(unit.forward, width, length, Vector3.up);
    }
    void DisplayEffect(Transform originUnit, Quaternion direction, Mesh mesh, Material material) {
        GameObject effectObj = new();
        effectObj.SetActive(false);
        effectObj.transform.position = originUnit.position;
        effectObj.transform.rotation = direction;
        var meshRenderer = effectObj.AddComponent<MeshRenderer>();
        meshRenderer.sharedMaterial = material;
        meshRenderer.shadowCastingMode = 0;
        meshRenderer.receiveShadows = false;
        var meshFilter = effectObj.AddComponent<MeshFilter>();
        meshFilter.mesh = mesh;
        effectObj.AddComponent<EffectRunner>();
        var effectRunner = effectObj.GetComponent<EffectRunner>();
        effectRunner.Run(effectObj, material, 1f);
    }
    public Mesh CreateArcMesh(Vector3 direction, float arc, float length, int numberOfVerticesInArc, Vector3 rotationAxis) {
        var origin = Vector3.zero;
        Mesh mesh = new();
        var n = numberOfVerticesInArc + 1;
        var arcStep = arc / (n - 2);
        var currentDegrees = -arc / 2;
        var vertices = new Vector3[n];
        var uv = new Vector2[n];
        vertices[0] = origin;
        uv[0] = origin;
        for (var i = 1; i < n; i++) {
            vertices[i] = Quaternion.AngleAxis(currentDegrees, rotationAxis) * direction * length;
            uv[i] = new Vector2(0, 1);
            //Debug.Log($"Current Degrees: {currentDegrees} -> {vertices[i]}");
            currentDegrees += arcStep;
        }
        mesh.vertices = vertices;
        mesh.uv = uv;
        var tris = new int[(n - 2) * 3];
        for (var i = 0; i < n - 2; i++) {
            tris[i * 3] = 0;
            tris[i * 3 + 1] = i + 1;
            tris[i * 3 + 2] = i + 2;
        }
        mesh.triangles = tris;
        var normals = new Vector3[n];
        for (var i = 0; i < n; i++) {
            normals[i] = rotationAxis;
        }
        mesh.normals = normals;
        return mesh;
    }
    public Mesh CreateQuadMesh(Vector3 direction, float width, float length, Vector3 rotationAxis) {
        Mesh mesh = new();
        var origin = Vector3.zero;
        // TODO: how to calculate local rotation? direction
        var vertices = new Vector3[4]
        {
            new Vector3(-width/2, 0, 0) + origin,
            new Vector3(width/2, 0, 0) + origin,
            new Vector3(-width/2, 0, length) + origin,
            new Vector3(width/2, 0, length) + origin
        };
        mesh.vertices = vertices;
        var tris = new int[6]
        {
            // lower left triangle
            0, 2, 1,
            // upper right triangle
            2, 3, 1
        };
        mesh.triangles = tris;
        var normals = new Vector3[4]
        {
            rotationAxis,
            rotationAxis,
            rotationAxis,
            rotationAxis
        };
        mesh.normals = normals;
        var uv = new Vector2[4]
        {
            new Vector2(0, 0),
            new Vector2(1, 0),
            new Vector2(0, 1),
            new Vector2(1, 1)
        };
        mesh.uv = uv;
        return mesh;
    }
}

[4.2503]

#nullable enable
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using CareBoo.Serially;
using TagFighter.Resources;
using UnityEngine;
[ProvideSourceInfo]
[Serializable]
public class EffectSystem : IEffectSystem
{
    // ParticleSystem _rippleOutVfx;
    [SerializeField] TagFighter.Effects.EffectColors? _colorMapping;
    const string PulseMaterial = "Materials/PulseMaterial2";
    class EffectRunner : MonoBehaviour
    {
        public GameObject? EffectObj;
        public Material? Material;
        public float PlayTime;
        public void Run(GameObject effectObj, Material material, float playTime) {
            EffectObj = effectObj;
            Material = material;
            PlayTime = playTime;
            Material.SetFloat("_Phase", 0);
            EffectObj.SetActive(true);
            StartCoroutine(PlayEffect(material, PlayTime));
        }
        public IEnumerator PlayEffect(Material material, float playTime) {
            float totalTime = 0;
            float phase = 0;
            while (phase < 0.98) {
                totalTime += Time.deltaTime;
                phase = totalTime / playTime;
                material.SetFloat("_Phase", phase);
                yield return null;
            }
            Destroy(EffectObj);
        }
    }
    public EffectSystem() {
    }
    public void ApplyTagsEffect(IEnumerable<(Type, IUnit)> tags, Transform origin, Quaternion direction, IAreaOfEffect areaOfEffect) {
        switch (areaOfEffect) {
            case SingleTarget: ApplyTagsEffectSingle(); break;
            case CircleArea aoe: ApplyTagsEffectRadius(tags, origin, direction, aoe); break;
            case ConeArea aoe: ApplyTagsEffectCone(tags, origin, direction, aoe); break;
            case PathArea aoe: ApplyTagsEffectPath(tags, origin, direction, aoe); break;
        }
    }
    public void ApplyTagsEffect(IEnumerable<(Type, IUnit)> tags, Transform origin, Transform effectLocation, IAreaOfEffect areaOfEffect) {
        var directionVector = (effectLocation.position - origin.position).normalized;
        directionVector.y = 0;
        var direction = Quaternion.LookRotation(directionVector, Vector3.up);
        ApplyTagsEffect(tags, origin, direction, areaOfEffect);
    }
    void ApplyTagsEffectSingle() {
        Debug.Log("ApplyTagsEffectSingle");
    }
    void ApplyTagsEffectPath(IEnumerable<(Type, IUnit)> tags, Transform origin, Quaternion direction, PathArea areaOfEffect) {
        var color = GetEffectColor(tags);
        var mesh = CreateQuadMeshForUnit(origin, areaOfEffect.Width, areaOfEffect.Length);
        // Add a new to clone the shared resource
        Material material = new(Resources.Load<Material>(PulseMaterial));
        material.SetColor("_Color", color);
        DisplayEffect(origin, direction, mesh, material);
    }
    void ApplyTagsEffectRadius(IEnumerable<(Type, IUnit)> tags, Transform origin, Quaternion direction, CircleArea areaOfEffect) {
        var color = GetEffectColor(tags);
        var mesh = CreateArcMeshForUnit(origin, 360, areaOfEffect.Radius);
        // Add a new to clone the shared resource
        Material material = new(Resources.Load<Material>(PulseMaterial));
        material.SetColor("_Color", color);
        DisplayEffect(origin, direction, mesh, material);
    }
    void ApplyTagsEffectCone(IEnumerable<(Type, IUnit)> tags, Transform origin, Quaternion direction, ConeArea areaOfEffect) {
        Debug.Log("ApplyTagsEffectCone");
        var color = GetEffectColor(tags);
        var mesh = CreateArcMeshForUnit(origin, areaOfEffect.Angle, areaOfEffect.Radius);
        // Add a new to clone the shared resource
        Material material = new(Resources.Load<Material>(PulseMaterial));
        material.SetColor("_Color", color);
        DisplayEffect(origin, direction, mesh, material);
    }
    public Color GetEffectColor(IEnumerable<(Type, IUnit)> tags) {
        Debug.Log("GetEffectColor");
        var color = new Color();
        Debug.Log($"GetEffectColor length {tags.Count()}");
        if (_colorMapping != null) {
            foreach (var tag in tags) {
                Debug.Log("GetEffectColor tag");
                if (_colorMapping.ContainsKey(tag.Item1)) {
                    Debug.Log("GetEffectColor mapping found");
                    var mappedColor = _colorMapping[tag.Item1];
                    // TODO: scale color by amount
                    color += mappedColor;
                }
            }
        }
        Debug.Log("GetEffectColor Finished");
        return color;
    }
    public Mesh CreateArcMeshForUnit(Transform unit, float arc, float length, int numberOfVerticesInArc = 100) {
        return CreateArcMesh(unit.forward, arc, length, numberOfVerticesInArc, Vector3.up);
    }
    public Mesh CreateQuadMeshForUnit(Transform unit, float width, float length) {
        return CreateQuadMesh(unit.forward, width, length, Vector3.up);
    }
    void DisplayEffect(Transform originUnit, Quaternion direction, Mesh mesh, Material material) {
        GameObject effectObj = new();
        effectObj.SetActive(false);
        effectObj.transform.position = originUnit.position;
        effectObj.transform.rotation = direction;
        var meshRenderer = effectObj.AddComponent<MeshRenderer>();
        meshRenderer.sharedMaterial = material;
        meshRenderer.shadowCastingMode = 0;
        meshRenderer.receiveShadows = false;
        var meshFilter = effectObj.AddComponent<MeshFilter>();
        meshFilter.mesh = mesh;
        effectObj.AddComponent<EffectRunner>();
        var effectRunner = effectObj.GetComponent<EffectRunner>();
        effectRunner.Run(effectObj, material, 1f);
    }
    public Mesh CreateArcMesh(Vector3 direction, float arc, float length, int numberOfVerticesInArc, Vector3 rotationAxis) {
        var origin = Vector3.zero;
        Mesh mesh = new();
        var n = numberOfVerticesInArc + 1;
        var arcStep = arc / (n - 2);
        var currentDegrees = -arc / 2;
        var vertices = new Vector3[n];
        var uv = new Vector2[n];
        vertices[0] = origin;
        uv[0] = origin;
        for (var i = 1; i < n; i++) {
            vertices[i] = Quaternion.AngleAxis(currentDegrees, rotationAxis) * direction * length;
            uv[i] = new Vector2(0, 1);
            //Debug.Log($"Current Degrees: {currentDegrees} -> {vertices[i]}");
            currentDegrees += arcStep;
        }
        mesh.vertices = vertices;
        mesh.uv = uv;
        var tris = new int[(n - 2) * 3];
        for (var i = 0; i < n - 2; i++) {
            tris[i * 3] = 0;
            tris[i * 3 + 1] = i + 1;
            tris[i * 3 + 2] = i + 2;
        }
        mesh.triangles = tris;
        var normals = new Vector3[n];
        for (var i = 0; i < n; i++) {
            normals[i] = rotationAxis;
        }
        mesh.normals = normals;
        return mesh;
    }
    public Mesh CreateQuadMesh(Vector3 direction, float width, float length, Vector3 rotationAxis) {
        Mesh mesh = new();
        var origin = Vector3.zero;
        // TODO: how to calculate local rotation? direction
        var vertices = new Vector3[4]
        {
            new Vector3(-width/2, 0, 0) + origin,
            new Vector3(width/2, 0, 0) + origin,
            new Vector3(-width/2, 0, length) + origin,
            new Vector3(width/2, 0, length) + origin
        };
        mesh.vertices = vertices;
        var tris = new int[6]
        {
            // lower left triangle
            0, 2, 1,
            // upper right triangle
            2, 3, 1
        };
        mesh.triangles = tris;
        var normals = new Vector3[4]
        {
            rotationAxis,
            rotationAxis,
            rotationAxis,
            rotationAxis
        };
        mesh.normals = normals;
        var uv = new Vector2[4]
        {
            new Vector2(0, 0),
            new Vector2(1, 0),
            new Vector2(0, 1),
            new Vector2(1, 1)
        };
        mesh.uv = uv;
        return mesh;
    }
}

Replacement in Assets/Scripts/Systems/Effects/DummyEffectSystem.cs at line 1 [4.10082]

B:BD[4.10082] → [5.23907:24768]

using System.Collections.Generic;
using TagFighter.Resources;
using UnityEngine;
using System;
class DummyEffectSystem : IEffectSystem
{
    public void ApplyTagsEffect(IEnumerable<(Type, IUnit)> tags, Transform origin, Quaternion direction, IAreaOfEffect areaOfEffect) {
        Debug.Log("Dummy:ApplyTagsEffect");
    }
    public Color GetEffectColor(IEnumerable<(Type, IUnit)> tags) {
        Debug.Log("Dummy:GetEffectColor");
        return Color.cyan;
    }
    public Mesh CreateArcMesh(Vector3 direction, float arc, float length, int numberOfVerticesInArc, Vector3 rotationAxis) {
        Debug.Log("Dummy:CreateArcMesh");
        return null;
    }
    public Mesh CreateQuadMesh(Vector3 direction, float width, float length, Vector3 rotationAxis) {
        Debug.Log("Dummy:CreateQuadMesh");
        return null;
    }
}

[4.10082]

using System.Collections.Generic;
using TagFighter.Resources;
using UnityEngine;
using System;
class DummyEffectSystem : IEffectSystem
{
    public void ApplyTagsEffect(IEnumerable<(Type, IUnit)> tags, Transform origin, Quaternion direction, IAreaOfEffect areaOfEffect) {
        Debug.Log("Dummy:ApplyTagsEffect");
    }
    public void ApplyTagsEffect(IEnumerable<(Type, IUnit)> tags, Transform origin, Transform effectLocation, IAreaOfEffect areaOfEffect) {
        Debug.Log("Dummy:ApplyTagsEffect");
    }
    public Color GetEffectColor(IEnumerable<(Type, IUnit)> tags) {
        Debug.Log("Dummy:GetEffectColor");
        return Color.cyan;
    }
    public Mesh CreateArcMesh(Vector3 direction, float arc, float length, int numberOfVerticesInArc, Vector3 rotationAxis) {
        Debug.Log("Dummy:CreateArcMesh");
        return null;
    }
    public Mesh CreateQuadMesh(Vector3 direction, float width, float length, Vector3 rotationAxis) {
        Debug.Log("Dummy:CreateQuadMesh");
        return null;
    }
}

Replacement in Assets/Scripts/Combat/Runes/RuneRef.cs at line 20 [7.2420]

B:BD[6.51372] → [3.11702:11855]

            var blackBoard = new EffectInput(context, new Transform[] { context.EffectLocation }, TagFighter.Resources.StatModifierAccessor.Permanent);

[6.51372]

[3.11855]

            var blackBoard = new EffectInput(context, Enumerable.Empty<Transform>(), TagFighter.Resources.StatModifierAccessor.Permanent);

File deletion: Zip.cs.meta

BF:BFD[6.5348] → [8.246:281]

BF:BFD[8.281] → [8.1:1]

B:BD[8.1] → [8.2:245]

fileFormatVersion: 2
guid: bfce83ffec5b7b14a85ec10ce4e193ab
MonoImporter:
  externalObjects: {}
  serializedVersion: 2
  defaultReferences: []
  executionOrder: 0
  icon: {instanceID: 0}
  userData: 
  assetBundleName: 
  assetBundleVariant:

File deletion: Zip.cs

BF:BFD[6.5348] → [8.1999:2029]

BF:BFD[8.2029] → [8.283:283]

B:BD[8.283] → [3.12470:12488]

∅:D[3.12488] → [8.284:689]

B:BD[8.283] → [8.284:689]

∅:D[3.12534] → [8.733:948]

B:BD[8.733] → [8.733:948]

∅:D[3.12615] → [9.5176:5212]

B:BD[9.5176] → [9.5176:5212]

∅:D[3.12689] → [9.5279:5292]

B:BD[9.5279] → [9.5279:5292]

∅:D[9.5331] → [8.1213:1228]

∅:D[3.12939] → [8.1213:1228]

B:BD[8.1213] → [8.1213:1228]

∅:D[9.5387] → [8.1362:1861]

∅:D[3.13155] → [8.1362:1861]

B:BD[8.1362] → [8.1362:1861]

∅:D[3.13215] → [10.2357:2608]

B:BD[10.2357] → [10.2357:2608]

∅:D[10.2608] → [8.1977:1988]

B:BD[8.1977] → [8.1977:1988]

B:BD[8.1988] → [10.2609:2945]

∅:D[10.2945] → [8.1988:1998]

B:BD[8.1988] → [8.1988:1998]

B:BD[8.1861] → [3.13156:13215]

B:BD[8.1228] → [3.12940:13155]

B:BD[9.5292] → [3.12690:12939]

B:BD[9.5212] → [3.12616:12689]

B:BD[8.948] → [3.12535:12615]

B:BD[8.689] → [3.12489:12534]

#nullable enable
namespace TagFighter.Effects.Steps
{
    using System.Collections.Generic;
    using System.Linq;
    using CareBoo.Serially;
    [StepType(StepTypeAttribute.OperatorStep)]
    public class Zip : OutputStep<IEnumerable<double>>
    {
        [UnityEngine.SerializeField]
        MultiPort<IEnumerable<double>> _in = new();
        [UnityEngine.SerializeReference, ShowSerializeReference]
        [UnityEngine.SerializeField]
        List<double> _const = new();
        public override IEnumerable<IPort> Inputs {
            get {
                yield return _in;
            }
        }
            double defaultVal = 0;
        }
            }
                        .Aggregate((current, next) =>
                        current.Zip(next, (first, second) =>
                        Operator.Operate(first, second)));
        }
        public override string ToString() {
            var operatorName = Operator == null ? "*" : Operator.GetType().Name;
            var constName = _const.Count == 0 ? "" : $"({string.Join(",", _const.Select(val => $"{val}[]"))})";
            return $"Zip.{operatorName}{constName}";
        }
        public override EffectStepNodeData ToData() {
            var effectStepNodeData = base.ToData();
            effectStepNodeData.Const = _const;
            effectStepNodeData.Operator = Operator;
            return effectStepNodeData;
        }
        public override bool FromData(EffectStepNodeData effectStepNodeData, Dictionary<string, EffectStepNode> guidToNode) {
            base.FromData(effectStepNodeData, guidToNode);
            _const = effectStepNodeData.Const ?? new();
            Operator = effectStepNodeData.Operator;
            return true;
        }
    }
}
        public override bool IsValid => Operator != null;
            return _in.Nodes.Select(getter => getter.Run(blackBoard)).Concat(_const.Select(value => blackBoard.Affected.Select(transform => value)))
                        .DefaultIfEmpty(GetDefault(blackBoard))
        public override IEnumerable<double> Run(EffectInput blackBoard) {
            if (!IsValid || Operator == null) {
                UnityEngine.Debug.LogError($"{Guid} Inner types are null");
                return GetDefault(blackBoard);
            return blackBoard.Affected.Select(transform => defaultVal);
        public static IEnumerable<double> GetDefault(EffectInput blackBoard) {
        public IResourceOperator? Operator;

File deletion: Repeat.cs.meta

BF:BFD[6.5348] → [8.2276:2314]

BF:BFD[8.2314] → [8.2031:2031]

B:BD[8.2031] → [8.2032:2275]

fileFormatVersion: 2
guid: bb9a9a2cce40a384084a18925a111186
MonoImporter:
  externalObjects: {}
  serializedVersion: 2
  defaultReferences: []
  executionOrder: 0
  icon: {instanceID: 0}
  userData: 
  assetBundleName: 
  assetBundleVariant:

File deletion: Repeat.cs

BF:BFD[6.5348] → [8.3038:3071]

BF:BFD[8.3071] → [8.2316:2316]

B:BD[8.2316] → [3.13779:13797]

∅:D[3.13797] → [8.2317:2618]

B:BD[8.2316] → [8.2317:2618]

∅:D[3.14021] → [8.2774:3037]

B:BD[8.2774] → [8.2774:3037]

B:BD[8.2618] → [3.13798:14021]

#nullable enable
namespace TagFighter.Effects.Steps
{
    using System.Collections.Generic;
    using System.Linq;
    [StepType(StepTypeAttribute.OperatorStep)]
    public class Repeat : OutputStep<IEnumerable<double>>
    {
        [UnityEngine.SerializeField]
        SinglePort<double> _in = new();
        }
        public override IEnumerable<IPort> Inputs {
            get {
                yield return _in;
            }
        }
        public override string ToString() => "Repeat";
        public override bool IsValid => true;
    }
}
        public override IEnumerable<double> Run(EffectInput blackBoard) {
            var value = _in.Node != null ? _in.Node.Run(blackBoard) : default;
            return blackBoard.Affected.Select(transform => value);

File deletion: PawnResourceSet.cs.meta

BF:BFD[6.5348] → [8.3318:3365]

BF:BFD[8.3365] → [8.3073:3073]

B:BD[8.3073] → [8.3074:3317]

fileFormatVersion: 2
guid: 844f2211c024f444f876e89a2321a495
MonoImporter:
  externalObjects: {}
  serializedVersion: 2
  defaultReferences: []
  executionOrder: 0
  icon: {instanceID: 0}
  userData: 
  assetBundleName: 
  assetBundleVariant:

File deletion: PawnResourceSet.cs

BF:BFD[6.5348] → [8.5639:5681]

BF:BFD[8.5681] → [8.3367:3367]

∅:D[3.14042] → [8.3370:3788]

B:BD[8.3370] → [8.3370:3788]

∅:D[3.14104] → [8.3848:4399]

B:BD[8.3848] → [8.3848:4399]

∅:D[3.14291] → [8.4538:4853]

B:BD[8.4538] → [8.4538:4853]

∅:D[3.14378] → [8.4916:4964]

B:BD[8.4916] → [8.4916:4964]

∅:D[3.14445] → [8.5014:5128]

B:BD[8.5014] → [8.5014:5128]

B:BD[8.5274] → [8.5274:5276]

∅:D[3.15035] → [8.5576:5591]

B:BD[8.5576] → [8.5576:5591]

∅:D[10.3259] → [8.5591:5593]

B:BD[8.5591] → [8.5591:5593]

∅:D[10.3556] → [8.5593:5630]

B:BD[8.5593] → [8.5593:5630]

∅:D[10.3559] → [8.5630:5638]

B:BD[8.5630] → [8.5630:5638]

B:BD[8.5630] → [10.3557:3559]

B:BD[8.5593] → [10.3260:3556]

B:BD[8.5591] → [10.2952:2954]

∅:D[3.15065] → [10.2980:3259]

B:BD[10.2980] → [10.2980:3259]

B:BD[10.2954] → [3.15036:15065]

B:BD[8.5276] → [3.14446:15035]

B:BD[8.4964] → [3.14379:14445]

B:BD[8.4853] → [3.14292:14378]

B:BD[8.4399] → [3.14105:14291]

B:BD[8.3788] → [3.14043:14104]

B:BD[8.3367] → [3.14024:14042]


namespace TagFighter.Effects.Steps
{
    using System.Linq;
    using System.Reflection;
    using System.Collections.Generic;
    [StepType(StepTypeAttribute.SetterStep)]
    public class PawnResourceSet : OutputStep<bool>
    {
        [UnityEngine.SerializeField]
        SinglePort<IEnumerable<double>> _in = new();
        [CareBoo.Serially.TypeFilter(derivedFrom: typeof(Resources.Resource<>))]
        public override IEnumerable<IPort> Inputs {
            get {
                yield return _in;
            }
        }
        public override string ToString() {
            var resourceName = Resource == null || Resource.Type == null ? "*" : Resource.Type.Name;
            var statName = "Current";
            return $"Pawn.Set.{resourceName}.{statName}";
        }
        public override bool IsValid {
            get {
                return Resource != null && Resource.Type != null;
            }
        }
                return false;
            }
            var getSpecificMethod = typeof(PawnResourceSet).GetMethod(nameof(SetSpecific), BindingFlags.NonPublic | BindingFlags.Instance).
                                            MakeGenericMethod(Resource.Type, Resource.Type.BaseType.GetGenericArguments()[0]);
            return (bool)value;
        }
            where TResource : Resources.Resource<TUnitType>
            where TUnitType : Resources.IUnitType {
            }
            return true;
        }
    }
}
        public override bool FromData(EffectStepNodeData effectStepNodeData, Dictionary<string, EffectStepNode> guidToNode) {
            base.FromData(effectStepNodeData, guidToNode);
            Resource = effectStepNodeData.Resource;
            // Register = effectStepNodeData.Register;
        }
        public override EffectStepNodeData ToData() {
            var effectStepNodeData = base.ToData();
            effectStepNodeData.Resource = Resource;
            // effectStepNodeData.Register = Register;
            return effectStepNodeData;
        }
            return success;
            var success = false;
            if (_in.Node != null) {
                var result = _in.Node.Run(Data);
                UnityEngine.Debug.Log($"{nameof(PawnResourceSet)} result {string.Join(",", result)}");
                var set = result.Zip(Data.Affected.Select(transform => transform.GetComponent<TResource>()), (value, resource) => (value, resource));
                foreach (var (value, resource) in set) {
                    Data.StatAccessor.AddCurrentModifier(resource, (Resources.Unit<TUnitType>)value);
                }
                success = true;
        bool SetSpecific<TResource, TUnitType>(EffectInput Data)
            var value = getSpecificMethod.Invoke(this, new object[] { blackBoard });
        public override bool Run(EffectInput blackBoard) {
            if (!IsValid || Resource == null) {
                UnityEngine.Debug.LogError($"{Guid} Inner types are null");
        public CareBoo.Serially.SerializableType? Resource;
#nullable enable

File deletion: PawnResourceGet.cs.meta

BF:BFD[6.5348] → [8.5928:5975]

BF:BFD[8.5975] → [8.5683:5683]

B:BD[8.5683] → [8.5684:5927]

fileFormatVersion: 2
guid: 9aba2983d5b304644a37facc1967f5de
MonoImporter:
  externalObjects: {}
  serializedVersion: 2
  defaultReferences: []
  executionOrder: 0
  icon: {instanceID: 0}
  userData: 
  assetBundleName: 
  assetBundleVariant:

File deletion: PawnResourceGet.cs

BF:BFD[6.5348] → [8.7921:7963]

BF:BFD[8.7963] → [8.5977:5977]

B:BD[8.5977] → [3.15068:15086]

∅:D[3.15086] → [8.5978:6317]

B:BD[8.5977] → [8.5978:6317]

∅:D[3.15148] → [8.6377:6379]

B:BD[8.6377] → [8.6377:6379]

∅:D[3.15273] → [8.6461:6533]

B:BD[8.6461] → [8.6461:6533]

∅:D[3.15343] → [8.6596:6882]

B:BD[8.6596] → [8.6596:6882]

∅:D[3.15430] → [8.6945:6947]

B:BD[8.6945] → [8.6945:6947]

∅:D[3.15479] → [8.6997:7010]

B:BD[8.6997] → [8.6997:7010]

∅:D[3.15567] → [8.7075:7189]

B:BD[8.7075] → [8.7075:7189]

∅:D[3.15701] → [8.7402:7897]

B:BD[8.7402] → [8.7402:7897]

∅:D[10.4165] → [8.7897:7908]

B:BD[8.7897] → [8.7897:7908]

∅:D[10.4168] → [8.7908:7920]

B:BD[8.7908] → [8.7908:7920]

B:BD[8.7908] → [10.4166:4168]

B:BD[8.7897] → [10.3562:4165]

B:BD[8.7189] → [3.15568:15701]

B:BD[8.7010] → [3.15480:15567]

B:BD[8.6947] → [3.15431:15479]

B:BD[8.6882] → [3.15344:15430]

B:BD[8.6533] → [3.15274:15343]

B:BD[8.6379] → [3.15149:15273]

B:BD[8.6317] → [3.15087:15148]

#nullable enable
namespace TagFighter.Effects.Steps
{
    using System.Collections.Generic;
    using System.Linq;
    using System.Reflection;
    [StepType(StepTypeAttribute.GetterStep)]
    public class PawnResourceGet : OutputStep<IEnumerable<double>>
    {
        [CareBoo.Serially.TypeFilter(derivedFrom: typeof(Resources.Resource<>))]
                UnityEngine.Debug.Log($"{Guid} Inner types are null");
            }
            var getSpecificMethod = typeof(PawnResourceGet).GetMethod(nameof(GetSpecific), BindingFlags.NonPublic | BindingFlags.Instance).
                                            MakeGenericMethod(Resource.Type, Resource.Type.BaseType.GetGenericArguments()[0]);
        }
            where TResource : Resources.Resource<TUnitType>
            where TUnitType : Resources.IUnitType {
        }
        public override IEnumerable<IPort> Inputs => Enumerable.Empty<IPort>();
        public override string ToString() {
            var resourceName = Resource == null || Resource.Type == null ? "*" : Resource.Type.Name;
            var statName = "Current";
            return $"Pawn.Get.{resourceName}.{statName}";
        }
        public override bool IsValid {
            get {
                return Resource != null && Resource.Type != null;
            }
        }
    }
}
        }
        public override EffectStepNodeData ToData() {
            var effectStepNodeData = base.ToData();
            effectStepNodeData.Resource = Resource;
            // effectStepNodeData.Register = Register;
            return effectStepNodeData;
        }
        public override bool FromData(EffectStepNodeData effectStepNodeData, Dictionary<string, EffectStepNode> guidToNode) {
            base.FromData(effectStepNodeData, guidToNode);
            Resource = effectStepNodeData.Resource;
            // Register = effectStepNodeData.Register;
            return true;
            return blackBoard.Affected.Select(transform => (double)transform.GetComponent<TResource>().GetCurrent().AsPrimitive());
        IEnumerable<double> GetSpecific<TResource, TUnitType>(EffectInput blackBoard)
            return (IEnumerable<double>)value;
            var value = getSpecificMethod.Invoke(this, new object[] { blackBoard });
                return blackBoard.Affected.Select(transform => 0d);
        public override IEnumerable<double> Run(EffectInput blackBoard) {
            if (!IsValid || Resource == null) {
        public CareBoo.Serially.SerializableType? Resource;

File deletion: Operate.cs.meta

BF:BFD[6.5348] → [8.8210:8249]

BF:BFD[8.8249] → [8.7965:7965]

B:BD[8.7965] → [8.7966:8209]

fileFormatVersion: 2
guid: 93ba90a75f8f1fe4189ea1ed3890ae3e
MonoImporter:
  externalObjects: {}
  serializedVersion: 2
  defaultReferences: []
  executionOrder: 0
  icon: {instanceID: 0}
  userData: 
  assetBundleName: 
  assetBundleVariant:

File deletion: Operate.cs

BF:BFD[6.5348] → [8.9485:9519]

BF:BFD[8.9519] → [8.8251:8251]

B:BD[8.8251] → [3.15704:15722]

∅:D[3.15722] → [8.8252:8623]

B:BD[8.8251] → [8.8252:8623]

∅:D[3.15768] → [8.8667:9159]

B:BD[8.8667] → [8.8667:9159]

∅:D[9.5459] → [8.9159:9161]

B:BD[8.9159] → [8.9159:9161]

∅:D[9.5634] → [8.9262:9277]

B:BD[8.9262] → [8.9262:9277]

B:BD[8.9288] → [8.9288:9290]

∅:D[3.16073] → [8.9435:9465]

B:BD[8.9435] → [8.9435:9465]

∅:D[10.4769] → [8.9465:9484]

B:BD[8.9465] → [8.9465:9484]

B:BD[8.9465] → [10.4171:4769]

B:BD[8.9290] → [3.15958:16073]

∅:D[3.15957] → [9.5601:5634]

B:BD[9.5601] → [9.5601:5634]

B:BD[8.9161] → [3.15769:15957]

B:BD[8.9159] → [9.5398:5459]

B:BD[8.8623] → [3.15723:15768]

#nullable enable
namespace TagFighter.Effects.Steps
{
    using System.Collections.Generic;
    using System.Linq;
    [StepType(StepTypeAttribute.OperatorStep)]
    public class Operate : OutputStep<double>
    {
        [UnityEngine.SerializeField]
        MultiPort<double> _in = new();
        [UnityEngine.SerializeReference, CareBoo.Serially.ShowSerializeReference]
        [UnityEngine.SerializeField]
        List<double> _const = new();
        public override IEnumerable<IPort> Inputs {
            get {
                yield return _in;
            }
        }
        public override string ToString() {
            var operatorName = Operator == null ? "*" : Operator.GetType().Name;
            var constName = _const.Count == 0 ? "" : $"({string.Join(",", _const)})";
            return $"{operatorName}{constName}";
        }
            }
            return result;
        }
    }
}
        }
        public override EffectStepNodeData ToData() {
            var effectStepNodeData = base.ToData();
            effectStepNodeData.Const = _const;
            effectStepNodeData.Operator = Operator;
            return effectStepNodeData;
        }
        public override bool FromData(EffectStepNodeData effectStepNodeData, Dictionary<string, EffectStepNode> guidToNode) {
            base.FromData(effectStepNodeData, guidToNode);
            _const = effectStepNodeData.Const ?? new();
            Operator = effectStepNodeData.Operator;
            return true;
            var result = Operator.OperateEnum(_in.Nodes.Select(getter => getter.Run(blackBoard)).Concat(_const));
                return default;
        public override double Run(EffectInput blackBoard) {
            if (!IsValid || Operator == null) {
                UnityEngine.Debug.LogError($"{Guid} Inner types are null");
        public override bool IsValid => Operator != null;
        public IResourceOperator? Operator;

File deletion: Fold.cs.meta

BF:BFD[6.5348] → [8.9766:9802]

BF:BFD[8.9802] → [8.9521:9521]

B:BD[8.9521] → [8.9522:9765]

fileFormatVersion: 2
guid: ba8070acc07ec7f448050fe3c5cd4278
MonoImporter:
  externalObjects: {}
  serializedVersion: 2
  defaultReferences: []
  executionOrder: 0
  icon: {instanceID: 0}
  userData: 
  assetBundleName: 
  assetBundleVariant:

File deletion: Fold.cs

BF:BFD[6.5348] → [8.10843:10874]

BF:BFD[8.10874] → [8.9804:9804]

B:BD[8.9804] → [3.16076:16094]

∅:D[3.16094] → [8.9805:10187]

B:BD[8.9804] → [8.9805:10187]

∅:D[3.16594] → [8.10231:10233]

B:BD[8.10231] → [8.10231:10233]

∅:D[3.16732] → [8.10371:10705]

B:BD[8.10371] → [8.10371:10705]

∅:D[3.16792] → [10.4783:4984]

B:BD[10.4783] → [10.4783:4984]

∅:D[10.4984] → [8.10821:10832]

B:BD[8.10821] → [8.10821:10832]

∅:D[10.5264] → [8.10832:10842]

B:BD[8.10832] → [8.10832:10842]

B:BD[8.10832] → [10.4985:5264]

B:BD[8.10705] → [3.16733:16792]

B:BD[8.10233] → [3.16595:16732]

B:BD[8.10187] → [3.16095:16594]

#nullable enable
namespace TagFighter.Effects.Steps
{
    using System.Collections.Generic;
    using System.Linq;
    [StepType(StepTypeAttribute.OperatorStep)]
    public class Fold : OutputStep<double>
    {
        [UnityEngine.SerializeField]
        SinglePort<IEnumerable<double>> _in = new();
        [UnityEngine.SerializeReference, CareBoo.Serially.ShowSerializeReference]
        }
        public override IEnumerable<IPort> Inputs {
            get {
                yield return _in;
            }
        }
        public override string ToString() {
            var operatorName = Operator == null ? "*" : Operator.GetType().Name;
            return $"Fold.{operatorName}";
        }
        public override EffectStepNodeData ToData() {
            var effectStepNodeData = base.ToData();
            effectStepNodeData.Operator = Operator;
            return effectStepNodeData;
        }
    }
}
        public override bool FromData(EffectStepNodeData effectStepNodeData, Dictionary<string, EffectStepNode> guidToNode) {
            base.FromData(effectStepNodeData, guidToNode);
            Operator = effectStepNodeData.Operator;
            return true;
        }
        public override bool IsValid => Operator != null;
            return _in.Node.Run(blackBoard).DefaultIfEmpty(GetDefault()).Aggregate((current, next) => Operator.Operate(current, next));
        public IResourceOperator? Operator;
        public double GetDefault() {
            const double DefaultVal = 0;
            return DefaultVal;
        }
        public override double Run(EffectInput blackBoard) {
            if (!IsValid || Operator == null) {
                UnityEngine.Debug.LogError($"{Guid} Inner types are null");
                return GetDefault();
            }
            if (_in.Node == null) {
                return GetDefault();
            }

File deletion: ContextResourceSet.cs.meta

BF:BFD[6.5348] → [8.11121:11171]

BF:BFD[8.11171] → [8.10876:10876]

B:BD[8.10876] → [8.10877:11120]

fileFormatVersion: 2
guid: 95498ab7ed723494fb6b3c000a0f1c35
MonoImporter:
  externalObjects: {}
  serializedVersion: 2
  defaultReferences: []
  executionOrder: 0
  icon: {instanceID: 0}
  userData: 
  assetBundleName: 
  assetBundleVariant:

File deletion: ContextResourceSet.cs

BF:BFD[6.5348] → [8.13667:13712]

BF:BFD[8.13712] → [8.11173:11173]

∅:D[3.17584] → [8.11176:11634]

B:BD[8.11176] → [8.11176:11634]

∅:D[3.17646] → [8.11694:11775]

B:BD[8.11694] → [8.11694:11775]

∅:D[3.17708] → [8.11835:12501]

B:BD[8.11835] → [8.11835:12501]

∅:D[3.17909] → [8.12640:12975]

B:BD[8.12640] → [8.12640:12975]

∅:D[3.17990] → [8.13038:13088]

B:BD[8.13038] → [8.13038:13088]

∅:D[3.18081] → [8.13156:13327]

B:BD[8.13156] → [8.13156:13327]

∅:D[3.18165] → [8.13501:13503]

B:BD[8.13501] → [8.13501:13503]

∅:D[3.18411] → [8.13617:13619]

B:BD[8.13617] → [8.13617:13619]

∅:D[3.18441] → [8.13645:13658]

B:BD[8.13645] → [8.13645:13658]

∅:D[10.7654] → [8.13658:13666]

B:BD[8.13658] → [8.13658:13666]

B:BD[8.13658] → [10.7057:7654]

B:BD[8.13619] → [3.18412:18441]

B:BD[8.13503] → [3.18166:18411]

B:BD[8.13327] → [3.18082:18165]

B:BD[8.13088] → [3.17991:18081]

B:BD[8.12975] → [3.17910:17990]

B:BD[8.12501] → [3.17709:17909]

B:BD[8.11775] → [3.17647:17708]

B:BD[8.11634] → [3.17585:17646]

B:BD[8.11173] → [3.17566:17584]


namespace TagFighter.Effects.Steps
{
    using System.Collections.Generic;
    using System.Reflection;
    using TagFighter.Effects.ResourceLocationAccessors.ContextRegisters;
    [StepType(StepTypeAttribute.SetterStep)]
    public class ContextResourceSet : OutputStep<bool>
    {
        [UnityEngine.SerializeField]
        SinglePort<double> _in = new();
        [CareBoo.Serially.TypeFilter(derivedFrom: typeof(Resources.Resource<>))]
        [CareBoo.Serially.TypeFilter(derivedFrom: typeof(ContextRegister<>))]
        public override IEnumerable<IPort> Inputs {
            get {
                yield return _in;
            }
        }
        public override string ToString() {
            var resourceName = Resource == null || Resource.Type == null ? "*" : Resource.Type.Name;
            var registerName = Register == null || Register.Type == null ? "*" : Register.Type.Name;
            return $"Context.Set.{resourceName}.{registerName}";
        }
        public override bool IsValid {
            get {
                return Register != null && Register.Type != null && Resource != null && Resource.Type != null;
            }
        }
                return false;
            }
            var getSpecificMethod = typeof(ContextResourceSet).GetMethod(nameof(SetSpecific), BindingFlags.NonPublic | BindingFlags.Instance).
                                            MakeGenericMethod(Resource.Type, Resource.Type.BaseType.GetGenericArguments()[0], Register.Type);
            return (bool)value;
        }
            where TResource : Resources.Resource<TUnitType>
            where TUnitType : Resources.IUnitType
            where TContextRegister : IContextRegister {
        }
    }
}
        public override EffectStepNodeData ToData() {
            var effectStepNodeData = base.ToData();
            effectStepNodeData.Resource = Resource;
            effectStepNodeData.Register = Register;
            return effectStepNodeData;
        }
        public override bool FromData(EffectStepNodeData effectStepNodeData, Dictionary<string, EffectStepNode> guidToNode) {
            base.FromData(effectStepNodeData, guidToNode);
            Resource = effectStepNodeData.Resource;
            Register = effectStepNodeData.Register;
            return true;
        }
            return success;
            var success = false;
            if (blackBoard != null) {
                blackBoard.Context.SetResource<TResource, TUnitType, TContextRegister>((Resources.Unit<TUnitType>)result);
                success = true;
            }
            var result = (_in.Node != null) ? _in.Node.Run(blackBoard) : default;
        bool SetSpecific<TResource, TUnitType, TContextRegister>(EffectInput blackBoard)
            var value = getSpecificMethod.Invoke(this, new object[] { Data });
        public override bool Run(EffectInput Data) {
            if (!IsValid || Resource == null || Register == null) {
                UnityEngine.Debug.LogError($"{Guid} Inner types are null");
        public CareBoo.Serially.SerializableType? Register;
        public CareBoo.Serially.SerializableType? Resource;
#nullable enable

File deletion: ContextResourceGet.cs.meta

BF:BFD[6.5348] → [8.13959:14009]

BF:BFD[8.14009] → [8.13714:13714]

B:BD[8.13714] → [8.13715:13958]

fileFormatVersion: 2
guid: c5c37fc06b3d0ad45b6305eb93d68542
MonoImporter:
  externalObjects: {}
  serializedVersion: 2
  defaultReferences: []
  executionOrder: 0
  icon: {instanceID: 0}
  userData: 
  assetBundleName: 
  assetBundleVariant:

File deletion: ContextResourceGet.cs

BF:BFD[6.5348] → [8.16324:16369]

BF:BFD[8.16369] → [8.14011:14011]

B:BD[8.14011] → [3.18444:18462]

∅:D[3.18462] → [8.14012:14415]

B:BD[8.14011] → [8.14012:14415]

∅:D[3.18524] → [8.14475:14556]

B:BD[8.14475] → [8.14475:14556]

∅:D[3.18586] → [8.14616:14618]

B:BD[8.14616] → [8.14616:14618]

∅:D[3.18795] → [8.14797:15128]

B:BD[8.14797] → [8.14797:15128]

∅:D[3.18882] → [8.15191:15225]

B:BD[8.15191] → [8.15191:15225]

B:BD[8.15225] → [3.18883:18969]

∅:D[3.18969] → [8.15225:15238]

B:BD[8.15225] → [8.15225:15238]

∅:D[3.19059] → [8.15305:15474]

B:BD[8.15305] → [8.15305:15474]

∅:D[3.19195] → [8.15692:16304]

B:BD[8.15692] → [8.15692:16304]

∅:D[10.8254] → [8.16304:16315]

B:BD[8.16304] → [8.16304:16315]

∅:D[10.8257] → [8.16315:16323]

B:BD[8.16315] → [8.16315:16323]

B:BD[8.16315] → [10.8255:8257]

B:BD[8.16304] → [10.7657:8254]

B:BD[8.15474] → [3.19060:19195]

B:BD[8.15238] → [3.18970:19059]

B:BD[8.15128] → [3.18796:18882]

B:BD[8.14618] → [3.18587:18795]

B:BD[8.14556] → [3.18525:18586]

B:BD[8.14415] → [3.18463:18524]

#nullable enable
namespace TagFighter.Effects.Steps
{
    using System.Reflection;
    using System.Collections.Generic;
    using System.Linq;
    using TagFighter.Effects.ResourceLocationAccessors.ContextRegisters;
    [StepType(StepTypeAttribute.GetterStep)]
    public class ContextResourceGet : OutputStep<double>
    {
        [CareBoo.Serially.TypeFilter(derivedFrom: typeof(Resources.Resource<>))]
        [CareBoo.Serially.TypeFilter(derivedFrom: typeof(ContextRegister<>))]
                return 0;
            }
            var getSpecificMethod = typeof(ContextResourceGet).GetMethod(nameof(GetSpecific), BindingFlags.NonPublic | BindingFlags.Instance).
                                            MakeGenericMethod(Resource.Type, Resource.Type.BaseType.GetGenericArguments()[0], Register.Type);
            return (int)value;
        }
        public double Test(EffectInput[] Data) {
            return 0;
        }
            where TResource : Resources.Resource<TUnitType>
            where TUnitType : Resources.IUnitType
            where TContextRegister : IContextRegister {
        }
        public override IEnumerable<IPort> Inputs => Enumerable.Empty<IPort>();
        public override string ToString() {
            var resourceName = Resource == null || Resource.Type == null ? "*" : Resource.Type.Name;
            var registerName = Register == null || Register.Type == null ? "*" : Register.Type.Name;
            return $"Context.Get.{resourceName}.{registerName}";
        }
        public override bool IsValid {
            get {
                return Register != null && Register.Type != null && Resource != null && Resource.Type != null;
            }
        }
    }
}
        }
        public override EffectStepNodeData ToData() {
            var effectStepNodeData = base.ToData();
            effectStepNodeData.Resource = Resource;
            effectStepNodeData.Register = Register;
            return effectStepNodeData;
        }
        public override bool FromData(EffectStepNodeData effectStepNodeData, Dictionary<string, EffectStepNode> guidToNode) {
            base.FromData(effectStepNodeData, guidToNode);
            Resource = effectStepNodeData.Resource;
            Register = effectStepNodeData.Register;
            return true;
            return blackBoard != null ? blackBoard.Context.GetResource<TResource, TUnitType, TContextRegister>().AsPrimitive() : 0;
        int GetSpecific<TResource, TUnitType, TContextRegister>(EffectInput blackBoard)
            var value = getSpecificMethod.Invoke(this, new object[] { blackBoard });
        public override double Run(EffectInput blackBoard) {
            if (!IsValid || Register == null || Resource == null) {
                UnityEngine.Debug.LogError($"{Guid} Inner types are null");
        public CareBoo.Serially.SerializableType? Register;
        public CareBoo.Serially.SerializableType? Resource;

File deletion: ContextAreaSet.cs.meta

BF:BFD[6.5348] → [8.16616:16662]

BF:BFD[8.16662] → [8.16371:16371]

B:BD[8.16371] → [8.16372:16615]

fileFormatVersion: 2
guid: 81d788b04f027ce4080f0b8736d97a71
MonoImporter:
  externalObjects: {}
  serializedVersion: 2
  defaultReferences: []
  executionOrder: 0
  icon: {instanceID: 0}
  userData: 
  assetBundleName: 
  assetBundleVariant:

File deletion: ContextAreaSet.cs

BF:BFD[6.5348] → [8.17458:17499]

BF:BFD[8.17499] → [8.16664:16664]

B:BD[8.16664] → [3.19198:19216]

∅:D[3.19216] → [8.16665:17189]

B:BD[8.16664] → [8.16665:17189]

∅:D[3.19277] → [8.17227:17298]

B:BD[8.17227] → [8.17227:17298]

∅:D[3.19355] → [8.17359:17457]

B:BD[8.17359] → [8.17359:17457]

B:BD[8.17298] → [3.19278:19355]

B:BD[8.17189] → [3.19217:19277]

#nullable enable
namespace TagFighter.Effects.Steps
{
    using System.Collections.Generic;
    [StepType(StepTypeAttribute.SetterStep)]
    public class ContextAreaSet : OutputStep<bool>
    {
        [UnityEngine.SerializeField]
        SinglePort<IAreaOfEffect> _in = new();
        public override IEnumerable<IPort> Inputs {
            get {
                yield return _in;
            }
        }
        public override string ToString() => "Context.AOE.Set";
        public override bool IsValid => true;
            var success = false;
            if (_in.Node != null) {
                success = true;
            }
            return success;
        }
    }
}
                blackBoard.Context.AreaOfEffect = _in.Node.Run(blackBoard);
        public override bool Run(EffectInput blackBoard) {

File deletion: ConstValue.cs.meta

BF:BFD[6.5348] → [8.17746:17788]

BF:BFD[8.17788] → [8.17501:17501]

B:BD[8.17501] → [8.17502:17745]

fileFormatVersion: 2
guid: c419ef0e55c3e694cb24080375e68c2e
MonoImporter:
  externalObjects: {}
  serializedVersion: 2
  defaultReferences: []
  executionOrder: 0
  icon: {instanceID: 0}
  userData: 
  assetBundleName: 
  assetBundleVariant:

File deletion: ConstValue.cs

BF:BFD[6.5348] → [8.18453:18490]

BF:BFD[8.18490] → [8.17790:17790]

B:BD[8.17790] → [3.19358:19376]

∅:D[3.19376] → [8.17791:18064]

B:BD[8.17790] → [8.17791:18064]

∅:D[3.19439] → [8.18176:18384]

B:BD[8.18176] → [8.18176:18384]

∅:D[10.8479] → [8.18384:18397]

B:BD[8.18384] → [8.18384:18397]

∅:D[10.8816] → [8.18397:18452]

B:BD[8.18397] → [8.18397:18452]

B:BD[8.18397] → [10.8480:8816]

B:BD[8.18384] → [10.8262:8479]

B:BD[8.18064] → [3.19377:19439]

#nullable enable
namespace TagFighter.Effects.Steps
{
    using System.Collections.Generic;
    using System.Linq;
    [StepType(StepTypeAttribute.GetterStep)]
    public class ConstValue : OutputStep<double>
    {
        [UnityEngine.SerializeField]
        double _value;
            return _value;
        }
        public override IEnumerable<IPort> Inputs => Enumerable.Empty<IPort>();
        public override string ToString() {
            return $"Const {_value}";
        }
        public override bool IsValid => true;
    }
}
        public override bool FromData(EffectStepNodeData effectStepNodeData, Dictionary<string, EffectStepNode> guidToNode) {
            base.FromData(effectStepNodeData, guidToNode);
            _value = effectStepNodeData.Const != null ? effectStepNodeData.Const.FirstOrDefault() : default;
            return true;
        }
        }
        public override EffectStepNodeData ToData() {
            var effectStepNodeData = base.ToData();
            effectStepNodeData.Const = new() { _value };
            return effectStepNodeData;
        public override double Run(EffectInput blackBoard) {

File deletion: ConeAreaGet.cs.meta

BF:BFD[6.5348] → [8.18737:18780]

BF:BFD[8.18780] → [8.18492:18492]

B:BD[8.18492] → [8.18493:18736]

fileFormatVersion: 2
guid: e3d165e54b32e6d4cbcc75c5b0cf7a68
MonoImporter:
  externalObjects: {}
  serializedVersion: 2
  defaultReferences: []
  executionOrder: 0
  icon: {instanceID: 0}
  userData: 
  assetBundleName: 
  assetBundleVariant:

File deletion: ConeAreaGet.cs

BF:BFD[6.5348] → [8.19752:19790]

BF:BFD[8.19790] → [8.18782:18782]

B:BD[8.18782] → [3.19442:19460]

∅:D[3.19460] → [8.18783:19528]

B:BD[8.18782] → [8.18783:19528]

∅:D[3.19530] → [8.19575:19612]

B:BD[8.19575] → [8.19575:19612]

∅:D[3.19724] → [8.19716:19751]

B:BD[8.19716] → [8.19716:19751]

B:BD[8.19612] → [3.19531:19724]

B:BD[8.19528] → [3.19461:19530]

#nullable enable
namespace TagFighter.Effects.Steps
{
    using System.Collections.Generic;
    [StepType(StepTypeAttribute.GetterStep)]
    public class ConeAreaGet : OutputStep<IAreaOfEffect>
    {
        [UnityEngine.SerializeField]
        SinglePort<double> _radius = new() {
            DisplayName = "Radius"
        };
        [UnityEngine.SerializeField]
        SinglePort<double> _angle = new() {
            DisplayName = "Angle"
        };
        public override IEnumerable<IPort> Inputs {
            get {
                yield return _radius;
                yield return _angle;
            }
        }
        public override string ToString() => "Cone AOE";
        public override bool IsValid => true;
            return new ConeArea() {
            };
        }
    }
}
                Radius = (float)(_radius.Node != null ? _radius.Node.Run(blackBoard) : default),
                Angle = (float)(_angle.Node != null ? _angle.Node.Run(blackBoard) : default),
        public override IAreaOfEffect Run(EffectInput blackBoard) {

File deletion: CircleAreaGet.cs.meta

BF:BFD[6.5348] → [8.20037:20082]

BF:BFD[8.20082] → [8.19792:19792]

B:BD[8.19792] → [8.19793:20036]

fileFormatVersion: 2
guid: 05c74f9724c88004184e3074359893c6
MonoImporter:
  externalObjects: {}
  serializedVersion: 2
  defaultReferences: []
  executionOrder: 0
  icon: {instanceID: 0}
  userData: 
  assetBundleName: 
  assetBundleVariant:

File deletion: CircleAreaGet.cs

BF:BFD[6.5348] → [8.20813:20853]

BF:BFD[8.20853] → [8.20084:20084]

∅:D[3.19745] → [8.20085:20613]

B:BD[8.20084] → [8.20085:20613]

∅:D[3.19941] → [8.20755:20812]

B:BD[8.20755] → [8.20755:20812]

B:BD[8.20613] → [3.19746:19941]

B:BD[8.20084] → [3.19727:19745]


namespace TagFighter.Effects.Steps
{
    using System.Collections.Generic;
    [StepType(StepTypeAttribute.GetterStep)]
    public class CircleAreaGet : OutputStep<IAreaOfEffect>
    {
        [UnityEngine.SerializeField]
        SinglePort<double> _radius = new() {
            DisplayName = "Radius"
        };
        public override IEnumerable<IPort> Inputs {
            get {
                yield return _radius;
            }
        }
        public override string ToString() => "Circle AOE";
        public override bool IsValid => true;
    }
}
        public override IAreaOfEffect Run(EffectInput blackBoard) => new CircleArea() {
            Radius = (float)(_radius.Node != null ? _radius.Node.Run(blackBoard) : default),
        };
#nullable enable

Replacement in Assets/Scripts/Combat/Runes/Effects/Nodes/Release/ReleaseWeave.cs at line 23 [3.2761]

B:BD[3.3312] → [3.3312:3386]

            blackBoard.Affected = blackBoard.Context.GetAffectedUnits();

[3.3312]

[3.3386]

            var appliedResource = blackBoard.Context.GetAllResourcesInRegister<ResourceLocationAccessors.ContextRegisters.Current>();
            blackBoard.Context.EffectSystem.ApplyTagsEffect(appliedResource, blackBoard.Context.Caster, blackBoard.Context.EffectLocation, blackBoard.Context.AreaOfEffect);
            blackBoard.Affected = blackBoard.Context.GetAffectedUnits().ToList();

Insertion in Assets/Scripts/Combat/Runes/Effects/Nodes/Release/ReleaseEffect.cs at line 6 [3.3938]
[3.4037]
[3.4037]
```
    using System.Linq;
```

Replacement in Assets/Scripts/Combat/Runes/Effects/Nodes/Release/ReleaseEffect.cs at line 35 [3.3938]

B:BD[3.4840] → [3.4840:4932]

            blackBoard.Affected = aoe.GetAffectedUnits(blackBoard.Context.EffectLocation);

[3.4840]

[3.4932]

            blackBoard.Affected = aoe.GetAffectedUnits(blackBoard.Context.EffectLocation).ToList();

Replacement in Assets/Scripts/Combat/Runes/Effects/Nodes/EffectStepNode.cs at line 46 [6.17784]
B:BD[10.5443] → [3.16814:16844]
```
        public string? Guid;
```
[10.5443]
[10.5472]
```
        public string Guid;
```

Replacement in Assets/Scripts/Combat/Runes/Effects/Nodes/EffectStepNode.cs at line 59 [6.17784]

B:BD[10.5798] → [3.17089:17202]

        public EffectStepNodeData(System.Type type, string? guid, Vector2 position, List<PortData> portsData) {

[10.5798]

[10.5910]

        public EffectStepNodeData(System.Type type, string guid, Vector2 position, List<PortData> portsData) {

Replacement in Assets/Scripts/Combat/Runes/Effects/Nodes/EffectStepNode.cs at line 77 [6.17784]
B:BD[6.18677] → [3.17203:17233]
```
        public string? Guid;
```
[6.18677]
[3.17233]
```
        public string Guid = System.Guid.NewGuid().ToString();
```
Replacement in Assets/Scripts/Combat/Runes/Effects/Nodes/EffectStepNode.cs at line 105 [6.17784]
B:BD[11.4122] → [11.4122:4181]
```
    [System.AttributeUsage(System.AttributeTargets.Class)
```
[11.4122]
[11.4181]
```
    [System.AttributeUsage(System.AttributeTargets.Class, Inherited = false)
```
Replacement in Assets/ScriptableObjects/Runes/TestRune.asset at line 134 [12.237]
B:BD[3.33697] → [3.33697:33726]
```
  Position: {x: 101, y: 362}
```
[3.33697]
[3.33726]
```
  Position: {x: 68.51999, y: 327}
```
Replacement in Assets/ScriptableObjects/Runes/TestRune.asset at line 136 [12.237]
B:BD[3.33771] → [3.33771:33783]
```
  _value: 5
```
[3.33771]
[3.33783]
```
  _value: 10
```

Insertion in Assets/ScriptableObjects/Runes/TestRune.asset at line 192 [12.237]

[3.35570]

--- !u!114 &-3588640908992573351
MonoBehaviour:
  m_ObjectHideFlags: 0
  m_CorrespondingSourceObject: {fileID: 0}
  m_PrefabInstance: {fileID: 0}
  m_PrefabAsset: {fileID: 0}
  m_GameObject: {fileID: 0}
  m_Enabled: 1
  m_EditorHideFlags: 0
  m_Script: {fileID: 11500000, guid: c419ef0e55c3e694cb24080375e68c2e, type: 3}
  m_Name: ConstValue
  m_EditorClassIdentifier: 
  Position: {x: 69, y: 463}
  Guid: eb75d72e-dc15-4b20-b3b5-4c3e472ce5ef
  _value: 30

Insertion in Assets/ScriptableObjects/Runes/TestRune.asset at line 225 [12.237]
[3.36143]
[9.5797]
```
  - {fileID: 6326256876420960218}
  - {fileID: -3588640908992573351}
```
Replacement in Assets/ScriptableObjects/Runes/TestRune.asset at line 264 [12.237]
B:BD[3.36944] → [3.36944:36984]
```
    Node: {fileID: 7852711552070706258}
```
[3.36944]
[12.733]
```
    Node: {fileID: 6326256876420960218}
```

Insertion in Assets/ScriptableObjects/Runes/TestRune.asset at line 390 [12.237]

[3.40075]

--- !u!114 &6326256876420960218
MonoBehaviour:
  m_ObjectHideFlags: 0
  m_CorrespondingSourceObject: {fileID: 0}
  m_PrefabInstance: {fileID: 0}
  m_PrefabAsset: {fileID: 0}
  m_GameObject: {fileID: 0}
  m_Enabled: 1
  m_EditorHideFlags: 0
  m_Script: {fileID: 11500000, guid: e3d165e54b32e6d4cbcc75c5b0cf7a68, type: 3}
  m_Name: ConeAreaGet
  m_EditorClassIdentifier: 
  Position: {x: 236, y: 362}
  Guid: 855586fc-1169-4349-8cfd-7ec04d63f9f1
  _radius:
    Node: {fileID: -5229030080647256284}
  _angle:
    Node: {fileID: -3588640908992573351}

Replacement in Assets/ScriptableObjects/Runes/TestRune.asset at line 458 [12.237]
B:BD[3.41596] → [3.41596:41625]
```
  Position: {x: 221, y: 362}
```
[3.41596]
[3.41625]
```
  Position: {x: 236, y: 250}
```
Replacement in Assets/ScriptableObjects/Runes/TestRune.asset at line 461 [12.237]
B:BD[3.41681] → [3.41681:41722]
```
    Node: {fileID: -5229030080647256284}
```
[3.41681]
[3.41722]
```
    Node: {fileID: 0}
```

Replacement in Assets/Scenes/SampleScene.unity at line 5764 [13.780110080]

B:BD[13.780121071] → [3.42843:42924]

  m_LocalRotation: {x: 0.22914574, y: -0.070709124, z: 0.016692158, w: 0.970677}

[13.780121071]

[14.33888019]

  m_LocalRotation: {x: 0.22914574, y: -0.070709094, z: 0.016692149, w: 0.970677}

Replacement in Assets/Scenes/SampleScene.unity at line 7939 [13.780110080]

B:BD[13.780162310] → [3.42925:43006]

  m_LocalRotation: {x: 0.22914574, y: -0.070709124, z: 0.016692158, w: 0.970677}

[13.780162310]

[14.33918016]

  m_LocalRotation: {x: 0.22914574, y: -0.070709094, z: 0.016692149, w: 0.970677}

Replacement in Assets/Scenes/SampleScene.unity at line 8480 [13.780110080]
B:BD[15.107447] → [16.1015:1030]
```
      value: 0
```
[15.107447]
[15.107462]
```
      value: 1
```
Replacement in Assets/Scenes/SampleScene.unity at line 8485 [13.780110080]
B:BD[15.107630] → [16.1031:1046]
```
      value: 0
```
[15.107630]
[15.107645]
```
      value: 1
```
Replacement in Assets/Scenes/SampleScene.unity at line 8490 [13.780110080]
B:BD[15.107820] → [16.1047:1062]
```
      value: 0
```
[15.107820]
[15.107835]
```
      value: -170
```
Replacement in Assets/Scenes/SampleScene.unity at line 8570 [13.780110080]
B:BD[15.115852] → [16.1063:1078]
```
      value: 0
```
[15.115852]
[15.115867]
```
      value: 1
```
Replacement in Assets/Scenes/SampleScene.unity at line 8575 [13.780110080]
B:BD[15.116037] → [16.1079:1094]
```
      value: 0
```
[15.116037]
[15.116052]
```
      value: 1
```
Replacement in Assets/Scenes/SampleScene.unity at line 8685 [13.780110080]
B:BD[15.117142] → [16.1095:1110]
```
      value: 0
```
[15.117142]
[17.26089]
```
      value: 1
```
Replacement in Assets/Scenes/SampleScene.unity at line 8690 [13.780110080]
B:BD[15.117278] → [16.1111:1126]
```
      value: 0
```
[15.117278]
[15.117293]
```
      value: 1
```
Replacement in Assets/Scenes/SampleScene.unity at line 8695 [13.780110080]
B:BD[15.117470] → [16.1127:1142]
```
      value: 0
```
[15.117470]
[15.117485]
```
      value: -60
```
Deletion in Assets/Editor/Rune/RuneEffectView.cs at line 256 [6.33420]
B:BD[6.39357] → [6.39357:39409]
```
            node.Guid = Guid.NewGuid().ToString();
```

Integrate ReleaseWeave with EffectSystem. Effect seems to fire incorrectly?

Dependencies

In channels

Change contents

Replacement in Assets/Scripts/Systems/Effects/IEffectSystem.cs at line 1 [4.1742]

Replacement in Assets/Scripts/Systems/Effects/EffectSystem.cs at line 1 [4.2503]

Replacement in Assets/Scripts/Systems/Effects/DummyEffectSystem.cs at line 1 [4.10082]

Replacement in Assets/Scripts/Combat/Runes/RuneRef.cs at line 20 [7.2420]

File deletion: Zip.cs.meta

File deletion: Zip.cs

File deletion: Repeat.cs.meta

File deletion: Repeat.cs

File deletion: PawnResourceSet.cs.meta

File deletion: PawnResourceSet.cs

File deletion: PawnResourceGet.cs.meta

File deletion: PawnResourceGet.cs

File deletion: Operate.cs.meta

File deletion: Operate.cs

File deletion: Fold.cs.meta

File deletion: Fold.cs

File deletion: ContextResourceSet.cs.meta

File deletion: ContextResourceSet.cs

File deletion: ContextResourceGet.cs.meta

File deletion: ContextResourceGet.cs

File deletion: ContextAreaSet.cs.meta

File deletion: ContextAreaSet.cs

File deletion: ConstValue.cs.meta

File deletion: ConstValue.cs

File deletion: ConeAreaGet.cs.meta

File deletion: ConeAreaGet.cs

File deletion: CircleAreaGet.cs.meta

File deletion: CircleAreaGet.cs

Replacement in Assets/Scripts/Combat/Runes/Effects/Nodes/Release/ReleaseWeave.cs at line 23 [3.2761]

Insertion in Assets/Scripts/Combat/Runes/Effects/Nodes/Release/ReleaseEffect.cs at line 6 [3.3938]

Replacement in Assets/Scripts/Combat/Runes/Effects/Nodes/Release/ReleaseEffect.cs at line 35 [3.3938]

Replacement in Assets/Scripts/Combat/Runes/Effects/Nodes/EffectStepNode.cs at line 46 [6.17784]

Replacement in Assets/Scripts/Combat/Runes/Effects/Nodes/EffectStepNode.cs at line 59 [6.17784]

Replacement in Assets/Scripts/Combat/Runes/Effects/Nodes/EffectStepNode.cs at line 77 [6.17784]

Replacement in Assets/Scripts/Combat/Runes/Effects/Nodes/EffectStepNode.cs at line 105 [6.17784]

Replacement in Assets/ScriptableObjects/Runes/TestRune.asset at line 134 [12.237]

Replacement in Assets/ScriptableObjects/Runes/TestRune.asset at line 136 [12.237]

Insertion in Assets/ScriptableObjects/Runes/TestRune.asset at line 192 [12.237]

Insertion in Assets/ScriptableObjects/Runes/TestRune.asset at line 225 [12.237]

Replacement in Assets/ScriptableObjects/Runes/TestRune.asset at line 264 [12.237]

Insertion in Assets/ScriptableObjects/Runes/TestRune.asset at line 390 [12.237]

Replacement in Assets/ScriptableObjects/Runes/TestRune.asset at line 458 [12.237]

Replacement in Assets/ScriptableObjects/Runes/TestRune.asset at line 461 [12.237]

Replacement in Assets/Scenes/SampleScene.unity at line 5764 [13.780110080]

Replacement in Assets/Scenes/SampleScene.unity at line 7939 [13.780110080]

Replacement in Assets/Scenes/SampleScene.unity at line 8480 [13.780110080]

Replacement in Assets/Scenes/SampleScene.unity at line 8485 [13.780110080]

Replacement in Assets/Scenes/SampleScene.unity at line 8490 [13.780110080]

Replacement in Assets/Scenes/SampleScene.unity at line 8570 [13.780110080]

Replacement in Assets/Scenes/SampleScene.unity at line 8575 [13.780110080]

Replacement in Assets/Scenes/SampleScene.unity at line 8685 [13.780110080]

Replacement in Assets/Scenes/SampleScene.unity at line 8690 [13.780110080]

Replacement in Assets/Scenes/SampleScene.unity at line 8695 [13.780110080]

Deletion in Assets/Editor/Rune/RuneEffectView.cs at line 256 [6.33420]