public static bool FixCoords(ref Vector3i chunk, ref Vector3i local) {
			bool changed = false;
			if(local.x < 0) {
				chunk.x--;
				local.x += OCChunk.SIZE_X;
				changed = true;
			}
			if(local.y < 0) {
				chunk.y--;
				local.y += OCChunk.SIZE_Y;
				changed = true;
			}
			if(local.z < 0) {
				chunk.z--;
				local.z += OCChunk.SIZE_Z;
				changed = true;
			}
			
			if(local.x >= OCChunk.SIZE_X) {
				chunk.x++;
				local.x -= OCChunk.SIZE_X;
				changed = true;
			}
			if(local.y >= OCChunk.SIZE_Y) {
				chunk.y++;
				local.y -= OCChunk.SIZE_Y;
				changed = true;
			}
			if(local.z >= OCChunk.SIZE_Z) {
				chunk.z++;
				local.z -= OCChunk.SIZE_Z;
				changed = true;
			}
			return changed;
		}

		private static void UpdateLight(OCMap map, Vector3i pos) {
	        list.Clear();
			foreach(Vector3i dir in Vector3i.directions) {
				list.Add( pos + dir );
			}
	        Scatter(map, list);
		}

	//NOTE: this function pulls the weight of actually destroying blocks for us. It is applied to the OCActions of a character; not to blocks themselves. 
	public void DestroyBlock(Vector3i? point)
	{
		if(point.HasValue)
		{
			OCMap map = OCMap.Instance;//(OCMap)GameObject.FindSceneObjectsOfType(typeof(OCMap)).FirstOrDefault();
			
			//for updating goal controllers after deletion.
			OCBlock blockType = map.GetBlock(point.Value).block;
			OCGoalController[] goalControllers = (OCGoalController[])GameObject.FindObjectsOfType(typeof(OCGoalController));
			
			//actually sets the block to null and recomputes the chunk. 
			Debug.Log(OCLogSymbol.DEBUG + "DeleteSelectedVoxel called from CreateBlockEffect");
			GameManager.world.voxels.DeleteSelectedVoxel(point.Value);
			
			//re-update goals concerned with this block type
			foreach(OCGoalController goalController in goalControllers)
			{
				if(goalController.GoalBlockType == blockType)
				{
					goalController.FindGoalBlockPositionInChunks(map.GetChunks());
				}
			}

			blocksDestroyed++;
		}
	}

		public static void RecomputeLightAtPosition(OCMap map, Vector3i pos) {
			OCSunLightMap lightmap = map.GetSunLightmap();
			int oldSunHeight = lightmap.GetSunHeight(pos.x, pos.z);
			ComputeRayAtPosition(map, pos.x, pos.z);
			int newSunHeight = lightmap.GetSunHeight(pos.x, pos.z);
			
			if(newSunHeight < oldSunHeight) { // свет опустился
				// добавляем свет
				list.Clear();
	            for (int ty = newSunHeight; ty <= oldSunHeight; ty++) {
					pos.y = ty;
	                lightmap.SetLight(MIN_LIGHT, pos);
	                list.Add( pos );
	            }
	            Scatter(map, list);
			}
			if(newSunHeight > oldSunHeight) { // свет поднялся
				// удаляем свет
				list.Clear();
	            for (int ty = oldSunHeight; ty <= newSunHeight; ty++) {
					pos.y = ty;
					list.Add( pos );
	            }
	            RemoveLight(map, list);
			}
			
			if(newSunHeight == oldSunHeight) {
				if( map.GetBlock(pos).IsAlpha() ) {
					UpdateLight(map, pos);
				} else {
					RemoveLight(map, pos);
				}
			}
		}

	public int DistanceSqr(Vector3i other)
	{
		int x2 = x - other.x,
			y2 = y - other.y,
			z2 = z - other.z;
		return (x2 * x2) + (y2 * y2) + (z2 * z2);
	}

		//---------------------------------------------------------------------------
		
		#region Private Member Data
		
		//---------------------------------------------------------------------------
		
		
		
		//---------------------------------------------------------------------------
		
		#endregion
		
		//---------------------------------------------------------------------------
		
		#region Accessors and Mutators
		
		//---------------------------------------------------------------------------
		
		
		
		//---------------------------------------------------------------------------
		
		#endregion
		
		//---------------------------------------------------------------------------
		
		#region Public Member Functions
		
		//---------------------------------------------------------------------------
		
		public void TransferBlock(Vector3i? origin, Vector3i? destination)
		{
			if(origin.HasValue && destination.HasValue)
			{
				OCMap map = OCMap.Instance;//(OCMap)GameObject.FindSceneObjectsOfType(typeof(OCMap)).FirstOrDefault();
				
				OCGoalController[] goalControllers = (OCGoalController[])GameObject.FindObjectsOfType(typeof(OCGoalController));

				foreach(Transform battery in map.BatteriesSceneObject.transform)
				{
					if(VectorUtil.AreVectorsEqual(battery.position, new Vector3((float)origin.Value.x, (float)origin.Value.y, (float)origin.Value.z)))
						battery.position = new Vector3((float)destination.Value.x, (float)destination.Value.y, (float)destination.Value.z);
				}

				OCBlockData block = map.GetBlock(origin.Value);

				map.SetBlockAndRecompute(block, destination.Value);
				map.SetBlockAndRecompute(OCBlockData.CreateInstance<OCBlockData>().Init(null, origin.Value), origin.Value);
				
				foreach(OCGoalController goalController in goalControllers)
				{
					if(goalController.GoalBlockType == block.block)
					{
						goalController.FindGoalBlockPositionInChunks(map.GetChunks());
					}
				}
				
			}
		}

		private static void SetChunkLightDirty(OCMap map, Vector3i chunkPos) {
			OCChunk chunkData = map.GetChunk(chunkPos);
			if(chunkData == null) return;
			OCChunkRenderer chunk = chunkData.GetChunkRenderer();
			if(chunk == null) return;
			chunk.SetLightDirty();
		}

    // generates a new spawn near initial spawn if initial spawn is in water
    public Vector3i DontSpawnPlayerInWater(Vector3i initialSpawn)
    {
        if (IsPlayerPositionDry(initialSpawn.x, initialSpawn.y, initialSpawn.z))
        {
            return initialSpawn;
        }

        //find shore
        //bonus +10 because player shouldn't be spawned too close to shore.
        bool bonusset = false;
        int bonus = -1;
        Vector3i pos = initialSpawn;
        for (int i = 0; i < playerareasize / 4 - 5; i++)
        {
            if (IsPlayerPositionDry(pos.x, pos.y, pos.z))
            {
                if (!bonusset)
                {
                    bonus = 10;
                    bonusset = true;
                }
            }
            if (bonusset && bonus-- < 0)
            {
                break;
            }
            pos.x++;
            int newblockheight = MapUtil.blockheight(d_Map, 0, pos.x, pos.y);
            pos.z = newblockheight + 1;
        }
        return pos;
    }

    public void ShiftWorldChunks(Vector3i increment)
    {
        m_ChunkProcessor.ChunksAreBeingAdded = true;
        // We copy the original, because if we moved each chunk it's a
        // "destructive" move, possibly overwriting another chunk that also needs
        // to move.
        Chunk[, ,] copyOfOriginalChunks = CreateCopyOfOriginalChunkArray();
        List<Chunk> newCunksAddedToMap = new List<Chunk>();
        List<Chunk> chunksToDecorate = new List<Chunk>();

        m_WorldData.MapChunkOffset = m_WorldData.MapChunkOffset - increment;
        //m_WorldData.MapChunkOffset.X -= increment.X;
        //m_WorldData.MapChunkOffset.Y -= increment.Y;
        for (int x = 0; x < m_WorldData.ChunksWide; x++)
        {
            for (int y = 0; y < m_WorldData.ChunksHigh; y++)
            {
                for (int z = 0; z < m_WorldData.ChunksDeep; z++)
                {
                    MoveChunk(copyOfOriginalChunks[x, y, z], increment, newCunksAddedToMap, chunksToDecorate);
                }
            }
        }
        m_ChunkProcessor.AddBatchOfChunks(newCunksAddedToMap, BatchType.TerrainGeneration);
        m_ChunkProcessor.AddBatchOfChunks(chunksToDecorate, BatchType.Decoration);
        m_ChunkProcessor.ChunksAreBeingAdded = false;
    }

    public override void Update(Server server, float dt)
    {
        int sizexchunks = server.mapsizexchunks();
        int sizeychunks = server.mapsizeychunks();
        int sizezchunks = server.mapsizezchunks();

        for (int i = 0; i < 100; i++)
        {
            MapUtilCi.PosInt(CompressUnusedIteration, sizexchunks, sizeychunks, chunkpos);
            ServerChunk c = server.d_Map.GetChunkValid(chunkpos.X, chunkpos.Y, chunkpos.Z);
            bool stop = false;
            if (c != null)
            {
                var globalpos = new Vector3i(chunkpos.X * Server.chunksize, chunkpos.Y * Server.chunksize, chunkpos.Z * Server.chunksize);
                bool unload = true;
                foreach (var k in server.clients)
                {
                    if (k.Value.IsBot)
                    {
                        // don't hold chunks in memory for bots
                        continue;
                    }
                    // unload distance = view distance + 60% (prevents chunks from being unloaded too early (square loading vs. circular unloading))
                    int viewdist = (int)(server.chunkdrawdistance * Server.chunksize * 1.8f);
                    if (server.DistanceSquared(server.PlayerBlockPosition(k.Value), globalpos) <= viewdist * viewdist)
                    {
                        //System.Console.WriteLine("No Unload:   {0},{1},{2}", chunkpos.X, chunkpos.Y, chunkpos.Z);
                        unload = false;
                    }
                }
                if (unload)
                {
                    // unload if chunk isn't seen by anyone
                    if (c.DirtyForSaving)
                    {
                        // save changes to disk if necessary
                        server.DoSaveChunk(chunkpos.X, chunkpos.Y, chunkpos.Z, c);
                    }
                    server.d_Map.SetChunkValid(chunkpos.X, chunkpos.Y, chunkpos.Z, null);
                    foreach (var client in server.clients)
                    {
                        // mark chunks unseen for all players
                        server.ClientSeenChunkRemove(client.Key, chunkpos.X, chunkpos.Y, chunkpos.Z);
                    }
                    stop = true;
                }
            }
            CompressUnusedIteration++;
            if (CompressUnusedIteration >= sizexchunks * sizeychunks * sizezchunks)
            {
                CompressUnusedIteration = 0;
            }
            if (stop)
            {
                // only unload one chunk at a time
                return;
            }
        }
    }

	//---------------------------------------------------------------------------

	#region Private Member Data

	//---------------------------------------------------------------------------
	

			
	//---------------------------------------------------------------------------

	#endregion

	//---------------------------------------------------------------------------

	#region Accessors and Mutators

	//---------------------------------------------------------------------------
		

			
	//---------------------------------------------------------------------------

	#endregion

	//---------------------------------------------------------------------------

	#region Public Member Functions

	//---------------------------------------------------------------------------

	public static void Build(Vector3i localPos, Vector3i worldPos, OpenCog.Map.OCMap map, OpenCog.Builder.OCMeshBuilder mesh, bool onlyLight)
	{
		if(!onlyLight)
		{
			BuildCross((Vector3)localPos, worldPos, map, mesh);
		}
		BuildCrossLight(map, worldPos, mesh);
	}

 public void ClearChunkDetails(Vector3i details)
 {
     BsonValue id = GetIDFor(details.X, details.Y, details.Z);
     lock (FSLock)
     {
         DBChunks.Delete(id);
     }
 }

 static ComputeProgram()
 {
     int x,y,z;
     GL.GetInteger((GetIndexedPName)All.MaxComputeWorkGroupCount, 0, out x);
     GL.GetInteger((GetIndexedPName)All.MaxComputeWorkGroupCount, 1, out y);
     GL.GetInteger((GetIndexedPName)All.MaxComputeWorkGroupCount, 2, out z);
     MaximumWorkGroupSize = new Vector3i(x,y,z);
 }

	CubeMesh CalculateRenderableCube(Cube cube, ref int visualVertexCount, ref int collisionVertexCount, Cube[,,] cubes, Vector3i gridPosition) {
    	if (cube == null) return null;
	    cube.cubeSize = cubeSize;
		
	    cube.indexes = gridPosition;
	    cube.chunk = this;
	    var cubeMesh = cube.Calculate(ref visualVertexCount, ref collisionVertexCount,cubes, cubeLegend, cubeObject.colliderType, cubeObject.cubeTag);
	    return cubeMesh;
	}

 public Block this[Vector3i Location]
 {
     get {
         return BlockData[Location.X, Location.Y, Location.Z];
     }
     set {
         BlockData[Location.X, Location.Y, Location.Z] = value;
     }
 }

		// TODO: May need to be re-enabled...hope not, since all blockdata that gets instantiated should get its coordinates too.
	//	public BlockData(Block block) {
	//		this.block = block;
	//		direction = BlockDirection.Z_PLUS;
	//	}
	
