AgenteEmboscadaHelada.java - pfc-gtg-mspacman - Agente software que utiliza inteligencia computacional para controlar a Ms. Pacman

Source path: svn/ tags/ pfc-gtg-pacmanvsghosts/ 1.1_EmboscadaHelada/ src/ gtg/ pfc/ pacmanvsghosts/ controladores/ mspacman/ AgenteEmboscadaHelada.java

‹r41

r49

package gtg.pfc.pacmanvsghosts.controladores.mspacman;

import java.awt.Color;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

import screenpac.model.GhostState;
import screenpac.model.Node;
import screenpac.model.GameStateInterface;
import screenpac.features.NearestPillDistance;
import screenpac.features.Utilities;
import screenpac.controllers.AgentInterface;
import screenpac.extract.Constants;

/**
 * Este agente está basado en el algoritmo IcePambush3 (ganador del CIG 2009) creado por Takashi Ashida, Takeru Miyama, Hiroshi Matsumoto, y Ruck Thawonmas,
 * de la Ritsumeikan University de Japón. Ya que este agente es una versión de dicho algoritmo se ha tomado el nombre de "Emboscada helada"
 * 
 * Se ha tomado este algoritmo como punto de partida y como muestra de sistema experto.
 * Su comportamiento general consiste en comer las pildoras normales mientras no se acerquen los fantasmas
 * y si los fantasmas se acercan emboscarles. Dicha "emboscada" consiste en ir hacia una posición proxima a la pildora de poder más cercana, y esperar el momento oportuno para tomarla y perseguir a los fantasmas.
 * Dicha regla es la principal estrategia para alcanzar una buena puntuación ya que comer varios fantasmas seguidos es lo que da más puntos.
 * 
 * @author tamudo84
 */
public class AgenteEmboscadaHelada implements AgentInterface, Constants {
    
    // Las constantes estaban definidas en el código original de ICEPambush teniendo en cuenta que no habia separación entre una casilla de pildora y otra.
    // Sin embargo, en este kit, se definen tres nodos intermedios para pasar de una pildora a otra. Así que se define un factor de escalabilidad de 4 con respecto al algoritmo original
    private static int SCALE_FACTOR = 4;	
    
    // Distancias originales de IcePambush3
    public static int DISTANCIA_EMBOSCADA = 4 * SCALE_FACTOR;
    public static int DISTANCIA_PILDORA_PODER_LEJOS = 20 * SCALE_FACTOR;
    public static int DISTANCIA_PILDORA_PODER_CERCA = 5 * SCALE_FACTOR;   
    public static int DISTANCIA_FANTASMA_LEJOS = 8 * SCALE_FACTOR;
    public static int DISTANCIA_FANTASMA_CERCA = 4 * SCALE_FACTOR;
    public static int DISTANCIA_FANTASMA_PROXIMO_PILDORA_PODER = 6 * SCALE_FACTOR;
    public static int DISTANCIA_FANTASMA_COMESTIBLE_CERCA = 10 * SCALE_FACTOR;
    public static int DISTANCIA_PILDORA_CERCA = 10 * SCALE_FACTOR;
    
    
    private static int DISTANCIA_NULL = -1;


