import java.io.*; //Todas las librerías de entrada/salida
import java.util.ArrayList;
import java.util.List;/**/
//import java.util.List<Jugador>;
// <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
import java.util.Observable;
import java.util.Random;
import java.util.logging.Level;
import java.util.logging.Logger;
// </editor-fold> 
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.OneToMany;
import javax.persistence.Transient;
@Entity
public class Juego extends Observable implements Serializable{
    final int NUM_TERRITORIOS=52;

    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,id=DCE.18D17727-657F-8175-533C-5B36502E382B]
    // </editor-fold> 
    private int numJugadores;

    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,id=DCE.1EC257D1-C35F-90E3-15E3-5038A4D1C07C]
    // </editor-fold> 
    private int num_turno;//¿?¿?

    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,id=DCE.39B92F3D-5825-2A87-53BD-12ED430746A6]
    // </editor-fold> 
    @Column(name="Partida")
    private String nombrePartida;
    
    private boolean [] ubicados=new boolean[NUM_TERRITORIOS];
    boolean territorios_completados=false;
    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,id=DCE.FEA1781F-3013-5F1A-CB0F-CCE79BC3E01D]
    // </editor-fold> 
    @Transient
    private ArrayList<Carta> Cartas=new ArrayList();

    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,id=DCE.F764ADBF-14B4-F75B-3251-94A065CCDCC6]
    // </editor-fold> 
    @OneToMany
    private List<Jugador> jugadores;//nuevo
    @Transient
    private ArrayList<Territorio> Territorios=new ArrayList();//nuevo
    @Transient
    private Tablero tablero;
    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,id=DCE.FA5A5FF5-40E8-14B4-7B7C-78C5252D5227]
    // </editor-fold> 
    @Transient
     private Dado d1;//nuevo
    @Transient
     private Dado d2;//nuevo
    @Transient
     private Dado d3;
    @Transient
     private Dado d4;
    @Transient
     private Dado d5;//nuevo
    
     private int numrondas;//nuevo
    
     private int tiradas;//nuevo
     private int primeravez;//nuevo
     @Transient
     private Carta mCarta;//nuevo
     //private Jugador jugador;//
     private int turno=0;//nuevo
     private int numCartas;//nuevo
     private int n=0;//numero de jugadores introducidos en la tabla de jugadores
     //private String nomdefensor;
     //private int comprobarvecino;
     //private String nombredestino;
     //private int numejer;
 //***********************************************************
 //***********************************************************
