// O relógio digital que acompanha o demo
unsigned long int RelogioDigital(int x, int y)
{
// 1:56 minutos em milisegundos
static unsigned long tempo = 116000;
// O tempo inicial do demo
static unsigned long tinicial = C2D2_TempoSistema();
// O tempo atual
static unsigned long tatual;
static char texto[12];
// Pega o tempo atual
tatual = C2D2_TempoSistema();
// Calcula a diferença
unsigned long diferenca = tatual-tinicial;
// Desenha o fundo de 144x32
C2D2P_RetanguloPintado(x, y, x+91, y+31, 0,0,0);
C2D2P_Retangulo(x, y, x+91, y+31, 255,255,255);
// Calcula os tempos
int minutos=0, segundos=0, centesimos=0;
if(diferenca <=116000)
{
minutos = (tempo-diferenca)/60000;
segundos = ((tempo-diferenca)%60000)/1000;
centesimos = ((tempo-diferenca)%1000)/10;
}
sprintf(texto, "%02i:%02i:%02i", minutos, segundos, centesimos);
C2D2_DesenhaTexto(fdigital, x+8, y+8, texto, C2D2_TEXTO_ESQUERDA);
// Retorna o tempo
return diferenca;
}
int main(int narg, char **valarg)
{
// Inicia a Chien2D 2 e testa se deu tudo certo
if(C2D2_Inicia(LARGURA_TELA, ALTURA_TELA, C2D2_JANELA, C2D2_DESENHO_OPENGL, "Darkphoenix - O Baixinho Invocado"))
printf("Iniciou a Chien2D 2 com sucesso\n");
else
{
printf("Falhou ao iniciar a Chien2D 2. Encerrando o programa.\n");
return 0;
}
// Inicia as primitivas
C2D2P_Inicia();
// Inicia os mapas
C2D2M_Inicia();
// Inicia o áudio
CA2_Inicia();
// Inicia os personagens
ATOR_Inicia();
// Carrega a fonte do sistema
unsigned int fonte = C2D2_CarregaFonte("fontes/isabelle64_alpha.png", 64);
// Carrega o mapa
unsigned int mapa = C2D2M_CarregaMapaMappy("fases/Aula04-Mapa.FMP", "graficos/Aula04-tileset.png");
// Dá as velocidades. As duas últimas devem ser 1. As demais, incrementa de 1 em 1
int numcamadas = 4;
C2D2M_VelocidadeCamadaMapa(mapa, numcamadas-1, 1);
// Faz um for esotérico para atribuir as velocidades. Se pra você facilitar, use uma camada só que não dá nada
for(int i=0, vel=numcamadas-1; i<numcamadas-1;i++, vel--)
C2D2M_VelocidadeCamadaMapa(mapa, i, vel);
// A camada de marcas é sempre a última
C2D2M_CamadaMarcas(mapa, 4, 89);
// Indica a gravidade a aplicar no mapa
C2D2M_GravidadeMapa(mapa, GRAVIDADE, MAXGRAVIDADE);
// Carrega o personagem
bool cdark = JOGO_CarregaDarkPhoenix();
bool cbola = JOGO_CarregaBola();
// As músicas
unsigned int musicas[2];
musicas[0] = CA2_CarregaMusica("audio/AulaPaulo_byPiovezan.it");
musicas[1] = CA2_CarregaMusica("audio/venceu.wav");
// Testa se carregou certo (se é diferente de 0)
if(fonte==0 || mapa == 0 || !cdark || !cbola)
{
printf("Falhou ao carregar alguma coisa. Encerrando.\n");
// Encerra a Chien2d2
CA2_Encerra();
ATOR_Encerra();
C2D2M_Encerra();
C2D2_Encerra();
return 0;
}
C2D2_TrocaCorLimpezaTela(121, 188, 255);
C2D2_Botao *teclado = C2D2_PegaTeclas();
// cria o personagem
int x=60, y=60;
C2D2M_PrimeiroBlocoMarca(mapa, C2D2M_INICIO, &x, &y);
Ator *dark = ATOR_CriaAtor(DARKPHOENIX, x, y, 0);
Evento ev;
bool nafase=true;
// Procura saber quantos inimigos tem na fase
int numInimigos=0;
if(C2D2M_PrimeiroBlocoMarca(mapa, MARCA_BOLA_DIREITA, &x, &y))
{
numInimigos++;
while(C2D2M_ProximoBlocoMarca(mapa, &x, &y))
numInimigos++;
}
if(C2D2M_PrimeiroBlocoMarca(mapa, MARCA_BOLA_ESQUERDA, &x, &y))
{
numInimigos++;
while(C2D2M_ProximoBlocoMarca(mapa, &x, &y))
numInimigos++;
}
Ator **inimigos = (Ator**)malloc(sizeof(Ator*)*numInimigos);
memset(inimigos, 0, numInimigos*sizeof(Ator*));
numInimigos=0;
if(C2D2M_PrimeiroBlocoMarca(mapa, MARCA_BOLA_DIREITA, &x, &y))
{
inimigos[numInimigos++]=ATOR_CriaAtor(BOLA, x, y, 0);
while(C2D2M_ProximoBlocoMarca(mapa, &x, &y))
inimigos[numInimigos++]=ATOR_CriaAtor(BOLA, x, y, 0);
}
if(C2D2M_PrimeiroBlocoMarca(mapa, MARCA_BOLA_ESQUERDA, &x, &y))
{
inimigos[numInimigos++]=ATOR_CriaAtor(BOLA, x, y, 180);
while(C2D2M_ProximoBlocoMarca(mapa, &x, &y))
inimigos[numInimigos++]=ATOR_CriaAtor(BOLA, x, y, 180);
}
// Coloca a música para tocar
CA2_TocaMusica(musicas[0], -1);
// Indica se e a primeira vez que vai tocar a musicado fim da fase
bool primeira = false;
while(!teclado[C2D2_ESC].pressionado && nafase)
{
C2D2_LimpaTela();
// Testa as colisões
if(ATOR_ColidiuBlocoCenario(dark, mapa, C2D2M_MORTE))
{
ev.tipoEvento = EVT_COLIDIU_ARMADILHA;
ATOR_EnviaEvento(dark, &ev);
}
if(ATOR_ColidiuBlocoCenario(dark, mapa, C2D2M_CHECK))
{
ev.tipoEvento = EVT_CHECKPOINT;
ATOR_EnviaEvento(dark, &ev);
}
if(ATOR_ColidiuBlocoCenario(dark, mapa, C2D2M_FIM))
{
ev.tipoEvento = EVT_FIM_FASE;
ATOR_EnviaEvento(dark, &ev);
if(!primeira)
{
CA2_TocaMusica(musicas[1], -1);
primeira=true;
}
}
for(int i=0;i<numInimigos;i++)
if(inimigos[i]!=0)
ATOR_ColidiuAtores(dark, inimigos[i]);
// Atualiza a lógica
ATOR_AplicaEstado(dark, mapa, LARGURA_TELA, ALTURA_TELA);
for(int i=0;i<numInimigos;i++)
if(inimigos[i]!=0)
ATOR_AplicaEstado(inimigos[i], mapa, LARGURA_TELA, ALTURA_TELA);
// Lê os controles
ProcessaControle(dark);
// Atualiza os personagens
ATOR_Atualiza(dark, mapa);
for(int i=0;i<numInimigos;i++)
if(inimigos[i]!=0)
if(!ATOR_Atualiza(inimigos[i], mapa))
{
free(inimigos[i]);
inimigos[i]=0;
}
// Centraliza o mapa no personagem principal
ATOR_CentraMapa(dark, mapa, LARGURA_TELA, ALTURA_TELA);
// Roda os eventos do jogo
while(ATOR_ProximoEventoJogo(&ev))
{
switch(ev.tipoEvento)
{
case EVT_FIM_FASE:
nafase=false;
break;
}
}
// Desenha o cenário
C2D2M_DesenhaCamadaMapa(mapa, 0, 0, 0, 640, 480);
C2D2M_DesenhaCamadaMapa(mapa, 1, 0, 0, 640, 480);
C2D2M_DesenhaCamadaMapa(mapa, 2, 0, 0, 640, 480);
// DEsenha os personagens
ATOR_Desenha(dark, mapa, 0, 0);
for(int i=0;i<numInimigos;i++)
if(inimigos[i]!=0)
ATOR_Desenha(inimigos[i], mapa, 0, 0);
// Desenha a camada mais superior
C2D2M_DesenhaCamadaMapa(mapa, 3, 0, 0, 640, 480);
// DEsenha as mensagens
if((dark->estado.estado == DARK_MORRENDO || dark->estado.estado == DARK_MORREU) && dark->vidas>0)
C2D2_DesenhaTexto(fonte, LARGURA_TELA/2, ALTURA_TELA/2, "Ops!", C2D2_TEXTO_CENTRALIZADO);
if((dark->estado.estado == DARK_MORRENDO || dark->estado.estado == DARK_MORREU) && dark->vidas==0)
C2D2_DesenhaTexto(fonte, LARGURA_TELA/2, ALTURA_TELA/2, "Game Over", C2D2_TEXTO_CENTRALIZADO);
if(dark->estado.estado == DARK_VITORIA)
C2D2_DesenhaTexto(fonte, LARGURA_TELA/2, ALTURA_TELA/2, "Fase Completa!", C2D2_TEXTO_CENTRALIZADO);
C2D2_Sincroniza(C2D2_FPS_PADRAO);
if(teclado[C2D2_ENTER].ativo)
C2D2_Pausa(50);
C2D2M_AnimaMapa(mapa);
}
// Apaga os personagens
free(dark);
for(int i=0;i<numInimigos;i++)
if(inimigos[i]!=0)
free(inimigos[i]);
free(inimigos);
// Descarrega o personagem
ATOR_DescarregaAtor(DARKPHOENIX);
// Apaga as imagens carregadas na memória
C2D2_RemoveFonte(fonte);
// Encerra os atores
ATOR_Encerra();
// Encerra os mapas
C2D2M_Encerra();
// Encerra o áudio
CA2_Encerra();
// Encerra a Chien2D 2
C2D2_Encerra();
return 0;
}
int main(int args, char **argc){
//inicializações essenciais
C2D2_Inicia(400, 400, C2D2_JANELA, C2D2_DESENHO_OPENGL, "Pong"); //cria a janela
CA2_Inicia();
C2D2_Botao* teclado = C2D2_PegaTeclas(); //possibilita poder reconhecer as teclas do teclado
C2D2_Mouse* mouse = C2D2_PegaMouse(); //possibilita poder reconhecer os botoes do mouse
unsigned int bola = C2D2_CarregaSpriteSet("Assets/ball.png", 63, 63); //carrega a imagem da bola
int xBola = 100; //inicializa a posicao de x
int yBola = 200; //inicializa a posicao de y
int speed = 1; //define a velocidade incial da bola
int direcaoX = 1; //define a direcao inicial em x
int direcaoY = 1; //define a direcao inicial em y
int totalBolaFrames = 8; //responsavel por verificar o numero de frames
int atualBolaFrame = 0; //responsavel por verificar qual o frame atual
int tempoBolaTransicao = 10; //responsavel pelo tempo de troca de cada frame
//quando mais próximo de 0, mais rápido
//carrega a imagem para a mira
unsigned int mira = C2D2_CarregaSpriteSet("Assets/mira.png", 21, 21);
//define os dados da barra1 (sprite, posicao em x, e em y e a velocidade
unsigned int barra1 = C2D2_CarregaSpriteSet("Assets/barra.png", 61, 11);
int xBarra1 = 200;
int yBarra1 = 0;
int speedBarra1 = 1;
//define os dados da barra2 (sprite, posicao em x, e em y e a velocidade
unsigned int barra2 = C2D2_CarregaSpriteSet("Assets/barra.png", 61, 11);
int xBarra2 = 200;
int yBarra2 = 390;
int speedBarra2 = 1;
//Carregar Texto
unsigned int fonte = C2D2_CarregaFonte("Assets/fonte.png", 32);
//pontuação primeiro jogador
int scoreJogador1 = 0;
char scoreJogador1Text[4];
//pontuação segundo jogador
int scoreJogador2 = 0;
char scoreJogador2Text[4];
//carregar som de batida
unsigned int batida = CA2_CarregaEfeito("Assets/bate.ogg");
//permite que o fundo seja de cor azul
C2D2_TrocaCorLimpezaTela(0,100,255);
//Update do jogo
do{
C2D2_LimpaTela(); //a cada vez que o programa roda, ele limpa a tela, evitando lixo de imagem
//controle do jogador 1 com a barra 1
if(teclado[C2D2_D].ativo && xBarra1 <= 339){
xBarra1 = xBarra1+speedBarra1;
}else if(teclado[C2D2_A].ativo && xBarra1 >= 0){
xBarra1 = xBarra1-speedBarra1;
}
//controle jogador 2 com a barra 2
if(teclado[C2D2_DIREITA].ativo && xBarra2 <= 339){
xBarra2 = xBarra2+speedBarra2;
}else if(teclado[C2D2_ESQUERDA].ativo && xBarra2 >= 0){
xBarra2 = xBarra2-speedBarra2;
}
//detectar se houve colisao
if(C2D2_ColidiuSprites(bola, atualBolaFrame, xBola, yBola, mira, 0, mouse->x, mouse->y)){
//detectar os botoes do mouse
if(mouse->botoes[C2D2_MESQUERDO].pressionado){
C2D2_TrocaCorLimpezaTela(0,255,0);
}else if(mouse->botoes[C2D2_MDIREITO].pressionado){
C2D2_TrocaCorLimpezaTela(255, 0, 0);
}else if(mouse->botoes[C2D2_MMEIO].pressionado){
C2D2_TrocaCorLimpezaTela(0, 0, 255);
}
}
//verifica se houve colisao da bola com a barra 1
if(C2D2_ColidiuSprites(bola, 0, xBola, yBola, barra1, 0, xBarra1, yBarra1)){
direcaoY *= -1;
speed++;
CA2_TocaEfeito(batida, CA2_CENTRO);
}
//verifica se houve colisao da bola com a barra 2
if(C2D2_ColidiuSprites(bola, 0, xBola, yBola, barra2, 0, xBarra2, yBarra2)){
direcaoY *= -1;
speed++;
CA2_TocaEfeito(batida, CA2_CENTRO);
}
//verifica se a bola bateu nas laterais do jogo
if(xBola <= 0 || xBola >= 347){ //lateral direita esquerda
direcaoX *=-1;
if(xBola <=0){
CA2_TocaEfeito(batida, CA2_ESQUERDA);
}else if(xBola >= 347){
CA2_TocaEfeito(batida, CA2_DIREITA);
}
}else if(yBola <= -10 || yBola >= 356){ //lateral inferior superior
if(yBola <= -10){
scoreJogador2++;
}else if(yBola >= 356){
scoreJogador1++;
}
xBola = 200;
yBola = 200;
speed = 1;
}
//a bola sempre esta em movimento
xBola = xBola+(speed*direcaoX);
yBola = yBola+(speed*direcaoY);
//animação da bola
tempoBolaTransicao++;
if(tempoBolaTransicao >= 2){
atualBolaFrame++;
if(atualBolaFrame>=totalBolaFrames){
atualBolaFrame = 0;
}
tempoBolaTransicao = 0;
}
//Area de desenho. A ordem de desenho influencia
C2D2_DesenhaSprite(mira, 0, mouse->x, mouse->y);
C2D2_DesenhaTexto(fonte, 10, 50, "PONG__:D", C2D2_TEXTO_ESQUERDA);
itoa(scoreJogador1, scoreJogador1Text, 10);
C2D2_DesenhaTexto(fonte, 10, 85, scoreJogador1Text, C2D2_TEXTO_ESQUERDA);
itoa(scoreJogador2, scoreJogador2Text, 10);
C2D2_DesenhaTexto(fonte, 400, 85, scoreJogador2Text, C2D2_TEXTO_DIREITA);
C2D2_DesenhaSprite(bola, atualBolaFrame, xBola, yBola);
C2D2_DesenhaSprite(barra1, 0, xBarra1, yBarra1);
C2D2_DesenhaSprite(barra2, 0, xBarra2, yBarra2);
//sincroniza o jogo
C2D2_Sincroniza(C2D2_FPS_PADRAO);
}while(!teclado[C2D2_ESC].pressionado && !teclado[C2D2_ENCERRA].pressionado);
CA2_Encerra();
C2D2_Encerra();
//finaliza o jogo
return 0;
}
void Creditos()
{
C2D2_Botao *teclado = C2D2_PegaTeclas();
unsigned long int tempo=ttotal;
C2D2_TrocaCorLimpezaTela(128,128,128);
int deslocamento;
// Desenha as retas no fundo
int x, y, angulo=45;
do
{
// Calcula a coordenada x,y da reta (diagonal tamanho 396, para círculo de raio 280)
x = 280*cos(angulo*RAD);
y = 280*sin(angulo*RAD);
angulo=(angulo+2)%360;
// Atualiza o deslocamento
deslocamento = 600 - (1612.0*(tempo-ttotal))/11700;
C2D2_LimpaTela();
// Desenha as retas
C2D2P_Linha(400+x, 300-y, 400-x, 300+y, 0, 0, 128);
C2D2P_Linha(400-x, 300-y, 400+x, 300+y, 0, 0, 128);
C2D2_DesenhaTexto(fpequeno, 400, deslocamento, "Programação e Gráficos", C2D2_TEXTO_CENTRALIZADO);
C2D2_DesenhaTexto(fsistema, 400, deslocamento+32, "Paulo V. W. Radtke", C2D2_TEXTO_CENTRALIZADO);
C2D2_DesenhaTexto(fpequeno, 400, deslocamento+196, "Música", C2D2_TEXTO_CENTRALIZADO);
C2D2_DesenhaTexto(fsistema, 400, deslocamento+228, "2nd Reality", C2D2_TEXTO_CENTRALIZADO);
C2D2_DesenhaTexto(fpequeno, 400, deslocamento+292, "por Purple Motion", C2D2_TEXTO_CENTRALIZADO);
C2D2_DesenhaTexto(fpequeno, 400, deslocamento+424, "Agradecimentos", C2D2_TEXTO_CENTRALIZADO);
C2D2_DesenhaTexto(fsistema, 400, deslocamento+456, "BCS", C2D2_TEXTO_CENTRALIZADO);
C2D2_DesenhaTexto(fsistema, 400, deslocamento+520, "Mel", C2D2_TEXTO_CENTRALIZADO);
C2D2_DesenhaTexto(fsistema, 400, deslocamento+584, "Pio", C2D2_TEXTO_CENTRALIZADO);
C2D2_DesenhaTexto(fpequeno, 400, deslocamento+748, "Copywrong 2008", C2D2_TEXTO_CENTRALIZADO);
C2D2_DesenhaTexto(fpequeno, 400, deslocamento+780, "Quase nenhum direito reservado.", C2D2_TEXTO_CENTRALIZADO);
// termina em 812.
//tem que pular 600 pontos no começo, mais 100 de lambuja pra cada lado. total de 1612 pontos
tempo=RelogioDigital(692,552);
C2D2_Sincroniza(C2D2_FPS_PADRAO);
}
while(tempo-ttotal < 11700 && !teclado[C2D2_ESC].pressionado && !teclado[C2D2_ENCERRA].pressionado);
// Apaga a tela com barras pretas
deslocamento=0;
do
{
// Calcula o quanto deceu na tela
deslocamento = (300.0*(tempo-ttotal-11700))/500;
// Calcula a coordenada x,y da reta (diagonal tamanho 396, para círculo de raio 280)
x = 280*cos(angulo*RAD);
y = 280*sin(angulo*RAD);
angulo=(angulo+2)%360;
C2D2_LimpaTela();
// Desenha as retas
C2D2P_Linha(400+x, 300-y, 400-x, 300+y, 0, 0, 128);
C2D2P_Linha(400-x, 300-y, 400+x, 300+y, 0, 0, 128);
C2D2P_RetanguloPintado(0, 0, 799, deslocamento, 0, 0, 0);
C2D2P_RetanguloPintado(0, 600-deslocamento, 799, 599, 0, 0, 0);
tempo=RelogioDigital(692,552);
C2D2_Sincroniza(C2D2_FPS_PADRAO);
}
while(tempo-ttotal < 12200 && !teclado[C2D2_ESC].pressionado && !teclado[C2D2_ENCERRA].pressionado);
ttotal += 12200;
}
void Estrela()
{
C2D2_Botao *teclado = C2D2_PegaTeclas();
unsigned long int tempo;
int angulo=0;
int cor=0, dcor=5, zoom=100, dzoom=5;
C2D2_TrocaCorLimpezaTela(0,0,0);
// Os vetores de pontos
int x[4], y[4];
int estado = 0;
do
{
// calcula os pontos da estrela
x[0] = 400+(181.0*zoom/100)*cos((angulo+45)*RAD);
x[1] = 400+(181.0*zoom/100)*cos((angulo+135)*RAD);
x[2] = 400+(181.0*zoom/100)*cos((angulo+225)*RAD);
x[3] = 400+(181.0*zoom/100)*cos((angulo+315)*RAD);
y[0] = 300-(181.0*zoom/100)*sin((angulo+45)*RAD);
y[1] = 300-(181.0*zoom/100)*sin((angulo+135)*RAD);
y[2] = 300-(181.0*zoom/100)*sin((angulo+225)*RAD);
y[3] = 300-(181.0*zoom/100)*sin((angulo+315)*RAD);
// Calcula a cor
cor+=dcor;
if(cor == 0 || cor == 255)
dcor*=-1;
// Atualiza o angulo
angulo=(angulo+2)%360;
// Calcula o zoom se necessário
if(estado!=0)
{
zoom+=dzoom;
if(zoom==20 || zoom==200)
dzoom*=-1;
}
// DEsenha a estrela
C2D2_LimpaTela();
C2D2_DesenhaSpriteEfeito(sprite2, 0, x, y, 255, 255, cor, 255);
if(estado==0)
C2D2_DesenhaTexto(fsistema, 400, 500, "Rotação + cor.", C2D2_TEXTO_CENTRALIZADO);
else
C2D2_DesenhaTexto(fsistema, 400, 500, "Rotação+zoom+cor.", C2D2_TEXTO_CENTRALIZADO);
tempo=RelogioDigital(692,552);
if(tempo-ttotal>10000)
estado=1;
C2D2_Sincroniza(C2D2_FPS_PADRAO);
}
while(tempo-ttotal < 20000 && !teclado[C2D2_ESC].pressionado && !teclado[C2D2_ENCERRA].pressionado);
// Os pontos das 3 estrelas
int xs[3][4];
int ys[3][4];
// O centro das estrelas
int cx[3]={300, 400, 500};
int cy[3]={400, 200, 400};
do
{
// calcula os pontos da estrela
for(int i=0;i<3;i++)
{
xs[i][0] = cx[i]+(181.0*zoom/100)*cos((angulo+45)*RAD);
xs[i][1] = cx[i]+(181.0*zoom/100)*cos((angulo+135)*RAD);
xs[i][2] = cx[i]+(181.0*zoom/100)*cos((angulo+225)*RAD);
xs[i][3] = cx[i]+(181.0*zoom/100)*cos((angulo+315)*RAD);
ys[i][0] = cy[i]-(181.0*zoom/100)*sin((angulo+45)*RAD);
ys[i][1] = cy[i]-(181.0*zoom/100)*sin((angulo+135)*RAD);
ys[i][2] = cy[i]-(181.0*zoom/100)*sin((angulo+225)*RAD);
ys[i][3] = cy[i]-(181.0*zoom/100)*sin((angulo+315)*RAD);
}
// Calcula a cor
cor+=dcor;
if(cor == 0 || cor == 255)
dcor*=-1;
// Atualiza o angulo
angulo=(angulo+2)%360;
// Calcula o zoom se necessário
zoom+=dzoom;
if(zoom==20 || zoom==300)
dzoom*=-1;
// DEsenha as estrela
C2D2_LimpaTela();
C2D2_DesenhaSpriteEfeito(sprite2, 0, xs[0], ys[0], cor, 255, 255, 192);
C2D2_DesenhaSpriteEfeito(sprite2, 0, xs[1], ys[1], 255, cor, 255, 192);
C2D2_DesenhaSpriteEfeito(sprite2, 0, xs[2], ys[2], 255, 255, cor, 192);
C2D2_DesenhaTexto(fsistema, 400, 500, "Tudo!", C2D2_TEXTO_CENTRALIZADO);
tempo=RelogioDigital(692,552);
if(tempo-ttotal>10000)
estado=1;
C2D2_Sincroniza(C2D2_FPS_PADRAO);
}
while(tempo-ttotal < 33000 && !teclado[C2D2_ESC].pressionado && !teclado[C2D2_ENCERRA].pressionado);
ttotal += 33000;
}
// Função demonstrando o básico de sprites
void Sprites()
{
C2D2_Botao *teclado = C2D2_PegaTeclas();
unsigned long int tempo;
C2D2_TrocaCorLimpezaTela(0,0,0);
int posicao=0;
int direcao=1;
do
{
// Atualiza a posição
posicao+=direcao;
if(posicao==7 || posicao==0)
direcao*=-1;
C2D2_LimpaTela();
// DEsenha os sprites da parte A
for(int i=0;i<25;i++)
for(int j=0;j<10;j++)
{
C2D2_DesenhaSprite(sprite1, (i+j)%24, posicao+32*i, 0+64*j);
C2D2_DesenhaSprite(sprite1, (i+j)%24, -posicao+32*i, 0+64*j);
C2D2_DesenhaSprite(sprite1, (i+j)%24, 32*i, posicao+64*j);
C2D2_DesenhaSprite(sprite1, (i+j)%24, 32*i, -posicao+64*j);
}
// DEsenha os sprites da parte B
for(int i=0;i<27;i++)
for(int j=0;j<12;j++)
{
C2D2_DesenhaSprite(sprite1, (i+j+4)%24, -16+posicao+32*i, -32+64*j);
C2D2_DesenhaSprite(sprite1, (i+j+4)%24, -16-posicao+32*i, -32+64*j);
C2D2_DesenhaSprite(sprite1, (i+j+4)%24, -16+32*i, -32+posicao+64*j);
C2D2_DesenhaSprite(sprite1, (i+j+4)%24, -16+32*i, -32-posicao+64*j);
}
C2D2_DesenhaTexto(fsistema, 400, 500, "2000 sprites.", C2D2_TEXTO_CENTRALIZADO);
tempo=RelogioDigital(692,552);
C2D2_Sincroniza(C2D2_FPS_PADRAO);
}
while(tempo-ttotal < 15000 && !teclado[C2D2_ESC].pressionado && !teclado[C2D2_ENCERRA].pressionado);
do
{
// Atualiza a posição
posicao+=direcao;
if(posicao==7 || posicao==0)
direcao*=-1;
C2D2_LimpaTela();
// Os vetores de pontos
int x[4], y[4];
// DEsenha os sprites da parte A
for(int i=0;i<25;i++)
for(int j=0;j<10;j++)
{
x[0]=x[3] = posicao+32*i;
x[1]=x[2] = posicao+32*i+32;
y[0]=y[1] = 0+64*j;
y[2]=y[3] = 0+64*j+64;
C2D2_DesenhaSpriteEfeito(sprite1, (i+j)%24, x, y, 255, 255, 255, 255);
x[0]=x[3] = -posicao+32*i;
x[1]=x[2] = -posicao+32*i+32;
y[0]=y[1] = 0+64*j;
y[2]=y[3] = 0+64*j+64;
C2D2_DesenhaSpriteEfeito(sprite1, (i+j)%24, x, y, 255, 0, 0, 255);
x[0]=x[3] = 32*i;
x[1]=x[2] = 32*i+32;
y[0]=y[1] = posicao+64*j;
y[2]=y[3] = posicao+64*j+64;
C2D2_DesenhaSpriteEfeito(sprite1, (i+j)%24, x, y, 0, 255, 0, 255);
x[0]=x[3] = 32*i;
x[1]=x[2] = 32*i+32;
y[0]=y[1] = -posicao+64*j;
y[2]=y[3] = -posicao+64*j+64;
C2D2_DesenhaSpriteEfeito(sprite1, (i+j)%24, x, y, 0, 0, 255, 255);
}
// DEsenha os sprites da parte B
for(int i=0;i<27;i++)
for(int j=0;j<12;j++)
{
x[0]=x[3] = -16+posicao+32*i;
x[1]=x[2] = -16+posicao+32*i+32;
y[0]=y[1] = -32+0+64*j;
y[2]=y[3] = -32+0+64*j+64;
C2D2_DesenhaSpriteEfeito(sprite1, (i+j)%24, x, y, 255, 255, 255, 127);
x[0]=x[3] = -16-posicao+32*i;
x[1]=x[2] = -16-posicao+32*i+32;
y[0]=y[1] = -32+0+64*j;
y[2]=y[3] = -32+0+64*j+64;
C2D2_DesenhaSpriteEfeito(sprite1, (i+j)%24, x, y, 255, 0, 0, 127);
x[0]=x[3] = -16+32*i;
x[1]=x[2] = -16+32*i+32;
y[0]=y[1] = -32+posicao+64*j;
y[2]=y[3] = -32+posicao+64*j+64;
C2D2_DesenhaSpriteEfeito(sprite1, (i+j)%24, x, y, 0, 255, 0, 127);
x[0]=x[3] = -16+32*i;
x[1]=x[2] = -16+32*i+32;
y[0]=y[1] = -32-posicao+64*j;
y[2]=y[3] = -32-posicao+64*j+64;
C2D2_DesenhaSpriteEfeito(sprite1, (i+j)%24, x, y, 0, 0, 255, 127);
}
C2D2_DesenhaTexto(fsistema, 400, 500, "Efeito de cor e alpha.", C2D2_TEXTO_CENTRALIZADO);
tempo=RelogioDigital(692,552);
C2D2_Sincroniza(C2D2_FPS_PADRAO);
}
while(tempo-ttotal < 30000 && !teclado[C2D2_ESC].pressionado && !teclado[C2D2_ENCERRA].pressionado);
// Adiciona ao tempo total o tempo passado nesta parte
ttotal+=30000;
}
// Função para demonstrar as primitivas
void Primitivas()
{
C2D2_Botao *teclado = C2D2_PegaTeclas();
unsigned long int tempo;
// DEsenha os círculos pulsando
C2D2_TrocaCorLimpezaTela(200, 200, 200);
// usa o seno para fazer o tamanho variável
int angulo=0, tamanho;
do
{
// Calcula o tamanho
tamanho = abs(35*sin(angulo*RAD));
// Atualiza o angulo
angulo=(angulo+1)%360;
// Limpa a tela
C2D2_LimpaTela();
// DEsenha os círculos do tamanho normal
for(int i=0;i<10;i++)
for(int j=0; j<8;j++)
{
C2D2P_CirculoPintado(40+80*i, 40+80*j, 5+tamanho, 255, 0, 0);
C2D2P_Circulo(40+80*i, 40+80*j, 5+tamanho, 128, 0, 0);
}
// DEsenha os círculos do tamanho diferente
for(int i=0;i<12;i++)
for(int j=0; j<9;j++)
{
C2D2P_CirculoPintado(80*i, 80*j, 40-tamanho, 0, 255, 0);
C2D2P_Circulo(80*i, 80*j, 40-tamanho, 0, 128, 0);
}
// DEsenha o relógio contador e pega o tempo
tempo=RelogioDigital(692,552);
C2D2_DesenhaTexto(fsistema, 400, 500, "180 círculos com borda.", C2D2_TEXTO_CENTRALIZADO);
C2D2_Sincroniza(C2D2_FPS_PADRAO);
}
while(tempo-ttotal < 13500 && !teclado[C2D2_ESC].pressionado && !teclado[C2D2_ENCERRA].pressionado);
// Desenha as retas
int posicao=0, direcao=1;
int cor=0;
C2D2_TrocaCorLimpezaTela(0,0,0);
do
{
// Atualiza a posição
posicao+=direcao;
if(posicao==7 || posicao==0)
direcao*=-1;
C2D2_LimpaTela();
cor=0;
// Desenha as linhas para os retângulos vermelhos
for(int i=0;i<37;i++)
{
C2D2P_Linha(posicao+8*i, posicao+8*i, posicao+791-8*i, posicao+8*i, 255-cor, 0, 0);
C2D2P_Linha(posicao+8*i, posicao+591-8*i, posicao+791-8*i, posicao+591-8*i, 255-cor, 0, 0);
C2D2P_Linha(posicao+8*i, posicao+8*i, posicao+8*i, posicao+591-8*i, 255-cor, 0, 0);
C2D2P_Linha(posicao+791-8*i, posicao+8*i, posicao+791-8*i, posicao+591-8*i, 255-cor, 0, 0);
cor++;
}
cor=0;
// Desenha as linhas para os retângulos azuis
for(int i=0;i<37;i++)
{
C2D2P_Linha(4+8*i, 2+posicao+8*i, 4+791-8*i, 2+posicao+8*i, 0, 0, 255-cor);
C2D2P_Linha(4+8*i, 2+posicao+591-8*i, 4+791-8*i, 2+posicao+591-8*i, 0, 0, 255-cor);
C2D2P_Linha(4+8*i, 2+posicao+8*i, 4+8*i, 2+posicao+591-8*i, 0, 0, 255-cor);
C2D2P_Linha(4+791-8*i, 2+posicao+8*i, 4+791-8*i, 2+posicao+591-8*i, 0, 0, 255-cor);
cor++;
}
C2D2_DesenhaTexto(fsistema, 400, 500, "296 linhas.", C2D2_TEXTO_CENTRALIZADO);
tempo=RelogioDigital(692,552);
C2D2_Sincroniza(C2D2_FPS_PADRAO);
}
while(tempo-ttotal < 27000 && !teclado[C2D2_ESC].pressionado && !teclado[C2D2_ENCERRA].pressionado);
// Adiciona ao tempo total o tempo passado nesta parte
ttotal+=27000;
}
