virtual protected void init()
{
Debug.Log("init");
if (noise_set != null)
{
noise_gen = new NoiseGen1(noise_set);
}
mesh_renderer = gameObject.GetComponent <MeshRenderer>();
if (mesh_renderer == null)
{
mesh_renderer = gameObject.AddComponent <MeshRenderer>();
if (col_set.mat == null)
{
mesh_renderer.sharedMaterial = new Material(Shader.Find("Standard"));
}
else
{
mesh_renderer.sharedMaterial = col_set.mat;
}
}
mesh_filter = gameObject.GetComponent <MeshFilter>();
if (mesh_filter == null)
{
mesh_filter = gameObject.AddComponent <MeshFilter>();
}
mesh_filter.mesh = new Mesh();
}
private void UpdateDisplay()
{
switch (this.cbType.SelectedIndex)
{
case 0:
{
this._noiseGen = this._perlinNoise;
break;
}
case 1:
{
this._noiseGen = this._kochLikeNoise;
break;
}
default:
{
this._noiseGen = null;
break;
}
}
if (this._noiseGen == null)
{
this.propertyGrid1.SelectedObject = null;
}
else
{
this.propertyGrid1.SelectedObject = this._noiseGen.Settings;
}
}
public TreeFeaturePlacer(
INoiseGenerator noiseGenerator, [Inject(Id = "Feature Container")] Transform featureContainer,
IFeatureConfig config
) : base(noiseGenerator, featureContainer)
{
Config = config;
}
/// <summary>
/// Initialises a new instance of the CompoundNoiseGenerator class.
/// </summary>
/// <param name="baseGenerator">The base noise generator.</param>
/// <param name="seed">The seed value.</param>
/// <param name="octaves">The number of octaves.</param>
/// <param name="baseFrequency">The base frequency which is the frequency of the lowest octave.</param>
/// <param name="persistence">The persistence value, which determines the amplitude for each octave.</param>
public CompoundNoiseGenerator(
INoiseGenerator baseGenerator,
int seed,
byte octaves,
float baseFrequency,
float persistence)
{
this.baseGenerator = baseGenerator;
this.octaves = octaves;
// Generate the seed for each octave's noise function
var random = new Random(seed);
this.seeds = new Dictionary<byte, int>(this.octaves);
for (byte i = 0; i < this.octaves; i++)
{
this.seeds[i] = random.Next();
}
// Pre-calculate the frequency for each octave
this.frequencies = new Dictionary<byte, float>(this.octaves);
for (byte i = 0; i < this.octaves; i++)
{
this.frequencies[i] = (float)Math.Pow(2, i) * baseFrequency;
}
// Pre-calculate the amplitude for each octave
this.amplitudes = new Dictionary<byte, float>(this.octaves);
for (byte i = 0; i < this.octaves; i++)
{
this.amplitudes[i] = (float)Math.Pow(persistence, i);
}
}
public FeaturePlacerBase(
INoiseGenerator noiseGenerator, [Inject(Id = "Feature Container")] Transform featureContainer
)
{
NoiseGenerator = noiseGenerator;
FeatureContainer = featureContainer;
}
virtual public void updateFromParent(INoiseGenerator ng, ChunkSettings cs, Vector3 pos)
{
chunk_set = cs;
transform.position = pos;
noise_gen = ng;
updateMesh();
}
public TerrainGenerator(int seed, IEnvironmentGenerator[] environmentGenerators, INoiseGenerator surfaceGenerator, INoiseGenerator biomeGenerator)
{
objectLock = new object();
this.environmentGenerators = environmentGenerators;
this.surfaceGenerator = surfaceGenerator;
this.biomeGenerator = biomeGenerator;
}
public CityFeaturePlacer(
INoiseGenerator noiseGenerator, [Inject(Id = "Feature Container")] Transform featureContainer,
IFeatureConfig config, IPossessionRelationship <IHexCell, ICity> cityLocationCanon
) : base(noiseGenerator, featureContainer)
{
Config = config;
CityLocationCanon = cityLocationCanon;
}
public bool AddGeneratorToLoadedGenerators(INoiseGenerator generator)
{
if(mLoadedGenerators.ContainsKey(generator.Name))
{
return false;
}
mLoadedGenerators.Add(generator.Name, generator);
return true;
}
public HybridMultiFractal(INoiseGenerator noise, double octaves, double lacunarity, double h = 0.25, double offset = 0.7)
{
_lacunarity = lacunarity;
_octaves = octaves;
_offset = offset;
_noise = noise;
_exponentArray = InitializeExponentArray(octaves, lacunarity, h);
}
public HillsHeightmapLogic(
IMapRenderConfig renderConfig, INoiseGenerator noiseGenerator,
IFlatlandsHeightmapLogic flatlandsHeightmapLogic
)
{
RenderConfig = renderConfig;
NoiseGenerator = noiseGenerator;
FlatlandsHeightmapLogic = flatlandsHeightmapLogic;
}
public EncampmentFeaturePlacer(
INoiseGenerator noiseGenerator, [Inject(Id = "Feature Container")] Transform featureContainer,
IFeatureConfig config, IEncampmentLocationCanon encampmentLocationCanon
) : base(noiseGenerator, featureContainer)
{
Config = config;
EncampmentLocationCanon = encampmentLocationCanon;
}
public RidgedMultiFractal(INoiseGenerator baseBaseNoise, int octaves, double lacunarity, double H = 1.0, double offset = 1.0, double gain = 2.0)
{
_gain = gain;
_offset = offset;
_lacunarity = lacunarity;
_octaves = octaves;
_baseNoise = baseBaseNoise;
_exponentArray = InitializeExponentArray(octaves, lacunarity, H);
}
public RidgedMultiFractal(INoiseGenerator baseBaseNoise, int octaves, double lacunarity, double H = 1.0, double offset = 1.0, double gain = 2.0)
{
_gain = gain;
_offset = offset;
_lacunarity = lacunarity;
_octaves = octaves;
_baseNoise = baseBaseNoise;
_exponentArray = InitializeExponentArray(octaves, lacunarity, H);
}
// Use this for initialization
void Awake()
{
var generator = new FastNoise();
generator.SetFrequency(noiseFrequency);
generator.SetFractalOctaves(4);
generator.SetNoiseType(FastNoise.NoiseType.PerlinFractal);
noiseGenerator = generator;
}
public HybridMultiFractal(INoiseGenerator noise, double octaves, double lacunarity, double h = 0.25, double offset = 0.7)
{
_lacunarity = lacunarity;
_octaves = octaves;
_offset = offset;
_noise = noise;
_exponentArray = InitializeExponentArray(octaves, lacunarity, h);
}
public void UpdateSettings(ColorSettings settings)
{
this.settings = settings;
biomeNoiseGenerator = NoiseGeneratorFactory.CreateNoiseGenerator(settings.biomeColorSettings.noise);
if (texture == null || texture.height != NumBiomes)
{
texture = new Texture2D(NumberColors * 2, NumBiomes * 2 - 2, TextureFormat.RGBA32, false);
}
}
static float SampleHeight(int x, int y, INoiseGenerator generator)
{
//This creates the noise used for the ground.
//The last value (8.0f) is the amp that defines (roughly) the maximum
//and minimum vaule the ground varies from the surface level
//return perlin.FractalNoise3D(pos.x, pos.y, pos.z, 4, 80.0f, 8.0f);
var noise = generator.GetNoise(x, y);
return((1.0f + noise) * 0.3f);
}
public void Generate(string[] s)
{
if(MainConsole.Instance.ConsoleScene == null)
{
MainConsole.Instance.Output("Select a scene first");
return;
}
//string noiseGen = MainConsole.Instance.CmdPrompt("Noise generator (Perlin or Kosh)", "Perlin", new List<string>(new [] { "Perlin", "Kosh" }));
//if(noiseGen == "Perlin")
{
_noiseGen = m_perlinNoise;
PerlinNoiseSettings pns = new PerlinNoiseSettings();
pns.ResultX = MainConsole.Instance.ConsoleScene.RegionInfo.RegionSizeX;
pns.ResultY = MainConsole.Instance.ConsoleScene.RegionInfo.RegionSizeY;
pns.RandomSeed = int.Parse(MainConsole.Instance.Prompt("Random Seed (0-infinity)", "10"));
pns.CorsenessX = int.Parse(MainConsole.Instance.Prompt("Corseness (X direction) (2-1000)", "100"));
pns.CorsenessY = int.Parse(MainConsole.Instance.Prompt("Corseness (Y direction) (2-1000)", "100"));
pns.FlatEdges = MainConsole.Instance.Prompt("Flat Edges (recommended)", "true", new List<string>(new[] { "true", "false" })) == "true";
pns.Octaves = int.Parse(MainConsole.Instance.Prompt("Octaves (0-infinity)", "5"));
pns.Persistence = float.Parse(MainConsole.Instance.Prompt("Persistence", "0.8"));
_noiseGen.Settings = pns;
}
/*else
{
_noiseGen = m_kochLikeNoise;
KochLikeNoiseSettings kns = new KochLikeNoiseSettings();
kns.ResultX = MainConsole.Instance.Prompt.RegionInfo.RegionSizeX;
kns.ResultY = MainConsole.Instance.Prompt.RegionInfo.RegionSizeY;
kns.H = double.Parse(MainConsole.Instance.Prompt("H", "1.0"));
kns.InitalGridX = int.Parse(MainConsole.Instance.Prompt("Initial Grid X", "2"));
if(kns.InitalGridX < 2)
kns.InitalGridX = 2;
kns.InitalGridY = int.Parse(MainConsole.Instance.Prompt("Initial Grid Y", "2"));
if(kns.InitalGridY < 2)
kns.InitalGridY = 2;
kns.RandomMin = int.Parse(MainConsole.Instance.Prompt("Random Min", "-1"));
kns.RandomMax = int.Parse(MainConsole.Instance.Prompt("Random Max", "1"));
kns.RandomSeed = int.Parse(MainConsole.Instance.Prompt("Random Seed", "0"));
kns.Scale = double.Parse(MainConsole.Instance.Prompt("Scale", "1.0"));
_noiseGen.Settings = kns;
}*/
float scaling = float.Parse(MainConsole.Instance.Prompt("Fractal Scaling", "50"));
float[,] land = _noiseGen.Generate();
ITerrainChannel c = new TerrainChannel(MainConsole.Instance.ConsoleScene);
for(int x = 0; x < MainConsole.Instance.ConsoleScene.RegionInfo.RegionSizeX; x++)
{
for(int y = 0; y < MainConsole.Instance.ConsoleScene.RegionInfo.RegionSizeY; y++)
{
c[x, y] = (land[x, y] * scaling) + (float)MainConsole.Instance.ConsoleScene.RegionInfo.RegionSettings.WaterHeight + 10;
}
}
MainConsole.Instance.ConsoleScene.RequestModuleInterface<ITerrainModule>().TerrainMap = c;
MainConsole.Instance.ConsoleScene.RequestModuleInterface<ITerrainModule>().TaintTerrain();
MainConsole.Instance.ConsoleScene.RegisterModuleInterface<ITerrainChannel>(c);
}
public void InjectDependencies(
INoiseGenerator noiseGenerator, IFeatureLocationLogic featureLocationLogic,
List <IFeaturePlacer> featurePlacers,
[InjectOptional(Id = "Feature Container")] Transform featureContainer
)
{
NoiseGenerator = noiseGenerator;
FeatureLocationLogic = featureLocationLogic;
FeaturePlacers = featurePlacers;
FeatureContainer = featureContainer;
}
public ResourceFeaturePlacer(
INoiseGenerator noiseGenerator, [Inject(Id = "Feature Container")] Transform featureContainer,
IFeatureConfig config, IPossessionRelationship <IHexCell, IResourceNode> resourceNodeLocationCanon,
IVisibilityCanon visibilityCanon
) : base(noiseGenerator, featureContainer)
{
Config = config;
ResourceNodeLocationCanon = resourceNodeLocationCanon;
VisibilityCanon = visibilityCanon;
}
virtual public void createdByParent(INoiseGenerator ng, ChunkSettings cs, Vector3 pos)
{
Debug.Log("created by parent");
//noise_set = ns;
chunk_set = cs;
has_parent = true;
noise_gen = ng;
init();
updateMesh();
transform.position = pos;
}
public void Generate(IScene scene, string[] s)
{
//string noiseGen = MainConsole.Instance.CmdPrompt("Noise generator (Perlin or Kosh)", "Perlin", new List<string>(new [] { "Perlin", "Kosh" }));
//if(noiseGen == "Perlin")
{
_noiseGen = m_perlinNoise;
PerlinNoiseSettings pns = new PerlinNoiseSettings();
pns.ResultX = scene.RegionInfo.RegionSizeX;
pns.ResultY = scene.RegionInfo.RegionSizeY;
pns.RandomSeed = int.Parse(MainConsole.Instance.Prompt("Random Seed (0-infinity)", "10"));
pns.CorsenessX = int.Parse(MainConsole.Instance.Prompt("Corseness (X direction) (2-1000)", "100"));
pns.CorsenessY = int.Parse(MainConsole.Instance.Prompt("Corseness (Y direction) (2-1000)", "100"));
pns.FlatEdges = MainConsole.Instance.Prompt("Flat Edges (recommended)", "true", new List <string>(new[] { "true", "false" })) == "true";
pns.Octaves = int.Parse(MainConsole.Instance.Prompt("Octaves (0-infinity)", "5"));
pns.Persistence = float.Parse(MainConsole.Instance.Prompt("Persistence", "0.8"));
_noiseGen.Settings = pns;
}
/*else
* {
* _noiseGen = m_kochLikeNoise;
* KochLikeNoiseSettings kns = new KochLikeNoiseSettings();
* kns.ResultX = MainConsole.Instance.Prompt.RegionInfo.RegionSizeX;
* kns.ResultY = MainConsole.Instance.Prompt.RegionInfo.RegionSizeY;
* kns.H = double.Parse(MainConsole.Instance.Prompt("H", "1.0"));
* kns.InitalGridX = int.Parse(MainConsole.Instance.Prompt("Initial Grid X", "2"));
* if(kns.InitalGridX < 2)
* kns.InitalGridX = 2;
* kns.InitalGridY = int.Parse(MainConsole.Instance.Prompt("Initial Grid Y", "2"));
* if(kns.InitalGridY < 2)
* kns.InitalGridY = 2;
* kns.RandomMin = int.Parse(MainConsole.Instance.Prompt("Random Min", "-1"));
* kns.RandomMax = int.Parse(MainConsole.Instance.Prompt("Random Max", "1"));
* kns.RandomSeed = int.Parse(MainConsole.Instance.Prompt("Random Seed", "0"));
* kns.Scale = double.Parse(MainConsole.Instance.Prompt("Scale", "1.0"));
* _noiseGen.Settings = kns;
* }*/
float scaling = float.Parse(MainConsole.Instance.Prompt("Fractal Scaling", "50"));
float[,] land = _noiseGen.Generate();
ITerrainChannel c = new TerrainChannel(scene);
for (int x = 0; x < scene.RegionInfo.RegionSizeX; x++)
{
for (int y = 0; y < scene.RegionInfo.RegionSizeY; y++)
{
c[x, y] = (land[x, y] * scaling) + (float)scene.RegionInfo.RegionSettings.WaterHeight + 10;
}
}
scene.RequestModuleInterface <ITerrainModule>().TerrainMap = c;
scene.RequestModuleInterface <ITerrainModule>().TaintTerrain();
scene.RegisterModuleInterface <ITerrainChannel>(c);
}
/// <summary>
/// Initializes a new instance of the <see cref="OrientationParticleFilter"/> class.
/// </summary>
/// <param name="noiseGenerator">See noiseGenerator argument of the constructor of <seealso cref="AbstractParticleFilter"/></param>
/// <param name="resampleNoiseSize">See resampleNoiseSize argument of the constructor of <seealso cref="AbstractParticleFilter"/></param>
/// <param name="resampler">See resampler argument of the constructor of <seealso cref="AbstractParticleFilter"/></param>
/// <param name="particleGenerator">See particleGenerator argument of the constructor of <seealso cref="AbstractParticleFilter"/></param>
/// <param name="particleAmount">See particleAmount argument of the constructor of <seealso cref="AbstractParticleFilter"/></param>
/// <param name="smoother">See smoother argument of the constructor of <seealso cref="AbstractParticleFilter"/></param>
public OrientationParticleFilter(INoiseGenerator noiseGenerator, float resampleNoiseSize, IResampler resampler, IParticleGenerator particleGenerator, int particleAmount, ISmoother smoother)
: base(
resampler,
noiseGenerator,
new CircularParticleController(particleGenerator, particleAmount),
new CircularParticleController(particleGenerator, particleAmount),
new CircularParticleController(particleGenerator, particleAmount),
resampleNoiseSize,
smoother,
AngleMath.Average)
{
this.orientationSources = new List <IOrientationSource>();
}
public ImplicitChunkHeightMap(Bounds2D bounds, int columns, int rows, INoiseGenerator noiseGenerator)
{
_noiseGenerator = noiseGenerator;
_rows = rows;
_columns = columns;
_bounds = bounds;
var origin = CalculatePosition(0, 0);
var position = CalculatePosition(1, 1);
_dx = 1 / (position.X - origin.X);
_dy = 1 / (position.Y - origin.Y);
}
/// <summary>
/// Initialises a new instance of the TerrainPointGenerator class.
/// </summary>
/// <param name="baseGenerator">The base noise generator.</param>
/// <param name="seed">The seed value for the terrain.</param>
/// <param name="octaves">The number of octaves of noise used by the terrain generator.</param>
/// <param name="baseFrequency">The base frequency which is the frequency of the lowest octave used by the
/// terrain generator.</param>
/// <param name="persistence">The persistence value, which determines the amplitude for each octave used by the
/// terrain generator.</param>
public TerrainPointGenerator(
INoiseGenerator baseGenerator,
int seed,
int octaves,
float baseFrequency,
float persistence)
{
this.baseGenerator = baseGenerator;
this.surfaceGenerator =
new CompoundNoiseGenerator(this.baseGenerator, seed, (byte)octaves, baseFrequency, persistence);
// Set the cave attributes
this.caves = this.CreateCaveAttributes(seed);
}
public MinimalSphereCoveringAnalyzer(INoiseGenerator noiseGenerator, ILogger <MinimalSphereCoveringAnalyzer> logger)
{
if (noiseGenerator == null)
{
throw new ArgumentNullException(nameof(noiseGenerator));
}
if (logger == null)
{
throw new ArgumentNullException(nameof(logger));
}
_noiseGenerator = noiseGenerator;
_logger = logger;
}
public ListsSizesDistributionAnalyzer(INoiseGenerator noiseGenerator, ILogger <ListsSizesDistributionAnalyzer> logger)
{
if (noiseGenerator == null)
{
throw new ArgumentNullException(nameof(noiseGenerator));
}
if (logger == null)
{
throw new ArgumentNullException(nameof(logger));
}
_noiseGenerator = noiseGenerator;
_logger = logger;
}
// Not needed for now
public void GenerateWorld(int size)
{
_mapSize = size;
_allTiles = new MapTile[size][];
_heightMapGenerator = CreateHeightMapGenerator();
_temperatureMapGenerator = CreateTemperatureMapGenerator();
_moistureMapGenerator = CreateMoistureMapGenerator();
_aggregationSelector = new BasicBiomeSelector();
GenerateTiles(size);
}
public FarmTriangulator(
IHexGrid grid, IImprovementLocationCanon improvementLocationCanon, INoiseGenerator noiseGenerator,
IMapRenderConfig renderConfig, IGeometry2D geometry2D, ICellEdgeContourCanon cellContourCanon,
IRiverCanon riverCanon, MapRenderingSignals mapRenderingSignals
)
{
Grid = grid;
ImprovementLocationCanon = improvementLocationCanon;
NoiseGenerator = noiseGenerator;
RenderConfig = renderConfig;
Geometry2D = geometry2D;
CellContourCanon = cellContourCanon;
RiverCanon = riverCanon;
MapRenderingSignals = mapRenderingSignals;
}
public RiverTriangulator(
IMapRenderConfig renderConfig, IRiverSplineBuilder riverSplineBuilder,
INoiseGenerator noiseGenerator, ICellEdgeContourCanon cellEdgeContourCanon,
INonRiverContourBuilder nonRiverContourBuilder, IHexGrid grid,
IRiverContourRationalizer riverContourCuller
)
{
RenderConfig = renderConfig;
RiverSplineBuilder = riverSplineBuilder;
NoiseGenerator = noiseGenerator;
CellEdgeContourCanon = cellEdgeContourCanon;
NonRiverContourBuilder = nonRiverContourBuilder;
Grid = grid;
RiverContourRationalizer = riverContourCuller;
}
protected static DecodingTestCase PrepareDecodingTestCase(
ICode code,
INoiseGenerator noiseGenerator,
int?errorsCount = null,
IEnumerable <int> informationWord = null) =>
new DecodingTestCase
{
Code = code,
InformationWord = informationWord?.Select(x => code.Field.CreateElement(x)).ToArray()
?? Enumerable.Repeat(code.Field.Zero(), code.InformationWordLength).ToArray(),
AdditiveNoise = noiseGenerator
.VariatePositionsAndValues(code.Field, code.CodewordLength, errorsCount ?? (code.CodeDistance - 1) / 2)
.Skip(30)
.First()
};
override protected void init()
{
Debug.Log("host init");
if (chunks == null || chunks.Length == 0)
{
Debug.Log("create chunks array");
chunks = new GameObject[chunk_host_set.length * chunk_host_set.width];
}
if (chunks.Length != chunk_host_set.length * chunk_host_set.width)
{
Debug.Log("resizing chunk array");
resizeChunksArr();
}
GameObject obj;
for (int i = 0; i < chunk_host_set.length; i++)
{
for (int j = 0; j < chunk_host_set.width; j++)
{
obj = getChunkObj(i, j);
if (obj == null)
{
obj = new GameObject();
obj.transform.parent = transform;
FlatChunk fc = obj.AddComponent <FlatChunk>();
INoiseGenerator ng = getNoiseGen(i, j);
fc.createdByParent(ng, chunk_set, getPos(i, j));
setChunkObj(i, j, obj);
}
else
{
obj.GetComponent <FlatChunk>().createdByParent(
getNoiseGen(i, j),
chunk_set,
Vector3.Scale(getPos(i, j), transform.localScale)
);
}
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="AbstractParticleFilter"/> class.
/// </summary>
/// <param name="resampler"><see cref="resampler"/></param>
/// <param name="noiseGenerator"><see cref="noiseGenerator"/></param>
/// <param name="particleControllerX"><see cref="ParticleControllerX"/></param>
/// <param name="particleControllerY">The particles for the y dimension</param>
/// <param name="particleControllerZ">The particles for the z dimension</param>
/// <param name="resampleNoiseSize"><see cref="resampleNoiseSize"/></param>
/// <param name="smoother"><see cref="smoother"/></param>
/// <param name="averageCalculator"><see cref="averageCalculator"/></param>
protected AbstractParticleFilter(
IResampler resampler,
INoiseGenerator noiseGenerator,
AbstractParticleController particleControllerX,
AbstractParticleController particleControllerY,
AbstractParticleController particleControllerZ,
float resampleNoiseSize,
ISmoother smoother,
Func <float[], float> averageCalculator)
{
this.resampler = resampler;
this.noiseGenerator = noiseGenerator;
this.ParticleControllerX = particleControllerX;
this.ParticleControllerY = particleControllerY;
this.ParticleControllerZ = particleControllerZ;
this.resampleNoiseSize = resampleNoiseSize;
this.smoother = smoother;
this.averageCalculator = averageCalculator;
this.CurrentTimeStamp = -1;
this.Measurements = new List <Measurement <Vector3> >();
}
static Program()
{
var configuration = new ConfigurationBuilder()
.AddJsonFile("appsettings.json")
.Build();
var loggerFactory = new LoggerFactory()
.AddSerilog(
new LoggerConfiguration()
.ReadFrom.Configuration(configuration)
.Enrich.FromLogContext()
.Enrich.WithProperty("Version", Assembly.GetEntryAssembly().GetName().Version.ToString(4))
.CreateLogger()
);
Logger = loggerFactory.CreateLogger <Program>();
NoiseGenerator = new RecursiveGenerator();
WordsComparer = new FieldElementsArraysComparer();
LinearCodeDistanceAnalyzer = new LinearCodeDistanceAnalyzer(loggerFactory.CreateLogger <LinearCodeDistanceAnalyzer>());
MinimalSphereCoveringAnalyzer = new MinimalSphereCoveringAnalyzer(NoiseGenerator, loggerFactory.CreateLogger <MinimalSphereCoveringAnalyzer>());
ListsSizesDistributionAnalyzer = new ListsSizesDistributionAnalyzer(NoiseGenerator, loggerFactory.CreateLogger <ListsSizesDistributionAnalyzer>());
var gaussSolver = new GaussSolver();
TelemetryCollector = new GsBasedDecoderTelemetryCollectorForGsBasedDecoder();
FixedDistanceCodesFactory
= new StandardCodesFactory(
new LiftingSchemeBasedBuilder(new GcdBasedBuilder(new RecursiveGcdFinder()), gaussSolver),
new RsBasedDecoder(new BerlekampWelchDecoder(gaussSolver), gaussSolver),
new GsBasedDecoder(
new GsDecoder(new KotterAlgorithmBasedBuilder(new PascalsTriangleBasedCalculator()), new RrFactorizator()),
gaussSolver
)
{
TelemetryCollector = TelemetryCollector
}
);
}
/// <summary>
/// Initializes a new instance of the <see cref="PositionParticleFilter"/> class.
/// </summary>
/// <param name="noiseGenerator">See noiseGenerator argument of the constructor of <seealso cref="AbstractParticleFilter"/></param>
/// <param name="resampleNoiseSize">See resampleNoiseSize argument of the constructor of <seealso cref="AbstractParticleFilter"/></param>
/// <param name="resampler">See resampler argument of the constructor of <seealso cref="AbstractParticleFilter"/></param>
/// <param name="particleGenerator">See particleGenerator argument of the constructor of <seealso cref="AbstractParticleFilter"/></param>
/// <param name="particleAmount">See particleAmount argument of the constructor of <seealso cref="AbstractParticleFilter"/></param>
/// <param name="fieldSize">The dimensions of the area where the user can be.</param>
/// <param name="smoother">See smoother argument of the constructor of <seealso cref="AbstractParticleFilter"/></param>
public PositionParticleFilter(
INoiseGenerator noiseGenerator,
float resampleNoiseSize,
IResampler resampler,
IParticleGenerator particleGenerator,
int particleAmount,
FieldSize fieldSize,
ISmoother smoother)
: base(
resampler,
noiseGenerator,
new LinearParticleController(particleGenerator, particleAmount, fieldSize.Xmin, fieldSize.Xmax),
new LinearParticleController(particleGenerator, particleAmount, fieldSize.Ymin, fieldSize.Ymax),
new LinearParticleController(particleGenerator, particleAmount, fieldSize.Zmin, fieldSize.Zmax),
resampleNoiseSize,
smoother,
Enumerable.Average)
{
this.displacementSources = new List <IDisplacementSource>();
this.positionSources = new List <IPositionSource>();
this.iex = new LinearRegression();
this.iey = new LinearRegression();
this.iez = new LinearRegression();
}
public FractalBrownianMotionSpectralGenerator(INoiseGenerator noiseGenerator)
{
_noiseGenerator = noiseGenerator;
}
public RidgedMultiFractalSpectralGenerator(INoiseGenerator noiseGenerator)
{
_noiseGenerator = noiseGenerator;
}
public PerlinNoiseElevation(INoiseGenerator noiseGenerator)
{
this.m_NoiseGenerator = noiseGenerator;
}
public void SetUp()
{
_noiseGenerator = MockRepository.GenerateStub<INoiseGenerator>();
}
public ScaledNoiseGenerator()
{
_largeScaleNoise = new ImprovedPerlinNoise(4711);
_noise = new NoiseFactory.RidgedMultiFractal().Create(new NoiseFactory.NoiseParameters());
}
public HeightMapGenerator(INoiseGenerator noiseGenerator)
{
_noiseGenerator = noiseGenerator;
}
public SlowedHeightIncreaseNoiseDecorator(INoiseGenerator generator)
: base(generator)
{
}
public TerrainGenerator(INoiseGenerator noiseGenerator)
{
//_noise = new FractalBrownianMotion(new SimplexNoise(), settings);
_noise = noiseGenerator;//new RidgedMultiFractal(new SimplexNoise(), 7, 2.1347);
_colorCycle = new ColorCycle();
}
public FractalBrownianMotion(INoiseGenerator noiseGenerator, FractalBrownianMotionSettings settings)
{
_settings = settings;
_noiseGenerator = noiseGenerator;
}
public NormNoiseDecorator(INoiseGenerator generator)
: base(generator)
{
}
protected NoiseDecorator(INoiseGenerator generator)
{
this.m_Generator = generator;
}
public DistanceFromWaterElevation(INoiseGenerator noiseGenerator)
{
this.m_NoiseGenerator = noiseGenerator;
}
public NoiseDecorator(double amplitude, double frequency, INoiseGenerator noiseGenerator)
{
_noiseGenerator = noiseGenerator;
_frequency = frequency;
_amplitude = amplitude;
}
public DiamondSquareHeightOffsetGenerator(int seed, double roughness, INoiseGenerator noiseGenerator)
{
_noiseGenerator = noiseGenerator;
_roughness = roughness;
_random = new Random(seed);
}
public void GenerateTerrain(IScene scene, string[] s)
{
string noiseType = MainConsole.Instance.Prompt("Noise generator (Perlin or Kosh)", "Perlin");
bool perlinNoise = noiseType.ToLower().StartsWith("p");
int baseHeight;
if (perlinNoise)
{
_noiseGen = m_perlinNoise;
PerlinNoiseSettings pns = new PerlinNoiseSettings();
pns.ResultX = scene.RegionInfo.RegionSizeX;
pns.ResultY = scene.RegionInfo.RegionSizeY;
pns.RandomSeed = int.Parse(MainConsole.Instance.Prompt("Random Seed (0-infinity)", "10"));
pns.CorsenessX = int.Parse(MainConsole.Instance.Prompt("Coarseness (X direction) (2-1000)", "100"));
pns.CorsenessY = int.Parse(MainConsole.Instance.Prompt("Coarseness (Y direction) (2-1000)", "100"));
pns.FlatEdges = MainConsole.Instance.Prompt("Flat Edges (recommended)", "true", new List<string>(new[] { "true", "false" })) == "true";
pns.Octaves = int.Parse(MainConsole.Instance.Prompt("Octaves (0-infinity)", "5"));
pns.Persistence = float.Parse(MainConsole.Instance.Prompt("Persistence", "0.8"));
_noiseGen.Settings = pns;
baseHeight = 30;
}
else
{
_noiseGen = m_kochLikeNoise;
KochLikeNoiseSettings kns = new KochLikeNoiseSettings();
//kns.ResultX = MainConsole.Instance.Prompt.RegionInfo.RegionSizeX;
//kns.ResultY = MainConsole.Instance.Prompt.RegionInfo.RegionSizeY;
kns.ResultX = scene.RegionInfo.RegionSizeX * 2;
kns.ResultY = scene.RegionInfo.RegionSizeY * 2;
kns.H = double.Parse(MainConsole.Instance.Prompt("Smoothing (Higher values are smoother)", "1.5"));
kns.InitalGridX = int.Parse(MainConsole.Instance.Prompt("Initial Grid X", "2"));
if(kns.InitalGridX < 2)
kns.InitalGridX = 2;
kns.InitalGridY = int.Parse(MainConsole.Instance.Prompt("Initial Grid Y", "2"));
if(kns.InitalGridY < 2)
kns.InitalGridY = 2;
// grid X/Y divide the region so...
// kns.ResultX = kns.ResultX * kns.InitalGridX;
// kns.ResultY = kns.ResultY * kns.InitalGridY;
kns.RandomMin = int.Parse(MainConsole.Instance.Prompt("Random Min", "-1"));
kns.RandomMax = int.Parse(MainConsole.Instance.Prompt("Random Max", "1"));
kns.RandomSeed = int.Parse(MainConsole.Instance.Prompt("Random Seed", "0"));
kns.Scale = double.Parse(MainConsole.Instance.Prompt("Scale", "1.0"));
_noiseGen.Settings = kns;
baseHeight = 0;
}
float scaling = float.Parse(MainConsole.Instance.Prompt("Fractal Scaling", "50"));
float[,] land = _noiseGen.Generate();
ITerrainChannel c = new TerrainChannel(scene);
for(int x = 0; x < scene.RegionInfo.RegionSizeX; x++)
{
for(int y = 0; y < scene.RegionInfo.RegionSizeY; y++)
{
c[x, y] = (land[x, y] * scaling) + (float)scene.RegionInfo.RegionSettings.WaterHeight + baseHeight;
}
}
scene.RequestModuleInterface<ITerrainModule>().TerrainMap = c;
scene.RequestModuleInterface<ITerrainModule>().TaintTerrain();
scene.RegisterModuleInterface<ITerrainChannel>(c);
}
/// <summary>
/// Initialises a new instance of the SeededNoiseGenerator class.
/// </summary>
/// <param name="baseGenerator">The base noise generator.</param>
/// <param name="seed">The seed value.</param>
public SeededNoiseGenerator(INoiseGenerator baseGenerator, int seed)
{
this.baseGenerator = baseGenerator;
this.seed = seed;
}
public ImplicitChunkHeightMap(Box3D bounds, int columns, int rows, INoiseGenerator noiseGenerator)
{
_noiseGenerator = noiseGenerator;
_rows = rows;
_columns = columns;
_bounds = bounds;
var origin = CalculatePosition(0, 0);
var position = CalculatePosition(1, 1);
_dx = 1 / (position.X - origin.X);
_dy = 1 / (position.Y - origin.Y);
}
public ChunkNoiseGenerator(Vector2 offset, INoiseGenerator noiseGenerator)
{
_offset = offset;
_noiseGenerator = noiseGenerator;
}
private static void Run()
{
Console.Write("Please enter width in pixels : ");
var width = int.Parse(Console.ReadLine());
Console.Write("Please enter height in pixels : ");
var height = int.Parse(Console.ReadLine());
Console.Write("Press 1 to use Perlin, 2 to use Improved Perlin : ");
if(int.Parse(Console.ReadLine()) == 1)
_noiseGenerator = new Perlin();
else
_noiseGenerator = new PerlinImproved();
//Console.Write("Please enter Frequency (0.01) : ");
//_noiseGenerator.Frequency = float.Parse(Console.ReadLine());
//Console.Write("Please enter Amplitude (4.8) : ");
//_noiseGenerator.Amplitude = float.Parse(Console.ReadLine());
//Console.Write("Please enter Persistence (0.9) : ");
//_noiseGenerator.Persistence = float.Parse(Console.ReadLine());
//Console.Write("Please enter Octaves (2) : ");
//_noiseGenerator.Octaves = int.Parse(Console.ReadLine());
var terrain = new double[width * height];
var normalisedTerrain = new double[width*height];
var counter = 0;
for(var y=0; y<height; y++)
{
for(var x=0; x<width; x++)
{
terrain[counter++] = _noiseGenerator.Compute(x, y);
}
}
var normalisedValues = Normalisation.CalculateInitialValues(terrain, 0, 255);
var count = 0;
var imageX = 0;
var imageY = 0;
var outputImage = new Bitmap(width, height);
foreach (var value in terrain)
{
var normalisedValue = (int)Normalisation.Normalise(normalisedValues, value);
normalisedTerrain[count++] = normalisedValue;
outputImage.SetPixel(imageX++, imageY, Color.FromArgb(normalisedValue, normalisedValue, normalisedValue));
if (imageX != outputImage.Width) continue;
imageY++;
imageX = 0;
}
double row = 0;
const int gridSize = 1;
var w = new World() {Name = "Default", Id = Guid.NewGuid()};
for (var y = 0; y < height; y++)
{
row = (row + 2) % 2 == 0 ? 1 : 0;
for (var x = 0; x < width; x++)
{
var xx = ((x + 1) * (gridSize * 2));
if ((y + 2) % 2 != 0)
{
xx = ((x + 1) * (gridSize * 2)) - gridSize;
}
var yy = (int)((y * gridSize) * 0.5);
w.AddHex(new Hex()
{
HexType = GetHexType(GetHeight(normalisedTerrain, xx, yy, width)),
Id = Guid.NewGuid(),
X = xx,
Y = yy
});
row += 2;
}
}
Console.WriteLine("Total Hexes : " + w.TotalHexes);
Console.WriteLine(GetCountForType(HexType.Ocean, w));
Console.WriteLine(GetCountForType(HexType.Sea, w));
Console.WriteLine(GetCountForType(HexType.Beach, w));
Console.WriteLine(GetCountForType(HexType.Plain, w));
Console.WriteLine(GetCountForType(HexType.Grass, w));
Console.WriteLine(GetCountForType(HexType.Trees, w));
Console.WriteLine(GetCountForType(HexType.Jungle, w));
Console.WriteLine(GetCountForType(HexType.Hill, w));
Console.WriteLine(GetCountForType(HexType.Mountain, w));
outputImage.Save(@"c:\temp\map.jpg");
Process.Start(@"c:\temp\map.jpg");
Console.ReadKey();
}
