com.megacrit.cardcrawl.actions.common.DrawCardAction Java Examples

@Override
public void use(AbstractPlayer p, AbstractMonster m) {
    int powerCount = GetPowerCount(p, "Weakened");
    if (powerCount > 0) {
        AbstractDungeon.actionManager.addToBottom(new RemoveSpecificPowerAction(p, p, "Weakened"));
        AbstractDungeon.actionManager.addToBottom(new ApplyPowerAction(m, p, new WeakPower(m, powerCount, false), powerCount));
    }
    powerCount = GetPowerCount(p, "Vulnerable");
    if (powerCount > 0) {
        AbstractDungeon.actionManager.addToBottom(new RemoveSpecificPowerAction(p, p, "Vulnerable"));
        AbstractDungeon.actionManager.addToBottom(new ApplyPowerAction(m, p, new VulnerablePower(m, powerCount, false), powerCount));
    }
    AbstractDungeon.actionManager.addToBottom(new DrawCardAction(p, this.magicNumber));
}
 

@Override
public void onCardDraw(AbstractCard card) {
    if (card.type == AbstractCard.CardType.CURSE) {
        this.flash();
        AbstractDungeon.actionManager.addToBottom(new DrawCardAction(owner, amount));
    }
}
 

@Override
public void use(AbstractPlayer p, AbstractMonster m) {
    addToBot(new DamageAction(m, new DamageInfo(p, damage), AttackEffect.SLASH_VERTICAL));

    if (isEligibleForExtraEffect()) {
        addToBot(new GainEnergyAction(metaMagicNumber));
        addToBot(new DrawCardAction(p, urMagicNumber));
    }
}
 

@Override
public void use(AbstractPlayer p, AbstractMonster abstractMonster) {
    if (magicNumber > 0) {
        addToBot(new DiscardAction(p, p, magicNumber, false));
        addToBot(new DrawCardAction(magicNumber));
    }
}
 

@Override
public void receivePostDraw(AbstractCard c) {
    if (c instanceof Convergence) {
        c.superFlash();
        if (c.upgraded) {
            AbstractDungeon.actionManager.addToTop(new DrawCardAction(AbstractDungeon.player, 1));
        }
        AbstractDungeon.actionManager.addToBottom(new WaitAction(Settings.ACTION_DUR_FAST));
        AbstractDungeon.actionManager.addToBottom(new ConvergenceAction(c.upgraded));
    }
}
 

@Override
public void update() {
    this.listening = true;
    AbstractDungeon.actionManager.addToTop(new DrawCardAction(
            AbstractDungeon.player, this.initialDraw));
    this.isDone = true;
}
 

@Override
public void use(AbstractPlayer p, AbstractMonster m) {
    MemoryManager mm = MemoryManager.forPlayer(p);
    if (mm != null && mm.currentMemory != null && !mm.currentMemory.isClarified) {
        addToBot(new ApplyPowerAction(p, p, new MustClarifyBeforeRememberingNewMemoriesPower(p, mm.currentMemory.ID)));
    }

    addToBot(new DrawCardAction(p, magicNumber));
    addToBot(new ApplyPowerAction(p, p, new NoDrawPower(p)));
}
 

@Override
public void receivePostDraw(AbstractCard c) {
    if (listening) {
        this.listening = false;
        if (c.isEthereal) {
            //AbstractDungeon.actionManager.addToTop(new MakeTempCardInHandAction(new Dazed(), 1, true));
            AbstractDungeon.actionManager.addToTop(new DrawCardAction(AbstractDungeon.player, this.amount));
        }
        /*
         *  calling unsubscribeFromPostBattle inside the callback
         *  for receivePostBattle means that when we're calling it
         *  there is currently an iterator going over the list
         *  of subscribers and calling receivePostBattle on each of
         *  them therefore if we immediately try to remove the this
         *  callback from the post battle subscriber list it will
         *  throw a concurrent modification exception in the iterator
         *
         *  for now we just add a delay - yes this is an atrocious solution
         *  PLEASE someone with a better idea replace it
         */
        Thread delayed = new Thread(() -> {
            try {
                Thread.sleep(200);
            } catch (Exception e) {
                System.out.println("could not delay unsubscribe to avoid ConcurrentModificationException");
                e.printStackTrace();
            }
            BaseMod.unsubscribe(this);
        });
        delayed.start();
    }
}
 

