physics experiments

src/me/hammerle/snuviengine/Main.java

@@ -1,11 +1,11 @@
 package me.hammerle.snuviengine;
 
-import me.hammerle.snuviengine.api.LazyWindowView;
+import me.hammerle.snuviengine.api.ResizingWindowView;
 import me.hammerle.snuviengine.api.Window;
 
 public class Main {
     public static void main(String[] args) {
-        Window window = new Window(50_000_000, new LazyWindowView(4, 3));
+        Window window = new Window(50_000_000, new ResizingWindowView(400, 300));
         if(window.initialize("wusi", 1024, 620)) {
             TestGame game = new TestGame();
             window.open(game);

src/me/hammerle/snuviengine/TestGame.java

@@ -1,5 +1,7 @@
 package me.hammerle.snuviengine;
 
+import java.util.ArrayList;
+import java.util.Random;
 import me.hammerle.snuviengine.api.Gamepad;
 import me.hammerle.snuviengine.api.Renderer;
 import me.hammerle.snuviengine.api.Game;
@@ -7,56 +9,136 @@ import me.hammerle.snuviengine.api.Keys;
 import me.hammerle.snuviengine.api.Stats;
 
 public class TestGame implements Game {
-    private float posX = 200.0f;
-    private float posY = 0.0f;
-    private float lastPosX = 0.0f;
-    private float lastPosY = 0.0f;
-    private float move = 16.5f;
-    private final float size = 20.0f;
+    private static final float MIN_X = 0.0f;
+    private static final float MIN_Y = 0.0f;
+    private static final float MAX_X = 200.0f;
+    private static final float MAX_Y = 300.0f;
+
+    private static final float SIZE = 12.0f;
 
     private Stats stats = null;
     private Gamepad gamepad = null;
+    private Keys keys = null;
+
+    private static class Entity {
+        private float lastPosX;
+        private float lastPosY;
+
+        private float posX;
+        private float posY;
+
+        private float motionX;
+        private float motionY;
+
+        private int color = 0xFF0000FF;
+
+        public boolean collidesWith(Entity e) {
+            return posX < e.posX + SIZE && posX + SIZE > e.posX
+                    && posY < e.posY + SIZE && posY + SIZE > e.posY;
+        }
+
+        public void collide(Entity e) {
+            if(!collidesWith(e)) {
+                return;
+            }
+
+            color = 0xFFFF00FF;
+            e.color = 0xFFFF00FF;
+
+            float diffX = SIZE - (e.posX - posX);
+            float diffY = SIZE - (e.posY - posY);
+
+            motionX += diffX;
+            motionY = diffY;
+            e.motionX -= diffX;
+            e.motionY -= diffY;
+        }
+    }
+
+    private final Random r = new Random(0);
+    private final ArrayList<Entity> entities = new ArrayList<>();
 
     @Override
     public void onCompleteInitialization(Stats stats, Keys keys, Gamepad gamepad) {
         this.stats = stats;
         this.gamepad = gamepad;
+        this.keys = keys;
+
+        for(int i = 0; i < 2; i++) {
+            Entity e = new Entity();
+            e.posX = MIN_X + r.nextFloat() * (MAX_X - MIN_X - SIZE);
+            e.posY = MIN_Y + r.nextFloat() * (MAX_Y - MIN_Y - SIZE);
+            e.lastPosX = e.posX;
+            e.lastPosY = e.posY;
+            double angle = r.nextDouble() * 2.0 * Math.PI;
+            double radius = 3.0;
+            e.motionX = (float) (Math.sin(angle) * radius);
+            e.motionY = (float) (Math.cos(angle) * radius);
+            entities.add(e);
+        }
+        entities.get(0).posX = 100;
+        entities.get(1).posX = 100;
+        entities.get(0).lastPosX = 100;
+        entities.get(1).lastPosX = 100;
+        entities.get(0).motionX = 0;
+        entities.get(1).motionX = 0;
     }
 
     @Override
     public void tick() {
-        lastPosX = posX;
-        lastPosY = posY;
-        posX += move;
-        if(posX < 0.0f || posX > 250.0f) {
-            move = -move;
+        entities.forEach(e -> {
+            e.motionY += 2.0f;
+
+            e.lastPosX = e.posX;
+            e.lastPosY = e.posY;
+            e.posX += e.motionX;
+            e.posY += e.motionY;
+
+            if(e.posX < MIN_X) {
+                e.posX = MIN_X;
+                e.motionX = -e.motionX;
+            }
+            if(e.posY < MIN_Y) {
+                //e.posY = MIN_Y;
+                //e.motionY = -e.motionY;
+            }
+            if(e.posX + SIZE > MAX_X) {
+                e.posX = MAX_X - SIZE;
+                e.motionX = -e.motionX;
+            }
+            if(e.posY + SIZE > MAX_Y) {
+                e.posY = MAX_Y - SIZE;
+                e.motionY = -e.motionY;
+            }
+            
+            e.color = 0xFF0000FF;
+        });
+        for(int i = 0; i < entities.size(); i++) {
+            for(int k = i + 1; k < entities.size(); k++) {
+                entities.get(i).collide(entities.get(k));
+            }
         }
     }
 
-    private boolean toggle;
-
     @Override
-    public void renderTick(Renderer renderer, float lag) {
-        toggle = !toggle;
+    public void renderTick(Renderer renderer, float lag) {        
         renderer.translateTo(0.0f, 0.0f);
         renderer.updateMatrix();
-        float y = 10;
+
         renderer.setColorEnabled(true);
-        renderer.setTextureEnabled(true);
-        y = renderer.getFontRenderer().drawString(10, y, true, String.format("F##ÜP__@S: #00FF00%.1f", stats.getFramesPerSecond()));
-        y = renderer.getFontRenderer().drawString(10, y, true, String.format("T/\\VPS: %.1f", stats.getTicksPerSecond()));
-        for(Gamepad.Button binding : gamepad.bindings) {
-            y = renderer.getFontRenderer().drawString(10, y, true, String.format("%s: %b, %d, %b", binding.getName(), binding.isDown(), binding.getTime(), binding.isReleased()));
+        renderer.setTextureEnabled(false);
+
+        for(Entity e : entities) {
+            float rx = e.lastPosX + (e.posX - e.lastPosX) * lag;
+            float ry = e.lastPosY + (e.posY - e.lastPosY) * lag;
+            renderer.getColorRenderer().drawRectangle(rx, ry, rx + SIZE, ry + SIZE, e.color);
         }
+
         renderer.setColorEnabled(true);
-        renderer.setTextureEnabled(false);
-        float rx = lastPosX + (posX - lastPosX) * lag;
-        float ry = lastPosY + (posY - lastPosY) * lag;
-        rx = renderer.round(rx);
-        ry = renderer.round(ry);
-        renderer.translateTo(rx, ry);
-        renderer.updateMatrix();
-        renderer.getColorRenderer().drawRectangle(0, 0, size, size, 0xFF0000FF);
+        renderer.setTextureEnabled(true);
+
+        float y = renderer.getFontRenderer().drawString(10, 10, true, String.format("FPS: %.1f", stats.getFramesPerSecond()));
+        renderer.getFontRenderer().drawString(10, y, true, String.format("TPS: %.1f", stats.getTicksPerSecond()));
     }
 
     @Override