C++ GetX函数代码示例

void Line::SetY(double y) { SetPosition(GetX(), y); }

/// Recalculate when each unit will arrive at the current army position, whatever that is
void CvArmyAI::UpdateCheckpointTurnsAndRemoveBadUnits()
{
	CvAIOperation* pOperation = GET_PLAYER(GetOwner()).getAIOperation(GetOperationID());
	//should be updated before calling this ...
	CvPlot* pCurrentArmyPlot = GC.getMap().plot(GetX(), GetY());

	//kick out damaged units, but if we're defending or escorting, no point in running away
	if (pOperation->IsOffensive())
	{
		for (unsigned int iI = 0; iI < m_FormationEntries.size(); iI++)
		{
			if (!m_FormationEntries[iI].IsUsed())
				continue;

			CvUnit* pUnit = GET_PLAYER(m_eOwner).getUnit(m_FormationEntries[iI].m_iUnitID);
			if (pUnit == NULL)
				continue;

			//failsafe - make sure the army ID is set
			if (pUnit->getArmyID() != GetID())
				pUnit->setArmyID(GetID());

			//let tactical AI handle those
			if (pUnit->GetCurrHitPoints() < pUnit->GetMaxHitPoints() / 3)
				RemoveUnit(m_FormationEntries[iI].GetUnitID());
		}
	}

	//update for all units in this army. ignore the ones still being built
	int iGatherTolerance = pOperation->GetGatherTolerance(this, pCurrentArmyPlot);
	for(unsigned int iI = 0; iI < m_FormationEntries.size(); iI++)
	{
		if (!m_FormationEntries[iI].IsUsed())
			continue;

		CvUnit* pUnit = GET_PLAYER(m_eOwner).getUnit(m_FormationEntries[iI].GetUnitID());
		if(pUnit && pCurrentArmyPlot)
		{
			if(plotDistance(*pUnit->plot(),*pCurrentArmyPlot)<iGatherTolerance)
			{
				m_FormationEntries[iI].SetTurnsToCheckpoint(0);
			}
			else
			{
				//be generous with the flags here, for some ops the muster point may be far away and intermittendly occupied by foreign units ...
				int iFlags = CvUnit::MOVEFLAG_APPROX_TARGET_RING2 | CvUnit::MOVEFLAG_IGNORE_STACKING | CvUnit::MOVEFLAG_IGNORE_ZOC;
				int iTurnsToReachCheckpoint = pUnit->TurnsToReachTarget(pCurrentArmyPlot, iFlags, pOperation->GetMaximumRecruitTurns());

				//if we're already moving to target, the current army plot is moving, so we cannot check progress against ...
				if ( iTurnsToReachCheckpoint==INT_MAX ||
					 (GetArmyAIState()==ARMYAISTATE_WAITING_FOR_UNITS_TO_CATCH_UP && !m_FormationEntries[iI].IsMakingProgressTowardsCheckpoint(iTurnsToReachCheckpoint)) )
				{
					CvString strMsg;
					strMsg.Format("Removing %s %d from army %d because no progress to checkpoint (%d:%d). ETA %d, previously %d.", 
						pUnit->getName().c_str(), m_FormationEntries[iI].GetUnitID(), GetID(), pCurrentArmyPlot->getX(), pCurrentArmyPlot->getY(),
						iTurnsToReachCheckpoint, m_FormationEntries[iI].m_iPrevEstimatedTurnsToCheckpoint);
					pOperation->LogOperationSpecialMessage(strMsg);
					RemoveUnit(m_FormationEntries[iI].GetUnitID());
				}
				else
					m_FormationEntries[iI].SetTurnsToCheckpoint(iTurnsToReachCheckpoint);
			}
		}
	}
}

