com.bladecoder.engine.model.BaseActor - java examples

Here are the examples of the java api com.bladecoder.engine.model.BaseActor taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.

64 Examples 7

19 View Complete Implementation : ActorList.java
Copyright Apache License 2.0
Author : bladecoder
@Override
protected void edit() {
    BaseActor e = list.getSelected();
    if (e == null)
        return;
    EditModelDialog<Scene, BaseActor> dialog = getEditElementDialogInstance(e);
    dialog.show(getStage());
    dialog.setListener(new ChangeListener() {

        @SuppressWarnings("unchecked")
        @Override
        public void changed(ChangeEvent event, Actor actor) {
            BaseActor e = ((EditModelDialog<Scene, BaseActor>) actor).getElement();
            // When the type is changed, a new element is created and it is needed to replace the previous element.
            if (e != list.getSelected()) {
                int i = list.getSelectedIndex();
                gereplacedems().set(i, e);
                list.setSelectedIndex(i);
                list.invalidateHierarchy();
            }
        }
    });
}

19 View Complete Implementation : ActorProps.java
Copyright Apache License 2.0
Author : bladecoder
public clreplaced ActorProps extends PropertyTable {

    public static final String DESC_PROP = "Description";

    public static final String POS_X_PROP = "pos X";

    public static final String POS_Y_PROP = "pos Y";

    public static final String VISIBLE_PROP = "visible";

    public static final String INTERACTION_PROP = "interaction";

    public static final String STATE_PROP = "state";

    public static final String BBOX_FROM_RENDERER_PROP = "Set BBOX from renderer";

    private BaseActor actor;

    // TableModelListener tableModelListener = new TableModelListener() {
    // @Override
    // public void tableChanged(TableModelEvent e) {
    // if (e.getType() == TableModelEvent.UPDATE) {
    // int row = e.getFirstRow();
    // updateModel((String) propertyTable.getModel().getValueAt(row, 0),
    // (String) propertyTable.getModel().getValueAt(row, 1));
    // }
    // }
    // };
    PropertyChangeListener propertyChangeListener = new PropertyChangeListener() {

        @Override
        public void propertyChange(PropertyChangeEvent evt) {
            EditorLogger.debug("Actor Props Listener: " + evt.getPropertyName());
            updateField(evt.getPropertyName());
        }
    };

    public ActorProps(Skin skin) {
        super(skin);
    }

    private void updateField(String modelProperty) {
        if (actor == null)
            return;
        if (modelProperty.equals("desc")) {
            setProperty(DESC_PROP, ((InteractiveActor) actor).getDesc());
        } else if (modelProperty.equals(Project.POSITION_PROPERTY)) {
            setProperty(POS_X_PROP, Float.toString(actor.getX()));
            setProperty(POS_Y_PROP, Float.toString(actor.getY()));
        } else if (modelProperty.equals("visible")) {
            setProperty(VISIBLE_PROP, Boolean.toString(actor.isVisible()));
        } else if (modelProperty.equals("interaction")) {
            setProperty(INTERACTION_PROP, Boolean.toString(((InteractiveActor) actor).getInteraction()));
        } else if (modelProperty.equals("state")) {
            setProperty(STATE_PROP, ((InteractiveActor) actor).getState());
        } else if (modelProperty.equals("bbox")) {
        // TODO Conflict with scnwidget
        // boolean v = value.isEmpty();
        // setProperty(BBOX_FROM_RENDERER_PROP, Boolean.toString(v));
        }
    }

    public void setActorDoreplacedent(BaseActor a) {
        this.actor = a;
        clearProps();
        if (a != null) {
            addProperty(POS_X_PROP, Float.toString(actor.getX()), Types.FLOAT);
            addProperty(POS_Y_PROP, Float.toString(actor.getY()), Types.FLOAT);
            addProperty(VISIBLE_PROP, Boolean.toString(actor.isVisible()), Types.BOOLEAN);
            if (a instanceof InteractiveActor) {
                addProperty(DESC_PROP, ((InteractiveActor) actor).getDesc());
                addProperty(INTERACTION_PROP, Boolean.toString(((InteractiveActor) actor).getInteraction()), Types.BOOLEAN);
                addProperty(STATE_PROP, ((InteractiveActor) actor).getState());
            }
            if (a instanceof SpriteActor) {
                boolean v = ((SpriteActor) a).isBboxFromRenderer();
                addProperty(BBOX_FROM_RENDERER_PROP, Boolean.toString(v), Types.BOOLEAN);
            }
            Ctx.project.addPropertyChangeListener(propertyChangeListener);
            invalidateHierarchy();
        }
    }

    @Override
    protected void updateModel(String property, String value) {
        if (property.equals(DESC_PROP)) {
            ((InteractiveActor) actor).setDesc(value);
        } else if (property.equals(POS_X_PROP)) {
            // TODO UNDO
            // UndoOp undoOp = new UndoSetAttr(Ctx.project.getSelectedChapter(), Ctx.project.getSelectedActor(), XMLConstants.POS_ATTR,
            // Param.toStringParam(pos));
            // Ctx.project.getUndoStack().add(undoOp);
            try {
                actor.setPosition(Float.parseFloat(value), actor.getY());
            } catch (NumberFormatException e) {
            }
        } else if (property.equals(POS_Y_PROP)) {
            // UndoOp undoOp = new UndoSetAttr(Ctx.project.getSelectedChapter(), Ctx.project.getSelectedActor(),XMLConstants.POS_ATTR,
            // Param.toStringParam(pos));
            // Ctx.project.getUndoStack().add(undoOp);
            try {
                actor.setPosition(actor.getX(), Float.parseFloat(value));
            } catch (NumberFormatException e) {
            }
        } else if (property.equals(VISIBLE_PROP)) {
            actor.setVisible(Boolean.parseBoolean(value));
        } else if (property.equals(INTERACTION_PROP)) {
            ((InteractiveActor) actor).setInteraction(Boolean.parseBoolean(value));
        } else if (property.equals(STATE_PROP)) {
            ((InteractiveActor) actor).setState(value);
        } else if (property.equals(BBOX_FROM_RENDERER_PROP)) {
            boolean v = true;
            try {
                v = Boolean.parseBoolean(value);
            } catch (ParseException e) {
            }
            ((SpriteActor) actor).setBboxFromRenderer(v);
        }
    }
}

19 View Complete Implementation : ScnWidgetInputListener.java
Copyright Apache License 2.0
Author : bladecoder
public clreplaced ScnWidgetInputListener extends ClickListener {

    private final ScnWidget scnWidget;

    public static enum DraggingModes {

        NONE,
        DRAGGING_ACTOR,
        DRAGGING_BBOX_POINT,
        DRAGGING_MARKER_0,
        DRAGGING_MARKER_100,
        DRAGGING_REFPOINT,
        ROTATE_ACTOR,
        SCALE_LOCK_ACTOR,
        SCALE_ACTOR
    }

    private DraggingModes draggingMode = DraggingModes.NONE;

    private BaseActor selActor = null;

    private Vector2 org = new Vector2();

    private Vector2 undoOrg = new Vector2();

    private float undoRot = 0;

    private int vertIndex;

    public ScnWidgetInputListener(ScnWidget w) {
        this.scnWidget = w;
    }

    @Override
    public void clicked(InputEvent event, float x, float y) {
        Scene scn = scnWidget.getScene();
        if (scn == null)
            return;
        Vector2 p = new Vector2(Gdx.input.getX(), Gdx.input.getY());
        scnWidget.screenToWorldCoords(p);
        // DOUBLE CLICK TO CREATE OR DELETE POINTS
        if (getTapCount() == 2 && scnWidget.getSelectedActor() != null) {
            Polygon poly = scnWidget.getSelectedActor().getBBox();
            if ((!(scnWidget.getSelectedActor() instanceof SpriteActor) || !((SpriteActor) scnWidget.getSelectedActor()).isBboxFromRenderer()) && !(scnWidget.getSelectedActor() instanceof AnchorActor)) {
                if (UIUtils.ctrl()) {
                    // Delete the point if selected
                    boolean deleted = PolygonUtils.deletePoint(poly, p.x, p.y, CanvasDrawer.CORNER_DIST);
                    if (deleted) {
                        Ctx.project.setModified();
                        return;
                    }
                } else {
                    boolean created = PolygonUtils.addClampPointIfTolerance(poly, p.x, p.y, CanvasDrawer.CORNER_DIST);
                    if (created) {
                        Ctx.project.setModified();
                        return;
                    }
                }
            }
        }
    }

    @Override
    public boolean touchDown(InputEvent event, float x, float y, int pointer, int button) {
        super.touchDown(event, x, y, pointer, button);
        // EditorLogger.debug("Touch Down - X: " + x + " Y: " + y);
        Scene scn = scnWidget.getScene();
        if (scn == null)
            return false;
        Vector2 p = new Vector2(Gdx.input.getX(), Gdx.input.getY());
        scnWidget.screenToWorldCoords(p);
        org.set(p);
        if (button == Buttons.LEFT) {
            selActor = scnWidget.getSelectedActor();
            if (selActor != null) {
                // ORIGIN DRAGGING
                if (selActor instanceof InteractiveActor) {
                    Vector2 refPoint = ((InteractiveActor) selActor).getRefPoint();
                    float orgX = selActor.getX() + refPoint.x;
                    float orgY = selActor.getY() + refPoint.y;
                    float dst = Vector2.dst(p.x, p.y, orgX, orgY);
                    if (dst < Scene.ANCHOR_RADIUS) {
                        draggingMode = DraggingModes.DRAGGING_REFPOINT;
                        undoOrg.set(refPoint.x, refPoint.y);
                        return true;
                    }
                }
                // VERTEXs DRAGGING
                if ((!(selActor instanceof SpriteActor) || !((SpriteActor) selActor).isBboxFromRenderer()) && !(scnWidget.getSelectedActor() instanceof AnchorActor)) {
                    Polygon bbox = selActor.getBBox();
                    float[] verts = bbox.getTransformedVertices();
                    for (int i = 0; i < verts.length; i += 2) {
                        if (p.dst(verts[i], verts[i + 1]) < CanvasDrawer.CORNER_DIST) {
                            draggingMode = DraggingModes.DRAGGING_BBOX_POINT;
                            vertIndex = i;
                            float[] v = bbox.getVertices();
                            undoOrg.set(v[i], v[i + 1]);
                            return true;
                        }
                    }
                }
                // CLICK IN MOVE ICON
                if (!(selActor instanceof AnchorActor) && scnWidget.inTransformIcon(p.x, p.y, DraggingModes.DRAGGING_ACTOR)) {
                    draggingMode = DraggingModes.DRAGGING_ACTOR;
                    undoOrg.set(selActor.getX(), selActor.getY());
                    return true;
                }
                if (selActor instanceof AnchorActor) {
                    float orgX = selActor.getX();
                    float orgY = selActor.getY();
                    float dst = Vector2.dst(p.x, p.y, orgX, orgY);
                    if (dst < Scene.ANCHOR_RADIUS) {
                        draggingMode = DraggingModes.DRAGGING_ACTOR;
                        undoOrg.set(selActor.getX(), selActor.getY());
                        return true;
                    }
                }
                // CHECK CLICK IN TRANSFORM ICON
                if (selActor instanceof SpriteActor) {
                    if (scnWidget.inTransformIcon(p.x, p.y, DraggingModes.ROTATE_ACTOR)) {
                        draggingMode = DraggingModes.ROTATE_ACTOR;
                        undoRot = ((SpriteActor) selActor).getRot();
                        return true;
                    }
                    if (!((SpriteActor) selActor).getFakeDepth()) {
                        if (scnWidget.inTransformIcon(p.x, p.y, DraggingModes.SCALE_ACTOR)) {
                            draggingMode = DraggingModes.SCALE_ACTOR;
                            undoOrg.set(((SpriteActor) selActor).getScaleX(), ((SpriteActor) selActor).getScaleY());
                            return true;
                        }
                        if (scnWidget.inTransformIcon(p.x, p.y, DraggingModes.SCALE_LOCK_ACTOR)) {
                            draggingMode = DraggingModes.SCALE_LOCK_ACTOR;
                            undoOrg.set(((SpriteActor) selActor).getScaleX(), ((SpriteActor) selActor).getScaleY());
                            return true;
                        }
                    }
                }
            }
            // CHECK FOR CLICK INSIDE ACTOR TO CHANGE SELECTION
            BaseActor a = scn.getActorAt(p.x, p.y);
            if (a != null && a != selActor) {
                selActor = a;
                BaseActor da = Ctx.project.getActor(selActor.getId());
                Ctx.project.setSelectedActor(da);
                return true;
            }
            // if (a != null) {
            // draggingMode = DraggingModes.DRAGGING_ACTOR;
            // undoOrg.set(selActor.getX(), selActor.getY());
            // return true;
            // }
            // CHECK FOR DRAGGING DEPTH MARKERS
            Vector2 depthVector = scnWidget.getScene().getDepthVector();
            if (depthVector != null) {
                p.set(0, depthVector.x);
                scnWidget.worldToScreenCoords(p);
                if (Vector2.dst(p.x - 40, p.y, x, y) < 50) {
                    draggingMode = DraggingModes.DRAGGING_MARKER_0;
                    Vector2 dv = scnWidget.getScene().getDepthVector();
                    undoOrg.set(dv.x, dv.y);
                    return true;
                }
                p.set(0, depthVector.y);
                scnWidget.worldToScreenCoords(p);
                if (Vector2.dst(p.x - 40, p.y, x, y) < 50) {
                    draggingMode = DraggingModes.DRAGGING_MARKER_100;
                    Vector2 dv = scnWidget.getScene().getDepthVector();
                    undoOrg.set(dv.x, dv.y);
                    return true;
                }
            }
        }
        return true;
    }

    @Override
    public void touchDragged(InputEvent event, float x, float y, int pointer) {
        // EditorLogger.debug("Touch Dragged - X: " + Gdx.input.getX() + " Y: "
        // + Gdx.input.getY());
        super.touchDragged(event, x, y, pointer);
        if (Gdx.input.isButtonPressed(Buttons.LEFT)) {
            Scene scn = scnWidget.getScene();
            if (scn == null)
                return;
            Vector2 d = new Vector2(Gdx.input.getX(), Gdx.input.getY());
            scnWidget.screenToWorldCoords(d);
            float angle = d.angle(org);
            d.sub(org);
            org.add(d);
            if (draggingMode == DraggingModes.DRAGGING_ACTOR) {
                selActor.setPosition(selActor.getX() + d.x, selActor.getY() + d.y);
                Ctx.project.setModified(this, Project.POSITION_PROPERTY, null, selActor);
            } else if (draggingMode == DraggingModes.ROTATE_ACTOR) {
                if (selActor instanceof SpriteActor) {
                    SpriteActor sa = (SpriteActor) selActor;
                    sa.setRot(sa.getRot() - angle);
                    Ctx.project.setModified();
                }
            } else if (draggingMode == DraggingModes.SCALE_ACTOR) {
                if (selActor instanceof SpriteActor) {
                    SpriteActor sa = (SpriteActor) selActor;
                    float sx = (org.x - d.x) / org.x - 1;
                    float sy = (org.y - d.y) / org.y - 1;
                    sa.setScale(sa.getScaleX() + sx, sa.getScaleY() + sy);
                    Ctx.project.setModified();
                }
            } else if (draggingMode == DraggingModes.SCALE_LOCK_ACTOR) {
                if (selActor instanceof SpriteActor) {
                    SpriteActor sa = (SpriteActor) selActor;
                    float s = (org.x - d.x) / org.x - 1;
                    sa.setScale(sa.getScaleX() + s, sa.getScaleY() + s);
                    Ctx.project.setModified();
                }
            } else if (draggingMode == DraggingModes.DRAGGING_REFPOINT) {
                Vector2 refPoint = ((InteractiveActor) selActor).getRefPoint();
                refPoint.add(d.x, d.y);
                Ctx.project.setModified();
            } else if (draggingMode == DraggingModes.DRAGGING_BBOX_POINT) {
                Polygon poly = selActor.getBBox();
                float[] verts = poly.getVertices();
                verts[vertIndex] += d.x;
                verts[vertIndex + 1] += d.y;
                poly.dirty();
                Ctx.project.setModified();
            } else if (draggingMode == DraggingModes.DRAGGING_MARKER_0) {
                Vector2 depthVector = scnWidget.getScene().getDepthVector();
                depthVector.x += d.y;
                Ctx.project.setModified();
                updateFakeDepth();
            } else if (draggingMode == DraggingModes.DRAGGING_MARKER_100) {
                Vector2 depthVector = scnWidget.getScene().getDepthVector();
                depthVector.y += d.y;
                Ctx.project.setModified();
                updateFakeDepth();
            }
        } else if (Gdx.input.isButtonPressed(Buttons.RIGHT) || Gdx.input.isButtonPressed(Buttons.MIDDLE)) {
            Vector2 p = new Vector2(Gdx.input.getX(), Gdx.input.getY());
            scnWidget.screenToWorldCoords(p);
            p.sub(org);
            scnWidget.translate(p);
        }
    }

    private void updateFakeDepth() {
        Scene scn = scnWidget.getScene();
        for (BaseActor a : scn.getActors().values()) {
            if (a instanceof SpriteActor) {
                a.setPosition(a.getX(), a.getY());
            }
        }
    }

    @Override
    public boolean scrolled(InputEvent event, float x, float y, int amount) {
        super.scrolled(event, x, y, amount);
        // EditorLogger.debug("SCROLLED - X: " + x + " Y: " + y);
        scnWidget.zoom(amount);
        return true;
    }

    @Override
    public void touchUp(InputEvent event, float x, float y, int pointer, int button) {
        super.touchUp(event, x, y, pointer, button);
        // EditorLogger.debug("Touch Up - X: " + x + " Y: " + y);
        if (draggingMode == DraggingModes.DRAGGING_ACTOR) {
            Ctx.project.getUndoStack().add(new UndoPosition(selActor, new Vector2(undoOrg)));
        } else if (draggingMode == DraggingModes.ROTATE_ACTOR) {
            Ctx.project.getUndoStack().add(new UndoRotation((SpriteActor) selActor, undoRot));
        } else if (draggingMode == DraggingModes.SCALE_ACTOR || draggingMode == DraggingModes.SCALE_LOCK_ACTOR) {
            Ctx.project.getUndoStack().add(new UndoScale((SpriteActor) selActor, new Vector2(undoOrg)));
        } else if (draggingMode == DraggingModes.DRAGGING_REFPOINT) {
            Ctx.project.getUndoStack().add(new UndoRefPosition((InteractiveActor) selActor, new Vector2(undoOrg)));
        } else if (draggingMode == DraggingModes.DRAGGING_BBOX_POINT) {
            Ctx.project.getUndoStack().add(new UndoBboxPointPos(selActor, vertIndex, new Vector2(undoOrg)));
        } else if (draggingMode == DraggingModes.DRAGGING_MARKER_0 || draggingMode == DraggingModes.DRAGGING_MARKER_100) {
            Ctx.project.getUndoStack().add(new UndoDepthVector(scnWidget.getScene(), new Vector2(undoOrg)));
        }
        draggingMode = DraggingModes.NONE;
        return;
    }

    @Override
    public boolean keyUp(InputEvent event, int keycode) {
        switch(keycode) {
            case Keys.UP:
            case Keys.DOWN:
            case Keys.LEFT:
            case Keys.RIGHT:
                Ctx.project.getUndoStack().add(new UndoPosition(selActor, new Vector2(undoOrg)));
        }
        return false;
    }

    @Override
    public boolean keyDown(InputEvent event, int keycode) {
        super.keyDown(event, keycode);
        Polygon p = null;
        if (scnWidget.getStage() == null || scnWidget.getStage().getKeyboardFocus() != scnWidget)
            return false;
        switch(keycode) {
            case Keys.ENTER:
                break;
            case Keys.BACKSPACE:
                break;
            case Keys.Z:
                if (UIUtils.ctrl()) {
                    Ctx.project.getUndoStack().undo();
                }
                break;
            case Keys.FORWARD_DEL:
                BaseActor a = Ctx.project.getSelectedActor();
                if (a == null)
                    return false;
                Ctx.project.getUndoStack().add(new UndoDeleteActor(Ctx.project.getSelectedScene(), a));
                Ctx.project.getSelectedScene().removeActor(a);
                Ctx.project.setModified(this, Project.NOTIFY_ELEMENT_DELETED, null, a);
                break;
            case Keys.S:
                if (UIUtils.ctrl()) {
                    try {
                        Ctx.project.saveProject();
                    } catch (IOException e1) {
                        String msg = "Something went wrong while saving the actor.\n\n" + e1.getClreplaced().getSimpleName() + " - " + e1.getMessage();
                        Message.showMsgDialog(scnWidget.getStage(), "Error", msg);
                        EditorLogger.printStackTrace(e1);
                    }
                }
                break;
            case Keys.UP:
            case Keys.DOWN:
            case Keys.LEFT:
            case Keys.RIGHT:
                selActor = scnWidget.getSelectedActor();
                p = selActor.getBBox();
                undoOrg.set(p.getX(), p.getY());
                Ctx.project.setModified(this, Project.POSITION_PROPERTY, null, selActor);
                break;
            case Keys.PLUS:
            case 70:
                scnWidget.zoom(-1);
                break;
            case Keys.MINUS:
                scnWidget.zoom(1);
                break;
        }
        return false;
    }

    @Override
    public void enter(InputEvent event, float x, float y, int pointer, com.badlogic.gdx.scenes.scene2d.Actor fromActor) {
        super.enter(event, x, y, pointer, fromActor);
        // EditorLogger.debug("ENTER - X: " + x + " Y: " + y);
        scnWidget.getStage().setScrollFocus(scnWidget);
    }
}