    /**
     * Como la clase implementa la interfaz AgentInterface está obligada a implementar este método.
     * Define la dirección que debe de tomar mspacman en la siguiente iteración en función del estado del juego actual
     * 
     * @param gameState estado del juego
     * @return devuelve la dirección hacia la que se moverá mspacman en el siguiente turno
     * @see screenpac.controllers.AgentInterface#action(screenpac.model.GameStateInterface)
     */
    public int action(GameStateInterface gameState) {
    	int direccionATomar; // Aún por decidir
    	
        gameState = gameState.copy();
        
        // Se calculan todos estos parámetros que servirán para la toma de decisiones de las diferentes reglas definidas
        Node posicionActualPacman = gameState.getPacman().current;
        Node pildoraPoderMasProxima = pildoraPoderMasProxima(gameState, posicionActualPacman);
        Node pildoraMasProxima = pildoraMasProxima(gameState, posicionActualPacman, false);
        Node pildoraMasProximaQueNoEstaEntreDosCrucesDeCaminosQueContenganUnaPildoraDePoder = pildoraMasProxima(gameState, posicionActualPacman, true);
        Node fantasmaAgresivoMasProximo = fantasmaAgresivoMasProximo(gameState, posicionActualPacman);
        Node fantasmaAgresivoMasProximoALaPildoraPoderMasProxima = (pildoraPoderMasProxima != null)?fantasmaAgresivoMasProximo(gameState, pildoraPoderMasProxima):null; 
        Node fantasmaComestibleMasProximo = fantasmaComestibleMasProximo(gameState, posicionActualPacman);
        
        int distanciaPildoraPoderMasProxima = (pildoraPoderMasProxima != null)?gameState.getMaze().dist(pildoraPoderMasProxima, posicionActualPacman):DISTANCIA_NULL;
        int distanciaPildoraMasProxima = (pildoraMasProxima != null)?gameState.getMaze().dist(pildoraMasProxima, posicionActualPacman):DISTANCIA_NULL;
        int distanciaFantasmaAgresivoMasProximo = (fantasmaAgresivoMasProximo != null)?gameState.getMaze().dist(fantasmaAgresivoMasProximo, posicionActualPacman):DISTANCIA_NULL;
        int distanciaFantasmaAgresivoMasProximoALaPildoraPoderMasProxima = (fantasmaAgresivoMasProximoALaPildoraPoderMasProxima != null)?gameState.getMaze().dist(fantasmaAgresivoMasProximoALaPildoraPoderMasProxima, pildoraPoderMasProxima):DISTANCIA_NULL;
        int distanciaFantasmaComestibleMasProximo = (fantasmaComestibleMasProximo != null)?gameState.getMaze().dist(fantasmaComestibleMasProximo, posicionActualPacman):DISTANCIA_NULL;
        
        boolean existeAlMenosUnaPildoraDePoder = pildoraPoderMasProxima != null;
        boolean existeAlMenosUnaPildora = pildoraMasProxima != null;
        boolean existeAlMenosUnaPildoraQueNoEstaEntreDosCrucesDeCaminosQueContenganUnaPildoraDePoder = pildoraMasProximaQueNoEstaEntreDosCrucesDeCaminosQueContenganUnaPildoraDePoder != null;
        boolean existeAlMenosUnFantasmaAgresivo = fantasmaAgresivoMasProximo != null;        
        boolean existeAlMenosUnFantasmaComestible = fantasmaComestibleMasProximo != null;
        
        Node nodoObjetivo = null; //Proximo nodo al que se quiere ir, aún por decidir
        
       
        if (existeAlMenosUnaPildoraDePoder && (distanciaPildoraPoderMasProxima <= DISTANCIA_PILDORA_PODER_CERCA) &&
        	existeAlMenosUnFantasmaAgresivo &&(DISTANCIA_FANTASMA_CERCA < distanciaFantasmaAgresivoMasProximo) && (distanciaFantasmaAgresivoMasProximo <= DISTANCIA_FANTASMA_LEJOS) &&
        	(distanciaFantasmaAgresivoMasProximoALaPildoraPoderMasProxima >= DISTANCIA_FANTASMA_PROXIMO_PILDORA_PODER)){
        	// Regla 1
        	// System.out.println("Regla 1");
        	nodoObjetivo = nodoEmboscadaMasProximo(gameState, posicionActualPacman, pildoraPoderMasProxima, DISTANCIA_EMBOSCADA);
        	
        }else if(existeAlMenosUnaPildoraDePoder && !existeAlMenosUnFantasmaComestible && (distanciaPildoraPoderMasProxima <= DISTANCIA_EMBOSCADA) &&
        		((distanciaFantasmaAgresivoMasProximo <= DISTANCIA_FANTASMA_CERCA ) || (distanciaFantasmaAgresivoMasProximoALaPildoraPoderMasProxima <= DISTANCIA_FANTASMA_PROXIMO_PILDORA_PODER) ) ){
        	// Regla 2
        	// System.out.println("Regla 2");
        	nodoObjetivo = pildoraPoderMasProxima;	// Usando la segunda version del algortimo A* (No implementado aún)
        	
        }else if(existeAlMenosUnaPildoraDePoder && !existeAlMenosUnFantasmaComestible &&
        		existeAlMenosUnFantasmaAgresivo && (distanciaFantasmaAgresivoMasProximo <= DISTANCIA_FANTASMA_LEJOS) &&
        		(distanciaPildoraPoderMasProxima < DISTANCIA_PILDORA_PODER_CERCA)){
        	// Regla 3
        	// System.out.println("Regla 3");
        	nodoObjetivo = pildoraPoderMasProxima;  // Usando la segunda version del algortimo A* (No implementado aún)
        	
        }else if(existeAlMenosUnaPildoraDePoder && !existeAlMenosUnFantasmaComestible &&
        		existeAlMenosUnFantasmaAgresivo && (distanciaFantasmaAgresivoMasProximo <= DISTANCIA_FANTASMA_LEJOS)){
        	// Regla 4
        	// System.out.println("Regla 4");
        	nodoObjetivo = pildoraPoderMasProxima;  // Usando la primera version del algortimo A* (No implementado aún)
        	
        }else if(existeAlMenosUnFantasmaAgresivo && (distanciaFantasmaAgresivoMasProximo <= DISTANCIA_FANTASMA_LEJOS) &&
        		 existeAlMenosUnFantasmaComestible && (distanciaFantasmaComestibleMasProximo <= DISTANCIA_FANTASMA_COMESTIBLE_CERCA)){
        	// Regla 5
        	// System.out.println("Regla 5");
        	nodoObjetivo = fantasmaComestibleMasProximo; // Usando la primera version del algortimo A* (No implementado aún)
        	
        }else if(existeAlMenosUnaPildora && existeAlMenosUnFantasmaAgresivo && (distanciaFantasmaAgresivoMasProximo <= DISTANCIA_FANTASMA_LEJOS)){
        	// Regla 6 
        	// System.out.println("Regla 6");
        	nodoObjetivo = pildoraMasProxima; // Usando la primera version del algortimo A* (No implementado aún)
        	
        }else if (existeAlMenosUnFantasmaComestible && (!existeAlMenosUnFantasmaAgresivo || (distanciaFantasmaAgresivoMasProximo > DISTANCIA_FANTASMA_LEJOS)) &&
        		  (distanciaFantasmaComestibleMasProximo <= DISTANCIA_FANTASMA_COMESTIBLE_CERCA)){
        	// Regla 7
        	// System.out.println("Regla 7");
        	nodoObjetivo = fantasmaComestibleMasProximo;  // Usando la segunda version del algortimo A* (No implementado aún)
        	
        }else if (existeAlMenosUnaPildoraDePoder && !existeAlMenosUnaPildoraQueNoEstaEntreDosCrucesDeCaminosQueContenganUnaPildoraDePoder && 
        		  (!existeAlMenosUnFantasmaAgresivo || (distanciaFantasmaAgresivoMasProximo > DISTANCIA_FANTASMA_LEJOS)) &&
      		      (distanciaPildoraPoderMasProxima >= DISTANCIA_PILDORA_PODER_LEJOS) && 
      		      existeAlMenosUnaPildora && (distanciaPildoraMasProxima <= DISTANCIA_PILDORA_CERCA)){
	      	// Regla 8
        	// System.out.println("Regla 8");
	      	nodoObjetivo = pildoraMasProxima;  // Usando la segunda version del algortimo A* (No implementado aún)
	      	
	    }else if (existeAlMenosUnaPildoraQueNoEstaEntreDosCrucesDeCaminosQueContenganUnaPildoraDePoder && 
      		      (!existeAlMenosUnFantasmaAgresivo || (distanciaFantasmaAgresivoMasProximo > DISTANCIA_FANTASMA_LEJOS))){
	      	// Regla 9
        	// System.out.println("Regla 9");
	      	nodoObjetivo = pildoraMasProximaQueNoEstaEntreDosCrucesDeCaminosQueContenganUnaPildoraDePoder;  // Usando la segunda version del algortimo A* (No implementado aún)
	      	
        }else{
        	// System.out.println("Ninguna regla");
        }
        
        if(nodoObjetivo != null){
        	// Buscamos el nodo adyacente más cercano al nodo objetivo para poder calcular la dirección a tomar        
        	Node nodoAdyacenteMasProximoANodoObjetivoSinFantasmas = nodoAdyacenteMasProximoANodoObjetivo(gameState, posicionActualPacman,nodoObjetivo, true);        	
        	Node nodoAdyacenteMasProximoANodoObjetivo = nodoAdyacenteMasProximoANodoObjetivo(gameState, posicionActualPacman,nodoObjetivo, false);
        	
        	if (nodoAdyacenteMasProximoANodoObjetivoSinFantasmas != null){
        		direccionATomar = Utilities.getWrappedDirection(posicionActualPacman, nodoAdyacenteMasProximoANodoObjetivoSinFantasmas, gameState.getMaze());
        	}else if(nodoAdyacenteMasProximoANodoObjetivo != null){
        		direccionATomar = Utilities.getWrappedDirection(posicionActualPacman, nodoAdyacenteMasProximoANodoObjetivo, gameState.getMaze());
        	}else{
        		direccionATomar = NEUTRAL;
        	}
        }else{
        	direccionATomar = NEUTRAL;
        }
     
        
        return direccionATomar;
    }
    
    
    /**
     * Dado el estado del juego te calcula la posición del nodo de la pildora más cercana
     * a la posición del nodo pasado como parametro
     * 
     * @param gameState estado del juego
     * @param node nodo desde el cual queremos calcular la distancia más cercana
     * @param forzarComprobacionQueNoEsteEntreDosCrucesDeCaminosQueContenganPildoraPoder si está a true se devolverá, si lo hubiera, una pildora que no este entre dos cruces que contengan una pildora de poder
     * @return devuelve el nodo donde se encuentra la pildora más cercana, devuelve null si no encuentra ninguna
     */
    public static Node pildoraMasProxima(GameStateInterface gameState, Node node, boolean forzarComprobacionQueNoEsteEntreDosCrucesDeCaminosQueContenganPildoraPoder){
    	int minDist = Integer.MAX_VALUE;
    	Node nodoPildoraMasProxima = null;
    	
    	List<Node> listaPildoras = gameState.getMaze().getPills();
    	
        for (Node nodoPildora : listaPildoras) {
            // Comprobamos que sea una pildora
            if (gameState.getPills().get(nodoPildora.pillIndex)) {            	
            	// Comprobamos que esté más cerca que la anterior encontrada
                if (gameState.getMaze().dist(node, nodoPildora) < minDist) {
                	// Si hace falta forzaremos la comprobación de que la pildora no esté entre dos cruces que contengan una pildora de poder
                	if(!forzarComprobacionQueNoEsteEntreDosCrucesDeCaminosQueContenganPildoraPoder || !nodoEntreDosCrucesDeCaminosQueContieneAlgunaPildoraDePoder(gameState, nodoPildora)){
	                	minDist = gameState.getMaze().dist(node, nodoPildora);
	                    nodoPildoraMasProxima = nodoPildora;
                	}
                }
            	
            }
        }
        
        return nodoPildoraMasProxima;
    }
    