//		public OCBlockData() 
//		{
//		}
		
		public OCBlockData Init(OpenCog.BlockSet.BaseBlockSet.OCBlock block, Vector3i globalPosition)
		{
			this.block = block;
			this._globalX = globalPosition.x;
			this._globalY = globalPosition.y;
			this._globalZ = globalPosition.z;
			direction = OCBlockDirection.Z_PLUS;
			return this;
		}

 /// <summary>
 /// Load a TileEntity's basic values (call via base() in all inheriting files)
 /// </summary>
 /// <param name="CX">Chunk X Coordinate</param>
 /// <param name="CY">Chunk Y Coordinate</param>
 /// <param name="CS">Chunk horizontal scale</param>
 /// <param name="c">TileEntity's NbtCompound.</param>
 public TileEntity(int CX,int CY,int CS,NbtCompound c)
 {
     Pos = new Vector3i(
         c.Get<NbtInt>("x").Value,
         c.Get<NbtInt>("y").Value,
         c.Get<NbtInt>("z").Value);
     ID = (c["id"] as NbtString).Value;
     orig = c;
 }

 /// <summary>
 /// Load a TileEntity's basic values (call via base() in all inheriting files)
 /// </summary>
 /// <param name="c"></param>
 public TileEntity(NbtCompound c)
 {
     orig = c;
     Pos = new Vector3i(
         c.Get<NbtInt>("x").Value,
         c.Get<NbtInt>("z").Value,
         c.Get<NbtInt>("y").Value);
     id = c.Get<NbtString>("id").Value;
 }

        public Block this[Vector3i Location]
        {
            get {
                return Realm.GetBlock((ChunkLocation * Size) + Location);
            }

            set {
                Realm.SetBlock((ChunkLocation * Size) + Location, value);
            }
        }

        public Block this[Vector3i Location]
        {
            get {
                return Realm.GetBlock(Location);
            }

            set {
                Realm.SetBlock(Location, value);
            }
        }