int main()
{
float d,fuerza;
punto_t p1,p2;
printf("\t\tIntroduzca las coordenadas de los puntos\n");
printf("Primer punto\nCoordenada x : ");
scanf("%f",&p1.posicion_x);
printf("\nCoordenada y : ");
scanf("%f",&p1.posicion_y);
printf("\nMasa del cuerpo en esta posicion : ");
scanf("%f",&p1.masa);
printf("Segundo punto\nCoordenada x : ");
scanf("%f",&p2.posicion_x);
printf("\nCoordenada y : ");
scanf("%f",&p2.posicion_y);
printf("\nMasa del cuerpo en esta posicion : ");
scanf("%f",&p2.masa);
d=distancia(p1,p2);
fuerza=(float)(p1.masa*p2.masa)*G/d;
printf("La fuerza entre ambos cuerpos es %f\n",fuerza);
printf("\nFuerza=(G*m1*m2)/d^2");
return 0;
}
// Donde N es el numero de rotaciones
void Model_Revolution::calcular_coord_textura(int N, int M)
{
int n_vertices = _vertices.size();
double d[M]; //vector de distancias
d[0] = 0;
for(unsigned int k=1; k<M; k++)
d[k] = d[k-1] + distancia(_vertices[k-1], _vertices[k]);
for(unsigned int i=0; i<N; i++)
{
for(unsigned int j=0; j<M; j++)
{
float si = (float)i/(N-1);
float tj = d[j]/d[M-1];
_texturas.push_back(_vertex2f(si, tj));
}
}
}
double simpleDTW( double ** s, const int size_s, double **t, const int size_t, int numCols){
long double custo = 0;
long double result = 0;
double DTW[size_s+1][size_t+1];
for(int i =1; i<= size_s; ++i){
DTW[i][0]= INT_MAX;
}
for(int i =1; i<= size_t; ++i){
DTW[0][i]= INT_MAX;
}
DTW[0][0]=0;
for (int i = 1; i <= size_s; ++i) {
for (int j = 1; j <= size_t; ++j) {
custo = distancia(s[i-1],t[j-1], numCols);
DTW[i][j] = custo + min(DTW[i-1][j], DTW[i][j-1], DTW[i-1][j-1]);
}
}
result = DTW[size_s][size_t];
return result;
}
double simpleDTW(vector<vector<double> > *s, vector<vector<double> > *t, int numCols){
double custo = 0;
double result = 0;
const int size_s = (*s).size();
const int size_t = (*t).size();
double DTW[size_s+1][size_t+1];
for(int i =1; i<= size_s; ++i){
DTW[i][0]= INT_MAX;
}
for(int i =1; i<= size_t; ++i){
DTW[0][i]= INT_MAX;
}
DTW[0][0]=0;
for (int i = 1; i <= size_s; ++i) {
for (int j = 1; j <= size_t; ++j) {
custo = distancia(&((*s)[i-1]),&((*t)[j-1]), numCols);
DTW[i][j] = custo + min(DTW[i-1][j], DTW[i][j-1], DTW[i-1][j-1]);
}
}
result = DTW[size_s][size_t];
return result;
}
int main()
{
int n, i, j, a = 0, b = 0;
long double min, dist;
scanf("%d", &n);
for(i = 1; i <= n; i++)
scanf("%d %d", &vacas[i].x, &vacas[i].y);
min = 1 << 30;
for(i = 1; i <= n; i++){
for(j = 1; j <= n; j++){
if(i != j){
dist = distancia(vacas[i], vacas[j]);
if(dist < min){
min = dist;
a = i;
b = j;
}
}
}
}
if(a < b)
printf("%d %d\n", a, b);
else
printf("%d %d\n", b, a);
return 0;
}
void color_filter_c(unsigned char *src,
unsigned char *dst,
unsigned char rc,
unsigned char gc,
unsigned char bc,
int threshold,
int width,
int height)
{
unsigned char (*src_matrix)[width * 3] = (unsigned char (*)[width * 3]) src;
unsigned char (*dst_matrix)[width * 3] = (unsigned char (*)[width * 3]) dst;
int _row = 0;
int _column = 0;
while(_row <= height - 1){
while(_column <= width * 3 - 3){
int b = src_matrix[_row][_column];
int g = src_matrix[_row][_column + 1];
int r = src_matrix[_row][_column + 2];
int dist = distancia(rc,gc,bc, r, g, b, threshold);
if(dist == 1){
int rgb = (r + g + b)/3;
dst_matrix[_row][_column] = rgb;
dst_matrix[_row][_column + 1] = rgb;
dst_matrix[_row][_column + 2] = rgb;
}else{
dst_matrix[_row][_column] = src_matrix[_row][_column];
dst_matrix[_row][_column + 1] = src_matrix[_row][_column + 1];
dst_matrix[_row][_column + 2] = src_matrix[_row][_column + 2];
}
_column = _column + 3;
}
_column = 0;
_row++;
}
}
void prim(struct ponto sardas[], float prim[])
{
int i, j, min, k;
float dist, vetor[100];
prim[0] = 0;
vetor[0] = -1;
for (i = 1; i < nroSardas; i++)
{
vetor[i] = INF;
}
k = 0;
for (i = 0; i < nroSardas - 1; i++)
{
for (j = 1; j < nroSardas; j++)
{
if (k != j)
{
dist = distancia(sardas[k], sardas[j]);
if (vetor[j] > dist)
{
vetor[j] = dist;
}
}
}
k = menor(vetor);
prim[k] = vetor[k];
vetor[k] = -1;
}
}
int main ()
{
int i;
Ponto_3D vetor[10];
srand(time(NULL));
for (i = 0; i < 10; i++)
{
vetor[i].x = rand()%10;
vetor[i].y = rand()%10;
vetor[i].z = rand()%10;
}
for (i = 0; i < 10; i++)
{
printf("%d ", vetor[i].x);
printf("%d ", vetor[i].y);
printf("%d ", vetor[i].z);
printf("\n");
}
printf("\n");
distancia(vetor);
system("pause");
return 0;
}
/**
@brief Comprueba si un punto es interior a un círculo
@param p punto a comprobar
@param c circulo
@retval true si el punto @a p es interior al círculo @a c
@retval false en caso contrario
*/
bool interior (Punto p, Circulo c){
if(distancia(p,c.getCentro())<=c.getRadio()) {
return true;
}
else{
return false;
}
}
vector <double> vector_pendiente(vector <double> xyz_ini, vector <double> xyz_fin){
vector <double> pendiente;
double distance = distancia(xyz_ini, xyz_fin);
pendiente.push_back( (xyz_fin.at(0) - xyz_ini.at(0)) / distance );
pendiente.push_back( (xyz_fin.at(1) - xyz_ini.at(1)) / distance );
pendiente.push_back( (xyz_fin.at(2) - xyz_ini.at(2)) / distance );
return pendiente;
}
point getPontoDeslocadoNaReta(point a, point b, double dist)
{
int dx = a.x-b.x;
int dy = a.y-b.y;
double normaAB = distancia(a,b);
double razao = dist/normaAB;
return point((int)(a.x-dx*razao), (int)(a.y-dy*razao));
}
/**
@brief Calcula la distancia entre dos circulos
@param c1 primer círculo
@param c2 segundo círculo
@return la distancia entre el círculo @a c1 y el círculo @a c2
La distancia entre dos círculos se define como la distancia entre los centros menos los dos radios.
Nótese que la distancia puede ser negativa si los círculos se intersecan
*/
double distancia (Circulo c1, Circulo c2){
Punto centro1, centro2;
double dist;
centro1=c1.getCentro();
centro2=c2.getCentro();
dist=distancia(centro1,centro2)-c1.getRadio()-c2.getRadio();
return dist;
}
float distancia_hexagonal(float fila1, float columna1, float fila2, float columna2) {
float f1 = fila1, f2 = fila2;
if ((int) columna1 % 2 == 0) {
f1 += 0.5;
}
if ((int) columna2 % 2 == 0) {
f2 += 0.5;
}
return distancia(f1, columna1, f2, columna2);
}
int main() {
int N, i, j, maisProximo, segundoProximo;
while (1) {
scanf("%d", &N);
if (N == 0)
break;
for (i = 0; i < N; i++) {
scanf("%d %d", &pontos[i][0], &pontos[i][1]);
visitado[i] = 0, adj[i][0] = adj[i][1] = -1;
}
for (i = 0; i < N; i++)
for (j = 0; j <= i; j++)
dist[i][j] = dist[j][i] = distancia(i, j);
maisProximo = INF, segundoProximo = INF;
for (i = 0; i < N; i++)
for (j = 0; j < N; j++)
if (i != j) {
if (dist[i][j] < maisProximo) {
segundoProximo = maisProximo, adj[i][1] = adj[i][0], maisProximo
= dist[i][j], adj[i][0] = j;
} else if (dist[i][j] == maisProximo) {
if (adj[i][0] == -1)
maisProximo = dist[i][j], adj[i][0] = j;
else if (desempata(adj[i][0], j))
segundoProximo = dist[i][j], adj[i][1] = j;
else
segundoProximo = maisProximo, adj[i][1] = adj[i][0], maisProximo
= dist[i][j], adj[i][0] = j;
} else if (dist[i][j] < segundoProximo) {
segundoProximo = dist[i][j], adj[i][1] = j;
} else if (dist[i][j] == segundoProximo) {
if (adj[i][1] == -1 || desempata(j, adj[i][1]))
segundoProximo = dist[i][j], adj[i][1] = j;
}
}
nVisitados = 0;
dfs(0);
if (N > 3 && nVisitados != N)
puts("There are stations that are unreachable.");
else
puts("All stations are reachable.");
}
return 0;
}
void selectRect2(nodeVal **values, int *imax, int *jmax){
float max_dist = -1, d;
int i,j;
for (i=0;i<2*b+1;i++){
for (j=i+1;j<2*b+1;j++){
d = distancia(values[i]->r,values[j]->r);
if(d > max_dist){
max_dist = d;
*imax = i, *jmax = j;
}
}
}
}
void* receptor(void* data)
{
boat* barco = (boat*) data;
char msg[256];
ais_state ais;
aismsg_1 msg_1; // Solo se contempla mensages de tipo 1.
long lat,lon;
double lat_dd, long_ddd;
float time;
while (1)
{
time = 0;
memset( &ais, 0, sizeof( ais_state ) );
pthread_mutex_lock(&lock);
if (list != NULL)
{
list = remove_message(list, msg);
pthread_mutex_unlock(&lock);
if (assemble_vdm( &ais, msg ) == 0)
{
ais.msgid = (unsigned char) get_6bit( &ais.six_state, 6 );
if( (ais.msgid == 1)&&(parse_ais_1( &ais, &msg_1 ) == 0) )
{
float dist = distancia(barco->cog, msg_1.cog, barco->sog, msg_1.sog, barco->latitude, barco->longitude, msg_1.latitude, msg_1.longitude);
lat = msg_1.latitude; lon = msg_1.longitude;
conv_pos(&lat, &lon);
pos2ddd( lat, lon, &lat_dd, &long_ddd );
printf("*****-----*****-----*****-----*****\n");
printf( "MESSAGE ID: %d\t", ais.msgid );
printf( "USER ID : %ld\n", msg_1.userid );
printf( "SOG : %d\t", msg_1.sog );
printf( "COG : %d\n", msg_1.cog );
printf( "POSITION : Lat %0.6f Lon %0.6f\n", lat_dd, long_ddd );
printf("MDCPA :%0.6f \n", dist);
}else printf("ERROR!!\nmsgid:%d msg:%s \n", ais.msgid, msg);
}
}
else
{
pthread_mutex_unlock(&lock);
printf("No hay mensages\n");
sleep(1);
time += 1;
}
usleep(100000); // 0.1 seg
time += 0.1;
boat_new_pos(barco, time);
}
}
void peanogosper ( ponto pt1, ponto pt2, double ang, int tipobase, int interacao)
{
ponto prox, atual;
int base, n, p, interac;
double dist;
base = tipobase;
atual = pt1;
dist = distancia ( pt1 , pt2 )/sqrt(7);
for ( n = 0; n < 7; n++)
{
interac = interacao;
switch ( ( n%7 ) )
{
case 0:
p = 0;
break;
case 1:
p = 1;
break;
case 2:
p = 3;
break;
case 3:
p = 2;
break;
case 4:
case 5:
p = 0;
break;
case 6:
p = -1;
break;
}
if ( interac > 0 ) {
prox.x = atual.x + dist*cos( ang + angbase + (p * (pi)/3) );
prox.y = atual.y + dist*sin( ang + angbase + (p * (pi)/3) );
peanogosper( atual , prox, angulo ( atual , prox ), base, --interac );
}
else if ( interacao == 0 )
{
if ( multicor == 1 ) escolhecor ( fabs( cos( atual.x ) ) , fabs ( cos ( prox.x) ), fabs ( cos ( atual.y ) ) );
draw_segmento(atual , prox);
}
atual = prox;
}
}
/*Contiene subfunciones que validan el movimiento*/
int validarMovimiento(tMovimiento* mov,tTablero* miTablero,int jugador)
{
if(quedaenMatriz(mov, miTablero)==TRUE)
return 3;
if(estaenMatriz(mov, miTablero)==TRUE)
return 3;
if(mismoLugar(mov)==TRUE)
return 1;
if(esdelJugador(miTablero,mov,jugador)==TRUE)
return 2;
if(distancia(mov)==TRUE)
return 4;
if(hayFicha(miTablero,mov)==TRUE)
return 5;
else
return 0;
}
//Retorna as 100 minucias mais próximas
vector<double> nearestMinutiaes(Mat &img){
vector< pair<int, int> > min = minutiae(img); // Posições das minucias
vector<double> dist;
for(int i = 0; i < min.size()-1; i++){
for(int j = i+1; j < min.size() ; j++){
dist.push_back( distancia(min[i], min[j]) );
}
}
sort(dist.begin(), dist.end());
if(dist.size() > minutiaeNearestSize){
dist = vector<double> (dist.begin(),dist.begin()+minutiaeNearestSize);
}
return dist;
}
void ilhadekochQI( ponto pt1, ponto pt2, double ang, int tipobase, int interacao)
{
ponto prox, atual;
int base, n, p, interac;
double dist;
base = tipobase;
atual = pt1;
dist = distancia ( pt1 , pt2 )/4;
for ( n = 0; n < 8; n++)
{
interac = interacao;
switch ( ( n%8 ) )
{
case 0:
case 7:
case 2:
case 5:
p = 0;
break;
case 1:
case 6:
p = 1;
break;
case 3:
case 4:
p = -1;
break;
}
prox.x = atual.x + dist*cos( ang + (p * (pi)/2) );
prox.y = atual.y + dist*sin( ang + (p * (pi)/2) );
if ( interac > 0 ) {
ilhadekochQI( atual , prox, angulo ( atual , prox ), base, --interac );
}
else if ( interacao == 0 )
{
if ( multicor == 1 ) escolhecor ( fabs( cos( atual.x ) ) , fabs ( cos ( prox.x) ), fabs ( cos ( atual.y ) ) );
draw_segmento(atual , prox);
}
atual = prox;
}
}
double windowedDTW(vector<vector<double> > *s, vector<vector<double> > *t, int w){
double custo = 0;
double result = 0;
const int size_s = (*s).size();
const int size_t = (*t).size();
if(abs(size_s-size_t)>w){
cout<<"Window size should be at least |m-n|"<<endl;
return -1;
}
//float DTW[size_s+1][size_t+1];
cin>>custo;
double **DTW = (double**)malloc(sizeof(double*)*(size_s+1));
for(int i =1; i<= size_s; ++i){
DTW[i] = (double*)malloc(sizeof(double)*(size_t+1));
DTW[i][0]= INT_MAX;
}
for(int i =1; i<= size_t; ++i){
DTW[0][i]= INT_MAX;
}
DTW[0][0]=0;
for (int i = 1; i <= size_s; ++i) {
for (int j = 1; j <= size_t; ++j) {
if(abs(i-j)<=w){
custo = distancia(&((*s)[i-1]),&((*t)[j-1]),0);
DTW[i][j] = custo + minMod(DTW, i, j, w);
}
}
}
result = DTW[size_s][size_t];
for(int i =1; i<= size_s; ++i){
free(DTW[i]);
}
free(DTW);
return result;
}
void LocalPlanner::setDeltaAtractivo() {
//Calcula el componente atractivo del campo de potencial
double d = distancia(posGoal, pos);
double theta = atan2(posGoal.y - pos.y, posGoal.x - pos.x);
if (d-CAMPOATT.radius < TOLERANCIA) {
deltaGoal.x = deltaGoal.y = 0;
return;
}
if ( (CAMPOATT.radius < d)and (d < (CAMPOATT.spread - CAMPOATT.radius ))) {
deltaGoal.x = CAMPOATT.intens *(d - CAMPOATT.radius)*cos(theta);
deltaGoal.y = CAMPOATT.intens *(d - CAMPOATT.radius)*sin(theta);
return;
}
if (d > (CAMPOATT.spread + CAMPOATT.radius)) {
deltaGoal.x = CAMPOATT.intens*CAMPOATT.spread*cos(theta);
deltaGoal.y = CAMPOATT.intens*CAMPOATT.spread*sin(theta);
return;
}
}
void LocalPlanner::escapaMinimoLocal(){
double distanci=0;
double angulo2 = 0;
double mindist = 100;
double angulo=0;
for(int i=0; i<posObs.size(); i++){
double dist = distancia(pos, posObs[i]); //esta sera la distancia al obhjetivo
if(dist > distanci){
double angulo = atan2(posObs[i].y - pos.y, posObs[i].x - pos.x);
distanci = dist;
ROS_INFO("nueva distancia max: %d", distanci);
}
}
deltaGoal.x = deltaGoal.y = 0;
ROS_INFO("Me voy hacia elobstaculo a una distancia %d", distanci);
//calcular vector hacia el obstaculo mas lejano
if (distanci-CAMPOALT.radius < TOLERANCIA) {
deltaAlt.x = deltaAlt.y = distanci;
return;
ROS_INFO("delta alternativa: %d %d", deltaAlt.x, deltaAlt.y);
}
if ( (CAMPOALT.radius < distanci)and (distanci < (CAMPOALT.spread - CAMPOALT.radius ))) {
deltaAlt.x = CAMPOALT.intens *(distanci - CAMPOALT.radius)*cos(angulo);
deltaAlt.y = CAMPOALT.intens *(distanci - CAMPOALT.radius)*sin(angulo);
ROS_INFO("delta alternativa: %d %d", deltaAlt.x, deltaAlt.y);
return;
}
if (distanci > (CAMPOATT.spread + CAMPOATT.radius)) {
deltaAlt.x = CAMPOALT.intens*CAMPOATT.spread*cos(angulo);
deltaAlt.y = CAMPOALT.intens*CAMPOATT.spread*sin(angulo);
ROS_INFO("delta alternativa: %d %d", deltaAlt.x, deltaAlt.y);
return;
}
}
void LocalPlanner::getOneDeltaRepulsivo(Tupla posObst, Tupla &deltaO){
// recibe una posición de un obstáculo y calcula el componente repulsivo para ese obstáculo.
// Devuelve los valores en deltaO.x y deltaO.y
double dist = distancia(posObst, pos); //esta sera la distancia al obhjetivo
double angulo = atan2(posObst.y - pos.y, posObst.x - pos.x);
if (dist < CAMPOREP.radius && dist < CAMPOREP.spread) {
deltaO.x = -signo(cos(angulo))*999999;
deltaO.y = -signo(sin(angulo))*999999;
return;
}
if( (CAMPOREP.radius < dist)and (dist < CAMPOREP.spread - CAMPOREP.radius) ) {
deltaO.x = -CAMPOREP.intens*(CAMPOREP.spread + CAMPOREP.radius - dist)*cos(angulo);
deltaO.y = -CAMPOREP.intens*(CAMPOREP.spread + CAMPOREP.radius - dist)*sin(angulo);
return;
}
if (dist > CAMPOREP.spread + CAMPOREP.radius) {
deltaO.x = deltaO.y = 0;
}
}
int main(int argc, char ** argv)
{
int n, i;
rota *rotas;
scanf("%d", &n);
rotas = (rota*) malloc (n * sizeof(rota));
for (i = 0; i < n; i++)
{
scanf("%d,%d,%d-%d-%d %d:%d:%d,%f,%f,%s", &rotas[i].registo, &rotas[i].viatura, &rotas[i].t.ano,
&rotas[i].t.mes, &rotas[i].t.dia, &rotas[i].t.horas,
&rotas[i].t.minutos, &rotas[i].t.segundos, &rotas[i].latitude,
&rotas[i].longitude, rotas[i].cidade);
rotas[i].distancia = distancia(rotas[i]);
}
quick_sort(rotas, 0, n-1);
imprime_rotas(rotas, n);
return 0;
}
float plano3d::distancia(recta3d r) //devuelve la distancia entre una recta y un plano
{
if (normal.ortogonal(r.vector)==0) return 0; //verifico primero si son paralelos la recta y el plano, si no distancia es 0
return(distancia(r.punto)); // La distancia es la del punto que define la recta al plano
}
float plano3d::distancia(plano3d p) //Distancia entre dos planos paralelos
{
if ((normal^p.normal).norma() != 0) return 0; //verifico si de verdad son paralelos, si no distancia es 0
return (distancia(p.punto)); // La distancia es la del punto que define la recta al plano
}
Grafo *resolver(int k_centrales, Ciudad *ciudades, int n_ciudades, Nodo **centrales)
{
Grafo *g = NULL;
NodoDistancia *nodos = NULL;
Arista *aristas = NULL;
int i, agregados, distancia_minima = -1, nodo_minimo = -1, componentes;
if(k_centrales <= 0 || ciudades == NULL || n_ciudades <= 0 || centrales == NULL){
return NULL;
}
g = crear_grafo(n_ciudades);
nodos = (NodoDistancia *)malloc(sizeof(NodoDistancia) * n_ciudades);
aristas = (Arista *)malloc(sizeof(Arista) * (n_ciudades - 1));
nodos[0].agregado = 1;
nodos[0].distancia = 0;
nodos[0].nodo = 0;
for(i = 1; i < n_ciudades; i++){
nodos[i].agregado = 0;
nodos[i].distancia = distancia(&(ciudades[i]), &(ciudades[0]));
nodos[i].nodo = 0;
}
for(agregados = 0; agregados < n_ciudades - 1; agregados++){
distancia_minima = -1;
nodo_minimo = 0;
for(i = 0; i < n_ciudades; i++){
if(!nodos[i].agregado){
if(distancia_minima == -1 || nodos[i].distancia < distancia_minima){
distancia_minima = nodos[i].distancia;
nodo_minimo = i;
}
}
}
nodos[nodo_minimo].agregado = 1;
aristas[agregados].nodo1 = nodo_minimo;
aristas[agregados].nodo2 = nodos[nodo_minimo].nodo;
aristas[agregados].distancia = distancia_minima;
for(i = 0; i < n_ciudades; i++){
if(!nodos[i].agregado){
if(nodos[i].distancia > distancia(&(ciudades[i]), &(ciudades[nodo_minimo]))){
nodos[i].distancia = distancia(&(ciudades[i]), &(ciudades[nodo_minimo]));
nodos[i].nodo = nodo_minimo;
}
}
}
}
ordenar_aristas(aristas, n_ciudades - 1);
for(componentes = n_ciudades; componentes > k_centrales; componentes--){
agregar_arista(g, aristas[n_ciudades - componentes].nodo1, aristas[n_ciudades - componentes].nodo2);
}
*centrales = nodos_de_componentes(g);
free(nodos);
free(aristas);
return g;
}
/* Gera um novo nivel */
Nivel genNivel(int level, Player* player, Enemy* enemies){
Nivel nivel;
clear();
move(0,0);
/* Escolhe um tamanho aleatorio para o mapa */
do{
nivel.tamI = rand() % 26;
}while(nivel.tamI < 21);
do{
nivel.tamJ = rand() % 51;
}while(nivel.tamJ < 46);
int tamI = nivel.tamI;
int tamJ = nivel.tamJ;
for(int i = 0; i < tamI; i++){
for(int j = 0; j < tamJ; j++)
nivel.mapa[i][j].shown = 0;
}
nivel.nivel = level;
nivel.inimigos = 0;
/* Gera o mapa aleatoriamente (apenas muros e espacos vazios) */
genRoom(&nivel);
/* Inicializa as posicoes do mapa */
for(int i = 0; i < tamI; i++){
for(int j = 0; j < tamJ; j++){
if(nivel.mapa[i][j].shown == 1){
nivel.mapa[i][j].used = 1;
nivel.mapa[i][j].enemyIndice = -1;
nivel.mapa[i][j].itemIndice = -1;
nivel.mapa[i][j].player = 0;
nivel.mapa[i][j].wall = 1;
nivel.mapa[i][j].stairs = 0;
nivel.mapa[i][j].quantItems = 0;
}
else{
nivel.mapa[i][j].used = 0;
nivel.mapa[i][j].enemyIndice = -1;
nivel.mapa[i][j].itemIndice = -1;
nivel.mapa[i][j].player = 0;
nivel.mapa[i][j].wall = 0;
nivel.mapa[i][j].stairs = 0;
nivel.mapa[i][j].quantItems = 0;
}
}
}
/* Posiciona a escada para o proximo nivel*/
int stairsI, stairsJ;
do{
stairsI = rand() % tamI;
stairsJ = rand() % tamJ;
}while(nivel.mapa[stairsI][stairsJ].used == 1);
nivel.mapa[stairsI][stairsJ].used = 1;
nivel.mapa[stairsI][stairsJ].stairs = 1;
for(int i = stairsI - 1; i <= stairsI + 1; i++){
for(int j = stairsJ - 1; j <= stairsJ + 1; j++){
if(nivel.mapa[i][j].wall == 1){
if((i > 0) && (i < tamI - 1) && (j > 0) && (j < tamJ - 1)){
nivel.mapa[i][j].used = 0;
nivel.mapa[i][j].wall = 0;
}
}
}
}
/* Posiciona boss do nivel */
int flag = 0;
if(flag == 0){
if(stairsI - 1 > 0){
nivel.mapa[stairsI - 1][stairsJ].enemyIndice = 0;
nivel.mapa[stairsI - 1][stairsJ].used = 1;
nivel.inimigos++;
enemies[0] = createEnemy(1, stairsI - 1, stairsJ, nivel.nivel);
}
else
flag = 1;
}
if(flag == 1){
if(stairsI + 1 < tamI - 1){
nivel.mapa[stairsI + 1][stairsJ].enemyIndice = 0;
nivel.mapa[stairsI + 1][stairsJ].used = 1;
nivel.inimigos++;
enemies[0] = createEnemy(1, stairsI + 1, stairsJ, nivel.nivel);
}
else
flag = 2;
}
if(flag == 2){
if(stairsJ - 1 > 0){
nivel.mapa[stairsI][stairsJ - 1].enemyIndice = 0;
nivel.mapa[stairsI][stairsJ - 1].used = 1;
nivel.inimigos++;
enemies[0] = createEnemy(1, stairsI, stairsJ - 1, nivel.nivel);
}
else
flag = 3;
}
if(flag == 3){
if(stairsJ + 1 < tamJ - 1){
nivel.mapa[stairsI][stairsJ + 1].enemyIndice = 0;
nivel.mapa[stairsI][stairsJ + 1].used = 1;
nivel.inimigos++;
enemies[0] = createEnemy(1, stairsI, stairsJ + 1, nivel.nivel);
}
}
/* Posiciona o jogador e garante que ele nao esta encostado em um muro (isso pode atrapalhar movimento em corredores) */
do{
(*player).y = rand() % tamI;
(*player).x = rand() % tamJ;
}while((nivel.mapa[player->y][player->x].used == 1) || (!distancia(player->y, player->x, stairsI, stairsJ, tamI * tamJ)));
nivel.mapa[player->y][player->x].used = 1;
nivel.mapa[player->y][player->x].player = 1;
nivel.mapa[player->y][player->x].stairs = -1;
for(int i = player->y - 1; i <= player->y + 1; i++){
for(int j = player->x - 1; j <= player->x + 1; j++){
if(nivel.mapa[i][j].wall == 1){
if((i > 0) && (i < tamI - 1) && (j > 0) && (j < tamJ - 1)){
nivel.mapa[i][j].used = 0;
nivel.mapa[i][j].wall = 0;
}
}
}
}
enemyPositions(nivel, enemies);
return nivel;
}
void ilhadekochQII( ponto pt1, ponto pt2, double ang, int tipobase, int interacao)
{
ponto prox, atual;
int base, n, p, interac;
double dist;
base = tipobase;
atual = pt1;
dist = distancia ( pt1 , pt2 )/8;
for ( n = 0; n < 32; n++)
{
interac = interacao;
switch ( ( n%32 ) )
{
case 1:
case 5:
case 6:
case 8:
case 13:
case 14:
case 17:
case 18:
case 23:
case 25:
case 26:
case 30:
p = 0;
break;
case 3:
case 11:
case 20:
case 28:
p = 2;
break;
case 0:
case 2:
case 4:
case 7:
case 24:
case 27:
case 29:
case 31:
p = 1;
break;
case 9:
case 10:
case 12:
case 15:
case 16:
case 19:
case 21:
case 22:
p = -1;
break;
}
prox.x = atual.x + dist*cos( ang + (p * (pi)/2) );
prox.y = atual.y + dist*sin( ang + (p * (pi)/2) );
if ( interac > 0 ) {
ilhadekochQII( atual , prox, angulo ( atual , prox ), base, --interac );
}
else if ( interacao == 0 )
{
if ( multicor == 1 ) escolhecor ( fabs( cos( atual.x ) ) , fabs ( cos ( prox.x) ), fabs ( cos ( atual.y ) ) );
draw_segmento(atual , prox);
}
atual = prox;
}
}
