MapImageCreator.java

Go to the documentation of this file.

package net.sf.gridarta.action.exportmap;
 
import java.awt.Graphics2D;
import java.awt.Image;
import java.awt.image.BufferedImage;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import net.sf.gridarta.gui.map.renderer.MapRenderer;
import net.sf.gridarta.gui.map.renderer.RendererFactory;
import net.sf.gridarta.model.archetype.Archetype;
import net.sf.gridarta.model.direction.Direction;
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.mapmanager.MapManager;
import net.sf.gridarta.model.mapmodel.MapFile;
import net.sf.gridarta.model.mapmodel.MapModel;
import net.sf.gridarta.model.mapmodel.MapPath;
import net.sf.gridarta.model.mapmodel.MapPathUtils;
import net.sf.gridarta.model.mapmodel.SameMapException;
import net.sf.gridarta.model.mapmodel.UnsavedMapException;
import net.sf.gridarta.utils.Size2D;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
 
public class MapImageCreator<G extends GameObject<G, A, R>, A extends MapArchObject<A>, R extends Archetype<G, A, R>> {
 
    private static final int SCALE = 32;
 
    @NotNull
    private final MapManager<G, A, R> mapManager;
 
    @NotNull
    private final RendererFactory<G, A, R> rendererFactory;
 
    @NotNull
    private final Map<MapFile, LayoutInfo> layoutInfo = new LinkedHashMap<>();
 
    @NotNull
    private final Map<MapFile, PendingInfo> pending = new LinkedHashMap<>();
 
    @NotNull
    private final Collection<MapFile> done = new HashSet<>();
 
    private int minX;
 
    private int minY;
 
    private int maxX;
 
    private int maxY;
 
    public MapImageCreator(@NotNull final MapManager<G, A, R> mapManager, @NotNull final RendererFactory<G, A, R> rendererFactory) {
        this.mapManager = mapManager;
        this.rendererFactory = rendererFactory;
    }
 
    @Nullable
    public BufferedImage createImage(@NotNull final MapFile mapFile, final boolean includeTiledMaps, @NotNull final ExportMapProgress progress) {
        progress.setMax(0);
 
        layoutInfo.clear();
        pending.clear();
        minX = 0;
        minY = 0;
        maxX = 1;
        maxY = 1;
        add(mapFile, includeTiledMaps, new PendingInfo(Direction.UP, 0, 0));
        progress.setMax(done.size());
 
        while (true) {
            final Iterator<Entry<MapFile, PendingInfo>> it = pending.entrySet().iterator();
            if (!it.hasNext()) {
                break;
            }
            final Entry<MapFile, PendingInfo> mapFile2 = it.next();
            it.remove();
 
            add(mapFile2.getKey(), includeTiledMaps, mapFile2.getValue());
            progress.setMax(done.size());
            if (progress.cancel()) {
                return null;
            }
        }
 
        final BufferedImage image = new BufferedImage((maxX - minX) / SCALE, (maxY - minY) / SCALE, BufferedImage.TYPE_INT_ARGB);
        final Graphics2D graphics = image.createGraphics();
        try {
            final List<LayoutInfo> tmp = new ArrayList<>(layoutInfo.values());
            Collections.shuffle(tmp);
            int done = 0;
            for (final LayoutInfo layoutInfo : tmp) {
                final MapControl<G, A, R> mapControl;
                try {
                    mapControl = mapManager.openMapFile(layoutInfo.getMapFile(), false);
                } catch (final IOException ex) {
                    System.err.println("cannot load map: " + layoutInfo.getMapFile() + ": " + ex);
                    continue;
                }
                try {
                    final MapRenderer mapRenderer = rendererFactory.newSimpleMapRenderer(mapControl.getMapModel());
                    final BufferedImage tmp1Image = mapRenderer.getFullImage();
                    final Image tmp2Image = tmp1Image.getScaledInstance(tmp1Image.getWidth() / SCALE, tmp1Image.getHeight() / SCALE, Image.SCALE_AREA_AVERAGING);
                    graphics.drawImage(tmp2Image, (layoutInfo.getX() - minX) / SCALE, (layoutInfo.getY() - minY) / SCALE, null);
                } finally {
                    mapManager.release(mapControl);
                }
 
                done++;
                progress.setValue(done, image);
                if (progress.cancel()) {
                    return null;
                }
            }
        } finally {
            graphics.dispose();
        }
        return image;
    }
 
    private void add(@NotNull final MapFile mapFile, final boolean includeTiledMaps, @NotNull final PendingInfo pendingInfo) {
        final MapControl<G, A, R> mapControl;
        try {
            mapControl = mapManager.openMapFile(mapFile, false);
        } catch (final IOException ex) {
            System.err.println("cannot load map: " + mapFile + ": " + ex);
            return;
        }
        try {
            final MapRenderer mapRenderer = rendererFactory.newSimpleMapRenderer(mapControl.getMapModel());
            final Size2D imageSize = mapRenderer.getImageSize();
            final int width = imageSize.getWidth();
            final int height = imageSize.getHeight();
 
            final int x = pendingInfo.getX(width);
            final int y = pendingInfo.getY(height);
            if (x < minX) {
                minX = x;
            } else if (x + width > maxX) {
                maxX = x + width;
            }
            if (y < minY) {
                minY = y;
            } else if (y + height > maxY) {
                maxY = y + height;
            }
            layoutInfo.put(mapFile, new LayoutInfo(mapFile, x, y));
 
            if (includeTiledMaps) {
                final A mapArchObject = mapControl.getMapModel().getMapArchObject();
                for (final Direction direction : Direction.values()) {
                    final String tilePath = mapArchObject.getTilePath(direction);
                    if (!tilePath.isEmpty()) {
                        final MapModel<G, A, R> mapModel2 = mapControl.getMapModel();
                        final MapPath mapPath2 = MapPathUtils.newMapPath(tilePath);
                        final MapFile mapFile2;
                        try {
                            mapFile2 = mapModel2.getMapFile(mapPath2);
                        } catch (final SameMapException | UnsavedMapException ignored) {
                            // ignore
                            continue;
                        }
                        if (done.add(mapFile2)) {
                            final int x2;
                            final int y2;
                            switch (direction) {
                            case NORTH:
                            case WEST:
                                x2 = x;
                                y2 = y;
                                break;
 
                            case EAST:
                                x2 = x + width;
                                y2 = y;
                                break;
 
                            case SOUTH:
                                x2 = x;
                                y2 = y + height;
                                break;
 
                            case NORTH_EAST:
                            case SOUTH_EAST:
                            case SOUTH_WEST:
                            case NORTH_WEST:
                            case UP:
                            case DOWN:
                            default:
                                throw new AssertionError("unexpected direction: " + direction);
                            }
                            pending.put(mapFile2, new PendingInfo(direction, x2, y2));
                        }
                    }
                }
            }
        } finally {
            mapManager.release(mapControl);
        }
    }
 
}