C Score para jogo do tipo pong em C

[joao victor caixeta costa]

estou fazendo um trabalho para a faculdade e preciso fazer um jogo em linguagem C utilizando a biblioteca Alegro, o jogo ja esta basicamente pronto, fiz em formato jogo pong padrão, mas gostaria de adicionar um contador de pontos, um placar ao jogo mesmo, mas não exatamente como implementar isso na tela do jogo, se alguém souber como fazer seria de grande ajuda, obrigado. segue o código até agora do jogo

#include <stdio.h>
#include <allegro5/allegro.h>
#include <allegro5/allegro_image.h>
#include <allegro5/allegro_acodec.h>
#include <allegro5/allegro_audio.h>


const float FPS = 60;

const int SCREEN_W = 1024;

const int SCREEN_H = 546;

const int BOLA_TAMANHO = 32;

const int REBATEDOR_LARGURA = 32;

const int REBATEDOR_ALTURA = 32;


int main(int argc, char **argv)
{
   ALLEGRO_DISPLAY *display = NULL;

   ALLEGRO_EVENT_QUEUE *event_queue = NULL;

   ALLEGRO_TIMER *timer = NULL;

   ALLEGRO_BITMAP *treinador = NULL;

   ALLEGRO_BITMAP *pokemon = NULL;

   ALLEGRO_BITMAP *bola = NULL;

   ALLEGRO_BITMAP *background = NULL;

   ALLEGRO_SAMPLE *sample=NULL;

   ALLEGRO_SAMPLE *sample1=NULL;

   ALLEGRO_SAMPLE *sample2=NULL;

   ALLEGRO_SAMPLE *sample3=NULL;

   ALLEGRO_SAMPLE *sample4=NULL;


   bool redraw = true;
   bool doexit = false;


   if(!al_init())

    {

      fprintf(stderr, "failed to initialize allegro!\n");

      return -1;
    }

   if(!al_install_keyboard())

    {

      fprintf(stderr, "failed to initialize the keyboard!\n");

      return -1;
    }

   timer = al_create_timer(1.0 / FPS);

   if(!timer)

    {

      fprintf(stderr, "failed to create timer!\n");

      return -1;

   }

   if(!al_install_audio())

    {

      fprintf(stderr, "failed to initialize audio!\n");

      return -1;

   }


    else
        if (!al_reserve_samples(5))
        {
            fprintf(stderr, "Falha ao reservar samples!\n");
            return -1;
        }

   if(!al_init_acodec_addon())

    {

      fprintf(stderr, "failed to initialize audio codecs!\n");
      return -1;

   }

   if (!al_reserve_samples(1))

    {

      fprintf(stderr, "failed to reserve samples!\n");

      return -1;

   }

   sample = al_load_sample("audio/som.wav");

    if (!sample)

    {
        fprintf(stderr, "Falha ao carregar sample.\n");

        al_destroy_display(display);

        return false;

    }

       sample1 = al_load_sample("audio/intro.wav");

    if (!sample1)

    {
        fprintf(stderr, "Falha ao carregar sample1.\n");

        al_destroy_display(display);

        return false;

    }


        sample2 = al_load_sample("audio/treinador.wav");

    if (!sample2)

    {
        fprintf(stderr, "Falha ao carregar sample2.\n");

        al_destroy_display(display);

        return false;

    }

        sample3 = al_load_sample("audio/pokemon.wav");

    if (!sample3)

    {
        fprintf(stderr, "Falha ao carregar sample3.\n");

        al_destroy_display(display);

        return false;

    }

            sample4 = al_load_sample("audio/hit.wav");

    if (!sample4)

    {
        fprintf(stderr, "Falha ao carregar sample4.\n");

        al_destroy_display(display);

        return false;

    }

   al_set_new_display_flags(ALLEGRO_OPENGL | ALLEGRO_WINDOWED);

   display = al_create_display(SCREEN_W, SCREEN_H);

   if(!display)

    {
      fprintf(stderr, "failed to create display!\n");

      al_destroy_timer(timer);

      return -1;

   }

    al_init_image_addon();

    if(!al_init_image_addon())

    {

        fprintf(stderr, "failed to initialize the image addon!\n");

        return -1;

    }

   background = al_load_bitmap("imagens/fundo.png");

   if(!background)

    {

    fprintf(stderr, "falhou ao criar o background bitmap!\n");

      al_destroy_bitmap(treinador);
      al_destroy_bitmap(pokemon);
      al_destroy_display(display);
      al_destroy_timer(timer);

        return -1;


    al_set_target_bitmap(al_get_backbuffer(display));

    }

   treinador =  al_load_bitmap("imagens/treinador.png");


   if(!treinador)

    {

      fprintf(stderr, "failed to create treinador bitmap!\n");

      al_destroy_display(display);

      al_destroy_timer(timer);

      return -1;

   }

    pokemon = al_load_bitmap("imagens/pokemon.png");

      if(!pokemon)

        {

      fprintf(stderr, "failed to create pokemon bitmap!\n");

      al_destroy_display(display);

      al_destroy_timer(timer);

      return -1;

   }


    float bola_pos_x = SCREEN_W / 2.0 - BOLA_TAMANHO / 2.0;

    float bola_pos_y = SCREEN_H / 2.0 - BOLA_TAMANHO / 2.0;

    float bola_vx = -4;

    float bola_vy = -4;



    float treinador_pos_x = 0;

    float treinador_pos_y = SCREEN_H / 2.0 - REBATEDOR_ALTURA / 2.0;

    float treinador_vy = 0;



    float pokemon_pos_x = SCREEN_W - REBATEDOR_LARGURA;

    float pokemon_pos_y = SCREEN_H / 2.0 - REBATEDOR_ALTURA / 2.0;

    float pokemon_vy = 0;



    int click=0;

    int savebvx;

    int savebvy;


    bola = al_load_bitmap("imagens/bola1.png");


        if(!bola)

    {

        fprintf(stderr, "falhou ao criar a bola bitmap!\n");

        al_destroy_display(display);

        al_destroy_timer(timer);

        return -1;

    }

   event_queue = al_create_event_queue();

   if(!event_queue)

    {

      fprintf(stderr, "failed to create event_queue!\n");

      al_destroy_bitmap(treinador);

      al_destroy_bitmap(pokemon);

      al_destroy_display(display);

      al_destroy_timer(timer);

      al_destroy_bitmap(background);

      return -1;

   }

    al_set_window_title(display, "PongMon - Pokémon Pong Version");
    al_set_target_bitmap(al_get_backbuffer(display));

    al_play_sample(sample1, 1.0, 0.0,1.0,ALLEGRO_PLAYMODE_ONCE,NULL);


    menu();


   al_register_event_source(event_queue, al_get_display_event_source(display));

   al_register_event_source(event_queue, al_get_timer_event_source(timer));

   al_register_event_source(event_queue, al_get_keyboard_event_source());



   al_clear_to_color(al_map_rgb(0,0,0));



   al_flip_display();



   al_start_timer(timer);



      while(1)

    {


        ALLEGRO_EVENT ev;

        al_wait_for_event(event_queue, &ev);

        al_play_sample(sample, 1.0, 0.0,1.0,ALLEGRO_PLAYMODE_ONCE,NULL);




        if(ev.type==ALLEGRO_EVENT_MOUSE_BUTTON_DOWN)

        {

            switch(ev.mouse.button)

            {

            case 1:

                printf("x:%d y:%d\n",ev.mouse.x, ev.mouse.y);

                if(click==0)

                {

                    savebvx=bola_vx;

                    savebvy=bola_vy;

                    bola_vx=0;

                    bola_vy=0;

                    click=1;


                }

                else

                {

                    bola_vx=savebvx;

                    bola_vy=savebvy;

                    click=0;

                }

                break;

            }

        }

        else if(ev.type == ALLEGRO_EVENT_TIMER)

        {

            if(bola_pos_y < 0 || bola_pos_y > SCREEN_H - BOLA_TAMANHO)

            {

                bola_vy = -bola_vy;

            //al_play_sample(sample4, 1.0, 0.0,1.0,ALLEGRO_PLAYMODE_ONCE,NULL); // hitparede

            }



            if(bola_pos_x < 0 || bola_pos_x > SCREEN_W - BOLA_TAMANHO)

            {

                bola_pos_x = SCREEN_W / 2.0 - BOLA_TAMANHO / 2.0;

                bola_pos_y = SCREEN_H / 2.0 - BOLA_TAMANHO / 2.0;

                bola_vx = -4, bola_vy = -4;

            //al_play_sample(sample4, 1.0, 0.0,1.0,ALLEGRO_PLAYMODE_ONCE,NULL); // ponto


            }



            if(bola_pos_x <= treinador_pos_x + REBATEDOR_LARGURA)

                if(bola_pos_y+BOLA_TAMANHO>=treinador_pos_y)

                    if(bola_pos_y-BOLA_TAMANHO<=treinador_pos_y+REBATEDOR_ALTURA)


                        bola_vx = -bola_vx;



            if(bola_pos_x + BOLA_TAMANHO >= pokemon_pos_x )

                if(bola_pos_y+BOLA_TAMANHO>=pokemon_pos_y)

                    if(bola_pos_y-BOLA_TAMANHO<=pokemon_pos_y+REBATEDOR_ALTURA)

                        bola_vx = -bola_vx;



            bola_pos_x              += bola_vx;

            bola_pos_y              += bola_vy;

            treinador_pos_y += treinador_vy;

            pokemon_pos_y  += pokemon_vy;

            redraw = true;







        }

        else if(ev.type == ALLEGRO_EVENT_KEY_DOWN)

        {

            switch(ev.keyboard.keycode)

            {

            case ALLEGRO_KEY_UP:

                pokemon=al_load_bitmap("imagens/pu1.png");

                pokemon_vy=-4;

                break;



            case ALLEGRO_KEY_DOWN:

                pokemon=al_load_bitmap("imagens/pd1.png");

                pokemon_vy=4;

                break;



            case ALLEGRO_KEY_W:

                treinador=al_load_bitmap("imagens/u1.png");

                treinador_vy=-4;

                break;

            case ALLEGRO_KEY_S:

                treinador=al_load_bitmap("imagens/d1.png");

                treinador_vy=4;

                break;


            case ALLEGRO_KEY_ESCAPE:

                return 0;

                break;

            }

        }

        else if(ev.type == ALLEGRO_EVENT_KEY_UP)

        {

            switch(ev.keyboard.keycode)

            {

            case ALLEGRO_KEY_UP:

            pokemon=al_load_bitmap("imagens/pl1.png");

            case ALLEGRO_KEY_DOWN:

            pokemon=al_load_bitmap("imagens/pl1.png");

                pokemon_vy=0;

                break;



            case ALLEGRO_KEY_W:

            treinador=al_load_bitmap("imagens/r1.png");

            case ALLEGRO_KEY_S:

            treinador=al_load_bitmap("imagens/r1.png");

                treinador_vy=0;

                break;

            }

        }

        else if(ev.type == ALLEGRO_EVENT_DISPLAY_CLOSE)

        {

            break;

        }



        if(redraw && al_is_event_queue_empty(event_queue))

        {

            redraw = false;



            al_clear_to_color(al_map_rgb(0,100,0));



            al_draw_bitmap(background, 0, 0, 0);

            al_draw_bitmap(treinador,treinador_pos_x, treinador_pos_y, 0);

            al_draw_bitmap(pokemon,pokemon_pos_x, pokemon_pos_y, 0);

            al_draw_bitmap(bola, bola_pos_x, bola_pos_y, 0);



            al_flip_display();

        }

    }


   al_destroy_bitmap(treinador);
   al_destroy_bitmap(pokemon);
   al_destroy_timer(timer);
   al_destroy_display(display);
   al_destroy_event_queue(event_queue);
   al_destroy_sample(sample);
   al_destroy_sample(sample1);
   al_destroy_sample(sample2);
   al_destroy_sample(sample3);
   al_destroy_sample(sample4);

   return 0;
}



