Arquivos da categoria: Allegro

Polígonos Aleatórios em Allegro – C

//================================================================
// Nome do Arquivo: random_polygons.c
// Filename: random_polygons.c
//
// Descrição: O programa exibe polígonos preenchidas em posições
//            e cores aleatórias, com 3 a 12 vértices, usando a
//            função polygon da biblioteca allegro
//================================================================

#include <stdlib.h>
#include <time.h>
#include <allegro.h>

int main(int argc, char *argv[])
{
    // Total de vértices e ponteiro de pontos do polígono
    int vertices, *points;
    // Cor do polígono
    int color;
    // Contador
    int i;

	// Inicializa a biblioteca Allegro
	allegro_init();

	// Inicializa o módulo do relógio
	install_timer();

	// Inicializa o teclado
	install_keyboard();

	// Define a profundidade de cores para 32 bits
	set_color_depth(32);

	// Define a resolução de 640x480 no modo janela
	set_gfx_mode(GFX_AUTODETECT_WINDOWED, 640, 480, 0, 0);

	// A falta de acento é proposital
	// Muda o título da janela
	set_window_title("Poligonos");

	// Inicia o gerador de números aleatórios
	srand(time(NULL));

	// Fica em loop até pressionar a tecla ESC
	while(!key[KEY_ESC])
	{
	    // Gera um total aleatório de vértices
	    vertices = (rand() % 10) + 3;
	    // Aloca memória para o polígono
	    points = (int *) malloc(sizeof(int) * vertices * 2);
	    // Gera os pontos do polígono de forma aleatória
	    for(i = 0; i &lt; vertices; i++) {
	         points[i * 2]     = rand() % 640;
	         points[i * 2 + 1] = rand() % 480;
        }
        // Cria uma cor aleatória
	    color  = makecol(rand() % 256, rand() % 256, rand() % 256);

	    // Desenha um polígono em uma posição e cor aleatória
	    polygon(screen, vertices, points, color);
	    free(points);

	    // Espera 300 milisegundos para economizar processamento
	    rest(300);

		// Espera a sincronização vertical
		vsync();
	}

	// Sai do programa
	allegro_exit();
	return 0;
}
// Esta macro converte o main para WinMain()
END_OF_MAIN();

Triângulos Aleatórios em Allegro – C

//================================================================
// Nome do Arquivo: random_triangles.c
// Filename: random_triangles.c
//
// Descrição: O programa exibe triangulos preenchidas em posições e
//            cores aleatórias usando a função triangle da
//            biblioteca allegro
//================================================================

#include <stdlib.h>
#include <time.h>
#include <allegro.h>

int main(int argc, char *argv[])
{
    // Pontos do triângulo
    int x1, y1, x2, y2, x3, y3;
    // Cor da elipse
    int color;

	// Inicializa a biblioteca Allegro
	allegro_init();

	// Inicializa o módulo do relógio
	install_timer();

	// Inicializa o teclado
	install_keyboard();

	// Define a profundidade de cores para 32 bits
	set_color_depth(32);

	// Define a resolução de 640x480 no modo janela
	set_gfx_mode(GFX_AUTODETECT_WINDOWED, 640, 480, 0, 0);

	// A falta de acento é proposital
	// Muda o título da janela
	set_window_title("Triangulos");

	// Inicia o gerador de números aleatórios
	srand(time(NULL));

	// Fica em loop até pressionar a tecla ESC
	while(!key[KEY_ESC])
	{
	    // Configura os atributos da elipse
	    x1 = rand() % 640;
	    y1 = rand() % 480;
	    x2 = rand() % 640;
	    y2 = rand() % 480;
	    x3 = rand() % 640;
	    y3 = rand() % 480;
	    color  = makecol(rand() % 256, rand() % 256, rand() % 256);

	    // Desenha um triângulo em uma posição e cor aleatória
	    triangle(screen, x1, y1, x2, y2, x3, y3, color);

	    // Espera 300 milisegundos para economizar processamento
	    rest(300);

		// Espera a sincronização vertical
		vsync();
	}

	// Sai do programa
	allegro_exit();
	return 0;
}
// Esta macro converte o main para WinMain()
END_OF_MAIN();

Curvas de Bezier Aleatórias em Allegro – C

//================================================================
// Nome do Arquivo: random_arcs.c
// Filename: random_arcs.c
//
// Descrição: O programa exibe curvas de bezier em posições e
//            cores aleatórias usando a função arc da biblioteca
//            allegro
//================================================================

#include <stdlib.h>
#include <time.h>
#include <allegro.h>

