void CurrencyOrb::DoTrackPlayer(float delta)
{
mSineWaveProps.DoSineWave = false;
Player * player = GameObjectManager::Instance()->GetPlayer();
if (!player)
{
return;
}
// accelerate towards the target
Vector3 direction = Vector3(player->CollisionCentreX(), player->CollisionCentreY(), player->Z()) - m_position;
direction.Normalise();
m_direction = direction;
float multiplier = mTimeTracking > 2.0f ? 3.0f : 1.0f;
bool prioritiseX = false;
if (std::abs(m_direction.X) > std::abs(m_direction.Y))
{
AccelerateX(m_direction.X, kAccelerateRate * multiplier);
prioritiseX = true;
}
else
{
AccelerateY(m_direction.Y, kAccelerateRate * multiplier);
}
if (prioritiseX && ((m_direction.X < 0 && m_velocity.X > 0) ||
(m_direction.X > 0 && m_velocity.X < 0)))
{
// the velocity of the orb is still moving in the opposite x direction
// let's give it a helping hand to catch up by accelerating harshly
AccelerateX(m_direction.X, kHarshAccelerateRate * multiplier);
}
if (!prioritiseX && ((m_direction.Y < 0 && m_velocity.Y > 0) ||
(m_direction.Y > 0 && m_velocity.Y < 0)))
{
// the velocity of the orb is still moving in the opposite y direction
// let's give it a helping hand to catch up by accelerating harshly
AccelerateY(m_direction.Y, kHarshAccelerateRate * multiplier);
}
Vector2 dir = Vector2(m_velocity.X, m_velocity.Y);
dir.Normalise();
if (dir.X > 0)
{
SetRotationAngle(-acos(dir.Dot(Vector2(0, -1))));
}
else
{
SetRotationAngle(acos(dir.Dot(Vector2(0, -1))));
}
}
void CIntegralRotation::Init (const CIntegralRotationDesc &Desc, int iRotationAngle)
// Init
//
// Initialize
{
// Defaults
m_iMaxRotationRate = Desc.GetMaxRotationSpeed();
m_iRotationAccel = Desc.GetRotationAccel();
m_iRotationAccelStop = Desc.GetRotationAccelStop();
if (iRotationAngle != -1)
SetRotationAngle(Desc, iRotationAngle);
}
void
EllipsoidSliceAttributes::SetFromNode(DataNode *parentNode)
{
if(parentNode == 0)
return;
DataNode *searchNode = parentNode->GetNode("EllipsoidSliceAttributes");
if(searchNode == 0)
return;
DataNode *node;
if((node = searchNode->GetNode("origin")) != 0)
SetOrigin(node->AsDoubleArray());
if((node = searchNode->GetNode("radii")) != 0)
SetRadii(node->AsDoubleArray());
if((node = searchNode->GetNode("rotationAngle")) != 0)
SetRotationAngle(node->AsDoubleArray());
}
void ScreenBase::UpdateDependentParameters()
{
m_PixelRect = CalculatePixelRect(m_Scale);
m_PtoG = math::Shift( /// 5. shifting on (E0, N0)
math::Rotate( /// 4. rotating on the screen angle
math::Scale( /// 3. scaling to translate pixel sizes to global
math::Scale( /// 2. swapping the Y axis??? why??? supposed to be a rotation on -pi / 2 here.
math::Shift( /// 1. shifting for the pixel center to become (0, 0)
math::Identity<double, 3>(),
- m_PixelRect.Center()
),
1,
-1
),
m_Scale,
m_Scale
),
m_Angle.cos(),
m_Angle.sin()
),
m_Org
);
m_GtoP = math::Inverse(m_PtoG);
m2::PointD const pxC = m_PixelRect.Center();
double const szX = PtoG(m2::PointD(m_PixelRect.maxX(), pxC.y)).Length(PtoG(m2::PointD(pxC)));
double const szY = PtoG(m2::PointD(pxC.x, m_PixelRect.minY())).Length(PtoG(m2::PointD(pxC)));
m_GlobalRect = m2::AnyRectD(m_Org, m_Angle, m2::RectD(-szX, -szY, szX, szY));
m_ClipRect = m_GlobalRect.GetGlobalRect();
double const kEps = 1e-5;
double angle = CalculatePerspectiveAngle(m_Scale);
m_isPerspective = angle > 0.0;
if (fabs(angle - m_3dAngleX) > kEps)
{
m_3dMaxAngleX = angle;
m_3dScale = CalculateScale3d(angle);
SetRotationAngle(angle);
}
}
void CIntegralRotation::ReadFromStream (SLoadCtx &Ctx, const CIntegralRotationDesc &Desc)
// ReadFromStream
//
// Reads data
{
DWORD dwLoad;
Init(Desc);
Ctx.pStream->Read((char *)&dwLoad, sizeof(DWORD));
m_iRotationFrame = (int)dwLoad;
Ctx.pStream->Read((char *)&dwLoad, sizeof(DWORD));
m_iRotationSpeed = (int)dwLoad;
// Make sure our frame is within bounds; this can change if the ship's
// rotation count is altered in the XML.
if (GetFrameIndex() >= Desc.GetFrameCount())
SetRotationAngle(Desc, 0);
}
void ViewPort::SetBoxes( void )
{
// In the case where canvas rotation is applied, we need to define a larger "virtual" pixel window size to ensure that
// enough chart data is fatched and available to fill the rotated screen.
rv_rect = wxRect( 0, 0, pix_width, pix_height );
// Specify the minimum required rectangle in unrotated screen space which will supply full screen data after specified rotation
if (( fabs( skew ) > .0001 ) || (fabs(rotation )>.0001 )) {
double rotator = rotation;
double lpixh = pix_height;
double lpixw = pix_width;
lpixh = wxMax(lpixh, (fabs(pix_height * cos(skew)) + fabs(pix_width * sin(skew))));
lpixw = wxMax(lpixw, (fabs(pix_width * cos(skew)) + fabs(pix_height * sin(skew))));
int dy = wxRound(
fabs( lpixh * cos( rotator ) ) + fabs( lpixw * sin( rotator ) ) );
int dx = wxRound(
fabs( lpixw * cos( rotator ) ) + fabs( lpixh * sin( rotator ) ) );
// It is important for MSW build that viewport pixel dimensions be multiples of 4.....
if( dy % 4 ) dy += 4 - ( dy % 4 );
if( dx % 4 ) dx += 4 - ( dx % 4 );
int inflate_x = wxMax(( dx - pix_width ) / 2, 0);
int inflate_y = wxMax(( dy - pix_height ) / 2, 0);
// Grow the source rectangle appropriately
rv_rect.Inflate( inflate_x, inflate_y );
}
// Compute Viewport lat/lon reference points for co-ordinate hit testing
// This must be done in unrotated space with respect to full unrotated screen space calculated above
double rotation_save = rotation;
SetRotationAngle(0.0);
wxPoint ul( rv_rect.x, rv_rect.y ), lr( rv_rect.x + rv_rect.width, rv_rect.y + rv_rect.height );
double dlat_min, dlat_max, dlon_min, dlon_max;
bool hourglass = false;
switch(m_projection_type) {
case PROJECTION_TRANSVERSE_MERCATOR:
case PROJECTION_STEREOGRAPHIC:
case PROJECTION_GNOMONIC:
hourglass = true;
case PROJECTION_POLYCONIC:
case PROJECTION_POLAR:
case PROJECTION_ORTHOGRAPHIC:
{
double d;
if( clat > 0 ) { // north polar
wxPoint u( rv_rect.x + rv_rect.width/2, rv_rect.y );
wxPoint ur( rv_rect.x + rv_rect.width, rv_rect.y );
GetLLFromPix( ul, &d, &dlon_min );
GetLLFromPix( ur, &d, &dlon_max );
GetLLFromPix( lr, &dlat_min, &d );
GetLLFromPix( u, &dlat_max, &d );
if(fabs(fabs(d - clon) - 180) < 1) { // the pole is onscreen
dlat_max = 90;
dlon_min = -180;
dlon_max = 180;
} else if(wxIsNaN(dlat_max))
dlat_max = 90;
if(hourglass) {
// near equator, center may be less
wxPoint l( rv_rect.x + rv_rect.width/2, rv_rect.y + rv_rect.height );
double dlat_min2;
GetLLFromPix( l, &dlat_min2, &d );
dlat_min = wxMin(dlat_min, dlat_min2);
}
if(wxIsNaN(dlat_min)) // world is off-screen
dlat_min = clat - 90;
} else { // south polar
wxPoint l( rv_rect.x + rv_rect.width/2, rv_rect.y + rv_rect.height );
wxPoint ll( rv_rect.x, rv_rect.y + rv_rect.height );
GetLLFromPix( ul, &dlat_max, &d );
GetLLFromPix( lr, &d, &dlon_max );
GetLLFromPix( ll, &d, &dlon_min );
GetLLFromPix( l, &dlat_min, &d );
if(fabs(fabs(d - clon) - 180) < 1) { // the pole is onscreen
dlat_min = -90;
dlon_min = -180;
dlon_max = 180;
} else if(wxIsNaN(dlat_min))
dlat_min = -90;
if(hourglass) {
// near equator, center may be less
wxPoint u( rv_rect.x + rv_rect.width/2, rv_rect.y );
double dlat_max2;
GetLLFromPix( u, &dlat_max2, &d );
dlat_max = wxMax(dlat_max, dlat_max2);
}
if(wxIsNaN(dlat_max)) // world is off-screen
dlat_max = clat + 90;
}
if(wxIsNaN(dlon_min)) {
// if neither pole is visible, but left and right of the screen are in space
// we can avoid drawing the far side of the earth
if(dlat_max < 90 && dlat_min > -90) {
dlon_min = clon - 90 - fabs(clat); // this logic is not optimal, is it always correct?
dlon_max = clon + 90 + fabs(clat);
} else {
dlon_min = -180;
dlon_max = 180;
}
}
}
break;
default: // works for mercator and equirectangular
{
GetLLFromPix( ul, &dlat_max, &dlon_min );
GetLLFromPix( lr, &dlat_min, &dlon_max );
}
}
if( clon < dlon_min )
dlon_min -= 360;
else if(clon > dlon_max)
dlon_max += 360;
// Set the viewport lat/lon bounding box appropriately
vpBBox.Set( dlat_min, dlon_min, dlat_max, dlon_max );
// Restore the rotation angle
SetRotationAngle( rotation_save );
}
void P3DBranchingAlgStd::Load
(P3DInputStringFmtStream
*SourceStream,
const P3DFileVersion
*Version)
{
char StrValue[255 + 1];
float FloatValue;
unsigned int UintValue;
bool BoolValue;
SourceStream->ReadFmtStringTagged("Density","f",&FloatValue);
SetDensity(FloatValue);
SourceStream->ReadFmtStringTagged("DensityV","f",&FloatValue);
SetDensityV(FloatValue);
if (Version->Minor > 5)
{
SourceStream->ReadFmtStringTagged("MinNumber","u",&UintValue);
SetMinNumber(UintValue);
SourceStream->ReadFmtStringTagged("MaxLimitEnabled","b",&BoolValue);
SetMaxLimitEnabled(BoolValue);
SourceStream->ReadFmtStringTagged("MaxNumber","u",&UintValue);
SetMaxNumber(UintValue);
}
else
{
SetMinNumber(0);
SetMaxLimitEnabled(false);
SetMaxNumber(0);
}
if (Version->Minor > 1)
{
SourceStream->ReadFmtStringTagged("Multiplicity","u",&UintValue);
SetMultiplicity(UintValue);
}
else
{
Multiplicity = 1;
}
if (Version->Minor > 7)
{
SourceStream->ReadFmtStringTagged("StartRevAngle","f",&FloatValue);
SetStartRevAngle(FloatValue);
}
else
{
StartRevAngle = 0.0f;
}
SourceStream->ReadFmtStringTagged("RevAngle","f",&FloatValue);
SetRevAngle(FloatValue);
SourceStream->ReadFmtStringTagged("RevAngleV","f",&FloatValue);
SetRevAngleV(FloatValue);
SourceStream->ReadFmtStringTagged("RotAngle","f",&FloatValue);
SetRotationAngle(FloatValue);
SourceStream->ReadFmtStringTagged("MinOffset","f",&FloatValue);
SetMinOffset(FloatValue);
SourceStream->ReadFmtStringTagged("MaxOffset","f",&FloatValue);
SetMaxOffset(FloatValue);
SourceStream->ReadFmtStringTagged("DeclinationCurve","s",StrValue,sizeof(StrValue));
P3DLoadSplineCurve(&DeclinationCurve,SourceStream,StrValue);
SourceStream->ReadFmtStringTagged("DeclinationV","f",&FloatValue);
SetDeclinationV(FloatValue);
}
void ViewPort::SetBoxes( void )
{
// In the case where canvas rotation is applied, we need to define a larger "virtual" pixel window size to ensure that
// enough chart data is fatched and available to fill the rotated screen.
rv_rect = wxRect( 0, 0, pix_width, pix_height );
// Specify the minimum required rectangle in unrotated screen space which will supply full screen data after specified rotation
if( ( g_bskew_comp && ( fabs( skew ) > .001 ) ) || ( fabs( rotation ) > .001 ) ) {
double rotator = rotation;
if(g_bskew_comp)
rotator -= skew;
int dy = wxRound(
fabs( pix_height * cos( rotator ) ) + fabs( pix_width * sin( rotator ) ) );
int dx = wxRound(
fabs( pix_width * cos( rotator ) ) + fabs( pix_height * sin( rotator ) ) );
// It is important for MSW build that viewport pixel dimensions be multiples of 4.....
if( dy % 4 ) dy += 4 - ( dy % 4 );
if( dx % 4 ) dx += 4 - ( dx % 4 );
int inflate_x = wxMax(( dx - pix_width ) / 2, 0);
int inflate_y = wxMax(( dy - pix_height ) / 2, 0);
// Grow the source rectangle appropriately
if( fabs( rotator ) > .001 )
rv_rect.Inflate( inflate_x, inflate_y );
}
// Compute Viewport lat/lon reference points for co-ordinate hit testing
// This must be done in unrotated space with respect to full unrotated screen space calculated above
double rotation_save = rotation;
SetRotationAngle( 0. );
double lat_ul, lat_ur, lat_lr, lat_ll;
double lon_ul, lon_ur, lon_lr, lon_ll;
GetLLFromPix( wxPoint( rv_rect.x, rv_rect.y ), &lat_ul, &lon_ul );
GetLLFromPix( wxPoint( rv_rect.x + rv_rect.width, rv_rect.y ), &lat_ur, &lon_ur );
GetLLFromPix( wxPoint( rv_rect.x + rv_rect.width, rv_rect.y + rv_rect.height ), &lat_lr,
&lon_lr );
GetLLFromPix( wxPoint( rv_rect.x, rv_rect.y + rv_rect.height ), &lat_ll, &lon_ll );
if( clon < 0. ) {
if( ( lon_ul > 0. ) && ( lon_ur < 0. ) ) {
lon_ul -= 360.;
lon_ll -= 360.;
}
} else {
if( ( lon_ul > 0. ) && ( lon_ur < 0. ) ) {
lon_ur += 360.;
lon_lr += 360.;
}
}
if( lon_ur < lon_ul ) {
lon_ur += 360.;
lon_lr += 360.;
}
if( lon_ur > 360. ) {
lon_ur -= 360.;
lon_lr -= 360.;
lon_ul -= 360.;
lon_ll -= 360.;
}
double dlat_min = lat_ul;
dlat_min = fmin ( dlat_min, lat_ur );
dlat_min = fmin ( dlat_min, lat_lr );
dlat_min = fmin ( dlat_min, lat_ll );
double dlon_min = lon_ul;
dlon_min = fmin ( dlon_min, lon_ur );
dlon_min = fmin ( dlon_min, lon_lr );
dlon_min = fmin ( dlon_min, lon_ll );
double dlat_max = lat_ul;
dlat_max = fmax ( dlat_max, lat_ur );
dlat_max = fmax ( dlat_max, lat_lr );
dlat_max = fmax ( dlat_max, lat_ll );
double dlon_max = lon_ur;
dlon_max = fmax ( dlon_max, lon_ul );
dlon_max = fmax ( dlon_max, lon_lr );
dlon_max = fmax ( dlon_max, lon_ll );
// Set the viewport lat/lon bounding box appropriately
vpBBox.SetMin( dlon_min, dlat_min );
vpBBox.SetMax( dlon_max, dlat_max );
// Restore the rotation angle
SetRotationAngle( rotation_save );
}
void BombProjectile::Update(float delta)
{
float targetDelta = Timing::Instance()->GetTargetDelta();
float percentDelta = delta / targetDelta;
// apply gravity to the
if (!mIsOnSolidLine)
{
if (!mIsInWater)
{
m_velocity.Y -= 0.3f * percentDelta;
}
else
{
m_velocity.Y -= 0.06f * percentDelta;
}
}
// nice simple update
if (mIsInWater)
{
m_velocity.X *= 0.92f; // slow down significantly
//m_velocity.Y *= 0.9f; // slow down significantly
}
m_direction = m_velocity;
m_direction.Normalise();
m_position += m_velocity * percentDelta;
// we dont need complicated movement so we'll ignore the MovingSprite class
Sprite::Update(delta);
if (IsOnSolidSurface())
{
// StopYAccelerating();
if (!mIsInWater)
{
SetRotationAngle(GetRotationAngle() + ((m_velocity.X * -0.04) *percentDelta));
}
else
{
SetRotationAngle(GetRotationAngle() + ((m_velocity.X * -0.009) *percentDelta));
}
}
else
{
if (!mIsInWater)
{
SetRotationAngle(GetRotationAngle() + ((m_velocity.X * -0.01) * percentDelta));
}
else
{
SetRotationAngle(GetRotationAngle() + ((m_velocity.X * -0.005) * percentDelta));
}
}
if (!m_isActive)
{
float currentTime = Timing::Instance()->GetTotalTimeSeconds();
float timeToDie = m_timeBecameInactive + m_maxTimeInActive;
if(currentTime > timeToDie)
{
// time to kill ourselves
GameObjectManager::Instance()->RemoveGameObject(this);
}
}
if (mTimeUntilNextParticleSpray > 0.0f)
{
mTimeUntilNextParticleSpray -= delta;
if (mTimeUntilNextParticleSpray < 0.0f)
{
mTimeUntilNextParticleSpray = 0.0f;
}
}
}