//***********************************************************
//***********************************************************
    @Id
    @GeneratedValue(strategy=GenerationType.AUTO)
    @Column(name="JuegoID")
    private Long id;
    @Transient
    private int ncartasrandom=52;
    @Transient
    private ArrayList<Carta> Cartas2=new ArrayList();
    @Transient
    private int numJugadoresActivos;

    public Juego() {
    }
    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,id=DCE.2C223D41-2ABF-A4BE-E470-1099200FD26E]
    // </editor-fold> 
    public Juego (List<Jugador> listajug) throws FileNotFoundException, IOException {
        //quizas falta el nombre de la partida a inicializar
        crearMapa();
        crearcartas();
        crearcartas2();
        tablero=new Tablero(Territorios);
        jugadores=listajug;
        primeravez=0; 
        numJugadores = 0;
        d1=new Dado();
        d2=new Dado();
        for(int i=0;i<NUM_TERRITORIOS;i++) ubicados[i]=false;
        
        //Territorio t=new Territorio();
    }
    
    @Override
    public String toString() {
        
        String jugador=jugadores.get(0).getNombre();
        for (int i=1;i<jugadores.size();i++){
            
            jugador=(jugador +", ");
            jugador=jugador.concat(jugadores.get(i).getNombre());
        }
        return "Nombre: " + nombrePartida + "; Jugadores: "+jugador;
    }
 //***********************************************************
    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,regenBody=yes,id=DCE.F35B06A8-BF8D-F453-7EB5-0E639478FAE1]
    // </editor-fold> 
    public String getNombrePartida () {
        return nombrePartida;
    }
 //***********************************************************
    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,regenBody=yes,id=DCE.BEBBBC53-4B7D-ECEC-93D7-55F4DA9BFE34]
    // </editor-fold> 
    public void setNombrePartida (String val) {
        this.nombrePartida = val;
    }
 //***********************************************************
    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,regenBody=yes,id=DCE.1B39CD7A-85A1-1E45-150E-1E987DE9432D]
    // </editor-fold> 
    public int getNumJugadores () {
        return numJugadores;
    }
 //***********************************************************
    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,regenBody=yes,id=DCE.970E4B46-7446-6D34-F5AE-59E6057C9E97]
    // </editor-fold> 
    public void setNumJugadores (int val) {
        this.numJugadores = val;
        
    }
 //***********************************************************
    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,regenBody=yes,id=DCE.54811DAC-E8B7-0529-FD7D-88139FDF5D45]
    // </editor-fold> 
    public int getNum_turno () {
        return num_turno;
    }
 //***********************************************************
    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,regenBody=yes,id=DCE.BD98E319-1EC9-6A46-16B6-946CD4A5A0FD]
    // </editor-fold> 
    public void setNum_turno (int val) {
        this.num_turno = val;
    }
    //***********************************************************
  public int numdado1()
  {    //nuevo
        return d1.getValorCara();
    }
   //*********************************************************** 
    public int numdado2()
    { //nuevo
        return d2.getValorCara();
    }
 //***********************************************************
    public Boolean iguales()
    {//devulve si son iguales, seguramente servira rubio
                            //a la hora de atacar o defender
        return (d1.getValorCara()==d2.getValorCara());
    }
     //***********************************************************
      //***********************************************************
  
   //***********************************************************
  
   //***********************************************************
   //***********************************************************
    public Jugador getjugadores(int valor)
    {
        return jugadores.get(valor);
    }
    public Jugador poseedorterritorio(Territorio t){
        int i=0;
        int ide=-1;
        boolean encontrado=false;
        while(!encontrado && i<numJugadores){
            int j=0;
               

            while(j<jugadores.get(i).getNumTerritorios() && !encontrado){
                if(jugadores.get(i).getTerritorio(j).getIdentificador()==t.getIdentificador()){
                 
                    ide=i;
                

                    encontrado=true;
                }
                else j++;
            }
            
            i++;
            
        }
        
        setChanged();
        notifyObservers();
         return jugadores.get(ide);
        
                
    }
    //***********************************************************
    
    public int getrondas()
    {
        return numrondas;
    }
     //***********************************************************
    public int gettur()
    {
        return turno;
    }
    public void setturno(int val)
    {
        turno=val;
    }
    
    //***********************************************************
   public void getturnoFasePrevia()
   {
        
        if (turno==numJugadores-1)//si es el ultimo
        {
            setturno(0);//jugador activo
            numrondas++;
        }
        else
            {
             setturno(turno+1);   
            }
        //calc_rearmamiento(jugadores.get(gettur()).getNumTerritorios());
                  //para que se le pase al sigueinte jugador
        setChanged();
        notifyObservers();
   }  
    public void getturno()
   {
       int suma_rearm=0;
             
        if (turno==numJugadores-1)//si es el ultimo
        {
            setturno(0);//jugador activo
            numrondas++;
        }
        //else
            
        /*if (turno==jugadores.size()-1)//si es el ultimo
        {
            setturno(0);//jugador activo
            numrondas++;
        }*/
        else
            {
             setturno(turno+1);   
            }
        //calc_rearmamiento(jugadores.get(gettur()).getNumTerritorios());
    //}
        
       //if(jugadores.get(gettur()).getcanj_tropas()==1){
            calc_rearmamiento(jugadores.get(gettur()).getNumTerritorios());
            //canjear_cartas(suma_rearm);//pasamos esta variable que sera suma a las tropas canjeadas
            jugadores.get(gettur()).setcanj_tropas(0);
        //}
        //else{
            //calc_rearmamiento(jugadores.get(gettur()).getNumTerritorios());//paso el numero de territorio del jugador
            //jugadores.get(gettur()).setcanj_tropas(0);
        //}
        //del jugador que posee el turno
      
       setChanged();
       notifyObservers();
   } 

    //***********************************************************
   public void anadirJugador(Jugador j)
   {
       if(n<6)
       {
           //System.out.println("Vamos a añadir el jugador "+ nombreJugador + ".");
           //Jugador j=new Jugador(nombreJugador, color);
           jugadores.add(n,j);
           n++;
       }
       
           
   }
   
   public void crearMapa() throws FileNotFoundException, IOException{
       
        InputStreamReader isr = new InputStreamReader(System.in);
        FileReader flujo=new FileReader("./ficheros/mapa.txt");
        BufferedReader fichero=new BufferedReader(flujo);
        String sCadena=fichero.readLine();
        
        //int i=0;
        while(!sCadena.contentEquals("EOF")){
           String id=fichero.readLine();
           String nombre=fichero.readLine();
           String leeZona=fichero.readLine();
           int zona=Integer.parseInt(leeZona);
           int[] vec={-1,-1,-1,-1,-1,-1,-1,-1,-1,-1};
           String vecinoSiguiente=fichero.readLine();
           int pos=0;
           int i=0;
           while(!vecinoSiguiente.contentEquals("fin")){
               vec[i]=Integer.parseInt(vecinoSiguiente);
               vec[i]--;
               i++;
               vecinoSiguiente=fichero.readLine();
           }
           int ident=Integer.parseInt(id);
           ident--;
           
           Territorio t1=new Territorio(nombre,ident,vec,zona);
           Territorios.add(t1);
           pos++;
           sCadena=fichero.readLine();
                          
        }
        
    }
   
   public void asignarTurnos(){
       boolean iguales=false; //Por si se empatan las tiradas
                    
                    int orden[]=new int[getNumJugadores()];
                    do{
                        for (int i=0;i<numJugadores;i++){
                            d1.tirarDado();
                            orden[i]=d1.getValorCara();
                            
                        }
                        int mayor=orden[0];
                        int primero=0;
                        iguales=false;
                        
                        for (int i=0;i<numJugadores;i++){
                            if (orden[i]>mayor) {
                                mayor = orden[i]; //guardo el numero y la posicion de la tirada mayor
                                primero=i; 
                            }
                        }
                        
                        for (int i=0;i<numJugadores && iguales!=true;i++){
                            if (orden[i]==mayor && i!=primero) iguales=true;// busco a ver si hay alguna tirada empatada
                         }
                        if (iguales!=true) setturno(primero);
                        //else  //Le doy el turno al que le toca.
                    } while(iguales==true);
                    repartoCartas();
                    setChanged();
                    notifyObservers();
       
   }
   
   
   
  //*********************************************************** 
    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,id=DCE.B9E91B01-8D3D-504B-549A-6B3E67885054]
    // </editor-fold> 
    public void cargarPartida (String nombreP) {
    }
 //***********************************************************
    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,id=DCE.2537877A-00AE-88ED-EB40-81143ADBF7F0]
    // </editor-fold> 
    public void guardarPartida (String nombreP) {
    }
 //***********************************************************
    public void muestraTerritoriosJugador(int numJug){//Muestra los territorios del jugador que le pasas
        for(int i=0; i<getjugadores(numJug).getNumTerritorios(); i++){
            String nombreorigen=Territorios.get(getjugadores(numJug).getTerritorio(i).getIdentificador()).getNomTerritorio();
            int no=getjugadores(gettur()).getTerritorio(i).getIdentificador();
            System.out.println(no+" - "+nombreorigen);
              
        }
    }
    
    public void muestraTerritoriosVecinos(int idTerritorio){//muestra los vecinos del territorio cuyo id se pasa
        int nvecinos=Territorios.get(idTerritorio).getNumVecinos();
        for(int i=0;i<nvecinos;i++){
           int idVecino=Territorios.get(idTerritorio).IdentVecino(i);
           Territorio t=Territorios.get(idVecino);
           System.out.println(t.getIdentificador()+" - "+t.getNomTerritorio());
        }
    }
    
    public int[] batalla(int tOrigen,int tDestino, int tropasAtaque, int tropasDestino){
         
        int [] tiradasAtaque=new int[3];
        int [] tiradasDefensa=new int[2];
        int retorno=0;
        boolean victoria=false;
        switch(tropasAtaque){
            case 1: d1.tirarDado();
                    tiradasAtaque[0]=d1.getValorCara();
                    d2.tirarDado();
                    tiradasDefensa[0]=d2.getValorCara();
                    
                    if(tiradasAtaque[0]>tiradasDefensa[0]){
                        int nuevoNumTropas=Territorios.get(tDestino).getNumTropas()-1;
                        Territorios.get(tDestino).setNumTropas(nuevoNumTropas);
                        
                        if (Territorios.get(tDestino).getNumTropas()==0){ 
                            
                            if(!(tieneZonaCompleta(poseedorterritorio(Territorios.get(tDestino)).getIdentificador(), Territorios.get(tDestino).getZona()))){
                                int z=Territorios.get(tDestino).getZona();
                                tablero.getZona(z).setJugadorPoseedor(-1);
                                
                            }
                            //invadir(tOrigen,tDestino);
                            
                            if(tieneZonaCompleta(jugadores.get(gettur()).getIdentificador(), Territorios.get(tDestino).getZona())){
                                int z=Territorios.get(tDestino).getZona();
                                tablero.getZona(z).setJugadorPoseedor(jugadores.get(gettur()).getIdentificador());
                                
                            }
                            retorno=1;
                        }
                       
                    }
                    else {
                        int nuevoNumTropas=Territorios.get(tOrigen).getNumTropas()-1;
                        Territorios.get(tOrigen).setNumTropas(nuevoNumTropas);
                        
                        retorno=2;
                    }
                    break;
            case 2: switch(tropasDestino){
                                   case 2:d1.tirarDado();
                                          d2.tirarDado();
                                          //d3.tirarDado();
                                          tiradasAtaque[0]=d1.getValorCara();
                                          tiradasAtaque[1]=d2.getValorCara();
                                          //tiradasAtaque[2]=d3.getValorCara();
                                          d1.tirarDado();
                                          d2.tirarDado();
                                          tiradasDefensa[0]=d1.getValorCara();
                                          tiradasDefensa[1]=d2.getValorCara();
                                          if(tiradasAtaque[0]<tiradasAtaque[1]){
                                              int aux=tiradasAtaque[0];
                                              tiradasAtaque[0]=tiradasAtaque[1];
                                              tiradasAtaque[1]=aux;
                                          }
                                          if(tiradasDefensa[0]<tiradasDefensa[1]){
                                              int aux=tiradasDefensa[0];
                                              tiradasDefensa[0]=tiradasDefensa[1];
                                              tiradasDefensa[1]=aux;
                                          }
                                          
                                          if(tiradasAtaque[0]>tiradasDefensa[0]){
                                             int nuevoNumTropas=Territorios.get(tDestino).getNumTropas()-1;
                                             Territorios.get(tDestino).setNumTropas(nuevoNumTropas);
                                             
                                             if (Territorios.get(tDestino).getNumTropas()==0){ 
                                                 victoria=true;
                                                //System.out.println("El territorio "+territorios.get(tDestino).getIdentificador()+" - "+territorios.get(tDestino).getNomTerritorio()+" ha sido conquistado por "+getjugadores(gettur()) );
                                               if(!(tieneZonaCompleta(poseedorterritorio(Territorios.get(tDestino)).getIdentificador(), Territorios.get(tDestino).getZona()))){
                                                    int z=Territorios.get(tDestino).getZona();
                                                    tablero.getZona(z).setJugadorPoseedor(-1);
                                
                                               }
                                               //invadir(tOrigen,tDestino);
                                               
                                               if(tieneZonaCompleta(jugadores.get(gettur()).getIdentificador(), Territorios.get(tDestino).getZona())){
                                                  int z=Territorios.get(tDestino).getZona();
                                                  tablero.getZona(z).setJugadorPoseedor(jugadores.get(gettur()).getIdentificador());
                                               }
                                               retorno=1;
                                             }
                                          }
                                          else {
                                               int nuevoNumTropas=Territorios.get(tOrigen).getNumTropas()-1;
                                               Territorios.get(tOrigen).setNumTropas(nuevoNumTropas);
                                          }
                                          if(!victoria){
                                               if (tiradasAtaque[1]>tiradasDefensa[1]){
                                                    int nuevoNumTropas=Territorios.get(tDestino).getNumTropas()-1;
                                                    Territorios.get(tDestino).setNumTropas(nuevoNumTropas);
                                                    //System.out.println("¡¡BABOOM!! El territorio "+Territorios.get(tDestino).getIdentificador()+" - "+Territorios.get(tDestino).getNomTerritorio()+" ha perdido una tropa");
                                                    if (Territorios.get(tDestino).getNumTropas()==0){ 
                                                        //System.out.println("El territorio "+Territorios.get(tDestino).getIdentificador()+" - "+Territorios.get(tDestino).getNomTerritorio()+" ha sido conquistado por "+getjugadores(gettur()).getNombre() );
                                                         if(!(tieneZonaCompleta(poseedorterritorio(Territorios.get(tDestino)).getIdentificador(), Territorios.get(tDestino).getZona()))){
                                                    int z=Territorios.get(tDestino).getZona();
                                                    tablero.getZona(z).setJugadorPoseedor(-1);
                                                    retorno=1;
                                
                                               }
                                               //invadir(tOrigen,tDestino);
                                               
                                               if(tieneZonaCompleta(jugadores.get(gettur()).getIdentificador(), Territorios.get(tDestino).getZona())){
                                                  int z=Territorios.get(tDestino).getZona();
                                                  tablero.getZona(z).setJugadorPoseedor(jugadores.get(gettur()).getIdentificador());
                                                  //System.out.println("El jugador "+tablero.getZona(z).getJugadorPoseedor()+" ahora posee la zona "+ tablero.getZona(z).getNomZona());
                                               }
                                                    }
                                               }
                                               else {
                                                    int nuevoNumTropas=Territorios.get(tOrigen).getNumTropas()-1;
                                                    Territorios.get(tOrigen).setNumTropas(nuevoNumTropas);
                                                    //System.out.println("¡¡CATACROKET!! El territorio "+Territorios.get(tOrigen).getIdentificador()+" - "+Territorios.get(tOrigen).getNomTerritorio()+" ha perdido una tropa");
                                                    retorno=2;
                                               } 
                                           }
                                           else { if(!(tieneZonaCompleta(poseedorterritorio(Territorios.get(tDestino)).getIdentificador(), Territorios.get(tDestino).getZona()))){
                                                    int z=Territorios.get(tDestino).getZona();
                                                    tablero.getZona(z).setJugadorPoseedor(-1);
                                
                                               }
                                               //invadir(tOrigen,tDestino);
                                               
                                               if(tieneZonaCompleta(jugadores.get(gettur()).getIdentificador(), Territorios.get(tDestino).getZona())){
                                                  int z=Territorios.get(tDestino).getZona();
                                                  tablero.getZona(z).setJugadorPoseedor(jugadores.get(gettur()).getIdentificador());
                                                  //System.out.println("El jugador "+tablero.getZona(z).getJugadorPoseedor()+" ahora posee la zona "+ tablero.getZona(z).getNomZona());
                                               }
                                           }
                                           break;
                                   case 1: d1.tirarDado();
                                           d2.tirarDado();
                                           tiradasAtaque[0]=d1.getValorCara();
                                           tiradasAtaque[1]=d2.getValorCara();
                                           d1.tirarDado();
                                           tiradasDefensa[0]=d1.getValorCara();
                                           if(tiradasAtaque[0]<tiradasAtaque[1]){
                                              int aux=tiradasAtaque[0];
                                              tiradasAtaque[0]=tiradasAtaque[1];
                                              tiradasAtaque[1]=aux;
                                           }
                                           
                                           if (tiradasAtaque[0]>tiradasDefensa[0]){
                                              int nuevoNumTropas=Territorios.get(tDestino).getNumTropas()-1;
                                              Territorios.get(tDestino).setNumTropas(nuevoNumTropas);
                                              //System.out.println("¡¡BABOOM!! El territorio "+Territorios.get(tDestino).getIdentificador()+" - "+Territorios.get(tDestino).getNomTerritorio()+" ha perdido una tropa");
                                              if (Territorios.get(tDestino).getNumTropas()==0){ 
                                                 //System.out.println("El territorio "+Territorios.get(tDestino).getIdentificador()+" - "+Territorios.get(tDestino).getNomTerritorio()+" ha sido conquistado por "+getjugadores(gettur()).getNombre() );
                                                  if(!(tieneZonaCompleta(poseedorterritorio(Territorios.get(tDestino)).getIdentificador(), Territorios.get(tDestino).getZona()))){
                                                    int z=Territorios.get(tDestino).getZona();
                                                    tablero.getZona(z).setJugadorPoseedor(-1);
                                                    retorno=1;
                                
                                               }
                                               
                                               if(tieneZonaCompleta(jugadores.get(gettur()).getIdentificador(), Territorios.get(tDestino).getZona())){
                                                  int z=Territorios.get(tDestino).getZona();
                                                  tablero.getZona(z).setJugadorPoseedor(jugadores.get(gettur()).getIdentificador());
                                                  
                                                  //jugadores.get(gettur()).muestraTerritorios();
                                               }
                                              }
                                           }
                                           else {
                                                int nuevoNumTropas=Territorios.get(tOrigen).getNumTropas()-1;
                                                Territorios.get(tOrigen).setNumTropas(nuevoNumTropas);
                                                //System.out.println("¡¡CATACROKET!! El territorio "+Territorios.get(tOrigen).getIdentificador()+" - "+Territorios.get(tOrigen).getNomTerritorio()+" ha perdido una tropa");
                                                retorno=2;
                                           } 
                                           break;
                                           //else invadir(tOrigen,tDestino);
                                          
                    }
                    break;    
            case 3: switch(tropasDestino){
                                   case 2:d1.tirarDado();
                                          //d2.tirarDado();
                                          //d3.tirarDado();
                                          tiradasAtaque[0]=d1.getValorCara();
                                          d1.tirarDado();
                                          tiradasAtaque[1]=d1.getValorCara();
                                          d1.tirarDado();
                                          tiradasAtaque[2]=d1.getValorCara();
                                          d1.tirarDado();
                                          tiradasDefensa[0]=d1.getValorCara();
                                          d1.tirarDado();
                                          tiradasDefensa[1]=d1.getValorCara();
                                          //tiradasDefensa[1]=d5.getValorCara();
                                          for(int i=0;i<tiradasAtaque.length;i++){
                                          for(int k=0;k<tiradasAtaque.length;k++){
                                              if(tiradasAtaque[i]>tiradasAtaque[k]){
                                                  int aux=tiradasAtaque[i];
                                                  tiradasAtaque[i]=tiradasAtaque[k];
                                                  tiradasAtaque[k]=aux;
                                              }
                                          }
                                      }
                                          if(tiradasDefensa[0]<tiradasDefensa[1]){
                                              int aux=tiradasDefensa[0];
                                              tiradasDefensa[0]=tiradasDefensa[1];
                                              tiradasDefensa[1]=aux;
                                          }
                                          
                                          if(tiradasAtaque[0]>tiradasDefensa[0]){
                                             int nuevoNumTropas=Territorios.get(tDestino).getNumTropas()-1;
                                             Territorios.get(tDestino).setNumTropas(nuevoNumTropas);
                                             //System.out.println("¡¡BOOOM!! El territorio "+Territorios.get(tDestino).getIdentificador()+" - "+Territorios.get(tDestino).getNomTerritorio()+" ha perdido una tropa");
                                            
                                             if (Territorios.get(tDestino).getNumTropas()==0){ 
                                                 victoria=true;
                                                //System.out.println("El territorio "+territorios.get(tDestino).getIdentificador()+" - "+territorios.get(tDestino).getNomTerritorio()+" ha sido conquistado por "+getjugadores(gettur()) );
                                                if(!(tieneZonaCompleta(poseedorterritorio(Territorios.get(tDestino)).getIdentificador(), Territorios.get(tDestino).getZona()))){
                                                    int z=Territorios.get(tDestino).getZona();
                                                    tablero.getZona(z).setJugadorPoseedor(-1);
                                
                                               }
                                               //invadir(tOrigen,tDestino);
                                               
                                               if(tieneZonaCompleta(jugadores.get(gettur()).getIdentificador(), Territorios.get(tDestino).getZona())){
                                                  int z=Territorios.get(tDestino).getZona();
                                                  tablero.getZona(z).setJugadorPoseedor(jugadores.get(gettur()).getIdentificador());
                                                  //System.out.println("El jugador "+tablero.getZona(z).getJugadorPoseedor()+" ahora posee la zona "+ tablero.getZona(z).getNomZona());
                                               }
                                             }
                                              retorno=1;
                                          }
                                          else {
                                               int nuevoNumTropas=Territorios.get(tOrigen).getNumTropas()-1;
                                               Territorios.get(tOrigen).setNumTropas(nuevoNumTropas);
                                               //System.out.println("¡¡CRASH!! El territorio "+Territorios.get(tOrigen).getIdentificador()+" - "+Territorios.get(tOrigen).getNomTerritorio()+" ha perdido una tropa");
                                                retorno=2;
                                          }
                                          if(!victoria){
                                               if (tiradasAtaque[1]>tiradasDefensa[1]){
                                                    int nuevoNumTropas=Territorios.get(tDestino).getNumTropas()-1;
                                                    Territorios.get(tDestino).setNumTropas(nuevoNumTropas);
                                                    //System.out.println("¡¡BABOOM!! El territorio "+Territorios.get(tDestino).getIdentificador()+" - "+Territorios.get(tDestino).getNomTerritorio()+" ha perdido una tropa");
                                                    if (Territorios.get(tDestino).getNumTropas()==0){ 
                                                      //  System.out.println("El territorio "+Territorios.get(tDestino).getIdentificador()+" - "+Territorios.get(tDestino).getNomTerritorio()+" ha sido conquistado por "+getjugadores(gettur()).getNombre() );
                                                        //invadir(tOrigen,tDestino);
                                                    }
                                                     retorno=1;
                                               }
                                               else {
                                                    int nuevoNumTropas=Territorios.get(tOrigen).getNumTropas()-1;
                                                    Territorios.get(tOrigen).setNumTropas(nuevoNumTropas);
                                                   //System.out.println("¡¡CATACROKET!! El territorio "+Territorios.get(tOrigen).getIdentificador()+" - "+Territorios.get(tOrigen).getNomTerritorio()+" ha perdido una tropa");
                                                     retorno=2;
                                               } 
                                           }
                                           else { if(!(tieneZonaCompleta(poseedorterritorio(Territorios.get(tDestino)).getIdentificador(), Territorios.get(tDestino).getZona()))){
                                                    int z=Territorios.get(tDestino).getZona();
                                                    tablero.getZona(z).setJugadorPoseedor(-1);
                                
                                               }
                                               //invadir(tOrigen,tDestino);
                                               
                                               if(tieneZonaCompleta(jugadores.get(gettur()).getIdentificador(), Territorios.get(tDestino).getZona())){
                                                  int z=Territorios.get(tDestino).getZona();
                                                  tablero.getZona(z).setJugadorPoseedor(jugadores.get(gettur()).getIdentificador());
                                                  //System.out.println("El jugador "+tablero.getZona(z).getJugadorPoseedor()+" ahora posee la zona "+ tablero.getZona(z).getNomZona());
                                               }
                                              
                                           }
                                           break;
                                   case 1: d1.tirarDado();
                                          //d2.tirarDado();
                                          //d3.tirarDado();
                                          tiradasAtaque[0]=d1.getValorCara();
                                          d1.tirarDado();
                                          tiradasAtaque[1]=d1.getValorCara();
                                          d1.tirarDado();
                                          tiradasAtaque[2]=d1.getValorCara();
                                           d1.tirarDado();
                                           tiradasDefensa[0]=d1.getValorCara();
                                            for(int i=0;i<tiradasAtaque.length;i++){
                                          for(int k=0;k<tiradasAtaque.length;k++){
                                              if(tiradasAtaque[i]>tiradasAtaque[k]){
                                                  int aux=tiradasAtaque[i];
                                                  tiradasAtaque[i]=tiradasAtaque[k];
                                                  tiradasAtaque[k]=aux;
                                              }
                                          }
                                      }
                                               
                                               if (tiradasAtaque[0]>tiradasDefensa[0]){
                                                    int nuevoNumTropas=Territorios.get(tDestino).getNumTropas()-1;
                                                    Territorios.get(tDestino).setNumTropas(nuevoNumTropas);
                                                    //System.out.println("¡¡BABOOM!! El territorio "+Territorios.get(tDestino).getIdentificador()+" - "+Territorios.get(tDestino).getNomTerritorio()+" ha perdido una tropa");
                                                    if (Territorios.get(tDestino).getNumTropas()==0){ 
                                                      //  System.out.println("El territorio "+Territorios.get(tDestino).getIdentificador()+" - "+Territorios.get(tDestino).getNomTerritorio()+" ha sido conquistado por "+getjugadores(gettur()).getNombre() );
                                                         if(!(tieneZonaCompleta(poseedorterritorio(Territorios.get(tDestino)).getIdentificador(), Territorios.get(tDestino).getZona()))){
                                                    int z=Territorios.get(tDestino).getZona();
                                                    tablero.getZona(z).setJugadorPoseedor(-1);
                                
                                               }
                                               //invadir(tOrigen,tDestino);
                                               
                                               if(tieneZonaCompleta(jugadores.get(gettur()).getIdentificador(), Territorios.get(tDestino).getZona())){
                                                  int z=Territorios.get(tDestino).getZona();
                                                  tablero.getZona(z).setJugadorPoseedor(jugadores.get(gettur()).getIdentificador());
                                                 // System.out.println("El jugador "+tablero.getZona(z).getJugadorPoseedor()+" ahora posee la zona "+ tablero.getZona(z).getNomZona());
                                               }
                                                    }
                                                     retorno=1;
                                               }
                                               else {
                                                    int nuevoNumTropas=Territorios.get(tOrigen).getNumTropas()-1;
                                                    Territorios.get(tOrigen).setNumTropas(nuevoNumTropas);
                                                   // System.out.println("¡¡CATACROKET!! El territorio "+Territorios.get(tOrigen).getIdentificador()+" - "+Territorios.get(tOrigen).getNomTerritorio()+" ha perdido una tropa");
                                                     retorno=2;
                                               } 
                                           break;
                                           //else invadir(tOrigen,tDestino);
                                          
                    }
                    break;
        }
       
        int []tiradasDados=new int[5];
        tiradasDados[0]=tiradasAtaque[0];
        tiradasDados[1]=tiradasAtaque[1];
        tiradasDados[2]=tiradasAtaque[2];
        tiradasDados[3]=tiradasDefensa[0];
        tiradasDados[4]=tiradasDefensa[1];
        setChanged();
        notifyObservers();
        return tiradasDados;
      
    }
    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,id=DCE.B2AED7C3-2BAC-ADAD-23D3-7C1845374ADD]
    // </editor-fold> 
    
    
    
 //***********************************************************
    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,id=DCE.0BA91DB7-C764-693A-2FA4-C68885F8B88A]
    // </editor-fold> er
    public void invadir(int tOrigen,int tDestino,int numTropasInvasion){
        InputStreamReader isr =new InputStreamReader(System.in);
        BufferedReader br = new BufferedReader(isr);
        //int numTropasInvasion=0;
        boolean correcto=false;
      
                 
                Jugador jugadorInvasor=poseedorterritorio(Territorios.get(tOrigen));
                Jugador jugadorInvadido=poseedorterritorio(Territorios.get(tDestino));
                jugadorInvadido.quitarTerritorio(Territorios.get(tDestino));
                jugadorInvasor.setTerritorio(Territorios.get(tDestino));
                Territorios.get(tDestino).setNumTropas(numTropasInvasion);
                Territorios.get(tOrigen).setNumTropas(Territorios.get(tOrigen).getNumTropas()-numTropasInvasion);
                //correcto=true;    

            
            
    
        Jugador comprobacion=poseedorterritorio(Territorios.get(tDestino));
       //System.out.println(Territorios.get(tDestino).getNomTerritorio()+ " pertenece ahora a "+comprobacion.getNombre()+" y está ocupado por "+Territorios.get(tDestino).getNumTropas()+" batallones");

    
    }
    
    
    
    public void transferir(int tOrigen,int tDestino, int nTropasTransferencia){
         getTerrtiorio(tOrigen).setNumTropas(getTerrtiorio(tOrigen).getNumTropas()-nTropasTransferencia);
         getTerrtiorio(tDestino).setNumTropas(getTerrtiorio(tDestino).getNumTropas()+nTropasTransferencia);
         setChanged();
         notifyObservers();

    }
    


