initial commit. core of character is coded out and files are in place.

core mechanic of blood mist is working

.gitignore

@@ -0,0 +1,3 @@
+/target/
+/.idea/
+/hemomancer.iml

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 Gremious
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,7 @@
+# Default Mod Base - Quick Start
+
+This is a cloneable branch of the Default with all comments removed.
+
+You can use this to quickly start up a brand new mod.
+
+I assume you know what you are doing.

pom.xml

@@ -0,0 +1,112 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+    <!--Hello! You'll basically should only need to change these names and the steam path (just below)-->
+    <!--The author name(s) as they appear in MTS and any other comments are in your ModTheSpire.json-->
+    <groupId>xyz.geniuscartel</groupId>
+    <artifactId>Hemomancer</artifactId>
+    <name>Hemomancer Mod</name>
+    <version>0.0.1</version>
+    <description>A custom bloodmage class.</description>
+
+    <properties>
+        <maven.compiler.source>1.8</maven.compiler.source>
+        <maven.compiler.target>1.8</maven.compiler.target>
+        <SlayTheSpire.version>01-23-2019</SlayTheSpire.version>
+        <ModTheSpire.version>3.8.0</ModTheSpire.version>
+        <!--CHANGE THIS TO YOUR STEAM INSTALLATION-->
+        <Steam.path>/home/dtookey/.steam/debian-installation/steamapps</Steam.path>
+    </properties>
+
+    <dependencies>
+        <dependency>
+            <groupId>com.megacrit.cardcrawl</groupId>
+            <artifactId>slaythespire</artifactId>
+            <version>${SlayTheSpire.version}</version>
+            <scope>system</scope>
+            <systemPath>${Steam.path}/common/SlayTheSpire/desktop-1.0.jar</systemPath>
+            <!--<systemPath>${basedir}/../lib/desktop-1.0.jar</systemPath>-->
+        </dependency>
+        <dependency>
+            <groupId>com.evacipated.cardcrawl</groupId>
+            <artifactId>modthespire</artifactId>
+            <version>${ModTheSpire.version}</version>
+            <scope>system</scope>
+            <systemPath>${Steam.path}/workshop/content/646570/1605060445/ModTheSpire.jar</systemPath>
+            <!--<systemPath>${basedir}/../lib/ModTheSpire.jar</systemPath>-->
+        </dependency>
+        <dependency>
+            <groupId>basemod</groupId>
+            <artifactId>basemod</artifactId>
+            <version>5.0.0</version>
+            <scope>system</scope>
+            <systemPath>${Steam.path}/workshop/content/646570/1605833019/BaseMod.jar</systemPath>
+            <!--<systemPath>${basedir}/../lib/BaseMod.jar</systemPath>-->
+        </dependency>
+        <dependency>
+            <groupId>com.evacipated.cardcrawl.mod</groupId>
+            <artifactId>StSLib</artifactId>
+            <version>1.3.2</version>
+            <scope>system</scope>
+            <systemPath>${Steam.path}/workshop/content/646570/1609158507/StSLib.jar</systemPath>
+            <!--<systemPath>${basedir}/../lib/StSLib.jar</systemPath>-->
+        </dependency>
+    </dependencies>
+
+
+    <!-- This is how your code is packaged into the jar file-->
+    <build>
+        <finalName>${project.artifactId}</finalName>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-jar-plugin</artifactId>
+                <version>2.4</version>
+                <configuration>
+                    <excludes>
+                        <exclude>**/*.psd</exclude>
+                    </excludes>
+                </configuration>
+            </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-antrun-plugin</artifactId>
+                <version>1.8</version>
+                <executions>
+                    <execution>
+                        <phase>package</phase>
+                        <configuration>
+                            <target>
+                                <!-- This moves your mod into a common folder where all mods you make can go. -->
+                                <copy file="target/${project.artifactId}.jar" tofile="${Steam.path}/common/SlayTheSpire/mods/${project.artifactId}.jar"/>
+                            </target>
+                        </configuration>
+                        <goals>
+                            <goal>run</goal>
+                        </goals>
+                    </execution>
+                </executions>
+            </plugin>
+        </plugins>
+
+        <resources>
+            <resource>
+                <directory>src/main/resources</directory>
+            </resource>
+            <resource>
+                <directory>src/main/resources</directory>
+                <filtering>false</filtering>
+                <excludes>
+                    <exclude>ModTheSpire.json</exclude>
+                </excludes>
+            </resource>
+            <resource>
+                <directory>src/main/resources</directory>
+                <filtering>true</filtering>
+                <includes>
+                    <include>ModTheSpire.json</include>
+                </includes>
+            </resource>
+        </resources>
+    </build>
+</project>

src/main/java/hemomancer/HemomancerMod.java

@@ -0,0 +1,375 @@
+package hemomancer;
+
+import basemod.BaseMod;
+import basemod.ModLabeledToggleButton;
+import basemod.ModPanel;
+import basemod.interfaces.*;
+import com.badlogic.gdx.Gdx;
+import com.badlogic.gdx.files.FileHandle;
+import com.badlogic.gdx.graphics.Color;
+import com.badlogic.gdx.graphics.Texture;
+import com.badlogic.gdx.utils.compression.lzma.Base;
+import com.evacipated.cardcrawl.mod.stslib.Keyword;
+import com.evacipated.cardcrawl.modthespire.lib.SpireConfig;
+import com.evacipated.cardcrawl.modthespire.lib.SpireInitializer;
+import com.google.gson.Gson;
+import com.megacrit.cardcrawl.core.Settings;
+import com.megacrit.cardcrawl.dungeons.TheCity;
+import com.megacrit.cardcrawl.helpers.CardHelper;
+import com.megacrit.cardcrawl.helpers.FontHelper;
+import com.megacrit.cardcrawl.localization.*;
+import com.megacrit.cardcrawl.unlock.UnlockTracker;
+import hemomancer.relics.BloodMistRelic;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import hemomancer.cards.*;
+import hemomancer.characters.Hemomancer;
+import hemomancer.events.IdentityCrisisEvent;
+import hemomancer.potions.PlaceholderPotion;
+import hemomancer.relics.BottledPlaceholderRelic;
+import hemomancer.util.IDCheckDontTouchPls;
+import hemomancer.util.TextureLoader;
+import hemomancer.variables.DefaultCustomVariable;
+import hemomancer.variables.DefaultSecondMagicNumber;
+
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.nio.charset.StandardCharsets;
+import java.util.Properties;
+
+@SpireInitializer
+public class HemomancerMod implements
+        EditCardsSubscriber,
+        EditRelicsSubscriber,
+        EditStringsSubscriber,
+        EditKeywordsSubscriber,
+        EditCharactersSubscriber,
+        PostInitializeSubscriber {
+    
+    public static final Logger logger = LogManager.getLogger(HemomancerMod.class.getName());
+    private static String modID;
+    
+    public static Properties theDefaultDefaultSettings = new Properties();
+    public static final String ENABLE_PLACEHOLDER_SETTINGS = "enablePlaceholder";
+    public static boolean enablePlaceholder = true;
+    
+    private static final String MODNAME = "hemomancer";
+    private static final String AUTHOR = "Virgil";
+    private static final String DESCRIPTION = "A bloodmage character for Slay the Spire.";
+    
+    public static final Color DEFAULT_GRAY = CardHelper.getColor(64.0f, 10.0f, 50.0f);
+    
+    public static final Color PLACEHOLDER_POTION_LIQUID = CardHelper.getColor(209.0f, 53.0f, 18.0f);
+    public static final Color PLACEHOLDER_POTION_HYBRID = CardHelper.getColor(255.0f, 230.0f, 230.0f);
+    public static final Color PLACEHOLDER_POTION_SPOTS = CardHelper.getColor(100.0f, 25.0f, 10.0f);
+    
+    private static final String ATTACK_DEFAULT_GRAY = "hemomancerResources/images/512/bg_attack_default_gray.png";
+    private static final String SKILL_DEFAULT_GRAY = "hemomancerResources/images/512/bg_skill_default_gray.png";
+    private static final String POWER_DEFAULT_GRAY = "hemomancerResources/images/512/bg_power_default_gray.png";
+    
+    private static final String ENERGY_ORB_DEFAULT_GRAY = "hemomancerResources/images/512/card_default_gray_orb.png";
+    private static final String CARD_ENERGY_ORB = "hemomancerResources/images/512/card_small_orb.png";
+    
+    private static final String ATTACK_DEFAULT_GRAY_PORTRAIT = "hemomancerResources/images/1024/bg_attack_default_gray.png";
+    private static final String SKILL_DEFAULT_GRAY_PORTRAIT = "hemomancerResources/images/1024/bg_skill_default_gray.png";
+    private static final String POWER_DEFAULT_GRAY_PORTRAIT = "hemomancerResources/images/1024/bg_power_default_gray.png";
+    private static final String ENERGY_ORB_DEFAULT_GRAY_PORTRAIT = "hemomancerResources/images/1024/card_default_gray_orb.png";
+    
+    private static final String THE_DEFAULT_BUTTON = "hemomancerResources/images/charSelect/DefaultCharacterButton.png";
+    private static final String THE_DEFAULT_PORTRAIT = "hemomancerResources/images/charSelect/DefaultCharacterPortraitBG.png";
+    public static final String THE_DEFAULT_SHOULDER_1 = "hemomancerResources/images/char/defaultCharacter/shoulder.png";
+    public static final String THE_DEFAULT_SHOULDER_2 = "hemomancerResources/images/char/defaultCharacter/shoulder2.png";
+    public static final String THE_DEFAULT_CORPSE = "hemomancerResources/images/char/defaultCharacter/corpse.png";
+    
+    public static final String BADGE_IMAGE = "hemomancerResources/images/Badge.png";
+    
+    public static final String THE_DEFAULT_SKELETON_ATLAS = "hemomancerResources/images/char/defaultCharacter/skeleton.atlas";
+    public static final String THE_DEFAULT_SKELETON_JSON = "hemomancerResources/images/char/defaultCharacter/skeleton.json";
+    
+    public static String makeCardPath(String resourcePath) {
+        return getModID() + "Resources/images/cards/" + resourcePath;
+    }
+    
+    public static String makeRelicPath(String resourcePath) {
+        return getModID() + "Resources/images/relics/" + resourcePath;
+    }
+    
+    public static String makeRelicOutlinePath(String resourcePath) {
+        return getModID() + "Resources/images/relics/outline/" + resourcePath;
+    }
+    
+    public static String makeOrbPath(String resourcePath) {
+        return getModID() + "Resources/images/orbs/" + resourcePath;
+    }
+    
+    public static String makePowerPath(String resourcePath) {
+        return getModID() + "Resources/images/powers/" + resourcePath;
+    }
+    
+    public static String makeEventPath(String resourcePath) {
+        return getModID() + "Resources/images/events/" + resourcePath;
+    }
+    
+    public HemomancerMod() {
+        
+        setModID("hemomancer");
+        
+        
+
+        logger.info("Creating the color " + Hemomancer.Enums.COLOR_GRAY.toString());
+        
+        BaseMod.addColor(Hemomancer.Enums.COLOR_GRAY, DEFAULT_GRAY, DEFAULT_GRAY, DEFAULT_GRAY,
+                DEFAULT_GRAY, DEFAULT_GRAY, DEFAULT_GRAY, DEFAULT_GRAY,
+                ATTACK_DEFAULT_GRAY, SKILL_DEFAULT_GRAY, POWER_DEFAULT_GRAY, ENERGY_ORB_DEFAULT_GRAY,
+                ATTACK_DEFAULT_GRAY_PORTRAIT, SKILL_DEFAULT_GRAY_PORTRAIT, POWER_DEFAULT_GRAY_PORTRAIT,
+                ENERGY_ORB_DEFAULT_GRAY_PORTRAIT, CARD_ENERGY_ORB);
+        
+        logger.info("Done creating the color");
+        
+        
+        logger.info("Adding mod settings");
+        
+        
+        theDefaultDefaultSettings.setProperty(ENABLE_PLACEHOLDER_SETTINGS, "FALSE");
+        try {
+            SpireConfig config = new SpireConfig("defaultMod", "theDefaultConfig", theDefaultDefaultSettings);
+            
+            config.load();
+            enablePlaceholder = config.getBool(ENABLE_PLACEHOLDER_SETTINGS);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        logger.info("Done adding mod settings");
+    }
+    
+    public static void setModID(String ID) {
+        Gson coolG = new Gson();
+        
+        InputStream in = HemomancerMod.class.getResourceAsStream("/IDCheckStringsDONT-EDIT-AT-ALL.json");
+        IDCheckDontTouchPls EXCEPTION_STRINGS = coolG.fromJson(new InputStreamReader(in, StandardCharsets.UTF_8), IDCheckDontTouchPls.class);
+        logger.info("You are attempting to set your mod ID as: " + ID);
+        if (ID.equals(EXCEPTION_STRINGS.DEFAULTID)) {
+            throw new RuntimeException(EXCEPTION_STRINGS.EXCEPTION);
+        } else if (ID.equals(EXCEPTION_STRINGS.DEVID)) {
+            modID = EXCEPTION_STRINGS.DEFAULTID;
+        } else {
+            modID = ID;
+        }
+        logger.info("Success! ID is " + modID);
+    }
+    
+    public static String getModID() {
+        return modID;
+    }
+    
+    private static void pathCheck() {
+        Gson coolG = new Gson();
+        
+        InputStream in = HemomancerMod.class.getResourceAsStream("/IDCheckStringsDONT-EDIT-AT-ALL.json");
+        IDCheckDontTouchPls EXCEPTION_STRINGS = coolG.fromJson(new InputStreamReader(in, StandardCharsets.UTF_8), IDCheckDontTouchPls.class);
+        String packageName = HemomancerMod.class.getPackage().getName();
+        FileHandle resourcePathExists = Gdx.files.internal(getModID() + "Resources");
+        if (!modID.equals(EXCEPTION_STRINGS.DEVID)) {
+            if (!packageName.equals(getModID())) {
+                throw new RuntimeException(EXCEPTION_STRINGS.PACKAGE_EXCEPTION + getModID());
+            }
+            if (!resourcePathExists.exists()) {
+                throw new RuntimeException(EXCEPTION_STRINGS.RESOURCE_FOLDER_EXCEPTION + getModID() + "Resources");
+            }
+        }
+    }
+    
+    @SuppressWarnings("unused")
+    public static void initialize() {
+        logger.info("========================= Initializing Default Mod. Hi. =========================");
+        BaseMod.subscribe(new HemomancerMod());
+        logger.info("========================= /Default Mod Initialized. Hello World./ =========================");
+    }
+    
+    @Override
+    public void receiveEditCharacters() {
+        logger.info("Beginning to edit characters. " + "Add " + Hemomancer.Enums.THE_DEFAULT.toString());
+        
+        BaseMod.addCharacter(new Hemomancer("Hemomancer", Hemomancer.Enums.THE_DEFAULT),
+                THE_DEFAULT_BUTTON, THE_DEFAULT_PORTRAIT, Hemomancer.Enums.THE_DEFAULT);
+        
+        receiveEditPotions();
+        logger.info("Added " + Hemomancer.Enums.THE_DEFAULT.toString());
+    }
+    
+    @Override
+    public void receivePostInitialize() {
+        logger.info("Loading badge image and mod options");
+        
+        
+        Texture badgeTexture = TextureLoader.getTexture(BADGE_IMAGE);
+        
+        
+        ModPanel settingsPanel = new ModPanel();
+        
+        
+        ModLabeledToggleButton enableNormalsButton = new ModLabeledToggleButton("This is the text which goes next to the checkbox.",
+                350.0f, 700.0f, Settings.CREAM_COLOR, FontHelper.charDescFont,
+                enablePlaceholder,
+                settingsPanel,
+                (label) -> {
+                },
+                (button) -> {
+                    
+                    enablePlaceholder = button.enabled;
+                    try {
+                        
+                        SpireConfig config = new SpireConfig("defaultMod", "theDefaultConfig", theDefaultDefaultSettings);
+                        config.setBool(ENABLE_PLACEHOLDER_SETTINGS, enablePlaceholder);
+                        config.save();
+                    } catch (Exception e) {
+                        e.printStackTrace();
+                    }
+                });
+        
+        settingsPanel.addUIElement(enableNormalsButton);
+        
+        BaseMod.registerModBadge(badgeTexture, MODNAME, AUTHOR, DESCRIPTION, settingsPanel);
+        
+        
+        BaseMod.addEvent(IdentityCrisisEvent.ID, IdentityCrisisEvent.class, TheCity.ID);
+        
+        
+        logger.info("Done loading badge Image and mod options");
+    }
+    
+    public void receiveEditPotions() {
+        logger.info("Beginning to edit potions");
+        
+        
+        BaseMod.addPotion(PlaceholderPotion.class, PLACEHOLDER_POTION_LIQUID, PLACEHOLDER_POTION_HYBRID, PLACEHOLDER_POTION_SPOTS, PlaceholderPotion.POTION_ID, Hemomancer.Enums.THE_DEFAULT);
+        
+        logger.info("Done editing potions");
+    }
+    
+    @Override
+    public void receiveEditRelics() {
+        logger.info("Adding relics");
+        
+        
+        BaseMod.addRelicToCustomPool(new BloodMistRelic(), Hemomancer.Enums.COLOR_GRAY);
+
+
+
+        
+        UnlockTracker.markRelicAsSeen(BottledPlaceholderRelic.ID);
+        logger.info("Done adding relics!");
+    }
+    
+    @Override
+    public void receiveEditCards() {
+        logger.info("Adding variables");
+        
+        pathCheck();
+        
+        logger.info("Add variabls");
+        
+        BaseMod.addDynamicVariable(new DefaultCustomVariable());
+        BaseMod.addDynamicVariable(new DefaultSecondMagicNumber());
+        
+        logger.info("Adding cards");
+
+        BaseMod.addCard(new HemomancerStrike());
+        BaseMod.addCard(new HemomancerBlock());
+        BaseMod.addCard(new HemomancerBloodPump());
+        BaseMod.addCard(new HemomancerFlay());
+
+        BaseMod.addCard(new HemomancerPHA1());
+        BaseMod.addCard(new HemomancerPHA2());
+        BaseMod.addCard(new HemomancerPHA3());
+        BaseMod.addCard(new HemomancerPHA4());
+        BaseMod.addCard(new HemomancerPHA5());
+
+        BaseMod.addCard(new HemomancerPHS1());
+        BaseMod.addCard(new HemomancerPHS2());
+        BaseMod.addCard(new HemomancerPHS3());
+        BaseMod.addCard(new HemomancerPHS4());
+        BaseMod.addCard(new HemomancerPHS5());
+
+        BaseMod.addCard(new HemomancerPHP1());
+        BaseMod.addCard(new HemomancerPHP2());
+        BaseMod.addCard(new HemomancerPHP3());
+
+
+        UnlockTracker.unlockCard(HemomancerStrike.ID);
+        UnlockTracker.unlockCard(HemomancerBlock.ID);
+        UnlockTracker.unlockCard(HemomancerBloodPump.ID);
+        UnlockTracker.unlockCard(HemomancerFlay.ID);
+        UnlockTracker.unlockCard(HemomancerPHA1.ID);
+        UnlockTracker.unlockCard(HemomancerPHA2.ID);
+        UnlockTracker.unlockCard(HemomancerPHA3.ID);
+        UnlockTracker.unlockCard(HemomancerPHA4.ID);
+        UnlockTracker.unlockCard(HemomancerPHA5.ID);
+        UnlockTracker.unlockCard(HemomancerPHS1.ID);
+        UnlockTracker.unlockCard(HemomancerPHS2.ID);
+        UnlockTracker.unlockCard(HemomancerPHS3.ID);
+        UnlockTracker.unlockCard(HemomancerPHS4.ID);
+        UnlockTracker.unlockCard(HemomancerPHS5.ID);
+        UnlockTracker.unlockCard(HemomancerPHP1.ID);
+        UnlockTracker.unlockCard(HemomancerPHP2.ID);
+        UnlockTracker.unlockCard(HemomancerPHP3.ID);
+
+        
+        logger.info("Done adding cards!");
+    }
+    
+    @Override
+    public void receiveEditStrings() {
+        logger.info("You seeing this?");
+        logger.info("Beginning to edit strings for mod with ID: " + getModID());
+        
+        
+        BaseMod.loadCustomStringsFile(CardStrings.class,
+                getModID() + "Resources/localization/eng/HemomancerMod-Card-Strings.json");
+        
+        
+        BaseMod.loadCustomStringsFile(PowerStrings.class,
+                getModID() + "Resources/localization/eng/HemomancerMod-Power-Strings.json");
+        
+        
+        BaseMod.loadCustomStringsFile(RelicStrings.class,
+                getModID() + "Resources/localization/eng/HemomancerMod-Relic-Strings.json");
+        
+        
+        BaseMod.loadCustomStringsFile(EventStrings.class,
+                getModID() + "Resources/localization/eng/HemomancerMod-Event-Strings.json");
+        
+        
+        BaseMod.loadCustomStringsFile(PotionStrings.class,
+                getModID() + "Resources/localization/eng/HemomancerMod-Potion-Strings.json");
+        
+        
+        BaseMod.loadCustomStringsFile(CharacterStrings.class,
+                getModID() + "Resources/localization/eng/HemomancerMod-Character-Strings.json");
+        
+        
+        BaseMod.loadCustomStringsFile(OrbStrings.class,
+                getModID() + "Resources/localization/eng/HemomancerMod-Orb-Strings.json");
+        
+        logger.info("Done edittting strings");
+    }
+    
+    @Override
+    public void receiveEditKeywords() {
+        
+        
+        Gson gson = new Gson();
+        String json = Gdx.files.internal(getModID() + "Resources/localization/eng/HemomancerMod-Keyword-Strings.json").readString(String.valueOf(StandardCharsets.UTF_8));
+        com.evacipated.cardcrawl.mod.stslib.Keyword[] keywords = gson.fromJson(json, com.evacipated.cardcrawl.mod.stslib.Keyword[].class);
+        
+        if (keywords != null) {
+            for (Keyword keyword : keywords) {
+                BaseMod.addKeyword(getModID().toLowerCase(), keyword.PROPER_NAME, keyword.NAMES, keyword.DESCRIPTION);
+            }
+        }
+    }
+    
+    public static String makeID(String idText) {
+        return getModID() + ":" + idText;
+    }
+}

src/main/java/hemomancer/actions/UncommonPowerAction.java

@@ -0,0 +1,59 @@
+package hemomancer.actions;
+
+import com.megacrit.cardcrawl.actions.AbstractGameAction;
+import com.megacrit.cardcrawl.actions.common.ApplyPowerAction;
+import com.megacrit.cardcrawl.cards.DamageInfo;
+import com.megacrit.cardcrawl.characters.AbstractPlayer;
+import com.megacrit.cardcrawl.dungeons.AbstractDungeon;
+import com.megacrit.cardcrawl.monsters.AbstractMonster;
+import com.megacrit.cardcrawl.relics.ChemicalX;
+import com.megacrit.cardcrawl.ui.panels.EnergyPanel;
+import hemomancer.powers.CommonPower;
+
+public class UncommonPowerAction extends AbstractGameAction {
+    private boolean freeToPlayOnce;
+    private int magicNumber;
+    private AbstractPlayer p;
+    private int energyOnUse;
+    private boolean upgraded;
+    
+    public UncommonPowerAction(final AbstractPlayer p, final AbstractMonster m,
+                               final int magicNumber, final boolean upgraded,
+                               final DamageInfo.DamageType damageTypeForTurn, final boolean freeToPlayOnce,
+                               final int energyOnUse) {
+        this.freeToPlayOnce = false;
+        this.p = p;
+        this.magicNumber = magicNumber;
+        this.freeToPlayOnce = freeToPlayOnce;
+        actionType = ActionType.SPECIAL;
+        this.energyOnUse = energyOnUse;
+        this.upgraded = upgraded;
+    }
+    
+    @Override
+    public void update() {
+        int effect = EnergyPanel.totalCount;
+        if (energyOnUse != -1) {
+            effect = energyOnUse;
+        }
+        if (p.hasRelic(ChemicalX.ID)) {
+            effect += 2;
+            p.getRelic(ChemicalX.ID).flash();
+        }
+        if (upgraded) {
+            ++effect;
+        }
+        if (effect > 0) {
+            for (int i = 0; i < effect; ++i) {
+                
+                AbstractDungeon.actionManager.addToBottom(new ApplyPowerAction(p, p,
+                        new CommonPower(p, p, magicNumber), magicNumber,
+                        AttackEffect.BLUNT_LIGHT));
+            }
+            if (!freeToPlayOnce) {
+                p.energy.use(EnergyPanel.totalCount);
+            }
+        }
+        isDone = true;
+    }
+}

src/main/java/hemomancer/cards/AbstractDynamicCard.java

@@ -0,0 +1,17 @@
+package hemomancer.cards;
+
+import static com.megacrit.cardcrawl.core.CardCrawlGame.languagePack;
+
+public abstract class AbstractDynamicCard extends AbstractHemomancerCard {
+    
+    public AbstractDynamicCard(final String id,
+                               final String img,
+                               final int cost,
+                               final CardType type,
+                               final CardColor color,
+                               final CardRarity rarity,
+                               final CardTarget target) {
+        
+        super(id, languagePack.getCardStrings(id).NAME, img, cost, languagePack.getCardStrings(id).DESCRIPTION, type, color, rarity, target);
+    }
+}

src/main/java/hemomancer/cards/AbstractHemomancerCard.java

@@ -0,0 +1,44 @@
+package hemomancer.cards;
+
+import basemod.abstracts.CustomCard;
+
+public abstract class AbstractHemomancerCard extends CustomCard {
+    
+    public int defaultSecondMagicNumber;
+    public int defaultBaseSecondMagicNumber;
+    public boolean upgradedDefaultSecondMagicNumber;
+    public boolean isDefaultSecondMagicNumberModified;
+    
+    public AbstractHemomancerCard(final String id,
+                                  final String name,
+                                  final String img,
+                                  final int cost,
+                                  final String rawDescription,
+                                  final CardType type,
+                                  final CardColor color,
+                                  final CardRarity rarity,
+                                  final CardTarget target) {
+        
+        super(id, name, img, cost, rawDescription, type, color, rarity, target);
+        isCostModified = false;
+        isCostModifiedForTurn = false;
+        isDamageModified = false;
+        isBlockModified = false;
+        isMagicNumberModified = false;
+        isDefaultSecondMagicNumberModified = false;
+    }
+    
+    public void displayUpgrades() {
+        super.displayUpgrades();
+        if (upgradedDefaultSecondMagicNumber) {
+            defaultSecondMagicNumber = defaultBaseSecondMagicNumber;
+            isDefaultSecondMagicNumberModified = true;
+        }
+    }
+    
+    public void upgradeDefaultSecondMagicNumber(int amount) {
+        defaultBaseSecondMagicNumber += amount;
+        defaultSecondMagicNumber = defaultBaseSecondMagicNumber;
+        upgradedDefaultSecondMagicNumber = true;
+    }
+}

src/main/java/hemomancer/cards/CardTemplate.java

@@ -0,0 +1,50 @@
+package hemomancer.cards;
+
+import com.megacrit.cardcrawl.actions.AbstractGameAction;
+import com.megacrit.cardcrawl.actions.common.DamageAction;
+import com.megacrit.cardcrawl.cards.DamageInfo;
+import com.megacrit.cardcrawl.characters.AbstractPlayer;
+import com.megacrit.cardcrawl.dungeons.AbstractDungeon;
+import com.megacrit.cardcrawl.monsters.AbstractMonster;
+import hemomancer.HemomancerMod;
+import hemomancer.characters.Hemomancer;
+
+import static hemomancer.HemomancerMod.makeCardPath;
+
+public class CardTemplate extends AbstractDynamicCard {
+    
+    public static final String ID = HemomancerMod.makeID("DefaultCommonAttack");
+    public static final String IMG = makeCardPath("Attack.png");
+    
+    private static final CardRarity RARITY = CardRarity.COMMON;
+    private static final CardTarget TARGET = CardTarget.ENEMY;
+    private static final CardType TYPE = CardType.ATTACK;
+    public static final CardColor COLOR = Hemomancer.Enums.COLOR_GRAY;
+    
+    private static final int COST = 1;
+    private static final int UPGRADED_COST = 0;
+    
+    private static final int DAMAGE = 7;
+    private static final int UPGRADE_PLUS_DMG = 2;
+    
+    public CardTemplate() {
+        super(ID, IMG, COST, TYPE, COLOR, RARITY, TARGET);
+        baseDamage = DAMAGE;
+    }
+    
+    @Override
+    public void use(AbstractPlayer p, AbstractMonster m) {
+        AbstractDungeon.actionManager.addToBottom(
+                new DamageAction(m, new DamageInfo(p, damage, damageTypeForTurn), AbstractGameAction.AttackEffect.SLASH_HORIZONTAL));
+    }
+    
+    @Override
+    public void upgrade() {
+        if (!upgraded) {
+            upgradeName();
+            upgradeDamage(UPGRADE_PLUS_DMG);
+            upgradeBaseCost(UPGRADED_COST);
+            initializeDescription();
+        }
+    }
+}

src/main/java/hemomancer/cards/HemomancerAttackWithVariable.java

@@ -0,0 +1,55 @@
+package hemomancer.cards;
+
+import com.megacrit.cardcrawl.actions.AbstractGameAction;
+import com.megacrit.cardcrawl.actions.common.DamageAction;
+import com.megacrit.cardcrawl.cards.DamageInfo;
+import com.megacrit.cardcrawl.characters.AbstractPlayer;
+import com.megacrit.cardcrawl.dungeons.AbstractDungeon;
+import com.megacrit.cardcrawl.monsters.AbstractMonster;
+import com.megacrit.cardcrawl.ui.panels.EnergyPanel;
+import hemomancer.HemomancerMod;
+import hemomancer.characters.Hemomancer;
+
+import static hemomancer.HemomancerMod.makeCardPath;
+
+public class HemomancerAttackWithVariable extends AbstractDynamicCard {
+    
+    public static final String ID = HemomancerMod.makeID(HemomancerAttackWithVariable.class.getSimpleName());
+    public static final String IMG = makeCardPath("Attack.png");
+    
+    private static final CardRarity RARITY = CardRarity.COMMON;
+    private static final CardTarget TARGET = CardTarget.ENEMY;
+    private static final CardType TYPE = CardType.ATTACK;
+    public static final CardColor COLOR = Hemomancer.Enums.COLOR_GRAY;
+    
+    private static final int COST = 1;
+    private static final int DAMAGE = 7;
+    private static final int UPGRADE_PLUS_DMG = 1;
+    
+    public int specialDamage;
+    
+    public HemomancerAttackWithVariable() {
+        super(ID, IMG, COST, TYPE, COLOR, RARITY, TARGET);
+        baseDamage = DAMAGE;
+        isMultiDamage = true;
+    }
+    
+    @Override
+    public void use(AbstractPlayer p, AbstractMonster m) {
+        int effect = EnergyPanel.totalCount;
+        for (int i = 0; i < effect; i++) {
+            AbstractDungeon.actionManager.addToBottom(
+                    new DamageAction(m, new DamageInfo(p, damage, damageTypeForTurn),
+                            AbstractGameAction.AttackEffect.FIRE));
+        }
+    }
+    
+    @Override
+    public void upgrade() {
+        if (!upgraded) {
+            upgradeName();
+            upgradeDamage(UPGRADE_PLUS_DMG);
+            initializeDescription();
+        }
+    }
+}

src/main/java/hemomancer/cards/HemomancerBlock.java

@@ -0,0 +1,46 @@
+package hemomancer.cards;
+
+import basemod.helpers.BaseModCardTags;
+import com.megacrit.cardcrawl.actions.common.GainBlockAction;
+import com.megacrit.cardcrawl.characters.AbstractPlayer;
+import com.megacrit.cardcrawl.dungeons.AbstractDungeon;
+import com.megacrit.cardcrawl.monsters.AbstractMonster;
+import hemomancer.HemomancerMod;
+import hemomancer.characters.Hemomancer;
+
+import static hemomancer.HemomancerMod.makeCardPath;
+
+public class HemomancerBlock extends AbstractDynamicCard {
+    
+    public static final String ID = HemomancerMod.makeID(HemomancerBlock.class.getSimpleName());
+    public static final String IMG = makeCardPath("blood_block.png");
+    
+    private static final CardRarity RARITY = CardRarity.BASIC;
+    private static final CardTarget TARGET = CardTarget.SELF;
+    private static final CardType TYPE = CardType.SKILL;
+    public static final CardColor COLOR = Hemomancer.Enums.COLOR_GRAY;
+    
+    private static final int COST = 1;
+    private static final int BLOCK = 5;
+    private static final int UPGRADE_PLUS_BLOCK = 3;
+    
+    public HemomancerBlock() {
+        super(ID, IMG, COST, TYPE, COLOR, RARITY, TARGET);
+        baseBlock = BLOCK;
+        this.tags.add(BaseModCardTags.BASIC_DEFEND);
+    }
+    
+    @Override
+    public void use(AbstractPlayer p, AbstractMonster m) {
+        AbstractDungeon.actionManager.addToBottom(new GainBlockAction(p, p, block));
+    }
+    
+    @Override
+    public void upgrade() {
+        if (!upgraded) {
+            upgradeName();
+            upgradeBlock(UPGRADE_PLUS_BLOCK);
+            initializeDescription();
+        }
+    }
+}

src/main/java/hemomancer/cards/HemomancerBloodPump.java

@@ -0,0 +1,45 @@
+package hemomancer.cards;
+
+import com.megacrit.cardcrawl.characters.AbstractPlayer;
+import com.megacrit.cardcrawl.core.CardCrawlGame;
+import com.megacrit.cardcrawl.localization.CardStrings;
+import com.megacrit.cardcrawl.monsters.AbstractMonster;
+import hemomancer.HemomancerMod;
+import hemomancer.characters.Hemomancer;
+import hemomancer.orbs.BloodMistOrb;
+
+
+public class HemomancerBloodPump extends AbstractDynamicCard {
+    public static final String ID = HemomancerMod.makeID("BloodPump");
+    private static final CardStrings cardStrings = CardCrawlGame.languagePack.getCardStrings(ID);
+
+
+    private int pumpValue = 1;
+
+    public HemomancerBloodPump() {
+        super(
+                ID,
+                HemomancerMod.makeCardPath("blood_pump.png"),
+                1,
+                CardType.SKILL,
+                Hemomancer.Enums.COLOR_GRAY,
+                CardRarity.BASIC,
+                CardTarget.SELF
+        );
+    }
+
+    @Override
+    public void upgrade() {
+        if (!this.upgraded) {
+            this.upgradeName();
+            this.rawDescription = cardStrings.UPGRADE_DESCRIPTION;
+            pumpValue = 2;
+        }
+    }
+
+    @Override
+    public void use(AbstractPlayer player, AbstractMonster monster) {
+        BloodMistOrb orb = BloodMistOrb.getBloodMistOrb(player);
+        orb.pump(pumpValue);
+    }
+}

src/main/java/hemomancer/cards/HemomancerCommonPower.java

@@ -0,0 +1,52 @@
+package hemomancer.cards;
+
+import com.megacrit.cardcrawl.actions.common.ApplyPowerAction;
+import com.megacrit.cardcrawl.characters.AbstractPlayer;
+import com.megacrit.cardcrawl.core.CardCrawlGame;
+import com.megacrit.cardcrawl.dungeons.AbstractDungeon;
+import com.megacrit.cardcrawl.localization.CardStrings;
+import com.megacrit.cardcrawl.monsters.AbstractMonster;
+import hemomancer.HemomancerMod;
+import hemomancer.characters.Hemomancer;
+import hemomancer.powers.CommonPower;
+
+import static hemomancer.HemomancerMod.makeCardPath;
+
+public class HemomancerCommonPower extends AbstractDynamicCard {
+    
+    public static final String ID = HemomancerMod.makeID(HemomancerCommonPower.class.getSimpleName());
+    public static final String IMG = makeCardPath("Power.png");
+    
+    private static final CardStrings cardStrings = CardCrawlGame.languagePack.getCardStrings(ID);
+    public static final String UPGRADE_DESCRIPTION = cardStrings.UPGRADE_DESCRIPTION;
+    
+    private static final CardRarity RARITY = CardRarity.COMMON;
+    private static final CardTarget TARGET = CardTarget.SELF;
+    private static final CardType TYPE = CardType.POWER;
+    public static final CardColor COLOR = Hemomancer.Enums.COLOR_GRAY;
+    
+    private static final int COST = 1;
+    private static final int MAGIC = 1;
+    private static final int UPGRADE_MAGIC = 1;
+    
+    public HemomancerCommonPower() {
+        super(ID, IMG, COST, TYPE, COLOR, RARITY, TARGET);
+        magicNumber = baseMagicNumber = MAGIC;
+    }
+    
+    @Override
+    public void use(AbstractPlayer p, AbstractMonster m) {
+        AbstractDungeon.actionManager.addToBottom(new ApplyPowerAction(p, p,
+                new CommonPower(p, p, magicNumber), magicNumber));
+    }
+    
+    @Override
+    public void upgrade() {
+        if (!upgraded) {
+            upgradeName();
+            upgradeMagicNumber(UPGRADE_MAGIC);
+            rawDescription = UPGRADE_DESCRIPTION;
+            initializeDescription();
+        }
+    }
+}

src/main/java/hemomancer/cards/HemomancerFlay.java

@@ -0,0 +1,66 @@
+package hemomancer.cards;
+
+import basemod.abstracts.CustomCard;
+import basemod.helpers.BaseModCardTags;
+import com.megacrit.cardcrawl.actions.AbstractGameAction;
+import com.megacrit.cardcrawl.actions.common.DamageAction;
+import com.megacrit.cardcrawl.cards.DamageInfo;
+import com.megacrit.cardcrawl.characters.AbstractPlayer;
+import com.megacrit.cardcrawl.core.CardCrawlGame;
+import com.megacrit.cardcrawl.dungeons.AbstractDungeon;
+import com.megacrit.cardcrawl.localization.CardStrings;
+import com.megacrit.cardcrawl.monsters.AbstractMonster;
+import hemomancer.HemomancerMod;
+import hemomancer.characters.Hemomancer;
+import hemomancer.orbs.BloodMistOrb;
+
+import static hemomancer.HemomancerMod.makeCardPath;
+
+public class HemomancerFlay extends CustomCard {
+
+    public static final String ID = HemomancerMod.makeID(HemomancerFlay.class.getSimpleName());
+    private static final CardStrings cardStrings = CardCrawlGame.languagePack.getCardStrings(ID);
+
+    public static final String IMG = makeCardPath("blood_flay.png");
+
+    public static final String NAME = cardStrings.NAME;
+    public static final String DESCRIPTION = cardStrings.DESCRIPTION;
+
+    private static final CardRarity RARITY = CardRarity.BASIC;
+    private static final CardTarget TARGET = CardTarget.ENEMY;
+    private static final CardType TYPE = CardType.ATTACK;
+    public static final CardColor COLOR = Hemomancer.Enums.COLOR_GRAY;
+
+    private static final int COST = 1;
+    private static final int DAMAGE = 10;
+    private static final int UPGRADE_PLUS_DMG = 4;
+
+    private static final int maxHPDecrease = 5;
+
+    public HemomancerFlay(){
+        super(ID, NAME, IMG, COST, DESCRIPTION, TYPE, COLOR, RARITY, TARGET);
+        baseDamage = DAMAGE;
+    }
+
+    @Override
+    public void upgrade() {
+        if (!upgraded) {
+            upgradeName();
+            upgradeDamage(UPGRADE_PLUS_DMG);
+            initializeDescription();
+        }
+    }
+
+    @Override
+    public void use(AbstractPlayer p, AbstractMonster m) {
+        AbstractDungeon.actionManager.addToBottom(
+                new DamageAction(m, new DamageInfo(p, damage, damageTypeForTurn),
+                        AbstractGameAction.AttackEffect.SLASH_HORIZONTAL));
+        BloodMistOrb orb = BloodMistOrb.getBloodMistOrb(p);
+        if(orb == null){
+            p.decreaseMaxHealth(maxHPDecrease);
+        }else{
+            orb.consume(p, maxHPDecrease);
+        }
+    }
+}

src/main/java/hemomancer/cards/HemomancerPHA1.java

@@ -0,0 +1,59 @@
+package hemomancer.cards;
+
+import basemod.abstracts.CustomCard;
+import basemod.helpers.BaseModCardTags;
+import com.megacrit.cardcrawl.actions.AbstractGameAction;
+import com.megacrit.cardcrawl.actions.common.DamageAction;
+import com.megacrit.cardcrawl.cards.DamageInfo;
+import com.megacrit.cardcrawl.characters.AbstractPlayer;
+import com.megacrit.cardcrawl.core.CardCrawlGame;
+import com.megacrit.cardcrawl.dungeons.AbstractDungeon;
+import com.megacrit.cardcrawl.localization.CardStrings;
+import com.megacrit.cardcrawl.monsters.AbstractMonster;
+import hemomancer.HemomancerMod;
+import hemomancer.characters.Hemomancer;
+
+import static hemomancer.HemomancerMod.makeCardPath;
+
+public class HemomancerPHA1 extends CustomCard {
+
+    public static final String ID = HemomancerMod.makeID(HemomancerPHA1.class.getSimpleName());
+    private static final CardStrings cardStrings = CardCrawlGame.languagePack.getCardStrings(ID);
+
+    public static final String IMG = makeCardPath("blood_attack.png");
+
+    public static final String NAME = cardStrings.NAME;
+    public static final String DESCRIPTION = cardStrings.DESCRIPTION;
+
+    private static final CardRarity RARITY = CardRarity.UNCOMMON;
+    private static final CardTarget TARGET = CardTarget.ENEMY;
+    private static final CardType TYPE = CardType.ATTACK;
+    public static final CardColor COLOR = Hemomancer.Enums.COLOR_GRAY;
+
+    private static final int COST = 1;
+    private static final int DAMAGE = 6;
+    private static final int UPGRADE_PLUS_DMG = 3;
+
+    public HemomancerPHA1() {
+        super(ID, NAME, IMG, COST, DESCRIPTION, TYPE, COLOR, RARITY, TARGET);
+        baseDamage = DAMAGE;
+        this.tags.add(BaseModCardTags.BASIC_STRIKE);
+        this.tags.add(CardTags.STRIKE);
+    }
+    
+    @Override
+    public void use(AbstractPlayer p, AbstractMonster m) {
+        AbstractDungeon.actionManager.addToBottom(
+                new DamageAction(m, new DamageInfo(p, damage, damageTypeForTurn),
+                        AbstractGameAction.AttackEffect.SLASH_HORIZONTAL));
+    }
+    
+    @Override
+    public void upgrade() {
+        if (!upgraded) {
+            upgradeName();
+            upgradeDamage(UPGRADE_PLUS_DMG);
+            initializeDescription();
+        }
+    }
+}

src/main/java/hemomancer/cards/HemomancerPHA2.java

@@ -0,0 +1,59 @@
+package hemomancer.cards;
+
+import basemod.abstracts.CustomCard;
+import basemod.helpers.BaseModCardTags;
+import com.megacrit.cardcrawl.actions.AbstractGameAction;
+import com.megacrit.cardcrawl.actions.common.DamageAction;
+import com.megacrit.cardcrawl.cards.DamageInfo;
+import com.megacrit.cardcrawl.characters.AbstractPlayer;
+import com.megacrit.cardcrawl.core.CardCrawlGame;
+import com.megacrit.cardcrawl.dungeons.AbstractDungeon;
+import com.megacrit.cardcrawl.localization.CardStrings;
+import com.megacrit.cardcrawl.monsters.AbstractMonster;
+import hemomancer.HemomancerMod;
+import hemomancer.characters.Hemomancer;
+
+import static hemomancer.HemomancerMod.makeCardPath;
+
+public class HemomancerPHA2 extends CustomCard {
+
+    public static final String ID = HemomancerMod.makeID(HemomancerPHA2.class.getSimpleName());
+    private static final CardStrings cardStrings = CardCrawlGame.languagePack.getCardStrings(ID);
+
+    public static final String IMG = makeCardPath("blood_attack.png");
+
+    public static final String NAME = cardStrings.NAME;
+    public static final String DESCRIPTION = cardStrings.DESCRIPTION;
+
+    private static final CardRarity RARITY = CardRarity.COMMON;
+    private static final CardTarget TARGET = CardTarget.ENEMY;
+    private static final CardType TYPE = CardType.ATTACK;
+    public static final CardColor COLOR = Hemomancer.Enums.COLOR_GRAY;
+
+    private static final int COST = 1;
+    private static final int DAMAGE = 6;
+    private static final int UPGRADE_PLUS_DMG = 3;
+
+    public HemomancerPHA2() {
+        super(ID, NAME, IMG, COST, DESCRIPTION, TYPE, COLOR, RARITY, TARGET);
+        baseDamage = DAMAGE;
+        this.tags.add(BaseModCardTags.BASIC_STRIKE);
+        this.tags.add(CardTags.STRIKE);
+    }
+    
+    @Override
+    public void use(AbstractPlayer p, AbstractMonster m) {
+        AbstractDungeon.actionManager.addToBottom(
+                new DamageAction(m, new DamageInfo(p, damage, damageTypeForTurn),
+                        AbstractGameAction.AttackEffect.SLASH_HORIZONTAL));
+    }
+    
+    @Override
+    public void upgrade() {
+        if (!upgraded) {
+            upgradeName();
+            upgradeDamage(UPGRADE_PLUS_DMG);
+            initializeDescription();
+        }
+    }
+}

src/main/java/hemomancer/cards/HemomancerPHA3.java

@@ -0,0 +1,59 @@
+package hemomancer.cards;
+
+import basemod.abstracts.CustomCard;
+import basemod.helpers.BaseModCardTags;
+import com.megacrit.cardcrawl.actions.AbstractGameAction;
+import com.megacrit.cardcrawl.actions.common.DamageAction;
+import com.megacrit.cardcrawl.cards.DamageInfo;
+import com.megacrit.cardcrawl.characters.AbstractPlayer;
+import com.megacrit.cardcrawl.core.CardCrawlGame;
+import com.megacrit.cardcrawl.dungeons.AbstractDungeon;
+import com.megacrit.cardcrawl.localization.CardStrings;
+import com.megacrit.cardcrawl.monsters.AbstractMonster;
+import hemomancer.HemomancerMod;
+import hemomancer.characters.Hemomancer;
+
+import static hemomancer.HemomancerMod.makeCardPath;
+
+public class HemomancerPHA3 extends CustomCard {
+
+    public static final String ID = HemomancerMod.makeID(HemomancerPHA3.class.getSimpleName());
+    private static final CardStrings cardStrings = CardCrawlGame.languagePack.getCardStrings(ID);
+
+    public static final String IMG = makeCardPath("blood_attack.png");
+
+    public static final String NAME = cardStrings.NAME;
+    public static final String DESCRIPTION = cardStrings.DESCRIPTION;
+
+    private static final CardRarity RARITY = CardRarity.COMMON;
+    private static final CardTarget TARGET = CardTarget.ENEMY;
+    private static final CardType TYPE = CardType.ATTACK;
+    public static final CardColor COLOR = Hemomancer.Enums.COLOR_GRAY;
+
+    private static final int COST = 1;
+    private static final int DAMAGE = 6;
+    private static final int UPGRADE_PLUS_DMG = 3;
+
+    public HemomancerPHA3() {
+        super(ID, NAME, IMG, COST, DESCRIPTION, TYPE, COLOR, RARITY, TARGET);
+        baseDamage = DAMAGE;
+        this.tags.add(BaseModCardTags.BASIC_STRIKE);
+        this.tags.add(CardTags.STRIKE);
+    }
+    
+    @Override
+    public void use(AbstractPlayer p, AbstractMonster m) {
+        AbstractDungeon.actionManager.addToBottom(
+                new DamageAction(m, new DamageInfo(p, damage, damageTypeForTurn),
+                        AbstractGameAction.AttackEffect.SLASH_HORIZONTAL));
+    }
+    
+    @Override
+    public void upgrade() {
+        if (!upgraded) {
+            upgradeName();
+            upgradeDamage(UPGRADE_PLUS_DMG);
+            initializeDescription();
+        }
+    }
+}

src/main/java/hemomancer/cards/HemomancerPHA4.java

@@ -0,0 +1,59 @@
+package hemomancer.cards;
+
+import basemod.abstracts.CustomCard;
+import basemod.helpers.BaseModCardTags;
+import com.megacrit.cardcrawl.actions.AbstractGameAction;
+import com.megacrit.cardcrawl.actions.common.DamageAction;
+import com.megacrit.cardcrawl.cards.DamageInfo;
+import com.megacrit.cardcrawl.characters.AbstractPlayer;
+import com.megacrit.cardcrawl.core.CardCrawlGame;
+import com.megacrit.cardcrawl.dungeons.AbstractDungeon;
+import com.megacrit.cardcrawl.localization.CardStrings;
+import com.megacrit.cardcrawl.monsters.AbstractMonster;
+import hemomancer.HemomancerMod;
+import hemomancer.characters.Hemomancer;
+
+import static hemomancer.HemomancerMod.makeCardPath;
+
+public class HemomancerPHA4 extends CustomCard {
+
+    public static final String ID = HemomancerMod.makeID(HemomancerPHA4.class.getSimpleName());
+    private static final CardStrings cardStrings = CardCrawlGame.languagePack.getCardStrings(ID);
+
+    public static final String IMG = makeCardPath("blood_attack.png");
+
+    public static final String NAME = cardStrings.NAME;
+    public static final String DESCRIPTION = cardStrings.DESCRIPTION;
+
+    private static final CardRarity RARITY = CardRarity.UNCOMMON;
+    private static final CardTarget TARGET = CardTarget.ENEMY;
+    private static final CardType TYPE = CardType.ATTACK;
+    public static final CardColor COLOR = Hemomancer.Enums.COLOR_GRAY;
+
+    private static final int COST = 1;
+    private static final int DAMAGE = 6;
+    private static final int UPGRADE_PLUS_DMG = 3;
+
+    public HemomancerPHA4() {
+        super(ID, NAME, IMG, COST, DESCRIPTION, TYPE, COLOR, RARITY, TARGET);
+        baseDamage = DAMAGE;
+        this.tags.add(BaseModCardTags.BASIC_STRIKE);
+        this.tags.add(CardTags.STRIKE);
+    }
+    
+    @Override
+    public void use(AbstractPlayer p, AbstractMonster m) {
+        AbstractDungeon.actionManager.addToBottom(
+                new DamageAction(m, new DamageInfo(p, damage, damageTypeForTurn),
+                        AbstractGameAction.AttackEffect.SLASH_HORIZONTAL));
+    }
+    
+    @Override
+    public void upgrade() {
+        if (!upgraded) {
+            upgradeName();
+            upgradeDamage(UPGRADE_PLUS_DMG);
+            initializeDescription();
+        }
+    }
+}

src/main/java/hemomancer/cards/HemomancerPHA5.java

@@ -0,0 +1,59 @@
+package hemomancer.cards;
+
+import basemod.abstracts.CustomCard;
+import basemod.helpers.BaseModCardTags;
+import com.megacrit.cardcrawl.actions.AbstractGameAction;
+import com.megacrit.cardcrawl.actions.common.DamageAction;
+import com.megacrit.cardcrawl.cards.DamageInfo;
+import com.megacrit.cardcrawl.characters.AbstractPlayer;
+import com.megacrit.cardcrawl.core.CardCrawlGame;
+import com.megacrit.cardcrawl.dungeons.AbstractDungeon;
+import com.megacrit.cardcrawl.localization.CardStrings;
+import com.megacrit.cardcrawl.monsters.AbstractMonster;
+import hemomancer.HemomancerMod;
+import hemomancer.characters.Hemomancer;
+
+import static hemomancer.HemomancerMod.makeCardPath;
+
+public class HemomancerPHA5 extends CustomCard {
+
+    public static final String ID = HemomancerMod.makeID(HemomancerPHA5.class.getSimpleName());
+    private static final CardStrings cardStrings = CardCrawlGame.languagePack.getCardStrings(ID);
+
+    public static final String IMG = makeCardPath("blood_attack.png");
+
+    public static final String NAME = cardStrings.NAME;
+    public static final String DESCRIPTION = cardStrings.DESCRIPTION;
+
+    private static final CardRarity RARITY = CardRarity.RARE;
+    private static final CardTarget TARGET = CardTarget.ENEMY;
+    private static final CardType TYPE = CardType.ATTACK;
+    public static final CardColor COLOR = Hemomancer.Enums.COLOR_GRAY;
+
+    private static final int COST = 1;
+    private static final int DAMAGE = 6;
+    private static final int UPGRADE_PLUS_DMG = 3;
+
+    public HemomancerPHA5() {
+        super(ID, NAME, IMG, COST, DESCRIPTION, TYPE, COLOR, RARITY, TARGET);
+        baseDamage = DAMAGE;
+        this.tags.add(BaseModCardTags.BASIC_STRIKE);
+        this.tags.add(CardTags.STRIKE);
+    }
+    
+    @Override
+    public void use(AbstractPlayer p, AbstractMonster m) {
+        AbstractDungeon.actionManager.addToBottom(
+                new DamageAction(m, new DamageInfo(p, damage, damageTypeForTurn),
+                        AbstractGameAction.AttackEffect.SLASH_HORIZONTAL));
+    }
+    
+    @Override
+    public void upgrade() {
+        if (!upgraded) {
+            upgradeName();
+            upgradeDamage(UPGRADE_PLUS_DMG);
+            initializeDescription();
+        }
+    }
+}

src/main/java/hemomancer/cards/HemomancerPHP1.java

@@ -0,0 +1,49 @@
+package hemomancer.cards;
+
+import basemod.helpers.BaseModCardTags;
+import com.megacrit.cardcrawl.actions.common.ApplyPowerAction;
+import com.megacrit.cardcrawl.characters.AbstractPlayer;
+import com.megacrit.cardcrawl.dungeons.AbstractDungeon;
+import com.megacrit.cardcrawl.monsters.AbstractMonster;
+import hemomancer.HemomancerMod;
+import hemomancer.characters.Hemomancer;
+import hemomancer.powers.RarePower;
+
+import static hemomancer.HemomancerMod.makeCardPath;
+
+public class HemomancerPHP1 extends AbstractDynamicCard {
+
+    public static final String ID = HemomancerMod.makeID(HemomancerPHP1.class.getSimpleName());
+    public static final String IMG = makeCardPath("Power.png");
+
+    private static final CardRarity RARITY = CardRarity.UNCOMMON;
+    private static final CardTarget TARGET = CardTarget.SELF;
+    private static final CardType TYPE = CardType.POWER;
+    public static final CardColor COLOR = Hemomancer.Enums.COLOR_GRAY;
+
+    private static final int COST = 3;
+    private static final int UPGRADE_COST = 2;
+
+    private static final int MAGIC = 1;
+
+    public HemomancerPHP1() {
+        super(ID, IMG, COST, TYPE, COLOR, RARITY, TARGET);
+        magicNumber = baseMagicNumber = MAGIC;
+        tags.add(BaseModCardTags.FORM);
+    }
+    
+    @Override
+    public void use(AbstractPlayer p, AbstractMonster m) {
+        AbstractDungeon.actionManager.addToBottom(
+                new ApplyPowerAction(p, p, new RarePower(p, p, magicNumber), magicNumber));
+    }
+    
+    @Override
+    public void upgrade() {
+        if (!upgraded) {
+            upgradeName();
+            upgradeBaseCost(UPGRADE_COST);
+            initializeDescription();
+        }
+    }
+}

src/main/java/hemomancer/cards/HemomancerPHP2.java

@@ -0,0 +1,49 @@
+package hemomancer.cards;
+
+import basemod.helpers.BaseModCardTags;
+import com.megacrit.cardcrawl.actions.common.ApplyPowerAction;
+import com.megacrit.cardcrawl.characters.AbstractPlayer;
+import com.megacrit.cardcrawl.dungeons.AbstractDungeon;
+import com.megacrit.cardcrawl.monsters.AbstractMonster;
+import hemomancer.HemomancerMod;
+import hemomancer.characters.Hemomancer;
+import hemomancer.powers.RarePower;
+
+import static hemomancer.HemomancerMod.makeCardPath;
+
+public class HemomancerPHP2 extends AbstractDynamicCard {
+
+    public static final String ID = HemomancerMod.makeID(HemomancerPHP2.class.getSimpleName());
+    public static final String IMG = makeCardPath("Power.png");
+
+    private static final CardRarity RARITY = CardRarity.UNCOMMON;
+    private static final CardTarget TARGET = CardTarget.SELF;
+    private static final CardType TYPE = CardType.POWER;
+    public static final CardColor COLOR = Hemomancer.Enums.COLOR_GRAY;
+
+    private static final int COST = 3;
+    private static final int UPGRADE_COST = 2;
+
+    private static final int MAGIC = 1;
+
+    public HemomancerPHP2() {
+        super(ID, IMG, COST, TYPE, COLOR, RARITY, TARGET);
+        magicNumber = baseMagicNumber = MAGIC;
+        tags.add(BaseModCardTags.FORM);
+    }
+    
+    @Override
+    public void use(AbstractPlayer p, AbstractMonster m) {
+        AbstractDungeon.actionManager.addToBottom(
+                new ApplyPowerAction(p, p, new RarePower(p, p, magicNumber), magicNumber));
+    }
+    
+    @Override
+    public void upgrade() {
+        if (!upgraded) {
+            upgradeName();
+            upgradeBaseCost(UPGRADE_COST);
+            initializeDescription();
+        }
+    }
+}

src/main/java/hemomancer/cards/HemomancerPHP3.java

@@ -0,0 +1,49 @@
+package hemomancer.cards;
+
+import basemod.helpers.BaseModCardTags;
+import com.megacrit.cardcrawl.actions.common.ApplyPowerAction;
+import com.megacrit.cardcrawl.characters.AbstractPlayer;
+import com.megacrit.cardcrawl.dungeons.AbstractDungeon;
+import com.megacrit.cardcrawl.monsters.AbstractMonster;
+import hemomancer.HemomancerMod;
+import hemomancer.characters.Hemomancer;
+import hemomancer.powers.RarePower;
+
+import static hemomancer.HemomancerMod.makeCardPath;
+
+public class HemomancerPHP3 extends AbstractDynamicCard {
+
+    public static final String ID = HemomancerMod.makeID(HemomancerPHP3.class.getSimpleName());
+    public static final String IMG = makeCardPath("Power.png");
+
+    private static final CardRarity RARITY = CardRarity.RARE;
+    private static final CardTarget TARGET = CardTarget.SELF;
+    private static final CardType TYPE = CardType.POWER;
+    public static final CardColor COLOR = Hemomancer.Enums.COLOR_GRAY;
+
+    private static final int COST = 3;
+    private static final int UPGRADE_COST = 2;
+
+    private static final int MAGIC = 1;
+
+    public HemomancerPHP3() {
+        super(ID, IMG, COST, TYPE, COLOR, RARITY, TARGET);
+        magicNumber = baseMagicNumber = MAGIC;
+        tags.add(BaseModCardTags.FORM);
+    }
+    
+    @Override
+    public void use(AbstractPlayer p, AbstractMonster m) {
+        AbstractDungeon.actionManager.addToBottom(
+                new ApplyPowerAction(p, p, new RarePower(p, p, magicNumber), magicNumber));
+    }
+    
+    @Override
+    public void upgrade() {
+        if (!upgraded) {
+            upgradeName();
+            upgradeBaseCost(UPGRADE_COST);
+            initializeDescription();
+        }
+    }
+}

src/main/java/hemomancer/cards/HemomancerPHS1.java

@@ -0,0 +1,46 @@
+package hemomancer.cards;
+
+import basemod.helpers.BaseModCardTags;
+import com.megacrit.cardcrawl.actions.common.GainBlockAction;
+import com.megacrit.cardcrawl.characters.AbstractPlayer;
+import com.megacrit.cardcrawl.dungeons.AbstractDungeon;
+import com.megacrit.cardcrawl.monsters.AbstractMonster;
+import hemomancer.HemomancerMod;
+import hemomancer.characters.Hemomancer;
+
+import static hemomancer.HemomancerMod.makeCardPath;
+
+public class HemomancerPHS1 extends AbstractDynamicCard {
+
+    public static final String ID = HemomancerMod.makeID(HemomancerPHS1.class.getSimpleName());
+    public static final String IMG = makeCardPath("blood_block.png");
+
+    private static final CardRarity RARITY = CardRarity.COMMON;
+    private static final CardTarget TARGET = CardTarget.SELF;
+    private static final CardType TYPE = CardType.SKILL;
+    public static final CardColor COLOR = Hemomancer.Enums.COLOR_GRAY;
+
+    private static final int COST = 1;
+    private static final int BLOCK = 5;
+    private static final int UPGRADE_PLUS_BLOCK = 3;
+
+    public HemomancerPHS1() {
+        super(ID, IMG, COST, TYPE, COLOR, RARITY, TARGET);
+        baseBlock = BLOCK;
+        this.tags.add(BaseModCardTags.BASIC_DEFEND);
+    }
+    
+    @Override
+    public void use(AbstractPlayer p, AbstractMonster m) {
+        AbstractDungeon.actionManager.addToBottom(new GainBlockAction(p, p, block));
+    }
+    
+    @Override
+    public void upgrade() {
+        if (!upgraded) {
+            upgradeName();
+            upgradeBlock(UPGRADE_PLUS_BLOCK);
+            initializeDescription();
+        }
+    }
+}

src/main/java/hemomancer/cards/HemomancerPHS2.java

@@ -0,0 +1,46 @@
+package hemomancer.cards;
+
+import basemod.helpers.BaseModCardTags;
+import com.megacrit.cardcrawl.actions.common.GainBlockAction;
+import com.megacrit.cardcrawl.characters.AbstractPlayer;
+import com.megacrit.cardcrawl.dungeons.AbstractDungeon;
+import com.megacrit.cardcrawl.monsters.AbstractMonster;
+import hemomancer.HemomancerMod;
+import hemomancer.characters.Hemomancer;
+
+import static hemomancer.HemomancerMod.makeCardPath;
+
+public class HemomancerPHS2 extends AbstractDynamicCard {
+
+    public static final String ID = HemomancerMod.makeID(HemomancerPHS2.class.getSimpleName());
+    public static final String IMG = makeCardPath("blood_block.png");
+
+    private static final CardRarity RARITY = CardRarity.COMMON;
+    private static final CardTarget TARGET = CardTarget.SELF;
+    private static final CardType TYPE = CardType.SKILL;
+    public static final CardColor COLOR = Hemomancer.Enums.COLOR_GRAY;
+
+    private static final int COST = 1;
+    private static final int BLOCK = 5;
+    private static final int UPGRADE_PLUS_BLOCK = 3;
+
+    public HemomancerPHS2() {
+        super(ID, IMG, COST, TYPE, COLOR, RARITY, TARGET);
+        baseBlock = BLOCK;
+        this.tags.add(BaseModCardTags.BASIC_DEFEND);
+    }
+    
+    @Override
+    public void use(AbstractPlayer p, AbstractMonster m) {
+        AbstractDungeon.actionManager.addToBottom(new GainBlockAction(p, p, block));
+    }
+    
+    @Override
+    public void upgrade() {
+        if (!upgraded) {
+            upgradeName();
+            upgradeBlock(UPGRADE_PLUS_BLOCK);
+            initializeDescription();
+        }
+    }
+}

src/main/java/hemomancer/cards/HemomancerPHS3.java

@@ -0,0 +1,46 @@
+package hemomancer.cards;
+
+import basemod.helpers.BaseModCardTags;
+import com.megacrit.cardcrawl.actions.common.GainBlockAction;
+import com.megacrit.cardcrawl.characters.AbstractPlayer;
+import com.megacrit.cardcrawl.dungeons.AbstractDungeon;
+import com.megacrit.cardcrawl.monsters.AbstractMonster;
+import hemomancer.HemomancerMod;
+import hemomancer.characters.Hemomancer;
+
+import static hemomancer.HemomancerMod.makeCardPath;
+
+public class HemomancerPHS3 extends AbstractDynamicCard {
+
+    public static final String ID = HemomancerMod.makeID(HemomancerPHS3.class.getSimpleName());
+    public static final String IMG = makeCardPath("blood_block.png");
+
+    private static final CardRarity RARITY = CardRarity.UNCOMMON;
+    private static final CardTarget TARGET = CardTarget.SELF;
+    private static final CardType TYPE = CardType.SKILL;
+    public static final CardColor COLOR = Hemomancer.Enums.COLOR_GRAY;
+
+    private static final int COST = 1;
+    private static final int BLOCK = 5;
+    private static final int UPGRADE_PLUS_BLOCK = 3;
+
+    public HemomancerPHS3() {
+        super(ID, IMG, COST, TYPE, COLOR, RARITY, TARGET);
+        baseBlock = BLOCK;
+        this.tags.add(BaseModCardTags.BASIC_DEFEND);
+    }
+    
+    @Override
+    public void use(AbstractPlayer p, AbstractMonster m) {
+        AbstractDungeon.actionManager.addToBottom(new GainBlockAction(p, p, block));
+    }
+    
+    @Override
+    public void upgrade() {
+        if (!upgraded) {
+            upgradeName();
+            upgradeBlock(UPGRADE_PLUS_BLOCK);
+            initializeDescription();
+        }
+    }
+}

src/main/java/hemomancer/cards/HemomancerPHS4.java

@@ -0,0 +1,46 @@
+package hemomancer.cards;
+
+import basemod.helpers.BaseModCardTags;
+import com.megacrit.cardcrawl.actions.common.GainBlockAction;
+import com.megacrit.cardcrawl.characters.AbstractPlayer;
+import com.megacrit.cardcrawl.dungeons.AbstractDungeon;
+import com.megacrit.cardcrawl.monsters.AbstractMonster;
+import hemomancer.HemomancerMod;
+import hemomancer.characters.Hemomancer;
+
+import static hemomancer.HemomancerMod.makeCardPath;
+
+public class HemomancerPHS4 extends AbstractDynamicCard {
+
+    public static final String ID = HemomancerMod.makeID(HemomancerPHS4.class.getSimpleName());
+    public static final String IMG = makeCardPath("blood_block.png");
+
+    private static final CardRarity RARITY = CardRarity.UNCOMMON;
+    private static final CardTarget TARGET = CardTarget.SELF;
+    private static final CardType TYPE = CardType.SKILL;
+    public static final CardColor COLOR = Hemomancer.Enums.COLOR_GRAY;
+
+    private static final int COST = 1;
+    private static final int BLOCK = 5;
+    private static final int UPGRADE_PLUS_BLOCK = 3;
+
+    public HemomancerPHS4() {
+        super(ID, IMG, COST, TYPE, COLOR, RARITY, TARGET);
+        baseBlock = BLOCK;
+        this.tags.add(BaseModCardTags.BASIC_DEFEND);
+    }
+    
+    @Override
+    public void use(AbstractPlayer p, AbstractMonster m) {
+        AbstractDungeon.actionManager.addToBottom(new GainBlockAction(p, p, block));
+    }
+    
+    @Override
+    public void upgrade() {
+        if (!upgraded) {
+            upgradeName();
+            upgradeBlock(UPGRADE_PLUS_BLOCK);
+            initializeDescription();
+        }
+    }
+}

src/main/java/hemomancer/cards/HemomancerPHS5.java

@@ -0,0 +1,46 @@
+package hemomancer.cards;
+
+import basemod.helpers.BaseModCardTags;
+import com.megacrit.cardcrawl.actions.common.GainBlockAction;
+import com.megacrit.cardcrawl.characters.AbstractPlayer;
+import com.megacrit.cardcrawl.dungeons.AbstractDungeon;
+import com.megacrit.cardcrawl.monsters.AbstractMonster;
+import hemomancer.HemomancerMod;
+import hemomancer.characters.Hemomancer;
+
+import static hemomancer.HemomancerMod.makeCardPath;
+
+public class HemomancerPHS5 extends AbstractDynamicCard {
+
+    public static final String ID = HemomancerMod.makeID(HemomancerPHS5.class.getSimpleName());
+    public static final String IMG = makeCardPath("blood_block.png");
+
+    private static final CardRarity RARITY = CardRarity.RARE;
+    private static final CardTarget TARGET = CardTarget.SELF;
+    private static final CardType TYPE = CardType.SKILL;
+    public static final CardColor COLOR = Hemomancer.Enums.COLOR_GRAY;
+
+    private static final int COST = 1;
+    private static final int BLOCK = 5;
+    private static final int UPGRADE_PLUS_BLOCK = 3;
+
+    public HemomancerPHS5() {
+        super(ID, IMG, COST, TYPE, COLOR, RARITY, TARGET);
+        baseBlock = BLOCK;
+        this.tags.add(BaseModCardTags.BASIC_DEFEND);
+    }
+    
+    @Override
+    public void use(AbstractPlayer p, AbstractMonster m) {
+        AbstractDungeon.actionManager.addToBottom(new GainBlockAction(p, p, block));
+    }
+    
+    @Override
+    public void upgrade() {
+        if (!upgraded) {
+            upgradeName();
+            upgradeBlock(UPGRADE_PLUS_BLOCK);
+            initializeDescription();
+        }
+    }
+}

src/main/java/hemomancer/cards/HemomancerRareAttack.java

@@ -0,0 +1,53 @@
+package hemomancer.cards;
+
+import com.megacrit.cardcrawl.actions.AbstractGameAction;
+import com.megacrit.cardcrawl.actions.animations.VFXAction;
+import com.megacrit.cardcrawl.actions.common.DamageAction;
+import com.megacrit.cardcrawl.cards.DamageInfo;
+import com.megacrit.cardcrawl.characters.AbstractPlayer;
+import com.megacrit.cardcrawl.dungeons.AbstractDungeon;
+import com.megacrit.cardcrawl.monsters.AbstractMonster;
+import com.megacrit.cardcrawl.vfx.combat.WeightyImpactEffect;
+import hemomancer.HemomancerMod;
+import hemomancer.characters.Hemomancer;
+
+import static hemomancer.HemomancerMod.makeCardPath;
+
+public class HemomancerRareAttack extends AbstractDynamicCard {
+    
+    public static final String ID = HemomancerMod.makeID(HemomancerRareAttack.class.getSimpleName());
+    public static final String IMG = makeCardPath("Attack.png");
+    
+    private static final CardRarity RARITY = CardRarity.RARE;
+    private static final CardTarget TARGET = CardTarget.ENEMY;
+    private static final CardType TYPE = CardType.ATTACK;
+    public static final CardColor COLOR = Hemomancer.Enums.COLOR_GRAY;
+    
+    private static final int COST = 2;
+    
+    private static final int DAMAGE = 30;
+    private static final int UPGRADE_PLUS_DMG = 5;
+    
+    public HemomancerRareAttack() {
+        super(ID, IMG, COST, TYPE, COLOR, RARITY, TARGET);
+        baseDamage = DAMAGE;
+    }
+    
+    @Override
+    public void use(AbstractPlayer p, AbstractMonster m) {
+        if (m != null) {
+            AbstractDungeon.actionManager.addToBottom(new VFXAction(new WeightyImpactEffect(m.hb.cX, m.hb.cY)));
+        }
+        AbstractDungeon.actionManager.addToBottom(
+                new DamageAction(m, new DamageInfo(p, damage, damageTypeForTurn),
+                        AbstractGameAction.AttackEffect.NONE));
+    }
+    
+    @Override
+    public void upgrade() {
+        if (!upgraded) {
+            upgradeName();
+            upgradeDamage(UPGRADE_PLUS_DMG);
+        }
+    }
+}

src/main/java/hemomancer/cards/HemomancerRarePower.java

@@ -0,0 +1,49 @@
+package hemomancer.cards;
+
+import basemod.helpers.BaseModCardTags;
+import com.megacrit.cardcrawl.actions.common.ApplyPowerAction;
+import com.megacrit.cardcrawl.characters.AbstractPlayer;
+import com.megacrit.cardcrawl.dungeons.AbstractDungeon;
+import com.megacrit.cardcrawl.monsters.AbstractMonster;
+import hemomancer.HemomancerMod;
+import hemomancer.characters.Hemomancer;
+import hemomancer.powers.RarePower;
+
+import static hemomancer.HemomancerMod.makeCardPath;
+
+public class HemomancerRarePower extends AbstractDynamicCard {
+    
+    public static final String ID = HemomancerMod.makeID(HemomancerRarePower.class.getSimpleName());
+    public static final String IMG = makeCardPath("Power.png");
+    
+    private static final CardRarity RARITY = CardRarity.RARE;
+    private static final CardTarget TARGET = CardTarget.SELF;
+    private static final CardType TYPE = CardType.POWER;
+    public static final CardColor COLOR = Hemomancer.Enums.COLOR_GRAY;
+    
+    private static final int COST = 3;
+    private static final int UPGRADE_COST = 2;
+    
+    private static final int MAGIC = 1;
+    
+    public HemomancerRarePower() {
+        super(ID, IMG, COST, TYPE, COLOR, RARITY, TARGET);
+        magicNumber = baseMagicNumber = MAGIC;
+        tags.add(BaseModCardTags.FORM);
+    }
+    
+    @Override
+    public void use(AbstractPlayer p, AbstractMonster m) {
+        AbstractDungeon.actionManager.addToBottom(
+                new ApplyPowerAction(p, p, new RarePower(p, p, magicNumber), magicNumber));
+    }
+    
+    @Override
+    public void upgrade() {
+        if (!upgraded) {
+            upgradeName();
+            upgradeBaseCost(UPGRADE_COST);
+            initializeDescription();
+        }
+    }
+}

src/main/java/hemomancer/cards/HemomancerRareSkill.java

@@ -0,0 +1,59 @@
+package hemomancer.cards;
+
+import com.megacrit.cardcrawl.actions.common.ApplyPowerAction;
+import com.megacrit.cardcrawl.characters.AbstractPlayer;
+import com.megacrit.cardcrawl.core.CardCrawlGame;
+import com.megacrit.cardcrawl.dungeons.AbstractDungeon;
+import com.megacrit.cardcrawl.localization.CardStrings;
+import com.megacrit.cardcrawl.monsters.AbstractMonster;
+import com.megacrit.cardcrawl.powers.VulnerablePower;
+import hemomancer.HemomancerMod;
+import hemomancer.characters.Hemomancer;
+
+import static hemomancer.HemomancerMod.makeCardPath;
+
+public class HemomancerRareSkill extends AbstractDynamicCard {
+    
+    public static final String ID = HemomancerMod.makeID(HemomancerRareSkill.class.getSimpleName());
+    public static final String IMG = makeCardPath("Skill.png");
+    
+    private static final CardStrings cardStrings = CardCrawlGame.languagePack.getCardStrings(ID);
+    public static final String UPGRADE_DESCRIPTION = cardStrings.UPGRADE_DESCRIPTION;
+    
+    private static final CardRarity RARITY = CardRarity.RARE;
+    private static final CardTarget TARGET = CardTarget.ALL_ENEMY;
+    private static final CardType TYPE = CardType.SKILL;
+    public static final CardColor COLOR = Hemomancer.Enums.COLOR_GRAY;
+    
+    private static final int COST = 1;
+    
+    private int TIMES = 2;
+    private final int UPGRADE_TIMES = 3;
+    
+    private int AMOUNT = 1;
+    
+    public HemomancerRareSkill() {
+        super(ID, IMG, COST, TYPE, COLOR, RARITY, TARGET);
+        baseMagicNumber = magicNumber = AMOUNT;
+    }
+    
+    @Override
+    public void use(AbstractPlayer p, AbstractMonster m) {
+        for (int i = 0; i < TIMES; i++) {
+            for (final AbstractMonster mo : AbstractDungeon.getCurrRoom().monsters.monsters) {
+                AbstractDungeon.actionManager.addToBottom(new ApplyPowerAction(mo, p,
+                        new VulnerablePower(mo, magicNumber, false), magicNumber));
+            }
+        }
+    }
+    
+    @Override
+    public void upgrade() {
+        if (!upgraded) {
+            upgradeName();
+            rawDescription = UPGRADE_DESCRIPTION;
+            TIMES = UPGRADE_TIMES;
+            initializeDescription();
+        }
+    }
+}

src/main/java/hemomancer/cards/HemomancerSecondMagicNumberSkill.java

@@ -0,0 +1,56 @@
+package hemomancer.cards;
+
+import com.megacrit.cardcrawl.actions.common.ApplyPowerAction;
+import com.megacrit.cardcrawl.characters.AbstractPlayer;
+import com.megacrit.cardcrawl.dungeons.AbstractDungeon;
+import com.megacrit.cardcrawl.monsters.AbstractMonster;
+import com.megacrit.cardcrawl.powers.PoisonPower;
+import com.megacrit.cardcrawl.powers.VulnerablePower;
+import hemomancer.HemomancerMod;
+import hemomancer.characters.Hemomancer;
+
+import static hemomancer.HemomancerMod.makeCardPath;
+
+public class HemomancerSecondMagicNumberSkill extends AbstractDynamicCard {
+    
+    public static final String ID = HemomancerMod.makeID(HemomancerSecondMagicNumberSkill.class.getSimpleName());
+    public static final String IMG = makeCardPath("Skill.png");
+    
+    private static final CardRarity RARITY = CardRarity.COMMON;
+    private static final CardTarget TARGET = CardTarget.ENEMY;
+    private static final CardType TYPE = CardType.SKILL;
+    public static final CardColor COLOR = Hemomancer.Enums.COLOR_GRAY;
+    
+    private static final int COST = 1;
+    
+    private static final int VULNERABLE = 2;
+    private static final int UPGRADE_PLUS_VULNERABLE = 3;
+    
+    private static final int POISON = 4;
+    private static final int UPGRADE_PLUS_POISON = 5;
+    
+    public HemomancerSecondMagicNumberSkill() {
+        super(ID, IMG, COST, TYPE, COLOR, RARITY, TARGET);
+        magicNumber = baseMagicNumber = VULNERABLE;
+        defaultSecondMagicNumber = defaultBaseSecondMagicNumber = POISON;
+    }
+    
+    @Override
+    public void use(AbstractPlayer p, AbstractMonster m) {
+        AbstractDungeon.actionManager.addToBottom(
+                new ApplyPowerAction(m, p, new VulnerablePower(m, magicNumber, false), this.magicNumber));
+        
+        AbstractDungeon.actionManager.addToBottom(
+                new ApplyPowerAction(m, p, new PoisonPower(m, p, this.defaultSecondMagicNumber), this.defaultSecondMagicNumber));
+    }
+    
+    @Override
+    public void upgrade() {
+        if (!this.upgraded) {
+            this.upgradeName();
+            this.upgradeMagicNumber(UPGRADE_PLUS_VULNERABLE);
+            this.upgradeDefaultSecondMagicNumber(UPGRADE_PLUS_POISON);
+            this.initializeDescription();
+        }
+    }
+}

src/main/java/hemomancer/cards/HemomancerStrike.java

@@ -0,0 +1,59 @@
+package hemomancer.cards;
+
+import basemod.abstracts.CustomCard;
+import basemod.helpers.BaseModCardTags;
+import com.megacrit.cardcrawl.actions.AbstractGameAction;
+import com.megacrit.cardcrawl.actions.common.DamageAction;
+import com.megacrit.cardcrawl.cards.DamageInfo;
+import com.megacrit.cardcrawl.characters.AbstractPlayer;
+import com.megacrit.cardcrawl.core.CardCrawlGame;
+import com.megacrit.cardcrawl.dungeons.AbstractDungeon;
+import com.megacrit.cardcrawl.localization.CardStrings;
+import com.megacrit.cardcrawl.monsters.AbstractMonster;
+import hemomancer.HemomancerMod;
+import hemomancer.characters.Hemomancer;
+
+import static hemomancer.HemomancerMod.makeCardPath;
+
+public class HemomancerStrike extends CustomCard {
+    
+    public static final String ID = HemomancerMod.makeID(HemomancerStrike.class.getSimpleName());
+    private static final CardStrings cardStrings = CardCrawlGame.languagePack.getCardStrings(ID);
+    
+    public static final String IMG = makeCardPath("blood_attack.png");
+    
+    public static final String NAME = cardStrings.NAME;
+    public static final String DESCRIPTION = cardStrings.DESCRIPTION;
+    
+    private static final CardRarity RARITY = CardRarity.BASIC;
+    private static final CardTarget TARGET = CardTarget.ENEMY;
+    private static final CardType TYPE = CardType.ATTACK;
+    public static final CardColor COLOR = Hemomancer.Enums.COLOR_GRAY;
+    
+    private static final int COST = 1;
+    private static final int DAMAGE = 6;
+    private static final int UPGRADE_PLUS_DMG = 3;
+    
+    public HemomancerStrike() {
+        super(ID, NAME, IMG, COST, DESCRIPTION, TYPE, COLOR, RARITY, TARGET);
+        baseDamage = DAMAGE;
+        this.tags.add(BaseModCardTags.BASIC_STRIKE);
+        this.tags.add(CardTags.STRIKE);
+    }
+    
+    @Override
+    public void use(AbstractPlayer p, AbstractMonster m) {
+        AbstractDungeon.actionManager.addToBottom(
+                new DamageAction(m, new DamageInfo(p, damage, damageTypeForTurn),
+                        AbstractGameAction.AttackEffect.SLASH_HORIZONTAL));
+    }
+    
+    @Override
+    public void upgrade() {
+        if (!upgraded) {
+            upgradeName();
+            upgradeDamage(UPGRADE_PLUS_DMG);
+            initializeDescription();
+        }
+    }
+}

src/main/java/hemomancer/cards/HemomancerUncommonAttack.java

@@ -0,0 +1,48 @@
+package hemomancer.cards;
+
+import com.megacrit.cardcrawl.actions.AbstractGameAction;
+import com.megacrit.cardcrawl.actions.common.DamageAction;
+import com.megacrit.cardcrawl.cards.DamageInfo;
+import com.megacrit.cardcrawl.characters.AbstractPlayer;
+import com.megacrit.cardcrawl.dungeons.AbstractDungeon;
+import com.megacrit.cardcrawl.monsters.AbstractMonster;
+import hemomancer.HemomancerMod;
+import hemomancer.characters.Hemomancer;
+
+import static hemomancer.HemomancerMod.makeCardPath;
+
+public class HemomancerUncommonAttack extends AbstractDynamicCard {
+    
+    public static final String ID = HemomancerMod.makeID(HemomancerUncommonAttack.class.getSimpleName());
+    public static final String IMG = makeCardPath("Attack.png");
+    
+    private static final CardRarity RARITY = CardRarity.UNCOMMON;
+    private static final CardTarget TARGET = CardTarget.ENEMY;
+    private static final CardType TYPE = CardType.ATTACK;
+    public static final CardColor COLOR = Hemomancer.Enums.COLOR_GRAY;
+    
+    private static final int COST = 1;
+    private static final int DAMAGE = 10;
+    private static final int UPGRADE_PLUS_DMG = 5;
+    
+    public HemomancerUncommonAttack() {
+        super(ID, IMG, COST, TYPE, COLOR, RARITY, TARGET);
+        baseDamage = DAMAGE;
+    }
+    
+    @Override
+    public void use(AbstractPlayer p, AbstractMonster m) {
+        AbstractDungeon.actionManager.addToBottom(
+                new DamageAction(m, new DamageInfo(p, damage, damageTypeForTurn),
+                        AbstractGameAction.AttackEffect.BLUNT_LIGHT));
+    }
+    
+    @Override
+    public void upgrade() {
+        if (!upgraded) {
+            upgradeName();
+            upgradeDamage(UPGRADE_PLUS_DMG);
+            initializeDescription();
+        }
+    }
+}

src/main/java/hemomancer/cards/HemomancerUncommonPower.java

@@ -0,0 +1,53 @@
+package hemomancer.cards;
+
+import com.megacrit.cardcrawl.characters.AbstractPlayer;
+import com.megacrit.cardcrawl.core.CardCrawlGame;
+import com.megacrit.cardcrawl.dungeons.AbstractDungeon;
+import com.megacrit.cardcrawl.localization.CardStrings;
+import com.megacrit.cardcrawl.monsters.AbstractMonster;
+import com.megacrit.cardcrawl.ui.panels.EnergyPanel;
+import hemomancer.HemomancerMod;
+import hemomancer.actions.UncommonPowerAction;
+import hemomancer.characters.Hemomancer;
+
+import static hemomancer.HemomancerMod.makeCardPath;
+
+public class HemomancerUncommonPower extends AbstractDynamicCard {
+    
+    public static final String ID = HemomancerMod.makeID(HemomancerUncommonPower.class.getSimpleName());
+    public static final String IMG = makeCardPath("Power.png");
+    
+    private static final CardStrings cardStrings = CardCrawlGame.languagePack.getCardStrings(ID);
+    public static final String UPGRADE_DESCRIPTION = cardStrings.UPGRADE_DESCRIPTION;
+    
+    private static final CardRarity RARITY = CardRarity.UNCOMMON;
+    private static final CardTarget TARGET = CardTarget.SELF;
+    private static final CardType TYPE = CardType.POWER;
+    public static final CardColor COLOR = Hemomancer.Enums.COLOR_GRAY;
+    
+    private static final int COST = -1;
+    private static final int MAGIC = 1;
+    
+    public HemomancerUncommonPower() {
+        super(ID, IMG, COST, TYPE, COLOR, RARITY, TARGET);
+        magicNumber = baseMagicNumber = MAGIC;
+    }
+    
+    @Override
+    public void use(final AbstractPlayer p, final AbstractMonster m) {
+        if (energyOnUse < EnergyPanel.totalCount) {
+            energyOnUse = EnergyPanel.totalCount;
+        }
+        AbstractDungeon.actionManager.addToBottom(new UncommonPowerAction(p, m, magicNumber,
+                upgraded, damageTypeForTurn, freeToPlayOnce, energyOnUse));
+    }
+    
+    @Override
+    public void upgrade() {
+        if (!upgraded) {
+            upgradeName();
+            rawDescription = UPGRADE_DESCRIPTION;
+            initializeDescription();
+        }
+    }
+}

src/main/java/hemomancer/cards/HemomancerUncommonSkill.java

@@ -0,0 +1,49 @@
+package hemomancer.cards;
+
+import com.megacrit.cardcrawl.actions.common.ApplyPowerAction;
+import com.megacrit.cardcrawl.characters.AbstractPlayer;
+import com.megacrit.cardcrawl.dungeons.AbstractDungeon;
+import com.megacrit.cardcrawl.monsters.AbstractMonster;
+import com.megacrit.cardcrawl.powers.PlatedArmorPower;
+import hemomancer.HemomancerMod;
+import hemomancer.characters.Hemomancer;
+
+import static hemomancer.HemomancerMod.makeCardPath;
+
+public class HemomancerUncommonSkill extends AbstractDynamicCard {
+    
+    public static final String ID = HemomancerMod.makeID(HemomancerUncommonSkill.class.getSimpleName());
+    public static final String IMG = makeCardPath("Skill.png");
+    
+    private static final CardRarity RARITY = CardRarity.UNCOMMON;
+    private static final CardTarget TARGET = CardTarget.SELF;
+    private static final CardType TYPE = CardType.SKILL;
+    public static final CardColor COLOR = Hemomancer.Enums.COLOR_GRAY;
+    
+    private static final int COST = 1;
+    private static final int UPGRADE_REDUCED_COST = 0;
+    
+    private static final int BLOCK = 1;
+    private static final int UPGRADE_PLUS_BLOCK = 2;
+    
+    public HemomancerUncommonSkill() {
+        super(ID, IMG, COST, TYPE, COLOR, RARITY, TARGET);
+        baseBlock = BLOCK;
+    }
+    
+    @Override
+    public void use(AbstractPlayer p, AbstractMonster m) {
+        AbstractDungeon.actionManager.addToBottom(
+                new ApplyPowerAction(p, p, new PlatedArmorPower(p, block), block));
+    }
+    
+    @Override
+    public void upgrade() {
+        if (!upgraded) {
+            upgradeName();
+            upgradeBlock(UPGRADE_PLUS_BLOCK);
+            upgradeBaseCost(UPGRADE_REDUCED_COST);
+            initializeDescription();
+        }
+    }
+}

src/main/java/hemomancer/cards/OrbSkill.java

@@ -0,0 +1,48 @@
+package hemomancer.cards;
+
+import com.megacrit.cardcrawl.actions.defect.ChannelAction;
+import com.megacrit.cardcrawl.characters.AbstractPlayer;
+import com.megacrit.cardcrawl.core.CardCrawlGame;
+import com.megacrit.cardcrawl.dungeons.AbstractDungeon;
+import com.megacrit.cardcrawl.localization.CardStrings;
+import com.megacrit.cardcrawl.monsters.AbstractMonster;
+import hemomancer.HemomancerMod;
+import hemomancer.characters.Hemomancer;
+import hemomancer.orbs.DefaultOrb;
+
+import static hemomancer.HemomancerMod.makeCardPath;
+
+public class OrbSkill extends AbstractDynamicCard {
+    
+    public static final String ID = HemomancerMod.makeID(OrbSkill.class.getSimpleName());
+    private static final CardStrings cardStrings = CardCrawlGame.languagePack.getCardStrings(ID);
+    
+    public static final String IMG = makeCardPath("Skill.png");
+    
+    public static final String NAME = cardStrings.NAME;
+    public static final String DESCRIPTION = cardStrings.DESCRIPTION;
+    
+    private static final CardRarity RARITY = CardRarity.UNCOMMON;
+    private static final CardTarget TARGET = CardTarget.SELF;
+    private static final CardType TYPE = CardType.SKILL;
+    public static final CardColor COLOR = Hemomancer.Enums.COLOR_GRAY;
+    
+    private static final int COST = 1;
+    
+    public OrbSkill() {
+        super(ID, IMG, COST, TYPE, COLOR, RARITY, TARGET);
+    }
+    
+    @Override
+    public void use(AbstractPlayer p, AbstractMonster m) {
+        AbstractDungeon.actionManager.addToBottom(new ChannelAction(new DefaultOrb()));
+    }
+    
+    @Override
+    public void upgrade() {
+        if (!this.upgraded) {
+            this.upgradeName();
+            this.initializeDescription();
+        }
+    }
+}

src/main/java/hemomancer/characters/Hemomancer.java

@@ -0,0 +1,212 @@
+package hemomancer.characters;
+
+import basemod.abstracts.CustomPlayer;
+import basemod.animations.SpriterAnimation;
+import com.badlogic.gdx.graphics.Color;
+import com.badlogic.gdx.graphics.g2d.BitmapFont;
+import com.badlogic.gdx.math.MathUtils;
+import com.esotericsoftware.spine.AnimationState;
+import com.evacipated.cardcrawl.modthespire.lib.SpireEnum;
+import com.megacrit.cardcrawl.actions.AbstractGameAction;
+import com.megacrit.cardcrawl.cards.AbstractCard;
+import com.megacrit.cardcrawl.characters.AbstractPlayer;
+import com.megacrit.cardcrawl.core.CardCrawlGame;
+import com.megacrit.cardcrawl.core.EnergyManager;
+import com.megacrit.cardcrawl.core.Settings;
+import com.megacrit.cardcrawl.helpers.CardLibrary;
+import com.megacrit.cardcrawl.helpers.FontHelper;
+import com.megacrit.cardcrawl.helpers.ScreenShake;
+import com.megacrit.cardcrawl.localization.CharacterStrings;
+import com.megacrit.cardcrawl.screens.CharSelectInfo;
+import com.megacrit.cardcrawl.unlock.UnlockTracker;
+import hemomancer.relics.BloodMistRelic;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import hemomancer.HemomancerMod;
+import hemomancer.cards.*;
+
+import java.util.ArrayList;
+
+import static hemomancer.HemomancerMod.*;
+import static hemomancer.characters.Hemomancer.Enums.COLOR_GRAY;
+
+public class Hemomancer extends CustomPlayer {
+    public static final Logger logger = LogManager.getLogger(HemomancerMod.class.getName());
+    
+    public static class Enums {
+        @SpireEnum
+        public static AbstractPlayer.PlayerClass THE_DEFAULT;
+        @SpireEnum(name = "DEFAULT_GRAY_COLOR")
+        public static AbstractCard.CardColor COLOR_GRAY;
+        @SpireEnum(name = "DEFAULT_GRAY_COLOR")
+        @SuppressWarnings("unused")
+        public static CardLibrary.LibraryType LIBRARY_COLOR;
+    }
+    
+    public static final int ENERGY_PER_TURN = 3;
+    public static final int STARTING_HP = 75;
+    public static final int MAX_HP = 75;
+    public static final int STARTING_GOLD = 99;
+    public static final int CARD_DRAW = 6;
+    public static final int ORB_SLOTS = 1;
+    
+    private static final String ID = makeID("HemomancerCharacter");
+    private static final CharacterStrings characterStrings = CardCrawlGame.languagePack.getCharacterString(ID);
+    private static final String[] NAMES = characterStrings.NAMES;
+    private static final String[] TEXT = characterStrings.TEXT;
+    
+    public static final String[] orbTextures = {
+            "hemomancerResources/images/char/defaultCharacter/orb/layer1.png",
+            "hemomancerResources/images/char/defaultCharacter/orb/layer2.png",
+            "hemomancerResources/images/char/defaultCharacter/orb/layer3.png",
+            "hemomancerResources/images/char/defaultCharacter/orb/layer4.png",
+            "hemomancerResources/images/char/defaultCharacter/orb/layer5.png",
+            "hemomancerResources/images/char/defaultCharacter/orb/layer6.png",
+            "hemomancerResources/images/char/defaultCharacter/orb/layer1d.png",
+            "hemomancerResources/images/char/defaultCharacter/orb/layer2d.png",
+            "hemomancerResources/images/char/defaultCharacter/orb/layer3d.png",
+            "hemomancerResources/images/char/defaultCharacter/orb/layer4d.png",
+            "hemomancerResources/images/char/defaultCharacter/orb/layer5d.png",};
+    
+    public Hemomancer(String name, PlayerClass setClass) {
+        super(name, setClass, orbTextures,
+                "hemomancerResources/images/char/defaultCharacter/orb/vfx.png", null,
+                new SpriterAnimation(
+                        "hemomancerResources/images/char/defaultCharacter/Spriter/theDefaultAnimation.scml"));
+        
+        
+        initializeClass(null,
+                THE_DEFAULT_SHOULDER_1,
+                THE_DEFAULT_SHOULDER_2,
+                THE_DEFAULT_CORPSE,
+                getLoadout(), 20.0F, -10.0F, 220.0F, 290.0F, new EnergyManager(ENERGY_PER_TURN));
+        
+        
+        loadAnimation(
+                THE_DEFAULT_SKELETON_ATLAS,
+                THE_DEFAULT_SKELETON_JSON,
+                1.0f);
+        AnimationState.TrackEntry e = state.setAnimation(0, "animation", true);
+        e.setTime(e.getEndTime() * MathUtils.random());
+        
+        
+        dialogX = (drawX + 0.0F * Settings.scale);
+        dialogY = (drawY + 220.0F * Settings.scale);
+    }
+    
+    @Override
+    public CharSelectInfo getLoadout() {
+        return new CharSelectInfo(NAMES[0], TEXT[0],
+                STARTING_HP, MAX_HP, ORB_SLOTS, STARTING_GOLD, CARD_DRAW, this, getStartingRelics(),
+                getStartingDeck(), false);
+    }
+    
+    @Override
+    public ArrayList<String> getStartingDeck() {
+        ArrayList<String> retVal = new ArrayList<>();
+        
+        retVal.add(HemomancerStrike.ID);
+//        retVal.add(HemomancerStrike.ID);
+//        retVal.add(HemomancerStrike.ID);
+//        retVal.add(HemomancerStrike.ID);
+
+        
+        retVal.add(HemomancerBlock.ID);
+//        retVal.add(HemomancerBlock.ID);
+//        retVal.add(HemomancerBlock.ID);
+//        retVal.add(HemomancerBlock.ID);
+        retVal.add(HemomancerBloodPump.ID);
+        retVal.add(HemomancerFlay.ID);
+        return retVal;
+    }
+    
+    public ArrayList<String> getStartingRelics() {
+        ArrayList<String> retVal = new ArrayList<>();
+        
+        retVal.add(BloodMistRelic.ID);
+
+        UnlockTracker.markRelicAsSeen(BloodMistRelic.ID);
+
+        return retVal;
+    }
+    
+    @Override
+    public void doCharSelectScreenSelectEffect() {
+        CardCrawlGame.sound.playA("ATTACK_DAGGER_1", 1.25f);
+        CardCrawlGame.screenShake.shake(ScreenShake.ShakeIntensity.LOW, ScreenShake.ShakeDur.SHORT,
+                false);
+    }
+    
+    @Override
+    public String getCustomModeCharacterButtonSoundKey() {
+        return "ATTACK_DAGGER_1";
+    }
+    
+    @Override
+    public int getAscensionMaxHPLoss() {
+        return 0;
+    }
+    
+    @Override
+    public AbstractCard.CardColor getCardColor() {
+        return COLOR_GRAY;
+    }
+    
+    @Override
+    public Color getCardTrailColor() {
+        return HemomancerMod.DEFAULT_GRAY;
+    }
+    
+    @Override
+    public BitmapFont getEnergyNumFont() {
+        return FontHelper.energyNumFontRed;
+    }
+    
+    @Override
+    public String getLocalizedCharacterName() {
+        return NAMES[0];
+    }
+    
+    @Override
+    public AbstractCard getStartCardForEvent() {
+        return new HemomancerStrike();
+    }
+    
+    @Override
+    public String getTitle(AbstractPlayer.PlayerClass playerClass) {
+        return NAMES[1];
+    }
+    
+    @Override
+    public AbstractPlayer newInstance() {
+        return new Hemomancer(name, chosenClass);
+    }
+    
+    @Override
+    public Color getCardRenderColor() {
+        return HemomancerMod.DEFAULT_GRAY;
+    }
+    
+    @Override
+    public Color getSlashAttackColor() {
+        return HemomancerMod.DEFAULT_GRAY;
+    }
+    
+    @Override
+    public AbstractGameAction.AttackEffect[] getSpireHeartSlashEffect() {
+        return new AbstractGameAction.AttackEffect[]{
+                AbstractGameAction.AttackEffect.BLUNT_HEAVY,
+                AbstractGameAction.AttackEffect.BLUNT_HEAVY,
+                AbstractGameAction.AttackEffect.BLUNT_HEAVY};
+    }
+    
+    @Override
+    public String getSpireHeartText() {
+        return TEXT[1];
+    }
+    
+    @Override
+    public String getVampireText() {
+        return TEXT[2];
+    }
+}

src/main/java/hemomancer/events/IdentityCrisisEvent.java

@@ -0,0 +1,117 @@
+package hemomancer.events;
+
+import com.megacrit.cardcrawl.cards.AbstractCard;
+import com.megacrit.cardcrawl.cards.CardGroup;
+import com.megacrit.cardcrawl.cards.colorless.Apotheosis;
+import com.megacrit.cardcrawl.core.CardCrawlGame;
+import com.megacrit.cardcrawl.core.Settings;
+import com.megacrit.cardcrawl.dungeons.AbstractDungeon;
+import com.megacrit.cardcrawl.events.AbstractImageEvent;
+import com.megacrit.cardcrawl.helpers.RelicLibrary;
+import com.megacrit.cardcrawl.helpers.ScreenShake;
+import com.megacrit.cardcrawl.localization.EventStrings;
+import com.megacrit.cardcrawl.relics.AbstractRelic;
+import com.megacrit.cardcrawl.vfx.cardManip.PurgeCardEffect;
+import com.megacrit.cardcrawl.vfx.cardManip.ShowCardAndObtainEffect;
+import hemomancer.HemomancerMod;
+
+import static hemomancer.HemomancerMod.makeEventPath;
+
+public class IdentityCrisisEvent extends AbstractImageEvent {
+    
+    public static final String ID = HemomancerMod.makeID("IdentityCrisisEvent");
+    private static final EventStrings eventStrings = CardCrawlGame.languagePack.getEventString(ID);
+    
+    private static final String NAME = eventStrings.NAME;
+    private static final String[] DESCRIPTIONS = eventStrings.DESCRIPTIONS;
+    private static final String[] OPTIONS = eventStrings.OPTIONS;
+    public static final String IMG = makeEventPath("IdentityCrisisEvent.png");
+    
+    private int screenNum = 0;
+    
+    private float HEALTH_LOSS_PERCENTAGE = 0.03F;
+    private float HEALTH_LOSS_PERCENTAGE_LOW_ASCENSION = 0.05F;
+    
+    private int healthdamage;
+    
+    public IdentityCrisisEvent() {
+        super(NAME, DESCRIPTIONS[0], IMG);
+        
+        if (AbstractDungeon.ascensionLevel >= 15) {
+            healthdamage = (int) ((float) AbstractDungeon.player.maxHealth * HEALTH_LOSS_PERCENTAGE);
+        } else {
+            healthdamage = (int) ((float) AbstractDungeon.player.maxHealth * HEALTH_LOSS_PERCENTAGE_LOW_ASCENSION);
+        }
+        
+        imageEventText.setDialogOption(OPTIONS[0]);
+        imageEventText.setDialogOption(OPTIONS[1] + healthdamage + OPTIONS[2]);
+        imageEventText.setDialogOption(OPTIONS[3], new Apotheosis());
+        imageEventText.setDialogOption(OPTIONS[4]);
+    }
+    
+    @Override
+    protected void buttonEffect(int i) {
+        switch (screenNum) {
+            case 0:
+                switch (i) {
+                    case 0:
+                        this.imageEventText.updateBodyText(DESCRIPTIONS[1]);
+                        this.imageEventText.updateDialogOption(0, OPTIONS[5]);
+                        this.imageEventText.clearRemainingOptions();
+                        screenNum = 1;
+                        AbstractRelic relicToAdd = RelicLibrary.starterList.get(AbstractDungeon.relicRng.random(RelicLibrary.starterList.size() - 1)).makeCopy();
+                        AbstractDungeon.getCurrRoom().spawnRelicAndObtain((float) (Settings.WIDTH / 2), (float) (Settings.HEIGHT / 2), relicToAdd);
+                        break;
+                    case 1:
+                        CardCrawlGame.screenShake.shake(ScreenShake.ShakeIntensity.MED, ScreenShake.ShakeDur.MED, false);
+                        CardCrawlGame.sound.play("BLUNT_FAST");
+                        AbstractDungeon.player.decreaseMaxHealth(healthdamage);
+                        if (CardGroup.getGroupWithoutBottledCards(AbstractDungeon.player.masterDeck.getPurgeableCards()).size() > 0) {
+                            AbstractDungeon.gridSelectScreen.open(
+                                    CardGroup.getGroupWithoutBottledCards(
+                                            AbstractDungeon.player.masterDeck.getPurgeableCards()),
+                                    1, OPTIONS[6], false, false, false, true);
+                        }
+                        
+                        this.imageEventText.updateBodyText(DESCRIPTIONS[2]);
+                        this.imageEventText.updateDialogOption(0, OPTIONS[5]);
+                        this.imageEventText.clearRemainingOptions();
+                        screenNum = 1;
+                        break;
+                    case 2:
+                        AbstractCard c = new Apotheosis().makeCopy();
+                        AbstractDungeon.effectList.add(new ShowCardAndObtainEffect(c, (float) (Settings.WIDTH / 2), (float) (Settings.HEIGHT / 2)));
+                        this.imageEventText.updateBodyText(DESCRIPTIONS[3]);
+                        this.imageEventText.updateDialogOption(0, OPTIONS[5]);
+                        this.imageEventText.clearRemainingOptions();
+                        screenNum = 1;
+                        break;
+                    case 3:
+                        imageEventText.loadImage("hemomancerResources/images/events/IdentityCrisisEvent2.png");
+                        this.imageEventText.updateBodyText(DESCRIPTIONS[4]);
+                        this.imageEventText.updateDialogOption(0, OPTIONS[5]);
+                        this.imageEventText.clearRemainingOptions();
+                        screenNum = 1;
+                        break;
+                }
+                break;
+            case 1:
+                switch (i) {
+                    case 0:
+                        openMap();
+                        break;
+                }
+                break;
+        }
+    }
+    
+    public void update() {
+        super.update();
+        if (!AbstractDungeon.gridSelectScreen.selectedCards.isEmpty()) {
+            AbstractCard c = AbstractDungeon.gridSelectScreen.selectedCards.get(0);
+            AbstractDungeon.topLevelEffects.add(new PurgeCardEffect(c, (float) (Settings.WIDTH / 2), (float) (Settings.HEIGHT / 2)));
+            AbstractDungeon.player.masterDeck.removeCard(c);
+            AbstractDungeon.gridSelectScreen.selectedCards.clear();
+        }
+    }
+}

src/main/java/hemomancer/orbs/BloodMistOrb.java

@@ -0,0 +1,91 @@
+package hemomancer.orbs;
+
+import basemod.abstracts.CustomOrb;
+import com.megacrit.cardcrawl.actions.animations.VFXAction;
+import com.megacrit.cardcrawl.characters.AbstractPlayer;
+import com.megacrit.cardcrawl.core.CardCrawlGame;
+import com.megacrit.cardcrawl.dungeons.AbstractDungeon;
+import com.megacrit.cardcrawl.localization.OrbStrings;
+import com.megacrit.cardcrawl.orbs.AbstractOrb;
+import com.megacrit.cardcrawl.vfx.combat.OrbFlareEffect;
+import hemomancer.HemomancerMod;
+
+import java.util.Iterator;
+
+public class BloodMistOrb extends CustomOrb {
+    public static final String BLOODMIST_ID = HemomancerMod.makeID("BloodMistOrb");
+    private static final OrbStrings orbString = CardCrawlGame.languagePack.getOrbString(BLOODMIST_ID);
+    public static final String[] DESC = orbString.DESCRIPTION;
+
+    public BloodMistOrb() {
+        super(
+                BLOODMIST_ID,
+                orbString.NAME,
+                0,
+                0,
+                DESC[0],
+                DESC[1],
+                HemomancerMod.makeOrbPath("default_orb.png")
+        );
+    }
+
+    @Override
+    public void onEvoke() {
+        AbstractDungeon.player.heal(evokeAmount);
+    }
+
+    @Override
+    public void updateDescription() {
+        this.description = "Supplies " + this.evokeAmount + " maximum hit points for the purpose of sanguine cards.";
+
+    }
+
+    public void pump(int pumpAmount) {
+        float speedTime = 0.25F;
+        AbstractDungeon.actionManager.addToBottom(new VFXAction(new OrbFlareEffect(this, OrbFlareEffect.OrbFlareColor.DARK), speedTime));
+        this.evokeAmount += pumpAmount;
+        this.passiveAmount += pumpAmount;
+        this.updateDescription();
+    }
+
+    public void consume(AbstractPlayer player, int x) {
+        int diff = this.evokeAmount - x;
+        this.evokeAmount = Math.max(0, diff);
+        this.passiveAmount = Math.max(0, diff);
+        if (diff < 0) {
+            player.decreaseMaxHealth(-diff);
+        }
+    }
+
+    @Override
+    public AbstractOrb makeCopy() {
+        return new BloodMistOrb();
+    }
+
+    @Override
+    public void playChannelSFX() {
+        CardCrawlGame.sound.play("STS_SFX_VampireBite_v2", 0.1f);
+    }
+
+    public static int getBloodMistStacks(AbstractPlayer player) {
+        BloodMistOrb orb = getBloodMistOrb(player);
+        if (orb == null) {
+            return 0;
+        } else {
+            return orb.evokeAmount;
+        }
+    }
+
+    public static BloodMistOrb getBloodMistOrb(AbstractPlayer player) {
+        Iterator<AbstractOrb> orbs = player.orbs.iterator();
+        BloodMistOrb orb = null;
+        while (orbs.hasNext()) {
+            AbstractOrb rawOrb = orbs.next();
+            if (rawOrb instanceof BloodMistOrb) {
+                orb = (BloodMistOrb) rawOrb;
+                break;
+            }
+        }
+        return orb;
+    }
+}

src/main/java/hemomancer/orbs/DefaultOrb.java

@@ -0,0 +1,120 @@
+package hemomancer.orbs;
+
+import com.badlogic.gdx.Gdx;
+import com.badlogic.gdx.graphics.Color;
+import com.badlogic.gdx.graphics.Texture;
+import com.badlogic.gdx.graphics.g2d.SpriteBatch;
+import com.badlogic.gdx.math.MathUtils;
+import com.megacrit.cardcrawl.actions.AbstractGameAction;
+import com.megacrit.cardcrawl.actions.animations.VFXAction;
+import com.megacrit.cardcrawl.actions.common.DamageAllEnemiesAction;
+import com.megacrit.cardcrawl.actions.common.DrawCardAction;
+import com.megacrit.cardcrawl.actions.utility.SFXAction;
+import com.megacrit.cardcrawl.cards.DamageInfo;
+import com.megacrit.cardcrawl.core.CardCrawlGame;
+import com.megacrit.cardcrawl.core.Settings;
+import com.megacrit.cardcrawl.dungeons.AbstractDungeon;
+import com.megacrit.cardcrawl.localization.OrbStrings;
+import com.megacrit.cardcrawl.orbs.AbstractOrb;
+import com.megacrit.cardcrawl.vfx.combat.DarkOrbActivateEffect;
+import com.megacrit.cardcrawl.vfx.combat.DarkOrbPassiveEffect;
+import com.megacrit.cardcrawl.vfx.combat.OrbFlareEffect;
+import hemomancer.HemomancerMod;
+import hemomancer.util.TextureLoader;
+
+import static hemomancer.HemomancerMod.makeOrbPath;
+
+public class DefaultOrb extends AbstractOrb {
+    
+    public static final String ORB_ID = HemomancerMod.makeID("DefaultOrb");
+    private static final OrbStrings orbString = CardCrawlGame.languagePack.getOrbString(ORB_ID);
+    public static final String[] DESC = orbString.DESCRIPTION;
+    
+    private static final Texture IMG = TextureLoader.getTexture(makeOrbPath("default_orb.png"));
+    
+    private float vfxTimer = 1.0f;
+    private float vfxIntervalMin = 0.1f;
+    private float vfxIntervalMax = 0.4f;
+    private static final float ORB_WAVY_DIST = 0.04f;
+    private static final float PI_4 = 12.566371f;
+    
+    public DefaultOrb() {
+        ID = ORB_ID;
+        name = orbString.NAME;
+        img = IMG;
+        evokeAmount = baseEvokeAmount = 1;
+        passiveAmount = basePassiveAmount = 3;
+        updateDescription();
+        angle = MathUtils.random(360.0f);
+        channelAnimTimer = 0.5f;
+    }
+    
+    @Override
+    public void updateDescription() {
+        applyFocus();
+        description = DESC[0] + evokeAmount + DESC[1] + passiveAmount + DESC[2];
+    }
+    
+    @Override
+    public void applyFocus() {
+        passiveAmount = basePassiveAmount;
+        evokeAmount = baseEvokeAmount;
+    }
+    
+    @Override
+    public void onEvoke() {
+        AbstractDungeon.actionManager.addToBottom(
+                new DamageAllEnemiesAction(AbstractDungeon.player,
+                        DamageInfo.createDamageMatrix(evokeAmount, true, true),
+                        DamageInfo.DamageType.THORNS, AbstractGameAction.AttackEffect.NONE));
+        
+        AbstractDungeon.actionManager.addToBottom(new SFXAction("TINGSHA"));
+    }
+    
+    @Override
+    public void onStartOfTurn() {
+        AbstractDungeon.actionManager.addToBottom(
+                new VFXAction(new OrbFlareEffect(this, OrbFlareEffect.OrbFlareColor.FROST), 0.1f));
+        AbstractDungeon.actionManager.addToBottom(
+                new DrawCardAction(AbstractDungeon.player, passiveAmount));
+    }
+    
+    @Override
+    public void updateAnimation() {
+        
+        super.updateAnimation();
+        angle += Gdx.graphics.getDeltaTime() * 45.0f;
+        vfxTimer -= Gdx.graphics.getDeltaTime();
+        if (vfxTimer < 0.0f) {
+            AbstractDungeon.effectList.add(new DarkOrbPassiveEffect(cX, cY));
+            vfxTimer = MathUtils.random(vfxIntervalMin, vfxIntervalMax);
+        }
+    }
+    
+    @Override
+    public void render(SpriteBatch sb) {
+        sb.setColor(new Color(1.0f, 1.0f, 1.0f, c.a / 2.0f));
+        sb.draw(img, cX - 48.0f, cY - 48.0f + bobEffect.y, 48.0f, 48.0f, 96.0f, 96.0f, scale + MathUtils.sin(angle / PI_4) * ORB_WAVY_DIST * Settings.scale, scale, angle, 0, 0, 96, 96, false, false);
+        sb.setColor(new Color(1.0f, 1.0f, 1.0f, this.c.a / 2.0f));
+        sb.setBlendFunction(770, 1);
+        sb.draw(img, cX - 48.0f, cY - 48.0f + bobEffect.y, 48.0f, 48.0f, 96.0f, 96.0f, scale, scale + MathUtils.sin(angle / PI_4) * ORB_WAVY_DIST * Settings.scale, -angle, 0, 0, 96, 96, false, false);
+        sb.setBlendFunction(770, 771);
+        renderText(sb);
+        hb.render(sb);
+    }
+    
+    @Override
+    public void triggerEvokeAnimation() {
+        AbstractDungeon.effectsQueue.add(new DarkOrbActivateEffect(cX, cY));
+    }
+    
+    @Override
+    public void playChannelSFX() {
+        CardCrawlGame.sound.play("ATTACK_FIRE", 0.1f);
+    }
+    
+    @Override
+    public AbstractOrb makeCopy() {
+        return new DefaultOrb();
+    }
+}

src/main/java/hemomancer/patches/DefaultInsertPatch.java

@@ -0,0 +1,35 @@
+package hemomancer.patches;
+
+import com.evacipated.cardcrawl.modthespire.lib.*;
+import com.megacrit.cardcrawl.dungeons.AbstractDungeon;
+import com.megacrit.cardcrawl.helpers.RelicLibrary;
+import com.megacrit.cardcrawl.relics.AbstractRelic;
+import javassist.CtBehavior;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+@SpirePatch(
+        clz = AbstractDungeon.class,
+        method = "returnRandomRelicKey"
+
+)
+public class DefaultInsertPatch {
+    private static final Logger logger = LogManager.getLogger(DefaultInsertPatch.class.getName());
+    
+    @SpireInsertPatch(
+            locator = Locator.class,
+            localvars = {"retVal"}
+    )
+    public static void thisIsOurActualPatchMethod(
+            AbstractRelic.RelicTier tier, String retVal) {
+        logger.info("Hey our patch triggered. The relic we're about to get is " + retVal);
+    }
+    
+    private static class Locator extends SpireInsertLocator {
+        @Override
+        public int[] Locate(CtBehavior ctMethodToPatch) throws Exception {
+            Matcher finalMatcher = new Matcher.MethodCallMatcher(RelicLibrary.class, "getRelic");
+            return LineFinder.findInOrder(ctMethodToPatch, finalMatcher);
+        }
+    }
+}

src/main/java/hemomancer/patches/relics/BottledPlaceholderField.java

@@ -0,0 +1,18 @@
+package hemomancer.patches.relics;
+
+import com.evacipated.cardcrawl.modthespire.lib.SpireField;
+import com.evacipated.cardcrawl.modthespire.lib.SpirePatch;
+import com.megacrit.cardcrawl.cards.AbstractCard;
+
+@SpirePatch(clz = AbstractCard.class, method = SpirePatch.CLASS)
+public class BottledPlaceholderField {
+    public static SpireField<Boolean> inBottledPlaceholderField = new SpireField<>(() -> false);
+    
+    @SpirePatch(clz = AbstractCard.class, method = "makeStatEquivalentCopy")
+    public static class MakeStatEquivalentCopy {
+        public static AbstractCard Postfix(AbstractCard result, AbstractCard self) {
+            inBottledPlaceholderField.set(result, inBottledPlaceholderField.get(self));
+            return result;
+        }
+    }
+}

src/main/java/hemomancer/potions/PlaceholderPotion.java

@@ -0,0 +1,55 @@
+package hemomancer.potions;
+
+import com.megacrit.cardcrawl.actions.common.ApplyPowerAction;
+import com.megacrit.cardcrawl.core.AbstractCreature;
+import com.megacrit.cardcrawl.core.CardCrawlGame;
+import com.megacrit.cardcrawl.dungeons.AbstractDungeon;
+import com.megacrit.cardcrawl.helpers.PowerTip;
+import com.megacrit.cardcrawl.localization.PotionStrings;
+import com.megacrit.cardcrawl.potions.AbstractPotion;
+import com.megacrit.cardcrawl.powers.LoseStrengthPower;
+import com.megacrit.cardcrawl.powers.StrengthPower;
+import com.megacrit.cardcrawl.rooms.AbstractRoom;
+import hemomancer.HemomancerMod;
+
+public class PlaceholderPotion extends AbstractPotion {
+    
+    public static final String POTION_ID = HemomancerMod.makeID("PlaceholderPotion");
+    private static final PotionStrings potionStrings = CardCrawlGame.languagePack.getPotionString(POTION_ID);
+    
+    public static final String NAME = potionStrings.NAME;
+    public static final String[] DESCRIPTIONS = potionStrings.DESCRIPTIONS;
+    
+    public PlaceholderPotion() {
+        super(NAME, POTION_ID, PotionRarity.COMMON, PotionSize.M, PotionColor.SMOKE);
+        potency = getPotency();
+        description = DESCRIPTIONS[0] + potency + DESCRIPTIONS[2] + DESCRIPTIONS[1] + potency + DESCRIPTIONS[2];
+        isThrown = false;
+        tips.add(new PowerTip(name, description));
+    }
+    
+    @Override
+    public void use(AbstractCreature target) {
+        target = AbstractDungeon.player;
+        if (AbstractDungeon.getCurrRoom().phase == AbstractRoom.RoomPhase.COMBAT) {
+            AbstractDungeon.actionManager.addToBottom(new ApplyPowerAction(target, AbstractDungeon.player, new StrengthPower(target, potency), potency));
+            AbstractDungeon.actionManager.addToBottom(new ApplyPowerAction(target, AbstractDungeon.player, new LoseStrengthPower(target, potency), potency));
+        }
+    }
+    
+    @Override
+    public AbstractPotion makeCopy() {
+        return new PlaceholderPotion();
+    }
+    
+    @Override
+    public int getPotency(final int potency) {
+        return 2;
+    }
+    
+    public void upgradePotion() {
+        potency += 1;
+        tips.clear();
+        tips.add(new PowerTip(name, description));
+    }
+}

src/main/java/hemomancer/powers/CommonPower.java

@@ -0,0 +1,85 @@
+package hemomancer.powers;
+
+import basemod.interfaces.CloneablePowerInterface;
+import com.badlogic.gdx.graphics.Texture;
+import com.badlogic.gdx.graphics.g2d.TextureAtlas;
+import com.megacrit.cardcrawl.actions.common.ApplyPowerAction;
+import com.megacrit.cardcrawl.actions.common.ReducePowerAction;
+import com.megacrit.cardcrawl.actions.utility.UseCardAction;
+import com.megacrit.cardcrawl.cards.AbstractCard;
+import com.megacrit.cardcrawl.core.AbstractCreature;
+import com.megacrit.cardcrawl.core.CardCrawlGame;
+import com.megacrit.cardcrawl.dungeons.AbstractDungeon;
+import com.megacrit.cardcrawl.localization.PowerStrings;
+import com.megacrit.cardcrawl.powers.AbstractPower;
+import com.megacrit.cardcrawl.powers.DexterityPower;
+import hemomancer.HemomancerMod;
+import hemomancer.util.TextureLoader;
+
+import static hemomancer.HemomancerMod.makePowerPath;
+
+public class CommonPower extends AbstractPower implements CloneablePowerInterface {
+    public AbstractCreature source;
+    
+    public static final String POWER_ID = HemomancerMod.makeID("CommonPower");
+    private static final PowerStrings powerStrings = CardCrawlGame.languagePack.getPowerStrings(POWER_ID);
+    public static final String NAME = powerStrings.NAME;
+    public static final String[] DESCRIPTIONS = powerStrings.DESCRIPTIONS;
+    
+    private static final Texture tex84 = TextureLoader.getTexture(makePowerPath("placeholder_power84.png"));
+    private static final Texture tex32 = TextureLoader.getTexture(makePowerPath("placeholder_power32.png"));
+    
+    public CommonPower(final AbstractCreature owner, final AbstractCreature source, final int amount) {
+        name = NAME;
+        ID = POWER_ID;
+        
+        this.owner = owner;
+        this.amount = amount;
+        this.source = source;
+        
+        type = PowerType.BUFF;
+        isTurnBased = false;
+        
+        
+        this.region128 = new TextureAtlas.AtlasRegion(tex84, 0, 0, 84, 84);
+        this.region48 = new TextureAtlas.AtlasRegion(tex32, 0, 0, 32, 32);
+        
+        updateDescription();
+    }
+    
+    @Override
+    public void onUseCard(final AbstractCard card, final UseCardAction action) {
+        AbstractDungeon.actionManager.addToBottom(new ApplyPowerAction(owner, owner,
+                new DexterityPower(owner, amount), amount));
+    }
+    
+    @Override
+    public void atEndOfTurn(final boolean isPlayer) {
+        int count = 0;
+        for (final AbstractCard c : AbstractDungeon.actionManager.cardsPlayedThisTurn) {
+            ++count;
+        }
+        
+        if (count > 0) {
+            flash();
+            for (int i = 0; i < count; ++i) {
+                AbstractDungeon.actionManager.addToBottom(
+                        new ReducePowerAction(owner, owner, DexterityPower.POWER_ID, amount));
+            }
+        }
+    }
+    
+    @Override
+    public void updateDescription() {
+        if (amount == 1) {
+            description = DESCRIPTIONS[0] + amount + DESCRIPTIONS[1];
+        } else if (amount > 1) {
+            description = DESCRIPTIONS[0] + amount + DESCRIPTIONS[2];
+        }
+    }
+    
+    @Override
+    public AbstractPower makeCopy() {
+        return new CommonPower(owner, source, amount);
+    }
+}

src/main/java/hemomancer/powers/RarePower.java

@@ -0,0 +1,72 @@
+package hemomancer.powers;
+
+import basemod.interfaces.CloneablePowerInterface;
+import com.badlogic.gdx.graphics.Texture;
+import com.badlogic.gdx.graphics.g2d.TextureAtlas;
+import com.megacrit.cardcrawl.actions.utility.QueueCardAction;
+import com.megacrit.cardcrawl.cards.AbstractCard;
+import com.megacrit.cardcrawl.core.AbstractCreature;
+import com.megacrit.cardcrawl.core.CardCrawlGame;
+import com.megacrit.cardcrawl.dungeons.AbstractDungeon;
+import com.megacrit.cardcrawl.localization.PowerStrings;
+import com.megacrit.cardcrawl.monsters.AbstractMonster;
+import com.megacrit.cardcrawl.powers.AbstractPower;
+import hemomancer.HemomancerMod;
+import hemomancer.cards.HemomancerRareAttack;
+import hemomancer.util.TextureLoader;
+
+public class RarePower extends AbstractPower implements CloneablePowerInterface {
+    public AbstractCreature source;
+    
+    public static final String POWER_ID = HemomancerMod.makeID("RarePower");
+    private static final PowerStrings powerStrings = CardCrawlGame.languagePack.getPowerStrings(POWER_ID);
+    public static final String NAME = powerStrings.NAME;
+    public static final String[] DESCRIPTIONS = powerStrings.DESCRIPTIONS;
+    
+    private static final Texture tex84 = TextureLoader.getTexture("hemomancerResources/images/powers/placeholder_power84.png");
+    private static final Texture tex32 = TextureLoader.getTexture("hemomancerResources/images/powers/placeholder_power32.png");
+    
+    public RarePower(final AbstractCreature owner, final AbstractCreature source, final int amount) {
+        name = NAME;
+        ID = POWER_ID;
+        
+        this.owner = owner;
+        this.amount = amount;
+        this.source = source;
+        
+        type = PowerType.DEBUFF;
+        isTurnBased = false;
+        
+        this.region128 = new TextureAtlas.AtlasRegion(tex84, 0, 0, 84, 84);
+        this.region48 = new TextureAtlas.AtlasRegion(tex32, 0, 0, 32, 32);
+        
+        updateDescription();
+    }
+    
+    @Override
+    public void atStartOfTurn() {
+        AbstractCard playCard = new HemomancerRareAttack();
+        AbstractMonster targetMonster = AbstractDungeon.getRandomMonster();
+        playCard.freeToPlayOnce = true;
+        
+        if (playCard.type != AbstractCard.CardType.POWER) {
+            playCard.purgeOnUse = true;
+        }
+        
+        AbstractDungeon.actionManager.addToBottom(new QueueCardAction(playCard, targetMonster));
+    }
+    
+    @Override
+    public void updateDescription() {
+        if (amount == 1) {
+            description = DESCRIPTIONS[0] + amount + DESCRIPTIONS[1];
+        } else if (amount > 1) {
+            description = DESCRIPTIONS[0] + amount + DESCRIPTIONS[2];
+        }
+    }
+    
+    @Override
+    public AbstractPower makeCopy() {
+        return new RarePower(owner, source, amount);
+    }
+}

src/main/java/hemomancer/relics/BloodMistRelic.java

@@ -0,0 +1,27 @@
+package hemomancer.relics;
+
+import basemod.abstracts.CustomRelic;
+import com.badlogic.gdx.graphics.Texture;
+import com.megacrit.cardcrawl.actions.defect.ChannelAction;
+import com.megacrit.cardcrawl.dungeons.AbstractDungeon;
+import hemomancer.HemomancerMod;
+import hemomancer.orbs.BloodMistOrb;
+import hemomancer.orbs.DefaultOrb;
+import hemomancer.util.TextureLoader;
+
+
+public class BloodMistRelic extends CustomRelic {
+    public static final String ID = HemomancerMod.makeID("BloodMistRelic");
+
+    private static final Texture IMG = TextureLoader.getTexture(HemomancerMod.makeRelicPath("placeholder_relic.png"));
+    private static final Texture OUTLINE = TextureLoader.getTexture(HemomancerMod.makeRelicOutlinePath("placeholder_relic.png"));
+
+    public BloodMistRelic() {
+        super(ID, IMG, OUTLINE, RelicTier.STARTER, LandingSound.CLINK);
+    }
+
+    @Override
+    public void atBattleStartPreDraw() {
+        AbstractDungeon.actionManager.addToBottom(new ChannelAction(new BloodMistOrb()));
+    }
+}

src/main/java/hemomancer/relics/BottledPlaceholderRelic.java

@@ -0,0 +1,151 @@
+package hemomancer.relics;
+
+import basemod.BaseMod;
+import basemod.abstracts.CustomBottleRelic;
+import basemod.abstracts.CustomRelic;
+import basemod.abstracts.CustomSavable;
+import com.badlogic.gdx.graphics.Texture;
+import com.evacipated.cardcrawl.mod.stslib.actions.common.AutoplayCardAction;
+import com.evacipated.cardcrawl.mod.stslib.fields.cards.AbstractCard.AutoplayField;
+import com.megacrit.cardcrawl.actions.utility.UseCardAction;
+import com.megacrit.cardcrawl.cards.AbstractCard;
+import com.megacrit.cardcrawl.cards.CardGroup;
+import com.megacrit.cardcrawl.dungeons.AbstractDungeon;
+import com.megacrit.cardcrawl.helpers.FontHelper;
+import com.megacrit.cardcrawl.helpers.PowerTip;
+import com.megacrit.cardcrawl.relics.AbstractRelic;
+import com.megacrit.cardcrawl.rooms.AbstractRoom;
+import hemomancer.HemomancerMod;
+import hemomancer.patches.relics.BottledPlaceholderField;
+import hemomancer.util.TextureLoader;
+
+import java.util.Iterator;
+import java.util.function.Predicate;
+
+import static hemomancer.HemomancerMod.makeRelicOutlinePath;
+import static hemomancer.HemomancerMod.makeRelicPath;
+
+public class BottledPlaceholderRelic extends CustomRelic implements CustomBottleRelic, CustomSavable<Integer> {
+    
+    private static AbstractCard card;
+    private boolean cardSelected = true;
+    
+    public static final String ID = HemomancerMod.makeID("BottledPlaceholderRelic");
+    private static final Texture IMG = TextureLoader.getTexture(makeRelicPath("BottledPlaceholder.png"));
+    private static final Texture OUTLINE = TextureLoader.getTexture(makeRelicOutlinePath("BottledPlaceholder.png"));
+    
+    public BottledPlaceholderRelic() {
+        super(ID, IMG, OUTLINE, RelicTier.COMMON, LandingSound.CLINK);
+        tips.clear();
+        tips.add(new PowerTip(name, description));
+    }
+    
+    @Override
+    public Predicate<AbstractCard> isOnCard() {
+        return BottledPlaceholderField.inBottledPlaceholderField::get;
+    }
+    
+    @Override
+    public Integer onSave() {
+        if (card != null) {
+            return AbstractDungeon.player.masterDeck.group.indexOf(card);
+        } else {
+            return -1;
+        }
+    }
+    
+    @Override
+    public void onLoad(Integer cardIndex) {
+        if (cardIndex == null) {
+            return;
+        }
+        if (cardIndex >= 0 && cardIndex < AbstractDungeon.player.masterDeck.group.size()) {
+            card = AbstractDungeon.player.masterDeck.group.get(cardIndex);
+            if (card != null) {
+                BottledPlaceholderField.inBottledPlaceholderField.set(card, true);
+                setDescriptionAfterLoading();
+            }
+        }
+    }
+    
+    @Override
+    public void onEquip() {
+        cardSelected = false;
+        if (AbstractDungeon.isScreenUp) {
+            AbstractDungeon.dynamicBanner.hide();
+            AbstractDungeon.overlayMenu.cancelButton.hide();
+            AbstractDungeon.previousScreen = AbstractDungeon.screen;
+        }
+        AbstractDungeon.getCurrRoom().phase = AbstractRoom.RoomPhase.INCOMPLETE;
+        
+        CardGroup group = CardGroup.getGroupWithoutBottledCards(AbstractDungeon.player.masterDeck);
+        AbstractDungeon.gridSelectScreen.open(group, 1, DESCRIPTIONS[3] + name + DESCRIPTIONS[2], false, false, false, false);
+    }
+    
+    @Override
+    public void onUnequip() {
+        if (card != null) {
+            AbstractCard cardInDeck = AbstractDungeon.player.masterDeck.getSpecificCard(card);
+            if (cardInDeck != null) {
+                BottledPlaceholderField.inBottledPlaceholderField.set(cardInDeck, false);
+            }
+        }
+    }
+    
+    @Override
+    public void update() {
+        super.update();
+        if (!cardSelected && !AbstractDungeon.gridSelectScreen.selectedCards.isEmpty()) {
+            cardSelected = true;
+            card = AbstractDungeon.gridSelectScreen.selectedCards.get(0);
+            
+            BottledPlaceholderField.inBottledPlaceholderField.set(card, true);
+            if (AbstractDungeon.getCurrRoom().phase == AbstractRoom.RoomPhase.INCOMPLETE) {
+                AbstractDungeon.getCurrRoom().phase = AbstractRoom.RoomPhase.COMPLETE;
+            }
+            AbstractDungeon.getCurrRoom().phase = AbstractRoom.RoomPhase.COMPLETE;
+            AbstractDungeon.gridSelectScreen.selectedCards.clear();
+            setDescriptionAfterLoading();
+        }
+    }
+    
+    public void onUseCard(AbstractCard targetCard, UseCardAction useCardAction) {
+        boolean fullHandDialog = false;
+        for (Iterator<AbstractCard> it = AbstractDungeon.player.drawPile.group.iterator(); it.hasNext(); ) {
+            AbstractCard card = it.next();
+            if (BottledPlaceholderField.inBottledPlaceholderField.get(card)) {
+                this.flash();
+                it.remove();
+                if (AbstractDungeon.player.hand.size() < BaseMod.MAX_HAND_SIZE) {
+                    if (AutoplayField.autoplay.get(card)) {
+                        AbstractDungeon.actionManager.addToBottom(new AutoplayCardAction(card, AbstractDungeon.player.hand));
+                    }
+                    card.triggerWhenDrawn();
+                    AbstractDungeon.player.drawPile.moveToHand(card, AbstractDungeon.player.drawPile);
+                    
+                    for (AbstractRelic r : AbstractDungeon.player.relics) {
+                        r.onCardDraw(card);
+                    }
+                } else {
+                    if (!fullHandDialog) {
+                        AbstractDungeon.player.createHandIsFullDialog();
+                        fullHandDialog = true;
+                    }
+                    AbstractDungeon.player.drawPile.moveToDiscardPile(card);
+                }
+            }
+        }
+    }
+    
+    public void setDescriptionAfterLoading() {
+        this.description = DESCRIPTIONS[1] + FontHelper.colorString(card.name, "y") + DESCRIPTIONS[2];
+        this.tips.clear();
+        this.tips.add(new PowerTip(this.name, this.description));
+        this.initializeTips();
+    }
+    
+    @Override
+    public String getUpdatedDescription() {
+        return DESCRIPTIONS[0];
+    }
+}

src/main/java/hemomancer/relics/DefaultClickableRelic.java

@@ -0,0 +1,75 @@
+package hemomancer.relics;
+
+import basemod.abstracts.CustomRelic;
+import com.badlogic.gdx.graphics.Texture;
+import com.evacipated.cardcrawl.mod.stslib.relics.ClickableRelic;
+import com.megacrit.cardcrawl.actions.animations.TalkAction;
+import com.megacrit.cardcrawl.actions.animations.VFXAction;
+import com.megacrit.cardcrawl.actions.defect.EvokeOrbAction;
+import com.megacrit.cardcrawl.actions.utility.SFXAction;
+import com.megacrit.cardcrawl.dungeons.AbstractDungeon;
+import com.megacrit.cardcrawl.helpers.PowerTip;
+import com.megacrit.cardcrawl.rooms.AbstractRoom;
+import com.megacrit.cardcrawl.vfx.CollectorCurseEffect;
+import hemomancer.HemomancerMod;
+import hemomancer.util.TextureLoader;
+
+import static hemomancer.HemomancerMod.makeRelicOutlinePath;
+import static hemomancer.HemomancerMod.makeRelicPath;
+
+public class DefaultClickableRelic extends CustomRelic implements ClickableRelic {
+    
+    public static final String ID = HemomancerMod.makeID("DefaultClickableRelic");
+    
+    private static final Texture IMG = TextureLoader.getTexture(makeRelicPath("default_clickable_relic.png"));
+    private static final Texture OUTLINE = TextureLoader.getTexture(makeRelicOutlinePath("default_clickable_relic.png"));
+    
+    private boolean usedThisTurn = false;
+    
+    public DefaultClickableRelic() {
+        super(ID, IMG, OUTLINE, RelicTier.COMMON, LandingSound.CLINK);
+        
+        tips.clear();
+        tips.add(new PowerTip(name, description));
+    }
+    
+    @Override
+    public void onRightClick() {
+        if (!isObtained || usedThisTurn) {
+            return;
+        }
+        if (AbstractDungeon.getCurrRoom() != null && AbstractDungeon.getCurrRoom().phase == AbstractRoom.RoomPhase.COMBAT) {
+            usedThisTurn = true;
+            flash();
+            stopPulse();
+            
+            AbstractDungeon.actionManager.addToBottom(new TalkAction(true, DESCRIPTIONS[1], 4.0f, 2.0f));
+            AbstractDungeon.actionManager.addToBottom(new SFXAction("MONSTER_COLLECTOR_DEBUFF"));
+            AbstractDungeon.actionManager.addToBottom(new VFXAction(
+                    new CollectorCurseEffect(AbstractDungeon.getRandomMonster().hb.cX, AbstractDungeon.getRandomMonster().hb.cY), 2.0F));
+            
+            AbstractDungeon.actionManager.addToBottom(new EvokeOrbAction(1));
+        }
+    }
+    
+    public void atTurnStart() {
+        usedThisTurn = false;
+        beginLongPulse();
+    }
+    
+    @Override
+    public void atPreBattle() {
+        usedThisTurn = false;
+        beginLongPulse();
+    }
+    
+    @Override
+    public void onVictory() {
+        stopPulse();
+    }
+    
+    @Override
+    public String getUpdatedDescription() {
+        return DESCRIPTIONS[0];
+    }
+}

src/main/java/hemomancer/relics/PlaceholderRelic.java

@@ -0,0 +1,42 @@
+package hemomancer.relics;
+
+import basemod.abstracts.CustomRelic;
+import com.badlogic.gdx.graphics.Texture;
+import com.megacrit.cardcrawl.dungeons.AbstractDungeon;
+import hemomancer.HemomancerMod;
+import hemomancer.util.TextureLoader;
+
+import static hemomancer.HemomancerMod.makeRelicOutlinePath;
+import static hemomancer.HemomancerMod.makeRelicPath;
+
+public class PlaceholderRelic extends CustomRelic {
+    
+    public static final String ID = HemomancerMod.makeID("PlaceholderRelic");
+    
+    private static final Texture IMG = TextureLoader.getTexture(makeRelicPath("placeholder_relic.png"));
+    private static final Texture OUTLINE = TextureLoader.getTexture(makeRelicOutlinePath("placeholder_relic.png"));
+    
+    public PlaceholderRelic() {
+        super(ID, IMG, OUTLINE, RelicTier.STARTER, LandingSound.MAGICAL);
+    }
+    
+    @Override
+    public void atBattleStartPreDraw() {
+        flash();
+    }
+    
+    @Override
+    public void onEquip() {
+        AbstractDungeon.player.energy.energyMaster += 1;
+    }
+    
+    @Override
+    public void onUnequip() {
+        AbstractDungeon.player.energy.energyMaster -= 1;
+    }
+    
+    @Override
+    public String getUpdatedDescription() {
+        return DESCRIPTIONS[0];
+    }
+}

src/main/java/hemomancer/relics/PlaceholderRelic2.java

@@ -0,0 +1,37 @@
+package hemomancer.relics;
+
+import basemod.abstracts.CustomRelic;
+import com.badlogic.gdx.graphics.Texture;
+import com.megacrit.cardcrawl.actions.common.ApplyPowerAction;
+import com.megacrit.cardcrawl.actions.common.RelicAboveCreatureAction;
+import com.megacrit.cardcrawl.dungeons.AbstractDungeon;
+import com.megacrit.cardcrawl.powers.StrengthPower;
+import hemomancer.HemomancerMod;
+import hemomancer.util.TextureLoader;
+
+import static hemomancer.HemomancerMod.makeRelicOutlinePath;
+import static hemomancer.HemomancerMod.makeRelicPath;
+
+public class PlaceholderRelic2 extends CustomRelic {
+    
+    public static final String ID = HemomancerMod.makeID("PlaceholderRelic2");
+    
+    private static final Texture IMG = TextureLoader.getTexture(makeRelicPath("placeholder_relic2.png"));
+    private static final Texture OUTLINE = TextureLoader.getTexture(makeRelicOutlinePath("placeholder_relic2.png"));
+    
+    public PlaceholderRelic2() {
+        super(ID, IMG, OUTLINE, RelicTier.COMMON, LandingSound.FLAT);
+    }
+    
+    @Override
+    public void atBattleStart() {
+        flash();
+        AbstractDungeon.actionManager.addToTop(new ApplyPowerAction(AbstractDungeon.player, AbstractDungeon.player, new StrengthPower(AbstractDungeon.player, 1), 1));
+        AbstractDungeon.actionManager.addToTop(new RelicAboveCreatureAction(AbstractDungeon.player, this));
+    }
+    
+    @Override
+    public String getUpdatedDescription() {
+        return DESCRIPTIONS[0];
+    }
+}

src/main/java/hemomancer/util/IDCheckDontTouchPls.java

@@ -0,0 +1,10 @@
+package hemomancer.util;
+
+public class IDCheckDontTouchPls {
+    public String DEFAULTID;
+    public String DEVID;
+    public String EXCEPTION;
+    public String PACKAGE_EXCEPTION;
+    public String RESOURCE_FOLDER_EXCEPTION;
+    public String RESOURCES;
+}

src/main/java/hemomancer/util/TextureLoader.java

@@ -0,0 +1,45 @@
+package hemomancer.util;
+
+import com.badlogic.gdx.graphics.Texture;
+import com.badlogic.gdx.graphics.Texture.TextureFilter;
+import com.badlogic.gdx.utils.GdxRuntimeException;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.util.HashMap;
+
+public class TextureLoader {
+    private static HashMap<String, Texture> textures = new HashMap<String, Texture>();
+    public static final Logger logger = LogManager.getLogger(TextureLoader.class.getName());
+    
+    /**
+     * @param textureString - String path to the texture you want to load relative to resources,
+     *                      Example: "theDefaultResources/images/ui/missing_texture.png"
+     * @return <b>com.badlogic.gdx.graphics.Texture</b> - The texture from the path provided
+     */
+    public static Texture getTexture(final String textureString) {
+        if (textures.get(textureString) == null) {
+            try {
+                loadTexture(textureString);
+            } catch (GdxRuntimeException e) {
+                logger.error("Could not find texture: " + textureString);
+                return getTexture("hemomancerResources/images/ui/missing_texture.png");
+            }
+        }
+        return textures.get(textureString);
+    }
+    
+    /**
+     * Creates an instance of the texture, applies a linear filter to it, and places it in the HashMap
+     *
+     * @param textureString - String path to the texture you want to load relative to resources,
+     *                      Example: "img/ui/missingtexture.png"
+     * @throws GdxRuntimeException
+     */
+    private static void loadTexture(final String textureString) throws GdxRuntimeException {
+        logger.info("DefaultMod | Loading Texture: " + textureString);
+        Texture texture = new Texture(textureString);
+        texture.setFilter(TextureFilter.Linear, TextureFilter.Linear);
+        textures.put(textureString, texture);
+    }
+}

