com.megacrit.cardcrawl.monsters.AbstractMonster Java Examples

@Override
public void onInitialApplication()
{
    // Dumb action to delay grabbing monster's intent until after it's actually set
    AbstractDungeon.actionManager.addToBottom(new AbstractGameAction()
    {
        @Override
        public void update()
        {
            if (owner instanceof AbstractMonster) {
                moveByte = ((AbstractMonster) owner).nextMove;
                moveIntent = ((AbstractMonster) owner).intent;
                try {
                    Field f = AbstractMonster.class.getDeclaredField("move");
                    f.setAccessible(true);
                    move = (EnemyMoveInfo) f.get(owner);
                    move.intent = AbstractMonster.Intent.STUN;
                    ((AbstractMonster) owner).createIntent();
                } catch (IllegalAccessException | NoSuchFieldException e) {
                    e.printStackTrace();
                }
            }
            isDone = true;
        }
    });
}
 

@Override
public void use(AbstractPlayer p, AbstractMonster m) {
    AbstractDungeon.actionManager.addToBottom(new DamageAction((AbstractCreature) m,
            new DamageInfo(p, this.damage, DamageInfo.DamageType.NORMAL), AbstractGameAction.AttackEffect.BLUNT_HEAVY));

    AbstractRoom room = AbstractDungeon.currMapNode.room;
    int numMonsters = room.monsters.monsters.size();

    this.multiDamage = new int[numMonsters];
    for (int i = 0; i < multiDamage.length; i++) {
        this.multiDamage[i] = this.damage;
    }

    AbstractDungeon.actionManager.addToBottom(new VFXAction(AbstractDungeon.player, new CleaveEffect(), 0.0F));
    AbstractDungeon.actionManager.addToBottom(new DamageAllEnemiesAction(p, this.multiDamage, this.damageTypeForTurn,
            AbstractGameAction.AttackEffect.NONE));
}
 

@Override
public void update() {
    if (duration == baseDuration) {
        AbstractDungeon.effectList.add(new FlashAtkImgEffect(this.target.hb.cX, this.target.hb.cY, AttackEffect.BLUNT_HEAVY));
    }
    tickDuration();
    if (isDone) {
        this.target.damage(this.info);

        boolean nonMinionsLeft = false;
        for (AbstractMonster m : AbstractDungeon.getCurrRoom().monsters.monsters) {
            if (!m.isDeadOrEscaped() && !m.hasPower(MinionPower.POWER_ID)) {
                nonMinionsLeft = true;
            }
        }
        if (nonMinionsLeft) {
            AbstractPlayer p = AbstractDungeon.player;
            AbstractDungeon.actionManager.addToBottom(new LoseHPAction(p, p, hpLoss));
        }
        if (AbstractDungeon.getCurrRoom().monsters.areMonstersBasicallyDead()) {
            AbstractDungeon.actionManager.clearPostCombatActions();
        }
    }
}
 

@Override
public void calculateCardDamage(AbstractMonster mo) {
    int realBaseBlock = baseBlock;
    baseBlock += calculateBonusBaseBlock();
    int realBaseDamage = baseDamage;
    baseDamage += calculateBonusBaseDamage(mo);

    magicNumber = baseMagicNumber + calculateBonusMagicNumber();
    isMagicNumberModified = magicNumber != baseMagicNumber;

    super.calculateCardDamage(mo);

    baseDamage = realBaseDamage;
    isDamageModified = damage != baseDamage;
    baseBlock = realBaseBlock;
    isBlockModified = block != baseBlock;

    setRawDynamicDescriptionSuffix(getRawDynamicDescriptionSuffix());
}
 

@Override
public void onUseCard(AbstractCard card, UseCardAction action) {
    if (!card.purgeOnUse && this.amount > 0 && !card.hasTag(LEGENDARY)) {
        this.flash();

        action.exhaustCard = true; // this is what corruption does
        SelfExertField.selfExert.set(card, true);

        AbstractMonster m = (AbstractMonster)action.target;

        for (int i = 0; i < amount; ++i) {
            CardMetaUtils.playCardAdditionalTime(card, m);
        }

        addToBot(new RemoveSpecificPowerAction(this.owner, this.owner, this.ID));
    }

}
 