public void ubicar(int idTerritorioOrigen){
    getTerrtiorio(idTerritorioOrigen).setNumTropas(getTerrtiorio(idTerritorioOrigen).getNumTropas()+1);
    getjugadores(gettur()).setTropasPendUbicar(getjugadores(gettur()).getTropasPendUbicar()-1);
    setChanged();
    notifyObservers();
}
 //***********************************************************
    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,id=DCE.29A7E251-A344-DD27-8740-92EE9A70B7C9]
    // </editor-fold> 
    public void transferir () {
    }
 //***********************************************************
    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,id=DCE.0AA044F4-3F72-02E4-1A8B-6F2292A799D0]
    // </editor-fold> 
   
    
    public void reparteTerritorios(){
        int jug=0;
        for(int i=0;i<52;i++){
            if(jug==numJugadores)jug=0;
            getjugadores(jug).setTerritorio(Territorios.get(i));
            jug++;
        }
        
    }
    
    
    
 //***********************************************************
    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,id=DCE.C78A8043-2E61-47FB-746B-00F850B6B6B3]
    // </editor-fold> 
    
 //***********************************************************
    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,regenBody=yes,id=DCE.351A78D6-29E6-0C53-4ED6-84034E0FA9B2]
    // </editor-fold> 
    public ArrayList<Carta> getCartas () {
        return Cartas;
    }
 //***********************************************************
    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,regenBody=yes,id=DCE.E5C01141-3346-D9B9-D5DE-24D050FF98C6]
    // </editor-fold> 
    public void setCartas (ArrayList<Carta> val) {
        this.Cartas = val;
    }
 //***********************************************************
    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,regenBody=yes,id=DCE.7CC9DC6D-0096-6527-4048-2F77C92EA163]
    // </editor-fold> 
    public Carta getCarta () {
        return mCarta;
    }
 //***********************************************************
    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,regenBody=yes,id=DCE.839EB2CA-C60E-0730-83BE-8C49FC833777]
    // </editor-fold> 
    public void setCarta (Carta val) {
        this.mCarta = val;
    }

      //***********************************************************
  public int numCartas()
    {
        return numCartas;
    }
     //***********************************************************

