public static TileDefinition SetTileItem(TileDefinition tileDefinition, TileBase item, int index) { TileDefinition def = tileDefinition; if (index == 0) { def.plenum = (Plenum)item; } else if (index == 1) { def.turf = (Turf)item; } // We are a fixture else if (index > 1 && index < (2 + TileDefinition.GetAllFixtureLayerSize())) { def.fixtures.SetFixtureAtIndex((Fixture)item, index - 2); } else { Debug.LogWarning("Out of range tile item was tried to be set"); } return(def); }
public TileModel(Guid tileIid, TileDefinition def) { id = tileIid; title = def.Title; wide = def.IsWide; url = def.Url; }
public TileDefinition[,] Load() { var doc = XDocument.Parse(_Xml); var tiles = new List <(Position pos, TileDefinition definition)>(); foreach (var tile in doc.Root.Elements()) { var objectElem = tile.Element("Object"); var objectType = objectElem == null ? MapObjectType.None : ParseEnum <MapObjectType>(objectElem.Value); tiles.Add((ExtractPosition(tile), new TileDefinition(ParseEnum <GroundType>(tile.Element("Ground").Value), objectType))); } var mapWidth = tiles.Max(t => t.pos.X) + 1; var mapHeight = tiles.Max(t => t.pos.Y) + 1; var tilesArray = new TileDefinition[mapWidth, mapHeight]; foreach (var tile in tiles) { tilesArray[tile.pos.X, tile.pos.Y] = tile.definition; } return(tilesArray); }
/** * Adjusts the connections value based on the given new tile. * Returns whether value changed. */ private bool UpdateSingleConnection(Direction direction, TileDefinition tile) { int index = LayerIndex; if (index == 0) { index = 17; // Hardcoded to the Fixture layer until I got a better solution for this. Is needed to make Airlocks connect to walls } bool isGeneric = (tile.turf && (tile.turf.genericType == genericType || genericType == null)); if (tile.fixtures != null) { isGeneric = isGeneric || (tile.fixtures.GetFixtureAtLayerIndex(index) && (tile.fixtures.GetFixtureAtLayerIndex(index).genericType == genericType || genericType == null)); } bool isSpecific = (tile.turf && (tile.turf.id == id || id == null)); if (tile.fixtures != null) { isSpecific = isSpecific || (tile.fixtures.GetFixtureAtLayerIndex(LayerIndex) && (tile.fixtures.GetFixtureAtLayerIndex(LayerIndex).id == id || id == null)); } bool changed = generalAdjacents.UpdateDirection(direction, isGeneric, true); changed |= specificAdjacents.UpdateDirection(direction, isSpecific, true); return(changed); }
private TileDefinition[] ParseTileDefinitions(XmlElement tilesDefinitionsXML) { List <TileDefinition> tiles = new List <TileDefinition>(); TileDefinition emptyTile = new TileDefinition(); emptyTile.tileType = TileDefinition.EMPTY_TILE_TYPE; emptyTile.castShadow = false; emptyTile.description = "Empty"; emptyTile.drawMode = TileDefinition.DrawMode.NONE; emptyTile.energy = 0; emptyTile.id = "empty"; //emptyTile.liquid = false; emptyTile.materials = null; emptyTile.solid = false; tiles.Add(emptyTile); byte tileId = 1; foreach (XmlElement tileDefinitionXML in GetChildElements(tilesDefinitionsXML)) { tiles.Add(ParseTileDefinition(tileId++, tileDefinitionXML)); } return(tiles.ToArray()); }
/** * When a single adjacent turf is updated */ public void UpdateSingle(Direction direction, TileDefinition tile) { if (UpdateSingleConnection(direction, tile)) { UpdateMeshAndDirection(); } }
private int Step() { s_StepPerfMarker.Begin(); int activeTiles = 0; bool overPressureEvent = false; // Step 1: Calculate flux foreach (AtmosObject tile in atmosTiles) { if (tile.GetState() == AtmosStates.Active) { tile.CalculateFlux(); } } // Step 2: Simulate foreach (TileObject tile in tileObjects) { AtmosStates state = tile.atmos.GetState(); switch (state) { case AtmosStates.Active: tile.atmos.SimulateFlux(); activeTiles++; break; case AtmosStates.Semiactive: tile.atmos.SimulateFlux(); break; } // Step 3: Move items according to the wind velocity Vector2 velocity = tile.atmos.GetVelocity(); if (velocity != Vector2.zero) { MoveVelocity(tile); } // Step 4: Destroy tiles with to much pressure if (tile.atmos.CheckOverPressure() && !overPressureEvent) { TileDefinition oldDefinition = tile.Tile; if (oldDefinition.turf?.isWall == true) { oldDefinition.turf = floor; tileManager.UpdateTile(tile.transform.position, oldDefinition); tile.atmos.SetBlocked(false); overPressureEvent = true; } } } // Step 5: Do pumps and pipes as well StepDevices(); StepPipe(); s_StepPerfMarker.End(); return(activeTiles); }
public void Clear(int biomeID) { this.Entities.Clear(); this.GetToken("biome").Value = biomeID; this.GetToken("music").Text = BiomeData.Biomes[biomeID].Music; var ground = TileDefinition.Find(BiomeData.Biomes[biomeID].GroundTile, true); for (int row = 0; row < Height; row++) { for (int col = 0; col < Width; col++) { var def = ground; if (Random.Flip() && def.Variants.Tokens.Count > 0) { var chance = Random.NextDouble(); var variants = def.Variants.Tokens.Where(v => v.Value < chance).ToArray(); if (variants.Length > 0) { def = TileDefinition.Find(variants.PickOne().Name); } } SetTile(row, col, def); } } }
/** * When a single adjacent turf is updated */ public void UpdateSingle(Direction direction, TileDefinition tile) { if (UpdateSingleConnection(direction, tile)) { UpdateWallCaps(); } }
private void PaintTile() { Undo.RegisterFullObjectHierarchyUndo(Lvl, "Painted tile"); Vec2i tilePos = GameHelper.WorldToTilePos(GetMouseWorldPos() - (Vector2)Lvl.transform.position); //Debug.Log("[Level] PaintTile - tilePos: " + tilePos +", GetMouseWorldPos(): "+ GetMouseWorldPos()); //if (Lvl.tileType != TileType.Empty) { //TileDefinition tileDef = new TileDefinition { type = Lvl.tileType, goalColor = Lvl.tileGoalColor, color = (Lvl.tileType == TileType.Bucket ? Lvl.tileGoalColor : Lvl.tileColor), pos = tilePos }; TileDefinition tileDef = new TileDefinition { type = TileType.Normal, goalColor = TileColor.None, color = TileColor.None, pos = tilePos }; if (Lvl.Map.IsValidTile(tilePos)) { Undo.RecordObject(Lvl.Map.GetTile(tilePos), "Painted tile"); Lvl.Map.SetTile(tilePos, tileDef); } else { Lvl.CreateTileAtPos(tilePos, tileDef); Undo.RegisterCreatedObjectUndo(Lvl.Map.GetTile(tilePos).gameObject, "Painted tile"); } //} else { // Lvl.Map.DeleteTileAt(tilePos); //} current.Use(); }
public static void DeleteTileLayer(TileManager tileManager, int layerIndex, int x, int y) { if (tileManager.GetTile(x, y) == null) { return; } // Save old definition TileDefinition oldDefinition = tileManager.GetTile(x, y).Tile; // Copy object to avoid dupplication between editor and tilemap if (oldDefinition.fixtures != null) { FixturesContainer f = (FixturesContainer)oldDefinition.fixtures.Clone(); oldDefinition.fixtures = f; } // Existing tile found. We try to update the non-null items in the tiledefinition List <TileBase> tileBases = GetTileItems(oldDefinition); for (int i = 0; i < tileBases.ToArray().Length; i++) { if (tileBases[i] != null && i == layerIndex) { oldDefinition = SetTileItem(oldDefinition, null, i); } } Undo.RecordObject(tileManager.GetTile(x, y).gameObject, "Updated tile"); tileManager.EditorUpdateTile(x, y, oldDefinition); }
private void MaybeSet(ref Tile[,] map, int x, int y, string tileName) { if (map[x, y].Definition.Wall && !map[x, y].Definition.CanBurn) { map[x, y].Index = TileDefinition.Find(tileName).Index; } }
public void Add(TileDefinition tile) { Argument.Assert.IsNotNull(tile, "tile"); if (Compare.IsNullOrEmpty(tile.LayoutId)) { throw new PortalFatalException("Tiles require the 'LayoutId' property to be initialized before being added to a view."); } if (paneLookup == null) { paneLookup = new Dictionary <string, List <TileDefinition> >(); } List <TileDefinition> tileList = null; if (paneLookup.ContainsKey(tile.LayoutId)) { tileList = paneLookup[tile.LayoutId]; } if (tileList == null) { tileList = new List <TileDefinition>(); paneLookup.Add(tile.LayoutId, tileList); } tileList.Add(tile); }
public virtual bool ProcessTileDamage(TilePosition pos, Tile tile, TileDefinition tileDefinition, int damage) { if (tileDefinition.energy != Tile.MAX_ENERGY) { if (tile.Energy > damage) { world.tileManager.SetTileEnergy(pos, (byte)(tile.Energy - damage)); world.tileManager.TileDamaged(pos); return(false); } else { world.tileManager.DestroyTile(pos); return(true); } } else { //world.tileManager.DestroyTile(pos); //return true; return(false); } }
public override void Execute(TileManager tileManager, Tile tile, TilePosition pos) { TileDefinition tileDefinition = tileManager.GetTileDefinition(tile.tileType); ItemDefinition itemDefinition = tileManager.world.itemManager.GetItemDefinitionById(tileDefinition.id); tileManager.world.gameplay.CreateItem(itemDefinition, Graphics.TilePositionToVector3(pos)); }
public void SetupTile(TileDefinition tileDefinition) { _tileDefinition = tileDefinition; SpriteRenderer.sprite = tileDefinition.TileSprite; _board = transform.parent.GetComponent <Board>(); _particleSystem.startColor = _tileDefinition.EffectColor; }
public void UpdateMapSolidity() { if (ParentBoard == null) { return; } ParentBoard.Tilemap[XPosition, YPosition].Definition = TileDefinition.Find(closed ? "doorwayClosed" : "doorwayOpened"); }
protected override void StartDelayed(InteractionEvent interactionEvent) { var tileObject = interactionEvent.Target.GetComponent <TileObject>(); TileDefinition tile = tileObject.Tile; tile.turf = Turf; Object.FindObjectOfType <TileManager>().UpdateTile(tileObject.transform.position, tile); }
public void Set(TileDefinition def) { tileDef.color = def.color; tileDef.goalColor = def.goalColor; tileDef.type = def.type; tileDef.pos = def.pos; tileDef.paintedTurn = def.paintedTurn; Refresh(); }
public static List <TileBase> GetTileItems(TileDefinition tileDefinition) { List <TileBase> items = new List <TileBase>(); items.Add(tileDefinition.plenum); items.Add(tileDefinition.turf); items.AddRange(tileDefinition.fixtures.GetAllFixtures()); return(items); }
/** * Adjusts the connections value based on the given new tile. * Returns whether value changed. */ private bool UpdateSingleConnection(Direction direction, TileDefinition tile) { bool isConnected = (tile.turf && (tile.turf.genericType == type || type == null)); if (tile.fixtures != null) { isConnected = isConnected || (tile.fixtures.GetFixtureAtLayerIndex(LayerIndex) && (tile.fixtures.GetFixtureAtLayerIndex(LayerIndex).genericType == type || type == null)); } return(adjacents.UpdateDirection(direction, isConnected, true)); }
public void Load(System.IO.BinaryReader br) { entries.Clear(); int n = br.ReadInt32(); for (int i = 0; i < n; i++) { string id = br.ReadString(); int position = br.ReadInt32(); int quantity = br.ReadInt32(); TileDefinition tileDefinition = owner.world.tileManager.GetTileDefinitionById(id); CWObject cwobject = null; if (tileDefinition != null) { //It's a tile DynamicTile dynamicTile = new DynamicTile(owner.world, tileDefinition, -1); cwobject = dynamicTile; } else { ItemDefinition itemDefinition = owner.world.itemManager.GetItemDefinitionById(id); if (itemDefinition != null) { //It's an item Item item; if (itemDefinition.type == CubeWorld.World.Objects.CWDefinition.DefinitionType.ItemTile) { item = new ItemTile(owner.world, (ItemTileDefinition)itemDefinition, -1); } else { item = new Item(owner.world, itemDefinition, -1); } cwobject = item; } } cwobject.Load(br); InventoryEntry ie = new InventoryEntry(); ie.position = position; ie.quantity = quantity; ie.cwobject = cwobject; entries.Add(ie); } }
/** * Sets the tile at the given position * to the currently selected tile type. * * Will create the tile if one does not exist */ public static void SetTile(TileManager tileManager, TileDefinition tileDefinition, int x, int y) { if (tileManager.GetTile(x, y) == null) { tileManager.EditorCreateTile(x, y, tileDefinition); Undo.RegisterCreatedObjectUndo(tileManager.GetTile(x, y).gameObject, "Created tile"); } else { Undo.RecordObject(tileManager.GetTile(x, y).gameObject, "Updated tile"); tileManager.EditorUpdateTile(x, y, tileDefinition); } }
/** * Adjusts the connections value based on the given new tile. * Returns whether value changed. */ private bool UpdateSingleConnection(Direction direction, TileDefinition tile) { bool isGeneric = (tile.turf && (tile.turf.genericType == genericType || genericType == null)) || (tile.fixture && (tile.fixture.genericType == genericType || genericType == null)); bool isSpecific = (tile.turf && (tile.turf.id == id || id == null)) || (tile.fixture && (tile.fixture.id == id || id == null)); bool changed = generalAdjacents.UpdateDirection(direction, isGeneric, true); changed |= specificAdjacents.UpdateDirection(direction, isSpecific, true); return(changed); }
public void Setup(int distance, TileDefinition tileDefinition) { _tileDefinition = tileDefinition; _text = GetComponentInChildren <Text>(); _text.text = ObjectiveCount.ToString(); if (ObjectiveCount > 0) { transform.gameObject.SetActive(true); } }
/** * Adjusts the connections value based on the given new tile. * Returns whether value changed. */ private bool UpdateSingleConnection(Direction direction, TileDefinition tile) { int index = (int)Layer; bool isConnected = (tile.turf && (tile.turf.genericType == type || type == null)); if (tile.fixtures != null) { isConnected = isConnected || (tile.fixtures[index] && (tile.fixtures[index].genericType == type || type == null)); } return(adjacents.UpdateDirection(direction, isConnected, true)); }
public TileDragHandler(TileManager tileManager, TileDefinition tileDefinition, Vector2Int mousePosition) { this.tileManager = tileManager; this.tileDefinition = tileDefinition; startPosition = mousePosition; curPosition = mousePosition; var tile = CreateGhostTile(tileManager, tileDefinition, " [" + mousePosition.x.ToString() + ", " + mousePosition.y.ToString() + "]"); tile.transform.position = tileManager.GetPosition(mousePosition.x, mousePosition.y); dragTiles.Insert(0, tile); }
public static BiomeData FromToken(Token t, int realmNum) { var n = new BiomeData(); n.Realm = (Realms)realmNum; n.Name = t.Text; var cvars = t.GetToken("rect").Text.Split(' ').Select(i => int.Parse(i)).ToArray(); n.Rect = new System.Drawing.Rectangle(cvars[0], cvars[1], cvars[2] - cvars[0], cvars[3] - cvars[1]); n.GroundTile = (int)t.GetToken("ground").Value; if (n.GroundTile == 0) { n.GroundTile = TileDefinition.Find(t.GetToken("ground").Text, true).Index; } var encounters = t.GetToken("encounters"); if (encounters == null) { n.Encounters = new string[0]; } else { n.MaxEncounters = 10; if (encounters.Value > 0) { n.MaxEncounters = (int)encounters.Value; } n.Encounters = encounters.Tokens.Select(x => x.Name).ToArray(); } var cultures = t.GetToken("cultures"); if (cultures == null) { n.Cultures = new[] { "human" } } ; else { n.Cultures = cultures.Tokens.Select(x => x.Name).Where(e => Culture.Cultures.ContainsKey(e)).ToArray(); } if (t.HasToken("music")) { n.Music = t.GetToken("music").Text; } return(n); }
public void CreateTileAtPos(Vec2i pos, TileDefinition tileDef) { Tile tileInst = PrefabLibrary.I.GetTileInstance(); tileInst.Set(tileDef); tileInst.gameObject.name = "Tile " + pos; tileInst.transform.position = GameHelper.TileToWorldPos(pos) + (Vector2)transform.position; tileInst.transform.SetParent(TileCont.transform); tileInst.transform.localScale = Vector3.one; tileMap.AddTile(tileInst); }
/** * Adjusts the connections value based on the given new tile. * Returns whether value changed. */ private bool UpdateSingleConnection(Direction direction, TileDefinition tile) { bool isConnected = (tile.turf && (tile.turf.genericType == type || type == null)); if (tile.fixtures != null) { isConnected = isConnected || (tile.fixtures.GetFixtureAtLayerIndex(LayerIndex) && (tile.fixtures.GetFixtureAtLayerIndex(LayerIndex).genericType == type || type == null)); } isConnected &= (AdjacencyBitmap.Adjacent(TileState.blockedDirection, direction) == 0); return(adjacents.UpdateDirection(direction, isConnected, true)); }
/// <summary> /// Initializes a new instance of the <see cref="Tile"/> class. /// </summary> /// <param name="type">The type.</param> public Tile(TileDefinition type) { _definition = type; }
public ScalableTileLayer(string name, Size mapSize, Size tileSize, TileDefinition defaultTileDefinition = null) : base(name, mapSize, tileSize, defaultTileDefinition) { }