src/main/java/hemomancer/variables/DefaultCustomVariable.java

@@ -0,0 +1,46 @@
+package hemomancer.variables;
+
+import basemod.abstracts.DynamicVariable;
+import com.megacrit.cardcrawl.cards.AbstractCard;
+import com.megacrit.cardcrawl.ui.panels.EnergyPanel;
+
+import static hemomancer.HemomancerMod.makeID;
+
+public class DefaultCustomVariable extends DynamicVariable {
+
+    private int currentValue = 0;
+    
+    @Override
+    public String key() {
+        return makeID("ENERGY_DAMAGE");
+    }
+    
+    @Override
+    public boolean isModified(AbstractCard card) {
+        return card.isDamageModified;
+    }
+    
+    @Override
+    public int value(AbstractCard card) {
+        return getCurrentValue();
+    }
+    
+    @Override
+    public int baseValue(AbstractCard card) {
+        return card.baseDamage * EnergyPanel.getCurrentEnergy();
+    }
+    
+    @Override
+    public boolean upgraded(AbstractCard card) {
+        return card.upgradedDamage;
+    }
+
+
+    public int getCurrentValue() {
+        return currentValue;
+    }
+
+    public void setCurrentValue(int currentValue) {
+        this.currentValue = currentValue;
+    }
+}