public int calc_rearmamiento(int nterritorio){
      int resultado=0;
      int ntropaspend=0;
      for(int i=0; i<tablero.getNumZonas(); i++)
      { //*************************************************************************
          if(getjugadores(gettur()).getIdentificador()==tablero.getZona(i).getJugadorPoseedor())
          //***********************************************************************
          {
              
              ntropaspend=ntropaspend+tablero.getZona(i).getBonusEjercitos();//bonus de zona
          }
      }
      if(nterritorio<=9 && nterritorio>0)
         ntropaspend=ntropaspend+3;
      else{
          int cociente=0;
          cociente=nterritorio/3;
          ntropaspend=ntropaspend+cociente;
      }
              
      getjugadores(gettur()).setTropasPendUbicar(ntropaspend);
     return ntropaspend;
  }

  
  
//*********************************************************
public boolean tieneZonaCompleta(int idJugador, int idZona){
            //System.out.println("hemos entrado en el metodo riene zona comleta");

    Zona z=tablero.getZona(idZona);
    Jugador jug=jugadores.get(idJugador);
    int maximo=jug.getNumTerritorios();
    
    boolean correcto=false;
    boolean encontrado=false;
    int contador=0;
    
    
    if(jug.getNumTerritorios()>=z.getNumTerritorios())
    {       
           for(int i=0; i<z.getNumTerritorios();i++)
           {
               int p=z.getTerritorio(i).getIdentificador();
               
               for(int j=0; j<jug.getNumTerritorios();j++)
               {
                 if(jug.getTerritorio(j).getIdentificador()==p)
                 {
                     contador++;
                 }
               }
           }
           if(contador==z.getNumTerritorios()){
               correcto=true;
              //System.out.println("la zona esta completa");
           }
               
           else{
            correcto=false;
           //System.out.println("no tienes las zona comleta");
           }
    }      
    //else
        //System.out.println("no tienes los suficients territorios");
    
    
    return correcto;
     
    }
    


