hmpfile.java

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

/*
 * MegaMek - Copyright (C) 2000,2001,2002,2003,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.
 */

/* OMIT_FOR_JHMPREAD_COMPILATION BLOCK_BEGIN */
package megamek.common.loaders;
/* BLOCK_END */

import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.InputStream;
import java.io.IOException;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.File;

import java.util.Hashtable;
import java.util.Vector;

/* OMIT_FOR_JHMPREAD_COMPILATION BLOCK_BEGIN */
import megamek.common.ArmlessMech;
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.IEntityMovementMode;
import megamek.common.QuadMech;
import megamek.common.TechConstants;
import megamek.common.WeaponType;
/* BLOCK_END */

/**
 * Based on the hmpread.c program and the MtfFile object.
 * 
 * Note that this class doubles as both a MM Heavy Metal Pro parser and a HMP to
 * MTF file converter (when the "main" method is used).
 * 
 * @author <a href="mailto:[e-mail]">Michael Newcomb</a>
 * @version $Revision: 4813 $
 *          Modified by Ryan McConnell (oscarmm) with lots of
 *          help from Ian Hamilton.
 */
public class HmpFile
/* OMIT_FOR_JHMPREAD_COMPILATION BLOCK_BEGIN */
    implements IMechLoader
/* BLOCK_END */
{
    private String name;
    private String model;
    private String fluff = null;

    private ChassisType chassisType;

    private TechType techType;

    private TechType mixedBaseTechType;
    private TechType engineTechType;
    private TechType heatSinkTechType;
    private TechType physicalWeaponTechType;
    private TechType targetingComputerTechType;
    private TechType myomerTechType;
    private TechType armorTechType;

    private int year;
    private int rulesLevel;

    private int tonnage;

    private InternalStructureType internalStructureType;
    private int engineRating;
    private EngineType engineType;
    private ArmorType armorType;

    private int heatSinks;
    private HeatSinkType heatSinkType;

    private int walkMP;
    private int jumpMP;

    private int laArmor;
    private ArmorType laArmorType;
    private int ltArmor;
    private ArmorType ltArmorType;
    private int ltrArmor;
    private ArmorType ltrArmorType;
    private int llArmor;
    private ArmorType llArmorType;

    private int raArmor;
    private ArmorType raArmorType;
    private int rtArmor;
    private ArmorType rtArmorType;
    private int rtrArmor;
    private ArmorType rtrArmorType;
    private int rlArmor;
    private ArmorType rlArmorType;

    private int headArmor;
    private ArmorType headArmorType;

    private int ctArmor;
    private ArmorType ctArmorType;
    private int ctrArmor;
    private ArmorType ctrArmorType;

    private MyomerType myomerType;

    private int totalWeaponCount;
    private int[][] weaponArray;

    private long[] laCriticals = new long[12];
    private long[] ltCriticals = new long[12];
    private long[] llCriticals = new long[12];

    private long[] raCriticals = new long[12];
    private long[] rtCriticals = new long[12];
    private long[] rlCriticals = new long[12];

    private long[] headCriticals = new long[12];
    private long[] ctCriticals = new long[12];

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

    private int gyroType = Mech.GYRO_STANDARD;
    private int cockpitType = Mech.COCKPIT_STANDARD;
    private int targSys = 0;
    private int jjType;
    
    private int atmCounter = 0;
    private int lbxCounter = 0;

    public HmpFile(InputStream is)
    /* OMIT_FOR_JHMPREAD_COMPILATION BLOCK_BEGIN */
        throws EntityLoadingException
    /* BLOCK_END */
    {
        try {
            DataInputStream dis = new DataInputStream(is);

            byte[] buffer = new byte[5];
            dis.read(buffer);
            String version = new String(buffer);

            // this next one no longer seems accurate...
            DesignType designType = DesignType.getType(readUnsignedByte(dis));

            // ??
            dis.skipBytes(3);

            // some flags saying which Clans use this design
            dis.skipBytes(3);

            // ??
            dis.skipBytes(1);

            // some flags saying which Inner Sphere factions use this design
            dis.skipBytes(3);

            // ??
            dis.skipBytes(1);

            tonnage = readUnsignedShort(dis);

            buffer = new byte[readUnsignedShort(dis)];
            dis.read(buffer);
            name = new String(buffer);

            buffer = new byte[readUnsignedShort(dis)];
            dis.read(buffer);
            model = new String(buffer);

            year = readUnsignedShort(dis);

            rulesLevel = readUnsignedShort(dis);

            long cost = readUnsignedInt(dis);

            // ??
            dis.skipBytes(22);

            // section with BF2 stuff
            int bf2Length = readUnsignedShort(dis);
            dis.skipBytes(bf2Length);

            techType = TechType.getType(readUnsignedShort(dis));

            if (techType == TechType.MIXED) {
                // We've got a total of 7 shorts here.
                // The first one is the mech's "base" chassis technology type.
                // It also doubles as the internal structure type.
                mixedBaseTechType = TechType.getType(readUnsignedShort(dis));
                // Next we have engine, heat sinks, physical attack weapon,
                // myomer, targeting computer, and finally armor. Note that
                // these 14 bytes are always present in mixed-tech designs,
                // whether the specific equipment exists on the mech or not.
                engineTechType = TechType.getType(readUnsignedShort(dis));
                heatSinkTechType = TechType.getType(readUnsignedShort(dis));
                physicalWeaponTechType = TechType
                        .getType(readUnsignedShort(dis));
                myomerTechType = TechType.getType(readUnsignedShort(dis));
                targetingComputerTechType = TechType
                        .getType(readUnsignedShort(dis));
                armorTechType = TechType.getType(readUnsignedShort(dis));
            }

            chassisType = ChassisType.getType(readUnsignedShort(dis));

            internalStructureType = InternalStructureType
                    .getType(readUnsignedShort(dis));

            engineRating = readUnsignedShort(dis);
            engineType = EngineType.getType(readUnsignedShort(dis));

            walkMP = readUnsignedShort(dis);
            jumpMP = readUnsignedShort(dis);

            heatSinks = readUnsignedShort(dis);
            heatSinkType = HeatSinkType.getType(readUnsignedShort(dis));

            armorType = ArmorType.getType(readUnsignedShort(dis));

            if (armorType == ArmorType.PATCHWORK) {
                laArmorType = ArmorType.getType(readUnsignedShort(dis));
                ltArmorType = ArmorType.getType(readUnsignedShort(dis));
                llArmorType = ArmorType.getType(readUnsignedShort(dis));
                raArmorType = ArmorType.getType(readUnsignedShort(dis));
                rtArmorType = ArmorType.getType(readUnsignedShort(dis));
                rlArmorType = ArmorType.getType(readUnsignedShort(dis));
                headArmorType = ArmorType.getType(readUnsignedShort(dis));
                ctArmorType = ArmorType.getType(readUnsignedShort(dis));
                ltrArmorType = ArmorType.getType(readUnsignedShort(dis));
                rtrArmorType = ArmorType.getType(readUnsignedShort(dis));
                ctrArmorType = ArmorType.getType(readUnsignedShort(dis));
            }

            dis.skipBytes(2); // ??
            laArmor = readUnsignedShort(dis);
            dis.skipBytes(4); // ??
            ltArmor = readUnsignedShort(dis);
            dis.skipBytes(4); // ??
            llArmor = readUnsignedShort(dis);
            dis.skipBytes(4); // ??
            raArmor = readUnsignedShort(dis);
            dis.skipBytes(4); // ??
            rtArmor = readUnsignedShort(dis);
            dis.skipBytes(2); // ??
            jjType = readUnsignedShort(dis);
            rlArmor = readUnsignedShort(dis);
            dis.skipBytes(4); // ??
            headArmor = readUnsignedShort(dis);
            dis.skipBytes(4); // ??
            ctArmor = readUnsignedShort(dis);
            dis.skipBytes(2); // ??
            ltrArmor = readUnsignedShort(dis);
            rtrArmor = readUnsignedShort(dis);
            ctrArmor = readUnsignedShort(dis);

            myomerType = MyomerType.getType(readUnsignedShort(dis));

            totalWeaponCount = readUnsignedShort(dis);
            weaponArray = new int[totalWeaponCount][4];
            for (int i = 0; i < totalWeaponCount; i++) {
                weaponArray[i][0] = readUnsignedShort(dis); // weapon count
                weaponArray[i][1] = readUnsignedShort(dis); // weapon type
                weaponArray[i][2] = readUnsignedShort(dis); // weapon location
                weaponArray[i][3] = readUnsignedShort(dis); // ammo

                dis.skipBytes(2); // ??

                // manufacturer name
                dis.skipBytes(readUnsignedShort(dis));