@Override
public void use(AbstractPlayer p, AbstractMonster m) {
    /*AbstractDungeon.actionManager.addToBottom(new SFXAction("THUNDERCLAP", 0.05f));
    for (AbstractMonster mo : AbstractDungeon.getCurrRoom().monsters.monsters) {
        if (mo.isDeadOrEscaped()) continue;
        AbstractDungeon.actionManager.addToBottom(new VFXAction(new LightningEffect(mo.drawX, mo.drawY), 0.05f));
    }*/
    AbstractDungeon.actionManager.addToBottom(new DamageAllEnemiesAction(p, this.multiDamage, this.damageTypeForTurn, AbstractGameAction.AttackEffect.POISON));
    for (AbstractMonster mo : AbstractDungeon.getCurrRoom().monsters.monsters) {
        AbstractDungeon.actionManager.addToBottom(new ApplyPowerAction(mo, p, new WeakPower(mo, this.magicNumber, false), this.magicNumber, true, AbstractGameAction.AttackEffect.NONE));
        AbstractDungeon.actionManager.addToBottom(new ApplyPowerAction(mo, p, new VulnerablePower(mo, this.magicNumber, false), this.magicNumber, true, AbstractGameAction.AttackEffect.NONE));
    }
}
 

@Override
public void use(AbstractPlayer p, AbstractMonster m) {
    AbstractDungeon.actionManager.addToBottom( // The action managed queues all the actions a card should do.
            // addToTop - first
            // addToBottom - last
            // 99.99% of the time you just want to addToBottom all of them.
            // Please do that unless you need to add to top for some specific reason.
            new DamageAction(m, new DamageInfo(p, damage, damageTypeForTurn),
                    // a list of existing actions can be found at com.megacrit.cardcrawl.actions but
                    // Chances are you'd instead look at "hey my card is similar to this basegame card"
                    // Let's find out what action *it* uses.
                    // I.e. i want energy gain or card draw, lemme check out Adrenaline
                    // P.s. if you want to damage ALL enemies OUTSIDE of a card, check out the custom orb.
                    AbstractGameAction.AttackEffect.SLASH_HORIZONTAL)); // The animation the damage action uses to hit.
}
 

private boolean isEligibleForExtraEffect() {

        for (AbstractMonster m : AbstractDungeon.getCurrRoom().monsters.monsters) {
            if (!m.isDeadOrEscaped() && m.hasPower(VulnerablePower.POWER_ID)) {
                return true;
            }
        }
        return false;
    }
 

@Override
public void use(AbstractPlayer p, AbstractMonster m) {
    for (int i = 0; i < metaMagicNumber; i++) {
        AbstractCard c = AbstractDungeon.returnRandomCurse();
        AbstractDungeon.actionManager.addToBottom(new MakeTempCardInDiscardAction(c, 1));
    }
    addToBot(new ApplyPowerAction(p, p, new WastingFormPower(p, magicNumber, metaMagicNumber)));
}
 

public static ExprEditor Instrument() {
    return new ExprEditor() {
        public void edit(MethodCall m) throws CannotCompileException {
            if (m.getClassName().equals(AbstractMonster.class.getName()) && m.getMethodName().equals("takeTurn")) {
                m.replace(String.format("if (!%1$s.entangledAndAttacking($0)) {$_ = $proceed($$);}", MagicMirrorPatch.class.getName()));
            }
        }
    };
}
 

@Override
public void use(AbstractPlayer p, AbstractMonster m) {
    AbstractDungeon.actionManager.addToBottom(new SFXAction("THUNDERCLAP", 0.05f));
    for (AbstractMonster mo : AbstractDungeon.getCurrRoom().monsters.monsters) {
        if (mo.isDeadOrEscaped())
            continue;
        AbstractDungeon.actionManager.addToBottom(new VFXAction(new LightningEffect(mo.drawX, mo.drawY), 0.05f));
    }
    AbstractDungeon.actionManager.addToBottom(new DamageAllEnemiesAction(p, this.multiDamage,
            this.damageTypeForTurn, AbstractGameAction.AttackEffect.NONE));
    AbstractDungeon.actionManager.addToBottom(new MakeTempCardInDrawPileAction(new Dazed(), 1, true, true));
}
 

