GameObjectMatcherParser.java

Go to the documentation of this file.

/*
 * Gridarta MMORPG map editor for Crossfire, Daimonin and similar games.
 * Copyright (C) 2000-2015 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.match;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Locale;
import net.sf.gridarta.utils.StringUtils;
import nu.xom.Element;
import nu.xom.Node;
import nu.xom.Nodes;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;

public class GameObjectMatcherParser {

    @NotNull
    private static final String XML_ATTRIB_ATTRIBUTE_NAME = "name";

    @NotNull
    private static final String XML_ATTRIB_ATTRIBUTE_OP = "op";

    @NotNull
    private static final String XML_ATTRIB_ATTRIBUTE_TYPE = "type";

    @NotNull
    private static final String XML_ATTRIB_ATTRIBUTE_VALUE = "value";

    @NotNull
    private static final String XML_ATTRIB_ATTRIBUTE_USEARCHETYPE = "useArchetype";

    @NotNull
    private static final String XML_MATCHER_ATTRIBUTE_ID = "id";

    @NotNull
    private static final String XML_MATCHER_ATTRIBUTE_SYSTEM = "system";

    @NotNull
    private static final String XML_MATCHER_ELEMENT_ENV = "Env";

    @NotNull
    private static final String XML_ELEMENT_TYPENRS = "TypeNrs";

    @NotNull
    private static final String XML_ELEMENT_ATTRIB = "Attrib";

    @NotNull
    private static final String XML_ELEMENT_OR = "Or";

    @NotNull
    private static final String XML_ELEMENT_AND = "And";

    @NotNull
    private static final String XML_TYPENRS_ATTRIBUTE_NUMBERS = "numbers";

    private GameObjectMatcherParser() {
    }

    @NotNull
    public static NamedGameObjectMatcher parseMatcher(@NotNull final Element el, final int editType) throws ParsingException {
        final String currentLanguage = Locale.getDefault().getLanguage();
        final String localName = el.getLocalName();
        if (localName == null || !localName.equals("GameObjectMatcher")) {
            throw new ParsingException("wrong local element name: expected \"GameObjectMatcher\" but got \"" + localName + "\"");
        }
        final String id = el.getAttribute(XML_MATCHER_ATTRIBUTE_ID).getValue();
        String title = getLanguageTitle(el, currentLanguage);
        if (title == null || title.isEmpty()) {
            title = getLanguageTitle(el, "en");
        }
        if (title == null || title.isEmpty()) {
            title = id;
        }
        final boolean systemMatcher = el.getAttribute(XML_MATCHER_ATTRIBUTE_SYSTEM).getValue().equals("true");
        final Node content = xpathEvaluate(el, "*[last()]");
        assert content != null;

        final Node env = xpathEvaluate(el, XML_MATCHER_ELEMENT_ENV);
        @Nullable final GameObjectMatcher envGameObjectMatcher;
        if (env != null && env instanceof Element) {
            final Node envContent = xpathEvaluate(env, "*[1]");
            envGameObjectMatcher = envContent == null ? new AndGameObjectMatcher(Collections.emptyList()) : createMatcher((Element) envContent);
        } else {
            envGameObjectMatcher = null;
        }

        //XXX:assert content.getNodeType() == Node.ELEMENT_NODE;
        final GameObjectMatcher matcher = createMatcher((Element) content);
        return new NamedGameObjectMatcher(systemMatcher ? 0 : editType, id, title, systemMatcher, envGameObjectMatcher, matcher);
    }

    @Nullable
    private static String getLanguageTitle(@NotNull final Node el, @NotNull final String language) {
        final Nodes nodes = el.query("title[lang('" + language + "')]");
        return nodes.size() == 0 ? null : nodes.get(0).getValue();
    }

    @NotNull
    private static GameObjectMatcher createMatcher(@NotNull final Element el) throws ParsingException {
        final String localName = el.getLocalName();
        if (localName == null) {
            // ignore
        } else if (localName.equals(XML_ELEMENT_TYPENRS)) {
            return createTypeNrsArchObjectMatcher(el);
        } else if (localName.equals(XML_ELEMENT_ATTRIB)) {
            return createAttributeArchObjectMatcher(el);
        } else if (localName.equals(XML_ELEMENT_OR)) {
            return createOrMatcher(el);
        } else if (localName.equals(XML_ELEMENT_AND)) {
            return createAndMatcher(el);
        }
        throw new ParsingException("expected element node name to be one of \"" + XML_ELEMENT_TYPENRS + "\", \"" + XML_ELEMENT_ATTRIB + "\", \"" + XML_ELEMENT_OR + "\", \"" + XML_ELEMENT_AND + "\".");
    }

    @NotNull
    private static GameObjectMatcher createAndMatcher(@NotNull final Node el) throws ParsingException {
        return new AndGameObjectMatcher(getChildMatchers(el));
    }

    @NotNull
    private static GameObjectMatcher createOrMatcher(@NotNull final Node el) throws ParsingException {
        return new OrGameObjectMatcher(getChildMatchers(el));
    }

    @NotNull
    private static Collection<GameObjectMatcher> getChildMatchers(@NotNull final Node el) throws ParsingException {
        final Collection<GameObjectMatcher> childMatchers = new ArrayList<>();
        for (int i = 0; i < el.getChildCount(); i++) {
            final Node childNode = el.getChild(i);
            if (childNode instanceof Element) {
                childMatchers.add(createMatcher((Element) childNode));
            }
        }
        return childMatchers;
    }

    @NotNull
    private static GameObjectMatcher createAttributeArchObjectMatcher(@NotNull final Element el) throws ParsingException {
        final String type = el.getAttribute(XML_ATTRIB_ATTRIBUTE_TYPE).getValue();
        if (type.equals("string")) {
            return new StringAttributeGameObjectMatcher(el.getAttribute(XML_ATTRIB_ATTRIBUTE_NAME).getValue(), Enum.valueOf(Operation.class, el.getAttribute(XML_ATTRIB_ATTRIBUTE_OP).getValue()), el.getAttribute(XML_ATTRIB_ATTRIBUTE_VALUE).getValue(), el.getAttribute(XML_ATTRIB_ATTRIBUTE_USEARCHETYPE).getValue().equals("true"));
        } else if (type.equals("int")) {
            return new IntAttributeGameObjectMatcher(el.getAttribute(XML_ATTRIB_ATTRIBUTE_NAME).getValue(), Enum.valueOf(Operation.class, el.getAttribute(XML_ATTRIB_ATTRIBUTE_OP).getValue()), el.getAttribute(XML_ATTRIB_ATTRIBUTE_VALUE).getValue(), el.getAttribute(XML_ATTRIB_ATTRIBUTE_USEARCHETYPE).getValue().equals("true"));
        } else {
            throw new AssertionError("impossible value '" + type + "' for XML_ATTRIB_ATTRIBUTE_TYPE");
        }
    }

    @NotNull
    private static GameObjectMatcher createTypeNrsArchObjectMatcher(@NotNull final Element el) throws ParsingException {
        final CharSequence numbers = el.getAttribute(XML_TYPENRS_ATTRIBUTE_NUMBERS).getValue();
        final String[] typeNrs = StringUtils.PATTERN_WHITESPACE.split(numbers, 0);
        final int[] types = new int[typeNrs.length];
        for (int i = 0; i < types.length; i++) {
            try {
                types[i] = Integer.parseInt(typeNrs[i]);
            } catch (final NumberFormatException ignored) {
                //noinspection ThrowInsideCatchBlockWhichIgnoresCaughtException
                throw new ParsingException("invalid number: " + typeNrs[i]);
            }
        }
        return new TypeNrsGameObjectMatcher(types);
    }

    @Nullable
    private static Node xpathEvaluate(@NotNull final Node el, @NotNull final String xpathExpression) {
        final Nodes nodes = el.query(xpathExpression);
        assert nodes.size() <= 1;
        return nodes.size() == 0 ? null : nodes.get(0);
    }

}