tdbfile.java

MegaMek is a networked Java clone of BattleTech, a turn-based sci-fi boardgame for 2+ players. Fight

/*
 * MegaMek - Copyright (C) 2000-2004 Ben Mazur ([e-mail])
 *
 *  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.
 */

/*
 * TdbFile.java
 *  -based on MtfFile.java, modifications by Ryan McConnell
 * Created on April 1, 2003, 2:48 PM
 */

package megamek.common.loaders;

import java.io.*;
import java.util.Hashtable;
import java.util.Vector;
import java.util.Enumeration;

import megamek.common.BipedMech;
import megamek.common.CriticalSlot;
import megamek.common.Engine;
import megamek.common.Entity;
import megamek.common.EquipmentType;
import megamek.common.LocationFullException;
import megamek.common.Mech;
import megamek.common.MiscType;
import megamek.common.Mounted;
import megamek.common.QuadMech;
import megamek.common.TechConstants;
import megamek.common.WeaponType;

import gd.xml.*;
import gd.xml.tiny.*;

public class TdbFile implements IMechLoader {

    private ParsedXML root = null;

    /**
     * The names of the various elements recognized by this parser.
     */
    private static final String  CREATOR_SECTION    = "creator";
    private static final String  BASICS_SECTION    = "basics";
    private static final String  ITEM_DEFS_SECTION    = "itemdefs";
    private static final String  MOUNTED_ITEMS_SECTION    = "mounteditems";
    private static final String  CRIT_DEFS_SECTION    = "critdefs";

    private static final String  NAME               = "name";
    private static final String  VERSION            = "version";
    private static final String  MODEL              = "model";
    private static final String  VARIANT            = "variant";
    private static final String  TECHNOLOGY         = "technology";
    private static final String  MOVEMECHMOD        = "movemechmod";
    private static final String  TONNAGE            = "tonnage"; // also attribute
    private static final String  TYPE               = "type";
    private static final String  OMNI               = "isomni";
    private static final String  WALK               = "walk";
    private static final String  JUMP               = "jump";
    private static final String  HEAT_SINKS         = "heatsinks";
    private static final String  ARMOR              = "armor"; // also attribute
    private static final String  ENGINE             = "engine";
    private static final String  GYRO               = "gyro";
    private static final String  COCKPIT            = "cockpit";
    private static final String  STRUCTURE          = "internal"; // also attribute
    private static final String  MOUNTED_ITEM       = "mounteditem";
    private static final String  LOCATION           = "location";
    private static final String  TARGSYS            = "targsys";

    /**
     * The names of the attributes recognized by this parser.
     */
    private static final String  LEVEL              = "level";
    private static final String  COUNT              = "count";
    private static final String  POINTS             = "points";
    private static final String  REAR_MOUNTED       = "rearmounted";
    private static final String  IS_SPREAD          = "isspread";
    private static final String  ITEM_INDEX         = "itemindex";
    private static final String  REAR_ARMOR         = "reararmor";
    private static final String  RATING             = "rating";

    /**
     * Special values recognized by this parser.
     */
    private static final String  TRUE               = "True";
    private static final String  FALSE              = "False";
    private static final String  DOUBLE             = "Double";
    private static final String  LASER              = "Laser";
    private static final String  COMPACT            = "Compact (2)";
    private static final String  TRUE_LOWER         = "true";

    private String creatorName = "Unknown";
    private String creatorVersion = "Unknown";
    private String name;
    private boolean isOmni = false;
    private String model;
    private String variant;

    private String chassisConfig;
    private String techBase;
    private static final String techYear = "3068"; // TDB doesn't have era
    private String rulesLevel;
    private String LAMTonnage;

    private String tonnage;

    private String heatSinks;
    private boolean dblSinks;
    private String walkMP;
    private String jumpMP;

    private int larmArmor;
    private int rarmArmor;
    private int ltArmor;
    private int rtArmor;
    private int ctArmor;
    private int headArmor;
    private int llegArmor;
    private int rlegArmor;
    private int ltrArmor;
    private int rtrArmor;
    private int ctrArmor;

    private String[][][] critData;
    private boolean isRearMounted[];
    private boolean isSplit[];

    private String armorType;
    private String engineType;
    private int engineRating;
    private String structureType;
    private String targSysStr;
    private String gyroType = "Standard";
    private String cockpitType = "Standard";
    private boolean clanTC = false;

    private Hashtable hSharedEquip = new Hashtable();
    private Vector vSplitWeapons = new Vector();