    /**
     * Dado el estado del juego te calcula la posición del nodo de la pildora de poder más cercana
     * a la posición del nodo pasado como parametro
     * 
     * @param gameState estado del juego
     * @param node nodo desde el cual queremos calcular la distancia más cercana
     * @return devuelve el nodo donde se encuentra la pildora de poder más cercana, devuelve null si no encuentra ninguna
     */
    public static Node pildoraPoderMasProxima(GameStateInterface gameState, Node node){
    	int minDist = Integer.MAX_VALUE;
    	Node nodoPildoraPoderMasProxima = null;
    	
    	List<Node> listaPildorasPoder = gameState.getMaze().getPowers();
    	
        for (Node nodoPildoraPoder : listaPildorasPoder) {
            // check the state of this pill
            // by querying the BitSet of pill states
            if (gameState.getPowers().get(nodoPildoraPoder.powerIndex)) {
                // this pill is on, but is it closer?
                if (gameState.getMaze().dist(node, nodoPildoraPoder) < minDist) {
                    minDist = gameState.getMaze().dist(node, nodoPildoraPoder);
                    nodoPildoraPoderMasProxima = nodoPildoraPoder;
                }
            }
        }
        
        return nodoPildoraPoderMasProxima;
    }
    
    /**
     * Comprueba si el nodo que se pasa como parámetro se encuentra entre dos cruces donde hay una pildora de poder
     * 
     * @gameState estado del juego
     * @param nodo es el nodo que se quiere comprobar
     * @return devuelve true si el nodo está entre dos cruces dónde hay una pildora de poder o false en caso contrario
     */
    public static boolean nodoEntreDosCrucesDeCaminosQueContieneAlgunaPildoraDePoder(GameStateInterface gameState, Node nodo){
    	boolean encontradaPildoraDePoder = false;
    	
    	/*
    	 * Para calcularlo comprueba que el nodo no tiene más de dos nodos adjuntos
    	 * Si tuviera más de dos es que se encuentra en una interseccion y por lo tanto ya es false
    	 * 
    	 * Si tiene dos, hay que alcanzar una inserseccion por los dos extremos. Si llegamos a ambas intersecciones
    	 * sin encontrarnos pildora de poder entonces devolvemos false
    	 * 
    	 * Si encontramos pildora de poder antes de intersección entonces es true
    	 */
    	
    	List<Node> listaNodosAdyacentes = nodo.adj;
    	
    	if(listaNodosAdyacentes.size() == 2 ){
    		Node nodoAdyacente_A = listaNodosAdyacentes.get(0);
    		Node nodoAdyacente_B = listaNodosAdyacentes.get(1);
    		
    		Node nodoAdyacenteAnterior_A = nodo;
    		Node nodoAdyacenteAnterior_B = nodo;
    		
    		boolean enconcontradoCruce_A = false;
    		boolean enconcontradoCruce_B = false;
    		
    		while(!encontradaPildoraDePoder && (!enconcontradoCruce_A || !enconcontradoCruce_B)){
    			List<Node> listaAdyacenteTemporal = null;
    			
    			if(((nodoAdyacente_A.powerIndex >= 0) && gameState.getPowers().get(nodoAdyacente_A.powerIndex)) || ((nodoAdyacente_B.powerIndex >= 0) && gameState.getPowers().get(nodoAdyacente_B.powerIndex))){
    				encontradaPildoraDePoder = true;
    			}else{
    			
	    			if(enconcontradoCruce_A || (nodoAdyacente_A.adj.size() != 2)){
	    				enconcontradoCruce_A = true;
	    			}else{
	    				listaAdyacenteTemporal = new ArrayList<Node>(nodoAdyacente_A.adj);
	    				listaAdyacenteTemporal.remove(nodoAdyacenteAnterior_A);
	    				
	    				nodoAdyacenteAnterior_A = nodoAdyacente_A;
	    				nodoAdyacente_A = listaAdyacenteTemporal.get(0);
	    			}
	    			
	    			if(enconcontradoCruce_B || (nodoAdyacente_B.adj.size() != 2)){
	    				enconcontradoCruce_B = true;
	    			}else{
	    				listaAdyacenteTemporal = new ArrayList<Node>(nodoAdyacente_B.adj);
	    				listaAdyacenteTemporal.remove(nodoAdyacenteAnterior_B);
	    				
	    				nodoAdyacenteAnterior_B = nodoAdyacente_B;
	    				nodoAdyacente_B = listaAdyacenteTemporal.get(0);
	    			}
    			}    			
    		}    		
    	}
    	return encontradaPildoraDePoder;
    }
    
