It's a simple change to logic really, simply use a >=
test instead. If Ticks
is greater than or equal to your trigger amount, you should fire the trigger. Then you use the Ticks += delta;
to increment it. Additionally, you can create a more generic object to hold information for a single event.
class EventObject {
float TimeSinceTrigger = 0;
float TriggerInterval;
boolean FireOnce;
boolean Fired;
public EventObject(float triggerInterval, boolean fireOnce) {
TriggerInterval = triggerInterval;
FireOnce = fireOnce;
}
public void update(float delta) {
TimeSinceTrigger += delta;
}
public bool isReady() {
if(FireOnce && Fired)
return false;
if(TimeSinceTrigger >= TriggerInterval) {
//We're ready, if we fire only once, set our flag for that
// otherwise, reset our time since trigger to fire again later.
if(FireOnce)
Fired = true;
else
TimeSinceTrigger = 0;
return true;
}
return false;
}
}
Then you can use that object like:
//Instantiate the objects
EventObject repeatingEvent = new EventObject(1000, false);
EventObject singleFireEvent = new EventObject(1000, true);
//At the beginning of your update loop:
repeatingEvent.update(delta);
singleFireEvent.update(delta);
//Wherever else in your update loop
if(repeatingEvent.isReady()) {
RunRepeatingEventCode();
}
if(singleFireEvent.isReady()) {
FireSingleEventCode();
}
With that, you're on your way to a robust event system. It could certainly use a lot of improvement. For example, keeping the event objects in a list, so you can stop updating them if they're done.
As for getting accurate delta time, you're on the right path. You System.nanoTime()
would be used like:
long lastUpdate = System.nanoTime();
//In the update method
long currentTime = System.nanoTime();
long delta = currentTime - lastUpdate;
lastUpdate = currentTime;