void CSE_ALifeMonsterAbstract::vfCheckForPopulationChanges ()
{
CSE_ALifeGroupAbstract *l_tpALifeGroupAbstract = smart_cast<CSE_ALifeGroupAbstract*>(this);
if (!l_tpALifeGroupAbstract || !bfActive() || m_bOnline)
return;
ai().ef_storage().alife_evaluation(true);
ALife::_TIME_ID l_tTimeID = ai().alife().time_manager().game_time();
if (l_tTimeID >= l_tpALifeGroupAbstract->m_tNextBirthTime) {
ai().ef_storage().alife().member() = this;
l_tpALifeGroupAbstract->m_tNextBirthTime = l_tTimeID + ALife::_TIME_ID(ai().ef_storage().m_pfBirthSpeed->ffGetValue()*24*60*60*1000);
if (randF(100) < ai().ef_storage().m_pfBirthProbability->ffGetValue()) {
u32 l_dwBornCount = iFloor(float(l_tpALifeGroupAbstract->m_wCount)*randF(.5f,1.5f)*ai().ef_storage().m_pfBirthPercentage->ffGetValue()/100.f + .5f);
if (l_dwBornCount) {
l_tpALifeGroupAbstract->m_tpMembers.resize(l_tpALifeGroupAbstract->m_wCount + l_dwBornCount);
ALife::OBJECT_IT I = l_tpALifeGroupAbstract->m_tpMembers.begin() + l_tpALifeGroupAbstract->m_wCount;
ALife::OBJECT_IT E = l_tpALifeGroupAbstract->m_tpMembers.end();
for ( ; I != E; ++I) {
CSE_Abstract *l_tpAbstract = alife().create (l_tpALifeGroupAbstract,this);
*I = l_tpAbstract->ID;
}
l_tpALifeGroupAbstract->m_wCount = l_tpALifeGroupAbstract->m_wCount + u16(l_dwBornCount);
}
}
}
}
void WaterLandscapeDemoScene::GenerateRandomWave()
{
unsigned int i = 5 + rand() % 250;
unsigned int j = 5 + rand() % 250;
float r = randF(1.0f, 2.0f);
mWaterMesh->Perturb(i, j, r);
}
void RandomTest::randomListTest()
{
float minF = 10.f, maxF = 20.f;
std::vector<float> randF(10);
::fwTools::random::fillContainer(minF, maxF, randF);
for(size_t i = 0; i < randF.size(); ++i)
{
CPPUNIT_ASSERT_MESSAGE("Generate random number not in good interval.", randF[i] >= minF && randF[i] <= maxF);
}
int minI = 10, maxI = 20;
std::vector<int> randI(10);
::fwTools::random::fillContainer(minI, maxI, randI);
for(size_t i = 0; i < randF.size(); ++i)
{
CPPUNIT_ASSERT_MESSAGE("Generate random number not in good interval.", randI[i] >= minI && randI[i] <= maxI);
}
}
int main(int argc, char **argv) {
if(argc < MIN_ARGS || argc > MAX_ARGS) {
std::cout<<"Usage:\n./master nBuffers nWorkers "
<<"sleepMin sleepMax [random seed] [-lock or -nolock]"
<<std::endl;
return -1; //Too many or too few command line arguments
}
int nBuffers;
int nWorkers;
float sleepMin;
float sleepMax;
int randSeed;
bool lock = false;
int semID;
int thing1[2]; // pipe 1 file descriptor
int thing2[2]; // pipe 2 file descriptor
pid_t pid; //pid for forked sort process
float random; // random float value, Ahhh!
char buffer[80]; // buffer for write/read
/*******************Variable Initialization*******************/
nBuffers = atoi(argv[1]);
nWorkers = atoi(argv[2]);
sleepMin = atof(argv[3]);
sleepMax = atof(argv[4]);
float arr2[nWorkers]; // holder of rand ID's in sorted order
if(argc >= 5)
randSeed = atoi(argv[5]);
else
randSeed = -1;
if(argc == 7)
if(strcmp(argv[6],"-lock") == 0) {
lock = true;
//std::cout<<"\nLocked"<<std::endl;
}
else if(strcmp(argv[6],"-nolock") == 0) {
lock = false;
//std::cout<<"\nUnlocked"<<std::endl;
}
else {
lock = false;
//std::cout<<"\nDefault: Unlocked"<<std::endl;
}
/*******************Variable Initialization*******************/
if(nBuffers < 0 || sleepMin < 0 || sleepMax < 0
|| sleepMin > sleepMax || nBuffers > 32
|| nWorkers > nBuffers) //Data check
return -1;
for(int i = 1; i < 10; i++) {
if((i > 1) && (i != nBuffers) && (nBuffers % i == 0))
return -1; //nBuffers is not a positive prime < 32
}
/********Sanity Check**********
std::cout<<"\nBuffers: "<<nBuffers<<std::endl;
std::cout<<"Workers: "<<nWorkers<<std::endl;
std::cout<<"SleepMin: "<<sleepMin<<std::endl;
std::cout<<"SleepMax: "<<sleepMax<<std::endl;
std::cout<<"Rand Seed: "<<randSeed<<std::endl;
std::cout<<"Locked: "<<lock<<std::endl;
*******************************/
//say hello
std::cout<<"\nShane Lopez, slopez23"
<<"\n\nIPC\n\nSimulating with "<<nBuffers<<" Buffers and "
<<nWorkers<<" Workers"<<std::endl;
if(lock)
std::cout<<"\n<Semaphores Engaged>"<<std::endl;
else
std::cout<<"\n<Semaphores Not Engaged>"<<std::endl;
std::cout<<"-----------------------------------------------"<<std::endl;
if(pipe(thing1) < 0 || pipe(thing2) < 0) { // Create Pipes
std::cerr << "Piping Error" << std::endl;
return -1;
}
if((pid = fork()) < 0) { // Fork
std::cerr << "Forking Error" << std::endl;
return -1;
}
else if(pid == 0) { // Child
close(thing1[WRITE]); // close unused pipe ends
close(thing2[READ]);
dup2(thing1[READ],READ); // dup2 appropriate ends
dup2(thing2[WRITE],WRITE);
execlp("sort","sort","-nr",NULL); // execute sort
}
else { // Parent
close(thing1[READ]); // close unused pipe ends
close(thing2[WRITE]);
for(int j = 0; j < nWorkers; j++) {
random = randF(sleepMin,sleepMax,randSeed);
//std::cout<<"Random "<< j <<": "<<random<<std::endl;
if(j == 0)
sprintf(buffer,"%f\n",random);
else
sprintf((buffer+strlen(buffer)),"%f\n",random);
}//Fills Buffer
write(thing1[WRITE],buffer,strlen(buffer));
/*std::cout<<"\nRandom Floats: \n";//<<buffer<<std::endl;
for(int h = 0; h < strlen("Random Floats: "); h++)
std::cout<<"-"; // Fancy
std::cout<<std::endl; // Take it down a notch
std::cout<<buffer<<std::endl;*/
close(thing1[WRITE]); // Close pipe end after use
read(thing2[READ],buffer,strlen(buffer));
close(thing2[READ]); // Close pipe end after use
char *p;
p = strtok(buffer,"\n"); // tok'n on that str
//std::cout<<p<<std::endl; // debuggery
/*std::cout<<"\n{Sorted} Random Floats: \n";
for(int h = 0; h < strlen("{Sorted} Random Floats: "); h++)
std::cout<<"-"; // Fancy
std::cout<<std::endl;*/
for(int j = 0; j < nWorkers; j++) { //prints and fills array
arr2[j] = atof(p);
p = strtok(NULL,"\n");
//std::cout<</*std::setprecision(4)<<*/arr2[j]<<std::endl;
}
//std::cout<<"\n"<<std::endl;
}
/**************************Begin Msg Q*****************************/
int msgQID;
msg sendMsg;
msg recMsg;
if((msgQID = msgget(IPC_PRIVATE,IPC_CREAT | 0600)) <= 0) {//Create msg Q
perror("msgget");
exit(-1);
}
/**************************Fork Exec*******************************/
pid_t IDs[nWorkers];
struct rusage sys_res;
//struct msqid_ds MSG;
//struct shmid_ds SHM;
int shmID;
shmID = shmget(IPC_PRIVATE,sizeof(int)*nBuffers,0600 | IPC_CREAT);
int *shm_ptr = (int*)shmat(shmID,NULL,0);
//create shm
for(int p = 0; p < nBuffers; p++) {
shm_ptr[p] = 0;
}
shmdt(shm_ptr);
if(lock) {//create semaphores
semID = semget(IPC_PRIVATE,nBuffers,IPC_CREAT|0600);
if(semID < 0) {
perror("semget");
exit(-1);
}
union semun s_val;
s_val.val = 1;
for(int t = 0; t < nBuffers; t++) {
if(semctl(semID,t,SETVAL,s_val) < 0) {
perror("semctl");
exit(-1);
}
}
}
//generate pids for each worker
for(int i = 0; i < nWorkers; i++) {
pid_t pid = fork();
IDs[i] = pid;
if(pid < 0) {
perror("fork");
exit(-1);
}
else if(pid == 0) { // execute worker
char a[10];
char b[10];
char c[10];
char d[10];
char e[10];
//pass arguments as char buffers
sprintf(a,"%d\n",(i+1));
sprintf(b,"%d\n",nBuffers);
sprintf(c,"%f\n",(arr2[i]));
sprintf(d,"%d\n",msgQID);
sprintf(e,"%d\n",shmID);
if(lock) {
char f[10];
sprintf(f,"%d\n",semID);
execlp("./worker","worker",a,b,c,d,e,f,NULL);
}
else
execlp("./worker","worker",a,b,c,d,e,NULL);
}
}
//implicitly in parent
int children = nWorkers;
int r_err = 0;
int w_err = 0;
int g = 0;
int SZ = (sizeof(struct msg) - sizeof(long int));
msg* recm = (msg*)malloc(sizeof(msg));
////////////////////
while(children > 0) {
if(msgrcv(msgQID,recm,30,-4,0) < 0) {//catch messages from Q
perror("msgrcv");
if(lock)
if(semctl(semID,0,IPC_RMID)) {
perror("semctl");
exit(-1);
}
if(shmctl(shmID,IPC_RMID,0) < 0) {
perror("shmctl");
exit(-1);
}
exit(-1);
}
//std::cout<<recm->id<<std::endl;
switch(recm->type) { //detect message type and act
/*case 4: std::cout<<"\n[Master]--Worker "<<recm->id
<<" reported Write error in buffer "
<<recm->bufC<<"- before sleep: "
<<recm->before<<" after sleep: "
<<recm->after<<std::endl;
//w_err++;
break;*/
case 3: std::cout<<"\n[Master]--{Worker "<<recm->id
<<"} reported Read error in buffer "
<<recm->bufC<<"- before sleep: "
<<recm->before<<" after sleep: "
<<recm->after<<std::endl;
r_err++;
//wait4(IDs[((recm->id)-1)],NULL,0,&sys_res);
break;
case 2: std::cout<<"\n[Master]--{Worker "<<recm->id
<<"} says bye!"<<std::endl;
wait4(IDs[((recm->id)-1)],NULL,0,&sys_res);
children--;
break;
case 1: std::cout<<"\n[Master]--{Worker "<<recm->id
<<"} says hello!"<<std::endl;
std::cout<<"Sleep time for worker "<<recm->id
<<": "<<recm->stime<<std::endl;
break;
default: std::cout<<"\n[Master]--<Unspecified msg type>"
<<std::endl;
break;
}
}
std::cout<<"\n"<<std::endl;
shm_ptr = (int*)shmat(shmID,NULL,0);
int desired = (int)(pow(2,nWorkers)-1);
//int w_err = 0;
//report buffer contents
std::cout<<"\n[Master]--<Reporting Buffer Contents>\n"<<std::endl;
for(int p = 0; p < nBuffers; p++) {
if(p > 9)
std::cout<<"Buffer "<<p<<": "<<shm_ptr[p]<<std::endl;
else
std::cout<<"Buffer "<<p<<": "<<shm_ptr[p]<<std::endl;
if(shm_ptr[p] != desired)
w_err++;
}
std::cout<<std::endl;
int *badB = new int[w_err];
int counter = 0;
//save indices of bad buffers
for(int p = 0; p < nBuffers; p++) {
if(shm_ptr[p] != desired) {
badB[counter] = p;
counter++;
if(counter == w_err)
break;
}
}
int examine;
int sieve;
int b;
int *b_bits = new int[32];
int c = 0;
int f = 0;
int werr = 0;
for(int r = 0; r < 32; r++) {
b_bits[r] = -1;
}
//Report errors
for(int g = 0; g < w_err; g++) {
b = badB[g];
examine = shm_ptr[b];
/////////////////////////////////////////////////////
if((badB[g]) > 9)
std::cout<<"\tError in buffer "<<b<<": "<<examine<<" != "
<<desired<<std::endl;
else
std::cout<<"\tError in buffer "<<b<<": "<<examine<<" != "
<<desired<<std::endl;
/////////////////////////////////////////////////////
//Examine bits
sieve = (examine ^ desired);//sift the bad bits
for(int v = 0; v < 32; v++) {
if((sieve & (1 << v)) >= 1) {
b_bits[c] = v;
c++;
}
}
//w_err += c;
//werr+=c;
std::cout<<"\t\tBad Bits: ";
while(f < c) {
if(f < (c-1))
std::cout<<"bit "<<b_bits[f]<<", ";
else
std::cout<<"bit "<<b_bits[f]<<" ";
werr++;
f++;
}
std::cout<<"\n"<<std::endl;
}
std::cout<<"\n"<<r_err<<" Read Errors "<<werr
<<" Write Errors"<<std::endl;
shmdt(shm_ptr);
if(lock)//remove sems
if(semctl(semID,0,IPC_RMID)) {
perror("semctl");
exit(-1);
}
if(shmctl(shmID,IPC_RMID,0) < 0) {//remove shared memory
perror("shmctl");
exit(-1);
}
if(msgctl(msgQID,IPC_RMID,0) < 0) { //close message Q
perror("msgctl");
exit(-1);
}
std::cout<<"-----------------------------------------------"<<std::endl;
exit(0);//all done!
}
void Emitter::update(float duration) {
if (!alive) {
return;
}
pos = pos + speed * duration;
while (!particles.empty() && particles.front()->life <= 0) {
pPool->recycle(particles.front());
particles.pop_front();
}
for (Particle*& it : particles) {
it->colorIndex = (1 - it->life / plife) * 256;
if (it->colorIndex < 0) {
it->colorIndex = 0;
} else if (it->colorIndex >= colorIndexLength) {
it->colorIndex = colorIndexLength - 1;
}
it->pos = it->pos + it->dir * duration;
it->pos.x += randF() * it->randLevel * duration;
it->pos.y += randF() * it->randLevel * duration;
it->pos.z += randF() * it->randLevel * duration;
if (forceType & Lorentz) {
Vector v = it->dir * mag;
it->pos = it->pos + v;
}
if (forceType & Gravity) {
it->dir = it->dir + force * duration;
}
if (forceType & Center) {
Vector t = center - it->pos;
t.unit();
it->dir = it->dir + t * centripetal * duration;
} else if (forceType & Z_Axle) {
float l = sqrt(it->pos.x * it->pos.x + it->pos.y * it->pos.y);
Vector t = {0, 0, 0};
if (l > 0) {
t.x = it->pos.x / l;
t.y = it->pos.y / l;
}
it->dir = it->dir + t * centripetal * duration;
}
it->life -= duration;
}
if (life > 0) {
for (int i = 0; i < emitsPerFrame; i++) {
float _yaw, _pitch, _speed;
// Vector _speed = {0, 0, 0};
Vector _particleSpeed = Vector::RotationToDirection(yaw + yawVar * randF(), pitch + pitchVar * randF()) * particleSpeed ;
Particle* p = pPool->getParticle();
p->init(pos, 4, _particleSpeed , plife + plifeVar * randF());
particles.push_back(p);
}
life -= duration;
} else {
if (particles.empty()) {
alive = false;
}
}
if (g2e||forceType & Gravity) {
speed = speed + force * duration;
}
}
void CSE_ALifeAnomalousZone::spawn_artefacts ()
{
VERIFY2 (!m_bOnline,"Cannot spawn artefacts in online!");
float m_min_start_power = pSettings->r_float(name(),"min_start_power");
float m_max_start_power = pSettings->r_float(name(),"max_start_power");
u32 m_min_artefact_count= pSettings->r_u32 (name(),"min_artefact_count");;
u32 m_max_artefact_count= pSettings->r_u32 (name(),"max_artefact_count");;
u32 m_artefact_count;
if (m_min_artefact_count == m_max_artefact_count)
m_artefact_count = m_min_artefact_count;
else
m_artefact_count = randI(m_min_artefact_count,m_max_artefact_count);
if (m_min_start_power == m_max_start_power)
m_maxPower = m_min_start_power;
else
m_maxPower = randF(m_min_start_power,m_max_start_power);
LPCSTR artefacts = pSettings->r_string(name(),"artefacts");
u32 n = _GetItemCount(artefacts);
VERIFY2 (!(n % 2),"Invalid parameters count in line artefacts for anomalous zone");
n >>= 1;
typedef std::pair<shared_str,float> ARTEFACT_PAIR;
string256 temp0, temp1;
ARTEFACT_PAIR *m_weights = (ARTEFACT_PAIR*)_alloca(n*sizeof(ARTEFACT_PAIR));
ARTEFACT_PAIR *I = m_weights;
ARTEFACT_PAIR *E = m_weights + n;
for (u32 i = 0; I != E; ++I, ++i) {
_GetItem (artefacts,2*i,temp0);
_GetItem (artefacts,2*i + 1,temp1);
new (I) ARTEFACT_PAIR(temp0,(float)atof(temp1));
}
for (u32 ii=0; ii<m_artefact_count; ++ii) {
float fProbability = randF(1.f);
float fSum = 0.f;
for (u16 p=0; p<n; ++p) {
fSum += m_weights[p].second;
if (fSum > fProbability)
break;
}
if (p < n) {
CSE_Abstract *l_tpSE_Abstract = alife().spawn_item(*m_weights[p].first,position(),m_tNodeID,m_tGraphID,0xffff);
R_ASSERT3 (l_tpSE_Abstract,"Can't spawn artefact ",*m_weights[p].first);
CSE_ALifeDynamicObject *i = smart_cast<CSE_ALifeDynamicObject*>(l_tpSE_Abstract);
R_ASSERT2 (i,"Non-ALife object in the 'game.spawn'");
i->m_tSpawnID = m_tSpawnID;
i->m_bALifeControl = true;
ai().alife().spawns().assign_artefact_position(this,i);
Fvector t = i->o_Position ;
u32 p = i->m_tNodeID ;
float q = i->m_fDistance ;
alife().graph().change(i,m_tGraphID,i->m_tGraphID);
i->o_Position = t;
i->m_tNodeID = p;
i->m_fDistance = q;
CSE_ALifeItemArtefact *l_tpALifeItemArtefact = smart_cast<CSE_ALifeItemArtefact*>(i);
R_ASSERT2 (l_tpALifeItemArtefact,"Anomalous zone can't generate non-artefact objects since they don't have an 'anomaly property'!");
l_tpALifeItemArtefact->m_fAnomalyValue = m_maxPower*(1.f - i->o_Position.distance_to(o_Position)/m_offline_interactive_radius);
}
}
for (I = m_weights; I != E; ++I)
I->~ARTEFACT_PAIR ();
}
