~repos /gdx-studio

package scene2d;
import scene3d.Actor3d;
import scene3d.Group3d;
import scene3d.Stage3d;

import com.badlogic.gdx.ApplicationListener;
import com.badlogic.gdx.Gdx;
import com.badlogic.gdx.InputMultiplexer;
import com.badlogic.gdx.graphics.Color;
import com.badlogic.gdx.graphics.GL20;
import com.badlogic.gdx.graphics.PerspectiveCamera;
import com.badlogic.gdx.graphics.g2d.Batch;
import com.badlogic.gdx.graphics.glutils.ShapeRenderer;
import com.badlogic.gdx.graphics.glutils.ShapeRenderer.ShapeType;
import com.badlogic.gdx.math.Intersector;
import com.badlogic.gdx.math.MathUtils;
import com.badlogic.gdx.math.Rectangle;
import com.badlogic.gdx.math.Vector2;
import com.badlogic.gdx.scenes.scene2d.Actor;
import com.badlogic.gdx.scenes.scene2d.Group;
import com.badlogic.gdx.scenes.scene2d.InputEvent;
import com.badlogic.gdx.scenes.scene2d.Touchable;
import com.badlogic.gdx.scenes.scene2d.actions.Actions;
import com.badlogic.gdx.scenes.scene2d.ui.Dialog;
import com.badlogic.gdx.scenes.scene2d.ui.Image;
import com.badlogic.gdx.scenes.scene2d.ui.Label;
import com.badlogic.gdx.scenes.scene2d.ui.Table;
import com.badlogic.gdx.scenes.scene2d.utils.ClickListener;
import com.badlogic.gdx.scenes.scene2d.utils.TextureRegionDrawable;
import com.badlogic.gdx.utils.ArrayMap;
import com.badlogic.gdx.utils.Json;
import com.badlogic.gdx.utils.JsonReader;
import com.badlogic.gdx.utils.JsonValue;
import com.badlogic.gdx.utils.Scaling;
import com.badlogic.gdx.utils.StringBuilder;
import com.badlogic.gdx.utils.Timer;
import com.badlogic.gdx.utils.Timer.Task;

abstract public class Scene extends Group {
  /* The array map containing all the scenes data of the game*/
  public static final ArrayMap<String, String> scenesMap = new ArrayMap<String, String>();
  private String sceneName = "";
  public String sceneBackground = "None";
  public String sceneMusic = "None";
  public String sceneTransition = "None";
  public float sceneDuration = 0;
  public InterpolationType sceneInterpolationType = InterpolationType.Linear;

  public static Color bgColor = new Color(1f,1f,1f,1f);
  public static JsonValue configJson = null;
  public static final JsonReader jsonReader = new JsonReader();
  public static final Json json = new Json();
  public static float splashDuration = 0f;
  public static boolean pauseState = false;
  /*Important:
   *  The Target Width  and Target Height refer to the nominal width and height of the game for the
   *  graphics which are created  for this width and height, this allows for the Stage to scale this
   *  graphics for all screen width and height. Therefore your game will work on all screen sizes
   *  but maybe blurred or look awkward on some devices.
   *  ex:
   *  My Game targetWidth = 800 targetHeight = 480
   *  Then my game works perfectly for SCREEN_WIDTH = 800 SCREEN_HEIGHT = 480
   *  and on others screen sizes it is just zoomed/scaled but works fine thats all
   */
  public static float targetWidth = 800;
  public static float targetHeight  = 480;
  public static boolean debug = false;
  public final static Vector2 mouse = new Vector2();

  private static Scene currentScene = null;
  private static int sceneIndex = 0;

  public static ClassLoader cl = null;
  public static com.badlogic.gdx.scenes.scene2d.Stage stage2d;
  public static Stage3d stage3d;
  private static Label fpsLabel;
  private static InputMultiplexer inputMux;

  public static int mousePointer = 0;
  public static int mouseButton = 0;
  public static boolean cullingEnabled = false;
  public static boolean isDirty = false;
  public static String basePackage = "source.";