public Territorio getTerrtiorio(int i){
    return Territorios.get(i);
}

public void crearcartas() throws IOException{
        InputStreamReader isr = new InputStreamReader(System.in);
        FileReader flujo = null;
        try {
            flujo = new FileReader("./ficheros/cartas.txt");
        } catch (FileNotFoundException ex) {
            Logger.getLogger(Juego.class.getName()).log(Level.SEVERE, null, ex);
        }
        BufferedReader fichero=new BufferedReader(flujo);
        String sCadena=fichero.readLine();
        while(!sCadena.contentEquals("EOF")){
                int idcarta=Integer.parseInt(sCadena);
                //System.out.println("ID Carta leída: "+ idcarta);
                String nomCarta=fichero.readLine();
                //System.out.println("Nombre de la carta: "+ nomCarta);
                sCadena=fichero.readLine();
                int numTropa=Integer.parseInt(sCadena);
                //System.out.println("Tropa: "+ numTropa);
                Carta c= new Carta(idcarta,nomCarta,numTropa);
                Cartas.add(c);
                sCadena=fichero.readLine();
        }
}

public void repartoCartas(){
    Random rnd=new Random();
    int llena=1;
    int numjug=0;
    int [] cuenta=new int[numJugadores];    
    for (int j=0;j<numJugadores;j++)
        cuenta[j]=0;
    
    for(int i=0;i<Cartas.size();i++){
      for (int k=0;k<numJugadores;k++){//comprobamos si esta llena
          if(cuenta[k]==0)
              llena=0;
      // System.out.println("for 2");
   //    System.out.println(" lleno de for2 :"+llena);
      }
     // System.out.println("size");
      if(llena==1){
         for (int j=0;j<numJugadores;j++){ //reseteamos 
           cuenta[j]=0;
           llena=1;
          // System.out.println("for 3");
         }
      }
      else{ 
       //   System.out.println("else ded los cojoen");
        int idterri=Cartas.get(i).getIdCarta();
        numjug=rnd.nextInt(numJugadores);
        while(cuenta[numjug]!=0){
          numjug=rnd.nextInt(numJugadores);
          getjugadores(numjug).setTerritorio(Territorios.get(idterri));
          cuenta[numjug]=1;
        }
      }
   }
}

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }
  
 public void borrarJugador(Jugador j)
   {
       jugadores.remove(j);
       n--;
       //System.out.println("Jugador borrado"); 
  
   }
