/*Funcao auxiliar usada internamente para checar se as duas entidades passadas irao colidir no proximo ciclo logico.
Assume que uma delas esta parada, e a outra se mexendo, entao preve onde essa entidade estara e se estara proxima
da outra entidade.*/
int checaColisao( Entity entQueMove, Entity entParada, double DeltaTime )
{
Vetor VetAuxQueMove, VetAuxParada;
double RaioDoCirculo, dist;
atualizaPosicao(entQueMove, DeltaTime);
VetAuxQueMove = getPosicao( entQueMove );
atualizaPosicao(entParada, DeltaTime);
VetAuxParada = getPosicao( entParada );
RaioDoCirculo = /*DeltaTime*VETORmodulo( getVelocidade( entQueMove ) ) +*/ getRaio(entQueMove) + getRaio(entParada) + OFFSET_RAIO;
dist = CalcDist( VetAuxQueMove, VetAuxParada );
atualizaPosicao(entParada, -DeltaTime);
atualizaPosicao(entQueMove, -DeltaTime);
if (dist <= RaioDoCirculo)
{
if ( checkIntersecaoDeFormas(entQueMove, entParada) == 1)
return 1;
}
return 0;
}
/*Funcao auxiliar usada internamente usada no meio do loop de checagem de colisoes.
Ela equivale ao segundo FOR do loop (o FOR dentro do outro), executando a funcao colisaoDeEntities para
cada dupla de entidades no jogo.
Note que antes de checar se a ent ira colidir com qualquer outra entidade, ela checa se a entidade
ira sair da tela, o que e' tratado como uma colisao entre 2 entidades (ent, NULL)*/
void colisaoPorEntity( Item ent_i, Item Aux )
{
Colisao AuxColisao;
Vetor pos;
Entity ent;
ent = (Entity)ent_i;
AuxColisao = (Colisao)Aux;
AuxColisao->ent = ent;
AuxColisao->podeChecar = 0;
atualizaPosicao(ent, AuxColisao->DeltaTime);
pos = getPosicao(ent);
if (round(getX(pos)) < 0 || round(getX(pos)) >= MAX_OCEANO_X || round(getY(pos)) < 0 || round(getY(pos)) >= MAX_OCEANO_Y)
{
/*chama colisao (ent, NULL) */
setEstaColidindo( ent, 1 );
callColidiuCom(ent, NULL, AuxColisao->DeltaTime);
return;
}
atualizaPosicao(ent, -(AuxColisao->DeltaTime) );
executeForAllEntities( colisaoDeEntities, AuxColisao );
}
/*Funcao importante usada internamente. Ela executa um update logico de um Bote.*/
void updateBote(Entity ent, double deltaTime)
{
int estado, estadoAntigo;
Vetor v;
atualizaPosicao(ent, deltaTime); /*atualizamos nossa posicao de acordo com a velocidade e variacao do tempo.*/
/*Se nao estivermos colidindo podemos tentar mudar nossa direcao de movimento de acordo */
if ( !getEstaColidindo(ent) )
{
v = getVelocidade(ent);
estadoAntigo = getBoteEstado(v);
if (estadoAntigo != -1)
{
/*E tentamos mudar nosso estado de acordo com uma cadeia de markov...*/
estado = markovProximoEstado(estadoAntigo, 8, markovTransicaoBote);
if (estado != estadoAntigo)
setBoteEstado(estado, v);
}
}
}
/*-------------------------------------------------------------
atualizaNave
Atualiza a posicao da nave de acordo com sua velocidade e direcao.
*/
void atualizaNave(Nave* nave, float timestep_value)
{
atualizaPosicao(nave->pos, nave->vel, nave->dir, timestep_value);
}
