/*
 * Canvas.java
 *
 * Created on 28 de Novembro de 2008, 15:39
 */

package ambienteGrafico.componentes;

import algoritmo.Agente;
import algoritmo.ConjuntoDeAgentes;
import algoritmo.ConjuntoDeSolucoes;
import algoritmo.EspacoDeBusca;
import algoritmo.Obstaculo;
import algoritmo.Sensor;
import algoritmo.SensorAntiColisao;
import algoritmo.SensorDeVizinhanca;
import algoritmo.SensorFitness;
import ambienteGrafico.ferramentas.*;
import auxiliar.Conversor;
import java.awt.Color;
import java.awt.Cursor;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;

import java.util.logging.Level;
import java.util.logging.Logger;
import javax.imageio.ImageIO;
import javax.swing.ImageIcon;
import javax.swing.JFrame;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.Timer;
import org.jdesktop.swingx.JXGlassBox;

/**
 *
 * @author  Marília
 */
public class Canvas extends JPanel implements ActionListener{

    private BufferedImage imagemPrincipal = null;
    private BufferedImage imagemAmbiente = null;
    private int contadorX=-100;
    private int contadorY=-100;
    private boolean loopBack=false;
    private Timer animationTimer;
    private int animationDelay; //Em milisegundos
    private ImageIcon[] spritesAgentes;
    private Ferramenta canvasFerramentaListener=null;
    private Ferramenta canvasFerramentaListenerDeDesenho=null;

    EspacoDeBusca espacoDeBusca = null;
    
    /** Creates new form Canvas */
    public Canvas() {
        
        initComponents();
        limparImagem(null);
        criarSpritesAgentes();
        mudarFerramenta(null);

        espacoDeBusca = EspacoDeBusca.getInstance();
        espacoDeBusca.setCanvas(this);
        espacoDeBusca.estabelecerMelhorSolucaoPossivel();
    }

