TiledLayer.java :  » Game » loon-simple » org » loon » framework » game » simple » action » sprite » j2me » Android Open Source

package org.loon.framework.game.simple.action.sprite.j2me;

import org.loon.framework.game.simple.core.graphics.LImage;
import org.loon.framework.game.simple.core.graphics.device.LGraphics;

/**
 * Copyright 2008 - 2009
 * 
 * Licensed under the Apache License, Version 2.0 (the "License"); you may not
 * use this file except in compliance with the License. You may obtain a copy of
 * the License at
 * 
 * http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 * License for the specific language governing permissions and limitations under
 * the License.
 * 
 * @project loonframework
 * @author chenpeng
 * @emailceponline@yahoo.com.cn
 * @version 0.1
 */
public class TiledLayer extends Layer {
  private final int rows, cols;

  LImage img;

  private int tileHeight, tileWidth, numStaticTiles;

  private int[][] tiles;

  int[] animatedTiles;

  int numAnimatedTiles;

  public TiledLayer(int cols, int rows, LImage img, int tileWidth,
      int tileHeight) {

    super(0, 0, cols * tileWidth, rows * tileHeight, true);

    if (img == null)
      throw new NullPointerException();
    if (cols <= 0 || rows <= 0 || tileHeight <= 0 || tileWidth <= 0)
      throw new IllegalArgumentException();
    if (img.getWidth() % tileWidth != 0
        || img.getHeight() % tileHeight != 0)
      throw new IllegalArgumentException();

    this.img = img;
    this.cols = cols;
    this.rows = rows;
    this.tileWidth = tileWidth;
    this.tileHeight = tileHeight;
    this.numStaticTiles = (img.getWidth() / tileWidth)
        * (img.getHeight() / tileHeight);
    this.tiles = new int[rows][cols];
    this.animatedTiles = new int[5];
    this.numAnimatedTiles = 0;
  }

  public int createAnimatedTile(int staticTileIndex) {
    synchronized (this) {
      if (staticTileIndex < 0 || staticTileIndex > numStaticTiles)
        throw new IndexOutOfBoundsException();

      if (numAnimatedTiles == animatedTiles.length) {
        int[] temp = new int[numAnimatedTiles + 6];
        System.arraycopy(animatedTiles, 0, temp, 0, numAnimatedTiles);
        animatedTiles = temp;
      }

      animatedTiles[numAnimatedTiles] = staticTileIndex;
      numAnimatedTiles++;
      return -numAnimatedTiles;
    }
  }

  public int getAnimatedTile(int index) {
    synchronized (this) {
      index = -index - 1;
      if (index < 0 || index >= numAnimatedTiles)
        throw new IndexOutOfBoundsException();
      return animatedTiles[index];
    }
  }

  public void setAnimatedTile(int index, int staticTileIndex) {
    synchronized (this) {
      index = -index - 1;
      if (index < 0 || index >= numAnimatedTiles)
        throw new IndexOutOfBoundsException();
      if (staticTileIndex < 0 || staticTileIndex > numStaticTiles)
        throw new IndexOutOfBoundsException();

      animatedTiles[index] = staticTileIndex;
    }
  }

  public int getCell(int col, int row) {
    return this.tiles[row][col];
  }

  public void setCell(int col, int row, int index) {
    synchronized (this) {
      if (-index - 1 >= numAnimatedTiles || index > numStaticTiles)
        throw new IndexOutOfBoundsException();
      tiles[row][col] = index;
    }
  }

  public void setStaticTileSet(LImage image, int tileWidth, int tileHeight) {
    synchronized (this) {
      if (img == null)
        throw new NullPointerException();
      if (tileHeight <= 0 || tileWidth <= 0)
        throw new IllegalArgumentException();
      if (img.getWidth() % tileWidth != 0
          || img.getHeight() % tileHeight != 0)
        throw new IllegalArgumentException();

      int newNumStaticTiles = (img.getWidth() / getCellWidth())
          * (img.getHeight() / getCellHeight());

      int w = cols * tileWidth;
      int h = rows * tileHeight;

      setSize(w, h);

      this.tileWidth = tileWidth;
      this.tileHeight = tileHeight;

      if (newNumStaticTiles >= numStaticTiles) {
        this.numStaticTiles = newNumStaticTiles;
        return;
      }

      this.numStaticTiles = newNumStaticTiles;
      this.animatedTiles = new int[5];
      this.numAnimatedTiles = 0;
      this.fillCells(0, 0, getColumns(), getRows(), 0);
    }
  }

  public void fillCells(int col, int row, int numCols, int numRows, int index) {
    synchronized (this) {
      if (numCols < 0 || numRows < 0)
        throw new IllegalArgumentException();
      if (row < 0 || col < 0 || col + numCols > this.cols
          || row + numRows > this.rows)
        throw new IndexOutOfBoundsException();
      if (-index - 1 >= numAnimatedTiles || index > numStaticTiles)
        throw new IndexOutOfBoundsException();

      int rMax = row + numRows;
      int cMax = col + numCols;
      for (int r = row; r < rMax; r++) {
        for (int c = col; c < cMax; c++) {
          tiles[r][c] = index;
        }
      }
    }
  }

  public final int getColumns() {
    return cols;
  }

  public final int getRows() {
    return rows;
  }

  public final int getCellWidth() {
    return tileWidth;
  }

  public final int getCellHeight() {
    return tileHeight;
  }

  public final void paint(LGraphics g) {
    synchronized (this) {
      if (!this.isVisible())
        return;

      int x = getX();
      int y = getY();

      int c0 = 0;
      int r0 = 0;
      int cMax = getColumns();
      int rMax = getRows();

      int tW = getCellWidth();
      int tH = getCellHeight();

      int x0 = x;
      int anchor = LGraphics.LEFT | LGraphics.TOP;

      int imgCols = img.getWidth() / tW;

      for (int r = r0; r < rMax; r++, y += tH) {
        x = x0;
        for (int c = c0; c < cMax; c++, x += tW) {
          int tile = getCell(c, r);
          if (tile < 0)
            tile = getAnimatedTile(tile);
          if (tile == 0)
            continue;

          tile--;

          int xSrc = tW * (tile % imgCols);
          int ySrc = (tile / imgCols) * tH;

          g.drawRegion(img, xSrc, ySrc, tW, tH, Sprite.TRANS_NONE, x,
              y, anchor);

        }
      }
    }
  }

}