  public Scene(){
    setTouchable(Touchable.childrenOnly);
    Camera.reset();
    stage2d.clear();
    stage3d.clear();
    stage2d.addListener(touchInput);
    setSize(targetWidth, targetHeight);
    setBounds(0,0, targetWidth, targetHeight);
    setColor(1f, 1f, 1f, 1f);
    setVisible(true);
    stage2d.getRoot().setPosition(0, 0);
    stage2d.getRoot().setVisible(true);
    stage3d.getRoot().setPosition(0, 0, 0);
    stage3d.getRoot().setVisible(true);
    sceneName = this.getClass().getName();
    setName(sceneName);
    Scene.log("Current Scene: "+sceneName);
    currentScene = this;
    load(sceneName);
    cullingEnabled = true;
  }

  @Override
  public void act(float delta){
    super.act(delta);
    if (fpsLabel != null)
      fpsLabel.setText("Fps: " + Gdx.graphics.getFramesPerSecond());
  }

  public abstract void onClick(Actor actor);
  public abstract void onTouchDown(Actor actor);
  public abstract void onTouchUp();
  public abstract void onDragged();
  public abstract void onGesture(GestureType gestureType);
  public abstract void onKeyTyped(char key);
  public abstract void onKeyUp(int keycode);
  public abstract void onKeyDown(int keycode);
  /*
   * This will pause any music and stop any sound being played
   * and will fire the Pause event
   */
  public abstract void onPause();
  /*
   * This will resume any music currently being played
   * and will fire the Resume event
   */
  public abstract void onResume();
  public abstract void onDispose();

  public void load(String sceneName){
    log("Load "+sceneName);
    if(!sceneName.contains(basePackage) && !sceneName.contains("gdxstudio"))
      sceneName = basePackage+sceneName;
    String[] lines = scenesMap.get(sceneName).split("\n");
    for(String line: lines){
      if(line.trim().isEmpty())
        continue;
      json.fromJson(null, line);
      //log(line);
    }
    if(!sceneBackground.equals("None"))
      setBackground(sceneBackground);
    if(!sceneMusic.equals("None"))
      Asset.musicPlay(sceneMusic);
    if(!sceneTransition.equals("None"))
      Effect.createEffect(Scene.getRoot(), EffectType.valueOf(sceneTransition), 1f,
          sceneDuration, sceneInterpolationType);
  }

  protected void save(){
    save(sceneName);
  }

  public void save(String sceneName){
    if(!isDirty)
      return;
    if(sceneName == null || sceneName.isEmpty())
      return;
    Scene.log("Save "+sceneName);
    if(!sceneName.contains(basePackage) && !sceneName.contains("gdxstudio"))
      sceneName = basePackage+sceneName;
    StringBuilder sb = new StringBuilder();
    for(Actor actor: getChildren()){
      sb.append(json.toJson(actor));
      sb.append("\n");
    }
    sb.append(json.toJson(getRoot().findActor(this.sceneName)));//??Warning
    scenesMap.put(sceneName, sb.toString());
    Gdx.files.local(Asset.basePath+"scene").writeString(json.toJson(scenesMap, ArrayMap.class,
        String.class), false);
    sb = null;
    isDirty = false;
  }

  /**
   * Set the current scene to be displayed
   * @param className The scene's Class Name
   **/
  public static void setScene(String className){
    if(!className.contains(basePackage) && !className.contains("gdxstudio"))
      className = basePackage+className;
    if(!scenesMap.containsKey(className)){
      log(className+": Scene Does not Exist");
      return;
    }
    /*
     *  Every time the scene Changes disable panning/following/listening as it can cause the
     *  camera to move around aimlessly, thus abrupting the scene and clear
     *  all the listeners/huds that were registered in the previous scene
     */
    sceneIndex = Scene.scenesMap.keys().toArray().indexOf(className, false);
    if(currentScene != null)
      currentScene.onDispose();
    try {
      if(cl != null)
        cl.loadClass(className).newInstance();
      else
        Class.forName(className).newInstance();
    } catch (InstantiationException e) {
      log("Scene cannot be created , Check if scene class constructor is empty");
      e.printStackTrace();
    } catch (IllegalAccessException e) {
      log("Scene cannot be created , Check if scene class can be found");
      e.printStackTrace();
    } catch (ClassNotFoundException e) {
      log("Scene cannot be created , Check if scene class can be found");
      e.printStackTrace();
    }
    //if (fpsLabel != null && configJson.getBoolean("showFPS")){
    //  fpsLabel.setPosition(targetWidth - 80, targetHeight - 20);
    //  Camera.addHud(fpsLabel);
    //}
  }

