terça-feira, 30 de novembro de 2010

Delphi

Deixe-me explanar um pouco a respeito de Delphi.

Deixo claro que não gosto desde o início.
Talvez por ter aprendido JAVA desde início, acho Delphi e suas procedures sem lógica.
Não consigo ver amarração nas variáveis e, só de imaginar a possibilidade de utilizar alguns componentes como variáveis, já sinto calafrios.

Outra desvantagem que vejo no Delphi é a dependência de componentes; nada está claramente catalogado, há muitos atributos e eventos, o que não garanta que você encontre um específico no componente que você está usando - mesmo se fisse lógica a existência.

Aliás, os eventos são dignos de um parágrafo próprio: Programação orientada a eventos? Realmente quebrei a cabeça para unir dois eventos que queria que resultassem em uma mesma coisa.

No JAVA, se você não sabe algo, sempre há a API. Toneladas de livros, sites de referencia, fóruns com pessoas dispostas a ajudar e toda uma cultura de auxílio mútuo, completam esse mundo.
No Delphi, se você não sabe algo, fica parado em frente à tela, sem saber o que fazer... Onde procurar? Como é uma "tecnologia" paga, raramente encontramos e-books grátis, fóruns com gente querendo ajudar os outros, tão pouco cordialidade entre os "programadores".
Exemplo disso é que fiquei 4 semanas pedindo ajuda para fazer o trabalho final que tenho que entregar dentro de instantes e NINGUÉM ajudou. Sequer a "professora". Isso que trabalho em uma empresa que trabalha com Delphi (mas que, graças a Deus, está migrando o sistema para JAVA, programação de verdade).

Os Forms Delphi dão a ilusão de serem classes JAVA, podendo ser objetos a serem utilizados conforme a necessidade, o que é uma gigantesca falácia.
Talvez o que atraia as pessoas para essa armadilha seja a ilusão de criar a tela arrastando componentes. Isso várias IDE's de outras linguagens também fazem, de forma gratuíta e sem necessidade de cracks.

Aliás, essa prática de arrastar componentes é o que cria "programas" com telas-monstro, com mais de 40 campos de inclusão... Atitude típica de interfaces Delphi. Não preciso nem dizer que essas telas costumam dar muita manutenção e suporte, porque são dificílimas até de saber por onde começar.

Por fim, o lixo de código e a programação duplicada inundam o Delphi. A programação é totalmente estruturada, repetindo enormes quantidades de linhas que, se fosse em JAVA, não precisaríamos fazê-lo.

Ficaria muito feliz em nunca mais tocar nessa porcaria na minha vida, a fim de não me contaminar com as práticas obsoletas dessa "Linguagem".

PS - Programadores Delphi: Sequer pensem em me perguntar algo... vão direto para a biblioteca, ok? ;)

quarta-feira, 24 de novembro de 2010

Trabalho do Labirinto Java

Segue o caso-de-uso passado pelo professor Rafael Jefman:

------------------------------------------------------------------------------------------

Trabalho: Jogo de Labirinto


Objetivo:


Implementar um jogo de labirinto, com interface em modo texto,

utilizando a linguagem Java, obedecendo as regras e requisitos abaixo.


Regras e requisitos:


- A interface com o usuário será feita via console, com o usuário

digitando comandos.

- Os comandos serão compostos por verbos e substantivos, por exemplo

"Andar Sul", ou "Olhar armadilha".

- O objetivo do jogo é que o Jogador consiga "fugir" de um labirinto .

- O labirinto é formado por salas, onde cada sala pode ter até 6

saídas (Norte, Sul, Leste, Oeste, Acima, Abaixo).

- Cada sala pode estar vazia, conter um tesouro, um inimigo, uma

armadilha, ou não ter nada.

- O Labirinto será descrito por um arquivo texto, entregue pelo

professor, em aula.


Inimigos e Regras de Combate:


- O Jogador terá, no início do jogo, 10 unidades de vida

- Cada golpe do Jogador, em combate causará 2 unidades de dano, mais

as unidades somadas da arma que o Jogador está utilizando.

- As armas disponíveis para o Jogador são:

      - Faca: 1 dano (o jogador inicia com a faca)

      - Espada: 2 danos

      - Cimitarra: 3 danos

- As armas são obtidas como os tesouros.

- O jogador só pode carregar uma arma de cada vez.

- Os inimigos causam danos variados e possuem pontos variados de vida,

de acordo com o tipo de inimigo:

      Goblins: 1-2 ponto de dano, 2 a 3 pontos de vida

      Orcs: 2-4 pontos de dano, 3 a 5 pontos de vida

      Trolls: 4-6 pontos de dano, 4 a 7 pontos de vida

- O combate é resolvido em "turnos", sendo que o Jogador pode escolher

combater o inimigo ou não. Sempre que o Jogador atacar o inimigo, ele

irá revidar com um golpe. Golpes serão efetivos 80% das vezes para os

jogares e 50% das vezes para os inimigos.

- Se um inimigo está em uma sala, ele bloqueará a passagem do jogador

para uma das saídas, aleatoriamente.

- Os inimigos serão distribuídos aleatoriamente pelo labirinto.


Tesouros:


Além das armas, outros tesouros podem ser encontrados no labirinto:

      - Poção da Vida: faz com que a quantidade de pontos de vida do

jogador retorne a 10

      - Armadura: Aumenta a resistencia aos golpes dos inimigos

              - Armadura de Couro: 1 ponto

              - Armadura de Metal: 2 pontos

              - Armadura de Mithrill: 3 pontos

      - Fogo de Dragão: Quando utilizado, mata o inimigo instantaneamente.

      - Chaves: Algumas portas estarão trancadas, e é preciso que o jogador

possua uma chave para abri-las. As chaves podem ser das cores Azul,

Verde, Vermelha e Amarela, cada uma abre uma porta da mesma cor.

Portas "marrom" não são trancadas. Uma porta tem 10% de chance de ser

Azul, 10% de chance de ser Verde, 10% de chance de ser Vermelha e 10%

de chance de ser Amarela. Se uma porta não tiver "cor", ela será

"marrom" e estará destrancada.


Os Tesouros estarão em salas aleatórias. O Jogador pode carregar

apenas uma arma, um tesouro e uma armadura ao mesmo tempo. Para

carregar outro equipamento, é necessário largar o que já está

utilizando.


As armadilhas são inimigos que:


- Não bloqueiam a porta onde estão localizadas.

- Causam dano aleatório de 1 até a morte instantânea (ao contrário dos

inimigos, cujo dano é fixo)

- Tem dois estados: armadas e desarmadas

- Se um jogador passar pela armadilha sem a desarmar, recebe o dano,

mas consegue passar.

- Uma porta pode ter uma armadilha e um inimigo.

- O jogador tem 90% de chance de desarmar a armadilha.

------------------------------------------------------------------------------------------


Daqui em diante, seguem as classes que implementei:


------------------------------------------------------------------------------------------


Classe Labirinto, método main, que chama as demais classes.


------------------------------------------------------------------------------------------

package Labirinto;
 
import java.io.*;

public class Labirinto {
    
    public static void main(String[] args) {
        
        String a="";
        String aux="";
        
        BufferedReader entra = new BufferedReader(new InputStreamReader(System.in));  
        mapa m = new mapa();
        
        m.abrir();
        m.LugarInicial();
        
        while (!aux.equals("O")||!aux.equals("o")){
            try{
                System.out.println("Digite a ação desejada: \n");
                aux = entra.readLine();
                
                System.out.println(aux);
                
                if(aux.equals("Ver Ajuda")){
                    a+="Andar Norte        - Escolhe passar pela porta norte \n";
                    a+="Andar Sul          - Escolhe passar pela porta sul \n";
                    a+="Andar Leste        - Escolhe passar pela porta leste \n";
                    a+="Andar Oeste        - Escolhe passar pela porta oeste \n";
                    a+="Subir Escada       - Escolhe subir o andar \n";
                    a+="Descer Escada      - Escolhe descer o andar \n";
                    a+="Ver Mochila        - Escolhe ver os itens carregados \n";
                    a+="Ver Ajuda          - Escolhe ver os comandos de ajuda \n";
                    a+="Descrever Sala     - Descreve a sala onde você está \n";
                    a+="Desarmar Armadilha - Desarma a armadilha encontrada \n";
                    a+="Pegar Arma         - Pega Arma do tesouro \n";
                    a+="Pegar Armadura     - Pega Armadura do tesouro \n";
                    a+="Pegar Fogo         - Pega Fogo do Dragão do tesouro \n";
                    a+="Pegar Cura         - Pega Poção de Cura do tesouro \n";
                    a+="Pegar Chave        - Pega Chave do tesouro \n";
                    a+="Fechar Jogo        - Escolhe fechar o jogo \n";
                }
                
                if(aux.equals("Andar Norte")||aux.equals("Andar Sul")||aux.equals("Andar Leste")||aux.equals("Andar Oeste")||aux.equals("Subir Escada")||aux.equals("Descer escada")){
                    m.andar(aux);                
                }
                
                if(aux.equals("Ver Mochila")){
                    m.listaMochila();
                }                
                if(aux.equals("Descrever Sala")){
                    m.descrever();
                }
                if(aux.equals("Desarmar Armadilha")){
                    m.desarmarArmadilha();
                }
                if((aux.equals("Pegar Arma"))||(aux.equals("Pegar Armadura"))||(aux.equals("Pegar Chave"))||(aux.equals("Pegar Cura"))||(aux.equals("Pegar Fogo"))){
                    m.pegarTesouro(aux);
                }
                if(aux.equals("Fechar Jogo")){
                    aux="O";
                }                                                
                
                System.out.println(a);
                a="";
            }catch (IOException exception) {  
                exception.printStackTrace();  
            }  
        }
    }
}


