Example #1
0
  /** Create the application. */
  public FrameJuego(String ip, int puerto, String nombre) throws Exception {

    servidor = new Socket(ip, puerto);
    initialize();

    entrada = new ObjectInputStream(servidor.getInputStream());
    threadComunicacion.start();

    Thread.sleep(100);

    for (Jugador j : juego.getJugadores()) {
      if (nombre.equals(j.getNombre())) {
        JOptionPane.showMessageDialog(null, "Ya hay un jugador con ese nombre");
        frmDrawPum.dispose();
        return;
      }
    }

    salida = new PrintWriter(servidor.getOutputStream());

    salida.println("0" + "&" + nombre + "&" + nombre);
    salida.flush();

    jugador = nombre;

    frmDrawPum.setVisible(true);
  }
 public void eliminarJugador(Jugador j) {
   for (Jugador aux : jugadores) {
     if (aux.getNoCamisa() == j.getNoCamisa()) {
       jugadores.remove(j);
     }
   }
 }
Example #3
0
 Partida(Jugador jugadorA, Jugador jugadorB) {
   this.jugadorA = jugadorA;
   this.jugadorB = jugadorB;
   cuartelA = jugadorA.getCuartel();
   cuartelB = jugadorB.getCuartel();
   mazoA = jugadorA.getCartasMazo();
   mazoB = jugadorB.getCartasMazo();
 }
Example #4
0
  public void muere() {

    Ba1 mundo = (Ba1) getWorld();

    if (this.isTouching(Jugador.class)) {

      mundo.restavidas();
      Jugador j = mundo.dimeJugador();
      j.setLocation(350, 50);
    }
  }
Example #5
0
 public Jugador obtenerOtroJugador(Jugador j) {
   if (jugadorA.equals(j)) {
     return jugadorB;
   } else {
     return jugadorA;
   }
 }
Example #6
0
  @Override
  public void render(float dt) {

    Gdx.gl.glClearColor(0, 0, 0, 1);
    Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT);

    // compara si la aplicacion se ejecuta en escritorio o en android
    if (Gdx.app.getType() == ApplicationType.Desktop) {
      this.entradaEscritorio(dt);
    } else if (Gdx.app.getType() == ApplicationType.Android) {
      this.entradaAndroid(dt);
    }
    // actualizamos
    camara.update();
    this.juegoGanado();
    batch.setProjectionMatrix(camara.combined);
    manejadorDeSprite.update(dt, arcanoid, jugador);

    // renderiza el manejadorDeSprite, fondo de pantalla y fuente de jugador
    batch.begin();
    batch.draw(fondoPantalla, 0, 0, Gdx.graphics.getWidth(), Gdx.graphics.getHeight());
    jugador.draw(batch);
    batch.end();
    manejadorDeSprite.render();
  }
