示例#1
0
// ------------------------------------------------------------------------------------------------
void ProjectileBase :: Update(float timeDelta)
{
    // Pre-Conditions:
    assert(IsActive() && "ProjectileBase::Update IsActive()");

    if(IsActive())
    {
		updateEvent->Process(this);

		if(isMoving)
		{
			Vector2df nextPos = Pos() + Heading() * speed * timeDelta;

			if(Game()->CheckCollisionWithChars(nextPos + Heading() * radius))
			{
				hitPos = nextPos + Heading() * radius;
				hitCharEvent->Process(this);
			}

			if(Game()->IsPosSolid(nextPos + Heading() * radius))
			{
				hitPos = nextPos + Heading() * radius;
				hitSolidEvent->Process(this);
			}

			SetPos(nextPos);
		}

		DecreaseLife(timeDelta);
    }

    // Post-Conditions
    assert(Pos().x >= MAP_MIN_POS_X && Pos().x < MAP_MAX_POS_X && "ProjectileBase::Update Pos().x >= MAP_MIN_POS_X && Pos().x < MAP_MAX_POS_X");
    assert(Pos().y >= MAP_MIN_POS_Y && Pos().y < MAP_MAX_POS_Y && "ProjectileBase::Update Pos().y >= MAP_MIN_POS_Y && Pos().y < MAP_MAX_POS_Y");
} // ----------------------------------------------------------------------------------------------
示例#2
0
void CUIWeaponCellItem::Update()
{
	bool b						= Heading();
	inherited::Update			();
	
	bool bForceReInitAddons		= (b!=Heading());

	if (object()->SilencerAttachable())
	{
		if (object()->IsSilencerAttached())
		{
			if (!GetIcon(eSilencer) || bForceReInitAddons)
			{
				CreateIcon	(eSilencer);
				InitAddon	(GetIcon(eSilencer), *object()->GetSilencerName(), m_addon_offset[eSilencer], Heading());
			}
		}
		else
		{
			if (m_addons[eSilencer])
				DestroyIcon(eSilencer);
		}
	}

	if (object()->ScopeAttachable()){
		if (object()->IsScopeAttached())
		{
			if (!GetIcon(eScope) || bForceReInitAddons)
			{
				CreateIcon	(eScope);
				InitAddon	(GetIcon(eScope), *object()->GetScopeName(), m_addon_offset[eScope], Heading());
			}
		}
		else
		{
			if (m_addons[eScope])
				DestroyIcon(eScope);
		}
	}

	if (object()->GrenadeLauncherAttachable()){
		if (object()->IsGrenadeLauncherAttached())
		{
			if (!GetIcon(eLauncher) || bForceReInitAddons)
			{
				CreateIcon	(eLauncher);
				InitAddon	(GetIcon(eLauncher), *object()->GetGrenadeLauncherName(), m_addon_offset[eLauncher], Heading());
			}
		}
		else
		{
			if (m_addons[eLauncher])
				DestroyIcon(eLauncher);
		}
	}
}
示例#3
0
Dialogs::ConvertMemoryCardDialog::ConvertMemoryCardDialog( wxWindow* parent, const wxDirName& mcdPath, const AppConfig::McdOptions& mcdSourceConfig )
	: wxDialogWithHelpers( parent, _( "Convert a memory card to a different format" ) )
	, m_mcdPath( mcdPath )
	, m_mcdSourceFilename( mcdSourceConfig.Filename.GetFullName() )
{
	SetMinWidth( 472 * MSW_GetDPIScale());

	CreateControls( mcdSourceConfig.Type );

	if ( m_radio_CardType ) m_radio_CardType->Realize();

	wxBoxSizer& s_buttons( *new wxBoxSizer( wxHORIZONTAL ) );
	s_buttons += new wxButton( this, wxID_OK, _( "Convert" ) ) | pxProportion( 2 );
	s_buttons += pxStretchSpacer( 3 );
	s_buttons += new wxButton( this, wxID_CANCEL ) | pxProportion( 2 );

	wxBoxSizer& s_padding( *new wxBoxSizer( wxVERTICAL ) );

	s_padding += Heading( wxString( _( "Convert: " ) ) + ( mcdPath + m_mcdSourceFilename ).GetFullPath() ).Unwrapped() | pxSizerFlags::StdExpand();

	wxBoxSizer& s_filename( *new wxBoxSizer( wxHORIZONTAL ) );
	s_filename += Heading( _( "To: " ) ).Unwrapped().Align(wxALIGN_RIGHT) | pxProportion(1);
	m_text_filenameInput->SetValue( wxFileName( m_mcdSourceFilename ).GetName() + L"_converted" );
	s_filename += m_text_filenameInput | pxProportion(2);
	s_filename += Heading( L".ps2" ).Align(wxALIGN_LEFT) | pxProportion(1);

	s_padding += s_filename | pxSizerFlags::StdExpand();

	s_padding += m_radio_CardType | pxSizerFlags::StdExpand();

	if ( mcdSourceConfig.Type != MemoryCardType::MemoryCard_File ) {
		s_padding += Heading( pxE( L"Please note that the resulting file may not actually contain all saves, depending on how many are in the source memory card." ) );
	}
	s_padding += Heading( pxE( L"WARNING: Converting a memory card may take a while! Please do not close the emulator during the conversion process, even if the emulator is no longer responding to input." ) );

	s_padding += 12;
	s_padding += s_buttons | pxSizerFlags::StdCenter();

	*this += s_padding | pxSizerFlags::StdExpand();

	Connect( wxID_OK, wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( ConvertMemoryCardDialog::OnOk_Click ) );
	Connect( m_text_filenameInput->GetId(), wxEVT_COMMAND_TEXT_ENTER, wxCommandEventHandler( ConvertMemoryCardDialog::OnOk_Click ) );

	SetSizerAndFit(GetSizer());

	m_text_filenameInput->SetFocus();
	m_text_filenameInput->SelectAll();
}
void main(void) {         
	Sys_Init();	//All init function
	putchar(' ');
	XBR0_Init();
	ADC_Init();    
	Port_Init();     
	PCA_Init();     
	SMB_Init();	//end the init function
	     
	lcd_clear();	
	lcd_print("initializing\r\n");
	printf("\n\n\n\rinitalizing");

	PCA0CP2 = 0xFFFF - MOTOR_NEUT;//set all to neutural
	PCA0CPL0 = 0xFFFF - PW_CENTER;
   	PCA0CPH0 = (0xFFFF - PW_CENTER) >> 8;

	pause();	//pause for a second?
	start_run();

	while (1) { 
		while(SS){            // if the slideswitch is off          
			slide_switch_off();
		}///end slide switch off
		while(!SS){	//while the slideswitch is on
			Heading();
			Ranger();
			LCD_Print();	//print all values on the lcd
			printf("\n\rRange:%d Compass:%d dh: %d, mPW: %d, sPW %d, batt:%d, obst: %d", range, heading, desired_heading, MOTOR_PW_AND_STEER_PW, STEER_PW, battery, near_obstical);	//print these on the secure crt for data aquisition
			//printf("\n\r Range:%d Compass:%d dh: %d, mPW: %d, sPW %d, obst: %d", range, heading, desired_heading, MOTOR_PW_AND_STEER_PW, STEER_PW, near_obstical);	//print these on the secure crt for data aquisition
		}//end slide switch on
	}	//end of the infinite while loop
}//end of the main function
//------------------------------ Update ---------------------------------------
//-----------------------------------------------------------------------------
void Rocket::Update()
{
  if (!m_bImpacted)
  {
    m_vVelocity = MaxSpeed() * Heading();

    //make sure vehicle does not exceed maximum velocity
    m_vVelocity.Truncate(m_dMaxSpeed);

    //update the position
    m_vPosition += m_vVelocity;

    TestForImpact();  
  }

  else
  {
    m_dCurrentBlastRadius += script->GetDouble("Rocket_ExplosionDecayRate");

    //when the rendered blast circle becomes equal in size to the blast radius
    //the rocket can be removed from the game
    if (m_dCurrentBlastRadius > m_dBlastRadius)
    {
      m_bDead = true;
    }
  }
}
示例#6
0
void CUICellItem::Update()
{
	if (m_pParentList)
		EnableHeading(m_pParentList->GetVerticalPlacement());

	if(Heading())
	{
		SetHeading			( 90.0f * (PI/180.0f) );
		SetHeadingPivot		(Fvector2().set(0.0f,0.0f), Fvector2().set(0.0f,GetWndSize().y), true);
	}else
		ResetHeadingPivot	();

	inherited::Update();
	
	if ( CursorOverWindow() )
	{
		Frect clientArea;
		m_pParentList->GetClientArea(clientArea);
		Fvector2 cp			= GetUICursor()->GetCursorPosition();
		if(clientArea.in(cp))
			GetMessageTarget()->SendMessage(this, DRAG_DROP_ITEM_FOCUSED_UPDATE, NULL);
	}
	
	m_b_already_drawn=false;
 
}
示例#7
0
CUIDragItem* CUICellItem::CreateDragItem()
{
	CUIDragItem* tmp;
	tmp = xr_new<CUIDragItem>(this);
	Frect r;
	GetAbsoluteRect(r);
	if( m_UIStaticItem.GetFixedLTWhileHeading() )
	{
		float w, h;
		w				= r.width();
		h				= r.height();
		if (Heading())
		{   // исправление пропорций
			w = w / m_cell_size.x * m_cell_size.y;
			h = h / m_cell_size.y * m_cell_size.x;
		}

		Fvector2 cp = GetUICursor()->GetCursorPosition();
		// поворот на 90 градусов, и центрирование по курсору мыша						
		r.x1			= (cp.x - h / 2.0f);
		r.y1			= (cp.y - w / 2.0f);
		r.x2			= r.x1 + h;
		r.y2			= r.y1 + w;
	} 
	tmp->Init(GetShader(),r,GetUIStaticItem().GetOriginalRect());
	return tmp;
}
示例#8
0
void main(void) {         
	Sys_Init();	//All init function
	putchar(' ');
	XBR0_Init();
	ADC_Init();    
	Port_Init();     
	PCA_Init();     
	SMB_Init();	//end the init function
	     
	lcd_clear();	
	lcd_print("initializing\r\n");
		

	PCA0CP2 = 0xFFFF - MOTOR_NEUT;
	PCA0CPL0 = 0xFFFF - PW_CENTER;
   	PCA0CPH0 = (0xFFFF - PW_CENTER) >> 8;
	while (n_Counts < 50);	//pause for a second?

	start_run();
	while (1) { 
		while(SS){            // if the slideswitch is off          
			slide_switch_off();
		}///end slide switch off
		while(!SS)	//while the slideswitch is on
		{
			Heading();
			Ranger();
			LCD_Print();	//print all values on the lcd
			printf("\n\r Range:%d  Compass:%d  PW:%d", range, heading, PW);	//print these on the secure crt for data aquisition
		}
	}	//end of the infinite while loop
}//end of the main function
示例#9
0
void CUIButton::DrawTexture()
{
	Frect rect; 
	GetAbsoluteRect		(rect);

	if(m_bAvailableTexture && m_bTextureEnable)
	{
		if(m_eButtonState == BUTTON_UP || m_eButtonState == BUTTON_NORMAL)
			m_UIStaticItem.SetPos(rect.left + m_TextureOffset.x, rect.top + m_TextureOffset.y);
		else
			m_UIStaticItem.SetPos(rect.left + m_PushOffset.x + m_TextureOffset.x, rect.top + m_PushOffset.y + m_TextureOffset.y);

		if(m_bStretchTexture)
			m_UIStaticItem.SetRect(0, 0, rect.width(), rect.height());
		else
		{
			Frect r={0,0,
				m_UIStaticItem.GetOriginalRectScaled().width(),
				m_UIStaticItem.GetOriginalRectScaled().height()};
			m_UIStaticItem.SetRect(r);
		}

		if( Heading() )
			m_UIStaticItem.Render( GetHeading() );
		else
			m_UIStaticItem.Render();		
	}
}
示例#10
0
//------------------------------ Update ---------------------------------------
//-----------------------------------------------------------------------------
void Bolt::Update()
{
  if (!m_bImpacted)
  {
    m_vVelocity = MaxSpeed() * Heading();

    //make sure vehicle does not exceed maximum velocity
    m_vVelocity.Truncate(m_dMaxSpeed);

    //update the position
    m_vPosition += m_vVelocity;

    
    //if the projectile has reached the target position or it hits an entity
    //or wall it should explode/inflict damage/whatever and then mark itself
    //as dead


    //test to see if the line segment connecting the bolt's current position
    //and previous position intersects with any bots.
    Raven_Bot* hit = GetClosestIntersectingBot(m_vPosition - m_vVelocity,
                                               m_vPosition);
    
    //if hit
    if (hit)
    {
      m_bImpacted = true;
      m_bDead     = true;

      //send a message to the bot to let it know it's been hit, and who the
      //shot came from
      Dispatcher->DispatchMsg(SEND_MSG_IMMEDIATELY,
                              m_iShooterID,
                              hit->ID(),
                              Msg_TakeThatMF,
                              (void*)&m_iDamageInflicted);
    }

    //test for impact with a wall
    double dist;
     if( FindClosestPointOfIntersectionWithWalls(m_vPosition - m_vVelocity,
                                                 m_vPosition,
                                                 dist,
                                                 m_vImpactPoint,
                                                 m_pWorld->GetMap()->GetWalls()))
     {
       m_bDead     = true;
       m_bImpacted = true;

       m_vPosition = m_vImpactPoint;

       return;
     }
  }
}
void GlobalReference::reset()
{
  position_ = Position();
  heading_ = Heading();

  has_position_ = false;
  has_heading_ = false;
  has_altitude_ = false;

  updated();
}
示例#12
0
void CUIWeaponCellItem::InitAddon(CUIStatic* s, LPCSTR section, Fvector2 addon_offset, bool b_rotate)
{
	
		Frect					tex_rect;
		Fvector2				base_scale;

		if(Heading())
		{
			base_scale.x			= GetHeight()/(INV_GRID_WIDTHF*m_grid_size.x);
			base_scale.y			= GetWidth()/(INV_GRID_HEIGHTF*m_grid_size.y);
		}else
		{
			base_scale.x			= GetWidth()/(INV_GRID_WIDTHF*m_grid_size.x);
			base_scale.y			= GetHeight()/(INV_GRID_HEIGHTF*m_grid_size.y);
		}
		Fvector2				cell_size;
		cell_size.x				= pSettings->r_u32(section, "inv_grid_width")*INV_GRID_WIDTHF;
		cell_size.y				= pSettings->r_u32(section, "inv_grid_height")*INV_GRID_HEIGHTF;

		tex_rect.x1				= pSettings->r_u32(section, "inv_grid_x")*INV_GRID_WIDTHF;
		tex_rect.y1				= pSettings->r_u32(section, "inv_grid_y")*INV_GRID_HEIGHTF;

		tex_rect.rb.add			(tex_rect.lt,cell_size);

		cell_size.mul			(base_scale);

		if(b_rotate)
		{
			s->SetWndSize		(Fvector2().set(cell_size.y, cell_size.x) );
			Fvector2 new_offset;
			new_offset.x		= addon_offset.y*base_scale.x;
			new_offset.y		= GetHeight() - addon_offset.x*base_scale.x - cell_size.x;
			addon_offset		= new_offset;
		}else
		{
			s->SetWndSize		(cell_size);
			addon_offset.mul	(base_scale);
		}

		s->SetWndPos			(addon_offset);
		s->SetOriginalRect		(tex_rect);
		s->SetStretchTexture	(true);

		s->EnableHeading		(b_rotate);
		
		if(b_rotate)
		{
			s->SetHeading			(GetHeading());
			Fvector2 offs;
			offs.set				(0.0f, s->GetWndSize().y);
			s->SetHeadingPivot		(Fvector2().set(0.0f,0.0f), /*Fvector2().set(0.0f,0.0f)*/offs, true);
		}
}
示例#13
0
//===============================================
//処理
//===============================================
//[input]
//	なし
//[return]
//	なし
//===============================================
void CField::Exec()
{
	//::D3DXVec3TransformCoord(&vAxisX, &vAxisX, &m_matRotate);
	//::D3DXVec3TransformCoord(&vAxisZ, &vAxisZ, &m_matRotate);
	
	//if(CJoyPad::GetState(0, PAD_STATE_HOLD, PAD_DIR_LEFT) )
	//{
	//	m_vPos -= vAxisX*0.1f;
	//	//m_Anim += 1.0f;
	//}
	//
	//if(CJoyPad::GetState(0, PAD_STATE_HOLD, PAD_DIR_RIGHT) )
	//{
	//	m_vPos += vAxisX*0.1f;
	//	//m_Anim += 1.0f;
	//}	
	//
	//if(CJoyPad::GetState(0, PAD_STATE_HOLD, PAD_DIR_UP) )
	//{
	//	m_vPos -= vAxisZ * 0.1f;
	//	//m_vPos.z -= 0.1f;
	//	//m_Anim += 1.0f;
	//}
	//
	//if(CJoyPad::GetState(0, PAD_STATE_HOLD, PAD_DIR_DOWN) )
	//{
	//	m_vPos += vAxisZ * 0.1f;
	//	//m_vPos.z += 0.1f;
	//	//m_Anim += 1.0f;
	//}
	
	
	//if(CJoyPad::GetState(0, PAD_STATE_HOLD, PAD_BUTTON_02) )
	//{
	//	m_vRot.x += 0.1f;
	//}
	
//	Update(0.000f);
	
	Translation(m_vPos.x, m_vPos.y, m_vPos.z);
	
	Scaling(m_vScale.x, m_vScale.y, m_vScale.z);
	
	Heading(m_vRot.x);
	
	Pitching(m_vRot.x);
	
	Rolling(m_vRot.x);
	
	Render(Joker::GetDevice());
	
	SetWorldMatrix();
}
示例#14
0
static void calculate_compass()
{
	int magX = 0; int magY = 0; int magZ = 0;
	static int count = 0;
	int iResult;
	int offsets[3] = {0};
	double dHeading = 0;
    float accForward;
    float accLeft;

	orietation_data[0] = gsensor_data[0];
	orietation_data[1] = gsensor_data[1];
	orietation_data[2] = gsensor_data[2];

	compass_data[0] = g_compass_data.y;
	compass_data[1] = -g_compass_data.x;
	compass_data[2] = g_compass_data.z;

	magX = compass_data[0];
	magY = compass_data[1];
	magZ = compass_data[2];

	count++;
	if (count < 1200){
		CollectDataItem(magX, magY, magZ);
		//LOGE("CollectData.\n");
	}

	iResult = Calibrate(&offsets[0]);
	// Elsewhere in the application, getting magnetic data and correcting out the
	// hard iron disturbances 
	magX -= offsets[0];
	magY -= offsets[1];
	magZ -= offsets[2];
	//Magnetic field data is now ready to be used
	accForward = 0;
	accLeft = 0;	
	dHeading = Heading(-magX,magY,magZ,accForward ,accLeft);

	if (dHeading >0)
		{
			// Use the Heading Value
			g_compass_data.x = dHeading;
		}

	Calculate_Sensor_Angle();
	g_compass_data.y = sensor_angle[1];
	g_compass_data.z = sensor_angle[2];

}
示例#15
0
Fvector2 CUICustomMap::ConvertRealToLocal  (const Fvector2& src)// meters->pixels (relatively own left-top pos)
{
	Fvector2 res;
	if( !Heading() ){
		return ConvertRealToLocalNoTransform(src);
	}else{
		Fvector2 heading_pivot = GetStaticItem()->GetHeadingPivot();
	
		res = ConvertRealToLocalNoTransform(src);
		res.sub(heading_pivot);
		rotation_(res.x, res.y, GetHeading(), res.x, res.y);
		res.add(heading_pivot);
		return res;
	};
}
示例#16
0
void CUICellItem::Update()
{
	if (m_pParentList)
		EnableHeading(m_pParentList->GetVerticalPlacement());

	if(Heading())
	{
		SetHeading			( 90.0f * (PI/180.0f) );
		SetHeadingPivot		(Fvector2().set(0.0f,0.0f), Fvector2().set(0.0f,GetWndSize().y), true);
	}else
		ResetHeadingPivot	();

	inherited::Update();
	
	m_b_already_drawn=false;
 
}
示例#17
0
void cEntity::TakeDamage(eDamageType a_DamageType, cEntity * a_Attacker, int a_RawDamage, int a_FinalDamage, double a_KnockbackAmount)
{
	TakeDamageInfo TDI;
	TDI.DamageType = a_DamageType;
	TDI.Attacker = a_Attacker;
	TDI.RawDamage = a_RawDamage;
	TDI.FinalDamage = a_FinalDamage;
	
	Vector3d Heading(0, 0, 0);
	if (a_Attacker != NULL)
	{
		Heading = a_Attacker->GetLookVector() * (a_Attacker->IsSprinting() ? 10 : 8);
	}
	Heading.y = 2;

	TDI.Knockback = Heading * a_KnockbackAmount;
	DoTakeDamage(TDI);
}
bool Player::FireEnergyCannon(ItemInstance *item)
{
    float pos[3];
    float *_heading = Heading();
    float range = (float)item->WeaponRange;
    
    if (GetEnergyValue() < item->EnergyUse)
    {
        SendVaMessage("Not enough energy! Need: %f", item->EnergyUse);
        return false;
    }
   
    /* Use the energy */
    RemoveEnergy(item->EnergyUse);
       
    pos[0] = PosX() + ( range * _heading[0] );
    pos[1] = PosY() + ( range * _heading[1] );
    pos[2] = PosZ() + ( range * _heading[2] );
   
    RangeListVec::iterator itrRList;
    Player *p = (0);
    
	while (g_PlayerMgr->GetNextPlayerOnList(p, m_RangeList))
	{        
        p->PointEffect(pos, 1017, 3.0f);
        //see if this player is in range of explosion.
        float range_to_blast = p->RangeFrom(pos, true);
        if (p != this)
        {
            SendVaMessage("Range to blast: %.2f", range_to_blast);
        }
        if (range_to_blast < 1000.0f)
        {
            float damage = p->CaughtInEnergyBlast(GameID(), range_to_blast);
            if (damage > 0)
            {
                SendVaMessage("Blast Damage: %.2f", damage);
                SendClientDamage(p->GameID(), GameID(), damage, 0, 0);
            }
        }
    }

    return true;
}
示例#19
0
bool DoCalculations(NMEA_INFO *Basic, DERIVED_INFO *Calculated)
{

  // first thing: assign navaltitude!
  EnergyHeightNavAltitude(Basic, Calculated);

  // second thing: if available, get external wind precalculated!
  if ( (Basic->ExternalWindAvailable==TRUE) && (AutoWindMode==D_AUTOWIND_EXTERNAL)) {
	if (Basic->ExternalWindSpeed>0 && Basic->ExternalWindSpeed<35) {
		Calculated->WindSpeed = Basic->ExternalWindSpeed;
		Calculated->WindBearing = Basic->ExternalWindDirection;
	}
  }

  Heading(Basic, Calculated);
  DistanceToNext(Basic, Calculated);
  DistanceToHome(Basic, Calculated);
  DetectFreeFlying(Basic,Calculated);	// check ongoing powerless flight
  DoLogging(Basic, Calculated);
  Vario(Basic,Calculated);
  TerrainHeight(Basic, Calculated);
  AltitudeRequired(Basic, Calculated, MACCREADY);
  DoAlternates(Basic,Calculated,TASKINDEX); 
  if (IsMultiMapShared()) {
	DoAlternates(Basic,Calculated,RESWP_LASTTHERMAL);
	DoAlternates(Basic,Calculated,RESWP_TEAMMATE);
	DoAlternates(Basic,Calculated,RESWP_FLARMTARGET);
	DoAlternates(Basic,Calculated,HomeWaypoint); 	
	#ifdef GTL2
	if (DoOptimizeRoute() || ACTIVE_WP_IS_AAT_AREA)
		DoAlternates(Basic, Calculated, RESWP_OPTIMIZED);
	#else
	if (DoOptimizeRoute()) DoAlternates(Basic,Calculated,RESWP_OPTIMIZED); 	
	#endif
	for (int i=RESWP_FIRST_MARKER; i<=RESWP_LAST_MARKER; i++) {
		if (WayPointList[i].Latitude==RESWP_INVALIDNUMBER) continue;
		DoAlternates(Basic,Calculated,i);
	}
  #ifndef GTL2
  }
  #else
  } else {
void GlobalReference::updated() {
  // check if a non-default reference has been set
  if (position_.latitude  != Position().latitude)  has_position_ = true;
  if (position_.longitude != Position().longitude) has_position_ = true;
  if (position_.altitude  != Position().altitude)  has_altitude_ = true;
  if (heading_.value      != Heading().value)      has_heading_  = true;

  // WGS84 constants
  static const double equatorial_radius = 6378137.0;
  static const double flattening = 1.0/298.257223563;
  static const double excentrity2 = 2*flattening - flattening*flattening;

  // calculate earth radii
  double temp = 1.0 / (1.0 - excentrity2 * sin(position_.latitude) * sin(position_.latitude));
  double prime_vertical_radius = equatorial_radius * sqrt(temp);
  radius_.north = prime_vertical_radius * (1 - excentrity2) * temp;
  radius_.east  = prime_vertical_radius * cos(position_.latitude);

  // calculate sin and cos of the heading reference
  sincos(heading_.value, &heading_.sin, &heading_.cos);
}
示例#21
0
void ScanForFunctions(CLanguageProxy& proxy)
{
	const char *text = proxy.Text(), *max = text + proxy.Size();
	if (*max != 0)
		return;
	
	while (text < max)
	{
		text = skip(text, '<');
		text = skip_white(text);
		
		switch (toupper(*text))
		{
			case 0:
				return;
			case 'A':
				if (isspace(*++text))
					text = Anchor(text, proxy);
				else
					text = skip_nc(text, '>');
				break;
			case 'H':
				if (*++text >= '1' && *text <= '6')
				{
					text = Heading(text, proxy);
				}
				else
					text = skip_nc(text, '>');
				break;
			case 'S':
				if (strncasecmp(text, "SCRIPT", 6) == 0)
					text = JavaScript(text, proxy);
				break;
			default:
				text = skip_nc(text + 1, '>');
				break;
		}
	}
} /* ScanForFunctions */
示例#22
0
void CUICellItem::Update()
{
	EnableHeading(m_pParentList->GetVerticalPlacement());
	if(Heading())
	{
		SetHeading			( 90.0f * (PI/180.0f) );
		SetHeadingPivot		(Fvector2().set(0.0f,0.0f), Fvector2().set(0.0f,GetWndSize().y), true);
	}else
		ResetHeadingPivot	();

	inherited::Update();
	
	if ( CursorOverWindow() )
	{
		Frect clientArea;
		m_pParentList->GetClientArea(clientArea);
		Fvector2 cp			= GetUICursor().GetCursorPosition();
		if(clientArea.in(cp))
			GetMessageTarget()->SendMessage(this, DRAG_DROP_ITEM_FOCUSED_UPDATE, NULL);
	}
	
	PIItem item = (PIItem)m_pData;
	if ( item )
	{
		m_has_upgrade = item->has_any_upgrades();

//		Fvector2 size      = GetWndSize();
//		Fvector2 up_size = m_upgrade->GetWndSize();
//		pos.x = size.x - up_size.x - 4.0f;
		Fvector2 pos;
		pos.set( m_upgrade_pos );
		if ( ChildsCount() )
		{
			pos.x += m_text->GetWndSize().x + 2.0f;
		}
		m_upgrade->SetWndPos( pos );
	}
	m_upgrade->Show( m_has_upgrade );
}
示例#23
0
 VehicleState(Position pos = Position(), Speed s = Speed(), Heading h = Heading(), 
              Acceleration a = Acceleration(), VehicleSize vsize = VehicleSize()) : 
     position(pos), speed(s), heading(h), acceleration(a), size(vsize) {}
示例#24
0
 static Heading InRadians(double rad) {
   double deg = rad * 180 / cpp::math::PI;
   return Heading((int16_t)(deg/CF));
 }
  void FacilityShadingGridController::addColumns(const QString &category, std::vector<QString> & fields)
  {
    // always show name and selected columns
    // show type next to name, since it comes from the groups
    fields.insert(fields.begin(), { NAME, TYPE, SELECTED });

    m_baseConcepts.clear();

    for (const auto &field : fields) {

      if (field == NAME) {
        addNameLineEditColumn(Heading(QString(NAME), false, false),
          false,
          false,
          CastNullAdapter<model::ShadingSurfaceGroup>(&model::ShadingSurfaceGroup::name),
          CastNullAdapter<model::ShadingSurfaceGroup>(&model::ShadingSurfaceGroup::setName)
          );
      }
      // Evan note: TODO to correctly use this column we need a new control --
      // a dropzone for spaces, and a combo box with site and building as choices
      else if (field == TYPE) {
        std::function<std::vector<std::string>()> choices(
          []() {
          std::vector<std::string> choices{  "Site", "Building", "Space" };
          return choices;
        }
        );

        addComboBoxColumn(Heading(QString(TYPE)),
          std::function<std::string(const std::string &)>(static_cast<std::string(*)(const std::string&)>(&openstudio::toString)),
          choices,
          CastNullAdapter<model::ShadingSurfaceGroup>(&model::ShadingSurfaceGroup::shadingSurfaceType),
          CastNullAdapter<model::ShadingSurfaceGroup>(&model::ShadingSurfaceGroup::setShadingSurfaceType),
          boost::optional<std::function<void(model::ShadingSurfaceGroup*)>>(),
          boost::optional<std::function<bool(model::ShadingSurfaceGroup*)>>()
          );
      }
      else {

        std::function<std::vector<model::ModelObject>(const model::ShadingSurfaceGroup &)> allShadingSurfaces(
          [](const model::ShadingSurfaceGroup &t_shadingSurfaceGroup) {
          std::vector<model::ModelObject> allModelObjects;
          auto shadingSurfaces = t_shadingSurfaceGroup.shadingSurfaces();
          allModelObjects.insert(allModelObjects.end(), shadingSurfaces.begin(), shadingSurfaces.end());
          return allModelObjects;
        }
        );

        if (field == SELECTED) {
          auto checkbox = QSharedPointer<QCheckBox>(new QCheckBox());
          checkbox->setToolTip("Check to select all rows");
          connect(checkbox.data(), &QCheckBox::stateChanged, this, &FacilityShadingGridController::selectAllStateChanged);
          connect(checkbox.data(), &QCheckBox::stateChanged, this->gridView(), &OSGridView::gridRowSelectionChanged);

          addSelectColumn(Heading(QString(SELECTED), false, false, checkbox), "Check to select this row",
            DataSource(
            allShadingSurfaces,
            true
            )
            );
        }
        else if (field == SHADINGSURFACENAME) {
          addLoadNameColumn(Heading(QString(SHADINGSURFACENAME), true, false),
            CastNullAdapter<model::ShadingSurface>(&model::ShadingSurface::name),
            CastNullAdapter<model::ShadingSurface>(&model::ShadingSurface::setName),
            boost::optional<std::function<void(model::ShadingSurface *)>>(
            std::function<void(model::ShadingSurface *)>(
            [](model::ShadingSurface *t_ss)
          {
            t_ss->remove();
          }
            )
            ),
            DataSource(
            allShadingSurfaces,
            true
            )
            );
        }
        else if (field == CONSTRUCTIONNAME) {
          addDropZoneColumn(Heading(QString(CONSTRUCTIONNAME), true, false),
            CastNullAdapter<model::ShadingSurface>(&model::ShadingSurface::construction),
            CastNullAdapter<model::ShadingSurface>(&model::ShadingSurface::setConstruction),
            boost::optional<std::function<void(model::ShadingSurface*)> >(NullAdapter(&model::ShadingSurface::resetConstruction)),
            boost::optional<std::function<bool(model::ShadingSurface*)> >(NullAdapter(&model::ShadingSurface::isConstructionDefaulted)),
            DataSource(
            allShadingSurfaces,
            true
            )
            );
        }
        else if (field == TRANSMITTANCESCHEDULENAME) {
          std::function<bool(model::ShadingSurface *, const model::Schedule &)> setter(
            [](model::ShadingSurface *t_shadingSurface, const model::Schedule &t_schedule) {
            auto copy = t_schedule;
            return t_shadingSurface->setTransmittanceSchedule(copy);
          }
          );

          addDropZoneColumn(Heading(QString(TRANSMITTANCESCHEDULENAME), true, false),
            CastNullAdapter<model::ShadingSurface>(&model::ShadingSurface::transmittanceSchedule),
            setter,
            boost::optional<std::function<void(model::ShadingSurface*)>>(CastNullAdapter<model::ShadingSurface>(&model::ShadingSurface::resetTransmittanceSchedule)),
            boost::optional<std::function<bool(model::ShadingSurface*)> >(),
            DataSource(
            allShadingSurfaces,
            true
            )
            );
        }
        else {
          // unhandled
          OS_ASSERT(false);
        }
      }
    }
  }
示例#26
0
bool CXbowDriver::GetData()
{

    //here we actually access serial ports etc
    if(m_pPort->IsStreaming())
    {
        MOOSTrace("Crossbow must not be streaming\n");
        return false;
    }
    
    //ask the crossbow for a reading
    m_pPort->Write("G",1);
    
    string sWhat;
    unsigned char Reply[CROSSBOW_POLLED_ANGLE_MODE_REPLY_LENGTH];
    
    //note local call back invoked here to specify termination
    int nRead = m_pPort->ReadNWithTimeOut((char*)Reply,sizeof(Reply));

    
    if(nRead == CROSSBOW_POLLED_ANGLE_MODE_REPLY_LENGTH)
    {
        if(Reply[0]!=255)
        {
            MOOSTrace("Unexpected Header in CrossBow reply\n");
        }
		
	//angles
        short nRoll  = (Reply[1]<<8) + Reply[2];
        short nPitch = (Reply[3]<<8) + Reply[4];
        short nYaw   = (Reply[5]<<8) + Reply[6];

	//This is roll, pitch and yaw for the DMU-AHRS, which is rotated
	//relative to the vehicle body. It has Z down and X out the tail.
        double df_deg_CBRoll   = nRoll*180.0/pow(2.0,15.0);
        double df_deg_CBPitch  = nPitch*180.0/pow(2.0,15.0);
        double df_deg_CBYaw    = nYaw*180.0/pow(2.0,15.0);
		
        //account for alignment of crossbow in vehicle frame
        //this is the angle measured from the vehicle center line(y)
        double dfHeading = df_deg_CBYaw+m_dfVehicleYToINSX;
        
        //now correct for magnetic offset
        dfHeading+=m_dfMagneticOffset;
        
        //convert to Yaw..
	//Notice that Heading is in DEGREES, positive CLOCKWISE
	//while Yaw is in RADIANS, positive COUNTERCLOCKWISE
        double dfYaw = -dfHeading*PI/180.0;
        dfYaw = MOOS_ANGLE_WRAP(dfYaw);
        
		
	//initialise transformed angles (in degrees)
	double df_deg_TRoll  = df_deg_CBRoll;
	double df_deg_TPitch = df_deg_CBPitch;
		
	if( m_dfVehicleYToINSX == 0 )
	{
	    //Crossbow roll and vehicle body roll match.
	    df_deg_TRoll = df_deg_TRoll;
	    //same for Pitch.
	    df_deg_TPitch = df_deg_TPitch;
	}
	else if (m_dfVehicleYToINSX == 180)
	{
	    df_deg_TRoll = -df_deg_TRoll;
	    df_deg_TPitch = -df_deg_TPitch;
	}
	else
	{
	    MOOSTrace("Bad 'TWIST' value (use 0 or 180)!\r\n");
	    return false;
	}
		
        //look after pitch
        double dfPitch = MOOSDeg2Rad(df_deg_TPitch);
        
        //look after roll
        double dfRoll = MOOSDeg2Rad(df_deg_TRoll);
        
        
        //find the temperature every so often
        m_nTempCnt++;

        if((m_nTempCnt % 100) == 0)
        {
            short nTemp   = ( Reply[25] << 8 ) + Reply[26];
            m_dfTemp = 44.4 * ( ((double)nTemp * 5.0/4096.0) - 1.375); 
            CMOOSMsg Temperature(MOOS_NOTIFY, "INS_TEMPERATURE", m_dfTemp);
	    m_Notifications.push_back(Temperature);
        }
        
        //notify the MOOS
        CMOOSMsg Heading(MOOS_NOTIFY, "INS_HEADING", dfHeading);
	m_Notifications.push_back(Heading);
	CMOOSMsg Yaw(MOOS_NOTIFY, "INS_YAW", dfYaw);
	m_Notifications.push_back(Yaw);
	CMOOSMsg Pitch(MOOS_NOTIFY, "INS_PITCH", dfPitch);
	m_Notifications.push_back(Pitch);
	CMOOSMsg Roll(MOOS_NOTIFY, "INS_ROLL", dfRoll);
	m_Notifications.push_back(Roll);
		
	//rates
	short nRollRate  = (Reply[7]<<8) + Reply[8];//p-dot
        short nPitchRate = (Reply[9]<<8) + Reply[10];//q-dot
        short nYawRate   = (Reply[11]<<8) + Reply[12];//r-dot

	//xbow calib constant
	double RR = 100.0;//deg/sec

	double dfRollRate  = nRollRate * RR * 1.5/pow(2.0,15);
	double dfPitchRate = nPitchRate * RR * 1.5/pow(2.0,15);
	double dfYawRate   = nYawRate * RR * 1.5/pow(2.0,15);

	//note X and Y axes are switched
	CMOOSMsg RollRate(MOOS_NOTIFY, "INS_ROLLRATE_Y", dfRollRate);
	m_Notifications.push_back(RollRate);
	CMOOSMsg PitchRate(MOOS_NOTIFY, "INS_ROLLRATE_X", dfPitchRate);
	m_Notifications.push_back(PitchRate);
	CMOOSMsg YawRate(MOOS_NOTIFY, "INS_ROLLRATE_Z", dfYawRate);
	m_Notifications.push_back(YawRate);

	//accelerations
        short nXAccel = (Reply[13]<<8) + Reply[14];//v-dot
        short nYAccel = (Reply[15]<<8) + Reply[16];//u-dot
        short nZAccel = (Reply[17]<<8) + Reply[18];//w-dot
		
	//xbow calib constant
	double GR = 2.0;//G's
	double dfXAccel = nXAccel * GR * 1.5/pow(2.0,15);
	double dfYAccel = nYAccel * GR * 1.5/pow(2.0,15);
	double dfZAccel = nZAccel * GR * 1.5/pow(2.0,15);

	//note X and Y axes are switched
	CMOOSMsg XAccel(MOOS_NOTIFY, "INS_ACCEL_Y", dfXAccel);
	m_Notifications.push_back(XAccel);
	CMOOSMsg YAccel(MOOS_NOTIFY, "INS_ACCEL_X", dfYAccel);
	m_Notifications.push_back(YAccel);
	CMOOSMsg ZAccel(MOOS_NOTIFY, "INS_ACCEL_Z", dfZAccel);
	m_Notifications.push_back(ZAccel);
		

	//magnetic field data
	short nXMag = (Reply[19]<<8) + Reply[20];
        short nYMag = (Reply[21]<<8) + Reply[22];
        short nZMag = (Reply[23]<<8) + Reply[24];

	double dfGaussX = nXMag * 1.25 * 1.5/pow(2.0,15.0);
	double dfGaussY = nYMag * 1.25 * 1.5/pow(2.0,15.0);
	double dfGaussZ = nZMag * 1.25 * 1.5/pow(2.0,15.0);

	CMOOSMsg GaussX(MOOS_NOTIFY, "INS_MAG_Y", dfGaussX);
	m_Notifications.push_back(GaussX);
	CMOOSMsg GaussY(MOOS_NOTIFY, "INS_MAG_X", dfGaussY);
	m_Notifications.push_back(GaussY);
	CMOOSMsg GaussZ(MOOS_NOTIFY, "INS_MAG_Z", dfGaussZ);
	m_Notifications.push_back(GaussZ);

        
        if(m_pPort->IsVerbose())
        {
            //this allows us to print data in verbose mode
            //when teh port couldn't as it is verbose
            MOOSTrace("Roll = %7.3f Pitch = %7.3f Yaw = %7.3f Heading = %7.3f Temp = %3.2f\n",
		      df_deg_TRoll,
		      df_deg_TPitch,
		      dfYaw*180/PI,
		      dfHeading,
		      m_dfTemp);
        }
        
    }
    else
    {
	MOOSTrace("read %d byte while expecting %d\n",
		  nRead,
		  CROSSBOW_POLLED_ANGLE_MODE_REPLY_LENGTH);
    }
    
    return true;
    
}
示例#27
0
 /** Set the heading in degrees from North */
 static Heading InDegrees(double deg) {
   return Heading((int16_t)(deg/CF));
 }
int main ()	{

	textmode (ATC_TEXT_MODE);
	clrscr();

	Position::MaxX = 30;
	Position::MaxY = 30;



	char pid;

	Position::MaxX = 30;
	Position::MaxY = 30;

	RadarScreen *r;
	Landmarks l;

	Traffic t;
	Plane *p1;
	Gate g (Position  (0,  10), 1, D90);
	Gate g1 (Position (0,  0),  2, D45);
	Gate g2 (Position (10, 0),  3, D0);
	Gate g3 (Position (MAX_X, MAX_Y), 4, D225);
//	Gate g4 (Position (10, 0), 4, D0);
	Airport a1 (Position (5, 5), 1, Heading (D90));
	Airport a2 (Position (10, 12), 2, Heading (D45));
	Beacon b1 (Position (7,13), 1);
	Beacon b2 (Position (1,1), 2);
	FlightPath fp (Position (MIN_FIELD_X, MIN_FIELD_Y),
		Position (MAX_FIELD_X, MAX_FIELD_Y));

	FlightPath fp1 (Position (MIN_FIELD_X, MAX_FIELD_Y),
		Position (MAX_FIELD_X, MIN_FIELD_Y));

	FlightPath fp2 (Position (10, 1), Position (10, MAX_FIELD_Y));

	int i;

	l.AddAirport (&a1);

	l.AddAirport (&a2);
	l.AddBeacon (&b1);
	l.AddBeacon (&b2);
	l.AddGate (&g);
	l.AddGate (&g1);
	l.AddGate (&g2);
	l.AddGate (&g3);
//	l.AddGate (&g4);
	l.AddFlightPath (&fp);
	l.AddFlightPath (&fp1);
	l.AddFlightPath (&fp2);

	r = new RadarScreen (&l);

	Boolean Crashed = False;

	r->Refresh();

	pid = t.NewId();

	p1 = new Plane (pid, g.NewPlaneCoords(), Prop, &g1);

	t.NewAirborne (p1);

	p1 = new Plane (t.NewId(), g1.NewPlaneCoords(), Jet, &g);

	t.NewAirborne (p1);


	p1 = new Plane (t.NewId(), g2.NewPlaneCoords(), Jet, &g);

	t.NewAirborne (p1);

	r->DisplayPlanes (&t);

	for (i = 0; i < 34; i++) {
		delay (500);


		if (i == 17)	{
			t.SearchAirborne ('a');
			t.FoundAirborne() -> AlterTargHeading (D270, AntiClockwise);

			t.SearchAirborne ('b');
			t.FoundAirborne() -> MakeCircle (AntiClockwise);
		}
		r->UnDisplayPlanes (&t);

		if (i % 2 == 0)	{
			t.StepJets();
		} else {
			t.StepAll();
		}

		r->DisplayPlanes (&t);

		if (!Crashed && t.Crashed ())	{
				cout << '\a';
			Crashed = True;
		}

	}

	textmode (C80);
	_setcursortype (_NORMALCURSOR);
	clrscr();

	return 0;
}
  void SpacesInteriorPartitionsGridController::addColumns(const QString &category, std::vector<QString> & fields)
  {
    // always show name and selected columns
    fields.insert(fields.begin(), { NAME, SELECTED });

    m_baseConcepts.clear();

    for (const auto &field : fields) {

      if (field == NAME) {
        addNameLineEditColumn(Heading(QString(NAME), false, false),
          false,
          false,
          CastNullAdapter<model::Space>(&model::Space::name),
          CastNullAdapter<model::Space>(&model::Space::setName)
          );
      }
      else {

          std::function<std::vector<model::ModelObject>(const model::Space &)> allInteriorPartitionSurfaceGroups(
            [](const model::Space &t_space) {
            std::vector<model::ModelObject> allModelObjects;
            auto interiorPartitionSurfaceGroups = t_space.interiorPartitionSurfaceGroups();
            allModelObjects.insert(allModelObjects.end(), interiorPartitionSurfaceGroups.begin(), interiorPartitionSurfaceGroups.end());
            return allModelObjects;
          }
          );

          std::function<std::vector<model::ModelObject>(const model::Space &)> allInteriorPartitionSurfaces(
            [allInteriorPartitionSurfaceGroups](const model::Space &t_space) {
            std::vector<model::ModelObject> allModelObjects;
            for (auto interiorPartitionSurfaceGroup : allInteriorPartitionSurfaceGroups(t_space)) {
              auto interiorPartitionSurfaces = interiorPartitionSurfaceGroup.cast<model::InteriorPartitionSurfaceGroup>().interiorPartitionSurfaces();
              for (auto interiorPartitionSurface : interiorPartitionSurfaces) {
                allModelObjects.push_back(interiorPartitionSurface);
              }
            }
            return allModelObjects;
          }
          );

          std::function<std::vector<boost::optional<model::ModelObject> >(const model::Space &)> allInteriorPartitionSurfaceInteriorPartitionSurfaceGroups(
            [allInteriorPartitionSurfaceGroups](const model::Space &t_space) {
            std::vector<boost::optional<model::ModelObject> > allModelObjects;
            for (auto interiorPartitionSurfaceGroup : allInteriorPartitionSurfaceGroups(t_space)) {
              auto interiorPartitionSurfaces = interiorPartitionSurfaceGroup.cast<model::InteriorPartitionSurfaceGroup>().interiorPartitionSurfaces();
              for (auto interiorPartitionSurface : interiorPartitionSurfaces) {
                auto group = interiorPartitionSurface.interiorPartitionSurfaceGroup();
                if (group) {
                  allModelObjects.push_back(*group);
                }
                else {
                  allModelObjects.emplace_back();
                }
              }
            }
            return allModelObjects;
          }
          );

        if (field == SELECTED) {
          auto checkbox = QSharedPointer<QCheckBox>(new QCheckBox());
          checkbox->setToolTip("Check to select all rows");
          connect(checkbox.data(), &QCheckBox::stateChanged, this, &SpacesInteriorPartitionsGridController::selectAllStateChanged);
          connect(checkbox.data(), &QCheckBox::stateChanged, this->gridView(), &OSGridView::gridRowSelectionChanged);

          addSelectColumn(Heading(QString(SELECTED), false, false, checkbox), "Check to select this row",
            DataSource(
            allInteriorPartitionSurfaces,
            true
            )
            );
        }
        else if (field == INTERIORPARTITIONGROUPNAME) {
          addNameLineEditColumn(Heading(QString(INTERIORPARTITIONGROUPNAME), true, false),
            false,
            false,
            CastNullAdapter<model::InteriorPartitionSurfaceGroup>(&model::InteriorPartitionSurfaceGroup::name),
            CastNullAdapter<model::InteriorPartitionSurfaceGroup>(&model::InteriorPartitionSurfaceGroup::setName),
            boost::optional<std::function<void(model::InteriorPartitionSurfaceGroup *)>>(),
            DataSource(
            allInteriorPartitionSurfaceInteriorPartitionSurfaceGroups,
            true)
            );
        }
        else if (field == INTERIORPARTITIONNAME) {
          addNameLineEditColumn(Heading(QString(INTERIORPARTITIONNAME), true, false),
          false,
          false,
          CastNullAdapter<model::InteriorPartitionSurface>(&model::InteriorPartitionSurface::name),
          CastNullAdapter<model::InteriorPartitionSurface>(&model::InteriorPartitionSurface::setName),
          boost::optional<std::function<void(model::InteriorPartitionSurface *)>>(),
          DataSource(
          allInteriorPartitionSurfaces,
          true)
          );
        }
        else if (field == CONSTRUCTIONNAME) {
          m_constructionColumn = 4;
          addDropZoneColumn(Heading(QString(CONSTRUCTIONNAME), true, false),
            CastNullAdapter<model::InteriorPartitionSurface>(&model::InteriorPartitionSurface::construction),
            CastNullAdapter<model::InteriorPartitionSurface>(&model::InteriorPartitionSurface::setConstruction),
            boost::optional<std::function<void(model::InteriorPartitionSurface*)> >(NullAdapter(&model::InteriorPartitionSurface::resetConstruction)),
            boost::optional<std::function<bool(model::InteriorPartitionSurface*)> >(NullAdapter(&model::InteriorPartitionSurface::isConstructionDefaulted)),
            DataSource(
            allInteriorPartitionSurfaces,
            true
            )
            );
        }
        else if (field == CONVERTTOINTERNALMASS) {
          addCheckBoxColumn(Heading(QString(CONVERTTOINTERNALMASS), true, false),
            std::string("Check to enable convert to InternalMass."),
            NullAdapter(&model::InteriorPartitionSurface::converttoInternalMass),
            NullAdapter(&model::InteriorPartitionSurface::setConverttoInternalMass),
            DataSource(
            allInteriorPartitionSurfaces,
            true
            )
            );
        }
        else if (field == SURFACEAREA) {
          std::function<bool(model::InteriorPartitionSurface *, double)> setter(
            [](model::InteriorPartitionSurface *t_interiorPartitionSurface, double t_arg) {
            return t_interiorPartitionSurface->setSurfaceArea(t_arg);
          }
          );

          addValueEditColumn(Heading(QString(SURFACEAREA)),
            CastNullAdapter<model::InteriorPartitionSurface>(&model::InteriorPartitionSurface::surfaceArea),
            setter//,
            //boost::optional<std::function<void(model::ModelObject *)>>(),
            //boost::optional<std::function<bool(model::ModelObject *)>>()//,
            //DataSource(
            //allInteriorPartitionSurfaces,
            //true
            //)
            );

          //boost::optional<double> surfaceArea() const; // TODO this optional is causing troubles
          //bool setSurfaceArea(boost::optional<double> surfaceArea);
          //bool setSurfaceArea(double surfaceArea);
          //void resetSurfaceArea();

        }
        else if (field == DAYLIGHTINGSHELFNAME) {
          //boost::optional<DaylightingDeviceShelf> daylightingDeviceShelf() const;

        }
        else {
          // unhandled
          OS_ASSERT(false);
        }
      }
    }
  }
示例#30
0
bool DoCalculations(NMEA_INFO *Basic, DERIVED_INFO *Calculated)
{

  // first thing: assign navaltitude!
  EnergyHeightNavAltitude(Basic, Calculated);

  // second thing: if available, get external wind precalculated!
  if ( (Basic->ExternalWindAvailable==TRUE) && (AutoWindMode==D_AUTOWIND_EXTERNAL)) {
	if (Basic->ExternalWindSpeed>0 && Basic->ExternalWindSpeed<35) {
		Calculated->WindSpeed = Basic->ExternalWindSpeed;
		Calculated->WindBearing = Basic->ExternalWindDirection;
	}
  }

  Heading(Basic, Calculated);
  DistanceToNext(Basic, Calculated);
  DistanceToHome(Basic, Calculated);
  DetectFreeFlying(Basic,Calculated);	// check ongoing powerless flight
  DoLogging(Basic, Calculated);
  TerrainHeight(Basic, Calculated);
  AltitudeRequired(Basic, Calculated, MACCREADY);
  DoAlternates(Basic,Calculated,TASKINDEX); 
  if (IsMultiMapShared()) {
    DoAlternates(Basic,Calculated,RESWP_LASTTHERMAL);
    DoAlternates(Basic,Calculated,RESWP_TEAMMATE);
    DoAlternates(Basic,Calculated,RESWP_FLARMTARGET);
    DoAlternates(Basic,Calculated,HomeWaypoint);

    if (DoOptimizeRoute() || ACTIVE_WP_IS_AAT_AREA) {
      DoAlternates(Basic, Calculated, RESWP_OPTIMIZED);
    }

    for (int i=RESWP_FIRST_MARKER; i<=RESWP_LAST_MARKER; i++) {
      if (WayPointList[i].Latitude==RESWP_INVALIDNUMBER) continue;
      DoAlternates(Basic,Calculated,i);
    }
  } else {
    // The following is needed only for the next-WP glide terrain line,
    // not for the main/primary glide terrain line.

    if ((FinalGlideTerrain > 2) && (DoOptimizeRoute() || ACTIVE_WP_IS_AAT_AREA))
      DoAlternates(Basic, Calculated, RESWP_OPTIMIZED);
  }

  if (!TargetDialogOpen) {
    // don't calculate these if optimise function being invoked or
    // target is being adjusted
    TaskStatistics(Basic, Calculated, MACCREADY);
    AATStats(Basic, Calculated);  
    TaskSpeed(Basic, Calculated, MACCREADY);
  }

  if (!FlightTimes(Basic, Calculated)) {
    // time hasn't advanced, so don't do calculations requiring an advance
    // or movement
    return false;
  }

  Turning(Basic, Calculated);
  LD(Basic,Calculated);
  CruiseLD(Basic,Calculated);

  // We calculate flaps settings only if the polar is extended.
  // We do assume that GA planes will NOT use extended polars
  if (GlidePolar::FlapsPosCount >0) Flaps(Basic,Calculated);

  Calculated->AverageLD=CalculateLDRotary(&rotaryLD,Basic,Calculated); 
  Average30s(Basic,Calculated);
  AverageThermal(Basic,Calculated);
  AverageClimbRate(Basic,Calculated);
  ThermalGain(Basic,Calculated);
  LastThermalStats(Basic, Calculated);
  //  ThermalBand(Basic, Calculated); moved to % circling function
  MaxHeightGain(Basic,Calculated);

  PredictNextPosition(Basic, Calculated);

  if (Orbiter) CalculateOrbiter(Basic,Calculated);

  CalculateOwnTeamCode(Basic, Calculated);
  CalculateTeammateBearingRange(Basic, Calculated);

  BallastDump();

  // reminder: Paragliders have AAT always on
  CalculateOptimizedTargetPos(Basic,Calculated);

  if (ValidTaskPoint(ActiveTaskPoint)) {
	// only if running a real task
	if (ValidTaskPoint(1)) InSector(Basic, Calculated);
	DoAutoMacCready(Basic, Calculated);
	#ifdef DEBUGTASKSPEED
	DebugTaskCalculations(Basic, Calculated);
	#endif
  } else { // 101002
	DoAutoMacCready(Basic, Calculated); // will set only EqMC 
  }

  DoAlternates(Basic, Calculated,Alternate1); 
  DoAlternates(Basic, Calculated,Alternate2); 
  DoAlternates(Basic, Calculated,BestAlternate); 

  // Calculate nearest waypoints when needed
  if ( !MapWindow::mode.AnyPan() && DrawBottom && (MapSpaceMode>MSM_MAP) ) {
	switch(MapSpaceMode) {
		case MSM_LANDABLE:
		case MSM_AIRPORTS:
		case MSM_NEARTPS: // 101222
			DoNearest(Basic,Calculated);
			break;
		case MSM_COMMON:
			DoCommon(Basic,Calculated);
			break;
		case MSM_RECENT:
			DoRecent(Basic,Calculated);
			break;
		case MSM_VISUALGLIDE:
			// Only if visualglide is really painted: topview is not fullscreen.
			if (Current_Multimap_SizeY<SIZE4) {
				DoNearest(Basic,Calculated);
			}
			break;
	}
  }

  CalculateHeadWind(Basic,Calculated);

  ConditionMonitorsUpdate(Basic, Calculated);

  return true;
}