//************************************************************
   public List getlistajugadores(){
        return jugadores; 
    }
public int getZonaDelTerritorio(int idTer){
       int indexZona=-1;
       boolean encontrado=false;
       for(int i=0;i<tablero.getNumZonas()&&(!encontrado);i++)
             for(int j=0;j<tablero.getZona(i).getNumTerritorios()&&(!encontrado);j++)
                      if(idTer==tablero.getZona(i).getTerritorio(j).getIdentificador()){
                          indexZona=i;
                          encontrado=true;
                      }
       return indexZona;
   }
   public String getNombreZonaDelTerritorio(int idTer){
       String nombre=" ";
       boolean encontrado=false;
       for(int i=0;i<tablero.getNumZonas()&&(!encontrado);i++)
             for(int j=0;j<tablero.getZona(i).getNumTerritorios()&&(!encontrado);j++)
                      if(idTer==tablero.getZona(i).getTerritorio(j).getIdentificador()){
                          nombre=tablero.getZona(i).getNomZona();
                          encontrado=true;
                      }
       return nombre;
   }
   
    public boolean obtenercarta(){
    boolean obtenido=false;
    int getnc=0;
    Random rndcartas=new Random();
    int numazar=rndcartas.nextInt(ncartasrandom);
    
    while(getCartas2().get(numazar).getdisponible()==1)
        numazar=rndcartas.nextInt(ncartasrandom);
    
    if(getjugadores(gettur()).getNumCartas()<5){
        System.out.println("Numero al azar que ha salido:"+numazar);
        System.out.println("El tamaño de Cartas_jug es: "+(getjugadores(gettur()).getCartas().size()+1));
        getjugadores(gettur()).getCartas().add(getCartas2().get(numazar));
        getjugadores(gettur()).setNumCartas(getjugadores(gettur()).getNumCartas()+1);
        getCartas2().get(numazar).setdisponible(1);
        
        for(int i=0; i<getjugadores(gettur()).getCartas().size(); i++){
            System.out.println("posicion: "+i);
            System.out.println("id carta: "+getjugadores(gettur()).getCartas().get(i).getIdCarta());
            System.out.println("nombre carta: "+getjugadores(gettur()).getCartas().get(i).getNomCarta());
            System.out.println("tipo carta: "+getjugadores(gettur()).getCartas().get(i).getNumTropa());
        }
        obtenido=true;
    }
    
    return obtenido;
        
}


