// Generate some buildings for Wild Shadows Assemblee game
// Author: amitp@cs.stanford.edu
// License: MIT

package {
  import flash.geom.*;
  import flash.display.*;
  import flash.filters.*;
  import flash.text.*;
  import flash.events.*;
  import flash.net.*;
  import flash.utils.*;

  public class templegen extends Sprite {

    [Embed("lofi_environment_a.png")]
      public const lofi_environment_a:Class;

    public var sprites:Bitmap = new lofi_environment_a();
    
    public var SIZE:int = 30;
    public var art_gray:Object = {
      wall: 0x04, //
      floor: 0x60, //
      column: 0x61, //
      broken: 0x03,
      boulder: 0x59
    };
    public var art_brown:Object = {
      wall: 0x15, //
      floor: 0x1c, //
      column: 0x1d,
      broken: 0x16, //
      boulder: 0x5a
    };
    public var art_blue:Object = {
      wall: 0x24, //
      floor: 0xad,
      column: 0x2d,
      broken: 0x23,
      boulder: 0x59
    };

    public var art:Object = [art_brown, art_gray, art_blue][int(Math.random()*3)];

    public var tiles:Vector.<Vector.<int>> = make2dArray(SIZE, SIZE);
    public var damage:Vector.<Vector.<int>> = make2dArray(SIZE, SIZE);
    public var rendered:BitmapData = new BitmapData(SIZE*8, SIZE*8,
                                                    true, 0x2200ff00);
    
    public function templegen() {
      stage.scaleMode = "noScale";
      stage.align = "TL";
      
      addChild(new Debug(this));
      
      graphics.beginFill(0x9999aa);
      graphics.drawRect(-1000, -1000, 2000, 2000);
      graphics.endFill();

      var b:Bitmap = new Bitmap(rendered);
      b.scaleX = 2;
      b.scaleY = 2;
      b.x = 30;
      b.y = 20;
      addChild(b);

      var h:int = SIZE/3.0 * (0.5 + Math.random() + Math.random());
      var w:int = SIZE/2.5 * (0.2 + Math.random() + Math.random());
      var top:int = SIZE/2 - h/2;
      var bottom:int = SIZE/2 + h/2;
      var left:int = SIZE/2 - w/2;
      var right:int = SIZE/2 + w/2;

      Debug.trace(h, w, left, right, top, bottom);
      
      for (var x:int = left; x <= right; x++) {
        for (var y:int = top; y <= bottom; y++) {
          tiles[x][y] = art.wall;
        }
      }
      for (x = left; x <= right-1-int(Math.random()*3); x++) {
        for (y = top+1; y <= bottom-1; y++) {
          tiles[x][y] = art.floor;
        }
      }
      drawCircle(left, top, 1.5, art.wall);
      drawCircle(left, bottom, 1.5, art.wall);
      drawCircle(right, top, 2.5, art.wall);
      drawCircle(right, bottom, 2.5, art.wall);

      for (x = left+3; x <= right-3; x += 3) {
        drawCircle(x, SIZE/2 - 3, 0.9, art.column);
        drawCircle(x, SIZE/2 + 3, 0.7, art.column);
      }
      
      generateDamageRegions();
      damageMap();
      damageMap();
      damageMap();
      damageMap();
      
      draw();

      var button:TextField = new TextField();
      button.text = "Save";
      button.x = 200;
      button.background = true;
      button.selectable = false;
      button.autoSize = TextFieldAutoSize.LEFT;
      button.filters = [new BevelFilter(1)];
      button.addEventListener(MouseEvent.MOUSE_UP,
                              function (e:MouseEvent):void {
                                save();
                              });
      addChild(button);
    }

    public function save():void {
      new FileReference().save(flattenArray(tiles));
    }
    
    public function flattenArray(A:Vector.<Vector.<int>>):ByteArray {
      var B:ByteArray = new ByteArray();
      for (var x:int = 0; x < SIZE; x++) {
        for (var y:int = 0; y < SIZE; y++) {
          B.writeByte(A[x][y]);
        }
      }
      return B;
    }
    
    public function make2dArray(w:int, h:int):Vector.<Vector.<int>> {
      var v:Vector.<Vector.<int>> = new Vector.<Vector.<int>>(w);
      for (var x:int = 0; x < w; x++) {
        v[x] = new Vector.<int>(h);
        for (var y:int = 0; y < h; y++) {
          v[x][y] = 0;
        }
      }
      return v;
    }

    public function bitmapToArray(b:BitmapData, v:Vector.<Vector.<int>>):void {
      for (var x:int = 0; x < SIZE; x++) {
        for (var y:int = 0; y < SIZE; y++) {
          v[x][y] = b.getPixel(x, y) & 0xff;
        }
      }
    }

    public function drawCircle(x:int, y:int, radius:Number, tile:int):void {
      for (var dx:int = Math.floor(-radius); dx <= radius; dx++) {
        for (var dy:int = Math.floor(-radius); dy <= radius; dy++) {
          if (Math.sqrt(dx*dx + dy*dy) <= radius) {
            tiles[x+dx][y+dy] = tile;
          }
        }
      }
    }
    
    public function generateDamageRegions():void {
      var d:BitmapData = new BitmapData(SIZE, SIZE);
      d.perlinNoise(SIZE, SIZE, 3, int(100000*Math.random()),
                    false, false, 7, true);
      bitmapToArray(d, damage);
    }

    public function damageMap():void {
      var max_damage:int = 0;
      for (x = 0; x < SIZE; x++) {
        for (y = 0; y < SIZE; y++) {
          if (damage[x][y] > max_damage) {
            max_damage = damage[x][y];
          }
        }
      }
      
      for (var x:int = 0; x < SIZE; x++) {
        for (var y:int = 0; y < SIZE; y++) {
          var t:int = tiles[x][y];
          var prob:Number = damage[x][y] / 256.0;
          if (t != 0x00 && 0.5*(Math.random()+Math.random()) < prob) {
            if (t == art.wall || t == art.column) {
              t = art.broken;
            } else if (t == art.boulder) {
              // undamaged
            } else {
              t = 0x00;
            }
            if (damage[x][y] > max_damage - 20 && Math.random() < 0.2) {
              t = art.boulder;
            }
            tiles[x][y] = t;
          }
        }
      }
    }
    
    public function draw():void {
      for (var x:int = 0; x < SIZE; x++) {
        for (var y:int = 0; y < SIZE; y++) {
          var t:int = tiles[x][y];
          if (t == 0x00) t = 0x48;
          if (t != 0x00) {
            var row:int = t >> 4;
            var col:int = t & 0x0f;
            rendered.copyPixels(sprites.bitmapData,
                                new Rectangle(col*8, row*8, 8, 8),
                                new Point(x*8, y*8));
          }
        }
      }
    }
  }
}