@SpireInsertPatch(
        locator = Locator.class,
        localvars = { "damageAmount" }
)
public static void patch(AbstractMonster __this, DamageInfo info, @ByRef int[] damageAmount)
{
    for (AbstractMonster m : AbstractDungeon.getMonsters().monsters) {
        for (AbstractPower power : m.powers) {
            if (power instanceof BlackTentaclesPower) {
                damageAmount[0] = ((BlackTentaclesPower) power).onAnyMonsterHpLoss(__this, info, damageAmount[0]);
            }
        }
    }
}
 

@Override
public void use(AbstractPlayer p, AbstractMonster m) {
    int energyGain = AbstractDungeon.player.exhaustPile.group.size() / this.magicNumber;
    if (energyGain > 0) {
        AbstractDungeon.actionManager.addToBottom(new GainEnergyAction(energyGain));
    }
}
 

@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 boolean canUse(AbstractPlayer p, AbstractMonster m) {
    boolean hasPlayedEthereal = false;
    for (AbstractCard c : AbstractDungeon.actionManager.cardsPlayedThisTurn) {
        if (c.isEthereal)
        {
            hasPlayedEthereal = true;
            break;
        }
    }
    cantUseMessage = "I haven't played an Ethereal card this turn ... yet.";
    return hasPlayedEthereal && super.canUse(p, m);
}
 

@Override
public void use(AbstractPlayer p, AbstractMonster abstractMonster) {
    addToBot(new ApplyPowerAction(p, p, new VulnerablePower(p, urMagicNumber, false)));
    addToBot(new VFXAction(new CleaveEffect()));
    this.addToBot(new DamageAllEnemiesAction(p, this.multiDamage, this.damageTypeForTurn, AbstractGameAction.AttackEffect.NONE));
    for (AbstractMonster m : AbstractDungeon.getMonsters().monsters) {
        addToBot(new ApplyPowerAction(m, p, new VulnerablePower(m, magicNumber, false)));
    }
}
 

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

    for (int i = 0; i < this.metaMagicNumber; ++i) {
        addToBot(new ApplyPowerAction(m, p, new WeakPower(m, this.magicNumber, false), this.magicNumber));
    }
}
 

@Override
public void update() {
    target = CombatUtils.getRandomAliveMonster(AbstractDungeon.getMonsters(), m -> !m.hasPower(BanishedPower.POWER_ID), AbstractDungeon.cardRandomRng);
    if (this.target != null) {
        card.calculateCardDamage((AbstractMonster) target);

        // Add to top in reverse order so VFX starts/waits before the damage effect happens.
        AbstractDungeon.actionManager.addToTop(new DamageAction(target, new DamageInfo(AbstractDungeon.player, card.damage, card.damageTypeForTurn), AttackEffect.SLASH_DIAGONAL));
        AbstractDungeon.actionManager.addToTop(new VFXAction(new ArcaneWeaponEffect(target.hb.x, target.hb.cY + target.hb.height / 12.0F), 0.5F));
    }

    isDone = true;
}
 

@Override
public void use(AbstractPlayer p, AbstractMonster mo) {
    AbstractMemory currentMemory = MemoryManager.forPlayer(p).currentMemory;
    if (currentMemory == null) { return; }

    for(AbstractMonster m : AbstractDungeon.getCurrRoom().monsters.monsters) {
        AbstractPower debuff = currentMemory.memoryType == MemoryType.SIN ?
                new VulnerablePower(m, magicNumber, false) :
                new WeakPower(m, magicNumber, false);

        addToBot(new ApplyPowerAction(m, p, debuff));
    }
}
 

@Override
public void useMaterialComponent(AbstractPlayer p, AbstractMonster m) {
    addToBot(new RemoveSpecificPowerAction(p, p, FrailPower.POWER_ID));
    if (upgraded) {
        addToBot(new RemoveSpecificPowerAction(p, p, VulnerablePower.POWER_ID));
    }
    addToBot(new RemoveSpecificPowerAction(p, p, WeakPower.POWER_ID));
}
 