void Sprite::ScaleToClipped( float fWidth, float fHeight )
{
	m_fRememberedClipWidth = fWidth;
	m_fRememberedClipHeight = fHeight;

	if( !m_pTexture )
		return;

	int iSourceWidth	= m_pTexture->GetSourceWidth();
	int iSourceHeight	= m_pTexture->GetSourceHeight();

	// save the original X&Y.  We're going to resore them later.
	float fOriginalX = GetX();
	float fOriginalY = GetY();

	if( IsDiagonalBanner(iSourceWidth, iSourceHeight) )		// this is a SSR/DWI CroppedSprite
	{
		float fCustomImageCoords[8] = {
			0.02f,	0.78f,	// top left
			0.22f,	0.98f,	// bottom left
			0.98f,	0.22f,	// bottom right
			0.78f,	0.02f,	// top right
		};
		Sprite::SetCustomImageCoords( fCustomImageCoords );

		if( fWidth != -1 && fHeight != -1)
			m_size = RageVector2( fWidth, fHeight );
		else
		{
			/* If no crop size is set, then we're only being used to crop diagonal
			 * banners so they look like regular ones. We don't actually care about
			 * the size of the image, only that it has an aspect ratio of 4:1.  */
			m_size = RageVector2(256, 64);
		}
		SetZoom( 1 );
	}
	else if( m_pTexture->GetID().filename.find( "(was rotated)" ) != m_pTexture->GetID().filename.npos && 
			 fWidth != -1 && fHeight != -1 )
	{
		/* Dumb hack.  Normally, we crop all sprites except for diagonal banners,
		 * which are stretched.  Low-res versions of banners need to do the same
		 * thing as their full resolution counterpart, so the crossfade looks right.
		 * However, low-res diagonal banners are un-rotated, to save space.  BannerCache
		 * drops the above text into the "filename" (which is otherwise unused for
		 * these banners) to tell us this.
		 */
		Sprite::StopUsingCustomCoords();
		m_size = RageVector2( fWidth, fHeight );
		SetZoom( 1 );
	}
	else if( fWidth != -1 && fHeight != -1 )
	{
		// this is probably a background graphic or something not intended to be a CroppedSprite
		Sprite::StopUsingCustomCoords();

		// first find the correct zoom
		Sprite::ScaleToCover( RectF(0,0,fWidth,fHeight) );
		// find which dimension is larger
		bool bXDimNeedsToBeCropped = GetZoomedWidth() > fWidth+0.01;
		
		if( bXDimNeedsToBeCropped )	// crop X
		{
			float fPercentageToCutOff = (this->GetZoomedWidth() - fWidth) / this->GetZoomedWidth();
			float fPercentageToCutOffEachSide = fPercentageToCutOff / 2;
			
			// generate a rectangle with new texture coordinates
			RectF fCustomImageRect( 
				fPercentageToCutOffEachSide, 
				0, 
				1 - fPercentageToCutOffEachSide, 
				1 );
			SetCustomImageRect( fCustomImageRect );
		}
		else		// crop Y
		{
			float fPercentageToCutOff = (this->GetZoomedHeight() - fHeight) / this->GetZoomedHeight();
			float fPercentageToCutOffEachSide = fPercentageToCutOff / 2;
			
			// generate a rectangle with new texture coordinates
			RectF fCustomImageRect( 
				0, 
				fPercentageToCutOffEachSide,
				1, 
				1 - fPercentageToCutOffEachSide );
			SetCustomImageRect( fCustomImageRect );
		}
		m_size = RageVector2( fWidth, fHeight );
		SetZoom( 1 );
	}

	// restore original XY
	SetXY( fOriginalX, fOriginalY );
}

