Facility.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 Facility {
    public static final int COST_MULTIPLIER = 1000;

    public static final int UNKNOWN3_SIZE = 3;

    public static final int FLAG_ANGLED = 0x01;
    public static final int FLAG_CROSSED = 0x02;
    public static final int FLAG_BUILDABLE = 0x04;
    public static final int FLAG_RESEARCH_UNNEEDED = 0x08;

    public static final String[] FACILITY_NAMES = {
        "Access Lift",
        "Living Quarters",
        "Laboratories",
        "Workshop",
        "Small Radar System",
        "Large Radar System",
        "Missile Defenses",
        "General Stores",
        "Alien Containment",
        "Laser Defense",
        "Plasma Defense",
        "Fusion Ball Defense",
        "Grav Shield",
        "Mind Shield",
        "Psionic Laboratory",
        "Hyper-wave Decoder",
        "Hangar"
    };

    public int index;

    public short nameIndex;
    public int cost;
    public short constructionDays;
    public int upkeep;
    public short capacity;
    public byte unknown1;
    public short defenseValue;
    public byte defenseAccuracy;
    public byte unknown2;
    public boolean angled;
    public boolean crossed;
    public boolean buildable;
    public boolean requiresResearch;
    public byte[] unknown3;

    protected Facility() {
    }

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

    public void copy(Facility other) {
        this.index = other.index;
        this.nameIndex = other.nameIndex;
        this.cost = other.cost;
        this.constructionDays = other.constructionDays;
        this.upkeep = other.upkeep;
        this.capacity = other.capacity;
        this.unknown1 = other.unknown1;
        this.defenseValue = other.defenseValue;
        this.defenseAccuracy = other.defenseAccuracy;
        this.unknown2 = other.unknown2;
        this.angled = other.angled;
        this.crossed = other.crossed;
        this.buildable = other.buildable;
        this.requiresResearch = other.requiresResearch;
        this.unknown3 = new byte[UNKNOWN3_SIZE];
        System.arraycopy(other.unknown3, 0, this.unknown3, 0, UNKNOWN3_SIZE);
    }

    public boolean readFromFile(UFOInputStream in) throws IOException {
        short flags;

        try {
            nameIndex = in.readUFOShort();
            cost = in.readUFOShort() * COST_MULTIPLIER;
            constructionDays = in.readUFOByte();
            upkeep = in.readUFOByte() * COST_MULTIPLIER;
            capacity = in.readUFOByte();
            unknown1 = in.readByte();
            defenseValue = in.readUFOShort();
            defenseAccuracy = in.readByte();
            unknown2 = in.readByte();
            flags = in.readUFOByte();

            angled = (flags & FLAG_ANGLED) != 0;
            crossed = (flags & FLAG_CROSSED) != 0;
            buildable = (flags & FLAG_BUILDABLE) != 0;
            requiresResearch = (flags & FLAG_RESEARCH_UNNEEDED) == 0;

            unknown3 = new byte[UNKNOWN3_SIZE];
            in.read(unknown3);

            return true;
        }
        catch(EOFException e) {
            return false;
        }
    }

    public void writeToFile(UFOOutputStream out) throws IOException {
        short flags = 0;

        if (angled) flags |= FLAG_ANGLED;
        if (crossed) flags |= FLAG_CROSSED;
        if (buildable) flags |= FLAG_BUILDABLE;
        if (!requiresResearch) flags |= FLAG_RESEARCH_UNNEEDED;

        out.writeUFOShort(nameIndex);
        out.writeUFOShort(cost / COST_MULTIPLIER);
        out.writeUFOByte(constructionDays);
        out.writeUFOByte(upkeep / COST_MULTIPLIER);
        out.writeUFOByte(capacity);
        out.writeByte(unknown1);
        out.writeUFOShort(defenseValue);
        out.writeByte(defenseAccuracy);
        out.writeByte(unknown2);
        out.writeUFOByte(flags);
        out.write(unknown3);
    }

    public static ArrayList<Facility> readList(UFOInputStream in) throws IOException {
        ArrayList<Facility> list = new ArrayList<Facility>();
        int index = 0;

        while(true) {
            Facility facility = new Facility();

            if (facility.readFromFile(in)) {
                facility.index = index++;
                list.add(facility);
            }
            else {
                break;
            }
        }

        return list;
    }

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

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

}