    /**
     * Dado el estado del juego te calcula la posición del nodo del fantasma más cercano
     * a la posición del nodo pasado como parametro
     * 
     * @param gameState estado del juego
     * @param node nodo desde el cual queremos calcular la distancia más cercana
     * @param comestible indica si se desea la distancia de lo que sean comestible o agresivos
     * @return devuelve el nodo donde se encuentra el fantasma agresivo más cercano, si no existe devuelve null
     */
    public static Node fantasmaMasProximo(GameStateInterface gameState, Node node, boolean comestible){
    	int minDist = Integer.MAX_VALUE;
    	Node nodoFantasmaMasProximo = null;
    	
    	GhostState[] arrayEstadoFantasmas = gameState.getGhosts();
    	
    	for (GhostState estadoFantasma: arrayEstadoFantasmas){
    		int distanciaFantasma = gameState.getMaze().dist(node, estadoFantasma.current);
    		
    		if (((estadoFantasma.edible() && comestible) || (!estadoFantasma.edible() && !comestible)) && (distanciaFantasma < minDist)){
    			nodoFantasmaMasProximo = estadoFantasma.current;
    			minDist = distanciaFantasma;
    		}
    	}
        
        return nodoFantasmaMasProximo;
    }
    
    /**
     * Dado el estado del juego te calcula la posición del nodo del fantasma agresivo más cercano
     * a la posición del nodo pasado como parametro
     * 
     * @param gameState estado del juego
     * @param node nodo desde el cual queremos calcular la distancia más cercana
     * @return devuelve el nodo donde se encuentra el fantasma agresivo más cercano, si no existe devuelve null
     */
    public static Node fantasmaAgresivoMasProximo(GameStateInterface gameState, Node node){
    	return fantasmaMasProximo(gameState, node, false);
    }
    