------------------------------------------------------------------------------------------


Classe Mapa, principal classe, responsável pela leitura do arquivo, montagem do mapa, movimentação do personagem e descrição.


------------------------------------------------------------------------------------------

package Labirinto;

import java.io.*;
import java.util.Scanner;

class mapa {

/*Cria uma matriz que guardará as salas e conexões de qualquer labirinto com até 1000 salas:
Estrutura:
Linha 1: Conexão Norte;  N - não tem | 0 a 1000 - número da sala que faz conexão;
Linha 2: Conexão Sul;    N - não tem | 0 a 1000 - número da sala que faz conexão;
Linha 3: Conexão Leste;  N - não tem | 0 a 1000 - número da sala que faz conexão;
Linha 4: Conexão Oeste;  N - não tem | 0 a 1000 - número da sala que faz conexão;
Linha 5: Conexão Acima;  N - não tem | 0 a 1000 - número da sala que faz conexão;
Linha 6: Conexão Abaixo; N - não tem | 0 a 1000 - número da sala que faz conexão;

Exemplo:

room 18 north 24 south 25 TRAP east 19 west 22 up 28 TRAP

sala[18][1] = 24;
sala[18][2] = 25;
sala[18][3] = 19;
sala[18][4] = 22;
sala[18][5] = 28;
sala[18][6] = N;
*/
private String [][] sala = new String[1000][7];

/*Cria uma matriz que guardará a cor das conexões de qualquer labirinto com até 1000 salas:
Estrutura:
Linha 1: Conexão Norte;  N - não tem | Cor da Porta | D - destrancada
Linha 2: Conexão Sul;    N - não tem | Cor da Porta | D - destrancada
Linha 3: Conexão Leste;  N - não tem | Cor da Porta | D - destrancada
Linha 4: Conexão Oeste;  N - não tem | Cor da Porta | D - destrancada
Linha 5: Conexão Acima;  N - não tem | Cor da Porta | D - destrancada
Linha 6: Conexão Abaixo; N - não tem | Cor da Porta | D - destrancada

Exemplo:

room 18 north 24 (Marrom) south 25 TRAP (Azul) east 19 (Marrom) west 22 (Vermelha) up 28 TRAP (Verde)

cor[18][1] = Marrom;
cor[18][2] = Azul;
cor[18][3] = Marrom;
cor[18][4] = Vermelha;
cor[18][5] = Verde;
cor[18][6] = N;
*/
private String [][] cor = new String[1000][7];

/*Cria uma matriz que guardará as armadilhas de qualquer labirinto com até 1000 salas:
Estrutura:
Linha 1: Conexão Norte;  N - não possui | TRAP - possui armada | D - possui desarmada ;
Linha 2: Conexão Sul;    N - não possui | TRAP - possui armada | D - possui desarmada ;
Linha 3: Conexão Leste;  N - não possui | TRAP - possui armada | D - possui desarmada ;
Linha 4: Conexão Oeste;  N - não possui | TRAP - possui armada | D - possui desarmada ;
Linha 5: Conexão Acima;  N - não possui | TRAP - possui armada | D - possui desarmada ;
Linha 6: Conexão Abaixo; N - não possui | TRAP - possui armada | D - possui desarmada ;

Exemplo:

room 18 north 24 south 25 TRAP east 19 west 22 up 28 TRAP

trap[18][1] = N;
trap[18][2] = TRAP;
trap[18][3] = N;
trap[18][4] = N;
trap[18][5] = TRAP;
trap[18][6] = N;
*/
private String [][] trap = new String[1000][7];

/*Cria uma matriz que guardará os inimigos de qualquer labirinto com até 1000 salas:
Estrutura:
Linha 1: Conexão Norte;  N - não possui | G - Goblin | O - Orc | T - Troll;
Linha 2: Conexão Sul;    N - não possui | G - Goblin | O - Orc | T - Troll;
Linha 3: Conexão Leste;  N - não possui | G - Goblin | O - Orc | T - Troll;
Linha 4: Conexão Oeste;  N - não possui | G - Goblin | O - Orc | T - Troll;
Linha 5: Conexão Acima;  N - não possui | G - Goblin | O - Orc | T - Troll;
Linha 6: Conexão Abaixo; N - não possui | G - Goblin | O - Orc | T - Troll;

Exemplo:

room 18 north 24 south 25 TRAP(+ goblin) east 19 west 22(troll) up 28 TRAP

inimigo[18][1] = N;
inimigo[18][2] = G;
inimigo[18][3] = N;
inimigo[18][4] = T;
inimigo[18][5] = N;
inimigo[18][6] = N;
*/
private String [][] inimigo = new String[1000][7];


/*Cria uma matriz que guardará os tesouros de qualquer labirinto com até 1000 salas:
Estrutura:
Linha 1: Arma;           N - não possui | Faca - Faca   | Espada - Espada | Cimitarra - Cimitarra;
Linha 2: Armadura;       N - não possui | Couro - Couro | Metal - Metal   | Mitrhrill - Mitrhrill;
Linha 3: Chave;          N - não possui | Cor da Chave
Linha 4: Poção de Cura;  N - não possui | Cura - Possui
Linha 5: Fogo do Dragão; N - não possui | Fogo - Possui

Exemplo:

room 18 north 24 south 25 TRAP(+ goblin) east 19 west 22(troll) up 28 TRAP

tesouro[18][1] = N;
tesouro[18][2] = G;
tesouro[18][3] = N;
tesouro[18][4] = T;
tesouro[18][5] = N;
tesouro[18][6] = N;
*/
private String [][] tesouro = new String[1000][7];

private String [][] dadosInimigo = new String[1000][7];

// guarda a posição do personagem.
private int posicao = 0;
private int nDirecao= 0;

inventario i = new inventario();
tesouro tes = new tesouro();
inimigo ini = new inimigo();
personagem p = new personagem();

    // Abre o arquivo e monta a matriz do labirinto
    public void abrir(){
       
        //zera o mapa (salas, armadilhas e inimigos)
        for (int i=0; i<1000; i++){
            for (int j=0; j<7; j++){
                sala[i][j]="N";
                trap[i][j]="N";
                inimigo[i][j]="N";
                cor[i][j]="N";
                tesouro[i][j]="N";
                dadosInimigo[i][j]="N";
            }
        }       

        // garanto a linha zero da matriz das salas para as saídas.       
        for (int j=0; j<7; j++){
            sala[0][j]="SAIDA";
        }
       
        String caminhonome=""; // serve para pegar o 'caminhonome' do arquivo
        int n=0;                  // serve para guardar o número da sala em String
        String aux="";           // serve para auxiliar as conversões de int para String
        String direcao="";       // serve para guardar a direção da conexão
       
        Scanner entra = new Scanner(System.in);
        while(caminhonome==""){
            System.out.println("Digite o caminho, nome e extensão do arquivo do labirinto:");
            caminhonome = entra.next();           
        }

        try {
            FileInputStream fis = new FileInputStream(caminhonome); 
            Scanner     scanner = new Scanner(fis); 
  
            while (scanner.hasNext("room")) { 
                scanner.next();
                // guarda o número da sala
                n = scanner.nextInt();
                tesouro[n][1]=tes.arma();
                tesouro[n][2]=tes.armadura();
                tesouro[n][3]=tes.Chave();
                tesouro[n][4]=tes.cura();
                tesouro[n][5]=tes.fogodragao();
                while (scanner.hasNext("south")||scanner.hasNext("north")||scanner.hasNext("east")||scanner.hasNext("west")||scanner.hasNext("up")||scanner.hasNext("down")){
                    // pula e guarda a próxima direção
                    direcao = scanner.next();
                    if(direcao.equals("north")){
                        nDirecao=1;
                    }
                    if(direcao.equals("south")){
                        nDirecao=2;
                    }
                    if(direcao.equals("east")){
                        nDirecao=3;
                    }
                    if(direcao.equals("west")){
                        nDirecao=4;
                    }
                    if(direcao.equals("up")){
                        nDirecao=5;
                    }
                    if(direcao.equals("down")){
                        nDirecao=6;
                    }
                    // busco o número da sala de conexão e guardo na sala:
                    aux = scanner.next();
                     sala[n][nDirecao] = aux;
                     cor[n][nDirecao] = cor();
                    if(scanner.hasNext("TRAP")){
                        // se tiver TRAP, somo ao número da sala de conexão a String 'TRAP' e guardo na matriz trap:
                        aux = " "+scanner.next();
                        trap[n][nDirecao] = aux;
                    }
                    // crio inimigo para a conexão
                    inimigo[n][nDirecao]=ini.Tipo();
                    if(!inimigo[n][nDirecao].equals("N")){
                        geraInimigo(inimigo[n][nDirecao], n, nDirecao);
                    }
                    // limpo a aux para próximo uso
                    aux="";                   
                }
                // limpo a n para próximo uso
                n=0;
            } 
        }
        catch (Exception e) { 
            e.printStackTrace(); 
        }
        for (int i=0; i<40; i++) { 
            System.out.println("Sala " + i + " Norte " +sala[i][1] + trap[i][1] + inimigo[i][1] + " Sul " +sala[i][2] + trap[i][2] + inimigo[i][2] + " Leste " +sala[i][3] + trap[i][3] + inimigo[i][3] + " Oeste " +sala[i][4] + trap[i][4] + inimigo[i][4] + " Acima " +sala[i][5] + trap[i][5] + inimigo[i][5] + " Abaixo " +sala[i][6] + trap[i][6] + inimigo[i][6]); 
        }
    }
   
