ProjectModel.java

Go to the documentation of this file.

/*
 * Gridarta MMORPG map editor for Crossfire, Daimonin and similar games.
 * Copyright (C) 2000-2023 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.project;
 
import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.net.URISyntaxException;
import java.net.URL;
import java.util.Collections;
import java.util.Map;
import net.sf.gridarta.model.anim.AnimationObjects;
import net.sf.gridarta.model.anim.DefaultAnimationObjects;
import net.sf.gridarta.model.archetype.Archetype;
import net.sf.gridarta.model.archetype.ArchetypeFactory;
import net.sf.gridarta.model.archetypechooser.ArchetypeChooserModel;
import net.sf.gridarta.model.archetypeset.ArchetypeSet;
import net.sf.gridarta.model.archetypetype.ArchetypeAttributeFactory;
import net.sf.gridarta.model.archetypetype.ArchetypeAttributeParser;
import net.sf.gridarta.model.archetypetype.ArchetypeTypeParser;
import net.sf.gridarta.model.archetypetype.ArchetypeTypeSet;
import net.sf.gridarta.model.archetypetype.ArchetypeTypeSetParser;
import net.sf.gridarta.model.archetypetype.DefaultArchetypeAttributeFactory;
import net.sf.gridarta.model.autojoin.AutojoinLists;
import net.sf.gridarta.model.autojoin.AutojoinListsParser;
import net.sf.gridarta.model.configsource.ConfigSource;
import net.sf.gridarta.model.errorview.ErrorView;
import net.sf.gridarta.model.errorview.ErrorViewCategory;
import net.sf.gridarta.model.errorview.ErrorViewCollector;
import net.sf.gridarta.model.errorview.ErrorViewCollectorErrorHandler;
import net.sf.gridarta.model.face.ArchFaceProvider;
import net.sf.gridarta.model.face.DefaultFaceObjects;
import net.sf.gridarta.model.face.FaceObjectProviders;
import net.sf.gridarta.model.face.FaceObjects;
import net.sf.gridarta.model.gameobject.GameObject;
import net.sf.gridarta.model.gameobject.GameObjectFactory;
import net.sf.gridarta.model.io.AbstractArchetypeParser;
import net.sf.gridarta.model.io.DefaultMapReaderFactory;
import net.sf.gridarta.model.io.DefaultMapWriter;
import net.sf.gridarta.model.io.GameObjectParser;
import net.sf.gridarta.model.io.GameObjectParserFactory;
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.maparchobject.MapArchObject;
import net.sf.gridarta.model.maparchobject.MapArchObjectFactory;
import net.sf.gridarta.model.mapcontrol.MapControlFactory;
import net.sf.gridarta.model.mapmanager.AbstractMapManager;
import net.sf.gridarta.model.mapmanager.DefaultMapManager;
import net.sf.gridarta.model.mapmanager.DefaultPickmapManager;
import net.sf.gridarta.model.mapmanager.MapManager;
import net.sf.gridarta.model.mapmodel.InsertionMode;
import net.sf.gridarta.model.mapmodel.MapModelFactory;
import net.sf.gridarta.model.mapmodel.TopmostInsertionMode;
import net.sf.gridarta.model.match.GameObjectMatcher;
import net.sf.gridarta.model.match.GameObjectMatchers;
import net.sf.gridarta.model.match.GameObjectMatchersParser;
import net.sf.gridarta.model.resource.AbstractResources;
import net.sf.gridarta.model.settings.ProjectSettings;
import net.sf.gridarta.model.smoothface.SmoothFaces;
import net.sf.gridarta.model.spells.ArchetypeSetSpellLoader;
import net.sf.gridarta.model.spells.GameObjectSpell;
import net.sf.gridarta.model.spells.NumberSpell;
import net.sf.gridarta.model.spells.Spells;
import net.sf.gridarta.model.spells.XMLSpellLoader;
import net.sf.gridarta.model.treasurelist.TreasureListsParser;
import net.sf.gridarta.model.treasurelist.TreasureLoader;
import net.sf.gridarta.model.treasurelist.TreasureTree;
import net.sf.gridarta.model.treasurelist.TreasureTreeNode;
import net.sf.gridarta.model.validation.DefaultValidatorPreferences;
import net.sf.gridarta.model.validation.DelegatingMapValidator;
import net.sf.gridarta.model.validation.NoSuchValidatorException;
import net.sf.gridarta.model.validation.ValidatorPreferences;
import net.sf.gridarta.model.validation.checks.ArchetypeTypeChecks;
import net.sf.gridarta.model.validation.checks.AttributeRangeChecker;
import net.sf.gridarta.model.validation.checks.EnvironmentChecker;
import net.sf.gridarta.model.validation.checks.PaidItemShopSquareChecker;
import net.sf.gridarta.model.validation.checks.ShopSquareChecker;
import net.sf.gridarta.model.validation.checks.ValidatorFactory;
import net.sf.gridarta.plugin.PluginModel;
import net.sf.gridarta.plugin.PluginModelLoader;
import net.sf.gridarta.plugin.PluginModelParser;
import net.sf.gridarta.plugin.PluginParameters;
import net.sf.gridarta.plugin.parameter.PluginParameterFactory;
import net.sf.gridarta.utils.CommonConstants;
import net.sf.gridarta.utils.IOUtils;
import net.sf.gridarta.utils.ResourceIcons;
import net.sf.gridarta.utils.StringUtils;
import net.sf.gridarta.utils.xml.ParseUtils;
import net.sf.japi.swing.action.ActionBuilder;
import net.sf.japi.swing.action.ActionBuilderFactory;
import nu.xom.Document;
import nu.xom.ParsingException;
import nu.xom.xinclude.XIncludeException;
import org.apache.log4j.Category;
import org.apache.log4j.Logger;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.xml.sax.SAXException;
 
public class ProjectModel<G extends GameObject<G, A, R>, A extends MapArchObject<A>, R extends Archetype<G, A, R>> {
 
    @NotNull
    private static final Category LOG = Logger.getLogger(ProjectModel.class);
 
    @NotNull
    private final ProjectSettings projectSettings;
 
    @NotNull
    private final ArchetypeTypeSet archetypeTypeSet;
 
    @NotNull
    private final GameObjectFactory<G, A, R> gameObjectFactory;
 
    @NotNull
    private final ArchetypeSet<G, A, R> archetypeSet;
 
    @NotNull
    private final AbstractMapManager<G, A, R> mapManager;
 
    @NotNull
    private final GameObjectMatchers gameObjectMatchers;
 
    @NotNull
    private final GameObjectParser<G, A, R> gameObjectParser;
 
    @NotNull
    private final SmoothFaces smoothFaces;
 
    @NotNull
    private final FaceObjectProviders faceObjectProviders;
 
    @NotNull
    private final DelegatingMapValidator<G, A, R> validators;
 
    @NotNull
    private final AnimationObjects animationObjects;
 
    @NotNull
    private final AbstractResources<G, A, R> resources;
 
    @NotNull
    private final MapManager<G, A, R> pickmapManager;
 
    @NotNull
    private final MapArchObjectFactory<A> mapArchObjectFactory;
 
    @NotNull
    private final MapModelFactory<G, A, R> mapModelFactory;
 
    @NotNull
    private final FaceObjects faceObjects;
 
    @NotNull
    private final DefaultMapReaderFactory<G, A, R> mapReaderFactory;
 
    @NotNull
    private final Spells<GameObjectSpell<G, A, R>> gameObjectSpells;
 
    @NotNull
    private final Spells<NumberSpell> numberSpells;
 
    @NotNull
    private final InsertionMode topmostInsertionMode = new TopmostInsertionMode();
 
    @NotNull
    private final ArchetypeChooserModel<G, A, R> archetypeChooserModel = new ArchetypeChooserModel<>();
 
    @NotNull
    private final TreasureTree treasureTree;
 
    @NotNull
    private final PathManager pathManager;
 
    @NotNull
    private final PluginModel<G, A, R> pluginModel;
 
    public ProjectModel(@NotNull final ErrorView errorView, @NotNull final ProjectSettings projectSettings, @NotNull final ProjectFactory<G, A, R> projectFactory, @NotNull final ResourceIcons resourceIcons, @NotNull final ConfigSource configSource) {
        this.projectSettings = projectSettings;
        archetypeTypeSet = loadArchetypeTypeSet(errorView, projectSettings);
        final int doubleFaceOffset = projectFactory.getDoubleFaceOffset();
        faceObjects = new DefaultFaceObjects(projectFactory.getIncludeFaceNumbers());
        smoothFaces = new SmoothFaces(faceObjects);
        faceObjectProviders = new FaceObjectProviders(doubleFaceOffset, faceObjects, resourceIcons);
        animationObjects = new DefaultAnimationObjects();
        final ArchetypeFactory<G, A, R> archetypeFactory = projectFactory.newArchetypeFactory(faceObjectProviders, animationObjects);
        gameObjectFactory = projectFactory.newGameObjectFactory(faceObjectProviders, animationObjects, archetypeTypeSet);
        archetypeSet = projectFactory.newArchetypeSet(projectSettings, archetypeFactory);
        final GameObjectParserFactory<G, A, R> gameObjectParserFactory = projectFactory.newGameObjectParserFactory(gameObjectFactory, archetypeSet, archetypeTypeSet);
        gameObjectParser = gameObjectParserFactory.newGameObjectParser();
        final AbstractArchetypeParser<G, A, R, ?> archetypeParser = projectFactory.newArchetypeParser(errorView, gameObjectParser, animationObjects, archetypeSet, gameObjectFactory, projectSettings, smoothFaces);
        final ArchFaceProvider archFaceProvider = new ArchFaceProvider();
        resources = projectFactory.newResources(gameObjectParser, archetypeSet, archetypeParser, faceObjects, animationObjects, archFaceProvider, faceObjectProviders, smoothFaces);
        loadArchetypes(errorView, projectSettings, archetypeSet, archetypeChooserModel, resources, configSource);
        faceObjectProviders.addFaceObjectProvidersListener(archetypeSet::connectFaces);
        final MapArchObjectParserFactory<A> mapArchObjectParserFactory = projectFactory.newMapArchObjectParserFactory();
        mapArchObjectFactory = projectFactory.newMapArchObjectFactory(projectSettings);
        mapReaderFactory = new DefaultMapReaderFactory<>(mapArchObjectFactory, mapArchObjectParserFactory, gameObjectParserFactory);
        final MapWriter<G, A, R> mapWriter = new DefaultMapWriter<>(mapArchObjectParserFactory, gameObjectParser);
        final ValidatorPreferences validatorPreferences = new DefaultValidatorPreferences();
        gameObjectMatchers = loadGameObjectMatchers(errorView, projectSettings);
        final AutojoinLists<G, A, R> autojoinLists = AutojoinListsParser.loadList(errorView, archetypeSet, projectSettings.getConfigurationDirectory());
        mapModelFactory = new MapModelFactory<>(archetypeChooserModel, autojoinLists, gameObjectFactory, gameObjectMatchers, topmostInsertionMode);
        final MapControlFactory<G, A, R> mapControlFactory = projectFactory.newMapControlFactory(mapWriter, projectSettings, mapModelFactory);
        pathManager = new PathManager(projectSettings);
        mapManager = new DefaultMapManager<>(mapReaderFactory, mapControlFactory, projectSettings, faceObjectProviders, pathManager);
        validators = loadValidators(errorView, projectFactory, projectSettings, gameObjectMatchers, archetypeTypeSet, validatorPreferences, mapWriter, mapManager);
        pickmapManager = new DefaultPickmapManager<>(mapReaderFactory, mapControlFactory, projectSettings, faceObjectProviders, pathManager);
        gameObjectSpells = loadArchetypeSpells(projectFactory.getSpellType(), gameObjectFactory, archetypeSet);
        numberSpells = loadSpellFile(projectFactory.getSpellFile(), errorView, projectSettings);
        final Map<String, TreasureTreeNode> specialTreasureLists = loadSpecialTreasureLists(errorView, projectSettings);
        treasureTree = TreasureLoader.parseTreasures(errorView, specialTreasureLists, configSource, projectSettings);
        final PluginParameterFactory<G, A, R> pluginParameterFactory = new PluginParameterFactory<>(archetypeSet, mapManager, projectSettings, pathManager);
        final PluginModelParser<G, A, R> pluginModelParser = new PluginModelParser<>(pluginParameterFactory);
        pluginModel = PluginModelLoader.loadPlugins(pluginParameterFactory, pluginModelParser, errorView, new File(projectSettings.getMapsDirectory(), projectFactory.getScriptsDir()));
    }
 
    @NotNull
    private static ArchetypeTypeSet loadArchetypeTypeSet(@NotNull final ErrorView errorView, @NotNull final ProjectSettings projectSettings) {
        final ArchetypeAttributeFactory archetypeAttributeFactory = new DefaultArchetypeAttributeFactory();
        final ArchetypeAttributeParser archetypeAttributeParser = new ArchetypeAttributeParser(archetypeAttributeFactory);
        final ArchetypeTypeParser archetypeTypeParser = new ArchetypeTypeParser(archetypeAttributeParser);
        try {
            final URL url = IOUtils.getResource(projectSettings.getConfigurationDirectory(), CommonConstants.TYPEDEF_FILE);
            final ErrorViewCollector typesErrorViewCollector = new ErrorViewCollector(errorView, url);
            final Document document = ParseUtils.readXmlUrl(url, "types", "types.dtd", "/system/dtd/types.dtd", new ErrorViewCollectorErrorHandler(typesErrorViewCollector, ErrorViewCategory.GAMEOBJECTMATCHERS_FILE_INVALID));
            final ArchetypeTypeSetParser archetypeTypeSetParser = new ArchetypeTypeSetParser(archetypeTypeParser);
            return archetypeTypeSetParser.loadTypesFromXML(typesErrorViewCollector, document);
        } catch (final IOException | ParsingException | SAXException | URISyntaxException | XIncludeException ex) {
            errorView.addWarning(ErrorViewCategory.TYPES_FILE_INVALID, CommonConstants.TYPEDEF_FILE + ": " + ex.getMessage());
        }
        return new ArchetypeTypeSet();
    }
 
    private static <G extends GameObject<G, A, R>, A extends MapArchObject<A>, R extends Archetype<G, A, R>> void loadArchetypes(@NotNull final ErrorView errorView, @NotNull final ProjectSettings projectSettings, @NotNull final ArchetypeSet<G, A, R> archetypeSet, @NotNull final ArchetypeChooserModel<G, A, R> archetypeChooserModel, @NotNull final AbstractResources<G, A, R> resources, @NotNull final ConfigSource configSource) {
        final long timeStart = System.currentTimeMillis();
        if (LOG.isInfoEnabled()) {
            LOG.info("Start to load archetypes...");
        }
        configSource.read(projectSettings, resources, errorView);
        addArchetypes(archetypeChooserModel, archetypeSet);
        if (LOG.isInfoEnabled()) {
            LOG.info("Archetype loading took " + (System.currentTimeMillis() - timeStart) / 1000.0 + " seconds.");
        }
    }
 
    private static <G extends GameObject<G, A, R>, A extends MapArchObject<A>, R extends Archetype<G, A, R>> void addArchetypes(@NotNull final ArchetypeChooserModel<G, A, R> archetypeChooserModel, @NotNull final ArchetypeSet<G, A, R> archetypeSet) {
        for (final R archetype : archetypeSet.getArchetypes()) {
            final CharSequence editorFolder = archetype.getEditorFolder();
            if (editorFolder != null && !editorFolder.equals(GameObject.EDITOR_FOLDER_INTERN)) {
                final String[] tmp = StringUtils.PATTERN_SLASH.split(editorFolder, 2);
                if (tmp.length == 2) {
                    final String panelName = tmp[0];
                    final String folderName = tmp[1];
                    archetypeChooserModel.addArchetype(panelName, folderName, archetype);
                }
            }
        }
    }
 
    @NotNull
    private static GameObjectMatchers loadGameObjectMatchers(@NotNull final ErrorView errorView, @NotNull final ProjectSettings projectSettings) {
        final GameObjectMatchers gameObjectMatchers = new GameObjectMatchers();
        final URL url;
        try {
            url = IOUtils.getResource(projectSettings.getConfigurationDirectory(), "GameObjectMatchers.xml");
        } catch (final IOException ex) {
            errorView.addWarning(ErrorViewCategory.GAMEOBJECTMATCHERS_FILE_INVALID, "GameObjectMatchers.xml: " + ex.getMessage());
            return gameObjectMatchers;
        }
        final ErrorViewCollector gameObjectMatchersErrorViewCollector = new ErrorViewCollector(errorView, url);
        try {
            final Document document = ParseUtils.readXmlUrl(url, "GameObjectMatchers", "GameObjectMatchers.dtd", "/system/dtd/GameObjectMatchers.dtd", new ErrorViewCollectorErrorHandler(gameObjectMatchersErrorViewCollector, ErrorViewCategory.GAMEOBJECTMATCHERS_FILE_INVALID));
            GameObjectMatchersParser.readGameObjectMatchers(document, gameObjectMatchers, gameObjectMatchersErrorViewCollector);
        } catch (final IOException | ParsingException | SAXException | URISyntaxException | XIncludeException ex) {
            gameObjectMatchersErrorViewCollector.addWarning(ErrorViewCategory.GAMEOBJECTMATCHERS_FILE_INVALID, ex.getMessage());
        }
        return gameObjectMatchers;
    }
 
    @NotNull
    private static <G extends GameObject<G, A, R>, A extends MapArchObject<A>, R extends Archetype<G, A, R>> DelegatingMapValidator<G, A, R> loadValidators(@NotNull final ErrorView errorView, @NotNull final ProjectFactory<G, A, R> projectFactory, @NotNull final ProjectSettings projectSettings, @NotNull final GameObjectMatchers gameObjectMatchers, @NotNull final ArchetypeTypeSet archetypeTypeSet, @NotNull final ValidatorPreferences validatorPreferences, @NotNull final MapWriter<G, A, R> mapWriter, @NotNull final MapManager<G, A, R> mapManager) {
        final DelegatingMapValidator<G, A, R> validators = new DelegatingMapValidator<>(validatorPreferences);
        final EnvironmentChecker<G, A, R> environmentChecker = new EnvironmentChecker<>(validatorPreferences);
        final ValidatorFactory<G, A, R> validatorFactory = new ValidatorFactory<>(validatorPreferences, gameObjectMatchers, projectSettings, mapWriter, mapManager);
        loadValidators(validators, validatorFactory, errorView);
        final AttributeRangeChecker<G, A, R> attributeRangeChecker = projectFactory.loadAttributeRangeChecker(new ErrorViewCollector(errorView, new File("GameObjectMatchers.xml")), gameObjectMatchers, validatorPreferences);
        validators.addValidator(attributeRangeChecker);
        validators.addValidator(environmentChecker);
        ArchetypeTypeChecks.addChecks(archetypeTypeSet, attributeRangeChecker, environmentChecker);
        final GameObjectMatcher shopSquareMatcher = gameObjectMatchers.getMatcher("system_shop_square", "shop_square");
        if (shopSquareMatcher != null) {
            final GameObjectMatcher noSpellsMatcher = gameObjectMatchers.getMatcher("system_no_spells", "no_spells");
            if (noSpellsMatcher != null) {
                final GameObjectMatcher blockedMatcher = gameObjectMatchers.getMatcher("system_blocked", "blocked");
                validators.addValidator(new ShopSquareChecker<>(validatorPreferences, shopSquareMatcher, noSpellsMatcher, blockedMatcher));
            }
 
            final GameObjectMatcher paidItemMatcher = gameObjectMatchers.getMatcher("system_paid_item");
            if (paidItemMatcher != null) {
                validators.addValidator(new PaidItemShopSquareChecker<>(validatorPreferences, shopSquareMatcher, paidItemMatcher));
            }
        }
        return validators;
    }
 
    private static <G extends GameObject<G, A, R>, A extends MapArchObject<A>, R extends Archetype<G, A, R>> void loadValidators(@NotNull final DelegatingMapValidator<G, A, R> validators, @NotNull final ValidatorFactory<G, A, R> validatorFactory, @NotNull final ErrorView errorView) {
        final ActionBuilder actionBuilder = ActionBuilderFactory.getInstance().getActionBuilder("net.sf.gridarta");
        int id = 0;
        while (true) {
            final String spec = actionBuilder.getString("validator." + id);
            if (spec == null) {
                break;
            }
            try {
                validators.addValidator(validatorFactory.newValidator(spec));
            } catch (final NoSuchValidatorException ex) {
                errorView.addWarning(ErrorViewCategory.MAP_VALIDATOR_ENTRY_INVALID, id, ex.getMessage());
            }
            id++;
        }
        if (LOG.isInfoEnabled()) {
            LOG.info("Loaded " + id + " map validators.");
        }
    }
 
    @NotNull
    private static <G extends GameObject<G, A, R>, A extends MapArchObject<A>, R extends Archetype<G, A, R>> Spells<GameObjectSpell<G, A, R>> loadArchetypeSpells(final int spellType, @NotNull final GameObjectFactory<G, A, R> gameObjectFactory, @NotNull final ArchetypeSet<G, A, R> archetypeSet) {
        final Spells<GameObjectSpell<G, A, R>> gameObjectSpells = new Spells<>();
        if (spellType != 0) {
            new ArchetypeSetSpellLoader<>(gameObjectFactory).load(archetypeSet, spellType, gameObjectSpells);
            gameObjectSpells.sort();
        }
        return gameObjectSpells;
    }
 
    @NotNull
    private static Spells<NumberSpell> loadSpellFile(@Nullable final String spellFile, @NotNull final ErrorView errorView, @NotNull final ProjectSettings projectSettings) {
        @NotNull final Spells<NumberSpell> numberSpells = new Spells<>();
        if (spellFile == null) {
            return numberSpells;
        }
 
        try {
            final URL url = IOUtils.getResource(projectSettings.getConfigurationDirectory(), spellFile);
            final ErrorViewCollector errorViewCollector = new ErrorViewCollector(errorView, url);
            final Document document = ParseUtils.readXmlUrl(url, "spells", "spells.dtd", "/system/dtd/spells.dtd", new ErrorViewCollectorErrorHandler(errorViewCollector, ErrorViewCategory.SPELLS_FILE_INVALID));
            XMLSpellLoader.load(errorViewCollector, document, numberSpells);
        } catch (final IOException | ParsingException | SAXException | URISyntaxException | XIncludeException ex) {
            errorView.addWarning(ErrorViewCategory.SPELLS_FILE_INVALID, spellFile + ": " + ex.getMessage());
        }
        numberSpells.sort();
        return numberSpells;
    }
 
    @NotNull
    private static Map<String, TreasureTreeNode> loadSpecialTreasureLists(@NotNull final ErrorView errorView, @NotNull final ProjectSettings projectSettings) {
        Map<String, TreasureTreeNode> specialTreasureLists;
        try {
            final URL url = IOUtils.getResource(projectSettings.getConfigurationDirectory(), "TreasureLists.xml");
            final ErrorViewCollector treasureListsErrorViewCollector = new ErrorViewCollector(errorView, url);
            try {
                final Document specialTreasureListsDocument = ParseUtils.readXmlUrl(url, "lists", "TreasureLists.dtd", "/system/dtd/TreasureLists.dtd", new ErrorViewCollectorErrorHandler(treasureListsErrorViewCollector, ErrorViewCategory.TREASURES_FILE_INVALID));
                specialTreasureLists = TreasureListsParser.parseTreasureLists(specialTreasureListsDocument);
            } catch (final IOException | ParsingException | SAXException | URISyntaxException | XIncludeException ex) {
                treasureListsErrorViewCollector.addWarning(ErrorViewCategory.TREASURES_FILE_INVALID, ex.getMessage());
                specialTreasureLists = Collections.emptyMap();
            }
        } catch (final FileNotFoundException ex) {
            errorView.addWarning(ErrorViewCategory.TREASURES_FILE_INVALID, "TreasureLists.xml: " + ex.getMessage());
            specialTreasureLists = Collections.emptyMap();
        }
        return specialTreasureLists;
    }
 
    @NotNull
    public ProjectSettings getProjectSettings() {
        return projectSettings;
    }
 
    @NotNull
    public ArchetypeTypeSet getArchetypeTypeSet() {
        return archetypeTypeSet;
    }
 
    @NotNull
    public GameObjectFactory<G, A, R> getGameObjectFactory() {
        return gameObjectFactory;
    }
 
    @NotNull
    public ArchetypeSet<G, A, R> getArchetypeSet() {
        return archetypeSet;
    }
 
    @NotNull
    public AbstractMapManager<G, A, R> getMapManager() {
        return mapManager;
    }
 
    @NotNull
    public GameObjectMatchers getGameObjectMatchers() {
        return gameObjectMatchers;
    }
 
    @NotNull
    public GameObjectParser<G, A, R> getGameObjectParser() {
        return gameObjectParser;
    }
 
    @NotNull
    public FaceObjectProviders getFaceObjectProviders() {
        return faceObjectProviders;
    }
 
    @NotNull
    public SmoothFaces getSmoothFaces() {
        return smoothFaces;
    }
 
    @NotNull
    public DelegatingMapValidator<G, A, R> getValidators() {
        return validators;
    }
 
    @NotNull
    public AnimationObjects getAnimationObjects() {
        return animationObjects;
    }
 
    @NotNull
    public AbstractResources<G, A, R> getResources() {
        return resources;
    }
 
    @NotNull
    public MapManager<G, A, R> getPickmapManager() {
        return pickmapManager;
    }
 
    @NotNull
    public MapArchObjectFactory<A> getMapArchObjectFactory() {
        return mapArchObjectFactory;
    }
 
    @NotNull
    public MapModelFactory<G, A, R> getMapModelFactory() {
        return mapModelFactory;
    }
 
    @NotNull
    public FaceObjects getFaceObjects() {
        return faceObjects;
    }
 
    @NotNull
    public MapReaderFactory<G, A> getMapReaderFactory() {
        return mapReaderFactory;
    }
 
    @NotNull
    public Spells<GameObjectSpell<G, A, R>> getGameObjectSpells() {
        return gameObjectSpells;
    }
 
    @NotNull
    public Spells<NumberSpell> getNumberSpells() {
        return numberSpells;
    }
 
    @NotNull
    public InsertionMode getTopmostInsertionMode() {
        return topmostInsertionMode;
    }
 
    @NotNull
    public ArchetypeChooserModel<G, A, R> getArchetypeChooserModel() {
        return archetypeChooserModel;
    }
 
    @NotNull
    public TreasureTree getTreasureTree() {
        return treasureTree;
    }
 
    @NotNull
    public PathManager getPathManager() {
        return pathManager;
    }
 
    @NotNull
    public PluginModel<G, A, R> getPluginModel() {
        return pluginModel;
    }
 
    @NotNull
    public PluginParameters newPluginParameters(@NotNull final Object rendererFactory) {
        final PluginParameters pluginParameters = new PluginParameters();
        pluginParameters.addPluginParameter("archetypeSet", archetypeSet);
        pluginParameters.addPluginParameter("projectSettings", projectSettings);
        pluginParameters.addPluginParameter("globalSettings", projectSettings); // XXX: for compatibility with existing scripts; should be replaced with "projectSettings"
        pluginParameters.addPluginParameter("mapManager", mapManager);
        pluginParameters.addPluginParameter("validators", validators);
        pluginParameters.addPluginParameter("gameObjectFactory", gameObjectFactory);
        pluginParameters.addPluginParameter("gameObjectMatchers", gameObjectMatchers);
        pluginParameters.addPluginParameter("rendererFactory", rendererFactory);
        return pluginParameters;
    }
 
}