  /**
   * Set the current scene to be displayed with an amount of delay
   * @param className The registered scene's name
   **/
  public static void setSceneWithDelay(final String className, float delay){
    Timer.schedule(new Task(){
      @Override
      public void run() {
        setScene(className);
      }
    }, delay);
  }

  /**
   * Returns the current scene being Displayed on stage
   **/
  public static Scene getCurrentScene(){
    return currentScene;
  }

  /**
   * Changes to the next scene in the scnesList
   **/
  public static void nextScene(){
    if(sceneIndex <= scenesMap.size)
      sceneIndex++;
    setScene(scenesMap.getKeyAt(sceneIndex));
  }

  /**
   * Changes to the previous scene in the scnesList
   **/
  public static void prevScene(){
    if(sceneIndex >= 0)
      sceneIndex--;
    setScene(scenesMap.getKeyAt(sceneIndex));
  }

  /**
   * Changes to the next scene in the scnesList
   **/
  public static void nextSceneWithDelay(float delay){
    if(sceneIndex <= scenesMap.size)
      sceneIndex++;
    setSceneWithDelay(Scene.scenesMap.getKeyAt(sceneIndex), delay);
  }

  /**
   * Changes to the previous scene in the scnesList
   **/
  public static void prevSceneWithDelay(float delay){
    if(sceneIndex >= 0)
      sceneIndex--;
    setSceneWithDelay(scenesMap.getKeyAt(sceneIndex), delay);
  }

  private static Image imgbg = null;
  public void setBackground(String texName) {
    if(imgbg != null)
      removeBackground();
    if(Asset.tex(texName) != null){
      imgbg = new Image(new TextureRegionDrawable(Asset.tex(texName)), Scaling.stretch);
      imgbg.setFillParent(true);
      stage2d.addActor(imgbg);
      imgbg.toBack();
    }
  }

  public void removeBackground() {
    getRoot().removeActor(imgbg);
  }

  public static Group getRoot(){
    return stage2d.getRoot();
  }

  public void addActor(Actor actor, float x, float y){
    if(actor != null){
      actor.setPosition(x, y);
      addActor(actor);
    }
  }

  public void addActorWithDelay(final Actor actor, float delay){
    Timer.schedule(new Task(){
      @Override
      public void run() {
        addActor(actor);
      }
    }, delay);
  }

  public boolean removeActor(String actorName){
    return removeActor(findActor(actorName));
  }

  public void removeActorWithDelay(Actor actor, float delay){
    addAction(Actions.sequence(Actions.delay(delay), Actions.removeActor(actor)));
  }

  public Actor hit(float x, float y){
    return hit(x, y, true);
  }


  /* Dragging Camera Related */
  static boolean gestureStarted = false;
  static Actor validActor = null;
  private final ClickListener touchInput = new ClickListener(){
    @Override
    public void clicked(InputEvent event, float x, float y){
      super.clicked(event, x, y);
      mouse.set(x, y);
      validActor = hit(x,y);
      if(validActor != null && validActor.getName() != null)
        Scene.getCurrentScene().onClick(validActor);
    }

    @Override
    public boolean touchDown(InputEvent event, float x, float y, int pointer, int button){
      mouse.set(x, y);
      mousePointer = pointer;
      mouseButton = button;
      touchInitialX = x;
      touchInitialY = y;
      gestureStarted = true;
      validActor = hit(x,y);
      if(validActor != null && validActor.getName() != null)
        Scene.getCurrentScene().onTouchDown(validActor);
      return super.touchDown(event, x, y, pointer, button);
    }


    @Override
    public void touchDragged(InputEvent event, float x, float y, int pointer){
      super.touchDragged(event, x, y, pointer);
      mouse.set(x, y);
      mousePointer = pointer;
      Scene.getCurrentScene().onDragged();
      if(gestureStarted == true){
        touchCurrentX = x;
        touchCurrentY = y;
        if(getGestureDirection() != GestureType.None){
          gestureStarted = false;
          Scene.getCurrentScene().onGesture(getGestureDirection());
        }
      }
      if(Camera.useDrag)
        Camera.dragCam((int)x, (int)-y);
    }

    @Override
    public void touchUp(InputEvent event, float x, float y, int pointer, int button){
      super.touchUp(event, x, y, pointer, button);
      mouse.set(x, y);
      mousePointer = pointer;
      mouseButton = button;
      // reset Gesture
      difX = 0.0f;
      difY = 0.0f;
      touchInitialX = 0.0f;
      touchInitialY = 0.0f;
      touchCurrentX = 0.0f;
      touchCurrentY = 0.0f;
      touchDifX = 0.0f;
      touchDifY = 0.0f;
      prevDifX = 0.0f;
      prevDifY = 0.0f;
      // reset Gesture
      Scene.getCurrentScene().onTouchUp();
      Camera.resetDrag();
      gestureStarted = false;
    }

    @Override
    public boolean keyTyped(InputEvent event, char key) {
      Scene.getCurrentScene().onKeyTyped(key);
      return super.keyUp(event, key);
    }

    @Override
    public boolean keyUp(InputEvent event, int keycode) {
      Scene.getCurrentScene().onKeyUp(keycode);
      return super.keyUp(event, keycode);
    }
    @Override
    public boolean keyDown(InputEvent event, int keycode) {
      Scene.getCurrentScene().onKeyDown(keycode);
      return super.keyDown(event, keycode);
    }
  };