    // cria a localização incial
    public void LugarInicial(){
        int w=0;
        int k=1;
        while(w==0){
            k = (int) (1+(Math.random() * 1000));
            if(!sala[k][1].equals("N") || !sala[k][2].equals("N") || !sala[k][3].equals("N") || !sala[k][4].equals("N") || !sala[k][5].equals("N") || !sala[k][6].equals("N")){
                w=1;
            }
        }
       
        posicao = k;
        i.criaInventario();
        salaPresa();
       
        descrever();
    }
   
    public void salaPresa(){
        int r=0, n=0;
        String aux="";
        // testo se todas as portas estão fechadas
        aux = tesouro[posicao][3];
        for(int j=0;j<7;j++){
            // testo se há chave no chão para abrir uma das portas da sala
            if(!cor[posicao][j].equals("N")){
                if(!cor[posicao][j].equals(aux)){
                    r++;
                }
                n++;
            }
        }
        for(int j=0;j<7;j++){
            if(cor[posicao][j].equals("Marrom")){
                r=0;
            }
        }
        if(r==n){
            descrever();
            System.out.println("\n Você está preso nesta sala.");
            System.exit(0);
        }
    }
   
    // Descreve o lugar onde o personagem está
    public void descrever(){
        String a="";
        if(posicao==0){
            System.out.println("Parabéns! Você conseguiu escapar do Labirinto!");
            System.exit(0);
        }
       
        a += "Você está na Sala " + posicao +"\n";
       
        if(!sala[posicao][1].equals("N")){
            a += "Porta "+cor[posicao][1]+" ao norte. ";
            if(!inimigo[posicao][1].equals("N")){
                a+="Há um "+inimigo[posicao][1]+" bloquando esta porta. ";
            }
            if(!trap[posicao][1].equals("N")){
                a+="Há uma armadilha nesta porta. ";
            }
            a+="\n";
        }
        if(!sala[posicao][2].equals("N")){
            a += "Porta "+cor[posicao][2]+" ao sul. ";
            if(!inimigo[posicao][2].equals("N")){
                a+="Há um "+inimigo[posicao][2]+" bloquando esta porta.";
            }
            if(!trap[posicao][2].equals("N")){
                a+="Há uma armadilha nesta porta. ";
            }
            a+="\n";
        }
        if(!sala[posicao][3].equals("N")){
            a += "Porta "+cor[posicao][3]+" ao leste; ";
            if(!inimigo[posicao][3].equals("N")){
                a+="Há um "+inimigo[posicao][3]+" bloquando esta porta.";
            }
            if(!trap[posicao][3].equals("N")){
                a+="Há uma armadilha nesta porta. ";
            }
            a+="\n";
        }
        if(!sala[posicao][4].equals("N")){
            a += "Porta "+cor[posicao][4]+" a oeste; ";
            if(!inimigo[posicao][4].equals("N")){
                a+="Há um "+inimigo[posicao][4]+" bloquando esta porta.";
            }
            if(!trap[posicao][4].equals("N")){
                a+="Há uma armadilha nesta porta. ";
            }
            a+="\n";
        }
        if(!sala[posicao][5].equals("N")){
            a += "Escada "+cor[posicao][5]+" para Subir; ";
            if(!inimigo[posicao][5].equals("N")){
                a+="Há um "+inimigo[posicao][5]+" bloquando esta Escada.";
            }
            if(!trap[posicao][5].equals("N")){
                a+="Há uma armadilha nesta Escada. ";
            }
            a+="\n";
        }
        if(!sala[posicao][6].equals("N")){
            a += "Escada "+cor[posicao][6]+" para descer; ";
            if(!inimigo[posicao][6].equals("N")){
                a+="Há um "+inimigo[posicao][6]+" bloquando esta Escada.";
            }
            if(!trap[posicao][6].equals("N")){
                a+="Há uma armadilha nesta Escada. ";
            }
            a+="\n";
        }
       
        for(int i=0; i<7; i++){
            if(!tesouro[posicao][i].equals("N")){
                a +="Tesouro: "+tesouro[posicao][i]+"\n";
            }
           
        }
         System.out.println(a);
    }
   
    //move o personagem pelo labirinto
    public void andar(String comando){
       
        String aux="";
               
        if(comando.equals("Andar Norte")){
            nDirecao=1;
        }
        if(comando.equals("Andar Sul")){
            nDirecao=2;
        }
        if(comando.equals("Andar Leste")){
            nDirecao=3;
        }
        if(comando.equals("Andar Oeste")){
            nDirecao=4;
        }
        if(comando.equals("Subir Escada")){
            nDirecao=5;
        }
        if(comando.equals("Descer Escada")){
            nDirecao=6;
        }           
           
        // Testa se há sala para onde o jogador quer se mover
        if(sala[posicao][nDirecao].equals("N")){
            System.out.println("Não há porta para esta direção. \n");
        }
        else{
            // testa se há inimigo na porta e leva para o método de combate
            if (!inimigo[posicao][nDirecao].equals("N")){
                aux=combate(posicao, nDirecao);
           
                if(!aux.equals(inimigo[posicao][nDirecao])){
                    inimigo[posicao][nDirecao]=aux;
                }
            }
            else{
                // testa se há armadilha na porta e leva para o método de dano da armadilha
                if(trap[posicao][nDirecao].equals("TRAP")){
                    danoArmadilha();
                }               
            }
           
            if((!cor[posicao][nDirecao].equals("D"))||(!cor[posicao][nDirecao].equals("Marrom"))){
                abrirPorta(nDirecao);
            }
           
            if(inimigo[posicao][nDirecao].equals("N")){
                if(cor[posicao][nDirecao].equals("Marrom")){
                    // comando que move o personagem para a próxima sala
                    posicao = Integer.parseInt(sala[posicao][nDirecao]);                   
                }
            }
        }
        salaPresa();
        descrever();           
    }
    // Este método teste se há chave para abrir a porta correspondente.
    public void abrirPorta(int nDirecao){
        // recupera a chave que o personagem carrega
        String aux = i.listatesouro();
        // testa se a chave que o personagem carrega é igual à cor da porta
        if(cor[posicao][nDirecao].equals(aux)){
            cor[posicao][nDirecao]="Marrom";
            System.out.println("Você abriu esta porta.");
        }
        else{
            if(!cor[posicao][nDirecao].equals("Marrom")){
                System.out.println("Você não possui a chave para abrir esta porta.");
            }
        }
    }
   
