Esempio n. 1
0
        /// <summary>
        /// Überschreibt den Block an der angegebenen Koordinate.
        /// </summary>
        /// <param name="index">Block-Koordinate</param>
        /// <param name="block">Neuer Block oder null, falls der alte Bock gelöscht werden soll.</param>
        public void SetBlock(Index3 index, IBlock block)
        {
            IPlanet planet = ResourceManager.Instance.GetPlanet(Player.Position.Planet);

            index.NormalizeXYZ(new Index3(
                planet.Size.X * Chunk.CHUNKSIZE_X,
                planet.Size.Y * Chunk.CHUNKSIZE_Y,
                planet.Size.Z * Chunk.CHUNKSIZE_Z));
            Coordinate coordinate = new Coordinate(0, index, Vector3.Zero);
            IChunk chunk = localChunkCache.Get(coordinate.ChunkIndex);
            chunk.SetBlock(coordinate.LocalBlockIndex, block);
        }
Esempio n. 2
0
        public void Index3NormaizeMethodenTest()
        {
            Index3 i1   = new Index3(20, 20, 20); // Startwert
            Index2 i2   = new Index2(12, 13);     // 2D-Size
            Index3 i2b  = new Index3(12, 13, 14); // 3D-Size
            Index3 ix   = new Index3(8, 20, 20);  // Ergebnis bei NormX
            Index3 iy   = new Index3(20, 7, 20);  // Ergebnis bei NormY
            Index3 iz   = new Index3(20, 20, 6);  // Ergebnis bei NormZ
            Index3 ixy  = new Index3(8, 7, 20);   // Ergebnis bei NormXY
            Index3 ixyz = new Index3(8, 7, 6);    // Ergebnis bei NormXYZ

            // Norm X (int)
            Index3 t = i1;

            t.NormalizeX(i2.X);
            Assert.AreEqual(ix, t);

            // Norm X (index2)
            t = i1;
            t.NormalizeX(i2);
            Assert.AreEqual(ix, t);

            // Norm X (index3)
            t = i1;
            t.NormalizeX(i2b);
            Assert.AreEqual(ix, t);

            // Norm Y (int)
            t = i1;
            t.NormalizeY(i2.Y);
            Assert.AreEqual(iy, t);

            // Norm Y (index2)
            t = i1;
            t.NormalizeY(i2);
            Assert.AreEqual(iy, t);

            // Norm Y (index3)
            t = i1;
            t.NormalizeY(i2b);
            Assert.AreEqual(iy, t);

            // Norm Z (int)
            t = i1;
            t.NormalizeZ(i2b.Z);
            Assert.AreEqual(iz, t);

            // Norm Z (index3)
            t = i1;
            t.NormalizeZ(i2b);
            Assert.AreEqual(iz, t);

            // Norm XY (int)
            t = i1;
            t.NormalizeXY(i2.X, i2.Y);
            Assert.AreEqual(ixy, t);

            // Norm XY (index2)
            t = i1;
            t.NormalizeXY(i2);
            Assert.AreEqual(ixy, t);

            // Norm XY (index3)
            t = i1;
            t.NormalizeXY(i2b);
            Assert.AreEqual(ixy, t);

            // Norm XYZ (int)
            t = i1;
            t.NormalizeXYZ(i2.X, i2.Y, i2b.Z);
            Assert.AreEqual(ixyz, t);

            // Norm XYZ (index3)
            t = i1;
            t.NormalizeXYZ(i2b);
            Assert.AreEqual(ixyz, t);
        }
Esempio n. 3
0
        /// <summary>
        /// Überschreibt den Block an der angegebenen Koordinate.
        /// </summary>
        /// <param name="index">Block-Koordinate</param>
        /// <param name="block">Neuer Block oder null, falls der alte Bock gelöscht werden soll.</param>
        public void SetBlock(int planetId, Index3 index, IBlock block)
        {
            IPlanet planet = GetPlanet(planetId);

            index.NormalizeXYZ(new Index3(
                planet.Size.X * Chunk.CHUNKSIZE_X,
                planet.Size.Y * Chunk.CHUNKSIZE_Y,
                planet.Size.Z * Chunk.CHUNKSIZE_Z));
            Coordinate coordinate = new Coordinate(0, index, Vector3.Zero);
            IChunk chunk = GetChunk(planetId, coordinate.ChunkIndex);
            chunk.SetBlock(coordinate.LocalBlockIndex, block);
        }