void loadPrefs() {
   debugBonesCheckbox.setChecked(prefs.getBoolean("debugBones", true));
   debugRegionsCheckbox.setChecked(prefs.getBoolean("debugRegions", false));
   debugMeshHullCheckbox.setChecked(prefs.getBoolean("debugMeshHull", false));
   debugMeshTrianglesCheckbox.setChecked(prefs.getBoolean("debugMeshTriangles", false));
   debugPathsCheckbox.setChecked(prefs.getBoolean("debugPaths", true));
   premultipliedCheckbox.setChecked(prefs.getBoolean("premultiplied", true));
   loopCheckbox.setChecked(prefs.getBoolean("loop", false));
   speedSlider.setValue(prefs.getFloat("speed", 0.3f));
   mixSlider.setValue(prefs.getFloat("mix", 0.3f));
   scaleSlider.setValue(prefs.getFloat("scale", 1));
   skeletonX = prefs.getInteger("x", 0);
   skeletonY = prefs.getInteger("y", 0);
   animationList.setSelected(prefs.getString("animationName", null));
   skinList.setSelected(prefs.getString("skinName", null));
   prefsLoaded = true;
 }
Example #2
0
  private List<String> createTestList() {
    // Create behavior names
    int numBehaviors = tests.length;
    String[] behaviorNames = new String[numBehaviors];
    for (int i = 0; i < numBehaviors; i++) {
      behaviorNames[i] = tests[i].testName;
    }

    final List<String> behaviorsList = new List<String>(skin);
    behaviorsList.setItems(behaviorNames);
    behaviorsList.addListener(
        new ClickListener() {
          @Override
          public void clicked(InputEvent event, float x, float y) {
            if (!behaviorSelectionWindow.isCollapsed() && getTapCount() == 2) {
              changeTest(behaviorsList.getSelectedIndex());
              behaviorSelectionWindow.collapse();
            }
          }
        });
    return behaviorsList;
  }
 void savePrefs() {
   if (!prefsLoaded) return;
   prefs.putBoolean("debugBones", debugBonesCheckbox.isChecked());
   prefs.putBoolean("debugRegions", debugRegionsCheckbox.isChecked());
   prefs.putBoolean("debugMeshHull", debugMeshHullCheckbox.isChecked());
   prefs.putBoolean("debugMeshTriangles", debugMeshTrianglesCheckbox.isChecked());
   prefs.putBoolean("debugPaths", debugPathsCheckbox.isChecked());
   prefs.putBoolean("premultiplied", premultipliedCheckbox.isChecked());
   prefs.putBoolean("loop", loopCheckbox.isChecked());
   prefs.putFloat("speed", speedSlider.getValue());
   prefs.putFloat("mix", mixSlider.getValue());
   prefs.putFloat("scale", scaleSlider.getValue());
   prefs.putInteger("x", skeletonX);
   prefs.putInteger("y", skeletonY);
   TrackEntry current = state.getCurrent(0);
   if (current != null) {
     String name = current.animation.name;
     if (name.equals("<empty>")) name = current.next == null ? "" : current.next.animation.name;
     prefs.putString("animationName", name);
   }
   if (skinList.getSelected() != null) prefs.putString("skinName", skinList.getSelected());
   prefs.flush();
 }
    void initialize() {
      skin.getFont("default").getData().markupEnabled = true;

      for (int i = 0; i < 6; i++) trackButtons.add(new TextButton(i + "", skin, "toggle"));

      animationList.getSelection().setRequired(false);

      premultipliedCheckbox.setChecked(true);

      loopCheckbox.setChecked(true);

      scaleSlider.setValue(1);
      scaleSlider.setSnapToValues(new float[] {1, 1.5f, 2, 2.5f, 3, 3.5f}, 0.01f);

      mixSlider.setValue(0.3f);
      mixSlider.setSnapToValues(new float[] {1, 1.5f, 2, 2.5f, 3, 3.5f}, 0.1f);

      speedSlider.setValue(1);
      speedSlider.setSnapToValues(new float[] {0.5f, 0.75f, 1, 1.25f, 1.5f, 2, 2.5f}, 0.1f);

      alphaSlider.setValue(1);
      alphaSlider.setDisabled(true);

      window.setMovable(false);
      window.setResizable(false);
      window.setKeepWithinStage(false);
      window.setX(-3);
      window.setY(-2);

      window.getTitleLabel().setColor(new Color(0.76f, 1, 1, 1));
      window.getTitleTable().add(openButton).space(3);
      window.getTitleTable().add(minimizeButton).width(20);

      skinScroll.setFadeScrollBars(false);

      animationScroll.setFadeScrollBars(false);
    }
