Autentia en la javacup

Autentia en la javacup

0. Índice de contenidos.

• 1. ¿Qué es la javacup?
• 2. ¿Cómo participar en la javacup?
• 3. La estrategia de los Elepanders al descubierto
• 4. Conclusiones

1. ¿Qué es la javacup?

La Javacup es un torneo que llevan organizando desde hace unos años nuestros amigos de Javahispano. Se trata de un api que os podéis
descargar de la página oficial. En la web también podréis descargaros la documentación del api y las reglas para participar.

2. ¿Cómo participar en la javacup?

Podéis descargaros el proyecto desde aquí. Una vez lo hayáis bajado tendréis que abrirlo con el NetBeans

Una vez abierto podéis configurar vuestro equipo en el paquete org.javahispano.javacup.gui.asistente, más concretamente con la clase Asistente.java

Cuando tengáis vuestra táctica programada la podréis probar con la clase Principal.java. Sólo tenéis que seleccionar las estrategias visitante y local y ejecutar el partido. Desde aquí queremos
felicitar a los creadores del Api. Nos ha gustado mucho y lo hemos encontrado muy divertido. La simulación del partido es del siguiente estilo:

3. La estrategia de los Elepanders al descubierto

Este año hemos tenido poco tiempo para dedicarle a la Javacup, tan solo un par de semanas, pero os vamos a poner algunas funciones que hemos usado en nuestra estrategia. Básicamente nuestro proceso fue: primero entender la estrategia que
usaban los patéticos para poder mejorarla. Luego fuimos creando pequeñas mejoras, e íbamos probándolas para comprobar como afectaban al juego de nuestro equipo.

    public Posicion posicionRivalMasCercano(Posicion miPosicion, SituacionPartido sp) {
        final Posicion[] posicionRivales = sp.rivales();
        double minimaDistancia = 500;
        double distancia;
        Posicion posicionRivalMasCercano = new Posicion();
        for (Posicion posicionRival: posicionRivales) {
            distancia = miPosicion.distancia(posicionRival);
            if (minimaDistancia > distancia ) {
                minimaDistancia = distancia;
                posicionRivalMasCercano = posicionRival;
            }
        }
        return posicionRivalMasCercano;
    }

Con esta función lo que hacíamos era que los jugadores cuyo número era menor que 5, es decir, todos los defensas de nuestro equipo, fueran a cubrir al rival más cercano. La primera vez que ejecutamos el algoritmo con la «peora», nos reímos un montón. TODOS los jugadores salieron a cubrir
al rival más cercano, incluido el ¡¡¡¡portero!!!! . Los patéticos nos metieron 11. Luego incluimos sólo a los defensas.

    private boolean rivalEstaCubierto(Posicion posicionRival, Posicion[] posicionMisJugadores) {
        for (Posicion miPosicion: posicionMisJugadores) {
            if (  ( posicionRival.getX() - DISTANCIA_ROBO_BALON <= miPosicion.getX() )
                && ( miPosicion.getX() <= posicionRival.getX() + DISTANCIA_ROBO_BALON )
                && ( posicionRival.getY() - DISTANCIA_ROBO_BALON <= miPosicion.getY() )
                && ( miPosicion.getY() <= posicionRival.getY() + DISTANCIA_ROBO_BALON ) )
                    return true;
        }
        return false;
    }
	
	public int[] obtenerDelanterosRivalesCubiertos(SituacionPartido sp) {

        int[] listaJugadoresCubiertos = new int[11];
        inicializarListaACero(listaJugadoresCubiertos);

        final Posicion[] posicionmisJugadores = sp.misJugadores();
        final Posicion[] posicionRivales = sp.rivales();

        JugadorDetalle[] detalleJugadoresRivales = sp.detalleJugadoresRivales();
        for ( JugadorDetalle detalleJugadorRival: detalleJugadoresRivales ) {
            if (detalleJugadorRival.esPortero()) {
                listaJugadoresCubiertos[detalleJugadorRival.getNumero()] = 1;
            } else if ( rivalEstaCubierto (posicionRivales[detalleJugadorRival.getNumero()-1], posicionmisJugadores) ) {
                listaJugadoresCubiertos[detalleJugadorRival.getNumero()-1]++;
            }

        }
        return listaJugadoresCubiertos;
    }

Con estas funciones calculábamos los delanteros que estábamos cubriendo, y por cuántos de nuestros defensas, ya que con el algortimo anterior varios de nuestros defensas cubrían al mismo delantero, como si se tratara del mismísimo Messi implementado en Java. Nuestra siguiente idea era hacer que cada defensa cubriera al delantero más cercano no cubierto, y por eso implementamos esas funciones aunque no pudimos perfeccionar la estrategia.

    /**
     * Devuelve true si he sobrepasado la vertical a 30 metros de la porteria
     * @param miPosicion
     * @param sp
     * @return
     */
    public boolean estoyEnDisposicionDeRematar(Posicion miPosicion, SituacionPartido sp) {
       int numeroPorteroRival = numeroPorteroRival(sp);
       if (  (sp.rivales()[numeroPorteroRival].getY() - 30 <= miPosicion.getY())
               && (miPosicion.getY()<= sp.rivales()[numeroPorteroRival].getY() + 30) ) {
           return true;
       }
       return false;

    }

Con esta función gestionábamos el ataque. Tirábamos si estábamos a menos de 30 metros de la portería. A continuación os ponemos la parte del algoritmo que se encargaba del ataque.

		Random r = new Random();
        for (int i : sp.puedenRematar()) {
            //Si el jugador es de indice 8 o 10
            if (i == 0) { //Soy el portero
                comandos.add(new ComandoGolpearBalon(i, alineacion1[1], 1, 12 + Constantes.ANGULO_VERTICAL_MAX));
            }
            if (estoyEnDisposicionDeRematar(posicionJugadores[i], sp)) {
                    comandos.add(new ComandoGolpearBalon(i, Constantes.centroArcoSup, 1, 12 + r.nextInt(6)));
            } else {
                int jugadorDestino;
                if ( estoyCubierto(posicionJugadores[i], sp) || i == 0 ) {
                    jugadorDestino = buscarJugadorOptimo(i, sp);
                    comandos.add(new ComandoGolpearBalon(i, posicionJugadores[jugadorDestino], 1, 15));
                } else {
                    Posicion trayectoriaPorteriaContraria = getTrayectoriaPorteriaContraria(posicionJugadores[i], sp);
                    comandos.add(new ComandoGolpearBalon(i, trayectoriaPorteriaContraria, 0.42, false));

                }
                
            }
        }

Básicamente nuestra idea era, si podíamos tirar con ciertas posibilidades de meter ( menos de 30 metros a portería ) tirábamos. Sino comprobábamos si estaba nuestro jugador cubierto. En ese caso buscábamos al jugador óptimo para pasarle la pelota y se la pasábamos. Si no estábamos cubiertos hacíamos correr a nuestros jugadores en dirección a la portería.

4. Conclusiones

Este año nos hemos divertido muchísimo y estamos orgullosos de nuestros 9 golitos, que nos hacen ser los segundos más goleadores de la parte baja de la clasificación, jejeje. Como buenos entrenadores achacamos nuestra posición a los árbitros que no nos han pitado muchos penaltis :P. El año que viene programaremos con las manos y no con los codos y los Elepanders volverán más fuertes y con más tiki-taka que nunca ;).