DefaultIsoGameObject.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.gameobject;
 
import java.awt.Point;
import javax.swing.Icon;
import javax.swing.ImageIcon;
import net.sf.gridarta.model.anim.AnimationObjects;
import net.sf.gridarta.model.archetype.Archetype;
import net.sf.gridarta.model.baseobject.BaseObject;
import net.sf.gridarta.model.face.FaceObjectProviders;
import net.sf.gridarta.model.maparchobject.MapArchObject;
import net.sf.gridarta.model.mapmodel.MapSquare;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
 
public abstract class DefaultIsoGameObject<G extends GameObject<G, A, R>, A extends MapArchObject<A>, R extends Archetype<G, A, R>> extends AbstractGameObject<G, A, R> {
 
    private static final long serialVersionUID = 1L;
 
    private static final int MAX_STRETCH = 8;
 
    private static final int MAX_STRETCH_DIAGONAL = 12;
 
    public static final int MAX_SUB_LAYERS = 7;
 
    @NotNull
    public static final String Z = "z";
 
    @NotNull
    public static final String LAYER = "layer";
 
    @NotNull
    public static final String SUB_LAYER = "sub_layer";
 
    @NotNull
    public static final String SYS_OBJECT = "sys_object";
 
    @NotNull
    protected static final String DRAW_DOUBLE_ALWAYS = "draw_double_always";
 
    @NotNull
    protected static final String DRAW_DOUBLE = "draw_double";
 
    @NotNull
    public static final String ALIGN = "align";
 
    @NotNull
    public static final String ZOOM = "zoom";
 
    @NotNull
    public static final String ALPHA = "alpha";
 
    @NotNull
    public static final String ROTATE = "rotate";
 
    @NotNull
    protected static final String GLOW_RADIUS = "glow_radius";
 
    @NotNull
    private final transient FaceObjectProviders faceObjectProviders;
 
    @Nullable
    private ImageIcon transFace;
 
    @Nullable
    private ImageIcon doubleFace;
 
    @Nullable
    private ImageIcon transDoubleFace;
 
    @Nullable
    private ImageIcon stretchedFace;
 
    @NotNull
    private final Point point = new Point();
 
    private boolean stretchFactorIsValid;
 
    private long stretchFactor;
 
    protected DefaultIsoGameObject(@NotNull final R archetype, @NotNull final FaceObjectProviders faceObjectProviders, @NotNull final AnimationObjects animationObjects) {
        super(archetype, faceObjectProviders, animationObjects);
        this.faceObjectProviders = faceObjectProviders;
    }
 
    @Override
    public boolean usesDirection() {
        return getAttributeInt(IS_TURNABLE) != 0 || getAttributeInt(IS_ANIMATED) != 0;
    }
 
    @Override
    public void setObjectFace() {
        transFace = null;
        doubleFace = null;
        transDoubleFace = null;
        stretchedFace = null;
        super.setObjectFace();
    }
 
    @NotNull
    public Icon getTransparentImage() {
        if (transFace == null) {
            transFace = faceObjectProviders.getTrans(this);
        }
        return transFace;
    }
 
    @NotNull
    public Icon getDoubleImage() {
        if (doubleFace == null) {
            doubleFace = faceObjectProviders.getDouble(this);
        }
        return doubleFace;
    }
 
    @NotNull
    public Icon getTransparentDoubleImage() {
        if (transDoubleFace == null) {
            transDoubleFace = faceObjectProviders.getTransDouble(this);
        }
        return transDoubleFace;
    }
 
    public final int getYOffset() {
        return getAttributeInt(LAYER) > 1 ? getAttributeInt(Z) : 0;
    }
 
    private int getYFloorOffset(final int dx, final int dy) {
        final MapSquare<G, A, R> mapSquare = getMapSquareOptional();
        if (mapSquare == null) {
            return 0;
        }
 
        point.x = mapSquare.getMapX() + dx;
        point.y = mapSquare.getMapY() + dy;
 
        try {
            for (final G gameObject : mapSquare.getMapModel().getMapSquare(point)) {
                if (gameObject.getAttributeInt(LAYER) == 1 && gameObject.getAttributeInt(SUB_LAYER) == getAttributeInt(SUB_LAYER)) {
                    return gameObject.getAttributeInt(Z);
                }
            }
        } catch (final IndexOutOfBoundsException ignored) {
            // skip points outside map bounds
        }
 
        return 0;
    }
 
    public final void refreshStretchFactor() {
        stretchFactorIsValid = false;
        stretchedFace = null;
    }
 
