private void runCollisions() { for (double movement = Math.Sqrt(ball.vel.X * ball.vel.X + ball.vel.Y * ball.vel.Y); movement > 0; movement -= PADDLEHEIGHT) { ball.limitedMove(PADDLEHEIGHT); if (ball.loc.Y > screenHeight - Ball.BALL_RADIUS) { ball = newBall(screenWidth, screenHeight); paddle = newPaddle(screenWidth, screenHeight); gameState.lives = gameState.lives - 1; if (gameState.lives < 0) { resetGame(); return; } } ball.collideOutside(paddle.getCollisionBox()); List <Block> removals = new List <Block>(); foreach (Block block in blocks) { if (ball.collideOutside(block.getCollisionBox()) && block.isDestroyable) { removals.Add(block); gameState.score = gameState.score + POINTS_PER_BLOCK; paddle = new Block((int)(paddle.width * .99), paddle.height, paddle.loc, paddle.isDestroyable); } } blocks.RemoveAll(i => removals.Contains(i)); if (blocks.Count == 0) { blocks = BlockLayer.randomBlocks(screenWidth, screenHeight); } ball.collideInside(new Rect(0, 0, screenWidth, screenHeight)); } }
public void InitOverlay( IDictionary <XBlock, BoolSimulation> simulations, IBoolSimulationRenderer cacheRenderer) { SelectionReset(); OverlayLayer.EnableSimulationCache = true; OverlayLayer.CacheRenderer = null; foreach (var simulation in simulations) { BlockLayer.Hidden.Add(simulation.Key); OverlayLayer.Shapes.Add(simulation.Key); } EditorLayer.Simulations = simulations; OverlayLayer.Simulations = simulations; OverlayLayer.CacheRenderer = cacheRenderer; cacheRenderer.Renderer = OverlayLayer.Renderer; cacheRenderer.NullStateStyle = OverlayLayer.NullStateStyle; cacheRenderer.TrueStateStyle = OverlayLayer.TrueStateStyle; cacheRenderer.FalseStateStyle = OverlayLayer.FalseStateStyle; cacheRenderer.Shapes = OverlayLayer.Shapes; cacheRenderer.Simulations = OverlayLayer.Simulations; BlockLayer.InvalidateVisual(); OverlayLayer.InvalidateVisual(); }
void update() { Node generator = (Node)GetParent().Get("generator_node"); List <Vector2> renderChunks = get_render_chunks(); foreach (Vector2 chunkPos in renderChunks) { if (oldRenderChunks.Contains(chunkPos)) { oldRenderChunks.Remove(chunkPos); continue; } if (!chunks.ContainsKey(chunkPos)) { generateChunk(chunkPos, generator); } update_chunk(chunkPos); } foreach (Vector2 chunk in oldRenderChunks) { for (int z = 0; z < layer_nodes.Count; z++) { BlockLayer layer = (BlockLayer)layer_nodes[z]; layer.clear_chunk(new Rect2(chunk * chunk_size, chunk_size)); } } oldRenderChunks = renderChunks; }
public void InvalidateLayers() { if (ShapeLayer.InvalidateVisual != null) { ShapeLayer.InvalidateVisual(); } if (BlockLayer.InvalidateVisual != null) { BlockLayer.InvalidateVisual(); } if (PinLayer.InvalidateVisual != null) { PinLayer.InvalidateVisual(); } if (WireLayer.InvalidateVisual != null) { WireLayer.InvalidateVisual(); } if (OverlayLayer.InvalidateVisual != null) { OverlayLayer.InvalidateVisual(); } }
public void ReadFlatOption() { if (!string.IsNullOrEmpty(this.FlatOptionsString)) { try { this.flatOption = new FlatOptions(); string[] args = this.FlatOptionsString.Split(';'); if (args.Length > 1) { this.flatOption.version = int.Parse(args[0]); string[] layerData = args[1].Split(',');//support format <2*1:0> or <minecraft:stone:1> BlockLayers layers = this.flatOption.blockLayers = new BlockLayers(); for (int i = 0; i < layerData.Length; ++i) { string[] blockData = layerData[i].Split('*'); if (blockData.Length == 2) { int layerCount = int.Parse(blockData[0]); BlockLayer layer = new BlockLayer(); layer.block = Block.Get(blockData[1]); layer.height = layerCount; layers.layers.Add(layer); } else if (blockData.Length == 1) { BlockLayer layer = new BlockLayer(); layer.block = Block.Get(blockData[0]); layer.height = 1; layers.layers.Add(layer); } else { continue; } } if (layers.layers.Count == 0) { Logger.Notice("FlatOptions Error"); this.flatOption = null; } } else { Logger.Notice("FlatOptions Error"); this.flatOption = null; } } catch (Exception e) { Logger.Error(e); Logger.Notice("FlatOptions Error"); this.flatOption = null; } } }
// --- TileMap --- public void update_chunk(Vector2 chunkPos) { for (int z = 0; z < layer_nodes.Count; z++) { BlockLayer layer = (BlockLayer)layer_nodes[z]; Rect2 chunk = new Rect2(chunkPos * chunk_size, chunk_size); layer.update_chunk(chunk, chunks[chunkPos], z); } }
public override void GenerationBasicTerrain(Chunk chunk) { if (this.flatOption != null) { BlockLayers layers = this.flatOption.blockLayers; for (int i = 0; i < 16; ++i) //X { for (int j = 0; j < 16; ++j) //Z { int y = 0; for (int c = 0; c < layers.layers.Count; ++c) { BlockLayer layer = layers.layers[c]; for (int k = 0; k < layer.height; ++k)//Y { if (World.MAX_HEIGHT == y) { Logger.Warn("World MaxHeight 256"); break; } chunk.SetBlock(i, y, j, (byte)layer.block.ID); chunk.SetMetadata(i, y, j, (byte)layer.block.Damage); chunk.SetBiome(i, j, BiomeIDs.Plains); y++; } } } } } else { SubChunk flat = new SubChunk(); for (int i = 0; i < 16; ++i) //X { for (int j = 0; j < 16; ++j) //Z { for (int k = 0; k < 16; ++k) //Y { if (k == 0) { flat.SetBlock(i, k, j, 7); } else if (k == 1 || k == 2) { flat.SetBlock(i, k, j, 3); } else if (k == 3) { flat.SetBlock(i, k, j, 2); } } } } chunk.SubChunks[0] = flat; } }
void OnGUI() { obj = (BlockLayer)EditorGUI.ObjectField(new Rect(3, 6, position.width - 6, 20), "Layer", obj, typeof(BlockLayer), true); if (obj != null) { selectedTileX = EditorGUI.IntField(new Rect(3, 26, position.width - 6, 20), "Selected Tile X", obj.selectedX); selectedTileY = EditorGUI.IntField(new Rect(3, 46, position.width - 6, 20), "Selected Tile Y", obj.selectedY); EditorGUI.LabelField(new Rect(3, 66, position.width - 6, 20), "Initial X: " + obj.initX); EditorGUI.LabelField(new Rect(3, 86, position.width - 6, 20), "Initial Y: " + obj.initY); EditorGUI.LabelField(new Rect(3, 106, position.width - 6, 20), "Final X: " + obj.endX); EditorGUI.LabelField(new Rect(3, 126, position.width - 6, 20), "Final Y: " + obj.endY); if (selectedTileX >= 0 && selectedTileX < obj.width && selectedTileY >= 0 && selectedTileY < obj.height) { if (obj.map == null) { obj.map = new int[obj.width * obj.height]; for (int i = 0; i < obj.width; i++) { for (int j = 0; j < obj.height; j++) { obj.map[i + (obj.width * j)] = -1; } } } if (obj.state == 2) { int maxX = Mathf.Max(obj.initX, obj.endX); int maxY = Mathf.Max(obj.initY, obj.endY); string[] blocksTypes = new string[BlockLayer.AllBlocks.Length + 1]; blocksTypes[0] = "Empty Block"; for (int i = 1; i < blocksTypes.Length; i++) { blocksTypes[i] = BlockLayer.AllBlocks[i - 1].BlockName; } lastBlock = EditorGUI.Popup(new Rect(3, 186, 300, 20), lastBlock, blocksTypes); for (int i = Mathf.Min(obj.initX, obj.endX); i <= maxX; i++) { for (int j = Mathf.Min(obj.initY, obj.endY); j <= maxY; j++) { obj.map[i + (obj.width * j)] = lastBlock - 1; } } } } } }
private void resetGame() { gameState = new GameState { score = 0, lives = START_LIVES }; blocks = BlockLayer.randomBlocks(screenWidth, screenHeight); }
public void ResetOverlay() { EditorLayer.Simulations = null; OverlayLayer.Simulations = null; OverlayLayer.CacheRenderer = null; BlockLayer.Hidden.Clear(); OverlayLayer.Shapes.Clear(); BlockLayer.InvalidateVisual(); OverlayLayer.InvalidateVisual(); }
public void update_visible_chunks(int z) { List <Vector2> render_chunks = get_render_chunks(); foreach (Vector2 chunkPos in render_chunks) { BlockLayer layer = (BlockLayer)layer_nodes[z]; Rect2 chunk = new Rect2(chunkPos * chunk_size, chunk_size); if (!chunks.ContainsKey(chunkPos)) { continue; } layer.update_chunk(chunk, chunks[chunkPos], z); } }
private bool isAppropriateClimateToGrow(IWorldAccessor world, BlockPos pos, AssetLocation blockCode, ClimateCondition climate) { ICoreServerAPI api = (ICoreServerAPI)world.Api; int mapheight = api.WorldManager.MapSizeY; BlockLayers layers = getBlockLayers(world); BlockLayer bl = layers.GetBlockLayerForNextGrowthStage(world, blockCode); //Check climate conditions to see whether the soil can grow to the next stage return( climate.Temperature >= bl.MinTemp && climate.Temperature <= bl.MaxTemp && climate.Rainfall >= bl.MinRain && climate.Rainfall <= bl.MaxRain && climate.Fertility >= bl.MinFertility && climate.Fertility <= bl.MaxFertility && (float)pos.Y / mapheight <= bl.MaxY ); }
/// <summary> /// Builds the mesh using 4 vertices and 2 triangles per face /// </summary> private void BuildMesh(Chunk chunk, BlockLayer layer) { //get this chunks mesh buffer MeshBuffer buffer = chunk.GetMeshBuffer(layer); // Request the lock, and block until it is obtained. Monitor.Enter(buffer); //clear the mesh buffer to store our vertices and triangles buffer.Clear(); for (int x=0; x<chunk.width; x++) { for (int y=0; y<chunk.height; y++) { for (int z=0; z<chunk.length; z++) { if (chunk[x,y,z] != BlockType.AIR) { if (x + chunk.x == 0 || chunk[x-1, y, z] == BlockType.AIR) buffer.AddFace(FACE.LEFT, x,y,z, chunk[x,y,z]); if (x + chunk.x == chunk.world.width-1 || chunk[x+1, y, z] == BlockType.AIR) buffer.AddFace(FACE.RIGHT, x,y,z, chunk[x,y,z]); if (y + chunk.y == 0 || chunk[x, y-1, z] == BlockType.AIR) buffer.AddFace(FACE.BOTTOM, x,y,z, chunk[x,y,z]); if (y + chunk.y == chunk.world.height-1 || chunk[x, y+1, z] == BlockType.AIR) buffer.AddFace(FACE.TOP, x,y,z, chunk[x,y,z]); if (z + chunk.z == 0 || chunk[x, y, z-1] == BlockType.AIR) buffer.AddFace(FACE.FRONT, x,y,z, chunk[x,y,z]); if (z + chunk.z == chunk.world.length-1 || chunk[x, y, z+1] == BlockType.AIR) buffer.AddFace(FACE.BACK, x,y,z, chunk[x,y,z]); } } } } // make sure the chunk knows to assign the mesh data buffer.SetGenerated(); // Ensure that the lock is released. Monitor.Exit(buffer); }
public async override void _Ready() { layer = GetParentOrNull <BlockLayer>(); if (layer == null) { GD.PushError("BlockFluid node [" + Name + "] is not a child of BlockLayer."); } await ToSignal(layer.GetParent(), "finished_setup"); data_node = (BlockData)(layer.GetParent().Get("data_node")); ThreadStart threadStart = new ThreadStart(SimThread); thread = new System.Threading.Thread(threadStart); thread.Start(); }
protected int getClimateSuitedGrowthStage(IWorldAccessor world, BlockPos pos, ClimateCondition climate) { if (climate == null) { return(CurrentStage()); // Can occasionally be null, e.g. during running /wgen regen command } ICoreServerAPI api = (ICoreServerAPI)world.Api; int mapheight = api.WorldManager.MapSizeY; float transitionSize = blocklayerconfig.blockLayerTransitionSize; for (int j = 0; j < blocklayerconfig.Blocklayers.Length; j++) { BlockLayer bl = blocklayerconfig.Blocklayers[j]; float tempDist = Math.Abs(climate.Temperature - GameMath.Clamp(climate.Temperature, bl.MinTemp, bl.MaxTemp)); float rainDist = Math.Abs(climate.WorldgenRainfall - GameMath.Clamp(climate.WorldgenRainfall, bl.MinRain, bl.MaxRain)); float fertDist = Math.Abs(climate.Fertility - GameMath.Clamp(climate.Fertility, bl.MinFertility, bl.MaxFertility)); float yDist = Math.Abs((float)pos.Y / mapheight - GameMath.Min((float)pos.Y / mapheight, bl.MaxY)); double posRand = (double)GameMath.MurmurHash3(pos.X, 1, pos.Z) / int.MaxValue; posRand = (posRand + 1) * transitionSize; if (tempDist + rainDist + fertDist + yDist <= posRand) { IMapChunk mapchunk = world.BlockAccessor.GetMapChunkAtBlockPos(pos); if (mapchunk == null) { return(0); } int topblockid = mapchunk.TopRockIdMap[(pos.Z % chunksize) * chunksize + (pos.X % chunksize)]; int blockId = bl.GetBlockId(posRand, climate.Temperature, climate.WorldgenRainfall, climate.Fertility, topblockid); Block block = world.Blocks[blockId]; if (block is BlockSoil) { return((block as BlockSoil).CurrentStage()); } } } return(0); }
private void InitBlockLayers(IWorldAccessor world, BlockLayer parentBlockLayer) { foreach (BlockLayerCodeByMin blockLayerCodeByMin in parentBlockLayer.BlockCodeByMin) { BlockLayer layer = new BlockLayer { MinFertility = blockLayerCodeByMin.MinFertility, MaxFertility = blockLayerCodeByMin.MaxFertility, MinRain = blockLayerCodeByMin.MinRain, MaxRain = parentBlockLayer.MaxRain, MinTemp = (int)blockLayerCodeByMin.MinTemp, MaxTemp = parentBlockLayer.MaxTemp, MaxY = blockLayerCodeByMin.MaxY, BlockCode = blockLayerCodeByMin.BlockCode }; layers.Add(blockLayerCodeByMin.BlockCode, layer); } }
public override void _Ready() { layer_nodes.Clear(); uint i = 0; foreach (Node node in GetParent().GetChildren()) { string name = node.Name; BlockLayer child = GetParent().GetNodeOrNull <BlockLayer>(name); if (child != null) { layer_nodes.Add(child); child.Id = i; } i++; } update(); }
public override void _Process(float delta) { if (Engine.EditorHint) { layer_nodes.Clear(); uint i = 0; foreach (Node node in GetParent().GetChildren()) { string name = node.Name; BlockLayer child = GetParent().GetNodeOrNull <BlockLayer>(name); if (child != null) { layer_nodes.Add(child); child.Id = i; } i++; } } update(); }
//make capcom screen image public Bitmap makeScreen(int scrNo, int levelNo, int videoNo, int bigBlockNo, int blockNo, int palleteNo, bool withBorders = true) { if (scrNo < 0) { return(VideoHelper.emptyScreen((int)(ConfigScript.getScreenWidth(levelNo) * 32), (int)(ConfigScript.getScreenHeight(levelNo) * 32))); } var bigBlocks = makeBigBlocks(videoNo, bigBlockNo, blockNo, palleteNo, MapViewType.Tiles, MapViewType.Tiles); //var bigBlocks = makeBigBlocks(videoNo, bigBlockNo, blockNo, palleteNo, MapViewType.ObjType,MapViewType.Tiles, withBorders); int[] indexes = Globals.getScreen(ConfigScript.screensOffset[levelNo], scrNo); int scrW = ConfigScript.getScreenWidth(0); //zero as screenNoForLevel int scrH = ConfigScript.getScreenHeight(0); //capcom hardcode var blockLayer1 = new BlockLayer() { screens = new int[1][] { indexes }, showLayer = true, blockWidth = 32, blockHeight = 32 }; return(new Bitmap(MapEditor.ScreenToImage(bigBlocks, new BlockLayer[] { blockLayer1 }, 0, 2.0f, false, 0, 0, scrW, scrH))); }
public void CustomizePrefab(GameObject prefab) { prefab.AddComponent <BlockLayer>(); l = prefab.GetComponent <BlockLayer>(); TiledMap tm = prefab.GetComponent <TiledMap>(); BlockLayer.BlockSize = tm.TileHeight; l.width = tm.NumTilesWide; l.height = tm.NumTilesHigh; l.map = new int[l.width * l.height]; for (int i = 0; i < l.width; i++) { for (int j = 0; j < l.height; j++) { l.map[i + (l.width * j)] = -1; } } }
// condition for when we should draw a face // the block is not rendered OR its a transparent block from another render layer private static bool ShouldDrawFace(BlockType type, BlockLayer layer) { return !Block.IsRendered(type) || (!Block.IsOpaque(type) && Block.RenderLayer(type) != layer); }
public void Build(List<Chunk> chunks, BlockLayer layer, Action<Chunk> completion) { //process each chunk seperately _processor.Spawn(chunks, BuildMesh, layer, false, completion); }
public override void Left(MobileObject target, Transform contactPoint, int x, int y, BlockLayer l) { if (target.XSpeed - l.XSpeed <= 0) { return; } float bx = GetX(x, l); float cx = contactPoint.position.x; float dx = cx - bx; target.X -= dx; target.BlockedFromRight = true; target.XSpeed = 0; }
public override void Right(MobileObject target, Transform contactPoint, int x, int y, BlockLayer l) { if (target.XSpeed - l.XSpeed >= 0) { return; } float bx = GetX(x, l); float cx = contactPoint.position.x; float dx = bx + BlockLayer.BlockSize - cx; target.X += dx; target.BlockedFromLeft = true; target.XSpeed = 0; }
public BlockLayers(IWorldAccessor world, string blockLayerId) { blockLayerConfig = BlockLayerConfig.GetInstance((ICoreServerAPI)world.Api); blockLayer = blockLayerConfig.GetBlockLayerById(world, blockLayerId); InitBlockLayers(world, blockLayer); }
public override void Up(MobileObject target, Transform contactPoint, int x, int y, BlockLayer l) { if (target.YSpeed - l.YSpeed >= 0) { return; } float by = GetY(y, l); float cy = contactPoint.position.y; float dy = cy - (by + BlockLayer.BlockSize); target.BlockedFromBelow = true; if (!target.BlockedAngleDetector) { target.Y -= dy; } }
public override void Right(MobileObject target, Transform contactPoint, int x, int y, BlockLayer l) { if (angle <= 0 && target.XSpeed >= 0) { return; } if (angle >= 0 && target.XSpeed <= 0) { return; } float by = GetY(y, l); float contactY = contactPoint.position.y; if (contactY < by + y2) { base.Right(target, contactPoint, x, y, l); } }
public override void Down(MobileObject target, Transform contactPoint, int x, int y, BlockLayer l) { if (angle != 0) { return; } base.Down(target, contactPoint, x, y, l); }
public void SetMeshBuffer(BlockLayer layer, MeshBuffer buffer) { _meshBuffers[(int)layer] = buffer; }
public override void Up(MobileObject target, Transform contactPoint, int x, int y, BlockLayer l) { float ny = GetY(y, l) + BlockLayer.BlockSize; int b = l.getBlock(contactPoint.position.x, ny); if (b >= 0) { BlockLayer.AllBlocks[b].Up(target, contactPoint, x, l.getYPos(ny), l); } }
private void LoadBlockLayers(double posRand, float rainRel, float temperature, int unscaledTemp, int posY, int firstBlockId) { float heightRel = ((float)posY - TerraGenConfig.seaLevel) / ((float)api.WorldManager.MapSizeY - TerraGenConfig.seaLevel); float fertilityRel = TerraGenConfig.GetFertilityFromUnscaledTemp((int)(rainRel * 255), unscaledTemp, heightRel) / 255f; float depthf = TerraGenConfig.SoilThickness(rainRel, temperature, posY - TerraGenConfig.seaLevel, 1f); int depth = (int)depthf; depth += (int)((depthf - depth) * rnd.NextDouble()); BlockLayersIds.Clear(); for (int j = 0; j < blockLayerConfig.Blocklayers.Length; j++) { BlockLayer bl = blockLayerConfig.Blocklayers[j]; float tempDist = Math.Abs(temperature - GameMath.Clamp(temperature, bl.MinTemp, bl.MaxTemp)); float rainDist = Math.Abs(rainRel - GameMath.Clamp(rainRel, bl.MinRain, bl.MaxRain)); float fertDist = Math.Abs(fertilityRel - GameMath.Clamp(fertilityRel, bl.MinFertility, bl.MaxFertility)); float yDist = Math.Abs((float)posY / mapheight - GameMath.Min((float)posY / mapheight, bl.MaxY)); if (tempDist + rainDist + fertDist + yDist <= posRand) { int blockId = bl.GetBlockId(posRand, temperature, rainRel, fertilityRel, firstBlockId); if (blockId != 0) { BlockLayersIds.Add(blockId); // Would be correct, but doesn't seem to cause noticable problems // so lets not add it for faster chunk gen posY--; temperature = TerraGenConfig.GetScaledAdjustedTemperatureFloat(unscaledTemp, posY - TerraGenConfig.seaLevel); // rainRel = TerraGenConfig.GetRainFall(unscaledRain, posY) / 255f; heightRel = ((float)posY - TerraGenConfig.seaLevel) / ((float)api.WorldManager.MapSizeY - TerraGenConfig.seaLevel); fertilityRel = TerraGenConfig.GetFertilityFromUnscaledTemp((int)(rainRel * 255), unscaledTemp, heightRel) / 255f; } } if (BlockLayersIds.Count >= depth) { break; } } layersUnderWater = null; for (int j = 0; j < blockLayerConfig.LakeBedLayer.BlockCodeByMin.Length; j++) { LakeBedBlockCodeByMin lbbc = blockLayerConfig.LakeBedLayer.BlockCodeByMin[j]; if (lbbc.Suitable(temperature, rainRel, (float)posY / api.WorldManager.MapSizeY, rnd)) { layersUnderWater = new int[] { lbbc.GetBlockForMotherRock(firstBlockId) }; break; } } if (layersUnderWater == null) { layersUnderWater = new int[0]; } }
public override void Right(MobileObject target, Transform contactPoint, int x, int y, BlockLayer l) { float nx = GetY(x, l) + BlockLayer.BlockSize; int b = l.getBlock(nx, contactPoint.position.y); if (b >= 0) { BlockLayer.AllBlocks[b].AngleDetector(target, contactPoint, l.getXPos(nx), y, l); } }
public override void Up(MobileObject target, Transform contactPoint, int x, int y, BlockLayer l) { if (target.BlockedAngleDetector) { return; } float contactX = contactPoint.position.x; float contactY = contactPoint.position.y; float bx = GetX(x, l); float by = GetY(y, l); if (contactX < bx + x1) { if (contactY <= by + y1) { base.Up(target, contactPoint, x, y, l); } } else if (contactX > bx + x2) { if (contactY <= by + y2) { base.AngleDetector(target, contactPoint, x, y, l); } } }
public override void AngleDetector(MobileObject target, Transform contactPoint, int x, int y, BlockLayer l) { float contactX = contactPoint.position.x; float contactY = contactPoint.position.y; float bx = GetX(x, l); float by = GetY(y, l); if (contactX < bx + x1) { if (contactY <= by + y1) { base.AngleDetector(target, contactPoint, x, y, l); } } else if (contactX > bx + x2) { if (contactY <= by + y2) { base.AngleDetector(target, contactPoint, x, y, l); } } else { float dy = m * (contactX - (bx + x1)) + (by + y1) - contactY; if (dy > 0 || target.GuidedByTerrain) { target.Y += dy; target.BlockedAngleDetector = true; target.TerrainAngle = angle; target.BlockedFromBelow = true; } } }
public MeshBuffer GetMeshBuffer(BlockLayer layer) { return _meshBuffers[(int)layer]; }