Tabnine Logo
Player.getCounters
Code IndexAdd Tabnine to your IDE (free)

How to use
getCounters
method
in
mage.players.Player

Best Java code snippets using mage.players.Player.getCounters (Showing top 20 results out of 315)

origin: magefree/mage

@Override
public boolean pay(Ability ability, Game game, UUID sourceId, UUID controllerId, boolean noMana, Cost costToPay) {
  Player player = game.getPlayer(controllerId);
  if (player != null && player.getCounters().getCount(CounterType.ENERGY) >= amount) {
    player.getCounters().removeCounter(CounterType.ENERGY, amount);
    paid = true;
  }
  return paid;
}
origin: magefree/mage

@Override
public boolean canAttack(Permanent attacker, UUID defenderId, Ability source, Game game) {
  Player targetPlayer = game.getPlayer(defenderId);
  if (targetPlayer != null) {
    if (targetPlayer.getCounters().containsKey(CounterType.POISON)) {
      return true;
    }
  }
  return false;
}
origin: magefree/mage

@Override
public boolean canPay(Ability ability, UUID sourceId, UUID controllerId, Game game) {
  Player player = game.getPlayer(controllerId);
  return player != null && player.getCounters().getCount(CounterType.ENERGY) >= amount;
}
origin: magefree/mage

@Override
public int calculate(Game game, Ability sourceAbility, Effect effect) {
  int amount = 0;
  Player player = game.getPlayer(sourceAbility.getControllerId());
  if (player != null) {
    amount = player.getCounters().getCount(CounterType.EXPERIENCE);
  }
  return amount;
}
origin: magefree/mage

@Override
public boolean checkTrigger(GameEvent event, Game game) {
  if (event.getSourceId().equals(this.getSourceId()) ) {
    Player target = game.getPlayer(event.getTargetId());
    if (target != null) {
      if (target.getCounters().getCount(CounterType.POISON) > 0) {
        return true;
      }
    }
  }
  return false;
}
origin: magefree/mage

@Override
public int calculate(Game game, Ability sourceAbility, Effect effect) {
  int amount = 0;
  Set<UUID> playerList = game.getOpponents(sourceAbility.getControllerId());
  for (UUID playerUUID : playerList) {
    Player player = game.getPlayer(playerUUID);
    if (player != null) {
      amount += player.getCounters().getCount(CounterType.POISON);
    }
  }
  return amount;
}
origin: magefree/mage

  @Override
  public boolean apply(Game game, Ability source) {
    Set<UUID> opponents = game.getOpponents(source.getControllerId());
    for (UUID opponentUuid : opponents) {
      Player opponent = game.getPlayer(opponentUuid);
      if (opponent != null && opponent.getCounters().getCount(CounterType.POISON) > 0) {
        return true;
      }
    }
    return false;
  }
}
origin: magefree/mage

@Override
public boolean apply(Game game, Ability source, Ability abilityToModify) {
  Player controller = game.getPlayer(source.getControllerId());
  if (controller != null) {
    SpellAbility spellAbility = (SpellAbility) abilityToModify;
    CardUtil.adjustCost(spellAbility, controller.getCounters().getCount(CounterType.EXPERIENCE));
    return true;
  }
  return false;
}
origin: magefree/mage

@Override
public boolean apply(Game game, Ability source) {
  Player player = game.getPlayer(targetPointer.getFirst(game, source));
  if (player != null) {
    int value = player.getCounters().getCount(CounterType.POISON);
    if (value > 0) {
      player.discard(value, source, game);
      return true;
    }
  }
  return false;
}
origin: magefree/mage

@Override
public boolean match(MageItem o, Game game) {
  if (o instanceof Player) {
    if (((Player)o).getCounters().isEmpty()) {
      return false;
    }
  } else if (o instanceof Permanent) {
    if (((Permanent)o).getCounters(game).isEmpty()) {
      return false;
    }
  }
  return super.match(o, game);
}
origin: magefree/mage

