Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
/*
* MicroEmulator
* Copyright (C) 2005 Andres Navarro
*
* 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 2.1 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; without 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
*/
package javax.microedition.lcdui.game;
import javax.microedition.lcdui.Graphics;
import javax.microedition.lcdui.Image;
/**
*
* @author Andres Navarro
*/
// Synchronization is important because of two things:
// first setStaticTileSet can change the whole Object
// so any function could be running at the same time as a setStaticTileSet
// and have inconsistent behaviour
// second is the animated tiles, their indexes should be consecutive and
// two simultaneus createAnimatedTile methods could blow that up.
// One would expect only one thread accessing this class at the same time
// but it becomes a little tricky when you consider that repaints access this
// class and you have no control or knowledge of the repaint thread on most
// systems
public class TiledLayer extends Layer {
private final int rows, cols;
// package access for collision detection
Image img;
private int tileHeight, tileWidth, numStaticTiles;
// the matrix for storing the tiles
private int [][]tiles;
// the list of anmated tiles
// NOTE the first animatedTile (index -1) goes
// into the first position in the array (index 0)
// so to access the correct tile use animatedTiles[-n-1]
int []animatedTiles;
// the ammount of animated tiles
int numAnimatedTiles;
public TiledLayer(int cols, int rows, Image img, int tileWidth, int tileHeight) {
// the specification doesn't states if the TiledLayer is visible on creation
// we assume it is
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;
}
// it is synchronized to avoid problems with the animatedTiles array and count
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(Image 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());
// recalculate size
int w = cols * tileWidth;
int h = rows * tileHeight;
setSize(w, h);
this.img = img;
this.tileWidth = tileWidth;
this.tileHeight = tileHeight;
if (newNumStaticTiles >= numStaticTiles) {
this.numStaticTiles = newNumStaticTiles;
return;
}
// if there are less static tiles
// all animated tiles are discarded and
// the tiledLayer is filled with tiles with index 0
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;
}
}
}
}
// dont need for synch here as columns are a constant
// after creation
public final int getColumns() {
return cols;
}
// dont need for synch here as rows are a constant
// after creation
public final int getRows() {
return rows;
}
public final int getCellWidth() {
return tileWidth;
}
public final int getCellHeight() {
return tileHeight;
}
public final void paint(Graphics 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 cX = g.getClipX();
int cY = g.getClipY();
int cW = g.getClipWidth();
int cH = g.getClipHeight();
// take out the columns and rows that are outside of
// the clip area, this should speed things up a bit
/*
int diff = cX - x;
if (diff > 0)
c0 += diff / tW;
diff = cX + cW - (x + cMax*tW);
if (diff > 0)
cMax -= diff / tW;
diff = cY - y;
if (diff > 0)
r0 += diff / tH;
diff = cY + cH - (x + rMax*tH);
if (diff > 0)
rMax -= diff / tH;
*/
int x0 = x;
int anchor = Graphics.LEFT | Graphics.TOP;
int imgCols = img.getWidth() / tW;
int imgRows = img.getHeight() / tH;
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);
}
}
}
}
}