Example #7
0
  @Test
  public void testIntegracionPartidaUnoVsUnoSinFlor() {
    elJuego =
        new Juego.Builder()
            .conRepartidor(repartidor)
            .agregarEquipo(new Equipo(jEquipoUno))
            .agregarEquipo(new Equipo(jEquipoDos))
            .iniciar();
    int puntajeEsperadoEquipoUno = 0;
    int puntajeEsperadoEquipoDos = 0;
    for (int i = 0; i < 2; i++) {
      puntajeEsperadoEquipoUno += 7;
      puntajeEsperadoEquipoDos += 2;
      Assert.assertEquals(jEquipoUno, elJuego.obtenerJugadorQueInicioRonda());
      ejecutarPrimeraRondaUnoVsUnoSinFlor();
      Assert.assertEquals(puntajeEsperadoEquipoUno, jEquipoUno.getEquipo().obtenerPuntajeTotal());
      Assert.assertEquals(puntajeEsperadoEquipoDos, jEquipoDos.getEquipo().obtenerPuntajeTotal());
      puntajeEsperadoEquipoUno += 7;
      puntajeEsperadoEquipoDos += 2;
      Assert.assertEquals(jEquipoDos, elJuego.obtenerJugadorQueInicioRonda());
      ejecutarSegundaRondaUnoVsUnoSinFlor();
      Assert.assertEquals(puntajeEsperadoEquipoUno, jEquipoUno.getEquipo().obtenerPuntajeTotal());
      Assert.assertEquals(puntajeEsperadoEquipoDos, jEquipoDos.getEquipo().obtenerPuntajeTotal());
    }
    Assert.assertEquals(28, jEquipoUno.getEquipo().obtenerPuntajeTotal());
    Assert.assertEquals(8, jEquipoDos.getEquipo().obtenerPuntajeTotal());

    Assert.assertEquals(jEquipoUno, elJuego.obtenerJugadorQueInicioRonda());
    elJuego.obtenerJugadorConDecision().tomarDecision(Decision.ENVIDO);
    elJuego.obtenerJugadorConDecision().tomarDecision(Decision.FALTA_ENVIDO);
    elJuego.obtenerJugadorConDecision().tomarDecision(Decision.QUIERO_ENVIDO);
    elJuego.obtenerJugadorConDecision().tomarDecision(Decision.SON_BUENAS);
    Assert.assertEquals(30, jEquipoUno.getEquipo().obtenerPuntajeTotal());
    Assert.assertTrue(elJuego.estaLaPartidaFinalizada());
  }
  public Object coerceToUi(java.lang.Object val, org.zkoss.zk.ui.Component comp) {

    DaoRoster daoRoster = new DaoRoster();

    if (val instanceof Jugador) {
      jugador = ((Jugador) val);
      roster = daoRoster.buscarRoster(jugador.getCedulaRif());
      if (roster == null) return valorRetornado = "";
      else valorRetornado = roster.getEquipo().getNombre();
    }
    return valorRetornado;
  }
  /**
   * Juego de naves que utiliza un Singletos para comunicar las clases
   *
   * <p>Se obtiene el singleton
   *
   * <p>Se eliminan las naves en base a los disparos Se incrementas las naves en un randon con base
   * a las vidas
   *
   * @param args
   */
  public static void main(String[] args) {
    Naves n1 = Naves.instanciaNaves();

    Jugador j1 = new Jugador();
    Computadora c1 = new Computadora();

    Scanner leer = new Scanner(System.in);

    System.out.println("==== JUEGO DE NAVES ====");

    int aDisparar;

    /** Mientras se tengan vidas se puede seguir jugando */
    while (n1.getVidas() >= 0) {

      System.out.println("Tienes " + n1.getVidas() + ", Cuántos disparos?\n");
      aDisparar = leer.nextInt();

      if (!(aDisparar > n1.getVidas())) {

        System.out.println("Naves actuales" + n1.getVidas() + "\n");

        for (int i = aDisparar; i > 0; i--) {
          j1.eliminarNave();
        }

        System.out.println("Naves destruidas " + aDisparar + "\n");

        int createNavaes = (int) Math.floor(Math.random() * n1.getVidas());

        for (int i = createNavaes; i > 0; i--) {
          c1.crearNave();
        }

      } else {
        System.out.println("No puedes disparar más de lo que tienes\n");
      }
    }
  }
Example #10
0
  public boolean ejecutarCasillaRetencion(boolean pTurno, Jugador pJugador, int pPos) {

    // Buscamos la casilla para saber los turnos de retencion
    CasillaRetencion unaCasilla = ListaCasillas.getListaCasillas().buscarCasillaRetencion(pPos);

    // Mostramos los turnos que va a estar retenido
    Visualizacion.getVisualizacion()
        .visualizarTurnosDeRetencion(pJugador, unaCasilla.getTurnosRetencion());

    // Aplicamos al jugador los turnos de retencion
    pJugador.retener(unaCasilla.getTurnosRetencion());

    pTurno = false;

    return pTurno;
  }
Example #11
0
  public boolean ejecutarCasillaTraslado(boolean pTurno, Jugador pJugador, int pPos) {

    // Buscamos la casilla para saber a que casilla va a ser trasladado el jugador
    CasillaTraslado casillaTraslado = ListaCasillas.getListaCasillas().buscarCasillaTraslado(pPos);

    // Movemos al jugador de casilla
    pJugador.moverACasilla(casillaTraslado.getCasillaDesp());

    // Mostramos a que casilla ha sido movido
    Visualizacion.getVisualizacion().visualizarTraslado(pJugador);

    if (casillaTraslado.getNumero() == 58) {
      pTurno = false;
    }
    return pTurno;
  }
Example #12
0
  /**
   * Este método sirve para verificar los datos de la partida y actualizar los datos si el usuario
   * ha superado algún record.
   */
  private void verificarPartida() {
    int jugadas = jugador.getJugadas();
    double tiempoJugador = jugador.getTiempo();

    if (contadorJugadas <= jugadas || jugadas == 0) {
      if (contadorJugadas < jugadas) {
        if (Double.parseDouble(tiempoFinal) < tiempoJugador) {
          jugador.setJugadas(contadorJugadas);
          jugador.setTiempo(Double.parseDouble(tiempoFinal));
        } else {
          jugador.setJugadas(contadorJugadas);
        }
      }
      if (contadorJugadas == jugadas) {
        if (Double.parseDouble(tiempoFinal) < tiempoJugador) {
          jugador.setTiempo(Double.parseDouble(tiempoFinal));
        }
      }
      if (jugadas == 0) {
        jugador.setJugadas(contadorJugadas);
        jugador.setTiempo(Double.parseDouble(tiempoFinal));
      }
    }
  }
