// Função que carrega os recursos globais
bool Carrega()
{
int carga=0;
BarraCarregamento(carga, NUM_RECURSOS);
mfundo = CA2_CarregaMusica("./audio/2nd_PurpleMotion.s3m");
BarraCarregamento(++carga, NUM_RECURSOS);
fdigital = C2D2_CarregaFonte("./fontes/digital.png", 16);
BarraCarregamento(++carga, NUM_RECURSOS);
fsistema = C2D2_CarregaFonte("./fontes/isabelle64.png", 64);
BarraCarregamento(++carga, NUM_RECURSOS);
fpequeno = C2D2_CarregaFonte("./fontes/arial32.png", 32);
BarraCarregamento(++carga, NUM_RECURSOS);
tuxwindows = C2D2_CarregaSpriteSet("./graficos/tuxwindows.jpg", 0, 0);
BarraCarregamento(++carga, NUM_RECURSOS);
titulo = C2D2_CarregaSpriteSet("./graficos/titulo.png", 0, 0);
BarraCarregamento(++carga, NUM_RECURSOS);
sprite1 = C2D2_CarregaSpriteSet("./graficos/atriz.png", 32, 64);
BarraCarregamento(++carga, NUM_RECURSOS);
sprite2 = C2D2_CarregaSpriteSet("./graficos/estrela.png", 256, 256);
BarraCarregamento(++carga, NUM_RECURSOS);
return true;
}
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(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;
}
void Shutar::Setup()
{
//musicas do jogo
musicas[0] = CA2_CarregaMusica("");
musicas[1] = CA2_CarregaMusica("splashloop.wav");
musicas[2] = CA2_CarregaMusica("bgloop.wav");
//carrega sprites simples
logoPUC = C2D2_CarregaSpriteSet("splashprojeto.png", 0, 0);
menu = C2D2_CarregaSpriteSet("screenmenu.jpg", 0, 0);
jogorolando = C2D2_CarregaSpriteSet("jogorolando.png", 0, 0);
mouseTX = C2D2_CarregaSpriteSet("mira.png", 24, 24);
hud_nergy = C2D2_CarregaSpriteSet("hud_energy.png", 120, 24);
gameoverTela = C2D2_CarregaSpriteSet("tela_game_over.png", 0, 0);
damage1 = C2D2_CarregaSpriteSet("damage_1.png", 276, 28);
damage2 = C2D2_CarregaSpriteSet("damage_2.png", 276, 28);
damage3 = C2D2_CarregaSpriteSet("damage_3.png", 276, 28);
damage4 = C2D2_CarregaSpriteSet("damage_4.png", 276, 28);
damage5 = C2D2_CarregaSpriteSet("damage_5.png", 276, 28);
damage6 = C2D2_CarregaSpriteSet("damage_6.png", 276, 28);
damage7 = C2D2_CarregaSpriteSet("damage_7.png", 276, 28);
damage8 = C2D2_CarregaSpriteSet("damage_8.png", 276, 28);
damage9 = C2D2_CarregaSpriteSet("damage_9.png", 276, 28);
damage10 = C2D2_CarregaSpriteSet("damage_10.png", 276, 28);
//carrega atores do jogo
bool cnave = Nave_Carrega();
bool ctiro = Tiro_Carrega();
bool cbomba = Bomba_Carrega();
bool credboss = RedBoss_Carrega();
bool cminired = MiniRed_Carrega();
bool cbatrobo = BatRobo_Carrega();
bool cocorrencia = Ocorrencia_Carrega();
//inimigo MiniShooter
bool cminishooter = MiniShooter_Carrega();
bool ctiroInimigo = TiroInimigo_Carrega();
//carrega mapa
mapa = C2D2M_CarregaMapaMappy("mapa5.FMP", "sheetstar01.png");
//mapa = C2D2M_CarregaMapaMappy("fase01_(90x90).FMP", "sheetstar01.png");
int numcamadas = 4;
//define a marca inical dos tiles programados da chien
C2D2M_CamadaMarcas(mapa, 3, 89);
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);
int tpX = 0, tpY = 0; //apenas referencia para coord serem trazidas
//PROCURA SABER NUMERO TOTAL DE INIMIGOS TIPO BAT
if (C2D2M_PrimeiroBlocoMarca(mapa, MARCA_INIMIGO_BT, &tpX, &tpY))
{
numinimigosBT++;
while (C2D2M_ProximoBlocoMarca(mapa, &tpX, &tpY))
numinimigosBT++;
}
tpX = 0;
tpY = 0;
//PROCURA SABER NUMERO TOTAL DE INIMIGOS TIPO MINIRED
if (C2D2M_PrimeiroBlocoMarca(mapa, MARCA_INIMIGOS_MINIRED, &tpX, &tpY))
{
numinimigosMR++;
while (C2D2M_ProximoBlocoMarca(mapa, &tpX, &tpY))
numinimigosMR++;
}
tpX = 0;
tpY = 0;
//PROCURA SABER NUMERO TOTAL DE INIMIGOS TIPO MINISHOOTER
if (C2D2M_PrimeiroBlocoMarca(mapa, C2D2M_FIM, &tpX, &tpY))
{
numinimigosSH++;
while (C2D2M_ProximoBlocoMarca(mapa, &tpX, &tpY))
numinimigosSH++;
}
tpX = 0;
tpY = 0;
if (C2D2M_PrimeiroBlocoMarca(mapa, C2D2M_CHECK, &tpX, &tpY))
{
numOcorrencias++;
while (C2D2M_ProximoBlocoMarca(mapa, &tpX, &tpY))
numOcorrencias++;
}
tpX = 0;
tpY = 0;
if (C2D2M_PrimeiroBlocoMarca(mapa, MARCA_REDBOSS, &tpX, &tpY))
{
numinimigosRB++;
while (C2D2M_ProximoBlocoMarca(mapa, &tpX, &tpY))
numinimigosRB++;
}
if (cnave)
{
int xinit = 0, yinit = 0;
// cria o personagem na posicao escolhida dentro do mapa com a tag INICIO
C2D2M_PrimeiroBlocoMarca(mapa, C2D2M_INICIO, &xinit, &yinit);
nave = ATOR_CriaAtor(NAVE, xinit, yinit, 0);
//nave = ATOR_CriaAtor(NAVE, xinit, yinit, 0);
}
if (ctiro)
{
shootOK = false;
}
if (cbomba)
{
BombaOK = false;
}
if (credboss)
{
inimigosRB = (Ator**)malloc(sizeof(Ator*)*numinimigosRB);
memset(inimigosRB, 0, numinimigosRB*sizeof(Ator*));
//posicao temporaria para referencia
int xini, yini = 0;
int indO = 0;
if (C2D2M_PrimeiroBlocoMarca(mapa, MARCA_REDBOSS, &xini, &yini))
{
inimigosRB[indO++] = ATOR_CriaAtor(REDBOSS, xini, yini, 0);
while (C2D2M_ProximoBlocoMarca(mapa, &xini, &yini))
inimigosRB[indO++] = ATOR_CriaAtor(REDBOSS, xini, yini, 0);
}
}
//redboss = ATOR_CriaAtor(REDBOSS, -5, 5, 0);
if (ctiroInimigo)
{
tirosInimigos = (Ator**)malloc(sizeof(Ator*)*numTirosInimigos);
memset(tirosInimigos, 0, numTirosInimigos*sizeof(Ator*));
//posicao temporaria para referencia
int xini, yini = 0;
int indO = 0;
tirosInimigos[indO++] = 0;
while (indO < numTirosInimigos)
tirosInimigos[indO++] = 0;
}
if (cminishooter)
{
inimigosSH = (Ator**)malloc(sizeof(Ator*)*numinimigosSH);
memset(inimigosSH, 0, numinimigosSH*sizeof(Ator*));
//posicao temporaria para referencia
int xini, yini = 0;
int indO = 0;
if (C2D2M_PrimeiroBlocoMarca(mapa, C2D2M_FIM, &xini, &yini))
{
inimigosSH[indO++] = ATOR_CriaAtor(MINISHOOTER, xini, yini, 0);
while (C2D2M_ProximoBlocoMarca(mapa, &xini, &yini))
inimigosSH[indO++] = ATOR_CriaAtor(MINISHOOTER, xini, yini, 0);
}
}
if (cminired)
{
inimigosMR = (Ator**)malloc(sizeof(Ator*)*numinimigosMR);
memset(inimigosMR, 0, numinimigosMR*sizeof(Ator*));
//posicao temporaria para referencia
int xini, yini = 0;
/*int indO = 0;*/
if (C2D2M_PrimeiroBlocoMarca(mapa, MARCA_INIMIGOS_MINIRED, &xini, &yini))
{
inimigosMR[indO++] = ATOR_CriaAtor(MINIRED, xini, yini, 0);
while (C2D2M_ProximoBlocoMarca(mapa, &xini, &yini))
inimigosMR[indO++] = ATOR_CriaAtor(MINIRED, xini, yini, 0);
}
}
if (cbatrobo)
{
inimigos = (Ator**)malloc(sizeof(Ator*)*numinimigosBT);
memset(inimigos, 0, numinimigosBT*sizeof(Ator*));
//posicao temporaria para referencia
int xini, yini = 0;
int indO = 0;
if (C2D2M_PrimeiroBlocoMarca(mapa, MARCA_INIMIGO_BT, &xini, &yini))
{
inimigos[indO++] = ATOR_CriaAtor(BATROBO, xini, yini, 0);
while (C2D2M_ProximoBlocoMarca(mapa, &xini, &yini))
inimigos[indO++] = ATOR_CriaAtor(BATROBO, xini, yini, 0);
}
}
if (cocorrencia)
{
ocorrencias = (Ator**)malloc(sizeof(Ator*)*numOcorrencias);
memset(ocorrencias, 0, numOcorrencias*sizeof(Ator*));
//posicao temporaria para referencia
int xini, yini = 0;
int indO = 0;
if (C2D2M_PrimeiroBlocoMarca(mapa, C2D2M_CHECK, &xini, &yini))
{
ocorrencias[indO++] = ATOR_CriaAtor(OCORRENCIA, xini, yini, 0);
while (C2D2M_ProximoBlocoMarca(mapa, &xini, &yini))
ocorrencias[indO++] = ATOR_CriaAtor(OCORRENCIA, xini, yini, 0);
}
}
}
