Example #1
0
        internal void SpawnStack(EntityStack stack)
        {
            PositionChunk positionChunk = PositionChunk.CreateFrom(stack.Position);
            Chunk         chunk         = GetChunk(positionChunk);

            chunk.AddEntity(stack);
        }
Example #2
0
        internal List <ChunkColumn> AllNeighborColumns(ChunkColumn chunkColumn)
        {
            Vector2[] deltas = new Vector2[] {
                new Vector2(-1, -1),
                new Vector2(0, -1),
                new Vector2(1, -1),
                new Vector2(-1, 0),
                new Vector2(1, 0),
                new Vector2(-1, 1),
                new Vector2(0, 1),
                new Vector2(1, 1),
            };
            List <ChunkColumn> neighbors = new List <ChunkColumn>();

            foreach (Vector2 delta in deltas)
            {
                PositionChunk chunkPos = new PositionChunk(chunkColumn.Position.X + (int)delta.X, 0, chunkColumn.Position.Z + (int)delta.Y);
                if (ChunkColumns.ContainsKey(chunkPos.Key))
                {
                    neighbors.Add(ChunkColumns[chunkPos.Key]);
                }
                else
                {
                    neighbors.Add(null);
                }
            }
            return(neighbors);
        }
Example #3
0
        private void ChangeChunk(int x, int y, int z)
        {
            PositionChunk positionChunk = PositionChunk.CreateFrom(new PositionBlock(x, y, z));

            chunkCache = World.Instance.GetCachedChunks();
            chunk      = chunkCache.GetChunk(positionChunk);
            chunk.Position.GetMinCornerBlock(out chunkCorner);
        }
Example #4
0
        internal void SetBlock(PositionBlock pos, int blockId)
        {
            PositionChunk positionChunk = PositionChunk.CreateFrom(pos);
            Chunk         chunk         = GetChunk(positionChunk);

            positionChunk.ConvertToLocalPosition(ref pos);
            chunk.SetLocalBlock(pos.X, pos.Y, pos.Z, blockId);
        }
 internal Chunk GetChunk(PositionChunk positionChunk)
 {
     if (chunks.ContainsKey(positionChunk.Key))
     {
         return(chunks[positionChunk.Key]);
     }
     return(null);
 }
Example #6
0
        internal Entity GetBlockEntity(PositionBlock position)
        {
            PositionChunk positionChunk = PositionChunk.CreateFrom(position);
            Chunk         chunk         = GetChunk(positionChunk);

            positionChunk.ConvertToLocalPosition(ref position);
            Entity entity = chunk.GetBlockEntity(position);

            return(entity);
        }
Example #7
0
        internal Chunk GetChunk(PositionChunk positionChunk)
        {
            Chunk chunk = storage.GetChunk(positionChunk);

            if (chunk == null)
            {
                chunk          = new Chunk();
                chunk.Position = positionChunk;
                storage.AddChunk(chunk);
            }
            return(chunk);
        }
Example #8
0
        internal override void OnDestroy(PositionBlock pos)
        {
            Chunk         chunk    = World.Instance.GetChunk(PositionChunk.CreateFrom(pos));
            PositionBlock localpos = pos;

            chunk.Position.ConvertToLocalPosition(ref localpos);
            float stage = (float)chunk.GetBlockMetaData(localpos, "stage");

            if (stage != 1f)
            {
                DropStack(new EntityStack(ItemRepository.SeedsWheat.Id, 1), pos);

                return;
            }
            base.OnDestroy(pos);
        }
Example #9
0
        internal object GetBlockMetaData(PositionBlock pos, string variable)
        {
            if (pos.Y < 0)
            {
                return(null);
            }
            if (pos.Y >= Chunk.MaxSizeY)
            {
                return(null);
            }
            PositionChunk positionChunk = PositionChunk.CreateFrom(pos);
            Chunk         chunk         = GetChunk(positionChunk);

            positionChunk.ConvertToLocalPosition(ref pos);
            return(chunk.GetBlockMetaData(pos, variable));
        }
Example #10
0
        internal void SetBlockMetaData(PositionBlock pos, string variable, object value)
        {
            if (pos.Y < 0)
            {
                return;
            }
            if (pos.Y >= Chunk.MaxSizeY)
            {
                return;
            }
            PositionChunk positionChunk = PositionChunk.CreateFrom(pos);
            Chunk         chunk         = GetChunk(positionChunk);

            positionChunk.ConvertToLocalPosition(ref pos);
            chunk.SetBlockMetaData(pos, variable, value);
        }
