int main(void) {
init_timer();
init_io();
USART_Init();
sei();
fill_cube(0xFF);
_delay_us(1500000);
int mode = (PIND & (1<<PD3));
if (mode) {
while (1) {
random_filler(1);
random_filler(0);
loadbar();
rain(100);
send_voxels_rand_z(200);
set_edges();
_delay_us(5000000);
}
} else {
int escape = 0;
int counter = 0;
while (1) {
uint8_t byte;
byte = USART_Receive();
if (!escape) {
if (byte == 0xAB) { // escape character
escape = 1;
} else if (counter < 64) {
tab[counter/8][counter%8] = byte;
counter++;
}
} else {
if (byte == 0xCD) { // start character
counter = 0;
} else if (byte == 0xAB && counter < 64) {
tab[counter/8][counter%8] = byte;
counter++;
}
escape = 0;
}
}
}
return 0;
}
////////////////////////////////////////////////////////////////////////////////
// Checks the LED state variable and performs current led pattern
// 0 Off, 1 Rain; 2 Light Rain, 3 Forgotten
void LED::continueState(){
// If the led state has changed turn off all
// lights prior to lighting the new pattern
if(ledState != lastState){
// changedLocation();
allOff();
}
switch (ledState){
//
case 0:
allOff();
break;
case 1:
lightRain();
break;
case 2:
rain();
break;
case 3:
heavyRain(); //Change to Heavy rain, will need to create that function
break;
case 4:
forgotten();
break;
}
// Save the last state of the led
lastState = ledState;
}
/* main function */
int main(int argc, char *argv[])
{
fb_info fb_inf;
/* initialize device fb */
if (init_fb(&fb_inf) < 0)
{
printf("Error init_fb\n");
exit(1);
}
rain("loading.jpg", fb_inf);
return 0;
}
void Effects::drawEffects()
{
if(raining)
rain();
}
static void storm()
{
rain();
game.weatherThinkTime--;
}
/* Launches one of those fancy effects. */
void launch_effect(int effect)
{
switch (effect) {
case 0:
/* Lights all the layers one by one. */
load_bar(1000);
break;
case 1:
/* A pixel bouncing randomly around. */
boing_boing(150, 500, 0x03, 0x01);
break;
case 2:
/* Randomly fill and empty the cube. */
fill(0x00);
random_filler(100, 1, 500, 1);
random_filler(100, 1, 500, 0);
break;
case 3:
/* Send voxels randomly back and forth the z-axis. */
send_voxels_rand_z(150, 500, 2000);
break;
case 4:
/* Spinning spiral */
spiral(1, 75, 1000);
break;
case 5:
/* A coordinate bounces randomly around the cube. For every position
* the status of that voxel is toggled. */
boing_boing(150, 500, 0x03, 0x02);
break;
case 6:
/* Random raindrops */
rain(40, 1000, 500, 500);
break;
case 7:
/* Snake: a snake randomly bounce around the cube. */
boing_boing(150, 500, 0x03, 0x03);
break;
case 8:
/* Spinning plane */
spinning_plane(1, 50, 1000);
break;
case 9:
/* Set x number of random voxels, delay, unset them. x increases
* from 1 to 32 and back to 1. */
random_2(48);
break;
case 10:
/* Set then unset all 64 voxels in a random order. */
random_filler2(200, 1);
delay_ms(2000);
random_filler2(200, 0);
delay_ms(1000);
break;
case 11:
/* Bounce a plane up and down all the directions. */
fly_plane('z', 1, 1000);
delay_ms(2000);
fly_plane('y', 1, 1000);
delay_ms(2000);
fly_plane('x', 1, 1000);
delay_ms(2000);
fly_plane('z', 0, 1000);
delay_ms(2000);
fly_plane('y', 0, 1000);
delay_ms(2000);
fly_plane('x', 0, 1000);
delay_ms(2000);
break;
case 12:
/* Fade in and out at low framerate. */
blinky2();
break;
case 13:
/* Random walk */
random_walk(4, 250, 1000);
break;
case 14:
/* Spinning square */
spinning_square(1, 50, 1000);
break;
}
}
int qml_interface::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QMainWindow::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
switch (_id) {
case 0:
itFogz();
break;
case 1:
destroyAll();
break;
case 2:
fair();
break;
case 3:
pCloudy();
break;
case 4:
cloudy();
break;
case 5:
rain();
break;
case 6:
thunder();
break;
case 7:
snow();
break;
case 8:
updateSlot();
break;
case 9:
replyFinished((*reinterpret_cast< QNetworkReply*(*)>(_a[1])));
break;
case 10: {
QString _r = getWindSpeed();
if (_a[0]) *reinterpret_cast< QString*>(_a[0]) = _r;
}
break;
case 11: {
QString _r = getWindDirection();
if (_a[0]) *reinterpret_cast< QString*>(_a[0]) = _r;
}
break;
case 12: {
QString _r = getTemperature();
if (_a[0]) *reinterpret_cast< QString*>(_a[0]) = _r;
}
break;
case 13: {
QString _r = getTime();
if (_a[0]) *reinterpret_cast< QString*>(_a[0]) = _r;
}
break;
case 14: {
QString _r = depsurx();
if (_a[0]) *reinterpret_cast< QString*>(_a[0]) = _r;
}
break;
case 15: {
QString _r = arvsurx();
if (_a[0]) *reinterpret_cast< QString*>(_a[0]) = _r;
}
break;
case 16: {
QString _r = depsury();
if (_a[0]) *reinterpret_cast< QString*>(_a[0]) = _r;
}
break;
case 17: {
QString _r = arvsury();
if (_a[0]) *reinterpret_cast< QString*>(_a[0]) = _r;
}
break;
case 18: {
QString _r = depsurz();
if (_a[0]) *reinterpret_cast< QString*>(_a[0]) = _r;
}
break;
case 19: {
QString _r = arvsurz();
if (_a[0]) *reinterpret_cast< QString*>(_a[0]) = _r;
}
break;
case 20: {
QString _r = getNextUpdate();
if (_a[0]) *reinterpret_cast< QString*>(_a[0]) = _r;
}
break;
case 21: {
QString _r = getFrequence();
if (_a[0]) *reinterpret_cast< QString*>(_a[0]) = _r;
}
break;
case 22: {
QString _r = getSymbol();
if (_a[0]) *reinterpret_cast< QString*>(_a[0]) = _r;
}
break;
case 23:
ItFogs();
break;
case 24: {
int _r = getPositionCiel();
if (_a[0]) *reinterpret_cast< int*>(_a[0]) = _r;
}
break;
case 25:
setSymbol();
break;
case 26: {
QString _r = getRandomInteger();
if (_a[0]) *reinterpret_cast< QString*>(_a[0]) = _r;
}
break;
default:
;
}
_id -= 27;
}
#ifndef QT_NO_PROPERTIES
else if (_c == QMetaObject::ReadProperty) {
void *_v = _a[0];
switch (_id) {
case 0:
*reinterpret_cast< Forecast*>(_v) = getCurrentForecast();
break;
}
_id -= 1;
} else if (_c == QMetaObject::WriteProperty) {
_id -= 1;
} else if (_c == QMetaObject::ResetProperty) {
_id -= 1;
} else if (_c == QMetaObject::QueryPropertyDesignable) {
_id -= 1;
} else if (_c == QMetaObject::QueryPropertyScriptable) {
_id -= 1;
} else if (_c == QMetaObject::QueryPropertyStored) {
_id -= 1;
} else if (_c == QMetaObject::QueryPropertyEditable) {
_id -= 1;
} else if (_c == QMetaObject::QueryPropertyUser) {
_id -= 1;
}
#endif // QT_NO_PROPERTIES
return _id;
}
int main (int argc, char *argv[] )
{
//this section populates the database
const char * cmds[2]; // pointer for xfer of command
char tmp[50] ; //working array variable
char tmp1[10][50][2][15]; // array that holds database
const char * rtrn; // separate return from send
int i; //ctr to parse string
int j ; //ctr to build commands
int k ; //first array index --device
int l; //2nd array index -- command number
int m; //3rd array index -- command name or command
int x1; //value of user input
int dsp1 = 0; //used to index a display of commands
int dsp2 = 0; // need a secondary index
int x2; // format command display
i =j =k =l =m =0;
char * z;
// filename to open
FILE *file = fopen( "datafile1.csv", "r" );
/* fopen returns 0, the NULL pointer, on failure */
if ( file == 0 )
{
printf( "Could not open file\n" );
}
else
{
/* read line and store it in the array . */
while ( ( z = fgets( tmp,100,file ) ) != 0 )
{
for (i = 0; i < strlen(tmp); i++) //work thru each line
{
if (tmp[0] == ':' ) // rezero array nums for each device
{
l=m=0;
printf("new device \n");
}
if (tmp[i] != ',' && tmp[i] != '\n')//read thru each piece of data
{
tmp1[k][l][m][j] = tmp[i];
j++;
}
if (tmp[i] == ',' || tmp[i] =='\n')//complete new array element
{
cmds[m] =tmp1[k][l][m] ;
printf("command %s %i %i %i \n", cmds[m],k,l,m);
m++;//this indexes the 2 elements from one input (csv)
j=0;
}
}
if (tmp[0] == ':')//change device index
k++;
//final processing for while loop
l++; //next command number
m=0; //reset index
}
fclose( file );
}
//get user imput via rdme and use snd1 to send the commands to the ard
while((x1=rdme())!= 55) //55 is the magic quit
{
if (x1 > 100) //device type
k= x1-100;
//display code should list device and commands in 4 column display
//iterates thru 2 for loops to get the info in the right place
for (dsp1 = 1;dsp1 <41; dsp1 +=4) //this is the master counter
{
for(dsp2 =0;dsp2 <4;dsp2++) //this counts the items in each row
{
// adjusts for 1 and 2 digit items and long command names
if((dsp1+dsp2) >9) x2 = 6;
if(strlen(tmp1[k][dsp1+dsp2][0])<x2)
printf("%i %s\t\t",(dsp1+dsp2),tmp1[k][dsp1+dsp2][0]);
else
printf("%i %s\t",(dsp1+dsp2),tmp1[k][dsp1+dsp2][0]);
}
printf("\n\n");
}
if (x1 <50) //command #
{
l = x1;
//printf("numbers %i %i %i \n", k,l,m);
cmds[0] = tmp1[k][l][0];
cmds[1] = tmp1[k][l][1];
printf("return %s\n",rain(cmds[1],rtrn)); //only sends hex
}
}
}
void WeatherManager::HandleWeatherEvent(psWeatherGameEvent* event)
{
{
CS::Threading::MutexScopedLock lock(eventsMutex);
events.Delete(event); // Delete this from our "db"
}
// See if we want to ignore this event
for(size_t i = 0; i < ignored.GetSize(); i++)
{
if(event == ignored[i])
{
ignored.DeleteIndex(i);
return;
}
}
switch(event->type)
{
case psWeatherMessage::SNOW:
case psWeatherMessage::RAIN:
{
event->si->current_rain_drops = event->value;
Notify4(LOG_WEATHER,"New %s in sector '%s': %d",event->type == psWeatherMessage::SNOW ? "snow" : "rain", event->si->name.GetData(),event->value);
psWeatherMessage::NetWeatherInfo info;
info.has_downfall = true;
info.downfall_is_snow = (event->type == psWeatherMessage::SNOW);
info.has_fog = true;
info.has_lightning = false;
info.downfall_drops = event->value;
// Save current fog and calculate new.
if(event->value)
{
// Only save the fog 'history' once. After that we just override.
if(!event->si->densitySaved)
{
event->si->fog_density_old = event->si->fog_density;
event->si->densitySaved = true;
}
// Set fog colour if there's not already fog.
if(!event->si->fog_density)
{
event->si->r = 255;
event->si->g = 255;
event->si->b = 255;
}
if(info.downfall_drops < 8000)
{
// Calculate fog to be linear in range 0 to 200
event->si->fog_density =
(int)(200.0f*(info.downfall_drops-1000.0f)/8000.0f);
}
else
{
event->si->fog_density = 200;
}
}
else if(event->si->fog_density)
{
// Restore fog, if the fog wasn't turned off.
event->si->fog_density = event->si->fog_density_old;
event->si->densitySaved = false;
}
info.fog_density = event->si->fog_density;
info.r = event->si->r;
info.g = event->si->g;
info.b = event->si->b;
info.sector = event->sector;
if(event->fade)
{
info.downfall_fade = event->fade;
info.fog_fade = event->fade;
}
else
{
if(event->value)
{
info.downfall_fade = event->si->GetRandomWeatherFadeIn((unsigned int)event->type);
info.fog_fade = info.downfall_fade;
}
else
{
info.downfall_fade = event->si->GetRandomWeatherFadeOut((unsigned int)event->type);
info.fog_fade = info.downfall_fade;
}
}
Notify4(LOG_WEATHER,"Drops: %d Density: %d Sector: %s\n",
info.downfall_drops,info.fog_density,info.sector.GetDataSafe());
psWeatherMessage rain(0,info);
if(rain.valid)
psserver->GetEventManager()->Broadcast(rain.msg,NetBase::BC_EVERYONE);
else
{
Bug1("Could not create valid psWeatherMessage (rain) for broadcast.\n");
}
// Make sure we don't have any other events in this sector that will disturb
// Simple case is when event types are equal. In addition we have to test
// for the mutal exclusive case where we are changing from snow to rain or
// rain to snow.
{
CS::Threading::MutexScopedLock lock(eventsMutex);
for(size_t i = 0; i < events.GetSize(); i++)
{
psWeatherGameEvent* evt = events[i];
if(evt->sector == event->sector && (evt->type == event->type
|| ((evt->type == psWeatherMessage::RAIN || evt->type
== psWeatherMessage::SNOW) && (event->type
== psWeatherMessage::RAIN || event->type
== psWeatherMessage::SNOW))))
{
ignored.Push(evt); // Ignore when the eventmanager handles the event
events.DeleteIndex(i);
i--;
Notify4(LOG_WEATHER,"Removed disturbing event for sector '%s' (%d,%d)",
evt->sector.GetData(),evt->value,evt->duration);
}
}
}
if(event->value) // Queue event to turn off rain/snow.
{
if(event->type != psWeatherMessage::SNOW)
event->si->is_raining = true;
else
event->si->is_snowing = true;
if(event->si->GetWeatherEnabled((unsigned int) psWeatherMessage::LIGHTNING) &&
event->value > 2000 && event->si->is_raining)
{
// Queue lightning during rain storm here first
QueueNextEvent(event->si->GetRandomWeatherGap((unsigned int) psWeatherMessage::LIGHTNING),
psWeatherMessage::LIGHTNING,
0,
0,
0,
event->si->name,
event->si,
event->clientnum);
}
// Queue event to stop rain/snow
int duration;
if(event->duration != -1)
{
if(event->duration)
{
duration = event->duration;
}
else
{
duration = event->si->GetRandomWeatherDuration((unsigned int) event->type);
}
QueueNextEvent(duration,
event->type,
0,
0,
event->fade,
event->si->name,
event->si);
}
}
else // Stop rain/snow.
{
if(event->type== psWeatherMessage::SNOW)
event->si->is_snowing = false;
else
event->si->is_raining = false;
// Queue event to turn on again later if enabled
StartWeather(event->si);
}
break;
}
case psWeatherMessage::FOG:
{
// Update sector weather info
event->si->fog_density = event->value;
event->si->r = event->cr;
event->si->g = event->cg;
event->si->b = event->cb;
// Update the clients
psWeatherMessage::NetWeatherInfo info;
info.has_downfall = false;
info.downfall_is_snow = false;
info.has_fog = true;
info.has_lightning = false;
info.sector = event->si->name;
info.fog_density = event->si->fog_density;
info.r = event->cr;
info.g = event->cg;
info.b = event->cb;
info.downfall_drops = 0;
info.downfall_fade = 0;
Notify3(LOG_WEATHER,"New Fog in sector '%s': %d", event->si->name.GetData(), event->value);
// Save the fade in so we can reverse it when fading out.
if(event->fade)
{
event->si->fogFade = event->fade;
}
else
{
// We're removing fog, so removed the 'saved' flag.
event->si->densitySaved = false;
}
info.fog_fade = event->si->fogFade;
psWeatherMessage fog(0,info);
if(fog.valid)
psserver->GetEventManager()->Broadcast(fog.msg,NetBase::BC_EVERYONE);
else
{
Bug1("Could not create valid psWeatherMessage (fog) for broadcast.\n");
}
if(event->value) // Queue event to turn off fog.
{
// Queue event to stop rain/snow
int duration;
if(event->duration != -1)
{
if(event->duration)
{
duration = event->duration;
}
else
{
duration = event->si->GetRandomWeatherDuration((unsigned int) event->type);
}
QueueNextEvent(duration,
event->type,
0,
0,
event->si->GetRandomWeatherFadeOut((unsigned int)psWeatherMessage::FOG),
event->si->name,
event->si);
}
}
else // Stop fog.
{
// Queue event to turn on again later if enabled
StartWeather(event->si, psWeatherMessage::FOG);
}
break;
}
case psWeatherMessage::LIGHTNING:
{
if(event->si->is_raining)
{
Notify2(LOG_WEATHER,"Lightning in sector '%s'",event->sector.GetData());
psWeatherMessage::NetWeatherInfo info;
info.has_downfall = false;
info.downfall_is_snow = false;
info.has_fog = false;
info.has_lightning = true;
info.sector = event->sector;
info.fog_fade = info.downfall_fade = 0;
info.r = info.g = info.b = 0;
info.downfall_drops = info.fog_density = 0;
psWeatherMessage lightning(0,info, event->clientnum);
if(lightning.valid)
{
psserver->GetEventManager()->Broadcast(lightning.msg);
}
else
{
Bug1("Could not create valid psWeatherMessage (lightning) for broadcast.\n");
}
if(event->si->is_raining &&
event->si->GetWeatherEnabled((unsigned int) psWeatherMessage::LIGHTNING))
{
QueueNextEvent(event->si->GetRandomWeatherGap((unsigned int) psWeatherMessage::LIGHTNING),
psWeatherMessage::LIGHTNING,
0,
0,
0,
event->si->name,
event->si,
event->clientnum);
}
}
break;
}
case psWeatherMessage::DAYNIGHT:
{
QueueNextEvent(GAME_MINUTE_IN_TICKS,
psWeatherMessage::DAYNIGHT,
0,
0,
0,
NULL,
NULL);
gameTimeMinute++;
if(gameTimeMinute >= 60)
{
gameTimeMinute = 0;
gameTimeHour++;
if(gameTimeHour >= 24)
{
gameTimeHour = 0;
gameTimeDay++;
if(gameTimeDay >= monthLengths[gameTimeMonth-1]+1)
{
gameTimeDay = 1;
gameTimeMonth++;
if(gameTimeMonth >= MONTH_COUNT+1)
{
gameTimeMonth = 1;
gameTimeYear++;
}
}
}
// Only save and broadcast every game hour.
SaveGameTime();
BroadcastGameTime();
}
else
{
// Super clients should get the time every minute
BroadcastGameTimeSuperclients();
}
break;
}
default:
{
break;
}
}
}
OP_ERROR
SOP_Rain::cookMySop(OP_Context &context)
{
//UT_Interrupt *boss;
if (error() < UT_ERROR_ABORT)
{
//boss = UTgetInterrupt();
//boss->opStart("Start generating rain");
fpreal now = TIME(context.getTime());
long nPoints = NPOINTS( now );
UT_Vector3 rainDirection = RAINDIRECTION(now);
//rainDirection.normalize(); //TODO: check for (0,0,0) vector
RainData rain( now,
nPoints, BOUNDMIN (now), BOUNDMAX (now),
rainDirection,
DICEMIN(now), DICEMAX(now), SEED(now),
SPEED (now),
SPEEDVARIENCE (now));
if(rain.getAllocationState() == false || isPointsNumberChanged_ == true)
{
rain.allocate(nPoints);
}
if( rain.getAllocationState() == true &&
( rain.getCachedState() == false || isParameterChanged_ == true ) )
{
rain.computeInitialPositions();
rain.setCachedState(true);
}
if (isPointsGenerated_ == false)
{
printf("Generate Points procedure\n");
gdp->clearAndDestroy();
generatePoints(gdp, nPoints);
isPointsGenerated_ = true;
}
for ( GA_Iterator pr_it(gdp->getPrimitiveRange());
!pr_it.atEnd();
++pr_it)
{
GEO_Primitive* prim = gdp->getGEOPrimitive(*pr_it);
GA_Range range = prim->getPointRange();
rain.shiftPositions( gdp, range);
}
//boss->opEnd();
}
isParameterChanged_ = false;
isPointsNumberChanged_ = false;
//unlockInputs();
return error();
}