int main(int argc, char *argv[])
{
    // Coordenadas dos 4 pontos de controle da curva
    int points[8];

    // Cor da curva
    int color;

    // Contador
    int i;

	// Inicializa a biblioteca Allegro
	allegro_init();

	// Inicializa o módulo do relógio
	install_timer();

	// Inicializa o teclado
	install_keyboard();

	// Define a profundidade de cores para 32 bits
	set_color_depth(32);

	// Define a resolução de 640x480 no modo janela
	set_gfx_mode(GFX_AUTODETECT_WINDOWED, 640, 480, 0, 0);

	// Muda o título da janela
	set_window_title("Curvas de Bezier");

	// Inicia o gerador de números aleatórios
	srand(time(NULL));

	// Fica em loop até pressionar a tecla ESC
	while(!key[KEY_ESC])
	{
	    // Configura os atributos da curva
	    for(i = 0; i &lt; 4; i++) {
	    	points[i*2] = rand() % 640;
	    	points[i*2 + 1] = rand() % 480;
     	}
	    color  = makecol(rand() % 256, rand() % 256, rand() % 256);

	    // Desenha uma curva de bezier em posição e cor aleatória
	    spline(screen, points, color);

	    // Espera 300 milisegundos para economizar processamento
	    rest(300);

		// Espera a sincronização vertical
		vsync();
	}

	// Sai do programa
	allegro_exit();
	return 0;
}
// Esta macro converte o main para WinMain()
END_OF_MAIN();

Arcos aleatórios em Allegro – C

//================================================================
// Nome do Arquivo: random_arcs.c
// Filename: random_arcs.c  
//
// Descrição: O programa exibe arcos em posições e cores
//            aleatórias usando a função arc da biblioteca allegro
//================================================================

#include <stdlib.h>
#include <time.h>
#include <allegro.h>

int main(int argc, char *argv[])
{
    // Ponto central do arco, os ângulos de rotação e o raio
    int x, y, ang1, ang2, r;
	
    // Cor da elipse
    int color;
    
	// Inicializa a biblioteca Allegro
	allegro_init();
	
	// Inicializa o módulo do relógio
	install_timer();

	// Inicializa o teclado
	install_keyboard();

	// Define a profundidade de cores para 32 bits
	set_color_depth(32);

	// Define a resolução de 640x480 no modo janela
	set_gfx_mode(GFX_AUTODETECT_WINDOWED, 640, 480, 0, 0);
	
	// Muda o título da janela
	set_window_title("Arcs");
	
	// Inicia o gerador de números aleatórios
	srand(time(NULL));
	
	// Fica em loop até pressionar a tecla ESC
	while(!key[KEY_ESC])
	{
	    // Configura os atributos do arco
	    x      = rand() % 640;
	    y      = rand() % 480;
	    ang1   = rand() % 257;
	    ang2   = rand() % 257;
	    r      = rand() % 240;
	    color  = makecol(rand() % 256, rand() % 256, rand() % 256);
	    
	    // Desenha um arco em uma posição e cor aleatória
	    arc(screen, x, y, itofix(ang1), itofix(ang2), r, color);
	    
	    // Espera 300 milisegundos para economizar processamento
	    rest(300);
	    
		// Espera a sincronização vertical
		vsync();
	}

	// Sai do programa
	allegro_exit();
	return 0;     
}
// Esta macro converte o main para WinMain()
END_OF_MAIN();

Elipses Aleatórias em Allegro #02 – C

//================================================================
// Nome do Arquivo: random_elipses.c
// Filename: random_elipses.c  
//
// Descrição: O programa exibe elipses preenchidas em posições e
//            cores aleatórias usando a função elipse da
//            biblioteca allegro
//================================================================

#include <stdlib.h>
#include <time.h>
#include <allegro.h>

int main(int argc, char *argv[])
{
    // Ponto central da elipse e os comprimentos dos raios
    int x, y, rx, ry;
    // Cor da elipse
    int color;
    
	// Inicializa a biblioteca Allegro
	allegro_init();
	
	// Inicializa o módulo do relógio
	install_timer();

	// Inicializa o teclado
	install_keyboard();

	// Define a profundidade de cores para 32 bits
	set_color_depth(32);

	// Define a resolução de 640x480 no modo janela
	set_gfx_mode(GFX_AUTODETECT_WINDOWED, 640, 480, 0, 0);
	
	// Muda o título da janela
	set_window_title("Elipses #02");
	
	// Inicia o gerador de números aleatórios
	srand(time(NULL));
	
	// Fica em loop até pressionar a tecla ESC
	while(!key[KEY_ESC])
	{
	    // Configura os atributos da elipse
	    x      = rand() % 640;
	    y      = rand() % 480;
	    rx = rand() % 320;
	    ry = rand() % 240;
	    color  = makecol(rand() % 256, rand() % 256, rand() % 256);
	    
	    // Desenha uma elipse em uma posição e cor aleatória
	    ellipsefill(screen, x, y, rx, ry, color);
	    
	    // Espera 300 milisegundos para economizar processamento
	    rest(300);
	    
		// Espera a sincronização vertical
		vsync();
	}

	// Sai do programa
	allegro_exit();
	return 0;     
}
// Esta macro converte o main para WinMain()
END_OF_MAIN();