@Override
public void use(AbstractPlayer p, AbstractMonster m) {
    int draw = 10 - AbstractDungeon.player.hand.size();
    if (draw > 0) {
        AbstractDungeon.actionManager.addToTop(new DrawCardAction(p, draw));
        AbstractDungeon.actionManager.addToBottom(new MakeTempCardInDrawPileAction(new Dazed(), 4, false, false));
    }
}
 

@Override
public void use(AbstractPlayer p, AbstractMonster m) {
    addToBot(new RememberSpecificMemoryAction(p, SlothMemory.STATIC.ID));
    addToBot(new CardsToTopOfDeckAction(p, p.discardPile, this.magicNumber, false));
    if (metaMagicNumber > 0) {
        addToBot(new DrawCardAction(p, metaMagicNumber));
    }
}
 

@Override
public void use(AbstractPlayer p, AbstractMonster m) {
    AbstractDungeon.actionManager.addToBottom(new DamageAction((AbstractCreature) m, new DamageInfo(p, this.damage, this.damageTypeForTurn), AbstractGameAction.AttackEffect.SLASH_VERTICAL));
    if (AbstractDungeon.player.drawPile.isEmpty()) {
        AbstractDungeon.actionManager.addToBottom(new EmptyDeckShuffleAction());
    }
    AbstractDungeon.actionManager.addToBottom(new DrawCardAction(p, this.magicNumber));
}
 

@Override
public void use(AbstractPlayer p, AbstractMonster m) {
    AbstractDungeon.actionManager.addToBottom(new GainBlockAction(p, p, this.block));
    if (AbstractDungeon.player.drawPile.isEmpty()) {
        AbstractDungeon.actionManager.addToBottom(new EmptyDeckShuffleAction());
    }
    AbstractDungeon.actionManager.addToBottom(new DrawCardAction(p, this.magicNumber));
}
 

@Override
public void use(AbstractPlayer p, AbstractMonster m) {
    AbstractDungeon.actionManager.addToBottom(new GainEnergyAction(this.magicNumber));
    AbstractDungeon.actionManager.addToBottom(new DrawCardAction(p, this.magicNumber));
    AbstractDungeon.actionManager.addToBottom(new ApplyPowerAction(p, p, new VulnerablePower(p, DEBUFF_AMT, true), DEBUFF_AMT));
    AbstractDungeon.actionManager.addToBottom(new ApplyPowerAction(p, p, new WeakPower(p, DEBUFF_AMT, true), DEBUFF_AMT));
    AbstractDungeon.actionManager.addToBottom(new ApplyPowerAction(p, p, new FrailPower(p, DEBUFF_AMT, true), DEBUFF_AMT));
}
 

@Override
public void use(AbstractPlayer p, AbstractMonster abstractMonster) {
    if (this.dontTriggerOnUseCard) {
        SelfExertField.selfExert.set(this, true);
        addToBot(new ExhaustSpecificCardAction(this, AbstractDungeon.player.hand));
    }
    else {
        addToBot(new DrawCardAction(DRAW));
        addToBot(new DecreaseMaxHpAction(p, p, magicNumber, AbstractGameAction.AttackEffect.POISON));
    }
}
 

@Override
public void use(AbstractPlayer p, AbstractMonster abstractMonster) {
    if (abstractMonster.hasPower(VulnerablePower.POWER_ID)) {
        addToBot(new DrawCardAction(p, magicNumber));
    }
    addToBot(new ApplyPowerAction(abstractMonster, p, new VulnerablePower(abstractMonster, urMagicNumber, false)));
}
 

