TestMapControlCreator.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.model.mapcontrol;

import java.io.File;
import java.io.IOException;
import net.sf.gridarta.model.archetype.DuplicateArchetypeException;
import net.sf.gridarta.model.archetype.TestArchetype;
import net.sf.gridarta.model.archetypechooser.ArchetypeChooserModel;
import net.sf.gridarta.model.archetypeset.ArchetypeSet;
import net.sf.gridarta.model.autojoin.AutojoinListsHelper;
import net.sf.gridarta.model.exitconnector.ExitMatcher;
import net.sf.gridarta.model.gameobject.TestGameObject;
import net.sf.gridarta.model.io.DefaultMapReader;
import net.sf.gridarta.model.io.DefaultMapWriter;
import net.sf.gridarta.model.io.GameObjectParser;
import net.sf.gridarta.model.io.MapArchObjectParserFactory;
import net.sf.gridarta.model.io.MapReaderFactory;
import net.sf.gridarta.model.io.MapWriter;
import net.sf.gridarta.model.io.PathManager;
import net.sf.gridarta.model.io.TestMapArchObjectParserFactory;
import net.sf.gridarta.model.io.TestMapReaderFactory;
import net.sf.gridarta.model.maparchobject.MapArchObjectFactory;
import net.sf.gridarta.model.maparchobject.TestMapArchObject;
import net.sf.gridarta.model.maparchobject.TestMapArchObjectFactory;
import net.sf.gridarta.model.mapmanager.AbstractMapManager;
import net.sf.gridarta.model.mapmanager.DefaultMapManager;
import net.sf.gridarta.model.mapmanager.FileControl;
import net.sf.gridarta.model.mapmanager.MapManager;
import net.sf.gridarta.model.mapmanager.TestFileControl;
import net.sf.gridarta.model.mapmodel.InsertionModeSet;
import net.sf.gridarta.model.mapmodel.MapFile;
import net.sf.gridarta.model.mapmodel.MapModel;
import net.sf.gridarta.model.mapmodel.MapModelFactory;
import net.sf.gridarta.model.mapmodel.TestMapModelCreator;
import net.sf.gridarta.model.mapmodel.TestMapModelHelper;
import net.sf.gridarta.model.match.GameObjectMatcher;
import net.sf.gridarta.model.match.TypeNrsGameObjectMatcher;
import net.sf.gridarta.model.settings.ProjectSettings;
import net.sf.gridarta.model.settings.TestProjectSettings;
import net.sf.gridarta.utils.Size2D;
import net.sf.gridarta.utils.StringUtils;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.junit.Assert;

public class TestMapControlCreator {

    @NotNull
    private final MapManager<TestGameObject, TestMapArchObject, TestArchetype> mapManager;

    @NotNull
    private final MapManager<TestGameObject, TestMapArchObject, TestArchetype> pickmapManager;

    @NotNull
    private final PathManager pathManager;

    @NotNull
    private final ExitMatcher<TestGameObject, TestMapArchObject, TestArchetype> exitMatcher;

    @NotNull
    private final MapArchObjectParserFactory<TestMapArchObject> mapArchObjectParserFactory;

    @NotNull
    private final GameObjectParser<TestGameObject, TestMapArchObject, TestArchetype> gameObjectParser;

    @NotNull
    private final ProjectSettings projectSettings;

    @NotNull
    private final MapArchObjectFactory<TestMapArchObject> mapArchObjectFactory = new TestMapArchObjectFactory();

    @NotNull
    private final MapModelFactory<TestGameObject, TestMapArchObject, TestArchetype> mapModelFactory;

    @NotNull
    private final TestMapModelCreator mapModelCreator = new TestMapModelCreator(false);

    @NotNull
    private final MapWriter<TestGameObject, TestMapArchObject, TestArchetype> mapWriter;

    public TestMapControlCreator() {
        final GameObjectMatcher exitGameObjectMatcher = new TypeNrsGameObjectMatcher(TestMapModelHelper.EXIT_TYPE);
        exitMatcher = new ExitMatcher<>(exitGameObjectMatcher);
        mapArchObjectParserFactory = new TestMapArchObjectParserFactory();
        gameObjectParser = mapModelCreator.newGameObjectParser();
        final MapReaderFactory<TestGameObject, TestMapArchObject> mapReaderFactory = new TestMapReaderFactory(mapArchObjectParserFactory, mapArchObjectFactory, gameObjectParser);
        projectSettings = new TestProjectSettings();
        mapWriter = new DefaultMapWriter<>(mapArchObjectParserFactory, gameObjectParser);
        final ArchetypeChooserModel<TestGameObject, TestMapArchObject, TestArchetype> archetypeChooserModel = new ArchetypeChooserModel<>();
        pathManager = new PathManager(projectSettings);
        mapModelFactory = new MapModelFactory<>(archetypeChooserModel, mapModelCreator.getAutojoinLists(), mapModelCreator.getGameObjectFactory(), mapModelCreator.getGameObjectMatchers(), mapModelCreator.getTopmostInsertionMode());
        final MapControlFactory<TestGameObject, TestMapArchObject, TestArchetype> mapControlFactory = new TestMapControlFactory(mapWriter, projectSettings, mapModelFactory);
        final AbstractMapManager<TestGameObject, TestMapArchObject, TestArchetype> tmpMapManager = new DefaultMapManager<>(mapReaderFactory, mapControlFactory, projectSettings, mapModelCreator.getFaceObjectProviders(), pathManager);
        final FileControl<TestGameObject, TestMapArchObject, TestArchetype> fileControl = new TestFileControl();
        tmpMapManager.setFileControl(fileControl);
        mapManager = tmpMapManager;
        final AbstractMapManager<TestGameObject, TestMapArchObject, TestArchetype> tmpPickmapManager = new DefaultMapManager<>(mapReaderFactory, mapControlFactory, projectSettings, mapModelCreator.getFaceObjectProviders(), pathManager);
        tmpPickmapManager.setFileControl(fileControl);
        pickmapManager = tmpPickmapManager;
    }