src/main/java/hemomancer/variables/DefaultSecondMagicNumber.java

@@ -0,0 +1,35 @@
+package hemomancer.variables;
+
+import basemod.abstracts.DynamicVariable;
+import com.megacrit.cardcrawl.cards.AbstractCard;
+import hemomancer.cards.AbstractHemomancerCard;
+
+import static hemomancer.HemomancerMod.makeID;
+
+public class DefaultSecondMagicNumber extends DynamicVariable {
+    
+    @Override
+    public String key() {
+        return makeID("SecondMagic");
+    }
+    
+    @Override
+    public boolean isModified(AbstractCard card) {
+        return ((AbstractHemomancerCard) card).isDefaultSecondMagicNumberModified;
+    }
+    
+    @Override
+    public int value(AbstractCard card) {
+        return ((AbstractHemomancerCard) card).defaultSecondMagicNumber;
+    }
+    
+    @Override
+    public int baseValue(AbstractCard card) {
+        return ((AbstractHemomancerCard) card).defaultBaseSecondMagicNumber;
+    }
+    
+    @Override
+    public boolean upgraded(AbstractCard card) {
+        return ((AbstractHemomancerCard) card).upgradedDefaultSecondMagicNumber;
+    }
+}

src/main/java/hemomancer/variables/HemomancerBloodMistVar.java

