ProducibleItem.java

/*
 *  UFO Saved Game Editor
 *  Copyright (C) 2010 Christopher Davoren
 *
 *  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 3 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, see <http://www.gnu.org/licenses/>.
 */

package net.rubikscomplex.ufosge.data;

import java.io.EOFException;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Iterator;
import net.rubikscomplex.ufosge.util.UFOInputStream;
import net.rubikscomplex.ufosge.util.UFOOutputStream;


/**
 *
 * @author Chris Davoren
 */
public class ProducibleItem {
    public int PREREQUISITE_NONE = -1;
    public int MAX_PREREQUISITES = 3;

    public static final String[] ITEM_NAMES = {
        "Fusion Ball Launcher",
        "Laser Cannon",
        "Plasma Cannon",
        "Fusion Ball",
        "Tank/Laser Cannon",
        "Hovertank/Plasma",
        "Hovertank/Launcher",
        "HWP Fusion Bomb",
        "Laser Pistol",
        "Laser Rifle",
        "Heavy Laser",
        "Motion Scanner",
        "Medi-kit",
        "Psi-Amp",
        "Heavy Plasma",
        "Heavy Plasma Clip",
        "Plasma Rifle",
        "Plasma Rifle Clip",
        "Plasma Pistol",
        "Plasma Pistol Clip",
        "Blaster Launcher",
        "Blaster Bomb",
        "Small Launcher",
        "Stun Bomb",
        "Alien Grenade",
        "Mind Probe",
        "Personal Armour",
        "Power Suit",
        "Flying Suit",
        "Alien Alloys",
        "UFO Power Source",
        "UFO Navigation",
        "FIRESTORM",
        "LIGHTNING",
        "AVENGER"
    };

    public int index;
    public int cost;
    public short requiredHours;
    public short spaceNeeded;

    public byte[] prerequisites;
    public byte[] prerequisiteQuantities;

    public byte type;

    public boolean buildable;

    public byte unknown1;
    public byte unknown2;

    public ProducibleItem() {
    }

    public ProducibleItem(ProducibleItem other) {
        copy(other);
    }

    public void copy(ProducibleItem other) {
        this.index = other.index;
        this.cost = other.cost;
        this.requiredHours = other.requiredHours;
        this.spaceNeeded = other.spaceNeeded;

        this.prerequisites = new byte[MAX_PREREQUISITES];
        System.arraycopy(other.prerequisites, 0, this.prerequisites, 0, MAX_PREREQUISITES);
        this.prerequisiteQuantities = new byte[MAX_PREREQUISITES];
        System.arraycopy(other.prerequisiteQuantities, 0, this.prerequisiteQuantities, 0, MAX_PREREQUISITES);

        this.type = other.type;
        this.buildable = other.buildable;
        this.unknown1 = other.unknown1;
        this.unknown2 = other.unknown2;
    }

    public boolean readFromFile(UFOInputStream in, int index) throws IOException {
        try {
            cost = in.readUFOInt();
            requiredHours = in.readUFOShort();
            spaceNeeded = in.readUFOShort();

            prerequisites = new byte[MAX_PREREQUISITES];
            prerequisiteQuantities = new byte[MAX_PREREQUISITES];

            for (int i = 0; i < MAX_PREREQUISITES; i++) {
                prerequisites[i] = in.readByte();
            }

            for (int i = 0; i < MAX_PREREQUISITES; i++) {
                prerequisiteQuantities[i] = in.readByte();
            }

            type = in.readByte();
            unknown1 = in.readByte();
            buildable = in.readByte() == 0;
            unknown2 = in.readByte();

            this.index = index;
            return true;
        }
        catch (EOFException e) {
            return false;
        }
    }

    public void writeToFile(UFOOutputStream out) throws IOException {
        out.writeUFOInt(cost);
        out.writeUFOShort(requiredHours);
        out.writeUFOShort(spaceNeeded);

        out.write(prerequisites);
        out.write(prerequisiteQuantities);

        out.writeByte(type);
        out.writeByte(unknown1);
        out.writeByte(buildable ? 0 : 1);
        out.writeByte(unknown2);
    }

    public static ArrayList<ProducibleItem> readList(UFOInputStream in) throws IOException {
        ArrayList<ProducibleItem> list = new ArrayList<ProducibleItem>();

        while (true) {
            ProducibleItem item = new ProducibleItem();

            if (item.readFromFile(in, list.size())) {
                list.add(item);
            }
            else {
                break;
            }
        }

        return list;
    }

    public static void writeList(UFOOutputStream out, ArrayList<ProducibleItem> list) throws IOException {
        Iterator<ProducibleItem> pi = list.iterator();

        while(pi.hasNext()) {
            pi.next().writeToFile(out);
        }
    }
}