Exemple #1
0
 public Trajectory(Position ball, double velocity, double angle, double angleVert) {
   length = 75;
   positions = new Position[length];
   z = new double[length];
   AbstractTrajectory t =
       new AirTrajectory(velocity * Math.cos(angleVert), velocity * Math.sin(angleVert), 0, 0);
   for (int i = 0; i < length; i++) {
     double radio = t.getX((double) (i + 1) / 60d) * Constants.AMPLIFICA_VEL_TRAYECTORIA;
     positions[i] =
         new Position(
             ball.getX() + radio * Math.cos(angle), ball.getY() + radio * Math.sin(angle));
     z[i] = t.getY((double) (i + 1) / 60d) * Constants.AMPLIFICA_VEL_TRAYECTORIA * 2;
   }
 }
 @Override
 public String toString() {
   return "X ["
       + posBalon.getX()
       + "] Y ["
       + posBalon.getY()
       + "] Z["
       + altura
       + "] "
       + "\tjugador: "
       + idxJugador
       + "\tEs rival: "
       + ganaRival;
 }
Exemple #3
0
  private boolean existeJugadorRivalCercaDeBalon(GameSituations sp) {

    boolean result = false;

    for (Position rival : sp.rivalPlayers()) {

      if (rival.distance(sp.ballPosition()) < 10) {
        result = true;
        break;
      }
    }

    return result;
  }
  private double calculateFitness(
      Position position, double z, int iter, Position last, double lastZ) {
    int oppIterToBall =
        ChimueloTacticUtils.calculateIterToBall(
            position,
            z,
            currentSituation.rivalPlayers(),
            currentSituation.rivalPlayersDetail(),
            currentSituation.rivalIterationsToKick());
    double Dx = position.getX() - last.getX();
    double Dy = position.getY() - last.getY();

    if (!position.isInsideGameField(0)) {
      if (position.getY() > Constants.LARGO_CAMPO_JUEGO / 2) {
        double posX =
            (Dx / Dy) * (Constants.LARGO_CAMPO_JUEGO / 2 - position.getY()) + position.getX();
        double Dz = z - lastZ;
        double posZ = (Dz / Dy) * (Constants.LARGO_CAMPO_JUEGO / 2 - position.getY()) + z;
        if (posZ <= Constants.ALTO_ARCO
            && Math.abs(posX) < Constants.LARGO_ARCO / 2 - Constants.RADIO_BALON
            && z - Dz <= Constants.ALTO_ARCO) {
          double fvel = Math.sqrt(Dx * Dx + Dy * Dy) / Constants.REMATE_VELOCIDAD_MAX;
          double fiter = Math.max(0, Math.min(1, (oppIterToBall - iter) / 75.0));
          double fx =
              Math.max(
                  0,
                  Math.min(
                      1, 1 - Math.abs(posX) / (Constants.LARGO_ARCO / 2 - Constants.RADIO_BALON)));
          return 1 + .40 * fvel + .45 * fiter + .15 * fx;
        }
      }
      return -1;
    }
    if (oppIterToBall <= iter) {
      double fdist = Math.max(0, Math.min(1, position.getY() / Constants.centroArcoSup.getY()));
      double fiter = Math.max(0.0, 1 - (iter - oppIterToBall) / 5.0);
      double fvel =
          Math.max(0, Math.min(1, Math.sqrt(Dx * Dx + Dy * Dy) / Constants.REMATE_VELOCIDAD_MAX));
      return -1 + (.3 * fdist + .1 * fiter + .6 * fvel);
    }
    return 0;
  }