Example #11
0
        internal Entity GetBlockEntityFromPosition(PositionBlock pos)
        {
            if (pos.Y < 0)
            {
                return(null);
            }
            if (pos.Y >= Chunk.MaxSizeY)
            {
                return(null);
            }
            PositionChunk positionChunk = PositionChunk.CreateFrom(pos);
            Chunk         chunk         = GetChunk(positionChunk);

            positionChunk.ConvertToLocalPosition(ref pos);
            return(chunk.GetBlockEntityFromPosition(pos));
        }
Example #12
0
        private ChunkColumn GetChunkColumn(PositionChunk chunkPos)
        {
            PositionChunk columnPos = new PositionChunk(chunkPos.X, 0, chunkPos.Z);
            ChunkColumn   column;

            if (ChunkColumns.ContainsKey(columnPos.Key))
            {
                column = ChunkColumns[columnPos.Key];
            }
            else
            {
                column = new ChunkColumn(columnPos.X, columnPos.Z);
                ChunkColumns.Add(columnPos.Key, column);
                column.InitializeStage();
            }
            column.Active = true;
            return(column);
        }
Example #13
0
        internal int GetBlock(PositionBlock pos)
        {
            if (pos.Y < 0)
            {
                return(0);
            }
            if (pos.Y >= Chunk.MaxSizeY)
            {
                return(0);
            }
            PositionChunk positionChunk = PositionChunk.CreateFrom(pos);
            Chunk         chunk         = GetChunk(positionChunk);

            positionChunk.ConvertToLocalPosition(ref pos);
            int blockId = chunk.GetLocalBlock(pos.X, pos.Y, pos.Z);

            return(blockId);
        }
Example #14
0
        internal List<ChunkColumn> AllNeighborColumns(ChunkColumn chunkColumn)
        {
            Vector2[] deltas = new Vector2[] {
                new Vector2(-1,-1),
                new Vector2(0,-1),
                new Vector2(1,-1),
                new Vector2(-1,0),
                new Vector2(1,0),
                new Vector2(-1,1),
                new Vector2(0,1),
                new Vector2(1,1),
            };
            List<ChunkColumn> neighbors = new List<ChunkColumn>();
            foreach (Vector2 delta in deltas)
            {
                PositionChunk chunkPos = new PositionChunk(chunkColumn.Position.X + (int)delta.X, 0, chunkColumn.Position.Z + (int)delta.Y);
                if (ChunkColumns.ContainsKey(chunkPos.Key))
                    neighbors.Add(ChunkColumns[chunkPos.Key]);
                else
                    neighbors.Add(null);

            }
            return neighbors;
        }
Example #15
0
 public ChunkColumn(int x, int z)
 {
     Position = new PositionChunk(x, 0, z);
 }