Elipses Aleatórias em Allegro #01 – C

//================================================================
// Nome do Arquivo: random_elipses.c
// Filename: random_elipses.c  
//
// Descrição: O programa exibe elipses em posições e cores 
//			  aleatórias usando a função elipse da biblioteca
//            allegro
//================================================================

#include <stdlib.h>
#include <time.h>
#include <allegro.h>

int main(int argc, char *argv[])
{
    // Ponto central da elipse e os comprimentos dos raios
    int x, y, rx, ry;
    // Cor do círculo
    int color;
    
	// Inicializa a biblioteca Allegro
	allegro_init();
	
	// Inicializa o módulo do relógio
	install_timer();

	// Inicializa o teclado
	install_keyboard();

	// Define a profundidade de cores para 32 bits
	set_color_depth(32);

	// Define a resolução de 640x480 no modo janela
	set_gfx_mode(GFX_AUTODETECT_WINDOWED, 640, 480, 0, 0);
	
	// Muda o título da janela
	set_window_title("Elipses #01");
	
	// Inicia o gerador de números aleatórios
	srand(time(NULL));
	
	// Fica em loop até pressionar a tecla ESC
	while(!key[KEY_ESC])
	{
	    // Configura os atributos da elipse
	    x      = rand() % 640;
	    y      = rand() % 480;
	    rx = rand() % 320;
	    ry = rand() % 240;
	    color  = makecol(rand() % 256, rand() % 256, rand() % 256);
	    
	    // Desenha uma elipse em uma posição e cor aleatória
	    ellipse(screen, x, y, rx, ry, color);
	    
	    // Espera 300 milisegundos para economizar processamento
	    rest(300);
	    
		// Espera a sincronização vertical
		vsync();
	}

	// Sai do programa
	allegro_exit();
	return 0;     
}
// Esta macro converte o main para WinMain()
END_OF_MAIN();

Círculos Aleatórios em Allegro #02 – C

//================================================================
// Nome do Arquivo: random_circles.c
// Filename: random_circles.c  
//
// Descrição: O programa exibe círculos em posições e cores 
//			  aleatórias usando a função circlefill da biblioteca
//            allegro
//================================================================

#include <stdlib.h>
#include <time.h>
#include <allegro.h>

int main(int argc, char *argv[])
{
    // Ponto central do círculo e o comprimento do raio
    int x, y, radius;
    // Cor do círculo
    int color;
    
	// Inicializa a biblioteca Allegro
	allegro_init();
	
	// Inicializa o módulo do relógio
	install_timer();

	// Inicializa o teclado
	install_keyboard();

	// Define a profundidade de cores para 32 bits
	set_color_depth(32);

	// Define a resolução de 640x480 no modo janela
	set_gfx_mode(GFX_AUTODETECT_WINDOWED, 640, 480, 0, 0);
	
	// A falta do acento é proposital
	// Muda o título da janela
	set_window_title("Circulos #02");
	
	// Inicia o gerador de números aleatórios
	srand(time(NULL));
	
	// Fica em loop até pressionar a tecla ESC
	while(!key[KEY_ESC])
	{
	    // Configura os atributos do círculo
	    x      = rand() % 640;
	    y      = rand() % 480;
	    radius = rand() % 320;
	    color  = makecol(rand() % 256, rand() % 256, rand() % 256);
	    
	    // Desenha um círculo em uma posição e cor aleatória
	    circlefill(screen, x, y, radius, color);
	    
	    // Espera 300 milisegundos para economizar processamento
	    rest(300);
	    
		// Espera a sincronização vertical
		vsync();
	}

	// Sai do programa
	allegro_exit();
	return 0;     
}
// Esta macro converte o main para WinMain()
END_OF_MAIN();

Círculos Aleatórios em Allegro #01 – C

//================================================================
// Nome do Arquivo: random_circles.c
// Filename: random_circles.c  
//
// Descrição: O programa exibe círculos em posições e cores 
//			  aleatórias usando a função circle da biblioteca
//            allegro
//================================================================

#include <stdlib.h>
#include <time.h>
#include <allegro.h>

