com.megacrit.cardcrawl.powers.DexterityPower Java Examples

@Override
public void onAfterUseCard(AbstractCard card, UseCardAction action) {
    super.onAfterUseCard(card, action);
    if (
            (owner.hasPower("Tranquil_AttunedAttackPower") && card.type == AbstractCard.CardType.ATTACK)
        //|| (owner.hasPower("Tranquil_AttunedSkillPower") && card.type == AbstractCard.CardType.SKILL)
    ) {
        this.amount++;
        AbstractDungeon.actionManager.addToBottom(new ApplyPowerAction(owner, owner,
                new StrengthPower(owner, 1), 1));
        AbstractDungeon.actionManager.addToBottom(new ApplyPowerAction(owner, owner,
                new DexterityPower(owner, 1), 1));
    } else {
        AbstractDungeon.actionManager.addToBottom(new ApplyPowerAction(owner, owner,
                new StrengthPower(owner, -1 * amount), -1 * amount));
        AbstractDungeon.actionManager.addToBottom(new ApplyPowerAction(owner, owner,
                new DexterityPower(owner, -1 * amount), -1 * amount));
        AbstractDungeon.actionManager.addToBottom(new RemoveSpecificPowerAction(owner, owner, this));
    }
}
 

@Override
public void onRemember() {
    AbstractDungeon.actionManager.addToBottom(
            new ApplyPowerAction(owner, owner, new DexterityPower(owner, DEXTERITY_ON_REMEMBER), DEXTERITY_ON_REMEMBER));

    if (!AbstractDungeon.getMonsters().areMonstersBasicallyDead()) {
        for (AbstractMonster monster : AbstractDungeon.getMonsters().monsters) {
            if (!monster.halfDead && !monster.isDead && !monster.isDying) {
                AbstractDungeon.actionManager.addToTop(
                        new ApplyPowerAction(monster, owner, new WeakPower(monster, WEAK_ON_REMEMBER, false), WEAK_ON_REMEMBER));
            }
        }
    }
}
 

@Override
public void atEndOfTurnPreEndTurnCards() {
    if (isPassiveEffectActive()) {
        AbstractDungeon.actionManager.addToBottom(
                // It's important to apply a negative dex power rather than reducing an existing dex power
                //   1. reducing the existing power doesn't work if the player currently has no dex
                //   2. we want it to be blockable by Artifact, which ApplyPowerAction is and ReducePowerAction isn't
                new ApplyPowerAction(owner, owner, new DexterityPower(this.owner, -DEXTERITY_LOSS_PER_TURN)));
        AbstractDungeon.actionManager.addToBottom(
                new GainBlockAction(owner, owner, BLOCK_PER_TURN));
    }
}
 

@Override
public void receivePowersModified() {
    AbstractPlayer p = AbstractDungeon.player;

    if (p != null && p.hasRelic("PaperPengwin")) {
        if (moreThanXStacks(p, "Weakened", PaperPengwin.MIN_STACKS) ||
                moreThanXStacks(p, "Vulnerable", PaperPengwin.MIN_STACKS) ||
                moreThanXStacks(p, "Frail", PaperPengwin.MIN_STACKS)) {
            if (!isApplyingPaperPengwin) {
                AbstractDungeon.actionManager.addToTop(
                        new ApplyPowerAction(p, p, new DexterityPower(p, PaperPengwin.MIN_STACKS), PaperPengwin.MIN_STACKS));
                AbstractDungeon.actionManager.addToTop(
                        new ApplyPowerAction(p, p, new StrengthPower(p, PaperPengwin.MIN_STACKS), PaperPengwin.MIN_STACKS));
                isApplyingPaperPengwin = true;
                p.getRelic("PaperPengwin").flash();
                ((PaperPengwin) p.getRelic("PaperPengwin")).setPulse(true);
            }
        } else {
            if (isApplyingPaperPengwin) {
                AbstractDungeon.actionManager.addToTop(
                        new ApplyPowerAction(p, p, new DexterityPower(p, -1 * PaperPengwin.MIN_STACKS), -1 * PaperPengwin.MIN_STACKS));
                AbstractDungeon.actionManager.addToTop(
                        new ApplyPowerAction(p, p, new StrengthPower(p, -1 * PaperPengwin.MIN_STACKS), -1 * PaperPengwin.MIN_STACKS));
                isApplyingPaperPengwin = false;
                ((PaperPengwin) p.getRelic("PaperPengwin")).setPulse(false);
            }
        }
    }
}
 