/************************************************************************
 Function: void AnimateText(BYTE mov)
                                                                       
 Overview: Routine to move or animate the text.
  		                                         
 Input: mov - number of pixels the text will be moved
                                                                       
 Output: none
************************************************************************/
void AnimateText(BYTE mov)
{
    static SHORT    xPos = STXXPOS, yPos = STXYPOS;
    static SHORT    x, y;
    SHORT           width;
    SHORT           height;

    SHORT           newX, newY, oldX, oldY;
    XCHAR           NewChar, *pString;

    // set the clipping region
    SetClip(CLIP_ENABLE);
    SetClipRgn(STXXPOS + 2, STXYPOS + 2, STXXPOS + STXWIDTH - 2, STXYPOS + STXHEIGHT - 2);

    // set the font
    SetFont(pHWData->pHWFont);

    // calculate string width & height	
    width = GetTextWidth((XCHAR *)pHWData->pHWStr, pHWData->pHWFont);
    height = GetTextHeight(pHWData->pHWFont);

    //-----------------------------------------------------------------
    // interlace the erasing and printing of characters
    // check first if we need to move in the positive or negative direction
    if((xPos + width) >= (STXXPOS + STXWIDTH))
        x = -(mov);
    if(xPos <= (STXXPOS))
        x = (mov);

    if((yPos + height) >= (STXYPOS + STXHEIGHT))
        y = -(mov);
    if(yPos <= (STXYPOS))
        y = (mov);

    pString = pHWData->pHWStr;
    oldX = xPos;
    oldY = yPos;
    newX = xPos + x;
    newY = yPos + y;
    while((XCHAR)15 < (XCHAR)(NewChar = *pString++))
    {

        // remove the old position of the character
        SetColor(FontScheme2->CommonBkColor);
        MoveTo(oldX, oldY);
        WAIT_UNTIL_FINISH(OutChar(NewChar));
        oldX = GetX();
        oldY = GetY();

        // display the character in the new position
        SetColor(BRIGHTBLUE);
        MoveTo(newX, newY);
        WAIT_UNTIL_FINISH(OutChar(NewChar));
        newX = GetX();
        newY = GetY();
    }

    xPos += x;
    yPos += y;

    // disable the clipping
    SetClip(CLIP_DISABLE);
}

// solar: if lifetime is 0 this is a permanent beacon.. not sure if that'll be
// useful for anything
Beacon::Beacon(Mob *at_mob, int lifetime)
:Mob
(
	nullptr, nullptr, 0, 0, 0, INVISIBLE_MAN, 0, BT_NoTarget, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
),
		remove_timer(lifetime),
		spell_timer(0)
{
	remove_timer.Disable();
	spell_timer.Disable();
	remove_me = false;
	spell_id = 0xFFFF;
	resist_adjust = 0;
	spell_iterations = 0;
	caster_id = 0;

	// copy location
	x_pos = at_mob->GetX();
	y_pos = at_mob->GetY();
	z_pos = at_mob->GetZ();
	heading = at_mob->GetHeading();

	if(lifetime)
	{
		remove_timer.Start();
	}
#ifdef SOLAR
	entity_list.Message(0, 0, "Beacon being created at %0.2f %0.2f %0.2f heading %0.2f lifetime %d", GetX(), GetY(), GetZ(), GetHeading(), lifetime);
#endif
}

/*****************************************
 *int main (void)
 *****************************************/
int main (void)
{
    InitializeHardware();
    HardwareButtonInit();
    InitAllLEDs();
    
#ifdef USE_BISTABLE_DISPLAY_GOL_AUTO_REFRESH     
	GFX_DRIVER_AutoUpdPart();		// Turn on widget auto update, partial update for less flashing
#endif
    
    InitTick();
	GOLInit();

    SetColor(WHITE);
    ClearDevice();

	// Set proper display rotation
#if(DISP_ORIENTATION == 90)
    GFX_DRIVER_InitRotmode(ROTATE_90);
#else
#error "This PICTail display orientation must be 90."
#endif
       
	// make sure that the correct hex file is loaded
    CheckExternalFlashHex();

	// Create cursor in GFX_CURSOR_LAYER with Alpha Color = 0xA
	GFX_DRIVER_CreateLayer( GFX_CURSOR_LAYER, GFX_LAYER_TRANS_EN | 0xA, GetX(), GetY(), GetX() + 31, GetY() + 31 );
	GFX_DRIVER_ActivateLayer( GFX_CURSOR_LAYER );
	PutImage(0, 0, (void *)&mouse_cursor_icon_270, IMAGE_NORMAL); 
	GFX_DRIVER_ActivateLayer( GFX_MAIN_LAYER );
	
	// Start demo screen 
	demoScreens = DEMO_INTRO_SCREEN_CREATE;
	
    while(1)
	{
        GOLDraw();
#ifndef USE_BISTABLE_DISPLAY_GOL_AUTO_REFRESH
	#if defined( ONE_CYCLE_DRAWING	) 
		// The screen drawing starts and completes during one while(1) cycle loop in main().
		// This Demo is one cycle drawing application.
        if ( GFX_DRIVER_IsUpdateRequested() || (g_UPDATE_FLAGS == GFX_UPDATE_AS_IT_DRAWS) )
        {
	    	GFX_DRIVER_UpdateEpd( g_UPDATE_FLAGS, 0, 0, GetMaxX(), GetMaxY() ); 
	    	g_UPDATE_FLAGS = GFX_UPDATE_NO_FLASH | GFX_WAIT_IMAGE_DISPLAYED;   
	    }
	#else
		// This way can be used when drawing may take few or more cycles of while(1) loop in main().
		// See "tick.c" file for details.
        if ( g_UpdateNow || (g_UPDATE_FLAGS == GFX_UPDATE_AS_IT_DRAWS) )
        {
	        g_UpdateNow = 0;
	    	GFX_DRIVER_UpdateEpd( g_UPDATE_FLAGS, 0, 0, GetMaxX(), GetMaxY() ); 
	    	g_UPDATE_FLAGS = GFX_UPDATE_NO_FLASH | GFX_WAIT_IMAGE_DISPLAYED;   
	    }	
	#endif
#endif		 
	}	

    return (-1);
}