public int contartipo(int tipo){
    int cont=0;
    for(int i=0; i<getjugadores(gettur()).getCartas().size(); i++){
        if(getjugadores(gettur()).getCartas().get(i).getNumTropa()==tipo)
            cont++;
    }
    return cont;
}


public void borrartipo(int tipo){
    boolean borrado=false;
    boolean encontrado=false;
    int idc2=0;
    int j=0;
    int i=0;
    while(i<getjugadores(gettur()).getCartas().size() && borrado==false){
        if(getjugadores(gettur()).getCartas().get(i).getNumTropa()==tipo){
            idc2=getjugadores(gettur()).getCartas().get(i).getIdCarta();
            
            while(j < getCartas2().size() && encontrado==false){
                if(getCartas2().get(j).getIdCarta()==idc2){
                    getCartas2().get(j).setdisponible(0);
                    encontrado=true;
                }
                else
                    j++;
            }
        
            
            getjugadores(gettur()).getCartas().remove(i);
            getjugadores(gettur()).setNumCartas(getjugadores(gettur()).getNumCartas()-1);
            borrado=true;
        }
        else
            i++;
    }
}

public boolean comprobar_canjear_cartas(){
    boolean correcto=false;
    int tipo1=0;
    int tipo2=0;
    int tipo3=0;
    
    tipo1=contartipo(1);
    tipo2=contartipo(2);
    tipo3=contartipo(3);

    
    if(getjugadores(gettur()).getNumCartas()>2 && getjugadores(gettur()).getNumCartas()<6)
        if(tipo1>=1 && tipo2>=1 && tipo3>=1){
                correcto=true;
        }
        else if(tipo3>=3){
                correcto=true;
        }
        else if(tipo2>=3){
            correcto=true;
        }
        else if(tipo1>=3){
            correcto=true;
        }
         
        
return correcto;
}


