{
+
+ /**
+ * 3rd object
+ */
+ public T3 third;
+
+
+ /**
+ * Make structure of 3 objects
+ *
+ * @param objA 1st object
+ * @param objB 2nd object
+ * @param objC 3rd object
+ */
+ public Triad(T1 objA, T2 objB, T3 objC) {
+ super(objA, objB);
+ third = objC;
+ }
+
+
+ /**
+ * @return 3rd object
+ */
+ public T3 getThird()
+ {
+ return third;
+ }
+
+
+ /**
+ * Set 1st object
+ *
+ * @param obj 1st object
+ */
+ public void setThird(T3 obj)
+ {
+ third = obj;
+ }
+
+
+ @Override
+ public boolean equals(Object obj)
+ {
+ if (!super.equals(obj)) return false;
+
+ return Calc.areObjectsEqual(third, ((Triad) obj).third);
+
+ }
+
+
+ @Override
+ public int hashCode()
+ {
+ return super.hashCode() + (third == null ? 0 : third.hashCode());
+ }
+
+
+ @Override
+ public String toString()
+ {
+ return "TRIAD{" + first + "," + second + "," + third + "}";
+ }
+
+}
diff --git a/src/mightypork/utils/objects/VarargsParser.java b/src/mightypork/utils/objects/VarargsParser.java
new file mode 100644
index 0000000..56769c9
--- /dev/null
+++ b/src/mightypork/utils/objects/VarargsParser.java
@@ -0,0 +1,58 @@
+package mightypork.utils.objects;
+
+
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+
+/**
+ * Varargs parser
+ * Converts an array of repeated "key, value" pairs to a LinkedHashMap.
+ * example:
+ *
+ *
+ *
+ *
+ *
+ *
+ * Object[] array = { "one", 1, "two", 4, "three", 9, "four", 16 };
+ * Map<String, Integer> args = new VarargsParser<String, Integer>().parse(array);
+ *
+ *
+ * @author MightyPork
+ * @param Type for Map keys
+ * @param Type for Map values
+ */
+public class VarargsParser {
+
+ /**
+ * Parse array of vararg key, value pairs to a LinkedHashMap.
+ *
+ * @param args varargs
+ * @return LinkedHashMap
+ * @throws ClassCastException in case of incompatible type in the array
+ * @throws IllegalArgumentException in case of invalid array length (odd)
+ */
+ @SuppressWarnings("unchecked")
+ public Map parse(Object... args) throws ClassCastException, IllegalArgumentException
+ {
+ LinkedHashMap attrs = new LinkedHashMap();
+
+ if (args.length % 2 != 0) {
+ throw new IllegalArgumentException("Odd number of elements in varargs map!");
+ }
+
+ K key = null;
+ for (Object o : args) {
+ if (key == null) {
+ if (o == null) throw new RuntimeException("Key cannot be NULL in varargs map.");
+ key = (K) o;
+ } else {
+ attrs.put(key, (V) o);
+ key = null;
+ }
+ }
+
+ return attrs;
+ }
+}
diff --git a/src/mightypork/utils/string/StringUtils.java b/src/mightypork/utils/string/StringUtils.java
new file mode 100644
index 0000000..4221b64
--- /dev/null
+++ b/src/mightypork/utils/string/StringUtils.java
@@ -0,0 +1,181 @@
+package mightypork.utils.string;
+
+
+/**
+ * General purpose string utilities
+ *
+ * @author MightyPork
+ */
+public class StringUtils {
+
+ /**
+ * Get if string is in array
+ *
+ * @param needle checked string
+ * @param case_sensitive case sensitive comparision
+ * @param haystack array of possible values
+ * @return is in array
+ */
+ public static boolean isInArray(String needle, boolean case_sensitive, String... haystack)
+ {
+ if (case_sensitive) {
+ for (String s : haystack) {
+ if (needle.equals(s)) return true;
+ }
+ return false;
+ } else {
+ for (String s : haystack) {
+ if (needle.equalsIgnoreCase(s)) return true;
+ }
+ return false;
+ }
+ }
+
+
+ public static String fromLastDot(String s)
+ {
+ return fromLastChar(s, '.');
+ }
+
+
+ public static String toLastDot(String s)
+ {
+ return toLastChar(s, '.');
+ }
+
+
+ public static String fromLastChar(String s, char c)
+ {
+ if (s == null) return null;
+ return s.substring(s.lastIndexOf(c) + 1, s.length());
+ }
+
+
+ public static String toLastChar(String s, char c)
+ {
+ if (s == null) return null;
+ return s.substring(0, s.lastIndexOf(c));
+ }
+
+
+ /**
+ * Repeat a string
+ *
+ * @param repeated string
+ * @param count
+ * @return output
+ */
+ public static String repeat(String repeated, int count)
+ {
+ String s = "";
+ for (int i = 0; i < count; i++)
+ s += repeated;
+ return s;
+ }
+
+
+ /**
+ * convert string to a same-length sequence of # marks
+ *
+ * @param password password
+ * @return encoded
+ */
+ public static String passwordify(String password)
+ {
+ return passwordify(password, "*");
+ }
+
+
+ /**
+ * convert string to a same-length sequence of chars
+ *
+ * @param password password
+ * @param replacing character used in output
+ * @return encoded
+ */
+ public static String passwordify(String password, String replacing)
+ {
+ return repeat(replacing, password.length());
+ }
+
+
+ /**
+ * Get ordinal version of numbers (1 = 1st, 5 = 5th etc.)
+ *
+ * @param number number
+ * @return ordinal, string
+ */
+ public static String numberToOrdinal(int number)
+ {
+ if (number % 100 < 4 || number % 100 > 13) {
+ if (number % 10 == 1) return number + "st";
+ if (number % 10 == 2) return number + "nd";
+ if (number % 10 == 3) return number + "rd";
+ }
+ return number + "th";
+ }
+
+
+ /**
+ * Format number with thousands separated by a dot.
+ *
+ * @param number number
+ * @return string 12.004.225
+ */
+ public static String formatInt(long number)
+ {
+ String num = number + "";
+ String out = "";
+ String dot = ".";
+ int cnt = 1;
+ for (int i = num.length() - 1; i >= 0; i--) {
+ out = num.charAt(i) + out;
+ if (cnt % 3 == 0 && i > 0) out = dot + out;
+ cnt++;
+ }
+
+ return out;
+ }
+
+
+ public static boolean isValidFilenameChar(char ch)
+ {
+ return isValidFilenameString(Character.toString(ch));
+ }
+
+
+ public static boolean isValidFilenameString(String filename)
+ {
+ return filename.matches("[a-zA-Z0-9 +\\-.,_%@#!]+");
+ }
+
+
+ public static boolean isValidIdentifierChar(char ch)
+ {
+ return isValidIdentifierString(Character.toString(ch));
+ }
+
+
+ public static boolean isValidIdentifierString(String filename)
+ {
+ return filename.matches("[a-zA-Z0-9._]+");
+ }
+
+
+ public static String ellipsisStart(String orig, int length)
+ {
+ if (orig.length() > length) {
+ orig = "\u2026" + orig.substring(length, orig.length());
+ }
+ return orig;
+ }
+
+
+ public static String ellipsisEnd(String orig, int length)
+ {
+ if (orig.length() > length) {
+ orig = orig.substring(0, length - 1) + "\u2026";
+ }
+ return orig;
+ }
+}
diff --git a/src/mightypork/utils/string/validation/CharValidator.java b/src/mightypork/utils/string/validation/CharValidator.java
new file mode 100644
index 0000000..83fe898
--- /dev/null
+++ b/src/mightypork/utils/string/validation/CharValidator.java
@@ -0,0 +1,7 @@
+package mightypork.utils.string.validation;
+
+
+public interface CharValidator {
+
+ public boolean isValid(char c);
+}
diff --git a/src/mightypork/utils/string/validation/CharValidatorRegex.java b/src/mightypork/utils/string/validation/CharValidatorRegex.java
new file mode 100644
index 0000000..27b128f
--- /dev/null
+++ b/src/mightypork/utils/string/validation/CharValidatorRegex.java
@@ -0,0 +1,20 @@
+package mightypork.utils.string.validation;
+
+
+public class CharValidatorRegex implements CharValidator {
+
+ private String formula;
+
+
+ public CharValidatorRegex(String regex) {
+ this.formula = regex;
+ }
+
+
+ @Override
+ public boolean isValid(char c)
+ {
+ return Character.toString(c).matches(formula);
+ }
+
+}
diff --git a/src/mightypork/utils/string/validation/CharValidatorWhitelist.java b/src/mightypork/utils/string/validation/CharValidatorWhitelist.java
new file mode 100644
index 0000000..d270479
--- /dev/null
+++ b/src/mightypork/utils/string/validation/CharValidatorWhitelist.java
@@ -0,0 +1,20 @@
+package mightypork.utils.string.validation;
+
+
+public class CharValidatorWhitelist implements CharValidator {
+
+ private String whitelist;
+
+
+ public CharValidatorWhitelist(String allowed) {
+ this.whitelist = allowed;
+ }
+
+
+ @Override
+ public boolean isValid(char c)
+ {
+ return whitelist.contains(Character.toString(c));
+ }
+
+}
diff --git a/src/mightypork/utils/string/validation/FileSuffixFilter.java b/src/mightypork/utils/string/validation/FileSuffixFilter.java
new file mode 100644
index 0000000..ccb4713
--- /dev/null
+++ b/src/mightypork/utils/string/validation/FileSuffixFilter.java
@@ -0,0 +1,45 @@
+package mightypork.utils.string.validation;
+
+
+import java.io.File;
+import java.io.FileFilter;
+
+
+/**
+ * File filter for certain suffixes
+ *
+ * @author MightyPork
+ */
+public class FileSuffixFilter implements FileFilter {
+
+ /** Array of allowed suffixes */
+ private String[] suffixes = null;
+
+
+ /**
+ * Suffix filter
+ *
+ * @param suffixes var-args allowed suffixes, case insensitive
+ */
+ public FileSuffixFilter(String... suffixes) {
+ this.suffixes = suffixes;
+ }
+
+
+ @Override
+ public boolean accept(File pathname)
+ {
+ if (!pathname.isFile()) return false;
+
+ String fname = pathname.getName().toLowerCase().trim();
+
+ for (String suffix : suffixes) {
+ if (fname.endsWith(suffix.toLowerCase().trim())) {
+ return true;
+ }
+ }
+
+ return false;
+ }
+
+}
diff --git a/src/mightypork/utils/string/validation/FilenameCharValidator.java b/src/mightypork/utils/string/validation/FilenameCharValidator.java
new file mode 100644
index 0000000..6907264
--- /dev/null
+++ b/src/mightypork/utils/string/validation/FilenameCharValidator.java
@@ -0,0 +1,10 @@
+package mightypork.utils.string.validation;
+
+
+public class FilenameCharValidator extends CharValidatorRegex {
+
+ public FilenameCharValidator() {
+ super("[a-zA-Z0-9 +\\-.,_%@#$!'\"]");
+ }
+
+}
diff --git a/src/mightypork/utils/string/validation/StringFilter.java b/src/mightypork/utils/string/validation/StringFilter.java
new file mode 100644
index 0000000..e06e3f4
--- /dev/null
+++ b/src/mightypork/utils/string/validation/StringFilter.java
@@ -0,0 +1,12 @@
+package mightypork.utils.string.validation;
+
+
+/**
+ * Utility interface for string filters (accepting filepaths and similar)
+ *
+ * @author MightyPork
+ */
+public interface StringFilter {
+
+ public boolean accept(String entry);
+}
diff --git a/src/mightypork/utils/time/AnimDouble.java b/src/mightypork/utils/time/AnimDouble.java
new file mode 100644
index 0000000..48d9648
--- /dev/null
+++ b/src/mightypork/utils/time/AnimDouble.java
@@ -0,0 +1,263 @@
+package mightypork.utils.time;
+
+
+import mightypork.utils.math.Calc;
+
+
+/**
+ * Double which supports delta timing
+ *
+ * @author MightyPork
+ */
+public class AnimDouble implements Updateable, Pauseable {
+
+ /** target double */
+ protected double endValue = 0;
+
+ /** last tick double */
+ protected double startValue = 0;
+
+ /** how long the transition should last */
+ protected double duration = 0;
+
+ /** current anim time */
+ protected double elapsedTime = 0;
+
+ /** True if this animator is paused */
+ protected boolean paused = false;
+
+
+ /**
+ * @param value value
+ */
+ public AnimDouble(double value) {
+ setTo(value);
+ }
+
+
+ public AnimDouble(AnimDouble other) {
+ setTo(other);
+ }
+
+
+ /**
+ * Get start value
+ *
+ * @return number
+ */
+ public double getStartValue()
+ {
+ return startValue;
+ }
+
+
+ /**
+ * Get value at delta time
+ *
+ * @return the value
+ */
+ public double getCurrentValue()
+ {
+ if (duration == 0) return endValue;
+ return Calc.interpolate(startValue, endValue, elapsedTime / duration);
+ }
+
+
+ /**
+ * Get end value
+ *
+ * @return number
+ */
+ public double getEndValue()
+ {
+ return endValue;
+ }
+
+
+ /**
+ * Get how much of the animation is already finished
+ *
+ * @return completion ratio (0 to 1)
+ */
+ public double getProgress()
+ {
+ if (duration == 0) return 1;
+ return elapsedTime / duration;
+ }
+
+
+ @Override
+ public void update(double delta)
+ {
+ elapsedTime = Calc.clampd(elapsedTime + delta, 0, duration);
+ if (isFinished()) {
+ duration = 0;
+ elapsedTime = 0;
+ startValue = endValue;
+ }
+ }
+
+
+ /**
+ * Get if animation is finished
+ *
+ * @return is finished
+ */
+ public boolean isFinished()
+ {
+ return duration == 0 || elapsedTime >= duration;
+ }
+
+
+ /**
+ * Set to a value (without animation)
+ *
+ * @param value
+ */
+ public void setTo(double value)
+ {
+ startValue = endValue = value;
+ elapsedTime = 0;
+ duration = 0;
+ }
+
+
+ /**
+ * Copy other
+ *
+ * @param other
+ */
+ public void setTo(AnimDouble other)
+ {
+ this.startValue = other.startValue;
+ this.endValue = other.endValue;
+ this.duration = other.duration;
+ this.elapsedTime = other.elapsedTime;
+ this.paused = other.paused;
+ }
+
+
+ /**
+ * Animate between two states, discard current state
+ *
+ * @param from initial state
+ * @param to target state
+ * @param time animation time (secs)
+ */
+ public void animate(double from, double to, double time)
+ {
+ startValue = from;
+ endValue = to;
+ duration = time;
+ elapsedTime = 0;
+ }
+
+
+ /**
+ * Animate between two states, start from current value (if it's in between)
+ *
+ * @param from start value
+ * @param to target state
+ * @param time animation time (secs)
+ */
+ public void fadeTo(double from, double to, double time)
+ {
+ double current = getCurrentValue();
+
+ startValue = from;
+ endValue = to;
+ duration = time;
+ elapsedTime = 0;
+
+ // if in between, pick up from where it is
+ if (current >= from && current <= to) { // up
+ elapsedTime = ((current - from) / (to - from)) * time;
+ } else if (current >= to && current <= from) { // down
+ elapsedTime = ((from - current) / (from - to)) * time;
+ }
+ }
+
+
+ /**
+ * Animate 0 to 1
+ *
+ * @param time animation time (secs)
+ */
+ public void fadeIn(double time)
+ {
+ fadeTo(0, 1, time);
+ }
+
+
+ /**
+ * Animate 1 to 0
+ *
+ * @param time animation time (secs)
+ */
+ public void fadeOut(double time)
+ {
+ fadeTo(1, 0, time);
+ }
+
+
+ /**
+ * Make a copy
+ *
+ * @return copy
+ */
+ public Pauseable getCopy()
+ {
+ return new AnimDouble(this);
+ }
+
+
+ @Override
+ public String toString()
+ {
+ return "Animation(" + startValue + " -> " + endValue + ", t=" + duration + "s, elapsed=" + elapsedTime + "s)";
+ }
+
+
+ /**
+ * Set to zero and stop animation
+ */
+ public void clear()
+ {
+ startValue = endValue = 0;
+ elapsedTime = 0;
+ duration = 0;
+ paused = false;
+ }
+
+
+ /**
+ * Stop animation, keep current value
+ */
+ public void stop()
+ {
+ startValue = endValue = getCurrentValue();
+ elapsedTime = 0;
+ duration = 0;
+ }
+
+
+ @Override
+ public void pause()
+ {
+ paused = true;
+ }
+
+
+ @Override
+ public void resume()
+ {
+ paused = false;
+ }
+
+
+ @Override
+ public boolean isPaused()
+ {
+ return paused;
+ }
+}
diff --git a/src/mightypork/utils/time/AnimDoubleDeg.java b/src/mightypork/utils/time/AnimDoubleDeg.java
new file mode 100644
index 0000000..455fb3e
--- /dev/null
+++ b/src/mightypork/utils/time/AnimDoubleDeg.java
@@ -0,0 +1,41 @@
+package mightypork.utils.time;
+
+
+import mightypork.utils.math.Calc;
+
+
+/**
+ * Double which supports delta timing
+ *
+ * @author MightyPork
+ */
+public class AnimDoubleDeg extends AnimDouble {
+
+ /**
+ * new AnimDoubleDeg
+ *
+ * @param d value
+ */
+ public AnimDoubleDeg(double d) {
+ super(d);
+ }
+
+
+ /**
+ * Get value at delta time
+ *
+ * @return the value
+ */
+ @Override
+ public double getCurrentValue()
+ {
+ return Calc.interpolateDeg(startValue, endValue, elapsedTime / duration);
+ }
+
+
+ @Override
+ public void fadeTo(double from, double to, double time)
+ {
+ throw new UnsupportedOperationException("Cannot fadeTo in AnimDoubleDeg. Use animate() instead.");
+ }
+}
diff --git a/src/mightypork/utils/time/FpsMeter.java b/src/mightypork/utils/time/FpsMeter.java
new file mode 100644
index 0000000..90d0431
--- /dev/null
+++ b/src/mightypork/utils/time/FpsMeter.java
@@ -0,0 +1,62 @@
+package mightypork.utils.time;
+
+
+/**
+ * Class for counting FPS in games.
+ * This class can be used also as a simple frequency meter - output is in Hz.
+ *
+ * @author MightyPork
+ */
+public class FpsMeter {
+
+ private long frames = 0;
+ private long drops = 0;
+ private long lastTimeMillis = System.currentTimeMillis();
+ private long lastSecFPS = 0;
+ private long lastSecDrop = 0;
+
+
+ /**
+ * @return current second's FPS
+ */
+ public long getFPS()
+ {
+ return lastSecFPS;
+ }
+
+
+ /**
+ * Notification that frame was rendered
+ */
+ public void frame()
+ {
+ if (System.currentTimeMillis() - lastTimeMillis > 1000) {
+ lastSecFPS = frames;
+ lastSecDrop = drops;
+ frames = 0;
+ drops = 0;
+ lastTimeMillis = System.currentTimeMillis();
+ }
+ frames++;
+ }
+
+
+ /**
+ * Notification that some frames have been dropped
+ *
+ * @param dropped dropped frames
+ */
+ public void drop(int dropped)
+ {
+ drops += dropped;
+ }
+
+
+ /**
+ * @return current second's dropped frames
+ */
+ public long getDropped()
+ {
+ return lastSecDrop;
+ }
+}
diff --git a/src/mightypork/utils/time/Pauseable.java b/src/mightypork/utils/time/Pauseable.java
new file mode 100644
index 0000000..99d3101
--- /dev/null
+++ b/src/mightypork/utils/time/Pauseable.java
@@ -0,0 +1,23 @@
+package mightypork.utils.time;
+
+
+public interface Pauseable {
+
+ /**
+ * Pause operation
+ */
+ public void pause();
+
+
+ /**
+ * Resume operation
+ */
+ public void resume();
+
+
+ /**
+ * @return paused state
+ */
+ public boolean isPaused();
+
+}
diff --git a/src/mightypork/utils/time/TimerDelta.java b/src/mightypork/utils/time/TimerDelta.java
new file mode 100644
index 0000000..862dca9
--- /dev/null
+++ b/src/mightypork/utils/time/TimerDelta.java
@@ -0,0 +1,47 @@
+package mightypork.utils.time;
+
+
+/**
+ * Timer for delta timing
+ *
+ * @author MightyPork
+ */
+public class TimerDelta {
+
+ private long lastFrame;
+
+ private static final long SECOND = 1000000000; // a million nanoseconds
+
+
+ /**
+ * New delta timer
+ */
+ public TimerDelta() {
+ lastFrame = System.nanoTime();
+ }
+
+
+ /**
+ * Get current time in NS
+ *
+ * @return current time NS
+ */
+ public long getTime()
+ {
+ return System.nanoTime();
+ }
+
+
+ /**
+ * Get time since the last "getDelta()" call.
+ *
+ * @return delta time (seconds)
+ */
+ public double getDelta()
+ {
+ long time = getTime();
+ double delta = (time - lastFrame) / (double) SECOND;
+ lastFrame = time;
+ return delta;
+ }
+}
diff --git a/src/mightypork/utils/time/TimerInterpolating.java b/src/mightypork/utils/time/TimerInterpolating.java
new file mode 100644
index 0000000..3cfee74
--- /dev/null
+++ b/src/mightypork/utils/time/TimerInterpolating.java
@@ -0,0 +1,105 @@
+package mightypork.utils.time;
+
+
+/**
+ * Timer for interpolated timing
+ *
+ * @author MightyPork
+ */
+public class TimerInterpolating {
+
+ private long lastFrame = 0;
+ private long nextFrame = 0;
+ private long skipped = 0;
+ private long lastSkipped = 0;
+
+ private static final long SECOND = 1000000000; // a million nanoseconds
+ private long FRAME; // a time of one frame in nanoseconds
+
+
+ /**
+ * New interpolated timer
+ *
+ * @param fps target FPS
+ */
+ public TimerInterpolating(long fps) {
+ FRAME = Math.round(SECOND / fps);
+
+ lastFrame = System.nanoTime();
+ nextFrame = System.nanoTime() + FRAME;
+ }
+
+
+ /**
+ * Sync and calculate dropped frames etc.
+ */
+ public void sync()
+ {
+ long time = getTime();
+ if (time >= nextFrame) {
+ long skippedNow = (long) Math.floor((time - nextFrame) / (double) FRAME) + 1;
+ //System.out.println("Skipping: "+skippedNow);
+ skipped += skippedNow;
+ lastFrame = nextFrame + (1 - skippedNow) * FRAME;
+ nextFrame += skippedNow * FRAME;
+ }
+ }
+
+
+ /**
+ * Get nanotime
+ *
+ * @return nanotime
+ */
+ public long getTime()
+ {
+ return System.nanoTime();
+ }
+
+
+ /**
+ * Get fraction of next frame
+ *
+ * @return fraction
+ */
+ public double getFraction()
+ {
+ if (getSkipped() >= 1) {
+ return 1;
+ }
+
+ long time = getTime();
+
+ if (time <= nextFrame) {
+ return (double) (time - lastFrame) / (double) FRAME;
+ }
+
+ return 1;
+ }
+
+
+ /**
+ * Get number of elapsed ticks
+ *
+ * @return ticks
+ */
+ public int getSkipped()
+ {
+ long change = skipped - lastSkipped;
+ lastSkipped = skipped;
+ return (int) change;
+ }
+
+
+ /**
+ * Clear timer and start counting new tick.
+ */
+ public void startNewFrame()
+ {
+ //System.out.println("! start new frame !");
+ long time = getTime();
+ lastFrame = time;
+ nextFrame = time + FRAME;
+ lastSkipped = skipped;
+ }
+}
diff --git a/src/mightypork/utils/time/Updateable.java b/src/mightypork/utils/time/Updateable.java
new file mode 100644
index 0000000..6512069
--- /dev/null
+++ b/src/mightypork/utils/time/Updateable.java
@@ -0,0 +1,17 @@
+package mightypork.utils.time;
+
+
+/**
+ * object supporting delta timing
+ *
+ * @author MightyPork
+ */
+public interface Updateable {
+
+ /**
+ * Update item state based on elapsed time
+ *
+ * @param delta time elapsed since last update, in seconds
+ */
+ public void update(double delta);
+}
diff --git a/src/net/mightypork/rogue/Game.java b/src/net/mightypork/rogue/Game.java
deleted file mode 100644
index 50de2dc..0000000
--- a/src/net/mightypork/rogue/Game.java
+++ /dev/null
@@ -1,52 +0,0 @@
-package net.mightypork.rogue;
-
-import org.mini2Dx.core.game.BasicGame;
-import org.mini2Dx.core.game.Mini2DxGame;
-import org.mini2Dx.core.graphics.Graphics;
-
-import com.badlogic.gdx.backends.lwjgl.LwjglApplication;
-import com.badlogic.gdx.backends.lwjgl.LwjglApplicationConfiguration;
-
-
-public class Game extends BasicGame {
-
- @Override
- public void initialise() {
-
- // TODO Auto-generated method stub
-
- }
-
- @Override
- public void interpolate(float arg0) {
-
- // TODO Auto-generated method stub
-
- }
-
- @Override
- public void render(Graphics arg0) {
-
- // TODO Auto-generated method stub
-
- }
-
- @Override
- public void update(float arg0) {
-
- // TODO Auto-generated method stub
-
- }
-
- public static void main(String [] args) {
- LwjglApplicationConfiguration cfg = new LwjglApplicationConfiguration();
- cfg.title = "A basic game";
- cfg.useGL20 = true;
- cfg.width = 800;
- cfg.height = 600;
- cfg.useCPUSynch = false;
- cfg.vSyncEnabled = true;
- new LwjglApplication(new Mini2DxGame(new Game()), cfg);
- }
-
-}