David Liu

Wildfrost Mod

About the Game

Wildfrost is a tactical roguelike deckbuilding game, in which players journey across a frozen tundra, collecting cards strong enough to banish the eternal winter! Perfect your card battling and deck-building skills, and set out on a quest to bring an end to The Wildfrost!

This mod currently adds over 90 more units, items, and charms. There are more features planned as it's still in development, such as custom enemies and bosses, new regions and visuals, and much more!

Developed from November 2024 and is currently ongoing.

Role in Development

  • Artist: DandyDingo
  • Programmer: David Liu
  • Designers: David Liu, DandyDingo

Wildfrost is developed in the Unity game engine, but mod support for the game relies on creating a DLL. Custom cards are created using builders that are part of the Wildfrost modding API, whereas Harmony is used for patching and injections into the source code. So far, I have only built upon the source code just using the Wildfrost modding API.

The mod started as a side passion project with a friend. We both really liked the game Wildfrost and wanted to keep playing more of it after completing the game, so we decided to create more of our own content and share our love of the game with others.

The artist I was working with isn't very experienced in game development, so I took the lead in getting the project off the ground. DandyDingo began to create ideas and keep them in a shared Google Doc while I began learning about the Wildfrost modding API and started creating a few basic cards. With my extensive knowledge of C# and Unity, I was able to quickly learn and understand the framework within just a couple days. Most of the effects for units are created using abstract classes with the use of enumerators and event callbacks. Within a week, I already had created ten custom cards with their own custom effects.

DandyDingo began working on the art for the custom cards in their free time. We were able to establish a good workflow between us, where they give me new batches of art following a specific naming convention, and I was able to easily place the files into the mod with minimal changes. This is the process we've kept up to this day.

Finding balance with the custom cards has proven to be a challenge. Although we both have good intuition from playing this game for hundreds of hours, the game has a little room between significant levels of power. Even changing the stats of a unit by one has made significant impacts on its capability in battles. DandyDingo and I also have very different playstyles, which is both good and bad because we are able to make diverse ideas together, but we also have different opinions on how powerful a card can be. We resolve most of our balance tweaks through continuous playtesting and reflecting back on recorded data.

We plan to continue developing this mod further with much more added content, since we both have still been having a lot of fun with this project. Once we reach our finalized product, we want to upload the mod to the Steam workshop and advertise it within small communities. Depending on our work-life balance at that point, we may continue to make more updates to the mod in the future. I'm very excited with the direction this passion project is going and can't wait to show more!

C# Examples

