public void Map(MappingFunction mappingFunction) { for (int i = 0; i < _words.Length; i++) { _words[i] = mappingFunction(_words[i]); } }
public override object AssignValuesFromObject(object other) { if (!mappings.ContainsKey(other.GetType())) { mappings.Add(other.GetType(), (MappingFunction) delegate(object other2) { return(this.MapByName(other2)); }); } if (CanBeAssignedFromType(other.GetType())) { return(MapByName(other)); } else /* if valid mapping is declared */ { // perform mapping as declared in the mapping function } MappingFunction map = mappings[other.GetType()] as MappingFunction; map(other); return(new Dictionary <string, object>()); }
//TODO : make a physics thread and put this on it public FluidSimulation(MappingFunction mappingFunction, Block[] blocks) { m_mappingFunction = mappingFunction; m_blocks = blocks; m_containers = new List<FluidContainer>(); m_solidCell = new FluidCell(FluidCell.CellType.Solid); m_addQueue = new Queue<List<FluidCell>>(); m_cellAccumulator = new List<FluidCell>(); }
public FluidContainer(MappingFunction mappingFunction, Block[] blocks, FluidCell solidCellReference) { m_mappingFunction = mappingFunction; m_blocks = blocks; m_solidCellReference = solidCellReference; Update = true; Alive = true; m_min = new Vector3Int(int.MaxValue, int.MaxValue, int.MaxValue); m_max = new Vector3Int(-int.MaxValue, -int.MaxValue, -int.MaxValue); Cells = new List<FluidCell>(); CellDictionary = new Dictionary<long, FluidCell>(); Updated = new List<FluidCell>(); }
/// <summary> /// Apply a SyntaxElement.MappingFunction to the syntax tree. /// </summary> /// <param name="mappingFunction">An aribtrary mapping function to be applied to the syntax tree.</param> /// <returns>A new object of the enclosing type with the mapping function applied.</returns> public override SyntaxElement ApplyMappingFunction(MappingFunction mappingFunction) { return(new ResourceAccessFact( (PrincipalIdentifier)mappingFunction(this.Resource), (PrincipalIdentifier)mappingFunction(this.Module), (PrincipalIdentifier)mappingFunction(this.Group), (IntegerIdentifier)mappingFunction(this.From), (IntegerIdentifier)mappingFunction(this.To), (IntegerIdentifier)mappingFunction(this.DayOfWeek), (VerbIdentifier)mappingFunction(this.AccessMode), (IntegerIdentifier)mappingFunction(this.Priority))); }
public void LoadOrCreateChunk(Vector3Int position, Block[] blocks, MappingFunction mappingFunction) { var pagePositionX = position.X / Page.PageSizeInBlocks; var pagePositionY = position.Y / Page.PageSizeInBlocks; var pagePositionZ = position.Z / Page.PageSizeInBlocks; var pageId = CreatePageId(pagePositionX, pagePositionY, pagePositionZ); if (m_pageCache.ContainsPage(pageId)) { var page = m_pageCache.GetPage(pageId); CopyPageToChunk(page, position, blocks, mappingFunction); } else if (m_directory.Pages.Contains(pageId)) { var page = DecompressPage(pageId); CopyPageToChunk(page, position, blocks, mappingFunction); m_pageCache.InsertPage(page); } else if (!m_pagesPendingWrite.Contains(pageId)) { m_pagesPendingWrite.Add(pageId); var page = new Page(position.X, position.Y, position.Z, pageId); var worldPosX = pagePositionX * Page.PageSizeInBlocks; var worldPosY = pagePositionY * Page.PageSizeInBlocks; var worldPosZ = pagePositionZ * Page.PageSizeInBlocks; TerrainGenerator.Instance.GenerateDataForChunk(worldPosX, worldPosY, worldPosZ, Page.PageSizeInBlocks, page.Data, (x, y, z) => Page.BlockIndexFromRelativePosition( x - worldPosX, y - worldPosY, z - worldPosZ)); //BlockDataUtilities.SetupScanDirectedHilbertCurve(Page.PageSizeInBlocks); // ChunkCompressor.GetHilbertCurve(32); var timer = Stopwatch.StartNew(); float compressionRatio; //ChunkCompressor.ScanDirection scanDir; var tree = ChunkCompressor.GetCompressor(Page.PageSizeInBlocks).ConvertArrayToIntervalTree(page.Data, out compressionRatio); Console.WriteLine("tree creation time: " + timer.ElapsedMilliseconds); // Console.WriteLine("h: " + scanDir); // Console.WriteLine("tree compresion ratio: " + compressionRatio); // timer.Restart(); // var tree2 = ChunkCompressor.ConvertArrayToIntervalTreeLinear(page.Data, Page.PageSizeInBlocks, // out compressionRatio, out scanDir); //Console.WriteLine("linear tree creation time: " + timer.ElapsedMilliseconds); // Console.WriteLine("l: " + scanDir); // Console.WriteLine("l: " + compressionRatio); // tree. timer.Restart(); var res = tree[new Interval(17490)]; Console.WriteLine("tree query time: " + timer.ElapsedMilliseconds); using (var fileStream = new FileStream(Path.Combine(m_dataDirectory, page.PageId + "_tree.page"), FileMode.Create)) { using (var compressor = new GZipStream(fileStream, CompressionLevel.Optimal)) { //Serializer.Serialize(compressor, tree); } } Console.WriteLine("tree compressionTime time: " + timer.ElapsedMilliseconds); timer.Restart(); CompressPage(page); Console.WriteLine("normal compressionTime time: " + timer.ElapsedMilliseconds); m_pageCache.InsertPage(page); m_directory.Pages.Add(pageId); CopyPageToChunk(page, position, blocks, mappingFunction); //m_jsonWriter.Write("SaveDirectory", m_directory); /* Task.Run(() => { CompressPage(page); m_pagesPendingWrite.Remove(page.PageId); });*/ } }
private static void CopyCunkToPage(Page page, Vector3Int position, Block[] blocks, MappingFunction mappingFunction) { var originX = MathUtilities.Modulo(position.X, Page.PageSizeInBlocks); var originY = MathUtilities.Modulo(position.Y, Page.PageSizeInBlocks); var originZ = MathUtilities.Modulo(position.Z, Page.PageSizeInBlocks); for (var x = originX; x < originX + Chunk.SizeInBlocks; x++) { for (var y = originY; y < originY + Chunk.SizeInBlocks; y++) { for (var z = originZ; z < originZ + Chunk.SizeInBlocks; z++) { page.Data[Page.BlockIndexFromRelativePosition(x, y, z)] = blocks[mappingFunction(position.X + x, position.Y + y, position.Z + z)]; } } } }
public void SaveChunk(Vector3Int position, Block[] blocks, MappingFunction mappingFunction, Action<bool> callback) { var pagePositionX = position.X >> 6; var pagePositionY = position.Y >> 6; var pagePositionZ = position.Z >> 6; var pageId = CreatePageId(pagePositionX, pagePositionY, pagePositionZ); if (m_pagesPendingWrite.Contains(pageId)) { if (callback != null) { callback(false); } } else { Page page; if (m_pageCache.ContainsPage(pageId)) { page = m_pageCache.GetPage(pageId); CopyCunkToPage(page, position, blocks, mappingFunction); } else if (m_directory.Pages.Contains(pageId)) { page = DecompressPage(pageId); CopyCunkToPage(page, position, blocks, mappingFunction); m_pageCache.InsertPage(page); } else { page = new Page(position.X, position.Y, position.Z, pageId); for (var x = 0; x < Page.PageSizeInBlocks; x++) { for (var y = 0; y < Page.PageSizeInBlocks; y++) { for (var z = 0; z < Page.PageSizeInBlocks; z++) { page.Data[Page.BlockIndexFromRelativePosition(x, y, z)] = blocks[mappingFunction(position.X + x, position.Y + y, position.Z + z)]; } } } m_pageCache.InsertPage(page); m_directory.Pages.Add(pageId); // m_jsonWriter.Write("SaveDirectory", m_directory); } m_pagesPendingWrite.Add(pageId); Task.Run(() => { CompressPage(page); if (callback != null) { callback(true); } m_pagesPendingWrite.Remove(page.PageId); }); } }
public void GenerateDataForChunk(int chunkX, int chunkY, int chunkZ, int chunkSize, Block[] blocks, MappingFunction mappingFunction) { for (var x = 0; x < chunkSize; ++x) { var cX = chunkX + x; for (var z = 0; z < chunkSize; ++z) { var cZ = chunkZ + z; var groundLevel = GetHeight(cX, cZ); var detailNoise = m_detail2.FractalBrownianMotion(cX, cZ, 64, 0, 8); var overhangStart = m_sealevel + MathHelper.Clamp(detailNoise * 4, -1, 1) * 2; var biome = m_biomeGenerator.GetRegionGenerator(cX, cZ); var province = m_provinceGenerator.GetRegionGenerator(cX, cZ); var data = m_populator.CalculateNearestSamplePosition(cX, cZ); /*var color = (ushort)data.Id;*/ var riverData = m_riverGenerator.GetRiverData(cX, cZ); if (riverData != null) { /* if (groundLevel < riverData.Position.Y) { Console.Out.WriteLine(x + ", " + z + ": " + (riverData.Position.Y - groundLevel)); }*/ groundLevel = riverData.Position.Y; } for (var y = chunkSize - 1; y >= 0 ; --y) { var cY = chunkY + y; Block block; if (cY > groundLevel + 10) { block = new Block(Block.None) {LightSun = CellularLighting<Block>.MaxSun}; } else if (cY > groundLevel) { block = new Block(Block.None) { LightSun = CellularLighting<Block>.MinLight }; } else if (cY >= groundLevel - m_biomeThickness) { if (cY > overhangStart) { var density = (MathHelper.Clamp(m_volume.FractalBrownianMotion(cX, cY, cZ, 64, 0, 4)*3, -1, 1) + 1)*0.5f; block = density > 0.125 ? biome.Apply((int) groundLevel, cX, cY, cZ) : Block.Empty; } else { block = biome.Apply((int) groundLevel, cX, cY, cZ); } } else { block = province.Apply((int)groundLevel - m_biomeThickness, cX, cY, cZ); } // var tint = (int) ((detailNoise * 5 + 10)); // block.Color = (ushort)((tint << 8) | (tint << 4) | tint); if (riverData != null && cY <= groundLevel && cY >= groundLevel - 1) { block = new Block(BlockDictionary.Instance.GetBlockIdForName("Water")); } blocks[mappingFunction(cX, cY, cZ)] = block; } for (var y = 0; y < chunkSize && chunkY + y < m_sealevel; ++y) { var cY = chunkY + y; var blockIndex = mappingFunction(cX, cY, cZ); if (!blocks[blockIndex].Exists) blocks[blockIndex] = new Block(BlockDictionary.Instance.GetBlockIdForName("Water")); } //TODO : redesign populator to be compatible with page loading /* if (Math.Abs(data.Delta.X - cX) < 0.01 && Math.Abs(data.Delta.Y - cZ) < 0.01) { m_populator.PopulateTree(cX, cZ, (int)groundLevel, blocks, mappingFunction); }*/ } } //TODO : query if chunk has all neighbors loaded so we can run our erosion step //TODO : after eroding generate structures }
public Chunk(Vector3Int chunkCachePosition, Block[] blocks, MappingFunction mappingFunction, GetNeighborChunk getNeighborChunk) { ChunkState = ChunkState.AwaitingGenerate; // set initial state to awaiting generation. ChunkCachePosition = chunkCachePosition; // set the relative position. m_blocks = blocks; m_mappingFunction = mappingFunction; m_getNeighborChunk = getNeighborChunk; // calculate the real world position. Position = new Vector3Int(ChunkCachePosition.X * SizeInBlocks, ChunkCachePosition.Y * SizeInBlocks, ChunkCachePosition.Z * SizeInBlocks); // calculate bounding-box. BoundingBox = new BoundingBox(new Vector3(Position.X, Position.Y, Position.Z), new Vector3(Position.X + SizeInBlocks, Position.Y + SizeInBlocks, Position.Z + SizeInBlocks)); #if DEBUG MainEngine.GetEngineInstance().DebugOnlyDebugManager.RegisterInGameDebuggable(this); #endif }
/// <summary> /// Apply a SyntaxElement.MappingFunction to the syntax tree. /// </summary> /// <param name="mappingFunction">An aribtrary mapping function to be applied to the syntax tree.</param> /// <returns>A new object of the enclosing type with the mapping function applied.</returns> public override SyntaxElement ApplyMappingFunction(MappingFunction mappingFunction) { return(new UserGroupMembershipFact( (PrincipalIdentifier)mappingFunction(this.User), (PrincipalIdentifier)mappingFunction(this.Group))); }
/// <summary> /// Apply a SyntaxElement.MappingFunction to the syntax tree. /// </summary> /// <param name="mappingFunction">An aribtrary mapping function to be applied to the syntax tree.</param> /// <returns>A new object of the enclosing type with the mapping function applied.</returns> public override SyntaxElement ApplyMappingFunction(MappingFunction mappingFunction) { return new UserGroupMembershipFact( (PrincipalIdentifier)mappingFunction(this.User), (PrincipalIdentifier)mappingFunction(this.Group)); }
/// <summary> /// Apply a SyntaxElement.MappingFunction to the syntax tree. /// </summary> /// <param name="mappingFunction">An aribtrary mapping function to be applied to the syntax tree.</param> /// <returns>A new object of the enclosing type with the mapping function applied.</returns> public override SyntaxElement ApplyMappingFunction(MappingFunction mappingFunction) { return new ResourceAccessFact( (PrincipalIdentifier)mappingFunction(this.Resource), (PrincipalIdentifier)mappingFunction(this.Module), (PrincipalIdentifier)mappingFunction(this.Group), (IntegerIdentifier)mappingFunction(this.From), (IntegerIdentifier)mappingFunction(this.To), (IntegerIdentifier)mappingFunction(this.DayOfWeek), (VerbIdentifier)mappingFunction(this.AccessMode), (IntegerIdentifier)mappingFunction(this.Priority)); }