  /*
   * Gesture related
   */
  public static float touchDragIntervalRange = 200f; // 200px drag for a gesture event
  public static float touchInitialX = 0.0f, touchInitialY = 0.0f;
  public static float touchCurrentX = 0.0f, touchCurrentY = 0.0f;
  public static float difX;
  public static float difY;
  public static float prevDifX;
  public static float prevDifY;
  public static float touchDifX;
  public static float touchDifY;

  public boolean isTouchDragInterval() {
    difX = java.lang.Math.abs(touchInitialX - touchCurrentX);
    difY = java.lang.Math.abs(touchInitialY - touchCurrentY);
    if (difX > touchDragIntervalRange || difY > touchDragIntervalRange)
      return true;
    else
      return false;
  }

  public static GestureType getGestureDirection() {
    prevDifX = difX;
    prevDifY = difY;
    difX = java.lang.Math.abs(touchInitialX - touchCurrentX);
    difY = java.lang.Math.abs(touchInitialY - touchCurrentY);
    /**
     * Get minimal changes on drag
     * <p> checkMomentumChanges
     * EXAMPLE<br>
     * User drags finger to left, suddenly dragging to right without removing
     * his finger from the screen
     * */
    if (prevDifX > difX || prevDifY > difY) {
      touchInitialX = touchCurrentX;
      touchInitialY = touchCurrentY;
      //
      difX = 0.0f;
      difY = 0.0f;
      prevDifX = 0.0f;
      prevDifY = 0.0f;

      /**
       * Set touch differences, optional, if you need amount of change from
       * initial touch to drag, USE THIS: on touchDrag, pan or similar mthods
       * */
      touchDifX = java.lang.Math.abs(touchInitialX - touchCurrentX);
      touchDifY = java.lang.Math.abs(touchInitialY - touchCurrentY);
    }
    if (touchInitialY < touchCurrentY && difY > difX) {
      return GestureType.Up;
    } else if (touchInitialY > touchCurrentY && difY > difX) {
      return GestureType.Down;
    } else if (touchInitialX < touchCurrentX && difY < difX) {
      return GestureType.Right;
    } else if (touchInitialX > touchCurrentX && difY < difX) {
      return GestureType.Left;
    } else {
      return GestureType.None;
    }
  }

  /*
   * Dialog Methods
   */
  public void showToast(String message, float duration){
    Table table = new Table(Asset.skin);
    table.add("   "+message+"   ");
    table.setBackground(Asset.skin.getDrawable("dialogDim"));
    table.pack();
    table.setPosition(Scene.targetWidth/2 - table.getWidth(), Scene.targetHeight/2 - table.getHeight());
    addActor(table);
    table.addAction(Actions.sequence(Actions.delay(duration), Actions.removeActor(table)));
  }

  public void showMessageDialog(String title, String message){
    Dialog dialog = new Dialog(title, Asset.skin);
    dialog.getContentTable().add(message);
    dialog.button("OK", "OK");
    dialog.pack();
    dialog.show(getStage());
  }