Example #16
0
        internal void Update(Vector3 centerPos)
        {
            float   chunkRadius        = (int)((GameSettings.CachingRadius) / 16f);
            float   chunkRadiusSquared = chunkRadius * chunkRadius;
            Vector3 centerBlockPos     = new Vector3(
                MathLibrary.FloorToWorldGrid(centerPos.X),
                MathLibrary.FloorToWorldGrid(centerPos.Y),
                MathLibrary.FloorToWorldGrid(centerPos.Z));

            if (centerBlockPos.Y > Chunk.MaxSizeY - 1)
            {
                centerBlockPos.Y = Chunk.MaxSizeY - 1;
            }
            else if (centerBlockPos.Y < 0)
            {
                centerBlockPos.Y = 0;
            }
            PositionChunk centerChunk = PositionChunk.CreateFrom(centerBlockPos);
            PositionChunk minChunk    = new PositionChunk(centerChunk.X - (int)chunkRadius, 0, centerChunk.Z - (int)chunkRadius);
            PositionChunk maxChunk    = new PositionChunk(centerChunk.X + (int)chunkRadius, Chunk.MaxSizeY / 16 - 1, centerChunk.Z + (int)chunkRadius);

            // add all chunks within blockradius
            if (!centerChunk.SameAs(LastCenterChunk))
            {
                // update the cache
                for (int x = minChunk.X; x <= maxChunk.X; x++)
                {
                    for (int z = minChunk.Z; z <= maxChunk.Z; z++)
                    {
                        int    dx = x - centerChunk.X;
                        int    dz = z - centerChunk.Z;
                        double chunkCurrentDistSquared = dx * dx + dz * dz;
                        if (chunkCurrentDistSquared > chunkRadiusSquared)
                        {
                            continue;
                        }
                        for (int y = minChunk.Y; y <= maxChunk.Y; y++)
                        {
                            Chunk chunk = World.Instance.GetChunk(new PositionChunk(x, y, z));
                            if (!cachedChunks.ContainsKey(chunk.Position.Key))
                            {
                                cachedChunks.Add(chunk.Position.Key, chunk);
                            }
                        }
                    }
                }
                OrderedChunks = cachedChunks.Values.Where(c =>
                {
                    float dx = c.Position.X - centerChunk.X;
                    float dz = c.Position.Z - centerChunk.Z;
                    return(dx * dx + dz * dz <= chunkRadiusSquared);
                }).OrderBy(c =>
                {
                    float dx = c.Position.X - centerChunk.X;
                    float dz = c.Position.Z - centerChunk.Z;
                    return(dx * dx + dz * dz);
                }).ThenBy(c =>
                {
                    float dy = c.Position.Y - centerChunk.Y;
                    return(dy * dy);
                }).ToList();

                IsDirty = true;
            }

            // update chunks...
            bool allowHeavyTask = true;

            foreach (var column in ChunkColumns.Values)
            {
                column.Active = false;
            }
            foreach (Chunk chunk in OrderedChunks)
            {
                chunk.Column           = GetChunkColumn(chunk.Position);
                chunk.HeavyTaskAllowed = allowHeavyTask;
                chunk.Update();
                if (chunk.HeavyTaskExecuted)
                {
                    allowHeavyTask = false;
                }
                // relocate entities
                foreach (EntityStack stack in chunk.StackEntities.ToArray())
                {
                    PositionChunk destChunk = PositionChunk.CreateFrom(stack.Position);
                    if (!chunk.Position.SameAs(destChunk))
                    {
                        // relocate
                        chunk.RemoveEntity(stack);
                        if (cachedChunks.ContainsKey(destChunk.Key))
                        {
                            cachedChunks[destChunk.Key].AddEntity(stack);
                        }
                    }
                }
            }

            // dispose and remove expired chunks
            var expiredChunks = cachedChunks.Where(pair => pair.Value.Expired).ToList();

            expiredChunks.ForEach(pair =>
            {
                pair.Value.Dipose();
                cachedChunks.Remove(pair.Key);
            });
            // remove unused columnds
            var columnsToRemove = ChunkColumns.Where(pair => pair.Value.Active == false).ToList();

            columnsToRemove.ForEach(pair =>
            {
                ChunkColumns.Remove(pair.Key);
            });

            LastCenterChunk = centerChunk;
        }
