void primeiraLinha(pixel *linha, int largura, float limiteMargens, int fluxoDesejado, int distanciaEntreIlhas, float probIlha) {
/* Insere os valores da primeira linha do programa */
int tamanhoDaMargemEsquerda;
int tamanhoDaMargemDireita;
int i = 0;
float v;
aleatorizaPrimeiraMargem (linha, largura, limiteMargens);
tamanhoDaMargemEsquerda = margemEsquerda(linha);
tamanhoDaMargemDireita = margemDireita(linha, largura);
insereIlha(linha, distanciaEntreIlhas, probIlha, tamanhoDaMargemEsquerda, tamanhoDaMargemDireita, largura);
for (i = tamanhoDaMargemEsquerda; i < largura - tamanhoDaMargemDireita; i++) { /* Insere a velocidade água */
if (linha[i-1].tipo == TERRA || tipo(&linha[i]) == TERRA || linha[i+1].tipo == TERRA)
setaVelocidade(&linha[i],0);
else{
v = velocidadeDaAguaPrimeiraLinha (linha[i-1].velocidade);
setaVelocidade(&linha[i], v);
}
}
suavizaVelocidades(linha, largura);
/* Consideramos a probabilidade de a primeira linha ter ilhas */
normaliza(linha, largura, fluxoDesejado);
}
void aleatorizaMargem(pixel *linhaAnterior, pixel *linha, float limiteMargens, int largura){
/* Calcula o novo tamanho das margens, baseado na linha anterior */
int tamanhoDaMargemEsquerda = margemEsquerda(linhaAnterior);
int tamanhoDaMargemDireita = margemDireita(linhaAnterior, largura);
int variacaoEsquerda = (rand()%3) - 1; /* O tamanho da margem nova vai variar da antiga de -1, 0 ou 1 */
int variacaoDireita = (rand()%3) - 1;
int i;
tamanhoDaMargemEsquerda = tamanhoDaMargemEsquerda + variacaoEsquerda;
tamanhoDaMargemDireita = tamanhoDaMargemDireita + variacaoDireita;
if (tamanhoDaMargemEsquerda <= 0) tamanhoDaMargemEsquerda = 1; /* Evita que as novas margens sejam 0 ou passem do limite */
else if (tamanhoDaMargemEsquerda > limiteMargens * largura || tamanhoDaMargemEsquerda >= largura - tamanhoDaMargemDireita - 10) tamanhoDaMargemEsquerda = margemEsquerda(linhaAnterior);
if (tamanhoDaMargemDireita <= 0) tamanhoDaMargemDireita = 1;
else if (tamanhoDaMargemDireita > limiteMargens * largura || tamanhoDaMargemDireita >= largura - tamanhoDaMargemEsquerda - 10) tamanhoDaMargemDireita = margemDireita(linhaAnterior, largura);
for (i = 0; i < tamanhoDaMargemEsquerda; i++){ /* Insere nova margem esquerda */
setaTipo(&linha[i], TERRA);
setaVelocidade(&linha[i], 0);
}
for (i = tamanhoDaMargemEsquerda; i < largura - tamanhoDaMargemDireita; i++) { /* Insere água no meio, para evitar erros*/
setaVelocidade(&linha[i], 1);
setaTipo(&linha[i], AGUA);
}
for (i = largura - tamanhoDaMargemDireita; i < largura; i++) { /* Insere nova margem direita */
setaTipo(&linha[i], TERRA);
setaVelocidade(&linha[i], 0);
}
}
void aleatorizaPrimeiraMargem (pixel *linha, int largura, float limiteMargens) {
int i;
int tamanhoDaMargemEsquerda = (limiteMargens*largura - 1)*rand()/RAND_MAX + 1;
int tamanhoDaMargemDireita = (limiteMargens*largura - 1)*rand()/RAND_MAX + 1;
if (tamanhoDaMargemEsquerda <= 0) tamanhoDaMargemEsquerda = 1; /* Evita que as novas margens sejam 0 ou passem do limite */
else if (tamanhoDaMargemEsquerda > limiteMargens * largura || tamanhoDaMargemEsquerda >= largura - tamanhoDaMargemDireita - 10) tamanhoDaMargemEsquerda = (largura - 10)/2;
if (tamanhoDaMargemDireita <= 0) tamanhoDaMargemDireita = 1;
else if (tamanhoDaMargemDireita > limiteMargens * largura || tamanhoDaMargemDireita >= largura - tamanhoDaMargemEsquerda - 10) tamanhoDaMargemDireita = (largura - 10)/2;
for (i = 0; i < tamanhoDaMargemEsquerda; i++){ /* Insere nova margem esquerda */
setaTipo(&linha[i], TERRA);
setaVelocidade(&linha[i], 0);
}
for (i = tamanhoDaMargemEsquerda; i < largura - tamanhoDaMargemDireita; i++) { /* Insere água no meio, para evitar erros*/
setaVelocidade(&linha[i], 1);
setaTipo(&linha[i], AGUA);
}
for (i = largura - tamanhoDaMargemDireita; i < largura; i++) { /* Insere nova margem direita */
setaTipo(&linha[i], TERRA);
setaVelocidade(&linha[i], 0);
}
}
void velocidadeProximaLinha (pixel *linha, pixel *linhaAnterior, int fluxoDesejado, int largura) {
int i = 0;
int tamanhoDaMargemEsquerda = margemEsquerda(linha);
int tamanhoDaMargemDireita = margemDireita(linha, largura);
for (i = tamanhoDaMargemEsquerda; i < largura-tamanhoDaMargemDireita; i++) {
if (tipo(&linha[i-1]) == TERRA || tipo(&linha[i]) == TERRA || tipo(&linha[i+1]) == TERRA) {
setaVelocidade(&linha[i], 0);
}
else {
float velocidadeAnterior = velocidade(&linhaAnterior[i]);
float aleatorio = realRandomico(0.9, 1.1);
float velocidadeNova = velocidadeAnterior*aleatorio;
if (velocidadeNova == 0) {
velocidadeNova = aleatorio*fluxoDesejado/(largura*8);
}
setaVelocidade(&linha[i], velocidadeNova);
}
}
}
int insereIlha(pixel *linha, int distanciaMinimaEntreIlhas, float probIlha, int tmargemEsquerda, int tmargemDireita, int largura){
int q, i;
int sorteio;
int comecoIlha, finalIlha;
int aux, aux2;
if( distanciaAtualEntreIlhas < distanciaMinimaEntreIlhas - 1){
distanciaAtualEntreIlhas++;
return 0;
}
q = (int) ( probIlha*1000000 - 1 );
sorteio = rand()%1000000;
if(sorteio > q){ /*Com probabilidade 1-p, sorteio sera maior que q*/
distanciaAtualEntreIlhas++;
return 0;
}
if(sorteio <= q){ /*Sorteio sera menor ou igual a q com probabilidade probIlha*/
int tamanhoMaximoDaIlha = (largura - tmargemEsquerda - tmargemDireita) * limiteDasIlhas;
int comecoMaximoDaIlha = tmargemEsquerda + (((1-limiteDasIlhas)/2)*(largura - tmargemEsquerda - tmargemDireita));
distanciaAtualEntreIlhas = 0;
aux = rand()%tamanhoMaximoDaIlha;
aux = comecoMaximoDaIlha + aux;
aux2 = rand()%tamanhoMaximoDaIlha;
aux2 = comecoMaximoDaIlha + aux2;
comecoIlha = aux < aux2 ? aux : aux2;
finalIlha = aux < aux2 ? aux2 : aux;
if(comecoIlha <= tmargemEsquerda || comecoIlha <= tmargemEsquerda + 1) comecoIlha = tmargemEsquerda + 3;
if(finalIlha >= largura - tmargemDireita || finalIlha >= largura - tmargemDireita - 2) finalIlha = largura - tmargemDireita - 3;
if(comecoIlha > finalIlha){
aux = comecoIlha;
comecoIlha = finalIlha;
finalIlha = aux;
}
for(i = comecoIlha; i <= finalIlha; i++){
setaTipo(&linha[i], TERRA);
setaVelocidade(&linha[i], 0);
}
}
return 1;
}
void normaliza(pixel *linha, int largura, int fluxoDesejado) { /* Normaliza a linha para ter o fluxo desejado */
int i = 0;
float fluxoObtido = 0;
float novaVel, vel;
for (i = 0; i < largura; i++) /* O fluxo obtido é a soma de todas as velocidades */
if (tipo(& linha[i] ) != TERRA)
fluxoObtido += velocidade(&linha[i]);
for (i = 0; i < largura; i++) { /* Transforma a linha numa que tenha o fluxo desejado */
if (tipo(&linha[i]) != TERRA){
vel = velocidade(&linha[i]);
novaVel = 1.0*vel*fluxoDesejado/fluxoObtido;
setaVelocidade(&linha[i], novaVel);
}
}
}
void suavizaVelocidades (pixel *linha, int largura) {
int i = 0;
int tamanhoDaMargemEsquerda = margemEsquerda(linha);
int tamanhoDaMargemDireita = margemDireita(linha, largura);
float velocidadeAnterior = 0;
for (i = tamanhoDaMargemEsquerda; i < largura - tamanhoDaMargemDireita; i++) {
if (velocidade(&linha[i]) != 0) {
float velocidadeNova = (velocidadeAnterior + velocidade(&linha[i]) + velocidade(&linha[i+1]))/3;
velocidadeAnterior = velocidade(&linha[i]);
setaVelocidade(&linha[i], velocidadeNova);
}
else {
velocidadeAnterior = 0;
}
}
}
int main(){
Ponto p, alvo, partida;
float theta, v0, t;
int colisao = 1, resposta;
int imgmagneto_attack, imgmagneto_standing, imgmagneto_standing2,
imgwolverine_flying, imgwolverine_standing, imgwolverine_standing2,
imgbackground, imgpikachu;
int grupo_wolverine, grupo_lancar;
AbreJanela(600,600, "Lancaverine 2.0");
imgmagneto_attack = AbreImagem("Xmen/magneto_attack.png");
imgmagneto_standing = AbreImagem("Xmen/magneto_standing.png");
imgmagneto_standing2 = AbreImagem("Xmen/magneto_standing2.png");
imgwolverine_flying = AbreImagem("Xmen/wolverine_flying.png");
imgwolverine_standing = AbreImagem("Xmen/wolverine_standing.png");
imgwolverine_standing2 = AbreImagem("Xmen/wolverine_standing2.png");
imgbackground = AbreImagem("Xmen/background.jpg");
imgpikachu = AbreImagem("Xmen/pikachu.png");
srand(time(NULL));
do{
LimpaDesenho(); //Limpo o desenho para comecar uma nova fase
defineCenario(&alvo, &partida, &grupo_wolverine, imgbackground, imgmagneto_standing, imgwolverine_standing, colisao);
Desenha1Frame();
theta = setaAngulo(partida);
v0 = setaVelocidade();
ApagaGrupo(grupo_wolverine); //vamos resetar o wolverine para ataque
grupo_wolverine = CriaGrupo(); //Separa os grupos - este e o grupo da bolinha
CriaQuadrado(TAMANHOQUADRADO, partida);
Pintar(255, 255, 255);
AssociaImagem(imgwolverine_flying);
t = 0;
theta = theta * PI/180;
colisao = 0;
do{
if(!colisao){
p.x = partida.x + v0 * cos(theta) * t;
p.y = partida.y + v0 * sin(theta) * t - ((1/2.0) * (9.8) * (t*t));
Move(p, grupo_wolverine);
t += 0.1; //tempo
}
colisao = colisaoBolinhaRetangulo(TAMANHOQUADRADO, TAMANHOQUADRADO, alvo, p);
Desenha1Frame();
}while(!colisao);
if(colisao == 1){ //atingiu Magneto
ApagaGrupo(grupo_wolverine); //remove Wolverine
AssociaImagem(imgmagneto_attack); //Modifica Magneto
grupo_wolverine = CriaGrupo(); //Separa os grupos - este e o grupo da bolinha
CriaQuadrado(TAMANHOQUADRADO, p);
Pintar(255, 255, 255);
AssociaImagem(imgwolverine_flying);
t = 0;
do{ //pausa dramatica
Desenha1Frame();
t += 0.1;
}while(t < 10);
do{ //lanca wolverine
Move(p, grupo_wolverine);
p.x -= 10;
p.y += 10;
Desenha1Frame();
}while(p.x + TAMANHOQUADRADO > -130);
ApagaGrupo(grupo_wolverine);
AssociaImagem(imgmagneto_standing);
CriaGrupo();
p.x = -80;
p.y = 32;
CriaQuadrado(20, p);
Pintar(255, 255, 255);
AssociaImagem(imgpikachu);
Desenha1Frame();
}
if(colisao == 2){//Nao atingiu magneto
if(p.x > alvo.x){ //Wolverine esta na frente do Magneto
AssociaImagem(imgwolverine_standing2);
}
else{ //Wolverine esta nas costas do Magneto
ApagaGrupo(grupo_wolverine);
AssociaImagem(imgmagneto_standing2);
grupo_wolverine = CriaGrupo(); //Separa os grupos - este e o grupo da bolinha
CriaQuadrado(TAMANHOQUADRADO, p);
Pintar(255, 255, 255);
AssociaImagem(imgwolverine_standing);
}
t = 0;
do{ //pausa dramatica
Desenha1Frame();
t += 0.1;
}while(t < 10);
}
if(colisao == 1){
printf("\nYay! Quer jogar um novo jogo?");
}
else{
printf("\nOh nao... Quer tentar de novo?");
}
printf("\n1 - Sim\n0 - Nao\n");
scanf("%d", &resposta);
}while(resposta);
Desenha();
return 0;
}
