part of skysprites;


math.Random _random = new math.Random();

// Random methods

/// Returns a random [double] in the range of 0.0 to 1.0.
double randomDouble() {
  return _random.nextDouble();
}

/// Returns a random [double] in the range of -1.0 to 1.0.
double randomSignedDouble() {
  return _random.nextDouble() * 2.0 - 1.0;
}

/// Returns a random [int] from 0 to max - 1.
int randomInt(int max) {
  return _random.nextInt(max);
}

/// Returns either [true] or [false] in a most random fashion.
bool randomBool() {
  return _random.nextDouble() < 0.5;
}

// atan2

class _Atan2Constants {

  _Atan2Constants() {
    for (int i = 0; i <= size; i++) {
      double f = i.toDouble() / size.toDouble();
      ppy[i] = math.atan(f) * stretch / math.PI;
      ppx[i] = stretch * 0.5 - ppy[i];
      pny[i] = -ppy[i];
      pnx[i] = ppy[i] - stretch * 0.5;
      npy[i] = stretch - ppy[i];
      npx[i] = ppy[i] + stretch * 0.5;
      nny[i] = ppy[i] - stretch;
      nnx[i] = -stretch * 0.5 - ppy[i];
    }
  }

  static const int size = 1024;
  static const double stretch = math.PI;

  static const int ezis = -size;

  final Float64List ppy = new Float64List(size + 1);
  final Float64List ppx = new Float64List(size + 1);
  final Float64List pny = new Float64List(size + 1);
  final Float64List pnx = new Float64List(size + 1);
  final Float64List npy = new Float64List(size + 1);
  final Float64List npx = new Float64List(size + 1);
  final Float64List nny = new Float64List(size + 1);
  final Float64List nnx = new Float64List(size + 1);
}

/// Provides convenience methods for calculations often carried out in graphics.
/// Some of the methods are returning approximations.
class GameMath {
  static final _Atan2Constants _atan2 = new _Atan2Constants();

  /// Returns the angle of two vector components. The result is less acurate
  /// than the standard atan2 function in the math package.
  static double atan2(double y, double x) {
    if (x >= 0) {
      if (y >= 0) {
        if (x >= y)
          return _atan2.ppy[(_Atan2Constants.size * y / x + 0.5).toInt()];
        else
          return _atan2.ppx[(_Atan2Constants.size * x / y + 0.5).toInt()];
      } else {
        if (x >= -y)
          return _atan2.pny[(_Atan2Constants.ezis * y / x + 0.5).toInt()];
        else
          return _atan2.pnx[(_Atan2Constants.ezis * x / y + 0.5).toInt()];
      }
    } else {
      if (y >= 0) {
        if (-x >= y)
          return _atan2.npy[(_Atan2Constants.ezis * y / x + 0.5).toInt()];
        else
          return _atan2.npx[(_Atan2Constants.ezis * x / y + 0.5).toInt()];
      } else {
        if (x <= y)
          return _atan2.nny[(_Atan2Constants.size * y / x + 0.5).toInt()];
        else
          return _atan2.nnx[(_Atan2Constants.size * x / y + 0.5).toInt()];
      }
    }
  }

  /// Approximates the distance between two points. The returned value can be
  /// up to 6% wrong in the worst case.
  static double distanceBetweenPoints(Point a, Point b) {
    double dx = a.x - b.x;
    double dy = a.y - b.y;
    if (dx < 0.0) dx = -dx;
    if (dy < 0.0) dy = -dy;
    if (dx > dy) {
      return dx + dy/2.0;
    }
    else {
      return dy + dx/2.0;
    }
  }

  /// Interpolates a [double] between [a] and [b] according to the
  /// [filterFactor], which should be in the range of 0.0 to 1.0.
  static double filter (double a, double b, double filterFactor) {
      return (a * (1-filterFactor)) + b * filterFactor;
  }

  /// Interpolates a [Point] between [a] and [b] according to the
  /// [filterFactor], which should be in the range of 0.0 to 1.0.
  static Point filterPoint(Point a, Point b, double filterFactor) {
    return new Point(filter(a.x, b.x, filterFactor), filter(a.y, b.y, filterFactor));
  }

  /// Returns the intersection between two line segmentss defined by p0, p1 and
  /// q0, q1. If the lines are not intersecting null is returned.
  static Point lineIntersection(Point p0, Point p1, Point q0, Point q1) {
    double epsilon = 1e-10;

    Vector2 r = new Vector2(p1.x - p0.x, p1.y - p0.y);
    Vector2 s = new Vector2(q1.x - q0.x, q1.y - q0.y);
    Vector2 qp = new Vector2(q0.x - p0.x, q0.y - p0.y);

    double rxs = cross2(r, s);

    if (rxs.abs() < epsilon) {
      // The lines are linear or collinear
      return null;
    }

    double t = cross2(qp, s) / rxs;
    double u = cross2(qp, r) / rxs;

    if ((0.0 <= t && t <= 1.0) && (0.0 <= u && u <= 1.0)) {
      return new Point(p0.x + t * r.x, p0.y + t * r.y);
    }

    // No intersection between the lines
    return null;
  }
}