Campo Minado Allegro C++

Esta é uma pré-visualização de arquivo. Entre para ver o arquivo original

Campo Minado/applauseClappingSound.ogg
Campo Minado/Good_Starts.ogg
Good Starts
Jingle Punks
YouTube Audio Library
Cinematic
Campo Minado/rsz_parabens2.png
Campo Minado/rsz_1menu.png
Campo Minado/parabens2.png
Campo Minado/explosion.ogg
Campo Minado/rsz_parabens.png
Campo Minado/menu.png
Campo Minado/parabens.png
Campo Minado/rsz_menu.png
Campo Minado/game0ver2.png
Campo Minado/rsz_game0ver2.png
Campo Minado/qu1.png
Campo Minado/game0ver.png
Campo Minado/telates2.cpp
//Isabella Grimaldi Gusmão
//Programação orientada à objetos com C++
//Campo minado com som
//CEFET/RJ Campus Petrópolis
// Os arquivos de cabeçalho
#include <allegro5/allegro.h>
#include <allegro5/allegro_image.h>
#include <allegro5/allegro_audio.h>
#include <allegro5/allegro_acodec.h>
 
// Para utilizarmos o fprintf
#include <stdio.h>
#include <stdlib.h>
#include <iostream>
#include <cstdlib>
#include <ctime>
using namespace std;
// Atributos da tela
const int TAM_FIG = 45;
class Block{
private:
 int qtBombs; //quantidade de bombas em volta
 bool flag; // se tem bandeira 
 bool bomb; // se tem bomba
 bool estado; // se foi aberto ou não
public:
 Block(){
 qtBombs=0;
 flag=0;
 bomb=0;
 estado=0;
 }
 void setEstado(bool e){
 estado = e;
 }
 bool getEstado(){
 return estado;
 }
 void setQtBombs(int n){
 qtBombs = n;
 }
 int getQtBombs(){
 return qtBombs;
 }
 void setFlag(bool f){
 flag = f;
 }
 bool getFlag(){
 return flag;
 }
 void setBomb(bool b){
 bomb = b;
 }
 bool getBomb(){
 return bomb;
 } 
};
class Tab{
private:
 Block **tab;
 int nl;
 int nc;
 int nBombs;
 int nFlags;
public:
 Tab(int nl, int nc, int nBombs): nl(nl), nc(nc), nBombs(nBombs){
 tab = (Block**)malloc(nl * sizeof(Block*));
 for(int i =0; i<nl; i++){
 tab[i] = (Block*) malloc(nc * sizeof(Block));
 }
 for(int i=0; i<nl; i++){
 for(int j=0; j<nc; j++){
 tab[i][j].setBomb(0);
 tab[i][j].setQtBombs(0);
 tab[i][j].setFlag(0);
 tab[i][j].setEstado(0);
 }
 }
 //MostraTab();
 alocarBombas();
 }
 Block ** & getTab(){
 return tab;
 }
 void alocarBombas(){ //coloca as bombas nas posições aleatórias
 int i, j;
 int flag=0;
 do{
 i = rand()%nl;
 j = rand()%nc;
 if(!tab[i][j].getBomb()){
 tab[i][j].setBomb(1);
 flag++;
 } 
 }while(flag<nBombs);
 
 
 for(int i=0; i<nl; i++){
 for(int j=0; j<nc; j++){
 int total = alocarNumero(i,j);
 tab[i][j].setQtBombs(total);
 }
 } 
 }
 int alocarNumero(int i, int j){
 int bombs = 0;
 if(i-1>=0 && j-1>=0)
 bombs += tab[i-1][j-1].getBomb();
 if(i-1>=0)
 bombs += tab[i-1][j].getBomb();
 if(i-1>=0 && j+1< nc)
 bombs += tab[i-1][j+1].getBomb();
 if(j-1>=0)
 bombs += tab[i][j-1].getBomb();
 if(j+1< nc)
 bombs += tab[i][j+1].getBomb();
 if(i+1< nl && j-1>=0)
 bombs += tab[i+1][j-1].getBomb();
 if(i+1< nl)
 bombs += tab[i+1][j].getBomb();
 if(i+1< nl && j< nc)
 bombs += tab[i+1][j+1].getBomb();
 return bombs;
 }
 void colocaFlag(int i, int j){
 if(tab[i][j].getFlag()){
 tab[i][j].setFlag(0);
 }
 else{
 tab[i][j].setFlag(1);
 }
 }
 int getNBombs(){
 return nBombs;
 }
 int getNL(){
 return nl;
 }
 int getNC(){
 return nc;
 }
 void IncrementaFlags(){
 nFlags+=1;
 }
 void DecrementaFlags(){
 nFlags-=1;
 }
 int getFlags(){
 return nFlags;
 }
 void MostraTab(){
 for(int i=0; i<nl; i++){
 for(int j=0; j<nc; j++){
 if(tab[i][j].getFlag()){
 cout << "F\t";
 }
 else if(tab[i][j].getBomb()){
 cout << "*\t" ;
 }
 else if(!tab[i][j].getBomb()){
 cout << tab[i][j].getQtBombs() << "\t";
 }
 }
 cout << endl << endl;
 }
 cout << endl;
 }
 int ContaBloqueados(){
 int count=0;
 for(int i=0; i<nl; i++){
 for(int j=0; j<nc; j++){
 if(tab[i][j].getEstado()){
 count+=1;
 }
 }
 }
 return count;
 }
};
void Abrir(Block **tab, int x, int y, int i, int j, int nl, int nc){
 ALLEGRO_BITMAP *vazio = al_load_bitmap("quadrado-branco2.jpg");
 ALLEGRO_BITMAP *img_um = al_load_bitmap("1.png");
 ALLEGRO_BITMAP *img_dois = al_load_bitmap("2.png");
 ALLEGRO_BITMAP *img_tres = al_load_bitmap("3.png");
 ALLEGRO_BITMAP *img_quatro = al_load_bitmap("4.png");
 ALLEGRO_BITMAP *img_cinco = al_load_bitmap("5.png");
 ALLEGRO_BITMAP *img_seis = al_load_bitmap("6.png");
 ALLEGRO_BITMAP *img_sete = al_load_bitmap("7.png");
 ALLEGRO_BITMAP *img_oito = al_load_bitmap("8.png");
 ALLEGRO_BITMAP *img_bomba = al_load_bitmap("bomb_icon2.jpg");
 if((x>=0 && x<nl) && (y>=0 && y<nc)){
 if(tab[x][y].getEstado() == 0 && tab[x][y].getBomb() == 0){ //se tiver fechado
 switch(tab[x][y].getQtBombs()){
 case 0:
 al_draw_bitmap(vazio, (i/TAM_FIG)*TAM_FIG, (j/TAM_FIG)*TAM_FIG, 0);
 al_flip_display();
 tab[x][y].setEstado(1);
 Abrir(tab, x+1, y, i+TAM_FIG, j, nl, nc);
 Abrir(tab, x+1 , y+1, i+TAM_FIG, j+TAM_FIG, nl, nc);
 Abrir(tab, x-1 , y, i-TAM_FIG, j, nl, nc);
 Abrir(tab, x+1, y-1, i+TAM_FIG, j-TAM_FIG, nl, nc);
 Abrir(tab, x, y+1, i, j+TAM_FIG, nl, nc);
 Abrir(tab, x-1, y+1, i-TAM_FIG, j+TAM_FIG, nl, nc);
 Abrir(tab, x, y-1, i, j-TAM_FIG, nl, nc);
 Abrir(tab, x-1, y-1, i-TAM_FIG, j-TAM_FIG, nl, nc);
 break;
 case 1:
 al_draw_bitmap(img_um, (i/TAM_FIG)*TAM_FIG, (j/TAM_FIG)*TAM_FIG, 0);
 al_flip_display();
 tab[x][y].setEstado(1);
 break;
 case 2:
 al_draw_bitmap(img_dois, (i/TAM_FIG)*TAM_FIG, (j/TAM_FIG)*TAM_FIG, 0);
 al_flip_display();
 tab[x][y].setEstado(1);
 break;
 case 3:
 al_draw_bitmap(img_tres, (i/TAM_FIG)*TAM_FIG, (j/TAM_FIG)*TAM_FIG, 0);
 al_flip_display();
 tab[x][y].setEstado(1);
 break;
 case 4:
 al_draw_bitmap(img_quatro, (i/TAM_FIG)*TAM_FIG, (j/TAM_FIG)*TAM_FIG, 0);
 al_flip_display();
 tab[x][y].setEstado(1);
 break;
 case 5:
 al_draw_bitmap(img_cinco, (i/TAM_FIG)*TAM_FIG, (j/TAM_FIG)*TAM_FIG, 0);
 al_flip_display();
 tab[x][y].setEstado(1);
 break;
 case 6:
 al_draw_bitmap(img_seis, (i/TAM_FIG)*TAM_FIG, (j/TAM_FIG)*TAM_FIG, 0);
 al_flip_display();
 tab[x][y].setEstado(1);
break;
 case 7:
 al_draw_bitmap(img_sete, (i/TAM_FIG)*TAM_FIG, (j/TAM_FIG)*TAM_FIG, 0);
 al_flip_display();
 tab[x][y].setEstado(1);
 break;
 case 8:
 al_draw_bitmap(img_oito, (i/TAM_FIG)*TAM_FIG, (j/TAM_FIG)*TAM_FIG, 0);
 al_flip_display();
 tab[x][y].setEstado(1);
 break;
 }
 }
 }
}
int main(void)
{
 if (!al_init())
 {
 fprintf(stderr, "Falha ao inicializar a Allegro.\n");
 return -1;
 }
 
 if (!al_init_image_addon())
 {
 fprintf(stderr, "Falha ao inicializar add-on allegro_image.\n");
 return -1;
 }
 const int LARGURA_MENU = 600;
 const int ALTURA_MENU = 518;
 ALLEGRO_DISPLAY * menu = al_create_display(LARGURA_MENU, ALTURA_MENU);
 if (!menu)
 {
 fprintf(stderr, "Falha ao criar menu.\n");
 return -1;
 }
 al_set_window_title(menu, "Campo minado da Isa");
 
 ALLEGRO_BITMAP *img_menu = al_load_bitmap("menu.png");
 if (!img_menu)
 {
 fprintf(stderr, "Falha ao carregar o arquivo de imagem.\n");
 al_destroy_display(menu);
 return -1;
 }
 // Torna apto o uso de mouse na aplicação
 if (!al_install_mouse())
 {
 fprintf(stderr, "Falha ao inicializar o mouse.\n");
 return -1;
 }
 // Atribui o cursor padrão do sistema para ser usado
 if (!al_set_system_mouse_cursor(menu, ALLEGRO_SYSTEM_MOUSE_CURSOR_DEFAULT))
 {
 fprintf(stderr, "Falha ao atribuir ponteiro do mouse.\n");
 return -1;
 }
 ALLEGRO_EVENT_QUEUE *fila_eventos2 = NULL;
 fila_eventos2 = al_create_event_queue();
 if (!fila_eventos2)
 {
 fprintf(stderr, "Falha ao criar fila de eventos.\n");
 al_destroy_display(menu);
 return -1;
 }
 
 al_register_event_source(fila_eventos2, al_get_display_event_source(menu));
 al_register_event_source(fila_eventos2, al_get_mouse_event_source());
 al_draw_bitmap(img_menu, 0, 0, 0);
 al_flip_display(); 
 int tamTab, qtdBombas;
 while (1)
 {
 ALLEGRO_EVENT evento;
 al_wait_for_event(fila_eventos2, &evento);
 
 
 if (evento.type == ALLEGRO_EVENT_DISPLAY_CLOSE)
 {
 exit(0);
 }
 if (evento.type == ALLEGRO_EVENT_MOUSE_BUTTON_UP){
 if(evento.mouse.y > 250 && evento.mouse.y < 283){
 tamTab = 8;
 qtdBombas = 10;
 break;
 }
 else if(evento.mouse.y > 283 && evento.mouse.y < 315){
 tamTab = 16;
 qtdBombas = 40;
 break;
 }
 } 
 }
 //al_destroy_display(menu);
 al_destroy_event_queue(fila_eventos2);
 srand((unsigned)time(0));
 Tab tabuleiro(tamTab, tamTab, qtdBombas);
 Block **tab = tabuleiro.getTab();
 const int LARGURA_TELA = tabuleiro.getNL() * TAM_FIG;
 const int ALTURA_TELA = tabuleiro.getNC() * TAM_FIG;
 int i=0, j=0;
 ALLEGRO_DISPLAY *janela = NULL;
 ALLEGRO_BITMAP *imagem = NULL;
 ALLEGRO_BITMAP *vazio = NULL;
 ALLEGRO_BITMAP *flag_im = NULL;
 ALLEGRO_EVENT_QUEUE *fila_eventos = NULL;
 int flag =0;
 int qt_flags = 0;
 
 
 janela = al_create_display(LARGURA_TELA, ALTURA_TELA);
 if (!janela)
 {
 fprintf(stderr, "Falha ao criar janela.\n");
 return -1;
 }
 al_set_window_title(janela, "Campo minado da Isa");
 
 imagem = al_load_bitmap("q2.jpg");
 if (!imagem)
 {
 fprintf(stderr, "Falha ao carregar o arquivo de imagem.\n");
 al_destroy_display(janela);
 return -1;
 }
 vazio = al_load_bitmap("quadrado-branco2.jpg");
 if (!vazio)
 {
 fprintf(stderr, "Falha ao carregar o arquivo de imagem.\n");
 al_destroy_display(janela);
 return -1;
 }
 flag_im = al_load_bitmap("flag3.jpg");
 if (!flag_im)
 {
 fprintf(stderr, "Falha ao carregar o arquivo de imagem.\n");
 al_destroy_display(janela);
 return -1;
 }
 ALLEGRO_BITMAP *img_um = al_load_bitmap("1.png");
 if (!img_um)
 {
 fprintf(stderr, "Falha ao carregar o arquivo de imagem.\n");
 al_destroy_display(janela);
 return -1;
 }
 ALLEGRO_BITMAP *img_dois = al_load_bitmap("2.png");
 if (!img_dois)
 {
 fprintf(stderr, "Falha ao carregar o arquivo de imagem.\n");
 al_destroy_display(janela);
 return -1;
 }
 ALLEGRO_BITMAP *img_tres = al_load_bitmap("3.png");
 if (!img_tres)
 {
 fprintf(stderr, "Falha ao carregar o arquivo de imagem.\n");
 al_destroy_display(janela);
 return -1;
 }
 ALLEGRO_BITMAP *img_quatro = al_load_bitmap("4.png");
 if (!img_quatro)
 {
 fprintf(stderr, "Falha ao carregar o arquivo de imagem.\n");
 al_destroy_display(janela);
 return -1;
 }
 ALLEGRO_BITMAP *img_cinco = al_load_bitmap("5.png");
 if (!img_cinco)
 {
 fprintf(stderr, "Falha ao carregar o arquivo de imagem.\n");
 al_destroy_display(janela);
 return -1;
 }
 ALLEGRO_BITMAP *img_seis = al_load_bitmap("6.png");
 if (!img_seis)
 {
 fprintf(stderr, "Falha ao carregar o arquivo de imagem.\n");
 al_destroy_display(janela);
 return -1;
 }
 ALLEGRO_BITMAP *img_sete = al_load_bitmap("7.png");
 if (!img_sete)
 {
 fprintf(stderr, "Falha ao carregar o arquivo de imagem.\n");
 al_destroy_display(janela);
 return -1;
 }
 ALLEGRO_BITMAP *img_oito = al_load_bitmap("8.png");
 if (!img_oito)
 {
 fprintf(stderr, "Falha ao carregar o arquivo de imagem.\n");
 al_destroy_display(janela);
 return -1;
 }
 ALLEGRO_BITMAP *img_bomba = al_load_bitmap("bomb_icon2.jpg");
 if (!img_bomba)
 {
 fprintf(stderr, "Falha ao carregar o arquivo de imagem.\n");
 al_destroy_display(janela);
 return -1;
 }
 ALLEGRO_BITMAP *img_gameOver = NULL;
 if(tabuleiro.getNL() >= 16){
 img_gameOver = al_load_bitmap("game0ver2.png");
 if (!img_gameOver)
 {
 fprintf(stderr, "Falha ao carregar o arquivo de imagem.\n");
 al_destroy_display(janela);
 return -1;
 }
 }
 else{
 img_gameOver = al_load_bitmap("rsz_game0ver2.png");
 if (!img_gameOver)
 {
 fprintf(stderr, "Falha ao carregar o arquivo de imagem.\n");
 al_destroy_display(janela);
 return -1;
 }
 }
 ALLEGRO_BITMAP *img_parabens = NULL;
 if(tabuleiro.getNL() >= 16){
 img_parabens = al_load_bitmap("parabens2.png");
 if (!img_gameOver)
 {
 fprintf(stderr, "Falha ao carregar o arquivo de imagem.\n");
 al_destroy_display(janela);
 return -1;
 }
 }
 else{
 img_parabens = al_load_bitmap("rsz_parabens2.png");
 if (!img_gameOver)
 {
 fprintf(stderr, "Falha ao carregar o arquivo de imagem.\n");
 al_destroy_display(janela);
 return -1;
 }
 }
 
 al_install_audio();
 al_init_acodec_addon();
 ALLEGRO_SAMPLE *explosao = NULL;
 ALLEGRO_SAMPLE *aplausos = NULL;
 ALLEGRO_SAMPLE *musicaFundo = NULL;
 ALLEGRO_SAMPLE_INSTANCE *songInstanceFundo = NULL;
 ALLEGRO_SAMPLE_INSTANCE *songInstance = NULL;
 al_reserve_samples(10);
 explosao = al_load_sample("explosion.ogg");
 aplausos = al_load_sample("applauseClappingSound.ogg");
 musicaFundo = al_load_sample("Good_Starts.ogg");
 songInstanceFundo = al_create_sample_instance(musicaFundo);
 al_attach_sample_instance_to_mixer(songInstanceFundo,
al_get_default_mixer());
 al_play_sample(musicaFundo, 1, 0, 1, ALLEGRO_PLAYMODE_LOOP, 0);
 fila_eventos = al_create_event_queue();
 if (!fila_eventos)
 {
 fprintf(stderr, "Falha ao criar fila de eventos.\n");
 al_destroy_display(janela);
 return -1;
 }
 
 al_register_event_source(fila_eventos, al_get_display_event_source(janela));
 
 for(i=0; i<LARGURA_TELA; i+=TAM_FIG){
 for(j=0; j<ALTURA_TELA; j+=TAM_FIG){
 al_draw_bitmap(imagem, i, j, 0);
 }
 }
 al_flip_display();
 al_register_event_source(fila_eventos, al_get_mouse_event_source());
 
 bool gameOver = 0, flag_Parabens = 0;
 while (1)
 {
 ALLEGRO_EVENT evento;
 al_wait_for_event(fila_eventos, &evento);
 
 
 if (evento.type == ALLEGRO_EVENT_DISPLAY_CLOSE)
 {
 break;
 }
 if(gameOver == 0 && flag_Parabens == 0){
 
 if (evento.type == ALLEGRO_EVENT_MOUSE_BUTTON_UP)
 { 
 i = (evento.mouse.x/TAM_FIG)%tabuleiro.getNL();
 j = (evento.mouse.y/TAM_FIG)%tabuleiro.getNC();
 //printf("%d %d\n", i, j);
 
 if(evento.mouse.button & 1){ //se clicou com o mouse do lado esquerdo
 if(tab[i][j].getEstado() == 0){ //se tiver fechado
 if(tab[i][j].getBomb() == 1){ //se for bomba
 al_draw_bitmap(img_bomba, (evento.mouse.x / TAM_FIG)*TAM_FIG, (evento.mouse.y / TAM_FIG)*TAM_FIG, 0);
 al_flip_display();
 tab[i][j].setEstado(1);
 songInstance = al_create_sample_instance(explosao);
 al_attach_sample_instance_to_mixer(songInstance, al_get_default_mixer());
 
 al_play_sample(explosao, 1, 0, 1, ALLEGRO_PLAYMODE_ONCE, 0);
 for(int k=0; k<tabuleiro.getNL(); k++){
 for(int l=0; l<tabuleiro.getNC(); l++){
 if(tab[k][l].getBomb()){
 //al_play_sample(explosao, 1, 0, 1, ALLEGRO_PLAYMODE_ONCE, 0);
 //usleep(2000000);
 al_draw_bitmap(img_bomba, k*TAM_FIG, l*TAM_FIG, 0);
 al_flip_display();
 }
 }
 }
 gameOver = 1;
 al_draw_bitmap(img_gameOver, LARGURA_TELA/4, ALTURA_TELA/4, 0);
 al_flip_display();
 }
 else{ //se não for uma bomba
 switch(tab[i][j].getQtBombs()){
 case 0:
 Abrir(tabuleiro.getTab(), i, j, evento.mouse.x, evento.mouse.y, tabuleiro.getNL(), tabuleiro.getNC());
 break;
 case 1:
 al_draw_bitmap(img_um, (evento.mouse.x / TAM_FIG)*TAM_FIG, (evento.mouse.y / TAM_FIG)*TAM_FIG, 0);
 al_flip_display();
 tab[i][j].setEstado(1);
 break;
 case 2:
 al_draw_bitmap(img_dois, (evento.mouse.x / TAM_FIG)*TAM_FIG, (evento.mouse.y / TAM_FIG)*TAM_FIG, 0);
 al_flip_display();
 tab[i][j].setEstado(1);
 break;
 case 3:
 al_draw_bitmap(img_tres, (evento.mouse.x / TAM_FIG)*TAM_FIG, (evento.mouse.y / TAM_FIG)*TAM_FIG, 0);
 al_flip_display();
 tab[i][j].setEstado(1);
 break;
 case 4:
 al_draw_bitmap(img_quatro, (evento.mouse.x / TAM_FIG)*TAM_FIG, (evento.mouse.y / TAM_FIG)*TAM_FIG, 0);
 al_flip_display();
 tab[i][j].setEstado(1);
 break;
 case 5:
 al_draw_bitmap(img_cinco, (evento.mouse.x / TAM_FIG)*TAM_FIG, (evento.mouse.y / TAM_FIG)*TAM_FIG, 0);
 al_flip_display();
 tab[i][j].setEstado(1);
 break;
 case 6:
 al_draw_bitmap(img_seis, (evento.mouse.x / TAM_FIG)*TAM_FIG, (evento.mouse.y / TAM_FIG)*TAM_FIG, 0);
 al_flip_display();
 tab[i][j].setEstado(1);
 break;
 case 7:
 al_draw_bitmap(img_sete, (evento.mouse.x / TAM_FIG)*TAM_FIG, (evento.mouse.y / TAM_FIG)*TAM_FIG, 0);
 al_flip_display();
 tab[i][j].setEstado(1);
 break;
 case 8:
 al_draw_bitmap(img_oito, (evento.mouse.x / TAM_FIG)*TAM_FIG, (evento.mouse.y / TAM_FIG)*TAM_FIG, 0);
 al_flip_display();
 tab[i][j].setEstado(1);
 break;
 }
 }
 }
 }
 else if(evento.mouse.button & 2){ //se clicou com o mouse do lado direito
 if(tab[i][j].getEstado()==0){
 if(tab[i][j].getFlag()==0){
 tabuleiro.IncrementaFlags();
 al_draw_bitmap(flag_im, (evento.mouse.x / TAM_FIG)*TAM_FIG, (evento.mouse.y / TAM_FIG)*TAM_FIG, 0);
 tab[i][j].setFlag(1);
 }
 else{
 tabuleiro.DecrementaFlags();
 al_draw_bitmap(imagem, (evento.mouse.x / TAM_FIG)*TAM_FIG, (evento.mouse.y / TAM_FIG)*TAM_FIG, 0);
 tab[i][j].setFlag(0);
 }
 }
 //printf("quantidade de flags -> %d\n", tabuleiro.getFlags());
 al_flip_display();
 }
 
 if((tabuleiro.getFlags() == tabuleiro.getNBombs() && (tabuleiro.getFlags() + tabuleiro.ContaBloqueados()) == tabuleiro.getNL()*tabuleiro.getNC())){ 
 songInstance = al_create_sample_instance(aplausos);
 al_attach_sample_instance_to_mixer(songInstance, al_get_default_mixer());
 al_play_sample(aplausos, 1, 0, 1, ALLEGRO_PLAYMODE_ONCE, 0);
 al_draw_bitmap(img_parabens, LARGURA_TELA/4, ALTURA_TELA/4, 0);
 al_flip_display();
 flag_Parabens = 1;
 }
 }
 
 }
 }
 al_destroy_sample(aplausos);
 al_destroy_sample(musicaFundo);
 al_destroy_sample(explosao);
 al_destroy_display(janela);
 al_destroy_event_queue(fila_eventos);
 
 return 0;
}
Campo Minado/clap.png
Campo Minado/8.png
Campo Minado/7.png
Campo Minado/6.png
Campo Minado/5.png
Campo Minado/4.png
Campo Minado/3.png
Campo Minado/2.png
Campo Minado/1.png
Campo Minado/quadrado-branco2.jpg
Campo Minado/quadrado-branco.jpg
Campo Minado/bomb_icon2.jpg
Campo Minado/bomb_icon.jpg
Campo Minado/flag3.jpg
Campo Minado/flag2.jpg
Campo Minado/qu2.png
Campo Minado/q2.jpg
Campo Minado/q.jpg
Campo Minado/quadrado3.png
Campo Minado/quadrado2.png
Campo Minado/quadrado.png
Campo Minado/caixa-de-selecao-vazia-quadrado-arredondado_318-41751.png.jpeg
Campo Minado/janela2.cpp
// Inclui o cabeçalho da bibilioteca Allegro 5
#include <allegro5/allegro.h>
 
