AbstractFilesResourcesReader.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.model.resource;
 
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.Reader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import net.sf.gridarta.model.anim.AnimationObjects;
import net.sf.gridarta.model.anim.AnimationParseException;
import net.sf.gridarta.model.archetype.Archetype;
import net.sf.gridarta.model.archetypeset.ArchetypeSet;
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.face.ArchFaceProvider;
import net.sf.gridarta.model.face.FaceObjects;
import net.sf.gridarta.model.face.FaceProvider;
import net.sf.gridarta.model.gameobject.GameObject;
import net.sf.gridarta.model.io.AbstractArchetypeParser;
import net.sf.gridarta.model.io.AbstractAnimationObjectsReader;
import net.sf.gridarta.model.maparchobject.MapArchObject;
import net.sf.gridarta.utils.FileFilters;
import net.sf.gridarta.utils.IOUtils;
import net.sf.gridarta.utils.Pair;
import org.apache.log4j.Category;
import org.apache.log4j.Logger;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
 
public abstract class AbstractFilesResourcesReader<G extends GameObject<G, A, R>, A extends MapArchObject<A>, R extends Archetype<G, A, R>> extends AbstractResourcesReader<G> {
 
    private static final Category LOG = Logger.getLogger(AbstractFilesResourcesReader.class);
 
    @NotNull
    private final File archDirectory;
 
    @NotNull
    private final ArchetypeSet<G, A, R> archetypeSet;
 
    @NotNull
    private final AbstractArchetypeParser<G, A, R, ?> archetypeParser;
 
    @NotNull
    private final AnimationObjects animationObjects;
 
    @NotNull
    private final ArchFaceProvider archFaceProvider;
 
    @NotNull
    private final AbstractAnimationObjectsReader animationObjectsReader;
 
    protected AbstractFilesResourcesReader(@NotNull final File archDirectory, @NotNull final ArchetypeSet<G, A, R> archetypeSet, @NotNull final AbstractArchetypeParser<G, A, R, ?> archetypeParser, @NotNull final ArchFaceProvider archFaceProvider, @NotNull final File collectedDirectory, @Nullable final String imageSet, @NotNull final AnimationObjects animationObjects, @NotNull final FaceObjects faceObjects, @NotNull final AbstractAnimationObjectsReader animationObjectsReader) {
        super(collectedDirectory, imageSet, animationObjects, faceObjects);
        this.archDirectory = archDirectory;
        this.archetypeSet = archetypeSet;
        this.archetypeParser = archetypeParser;
        this.archFaceProvider = archFaceProvider;
        this.animationObjects = animationObjects;
        this.animationObjectsReader = animationObjectsReader;
    }
 
    @NotNull
    @Override
    public FaceProvider read(@NotNull final ErrorView errorView, @NotNull final List<G> invObjects) {
        archetypeSet.setLoadedFromArchive(false);
        final int animationObjectsSize = animationObjects.size();
        final int archetypeCount = archetypeSet.getArchetypeCount();
        final Collection<Pair<String, File>> animFiles = new ArrayList<>();
        final ErrorViewCollector archDirectoryErrorViewCollector = new ErrorViewCollector(errorView, archDirectory);
        loadArchetypesFromFiles(archDirectoryErrorViewCollector, archetypeParser, "", archDirectory, 0, "default", "default", invObjects, archFaceProvider, errorView, animFiles);
        loadAnimationsFromFiles(archDirectoryErrorViewCollector, animFiles);
        if (LOG.isInfoEnabled()) {
            LOG.info("Loaded " + (animationObjects.size() - animationObjectsSize) + " animations from '" + archDirectory + "'.");
        }
        if (LOG.isInfoEnabled()) {
            LOG.info("Loaded " + (archetypeSet.getArchetypeCount() - archetypeCount) + " archetypes from '" + archDirectory + "'.");
        }
        if (LOG.isInfoEnabled()) {
            LOG.info("Loaded " + archFaceProvider.size() + " faces from '" + archDirectory + "'.");
        }
        return archFaceProvider;
    }
 