    /** Creates new TdbFile */
    public TdbFile(InputStream is) throws EntityLoadingException {
        try {
            root = TinyParser.parseXML(is);
        }
        catch (ParseException e) {
            throw new EntityLoadingException("   Failure to parse XML ("+e.getLocalizedMessage()+")");
        }
        // Arbitrarily sized static arrays suck, or so a computer
        //  science teacher once told me.
        isRearMounted = new boolean[256];
        isSplit = new boolean[256];

        critData = new String[8][12][2];
        parseNode((ParsedXML)root.elements().nextElement());
    }

    private void parseNode(ParsedXML node) throws EntityLoadingException {
        if (!node.getTypeName().equals("tag")) {
            // We only want to parse element nodes, text nodes
            //  are implicitly parsed when needed.
            return;
        }

        Enumeration children = node.elements();

        if (node.getName().equals(CREATOR_SECTION)) {
            parseCreatorNode(node);
        } else if (node.getName().equals(BASICS_SECTION)) {
            parseBasicsNode(node);
        } else if (node.getName().equals(ITEM_DEFS_SECTION)) {
            return; // don't need item defs section of xml
        } else if (node.getName().equals(MOUNTED_ITEMS_SECTION)) {
            parseMountedNode(node);
        } else if (node.getName().equals(CRIT_DEFS_SECTION)) {
            parseCritNode(node);
        } else if (children != null) {
            // Use recursion to process all the children
            while (children.hasMoreElements()) {
                parseNode((ParsedXML)children.nextElement());
            }
        }
    }

    private void parseCreatorNode(ParsedXML node) throws EntityLoadingException {
        if (!node.getTypeName().equals("tag")) {
            // We only want to parse element nodes, text nodes
            //  are directly parsed below.
            return;
        }

        Enumeration children = node.elements();

        if (node.getName().equals(NAME)) {
            creatorName = ((ParsedXML)children.nextElement()).getContent();
        } else if (node.getName().equals(VERSION)) {
            creatorVersion = ((ParsedXML)children.nextElement()).getContent();
        } else if (children != null) {
            // Use recursion to process all the children
            while (children.hasMoreElements()) {
                parseCreatorNode((ParsedXML)children.nextElement());
            }
        }
        // Other tags (that don't match any if blocks above)
        //  are simply ignored.
    }

    private void parseBasicsNode(ParsedXML node) throws EntityLoadingException {
        if (!node.getTypeName().equals("tag")) {
            // We only want to parse element nodes, text nodes
            //  are directly parsed below.
            return;
        }

        Enumeration children = node.elements();

        if (node.getName().equals(NAME)) {
            name = ((ParsedXML)children.nextElement()).getContent();
        } else if (node.getName().equals(MODEL)) {
            model = ((ParsedXML)children.nextElement()).getContent();
        } else if (node.getName().equals(OMNI)) {
            isOmni = ((ParsedXML)children.nextElement()).getContent().equals(TRUE_LOWER);
        } else if (node.getName().equals(VARIANT)) {
            variant = ((ParsedXML)children.nextElement()).getContent();
        } else if (node.getName().equals(TECHNOLOGY)) {
            techBase = ((ParsedXML)children.nextElement()).getContent();
            rulesLevel = node.getAttribute(LEVEL);
        } else if (node.getName().equals(TONNAGE)) {
            tonnage = ((ParsedXML)children.nextElement()).getContent();
        } else if (node.getName().equals(TYPE)) {
            chassisConfig = ((ParsedXML)children.nextElement()).getContent();
        } else if (node.getName().equals(MOVEMECHMOD)) {
            // This tag seems to indicate the pod space on an omnimech
            //  or the tonnage of the conversion equipment for
            //  a LAM (Land Air Mech).
            LAMTonnage = node.getAttribute(TONNAGE);
        } else if (node.getName().equals(WALK)) {
            walkMP = ((ParsedXML)children.nextElement()).getContent();
        } else if (node.getName().equals(JUMP)) {
            jumpMP = ((ParsedXML)children.nextElement()).getContent();
        } else if (node.getName().equals(HEAT_SINKS)) {
            if (((ParsedXML)children.nextElement()).getContent().indexOf(DOUBLE) != -1) {
                dblSinks = true;
            } else {
                dblSinks = false;
            }
            heatSinks = node.getAttribute(COUNT);
        } else if (node.getName().equals(ARMOR)) {
            armorType = ((ParsedXML)children.nextElement()).getContent();
        } else if (node.getName().equals(ENGINE)) {