  public boolean showConfirmDialog(String title, String message){
    Dialog dialog = new Dialog(title, Asset.skin);
    dialog.button("Yes", "Yes");
    dialog.button("No", "No");
    dialog.pack();
    dialog.show(getStage());
    //if(dialog.result().equals("Yes")) FIXME update Gdx
    //  return true;
    return false;
  }

  public void outline(Actor actor){
    selectionBox.setPosition(actor.getX(), actor.getY());
    selectionBox.setSize(actor.getWidth(), actor.getHeight());
    stage2d.addActor(selectionBox);
  }

/***********************************************************************************************************
*           3d Related Functions                                           *
************************************************************************************************************/

  public static void addActor3d(Actor3d actor3d){
    stage3d.addActor3d(actor3d);
  }

  public static void removeActor3d(Actor3d actor3d){
    stage3d.getRoot().removeActor3d(actor3d);
  }

  public static void removeActor3d(String actor3dName){
    getRoot3d().removeActor3d(stage3d.getRoot().findActor(actor3dName));
  }

  public static Group3d getRoot3d(){
    return stage3d.getRoot();
  }

  public static void getChildren3d(){
    stage3d.getActors3d();
  }

  public static void resetCamera3d(){
    stage3d.getCamera().position.set(10f, 10f, 10f);
    stage3d.getCamera().lookAt(0,0,0);
    stage3d.getCamera().near = 0.1f;
    stage3d.getCamera().far = 300f;
  }

  public static PerspectiveCamera getCamera3d(){
    return stage3d.getCamera();
  }


  public static void log(String log) {
    if(Scene.configJson.getBoolean("loggingEnabled"))
      Gdx.app.log("Stage ", log);
  }


/***********************************************************************************************************
*           Utilities Related Functions                                           *
************************************************************************************************************/
  /*
   * The the angle in degrees of the inclination of a line
   * @param cx, cy The center point x, y
   * @param tx, ty The target point x, y
   */
  public static float getAngle(float cx, float cy, float tx, float ty) {
    float angle = (float) Math.toDegrees(MathUtils.atan2(tx - cx, ty - cy));
    //if(angle < 0){
    //    angle += 360;
    //}
    return angle;
  }

  private static Vector2 distVector = new Vector2();
  public static final float getDistance(Actor a, Actor b){
    distVector.set(a.getX(), a.getY());
    return distVector.dst(b.getX(), b.getY());
  }

  public static final float getDistance(float x1, float y1, float x2, float y2){
    distVector.set(x1, y1);
    return distVector.dst(x2, y2);
  }

  /*
   * Capitalizes the First Letter of a String
   */
  public static String capitalize(String text){
    if(text != null && text != "")
      return (text.substring(0, 1)).toUpperCase() + text.substring(1);
    else
      return "";
  }

  /*
   * UnCapitalizes the First Letter of a String
   */
  public static String uncapitalize(String text){
    return text.substring(0, 1).toLowerCase()+text.substring(1);
  }

  public static Rectangle getBounds(Actor actor) {
    float posX = actor.getX();
    float posY = actor.getY();
    float width = actor.getWidth();
    float height = actor.getHeight();
    return new Rectangle(posX, posY, width, height);
  }

  public static boolean collides(Actor actor, float x, float y) {
    Rectangle rectA1 = getBounds(actor);
    Rectangle rectA2 = new Rectangle(x, y, 5, 5);
    // Check if rectangles collides
    if (Intersector.overlaps(rectA1, rectA2)) {
      return true;
    } else {
      return false;
    }
  }

  public static boolean collides(Actor actor1, Actor actor2) {
    Rectangle rectA1 = getBounds(actor1);
    Rectangle rectA2 = getBounds(actor2);
    // Check if rectangles collides
    if (Intersector.overlaps(rectA1, rectA2)) {
      return true;
    } else {
      return false;
    }
  }


  /**
   * Get screen time from start in format of HH:MM:SS. It is calculated from
   * "secondsTime" parameter.
   * */
  public static String toScreenTime(float secondstime) {
    int seconds = (int)(secondstime % 60);
    int minutes = (int)((secondstime / 60) % 60);
    int hours =  (int)((secondstime / 3600) % 24);
    return new String(addZero(hours) + ":" + addZero(minutes) + ":" + addZero(seconds));
  }

