Modular arithmetic can help you here. % is the modulus operator in Java, and the expression X % Y returns the remainder of the division operation X / Y. This is useful for making numbers "wrap around."

Based on your sample code, a full cycle of your day is 200 units of Statistics.duration. The first 50 are the day portion, the second 50 are the noon portion, the next 50 are dusk, the last 50 are night.

Thus, Statistics.duration % 200 will give you a value between 0 and 199. If that value is less than 50, you're in the day time. Between 50 and 100, dusk. And so on. Your code can then become something like...

public void updateTime() { int timeOfDay= Statistics.duration % 200; if (timeOfDay <= 50){ // it's dawn... } else if (timeOfDay > 50 && timeOfDay <= 100) { // it's noon... } else if (timeOfDay > 100 && timeOfDay <= 150) { // it's dusk... } else { // it's night... } } 

You can wrap that entire block in your check for dungeon level as well as whatever else you might need.

Josh Petrie is right.

Futhermore, you could use an enum to avoid using if else if.

public enum DayTime { DAWN(0), NOON(1), DUSK(2), NIGHT(3); private int n; DayTime(int n) { this.n = n; } public static DayTime valueOf(int n) { for (DayTime value : values()) { int i = value.n; if (n == i) { return value; } } return null; } } public void updateTime() { int dayTimeIndex = Statistics.duration % 200 / 50; DayTime dayTime = DayTime.valueOf(dayTimeIndex); ... } 

The easiest thing you can do is, for example, % the actual time.

actualtime %= MAX_TIME; 

Very easy method!

My first thought

If I understood correclty, you wants it to repeat the time as in a cycle, so you have a "class" which handles time by using modulus.

//I don't know how to write it on Java class TimeHandler = { var current = 0; const max = 200; update() => { // it will make "current" eventually become 0 again current = (1 + current) % max;//it does not use "++" because some languages do not guarantee the order of operations } getPeriod() => { return PeriodFabric.for(current, max); } } 

The fabric return the right period for a given time

class PeriodFabric = { const periods = [DAWN, NOON, DUSK, NIGHT]; for(time, max) { var qt = max / periods.length; var range = Math.floor(time / qt); return periods[range]; } } 

This period can be forward to whatever classes need it, as the dungeon.

class Dungeon = { var nightMode = null; update(period) { nightMode = periord === NIGHT && depth > 100; } } 

Separating like this has the advantage of separing concers

• you could have multiple cycles which are concerned to time (as day/night, seasons, etc) or even better modify TimeHandler to make it generic.
• you can create more periods without modifying the TimeHandler
• you can pass periods forward to classes which behave based on it, as I did on the dungeon, so the responsabily to declare its nightMode lives there

My friend's suggestion

I talked this answer to a friend, he's suggested me that instead of returning the period, classes would subscribe to "PeriodFabric" which would notify them when the period had changed, passing the new period to its subscrivers.

You probably want to use the sine function.

Suppose you have the time of day t for a 24 for hour day, so 0 <= t < 24.

Then you want to map t to a value t' between 0 <= t' < \pi.

So t' = t * \pi / 24. At t = 0 we want t' = 0, at t = 12 we want t' = \pi / 2

Now let y = sin(t').

When y = 0 it is midnight, and when y = 1 it is noon.

Let L be your light level at noon and l be your light level as a function of time.

You can define l(t) = Ly = Lsin(t').

Your light level now transitions smoothly through the entire cycle as a function of t and you have removed branching entirely.

You can further parameterize t if you wish manipulate how time passes.