terça-feira, 30 de novembro de 2010
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
Nada muito complexo, bastava a tela, sem tratamento de botões.
----------------------------------------------------------------------------------------------------------------
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:
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
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);
}
}
segunda-feira, 25 de outubro de 2010
quarta-feira, 13 de outubro de 2010
JDBC
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
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> </td>
<td><span class="Style6">
<label>
<input type="submit" name="Submit" value="OK" />
</label>
</span></td>
</tr>
<tr>
<td> </td>
<td><span class="Style6"><a href="../login/esquece_senha.php">Esquece senha </a></span></td>
</tr>
<tr>
<td> </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> </td>
<td><span class="Style2">
<label>
<input type="submit" name="Submit" value="Enviar" />
</label>
</span></td>
</tr>
</table>
<p> </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> </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"> </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> </td>
<td><span class="Style6"><a href="../login/login.php">Sair </a></span></td>
</tr>
</table>
<p> </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> </td>
<td><span class="Style6"><a href="../login/login.php">Sair </a></span></td>
</tr>
</table>
</body>
</html>