@Override
public void receivePostExhaust(AbstractCard c) {
    if (c.isEthereal) {
        this.flash();
        AbstractDungeon.actionManager.addToBottom(new ApplyPowerAction(
                this.owner, this.owner,
                new DexterityPower(this.owner, this.amount), this.amount));
    }
}
 

@Override
public void atEndOfTurn(final boolean isPlayer) {
    int count = 0;
    for (final AbstractCard c : AbstractDungeon.actionManager.cardsPlayedThisTurn) {
        // This is how you iterate through arrays (like the one above) and card groups like
        // "AbstractDungeon.player.masterDeck.getAttacks().group" - every attack in your actual master deck.
        // Read up on java's enhanced for-each loops if you want to know more on how these work.

        ++count; // At the end of your turn, increase the count by 1 for each card played this turn.
    }

    if (count > 0) {
        flash(); // Makes the power icon flash.
        for (int i = 0; i < count; ++i) {
            AbstractDungeon.actionManager.addToBottom(
                    new ReducePowerAction(owner, owner, DexterityPower.POWER_ID, amount));
            // Reduce the power by 1 for each count - i.e. for each card played this turn.
            // DO NOT HARDCODE YOUR STRINGS ANYWHERE: i.e. don't write any Strings directly i.e. "Dexterity" for the power ID above.
            // Use the power/card/relic etc. and fetch it's ID like shown above. It's really bad practice to have "Strings" in your code:

            /*
             * 1. It's bad for if somebody likes your mod enough (or if you decide) to translate it.
             * Having only the JSON files for translation rather than 15 different instances of "Dexterity" in some random cards is A LOT easier.
             *
             * 2. You don't have a centralised file for all strings for easy proof-reading, and if you ever want to change a string
             * you now have to go through all your files individually.
             *
             * 3. Without hardcoded strings, editing a string doesn't require a compile, saving you time (unless you clean+package).
             *
             */
        }
    }

}
 

@Override
public void useMaterialComponent(AbstractPlayer p, AbstractMonster m) {
    addToBot(new ApplyPowerAction(p, p, new DexterityPower(p, magicNumber), magicNumber));
    addToBot(new ApplyPowerAction(p, p, new LoseDexterityPower(p, magicNumber), magicNumber));
}
 

@Override
public void useMaterialComponent(AbstractPlayer p, AbstractMonster m) {
    addToBot(new ApplyPowerAction(p, p, new DexterityPower(p, magicNumber), magicNumber));
}
 

@Override
public void onGainPassiveEffect() {
    // It is by design that the dexterity decrease can be blocked by Artifact.
    AbstractDungeon.actionManager.addToBottom(new ApplyPowerAction(owner, owner, new DexterityPower(owner, PASSIVE_DEXTERITY_MODIFIER), PASSIVE_DEXTERITY_MODIFIER));
}
 

@Override
public void onLosePassiveEffect() {
    AbstractDungeon.actionManager.addToBottom(new ApplyPowerAction(owner, owner, new DexterityPower(owner, -PASSIVE_DEXTERITY_MODIFIER), -PASSIVE_DEXTERITY_MODIFIER));
}
 

@Override
public void use(AbstractPlayer p, AbstractMonster m) {
    AbstractDungeon.actionManager.addToBottom(new ApplyPowerAction(p, p, new DexterityPower(p, this.magicNumber), this.magicNumber));
    AbstractDungeon.actionManager.addToBottom(new ApplyPowerAction(p, p, new PremonitionsPower(p, 1), 1));
}
 

@Override
public void use(AbstractPlayer p, AbstractMonster m) {
    AbstractDungeon.actionManager.addToBottom(new GainBlockAction(p, p, this.block));
    AbstractDungeon.actionManager.addToBottom(new ApplyPowerAction(p, p, new DexterityPower(p, DEX_GAIN_AMT), DEX_GAIN_AMT));
    AbstractDungeon.actionManager.addToBottom(new ApplyPowerAction(m, p, new WeakPower(m, this.magicNumber, false), this.magicNumber));
}
 

@Override
public void onUseCard(final AbstractCard card, final UseCardAction action) {
    AbstractDungeon.actionManager.addToBottom(new ApplyPowerAction(owner, owner,
            new DexterityPower(owner, amount), amount));
}