    public TestMapModelHelper newMapModelCreator() throws DuplicateArchetypeException {
        return mapModelCreator.newTestMapModelHelper();
    }

    public MapControl<TestGameObject, TestMapArchObject, TestArchetype> newMapControl(@Nullable final MapFile mapFile, @NotNull final String mapName, @NotNull final Size2D mapSize) {
        final TestMapArchObject mapArchObject = mapArchObjectFactory.newMapArchObject(false);
        mapArchObject.setMapSize(mapSize);
        mapArchObject.setMapName(mapName);
        return mapManager.newMap(null, mapArchObject, mapFile, true);
    }

    @NotNull
    public PathManager getPathManager() {
        return pathManager;
    }

    @NotNull
    public ProjectSettings getProjectSettings() {
        return projectSettings;
    }

    @NotNull
    public ExitMatcher<TestGameObject, TestMapArchObject, TestArchetype> getExitMatcher() {
        return exitMatcher;
    }

    @NotNull
    public ArchetypeSet<TestGameObject, TestMapArchObject, TestArchetype> getArchetypeSet() {
        return mapModelCreator.getArchetypeSet();
    }

    @NotNull
    public MapManager<TestGameObject, TestMapArchObject, TestArchetype> getMapManager() {
        return mapManager;
    }

    @NotNull
    public InsertionModeSet<TestGameObject, TestMapArchObject, TestArchetype> getInsertionModeSet() {
        return mapModelCreator.getInsertionModeSet();
    }

    @NotNull
    public AutojoinListsHelper newAutojoinListsHelper() {
        return new AutojoinListsHelper(mapModelCreator);
    }

    @NotNull
    public TestMapModelCreator getMapModelCreator() {
        return mapModelCreator;
    }

    @NotNull
    public MapArchObjectFactory<TestMapArchObject> getMapArchObjectFactory() {
        return mapArchObjectFactory;
    }

    @NotNull
    public MapModelFactory<TestGameObject, TestMapArchObject, TestArchetype> getMapModelFactory() {
        return mapModelFactory;
    }

    @NotNull
    public MapManager<TestGameObject, TestMapArchObject, TestArchetype> getPickmapManager() {
        return pickmapManager;
    }

    @NotNull
    public MapWriter<TestGameObject, TestMapArchObject, TestArchetype> getMapWriter() {
        return mapWriter;
    }

    @NotNull
    public DefaultMapReader<TestGameObject, TestMapArchObject, TestArchetype> newMapReader(@NotNull final File mapFile) throws IOException {
        return new DefaultMapReader<>(mapArchObjectParserFactory, mapArchObjectFactory, gameObjectParser, mapFile);
    }

    @NotNull
    public File createMapsDirectory(@NotNull final String... specs) throws IOException {
        final File mapsDirectory = createTempDir("gridarta");
        projectSettings.setMapsDirectory(mapsDirectory);
        @Nullable File directoryToDelete = mapsDirectory;
        try {
            createMaps(specs);
            directoryToDelete = null;
        } finally {
            if (directoryToDelete != null) {
                deleteTempDir(directoryToDelete);
            }
        }
        return mapsDirectory;
    }

    private void createMaps(@NotNull final String[] specs) throws IOException {
        for (final String spec : specs) {
            final String[] tmp = StringUtils.PATTERN_COLON.split(spec, 2);
            if (tmp.length != 2) {
                throw new IllegalArgumentException();
            }

            final MapFile mapFile = new PathManager(projectSettings).getMapFile(new File(projectSettings.getMapsDirectory(), tmp[0]));
            final String mapName = tmp[1];

            final File file = mapFile.getFile();
            if (!file.getParentFile().exists() && !file.getParentFile().mkdirs()) {
                throw new IOException("cannot create directory: " + file.getParentFile());
            }

            final MapModel<TestGameObject, TestMapArchObject, TestArchetype> mapModel = mapModelCreator.newMapModel(5, 5);
            final MapControl<TestGameObject, TestMapArchObject, TestArchetype> mapControl = new DefaultMapControl<>(mapModel, false, mapWriter, projectSettings);
            mapControl.getMapModel().getMapArchObject().setMapName(mapName);
            mapControl.saveAs(mapFile);
        }
    }

    @NotNull
    private static File createTempDir(@NotNull final String prefix) throws IOException {
        final String tmpDir = System.getProperty("java.io.tmpdir");
        if (tmpDir == null) {
            throw new IOException("the system property 'java.io.tmpdir' does not exist");
        }

        final File tmpFile = new File(tmpDir);
        if (!tmpFile.exists() && !tmpFile.mkdirs()) {
            throw new IOException("cannot create temporary directory " + tmpFile);
        }

        final File result = File.createTempFile(prefix, null);
        if (!result.delete()) {
            throw new IOException("cannot delete temporary file " + result);
        }
        if (!result.mkdir()) {
            throw new IOException("cannot create temporary directory " + result);
        }

        return result;
    }

    public static void deleteTempDir(@NotNull final File dir) {
        final File[] files = dir.listFiles();
        if (files != null) {
            for (final File file : files) {
                if (file.isDirectory()) {
                    deleteTempDir(file);
                } else if (!file.delete()) {
                    Assert.fail("cannot delete file " + file);
                }
            }
        }
        if (!dir.delete()) {
            Assert.fail("cannot delete directory " + dir);
        }
    }

}