    public String cor(){
        String cor="";
        while (cor.equals("")){
            int a = (int) (1+(Math.random() * 10));
            switch(a){
                case 1:  cor = "Verde"; break;
                case 3:  cor = "Vermelha"; break;
                case 5:  cor = "Amarela"; break;
                case 7:  cor = "Azul"; break;
                default: cor = "Marrom"; break;
            }
        }
        return cor;       
    }
    public void pegarTesouro(String opcao){
       
        String aux = "";
       
        if(opcao.equals("Pegar Arma")){
            if(!tesouro[posicao][1].equals("N")){
                aux=i.listaarma();
                i.getarma(tesouro[posicao][1]);
                tesouro[posicao][1]=aux;
            }
            else{
                System.out.println("Não há arma no tesouro");
            }
        }
        if(opcao.equals("Pegar Armadura")){
            if(!tesouro[posicao][2].equals("N")){
                aux=i.listaarmadura();
                i.getarmadura(tesouro[posicao][2]);
                tesouro[posicao][2]=aux;
            }
            else{
                System.out.println("Não há armadura no tesouro");
            }
        }
        if(opcao.equals("Pegar Chave")){
            if(!tesouro[posicao][3].equals("N")){
                aux=i.listatesouro();
                i.gettesouro(tesouro[posicao][3]);
                tesouro[posicao][3]=aux;
            }
            else{
                System.out.println("Não há Chave no tesouro");
            }
        }       
        if(opcao.equals("Pegar Cura")){
            if(!tesouro[posicao][4].equals("N")){
                aux=i.listatesouro();
                i.gettesouro(tesouro[posicao][4]);
                tesouro[posicao][4]=aux;
            }
            else{
                System.out.println("Não há Poção de Cura no tesouro");
            }
        }
        if(opcao.equals("Pegar Fogo")){
            if(!tesouro[posicao][5].equals("N")){
                aux=i.listatesouro();
                i.gettesouro(tesouro[posicao][5]);
                tesouro[posicao][5]=aux;
            }
            else{
                System.out.println("Não há Fogo do Dragão no tesouro");
            }
        }       
    }
    // Desarma a armadilha.
    public void desarmarArmadilha(){
       
        int a = (int) (1+(Math.random() * 10));
        switch(a){
            case 5:
                System.out.println("Você não conseguiu desarmar a armadilha. \n");break;
            default:
                System.out.println("Você conseguiu desarmar a armadilha. \n");
                trap[posicao][nDirecao]="N";break;
        }
    }
   
    //gera o combate entre o personagem e os inimigos
    public String combate(int posicao, int nDirecao){
        Scanner entra = new Scanner(System.in);
       
        String sa=""+posicao;
        String di=""+nDirecao;
        for(int i=0;i<1000;i++){
            if(dadosInimigo[i][2].equals(sa)){
                if(dadosInimigo[i][3].equals(di)){
                    posicao=i;
                    break;
                }
            }
        }
      
        String aux="";
        aux=i.listatesouro();
        int a=0, vida=0;
       
        if(!aux.equals(null)){       
            if(aux.equals("Fogo")){
                System.out.println("Atacar com Arma ou com Fogo do Dragão?");
                aux = entra.nextLine();
                if(aux.equals("Usar Fogo")){
                    return "N";
                }
            }
        }
       
        a = p.dano(i.listaarma());
        aux=dadosInimigo[posicao][4];
        int b = Integer.parseInt(aux);
        vida =  b - a;
        System.out.println("Você acertou o "+dadosInimigo[posicao][1]+" com "+a+" pontos de dano. \n");
        dadosInimigo[posicao][4]=""+vida;
       
        if(vida>0){
            a = ini.ataque(dadosInimigo[posicao][1]);
            System.out.println("O "+dadosInimigo[posicao][1]+" acertou você com "+a+" pontos de dano. \n");
            a = p.vida(a, i.listaarmadura());
            return dadosInimigo[posicao][1];
        }
        else{
            System.out.println("Você matou o "+dadosInimigo[posicao][1]+"\n");
            return "N";
        }
       
    }
   
    public void geraInimigo(String Tipo, int posicao, int nDirecao){
       
        int a=0;
       
        for(int i=0; i<1000; i++){
            if(dadosInimigo[i][1].equals("N")){
                dadosInimigo[i][1] = Tipo;
                dadosInimigo[i][2] = ""+posicao;
                dadosInimigo[i][3] = ""+nDirecao;
                a = ini.vida(Tipo);
                dadosInimigo[i][4] = ""+a;
                break;
            }
        }
    }
   
    public void listaMochila(){
       
        String aux="";
        String a="";
        aux=i.listaarma();
        a+="Arma: "+aux+"\n";
        aux=i.listaarmadura();
        a+="Armadura: "+aux+"\n";
        aux=i.listatesouro();
        a+="Tesouro: "+aux+"\n";
        System.out.println(a);
    }
   
    // GERA O DANO POR PASSAR EM UM ARMADILHA NÃO DESARMADA
    public void danoArmadilha(){
       
        System.out.println("Você não desarmou a armadilha e foi vítima dela. \n");
       
        // calcula o dano
        int dano = (int) (1+(Math.random() * 10));
       
        // cria o objeto da classe personagem para enviar o dano inflingido pela armadilha
        personagem p = new personagem();
        dano = p.vida(dano, i.listaarmadura());
    }
   
}
------------------------------------------------------------------------------------------


Classe Inimigo. Gera e controla os inimigos no jogo.


------------------------------------------------------------------------------------------

package Labirinto;

public class inimigo {
   
    public String Tipo(){
        String inimigo="";
        int a = (int) (1+(Math.random() * 8));
        switch(a){
            case 1: inimigo = "Goblin"; break;
            case 2: inimigo = "Orc"; break;
            case 3: inimigo = "Trol"; break;
            case 4: inimigo = "N"; break;
            case 5: inimigo = "N"; break;
            case 6: inimigo = "N"; break;
            case 7: inimigo = "N"; break;
            case 8: inimigo = "N"; break;
        }
        return inimigo;
    }

    // gera atque do inimigo
    public int vida(String inimigo){
        int a=0;
        if(inimigo.equals("Goblin")){
            a = (int) (2 + (Math.random() * 2));
        }
        if(inimigo.equals("Orc")){
            a = (int) (3 + (Math.random() * 3));
        }
        if(inimigo.equals("Trol")){
            a = (int) (4 + (Math.random() * 4));
        }
        return a;
    }
   
    // Gera ataque do inimigo
    public int ataque(String inimigo){
        int a=0;
        if(inimigo.equals("Goblin")){
            a = (int) (1 + (Math.random() * 2));
        }
        if(inimigo.equals("Orc")){
            a = (int) (2 + (Math.random() * 3));
        }
        if(inimigo.equals("Trol")){
            a = (int) (4 + (Math.random() * 3));
        }
        return a;
    }
}
------------------------------------------------------------------------------------------


Classe Inventário. Gera, controla e mostra o inventário do jogador.


------------------------------------------------------------------------------------------

package Labirinto;

import java.util.Scanner;

public class inventario {
    
    public String inventario[][]=new String[2][4];
    // 1 - arma;
    // 2 - tesouro;
    // 3 - armadura;

    public void criaInventario(){
        inventario[1][1]="Faca";
        inventario[1][2]="Cura";
        inventario[1][3]="";
    }

    public String listaarma(){
        String aux =inventario[1][1];
        return aux;
    }
    public String listatesouro(){
        String aux =inventario[1][2];
        return aux;
    }
    public String listaarmadura(){
        String aux =inventario[1][3];
        return aux;
    }

    public String getarma(String a){
        Scanner entra = new Scanner(System.in);
        String aux ="";
        if (inventario[1][1].equals("")){
            inventario[1][1] = a;
        }
        else{
            aux +="Voce esta carregando "+inventario[1][1]+"\n";
            aux +="Deseja trocar por "+a+"? \n";
            aux +="Digite: S -> Sim; N-> Nao \n";
            System.out.println(aux);
            aux = entra.next();
            if(aux.equals("S")){
                inventario[1][1] = a;
            }
        }
        return inventario[1][1];
    }
    public String gettesouro(String a){
        Scanner entra = new Scanner(System.in);
        String aux ="";
        if (inventario[1][2].equals("")){
            inventario[1][2] = a;
        }
        else{
            aux +="Voce esta carregando "+inventario[1][2]+"\n";
            aux +="Deseja trocar por "+a+"? \n";
            aux +="Digite: S -> Sim; N-> Nao \n";
            System.out.println(aux);
            aux = entra.next();
            if(aux.equals("S")){
                inventario[1][2] = a;
            }
        }
        return inventario[1][2];
    }
    public String getarmadura(String a){
        Scanner entra = new Scanner(System.in);
        String aux ="";
        if (inventario[1][3].equals("")){
            inventario[1][3] = a;
        }
        else{
            aux +="Voce esta carregando "+inventario[1][3]+"\n";
            aux +="Deseja trocar por "+a+"? \n";
            aux +="Digite: S -> Sim; N-> Nao \n";
            System.out.println(aux);
            aux = entra.next();
            if(aux.equals("S")){
                inventario[1][3] = a;
            }
        }
        return inventario[1][3];
    }
}



------------------------------------------------------------------------------------------


Classe personagem: Cria e Controla os atributos do Personagem


------------------------------------------------------------------------------------------

package Labirinto;

class personagem {
    
    public String inventario="";
    public int vida=10, dano=3;
    