/**\brief Slider mouse down call back.
 */
bool Slider::MouseLUp( int xi, int yi ){
	this->SetVal(this->PixelToVal(xi - GetX()));
	Widget::MouseLDown( xi, yi );;
	if(OPTION(int, "options/sound/buttons")) UI::beep->Play();
	return true;
}

void CGSH_Direct3D9::SetRenderingContext(uint64 primReg)
{
	auto prim = make_convertible<PRMODE>(primReg);

	unsigned int context = prim.nContext;

	uint64 testReg = m_nReg[GS_REG_TEST_1 + context];
	uint64 frameReg = m_nReg[GS_REG_FRAME_1 + context];
	uint64 alphaReg = m_nReg[GS_REG_ALPHA_1 + context];
	uint64 zbufReg = m_nReg[GS_REG_ZBUF_1 + context];
	uint64 tex0Reg = m_nReg[GS_REG_TEX0_1 + context];
	uint64 tex1Reg = m_nReg[GS_REG_TEX1_1 + context];
	uint64 clampReg = m_nReg[GS_REG_CLAMP_1 + context];
	uint64 scissorReg = m_nReg[GS_REG_SCISSOR_1 + context];

	if(!m_renderState.isValid ||
		(m_renderState.primReg != primReg))
	{
		m_device->SetRenderState(D3DRS_ALPHABLENDENABLE, ((prim.nAlpha != 0) && m_alphaBlendingEnabled) ? TRUE : FALSE);
	}

	if(!m_renderState.isValid ||
		(m_renderState.alphaReg != alphaReg))
	{
		SetupBlendingFunction(alphaReg);
	}

	if(!m_renderState.isValid ||
		(m_renderState.testReg != testReg))
	{
		SetupTestFunctions(testReg);
	}

	if(!m_renderState.isValid ||
		(m_renderState.zbufReg != zbufReg) ||
		(m_renderState.frameReg != frameReg))
	{
		SetupDepthBuffer(zbufReg, frameReg);
	}

	if(!m_renderState.isValid ||
		(m_renderState.frameReg != frameReg) ||
		(m_renderState.scissorReg != scissorReg))
	{
		SetupFramebuffer(frameReg, scissorReg);
	}

	if(!m_renderState.isValid ||
		(m_renderState.tex0Reg != tex0Reg) ||
		(m_renderState.tex1Reg != tex1Reg) ||
		(m_renderState.clampReg != clampReg))
	{
		SetupTexture(tex0Reg, tex1Reg, clampReg);
	}

	m_renderState.isValid = true;
	m_renderState.primReg = primReg;
	m_renderState.alphaReg = alphaReg;
	m_renderState.testReg = testReg;
	m_renderState.zbufReg = zbufReg;
	m_renderState.frameReg = frameReg;
	m_renderState.tex0Reg = tex0Reg;
	m_renderState.tex1Reg = tex1Reg;
	m_renderState.clampReg = clampReg;
	m_renderState.scissorReg = scissorReg;

	auto offset = make_convertible<XYOFFSET>(m_nReg[GS_REG_XYOFFSET_1 + context]);
	m_nPrimOfsX = offset.GetX();
	m_nPrimOfsY = offset.GetY();
	
	if(GetCrtIsInterlaced() && GetCrtIsFrameMode())
	{
		if(m_nCSR & CSR_FIELD)
		{
			m_nPrimOfsY += 0.5;
		}
	}
}