19 View Complete Implementation : ScnWidgetInputListener.java
Copyright Apache License 2.0
Author : bladecoder
private void updateFakeDepth() {
    Scene scn = scnWidget.getScene();
    for (BaseActor a : scn.getActors().values()) {
        if (a instanceof SpriteActor) {
            a.setPosition(a.getX(), a.getY());
        }
    }
}

19 View Complete Implementation : UndoDeleteActor.java
Copyright Apache License 2.0
Author : bladecoder
public clreplaced UndoDeleteActor implements UndoOp {

    private BaseActor a;

    private Scene s;

    public UndoDeleteActor(Scene s, BaseActor a) {
        this.s = s;
        this.a = a;
    }

    @Override
    public void undo() {
        s.addActor(a);
        Ctx.project.setModified(this, Project.NOTIFY_ELEMENT_CREATED, null, a);
    }
}

19 View Complete Implementation : ScnWidget.java
Copyright Apache License 2.0
Author : bladecoder
public void setSelectedActor(BaseActor actor) {
    BaseActor a = null;
    if (scn != null && actor != null) {
        a = actor;
    }
    selectedActor = a;
    // faRenderer.setActor(a);
    setAnimationRenderer(null, null);
}

19 View Complete Implementation : ActorList.java
Copyright Apache License 2.0
Author : bladecoder
@Override
protected EditModelDialog<Scene, BaseActor> getEditElementDialogInstance(BaseActor a) {
    return new EditActorDialog(skin, parent, a);
}

19 View Complete Implementation : ActorList.java
Copyright Apache License 2.0
Author : bladecoder
private void setPlayer() {
    int pos = list.getSelectedIndex();
    if (pos == -1)
        return;
    BaseActor a = list.gereplacedems().get(pos);
    if (a instanceof CharacterActor) {
        Ctx.project.getSelectedScene().setPlayer((CharacterActor) a);
        Ctx.project.setModified();
    }
}

19 View Complete Implementation : UndoBboxPointPos.java
Copyright Apache License 2.0
Author : bladecoder
public clreplaced UndoBboxPointPos implements UndoOp {

    private BaseActor a;

    private Vector2 pos;

    private int i;

    public UndoBboxPointPos(BaseActor a, int i, Vector2 pos) {
        this.pos = pos;
        this.a = a;
        this.i = i;
    }

    @Override
    public void undo() {
        float[] verts = a.getBBox().getVertices();
        verts[i] = pos.x;
        verts[i + 1] = pos.y;
        a.getBBox().dirty();
        Ctx.project.setModified();
    }
}

19 View Complete Implementation : Project.java
Copyright Apache License 2.0
Author : bladecoder
public void setSelectedActor(BaseActor a) {
    BaseActor old = null;
    old = selectedActor;
    selectedActor = a;
    selectedFA = null;
    firePropertyChange(NOTIFY_ACTOR_SELECTED, old, selectedActor);
}

19 View Complete Implementation : ActorList.java
Copyright Apache License 2.0
Author : bladecoder
@Override
protected void delete() {
    BaseActor a = removeSelected();
    parent.removeActor(a);
    // delete player attr if the actor to delete is the player
    if (parent.getPlayer() == a) {
        parent.setPlayer(null);
    }
    if (a.getId().equals(parent.getWalkZone())) {
        parent.setWalkZone(null);
    }
    // TRANSLATIONS
    Ctx.project.getI18N().putTranslationsInElement(a);
    // UNDO
    Ctx.project.getUndoStack().add(new UndoDeleteActor(parent, a));
    Ctx.project.setModified();
}

19 View Complete Implementation : UndoPosition.java
Copyright Apache License 2.0
Author : bladecoder
public clreplaced UndoPosition implements UndoOp {

    private BaseActor a;

    private Vector2 pos;

    public UndoPosition(BaseActor a, Vector2 pos) {
        this.pos = pos;
        this.a = a;
    }

    @Override
    public void undo() {
        a.setPosition(pos.x, pos.y);
        Ctx.project.setModified(this, Project.POSITION_PROPERTY, null, a);
    }
}

