Sphere::Sphere(GLfloat _x, GLfloat _y, GLfloat _z, GLfloat _radius, GLfloat _r, GLfloat _g, GLfloat _b) {
x = _x;
y = _y;
z = _z;
radius = _radius;
float speedCap = 0.05;
vx = randomFloat(-speedCap, speedCap);
vy = randomFloat(-speedCap, speedCap);
vz = randomFloat(-speedCap, speedCap);
if (_r == -1) {
color[0] = randomFloat(0.0, 1.0);
color[1] = randomFloat(0.0, 1.0);
color[2] = randomFloat(0.0, 1.0);
} else {
color[0] = _r;
color[1] = _g;
color[2] = _b;
}
color[3] = 1.0f;
}
float randomMass() { return randomFloat(mass_min, mass_max); }
double RobertaFunctions::arrRand(int len, double arr[]) {
int arrayInd = len * (randomFloat()*100)/100;
return arr[arrayInd - 1];
}
float Random::randomInRange(float min, float max){
return randomFloat() * (max - min + 1) + min;
}
std::vector<std::vector<Phase>> initializeBossPhases(World &world, Boss &boss)
{
std::vector<std::vector<Phase>> data(Boss::TypeCount);
// Welcome to one of the most un-readable code I've ever made :
// Boss1 Phase1
Phase b1p1(world, boss, sf::seconds(5.f));
b1p1.addSkill(sf::seconds(0.f), [&](Boss& b, sf::Time){
Player* player = world.getPlayerEntity();
//world.shakeCameraFor(0.3f);
boss.unsensible();
if((b.getPosition().x-player->getPosition().x) > 40) {
boss.move(Entity::Left);
} else if((b.getPosition().x-player->getPosition().x) < 40) {
boss.move(Entity::Right);
} else {
//boss.knock();
}
});
data[Boss::Boss1].push_back(b1p1);
// Boss1 Phase2
Phase b1p2(world, boss, sf::seconds(3.f));
b1p2.addSkill(sf::seconds(0.f), [&](Boss& b, sf::Time){
b.sensible();
});
data[Boss::Boss1].push_back(b1p2);
// Boss1 Phase3
Phase b1p3(world, boss, sf::seconds(1.f));
b1p3.addSkill(sf::seconds(0.9f), [&](Boss& b, sf::Time dt){
if(randomInt(0,5) == 1) world.addMedkit(sf::Vector2f(randomFloat(10, 1270), 20));
});
data[Boss::Boss1].push_back(b1p3);
// Boss1 Phase4
Phase b1p4(world, boss, sf::seconds(1.f));
b1p4.addSkill(sf::seconds(0.9f), [&](Boss& b, sf::Time dt){
Player* player = world.getPlayerEntity();
auto pos = player->getPosition();
//world.addZombie(sf::Vector2f(pos.x, 100.f));
//world.addZombie(sf::Vector2f(pos.x+50.f, 100.f));
world.addZombie(sf::Vector2f(randomFloat(10, 1270), 100.f));
b.playLocalSound(world.getCommandQueue(), Sounds::Boss1AddPop);
});
data[Boss::Boss1].push_back(b1p4);
//////////////////////////////////////////////
/*// Boss2 Phase2
Phase b2p2(world, boss, sf::seconds(2.f));
b2p2.addSkill(sf::seconds(0.90f), [&](Boss&, sf::Time){
});
data[Entity::Boss2].push_back(b2p2);
// Boss2 Phase1
Phase b2p1(world, boss, sf::seconds(1.2f));
b2p1.addSkill(sf::seconds(0.5f), [&](Boss& b, sf::Time){
PlayerEntity* player = world.player();
if((b.getPosition().x-player->getPosition().x) > 0) {
world.addCreature(2, 50.f);
} else {
world.addCreature(2, -50.f);
}
});
data[Entity::Boss2].push_back(b2p1);
// Boss2 Phase2
data[Entity::Boss2].push_back(b2p2);
data[Entity::Boss2].push_back(b2p1);
data[Entity::Boss2].push_back(b2p2);
data[Entity::Boss2].push_back(b2p1);
// Boss1 Phase4
Phase b2p3(world, boss, sf::seconds(0.f));
b2p3.addSkill(sf::seconds(0.f), [&](Boss& b, sf::Time dt){
PlayerEntity* player = world.player();
if(b.getPosition().x < 512) {
for(unsigned int i = 0; i < 5; ++i)
{
world.addCreature(2, 50.f + i*32.f);
}
world.addCreature(1, 380.f);
} else {
for(unsigned int i = 0; i < 5; ++i)
{
world.addCreature(2, -50.f - i*32.f);
}
world.addCreature(1, -380.f);
}
});
data[Entity::Boss2].push_back(b2p3);
// Boss2 Phase4
Phase b2p4(world, boss, sf::seconds(4.f));
b2p4.addSkill(sf::seconds(0.f), [&](Boss& b, sf::Time){
PlayerEntity* player = world.player();
if((b.getPosition().x-player->getPosition().x) > 0) {
boss.move(Entity::Left);
} else {
boss.move(Entity::Right);
}
});
data[Entity::Boss2].push_back(b2p4);
// Boss2 Phase5
Phase b2p5(world, boss, sf::seconds(2.f));
b2p5.addSkill(sf::seconds(0.90f), [&](Boss& b, sf::Time){
b.knock();
});
data[Entity::Boss2].push_back(b2p5);
// Boss2 Phase6
Phase b2p6(world, boss, sf::seconds(0.0f));
b2p6.addSkill(sf::seconds(0.f), [&](Boss& b, sf::Time){
PlayerEntity* player = world.player();
if((b.getPosition().x-player->getPosition().x) > 0) {
world.addCreature(3, 50.f);
} else {
world.addCreature(3, -50.f);
}
});
data[Entity::Boss2].push_back(b2p6);
// Boss2 Phase7
Phase b2p7(world, boss, sf::seconds(4.1f));
b2p7.addSkill(sf::seconds(0.f), [&](Boss& b, sf::Time){
PlayerEntity* player = world.player();
if((b.getPosition().x-player->getPosition().x) > 0) {
boss.move(Entity::Right);
} else {
boss.move(Entity::Left);
}
});
data[Entity::Boss2].push_back(b2p7);
//////////////////////////////////////////////
// Boss3 Phase1
Phase b3p1(world, boss, sf::seconds(0.6f));
b3p1.addSkill(sf::seconds(0.5f), [&](Boss& b, sf::Time){
for(unsigned int i = 0; i < 6; ++i)
{
world.addCreature(3, 50.f + 150.f*i);
world.addCreature(3, -50.f - 150.f*i);
}
});
data[Entity::Boss3].push_back(b3p1);
Phase b3p2(world, boss, sf::seconds(5.f));
b3p2.addSkill(sf::seconds(0.90f), [&](Boss& b, sf::Time){b.knock();});
data[Entity::Boss3].push_back(b3p2);
// Boss1 Phase1
Phase b3p3(world, boss, sf::seconds(5.f));
b3p3.addSkill(sf::seconds(0.f), [&](Boss& b, sf::Time){
PlayerEntity* player = world.player();
world.shakeCameraFor(0.3f);
if((b.getPosition().x-player->getPosition().x) > 0) {
boss.move(Entity::Left);
} else {
boss.move(Entity::Right);
}
});
data[Entity::Boss3].push_back(b3p3);
data[Entity::Boss3].push_back(b3p1);
// Boss1 Phase4
Phase b3p4(world, boss, sf::seconds(3.f));
b3p4.addSkill(sf::seconds(0.f), [&](Boss& b, sf::Time){
b.knock();
});
data[Entity::Boss3].push_back(b3p4);
// Boss3 Phase5
Phase b3p5(world, boss, sf::seconds(2.f));
b3p5.addSkill(sf::seconds(0.f), [&](Boss& b, sf::Time dt){
b.setPosition(sf::Vector2f(b.getPosition().x, b.getPosition().y-500*dt.asSeconds()));
});
data[Entity::Boss3].push_back(b3p5);
data[Entity::Boss3].push_back(b3p2);
// Boss3 Phase6
Phase b3p6(world, boss, sf::seconds(0.0f));
b3p6.addSkill(sf::seconds(0.f), [&](Boss& b, sf::Time dt){
PlayerEntity* player = world.player();
b.setPosition(sf::Vector2f(player->getPosition().x, -160));
world.addCreature(1, 50);
});
data[Entity::Boss3].push_back(b3p6);
Phase b3p6bis(world, boss, sf::seconds(1.5f));
b3p6bis.addSkill(sf::seconds(0.90f), [&](Boss& b, sf::Time){b.knock();});
data[Entity::Boss3].push_back(b3p6bis);
// Boss3 Phase7
Phase b3p7(world, boss, sf::seconds(1.3f));
b3p7.addSkill(sf::seconds(0.f), [&](Boss& b, sf::Time dt){
if(b.getPosition().y < 512-105)
{
b.setPosition(sf::Vector2f(b.getPosition().x, b.getPosition().y+500*dt.asSeconds()));
}
else
{
world.shakeCamera();
b.playLocalSound(world.getCommandQueue(), Sounds::BossCrush);
}
});
data[Entity::Boss3].push_back(b3p7);
data[Entity::Boss3].push_back(b3p1);
// Boss3 Phase8
data[Entity::Boss3].push_back(b3p5);
data[Entity::Boss3].push_back(b3p6);
data[Entity::Boss3].push_back(b3p6bis);
data[Entity::Boss3].push_back(b3p7);
data[Entity::Boss3].push_back(b3p1);
data[Entity::Boss3].push_back(b3p5);
// Boss3 Phase9
Phase b3p9(world, boss, sf::seconds(1.5f));
b3p9.addSkill(sf::seconds(0.f), [&](Boss& b, sf::Time dt){
b.setPosition(1024+160, 512-105);
});
data[Entity::Boss3].push_back(b3p9);*/
return data;
}
void DimensionReduction::apply(Window im, int dimensions) {
assert(dimensions < im.channels && dimensions > 0,
"dimensions must be greater than zero and less than the current number of channels\n");
// get some statistics (mostly for the covariance matrix)
Stats stats(im);
// we're going to find the leading eigenvectors of the covariance matrix and
// use them as the basis for our subspace
vector<float> subspace(dimensions * im.channels), newsubspace(dimensions * im.channels);
for (int i = 0; i < dimensions * im.channels; i++) subspace[i] = randomFloat(0, 1);
float delta = 1;
while (delta > 0.00001) {
// multiply the subspace by the covariance matrix
for (int d = 0; d < dimensions; d++) {
for (int c1 = 0; c1 < im.channels; c1++) {
newsubspace[d * im.channels + c1] = 0;
for (int c2 = 0; c2 < im.channels; c2++) {
newsubspace[d * im.channels + c1] += (float)(subspace[d * im.channels + c2] * stats.covariance(c1, c2));
}
}
}
// orthonormalize it with gram-schmidt
for (int d = 0; d < dimensions; d++) {
// first subtract it's component in the direction of all earlier vectors
for (int d2 = 0; d2 < d; d2++) {
float dot = 0;
for (int c = 0; c < im.channels; c++) {
dot += newsubspace[d * im.channels + c] * newsubspace[d2 * im.channels + c];
}
for (int c = 0; c < im.channels; c++) {
newsubspace[d * im.channels + c] -= dot * newsubspace[d2 * im.channels + c];
}
}
// then normalize it
float sum = 0;
for (int c = 0; c < im.channels; c++) {
float val = newsubspace[d * im.channels + c];
sum += val * val;
}
float factor = 1.0f / sqrt(sum);
for (int c = 0; c < im.channels; c++) {
newsubspace[d * im.channels + c] *= factor;
}
// if the sum is negative, flip it
sum = 0;
for (int c = 0; c < im.channels; c++) {
sum += newsubspace[d * im.channels + c];
}
if (sum < -0.01) {
for (int c = 0; c < im.channels; c++) {
newsubspace[d * im.channels + c] *= -1;
}
}
}
// check to see how much changed
delta = 0;
for (int d = 0; d < dimensions; d++) {
for (int c = 0; c < im.channels; c++) {
float diff = newsubspace[d * im.channels + c] - subspace[d * im.channels + c];
delta += diff * diff;
}
}
newsubspace.swap(subspace);
}
// now project the image onto the subspace
vector<float> output(im.channels);
for (int t = 0; t < im.frames; t++) {
for (int y = 0; y < im.height; y++) {
for (int x = 0; x < im.width; x++) {
for (int c = 0; c < im.channels; c++) output[c] = 0;
// project this pixel onto each vector, and add the results
for (int d = 0; d < dimensions; d++) {
float dot = 0;
for (int c = 0; c < im.channels; c++) {
dot += im(x, y, t)[c] * subspace[d * im.channels + c];
}
for (int c = 0; c < im.channels; c++) {
output[c] += dot * subspace[d * im.channels + c];
}
}
for (int c = 0; c < im.channels; c++) im(x, y, t)[c] = output[c];
}
}
}
// display the subspace for debugging
printf("Basis chosen:\n");
for (int c = 0; c < im.channels; c++) {
for (int d = 0; d < dimensions; d++) {
printf("%f \t", newsubspace[d * im.channels + c]);
}
printf("\n");
}
}
TEST( AudioEngine, TempoUpdate )
{
AudioEngine::test_program = 1; // help mocked OpenSL IO identify which test is running
// prepare engine environment
float oldTempo = randomFloat( 40.0f, 199.0f );
float newTempo = randomFloat( 120.0f, 300.0f );
SequencerController* controller = new SequencerController();
controller->prepare( 240, 48000, oldTempo, 4, 4 );
controller->setTempoNow( oldTempo, 4, 4 ); // ensure tempo is applied immediately
controller->rewind();
int oldSPBar = AudioEngine::samples_per_bar;
int oldSPBeat = AudioEngine::samples_per_beat;
int oldSPStep = AudioEngine::samples_per_step;
int oldMaxBP = AudioEngine::max_buffer_position = randomInt( 11025, 8820 );
EXPECT_EQ( oldTempo, controller->getTempo() )
<< "expected tempo to be set prior to engine start";
// request new tempo via controller
controller->setTempo( newTempo, 12, 8 );
EXPECT_EQ( oldTempo, controller->getTempo() )
<< "expected tempo at the old value to be set prior to engine start";
EXPECT_EQ( 4, controller->getTimeSigBeatAmount() )
<< "expected time signature to be at the old value prior to the engine start";
EXPECT_EQ( 4, controller->getTimeSigBeatUnit() )
<< "expected time signature to be at the old value prior to the engine start";
AudioEngine::start();
//usleep( 50 ); // tempo update is executed after the engine is halted by the OpenSL mock
// assert results
EXPECT_EQ( newTempo, controller->getTempo() )
<< "expected engine to have updated the tempo during a single iteration of its render cycle";
EXPECT_EQ( 12, controller->getTimeSigBeatAmount() )
<< "expected engine to have updated the time signature during a single iteration of its render cycle";
EXPECT_EQ( 8, controller->getTimeSigBeatUnit() )
<< "expected engine to have updated the time signature during a single iteration of its render cycle";
ASSERT_FALSE( AudioEngine::max_buffer_position == oldMaxBP )
<< "expected engine to have updated its max buffer position after tempo change";
ASSERT_FALSE( AudioEngine::samples_per_bar == oldSPBar )
<< "expected engine to have updated its samples per bar value after tempo change";
ASSERT_FALSE( AudioEngine::samples_per_beat == oldSPBeat )
<< "expected engine to have updated its samples per beat value after tempo change";
ASSERT_FALSE( AudioEngine::samples_per_step == oldSPStep )
<< "expected engine to have updated its samples per step value after tempo change";
EXPECT_EQ( 2, AudioEngine::test_program )
<< "expected program to have incremented";
delete controller;
}
// TO DO - Base on waypoint danger
// base on base point -- if already have attack point and base point -- less focus on base point
int CTFObjectiveResource::getRandomValidPointForTeam ( int team, ePointAttackDefend_s type)
{
TF2PointProb_t *arr = NULL;
vector<int> points;
int iotherteam;
float fTotal = 0.0f;
if (( team < 2 ) || ( team > 3 ))
return 0;
if ( m_iNumControlPoints == NULL )
return 0;
iotherteam = (team==2)?3:2;
arr = m_ValidPoints[team-2][type];
for ( int i = 0; i < *m_iNumControlPoints; i ++ )
{
if ( arr[i].bValid == true )
{
points.push_back(i);
if ( type == TF2_POINT_ATTACK )
{
if (GetCappingTeam(i) == team)
arr[i].fProbMultiplier = 3.0f;
else if ((getLastCaptureTime(i) + 10.0f) > gpGlobals->curtime )
arr[i].fProbMultiplier = 2.0f;
}
else
{
if (GetCappingTeam(i) == iotherteam)
{
int numplayers = GetNumPlayersInArea(i,iotherteam);
// IF this is not base point and a lot of players are here, reduce probability of defending
if ( (i != GetBaseControlPointForTeam(team)) && (numplayers > 1) )
{
arr[i].fProbMultiplier = 1.0f - ((float)numplayers/(gpGlobals->maxClients/4));
if ( arr[i].fProbMultiplier <= 0.0f )
arr[i].fProbMultiplier = 0.1f;
}
else // Otherwise there aren't any playres on or is base and has been attacked recently
arr[i].fProbMultiplier = 4.0f;
}
else if ((getLastCaptureTime(i) + 10.0f) > gpGlobals->curtime )
arr[i].fProbMultiplier = 2.0f;
}
fTotal += arr[i].fProb*arr[i].fProbMultiplier;
}
}
float fRand = randomFloat(0.0f,fTotal);
fTotal = 0.0f;
for ( unsigned int i = 0; i < points.size(); i ++ )
{
int index = points[i];
fTotal += arr[index].fProb*arr[index].fProbMultiplier;
if ( fTotal > fRand )
{
return m_IndexToWaypointAreaTranslation[index];
}
}
// no points
return 0;
}
void tree::fractalTree(int count, Vertex zero, Vertex one, float angleRight, float angleLeft)
{
count--;
if (count > 0) {
vec4 Zero(zero.coords[0], zero.coords[1],zero.coords[2],1);
vec4 One(one.coords[0], one.coords[1], one.coords[2],1);
vec4 Scale = (One - Zero);
Scale = Scale * 0.8f;
//float randValue = randomFloat(-rand, rand);
//float alpha = ((angleRight + randValue)*3.14 / 180);
////mat3x3 rotMatrix(cos(alpha), sin(alpha), -sin(alpha), cos(alpha));
//mat3x3 rotMatrixX(1, 0, 0, 0, cos(alpha), sin(alpha), 0, -sin(alpha), cos(alpha));
//float randValue2 = randomFloat(-rand, rand);
//float beta = ((angleRight + randValue2)*3.14 / 180);
//mat3x3 rotMatrixZ(cos(beta), sin(beta), 0, -sin(beta), cos(beta), 0, 0, 0, 1);
//vec3 Answer = (Scale * rotMatrixZ)*rotMatrixX;
mat4 rotMatrix = mat4(1);
rotMatrix = rotate(rotMatrix, randomFloat((-angleRight), angleRight)*3.14f/180.0f, vec3(0, 1, 0));
rotMatrix = rotate(rotMatrix, randomFloat((-angleRight), angleRight)*3.14f / 180.0f, vec3(0, 0, 1));
rotMatrix = rotate(rotMatrix, randomFloat((-angleRight), angleRight)*3.14f / 180.0f, vec3(1, 0, 0));
vec4 Answer = rotMatrix * Scale;
Answer = Answer + One;
branches[branchesIterator].zero = one;
branches[branchesIterator].zero.colors[0] = 0.3f;
branches[branchesIterator].zero.colors[1] = 0.1f;
branches[branchesIterator].one.coords[0] = Answer.x;
branches[branchesIterator].one.coords[1] = Answer.y;
branches[branchesIterator].one.coords[2] = Answer.z;
branches[branchesIterator].one.coords[3] = 1;
branches[branchesIterator].one.coords[3] = 1;
branches[branchesIterator].one.colors[0] = 0.3f;
branches[branchesIterator].one.colors[1] = 0.1f;
if (count == 1)
branches[branchesIterator].end = true;
else
branches[branchesIterator].end = false;
branchesIterator++;
depth.push_back(count);
fractalTree(count, branches[branchesIterator - 1].zero, branches[branchesIterator - 1].one, angleRight, angleLeft);
////////////////////////////////////////////////
Zero = vec4(zero.coords[0], zero.coords[1], zero.coords[2],1);
One = vec4(one.coords[0], one.coords[1], one.coords[2],1);
Scale = One - Zero;
Scale = Scale * 0.8f;
/*randValue = randomFloat(-rand, rand);
alpha = ((angleLeft +randValue)*3.14 / 180)*-1;
rotMatrixX = mat3x3(1, 0, 0, 0, cos(alpha), sin(alpha), 0, -sin(alpha), cos(alpha));
randValue2 = randomFloat(-rand, rand);
beta = ((angleLeft + randValue2)*3.14 / 180)*-1;
rotMatrixZ = mat3x3(cos(beta), sin(beta), 0, -sin(beta), cos(beta), 0, 0, 0, 1);
Answer = (Scale * rotMatrixZ)*rotMatrixX;*/
rotMatrix = mat4(1);
rotMatrix = rotate(rotMatrix, (randomFloat((-angleLeft), angleLeft)*3.14f/180.0f), vec3(0, 1, 0));
rotMatrix = rotate(rotMatrix, randomFloat((-angleLeft), angleLeft)*3.14f / 180.0f, vec3(0, 0, 1));
rotMatrix = rotate(rotMatrix, randomFloat((-angleLeft), angleLeft)*3.14f / 180.0f, vec3(1, 0, 0));
Answer = rotMatrix * Scale;
Answer = Answer + One;
branches[branchesIterator].zero = one;
branches[branchesIterator].zero.colors[0] = 0.3f;
branches[branchesIterator].zero.colors[1] = 0.1f;
branches[branchesIterator].one.coords[0] = Answer.x;
branches[branchesIterator].one.coords[1] = Answer.y;
branches[branchesIterator].one.coords[2] = Answer.z;
branches[branchesIterator].one.coords[3] = 1;
branches[branchesIterator].one.coords[3] = 1;
branches[branchesIterator].one.colors[0] = 0.3f;
branches[branchesIterator].one.colors[1] = 0.1f;
if (count == 1)
branches[branchesIterator].end = true;
else
branches[branchesIterator].end = false;
branchesIterator++;
depth.push_back(count);
fractalTree(count, branches[branchesIterator - 1].zero, branches[branchesIterator - 1].one, angleRight,angleLeft);
}
}
Vector2D ParticalEffect::RandomUnitVectorHalf() {
float angle = (TWO_PI/2.0f) * randomFloat();
return Vector2D( cos(angle), sin(angle) );
}
Vector2D ParticalEffect::RandomUnitVector() {
float angle = TWO_PI * randomFloat();
return Vector2D( cos(angle), sin(angle) );
}
float ParticalEffect::randomInRange(float min, float max) {
return randomFloat() * (max - min + 1) + min;
}
//Returns the average velocity of particles produced by the fountain.
cVec3 Explosion::CurVelocity() {
//return cVec3(0.0f, -3 * cos(mfAngle) , 3 * cos(mfAngle));
return cVec3(0.5f * randomFloat() - 0.25f, 1.f * randomFloat() + 1.f, 0.5f * randomFloat() - 0.25f);
}
float BaseUtils::randomAngle(float from, float to) {
while (to < from) {
to += 360;
}
return normalizeAngle(randomFloat(from, to));
}
void initWeights(Neuron* neuron) {
for (int i = 0; i <= N; i++)
neuron->w[i] = randomFloat();
}
glm::vec2 Randomness::randomUnitVector()
{
float angle = TWO_PI * randomFloat();
return glm::vec2(cos(angle), sin(angle));
}
float Randomness::randomInRange(float min, float max)
{
return (randomFloat()*(max-min)+min);
}
//--------------------------------------------------------------
void ofApp::setup(){
sliderArea = ofRectangle(0, 0, ofGetWindowWidth() / 2, ofGetWindowHeight());
///////////////////////////////
// Audio Stuff
///////////////////////////////
const int NUM_STEPS = 8;
// synth paramters are like instance variables -- they're values you can set later, by
// cally synth.setParameter()
ControlGenerator bpm = synth.addParameter("tempo",100).min(50).max(300);
ControlGenerator transpose = synth.addParameter("transpose", 0).min(-6).max(6);
// ControlMetro generates a "trigger" message at a given bpm. We multiply it by four because we
// want four 16th notes for every beat
ControlGenerator metro = ControlMetro().bpm(4 * bpm);
// ControlStepper increments a value every time it's triggered, and then starts at the beginning again
// Here, we're using it to move forward in the sequence
ControlGenerator step = ControlStepper().end(NUM_STEPS).trigger(metro);
// ControlSwitcher holds a list of ControlGenerators, and routes whichever one the inputIndex is pointing
// to to its output.
ControlSwitcher pitches = ControlSwitcher().inputIndex(step);
ControlSwitcher cutoffs = ControlSwitcher().inputIndex(step);
ControlSwitcher glides = ControlSwitcher().inputIndex(step);
// stick a bunch of random values into the pitch and cutoff lists
for(int i = 0; i < NUM_STEPS; i++){
ControlGenerator pitchForThisStep = synth.addParameter("step" + to_string(i) + "Pitch", randomFloat(10, 80)).min(10).max(80);
pitches.addInput(pitchForThisStep);
ControlGenerator cutoff = synth.addParameter("step" + to_string(i) + "Cutoff", 500).min(30).max(1500);
cutoffs.addInput(cutoff);
ControlGenerator glide = synth.addParameter("step" + to_string(i) + "Glide", 0).min(0).max(0.1);
glides.addInput(glide);
}
// Define a scale according to steps in a 12-note octave. This is a pentatonic scale. Like using
// just the black keys on a piano
vector<float> scale;
scale.push_back(0);
scale.push_back(2);
scale.push_back(3);
scale.push_back(5);
scale.push_back(7);
scale.push_back(10);
// ControlSnapToScale snaps a float value to the nearest scale value, no matter what octave its in
ControlGenerator midiNote = transpose + ControlSnapToScale().setScale(scale).input(pitches);
ControlGenerator frequencyInHertz = ControlMidiToFreq().input(midiNote);
// now that we've done all that, we have a frequency signal that's changing 4x per beat
Generator tone = RectWave().freq( frequencyInHertz.smoothed().length(glides) );
// create an amplitude signal with an ADSR envelope, and scale it down a little so it's not scary loud
Generator amplitude = ADSR(0.01, 0.1, 0,0).trigger(metro) * 0.3;
// create a filter, and feed the cutoff sequence in to it
LPF24 filter = LPF24().cutoff(cutoffs).Q(0.1);
filter.input(tone * amplitude);
// rout the output of the filter to the synth's main output
synth.setOutputGen( filter );
// build a slider for each parameter
vector<ControlParameter> synthParameters = synth.getParameters();
for(int i = 0; i < synthParameters.size(); i++){
sliders.push_back(ParameterSlider(synthParameters.at(i)));
}
auto _devices = soundStream.getDeviceList();
ofSoundStreamSettings _settings;
if (!_devices.empty()) {
_settings.setOutDevice(_devices[1]);
}
_settings.setOutListener(this);
_settings.bufferSize = 512;
_settings.sampleRate = 44100;
_settings.numInputChannels = 0;
_settings.numOutputChannels = 2;
soundStream.setup(_settings);
}
SimdVector3 randomPosition( const SimdPoint3& minPoint, const SimdPoint3& maxPoint )
{
return SimdVector3( randomFloat( minPoint.getX(), maxPoint.getX() ),
randomFloat( minPoint.getY(), maxPoint.getY() ),
randomFloat( minPoint.getZ(), maxPoint.getZ() ) );
}
int main()
{
// seeding random
srand(static_cast<unsigned int>(time(nullptr)));
// creating window
sf::RenderWindow window(sf::VideoMode(1000, 1000), "genlines");
window.setVerticalSyncEnabled(true);
// centering 2D camera
window.setView(sf::View(sf::FloatRect(-500, -500, 1000, 1000)));
// creating manager
EvolutionManager manager(sf::Vector2f(200.0f, -250.0f), sf::Vector2f(-250.0f, -250.0f));
std::vector<Line> lines = manager.getCurrentGeneration();
// creating circle around target point
sf::CircleShape area;
area.setOutlineThickness(1.0f);
area.setOutlineColor(sf::Color::Red);
area.setFillColor(sf::Color::Black);
area.setRadius(50.0f);
area.setPosition(manager.getTarget() - sf::Vector2f(50.0f, 50.0f));
// starting main application looop
while (window.isOpen())
{
sf::Event event;
while (window.pollEvent(event))
{
switch (event.type)
{
case sf::Event::Closed:
window.close();
break;
case sf::Event::KeyPressed:
if (event.key.code == sf::Keyboard::Key::Escape) {
window.close();
}
else if (event.key.code == sf::Keyboard::Key::Space) {
lines = manager.nextGeneration();
}
else if (event.key.code == sf::Keyboard::Key::R) {
manager = EvolutionManager(sf::Vector2f(randomFloat(-400.0f, 400.0f), randomFloat(-400.0f, 400.0f)),
sf::Vector2f(randomFloat(-400.0f, 400.0f), randomFloat(-400.0f, 400.0f)));
lines = manager.getCurrentGeneration();
area.setPosition(manager.getTarget() - sf::Vector2f(50.0f, 50.0f));
}
break;
default:
break;
}
}
window.clear();
// drawing sphere
window.draw(area);
// drawing lines
for (Line& line : lines) {
window.draw(line);
}
window.display();
}
return 0;
}
void KMeans::apply(Window im, int clusters) {
assert(clusters > 1, "must have at least one cluster\n");
vector< vector<float> > cluster, newCluster;
vector<int> newClusterMembers(clusters);
for (int c = 0; c < im.channels; c++) {
cluster.push_back(vector<float>(clusters, 0));
newCluster.push_back(vector<float>(clusters, 0));
}
// initialize the clusters to randomly selected pixels
for (int i = 0; i < clusters; i++) {
float *pixel = im(randomInt(0, im.width-1), randomInt(0, im.height-1), randomInt(0, im.frames-1));
for (int c = 0; c < im.channels; c++) {
cluster[c][i] = pixel[c] + randomFloat(-0.0001f, 0.0001f);
}
}
while (1) {
// wipe the newCluster
for (int i = 0; i < clusters; i++) {
newClusterMembers[i] = 0;
for (int c = 0; c < im.channels; c++) {
newCluster[c][i] = 0;
}
}
for (int t = 0; t < im.frames; t++) {
for (int y = 0; y < im.height; y++) {
for (int x = 0; x < im.width; x++) {
float *pixel = im(x, y, t);
// assign this pixel to a cluster
int bestCluster = 0;
float bestDistance = 1e10;
for (int i = 0; i < clusters; i++) {
float distance = 0;
for (int c = 0; c < im.channels; c++) {
float d = cluster[c][i] - pixel[c];
distance += d*d;
}
if (distance < bestDistance) {
bestCluster = i;
bestDistance = distance;
}
}
for (int c = 0; c < im.channels; c++) {
newCluster[c][bestCluster] += pixel[c];
}
newClusterMembers[bestCluster]++;
}
}
}
// normalize the new clusters (reset any zero ones to random)
for (int i = 0; i < clusters; i++) {
if (newClusterMembers[i] == 0) {
float *pixel = im(randomInt(0, im.width-1),
randomInt(0, im.height-1),
randomInt(0, im.frames-1));
for (int c = 0; c < im.channels; c++) {
newCluster[c][i] = pixel[c] + randomFloat(-0.0001f, 0.0001f);
}
} else {
for (int c = 0; c < im.channels; c++) {
newCluster[c][i] /= newClusterMembers[i];
}
}
}
// break if the clusters are unchanged
if (cluster == newCluster) break;
// swap over the pointers
cluster.swap(newCluster);
}
// now color each pixel according to the closest cluster
for (int t = 0; t < im.frames; t++) {
for (int y = 0; y < im.height; y++) {
for (int x = 0; x < im.width; x++) {
float *pixel = im(x, y, t);
// assign this pixel to a cluster
int bestCluster = 0;
float bestDistance = 1e10;
for (int i = 0; i < clusters; i++) {
float distance = 0;
for (int c = 0; c < im.channels; c++) {
float d = cluster[c][i] - pixel[c];
distance += d*d;
}
if (distance < bestDistance) {
bestCluster = i;
bestDistance = distance;
}
}
for (int c = 0; c < im.channels; c++) {
pixel[c] = cluster[c][bestCluster];
}
}
}
}
}
void mutacao(Individuo* ind){
float mutVal;
//Probabilidade de ataque
if (randomFloat(0,1) < MUT_RATE){
mutVal = randomFloat(-DELTA_PROB, DELTA_PROB);
ind->setProbAtk(ind->getProbAtk() + mutVal);
}
//Velocidade de ataque
if (randomFloat(0, 1) < MUT_RATE) {
mutVal = randomFloat(-DELTA_VEL_ATK, DELTA_VEL_ATK);
ind->setVelAtk(ind->getVelAtk() + mutVal);
}
//Velocidade de esquiva
if (randomFloat(0, 1) < MUT_RATE) {
mutVal = randomFloat(-DELTA_VEL_DEF, DELTA_VEL_DEF);
ind->setVelDef(ind->getVelDef() + mutVal);
}
//Tempo de ataque
if (randomFloat(0, 1) < MUT_RATE) {
mutVal = randomFloat(-DELTA_T_ATK, DELTA_T_ATK);
ind->setTAtk(ind->getTAtk() + mutVal);
}
//Tempo de defesa
if (randomFloat(0, 1) < MUT_RATE) {
mutVal = randomFloat(-DELTA_T_DEF, DELTA_T_DEF);
ind->setTDef(ind->getTDef() + mutVal);
}
//Torque
if (randomFloat(0, 1) < MUT_RATE) {
mutVal = randomFloat(-DELTA_TORQUE, DELTA_TORQUE);
ind->setTorque(ind->getTorque() + mutVal);
}
//Peso
if (randomFloat(0, 1) < MUT_RATE) {
mutVal = randomFloat(-DELTA_WEIGHT, DELTA_WEIGHT);
ind->setWeight(ind->getWeight() + mutVal);
}
}
void Grenade::think(const double elapsedTime)
{
//Run entity think routines.
Entity::think(elapsedTime);
//Check if Grenade lifetime is over.
if(mLifeTimer.getElapsedTime() > ttl)
{
game->getEntityManager()->add(New Explosion(mPosition,3.0f));
setShouldDelete(true);
}
mVelocity.Y -= 0.001;
if(mPosition.Y < -1.f)
{
mVelocity.Y = -mVelocity.Y;
mVelocity.Y *= GRENADE_DAMPING;
//if(abs(mVelocity.Y) > 0.01f)
//game->getSoundEngine()->play3DSound(game->getResourceManager()->get("squishsound"), mPosition, 3.0, randomFloat(0.75,1.25));
if(rotator < 0)
{
rotator += 5;
if(rotator > 0)
{
rotator = 0;
}
}
else if(rotator > 0)
{
rotator -= 5;
if(rotator < 0)
rotator = 0;
}
game->getSoundEngine()->play3DSound(game->getResourceManager()->get("grenade_clink"), mPosition, 0.8f, randomFloat(0.75,1.25));
}
if(game->getCurrentMap()->getTile(int(mPosition.X + mVelocity.X), int(mPosition.Z)).type == TYPE_WALL)
{
mVelocity.X = -mVelocity.X;
mVelocity *= GRENADE_DAMPING;
game->getSoundEngine()->play3DSound(game->getResourceManager()->get("grenade_clink"), mPosition, 0.8f, randomFloat(0.75,1.25));
}
if(game->getCurrentMap()->getTile(int(mPosition.X), int(mPosition.Z + mVelocity.Z)).type == TYPE_WALL)
{
mVelocity.Z = -mVelocity.Z;
mVelocity *= GRENADE_DAMPING;
game->getSoundEngine()->play3DSound(game->getResourceManager()->get("grenade_clink"), mPosition, 0.8f, randomFloat(0.75,1.25));
}
//Add velocity to current position.
mPosition += mVelocity;
mpAnim->setRotation(mpAnim->getRotation() + rotator);
if(mVoice)
mVoice->setPosition(mPosition);
}
int main()
{
//vars
int x = 800;
int y = 600;
int framerate = 60;
const enum modes{BALLS, TRIS, BOXES, ALL};
int mode;
const int balls = 0;
const int triangles = 10;
const int boxes = 10;
BouncingObject* shapes[balls + triangles + boxes];
CollisionDetection col;
//////
sf::ConvexShape box(4);
box.setPointCount(4);
box.setPosition(sf::Vector2f(x - 10, y - 10));
box.setPoint(0, sf::Vector2f(-10, -10));
box.setPoint(1, sf::Vector2f(10, -10));
box.setPoint(2, sf::Vector2f(10, 10));
box.setPoint(3, sf::Vector2f(-10, 10));
box.setFillColor(sf::Color(160, 20, 40, 128));
//////
// Create the main window
sf::RenderWindow window(sf::VideoMode(x, y, 32), "BOUNCING SHAPES");
window.setFramerateLimit(framerate);
srand(time(NULL));
mode = modes::ALL;
int total = 0;
if (mode == modes::BALLS || mode == modes::ALL)
{
int j;
for (j = total; j < total + balls; j++)
{
shapes[j] = new BouncingBall(16, Vector2f(randomFloat(x - 16, 1, false), randomFloat(y - 16, 1, false)), randomColor());
shapes[j]->impulse(Vector2f(randomFloat(8, 1, true), randomFloat(8, 1, true)));
shapes[j]->setRotate(false);
}
total += j;
}
if (mode == modes::TRIS || mode == modes::ALL)
{
int j = total;
for (j; j < total + triangles; j++)
{
//shapes[j] = new BouncingTriangle(32, Vector2f(0,0), randomColor());
//shapes[j] = new BouncingTriangle(32, Vector2f(x / 4 , y / 4), randomColor());
shapes[j] = new BouncingTriangle(16, Vector2f(randomFloat(x - 16, 1, false), randomFloat(y - 16, 1, false)), randomColor());
shapes[j]->impulse(Vector2f(randomFloat(80, 1, true), randomFloat(80, 1, true)));
shapes[j]->spin(randomFloat(8, 1, true));
}
total += j - total;
}
if (mode == modes::BOXES || mode == modes::ALL)
{
int j = total;
for (j; j < total + boxes; j++)
{
shapes[j] = new BouncingRectangle(16, Vector2f(randomFloat(x - 16, 1, false), randomFloat(y - 16, 1, false)), randomColor());
shapes[j]->impulse(Vector2f(randomFloat(8, 1, true), randomFloat(8, 1, true)));
shapes[j]->spin(randomFloat(8, 1, true));
}
total += j - total;
}
// Start game loop
while (window.isOpen())
{
// Process events
sf::Event Event;
while (window.pollEvent(Event))
{
// Close window : exit
if (Event.type == sf::Event::Closed)
window.close();
// Escape key : exit
if ((Event.type == sf::Event::KeyPressed) && (Event.key.code == sf::Keyboard::Escape))
window.close();
if ((Event.type == sf::Event::KeyPressed) && (Event.key.code == sf::Keyboard::Num1))
shapes[0]->setPosition(sf::Vector2f(sf::Mouse().getPosition(window)));
if ((Event.type == sf::Event::KeyPressed) && (Event.key.code == sf::Keyboard::Num2))
shapes[1]->setPosition(sf::Vector2f(sf::Mouse().getPosition(window)));
}
//Declare looping vars
int i, j;
//update items
for (i = 0; i < total; i++)
{
shapes[i]->update(0.05, x, y);
}
//check collisions
for (i = 0; i < total - 1; i++)
{
bool collision = false;
for (j = i + 1; j < total; j++)
{
if (col.CheckBoundingSphere(shapes[i]->getPosition(), shapes[j]->getPosition(), shapes[i]->getRadius(), shapes[j]->getRadius()))
{
if (col.CheckCollisionSAT(*shapes[i], *shapes[j]))
{
shapes[i]->bounceOther(shapes[j]->getPosition());
shapes[j]->bounceOther(shapes[i]->getPosition());
}
}
}
}
//prepare frame
window.clear();
//draw frame items
for (int i = 0; i < total; i++)
{
//shapes[i]->draw(window);
window.draw(shapes[i]->getShape());
//window.setTitle("" + sf::Mouse().getPosition(window).x + ", " + sf::Mouse().getPosition(window).x);
}
// Finally, display rendered frame on screen
window.display();
} //loop back for next frame
return EXIT_SUCCESS;
}
Vector2D Random::RandomUnitVectorHalf() {
float angle = (TWO_PI/6.0f) * randomFloat();
return Vector2D( cos(angle), sin(angle) );
}
void drawObj(GLenum mode) {
vector<Group*> groups = mesh->getGroups();
for (auto g : groups) {
Group *group = g;
if (group->getFaces().size() == 0) {
continue;
}
Material *material = group->getMaterial();
if (material != nullptr) {
if (material->hasTexture()) {
glBindTexture(GL_TEXTURE_2D, textures->getIds()[material->getTexnum()]);
}
}
setLightingForGroup(group);
if (mode == GL_SELECT) {
glLoadName(group->getId());
}
float alpha = group->isVisible() ? 1 : 0.2;
vector<Face*> faces = group->getFaces();
for (auto f : faces) {
if (useRandomColors && (material == nullptr || !material->hasTexture())) {
glColor4f(randomFloat(), randomFloat(), randomFloat(), alpha);
} else {
glColor4f(0.5, 0.5, 0.5, alpha);
}
Face* face = f;
vector<int> verticesIndexes = face->getVertices();
vector<int> normalsIndexes = face->getNormalsIndexes();
vector<int> texturesIndexes = face->getTextureIndexes();
u_long size = verticesIndexes.size();
if (size == 3) {
glBegin(GL_TRIANGLES);
} else if (size == 4) {
glBegin(GL_QUADS);
} else {
glBegin(GL_POLYGON);
}
for (int i = 0; i < verticesIndexes.size(); i++) {
// normal
int normalIndex = normalsIndexes.at(i);
if (normalIndex >= 0) {
Vertex *normal = mesh->getNormals().at(normalIndex - 1); // -1 porque OBJ são 1-indexed
glNormal3f(normal->getX(), normal->getY(), normal->getZ());
}
// texture mapping
int textureIndex = texturesIndexes.at(i);
if (textureIndex >= 0) {
TextureMapping *textureMapping = mesh->getTextureMappings().at(textureIndex - 1); // -1 porque OBJ são 1-indexed
glTexCoord2f(textureMapping->getU(), textureMapping->getV());
}
// vertex
int vertexIndex = verticesIndexes.at(i);
Vertex *vertex = mesh->getVertices().at(vertexIndex - 1); // -1 porque OBJ são 1-indexed
glVertex3d(vertex->getX(), vertex->getY(), vertex->getZ());
}
glEnd();
}
}
}
Vector2D Random::RandomUnitVector() {
float angle = TWO_PI * randomFloat();
return Vector2D( cos(angle), sin(angle) );
}
void SpecialActions::update(SpecialActionsOutput& specialActionsOutput)
{
if(!motionNetData.nodeArray)
{
specialActionsOutput.angles.fill(0);
specialActionsOutput.stiffnessData.stiffnesses.fill(0);
return;
}
float speedFactor = 1.0f;
MODIFY("parameters:SpecialActions:speedFactor", speedFactor);
if(theMotionSelection.specialActionMode != MotionSelection::deactive)
{
specialActionsOutput.isLeavingPossible = true;
if(dataRepetitionCounter <= 0)
{
if(!wasActive)
{
//entered from external motion
currentNode = 0;
for(int i = 0; i < Joints::numOfJoints; ++i)
lastRequest.angles[i] = theJointAngles.angles[i];
lastSpecialAction = SpecialActionRequest::numOfSpecialActionIDs;
}
// this is need when a special actions gets executed directly after another without
// switching to a different motion for interpolating the stiffness
if(wasEndOfSpecialAction)
{
specialActionsOutput.stiffnessData.resetToDefault();
if(!mirror)
lastStiffnessRequest = currentStiffnessRequest;
else
lastStiffnessRequest.mirror(currentStiffnessRequest);
currentStiffnessRequest.resetToDefault();
}
wasEndOfSpecialAction = false;
// search next data, leave on transition to external motion
if(!getNextData(theMotionSelection.specialActionRequest, specialActionsOutput))
{
wasActive = true;
wasEndOfSpecialAction = true;
specialActionsOutput.odometryOffset = Pose2f();
return;
}
}
else
{
dataRepetitionCounter -= int(theFrameInfo.cycleTime * 1000 * speedFactor);
stiffnessInterpolationCounter -= int(theFrameInfo.cycleTime * 1000 * speedFactor);
}
//set current joint values
calculateJointRequest(specialActionsOutput);
//odometry update
if(currentInfo.type == SpecialActionInfo::homogeneous || currentInfo.type == SpecialActionInfo::once)
if(mirror)
specialActionsOutput.odometryOffset = Pose2f(-currentInfo.odometryOffset.rotation, currentInfo.odometryOffset.translation.x(), -currentInfo.odometryOffset.translation.y());
else
specialActionsOutput.odometryOffset = currentInfo.odometryOffset;
else
specialActionsOutput.odometryOffset = Pose2f();
if(currentInfo.type == SpecialActionInfo::once)
currentInfo.type = SpecialActionInfo::none;
//store value if current data line finished
if(dataRepetitionCounter <= 0)
{
if(!mirror)
lastRequest = currentRequest;
else
lastRequest.mirror(currentRequest);
}
specialActionsOutput.isLeavingPossible = false;
if(deShakeMode)
for(int i = Joints::lShoulderPitch; i <= Joints::rElbowRoll; ++i)
if(randomFloat() < 0.25)
specialActionsOutput.angles[i] = JointAngles::off;
}
wasActive = theMotionSelection.specialActionMode != MotionSelection::deactive;
}
void CBotGAValues :: addRnd()
{
m_theValues.push_back(randomFloat(0,1));
}
float randomFloatMax(float max) {
return max * randomFloat();
};