@@ -0,0 +1,32 @@
+package hemomancer.variables;
+
+import basemod.abstracts.DynamicVariable;
+import com.megacrit.cardcrawl.cards.AbstractCard;
+import hemomancer.HemomancerMod;
+
+public class HemomancerBloodMistVar extends DynamicVariable {
+    @Override
+    public String key() {
+        return HemomancerMod.makeID("BloodMistVar");
+    }
+
+    @Override
+    public boolean isModified(AbstractCard abstractCard) {
+        return false;
+    }
+
+    @Override
+    public int value(AbstractCard abstractCard) {
+        return 0;
+    }
+
+    @Override
+    public int baseValue(AbstractCard abstractCard) {
+        return 0;
+    }
+
+    @Override
+    public boolean upgraded(AbstractCard abstractCard) {
+        return false;
+    }
+}

src/main/resources/IDCheckStringsDONT-EDIT-AT-ALL.json

@@ -0,0 +1,8 @@
+{
+  "DEFAULTID": "theDefault",
+  "DEVID": "theDefaultDev",
+  "EXCEPTION": "Go to your constructor in your class with SpireInitializer and change your mod ID from \"theDefault\"",
+  "PACKAGE_EXCEPTION": "Rename your theDefault folder (package) to match your mod ID! ",
+  "RESOURCE_FOLDER_EXCEPTION": "Rename your theDefaultResources folder to match your mod ID!",
+  "RESOURCES": "Resources"
+}