    public final long getStretchFactor() {
        if (stretchFactorIsValid) {
            return stretchFactor;
        }
 
        int nwHeight = getYFloorOffset(-1, -1);
        int nHeight = getYFloorOffset(0, -1);
        int neHeight = getYFloorOffset(1, -1);
        int swHeight = getYFloorOffset(-1, 1);
        int sHeight = getYFloorOffset(0, 1);
        int seHeight = getYFloorOffset(1, 1);
        int wHeight = getYFloorOffset(-1, 0);
        int eHeight = getYFloorOffset(1, 0);
        final int myHeight = getYFloorOffset(0, 0);
 
        if (Math.abs(myHeight - eHeight) > MAX_STRETCH) {
            eHeight = myHeight;
        }
 
        if (Math.abs(myHeight - seHeight) > MAX_STRETCH_DIAGONAL) {
            seHeight = myHeight;
        }
 
        if (Math.abs(myHeight - sHeight) > MAX_STRETCH) {
            sHeight = myHeight;
        }
 
        if (Math.abs(myHeight - swHeight) > MAX_STRETCH_DIAGONAL) {
            swHeight = myHeight;
        }
 
        if (Math.abs(myHeight - wHeight) > MAX_STRETCH) {
            wHeight = myHeight;
        }
 
        if (Math.abs(myHeight - nwHeight) > MAX_STRETCH_DIAGONAL) {
            nwHeight = myHeight;
        }
 
        if (Math.abs(myHeight - nHeight) > MAX_STRETCH) {
            nHeight = myHeight;
        }
 
        if (Math.abs(myHeight - neHeight) > MAX_STRETCH_DIAGONAL) {
            neHeight = myHeight;
        }
 
        int top = Math.max(wHeight, nwHeight);
        top = Math.max(top, nHeight);
        top = Math.max(top, myHeight);
 
        int bottom = Math.max(sHeight, seHeight);
        bottom = Math.max(bottom, eHeight);
        bottom = Math.max(bottom, myHeight);
 
        int right = Math.max(nHeight, neHeight);
        right = Math.max(right, eHeight);
        right = Math.max(right, myHeight);
 
        int left = Math.max(wHeight, swHeight);
        left = Math.max(left, sHeight);
        left = Math.max(left, myHeight);
 
        int minHt = Math.min(top, bottom);
        minHt = Math.min(minHt, left);
        minHt = Math.min(minHt, right);
        minHt = Math.min(minHt, myHeight);
 
        if (myHeight < 0 && left == 0 && right == 0 && top == 0 && bottom == 0) {
            int top2 = Math.min(wHeight, nwHeight);
            top2 = Math.min(top2, nHeight);
            top2 = Math.min(top2, myHeight);
 
            int bottom2 = Math.min(sHeight, seHeight);
            bottom2 = Math.min(bottom2, eHeight);
            bottom2 = Math.min(bottom2, myHeight);
 
            int right2 = Math.min(nHeight, neHeight);
            right2 = Math.min(right2, eHeight);
            right2 = Math.min(right2, myHeight);
 
            int left2 = Math.min(wHeight, swHeight);
            left2 = Math.min(left2, sHeight);
            left2 = Math.min(left2, myHeight);
 
            top = top2 - top;
            bottom = bottom2 - bottom;
            right = right2 - right;
            left = left2 - left;
 
            minHt = Math.min(top, bottom);
            minHt = Math.min(minHt, left);
            minHt = Math.min(minHt, right);
            minHt = Math.min(minHt, myHeight);
 
            minHt = Math.abs(minHt);
            top = Math.abs(top);
            bottom = Math.abs(bottom);
            left = Math.abs(left);
            right = Math.abs(right);
        }
 
        top -= minHt;
        bottom -= minHt;
        left -= minHt;
        right -= minHt;
 
        top = Math.abs(Math.min(255, top));
        bottom = Math.abs(Math.min(255, bottom));
        left = Math.abs(Math.min(255, left));
        right = Math.abs(Math.min(255, right));
 
        stretchFactor = bottom + (left << 8) + (right << 16) + (top << 24);
        stretchFactorIsValid = true;
        return stretchFactor;
    }
 
    @NotNull
    public Icon getStretchedImage(final long stretchFactor) {
        if (stretchedFace == null) {
            stretchedFace = faceObjectProviders.getStretched(this, stretchFactor);
        }
        return stretchedFace;
    }
 
    public abstract boolean isDrawDouble(boolean drawDoubleFaces);
 
    public abstract boolean isStretched(boolean tileStretching);
 
    @NotNull
    @Override
    @SuppressWarnings("unchecked")
    public G clone() {
        final DefaultIsoGameObject<G, A, R> clone = (DefaultIsoGameObject<G, A, R>) super.clone();
        return clone.getThis();
    }
 
    @Override
    public boolean isEqual(@NotNull final BaseObject<?, ?, ?, ?> gameObject) {
        return super.isEqual(gameObject);
        // ignore "scriptArchData"
        // ignore "transFace"
    }
 
    @Override
    public void facesReloaded() {
        transFace = null;
        doubleFace = null;
        transDoubleFace = null;
        stretchedFace = null;
        super.facesReloaded();
    }
 
}