@Override
public boolean canTarget(UUID id, Game game) {
  Permanent permanent = game.getPermanent(id);
  if (permanent != null) {
    if (permanent.getCounters(game).isEmpty()) {
      return false;
    }
  }
  Player player = game.getPlayer(id);
  if (player != null) {
    if (player.getCounters().isEmpty()) {
      return false;
    }
  }
  return super.canTarget(id, game);
}
origin: magefree/mage

@Override
public boolean canTarget(UUID id, Ability source, Game game) {
  Permanent permanent = game.getPermanent(id);
  if (permanent != null) {
    if (permanent.getCounters(game).isEmpty()) {
      return false;
    }
  }
  Player player = game.getPlayer(id);
  if (player != null) {
    if (player.getCounters().isEmpty()) {
      return false;
    }
  }
  return super.canTarget(id, source, game);
}
origin: magefree/mage

@Override
public boolean apply(MageObject input, Game game) {
  Spell spell = game.getStack().getSpell(input.getId());
  if (spell != null) {
    Player controller = game.getPlayer(spell.getControllerId());
    if (controller != null) {
      if (spell.getConvertedManaCost() > controller.getCounters().getCount(CounterType.EXPERIENCE)) {
        return true;
      }
    }
  }
  return false;
}
origin: magefree/mage

  @Override
  public boolean apply(Game game, Ability source) {

    Player targetPlayer = game.getPlayer(source.getFirstTarget());
    if (targetPlayer == null) {
      return false;
    }

    int countPoisonCounters = targetPlayer.getCounters().getCount(CounterType.POISON);
    if (countPoisonCounters > 0) {
      targetPlayer.removeCounters(CounterType.POISON.getName(), countPoisonCounters, source, game);
      targetPlayer.damage(countPoisonCounters, source.getSourceId(), game, false, true);
      return true;
    }
    return false;
  }
}
origin: magefree/mage

  @Override
  public boolean apply(Game game, Ability source) {
    Player controller = game.getPlayer(source.getControllerId());
    if (controller != null) {
      Permanent target = game.getPermanent(getTargetPointer().getFirst(game, source));
      if (target != null) {
        int amount = controller.getCounters().getCount(CounterType.EXPERIENCE);
        target.addCounters(CounterType.P1P1.createInstance(amount), source, game);
      }
      return true;
    }
    return false;
  }
}
origin: magefree/mage

@Override
public boolean apply(Game game, Ability source) {
  Spell spell = game.getStack().getSpell(targetPointer.getFirst(game, source));
  if (spell != null) {
    Player player = game.getPlayer(spell.getControllerId());
    if (player != null && player.getCounters().containsKey(CounterType.POISON))
      return game.getStack().counter(targetPointer.getFirst(game, source), source.getSourceId(), game);
  }
  return false;
}
origin: magefree/mage

  @Override
  public boolean apply(Game game, Ability source) {
    Player controller = game.getPlayer(source.getControllerId());
    if (controller != null) {
      Permanent permanent = game.getPermanent(source.getSourceId());
      if (permanent != null && new MageObjectReference(source.getSourceObject(game), game).refersTo(permanent, game)) {
        int amount = controller.getCounters().getCount(CounterType.EXPERIENCE);
        permanent.getPower().setValue(amount);
        permanent.getToughness().setValue(amount);
        return true;
      } else {
        discard();
      }
    }
    return false;
  }
}
origin: magefree/mage