19 View Complete Implementation : ScnWidget.java
Copyright Apache License 2.0
Author : bladecoder
public clreplaced ScnWidget extends Widget {

    private static final Color BLACK_TRANSPARENT = new Color(0f, 0f, 0f, 0.5f);

    // TMPs to avoid GC calls
    private final Vector3 tmpV3 = new Vector3();

    private final Vector2 tmpV2 = new Vector2();

    private final Vector2 tmp2V2 = new Vector2();

    private final Vector3 tmpV3Draw = new Vector3();

    private final Vector2 tmpV2Transform = new Vector2();

    private final SpriteBatch sceneBatch = new SpriteBatch();

    private final CanvasDrawer drawer = new CanvasDrawer();

    private final AnimationDrawer faRenderer = new AnimationDrawer();

    private final ScnWidgetInputListener inputListner = new ScnWidgetInputListener(this);

    private final Rectangle bounds = new Rectangle();

    private final Rectangle scissors = new Rectangle();

    private Scene scn;

    private BaseActor selectedActor = null;

    private boolean inScene = false;

    private boolean animation = true;

    private static final int[] zoomLevels = { 5, 10, 16, 25, 33, 50, 66, 100, 150, 200, 300, 400, 600, 800, 1000 };

    private int zoomLevel = 100;

    private BitmapFont bigFont;

    private BitmapFont defaultFont;

    private TiledDrawable tile;

    private Drawable background;

    private boolean loading = false;

    private boolean loadingError = false;

    private boolean showSpriteBounds = true;

    private final GlyphLayout textLayout = new GlyphLayout();

    private final OrthographicCamera camera = new OrthographicCamera();

    private final TextureRegion scnMoveIcon;

    private final TextureRegion scnRotateIcon;

    private final TextureRegion scnScaleLockIcon;

    private final TextureRegion scnScaleIcon;

    /**
     * The NOTIFY_PROJECT_LOADED listener is called from other thread. This flag is
     * to recreate the scene in the OpenGL thread.
     */
    private boolean projectLoadedFlag = false;

    public ScnWidget(Skin skin) {
        bigFont = skin.get("big-font", BitmapFont.clreplaced);
        defaultFont = skin.get("default-font", BitmapFont.clreplaced);
        setSize(150, 150);
        tile = new TiledDrawable(Ctx.replacedetManager.getIcon("transparent-light"));
        background = skin.getDrawable("background");
        faRenderer.setViewport(getWidth(), getHeight());
        setLayoutEnabled(true);
        addListener(inputListner);
        Ctx.project.addPropertyChangeListener(new PropertyChangeListener() {

            @Override
            public void propertyChange(PropertyChangeEvent e) {
                EditorLogger.debug("ScnWidget Listener: " + e.getPropertyName());
                if (e.getPropertyName().equals(Project.NOTIFY_SCENE_SELECTED)) {
                    if (!projectLoadedFlag)
                        setSelectedScene(Ctx.project.getSelectedScene());
                } else if (e.getPropertyName().equals(Project.NOTIFY_ACTOR_SELECTED)) {
                    if (!projectLoadedFlag)
                        setSelectedActor(Ctx.project.getSelectedActor());
                } else if (e.getPropertyName().equals(Project.NOTIFY_ANIM_SELECTED)) {
                    if (!projectLoadedFlag && Ctx.project.getSelectedFA() != null)
                        setSelectedFA(Ctx.project.getSelectedFA());
                } else if (e.getPropertyName().equals(Project.NOTIFY_PROJECT_LOADED)) {
                    projectLoadedFlag = true;
                } else if (e.getPropertyName().equals("scene")) {
                    setSelectedScene(Ctx.project.getSelectedScene());
                    setSelectedActor(Ctx.project.getSelectedActor());
                } else if (e.getPropertyName().equals("init_animation")) {
                    if (!inScene)
                        setSelectedFA(null);
                }
            }
        });
        showSpriteBounds = Boolean.parseBoolean(Ctx.project.getEditorConfig().getProperty("view.showSpriteBounds", "true"));
        inScene = Boolean.parseBoolean(Ctx.project.getEditorConfig().getProperty("view.inScene", "false"));
        animation = Boolean.parseBoolean(Ctx.project.getEditorConfig().getProperty("view.animation", "true"));
        scnMoveIcon = Ctx.replacedetManager.getIcon("scn_move");
        scnRotateIcon = Ctx.replacedetManager.getIcon("scn_rotate");
        scnScaleLockIcon = Ctx.replacedetManager.getIcon("scn_scale_lock");
        scnScaleIcon = Ctx.replacedetManager.getIcon("scn_scale");
    }

    public OrthographicCamera getCamera() {
        return camera;
    }

    @Override
    public void act(float delta) {
        if (projectLoadedFlag) {
            projectLoadedFlag = false;
            if (scn != null) {
                scn.dispose();
                scn = null;
            }
            setSelectedScene(Ctx.project.getSelectedScene());
            setSelectedActor(Ctx.project.getSelectedActor());
            setSelectedFA(Ctx.project.getSelectedFA());
        }
        if (scn != null && !loading && !loadingError) {
            if (!inScene)
                faRenderer.update(delta);
            // scn.update(delta);
            for (SceneLayer layer : scn.getLayers()) layer.update();
            if (animation) {
                for (BaseActor a : scn.getActors().values()) {
                    boolean v = a.isVisible();
                    a.setVisible(true);
                    a.update(delta);
                    a.setVisible(v);
                }
            }
            handleKeyPositioning();
        }
    }

    private void handleKeyPositioning() {
        if (getStage() == null || getStage().getKeyboardFocus() != this)
            return;
        if (Gdx.input.isKeyPressed(Keys.UP) || Gdx.input.isKeyPressed(Keys.DOWN) || Gdx.input.isKeyPressed(Keys.LEFT) || Gdx.input.isKeyPressed(Keys.RIGHT)) {
            BaseActor selActor = getSelectedActor();
            if (selActor == null)
                return;
            if (Gdx.input.isKeyPressed(Keys.UP))
                // p.translate(0, 1);
                selActor.setPosition(selActor.getX(), selActor.getY() + 1);
            else if (Gdx.input.isKeyPressed(Keys.DOWN))
                // p.translate(0, -1);
                selActor.setPosition(selActor.getX(), selActor.getY() - 1);
            else if (Gdx.input.isKeyPressed(Keys.LEFT))
                // p.translate(-1, 0);
                selActor.setPosition(selActor.getX() - 1, selActor.getY());
            else if (Gdx.input.isKeyPressed(Keys.RIGHT))
                // p.translate(1, 0);
                selActor.setPosition(selActor.getX() + 1, selActor.getY());
        }
    }

    @Override
    public void draw(Batch batch, float parentAlpha) {
        validate();
        float tmp = batch.getPackedColor();
        batch.setColor(Color.WHITE);
        if (scn != null && !loading && !loadingError) {
            // BACKGROUND
            batch.disableBlending();
            tile.draw(batch, getX(), getY(), getWidth(), getHeight());
            batch.enableBlending();
            Vector3 v = tmpV3Draw.set(getX(), getY(), 0);
            v = v.prj(batch.getTransformMatrix());
            batch.end();
            HdpiUtils.glViewport((int) v.x, (int) v.y, (int) getWidth(), (int) (getHeight()));
            getStage().calculateScissors(bounds, scissors);
            if (ScissorStack.pushScissors(scissors)) {
                // WORLD CAMERA
                sceneBatch.setProjectionMatrix(camera.combined);
                sceneBatch.begin();
                Array<AtlasRegion> scnBackground = scn.getBackground();
                if (scnBackground != null) {
                    sceneBatch.disableBlending();
                    float x = 0;
                    for (AtlasRegion tile : scnBackground) {
                        sceneBatch.draw(tile, x, 0f);
                        x += tile.getRegionWidth();
                    }
                    sceneBatch.enableBlending();
                }
                // draw layers from bottom to top
                List<SceneLayer> layers = scn.getLayers();
                for (int i = layers.size() - 1; i >= 0; i--) {
                    SceneLayer layer = layers.get(i);
                    if (!layer.isVisible())
                        continue;
                    List<InteractiveActor> actors = layer.getActors();
                    for (InteractiveActor a : actors) {
                        if (a instanceof SpriteActor) {
                            boolean visibility = a.isVisible();
                            a.setVisible(true);
                            ((SpriteActor) a).draw(sceneBatch);
                            a.setVisible(visibility);
                        }
                    }
                }
                sceneBatch.end();
                ScissorStack.popScissors();
            }
            drawer.drawBGBounds();
            drawer.drawBBoxActors(scn, showSpriteBounds);
            if (selectedActor != null) {
                drawer.drawSelectedActor(selectedActor);
            }
            getStage().getViewport().apply();
            // SCREEN CAMERA
            batch.begin();
            drawFakeDepthMarkers((SpriteBatch) batch);
            if (!inScene) {
                faRenderer.draw((SpriteBatch) batch);
            }
            // DRAW selected actor ICONS
            if (selectedActor != null) {
                drawTransformIcons((SpriteBatch) batch, selectedActor);
            }
            // DRAW COORDS
            Vector2 coords = tmpV2Transform.set(Gdx.input.getX(), Gdx.input.getY());
            screenToWorldCoords(coords);
            String str = MessageFormat.format("({0}, {1})", (int) coords.x, (int) coords.y);
            textLayout.setText(defaultFont, str);
            RectangleRenderer.draw(batch, 0f, getY() + getHeight() - textLayout.height - 15, textLayout.width + 10, textLayout.height + 10, BLACK_TRANSPARENT);
            defaultFont.draw(batch, textLayout, 5, getHeight() + getY() - 10);
            batch.setPackedColor(tmp);
        } else {
            background.draw(batch, getX(), getY(), getWidth(), getHeight());
            String s;
            if (loading) {
                s = "LOADING...";
                Timer.post(new Task() {

                    @Override
                    public void run() {
                        loading = false;
                        try {
                            EnginereplacedetManager.getInstance().finishLoading();
                            scn.retrievereplacedets();
                            // disable Spine events
                            for (BaseActor a : scn.getActors().values()) {
                                if (a instanceof SpriteActor && ((SpriteActor) a).getRenderer() instanceof SpineRenderer) {
                                    ((SpineRenderer) ((SpriteActor) a).getRenderer()).enableEvents(false);
                                }
                            }
                            drawer.setCamera(camera);
                            invalidate();
                        } catch (Exception e) {
                            Message.showMsg(getStage(), "Could not load replacedets for scene", 4);
                            EditorLogger.printStackTrace(e);
                            loadingError = true;
                            loading = false;
                        }
                    }
                });
            } else if (loadingError) {
                s = "ERROR IN SCENE DATA. CANNOT DISPLAY SCENE";
            } else if (!Ctx.project.isLoaded()) {
                s = "CREATE OR LOAD A PROJECT";
            } else {
                s = "THERE ARE NO SCENES IN THIS CHAPTER YET";
            }
            textLayout.setText(bigFont, s);
            bigFont.draw(batch, textLayout, (getWidth() - textLayout.width) / 2, getHeight() / 2 + bigFont.getLineHeight() * 3);
        }
    }

    private void drawTransformIcons(SpriteBatch batch, BaseActor a) {
        Polygon p = a.getBBox();
        if (!(a instanceof AnchorActor)) {
            if (a instanceof InteractiveActor) {
                InteractiveActor ia = (InteractiveActor) a;
                if (!scn.getLayer(ia.getLayer()).isVisible())
                    return;
            }
            Rectangle r = p.getBoundingRectangle();
            worldToScreenCoords(tmpV2Transform.set(r.x, r.y));
            float x = tmpV2Transform.x;
            float y = tmpV2Transform.y;
            worldToScreenCoords(tmpV2Transform.set(r.x + r.width, r.y + r.height));
            float x2 = tmpV2Transform.x;
            float y2 = tmpV2Transform.y;
            batch.draw(scnMoveIcon, x + (x2 - x - scnMoveIcon.getRegionWidth()) / 2, y2);
            if (a instanceof SpriteActor) {
                batch.draw(scnRotateIcon, x2 - scnRotateIcon.getRegionWidth() / 3, y2 - scnRotateIcon.getRegionHeight() / 3);
                if (!((SpriteActor) a).getFakeDepth()) {
                    batch.draw(scnScaleLockIcon, x - scnScaleLockIcon.getRegionWidth(), y2);
                    batch.draw(scnScaleIcon, x - scnScaleIcon.getRegionWidth(), y - scnScaleIcon.getRegionHeight());
                }
            }
        }
    }

    public boolean inTransformIcon(float px, float py, DraggingModes dm) {
        Polygon p = selectedActor.getBBox();
        Rectangle r = p.getBoundingRectangle();
        worldToScreenCoords(tmpV2Transform.set(r.x, r.y));
        float x = tmpV2Transform.x;
        float y = tmpV2Transform.y;
        worldToScreenCoords(tmpV2Transform.set(r.x + r.width, r.y + r.height));
        float x2 = tmpV2Transform.x;
        float y2 = tmpV2Transform.y;
        Rectangle r2 = null;
        if (dm == DraggingModes.ROTATE_ACTOR) {
            r2 = new Rectangle(x2 - scnRotateIcon.getRegionWidth() / 3, y2 - scnRotateIcon.getRegionHeight() / 3, scnRotateIcon.getRegionWidth(), scnRotateIcon.getRegionHeight());
        } else if (dm == DraggingModes.SCALE_ACTOR) {
            r2 = new Rectangle(x - scnScaleIcon.getRegionWidth(), y - scnScaleIcon.getRegionHeight(), scnScaleIcon.getRegionWidth(), scnScaleIcon.getRegionHeight());
        } else if (dm == DraggingModes.SCALE_LOCK_ACTOR) {
            r2 = new Rectangle(x - scnScaleLockIcon.getRegionWidth(), y2, scnScaleLockIcon.getRegionWidth(), scnScaleLockIcon.getRegionHeight());
        } else if (dm == DraggingModes.DRAGGING_ACTOR) {
            r2 = new Rectangle(x + (x2 - x - scnMoveIcon.getRegionWidth()) / 2, y2, scnMoveIcon.getRegionWidth(), scnMoveIcon.getRegionHeight());
        }
        worldToScreenCoords(tmpV2Transform.set(px, py));
        return r2.contains(tmpV2Transform.x, tmpV2Transform.y);
    }

    private void drawFakeDepthMarkers(SpriteBatch batch) {
        int margin = 5;
        Vector2 d = scn.getDepthVector();
        if (d == null)
            return;
        tmp2V2.x = 0;
        tmp2V2.y = d.y;
        worldToScreenCoords(tmp2V2);
        String s = "100%";
        textLayout.setText(defaultFont, s);
        float posx = tmp2V2.x - textLayout.width - 20;
        RectangleRenderer.draw(batch, posx, tmp2V2.y, textLayout.width + margin * 2, textLayout.height + margin * 2, Color.BLACK);
        RectangleRenderer.draw(batch, tmp2V2.x - 20, tmp2V2.y, 20, 2, Color.BLACK);
        defaultFont.draw(batch, textLayout, posx + margin, tmp2V2.y + textLayout.height + margin);
        tmp2V2.x = 0;
        tmp2V2.y = d.x;
        worldToScreenCoords(tmp2V2);
        s = "0%";
        textLayout.setText(defaultFont, s);
        posx = tmp2V2.x - textLayout.width - 20;
        RectangleRenderer.draw(batch, posx, tmp2V2.y, textLayout.width + margin * 2, textLayout.height + margin * 2, Color.BLACK);
        RectangleRenderer.draw(batch, tmp2V2.x - 20, tmp2V2.y, 20, 2, Color.BLACK);
        defaultFont.draw(batch, textLayout, posx + margin, tmp2V2.y + textLayout.height + margin);
    }

    public void setInSceneSprites(boolean v) {
        inScene = v;
        Ctx.project.getEditorConfig().setProperty("view.inScene", Boolean.toString(inScene));
        if (!inScene)
            setSelectedFA(null);
    }

    public boolean getInSceneSprites() {
        return inScene;
    }

    public void setAnimation(boolean v) {
        animation = v;
        Ctx.project.getEditorConfig().setProperty("view.animation", Boolean.toString(animation));
    }

    public boolean getAnimation() {
        return animation;
    }

    public void setAnimationRenderer(BaseActor a, AnimationDesc fa) {
        try {
            faRenderer.setActor(a);
            faRenderer.setAnimation(fa);
        } catch (Exception e) {
            Message.showMsg(getStage(), "Could not retrieve replacedets for sprite: " + fa.id, 4);
            EditorLogger.printStackTrace(e);
            faRenderer.setAnimation(null);
        }
    }

    public boolean getShowSpriteBounds() {
        return showSpriteBounds;
    }

    public void setShowSpriteBounds(boolean v) {
        showSpriteBounds = v;
        Ctx.project.getEditorConfig().setProperty("view.showSpriteBounds", Boolean.toString(showSpriteBounds));
    }

    @Override
    public void layout() {
        // EditorLogger.debug("LAYOUT SIZE CHANGED - X: " + getX() + " Y: "
        // + getY() + " Width: " + getWidth() + " Height: " + getHeight());
        // EditorLogger.debug("Last Point coords - X: " + (getX() + getWidth())
        // + " Y: " + (getY() + getHeight()));
        localToScreenCoords(tmpV2.set(getX() + getWidth(), getY() + getHeight()));
        // EditorLogger.debug("Screen Last Point coords: " + tmpV2);
        faRenderer.setViewport(getWidth(), getHeight());
        bounds.set(getX(), getY(), getWidth(), getHeight());
        // SETS WORLD CAMERA
        if (scn != null) {
            float aspect = getWidth() / getHeight();
            float wWidth = Ctx.project.getWorld().getWidth();
            float wHeight = Ctx.project.getWorld().getHeight();
            float aspectWorld = wWidth / wHeight;
            if (aspectWorld > aspect) {
                wHeight = wWidth / aspect;
            } else {
                wWidth = wHeight * aspect;
            }
            zoomLevel = 100;
            camera.setToOrtho(false, wWidth, wHeight);
            camera.zoom = 1f;
            camera.position.set(Ctx.project.getWorld().getWidth() / 2, Ctx.project.getWorld().getHeight() / 2, 0);
            camera.update();
            zoom(+1);
        }
    }

    public void zoom(int amount) {
        if (zoomLevel == zoomLevels[0] && amount < 0) {
            zoomLevel = zoomLevels[1];
        } else if (zoomLevel == zoomLevels[zoomLevels.length - 1] && amount > 0) {
            zoomLevel = zoomLevels[zoomLevels.length - 2];
        } else {
            for (int i = 1; i < zoomLevels.length - 1; i++) {
                if (zoomLevels[i] == zoomLevel) {
                    zoomLevel = amount > 0 ? zoomLevels[i - 1] : zoomLevels[i + 1];
                    break;
                }
            }
        }
        if (scn != null) {
            camera.zoom = 100f / zoomLevel;
            camera.update();
        }
    }

    public void translate(Vector2 delta) {
        // EditorLogger.debug("TRANSLATING - X: " + delta.x + " Y: " + delta.y);
        if (scn != null) {
            camera.translate(-delta.x, -delta.y, 0);
            camera.update();
        }
    }

    public void localToScreenCoords(Vector2 coords) {
        localToStageCoordinates(coords);
        getStage().stageToScreenCoordinates(coords);
    }

    public void localToWorldCoords(Vector2 coords) {
        localToStageCoordinates(coords);
        getStage().stageToScreenCoordinates(coords);
        tmpV3.set(coords.x, coords.y, 0);
        camera.unproject(tmpV3, getX(), getY(), getWidth(), getHeight());
        coords.set(tmpV3.x, tmpV3.y);
    }

    public void screenToWorldCoords(Vector2 coords) {
        tmpV2.set(0, 0);
        localToStageCoordinates(tmpV2);
        // getStage().stageToScreenCoordinates(tmpV2);
        tmpV3.set(coords.x, coords.y, 0);
        camera.unproject(tmpV3, tmpV2.x, tmpV2.y, getWidth(), getHeight());
        coords.set(tmpV3.x, tmpV3.y);
    }

    public void worldToScreenCoords(Vector2 coords) {
        tmpV2.set(getX(), getY());
        localToStageCoordinates(tmpV2);
        tmpV3.set(coords.x, coords.y, 0);
        camera.project(tmpV3, tmpV2.x, tmpV2.y, getWidth(), getHeight());
        coords.set(tmpV3.x, tmpV3.y);
        stageToLocalCoordinates(coords);
    }

    public boolean inScaleIcon(float px, float py) {
        Polygon p = selectedActor.getBBox();
        if (selectedActor instanceof SpriteActor) {
            InteractiveActor ia = (InteractiveActor) selectedActor;
            if (!scn.getLayer(ia.getLayer()).isVisible())
                return false;
            Rectangle r = p.getBoundingRectangle();
            worldToScreenCoords(tmpV2Transform.set(r.x + r.width, r.y + r.height));
            float x = tmpV2Transform.x;
            float y = tmpV2Transform.y;
            Rectangle r2 = new Rectangle(x - scnMoveIcon.getRegionWidth() / 2, y, scnMoveIcon.getRegionWidth(), scnMoveIcon.getRegionHeight());
            worldToScreenCoords(tmpV2Transform.set(px, py));
            return r2.contains(tmpV2Transform.x, tmpV2Transform.y);
        }
        return false;
    }

    public Scene getScene() {
        return scn;
    }

    public BaseActor getSelectedActor() {
        return selectedActor;
    }

    public void setSelectedScene(Scene s) {
        if (scn != null) {
            scn.dispose();
            faRenderer.dispose();
            scn = null;
            EnginereplacedetManager.getInstance().clear();
        }
        loadingError = false;
        setSelectedActor(null);
        if (s != null) {
            scn = s;
            scn.loadreplacedets();
            loading = true;
        }
        // SETS WORLD CAMERA
        if (scn != null) {
            float aspect = getWidth() / getHeight();
            float wWidth = Ctx.project.getWorld().getWidth();
            float wHeight = Ctx.project.getWorld().getHeight();
            float aspectWorld = wWidth / wHeight;
            if (aspectWorld > aspect) {
                wHeight = wWidth / aspect;
            } else {
                wWidth = wHeight * aspect;
            }
            zoomLevel = 100;
            camera.setToOrtho(false, wWidth, wHeight);
            camera.zoom = 1f;
            camera.update();
            // translate(new Vector2((-getWidth() + wWidth ) / 2 *
            // camera.zoom,
            // (-getHeight() + wHeight) / 2 * camera.zoom));
            translate(new Vector2(0, (-getHeight() + wHeight) / 2));
        }
    }

    public void setSelectedActor(BaseActor actor) {
        BaseActor a = null;
        if (scn != null && actor != null) {
            a = actor;
        }
        selectedActor = a;
        // faRenderer.setActor(a);
        setAnimationRenderer(null, null);
    }

    public void setSelectedFA(String selFA) {
        if (selectedActor instanceof SpriteActor && ((SpriteActor) selectedActor).getRenderer() instanceof AnimationRenderer) {
            AnimationRenderer s = (AnimationRenderer) ((SpriteActor) selectedActor).getRenderer();
            if (selFA == null || (s.getAnimations().get(selFA) == null && s.getAnimations().get(AnimationRenderer.getFlipId(selFA)) == null)) {
                selFA = s.getInitAnimation();
            }
            if (selFA != null && (s.getAnimations().get(selFA) != null || s.getAnimations().get(AnimationRenderer.getFlipId(selFA)) != null)) {
                setAnimationRenderer(selectedActor, s.getAnimations().get(selFA));
                String animInScene = selFA;
                if (!inScene && s.getInitAnimation() != null)
                    animInScene = s.getInitAnimation();
                try {
                    ((SpriteActor) selectedActor).startAnimation(animInScene, Tween.Type.REPEAT, Tween.INFINITY, null);
                } catch (Exception e) {
                    setAnimationRenderer(selectedActor, null);
                    s.getAnimations().remove(selFA);
                }
            } else {
                setAnimationRenderer(selectedActor, null);
            }
        } else {
            setAnimationRenderer(selectedActor, null);
        }
    }

    public void dispose() {
        if (scn != null) {
            scn.dispose();
            scn = null;
        }
        faRenderer.dispose();
    }
}