public void canjear_cartas(int var){    
    int tipo1=0;
    int tipo2=0;
    int tipo3=0;
    
    tipo1=contartipo(1);
    tipo2=contartipo(2);
    tipo3=contartipo(3);

        int tpu=getjugadores(gettur()).getTropasPendUbicar();
        System.out.println("tropas pdu"+tpu);
        if(tipo1>=1 && tipo2>=1 && tipo3>=1){
                getjugadores(gettur()).setTropasPendUbicar(var+10);
                System.out.println("tropas añadidas 10");
                borrartipo(1); borrartipo(2); borrartipo(3);
        }
        else if(tipo3>=3){
                getjugadores(gettur()).setTropasPendUbicar(var+7);
                System.out.println("tropas añadidas 7");
                borrartipo(3); borrartipo(3); borrartipo(3);
        }
        else if(tipo2>=3){
            getjugadores(gettur()).setTropasPendUbicar(var+5);
            System.out.println("tropas añadidas 5");
            borrartipo(2); borrartipo(2); borrartipo(2);
        }
        else{ 
            if(tipo1>=3){
                getjugadores(gettur()).setTropasPendUbicar(var+3);
                System.out.println("tropas añadidas 3");
                borrartipo(1); borrartipo(1); borrartipo(1);
            }
        }
        
}

public ArrayList<Carta> getCartas2 () {
        return Cartas2;
    }


        public void crearcartas2() throws IOException{
        InputStreamReader isr = new InputStreamReader(System.in);
        FileReader flujo = null;
        try {
            flujo = new FileReader("./ficheros/cartas.txt");
        } catch (FileNotFoundException ex) {
            Logger.getLogger(Juego.class.getName()).log(Level.SEVERE, null, ex);
        }
        BufferedReader fichero=new BufferedReader(flujo);
        String sCadena=fichero.readLine();
        while(!sCadena.contentEquals("EOF")){
                int idcarta=Integer.parseInt(sCadena);
                String nomCarta=fichero.readLine();
                sCadena=fichero.readLine();
                int numTropa=Integer.parseInt(sCadena);
                Carta c= new Carta(idcarta,nomCarta,numTropa);
                Cartas2.add(c);
                sCadena=fichero.readLine();
        }
        
        for(int i=0; i<Cartas2.size(); i++)
        {
            Cartas2.get(i).setdisponible(0);
        }
    }

    

    public int getNumJugadoresActivos() {
        return numJugadoresActivos;
    }

    public void setNumJugadoresActivos(int numJugadoresActivos) {
        this.numJugadoresActivos = numJugadoresActivos;
    }
}













