Esempio n. 1
0
void choose_direction_for_ghost(char * map, struct pacghost * pacman, struct pacghost * ghost, int difficulty, int is_pacman_powered_up){
    if (!is_pacman_powered_up){
        if (difficulty == 0){
            move_randomly(ghost);
        } else if (difficulty == 1){
            int random = random_in_range(0,10);
            if (random < 5)
                move_randomly(ghost);
            else
                chase_after_pacman(pacman, ghost);
        } else if (difficulty == 2){
            int random = random_in_range(0,10);
            if (random < 2)
                move_randomly(ghost);
            else
                chase_after_pacman(pacman, ghost);

        } else {
            chase_after_pacman(pacman, ghost);
        }
    /* The ghost move to the point nearer to him than pacman when pacman powered */
    } else {
        /* As the point search in order. The ghost tend to stuck when came to top left */
        for (int rows = 0; rows < height; rows++) {
            for (int cols = 0; cols < width; cols++){
                if (isValidMoveCell(rows, cols)){
                    if (distance_between_two_points(pacman->xLocation,pacman->yLocation,rows,cols) > distance_between_two_points(ghost->xLocation,ghost->yLocation,rows,cols)){
                        ghost->direction = direction_from_node_to_node(ghost->xLocation,ghost->yLocation,rows,cols);
                        return;
                    }
                }
            }
        }
    }   
}
Esempio n. 2
0
void	do_sierpinski(short unsigned* shm, short unsigned* local,int* n_gen)
{
	int x,y;
	int des,sin,su;

	inuso=P(sem_id,0);
	
	if( (* n_gen) == 0 ) 
	{	// inizializza la matrice con una sola cella viva
		for ( y=0; y < N_Y * N_X; ++y )	local[y]=0;
		
		fiat( random_in_range(0,N_X), random_in_range(0,N_Y), local);
		++(* n_gen);
	} else
	{
		for( y=0; y < N_Y * N_X; ++y )	local[y]=shm[y];
	}

	for( y=0; y < N_Y; ++y )
	{ 
		for( x=0; x < N_X; ++x )
		{
			// rendiamo l'universo un toro \m/
			if(x==0)	sin=N_X-1;
			else		sin=x-1;
			if(x==N_X-1)	des=0;
			else		des=x+1;
			if(y==0)	su=N_Y-1;	
			else		su=y-1;
	
			switch( get_stato(x,y,local) )
			{
				case MORTO:
					if	// XOR
					(	(get_stato(sin,su,local)==VIVO)
					 ^	(get_stato(des,su,local)==VIVO)
					 ) 
						fiat(x,y,shm);
					else
						uccidi(x,y,shm);
					break;
				case VIVO:
					if	// condizione da rivedere
					(	(get_stato(sin,su,local)==VIVO)
					 &&	(get_stato(des,su,local)==VIVO)
					 ) 
						uccidi(x,y,shm);
					else
						fiat(x,y,shm);
					break;
				defaut:
					;
					break;
				}
			}
		} 
	
	++(*n_gen);
	inuso=V(sem_id,0);
}
Esempio n. 3
0
//
// Calculate the random influent each round
//
void RandomInfluent(void) {
	Influent.Flow = random_in_range(9, 30) / 10.0;
	Influent.Cbod = random_in_range(1900, 4000);
	Influent.Tss = random_in_range(2000, 5000);
	Influent.Tn = random_in_range(490, 750);
	Influent.Tp = random_in_range(75, 150);
}
Esempio n. 4
0
char *gen_random_str(int min, int max) {
    int length = random_in_range(min, max);
    char *s = calloc(length);
    for(int i=0; i<length - 2; i++) {
        s[i] = random_in_range(0x30, 0x7e);
    }
    return s;
}
Esempio n. 5
0
Vec3d Particle_source_box::uniform_position_in_cube( 
    const double xleft,  const double ytop, const double zfar,
    const double xright, const double ybottom, const double znear,
    std::default_random_engine &rnd_gen )
{
    return vec3d_init( random_in_range( xright, xleft, rnd_gen ), 
		       random_in_range( ybottom, ytop, rnd_gen ),
		       random_in_range( znear, zfar, rnd_gen ) );
}
Esempio n. 6
0
Vec3d Particle_source_cylinder::uniform_position_in_cylinder(
    std::default_random_engine &rnd_gen )
{
    // random point in cylinder along z
    Vec3d cyl_axis = vec3d_init( ( axis_end_x - axis_start_x ),
				 ( axis_end_y - axis_start_y ),
				 ( axis_end_z - axis_start_z ) );
    double cyl_axis_length = vec3d_length( cyl_axis );
    double x, y, z;
    double r, phi;
    r = sqrt( random_in_range( 0.0, 1.0, rnd_gen ) ) * radius;
    phi = random_in_range( 0.0, 2.0 * M_PI, rnd_gen );
    z = random_in_range( 0.0, cyl_axis_length, rnd_gen );
    //
    x = r * cos( phi );
    y = r * sin( phi );
    z = z;
    Vec3d random_pnt_in_cyl_along_z = vec3d_init( x, y, z );
    // rotate:
    // see https://en.wikipedia.org/wiki/Rodrigues'_rotation_formula
    // todo: Too complicated. Try rejection sampling.
    Vec3d random_pnt_in_rotated_cyl;
    Vec3d unit_cyl_axis = vec3d_normalized( cyl_axis );
    Vec3d unit_along_z = vec3d_init( 0, 0, 1.0 );
    Vec3d rotation_axis = vec3d_cross_product( unit_along_z, unit_cyl_axis );
    double rotation_axis_length = vec3d_length( rotation_axis );
    if ( rotation_axis_length == 0 ) {
	if ( copysign( 1.0, vec3d_z( unit_cyl_axis ) ) >= 0 ){
	    random_pnt_in_rotated_cyl = random_pnt_in_cyl_along_z;
	} else {
	    random_pnt_in_rotated_cyl = vec3d_negate( random_pnt_in_cyl_along_z );
	}
    } else {
	Vec3d unit_rotation_axis = vec3d_normalized( rotation_axis );
	double rot_cos = vec3d_dot_product( unit_cyl_axis, unit_along_z );
	double rot_sin = rotation_axis_length;
	
	random_pnt_in_rotated_cyl =
	    vec3d_add(
		vec3d_times_scalar( random_pnt_in_cyl_along_z, rot_cos ),
		vec3d_add(
		    vec3d_times_scalar(
			vec3d_cross_product( unit_rotation_axis,
					     random_pnt_in_cyl_along_z ),
			rot_sin ),
		    vec3d_times_scalar(
			unit_rotation_axis,
			( 1 - rot_cos ) * vec3d_dot_product(
			    unit_rotation_axis,
			    random_pnt_in_cyl_along_z ) ) ) );
    }
    // shift:
    Vec3d shifted = vec3d_add( random_pnt_in_rotated_cyl,
			       vec3d_init( axis_start_x, axis_start_y, axis_start_z ) );
    return shifted;
}
Esempio n. 7
0
File: main.c Progetto: thutt/lmsbw
static void
allocate_directories(directory_t *dir, unsigned allow_zero)
{
    unsigned n_directories = random_in_range(arg_subdirs);

    while (!allow_zero && n_directories == 0) {
        n_directories = random_in_range(arg_subdirs);
    }
    dir->n_directories = n_directories;
    dir->directories   = allocate_directory(n_directories);
}
Esempio n. 8
0
//This is a super-uniform function, much better than (rand() % max) +min
int random_in_range (unsigned int min, unsigned int max)
{
    int base_random = rand(); /* in [0, RAND_MAX] */
    if (RAND_MAX == base_random) return random_in_range(min, max);          /* now guaranteed to be in [0, RAND_MAX) */
    unsigned int range   = max - min,
                 remainder= RAND_MAX % range, // These are range buckets, plus one smaller interval
                 bucket   = RAND_MAX / range; // within remainder of RAND_MAX */
    if (base_random < RAND_MAX - remainder) 
        return min + base_random/bucket;
    else 
        return random_in_range (min, max);
}
Esempio n. 9
0
void InitFilesystem(void) {
	char root_passwd[32];
	char secure_passwd[32];
	uint8_t i;
        const char *rand_page = (const char *)0x4347C000;

	bzero(FS, sizeof(FS));
	bzero(FH, sizeof(FH));

	// generate a random root password
	bzero(root_passwd, 32);
	for (i = 0; i < 10; i++) {
		root_passwd[i] = (char)random_in_range(65,122);
	}
	root_passwd[i] = '\0';

	// generate a random secure user password
	bzero(secure_passwd, 32);
	for (i = 0; i < 31; i++) {
		secure_passwd[i] = (char)random_in_range(65,122);
	}
	secure_passwd[i] = '\0';

	// passwd file
	strcpy(FS[0].Filename, "passwd");
	strcpy(FS[0].Owner, "root");
	strcpy(FS[0].Group, "root");
	FS[0].Perms = 0x700;
	sprintf(FS[0].Data, "$s:secure:secure\ncrs:crs:crs\n$s:root:root", secure_passwd, root_passwd);
	FS[0].Size = cgc_strlen(FS[0].Data);

	// confidential data file
	strcpy(FS[1].Filename, "confidential");
	strcpy(FS[1].Owner, "secure");
	strcpy(FS[1].Group, "secure");
	FS[1].Perms = 0x700;
	// cgc_read starting at 4th byte since we already used the first 4 to seed the prng
	// but don't use any 4-byte chunks that have NULL's or newlines
	rand_page+=4;
	i = 0;
	while (i < 4) {
		if (*rand_page == '\0' || *rand_page == '\n') {
			i = 0;
			rand_page++;
			continue;
		}
		FS[1].Data[i++] = *rand_page;
		rand_page++;
	}
	FS[1].Size = 4;

}
Esempio n. 10
0
void swarm_to_digit(int digit, int start_idx, int end_idx, int offset_x, int offset_y) {
  int end = minimum(end_idx, NUM_PARTICLES);

  for(int i=start_idx; i<end; i++) {

    GBitmap bitmap   = *number_bitmaps[digit];
    const uint8_t *pixels = bitmap.addr;

    // pick a random point in the four image
    // get the image
    // pick a random number the length of the array
    // if the value is zero, pick a differnet number increment until you get there
    // move to that position
    int image_length = bitmap.row_size_bytes * bitmap.bounds.size.h - 1;
    int idx = random_in_range(0, image_length);
    uint8_t pixel = pixels[idx];

    // guarantee we're on a non-zero byte
    while(pixel == 0x00) {
     idx = random_in_range(0, image_length);
     pixel = pixels[idx];
    }

    // pick a non-zero bit
    int bit_pos = (idx * 8);
    int bit_add = random_in_range(0,7);
    int tries = 8;
    while(!(pixel & (1 << bit_add))) {
      if(tries < 0) break;
      bit_add = random_in_range(0,7);
      tries--;
    }
    bit_pos += bit_add;

    
    int row_size_bits = bitmap.row_size_bytes * 8;
    int pixel_row = bit_pos / row_size_bits;
    int pixel_col = bit_pos % row_size_bits;

    float scale = 1.0F;
    GPoint goal = GPoint(scale*pixel_col+offset_x, scale*pixel_row+offset_y); // switch row & col

    particles[i].grav_center = FPoint(goal.x, goal.y);
    particles[i].power = TIGHT_POWER;
    particles[i].goal_size = random_in_rangef(2.0F, 3.5F);
    particles[i].swarming = true;
  }

}
Esempio n. 11
0
File: 06.c Progetto: mBlack95/12
int random_in_range (int min, int max){
  	int base_random = rand(); /* in [0, RAND_MAX] */
  	if (RAND_MAX == base_random) return random_in_range(min, max);
  	/* now guaranteed to be in [0, RAND_MAX) */
  	int range = max - min,
 	remainder = RAND_MAX % range,
 	bucket = RAND_MAX / range;
	/* There are range buckets, plus one smaller interval
	within remainder of RAND_MAX */
	if (base_random < RAND_MAX - remainder) {
		return min + base_random/bucket;
	} else {
		return random_in_range (min, max);
	}  	
}
Esempio n. 12
0
vector<double> PageRank::metodoPotencia() {
	int n = A.size();
	// creo el x aleatorio
	vector<double> x(n, 0);
	for (int i = 0; i < n; i++) {
		x[i] = random_in_range(1,50);
	}

	// traspongo x para poder multiplicarlo por A
	vector< vector<double> > aux = row2Column(x);

	vector< vector<double> > B = multiply(A, A);
	vector< vector<double> > C = A;
	double delta = phi(column2Row(multiply(B, aux))) / phi(column2Row(multiply(C, aux)));
	double last_delta = INFINITY;

	while (fabs(delta - last_delta) > precision) {
		C = B;
		B = multiply(B, A);
		last_delta = delta;
		delta = phi(column2Row(multiply(B, aux))) / phi(column2Row(multiply(C, aux)));
	}
	vector<double> v = column2Row(multiply(B, aux));

	return scaleVector(v, 1/norma1(v));
}
Esempio n. 13
0
File: 06.c Progetto: mBlack95/12
int main() {
	int x, i, arr[100];
	while ((x<=0) || (x>=10)) {
	pritnf("Vavedete x: ");	
	scanf("%d", &x);
	}

	for(i=0; i<100; i++) {
		arr[i]=random_in_range (0,100);
		printf("%d ", arr[i]);
	}
	printf("\n End of Random Numbers \n");

	int z, n, f, m=0;
	for(n=0; n<10; n++) {	
		for(i=0; i<100; i++) {
			z=x+10*n;
			if (arr[i] == z) {
				f=arr[m];
				arr[m]=arr[i];
				arr[i]=f;
				m=m+1;
			}
		}
	}

	for(i=0; i<100; i++) {
		printf("%d ", arr[i]);
	}
			
	printf("\n");
}
Esempio n. 14
0
File: main.c Progetto: thutt/lmsbw
static void
allocate_sources(directory_t *dir)
{
    const unsigned n_sources = random_in_range(arg_sources);
    dir->n_sources           = n_sources;
    dir->sources             = allocate_source(n_sources);
}
Esempio n. 15
0
static unsigned int random_in_range(unsigned int min, unsigned int max)
{
    int base_random = rand();

    if (RAND_MAX == base_random) {
        return random_in_range(min, max);
    }

    unsigned int range     = max - min;
    unsigned int remainder = RAND_MAX % range;
    unsigned int bucket    = RAND_MAX / range;

    if ((unsigned int) base_random < RAND_MAX - remainder) {
        return min + ((unsigned int) base_random / bucket);
    }

    return random_in_range(min, max);
}
Esempio n. 16
0
int random_in_range(int min, int max)
{
	int base_random = rand();
	if(RAND_MAX == base_random) return random_in_range(min, max);

	int range = max - min;
	int remainder = RAND_MAX % range;
	int bucket = RAND_MAX / range;

	if(base_random < RAND_MAX - remainder)
	{
		return min + base_random/bucket;
	}
	else
	{
		return random_in_range(min, max);
	}
}
Esempio n. 17
0
// Shuffle the deck using the Knuth shuffle agorithm with array initialization
void shuffle(standard_deck *deck)
{
	for (int i=0; i<SIZE_OF_DECK; i++)
	{
		int j = random_in_range(0, i);
		deck->deck[i] = deck->deck[j];
		// Initialize array with the numbers 1 to 52
		deck->deck[j] = (char)(i + 1); 
	}
	deck->top = 0;
}
Esempio n. 18
0
static Location
enemy_random_location (void)
{
  Location location;
  location.x = get_random_location ().x;
  location.y = random_in_range (25, 100);

  return location;


}
Esempio n. 19
0
void test_random_port_in_range() {
  jnx_term_printf_in_color(JNX_COL_WHITE, "\ttest_random_port_in_range(): ");

  int i, count = 10, min = 10000, max = 20000, current;
  for (i = 0; i < count; i++) {
    current = random_in_range(min, max);
    assert(min <= current && current <= max);
  }

  jnx_term_printf_in_color(JNX_COL_GREEN, "Pass\n");
}
Esempio n. 20
0
void
calculate_grid_backtrack(void)
{
    int next_cell;

    for (int m = 0; m < 9; m++) {
        for (int n = 0; n < 9; n++) {
            next_cell = (int)random_in_range(9);
            insert_cell(m, n, next_cell);
        }
    }
}
Esempio n. 21
0
static Acceleration
enemy_random_acceleration ()
{

  Acceleration acceleration = {1.5, 0.5};

  //50% of enemy ships will go accelerate to the other side(heading towards up)

  if (random_in_range (0, 2)) acceleration.y *= -1;

  return acceleration;
}
Esempio n. 22
0
user *gen_random_user() {
    user *new_user = calloc(sizeof(user));
    new_user->name = gen_random_str(5, 32);
    char *hn = gen_random_str(5, 32);
    strcpy(new_user->hostname, hn);
    free(hn);
    new_user->idletime = rand() & 0xffffff;
    new_user->realname = gen_random_str(5, 64);
    new_user->phone = gen_random_str(9,9);
    new_user->online = random_in_range(0,1);

    return new_user;
}
Esempio n. 23
0
uint32_t AddConnection(CGCRPC_Endpoint *endpoint)
{
  for (int i=0; i < MAX_CGCRPC_CONNECTIONS; i++)
  {
    if (connections[i].bindID == 0)
    {
      connections[i].bindID = random_in_range(1, 0xffffffff);
      connections[i].endpoint = endpoint;
      return connections[i].bindID;
    }
  }
  return 0;
}
static void add_texture(int x, int y, gal_uint8 color)
{
    Texture *t;

    t = (Texture *) malloc(sizeof(Texture));

    t->mid_x = x << 16;
    t->mid_y = y << 16;

    t->millis = 0;
    t->color  = color;
    t->speed  = speed + (fixed_speed ? 0 : random_in_range(-(speed/2), +(speed/2)));
    t->succ = texture_list;
    texture_list = t;
}
Esempio n. 25
0
address *pick_address() {
    int i = 0;
    address *next = abook->root;
    while (next != NULL) {
        i++;
        next = next->next;
    }
    int pick = random_in_range(0, i-1);
    next = abook->root;
    while (next->next != NULL && pick > 0) {
        next = next->next;
        pick--;
    }
    return next;
}
Esempio n. 26
0
void
init_enemies (void)
{
  int i;
  ALLEGRO_BITMAP *shared_enemy_ship_image = al_load_bitmap ("assets/png/enemyShip.png");
  for (i = 0; i < NUM_ENEMIES; i++)
    {
      enemies[i].health_pts = ENEMY_HP;
      enemies[i].location = enemy_random_location ();
      enemies[i].live = 0;
      enemies[i].follow_player = random_in_range (0, 2); //50% will follow the player
      enemies[i].acceleration = enemy_random_acceleration ();
      enemies[i].image = shared_enemy_ship_image;
      enemies[i].puller = NULL;

    }
}
Esempio n. 27
0
address *add_random_addressbook_entry() {
    
    address *a = calloc(sizeof(address));
    a->name = gen_random_string(5, 32);
    a->home_server = gen_random_string(5, 32);
    a->mode = random_in_range(0,1);
    address *n = abook->root;
    if (n == NULL) {
        // First Entry
        abook->root = a;
    } else {
        while (n->next != NULL) {
            n = n->next;
        }
        n->next = a;
    }
    abook->num_entries++;
    return a;
}
Esempio n. 28
0
int sort_one(int a[], int length, int left, int right)
{
    if (a == NULL || length <= 0 || left < 0 || right >= length) {
        return -1;  /* error */
    }
    int index = random_in_range(left, right);
    swap(&a[index], &a[right]);
    int small = left - 1;

    for (index = left; index < right; index++) {
        if (a[index] < a[right]) {
            small++;
            if (small != index)
                swap(&a[small], &a[index]);
        }
    }
    small++;
    swap(&a[small], &a[right]);
    return small;
}
Esempio n. 29
0
void move_randomly(struct pacghost * ghost) {
    int availableWay = ghost_map[ghost->xLocation * width + ghost->yLocation]  - '0';
    int count = 0;
    if (availableWay >= 3 || !(canMove(ghost))) {
        int random = random_in_range(0,availableWay);
        if (isValidMoveCell(ghost->xLocation-1,ghost->yLocation)){
            if (count != random){
                count++;
            } else {
                ghost->direction = 0;
                count++;
            }
        }
        if (isValidMoveCell(ghost->xLocation,ghost->yLocation+1)){
            if (count != random){
                count++;
            } else {
                ghost->direction = 1;
                count++;
            }
        }
        if (isValidMoveCell(ghost->xLocation+1,ghost->yLocation)){
            if (count != random){
                count++;
            } else {
                ghost->direction = 2;
                count++;
            }
        }
        if (isValidMoveCell(ghost->xLocation,ghost->yLocation-1)){
            if (count != random)
                count++;
            else 
                ghost->direction = 3;
        }
    }
}
Esempio n. 30
0
vector<double> PageRankEsparso::metodoPotencia() {
	int n = A.size();
	// creo el x aleatorio
	vector<double> x(n, 0);
	for (int i = 0; i < n; i++) {
		x[i] = random_in_range(1,50);
	}
	// creo el v aleatorio
	vector<double> v(n, double(1)/double(n));

	vector<double> y = x;
	double delta = INFINITY;
	double last_delta;
	do {
		x = y;
		y = scaleVector(multiplyEsparso(A, x), teletransportacion);
		double w = norma1(x) - norma1(y);
		y = sumVector(y, scaleVector(v, w));
		last_delta = delta;
		delta = phi(y) / phi(x);
	} while (fabs(delta - last_delta) > precision);

	return scaleVector(y, 1/norma1(y));
}