FlixelTileMapReader

/*

    dsh-piccolo-tilemap  Piccolo2D tile map nodes and supporting classes.
    Copyright (c) 2006-2011 held jointly by the individual authors.

    This library is free software; you can redistribute it and/or modify it
    under the terms of the GNU Lesser General Public License as published
    by the Free Software Foundation; either version 3 of the License, or (at
    your option) any later version.

    This library is distributed in the hope that it will be useful, but WITHOUT
    ANY WARRANTY; with out even the implied warranty of MERCHANTABILITY or
    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
    License for more details.

    You should have received a copy of the GNU Lesser General Public License
    along with this library;  if not, write to the Free Software Foundation,
    Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA.

    > http://www.fsf.org/licensing/licenses/lgpl.html
    > http://www.opensource.org/licenses/lgpl-license.php

*/
package org.dishevelled.piccolo.tilemap.io.impl;

import java.awt.Image;
import java.awt.image.BufferedImage;

import java.io.BufferedReader;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;

import java.net.URL;

import java.util.ArrayList;
import java.util.List;

import org.dishevelled.piccolo.sprite.Animations;
import org.dishevelled.piccolo.sprite.Sprite;

import org.dishevelled.piccolo.tilemap.AbstractTileMap;
import org.dishevelled.piccolo.tilemap.SparseTileMap;

/**
 * Flixel tile set + CSV file format tile map reader.
 *
 * @author  Michael Heuer
 * @version $Revision$ $Date$
 */
public class FlixelTileMapReader
    extends AbstractTileMapReader
{
    /** Tile width in pixels. */
    private final int tileWidth;

    /** Tile height in pixels. */
    private final int tileHeight;

    /** List of tile images. */
    private final List<Image> tiles;


    /**
     * Create a new flixel tile map reader with the specified tile set image.
     *
     * @param tileSet tile set image, must not be null
     * @param tileWidth tile width in pixels
     */
    public FlixelTileMapReader(final BufferedImage tileSet, final int tileWidth)
    {
        this.tileWidth = tileWidth;
        this.tileHeight = tileSet.getHeight();
        tiles = Animations.createFrameList(tileSet, 0, 0, tileWidth, tileSet.getHeight(), tileSet.getWidth() / tileWidth);
    }

    /**
     * Create a new flixel tile map reader with the specified tile set image input stream.
     *
     * @param tileSet tile set image input stream, must not be null
     * @param tileWidth tile width in pixels
     * @param tileHeight tile height in pixels
     * @param frames number of frames
     */
    public FlixelTileMapReader(final InputStream tileSet, final int tileWidth, final int tileHeight, final int frames)
    {
        this.tileWidth = tileWidth;
        this.tileHeight = tileHeight;
        try
        {
            tiles = Animations.createFrameList(tileSet, 0, 0, tileWidth, tileHeight, frames);
        }
        catch (IOException e)
        {
            throw new RuntimeException("could not read from " + tileSet);
        }
    }

    /**
     * Create a new flixel tile map reader with the specified tile set image file.
     *
     * @param tileSet tile set image file, must not be null
     * @param tileWidth tile width in pixels
     * @param tileHeight tile height in pixels
     * @param frames number of frames
     */
    public FlixelTileMapReader(final File tileSet, final int tileWidth, final int tileHeight, final int frames)
    {
        this.tileWidth = tileWidth;
        this.tileHeight = tileHeight;
        try
        {
            tiles = Animations.createFrameList(tileSet, 0, 0, tileWidth, tileHeight, frames);
        }
        catch (IOException e)
        {
            throw new RuntimeException("could not read from " + tileSet);
        }
    }

    /**
     * Create a new flixel tile map reader with the specified tile set image URL.
     *
     * @param tileSet tile set image URL, must not be null
     * @param tileWidth tile width in pixels
     * @param tileHeight tile height in pixels
     * @param frames number of frames
     */
    public FlixelTileMapReader(final URL tileSet, final int tileWidth, final int tileHeight, final int frames)
    {
        this.tileWidth = tileWidth;
        this.tileHeight = tileHeight;
        try
        {
            tiles = Animations.createFrameList(tileSet, 0, 0, tileWidth, tileHeight, frames);
        }
        catch (IOException e)
        {
            throw new RuntimeException("could not read from " + tileSet);
        }
    }


    /** {@inheritDoc} */
    public AbstractTileMap read(final InputStream inputStream) throws IOException
    {
        if (inputStream == null)
        {
            throw new IllegalArgumentException ("inputStream must not be null");
        }

        // create separate sprites for each tile map
        List<Sprite> tileSprites = new ArrayList<Sprite>(tiles.size());
        for (Image tile : tiles)
        {
            // create new single frame animation for each sprite
            tileSprites.add(new Sprite(Animations.createAnimation(tile)));
        }
        // this means that each copy of a sprite in the same tile map
        //    will be in sync
        // but those in different tile maps will not necessarily be in sync
        // ...though not sure how to specify multiple-frame sprites in this format

        int rows = 0;
        BufferedReader reader = null;
        // too bad about this...
        List<List<Sprite>> tmp = new ArrayList<List<Sprite>>();
        try
        {
            reader = new BufferedReader(new InputStreamReader(inputStream));
            while (reader.ready())
            {
                String line = reader.readLine();
                List<Sprite> row = new ArrayList<Sprite>();
                for (String value : line.split(","))
                {
                    int index = Integer.valueOf(value);
                    if (index >= 0 && index < tileSprites.size())
                    {
                        row.add(tileSprites.get(index));
                    }
                    else
                    {
                        row.add(null);
                    }
                }
                tmp.add(row);
                rows++;
            }
        }
        catch (NumberFormatException e)
        {
            throw new IOException("caught NumberFormatException at line number " + rows
                    + "\n" + e.getMessage());
            // jdk 1.6+
            //throw new IOException("caught NumberFormatException at line number " + lineNumber, e);
        }

        SparseTileMap tileMap = new SparseTileMap(tmp.get(0).size(), tmp.size(), tileWidth, tileHeight);
        for (int row = 0; row < tileHeight; row++)
        {
            for (int column = 0; column < tileWidth; column++)
            {
                Sprite sprite = tmp.get(row).get(column);
                if (sprite != null)
                {
                    tileMap.setTileRowColumn(row, column, sprite);
                }
            }
        }
        return tileMap;
   }
}