19 View Complete Implementation : ActorList.java
Copyright Apache License 2.0
Author : bladecoder
@Override
protected void copy() {
    BaseActor e = list.getSelected();
    if (e == null)
        return;
    clipboard = (BaseActor) ElementUtils.cloneElement(e);
    toolbar.disablePaste(false);
    // TRANSLATIONS
    Ctx.project.getI18N().putTranslationsInElement(clipboard);
}

19 View Complete Implementation : PolygonalNavGraph.java
Copyright Apache License 2.0
Author : bladecoder
public void createInitialGraph(BaseActor wz, Collection<BaseActor> actors) {
    graphNodes.clear();
    if (wz == null) {
        walkZone = null;
        return;
    }
    walkZone = wz.getBBox();
    // 1.- Add WalkZone convex nodes
    float[] verts = walkZone.getTransformedVertices();
    for (int i = 0; i < verts.length; i += 2) {
        if (!PolygonUtils.isVertexConcave(walkZone, i)) {
            graphNodes.add(new NavNodePolygonal(verts[i], verts[i + 1]));
        }
    }
    // 2.- Add obstacles concave nodes
    obstacles.clear();
    for (BaseActor a : actors) {
        if (a instanceof ObstacleActor && a.isVisible())
            obstacles.add(a.getBBox());
    }
    for (Polygon o : obstacles) {
        verts = o.getTransformedVertices();
        for (int i = 0; i < verts.length; i += 2) {
            if (PolygonUtils.isVertexConcave(o, i) && PolygonUtils.isPointInside(walkZone, verts[i], verts[i + 1], false)) {
                graphNodes.add(new NavNodePolygonal(verts[i], verts[i + 1]));
            }
        }
    }
    // 3.- CALC LINE OF SIGHTs
    for (int i = 0; i < graphNodes.size() - 1; i++) {
        NavNodePolygonal n1 = graphNodes.get(i);
        for (int j = i + 1; j < graphNodes.size(); j++) {
            NavNodePolygonal n2 = graphNodes.get(j);
            if (inLineOfSight(n1.x, n1.y, n2.x, n2.y)) {
                n1.neighbors.add(n2);
                n2.neighbors.add(n1);
            }
        }
    }
}

18 View Complete Implementation : ActionCallbackSerializer.java
Copyright Apache License 2.0
Author : bladecoder
/**
 * Generates a String for serialization that allows locate the ActionCallback
 *
 * @param cb The ActionCallback to serialize
 * @return The generated location string
 */
public static String find(World w, Scene s, ActionCallback cb) {
    String id = null;
    if (cb == null)
        return null;
    // search in UIActors
    id = find(cb, w.getUIActors());
    if (id != null)
        return id;
    // search in inventory
    id = find(cb, w.getInventory());
    if (id != null)
        return id;
    // search in inkManager actions
    id = find(cb, w.getInkManager().getVerbRunner());
    if (id != null)
        return id;
    // search in scene verbs
    id = find(cb, s);
    if (id != null)
        return id;
    // search in player
    id = find(cb, s.getPlayer());
    if (id != null)
        return id;
    // search in actors
    for (BaseActor a : s.getActors().values()) {
        if (!(a instanceof InteractiveActor))
            continue;
        id = find(cb, (InteractiveActor) a);
        if (id != null)
            return id;
    }
    // search in worldVerbs
    for (Verb v : w.getVerbManager().getVerbs().values()) {
        id = find(cb, v);
        if (id != null) {
            StringBuilder stringBuilder = new StringBuilder(DEFAULT_VERB_TAG);
            stringBuilder.append(SEPARATION_SYMBOL).append(id);
            return stringBuilder.toString();
        }
    }
    return null;
}

18 View Complete Implementation : CheckInteractionVerbs.java
Copyright Apache License 2.0
Author : bladecoder
@Override
public void visit(BaseActor a) {
    if (a instanceof InteractiveActor) {
        ia = (InteractiveActor) a;
        hasLookat = false;
        hasPickup = false;
        hasTalkto = false;
        hasLeave = false;
        hasEnterExit = false;
        hasUse = false;
        if (ia.getInteraction()) {
            HashMap<String, Verb> verbs = ia.getVerbManager().getVerbs();
            for (Verb v : verbs.values()) checkVerb(v);
            // TODO: check states and verbs for states.
            if (hasLeave || hasEnterExit)
                return;
            // discard inventory actors
            if (hasLookat) {
                if (ia instanceof SpriteActor) {
                    SpriteActor sa = (SpriteActor) ia;
                    if (sa.getRenderer() instanceof AtlasRenderer) {
                        AtlasRenderer r = (AtlasRenderer) sa.getRenderer();
                        HashMap<String, AnimationDesc> animations = r.getAnimations();
                        if (animations.size() == 0) {
                            EditorLogger.error("CheckInteractionVerbs: Actor with no animations! - " + sa.getScene().getId() + "." + sa.getId());
                        }
                        if (animations.get(r.getInitAnimation()).source.contains("inventory")) {
                            if (!hasUse)
                                EditorLogger.msg("CheckInteractionVerbs: Inventory item should has default 'use' - " + sa.getScene().getId() + "." + sa.getId());
                            return;
                        }
                    }
                }
            }
            // check for lookat and pickup/talk verbs
            if (!hasLookat || (!hasPickup && !hasTalkto)) {
                String msg = "CheckInteractionVerbs: " + a.getScene().getId() + "." + a.getId();
                if (!hasLookat)
                    EditorLogger.error(msg);
                else
                    EditorLogger.msg(msg);
            }
        }
    }
}

18 View Complete Implementation : AnimationDrawer.java
Copyright Apache License 2.0
Author : bladecoder
public void setActor(BaseActor a) {
    if (renderer != null) {
        renderer.dispose();
        renderer = null;
    }
    if (a instanceof SpriteActor && ((SpriteActor) a).getRenderer() instanceof AnimationRenderer) {
        ActorRenderer r = ((SpriteActor) a).getRenderer();
        if (r instanceof Sprite3DRenderer) {
            renderer = new Sprite3DRenderer();
            ((Sprite3DRenderer) renderer).setSpriteSize(new Vector2(r.getWidth(), r.getHeight()));
        } else if (r instanceof SpineRenderer) {
            renderer = new SpineRenderer();
            ((SpineRenderer) renderer).enableEvents(false);
            ((SpineRenderer) renderer).setSkin(((SpineRenderer) r).getSkin());
        } else if (r instanceof ImageRenderer) {
            renderer = new ImageRenderer();
        } else if (r instanceof AtlasRenderer) {
            renderer = new AtlasRenderer();
        }
        renderer.setOrgAlign(Align.bottom);
    }
}

18 View Complete Implementation : CanvasDrawer.java
Copyright Apache License 2.0
Author : bladecoder
public void drawSelectedActor(BaseActor selectedActor) {
    // Gdx.gl20.glLineWidth(3);
    Gdx.gl20.glEnable(GL20.GL_BLEND);
    // Gdx.gl20.glBlendFunc(GL20.GL_SRC_ALPHA, GL20.GL_ONE_MINUS_SRC_ALPHA);
    drawer.setProjectionMatrix(camera.combined);
    // drawer.setTransformMatrix(new Matrix4());
    if (selectedActor instanceof AnchorActor) {
        drawer.begin(ShapeRenderer.ShapeType.Line);
        drawer.setColor(MOUSESELECTION_STROKE_COLOR);
        drawer.rect(selectedActor.getX() - Scene.ANCHOR_RADIUS, selectedActor.getY() - Scene.ANCHOR_RADIUS, Scene.ANCHOR_RADIUS * 2, Scene.ANCHOR_RADIUS * 2);
        drawer.end();
    } else {
        Polygon p = selectedActor.getBBox();
        Rectangle rect = p.getBoundingRectangle();
        drawer.begin(ShapeRenderer.ShapeType.Filled);
        drawer.setColor(MOUSESELECTION_FILL_COLOR);
        drawer.rect(rect.x, rect.y, rect.width, rect.height);
        drawer.end();
        drawer.begin(ShapeRenderer.ShapeType.Line);
        drawer.setColor(MOUSESELECTION_STROKE_COLOR);
        drawer.rect(rect.x, rect.y, rect.width, rect.height);
        // DRAW SELECTION BOUNDS
        if ((!(selectedActor instanceof SpriteActor) || !((SpriteActor) selectedActor).isBboxFromRenderer()) && !(selectedActor instanceof AnchorActor)) {
            float[] verts = selectedActor.getBBox().getTransformedVertices();
            for (int i = 0; i < verts.length; i += 2) drawer.rect(verts[i] - CORNER_DIST / 2, verts[i + 1] - CORNER_DIST / 2, CORNER_DIST, CORNER_DIST);
        }
        // DRAW REFPOINT
        if (selectedActor instanceof InteractiveActor) {
            Vector2 refPoint = ((InteractiveActor) selectedActor).getRefPoint();
            float orgX = selectedActor.getX() + refPoint.x;
            float orgY = selectedActor.getY() + refPoint.y;
            drawer.line(orgX - Scene.ANCHOR_RADIUS, orgY, orgX + Scene.ANCHOR_RADIUS, orgY);
            drawer.line(orgX, orgY - Scene.ANCHOR_RADIUS, orgX, orgY + Scene.ANCHOR_RADIUS);
        }
        drawer.end();
    }
}

