External Library issue

Hi, I am trying to use the FastNoiseLite noise libray but I keep getting the error: FastNoiseLite is not a constructor or FastNoiseLite is not defined.

In my import for events script I have:

import * as FastNoiseLite from "./fastNoiseLite.js";

export default class FastNoiseLite { //...code

const noise = new FastNoiseLite();

A couple of things to get this working.

1) Use the import in the file you need it.

import * as FastNoiseLite from "./fastNoiseLite.js";

export default FastNoiseLite {
	...
}

	import * as FastNoiseLite from "./fastNoiseLite.js";

	// Use FastNoiseLite.default to access the default export from the module
	
	const noise = new FastNoiseLite.default();
	noise.SetNoiseType(FastNoiseLite.default.NoiseType.Perlin);

	import FastNoiseLite from "./fastNoiseLite.js";

Thanks. using...

import FastNoiseLite from "./fastNoiseLite.js";

import * as FastNoiseLite from "./fastNoiseLite.js";

That last snippet that you are not sure what it is, is what classes used to look in Javascript and they are used just like classes defined with the newer syntax.

	let grad = new Grad(1, 2, 3, 4);
	grad.dot2(0, 1);

Hi again, DiegoM I tried simplexnoise2d.js but surprisingly despite its name it seems to be written in typescript. This mean when I bring it into construct I just get a ton of errors.

I always thought c3 supported typescript but it seems to rename everything to .js and also throw errors.

I just saw the help on typescript. Seems a lot of effort just to include a library.:(

I didn't try it out myself and didn't notice the main file in the repo is Typescript and that the type definitions are no where to be seen. You need those so TypeScript can work.

Anyway, it looks like you can't just copy and paste from the repo, because the code you end up using needs to be generated using a build script that is also in there.

Instead of doing that, you should download it from from NPM. That way you get the built library in both JavaScript and TypeScript. To get this working I think it's easier to just look for the Javascript file and import that in C3.

To load the library I did the following:

1. Install NPM
2. Create an empty folder somewhere, the desktop is an easy place.
3. Open that folder
4. Open a command line window in that folder (In Windows if you press SHIFT while right-clicking, you should see an "Open Powershell" option)
5. In the command line type npm i -S simplex-noise
6. That will create a node_modules folder with all the files you are looking for
7. I took the .js file in ..\node_modules\simplex-noise\dist\esm
8. Import that file into C3

After all of that, I imported in the main script with:

import { createNoise2D } from "./simplex-noise.js";

I don't know anything about noise, but I did a little bit of digging and found what looks like a rather elegant solution for your problem, so elegant that I wouldn't have been able to figure it out in a million years :P

gamedev.net/blog/33/entry-2138456-seamless-noise

Towards the end of the article there is this bit of code:

for x=0,bufferwidth-1,1 do
	for y=0,bufferheight-1,1 do
		local s=x/bufferwidth
		local t=y/bufferheight
		local dx=x2-x1
		local dy=y2-y1

		local nx=x1+cos(s*2*pi)*dx/(2*pi)
		local ny=y1+cos(t*2*pi)*dy/(2*pi)
		local nz=x1+sin(s*2*pi)*dx/(2*pi)
		local nw=y1+sin(t*2*pi)*dy/(2*pi)

		buffer:set(x,y,Noise4D(nx,ny,nz,nw))
	end
end

// Going to need 4D noise
import { createNoise4D } from "./simplex-noise.js";

const noise4D = createNoise4D();

// The size of the noise data we are going to generate
const width = 250;
const height = 250;

// Shortest way I found to declare a 2D array to store the result
const noiseTexture = Array.from({ length: width }, () => new Array(height).fill(0));

for (let x=0; width-1; x++)
{
	for (let y=0; height-1; y++)
	{
		// Do some sick math here!
		let s = x / width;
		let t = y / height;
		let dx = x2-x1;
		let dy = y2-y1;

		let nx = x1 + Math.cos(s*2*Math.PI) * dx / (2*Math.PI);
		let ny = y1 + Math.cos(t*2*Math.PI) * dy / (2*Math.PI);
		let nz = x1 + Math.sin(s*2*Math.PI) * dx / (2*Math.PI);
		let nw = y1 + Math.sin(t*2*Math.PI) * dy / (2*Math.PI);
		
		// Store the result for each coordinate
		noiseTexture[x][y] = noise4D(nx,ny,nz,nw);
	}
}