src/main/resources/ModTheSpire.json

@@ -0,0 +1,12 @@
+{
+  "modid": "${project.artifactId}",
+  "name": "${project.name}",
+  "author_list": ["Virgil"],
+  "description": "${project.description}",
+  "version": "${project.version}",
+  "sts_version": "${SlayTheSpire.version}",
+  "mts_version": "${ModTheSpire.version}",
+  "dependencies": ["basemod", "stslib"],
+  "update_json": ""
+}
+

src/main/resources/hemomancerResources/images/char/defaultCharacter/Spriter/theDefaultAnimation.autosave.scml

@@ -0,0 +1,149 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<spriter_data scml_version="1.0" generator="BrashMonkey Spriter" generator_version="r11">
+    <folder id="0">
+        <file id="0" name="object1.png" width="109" height="114" pivot_x="0" pivot_y="1"/>
+        <file id="1" name="object2.png" width="40" height="40" pivot_x="0" pivot_y="1"/>
+        <file id="2" name="object3.png" width="123" height="31" pivot_x="0" pivot_y="1"/>
+    </folder>
+    <entity id="0" name="entity_000">
+        <obj_info name="bone_000" type="bone" w="28.6989" h="10"/>
+        <obj_info name="bone_001" type="bone" w="87.401" h="10"/>
+        <obj_info name="bone_002" type="bone" w="106.964" h="10"/>
+        <obj_info name="bone_003" type="bone" w="64.3493" h="10"/>
+        <obj_info name="bone_004" type="bone" w="85.6919" h="10"/>
+        <animation id="0" name="NewAnimation" length="3000" interval="100">
+            <mainline>
+                <key id="0">
+                    <bone_ref id="0" timeline="6" key="0"/>
+                    <bone_ref id="1" parent="0" timeline="7" key="0"/>
+                    <bone_ref id="2" parent="0" timeline="8" key="0"/>
+                    <bone_ref id="3" parent="0" timeline="9" key="0"/>
+                    <bone_ref id="4" parent="0" timeline="10" key="0"/>
+                    <object_ref id="0" timeline="2" key="0" z_index="0"/>
+                    <object_ref id="1" timeline="0" key="0" z_index="1"/>
+                    <object_ref id="2" parent="3" timeline="1" key="0" z_index="2"/>
+                    <object_ref id="3" parent="2" timeline="3" key="0" z_index="3"/>
+                    <object_ref id="4" parent="4" timeline="4" key="0" z_index="4"/>
+                    <object_ref id="5" parent="1" timeline="5" key="0" z_index="5"/>
+                </key>
+                <key id="1" time="750">
+                    <bone_ref id="0" timeline="6" key="1"/>
+                    <bone_ref id="1" parent="0" timeline="7" key="0"/>
+                    <bone_ref id="2" parent="0" timeline="8" key="0"/>
+                    <bone_ref id="3" parent="0" timeline="9" key="0"/>
+                    <bone_ref id="4" parent="0" timeline="10" key="0"/>
+                    <object_ref id="0" timeline="2" key="0" z_index="0"/>
+                    <object_ref id="1" timeline="0" key="0" z_index="1"/>
+                    <object_ref id="2" parent="3" timeline="1" key="0" z_index="2"/>
+                    <object_ref id="3" parent="2" timeline="3" key="0" z_index="3"/>
+                    <object_ref id="4" parent="4" timeline="4" key="0" z_index="4"/>
+                    <object_ref id="5" parent="1" timeline="5" key="0" z_index="5"/>
+                </key>
+                <key id="2" time="1500" curve_type="cubic" c1="0.706468" c2="0.78607">
+                    <bone_ref id="0" timeline="6" key="2"/>
+                    <bone_ref id="1" parent="0" timeline="7" key="1"/>
+                    <bone_ref id="2" parent="0" timeline="8" key="1"/>
+                    <bone_ref id="3" parent="0" timeline="9" key="1"/>
+                    <bone_ref id="4" parent="0" timeline="10" key="1"/>
+                    <object_ref id="0" timeline="2" key="1" z_index="0"/>
+                    <object_ref id="1" timeline="0" key="1" z_index="1"/>
+                    <object_ref id="2" parent="3" timeline="1" key="1" z_index="2"/>
+                    <object_ref id="3" parent="2" timeline="3" key="1" z_index="3"/>
+                    <object_ref id="4" parent="4" timeline="4" key="1" z_index="4"/>
+                    <object_ref id="5" parent="1" timeline="5" key="1" z_index="5"/>
+                </key>
+            </mainline>
+            <timeline id="0" name="object1">
+                <key id="0" spin="0">
+                    <object folder="0" file="0" x="-54.223101" y="215.801131"/>
+                </key>
+                <key id="1" time="1500" spin="0">
+                    <object folder="0" file="0" x="-54.223101" y="157.801131"/>
+                </key>
+            </timeline>
+            <timeline id="1" name="object2">
+                <key id="0" spin="0">
+                    <object folder="0" file="1" x="72.229964" y="-19.533164" angle="90.387128"/>
+                </key>
+                <key id="1" time="1500" spin="0">
+                    <object folder="0" file="1" x="38.732849" y="-20.267103" angle="90.387128"/>
+                </key>
+            </timeline>
+            <timeline id="2" name="object3">
+                <key id="0" spin="0">
+                    <object folder="0" file="2" x="-62.86722" y="4.012448"/>
+                </key>
+                <key id="1" time="1500" spin="0">
+                    <object folder="0" file="2" x="-62.86722" y="4.012448"/>
+                </key>
+            </timeline>
+            <timeline id="3" name="object2_000">
+                <key id="0" spin="0">
+                    <object folder="0" file="1" x="100.260439" y="17.255078" angle="0.395137"/>
+                </key>
+                <key id="1" time="1500" spin="0">
+                    <object folder="0" file="1" x="54.190758" y="25.51983" angle="0.395137"/>
+                </key>
+            </timeline>
+            <timeline id="4" name="object2_001">
+                <key id="0" spin="0">
+                    <object folder="0" file="1" x="135.495569" y="-18.156697" angle="181.74451"/>
+                </key>
+                <key id="1" time="1500" spin="0">
+                    <object folder="0" file="1" x="98.397247" y="-19.333472" angle="181.74451"/>
+                </key>
+            </timeline>
+            <timeline id="5" name="object2_002">
+                <key id="0" spin="0">
+                    <object folder="0" file="1" x="116.914366" y="17.820602" angle="269.144903"/>
+                </key>
+                <key id="1" time="1500" spin="0">
+                    <object folder="0" file="1" x="96.296043" y="16.785012" angle="269.144903"/>
+                </key>
+            </timeline>
+            <timeline id="6" obj="0" name="bone_000" object_type="bone">
+                <key id="0" spin="-1">
+                    <bone x="4.670551" y="119.735545" angle="90.868051"/>
+                </key>
+                <key id="1" time="750" spin="-1">
+                    <bone x="4.670551" y="119.735545" angle="0"/>
+                </key>
+                <key id="2" time="1500" spin="-1">
+                    <bone x="4.670551" y="119.735545" angle="270"/>
+                </key>
+            </timeline>
+            <timeline id="7" obj="1" name="bone_001" object_type="bone">
+                <key id="0" spin="0">
+                    <bone x="35.661256" y="0.329343" angle="359.987046"/>
+                </key>
+                <key id="1" time="1500" spin="0">
+                    <bone x="35.661256" y="0.329343" angle="359.987046"/>
+                </key>
+            </timeline>
+            <timeline id="8" obj="2" name="bone_002" object_type="bone">
+                <key id="0" spin="0">
+                    <bone x="12.89707" y="-9.761725" angle="268.736812"/>
+                </key>
+                <key id="1" time="1500" spin="0">
+                    <bone x="12.89707" y="-9.761725" angle="268.736812"/>
+                </key>
+            </timeline>
+            <timeline id="9" obj="3" name="bone_003" object_type="bone">
+                <key id="0" spin="0">
+                    <bone x="-13.885099" y="1.94971" angle="178.744821"/>
+                </key>
+                <key id="1" time="1500" spin="0">
+                    <bone x="-13.885099" y="1.94971" angle="178.744821"/>
+                </key>
+            </timeline>
+            <timeline id="10" obj="4" name="bone_004" object_type="bone">
+                <key id="0" spin="0">
+                    <bone x="13.634799" y="10.229392" angle="87.387439"/>
+                </key>
+                <key id="1" time="1500" spin="0">
+                    <bone x="13.634799" y="10.229392" angle="87.387439"/>
+                </key>
+            </timeline>
+        </animation>
+    </entity>
+</spriter_data>