18 View Complete Implementation : ScnWidgetInputListener.java
Copyright Apache License 2.0
Author : bladecoder
@Override
public boolean touchDown(InputEvent event, float x, float y, int pointer, int button) {
    super.touchDown(event, x, y, pointer, button);
    // EditorLogger.debug("Touch Down - X: " + x + " Y: " + y);
    Scene scn = scnWidget.getScene();
    if (scn == null)
        return false;
    Vector2 p = new Vector2(Gdx.input.getX(), Gdx.input.getY());
    scnWidget.screenToWorldCoords(p);
    org.set(p);
    if (button == Buttons.LEFT) {
        selActor = scnWidget.getSelectedActor();
        if (selActor != null) {
            // ORIGIN DRAGGING
            if (selActor instanceof InteractiveActor) {
                Vector2 refPoint = ((InteractiveActor) selActor).getRefPoint();
                float orgX = selActor.getX() + refPoint.x;
                float orgY = selActor.getY() + refPoint.y;
                float dst = Vector2.dst(p.x, p.y, orgX, orgY);
                if (dst < Scene.ANCHOR_RADIUS) {
                    draggingMode = DraggingModes.DRAGGING_REFPOINT;
                    undoOrg.set(refPoint.x, refPoint.y);
                    return true;
                }
            }
            // VERTEXs DRAGGING
            if ((!(selActor instanceof SpriteActor) || !((SpriteActor) selActor).isBboxFromRenderer()) && !(scnWidget.getSelectedActor() instanceof AnchorActor)) {
                Polygon bbox = selActor.getBBox();
                float[] verts = bbox.getTransformedVertices();
                for (int i = 0; i < verts.length; i += 2) {
                    if (p.dst(verts[i], verts[i + 1]) < CanvasDrawer.CORNER_DIST) {
                        draggingMode = DraggingModes.DRAGGING_BBOX_POINT;
                        vertIndex = i;
                        float[] v = bbox.getVertices();
                        undoOrg.set(v[i], v[i + 1]);
                        return true;
                    }
                }
            }
            // CLICK IN MOVE ICON
            if (!(selActor instanceof AnchorActor) && scnWidget.inTransformIcon(p.x, p.y, DraggingModes.DRAGGING_ACTOR)) {
                draggingMode = DraggingModes.DRAGGING_ACTOR;
                undoOrg.set(selActor.getX(), selActor.getY());
                return true;
            }
            if (selActor instanceof AnchorActor) {
                float orgX = selActor.getX();
                float orgY = selActor.getY();
                float dst = Vector2.dst(p.x, p.y, orgX, orgY);
                if (dst < Scene.ANCHOR_RADIUS) {
                    draggingMode = DraggingModes.DRAGGING_ACTOR;
                    undoOrg.set(selActor.getX(), selActor.getY());
                    return true;
                }
            }
            // CHECK CLICK IN TRANSFORM ICON
            if (selActor instanceof SpriteActor) {
                if (scnWidget.inTransformIcon(p.x, p.y, DraggingModes.ROTATE_ACTOR)) {
                    draggingMode = DraggingModes.ROTATE_ACTOR;
                    undoRot = ((SpriteActor) selActor).getRot();
                    return true;
                }
                if (!((SpriteActor) selActor).getFakeDepth()) {
                    if (scnWidget.inTransformIcon(p.x, p.y, DraggingModes.SCALE_ACTOR)) {
                        draggingMode = DraggingModes.SCALE_ACTOR;
                        undoOrg.set(((SpriteActor) selActor).getScaleX(), ((SpriteActor) selActor).getScaleY());
                        return true;
                    }
                    if (scnWidget.inTransformIcon(p.x, p.y, DraggingModes.SCALE_LOCK_ACTOR)) {
                        draggingMode = DraggingModes.SCALE_LOCK_ACTOR;
                        undoOrg.set(((SpriteActor) selActor).getScaleX(), ((SpriteActor) selActor).getScaleY());
                        return true;
                    }
                }
            }
        }
        // CHECK FOR CLICK INSIDE ACTOR TO CHANGE SELECTION
        BaseActor a = scn.getActorAt(p.x, p.y);
        if (a != null && a != selActor) {
            selActor = a;
            BaseActor da = Ctx.project.getActor(selActor.getId());
            Ctx.project.setSelectedActor(da);
            return true;
        }
        // if (a != null) {
        // draggingMode = DraggingModes.DRAGGING_ACTOR;
        // undoOrg.set(selActor.getX(), selActor.getY());
        // return true;
        // }
        // CHECK FOR DRAGGING DEPTH MARKERS
        Vector2 depthVector = scnWidget.getScene().getDepthVector();
        if (depthVector != null) {
            p.set(0, depthVector.x);
            scnWidget.worldToScreenCoords(p);
            if (Vector2.dst(p.x - 40, p.y, x, y) < 50) {
                draggingMode = DraggingModes.DRAGGING_MARKER_0;
                Vector2 dv = scnWidget.getScene().getDepthVector();
                undoOrg.set(dv.x, dv.y);
                return true;
            }
            p.set(0, depthVector.y);
            scnWidget.worldToScreenCoords(p);
            if (Vector2.dst(p.x - 40, p.y, x, y) < 50) {
                draggingMode = DraggingModes.DRAGGING_MARKER_100;
                Vector2 dv = scnWidget.getScene().getDepthVector();
                undoOrg.set(dv.x, dv.y);
                return true;
            }
        }
    }
    return true;
}

18 View Complete Implementation : ActorList.java
Copyright Apache License 2.0
Author : bladecoder
@Override
protected void paste() {
    BaseActor newElement = (BaseActor) ElementUtils.cloneElement(clipboard);
    newElement.setId(ElementUtils.getCheckedId(newElement.getId(), parent.getActors().keySet().toArray(new String[0])));
    int pos = list.getSelectedIndex() + 1;
    list.gereplacedems().insert(pos, newElement);
    parent.addActor(newElement);
    Ctx.project.getI18N().extractStrings(parent.getId(), newElement);
    if (newElement instanceof SpriteActor) {
        SpriteActor ia = (SpriteActor) newElement;
        ia.loadreplacedets();
        EnginereplacedetManager.getInstance().finishLoading();
        ia.retrievereplacedets();
    }
    list.setSelectedIndex(pos);
    list.invalidateHierarchy();
    Ctx.project.setModified();
}

18 View Complete Implementation : ActorProps.java
Copyright Apache License 2.0
Author : bladecoder
public void setActorDoreplacedent(BaseActor a) {
    this.actor = a;
    clearProps();
    if (a != null) {
        addProperty(POS_X_PROP, Float.toString(actor.getX()), Types.FLOAT);
        addProperty(POS_Y_PROP, Float.toString(actor.getY()), Types.FLOAT);
        addProperty(VISIBLE_PROP, Boolean.toString(actor.isVisible()), Types.BOOLEAN);
        if (a instanceof InteractiveActor) {
            addProperty(DESC_PROP, ((InteractiveActor) actor).getDesc());
            addProperty(INTERACTION_PROP, Boolean.toString(((InteractiveActor) actor).getInteraction()), Types.BOOLEAN);
            addProperty(STATE_PROP, ((InteractiveActor) actor).getState());
        }
        if (a instanceof SpriteActor) {
            boolean v = ((SpriteActor) a).isBboxFromRenderer();
            addProperty(BBOX_FROM_RENDERER_PROP, Boolean.toString(v), Types.BOOLEAN);
        }
        Ctx.project.addPropertyChangeListener(propertyChangeListener);
        invalidateHierarchy();
    }
}

18 View Complete Implementation : ActorInputPanel.java
Copyright Apache License 2.0
Author : bladecoder
private static String[] getValues(boolean mandatory, Param.Type type) {
    ArrayList<BaseActor> filteredActors = new ArrayList<>();
    if (Ctx.project.getSelectedScene() != null) {
        Map<String, BaseActor> actors = Ctx.project.getSelectedScene().getActors();
        for (BaseActor a : actors.values()) {
            if (type == Param.Type.CHARACTER_ACTOR) {
                if (a instanceof CharacterActor)
                    filteredActors.add(a);
            } else if (type == Param.Type.INTERACTIVE_ACTOR) {
                if (a instanceof InteractiveActor)
                    filteredActors.add(a);
            } else if (type == Param.Type.WALKZONE_ACTOR) {
                if (a instanceof WalkZoneActor)
                    filteredActors.add(a);
            } else if (type == Param.Type.SPRITE_ACTOR) {
                if (a instanceof SpriteActor)
                    filteredActors.add(a);
            } else {
                filteredActors.add(a);
            }
        }
    }
    String[] result = null;
    if (type != Param.Type.WALKZONE_ACTOR) {
        // Add player variable to the list
        result = new String[filteredActors.size() + 1];
        result[0] = Scene.VAR_PLAYER;
        for (int i = 0; i < filteredActors.size(); i++) {
            result[i + 1] = filteredActors.get(i).getId();
        }
    } else {
        result = new String[filteredActors.size()];
        for (int i = 0; i < filteredActors.size(); i++) {
            result[i] = filteredActors.get(i).getId();
        }
    }
    Arrays.sort(result);
    return result;
}

18 View Complete Implementation : UndoCreateActor.java
Copyright Apache License 2.0
Author : bladecoder
public clreplaced UndoCreateActor implements UndoOp {

    private Scene scn;

    private BaseActor a;

    public UndoCreateActor(Scene s, BaseActor a) {
        scn = s;
        this.a = a;
    }

    @Override
    public void undo() {
        scn.getActors().remove(a.getId());
        Ctx.project.setModified(this, Project.NOTIFY_ELEMENT_DELETED, null, a);
    }
}

18 View Complete Implementation : UndoDepthVector.java
Copyright Apache License 2.0
Author : bladecoder
private void updateFakeDepth() {
    for (BaseActor a : s.getActors().values()) {
        if (a instanceof SpriteActor) {
            a.setPosition(a.getX(), a.getY());
        }
    }
}

18 View Complete Implementation : CameraAction.java
Copyright Apache License 2.0
Author : bladecoder
@Override
public boolean run(VerbRunner cb) {
    Vector2 pos2 = null;
    Float zoom2 = zoom;
    if (pos != null)
        pos2 = new Vector2(pos);
    float scale = EnginereplacedetManager.getInstance().getScale();
    SceneCamera camera = w.getSceneCamera();
    if (zoom2 == null || zoom2 < 0)
        zoom2 = camera.getZoom();
    if (pos == null && target == null) {
        pos2 = new Vector2(camera.getPosition());
        pos2.x /= scale;
        pos2.y /= scale;
    }
    if (target != null) {
        BaseActor target = w.getCurrentScene().getActor(this.target, false);
        float x = target.getX();
        float y = target.getY();
        if (target instanceof InteractiveActor) {
            Vector2 refPoint = ((InteractiveActor) target).getRefPoint();
            x += refPoint.x;
            y += refPoint.y;
        }
        if (pos2 != null) {
            pos2.x += x;
            pos2.y += y;
        } else {
            pos2 = new Vector2(x, y);
        }
    }
    camera.stopAnim();
    if (followActor != null) {
        if (followActor.equals("none"))
            w.getCurrentScene().setCameraFollowActor(null);
        else {
            w.getCurrentScene().setCameraFollowActor((SpriteActor) w.getCurrentScene().getActor(followActor, false));
        }
    }
    if (duration == null || duration == 0) {
        camera.setZoom(zoom2);
        camera.setPosition(pos2.x * scale, pos2.y * scale);
        return false;
    } else {
        camera.startAnimation(pos2.x * scale, pos2.y * scale, zoom2, duration, interpolation, wait ? cb : null);
    }
    return wait;
}

18 View Complete Implementation : CancelVerbAction.java
Copyright Apache License 2.0
Author : bladecoder
@Override
public boolean run(VerbRunner cb) {
    VerbRunner v = null;
    if (verb == null) {
        v = (VerbRunner) cb;
    }
    if (v == null && actor != null) {
        BaseActor a = w.getCurrentScene().getActor(actor, true);
        v = ((InteractiveActor) a).getVerb(verb, target);
    }
    if (v == null) {
        v = w.getCurrentScene().getVerb(verb);
    }
    if (v == null) {
        v = w.getVerbManager().getVerb(verb, null, null);
    }
    if (v != null) {
        // Cancel possible pending timer
        w.getCurrentScene().getTimers().removeTimerWithCb(v);
        v.cancel();
    } else
        EngineLogger.error("Cannot find VERB: " + verb + " for ACTOR: " + actor);
    return false;
}

18 View Complete Implementation : TextAction.java
Copyright Apache License 2.0
Author : bladecoder
@Override
public boolean run(VerbRunner cb) {
    if (text == null)
        return false;
    float x = TextManager.POS_CENTER, y = TextManager.POS_CENTER;
    if (target != null) {
        Scene ts = target.getScene(w);
        BaseActor anchorActor = ts.getActor(target.getActorId(), true);
        x = anchorActor.getX();
        y = anchorActor.getY();
        if (anchorActor instanceof InteractiveActor) {
            Vector2 refPoint = ((InteractiveActor) anchorActor).getRefPoint();
            x += refPoint.x;
            y += refPoint.y;
        }
        if (pos != null) {
            float scale = EnginereplacedetManager.getInstance().getScale();
            x += pos.x * scale;
            y += pos.y * scale;
        }
    } else if (pos != null) {
        float scale = EnginereplacedetManager.getInstance().getScale();
        if (pos.x != TextManager.POS_CENTER)
            x = pos.x * scale;
        if (pos.y != TextManager.POS_CENTER)
            y = pos.y * scale;
    } else {
        if (type == Text.Type.SUBreplacedLE) {
            x = y = TextManager.POS_SUBreplacedLE;
        }
    }
    w.getCurrentScene().getTextManager().addText(text, x, y, queue, type, color, style, null, voiceId, null, wait ? cb : null);
    return wait;
}

18 View Complete Implementation : CheckDesc.java
Copyright Apache License 2.0
Author : bladecoder
@Override
public void visit(BaseActor a) {
    if (a instanceof InteractiveActor) {
        ia = (InteractiveActor) a;
        hasLeave = false;
        hasEnterExit = false;
        if (ia.getInteraction()) {
            HashMap<String, Verb> verbs = ia.getVerbManager().getVerbs();
            for (Verb v : verbs.values()) checkVerb(v);
            // TODO: check states and verbs for states.
            if (hasLeave || hasEnterExit)
                return;
            if (ia.getDesc() == null || ia.getDesc().trim().isEmpty()) {
                EditorLogger.error("CheckDesc: " + a.getScene().getId() + "." + a.getId());
            }
        }
    }
}

18 View Complete Implementation : DropItemAction.java
Copyright Apache License 2.0
Author : bladecoder
@Override
public boolean run(VerbRunner cb) {
    Scene ts = null;
    if (scene == null)
        ts = w.getCurrentScene();
    else
        ts = w.getScene(scene);
    Inventory inv = null;
    if (inventory == null) {
        inv = w.getInventory();
    } else {
        inv = w.getInventories().get(inventory);
        if (inv == null) {
            EngineLogger.error("Inventory not found: " + inventory);
            return false;
        }
    }
    BaseActor a;
    if (actor != null) {
        a = inv.get(actor);
        if (a == null) {
            EngineLogger.error(MessageFormat.format("DropItemAction -  Item not found: {0}", actor));
            return false;
        }
        removeActor(inv, ts, a);
    } else {
        int n = inv.getNumItems();
        for (int i = n - 1; i >= 0; i--) {
            a = inv.get(i);
            removeActor(inv, ts, a);
        }
    }
    return false;
}

18 View Complete Implementation : GotoAction.java
Copyright Apache License 2.0
Author : bladecoder
@Override
public boolean run(VerbRunner cb) {
    CharacterActor actor = (CharacterActor) w.getCurrentScene().getActor(this.actor, false);
    float x = actor.getX();
    float y = actor.getY();
    if (target != null) {
        BaseActor target = w.getCurrentScene().getActor(this.target, false);
        x = target.getX();
        y = target.getY();
        if (target instanceof InteractiveActor && target != actor) {
            Vector2 refPoint = ((InteractiveActor) target).getRefPoint();
            x += refPoint.x;
            y += refPoint.y;
        }
        if (pos != null) {
            float scale = EnginereplacedetManager.getInstance().getScale();
            x += pos.x * scale;
            y += pos.y * scale;
        }
    } else if (pos != null) {
        float scale = EnginereplacedetManager.getInstance().getScale();
        x = pos.x * scale;
        y = pos.y * scale;
    }
    actor.goTo(new Vector2(x, y), wait ? cb : null, ignoreWalkZone);
    return wait;
}

