Timer, use long millis instead of float seconds.

diff --git a/gdx/src/com/badlogic/gdx/utils/Timer.java b/gdx/src/com/badlogic/gdx/utils/Timer.java
index 4b7228e..c18d63f 100644 (file)
--- a/gdx/src/com/badlogic/gdx/utils/Timer.java
+++ b/gdx/src/com/badlogic/gdx/utils/Timer.java
@@ -28,16 +28,15 @@ public class Timer {
                        public void run () {\r
                                while (true) {\r
                                        synchronized (instances) {\r
-                                               float time = System.nanoTime() * MathUtils.nanoToSec;\r
-                                               float wait = Float.MAX_VALUE;\r
+                                               long timeMillis = System.nanoTime() / 1000000;\r
+                                               long waitMillis = Long.MAX_VALUE;\r
                                                for (int i = 0, n = instances.size; i < n; i++) {\r
                                                        try {\r
-                                                               wait = instances.get(i).update(time, wait);\r
+                                                               waitMillis = instances.get(i).update(timeMillis, waitMillis);\r
                                                        } catch (Throwable ex) {\r
                                                                throw new GdxRuntimeException("Task failed: " + instances.get(i).getClass().getName(), ex);\r
                                                        }\r
                                                }\r
-                                               long waitMillis = (long)(wait * 1000);\r
                                                try {\r
                                                        if (waitMillis > 0) instances.wait(waitMillis);\r
                                                } catch (InterruptedException ignored) {\r
@@ -80,8 +79,8 @@ public class Timer {
        /** Schedules a task to occur once after the specified delay and then a number of additional times at the specified interval. */\r
        public void scheduleTask (Task task, float delaySeconds, float intervalSeconds, int repeatCount) {\r
                if (task.repeatCount != CANCELLED) throw new IllegalArgumentException("The same task may not be scheduled twice.");\r
-               task.executeTime = System.nanoTime() * MathUtils.nanoToSec + delaySeconds;\r
-               task.intervalSeconds = intervalSeconds;\r
+               task.executeTimeMillis = System.nanoTime() / 1000000 + (long)(delaySeconds * 1000);\r
+               task.intervalMillis = (long)(intervalSeconds * 1000);\r
                task.repeatCount = repeatCount;\r
                synchronized (tasks) {\r
                        tasks.add(task);\r
@@ -114,12 +113,12 @@ public class Timer {
                }\r
        }\r
 \r
-       float update (float time, float wait) {\r
+       long update (long timeMillis, long waitMillis) {\r
                synchronized (tasks) {\r
                        for (int i = 0, n = tasks.size; i < n; i++) {\r
                                Task task = tasks.get(i);\r
-                               if (task.executeTime > time) {\r
-                                       wait = Math.min(wait, task.executeTime - time);\r
+                               if (task.executeTimeMillis > timeMillis) {\r
+                                       waitMillis = Math.min(waitMillis, task.executeTimeMillis - timeMillis);\r
                                        continue;\r
                                }\r
                                if (task.repeatCount != CANCELLED) {\r
@@ -134,13 +133,13 @@ public class Timer {
                                        i--;\r
                                        n--;\r
                                } else {\r
-                                       task.executeTime = time + task.intervalSeconds;\r
-                                       wait = Math.min(wait, task.executeTime - time);\r
+                                       task.executeTimeMillis = timeMillis + task.intervalMillis;\r
+                                       waitMillis = Math.min(waitMillis, task.intervalMillis);\r
                                        if (task.repeatCount > 0) task.repeatCount--;\r
                                }\r
                        }\r
                }\r
-               return wait;\r
+               return waitMillis;\r
        }\r
 \r
        static private void wake () {\r
@@ -177,8 +176,8 @@ public class Timer {
         * @see Timer\r
         * @author Nathan Sweet */\r
        static abstract public class Task implements Runnable {\r
-               float executeTime;\r
-               float intervalSeconds;\r
+               long executeTimeMillis;\r
+               long intervalMillis;\r
                int repeatCount = CANCELLED;\r
 \r
                /** If this is the last time the task will be ran or the task is first cancelled, it may be scheduled again in this method. */\r
@@ -186,7 +185,7 @@ public class Timer {
 \r
                /** Cancels the task. It will not be executed until it is scheduled again. This method can be called at any time. */\r
                public void cancel () {\r
-                       executeTime = 0;\r
+                       executeTimeMillis = 0;\r
                        repeatCount = CANCELLED;\r
                }\r
 \r