  private static String addZero(int value){
    String str = "";
    if(value < 10)
       str = "0" + value;
    else
      str = "" + value;
    return str;
  }

  /*
   * TEA Encryption and Decryption
   */
  public static String encryptKey = "Default";
  private static final int encryptDelta = 0x9E3779B9;
  private static final int MX(int sum, int y, int z, int p, int e, int[] k) {
    return (z >>> 5 ^ y << 2) + (y >>> 3 ^ z << 4) ^ (sum ^ y) + (k[p & 3 ^ e] ^ z);
  }

  public static final byte[] encrypt(String data) {
    return encrypt(data.getBytes(), encryptKey.getBytes());
  }

  public static final byte[] decrypt(String data) {
    return decrypt(data.getBytes(), encryptKey.getBytes());
  }

  public static final byte[] encrypt(String data, String key) {
    return encrypt(data.getBytes(), key.getBytes());
  }

  public static final byte[] decrypt(String data, String key) {
    return decrypt(data.getBytes(), key.getBytes());
  }

  private static final byte[] encrypt(byte[] data, byte[] key) {
    if (data.length == 0)
      return data;
    return toByteArray(encrypt(toIntArray(data, true), toIntArray(key, false)), false);
  }


  private static final byte[] decrypt(byte[] data, byte[] key) {
    if (data.length == 0)
      return data;
    return toByteArray(decrypt(toIntArray(data, false), toIntArray(key, false)), true);
  }

  private static final int[] encrypt(int[] v, int[] k) {
    int n = v.length - 1;
    if (n < 1) {
      return v;
    }
    if (k.length < 4) {
      int[] key = new int[4];

      System.arraycopy(k, 0, key, 0, k.length);
      k = key;
    }
    int z = v[n], y = v[0], sum = 0, e;
    int p, q = 6 + 52 / (n + 1);

    while (q-- > 0) {
      sum = sum + encryptDelta;
      e = sum >>> 2 & 3;
  for (p = 0; p < n; p++) {
    y = v[p + 1];
    z = v[p] += MX(sum, y, z, p, e, k);
  }
  y = v[0];
  z = v[n] += MX(sum, y, z, p, e, k);
    }
    return v;
  }

  private static final int[] decrypt(int[] v, int[] k) {
    int n = v.length - 1;

    if (n < 1) {
      return v;
    }
    if (k.length < 4) {
      int[] key = new int[4];

      System.arraycopy(k, 0, key, 0, k.length);
      k = key;
    }
    int z = v[n], y = v[0], sum, e;
    int p, q = 6 + 52 / (n + 1);

    sum = q * encryptDelta;
    while (sum != 0) {
      e = sum >>> 2 & 3;
    for (p = n; p > 0; p--) {
      z = v[p - 1];
      y = v[p] -= MX(sum, y, z, p, e, k);
    }
    z = v[n];
    y = v[0] -= MX(sum, y, z, p, e, k);
    sum = sum - encryptDelta;
    }
    return v;
  }


  private static final int[] toIntArray(byte[] data, boolean includeLength) {
    int n = (((data.length & 3) == 0)
        ? (data.length >>> 2)
            : ((data.length >>> 2) + 1));
    int[] result;

    if (includeLength) {
      result = new int[n + 1];
      result[n] = data.length;
    }
    else {
      result = new int[n];
    }
    n = data.length;
    for (int i = 0; i < n; i++) {
      result[i >>> 2] |= (0x000000ff & data[i]) << ((i & 3) << 3);
    }
    return result;
  }


  private static final byte[] toByteArray(int[] data, boolean includeLength) {
    int n = data.length << 2;

    if (includeLength) {
      int m = data[data.length - 1];

      if (m > n) {
        return null;
      }
      else {
        n = m;
      }
    }
    byte[] result = new byte[n];

    for (int i = 0; i < n; i++) {
      result[i] = (byte) ((data[i >>> 2] >>> ((i & 3) << 3)) & 0xff);
    }
    return result;
  }

  private static ShapeRenderer shapeRenderer;
  private final static Actor selectionBox = new Actor(){
    @Override
    public void draw(Batch batch, float alpha){
      batch.end();
      shapeRenderer.begin(ShapeType.Line);
      shapeRenderer.setColor(Color.GREEN);
      shapeRenderer.rect(getX(), getY(),
            getWidth(),getHeight());
      shapeRenderer.end();
      batch.begin();
    }
  };