18 View Complete Implementation : GotoAction.java
Copyright Apache License 2.0
Author : bladecoder
/**
 * If 'player' is far from 'actor', we bring it close. If 'player' is closed
 * from 'actor' do nothing.
 *
 * TODO: DOESN'T WORK NOW
 *
 * @param player
 * @param actor
 */
@SuppressWarnings("unused")
private void goNear(CharacterActor player, BaseActor actor, ActionCallback cb) {
    Rectangle rdest = actor.getBBox().getBoundingRectangle();
    // Vector2 p0 = new Vector2(player.getSprite().getX(),
    // player.getSprite().getY());
    Vector2 p0 = new Vector2(player.getX(), player.getY());
    // calculamos el punto más cercano al objeto
    // izquierda
    Vector2 p1 = new Vector2(rdest.x, rdest.y);
    // derecha
    Vector2 p2 = new Vector2(rdest.x + rdest.width, rdest.y);
    // centro
    Vector2 p3 = new Vector2(rdest.x + rdest.width / 2, rdest.y);
    float d1 = p0.dst(p1);
    float d2 = p0.dst(p2);
    float d3 = p0.dst(p3);
    Vector2 pf;
    if (d1 < d2 && d1 < d3) {
        pf = p1;
    } else if (d2 < d1 && d2 < d3) {
        pf = p2;
    } else {
        pf = p3;
    }
    player.goTo(pf, cb, ignoreWalkZone);
}

18 View Complete Implementation : SetActorAttrAction.java
Copyright Apache License 2.0
Author : bladecoder
@Override
public boolean run(VerbRunner cb) {
    Scene s = actor.getScene(w);
    BaseActor a = s.getActor(actor.getActorId(), true);
    if (a == null) {
        EngineLogger.error("SetActorAttr - Actor not found:" + this.actor.getActorId());
        return false;
    }
    if (visible != null)
        a.setVisible(visible);
    if (interaction != null) {
        if (a instanceof InteractiveActor)
            ((InteractiveActor) a).setInteraction(interaction);
        else
            EngineLogger.error("'Interaction' property not supported for actor:" + a.getId());
    }
    if (layer != null) {
        if (a instanceof InteractiveActor) {
            InteractiveActor iActor = (InteractiveActor) a;
            String oldLayer = iActor.getLayer();
            s.getLayer(oldLayer).remove(iActor);
            iActor.setLayer(layer);
            SceneLayer l = s.getLayer(layer);
            l.add(iActor);
            if (!l.isDynamic())
                l.orderByZIndex();
        } else
            EngineLogger.error("'layer' property not supported for actor:" + a.getId());
    }
    if (zIndex != null) {
        if (a instanceof InteractiveActor) {
            InteractiveActor iActor = (InteractiveActor) a;
            iActor.setZIndex(zIndex);
            SceneLayer l = s.getLayer(iActor.getLayer());
            if (!l.isDynamic())
                l.orderByZIndex();
        } else
            EngineLogger.error("'zIndex' property not supported for actor:" + a.getId());
    }
    if (scale != null) {
        if (a instanceof SpriteActor)
            ((SpriteActor) a).setScale(scale);
        else
            EngineLogger.error("'scale' property not supported for actor:" + a.getId());
    }
    if (scaleXY != null) {
        if (a instanceof SpriteActor)
            ((SpriteActor) a).setScale(scaleXY.x, scaleXY.y);
        else
            EngineLogger.error("'scale' property not supported for actor:" + a.getId());
    }
    if (rotation != null) {
        if (a instanceof SpriteActor)
            ((SpriteActor) a).setRot(rotation);
        else
            EngineLogger.error("'rotation' property not supported for actor:" + a.getId());
    }
    if (tint != null) {
        if (a instanceof SpriteActor)
            ((SpriteActor) a).setTint(tint.cpy());
        else
            EngineLogger.error("'tint' property not supported for actor:" + a.getId());
    }
    if (fakeDepth != null) {
        if (a instanceof SpriteActor) {
            ((SpriteActor) a).setFakeDepth(fakeDepth);
        } else
            EngineLogger.error("'fakeDepth' property not supported for actor:" + a.getId());
    }
    if (standAnimation != null) {
        if (a instanceof CharacterActor)
            ((CharacterActor) a).setStandAnim(standAnimation);
        else
            EngineLogger.error("'standAnimation' property not supported for actor:" + a.getId());
    }
    if (walkAnimation != null) {
        if (a instanceof CharacterActor)
            ((CharacterActor) a).setWalkAnim(walkAnimation);
        else
            EngineLogger.error("'walkAnimation' property not supported for actor:" + a.getId());
    }
    if (talkAnimation != null) {
        if (a instanceof CharacterActor)
            ((CharacterActor) a).setTalkAnim(talkAnimation);
        else
            EngineLogger.error("'talkAnimation' property not supported for actor:" + a.getId());
    }
    if (walkingSpeed != null) {
        if (a instanceof CharacterActor)
            ((CharacterActor) a).setWalkingSpeed(walkingSpeed);
        else
            EngineLogger.error("'walkingSpeed' property not supported for actor:" + a.getId());
    }
    if (uiActor != null) {
        if (a instanceof InteractiveActor) {
            if (uiActor)
                setUIActor(s, (InteractiveActor) a);
            else
                removeUIActor(s, (InteractiveActor) a);
        } else
            EngineLogger.error("'uiActor' property not supported for actor:" + a.getId());
    }
    if (talkingTextPos != null) {
        if (a instanceof CharacterActor)
            ((CharacterActor) a).setTalkingTextPos(talkingTextPos);
        else
            EngineLogger.error("'talkingTextPos' property not supported for actor:" + a.getId());
    }
    return false;
}

17 View Complete Implementation : Project.java
Copyright Apache License 2.0
Author : bladecoder
public clreplaced Project extends PropertyChange {

    public static final String PROP_PROJECTFILE = "projectFile";

    public static final String NOTIFY_SCENE_SELECTED = "SCENE_SELECTED";

    public static final String NOTIFY_ACTOR_SELECTED = "ACTOR_SELECTED";

    public static final String NOTIFY_ANIM_SELECTED = "ANIM_SELECTED";

    public static final String NOTIFY_VERB_SELECTED = "VERB_SELECTED";

    public static final String NOTIFY_PROJECT_LOADED = "PROJECT_LOADED";

    public static final String NOTIFY_PROJECT_SAVED = "PROJECT_SAVED";

    public static final String NOTIFY_CHAPTER_LOADED = "CHAPTER_LOADED";

    public static final String NOTIFY_ELEMENT_DELETED = "ELEMENT_DELETED";

    public static final String NOTIFY_ELEMENT_CREATED = "ELEMENT_CREATED";

    public static final String NOTIFY_MODEL_MODIFIED = "MODEL_MODIFIED";

    public static final String POSITION_PROPERTY = "pos";

    public static final String WIDTH_PROPERTY = "width";

    public static final String HEIGHT_PROPERTY = "height";

    public static final String CHAPTER_PROPERTY = "chapter";

    public static final String SPINE_RENDERER_STRING = "spine";

    public static final String ATLAS_RENDERER_STRING = "atlas";

    public static final String IMAGE_RENDERER_STRING = "image";

    public static final String S3D_RENDERER_STRING = "3d";

    public static final String PARTICLE_RENDERER_STRING = "particle";

    public static final String TEXT_RENDERER_STRING = "text";

    public static final String NEW_replacedETS_PATH = "/replacedets";

    public static final String OLD_replacedETS_PATH = "/android/replacedets";

    public static final String MODEL_PATH = "/model";

    public static final String ATLASES_PATH = "/atlases";

    public static final String FONTS_PATH = "/fonts";

    public static final String MUSIC_PATH = "/music";

    public static final String SOUND_PATH = "/sounds";

    public static final String IMAGE_PATH = "/images";

    public static final String SPRITE3D_PATH = "/3d";

    public static final String SPINE_PATH = "/spine";

    public static final String PARTICLE_PATH = "/particles";

    public static final String VOICE_PATH = "/voices";

    public static final String UI_PATH = "/ui";

    public static final String FONT_PATH = UI_PATH + "/fonts";

    public static final int DEFAULT_WIDTH = 1920;

    public static final int DEFAULT_HEIGHT = 1080;

    private static final String CONFIG_DIR = System.getProperty("user.home") + "/.AdventureEditor";

    private static final String CONFIG_FILENAME = "config.properties";

    public static final String LAST_PROJECT_PROP = "last_project";

    private final Properties editorConfig = new Properties();

    private File projectFile;

    private final UndoStack undoStack = new UndoStack();

    private OrderedProperties projectConfig;

    private I18NHandler i18n;

    private Chapter chapter;

    private Scene selectedScene;

    private BaseActor selectedActor;

    private String selectedFA;

    private boolean modified = false;

    private final World world = new World();

    public Project() {
        loadConfig();
    }

    public World getWorld() {
        return world;
    }

    public String getreplacedetPath(String base) {
        String path = base + NEW_replacedETS_PATH;
        if (new File(path).exists()) {
            return path;
        } else {
            return base + OLD_replacedETS_PATH;
        }
    }

    public String getreplacedetPath() {
        return getreplacedetPath(getProjectPath());
    }

    public UndoStack getUndoStack() {
        return undoStack;
    }

    private void loadConfig() {
        File dir = new File(CONFIG_DIR);
        File f = new File(CONFIG_DIR + "/" + CONFIG_FILENAME);
        if (!dir.exists())
            dir.mkdirs();
        try {
            if (!f.exists()) {
                f.createNewFile();
            } else {
                editorConfig.load(new FileInputStream(f));
            }
        } catch (IOException e) {
            EditorLogger.error(e.getMessage());
        }
    }

    public void saveConfig() {
        File f = new File(CONFIG_DIR + "/" + CONFIG_FILENAME);
        try {
            editorConfig.store(new FileOutputStream(f), null);
        } catch (IOException e) {
            EditorLogger.error(e.getMessage());
        }
    }

    public Properties getEditorConfig() {
        return editorConfig;
    }

    public OrderedProperties getProjectConfig() {
        return projectConfig;
    }

    public I18NHandler getI18N() {
        return i18n;
    }

    public String translate(String key) {
        return i18n.getTranslation(key);
    }

    public void setModified(Object source, String property, Object oldValue, Object newValue) {
        modified = true;
        PropertyChangeEvent evt = new PropertyChangeEvent(source, property, oldValue, newValue);
        firePropertyChange(evt);
    }

    public void notifyPropertyChange(String property) {
        firePropertyChange(property);
    }

    public void setSelectedScene(Scene scn) {
        selectedScene = scn;
        selectedActor = null;
        selectedFA = null;
        if (scn != null)
            getEditorConfig().setProperty("project.selectedScene", scn.getId());
        firePropertyChange(NOTIFY_SCENE_SELECTED, null, selectedScene);
    }

    public void setSelectedActor(BaseActor a) {
        BaseActor old = null;
        old = selectedActor;
        selectedActor = a;
        selectedFA = null;
        firePropertyChange(NOTIFY_ACTOR_SELECTED, old, selectedActor);
    }

    public Chapter getChapter() {
        return chapter;
    }

    public Scene getSelectedScene() {
        return selectedScene;
    }

    public BaseActor getSelectedActor() {
        return selectedActor;
    }

    public String getSelectedFA() {
        return selectedFA;
    }

    public void setSelectedFA(String id) {
        String old = selectedFA;
        selectedFA = id;
        firePropertyChange(NOTIFY_ANIM_SELECTED, old, selectedFA);
    }

    public String getModelPath() {
        return getreplacedetPath() + MODEL_PATH;
    }

    public String getProjectPath() {
        return projectFile.getAbsolutePath();
    }

    public File getProjectDir() {
        return projectFile;
    }

    public String getreplacedle() {
        if (projectConfig == null)
            return null;
        return projectConfig.getProperty(Config.replacedLE_PROP, getProjectDir().getName());
    }

    public boolean isLoaded() {
        return Ctx.project.getProjectDir() != null;
    }

    public String getPackagereplacedle() {
        return getreplacedle().replace(" ", "").replace("'", "");
    }

    public void createProject(String projectDir, String name, String pkg, String sdkLocation, boolean spinePlugin) throws IOException {
        closeProject();
        createLibGdxProject(projectDir, name, pkg, "BladeEngine", sdkLocation, spinePlugin);
        projectFile = new File(projectDir + "/" + name);
        loadProject(projectFile);
    }

    private void createLibGdxProject(String projectDir, String name, String pkg, String mainClreplaced, String sdkLocation, boolean spinePlugin) throws IOException {
        String sdk = null;
        if (sdkLocation != null && !sdkLocation.isEmpty()) {
            sdk = sdkLocation;
        } else if (System.getenv("ANDROID_HOME") != null) {
            sdk = System.getenv("ANDROID_HOME");
        }
        new BladeEngineSetup().build(projectDir + "/" + name, name, pkg, mainClreplaced, sdk, spinePlugin);
    }

    public void saveProject() throws IOException {
        if (projectFile != null && chapter.getId() != null && modified) {
            EngineLogger.setDebug();
            // 1.- SAVE world
            world.saveWorldDesc(new FileHandle(new File(getreplacedetPath() + MODEL_PATH + "/" + EnginereplacedetManager.WORLD_FILENAME)));
            // 2.- SAVE .chapter
            chapter.save();
            // 3.- SAVE BladeEngine.properties
            List<String> resolutions = getResolutions();
            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < resolutions.size(); i++) {
                sb.append(resolutions.get(i));
                if (i < resolutions.size() - 1)
                    sb.append(',');
            }
            projectConfig.setProperty(Config.RESOLUTIONS, sb.toString());
            projectConfig.store(new FileOutputStream(getreplacedetPath() + "/" + Config.PROPERTIES_FILENAME), null);
            // 4.- SAVE I18N
            i18n.save();
            modified = false;
            firePropertyChange(NOTIFY_PROJECT_SAVED);
        }
    }

    public void closeProject() {
        setSelectedScene(null);
        this.projectFile = null;
        this.projectConfig = null;
        firePropertyChange(NOTIFY_PROJECT_LOADED);
    }

    public void loadProject(File projectToLoad) throws IOException {
        projectToLoad = checkProjectStructure(projectToLoad);
        if (projectToLoad != null) {
            // dispose the current project
            closeProject();
            this.projectFile = projectToLoad;
            // Use FolderClreplacedLoader for loading CUSTOM actions.
            // TODO Add 'core/bin' and '/core/out' folders???
            FolderClreplacedLoader folderClreplacedLoader = null;
            if (new File(projectFile, "/replacedets").exists()) {
                folderClreplacedLoader = new FolderClreplacedLoader(projectFile.getAbsolutePath() + "/core/build/clreplacedes/java/main");
            } else {
                folderClreplacedLoader = new FolderClreplacedLoader(projectFile.getAbsolutePath() + "/core/build/clreplacedes/main");
            }
            ActionFactory.setActionClreplacedLoader(folderClreplacedLoader);
            EnginereplacedetManager.createEditInstance(getreplacedetPath());
            try {
                // Clear last project to avoid reloading if the project fails.
                getEditorConfig().remove(LAST_PROJECT_PROP);
                saveConfig();
                world.loadWorldDesc();
            } catch (SerializationException ex) {
                // check for not compiled custom actions
                if (ex.getCause() != null && ex.getCause() instanceof ClreplacedNotFoundException) {
                    EditorLogger.msg("Custom action clreplaced not found. Trying to compile...");
                    if (RunProccess.runGradle(getProjectDir(), "desktop:compileJava")) {
                        folderClreplacedLoader.reload();
                        world.loadWorldDesc();
                    } else {
                        this.projectFile = null;
                        throw new IOException("Failed to run Gradle.");
                    }
                } else {
                    this.projectFile = null;
                    throw ex;
                }
            }
            chapter = new Chapter(getreplacedetPath() + Project.MODEL_PATH);
            i18n = new I18NHandler(getreplacedetPath() + Project.MODEL_PATH);
            // No need to load the chapter. It's loaded by the chapter combo.
            // loadChapter(world.getInitChapter());
            projectConfig = new OrderedPropertiesBuilder().withSuppressDateInComment(true).withOrderingCaseSensitive().build();
            projectConfig.load(new FileInputStream(getreplacedetPath() + "/" + Config.PROPERTIES_FILENAME));
            modified = false;
            Display.setreplacedle("Adventure Editor v" + Versions.getVersion() + " - " + projectFile.getAbsolutePath());
            firePropertyChange(NOTIFY_PROJECT_LOADED);
        } else {
            closeProject();
            throw new IOException("Project not found.");
        }
    }

    public boolean checkVersion(File projectPath) throws FileNotFoundException, IOException {
        String editorVersion = getEditorBladeEngineVersion();
        String projectVersion = getProjectBladeEngineVersion(projectPath);
        if (editorVersion.equals(projectVersion) || editorVersion.indexOf('.') == -1)
            return true;
        if (parseVersion(editorVersion) <= parseVersion(projectVersion))
            return true;
        return false;
    }

    private int parseVersion(String v) {
        // 1 -> release, 0 -> snapshot
        int number = 1;
        if (v.endsWith("-SNAPSHOT")) {
            number = 0;
            v = v.substring(0, v.length() - "-SNAPSHOT".length());
        }
        String[] split = v.split("\\.");
        try {
            for (int i = 0; i < split.length; i++) {
                number += Math.pow(10, (split.length - i) * 2) * Integer.parseInt(split[i]);
            }
        } catch (NumberFormatException e) {
        }
        return number;
    }

    public String getProjectBladeEngineVersion(File projectPath) throws FileNotFoundException, IOException {
        OrderedProperties properties = getGradleProperties(projectPath);
        return properties.getProperty(Config.BLADE_ENGINE_VERSION_PROP, "default");
    }

    public String getEditorBladeEngineVersion() {
        return Versions.getVersion();
    }

    public void updateEngineVersion(File projectPath) throws FileNotFoundException, IOException {
        OrderedProperties prop = getGradleProperties(projectPath);
        prop.setProperty(Config.BLADE_ENGINE_VERSION_PROP, Versions.getVersion());
        prop.setProperty("gdxVersion", Versions.getLibgdxVersion());
        prop.setProperty("roboVMVersion", Versions.getRoboVMVersion());
        prop.setProperty("roboVMGradlePluginVersion", Versions.getROBOVMGradlePluginVersion());
        prop.setProperty("androidGradlePluginVersion", Versions.getAndroidGradlePluginVersion());
        prop.setProperty("bladeInkVersion", Versions.getBladeInkVersion());
        saveGradleProperties(prop, projectPath);
    }

    /**
     * Checks if the model folder exists in the preplaceded folder or in his parent.
     *
     * @return The correct project folder or null if the model folder is not found.
     */
    private File checkProjectStructure(File folder) {
        File projectFolder = folder;
        if (!new File(getreplacedetPath(projectFolder.getAbsolutePath()) + MODEL_PATH).exists()) {
            projectFolder = projectFolder.getParentFile();
            if (!new File(getreplacedetPath(projectFolder.getAbsolutePath()) + MODEL_PATH).exists())
                return null;
        }
        return projectFolder;
    }

    public BaseActor getActor(String id) {
        return selectedScene.getActor(id, false);
    }

    public List<String> getResolutions() {
        File atlasesPath = new File(getreplacedetPath() + UI_PATH);
        ArrayList<String> l = new ArrayList<>();
        File[] list = atlasesPath.listFiles();
        if (list == null)
            return l;
        for (int i = 0; i < list.length; i++) {
            String name = list[i].getName();
            if (list[i].isDirectory()) {
                try {
                    Float.parseFloat(name);
                    l.add(name);
                } catch (Exception e) {
                }
            }
        }
        return l;
    }

    public String getResDir() {
        return "1";
    }

    public void loadChapter(String selChapter) throws IOException {
        undoStack.clear();
        setSelectedScene(null);
        try {
            chapter.load(selChapter);
            firePropertyChange(NOTIFY_CHAPTER_LOADED);
            getEditorConfig().setProperty(LAST_PROJECT_PROP, projectFile.getAbsolutePath());
            getEditorConfig().setProperty("project.selectedChapter", selChapter);
        } catch (SerializationException ex) {
            // check for not compiled custom actions
            if (ex.getCause() != null && ex.getCause() instanceof ClreplacedNotFoundException) {
                EditorLogger.msg("Custom action clreplaced not found. Trying to compile...");
                if (RunProccess.runGradle(getProjectDir(), "desktop:compileJava")) {
                    ((FolderClreplacedLoader) ActionFactory.getActionClreplacedLoader()).reload();
                    chapter.load(selChapter);
                } else {
                    throw new IOException("Failed to run Gradle.");
                }
            } else {
                throw ex;
            }
        }
        i18n.load(selChapter);
    }

    public boolean isModified() {
        return modified;
    }

    public void setModified() {
        modified = true;
        firePropertyChange(NOTIFY_MODEL_MODIFIED);
    }

    public OrderedProperties getGradleProperties(File projectPath) throws FileNotFoundException, IOException {
        OrderedProperties prop = new OrderedPropertiesBuilder().withSuppressDateInComment(true).withOrderingCaseSensitive().build();
        prop.load(new FileReader(projectPath.getAbsolutePath() + "/gradle.properties"));
        return prop;
    }

    public void saveGradleProperties(OrderedProperties prop, File projectPath) throws IOException {
        FileOutputStream os = new FileOutputStream(projectPath.getAbsolutePath() + "/gradle.properties");
        prop.store(os, null);
    }
}

