part of 'generator.dart';

class Vault {
  final int vx, vy;
  final DirectionSet smooth;
  final List<VaultTile> tiles;

  Vault(this.vx, this.vy, this.smooth, this.tiles) {
    assert(tiles.length == vx * vy);
  }

  void clear(VaultTile lt) {
    for (var y = 0; y < vy; y++) {
      for (var x = 0; x < vx; x++) {
        tiles[y * vx + x] = lt;
      }
    }
  }

  void blitFrom(Vault other, int dx, int dy) {
    assert(dx >= 0);
    assert(dy >= 0);
    assert(dx + other.vx <= vx);
    assert(dy + other.vy <= vy);
    for (var x = 0; x < other.vx; x++) {
      for (var y = 0; y < other.vy; y++) {
        tiles[(y + dy) * vx + x + dx] = other.tiles[y * other.vx + x];
      }
    }
  }

  Vault flip() {
    List<VaultTile> tiles2 = [
      for (var y = 0; y < vy; y++)
        for (var x = vx - 1; x >= 0; x--) tiles[y * vx + x]
    ];

    return Vault(vx, vy, smooth.flip(), tiles2);
  }

  // TODO: Actually test this logic.
  // This worked in Python, so it might even be right!
  Vault rotateRight() {
    List<VaultTile> tiles2 = [
      for (var x = 0; x < vx; x++)
        for (var y = 0; y < vy; y++) tiles[(vy - 1 - y) * vx + x]
    ];

    return Vault(vy, vx, smooth.rotateRight(), tiles2);
  }

  Vault rotateLeft() {
    List<VaultTile> tiles2 = [
      for (var x = vx - 1; x >= 0; x++)
        for (var y = vy - 1; y >= 0; y++) tiles[y * vx + (vx - 1 - x)]
    ];

    return Vault(vy, vx, smooth.rotateLeft(), tiles2);
  }

  static Vault blank(int vx, int vy, DirectionSet smooth, VaultTile lt) {
    var tiles = [
      for (var y = 0; y < vy; y++)
        for (var x = 0; x < vx; x++) lt
    ];

    return Vault(vx, vy, smooth, tiles);
  }
}