Example #17
0
        internal void ProfilerSnapshot()
        {
            VertexBuffer.Dispose(ref profileVertexBuffer);

            t.ResetTransformation();
            FontRenderer f      = FontRenderer.Instance;
            Player       player = World.Instance.Player;

            f.BeginBatch();
            f.CharScale = 1;
            string report = p.Report();
            float  y      = TheGame.Instance.Height - FontRenderer.Instance.LineHeight;

            using (StringReader sr = new StringReader(report))
            {
                string line;
                while ((line = sr.ReadLine()) != null)
                {
                    f.RenderTextShadow(line, 0, y);
                    y -= f.LineHeight;
                }
            }

            // log...
            y -= f.LineHeight;

            if (World.Instance.PlayerVoxelTrace.Hit)
            {
                Vector4 impactpos = World.Instance.PlayerVoxelTrace.ImpactPosition;
                string  line      = string.Format(GetVectorAsString("impactpos", impactpos));
                f.RenderTextShadow(line, 0, y);
                y -= f.LineHeight;
            }
            else
            {
                f.RenderTextShadow("impactpos", 0, y);
                y -= f.LineHeight;

                Vector3 pos = new Vector3(player.Position.X, player.Position.Y, player.Position.Z);
                if (pos.Y > Chunk.MaxSizeY - 1)
                {
                    pos.Y = Chunk.MaxSizeY - 1;
                }
                else if (pos.Y < 0)
                {
                    pos.Y = 0;
                }
                PositionChunk chunkPos  = PositionChunk.CreateFrom(pos);
                Vector3       chunkPos3 = new Vector3(chunkPos.X, chunkPos.Y, chunkPos.Z);
                f.RenderTextShadow(string.Format(GetVectorAsString("chunkpos", chunkPos3)), 0, y);
                y -= f.LineHeight;
                ChunkCache cache = World.Instance.GetCachedChunks();
                Chunk      c     = cache.GetChunk(chunkPos);
                if (c != null)
                {
                    f.RenderTextShadow(string.Format("chunk.Stage      = {0}", c.Stage.ToString()), 0, y);
                    y -= f.LineHeight;
                    f.RenderTextShadow(string.Format("chunk.col.stage  = {0}", c.Column.Stage.ToString()), 0, y);
                    y -= f.LineHeight;
                    f.RenderTextShadow(string.Format("chunk.col.active = {0}", c.Column.Active.ToString()), 0, y);
                    y -= f.LineHeight;
                    f.RenderTextShadow(string.Format("cache.alleighbors= {0}", cache.AllNeighborColumns(c.Column).Where(cc => cc != null).Count()), 0, y);
                    y -= f.LineHeight;

                    List <Chunk> chunks = new List <Chunk>();
                    for (int i = 0; i < 8; i++)
                    {
                        chunks.Add(cache.GetChunk(new PositionChunk(c.Position.X, i, c.Position.Z)));
                    }
                }
            }
            f.RenderTextShadow(GetVectorAsString("direction", player.Direction), 0, y);

            y -= f.LineHeight;
            f.RenderTextShadow(GetVectorAsString("position", player.Position), 0, y);

            y -= f.LineHeight;
            y -= f.LineHeight;
            string[] lastLines = Log.Instance.Last(70);
            foreach (string line in lastLines)
            {
                f.RenderTextShadow(line, 0, y);
                y -= f.LineHeight;
            }
            f.StopBatch();
            profileVertexBuffer = t.GetVertexBuffer();
        }
Example #18
0
 private ChunkColumn GetChunkColumn(PositionChunk chunkPos)
 {
     PositionChunk columnPos = new PositionChunk(chunkPos.X, 0, chunkPos.Z);
     ChunkColumn column;
     if (ChunkColumns.ContainsKey(columnPos.Key))
     {
         column = ChunkColumns[columnPos.Key];
     }
     else
     {
         column = new ChunkColumn(columnPos.X, columnPos.Z);
         ChunkColumns.Add(columnPos.Key, column);
         column.InitializeStage();
     }
     column.Active = true;
     return column;
 }
Example #19
0
 internal Chunk GetChunk(PositionChunk positionChunk)
 {
     if (!cachedChunks.ContainsKey(positionChunk.Key))
         return null;
     return cachedChunks[positionChunk.Key];
 }
