/* ----------------------------------------------------------------------------
* Emits the particles, regardless of the timer.
* manager: The particle manager to place these particles on.
*/
void particle_generator::emit(particle_manager &manager) {
size_t final_nr =
max(
0,
(int) number +
randomi((int) (0 - number_deviation), (int) number_deviation)
);
for(size_t p = 0; p < final_nr; ++p) {
particle new_p = base_particle;
new_p.duration =
max(
0.0f,
new_p.duration +
randomf(-duration_deviation, duration_deviation)
);
new_p.time = new_p.duration;
new_p.friction +=
randomf(-friction_deviation, friction_deviation);
new_p.gravity +=
randomf(-gravity_deviation, gravity_deviation);
new_p.x +=
randomf(-x_deviation, x_deviation);
new_p.y +=
randomf(-y_deviation, y_deviation);
new_p.size =
max(
0.0f,
new_p.size +
randomf(-size_deviation, size_deviation)
);
//For speed, let's decide if we should use
//(speed_x and speed_y) or (speed and angle).
//We'll use whichever one is not all zeros.
if(angle != 0 || speed != 0) {
angle_to_coordinates(
angle + randomf(-angle_deviation, angle_deviation),
speed + randomf(-speed_deviation, speed_deviation),
&new_p.speed_x, &new_p.speed_y
);
} else {
new_p.speed_x +=
randomf(-speed_x_deviation, speed_x_deviation);
new_p.speed_y +=
randomf(-speed_y_deviation, speed_y_deviation);
}
manager.add(new_p);
}
}
int main ()
{
long i; long Ncirc = 0;
double pi, x, y, test;
double r = 1.0; // radius of circle. Side of squrare is 2*r
seed(-r, r); // The circle and square are centered at the origin
for(i=0;i<num_trials; i++)
{
x = randomi();
y = randomi();
test = x*x + y*y;
if (test <= r*r) Ncirc++;
}
pi = 4.0 * ((double)Ncirc/(double)num_trials);
printf("\n %ld trials, pi is %f \n",num_trials, pi);
return 0;
}
/* ----------------------------------------------------------------------------
* Checks if the attack should miss, and returns the result.
* If it was already decided that it missed in a previous frame, that's a
* straight no. If not, it will roll with the hit rate to check.
* If the attack is a miss, it also registers the miss, so that we can keep
* memory of it for the next frames.
*/
bool pikmin::process_attack_miss(hitbox_interaction* info) {
if(info->mob2->anim.cur_anim == missed_attack_ptr) {
//In a previous frame, we had already considered this animation a miss.
return false;
}
unsigned char hit_rate = info->mob2->anim.cur_anim->hit_rate;
if(hit_rate == 0) return false;
unsigned char hit_roll = randomi(0, 100);
if(hit_roll > hit_rate) {
//This attack was randomly decided to be a miss.
//Record this animation so it won't be considered a hit next frame.
missed_attack_ptr = info->mob2->anim.cur_anim;
missed_attack_timer.start();
return false;
}
return true;
}
/* ----------------------------------------------------------------------------
* Makes a mob move to a spot because it's being carried.
* m: Mob to start moving (the treasure, for instance).
* np: New Pikmin; the Pikmin that justed joined the carriers. Used to detect ties and tie-breaking.
* lp: Leaving Pikmin; the Pikmin that just left the carriers. Used to detect ties and tie-breaking.
*/
void start_carrying(mob* m, pikmin* np, pikmin* lp) {
// TODO what if an Onion hasn't been revelead yet?
if(!m->carrier_info) return;
if(m->carrier_info->carry_to_ship) {
m->set_target(
ships[0]->x + ships[0]->type->radius + m->type->radius + 8,
ships[0]->y,
NULL,
NULL,
false);
m->carrier_info->decided_type = NULL;
} else {
map<pikmin_type*, unsigned> type_quantity; // How many of each Pikmin type are carrying.
vector<pikmin_type*> majority_types; // The Pikmin type with the most carriers.
// First, count how many of each type there are carrying.
for(size_t p = 0; p < m->carrier_info->max_carriers; p++) {
pikmin* pik_ptr = NULL;
if(m->carrier_info->carrier_spots[p] == NULL) continue;
if(typeid(*m->carrier_info->carrier_spots[p]) != typeid(pikmin)) continue;
pik_ptr = (pikmin*) m->carrier_info->carrier_spots[p];
if(!pik_ptr->pik_type->has_onion) continue; // If it doesn't have an Onion, it won't even count. // TODO what if it hasn't been discovered / Onion not on this area?
type_quantity[pik_ptr->pik_type]++;
}
// Then figure out what are the majority types.
unsigned most = 0;
for(auto t = type_quantity.begin(); t != type_quantity.end(); t++) {
if(t->second > most) {
most = t->second;
majority_types.clear();
}
if(t->second == most) majority_types.push_back(t->first);
}
// If we ended up with no candidates, pick a type at random, out of all possible types.
if(majority_types.empty()) {
for(auto t = pikmin_types.begin(); t != pikmin_types.end(); t++) {
if(t->second->has_onion) { // TODO what if it hasn't been discovered / Onion not on this area?
majority_types.push_back(t->second);
}
}
}
// Now let's pick an Onion.
if(majority_types.empty()) {
return; // TODO warn that something went horribly wrong?
} else if(majority_types.size() == 1) {
// If there's only one possible type to pick, pick it.
m->carrier_info->decided_type = majority_types[0];
} else {
// If there's a tie, let's take a careful look.
bool new_tie = false;
// Is the Pikmin that just joined part of the majority types?
// If so, that means this Pikmin just created a NEW tie!
// So let's pick a random Onion again.
if(np) {
for(size_t mt = 0; mt < majority_types.size(); mt++) {
if(np->type == majority_types[mt]) {
new_tie = true;
break;
}
}
}
// If a Pikmin left, check if it is related to the majority types.
// If not, then a new tie wasn't made, no worries.
// If it was related, a new tie was created.
if(lp) {
new_tie = false;
for(size_t mt = 0; mt < majority_types.size(); mt++) {
if(lp->type == majority_types[mt]) {
new_tie = true;
break;
}
}
}
// Check if the previously decided type belongs to one of the majorities.
// If so, it can be chosen again, but if not, it cannot.
bool can_continue = false;
for(size_t mt = 0; mt < majority_types.size(); mt++) {
if(majority_types[mt] == m->carrier_info->decided_type) {
can_continue = true;
break;
}
}
if(!can_continue) m->carrier_info->decided_type = NULL;
// If the Pikmin that just joined is not a part of the majorities,
// then it had no impact on the existing ties.
// Go with the Onion that had been decided before.
if(new_tie || !m->carrier_info->decided_type) {
m->carrier_info->decided_type = majority_types[randomi(0, majority_types.size() - 1)];
}
}
// Figure out where that type's Onion is.
size_t onion_nr = 0;
for(; onion_nr < onions.size(); onion_nr++) {
if(onions[onion_nr]->oni_type->pik_type == m->carrier_info->decided_type) {
break;
}
}
// Finally, start moving the mob.
m->set_target(onions[onion_nr]->x, onions[onion_nr]->y, NULL, NULL, false);
m->set_state(MOB_STATE_BEING_CARRIED);
sfx_pikmin_carrying.play(-1, true);
}
}
/* implementation of Test B */
void testb_check(size_t const n) {
list_t lists[NUM_OF_LISTS];
int *added_value;
int values[NUM_OF_LISTS][n];
int ret, i, j;
int value;
// --------------
// INITIALIZATION
// of the lists and check for correctness
// --------------
for(i=0; i<NUM_OF_LISTS; ++i) {
ret = list_init(&lists[i]);
assert(ret == 0 && "list initialization fails");
}
// for achieving the insertion of new elements creating new
// memory areas, instead of calling malloc(), we set the
// list_attribute_copy and check the correctness.
for(i=0; i<NUM_OF_LISTS; ++i) {
ret = list_attributes_copy(&lists[i], int_size, 1);
assert(ret == 0 && "setting attribute copy fails");
}
// ---------
// INSERTION
// both successful and unsuccessful
// ---------
for(i=0; i<NUM_OF_LISTS; ++i) {
// successful insertion in empty list
randomi(&value);
ret = list_insert_at(&lists[i], &value, 0);
assert(ret > 0 && "element insertion fails");
assert(list_size(&lists[i]) == 1 && "list size is wrong");
// checking the inserted value
added_value = (int *)list_get_at(&lists[i], 0);
assert(added_value != NULL && "retrieving element fails");
assert(value == *added_value && "retrieved value has wrong value");
// successful deletion
ret = list_delete_at(&lists[i], 0);
assert(ret == 0 && "delete element fails");
assert(list_size(&lists[i]) == 0 && "list size is wrong");
}
// Failure of insertion on multiple elements.
// The insertion is done at indexes that are not
// reachable for the list because it's empty
for(i=0; i<NUM_OF_LISTS; ++i) {
randomi(&value);
for(j=1; j<4; ++j) {
ret = list_insert_at(&lists[i], &value, j);
assert(ret < 0 && "element insertion failure fails");
assert(list_size(&lists[i]) == 0 && "list size is wrong");
ret = list_delete_at(&lists[i], j);
assert(ret < 0 && "element deletion failure fails");
assert(list_size(&lists[i]) == 0 && "list size is wrong");
}
}
// ---------
// PREAPPEND
// ---------
// append the second half of the lists
for(i=0; i<NUM_OF_LISTS; ++i) {
for(j=0; j<(n/2); ++j) {
randomi(&value);
ret = list_prepend(&lists[i], &value);
assert(ret == 1 && "element prepend fails");
// checking also the value appended
added_value = (int *)list_get_at(&lists[i], 0);
assert(added_value != NULL && "retrieving element fails");
assert(value == *added_value && "retrieved value has wrong value");
// store the max for each list
values[i][(n/2-1)-j] = value;
}
assert(list_size(&lists[i]) == n/2 && "list size is wrong");
}
// ------
// APPEND
// ------
// append the first half of the lists
for(i=0; i<NUM_OF_LISTS; ++i) {
for(j=(n/2); j<n; ++j) {
randomi(&value);
ret = list_append(&lists[i], &value);
assert(ret == 1 && "element append fails");
// checking also the value appended
added_value = (int *)list_get_at(&lists[i], j);
assert(added_value != NULL && "retrieving element fails");
assert(value == *added_value && "retrieved value has wrong value");
// store the value in the matrix
values[i][j] = value;
}
assert(list_size(&lists[i]) == n && "list size is wrong");
}
// check the values inserted in the lists
for(i=0; i<NUM_OF_LISTS; ++i) {
for(j=0; j<n; ++j) {
assert(values[i][j] == *(int *)list_get_at(&lists[i], j)
&& "retrieved value has wrong value");
}
}
// -----
// CLEAR
// -----
// check the correctness of the clear function execution
// and check also the length of the cleared list
for(i=0; i<NUM_OF_LISTS; ++i) {
unsigned int isize;
isize = list_size(&lists[i]);
ret = list_clear(&lists[i]);
assert(ret == (int)isize && "clearing list fails");
ret = list_size(&lists[i]);
assert(ret == 0 && "list size is wrong");
}
// -------
// DESTROY
// -------
// destroy both lists
for(i=0; i<NUM_OF_LISTS; ++i)
list_destroy(&lists[i]);
}
void Grass::fixTexType()
{
texPart_x = randomi(0,6);
}
