DeletionTool.java

Go to the documentation of this file.

/*
 * Gridarta MMORPG map editor for Crossfire, Daimonin and similar games.
 * Copyright (C) 2000-2015 The Gridarta Developers.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */

package net.sf.gridarta.gui.panel.tools;

import java.awt.Component;
import java.awt.Container;
import java.awt.GridBagConstraints;
import java.awt.GridBagLayout;
import java.awt.Point;
import java.util.Collection;
import java.util.HashSet;
import javax.swing.JComboBox;
import javax.swing.JPanel;
import net.sf.gridarta.gui.map.event.MouseOpEvent;
import net.sf.gridarta.gui.panel.objectchooser.ObjectChooser;
import net.sf.gridarta.gui.utils.SwingUtils;
import net.sf.gridarta.model.archetype.Archetype;
import net.sf.gridarta.model.gameobject.GameObject;
import net.sf.gridarta.model.maparchobject.MapArchObject;
import net.sf.gridarta.model.mapcontrol.MapControl;
import net.sf.gridarta.model.mapcursor.MapCursor;
import net.sf.gridarta.model.mapmodel.MapModel;
import net.sf.gridarta.model.mapmodel.MapSquare;
import net.sf.gridarta.model.mapviewsettings.MapViewSettings;
import net.sf.gridarta.model.match.GameObjectMatcher;
import net.sf.gridarta.model.pickmapsettings.PickmapSettings;
import net.sf.gridarta.utils.ActionBuilderUtils;
import net.sf.japi.swing.action.ActionBuilder;
import net.sf.japi.swing.action.ActionBuilderFactory;
import net.sf.japi.swing.action.ActionMethod;
import net.sf.japi.swing.action.ToggleAction;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;

public class DeletionTool<G extends GameObject<G, A, R>, A extends MapArchObject<A>, R extends Archetype<G, A, R>> extends BasicAbstractTool<G, A, R> {

    private static final int DELETE_TOPMOST = 0;

    private static final int DELETE_ALL = 1;

    private static final int DELETE_BOTTOMMOST = 2;

    private static final int SCOPE_SQUARE = 0;

    private static final int SCOPE_ABOVE_FLOOR = 1;

    private static final int SCOPE_BELOW_FLOOR = 2;

    private static final int SCOPE_SELECTED_OBJECT = 3;

    private static final int SCOPE_WALL = 4;

    private static final int SCOPE_FLOOR = 5;

    @NotNull
    private static final ActionBuilder ACTION_BUILDER = ActionBuilderFactory.getInstance().getActionBuilder("net.sf.gridarta.gui.panel.tools");

    @NotNull
    private final MapViewSettings mapViewSettings;

    @Nullable
    private final GameObjectMatcher floorGameObjectMatcher;

    @Nullable
    private final GameObjectMatcher wallGameObjectMatcher;

    @Nullable
    private final GameObjectMatcher monsterGameObjectMatcher;

    @NotNull
    private final ObjectChooser<G, A, R> objectChooser;

    @NotNull
    private final PickmapSettings pickmapSettings;

    @NotNull
    private final ToggleAction ignoreWallsAction = (ToggleAction) ACTION_BUILDER.createToggle(true, "deletionToolExceptionsIgnoreWalls", this);

    @NotNull
    private final ToggleAction ignoreFloorsAction = (ToggleAction) ACTION_BUILDER.createToggle(true, "deletionToolExceptionsIgnoreFloors", this);

    @NotNull
    private final ToggleAction ignoreMonstersAction = (ToggleAction) ACTION_BUILDER.createToggle(true, "deletionToolExceptionsIgnoreMonsters", this);

    private boolean deletionToolExceptionsIgnoreWalls;

    private boolean deletionToolExceptionsIgnoreFloors;

    private boolean deletionToolExceptionsIgnoreMonsters;

    @NotNull
    private final JComboBox<?> deleteComboBox = createDeleteComboBox();

    @NotNull
    private final JComboBox<?> scopeComboBox = createScopeComboBox();

    public DeletionTool(@NotNull final MapViewSettings mapViewSettings, @NotNull final ObjectChooser<G, A, R> objectChooser, @NotNull final PickmapSettings pickmapSettings, @Nullable final GameObjectMatcher floorGameObjectMatcher, @Nullable final GameObjectMatcher wallGameObjectMatcher, @Nullable final GameObjectMatcher monsterGameObjectMatcher) {
        super("deletion");
        this.mapViewSettings = mapViewSettings;
        this.objectChooser = objectChooser;
        this.pickmapSettings = pickmapSettings;
        this.floorGameObjectMatcher = floorGameObjectMatcher;
        this.wallGameObjectMatcher = wallGameObjectMatcher;
        this.monsterGameObjectMatcher = monsterGameObjectMatcher;
    }

