package src;
import java.awt.Image;
import com.gameloftProgrammersCup.clientInterfaces.MapElement;
import java.net.Socket;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import java.util.TreeSet;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import src.estadisticas.Estadisticas;
import src.estadisticas.EstadisticasTipoUnidad;
import src.estadisticas.NodoMapaEstadisticas;
import com.gameloftProgrammersCup.client.ClientCommand;
import com.gameloftProgrammersCup.client.UnitStats;
import com.gameloftProgrammersCup.client.Vision;
import com.gameloftProgrammersCup.clientInterfaces.BasicPJ;
import com.gameloftProgrammersCup.clientInterfaces.Command;
import com.gameloftProgrammersCup.clientInterfaces.Fortress;
import com.gameloftProgrammersCup.clientInterfaces.Point;
import com.gameloftProgrammersCup.server.PlayerCharacter;
import java.math.*;
import src.estrategias.*;
public class Fortaleza extends UnidadBasica implements Fortress {
private List comandos = new ArrayList();
private int idComando=0;
private int idUnidad=1002;
private int costoUnidad=0;
private int esperaCreacion=0;
public int resourcesPayload=0;
private int recursosAnteriores=0;
public int payLoad=0;
public List unidades = new ArrayList();
public Set resources = new HashSet();//quedan solo las minas
public UnidadBasica unidadACrear = null;
public static MapElement[][] mapa;
public static int anchoMapa=0;
public static int altoMapa=0;
public Estadisticas estadisticas = new Estadisticas();
private final int radioSeguridadInicial=4;
public int radioSeguridad = radioSeguridadInicial;//distancia desde fortaleza que determina radio de seguridad
private EstrategiaGeneral estrategia;//=new EstrategiaEquilibrada(unidades);//o (null) es lo mismo
public List <Enemigo> enemigos = new ArrayList();
public static FortalezaEnemiga fortalezaEnemiga=null;
public int vidaInicial=0;
static public Fortaleza instanciaFortaleza ;//para poder acceder desde cualquier lado, singleton
/**
* cantidades de cada unidad presentes
* @return
*/
public int[] cantidadesUnidades(){
int[] proporciones = new int[MAX_UNIDAD];
Iterator it=unidades.iterator();
while(it.hasNext())
switch(((UnidadBasica)it.next()).getTipoInternoUnidad()){
case UnidadBasica.TIPO_COLECTORINICIAL:
proporciones[UnidadBasica.TIPO_COLECTORINICIAL]++;
break;
case UnidadBasica.TIPO_ASESINO:
proporciones[UnidadBasica.TIPO_ASESINO]++;
break;
case UnidadBasica.TIPO_COLECTORNORMAL:
proporciones[UnidadBasica.TIPO_COLECTORNORMAL]++;
break;
case UnidadBasica.TIPO_GUARDIA:
proporciones[UnidadBasica.TIPO_GUARDIA]++;
break;
case UnidadBasica.TIPO_EXPLORADOR:
proporciones[UnidadBasica.TIPO_EXPLORADOR]++;
break;
}
return proporciones;
}
public void addEnemigo(Enemigo enemigo){
enemigos.add(enemigo);
}
public int getUnidadesSize(){
return unidades.size();
}
public Fortaleza(int actionRange, int actionSpeed, int life, int id, Cliente jugador, int vision,EstrategiaGeneral estrategia) {
super(actionRange, actionSpeed, 0,life, id, jugador, vision);
this.estrategia = estrategia;
instanciaFortaleza = this;
// TODO Auto-generated constructor stub
}
public void addResources(PlayerCharacter arg0) {
// TODO Auto-generated method stub
}
public void addResources(List listaVision) {// sepodria hacer con un equals en elemento mapa y redefinir el hash
Iterator itVision= listaVision.iterator();
while (itVision.hasNext()){
Vision vision=(Vision) itVision.next();
boolean duplicado=false;
Iterator itrecursos = resources.iterator();
while (itrecursos.hasNext()){
MapElement recurso= (MapElement) itrecursos.next();
if (vision.getPosition().equals(recurso.getPosition()))
duplicado=true;
}
if (!duplicado){
if (Vision.TYPE_RESOURCE==vision.getType()){
Mina nuevoRecurso = new Mina();
nuevoRecurso.setPosition(vision.getPosition());
nuevoRecurso.setResourcesStored(0);
resources.add(nuevoRecurso);
}/*
else{
if (Vision.TYPE_ALLY==vision.getType()){
//busco la unidad y la agrego
}
else{
Enemigo nuevoRecurso= new Enemigo(vision.getType());
nuevoRecurso.setPosition(vision.getPosition());
resources.add(nuevoRecurso);
}
}*/
}
}
}
public void decreaseDelay() {
// TODO Auto-generated method stub
}
public int getAmountResourcesOwned() {
// TODO Auto-generated method stub
return 0;
}
public List getCharacters() {
// TODO Auto-generated method stub
return null;
}
public int getColorScheme() {
// TODO Auto-generated method stub
return 0;
}
public int getCreationCost() {
// TODO Auto-generated method stub
return 0;
}
public int getDelay() {
// TODO Auto-generated method stub
return 0;
}
public Image getImage() {
// TODO Auto-generated method stub
return null;
}
public Set getKnownResources() {
return resources;
}
public String getName() {
// TODO Auto-generated method stub
return null;
}
public int getPoints() {
// TODO Auto-generated method stub
return 0;
}
public Socket getSocket() {
// TODO Auto-generated method stub
return null;
}
public int getTroopId() {
// TODO Auto-generated method stub
return idUnidad;
}
public void reset() {
// TODO Auto-generated method stub
}
public void setColorScheme(int arg0) {
// TODO Auto-generated method stub
}
public void setDelay() {
// TODO Auto-generated method stub
}
public void setName(String arg0) {
// TODO Auto-generated method stub
}
public void setPoints(int arg0) {
// TODO Auto-generated method stub
}
public void setSocket(Socket arg0) {
// TODO Auto-generated method stub
}
public Command getCurrentCommand() {
// TODO Auto-generated method stub
return null;
}
public int getMaxLoad() {
// TODO Auto-generated method stub
return 0;
}
public void resourceXML(Document arg0, Element arg1) {
// TODO Auto-generated method stub
}
public void setResources(int arg0) {
// TODO Auto-generated method stub
}
public void unitXML(Document arg0, Element arg1) {
// TODO Auto-generated method stub
}
public void visionXML(Document arg0, Element arg1) {
// TODO Auto-generated method stub
}
public int getType() {
// TODO Auto-generated method stub
return MapElement.TYPE_FORTRESS;
}
public int resourcesStored() {
return this.payLoad;
}
public void crearUnidad(){
;
//Setea el costo con la primera unidad que produce
if (costoUnidad==0){
if (recursosAnteriores==0)
recursosAnteriores=this.resourcesStored();
else
costoUnidad=recursosAnteriores-this.resourcesStored();
}
ClientCommand nuevoComando=estrategia.fabricarUnidad(this);
//hay que hacer una decision bonita para ver que producir
/*
int cantidadRecolectores =0;
ClientCommand nuevoComando=new ClientCommand();
Iterator it= unidades.iterator();
while (it.hasNext()){
UnidadBasica unidad = (UnidadBasica) it.next();
if (unidad.getType()==MapElement.TYPE_COLLECTOR && ((Colector)unidad).getMaxLoad()!=0){
cantidadRecolectores++;
}
}
//creoguardia!
/* unidadACrear = new Guardia(this.getTroopId(), jugador,new EstrategiaGuardianFijo());//Atacante(2, 2, 10,2, this.getTroopId(), jugador,4);
// pup c va en el constructor((Colector)unidadACrear).setMovementSpeed(2);//malisimo :/
// pup c ya estaba defaulteado :)unidadACrear.setType(UnidadBasica.TIPO_ATACANTE);
nuevoComando.setId(idComando+1);
nuevoComando.setIdUnit(unidadACrear.getId());
nuevoComando.setType("create");
nuevoComando.setDestination(this.getPosition());
nuevoComando.setLife(unidadACrear.getLife());
nuevoComando.setActionRange(unidadACrear.getActionRange());
nuevoComando.setActionSpeed(unidadACrear.getActionSpeed());
nuevoComando.setMovementSpeed(unidadACrear.getMovementSpeed());
nuevoComando.setViewRange(unidadACrear.getVision());
nuevoComando.setUnitType(BasicPJ.TYPE_ATTACKER); */
/* if (cantidadRecolectores<1){
//creo recolector
unidadACrear = new ColectorInicial(this.getTroopId(), jugador, new EstrategiaColectorNormal());
//(2, 2, 10,4, this.getTroopId(), jugador,1,20);
//pup c va en el constructor ((Colector)unidadACrear).setMovementSped(2);//malisimo :/
//pup c ya estaba defaulteado :) unidadACrear.setType(UnidadBasica.TIPO_COLECTOR);
nuevoComando.setId(idComando+1);
nuevoComando.setIdUnit(unidadACrear.getId());
nuevoComando.setType("create");
nuevoComando.setDestination(this.getPosition());
nuevoComando.setLife(unidadACrear.getLife());
nuevoComando.setActionRange(unidadACrear.getActionRange());
nuevoComando.setActionSpeed(unidadACrear.getActionSpeed());
nuevoComando.setMaxCarry(unidadACrear.getMaxLoad());
nuevoComando.setMovementSpeed(unidadACrear.getMovementSpeed());
nuevoComando.setViewRange(unidadACrear.getVision());
nuevoComando.setUnitType(BasicPJ.TYPE_COLLECTOR);
}
else{//creo atacante
unidadACrear = new Explorador(this.getTroopId(), jugador, new EstrategiaExplorador());
// pup c va en el constructor((Colector)unidadACrear).setMovementSpeed(2);//malisimo :/
// pup c ya estaba defaulteado :)unidadACrear.setType(UnidadBasica.TIPO_ATACANTE);
nuevoComando.setId(idComando+1);
nuevoComando.setIdUnit(unidadACrear.getId());
nuevoComando.setType("create");
nuevoComando.setDestination(this.getPosition());
nuevoComando.setLife(unidadACrear.getLife());
nuevoComando.setActionRange(unidadACrear.getActionRange());
nuevoComando.setActionSpeed(unidadACrear.getActionSpeed());
nuevoComando.setMovementSpeed(unidadACrear.getMovementSpeed());
nuevoComando.setViewRange(unidadACrear.getVision());
nuevoComando.setUnitType(BasicPJ.TYPE_COLLECTOR);
}
*/
comandos.add(nuevoComando);
}
public List getComandos(){
return comandos;
}
public void crearMapa(int width,int height){
mapa= new MapElement[width][height];
estadisticas.crearMapa(width,height);
}
public void actualizarEntorno(List unitStats){
comandos.clear();
//actualizo la fortaleza, los costos de creacion, delay y agrego la nueva unidad si se pudo crear.
actualizarFortaleza(unitStats);
actualizarUnidades(unitStats);
actualizarMapa(unitStats);
limpiarMuertos();
}
/**
* elimina mis unidades muertas
*
*/
public void limpiarMuertos(){
Iterator it = unidades.iterator();
while(it.hasNext())
{
UnidadBasica ub = (UnidadBasica)it.next();
if(ub.getUltimoTurnoActualizado()!=0 && ub.getUltimoTurnoActualizado() != jugador.turno)//agregado
{
if (ub.getPosition()!=null){
mapa[ub.getPosition().getX()][ub.getPosition().getY()]=null;
it.remove();
switch(ub.getTipoInternoUnidad())
{
case UnidadBasica.TIPO_ASESINO:
Asesino.getEstadisticasTipoUnidad().setDa�oRecibido(Asesino.getEstadisticasTipoUnidad().getDa�oRecibido()+ub.life);
break;
case UnidadBasica.TIPO_COLECTORINICIAL:
ColectorInicial.getEstadisticasTipoUnidad().setDa�oRecibido(ColectorInicial.getEstadisticasTipoUnidad().getDa�oRecibido()+ub.life);
break;
case UnidadBasica.TIPO_COLECTORNORMAL:
ColectorNormal.getEstadisticasTipoUnidad().setDa�oRecibido(ColectorNormal.getEstadisticasTipoUnidad().getDa�oRecibido()+ub.life);
break;
case UnidadBasica.TIPO_EXPLORADOR:
Explorador.getEstadisticasTipoUnidad().setDa�oRecibido(Explorador.getEstadisticasTipoUnidad().getDa�oRecibido()+ub.life);
break;
case UnidadBasica.TIPO_GUARDIA:
Guardia.getEstadisticasTipoUnidad().setDa�oRecibido(Guardia.getEstadisticasTipoUnidad().getDa�oRecibido()+ub.life);
break;
}
}
else
System.out.println("JODIDO");
}
}
}
private void actualizarUnidades(List unitStats){
Iterator it = unitStats.iterator();
UnitStats stat=null;
while(it.hasNext())//recorro y actualizo las unidades
{
stat = (UnitStats) it.next();
Iterator it2 = unidades.iterator();
while(it2.hasNext())
{
UnidadBasica unidad= (UnidadBasica) it2.next();
if (unidad.getId()==stat.getUnitId()){// lo que haya que actualizar
unidad.actualizarStat(stat, this);
unidad.setUltimoTurnoActualizado(jugador.turno);
break;
}
}
}
}
public void actualizarFortaleza(List unitStats){
//me cago habria que hacerlo una vez esto y no aca
//if(position!=null)
//System.out.println("peligrosidad casa"+Estadisticas.mapaEstadistico[position.getX()-1][position.getY()-1].getPeligrosidad());
Iterator it = unitStats.iterator();
UnitStats stat=null;
while(it.hasNext())
{
stat = (UnitStats) it.next();
if (this.getId()==0 && stat.getUnitId()<1000){
this.setId(1);
this.idUnidad=3;
}
else
{
if (this.getId()==0 && stat.getUnitId()>=1000){
this.setId(1000);
this.idUnidad=1002;
}
}
if (stat.getUnitId()==this.getId()){
this.actualizarStat(stat, this);
break;
}
}
//System.out.println("Minas "+this.getKnownResources().size());
}
public void actualizarStat(UnitStats stat, Fortaleza fortaleza){
this.addResources(stat.getResources());
this.setLife(stat.getLife());
if (vidaInicial==0){
vidaInicial=this.getLife();
}
this.setPosition(stat.getPosition());
this.mapa[stat.getPosition().getX()][stat.getPosition().getY()]=this;
this.setPayload(stat.getPayload());//agregado
int error = stat.getErrorCode();
if (error==0 && unidadACrear!=null) {//agrega la unidad nueva a nuestra lista de unidades
switch(unidadACrear.getTipoInternoUnidad()){
case UnidadBasica.TIPO_ASESINO:
Asesino asesino = (Asesino)unidadACrear;
asesino.getEstadisticasTipoUnidad().setUnidadesFabricadas(asesino.getEstadisticasTipoUnidad().getUnidadesFabricadas()+1);
break;
case UnidadBasica.TIPO_COLECTORINICIAL:
ColectorInicial ci= (ColectorInicial)unidadACrear;
ci.getEstadisticasTipoUnidad().setUnidadesFabricadas(ci.getEstadisticasTipoUnidad().getUnidadesFabricadas()+1);
break;
case UnidadBasica.TIPO_COLECTORNORMAL:
ColectorNormal cn= (ColectorNormal)unidadACrear;
cn.getEstadisticasTipoUnidad().setUnidadesFabricadas(cn.getEstadisticasTipoUnidad().getUnidadesFabricadas()+1);
break;
case UnidadBasica.TIPO_EXPLORADOR:
Explorador exp= (Explorador)unidadACrear;
exp.getEstadisticasTipoUnidad().setUnidadesFabricadas(exp.getEstadisticasTipoUnidad().getUnidadesFabricadas()+1);
break;
case UnidadBasica.TIPO_GUARDIA:
Guardia gu= (Guardia)unidadACrear;
gu.getEstadisticasTipoUnidad().setUnidadesFabricadas(gu.getEstadisticasTipoUnidad().getUnidadesFabricadas()+1);
break;
//uffff
}
unidades.add(unidadACrear);
this.setIdUnidad(this.getTroopId()+1);
//unidadACrear.getClass().etEstadisticasTipoUnidad().setUnidadesFabricadas(unidadACrear.getEstadisticasTipoUnidad().getUnidadesFabricadas()+1);
unidadACrear=null;
}
}
public void actualizarMapa(List stats) {
limpiarAliados();
Iterator it=stats.iterator();
while (it.hasNext()){
UnitStats stat=(UnitStats)it.next();
if (stat.getHomeId()==stat.getUnitId()){
actualizarMapa(stat,this);
}
else{
Iterator it2=unidades.iterator();
while (it2.hasNext()){
UnidadBasica unidad=(UnidadBasica)it2.next();
if (stat.getUnitId()==unidad.getId()){
actualizarMapa(stat,unidad);
break;
}
}
}
}
limpiarEnemigos();
}
private void limpiarAliados() {
for (int i=0;i<anchoMapa;i++){
for (int j=0 ;j<altoMapa;j++){
if (mapa[i][j]!=null && mapa[i][j].getType()==Vision.TYPE_ALLY){
mapa[i][j]=null;
}
}
}
}
private void actualizarMapa(UnitStats stat,UnidadBasica unidad){
if (unidad.getPosition()==null)
return;
int centroX=unidad.getPosition().getX();
int centroY=unidad.getPosition().getY();
int rango=unidad.getVision();
int limiteIzquierdo=(centroX-rango)>=0 ? centroX-rango : 0;
int limiteDerecho=(centroX+rango)<anchoMapa ? centroX+rango : anchoMapa+1;
int limiteSuperior=(centroY-rango)>=0 ? centroY-rango : 0;
int limiteInferior=(centroY+rango)<altoMapa ? centroY+rango : altoMapa+1;
//primero marco todo en el rango de vision como descubierto
for (int i = limiteIzquierdo; i<=limiteDerecho;i++ ){
for (int j=limiteSuperior;j<=limiteInferior;j++){
if (unidad.getPosition().distance(new Point(i,j))<=rango){
{
if(!isPointAfuera(new Point(i,j)))
{
if (!Estadisticas.mapaEstadistico[i][j].isDescubierto())
unidad.addPosicionesDescubiertas(1);
Estadisticas.mapaEstadistico[i][j].marcarComoDescubierto(Cliente.turno);
}
}
}
}
}
//agrego los resources vistos
Iterator it = stat.getResources().iterator();
while (it.hasNext()){
Vision vision = (Vision) it.next();
//hay que convertir el tipo porque son distintos para el vision, para el elementMap
//primero chequear si ya estaba descubierto
MapElement elementoMapa=null;
switch (vision.getType()){
case (Vision.TYPE_ALLY):
/*if (vision.getPosition().equals(this.position)){
elementoMapa=this;
break;
}
Iterator it2=unidades.iterator();
while (it2.hasNext()){
UnidadBasica aliado=(UnidadBasica)it2.next();
if (aliado.getPosition()!=null && vision.getPosition().equals(aliado.getPosition())){
elementoMapa=aliado;
break;
}
}*/
break;
case (Vision.TYPE_RESOURCE):
Iterator it3=this.getKnownResources().iterator();
while (it3.hasNext()){
Mina mina=(Mina)it3.next();
if (vision.getPosition().equals(mina.getPosition())){
elementoMapa=mina;
break;
}
}
break;
default: //enemigo!
if (vision.getType()==Vision.TYPE_ENEMY_FORTRESS && fortalezaEnemiga==null){
fortalezaEnemiga=new FortalezaEnemiga(vidaInicial,jugador.turno);
fortalezaEnemiga.setPosition(vision.getPosition());
}
MapElement meCandidato= mapa[vision.getPosition().getX()][vision.getPosition().getY()];
if(meCandidato!= null && meCandidato.getClass().getName().equals("src.Enemigo"))
{
((Enemigo)meCandidato).setUltimoTurnoVisto(jugador.turno);//en el mismo lugar, asumo que es el mismo enemigo y actualizo
elementoMapa = meCandidato;
Iterator it4=enemigos.iterator();
boolean estabaEnLista=false;
while (it4.hasNext()){
Enemigo enemigoIt=(Enemigo)it4.next();
if (enemigoIt.getPosition()!=null && enemigoIt.getPosition().equals(meCandidato.getPosition())){
estabaEnLista=true;
break;
}
}
if (!estabaEnLista){
Enemigo enemigo=new Enemigo(vision.getType(), jugador.turno);
enemigo.setPosition(vision.getPosition());
elementoMapa=enemigo;
enemigos.add(enemigo);
}
}//parche para que vuelva a asignar al mismo (y no tire error)
else //no exista, agregarlo
{
Enemigo enemigo=new Enemigo(vision.getType(), jugador.turno);
enemigo.setPosition(vision.getPosition());
elementoMapa=enemigo;
enemigos.add(enemigo);
}
}
if (elementoMapa==null){
if (vision.getType()!=Vision.TYPE_ALLY)
System.out.println("Error en actualizar mapa");
}
else
mapa[vision.getPosition().getX()][vision.getPosition().getY()]=elementoMapa;
}
}
/**
* revisa la lista de enemigos, saca todos los que no son vistos en el turno actual
*
*/
public void limpiarEnemigos(){
Iterator it = enemigos.iterator();
while(it.hasNext())
{
Enemigo e = (Enemigo)it.next();
if (e.getUltimoTurnoVisto() != jugador.turno)
{//vuela
/*if( mapa[e.getPosition().getX()][e.getPosition().getY()] != null && mapa[e.getPosition().getX()][e.getPosition().getY()].getClass().getName().equals("src.Enemigo"))
mapa[e.getPosition().getX()][e.getPosition().getY()]=null;*/
it.remove();
}
}
}
public void darOrdenes(){
//evaluo el entorno y da ordenes;
/*Iterator it= this.getKnownResources().iterator();
int cantidadMinasActivas=0;
while (it.hasNext()){
Mina mina =(Mina)it.next();
if (mina.resourcesStored()<this.resourcesPayload || this.resourcesPayload==0){
cantidadMinasActivas++;
}
}
int cantidadPuntosNoDescubiertos=0;
for (int i = 0; i<=anchoMapa;i++ ){
for (int j=0;j<=altoMapa;j++){
if (!this.estadisticas.mapaEstadistico[i][j].isDescubierto())
cantidadPuntosNoDescubiertos++;
}
}
it= unidades.iterator();
while (it.hasNext()){
UnidadBasica unidad = (UnidadBasica) it.next();
if (unidad.getType()==MapElement.TYPE_COLLECTOR && ((Colector)unidad).getMaxLoad()!=0){
if (cantidadMinasActivas>0)
((Colector)unidad).setEstrategia(new EstrategiaColectorNormal());
else
if (cantidadPuntosNoDescubiertos>0)
((Colector)unidad).setEstrategia(new EstrategiaExploracionEspiral());
}
if (unidad.getType()==MapElement.TYPE_COLLECTOR && ((Colector)unidad).getMaxLoad()==0 && fortalezaEnemiga!=null && !((Colector)unidad).getEstrategia().getClass().getName().equals("src.estrategias.EstrategiaExploradorAcecharColector")){
if (cantidadPuntosNoDescubiertos>0)
((Colector)unidad).setEstrategia(new EstrategiaExploradorAcecharColector());
else
((Colector)unidad).setEstrategia(new EstrategiaExploradorAcecharColector());
}
}*/
getEstrategia().actualizarEstrategias(unidades, estadisticas);
Iterator it = unidades.iterator();
while(it.hasNext())
{
//olvidalo if(it.getClass().getName().equals("Guardia"))
UnidadBasica ub= (UnidadBasica)it.next();
ClientCommand nuevoComando =ub.actuar();
if (nuevoComando != null){
if (nuevoComando.getDestination()==null)
System.out.println("Error jodido");
comandos.add(nuevoComando);
}
/*comentado el choclo para poder probar guardias */
/*UnidadBasica unidad= (UnidadBasica) it.next();
ClientCommand nuevoComando = new ClientCommand();
if (unidad.getType()==BasicPJ.TYPE_ATTACKER){
if (unidad.getCommand()==null){
nuevoComando.setId(idComando+1);
nuevoComando.setIdUnit(unidad.getId());
nuevoComando.setType("move");
//genero lista de puntos no descubiertos, prioriza el lado enemigo si no conozco la fortaleza.
NodoMapaEstadisticas[][] mapaDescubierto = estadisticas.mapaEstadistico;
List nodosNoDescubiertos=new ArrayList();
int limiteIzquierdo=this.getId()==1 ? anchoMapa/2 : 0;
int limiteDerecho=this.getId()==1 ? anchoMapa : anchoMapa/2;
int limiteSuperior=0;
int limiteInferior=altoMapa;
for (int i = limiteIzquierdo; i<=limiteDerecho;i++ ){
for (int j=limiteSuperior;j<=limiteInferior;j++){
if (!mapaDescubierto[i][j].isDescubierto())
nodosNoDescubiertos.add(new Point(i,j));
}
}
Point destino=this.getPosition();
if (nodosNoDescubiertos.size()>0){
int rnd;
rnd = (int)(Math.random()*(nodosNoDescubiertos.size()-1));
destino=(Point) nodosNoDescubiertos.get(rnd);
System.out.println("Puntos no descubiertos : "+nodosNoDescubiertos.size());
}
nuevoComando.setDestination(destino);
nuevoComando.setUnitType(unidad.getType());
comandos.add(nuevoComando);
unidad.setCommand(nuevoComando);
}
}
else{
if (unidad.getCommand()==null){
nuevoComando.setId(idComando+1);
nuevoComando.setIdUnit(unidad.getId());
if (unidad.resourcesStored()<unidad.getMaxLoad()){//recolecto
//calculo mina
Set recursos=this.getKnownResources();
Iterator it2= recursos.iterator();
int distancia=99999;
Mina minaCercana=new Mina();
while (it2.hasNext()){
Mina recurso=(Mina)it2.next();
if (recurso.getPosition().distance(unidad.getPosition())<distancia
&& (recurso.resourcesStored()<this.resourcesPayload || this.resourcesPayload==0)){//chequear capacidad de mina
minaCercana.setPosition(recurso.getPosition());
distancia=minaCercana.getPosition().distance(unidad.getPosition());
}
}
if (minaCercana.getPosition()!=null){
if (unidad.getPosition().distance(minaCercana.getPosition())<=2){
nuevoComando.setType("collect");
nuevoComando.setDestination(minaCercana.getPosition());
}
else//voy a la mina mas cercana, similiar al de la fortaleza, refactorizar
{
if (unidad.getWayPoints()==null || unidad.getWayPoints().size()==0){
unidad.setWayPoints(this.intentoDePathFinding(minaCercana.getPosition(), unidad, this, false,true));
unidad.destino=minaCercana.getPosition();
}
nuevoComando.setType("move");
nuevoComando.setDestination((Point)unidad.getWayPoints().get(0));
}
nuevoComando.setUnitType(unidad.getType());
comandos.add(nuevoComando);
unidad.setCommand(nuevoComando);
}
}
if (unidad.resourcesStored()!=0){
if (unidad.getPosition().distance(this.getPosition())<=2){ // deposito en la fortaleza
nuevoComando.setType("collect");
nuevoComando.setDestination(this.getPosition());
}
else// voy a la fortaleza
{
if (unidad.getWayPoints()==null || unidad.getWayPoints().size()==0){
unidad.setWayPoints(this.intentoDePathFinding(this.getPosition(), unidad, this, false,true));
unidad.destino=this.getPosition();
}
nuevoComando.setType("move");
nuevoComando.setDestination((Point)unidad.getWayPoints().get(0));
}
nuevoComando.setUnitType(unidad.getType());
comandos.add(nuevoComando);
unidad.setCommand(nuevoComando);
}
}
}*/
}
}
public void setIdUnidad(int idUnidad) {
this.idUnidad = idUnidad;
}
/**
* devuelve un punto cualquiera adentro del radio de seguridad, que no sea fortaleza ni est ocupado ni caiga afuera
*/
public Point puntoRandomEnRadioSeguridad(){
int xOffset = (int)Math.round(Math.random() * radioSeguridad);
int yOffset = (int)Math.round(Math.random() * radioSeguridad);
if((!isPointAfuera(new Point(this.position.getX() + xOffset,this.position.getY()+ yOffset))&&(this.mapa[position.getX() + xOffset][position.getY()+ yOffset]==null)))
return new Point(this.position.getX() + xOffset, position.getY()+ yOffset);
else if ((!isPointAfuera(new Point(this.position.getX() - xOffset,this.position.getY()+ yOffset))&&(this.mapa[position.getX() - xOffset][position.getY()+ yOffset]==null)))
return new Point(this.position.getX() - xOffset, position.getY()+ yOffset);
else if ((!isPointAfuera(new Point(this.position.getX() + xOffset,this.position.getY()-yOffset))&&(this.mapa[position.getX() + xOffset][position.getY()- yOffset]==null)))
return new Point(this.position.getX() + xOffset, position.getY()- yOffset);
else if ((!isPointAfuera(new Point(this.position.getX() - xOffset,this.position.getY()-yOffset))&&(this.mapa[position.getX() - xOffset][position.getY()- yOffset]==null)))
return new Point(this.position.getX() - xOffset, position.getY()- yOffset);
else return puntoRandomEnRadioSeguridad();//y si, si no sabes que hacer... llamala de nuevo
}
/**
* esta un punto afuera del mapa?
* @param p
* @return true si est afuera
*/
public static boolean isPointAfuera(Point p){
if (p.getX() <0 || p.getX() >= anchoMapa || p.getY()<0||p.getY() >= altoMapa)
return true;
else return false;
}
/**
* @return the idComando
*/
public int getIdComando() {
return idComando;
}
/**
* @param idComando the idComando to set
*/
public void setIdComando(int idComando) {
this.idComando = idComando;
}
/**
* devuelve lo que est parado en cierta posicion del mapa
* @param p: punto, coordenadas
* @return un MapElement o null
*
*/
public static MapElement getElementoMapaEnPosicion(Point p)
{return mapa[p.getX()][p.getY()];}
/**
* Agrega un nuevo comando a la lista
* @param c
*/
public void addNewCommand(Command c){
comandos.add(c);
}
/**
* @return the estrategia
*/
public EstrategiaGeneral getEstrategia() {
return estrategia;
}
/**
* @param estrategia the estrategia to set
*/
public void setEstrategia(EstrategiaGeneral estrategia) {
this.estrategia = estrategia;
}
/**
* no est pensado para ser usado por fortaleza, solo por unidades
*/
public ClientCommand actuar(){
return null;
}
/**
* funeral de unidad caida : (
* @param ubAliadoCaido: muerto
*/
/*public void retirarMuerto(UnidadBasica ubAliadoCaido){
mapa[ubAliadoCaido.getPosition().getX()][ubAliadoCaido.getPosition().getY()]=null;
unidades.remove(ubAliadoCaido);
}*/
/*
public List intentoDePathFinding(Point destino,UnidadBasica unidad, Fortaleza fortaleza,boolean peligrosidad,boolean aRangoDeAccion){
int pesoPeligro=peligrosidad ? 1 : 0 ;
//primero derecho despues diagonal
if (unidad.getActionRange()==0)
aRangoDeAccion=false;
boolean encontrado=false;
List camino=new ArrayList();
List puntosInvalidos= new ArrayList();
puntosInvalidos.addAll(fortaleza.getKnownResources());
puntosInvalidos.addAll(fortaleza.unidades);
puntosInvalidos.addAll(enemigos);
puntosInvalidos.add(fortaleza);
List open=new ArrayList();
List closed=new ArrayList();
while (!encontrado){
Point ultimoPunto = (Point) camino.get(camino.size()-1);
//calculo punto dentro del rango y menor distancia al destino
int centroX=ultimoPunto.getX();
int centroY=ultimoPunto.getY();
int rango=unidad.getMovementSpeed();
int limiteIzquierdo=(centroX-rango)>=0 ? centroX-rango : 0;
int limiteDerecho=(centroX+rango)<anchoMapa ? centroX+rango : anchoMapa;
int limiteSuperior=(centroY-rango)>=0 ? centroY-rango : 0;
int limiteInferior=(centroY+rango)<altoMapa ? centroY+rango : altoMapa;
//primero marco todo en el rango de vision como descubierto
Point salto=null;//puede dar problemas
boolean puntoInvalido=false;
for (int i = limiteIzquierdo; i<=limiteDerecho;i++ ){
for (int j=limiteSuperior;j<=limiteInferior;j++){
Point posibleSalto=new Point(i,j);
if (ultimoPunto.distance(posibleSalto)<=rango && (salto==null || (posibleSalto.distance(destino)<salto.distance(destino) || (posibleSalto.distance(destino)==salto.distance(destino) && (distanciaManhattan(posibleSalto,destino)<distanciaManhattan(salto,destino) || posibleSalto.distance(ultimoPunto)<salto.distance(ultimoPunto)))) )){
// (posibleSalto.distance(destino)<salto.distance(destino)) ){
List puntosIntermedios=new ArrayList();
int desplazamientoX=posibleSalto.getX()-ultimoPunto.getX();
int desplazamientoY=posibleSalto.getY()-ultimoPunto.getY();
int cantidadDiagonalesExactas=Math.min(Math.abs(desplazamientoX), Math.abs(desplazamientoY));
int diagonalX=desplazamientoX>0 ? 1: -1;
int diagonalY=desplazamientoY>0 ? 1: -1;
desplazamientoX=Math.abs(desplazamientoX-cantidadDiagonalesExactas*diagonalX);
desplazamientoY=Math.abs(desplazamientoY-cantidadDiagonalesExactas*diagonalY);
while (desplazamientoX>0){//es uno u el otro
puntosIntermedios.add(new Point(ultimoPunto.getX()+desplazamientoX*diagonalX,ultimoPunto.getY()));
desplazamientoX--;
}
while (desplazamientoY>0){//es uno u el otro
puntosIntermedios.add(new Point(ultimoPunto.getX(),ultimoPunto.getY()+desplazamientoY*diagonalY));
desplazamientoY--;
}
while (cantidadDiagonalesExactas>0){
cantidadDiagonalesExactas--;
puntosIntermedios.add(new Point(posibleSalto.getX()-diagonalX*cantidadDiagonalesExactas,posibleSalto.getY()-diagonalY*cantidadDiagonalesExactas));
}
//chequear camino a ese punto libre
Iterator it=puntosInvalidos.iterator();
while (it.hasNext()){
MapElement invalido=(MapElement)it.next();
Iterator it2=puntosIntermedios.iterator();
while (it2.hasNext()){
Point wayPoint=(Point)it2.next();
if (aRangoDeAccion){
if (( invalido.getPosition().equals(wayPoint) || fortaleza.getPosition().equals(wayPoint) || destino.equals(wayPoint) )){
puntoInvalido=true;
break;
}
}
else
{
if (!invalido.equals(destino) && ( invalido.equals(wayPoint) || fortaleza.getPosition().equals(wayPoint) )){
puntoInvalido=true;
break;
}
}
}
if (puntoInvalido)
break;
}
if(!puntoInvalido)
salto=posibleSalto;
puntoInvalido=false;
}
}
}
if (salto.equals(ultimoPunto)){//tenemos que retroceder, retrocedo y marco este punto como invalido
Mina obstaculo=new Mina();
obstaculo.setPosition(ultimoPunto);
puntosInvalidos.add(obstaculo);
camino.remove(camino.size()-1);
if (camino.size()>0)
ultimoPunto=(Point)camino.get(camino.size()-1);
else{
System.out.println("En el horno, algo fallo");
return null;
}
}
else{
camino.add(salto);
Mina obstaculo=new Mina();
obstaculo.setPosition(ultimoPunto);
puntosInvalidos.add(obstaculo);
if (aRangoDeAccion){
if (salto.distance(destino)<=unidad.getActionRange())
encontrado=true;
}
else{
if (salto.equals(destino))
encontrado=true;
}
}
}
camino.remove(0);
return camino;
}*/
/**
* resetear todo, mapas, unidades... agh, trabajo
*
*/
public void reinicializar(){
comandos.clear();
enemigos.clear();
this.mapa=null;
this.radioSeguridad=radioSeguridadInicial;
unidadACrear=null;
unidades.clear();
resources.clear();
this.setIdUnidad(this.getId()+2);
this.setIdComando(0);
fortalezaEnemiga=null;
Estadisticas.mapaEstadistico=null;
Estadisticas.partidasJugadas++;
EstrategiaExploradorAcecharColector.perimetro=6;
EstrategiaFormacionAtaque.objetivo=null;
EstrategiaFormacionAtaque.radio=0;
EstrategiaFormacionAtaque.avanzarFormacionX=0;
EstrategiaFormacionAtaque.avanzarFormacionY=0;
EstrategiaFormacionAtaque.moverse=false;
if (getLife()<25)
Estadisticas.vecesFortalezaDestruida++;
if(Estadisticas.vecesFortalezaDestruida>0)
estrategia=new EstrategiaDefensaFortaleza(unidades);//chau, si rompieron la fortaleza 1 vez, sale defensivo para siempre*/
else
estrategia=new EstrategiaEquilibrada(unidades);
}
/**
* @return the resourcesPayload
*/
public int getPayLoad() {
return payLoad;
}
/**
* @param resourcesPayload the resourcesPayload to set
*/
public void setPayload(int payLoad) {
if(this.payLoad < payLoad)//ojo, solo contabilizo aumentos
Estadisticas.registrarAumentoRecursos(payLoad - this.payLoad);
this.payLoad = payLoad;
}
public int getTipoInternoUnidad(){
return -1;
}
/**
* no me interesa esta estad�stica para la fortaleza. void.
*/
public void addPosicionesDescubiertas(int iCantidad){
//0
}
/**
* idem
*/
public void addMuerteDeEsteTipoDeUnidad(){
//0
}
/**
* devuelve el radio a lo largo del cual hay vigilancia alrededor de la fortaleza nuestra
* @return
*/
public int getRadioSeguridad(){
Iterator it = unidades.iterator();
int iTotalDefensores = 0;
while(it.hasNext())
{
Object ub = it.next();
if (ub.getClass().getName().equals("src.Guardia"))
iTotalDefensores++;
}
return iTotalDefensores*2;
}
/**
* @override
* no aplica para fortaleza
*/
public void setEstrategiaUnidad(EstrategiaUnidad eu){
//nada
}
/**no aplica para fortaleza
* @return the estadisticasTipoUnidad
*/
static public EstadisticasTipoUnidad getEstadisticasTipoUnidad() {
return null;
}
/**menos
* @param estadisticasTipoUnidad the estadisticasTipoUnidad to set
*/
static public void setEstadisticasTipoUnidad(){};
/**
* versor !!!
* @param p
* @param
* @return devuelve un vector unitario con floats. indica direccion entre los dos puntos, yendo del primero al segundo
*/
static public double[] versorDe(Point p1, Point p2){
float distX = p2.getX() - p1.getY();
float distY = p2.getY() - p1.getY();
double[] faVersor = new double[2];
faVersor[0] = distX/Math.sqrt(Math.pow(distX, 2)+Math.pow(distY, 2));
faVersor[1] = distY/Math.sqrt(Math.pow(distX, 2)+Math.pow(distY, 2));
return faVersor;
}
/**
* devuelve todos los enemigos vistos en el turno actual en array
*/
public List <Enemigo> enemigosAtacantesDelTurno(){
Iterator it = enemigos.iterator();
List enemigosTurno = new ArrayList();
while(it.hasNext()){
Enemigo en= (Enemigo)it.next();
if(en.getUltimoTurnoVisto()==(jugador.turno) && en.getType()==Vision.TYPE_ENEMY_ATTACKER)
enemigosTurno.add(en);
}
return enemigosTurno;
}
}