void ProcessKbd(void)
{
int16_t result;
static bool newconsf=false;
bool state;
while((result = VGLKeyboardGetCh()) != 0) {
state=UpdateStates(&result);
if(newconsf==true && pausef==true) {
/* return to game ? */
if(state==false)
continue;
else newconsf=false; /* yes */
}
while(newconsf==false && state==true &&
result>=F1KEY && result<=F10KEY && altpressed) {
/* Alt-Fn pressed to switch consoles */
int activecons=0;
int newcons=result-F1KEY+1;
ioctl(0, VT_GETACTIVE, &activecons);
if(newcons==activecons) /* to another console ? */
break;
newconsf=true;
/* do switch */
ioctl(0,VT_ACTIVATE,(caddr_t)(long)newcons);
if(started==true && pausef==false) {
pausef=true;
testpause(); /* force pause if game active */
}
else {
VGLCheckSwitch(); /* game not active - just switch */
/* now wait for another keyboard strike */
result=VGLKeyboardGetCh();
while(1) {
if(result!=0) {
state=UpdateStates(&result);
if(state==true) /* ignore releases */
break;
}
usleep(500); /* don't waste CPU when idle */
result=VGLKeyboardGetCh();
}
}
newconsf=false; /* switched back */
}
if(state == true)
continue;
if(klen == KBLEN) /* Buffer is full, drop some pieces */
memcpy(kbuffer, kbuffer + 1, --klen);
kbuffer[klen++] = result;
}
}
void CGUIControl::QueueAnimation(ANIMATION_TYPE animType)
{
MarkDirtyRegion();
if (!CheckAnimation(animType))
return;
CAnimation *reverseAnim = GetAnimation((ANIMATION_TYPE)-animType, false);
CAnimation *forwardAnim = GetAnimation(animType);
// we first check whether the reverse animation is in progress (and reverse it)
// then we check for the normal animation, and queue it
if (reverseAnim && reverseAnim->IsReversible() && (reverseAnim->GetState() == ANIM_STATE_IN_PROCESS || reverseAnim->GetState() == ANIM_STATE_DELAYED))
{
reverseAnim->QueueAnimation(ANIM_PROCESS_REVERSE);
if (forwardAnim) forwardAnim->ResetAnimation();
}
else if (forwardAnim)
{
forwardAnim->QueueAnimation(ANIM_PROCESS_NORMAL);
if (reverseAnim) reverseAnim->ResetAnimation();
}
else
{ // hidden and visible animations delay the change of state. If there is no animations
// to perform, then we should just change the state straightaway
if (reverseAnim) reverseAnim->ResetAnimation();
UpdateStates(animType, ANIM_PROCESS_NORMAL, ANIM_STATE_APPLIED);
}
}
void ConfigurationDialog::OnDeleteAllAlarms( wxCommandEvent& event )
{
for(unsigned int i=0; i<Alarm::s_Alarms.size(); i++)
m_lAlarms->DeleteItem(0);
Alarm::DeleteAll();
Alarm::s_Alarms.clear();
UpdateStates();
g_watchdog_pi->m_WatchdogDialog->UpdateAlarms();
}
void ConfigurationDialog::OnDeleteAlarm( wxCommandEvent& event )
{
std::vector<Alarm*>::iterator it = Alarm::s_Alarms.begin();
for(int i=0; i<CurrentSelection(); i++)
it++;
delete *it;
Alarm::s_Alarms.erase(it);
m_lAlarms->DeleteItem(CurrentSelection());
UpdateStates();
g_watchdog_pi->m_WatchdogDialog->UpdateAlarms();
}
void ConfigurationDialog::OnNewAlarm( wxCommandEvent& event )
{
NewAlarmDialog dlg(this);
if(dlg.ShowModal() == wxID_CANCEL)
return;
Alarm::NewAlarm((AlarmType)dlg.m_lAlarmType->GetNextItem(-1, wxLIST_NEXT_ALL, wxLIST_STATE_SELECTED));
wxListItem item;
long index = m_lAlarms->InsertItem(m_lAlarms->GetItemCount(), item);
m_lAlarms->SetItemState(m_lAlarms->GetItemCount() - 1,
wxLIST_STATE_SELECTED, wxLIST_STATE_SELECTED);
g_watchdog_pi->m_WatchdogDialog->UpdateAlarms();
UpdateItem(index);
UpdateStates();
OnEditAlarm(event);
if(m_bOnEditAlarmOK) return;
else OnDeleteAlarm(event);
}
bool CGUIControl::Animate(unsigned int currentTime)
{
// check visible state outside the loop, as it could change
GUIVISIBLE visible = m_visible;
m_transform.Reset();
bool changed = false;
CPoint center(GetXPosition() + GetWidth() * 0.5f, GetYPosition() + GetHeight() * 0.5f);
for (unsigned int i = 0; i < m_animations.size(); i++)
{
CAnimation &anim = m_animations[i];
anim.Animate(currentTime, HasProcessed() || visible == DELAYED);
// Update the control states (such as visibility)
UpdateStates(anim.GetType(), anim.GetProcess(), anim.GetState());
// and render the animation effect
changed |= (anim.GetProcess() != ANIM_PROCESS_NONE);
anim.RenderAnimation(m_transform, center);
/* // debug stuff
if (anim.currentProcess != ANIM_PROCESS_NONE)
{
if (anim.effect == EFFECT_TYPE_ZOOM)
{
if (IsVisible())
CLog::Log(LOGDEBUG, "Animating control %d with a %s zoom effect %s. Amount is %2.1f, visible=%s", m_controlID, anim.type == ANIM_TYPE_CONDITIONAL ? (anim.lastCondition ? "conditional_on" : "conditional_off") : (anim.type == ANIM_TYPE_VISIBLE ? "visible" : "hidden"), anim.currentProcess == ANIM_PROCESS_NORMAL ? "normal" : "reverse", anim.amount, IsVisible() ? "true" : "false");
}
else if (anim.effect == EFFECT_TYPE_FADE)
{
if (IsVisible())
CLog::Log(LOGDEBUG, "Animating control %d with a %s fade effect %s. Amount is %2.1f. Visible=%s", m_controlID, anim.type == ANIM_TYPE_CONDITIONAL ? (anim.lastCondition ? "conditional_on" : "conditional_off") : (anim.type == ANIM_TYPE_VISIBLE ? "visible" : "hidden"), anim.currentProcess == ANIM_PROCESS_NORMAL ? "normal" : "reverse", anim.amount, IsVisible() ? "true" : "false");
}
}*/
}
return changed;
}
bool CGUIControl::CheckAnimation(ANIMATION_TYPE animType)
{
// rule out the animations we shouldn't perform
if (!IsVisible() || !HasProcessed())
{ // hidden or never processed - don't allow exit or entry animations for this control
if (animType == ANIM_TYPE_WINDOW_CLOSE)
{ // could be animating a (delayed) window open anim, so reset it
ResetAnimation(ANIM_TYPE_WINDOW_OPEN);
return false;
}
}
if (!IsVisible())
{ // hidden - only allow hidden anims if we're animating a visible anim
if (animType == ANIM_TYPE_HIDDEN && !IsAnimating(ANIM_TYPE_VISIBLE))
{
// update states to force it hidden
UpdateStates(animType, ANIM_PROCESS_NORMAL, ANIM_STATE_APPLIED);
return false;
}
if (animType == ANIM_TYPE_WINDOW_OPEN)
return false;
}
return true;
}
ConfigurationDialog::ConfigurationDialog( watchdog_pi &_watchdog_pi, wxWindow* parent)
: ConfigurationDialogBase( parent ), m_watchdog_pi(_watchdog_pi)
{
wxFileConfig *pConf = GetOCPNConfigObject();
pConf->SetPath ( _T( "/Settings/Watchdog" ) );
int enabled = pConf->Read ( _T ( "Enabled" ), 1L );
m_rbAlways->SetValue(enabled == 1);
m_rbOnce->SetValue(enabled == 2);
m_rbVisible->SetValue(enabled == 3);
m_rbNever->SetValue(enabled == 0);
m_lAlarms->InsertColumn(ALARM_TYPE, _("Type"));
m_lAlarms->InsertColumn(ALARM_OPTIONS, _("Options"));
m_lAlarms->InsertColumn(ALARM_ACTION, _("Action"));
for(unsigned int i=0; i<Alarm::s_Alarms.size(); i++) {
wxListItem item;
m_lAlarms->InsertItem(i, item);
UpdateItem(i);
}
UpdateStates();
}
void AI_HandleMove(int bMyMove, const tMove *Move)
{
if( gbFirstTurn )
{
gbFirstTurn = false;
AI_int_InitialiseBoardState();
// Reverse the first move
if( Move->dir != DIR_INVAL )
{
tPiece *p;
switch(Move->dir)
{
case DIR_INVAL: ASSERT(Move->dir != DIR_INVAL); break;
case DIR_LEFT: p = GetPieceByPos( Move->x-1, Move->y ); break ;
case DIR_RIGHT: p = GetPieceByPos( Move->x+1, Move->y ); break ;
case DIR_UP: p = GetPieceByPos( Move->x, Move->y-1 ); break ;
case DIR_DOWN: p = GetPieceByPos( Move->x, Move->y+1 ); break ;
}
MovePieceTo( p, Move->x, Move->y );
p->StartX = Move->x;
p->StartY = Move->y;
}
}
if(Move->result == RESULT_VICTORY)
{
// TODO: Distiguish between victory conditions?
// - Note flag location?
// TODO: Save back initial board state
DB_WriteBackInitialState(gsOpponentDbFilename, !gMyColour, gpCurrentGameState->Opponent.Pieces);
}
if( !bMyMove )
{
if( Move->dir != DIR_INVAL )
UpdateStates(Move);
}
else
{
tPiece *p = GetPieceByPos(Move->x, Move->y);
ASSERT(p);
int newx = p->X, newy = p->Y;
switch(Move->dir)
{
case DIR_INVAL: break;
case DIR_LEFT: newx -= Move->dist; break;
case DIR_RIGHT: newx += Move->dist; break;
case DIR_UP: newy -= Move->dist; break;
case DIR_DOWN: newy += Move->dist; break;
}
tPiece *target = GetPieceByPos(newx, newy);
switch(Move->result)
{
case RESULT_ILLEGAL: break;
case RESULT_INVAL: break;
case RESULT_OK:
MovePieceTo(p, newx, newy);
break;
case RESULT_KILL:
UpdateRank(target, Move->defender);
RemovePiece(target);
MovePieceTo(p, newx, newy);
PieceExposed(p); // TODO: Update oponent's view
giTurnsSinceLastTake = 0;
break;
case RESULT_DIES:
case RESULT_VICTORY:
UpdateRank(target, Move->defender);
PieceExposed(p);
RemovePiece(p);
giTurnsSinceLastTake = 0;
break;
case RESULT_BOTHDIE:
UpdateRank(target, Move->defender);
PieceExposed(p);
RemovePiece(p);
RemovePiece(target);
giTurnsSinceLastTake = 0;
break;
}
}
}
void idKeypad::Think( void )
{
int i;
//glows.
if (state == ACTIVE)
{
if (gameLocal.GetLocalPlayer()->focusFrobEnt)
{
bool isHover = false;
int i;
int hoverIndex = gameLocal.GetLocalPlayer()->focusFrobEnt->entityNumber;
for (i = 0; i < 9; i++)
{
if (hoverIndex == frobcubes[i]->entityNumber)
{
SetSkin(skin_glow[i]);
isHover = true;
}
}
if (!isHover)
{
SetSkin(0); //default.
bluebox->Hide();
}
else
{
//show bluebox.
bluebox->Show();
idAngles remoteAng = gameLocal.GetLocalPlayer()->viewAngles;
remoteAng.yaw += 180 + 30;
remoteAng.pitch *= -1;
remoteAng.pitch += 3 * idMath::Sin(gameLocal.time * 0.0005f); //sway
remoteAng.yaw += 3 + 3 * idMath::Sin(gameLocal.time * 0.0003f); //sway
bluebox->SetAngles( remoteAng );
idVec3 up, right;
remoteAng.ToVectors( NULL, &right, &up );
idVec3 finalPos = gameLocal.GetLocalPlayer()->GetEyePosition()
+ (gameLocal.GetLocalPlayer()->viewAngles.ToForward() * 12.0f)
+ (up * -5.0f)
+ (right * 7.0f);
bluebox->GetPhysics()->SetOrigin(finalPos);
//bluebox->GetPhysics()->SetOrigin(
}
}
else
{
SetSkin(0); //default.
//hide bluebox.
bluebox->Hide();
}
}
//handle the button animations.
for (i = 0; i < 9; i++)
{
if (gameLocal.time > transitions[i])
{
jointHandle_t joint;
joint = animator.GetJointHandle( GetJointViaIndex(i) );
animator.ClearJoint(joint);
}
}
UpdateStates();
idAnimatedEntity::Think();
idAnimatedEntity::Present();
}
/*
* This is the most important function in localization. go through the poles in pole list
* and calculate weight and make decisions...
*/
void Algorithm::ParticleFilter(list<PoleData> & poleList) //i have array of single poles
{
/*
* if there is only one or two poles we can't trust that. so wait for more than 1.
* but if the oldest pole is very old, make an iteration.
*/
if (/*poleList.front().time-(*m_currTimePtr) > 50000 && */poleList.size()<=2) return;
//reset counter
m_stepsWithoutPolePicture=0;
#ifdef LOCALIZATION_DEBUG
printf("Algorithm::ParticleFilter(list<PoleData> & poleList):\n");
printf("have %d poles to go through\n",poleList.size());
#endif
//this was a try to make a low pass filter to throw poles with noise. not tested.
//TODO try to do this. not so important.
// bool DoneLPF = poleList.size() < 3 ? true:false; // lpf only for 3 or more poles;
// PoleData temp[3];
// int i;
// list<PoleData>::iterator it;
// list<PoleData>::iterator itErase;
double w;
while (poleList.size()>0)
{
//LPF stuff
/*
// cout<<"START 1 "<<poleList.size()<<endl;
// it = poleList.begin();
// PoleId ID = it->id;
// i=0;
// while((!DoneLPF) && it!= poleList.end()) //LPF
// {
// cout<<"START 2 "<<poleList.size()<<"\ti= "<<i<<endl;
// if(it->id == ID)
// {
// if(it->distFromMe < 0)
// {
// DoneLPF = true;
// continue;
// }
// else
// {
// temp[i] = *it;
// if(i == 1)
// itErase = it;// the pole to erase
// it++;
// i++;
// }
// }
// if(i == 3)
// {
// cout<<"IF 2 "<<poleList.size()<<"\ti= "<<i<<endl;
// DoneLPF = true;
// if((fabs(temp[0].distFromMe - temp[2].distFromMe) < fabs(temp[0].distFromMe - temp[1].distFromMe )) && (temp[2].time - temp[0].time < 1000000))
// {
// poleList.erase(itErase);
// }
// }
// }
*/
PoleData pole=poleList.front();
poleList.pop_front();
#ifdef LOCALIZATION_DEBUG
cout<<"\t#poles: "<<poleList.size()<<" \t";
cout<<"Dist: "<<pole.distFromMe<<"\tID: "<<pole.id<<endl;
//if(DoneLPF && i==3)
// cout<<"Dist: "<<temp[1].distFromMe<<"\tID: "<<temp[1].id<<"\tTHROWED"<<endl;
#endif
//go through each particle and calculate the wieght
for (State_iterator it = m_currState.begin(); it != m_currState.end() ;it++)//update weight
{
/*
* TODO: OMG found a bug!!
* what happens when the pole.id==GOAL_UNKNOWN_BACK ???!!!
* TODO FIXME
*/
if (pole.id==GOAL_UNKNOWN_FRONT) // either left or right front pole, give maximum weight.
{
double w0,w1;
pole.id=GOAL_LEFT_FRONT;
w0=getWeightFromPole(pole,*it);
pole.id=GOAL_RIGHT_FRONT;
w1=getWeightFromPole(pole,*it);
pole.id=GOAL_UNKNOWN_FRONT;
if (w0>w1) w=w0; else w=w1;
}
else //We know what pole it is.
{
w=getWeightFromPole(pole,*it);
}
//give new weight for the particle, while considering old weight.
(it->weight)*=w;
}
}
double sumOfWeight=0;
for (State_iterator it = m_currState.begin(); it != m_currState.end() ;it++) {
sumOfWeight+=it->weight;
}
sumOfWeight = 1 / sumOfWeight;
//if all the sum of weight is very low, it means all the particles are out
if (sumOfWeight<0.001)
m_outOfLocation=true;
else
m_outOfLocation=false;
//TODO use the sumOfWeight we calculated before and send to this function
//normalize weight for the monte carlo
NormalizeWeight(sumOfWeight); //sum of weights = 1
//choose new set
UpdateStates();
}
//This function will eventually replace the above function to handle
// POIs instead of poles
//TODO compare this function to the previous and see if we can upgrade some of the things
// they were unable to do last year
void Algorithm::ParticleFilter(list<PoiData>& poiList)
{
/*
* if there is only one or two poles we can't trust that. so wait for more than 1.
* but if the oldest pole is very old, make an iteration.
*/
//if (/*poleList.front().time-(*m_currTimePtr) > 50000 && */poleList.size()<=2) return;
//TODO verify this line!!
if(/**m_currTimePtr - poiList.front().time < 50000 ||*/ poiList.size() <= 2)
return;
//reset counter
m_stepsWithoutPolePicture=0;
#ifdef LOCALIZATION_DEBUG
cout << "[Algorithm::ParticleFilter]: have " << poiList.size() << " POIs to go through" << endl;
#endif
//TODO attempt to create a LPF for the POIs
double w, maxW;
while (poiList.size()>0)
{
PoiData poi = poiList.front();
poiList.pop_front();
#ifdef LOCALIZATION_DEBUG
cout<<"\t#POIs: "<<poiList.size()<<" \t";
cout<<"Dist: "<<poi.distFromMe<<"\tID: "<<poi.id<<endl;
#endif
//go through each particle and calculate the weight
for (State_iterator it = m_currState.begin(); it != m_currState.end() ;it++)//update weight
{
if (poi.id==UNKNOWN)
{
w = 0;
maxW = 0;
for(int i=0;i<NUMBER_OF_POIS;i++)
{
poi.id = (PoiId)i;
w = GetWeightFromPoi(poi,*it);
maxW = w > maxW ? w : maxW;
}
w = maxW;
poi.id = UNKNOWN;
}
else //We know what poi it is.
{
w = GetWeightFromPoi(poi,*it);
}
//give new weight for the particle, while considering old weight.
(it->weight)*=w;
}
}
double sumOfWeight=0;
for (State_iterator it = m_currState.begin(); it != m_currState.end() ;it++) {
sumOfWeight += it->weight;
}
//if all the sum of weight is very low, it means all the particles are out
if ((sumOfWeight/m_currState.size()) < 0.001)
m_outOfLocation=true;
else
m_outOfLocation=false;
NormalizeWeight(sumOfWeight);
//choose new set
UpdateStates();
}
void WeatherRouting::OnComputationTimer( wxTimerEvent & )
{
bool update = false;
for(std::list<RouteMapOverlay*>::iterator it = m_RunningRouteMaps.begin();
it != m_RunningRouteMaps.end(); )
{
RouteMapOverlay *routemapoverlay = *it;
if(!routemapoverlay->Running())
{
UpdateRouteMap(routemapoverlay);
it = m_RunningRouteMaps.erase(it);
m_gProgress->SetValue(m_RoutesToRun - m_WaitingRouteMaps.size() - m_RunningRouteMaps.size());
update = true;
/* update report if needed */
if(m_ReportDialog.IsShown())
{
if(routemapoverlay == CurrentRouteMap())
m_ReportDialog.SetRouteMapOverlay(routemapoverlay);
}
continue;
} else
it++;
/* get a new grib for the route map if needed */
if(routemapoverlay->NeedsGrib())
{
m_RouteMapOverlayNeedingGrib = routemapoverlay;
routemapoverlay->RequestGrib(routemapoverlay->NewTime());
m_RouteMapOverlayNeedingGrib = NULL;
}
}
if((int)m_RunningRouteMaps.size() < m_SettingsDialog.m_sConcurrentThreads->GetValue()
&& m_WaitingRouteMaps.size())
{
RouteMapOverlay *routemapoverlay = m_WaitingRouteMaps.front();
m_WaitingRouteMaps.pop_front();
routemapoverlay->Start();
UpdateRouteMap(routemapoverlay);
m_RunningRouteMaps.push_back(routemapoverlay);
update = true;
}
static int cycles; /* don't refresh all the time */
if(++cycles > 25 && CurrentRouteMap() && CurrentRouteMap()->Updated())
{
cycles = 0;
m_StatisticsDialog.SetRunTime(m_RunTime += wxDateTime::Now() - m_StartTime);
if(m_StatisticsDialog.IsShown())
m_StatisticsDialog.SetRouteMapOverlay(CurrentRouteMap());
m_StartTime = wxDateTime::Now();
GetParent()->Refresh();
}
if(update)
UpdateStates();
if(m_RunningRouteMaps.size())
{
/* todo, instead of respawning the funky timer here,
maybe we can do it from the thread instead to eliminate the delay */
m_tCompute.Start(25, true);
return;
}
Stop();
}
void WeatherRouting::OnResetAll ( wxCommandEvent& event )
{
Reset();
UpdateStates();
}
void ProcessFrame()
{
UpdateStates();
RenderFrame();
}