AbstractBaseObject.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.baseobject;
 
import java.awt.Point;
import java.util.Collection;
import java.util.Objects;
import javax.swing.ImageIcon;
import net.sf.gridarta.model.anim.AnimationObject;
import net.sf.gridarta.model.anim.AnimationObjects;
import net.sf.gridarta.model.archetype.Archetype;
import net.sf.gridarta.model.face.FaceObjectProviders;
import net.sf.gridarta.model.gameobject.FaceSource;
import net.sf.gridarta.model.gameobject.GameObject;
import net.sf.gridarta.model.gameobject.MultiArchData;
import net.sf.gridarta.model.maparchobject.MapArchObject;
import net.sf.gridarta.utils.NumberUtils;
import net.sf.gridarta.utils.StringUtils;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
 
public abstract class AbstractBaseObject<G extends GameObject<G, A, R>, A extends MapArchObject<A>, R extends Archetype<G, A, R>, T extends BaseObject<G, A, R, T>> extends GameObjectContainer<G, A, R> implements BaseObject<G, A, R, T> {
 
    private static final long serialVersionUID = 1L;
 
    @NotNull
    private final AnimationObjects animationObjects;
 
    @NotNull
    private GameObjectText gameObjectText = new GameObjectText();
 
    @Nullable
    private String faceObjName;
 
    @NotNull
    private FaceSource faceObjSource = FaceSource.FACE_NOT_FOUND;
 
    @Nullable
    private ImageIcon normalFace;
 
    @NotNull
    private final transient FaceObjectProviders faceObjectProviders;
 
    @NotNull
    private String objName = "";
 
    @Nullable
    private StringBuilder msgText;
 
    private int mapX;
 
    private int mapY;
 
    @Nullable
    private MultiArchData<G, A, R, T> multi;
 
    @Deprecated
    // default arches don't get an editType (not worth the time)
    // they get one assigned as soon as put on a map though.
    // TODO: This should be changed.
    private int editType = EDIT_TYPE_NONE;
 
    @Nullable
    private String faceName;
 
    private int typeNo;
 
    @Nullable
    private String animName;
 
    private int direction;
 
    @NotNull
    private String loreText = "";
 
    protected AbstractBaseObject(@NotNull final FaceObjectProviders faceObjectProviders, @NotNull final AnimationObjects animationObjects) {
        this.faceObjectProviders = faceObjectProviders;
        this.animationObjects = animationObjects;
    }
 
    @Override
    public int getTypeNo() {
        return typeNo;
    }
 
    private void setTypeNo(final int typeNo) {
        if (this.typeNo == typeNo) {
            return;
        }
 
        beginGameObjectChange();
        try {
            this.typeNo = typeNo;
        } finally {
            endGameObjectChange();
        }
    }
 
    private void setFaceName(@NotNull final String faceName) {
        final String effectiveFaceName = getEffectiveFaceName(faceName);
        //Strings are interned
        //noinspection StringEquality
        if (this.faceName == effectiveFaceName) {
            return;
        }
 
        beginGameObjectChange();
        try {
            this.faceName = effectiveFaceName;
        } finally {
            endGameObjectChange();
        }
    }
 
    @Nullable
    protected abstract String getEffectiveFaceName(@NotNull String faceName);
 
    @Nullable
    @Override
    public String getFaceName() {
        return faceName;
    }
 
    @Override
    public int countInvObjects() {
        int count = 0;
        for (final BaseObject<G, A, R, ?> gameObject : this) {
            count++;
            count += gameObject.countInvObjects();
        }
        return count;
    }
 
    @Override
    public boolean hasAttribute(@NotNull final String attributeName, final boolean queryArchetype) {
        return !getAttributeString(attributeName, queryArchetype).isEmpty();
    }
 
    @Override
    public boolean hasAttribute(@NotNull final String attributeName) {
        return hasAttribute(attributeName, true);
    }
 
    @Nullable
    protected String getAttributeValue(@NotNull final String attributeName) {
        return gameObjectText.getAttributeValue(attributeName);
    }
 
    @NotNull
    @Override
    public String getAttributeString(@NotNull final String attributeName) {
        return getAttributeString(attributeName, true);
    }
 
    @Override
    public int getAttributeInt(@NotNull final String attributeName, final boolean queryArchetype) {
        return NumberUtils.parseInt(getAttributeString(attributeName, queryArchetype));
    }
 
    @Override
    public int getAttributeInt(@NotNull final String attributeName) {
        return getAttributeInt(attributeName, true);
    }
 
