How to use

lost

method

in

mage.players.Player

  @Override
  public boolean apply(Game game, Ability source) {
    Player player = game.getPlayer(source.getControllerId());
    if (player != null) {
      player.lost(game);
      return true;
    }
    return false;
  }
}

  @Override
  public boolean apply(Game game, Ability source) {
    Player target = game.getPlayer(source.getFirstTarget());
    if (target != null) {
      target.lost(game);
      return true;
    }
    return false;
  }
}

  @Override
  public boolean apply(Game game, Ability source) {
    Player controller = game.getPlayer(source.getControllerId());
    if (controller != null) {
      controller.lost(game);
      return true;
    }
    return false;
  }
}

  @Override
  public boolean apply(Game game, Ability source) {
    Player target = game.getPlayer(this.getTargetPointer().getFirst(game, source));
    if (target != null) {
      target.lost(game);
      return true;
    }
    return false;
  }
}

@Override
protected boolean checkStateBasedActions() {
  for (Player player : getPlayers().values()) {
    for (UUID commanderId : player.getCommandersIds()) {
      CommanderInfoWatcher damageWatcher = getState().getWatcher(CommanderInfoWatcher.class, commanderId);
      if (damageWatcher == null) {
        continue;
      }
      for (Map.Entry<UUID, Integer> entrySet : damageWatcher.getDamageToPlayer().entrySet()) {
        if (entrySet.getValue() > 20) {
          Player opponent = getPlayer(entrySet.getKey());
          if (opponent != null && !opponent.hasLost() && player.isInGame()) {
            opponent.lost(this);
          }
        }
      }
    }
  }
  return super.checkStateBasedActions();
}

@Override
public boolean apply(Game game, Ability source) {
  Player player = game.getPlayer(source.getControllerId());
  if (player != null) { 
    if (player.chooseUse(Outcome.Benefit, "Pay " + cost.getText()  + '?', source, game)) {
      cost.clearPaid();
      if (cost.pay(source, game, source.getSourceId(), source.getControllerId(), false, null)){
        return true;
      }
    }
    player.lost(game);
    return true;
  }
  return false;
}

protected UUID findWinnersAndLosers() {
  UUID winnerIdFound = null;
  for (Player player : state.getPlayers().values()) {
    if (player.hasWon()) {
      logger.debug(player.getName() + " has won gameId: " + getId());
      winnerIdFound = player.getId();
      break;
    }
    if (!player.hasLost() && !player.hasLeft()) {
      logger.debug(player.getName() + " has not lost so he won gameId: " + this.getId());
      player.won(this);
      winnerIdFound = player.getId();
      break;
    }
  }
  for (Player player : state.getPlayers().values()) {
    if (winnerIdFound != null && !player.getId().equals(winnerIdFound) && !player.hasLost()) {
      player.lost(this);
    }
  }
  return winnerIdFound;
}

  @Override
  public boolean apply(Game game, Ability source) {
    int life;
    PlayerList playerList = game.getState().getPlayersInRange(source.getControllerId(), game);
    for (UUID pid : playerList) {
      Player player = game.getPlayer(pid);
      if (player != null) {
        life = player.getLife();
        if (life == 13) {
          player.lost(game);
        }
      }
    }
    for (UUID pid : playerList) {
      Player player = game.getPlayer(pid);
      if (player != null) {
        player.gainLife(1, game, source);
      }
    }
    return true;
  }
}

  @Override
  public boolean apply(Game game, Ability source) {
    int life;
    PlayerList playerList = game.getState().getPlayersInRange(source.getControllerId(), game);
    for (UUID pid : playerList) {
      Player player = game.getPlayer(pid);
      if (player != null) {
        life = player.getLife();
        if (life == 13) {
          player.lost(game);
        }
      }
    }
    for (UUID pid : playerList) {
      Player player = game.getPlayer(pid);
      if (player != null) {
        player.loseLife(1, game, false);
      }
    }
    return true;
  }
}

@Override
public boolean replaceEvent(GameEvent event, Ability source, Game game) {
  Player controller = game.getPlayer(event.getPlayerId());
  if (controller != null) {
    Target target = new TargetCardInYourGraveyard(amount, new FilterCard("card in your graveyard"));
    if (target.canChoose(source.getSourceId(), controller.getId(), game)) {
      if (controller.choose(Outcome.Exile, target, source.getSourceId(), game)) {
        Set<Card> cards = new HashSet<>(amount);
        for (UUID targetId : target.getTargets()) {
          Card card = controller.getGraveyard().get(targetId, game);
          if (card != null) {
            cards.add(card);
          }
        }
        controller.moveCardsToExile(cards, source, game, true, null, "");
        return true;
      }
    }
    controller.lost(game);
  }
  return true;
}

    && exiledCard.getOwnerId().equals(player.getId()))).map((_item) -> 1).reduce(cardsFound, Integer::sum);
if (cardsFound > 2) {
  player.lost(game);

@Override
public boolean apply(Game game, Ability source) {
  Player controller = game.getPlayer(source.getControllerId());
  if (controller != null) {
    Target target = new TargetControlledPermanent(amount, amount, filter, true);
    if (target.canChoose(source.getSourceId(), controller.getId(), game)) {
      if (controller.choose(Outcome.Sacrifice, target, source.getSourceId(), game)) {
        for (UUID targetId : target.getTargets()) {
          Permanent permanent = game.getPermanent(targetId);
          if (permanent != null) {
            permanent.sacrifice(source.getSourceId(), game);
          }
        }
        return true;
      }
    }
    controller.lost(game);
    return true;
  }
  return false;
}

@Override
public boolean replaceEvent(GameEvent event, Ability source, Game game) {
  Player controller = game.getPlayer(source.getControllerId());
  if (controller != null) {
    boolean cardReturned = false;
    TargetCardInYourGraveyard target = new TargetCardInYourGraveyard();
    target.setNotTarget(true);
    if (target.canChoose(source.getSourceId(), controller.getId(), game)) {
      if (target.choose(Outcome.ReturnToHand, controller.getId(), source.getSourceId(), game)) {
        Card card = game.getCard(target.getFirstTarget());
        if (card != null) {
          controller.moveCards(card, Zone.HAND, source, game);
          cardReturned = true;
        }
      }
    }
    if (!cardReturned) {
      game.informPlayers(controller.getLogName() + " can't return a card from graveyard to hand.");
      controller.lost(game);
    }
    return true;
  }
  return false;
}

@Override
public boolean apply(Game game, Ability source) {
  Player targetPlayer = game.getPlayer(source.getFirstTarget());
  if (targetPlayer != null && targetPlayer.canLose(game)) {
    game.informPlayers(targetPlayer.getLogName() + " was destroyed");
    targetPlayer.lost(game); // double checks canLose, but seems more future-proof than lostForced
  }
  Permanent sourcePermanent = game.getPermanent(source.getSourceId());
  MageObject mageObject = game.getObject(source.getSourceId());
  if (sourcePermanent != null && mageObject != null) {
    if (game.getState().getValue(mageObject.getId() + "_doom") == null) {
      return false;
    }
    Integer doomNumber = 5;
    game.getState().setValue(mageObject.getId() + "_doom", doomNumber);
    ((Permanent) mageObject).addInfo("doom counter", CardUtil.addToolTipMarkTags("Doom counter at: " + doomNumber), game);
    return true;
  }
  return false;
}

  || player.isEmptyDraw()
  || player.getCounters().getCount(CounterType.POISON) >= 10)) {
player.lost(this);