Exemple #5
0
  /** Renderiza el juego, uso interno */
  @Override
  public void render(GameContainer gc, Graphics g) throws SlickException {
    double escalaTemporal = 0;
    if (autoescala) {
      escalaTemporal = escala;
      if (!noAutoEscalar) {
        escala = Math.min(escala, escalaAjustada);
        if (partido.getIteracion() < 50) {
          escalaGradual = escalaGradual + (escala - escalaGradual) * 0.01;
        } else {
          escalaGradual = escalaGradual + (escala - escalaGradual) * 0.2;
        }
      }

      escala = escalaGradual;
    }
    Position p = new Position(px, py);
    if (entorno) {
      pc.pintaEntorno(g, p, escala);
    }
    pc.pintaCancha(g, p, escala);
    Position[][] pos = partido.getPosiciones();
    if (!partido.esGol() && partido.estanSacando()) {
      double zoom = 1 * escala * (1 + 0.02 * (double) iterSaca);
      rel =
          Transforma.transform(
              pos[2][0],
              Constants.centroCampoJuego,
              -Transforma.transform(px, escala) + sx2,
              -Transforma.transform(py, escala) + sy2,
              escala);
      g.drawImage(
          xImage.getScaledCopy((int) zoom, (int) zoom),
          rel[0] - (int) (zoom / 2),
          rel[1] - (int) (zoom / 2));
    }
    Position ball = partido.getPosVisibleBalon();
    for (int i = 0; i < 11; i++) {
      rel =
          Transforma.transform(
              pos[0][i],
              Constants.centroCampoJuego,
              -Transforma.transform(px, escala) + sx2,
              -Transforma.transform(py, escala) + sy2,
              escala);
      pjLocal.pintaSombra(i, iteraciones[i][0], angVisible[i][0], escala, rel[0], rel[1], g);
      rel =
          Transforma.transform(
              pos[1][i],
              Constants.centroCampoJuego,
              -Transforma.transform(px, escala) + sx2,
              -Transforma.transform(py, escala) + sy2,
              escala);
      pjVisita.pintaSombra(i, iteraciones[i][1], angVisible[i][1], escala, rel[0], rel[1], g);
    }
    z = partido.getAlturaBalon(); // 16*Math.sin(Math.abs(ang % Math.PI));

    if (partido.estaRebotando() || z == 0) {
      ang = -balon0.angle(ball);
      velgiro = balon0.distance(ball) * 1.5;
    }
    if (partido.estanRematando()) {
      ang = rand.nextDouble() * Math.PI * 2;
      velgiro = rand.nextDouble();
    }

    balon0 = ball;
    giro = giro + velgiro * 1.5;
    if (giro < 0) {
      giro = 6 + giro;
    }
    rel =
        Transforma.transform(
            ball,
            Constants.centroCampoJuego,
            -Transforma.transform(px, escala) + sx2,
            -Transforma.transform(py, escala) + sy2,
            escala);
    pb.pintaSombra(escala, rel[0], rel[1], z, g);
    if (partido.getAlturaBalon() <= 2) {
      pb.pintaBalon((int) (giro), ang, escala, rel[0], rel[1], z * 2, g);
    }
    pp.pintaPublicidad(g, p, escala);

    if (jugador3d) {
      lista.clear();
      for (int i = 0; i < 11; i++) {
        rel =
            Transforma.transform(
                pos[0][i],
                Constants.centroCampoJuego,
                -Transforma.transform(px, escala) + sx2,
                -Transforma.transform(py, escala) + sy2,
                escala);
        lista.add(
            new Object[] {pjLocal, i, iteraciones[i][0], angVisible[i][0], escala, rel[0], rel[1]});
        rel =
            Transforma.transform(
                pos[1][i],
                Constants.centroCampoJuego,
                -Transforma.transform(px, escala) + sx2,
                -Transforma.transform(py, escala) + sy2,
                escala);
        lista.add(
            new Object[] {
              pjVisita, i, iteraciones[i][1], angVisible[i][1], escala, rel[0], rel[1]
            });
      }
      Object[] tmp1, tmp2;
      for (int i = 0; i < lista.size() - 1; i++) {
        for (int j = i + 1; j < lista.size(); j++) {
          tmp1 = lista.get(i);
          tmp2 = lista.get(j);
          if ((Integer) tmp1[6] > (Integer) tmp2[6]) {
            lista.set(i, tmp2);
            lista.set(j, tmp1);
          }
        }
      }

      for (Object obj[] : lista) {
        PintaJugador pj = (PintaJugador) obj[0];
        pj.pintaJugador(
            (Integer) obj[1],
            (Integer) obj[2],
            (Double) obj[3],
            (Double) obj[4],
            (Integer) obj[5],
            (Integer) obj[6],
            g);
      }

      for (int i = 0; i < 11; i++) {
        rel =
            Transforma.transform(
                pos[0][i],
                Constants.centroCampoJuego,
                -Transforma.transform(px, escala) + sx2,
                -Transforma.transform(py, escala) + sy2,
                escala);
        if (tipoTexto == 3 || (pos[0][i].distance(pos[2][0]) < 8 && tipoTexto == 1)) {
          pjLocal.pintaNumero(i, rel[0], rel[1], g);
        }
        if (tipoTexto == 4 || (pos[0][i].distance(pos[2][0]) < 8 && tipoTexto == 2)) {
          pjLocal.pintaNombre(i, rel[0], rel[1], g);
        }
        rel =
            Transforma.transform(
                pos[1][i],
                Constants.centroCampoJuego,
                -Transforma.transform(px, escala) + sx2,
                -Transforma.transform(py, escala) + sy2,
                escala);
        if (tipoTexto == 3 || (pos[1][i].distance(pos[2][0]) < 8 && tipoTexto == 1)) {
          pjVisita.pintaNumero(i, rel[0], rel[1], g);
        }
        if (tipoTexto == 4 || (pos[1][i].distance(pos[2][0]) < 8 && tipoTexto == 2)) {
          pjVisita.pintaNombre(i, rel[0], rel[1], g);
        }
      }
    } else {
      for (int i = 0; i < 11; i++) {
        rel =
            Transforma.transform(
                pos[0][i],
                Constants.centroCampoJuego,
                -Transforma.transform(px, escala) + sx2,
                -Transforma.transform(py, escala) + sy2,
                escala);
        pjLocal.pintaJugador(i, iteraciones[i][0], angVisible[i][0], escala, rel[0], rel[1], g);
        if (tipoTexto == 3 || (pos[0][i].distance(pos[2][0]) < 8 && tipoTexto == 1)) {
          pjLocal.pintaNumero(i, rel[0], rel[1], g);
        }
        if (tipoTexto == 4 || (pos[0][i].distance(pos[2][0]) < 8 && tipoTexto == 2)) {
          pjLocal.pintaNombre(i, rel[0], rel[1], g);
        }
        rel =
            Transforma.transform(
                pos[1][i],
                Constants.centroCampoJuego,
                -Transforma.transform(px, escala) + sx2,
                -Transforma.transform(py, escala) + sy2,
                escala);
        pjVisita.pintaJugador(i, iteraciones[i][1], angVisible[i][1], escala, rel[0], rel[1], g);
        if (tipoTexto == 3 || (pos[1][i].distance(pos[2][0]) < 8 && tipoTexto == 1)) {
          pjVisita.pintaNumero(i, rel[0], rel[1], g);
        }
        if (tipoTexto == 4 || (pos[1][i].distance(pos[2][0]) < 8 && tipoTexto == 2)) {
          pjVisita.pintaNombre(i, rel[0], rel[1], g);
        }
      }
    }

    rel =
        Transforma.transform(
            ball,
            Constants.centroCampoJuego,
            -Transforma.transform(px, escala) + sx2,
            -Transforma.transform(py, escala) + sy2,
            escala);
    if (partido.getAlturaBalon() > 2) {
      pb.pintaBalon((int) (giro), ang, escala, rel[0], rel[1], z * 2, g);
    }
    pc.pintaArcos(g, p, escala);
    if (estadio) {
      pc.pintaEstadio(g, p, escala);
    }
    if (marcador) {
      pm.pintaMarcador(
          partido.getGolesLocal(),
          partido.getGolesVisita(),
          partido.getIteracion(),
          partido.getPosesionBalonLocal(),
          g);
    }
    if (golIter > 0) {
      double zoom = 1 + 0.05 * (golIter % 3);
      g.drawImage(
          golImage.getScaledCopy((int) (361d * zoom), (int) (81d * zoom)),
          sx2 - (int) (180d * zoom),
          sy2 - (int) (40d * zoom));
    }

    if (offSideIter > 0) {
      g.drawImage(offSideImage, sx2 - 70, sy2 - 20);
      // g.drawImage(offSideImage, offSideIter - 300, sy2 - 20);
    }

    if (saqueIter > 0) {
      g.drawImage(cambioImage, saqueIter - 300, sy2 - 20);
    }
    if (autoescala) {
      escala = escalaTemporal;
    }
    if (guardado && iteracionControl > 0) {
      Image img = paImage;
      if (incremento > 0) {
        img = avImage;
      }
      if (incremento < 0) {
        img = reImage;
      }
      g.drawImage(img, sx2 - 10, sy2 - 10);
      g.setColor(Color.white);
      g.drawString("" + incremento + "x", sx2 + 20, sy2 - 10);
    }
    if (guardado && progreso) {
      g.setColor(Color.black);
      g.drawRect(sx - 20, 20, 10, sy - 40);
      g.setColor(Color.darkGray);
      g.fillRect(sx - 19, 21, 8, sy - 42);
      int valor =
          (int) (((double) sy - 41.0) * ((double) pg.getTiempo() / (double) pg.getIterciones()));
      int valorInicio =
          (int) (((double) sy - 42.0) * ((double) inicio / (double) pg.getIterciones()));
      int valorFin = (int) (((double) sy - 42.0) * ((double) fin / (double) pg.getIterciones()));
      g.setColor(Color.red);
      g.fillRect(sx - 19, sy - 21 - valor, 8, valor);
      g.setColor(Color.white);
      g.drawLine(sx - 19, sy - 22 - valorFin, sx - 12, sy - 22 - valorFin);
      g.drawLine(sx - 19, sy - 21 - valorFin, sx - 18, sy - 21 - valorFin);
      g.drawLine(sx - 13, sy - 21 - valorFin, sx - 12, sy - 21 - valorFin);
      g.drawLine(sx - 19, sy - 22 - valorInicio, sx - 12, sy - 22 - valorInicio);
      g.drawLine(sx - 19, sy - 23 - valorInicio, sx - 18, sy - 23 - valorInicio);
      g.drawLine(sx - 13, sy - 23 - valorInicio, sx - 12, sy - 23 - valorInicio);
    }
    if (showTexto) {
      if (partido.getIteracion() < 50) {
        g.setColor(Color.black);
        g.drawString(partido.getDetalleVisita().getTacticName() + " (Visita)", sx2 + 11, sy2 + 11);
        g.drawString("vs", sx2 + 41, sy2 + 41);
        g.drawString(partido.getDetalleLocal().getTacticName() + " (Local)", sx2 + 71, sy2 + 71);
        g.setColor(Color.white);
        g.drawString(partido.getDetalleVisita().getTacticName() + " (Visita)", sx2 + 10, sy2 + 10);
        g.drawString("vs", sx2 + 40, sy2 + 40);
        g.drawString(partido.getDetalleLocal().getTacticName() + " (Local)", sx2 + 70, sy2 + 70);
      }
    }
    if (showTexto) {
      if (partido.getIteracion() > Constants.ITERACIONES) {
        g.setColor(Color.black);
        g.drawString("Gana", sx2 + 11, sy2 + 11);
        if ((partido.getGolesLocal() > partido.getGolesVisita())
            || (partido.getGolesLocal() == partido.getGolesVisita()
                && partido.getPosesionBalonLocal() >= .5d)) {
          g.drawString(partido.getDetalleLocal().getTacticName(), sx2 + 41, sy2 + 41);
        } else {
          g.drawString(partido.getDetalleVisita().getTacticName(), sx2 + 41, sy2 + 41);
        }
        g.setColor(Color.white);
        g.drawString("Gana", sx2 + 10, sy2 + 10);
        if ((partido.getGolesLocal() > partido.getGolesVisita())
            || (partido.getGolesLocal() == partido.getGolesVisita()
                && partido.getPosesionBalonLocal() >= .5d)) {
          g.drawString(partido.getDetalleLocal().getTacticName(), sx2 + 40, sy2 + 40);
        } else {
          g.drawString(partido.getDetalleVisita().getTacticName(), sx2 + 40, sy2 + 40);
        }
      }
    }
    /*if (isRain) {
        g.setColor(lluvia);
        for (int i = 0; i < 200; i++) {
            double an = rand.nextDouble() * Math.PI * 2d;
            double rad = rand.nextDouble() * 1024;
            int x0 = (int) (sx2 + Math.sin(an) * rad);
            int y0 = (int) (sy2 + Math.cos(an) * rad);
            int x1 = (int) (sx2 + Math.sin(an) * rad * 1.1d);
            int y1 = (int) (sy2 + Math.cos(an) * rad * 1.1d);
            g.drawLine(x0, y0, x1, y1);
        }
        if (rand.nextDouble() < 0.05) {
            g.setColor(relampago);
            g.fillRect(0, 0, sx, sy);
        }
        isRain = rand.nextDouble() < 0.995;
    } else {
        isRain = rand.nextDouble() < 0.005;
    }*/
  }