    public int vida(int dano, String Armadura){
        String a="";
        
        if(dano>0){
            
            a = Armadura;
            
            if(a.equals("Couro")){
                dano = dano - 1;
                System.out.println("Sua armadura de Couro absorveu 1 de dano \n");
            }
            if(a.equals("Metal")){
                dano = dano - 2;
                System.out.println("Sua armadura de Metal absorveu 2 de dano \n");
            }
            if(a.equals("Mithrill")){
                dano = dano - 3;
                System.out.println("Sua armadura de Mithrill absorveu 3 de dano \n");
            }                        
            vida = vida - dano;
        }
        else{
            vida = 10;
            System.out.println("Voce tomou uma pocao de cura.");
        }
        
        System.out.println("Vida: "+vida);
        
        if(vida <= 0){
            System.out.println("Voce morreu");
            System.exit(0);
        }
        
        return vida;
    }

    public int dano(String arma){
        
        int dano=2;
        if(arma.equals("Faca")){
            dano=4;
        }
        if(arma.equals("Espada")){
            dano=5;
        }
        if(arma.equals("Cimitarra")){
            dano=6;
        }

        dano = (int) (Math.random() * dano );

        return dano;
    }
}

------------------------------------------------------------------------------------------


Classe Tesouro: Cria e controla os tesouros do labirinto.


------------------------------------------------------------------------------------------

package Labirinto;

class tesouro {
    
    public String Chave(){
        String chave="";
        while (chave.equals("")){
            int a = (int) (1+(Math.random() * 8));
            switch(a){
                case 1:  chave = "Azul";     break;
                case 3:  chave = "Amarela";  break;
                case 5:  chave = "Verde";    break;
                case 7:  chave = "Vermelha"; break;
                default: chave = "N";
            }
        }
        return chave;
    }
    public String arma(){
        String arma="";
        while (arma.equals("")){
            int a = (int) (1+(Math.random() * 14));
            switch(a){
                case 1:  arma = "Faca";      break;
                case 3:  arma = "Cimitarra"; break;
                case 5:  arma = "Espada";    break;
                case 7:  arma = "Faca";      break;
                case 9:  arma = "Espada";    break;
                case 11: arma = "Faca";      break;
                default: arma = "N";
            }
        }        
        return arma;
    }    
    
    public String armadura(){
        String armadura="";
        while (armadura.equals("")){
            int a = (int) (1+(Math.random() * 14));
            switch(a){
                case 1:  armadura = "Couro";     break;
                case 3:  armadura = "Mitrhrill"; break;
                case 5:  armadura = "Metal";     break;
                case 7:  armadura = "Couro";     break;
                case 9:  armadura = "Metal";     break;
                case 11: armadura = "Couro";     break;
                default: armadura = "N";
            }
        }
        return armadura;
    }
    
    public String cura(){
        String pocao="";
        int a = (int) (1+(Math.random() * 10));
        switch(a){
            case 2:  pocao="Cura"; break;
            case 4:  pocao="Cura"; break;
            case 5:  pocao="Cura"; break;
            case 6:  pocao="Cura"; break;
            case 8:  pocao="cura"; break;
            default: pocao="N";
        }        
        return pocao;
    }
    public String fogodragao(){
        String pocao="";
        int a = (int) (1+(Math.random() * 10));
        switch(a){
            case 3:  pocao="Fogo"; break;
            case 5:  pocao="Fogo"; break;
            case 7:  pocao="Fogo"; break;
            default: pocao="N";
        }
        return pocao;
    }
}


------------------------------------------------------------------------------------------

sexta-feira, 12 de novembro de 2010

Tela para Urna Eletrônica

Um grande colega meu me fez um pedido de uma tela para urna eletrônica...

Nada muito complexo, bastava a tela, sem tratamento de botões.

São duas classes. Na Classe Main, está o método main(String args[]) que chama o run(). O método run() é responsável por criar a tela e deixá-la visível. A outra classe é a MyListener. Deixei ela com o lixo que o Eclipse cria... depois tem que ver se serão necessários os métodos ou não. No método keyReleased(KeyEvent e), tratei o problema de só aceitar números... Ele até escreve, mas apaga as letras, não permitindo elas. Logo abaixo, pode-se colocar um select no banco, ou qualquer outro repositório para verificar se o número digitado já existe. No caso de haver, pode-se chamar o método run() denovo, passando os parâmetros que foram encontrados. Pra isso, cria-se um segundo método run(String nome, String partido, String caminhoFoto, String numeroDigitado), igual ao que tá ali, mas que receba o que está indicado ali em cima. Completa os campos com os dados e corre pro abraço!




----------------------------------------------------------------------------------------------------------------

import java.awt.Font;

import javax.swing.ImageIcon;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JTextField;

public class Main {
      public static void main(String[] args) {
          Main m = new Main();
          m.run();
      }
    
      public void run(){
            JFrame f = new JFrame();
            f.setLayout(null);
          
            // Objeto Font para ajustar o tipo, estilo e tamanho da fonte
            Font t = new Font("Arial", Font.BOLD, 20);
          
            // insere as frases do candidato
            JLabel Nome = new JLabel("TIRIRICA");
            // utilizando o objeto Fnto para ajustar o texto
            Nome.setFont(t);
            // ajustar posição do elemento: (coluna, linha, largura, altura)
            Nome.setBounds(120, 50, 400, 20);
          
            JLabel Partido = new JLabel("PPB - Partido dos Palhaços Brasileiros");
            Partido.setFont(t);
            Partido.setBounds(120, 150, 400, 20);
          
            // insere a foto do candidato
            ImageIcon img_candidato = new ImageIcon("C:/TIRIRICA.JPG");
            JLabel Foto = new JLabel(img_candidato);
            Foto.setBounds(560, 50, 120, 120);

            // insere a caixa de texto que vai receber os números do teclado.
            JTextField caixa = new JTextField("");
            caixa.setBounds(120, 220, 560, 25);
            caixa.addKeyListener(new MyListener());
      
            // Objeto do botão Branco.
            JButton branco = new JButton("Branco");
            branco.setBounds(120, 300, 120, 25);

            // Objeto do botão Corrige
            JButton corrige = new JButton("Corrige");
            corrige.setBounds(340, 300, 120, 25);

            // Ibjeto do botão Confirma
            JButton confirma = new JButton("Confirma");
            confirma.setBounds(560, 300, 120, 25);          
          
            // adiciona as Labels
            f.add(Nome);
            f.add(Partido);
          
            // adiciona a foto
            f.add(Foto);
          
            // adiciona o JTextField
            f.add(caixa);
          
            // adiciona os botões
            f.add(branco);
            f.add(corrige);
            f.add(confirma);
          
            // tamanho da tela
            f.setSize(800, 400);
            f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
            f.setVisible(true);        
      }
}

----------------------------------------------------------------------------------------------------------------

import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;

import javax.swing.JTextField;

public class MyListener implements KeyListener { 
 
    public void keyTyped(KeyEvent e) { 
  
    } 
 
    public void keyPressed(KeyEvent e) { 
        
    } 
  
    public void keyReleased(KeyEvent e) { 
        Object source = e.getSource(); // pega o objeto que disparou a acao 
        if (source instanceof JTextField) { 
            JTextField txt = (JTextField) source; 
            try { 
                //testa se existem apenas numeros 
                Integer.parseInt(txt.getText());  
            }
            catch (NumberFormatException ex) { 
                //Pega a String que esta no textfield 
                String text = txt.getText(); 
                //retira o utimo caracter da string, que por sua vez nao e um numero 
                String newText = text.substring(0,text.length()-1); 
                txt.setText( newText ); 
            }
        }
       
        // trata aqui se o número digitado até então
        // coincide com os números dos possíveis candidatos
    } 
}

quarta-feira, 10 de novembro de 2010

Ler um arquivo de texto para criar um banco de dados:

Estou utilizando o Postgresql, novamente.

Segue o caso de uso:
------------------------------------------------------------
Objetivo do Trabalho:

Ler um arquivo texto com a descrição de um banco de dados e criar o
banco de dados e as tabelas correspondentes.

O formato do arquivo de entrada é definido da seguinte forma

TABELA <nome da tabela>
CAMPO <nome do campo> <tipo de dado> <tamanho do campo>
INDICE <nome do campo> <nome do campo> <nome do campo> ...

O arquivo pode conter várias tabelas, cada tabela pode conter vários
campos e vários índices. O "tamanho do campo" é opcional. O índice
pode conter vários nomes de campos.
------------------------------------------------------------
import java.io.FileInputStream;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Scanner;
import java.util.logging.Level;
import java.util.logging.Logger;


public class banco {

    public static void main(String args[]){
        banco BC = new banco();
        BC.leArquivo();
     
    }
 
