root/as3/MapChipX/trunk/src/org/libspark/mapchipx/MapChipX.as

/*
 * MapChipX
 * Copyright (c) 2009 KAZUMiX
 * 
 * Licensed under the MIT License:
 * http://www.opensource.org/licenses/mit-license.php
 * 
*/

package org.libspark.mapchipx {
        import flash.display.Bitmap;
        import flash.display.BitmapData;
        import flash.display.Sprite;
        import flash.geom.Point;
        import flash.geom.Rectangle;
        
        public class MapChipX extends Sprite {
                
                private var map:Array;
                private var chipInfos:ChipInfoArray;
                private var frameWidth:uint;
                private var frameHeight:uint;
                private var isTransparent:Boolean;
                private var isStaticChips:Boolean;
                
                private var mapRaws:uint;
                private var mapCols:uint;
                
                private var mapWidth:uint;
                private var mapHeight:uint;
                
                private var chipWidth:uint;
                private var chipHeight:uint;
                
                private var rollMap:Sprite;
                private var tiledBitmapContainer:Bitmap;
                private var tiledBitmapData:BitmapData;
                
                private var tiledBitmapRadius:uint;

                private var prevTiledMapLTPoint:Point = new Point();

                public function MapChipX(map:Array, chipInfos:ChipInfoArray, frameWidth:uint, frameHeight:uint, isTransparent:Boolean=false, isStaticChips=false):void {
                        this.map = map;
                        this.chipInfos = chipInfos;
                        this.frameWidth = frameWidth;
                        this.frameHeight = frameHeight;
                        this.isTransparent = isTransparent;
                        this.isStaticChips = isStaticChips;
                        
                        this.mapRaws = this.map.length;
                        this.mapCols = this.map[0].length;
                        
                        this.chipWidth = chipInfos.chipWidth;
                        this.chipHeight = chipInfos.chipHeight;
                        
                        this.mapWidth = mapCols * chipWidth;
                        this.mapHeight = mapRaws * chipHeight;
                        
                        this.setupRollMap();
                        setupTiledBitmap();
                }
                
                private function setupRollMap():void {
                        rollMap = new Sprite();
                        rollMap.x = this.frameWidth / 2;
                        rollMap.y = this.frameHeight / 2;
                        addChild(rollMap);
                }
                
                private function setupTiledBitmap():void {
                        tiledBitmapRadius = Math.sqrt(frameWidth * frameWidth / 4 + frameHeight * frameHeight / 4);
                        var tiledBitmapWidth:uint = Math.ceil(tiledBitmapRadius * 2 / chipWidth + 1) * chipWidth;
                        var tiledBitmapHeight:uint = Math.ceil(tiledBitmapRadius * 2 / chipHeight + 1) * chipHeight;
                        tiledBitmapData = new BitmapData(tiledBitmapWidth, tiledBitmapHeight, isTransparent);
                        tiledBitmapContainer = new Bitmap(tiledBitmapData);
                        rollMap.addChild(tiledBitmapContainer);
                }
                
                public function update(_centerX:int, _centerY:int, _centerRotation:Number = 0) {
                        var centerX:int = _centerX % mapWidth;
                        if (centerX < 0) {
                                centerX += mapWidth;
                        }
                        var centerY:int = _centerY % mapHeight;
                        if (centerY < 0) {
                                centerY += mapHeight;
                        }
                        var centerRotation:Number = _centerRotation % 360;
                        
                        var visibleLTPoint:Point = getVisibleLeftTopPoint(centerX, centerY);
                        var visibleRBPoint:Point = getVisibleRightBottomPoint(centerX, centerY);
                        
                        var tiledMapLTPoint:Point = getTiledMapLeftTopPoint(visibleLTPoint);
                        var tiledMapRBPoint:Point = getTileMapRightBottomPoint(visibleRBPoint);
                        
                        setTiledBitmap(tiledMapLTPoint, tiledMapRBPoint);
                        setTiledBitmapPosition(centerX, centerY, tiledMapLTPoint);
                        
                        rollMap.rotation = centerRotation;
                }
                
                private function getVisibleLeftTopPoint(centerX:int, centerY:int):Point {
                        var x:Number = centerX - tiledBitmapRadius;
                        var y:Number = centerY - tiledBitmapRadius;
                        return new Point(x, y);
                }
                
                private function getVisibleRightBottomPoint(centerX:int, centerY:int):Point {
                        var x:Number = centerX + tiledBitmapRadius;
                        var y:Number = centerY + tiledBitmapRadius;
                        return new Point(x, y);
                }
                
                private function getTiledMapLeftTopPoint(visibleLTPoint:Point):Point {
                        var x:Number = Math.floor(visibleLTPoint.x / chipWidth);
                        var y:Number = Math.floor(visibleLTPoint.y / chipHeight);
                        return new Point(x, y);
                }
                
                private function getTileMapRightBottomPoint(visibleRBPoint:Point):Point {
                        var x:Number = Math.ceil(visibleRBPoint.x / chipWidth);
                        var y:Number = Math.ceil(visibleRBPoint.y / chipHeight);
                        return new Point(x, y);
                }
                
                private function setTiledBitmap(tiledMapLTPoint:Point, tiledMapRBPoint:Point):void {
                        if (isStaticChips && isSameBlock(tiledMapLTPoint)) {
                                return;
                        }
                        prevTiledMapLTPoint = tiledMapLTPoint;
                        
                        var rawOffset:int = tiledMapLTPoint.y;
                        var colOffset:int = tiledMapLTPoint.x;
                        
                        for (var raw:int = tiledMapLTPoint.y, raws:int = tiledMapRBPoint.y; raw <= raws; raw++) {
                                var tileY:uint = (raw - rawOffset) * chipHeight;
                                for ( var col:int = tiledMapLTPoint.x, cols:int = tiledMapRBPoint.x; col <= cols; col++) {
                                        var chipInfo:ChipInfo = getChipInfoFromMap(raw, col);
                                        var tileX:uint = (col - colOffset) * chipWidth;
                                        chipInfo.pasteTo(tiledBitmapData, new Point(tileX, tileY));
                                }
                        }
                }
                
                private function isSameBlock(tiledMapLTPoint:Point):Boolean {
                        if (prevTiledMapLTPoint.x == tiledMapLTPoint.x && prevTiledMapLTPoint.y == tiledMapLTPoint.y) {
                                return true;
                        }
                        return false;
                }
                
                private function getChipInfoFromMap(raw:int, col:int):ChipInfo {
                        var x:int = col % mapCols;
                        if (x < 0) {
                                x += mapCols;
                        }
                        var y:int = raw % mapRaws;
                        if (y < 0) {
                                y += mapRaws;
                        }
                        //trace(y, x);
                        return chipInfos[map[y][x]];
                }
                
                private function setTiledBitmapPosition(centerX:int, centerY:int, tiledMapLTPoint:Point):void {
                        var centerTileX:int = centerX / chipWidth;
                        var tileOffsetX:int = (tiledMapLTPoint.x - centerTileX) * chipWidth;
                        var modX:int = centerX % chipWidth;
                        var x:int = tileOffsetX - modX;
                        
                        var centerTileY:int = centerY / chipHeight;
                        var tileOffsetY:int = (tiledMapLTPoint.y - centerTileY) * chipHeight;
                        var modY:int = centerY % chipHeight;
                        var y:int = tileOffsetY - modY;
                        
                        tiledBitmapContainer.x = x;
                        tiledBitmapContainer.y = y;
                }
                
        }
        
}