void menu()
{
   ALLEGRO_BITMAP *menu=NULL;

   menu= al_load_bitmap("imagens/intro.png");
    if(!menu)
        {
        fprintf(stderr, "Falha ao carregar bitmap menu!\n");
        return -1;
    }

    al_draw_bitmap(menu, 0, 0, 0);
    al_flip_display();
    al_rest(8);



}

 

[Visitante]

Isso é bem simples de fazer. Não sei usar Alegro mas vou lhe ensinar como eu faria tal score:

primeiro, você precisa criar um bitmap (imagem) com os números de 0 até 9

segundo, você precisa apenas "recortar" cada número da imagem no momento que for desenhar na tela.

terceiro, no momento de recortar, você deve se basear no valor atual do score.

 

O terceiro eu sugiro que você crie uma função.

Deixa eu mostrar como é:

 

/*
JANELA_ALLEGRO é a janela do allegro, a área onde você desenha
x é a posição de destino na janela
y é a posição de destino na janela
larguraDigito é a largura da letra DENTRO do bitmap numeros
alturaDigito é a altura da letra DENTRO do bitmap numeros
pontos é quantidade de pontos para desenhar
numeros é o bitmap dos numeros
*/
void desenhaScore (JANELA_ALLEGRO janela, int x, int y, int larguraDigito, int alturaDigito, int pontos, BITMAP numeros) {
  //pra ficar mais fácil, salve o valor dos pontos numa string
  char pontosStr[12];
  sprintf(pontosStr, "%d", pontos);

  //agora, você deve percorrer cada um dos digitos de pontosStr
  // e ir definindo a posição do digito na tela
  int i = 0, tamanho = strlen(pontosStr);
  for ( ; i < tamanho; i++) {
    //como a mudança na posiçao é apenas horizontal, basta ir mudando o destino
    //funciona assim:
    //a posição inicial é x + 0 * larguraDigito = x + 0
    //se tiver mais digitos a próxima será: x + 1 * larguraDigito
    //e assim vai movendo pra direita até o final
    int px = x + i * larguraDigito;
    //não se mexe na posição y
    int py = y;
    //aqui é a posição de recortar DENTRO da imagem
    //a imagem dos digitos é organizada de forma horizontal
    //sendo assim a imagem do 0 está mais a esquerda e a do 9 e restantes estão mais a direita
    //assim |0|1|2|3|4|5|6|7|8|9| cada quadrado desse é de larguraDigito
    //o (pontosStr[i] - '0') é pra converter o digito da string pontosStr para um valor inteiro (digito de 0 até 9)
    int fonteX = (pontosStr[i] - '0') * larguraDigito;
    int fontY = 0;
    //agora, aqui você chama a função de desenhar e recortar
    //Exemplo
    //desenhar(janela, numeros, fonteX, fonteY, larguraDigito, alturaDigito, px, py, larguraDigito, alturaDigito)
    //não sei como fazer no ALLEGRO mas é assim o método geral.
  }
}

Com esse código você pode adaptar para desenhar o score.

COm ele, você pode posicionar em qualquer parte da janela o score, e pode ter mais do que um também.

Basta apenas fazer mais de uma chamada ao desenhaScore com os parâmetros corretos.