    private void loadArchetypesFromFiles(@NotNull final ErrorViewCollector errorViewCollector, @NotNull final AbstractArchetypeParser<G, A, R, ?> archetypeParser, @NotNull final String path, @NotNull final File f, final int folderLevel, @NotNull final String panelName, @NotNull final String folderName, @NotNull final List<G> invObjects, @NotNull final ArchFaceProvider archFaceProvider, @NotNull final ErrorView errorView, @NotNull final Collection<Pair<String, File>> animFiles) {
        final String name = f.getName();
        if (f.isDirectory()) {
            // now, setup the archetype panels
            if (isValidEntry(folderLevel, name)) {
                final String[] entries = f.list();
                if (entries == null) {
                    errorViewCollector.addWarning(ErrorViewCategory.ARCHETYPE_DIR_INVALID, f.getPath());
                } else {
                    Arrays.sort(entries);
                    final String thisPanelName = folderLevel == 1 ? name : panelName;
                    final String thisFolderName = folderLevel == 1 || folderLevel == 2 ? name : folderName;
                    final String newPath = folderLevel == 0 ? "" : path + "/" + name;
                    for (final String entry : entries) {
                        loadArchetypesFromFiles(errorViewCollector, archetypeParser, newPath, new File(f, entry), folderLevel + 1, thisPanelName, thisFolderName, invObjects, archFaceProvider, errorView, animFiles);
                    }
                }
            }
        } else if (f.isFile()) { // watch out for stuff that's not a file and not a directory!!!
            if (FileFilters.ARC_FILE_FILTER.accept(f)) {
                try {
                    try (FileInputStream fis = new FileInputStream(f)) {
                        try (InputStreamReader isr = new InputStreamReader(fis, IOUtils.MAP_ENCODING)) {
                            try (BufferedReader in = new BufferedReader(isr)) {
                                archetypeParser.parseArchetypeFromStream(in, null, null, null, panelName, folderName, path, invObjects, new ErrorViewCollector(errorView, f));
                            }
                        }
                    }
                } catch (final IOException ex) {
                    new ErrorViewCollector(errorView, f).addWarning(ErrorViewCategory.ARCHETYPE_FILE_INVALID, ex.getMessage());
                }
            } else if (FileFilters.PNG_FILE_FILTER.accept(f)) {
                if (archetypeSet.getImageSet() == null || name.contains("." + archetypeSet.getImageSet() + ".")) {
                    addPNGFace(f.getAbsolutePath(), path, name, errorView, archFaceProvider);
                }
            } else if (FileFilters.FACE_FILE_FILTER.accept(f)) {
                parseDefFace(errorView, f.getAbsolutePath(), path);
            } else if (FileFilters.ANIM_FILE_FILTER.accept(f)) {
                animFiles.add(new Pair<>(path, f));
            }
        }
    }
 
    private void parseDefFace(@NotNull final ErrorView errorView, @NotNull final String path, @NotNull final String filename) {
        final ErrorViewCollector errorViewCollector = new ErrorViewCollector(errorView, new File(path));
        try {
            try (FileInputStream fis = new FileInputStream(path)) {
                try (InputStreamReader isr = new InputStreamReader(fis, IOUtils.MAP_ENCODING)) {
                    try (Reader in = new BufferedReader(isr)) {
                        animationObjectsReader.loadAnimations(animationObjects, errorViewCollector, in, "animation ", filename, null);
                    }
                }
            }
        } catch (final IOException ex) {
            errorViewCollector.addWarning(ErrorViewCategory.FACE_FILE_INVALID, ex.getMessage());
        } catch (final AnimationParseException ex) {
            errorViewCollector.addWarning(ErrorViewCategory.FACE_FILE_INVALID, "line " + ex.getLineNumber() + ": parsing error: " + ex.getMessage());
        }
    }
 
    private void loadAnimationsFromFiles(@NotNull final ErrorViewCollector errorViewCollector, @NotNull final Iterable<Pair<String, File>> animFiles) {
        for (final Pair<String, File> pair : animFiles) {
            final String animPath = pair.getFirst();
            final File animFile = pair.getSecond();
            try {
                animationObjectsReader.loadAnimations(animationObjects, errorViewCollector, animPath, animFile, "anim ");
            } catch (final IOException ex) {
                errorViewCollector.addWarning(ErrorViewCategory.ANIM_FILE_INVALID, ex.getMessage() + ", " + animFile);
            } catch (final AnimationParseException ex) {
                errorViewCollector.addWarning(ErrorViewCategory.ANIM_ENTRY_INVALID, "line " + ex.getLineNumber() + ": parsing error: " + ex.getMessage() + ", " + animFile);
            }
        }
    }
 
    protected abstract boolean isValidEntry(int folderLevel, String name);
 
}