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

// using System.Collections;
// using System.Collections.Generic;
// using UnityEngine;
namespace TagFighter.Effects
{
    public abstract class GetterNode : EffectStepNode
    {
    }
}

    public class ZipStep : SequenceGetterStep, IOperatorStep

    [StepType(StepTypeAttribute.OperatorStep)]
    public class ZipStep : SequenceGetterStep

        [UnityEngine.SerializeField]
        List<double> _const = new();

            return _in.Nodes.Select(getter => getter.Get())
            .Aggregate((current, next) =>

            if (!IsValid) {
                double defaultVal = 0;
                UnityEngine.Debug.Log($"{Guid} Inner types are null");
                return Data.Affected.Select(transform => defaultVal);
            }
            return _in.Nodes.Select(getter => getter.Get()).Concat(_const.Select(value => Data.Affected.Select(transform => value)))
                        .Aggregate((current, next) =>

        public override string ShortName {
            get {
                var operatorName = Operator == null ? "*" : Operator.GetType().Name;

        public override string ToString() {
            var operatorName = Operator == null ? "*" : Operator.GetType().Name;
            var constName = _const.Count == 0 ? "" : $"({string.Join(",", _const.Select(val => $"{val}[]"))})";

                return new($"Zip.{operatorName}");

            return $"Zip.{operatorName}{constName}";
        }
        public override bool IsValid {
            get {
                return Operator != null;

// using System.Collections;
// using System.Collections.Generic;
// using UnityEngine;

// using System.Collections;
// using System.Collections.Generic;
// using UnityEngine;

// using System.Collections;
// using UnityEngine;
using System.Collections.Generic;

    using System.Collections.Generic;

    public class RepeatStep : SequenceGetterStep, IOperatorStep

    [StepType(StepTypeAttribute.OperatorStep)]
    public class RepeatStep : SequenceGetterStep

        public override string ShortName => "Repeat";

        public override string ToString() => "Repeat";
        public override bool IsValid => true;

    // using System.Linq;

    public class PawnSetterStep : SetterNode, ISetterStep

    [StepType(StepTypeAttribute.SetterStep)]
    public class PawnSetterStep : SetterNode

        public override string ShortName {
            get {
                var resourceName = Resource.Type == null ? "*" : Resource.Type.Name;
                var statName = "Current";

        public override string ToString() {
            var resourceName = Resource == null || Resource.Type == null ? "*" : Resource.Type.Name;
            var statName = "Current";

                return new($"Pawn.Set.{resourceName}.{statName}");

            return $"Pawn.Set.{resourceName}.{statName}";
        }
        public override bool IsValid {
            get {
                return Resource != null && Resource.Type != null;

            if (Resource.Type == null) {

            if (!IsValid) {

    public class PawnGetterStep : SequenceGetterStep, IGetterStep

    [StepType(StepTypeAttribute.GetterStep)]
    public class PawnGetterStep : SequenceGetterStep

            if (Resource.Type == null) {

            if (!IsValid) {

        public override string ShortName {

        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 {

                var resourceName = Resource.Type == null ? "*" : Resource.Type.Name;
                var statName = "Current";
                return new($"Pawn.Get.{resourceName}.{statName}");

                return Resource != null && Resource.Type != null;

    public class OperatorStep : SingleGetterStep, IOperatorStep

    [StepType(StepTypeAttribute.OperatorStep)]
    public class OperatorStep : SingleGetterStep

        [UnityEngine.SerializeField]
        List<double> _const = new();

        public override string ToString() {
            var operatorName = Operator == null ? "*" : Operator.GetType().Name;
            var constName = _const.Count == 0 ? "" : $"({string.Join(",", _const)})";

        public override string ShortName {
            get {
                var operatorName = Operator == null ? "*" : Operator.GetType().Name;

            return $"{operatorName}{constName}";
        }

                return new($"{operatorName}");

        public override bool IsValid {
            get {
                return Operator != null;

            return Operator.OperateEnum(_in.Nodes.Select(getter => getter.Get()));

            var result = Operator.OperateEnum(_in.Nodes.Select(getter => getter.Get()).Concat(_const));
            return result;

    public class FoldStep : SingleGetterStep, IOperatorStep

    [StepType(StepTypeAttribute.OperatorStep)]
    public class FoldStep : SingleGetterStep

        public override string ToString() {
            var operatorName = Operator == null ? "*" : Operator.GetType().Name;

        public override string ShortName {

            return $"Fold.{operatorName}";
        }
        public override bool IsValid {

                var operatorName = Operator == null ? "*" : Operator.GetType().Name;
                return new($"Fold.{operatorName}");

                return Operator != null;

        public EffectStepValidatedEventArgs(string displayName) {

        public bool IsValid;
        public EffectStepValidatedEventArgs(string displayName, bool isValid) {

            IsValid = isValid;

    public interface IOperatorStep { };
    public interface IGetterStep { };
    public interface ISetterStep { };

        public abstract string ShortName { get; }

        public abstract bool IsValid { get; }

            OnValidated(this, new(ShortName));

            OnValidated(this, new(ToString(), IsValid));

        }
    }
    [System.AttributeUsage(System.AttributeTargets.Class)
    ]
    public class StepTypeAttribute : System.Attribute
    {
        public string Name;
        public StepTypeAttribute(string name) {
            Name = name;

        public override string ToString() => Name;
        public const string OperatorStep = "Operator";
        public const string GetterStep = "Get";
        public const string SetterStep = "Set";

    // using System.Linq;

        public override string ShortName => "Root";

        public override bool IsValid => true;

        // public override IEnumerable<IPort<EffectStepNode>> Outputs => Enumerable.Empty<IPort<EffectStepNode>>();

        public override string ToString() => "Root";

    public class ContextSetterStep : SetterNode, ISetterStep

    [StepType(StepTypeAttribute.SetterStep)]
    public class ContextSetterStep : SetterNode

        }
        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 string ShortName {

        public override bool IsValid {

                var resourceName = Resource.Type == null ? "*" : Resource.Type.Name;
                var registerName = Register.Type == null ? "*" : Register.Type.Name;
                return new($"Context.Set.{resourceName}.{registerName}");

                return Register != null && Register.Type != null && Resource != null && Resource.Type != null;

            if (Register.Type == null || Resource.Type == null) {

            if (!IsValid) {

    public class ContextGetterStep : SingleGetterStep, IGetterStep

    [StepType(StepTypeAttribute.GetterStep)]
    public class ContextGetterStep : SingleGetterStep

        public override string ShortName {
            get {
                var resourceName = Resource.Type == null ? "*" : Resource.Type.Name;
                var registerName = Register.Type == null ? "*" : Register.Type.Name;

        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}";
        }

                return new($"Context.Get.{resourceName}.{registerName}");

        public override bool IsValid {
            get {
                return Register != null && Register.Type != null && Resource != null && Resource.Type != null;

    public class ConstValueStep : SingleGetterStep, IGetterStep

    [StepType(StepTypeAttribute.GetterStep)]
    public class ConstValueStep : SingleGetterStep

        public override string ShortName => "Const";

        public override string ToString() {
            return $"Const {_value}";
        }
        public override bool IsValid => true;

    public class ConeAreaStep : SetterNode, ISetterStep

    [StepType(StepTypeAttribute.SetterStep)]
    public class ConeAreaStep : SetterNode

        public override string ShortName => "Cone AOE";

        public override string ToString() => "Cone AOE";
        public override bool IsValid => true;

  _const: []

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

  m_LocalRotation: {x: 0.22914575, y: -0.0707091, z: 0.01669215, w: 0.970677}

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

  m_LocalRotation: {x: 0.22914575, y: -0.0707091, z: 0.01669215, w: 0.970677}

    using System.Reflection;

                foreach (var type in TypeCache.GetTypesDerivedFrom(typeof(IGetterStep))) {
                    e.menu.AppendAction($"Get/{type.Name}", action => AddNode(type, action.eventInfo.mousePosition));

                List<Type> additional = new();
                foreach (var (type, stepType) in TypeCache.GetTypesDerivedFrom(typeof(EffectStepNode))
                                              .Where(type => type.IsAbstract == false)
                                              .Select(type => (type, type.GetTypeInfo().GetCustomAttribute<StepTypeAttribute>()))) {
                    if (stepType != null) {
                        e.menu.AppendAction($"{stepType}/{type.Name}", action => AddNode(type, action.eventInfo.mousePosition));
                    }
                    else {
                        additional.Add(type);
                    }

                foreach (var type in TypeCache.GetTypesDerivedFrom(typeof(IOperatorStep))) {
                    e.menu.AppendAction($"Operator/{type.Name}", action => AddNode(type, action.eventInfo.mousePosition));

                foreach (var type in additional) {
                    e.menu.AppendAction($"{type.Name}", action => AddNode(type, action.eventInfo.mousePosition));

                foreach (var type in TypeCache.GetTypesDerivedFrom(typeof(ISetterStep))) {
                    e.menu.AppendAction($"Set/{type.Name}", action => AddNode(type, action.eventInfo.mousePosition));
                }
                e.menu.AppendAction("Root Node", action => AddNode(typeof(EffectEndNode), action.eventInfo.mousePosition));

.GetterStep #title{

.GetStep #title{

.SetterStep #title{

.SetStep #title{

}
.InvalidStep #node-border{
    border-width: 2px;
    border-radius: 5px;
    border-color: #FF0033;

            _selectedNodeView.title = e.DisplayName;

            _selectedNodeView.RefreshDisplay(e);
            // _selectedNodeView.title = e.DisplayName;

    using System.Reflection;

        const string InvalidClassName = "InvalidStep";

            title = Node.ShortName;

            title = Node.ToString();

        public void RefreshDisplay(EffectStepValidatedEventArgs e) {
            title = e.DisplayName;
            if (e.IsValid) {
                RemoveFromClassList(InvalidClassName);
            }
            else {
                AddToClassList(InvalidClassName);
            }
        }

            switch (Node) {
                case IOperatorStep:
                    AddToClassList("OperatorStep");
                    break;
                case IGetterStep:
                    AddToClassList("GetterStep");
                    break;
                case ISetterStep:
                    AddToClassList("SetterStep");
                    break;
                default:
                    break;

            var stepType = Node.GetType().GetTypeInfo().GetCustomAttribute<StepTypeAttribute>();
            if (stepType != null) {
                AddToClassList($"{stepType.Name}Step");
            }
            if (!Node.IsValid) {
                AddToClassList(InvalidClassName);