17 View Complete Implementation : CanvasDrawer.java
Copyright Apache License 2.0
Author : bladecoder
public void drawBBoxActors(Scene scn, boolean showSpriteBounds) {
    drawer.setProjectionMatrix(camera.combined);
    drawer.setTransformMatrix(new Matrix4());
    drawer.begin(ShapeType.Line);
    for (BaseActor a : scn.getActors().values()) {
        Polygon p = a.getBBox();
        if (p == null) {
            EditorLogger.error("ERROR DRAWING BBOX FOR: " + a.getId());
        }
        // Rectangle r = a.getBBox().getBoundingRectangle();
        if (a instanceof ObstacleActor) {
            drawer.setColor(Scene.OBSTACLE_COLOR);
            drawer.polygon(p.getTransformedVertices());
        } else if (a instanceof InteractiveActor) {
            InteractiveActor iActor = (InteractiveActor) a;
            if (a instanceof SpriteActor && !showSpriteBounds)
                continue;
            if (!scn.getLayer(iActor.getLayer()).isVisible())
                continue;
            drawer.setColor(Scene.ACTOR_BBOX_COLOR);
            if (p.getTransformedVertices().length > 2)
                drawer.polygon(p.getTransformedVertices());
        } else if (a instanceof WalkZoneActor) {
            drawer.setColor(Scene.WALKZONE_COLOR);
            if (p.getTransformedVertices().length > 2)
                drawer.polygon(p.getTransformedVertices());
        } else if (a instanceof AnchorActor) {
            drawer.setColor(Scene.ANCHOR_COLOR);
            drawer.line(p.getX() - Scene.ANCHOR_RADIUS, p.getY(), p.getX() + Scene.ANCHOR_RADIUS, p.getY());
            drawer.line(p.getX(), p.getY() - Scene.ANCHOR_RADIUS, p.getX(), p.getY() + Scene.ANCHOR_RADIUS);
        }
    // drawer.rect(r.getX(), r.getY(), r.getWidth(), r.getHeight());
    }
    drawer.end();
}

17 View Complete Implementation : ScnWidget.java
Copyright Apache License 2.0
Author : bladecoder
private void handleKeyPositioning() {
    if (getStage() == null || getStage().getKeyboardFocus() != this)
        return;
    if (Gdx.input.isKeyPressed(Keys.UP) || Gdx.input.isKeyPressed(Keys.DOWN) || Gdx.input.isKeyPressed(Keys.LEFT) || Gdx.input.isKeyPressed(Keys.RIGHT)) {
        BaseActor selActor = getSelectedActor();
        if (selActor == null)
            return;
        if (Gdx.input.isKeyPressed(Keys.UP))
            // p.translate(0, 1);
            selActor.setPosition(selActor.getX(), selActor.getY() + 1);
        else if (Gdx.input.isKeyPressed(Keys.DOWN))
            // p.translate(0, -1);
            selActor.setPosition(selActor.getX(), selActor.getY() - 1);
        else if (Gdx.input.isKeyPressed(Keys.LEFT))
            // p.translate(-1, 0);
            selActor.setPosition(selActor.getX() - 1, selActor.getY());
        else if (Gdx.input.isKeyPressed(Keys.RIGHT))
            // p.translate(1, 0);
            selActor.setPosition(selActor.getX() + 1, selActor.getY());
    }
}

17 View Complete Implementation : SceneActorInputPanel.java
Copyright Apache License 2.0
Author : bladecoder
private String[] getActorValues(Scene scn) {
    Map<String, BaseActor> actors = scn.getActors();
    ArrayList<BaseActor> filteredActors = new ArrayList<BaseActor>();
    for (BaseActor a : actors.values()) {
        if (type == Param.Type.SCENE_CHARACTER_ACTOR) {
            if (a instanceof CharacterActor)
                filteredActors.add(a);
        } else if (type == Param.Type.SCENE_INTERACTIVE_ACTOR) {
            if (a instanceof InteractiveActor)
                filteredActors.add(a);
        } else if (type == Param.Type.SCENE_SPRITE_ACTOR) {
            if (a instanceof SpriteActor)
                filteredActors.add(a);
        } else if (type == Param.Type.SCENE_WALKZONE_ACTOR) {
            if (a instanceof WalkZoneActor)
                filteredActors.add(a);
        } else {
            filteredActors.add(a);
        }
    }
    String[] result = null;
    if (type != Param.Type.SCENE_WALKZONE_ACTOR) {
        // Add player variable to the list
        result = new String[filteredActors.size() + 1];
        result[0] = Scene.VAR_PLAYER;
        for (int i = 0; i < filteredActors.size(); i++) {
            result[i + 1] = filteredActors.get(i).getId();
        }
    } else {
        result = new String[filteredActors.size()];
        for (int i = 0; i < filteredActors.size(); i++) {
            result[i] = filteredActors.get(i).getId();
        }
    }
    Arrays.sort(result);
    return result;
}

17 View Complete Implementation : IfAttrAction.java
Copyright Apache License 2.0
Author : bladecoder
@Override
public boolean run(VerbRunner cb) {
    Scene s = actor.getScene(w);
    final String actorId = actor.getActorId();
    if (attr.equals(ActorAttribute.STATE)) {
        BaseActor a = s.getActor(actorId, true);
        if (a == null || !(a instanceof InteractiveActor)) {
            EngineLogger.error(getClreplaced() + "- No not found: " + actorId);
            return false;
        }
        InteractiveActor ia = (InteractiveActor) a;
        if (!ActionUtils.compareNullStr(value, ia.getState())) {
            gotoElse(cb);
        }
    } else if (attr.equals(ActorAttribute.VISIBLE)) {
        BaseActor a = s.getActor(actorId, true);
        if (a == null) {
            EngineLogger.error(getClreplaced() + "- No not found: " + actorId);
            return false;
        }
        boolean val = Boolean.parseBoolean(value);
        if (val != a.isVisible()) {
            gotoElse(cb);
        }
    } else if (attr.equals(ActorAttribute.INTERACTIVE)) {
        BaseActor a = s.getActor(actorId, true);
        if (a == null) {
            EngineLogger.error(getClreplaced() + "- No not found: " + actorId);
            return false;
        }
        boolean val = Boolean.parseBoolean(value);
        if (a instanceof InteractiveActor) {
            if (val != ((InteractiveActor) a).getInteraction()) {
                gotoElse(cb);
            }
        } else if (val == true) {
            gotoElse(cb);
        }
    } else if (attr.equals(ActorAttribute.IN_INVENTORY)) {
        // 'value' can have the inventory name to search in
        // or 'true/false' to search in the current inventory.
        Inventory inventory = null;
        boolean val = true;
        if (value != null) {
            inventory = w.getInventories().get(value);
        }
        if (inventory == null) {
            // boolean mode: search in the current inventory
            val = Boolean.parseBoolean(value);
            inventory = w.getInventory();
        }
        SpriteActor item = null;
        item = inventory.get(actorId);
        if ((val && item == null) || (!val && item != null)) {
            gotoElse(cb);
        }
    } else if (attr.equals(ActorAttribute.TARGET)) {
        if (!ActionUtils.compareNullStr(value, cb.getCurrentTarget())) {
            gotoElse(cb);
        }
    } else if (attr.equals(ActorAttribute.IN_SCENE)) {
        boolean val = Boolean.parseBoolean(value);
        BaseActor a2 = s.getActor(actorId, false);
        if ((val && a2 == null) || (!val && a2 != null))
            gotoElse(cb);
    } else if (attr.equals(ActorAttribute.IN_UI)) {
        boolean val = Boolean.parseBoolean(value);
        BaseActor a2 = w.getUIActors().get(actorId);
        if ((val && a2 == null) || (!val && a2 != null))
            gotoElse(cb);
    } else if (attr.equals(ActorAttribute.LAYER)) {
        BaseActor a = s.getActor(actorId, true);
        if (a == null || !(a instanceof InteractiveActor)) {
            EngineLogger.error(getClreplaced() + "- No not found: " + actorId);
            return false;
        }
        InteractiveActor ia = (InteractiveActor) a;
        if (!ActionUtils.compareNullStr(value, ia.getLayer())) {
            gotoElse(cb);
        }
    } else if (attr.equals(ActorAttribute.DIRECTION)) {
        BaseActor a = s.getActor(actorId, true);
        if (a == null || !(a instanceof SpriteActor)) {
            EngineLogger.error(getClreplaced() + "- No not found: " + actorId);
            return false;
        }
        SpriteActor sa = (SpriteActor) a;
        if (sa.getRenderer() instanceof AnimationRenderer) {
            String dir = null;
            String anim = ((AnimationRenderer) sa.getRenderer()).getCurrentAnimationId();
            int idx = anim.lastIndexOf('.');
            if (idx != -1)
                dir = anim.substring(idx + 1);
            if (!ActionUtils.compareNullStr(value, dir)) {
                gotoElse(cb);
            }
        }
    } else if (attr.equals(ActorAttribute.INSIDE)) {
        BaseActor a = s.getActor(actorId, true);
        if (a == null) {
            EngineLogger.error(getClreplaced() + "- No not found: " + actorId);
            return false;
        }
        BaseActor insideActor = w.getCurrentScene().getActor(value, false);
        if (insideActor == null) {
            EngineLogger.debug("Actor for inside test not found: " + value);
            return false;
        }
        boolean inside = PolygonUtils.isPointInside(insideActor.getBBox(), a.getX(), a.getY(), true);
        if (!inside) {
            gotoElse(cb);
        }
    }
    return false;
}