    /**
     * Dado el estado del juego te calcula la posición del nodo del fantasma comestible más cercano
     * a la posición del nodo pasado como parametro
     * 
     * @param gameState estado del juego
     * @param node nodo desde el cual queremos calcular la distancia más cercana
     * @return devuelve el nodo donde se encuentra el fantasma agresivo más cercano, si no existe devuelve null
     */
    public static Node fantasmaComestibleMasProximo(GameStateInterface gameState, Node node){
    	return fantasmaMasProximo(gameState, node, true);
    }
    
    /**
     * Devuelve el nodo más cercano para hacer una emboscada a un nodo dado
     * 
     * @param gameState estado del juego
     * @param nodoSituacionActual nodo de la posición actual del pacman
     * @param nodoObjetivoEmboscada nodo que se quiere utilizar para la emboscada
     * @param distanciaEmboscada distancia a la que se quiere permanecer del nodo de emboscada
     * @return el nodo más cercano para hacer una emboscada a un nodo dado
     */
    public static Node nodoEmboscadaMasProximo(GameStateInterface gameState, Node nodoSituacionActual, Node nodoObjetivoEmboscada, int distanciaEmboscada){
    	Node nodoEmboscadaMasProximo = null;
    	
    	Set<Node> candidatosNodosEmboscada = new HashSet<Node>();
    	
    	candidatosNodosEmboscada.addAll(nodoObjetivoEmboscada.adj);
    	    	
    	for(int distanciaNodos = 1;distanciaNodos <= distanciaEmboscada;distanciaNodos++){
    		// Limpiamos los que no tengan distancia de con el nodoObjetivoEmboscada de distanciaNodos
    		Set<Node> candicatosNoFactibles = new HashSet<Node>();
    		for(Node nodo:candidatosNodosEmboscada){
    			if(gameState.getMaze().dist(nodo, nodoObjetivoEmboscada) != distanciaNodos){
    				candicatosNoFactibles.add(nodo);
    			}
    		}
    		candidatosNodosEmboscada.removeAll(candicatosNoFactibles);
    		
    		if(distanciaNodos < distanciaEmboscada){
	    		// Para todos los nodos que queden le añadimos su lista de adyacentes
    			// si es que aún no hemos llegado a la distancia deseada
    			
    			Set<Node> nuevosCandidatosNodosEmboscada = new HashSet<Node>();
	    		for(Node nodo:candidatosNodosEmboscada){
	    			nuevosCandidatosNodosEmboscada.addAll(nodo.adj);
	    		}
	    		candidatosNodosEmboscada = nuevosCandidatosNodosEmboscada;
    		}
    	}
    	
    	// Ahora, de todos los posibles candidatos (nodos a la distancia de emboscada dada)
    	// nos quedamos con el nodo más cercano al pacman
    	int minDist = Integer.MAX_VALUE;
    	for (Node nodoCandidato: candidatosNodosEmboscada){
    		int distanciaCandidato = gameState.getMaze().dist(nodoCandidato, nodoSituacionActual);
    		
    		if ((distanciaCandidato < minDist)){
    			nodoEmboscadaMasProximo = nodoCandidato;
    			minDist = distanciaCandidato;
    		}
    	}
    	
    	return nodoEmboscadaMasProximo;
    }
    