    @Override
    public long getAttributeLong(@NotNull final String attributeName, final boolean queryArchetype) {
        return NumberUtils.parseLong(getAttributeString(attributeName, queryArchetype));
    }
 
    @Override
    public long getAttributeLong(@NotNull final String attributeName) {
        return getAttributeLong(attributeName, true);
    }
 
    @Override
    public double getAttributeDouble(@NotNull final String attributeName, final boolean queryArchetype) {
        return NumberUtils.parseDouble(getAttributeString(attributeName, queryArchetype));
    }
 
    @Override
    public double getAttributeDouble(@NotNull final String attributeName) {
        return getAttributeDouble(attributeName, true);
    }
 
    @Override
    public void setAttributeString(@NotNull final String attributeName, @NotNull final String value) {
        final boolean sameAsInArchetype = getArchetype().getAttributeString(attributeName).equals(value);
        if (!gameObjectText.setAttributeValue(attributeName, sameAsInArchetype, value, this)) {
            return;
        }
 
        updateCachedAttributes();
    }
 
    @Override
    public void setAttributeInt(@NotNull final String attributeName, final int value) {
        final boolean sameAsInArchetype = getArchetype().getAttributeInt(attributeName) == value;
        if (!gameObjectText.setAttributeValue(attributeName, sameAsInArchetype, Integer.toString(value), this)) {
            return;
        }
 
        updateCachedAttributes();
    }
 
    @Override
    public void removeAttribute(@NotNull final String attributeName) {
        if (!gameObjectText.removeAttribute(attributeName, this)) {
            return;
        }
 
        updateCachedAttributes();
    }
 
    @Override
    public abstract void notifyBeginChange();
 
    @Override
    public abstract void notifyEndChange();
 
    protected void updateArchetype() {
        beginGameObjectChange();
        try {
            updateCachedAttributes();
            if (multi != null) {
                final int multiShapeID = getArchetype().getMultiShapeID();
                assert multi != null;
                multi.setMultiShapeID(multiShapeID);
            }
        } finally {
            endGameObjectChange();
        }
    }
 
    @Override
    public int getEditType() {
        return isHead() ? editType : getHead().getEditType();
    }
 
    @Override
    public void setEditType(final int editType) {
        assert isHead();
        if (this.editType == editType) {
            return;
        }
 
        this.editType = editType;
        transientGameObjectChange();
    }
 
    @Override
    public void addMsgTextLine(@NotNull final String text) {
        // It's intentional that if text == null, msgText still is created if it's empty.
        // FIXME: Though it's intentional, it's not nice, search for users and fix this.
        // (Also look at deleteMsgText() and getMsgText() then)
        if (msgText == null) {
            msgText = new StringBuilder();
        }
 
        beginGameObjectChange();
        try {
            final String trimmedText = StringUtils.removeTrailingWhitespace(text);
            assert msgText != null;
            msgText.append(trimmedText);
            assert msgText != null;
            msgText.append('\n');
        } finally {
            endGameObjectChange();
        }
    }
 
    @Nullable
    @Override
    public String getMsgText(final boolean queryArchetype) {
        if (msgText != null) {
            return msgText.toString();
        }
        if (!queryArchetype) {
            return null;
        }
        final R archetype = getArchetype();
        return archetype == this ? null : archetype.getMsgText(queryArchetype);
    }
 
    @Override
    public void setMsgText(@Nullable final String msgText) {
        final String trimmedMsgText = msgText == null ? null : StringUtils.removeTrailingWhitespaceFromLines(StringUtils.ensureTrailingNewline(msgText));
        if (this.msgText == null ? trimmedMsgText == null : this.msgText.toString().equals(trimmedMsgText)) {
            return;
        }
 
        beginGameObjectChange();
        try {
            if (trimmedMsgText == null) {
                this.msgText = null;
            } else if (this.msgText == null) {
                this.msgText = new StringBuilder(trimmedMsgText);
            } else {
                this.msgText.setLength(0);
                assert this.msgText != null;
                this.msgText.append(trimmedMsgText);
            }
        } finally {
            endGameObjectChange();
        }
    }
 
    @Override
    public int getMapX() {
        return mapX;
    }
 
    @Override
    public int getMapY() {
        return mapY;
    }
 
    @NotNull
    @Override
    public Point getMapLocation() {
        return new Point(mapX, mapY);
    }
 
    @Override
    public void setMapX(final int mapX) {
        this.mapX = mapX;
    }
 