Example #13
0
 @Then("^hay empate$")
 public void hay_empate() {
   Assert.assertEquals(Resultado.EMPATE, jugadorUno.juegaContra(jugadorDos));
 }
Example #14
0
 @Then("^gana jugadorDos$")
 public void gana_jugadorDos() {
   Assert.assertEquals(Resultado.PIERDE, jugadorUno.juegaContra(jugadorDos));
 }
Example #15
0
 private boolean controlarSiElCantoDeFlorFinalizo() {
   int jugadoresConFlor = 0;
   for (Jugador jugador : this.jugadoresEnJuego) if (jugador.tieneFlor()) jugadoresConFlor++;
   return (this.cantoEnProcesoParaElTanto.terminoElProcesoDeCanto(jugadoresConFlor));
 }
Example #16
0
  /** Test of analizarPuntuacion method, of class JuegoEspadas. */
  @Test
  public void testAnalizarPuntuacion() {
    System.out.println("analizarPuntuacion");
    Jugador j1 = new Jugador();
    Jugador j2 = new Jugador();
    JuegoEspadas juego = new JuegoEspadas();
    Baraja b = new Baraja();

    j1.setCarta(b.mostrar(1)); // ninguno con espadas para comprobar empate
    j2.setCarta(b.mostrar(2));
    assertEquals(null, juego.analizarPuntuacion(j1, j2)); // se comprueba empate

    j1.reset();
    j2.reset();
    j1.setCarta(b.mostrar(20));
    j2.setCarta(b.mostrar(2)); // gana j1 por mas espadas
    j1.setCarta(b.mostrar(3));
    j2.setCarta(b.mostrar(5));
    j1.setCarta(b.mostrar(0));
    j2.setCarta(b.mostrar(10));
    j1.setCarta(b.mostrar(7));
    j2.setCarta(b.mostrar(11));
    j1.setCarta(b.mostrar(32));
    j2.setCarta(b.mostrar(9));
    assertEquals(j1, juego.analizarPuntuacion(j1, j2)); // gana j1

    j1.reset();
    j2.reset();
    j1.setCarta(b.mostrar(2));
    j2.setCarta(b.mostrar(20)); // gana j2 por mas espadas
    j1.setCarta(b.mostrar(3));
    j2.setCarta(b.mostrar(5));
    j1.setCarta(b.mostrar(0));
    j2.setCarta(b.mostrar(10));
    j1.setCarta(b.mostrar(7));
    j2.setCarta(b.mostrar(11));
    j1.setCarta(b.mostrar(32));
    j2.setCarta(b.mostrar(9));
    j1.setCarta(b.mostrar(1));
    j2.setCarta(b.mostrar(20));
    assertEquals(j2, juego.analizarPuntuacion(j1, j2)); // gana j2

    j1.reset();
    j2.reset();
    j1.setCarta(b.mostrar(20));
    j2.setCarta(b.mostrar(25)); // gana j2 por espada mas alta
    j1.setCarta(b.mostrar(3));
    j2.setCarta(b.mostrar(5));
    j1.setCarta(b.mostrar(0));
    j2.setCarta(b.mostrar(10));
    j1.setCarta(b.mostrar(7));
    j2.setCarta(b.mostrar(11));
    j1.setCarta(b.mostrar(32));
    j2.setCarta(b.mostrar(9));
    j1.setCarta(b.mostrar(1));
    j2.setCarta(b.mostrar(20));
    assertEquals(j2, juego.analizarPuntuacion(j1, j2)); // gana j2

    j1.setCarta(b.mostrar(25));
    j2.setCarta(b.mostrar(20)); // gana j1 por espada mas alta
    j1.setCarta(b.mostrar(3));
    j2.setCarta(b.mostrar(5));
    j1.setCarta(b.mostrar(0));
    j2.setCarta(b.mostrar(10));
    j1.setCarta(b.mostrar(7));
    j2.setCarta(b.mostrar(11));
    j1.setCarta(b.mostrar(32));
    j2.setCarta(b.mostrar(9));
    j1.setCarta(b.mostrar(1));
    j2.setCarta(b.mostrar(20));
    assertEquals(j2, juego.analizarPuntuacion(j1, j2)); // gana j2
  }
