public override Matrix Lerp(Matrix a, Matrix b, float t)
{
return(MyMath.Lerp(ref a, ref b, t));
}
/// <summary>
/// Delete a level from the local system. Returns false if not yet initialized.
/// </summary>
/// <param name="worldId"></param>
/// <param name="callback"></param>
/// <param name="param"></param>
/// <returns></returns>
public bool StartDeletingLevel(
Guid worldId,
Genres bucket,
BokuAsyncCallback callback,
object param)
{
bool deleted = false;
bucket &= Genres.SharableBins;
// Verify exactly one bucket is specified
Debug.Assert(bucket != 0);
Debug.Assert((int)bucket == int.MinValue || MyMath.IsPowerOfTwo((int)bucket));
string worldFilename = null;
string stuffFilename = null;
string thumbFilename = null;
LevelMetadata record = null;
string stuffPath = String.Empty;
string worldPath = String.Empty;
if (0 != (bucket & Genres.MyWorlds))
{
stuffPath = BokuGame.MyWorldsStuffPath;
worldPath = BokuGame.MyWorldsPath;
}
else if (0 != (bucket & Genres.Downloads))
{
stuffPath = BokuGame.DownloadsStuffPath;
worldPath = BokuGame.DownloadsPath;
}
lock (Synch)
{
for (int i = 0; i < allLevels.Count; ++i)
{
record = allLevels[i];
if (record.WorldId == worldId && (record.Genres & bucket) == bucket)
{
worldFilename = Path.Combine(BokuGame.Settings.MediaPath, worldPath + worldId.ToString() + @".Xml");
stuffFilename = Path.Combine(BokuGame.Settings.MediaPath, stuffPath + worldId.ToString() + @".Xml");
thumbFilename = Path.Combine(BokuGame.Settings.MediaPath, worldPath + worldId.ToString());
// Need to get the terrain file before we delete the main file. BUT the terrain should be
// deleted after, otherwise the usage test will find the main file and always thing that
// the terrain file is in use.
string terrainFilename = null;
try
{
// Only delete terrain file if no longer referenced.
XmlWorldData xmlWorldData = XmlWorldData.Load(worldFilename, XnaStorageHelper.Instance);
terrainFilename = xmlWorldData.xmlTerrainData2.virtualMapFile;
}
catch { }
// Note : Delete() handles non-existent files just fine.
Storage4.Delete(worldFilename);
Storage4.Delete(stuffFilename);
Storage4.Delete(thumbFilename + @".dds");
Storage4.Delete(thumbFilename + @".jpg");
Storage4.Delete(thumbFilename + @".png");
// Only deletes terrain file if no other world is using it. (including autosaves)
DeleteTerrainFile(terrainFilename);
LevelMetadata level = allLevels[i];
allLevels.RemoveAt(i);
LevelRemoved_Synched(level);
deleted = true;
break;
}
}
}
AsyncResult result = new AsyncResult();
result.Success = deleted;
result.Param = param;
result.Seconds = 0;
if (callback != null)
{
callback(result);
}
return(deleted);
}
public override float Lerp(float a, float b, float t)
{
return(MyMath.Lerp(a, b, t));
}
public override Vector4 Lerp(Vector4 a, Vector4 b, float t)
{
return(MyMath.Lerp(a, b, t));
}
} // end of c'tor
// Cut and pasted from BaseSpriteEmitter, just to override
// how the position is computed. Might like to refactor the
// Update into common particle tasks (spawn, kill, move, etc.)
public override void Update(Camera camera)
{
if (Active)
{
// Emit new particles if needed.
float dt = Time.GameTimeFrameSeconds;
dt = MathHelper.Clamp(dt, 0.0f, 1.0f); // Limit to reasonable values.
Position += Velocity * dt;
if (Emitting)
{
if (LinearEmission)
{
Vector3 deltaPosition = Position - PreviousPosition;
float dist = deltaPosition.Length();
partial += dist * EmissionRate;
}
else
{
partial += dt * EmissionRate;
}
// Emit as many particles as needed this
// frame to keep up with the emission rate.
while (partial >= 1.0f)
{
if (particleList.Count < MaxSprites)
{
// Pick a random position on the sphere.
Vector3 rndVec = new Vector3((float)(rnd.NextDouble() - rnd.NextDouble()),
(float)(rnd.NextDouble() - rnd.NextDouble()),
(float)(rnd.NextDouble() - rnd.NextDouble()));
rndVec.Normalize();
rndVec *= targetRadius;
Vector3 pos = Position + rndVec;
// Pick a random position somewhere along the path covered this frame.
if (PositionJitter > 0.0f)
{
pos += PositionJitter * new Vector3((float)rnd.NextDouble() - (float)rnd.NextDouble(), (float)rnd.NextDouble() - (float)rnd.NextDouble(), (float)rnd.NextDouble() - (float)rnd.NextDouble());
}
float lifetime = MinLifetime + (float)rnd.NextDouble() * (MaxLifetime - MinLifetime);
BaseSpriteParticle particle = new BaseSpriteParticle(pos, lifetime, Color, MaxRotationRate, NumTiles);
particleList.Add(particle);
}
partial -= 1.0f;
}
}
// Update the previous position to match the current one for the next frame.
ResetPreviousPosition();
// Update any existing particles. For more heavyweight particles we could
// have an Update call per particle. These are lightweight enough that we
// can just update them directly.
for (int i = 0; i < particleList.Count;)
{
BaseSpriteParticle particle = (BaseSpriteParticle)particleList[i];
particle.age += dt;
Debug.Assert(particle.age >= 0.0f);
float t = particle.age / particle.lifetime;
if (t > 1.0f)
{
// Dead particle.
particleList.RemoveAt(i);
}
else
{
particle.radius = MyMath.Lerp(StartRadius, EndRadius, t);
particle.alpha = MyMath.Lerp(StartAlpha, EndAlpha, t);
particle.rotation += particle.deltaRotation * dt;
// Change the linear fade to a curve.
particle.alpha *= particle.alpha;
// Add in gravity effect.
if (NonZeroGravity)
{
particle.velocity += Gravity * dt;
float speed2 = particle.velocity.LengthSquared();
if (speed2 > MaxSpeed * MaxSpeed)
{
particle.velocity.Normalize();
particle.velocity *= MaxSpeed;
}
}
particle.position += particle.velocity * dt;
i++;
}
} // end loop update particles.
// Now that we've updated all the particles, create/update the vertex buffer.
UpdateVerts();
// See if we've died.
if (Dying && particleList.Count == 0)
{
Active = false;
RemoveFromManager();
}
} // end of if active
} // end Update
private static void UpdateFlyingEffects(Camera camera)
{
double currTime = Time.GameTimeTotalSeconds;
for (int i = 0; i < flyingEffects.Count; ++i)
{
ScoreEffect scoreEffect = flyingEffects[i];
float timeElapsed = (float)(currTime - scoreEffect.spawnTime);
if (timeElapsed > kFlyingEffectSeconds)
{
flyingEffects.RemoveAt(--i + 1);
ReleaseScoreEffect(scoreEffect);
continue;
}
Score score;
scores.TryGetValue((int)scoreEffect.color, out score);
Viewport viewport = BokuGame.bokuGame.GraphicsDevice.Viewport;
float pct = timeElapsed / kFlyingEffectSeconds;
// If the thing went to the recycle bin, remove our reference to it.
if (scoreEffect.thing != null && scoreEffect.thing.CurrentState == GameThing.State.Inactive)
{
scoreEffect.thing = null;
}
// If we still have a reference to the thing, update the source position of the flying score's path.
if (scoreEffect.thing != null)
{
scoreEffect.thingPosition = scoreEffect.thing.Movement.Position;
}
Vector3 pt0 = scoreEffect.thingPosition + new Vector3(0, 0, scoreEffect.thingBoundingRadius * 2);
Vector3 pt1 = new Vector3(
(float)viewport.Width * 0.5f,
(float)viewport.Height * 0.3f,
0.75f);
pt1 = viewport.Unproject(
pt1,
camera.ProjectionMatrix,
camera.ViewMatrix,
Matrix.Identity);
Vector3 pt2 = new Vector3(
(float)viewport.Width * 0.6f,
(float)viewport.Height * 0.1f,
0.5f);
pt2 = viewport.Unproject(
pt1,
camera.ProjectionMatrix,
camera.ViewMatrix,
Matrix.Identity);
Vector3 pt3 = new Vector3(
(float)viewport.Width * 0.9f,
y_margin + ScoreBoardFont().LineSpacing *score.order,
0.5f);
pt3 = viewport.Unproject(
pt3,
camera.ProjectionMatrix,
camera.ViewMatrix,
Matrix.Identity);
scoreEffect.curr = MyMath.CubicBezier(pt0, pt1, pt2, pt3, pct);
scoreEffect.alpha = MyMath.Clamp((1f - pct) * 5, 0, 1);
}
}
private void CreateRenderTargets(GraphicsDevice device)
{
int shadowOffset = Scoreboard.ShadowOffset;
int surfaceWidth = MyMath.GetNextPowerOfTwo(charWidth);
int surfaceHeight = MyMath.GetNextPowerOfTwo(charHeight);
string str = String.Format("{0}", ch);
if (surface == null || surface.IsDisposed || surface.GraphicsDevice.IsDisposed)
{
surface = new RenderTarget2D(
BokuGame.bokuGame.GraphicsDevice,
surfaceWidth,
surfaceHeight,
false,
SurfaceFormat.Color,
DepthFormat.None);
InGame.GetRT("Scoreboard", surface);
}
InGame.SetRenderTarget(surface);
InGame.Clear(Color.Transparent);
SpriteBatch batch = UI2D.Shared.SpriteBatch;
try
{
try
{
batch.Begin();
TextHelper.DrawString(
ScoreBoardFont,
str,
new Vector2(shadowOffset + (surfaceWidth - charWidth) / 2, shadowOffset + (surfaceHeight - charHeight) / 2),
Color.Black);
TextHelper.DrawString(
ScoreBoardFont,
str,
new Vector2((surfaceWidth - charWidth) / 2, (surfaceHeight - charHeight) / 2),
Color.White);
}
catch (Exception e)
{
if (e != null)
{
}
}
finally
{
batch.End();
}
}
catch
{
}
finally
{
InGame.RestoreRenderTarget();
}
}
} // end of PixelsToCameraSpaceScreenCoords()
/// <summary>
/// A helper function which smoothly changes the heightOffset of the camera.
/// This takes the desired offset as a paramter, rather than the absolute height.
/// </summary>
/// <param name="height">The height we want the camera at point to be.</param>
public void ChangeHeightOffsetNotHeight(float desiredOffset)
{
targetHeight = Terrain.GetTerrainHeightFlat(At) + desiredOffset;
HeightOffset = MyMath.Lerp(HeightOffset, desiredOffset, Time.WallClockFrameSeconds);
} // end of Camera MoveHeightOffset()
} // end of TwitchCurve c'tor
/// <summary>
/// Applies the curve to the paramter t. Assumes that t is
/// in the range [0, 1].
/// </summary>
public static float Apply(float t, Shape shape)
{
const float overshootAmplitutde = 0.1f;
float result = t;
switch (shape)
{
case Shape.Linear:
result = t;
break;
case Shape.EaseIn:
result = 2.0f * MyMath.SmoothStep(0.0f, 2.0f, t);
break;
case Shape.EaseOut:
result = 2.0f * MyMath.SmoothStep(-1.0f, 1.0f, t) - 1.0f;
break;
case Shape.EaseInOut:
result = MyMath.SmoothStep(0.0f, 1.0f, t);
break;
case Shape.OvershootIn:
{
t *= 0.5f;
float smooth = MyMath.SmoothStep(0.0f, 1.0f, t);
result = smooth - overshootAmplitutde * (float)Math.Cos((t - 0.25f) * MathHelper.TwoPi);
// Blend toward smooth at tail.
if (t < 0.1f)
{
result = MyMath.Lerp(smooth, result, t * 10.0f);
}
result *= 2.0f;
}
break;
case Shape.OvershootOut:
{
t = 0.5f + t * 0.5f;
float smooth = MyMath.SmoothStep(0.0f, 1.0f, t);
result = smooth - overshootAmplitutde * (float)Math.Cos((t - 0.25f) * MathHelper.TwoPi);
// Blend toward smooth at tail.
if (t > 0.9f)
{
result = MyMath.Lerp(smooth, result, (1.0f - t) * 10.0f);
}
result = (result - 0.5f) * 2.0f;
}
break;
case Shape.OvershootInOut:
{
float smooth = MyMath.SmoothStep(0.0f, 1.0f, t);
result = smooth - overshootAmplitutde * (float)Math.Cos((t - 0.25f) * MathHelper.TwoPi);
// Blend toward smooth at tails.
if (t < 0.1f)
{
result = MyMath.Lerp(smooth, result, t * 10.0f);
}
else if (t > 0.9f)
{
result = MyMath.Lerp(smooth, result, (1.0f - t) * 10.0f);
}
}
break;
}
return(result);
} // TwitchCurve Apply()