////////////////////////////////////////////////////////////////////////////
//--------------------------------- REVISIONS ------------------------------
// Date Name Tracking # Description
// --------- ------------------- ------------- ----------------------
// 13JUN2009 James Shen Initial Creation
////////////////////////////////////////////////////////////////////////////
/**
* Reset the rectangle.
* @param ff_xmin
* @param ff_ymin
* @param ff_xmax
* @param ff_ymax
* @return
*/
public RectangleFP Reset(int ffXmin, int ffYmin, int ffXmax, int ffYmax)
{
_ffXmin = MathFP.Min(ffXmin, ffXmax);
_ffXmax = MathFP.Max(ffXmin, ffXmax);
_ffYmin = MathFP.Min(ffYmin, ffYmax);
_ffYmax = MathFP.Max(ffYmin, ffYmax);
return(this);
}
public virtual RectangleFP Union(PointFP p)
{
if (!IsEmpty())
{
Reset(MathFP.Min(ff_xmin, p.X), MathFP.Max(ff_xmax, p.X), MathFP.Min(ff_ymin, p.Y), MathFP.Max(ff_ymax, p.Y));
}
return(this);
}
public virtual RectangleFP Reset(int ff_xmin, int ff_ymin, int ff_xmax, int ff_ymax)
{
this.ff_xmin = MathFP.Min(ff_xmin, ff_xmax);
this.ff_xmax = MathFP.Max(ff_xmin, ff_xmax);
this.ff_ymin = MathFP.Min(ff_ymin, ff_ymax);
this.ff_ymax = MathFP.Max(ff_ymin, ff_ymax);
return(this);
}
////////////////////////////////////////////////////////////////////////////
//--------------------------------- REVISIONS ------------------------------
// Date Name Tracking # Description
// --------- ------------------- ------------- ----------------------
// 13JUN2009 James Shen Initial Creation
////////////////////////////////////////////////////////////////////////////
/**
* return the union of the rectangle and the given point.
* @param p
* @return
*/
public RectangleFP Union(PointFP p)
{
if (!IsEmpty())
{
Reset(MathFP.Min(_ffXmin, p.X), MathFP.Max(_ffXmax, p.X),
MathFP.Min(_ffYmin, p.Y), MathFP.Max(_ffYmax, p.Y));
}
return(this);
}
public virtual RectangleFP Union(RectangleFP r)
{
if (!r.IsEmpty())
{
if (IsEmpty())
{
Reset(r);
}
else
{
Reset(MathFP.Min(ff_xmin, r.ff_xmin), MathFP.Max(ff_xmax, r.ff_xmax), MathFP.Min(ff_ymin, r.ff_ymin), MathFP.Max(ff_ymax, r.ff_ymax));
}
}
return(this);
}
////////////////////////////////////////////////////////////////////////////
//--------------------------------- REVISIONS ------------------------------
// Date Name Tracking # Description
// --------- ------------------- ------------- ----------------------
// 13JUN2009 James Shen Initial Creation
////////////////////////////////////////////////////////////////////////////
/**
* Calculate the union of the two rectangle.
* @param r
* @return
*/
public RectangleFP Union(RectangleFP r)
{
if (!r.IsEmpty())
{
if (IsEmpty())
{
Reset(r);
}
else
{
Reset(MathFP.Min(_ffXmin, r._ffXmin),
MathFP.Max(_ffXmax, r._ffXmax),
MathFP.Min(_ffYmin, r._ffYmin),
MathFP.Max(_ffYmax, r._ffYmax));
}
}
return(this);
}
public override void LineTo(PointFP point)
{
//PointFP a = new PointFP(CurrentPoint);
PointFP pntTemp = new PointFP(point);
ff_xmin = MathFP.Min(ff_xmin, CurrentPoint.X);
ff_xmax = MathFP.Max(ff_xmax, point.X);
ff_ymin = MathFP.Min(ff_ymin, CurrentPoint.Y);
ff_ymax = MathFP.Max(ff_ymax, point.Y);
if (transformMatrix != null)
{
pntTemp.Transform(transformMatrix);
//b.Transform(transformMatrix);
}
Scanline(transformedPoint.X, transformedPoint.Y, pntTemp.X, pntTemp.Y);
transformedPoint = pntTemp;
base.LineTo(point);
}
public GradientBrushFP(int ff_xmin, int ff_ymin, int ff_xmax, int ff_ymax, int ff_angle, int type)
{
bounds.Reset(ff_xmin, ff_ymin,
ff_xmax == ff_xmin ? ff_xmin + 1 : ff_xmax,
ff_ymax == ff_ymin ? ff_ymin + 1 : ff_ymax);
matrix = new MatrixFP();
matrix.Translate(-(ff_xmin + ff_xmax) / 2, -(ff_ymin + ff_ymax) / 2);
matrix.Rotate(-ff_angle);
this.type = type;
if (type == RADIAL_GRADIENT)
{
matrix.Scale(MathFP.Div(SingleFP.One, bounds.Width), MathFP.Div(SingleFP.One, bounds.Height));
}
int ff_ang = MathFP.Atan(MathFP.Div(bounds.Height, bounds.Width == 0 ? 1 : bounds.Width));
int ff_len = PointFP.Distance(bounds.Height, bounds.Width);
ff_length = MathFP.Mul(ff_len, MathFP.Max(
MathFP.Abs(MathFP.Cos(ff_angle - ff_ang)),
MathFP.Abs(MathFP.Cos(ff_angle + ff_ang))));
}
public override void OnSyncedUpdate()
{
base.OnSyncedUpdate();
if (!m_RunSyncedUpdate)
{
return;
}
// Get delta time.
FP deltaTime = TrueSyncManager.deltaTimeMain;
// Handle attract.
if (m_Running)
{
bool buttonPressed = TrueSyncInput.GetByte(m_ButtonPressedCode) > 0;
if (buttonPressed)
{
FP cost = m_EnergyCostRate * deltaTime;
cost = MathFP.Max(cost, FP.Zero);
if (m_Energy != null && m_Energy.CanSpend(cost))
{
m_Energy.Consume(cost);
}
else
{
m_Running = false;
}
}
else
{
m_Running = false;
}
}
else
{
bool buttonDown = TrueSyncInput.HasByte(m_ButtonDownCode);
if (buttonDown)
{
FP cost = m_EnergyCostRate * deltaTime;
cost = MathFP.Max(cost, FP.Zero);
if (m_Energy != null && m_Energy.CanSpend(cost))
{
m_Energy.Consume(cost);
m_Running = true;
}
}
}
// Update effector.
if (m_Running)
{
UpdateEffector();
}
}
public static bool Intersects(LineFP l1, LineFP l2, PointFP intersection)
{
int x = SingleFP.NaN;
int y = SingleFP.NaN;
if (intersection != null)
{
intersection.Reset(x, y);
}
int ax0 = l1.P1.X;
int ax1 = l1.P2.X;
int ay0 = l1.P1.Y;
int ay1 = l1.P2.Y;
int bx0 = l2.P1.X;
int bx1 = l2.P2.X;
int by0 = l2.P1.Y;
int by1 = l2.P2.Y;
int adx = (ax1 - ax0);
int ady = (ay1 - ay0);
int bdx = (bx1 - bx0);
int bdy = (by1 - by0);
if (IsZero(adx) && IsZero(bdx))
{
return(IsEqual(ax0, bx0));
}
else if (IsZero(ady) && IsZero(bdy))
{
return(IsEqual(ay0, by0));
}
else if (IsZero(adx))
{
// A vertical
x = ax0;
y = IsZero(bdy)?by0:MathFP.Mul(MathFP.Div(bdy, bdx), x - bx0) + by0;
}
else if (IsZero(bdx))
{
// B vertical
x = bx0;
y = IsZero(ady)?ay0:MathFP.Mul(MathFP.Div(ady, adx), x - ax0) + ay0;
}
else if (IsZero(ady))
{
y = ay0;
x = MathFP.Mul(MathFP.Div(bdx, bdy), y - by0) + bx0;
}
else if (IsZero(bdy))
{
y = by0;
x = MathFP.Mul(MathFP.Div(adx, ady), y - ay0) + ax0;
}
else
{
int xma = MathFP.Div(ady, adx); // slope segment A
int xba = ay0 - (MathFP.Mul(ax0, xma)); // y intercept of segment A
int xmb = MathFP.Div(bdy, bdx); // slope segment B
int xbb = by0 - (MathFP.Mul(bx0, xmb)); // y intercept of segment B
// parallel lines?
if (xma == xmb)
{
// Need trig functions
return(xba == xbb);
}
else
{
// Calculate points of intersection
// At the intersection of line segment A and B, XA=XB=XINT and YA=YB=YINT
x = MathFP.Div((xbb - xba), (xma - xmb));
y = (MathFP.Mul(xma, x)) + xba;
}
}
// After the point or points of intersection are calculated, each
// solution must be checked to ensure that the point of intersection lies
// on line segment A and B.
int minxa = MathFP.Min(ax0, ax1);
int maxxa = MathFP.Max(ax0, ax1);
int minya = MathFP.Min(ay0, ay1);
int maxya = MathFP.Max(ay0, ay1);
int minxb = MathFP.Min(bx0, bx1);
int maxxb = MathFP.Max(bx0, bx1);
int minyb = MathFP.Min(by0, by1);
int maxyb = MathFP.Max(by0, by1);
if (intersection != null)
{
intersection.Reset(x, y);
}
return((x >= minxa) && (x <= maxxa) && (y >= minya) && (y <= maxya) && (x >= minxb) && (x <= maxxb) && (y >= minyb) && (y <= maxyb));
}
// INERNALS
private void ComputeTimeScale(out FP o_TimeScale)
{
o_TimeScale = FP.One;
//bool slowMotionEnabled;
//GameSettings.TryGetBoolMain(Settings.s_SlowMotionSetting, out slowMotionEnabled);
if (m_Reference == null || m_ReferenceTransform == null /*|| !slowMotionEnabled*/)
{
return;
}
TSVector2 velocity = m_Reference.velocity;
if (velocity.LengthSquared() < m_MinReferenceSpeed * m_MinReferenceSpeed)
{
o_TimeScale = 1f;
return;
}
if (m_UseRaycast)
{
TSVector2 rayOrigin = m_Reference.position;
TSVector2 rayDirection = velocity.normalized;
FP speed = velocity.magnitude;
FP rayDistance = speed * m_TimeToReach;
rayDistance = MathFP.Max(rayDistance, m_DistanceThreshold);
TSRaycastHit2D[] raycastHit = TSPhysics2D.Raycast(rayOrigin, rayDirection, rayDistance, m_RaycastMask);
if (raycastHit == null || raycastHit.Length == 0)
{
o_TimeScale = 1f;
return;
}
TSRaycastHit2D hitResult = raycastHit[0];
FP timeScale = MathFP.GetClampedPercentage(hitResult.distance, m_MinDistance, m_MaxDistance);
timeScale = MathFP.Max(timeScale, m_MinTimeScale);
o_TimeScale = timeScale;
}
else // Do a simple line check.
{
TSVector2 delta = velocity * m_TimeToReach;
if (delta.magnitude > m_DistanceThreshold)
{
delta = delta.normalized * m_DistanceThreshold;
}
TSVector2 rayStart = m_Reference.position;
TSVector2 rayEnd = rayStart + delta;
// Check each stored segment.
for (int segmentIndex = 0; segmentIndex < m_SegmentCount; ++segmentIndex)
{
TSVector2 pointA = m_Segments[segmentIndex * 2];
TSVector2 pointB = m_Segments[segmentIndex * 2 + 1];
FP t;
TSVector2 intersectionPoint;
if (Test2DSegmentSegment(pointA, pointB, rayStart, rayEnd, out t, out intersectionPoint))
{
TSVector2 distance = intersectionPoint - rayStart;
FP timeScale = MathFP.GetClampedPercentage(distance.magnitude, m_MinDistance, m_MaxDistance);
timeScale = MathFP.Max(timeScale, m_MinTimeScale);
o_TimeScale = timeScale;
return;
}
}
}
}
public override void OnSyncedUpdate()
{
base.OnSyncedUpdate();
if (!m_RunSyncedUpdate)
{
return;
}
// Read delta time.
FP deltaTime = TrueSyncManager.deltaTimeMain;
int currentTick = TrueSyncManager.ticksMain;
// Update timers.
UpdateTimers(deltaTime);
// Read input.
FP horizontalAxis;
FP verticalAxis;
if (m_EnableInputCompression)
{
int intX = TrueSyncInput.GetInt(m_HorizontalAxisCode);
int intY = TrueSyncInput.GetInt(m_VerticalAxisCode);
horizontalAxis = intX / (FP)s_InputPrecision;
verticalAxis = intY / (FP)s_InputPrecision;
}
else
{
horizontalAxis = TrueSyncInput.GetFP(m_HorizontalAxisCode);
verticalAxis = TrueSyncInput.GetFP(m_VerticalAxisCode);
}
// Handle actions.
bool actionRequested = TrueSyncInput.HasByte(m_DashRequestedCode);
bool cooldownOk = (m_CooldownTimer == FP.Zero);
bool energyAvailable = (m_Energy != null && m_Energy.CanSpend(m_DashEnergyCost));
if (actionRequested && m_DashTickRequest == 0 && energyAvailable && cooldownOk)
{
// Cahce dash tick request.
m_DashTickRequest = currentTick + m_DashTickDelay;
// Consume energy.
if (m_Energy != null)
{
m_Energy.Consume(m_DashEnergyCost);
}
}
if ((m_DashTickRequest > 0) && (m_DashTickRequest == currentTick))
{
// Consume tick input.
m_DashTickRequest = 0;
// Override layer, mass and drag.
int layerOverride = m_DashLayer;
FP massOverride = m_DashMass;
FP dragOverride = m_DashDrag;
SetRigidbodyLayer(layerOverride);
SetRigidbodyMass(massOverride);
SetRigidbodyDrag(dragOverride);
// Apply insant force.
TSVector2 move = new TSVector2(horizontalAxis, verticalAxis);
move.Normalize();
TSVector2 moveForce = move * m_DashAppliedForce;
m_Rigidbody2D.AddForce(moveForce);
// Update timers.
m_DurationTimer = m_DashDuration;
m_CooldownTimer = MathFP.Max(m_DashCooldown, m_DurationTimer);
// Raise event.
if (m_OnDashTriggered != null)
{
m_OnDashTriggered();
}
}
else // Handle movement.
{
if (m_DurationTimer == FP.Zero)
{
// Restore layer, mass and drag.
SetRigidbodyLayer(m_OriginalLayer);
SetRigidbodyMass(m_OriginalMass);
SetRigidbodyDrag(m_OriginalDrag);
// Compute movement force.
TSVector2 move = new TSVector2(horizontalAxis, verticalAxis);
TSVector2 moveForce = move * m_MoveForce;
if (m_MaxSpeed > FP.Zero)
{
TSVector2 currentVelocity = m_Rigidbody2D.velocity;
TSVector2 moveAcceleration = moveForce / m_Rigidbody2D.mass; // F = m * a ==> a = F / m
TSVector2 deltaVelocity = moveAcceleration * deltaTime; // a = dv / dt ==> dv = a * dt
TSVector2 newVelocity = currentVelocity + deltaVelocity;
if (newVelocity.LengthSquared() > m_MaxSpeed * m_MaxSpeed)
{
// Modulate moveForce in order to reach a maximum speed of m_MaxSpeed.
TSVector2 maxVelocity = newVelocity.normalized * m_MaxSpeed;
TSVector2 maxAcceleration = (maxVelocity - currentVelocity) / deltaTime;
moveForce = maxAcceleration * m_Rigidbody2D.mass;
}
}
m_Rigidbody2D.AddForce(moveForce);
}
}
}