src/main/resources/hemomancerResources/images/char/defaultCharacter/Spriter/theDefaultAnimation.scml

@@ -0,0 +1,149 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<spriter_data scml_version="1.0" generator="BrashMonkey Spriter" generator_version="r11">
+    <folder id="0">
+        <file id="0" name="object1.png" width="109" height="114" pivot_x="0" pivot_y="1"/>
+        <file id="1" name="object2.png" width="40" height="40" pivot_x="0" pivot_y="1"/>
+        <file id="2" name="object3.png" width="123" height="31" pivot_x="0" pivot_y="1"/>
+    </folder>
+    <entity id="0" name="entity_000">
+        <obj_info name="bone_000" type="bone" w="28.6989" h="10"/>
+        <obj_info name="bone_001" type="bone" w="87.401" h="10"/>
+        <obj_info name="bone_002" type="bone" w="106.964" h="10"/>
+        <obj_info name="bone_003" type="bone" w="64.3493" h="10"/>
+        <obj_info name="bone_004" type="bone" w="85.6919" h="10"/>
+        <animation id="0" name="NewAnimation" length="3000" interval="100">
+            <mainline>
+                <key id="0">
+                    <bone_ref id="0" timeline="6" key="0"/>
+                    <bone_ref id="1" parent="0" timeline="7" key="0"/>
+                    <bone_ref id="2" parent="0" timeline="8" key="0"/>
+                    <bone_ref id="3" parent="0" timeline="9" key="0"/>
+                    <bone_ref id="4" parent="0" timeline="10" key="0"/>
+                    <object_ref id="0" timeline="2" key="0" z_index="0"/>
+                    <object_ref id="1" timeline="0" key="0" z_index="1"/>
+                    <object_ref id="2" parent="3" timeline="1" key="0" z_index="2"/>
+                    <object_ref id="3" parent="2" timeline="3" key="0" z_index="3"/>
+                    <object_ref id="4" parent="4" timeline="4" key="0" z_index="4"/>
+                    <object_ref id="5" parent="1" timeline="5" key="0" z_index="5"/>
+                </key>
+                <key id="1" time="750">
+                    <bone_ref id="0" timeline="6" key="1"/>
+                    <bone_ref id="1" parent="0" timeline="7" key="0"/>
+                    <bone_ref id="2" parent="0" timeline="8" key="0"/>
+                    <bone_ref id="3" parent="0" timeline="9" key="0"/>
+                    <bone_ref id="4" parent="0" timeline="10" key="0"/>
+                    <object_ref id="0" timeline="2" key="0" z_index="0"/>
+                    <object_ref id="1" timeline="0" key="0" z_index="1"/>
+                    <object_ref id="2" parent="3" timeline="1" key="0" z_index="2"/>
+                    <object_ref id="3" parent="2" timeline="3" key="0" z_index="3"/>
+                    <object_ref id="4" parent="4" timeline="4" key="0" z_index="4"/>
+                    <object_ref id="5" parent="1" timeline="5" key="0" z_index="5"/>
+                </key>
+                <key id="2" time="1500" curve_type="cubic" c1="0.706468" c2="0.78607">
+                    <bone_ref id="0" timeline="6" key="2"/>
+                    <bone_ref id="1" parent="0" timeline="7" key="1"/>
+                    <bone_ref id="2" parent="0" timeline="8" key="1"/>
+                    <bone_ref id="3" parent="0" timeline="9" key="1"/>
+                    <bone_ref id="4" parent="0" timeline="10" key="1"/>
+                    <object_ref id="0" timeline="2" key="1" z_index="0"/>
+                    <object_ref id="1" timeline="0" key="1" z_index="1"/>
+                    <object_ref id="2" parent="3" timeline="1" key="1" z_index="2"/>
+                    <object_ref id="3" parent="2" timeline="3" key="1" z_index="3"/>
+                    <object_ref id="4" parent="4" timeline="4" key="1" z_index="4"/>
+                    <object_ref id="5" parent="1" timeline="5" key="1" z_index="5"/>
+                </key>
+            </mainline>
+            <timeline id="0" name="object1">
+                <key id="0" spin="0">
+                    <object folder="0" file="0" x="-54.223101" y="215.801131"/>
+                </key>
+                <key id="1" time="1500" spin="0">
+                    <object folder="0" file="0" x="-54.223101" y="157.801131"/>
+                </key>
+            </timeline>
+            <timeline id="1" name="object2">
+                <key id="0" spin="0">
+                    <object folder="0" file="1" x="72.229964" y="-19.533164" angle="90.387128"/>
+                </key>
+                <key id="1" time="1500" spin="0">
+                    <object folder="0" file="1" x="38.732849" y="-20.267103" angle="90.387128"/>
+                </key>
+            </timeline>
+            <timeline id="2" name="object3">
+                <key id="0" spin="0">
+                    <object folder="0" file="2" x="-62.86722" y="4.012448"/>
+                </key>
+                <key id="1" time="1500" spin="0">
+                    <object folder="0" file="2" x="-62.86722" y="4.012448"/>
+                </key>
+            </timeline>
+            <timeline id="3" name="object2_000">
+                <key id="0" spin="0">
+                    <object folder="0" file="1" x="100.260439" y="17.255078" angle="0.395137"/>
+                </key>
+                <key id="1" time="1500" spin="0">
+                    <object folder="0" file="1" x="54.190758" y="25.51983" angle="0.395137"/>
+                </key>
+            </timeline>
+            <timeline id="4" name="object2_001">
+                <key id="0" spin="0">
+                    <object folder="0" file="1" x="135.495569" y="-18.156697" angle="181.74451"/>
+                </key>
+                <key id="1" time="1500" spin="0">
+                    <object folder="0" file="1" x="98.397247" y="-19.333472" angle="181.74451"/>
+                </key>
+            </timeline>
+            <timeline id="5" name="object2_002">
+                <key id="0" spin="0">
+                    <object folder="0" file="1" x="116.914366" y="17.820602" angle="269.144903"/>
+                </key>
+                <key id="1" time="1500" spin="0">
+                    <object folder="0" file="1" x="96.296043" y="16.785012" angle="269.144903"/>
+                </key>
+            </timeline>
+            <timeline id="6" obj="0" name="bone_000" object_type="bone">
+                <key id="0" spin="-1">
+                    <bone x="4.670551" y="119.735545" angle="90.868051"/>
+                </key>
+                <key id="1" time="750" spin="-1">
+                    <bone x="4.670551" y="119.735545" angle="0"/>
+                </key>
+                <key id="2" time="1500" spin="-1">
+                    <bone x="4.670551" y="119.735545" angle="270"/>
+                </key>
+            </timeline>
+            <timeline id="7" obj="1" name="bone_001" object_type="bone">
+                <key id="0" spin="0">
+                    <bone x="35.661256" y="0.329343" angle="359.987046"/>
+                </key>
+                <key id="1" time="1500" spin="0">
+                    <bone x="35.661256" y="0.329343" angle="359.987046"/>
+                </key>
+            </timeline>
+            <timeline id="8" obj="2" name="bone_002" object_type="bone">
+                <key id="0" spin="0">
+                    <bone x="12.89707" y="-9.761725" angle="268.736812"/>
+                </key>
+                <key id="1" time="1500" spin="0">
+                    <bone x="12.89707" y="-9.761725" angle="268.736812"/>
+                </key>
+            </timeline>
+            <timeline id="9" obj="3" name="bone_003" object_type="bone">
+                <key id="0" spin="0">
+                    <bone x="-13.885099" y="1.94971" angle="178.744821"/>
+                </key>
+                <key id="1" time="1500" spin="0">
+                    <bone x="-13.885099" y="1.94971" angle="178.744821"/>
+                </key>
+            </timeline>
+            <timeline id="10" obj="4" name="bone_004" object_type="bone">
+                <key id="0" spin="0">
+                    <bone x="13.634799" y="10.229392" angle="87.387439"/>
+                </key>
+                <key id="1" time="1500" spin="0">
+                    <bone x="13.634799" y="10.229392" angle="87.387439"/>
+                </key>
+            </timeline>
+        </animation>
+    </entity>
+</spriter_data>