Example #17
0
  public void jugar() {

    this.enEjecución = true;

    Jugador jugadorActual;

    // Iniciamos el iterador
    Iterator<Jugador> itrJug = ListaJugadores.getListaJugadores().getIterador();

    // Mientras no haya finalizado ningun jugador, seguimos
    while (ListaJugadores.getListaJugadores().algunoHaTerminado() == false) {

      // Mientras turno sea true, sera el turno del jugador actual
      // Al cambiar a false, el turno pasara al siguiente
      Boolean turno = true;

      // Si estabamos en el ultimo reiniciamos el iterador
      // para volver al primero
      if (!itrJug.hasNext()) {
        itrJug = ListaJugadores.getListaJugadores().getIterador();
      }

      // Cogemos un jugador
      jugadorActual = itrJug.next();

      // Si el jugador estuviese retenido en alguna casilla, no entraria en el while,
      // por lo que pasaria el turno al siguiente jugador.
      // Si el jugador esta en la ultima casilla, tampoco entraría en el while, ya que
      // tiene un tratamiento distinto.
      while (jugadorActual.getRetencion() == 0
          && turno == true
          && jugadorActual.getPosicion() != 63) {

        // Tiramos el dado
        int tirada = Dado.getDado().getTirada();
        Visualizacion.getVisualizacion().visualizarTirada(jugadorActual.getNombre(), tirada);

        // Avanzamos hasta la casilla que nos corresponda
        jugadorActual.avanzar(tirada);
        Visualizacion.getVisualizacion().visualizarAvance(jugadorActual);

        // Obtenemos la posicion en la que se encuentra el jugador
        int posicion = jugadorActual.getPosicion();

        // Obtenemos el tipo de casilla en la que se encuentra
        int tipoCasilla = ListaCasillas.getListaCasillas().getTipoCasilla(posicion);

        switch (tipoCasilla) {

            // Casilla de pregunta
          case 1:
            turno = this.ejecutarCasillaNormal(turno);
            break;

            // Casilla de retencion
          case 2:
            turno = this.ejecutarCasillaRetencion(turno, jugadorActual, posicion);
            break;

            // Casilla de traslado
          case 3:
            this.ejecutarCasillaTraslado(turno, jugadorActual, posicion);
            break;
        }
      }

      if (turno && jugadorActual.getRetencion() != 0 && jugadorActual.getPosicion() != 63) {
        jugadorActual.actualizarRet();
        Visualizacion.getVisualizacion().visualizarRetencionPendiente(jugadorActual);
        turno = false;
      }

      // Al llegar a la ultima casilla se le hace al jugador una pregunta
      // de cada tema. Si falla alguna, pasa el turno al siguiente jugador.
      // Si en 3 turnos no acierta todas, vuelve a empezar
      if (jugadorActual.getPosicion() == 63) {
        if (jugadorActual.getRetencion() < 3) {
          jugadorActual.actualizarRet();
        }

        if (jugadorActual.getRetencion() != 0) {

          // Hacer preguntas, una de cada tipo
          // Si falla alguna nos salimos
          Boolean fallo = false;
          int cont = 0;
          int aciertos = 0;
          while (fallo == false && aciertos < 5) {

            Carta unaCarta = Listas.getMisListas().buscarCartaTema(cont);

            while (unaCarta == null) {
              unaCarta = Listas.getMisListas().buscarCartaTema(cont);
              if (unaCarta == null) {
                Listas.getMisListas().reiniciarListas();
              }
            }

            // Visualizar carta
            // Recoger respuesta
            Boolean resp =
                Visualizacion.getVisualizacion().visualizarCartayRecogerRespuesta(unaCarta);

            if (resp) {

              // Si acierta -> acierto+1
              aciertos++;
            } else {

              // Si falla -> fallo = true
              fallo = true;
            }

            cont++;
          }

          if (!fallo) {
            jugadorActual.ganar();
            Visualizacion.getVisualizacion().visualizarHaGanado(jugadorActual);
            this.enEjecución = false;
          }

        } else {

          // El jugador vuelve a empezar
          jugadorActual.moverACasilla(1);
        }
      }
    }
  }
Example #18
0
 @Then("^gana jugadorUno$")
 public void gana_jugadorUno() {
   Assert.assertEquals(Resultado.GANA, jugadorUno.juegaContra(jugadorDos));
 }