    @Override
    public void pressed(@NotNull final MouseOpEvent<G, A, R> e) {
        final Point mapLoc = e.getMapLocation();
        final MapCursor<G, A, R> mapCursor = e.getMapCursor();
        final MapControl<G, A, R> mapControl = e.getMapControl();
        mapCursor.setLocationSafe(mapLoc);
        if (mapLoc != null) {
            // delete the topmost arch (matching the view settings) on that square and redraw the map
            deleteArch(mapLoc, mapControl);
        }
    }

    @Override
    public void released(@NotNull final MouseOpEvent<G, A, R> e) {

    }

    @Override
    public void clicked(@NotNull final MouseOpEvent<G, A, R> e) {
    }

    @Override
    public void dragged(@NotNull final MouseOpEvent<G, A, R> e) {
        final Point mapLoc = e.getMapLocation();
        final MapCursor<G, A, R> mapCursor = e.getMapCursor();
        final MapControl<G, A, R> mapControl = e.getMapControl();
        if (mapCursor.setLocationSafe(mapLoc)) {
            // delete the topmost arch (matching the view settings) on that square and redraw the map
            deleteArch(mapLoc, mapControl);
        }
    }

    @Override
    public void moved(@NotNull final MouseOpEvent<G, A, R> e) {
    }

    private void deleteArch(@NotNull final Point mapLoc, @NotNull final MapControl<G, A, R> mapControl) {
        if (mapControl.isPickmap() && pickmapSettings.isLocked()) {
            return;
        }

        final MapSquare<G, A, R> mapSquare = mapControl.getMapModel().getMapSquare(mapLoc);
        final int scopeType = scopeComboBox.getSelectedIndex();
        final int deleteType = deleteComboBox.getSelectedIndex();

        @Nullable final GameObject<G, A, R> start;
        @Nullable final GameObject<G, A, R> end;
        switch (scopeType) {
        case SCOPE_SQUARE:
            start = mapSquare.getFirst();
            end = mapSquare.getLast();
            break;

        case SCOPE_ABOVE_FLOOR:
            start = floorGameObjectMatcher == null ? null : mapSquare.getAfterLast(floorGameObjectMatcher);
            end = mapSquare.getLast();
            break;

        case SCOPE_BELOW_FLOOR:
            start = mapSquare.getFirst();
            end = floorGameObjectMatcher == null ? null : mapSquare.getBeforeFirst(floorGameObjectMatcher);
            break;

        case SCOPE_SELECTED_OBJECT:
            start = mapSquare.getFirst();
            end = mapSquare.getLast();
            break;

        case SCOPE_WALL:
            start = mapSquare.getFirst();
            end = mapSquare.getLast();
            break;

        case SCOPE_FLOOR:
            start = mapSquare.getFirst();
            end = mapSquare.getLast();
            break;

        default:
            return;
        }
        if (start == null || end == null) {
            return;
        }
        final Collection<G> gameObjectsToDelete = new HashSet<>();
        boolean foundFirst = false;
        final GameObject<G, A, R> start2 = deleteType == DELETE_TOPMOST ? end : start;
        final GameObject<G, A, R> end2 = deleteType == DELETE_TOPMOST ? start : end;
        for (final GameObject<G, A, R> gameObject : deleteType == DELETE_TOPMOST ? mapSquare.reverse() : mapSquare) {
            if (gameObject == start2) {
                foundFirst = true;
            }
            if (foundFirst) {
                final G head = gameObject.getHead();
                if (mapViewSettings.isEditType(head)) {
                    boolean insert = false;
                    switch (scopeType) {
                    case SCOPE_SQUARE:
                    case SCOPE_ABOVE_FLOOR:
                    case SCOPE_BELOW_FLOOR:
                        insert = true;
                        break;

                    case SCOPE_SELECTED_OBJECT:
                        if (objectChooser.isMatching(head)) {
                            insert = true;
                        }
                        break;

                    case SCOPE_WALL:
                        if (wallGameObjectMatcher != null && wallGameObjectMatcher.isMatching(head)) {
                            insert = true;
                        }
                        break;

                    case SCOPE_FLOOR:
                        if (floorGameObjectMatcher != null && floorGameObjectMatcher.isMatching(head)) {
                            insert = true;
                        }
                        break;
                    }
                    if (insert) {
                        if (deletionToolExceptionsIgnoreWalls && wallGameObjectMatcher != null && wallGameObjectMatcher.isMatching(head)) {
                            // ignore
                        } else if (deletionToolExceptionsIgnoreFloors && floorGameObjectMatcher != null && floorGameObjectMatcher.isMatching(head)) {
                            // ignore
                        } else if (deletionToolExceptionsIgnoreMonsters && monsterGameObjectMatcher != null && monsterGameObjectMatcher.isMatching(head)) {
                            // ignore
                        } else {
                            gameObjectsToDelete.add(head);
                            if (deleteType != DELETE_ALL) {
                                break;
                            }
                        }
                    }
                }
                if (gameObject == end2) {
                    break;
                }
            }
        }
        if (!gameObjectsToDelete.isEmpty()) {
            final MapModel<G, A, R> mapModel = mapSquare.getMapModel();
            mapModel.beginTransaction("Delete Object");
            try {
                for (final G gameObjectToDelete : gameObjectsToDelete) {
                    mapModel.removeGameObject(gameObjectToDelete, mapViewSettings.isAutojoin());
                }
            } finally {
                mapModel.endTransaction();
            }
        }
    }

