public IChunk[] GenerateChunk(IPlanet planet, Index2 index)
{
IChunk[] result = new IChunk[planet.Size.Z];
for (int layer = 0; layer < planet.Size.Z; layer++)
result[layer] = new Chunk(new Index3(index.X, index.Y, layer), planet.Id);
int part = (planet.Size.Z * Chunk.CHUNKSIZE_Z) / 4;
for (int y = 0; y < Chunk.CHUNKSIZE_Y; y++)
{
float heightY = (float)Math.Sin((float)(y * Math.PI) / 15f);
for (int x = 0; x < Chunk.CHUNKSIZE_X; x++)
{
float heightX = (float)Math.Sin((float)(x * Math.PI) / 18f);
float height = ((heightX + heightY + 2) / 4) * (2 * part);
for (int z = 0; z < planet.Size.Z * Chunk.CHUNKSIZE_Z; z++)
{
if (z < (int)(height + part))
{
int block = z % (Chunk.CHUNKSIZE_Z);
int layer = (int)(z / Chunk.CHUNKSIZE_Z);
result[layer].SetBlock(x, y, block, new SandBlock());
}
}
}
}
return result;
}
public Index2 getIndexForVec(Vector3 vec)
{
Index2 returnIndex = new Index2();
returnIndex.X = Mathf.RoundToInt(vec.x / (cellSize * prodMesh.xSize));
returnIndex.Y= Mathf.RoundToInt(vec.z / (cellSize * prodMesh.xSize));
return returnIndex;
}
public IChunk[] GenerateChunk(IEnumerable<IBlockDefinition> blockDefinitions, IPlanet planet, Index2 index)
{
IBlockDefinition sandDefinition = blockDefinitions.FirstOrDefault(d => typeof(SandBlockDefinition) == d.GetType());
ushort sandIndex = (ushort)(Array.IndexOf(blockDefinitions.ToArray(), sandDefinition) + 1);
IChunk[] result = new IChunk[planet.Size.Z];
for (int layer = 0; layer < planet.Size.Z; layer++)
result[layer] = new Chunk(new Index3(index.X, index.Y, layer), planet.Id);
int part = (planet.Size.Z * Chunk.CHUNKSIZE_Z) / 4;
for (int y = 0; y < Chunk.CHUNKSIZE_Y; y++)
{
float heightY = (float)Math.Sin((float)(y * Math.PI) / 15f);
for (int x = 0; x < Chunk.CHUNKSIZE_X; x++)
{
float heightX = (float)Math.Sin((float)(x * Math.PI) / 18f);
float height = ((heightX + heightY + 2) / 4) * (2 * part);
for (int z = 0; z < planet.Size.Z * Chunk.CHUNKSIZE_Z; z++)
{
if (z < (int)(height + part))
{
int block = z % (Chunk.CHUNKSIZE_Z);
int layer = (int)(z / Chunk.CHUNKSIZE_Z);
result[layer].SetBlock(x, y, block, sandIndex);
}
}
}
}
return result;
}
public static Index2 operator /(Index2 a, int b)
{
Index2 retIndex = new Index2();
retIndex.X = a.X / b;
retIndex.Y = a.Y / b;
return retIndex;
}
/// <summary>
/// Lädt eine <see cref="IChunkColumn"/>.
/// </summary>
/// <param name="universeGuid">GUID des Universums.</param>
/// <param name="planet">Index des Planeten.</param>
/// <param name="columnIndex">Zu serialisierende ChunkColumn.</param>
/// <returns>Die neu geladene ChunkColumn.</returns>
public IChunkColumn LoadColumn(Guid universeGuid, IPlanet planet, Index2 columnIndex)
{
string file = Path.Combine(GetRoot(), universeGuid.ToString(), planet.Id.ToString(), string.Format(ColumnFilename, columnIndex.X, columnIndex.Y));
if (!File.Exists(file))
return null;
try {
using (Stream stream = File.Open(file, FileMode.Open, FileAccess.Read))
{
using (GZipStream zip = new GZipStream(stream, CompressionMode.Decompress))
{
return planet.Generator.GenerateColumn(zip, DefinitionManager.Instance, planet.Id, columnIndex);
}
}
}
catch (IOException)
{
try
{
File.Delete(file);
}
catch (IOException) { }
return null;
}
}
public override float[,] GetHeightmap(Index2 chunkIndex)
{
float[,] values = new float[Chunk.CHUNKSIZE_X, Chunk.CHUNKSIZE_Y];
Index2 blockIndex = new Index2(chunkIndex.X * Chunk.CHUNKSIZE_X, chunkIndex.Y * Chunk.CHUNKSIZE_Y);
float[,] regions = BiomeNoiseGenerator.GetTileableNoiseMap2D(blockIndex.X, blockIndex.Y, Chunk.CHUNKSIZE_X, Chunk.CHUNKSIZE_Y, Planet.Size.X * Chunk.CHUNKSIZE_X, Planet.Size.Y * Chunk.CHUNKSIZE_Y);
float[][,] biomeValues = new float[SubBiomes.Count][,];
for (int i = 0; i < SubBiomes.Count; i++)
biomeValues[i] = SubBiomes[i].GetHeightmap(chunkIndex);
for (int x = 0; x < Chunk.CHUNKSIZE_X; x++)
{
for (int y = 0; y < Chunk.CHUNKSIZE_Y; y++)
{
float region = regions[x, y] / 2 + 0.5f;
int biome2;
int biome1 = ChooseBiome(region, out biome2);
float interpolationValue = 0f;
if (biome2 != -1)
{
interpolationValue = CalculateInterpolationValue(region, SubBiomes[biome1], SubBiomes[biome2]);
values[x, y] = (biomeValues[biome2][x, y] * interpolationValue) + (biomeValues[biome1][x, y] * (1 - interpolationValue));
}
else
values[x, y] = biomeValues[biome1][x, y];
}
}
return values;
}
public static Index2 operator -(Index2 a, Index2 b)
{
Index2 retIndex = new Index2();
retIndex.X = a.X - b.X;
retIndex.Y = a.Y - b.Y;
return retIndex;
}
public void GenerateOutput(List<Index2> outputCull, out List<Vector3> vertices, out List<int> indices)
{
var newVertices = new List<Vector3>((int)mesh.PointCount);
var newIndices = new List<int>((int)mesh.PointCount*3);
var vertexArrayPositions = new int[heightMap.Width, heightMap.Height];
vertexArrayPositions.Fill(-1);
mesh.OverFaces((tri, obj) =>
{
var triVertices = new[]
{
tri.Point1,
tri.Point2,
tri.Point3
};
foreach (var holeMarker in outputCull)
{
var count = 0;
foreach (var vertex in triVertices)
{
var idx = new Index2
{
X = (int)vertex.X,
Y = (int)vertex.Y
};
// The triangle abuts one of the hole markers
if (holeMarker == idx) return;
// The triangle is within the hole markers neighborhood
if (Index2.Abs(idx - holeMarker) <= Index2.One) count++;
}
if (count > 2) return;
}
if (GeometryHelpers.IsCounterClockwise(triVertices[0], triVertices[1], triVertices[2]))
{
var temp = triVertices[1];
triVertices[1] = triVertices[2];
triVertices[2] = temp;
}
foreach (var vertex in triVertices)
{
if (vertexArrayPositions[(int) vertex.X, (int) vertex.Y] == -1)
{
vertexArrayPositions[(int) vertex.X, (int) vertex.Y] = newVertices.Count;
newVertices.Add(new Vector3(vertex, heightMap.Eval(vertex.X, vertex.Y)));
}
newIndices.Add(vertexArrayPositions[(int) vertex.X, (int) vertex.Y]);
}
});
vertices = newVertices;
indices = newIndices;
}
public void Index2DivisionTest()
{
Index2 i1 = new Index2(20, 15); // Startwert
Index2 i2 = new Index2(6, 5); // Multiplikation mit 3
Index2 i3 = new Index2(-10, -7); // Multi mit -2
Assert.AreEqual(i2, i1 / 3);
Assert.AreEqual(i3, i1 / -2);
}
protected override void OnDrawContent(SpriteBatch batch, Rectangle contentArea, GameTime gameTime, float alpha)
{
batch.Draw(Skin.Pix, new Rectangle(contentArea.X - 2, contentArea.Y - 2, contentArea.Width + 4, contentArea.Height + 4), Color.Black);
batch.Draw(Scene.MiniMapTexture, new Rectangle(contentArea.X, contentArea.Y, contentArea.Width, contentArea.Height), Color.White);
Index2 center = new Index2((contentArea.Width / 2) + contentArea.X, (contentArea.Height / 2) + contentArea.Y);
batch.Draw(Skin.Pix, new Rectangle(center.X - 1, center.Y - 1, 2, 2), Color.White);
}
public void Index2AdditionTest()
{
Index2 i1 = new Index2(20, 15); // Startwert
Index2 i2 = new Index2(-100, -130); // Negativ Addition
Index2 i3 = new Index2(-80, -115); // Ergebnis i1 + i2
Index2 i4 = new Index2(77, 44); // positive Addition
Index2 i5 = new Index2(97, 59); // Ergebnis i1 + i4
// Addition
Assert.AreEqual(i3, i1 + i2);
Assert.AreEqual(i5, i1 + i4);
}
public Color[] DoSomething(Light[] lights, Color ambient, bool[,] obstacles, Rectangle renderArea, Rectangle influenceArea, int downscale)
{
scale = 1f / downscale;
lightArray = new LightArray(renderArea.Width * renderArea.Height, ambient);
Light[] smallerLights = new Light[lights.Length];
Rectangle smallerRenderArea = new Rectangle((int)(renderArea.X * scale), (int)(renderArea.Y * scale), (int)(renderArea.Width * scale), (int)(renderArea.Height * scale));
Rectangle smallerInfluenceArea = new Rectangle((int)(influenceArea.X * scale), (int)(influenceArea.Y * scale), (int)(influenceArea.Width * scale), (int)(influenceArea.Height * scale));
for (int i = 0; i < smallerLights.Length; i++)
{
smallerLights[i] = new Light(lights[i].Position * scale, (short)(lights[i].Radius * scale), lights[i].Brightness, lights[i].Color);
DebugRenderer.AddDebugObjectWorldSingleCall(new DebugLight(lights[i], Color.AliceBlue));
}
Index2[][] pointsToCheck = new Index2[lights.Length][];
for (int i = 0; i < smallerLights.Length; i++)
{
pointsToCheck[i] = Circle.CalculateEdge(smallerLights[i].Position, smallerLights[i].Radius);
foreach (var currentPoint in pointsToCheck[i])
{
if (smallerRenderArea.Contains(currentPoint) || smallerRenderArea.Contains(smallerLights[i].Position))
{
foreach (var raycast in new LightRaycast(smallerLights[i], smallerLights[i].Position, currentPoint))
{
if (!smallerInfluenceArea.Contains(raycast)) //TODO: Use binarysearch
{
continue;
}
int x = raycast.X - smallerRenderArea.X;
int y = raycast.Y - smallerRenderArea.Y;
if (obstacles[x, y])
{
break;
}
if (!smallerRenderArea.Contains(raycast))
{
continue;
}
for (int xOff = 0; xOff < downscale; xOff++)
{
for (int yOff = 0; yOff < downscale; yOff++)
{
lightArray.Set((downscale * y + yOff) * renderArea.Width + (downscale * x + xOff), smallerLights[i].Color);
}
}
}
}
}
}
return(lightArray.ToColorArray());
}
private static void GPUMult(Index2 index, ArrayView2D <double> aView, ArrayView2D <double> bView,
ArrayView2D <double> resView)
{
int x = index.X; //matrix one row
int y = index.Y; //matrix two column
double sum = 0;
for (int i = 0; i < aView.Height; i++)
{
sum += aView[x, i] * bView[i, y];
}
resView[index] = sum;
}
/// <summary>
///
/// </summary>
/// <param name="i"></param>
/// <param name="j"></param>
/// <param name="current"></param>
/// <returns></returns>
public int NextAt(Index2 index, int[,] current)
{
int sum = GetNeighborSum(index, current);
int state = current[index.I, index.J];
if (state == 0)
{
return((sum == 3) ? 1 : 0);
}
else
{
return((sum < 2 || sum > 3) ? 0 : 1);
}
}
public Index2[] FloodFill(Index2 point, List <Index2> result)
{
if (result.Contains(point) || IsEdge(point))
{
return(result.ToArray());
}
result.Add(point);
foreach (var p in GetNeighbours(point))
{
FloodFill(p, result);
}
return(result.ToArray());
}
void DisableEnemySpawningInSector(Index2 sector, bool destroyEnemies = true)
{
if (destroyEnemies)
{
foreach (Enemy e in Actor.FindObjectsInSector <Enemy>(Sector))
{
Destroy(e.gameObject);
}
}
foreach (EnemySpawnPoint sp in Actor.FindObjectsInSector <EnemySpawnPoint>(sector))
{
sp.SpawningEnabled = false;
}
}
public void TestPerf()
{
// Specifie l'ordre des clefs trie
Index2 <Model> tree = new Index2 <Model>(null,
c => c.Ope5,
c => c.Car2,
c => c.Qs3,
c => c.Pu1,
c => c.Pre4
);
tree.Sort(Datas.Matrix); // on construit
var filter = tree.GetEvaluator <Model1>(
c => c.Dgh5,
c => c.Re2,
c => c.Df3,
c => c.az1,
c => c.Klm4
);
Stopwatch st = new Stopwatch();
var m = new Model1()
{
Dgh5 = 2, Re2 = null, Df3 = null, az1 = 23
};
st.Start();
Assert.AreEqual(filter(m), true);
st.Stop();
Debug.WriteLine(st.Elapsed.TotalMilliseconds);
var count = 1000;
st.Restart();
for (int i = 0; i < count; i++)
{
filter(m);
}
st.Stop();
Debug.WriteLine(st.Elapsed.TotalMilliseconds / count);
/*
* 6,5106
* 0,0009812
*/
}
public static void Execute(Index2 index, ArrayView3D <byte> destBuffer, Index2 offset, byte[] color)
{
if (color == null)
{
throw new ArgumentNullException(nameof(color));
}
using (MemoryBuffer <byte> c = HardwareAcceleratorManager.GPUAccelerator.Allocate <byte>(color.Length))
{
c.CopyFrom(color, 0, 0, color.Length);
kernel(index, destBuffer, offset, c);
HardwareAcceleratorManager.GPUAccelerator.Synchronize();
}
}
private static void strategy(Index2 index, ArrayView2D <byte> indexedBitmapBuffer,
ArrayView2D <int> bitmapTile, ArrayView <int> colors)
{
int c = bitmapTile[index];
for (int i = 0; i < colors.Length; i++)
{
if (colors[i] == c)
{
indexedBitmapBuffer[index] = (byte)i;
break;
}
}
}
public static void CopyGroupedTo <T>(this ArrayView2D <T> sourceView, ArrayView2D <T> targetView, Index threadIdx)
where T : struct
{
Debug.Assert(sourceView.Extent <= targetView.Extent, "Target view out of range");
Debug.Assert(threadIdx.X >= Index.Zero && threadIdx.X < Group.Dimension.X, "X thread-index out of range");
for (Index i = threadIdx.X; i < sourceView.Extent.X; i += Group.Dimension.X)
{
for (Index j = 0; j < sourceView.Extent.Y; ++j)
{
var idx = new Index2(i, j);
targetView[idx] = sourceView[idx];
}
}
}
protected override void OnDrawContent(SpriteBatch batch, Rectangle contentArea, GameTime gameTime, float alpha)
{
if (Scene == null || Scene.MiniMapTexture == null)
{
return;
}
batch.Draw(Skin.Pix, new Rectangle(contentArea.X - 2, contentArea.Y - 2, contentArea.Width + 4, contentArea.Height + 4), Color.Black);
batch.Draw(Scene.MiniMapTexture, new Rectangle(contentArea.X, contentArea.Y, contentArea.Width, contentArea.Height), Color.White);
Index2 center = new Index2((contentArea.Width / 2) + contentArea.X, (contentArea.Height / 2) + contentArea.Y);
batch.Draw(Skin.Pix, new Rectangle(center.X - 1, center.Y - 1, 2, 2), Color.White);
}
public void CopyFrom(
AcceleratorStream stream,
T[][] source,
Index2 sourceOffset,
Index2 targetOffset,
Index2 extent)
{
if (source == null)
{
throw new ArgumentNullException(nameof(source));
}
if (extent.X < 0 || extent.Y < 0 ||
extent.X > source.Length)
{
throw new ArgumentOutOfRangeException(nameof(extent));
}
if (sourceOffset.X < 0 || sourceOffset.Y < 0 ||
sourceOffset.X >= extent.X || sourceOffset.Y >= extent.Y)
{
throw new ArgumentOutOfRangeException(nameof(sourceOffset));
}
var tempBuffer = new T[extent.Size];
for (int i = 0; i < extent.X; ++i)
{
var subData = source[i + sourceOffset.X];
if (subData == null)
{
continue;
}
// Skip entries that are out of bounds
for (int j = 0, e = IntrinsicMath.Min(subData.Length, extent.Y); j < e; ++j)
{
var targetIdx = new Index2(i, j).ComputeLinearIndex(extent);
tempBuffer[targetIdx] = subData[j + sourceOffset.Y];
}
}
buffer.CopyFrom(
stream,
tempBuffer,
0,
targetOffset,
extent.Size);
}
public void CopyTo(
AcceleratorStream stream,
T[,] target,
Index2 sourceOffset,
Index2 targetOffset,
Index2 extent)
{
if (target == null)
{
throw new ArgumentNullException(nameof(target));
}
if (sourceOffset.X < 0 || sourceOffset.Y < 0 ||
sourceOffset.X >= Extent.X ||
sourceOffset.Y >= Extent.Y)
{
throw new ArgumentOutOfRangeException(nameof(sourceOffset));
}
if (targetOffset.X < 0 || targetOffset.Y < 0 ||
targetOffset.X >= target.GetLength(0) ||
targetOffset.Y >= target.GetLength(1))
{
throw new ArgumentOutOfRangeException(nameof(targetOffset));
}
if (extent.X < 0 || extent.Y < 0 ||
sourceOffset.X + extent.X > Extent.X ||
sourceOffset.Y + extent.Y > Extent.Y ||
targetOffset.X + extent.X > target.GetLength(0) ||
targetOffset.Y + extent.Y > target.GetLength(1))
{
throw new ArgumentOutOfRangeException(nameof(extent));
}
var tempBuffer = new T[extent.Size];
buffer.CopyTo(stream, tempBuffer, sourceOffset, 0, extent);
for (int i = 0; i < extent.X; ++i)
{
for (int j = 0; j < extent.Y; ++j)
{
var sourceIdx = new Index2(i, j).ComputeLinearIndex(extent);
target[i + targetOffset.X, j + targetOffset.Y] =
tempBuffer[sourceIdx];
}
}
}
public static Area ToArea(this Rectangle rectangle)
{
Index2[] area = new Index2[rectangle.Width * rectangle.Height];
int i = 0;
for (int x = 0; x < rectangle.Width; x++)
{
for (int y = 0; y < rectangle.Height; y++)
{
area[i] = new Index2(x, y);
i++;
}
}
return(new Area(area));
}
public void InstanceMethodIndex2EntryPoint(int length)
{
var instanceHost = new InstaceHost();
Action <Index2, ArrayView <int>, Index2> kernel = instanceHost.InstanceKernel;
var extent = new Index2(length, length);
using var buffer = Accelerator.Allocate <int>(extent.Size);
Execute(kernel.Method, extent, buffer.View, extent);
var expected =
Enumerable.Range(instanceHost.InstanceOffset(), extent.Size).ToArray();
Verify(buffer, expected);
}
public void StaticFieldCapturingLambdaIndex2EntryPoint(int length)
{
Action <Index2, ArrayView <int>, Index2> kernel =
(index, output, extent) =>
{
var linearIndex = index.ComputeLinearIndex(extent);
output[linearIndex] = linearIndex + CaptureHost.CaptureField;
};
var extent = new Index2(length, length);
using var buffer = Accelerator.Allocate <int>(extent.Size);
Assert.Throws <NotSupportedException>(() =>
Execute(kernel.Method, extent, buffer.View, extent));
}
public float[,] GetHeightmap(Index2 chunkIndex)
{
float[,] values = new float[Chunk.CHUNKSIZE_X, Chunk.CHUNKSIZE_Y];
chunkIndex = new Index2(chunkIndex.X * Chunk.CHUNKSIZE_X, chunkIndex.Y * Chunk.CHUNKSIZE_Y);
for (int x = 0; x < Chunk.CHUNKSIZE_X; x++)
{
for (int y = 0; y < Chunk.CHUNKSIZE_Y; y++)
{
values[x, y] = 0f;
}
}
return(values);
}
public AnimatedTileLighting(BasicTile tile)
{
Position = tile.Position;
Index = tile.Index;
var array = tile.Animations.GetAnimations().Where(a => a.Name.EndsWith("shadow")).ToArray();
animations = new AnimationCollection(tile.Animations.StartAnimation + "shadow");
if (array.Length <= 0)
{
GameConsole.Warning("Warning: No shadow animations found.");
return;
}
animations.AddAnimations(array);
tile.Animations.AnimationChanged += AnimationChanged;
}
internal static void FullyConnectedLayer2D(Index2 currentInput, ArrayView3D <float> weights, ArrayView2D <float> error, ArrayView2D <float> activatedPreviousLayer, ArrayView2D <float> bias, ArrayView <float> variables)
{
var fac = error[currentInput] * variables[new Index1(0)];
bias[currentInput] -= fac;
for (int x = 0; x < activatedPreviousLayer.Width; x++)
{
for (int y = 0; y < activatedPreviousLayer.Height; y++)
{
Index2 asosIndex = new Index2(x, y);
var adjustment = fac * activatedPreviousLayer[asosIndex];
weights[new Index3(currentInput, x * y + x)] -= adjustment;
}
}
}
public float[,] GetHeightmap(Index2 chunkIndex)
{
float[,] values = new float[Chunk.CHUNKSIZE_X , Chunk.CHUNKSIZE_Y ];
chunkIndex = new Index2(chunkIndex.X * Chunk.CHUNKSIZE_X , chunkIndex.Y * Chunk.CHUNKSIZE_Y );
for (int x = 0; x < Chunk.CHUNKSIZE_X ; x++)
{
for (int y = 0; y < Chunk.CHUNKSIZE_Y ; y++)
{
values[x, y] = 0f;
}
}
return values;
}
private static void GPUMult(Index2 index, ArrayView2D <T> aView, ArrayView2D <T> bView,
ArrayView2D <T> resView)
{
int x = index.X; //matrix one row
int y = index.Y; //matrix two column
//this needs to be done explicitly so we know where to start
T sum = aView[x, 0].Multiply(bView[0, y]);
for (int i = 1; i < aView.Height; i++)
{
sum = sum.Add(aView[x, i].Multiply(bView[i, y]));
}
resView[index] = sum;
}
/// <summary>
///
/// </summary>
/// <param name="i"></param>
/// <param name="j"></param>
/// <param name="current"></param>
/// <returns></returns>
public int NextState(Index2 index, int[,] current)
{
int sum = GetNeighborSum(index, current);
int state = current[index.I, index.J];
//the state that will be output based on rules
int output = 0;
//if current state is "alive"
if (state == 1)
{
//loneliness
if (sum < 2)
{
output = 0;
}
//balance
if (sum >= 2 && sum <= 3)
{
output = 1;
}
//overcrowding
if (sum > 3)
{
output = 0;
}
}
//if current state is "dead"
if (state == 0)
{
//procreation
if (sum == 3)
{
output = 1;
}
//no procreation
else
{
output = 0;
}
}
return(output);
}
protected override void RequestDraw()
{
MainState _currentState = _state;
if (_currentState != null)
{
Index2 cells = _currentState.Map.GetCellCount();
DrawPlayground(cells, _currentState.Map.Tiles);
foreach (var item in _currentState.Items)
{
if (item is AnthillState)
{
AnthillState anthillState = item as AnthillState;
DrawItem(item.Id, item.Position, anthillState.Radius, null, null, Color.Brown, null, null, null, null, null, null);
}
if (item is AntState)
{
AntState antState = item as AntState;
// DrawItem(item.Id, item.Position, antState.Radius, Color.Black);
}
if (item is SugarState)
{
SugarState sugarState = item as SugarState;
// DrawItem(item.Id, item.Position, sugarState.Radius, Color.White);
}
if (item is AppleState)
{
AppleState appleState = item as AppleState;
// DrawItem(item.Id, item.Position, 5, Color.LightGreen);
}
if (item is MarkerState)
{
MarkerState markerState = item as MarkerState;
// DrawItem(item.Id, item.Position, 10, Color.Yellow);
}
if (item is BugState)
{
// DrawItem(item.Id, item.Position, 10, Color.Blue);
}
}
}
}
private void InitFlat(bool blockBorder, TileSpeed speed)
{
Map = Map.CreateMap(MapPreset.Small, true);
Index2 cells = Map.GetCellCount();
for (int x = 0; x < cells.X; x++)
{
for (int y = 0; y < cells.Y; y++)
{
Map.Tiles[x, y].Speed = speed;
}
}
Engine.Init(Map);
Engine.InsertItem(Item);
}
internal static void SoftmaxLayer2D(Index2 currentInput, ArrayView2D <float> error, ArrayView2D <float> errorNextLayer, ArrayView3D <float> weightNextLayer, ArrayView2D <float> derived, ArrayView2D <float> should, ArrayView <float> variable)
{
int xBounds = (int)errorNextLayer.Extent.X;
int yBounds = (int)errorNextLayer.Extent.Y;
float sum = 0.0f;
for (int x = 0; x < xBounds; x++)
{
for (int y = 0; y < yBounds; y++)
{
Index2 varIndex = new Index2(x, y);
sum += errorNextLayer[varIndex] * weightNextLayer[new Index3(varIndex, currentInput.X * currentInput.Y + currentInput.X)];
}
}
error[currentInput] = sum * derived[currentInput];
}
public OceanSeismicMultithreaded(int n, int m)
{
// Create new output cube
SeismicCube outputCube = SeismicCube.NullObject;
SeismicCollection coll = SeismicCollection.NullObject;
SeismicRoot seisRoot;
seisRoot = SeismicRoot.Get(PetrelProject.PrimaryProject);
if (!seisRoot.HasSeismicProject)
{
using (ITransaction tr = DataManager.NewTransaction())
{
tr.Lock(seisRoot);
seisRoot.CreateSeismicProject();
tr.Commit();
}
}
SeismicProject proj = seisRoot.SeismicProject;
using (ITransaction tr = DataManager.NewTransaction())
{
tr.Lock(proj);
coll = proj.CreateSeismicCollection("Test Survey Async " + n.ToString() + "x" + m.ToString());
tr.Lock(coll);
Index3 size = new Index3(n, n, m);
Point3 origin = new Point3(13579.75, 24680.08, 0.0);
Vector3 iSpacing = new Vector3(100.0, 0.0, 0.000);
Vector3 jSpacing = new Vector3(0.0, 100.0, 0.000);
Vector3 kSpacing = new Vector3(0.0, 0.0, -100.0);
Index2 annotationOrigin = new Index2(0, 0);
Index2 annotationInc = new Index2(1, 1);
if (coll.CanCreateSeismicCube(size, origin, iSpacing, jSpacing, kSpacing))
{
Type dataType = typeof(float);
Domain vDomain = Domain.ELEVATION_DEPTH;
Template tmpl = PetrelProject.WellKnownTemplates
.SeismicColorGroup.SeismicDefault;
Range1 <double> r = new Range1 <double>(0.0, 140.0);
_cube = coll.CreateSeismicCube(size, origin, iSpacing, jSpacing, kSpacing, annotationOrigin, annotationInc, dataType, vDomain, tmpl, r);
}
if (_cube.IsWritable)
{
MakeCube(_cube);
}
tr.Commit();
}
}
public static void CalculateSignatureLengthDerivative(Index2 index, ArrayView3D <float> output, ArrayView3D <short> input, short maxValue)
{
var x = index.X;
var y = index.Y;
if (x == 0)
{
x = 1;
}
if (x == input.Width - 1)
{
x = input.Width - 2;
}
if (y == 0)
{
y = 1;
}
if (y == input.Height - 1)
{
y = input.Height - 2;
}
var depth = input.Depth;
float xDiffComponentSum = 0;
float yDiffComponentSum = 0;
for (int i = 0; i < depth; i++)
{
var val1 = XMath.Clamp(input[x - 1, y, i], (short)0, maxValue);
var val2 = XMath.Clamp(input[x + 1, y, i], (short)0, maxValue);
var xDiff = val2 - val1;
xDiffComponentSum += xDiff * xDiff;
val1 = XMath.Clamp(input[x, y - 1, i], (short)0, maxValue);
val2 = XMath.Clamp(input[x, y + 1, i], (short)0, maxValue);
var yDiff = val2 - val1;
yDiffComponentSum += yDiff * yDiff;
}
var xDiffLength = XMath.Sqrt(xDiffComponentSum);
var yDiffLength = XMath.Sqrt(yDiffComponentSum);
output[index.X, index.Y, 0] = xDiffLength;
output[index.X, index.Y, 1] = yDiffLength;
output[index.X, index.Y, 2] = XMath.Max(xDiffLength, yDiffLength);
}
public void Index2ComparerTest()
{
Index2 i1 = new Index2(12, 13);
Index2 i2 = new Index2(12, 15);
Index2 i3 = new Index2(22, 13);
Index2 i4 = new Index2(12, 13);
Assert.AreEqual(i1, i1);
Assert.AreEqual(i1, i4);
Assert.AreNotEqual(i1, i2);
Assert.AreNotEqual(i1, i3);
Assert.IsTrue(i1 == i1);
Assert.IsTrue(i1 == i4);
Assert.IsTrue(i1 != i2);
Assert.IsTrue(i1 != i3);
}
private void Update(EvaluationContext context)
{
var overwrites = context.VariationOverwrites;
// var id = new Variator.VariationId(Guid.Empty, Guid.Empty);
if (!overwrites.TryGetValue(Variator.VariationId.EmptySet, out var entry))
{
entry = new VariationSelector();
overwrites.Add(Variator.VariationId.EmptySet, entry);
}
entry.Index1 = Index1.GetValue(context);
entry.Index2 = Index2.GetValue(context);
entry.Weight = Weight.GetValue(context);
Result.Value = Input.GetValue(context);
overwrites.Remove(Variator.VariationId.EmptySet);
}
public void Index2ComparerTest()
{
Index2 i1 = new Index2(12, 13);
Index2 i2 = new Index2(12, 15);
Index2 i3 = new Index2(22, 13);
Index2 i4 = new Index2(12, 13);
Assert.Equals(i1, i1);
Assert.Equals(i1, i4);
Assert.AreNotEqual(i1, i2);
Assert.AreNotEqual(i1, i3);
// Assert.True(i1 == i1);
Assert.True(i1 == i4);
Assert.True(i1 != i2);
Assert.True(i1 != i3);
}
public void CalculateLightmap(Renderer2D renderer, Matrix cam, Index2 mapSize, Color ambient)
{
var tempRender = CalculateRenderView(mapSize);
if (!tempRender.HasValue)
{
return;
}
renderSize = tempRender.Value;
influenceArea = CalculateInfluenceArea();
obstacles = GrabObstacles(renderer, cam);
texture?.Dispose();
texture = new Texture2D(graphicsDevice, renderSize.Width, renderSize.Height);
textureData = new FieldOfView().DoSomething(lights.ToArray(), ambient, obstacles, renderSize, influenceArea, 2);
texture.SetData(textureData);
//texture = texture.GaussianBlur(3);
}
public float[,] GetHeightmap(Index2 chunkIndex)
{
float[,] values = new float[Chunk.CHUNKSIZE_X , Chunk.CHUNKSIZE_Y];
chunkIndex = new Index2(chunkIndex.X * Chunk.CHUNKSIZE_X, chunkIndex.Y * Chunk.CHUNKSIZE_Y);
float[,] heights = BiomeNoiseGenerator.GetTileableNoiseMap2D(chunkIndex.X, chunkIndex.Y, Chunk.CHUNKSIZE_X , Chunk.CHUNKSIZE_Y, Planet.Size.X * Chunk.CHUNKSIZE_X , Planet.Size.Y * Chunk.CHUNKSIZE_Y );
for (int x = 0; x < Chunk.CHUNKSIZE_X ; x++)
{
for (int y = 0; y < Chunk.CHUNKSIZE_Y ; y++)
{
values[x, y] = (heights[x, y] / 2 + 0.5f) * ValueRange + ValueRangeOffset;
}
}
return values;
}
public float[,] GetHeightmap(Index2 chunkIndex)
{
float[,] values = new float[Chunk.CHUNKSIZE_X, Chunk.CHUNKSIZE_Y];
chunkIndex = new Index2(chunkIndex.X * Chunk.CHUNKSIZE_X, chunkIndex.Y * Chunk.CHUNKSIZE_Y);
float[,] heights = BiomeNoiseGenerator.GetTileableNoiseMap2D(chunkIndex.X, chunkIndex.Y, Chunk.CHUNKSIZE_X, Chunk.CHUNKSIZE_Y, Planet.Size.X * Chunk.CHUNKSIZE_X, Planet.Size.Y * Chunk.CHUNKSIZE_Y);
for (int x = 0; x < Chunk.CHUNKSIZE_X; x++)
{
for (int y = 0; y < Chunk.CHUNKSIZE_Y; y++)
{
values[x, y] = (heights[x, y] / 2 + 0.5f) * ValueRange + ValueRangeOffset;
}
}
return(values);
}
void OverrideSectorWithThisSectorsVoxels(Index2 sector, bool doOverride)
{
OverworldTerrainEngine eng = OverworldTerrainEngine.Instance;
OverworldChunk ch = eng.GetChunkForSector(sector) as OverworldChunk;
if (ch != null)
{
OverrideChunkWithThisSectorsVoxels(ch, doOverride);
OverworldChunk ch_down = ch.GetChunkDirectlyBelowThisChunk() as OverworldChunk; // TODO: Better methods for getting neighbors
if (ch_down != null)
{
OverrideChunkWithThisSectorsVoxels(ch_down, doOverride);
}
}
}
public void LoadChunkTest()
{
int planet = 2;
Index2 index = new Index2(6, 7);
IChunkColumn result = null;
int loadCallCounter = 0;
int saveCallCounter = 0;
GlobalChunkCache cache = new GlobalChunkCache(
(p, i) =>
{
Assert.AreEqual(i, index);
loadCallCounter++;
return result = new TestChunkColumn(planet, index);
},
(p, i, c) =>
{
Assert.AreEqual(p, planet);
Assert.AreEqual(i, index);
Assert.AreEqual(c, result);
saveCallCounter++;
});
Assert.AreEqual(0, cache.LoadedChunkColumns);
Assert.AreEqual(0, loadCallCounter);
Assert.AreEqual(0, saveCallCounter);
// Chunk laden
IChunkColumn x = cache.Subscribe(planet, index);
Assert.AreEqual(x, result);
Assert.AreEqual(x.Planet, planet);
Assert.AreEqual(x.Index, index);
Assert.AreEqual(1, loadCallCounter);
Assert.AreEqual(0, saveCallCounter);
Assert.AreEqual(1, cache.LoadedChunkColumns);
// Chunk unload
cache.Release(planet, index);
Assert.AreEqual(0, cache.LoadedChunkColumns);
Assert.AreEqual(1, loadCallCounter);
Assert.AreEqual(1, saveCallCounter);
}
public void Index3AdditionTest()
{
Index3 i1 = new Index3(20, 15, 17); // Startwert
Index2 in2 = new Index2(-100, -130); // Negativ Addition (2D)
Index3 in3 = new Index3(-100, -130, -33); // Negativ Addition (3D)
Index3 in2r = new Index3(-80, -115, 17); // Ergebnis i1 + in2
Index3 in3r = new Index3(-80, -115, -16); // Ergebnis i1 + in3
Index2 ip2 = new Index2(77, 44); // positive Addition (2D)
Index3 ip3 = new Index3(77, 44, 54); // positive Addition (3D)
Index3 ip2r = new Index3(97, 59, 17); // Ergebnis i1 + ip2
Index3 ip3r = new Index3(97, 59, 71); // Ergebnis i1 + ip3
// Addition
Assert.AreEqual(in2r, i1 + in2);
Assert.AreEqual(in3r, i1 + in3);
Assert.AreEqual(ip2r, i1 + ip2);
Assert.AreEqual(ip3r, i1 + ip3);
}
public void Update()
{
MouseState state = Mouse.GetState();
mousePointer = new Index2(state.X, state.Y);
if (state.LeftButton == ButtonState.Pressed)
{
if (!mouseDown)
{
mouseDown = true;
}
}
else
{
if (mouseDown)
{
mouseDown = false;
if (OnLeftMouseUp != null)
OnLeftMouseUp(mousePointer);
}
}
}
public void Index2ConstructorTest()
{
// Parameterlos
Index2 i1 = new Index2();
Assert.AreEqual(0, i1.X);
Assert.AreEqual(0, i1.Y);
// Simpler Parameter
Index2 i2 = new Index2(21, 32);
Assert.AreEqual(21, i2.X);
Assert.AreEqual(32, i2.Y);
// Index2-Parameter
Index2 i3 = new Index2(new Index2(-2, 80));
Assert.AreEqual(-2, i3.X);
Assert.AreEqual(80, i3.Y);
// Index3 Parameter
Index2 i4 = new Index2(new Index3(int.MinValue, int.MaxValue, 0));
Assert.AreEqual(int.MinValue, i4.X);
Assert.AreEqual(int.MaxValue, i4.Y);
}
public IChunk[] GenerateChunk(IEnumerable<IBlockDefinition> blockDefinitions, IPlanet planet, Index2 index)
{
IBlockDefinition sandDefinition = blockDefinitions.FirstOrDefault(d => typeof(SandBlockDefinition) == d.GetType());
ushort sandIndex = (ushort)(Array.IndexOf(blockDefinitions.ToArray(), sandDefinition) + 1);
IBlockDefinition groundDefinition = blockDefinitions.FirstOrDefault(d => typeof(GroundBlockDefinition) == d.GetType());
ushort groundIndex = (ushort)(Array.IndexOf(blockDefinitions.ToArray(), groundDefinition) + 1);
IBlockDefinition stoneDefinition = blockDefinitions.FirstOrDefault(d => typeof(StoneBlockDefinition) == d.GetType());
ushort stoneIndex = (ushort)(Array.IndexOf(blockDefinitions.ToArray(), stoneDefinition) + 1);
IBlockDefinition waterDefinition = blockDefinitions.FirstOrDefault(d => typeof(WaterBlockDefinition) == d.GetType());
ushort waterIndex = (ushort)(Array.IndexOf(blockDefinitions.ToArray(), waterDefinition) + 1);
IBlockDefinition grassDefinition = blockDefinitions.FirstOrDefault(d => typeof(GrassBlockDefinition) == d.GetType());
ushort grassIndex = (ushort)(Array.IndexOf(blockDefinitions.ToArray(), grassDefinition) + 1);
if (!(planet is ComplexPlanet))
throw new ArgumentException("planet is not a Type of ComplexPlanet");
ComplexPlanet localPlanet = (ComplexPlanet)planet;
float[,] localHeightmap = localPlanet.BiomeGenerator.GetHeightmap(index);
IChunk[] chunks = new IChunk[planet.Size.Z];
for (int i = 0; i < planet.Size.Z; i++)
chunks[i] = new Chunk(new Index3(index, i), planet.Id);
int obersteSchicht;
bool surfaceBlock;
bool ozeanSurface;
for (int x = 0; x < Chunk.CHUNKSIZE_X; x++)
{
for (int y = 0; y < Chunk.CHUNKSIZE_Y; y++)
{
obersteSchicht = 5;
surfaceBlock = true;
ozeanSurface = false;
for (int i = chunks.Length - 1; i >= 0; i--)
{
for (int z = Chunk.CHUNKSIZE_Z - 1; z >= 0; z--)
{
int absoluteZ = (z + (i * Chunk.CHUNKSIZE_Z));
if (absoluteZ <= localHeightmap[x, y] * localPlanet.Size.Z * Chunk.CHUNKSIZE_Z)
{
if (obersteSchicht > 0)
{
float temp = localPlanet.ClimateMap.GetTemperature(new Index3(index.X * Chunk.CHUNKSIZE_X + x, index.Y * Chunk.CHUNKSIZE_Y + y, i * Chunk.CHUNKSIZE_Z + z));
if ((ozeanSurface || surfaceBlock) && (absoluteZ <= (localPlanet.BiomeGenerator.SeaLevel + 2)) && (absoluteZ >= (localPlanet.BiomeGenerator.SeaLevel - 2)))
{
chunks[i].SetBlock(x, y, z, sandIndex);
}
else if (temp >= 35)
{
chunks[i].SetBlock(x, y, z, sandIndex);
}
else if (absoluteZ >= localPlanet.Size.Z * Chunk.CHUNKSIZE_Z * 0.6f)
{
if (temp > 12)
chunks[i].SetBlock(x, y, z, groundIndex);
else
chunks[i].SetBlock(x, y, z, stoneIndex);
}
else if (temp >= 8)
{
if (surfaceBlock && !ozeanSurface)
{
chunks[i].SetBlock(x, y, z, grassIndex);
surfaceBlock = false;
}
else
{
chunks[i].SetBlock(x, y, z, groundIndex);
}
}
else
{
chunks[i].SetBlock(x, y, z, groundIndex);
}
obersteSchicht--;
}
else
{
chunks[i].SetBlock(x, y, z, stoneIndex);
}
}
else if ((z + (i * Chunk.CHUNKSIZE_Z)) <= localPlanet.BiomeGenerator.SeaLevel)
{
chunks[i].SetBlock(x, y, z, waterIndex);
ozeanSurface = true;
}
}
}
}
}
//float[,] cloudmap = null;
////Biomes.BiomeBlockValue[, ,] blockValues = localPlanet.BiomeGenerator.GetBlockValues(index,heightmap,0f,1f);
////for (int x = 0; x < Chunk.CHUNKSIZE_X; x++)
//Parallel.For(0, Chunk.CHUNKSIZE_X, x =>
//{
// for (int y = 0; y < Chunk.CHUNKSIZE_Y; y++)
// {
// bool grass = true, sand = false;
// for (int i = chunks.Length - 1; i >= 0; i--)
// {
// for (int z = Chunk.CHUNKSIZE_Z - 1; z >= 0; z--)
// {
// //Biomes.BiomeBlockValue blockValue = blockValues[x, y, z + i * Chunk.CHUNKSIZE_Z];
// int blockHeight = Math.Max(z + Chunk.CHUNKSIZE_Z * (i), 0);
// //float density = heightmap[x,y] * (Chunk.CHUNKSIZE_Z * (planet.Size.Z)) - blockHeight;
// Index3 blockIndex = new Index3(index.X * Chunk.CHUNKSIZE_X + x, index.Y * Chunk.CHUNKSIZE_Y + y, i * Chunk.CHUNKSIZE_Z + z);
// if (blockValue.Density > 0.6f || (z < 3 && i == 0))
// {
// if (blockValue.IsDessert || (grass | sand) && (z + (i * Chunk.CHUNKSIZE_Z)) <= localPlanet.BiomeGenerator.SeaLevel && (z + (i * Chunk.CHUNKSIZE_Z)) >= localPlanet.BiomeGenerator.SeaLevel - 2)
// {
// chunks[i].SetBlock(new Index3(x, y, z), new SandBlock());
// grass = false;
// sand = true;
// }
// else if (grass && planet.ClimateMap.GetTemperature(blockIndex) > 18.0f)
// {
// chunks[i].SetBlock(new Index3(x, y, z), new GrassBlock());
// grass = false;
// }
// //else if (z < Chunk.CHUNKSIZE_Z - 1 && noiseplus >= resDensity)
// //{
// // chunks[i].SetBlock(new Index3(x, y, z), new StoneBlock());
// //}
// else
// {
// chunks[i].SetBlock(new Index3(x, y, z), new GroundBlock());
// grass = false;
// }
// }
// else if ((z + (i * Chunk.CHUNKSIZE_Z)) <= localPlanet.BiomeGenerator.SeaLevel)
// {
// grass = false;
// sand = true;
// chunks[i].SetBlock(new Index3(x, y, z), new WaterBlock());
// }
// }
// }
// }
//});
return chunks;
}
private bool FillChunkRenderer()
{
if (player.ActorHost == null)
return false;
Index2 destinationChunk = new Index2(player.ActorHost.Position.ChunkIndex);
// Nur ausführen wenn der Spieler den Chunk gewechselt hat
if (destinationChunk != currentChunk)
{
localChunkCache.SetCenter(planet, new Index2(player.ActorHost.Position.ChunkIndex));
int mask = (int)Math.Pow(2, VIEWRANGE) - 1;
int span = (int)Math.Pow(2, VIEWRANGE);
int spanOver2 = span >> 1;
for (int x = 0; x < span; x++)
{
for (int y = 0; y < span; y++)
{
Index2 local = new Index2(x - spanOver2, y - spanOver2) + destinationChunk;
local.NormalizeXY(planet.Size);
int virtualX = local.X & mask;
int virtualY = local.Y & mask;
int rendererIndex = virtualX +
(virtualY << VIEWRANGE);
for (int z = 0; z < planet.Size.Z; z++)
{
chunkRenderer[rendererIndex, z].SetChunk(localChunkCache, local.X, local.Y, z);
}
}
}
Index3 comparationIndex = player.ActorHost.Position.ChunkIndex;
orderedChunkRenderer.Sort((x, y) =>
{
if (!x.ChunkPosition.HasValue) return 1;
if (!y.ChunkPosition.HasValue) return -1;
Index3 distX = comparationIndex.ShortestDistanceXYZ(x.ChunkPosition.Value, planet.Size);
Index3 distY = comparationIndex.ShortestDistanceXYZ(y.ChunkPosition.Value, planet.Size);
return distX.LengthSquared().CompareTo(distY.LengthSquared());
});
currentChunk = destinationChunk;
}
foreach (var renderer in orderedChunkRenderer)
{
if (!renderer.NeedUpdate())
continue;
renderer.RegenerateVertexBuffer();
return true;
}
return false;
}
public void Index2ShortestDistanceMethodenTest()
{
Index2 size = new Index2(20, 20);
Index2 i1 = new Index2(5, 7); // Startwert
Index2 i2 = new Index2(12, 13); // Destinations
Index2 i3 = new Index2(7, 6); // Results
Assert.AreEqual(i3.X, i1.ShortestDistanceX(i2.X, size.X));
Assert.AreEqual(i3.Y, i1.ShortestDistanceY(i2.Y, size.Y));
Assert.AreEqual(i3, i1.ShortestDistanceXY(i2, size));
}
void input_OnLeftMouseUp(Index2 position)
{
if (ActiveScreen != null)
{
foreach (var control in ActiveScreen.Controls)
{
if (position.X >= control.Position.X &&
position.X <= control.Position.X + control.Size.X &&
position.Y >= control.Position.Y &&
position.Y <= control.Position.Y + control.Size.Y)
{
control.FireMouseUp();
}
}
}
}
public void Index2SubtraktionTest()
{
Index2 i1 = new Index2(20, 15); // Startwert
Index2 i2 = new Index2(-100, -130); // Negativ Addition
Index2 i3 = new Index2(120, 145); // Ergebnis i1 - i2
Index2 i4 = new Index2(77, 44); // positive Addition
Index2 i5 = new Index2(-57, -29); // Ergebnis i1 - i4
// Addition
Assert.AreEqual(i3, i1 - i2);
Assert.AreEqual(i5, i1 - i4);
}
public void Index2MultiplikationTest()
{
Index2 i1 = new Index2(20, 15); // Startwert
Index2 i2 = new Index2(60, 45); // Multiplikation mit 3
Index2 i3 = new Index2(-40, -30); // Multi mit -2
Assert.AreEqual(i2, i1 * 3);
Assert.AreEqual(i3, i1 * -2);
}
public override void Update(GameTime gameTime)
{
bool nextInteract = false;
bool nextJump = false;
bool nextApply = false;
bool nextInventory = false;
bool[] nextSlot = new bool[SlotTriggerLength];
bool nextSlotLeft = false;
bool nextSlotRight = false;
MoveX = 0f;
MoveY = 0f;
HeadX = 0f;
HeadY = 0f;
if (ScreenMode)
{
Game.IsMouseVisible = true;
screenMouse.Update();
screenKeyboard.Update();
mousePointer = screenMouse.PointerPosition;
}
else
{
Game.IsMouseVisible = false;
gamepad.Update();
keyboard.Update();
if (Game.IsActive)
mouse.Update();
foreach (var device in inputDevices)
{
nextInteract |= device.InteractTrigger;
nextApply |= device.ApplyTrigger;
nextJump |= device.JumpTrigger;
nextInventory |= device.InventoryTrigger;
nextSlotLeft |= device.SlotLeftTrigger;
nextSlotRight |= device.SlotRightTrigger;
if (device.SlotTrigger != null)
for (int i = 0; i < Math.Min(device.SlotTrigger.Length, SlotTriggerLength); i++)
nextSlot[i] |= device.SlotTrigger[i];
MoveX += device.MoveX;
MoveY += device.MoveY;
HeadX += device.HeadX;
HeadY += device.HeadY;
}
InteractTrigger.Value = nextInteract;
ApplyTrigger.Value = nextApply;
InventoryTrigger.Value = nextInventory;
JumpTrigger.Value = nextJump;
SlotLeftTrigger.Value = nextSlotLeft;
SlotRightTrigger.Value = nextSlotRight;
for (int i = 0; i < SlotTriggerLength; i++)
SlotTrigger[i].Value = nextSlot[i];
MoveX = Math.Min(1, Math.Max(-1, MoveX));
MoveY = Math.Min(1, Math.Max(-1, MoveY));
}
}
public void LoadMultipleChunksTest()
{
int planet1 = 4;
int planet2 = 12;
Index2 index1 = new Index2(5, 6);
Index2 index2 = new Index2(15, 16);
IChunkColumn result1 = null;
IChunkColumn result2 = null;
int loadCallCounter = 0;
int saveCallCounter = 0;
GlobalChunkCache cache = new GlobalChunkCache(
(p, i) =>
{
loadCallCounter++;
if (p == planet1)
{
Assert.AreEqual(i, index1);
return result1 = new TestChunkColumn(p, index1);
}
else if (p == planet2)
{
Assert.AreEqual(i, index2);
return result2 = new TestChunkColumn(p, index2);
}
throw new NotSupportedException();
},
(p, i, c) =>
{
saveCallCounter++;
if (p == planet1)
{
Assert.AreEqual(i, index1);
Assert.AreEqual(c, result1);
return;
}
else if (p == planet2)
{
Assert.AreEqual(i, index2);
Assert.AreEqual(c, result2);
return;
}
throw new NotSupportedException();
});
// Load 1
Assert.AreEqual(0, cache.LoadedChunkColumns);
Assert.AreEqual(0, loadCallCounter);
Assert.AreEqual(0, saveCallCounter);
IChunkColumn x1 = cache.Subscribe(planet1, index1);
Assert.AreEqual(x1, result1);
Assert.AreEqual(x1.Planet, planet1);
Assert.AreEqual(x1.Index, index1);
Assert.AreEqual(1, cache.LoadedChunkColumns);
Assert.AreEqual(1, loadCallCounter);
Assert.AreEqual(0, saveCallCounter);
// Load 2
IChunkColumn x2 = cache.Subscribe(planet2, index2);
Assert.AreEqual(x2, result2);
Assert.AreEqual(x2.Planet, planet2);
Assert.AreEqual(x2.Index, index2);
Assert.AreEqual(2, cache.LoadedChunkColumns);
Assert.AreEqual(2, loadCallCounter);
Assert.AreEqual(0, saveCallCounter);
// Unload 1
cache.Release(planet1, index1);
Assert.AreEqual(1, cache.LoadedChunkColumns);
Assert.AreEqual(2, loadCallCounter);
Assert.AreEqual(1, saveCallCounter);
// Unload 2
cache.Release(planet2, index2);
Assert.AreEqual(0, cache.LoadedChunkColumns);
Assert.AreEqual(2, loadCallCounter);
Assert.AreEqual(2, saveCallCounter);
}
private bool FillChunkRenderer()
{
Index2 destinationChunk = new Index2(player.ActorHost.Position.ChunkIndex);
// Nur ausführen wenn der Spieler den Chunk gewechselt hat
if (destinationChunk != currentChunk)
{
int mask = (int)Math.Pow(2, VIEWRANGE) - 1;
int span = (int)Math.Pow(2, VIEWRANGE);
int spanOver2 = span >> 1;
for (int x = 0; x < span; x++)
{
for (int y = 0; y < span; y++)
{
Index2 local = new Index2(x - spanOver2, y - spanOver2) + destinationChunk;
local.NormalizeXY(planet.Size);
int virtualX = local.X & mask;
int virtualY = local.Y & mask;
int rendererIndex = virtualX +
(virtualY << VIEWRANGE);
for (int z = 0; z < planet.Size.Z; z++)
{
chunkRenderer[rendererIndex, z].SetChunk(_manager, local.X, local.Y, z);
}
}
}
currentChunk = destinationChunk;
}
#region Chunkrenderer updaten
// int shortestDistance = int.MaxValue;
// ChunkRenderer updatableRenderer = null;
foreach (var renderer in chunkRenderer)
{
if (!renderer.NeedUpdate())
continue;
renderer.RegenerateVertexBuffer();
// Index2 absoluteIndex = new Index2(renderer.ChunkPosition.Value);
// Index2 relativeIndex = destinationChunk.ShortestDistanceXY(
// absoluteIndex, new Index2(
// planet.Size.X,
// planet.Size.Y));
//
// int distance = relativeIndex.LengthSquared();
// if (distance < shortestDistance)
// {
// updatableRenderer = renderer;
// shortestDistance = distance;
// }
}
// if (updatableRenderer != null)
// updatableRenderer.RegenerateVertexBuffer();
#endregion
return true;
// return updatableRenderer != null;
}
public abstract float[,] GetHeightmap(Index2 chunkIndex);
public void LoadChunkWithMultipleReferencesTest()
{
int planet = 4;
Index2 index = new Index2(5, 6);
IChunkColumn result = null;
int loadCallCounter = 0;
int saveCallCounter = 0;
GlobalChunkCache cache = new GlobalChunkCache(
(p, i) =>
{
loadCallCounter++;
Assert.AreEqual(i, index);
return result = new TestChunkColumn(planet, index);
},
(p, i, c) =>
{
saveCallCounter++;
Assert.AreEqual(i, index);
Assert.AreEqual(c, result);
});
// Load 1
Assert.AreEqual(0, cache.LoadedChunkColumns);
Assert.AreEqual(0, loadCallCounter);
Assert.AreEqual(0, saveCallCounter);
IChunkColumn x1 = cache.Subscribe(planet, index);
Assert.AreEqual(x1, result);
Assert.AreEqual(x1.Planet, planet);
Assert.AreEqual(x1.Index, index);
Assert.AreEqual(1, cache.LoadedChunkColumns);
Assert.AreEqual(1, loadCallCounter);
Assert.AreEqual(0, saveCallCounter);
// Load 2
IChunkColumn x2 = cache.Subscribe(planet, index);
Assert.AreEqual(x2, result);
Assert.AreEqual(x2.Planet, planet);
Assert.AreEqual(x2.Index, index);
Assert.AreEqual(x1, x2);
Assert.AreEqual(1, cache.LoadedChunkColumns);
Assert.AreEqual(1, loadCallCounter);
Assert.AreEqual(0, saveCallCounter);
// Unload 1
cache.Release(planet, index);
Assert.AreEqual(1, cache.LoadedChunkColumns);
Assert.AreEqual(1, loadCallCounter);
Assert.AreEqual(0, saveCallCounter);
// Unload 2
cache.Release(planet, index);
Assert.AreEqual(0, cache.LoadedChunkColumns);
Assert.AreEqual(1, loadCallCounter);
Assert.AreEqual(1, saveCallCounter);
}
private void item_CellChanged(Item item, Index2 newValue)
{
// Environment Information aktualisieren
VisibleEnvironment env = viewers[item.Id].Environment;
// Element außerhalb des Spielfeldes
Index2 limit = Engine.Map.GetCellCount();
if (newValue.X < 0 || newValue.X >= limit.X ||
newValue.Y < 0 || newValue.Y >= limit.Y)
{
env.Center = null;
env.North = null;
env.South = null;
env.West = null;
env.East = null;
env.NorthWest = null;
env.NorthEast = null;
env.SouthWest = null;
env.SouthEast = null;
return;
}
// Umgebungszellen durchlaufen
for (int x = -1; x <= 1; x++)
for (int y = -1; y <= 1; y++)
{
var offset = new Index2(x, y);
Index2 cell = newValue + offset;
if (cell.X < 0 || cell.X >= limit.X ||
cell.Y < 0 || cell.Y >= limit.Y)
{
// Es existiert keine Zelle mehr
env[offset] = null;
}
else
{
// Zelleninfos ermitteln
float speed = Engine.Map.Tiles[cell.X, cell.Y].GetSpeedMultiplicator();
TileHeight height = Engine.Map.Tiles[cell.X, cell.Y].Height;
env[offset] = new VisibleCell
{
Speed = speed,
Height = height
};
}
}
// Inform user
viewers[item.Id].RefreshEnvironment();
}
