/*Funcao importante usada internamente. Ela trata a colisao entre as entidades ent e aux, levando em conta a variacao de tempo.
Note que enquanto ela trata a colisao de ambas entidades, fazendo o necessario, ela e' executada e funciona do ponto de vista
da entidade ENT, que pode ser assumida um passageiro nessa funcao (nesse contexto).*/
void colisaoPassageiro(Entity ent, Entity aux, double deltaTime)
{
double x;
if (aux == NULL)
{
/*Sairemos da tela, entao setamos que devemos ser destruidos.
Ao fim do update logico de todas entidades, todas as entidades marcadas assim serao destruidas.
Tambem zeramos nossa velocidade pois antes do ciclo de destruicao dessas entidades marcadas ocorre
o update logico delas, o qual invariavelmente fara esse passageiro se mexer, e nao queremos deixar ele ir
para fora da tela, mesmo que por um unico frame.*/
setX(getVelocidade(ent), 0);
setY(getVelocidade(ent), 0);
setEntityToBeDestroyed(ent);
return;
}
else if ( isPassageiro(aux) == 1 || getTipo(aux) == ASIMOV)
{
/*Colisao entre passageiros, colisao simples, basta acertar as velocidades.*/
if ( checkChance( CHANCE_REST ) ) x = 1.0;
else x = getRandDouble();
atualizaVelocidade( ent, aux, 1.0 );
}
else if ( getTipo(aux) == BOTE )
{
/*Aqui estamos colidindo com um bote. Como essa e' uma colisao importante, diferente das comuns,
chamamos a funcao de colisao do bote para tratar essa colisao, para que nao tenhamos o mesmo algoritmo em 2 lugares.*/
callColidiuCom(aux, ent, deltaTime);
}
else if ( getTipo(aux) == RECIFE)
{
printf("Colisao PASS->RECIFE nao implementada \n");
}
}
/*Funcao importante usada internamente. Ela trata a colisao entre as entidades ent e aux, levando em conta a variacao de tempo.
Note que enquanto ela trata a colisao de ambas entidades, fazendo o necessario, ela e' executada e funciona do ponto de vista
da entidade ENT, que pode ser assumida um Bote nessa funcao (nesse contexto).*/
void colisaoBote(Entity ent, Entity aux, double deltaTime)
{
if (aux == NULL) /*TESTAR*/
{
calculaDirecaoColisaoParede(ent);
return;
}
else if ( getTipo(aux) == RECIFE )
{
if ( checkChance( CHANCE_ENCALHAR ) )
{
/*Bote encalhou... Deve ser reinicializado na borda da tela, com velocidade/direcao novas.
Por enquanto, simplesmente deletamos ele. O loop do jogo (no Naufrago) tomara conta de recria-lo.
Porem se quisermos fazer algum efeito ou codigo extra nesse caso, aqui e' o lugar.*/
setEntityToBeDestroyed( ent );
}
else
calculaDirecoesColisao(ent, aux);
}
else if ( isBote(aux) == 1 || getTipo(aux) == ASIMOV)
{
/*Colisao entre Botes ou Bote->Asimov, colisao simples, basta acertar as velocidades.*/
atualizaVelocidade( ent, aux, 1.0 );
}
else if ( getTipo(aux) == PASS )
{
setEntityToBeDestroyed( aux );
/*aqui este bote (ent) recolheu o passageiro (aux).
Por enquanto nao fazemos nada mais, mas se necessario, adicionar extras aqui, como aumentar um contador de
passageiros pegos, aumentar a massa do bote, etc.*/
}
}
void main(int argc, char *argv[]){
j = fopen("ips.json","w");
if(argc != 4){
sprintf(json + strlen(json),"{\n\"Error\": \"Faltan o sobran argumentos\"\n}");
fputs(json,j);
fclose(j);
}else{
char ip[16];
char clase, opcion;
int num = atoi(argv[3]);
char tipo[10];
f = fopen("red.txt","w");
sprintf(ip,"%s",argv[1]);
opcion = argv[2][0];
separaIP(ip);
fprintf(f,"Dirección IP: %d.%d.%d.%d\n",IP[0],IP[1],IP[2],IP[3]);
clase = getClase();
if(clase == 'A' || clase == 'B' || clase == 'C'){
sprintf(tipo,"%s",getTipo(clase));
fprintf(f,"Tipo: %s\n", tipo);
getDiRed();
getBroadcast(0);
sprintf(json,"{\n\"Red\": \"%d.%d.%d.%d\",\n\"Clase\": \"%c\",\n\"Primer IP\": \"%d.%d.%d.%d\",\n\"Mascara\": \"%d.%d.%d.%d\",\n\"Broadcast\": \"%d.%d.%d.%d\",\n\"Ultima IP\": \"%d.%d.%d.%d\",\n\"Default Gateway\": \"%d.%d.%d.%d\"",red[0],red[1],red[2],red[3],clase,red[0],red[1],red[2],red[3]+1,mascara[0],mascara[1],mascara[2],mascara[3],broadcast[0],broadcast[1],broadcast[2],broadcast[3],broadcast[0],broadcast[1],broadcast[2],broadcast[3]-1,broadcast[0],broadcast[1],broadcast[2],broadcast[3]-1);
imprimeTabla(clase);
}else{
fprintf(f,"Clase: %c\n",clase);
}
switch(opcion){
case 's':
validaNumero(bitsNecesarios(num),clase);
fprintf(f,"Se crearán %d subredes\n",(int)pow(2,bitsNecesarios(num)));
getSubredes(bitsNecesarios(num),clase);
break;
case 'h':
num += 2;
getHosts(bitsNecesarios(num),clase);
break;
case '-':
sprintf(json+strlen(json),"\n");
fputs(json,j);
break;
default:
sprintf(json + strlen(json),"{\n\"Error\": \"Argumento inválido\"\n}");
fputs(json,j);
fclose(j);
exit(0);
}
fclose(f);
strcat(json,"}");
fputs(json,j);;
fclose(j);
}
}
char* CatServ (int in_fd, int out_fd)
{
int bytes_rcvd = 1, bytes_sent = 0, i, j, cont = 0;
unsigned char * buf = (char *) malloc (BUF_SIZE);
char * tipo;
tipo = getTipo(in_fd);
while (bytes_rcvd > 0)
{
bzero(buf, sizeof(buf));
bytes_rcvd = read (in_fd, buf, BUF_SIZE);
write (out_fd, buf, bytes_rcvd);
}
free (buf);
return tipo;
}
/*Checa se a entidade passada e' um Bote, retornando 1 se for, 0 caso contrario.
Para isso simplesmente checamos se a ID da entidade consta na nossa lista de IDs de Botes.*/
short isBote(Entity ent)
{
return getTipo(ent) == BOTE;
}
bool Documento::isInstanceOf(std::string tipo) const
{
return getTipo() == tipo;
}
std::string Documento::str() const
{
return getTipo() + ": {numero: " + numero_ + ", mae: " + nome_mae_;
}
/*Checa se a entidade passada e' um passageiro, retornando 1 se for, 0 caso contrario.
Para isso simplesmente checamos se a ID da entidade consta na nossa lista de IDs de passageiros.*/
short isPassageiro(Entity ent)
{
return getTipo(ent) == PASS;
}