    @Nullable
    @Override
    public Component createOptionsView() {
        final Container panel = new JPanel();
        panel.setLayout(new GridBagLayout());

        final GridBagConstraints gbcLabel = new GridBagConstraints();
        gbcLabel.anchor = GridBagConstraints.EAST;

        final GridBagConstraints gbcComboBox = new GridBagConstraints();
        gbcComboBox.fill = GridBagConstraints.HORIZONTAL;
        gbcComboBox.weightx = 1.0;
        gbcComboBox.gridwidth = GridBagConstraints.REMAINDER;

        final GridBagConstraints gbcCheckBox = new GridBagConstraints();
        gbcCheckBox.fill = GridBagConstraints.HORIZONTAL;
        gbcCheckBox.gridwidth = GridBagConstraints.REMAINDER;

        panel.add(SwingUtils.createLabel("deletionTool.delete", deleteComboBox), gbcLabel);
        panel.add(deleteComboBox, gbcComboBox);

        panel.add(SwingUtils.createLabel("deletionTool.scope", scopeComboBox), gbcLabel);
        panel.add(scopeComboBox, gbcComboBox);

        panel.add(ignoreWallsAction.createCheckBox(), gbcCheckBox);
        panel.add(ignoreFloorsAction.createCheckBox(), gbcCheckBox);
        panel.add(ignoreMonstersAction.createCheckBox(), gbcCheckBox);
        return panel;
    }

    @NotNull
    private static JComboBox<?> createDeleteComboBox() {
        final String[] options = { ActionBuilderUtils.getString(ACTION_BUILDER, "deletionTool.delete.top"), ActionBuilderUtils.getString(ACTION_BUILDER, "deletionTool.delete.all"), ActionBuilderUtils.getString(ACTION_BUILDER, "deletionTool.delete.bottom"), };
        final JComboBox<?> comboBox = new JComboBox<>(options);
        comboBox.setToolTipText(ActionBuilderUtils.getString(ACTION_BUILDER, "deletionTool.delete.shortdescription"));
        return comboBox;
    }

    @NotNull
    private static JComboBox<?> createScopeComboBox() {
        final String[] options = { ActionBuilderUtils.getString(ACTION_BUILDER, "deletionTool.scope.square"), ActionBuilderUtils.getString(ACTION_BUILDER, "deletionTool.scope.aboveFloor"), ActionBuilderUtils.getString(ACTION_BUILDER, "deletionTool.scope.belowFloor"), ActionBuilderUtils.getString(ACTION_BUILDER, "deletionTool.scope.selectedObject"), ActionBuilderUtils.getString(ACTION_BUILDER, "deletionTool.scope.wall"), ActionBuilderUtils.getString(ACTION_BUILDER, "deletionTool.scope.floor"), };
        final JComboBox<?> comboBox = new JComboBox<>(options);
        comboBox.setToolTipText(ActionBuilderUtils.getString(ACTION_BUILDER, "deletionTool.scope.shortdescription"));
        return comboBox;
    }

    @ActionMethod
    public boolean isDeletionToolExceptionsIgnoreWalls() {
        return deletionToolExceptionsIgnoreWalls;
    }

    @ActionMethod
    public void setDeletionToolExceptionsIgnoreWalls(final boolean deletionToolExceptionsIgnoreWalls) {
        this.deletionToolExceptionsIgnoreWalls = deletionToolExceptionsIgnoreWalls;
    }

    @ActionMethod
    public boolean isDeletionToolExceptionsIgnoreFloors() {
        return deletionToolExceptionsIgnoreFloors;
    }

    @ActionMethod
    public void setDeletionToolExceptionsIgnoreFloors(final boolean deletionToolExceptionsIgnoreFloors) {
        this.deletionToolExceptionsIgnoreFloors = deletionToolExceptionsIgnoreFloors;
    }

    @ActionMethod
    public boolean isDeletionToolExceptionsIgnoreMonsters() {
        return deletionToolExceptionsIgnoreMonsters;
    }

    @ActionMethod
    public void setDeletionToolExceptionsIgnoreMonsters(final boolean deletionToolExceptionsIgnoreMonsters) {
        this.deletionToolExceptionsIgnoreMonsters = deletionToolExceptionsIgnoreMonsters;
    }

}