/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package game;

import java.awt.Color;
import java.awt.Graphics;
import java.awt.Rectangle;

/**
 * @author A KUMA
 */
public class Invader {//hilo q controla grid inv
    private int numInvader,numLineInv,LInv=33,HInv=24;
    //LInv&HInv :largo y alto de invader
    int limDer,limIzq,limInf,limSup,columIni=0,columFin=1;//limites de grid y inicio de colums izq
    private int x,y,i,j,xr=LInv+LInv/4,yr=HInv+HInv/3,y0,x0;
    //x,y punto sup-izq de grid inv
    //xr:spaciado entre invaders,yr:spaciado entre linea inv
    boolean invaderL[],invaderC[];
    //almacena existencia d 'n' columna(C) y 'n' line(L)
    boolean camina=true,invCh=true;
    boolean invaderGrid[][];//grid boolean for grid inv
    
    public Invader(int unX, int unY,int UNnumInv,int UNnumLineinv){
        numLineInv=UNnumLineinv;
        numInvader=UNnumInv;
        x=unX;
        y=unY;
        invaderL=new boolean[numLineInv];
        invaderC=new boolean[numInvader];
        invaderGrid=new boolean[numLineInv][numInvader];
        for(i=0;i<numLineInv;i++){//inicializa  lineas inv
            invaderL[i]=true;//inicia con todas lineas activas
        }
        for(i=0;i<numInvader;i++){//inicializa  columnas inv
            invaderC[i]=true;
        }
        for(i=0;i<numLineInv;i++){//inicializa all invs de grid
            for(j=0;j<numInvader;j++){
                invaderGrid[i][j]=true;
            }
        }
        getLim();//obtiene limites de grid
    }
    public Rectangle getRectangleInv(int i,int j){//calcula la posion del inv (i,j)
        int xInv,yInv;
        xInv=xr*j+x;
        yInv=yr*i+y;
        return new Rectangle(xInv,yInv,LInv,HInv);
    }
    public  void getLim(){
        limDer=(x+numInvader*xr)-LInv/3;
        limIzq=x;
        limSup=y;
        limInf=numLineInv*yr+y;
    }
    public boolean EstadoInv(int i,int j){
        return invaderGrid[i][j];
    }
    public int getXInv(int j){
        return x+(j)*xr+LInv/2;
    }
    public int getYInv(int i){
        return y+(i+1)*yr;
    }
    public int getIzq(){return limIzq;}
    public void setLimDer(){}
    public int getSup(){return y;}
    public int getInf(){return limInf;}
    public int getDer(){return limDer;}
    public int getX(){return x;}
    public void setX(int newx){
        x=newx;
    }
    public void setY(int newy){
        y=newy;
    }
    public void setDeadInv(int i,int j){
        invaderGrid[i][j]=false;//mata un inv
        Sound.Acert.play();
        
        lineGrid(i);
        if(!invaderL[numLineInv-1]){
            numLineInv-=1;
            limInf-=yr;
        }//si la ultima line est muerta se resta una linea
        columGrid(j);//si era el last inv de colum ent colum del
        chekColumGrid(j);//vemos si  la ultima colum existe o eliminamos
    }
    public boolean win(){
        int i;
        for(i=0;i<numLineInv;i++){//si encuentra una linea activa no win
            if(invaderL[i])return false;
        }
        return true;
    }
    public void chekColumGrid(int j){
        int k;//columIni=0,columFin=0;
        //si murio last colum izq entonces pregunta por la anterior
        for(k=columIni;k<numInvader;k++){//y verifica si la sig existe
            if(!invaderC[k]){//si ecuentra un colum vacia continua asta encontrar una activa
                limIzq+=xr;
                columIni++;//dice q se inicia una columna despues
            }else break;//si encuentra una colum izq se sale de bucle
        }
        //si murio last colum der entonces pregunta por la anterior
        for(k=columFin;k<=numInvader;k++){//y verifica si la sig existe
            if(!invaderC[numInvader-k]){//si no exist
                columFin++;//una colum antes...
                limDer-=xr;
            } else break;//si encuentra una colum se sale de bucle
        }
    }
    public void lineGrid(int j){
        int c;
        invaderL[j]=false;//suponemos q no hay ningun inv en linea j
        for(c=0;c<numInvader;c++){
            //buscara algun inv y si lo encuentra cambia estado line a activa
            if(invaderGrid[j][c]){invaderL[j]=true;break;}
        }
    }
    public void columGrid(int j){
        int c;
        invaderC[j]=false;//suponemos q no hay ningun inv en linea j
        for(c=0;c<numLineInv;c++){
            //buscara algun inv y si lo encuentra cambia estado line a activa
            if(invaderGrid[c][j]){invaderC[j]=true;break;}
        }
    }
    // construye grid
    private void construyeGrid(Graphics g){
        y0=y;
        x0=x;//verifica donde inicia grid
        invCh=true;
        //ux=LInv/11,uy=HInv/8   //son unidades segun tamano del lienzo
        for(i=0;i<numLineInv;i++){//empieza a dibujar i line
            if(invaderL[i]){//verif si dibuja linea i
                for(j=0,x0=x;j<numInvader;j++){ //dibuja (i,j) invader
                    if(invaderGrid[i][j]){//verifica si inv[i][j] se dibuja
                        //verifica q tipo de invader escoje en thisd line
                        if(invCh){
                            //verifica cambio al caminar...caminar!?
                            if(camina){dibujaInv_a1(x0,y0,LInv/11,HInv/8,g);}
                            else{dibujaInv_a0(x0,y0,LInv/11,HInv/8,g);}
                        }else{
                            //verifica cambio al caminar...caminar?!
                            if(camina){dibujaInv_b1(x0,y0,LInv/11,HInv/8,g);}
                            else{dibujaInv_b0(x0,y0,LInv/11,HInv/8,g);}
                        }
                    }
                    x0+=xr; //spaciado asta sig inv
                }
            }
            y0+=yr;//spaciado asta sig line
            invCh=!invCh;//cambia tipo dè ~inv el sig line
        }
        
    }
    public void camina(){
        camina=!camina;
    }
    public void dibuja(Graphics g){
        g.setColor(Color.WHITE);
        //getLim();
        g.drawRect(this.getIzq(),this.getSup(),this.getDer()-this.getIzq(),this.getInf()-this.getSup());
        construyeGrid(g);//construye la grid
    }
    public static void  dibujaInv_a0(int x0,int y0,int ux,int uy,Graphics g){//dibuja un invader propiamente
        g.setColor(Color.WHITE);
        g.fillRect(x0+2*ux,y0+2*uy,7*ux,4*uy);//cuerpo pcipal
        g.fillRect(x0+ux,y0+3*uy,ux,2*uy);//soporte izq
        g.fillRect(x0,y0+4*uy,ux,3*uy);
        g.fillRect(x0+2*ux,y0,ux,uy);//antena
        g.fillRect(x0+3*ux,y0+uy,ux,uy);
        g.fillRect(x0+2*ux,y0+6*uy,ux,uy);//??
        g.fillRect(x0+3*ux,y0+7*uy,2*ux,uy);
        
        g.fillRect(x0+9*ux,y0+3*uy,ux,2*uy);//soporte der
        g.fillRect(x0+10*ux,y0+4*uy,ux,3*uy);
        g.fillRect(x0+8*ux,y0,ux,uy);//antena
        g.fillRect(x0+7*ux,y0+uy,ux,uy);
        g.fillRect(x0+8*ux,y0+6*uy,ux,uy);//??
        g.fillRect(x0+6*ux,y0+7*uy,2*ux,uy);
        
        g.setColor(Color.BLACK);
        g.fillRect(x0+3*ux,y0+3*uy,ux,uy);//ojo izq
        g.fillRect(x0+7*ux,y0+3*uy,ux,uy);//ojo der
    }
    public static void  dibujaInv_a1(int x0,int y0,int ux,int uy,Graphics g){//dibuja un invader propiamente
        g.setColor(Color.WHITE);
        g.fillRect(x0+2*ux,y0+2*uy,7*ux,4*uy);//cuerpo pcipal
        g.fillRect(x0+ux,y0+3*uy,ux,3*uy);//soporte izq
        g.fillRect(x0,y0+1*uy,ux,4*uy);
        g.fillRect(x0+2*ux,y0,ux,uy);//antena
        g.fillRect(x0+3*ux,y0+uy,ux,uy);
        g.fillRect(x0+2*ux,y0+6*uy,ux,uy);//??
        g.fillRect(x0+ux,y0+7*uy,ux,uy);
        
        g.fillRect(x0+9*ux,y0+3*uy,ux,3*uy);//soporte der
        g.fillRect(x0+10*ux,y0+1*uy,ux,4*uy);
        g.fillRect(x0+8*ux,y0,ux,uy);//antena
        g.fillRect(x0+7*ux,y0+uy,ux,uy);
        g.fillRect(x0+8*ux,y0+6*uy,ux,uy);//??
        g.fillRect(x0+9*ux,y0+7*uy,ux,uy);
        
        g.setColor(Color.BLACK);
        g.fillRect(x0+3*ux,y0+3*uy,ux,uy);//ojo izq
        g.fillRect(x0+7*ux,y0+3*uy,ux,uy);//ojo der
    }
    static public void dibujaInv_b0(int x0,int y0,int ux,int uy,Graphics g){
        g.setColor(Color.white);
        g.fillRect(x0,y0+3*uy,ux,2*uy);
        g.fillRect(x0,y0+7*uy,ux,uy);
        g.fillRect(x0+ux,y0+2*uy,ux,3*uy);
        g.fillRect(x0+ux,y0+6*uy,ux,uy);
        g.fillRect(x0+2*ux,y0+1*uy,ux,5*uy);
        g.fillRect(x0+3*ux,y0,ux,5*uy);
        g.fillRect(x0+2*ux,y0+7*uy,ux,uy);
        g.fillRect(x0+3*ux,y0+6*uy,2*ux,uy);//central...bk?
        
        g.fillRect(x0+7*ux,y0+3*uy,ux,2*uy);
        g.fillRect(x0+ux*7,y0+7*uy,ux,uy);
        g.fillRect(x0+6*ux,y0+2*uy,ux,3*uy);
        g.fillRect(x0+6*ux,y0+6*uy,ux,uy);
        g.fillRect(x0+5*ux,y0+1*uy,ux,5*uy);
        g.fillRect(x0+4*ux,y0,ux,5*uy);
        g.fillRect(x0+5*ux,y0+7*uy,ux,uy);
        
        g.setColor(Color.black);
        g.fillRect(x0+2*ux,y0+3*uy,ux,uy);
        g.fillRect(x0+5*ux,y0+3*uy,ux,uy);
    }
    static public void dibujaInv_b1(int x0,int y0,int ux,int uy,Graphics g){
        g.setColor(Color.white);
        g.fillRect(x0,y0+3*uy,ux,2*uy);
        g.fillRect(x0,y0+6*uy,ux,uy);
        g.fillRect(x0+ux,y0+2*uy,ux,4*uy);
        g.fillRect(x0+ux,y0+7*uy,ux,uy);
        g.fillRect(x0+2*ux,y0+1*uy,ux,4*uy);
        g.fillRect(x0+3*ux,y0,ux,6*uy);
        
        g.fillRect(x0+7*ux,y0+3*uy,ux,2*uy);
        g.fillRect(x0+ux*7,y0+6*uy,ux,uy);
        g.fillRect(x0+6*ux,y0+2*uy,ux,4*uy);
        g.fillRect(x0+6*ux,y0+7*uy,ux,uy);
        g.fillRect(x0+5*ux,y0+1*uy,ux,4*uy);
        g.fillRect(x0+4*ux,y0,ux,6*uy);
        
        g.setColor(Color.black);
        g.fillRect(x0+2*ux,y0+3*uy,ux,uy);
        g.fillRect(x0+5*ux,y0+3*uy,ux,uy);
    }
}