    @Override
    public void setMapY(final int mapY) {
        this.mapY = mapY;
    }
 
    @Override
    public boolean isHead() {
        // == is okay because that's the definition of being head.
        //noinspection ObjectEquality
        return getHead() == this;
    }
 
    @Nullable
    @Override
    public T getMultiNext() {
        return multi == null ? null : multi.getNext(getThis());
    }
 
    @Override
    public int getMultiRefCount() {
        return multi == null ? 0 : multi.getMultiRefCount();
    }
 
    @Override
    public void addTailPart(@NotNull final T tail) {
        initMultiData();
        assert multi != null;
        tail.setMulti(multi);
        assert multi != null;
        multi.addPart(tail);
    }
 
    @Override
    public void removeTailParts() {
        multi = null;
    }
 
    @Override
    public T getHead() {
        return multi == null ? getThis() : multi.getHead();
    }
 
    @Override
    public boolean isTail() {
        return getHead() != this;
    }
 
    @Override
    public int getSizeX() {
        return multi == null ? 1 : multi.getSizeX();
    }
 
    @Override
    public int getSizeY() {
        return multi == null ? 1 : multi.getSizeY();
    }
 
    @Override
    public int getMaxX() {
        return multi == null ? 0 : multi.getMaxX();
    }
 
    @Override
    public int getMaxY() {
        return multi == null ? 0 : multi.getMaxY();
    }
 
    @Override
    public int getMinX() {
        return multi == null ? 0 : multi.getMinX();
    }
 
    @Override
    public int getMinY() {
        return multi == null ? 0 : multi.getMinY();
    }
 
    private void initMultiData() {
        if (multi == null) {
            multi = new MultiArchData<>(getThis(), getArchetype().getMultiShapeID());
        }
    }
 
    @Override
    @NotNull
    @SuppressWarnings("unchecked")
    public T clone() {
        final AbstractBaseObject<G, A, R, T> clone = (AbstractBaseObject<G, A, R, T>) super.clone();
        //        clone.archetype = archetype; // will NOT be cloned: archetypes are unique
        clone.gameObjectText = new GameObjectText(gameObjectText);
        if (msgText != null) {
            clone.msgText = new StringBuilder(msgText);
        }
        clone.multi = null;
        return clone.getThis();
    }
 
    @Override
    protected void setThisContainer(@NotNull final G gameObject) {
        gameObject.setContainer(this, 0, 0);
    }
 
    @NotNull
    @Override
    public String getObjName() {
        return objName;
    }
 
    private void setObjName(@NotNull final String objName) {
        final String objName2 = objName.isEmpty() ? getArchetype().getArchetypeName() : objName;
        final String newObjName = objName2.intern();
        // Using == on these Strings is okay, they are both interned.
        //noinspection StringEquality
        if (this.objName == newObjName) {
            return;
        }
 
        beginGameObjectChange();
        try {
            this.objName = newObjName;
        } finally {
            endGameObjectChange();
        }
    }
 
    @NotNull
    @Override
    public String getBestName() {
        final String baseName;
        if (objName.isEmpty()) {
            final Archetype<G, A, R> archetype = getArchetype();
            final String archObjName = archetype.getObjName();
            baseName = archObjName.isEmpty() ? archetype.getArchetypeName() : archObjName;
        } else {
            baseName = objName;
        }
 
        final String title = getAttributeString(TITLE);
        return title.isEmpty() ? baseName : baseName + " " + title;
    }
 
    @NotNull
    @Override
    public String getObjectText() {
        return gameObjectText.getObjectText();
    }
 
    @Override
    public void addObjectText(@NotNull final String line) {
        if (!gameObjectText.addObjectText(line, this)) {
            return;
        }
 
        updateCachedAttributes();
    }
 
    @Override
    public void setObjectText(@NotNull final String objectText) {
        if (!gameObjectText.setObjectText(objectText, this)) {
            return;
        }
 
        updateCachedAttributes();
    }
 
    @Override
    public boolean isDefaultGameObject() {
        final R archetype = getArchetype();
        if (!objName.equals(archetype.getObjName())) {
            return false;
        }
        if (gameObjectText.hasObjectText()) {
            return false;
        }
        if (msgText != null && !msgText.toString().equals(archetype.getMsgText(false))) {
            return false;
        }
        if (faceName != null && !faceName.equals(archetype.getFaceName())) {
            return false;
        }
        if (animName != null && !animName.equals(archetype.getAnimName())) {
            return false;
        }
        return typeNo == archetype.getTypeNo();
    }
 