    /**
     * Devuelve el nodo adyacente más cercano de un nodo dado a un nodo objetivo
     * 
     * @param gameState estado del juego
     * @param nodoSituacionActual nodo de la posición actual del pacman
     * @param nodoObjetivo nodo que se quiere utilizar para la emboscada
     * @param evitarFantasmasAgresivos si está a true solo tirará por un camino que no contenga fantasmas 
     * @return el nodo adyacente a la posicion actual más cercano al nodo objetivo, si no lo encuentra devuelve null
     */
    public static Node nodoAdyacenteMasProximoANodoObjetivo(GameStateInterface gameState, Node nodoSituacionActual, Node nodoObjetivo, boolean evitarFantasmasAgresivos){
    	List<Node> nodosAdyacentes = nodoSituacionActual.adj;
    	
    	int minDist = Integer.MAX_VALUE;
    	Node nodoAdyacenteMasProximoANodoObjetivo = null;
    	
    	for(Node nodoAdyacente:nodosAdyacentes){
    		int distNodoAdyacente = gameState.getMaze().dist(nodoAdyacente, nodoObjetivo);
    		
    		if ((distNodoAdyacente < minDist) && (!evitarFantasmasAgresivos || tramoSinFantasmasAgresivos(gameState, nodoSituacionActual, nodoAdyacente))){
            	minDist = distNodoAdyacente;
            	nodoAdyacenteMasProximoANodoObjetivo = nodoAdyacente;
            } 
    	}
    	
    	return nodoAdyacenteMasProximoANodoObjetivo;
    }
    
    
    /**
     * Devuelve si el siguiente tramo contiene fantasmas agresivos. 
     * Consideraremos un tramo a la posicion actual y una intersección si avanzamos en el sentido hacia el nodoAdyacenteSiguiente
     * 
     * @param gameState estado del juego
     * @param nodoSituacionActual nodo de la posición actual del pacman
     * @param nodoAdyacenteSiguiente nodo siguiente al que queremos avanzar y que indica el sentido de la marcha
     * @return devuelve true, si no hay fantasmas en el tramo a recorrer y false en otro caso
     */
    public static boolean tramoSinFantasmasAgresivos(GameStateInterface gameState, Node nodoSituacionActual, Node nodoAdyacenteSiguiente){
    	boolean tramoSinFantasmas = true;
    	boolean finTramo = false;  // Cuando encontramos el cruce
    	
    	Node nodoAComprobar = nodoAdyacenteSiguiente;
    	Node nodoAnterior = nodoSituacionActual;
    	
    	while(!finTramo && tramoSinFantasmas && nodoAComprobar!= null){    		
    		if(nodoHayFantasmaAgresivo(gameState, nodoAComprobar)){
    			tramoSinFantasmas = false;
    		}else if(nodoAComprobar.adj == null || nodoAComprobar.adj.size() > 2){
    			finTramo = true;    			
    		}else{
    			// Salvaguardamos el nodo anterior y el nodo a comprobar porque lo vamos a necesitar y adjudicamos los proximos valores de la iteracion siguiente
    			Node nodoAnteriorTemp = nodoAnterior;
    			Node nodoAComprobarTemp = nodoAComprobar;
    			
    			nodoAnterior = nodoAComprobar;
    			nodoAComprobar = null;
    			
    			// Buscamos el siguiente nodo a comprobar comprobando que no se trate del nodoAnterior
    			for(Node nodoAdyacente:nodoAComprobarTemp.adj){    				
    				if(!nodoAdyacente.equals(nodoAnteriorTemp)){
    					nodoAComprobar = nodoAdyacente;
    				}
    			}
    		}
    	}
    	
    	return tramoSinFantasmas;
    }

