// A função da parte inicial
void Intro()
{
C2D2_Botao *teclado = C2D2_PegaTeclas();
unsigned long int tempo;
// Desenha a tela do tux enquanto não passar 6,5 segundos
do
{
C2D2_DesenhaSprite(tuxwindows, 0, 0, 0);
// DEsenha o relógio contador e pega o tempo
tempo=RelogioDigital(692,552);
C2D2_Sincroniza(C2D2_FPS_PADRAO);
}
while(tempo < 6500 && !teclado[C2D2_ESC].pressionado && !teclado[C2D2_ENCERRA].pressionado);
// Cai a tela por 1,5 segundos
do
{
C2D2_DesenhaSprite(titulo, 0, 0, 0);
C2D2_DesenhaSprite(tuxwindows, 0, 0, 600*(tempo-6500)/1500);
// DEsenha o relógio contador e pega o tempo
tempo=RelogioDigital(692,552);
C2D2_Sincroniza(C2D2_FPS_PADRAO);
}
while(tempo < 8000 && !teclado[C2D2_ESC].pressionado && !teclado[C2D2_ENCERRA].pressionado);
// Mostra o título por 5 segundos
do
{
C2D2_DesenhaSprite(titulo, 0, 0, 0);
// DEsenha o relógio contador e pega o tempo
tempo=RelogioDigital(692,552);
C2D2_Sincroniza(C2D2_FPS_PADRAO);
}
while(tempo < 15000 && !teclado[C2D2_ESC].pressionado && !teclado[C2D2_ENCERRA].pressionado);
// Indica o tempo total já passado para o próximo módulo
ttotal = 15000;
}
void BarraCarregamento(int carregados, int total)
{
// Calcula a cor
int cor = 255*carregados/total;
C2D2_LimpaTela();
// A barra tem 600 pontos de largura. Desenha o contorno primeiro
C2D2P_Retangulo(95, 270, 705, 330, 255-cor, cor, 0);
// DEsenha a barra proporcional
C2D2P_RetanguloPintado(100, 275, 100+600*carregados/total , 325, 255-cor, cor, 0);
C2D2_Sincroniza(C2D2_FPS_PADRAO);
}
void Shutar::GameLoop()
{
//Tudo que for iniciado precisar ser encerrado ... JANELA ATORES SONS ETC
while (GameState < 5)
{
//se musica esta tocando não toca de novo
if (!tocandomusica)
{
switch (GameState)
{
case 1:
CA2_AjustaVolume(25,-1);
CA2_TocaMusica(GameState, -1);
tocandomusica = true;
break;
case 2:
CA2_AjustaVolume(25, 100);
CA2_TocaMusica(GameState, 100);
tocandomusica = true;
break;
case 3:
CA2_AjustaVolume(30, 100);
CA2_TocaMusica(GameState, -1);
tocandomusica = true;
break;
}
}
Update(GameState);
Draw();
C2D2_Sincroniza(C2D2_FPS_PADRAO);
}
}
int main(int ac, char **av)
{
srand((unsigned)time(NULL));
WSAData wsaData;
WSAStartup(MAKEWORD(2, 2), &wsaData);
sockaddr_in meuEndereco;
meuEndereco.sin_addr.s_addr = INADDR_ANY;
meuEndereco.sin_family = AF_INET;
meuEndereco.sin_port = htons(9000 + (rand()%1000));
SOCKET meuSocket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
bind(meuSocket, (sockaddr*)&meuEndereco, sizeof(meuEndereco));
sockaddr_in destinatario;
destinatario.sin_addr.s_addr = inet_addr("10.96.26.85");
destinatario.sin_family = AF_INET;
destinatario.sin_port = htons(8888);
sockaddr_in enderecoRemetente;
int enderecoRemetenteTam = sizeof(enderecoRemetente);
int comando = 0;
int cliente;
int clientes = 0;
int x[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
int y[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
sendto(meuSocket, (char*)&comando, sizeof(int), NULL, (sockaddr*)&destinatario, sizeof(destinatario));
int r = recvfrom(meuSocket, (char*)&cliente, sizeof(int), NULL, (sockaddr*)&enderecoRemetente, &enderecoRemetenteTam);
C2D2_Inicia(800, 600, C2D2_JANELA, C2D2_DESENHO_OPENGL, "Amostragem");
C2D2_Botao *teclado;
teclado = C2D2_PegaTeclas();
C2D2_Mouse *mouse;
mouse = C2D2_PegaMouse();
C2D2_TrocaCorLimpezaTela(0, 120, 0);
unsigned int cursorSprite;
cursorSprite = C2D2_CarregaSpriteSet("cursor.png", 25, 25);
unsigned long proximaAtualizacaoFrame = C2D2_TempoSistema() + 100;
while (!teclado[C2D2_ESC].pressionado)
{
if (proximaAtualizacaoFrame < C2D2_TempoSistema())
{
proximaAtualizacaoFrame = C2D2_TempoSistema() + 100;
comando = 1;
sendto(meuSocket, (char*)&comando, sizeof(int), NULL, (sockaddr*)&destinatario, sizeof(destinatario));
sendto(meuSocket, (char*)&cliente, sizeof(int), NULL, (sockaddr*)&destinatario, sizeof(destinatario));
sendto(meuSocket, (char*)&mouse->x, sizeof(int), NULL, (sockaddr*)&destinatario, sizeof(destinatario));
sendto(meuSocket, (char*)&mouse->y, sizeof(int), NULL, (sockaddr*)&destinatario, sizeof(destinatario));
comando = 2;
sendto(meuSocket, (char*)&comando, sizeof(int), NULL, (sockaddr*)&destinatario, sizeof(destinatario));
recvfrom(meuSocket, (char*)&clientes, sizeof(int), NULL, (sockaddr*)&enderecoRemetente, &enderecoRemetenteTam);
for (int i = 0; i < clientes; i++){
recvfrom(meuSocket, (char*)&x[i], sizeof(int), NULL, (sockaddr*)&enderecoRemetente, &enderecoRemetenteTam);
recvfrom(meuSocket, (char*)&y[i], sizeof(int), NULL, (sockaddr*)&enderecoRemetente, &enderecoRemetenteTam);
}
}
C2D2_LimpaTela();
C2D2_DesenhaSprite(cursorSprite,
0, mouse->x, mouse->y);
for (int i = 0; i < clientes; i++){
if (i+1 == cliente) continue;
C2D2_DesenhaSprite(cursorSprite,
0, x[i], y[i]);
}
C2D2_Sincroniza(C2D2_FPS_PADRAO);
}
C2D2_RemoveSpriteSet(cursorSprite);
C2D2_Encerra();
closesocket(meuSocket);
WSACleanup();
return 0;
}
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 narg, char **valarg)
{
// Inicia a Chien2D 2 e testa se deu tudo certo
if(C2D2_Inicia(LARGTELA, ALTTELA, C2D2_JANELA, C2D2_DESENHO_PADRAO, "Rotação"))
printf("Iniciou a Chien2D 2 com sucesso\n");
else
{
printf("Falhou ao iniciar a Chien2D 2. Encerrando o programa.\n");
return 0;
}
// os sprites
unsigned int spritescertos[4], spriteserrados[4], help;
// Coordenadas na tela
float xf[16], yf[16], xtrf[16], ytrf[16];
int xi[16], yi[16], xtri[16], ytri[16];
float angulo = 0;
// Escolhe se desenha certo ou não
bool certo = false;
// O zoom a aplicar
int zoom = 200;
for(int i=0;i<4;i++)
{
char nome[40];
sprintf(nome, "graficos/rotacao%i.png", i);
spritescertos[i]= C2D2_CarregaSpriteSet(nome, TAMSPRITE+2, TAMSPRITE+2);
xf[0+i*4] = xf[3+i*4] = -TAMSPRITE + TAMSPRITE*(i%2);
xf[1+i*4] = xf[2+i*4] = (i%2)*TAMSPRITE;
yf[0+i*4] = yf[1+i*4] = (TAMSPRITE - (i/2)*TAMSPRITE);
yf[2+i*4] = yf[3+i*4] = -(i/2)*TAMSPRITE;
// Faz o mesmo para os sprites errados
sprintf(nome, "graficos/rotacaoerrado%i.png", i);
spriteserrados[i]= C2D2_CarregaSpriteSet(nome, TAMSPRITE, TAMSPRITE);
xi[0+i*4] = xi[3+i*4] = -TAMSPRITE + TAMSPRITE*(i%2);
xi[1+i*4] = xi[2+i*4] = (i%2)*TAMSPRITE;
yi[0+i*4] = yi[1+i*4] = (TAMSPRITE - (i/2)*TAMSPRITE);
yi[2+i*4] = yi[3+i*4] = -(i/2)*TAMSPRITE;
}
help = C2D2_CarregaSpriteSet("graficos/help.png", 0, 0);
// Recupera o teclado
C2D2_Botao *teclas = C2D2_PegaTeclas();
// Recupera o mouse
C2D2_Mouse *mouse = C2D2_PegaMouse();
C2D2_TrocaCorLimpezaTela(255,0,0);
do
{
// Muda o zoom?
if(teclas[C2D2_Z].ativo && zoom > 1)
zoom--;
else if(teclas[C2D2_X].ativo && zoom < 400)
zoom++;
// Troca o render?
if(teclas[C2D2_ESPACO].pressionado)
certo = !certo;
// Calcula o novo angulo
if(teclas[C2D2_ENTER].ativo)
angulo+=1.5;
else
angulo+=0.3;
if(angulo>360)
angulo-=360;
// Rotaciona os pontos
for(int i=0;i<16;i++)
{
// Os pontos certos
xtrf[i] = LARGTELA/2 + (xf[i]*zoom/100.0)*cos(RAD*angulo) + (yf[i]*zoom/100.0)*sin(RAD*angulo);
ytrf[i] = ALTTELA/2 - ((xf[i]*zoom/100.0)*-sin(RAD*angulo) + (yf[i]*zoom/100.0)*cos(RAD*angulo));
// Os pontos errados
xtri[i] = LARGTELA/2 + (xi[i]*zoom/100.0)*cos(RAD*angulo) + (yi[i]*zoom/100.0)*sin(RAD*angulo);
ytri[i] = ALTTELA/2 - ((xi[i]*zoom/100.0)*-sin(RAD*angulo) + (yi[i]*zoom/100.0)*cos(RAD*angulo));
}
// Limpa a tela com a cor de fundo atual
C2D2_LimpaTela();
// Desenha os sprites
for(int i=0;i<4;i++)
{
if(certo)
C2D2_DesenhaSpriteEfeitoSubpixel(spritescertos[i], 0, &xtrf[i*4], &ytrf[i*4], 255, 255, 255, 255);
else
C2D2_DesenhaSpriteEfeito(spriteserrados[i], 0, &xtri[i*4], &ytri[i*4], 255, 255, 255, 255);
}
C2D2_DesenhaSprite(help, 0, 10, 10);
// Faz a troca do front buffer com o back buffer e atualiza as entradas
C2D2_Sincroniza(C2D2_FPS_PADRAO);
}
while(!teclas[C2D2_ENCERRA].pressionado && !teclas[C2D2_ESC].pressionado);
// Remove as imagens
for(int i=0;i<4;i++)
{
C2D2_RemoveSpriteSet(spritescertos[i]);
C2D2_RemoveSpriteSet(spriteserrados[i]);
}
C2D2_RemoveSpriteSet(help);
// 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;
}
int main(int ac, char **av)
{
if(!C2D2_Inicia(800, 600, C2D2_JANELA, C2D2_DESENHO_OPENGL, "Chien 2D v2.0 Megademo"))
{
printf("Nao conseguiu iniciar a tela. Encerrando.\n");
return 1;
}
// Inicia o áudio
CA2_Inicia();
// Inicia o desenho de primitivas
C2D2P_Inicia();
// Obtém o teclado
C2D2_Botao *teclado = C2D2_PegaTeclas();
// Indica se deve encerrar o demo
bool encerra = false;
// Indica o estado do demo
int estado = 0;
// Carrega os recursos
if(Carrega())
{
// Toca a música
CA2_TocaMusica(mfundo, 1);
while(!encerra && !teclado[C2D2_ESC].pressionado && !teclado[C2D2_ENCERRA].pressionado)
{
switch(estado)
{
case 0:
Intro();
estado++;
break;
case 1:
Primitivas();
estado++;
break;
case 2:
Sprites();
estado++;
break;
case 3:
Estrela();
estado++;
break;
case 4:
Creditos();
estado++;
break;
case 5:
C2D2_TrocaCorLimpezaTela(0,0,0);
C2D2_LimpaTela();
if(RelogioDigital(692,552) > 119000)
estado++;
C2D2_Sincroniza(C2D2_FPS_PADRAO);
break;
default:
encerra=true;
}
}
CA2_PausaMusica();
// DEscarrega os recursos
Descarrega();
}
else
printf("Opa! Falhou algo. Encerrando.\n");
// Encerra tudo
CA2_Encerra();
C2D2_Encerra();
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;
}
