HEADmaster

19 files changed, 1720 insertions, 0 deletions

diff --git a/core/src/sk/neuromancer/sphaera/interf/Collidable.java b/core/src/sk/neuromancer/sphaera/interf/Collidable.java
new file mode 100755
index 0000000..7a1f4fb
--- /dev/null
+++ b/core/src/sk/neuromancer/sphaera/interf/Collidable.java
@@ -0,0 +1,7 @@
+package sk.neuromancer.sphaera.interf;
+
+import sk.neuromancer.sphaera.rewrite.Sphere;
+
+public interface Collidable {
+    public boolean collides(Sphere other);
+}
diff --git a/core/src/sk/neuromancer/sphaera/interf/Moveable.java b/core/src/sk/neuromancer/sphaera/interf/Moveable.java
new file mode 100755
index 0000000..10e8a73
--- /dev/null
+++ b/core/src/sk/neuromancer/sphaera/interf/Moveable.java
@@ -0,0 +1,8 @@
+package sk.neuromancer.sphaera.interf;
+
+import com.badlogic.gdx.math.Vector3;
+
+public interface Moveable {
+    public Vector3 getVelocity();
+    public void move(float howMuch);
+}
diff --git a/core/src/sk/neuromancer/sphaera/interf/Moving.java b/core/src/sk/neuromancer/sphaera/interf/Moving.java
new file mode 100755
index 0000000..c8da69b
--- /dev/null
+++ b/core/src/sk/neuromancer/sphaera/interf/Moving.java
@@ -0,0 +1,9 @@
+package sk.neuromancer.sphaera.interf;
+
+public interface Moving {
+    public void forward(float angle);
+    public void back(float angle);
+    public void rotateAzimuth(float angle);
+    public void rotateLeft(float angle);
+    public void rotateRight(float angle);
+}
diff --git a/core/src/sk/neuromancer/sphaera/interf/Renderable.java b/core/src/sk/neuromancer/sphaera/interf/Renderable.java
new file mode 100755
index 0000000..9935836
--- /dev/null
+++ b/core/src/sk/neuromancer/sphaera/interf/Renderable.java
@@ -0,0 +1,8 @@
+package sk.neuromancer.sphaera.interf;
+
+import com.badlogic.gdx.graphics.g3d.Environment;
+import com.badlogic.gdx.graphics.g3d.ModelBatch;
+
+public interface Renderable {
+    public void render(ModelBatch renderer, Environment environment);
+}
diff --git a/core/src/sk/neuromancer/sphaera/interf/Renderer.java b/core/src/sk/neuromancer/sphaera/interf/Renderer.java
new file mode 100755
index 0000000..1db302e
--- /dev/null
+++ b/core/src/sk/neuromancer/sphaera/interf/Renderer.java
@@ -0,0 +1,5 @@
+package sk.neuromancer.sphaera.interf;
+
+public interface Renderer {
+    public void render();
+}
diff --git a/core/src/sk/neuromancer/sphaera/interf/Tickable.java b/core/src/sk/neuromancer/sphaera/interf/Tickable.java
new file mode 100755
index 0000000..650cbb8
--- /dev/null
+++ b/core/src/sk/neuromancer/sphaera/interf/Tickable.java
@@ -0,0 +1,5 @@
+package sk.neuromancer.sphaera.interf;
+
+public interface Tickable {
+    public void tick(long tickCount);
+}
diff --git a/core/src/sk/neuromancer/sphaera/rewrite/DirectedSphere.java b/core/src/sk/neuromancer/sphaera/rewrite/DirectedSphere.java
new file mode 100755
index 0000000..885553c
--- /dev/null
+++ b/core/src/sk/neuromancer/sphaera/rewrite/DirectedSphere.java
@@ -0,0 +1,105 @@
+package sk.neuromancer.sphaera.rewrite;
+
+import com.badlogic.gdx.graphics.g3d.Material;
+import com.badlogic.gdx.math.Vector3;
+
+import sk.neuromancer.sphaera.interf.Moving;
+
+public class DirectedSphere extends Sphere implements Moving {
+    
+    private Vector3 direction;
+    
+    public DirectedSphere() {
+        super();
+        this.direction = Vector3.Zero.cpy();
+    }
+
+    public DirectedSphere(float radius) {
+        super(radius);
+    }
+
+    public DirectedSphere(float radius, Material... mat) {
+        super(radius, mat);
+    }
+
+    public DirectedSphere(float x, float y, float z, float radius,
+            Material... mat) {
+        super(x, y, z, radius, mat);
+    }
+    
+    public DirectedSphere(Sphere parent, float a, float b, float radius,
+            Material... mat) {
+        super(parent, a, b, radius, mat);
+    }
+
+    public DirectedSphere(Sphere parent, float a, float b, float radius, Vector3 direction,
+            Material... mat) {
+        super(parent, a, b, radius, mat);
+        this.direction = direction;
+    }
+    
+    public void randomDirection(){
+        Vector3 relative = this.getRelativePosition();
+        Vector3 random = new Vector3().setToRandomDirection();
+        Vector3 circleNormal = relative.cpy().crs(random);
+        float angle = SphereUtils.angleDeg(random, relative);
+        random.rotate(circleNormal, angle);
+        this.direction = random;
+    }
+
+    @Override
+    public void forward(float angle) {
+        Vector3 oldRelative = this.getRelativePosition();
+        Vector3 circleNormal = oldRelative.cpy().crs(this.direction);
+        Vector3 newRelative = oldRelative.cpy().rotate(circleNormal, angle);
+        this.setVelocity(newRelative.cpy().sub(oldRelative));
+    }
+
+    @Override
+    public void back(float angle) {
+        this.forward(-angle);
+    }
+
+    @Override
+    public void rotateAzimuth(float angle) {
+        this.direction.rotate(this.getRelativePosition(), angle);
+    }
+
+    @Override
+    public void rotateLeft(float angle) {
+        rotateAzimuth(angle);
+    }
+
+    @Override
+    public void rotateRight(float angle) {
+        rotateAzimuth(-angle);
+    }
+    
+    @Override
+    public void move(float howMuch) {
+        if(this.getVelocity().len() == 0)
+            return;
+        Vector3 oldRelative = this.getRelativePosition();
+        super.move(howMuch);
+        Vector3 newRelative = this.getRelativePosition();
+        this.updateDirection(oldRelative, newRelative);
+    }
+
+    private void updateDirection(Vector3 oldPos, Vector3 newPos) {
+        Vector3 circleNormal = oldPos.cpy().crs(newPos);
+        float angle = SphereUtils.angleDeg(oldPos, newPos);
+        this.direction = circleNormal.cpy().crs(newPos);
+    }
+    
+    public void setDirection(float x, float y, float z){
+        this.direction = new Vector3(x,y,z);
+    }
+
+    public void setDirection(Vector3 direction){
+        this.direction = direction;
+    }
+
+    public Vector3 getDirection(){
+        return this.direction.cpy();
+    }
+}
diff --git a/core/src/sk/neuromancer/sphaera/rewrite/Exit.java b/core/src/sk/neuromancer/sphaera/rewrite/Exit.java
new file mode 100755
index 0000000..3fbc621
--- /dev/null
+++ b/core/src/sk/neuromancer/sphaera/rewrite/Exit.java
@@ -0,0 +1,54 @@
+package sk.neuromancer.sphaera.rewrite;
+
+public class Exit extends GameState{
+
+    public Exit(Object... remains) {
+        super(remains);
+    }
+
+    @Override
+    public void show() {
+        
+    }
+
+    @Override
+    public void render(float delta) {
+        
+    }
+
+    @Override
+    public void resize(int width, int height) {
+        
+    }
+
+    @Override
+    public void pause() {
+        
+    }
+
+    @Override
+    public void resume() {
+        
+    }
+
+    @Override
+    public void hide() {
+        
+    }
+
+    @Override
+    public void dispose() {
+        
+    }
+
+    @Override
+    public void tick(long tickCount) {
+        
+    }
+
+    @Override
+    public GameState next() {
+        return null;
+    }
+
+}
diff --git a/core/src/sk/neuromancer/sphaera/rewrite/GameState.java b/core/src/sk/neuromancer/sphaera/rewrite/GameState.java
new file mode 100755
index 0000000..6c91c2e
--- /dev/null
+++ b/core/src/sk/neuromancer/sphaera/rewrite/GameState.java
@@ -0,0 +1,37 @@
+package sk.neuromancer.sphaera.rewrite;
+
+import sk.neuromancer.sphaera.interf.Tickable;
+
+import com.badlogic.gdx.InputAdapter;
+import com.badlogic.gdx.Screen;
+
+public abstract class GameState extends InputAdapter implements Screen, Tickable{
+    
+    private Object[] remains;
+    private boolean finished = false;
+    private GameState next;
+    
+    public GameState(Object... remains){
+        this.remains = remains;
+    }
+    
+    public Object[] getRemains(){
+        return this.remains;
+    }
+    
+    public GameState next(){
+        return this.next;
+    }
+    
+    public boolean isFinished(){
+        return this.finished;
+    }
+    
+    protected void finish(){
+        this.finished = true;
+    }
+    
+    protected void setNext(GameState next){
+        this.next = next;
+    }
+}
diff --git a/core/src/sk/neuromancer/sphaera/rewrite/LiveSphere.java b/core/src/sk/neuromancer/sphaera/rewrite/LiveSphere.java
new file mode 100755
index 0000000..8f9235b
--- /dev/null
+++ b/core/src/sk/neuromancer/sphaera/rewrite/LiveSphere.java
@@ -0,0 +1,65 @@
+package sk.neuromancer.sphaera.rewrite;
+
+import com.badlogic.gdx.graphics.g3d.Material;
+import com.badlogic.gdx.math.Vector3;
+
+import sk.neuromancer.sphaera.interf.Tickable;
+
+public class LiveSphere extends DirectedSphere implements Tickable{
+    
+    private SphereType type;
+    
+    public LiveSphere() {
+        super();
+    }
+    
+    public LiveSphere(float radius) {
+        super(radius);
+    }
+    
+    public LiveSphere(float radius, SphereType type) {
+        super(radius, type.equals(SphereType.BIGGER) ? Sphere.BIGGER_MAT : Sphere.SMALLER_MAT);
+        this.type = type;
+    }
+    
+    public LiveSphere(float radius, Material... mat) {
+        super(radius, mat);
+    }
+    
+    public LiveSphere(float x, float y, float z, float radius, SphereType type) {
+        super(x, y, z, radius, type.equals(SphereType.BIGGER) ? Sphere.BIGGER_MAT : Sphere.SMALLER_MAT);
+        this.type = type;
+    }
+
+    public LiveSphere(float x, float y, float z, float radius, Material... mat) {
+        super(x, y, z, radius, mat);
+    }
+    
+
+    public LiveSphere(Sphere parent, float a, float b, float radius,
+            Vector3 direction, Material... mat) {
+        super(parent, a, b, radius, direction, mat);
+    }
+
+    public LiveSphere(Sphere parent, float a, float b, float radius,
+            Material... mat) {
+        super(parent, a, b, radius, mat);
+    }
+
+    @Override
+    public void tick(long tickCount) {
+        this.forward(0.5f);
+    }
+    
+    public SphereType getType(){
+        return this.type;
+    }
+    
+    public void setType(SphereType type){
+        this.type = type;
+    }
+    
+    public enum SphereType{
+        SMALLER, BIGGER;
+    }
+}
diff --git a/core/src/sk/neuromancer/sphaera/rewrite/Menu.java b/core/src/sk/neuromancer/sphaera/rewrite/Menu.java
new file mode 100755
index 0000000..4898e04
--- /dev/null
+++ b/core/src/sk/neuromancer/sphaera/rewrite/Menu.java
@@ -0,0 +1,232 @@
+package sk.neuromancer.sphaera.rewrite;
+
+import com.badlogic.gdx.Gdx;
+import com.badlogic.gdx.graphics.Color;
+import com.badlogic.gdx.graphics.GL20;
+import com.badlogic.gdx.graphics.OrthographicCamera;
+import com.badlogic.gdx.graphics.Pixmap;
+import com.badlogic.gdx.graphics.Texture;
+import com.badlogic.gdx.graphics.g2d.BitmapFont;
+import com.badlogic.gdx.graphics.g2d.TextureRegion;
+import com.badlogic.gdx.scenes.scene2d.InputEvent;
+import com.badlogic.gdx.scenes.scene2d.Stage;
+import com.badlogic.gdx.scenes.scene2d.ui.Image;
+import com.badlogic.gdx.scenes.scene2d.ui.Label;
+import com.badlogic.gdx.scenes.scene2d.ui.Label.LabelStyle;
+import com.badlogic.gdx.scenes.scene2d.ui.Skin;
+import com.badlogic.gdx.scenes.scene2d.ui.TextButton;
+import com.badlogic.gdx.scenes.scene2d.ui.TextButton.TextButtonStyle;
+import com.badlogic.gdx.scenes.scene2d.utils.ClickListener;
+import com.badlogic.gdx.scenes.scene2d.utils.TextureRegionDrawable;
+import com.badlogic.gdx.utils.viewport.StretchViewport;
+import com.badlogic.gdx.utils.viewport.Viewport;
+
+public class Menu extends GameState{
+    
+    
+    private MenuState state;
+    private World world;
+    private float score;
+    
+    private Stage ui;
+    private TextButton playButton;
+    private TextButton exitButton;
+    private Image logo;
+    private Label scoreLabel;
+    private Label howToLabel;
+    private Label by;
+    
+    private TextButtonStyle buttonStyle;
+    private LabelStyle labelStyle;
+    
+    public static final String LOGO = "logo.png";
+    public static final String BUTTON = "button.png";
+
+    public Menu(Object... remains){
+        super(remains);
+        if(remains.length > 0){
+            state = (MenuState) remains[0];
+        }else{
+            state = MenuState.START;
+        }
+        
+        switch(state){
+        case WIN:
+        case PAUSE:
+        case POST:
+            if(remains.length > 1){
+                world = (World) remains[1];
+                if(remains.length > 2){
+                    this.score = (Float) remains[2];
+                }
+            }else{
+                world = new World();
+            }
+            break;
+        case START:
+            world = new World();
+            break;
+        default:
+            break;
+        }
+        
+        ui = new Stage();
+        
+        Skin skin = new Skin();
+        
+        logo = new Image(new Texture(Gdx.files.internal(LOGO)));
+        
+        buttonStyle = new TextButtonStyle();
+        Texture buttonTexture = new Texture(Gdx.files.internal(BUTTON));
+        
+        buttonStyle.up = new TextureRegionDrawable(new TextureRegion(buttonTexture));
+        
+        if(!buttonTexture.getTextureData().isPrepared()){
+            buttonTexture.getTextureData().prepare();
+        }
+        
+        Pixmap downPixmap = buttonTexture.getTextureData().consumePixmap();
+        downPixmap.setColor(0.5f, 0, 0, 0.3f);
+        downPixmap.fillRectangle(5, 5, 55, 23);
+        
+        buttonStyle.down = new TextureRegionDrawable(new TextureRegion(new Texture(downPixmap)));
+        buttonStyle.font = new BitmapFont();
+        
+        labelStyle = new LabelStyle(new BitmapFont(), Color.BLACK);
+        
+        skin.add("default", buttonStyle);
+        skin.add("label", labelStyle);
+        
+        float width = Gdx.graphics.getWidth();
+        float height = Gdx.graphics.getHeight();
+        
+        playButton = new TextButton("PLAY", skin);
+        playButton.setSize(width/2.5f, width/6);
+        playButton.setPosition(width/2f - width/2.5f, height/3f);
+        playButton.addListener(new ClickListener(){
+            @Override
+            public void clicked(InputEvent event, float x, float y) {
+                playClick();
+            }
+        });
+        
+        exitButton = new TextButton("EXIT", skin);
+        exitButton.setSize(width/2.5f, width/6);
+        exitButton.setPosition(width/2f, height/3f);
+        exitButton.addListener(new ClickListener(){
+            @Override
+            public void clicked(InputEvent event, float x, float y) {
+                exitClick();
+            }
+        });
+        
+        logo.setPosition(width/2 - width/4, width/4);
+        logo.setSize(width/2, width/2);
+        
+        String scoreString = score == 0 ? "" : "Score:" + Float.toString(score);
+        
+        scoreLabel = new Label(scoreString, skin, "label");
+        scoreLabel.setPosition(width/16, 7 * height/8);
+        scoreLabel.setFontScale(5);
+        
+        String howToString = state == MenuState.WIN ? "Congrats! You have won." : "Collect the blue spheres, avoid red ones. Grow! \nSPACE to move. A,D to rotate, SCROLL to zoom.";
+        
+        howToLabel = new Label(howToString, skin, "label");
+        howToLabel.setPosition(width/12, height/8);
+        howToLabel.setFontScale(2.5f);
+        
+        by = new Label("by J08nY", skin, "label");
+        by.setPosition(width/2 + width/4, width/2);
+        
+        
+        ui.addActor(logo);
+        ui.addActor(by);
+        ui.addActor(scoreLabel);
+        ui.addActor(howToLabel);
+        ui.addActor(playButton);
+        ui.addActor(exitButton);
+    }
+
+    @Override
+    public void show() {
+        resize(Gdx.graphics.getWidth(), Gdx.graphics.getHeight());
+        Gdx.input.setInputProcessor(ui);
+    }
+
+    @Override
+    public void render(float delta) {
+        Gdx.gl.glClearColor(1,1,1,1);
+        Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT);
+        
+        ui.draw();
+    }
+    
+    public void playClick(){
+        this.finish();
+        if(this.world != null)
+            this.world.dispose();
+        this.setNext(new World(this));
+    }
+    
+    public void exitClick(){
+        this.finish();
+        if(this.world != null)
+            this.world.dispose();
+        this.setNext(new Exit());
+    }
+    
+    @Override
+    public void tick(long tickCount) {
+        ui.act(1/SphaeraGame.TPS);
+    }
+
+    @Override
+    public void resize(int width, int height) {
+        
+    }
+
+    @Override
+    public void pause() {
+        
+    }
+
+    @Override
+    public void resume() {
+        
+    }
+
+    @Override
+    public void hide() {
+        Gdx.gl.glClearColor(1,1,1,1);
+        Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT);
+    }
+
+    @Override
+    public void dispose() {
+        if(ui != null)
+            ui.dispose();
+    }
+
+    public enum MenuState{
+        START, PAUSE, POST, WIN;
+    }
+
+    @Override
+    public GameState next() {
+        switch(state){
+        case PAUSE:
+            //world or exit
+            break;
+        case POST:
+            //world or exit
+            break;
+        case START:
+            //world or exit
+            break;
+        default:
+            break;
+        }
+        
+        return super.next();
+    }
+}
diff --git a/core/src/sk/neuromancer/sphaera/rewrite/MovingSphere.java b/core/src/sk/neuromancer/sphaera/rewrite/MovingSphere.java
new file mode 100755
index 0000000..a79bbc8
--- /dev/null
+++ b/core/src/sk/neuromancer/sphaera/rewrite/MovingSphere.java
@@ -0,0 +1,72 @@
+package sk.neuromancer.sphaera.rewrite;
+
+import com.badlogic.gdx.graphics.g3d.Material;
+
+import sk.neuromancer.sphaera.interf.Moving;
+
+public class MovingSphere extends Sphere implements Moving {
+    
+    private float azimuth = 0f;
+
+    public MovingSphere() {
+        super();
+    }
+
+    public MovingSphere(float radius) {
+        super(radius);
+    }
+
+    public MovingSphere(float radius, Material... mat) {
+        super(radius, mat);
+    }
+
+    public MovingSphere(float x, float y, float z, float radius,
+            Material... mat) {
+        super(x, y, z, radius, mat);
+    }
+    
+    public MovingSphere(Sphere parent, float a, float b, float radius,
+            Material... mat) {
+        super(parent, a, b, radius, mat);
+    }
+
+    public MovingSphere(Sphere parent, float a, float b, float radius, float azimuth,
+            Material... mat) {
+        super(parent, a, b, radius, mat);
+        this.azimuth = azimuth;
+    }
+
+    @Override
+    public void forward(float angle){
+        this.setVelocity(SphereUtils.rotateDegVelocity(getSphericalPosition(), angle, azimuth));
+    }
+    
+    @Override
+    public void back(float angle){
+        this.forward(-angle);
+    }
+    
+    @Override
+    public void rotateAzimuth(float angle){
+        this.azimuth+=angle;
+    }
+
+    @Override
+    public void rotateLeft(float angle){
+        rotateAzimuth(-angle);
+    }
+    
+    @Override
+    public void rotateRight(float angle){
+        rotateAzimuth(angle);
+    }
+    
+    public float getAzimuth() {
+        return azimuth;
+    }
+
+    public void setAzimuth(float azimuth) {
+        this.azimuth = azimuth;
+    }
+
+}
diff --git a/core/src/sk/neuromancer/sphaera/rewrite/Player.java b/core/src/sk/neuromancer/sphaera/rewrite/Player.java
new file mode 100755
index 0000000..254438e
--- /dev/null
+++ b/core/src/sk/neuromancer/sphaera/rewrite/Player.java
@@ -0,0 +1,85 @@
+package sk.neuromancer.sphaera.rewrite;
+
+import sk.neuromancer.sphaera.interf.Moving;
+import sk.neuromancer.sphaera.interf.Tickable;
+
+import com.badlogic.gdx.graphics.Color;
+import com.badlogic.gdx.graphics.g3d.Material;
+import com.badlogic.gdx.graphics.g3d.attributes.ColorAttribute;
+import com.badlogic.gdx.math.Vector3;
+
+public class Player extends DirectedSphere implements Moving, Tickable{
+    
+    public static float BASE_RADIUS = 1f;
+    public static float CAM_MULT = 1.0f;
+    public static float CAM_BASE = 28f;
+    
+    public static final Color DEFAULT_DIFFUSE = new Color(0.1f, 0.1f, 0.1f, 1f);
+    public static final Color DEFAULT_SPECULAR = new Color(1f, 1f, 1f, 0.5f);
+    public static final Color DEFAULT_AMBIENT = new Color(0.05f, 0.05f, 0.05f, 0.5f);
+    public static final Color DEFAULT_REFLECTION = new Color(1f, 1f, 1f, 0.5f);
+    
+    public static final Material BASE_MAT = new Material(ColorAttribute.createDiffuse(DEFAULT_DIFFUSE),
+                                                        ColorAttribute.createReflection(DEFAULT_SPECULAR),
+                                                        ColorAttribute.createAmbient(DEFAULT_AMBIENT),
+                                                        ColorAttribute.createReflection(DEFAULT_REFLECTION)
+                                                            );
+    
+    public static final float MOV_SPEED = 1.2f;
+    public static final float ROT_SPEED = 5f;
+    
+    private float speed = MOV_SPEED;
+    
+    public Player() {
+        super();
+    }
+    
+    public Player(float radius) {
+        super(radius);
+    }
+    
+    public Player(float radius, Material... mat) {
+        super(radius, mat);
+    }
+
+    public Player(float x, float y, float z, float radius, Material... mat) {
+        super(x, y, z, radius, mat);
+    }
+
+    public Player(Sphere parent, float a, float b, float radius, Vector3 direction,
+            Material... mat) {
+        super(parent, a, b, radius, direction, mat);
+    }
+    
+    public Vector3 getCameraPosition(){
+        return this.getRelativePosition().setLength(CAM_BASE + this.getRadius() * CAM_MULT);
+    }
+    
+    public Vector3 getCameraDirection(){
+        return this.getCameraPosition().scl(-1);
+    }
+    
+    public Vector3 getCameraUp(){
+        return this.getDirection();
+    }
+
+    @Override
+    public void tick(long tickCount) {
+        
+    }
+    
+    public float getSpeed(){
+        return this.speed;
+    }
+    
+    public void setSpeed(float speed){
+        this.speed = speed;
+    }
+    
+    /*
+    @Override public void dropOnParent(Vector3 oldParentPos){
+        super.dropOnParent(oldParentPos);
+        setDirection(this.getDirection().scl(-1));
+    }
+*/
+}
diff --git a/core/src/sk/neuromancer/sphaera/rewrite/SoundPlayer.java b/core/src/sk/neuromancer/sphaera/rewrite/SoundPlayer.java
new file mode 100755
index 0000000..31db99c
--- /dev/null
+++ b/core/src/sk/neuromancer/sphaera/rewrite/SoundPlayer.java
@@ -0,0 +1,75 @@
+package sk.neuromancer.sphaera.rewrite;
+
+import java.util.Random;
+
+import com.badlogic.gdx.Gdx;
+import com.badlogic.gdx.audio.Sound;
+import com.badlogic.gdx.utils.Disposable;
+
+import sk.neuromancer.sphaera.interf.Tickable;
+
+public class SoundPlayer implements Tickable, Disposable{
+
+    private Sound[] base = new Sound[4];
+    private Sound explosion;
+
+    public static final String BASE_SOUND_NAME = "base";
+
+    private boolean isLoaded = false;
+    private boolean isPlaying = false;
+
+    public static final int BPM = 100;
+    public static final float TPB = (SphaeraGame.TPS * 60) / BPM;
+
+    public static final float VOLUME = 0.2f;
+    
+    private int[] order = {3,2,0,1};
+
+    private int s = 0;
+
+    public SoundPlayer() {
+        
+    }
+
+    @Override
+    public void tick(long tickCount) {
+        if(!isPlaying)
+            return;
+        if(!isLoaded)
+            return;
+        if(tickCount % TPB == 0){
+            base[order[s]].play(VOLUME);
+            s++;
+            s%=base.length;
+        }
+    }
+
+    public void load() {
+        for(int i = 0; i < base.length; i++){
+            base[i] = Gdx.audio.newSound(Gdx.files.internal(BASE_SOUND_NAME + i + ".wav"));
+        }
+        explosion = Gdx.audio.newSound(Gdx.files.internal("explosion.wav"));
+        isLoaded = true;
+    }
+
+    public void play(){
+        isPlaying = true;
+    }
+
+    public void pause(){
+        isPlaying = false;
+    }
+
+
+    public void playExplosion(){
+        explosion.play();
+    }
+
+    @Override
+    public void dispose() {
+        for(Sound s: base){
+            s.dispose();
+        }
+        explosion.dispose();
+    }
+}
diff --git a/core/src/sk/neuromancer/sphaera/rewrite/SphaeraGame.java b/core/src/sk/neuromancer/sphaera/rewrite/SphaeraGame.java
new file mode 100755
index 0000000..beb5a5a
--- /dev/null
+++ b/core/src/sk/neuromancer/sphaera/rewrite/SphaeraGame.java
@@ -0,0 +1,119 @@
+package sk.neuromancer.sphaera.rewrite;
+
+import sk.neuromancer.sphaera.interf.Tickable;
+
+import com.badlogic.gdx.Game;
+import com.badlogic.gdx.Gdx;
+
+public class SphaeraGame extends Game implements Tickable{
+    
+    private Splash splash = null;
+    private Menu menu = null;
+    private World world = null;
+    private SoundPlayer soundPlayer;
+    
+    public static final int DEFAULT_WIDTH = 900;
+    public static final int DEFAULT_HEIGHT = 650;
+    
+    public static final int TPS = 30;
+    public static final int FOV = 75;
+    
+    private long lastTickTime;
+    private long ticks, frames;
+    
+    @Override
+    public void create(){
+        Gdx.graphics.setTitle("Sphaera");
+        
+        splash = new Splash();
+        setScreen(splash);
+        
+        Gdx.input.setInputProcessor(splash);
+        
+        soundPlayer = new SoundPlayer();
+        soundPlayer.load();
+        //soundPlayer.play();
+        
+        ticks = frames = 0;
+        lastTickTime = System.currentTimeMillis();
+    }
+
+    @Override
+    public void resize(int width, int height) {
+        super.resize(width, height);
+    }
+
+    @Override
+    public void render() {
+        long now = System.currentTimeMillis();
+        if(now - lastTickTime > (1/TPS) * 1000){
+            tick(ticks);
+            lastTickTime = now;
+        }
+        draw();
+    }
+    
+    @Override
+    public void tick(long tickCount) {
+        ticks++;
+        GameState state = getScreen();
+        state.tick(tickCount);
+        soundPlayer.tick(tickCount);
+        
+        if(ticks % 30 == 0){
+            System.out.println(Gdx.graphics.getFramesPerSecond());
+        }
+        
+        if(state.isFinished()){
+            if(state instanceof World){
+                soundPlayer.playExplosion();
+            }
+            
+            state = state.next();
+            Gdx.input.setInputProcessor(state);
+            setScreen(state);
+            
+            if(state instanceof Menu){
+                menu = (Menu) state;
+            }else if(state instanceof World){
+                world = (World) state;
+            }else if(state instanceof Exit){
+                this.dispose();
+                state.dispose();
+                Gdx.app.exit();
+            }
+        }
+    }
+    
+    public void draw(){
+        frames++;
+        super.render();
+    }
+    
+    @Override
+    public void pause() {
+        super.pause();
+    }
+
+    @Override
+    public void resume() {
+        super.resume();
+    }
+
+    @Override
+    public void dispose() {
+        if(splash != null)
+            splash.dispose();
+        if(menu != null)
+            menu.dispose();
+        if(world != null)
+            world.dispose();
+        if(soundPlayer != null)
+            soundPlayer.dispose();
+    }
+
+    @Override
+    public GameState getScreen() {
+        return (GameState) super.getScreen();
+    }
+}
diff --git a/core/src/sk/neuromancer/sphaera/rewrite/Sphere.java b/core/src/sk/neuromancer/sphaera/rewrite/Sphere.java
new file mode 100755
index 0000000..54966fa
--- /dev/null
+++ b/core/src/sk/neuromancer/sphaera/rewrite/Sphere.java
@@ -0,0 +1,279 @@
+package sk.neuromancer.sphaera.rewrite;
+
+import java.util.Collection;
+import java.util.LinkedList;
+import java.util.List;
+
+import sk.neuromancer.sphaera.interf.Collidable;
+import sk.neuromancer.sphaera.interf.Moveable;
+import sk.neuromancer.sphaera.interf.Renderable;
+
+import com.badlogic.gdx.graphics.Color;
+import com.badlogic.gdx.graphics.VertexAttributes.Usage;
+import com.badlogic.gdx.graphics.g3d.Environment;
+import com.badlogic.gdx.graphics.g3d.Material;
+import com.badlogic.gdx.graphics.g3d.ModelBatch;
+import com.badlogic.gdx.graphics.g3d.ModelInstance;
+import com.badlogic.gdx.graphics.g3d.attributes.ColorAttribute;
+import com.badlogic.gdx.graphics.g3d.utils.ModelBuilder;
+import com.badlogic.gdx.math.Vector3;
+import com.badlogic.gdx.utils.Disposable;
+
+public class Sphere implements Renderable, Moveable, Collidable, Disposable{
+    private static final int MAX_DIV = 50;
+    private static final int DIV = 12;
+
+    public static final float BASE_RADIUS = 50f;
+
+    public static final Color DEFAULT_DIFFUSE = new Color(0.9f, 0.9f, 0.9f, 1f);
+    public static final Color DEFAULT_SPECULAR = new Color(0.5f, 0.5f, 0.5f, 0.5f);
+    public static final Color DEFAULT_AMBIENT = new Color(1f, 1f, 1f, 0.5f);
+    public static final Color DEFAULT_REFLECTION = new Color(0.5f, 0.5f, 0.5f, 0.5f);
+    
+    public static final Color SMALLER_DIFFUSE = new Color(0.05f, 0.05f, 0.9f, 1f);
+    
+    public static final Color BIGGER_DIFFUSE = new Color(0.7f, 0.1f, 0.1f, 1f);
+
+    public static final Material BASE_MAT = new Material(ColorAttribute.createDiffuse(DEFAULT_DIFFUSE),
+            ColorAttribute.createReflection(DEFAULT_SPECULAR),
+            ColorAttribute.createAmbient(DEFAULT_AMBIENT),
+            ColorAttribute.createReflection(DEFAULT_REFLECTION)
+            );
+    
+    public static final Material SMALLER_MAT = new Material(ColorAttribute.createDiffuse(SMALLER_DIFFUSE),
+            ColorAttribute.createReflection(DEFAULT_SPECULAR),
+            ColorAttribute.createAmbient(DEFAULT_AMBIENT),
+            ColorAttribute.createReflection(DEFAULT_REFLECTION)
+            );
+    
+    public static final Material BIGGER_MAT = new Material(ColorAttribute.createDiffuse(BIGGER_DIFFUSE),
+            ColorAttribute.createReflection(DEFAULT_SPECULAR),
+            ColorAttribute.createAmbient(DEFAULT_AMBIENT),
+            ColorAttribute.createReflection(DEFAULT_REFLECTION)
+            );
+
+    private Sphere parent = null;//if parent null, then 
+    private List<Sphere> children = new LinkedList<Sphere>();
+
+    private ModelInstance model;
+
+    private float radius;
+
+    /**
+     * Both positions are relative to the parent,
+     * if parent == null, then they are absolute.
+     */
+    private Vector3 position;
+    private Vector3 sphericalPosition;//degrees
+
+    /*
+     * Dunno if Ill use it...
+     */
+    private Vector3 velocity;
+
+    public Sphere(){
+        this.position = Vector3.Zero.cpy();
+        this.sphericalPosition = Vector3.Zero.cpy();
+        this.velocity = Vector3.Zero.cpy();
+    }
+
+    public Sphere(float radius){
+        this();
+        this.radius = radius;
+    }
+
+    public Sphere(float radius, Material... mat){
+        this(radius);
+        ModelBuilder mb = new ModelBuilder();
+        int div = Math.min(MAX_DIV, (int) radius * DIV);
+        if(this instanceof Player){
+            div = MAX_DIV;
+        }
+        this.model = new ModelInstance(mb.createSphere(2, 2, 2, div, div, mat[0], Usage.Position | Usage.Normal));
+        /*for(Material m : mat){
+            this.model.materials.add(m);
+        }*/
+    }
+
+    public Sphere(float x, float y, float z, float radius, Material... mat){
+        this(radius, mat);
+        this.position.x = x;
+        this.position.y = y;
+        this.position.z = z;
+        this.sphericalPosition = SphereUtils.toSphericalDeg(x, y, z);
+    }
+
+    public Sphere(Sphere parent, float a, float b, float radius, Material... mat){
+        this(radius, mat);
+        this.parent = parent;
+        this.sphericalPosition.x = parent.getRadius() + this.radius;
+        this.sphericalPosition.y = a;
+        this.sphericalPosition.z = b;
+        this.position = SphereUtils.toCartesianDeg(this.sphericalPosition.x, a, b);
+    }
+
+    public Sphere getParent() {
+        return this.parent;
+    }
+
+    public void setParent(Sphere newParent){
+        if(this.parent != null){
+            this.parent.removeChildren(this);
+        }
+        this.parent = newParent;
+        this.parent.addChildren(this);
+    }
+
+    public boolean addChildren(Sphere child){
+        return this.children.add(child);
+    }
+
+    public boolean removeChildren(Sphere child){
+        return this.children.remove(child);
+    }
+
+    public Collection<Sphere> getChildren(){
+        return new LinkedList<Sphere>(this.children);
+    }
+
+    public float getRadius() {
+        return this.radius;
+    }
+
+    public void setRadius(float radius){
+        this.radius = radius;
+    }
+
+    public void scaleRadius(float newRadius){
+        Vector3 newSpherical = this.getSphericalPosition();
+        if(this.getParent() != null){
+            newSpherical.x = this.getParent().getRadius() + newRadius;
+        }
+        Vector3 newRelative = this.getRelativePosition();
+        newRelative.setLength(this.getParent().getRadius() + newRadius);
+        this.setSphericalPosition(newSpherical);
+        this.setRelativePosition(newRelative);
+        this.setRadius(newRadius);
+    }
+
+    public void setSphericalPosition(Vector3 spherical){
+        this.sphericalPosition = spherical.cpy();
+    }
+
+    public void setRelativePosition(Vector3 relative){
+        this.position = relative.cpy();
+    }
+
+    public void setPositionSpherical(Vector3 spherical){
+        //both
+        this.setSphericalPosition(spherical);
+        this.setRelativePosition(SphereUtils.toCartesianDeg(spherical));
+    }
+
+    public void setPositionRelative(Vector3 relative){
+        //both
+        this.setRelativePosition(relative);
+        this.setSphericalPosition(SphereUtils.toSphericalDeg(relative));
+    }
+
+    public Vector3 getSphericalPosition(){
+        return this.sphericalPosition.cpy();
+    }
+
+    public Vector3 getAbsolutePosition(){
+        if(this.parent == null){
+            return this.getRelativePosition();
+        }
+        return this.position.cpy().add(this.getParent().getAbsolutePosition());
+    }
+
+    public Vector3 getRelativePosition(){
+        return this.position.cpy();
+    }
+
+    public void dropOnParent(Vector3 oldParentPos){
+        if(this.parent == null){
+            return;
+        }
+
+        Vector3 absolutePos = oldParentPos.add(this.position);
+        Vector3 fromParent = absolutePos.cpy().sub(this.parent.getAbsolutePosition());
+        fromParent.setLength(this.parent.getRadius() + this.radius);
+        this.setPositionRelative(fromParent);
+    }
+
+    public void dropOnParent(Sphere oldParent){
+        this.dropOnParent(oldParent.getAbsolutePosition());
+        /*potrebujem absolutne pozicie
+         *OH SHIT!
+         *mam problem, musim toto riesit pri zmene parenta!!
+         *pretoze tu uz nemam toho stareho takze getAbsolutePosition je BS aj getRelative...
+         */
+    }
+
+    public void putOnParent(float polar, float azimuth){
+        if(this.getParent() == null)
+            return;
+
+        float completeRadius = this.getParent().getRadius() + this.getRadius();
+        this.setPositionSpherical(new Vector3(completeRadius, polar, azimuth));
+    }
+    
+    public void setColorAttributes(ColorAttribute... attribs){
+        this.model.materials.get(0).set(attribs);
+    }
+
+    @Override
+    public void render(ModelBatch renderer, Environment environment) {
+        model.transform.setToTranslation(this.getAbsolutePosition());
+        model.transform.scale(radius,radius,radius);
+        renderer.render(model, environment);
+    }
+
+    @Override
+    public Vector3 getVelocity(){
+        return this.velocity.cpy();
+    }
+
+    public void setVelocity(Vector3 velocity){
+        this.velocity = velocity;
+    }
+
+    public void move(){
+        //all the way
+        this.move(1);
+    }
+
+    @Override
+    public void move(float howMuch){
+        if(this.velocity.len() == 0)
+            return;
+        this.velocity.scl(howMuch);
+        this.setPositionRelative(this.getRelativePosition().add(this.velocity));
+        this.velocity = Vector3.Zero.cpy();
+        //maybe leave velocity as the rest I want to go?
+        //that way I can call move again and hope I 
+    }
+
+    @Override
+    public boolean collides(Sphere other) {
+        if(this.getParent() != null && other.getParent() != null){
+            return this.getRelativePosition().sub(other.getRelativePosition()).len() < this.getRadius() + other.getRadius();
+        }
+        return this.getAbsolutePosition().sub(other.getAbsolutePosition()).len() < this.getRadius() + other.getRadius();
+    }
+
+    @Override
+    public String toString(){
+        return "Sphere" + ":" + /*this.hashCode() +*/ "\n" +
+                "   radius=" + this.getRadius() + "\n" +
+                "   spherical=" + this.getSphericalPosition() + "\n" +
+                "   relative=" + this.getRelativePosition();
+    }
+
+    @Override
+    public void dispose() {
+        this.model.model.dispose();
+    }
+    
+}
diff --git a/core/src/sk/neuromancer/sphaera/rewrite/SphereUtils.java b/core/src/sk/neuromancer/sphaera/rewrite/SphereUtils.java
new file mode 100755
index 0000000..e59fef3
--- /dev/null
+++ b/core/src/sk/neuromancer/sphaera/rewrite/SphereUtils.java
@@ -0,0 +1,123 @@
+package sk.neuromancer.sphaera.rewrite;
+
+import com.badlogic.gdx.math.MathUtils;
+import com.badlogic.gdx.math.Vector3;
+
+/**
+ * 
+ *
+ */
+public class SphereUtils {
+    
+    public static void main(String[] args){
+        test();
+    }
+    
+    public static void test(){
+        Vector3 topSpherical = new Vector3(10,0,0);
+        Vector3 topCartesian = SphereUtils.toCartesianDeg(topSpherical);
+        System.out.println(topCartesian + " should be (0,10,0))");
+        
+        Vector3 xSpherical = new Vector3(10,90,90);
+        Vector3 xCartesian = SphereUtils.toCartesianDeg(xSpherical);
+        System.out.println(xCartesian + "should be (10,0,0)");
+        
+        Vector3 rotTopToX = xCartesian.cpy().sub(topCartesian);
+        System.out.println(rotTopToX);//seems okay
+    }
+    
+    public static float angleDeg(Vector3 cartesianA, Vector3 cartesianB){
+        return SphereUtils.angleRad(cartesianA, cartesianB) * MathUtils.radiansToDegrees;
+    }
+    
+    public static float angleRad(Vector3 cartesianA, Vector3 cartesianB){
+        return (float)Math.acos(((cartesianA.dot(cartesianB))/(cartesianA.len()*cartesianB.len())));
+    }
+    
+    public static Vector3 sphericalToRad(Vector3 sphericalDeg){
+        return new Vector3(sphericalDeg.x, sphericalDeg.y * MathUtils.degreesToRadians, sphericalDeg.z * MathUtils.degreesToRadians);
+    }
+    
+    public static Vector3 sphericalToDeg(Vector3 sphericalRad){
+        return new Vector3(sphericalRad.x, sphericalRad.y * MathUtils.radiansToDegrees, sphericalRad.z * MathUtils.radiansToDegrees);
+    }
+    
+    public static Vector3 tangentDeg(Vector3 sphericalDeg, float azimuthDeg){
+        return SphereUtils.tangentRad(SphereUtils.sphericalToRad(sphericalDeg), azimuthDeg * MathUtils.degreesToRadians);
+    }
+    
+    public static Vector3 tangentRad(Vector3 sphericalRad, float azimuthRad){
+        Vector3 tangentSpherical = SphereUtils.rotateRad(sphericalRad, (float) Math.PI / 2f, azimuthRad);
+        return SphereUtils.toCartesianRad(tangentSpherical);
+    }
+    
+    public static Vector3 rotateDegDelta(Vector3 sphericalDeg, float angleDeg, float azimuthDeg){
+        Vector3 newSpherical = SphereUtils.rotateDeg(sphericalDeg, angleDeg, azimuthDeg);
+        return newSpherical.sub(sphericalDeg);
+    }
+    
+    public static Vector3 rotateRadDelta(Vector3 sphericalRad, float angleRad, float azimuthRad){
+        Vector3 newSpherical = SphereUtils.rotateRad(sphericalRad, angleRad, azimuthRad);
+        return newSpherical.sub(sphericalRad);
+    }
+    
+    public static Vector3 rotateDegVelocity(Vector3 sphericalDeg, float angleDeg, float azimuthDeg){
+        Vector3 newSpherical = SphereUtils.rotateDeg(sphericalDeg, angleDeg, azimuthDeg);
+        return SphereUtils.toCartesianDeg(newSpherical).sub(SphereUtils.toCartesianDeg(sphericalDeg));
+    }
+    
+    public static Vector3 rotateRadVelocity(Vector3 sphericalRad, float angleRad, float azimuthRad){
+        Vector3 newSpherical = SphereUtils.rotateRad(sphericalRad, angleRad, azimuthRad);
+        return SphereUtils.toCartesianRad(newSpherical).sub(SphereUtils.toCartesianRad(sphericalRad));
+    }
+    
+    public static Vector3 rotateDeg(Vector3 sphericalDeg, float angleDeg, float azimuthDeg){
+        return new Vector3(sphericalDeg.x, (float) (sphericalDeg.y - Math.cos(azimuthDeg * MathUtils.degreesToRadians) * angleDeg),
+                (float) (sphericalDeg.z + Math.sin(azimuthDeg * MathUtils.degreesToRadians) * angleDeg));
+    }
+    
+    public static Vector3 rotateRad(Vector3 sphericalRad, float angleRad, float azimuthRad){
+        return new Vector3(sphericalRad.x, (float) (sphericalRad.y - Math.cos(azimuthRad) * angleRad),
+                (float) (sphericalRad.z + Math.sin(azimuthRad) * angleRad));
+    }
+    
+    public static Vector3 toCartesianDeg(Vector3 spherical){
+        return SphereUtils.toCartesianDeg(spherical.x, spherical.y, spherical.z);
+    }
+    
+    public static Vector3 toCartesianRad(Vector3 spherical){
+        return SphereUtils.toCartesianRad(spherical.x, spherical.y, spherical.z);
+    }
+    
+    public static Vector3 toCartesianDeg(float radius, float polar, float azimuth){
+        polar*=MathUtils.degreesToRadians;
+        azimuth*=MathUtils.degreesToRadians;
+        return SphereUtils.toCartesianRad(radius, polar, azimuth);
+    }
+    
+    public static Vector3 toCartesianRad(float radius, float polar, float azimuth){
+        float x = (float) (radius * Math.sin(polar) * Math.sin(azimuth));
+        float y = (float) (radius * Math.cos(polar));
+        float z = (float) (radius * Math.sin(polar) * Math.cos(azimuth));
+        return new Vector3(x,y,z);
+    }
+    
+    public static Vector3 toSphericalDeg(Vector3 cartesian){
+        return SphereUtils.toSphericalDeg(cartesian.x, cartesian.y, cartesian.z);
+    }
+    
+    public static Vector3 toSphericalRad(Vector3 cartesian){
+        return SphereUtils.toSphericalRad(cartesian.x, cartesian.y, cartesian.z);
+    }
+    
+    public static Vector3 toSphericalDeg(float x, float y, float z){
+        return SphereUtils.sphericalToDeg(SphereUtils.toSphericalRad(x, y, z));
+    }
+    
+    public static Vector3 toSphericalRad(float x, float y, float z){
+        float radius = (float) Math.sqrt(x*x + y*y + z*z);
+        float polar = (float) Math.acos(y/radius);
+        float azimuth = (float) Math.atan2(z, x);
+        return new Vector3(radius, polar, azimuth);
+    }
+}
diff --git a/core/src/sk/neuromancer/sphaera/rewrite/Splash.java b/core/src/sk/neuromancer/sphaera/rewrite/Splash.java
new file mode 100755
index 0000000..d38fbc5
--- /dev/null
+++ b/core/src/sk/neuromancer/sphaera/rewrite/Splash.java
@@ -0,0 +1,93 @@
+package sk.neuromancer.sphaera.rewrite;
+
+import com.badlogic.gdx.Gdx;
+import com.badlogic.gdx.graphics.Color;
+import com.badlogic.gdx.graphics.GL20;
+import com.badlogic.gdx.graphics.OrthographicCamera;
+import com.badlogic.gdx.graphics.Texture;
+import com.badlogic.gdx.graphics.g2d.Sprite;
+import com.badlogic.gdx.graphics.g2d.SpriteBatch;
+import com.badlogic.gdx.utils.viewport.FillViewport;
+import com.badlogic.gdx.utils.viewport.Viewport;
+
+public class Splash extends GameState{
+    
+    private Sprite splash;
+    private OrthographicCamera camera;
+    private Viewport viewport;
+    private SpriteBatch renderer;
+    
+    public static final String FILE = "splash.png";
+    public static final Color SPLASH_COLOR = Color.valueOf("FF1E29");
+    
+    public static final int DURATION = 2;
+
+    public Splash(Object... remains){
+        super(remains);
+        this.splash = new Sprite(new Texture(Gdx.files.internal(FILE)));
+        this.camera = new OrthographicCamera();
+        this.renderer = new SpriteBatch();
+        
+        this.viewport = new FillViewport(SphaeraGame.DEFAULT_WIDTH, SphaeraGame.DEFAULT_HEIGHT, camera);
+        this.viewport.apply();
+        
+        this.camera.position.set(camera.viewportWidth/2, camera.viewportHeight/2,0);
+    }
+
+    @Override
+    public void show() {
+        resize(Gdx.graphics.getWidth(), Gdx.graphics.getHeight());
+    }
+
+    @Override
+    public void render(float delta) {
+        camera.update();
+        Gdx.gl.glClearColor(SPLASH_COLOR.r, SPLASH_COLOR.g, SPLASH_COLOR.b, SPLASH_COLOR.a);
+        Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT);
+        
+        renderer.setProjectionMatrix(camera.combined);
+        renderer.begin();
+        splash.draw(renderer);
+        renderer.end();
+    }
+    
+    @Override
+    public void tick(long tickCount) {
+        if(tickCount > DURATION * SphaeraGame.TPS){
+            if(!isFinished()){
+                this.finish();
+                this.setNext(new Menu());
+            }
+        }
+    }
+
+    @Override
+    public void resize(int width, int height) {
+        viewport.update(width, height, true);
+        
+        int minSize = width > height ? width : height;
+        splash.setSize(minSize, minSize);
+        splash.setCenter(width/2, height/2);
+    }
+
+    @Override
+    public void pause() {
+
+    }
+
+    @Override
+    public void resume() {
+
+    }
+
+    @Override
+    public void hide() {
+        Gdx.gl.glClearColor(1,1,1,1);
+        Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT);
+    }
+
+    @Override
+    public void dispose() {
+        splash.getTexture().dispose();
+    }
+}
diff --git a/core/src/sk/neuromancer/sphaera/rewrite/World.java b/core/src/sk/neuromancer/sphaera/rewrite/World.java
new file mode 100755
index 0000000..0aa0d0e
--- /dev/null
+++ b/core/src/sk/neuromancer/sphaera/rewrite/World.java
@@ -0,0 +1,339 @@
+package sk.neuromancer.sphaera.rewrite;
+
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Random;
+
+import sk.neuromancer.sphaera.rewrite.LiveSphere.SphereType;
+import sk.neuromancer.sphaera.rewrite.Menu.MenuState;
+
+import com.badlogic.gdx.Gdx;
+import com.badlogic.gdx.Input.Keys;
+import com.badlogic.gdx.graphics.Color;
+import com.badlogic.gdx.graphics.GL20;
+import com.badlogic.gdx.graphics.PerspectiveCamera;
+import com.badlogic.gdx.graphics.g3d.Environment;
+import com.badlogic.gdx.graphics.g3d.ModelBatch;
+import com.badlogic.gdx.graphics.g3d.attributes.ColorAttribute;
+import com.badlogic.gdx.graphics.g3d.environment.DirectionalShadowLight;
+import com.badlogic.gdx.graphics.g3d.utils.DepthShaderProvider;
+
+@SuppressWarnings("deprecation")
+public class World extends GameState{
+
+    private Environment environment;
+    private ModelBatch renderBatch;
+    private PerspectiveCamera camera;
+    private float zoom = 1f;
+
+    /*
+     * TODO SpriteBatch overlay, android control!!
+     * two buttons!!!
+     */
+
+    private ModelBatch shadowBatch;
+    private DirectionalShadowLight shadowLight;
+
+    private List<Sphere> spheres = new LinkedList<Sphere>();
+    private List<LiveSphere> liveSpheres = new LinkedList<LiveSphere>();
+    private Player player;
+    private boolean isGenerated = false;
+    private int level = 1;
+
+
+    public static final int LIVE_SPHERES_BASE = 30;
+    /*
+    public static final int INITIAL_LAYERS = 3;
+     */
+
+    /**
+     * TODO what about this? Should just be Gdx.graphics.getWidth(?
+     */
+    public static final int VIEW_WIDTH = 400;
+    public static final int VIEW_HEIGHT = 300;
+
+    public World(Object... remains) {
+        super(remains);
+
+        this.camera = new PerspectiveCamera(SphaeraGame.FOV, VIEW_WIDTH, VIEW_HEIGHT);
+        this.camera.near = 1f;
+        this.camera.far = 300f;
+        this.camera.update();
+
+        this.shadowLight = new DirectionalShadowLight(Gdx.graphics.getWidth(), Gdx.graphics.getHeight(), VIEW_WIDTH, VIEW_HEIGHT, 1f, 200f);
+        this.shadowLight.set(Color.WHITE, 0, -1, 0);
+
+        this.environment = new Environment();
+
+        this.environment.add(this.shadowLight);
+        this.environment.shadowMap = this.shadowLight;
+
+        environment.set(new ColorAttribute(ColorAttribute.AmbientLight, 0.3f, 0.3f, 0.3f, 0.05f));
+        //TODO environment attibutes
+
+        this.shadowBatch = new ModelBatch(new DepthShaderProvider());
+        this.renderBatch = new ModelBatch();
+    }
+
+
+    /*
+    public void generateNextLayer(int layer){
+        Random r = new Random();
+
+        Sphere parent = spheres.get(layer);
+
+        float polar = 90 + r.nextInt(90);
+        float azimuth = r.nextInt(360);
+        float radius = (layer+1) * (layer+1) * Sphere.BASE_RADIUS * 5;
+        Sphere next = new Sphere(parent, polar, azimuth, radius, Sphere.BASE_MAT);
+        spheres.add(next);
+
+        for(int i = 0; i < LIVE_SPHERES_BASE; i++){
+            //populate sphere
+
+            polar = r.nextInt(180);
+            azimuth = r.nextInt(360);
+            radius = parent.getRadius()/(i*1.7f);
+
+            SphereType type = radius > Player.BASE_RADIUS ? SphereType.BIGGER : SphereType.SMALLER;
+            LiveSphere ls = new LiveSphere(radius, type);
+            ls.setParent(parent);
+            ls.putOnParent(polar, azimuth);
+            if(layer < 2){
+                if(ls.collides(player) || ls.collides(next)){
+                    parent.removeChildren(ls);
+                    i--;
+                    continue;
+                }
+            }
+            liveSpheres.add(ls);
+        }
+    }
+
+    public void generateNew(Player player){
+        this.player = player;
+
+        Sphere base = new Sphere(Sphere.BASE_RADIUS, Sphere.BASE_MAT);
+        player.setParent(base);
+        player.putOnParent(90, 0);
+        player.setDirection(0, 0, 1);
+
+        spheres.add(base);
+
+        Random r = new Random();
+        for(int layer = 0; layer < INITIAL_LAYERS; layer++){
+            generateNextLayer(layer);
+        }
+        isGenerated = true;
+    }
+
+    public void generateNew(){
+        Player playa = new Player(Player.BASE_RADIUS, Player.BASE_MAT);
+        generateNew(playa);
+    }
+     */
+
+    public void generateNew(int level){
+        for(Sphere s: spheres){
+            s.dispose();
+        }
+        for(LiveSphere ls: liveSpheres){
+            ls.dispose();
+        }
+
+        this.spheres.clear();
+        this.liveSpheres.clear();
+
+        if(player == null){
+            player = new Player(Player.BASE_RADIUS, Player.BASE_MAT);
+        }
+        Sphere base = new Sphere(Sphere.BASE_RADIUS*level, Sphere.BASE_MAT);
+        player.setParent(base);
+        player.putOnParent(90, 0);
+        player.setDirection(0, 0, 1);
+
+        spheres.add(base);
+
+        Random r = new Random();
+        float radius = player.getRadius();
+        for(int i = 0; i < LIVE_SPHERES_BASE; i++){
+            //populate sphere
+
+            float polar = r.nextInt(180);
+            float azimuth = r.nextInt(360);
+            
+            if(i > 3)
+                radius += player.getRadius()/2;
+            
+
+            SphereType type = radius > Player.BASE_RADIUS ? SphereType.BIGGER : SphereType.SMALLER;
+            LiveSphere ls = new LiveSphere(radius, type);
+            ls.setParent(base);
+            ls.putOnParent(polar, azimuth);
+            ls.randomDirection();
+            if(ls.collides(player)){
+                base.removeChildren(ls);
+                i--;
+                continue;
+            }
+            liveSpheres.add(ls);
+        }
+
+        this.level++;
+        isGenerated = true;
+    }
+
+    @Override
+    public void show() {
+        if(!isGenerated)
+            generateNew(level);
+
+        resize(Gdx.graphics.getWidth(), Gdx.graphics.getHeight());
+    }
+
+    @Override
+    public void render(float delta) {
+        Gdx.gl.glClearColor(1,1,1,1);
+        Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT | GL20.GL_DEPTH_BUFFER_BIT);
+
+        shadowLight.begin(camera.position, camera.direction);
+        shadowBatch.begin(camera);
+        this.renderThings(shadowBatch, environment);
+        shadowBatch.end();
+        shadowLight.end();
+
+        renderBatch.begin(camera);
+        this.renderThings(renderBatch, environment);
+        renderBatch.end();
+    }
+
+    private void renderThings(ModelBatch batch, Environment environment){
+        for(Sphere s: spheres){
+            s.render(batch, environment);
+        }
+        for(LiveSphere ls : liveSpheres){
+            ls.render(batch, environment);
+        }
+        if(player != null)
+            player.render(batch, environment);
+    }
+
+    @Override
+    public void tick(long tickCount) {
+        if(liveSpheres.size() == 0){
+            //win!
+            this.finish();
+            this.setNext(new Menu(MenuState.WIN, this, player.getRadius()));
+        }
+        
+        if(Gdx.input.isKeyPressed(Keys.A) || Gdx.input.isKeyJustPressed(Keys.LEFT) ||
+                Gdx.input.isKeyPressed(Keys.ALT_LEFT)){
+            player.rotateLeft(Player.ROT_SPEED);
+        }else if(Gdx.input.isKeyPressed(Keys.D) || Gdx.input.isKeyJustPressed(Keys.RIGHT) ||
+                Gdx.input.isKeyPressed(Keys.ALT_RIGHT)){
+            player.rotateRight(Player.ROT_SPEED);
+        }
+        
+        if(Gdx.input.isKeyPressed(Keys.SPACE) || Gdx.input.isKeyPressed(Keys.SHIFT_LEFT) || 
+                Gdx.input.isKeyPressed(Keys.ENTER) || Gdx.input.isKeyPressed(Keys.W)){
+            player.forward(player.getSpeed());
+        }
+
+        player.move();
+
+        Iterator<LiveSphere> live = liveSpheres.iterator();
+
+        while(live.hasNext()){
+            LiveSphere ls = live.next();
+            ls.tick(tickCount);
+            ls.move();
+
+            if(player.getRadius() >= ls.getRadius() && ls.getType().equals(SphereType.BIGGER)){
+                ls.setColorAttributes(ColorAttribute.createDiffuse((Sphere.SMALLER_DIFFUSE)));
+            }
+
+            if(player.collides(ls)){
+                if(player.getRadius() >= ls.getRadius()){
+                    player.scaleRadius(player.getRadius() + ls.getRadius()/(player.getRadius()*0.7f));
+                    ls.getParent().removeChildren(ls);
+                    ls.dispose();
+                    live.remove();
+                }else{
+                    this.finish();
+                    this.setNext(new Menu(MenuState.POST, this, player.getRadius()));
+                }
+            }
+        }
+
+        /*
+        for(Sphere s: spheres){
+            if(s.getParent() == player.getParent()){
+                if(s.collides(player)){
+                    Sphere oldParent = player.getParent();
+                    player.setParent(s);
+                    player.dropOnParent(oldParent);
+                }
+            }
+        }
+         */
+
+        camera.position.set(player.getAbsolutePosition().add(player.getCameraPosition().scl(zoom)));
+        camera.direction.set(player.getCameraDirection());
+        camera.up.set(player.getCameraUp());
+        //camera.far = player.getCameraDirection().len()*3;
+        camera.update();
+    }
+
+    @Override
+    public void resize(int width, int height) {
+
+    }
+
+    @Override
+    public boolean keyDown(int keycode) {
+        if(keycode == Keys.ESCAPE){
+            this.finish();
+            this.setNext(new Menu(MenuState.PAUSE, this, player.getRadius()));
+            return true;
+        }
+        return false;
+    }
+
+    @Override
+    public boolean scrolled(int amount) {
+        this.zoom+=amount*0.1f;
+        return true;
+    }
+
+    @Override
+    public void pause() {
+
+    }
+
+    @Override
+    public void resume() {
+
+    }
+
+    @Override
+    public void hide() {
+
+    }
+
+    @Override
+    public void dispose() {
+        if(this.shadowBatch != null)
+            this.shadowBatch.dispose();
+        if(this.renderBatch != null)
+            this.renderBatch.dispose();
+        for(Sphere s: spheres){
+            s.dispose();
+        }
+        for(LiveSphere ls: liveSpheres){
+            ls.dispose();
+        }
+        if(player != null)
+            player.dispose();
+    }
+}