@Override
public void use(AbstractPlayer p, AbstractMonster m) {
    addToBot(new HealAction(m, p, magicNumber));
    addToBot(new RememberSpecificMemoryAction(p, KindnessMemory.STATIC.ID));
    if (upgraded) {
        addToBot(new GainClarityOfCurrentMemoryAction(p));
    }
}
 

@Override
public void use(AbstractPlayer p, AbstractMonster m) {
    if (upgraded) {
        addToBot(new PatronAction(m, new DamageInfo(p, damage), this, CardMetaUtils::downgradeCardPermanently, EffectUtils::showDowngradeEffect));
    } else {
        addToBot(new PatronAction(m, new DamageInfo(p, damage), this, CardMetaUtils::destroyCardPermanently, EffectUtils::showDestroyEffect));
    }
}
 

public void onUseCard(AbstractCard card, UseCardAction action) {
    if (!card.purgeOnUse && this.amount > 0) {
        this.flash();

        AbstractMonster m = (AbstractMonster)action.target;

        for (int i = 0; i < amount; ++i) {
            CardMetaUtils.playCardAdditionalTime(card, m);
        }

        AbstractDungeon.actionManager.addToBottom(new RemoveSpecificPowerAction(this.owner, this.owner, this.ID));
    }
}
 

@Override
public void onInitialApplication() {
    if (owner instanceof AbstractMonster) {
        associatedStunPower = new StunMonsterPower((AbstractMonster)this.owner, this.amount);
        AbstractDungeon.actionManager.addToTop(new ApplyPowerAction(this.owner, this.source, associatedStunPower, this.amount));
    }
}
 

@Override
public void use(AbstractPlayer p, AbstractMonster m) {
    // Based on HandOfGreed's GreedAction
    for(int i = 0; i < magicNumber; ++i) {
        AbstractDungeon.effectList.add(new GainPennyEffect(p, p.hb.cX, p.hb.cY, p.hb.cX, p.hb.cY, true));
    }
    AbstractDungeon.player.gainGold(magicNumber);

    addToBot(new RememberSpecificMemoryAction(p, CharityMemory.STATIC.ID));
    if (upgraded) {
        addToBot(new GainClarityOfCurrentMemoryAction(p));
    }
}
 

@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_HEAVY)));
    Channel that = this; // funny little naming convention for providing this to inner class
    ITopCycleCallback cb = new ITopCycleCallback() {
        @Override
        public void processCard(AbstractCard c) {
            if (c.isEthereal) {
                AbstractDungeon.actionManager.addToBottom(new DamageAction((AbstractCreature) m, new DamageInfo(p, that.damage, that.damageTypeForTurn), AbstractGameAction.AttackEffect.SLASH_HEAVY));
            }
        }
    };
    AbstractDungeon.actionManager.addToBottom(new ChannelAction(p, DISCARD_AMT, cb));
}
 

public static boolean[] CheckTargets(Predicate<AbstractMonster> condition) {
    ArrayList<AbstractMonster> monsters = AbstractDungeon.getCurrRoom().monsters.monsters;
    boolean[] targets = new boolean[monsters.size()];
    for (int i = 0, l = targets.length; i < l; ++i) {
        targets[i] = condition.test(monsters.get(i));
    }
    return targets;

}
 

@Override
public void use(AbstractPlayer p, AbstractMonster m) {
    AbstractCard c = AbstractDungeon.returnTrulyRandomCardInCombat();
    if (!c.isEthereal) {
        c.isEthereal = true;
        c.rawDescription = "Ethereal. NL " + c.rawDescription;
        c.initializeDescription();
    }
    c.freeToPlayOnce = true;
    AbstractDungeon.actionManager.addToBottom(new MakeTempCardInDrawPileAction(c, 1, false, true));
}
 

public StunMonsterAction(AbstractMonster target, AbstractCreature source, int amount)
{
    this.target = target;
    this.source = source;
    this.amount = amount;
    actionType = AbstractGameAction.ActionType.DEBUFF;
    duration = Settings.ACTION_DUR_FAST;
}
 

@Override
public void use(AbstractPlayer p, AbstractMonster abstractMonster) {
    removeRetainThorns();
    addToBot(new ApplyPowerAction(p, p, new ThornsPower(p, magicNumber)));
}