Merge pull request #69 from GraysonnG/develop

Merge Develop into Master 12/7/18

pom.xml

@@ -2,7 +2,7 @@
   <modelVersion>4.0.0</modelVersion>
   <groupId>InfiniteSpire</groupId>
   <artifactId>InfiniteSpire</artifactId>
-  <version>0.6.1</version>
+  <version>0.7.0</version>
   <dependencies>
     <dependency>
       <groupId>com.megacrit.cardcrawl</groupId>

src/main/java/infinitespire/InfiniteSpire.java

@@ -62,7 +62,7 @@
 @SpireInitializer
 public class InfiniteSpire implements PostInitializeSubscriber, PostBattleSubscriber, EditRelicsSubscriber,
 	EditCardsSubscriber, EditKeywordsSubscriber, EditStringsSubscriber, PreDungeonUpdateSubscriber {
-	public static final String VERSION = "0.6.1";
+	public static final String VERSION = "0.7.0";
 	public static final Logger logger = LogManager.getLogger(InfiniteSpire.class.getName());
 
 	private static ArrayList<OnQuestRemovedSubscriber> onQuestRemovedSubscribers = new ArrayList<>();
@@ -213,8 +213,8 @@ public static void saveData() {
 			Nightmare.save(config);
 			config.setBool("isGuardianDead", hasDefeatedGuardian);
 			config.setBool("isEndless", isEndless);
-			config.setBool("startWithEndlessQuest", startWithEndlessQuest);
-			config.setBool("cardParticles", shouldDoParticles);
+			config.setBool("startWithEndless", startWithEndlessQuest);
+			config.setBool("blackCardParticles", shouldDoParticles);
 			config.save();
 		} catch (IOException e) {
 			e.printStackTrace();
@@ -238,9 +238,15 @@ public static void loadData() {
 			SpireConfig config = new SpireConfig("InfiniteSpire", "infiniteSpireConfig");
 			config.load();
 			isEndless = config.getBool("isEndless");
-			startWithEndlessQuest = config.getBool("startWithEndlessQuest");
+			if(config.has("startWithEndless")) {
+				startWithEndlessQuest = config.getBool("startWithEndless");
+			} else {
+				startWithEndlessQuest = true;
+			}
 			if(config.has("cardParticles")) {
-				shouldDoParticles = config.getBool("cardParticles");
+				shouldDoParticles = config.getBool("blackCardParticles");
+			} else {
+				shouldDoParticles = true;
 			}
 			if (AbstractDungeon.player != null)
 				BottledSoul.load(config);
@@ -275,6 +281,7 @@ private static void initializeRelics() {
 		RelicLibrary.add(new DarkRift());
 		RelicLibrary.add(new Eraser());
 		RelicLibrary.add(new Chaos()); // This relic may have bugs lmao sorry
+		RelicLibrary.add(new CursedDice());
 
 		RelicLibrary.add(new EmpoweringShard());
 		RelicLibrary.add(new WardingShard());

src/main/java/infinitespire/abstracts/BlackCard.java

@@ -37,6 +37,7 @@ public abstract class BlackCard extends Card {
 	public static final CardRarity RARITY = CardRarity.SPECIAL;
 	public static final CardColor COLOR = CardColorEnumPatch.CardColorPatch.INFINITE_BLACK;
 	public static final Color TITLE_COLOR = new Color(1f, 0.15f, 0.15f, 1f);
+	private static final float FPS_SCALE = (240f / Settings.MAX_FPS);
 	public ArrayList<BlackParticle> particles;
 
 	public BlackCard(String id, String name, String img, int cost, String rawDescription, CardType type, CardTarget target) {
@@ -68,10 +69,10 @@ public void update(){
 		particles.removeIf(BlackParticle::isDead);
 
 		if(this.particles.size() < 150 && InfiniteSpire.shouldDoParticles && !Settings.DISABLE_EFFECTS){
-			Vector2 point1 = generateRandomPointAlongEdgeOfHitbox();
-			particles.add(new BlackParticle(point1.x, point1.y, this.drawScale, this.upgraded));
-			Vector2 point2 = generateRandomPointAlongEdgeOfHitbox();
-			particles.add(new BlackParticle(point2.x, point2.y, this.drawScale, this.upgraded));
+			for(int i = 0; i < 2 * FPS_SCALE; i++){
+				Vector2 point = generateRandomPointAlongEdgeOfHitbox();
+				particles.add(new BlackParticle(point.x, point.y, this.drawScale, this.upgraded));
+			}
 		}
 	}
 
@@ -117,8 +118,12 @@ public BlackParticle(float x, float y, float drawScale, boolean upgraded) {
 			this.drawScale = drawScale;
 			this.upgraded = upgraded;
 
-			float speedScale = this.drawScale;
-			float maxV = 2.0f * speedScale;
+			float speedScale = MathUtils.clamp(
+				Gdx.graphics.getDeltaTime() * 240f,
+				FPS_SCALE - 0.2f,
+				FPS_SCALE + 0.2f);
+			float maxV = 2.0f * drawScale;
+			maxV = MathUtils.clamp(maxV, 0.01f, FPS_SCALE * 2f);
 
 			float velX = MathUtils.random(-maxV * speedScale / 2f, maxV * speedScale / 2f);
 			float velY = MathUtils.random(0.01f, maxV * speedScale);
@@ -194,7 +199,7 @@ public int[] Locate(CtBehavior ctMethodToPatch) throws CannotCompileException, P
 			}
 		}
 	}
-	
+
 	@SpirePatch(clz = SingleCardViewPopup.class, method = "renderTitle")
 	public static class RenderSingleCardPopupTitle {
 		@SpirePrefixPatch

src/main/java/infinitespire/effects/BlackCardEffect.java

@@ -32,4 +32,9 @@ public void update() {
 	public void render(SpriteBatch spriteBatch) {
 
 	}
+
+	@Override
+	public void dispose() {
+
+	}
 }

src/main/java/infinitespire/effects/QuestLogUpdateEffect.java

@@ -46,4 +46,9 @@ public void render(SpriteBatch sb) {
 		sb.setBlendFunction(770, 771);
 		sb.draw(this.texture, x, y, 64f, 64f, 128f, 128f, scale, scale, 0.0f, 0, 0, 128, 128, false, false);
 	}
+
+	@Override
+	public void dispose() {
+
+	}
 }

src/main/java/infinitespire/effects/uniqueVFX/FinalStrikeEffect.java

@@ -107,4 +107,9 @@ public void render(SpriteBatch sb) {
 			this.scale * MathUtils.random(0.99f, 1.01f) * 2.0f * (this.duration + 0.8f), this.rotation);
 		sb.setBlendFunction(770, 771);
 	}
+
+	@Override
+	public void dispose() {
+
+	}
 }

src/main/java/infinitespire/effects/uniqueVFX/MenacingEffect.java

@@ -89,4 +89,9 @@ public void render(SpriteBatch sb) {
 			sb.draw(InfiniteSpire.getTexture("img/infinitespire/vfx/menacing.png"), this.x, this.y, 128f, 128f, 256f, 256f, size, size, 1f, 0, 0, 256, 256, false, false);
 		}
 	}
+
+	@Override
+	public void dispose() {
+
+	}
 }

