Example #1
0
void TSpawnPoint::GetSpawnPoint(int *x, int *y, int *z) {
    do {
        int quadrado = rand() % n_quadrados; //em qual dos quadrados vai nascer

        int menor_x = Menor(quadrados_validos[quadrado].x1, quadrados_validos[quadrado].x2, quadrados_validos[quadrado].x3, quadrados_validos[quadrado].x4);

        int menor_y = Menor(quadrados_validos[quadrado].y1, quadrados_validos[quadrado].y2, quadrados_validos[quadrado].y3, quadrados_validos[quadrado].y4);

        int menor_z = Menor(quadrados_validos[quadrado].z1, quadrados_validos[quadrado].z2, quadrados_validos[quadrado].z3, quadrados_validos[quadrado].z4);



        int maior_x = Maior(quadrados_validos[quadrado].x1, quadrados_validos[quadrado].x2, quadrados_validos[quadrado].x3, quadrados_validos[quadrado].x4);

        int maior_y = Maior(quadrados_validos[quadrado].y1, quadrados_validos[quadrado].y2, quadrados_validos[quadrado].y3, quadrados_validos[quadrado].y4);

        int maior_z = Maior(quadrados_validos[quadrado].z1, quadrados_validos[quadrado].z2, quadrados_validos[quadrado].z3, quadrados_validos[quadrado].z4);


        int dx = maior_x - menor_x;
        if (dx == 0) dx = 1;
        int dy = maior_y - menor_y;
        if (dy == 0) dy = 1;
        int dz = maior_z - menor_z;
        if (dz == 0) dz = 1;

        *x = menor_x + rand() % dx;
        *y = menor_y + rand() % dy;
        *z = menor_z + rand() % dz;

    } while ( GuardarSpawn(*x, *y, *z) == false ); //sorteia novamente caso este ponto já tenha sido utilizado
}
Example #2
0
//Gera um vetor ordenado crescentemente com elementos de 0 a 'i-n+1=size'
void Crescente(int vetor[], int i, int n) {
    int menor = Menor(i,n);
    int size = Size(i,n);
    int x;
    for (x = 0; x < size; x++) {
        vetor[x] = menor + x;
    }
}
Example #3
0
int Menor( long item[], int n)                     //  item[n]     n      return
{                                                  //
    int num;                                       //  0:   92     0        92
                                                   //  1:   12     1        12
    if ( n==0 ) {                                  //  2:   -2     2        -2
        return( item[0] );                         //  3:   45     3        -2
    }                                              //  4:   57     4        -2
                                                   // etc...
    n--;
    num = Menor( item, n ); // recursao: traz no. "anterior"
    if (item[n] < num) {
        num = item[n];      // Sobrepoe se menor
    }                       // [senao] mantem no. "anterior"

    return(num);            // retorna [ "o anterior" | "o trocado" ]
}
Example #4
0
int main(void)
{
       //   8:   0  1  2  3  4  5  6  7
    long a[]= { 92,12,-2,25,57,15,23,-1};       // lista
//  long a[]= { 50,50,50,50}; //,50,50,50,50};       // lista
    int qtd = 8;

    printf("\nRecursive: \n\n");
    printArray( a, qtd );

    printf("Resultados ---\n");
    printf("   Menor : %3d \n", Menor( a, qtd) );
    printf("   Maior : %3d \n", Maior( a, qtd) );
    printf("    Soma : %3d \n", Soma ( a, qtd) );
    printf("   Media : %3d \n", Media( a, qtd) );

    return 0;
}
Example #5
0
int main ()
{
	int soma_num=0, soma_par=0, num, cont=0, cont_par=0, num_maior, num_menor;
	float media_num, media_par;
	printf("\t\t\t\t\t\tºPor: Felipe Andrade %cº\n\n",184);
	num=Ler_num(num);
	num_maior=num_menor=num;
	while (num != 0){
		cont++;
		soma_num=Soma(soma_num,num);
		num_maior=Maior(num,num_maior,num_menor);
		num_menor=Menor(num,num_maior,num_menor);
		if (num%2 == 0){
			soma_par=Soma_par(soma_par,num);
			cont_par++;
		}
		num=Ler_num(num);		
	}
	media_num = (float)soma_num/cont;
	media_par = (float)soma_par/cont_par;	
	Resultado(soma_num,cont,media_num,num_maior,num_menor,media_par);
}
Example #6
0
//i está contido e n não está contido no intervalo
int ValorAleatorioNoIntervalo(int i, int n) {
    int menor = Menor(i,n);
    int size = Size(i,n);
    return menor+(rand()%size);
}
Example #7
0
//Gera a diferença entre dois elementos
int Size(int a, int b) {
    return ((Maior(a,b) - Menor(a,b))+1);
}