Example #5
0
  @Override
  public void create() {
    skin = new Skin(Gdx.files.internal("data/uiskin.json"));
    texture1 = new Texture(Gdx.files.internal("data/badlogicsmall.jpg"));
    texture2 = new Texture(Gdx.files.internal("data/badlogic.jpg"));
    TextureRegion image = new TextureRegion(texture1);
    TextureRegion imageFlipped = new TextureRegion(image);
    imageFlipped.flip(true, true);
    TextureRegion image2 = new TextureRegion(texture2);
    // stage = new Stage(Gdx.graphics.getWidth(), Gdx.graphics.getHeight(), false, new
    // PolygonSpriteBatch());
    stage = new Stage();
    // stage.setViewport(new ExtendViewport(800, 480));
    Gdx.input.setInputProcessor(stage);

    // Group.debug = true;

    ImageButtonStyle style = new ImageButtonStyle(skin.get(ButtonStyle.class));
    style.imageUp = new TextureRegionDrawable(image);
    style.imageDown = new TextureRegionDrawable(imageFlipped);
    ImageButton iconButton = new ImageButton(style);

    Button buttonMulti = new TextButton("Multi\nLine\nToggle", skin, "toggle");
    Button imgButton = new Button(new Image(image), skin);
    Button imgToggleButton = new Button(new Image(image), skin, "toggle");

    Label myLabel = new Label("this is some text.", skin);
    myLabel.setWrap(true);

    Table t = new Table();
    t.row();
    t.add(myLabel);

    t.layout();

    CheckBox checkBox = new CheckBox("Check me", skin);
    final Slider slider = new Slider(0, 10, 1, false, skin);
    TextField textfield = new TextField("", skin);
    textfield.setMessageText("Click here!");
    SelectBox dropdown = new SelectBox(skin);
    dropdown.setItems(
        "Android1",
        "Windows1",
        "Linux1",
        "OSX1",
        "Android2",
        "Windows2",
        "Linux2",
        "OSX2",
        "Android3",
        "Windows3",
        "Linux3",
        "OSX3",
        "Android4",
        "Windows4",
        "Linux4",
        "OSX4",
        "Android5",
        "Windows5",
        "Linux5",
        "OSX5",
        "Android6",
        "Windows6",
        "Linux6",
        "OSX6",
        "Android7",
        "Windows7",
        "Linux7",
        "OSX7");
    dropdown.setSelected("Linux6");
    Image imageActor = new Image(image2);
    ScrollPane scrollPane = new ScrollPane(imageActor);
    List list = new List(skin);
    list.setItems(listEntries);
    list.getSelection().setMultiple(true);
    list.getSelection().setRequired(false);
    // list.getSelection().setToggle(true);
    ScrollPane scrollPane2 = new ScrollPane(list, skin);
    scrollPane2.setFlickScroll(false);
    SplitPane splitPane = new SplitPane(scrollPane, scrollPane2, false, skin, "default-horizontal");
    fpsLabel = new Label("fps:", skin);

    // configures an example of a TextField in password mode.
    final Label passwordLabel = new Label("Textfield in password mode: ", skin);
    final TextField passwordTextField = new TextField("", skin);
    passwordTextField.setMessageText("password");
    passwordTextField.setPasswordCharacter('*');
    passwordTextField.setPasswordMode(true);

    // window.debug();
    Window window = new Window("Dialog", skin);
    window.getButtonTable().add(new TextButton("X", skin)).height(window.getPadTop());
    window.setPosition(0, 0);
    window.defaults().spaceBottom(10);
    window.row().fill().expandX();
    window.add(iconButton);
    window.add(buttonMulti);
    window.add(imgButton);
    window.add(imgToggleButton);
    window.row();
    window.add(checkBox);
    window.add(slider).minWidth(100).fillX().colspan(3);
    window.row();
    window.add(dropdown);
    window.add(textfield).minWidth(100).expandX().fillX().colspan(3);
    window.row();
    window.add(splitPane).fill().expand().colspan(4).maxHeight(200);
    window.row();
    window.add(passwordLabel).colspan(2);
    window.add(passwordTextField).minWidth(100).expandX().fillX().colspan(2);
    window.row();
    window.add(fpsLabel).colspan(4);
    window.pack();

    // stage.addActor(new Button("Behind Window", skin));
    stage.addActor(window);

    textfield.setTextFieldListener(
        new TextFieldListener() {
          public void keyTyped(TextField textField, char key) {
            if (key == '\n') textField.getOnscreenKeyboard().show(false);
          }
        });

    slider.addListener(
        new ChangeListener() {
          public void changed(ChangeEvent event, Actor actor) {
            Gdx.app.log("UITest", "slider: " + slider.getValue());
          }
        });

    iconButton.addListener(
        new ChangeListener() {
          public void changed(ChangeEvent event, Actor actor) {
            new Dialog("Some Dialog", skin, "dialog") {
              protected void result(Object object) {
                System.out.println("Chosen: " + object);
              }
            }.text("Are you enjoying this demo?")
                .button("Yes", true)
                .button("No", false)
                .key(Keys.ENTER, true)
                .key(Keys.ESCAPE, false)
                .show(stage);
          }
        });
  }
    void events() {
      window.addListener(
          new InputListener() {
            public boolean touchDown(InputEvent event, float x, float y, int pointer, int button) {
              event.cancel();
              return true;
            }
          });

      openButton.addListener(
          new ChangeListener() {
            public void changed(ChangeEvent event, Actor actor) {
              FileDialog fileDialog = new FileDialog((Frame) null, "Choose skeleton file");
              fileDialog.setMode(FileDialog.LOAD);
              fileDialog.setVisible(true);
              String name = fileDialog.getFile();
              String dir = fileDialog.getDirectory();
              if (name == null || dir == null) return;
              loadSkeleton(new FileHandle(new File(dir, name).getAbsolutePath()));
            }
          });

      setupPoseButton.addListener(
          new ChangeListener() {
            public void changed(ChangeEvent event, Actor actor) {
              if (skeleton != null) skeleton.setToSetupPose();
            }
          });
      bonesSetupPoseButton.addListener(
          new ChangeListener() {
            public void changed(ChangeEvent event, Actor actor) {
              if (skeleton != null) skeleton.setBonesToSetupPose();
            }
          });
      slotsSetupPoseButton.addListener(
          new ChangeListener() {
            public void changed(ChangeEvent event, Actor actor) {
              if (skeleton != null) skeleton.setSlotsToSetupPose();
            }
          });

      minimizeButton.addListener(
          new ClickListener() {
            public boolean touchDown(InputEvent event, float x, float y, int pointer, int button) {
              event.cancel();
              return super.touchDown(event, x, y, pointer, button);
            }

            public void clicked(InputEvent event, float x, float y) {
              if (minimizeButton.isChecked()) {
                window.getCells().get(0).setActor(null);
                window.setHeight(37);
                minimizeButton.setText("+");
              } else {
                window.getCells().get(0).setActor(root);
                ui.window.setHeight(Gdx.graphics.getHeight() + 8);
                minimizeButton.setText("-");
              }
            }
          });

      scaleSlider.addListener(
          new ChangeListener() {
            public void changed(ChangeEvent event, Actor actor) {
              scaleLabel.setText(Float.toString((int) (scaleSlider.getValue() * 100) / 100f));
              if (!scaleSlider.isDragging()) loadSkeleton(skeletonFile);
            }
          });

      speedSlider.addListener(
          new ChangeListener() {
            public void changed(ChangeEvent event, Actor actor) {
              speedLabel.setText(Float.toString((int) (speedSlider.getValue() * 100) / 100f));
            }
          });

      alphaSlider.addListener(
          new ChangeListener() {
            public void changed(ChangeEvent event, Actor actor) {
              alphaLabel.setText(Float.toString((int) (alphaSlider.getValue() * 100) / 100f));
              int track = trackButtons.getCheckedIndex();
              if (track > 0) {
                TrackEntry current = state.getCurrent(track);
                if (current != null) {
                  current.setAlpha(alphaSlider.getValue());
                  current.resetRotationDirections();
                }
              }
            }
          });

      mixSlider.addListener(
          new ChangeListener() {
            public void changed(ChangeEvent event, Actor actor) {
              mixLabel.setText(Float.toString((int) (mixSlider.getValue() * 100) / 100f));
              if (state != null) state.getData().setDefaultMix(mixSlider.getValue());
            }
          });

      animationList.addListener(
          new ChangeListener() {
            public void changed(ChangeEvent event, Actor actor) {
              if (state != null) {
                String name = animationList.getSelected();
                if (name == null)
                  state.setEmptyAnimation(trackButtons.getCheckedIndex(), ui.mixSlider.getValue());
                else setAnimation();
              }
            }
          });

      loopCheckbox.addListener(
          new ChangeListener() {
            public void changed(ChangeEvent event, Actor actor) {
              setAnimation();
            }
          });

      skinList.addListener(
          new ChangeListener() {
            public void changed(ChangeEvent event, Actor actor) {
              if (skeleton != null) {
                String skinName = skinList.getSelected();
                if (skinName == null) skeleton.setSkin((Skin) null);
                else skeleton.setSkin(skinName);
                skeleton.setSlotsToSetupPose();
              }
            }
          });

      ChangeListener trackButtonListener =
          new ChangeListener() {
            public void changed(ChangeEvent event, Actor actor) {
              int track = ui.trackButtons.getCheckedIndex();
              if (track == -1) return;
              TrackEntry current = state.getCurrent(track);
              animationList.getSelection().setProgrammaticChangeEvents(false);
              animationList.setSelected(current == null ? null : current.animation.name);
              animationList.getSelection().setProgrammaticChangeEvents(true);

              alphaSlider.setDisabled(track == 0);
              alphaSlider.setValue(current == null ? 1 : current.alpha);
            }
          };
      for (TextButton button : trackButtons.getButtons()) button.addListener(trackButtonListener);

      Gdx.input.setInputProcessor(
          new InputMultiplexer(
              stage,
              new InputAdapter() {
                public boolean touchDown(int screenX, int screenY, int pointer, int button) {
                  touchDragged(screenX, screenY, pointer);
                  return false;
                }

                public boolean touchDragged(int screenX, int screenY, int pointer) {
                  skeletonX = screenX;
                  skeletonY = Gdx.graphics.getHeight() - screenY;
                  return false;
                }

                public boolean touchUp(int screenX, int screenY, int pointer, int button) {
                  savePrefs();
                  return false;
                }
              }));

      ChangeListener savePrefsListener =
          new ChangeListener() {
            public void changed(ChangeEvent event, Actor actor) {
              if (actor instanceof Slider && ((Slider) actor).isDragging()) return;
              savePrefs();
            }
          };
      debugBonesCheckbox.addListener(savePrefsListener);
      debugRegionsCheckbox.addListener(savePrefsListener);
      debugMeshHullCheckbox.addListener(savePrefsListener);
      debugMeshTrianglesCheckbox.addListener(savePrefsListener);
      debugPathsCheckbox.addListener(savePrefsListener);
      premultipliedCheckbox.addListener(savePrefsListener);
      loopCheckbox.addListener(savePrefsListener);
      speedSlider.addListener(savePrefsListener);
      mixSlider.addListener(savePrefsListener);
      scaleSlider.addListener(savePrefsListener);
      animationList.addListener(savePrefsListener);
      skinList.addListener(savePrefsListener);
    }
  public LevelEditorGameState(GameStateManager gsm) {
    super(gsm);

    bitmapFont = new BitmapFont();
    stage = new Stage();

    Skin skin = new Skin(Gdx.files.internal("uiskin.json"));
    Label titleLabel = new Label("Level Editor", skin);
    stage.addActor(titleLabel);
    Table table = new Table();
    stage.addActor(table);
    table.setSize(V_WIDTH / 3, V_HEIGHT);
    table.setPosition(0, 0);
    table.debug(); // show debug shit

    int i = 0;
    for (E_TOOL e : E_TOOL.values()) {
      // for use in the input listener
      final E_TOOL temp = e;
      TextButton b = new TextButton(e.name(), skin);
      b.addListener(
          new InputListener() {
            @Override
            public boolean touchDown(InputEvent event, float x, float y, int pointer, int button) {
              current_Tool = temp;
              return false;
            }
          });

      if (++i % 2 == 0) {
        table.row();
      }
      table.add(b);
    }

    table.row();

    table.add(new Label("Zoom", skin));
    zoomSlider = new Slider(0.1f, 10.0f, 0.1f, false, skin);
    zoomSlider.addListener(
        new ChangeListener() {
          @Override
          public void changed(ChangeEvent event, Actor actor) {
            cam.zoom = zoom = zoomSlider.getValue();
          }
        });
    table.add(zoomSlider);

    table.row();

    table.add(new Label("Grid", skin));
    gridSlider = new Slider(1, 20, 1, false, skin);
    gridSlider.addListener(
        new ChangeListener() {
          @Override
          public void changed(ChangeEvent event, Actor actor) {
            gridSize = (int) gridSlider.getValue();
          }
        });
    table.add(gridSlider);

    final List pointTypeList = new List(skin);
    pointTypeList.setItems(Point.TYPE.values());
    pointTypeList.addListener(
        new ChangeListener() {
          @Override
          public void changed(ChangeEvent event, Actor actor) {
            point_Type = (Point.TYPE) pointTypeList.getSelected();
          }
        });

    final List shapeTypeList = new List(skin);
    shapeTypeList.setItems(Shape.TYPE.values());
    shapeTypeList.addListener(
        new ChangeListener() {
          @Override
          public void changed(ChangeEvent event, Actor actor) {
            shape_Type = (Shape.TYPE) shapeTypeList.getSelected();
          }
        });

    table.row();
    table.add(pointTypeList);

    table.row();
    table.add(shapeTypeList);

    current_Tool = E_TOOL.SELECT;
    point_Type = Point.TYPE.SPAWN;
    shape_Type = Shape.TYPE.WALL;

    gridSize = 2;
    width = V_WIDTH;
    height = V_HEIGHT;
    zoom = 5;

    cam.zoom = zoom;

    filename = "blacklevel.lvl";
    loadLevel(filename);

    setInputProcessor(new InputMultiplexer(stage, new EditorInputAdapter()));
  }