    @Override
    public boolean isEqual(@NotNull final BaseObject<?, ?, ?, ?> gameObject) {
        if (!(gameObject instanceof AbstractBaseObject)) {
            return false;
        }
        final AbstractBaseObject<?, ?, ?, ?> abstractBaseObject = (AbstractBaseObject<?, ?, ?, ?>) gameObject;
        if (!hasSameContents(abstractBaseObject)) {
            return false;
        }
        if (!Objects.equals(abstractBaseObject.faceObjName, faceObjName)) {
            return false;
        }
        // ignore "faceObjSource"
        // ignore "normalFace"
        // ignore "container"
        if (abstractBaseObject.getArchetype() != getArchetype()) {
            return false;
        }
        if (!abstractBaseObject.getArchetype().getArchetypeName().equals(getArchetype().getArchetypeName())) {
            return false;
        }
        if (!abstractBaseObject.objName.equals(objName)) {
            return false;
        }
        if (!abstractBaseObject.gameObjectText.equals(gameObjectText)) {
            return false;
        }
        if (abstractBaseObject.msgText == null ? msgText != null : msgText == null || !msgText.toString().equals(abstractBaseObject.msgText.toString())) {
            return false;
        }
        // ignore "mapX"
        // ignore "mapY"
        // ignore "attributeCache"
        // ignore "multi"
        // ignore "editType"
        if (!Objects.equals(abstractBaseObject.faceName, faceName)) {
            return false;
        }
        if (!Objects.equals(abstractBaseObject.animName, animName)) {
            return false;
        }
        if (abstractBaseObject.typeNo != typeNo) {
            return false;
        }
        //noinspection RedundantIfStatement
        if (abstractBaseObject.direction != direction) {
            return false;
        }
        return true;
    }
 
    @Override
    public int getDirection() {
        return direction;
    }
 
    protected void beginGameObjectChange() {
        if (multi == null) {
            notifyBeginChange();
        } else {
            for (final BaseObject<G, A, R, T> part : multi) {
                part.notifyBeginChange();
            }
        }
    }
 
    protected void endGameObjectChange() {
        if (multi == null) {
            notifyEndChange();
        } else {
            for (final BaseObject<G, A, R, T> part : multi) {
                part.notifyEndChange();
            }
        }
    }
 
    private void transientGameObjectChange() {
        if (multi == null) {
            notifyTransientChange();
        } else {
            for (final BaseObject<G, A, R, T> part : multi) {
                part.notifyTransientChange();
            }
        }
    }
 
    @NotNull
    @Override
    public FaceSource getFaceObjSource() {
        return faceObjSource;
    }
 
    private void setAnimName(@NotNull final String animName) {
        final String newAnimName = animName.isEmpty() ? null : animName.intern();
        // Using == on these Strings is okay, they are both interned.
        //noinspection StringEquality
        if (this.animName == newAnimName) {
            return;
        }
 
        beginGameObjectChange();
        try {
            this.animName = newAnimName;
        } finally {
            endGameObjectChange();
        }
    }
 
    @Nullable
    @Override
    public String getAnimName() {
        return animName;
    }
 
    @Override
    public boolean isMulti() {
        return multi != null;
    }
 
    @Nullable
    protected MultiArchData<G, A, R, T> getMulti() {
        return multi;
    }
 
    @Override
    public void setMulti(@NotNull final MultiArchData<G, A, R, T> multi) {
        this.multi = multi;
    }
 
    private void setFaceObjName(@Nullable final String faceObjName) {
        final String newFaceObjName = faceObjName == null ? null : faceObjName.intern();
        // Using == on these Strings is okay, they are both interned.
        //noinspection StringEquality
        if (this.faceObjName == newFaceObjName) {
            return;
        }
 
        beginGameObjectChange();
        try {
            this.faceObjName = newFaceObjName;
        } finally {
            endGameObjectChange();
        }
    }
 
    @Nullable
    @Override
    public String getFaceObjName() {
        return faceObjName;
    }
 