    public void leArquivo(){
    
        String caminhonome=""; // serve para pegar o 'caminhonome' do arquivo
        String query = "";
        String aux = "";
        String nome[] = new String[100];
        String tipo[] = new String[1000];
        String tamanho[] = new String[1000];
        String separa[] = new String[1000];
        int i=0;
      
        //banco BC = new banco();
     
        Scanner entra = new Scanner(System.in);
        while(caminhonome.equals("")){
            System.out.println("Digite o caminho, nome e extensao do arquivo do Banco:");

            caminhonome = entra.next();         
        }
        try {
            FileInputStream fis = new FileInputStream(caminhonome);
            Scanner     scanner = new Scanner(fis);
          
            while (scanner.hasNext("TABELA")) {
                // pula a palavra "TABELA"
                scanner.next();
                // guarda o nome da tabela
                query += "CREATE TABLE "+scanner.next()+"(";
              
                while (scanner.hasNext("CAMPO")){
                   
                    // pula a palavra "CAMPO"
                    scanner.next();
                   
                    // guarda o nome do campo
                    nome[i] = scanner.next();                 
                   
                    // guarda o tipo da variável
                    tipo[i] = scanner.next();                 
                  
                    // guarda o tamanho da variável
                    tamanho[i] = "("+scanner.next()+")";                 
                  
                    if(scanner.hasNext("INDICE")){
                        scanner.next(); // pula a palavra INDICE
                        aux = scanner.next();
                        for(int j=0; j<i; j++){
                            if(nome[j].equals(aux)){
                                tamanho[j] += " PRIMARY KEY";
                            }
                        }
                    }
                    if(scanner.hasNext("CAMPO")){
                        separa[i] = ", ";
                        i++;
                    }                   
                }
                for(int y=0;y<i; y++){
                    if(y!=0){
                        query += separa[y];
                    }
                    query += nome[y];
                    query += " "+tipo[y];
                    query += " "+tamanho[y];
                }
                query += ");";

                // aqui será chamado o método para criar o banco.
                BC.criaBanco(query);
              
                query += "\n";
                System.out.println(query);
                query="";
               
                i=0;
            }
        }
        catch (Exception e) {
            System.out.println("Não foi possível ler o arquivo, erro de IO");
            System.exit(0);
        }
        System.out.println(query);
        System.exit(0);
    }
  
    public void criaBanco(String sql){
      
        // Cria a conexão com o banco de dados. Importante a IDE já estar setada para usar o banco
        try{
            Class.forName("org.postgresql.Driver");
        }catch(ClassNotFoundException e){
            System.out.println("Sem Driver");
            System.exit(1);
        }

        // cria a conexão
        Connection c = null;
        try {
            c = DriverManager.getConnection("jdbc:postgresql://localhost/postgres", "postgres", "senacrs");
        } catch (SQLException ex) {
            Logger.getLogger(banco.class.getName()).log(Level.SEVERE, null, ex);
        }
      
        // cria o statement
        Statement s = null;
        try {
            s = c.createStatement();
        } catch (SQLException ex) {
            Logger.getLogger(banco.class.getName()).log(Level.SEVERE, null, ex);
        }
             
        // faz a criação das tabelas a partir do comando lido anteriormente.
        try{
            s.executeUpdate(sql);
        }catch(SQLException ex){
            Logger.getLogger(banco.class.getName()).log(Level.SEVERE, null, ex);
        }
        System.out.println("Tabela Criada com Sucesso!");
    }
}

quarta-feira, 3 de novembro de 2010

Swing JAVA

Esse programinha bobo implementa uma interface Swing boba.
O legal dela é que já está orientada para implementações dinâmicas, ao fugir do static do método main.

Basicamente, há dois botões, um que adiciona e outro que subtrai o valor que é informado logo ao lado.

----------------------------------------------------------------------------------------------------------

import java.awt.Container;
import java.awt.FlowLayout;
import java.awt.LayoutManager;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.*;

class main implements ActionListener{
   
    JLabel hello;
    public int i=0;
    public String aux="0";
   

    public static void main(String args[]){
       
        new main().run(args);
       
    }
   
    public void run(String args[]){
       
        JFrame win = createUI();
        win.pack();
        win.setVisible(true);
    }
    public JFrame createUI(){
        JFrame win = new JFrame("Hello");
        hello = new JLabel(aux);
        Container pane = win.getContentPane();
       
        pane.setLayout(new FlowLayout());
        JButton button = new JButton("Adiciona");
        JButton butto2 = new JButton("Diminui");
       
        pane.add(button);
        pane.add(butto2);
        pane.add(hello);
       
        win.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
       
        button.addActionListener(this);
        butto2.addActionListener(this);
       
        button.setActionCommand("Mais");
        butto2.setActionCommand("Menos");
       
        return win;
       
    }
    public void actionPerformed(ActionEvent e){
       
       
        if(e.getActionCommand().equals("Mais")){
            i++;
        }
        else{
            i--;
        }
        aux=""+i;
       
        hello.setText(aux);
    }

}

quarta-feira, 13 de outubro de 2010

JDBC

Esse código visa fazer a ligação com um banco de dados Postgresql.
O jar para conexão com o banco é esse aqui:

http://www.postgresql.org/download/windows

---------------------------------------------------------------------------------------------------

package projetojdbc;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.logging.Level;
import java.util.logging.Logger;

public class Main {

    public static void main(String[] args) {
// Cria a conexão com o banco de dados. Importante a IDE já estar setada para usar o banco
       try{
           Class.forName("org.postgresql.Driver");
       }catch(ClassNotFoundException e){
           System.out.println("Sem Driver");
           System.exit(1);
       }
       System.out.println("Com Driver");



// cria a conexão
    Connection c = null;
        try {
            c = DriverManager.getConnection("jdbc:postgresql://localhost/postgres", "postgres", "senacrs");
        } catch (SQLException ex) {
            Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex);
        }
// cria o statement
    Statement s = null;
        try {
            s = c.createStatement();
        } catch (SQLException ex) {
            Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex);
        }
// cria o resultSet para usar Selects
    ResultSet rs = null;
        try {
            rs = s.executeQuery("SELECT * FROM ATENDENTE");
        } catch (SQLException ex) {
            Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex);
        }
// usa o resultset para update
     try{
        int executeUpdate = s.executeUpdate("UPDATE atendente SET nome='arthur' where nome=''");
        }catch(SQLException ex){
            Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex);
          
        }
// usa o prepare statement para insert
        try {
            PreparedStatement ps = c.prepareStatement("INSERT INTO ATENDENTE VALUES ('ARTHUR', 'ARTHUR', 'ARTHUR')");
        } catch (SQLException ex) {
            Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex);
        }
    }
}

quarta-feira, 22 de setembro de 2010

Protegendo Páginas em PHP

Então,
Agora que o Blog não é mais exclusivo JAVA, vou começar com uma aplicação de Login (todos já fizemos), com páginas diferentes para Administrador e Funcionários (nem todos já fiseram), protegidas para que não se possa acessar nenhuma URL além da tela inicial (quase ninguém faz).

------------------------------------------------------------------------------------------
config.php - Serve para configurar a conexão com o banco de dados.
------------------------------------------------------------------------------------------
<?php
$host = "localhost"; //Servidor do mysql
$user = "root"; //Usuario do banco de dados
$senha = ""; //senha do banco de dados
$db = "user"; //banco de dados
$nome_site = "login.php"; //Nome do site
$email = "email@host.com"; //E-mail do administrador
$site = "http://www.meusite.com"; //Seu site n se esuqece de bota o http://

mysql_connect($host, $user, $senha) or die (mysql_error());
mysql_select_db($db) or die (mysql_error());
?>

------------------------------------------------------------------------------------------

login.php - Página Principal
------------------------------------------------------------------------------------------
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
<title>Document sans titre</title>
<style type="text/css">
<!--
.Style6 {font-size: 13px}
-->
</style>
</head>

<body>
<form id="form1" name="form1" method="post" action="../login/logar.php">
  <table width="41%" border="0">
    <tr>
      <td colspan="2"><div align="center"><strong>Usuario</strong></div></td>
    </tr>
    <tr>
      <td><span class="Style6">Login:</span></td>
      <td><span class="Style6">
        <label>
        <input name="login" type="text" id="login" />
        </label>
      </span></td>
    </tr>
    <tr>
      <td><span class="Style6">Senha:</span></td>
      <td><span class="Style6">
        <label>
        <input name="senha" type="password" id="senha" />
        </label>
      </span></td>
    </tr>
    <tr>
      <td>&nbsp;</td>
      <td><span class="Style6">
        <label>
        <input type="submit" name="Submit" value="OK" />
        </label>
      </span></td>
    </tr>
    <tr>
      <td>&nbsp;</td>
      <td><span class="Style6"><a href="../login/esquece_senha.php">Esquece senha </a></span></td>
    </tr>
    <tr>
      <td>&nbsp;</td>
      <td><span class="Style6"><a href="../login/cadastro.php">Cadastro</a></span></td>
    </tr>
  </table>
