public override void boardSetup() { boardHolder = new GameObject ("Board").transform; // Generate a map from Cellular Automata. // CellularAutomata foo = new CellularAutomata(rows, columns); //PureRandom foo = new PureRandom(rows, columns); GameObject playerChar = GameObject.FindGameObjectWithTag("Player"); selectedRule.initializeMap (); selectedRule.generateMap (); Tile[,] mapConvert = selectedRule.map; MapValidationFunctions mvf = new MapValidationFunctions(); Coord startPoint = new Coord(floodStartX,floodStartY); Coord endPoint = new Coord(floodGoalX, floodGoalY); mvf.FloodFillCheck(selectedRule.map, startPoint, endPoint); // This is the autotiler phase. // // Let's try this method of instantiating the prefab of our choice... GameObject tileInstance = Instantiate(tilesetToUse, new Vector3(0,0,0), Quaternion.identity) as GameObject; selectedTileset = tileInstance.GetComponent<Tileset>(); selectedTileset.autoTiler( mapConvert ); if(MapValidationFunctions.clearable) Debug.Log ("The goal has been found!"); else Debug.Log ("I can't find the goal."); //convertTiles( mapConvert ); }
public void AnimateTileset(Tileset tileset) { foreach (var tile in tileset) { AnimateSprite(tile.Sprite); } }
public TileLayer(int[,] tiles, Tileset tileset, int base_x, int base_y) { this.Tileset = tileset; this.BaseX = base_x; this.BaseY = base_y; this.tiles = tiles; }
public override bool Convert(ConvertOperation convert) { bool finishConvertOp = false; List<Pixmap> availData = convert.Perform<Pixmap>().ToList(); // Generate objects foreach (Pixmap baseRes in availData) { if (convert.IsObjectHandled(baseRes)) continue; // Find target Resource matching the source - or create one. Tileset targetRes = this.FindMatchingResources<Pixmap,Tileset>(baseRes, IsMatch) .FirstOrDefault(); if (targetRes == null && convert.AllowedOperations.HasFlag(ConvertOperation.Operation.CreateRes)) { string texPath = PathHelper.GetFreePath(baseRes.FullName, Resource.GetFileExtByType<Tileset>()); targetRes = new Tileset(); targetRes.RenderConfig.Add(new TilesetRenderInput { SourceData = baseRes }); targetRes.Compile(); targetRes.Save(texPath); } if (targetRes == null) continue; convert.AddResult(targetRes); finishConvertOp = true; convert.MarkObjectHandled(baseRes); } return finishConvertOp; }
protected TileToolBase(Application application, Tileset Tileset, TileSelection selection) { this.application = application; this.Tileset = Tileset; this.selection = selection; selection.Changed += OnSelectionChanged; }
public FormLoadSettings(Tileset[] tilesets) { InitializeComponent(); this.tilesets = tilesets; foreach (var tileset in tilesets) { Node node = new Node(tileset.File); if (String.IsNullOrEmpty(tileset.File)) { node.Text = String.Format("Not Specified [w: {0}, h: {1}]", tileset.Size.X, tileset.Size.Y); } node.Cells.Add(new Cell("<browse for file>")); node.Cells[0].Editable = false; node.Cells[1].Editable = false; node.NodeDoubleClick += node_NodeDoubleClick; tilesetFilesList.Nodes.Add(node); } }
/// <summary> /// Create a new, empty brush /// </summary> public TileBrush(int width, int height, Tileset tileset) { this.width = width; this.height = height; this.patterns = new List<TileBlock>(); this.tileset = tileset; }
public ItemObject(TmxObject obj, Tileset tileset) : base(obj, tileset) { if (ScriptId == -1) { Item = Global.GetItem(int.Parse(obj.Properties["item"])); Quantity = obj.Properties.ContainsKey("quantity") ? int.Parse(obj.Properties["quantity"]) : 1; } }
public void CreateTileset(Tileset t) { AssetDatabase.DeleteAsset(_path); AssetDatabase.CreateAsset(t, _path); AssetDatabase.SaveAssets(); AssetDatabase.Refresh(); }
public BrushEditor(IEditorApplication application, Tilemap Tilemap, Tileset Tileset, string brushFile) { selection = new Selection(); selection.Changed += OnSelectionChanged; this.application = application; this.Tilemap = Tilemap; brush = Brush.loadFromFile(brushFile, Tileset); }
public CaveBlock(Game game, Vector2 position, Color color,AMaterialStats stats,bool gtbS,Tileset tset,Color glowcolour) : base(game, position, color, stats,tset,glowcolour) { NeighbourList = new List<CaveBlock>(); GoingtobeSolid = gtbS; krypton = Game.Services.GetService<KryptonEngine>(); _world = Game.Services.GetService<World>(); }
public FillEditor(IEditorApplication application, Tilemap Tilemap, Tileset Tileset, Selection selection) { this.application = application; this.Tilemap = Tilemap; this.Tileset = Tileset; this.selection = selection; application.TilemapChanged += OnTilemapChanged; selection.Changed += OnSelectionChanged; }
public Tileset Load(FilePath path) { var tileset = new Tileset(); tileset.FilePath = path; var doc = XDocument.Load(path.Absolute); var reader = doc.Element("Tileset"); if (reader == null) throw new Exception("The specified tileset definition file does not contain a Tileset tag."); var sheetPath = FilePath.FromRelative(reader.Attribute("tilesheet").Value, path.BasePath); tileset.ChangeSheetPath(sheetPath.Absolute); int size; if (!int.TryParse(reader.Attribute("tilesize").Value, out size)) throw new Exception("The tileset definition does not contain a valid tilesize attribute."); tileset.TileSize = size; var propParent = reader.Element("TileProperties"); if (propParent != null) { foreach (XElement propNode in propParent.Elements("Properties")) { var prop = new TileProperties(propNode); tileset.AddProperties(prop); } } foreach (XElement tileNode in reader.Elements("Tile")) { int id = int.Parse(tileNode.Attribute("id").Value); string name = tileNode.Attribute("name").Value; var spriteNode = tileNode.Element("Sprite"); if (spriteNode == null) throw new GameXmlException(tileNode, "All Tile tags must contain a Sprite tag."); var sprite = LoadSprite(spriteNode); var tileSprite = new TileSprite(tileset, sprite); Tile tile = new Tile(id, tileSprite); string propName = "Default"; XAttribute propAttr = tileNode.Attribute("properties"); if (propAttr != null) propName = propAttr.Value; tile.Properties = tileset.GetProperties(propName); tile.Sprite.Play(); tileset.Add(tile); } return tileset; }
public ScreenInfo(string name, Tileset tileset) { this.Name = name; this.Tileset = tileset; BlockPatterns = new List<BlockPatternInfo>(); Teleports = new List<TeleportInfo>(); Layers = new List<ScreenLayerInfo>(); Commands = new List<SceneCommandInfo>(); }
public FacilityConnectors(Tileset tileset, int row, int column) { northConnector = row > 0; westConnector = column > 0; southConnector = row < (6 - tileset.RowCount / 10); eastConnector = column < (6 - tileset.ColumnCount / 10); var isAlienGarden = alienGardens.Contains(tileset); northWall = (byte)(isAlienGarden ? 54 : 86); westWall = (byte)(isAlienGarden ? 55 : 87); //TODO: Set correct ground tile when taking out south/east "objects" (unless dirt looks okay for some facilities...) }
public TileMap(Tileset tileSet, MapLayer baseLayer) { Tilesets = new List<Tileset>(); Tilesets.Add(tileSet); MapLayers = new List<ILayer>(); MapLayers.Add(baseLayer); mapWidth = baseLayer.Width; mapHeight = baseLayer.Height; }
public EditTilesetTileInputAction(Tileset tileset, RawList<TileInput> tileInput, RawList<bool> tileInputMask) { if (tileset == null) throw new ArgumentNullException("tileset"); if (tileInput == null) throw new ArgumentNullException("tileInput"); if (tileInputMask == null) throw new ArgumentNullException("tileInputMask"); if (tileInputMask.Count != tileInput.Count) throw new ArgumentException("Input Mask needs to be the same size as input.", "tileInputMask"); this.tileset = tileset; this.tileInput = tileInput; this.tileInputMask = tileInputMask; }
public void ProcessBackground(Tileset ts, XmlNode xnNode) { XmlElement xe = (XmlElement)xnNode; List<BGLayer> bglList = new List<BGLayer>(10); ProcessBGFilename(ts, xe.GetElementsByTagName("bgFilename")[0]); XmlNodeList xnl = xe.GetElementsByTagName("layer"); foreach (XmlNode node in xnl) { bglList.Add(ProcessLayer(node)); } ts.LayerList = bglList; }
public override void Do() { // Make a backup of the tileset in its current state if (this.backupBeforeApply == null) this.backupBeforeApply = this.targetTileset.DeepClone(BackupCloneContext); // Compile the tileset so all the changes become visible this.targetTileset.Compile(); // Notify the editor we changes our target tileset this.OnNotifyPropertyChanged(); }
public TilesetViewPaintTilesEventArgs( Graphics graphics, Rectangle clipRect, Tileset tileset, Bitmap sourceImage, RawList<TilesetViewPaintTileData> paintedTiles) : base(graphics, clipRect) { this.tileset = tileset; this.sourceImage = sourceImage; this.paintedTiles = paintedTiles; }
public TilesetDocument CreateNew(FilePath filePath) { var tileset = new Tileset() { FilePath = filePath, TileSize = 16 }; var document = new TilesetDocument(tileset); AddDefaultTileProperties(document); return document; }
public override void Do() { // Make a backup of the tileset in its current state if (this.backupBeforeRevert == null) this.backupBeforeRevert = this.targetTileset.DeepClone(BackupCloneContext); // Revert the tileset back to its unchanged state. No need to compile it, // this is meant to un-do changed that were done without compiling yet. this.backupBeforeChanges.DeepCopyTo(this.targetTileset); // Notify the editor we changes our target tileset this.OnNotifyPropertyChanged(); }
/// <summary> /// Determines the default tile index of the specified <see cref="Tileset"/> /// depending on the role of the <see cref="Tilemap"/> in which it is used. /// </summary> /// <param name="tileset"></param> /// <param name="isUpperLayer"></param> /// <returns></returns> public static int GetDefaultTileIndex(Tileset tileset, bool isUpperLayer) { if (tileset == null) return 0; for (int i = 0; i < tileset.TileData.Count; i++) { // Use solid tiles for the base layer, but transparent tiles // for all upper layers. if (tileset.TileData[i].IsVisuallyEmpty == isUpperLayer) return i; } return 0; }
public FacilityConnectors(Tileset[,] tilesets, int row, int column) { var facility = tilesets[row, column]; var northFacility = row == 0 ? null : tilesets[row - 1, column]; var sourthFacility = row == 5 ? null : tilesets[row + 1, column]; var eastFacility = column == 5 ? null : tilesets[row, column + 1]; var westFacility = column == 0 ? null : tilesets[row, column - 1]; northConnector = AreVerticallyConnected(northFacility, facility); southConnector = AreVerticallyConnected(facility, sourthFacility); eastConnector = AreHorizontallyConnected(facility, eastFacility); westConnector = AreHorizontallyConnected(westFacility, facility); northWall = 14; westWall = 15; }
/// <summary> /// Check a tile block for nonexistent tile ids. /// </summary> /// <param name="tiles">TileBlock to check</param> /// <param name="Tileset">Tileset where the ids should be defined</param> /// <returns>List of invalid tile ids.</returns> public static List<int> CheckIds(TileBlock tiles, Tileset Tileset) { List<int> invalidTiles = new List<int>(); for (int y = 0; y < tiles.Height; ++y) { for (int x = 0; x < tiles.Width; ++x) { int TileId = tiles[x, y]; if (!Tileset.IsValid(TileId)) { if (invalidTiles.IndexOf(TileId) == -1) invalidTiles.Add(TileId); } } } return invalidTiles; }
public EditTilesetTileInputAction(Tileset tileset, int tileIndex, TileInput tileInput) { if (tileset == null) throw new ArgumentNullException("tileset"); this.tileset = tileset; this.tileInput = new RawList<TileInput>(tileIndex + 1); this.tileInput.Count = tileIndex + 1; this.tileInput.Data[tileIndex] = tileInput; this.tileInputMask = new RawList<bool>(tileIndex + 1); this.tileInputMask.Count = tileIndex + 1; this.tileInputMask.Data[tileIndex] = true; }
public EditTilesetAutoTileItemAction(Tileset tileset, TilesetAutoTileInput autoTile, int tileIndex, TilesetAutoTileItem tileInput) { if (tileset == null) throw new ArgumentNullException("tileset"); if (autoTile == null) throw new ArgumentNullException("autoTile"); this.tileset = tileset; this.autoTile = autoTile; this.tileInput = new RawList<TilesetAutoTileItem>(tileIndex + 1); this.tileInput.Count = tileIndex + 1; this.tileInput.Data[tileIndex] = tileInput; this.tileInputMask = new RawList<bool>(tileIndex + 1); this.tileInputMask.Count = tileIndex + 1; this.tileInputMask.Data[tileIndex] = true; }
public static List<RoomSprite> FillRect(Game _game, Rectangle wall,Color colour,Tileset tset,Color glowcolour) { List<RoomSprite> _roomSpriteList = new List<RoomSprite>(); int x = (int)(wall.Width / Globals.SmallGridSize.X); int y = (int)(wall.Height / Globals.SmallGridSize.Y); for (int i = 1; i <= x; i++) { for (int j = 1; j <= y; j++) { var wallblock = new SmallBlock01(_game, new Vector2(wall.Location.X + (i * Globals.SmallGridSize.X) - Globals.SmallGridSize.X, wall.Location.Y - (j * Globals.SmallGridSize.Y)) , colour,tset,glowcolour); _roomSpriteList.Add(wallblock); } } return _roomSpriteList; }
public Tilemap(Tileset Tileset, Lisp.List Data) { this.Tileset = Tileset; Properties Props = new Properties(Data); uint Width = 0; uint Height = 0; Props.Get("width", ref Width); Props.Get("height", ref Height); if(Width == 0 || Height == 0) throw new Exception("Width or Height of Tilemap invalid"); List<uint> Tiles = new List<uint>(); Props.GetUIntList("tiles", Tiles); if(Tiles.Count != (int) (Width * Height)) throw new Exception("TileCount != Width*Height"); Props.Get("solid", ref Solid); Props.PrintUnusedWarnings(); Field = new Field<uint>(Tiles, Width, Height); }
public void ChangeTileset(Tileset tileset) { Clear(); Tileset = tileset; if (tileset == null) brushes = null; else if (brushSets.ContainsKey(tileset.FilePath.Absolute)) { brushes = brushSets[tileset.FilePath.Absolute]; } else { brushes = new List<ITileBrush>(); brushSets.Add(tileset.FilePath.Absolute, brushes); LoadBrushes(); } if (brushes != null) { foreach (var brush in brushes) AddBrushPanel(brush); } }
private static void CreateFromSpriteEditorScene(TiledMapSave tiledMapSave, float scale, float zOffset, FileReferenceType referenceType, ReducedTileMapInfo toReturn) { var ses = tiledMapSave.ToSceneSave(scale, referenceType); // This is not a stable sort! //ses.SpriteList.Sort((first, second) => first.Z.CompareTo(second.Z)); ses.SpriteList = ses.SpriteList.OrderBy(item => item.Z).ToList(); ReducedLayerInfo reducedLayerInfo = null; float z = float.NaN; int textureWidth = 0; int textureHeight = 0; AbstractMapLayer currentLayer = null; int indexInLayer = 0; foreach (var spriteSave in ses.SpriteList) { if (spriteSave.Z != z) { indexInLayer = 0; z = spriteSave.Z; int layerIndex = FlatRedBall.Math.MathFunctions.RoundToInt(z - zOffset); var abstractMapLayer = tiledMapSave.MapLayers[layerIndex]; currentLayer = abstractMapLayer; reducedLayerInfo = new ReducedLayerInfo { Z = spriteSave.Z, Texture = spriteSave.Texture, Name = abstractMapLayer.Name, TileWidth = FlatRedBall.Math.MathFunctions.RoundToInt(spriteSave.ScaleX * 2), TileHeight = FlatRedBall.Math.MathFunctions.RoundToInt(spriteSave.ScaleY * 2) }; var mapLayer = abstractMapLayer as MapLayer; // This should have data: if (mapLayer != null) { var idOfTexture = mapLayer.data[0].tiles.FirstOrDefault(item => item != 0); Tileset tileSet = tiledMapSave.GetTilesetForGid(idOfTexture); var tilesetIndex = tiledMapSave.Tilesets.IndexOf(tileSet); textureWidth = tileSet.Images[0].width; textureHeight = tileSet.Images[0].height; reducedLayerInfo.TextureId = tilesetIndex; toReturn.Layers.Add(reducedLayerInfo); } var objectGroup = tiledMapSave.MapLayers[layerIndex] as mapObjectgroup; // This code only works based on the assumption that only one tileset will be used in any given object layer's image objects var mapObjectgroupObject = [email protected](o => o.gid != null); if (mapObjectgroupObject?.gid != null) { var idOfTexture = mapObjectgroupObject.gid.Value; Tileset tileSet = tiledMapSave.GetTilesetForGid(idOfTexture); var tilesetIndex = tiledMapSave.Tilesets.IndexOf(tileSet); textureWidth = tileSet.Images[0].width; textureHeight = tileSet.Images[0].height; reducedLayerInfo.TextureId = tilesetIndex; toReturn.Layers.Add(reducedLayerInfo); } } ReducedQuadInfo quad = ReducedQuadInfo.FromSpriteSave(spriteSave, textureWidth, textureHeight); if (currentLayer is mapObjectgroup) { var asMapObjectGroup = currentLayer as mapObjectgroup; var objectInstance = asMapObjectGroup.@object[indexInLayer]; // skip over any non-sprite objects: while (objectInstance.gid == null) { indexInLayer++; if (indexInLayer >= [email protected]) { objectInstance = null; break; } else { objectInstance = asMapObjectGroup.@object[indexInLayer]; } } if (objectInstance != null && objectInstance.properties.Count != 0) { var nameProperty = objectInstance.properties.FirstOrDefault(item => item.StrippedNameLower == "name"); if (nameProperty != null) { quad.Name = nameProperty.value; } else { quad.Name = spriteSave.Name; bool needsName = string.IsNullOrEmpty(spriteSave.Name); if (needsName) { quad.Name = $"_{currentLayer.Name}runtime{indexInLayer}"; } } List <NamedValue> list = new List <NamedValue>(); foreach (var property in objectInstance.properties) { list.Add( new NamedValue { Name = property.StrippedName, Value = property.value, Type = property.Type } ); } quad.QuadSpecificProperties = list; } } reducedLayerInfo?.Quads.Add(quad); indexInLayer++; } }
private static void CreateFromTiledMapSave(TiledMapSave tiledMapSave, string directory, FileReferenceType referenceType, ReducedTileMapInfo reducedTileMapInfo) { ReducedLayerInfo reducedLayerInfo = null; for (int i = 0; i < tiledMapSave.MapLayers.Count; i++) { var tiledLayer = tiledMapSave.MapLayers[i]; string texture = null; uint tileIdOfTexture = 0; Tileset tileSet = null; uint? firstGid = null; if (tiledLayer is MapLayer) { var mapLayer = tiledLayer as MapLayer; if (mapLayer.data.Length != 0) { firstGid = mapLayer.data[0].tiles.FirstOrDefault(item => item != 0); } } else { var objectLayer = tiledLayer as mapObjectgroup; var firstObjectWithTexture = [email protected](item => item.gid != 0); firstGid = firstObjectWithTexture?.gid; } if (firstGid > 0) { tileSet = tiledMapSave.GetTilesetForGid(firstGid.Value); if (tileSet != null) { if (referenceType == FileReferenceType.NoDirectory) { texture = tileSet.Images[0].sourceFileName; } else if (referenceType == FileReferenceType.Absolute) { if (!string.IsNullOrEmpty(tileSet.SourceDirectory) && tileSet.SourceDirectory != ".") { directory += tileSet.SourceDirectory; directory = FlatRedBall.IO.FileManager.RemoveDotDotSlash(directory); } texture = FlatRedBall.IO.FileManager.RemoveDotDotSlash(directory + tileSet.Images[0].Source); } else { throw new NotImplementedException(); } } int tileWidth = FlatRedBall.Math.MathFunctions.RoundToInt(tiledMapSave.tilewidth); int tileHeight = FlatRedBall.Math.MathFunctions.RoundToInt(tiledMapSave.tileheight); reducedLayerInfo = new ReducedLayerInfo { Z = i, Texture = texture, Name = tiledLayer.Name, TileWidth = tileWidth, TileHeight = tileHeight, }; reducedTileMapInfo.Layers.Add(reducedLayerInfo); var tilesetIndex = tiledMapSave.Tilesets.IndexOf(tileSet); reducedLayerInfo.TextureId = tilesetIndex; // create the quad here: if (tiledLayer is MapLayer) { AddTileLayerTiles(tiledMapSave, reducedLayerInfo, i, tiledLayer, tileSet, tileWidth, tileHeight); } else if (tiledLayer is mapObjectgroup) { AddObjectLayerTiles(reducedLayerInfo, tiledLayer, tileSet, firstGid, tileWidth, tileHeight); } } } }
private void PerformUserDrawAction() { Tileset tileset = this.SelectedTileset.Res; if (tileset == null) { return; } TilesetAutoTileInput autoTile = this.currentAutoTile; if (autoTile == null) { return; } int tileIndex = this.TilesetView.HoveredTileIndex; if (tileIndex < 0 || tileIndex > tileset.TileCount) { return; } // Determine data before the operation, and set up data for afterwards bool lastIsBaseTile = autoTile.BaseTileIndex == tileIndex; bool newIsBaseTile = lastIsBaseTile; TilesetAutoTileItem lastInput = (autoTile.TileInput.Count > tileIndex) ? autoTile.TileInput[tileIndex] : default(TilesetAutoTileItem); TilesetAutoTileItem newInput = lastInput; // Determine how data is modified due to our user operation if (this.userDrawMode == AutoTileDrawMode.Add) { if (this.isExternalDraw) { newInput.Neighbours = TileConnection.None; newInput.ConnectsToAutoTile = true; newInput.IsAutoTile = false; newIsBaseTile = false; } else if (this.isBaseTileDraw) { newInput.Neighbours = TileConnection.All; newInput.IsAutoTile = true; newInput.ConnectsToAutoTile = false; newIsBaseTile = true; } else { newInput.Neighbours |= this.hoveredArea; newInput.IsAutoTile = true; newInput.ConnectsToAutoTile = false; } } else if (this.userDrawMode == AutoTileDrawMode.Remove) { if (this.isExternalDraw || this.isBaseTileDraw || this.hoveredArea == TileConnection.None) { newInput.Neighbours = TileConnection.None; newInput.ConnectsToAutoTile = false; newInput.IsAutoTile = false; newIsBaseTile = false; } else { newInput.Neighbours &= ~this.hoveredArea; } } // Apply the new, modified data to the actual data using an UndoRedo operation if (newIsBaseTile != lastIsBaseTile) { UndoRedoManager.Do(new EditPropertyAction( null, TilemapsReflectionInfo.Property_TilesetAutoTileInput_BaseTile, new object[] { autoTile }, new object[] { newIsBaseTile?tileIndex: -1 })); } if (!object.Equals(lastInput, newInput)) { UndoRedoManager.Do(new EditTilesetAutoTileItemAction( tileset, autoTile, tileIndex, newInput)); } }
/// <summary> /// Converts a TiledMapSave to a ReducedTileMapInfo object /// </summary> /// <param name="tiledMapSave">The TiledMapSave to convert</param> /// <param name="scale">The amount to scale by - default of 1</param> /// <param name="zOffset">The zOffset</param> /// <param name="directory">The directory of the file associated with the tiledMapSave, used to find file references.</param> /// <param name="referenceType">How the files in the .tmx are referenced.</param> /// <returns></returns> public static ReducedTileMapInfo FromTiledMapSave(TiledMapSave tiledMapSave, float scale, float zOffset, string directory, FileReferenceType referenceType) { var toReturn = new ReducedTileMapInfo(); toReturn.NumberCellsTall = tiledMapSave.Height; toReturn.NumberCellsWide = tiledMapSave.Width; var ses = tiledMapSave.ToSceneSave(scale, referenceType); ses.SpriteList.Sort((first, second) => first.Z.CompareTo(second.Z)); ReducedLayerInfo reducedLayerInfo = null; // If we rely on the image, it's both slow (have to open the images), and // doesn't work at runtime in games: //Dictionary<string, Point> loadedTextures = new Dictionary<string, Point>(); //SetCellWidthAndHeight(tiledMapSave, directory, toReturn, ses, loadedTextures); toReturn.CellHeightInPixels = (ushort)tiledMapSave.tileheight; toReturn.CellWidthInPixels = (ushort)tiledMapSave.tilewidth; SetQuadWidthAndHeight(toReturn, ses); float z = float.NaN; int textureWidth = 0; int textureHeight = 0; for (int i = 0; i < ses.SpriteList.Count; i++) { SpriteSave spriteSave = ses.SpriteList[i]; if (spriteSave.Z != z) { z = spriteSave.Z; reducedLayerInfo = new ReducedLayerInfo(); reducedLayerInfo.Z = spriteSave.Z; reducedLayerInfo.Texture = spriteSave.Texture; int layerIndex = FlatRedBall.Math.MathFunctions.RoundToInt(z - zOffset); var mapLayer = tiledMapSave.Layers[layerIndex]; // This should have data: var idOfTexture = mapLayer.data[0].tiles.FirstOrDefault(item => item != 0); Tileset tileSet = tiledMapSave.GetTilesetForGid(idOfTexture); var tilesetIndex = tiledMapSave.Tilesets.IndexOf(tileSet); textureWidth = tileSet.Images[0].width; textureHeight = tileSet.Images[0].height; reducedLayerInfo.Name = mapLayer.Name; reducedLayerInfo.TextureId = tilesetIndex; toReturn.Layers.Add(reducedLayerInfo); } ReducedQuadInfo quad = ReducedQuadInfo.FromSpriteSave(spriteSave, textureWidth, textureHeight); reducedLayerInfo.Quads.Add(quad); } return(toReturn); }
private extern void orig_ReadInto(patch_TerrainType data, Tileset tileset, XmlElement xml);
public void SetTileset(Tileset to) { tilesetsComboBox.SelectedItem = to; tileSelector.Tileset = to; }
private static void AddObjectLayerTiles(ReducedLayerInfo reducedLayerInfo, AbstractMapLayer tiledLayer, Tileset tileSet, uint?gid, int tileWidth, int tileHeight) { var asMapLayer = tiledLayer as mapObjectgroup; foreach (var objectInstance in asMapLayer.@object) { if (objectInstance.gid > 0) { ReducedQuadInfo quad = new DataTypes.ReducedQuadInfo(); quad.LeftQuadCoordinate = (float)objectInstance.x; quad.BottomQuadCoordinate = (float)-objectInstance.y; quad.RotationDegrees = (float)objectInstance.Rotation; quad.FlipFlags = (byte)(gid.Value & 0xf0000000 >> 7); var valueWithoutFlip = gid.Value & 0x0fffffff; int leftPixelCoord; int topPixelCoord; int rightPixelCoord; int bottomPixelCoord; TiledMapSave.GetPixelCoordinatesFromGid(gid.Value, tileSet, out leftPixelCoord, out topPixelCoord, out rightPixelCoord, out bottomPixelCoord); quad.LeftTexturePixel = (ushort)Math.Min(leftPixelCoord, rightPixelCoord); quad.TopTexturePixel = (ushort)Math.Min(topPixelCoord, bottomPixelCoord); quad.Name = objectInstance.Name; if (string.IsNullOrEmpty(quad.Name)) { var prop = quad.QuadSpecificProperties.FirstOrDefault(quadProp => quadProp.Name.ToLowerInvariant() == "name"); quad.Name = (string)prop.Value; } reducedLayerInfo?.Quads.Add(quad); } } }
public static string GetAmbientDaySound(Tileset tileset) { return($"{GetAmbientSound(tileset)}Day"); }
public override void BuildMainFunction(string path, float left, float right, float top, float bottom, Tileset light, SoundEnvironment sound, params string[] initFunctions) { var fileSyntax = new LuaCompilationUnitSyntax(); fileSyntax.AddStatement(GetMainFunctionSyntax(left, right, top, bottom, light, sound, initFunctions)); RenderFunctionToFile(path, fileSyntax); }
public static Tile GetRandomTile(AssetHandler assetHandler, DebugForm debugForm, int salt, Tileset tileset) { Random tempRand = new Random(salt); Tile randTile = new Tile(); int rand = tempRand.Next(0, 1000); if (debugForm != null) { debugForm.WriteLine("Random-Value: " + rand); } if (rand < 250) { randTile.isEnterable = true; randTile.isInteractable = false; randTile.tileBitmap = tileset.TileIcons[(int)Tiles.Plain_0]; randTile.tileName = "Plain_0"; } else if (rand < 500) { randTile.isEnterable = true; randTile.isInteractable = false; randTile.tileBitmap = tileset.TileIcons[(int)Tiles.Plain_1]; randTile.tileName = "Plain_1"; } else if (rand < 750) { randTile.isEnterable = true; randTile.isInteractable = false; randTile.tileBitmap = tileset.TileIcons[(int)Tiles.Plain_2]; randTile.tileName = "Plain_2"; } else if (rand < 940) { randTile.isEnterable = true; randTile.isInteractable = false; randTile.tileBitmap = tileset.TileIcons[(int)Tiles.Plain_3]; randTile.tileName = "Plain_3"; } else if (rand < 965) { randTile.isEnterable = false; randTile.isInteractable = false; randTile.tileBitmap = tileset.TileIcons[(int)Tiles.Plain_4]; randTile.tileName = "Plain_4"; } else if (rand < 985) { randTile.isEnterable = true; randTile.isInteractable = true; randTile.tileBitmap = tileset.TileIcons[(int)Tiles.Plain_House_0]; randTile.tileName = "Plain_House_0"; //randTile.interaction = new GetItemInteraction(Weapon.GetRandomWeapon(assetHandler),"Dorfbesuch","Willkommen im Dummy-Dorf, hier ist ein Item-Test!"); randTile.interaction = GetItemInteraction.GetRandomItemInteraction(assetHandler); } else if (rand < 998) { randTile.isEnterable = true; randTile.isInteractable = true; randTile.tileBitmap = tileset.TileIcons[(int)Tiles.Plain_House_1]; randTile.tileName = "Plain_House_1"; } else if (rand < 1000) { randTile.isEnterable = true; randTile.isInteractable = false; randTile.tileBitmap = tileset.TileIcons[(int)Tiles.Plain_Castle_0]; randTile.tileName = "Plain_Castle_0"; } else { randTile.isEnterable = true; randTile.isInteractable = true; randTile.tileBitmap = tileset.TileIcons[(int)Tiles.Dummy]; randTile.tileName = "DUMMY"; } return(randTile); }
public static Tileset CreateTilesetFromTmx(string tmxFilePath, string dstPath) { string tmxFileName = Path.GetFileNameWithoutExtension(tmxFilePath); TmxTilemap tilemap = TmxTilemap.LoadFromFile(tmxFilePath); if (tilemap.DicTilesetTex2D.Values.Count == 0) { return(null); } //NOTE: calling this after PackTextures will make the atlasTexture to be null sometimes Tileset tilesetAsset = ScriptableObject.CreateInstance <Tileset>(); AssetDatabase.CreateAsset(tilesetAsset, Path.Combine(dstPath, tmxFileName + "Tileset.asset")); Texture2D atlasTexture; Rect[] tilesetRects; if (tilemap.DicTilesetTex2D.Values.Count == 1) { atlasTexture = tilemap.DicTilesetTex2D.Values.ToArray()[0]; tilesetRects = new Rect[] { new Rect(0, 0, atlasTexture.width, atlasTexture.height) }; } else { atlasTexture = new Texture2D(8192, 8192, TextureFormat.ARGB32, false, false); tilesetRects = atlasTexture.PackTextures(tilemap.DicTilesetTex2D.Values.ToArray(), 0); } string atlasPath = Path.GetDirectoryName(AssetDatabase.GetAssetPath(tilesetAsset)) + "/" + tmxFileName + "Atlas.png"; AssetDatabase.CreateAsset(atlasTexture, atlasPath); File.WriteAllBytes(atlasPath, atlasTexture.EncodeToPNG()); ImportTexture(atlasPath); AssetDatabase.Refresh(); // Link Atlas with asset to be able to save it in the prefab tilesetAsset.AtlasTexture = (Texture2D)AssetDatabase.LoadAssetAtPath(atlasPath, typeof(Texture2D)); tilesetAsset.TilePxSize = new Vector2(tilemap.Map.Tilesets[0].TileWidth, tilemap.Map.Tilesets[0].TileHeight); int tilesetIdx = 0; List <Tile> tileList = new List <Tile>(); foreach (Texture2D tilesetTexture in tilemap.DicTilesetTex2D.Values) { TmxTileset tmxTileset = tilemap.Map.Tilesets[tilesetIdx]; Vector2 tileSize = new Vector2(tilemap.Map.Tilesets[tilesetIdx].TileWidth, tilemap.Map.Tilesets[tilesetIdx].TileHeight); Rect[] tileRects = GenerateGridSpriteRectangles(tilesetTexture, new Vector2(tmxTileset.Margin, tmxTileset.Margin), tileSize, new Vector2(tmxTileset.Spacing, tmxTileset.Spacing)); TileSelection tilesetSelection = new TileSelection(Enumerable.Range(tileList.Count, tileRects.Length).Select(i => (uint)i).ToList(), tmxTileset.Columns); foreach (Rect tileRect in tileRects) { Rect uv = tileRect; uv.xMin /= tilesetAsset.AtlasTexture.width; uv.xMax /= tilesetAsset.AtlasTexture.width; uv.yMin /= tilesetAsset.AtlasTexture.height; uv.yMax /= tilesetAsset.AtlasTexture.height; uv.position += tilesetRects[tilesetIdx].position; tileList.Add(new Tile() { uv = uv }); } tilesetIdx++; tilesetAsset.TileViews.Add(new TileView(tilesetTexture.name, tilesetSelection)); } tilesetAsset.SetTiles(tileList); return(tilesetAsset); }
public static void ImportTmxIntoTheScene(string tmxFilePath, Tileset tileset) { string tmxFileName = Path.GetFileNameWithoutExtension(tmxFilePath); TmxTilemap tilemap = TmxTilemap.LoadFromFile(tmxFilePath); if (tilemap.DicTilesetTex2D.Values.Count == 0) { return; } GameObject tilemapGroupObj = new GameObject(tmxFileName); TilemapGroup tilemapGroup = tilemapGroupObj.AddComponent <TilemapGroup>(); int orderInLayer = 0; foreach (TmxLayer layer in tilemap.Map.Layers) { GameObject tilemapObj = new GameObject(layer.Name); tilemapObj.transform.SetParent(tilemapGroupObj.transform); Tilemap tilemapBhv = tilemapObj.AddComponent <Tilemap>(); tilemapBhv.Tileset = tileset; tilemapBhv.OrderInLayer = orderInLayer++; tilemapBhv.IsVisible = layer.Visible; tilemapBhv.TintColor = new Color(1f, 1f, 1f, layer.Opacity); for (int gx = 0; gx < layer.Width; gx++) { for (int gy = 0; gy < layer.Height; gy++) { int tileIdx = gy * layer.Width + gx; TmxLayerTile tile = layer.Tiles[tileIdx]; //skip non valid tiles if (tile.GId == 0) { continue; } int tileId = tilemap.GetTileAbsoluteId(tile); uint tileData = tileId >= 0 ? (uint)tileId : Tileset.k_TileData_Empty; if (tileData != Tileset.k_TileData_Empty) { // add tile flags if ((tile.GId & k_FLIPPED_HORIZONTALLY_FLAG) != 0) { tileData |= Tileset.k_TileFlag_FlipH; } if ((tile.GId & k_FLIPPED_VERTICALLY_FLAG) != 0) { tileData |= Tileset.k_TileFlag_FlipV; } if ((tile.GId & k_FLIPPED_DIAGONALLY_FLAG) != 0) { tileData |= Tileset.k_TileFlag_Rot90; } //convert from tiled flip diagonal to rot90 if ((tileData & Tileset.k_TileFlag_Rot90) != 0) { if (((tile.GId & k_FLIPPED_HORIZONTALLY_FLAG) != 0) != ((tile.GId & k_FLIPPED_VERTICALLY_FLAG) != 0)) { tileData ^= Tileset.k_TileFlag_FlipH; } else { tileData ^= Tileset.k_TileFlag_FlipV; } } } tilemapBhv.SetTileData(gx, layer.Height - gy - 1, tileData); } } tilemapBhv.UpdateMesh(); } tilemapGroup.Refresh(); }
private ScreenLayerInfo LoadScreenLayer(XElement node, string stagePath, string name, Tileset tileset, int tileStartX, int tileStartY, bool foreground) { var tileFilePath = Path.Combine(stagePath, name + ".scn"); var tileArray = LoadTiles(tileFilePath); var tileLayer = new TileLayer(tileArray, tileset, tileStartX, tileStartY); var entities = new List <EntityPlacement>(); foreach (XElement entity in node.Elements("Entity")) { EntityPlacement info = LoadEntityPlacement(entity); entities.Add(info); } var keyframes = new List <ScreenLayerKeyframe>(); foreach (var keyframeNode in node.Elements("Keyframe")) { var frame = LoadScreenLayerKeyFrame(keyframeNode); keyframes.Add(frame); } return(new ScreenLayerInfo(name, tileLayer, foreground, entities, keyframes)); }
private void OnNew(Tileset tileset) { var instanceID = tileset.GetInstanceID(); _tsWindow.SetTileSet(instanceID); }
/// <summary> /// /// </summary> public static void Load() { Packer packer = new Packer(); packer.Padding = 0; // Load the main font. Font = new SpriteFont(Path() + "fonts/dogica.ttf", 6, ASCII, TextureFilter.Nearest); Font.LineGap = 4; int packIndex = 0; #region Load sprites List <SpriteInfo> spriteInfo = new List <SpriteInfo>(); // Get all sprites. string spritePath = Path() + "sprites/"; foreach (string it in Directory.EnumerateFiles(spritePath)) { if (!it.EndsWith(".ase")) { continue; } SpriteInfo info = new SpriteInfo(); info.Aseprite = new Aseprite(it); info.Name = System.IO.Path.GetFileNameWithoutExtension(it); info.PackIndex = packIndex; foreach (var frame in info.Aseprite.Frames) { packer.AddBitmap(packIndex.ToString(), frame.Bitmap); packIndex++; } spriteInfo.Add(info); } #endregion #region Load tilesets List <SpriteInfo> tilesetInfo = new List <SpriteInfo>(); // Get all tilesets. string tilesetPath = Path() + "tilesets/"; foreach (string it in Directory.EnumerateFiles(tilesetPath)) { if (!it.EndsWith(".ase")) { continue; } SpriteInfo info = new SpriteInfo(); info.Aseprite = new Aseprite(it); info.Name = System.IO.Path.GetFileNameWithoutExtension(it); info.PackIndex = packIndex; var frame = info.Aseprite.Frames[0]; var columns = frame.Bitmap.Width / Game.TileWidth; var rows = frame.Bitmap.Height / Game.TileHeight; for (int x = 0; x < columns; x++) { for (int y = 0; y < rows; y++) { var subrect = new RectInt(x * Game.TileWidth, y * Game.TileHeight, Game.TileWidth, Game.TileHeight); var subimage = frame.Bitmap.GetSubBitmap(subrect); packer.AddBitmap(packIndex.ToString(), subimage); packIndex++; } } tilesetInfo.Add(info); } #endregion // Build the atlas. packer.Pack(); SpriteAtlas = new Atlas(packer); #region Add sprites foreach (SpriteInfo info in spriteInfo) { Sprite sprite = new Sprite(); sprite.Name = info.Name; sprite.Origin = Vector2.Zero; sprite.Animations = new List <Sprite.Animation>(); if (info.Aseprite.Slices.Count > 0 && info.Aseprite.Slices[0].Pivot.HasValue) { sprite.Origin = new Vector2( info.Aseprite.Slices[0].Pivot.Value.X, info.Aseprite.Slices[0].Pivot.Value.Y ); } foreach (var tag in info.Aseprite.Tags) { Sprite.Animation anim = new Sprite.Animation(); anim.Name = tag.Name; anim.Frames = new List <Sprite.Frame>(); for (int i = tag.From; i <= tag.To; i++) { Sprite.Frame frame = new Sprite.Frame(); frame.Duration = info.Aseprite.Frames[i].Duration / 1000.0f; frame.Image = SpriteAtlas.Subtextures[(info.PackIndex + i).ToString()]; anim.Frames.Add(frame); } sprite.Animations.Add(anim); } Sprites.Add(sprite); } #endregion #region Add Tilesets foreach (SpriteInfo info in tilesetInfo) { var frame = info.Aseprite.Frames[0]; Tileset tileset = new Tileset(); tileset.Name = info.Name; tileset.Columns = frame.Bitmap.Width / Game.TileWidth; tileset.Rows = frame.Bitmap.Height / Game.TileHeight; for (int x = 0, i = info.PackIndex; x < tileset.Columns; x++) { for (int y = 0; y < tileset.Rows; y++) { tileset.Tiles[x + y * tileset.Columns] = SpriteAtlas.Subtextures[i.ToString()]; i++; } } Tilesets.Add(tileset); } #endregion // Load the rooms. string mapPath = Path() + "map/"; foreach (string it in Directory.EnumerateFiles(mapPath)) { if (!it.EndsWith(".png")) { continue; } var name = System.IO.Path.GetFileNameWithoutExtension(it); var point = name.Split('x'); if (point.Length != 2) { continue; } RoomInfo info; info.Cell.X = int.Parse(point[0]); info.Cell.Y = int.Parse(point[1]); info.Image = new Bitmap(it); Debug.Assert(info.Image.Width == Game.Columns, "Room is incorrect width!"); Debug.Assert(info.Image.Height == Game.Rows, "Room is incorrect height!"); Rooms.Add(info); } }
public TileSetTilesetAction(TileLayer tileLayer, Tileset setTo) : base(tileLayer) { this.setTo = setTo; }
public override void Draw(Microsoft.Xna.Framework.GameTime time) { spriteBatch.Begin(); int x = 0; int y = 0; try { foreach (TileLogicScript logic in TileLogicManager.Instance.logics) { Tileset _s_0 = EditorEngine.Instance.GetTilesetByName(logic.s_0); int _s_1 = logic.s_1; if ((x << 4) + 16 > this.Width) { y++; x = 0; } Rectangle srcRect = _s_0.Texture.GetSource(_s_1); Rectangle targetRect = new Rectangle(x << 4, (y << 4) - scrollbar.Value, 16, 16); spriteBatch.Draw(_s_0.Texture.Texture, targetRect, srcRect, Color.White); x += 1; } this.yMax = y << 4; if (!initializedYMax) { initializedYMax = true; refreshScrollbar(); } } catch (Exception e) { Console.WriteLine("Bullshit occured: " + e); } Selection selection = new Selection(); selection.Start(new Vector2(xt << 4, yt << 4)); selection.End(new Vector2(xt << 4, yt << 4)); SelectionUtil.DrawRectangle( spriteBatch, Color.Black, new Rectangle( selection.Region.X * 16 + 1, selection.Region.Y * 16 + 1 - this.scrollbar.Value, selection.Region.Width * 16, selection.Region.Height * 16)); SelectionUtil.DrawRectangle( spriteBatch, Color.White, new Rectangle( selection.Region.X * 16, selection.Region.Y * 16 - this.scrollbar.Value, selection.Region.Width * 16, selection.Region.Height * 16)); spriteBatch.End(); }
public UnknownTile(Tileset tileset) : base(-1, new TileSprite(tileset)) { }
public ApplyTilesetChangesAction(Tileset targetTileset, Tileset backupBeforeChanges) { this.targetTileset = targetTileset; this.backupBeforeChanges = backupBeforeChanges; }
void OnGUI() { //EditorGUILayout.Space(10); GUILayout.BeginHorizontal(); { GUILayout.Space(10); GUILayout.BeginVertical(); { GUILayout.Space(10); GUILayout.Label("SMW Tileset Creation", EditorStyles.boldLabel); GUILayout.BeginHorizontal(); { GUILayout.BeginVertical(); { GUILayout.Label("Tileset from Sprite", EditorStyles.boldLabel); // EditorGUILayout.LabelField("Sprite"); EditorGUI.BeginChangeCheck(); w_TilesetSprite = EditorGUILayout.ObjectField("Sprite", w_TilesetSprite, typeof(Sprite), false, GUILayout.ExpandWidth(true)) as Sprite; if (EditorGUI.EndChangeCheck()) { if (w_TilesetSprite != null) { w_TilesetName = Path.GetFileNameWithoutExtension(AssetDatabase.GetAssetPath(w_TilesetSprite)); } else { w_TilesetName = ""; } if (w_TilesetTileTypesList != null) { w_TilesetTileTypesList.Clear(); w_TilesetTileTypesList = null; } } EditorGUILayout.LabelField("TilesetName: " + w_TilesetName, EditorStyles.boldLabel); w_TargetColor = EditorGUILayout.ColorField("Target Color:", w_TargetColor); w_ReplacementColor = EditorGUILayout.ColorField("Replacement Color:", w_ReplacementColor); if (w_TilesetSprite == null) { GUI.enabled = false; } if (GUILayout.Button("Prepare Sprite Texture")) { w_TilesetSprite = PrepareSpriteTexture(w_TilesetSprite, 32, w_TargetColor, w_ReplacementColor); } if (GUILayout.Button("Select Tileset's TileTypeFile")) { if (OnGUI_OpenFile(out m_LastFilePath, "tls")) { // file slected and openeed w_TilesetTileTypeFilePath = m_LastFilePath; m_FileOpened = true; w_TilesetTileTypesList = ReadTileTypes(w_TilesetTileTypeFilePath); if (w_TilesetTileTypesList == null) { Debug.LogError("w_TilesetTileTypesList == null"); } else { for (int i = 0; i < w_TilesetTileTypesList.Count; i++) { Debug.Log(Path.GetDirectoryName(m_LastFilePath) + "/" + Path.GetFileName(m_LastFilePath) + " " + w_TilesetTileTypesList[i] + " - " + w_TilesetTileTypesList[i].ToString()); // + " " + w_TilesetTileTypes[i]); } } } else { // file open dialouge cancled w_TilesetTileTypesList.Clear(); w_TilesetTileTypesList = null; w_TilesetTileTypeFilePath = ""; m_FileOpened = false; } } EditorGUILayout.LabelField("Tileset's Tile Type File Path = " + w_TilesetTileTypeFilePath, GUILayout.ExpandWidth(true)); bool current = GUI.enabled; w_TileSpriteAlignment = (SpriteAlignment)EditorGUILayout.EnumPopup("Pivot", w_TileSpriteAlignment); if (w_TileSpriteAlignment != SpriteAlignment.Custom) { // deaktiviere custom Offset GUI.enabled = false; } // GUI: Custom Pivot w_customTilePivotOffset = EditorGUILayout.Vector2Field("Custom Offset", w_customTilePivotOffset); GUI.enabled = current; w_TilePixelWidth = EditorGUILayout.IntField("Tile Width (px)", w_TilePixelWidth); w_TilePixelHeight = EditorGUILayout.IntField("Tile Height (px)", w_TilePixelHeight); if (w_TilesetSprite != null) { GUI.enabled = true; GUILayout.Label("Spritename = " + w_TilesetSprite.name); if (GUILayout.Button("Slice & Prepare Tileset Sprite", GUILayout.ExpandWidth(false))) { TextureImporter textureImporter = (TextureImporter)UnityEditor.TextureImporter.GetAtPath(AssetDatabase.GetAssetPath(w_TilesetSprite)); PerformMetaSlice(w_TilesetSprite.texture, textureImporter, w_TileSpriteAlignment, w_customTilePivotOffset, w_TilePixelWidth, w_TilePixelHeight, w_TilesetPixelPerUnit); } Color temp = GUI.color; if (w_TilesetSprite.pixelsPerUnit == 32) { GUI.color = Color.green; // EditorGUILayout.LabelField("<color=green>PixelPerUnit = " + w_TilesetSprite.pixelsPerUnit + "</color>"); } else { GUI.color = Color.red; // EditorGUILayout.LabelField("<color=red>PixelPerUnit = " + w_TilesetSprite.pixelsPerUnit + "</color>"); } EditorGUILayout.LabelField("PixelPerUnit = " + w_TilesetSprite.pixelsPerUnit); GUI.color = temp; } else { GUILayout.Label("no Sprite selected", EditorStyles.boldLabel); GUI.enabled = false; } if (!m_FileOpened) { if (GUI.enabled) { GUILayout.Label("no Tileset TileTypeFile selected", EditorStyles.boldLabel); GUI.enabled = false; } } if (w_TilesetTileTypesList == null) { if (GUI.enabled) { GUILayout.Label("no Tileset TileTypeFile in List", EditorStyles.boldLabel); GUI.enabled = false; } } GUILayout.BeginHorizontal(); if (GUILayout.Button("Create Tileset from Sprite & TLS File", GUILayout.ExpandWidth(false))) { currentTileset = Create(w_TilesetName, w_TilesetSprite, w_TilesetTileTypesList, GetPivotValue(w_TileSpriteAlignment, w_customTilePivotOffset)); // EditorUtility.FocusProjectWindow(); <-- Satck Overflow // Selection.activeObject = currentTileset; } bool lastState = GUI.enabled; if (true) { //TODO GUI.enabled = true; } if (GUILayout.Button("Create Tileset from Sprite without TLS File", GUILayout.ExpandWidth(false))) { currentTileset = Create(w_TilesetName, w_TilesetSprite, null, GetPivotValue(w_TileSpriteAlignment, w_customTilePivotOffset)); // EditorUtility.FocusProjectWindow(); <-- Satck Overflow // Selection.activeObject = currentTileset; } GUI.enabled = lastState; GUILayout.EndHorizontal(); } GUILayout.EndVertical(); GUI.enabled = true; if (GUILayout.Button("Create empty Tileset SO", GUILayout.ExpandWidth(false))) { currentTileset = CreateEmpty(); } } GUILayout.EndHorizontal(); GUILayout.Space(10); GUILayout.Label("Current Tileset", EditorStyles.boldLabel); currentTileset = EditorGUILayout.ObjectField("Tileset ", currentTileset, typeof(Tileset), false) as Tileset; GUILayout.Space(10); GUILayout.Label("Tileset Tile Preview", EditorStyles.boldLabel); w_TilesetPixelPerUnit = EditorGUILayout.IntField("Tileset Pixel per Unit", w_TilesetPixelPerUnit); w_SubTilePosX = EditorGUILayout.IntField("X (iCol)", w_SubTilePosX); w_SubTilePosY = EditorGUILayout.IntField("Y (iRow)", w_SubTilePosY); // if (GUILayout.Button("Show Tile (SubSprite)", GUILayout.ExpandWidth(false))) // { // CreateGameObjectWithSubSprite(w_SubTilePosX, w_SubTilePosY); // } if (GUILayout.Button("Show Tile (NewSprite)", GUILayout.ExpandWidth(false))) { CreateGameObjectWithNewSprite(w_SubTilePosX, w_SubTilePosY); } if (GUILayout.Button("Show Tile (AssetSlicedSprite)", GUILayout.ExpandWidth(false))) { CreateGameObjectWithAssetSprite(w_SubTilePosX, w_SubTilePosY); } } GUILayout.EndVertical(); } GUILayout.EndHorizontal(); // Repaint(); }
public static string GetAmbientNightSound(Tileset tileset) { return($"{GetAmbientSound(tileset)}Night"); }
public MapEnvironment(Tileset tileset, uint width, uint height, int cliffLevel) : this(tileset, width, height, cliffLevel, new RectangleMargins(6, 6, 4, 8)) { }
private LuaVariableListDeclarationSyntax GetMainFunctionSyntax(float left, float right, float top, float bottom, Tileset tileset, SoundEnvironment sound, params string[] initFunctions) { var localLeft = new LuaBinaryExpressionSyntax( new LuaFloatLiteralExpressionSyntax(left), LuaSyntaxNode.Tokens.Plus, new LuaInvocationExpressionSyntax("GetCameraMargin", "CAMERA_MARGIN_LEFT")); var localRight = new LuaBinaryExpressionSyntax( new LuaFloatLiteralExpressionSyntax(right), LuaSyntaxNode.Tokens.Sub, new LuaInvocationExpressionSyntax("GetCameraMargin", "CAMERA_MARGIN_RIGHT")); var localTop = new LuaBinaryExpressionSyntax( new LuaFloatLiteralExpressionSyntax(top), LuaSyntaxNode.Tokens.Sub, new LuaInvocationExpressionSyntax("GetCameraMargin", "CAMERA_MARGIN_TOP")); var localBottom = new LuaBinaryExpressionSyntax( new LuaFloatLiteralExpressionSyntax(bottom), LuaSyntaxNode.Tokens.Plus, new LuaInvocationExpressionSyntax("GetCameraMargin", "CAMERA_MARGIN_BOTTOM")); var locals = new[] { localLeft, localRight, localTop, localBottom, }; var statements = new List <LuaStatementSyntax> { new LuaLocalDeclarationStatementSyntax(new LuaLocalVariablesStatementSyntax( new[] { new LuaSymbolNameSyntax(new LuaIdentifierLiteralExpressionSyntax("left")), new LuaSymbolNameSyntax(new LuaIdentifierLiteralExpressionSyntax("right")), new LuaSymbolNameSyntax(new LuaIdentifierLiteralExpressionSyntax("top")), new LuaSymbolNameSyntax(new LuaIdentifierLiteralExpressionSyntax("bottom")), }, locals)), new LuaExpressionStatementSyntax( new LuaInvocationExpressionSyntax( "SetCameraBounds", "left", "bottom", "right", "top", "left", "top", "right", "bottom")), new LuaExpressionStatementSyntax(new LuaInvocationExpressionSyntax( "SetDayNightModels", new LuaStringLiteralExpressionSyntax(LightEnvironmentProvider.GetTerrainLightEnvironmentModel(tileset)), new LuaStringLiteralExpressionSyntax(LightEnvironmentProvider.GetUnitLightEnvironmentModel(tileset)))), new LuaExpressionStatementSyntax(new LuaInvocationExpressionSyntax("NewSoundEnvironment", new LuaStringLiteralExpressionSyntax(SoundEnvironmentProvider.GetSoundEnvironment(sound)))), new LuaExpressionStatementSyntax(new LuaInvocationExpressionSyntax("SetAmbientDaySound", new LuaStringLiteralExpressionSyntax(SoundEnvironmentProvider.GetAmbientDaySound(tileset)))), new LuaExpressionStatementSyntax(new LuaInvocationExpressionSyntax("SetAmbientNightSound", new LuaStringLiteralExpressionSyntax(SoundEnvironmentProvider.GetAmbientNightSound(tileset)))), new LuaExpressionStatementSyntax(new LuaInvocationExpressionSyntax( "SetMapMusic", new LuaStringLiteralExpressionSyntax("Music"), LuaIdentifierLiteralExpressionSyntax.False, LuaNumberLiteralExpressionSyntax.Zero)), }; foreach (var initFunction in initFunctions) { statements.Add(new LuaExpressionStatementSyntax(new LuaInvocationExpressionSyntax(initFunction))); } var functionSyntax = new LuaFunctionExpressionSyntax(); functionSyntax.AddStatements(statements); var mainFunctionDeclarator = new LuaVariableDeclaratorSyntax("main", functionSyntax); mainFunctionDeclarator.IsLocalDeclaration = false; var globalFunctionSyntax = new LuaVariableListDeclarationSyntax(); globalFunctionSyntax.Variables.Add(mainFunctionDeclarator); return(globalFunctionSyntax); }
public void LoadMinecart() { // if mode7 map if (Index < 2) { labelStartXY.Visible = true; startX.Visible = true; startY.Visible = true; startX.Value = Bits.GetShort(Model.ROM, 0x039670); startY.Value = Bits.GetShort(Model.ROM, 0x039679); // Create map elements PaletteSet = Model.M7PaletteSet; Tileset = new Tileset(Model.M7PaletteSet, TilesetType.Mode7); if (Index == 0) { Tilemap = new Mode7Tilemap(Model.M7TilemapA, Tileset, PaletteSet); } else { Tilemap = new Mode7Tilemap(Model.M7TilemapB, Tileset, PaletteSet); } // Load the screens toggleScreens.Enabled = false; ScreensForm.Hide(); ObjectsForm.Hide(); } // if side-scrolling map else { labelStartXY.Visible = false; startX.Visible = false; startY.Visible = false; // Create map elements PaletteSet = Model.SSPaletteSet; Tileset = new Tileset(Model.SSTileset, Model.SSGraphics, PaletteSet, 16, 16, TilesetType.SideScrolling); Tilemap = new SideTilemap(Model.SSTilemap, null, Tileset, PaletteSet); toggleScreens.Enabled = true; ScreensForm.LoadScreens(); // ObjectsForm toggleScreens.Enabled = true; ScreensForm.Show(dockPanel, DockState.DockTop); ObjectsForm.Left = this.Right + 10; ObjectsForm.Top = this.Top; ObjectsForm.Show(ScreensForm.Pane, DockAlignment.Right, 0.25); ObjectsForm.InitializeObjects(); } // (Re)load editors and forms ReloadPaletteEditor(); ReloadGraphicEditor(); ReloadSpritePaletteEditor(); ReloadSpriteGraphicEditor(); LoadTilesetEditor(); LoadTilemapEditor(); // Rails properties TilesetForm.Rails = state.Rails && Index < 2; }
public MapEnvironment(Tileset tileset, uint width, uint height, int cliffLevel, RectangleMargins cameraBoundsComplements) : this() { if (!Enum.IsDefined(typeof(Tileset), tileset)) { throw new ArgumentOutOfRangeException(nameof(tileset)); } var maxx = width - 1; if ((maxx % 32) != 0 || width == 0) { throw new ArgumentOutOfRangeException(nameof(width)); } var maxy = height - 1; if ((maxy % 32) != 0 || height == 0) { throw new ArgumentOutOfRangeException(nameof(height)); } if (cameraBoundsComplements is null) { throw new ArgumentNullException(nameof(cameraBoundsComplements)); } _tileset = tileset; _version = LatestVersion; _width = width; _height = height; _left = MapWidth / -2f; _bottom = MapHeight / -2f; _terrainTypes = GetDefaultTerrainTypes().ToList(); _cliffTypes = GetDefaultCliffTypes().ToList(); var edgeLeft = cameraBoundsComplements.Left; var edgeRight = maxx - cameraBoundsComplements.Right; var edgeBottom = cameraBoundsComplements.Bottom; var edgeTop = maxy - cameraBoundsComplements.Top; for (var y = 0; y < _width; y++) { for (var x = 0; x < _height; x++) { var tile = new MapTile(); tile.CliffLevel = cliffLevel; tile.CliffTexture = 15; tile.CliffVariation = 0; tile.Height = 0; tile.IsBlighted = false; tile.IsBoundary = false; tile.IsEdgeTile = x != maxx && y != maxy && (x < edgeLeft || x >= edgeRight || y < edgeBottom || y >= edgeTop); tile.IsRamp = false; tile.IsWater = false; tile.Texture = 0; tile.Variation = 0; tile.WaterHeight = 0; _tiles.Add(tile); } } }
protected override void OnInitialized() { base.OnInitialized(); tileset = Environment.Resources.Textures.PenguinWalking; }
public MapEnvironment(Tileset tileset, uint width, uint height) : this(tileset, width, height, DefaultCliffLevel) { }
private static void AddTileLayerTiles(TiledMapSave tiledMapSave, ReducedLayerInfo reducedLayerInfo, int i, AbstractMapLayer tiledLayer, Tileset tileSet, int tileWidth, int tileHeight) { var asMapLayer = tiledLayer as MapLayer; var count = asMapLayer.data[0].tiles.Count; for (int dataId = 0; dataId < count; dataId++) { var dataAtIndex = asMapLayer.data[0].tiles[dataId]; if (dataAtIndex != 0) { ReducedQuadInfo quad = new DataTypes.ReducedQuadInfo(); float tileCenterX; float tileCenterY; float tileZ; tiledMapSave.CalculateWorldCoordinates(i, dataId, tileWidth, tileHeight, asMapLayer.width, out tileCenterX, out tileCenterY, out tileZ); quad.LeftQuadCoordinate = tileCenterX - tileWidth / 2.0f; quad.BottomQuadCoordinate = tileCenterY - tileHeight / 2.0f; var gid = dataAtIndex; //quad.FlipFlags = (byte)((gid & 0xf0000000) >> 28); var valueWithoutFlip = gid & 0x0fffffff; spriteSaveForConversion.RotationZ = 0; spriteSaveForConversion.FlipHorizontal = false; TiledMapSave.SetSpriteTextureCoordinates(gid, spriteSaveForConversion, tileSet, tiledMapSave.orientation); bool isRotated = spriteSaveForConversion.RotationZ != 0; if (isRotated) { quad.FlipFlags = (byte)(quad.FlipFlags | ReducedQuadInfo.FlippedDiagonallyFlag); } var leftTextureCoordinate = System.Math.Min(spriteSaveForConversion.LeftTextureCoordinate, spriteSaveForConversion.RightTextureCoordinate); var topTextureCoordinate = System.Math.Min(spriteSaveForConversion.TopTextureCoordinate, spriteSaveForConversion.BottomTextureCoordinate); if (spriteSaveForConversion.LeftTextureCoordinate > spriteSaveForConversion.RightTextureCoordinate) { quad.FlipFlags = (byte)(quad.FlipFlags | ReducedQuadInfo.FlippedHorizontallyFlag); } if (spriteSaveForConversion.TopTextureCoordinate > spriteSaveForConversion.BottomTextureCoordinate) { quad.FlipFlags = (byte)(quad.FlipFlags | ReducedQuadInfo.FlippedVerticallyFlag); } quad.LeftTexturePixel = (ushort)FlatRedBall.Math.MathFunctions.RoundToInt(leftTextureCoordinate * tileSet.Images[0].width); quad.TopTexturePixel = (ushort)FlatRedBall.Math.MathFunctions.RoundToInt(topTextureCoordinate * tileSet.Images[0].height); if (tileSet.TileDictionary.ContainsKey(valueWithoutFlip)) { var dictionary = tileSet.TileDictionary[valueWithoutFlip].PropertyDictionary; if (dictionary.ContainsKey("name")) { quad.Name = tileSet.TileDictionary[valueWithoutFlip].PropertyDictionary["name"]; } else if (dictionary.ContainsKey("Name")) { quad.Name = tileSet.TileDictionary[valueWithoutFlip].PropertyDictionary["Name"]; } } reducedLayerInfo?.Quads.Add(quad); } } }
void Start() { Physics2D.IgnoreLayerCollision(10, 11); nextLevelData = new AssetProxy(typeof(NextLevelData)).LoadAsset("Objects/NextData.asset"); gamData = new AssetProxy(typeof(GameData)).LoadAsset("Objects/Data.asset"); Debug.Log(nextLevelData); nextLevelData.GenerateNextLevelData(); Vector2Int ms = nextLevelData.GetMapSize(); int MapSizeX = ms.x; int MapSizeY = ms.y; System.DateTime start = System.DateTime.Now; edgeCollider = GetComponent <EdgeCollider2D>(); edgeCollider.points = new Vector2[] { new Vector2(-MapSizeX / 2, -MapSizeY / 2), new Vector2(-MapSizeX / 2, MapSizeY / 2), new Vector2(MapSizeX / 2, MapSizeY / 2), new Vector2(MapSizeX / 2, -MapSizeY / 2), new Vector2(-MapSizeX / 2, -MapSizeY / 2) }; GameMap map = new GameMap(MapSizeX, MapSizeY); map.ground = GetComponentsInChildren <Tilemap>()[0]; map.decorations = GetComponentsInChildren <Tilemap>()[1]; map.structures = GetComponentsInChildren <Tilemap>()[2]; TilesetCreator tilesetCreator; Locations location = nextLevelData.GetLocation(); switch (location) { case Locations.Forest: tilesetCreator = new ForestTilesetCreator(); break; case Locations.Desert: tilesetCreator = new DesertTilesetCreator(); break; case Locations.Village: tilesetCreator = new VillageTilesetCreator(); break; default: tilesetCreator = new ForestTilesetCreator(); break; } Tileset ts = tilesetCreator.CreateTileset(); MapBuilder builder; MapType type = nextLevelData.GetMapType(); switch (type) { case MapType.Dungeon: builder = new DungeonMapBuilder(new Rect(-MapSizeX / 2, -MapSizeY / 2, MapSizeX, MapSizeY), map, ts); break; case MapType.Ruins: builder = new RuinsMapBuilder(new Rect(-MapSizeX / 2, -MapSizeY / 2, MapSizeX, MapSizeY), map, ts); break; case MapType.Village: tilesetCreator = new VillageTilesetCreator(); ts = tilesetCreator.CreateTileset(); builder = new VillageMapBuilder(new Rect(-MapSizeX / 2, -MapSizeY / 2, MapSizeX, MapSizeY), map, ts); break; default: builder = new DungeonMapBuilder(new Rect(-MapSizeX / 2, -MapSizeY / 2, MapSizeX, MapSizeY), map, ts); break; } //MapBuilder builder = new VillageMapBuilder(new Rect(-MapSizeX / 2, -MapSizeY / 2, MapSizeX, MapSizeY), map); MapGenerator mapGen = new MapGenerator(builder); mapGen.Generate(); builder.GetMap(); Spawner spawner = new Spawner(); spawner.Spawn(map, ts); BuffSpawner buffSpawner = new BuffSpawner(); buffSpawner.Spawn(map, ts); System.TimeSpan timeItTook = System.DateTime.Now - start; Debug.Log(string.Format("Map generated, {0}", timeItTook)); }
public MapEnvironment(Tileset tileset, uint width, uint height, RectangleMargins cameraBoundsComplements) : this(tileset, width, height, DefaultCliffLevel, cameraBoundsComplements) { }