BaseMod.csTargetModeAdjacent.csTargetModeLowestHealthInRow.csStatusEffectInstantSwapPermanent.cs
#region Function Overrides
        public override void Load()
        {
            Instance = this;

            // Save Data
            OriginalProfile = SaveSystem.GetProfile();
            SwitchToSaveProfile("Dingofrost", copyFiles: true);

            if (!loaded)
            {
                CreateModAssets();
            }
            base.Load();

            CreateModBattles();
            CustomModifications();

            //needed for custom icons
            FloatingText ftext = GameObject.FindObjectOfType(true);
            ftext.textAsset.spriteAsset.fallbackSpriteAssets.Add(assetSprites);

            // Custom Tribe Fix
            Events.OnEntityCreated += FixImage;

            // Tribes
            GameMode gameMode = TryGet("GameModeNormal");
            gameMode.classes = gameMode.classes.Append(TryGet("Wanderers")).ToArray();

            // Save mod loaded data
            SwitchToSaveProfile(OriginalProfile);
            UpdateSave();
            SwitchToSaveProfile("Dingofrost");
            UpdateSave();
        }

        public override void Unload()
        {
            base.Unload();

            // Custom Tribe Fix
            Events.OnEntityCreated -= FixImage;

            GameMode gameMode = TryGet("GameModeNormal");
            gameMode.classes = RemoveNulls(gameMode.classes); //Without this, a non-restarted game would crash on tribe selection
            UnloadFromClasses();                               //This tutorial doesn't need it, but it doesn't hurt to clean the pools

            // Save Data
            SwitchToSaveProfile(OriginalProfile);
        }

        public override List AddAssets()
        {
            return assets.OfType().ToList();
        }
        #endregion

        private void CreateModAssets()
        {
            // Needed to get sprites in text boxes
            assetSprites = CreateSpriteAsset("assetSprites", directoryWithPNGs: this.ImagePath("Sprites"), textures: new Texture2D[] { }, sprites: new Sprite[] { });

            CreateModConstraints();
            CreateModCards();
            CreateModIcons();
        }

        private void CreateModConstraints()
        {
            targetConstraints = new List();

            #region Has Attack Effect
            TargetConstraintHasAttackEffect notInstantSummonCopy = ScriptableObject.CreateInstance();
            notInstantSummonCopy.name = "Does Not Have Instant Summon Copy";
            notInstantSummonCopy.effect = TryGet("Instant Summon Copy");
            notInstantSummonCopy.not = true;

            TargetConstraintHasAttackEffect notInstantSummonCopyOfEnemy = ScriptableObject.CreateInstance();
            notInstantSummonCopyOfEnemy.name = "Does Not Have Instant Summon Copy Of Enemy";
            notInstantSummonCopyOfEnemy.effect = TryGet("Instant Summon Copy On Other Side With X Health");
            notInstantSummonCopyOfEnemy.not = true;

            TargetConstraintHasAttackEffect notSacrificeAlly = ScriptableObject.CreateInstance();
            notSacrificeAlly.name = "Does Not Have Sacrifice Ally";
            notSacrificeAlly.effect = TryGet("Sacrifice Ally");
            notSacrificeAlly.not = true;
            #endregion

            #region Has Status
            TargetConstraintHasStatus hasConsume = ScriptableObject.CreateInstance();
            hasConsume.name = "Has Consume";
            hasConsume.status = TryGet("Destroy After Use");

            TargetConstraintHasStatus notHitAllEnemies = ScriptableObject.CreateInstance();
            notHitAllEnemies.name = "Does Not Have Hit All Enemies";
            notHitAllEnemies.status = TryGet("Hit All Enemies");
            notHitAllEnemies.not = true;
            #endregion

            #region Has Trait
            TargetConstraintHasTrait notAimless = ScriptableObject.CreateInstance();
            notAimless.name = "Does Not Have Aimless";
            notAimless.trait = TryGet("Aimless");
            notAimless.not = true;

            TargetConstraintHasTrait notBarrage = ScriptableObject.CreateInstance();
            notBarrage.name = "Does Not Have Barrage";
            notBarrage.trait = TryGet("Barrage");
            notBarrage.not = true;

            TargetConstraintHasTrait notLongshot = ScriptableObject.CreateInstance();
            notLongshot.name = "Does Not Have Longshot";
            notLongshot.trait = TryGet("Longshot");
            notLongshot.not = true;
            #endregion

            #region Play On Slot
            TargetConstraintPlayOnSlot playsOnBoard = ScriptableObject.CreateInstance();
            playsOnBoard.name = "Plays On Board";
            playsOnBoard.board = true;

            TargetConstraintPlayOnSlot notSlot = ScriptableObject.CreateInstance();
            notSlot.name = "Does Not Play On Slot";
            notSlot.slot = true;
            notSlot.not = true;
            #endregion

            #region Max Counter More Than
            TargetConstraintMaxCounterMoreThan counterMoreThan0 = ScriptableObject.CreateInstance();
            counterMoreThan0.name = "Max Counter More Than 0";
            #endregion

            #region Is Card Type
            TargetConstraintIsCardType notBoss = ScriptableObject.CreateInstance();
            notBoss.name = "Is Not Boss";
            notBoss.allowedTypes = new CardType[] { TryGet("Boss") };
            notBoss.not = true;

            TargetConstraintIsCardType notMiniboss = ScriptableObject.CreateInstance();
            notMiniboss.name = "Is Not Miniboss";
            notMiniboss.allowedTypes = new CardType[] { TryGet("Miniboss") };
            notMiniboss.not = true;

            TargetConstraintIsCardType notSmallBoss = ScriptableObject.CreateInstance();
            notSmallBoss.name = "Is Not Small Boss";
            notSmallBoss.allowedTypes = new CardType[] { TryGet("BossSmall") };
            notSmallBoss.not = true;
            #endregion

            #region Miscellaneous
            TargetConstraintDoesAttack doesAttack = ScriptableObject.CreateInstance();
            doesAttack.name = "Does Attack";

            TargetConstraintDoesDamage doesDamage = ScriptableObject.CreateInstance();
            doesDamage.name = "Does Damage";

            TargetConstraintHasHealth hasHealth = ScriptableObject.CreateInstance();
            hasHealth.name = "Has Health";

            TargetConstraintHasReaction hasReaction = ScriptableObject.CreateInstance();
            hasReaction.name = "Has Reaction";

            TargetConstraintIsUnit isUnit = ScriptableObject.CreateInstance();
            isUnit.name = "Is Unit";

            TargetConstraintIsItem isItem = ScriptableObject.CreateInstance();
            isItem.name = "Is Item";

            TargetConstraintNeedsTarget needsTarget = ScriptableObject.CreateInstance();
            needsTarget.name = "Needs Target";
            #endregion

            #region Or
            TargetConstraintOr doesTrigger = ScriptableObject.CreateInstance();
            doesTrigger.name = "Does Trigger";
            doesTrigger.constraints = new TargetConstraint[] { hasReaction, counterMoreThan0, isItem };

            TargetConstraintOr hasHealthOrAttack = ScriptableObject.CreateInstance();
            hasHealthOrAttack.name = "Has Health Or Attack";
            hasHealthOrAttack.constraints = new TargetConstraint[] { hasHealth, doesDamage };

            TargetConstraintOr isUnitOrNeedsTarget = ScriptableObject.CreateInstance();
            isUnitOrNeedsTarget.name = "Is Unit Or Needs Target";
            isUnitOrNeedsTarget.constraints = new TargetConstraint[] { isUnit, needsTarget };
            #endregion

            targetConstraints.AddRange(new TargetConstraint[]
            {
                // Has Attack Effect
                notInstantSummonCopy,
                notInstantSummonCopyOfEnemy,
                notSacrificeAlly,

                // Has Status
                hasConsume,
                notHitAllEnemies,

                // Has Trait
                notAimless,
                notBarrage,
                notLongshot,

                // Play On Slot
                playsOnBoard,
                notSlot,

                // Max Counter More Than
                counterMoreThan0,

                // Is Card Type
                notBoss,
                notMiniboss,
                notSmallBoss,

                // Miscellaneous
                doesAttack,
                doesDamage,
                hasHealth,
                hasReaction,
                isUnit,
                isItem,
                needsTarget,

                // Or
                doesTrigger,
                hasHealthOrAttack,
                isUnitOrNeedsTarget
            });
        }

        private void CreateModCards()
        {
            #region Tribes
            assets.Add(
                TribeCopy("Clunk", "Wanderers")
                .WithFlag("Images/Tribes/Wanderer_Tribe_Flag.png")
                .WithSelectSfxEvent(FMODUnity.RuntimeManager.PathToEventReference("event:/sfx/status/bom_hit"))
                .SubscribeToAfterAllBuildEvent(
                    (data) =>
                    {
                        // Game Object
                        GameObject gameObject = data.characterPrefab.gameObject.InstantiateKeepName();   //Copy the previous prefab
                        UnityEngine.Object.DontDestroyOnLoad(gameObject);                                //GameObject may be destroyed if their scene is unloaded. This ensures that will never happen to our gameObject
                        gameObject.name = "Player (Wanderers)";                                          //For comparison, the clunkmaster character is named "Player (Clunk)"
                        data.characterPrefab = gameObject.GetComponent();                     //Set the characterPrefab to our new prefab
                        data.id = "Wanderers";                                                           //Used to track win/loss statistics for the tribe. Not displayed anywhere though :/
                        
                        // Leaders
                        data.leaders = new CardData[] { TryGet("tom"), TryGet("dingo"), TryGet("dandy") };

                        // Starting Deck
                        Inventory inventory = ScriptableObject.CreateInstance();
                        CardDataList startingDeck = new CardDataList();
                        startingDeck.Add(TryGet("hatchet"));
                        startingDeck.Add(TryGet("hatchet"));
                        startingDeck.Add(TryGet("hatchet"));
                        startingDeck.Add(TryGet("hatchet"));
                        startingDeck.Add(TryGet("frozenfire"));
                        startingDeck.Add(TryGet("rations"));
                        startingDeck.Add(TryGet("playingcards"));
                        startingDeck.Add(TryGet("sewingkit"));
                        inventory.deck = startingDeck;
                        data.startingInventory = inventory;

                        // Reward Pools
                        RewardPool unitPool = CreateRewardPool("WanderersUnitPool", "Units", new DataFile[]
                        {
                            TryGet("Elysio"),
                            TryGet("fiend"),
                            TryGet("temn"),
                            TryGet("captainzoryn"),
                            TryGet("pixel"),
                            TryGet("zaden"),
                            TryGet("salem"),
                            TryGet("razz"),
                            TryGet("harriot"),
                            TryGet("peppermint"),
                            TryGet("covet"),
                            TryGet("trogan"),
                            TryGet("buttercup"),
                            TryGet("jasper"),
                            TryGet("stasis"),
                            TryGet("Priscylla"),
                            TryGet("Felice"),
                            TryGet("Brewster"),
                            TryGet("Ether"),
                            TryGet("Steven"),
                            TryGet("Joseph"),
                            TryGet("Hugo"),
                            TryGet("Hullaballoo"),
                            TryGet("Oryx"),
                            TryGet("Atticus"),
                            TryGet("Kreedance"),
                            TryGet("Ren"),
                            TryGet("Snip"),
                            TryGet("Brew"),
                            TryGet("Barb")
                        });

                        RewardPool itemPool = CreateRewardPool("WanderersItemPool", "Items", new DataFile[]
                        {
                            // Items
                            TryGet("Whiskey"),
                            TryGet("Smokes"),
                            TryGet("Painkillers"),
                            TryGet("ConfusingMap"),
                            TryGet("SoulCandy"),
                            TryGet("Book"),
                            TryGet("RageBrew"),
                            TryGet("MercifulDagger"),
                            TryGet("Cutlass"),
                            TryGet("WornDice"),
                            TryGet("Quill"),
                            TryGet("FoulSoup"),
                            TryGet("HuntingSpear"),
                            TryGet("ThermalTracker"),
                            TryGet("Pickaxe"),
                            TryGet("VolatileVial"),
                            TryGet("BarbedWire"),
                            TryGet("SunCookies"),
                            TryGet("ScytheShard"),
                            TryGet("PaidContract"),
                            TryGet("GoodSoup"),
                            TryGet("Bomb"),
                            TryGet("ReligiousText"),
                            TryGet("OtherworldlyFeather"),
                            TryGet("HauntedSword"),
                            TryGet("AssortedPeppers"),
                            TryGet("ForagingBasket"),
                            TryGet("SpoiledRations"),
                            //TryGet("TinySnowman"),
                            TryGet("MassiveSnowflake"),
                            TryGet("BottledDream"),
                            TryGet("TastyPage"),
                            TryGet("CursedScythe"),
                            TryGet("Cage"),
                            TryGet("BloodTrail"),
                            TryGet("FaintShadow"),
                            TryGet("SnakeOil"),
                            TryGet("SoothingTea"),

                            // Clunkers
                            TryGet("Firewood"),
                            TryGet("Radio"),
                            TryGet("FrostedTree"),
                            TryGet("NooseTrap"),
                            TryGet("Booty"),
                            TryGet("Effigy"),
                            TryGet("Bookshelf"),
                            TryGet("VultureTotem")
                        });

                        RewardPool charmPool = CreateRewardPool("WanderersCharmPool", "Charms", new DataFile[]
                        {
                            TryGet("CardUpgradeHunter"),
                            TryGet("CardUpgradeScavenger"),
                            TryGet("CardUpgradeHex"),
                            TryGet("CardUpgradeSplash"),
                            TryGet("CardUpgradeAdaptive")
                        });

                        data.rewardPools = new RewardPool[]
                        {
                            unitPool,
                            itemPool,
                            charmPool,
                            Extensions.GetRewardPool("GeneralCharmPool"),
                            Extensions.GetRewardPool("GeneralModifierPool")
                        };
                    })
                );
            #endregion

            #region Leaders

            #region Tom
            assets.Add(
                new CardDataBuilder(this).CreateUnit("tom", "Tom")
                .SetSprites("Characters/WandererTribe_CardArt_Tom.png", "Backgrounds/WandererTribe_CardBG_Tom.png")
                .SetStats(7, 1, 4)
                .WithCardType("Leader")
                .SubscribeToAfterAllBuildEvent(delegate (CardData data)
                {
                    // Creation scripts
                    data.createScripts = new CardScript[]
                    {
                        GiveUpgrade()
                    };

                    // Effect
                    data.startWithEffects = new CardData.StatusEffectStacks[]
                    {
                        SStack("When Ally Is Targeted Add Attack Or Health", 1)
                    };
                })
                );
            #endregion

            #region Dandy
            assets.Add(
                new CardDataBuilder(this).CreateUnit("dandy", "Dandy")
                .SetSprites("Characters/WandererTribe_CardArt_Dandy.png", "Backgrounds/WandererTribe_CardBG_Dandy.png")
                .SetStats(8)
                .WithCardType("Leader")
                .SubscribeToAfterAllBuildEvent(delegate (CardData data)
                {
                    // Creation scripts
                    data.createScripts = new CardScript[]
                    {
                        GiveUpgrade()
                    };

                    // Effect
                    data.startWithEffects = new CardData.StatusEffectStacks[]
                    {
                        SStack("When Hit Restore Health And Reduce Counter To Allies", 1)
                    };
                })
                );
            #endregion

            #region Dingo
            assets.Add(
                new CardDataBuilder(this).CreateUnit("dingo", "Dingo")
                .SetSprites("Characters/WandererTribe_CardArt_Dingo.png", "Backgrounds/WandererTribe_CardBG_Dingo.png")
                .SetStats(6, 2, 3)
                .WithCardType("Leader")
                .SubscribeToAfterAllBuildEvent(delegate (CardData data)
                {
                    // Creation scripts
                    data.createScripts = new CardScript[]
                    {
                        GiveUpgrade()
                    };

                    // Effect
                    data.startWithEffects = new CardData.StatusEffectStacks[]
                    {
                        SStack("While Active Increase Effects To Allies & Enemies (Fixed)", 1),
                        SStack("Hex", 2)
                    };
                })
                );
            #endregion

            #endregion

            #region Companions

            #region Fiend
            assets.Add(
                new CardDataBuilder(this).CreateUnit("fiend", "Fiend")
                .SetSprites("Characters/WandererTribe_CardArt_Fiend.png", "Backgrounds/WandererTribe_CardBG_Fiend.png")
                .SetStats(8, 2, 4)
                .WithCardType("Friendly")
                .SetStartWithEffect(SStack("When Hit Draw", 1), SStack("On Kill Draw", 1))
                );
            #endregion

            #region Temn
            assets.Add(
                new CardDataBuilder(this).CreateUnit("temn", "Temn")
                .SetSprites("Characters/WandererTribe_CardArt_Temn.png", "Backgrounds/WandererTribe_CardBG_Temn.png")
                .SetStats(4, null, 3)
                .WithCardType("Friendly")
                .SetAttackEffect(SStack("Null", 3))
                .SetTraits(TStack("Aimless", 1))
                .SubscribeToAfterAllBuildEvent(delegate (CardData data)
                {
                    // Effect
                    data.startWithEffects = new CardData.StatusEffectStacks[]
                    {
                        SStack("On Card Played Copy Effects", 1)
                    };
                })
                );
            #endregion

            #region Captain Zoryn
            assets.Add(
                new CardDataBuilder(this).CreateUnit("captainzoryn", "Captain Zoryn")
                .SetSprites("Characters/WandererTribe_CardArt_CaptainZoryn.png", "Backgrounds/WandererTribe_CardBG_Zoryn.png")
                .SetStats(3, 3, 4)
                .WithCardType("Friendly")
                .SetTraits(TStack("Longshot", 1))
                .SubscribeToAfterAllBuildEvent(delegate (CardData data)
                {
                    // Effect
                    data.startWithEffects = new CardData.StatusEffectStacks[]
                    {
                        SStack("On Turn Drop Gold", 1),
                        SStack("On Card Played Boost To Self", 1)
                    };
                })
                );
            #endregion

            #region Pixel
            assets.Add(
                new CardDataBuilder(this).CreateUnit("pixel", "Pixel")
                .SetSprites("Characters/WandererTribe_CardArt_Pixel.png", "Backgrounds/WandererTribe_CardBG_Pixel.png")
                .SetStats(3, 1, 3)
                .WithCardType("Friendly")
                .SubscribeToAfterAllBuildEvent(delegate (CardData data)
                {
                    // Effect
                    data.startWithEffects = new CardData.StatusEffectStacks[]
                    {
                        SStack("When Card Is Consumed Add Attack To All Allies", 1)
                    };
                })
                );
            #endregion

            #region Zaden
            assets.Add(
                new CardDataBuilder(this).CreateUnit("zaden", "Zaden")
                .SetSprites("Characters/WandererTribe_CardArt_Berry.png", "Backgrounds/WandererTribe_CardBG_Berry.png")
                .SetStats(4, 0, 4)
                .WithCardType("Friendly")
                .SubscribeToAfterAllBuildEvent(delegate (CardData data)
                {
                    // Effect
                    data.startWithEffects = new CardData.StatusEffectStacks[]
                    {
                        SStack("Hex", 1)
                    };

                    data.traits.Add(TStack("Splash", 1));
                })
                );
            #endregion

            #region Salem
            assets.Add(
                new CardDataBuilder(this).CreateUnit("salem", "Salem")
                .SetSprites("Characters/WandererTribe_CardArt_Vultra.png", "Backgrounds/WandererTribe_CardBG_Vultra.png")
                .SetStats(10, 0, 5)
                .WithCardType("Friendly")
                .SetTraits(TStack("Smackback", 1))
                .SubscribeToAfterAllBuildEvent(delegate (CardData data)
                {
                    // Effect
                    data.startWithEffects = new CardData.StatusEffectStacks[]
                    {
                        SStack("Bonus Damage Equal To Enemy Missing Health", 1)
                    };
                })
                );
            #endregion

            #region Razz
            assets.Add(
                new CardDataBuilder(this).CreateUnit("razz", "Razz")
                .SetSprites("Characters/WandererTribe_CardArt_Razz.png", "Backgrounds/WandererTribe_CardBG_Razz.png")
                .SetStats(6, 5, 4)
                .WithCardType("Friendly")
                .SubscribeToAfterAllBuildEvent(delegate (CardData data)
                {
                    // Effect
                    data.startWithEffects = new CardData.StatusEffectStacks[]
                    {
                        SStack("When Reduce Counter Reduce Counter", 1)
                    };
                })
                );
            #endregion

            #region Harriot
            assets.Add(
                new CardDataBuilder(this).CreateUnit("harriot", "Harriot")
                .SetSprites("Characters/WandererTribe_CardArt_Harriot.png", "Backgrounds/WandererTribe_CardBG_Harriot.png")
                .SetStats(4, 1, 4)
                .WithCardType("Friendly")
                .SubscribeToAfterAllBuildEvent(delegate (CardData data)
                {
                    // Effect
                    data.startWithEffects = new CardData.StatusEffectStacks[]
                    {
                        SStack("On Card Played Destroy Rightmost Card In Hand And Gain Attack", 1)
                    };
                })
                );
            #endregion

            #region Peppermint
            assets.Add(
                new CardDataBuilder(this).CreateUnit("peppermint", "Peppermint")
                .SetSprites("Characters/WandererTribe_CardArt_Peppermint.png", "Backgrounds/WandererTribe_CardBG_Peppermint.png")
                .SetStats(9)
                .WithCardType("Friendly")
                .SubscribeToAfterAllBuildEvent(delegate (CardData data)
                {
                    // Effect
                    data.startWithEffects = new CardData.StatusEffectStacks[]
                    {
                        SStack("When Healed Apply Shroom To Random Enemy", 1)
                    };
                })
                );
            #endregion

            #region Covet
            assets.Add(
                new CardDataBuilder(this).CreateUnit("covet", "Covet")
                .SetSprites("Characters/WandererTribe_CardArt_Covet.png", "Backgrounds/WandererTribe_CardBG_Covet.png")
                .SetStats(1, 1, 2)
                .WithCardType("Friendly")
                .SubscribeToAfterAllBuildEvent(delegate (CardData data)
                {
                    // Effect
                    data.startWithEffects = new CardData.StatusEffectStacks[]
                    {
                        SStack("When Deployed Swap Stats With Front Ally", 1)
                    };
                })
                );
            #endregion

            #region Trogan
            assets.Add(
                new CardDataBuilder(this).CreateUnit("trogan", "Trogan")
                .SetSprites("Characters/WandererTribe_CardArt_Trogan.png", "Backgrounds/WandererTribe_CardBG_Trogan.png")
                .SetStats(8, 3, 5)
                .WithCardType("Friendly")
                .SubscribeToAfterAllBuildEvent(delegate (CardData data)
                {
                    // Effect
                    data.startWithEffects = new CardData.StatusEffectStacks[]
                    {
                        SStack("Adaptive", 1)
                    };
                })
                );
            #endregion

            #region Buttercup
            assets.Add(
                new CardDataBuilder(this).CreateUnit("buttercup", "Buttercup")
                .SetSprites("Characters/WandererTribe_CardArt_Buttercup.png", "Backgrounds/WandererTribe_CardBG_Buttercup.png")
                .SetStats(4, 2, 3)
                .WithCardType("Friendly")
                .SubscribeToAfterAllBuildEvent(delegate (CardData data)
                {
                    // Effect
                    data.startWithEffects = new CardData.StatusEffectStacks[]
                    {
                        SStack("On Card Played Trigger Against Allies In Row", 1)
                    };

                    data.traits.Add(TStack("Scavenger", 2));
                })
                );
            #endregion

            #region Jasper
            assets.Add(
                new CardDataBuilder(this).CreateUnit("jasper", "Jasper")
                .SetSprites("Characters/WandererTribe_CardArt_Jasper.png", "Backgrounds/WandererTribe_CardBG_Jasper.png")
                .SetStats(1)
                .WithCardType("Friendly")
                .SetTraits(TStack("Pigheaded", 1))
                .SubscribeToAfterAllBuildEvent(delegate (CardData data)
                {
                    // Effect
                    data.startWithEffects = new CardData.StatusEffectStacks[]
                    {
                        SStack("When Deployed Add Frenzy To Hand", 1)
                    };
                })
                );
            #endregion

            #region Stasis
            assets.Add(
                new CardDataBuilder(this).CreateUnit("stasis", "Stasis")
                .SetSprites("Characters/WandererTribe_CardArt_Stasis.png", "Backgrounds/WandererTribe_CardBG_Stasis.png")
                .SetStats(5)
                .WithCardType("Friendly")
                .SubscribeToAfterAllBuildEvent(delegate (CardData data)
                {
                    // Effect
                    data.startWithEffects = new CardData.StatusEffectStacks[]
                    {
                        SStack("When Deployed Summon Lion", 1)
                    };
                })
                );
            #endregion

            #region Priscylla
            assets.Add(
                new CardDataBuilder(this).CreateUnit("Priscylla", "Priscylla")
                .SetSprites("Characters/WandererTribe_CardArt_Stasis.png", "Backgrounds/WandererTribe_CardBG_Stasis.png")
                .SetStats(4)
                .WithCardType("Friendly")
                .SubscribeToAfterAllBuildEvent(delegate (CardData data)
                {
                    // Effect
                    data.startWithEffects = new CardData.StatusEffectStacks[]
                    {
                        SStack("Trigger Against When Enemy Below Health X", 4)
                    };

                    data.attackEffects = new CardData.StatusEffectStacks[]
                    {
                        SStack("Instant Kill", 1)
                    };
                })
                );
            #endregion

            #region Felice
            assets.Add(
                new CardDataBuilder(this).CreateUnit("Felice", "Felice")
                .SetSprites("Characters/WandererTribe_CardArt_Stasis.png", "Backgrounds/WandererTribe_CardBG_Stasis.png")
                .SetStats(1, null, 2)
                .WithCardType("Friendly")
                .SubscribeToAfterAllBuildEvent(delegate (CardData data)
                {
                    // Effect
                    data.startWithEffects = new CardData.StatusEffectStacks[]
                    {
                        SStack("Summon Sheep Coworker", 1),
                        SStack("On Card Played Add Paperwork To Hand", 1)
                    };
                })
                );
            #endregion

            #region Brewster
            assets.Add(
                new CardDataBuilder(this).CreateUnit("Brewster", "Brewster")
                .SetSprites("Characters/WandererTribe_CardArt_Stasis.png", "Backgrounds/WandererTribe_CardBG_Stasis.png")
                .SetStats(1, 0, 4)
                .WithCardType("Friendly")
                .SetTraits(TStack("Aimless", 1), TStack("Fragile", 1), TStack("Wild", 1), TStack("Pull", 1))
                .SubscribeToAfterAllBuildEvent(delegate (CardData data)
                {
                    // Effect
                    data.startWithEffects = new CardData.StatusEffectStacks[]
                    {
                        SStack("MultiHit", 2),
                        SStack("Bloodlust", 1)
                    };
                })
                );
            #endregion

            #region Ether
            assets.Add(
                new CardDataBuilder(this).CreateUnit("Ether", "Ether")
                .SetSprites("Characters/WandererTribe_CardArt_Stasis.png", "Backgrounds/WandererTribe_CardBG_Stasis.png")
                .SetStats(3, 0, 10)
                .WithCardType("Friendly")
                .SubscribeToAfterAllBuildEvent(delegate (CardData data)
                {
                    // Effect
                    data.startWithEffects = new CardData.StatusEffectStacks[]
                    {
                        SStack("On Card Played Increase Counter To Target And Reduce Counter To Self", 1),
                        SStack("On Turn Apply Attack To Self", 1),
                        SStack("Trigger Against When Enemy Attacks", 1)
                    };
                })
                );
            #endregion

            #region Steven
            assets.Add(
                new CardDataBuilder(this).CreateUnit("Steven", "Steven")
                .SetSprites("Characters/WandererTribe_CardArt_Stasis.png", "Backgrounds/WandererTribe_CardBG_Stasis.png")
                .SetStats(6, 2, 3)
                .WithCardType("Friendly")
                .SubscribeToAfterAllBuildEvent(delegate (CardData data)
                {
                    // Effect
                    data.startWithEffects = new CardData.StatusEffectStacks[]
                    {
                        SStack("While Active In Full Board Gain Attack And Barrage", 3)
                    };
                })
                );
            #endregion

            #region Joseph
            assets.Add(
                new CardDataBuilder(this).CreateUnit("Joseph", "Joseph")
                .SetSprites("Characters/WandererTribe_CardArt_Stasis.png", "Backgrounds/WandererTribe_CardBG_Stasis.png")
                .SetStats(3, 1, 4)
                .WithCardType("Friendly")
                .SubscribeToAfterAllBuildEvent(delegate (CardData data)
                {
                    // Effect
                    data.startWithEffects = new CardData.StatusEffectStacks[]
                    {
                        SStack("On Card Played Sacrifice Adjacent Allies", 1)
                    };

                    data.traits.Add(TStack("Scavenger", 3));
                })
                );
            #endregion

            #region Hugo
            assets.Add(
                new CardDataBuilder(this).CreateUnit("Hugo", "Hugo")
                .SetSprites("Characters/WandererTribe_CardArt_Stasis.png", "Backgrounds/WandererTribe_CardBG_Stasis.png")
                .SetStats(1, null, 4)
                .WithCardType("Friendly")
                .CanBeHit(false) // Intangible
                .SubscribeToAfterAllBuildEvent(delegate (CardData data)
                {
                    // Effect
                    data.attackEffects = new CardData.StatusEffectStacks[]
                    {
                        SStack("Overload", 1)
                        
                    };

                    data.startWithEffects = new CardData.StatusEffectStacks[]
                    {
                        SStack("Intangible", 1),
                        SStack("Nocturnal", 1),
                        SStack("On Card Played Boost To Self", 1),
                        SStack("Hit All Enemies", 1)
                    };
                })
                );
            #endregion

            #region Hullaballoo
            assets.Add(
                new CardDataBuilder(this).CreateUnit("Hullaballoo", "Hullaballoo")
                .SetSprites("Characters/WandererTribe_CardArt_Stasis.png", "Backgrounds/WandererTribe_CardBG_Stasis.png")
                .SetStats(1, 3, 4)
                .WithCardType("Friendly")
                .SetStartWithEffect(SStack("Block", 1), SStack("On Card Played Apply Block To Self", 1))
                );
            #endregion

            #region Oryx
            assets.Add(
                new CardDataBuilder(this).CreateUnit("Oryx", "Oryx")
                .SetSprites("Characters/WandererTribe_CardArt_Stasis.png", "Backgrounds/WandererTribe_CardBG_Stasis.png")
                .SetStats(1, null, 2)
                .WithCardType("Friendly")
                .CanBeHit(false) // Intangible
                .SetTraits(TStack("Draw",1))
                .SubscribeToAfterAllBuildEvent(delegate (CardData data)
                {
                    // Effect
                    data.startWithEffects = new CardData.StatusEffectStacks[]
                    {
                        SStack("Intangible", 1),
                        SStack("Nocturnal", 1)
                    };
                })
                );
            #endregion

            #region Atticus
            assets.Add(
                new CardDataBuilder(this).CreateUnit("Atticus", "Atticus")
                .SetSprites("Characters/WandererTribe_CardArt_Trogan.png", "Backgrounds/WandererTribe_CardBG_Trogan.png")
                .SetStats(8, 0, 5)
                .WithCardType("Friendly")
                .SetAttackEffect(SStack("Overload", 3))
                .SubscribeToAfterAllBuildEvent(delegate (CardData data)
                {
                    // Effect
                    data.startWithEffects = new CardData.StatusEffectStacks[]
                    {
                        SStack("Adaptive", 1)
                    };
                })
                );
            #endregion

            #region Kreedance
            assets.Add(
                new CardDataBuilder(this).CreateUnit("Kreedance", "Kreedance")
                .SetSprites("Characters/WandererTribe_CardArt_Trogan.png", "Backgrounds/WandererTribe_CardBG_Trogan.png")
                .SetStats(12, 1)
                .WithCardType("Friendly")
                .SetTraits(TStack("Smackback", 1))
                .SubscribeToAfterAllBuildEvent(delegate (CardData data)
                {
                    // Effect
                    data.startWithEffects = new CardData.StatusEffectStacks[]
                    {
                        SStack("Teeth", 3),
                        SStack("Pre Card Played Apply Smackback To Target", 1)
                    };
                })
                );
            #endregion

            #region Ren
            assets.Add(
                new CardDataBuilder(this).CreateUnit("Ren", "Ren")
                .SetSprites("Characters/WandererTribe_CardArt_Trogan.png", "Backgrounds/WandererTribe_CardBG_Trogan.png")
                .SetStats(9, 2, 4)
                .WithCardType("Friendly")
                .SubscribeToAfterAllBuildEvent(delegate (CardData data)
                {
                    // Effect
                    data.startWithEffects = new CardData.StatusEffectStacks[]
                    {
                        SStack("On Turn Heal Self And Allies", 2)
                    };
                })
                );
            #endregion

            #region Snip
            assets.Add(
                new CardDataBuilder(this).CreateUnit("Snip", "Snip")
                .SetSprites("Characters/WandererTribe_CardArt_Trogan.png", "Backgrounds/WandererTribe_CardBG_Trogan.png")
                .SetStats(2, 5, 2)
                .WithCardType("Friendly")
                .SetTraits(TStack("Pull", 1))
                .SubscribeToAfterAllBuildEvent(delegate (CardData data)
                {
                    // Effect
                    data.startWithEffects = new CardData.StatusEffectStacks[]
                    {
                        SStack("On Turn Randomize Stats (2-5)", 1),
                        SStack("Adaptive", 1)
                    };
                })
                );
            #endregion

            #region Brew
            assets.Add(
                new CardDataBuilder(this).CreateUnit("Brew", "Brew")
                .SetSprites("Characters/WandererTribe_CardArt_Trogan.png", "Backgrounds/WandererTribe_CardBG_Trogan.png")
                .SetStats(11)
                .WithCardType("Friendly")
                .SubscribeToAfterAllBuildEvent(delegate (CardData data)
                {
                    // Effect
                    data.startWithEffects = new CardData.StatusEffectStacks[]
                    {
                        SStack("When Hit Multiple 5 Instant Summon Big Fishy", 5)
                    };
                })
                );
            #endregion

            #region Barb
            assets.Add(
                new CardDataBuilder(this).CreateUnit("Barb", "Barb")
                .SetSprites("Characters/WandererTribe_CardArt_Trogan.png", "Backgrounds/WandererTribe_CardBG_Trogan.png")
                .SetStats(7, 2, 4)
                .WithCardType("Friendly")
                .SetAttackEffect(SStack("Null", 5))
                );
            #endregion

            #region Roséate
            assets.Add(new CardDataBuilder(this)
                .CreateUnit("Roseate", "Roseate")
                .SetSprites("Characters/WandererTribe_CardArt_Trogan.png", "Backgrounds/WandererTribe_CardBG_Trogan.png")
                .SetStats(2, 2, 3)
                .WithCardType("Friendly")
                .SubscribeToAfterAllBuildEvent(delegate (CardData data)
                {
                    // Effect
                    data.startWithEffects = new CardData.StatusEffectStacks[]
                    {
                        SStack("On Card Played Instant Swap Effects", 1)
                    };
                })
                );
            #endregion

            #endregion

            #region Pets

            #region Rye
            assets.Add(
                new CardDataBuilder(this).CreateUnit("Rye", "Rye")
                .SetSprites("Characters/WandererTribe_CardArt_Fiend.png", "Backgrounds/WandererTribe_CardBG_Fiend.png")
                .SetStats(3, 3)
                .WithCardType("Friendly")
                .IsPet(String.Empty)
                .SubscribeToAfterAllBuildEvent(delegate (CardData data)
                {
                    // Effect
                    data.startWithEffects = new CardData.StatusEffectStacks[]
                    {
                        SStack("On Card Played Discard Self", 1),
                        SStack("Trigger Against Random Enemy When Drawn", 1),
                        SStack("Destroy After Place", 1)
                    };
                })
                );
            #endregion

            #region Lionel
            assets.Add(
                new CardDataBuilder(this).CreateUnit("Lionel", "Lionel")
                .SetSprites("Characters/WandererTribe_CardArt_Fiend.png", "Backgrounds/WandererTribe_CardBG_Fiend.png")
                .SetStats(3, 2, 3)
                .WithCardType("Friendly")
                .IsPet(String.Empty)
                .SubscribeToAfterAllBuildEvent(delegate (CardData data)
                {
                    // Effect
                    data.startWithEffects = new CardData.StatusEffectStacks[]
                    {
                        SStack("On Card Played Apply Bless To Random Ally", 1)
                    };
                })
                );
            #endregion

            #region Talon
            assets.Add(
                new CardDataBuilder(this).CreateUnit("Talon", "Talon")
                .SetSprites("Characters/WandererTribe_CardArt_Fiend.png", "Backgrounds/WandererTribe_CardBG_Fiend.png")
                .SetStats(2, 2, 4)
                .WithCardType("Friendly")
                .IsPet(String.Empty)
                .SubscribeToAfterAllBuildEvent(delegate (CardData data)
                {
                    // Effect
                    data.traits.Add(TStack("Scavenger", 1));
                })
                );
            #endregion

            #region Regus
            assets.Add(
                new CardDataBuilder(this).CreateUnit("Regus", "Regus")
                .SetSprites("Characters/WandererTribe_CardArt_Fiend.png", "Backgrounds/WandererTribe_CardBG_Fiend.png")
                .SetStats(6, 3, 3)
                .WithCardType("Friendly")
                .IsPet(String.Empty)
                .SubscribeToAfterAllBuildEvent(delegate (CardData data)
                {
                    // Effect
                    data.traits.Add(TStack("Hunter", 1));
                })
                );
            #endregion

            #endregion

            #region Summons

            #region Plush Monster
            assets.Add(
                new CardDataBuilder(this).CreateUnit("plushmonster", "Plush Monster")
                .SetSprites("Items/WandererTribe_CardArt_PlushMonster.png", "Backgrounds/WandererTribe_ItemBG_PlushMonster.png")
                .SetStats(1, null, 3)
                .WithCardType("Summoned")
                .SetTraits(TStack("Fragile", 1))
                .SetStartWithEffect(SStack("On Card Played Trigger RandomAlly", 1))
                .SubscribeToAfterAllBuildEvent(delegate (CardData data)
                {
                    data.startWithEffects[0].data.type = "On Card Played Trigger RandomAlly";
                    TargetConstraintHasStatusType constraint = ScriptableObject.CreateInstance();
                    constraint.statusType = "On Card Played Trigger RandomAlly";
                    constraint.not = true;
                    TargetConstraintHasStatus hasSnow = ScriptableObject.CreateInstance();
                    hasSnow.status = TryGet("Snow");
                    hasSnow.not = true;
                    ((StatusEffectApplyX)data.startWithEffects[0].data).applyConstraints = ((StatusEffectApplyX)data.startWithEffects[0].data).applyConstraints.AddRangeToArray(new TargetConstraint[] { constraint, hasSnow, ScriptableObject.CreateInstance(), ScriptableObject.CreateInstance() });
                })
                );
            #endregion

            #region Chuckles
            assets.Add(
                new CardDataBuilder(this).CreateUnit("chuckles", "Chuckles")
                .SetSprites("Characters/WandererTribe_CardArt_Chuckles.png", "Backgrounds/WandererTribe_CardBG_Chuckles.png")
                .SetStats(2, 2, 4)
                .WithCardType("Summoned")
                .SubscribeToAfterAllBuildEvent(delegate (CardData data)
                {
                    // Effect
                    data.traits.Add(TStack("Scavenger", 2));
                })
                );
            #endregion

            #region Steak
            assets.Add(
                new CardDataBuilder(this).CreateUnit("steak", "Steak")
                .SetSprites("Characters/WandererTribe_CardArt_Steak.png", "Backgrounds/WandererTribe_CardBG_Steak.png")
                .SetStats(8)
                .WithCardType("Summoned")
                .SetStartWithEffect(SStack("Teeth", 4))
                );
            #endregion

            #region Cleaver
            assets.Add(
                new CardDataBuilder(this).CreateUnit("cleaver", "Cleaver")
                .SetSprites("Characters/WandererTribe_CardArt_Cleaver.png", "Backgrounds/WandererTribe_CardBG_Cleaver.png")
                .SetStats(4, 4, 2)
                .WithCardType("Summoned")
                .SubscribeToAfterAllBuildEvent(delegate (CardData data)
                {
                    // Effect
                    data.traits = new List()
                    {
                        TStack("Hunter", 1)
                    };
                })
                );
            #endregion

            #region Arsy Lion
            assets.Add(
                new CardDataBuilder(this).CreateUnit("arsyLion", "Arsy")
                .SetSprites("Characters/WandererTribe_CardArt_ArsyLion.png", "Backgrounds/WandererTribe_CardBG_ArsyLion.png")
                .SetStats(1, null, 2)
                .WithCardType("Summoned")
                .SubscribeToAfterAllBuildEvent(delegate (CardData data)
                {
                    // Effect
                    data.startWithEffects = new CardData.StatusEffectStacks[]
                    {
                        SStack("When Deployed Summon All Lions", 1),
                        SStack("On Turn Escape To Self", 1)
                    };
                })
                );
            #endregion

            #region Innocent Monster
            assets.Add(
                new CardDataBuilder(this).CreateUnit("innocentMonster", "Innocent Monster")
                .SetSprites("Characters/WandererTribe_CardArt_ArsyLion.png", "Backgrounds/WandererTribe_CardBG_ArsyLion.png")
                .SetStats(5, 5)
                .WithCardType("Summoned")
                .SetTraits(TStack("Smackback", 1))
                .SubscribeToAfterAllBuildEvent(delegate (CardData data)
                {
                    // Effect
                    data.startWithEffects = new CardData.StatusEffectStacks[]
                    {
                        SStack("When Destroyed Add Health To Enemies", 5)
                    };
                })
                );
            #endregion

            #region Frozen Corpse
            assets.Add(
                new CardDataBuilder(this).CreateUnit("frozencorpse", "Frozen Corpse")
                .SetSprites("Characters/WandererTribe_CardArt_ArsyLion.png", "Backgrounds/WandererTribe_CardBG_ArsyLion.png")
                .SetStats(3, 1, 1)
                .WithCardType("Summoned")
                .SetAttackEffect(SStack("Snow", 2))
                .SubscribeToAfterAllBuildEvent(delegate (CardData data)
                {
                    // Effect
                    data.startWithEffects = new CardData.StatusEffectStacks[]
                    {
                        SStack("Block", 1),
                        SStack("Stop Count Down While Self Has Block", 1)
                    };
                })
                );
            #endregion

            #region Sheep Coworker
            assets.Add(
                new CardDataBuilder(this).CreateUnit("SheepCoworker", "Sheep Coworker")
                .SetSprites("Characters/WandererTribe_CardArt_ArsyLion.png", "Backgrounds/WandererTribe_CardBG_ArsyLion.png")
                .SetStats(1, null, 2)
                .WithCardType("Summoned")
                .SubscribeToAfterAllBuildEvent(delegate (CardData data)
                {
                    // Effect
                    data.startWithEffects = new CardData.StatusEffectStacks[]
                    {
                        SStack("On Card Played Apply Health To Self", 1),
                        SStack("On Card Played Add Paperwork To Hand", 1)
                    };
                })
                );
            #endregion

            #region Big Fishy
            assets.Add(
                new CardDataBuilder(this).CreateUnit("BigFishy", "Big Fishy")
                .SetSprites("Characters/WandererTribe_CardArt_ArsyLion.png", "Backgrounds/WandererTribe_CardBG_ArsyLion.png")
                .SetStats(15, 15)
                .WithCardType("Summoned")
                .SetTraits(TStack("Barrage", 1), TStack("Smackback", 1))
                );
            #endregion

            #region Nightmare
            assets.Add(
                new CardDataBuilder(this).CreateUnit("Nightmare", "Nightmare")
                .SetSprites("Characters/WandererTribe_CardArt_ArsyLion.png", "Backgrounds/WandererTribe_CardBG_ArsyLion.png")
                .SetStats(9, 1, 3)
                .WithCardType("Summoned")
                .SubscribeToAfterAllBuildEvent(delegate (CardData data)
                {
                    // Effect
                    data.startWithEffects = new CardData.StatusEffectStacks[]
                    {
                        SStack("Hex", 1),
                        SStack("When Ally Is Sacrificed Boost Effects To Self", 1)
                    };
                })
                );
            #endregion

            #region Knowledge Gremlin
            assets.Add(
                new CardDataBuilder(this).CreateUnit("KnowledgeGremlin", "Knowledge Gremlin")
                .SetSprites("Characters/WandererTribe_CardArt_ArsyLion.png", "Backgrounds/WandererTribe_CardBG_ArsyLion.png")
                .SetStats(3, 2)
                .WithCardType("Summoned")
                .SubscribeToAfterAllBuildEvent(delegate (CardData data)
                {
                    // Effect
                    data.startWithEffects = new CardData.StatusEffectStacks[]
                    {
                        SStack("Trigger When Card Drawn", 1)
                    };
                })
                );
            #endregion

            #region Savage Beast
            assets.Add(new CardDataBuilder(this)
                .CreateUnit("SavageBeast", "Savage Beast")
                .SetSprites("Characters/WandererTribe_CardArt_ArsyLion.png", "Backgrounds/WandererTribe_CardBG_ArsyLion.png")
                .SetStats(2, 6, 3)
                .WithCardType("Summoned")
                );
            #endregion

            #region Ravenous Creature
            assets.Add(new CardDataBuilder(this)
                .CreateUnit("RavenousCreature", "Ravenous Creature")
                .SetSprites("Characters/WandererTribe_CardArt_ArsyLion.png", "Backgrounds/WandererTribe_CardBG_ArsyLion.png")
                .SetStats(2, 2, 5)
                .WithCardType("Summoned")
                .SubscribeToAfterAllBuildEvent(delegate (CardData data)
                {
                    // Effect
                    data.startWithEffects = new CardData.StatusEffectStacks[]
                    {
                        SStack("When Ally Summoned Sacrifice Ally And Instant Apply Current Health And Attack", 1)
                    };
                })
                );
            #endregion

            #region Protector
            assets.Add(new CardDataBuilder(this)
                .CreateUnit("TomShadow", "Protector")
                .SetSprites("Characters/WandererTribe_SummonArt_Protector.png", "Backgrounds/WandererTribe_SummonBG_Protector.png")
                .SetStats(1, 1, 4)
                .WithCardType("Summoned")
                .SetTraits(TStack("Fragile", 1))
                .SubscribeToAfterAllBuildEvent(delegate (CardData data)
                {
                    // Effect
                    data.startWithEffects = new CardData.StatusEffectStacks[]
                    {
                        SStack("When Ally Is Targeted Add Attack Or Health", 1)
                    };
                })
                );
            #endregion

            #region Caregiver
            assets.Add(new CardDataBuilder(this)
                .CreateUnit("DandyShadow", "Caregiver")
                .SetSprites("Characters/WandererTribe_SummonArt_Caregiver.png", "Backgrounds/WandererTribe_SummonBG_Caregiver.png")
                .SetStats(1)
                .WithCardType("Summoned")
                .SetTraits(TStack("Fragile", 1))
                .SubscribeToAfterAllBuildEvent(delegate (CardData data)
                {
                    // Effect
                    data.startWithEffects = new CardData.StatusEffectStacks[]
                    {
                        SStack("When Hit Restore Health And Reduce Counter To Allies", 1)
                    };
                })
                );
            #endregion

            #region Despoiler
            assets.Add(new CardDataBuilder(this)
                .CreateUnit("DingoShadow", "Despoiler")
                .SetSprites("Characters/WandererTribe_SummonArt_Despoiler.png", "Backgrounds/WandererTribe_SummonBG_Despoiler.png")
                .SetStats(1, 2, 3)
                .WithCardType("Summoned")
                .SetTraits(TStack("Fragile", 1))
                .SubscribeToAfterAllBuildEvent(delegate (CardData data)
                {
                    // Effect
                    data.startWithEffects = new CardData.StatusEffectStacks[]
                    {
                        SStack("While Active Increase Effects To Allies & Enemies (Fixed)", 1),
                        SStack("Hex", 2)
                    };
                })
                );
            #endregion

            #endregion

            #region Clunkers

            #region Firewood
            assets.Add(new CardDataBuilder(this)
                .CreateUnit("Firewood", "Firewood", "TargetModeBasic", "")
                .SetSprites("Items/WandererTribe_CardArt_PlushMonster.png", "Backgrounds/WandererTribe_ItemBG_PlushMonster.png")
                .WithCardType("Clunker")
                .SetStats(null, null, 1)
                .SubscribeToAfterAllBuildEvent(delegate (CardData data)
                {
                    data.hasHealth = false;
                    data.hasAttack = false;

                    data.startWithEffects = new CardData.StatusEffectStacks[]
                    {
                        SStack("Scrap", 1),
                        SStack("On Turn Heal Allies In Row", 1)
                    };
                })
                );
            #endregion

            #region Radio
            assets.Add(new CardDataBuilder(this)
                .CreateUnit("Radio", "Radio", "TargetModeBasic", "")
                .SetSprites("Items/WandererTribe_CardArt_PlushMonster.png", "Backgrounds/WandererTribe_ItemBG_PlushMonster.png")
                .WithCardType("Clunker")
                .SetStats(null, null, 2)
                .SubscribeToAfterAllBuildEvent(delegate (CardData data)
                {
                    data.hasHealth = false;
                    data.hasAttack = false;

                    data.startWithEffects = new CardData.StatusEffectStacks[]
                    {
                        SStack("Scrap", 1),
                        SStack("On Turn Increase Attack To Allies In Row", 1)
                    };
                })
                );
            #endregion

            #region Frosted Tree
            assets.Add(new CardDataBuilder(this)
                .CreateUnit("FrostedTree", "Frosted Tree", "TargetModeBasic", "")
                .SetSprites("Items/WandererTribe_CardArt_PlushMonster.png", "Backgrounds/WandererTribe_ItemBG_PlushMonster.png")
                .WithCardType("Clunker")
                .SetTraits(TStack("Pigheaded", 1))
                .SubscribeToAfterAllBuildEvent(delegate (CardData data)
                {
                    data.hasHealth = false;
                    data.hasAttack = false;

                    data.startWithEffects = new CardData.StatusEffectStacks[]
                    {
                        SStack("Scrap", 1),
                        SStack("While Active Increase Effects And Decrease Attack To Allies In The Row", 1)
                    };
                })
                );
            #endregion

            #region Noose Trap
            assets.Add(new CardDataBuilder(this)
                .CreateUnit("NooseTrap", "Noose Trap", "TargetModeBasic", "")
                .SetSprites("Items/WandererTribe_CardArt_PlushMonster.png", "Backgrounds/WandererTribe_ItemBG_PlushMonster.png")
                .WithCardType("Clunker")
                .SubscribeToAfterAllBuildEvent(delegate (CardData data)
                {
                    data.hasHealth = false;
                    data.hasAttack = false;

                    data.startWithEffects = new CardData.StatusEffectStacks[]
                    {
                        SStack("Scrap", 1),
                        SStack("When Destroyed Set Attacker Attack", 1)
                    };
                })
                );
            #endregion

            #region Pile O' Booty
            assets.Add(new CardDataBuilder(this)
                .CreateUnit("Booty", "Pile O' Booty", "TargetModeBasic", "")
                .SetSprites("Items/WandererTribe_CardArt_PlushMonster.png", "Backgrounds/WandererTribe_ItemBG_PlushMonster.png")
                .WithCardType("Clunker")
                .SubscribeToAfterAllBuildEvent(delegate (CardData data)
                {
                    data.hasHealth = false;
                    data.hasAttack = false;

                    data.startWithEffects = new CardData.StatusEffectStacks[]
                    {
                        SStack("Scrap", 1),
                        SStack("On Turn Drop Gold", 1),
                        SStack("On Card Played Boost To Self", 1),
                        SStack("Trigger When Enemy Is Killed", 1)
                    };
                })
                );
            #endregion

            #region Effigy
            assets.Add(new CardDataBuilder(this)
                .CreateUnit("Effigy", "Effigy", "TargetModeBasic", "")
                .SetSprites("Items/WandererTribe_CardArt_PlushMonster.png", "Backgrounds/WandererTribe_ItemBG_PlushMonster.png")
                .WithCardType("Clunker")
                .SubscribeToAfterAllBuildEvent(delegate (CardData data)
                {
                    data.hasHealth = false;
                    data.hasAttack = false;

                    data.startWithEffects = new CardData.StatusEffectStacks[]
                    {
                        SStack("Scrap", 1),
                        SStack("On Card Played Apply Bless To Allies", 1),
                        SStack("Trigger When Ally Is Killed", 1)
                    };
                })
                );
            #endregion

            #region Bookshelf
            assets.Add(new CardDataBuilder(this)
                .CreateUnit("Bookshelf", "Bookshelf", "TargetModeBasic", "")
                .SetSprites("Items/WandererTribe_CardArt_PlushMonster.png", "Backgrounds/WandererTribe_ItemBG_PlushMonster.png")
                .WithCardType("Clunker")
                .SubscribeToAfterAllBuildEvent(delegate (CardData data)
                {
                    data.hasHealth = false;
                    data.hasAttack = false;

                    data.startWithEffects = new CardData.StatusEffectStacks[]
                    {
                        SStack("Scrap", 1),
                        SStack("On Card Played Draw Equal To Summoned Allies", 1),
                        SStack("Trigger When Ally Summoned", 1)
                    };
                })
                );
            #endregion

            #region Vulture Totem
            assets.Add(new CardDataBuilder(this)
                .CreateUnit("VultureTotem", "Vulture Totem", "TargetModeBasic", "")
                .SetSprites("Items/WandererTribe_CardArt_PlushMonster.png", "Backgrounds/WandererTribe_ItemBG_PlushMonster.png")
                .WithCardType("Clunker")
                .SubscribeToAfterAllBuildEvent(delegate (CardData data)
                {
                    data.hasHealth = false;
                    data.hasAttack = false;

                    data.startWithEffects = new CardData.StatusEffectStacks[]
                    {
                        SStack("Scrap", 1),
                        SStack("On Card Played Instant Add Scavenger To Random Ally", 1),
                        SStack("Trigger When Ally Is Sacrificed", 1)
                    };
                })
                );
            #endregion

            #endregion

            #region Enemies

            #region Dingo
            assets.Add(
                new CardDataBuilder(this).CreateUnit("EnemyDingo", "Dingo")
                .SetSprites("Characters/Enemy_Dingo.png", "Backgrounds/Enemy_Dingo_Background.png")
                .SetStats(4, 2, 2)
                .WithCardType("Enemy")
                .SubscribeToAfterAllBuildEvent(delegate (CardData data)
                {
                    // Effect
                    data.traits = new List()
                    {
                        TStack("Hunter", 1)
                    };
                })
                );
            #endregion

            #region Kory
            assets.Add(
                new CardDataBuilder(this).CreateUnit("EnemyKory", "Kory")
                .SetSprites("Characters/Enemy_Dingo.png", "Backgrounds/Enemy_Dingo_Background.png")
                .SetStats(6)
                .WithCardType("Enemy")
                .SubscribeToAfterAllBuildEvent(delegate (CardData data)
                {
                    // Effect
                    data.startWithEffects = new CardData.StatusEffectStacks[]
                    {
                        //SStack("When Sacrificed Apply Spice To Applier", 1)
                    };
                })
                );
            #endregion

            #endregion

            #region Items

            #region Old Hatchet
            assets.Add(
                new CardDataBuilder(this).CreateItem("hatchet", "Old Hatchet")
                .SetSprites("Items/WandererTribe_CardArt_Hatchet.png", "Backgrounds/WandererTribe_ItemBG_Hatchet.png")
                .SetDamage(3)
                .SubscribeToAfterAllBuildEvent(delegate (CardData data)
                {
                    // Prevent targeting Intangible
                    data.targetConstraints = data.targetConstraints.AddToArray(ScriptableObject.CreateInstance());

                    // Effect
                    data.startWithEffects = new CardData.StatusEffectStacks[]
                    {
                        SStack("Flimsy", 1)
                    };
                })
                );
            #endregion

            #region Frozen Fire
            assets.Add(
                new CardDataBuilder(this).CreateItem("frozenfire", "Frozen Fire")
                .SetSprites("Items/WandererTribe_CardArt_FrozenFire.png", "Backgrounds/WandererTribe_ItemBG_FrozenFire.png")
                .SetTraits(TStack("Aimless", 1))
                .SetStartWithEffect(SStack("MultiHit", 1))
                .SubscribeToAfterAllBuildEvent(delegate (CardData data)
                {
                    // Prevent targeting Intangible
                    data.targetConstraints = data.targetConstraints.AddToArray(ScriptableObject.CreateInstance());

                    // Effect
                    StatusEffectSnow snow = TryGet("Snow");
                    snow.targetConstraints.AddItem(ScriptableObject.CreateInstance());

                    data.attackEffects = new CardData.StatusEffectStacks[]
                    {
                        new CardData.StatusEffectStacks(snow, 2)
                    };
                })
                );
            #endregion

            #region Rations
            assets.Add(
                new CardDataBuilder(this).CreateItem("rations", "Rations")
                .SetSprites("Items/WandererTribe_CardArt_Rations.png", "Backgrounds/WandererTribe_ItemBG_Rations.png")
                .SetTraits(TStack("Aimless", 1))
                .SubscribeToAfterAllBuildEvent(delegate (CardData data)
                {
                    // Prevent targeting Intangible
                    data.targetConstraints = data.targetConstraints.AddToArray(ScriptableObject.CreateInstance());

                    // Effect
                    data.startWithEffects = new CardData.StatusEffectStacks[]
                    {
                        SStack("MultiHit", 3),
                        SStack("Reduce Frenzy On Use", 1)
                    };

                    StatusEffectInstantIncreaseMaxHealth increaseHealth = TryGet("Increase Max Health");

                    data.attackEffects = new CardData.StatusEffectStacks[]
                    {
                        new CardData.StatusEffectStacks(increaseHealth, 1)
                    };
                })
                );
            #endregion

            #region Playing Cards
            assets.Add(
                new CardDataBuilder(this).CreateItem("playingcards", "Playing Cards")
                .SetSprites("Items/WandererTribe_CardArt_PlayingCards.png", "Backgrounds/WandererTribe_ItemBG_PlayingCards.png")
                .SetTraits(TStack("Aimless", 1))
                .SubscribeToAfterAllBuildEvent(delegate (CardData data)
                {
                    // Prevent targeting Intangible
                    data.targetConstraints = data.targetConstraints.AddToArray(ScriptableObject.CreateInstance());

                    // Effect
                    data.startWithEffects = new CardData.StatusEffectStacks[]
                    {
                        SStack("MultiHit", 1)
                    };

                    StatusEffectInstantIncreaseAttack increaseAttack = TryGet("Increase Attack");
                    increaseAttack.targetConstraints.AddItem(ScriptableObject.CreateInstance());

                    data.attackEffects = new CardData.StatusEffectStacks[]
                    {
                        new CardData.StatusEffectStacks(increaseAttack, 1)
                    };
                })
                );
            #endregion

            #region Sewing Kit
            assets.Add(CardCopy("FallowMask", "sewingkit")
                .WithTitle("Sewing Kit")
                .SetSprites("Items/WandererTribe_CardArt_SewingKit.png", "Backgrounds/WandererTribe_ItemBG_SewingKit.png")
                .SubscribeToAfterAllBuildEvent(delegate (CardData data)
                {
                    // Effect
                    data.startWithEffects = new CardData.StatusEffectStacks[]
                    {
                        SStack("Summon Plush Monster", 1)
                    };
                })
                );
            #endregion

            #region Whiskey
            assets.Add(CardCopy("EyeDrops", "Whiskey")
                .WithTitle("Whiskey")
                .SetSprites("Items/WandererTribe_CardArt_Whiskey.png", "Backgrounds/WandererTribe_ItemBG_Whiskey.png")
                .WithValue(50)
                .SetAttackEffect(SStack("Increase Attack", 5), SStack("Instant Gain Aimless", 1))
                .SetTraits(TStack("Consume", 1))
                .SubscribeToAfterAllBuildEvent(delegate (CardData data)
                {
                    // Prevent targeting Intangible
                    data.targetConstraints = data.targetConstraints.AddToArray(ScriptableObject.CreateInstance());
                })
                );
            #endregion

            #region Pack O' Smokes
            assets.Add(CardCopy("PinkberryJuice", "Smokes")
                .WithTitle("Pack O' Smokes")
                .SetSprites("Items/WandererTribe_CardArt_Smokes.png", "Backgrounds/WandererTribe_ItemBG_Smokes.png")
                .WithValue(40)
                .SetAttackEffect(SStack("Heal", 8))
                .SubscribeToAfterAllBuildEvent(delegate (CardData data)
                {
                    // Prevent targeting Intangible
                    data.targetConstraints = data.targetConstraints.AddToArray(ScriptableObject.CreateInstance());

                    // Effect
                    data.startWithEffects = new CardData.StatusEffectStacks[]
                    {
                        SStack("Reduce Effects To Self", 1)
                    };
                })
                );
            #endregion

            #region Painkillers
            assets.Add(new CardDataBuilder(this)
                .CreateItem("Painkillers", "Painkillers")
                .SetSprites("Items/WandererTribe_CardArt_Painkillers.png", "Backgrounds/WandererTribe_ItemBG_Painkillers.png")
                .WithValue(55)
                .SetAttackEffect(SStack("Block", 2))
                .SetTraits(TStack("Consume", 1))
                .SubscribeToAfterAllBuildEvent(delegate (CardData data)
                {
                    // Prevent targeting Intangible
                    data.targetConstraints = data.targetConstraints.AddToArray(ScriptableObject.CreateInstance());

                    // Hand allowed
                    data.canPlayOnHand = true;
                })
                );
            #endregion

            #region Confusing Map
            assets.Add(new CardDataBuilder(this)
                .CreateItem("ConfusingMap", "Confusing Map")
                .SetSprites("Items/WandererTribe_CardArt_ConfusingMap.png", "Backgrounds/WandererTribe_ItemBG_ConfusingMap.png")
                .WithValue(55)
                .NeedsTarget(false)
                .SetTraits(TStack("Consume", 1))
                .SubscribeToAfterAllBuildEvent(delegate (CardData data)
                {
                    data.canPlayOnBoard = false;
                    data.canPlayOnEnemy = false;
                    data.canPlayOnFriendly = false;

                    // Effect
                    data.startWithEffects = new CardData.StatusEffectStacks[] { SStack("On Card Played Add Noomlin To Random Card In Hand", 1), SStack("MultiHit", 1) };
                })
                );
            #endregion

            #region Soul Candy
            assets.Add(new CardDataBuilder(this)
                .CreateItem("SoulCandy", "Soul Candy")
                .SetSprites("Items/WandererTribe_CardArt_SoulCandy.png", "Backgrounds/WandererTribe_ItemBG_SoulCandy.png")
                .WithValue(45)
                .SetAttackEffect(SStack("Heal", 2))
                .SetTraits(TStack("Noomlin", 1))
                .SubscribeToAfterAllBuildEvent(delegate (CardData data)
                {
                    // Prevent targeting Intangible
                    data.targetConstraints = data.targetConstraints.AddToArray(ScriptableObject.CreateInstance());

                    // Hand allowed
                    data.canPlayOnHand = true;
                })
                );
            #endregion

            #region A Book
            assets.Add(new CardDataBuilder(this)
                .CreateItem("Book", "A Book")
                .SetSprites("Items/WandererTribe_CardArt_ABook.png", "Backgrounds/WandererTribe_ItemBG_ABook.png")
                .WithValue(40)
                .NeedsTarget(false)
                .SetTraits(TStack("Draw", 3))
                );
            #endregion

            #region Rage Brew
            assets.Add(new CardDataBuilder(this)
                .CreateItem("RageBrew", "Rage Brew")
                .SetSprites("Items/WandererTribe_CardArt_RageBrew.png", "Backgrounds/WandererTribe_ItemBG_RageBrew.png")
                .WithValue(50)
                .SetStats(null, 3)
                .SubscribeToAfterAllBuildEvent(delegate (CardData data)
                {
                    // Prevent targeting Intangible
                    data.targetConstraints = data.targetConstraints.AddToArray(ScriptableObject.CreateInstance());

                    data.attackEffects = new CardData.StatusEffectStacks[]
                    {
                        SStack("Double Attack Effect", 1),
                        SStack("Instant Gain Hunter", 1)
                    };
                })
                );
            #endregion

            #region Merciful Dagger
            assets.Add(new CardDataBuilder(this)
                .CreateItem("MercifulDagger", "Merciful Dagger")
                .SetSprites("Items/WandererTribe_CardArt_MercifulDagger.png", "Backgrounds/WandererTribe_ItemBG_MercifulDagger.png")
                .WithValue(50)
                .SetStats(null, 0)
                .CanPlayOnEnemy(false)
                .SubscribeToAfterAllBuildEvent(delegate (CardData data)
                {
                    // Prevent targeting Intangible
                    data.targetConstraints = data.targetConstraints.AddToArray(ScriptableObject.CreateInstance());

                    data.attackEffects = new CardData.StatusEffectStacks[]
                    {
                        SStack("Sacrifice Ally", 1),
                        SStack("Instant Apply Current Health And Attack To Front Ally", 1)
                    };

                    data.startWithEffects = new CardData.StatusEffectStacks[]
                    {
                        SStack("Flimsy", 1)
                    };
                })
                );
            #endregion

            #region Cutlass
            assets.Add(new CardDataBuilder(this)
                .CreateItem("Cutlass", "Cutlass")
                .SetSprites("Items/WandererTribe_CardArt_Cutlass.png", "Backgrounds/WandererTribe_ItemBG_Cutlass.png")
                .WithValue(45)
                .SetStats(null, 2)
                .SetTraits(TStack("Greed", 1))
                .SubscribeToAfterAllBuildEvent(delegate (CardData data)
                {
                    // Prevent targeting Intangible
                    data.targetConstraints = data.targetConstraints.AddToArray(ScriptableObject.CreateInstance());

                    data.startWithEffects = new CardData.StatusEffectStacks[]
                    {
                        SStack("On Hit Equal Gain Gold", 1)
                    };
                })
                );
            #endregion

            #region Worn Dice
            assets.Add(new CardDataBuilder(this)
                .CreateItem("WornDice", "Worn Dice")
                .SetSprites("Items/WandererTribe_CardArt_WornDice.png", "Backgrounds/WandererTribe_ItemBG_WornDice.png")
                .WithValue(40)
                .SetStartWithEffect(SStack("MultiHit", 1))
                .SubscribeToAfterAllBuildEvent(delegate (CardData data)
                {
                    // Prevent targeting Intangible
                    data.targetConstraints = data.targetConstraints.AddToArray(ScriptableObject.CreateInstance());

                    data.attackEffects = new CardData.StatusEffectStacks[]
                    {
                        SStack("On Card Played Random Damage", 1)
                    };
                })
                );
            #endregion

            #region Quill
            assets.Add(new CardDataBuilder(this)
                .CreateItem("Quill", "Quill")
                .SetSprites("Items/WandererTribe_CardArt_Quill.png", "Backgrounds/WandererTribe_ItemBG_Quill.png")
                .WithValue(50)
                .SetStats(null, 1)
                .SetAttackEffect(SStack("Null", 3))
                .SubscribeToAfterAllBuildEvent(delegate (CardData data)
                {
                    // Prevent targeting Intangible
                    data.targetConstraints = data.targetConstraints.AddToArray(ScriptableObject.CreateInstance());
                })
                );
            #endregion

            #region Foul Soup
            assets.Add(new CardDataBuilder(this)
                .CreateItem("FoulSoup", "Foul Soup")
                .SetSprites("Items/WandererTribe_CardArt_FoulSoup.png", "Backgrounds/WandererTribe_ItemBG_FoulSoup.png")
                .WithValue(60)
                .SetTraits(TStack("Aimless", 1))
                .SubscribeToAfterAllBuildEvent(delegate (CardData data)
                {
                    // Prevent targeting Intangible
                    data.targetConstraints = data.targetConstraints.AddToArray(ScriptableObject.CreateInstance());

                    // Effect
                    StatusEffectHaze haze = TryGet("Haze");
                    haze.targetConstraints.AddItem(ScriptableObject.CreateInstance());

                    data.attackEffects = new CardData.StatusEffectStacks[]
                    {
                        new CardData.StatusEffectStacks(haze, 1)
                    };
                })
                );
            #endregion

            #region Hunting Spear
            assets.Add(new CardDataBuilder(this)
                .CreateItem("HuntingSpear", "Hunting Spear")
                .SetSprites("Items/WandererTribe_CardArt_HuntingSpear.png", "Backgrounds/WandererTribe_ItemBG_HuntingSpear.png")
                .WithValue(40)
                .SetStats(null, 5)
                .SetStartWithEffect(SStack("On Kill Apply Attack To Self", 2))
                .SubscribeToAfterAllBuildEvent(delegate (CardData data)
                {
                    // Prevent targeting Intangible
                    data.targetConstraints = data.targetConstraints.AddToArray(ScriptableObject.CreateInstance());
                })
                );
            #endregion

            #region Thermal Tracker
            assets.Add(CardCopy("Leecher", "ThermalTracker")
                .WithTitle("Thermal Tracker")
                .SetSprites("Items/WandererTribe_CardArt_SewingKit.png", "Backgrounds/WandererTribe_ItemBG_SewingKit.png")
                .WithValue(50)
                .SubscribeToAfterAllBuildEvent(delegate (CardData data)
                {
                    data.traits.Clear();

                    data.startWithEffects = new CardData.StatusEffectStacks[]
                    {
                        SStack("Summon Enemy Innocent Monster", 1)
                    };
                })
                );
            #endregion

            #region Tom's Pickaxe
            assets.Add(new CardDataBuilder(this)
                .CreateItem("Pickaxe", "Tom's Pickaxe")
                .SetSprites("Items/WandererTribe_CardArt_TomsPickaxe.png", "Backgrounds/WandererTribe_ItemBG_TomsPickaxe.png")
                .WithValue(40)
                .SetStats(null, 3)
                .SetAttackEffect(SStack("Snow", 2))
                .SubscribeToAfterAllBuildEvent(delegate (CardData data)
                {
                    // Prevent targeting Intangible
                    data.targetConstraints = data.targetConstraints.AddToArray(ScriptableObject.CreateInstance());
                })
                );
            #endregion

            #region Volatile Vial
            assets.Add(new CardDataBuilder(this)
                .CreateItem("VolatileVial", "Volatile Vial")
                .SetSprites("Items/WandererTribe_CardArt_VolatileVial.png", "Backgrounds/WandererTribe_ItemBG_VolatileVial.png")
                .WithValue(50)
                .SetStats(null, 0)
                .SubscribeToAfterAllBuildEvent(delegate (CardData data)
                {
                    // Prevent targeting Intangible
                    data.targetConstraints = data.targetConstraints.AddToArray(ScriptableObject.CreateInstance());

                    data.startWithEffects = new CardData.StatusEffectStacks[]
                    {
                        SStack("Hex", 1)
                    };

                    data.traits.Add(TStack("Splash", 1));
                })
                );
            #endregion

            #region Barbed Wire
            assets.Add(new CardDataBuilder(this)
                .CreateItem("BarbedWire", "Barbed Wire")
                .SetSprites("Items/WandererTribe_CardArt_BarbedWire.png", "Backgrounds/WandererTribe_ItemBG_BarbedWire.png")
                .WithValue(45)
                .SetStats(null, 1)
                .SubscribeToAfterAllBuildEvent(delegate (CardData data)
                {
                    // Prevent targeting Intangible
                    data.targetConstraints = data.targetConstraints.AddToArray(ScriptableObject.CreateInstance());

                    data.attackEffects = new CardData.StatusEffectStacks[]
                    {
                        SStack("Teeth", 2)
                    };
                })
                );
            #endregion

            #region Sun-baked Cookies
            assets.Add(new CardDataBuilder(this)
                .CreateItem("SunCookies", "Sun-baked Cookies")
                .SetSprites("Items/WandererTribe_CardArt_SunBakedCookies.png", "Backgrounds/WandererTribe_ItemBG_SunBakedCookies.png")
                .WithValue(50)
                .SetAttackEffect(SStack("Reduce Counter", 1))
                .SetStartWithEffect(SStack("MultiHit", 1))
                .SetTraits(TStack("Combo", 1))
                .SubscribeToAfterAllBuildEvent(delegate (CardData data)
                {
                    // Prevent targeting Intangible
                    data.targetConstraints = data.targetConstraints.AddToArray(ScriptableObject.CreateInstance());
                })
                );
            #endregion

            #region Scythe Shard
            assets.Add(CardCopy("FallowMask", "ScytheShard")
                .WithTitle("Scythe Shard")
                .SetSprites("Items/WandererTribe_CardArt_SewingKit.png", "Backgrounds/WandererTribe_ItemBG_SewingKit.png")
                .WithValue(50)
                .SubscribeToAfterAllBuildEvent(delegate (CardData data)
                {
                    // Effect
                    data.startWithEffects = new CardData.StatusEffectStacks[]
                    {
                        SStack("Summon Frozen Corpse", 1)
                    };
                })
                );
            #endregion

            #region Paid Contract
            assets.Add(CardCopy("FallowMask", "PaidContract")
                .WithTitle("Paid Contract")
                .SetSprites("Items/WandererTribe_CardArt_SewingKit.png", "Backgrounds/WandererTribe_ItemBG_SewingKit.png")
                .WithValue(40)
                .SetTraits(TStack("Consume", 1))
                .SubscribeToAfterAllBuildEvent(delegate (CardData data)
                {
                    // Effect
                    data.startWithEffects = new CardData.StatusEffectStacks[]
                    {
                        SStack("Summon Random Wanderer Companion", 1)
                    };
                })
                );
            #endregion

            #region Paperwork
            assets.Add(new CardDataBuilder(this)
                .CreateItem("Paperwork", "Paperwork")
                .SetSprites("Items/WandererTribe_CardArt_SewingKit.png", "Backgrounds/WandererTribe_ItemBG_SewingKit.png")
                .SetStats(null, 1)
                .SetTraits(TStack("Consume", 1))
                .SubscribeToAfterAllBuildEvent(delegate (CardData data)
                {
                    // Prevent targeting Intangible
                    data.targetConstraints = data.targetConstraints.AddToArray(ScriptableObject.CreateInstance());

                    // Effect
                    data.startWithEffects = new CardData.StatusEffectStacks[]
                    {
                        SStack("Stackable", 1)
                    };
                })
                );
            #endregion

            #region Good Soup
            assets.Add(new CardDataBuilder(this)
                .CreateItem("GoodSoup", "Good Soup")
                .SetSprites("Items/WandererTribe_CardArt_GoodSoup.png", "Backgrounds/WandererTribe_ItemBG_GoodSoup.png")
                .WithValue(55)
                .SetTraits(TStack("Consume", 1))
                .SubscribeToAfterAllBuildEvent(delegate (CardData data)
                {
                    // Prevent targeting Intangible
                    data.targetConstraints = data.targetConstraints.AddToArray(ScriptableObject.CreateInstance());

                    // Hand allowed
                    data.canPlayOnHand = true;

                    // Effect
                    data.attackEffects = new CardData.StatusEffectStacks[]
                    {
                        SStack("On Card Played Apply Spice Equal To Health", 1)
                    };
                })
                );
            #endregion

            #region BOMB
            assets.Add(new CardDataBuilder(this)
                .CreateItem("Bomb", "BOMB")
                .SetSprites("Items/WandererTribe_CardArt_BOMB.png", "Backgrounds/WandererTribe_ItemBG_BOMB.png")
                .WithValue(50)
                .SetStats(null, 2)
                .SubscribeToAfterAllBuildEvent(delegate (CardData data)
                {
                    // Prevent targeting Intangible
                    data.targetConstraints = data.targetConstraints.AddToArray(ScriptableObject.CreateInstance());

                    // Effect
                    data.attackEffects = new CardData.StatusEffectStacks[]
                    {
                        SStack("On Hit Gain Gold", 1)
                    };

                    data.traits.Add(TStack("Splash", 1));
                })
                );
            #endregion

            #region Religious Text
            assets.Add(new CardDataBuilder(this)
                .CreateItem("ReligiousText", "Religious Text")
                .SetSprites("Items/WandererTribe_CardArt_ReligiousText.png", "Backgrounds/WandererTribe_ItemBG_ReligiousText.png")
                .WithValue(55)
                .SetStats(null, 0)
                .SetAttackEffect(SStack("Demonize", 1))
                .SetStartWithEffect(SStack("Hit All Enemies", 1))
                .SubscribeToAfterAllBuildEvent(delegate (CardData data)
                {
                    // Prevent targeting Intangible
                    data.targetConstraints = data.targetConstraints.AddToArray(ScriptableObject.CreateInstance());
                })
                );
            #endregion

            #region Otherworldly Feather
            assets.Add(new CardDataBuilder(this)
                .CreateItem("OtherworldlyFeather", "Otherworldly Feather")
                .SetSprites("Items/WandererTribe_CardArt_OtherworldFeather.png", "Backgrounds/WandererTribe_ItemBG_OtherworldFeather.png")
                .WithValue(50)
                .SetAttackEffect(SStack("Overload", 3))
                .SubscribeToAfterAllBuildEvent(delegate (CardData data)
                {
                    // Prevent targeting Intangible
                    data.targetConstraints = data.targetConstraints.AddToArray(ScriptableObject.CreateInstance());

                    // Effect
                    data.startWithEffects = new CardData.StatusEffectStacks[]
                    {
                        SStack("On Card Played Boost To Self", 1)
                    };
                })
                );
            #endregion

            #region Haunted Sword
            assets.Add(new CardDataBuilder(this)
                .CreateItem("HauntedSword", "Haunted Sword")
                .SetSprites("Items/WandererTribe_CardArt_HauntedSword.png", "Backgrounds/WandererTribe_ItemBG_HauntedSword.png")
                .WithValue(50)
                .SetStats(null, 0)
                .SubscribeToAfterAllBuildEvent(delegate (CardData data)
                {
                    // Prevent targeting Intangible
                    data.targetConstraints = data.targetConstraints.AddToArray(ScriptableObject.CreateInstance());

                    // Effect
                    data.startWithEffects = new CardData.StatusEffectStacks[]
                    {
                        SStack("On Hit Apply Overload Equal To Target Attack", 1)
                    };
                })
                );
            #endregion

            #region Assorted Peppers
            assets.Add(new CardDataBuilder(this)
                .CreateItem("AssortedPeppers", "Assorted Peppers")
                .SetSprites("Items/WandererTribe_CardArt_AssortedPeppers.png", "Backgrounds/WandererTribe_ItemBG_AssortedPeppers.png")
                .WithValue(45)
                .SetAttackEffect(SStack("Spice", 2))
                .SetStartWithEffect(SStack("MultiHit", 2))
                .SetTraits(TStack("Aimless", 1))
                .SubscribeToAfterAllBuildEvent(delegate (CardData data)
                {
                    // Prevent targeting Intangible
                    data.targetConstraints = data.targetConstraints.AddToArray(ScriptableObject.CreateInstance());
                })
                );
            #endregion

            #region Foraging Basket
            assets.Add(new CardDataBuilder(this)
                .CreateItem("ForagingBasket", "Foraging Basket")
                .SetSprites("Items/WandererTribe_CardArt_ForagingBasket.png", "Backgrounds/WandererTribe_CardArt_ForagingBasket.png")
                .WithValue(50)
                .SubscribeToAfterAllBuildEvent(delegate (CardData data)
                {
                    // Prevent targeting Intangible
                    data.targetConstraints = data.targetConstraints.AddToArray(ScriptableObject.CreateInstance());

                    // Effect
                    data.attackEffects = new CardData.StatusEffectStacks[]
                    {
                        SStack("Apply Shroom Equal To Ally Count", 1)
                    };
                })
                );
            #endregion

            #region Spoiled Rations
            assets.Add(
                new CardDataBuilder(this).CreateItem("SpoiledRations", "Spoiled Rations")
                .SetSprites("Items/WandererTribe_CardArt_SpoiledRations.png", "Backgrounds/WandererTribe_ItemBG_SpoiledRations.png")
                .WithValue(50)
                .SetAttackEffect(SStack("Shroom", 2))
                .SetTraits(TStack("Aimless", 1))
                .SubscribeToAfterAllBuildEvent(delegate (CardData data)
                {
                    // Prevent targeting Intangible
                    data.targetConstraints = data.targetConstraints.AddToArray(ScriptableObject.CreateInstance());

                    // Effect
                    data.startWithEffects = new CardData.StatusEffectStacks[]
                    {
                        SStack("MultiHit", 3),
                        SStack("Reduce Frenzy On Use", 1)
                    };
                })
                );
            #endregion

            #region Tiny Snowman
            assets.Add(
                new CardDataBuilder(this).CreateItem("TinySnowman", "Tiny Snowman")
                .SetSprites("Items/WandererTribe_CardArt_TinySnowman.png", "Backgrounds/WandererTribe_ItemBG_TinySnowman.png")
                .SetAttackEffect(SStack("Snow", 1))
                .SetTraits(TStack("Zoomlin", 1))
                .SubscribeToAfterAllBuildEvent(delegate (CardData data)
                {
                    // Prevent targeting Intangible
                    data.targetConstraints = data.targetConstraints.AddToArray(ScriptableObject.CreateInstance());

                    // Effect
                    data.startWithEffects = new CardData.StatusEffectStacks[]
                    {
                        SStack("On Card Played Add Tiny Snowman To Hand", 1),
                        SStack("Stackable", 1)
                    };
                })
                );
            #endregion

            #region Massive Snowflake
            assets.Add(
                new CardDataBuilder(this).CreateItem("MassiveSnowflake", "Massive Snowflake")
                .SetSprites("Items/WandererTribe_CardArt_MassiveSnowflake.png", "Backgrounds/WandererTribe_ItemBG_MassiveSnowflake.png")
                .WithValue(60)
                .SetStats(null, 0)
                .SetAttackEffect(SStack("Snow", 1))
                .SubscribeToAfterAllBuildEvent(delegate (CardData data)
                {
                    // Prevent targeting Intangible
                    data.targetConstraints = data.targetConstraints.AddToArray(ScriptableObject.CreateInstance());

                    // Effect
                    data.startWithEffects = new CardData.StatusEffectStacks[]
                    {
                        SStack("Flimsy", 1),
                        SStack("Hit All Enemies", 1)
                    };
                })
                );
            #endregion

            #region Bottled Dream
            assets.Add(CardCopy("FallowMask", "BottledDream")
                .WithTitle("Bottled Dream")
                .SetSprites("Items/WandererTribe_CardArt_SewingKit.png", "Backgrounds/WandererTribe_ItemBG_SewingKit.png")
                .WithValue(50)
                .SetTraits(TStack("Consume", 1))
                .SubscribeToAfterAllBuildEvent(delegate (CardData data)
                {
                    // Effect
                    data.startWithEffects = new CardData.StatusEffectStacks[]
                    {
                        SStack("Summon Nightmare", 1)
                    };
                })
                );
            #endregion

            #region Tasty Page
            assets.Add(CardCopy("FallowMask", "TastyPage")
                .WithTitle("Tasty Page")
                .SetSprites("Items/WandererTribe_CardArt_SewingKit.png", "Backgrounds/WandererTribe_ItemBG_SewingKit.png")
                .WithValue(50)
                .SubscribeToAfterAllBuildEvent(delegate (CardData data)
                {
                    // Effect
                    data.startWithEffects = new CardData.StatusEffectStacks[]
                    {
                        SStack("Summon Knowledge Gremlin", 1)
                    };
                })
                );
            #endregion

            #region Cursed Scythe
            assets.Add(new CardDataBuilder(this)
                .CreateItem("CursedScythe", "Cursed Scythe")
                .SetSprites("Items/WandererTribe_CardArt_CursedScythe.png", "Backgrounds/WandererTribe_ItemBG_CursedScythe.png")
                .SetStats(null, 10)
                .WithValue(50)
                .SubscribeToAfterAllBuildEvent(delegate (CardData data)
                {
                    // Prevent targeting Intangible
                    data.targetConstraints = data.targetConstraints.AddToArray(ScriptableObject.CreateInstance());

                    // Effect
                    data.attackEffects = new CardData.StatusEffectStacks[]
                    {
                        SStack("Instant Apply Hex To Random Ally", 1)
                    };

                    data.startWithEffects = new CardData.StatusEffectStacks[]
                    {
                        SStack("On Card Played Boost To Self", 1)
                    };
                })
                );
            #endregion

            #region Cage
            assets.Add(CardCopy("FallowMask", "Cage")
                .WithTitle("Cage")
                .SetSprites("Items/WandererTribe_CardArt_SewingKit.png", "Backgrounds/WandererTribe_ItemBG_SewingKit.png")
                .WithValue(50)
                .SubscribeToAfterAllBuildEvent(delegate (CardData data)
                {
                    // Effect
                    data.startWithEffects = new CardData.StatusEffectStacks[]
                    {
                        SStack("Summon Savage Beast", 1),
                        SStack("Gain Zoomlin When Redraw Charges", 1)
                    };
                })
                );
            #endregion

            #region Blood Trail
            assets.Add(CardCopy("FallowMask", "BloodTrail")
                .WithTitle("Blood Trail")
                .SetSprites("Items/WandererTribe_CardArt_SewingKit.png", "Backgrounds/WandererTribe_ItemBG_SewingKit.png")
                .WithValue(55)
                .SetTraits(TStack("Consume", 1))
                .SubscribeToAfterAllBuildEvent(delegate (CardData data)
                {
                    // Effect
                    data.startWithEffects = new CardData.StatusEffectStacks[]
                    {
                        SStack("Summon Ravenous Creature", 1)
                    };
                })
                );
            #endregion

            #region Faint Shadow
            assets.Add(CardCopy("FallowMask", "FaintShadow")
                .WithTitle("Faint Shadow")
                .SetSprites("Items/WandererTribe_CardArt_FaintShadow.png", "Backgrounds/WandererTribe_ItemBG_FaintShadow.png")
                .WithValue(65)
                .SetTraits(TStack("Consume", 1))
                .SubscribeToAfterAllBuildEvent(delegate (CardData data)
                {
                    // Effect
                    data.startWithEffects = new CardData.StatusEffectStacks[]
                    {
                        SStack("Summon Other Leaders", 1)
                    };
                })
                );
            #endregion

            #region Snake Oil
            assets.Add(new CardDataBuilder(this)
                .CreateItem("SnakeOil", "Snake Oil")
                .SetSprites("Items/WandererTribe_CardArt_SnakeOil.png", "Backgrounds/WandererTribe_ItemBG_SnakeOil.png")
                .WithValue(60)
                .SetTraits(TStack("Consume", 1))
                .SubscribeToAfterAllBuildEvent(delegate (CardData data)
                {
                    // Prevent targeting Intangible
                    data.targetConstraints = data.targetConstraints.AddToArray(ScriptableObject.CreateInstance());

                    // Hand allowed
                    data.canPlayOnHand = true;

                    // Effect
                    data.attackEffects = new CardData.StatusEffectStacks[]
                    {
                        SStack("MultiHit", 1),
                        SStack("Reduce Max Health", 3)
                    };
                })
                );
            #endregion

            #region Soothing Tea
            assets.Add(new CardDataBuilder(this)
                .CreateItem("SoothingTea", "Soothing Tea")
                .SetSprites("Items/WandererTribe_CardArt_SoothingTea.png", "Backgrounds/WandererTribe_ItemBG_SoothingTea.png")
                .WithValue(50)
                .SetTraits(TStack("Consume", 1))
                .SubscribeToAfterAllBuildEvent(delegate (CardData data)
                {
                    // Prevent targeting Intangible
                    data.targetConstraints = data.targetConstraints.AddToArray(ScriptableObject.CreateInstance());

                    // Hand allowed
                    data.canPlayOnHand = true;

                    data.attackEffects = new CardData.StatusEffectStacks[]
                    {
                        SStack("Increase Max Health", 8)
                    };
                })
                );
            #endregion

            #endregion

            #region Charms

            #region Predator Charm
            assets.Add(new CardUpgradeDataBuilder(this)
                .Create("CardUpgradeHunter")
                .WithType(CardUpgradeData.Type.Charm)
                .WithImage("Sprites/hex_icon.png")
                .WithTitle("Predator Charm")
                .WithText($"Gain ")
                .WithTier(1)
                .SubscribeToAfterAllBuildEvent(delegate (CardUpgradeData data)
                {
                    // Effect
                    data.giveTraits = new CardData.TraitStacks[]
                    {
                        TStack("Hunter", 1)
                    };

                    // Constraints
                    data.targetConstraints = new TargetConstraint[]
                    {
                        TryGetConstraint("Does Not Have Aimless"),
                        TryGetConstraint("Does Not Have Barrage"),
                        TryGetConstraint("Does Not Have Longshot"),
                        TryGetConstraint("Is Unit"),
                        TryGetConstraint("Does Attack"),
                        TryGetConstraint("Does Not Have Hit All Enemies")
                    };
                })
                );
            #endregion

            #region Grotesque Charm
            assets.Add(new CardUpgradeDataBuilder(this)
                .Create("CardUpgradeScavenger")
                .WithType(CardUpgradeData.Type.Charm)
                .WithImage("Sprites/hex_icon.png")
                .WithTitle("Grotesque Charm")
                .WithText($"Gain  <1>")
                .WithTier(3)
                .SubscribeToAfterAllBuildEvent(delegate (CardUpgradeData data)
                {
                    // Effect
                    data.giveTraits = new CardData.TraitStacks[]
                    {
                        TStack("Scavenger", 1)
                    };

                    // Constraints
                    data.targetConstraints = new TargetConstraint[]
                    {
                        TryGetConstraint("Is Unit"),
                        TryGetConstraint("Has Health"),
                        TryGetConstraint("Does Damage")
                    };
                })
                );
            #endregion

            #region Bewitching Charm
            assets.Add(new CardUpgradeDataBuilder(this)
                .Create("CardUpgradeHex")
                .WithType(CardUpgradeData.Type.Charm)
                .WithImage("Sprites/hex_icon.png")
                .WithTitle("Bewitching Charm")
                .WithText($"Apply <1> ")
                .WithTier(2)
                .SubscribeToAfterAllBuildEvent(delegate (CardUpgradeData data)
                {
                    // Effect
                    data.effects = new CardData.StatusEffectStacks[]
                    {
                        SStack("Hex", 1)
                    };

                    // Constraints
                    data.targetConstraints = new TargetConstraint[]
                    {
                        TryGetConstraint("Does Trigger"),
                        TryGetConstraint("Does Not Play On Slot"),
                        TryGetConstraint("Plays On Board")
                    };
                })
                );
            #endregion

            #region ??? Charm
            assets.Add(new CardUpgradeDataBuilder(this)
                .Create("CardUpgradeSplash")
                .WithType(CardUpgradeData.Type.Charm)
                .WithImage("Sprites/hex_icon.png")
                .WithTitle("[Unnamed] Charm")
                .WithText($"Gain ")
                .WithTier(3)
                .SubscribeToAfterAllBuildEvent(delegate (CardUpgradeData data)
                {
                    // Effect
                    data.giveTraits = new CardData.TraitStacks[]
                    {
                        TStack("Splash", 1)
                    };

                    // Constraints
                    data.targetConstraints = new TargetConstraint[]
                    {
                        TryGetConstraint("Does Not Have Aimless"),
                        TryGetConstraint("Does Not Have Barrage"),
                        TryGetConstraint("Does Not Have Longshot"),
                        TryGetConstraint("Is Unit Or Needs Target"),
                        TryGetConstraint("Does Attack"),
                        TryGetConstraint("Plays On Board"),
                        TryGetConstraint("Does Not Play On Slot"),
                        TryGetConstraint("Does Not Have Instant Summon Copy"),
                        TryGetConstraint("Does Not Have Instant Summon Copy Of Enemy"),
                        TryGetConstraint("Does Not Have Sacrifice Ally"),
                        TryGetConstraint("Does Not Have Hit All Enemies")
                    };
                })
                );
            #endregion

            #region ??? Charm
            assets.Add(new CardUpgradeDataBuilder(this)
                .Create("CardUpgradeAdaptive")
                .WithType(CardUpgradeData.Type.Charm)
                .WithImage("Sprites/hex_icon.png")
                .WithTitle("[Unnamed] Charm")
                .WithText($"Gain ")
                .WithTier(3)
                .SubscribeToAfterAllBuildEvent(delegate (CardUpgradeData data)
                {
                    // Effect
                    data.effects = new CardData.StatusEffectStacks[]
                    {
                        SStack("Adaptive", 1)
                    };

                    // Constraints
                    data.targetConstraints = new TargetConstraint[]
                    {
                        TryGetConstraint("Does Not Have Aimless"),
                        TryGetConstraint("Does Trigger"),
                        TryGetConstraint("Is Unit"),
                        TryGetConstraint("Does Attack")
                    };
                })
                );
            #endregion

            #endregion

            #region Keywords

            #region Hex
            assets.Add(
                new KeywordDataBuilder(this)
                .Create("hex")
                .WithTitle("Hex")
                .WithTitleColour(new Color(0.85f, 0.44f, 0.85f))
                .WithShowName(false)
                .WithDescription("Apply a random debuff|Debuffs are Bom, Demonize, Frost, Haze, Ink, Overburn, Shroom, and Snow")
                .WithNoteColour(new Color(0.85f, 0.44f, 0.85f))
                .WithBodyColour(new Color(1f, 1f, 1f))
                .WithIconName("hexicon")
                .WithCanStack(true)
                );
            #endregion

            #region Splash
            assets.Add(
                new KeywordDataBuilder(this)
                .Create("splash")
                .WithTitle("Splash")
                .WithTitleColour(new Color(1f, 0.79f, 0.34f))
                .WithShowName(true)
                .WithDescription("Hits adjacent targets")
                .WithBodyColour(new Color(1f, 1f, 1f))
                .WithCanStack(false)
                );
            #endregion

            #region Flimsy
            assets.Add(
                new KeywordDataBuilder(this)
                .Create("flimsy")
                .WithTitle("Flimsy")
                .WithTitleColour(new Color(0.5f, 0.5f, 0.5f))
                .WithShowName(true)
                .WithDescription("50% chance to  on use")
                .WithBodyColour(new Color(1f, 1f, 1f))
                .WithCanStack(false)
                );
            #endregion

            #region Mimic
            assets.Add(
                new KeywordDataBuilder(this)
                .Create("mimic")
                .WithTitle("Mimic")
                .WithTitleColour(new Color(1f, 0.79f, 0.34f))
                .WithShowName(true)
                .WithDescription("Copy the effects of the enemy hit|Effects last until new effects are copied")
                .WithBodyColour(new Color(1f, 1f, 1f))
                .WithNoteColour(new Color(1f, 0.79f, 0.34f))
                .WithCanStack(false)
                );
            #endregion

            #region Adaptive
            assets.Add(
                new KeywordDataBuilder(this)
                .Create("adaptive")
                .WithTitle("Adaptive")
                .WithTitleColour(new Color(1f, 0.79f, 0.34f))
                .WithShowName(true)
                .WithDescription($"Gain  when placed in front\nGain  when placed in middle\nGain  when placed in back")
                .WithBodyColour(new Color(1f, 1f, 1f))
                .WithCanStack(false)
                );
            #endregion

            #region Scavenger
            assets.Add(
                new KeywordDataBuilder(this)
                .Create("scavenger")
                .WithTitle("Scavenger")
                .WithTitleColour(new Color(0.6f, 0.1f, 0.1f))
                .WithShowName(true)
                .WithDescription("When an ally dies, gain  and ")
                .WithBodyColour(new Color(1f, 1f, 1f))
                .WithCanStack(true)
                );
            #endregion

            #region Lion
            assets.Add(
                new KeywordDataBuilder(this)
                .Create("lion")
                .WithTitle("Lion")
                .WithTitleColour(new Color(1f, 0.79f, 0.34f))
                .WithShowName(true)
                .WithDescription($"Lions are  allies that include , , and ")
                .WithBodyColour(new Color(1f, 1f, 1f))
                .WithCanStack(false)
                );
            #endregion

            #region Hunter
            assets.Add(
                new KeywordDataBuilder(this)
                .Create("hunter")
                .WithTitle("Hunter")
                .WithTitleColour(new Color(1f, 0.79f, 0.34f))
                .WithShowName(true)
                .WithDescription("Always hits the lowest  enemy in the row")
                .WithBodyColour(new Color(1f, 1f, 1f))
                .WithCanStack(false)
                );
            #endregion

            #region Execute
            assets.Add(
                new KeywordDataBuilder(this)
                .Create("execute")
                .WithTitle("Execute")
                .WithTitleColour(new Color(0.75f, 0f, 0f))
                .WithShowName(true)
                .WithDescription("Kills the target|Does not work against Clunkers")
                .WithBodyColour(new Color(1f, 1f, 1f))
                .WithNoteColour(new Color(0.75f, 0f, 0f))
                .WithCanStack(false)
                );
            #endregion

            #region Secretary
            assets.Add(
                new KeywordDataBuilder(this)
                .Create("secretary")
                .WithTitle("Secretary")
                .WithTitleColour(new Color(1f, 0.79f, 0.34f))
                .WithShowName(true)
                .WithDescription($"Add  to your hand")
                .WithBodyColour(new Color(1f, 1f, 1f))
                .WithCanStack(true)
                );
            #endregion

            #region Stackable
            assets.Add(
                new KeywordDataBuilder(this)
                .Create("stackable")
                .WithTitle("Stackable")
                .WithTitleColour(new Color(1f, 0.79f, 0.34f))
                .WithShowName(true)
                .WithDescription("When another copy of this card is created while it is in your hand, combine the card and the copy together")
                .WithBodyColour(new Color(1f, 1f, 1f))
                );
            #endregion

            #region Bloodlust
            assets.Add(
                new KeywordDataBuilder(this)
                .Create("bloodlust")
                .WithTitle("Bloodlust")
                .WithTitleColour(new Color(1f, 0f, 0f))
                .WithShowName(true)
                .WithDescription("Gain   on kill\nLose   after attack ends")
                .WithBodyColour(new Color(1f, 1f, 1f))
                .WithCanStack(false)
                );
            #endregion

            #region Eclipse
            assets.Add(
                new KeywordDataBuilder(this)
                .Create("eclipse")
                .WithTitle("Eclipse")
                .WithTitleColour(new Color(0.5f, 0.5f, 0.5f))
                .WithShowName(true)
                .WithDescription("Counts up the target's  and counts down  by the same amount")
                .WithCanStack(true)
                );
            #endregion

            #region Intangible
            assets.Add(
                new KeywordDataBuilder(this)
                .Create("intangible")
                .WithTitle("Intangible")
                .WithDescription("Cannot be hit")
                .WithTitleColour(new Color(0.5f, 1f, 0.66f))
                .WithShowName(true)
                );
            #endregion

            #region Nocturnal
            assets.Add(
                new KeywordDataBuilder(this)
                .Create("nocturnal")
                .WithTitle("Nocturnal")
                .WithDescription("Unaffected by count down  and trigger effects")
                .WithTitleColour(new Color(0.5f, 0.5f, 0.5f))
                .WithShowName(true)
                );
            #endregion

            #region Consumed
            assets.Add(
                new KeywordDataBuilder(this)
                .Create("consumed")
                .WithTitle("Consumed")
                .WithDescription("The condition when a card with  is played")
                .WithShowName(true)
                );
            #endregion

            #region Lions
            assets.Add(
                new KeywordDataBuilder(this)
                .Create("lions")
                .WithTitle("Lions")
                .WithTitleColour(new Color(1f, 0.79f, 0.34f))
                .WithShowName(true)
                .WithDescription($"Lions are  allies that include , , and ")
                .WithBodyColour(new Color(1f, 1f, 1f))
                .WithCanStack(false)
                );
            #endregion

            #region Consumable
            assets.Add(
                new KeywordDataBuilder(this)
                .Create("consumable")
                .WithTitle("Consumable")
                .WithDescription(" when placed")
                .WithShowName(true)
                );
            #endregion

            #region Bless
            assets.Add(
                new KeywordDataBuilder(this)
                .Create("bless")
                .WithTitle("Bless")
                .WithTitleColour(new Color(1f, 1f, 0.7f))
                .WithShowName(false)
                .WithDescription("Apply a random buff|Buffs are Block, Shell, Spice, and Teeth")
                .WithNoteColour(new Color(1f, 1f, 0.7f))
                .WithBodyColour(new Color(1f, 1f, 1f))
                .WithIconName("hexicon")
                .WithCanStack(true)
                );
            #endregion

            #endregion

            #region Traits

            #region Hunter Trait
            assets.Add(new TraitDataBuilder(this)
                .Create("Hunter")
                .SubscribeToAfterAllBuildEvent(delegate (TraitData data)
                {
                    data.keyword = TryGet("hunter");
                    data.overrides = new TraitData[] { TryGet("Aimless"), TryGet("Longshot"), TryGet("Barrage"), TryGet("Splash") };
                    data.effects = new StatusEffectData[] { TryGet("Hit Lowest Health Enemy In Row") };
                })
                );
            #endregion

            #region Splash Trait
            assets.Add(new TraitDataBuilder(this)
                .Create("Splash")
                .SubscribeToAfterAllBuildEvent(delegate (TraitData data)
                {
                    data.keyword = TryGet("splash");
                    data.overrides = new TraitData[] { TryGet("Aimless"), TryGet("Longshot"), TryGet("Barrage"), TryGet("Hunter") };
                    data.effects = new StatusEffectData[] { TryGet("Hit Adjacent Enemies")};
                })
                );
            #endregion

            #region Scavenger Trait
            assets.Add(new TraitDataBuilder(this)
                .Create("Scavenger")
                .SubscribeToAfterAllBuildEvent(delegate (TraitData data)
                {
                    data.keyword = TryGet("scavenger");
                    data.effects = new StatusEffectData[] { TryGet("When Ally Is Killed Gain Attack And Health") };
                })
                );
            #endregion

            #endregion

            #region Effects

            #region Keyword Effects

            #region Hex Effect
            assets.Add(StatusCopy("Snow","Hex")
                .Create("Hex")
                .WithCanBeBoosted(true)
                .WithText("Apply <{a}> ")
                .WithType("")
                .FreeModify(delegate (StatusEffectApplyRandom data)
                {
                    string[] effects = {
                        "Weakness",
                        "Demonize",
                        "Frost",
                        "Haze",
                        "Null",
                        "Overload",
                        "Shroom",
                        "Snow"
                    };

                    data.effectsToApply = effects;

                    ((StatusEffectApplyX)data).applyToFlags = StatusEffectApplyX.ApplyToFlags.Target;
                })
                );
            #endregion

            #region Flimsy Effect
            assets.Add(StatusCopy("Destroy After Use", "Flimsy")
                .Create("Flimsy")
                .WithCanBeBoosted(false)
                .WithText($"")
                .WithType("")
                );
            #endregion

            #region Mimic Effect
            assets.Add(new StatusEffectDataBuilder(this)
                .Create("On Card Played Copy Effects")
                .WithCanBeBoosted(false)
                .WithText($"")
                .SubscribeToAfterAllBuildEvent(delegate (StatusEffectData data)
                {
                    ((StatusEffectApplyX)data).queue = true;
                    ((StatusEffectApplyX)data).applyToFlags = StatusEffectApplyX.ApplyToFlags.Target;
                    ((StatusEffectApplyX)data).effectToApply = TryGet("Copy Effects Repeatable");
                })
                );
            #endregion

            #region Mimic's Indirect Effect
            assets.Add(
                new StatusEffectDataBuilder(this)
                .Create("Copy Effects Repeatable")
                .WithCanBeBoosted(true)
                );
            #endregion

            #region Adaptive Effect
            assets.Add(new StatusEffectDataBuilder(this)
                .Create("Adaptive")
                .WithCanBeBoosted(false)
                .WithText($"")
                .SubscribeToAfterAllBuildEvent(delegate (StatusEffectData data)
                {
                    ((StatusEffectApplyXOnMove)data).traitsToApply = new TraitData[] { TryGet("Smackback"), TryGet("Hunter"), TryGet("Longshot") };
                    ((StatusEffectApplyX)data).applyToFlags = StatusEffectApplyX.ApplyToFlags.Self;
                })
                );
            #endregion

            #region Scavenger Effect
            assets.Add(new StatusEffectDataBuilder(this)
                .Create("When Ally Is Killed Gain Attack And Health")
                .WithCanBeBoosted(true)
                .WithStackable(true)
                .SubscribeToAfterAllBuildEvent(delegate (StatusEffectData data)
                {
                    ((StatusEffectApplyX)data).applyToFlags = StatusEffectApplyX.ApplyToFlags.Self;
                    ((StatusEffectApplyX)data).effectToApply = TryGet("Increase Attack & Health");
                })
                );
            #endregion

            #region Execute Effect
            assets.Add(new StatusEffectDataBuilder(this)
                .Create("Instant Kill")
                .WithText($"")
                .SubscribeToAfterAllBuildEvent(delegate (StatusEffectData data)
                {
                    TargetConstraintHasStatus notScrap = ScriptableObject.CreateInstance();
                    notScrap.status = TryGet("Scrap");
                    notScrap.not = true;
                    ((StatusEffectInstantExecute)data).killConstraints = new TargetConstraint[] { notScrap };
                })
                );
            #endregion

            #region Hunter Effect
            assets.Add(new StatusEffectDataBuilder(this)
                .Create("Hit Lowest Health Enemy In Row")
                .WithCanBeBoosted(false)
                .SubscribeToAfterAllBuildEvent(delegate (StatusEffectData data)
                {
                    ((StatusEffectChangeTargetMode)data).targetMode = ScriptableObject.CreateInstance();
                })
                );
            #endregion

            #region Splash Effect
            assets.Add(new StatusEffectDataBuilder(this)
                .Create("Hit Adjacent Enemies")
                .WithCanBeBoosted(false)
                .SubscribeToAfterAllBuildEvent(delegate (StatusEffectData data)
                {
                    ((StatusEffectChangeTargetMode)data).targetMode = ScriptableObject.CreateInstance();
                })
                );
            #endregion

            #region Secretary Effect
            assets.Add(StatusCopy("On Card Played Add Junk To Hand", "On Card Played Add Paperwork To Hand")
                .WithText(" <{a}>")
                .SubscribeToAfterAllBuildEvent(delegate (StatusEffectData data)
                {
                    ((StatusEffectApplyX)data).effectToApply = TryGet("Instant Summon Paperwork In Hand");
                })
                );
            #endregion

            #region Secretary Indirect Effect
            assets.Add(new StatusEffectDataBuilder(this)
                .Create("Instant Summon Paperwork In Hand")
                .WithCanBeBoosted(true)
                .WithStackable(false)
                .SubscribeToAfterAllBuildEvent(delegate (StatusEffectData data)
                {
                    ((StatusEffectInstantSummonStackable)data).targetSummon = TryGet("Summon Paperwork");
                    ((StatusEffectInstantSummonStackable)data).summonPosition = StatusEffectInstantSummon.Position.Hand;
                })
                );
            #endregion

            #region Secretary Indirect Effect 2
            assets.Add(StatusCopy("Summon Junk", "Summon Paperwork")
                .WithCanBeBoosted(true)
                .SubscribeToAfterAllBuildEvent(delegate (StatusEffectData data)
                {
                    ((StatusEffectSummon)data).summonCard = TryGet("Paperwork");
                })
                );
            #endregion

            #region Stackable Effect
            assets.Add(new StatusEffectDataBuilder(this)
                .Create("Stackable")
                .WithText($"")
                .WithStackable(false)
                .SubscribeToAfterAllBuildEvent(delegate (StatusEffectData data)
                {
                    ((StatusEffectOngoingEffects)data).add = false;
                })
                );
            #endregion

            #region Bloodlust Effect
            assets.Add(
                new StatusEffectDataBuilder(this)
                .Create("Bloodlust")
                .WithText($"")
                );
            #endregion

            #region Eclipse Effect
            assets.Add(new StatusEffectDataBuilder(this)
                .Create("On Card Played Increase Counter To Target And Reduce Counter To Self")
                .WithText(" <{a}>")
                .WithCanBeBoosted(true)
                .SubscribeToAfterAllBuildEvent(delegate (StatusEffectData data)
                {
                    ((StatusEffectApplyXMultipleOnCardPlayed)data).effects = new StatusEffectApplyXInstant[] { TryGet("Increase Counter To Target"), TryGet("Reduce Counter To Self") };
                })
                );
            #endregion

            #region Eclipse's Indirect Effect 1
            assets.Add(new StatusEffectDataBuilder(this)
                .Create("Increase Counter To Target")
                .WithCanBeBoosted(true)
                .SubscribeToAfterAllBuildEvent(delegate (StatusEffectData data)
                {
                    ((StatusEffectApplyX)data).effectToApply = TryGet("Increase Counter");
                    ((StatusEffectApplyX)data).applyToFlags = StatusEffectApplyX.ApplyToFlags.Target;
                })
                );
            #endregion

            #region Eclipse's Indirect Effect 2
            assets.Add(new StatusEffectDataBuilder(this)
                .Create("Increase Counter")
                .WithCanBeBoosted(true)
                );
            #endregion

            #region Eclipse's Indirect Effect 3
            assets.Add(new StatusEffectDataBuilder(this)
                .Create("Reduce Counter To Self")
                .WithCanBeBoosted(true)
                .SubscribeToAfterAllBuildEvent(delegate (StatusEffectData data)
                {
                    ((StatusEffectApplyX)data).effectToApply = TryGet("Reduce Counter");
                    ((StatusEffectApplyX)data).applyToFlags = StatusEffectApplyX.ApplyToFlags.Self;
                })
                );
            #endregion

            #region Intangible Effect
            assets.Add(new StatusEffectDataBuilder(this)
                .Create("Intangible")
                .WithText($"")
                );
            #endregion

            #region Nocturnal Effect
            assets.Add(new StatusEffectDataBuilder(this)
                .Create("Nocturnal")
                .WithText($"")
                .SubscribeToAfterAllBuildEvent(delegate (StatusEffectData data)
                {
                    ((StatusEffectActuallyImmuneToX)data).max = 0;
                    ((StatusEffectActuallyImmuneToX)data).immunityTypes = ((StatusEffectActuallyImmuneToX)data).immunityTypes.AddRangeToArray(new StatusEffectData[] { TryGet("Reduce Counter"), TryGet("Trigger"), TryGet("Trigger (High Prio)") });
                })
                );
            #endregion

            #region Bless Effect
            assets.Add(StatusCopy("Snow", "Bless")
                .Create("Bless")
                .WithCanBeBoosted(true)
                .WithText("Apply <{a}> ")
                .WithType("")
                .FreeModify(delegate (StatusEffectApplyRandom data)
                {
                    string[] effects = {
                        "Block",
                        "Shell",
                        "Spice",
                        "Teeth"
                    };

                    data.effectsToApply = effects;
                })
                );
            #endregion

            #endregion

            #region Unit Effects

            #region Tom's Effect
            assets.Add(
                new StatusEffectDataBuilder(this)
                .Create("When Ally Is Targeted Add Attack Or Health")
                .WithText("When an ally is targeted with an item, add <+{a}>  or <+{a}>  to the ally")
                .WithCanBeBoosted(true)
                );
            #endregion

            #region Dandy's Effect
            assets.Add(new StatusEffectDataBuilder(this)
                .Create("When Hit Restore Health And Reduce Counter To Allies")
                .WithText("When hit, restore <{a}>  and count down all allies'  by <{a}>")
                .WithCanBeBoosted(true)
                .SubscribeToAfterAllBuildEvent(delegate (StatusEffectData data)
                {
                    ((StatusEffectApplyXMultipleWhenHit)data).effects = new StatusEffectApplyXInstant[] { TryGet("Heal Self"), TryGet("Reduce Counter To All Allies") };
                })
                );
            #endregion

            #region Dandy's Indirect Effect
            assets.Add(new StatusEffectDataBuilder(this)
                .Create("Heal Self")
                .SubscribeToAfterAllBuildEvent(delegate (StatusEffectData data)
                {
                    ((StatusEffectApplyX)data).effectToApply = TryGet("Heal");
                    ((StatusEffectApplyX)data).applyToFlags = StatusEffectApplyX.ApplyToFlags.Self;
                })
                );
            #endregion

            #region Dandy's Indirect Effect 2
            assets.Add(new StatusEffectDataBuilder(this)
                .Create("Reduce Counter To All Allies")
                .SubscribeToAfterAllBuildEvent(delegate (StatusEffectData data)
                {
                    ((StatusEffectApplyX)data).effectToApply = TryGet("Reduce Counter");
                    ((StatusEffectApplyX)data).applyToFlags = StatusEffectApplyX.ApplyToFlags.Allies;
                })
                );
            #endregion

            #region Dingo's Effect
            assets.Add(
                StatusCopy("While Active Increase Effects To Allies & Enemies", "While Active Increase Effects To Allies & Enemies (Fixed)")
                .SubscribeToAfterAllBuildEvent(delegate (StatusEffectData data)
                {
                    ((StatusEffectWhileActiveX)data).affectOthersWithSameEffect = false;
                    ((StatusEffectWhileActiveX)data).applyConstraints = new TargetConstraint[] { ScriptableObject.CreateInstance() };
                })
                );
            #endregion

            #region Elysio's Effect
            assets.Add(new StatusEffectDataBuilder(this)
                .Create("When Deployed Permanently Swap Life With Enemy In Row")
                .WithText("When deployed, permanently swap lives with a random non-boss enemy in the row")
                .WithStackable(false)
                .SubscribeToAfterAllBuildEvent(delegate (StatusEffectData data)
                {
                    ((StatusEffectApplyX)data).effectToApply = TryGet("Instant Permanently Swap");
                    ((StatusEffectApplyX)data).applyToFlags = StatusEffectApplyX.ApplyToFlags.RandomEnemyInRow;
                    ((StatusEffectApplyX)data).applyConstraints = new TargetConstraint[]
                    {
                        TryGetConstraint("Is Not Miniboss"),
                        TryGetConstraint("Is Not Small Boss"),
                        TryGetConstraint("Is Not Boss"),
                    };
                })
                );
            #endregion

            #region Elysio's Indirect Effect
            assets.Add(new StatusEffectDataBuilder(this)
                .Create("Instant Permanently Swap")
                .SubscribeToAfterAllBuildEvent(delegate (StatusEffectData data)
                {
                    ((StatusEffectInstantSwapPermanent)data).saveDataName = "Elysio";
                })
                );
            #endregion

            #region Captain Zoryn's Effect
            assets.Add(
                StatusCopy("On Card Played Boost To Allies & Enemies", "On Card Played Boost To Self")
                .WithCanBeBoosted(false)
                .WithText("Boost effects by 1")
                .SubscribeToAfterAllBuildEvent(delegate (StatusEffectData data)
                {
                    ((StatusEffectApplyX)data).applyToFlags = StatusEffectApplyX.ApplyToFlags.Self;
                })
                );
            #endregion

            #region Pixel's Effect
            assets.Add(
               new StatusEffectDataBuilder(this)
                .Create("When Card Is Consumed Add Attack To All Allies")
                .WithText("When a card is , add <+{a}>  to all allies")
                .WithCanBeBoosted(true)
                .SubscribeToAfterAllBuildEvent(delegate (StatusEffectData data)
                {
                    ((StatusEffectApplyXWhenCardConsumed)data).mustBeOnBoard = false;
                    ((StatusEffectApplyX)data).applyToFlags = StatusEffectApplyX.ApplyToFlags.Allies;
                    ((StatusEffectApplyX)data).effectToApply = TryGet("Increase Attack");
                })
                );
            #endregion

            #region Salem's Effect
            assets.Add(
                new StatusEffectDataBuilder(this)
                .Create("Bonus Damage Equal To Enemy Missing Health")
                .WithCanBeBoosted(false)
                .WithText("Deal additional damage equal to target's missing ")
                );
            #endregion

            #region Razz's Effect
            assets.Add(
                new StatusEffectDataBuilder(this)
                .Create("When Reduce Counter Reduce Counter")
                .WithCanBeBoosted(false)
                .WithText("Receives twice the amount from count down  effects")
                .FreeModify(delegate (StatusEffectApplyXWhenYEffectAppliedTo data)
                {
                    data.whenAppliedToFlags = StatusEffectApplyX.ApplyToFlags.Self;
                    data.whenAppliedTypes = new string[] { "counter down" };
                    data.adjustAmount = true;
                    data.multiplyAmount = 2;
                })
                );
            #endregion

            #region Harriot's Effect
            assets.Add(new StatusEffectDataBuilder(this)
                .Create("On Card Played Destroy Rightmost Card In Hand And Gain Attack")
                .WithCanBeBoosted(false)
                .WithText("Eat the rightmost card in your hand and gain double its ")
                .SubscribeToAfterAllBuildEvent(delegate (StatusEffectData data)
                {
                    ((StatusEffectApplyXPreTrigger)data).applyToFlags = StatusEffectApplyX.ApplyToFlags.RightCardInHand;
                    ((StatusEffectApplyXPreTrigger)data).effectToApply = TryGet("Sacrifice Card In Hand And Instant Increase Attack");
                    ((StatusEffectApplyXPreTrigger)data).stackable = false;
                })
                );
            #endregion

            #region Harriot's Indirect Effect
            assets.Add(
                new StatusEffectDataBuilder(this)
                .Create("Sacrifice Card In Hand And Instant Increase Attack")
                .WithCanBeBoosted(false)
                .SubscribeToAfterAllBuildEvent(delegate (StatusEffectData data)
                {
                    ((StatusEffectInstantDestroyCardAndGainAttack)data).effects = new StatusEffectInstant[] { TryGet("Sacrifice Card In Hand") };
                    ((StatusEffectInstantDestroyCardAndGainAttack)data).applyXEffects = new StatusEffectApplyXInstant[] { TryGet("Instant Increase Attack To Applier") };
                    ((StatusEffectInstantDestroyCardAndGainAttack)data).multFactor = 2f;
                })
                );
            #endregion

            #region Peppermint's Effect
            assets.Add(new StatusEffectDataBuilder(this)
                .Create("When Healed Apply Shroom To Random Enemy")
                .WithText("When healed, apply equal  to a random enemy")
                .SubscribeToAfterAllBuildEvent(delegate (StatusEffectData data)
                {
                    ((StatusEffectApplyXWhenHealed)data).alsoWhenMaxHealthIncreased = false;
                    ((StatusEffectApplyX)data).applyToFlags = StatusEffectApplyX.ApplyToFlags.RandomEnemy;
                    ((StatusEffectApplyX)data).effectToApply = TryGet("Shroom");
                    ((StatusEffectApplyX)data).applyEqualAmount = true;
                })
                );
            #endregion

            #region Covet's Effect
            assets.Add(new StatusEffectDataBuilder(this)
                .Create("When Deployed Swap Stats With Front Ally")
                .WithText("When deployed, swap , , and  with front ally")
                .SubscribeToAfterAllBuildEvent(delegate (StatusEffectData data)
                {
                    ((StatusEffectApplyX)data).applyToFlags = StatusEffectApplyX.ApplyToFlags.FrontAlly;
                    ((StatusEffectApplyX)data).effectToApply = TryGet("Instant Swap Stats With Front Ally");
                })
                );
            #endregion

            #region Covet's Indirect Effect
            assets.Add(new StatusEffectDataBuilder(this)
                .Create("Instant Swap Stats With Front Ally")
                .SubscribeToAfterAllBuildEvent(delegate (StatusEffectData data)
                {
                    data.targetConstraints = new TargetConstraint[] { ScriptableObject.CreateInstance(), ScriptableObject.CreateInstance() };
                })
                );
            #endregion

            #region Buttercup's Effect
            assets.Add(StatusCopy("On Card Played Trigger Against AllyInFrontOf", "On Card Played Trigger Against Allies In Row")
                .WithText("Also hits allies in the row")
                .SubscribeToAfterAllBuildEvent(delegate (StatusEffectData data)
                {
                    ((StatusEffectApplyX)data).applyToFlags = StatusEffectApplyX.ApplyToFlags.AlliesInRow;
                    ((StatusEffectApplyX)data).applyConstraints = new TargetConstraint[] { ScriptableObject.CreateInstance() };
                })
                );
            #endregion

            #region Jasper's Effect
            assets.Add(new StatusEffectDataBuilder(this)
                .Create("When Deployed Add Frenzy To Hand")
                .WithText("When deployed, add   to all  in your hand")
                .WithCanBeBoosted(true)
                .SubscribeToAfterAllBuildEvent(delegate (StatusEffectData data)
                {
                    ((StatusEffectApplyX)data).applyToFlags = StatusEffectApplyX.ApplyToFlags.Hand;
                    StatusEffectMultiHit frenzyEffect = TryGet("MultiHit");
                    StatusEffectData effectCopy = UnityEngine.Object.Instantiate(frenzyEffect);
                    effectCopy.id = frenzyEffect.id++;
                    effectCopy.name = frenzyEffect.name;
                    effectCopy.original = frenzyEffect;
                    effectCopy.isClone = true;
                    effectCopy.targetConstraints = new TargetConstraint[] { ScriptableObject.CreateInstance() };
                    ((StatusEffectApplyX)data).effectToApply = effectCopy;
                })
                );
            #endregion

            #region Stasis's Effect
            assets.Add(StatusCopy("When Deployed Summon Wowee", "When Deployed Summon Lion")
                .WithText("When deployed, summon a {0}")
                .WithTextInsert($"")
                .SubscribeToAfterAllBuildEvent(delegate (StatusEffectData data)
                {
                    ((StatusEffectApplyXWhenDeployed)data).effectToApply = TryGet("Instant Summon Lion");
                })
                );
            #endregion

            #region Stasis's Indirect Effect
            assets.Add(new StatusEffectDataBuilder(this)
                .Create("Instant Summon Lion")
                .WithStackable(false)
                .SubscribeToAfterAllBuildEvent(delegate (StatusEffectData data)
                {
                    ((StatusEffectInstantSummonRandom)data).targetSummonRandom = TryGet("Summon Lion");
                })
                );
            #endregion

            #region Stasis's Indirect Effect 2
            assets.Add(new StatusEffectDataBuilder(this)
                .Create("Summon Lion")
                .WithText($"Summon a ")
                .WithCanBeBoosted(false)
                .SubscribeToAfterAllBuildEvent(delegate (StatusEffectData data)
                {
                    ((StatusEffectSummonRandom)data).summonCards = new CardData[] { TryGet("chuckles"), TryGet("steak"), TryGet("cleaver") };
                    ((StatusEffectSummonRandom)data).summonChanceCards = new CardData[] { TryGet("arsyLion") };
                    ((StatusEffectSummon)data).gainTrait = TryGet("Temporary Summoned");
                    ((StatusEffectSummon)data).setCardType = TryGet("Summoned");
                    ((StatusEffectSummon)data).effectPrefabRef = TryGet("Summon Beepop").effectPrefabRef;
                })
                );
            #endregion

            #region Priscylla's Effect
            assets.Add(new StatusEffectDataBuilder(this)
                .Create("Trigger Against When Enemy Below Health X")
                .WithText("Trigger against any enemy below <{a}> ")
                .WithIsReaction(true)
                .WithCanBeBoosted(true)
                .SubscribeToAfterAllBuildEvent(delegate (StatusEffectData data)
                {
                    data.affectedBySnow = true;
                    data.descColorHex = "F99C61";

                    TargetConstraintHasStatus notScrap = ScriptableObject.CreateInstance();
                    notScrap.status = TryGet("Scrap");
                    notScrap.not = true;
                    data.targetConstraints = new TargetConstraint[] { notScrap };
                })
                );
            #endregion

            #region Felice's Effect
            assets.Add(StatusCopy("Summon Beepop", "Summon Sheep Coworker")
                .WithText($"Summon ")
                .SubscribeToAfterAllBuildEvent(delegate (StatusEffectData data)
                {
                    ((StatusEffectSummon)data).summonCard = TryGet("SheepCoworker");
                })
                );
            #endregion

            #region Ether's Effect 
            assets.Add(new StatusEffectDataBuilder(this)
                .Create("Trigger Against When Enemy Attacks")
                .WithText("Trigger on turn end against enemies that attacked")
                .WithIsReaction(true)
                .SubscribeToAfterAllBuildEvent(delegate (StatusEffectData data)
                {
                    data.affectedBySnow = true;
                    data.descColorHex = "F99C61";
                })
                );
            #endregion

            #region Steven's Effect 
            assets.Add(new StatusEffectDataBuilder(this)
                .Create("While Active In Full Board Gain Attack And Barrage")
                .WithText("While active in a full board, add <+{a}> and  to self")
                .WithCanBeBoosted(true)
                .SubscribeToAfterAllBuildEvent(delegate (StatusEffectData data)
                {
                    ((StatusEffectOngoingAttackAndBarrageInFullBoard)data).trait = TryGet("Barrage");
                })
                );
            #endregion

            #region Joseph's Effect 
            assets.Add(new StatusEffectDataBuilder(this)
                .Create("On Card Played Sacrifice Adjacent Allies")
                .WithText("Sacrifice adjacent allies")
                .SubscribeToAfterAllBuildEvent(delegate (StatusEffectData data)
                {
                    ((StatusEffectApplyXOnCardPlayed)data).effectToApply = TryGet("Instant Sacrifice Adjacent Allies");
                    ((StatusEffectApplyXOnCardPlayed)data).applyToFlags = StatusEffectApplyX.ApplyToFlags.Self;
                })
                );
            #endregion

            #region Joseph's Indirect Effect 
            assets.Add(new StatusEffectDataBuilder(this)
                .Create("Instant Sacrifice Adjacent Allies")
                );
            #endregion

            #region Kreedance's Effect 
            assets.Add(new StatusEffectDataBuilder(this)
                .Create("Pre Card Played Apply Smackback To Target")
                .WithText("Before attacking, add  to the target")
                .SubscribeToAfterAllBuildEvent(delegate (StatusEffectData data)
                {
                    ((StatusEffectApplyXPreCardPlayed)data).effectToApply = TryGet("Instant Gain Smackback");
                    ((StatusEffectApplyXPreCardPlayed)data).applyToFlags = StatusEffectApplyX.ApplyToFlags.Target;
                })
                );
            #endregion

            #region Kreedance's Indirect Effect 
            assets.Add(new StatusEffectDataBuilder(this)
                .Create("Instant Gain Smackback")
                .WithText("Add  to the target")
                .SubscribeToAfterAllBuildEvent(delegate (StatusEffectData data)
                {
                    ((StatusEffectApplyXInstant)data).effectToApply = TryGet("Temporary Smackback");
                    ((StatusEffectApplyXInstant)data).applyToFlags = StatusEffectApplyX.ApplyToFlags.Self;
                })
                );
            #endregion

            #region Kreedance's Indirect Effect 2
            assets.Add(new StatusEffectDataBuilder(this)
                .Create("Temporary Smackback")
                .SubscribeToAfterAllBuildEvent(delegate (StatusEffectData data)
                {
                    ((StatusEffectTemporaryTrait)data).trait = TryGet("Smackback");
                })
                );
            #endregion

            #region Ren's Effect 
            assets.Add(new StatusEffectDataBuilder(this)
                .Create("On Turn Heal Self And Allies")
                .WithText("Restore <{a}>  to self and all allies")
                .SubscribeToAfterAllBuildEvent(delegate (StatusEffectData data)
                {
                    ((StatusEffectApplyXOnCardPlayed)data).effectToApply = TryGet("Heal (No Ping)");
                    ((StatusEffectApplyXOnCardPlayed)data).applyToFlags = StatusEffectApplyX.ApplyToFlags.Self | StatusEffectApplyX.ApplyToFlags.Allies;
                })
                );
            #endregion

            #region Snip's Effect 
            assets.Add(new StatusEffectDataBuilder(this)
                .Create("On Turn Randomize Stats (2-5)")
                .WithText("Randomize  between 2 and 5")
                .SubscribeToAfterAllBuildEvent(delegate (StatusEffectData data)
                {
                    ((StatusEffectApplyXOnCardPlayed)data).effectToApply = TryGet("Randomize Stats (2-5)");
                    ((StatusEffectApplyXOnCardPlayed)data).applyToFlags = StatusEffectApplyX.ApplyToFlags.Self;
                })
                );
            #endregion

            #region Brew's Effect 
            assets.Add(new StatusEffectDataBuilder(this)
                .Create("When Hit Multiple 5 Instant Summon Big Fishy")
                .WithText("Summon  when hit <{a}> more times")
                .WithIsReaction(true)
                .SubscribeToAfterAllBuildEvent(delegate (StatusEffectData data)
                {
                    data.descColorHex = "F99C61";
                    ((StatusEffectApplyXWhenHitMultiple)data).startingCounter = 5;
                    ((StatusEffectApplyX)data).effectToApply = TryGet("Instant Summon Big Fishy");
                    ((StatusEffectApplyX)data).applyToFlags = StatusEffectApplyX.ApplyToFlags.Self;
                })
                );
            #endregion

            #region Brew's Indirect Effect
            assets.Add(StatusCopy("Instant Summon Fallow", "Instant Summon Big Fishy")
                .SubscribeToAfterAllBuildEvent(delegate (StatusEffectData data)
                {
                    ((StatusEffectInstantSummon)data).targetSummon = TryGet("Summon Big Fishy");
                })
                );
            #endregion

            #region Brew's Indirect Effect 2
            assets.Add(StatusCopy("Summon Beepop", "Summon Big Fishy")
                .WithText($"Summon ")
                .SubscribeToAfterAllBuildEvent(delegate (StatusEffectData data)
                {
                    ((StatusEffectSummon)data).summonCard = TryGet("BigFishy");
                })
                );
            #endregion

            #region Roséate's Effect 
            assets.Add(new StatusEffectDataBuilder(this)
                .Create("On Card Played Instant Swap Effects")
                .WithText("Swap effects with the target")
                .SubscribeToAfterAllBuildEvent(delegate (StatusEffectData data)
                {
                    ((StatusEffectApplyX)data).effectToApply = TryGet("Instant Swap Effects");
                    ((StatusEffectApplyX)data).applyToFlags = StatusEffectApplyX.ApplyToFlags.Target;
                })
                );
            #endregion

            #region Roséate's Indirect Effect 
            assets.Add(new StatusEffectDataBuilder(this)
                .Create("Instant Swap Effects")
                );
            #endregion

            #endregion

            #region Pet Effects

            #region Rye Effect
            assets.Add(new StatusEffectDataBuilder(this)
                .Create("On Card Played Discard Self")
                .WithText("Discard self")
                .WithStackable(false)
                );
            #endregion

            #region Rye Effect 2
            assets.Add(StatusCopy("Trigger Against Random Unit When Drawn", "Trigger Against Random Enemy When Drawn")
                .WithText("When drawn, trigger against a random enemy")
                .WithStackable(false)
                .SubscribeToAfterAllBuildEvent(delegate (StatusEffectData data)
                {
                    ((StatusEffectApplyX)data).applyToFlags = StatusEffectApplyX.ApplyToFlags.RandomEnemy;
                })
                );
            #endregion

            #region Rye Effect 3
            assets.Add(new StatusEffectDataBuilder(this)
                .Create("Destroy After Place")
                .WithText($"")
                );
            #endregion

            #region Lionel Effect
            assets.Add(new StatusEffectDataBuilder(this)
                .Create("On Card Played Apply Bless To Random Ally")
                .WithText("Apply <{a}>  to a random ally")
                .WithStackable(true)
                .WithCanBeBoosted(true)
                .SubscribeToAfterAllBuildEvent(delegate (StatusEffectData data)
                {
                    string[] effects = {
                        "Block",
                        "Shell",
                        "Spice",
                        "Teeth"
                    };

                    ((StatusEffectApplyRandom)data).effectsToApply = effects;
                    ((StatusEffectApplyX)data).applyToFlags = StatusEffectApplyX.ApplyToFlags.RandomAlly;
                })
                );
            #endregion

            #endregion

            #region Summon Effects

            #region Innocent Monster's Effect
            assets.Add(StatusCopy("When Destroyed Add Health To Allies", "When Destroyed Add Health To Enemies")
                .WithText("When destroyed, add <+{a}> to all enemies")
                .SubscribeToAfterAllBuildEvent(delegate (StatusEffectData data)
                {
                    ((StatusEffectApplyX)data).applyToFlags = StatusEffectApplyX.ApplyToFlags.Enemies;
                })
                );
            #endregion

            #region Arsy Lion's Effect
            assets.Add(StatusCopy("When Deployed Summon Wowee", "When Deployed Summon All Lions")
                .WithText($"When deployed, summon all other ")
                .SubscribeToAfterAllBuildEvent(delegate (StatusEffectData data)
                {
                    ((StatusEffectApplyX)data).effectToApply = TryGet("Summon All Lions");
                })
                );
            #endregion

            #region Arsy Lion's Indirect Effect
            assets.Add(new StatusEffectDataBuilder(this)
                .Create("Summon All Lions")
                .WithCanBeBoosted(false)
                .SubscribeToAfterAllBuildEvent(delegate (StatusEffectData data)
                {
                    StatusEffectInstantSummonChain chucklesSummon = TryGet("Instant Summon Chuckles");
                    chucklesSummon.summonIndex = 0;
                    StatusEffectInstantSummonChain steakSummon = TryGet("Instant Summon Steak");
                    steakSummon.summonIndex = 1;
                    StatusEffectInstantSummonChain cleaverSummon = TryGet("Instant Summon Cleaver");
                    cleaverSummon.summonIndex = 2;
                    ((StatusEffectInstantMultiple)data).effects = new StatusEffectInstant[] { chucklesSummon, steakSummon, cleaverSummon };
                })
                );
            #endregion

            #region Arsy Lion's Indirect Effect 2
            assets.Add(new StatusEffectDataBuilder(this)
                .Create("Instant Summon Chuckles")
                .SubscribeToAfterAllBuildEvent(delegate (StatusEffectData data)
                {
                    ((StatusEffectInstantSummon)data).targetSummon = TryGet("Summon Chuckles");
                })
                );
            #endregion

            #region Arsy Lion's Indirect Effect 3
            assets.Add(StatusCopy("Summon Fallow", "Summon Chuckles")
                .SubscribeToAfterAllBuildEvent(delegate (StatusEffectData data)
                {
                    ((StatusEffectSummon)data).summonCard = TryGet("chuckles");
                })
                );
            #endregion

            #region Arsy Lion's Indirect Effect 4
            assets.Add(new StatusEffectDataBuilder(this)
                .Create("Instant Summon Steak")
                .SubscribeToAfterAllBuildEvent(delegate (StatusEffectData data)
                {
                    ((StatusEffectInstantSummon)data).targetSummon = TryGet("Summon Steak");
                })
                );
            #endregion

            #region Arsy Lion's Indirect Effect 5
            assets.Add(StatusCopy("Summon Fallow", "Summon Steak")
                .SubscribeToAfterAllBuildEvent(delegate (StatusEffectData data)
                {
                    ((StatusEffectSummon)data).summonCard = TryGet("steak");
                })
                );
            #endregion

            #region Arsy Lion's Indirect Effect 6
            assets.Add(new StatusEffectDataBuilder(this)
                .Create("Instant Summon Cleaver")
                .SubscribeToAfterAllBuildEvent(delegate (StatusEffectData data)
                {
                    ((StatusEffectInstantSummon)data).targetSummon = TryGet("Summon Cleaver");
                })
                );
            #endregion

            #region Arsy Lion's Indirect Effect 7
            assets.Add(StatusCopy("Summon Fallow", "Summon Cleaver")
                .SubscribeToAfterAllBuildEvent(delegate (StatusEffectData data)
                {
                    ((StatusEffectSummon)data).summonCard = TryGet("cleaver");
                })
                );
            #endregion

            #region Sheep Coworker's Effect
            assets.Add(StatusCopy("On Card Played Apply Attack To Self", "On Card Played Apply Health To Self")
                .WithText("Gain <+{a}> ")
                .SubscribeToAfterAllBuildEvent(delegate (StatusEffectData data)
                {
                    ((StatusEffectApplyXOnCardPlayed)data).effectToApply = TryGet("Increase Max Health");
                })
                );
            #endregion

            #region Nightmare's Effect
            assets.Add(StatusCopy("When Ally Is Sacrificed Draw", "When Ally Is Sacrificed Boost Effects To Self")
                .WithText("When an ally is , boost effects by 1")
                .WithCanBeBoosted(false)
                .SubscribeToAfterAllBuildEvent(delegate (StatusEffectData data)
                {
                    ((StatusEffectApplyXWhenAllyIsKilled)data).effectToApply = TryGet("Increase Effects");
                })
                );
            #endregion

            #region Knowledge Gremlin's Effect
            assets.Add(new StatusEffectDataBuilder(this)
                .Create("Trigger When Card Drawn")
                .WithText("Trigger when a card is drawn (Excludes Redraw Bell)")
                .WithIsReaction(true)
                .SubscribeToAfterAllBuildEvent(delegate (StatusEffectData data)
                {
                    data.affectedBySnow = true;
                    data.descColorHex = "F99C61";

                    ((StatusEffectApplyX)data).effectToApply = TryGet("Trigger");
                    ((StatusEffectApplyX)data).applyToFlags = StatusEffectApplyX.ApplyToFlags.Self;
                    ((StatusEffectApplyX)data).doPing = false;
                })
                );
            #endregion

            #region Frozen Corpse's Effect
            assets.Add(new StatusEffectDataBuilder(this)
                .Create("Stop Count Down While Self Has Block")
                .WithText("Freezes  while having ")
                .WithStackable(false)
                .SubscribeToAfterAllBuildEvent(delegate (StatusEffectData data)
                {
                    ((StatusEffectIncreaseCounterWhileX)data).status = TryGet("Block");
                })
                );
            #endregion

            #region Ravenous Creature Effect
            assets.Add(new StatusEffectDataBuilder(this)
                .Create("When Ally Summoned Sacrifice Ally And Instant Apply Current Health And Attack")
                .WithText("When an ally is , kill it and absorb its  and ")
                .SubscribeToAfterAllBuildEvent(delegate (StatusEffectData data)
                {
                    ((StatusEffectApplyXWhenAllySummoned)data).applyToFlags = StatusEffectApplyX.ApplyToFlags.Self;
                    ((StatusEffectApplyXWhenAllySummoned)data).effectToApplyToSummon = TryGet("Kill");
                    ((StatusEffectApplyXWhenAllySummoned)data).effectToApply = TryGet("Instant Apply Current Health And Attack");
                })
                );
            #endregion

            #endregion

            #region Clunker Effects

            #region Firewood Effect
            assets.Add(
                new StatusEffectDataBuilder(this)
                .Create("On Turn Heal Allies In Row")
                .WithText("Restore <{a}>  to allies in the row")
                .WithCanBeBoosted(true)
                .SubscribeToAfterAllBuildEvent(delegate (StatusEffectData data)
                {
                    ((StatusEffectApplyX)data).applyToFlags = StatusEffectApplyX.ApplyToFlags.AlliesInRow;
                    ((StatusEffectApplyX)data).effectToApply = TryGet("Heal (No Ping)");
                })
                );
            #endregion

            #region Radio Effect
            assets.Add(
                new StatusEffectDataBuilder(this)
                .Create("On Turn Increase Attack To Allies In Row")
                .WithText("Increase  by <{a}> to allies in the row")
                .WithCanBeBoosted(true)
                .SubscribeToAfterAllBuildEvent(delegate (StatusEffectData data)
                {
                    ((StatusEffectApplyX)data).applyToFlags = StatusEffectApplyX.ApplyToFlags.AlliesInRow;
                    ((StatusEffectApplyX)data).effectToApply = TryGet("Increase Attack");
                })
                );
            #endregion

            #region Frosted Tree Effect
            assets.Add(
                StatusCopy("While Active Increase Effects To Allies & Enemies", "While Active Increase Effects And Decrease Attack To Allies In The Row")
                .WithText("While active, allies in the row have effects boosted by 1 and  reduced by 2")
                .WithCanBeBoosted(false)
                .WithStackable(false)
                .SubscribeToAfterAllBuildEvent(delegate (StatusEffectData data)
                {
                    ((StatusEffectWhileActiveX)data).affectOthersWithSameEffect = false;
                    ((StatusEffectApplyX)data).applyToFlags = StatusEffectApplyX.ApplyToFlags.AlliesInRow;
                    StatusEffectOngoingEffectsAndAttack effect = TryGet("Ongoing Increase Effects And Decrease Attack");
                    effect.attackAmount = 2;
                    ((StatusEffectApplyX)data).effectToApply = effect;
                })
                );
            #endregion

            #region Frosted Tree Indirect Effect
            assets.Add(new StatusEffectDataBuilder(this)
                .Create("Ongoing Increase Effects And Decrease Attack")
                );
            #endregion

            #region Noose Trap Effect
            assets.Add(new StatusEffectDataBuilder(this)
                .Create("When Destroyed Set Attacker Attack")
                .WithText("When destroyed, set the attacker's  to 1")
                .SubscribeToAfterAllBuildEvent(delegate (StatusEffectData data)
                {
                    ((StatusEffectApplyX)data).applyToFlags = StatusEffectApplyX.ApplyToFlags.Attacker;
                    ((StatusEffectApplyX)data).effectToApply = TryGet("Set Attack");
                    ((StatusEffectApplyX)data).targetMustBeAlive = false;
                })
                );
            #endregion

            #region Effigy Effect
            assets.Add(new StatusEffectDataBuilder(this)
                .Create("On Card Played Apply Bless To Allies")
                .WithText("Apply <{a}>  to all allies")
                .WithStackable(true)
                .WithCanBeBoosted(true)
                .SubscribeToAfterAllBuildEvent(delegate (StatusEffectData data)
                {
                    string[] effects = {
                        "Block",
                        "Shell",
                        "Spice",
                        "Teeth"
                    };

                    ((StatusEffectApplyRandom)data).effectsToApply = effects;
                    ((StatusEffectApplyX)data).applyToFlags = StatusEffectApplyX.ApplyToFlags.Allies;
                })
                );
            #endregion

            #region Effigy Effect 2
            assets.Add(new StatusEffectDataBuilder(this)
                .Create("Trigger When Ally Is Killed")
                .WithText("Trigger when an ally is killed")
                .WithIsReaction(true)
                .SubscribeToAfterAllBuildEvent(delegate (StatusEffectData data)
                {
                    data.descColorHex = "F99C61";
                    ((StatusEffectApplyXWhenCardDestroyed)data).canBeEnemy = false;
                    ((StatusEffectApplyX)data).effectToApply = TryGet("Trigger");
                    ((StatusEffectApplyX)data).applyToFlags = StatusEffectApplyX.ApplyToFlags.Self;
                })
                );
            #endregion

            #region Bookshelf Effect
            assets.Add(new StatusEffectDataBuilder(this)
                .Create("On Card Played Draw Equal To Summoned Allies")
                .WithText(" equal to amount of  allies")
                );
            #endregion

            #region Bookshelf Effect 2
            assets.Add(new StatusEffectDataBuilder(this)
                .Create("Trigger When Ally Summoned")
                .WithText("Trigger when an ally is summoned")
                .WithIsReaction(true)
                .SubscribeToAfterAllBuildEvent(delegate (StatusEffectData data)
                {
                    data.descColorHex = "F99C61";
                    ((StatusEffectApplyXWhenAllySummoned)data).effectToApply = TryGet("Trigger");
                    ((StatusEffectApplyXWhenAllySummoned)data).applyToFlags = StatusEffectApplyX.ApplyToFlags.Self;
                })
                );
            #endregion

            #region Vulture Totem Effect
            assets.Add(new StatusEffectDataBuilder(this)
                .Create("On Card Played Instant Add Scavenger To Random Ally")
                .WithText("Add  <{a}> to a random ally")
                .WithCanBeBoosted(true)
                .SubscribeToAfterAllBuildEvent(delegate (StatusEffectData data)
                {
                    ((StatusEffectApplyX)data).effectToApply = TryGet("Temporary Scavenger");
                    ((StatusEffectApplyX)data).applyToFlags = StatusEffectApplyX.ApplyToFlags.RandomAlly;
                    ((StatusEffectApplyX)data).applyConstraints = new TargetConstraint[] { TryGetConstraint("Has Health Or Attack") };
                })
                );
            #endregion

            #region Vulture Totem Indirect Effect
            assets.Add(new StatusEffectDataBuilder(this)
                .Create("Temporary Scavenger")
                .WithCanBeBoosted(true)
                .SubscribeToAfterAllBuildEvent(delegate (StatusEffectData data)
                {
                    ((StatusEffectTemporaryTrait)data).trait = TryGet("Scavenger");
                })
                );
            #endregion

            #region Vulture Totem Effect 2
            assets.Add(new StatusEffectDataBuilder(this)
                .Create("Trigger When Ally Is Sacrificed")
                .WithText("Trigger when an ally is sacrificed")
                .WithIsReaction(true)
                .SubscribeToAfterAllBuildEvent(delegate (StatusEffectData data)
                {
                    data.descColorHex = "F99C61";
                    ((StatusEffectApplyXWhenCardDestroyed)data).canBeEnemy = false;
                    ((StatusEffectApplyXWhenCardDestroyed)data).mustBeSacrificed = true;
                    ((StatusEffectApplyX)data).effectToApply = TryGet("Trigger");
                    ((StatusEffectApplyX)data).applyToFlags = StatusEffectApplyX.ApplyToFlags.Self;
                })
                );
            #endregion

            #endregion

            #region Item Effects

            #region Rations Effect
            assets.Add(
                new StatusEffectDataBuilder(this)
                .Create("Reduce Frenzy On Use")
                .WithCanBeBoosted(false)
                .WithText("Reduce  by 1 after use")
                .SubscribeToAfterAllBuildEvent(delegate (StatusEffectData data)
                {
                    ((StatusEffectReduceEffect)data).statusEffect = TryGet("MultiHit");
                })
                );
            #endregion

            #region Playing Cards Effect
            assets.Add(StatusCopy("Increase Attack", "Increase or Decrease Attack")
                .Create("Increase or Decrease Attack")
                .WithCanBeBoosted(true)
                .WithText("Increase or Decrease  by <{a}>")
                .WithType("")
                .SubscribeToAfterAllBuildEvent(delegate (StatusEffectData data)
                {
                    data.targetConstraints = new TargetConstraint[] { ScriptableObject.CreateInstance() };
                })
                );
            #endregion

            #region Sewing Kit Effect
            assets.Add(StatusCopy("Summon Fallow", "Summon Plush Monster")
                .WithText($"Summon ")
                .SubscribeToAfterAllBuildEvent(delegate (StatusEffectData data)
                {
                    ((StatusEffectSummon)data).summonCard = TryGet("plushmonster");
                })
                );
            #endregion

            #region Pack O' Smokes Effect
            assets.Add(new StatusEffectDataBuilder(this)
                .Create("Reduce Effects To Self")
                .WithText("Reduce effects by 1")
                .WithCanBeBoosted(false)
                .SubscribeToAfterAllBuildEvent(delegate (StatusEffectData data)
                {
                    ((StatusEffectReduceEffect)data).onUse = false;
                    ((StatusEffectReduceEffect)data).reduceBoostableEffects = true;
                })
                );
            #endregion

            #region Confusing Map's Effect
            assets.Add(StatusCopy("On Card Played Add Zoomlin To Cards In Hand", "On Card Played Add Noomlin To Random Card In Hand")
                .WithText($"Add  to a random card in your hand")
                .SubscribeToAfterAllBuildEvent(delegate (StatusEffectData data)
                {
                    ((StatusEffectApplyX)data).effectToApply = TryGet("Temporary Noomlin");
                    ((StatusEffectApplyX)data).applyToFlags = StatusEffectApplyX.ApplyToFlags.RandomCardInHand;
                    TargetConstraintHasTrait notNoomlin = ScriptableObject.CreateInstance();
                    notNoomlin.trait = TryGet("Noomlin");
                    notNoomlin.not = true;
                    ((StatusEffectApplyX)data).applyConstraints = new TargetConstraint[] { notNoomlin };
                })
                );
            #endregion

            #region Rage Brew's Effect
            assets.Add(StatusCopy("Instant Gain Aimless", "Instant Gain Hunter")
                .WithText($"Add  to the target")
                .SubscribeToAfterAllBuildEvent(delegate (StatusEffectData data)
                {
                    ((StatusEffectApplyXInstant)data).effectToApply = TryGet("Temporary Hunter");
                })
                );
            #endregion

            #region Rage Brew's Indirect Effect
            assets.Add(StatusCopy("Temporary Aimless", "Temporary Hunter")
                .SubscribeToAfterAllBuildEvent(delegate (StatusEffectData data)
                {
                    ((StatusEffectTemporaryTrait)data).trait = TryGet("Hunter");
                })
                );
            #endregion

            #region Rage Brew's Indirect Effect 2
            assets.Add(StatusCopy("Double Attack", "Double Attack Effect")
                .WithText("Double the target's ")
                );
            #endregion

            #region Merciful Dagger's Effect
            assets.Add(new StatusEffectDataBuilder(this)
                .Create("Instant Apply Current Health And Attack To Front Ally")
                .WithText("Add their  and  to front ally")
                .SubscribeToAfterAllBuildEvent(delegate (StatusEffectData data)
                {
                    ((StatusEffectApplyXInstant)data).applyToFlags = StatusEffectApplyX.ApplyToFlags.FrontAlly;
                    ((StatusEffectApplyXInstant)data).effectToApply = TryGet("Instant Apply Current Health And Attack");
                })
                );
            #endregion

            #region Merciful Dagger's Indirect Effect
            assets.Add(new StatusEffectDataBuilder(this)
                .Create("Instant Apply Current Health And Attack")
                .SubscribeToAfterAllBuildEvent(delegate (StatusEffectData data)
                {
                    ((StatusEffectInstantMultiple)data).effects = new StatusEffectInstant[] { TryGet("Increase Max Health"), TryGet("Increase Attack") };
                })
                );
            #endregion

            #region Cutlass Effect
            assets.Add(StatusCopy("On Hit Equal Overload To Target", "On Hit Equal Gain Gold") 
                .WithText("Gain  equal to damage dealt")
                .SubscribeToAfterAllBuildEvent(delegate (StatusEffectData data)
                {
                    ((StatusEffectApplyXOnHit)data).effectToApply = TryGet("Gain Gold");
                })
                );
            #endregion

            #region Worn Dice Effect
            assets.Add(new StatusEffectDataBuilder(this)
                .Create("On Card Played Random Damage")
                .WithText("Deal 1-6 damage")
                .SubscribeToAfterAllBuildEvent(delegate (StatusEffectData data)
                {
                    ((StatusEffectApplyXInstantRandomAmount)data).range = new Vector2Int(1, 6);
                    data.doesDamage = true;
                    ((StatusEffectApplyX)data).dealDamage = true;
                    ((StatusEffectApplyX)data).countsAsHit = true;
                    ((StatusEffectApplyX)data).applyToFlags = StatusEffectApplyX.ApplyToFlags.Self;
                })
                );
            #endregion

            #region Thermal Tracker Effect
            assets.Add(StatusCopy("Summon Enemy Leech", "Summon Enemy Innocent Monster")
                .WithText("Summon  on the enemy side")
                .SubscribeToAfterAllBuildEvent(delegate (StatusEffectData data)
                {
                    ((StatusEffectSummon)data).summonCard = TryGet("innocentMonster");
                })
                );
            #endregion

            #region Scythe Shard Effect
            assets.Add(StatusCopy("Summon Fallow", "Summon Frozen Corpse")
                .WithText($"Summon ")
                .SubscribeToAfterAllBuildEvent(delegate (StatusEffectData data)
                {
                    ((StatusEffectSummon)data).summonCard = TryGet("frozencorpse");
                })
                );
            #endregion

            #region Paid Contract Effect
            assets.Add(new StatusEffectDataBuilder(this)
                .Create("Summon Random Wanderer Companion")
                .WithText($"Summon a random Wanderer Companion")
                .SubscribeToAfterAllBuildEvent(delegate (StatusEffectData data)
                {
                    ((StatusEffectSummon)data).gainTrait = TryGet("Temporary Summoned");
                    ((StatusEffectSummon)data).setCardType = TryGet("Summoned");
                    ((StatusEffectSummon)data).effectPrefabRef = TryGet("Summon Beepop").effectPrefabRef;
                })
                );
            #endregion

            #region Good Soup Effect
            assets.Add(new StatusEffectDataBuilder(this)
                .Create("On Card Played Apply Spice Equal To Health")
                .WithText("Apply  equal to the target's ")
                .SubscribeToAfterAllBuildEvent(delegate (StatusEffectData data)
                {
                    ((StatusEffectInstantGainXEqualToHealth)data).status = TryGet("Spice");
                    ((StatusEffectInstantGainXEqualToHealth)data).countsAsHit = false;
                })
                );
            #endregion

            #region BOMB Effect
            assets.Add(StatusCopy("Gain Gold", "On Hit Gain Gold")
                .WithText("Gain <{a}>  on hit")
                .WithCanBeBoosted(true)
                );
            #endregion

            #region Haunted Sword Effect
            assets.Add(new StatusEffectDataBuilder(this)
                .Create("On Hit Apply Overload Equal To Target Attack")
                .WithText("Apply  equal to target's ")
                .SubscribeToAfterAllBuildEvent(delegate (StatusEffectData data)
                {
                    ((StatusEffectApplyX)data).effectToApply = TryGet("Overload");
                    ((StatusEffectApplyX)data).applyToFlags = StatusEffectApplyX.ApplyToFlags.Target;
                })
                );
            #endregion

            #region Foraging Basket Effect
            assets.Add(new StatusEffectDataBuilder(this)
                .Create("Apply Shroom Equal To Ally Count")
                .WithText("Apply  equal to amount of allies on the board")
                .SubscribeToAfterAllBuildEvent(delegate (StatusEffectData data)
                {
                    ((StatusEffectApplyX)data).effectToApply = TryGet("Shroom");
                    ((StatusEffectApplyX)data).applyToFlags = StatusEffectApplyX.ApplyToFlags.Self;
                })
                );
            #endregion

            #region Tiny Snowman Effect
            assets.Add(new StatusEffectDataBuilder(this)
                .Create("On Card Played Add Tiny Snowman To Hand")
                .WithText("Add <{a}>  to your hand")
                .WithCanBeBoosted(true)
                .SubscribeToAfterAllBuildEvent(delegate (StatusEffectData data)
                {
                    ((StatusEffectApplyX)data).effectToApply = TryGet("Instant Summon Tiny Snowman In Hand");
                    ((StatusEffectApplyX)data).applyToFlags = StatusEffectApplyX.ApplyToFlags.Self;
                    ((StatusEffectApplyX)data).queue = true;
                    ((StatusEffectApplyX)data).separateActions = true;
                })
                );
            #endregion

            #region Tiny Snowman Indirect Effect
            assets.Add(new StatusEffectDataBuilder(this)
                .Create("Instant Summon Tiny Snowman In Hand")
                .WithCanBeBoosted(true)
                .SubscribeToAfterAllBuildEvent(delegate (StatusEffectData data)
                {
                    ((StatusEffectInstantSummonStackable)data).targetSummon = TryGet("Summon Tiny Snowman");
                    ((StatusEffectInstantSummonStackable)data).summonPosition = StatusEffectInstantSummon.Position.Hand;
                })
                );
            #endregion

            #region Tiny Snowman Indirect Effect 2
            assets.Add(StatusCopy("Summon Junk", "Summon Tiny Snowman")
                .WithCanBeBoosted(true)
                .SubscribeToAfterAllBuildEvent(delegate (StatusEffectData data)
                {
                    ((StatusEffectSummon)data).summonCard = TryGet("TinySnowman");
                })
                );
            #endregion

            #region Bottled Dream Effect
            assets.Add(StatusCopy("Summon Fallow", "Summon Nightmare")
                .WithText($"Summon ")
                .SubscribeToAfterAllBuildEvent(delegate (StatusEffectData data)
                {
                    ((StatusEffectSummon)data).summonCard = TryGet("Nightmare");
                })
                );
            #endregion

            #region Tasty Page Effect
            assets.Add(StatusCopy("Summon Fallow", "Summon Knowledge Gremlin")
                .WithText($"Summon ")
                .SubscribeToAfterAllBuildEvent(delegate (StatusEffectData data)
                {
                    ((StatusEffectSummon)data).summonCard = TryGet("KnowledgeGremlin");
                })
                );
            #endregion

            #region Cursed Scythe Effect
            assets.Add(new StatusEffectDataBuilder(this)
                .Create("Instant Apply Hex To Random Ally")
                .WithText("Apply <{a}>  to a random ally")
                .WithCanBeBoosted(true)
                .SubscribeToAfterAllBuildEvent(delegate (StatusEffectData data)
                {
                    string[] effects = {
                        "Weakness",
                        "Demonize",
                        "Frost",
                        "Haze",
                        "Null",
                        "Overload",
                        "Shroom",
                        "Snow"
                    };

                    ((StatusEffectApplyXInstantApplyHex)data).effectsToApply = effects;
                })
                );
            #endregion

            #region Cage Effect
            assets.Add(StatusCopy("Summon Fallow", "Summon Savage Beast")
                .WithText($"Summon ")
                .SubscribeToAfterAllBuildEvent(delegate (StatusEffectData data)
                {
                    ((StatusEffectSummon)data).summonCard = TryGet("SavageBeast");
                })
                );
            #endregion

            #region Cage Effect 2
            assets.Add(new StatusEffectDataBuilder(this)
                .Create("Gain Zoomlin When Redraw Charges")
                .WithText($"Gain  when the Redraw Bell recharges")
                .SubscribeToAfterAllBuildEvent(delegate (StatusEffectData data)
                {
                    ((StatusEffectApplyXWhenRedrawCharges)data).effectToApply = TryGet("Temporary Zoomlin");
                    ((StatusEffectApplyXWhenRedrawCharges)data).applyToFlags = StatusEffectApplyX.ApplyToFlags.Self;
                })
                );
            #endregion

            #region Blood Trail Effect
            assets.Add(StatusCopy("Summon Fallow", "Summon Ravenous Creature")
                .WithText($"Summon ")
                .SubscribeToAfterAllBuildEvent(delegate (StatusEffectData data)
                {
                    ((StatusEffectSummon)data).summonCard = TryGet("RavenousCreature");
                })
                );
            #endregion

            #region Faint Shadow Effect
            assets.Add(new StatusEffectDataBuilder(this)
                .Create("Summon Other Leaders")
                .WithText("They're always with you")
                );
            #endregion

            #region Snake Oil Effect
            assets.Add(new StatusEffectDataBuilder(this)
                .Create("Halve Max Health")
                .WithText("Reduce  by half")
                .SubscribeToAfterAllBuildEvent(delegate (StatusEffectData data)
                {
                    data.targetConstraints = new TargetConstraint[]
                    {
                        TryGetConstraint("Has Health"),
                        TryGetConstraint("Does Trigger")
                    };
                })
                );
            #endregion

            #endregion

            #endregion

            #region Special slot just for Elysio :)
            string cardName = SaveSystem.LoadProgressData("Elysio");
            List cardUpgrades = SaveSystem.LoadProgressData>("ElysioUpgrades");
            if (cardName.IsNullOrEmpty())
            {
                assets.Add(
                    new CardDataBuilder(this).CreateUnit("Elysio", "Elysio")
                    .SetSprites("Characters/WandererTribe_CardArt_Elysio.png", "Backgrounds/WandererTribe_CardBG_Elysio.png")
                    .SetStats(1)
                    .WithCardType("Friendly")
                    .SubscribeToAfterAllBuildEvent(delegate (CardData data)
                    {
                        data.startWithEffects = new CardData.StatusEffectStacks[]
                        {
                            SStack("When Deployed Permanently Swap Life With Enemy In Row", 1)
                        };
                    })
                    );
            }
            else
            {
                assets.Add(new CardDataBuilder(this)
                    .CreateUnit("Elysio", "Elysio")
                    .SubscribeToAfterAllBuildEvent(delegate (CardData data)
                    {
                        // Copy all data from swapped data
                        CardData copyData = TryGet(cardName);

                        data.mainSprite = copyData.mainSprite;
                        data.backgroundSprite = copyData.backgroundSprite;
                        data.hasHealth = copyData.hasHealth;
                        data.hp = copyData.hp;
                        data.hasAttack = copyData.hasAttack;
                        data.damage = copyData.damage;
                        data.counter = copyData.counter;
                        data.canBeHit = copyData.canBeHit;
                        data.needsTarget = copyData.needsTarget;
                        data.targetMode = copyData.targetMode;
                        data.bloodProfile = copyData.bloodProfile;
                        data.idleAnimationProfile = copyData.idleAnimationProfile;
                        data.targetConstraints = copyData.targetConstraints;

                        // Effects
                        data.attackEffects = copyData.attackEffects.Clone().ToArray();
                        data.startWithEffects = copyData.startWithEffects.Clone().ToArray();
                        data.traits = copyData.traits;

                        // Creation scripts
                        foreach (string upgrade in cardUpgrades)
                        {
                            data.createScripts = data.createScripts.AddToArray(GiveUpgrade(upgrade));
                        }
                    })
                    );
            }
            #endregion
        }

        private void CreateModIcons()
        {
            //make sure you icon is in both the images folder and the sprites subfolder
            //Make sure the icon variable in CreateIconKeyword, the name variable in CreateIcon and your png name are all the same, in this case they are vampicon

            #region Hex
            CreateIcon(this, "hexicon", ImagePath("hex_icon.png").ToSprite(), "hex", "frost", Color.white, new KeywordData[] { Get("hex") })
                .GetComponentInChildren(true).enabled = true;
            #endregion

            #region Bless
            CreateIcon(this, "blessicon", ImagePath("hex_icon.png").ToSprite(), "bless", "frost", Color.white, new KeywordData[] { Get("bless") })
                .GetComponentInChildren(true).enabled = true;
            #endregion
        }

        private void CreateModBattles()
        {
            // TBD
        }

        private void CustomModifications()
        {
            // Target overrides/constraints
            var targetTraits = AddressableLoader.GetGroup("TraitData").ToArray().RemoveFromArray(item => item.effects.FirstOrDefault(effect => effect is StatusEffectChangeTargetMode || effect is StatusEffectBombard) != null);
            var targetEffects = AddressableLoader.GetGroup("StatusEffectData").ToArray().RemoveFromArray(item => item is StatusEffectChangeTargetMode || item is StatusEffectBombard);
            TargetConstraintHasTrait notSplash = ScriptableObject.CreateInstance();
            notSplash.name = "Does Not Have Splash";
            notSplash.trait = TryGet("Splash");
            notSplash.not = true;

            TargetConstraintHasTrait notHunter = ScriptableObject.CreateInstance();
            notHunter.name = "Does Not Have Hunter";
            notHunter.trait = TryGet("Hunter");
            notHunter.not = true;

            TargetConstraintHasStatus notExecute = ScriptableObject.CreateInstance();
            notExecute.name = "Does Not Have Execute";
            notExecute.status = TryGet("Instant Kill");
            notExecute.not = true;

            // Consume constraints
            var consumeTraits = AddressableLoader.GetGroup("TraitData").ToArray().RemoveFromArray(item => item.effects.FirstOrDefault(effect => effect is StatusEffectDestroyAfterUse) != null);
            var consumeEffects = AddressableLoader.GetGroup("StatusEffectData").ToArray().RemoveFromArray(item => item is StatusEffectDestroyAfterUse);
            TargetConstraintHasStatus notFlimsy = ScriptableObject.CreateInstance();
            notFlimsy.name = "Does Not Have Flimsy";
            notFlimsy.status = TryGet("Flimsy");
            notFlimsy.not = true;

            // Consumable constraints
            TargetConstraintHasStatus hasConsumable = ScriptableObject.CreateInstance();
            hasConsumable.status = TryGet("Destroy After Place");
            TargetConstraintOr hasConsumeOrConsumable = ScriptableObject.CreateInstance();
            hasConsumeOrConsumable.name = "Has Consume Or Consmable";
            hasConsumeOrConsumable.constraints = new TargetConstraint[] { TryGetConstraint("Has Consume"), hasConsumable };

            // Noomlin constraints
            var noomlinTraits = AddressableLoader.GetGroup("TraitData").ToArray().RemoveFromArray(item => item.effects.FirstOrDefault(effect => effect is StatusEffectFreeAction) != null);
            var noomlinEffects = AddressableLoader.GetGroup("StatusEffectData").ToArray().RemoveFromArray(item => item is StatusEffectFreeAction);
            TargetConstraintHasStatus notTriggerWhenDrawn = ScriptableObject.CreateInstance();
            notTriggerWhenDrawn.name = "Does Not Have Trigger When Drawn";
            notTriggerWhenDrawn.status = TryGet("Trigger Against Random Enemy When Drawn");
            notTriggerWhenDrawn.not = true;
            ((ScriptRunScriptsOnDeck)TryGet("BlessingNoomlin").startScripts.First()).constraints = ((ScriptRunScriptsOnDeck)TryGet("BlessingNoomlin").startScripts.First()).constraints.AddToArray(notTriggerWhenDrawn);
            TryGet("Free Action").targetConstraints = TryGet("Free Action").targetConstraints.AddToArray(notTriggerWhenDrawn);
            TryGet("Instant Gain Noomlin (To Card In Hand)").targetConstraints = TryGet("Instant Gain Noomlin (To Card In Hand)").targetConstraints.AddToArray(notTriggerWhenDrawn);
            TryGet("On Card Played Add Noomlin To Random Card In Hand").applyConstraints = TryGet("On Card Played Add Noomlin To Random Card In Hand").applyConstraints.AddToArray(notTriggerWhenDrawn);
            
            // Intangible constraints
            TryGet("Haze").targetConstraints = TryGet("Haze").targetConstraints.AddToArray(ScriptableObject.CreateInstance());

            // Adaptive constraints
            var adaptiveEffects = AddressableLoader.GetGroup("StatusEffectData").ToArray().RemoveFromArray(item => item.name == $"{GUID}.Adaptive");
            TargetConstraintHasStatus notAdaptive = ScriptableObject.CreateInstance();
            notAdaptive.name = "Does Not Have Adaptive";
            notAdaptive.status = TryGet("Adaptive");
            notAdaptive.not = true;


            foreach (TraitData trait in AddressableLoader.GetGroup("TraitData"))
            {
                // Target overrides
                if (trait.name == "Aimless" || trait.name == "Barrage" || trait.name == "Longshot")
                {
                    trait.overrides = TryGet(trait.name).overrides.With(TryGet("Splash"));
                }
            }
            foreach (var charm in AddressableLoader.GetGroup("CardUpgradeData"))
            {
                // Target constraints
                if (charm.giveTraits.FirstOrDefault(item => targetTraits.FirstOrDefault(item2 => item2 == item.data) != null) != null ||
                    charm.effects.FirstOrDefault(item => targetEffects.FirstOrDefault(item2 => item2 == item.data) != null) != null)
                {
                    charm.targetConstraints = charm.targetConstraints.AddRangeToArray(new TargetConstraint[] { notSplash, notHunter, notExecute });
                }

                // Consume constraints
                if (charm.giveTraits.FirstOrDefault(item => consumeTraits.FirstOrDefault(item2 => item2 == item.data) != null) != null ||
                    charm.effects.FirstOrDefault(item => consumeEffects.FirstOrDefault(item2 => item2 == item.data) != null) != null)
                {
                    charm.targetConstraints = charm.targetConstraints.AddToArray(notFlimsy);
                }

                // Consumable constraints
                if (charm.targetConstraints.FirstOrDefault(item => item.name == "Has Consume") != null)
                {
                    TargetConstraint consumeConstraint = null;
                    foreach (TargetConstraint constraint in charm.targetConstraints)
                    {
                        if (constraint.name == "Has Consume")
                        {
                            consumeConstraint = constraint;
                            break;
                        }
                    }

                    charm.targetConstraints = charm.targetConstraints.RemoveFromArray(consumeConstraint);
                    charm.targetConstraints = charm.targetConstraints.AddToArray(hasConsumeOrConsumable);
                }

                // Noomlin constraints
                if (charm.giveTraits.FirstOrDefault(item => noomlinTraits.FirstOrDefault(item2 => item2 == item.data) != null) != null ||
                    charm.effects.FirstOrDefault(item => noomlinEffects.FirstOrDefault(item2 => item2 == item.data) != null) != null)
                {
                    foreach (TargetConstraint constraint in charm.targetConstraints)
                    {
                        charm.targetConstraints = charm.targetConstraints.AddRangeToArray(new TargetConstraint[] { notTriggerWhenDrawn });
                    }
                }

                // Adaptive constraints
                if (charm.effects.FirstOrDefault(item => adaptiveEffects.FirstOrDefault(item2 => item2 == item.data) != null) != null)
                {
                    charm.targetConstraints = charm.targetConstraints.AddToArray(notAdaptive);
                }
            }
        }

        #region Helper Methods
        public T TryGet(string name) where T : DataFile
        {
            T data;
            if (typeof(StatusEffectData).IsAssignableFrom(typeof(T)))
                data = base.Get(name) as T;
            else if (typeof(KeywordData).IsAssignableFrom(typeof(T)))
                data = base.Get(name.ToLower()) as T;
            else
                data = base.Get(name);

            if (data == null)
                throw new Exception($"TryGet Error: Could not find a [{typeof(T).Name}] with the name [{name}] or [{Extensions.PrefixGUID(name, this)}]");

            return data;
        }

        public TargetConstraint TryGetConstraint(string name)
        {
            foreach (TargetConstraint constraint in targetConstraints)
            {
                if (constraint.name == name)
                    return constraint;
            }

            throw new Exception($"TryGet Error: Could not find a constraint with the name [{name}] or [{Extensions.PrefixGUID(name, this)}]");
        }

        internal T[] RemoveNulls(T[] data) where T : DataFile
        {
            List list = data.ToList();
            list.RemoveAll(x => x == null || x.ModAdded == this);
            return list.ToArray();
        }

        private void FixImage(Entity entity)
        {
            if (entity.display is Card card && !card.hasScriptableImage) //These cards should use the static image
            {
                card.mainImage.gameObject.SetActive(true);               //And this line turns them on
            }
        }

        public CardData.StatusEffectStacks SStack(string name, int amount)
        {
            return new CardData.StatusEffectStacks(TryGet(name), amount);
        }

        public CardData.TraitStacks TStack(string name, int amount)
        {
            return new CardData.TraitStacks(TryGet(name), amount);
        }

        private ClassDataBuilder TribeCopy(string oldName, string newName)
        {
            return DataCopy(oldName, newName);
        }

        public StatusEffectDataBuilder StatusCopy(string oldName, string newName)
        {
            return DataCopy(oldName, newName);
        }

        public CardDataBuilder CardCopy(string oldName, string newName)
        {
            return DataCopy(oldName, newName);
        }

        private T DataCopy(string oldName, string newName) where Y : DataFile where T : DataFileBuilder, new()
        {
            Y data = Get(oldName).InstantiateKeepName();
            data.name = GUID + "." + newName;
            T builder = data.Edit();
            builder.Mod = this;
            return builder;
        }

        public void UnloadFromClasses()
        {
            List tribes = AddressableLoader.GetGroup("ClassData");
            foreach (ClassData tribe in tribes)
            {
                if (tribe == null || tribe.rewardPools == null) { continue; } //This isn't even a tribe; skip it.

                foreach (RewardPool pool in tribe.rewardPools)
                {
                    if (pool == null) { continue; }; //This isn't even a reward pool; skip it.

                    pool.list.RemoveAllWhere((item) => item == null || item.ModAdded == this); //Find and remove everything that needs to be removed.
                }
            }
        }

        internal CardScript GiveUpgrade(string name = "Crown") //Give a crown
        {
            CardScriptGiveUpgrade script = ScriptableObject.CreateInstance(); //This is the standard way of creating a ScriptableObject
            script.name = $"Give {name}";                               //Name only appears in the Unity Inspector. It has no other relevance beyond that.
            script.upgradeData = TryGet(name);
            return script;
        }

        private RewardPool CreateRewardPool(string name, string type, DataFile[] list)
        {
            RewardPool pool = ScriptableObject.CreateInstance();
            pool.name = name;
            pool.type = type;            //The usual types are Units, Items, Charms, and Modifiers.
            pool.list = list.ToList();
            return pool;
        }

        public static TMP_SpriteAsset CreateSpriteAsset(string name, string directoryWithPNGs = null, Texture2D[] textures = null, Sprite[] sprites = null)
        {
            List allTextures = new List();
            IEnumerable enumerable;
            if (!directoryWithPNGs.IsNullOrWhitespace())
            {
                enumerable = Directory.GetFiles(directoryWithPNGs, "*.png", SearchOption.AllDirectories).Select(delegate (string p)
                {
                    Texture2D texture2D2 = new Texture2D(1, 1)
                    {
                        name = Path.GetFileNameWithoutExtension(p)
                    };
                    texture2D2.LoadImage(File.ReadAllBytes(p));
                    return texture2D2;
                });
            }
            else
            {
                IEnumerable enumerable2 = Array.Empty();
                enumerable = enumerable2;
            }

            IEnumerable enumerable3 = enumerable;
            foreach (Texture2D item2 in enumerable3)
            {
                if ((bool)item2)
                {
                    allTextures.Add(item2);
                }
            }

            object obj;
            if (sprites != null && sprites.Length != 0)
            {
                obj = sprites?.Where((Sprite s) => s != null).Select(delegate (Sprite s)
                {
                    Texture2D texture2D = s.ToTexture();
                    texture2D.name = s.name;
                    return texture2D;
                }) ?? Array.Empty();
            }
            else
            {
                IEnumerable enumerable2 = Array.Empty();
                obj = enumerable2;
            }

            IEnumerable enumerable4 = (IEnumerable)obj;
            foreach (Texture2D item3 in enumerable4)
            {
                if ((bool)item3)
                {
                    allTextures.Add(item3);
                }
            }

            object obj2;
            if (textures != null && textures.Length != 0)
            {
                obj2 = (from t in textures?.Where((Texture2D t) => t != null && t.width > 0 && t.height > 0)
                        select t.isReadable ? t : t.MakeReadable()) ?? Array.Empty();
            }
            else
            {
                IEnumerable enumerable2 = Array.Empty();
                obj2 = enumerable2;
            }

            IEnumerable enumerable5 = (IEnumerable)obj2;
            foreach (Texture2D item4 in enumerable5)
            {
                if ((bool)item4)
                {
                    allTextures.Add(item4);
                }
            }

            Texture2D atlas = new Texture2D(4096, 4096)
            {
                name = name + ".Sheet"
            };
            Rect[] rects = atlas.PackTextures(allTextures.ToArray(), 2);
            Dictionary dictionary = allTextures.ToDictionary((Texture2D t) => rects[allTextures.IndexOf(t)]);
            Shader shader = Shader.Find("TextMeshPro/Sprite");
            Material material = new Material(shader);
            material.SetTexture(ShaderUtilities.ID_MainTex, atlas);
            TMP_SpriteAsset tMP_SpriteAsset = TMP_Settings.defaultSpriteAsset.InstantiateKeepName();
            ((Action)delegate (TMP_SpriteAsset s)
            {
                s.name = name;
                s.spriteGlyphTable.Clear();
                s.spriteCharacterTable.Clear();
                s.material = material;
                s.spriteSheet = atlas;
                s.UpdateLookupTables();
            })(tMP_SpriteAsset);
            Rect[] array = rects;
            for (int i = 0; i < array.Length; i++)
            {
                Rect key = array[i];
                TMP_SpriteGlyph tMP_SpriteGlyph = new TMP_SpriteGlyph
                {
                    glyphRect = new GlyphRect((int)(key.x * (float)atlas.width), (int)(key.y * (float)atlas.height), (int)(key.width * (float)atlas.width), (int)(key.height * (float)atlas.height)),
                    index = (uint)tMP_SpriteAsset.spriteGlyphTable.Count,
                    metrics = new GlyphMetrics(170.6667f, 170.6667f, -10f, 150f, 150f),
                    scale = 1.5f
                };
                tMP_SpriteAsset.spriteGlyphTable.Add(tMP_SpriteGlyph);
                Debug.LogWarning("[" + tMP_SpriteAsset.name + "] adds glyph [" + dictionary[key].name + "]");
                TMP_SpriteCharacter item = new TMP_SpriteCharacter(tMP_SpriteGlyph.index, tMP_SpriteGlyph)
                {
                    name = dictionary[key].name
                };
                tMP_SpriteAsset.spriteCharacterTable.Add(item);
            }

            tMP_SpriteAsset.UpdateLookupTables();
            return tMP_SpriteAsset;
        }

        public static GameObject CreateIcon(WildfrostMod modOrNull, string name, Sprite sprite, string type, string copyTextFrom, Color textColor, KeywordData[] keys)
        {
            GameObject gameObject = new GameObject(name);
            UnityEngine.Object.DontDestroyOnLoad(gameObject);
            gameObject.SetActive(value: false);
            StatusIcon statusIcon = gameObject.AddComponent();
            Dictionary cardIcons = CardManager.cardIcons;
            if (!copyTextFrom.IsNullOrEmpty())
            {
                GameObject gameObject2 = cardIcons[copyTextFrom].GetComponentInChildren().gameObject.InstantiateKeepName();
                gameObject2.transform.SetParent(gameObject.transform);
                statusIcon.textElement = gameObject2.GetComponent();
                statusIcon.textColour = textColor;
                statusIcon.textColourAboveMax = textColor;
                statusIcon.textColourBelowMax = textColor;
            }

            statusIcon.onCreate = new UnityEvent();
            statusIcon.onDestroy = new UnityEvent();
            statusIcon.onValueDown = new UnityEventStatStat();
            statusIcon.onValueUp = new UnityEventStatStat();
            statusIcon.afterUpdate = new UnityEvent();
            Image image = gameObject.AddComponent();
            image.sprite = sprite;
            CardHover cardHover = gameObject.AddComponent();
            cardHover.enabled = false;
            cardHover.IsMaster = false;
            CardPopUpTarget cardPopUpTarget = gameObject.AddComponent();
            cardPopUpTarget.keywords = keys;
            cardHover.pop = cardPopUpTarget;
            RectTransform component = gameObject.GetComponent();
            component.anchorMin = Vector2.zero;
            component.anchorMax = Vector2.zero;
            component.sizeDelta *= 0.01f;
            gameObject.SetActive(value: true);
            statusIcon.type = type;
            cardIcons[type] = gameObject;
            return gameObject;
        }

        public static void SwitchToSaveProfile(string switchTo, bool copyFiles = false)
        {
            SaveSystem.Profile = switchTo;
            SaveSystem.folderName = SaveSystem.profileFolder + "/" + switchTo;
            if (SaveSystem.Enabled)
            {
                Events.InvokeSaveSystemProfileChanged();
            }

            string text = SaveSystem.profileFolder + "/Default";
            DirectoryInfo parent = Directory.GetParent(SaveSystem.settings.FullPath);
            if (!(!Directory.Exists(parent.FullName + "/" + SaveSystem.folderName) && Directory.Exists(parent.FullName + "/" + text) && copyFiles))
            {
                return;
            }

            DirectoryInfo directoryInfo = Directory.CreateDirectory(parent.FullName + "/" + SaveSystem.folderName);
            string[] array = new string[5] { "Campaign", "Battle", "History", "Save", "Stats" };
            string[] array2 = array;
            foreach (string text2 in array2)
            {
                if (File.Exists(parent?.ToString() + "/" + text + "/" + text2 + ".sav"))
                {
                    File.Copy(parent?.ToString() + "/" + text + "/" + text2 + ".sav", directoryInfo?.ToString() + "/" + text2 + ".sav");
                }

                if (File.Exists(parent?.ToString() + "/" + text + "/" + text2 + ".sav.bac"))
                {
                    File.Copy(parent?.ToString() + "/" + text + "/" + text2 + ".sav.bac", directoryInfo?.ToString() + "/" + text2 + ".sav.bac");
                }
            }
        }
        #endregion