Analise do Código

Wisintainer · 21 de setembro de 2010

Boa tarde, amigos do fórum.

Sou acedêmico do curso de Ciência da Computação da UNIVALI - SC, primeiro período.

Estou fazendo um jogo simples, ao estilo Arkanoid em c++ utilizando biblioteca Allegro.

Gostaria que vocês me ajudassem a descobrir por que o laço da linha 42 só acontece uma vez ( linha: void rebate_bola(){

if(bola_y == 474 and bola_x > mouse_x and bola_x < mouse_x + 125 ){

direcao_y = -1;

}

)

, ou seja no caso do jogo, a bolinha só rebate uma vez no rebatedor, depois passa direto.


#include <allegro.h>

BITMAP* quadrado;
BITMAP* bolinha;
BITMAP* bloco;
BITMAP* buffer;


int x=0;
int direcao_y = 1;
int direcao_x = 1;
int bola_x = 200;
int bola_y = 200;
int blocos[6][10] =


{{1,1,1,1,1,1,1,1,1,1},
 {1,1,1,1,1,1,1,1,1,1},
 {1,1,1,1,1,1,1,1,1,1}};

int a=0;
int b=0;
int vidas = 2;






// funcao para ler as teclas
void ler_teclas(){
    if(key[KEY_LEFT]){
            x= x - 2;
	}
	else if(key[KEY_RIGHT]){
        x = x + 2;
	}
}

void rebate_bola(){

	if(bola_y == 474 and bola_x > mouse_x and bola_x < mouse_x + 125 ){
	direcao_y = -1;

	}




    if(bola_x >= 780){
        direcao_x = -1;

    }

    if(bola_y <=0){
        direcao_y = + 1;

    }

    if(bola_x <= 0){
        direcao_x = + 1;

	}

        if(bola_y <=100){
             a = bola_x / 80;
             b = bola_y / 20;
            blocos [b][a]= 0;


            //blocos_2 [a]= 0;
            //blocos_3 [a]= 0;

        }



}


void logica_do_jogo(){
    bola_x = bola_x + direcao_x;
    bola_y = bola_y + direcao_y;

    rebate_bola();

}

void desenha(){


    blit(quadrado, buffer, 0, 0 , mouse_x, 500, 135, 56);


    // blit(bolinha, buffer, 0, 0 , 0, 0, 135, 56);
    draw_sprite(buffer, bolinha, bola_x, bola_y);

  for(int i=0; i <3; i++){
    for(int j =0; j < 10; j++){


        if(blocos[i][j] == 0){
             direcao_y = 1;
            continue;
        }

        blit(bloco, buffer ,0, 0, 80 * j,20 * i, 80, 20);





	}
  }

}








int main(){
    allegro_init();
    //instruções para a inicialização da tela no Allegro

    set_color_depth(32);
    set_gfx_mode(GFX_AUTODETECT_WINDOWED, 800, 600, 0, 0);

    install_keyboard();
    install_mouse();
    buffer = create_bitmap(800, 600);
    quadrado = load_bmp("quadrado.bmp", NULL);
    bolinha = load_bmp("bolinha.bmp", NULL);
    bloco = load_bmp("bloco.bmp", NULL);




    while(!key[KEY_ESC]){
        ler_teclas();


        clear(buffer);
        logica_do_jogo();
		desenha();


        blit(buffer, screen, 0, 0 , 0, 0, 800, 600);
    }


    allegro_exit();
    return 0;
}   END_OF_MAIN();

Wisintainer · 21 de setembro de 2010

Perdoem a identação...

barutaji · 21 de setembro de 2010

Pelo que vi acho até estranho que o programa tenha rodado.

"and" não faz parte da notação C e C++, tem que usar "&&".

E aquele END_OF_MAIN(); também não faz muito sentido para mim, o que seria isso? O programa já acabou, essa linha não vai ser executada e o compilador vai ficar reclamando sobre o protótipo da função.

Wisintainer · 21 de setembro de 2010

Essa linha é da biblioteca Allegro. Estou usando C++ para utilizar and e or

Alguem pode ajudar?

barutaji · 21 de setembro de 2010

void desenha(){


    blit(quadrado, buffer, 0, 0 , mouse_x, 500, 135, 56);


    // blit(bolinha, buffer, 0, 0 , 0, 0, 135, 56);
    draw_sprite(buffer, bolinha, bola_x, bola_y);

  for(int i=0; i <3; i++){
    for(int j =0; j < 10; j++){


        if(blocos[i][j] == 0){
             direcao_y = 1;
            continue;
        }

        blit(bloco, buffer ,0, 0, 80 * j,20 * i, 80, 20);





	}
  }

}

Essa função é executada 1 vez por "ciclo". Depois que bateu em um bloco qualquer 1 vez, sempre vai haver um elemento em que "if(blocos[j] == 0)" vai ser verdadeiro. A bola não vai mais conseguir subir depois que bateu em qualquer bloco, pois essa função elimina o avanço e troca o sentido de novo, eternamente. Procede?

Mesmo que não seja isso, mudar o sentido de movimento dentro de uma função "desenhar" deixa o código confuso, pelo menos ninguem vai procurar uma coisa dessas aí dentro.

Outra coisa que eu vi:


if(bola_y <=100){
    a = bola_x / 80;
    b = bola_y / 20;
    blocos [b][a]= 0;
}

Desse jeito a bola nunca vai passar da primeira linha, pois não está verificando se o valor já é 0 ou não.

E sobre o END_OF_MAIN(); ele fica ali mesmo? Depois que o main já foi fechado? Que estranho. Uma biblioteca só consegue fornecer comandos dentro da notação, como poderiam fazer isso?

Bom, como deu pra ver não conheço a implementação do allegro, estou apenas tentando ver a lógica, então se disse algo que não procede, desconsidere.

Wisintainer · 22 de setembro de 2010

barutaji, entendi o que você quis dizer, mas ao seu ver como posso corrigir este problema?

DarkBlur · 22 de setembro de 2010

So uma duvida. Esta Key (onte há if(!Key...) é uma função/metodo padrão da Biblioteca allegro?

Estou fazendo um trabalho que é um jogo de nave, e para poder fazer a coisa funcionar tive de usar o comando KBHIT (if (kbhit)) << "Se pressionada uma tecla", até o então deu tudo certo, mas caso eu consiga aprender Allegro em um mês sou capaz de desfazer todo o meu codigo para implementar esta biblioteca.

Grato

barutaji · 22 de setembro de 2010

Bom, não sei como seria o código final, mas algumas idéias:

-A função rebatebola vai ter que ser responsável por todo o processo de definição do movimento futuro, os dados vão entrar e ao sairem já vão ser os valores finais para serem usados no próximo ciclo.

-A parte do "rebatimento" na altura dos blocos vai ser a parte mais difícil, você tem que avaliar sua posição atual e como está o "estado" do bloco no qual você vai bater. Se for 0 continua, se 1 muda estado do bloco e muda o sentido dos ponteiros. Isso dificulta porque essa mudança pode ser em todos os sentidos, como nos casos em que fica um "muro" na primeira fileira e a bola fica rebatendo lá em cima. Talvez valha a pena criar uma função só para controlar isso: assim que o y passa do ponto 100 é ativada a função responsável por cuidar dos rebatimentos nos blocos. Ou talvez não compense, você que sabe.

-Ah, outra coisa, não vi nada que controle a "morte" (se y passar do ponto permitido) e o contador de vidas. Teria que implementar também.

-De resto eu manteria como já está: analisa a situação presente, programa atualização de estados, executa a atualização, repassa as alterações para a tela e reinicia o ciclo.

DarkBlur · 22 de setembro de 2010

Bom, não sei como seria o código final, mas algumas idéias:
-A função rebatebola vai ter que ser responsável por todo o processo de definição do movimento futuro, os dados vão entrar e ao sairem já vão ser os valores finais para serem usados no próximo ciclo.

-A parte do "rebatimento" na altura dos blocos vai ser a parte mais difícil, você tem que avaliar sua posição atual e como está o "estado" do bloco no qual você vai bater. Se for 0 continua, se 1 muda estado do bloco e muda o sentido dos ponteiros. Isso dificulta porque essa mudança pode ser em todos os sentidos, como nos casos em que fica um "muro" na primeira fileira e a bola fica rebatendo lá em cima. Talvez valha a pena criar uma função só para controlar isso: assim que o y passa do ponto 100 é ativada a função responsável por cuidar dos rebatimentos nos blocos. Ou talvez não compense, você que sabe.

-Ah, outra coisa, não vi nada que controle a "morte" (se y passar do ponto permitido) e o contador de vidas. Teria que implementar também.

-De resto eu manteria como já está: analisa a situação presente, programa atualização de estados, executa a atualização, repassa as alterações para a tela e reinicia o ciclo.

Referente ao teste dos blocos a serem "acertados", eu faria da seguinte forma. Criaria uma matriz para a parte logica do jogo, quando y<N (onde N é o limite em que se inicia os campos onde há blocos a serem acertados) iria chamar a função de teste de colisão. Este teste de colisão voce tera de fazer da seguinte forma: voce tem que testar as diagonais (pois a bolinha nunca vai no sentido reto) se a diagonal for 1, então voce tera que apagar o campo desta diagonal, tera que chamar a função que a bolinha rebate e iniciar a movimentação, e consequentemente os testes novamente de colisão de bloco. É importante ter atenção no seguinte: 0 para vazio, 1 para "tijolo" e 2 , por exemplo, para a margem da area de jogo.

no seu codigo eu não entendi o por que você fez:



if (bola_y <=100)
{
      a=bola_x /80;
      b=bola_y / 20;
      blocos [b][a] = 0;
}

Entendi até onde y<100 ou seja, se estiver na area dos quadrados correto? Por isso dei a ideia da matriz, pois nem sempre você terá algo no caminho do curso. O Que nao entendi mesmo é a divisão por 80 e 20.

Wisintainer · 23 de setembro de 2010

DarkBlur tudo bem?

Sim o if(!Key...)é uma função da biblioteca Allegro. Eu estava fazendo o jogo em modo console, mas depois de uma aula de Allegro que tivermos migrei o código achei mais satisfatório o resultado.

Quanto a adaptação vou tentar fazer aqui e posto os resultados. Obrigado por enquanto.