Onvalid | JSON Schemas written in Javascript | JSON Processing library

Your problem is the order:

What does the equals sign in the generic type mean?

It's the default type.

How can there be two arrows in the signature?

It's a function that returns another function. For example, this function:

I have understood the logic if anyone wants to make an input like this they can use this code

I have used react-bootstrap for styling

The Custom Input

You are always setting it to false. Move it before the if.

Sounds like you rather wanted to use e.g.

I came up with a solution. I created a base class that all other classes in my game will inherit from. It looks like this:

You can use the validationParams field to trigger the validation if a value in another field changes.

It's the gradient set being used. Directions (1, 1) point directly at diagonal neighbors. If those diagonal neighbors have (-1, -1), then they constructively interfere. Same for other corner pairs, and for when they point negative instead of positive at each other. EDIT: You can try +x + ROOT2*y, +ROOT2*x + y, and all sign permutations thereof, to produce 8 gradients.

Also, even if you improve the gradients, you may have heard that Perlin is an older method for noise, which produces a lot of 45 and 90 degree bias. There aren't a lot of cases where I recommend it. If you want to implement noise as a programming exercise, that's great. But if you want to use noise in a project, I would either code or import a good 2D simplex implementation.

EDIT: See comments. I looked at the wrong image. Solution you need, is only sample = sample * 0.5 + 0.5 to rescale the output so that the negative values don't all get cut off in the image.

Also if you want to convert your noise into a rudimentary simplex, you can do this:

1. Define constants double F2 = 0.366025403784439 and double G2 = -0.211324865405187. These will be used below, to work with the triangular grid.
2. At the beginning of GetPixel(double x, double y) add double s = (x + y) * F2; x += s; y += s;. This will convert the coordinates which produce integers on a square grid, to coordinates which produce integers on a diagonally-compressed square grid which represents equilateral triangles.
3. After you define xdec and ydec, add double t = (xdec + ydec) * G2; xdec += t; ydec += t;. This will unskew these coordinates relative to the base of the compressed square, so that they can now be used for distance and gradients again.
4. Define doubles xdec2 = xdec - 1 - G2; ydec2 = ydec - G2;. Define xdec3 = xdec - G2; ydec3 = ydec - 1 - G2;. Define xdec4 = xdec - 1 - 2*G2; ydec4 = ydec - 1 - 2*G2;. You need this, because simply subtracting 1 doesn't work anymore to get the relative coordinates to the other four corners, because the corners aren't aligned with a square anymore. Now, any time you subtract 1 from either of the coordinates, you also need to subtract G2 from both. Thus, for #2 and #3 you subtract G2 once from each, and for #4 you subtract it twice (2*G2). You can re-derive this yourself by seeing what happens if you had already subtracted 1 from one or both of the coordinates, before calculating the previous step where you define double t.
5. Change d2, d3, d4 to use these values instead, like d2 = grad(g2, xdec2, ydec2);
6. Remove everything starting with double u and ending with return yInter;. Add double value = 0;. You will add stuff to this value.
7. Define double a1 = 0.5 - xdec*xdec - ydec*ydec; double a2 = 0.5 - xdec2*xdec2 - ydec2*ydec2; and the same pattern for a3 and a4. These functions represent circles around each triangle vertex, which stop at the triangle edges.
8. Add if (a1 > 0) value += (a1 * a1) * (a1 * a1) * d1; and the same for a2, a3, a4. These add a value to the noise inside each of those circles, based on the gradient and distance.
9. If you use the improved gradients I suggested for Perlin, add return value * 38.283687591552734375;. If you use the original ones, I think the right value to multiply by is 75.3929901123046875 but I'm not sure. It will be something close to that, though. Really, you probably want more gradients for simplex, but the 8 should make it look better than Perlin at least.

The noise will not look very good without the improved gradients. You will still see a lot of 45 degree bias. If you want to really improve the noise, here is my suggestion, with 24 gradients. You can find these gradients here. Use 99.83685446303647 as the value you multiply by at the end.

There was some issue with my versions. Making all versions of aws-cdk and aws-* the same solved the issue. I did follow below steps:

• cd to your project path
• npx npm-check-updates -u
• npm install
• restart your IDE