@Override
public boolean apply(Game game, Ability source) {
  Permanent permanent = game.getPermanent(getTargetPointer().getFirst(game, source));
  if (permanent != null) {
    for (Counter counter : permanent.getCounters(game).copy().values()) { // copy to prevent ConcurrentModificationException
      permanent.removeCounters(counter, game);
    }
    return true;
  }
  Player player = game.getPlayer(getTargetPointer().getFirst(game, source));
  if (player != null) {
    for (Counter counter : player.getCounters().copy().values()) { // copy to prevent ConcurrentModificationException
      player.removeCounters(counter.getName(), counter.getCount(), source, game);
    }
    return true;
  }
  return false;
}
origin: magefree/mage

  @Override
  public boolean apply(Game game, Ability source) {
    Player controller = game.getPlayer(source.getControllerId());
    if (controller != null) {
      new GetEnergyCountersControllerEffect(3).apply(game, source);
      int numberToPay = controller.getAmount(0, controller.getCounters().getCount(CounterType.ENERGY), "How many {E} do you like to pay?", game);
      if (numberToPay > 0) {
        Cost cost = new PayEnergyCost(numberToPay);
        if (cost.pay(source, game, source.getSourceId(), source.getControllerId(), true)) {
          Permanent targetCreature = game.getPermanent(getTargetPointer().getFirst(game, source));
          if (targetCreature != null) {
            targetCreature.damage(numberToPay, source.getSourceId(), game, false, true);
          }
        }
      }
      return true;
    }
    return false;
  }
}
origin: magefree/mage

@Override
public boolean apply(Game game, Ability source) {
  Player controller = game.getPlayer(source.getControllerId());
  if (controller != null) {
    new GetEnergyCountersControllerEffect(2).apply(game, source);
    if (controller.getCounters().getCount(CounterType.ENERGY) > 7) {
      Cost cost = new PayEnergyCost(8);
      if (controller.chooseUse(outcome,
          "Pay {E}{E}{E}{E}{E}{E}{E}{E} to use this? ",
          "Untap all creatures you control and after this phase, there is an additional combat phase.",
          "Yes", "No", source, game)
          && cost.pay(source, game, source.getSourceId(), source.getControllerId(), true)) {
        new UntapAllControllerEffect(new FilterControlledCreaturePermanent()).apply(game, source);
        new AdditionalCombatPhaseEffect().apply(game, source);
      }
    }
    return true;
  }
  return false;
}
mage.playersPlayergetCounters

Popular methods of Player

  • getId
  • getHand
  • getName
  • getLife
  • getLibrary
  • hasLeft
  • hasWon
  • hasLost
  • copy
  • damage
  • declareAttacker
  • getGraveyard
  • declareAttacker,
  • getGraveyard,
  • getPlayersUnderYourControl,
  • activateAbility,
  • canLose,
  • choose,
  • declareBlocker,
  • gainLife,
  • getAttachments

Popular in Java

  • Reactive rest calls using spring rest template
  • notifyDataSetChanged (ArrayAdapter)
  • onCreateOptionsMenu (Activity)
  • getResourceAsStream (ClassLoader)
  • NumberFormat (java.text)
    The abstract base class for all number formats. This class provides the interface for formatting and
  • SortedSet (java.util)
    SortedSet is a Set which iterates over its elements in a sorted order. The order is determined eithe
  • Pattern (java.util.regex)
    Patterns are compiled regular expressions. In many cases, convenience methods such as String#matches
  • Servlet (javax.servlet)
    Defines methods that all servlets must implement. A servlet is a small Java program that runs within
  • Response (javax.ws.rs.core)
    Defines the contract between a returned instance and the runtime when an application needs to provid
  • IsNull (org.hamcrest.core)
    Is the value null?
  • Top plugins for WebStorm
Tabnine Logo
  • Products

    Search for Java codeSearch for JavaScript code
  • IDE Plugins

    IntelliJ IDEAWebStormVisual StudioAndroid StudioEclipseVisual Studio CodePyCharmSublime TextPhpStormVimGoLandRubyMineEmacsJupyter NotebookJupyter LabRiderDataGripAppCode
  • Company

    About UsContact UsCareers
  • Resources

    FAQBlogTabnine AcademyTerms of usePrivacy policyJava Code IndexJavascript Code Index
Get Tabnine for your IDE now