src/main/java/infinitespire/effects/uniqueVFX/UltimateFormEffect.java

@@ -58,4 +58,9 @@ public void update() {
 	public void render(SpriteBatch spriteBatch) {
 
 	}
+
+	@Override
+	public void dispose() {
+
+	}
 }

src/main/java/infinitespire/patches/CursedDicePatch.java

@@ -0,0 +1,52 @@
+package infinitespire.patches;
+
+
+import com.evacipated.cardcrawl.modthespire.lib.*;
+import com.megacrit.cardcrawl.cards.AbstractCard;
+import com.megacrit.cardcrawl.cards.DamageInfo;
+import com.megacrit.cardcrawl.cards.Soul;
+import com.megacrit.cardcrawl.characters.AbstractPlayer;
+import com.megacrit.cardcrawl.dungeons.AbstractDungeon;
+import infinitespire.relics.CursedDice;
+import javassist.CtBehavior;
+
+public class CursedDicePatch {
+
+	@SpirePatch(clz = AbstractPlayer.class, method = "damage", paramtypez = {DamageInfo.class})
+	public static class AbstractDungeonPatches {
+		@SpireInsertPatch(locator = DeathLocator.class)
+		public static SpireReturn CursedDiceCheck(AbstractPlayer player, DamageInfo info) {
+			if(player.hasRelic(CursedDice.ID)) {
+				if(player.getRelic(CursedDice.ID).counter > -2) {
+					player.isDead = false;
+					player.currentHealth = 0;
+					player.getRelic(CursedDice.ID).onTrigger();
+					return SpireReturn.Return(null);
+				}
+			}
+
+
+			return SpireReturn.Continue();
+		}
+
+		private static class DeathLocator extends SpireInsertLocator {
+			@Override
+			public int[] Locate(CtBehavior ctBehavior) throws Exception {
+				Matcher matcher = new Matcher.MethodCallMatcher(AbstractDungeon.class, "getMonsters");
+
+				return LineFinder.findInOrder(ctBehavior, matcher);
+			}
+		}
+	}
+
+	@SpirePatch(clz = Soul.class, method = "discard", paramtypez = {AbstractCard.class, boolean.class})
+	public static class SoulCardPatches {
+		@SpirePostfixPatch
+		public static void moveToExhaustInsteadPatch(Soul __instance, AbstractCard card, boolean visualOnly) {
+			if(AbstractDungeon.player.hasRelic(CursedDice.ID)) {
+				CursedDice dice = (CursedDice) AbstractDungeon.player.getRelic(CursedDice.ID);
+				dice.moveCardToExhaust(card, visualOnly);
+			}
+		}
+	}
+}