    //Criar as imagens
    public void limparImagem(File arquivoImagem) {
        if (imagemPrincipal != null && arquivoImagem==null) {
                imagemPrincipal = new BufferedImage(imagemPrincipal.getWidth(), imagemPrincipal.getHeight(), BufferedImage.TYPE_INT_RGB);
                imagemAmbiente = getCopia(imagemPrincipal);
        }
        else if(imagemPrincipal != null && arquivoImagem !=null){
            //pega caminhoImagem como imagemPrincial
            try {

                imagemPrincipal = ImageIO.read(arquivoImagem);
                imagemAmbiente = getCopia(imagemPrincipal);
            } catch (IOException ex) {
                Logger.getLogger(Canvas.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
        else {
            try {

                imagemPrincipal = ImageIO.read(getClass().getResource("/imagens/Exemplos de Ambientes/ModeloAmbiente1420x800comTubos.jpg"));
                //imagemPrincipal = new BufferedImage(1, 1, BufferedImage.TYPE_INT_RGB);
                imagemAmbiente = getCopia(imagemPrincipal);
            } catch (IOException ex) {
                Logger.getLogger(Canvas.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
        
        System.out.println("Dimencao Imagem principal: "+ imagemPrincipal.getWidth()+","+ imagemPrincipal.getHeight());
        System.out.println("Dimencao Imagem ambiente: "+ imagemAmbiente.getWidth()+","+ imagemAmbiente.getHeight());
        imagemPrincipal.flush();
       
    }
    
    public void mudarFerramenta(Ferramenta ferramenta){
        if(ferramenta==null){
            canvasFerramentaListener = new FerramentaNula(null);
            addMouseListener(canvasFerramentaListener);
            addMouseMotionListener(canvasFerramentaListener);
            System.out.println("Ferramenta Nula");
        }
        else{          
            removeMouseListener(canvasFerramentaListener);
            removeMouseMotionListener(canvasFerramentaListener);
            removerFerramentaDeDesenho();

            canvasFerramentaListener = ferramenta;
            addMouseListener(canvasFerramentaListener);
            addMouseMotionListener(canvasFerramentaListener);
            System.out.println("Ferramenta Mudada");
        }
        setCursor(canvasFerramentaListener.getCursor());
    }
    //Posso ter o listener FerramentaInserirAlvo ao mesmo tempo de FerramentaDesenharLinha
    public void adicionarFerramentaDeDesenho(Ferramenta ferramenta){
        removeMouseListener(canvasFerramentaListenerDeDesenho);
        removeMouseMotionListener(canvasFerramentaListenerDeDesenho);
        canvasFerramentaListenerDeDesenho = ferramenta;
        addMouseListener(canvasFerramentaListenerDeDesenho);
        addMouseMotionListener(canvasFerramentaListenerDeDesenho);
    }

    public void removerFerramentaDeDesenho(){
        removeMouseListener(canvasFerramentaListenerDeDesenho);
        removeMouseMotionListener(canvasFerramentaListenerDeDesenho);
    }
    
    private void criarSpritesAgentes(){
        spritesAgentes = new ImageIcon[360];
        for(int i = 0;i<360; i++){
           spritesAgentes[i] = new ImageIcon(getClass().getResource("/imagens/Boat Sprites/boat_"+ i +".gif"));
        }
        System.out.println("Sprites criados");
     }
     
    protected void paintComponent(Graphics g)
     {        
         super.paintComponent(g);
         
         if (animationTimer!=null && animationTimer.isRunning()){
            
             animacao();
         }
          
         Graphics2D g2d = (Graphics2D)g.create();
         g2d.drawImage(imagemPrincipal, 0, 0, this.getWidth(), this.getHeight(), null);
         g2d.dispose();
         
     }
        //Aciona actionListener para Repintar panel
    public void startAnimation() {
            if (animationTimer == null) {
                animationTimer = new Timer(animationDelay, this);
                animationTimer.start();
            }
            else {// continuar da última imagem mostradaS
                if (!animationTimer.isRunning())
                    animationTimer.restart();
            }
    }

    public void stopAnimation() {
            if(animationTimer!=null)
                animationTimer.stop();
    }
    
    //O que acontece durante a animação
    private void animacao(){
        
         imagemPrincipal = getCopia(imagemAmbiente);
         
         Graphics2D g2dImagem = imagemPrincipal.createGraphics();
         
         ConjuntoDeAgentes agentes = espacoDeBusca.getAgentes();
         espacoDeBusca.setCicloAtual(espacoDeBusca.getCicloAtual()+1);

         
      

              //Pintar os obstáculos
             Obstaculo obstaculo;
             for(int i=0; i<espacoDeBusca.getObstaculos().getNumObstaculos();i++){
                    obstaculo = espacoDeBusca.getObstaculos().get(i);
                    if(obstaculo.isAtivo()){
                        pintarAreaRepulsaoDoObstaculo(obstaculo,g2dImagem);
                    }
             }
             Agente agente;
             double[] posicao;
             int angulo = 0;
             System.out.println("Ciclo: "+ espacoDeBusca.getCicloAtual());
             for (int k=0; k<agentes.getNumAgentes();k++){
                    agente = agentes.get(k);
                    posicao = agente.getPosicao();
                    /*int[] posicaoEmPx = Conversor.converterEscalaMetroParaEscalaImagem(posicao[0],
                                                                       posicao[1],
                                                                       this.getWidth(),
                                                                       this.getHeight(),
                                                                       espacoDeBusca.getLimiteMaxCoordX(),
                                                                       espacoDeBusca.getLimiteMaxCoordY());
                    */
                    int[] posicaoEmPx = Conversor.converterEscalaMetroParaEscalaImagem(posicao[0],posicao[1],
                                                                                espacoDeBusca.getLimiteMaxCoordX(),
                                                                                espacoDeBusca.getLimiteMaxCoordY(),
                                                                                imagemPrincipal.getWidth(),
                                                                                imagemPrincipal.getHeight());

                    //desenverter a escala do y //
                    posicaoEmPx[1] = imagemPrincipal.getHeight() - posicaoEmPx[1];

                    angulo = (int) Math.round(  agente.getVelocidadePolar()[1]  );
                    if(angulo == 360)
                        angulo = 0;
                    //Insere o novo estado do agente na imagem
                    ImageIcon figura = spritesAgentes[angulo];
                    int[] posicaoIcon = new int[2];
                    //Centra o meio da imagem na posição que queremos
                    posicaoIcon[0] = posicaoEmPx[0]-(figura.getIconWidth()/2);
                    posicaoIcon[1] = posicaoEmPx[1]-(figura.getIconHeight()/2);
                    /*//Converte o ponto na escala do canvas em um ponto na escala da imagem
                    posicaoIcon = Conversor.converterEscalaCanvasParaEscalaImagem(posicaoIcon[0],posicaoIcon[1],
                                                                                  this.getWidth(),this.getHeight(),
                                                                                  imagemPrincipal.getWidth(), imagemPrincipal.getHeight());
                    */

                     //Pinta os sensores do agente
                    SensorDeVizinhanca sensorDeVizinhanca = agente.getSensorDeVizinhanca();
                    if(sensorDeVizinhanca.isMostrarSensor()){
                        pintarSensor(posicaoEmPx, sensorDeVizinhanca,g2dImagem,true,false,null);
                    }

                    SensorFitness sensorFitness = agente.getSensorFitness();
                    if(sensorFitness.isMostrarSensor()){
                        pintarSensor(posicaoEmPx, sensorFitness,g2dImagem,true,false, null);
                    }

                    SensorAntiColisao sensorAntiColisao = agente.getSensorAntiColisao();
                    if(sensorAntiColisao.isMostrarSensor()){
                        pintarSensor(posicaoEmPx, sensorAntiColisao,g2dImagem,true,false,null);
                    }

                    //Pinta os locais avaliados pelo agente
                    pintarLocaisAvaliadosPeloAgente(g2dImagem, agente);
                    //Pintar Destino
                    //pintarDestino(g2dImagem, agente);

                    
                    
                    if(    !(posicaoIcon[0]+figura.getIconWidth()>imagemAmbiente.getWidth()
                        || posicaoIcon[0]<0
                        || posicaoIcon[1]+figura.getIconHeight()>imagemAmbiente.getHeight()
                        || posicaoIcon[1]<0)){
                            //Mostrar o rastro da trajetória do agente
                            if(agente.isMostrarTrajetoria()){
                                Graphics2D g2dImagemAmb = imagemAmbiente.createGraphics();
                                g2dImagemAmb.setColor(new Color(255,100,0,150)); //laranja transparente
                                g2dImagemAmb.draw(new java.awt.geom.Rectangle2D.Double(posicaoEmPx[0], posicaoEmPx[1], 2, 2));
                            }
                            //Pintar o agente
                            figura.paintIcon(this, g2dImagem,  posicaoIcon[0],posicaoIcon[1]);
                    }
                    /*System.out.println("Agente["+k+"]= posicaoEmPx: "+ posicaoEmPx[0]+","+posicaoEmPx[1]
                                                    +" | velocidade: "+agente.getVelocidadePolar()[0]+" | angulo: "+angulo
                                                    +" | posicao: "+ Math.round(posicao[0])+","+ Math.round(posicao[1])
                                                    +" | posicaoDestino: "+ Math.round(agente.getPosicaoDestino()[0])+","+ Math.round(agente.getPosicaoDestino()[1])
                                                    +" | modo: PSO-"+ agente.isEstadoPSO());
                   */
             }
             espacoDeBusca.executar();
             //mostra a direção da correnteza na tela
             animarCorrenteza(g2dImagem,espacoDeBusca.getVeloCorrentezaPolar(),espacoDeBusca.getLimiteMaxCoordX(), espacoDeBusca.getLimiteMaxCoordY());

             if(espacoDeBusca.isExecucaoFinalizada())
                stopAnimation();
    }
    
    private void animarCorrenteza(Graphics2D g2dImagem, double[]velocPolarCorrenteza, int maxDimX, int maxDimY){
       //boolean ativarAnimacao = ((FerramentaSimulacao) canvasFerramentaListener).getPainel()
        g2dImagem.setColor(new Color(0,255,0,150)); //verde transparente
        g2dImagem.setStroke(new java.awt.BasicStroke(5));
        double[] correnteza = Conversor.coordPolarParaCartesiana(velocPolarCorrenteza[0], velocPolarCorrenteza[1]);
        if(contadorX==-100){//inicializa valor do contador
            if( correnteza[0]<0)
                contadorX = maxDimX;
            else if(correnteza[0]==0)
                contadorX = maxDimX/2;
            else
                contadorX = 0;
            
            if( correnteza[1]<0)
                contadorY = 0;
              else if(correnteza[1]==0)
                contadorY = maxDimY/2;
            else
                contadorY = maxDimY;
            
        }
        int tamanhoArestaX = (int) Math.round(contadorX+correnteza[0]*20);
        int tamanhoArestaY = (int) Math.round(contadorY-correnteza[1]*20);
        
        boolean reiniciar = false;
        
        if(tamanhoArestaX <0 || tamanhoArestaX >maxDimX || tamanhoArestaY <0 || tamanhoArestaY >maxDimY){
            reiniciar =true;
            if( correnteza[0]<0)
                contadorX = maxDimX;
            else if(correnteza[0]==0)
                contadorX = maxDimX/2;
            else
                contadorX = 0;
            
            if( correnteza[1]<0)
                contadorY = 0;
              else if(correnteza[1]==0)
                contadorY = maxDimY/2;
            else
                contadorY = maxDimY;
            
            tamanhoArestaX = (int) Math.round(contadorX+correnteza[0]*20);
            tamanhoArestaY = (int) Math.round(contadorY-correnteza[1]*20);
        }
        g2dImagem.draw(new java.awt.geom.Line2D.Double(contadorX, contadorY, tamanhoArestaX, tamanhoArestaY));
       if(!reiniciar){
            contadorX = (int) Math.round(contadorX+correnteza[0]);
            contadorY = (int) Math.round(contadorY-correnteza[1]);
        }
        
    }
    
    private void pintarSensor(int posicaoEmPx[],Sensor sensor,Graphics2D g2dImagem,boolean desenharCircunferencia,boolean desenharCirculo,  Integer agenteID){
       
        int[] alcanceSensor = Conversor.converterEscalaMetroParaEscalaImagem( (int) sensor.getSensorDiametro(),
                                                                            (int) sensor.getSensorDiametro(),
                                                                            espacoDeBusca.getLimiteMaxCoordX(),
                                                                            espacoDeBusca.getLimiteMaxCoordY(),
                                                                            imagemPrincipal.getWidth(),
                                                                            imagemPrincipal.getHeight());
       

        
        g2dImagem.setStroke(new java.awt.BasicStroke(2));
        g2dImagem.setColor( sensor.getCor() );
        if(desenharCircunferencia)
            g2dImagem.drawArc( (posicaoEmPx[0]-alcanceSensor[0]/2),
                            (posicaoEmPx[1]-alcanceSensor[0]/2),
                            alcanceSensor[0],
                            alcanceSensor[0],
                            0, 360);
        if(desenharCirculo){
            g2dImagem.setColor( getColorDaFotoNoAmbiente( agenteID) );
            g2dImagem.fillOval( (posicaoEmPx[0]-alcanceSensor[0]/2),
                                (posicaoEmPx[1]-alcanceSensor[0]/2),
                                 alcanceSensor[0],
                                 alcanceSensor[0]);

        }
        //System.out.println("Alcance sensor:"+ alcanceSensor[0] +"  Cor:"+sensor.getCor().toString());
        
    }
    
    private void pintarLocaisAvaliadosPeloAgente(Graphics2D g2dImagem, Agente agente){
        ConjuntoDeSolucoes memoriaDeSolucoes = agente.getMemoriaDeSolucoes();//.getUltimosLocaisAvaliados();//qtd default: 5
        double[] localJaVisitado;
                
                int[] posicaoLocalJaVisitadoEmPx;
                for (int idSolucao = 0; idSolucao < memoriaDeSolucoes.getNumSolucoes(); idSolucao++){
                     
                    localJaVisitado = memoriaDeSolucoes.get(idSolucao).getPosicao();
                    if( !(localJaVisitado[0]==0 && localJaVisitado[1]==0)){
                        posicaoLocalJaVisitadoEmPx = Conversor.converterEscalaMetroParaEscalaImagem(localJaVisitado[0],localJaVisitado[1],
                                                                                espacoDeBusca.getLimiteMaxCoordX(),
                                                                                espacoDeBusca.getLimiteMaxCoordY(),
                                                                                imagemPrincipal.getWidth(),
                                                                                imagemPrincipal.getHeight());
                        //desenverter a escala do y
                        posicaoLocalJaVisitadoEmPx[1] = Math.abs(imagemPrincipal.getHeight() -  posicaoLocalJaVisitadoEmPx[1]);

                        Integer agenteID = agente.getIdAgente();
                        pintarSensor(posicaoLocalJaVisitadoEmPx, agente.getSensorFitness(),g2dImagem,false,true,agenteID);
                    }
                }
    }
    
    private void pintarDestino(Graphics2D g2dImagem, Agente agente){


                int[] posicaoDestinoEmPx = Conversor.converterEscalaMetroParaEscalaImagem(agente.getPosicaoDestino()[0],agente.getPosicaoDestino()[1],
                                                                                espacoDeBusca.getLimiteMaxCoordX(),
                                                                                espacoDeBusca.getLimiteMaxCoordY(),
                                                                                imagemPrincipal.getWidth(),
                                                                                imagemPrincipal.getHeight());
                //inverter a escala do y
                posicaoDestinoEmPx[1] = Math.abs(imagemPrincipal.getHeight() -  posicaoDestinoEmPx[1]);
                
                //System.out.println("Posicao Destino= Em M:("+agente.getPosicaoDestino()[0]+","+agente.getPosicaoDestino()[1]+") Em Px: ("+posicaoDestinoEmPx[0]+","+posicaoDestinoEmPx[1]+")");
                
                g2dImagem.setColor(new Color(255,255,255)); //branco
                g2dImagem.draw(new java.awt.geom.Rectangle2D.Double(posicaoDestinoEmPx[0], posicaoDestinoEmPx[1], 3, 3));
                
                int[] posicaoAtualEmPx = Conversor.converterEscalaMetroParaEscalaImagem(agente.getPosicao()[0],agente.getPosicao()[1],
                                                                                espacoDeBusca.getLimiteMaxCoordX(),
                                                                                espacoDeBusca.getLimiteMaxCoordY(),
                                                                                imagemPrincipal.getWidth(),
                                                                                imagemPrincipal.getHeight());
                //inverter a escala do y
                posicaoAtualEmPx[1] = imagemPrincipal.getHeight() -  posicaoAtualEmPx[1];
                g2dImagem.draw(new java.awt.geom.Line2D.Double(posicaoAtualEmPx[0], posicaoAtualEmPx[1], posicaoDestinoEmPx[0], posicaoDestinoEmPx[1]));

                if(agente.isEstadoPSO())
                    pintarLbest(g2dImagem, agente);
    }

    public void pintarLbest(Graphics2D g2dImagem, Agente agente){
                double[] posicaoLbest = agente.getMemoriaDeSolucoes().getSolucaoLbest().getPosicao();
                int[] posicaoLbestEmPx = Conversor.converterEscalaMetroParaEscalaImagem(posicaoLbest[0],posicaoLbest[1],
                                                                                espacoDeBusca.getLimiteMaxCoordX(),
                                                                                espacoDeBusca.getLimiteMaxCoordY(),
                                                                                imagemPrincipal.getWidth(),
                                                                                imagemPrincipal.getHeight());
                //inverter a escala do y
                posicaoLbestEmPx[1] = Math.abs(imagemPrincipal.getHeight() -  posicaoLbestEmPx[1]);

                //System.out.println("Posicao Destino= Em M:("+agente.getPosicaoDestino()[0]+","+agente.getPosicaoDestino()[1]+") Em Px: ("+posicaoDestinoEmPx[0]+","+posicaoDestinoEmPx[1]+")");

                g2dImagem.setColor(new Color(0,0,0)); //preto
                g2dImagem.draw(new java.awt.geom.Rectangle2D.Double(posicaoLbestEmPx[0], posicaoLbestEmPx[1], 3, 3));

                int[] posicaoAtualEmPx = Conversor.converterEscalaMetroParaEscalaImagem(agente.getPosicao()[0],agente.getPosicao()[1],
                                                                                espacoDeBusca.getLimiteMaxCoordX(),
                                                                                espacoDeBusca.getLimiteMaxCoordY(),
                                                                                imagemPrincipal.getWidth(),
                                                                                imagemPrincipal.getHeight());
                //inverter a escala do y
                posicaoAtualEmPx[1] = imagemPrincipal.getHeight() -  posicaoAtualEmPx[1];
                g2dImagem.draw(new java.awt.geom.Line2D.Double(posicaoAtualEmPx[0], posicaoAtualEmPx[1], posicaoLbestEmPx[0], posicaoLbestEmPx[1]));
    }
    //É chamada pelas classes de inserção e seleção de obstaculos no ambiente
    public void pintarAreaRepulsaoDoObstaculo(Obstaculo obstaculo,Graphics2D g2dImagem){
        int[] posicaoObstaculoEmPx = Conversor.converterEscalaMetroParaEscalaImagem(obstaculo.getPosicao()[0],obstaculo.getPosicao()[1],
                                                                                espacoDeBusca.getLimiteMaxCoordX(),
                                                                                espacoDeBusca.getLimiteMaxCoordY(),
                                                                                imagemPrincipal.getWidth(),
                                                                                imagemPrincipal.getHeight());
        //desenverter a escala do y
        posicaoObstaculoEmPx[1] = Math.abs(imagemPrincipal.getHeight() -  posicaoObstaculoEmPx[1]);


        int[] raioDaAreaDeRepulsao = Conversor.converterEscalaMetroParaEscalaImagem( obstaculo.getRaioAreaRepulsao(),
                                                                            obstaculo.getRaioAreaRepulsao(),
                                                                            espacoDeBusca.getLimiteMaxCoordX(),
                                                                            espacoDeBusca.getLimiteMaxCoordY(),
                                                                            imagemPrincipal.getWidth(),
                                                                            imagemPrincipal.getHeight());
        ImageIcon figuraObstaculo=null;
        int[] posicaoIconObstaculo = new int[2];
        if(g2dImagem ==null){
           
            /*if(imagemPrincipal == null){
                imagemPrincipal = getCopia(imagemAmbiente);
            }*/
            g2dImagem = imagemPrincipal.createGraphics();
            if(obstaculo.isMostrarAreaRepulsao()){
                g2dImagem.setColor(new Color(50,50,50,150)); //cor escura
             
                g2dImagem.fillOval( (posicaoObstaculoEmPx[0]-raioDaAreaDeRepulsao[0]),
                                (posicaoObstaculoEmPx[1]-raioDaAreaDeRepulsao[0]),
                                 raioDaAreaDeRepulsao[0]*2,
                                 raioDaAreaDeRepulsao[0]*2);
            }
            figuraObstaculo = new ImageIcon(getClass().getResource(obstaculo.getCaminhoImagem()));
            posicaoIconObstaculo[0] = posicaoObstaculoEmPx[0]-(figuraObstaculo.getIconWidth()/2);
            posicaoIconObstaculo[1] = posicaoObstaculoEmPx[1]-(figuraObstaculo.getIconHeight()/2);
            figuraObstaculo.paintIcon(this, g2dImagem,  posicaoIconObstaculo[0],posicaoIconObstaculo[1]);
            
            imagemPrincipal.flush();
            repaint();
             
        }
        else{
            if(obstaculo.isMostrarAreaRepulsao()){
                g2dImagem.setColor(new Color(50,50,50,150)); //cor escura
                g2dImagem.fillOval( (posicaoObstaculoEmPx[0]-raioDaAreaDeRepulsao[0]),
                                (posicaoObstaculoEmPx[1]-raioDaAreaDeRepulsao[0]),
                                 raioDaAreaDeRepulsao[0]*2,
                                 raioDaAreaDeRepulsao[0]*2);
            }
            figuraObstaculo = new ImageIcon(getClass().getResource(obstaculo.getCaminhoImagem()));
            posicaoIconObstaculo[0] = posicaoObstaculoEmPx[0]-(figuraObstaculo.getIconWidth()/2);
            posicaoIconObstaculo[1] = posicaoObstaculoEmPx[1]-(figuraObstaculo.getIconHeight()/2);
            figuraObstaculo.paintIcon(this, g2dImagem,  posicaoIconObstaculo[0],posicaoIconObstaculo[1]);

        }
    }

    private Color getColorDaFotoNoAmbiente(Integer agenteID){
        
        if(agenteID!=null){
            int id = agenteID.intValue();
            if(id==0)
                return new Color(100, 0, 100,150);
            else if(id==1)
                 return new Color(100,100,0,150);
            else if(id==2)
                 return new Color(0,100,100,150);
            else if(id==3)
                return new Color(255,255,0,150); //amarelo
            else if(id==4)
                return new Color(255,0,255,150);//magenta
            else
               return new Color(0,255,255,150); //ciano
        }
        else
            return null;

    }
    
    public BufferedImage getCopia(BufferedImage in) {
            
            BufferedImage temp = new BufferedImage(in.getWidth(), in.getHeight(),BufferedImage.TYPE_INT_RGB);
            Graphics2D g2d = temp.createGraphics();
            g2d.drawImage(in, null, 0, 0);

            return temp;
    }

    public void mostrarResultadoFinal(BufferedImage imagemEncontrada){
         JOptionPane.showMessageDialog(this.getParent(), new javax.swing.ImageIcon(imagemEncontrada),null,JOptionPane.PLAIN_MESSAGE,null);
    }
    /** This method is called from within the constructor to
     * initialize the form.
     * WARNING: Do NOT modify this code. The content of this method is
     * always regenerated by the Form Editor.
     */
    @SuppressWarnings("unchecked")
    // <editor-fold defaultstate="collapsed" desc="Generated Code">//GEN-BEGIN:initComponents
    private void initComponents() {

        setBackground(new java.awt.Color(255, 255, 255));
        setMinimumSize(new java.awt.Dimension(800, 600));
        setRequestFocusEnabled(false);
        setVerifyInputWhenFocusTarget(false);

        org.jdesktop.layout.GroupLayout layout = new org.jdesktop.layout.GroupLayout(this);
        this.setLayout(layout);
        layout.setHorizontalGroup(
            layout.createParallelGroup(org.jdesktop.layout.GroupLayout.LEADING)
            .add(0, 800, Short.MAX_VALUE)
        );
        layout.setVerticalGroup(
            layout.createParallelGroup(org.jdesktop.layout.GroupLayout.LEADING)
            .add(0, 600, Short.MAX_VALUE)
        );
    }// </editor-fold>//GEN-END:initComponents


    // Variables declaration - do not modify//GEN-BEGIN:variables
    // End of variables declaration//GEN-END:variables

    public static void main(String args[]) {
        java.awt.EventQueue.invokeLater(new Runnable() {
            public void run() {
                JFrame frame =  new JFrame();
                frame.setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);
                Canvas panel = new Canvas();//.setVisible(true);
                panel.setVisible(true);
                frame.setContentPane(panel);
                frame.setVisible(true);
                frame.pack();
            }
        });
    }

    @Override
    public void actionPerformed(ActionEvent e) {
        
       repaint();

    }
    
    //------------Getters & Setters------------------//
    public BufferedImage getImagemAmbiente() {
        return imagemAmbiente;
    }

    public void setImagemAmbiente(BufferedImage imagemAmbiente) {
        this.imagemAmbiente = imagemAmbiente;
    }

    public BufferedImage getImagemPrincipal() {
        return imagemPrincipal;
    }

    public void setImagemPrincipal(BufferedImage imagemPrincipal) {
        this.imagemPrincipal = imagemPrincipal;
    }

    public ImageIcon[] getSpritesAgentes() {
        return spritesAgentes;
    }

    public void setSpritesAgentes(ImageIcon[] spritesAgentes) {
        this.spritesAgentes = spritesAgentes;
    }

    public Timer getAnimationTimer() {
        return animationTimer;
    }

    public void setAnimationTimer(Timer animationTimer) {
        this.animationTimer = animationTimer;
    }


    
   
    
}