	/**
	 * Devuelve true si en el nodo a comprobar se encuentra actualmente un fantasma agresivo o no
	 * 
	 * @param gameState estado del juego
	 * @param nodoAComprobar nodo que se quiere comprobar 
	 * @return devuelve true si en el nodo a comprobar hay actualmente un fantasma agresivo, false en otro caso
	 */
	public static boolean nodoHayFantasmaAgresivo(GameStateInterface gameState, Node nodoAComprobar) {
		boolean hayFantasmaAgresivo = false;
		
		GhostState[] arrayEstadoFantasmas = gameState.getGhosts();
    	
		int indiceFantasma = 0;
    	while(!hayFantasmaAgresivo && (arrayEstadoFantasmas != null) && (indiceFantasma < arrayEstadoFantasmas.length)){
    		GhostState estadoFantasma = arrayEstadoFantasmas[indiceFantasma];
    		
    		if ((estadoFantasma!= null) && !estadoFantasma.edible() && estadoFantasma.current.equals(nodoAComprobar)){
    			hayFantasmaAgresivo = true;
    		}
    		indiceFantasma++;
    	}
		
		return hayFantasmaAgresivo;
	}
}

Show details Hide details

Change log

r42 by tamudo84 on Feb 23, 2011 Diff

Creada nueva tag 1.1_EmboscadaHelada

Go to:

Project members, sign in to write a code review

Older revisions

r41 by tamudo84 on Feb 23, 2011 Diff

- Refactorizado, limpiado y
documentado el código. Ahora el agente
creado se llama Emboscada Helada

r40 by tamudo84 on Feb 21, 2011 Diff

Creado un algoritmo que toma
correctamente la dirección a tomar

r38 by tamudo84 on Jan 26, 2011 Diff

Implementadas las 9 reglas de
IcePambush

All revisions of this file

File info

Size: 26245 bytes, 490 lines

View raw file