package common.rng;

class SimplexGenOld {
	private static final int DIRS[][] = { { 1, 1, 0 }, { -1, 1, 0 }, { 1, -1, 0 }, { -1, -1, 0 }, { 1, 0, 1 }, { -1, 0, 1 }, { 1, 0, -1 },
			{ -1, 0, -1 }, { 0, 1, 1 }, { 0, -1, 1 }, { 0, 1, -1 }, { 0, -1, -1 } };
	private static final double SQ3NORM = 0.5D * (Math.sqrt(3D) - 1.0D);
	private static final double SQ3INV = (3D - Math.sqrt(3D)) / 6D;

	private final int bitfield[];
	private final double xVar;
	private final double zVar;
	private final double unused1;

	protected SimplexGenOld(Random random) {
		this.bitfield = new int[512];
		this.xVar = random.doublev() * 256D;
		this.zVar = random.doublev() * 256D;
		this.unused1 = random.doublev() * 256D;
		
		for(int n = 0; n < 256; n++) {
			this.bitfield[n] = n;
		}

		for(int n = 0; n < 256; n++) {
			int pos = random.zrange(256 - n) + n;
			int value = this.bitfield[n];
			this.bitfield[n] = this.bitfield[pos];
			this.bitfield[pos] = value;
			this.bitfield[n + 256] = this.bitfield[n];
		}
	}

	private static int floorClamp(double d) {
		return d <= 0.0D ? (int)d - 1 : (int)d;
	}

	private static double multPair(int n[], double xm, double zm) {
		return (double)n[0] * xm + (double)n[1] * zm;
	}

	public void generate(double noise[], double xoff, double zoff, int xsize, int zsize, double xscale, double zscale, double amp) {
		int o = 0;
		for(int n1 = 0; n1 < xsize; n1++) {
			double xv = (xoff + (double)n1) * xscale + this.xVar;
			for(int n2 = 0; n2 < zsize; n2++) {
				double zv = (zoff + (double)n2) * zscale + this.zVar;
				double d10 = (xv + zv) * SQ3NORM;
				int j1 = floorClamp(xv + d10);
				int k1 = floorClamp(zv + d10);
				double d11 = (double)(j1 + k1) * SQ3INV;
				double d12 = (double)j1 - d11;
				double d13 = (double)k1 - d11;
				double d14 = xv - d12;
				double d15 = zv - d13;
				int l1;
				int i2;
				if(d14 > d15) {
					l1 = 1;
					i2 = 0;
				}
				else {
					l1 = 0;
					i2 = 1;
				}
				double d16 = (d14 - (double)l1) + SQ3INV;
				double d17 = (d15 - (double)i2) + SQ3INV;
				double d18 = (d14 - 1.0D) + 2D * SQ3INV;
				double d19 = (d15 - 1.0D) + 2D * SQ3INV;
				int j2 = j1 & 0xff;
				int k2 = k1 & 0xff;
				int l2 = this.bitfield[j2 + this.bitfield[k2]] % 12;
				int i3 = this.bitfield[j2 + l1 + this.bitfield[k2 + i2]] % 12;
				int j3 = this.bitfield[j2 + 1 + this.bitfield[k2 + 1]] % 12;
				double d20 = 0.5D - d14 * d14 - d15 * d15;
				double d7;
				if(d20 < 0.0D) {
					d7 = 0.0D;
				}
				else {
					d20 *= d20;
					d7 = d20 * d20 * multPair(DIRS[l2], d14, d15);
				}
				double d21 = 0.5D - d16 * d16 - d17 * d17;
				double d8;
				if(d21 < 0.0D) {
					d8 = 0.0D;
				}
				else {
					d21 *= d21;
					d8 = d21 * d21 * multPair(DIRS[i3], d16, d17);
				}
				double d22 = 0.5D - d18 * d18 - d19 * d19;
				double d9;
				if(d22 < 0.0D) {
					d9 = 0.0D;
				}
				else {
					d22 *= d22;
					d9 = d22 * d22 * multPair(DIRS[j3], d18, d19);
				}
				noise[o++] += 70D * (d7 + d8 + d9) * amp;
			}

		}

	}
}