src/main/java/infinitespire/powers/CursedDicePower.java

@@ -0,0 +1,25 @@
+package infinitespire.powers;
+
+import com.megacrit.cardcrawl.characters.AbstractPlayer;
+import com.megacrit.cardcrawl.powers.AbstractPower;
+import infinitespire.InfiniteSpire;
+
+public class CursedDicePower extends AbstractPower {
+
+	public static final String powerID = "is_DicePower";
+
+	public CursedDicePower(AbstractPlayer player) {
+		this.owner = player;
+		this.amount = -1;
+		this.name = "Cursed Dice";
+		this.ID = powerID;
+		this.img = InfiniteSpire.getTexture("img/infinitespire/powers/crit.png");
+		this.type = PowerType.BUFF;
+		this.priority = 99;
+		this.updateDescription();
+	}
+
+	public void updateDescription() {
+		this.description = "You no longer take damage.";
+	}
+}

src/main/java/infinitespire/relics/CursedDice.java

@@ -0,0 +1,155 @@
+package infinitespire.relics;
+
+import com.badlogic.gdx.graphics.Color;
+import com.megacrit.cardcrawl.actions.GameActionManager;
+import com.megacrit.cardcrawl.actions.common.DrawCardAction;
+import com.megacrit.cardcrawl.actions.common.RelicAboveCreatureAction;
+import com.megacrit.cardcrawl.actions.common.ShuffleAction;
+import com.megacrit.cardcrawl.actions.defect.ShuffleAllAction;
+import com.megacrit.cardcrawl.cards.AbstractCard;
+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.screens.DeathScreen;
+import infinitespire.InfiniteSpire;
+import infinitespire.abstracts.Quest;
+import infinitespire.abstracts.Relic;
+import infinitespire.quests.DieQuest;
+
+public class CursedDice extends Relic {
+	public static final String ID = InfiniteSpire.createID("CursedDice");
+	private int cardsTillDeath = -1;
+	private int playableCards = -1;
+	private boolean initialActionTaken = false;
+
+	public CursedDice() {
+		super(ID, "curseddice", RelicTier.RARE, LandingSound.SOLID);
+	}
+
+	public void setCounter(int counter) {
+		if (counter == -2) {
+			this.img = InfiniteSpire.getTexture("img/infinitespire/relics/curseddice-used.png");
+			this.counter = -2;
+		}
+	}
+
+	public boolean isActive(){
+		return this.initialActionTaken && counter > -2;
+	}
+
+	@Override
+	public void onVictory() {
+		if(initialActionTaken && counter > -2) {
+			this.setCounter(-2);
+			this.doHeal();
+			this.stopPulse();
+			this.pulse = false;
+			AbstractDungeon.player.tint.changeColor(Color.WHITE.cpy());
+		}
+	}
+
+	@Override
+	public void onTrigger() {
+		GameActionManager manager = AbstractDungeon.actionManager;
+		AbstractPlayer player = AbstractDungeon.player;
+
+		this.flash();
+		if(!initialActionTaken) {
+			//shuffle all cards to drawPile
+			manager.addToBottom(new ShuffleAllAction());
+			manager.addToBottom(new ShuffleAction(player.drawPile, false));
+
+			//set the counter
+			cardsTillDeath = player.drawPile.group.size();
+			cardsTillDeath += player.hand.group.size();
+			cardsTillDeath += player.discardPile.group.size();
+			cardsTillDeath += player.limbo.group.size();
+			this.counter = cardsTillDeath;
+			this.playableCards = cardsTillDeath;
+
+			//draw cards if lethal damage is taken on player turn
+			if(!manager.turnHasEnded) {
+				int cardsToDraw = 5;
+				//TODO: figure out how many cards to draw
+				manager.addToBottom(new DrawCardAction(player, cardsToDraw));
+			}
+
+			//heal the player to prevent stupid death logic
+			player.heal(1);
+
+
+			initialActionTaken = true;
+
+			for(Quest q : InfiniteSpire.questLog) {
+				if(q instanceof DieQuest){
+					q.incrementQuestSteps();
+				}
+			}
+
+			this.beginPulse();
+			this.pulse = true;
+		}
+	}
+
+	public void update(){
+		super.update();
+		if(CardCrawlGame.isInARun()) {
+			AbstractPlayer player = AbstractDungeon.player;
+			if (!player.isDead && isActive()) {
+				if (cardsTillDeath == 0) {
+					player.currentHealth = 0;
+					AbstractDungeon.deathScreen = new DeathScreen(AbstractDungeon.getMonsters());
+					player.isDead = true;
+				}
+
+				if (this.counter != cardsTillDeath || this.counter <= -1) {
+					this.flash();
+					this.counter = cardsTillDeath;
+				}
+
+				cardsTillDeath = player.drawPile.group.size();
+				cardsTillDeath += player.hand.group.size();
+				cardsTillDeath += player.discardPile.group.size();
+				cardsTillDeath += player.limbo.group.size();
+
+				Color tint = Color.WHITE.cpy();
+				tint.g = (float)cardsTillDeath / (float)playableCards;
+				tint.r = 1.0f;
+				tint.b = (float)cardsTillDeath / (float)playableCards;
+
+				player.tint.changeColor(tint);
+			}
+			if (this.counter == -2) {
+				this.img = InfiniteSpire.getTexture("img/infinitespire/relics/curseddice-used.png");
+			}
+		}
+	}
+
+	private void doHeal() {
+		AbstractDungeon.actionManager.addToBottom(new RelicAboveCreatureAction(AbstractDungeon.player, this));
+		int healAmt = (int) (AbstractDungeon.player.maxHealth * 0.35f);
+		if(AbstractDungeon.player.hasBlight("FullBelly")) {
+			healAmt /= 2;
+		}
+		if(healAmt < 1){
+			healAmt = 1;
+		}
+		AbstractDungeon.player.heal(healAmt, true);
+	}
+
+	public void moveCardToExhaust(AbstractCard card, boolean visualOnly) {
+		if(isActive()) {
+			if(!visualOnly) {
+				AbstractDungeon.player.discardPile.moveToExhaustPile(card);
+			}
+		}
+	}
+
+	@Override
+	public int onAttacked(DamageInfo info, int damageAmount) {
+		if(isActive()) return 0;
+
+		return super.onAttacked(info, damageAmount);
+	}
+}