source: tmcsimulator-scriptbuilder/trunk/src/scriptbuilder/structures/SimulationScript.java @ 76

package scriptbuilder.structures;



import java.awt.Color;

import java.io.BufferedWriter;

import java.io.File;

import java.io.FileWriter;

import java.io.OutputStream;

import java.io.OutputStreamWriter;

import java.util.ArrayList;

import java.util.List;

import java.util.Observable;

import java.util.Random;

import java.util.Vector;

import java.util.logging.Level;

import java.util.logging.Logger;

import javax.xml.parsers.ParserConfigurationException;

import javax.xml.parsers.SAXParserFactory;

import scriptbuilder.structures.ScriptEvent.ScriptEventType;

import scriptbuilder.structures.ScriptIncident.IncidentFocusedEvent;

import scriptbuilder.structures.ScriptIncident.SliceChangedEvent;

import scriptbuilder.structures.units.Unit;



/**

 * Representation of the script to be run by the TMC Simulator. Holds a list of

 * incidents, which have start and end times and contain events.

 *

 * @author Greg Eddington <geddingt@calpoly.edu>

 *

 * @author Bryan McGuffin <bmcguffi@calpoly.edu>

 * @version 2017/06/22

 */

public class SimulationScript extends Observable implements I_XML_Writable

{



    /**

     * All default options for GUI colorings of incidents.

     */

    public static final Color[] incidentColors =

    {

        Color.BLACK,

        Color.BLUE,

        Color.RED,

        new Color(0x38, 0x5E, 0x0F),

        new Color(128, 0, 128),

        Color.MAGENTA,

        new Color(0x23, 0x6B, 0x8E),

        Color.ORANGE,

        new Color(0x60, 0x33, 0x11),

        Color.GRAY

    };



    /**

     * The file to which this script will be saved.

     */

    public File saveFile = null;



    /**

     * The name of this script.

     */

    public String title = "";



    /**

     * The incidents displayed by the GUI.

     */

    public List<ScriptIncident> incidents;



    /**

     * The units which participate in Unit events.

     */

    public List<Unit> units;



    //Somewhere in the code, something assumes that the list of incidents

    //contains exactly 10 items. Until I can find and un-break that, this will do.

    private final int INCIDENT_FILL_COUNT = 10;



    /**

     * Number of incidents currently displayed.

     */

    private int numberOfIncidents;



    /**

     * Script handler for parsing incoming XML files.

     */

    private MyScriptHandler sh;



    //TODO: Pretty much everything in this constructor is dummy data.

    //Replace all of it.

    /**

     * Constructor. Backfill incident list with null objects, to be replaced

     * later.

     */

    public SimulationScript()

    {

        sh = new MyScriptHandler(this);

        incidents = new ArrayList<ScriptIncident>();

        units = new ArrayList<Unit>();

        numberOfIncidents = 0;



        //Backfill with null incidents

        for (int i = numberOfIncidents; i < INCIDENT_FILL_COUNT; i++)

        {

            incidents.add(null);

        }

    }



    /**

     * Update the script's observers.

     *

     */

    public void update()

    {

        // The script has changed, notify observers

        setChanged();

        notifyObservers(this);

    }



    /**

     * Tell this script's observers that there is a new slice event.

     *

     * @param e the slice focus event

     */

    public void broadcastEvent(SliceChangedEvent e)

    {

        // The slice focus has changed; pass the message

        setChanged();

        notifyObservers(e);

    }



    /**

     * Tell this script's observers that there is a new slice event.

     *

     * @param e the incident focus event

     */

    public void broadcastEvent(IncidentFocusedEvent e)

    {

        // The slice focus has changed; pass the message

        setChanged();

        notifyObservers(e);

    }



    /**

     * Load in an existing script from an XML file.

     *

     * @param f the file containing the script

     */

    public void loadScriptFromFile(File f)

    {

        try

        {



            SAXParserFactory.newInstance().newSAXParser().parse(f, sh);



            Vector<ScriptIncident> inc = sh.getIncidents();

            units = sh.getUnits();

            for (ScriptIncident sci : inc)

            {

                addIncident(sci);

            }

        }

        catch (Exception ex)

        {

            System.out.println("ERROR LOADING SCRIPT");

            ex.printStackTrace();

        }

        this.update();

    }



    /**

     * Add a new incident to the script.

     *

     * @param sci the incident to be added.

     * @return true if there was enough room to add this incident.

     */

    public boolean addIncident(ScriptIncident sci)

    {

        if (numberOfIncidents < INCIDENT_FILL_COUNT)

        {

            incidents.set(numberOfIncidents++, sci);

            return true;

        }

        return false;

    }



    /**

     * Write this script, in proper XML format, to the file in question.

     *

     * @param f the destination savefile to be written.

     */

    public void saveScriptToFile(File f)

    {

        try

        {

            f.createNewFile();



            BufferedWriter bw = new BufferedWriter(new FileWriter(f));

            bw.write(this.toXML());

            bw.flush();

            bw.close();



        }

        catch (Exception ex)

        {

            System.out.println("ERROR SAVING SCRIPT");

            ex.printStackTrace();

        }

    }



    @Override

    public String toXML()

    {

        ArrayList<TimeSlice> slices = allSlices();

        String output = "<?xml version=\"1.0\" encoding=\"ISO-8859-1\"?>\n";

        output += "<!DOCTYPE TMC_SCRIPT SYSTEM \"script.dtd\">\n";

        output += XMLWriter.openTag(ELEMENT.TMC_SCRIPT.tag + " title=\"" + this.title + "\"");



        if (units.size() > 0)

        {

            output += XMLWriter.openTag(ELEMENT.SCRIPT_DATA.tag);

            for (Unit unit : units)

            {

                output += unit.toXML();

            }

            output += XMLWriter.closeTag(ELEMENT.SCRIPT_DATA.tag);

        }

        for (TimeSlice slice : slices)

        {

            output += slice.toXML();

        }

        output += XMLWriter.closeTag(ELEMENT.TMC_SCRIPT.tag);

        return output;

    }



    /**

     * Arranges all timeslices in this script in chronological order, then by

     * incident number.

     *

     * @return a list of all timeslices in the simulation script

     */

    public ArrayList<TimeSlice> allSlices()

    {

        ArrayList<TimeSlice> list = new ArrayList<TimeSlice>();

        int length = absoluteLength();



        for (int i = 0; i < length; i++)

        {

            for (ScriptIncident inc : incidents)

            {



                if (inc != null && inc.slices.get(i) != null)

                {

                    list.add(inc.slices.get(i));

                }

            }

        }

        return list;

    }



    /**

     * Gets the total length of the simulation in seconds.

     *

     * @return

     */

    public int absoluteLength()

    {

        int length = 0;

        for (ScriptIncident inc : incidents)

        {

            if (inc != null)

            {

                inc.updateLength();

                int currentLength = inc.length + inc.offset;

                if (currentLength > length)

                {

                    length = currentLength;

                }

            }

        }

        return length;

    }



    /**

     * Counts the number of incidents currently running.

     *

     * @return the number of non-null incidents currently in the script. A

     * number between 0 and INCIDENT_FILL_COUNT, inclusive.

     */

    public int incidentCount()

    {

        int count = 0;

        for (ScriptIncident inc : incidents)

        {

            if (inc != null)

            {

                count++;

            }

        }

        return count;

    }



}