public static void Update(DeltaTime dt)
{
if (updateQueue.Count > 0)
{
while (updateQueue.Count > 0)
{
UpdateBuffer(updateQueue.Dequeue());
}
ApplyBufferUpdates();
}
foreach (UIItem item in uiItems[currentLayer])
{
item.Update(dt);
}
}
public override void Update(DeltaTime deltaTime)
{
/*
* delay -= deltaTime.Seconds;
*
* if (delay <= 0) {
* delay = 2;
* index++;
* if (index >= grades.Length) index = 0;
* FinalizeScore();
* }*/
returnButton.Update(deltaTime);
Draw();
}
//Coulnd't get this to work with deltaTime. Since it's just a misc visual effect I don't think it's worth the time to fix it.
private void UpdatePoint(int pointIndex, DeltaTime deltaTime)
{
float dif = WaterPoints[pointIndex].Y - line;
float acc = -k * dif - (dampening * pointVel[pointIndex]);
deltaHeight[pointIndex] += pointVel[pointIndex];
pointVel[pointIndex] += acc;
if (pointIndex > 0)
{
pointVel[pointIndex - 1] += spread * (WaterPoints[pointIndex].Y - WaterPoints[pointIndex - 1].Y);
}
if (pointIndex < surfacePoints - 1)
{
pointVel[pointIndex + 1] += spread * (WaterPoints[pointIndex].Y - WaterPoints[pointIndex + 1].Y);
}
}
protected override void Update(DeltaTime delta)
{
if (Input.IsKeyReleased(InputKey.F1))
{
renderVisualizer = !renderVisualizer;
}
if (Input.IsKeyReleased(InputKey.F2))
{
string jsonData = SceneTree.SaveToJson(tree);
File.WriteAllText("_Data/Scenes/SavedDebugScene.json", jsonData);
}
if (renderVisualizer)
{
visualizer.Update(delta);
}
}
public override void Update(DeltaTime deltaTime)
{
Point mouse = Program.Input.MouseLocation;
bool mouseDown = Program.Input.MouseDown;
Hovered = (mouse.X >= origin.X && mouse.X <= origin.X + Size.Width) &&
(mouse.Y >= origin.Y && mouse.Y <= origin.Y + Size.Height);
if (clickBuildup > 0)
{
clickBuildup -= clickBuildupDecrease * deltaTime.Seconds;
if (clickBuildup < 0)
{
clickBuildup = 0;
}
}
if (Hovered)
{
if (mouseDown != lastDown && Selectable)
{
if ((SelectMode == SelectMode.OnMouseUp && mouseDown == false) ||
(SelectMode == SelectMode.OnMouseDown && mouseDown == true))
{
Select();
}
}
if (Hoverable && hoverBuildup < hoverBuildupMax && clickBuildup == 0)
{
hoverBuildup += hoverBuildupIncrease * deltaTime.Seconds;
}
}
else if (hoverBuildup > 0)
{
hoverBuildup -= hoverBuildupDecrease * deltaTime.Seconds;
if (hoverBuildup < 0)
{
hoverBuildup = 0;
}
}
lastDown = mouseDown;
}
public override void Update(DeltaTime deltaTime)
{
if (currentFade <= 0)
{
return;
}
if (currentFadeDelay > 0)
{
currentFadeDelay -= deltaTime.Seconds;
}
else
{
currentFade -= deltaTime.Seconds;
}
currentBarWidth = (int)((currentFade / FadeTime) * BarWidth);
}
public override void Update(DeltaTime deltaTime)
{
graphics.FillRectangle(Brushes.White, 0, 0, Program.Width, Program.Height);
graphics.DrawImageUnscaled(flag.Image, 0, 0);
graphics.DrawString(flag.Country, Form1.DefaultFont, Brushes.Black, 400, 400);
x -= (int)deltaTime.Milliseconds;
if (x <= 0)
{
x = 1000;
//index = new Random().Next(0, Program.Flags.getFlags().Count-1);
index++;
flag = Program.Flags.GetFlags()[index];
}
Console.WriteLine(deltaTime.Milliseconds + " " + x);
}
private void Worker()
{
try
{
var stopwatch = new Stopwatch();
var deltaTime = new DeltaTime();
while (this.running)
{
var elapsed = stopwatch.Elapsed;
stopwatch.Reset();
stopwatch.Start();
deltaTime.ElapsedTime = elapsed;
deltaTime.TotalTime += elapsed;
try
{
this.DoUpdate(deltaTime);
}
catch (Exception exception)
{
this.OnUpdateError(exception);
}
var updateTime = stopwatch.Elapsed;
var timeToSleep = (int)(this.updateInterval - updateTime).TotalMilliseconds;
if (timeToSleep < 1)
{
timeToSleep = 1;
}
this.Tracker?.AddValue(updateTime);
if (this.running)
{
this.workerThreadExitResetEvent?.WaitOne(timeToSleep);
}
}
}
catch (ThreadAbortException)
{
}
}
public void Update(DeltaTime dt)
{
if (!Animations[currentAnimation].Update(dt))
{
currentCallback?.Invoke(true);
if (queuedAnimation != -1)
{
currentAnimation = queuedAnimation;
currentCallback = queuedCallback;
queuedAnimation = -1;
}
else
{
currentAnimation = idleAnimation;
currentCallback = null;
}
Animations[currentAnimation].Start( );
}
}
public void Update(DeltaTime delta)
{
if (Input.IsKeyPressed(InputKey.ArrowUp))
{
MoveUp();
}
else if (Input.IsKeyPressed(InputKey.ArrowDown))
{
MoveDown();
}
else if (Input.IsKeyPressed(InputKey.ArrowLeft))
{
MoveLeft();
}
else if (Input.IsKeyPressed(InputKey.ArrowRight))
{
MoveRight();
}
}
//-------------------------------------------------------------------------------
//-------------------------------------------------------------------------------
public SpriteAnimationData UpdateCurrentAnimation(DeltaTime deltaTime)
{
SpriteAnimationData data = new SpriteAnimationData();
if (m_currentAnimation != null && !Paused)
{
m_fTimeElapsedScinceLastFrame += deltaTime.ElapsedGameTime.TotalMilliseconds;
if (m_fTimeElapsedScinceLastFrame >= m_fDesiredElapsedTime)
{
data.m_currentFrame.X = Direction == AnimationDirection.Forward ? m_currentFrame.X++ : m_currentFrame.X--;
m_fTimeElapsedScinceLastFrame = 0;
}
else
{
data.m_currentFrame.X = m_currentFrame.X;
}
data.m_currentFrame.Y = m_currentFrame.Y;
data.m_frameSize = m_currentAnimation.m_frameSize;
if ((m_currentFrame.X * m_currentAnimation.m_frameSize.X) >= m_currentAnimation.m_sheetSize.X)
{
if (m_currentAnimation.m_bLooping)
{
m_currentFrame = Frame.Zero;
}
else
{
m_currentAnimation = null;
}
}
}
//We need to do this if it is paused with an animation.
else if (m_currentAnimation != null && Paused)
{
data.m_currentFrame = m_currentFrame;
data.m_frameSize = m_currentAnimation.m_frameSize;
}
return(data);
}
public override void Update(DeltaTime deltaTime)
{
/*
* ticks++;
* if(timer.ElapsedMilliseconds >= 1000)
* {
* Console.WriteLine("{0} tps", ticks);
* ticks = 0;
* timer.Restart();
* }
*/
if (freezeTime > 0)
{
SetFlagLocations();
freezeTime -= deltaTime.Seconds;
if (freezeTime <= 0)
{
foreach (QuizButton b in buttons)
{
b.Selectable = true;
b.Hoverable = true;
}
freezeTime = 0;
NextFlag();
}
}
foreach (QuizButton b in buttons)
{
b.Update(deltaTime);
}
tracker.Update(deltaTime);
scoreAddLabel.Update(deltaTime);
Draw();
}
public override void Update(DeltaTime deltaTime)
{
foreach (Button b in stateButtons)
{
b.Update(deltaTime);
}
if (selectedStartButtons >= 0)
{
foreach (Button b in startButtons[selectedStartButtons])
{
if (b != null)
{
b.Update(deltaTime);
}
}
}
Draw();
}
//-------------------------------------------------------------------------------
//-------------------------------------------------------------------------------
public override void Draw(DeltaTime deltaTime)
{
CallRequestInfo(deltaTime);
if (m_RenderInfoList.Count > 0)
{
if (EffectSettings != null)
{
EffectSettings.m_fpUpdate(EffectSettings.m_effect, EffectSettings.m_effectSettings);
}
//This is a little ugly but ill work it out later
if (Effect != null)
{
m_spriteBatch.Begin(SpriteSortMode.Deferred, BlendState, null, null, null, Effect);
}
else
{
m_spriteBatch.Begin();
}
foreach (SpriteInfo spriteInfo in m_RenderInfoList)
{
m_spriteBatch.Draw(spriteInfo.m_texture2D,
spriteInfo.m_v2Position,
new Rectangle((int)(((spriteInfo.m_animationData.m_frameSize.X) * spriteInfo.m_animationData.m_currentFrame.X)),
(int)(((spriteInfo.m_animationData.m_frameSize.Y) * spriteInfo.m_animationData.m_currentFrame.Y)),
spriteInfo.m_animationData.m_frameSize.X,
spriteInfo.m_animationData.m_frameSize.Y),
spriteInfo.m_colour,
spriteInfo.m_fRotation,
spriteInfo.m_v2Origin,
spriteInfo.m_v2ScaleFactor,
spriteInfo.m_eSpriteEffects,
spriteInfo.m_fDepth);
}
m_spriteBatch.End();
m_RenderInfoList.Clear();
}
base.Draw(deltaTime);
}
private void UpdateTblDelta(float curPosX, string fromFlag)
{
if (_deltaList == null)
{
return;
}
DeltaTime tblDeltaTime = new DeltaTime()
{
pos = curPosX, time = Time.time, flag = fromFlag
};
if (_deltaList.Count < TBL_DELTA_COUNT)
{
_deltaList.Add(tblDeltaTime);
}
else
{
_deltaList.RemoveAt(0);
_deltaList.Add(tblDeltaTime);
}
}
public override void Update(DeltaTime deltaTime)
{
if (!loading)
{
loading = true;
Font loadFont = new Font("Arial", 40, FontStyle.Bold);
Size textSize = TextRenderer.MeasureText(loadingMessage, loadFont);
graphics.FillRectangle(Brushes.Black, 0, 0, Program.Width, Program.Height);
TextRenderer.DrawText(graphics, loadingMessage, loadFont, new Point(Program.Width / 2 - textSize.Width / 2, Program.Height / 2 - textSize.Height / 2), Color.White);
base.Update(deltaTime);
Program.Flags.Populate();
}
else
{
Program.SetCurrentState(Program.MainMenu);
}
}
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
private void GenerateParticles(DeltaTime deltaTime)
{
if (deltaTime.ElapsedGameTime.Milliseconds > ParticleController.GenerationTimer)
{
for (int nCounter = 0; nCounter < ParticleController.GenerationRate; ++nCounter)
{
if (m_freeParticleList.Count > 0)
{
IParticle particle = m_freeParticleList.Dequeue();
particle.Scale = ParticleController.InitialScale;
ParticleController.InitializeParticle(ref particle, this);
particle.OnInitilized();
particle.Active = true;
}
else
{
break;
}
}
}
}
//----------------------------------------------------------------------------
//I have made this public so the consumer has the choice of running this multi-threaded or not.
//----------------------------------------------------------------------------
public void UpdateSimulation(DeltaTime deltaTime = default(DeltaTime))
{
PhysicsBody[] aBodies = null;
lock (m_UpdateLock)
{
if (m_updateList.Count > 0)
{
aBodies = m_updateList.ToArray();
m_updateList.Clear();
}
}
if (aBodies == null)
{
return;
}
m_updateTime = deltaTime;
Parallel.ForEach(aBodies, Simulate);
}
public Node <INode> GetNode(string nodeName, IConstellationFileParser constellationFileParser)
{
switch (nodeName)
{
case DeltaTime.NAME:
INode nodeDeltaTime = new DeltaTime() as INode;
return(new Node <INode> (nodeDeltaTime));
case ObjectParameter.NAME:
INode nodeObjectAttribute = new ObjectParameter() as INode;
return(new Node <INode> (nodeObjectAttribute));
case Update.NAME:
INode nodeUpdate = new Update() as INode;
return(new Node <INode> (nodeUpdate));
case LateUpdate.NAME:
INode nodeLateUpdate = new LateUpdate() as INode;
return(new Node <INode> (nodeLateUpdate));
case PlayerPreferences.NAME:
INode nodePlayerPref = new PlayerPreferences() as INode;
return(new Node <INode> (nodePlayerPref));
case LoadScene.NAME:
INode nodeLoadScene = new LoadScene() as INode;
return(new Node <INode> (nodeLoadScene));
case Quit.NAME:
INode quit = new Quit() as INode;
return(new Node <INode> (quit));
case AddConstellationBehaviourFromJSON.NAME:
INode addConstellationBehaviourFromJSON = new AddConstellationBehaviourFromJSON() as INode;
return(new Node <INode>(addConstellationBehaviourFromJSON));
default:
return(null);
}
}
public override int GetHashCode()
{
var hashCode = -1389298070;
hashCode = hashCode * -1521134295 + EqualityComparer <string> .Default.GetHashCode(Name);
hashCode = hashCode * -1521134295 + CameraFOV.GetHashCode();
hashCode = hashCode * -1521134295 + CameraFOV.GetHashCode();
hashCode = hashCode * -1521134295 + DeltaTime.GetHashCode();
hashCode = hashCode * -1521134295 + Speed.GetHashCode();
hashCode = hashCode * -1521134295 + G.GetHashCode();
hashCode = hashCode * -1521134295 + Epoch.GetHashCode();
hashCode = hashCode * -1521134295 + CollisionsType.GetHashCode();
foreach (MaterialPoint body in Bodies)
{
hashCode = hashCode * -1521134295 + body.GetHashCode();
}
hashCode = hashCode * -1521134295 + EnableTracers.GetHashCode();
return(hashCode);
}
protected bool TryGetNext(out TSignal signal, DeltaTime deltaTime)
{
while (true)
{
if (this.basicQueue.TryDequeue(out var info))
{
if (info.Delay != TimeSpan.Zero)
{
lock (this.syncRoot)
{
this.delayedQueue.Push(new DelayedSignalInfo(info.Signal, deltaTime.TotalTime.Add(info.Delay)));
}
continue;
}
signal = info.Signal;
return(true);
}
lock (this.syncRoot)
{
if (this.delayedQueue.Count > 0)
{
var item = this.delayedQueue.Top;
if (item.TargetDeltaTime <= deltaTime.TotalTime)
{
this.delayedQueue.Pop();
signal = item.Signal;
return(true);
}
}
}
signal = default(TSignal);
return(false);
}
}
private void UpdateNode(DeltaTime deltaTime, bool isFixedUpdate, ulong id, bool parentExecuting = true)
{
SceneNode node = allNodes[id];
if (node.updatePolicy == NodeUpdatePolicy.AlwaysExecute ||
(node.updatePolicy == NodeUpdatePolicy.FollowParent && parentExecuting))
{
if (isFixedUpdate)
{
node.FixedUpdate(deltaTime);
}
else
{
node.Update(deltaTime);
}
parentExecuting = true;
}
foreach (ulong childId in node.children)
{
UpdateNode(deltaTime, isFixedUpdate, childId, parentExecuting);
}
}
private List <TimeSpan> GetDeltas()
{
var delta = DeltaTime.Get();
var previous = dtFecha.SelectedDate;
StartDate.Set(previous.GetValueOrDefault().Add(StartDate.Get().TimeOfDay));
foreach (C1GridViewRow item in gridEstados.Rows)
{
var txt = item.FindControl("txtHoraEstado") as TextBox;
if (txt != null)
{
var time = GetHours(txt.Text, previous.GetValueOrDefault());
var ts = time.Subtract(previous.GetValueOrDefault());
if (item.RowIndex == 0)
{
StartDate.Set(time);
}
previous = time;
if (ts == delta[item.RowIndex])
{
continue;
}
delta[item.RowIndex] = ts;
}
break;
}
return(delta);
}
public override void Update(DeltaTime deltaTime)
{
if (Enabled && currentFade < maxFade)
{
currentFade += deltaTime.Seconds;
if (currentFade > maxFade)
{
currentFade = maxFade;
}
}
else if (!Enabled && currentFade > 0)
{
currentFade -= deltaTime.Seconds;
if (currentFade < 0)
{
currentFade = 0;
}
}
foreach (QuizButton b in Buttons)
{
b.Update(deltaTime);
}
}
/// <summary>
/// Get the first DeltaTime Interval inside a DeltaTime to split into defined units
/// </summary>
/// <param name="delta">The DeltaTime to iterate</param>
/// <returns>The first DeltaTime day interval</returns>
public static DeltaTime First(this DeltaTime delta)
{
//Parse the interval to date for manage
DateTime start = DateTime.Parse(delta.StartTime, null, System.Globalization.DateTimeStyles.RoundtripKind);
//Same for end NOTE: Could be optimized using a clone of start
DateTime end = DateTime.Parse(delta.StartTime, null, System.Globalization.DateTimeStyles.RoundtripKind);
//Use add for set the end DateTime unit
if (start.Hour == _morningStartHour)
{
end = end.AddHours(_morningEndHour - _morningStartHour);
}
if (start.Hour == _afternoonStartHour)
{
end = end.AddHours(_afternoonEndHour - _afternoonStartHour);
}
//Else Not clamped DeltaTime ERROR
//Return the new DeltaTime having "o" (ISO 8601) DateTime string formatted
return(new DeltaTime {
StartTime = start.ToString("o"), EndTime = end.ToString("o")
});
}
/// <summary>
/// Determinate if a Deltatime start is in the future compared to current time
/// </summary>
/// <param name="deltaTime">This item to check</param>
/// <returns>Bool true : the start time is in the future</returns>
public static bool IsFuture(this DeltaTime deltaTime)
{
var now = DateTime.Now.ToString("o");
return(string.Compare(deltaTime.StartTime, now) > 0);
}
public virtual void Update(DeltaTime deltaTime)
{
}
/// <summary>
/// Creates a new Derivative object.
/// </summary>
/// <param name="initialCondition">Initial value to set x</param>
public Derivative(double initialCondition)
{
m_xPrev = initialCondition;
m_dt = new DeltaTime();
}
/// <summary>
/// New Integral.
/// </summary>
public Integral()
{
m_value = 0;
m_dt = new DeltaTime();
}
protected abstract void DoUpdate(DeltaTime deltaTime);
/// <summary> /// Validator for DeltaTime class /// <para> /// Delta time valid definition is a delta time that has EndTime attribute /// Bigger than StartTime attribute, the two values should be string "o" (ISO 8601) formatted DateTime classes /// </para> /// </summary> /// <param name="deltaTime">Target to validate</param> /// <returns>The bool that indicates the valid status</returns> public static bool IsValid(this DeltaTime deltaTime) => (string.Compare(deltaTime.StartTime, deltaTime.EndTime) < 0);
//-------------------------------------------------------------------------------
//-------------------------------------------------------------------------------
public void Draw(DeltaTime deltaTime, ICamera camera)
{
m_octreeRoot.Draw(deltaTime, camera);
}