int main(int argc, char *argv[])
{
    // Ponto central do círculo e o comprimento do raio
    int x, y, radius;
    // Cor da linha
    int color;
    
	// Inicializa a biblioteca Allegro
	allegro_init();
	
	// Inicializa o módulo do relógio
	install_timer();

	// Inicializa o teclado
	install_keyboard();

	// Define a profundidade de cores para 32 bits
	set_color_depth(32);

	// Define a resolução de 640x480 no modo janela
	set_gfx_mode(GFX_AUTODETECT_WINDOWED, 640, 480, 0, 0);
	
	// A falta do acento é proposital
	// Muda o título da janela
	set_window_title("Circulos #01");
	
	// Inicia o gerador de números aleatórios
	srand(time(NULL));
	
	// Fica em loop até pressionar a tecla ESC
	while(!key[KEY_ESC])
	{
	    // Configura os atributos do círculo
	    x      = rand() % 640;
	    y      = rand() % 480;
	    radius = rand() % 320;
	    color  = makecol(rand() % 256, rand() % 256, rand() % 256);
	    
	    // Desenha um círculo em uma posição e cor aleatória
	    circle(screen, x, y, radius, color);
	    
	    // Espera 300 milisegundos para economizar processamento
	    rest(300);
	    
		// Espera a sincronização vertical
		vsync();
	}

	// Sai do programa
	allegro_exit();
	return 0;     
}
// Esta macro converte o main para WinMain()
END_OF_MAIN();

Linhas Aleatórias em Allegro #03 – C

//================================================================
// Nome do Arquivo: random_retangles.c
// Filename: random_retangles.c
//
// Descrição: O programa exibe linhas em posições e cores
//            aleatórias usando a função line da biblioteca
//			  allegro
//================================================================

#include &lt;stdlib.h&gt;
#include &lt;time.h&gt;
#include &lt;allegro.h&gt;

int main(int argc, char *argv[])
{
    // Pontos base das linhas
    int x1, y1, x2, y2;
    // Cor da linha
    int color;

	// Inicializa a biblioteca Allegro
	allegro_init();

	// Inicializa o módulo do relógio
	install_timer();

	// Inicializa o teclado
	install_keyboard();

	// Define a profundidade de cores para 32 bits
	set_color_depth(32);

	// Define a resolução de 640x480 no modo janela
	set_gfx_mode(GFX_AUTODETECT_WINDOWED, 640, 480, 0, 0);

	// Muda o título da janela
	// O título sem acento é proposital
	set_window_title(&quot;Linhas #03&quot;);

	// Inicia o gerador de números aleatórios
	srand(time(NULL));

	// Fica em loop até pressionar a tecla ESC
	while(!key[KEY_ESC])
	{
	    // Configura os atributos das linhas
	    x1      = rand() % 640;
	    y1      = rand() % 480;
	    x2      = rand() % 640;
	    y2      = rand() % 480;
	    color   = makecol(rand() % 256, rand() % 256, rand() % 256);

	    // Desenha uma linha em uma posição e cor aleatória
	    line(screen, x1, y1, x2, y2, color);

	    // Espera 1000 milisegundos para economizar processamento
	    rest(300);

		// Espera a sincronização vertical
		vsync();
	}

	// Sai do programa
	allegro_exit();
	return 0;
}
// Esta macro converte o main para WinMain()
END_OF_MAIN();

Linhas Aleatórias em Allegro #02 – C

//================================================================
// Nome do Arquivo: random_lines.c
// Filename: random_lines.c  
//
// Descrição: O programa exibe linhas verticais em posições 
// 			  e cores aleatórias usando a função vline da 
// 			  biblioteca allegro
//================================================================

#include <stdlib.h>
#include <time.h>
#include <allegro>

int main(int argc, char *argv[])
{
    // Pontos base das linhas
    int x1, y1, y2;
    // Cor da linha
    int color;
    
	// Inicializa a biblioteca Allegro
	allegro_init();
	
	// Inicializa o módulo do relógio
	install_timer();

	// Inicializa o teclado
	install_keyboard();

	// Define a profundidade de cores para 32 bits
	set_color_depth(32);

	// Define a resolução de 640x480 no modo janela
	set_gfx_mode(GFX_AUTODETECT_WINDOWED, 640, 480, 0, 0);
	
	// Muda o título da janela
	set_window_title(&quot;Linhas #02&quot;);
	
	// Inicia o gerador de números aleatórios
	srand(time(NULL));
	
	// Fica em loop até pressionar a tecla ESC
	while(!key[KEY_ESC])
	{
	    // Configura os atributos das linhas
	    x1      = rand() % 640;
	    y1      = rand() % 480;
	    y2      = rand() % 480;
	    color   = makecol(rand() % 256, rand() % 256, rand() % 256);
	    
	    // Desenha uma linha em uma posição e cor aleatória
	    vline(screen, x1, y1, y2, color);
	    
	    // Espera 300 milisegundos para economizar processamento
	    rest(300);
	    
		// Espera a sincronização vertical
		vsync();
	}

	// Sai do programa
	allegro_exit();
	return 0;     
}
// Esta macro converte o main para WinMain()
END_OF_MAIN();