</form>
</body>
</html>

------------------------------------------------------------------------------------------

logar.php - Página que irá trabalhar os dados do Login
------------------------------------------------------------------------------------------
<?php
require("bloquear.php");
trancar_pagina("logar.php");
?>
<?php
include("config.php");

$login = $_POST['login'];
$senha = $_POST['senha'];

/* Verifica se existe usuario, o segredo ta aqui quando ele procupa uma
linha q contenha o login e a senha digitada */
$sql_logar = "SELECT * FROM user WHERE login = '$login' && senha = '$senha'";
$exe_logar = mysql_query($sql_logar) or die (mysql_error());
$fet_logar = mysql_fetch_assoc($exe_logar);
$num_logar = mysql_num_rows($exe_logar);

//Verifica se n existe uma linha com o login e a senha digitado
if ($num_logar == 0){
   echo "Login ou senha invalido.";
   echo "<br><a href='javascript:window.history.go(-1)'>Clique aqui para volta.</a>";  
}
elseif($fet_logar['activo'] == "N"){
   echo "Usuario não ativado, verifique seu e-mail para ativa a conta.";
   echo "<br><a href='javascript:window.history.go(-1)'>Clique aqui para volta.</a>";
}
else{
   //Cria a sessão e manda pra pagina principal.php
   session_start();
   $_SESSION['login'] = $login;
   $_SESSION['senha'] = $senha;
  
    if ($fet_logar['Tipo'] == "A"){
        header("Location:administrador.php");
    }
    else{
        header("Location:funcionario.php");
    }
}
?>
------------------------------------------------------------------------------------------

Cadastro.php - Cadastro de novo funcionário no banco
------------------------------------------------------------------------------------------
<?php
require("bloquear.php");
trancar_pagina("cadastro.php");
?>
<?php

include("config.php");

if (isset($_POST['login'])){

   //pega a sessão id do usuario
   session_start();
   $sessao = session_id();
   $login = $_POST['login'];
   $senha = $_POST['senha'];
   $nome  = $_POST['nome'];
   $email = $_POST['email'];

   $sql_busca = "SELECT * FROM user WHERE login = '$login'";
   $exe_busca = mysql_query($sql_busca) or die (mysql_error());
   $num_busca = mysql_num_rows($exe_busca);

   $sql_busca2 = "SELECT * FROM user WHERE email = '$email'";
   $exe_busca2 = mysql_query($sql_busca2) or die (mysql_error());
   $num_busca2 = mysql_num_rows($exe_busca2);

   //Verifica se os campos estão preenchidos
   if ($_POST['login'] == "" || $_POST['senha'] == "" || $_POST['senha2'] == "" || $_POST['nome'] == "" || $_POST['email'] == "" || $_POST['Tipo'] == ""){
      $ac[] = "Por favou preencha todos os campos corretamente.";
   }
   //Verifica se ja existe o login
   if ($num_busca > 0){
      $ac[] = "Esse login já esta sendo usado por outro usuario.";
   }
   //Verifica se ja existe o e-mail
   if ($num_busca2 > 0){
      $ac[] = "Esse e-mail já esta sendo usado por outro usuario.";
   }
   //Verifica se o e-mail esta correto
   if (!ereg("@.", $_POST['email'])){
      $ac[] = "E-mail invalido.";
   }
   //Verifica se as duas senha são diferente
   if ($_POST['senha'] != $_POST['senha2']){
      $ac[] = "Verifique se as duas senha estão correta.";
   }
   //Verifica se todas estão corretas
   if (!isset($ac)){
      //Inclui o cadastro no mysql
      $sql_inclu = "INSERT INTO user(login, senha, email, sessao) VALUES
                    ('$login', '$senha', '$email', '$sessao')";
      $exe_inclu = mysql_query($sql_inclu) or die (mysql_error());
        $sql_inclui = "INSERT INTO nome(nome) VALUES('$nome')";
      $exe_inclui = mysql_query($sql_inclui) or die (mysql_error());
     
      $topico = "Cadastro $nome_site";
      $mensagem = "<html>";
      $mensagem .= "<body>";
      $mensagem .= "Olá $login\r\n";
      $mensagem .= "<br>Você efetuou um cadastro no $nome_site.</br>";
      $mensagem .=    "<br>Login: $login";
      $mensagem .=    "<br>Senha: $senha";
      $mensagem .=    "<br>Ativar conta <a href='$site/active.php?ac=$sessao'>$site/active.php?ac=$sessao</a></br>";
      $mensagem .=    "</body>";
      $mensagem .=    "</html>";
      $headers = "MIME-Version: 1.0\r\n";
      $headers .= "Content-type: text/html; charset=iso-8859-1\r\n";
      $headers .= "From: $nome_site <$email>\r\n";
      $ac[] = "Cadastro efetuado com sucesso, verifique seu e-mail para ativa a conta.";
      //enviar para o email o login, senha e o codigo de ativação
      mail($email, $topico, $mensagem, $headers);
   }
}
?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
<title>Document sans titre</title>
<style type="text/css">
<!--
.Style2 {font-size: 13px}
-->
</style>
</head>
<body>
<?php
if (isset($ac)){
   for($i=0;$i<count($ac);$i++){
      echo "<li>".$ac[$i];
   }
}
?>
<form id="form1" name="form1" method="post" action="<? $_SERVER['file:///C|/DOCUME~1/admin/CONFIG~1/Temp/Rar$DI05.687/PHP_SELF']?>">
  <table width="100%" border="0">
    <tr>
      <td colspan="2"><div align="center"><strong>Cadastro</strong></div></td>
    </tr>
    <tr>
      <td width="13%"><span class="Style2">Login:</span></td>
      <td width="87%"><span class="Style2">
        <label>
        <input name="login" type="text" id="login" />
        </label>
      </span></td>
    </tr>
    <tr>
      <td><span class="Style2">Senha:</span></td>
      <td><span class="Style2">
        <label>
        <input name="senha" type="password" id="senha" />
        </label>
      </span></td>
    </tr>
    <tr>
      <td><span class="Style2">Repetir senha: </span></td>
      <td><span class="Style2">
        <label>
        <input name="senha2" type="password" id="senha2" />
        </label>
      </span></td>
    </tr>
    <tr>
      <td><span class="Style2">Nome: </span></td>
      <td><span class="Style2">
        <label>
        <input name="Nome" type="text" id="nome" />
        </label>
      </span></td>
    </tr>   
    <tr>
      <td><span class="Style2">E-mail:</span></td>
      <td><span class="Style2">
        <label>
        <input name="email" type="text" id="email" />
        </label>
      </span></td>
    </tr>
    <tr>
    <td><span class="Style2">Tipo:</span></td>
      <td><label>
      <input type="radio" name="Tipo" id="af" value="A" />
      Administrador
      <input type="radio" name="Tipo" id="af" value="F" />
      Funcionário</label></td>
    </tr>
    <tr>
      <td>&nbsp;</td>
      <td><span class="Style2">
        <label>
        <input type="submit" name="Submit" value="Enviar" />
        </label>
      </span></td>
    </tr>
  </table>
  <p>&nbsp;</p>
</form>
</body>
</html>

------------------------------------------------------------------------------------------

esquece_senha.php - Recuperação de Senha
------------------------------------------------------------------------------------------
<?php
include("config.php");

if (isset($_POST['login'])){
   $login = $_POST['login'];
   //Verifica se existe usuario
   $sql_busca = "SELECT * FROM user WHERE login = '$login'";
   $exe_busca = mysql_query($sql_busca) or die (mysql_error());
   $fet_busca = mysql_fetch_assoc($exe_busca);
   $num_busca = mysql_num_rows($exe_busca);
   //verifica se existe uma linha com o login digitado
   if ($num_busca > 0){
      $email = $fet_busca['email'];
      $senha = $fet_busca['senha'];
      $topico = "Esquece senha";
      $mensagem = "<html>";
      $mensagem .= "<body>";
      $mensagem .= "<br>Você efetuou um pedido de recuperação de senha no $nome_site.</br>";
      $mensagem .=    "<br>Login: $login";
      $mensagem .=    "<br>Senha: $senha</br>";
      $mensagem .= "<br>Site oficial do $nome_site";
      $mensagem .=    "<br><a href='$site'>$site</a></br>";
      $mensagem .=    "</body>";
      $mensagem .=    "</html>";
      $headers = "MIME-Version: 1.0\r\n";
      $headers .= "Content-type: text/html; charset=iso-8859-1\r\n";
      $headers .= "From: $nome_site <$email>\r\n";
     
      //enviar para o email o login e a senha
      mail($email, $topico, $mensagem, $headers);
      $ac[] = "Sua senha foi enviado para seu e-mail.";
   }
   else {
      $ac[] = "Esse login não existe.";
   }
}
?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
<title>Document sans titre</title>
<style type="text/css">
<!--
.Style2 {font-size: 13px}
-->
</style>
</head>

