How to use

getCounters

method

in

mage.players.Player

@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;
}

@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;
}

@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;
}

@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;
}

@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;
}

@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;
}

  @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;
  }
}

@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;
}

@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;
}

@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);
}

@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);
}

@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);
}

@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;
}

  @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;
  }
}

  @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;
  }
}

@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;
}

  @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;
  }
}

@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;
}

  @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;
  }
}

@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;
}