Example #20
0
        internal void Update(Vector3 centerPos)
        {
            float chunkRadius = (int)((GameSettings.CachingRadius) / 16f);
            float chunkRadiusSquared = chunkRadius * chunkRadius;
            Vector3 centerBlockPos = new Vector3(
                MathLibrary.FloorToWorldGrid(centerPos.X),
                MathLibrary.FloorToWorldGrid(centerPos.Y),
                MathLibrary.FloorToWorldGrid(centerPos.Z));
            if (centerBlockPos.Y > Chunk.MaxSizeY - 1)
                centerBlockPos.Y = Chunk.MaxSizeY - 1;
            else if (centerBlockPos.Y < 0)
                centerBlockPos.Y = 0;
            PositionChunk centerChunk = PositionChunk.CreateFrom(centerBlockPos);
            PositionChunk minChunk = new PositionChunk(centerChunk.X - (int)chunkRadius, 0, centerChunk.Z - (int)chunkRadius);
            PositionChunk maxChunk = new PositionChunk(centerChunk.X + (int)chunkRadius, Chunk.MaxSizeY / 16 - 1, centerChunk.Z + (int)chunkRadius);

            // add all chunks within blockradius
            if (!centerChunk.SameAs(LastCenterChunk))
            {
                // update the cache
                for (int x = minChunk.X; x <= maxChunk.X; x++)
                {
                    for (int z = minChunk.Z; z <= maxChunk.Z; z++)
                    {
                        int dx = x - centerChunk.X;
                        int dz = z - centerChunk.Z;
                        double chunkCurrentDistSquared = dx * dx + dz * dz;
                        if (chunkCurrentDistSquared > chunkRadiusSquared)
                            continue;
                        for (int y = minChunk.Y; y <= maxChunk.Y; y++)
                        {
                            Chunk chunk = World.Instance.GetChunk(new PositionChunk(x, y, z));
                            if (!cachedChunks.ContainsKey(chunk.Position.Key))
                            {
                                cachedChunks.Add(chunk.Position.Key, chunk);
                            }
                        }
                    }
                }
                OrderedChunks = cachedChunks.Values.Where(c =>
                {
                    float dx = c.Position.X - centerChunk.X;
                    float dz = c.Position.Z - centerChunk.Z;
                    return dx * dx + dz * dz <= chunkRadiusSquared;
                }).OrderBy(c =>
                {
                    float dx = c.Position.X - centerChunk.X;
                    float dz = c.Position.Z - centerChunk.Z;
                    return dx * dx + dz * dz;
                }).ThenBy(c =>
                {
                    float dy = c.Position.Y - centerChunk.Y;
                    return dy * dy;
                }).ToList();

                IsDirty = true;
            }

            // update chunks...
            bool allowHeavyTask = true;
            foreach (var column in ChunkColumns.Values)
            {
                column.Active = false;
            }
            foreach (Chunk chunk in OrderedChunks)
            {
                chunk.Column = GetChunkColumn(chunk.Position);
                chunk.HeavyTaskAllowed = allowHeavyTask;
                chunk.Update();
                if (chunk.HeavyTaskExecuted)
                    allowHeavyTask = false;
                // relocate entities
                foreach (EntityStack stack in chunk.StackEntities.ToArray())
                {
                    PositionChunk destChunk = PositionChunk.CreateFrom(stack.Position);
                    if (!chunk.Position.SameAs(destChunk))
                    {
                        // relocate
                        chunk.RemoveEntity(stack);
                        if (cachedChunks.ContainsKey(destChunk.Key))
                        {
                            cachedChunks[destChunk.Key].AddEntity(stack);
                        }
                    }
                }
            }

            // dispose and remove expired chunks
            var expiredChunks = cachedChunks.Where(pair => pair.Value.Expired).ToList();
            expiredChunks.ForEach(pair =>
            {
                pair.Value.Dipose();
                cachedChunks.Remove(pair.Key);
            });
            // remove unused columnds
            var columnsToRemove = ChunkColumns.Where(pair => pair.Value.Active == false).ToList();
            columnsToRemove.ForEach(pair =>
            {
                ChunkColumns.Remove(pair.Key);
            });

            LastCenterChunk = centerChunk;
        }
Example #21
0
 public ChunkColumn(int x, int z)
 {
     Position = new PositionChunk(x, 0, z);
 }
Example #22
0
 internal Chunk GetChunk(PositionChunk positionChunk)
 {
     Chunk chunk = storage.GetChunk(positionChunk);
     if (chunk == null)
     {
         chunk = new Chunk();
         chunk.Position = positionChunk;
         storage.AddChunk(chunk);
     }
     return chunk;
 }
Example #23
0
        private void CollectNearbyEntities()
        {
            if (throwStackDelay > 0)
            {
                throwStackDelay--;
                return;
            }

            AxisAlignedBoundingBox collectArea = AABB;
            collectArea.Translate(Position);
            float radius = 0.5f;
            collectArea.Min -= new Vector3(radius, radius, radius);
            collectArea.Max += new Vector3(radius, radius, radius);
            collectArea.CapToWorldBounds();

            PositionChunk minChunk = PositionChunk.CreateFrom(collectArea.Min);
            PositionChunk maxChunk = PositionChunk.CreateFrom(collectArea.Max);
            PositionChunk chunkPos;
            for (int x = minChunk.X; x <= maxChunk.X; x++)
            {
                for (int y = minChunk.Y; y <= maxChunk.Y; y++)
                {
                    for (int z = minChunk.Z; z <= maxChunk.Z; z++)
                    {
                        chunkPos = new PositionChunk(x, y, z);
                        Chunk chunk = World.Instance.GetChunk(chunkPos);
                        foreach (EntityStack stack in chunk.EntitiesInArea(collectArea))
                        {
                            // transfer items
                            Inventory.CollectStack(stack);
                            // if stack is empty remove it
                            if (stack.IsEmpty)
                            {
                                chunk.RemoveEntity(stack);
                            }
                        }
                    }
                }
            }
        }