<body>
<?php
if (isset($ac)){
   for($i=0;$i<count($ac);$i++){
      echo "<li>".$ac[$i];
   }
}
?>
<form id="form1" name="form1" method="post" action="<? $_SERVER['file:///C|/DOCUME~1/admin/CONFIG~1/Temp/Rar$DI57.031/PHP_SELF']?>">
  <table width="33%" border="0">
    <tr>
      <td colspan="2"><div align="center"><strong>Esquece senha </strong></div></td>
    </tr>
    <tr>
      <td width="22%"><span class="Style2">Login:</span></td>
      <td width="78%"><span class="Style2">
        <label>
        <input name="login" type="text" id="login" />
        </label>
      </span></td>
    </tr>
    <tr>
      <td>&nbsp;</td>
      <td><span class="Style2">
        <label>
        <input type="submit" name="Submit" value="Enviar" />
        </label>
      </span></td>
    </tr>
  </table>
</form>
</body>
</html>

------------------------------------------------------------------------------------------

restrito.php - faz a sessão ser restrita a usuários
------------------------------------------------------------------------------------------
<?php
@session_start();
if (isset($_SESSION['login']) && isset($_SESSION['senha'])){
   $login_usuario = $_SESSION['login'];
}
else {
   header("Location:login.php");
   exit();
}
?>

------------------------------------------------------------------------------------------

bloquear.php - Impede que seja acessada qualquer URL diretamente.
------------------------------------------------------------------------------------------
<?php
function trancar_pagina($nome){
    if (eregi("$nome", $_SERVER['SCRIPT_NAME'])){
        header("Location:login.php");
    }
}
?>
------------------------------------------------------------------------------------------

administrador.php - Trata os direitos do Administrador
------------------------------------------------------------------------------------------
<?php
require("bloquear.php");
trancar_pagina("administrador.php");
?>
<?php
include('config.php');

$editFormAction = $_SERVER['PHP_SELF'];
if (isset($_SERVER['QUERY_STRING'])) {
  $editFormAction .= "?" . htmlentities($_SERVER['QUERY_STRING']);
}

if ((isset($_POST["MM_insert"])) && ($_POST["MM_insert"] == "form1")) {
  mysql_select_db($db);
  $login = $_POST['login'];
  $v2      = $_POST['email'];
  $v3      = $_POST['radio1'];
  $v4      = $_POST['Pontos'];
  
  $updateSQL = "UPDATE user SET email='$v2', activo='$v3', Pontos='$v4' WHERE login = '$login'";

  $Result1 = mysql_query($updateSQL) or die(mysql_error());
 
  echo "Dados alterados com sucesso! <br>";
}

mysql_select_db($db);
$query_manu1 = "SELECT * FROM user";
$manu1 = mysql_query($query_manu1) or die(mysql_error());
$row_manu1 = mysql_fetch_assoc($manu1);
$totalRows_manu1 = mysql_num_rows($manu1);
?>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>Untitled Document</title>
</head>

<body>

Olá <?php
include("config.php");
include("restrito.php");

$sql_busca = "SELECT * FROM user WHERE login = '$login_usuario'";
$exe_busca = mysql_query($sql_busca) or die (mysql_error());
$fet_busca = mysql_fetch_assoc($exe_busca);
$qtd_registros = mysql_num_rows($exe_busca); // retorna a quantidade registros encontrados na consulta acima
$nome = array();

 for($i=0;$i<$qtd_registros;$i++)
{
     $nome[$i] = mysql_result($exe_busca,$i,"login"); // a função mysql_result tem 3 parâmetros: 1º aponta para a variável da consulta; 2º aponta para a linha do registro que você quer pegar; 3º aponta para a coluna que você quer pegar na tabela
    echo $nome[$i]."<br>";   
}
?>
<br>
Você Possui  <?php
include("config.php");
include("restrito.php");

$sql_busca = "SELECT * FROM user WHERE login = '$login_usuario'";
$exe_busca = mysql_query($sql_busca) or die (mysql_error());
$fet_busca = mysql_fetch_assoc($exe_busca);
$qtd_registros = mysql_num_rows($exe_busca); // retorna a quantidade registros encontrados na consulta acima
$nome = array();

 for($i=0;$i<$qtd_registros;$i++)
{
     $nome[$i] = mysql_result($exe_busca,$i,"pontos"); // a função mysql_result tem 3 parâmetros: 1º aponta para a variável da consulta; 2º aponta para a linha do registro que você quer pegar; 3º aponta para a coluna que você quer pegar na tabela
    echo $nome[$i]." pontos! <br>";   
}
?> 
<br>
Alteração de Pontos:
<br><br>

<form action="<?php echo $editFormAction; ?>" method="post" name="form1" id="form1">
  <table>
    <tr valign="baseline">
      <td nowrap="nowrap" align="right">Login:</td>
      <td><select name="login">
        <?php
do { 
?>
        <option value="<?php echo $row_manu1['login']?>" ><?php echo $row_manu1['login']?></option>
        <?php
} while ($row_manu1 = mysql_fetch_assoc($manu1));
?>
  </select></td>
    </tr>
    <tr> </tr>
    <tr valign="baseline">
      <td nowrap="nowrap" align="right">Email:</td>
      <td><input type="text" name="email" value="" size="32" /></td>
    </tr>
    <tr valign="baseline">
      <td nowrap="nowrap" align="right">Activo:</td>
      <td><label>
      <input type="radio" name="radio1" id="sn" value="S" />
      Sim
      <input type="radio" name="radio1" id="sn" value="N" />
      Não</label></td>
    </tr>
    <tr valign="baseline">
      <td nowrap="nowrap" align="right">Novos Pontos:</td>
      <td><input type="text" name="Pontos" value="" size="32" /></td>
    </tr>
    <tr valign="baseline">
      <td nowrap="nowrap" align="right">Tipo:</td>
      <td><label>
      <input type="radio" name="radio2" id="af" value="A" />
      Administrador
      <input type="radio" name="radio2" id="af" value="F" />
      Funcionário</label></td>
    </tr>
    <tr valign="baseline">
      <td nowrap="nowrap" align="right">&nbsp;</td>
      <td><input type="submit" value="Alterar" /></td>
    </tr>
  </table>
  <input type="hidden" name="MM_insert" value="form1" />
</form>
<br><br>
  <table width="41%" border="0">
    <tr>
      <td>&nbsp;</td>
      <td><span class="Style6"><a href="../login/login.php">Sair </a></span></td>
    </tr>
  </table>

<p>&nbsp;</p>
</body>
</html>
<?php
mysql_free_result($manu1);
?> 
------------------------------------------------------------------------------------------

funcionario.php - Trata os direitos dos Funcionarios
------------------------------------------------------------------------------------------
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>Untitled Document</title>
</head>

<body>

<?php
require("bloquear.php");
trancar_pagina("funcionario.php");
?>


Olá <?php
include("config.php");
include("restrito.php");

$sql_busca = "SELECT * FROM user WHERE login = '$login_usuario'";
$exe_busca = mysql_query($sql_busca) or die (mysql_error());
$fet_busca = mysql_fetch_assoc($exe_busca);
$qtd_registros = mysql_num_rows($exe_busca); // retorna a quantidade registros encontrados na consulta acima
$nome = array();

 for($i=0;$i<$qtd_registros;$i++)
{
     $nome[$i] = mysql_result($exe_busca,$i,"login");
/*     a função mysql_result tem 3 parâmetros:
        1º aponta para a variável da consulta;
     2º aponta para a linha do registro que você quer pegar;
     3º aponta para a coluna que você quer pegar na tabela */
    echo $nome[$i]."<br>";   
}
?>
<br>
Você Possui  <?php
include("config.php");
include("restrito.php");

$sql_busca = "SELECT * FROM user WHERE login = '$login_usuario'";
$exe_busca = mysql_query($sql_busca) or die (mysql_error());
$fet_busca = mysql_fetch_assoc($exe_busca);
$qtd_registros = mysql_num_rows($exe_busca); // retorna a quantidade registros encontrados na consulta acima
$nome = array();

 for($i=0;$i<$qtd_registros;$i++)
{
     $nome[$i] = mysql_result($exe_busca,$i,"pontos"); // a função mysql_result tem 3 parâmetros: 1º aponta para a variável da consulta; 2º aponta para a linha do registro que você quer pegar; 3º aponta para a coluna que você quer pegar na tabela
    echo $nome[$i]." pontos! <br><br>";   
}

?>
  <table width="41%" border="0">
    <tr>
      <td>&nbsp;</td>
      <td><span class="Style6"><a href="../login/login.php">Sair </a></span></td>
    </tr>
  </table>
</body>
</html>