    @Override
    public void setObjectFace() {
        @Nullable String effectiveAnimName;
        if (getAttributeInt(IS_ANIMATED) == 0 && getAttributeInt(IS_TURNABLE) == 0) {
            effectiveAnimName = null;
            faceObjSource = FaceSource.ANIM;
        } else if (animName != null) {
            effectiveAnimName = animName;
            faceObjSource = FaceSource.ANIM;
        } else if (getArchetype() != null) {
            effectiveAnimName = getArchetype().getAnimName();
            faceObjSource = FaceSource.ARCHETYPE_ANIM;
        } else {
            effectiveAnimName = null;
            faceObjSource = FaceSource.ARCHETYPE_ANIM;
        }
        if (effectiveAnimName != null && effectiveAnimName.equals("NONE")) {
            effectiveAnimName = null;
        }
 
        @Nullable String effectiveFaceObjName;
        if (effectiveAnimName == null) { // ok, we fallback to the face picture
            if (faceName != null) {
                effectiveFaceObjName = faceName;
                faceObjSource = FaceSource.FACE;
            } else if (getArchetype() != null) {
                effectiveFaceObjName = getArchetype().getFaceName();
                faceObjSource = FaceSource.ARCHETYPE_FACE;
            } else {
                effectiveFaceObjName = null;
                faceObjSource = FaceSource.ARCHETYPE_FACE;
            }
        } else { // we have a animation - get the frame picture
            final AnimationObject animationObject = animationObjects.get(effectiveAnimName);
            if (animationObject == null) {
                effectiveFaceObjName = null;
            } else {
                try {
                    effectiveFaceObjName = animationObject.getFirstFrame(direction);
                } catch (final IndexOutOfBoundsException ignored) {
                    effectiveFaceObjName = null;
                }
            }
        }
 
        setFaceObjName(effectiveFaceObjName);
 
        if (effectiveFaceObjName == null || faceObjectProviders.getImageIconForFacename(effectiveFaceObjName) == null) {
            faceObjSource = FaceSource.FACE_NOT_FOUND;
        }
        normalFace = null;
    }
 
    @NotNull
    @Override
    public ImageIcon getNormalImage() {
        if (normalFace == null) {
            normalFace = faceObjectProviders.getFace(getThis());
        }
        return normalFace;
    }
 
    @NotNull
    @Override
    public String getLoreText() {
        return loreText;
    }
 
    @Override
    public void setLoreText(@NotNull final CharSequence loreText) {
        final String trimmedLoreText = StringUtils.removeTrailingWhitespace(loreText);
        if (this.loreText.equals(trimmedLoreText)) {
            return;
        }
 
        beginGameObjectChange();
        try {
            this.loreText = trimmedLoreText.intern();
        } finally {
            endGameObjectChange();
        }
    }
 
    @Override
    public void facesReloaded() {
        normalFace = null;
        transientGameObjectChange();
    }
 
    @NotNull
    @Override
    public String toString(@NotNull final String format) {
        final StringBuilder sb = new StringBuilder();
        final char[] chars = format.toCharArray();
        int pos = 0;
        while (pos < chars.length) {
            if (chars[pos] == '$' && pos + 2 < chars.length && chars[pos + 1] == '{') {
                pos += 2;
                final int startPos = pos;
                int nesting = 1;
                while (pos < chars.length) {
                    if (chars[pos] == '}') {
                        nesting--;
                        pos++;
                        if (nesting <= 0) {
                            break;
                        }
                    } else if (chars[pos] == '$' && pos + 1 < chars.length && chars[pos + 1] == '{') {
                        nesting++;
                        pos += 2;
                    } else {
                        pos++;
                    }
                }
                if (nesting > 0) {
                    sb.append("${");
                    pos++;
                } else {
                    final int endPos = pos - 1;
                    assert startPos <= endPos;
                    final CharSequence spec = new String(chars, startPos, endPos - startPos);
                    final String[] tmp = StringUtils.PATTERN_COLON.split(spec, 2);
                    if (tmp.length < 2) {
                        if (tmp[0].equals("NAME")) {
                            sb.append(getBestName());
                        } else {
                            sb.append(getAttributeString(tmp[0]));
                        }
                    } else {
                        if (hasAttribute(tmp[0])) {
                            sb.append(toString(tmp[1]));
                        }
                    }
                }
            } else {
                sb.append(chars[pos]);
                pos++;
            }
        }
 
        return sb.toString();
    }
 
    @NotNull
    protected abstract T getThis();
 
    private void updateCachedAttributes() {
        beginGameObjectChange();
        try {
            direction = getAttributeInt(DIRECTION);
            setFaceName(getAttributeString(FACE));
            setAnimName(getAttributeString(ANIMATION));
            setTypeNo(getAttributeInt(TYPE));
            setObjName(getAttributeString(NAME));
            setObjectFace();
        } finally {
            endGameObjectChange();
        }
    }
 
    @NotNull
    public Collection<String> getAttributeKeys() {
        return gameObjectText.getAttributeKeys();
    }
 
}