// Inclui o cabeçalho do add-on para uso de imagens
#include <allegro5/allegro_image.h>
using namespace std;
 
int main(void)
{
 // Variável representando a janela principal
 ALLEGRO_DISPLAY *janela = NULL;
 
 // Variável representando a imagem
 ALLEGRO_BITMAP *imagem = NULL;
 
 // Inicializa a Allegro
 al_init();
 
 // Inicializa o add-on para utilização de imagens
 al_init_image_addon();
 
 // Configura a janela
 janela = al_create_display(640, 480);
 
 // Carrega a imagem
 imagem = al_load_bitmap("sunshine.jpg");
 
 // Desenha a imagem na tela
 al_draw_bitmap(imagem, 0, 0, 0);
 
 // Atualiza a tela
 al_flip_display();
 
 // Segura a execução por 10 segundos
 al_rest(10.0);
 
 // Finaliza a janela
 al_destroy_display(janela);
 
 return 0;
}
Campo Minado/janela.cpp
// Inclui o arquivo de cabeçalho da biblioteca Allegro 5
#include <allegro5/allegro.h>
using namespace std;
 
// Nossa conhecida função main...
int main(void)
{
 // Variável representando a janela principal
 ALLEGRO_DISPLAY *janela = NULL;
 
 // Inicializamos a biblioteca
 al_init();
 
 // Criamos a nossa janela - dimensões de 640x480 px
 janela = al_create_display(640, 480);
 
 // Preenchemos a janela de branco
 al_clear_to_color(al_map_rgb(255, 255, 255));
 
 // Atualiza a tela
 al_flip_display();
 
 // Segura a execução por 10 segundos
 al_rest(10.0);
 
 // Finaliza a janela
 al_destroy_display(janela);
 
 return 0;
}