17 View Complete Implementation : MoveToSceneAction.java
Copyright Apache License 2.0
Author : bladecoder
@Override
public boolean run(VerbRunner cb) {
    final Scene s = actor.getScene(w);
    final String actorId = actor.getActorId();
    if (actorId == null) {
        // if called in a scene verb and no actor is specified, we do nothing
        EngineLogger.error(getClreplaced() + ": No actor specified");
        return false;
    }
    BaseActor a = s.getActor(actorId, false);
    s.removeActor(a);
    Scene ts = null;
    if (scene == null)
        ts = w.getCurrentScene();
    else
        ts = w.getScene(scene);
    // Dispose if s is the current scene or a cached scene and the target is not the
    // current scene or a cache scene
    if ((s == w.getCurrentScene() || w.getCachedScene(ts.getId()) != null) && !(ts == w.getCurrentScene() || w.getCachedScene(ts.getId()) != null) && a instanceof Disposable) {
        ((Disposable) a).dispose();
    }
    // We must load replacedets when the target scene is the current scene or when
    // the scene is cached.
    if ((ts == w.getCurrentScene() || w.getCachedScene(ts.getId()) != null) && !(s == w.getCurrentScene() || w.getCachedScene(s.getId()) != null) && a instanceof replacedetConsumer) {
        ((replacedetConsumer) a).loadreplacedets();
        EnginereplacedetManager.getInstance().finishLoading();
        ((replacedetConsumer) a).retrievereplacedets();
    }
    ts.addActor(a);
    return false;
}

17 View Complete Implementation : PositionAction.java
Copyright Apache License 2.0
Author : bladecoder
@Override
public boolean run(VerbRunner cb) {
    Scene s = actor.getScene(w);
    BaseActor a = s.getActor(actor.getActorId(), true);
    float x = a.getX();
    float y = a.getY();
    if (target != null) {
        Scene ts = target.getScene(w);
        BaseActor anchorActor = ts.getActor(target.getActorId(), false);
        x = anchorActor.getX();
        y = anchorActor.getY();
        if (anchorActor instanceof InteractiveActor && a != anchorActor) {
            Vector2 refPoint = ((InteractiveActor) anchorActor).getRefPoint();
            x += refPoint.x;
            y += refPoint.y;
        }
        if (position != null) {
            float scale = EnginereplacedetManager.getInstance().getScale();
            x += position.x * scale;
            y += position.y * scale;
        }
    } else if (position != null) {
        float scale = EnginereplacedetManager.getInstance().getScale();
        x = position.x * scale;
        y = position.y * scale;
    }
    a.setPosition(x, y);
    return false;
}

17 View Complete Implementation : RandomPositionAction.java
Copyright Apache License 2.0
Author : bladecoder
@Override
public boolean run(VerbRunner cb) {
    Scene s = actor.getScene(w);
    BaseActor a = s.getActor(actor.getActorId(), true);
    float x = a.getX();
    float y = a.getY();
    float rx = (float) (minPosition.x + Math.random() * (maxPosition.x - minPosition.x));
    float ry = (float) (minPosition.y + Math.random() * (maxPosition.y - minPosition.y));
    if (target != null) {
        Scene ts = target.getScene(w);
        BaseActor anchorActor = ts.getActor(target.getActorId(), false);
        x = anchorActor.getX();
        y = anchorActor.getY();
        if (anchorActor instanceof InteractiveActor && a != anchorActor) {
            Vector2 refPoint = ((InteractiveActor) anchorActor).getRefPoint();
            x += refPoint.x;
            y += refPoint.y;
        }
        float scale = EnginereplacedetManager.getInstance().getScale();
        x += rx * scale;
        y += ry * scale;
    } else {
        float scale = EnginereplacedetManager.getInstance().getScale();
        x = rx * scale;
        y = ry * scale;
    }
    a.setPosition(x, y);
    return false;
}

16 View Complete Implementation : I18NHandler.java
Copyright Apache License 2.0
Author : bladecoder
public void putTranslationsInElement(Scene scn) {
    HashMap<String, Verb> verbs = scn.getVerbManager().getVerbs();
    for (Verb v : verbs.values()) putTranslationsInElement(v, false);
    for (BaseActor a : scn.getActors().values()) {
        putTranslationsInElement(a);
    }
}

16 View Complete Implementation : ModelWalker.java
Copyright Apache License 2.0
Author : bladecoder
public void walk(World w) {
    Map<String, Scene> scenes = Ctx.project.getWorld().getScenes();
    for (StartVisitor sv : startVisitors) sv.start(w);
    for (Scene scn : scenes.values()) {
        for (SceneVisitor sv : sceneVisitors) sv.visit(scn);
        Map<String, BaseActor> actors = scn.getActors();
        // SCENE VERBS
        HashMap<String, Verb> verbs = scn.getVerbManager().getVerbs();
        for (Verb v : verbs.values()) {
            for (VerbVisitor vv : verbVisitors) vv.visit(scn, null, v);
            ArrayList<Action> actions = v.getActions();
            for (Action act : actions) {
                for (ActionVisitor av : actionVisitors) av.visit(scn, null, v, act);
            }
        }
        for (BaseActor a : actors.values()) {
            for (ActorVisitor av : actorVisitors) av.visit(a);
            if (a instanceof InteractiveActor) {
                InteractiveActor ia = (InteractiveActor) a;
                // ACTOR VERBS
                verbs = ia.getVerbManager().getVerbs();
                for (Verb v : verbs.values()) {
                    for (VerbVisitor vv : verbVisitors) vv.visit(scn, ia, v);
                    ArrayList<Action> actions = v.getActions();
                    for (Action act : actions) {
                        for (ActionVisitor av : actionVisitors) av.visit(scn, ia, v, act);
                    }
                }
            }
            // DIALOGS
            if (a instanceof CharacterActor) {
                HashMap<String, Dialog> dialogs = ((CharacterActor) a).getDialogs();
                if (dialogs != null) {
                    for (Dialog d : dialogs.values()) {
                        for (DialogVisitor dv : dialogVisitors) dv.visit((CharacterActor) a, d);
                        ArrayList<DialogOption> options = d.getOptions();
                        for (DialogOption o : options) {
                            for (DialogOptionVisitor ov : optionVisitors) ov.visit((CharacterActor) a, d, o);
                        }
                    }
                }
            }
        }
    }
    for (EndVisitor ev : endVisitors) ev.end(w);
}

16 View Complete Implementation : ScnWidget.java
Copyright Apache License 2.0
Author : bladecoder
public void setAnimationRenderer(BaseActor a, AnimationDesc fa) {
    try {
        faRenderer.setActor(a);
        faRenderer.setAnimation(fa);
    } catch (Exception e) {
        Message.showMsg(getStage(), "Could not retrieve replacedets for sprite: " + fa.id, 4);
        EditorLogger.printStackTrace(e);
        faRenderer.setAnimation(null);
    }
}

16 View Complete Implementation : ScnWidgetInputListener.java
Copyright Apache License 2.0
Author : bladecoder
@Override
public boolean keyDown(InputEvent event, int keycode) {
    super.keyDown(event, keycode);
    Polygon p = null;
    if (scnWidget.getStage() == null || scnWidget.getStage().getKeyboardFocus() != scnWidget)
        return false;
    switch(keycode) {
        case Keys.ENTER:
            break;
        case Keys.BACKSPACE:
            break;
        case Keys.Z:
            if (UIUtils.ctrl()) {
                Ctx.project.getUndoStack().undo();
            }
            break;
        case Keys.FORWARD_DEL:
            BaseActor a = Ctx.project.getSelectedActor();
            if (a == null)
                return false;
            Ctx.project.getUndoStack().add(new UndoDeleteActor(Ctx.project.getSelectedScene(), a));
            Ctx.project.getSelectedScene().removeActor(a);
            Ctx.project.setModified(this, Project.NOTIFY_ELEMENT_DELETED, null, a);
            break;
        case Keys.S:
            if (UIUtils.ctrl()) {
                try {
                    Ctx.project.saveProject();
                } catch (IOException e1) {
                    String msg = "Something went wrong while saving the actor.\n\n" + e1.getClreplaced().getSimpleName() + " - " + e1.getMessage();
                    Message.showMsgDialog(scnWidget.getStage(), "Error", msg);
                    EditorLogger.printStackTrace(e1);
                }
            }
            break;
        case Keys.UP:
        case Keys.DOWN:
        case Keys.LEFT:
        case Keys.RIGHT:
            selActor = scnWidget.getSelectedActor();
            p = selActor.getBBox();
            undoOrg.set(p.getX(), p.getY());
            Ctx.project.setModified(this, Project.POSITION_PROPERTY, null, selActor);
            break;
        case Keys.PLUS:
        case 70:
            scnWidget.zoom(-1);
            break;
        case Keys.MINUS:
            scnWidget.zoom(1);
            break;
    }
    return false;
}

16 View Complete Implementation : DropItemAction.java
Copyright Apache License 2.0
Author : bladecoder
private void removeActor(Inventory inv, Scene ts, BaseActor a) {
    float scale = EnginereplacedetManager.getInstance().getScale();
    inv.removeItem(a.getId());
    if (ts != w.getCurrentScene() && w.getCachedScene(ts.getId()) == null && a instanceof Disposable)
        ((Disposable) a).dispose();
    ts.addActor(a);
    if (pos != null)
        a.setPosition(pos.x * scale, pos.y * scale);
}

16 View Complete Implementation : PositionAnimAction.java
Copyright Apache License 2.0
Author : bladecoder
@Override
public boolean run(VerbRunner cb) {
    float scale = EnginereplacedetManager.getInstance().getScale();
    BaseActor a = w.getCurrentScene().getActor(actor, true);
    float x = a.getX();
    float y = a.getY();
    if (target != null) {
        BaseActor target = w.getCurrentScene().getActor(this.target, false);
        x = target.getX();
        y = target.getY();
        if (target instanceof InteractiveActor && target != a) {
            Vector2 refPoint = ((InteractiveActor) target).getRefPoint();
            x += refPoint.x;
            y += refPoint.y;
        }
        if (pos != null) {
            x += pos.x * scale;
            y += pos.y * scale;
        }
    } else if (pos != null) {
        x = pos.x * scale;
        y = pos.y * scale;
    }
    if (!(a instanceof SpriteActor)) {
        a.setPosition(x, y);
        return false;
    } else {
        // WARNING: only spriteactors support animation
        float s;
        if (mode != null && mode == Mode.SPEED) {
            Vector2 p0 = new Vector2(a.getX(), a.getY());
            s = p0.dst(x, y) / (scale * speed);
        } else {
            s = speed;
        }
        SpritePosTween t = new SpritePosTween();
        t.start((SpriteActor) a, repeat, count, x, y, s, interpolation, wait ? cb : null);
        ((SpriteActor) a).addTween(t);
    }
    return wait;
}

16 View Complete Implementation : ScreenPositionAction.java
Copyright Apache License 2.0
Author : bladecoder
@Override
public boolean run(VerbRunner cb) {
    Scene s = actor.getScene(w);
    BaseActor a = s.getActor(actor.getActorId(), true);
    if (position != null) {
        float scale = EnginereplacedetManager.getInstance().getScale();
        Viewport viewport = ((SceneScreen) BladeEngine.getAppUI().getScreen(Screens.SCENE_SCREEN)).getViewport();
        Vector3 v = new Vector3(position.x * scale, position.y * scale, 0);
        if (anchor == Anchor.CENTER) {
            v.x += viewport.getWorldWidth() / 2;
            v.y += viewport.getWorldHeight() / 2;
        } else if (anchor == Anchor.TOP_LEFT) {
            v.x += 0;
            v.y += viewport.getWorldHeight();
        } else if (anchor == Anchor.TOP_RIGHT) {
            v.x += viewport.getWorldWidth();
            v.y += viewport.getWorldHeight();
        } else if (anchor == Anchor.BOTTOM_RIGHT) {
            v.x += viewport.getWorldWidth();
            v.y += 0;
        } else if (anchor == Anchor.BOTTOM_LEFT) {
            v.x += 0;
            v.y += 0;
        } else if (anchor == Anchor.TOP) {
            v.x += viewport.getWorldWidth() / 2;
            v.y += viewport.getWorldHeight();
        } else if (anchor == Anchor.BOTTOM) {
            v.x += viewport.getWorldWidth() / 2;
            v.y += 0;
        } else if (anchor == Anchor.LEFT) {
            v.x += 0;
            v.y += viewport.getWorldHeight() / 2;
        } else if (anchor == Anchor.RIGHT) {
            v.x += viewport.getWorldWidth();
            v.y += viewport.getWorldHeight() / 2;
        }
        // viewport.project(v);
        v.x *= viewport.getScreenWidth() / viewport.getWorldWidth();
        v.y *= viewport.getScreenHeight() / viewport.getWorldHeight();
        // v.y = viewport.getScreenHeight() - v.y;
        v.y = Gdx.graphics.getHeight() - v.y;
        if (w.getUIActors().getActors().contains(a))
            w.getUIActors().getCamera().unproject(v, 0, 0, viewport.getScreenWidth(), viewport.getScreenHeight());
        else
            w.getCurrentScene().getCamera().unproject(v, 0, 0, viewport.getScreenWidth(), viewport.getScreenHeight());
        a.setPosition(v.x, v.y);
    }
    return false;
}

16 View Complete Implementation : SetPlayerAction.java
Copyright Apache License 2.0
Author : bladecoder
@Override
public boolean run(VerbRunner cb) {
    Scene s = actor.getScene(w);
    BaseActor a = s.getActor(actor.getActorId(), true);
    s.setPlayer((CharacterActor) a);
    if (inventory != null) {
        w.getInventory().dispose();
        w.setInventory(inventory);
        w.getInventory().loadreplacedets();
        EnginereplacedetManager.getInstance().finishLoading();
        w.getInventory().retrievereplacedets();
    }
    return false;
}

15 View Complete Implementation : I18NHandler.java
Copyright Apache License 2.0
Author : bladecoder
public void extractStrings(Scene scn) {
    HashMap<String, Verb> verbs = scn.getVerbManager().getVerbs();
    for (Verb v : verbs.values()) extractStrings(scn.getId(), null, v);
    for (BaseActor a : scn.getActors().values()) {
        extractStrings(scn.getId(), a);
    }
}