  static void setupFps(){
    fpsLabel = new Label("", Asset.skin);
    fpsLabel.setName("Fps");
  }
  public static float stateTime = 0;
  public static float gameUptime = 0;
  private static float startTime = System.nanoTime();
  /*
   *  The main application listener for the game
   */
  public static ApplicationListener app = new ApplicationListener() {
    public int dots = 40;
    public int xlines;
    public int ylines;
    @Override
    public final void create() {
      log("Create");
      Config.setup();
      Serializer.setup();
      stage2d = new com.badlogic.gdx.scenes.scene2d.Stage(Gdx.graphics.getWidth(), Gdx.graphics.getHeight(),
          Scene.configJson.getBoolean("keepAspectRatio"));
      stage2d.getRoot().setName("Root");
      stage2d.getRoot().setTouchable(Touchable.childrenOnly);
      stage2d.setCamera(new Camera());
      inputMux = new InputMultiplexer();
      inputMux.addProcessor(stage2d);
      stage3d = new Stage3d();
      //camController = new CameraInputController(stage3d.getCamera());
      //inputMux.addProcessor(stage3d);
      //inputMux.addProcessor(camController);
      shapeRenderer = new ShapeRenderer();
      selectionBox.setTouchable(Touchable.disabled);
      selectionBox.setName("Shape");
      JsonValue sv = Scene.jsonReader.parse(Gdx.files.internal(Asset.basePath+"scene"));
      for(JsonValue jv: sv.iterator())
        scenesMap.put(jv.name, jv.asString());
      setScene(scenesMap.firstKey());
      Gdx.input.setCatchBackKey(true);
      Gdx.input.setCatchMenuKey(true);
      Gdx.input.setInputProcessor(inputMux);
      xlines = (int)Gdx.graphics.getWidth()/dots;
       ylines = (int)Gdx.graphics.getHeight()/dots;
    }
    /*
     * This is the main rendering call that updates the time, updates the stage,
     * loads assets asynchronously, updates the camera and FPS text.
     */
    @Override
    public final void render(){
      Gdx.gl.glClearColor(bgColor.r, bgColor.g, bgColor.b, bgColor.a);
      Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT |GL20.GL_DEPTH_BUFFER_BIT);
      if (System.nanoTime() - startTime >= 1000000000) {
        gameUptime +=1 ;
        startTime = System.nanoTime();
      }
      stateTime += Gdx.graphics.getDeltaTime();
      Asset.load();
      stage3d.act();
      stage3d.draw();
        //camController.update();
      Scene.stage2d.act();//Gdx.graphics.getDeltaTime();
      Scene.stage2d.draw();
      if(debug){
        shapeRenderer.begin(ShapeType.Point);
        shapeRenderer.setColor(Color.BLACK);
        for(int i = 0; i<=xlines; i++)
          for(int j = 0; j<=ylines; j++)
            shapeRenderer.point(2+i*dots, j*dots, 0);
        shapeRenderer.end();
      }
     }
    @Override
    public final void resize(int width, int height) {
      log("Resize");
      stage2d.setViewport(targetWidth, targetHeight, configJson.getBoolean("keepAspectRatio"));
      stage3d.setViewport(targetWidth, targetHeight, configJson.getBoolean("keepAspectRatio"));
    }
    @Override
    public final void pause() {
      log("Pause");
      Asset.musicPause();
      Asset.soundStop();
      Scene.pauseState = true;
      Scene.getCurrentScene().onPause();
    }
    @Override
    public final void resume() {
      log("Resume");
      Asset.musicResume();
      Scene.pauseState = false;
      Scene.getCurrentScene().onResume();
    }
    @Override
    public final void dispose() {
      log("Dispose");
      Scene.getCurrentScene().onDispose();
      Scene.stage2d.dispose();
      Asset.unloadAll();
      Gdx.app.exit();
    }
  };

  public static final void exit(){
    log("Disposing and Exiting");
    getCurrentScene().onDispose();
    stage2d.dispose();
    stage3d.dispose();
    Asset.unloadAll();
    Gdx.app.exit();
  }


  public enum GestureType {
    None, Up, Down, Left, Right
  }

  public enum OnEventType {
    DoEffect,
    SetScene
  }

}