@Override
public void use(AbstractPlayer p, AbstractMonster abstractMonster) {
    addToBot(new DrawCardAction(this.misc));
    addToBot(new GainEnergyAction(this.urMagicNumber));
    if (this.misc > 0) {
        this.addToBot(new IncreaseMiscAction(this.uuid, this.misc, -this.magicNumber));
    }
}
 

@Override
public void onStartOfTurn() {// 1.At the start of your turn.
    AbstractDungeon.actionManager.addToBottom(// 2.This orb will have a flare effect
            new VFXAction(new OrbFlareEffect(this, OrbFlareEffect.OrbFlareColor.FROST), 0.1f));

    AbstractDungeon.actionManager.addToBottom(// 3. And draw you cards.
            new DrawCardAction(AbstractDungeon.player, passiveAmount));
}
 

@Override
public void use(AbstractPlayer p, AbstractMonster m) {
    addToBot(new RememberSpecificMemoryAction(p, GluttonyMemory.STATIC.ID));
    addToBot(new DrawCardAction(p, magicNumber, false));
}
 

@Override
public void use(AbstractPlayer p, AbstractMonster m) {
    AbstractDungeon.actionManager.addToBottom(new MakeTempCardInDrawPileAction(new Dazed(), DAZED_COUNT, true, true));
    AbstractDungeon.actionManager.addToBottom(new DrawCardAction(p, this.magicNumber));
    AbstractDungeon.actionManager.addToBottom(new GainEnergyAction(this.magicNumber));
}
 

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

public void onCardDraw(AbstractCard card) {
    if (card.isEthereal) {
        this.flash();
        AbstractDungeon.actionManager.addToBottom(new DrawCardAction(this.owner, this.amount));// 38
    }
}
 

@Override
public void atStartOfTurn() {
    this.flash();
    AbstractDungeon.actionManager.addToBottom(new MakeTempCardInDrawPileAction(new Dazed(), this.amount, true, true));
    AbstractDungeon.actionManager.addToBottom(new DrawCardAction(this.owner, this.amount));
}
 

@Override
public void onRemember() {
    AbstractDungeon.actionManager.addToBottom(new DrawCardAction(owner, CARDS_DRAWN_ON_ENTER));
}
 

@Override
public void use(AbstractPlayer p, AbstractMonster m) {
    addToBot(new DrawCardAction(p, metaMagicNumber));
    addToBot(new GainEnergyAction(magicNumber));
}
 

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

@Override
public void use(AbstractPlayer p, AbstractMonster m) {
    addToBot(new DrawCardAction(p, this.magicNumber));
    addToBot(new CardsToTopOfDeckAction(p, p.hand, this.metaMagicNumber, true));
}
 

@Override
public void use(AbstractPlayer p, AbstractMonster m) {
    addToBot(new DrawCardAction(p, magicNumber, false));
    addToBot(new ExhaustCardsMatchingPredicateAction(p, p.hand,
            c -> c.type == CardType.CURSE || c.type == CardType.STATUS));
}
 

@Override
public void use(AbstractPlayer p, AbstractMonster m) {
    addToBot(new GainBlockAction(p, p, block));
    addToBot(new DrawCardAction(p, magicNumber));
}
 

@Override
public void use(AbstractPlayer p, AbstractMonster m) {
    addToBot(new RememberSpecificMemoryAction(p, PatienceMemory.STATIC.ID));
    addToBot(new DamageAction(m, new DamageInfo(p, damage), AttackEffect.SLASH_HORIZONTAL));
    addToBot(new DrawCardAction(magicNumber));
}
 

@Override
public void use(AbstractPlayer p, AbstractMonster m) {
    addToBot(new DrawCardAction(p, magicNumber));
    addToBot(new ApplyPowerAction(p, p, new PlayNextAttackThisTurnAdditionalTimesPower(p, metaMagicNumber), metaMagicNumber));
}