예제 #1
0
  @Override
  public synchronized int temPartida(Integer idJogador) throws RemoteException {
    if (partidas.isEmpty()) return 0;
    if (partidas.size() > 49)
      throw new RemoteException(
          "O jogo atingiu seu limite de 50 partidas simultâneas, por favor tente mais tarde.");

    List<Partida> partidasAux =
        partidas
            .stream()
            .filter(p -> (p.getJogadores() != null && p.getJogadores().size() < 2))
            .collect(Collectors.toList());

    if (partidasAux.isEmpty()) return 0;

    Partida partida = partidasAux.get(0);
    if (partida == null || partida.getJogadores().isEmpty()) return 0;

    partida.getJogadores().add(idJogador);
    partida.setJogadorDaVez(1);

    Jogador jogador = jogadores.get(idJogador);
    jogador.setStatus(0);
    jogador.setOrdemJogada(partida.getJogadores().size());

    return partida.getJogadores().size();
  }
예제 #2
0
  @Override
  public synchronized int encerraPartida(Integer idJogador) throws RemoteException {
    Partida partida = getMinhaPartida(idJogador);

    if (partida == null) return -1;

    Jogador jogador = this.jogadores.get(idJogador);

    if (partida.getJogadores().size() > 1) {
      Jogador oponente =
          this.jogadores.get(
              partida
                  .getJogadores()
                  .stream()
                  .filter(j -> !j.equals(idJogador))
                  .collect(Collectors.toList())
                  .get(0));

      jogador.setStatus(6); // 6 -> perdedor por WO
      oponente.setStatus(5); // 5 -> vencedor por WO
    }
    this.partidas.remove(partida);

    return 0;
  }
예제 #3
0
  @Override
  public synchronized int registraJogador(String nomeJogador) throws RemoteException {
    Collection<Jogador> jogadoresAux = this.jogadores.values();

    if (jogadoresAux.stream().filter(j -> (nomeJogador.equals(j.getNomeJogador()))).count() > 0)
      return -1;

    Jogador j = new Jogador(getPID(), nomeJogador);
    this.jogadores.put(j.getIdJogador(), j);

    return j.getIdJogador();
  }
예제 #4
0
  @Override
  public synchronized int ehMinhaVez(Integer idJogador) throws RemoteException {
    Partida partida = getMinhaPartida(idJogador);
    Jogador jogador = jogadores.get(idJogador);
    Integer vencedor = 0;

    if (partida == null && jogador == null) return -1;

    if (partida == null) return jogador.getStatus();

    if (partida.getJogadores().size() > 1) vencedor = verificarVencedor(partida, jogador);

    if (vencedor > 0) return vencedor;

    if (partida.getJogadorDaVez().equals(jogador.getOrdemJogada())) return 1;
    else return 0;
  }
예제 #5
0
  @Override
  public synchronized int criaPartida(Integer idJogador, Integer tamanhoTabuleiro)
      throws RemoteException {
    try {
      List<Integer> listaJogador = new ArrayList<>();
      listaJogador.add(idJogador);

      Tabuleiro tabuleiro = new Tabuleiro(tamanhoTabuleiro);
      Partida partida = new Partida(listaJogador, tabuleiro);
      Jogador jogador = jogadores.get(idJogador);
      jogador.setOrdemJogada(partida.getJogadores().size());

      this.partidas.add(partida);

      return 1;

    } catch (Exception e) {
      return -1;
    }
  }
예제 #6
0
  @Override
  public synchronized int enviaJogada(Integer idJogador, Integer numColuna) throws RemoteException {
    Partida partida = getMinhaPartida(idJogador);
    Jogador jogador = jogadores.get(idJogador);
    Integer vencedor = ehMinhaVez(idJogador);

    if (partida == null) return -1;
    if (vencedor > 1) return vencedor;

    Tabuleiro tabuleiro = partida.getTabuleiro();
    Integer[][] grade = tabuleiro.getGrade();

    if (colunaCheia(tabuleiro, numColuna)) return 0;

    for (int i = (tabuleiro.getNumColuna() - 1); i >= 0; i--) {
      if (0 == grade[i][numColuna]) {
        grade[i][numColuna] = jogador.getOrdemJogada();
        if (jogador.getOrdemJogada().equals(1)) partida.setJogadorDaVez(2);
        else partida.setJogadorDaVez(1);
        return 1;
      }
    }
    return -1;
  }
예제 #7
0
  private int verificarVencedor(Partida partida, Jogador jogador) {
    Jogador oponente =
        this.jogadores.get(
            partida
                .getJogadores()
                .stream()
                .filter(j -> !j.equals(jogador.getIdJogador()))
                .collect(Collectors.toList())
                .get(0));
    Tabuleiro tabuleiro = partida.getTabuleiro();
    boolean vencedor;

    vencedor = verificarVertical(tabuleiro, jogador.getOrdemJogada());
    if (!vencedor) vencedor = verificarHorizontal(tabuleiro, jogador.getOrdemJogada());
    if (!vencedor) vencedor = verificarDiagonal(tabuleiro, jogador.getOrdemJogada());

    if (oponente.getStatus() == 2 && vencedor) { // 4 -> houve empate
      jogador.setStatus(4);
      oponente.setStatus(4);
      return 4;
    }
    if (oponente.getStatus() == 2) { // 3 -> é o perdedor
      jogador.setStatus(3);
      return 3;
    }
    if (vencedor) { // 2 -> é o vencedor
      jogador.setStatus(2);
      oponente.setStatus(3);
      return 2;
    }
    if (oponente.getStatus() == 5) { // 6 -> perdedor por WO
      jogador.setStatus(6);
      return 6;
    }
    if (tabuleiroCheio(tabuleiro)) { // 4 -> houve empate
      jogador.setStatus(4);
      oponente.setStatus(4);
      return 4;
    }

    return -1;
  }