Point Tile::GetPoint() const
{
	return Point(GetX(), GetY());
}

void CFish::BreedingUpdate(double elapsed)
{
	
	CAquarium *aquarium = GetAquarium();
	//fish logic for breeding
	if (mCanBreed == true && mAge >= MaxAge)
	{
		if (mInterestTime >= InterestTimePreBreed)
		{
			mIsInterested = true;
		}
		else if (mIsGestating == false)
			mInterestTime++;
		if (mIsGestating == true)
			mGestatingTime++;

		if (mIsInterested == true)
		{
			CBreedVisitor visitor(mIsMale, GetType());
			
			aquarium->Accept(&visitor);
			if (visitor.IsInterested())
			{
				// Compute a vector from (x1,y1) to (x2,y2)
					
				double dx = visitor.GetX() - GetX();
				double dy = visitor.GetY() - GetY();				
				
				// How long is that vector?
				double len = sqrt(dx * dx + dy * dy);
				if (len > 0)
				{
					// Normalize the vector
					dx /= len;
					dy /= len;
				}

				// Update the location
				if (GetType() == "beta")
				{
					mSpeedX = dx * (MaxSpeedX - BetaSpeed) * BreedMultuplier * elapsed;
					mSpeedY = dy * (MaxSpeedY - BetaSpeed) * BreedMultuplier * elapsed;
				}

				if (GetType() == "bubbles")
				{
					mSpeedX = dx * (MaxSpeedX - BubblesSpeed) * BreedMultuplier * elapsed;
					mSpeedY = dy * (MaxSpeedY - BubblesSpeed) * BreedMultuplier * elapsed;
				}

				if (GetType() == "dory")
				{
					mSpeedX = dx * (DorySpeed - MaxSpeedX) * BreedMultuplier * elapsed;
					mSpeedY = dy * (DorySpeed - MaxSpeedY) * BreedMultuplier * elapsed;
				}

				

				// check if the visited fish overlaps this one
				if (OverlapTest(visitor.GetX(), visitor.GetY()))
				{
					if (mIsMale == 0)
					{
						mIsGestating = true;
					}
					else
					{
						visitor.SetGestating();
					}
					mIsInterested = false;
					mInterestTime = 0;
					visitor.SetUninterested();
					if (GetType() == "beta")
					{
						mSpeedX = ((double)rand() / RAND_MAX) * (MaxSpeedX - BetaSpeed);
						mSpeedY = ((double)rand() / RAND_MAX) * (MaxSpeedY - BetaSpeed);
					}
					else if (GetType() == "bubbles")
					{
						mSpeedX = ((double)rand() / RAND_MAX) * (MaxSpeedX - BubblesSpeed);
						mSpeedY = ((double)rand() / RAND_MAX) * (MaxSpeedY - BubblesSpeed);
					}
					else if (GetType() == "dory")
					{
						mSpeedX = ((double)rand() / RAND_MAX) * (DorySpeed- MaxSpeedX);
						mSpeedY = ((double)rand() / RAND_MAX) * (DorySpeed- MaxSpeedY);
					}
					
										
				}
				
			}


		}

		if (mGestatingTime >= GestatingTime)
		{
			mIsGestating = false;
			mGestatingTime = 0;
//.........这里部分代码省略.........

bool Player::IsPointWithin(int x, int y)
{
	return (x > (GetX()) && GetX() + GetWidth()  > x) && (y > GetY()  && GetY() + GetWidth() > y);
}

void Sprite::MoveLeft(Dim x) {
		if(GetX() > x)
				SetX(GetX() - x);
}

wxRealPoint ExplainShape::GetEndPoint(int kidNo)
{
    wxRealPoint rp(GetX() - GetBitmap().GetWidth() / 2.0 - ARROWMARGIN, GetY() - (GetHeight()-GetBitmap().GetHeight()) / 2. + (kidCount>1 ? GetBitmap().GetHeight() * 2. /3. * kidNo / (2*kidCount-2) : 0 ));
    return rp;
}

WorldPacket Creature::PackData()
{
    WorldPacket Packet((uint16)MSG_ADD_OBJECT);
    Packet << ObjID << pTemplate->Tileset << pTemplate->Name << GetX() << GetY() << pTemplate->tx << pTemplate->ty;
    return Packet;
}

struct Cluster* Calculate(struct Points* Field, int Height, int Width, int* Num, int NumOfPoints)
{
	struct Cluster *Clusters;
	int i,j,k,NumOfClusters;
	int n;
	double Min;
	/*int Min_x;
	int Min_y;
	int Max_x;
	int Max_y;*/
	double New_Cluster_X;
	double New_Cluster_Y;
	int Min_cluster;
	double Distance;
	double Point_X, Point_Y;
	int Flag = 1;
	int New_Flag;
	
	
	printf("Enter number of clusters: ");
	scanf("%d",&NumOfClusters);
	
	Clusters = (struct Cluster*)malloc(NumOfClusters * sizeof(struct Cluster));
	Init_Clusters(Clusters, NumOfClusters);
	
	srand(time(NULL));
	
	for(i = 0; i< NumOfClusters; i++)
	{
		Clusters[i].x = (double)(rand()%Width);
		Clusters[i].y = (double)(rand()%Height);
	}

	#pragma omp parallel for private(i, Min)
	for(i = 0;i<NumOfPoints;i++)
	{
		Min = (double)(Height + Width);
		for(k = 0; k<NumOfClusters; k++)
		{
			Distance = Dist(Field[i].x,Field[i].y,Clusters[k].x,Clusters[k].y);
			if(Distance < Min)
			{
				Min = Distance;
				Min_cluster = k;
			}
		}
		Field[i].cluster = Min_cluster;
		Clusters[Min_cluster] = AddIndex(Clusters[Min_cluster], i);
	}
	
	while(Flag == 1)
	{
		Flag = 0;
		#pragma omp parallel for private(k)
		for(k=0; k<NumOfClusters; k++)
		{
			n = GetClusterNumOfPoints(Clusters[k]);
			New_Cluster_X = 0;
			New_Cluster_Y = 0;
			
			/*for(i = 0; i < n; i++)
			{
				Point_X = GetX(Field, Clusters[k],i);
				Point_Y = GetY(Field, Clusters[k],i);
				New_Cluster_X = (i*New_Cluster_X + Point_X)/(i+1);//vot on obhod perepolneniya
				New_Cluster_Y = (i*New_Cluster_Y + Point_Y)/(i+1);
			}*/
			#pragma omp parallel for private(i) reduction(+:New_Cluster_X, New_Cluster_Y)
			for(i = 0; i < n; i++)
			{
				New_Cluster_X += GetX(Field, Clusters[k],i)/n;
				New_Cluster_Y += GetY(Field, Clusters[k],i)/n;
			}
			Clusters[k].x = New_Cluster_X;
			Clusters[k].y = New_Cluster_Y;
		}
		Clear_Points(Clusters, NumOfClusters);
		#pragma omp parallel for private(i, Min)
		for(i = 0;i<NumOfPoints;i++)
		{
			Min = (double)(Height + Width);
			for(k = 0; k<NumOfClusters; k++)
			{
				Distance = Dist(Field[i].x,Field[i].y,Clusters[k].x,Clusters[k].y);
				if(Distance < Min)
				{
					Min = Distance;
					Min_cluster = k;
				}
			}
			if(Field[i].cluster != Min_cluster)
				Flag = 1;
			Field[i].cluster = Min_cluster;
			Clusters[Min_cluster] = AddIndex(Clusters[Min_cluster], i);
		}
	}
	*Num = NumOfClusters;
	return Clusters;
}