private void LoadBiomes() { XmlDocument xml = new XmlDocument(); xml.Load("Content/XML/Biomes.xml"); foreach (XmlNode node in xml.SelectNodes("Biomes/Biome")) { string uid = node.Attributes.GetNamedItem("UID").Value; string file = node.Attributes.GetNamedItem("File").Value; string name = node.Attributes.GetNamedItem("Name").Value; try { using (Texture2D texture = TextureUtility.LoadTexture(GraphicsDevice, "Content/Graphics/Biomes/" + file)) { Texture2D[,] variants = TextureUtility.Split(GraphicsDevice, texture, 64, 64); BasicSprite[] sprites = new BasicSprite[variants.Length]; int i = 0, maxY = variants.GetLength(1), maxX = variants.GetLength(0); for (int y = 0; y < maxY; y++) { for (int x = 0; x < maxX; x++) { sprites[i] = Textures.Copy(variants[x, y]); i++; } } Biome biome = new Biome(uid, name, sprites); Data.Biomes.Add(uid, biome); } } catch { } } Textures.ApplyChanges(); }
public void LoadContent(SpriteBatch sb, ContentManager content) { Resources = new CommonResources(); Resources.LoadContent(sb, content); Player1.LoadContent(sb, content); Ship.LoadContent(sb, content); Hud.LoadContent(sb, content); //Initialize bg array for (int i = 0; i < bgList.GetLength(0); i++) { for (int j = 0; j < bgList.GetLength(1); j++) { bgList[i, j] = Resources.ReturnRandomBackground(); } } //Instantiate obj stack Objectives = new Stack <Collectible>(); //Push to objective stack Objectives.Push(new Collectible("engine", new Vector2(-3000, -2000), Resources.Engine)); Objectives.Push(new Collectible("welder", new Vector2(3000, 4000), Resources.Welder)); Objectives.Push(new Collectible("ai", new Vector2(-200, 200), Resources.Ai)); }
internal static Texture2D Resize(this Texture2D[,] textures, int size) { Texture2D result = new Texture2D(Main.graphics.GraphicsDevice, size, size); Color[] data1 = new Color[size * size]; int maxX = textures.GetLength(0); int maxY = textures.GetLength(1); int maxWidth = 0; int maxHeight = 0; for (int x = 0; x < maxX; x++) { maxWidth += textures[x, 0].Width; } for (int y = 0; y < maxY; y++) { maxHeight += textures[0, y].Height; } float max = Math.Max(maxWidth, maxHeight); float scale = size / max; int[] widths = new int[maxX + 1]; int[] heights = new int[maxY + 1]; for (int x = 0; x < maxX; x++) { for (int y = 0; y < maxY; y++) { Texture2D texture = textures[x, y]; int width = (int)(texture.Width * scale); int height = (int)(texture.Height * scale); widths[x + 1] = widths[x] + width; heights[y + 1] = heights[y] + height; Texture2D texture2; using (System.IO.MemoryStream ms = new System.IO.MemoryStream()) { texture.SaveAsPng(ms, width, height); texture2 = Texture2D.FromStream(texture.GraphicsDevice, ms); } Color[] data2 = new Color[width * height]; texture2.GetData <Color>(data2); for (int i = 0; i < height; i++) { for (int j = 0; j < width; j++) { data1[heights[y] * size + widths[x] + i * size + j] = data2[i * width + j]; } } } } result.SetData(data1); return(result); }
public SpriteSheet(Texture2D[,] sprites) { //Same amount of columns as sprites, 1 row cols = sprites.GetLength(0); rows = sprites.GetLength(1); //Save the sprites this.sprites = sprites; }
//public Texture2D showTexture; public MapTextureShower(Map map, Vector2Int unit, Func <int, Color[]> showerFun = null, Material quadsMaterial = null) { this.unit = unit; this.map = map; this.showerFun = showerFun; this.quadsMaterial = quadsMaterial; map.onAddMapNode += OnMapAddNode; map.onRemoveMapNode += OnMapRemoveNode; int x = map.Size.x / (1024 / unit.x); int y = map.Size.y / (1024 / unit.y); int mx = map.Size.x % (1024 / unit.x); int my = map.Size.y % (1024 / unit.y); if (mx != 0) { x += 1; } if (my != 0) { y += 1; } textures = new Texture2D[x, y]; quads = new GameObject[x, y]; isModify = new bool[x, y]; for (int i = 0; i < textures.GetLength(0); i++) { for (int j = 0; j < textures.GetLength(1); j++) { int xsize = map.Size.x * unit.x > 1024 ? 1024 : map.Size.x * unit.x; int ysize = map.Size.y * unit.y > 1024 ? 1024 : map.Size.y * unit.y; if (i == textures.GetLength(0) - 1) { xsize = mx == 0 ? xsize : mx * unit.x; } if (j == textures.GetLength(1) - 1) { ysize = my == 0 ? ysize : my * unit.y; } textures[i, j] = new Texture2D(xsize, ysize); textures[i, j].wrapMode = TextureWrapMode.Clamp; quads[i, j] = GameObject.CreatePrimitive(PrimitiveType.Quad); if (quadsMaterial != null) { quads[i, j].GetComponent <MeshRenderer>().material = quadsMaterial; } quads[i, j].GetComponent <MeshRenderer>().material.mainTexture = textures[i, j]; quads[i, j].transform.position = new Vector3(i * unit.x, 0, j * unit.y) + new Vector3(xsize / (unit.x * 2), 0, ysize / (unit.y * 2)); quads[i, j].transform.localScale = new Vector3(xsize / unit.x, ysize / unit.y, 1); quads[i, j].transform.rotation = Quaternion.Euler(90, 0, 0); } } }
public static void FinishOperation() { for (var x = 0; x < editorTextures.GetLength(0); x++) { for (var y = 0; y < editorTextures.GetLength(1); y++) { if (editorDirty[x, y]) { editorTextures[x, y].Apply(); editorDirty[x, y] = false; } } } }
public void Draw(SpriteBatch sb) { sb.Begin(); for (int i = 0; i < casinoMap.GetLength(0); i++) { for (int j = 0; j < casinoMap.GetLength(1); j++) { Texture2D currText = casinoMap[i, j]; Rectangle currRect = casinoMapRect[i, j]; sb.Draw(currText, currRect, Color.White); } } sb.End(); }
//default map constructor, makes a concrete bitmap with nothing on it public Map(ContentManager content, int screenWidth, int screenHeight) { tileSize = screenWidth / 20; tileMap = new Texture2D[20, 100]; objectMap = new MapObject[tileMap.GetLength(0), tileMap.GetLength(1)]; tileRot = new int[tileMap.GetLength(0), tileMap.GetLength(1)]; objRot = new int[tileMap.GetLength(0), tileMap.GetLength(1)]; //loops through entire tileMap array and sets each value to concrete for (int i = 0; i < tileMap.GetLength(0); i++) { for (int j = 0; j < tileMap.GetLength(1); j++) { tileMap[i, j] = content.Load<Texture2D>("ConcreteCorner"); } } //loops through objectMap array and sets edges to noTexture for (int i = 0; i < objectMap.GetLength(0); i++) { for (int j = 0; j < objectMap.GetLength(1); j++) { objectMap[i, j] = new MapObject(content, true, "NoTexture", i, j); } } for (int i = 1; i < objectMap.GetLength(0) - 1; i++) { for (int j = 1; j < objectMap.GetLength(1) - 1; j++) { objectMap[i, j] = null; } } for (int i = 1; i < objectMap.GetLength(0); i += 6) { for (int j = 0; j < objectMap.GetLength(1) - 3; j++) { objectMap[i, j] = new MapObject(content, true, "NoTexture", i, j); } } }
protected void Animate(GameTime gameTime) { double mod = (speed / (vel.X / gameTime.ElapsedGameTime.TotalSeconds)); if (mod < 0) { mod = mod * -1; } if (is_moving == true && time >= delay * mod && is_falling == false) { if (currentSprite < img.GetLength(0) - 1) { currentSprite++; } else { currentSprite = 0; } time = 0; } else if (is_moving == false) { currentSprite = 0; } else if (is_falling) { currentSprite = 2; } }
public void JoinGrid() { Texture2D[,] array = currentShape.array; int length = array.GetLength(1); for (int y = 0; y < length; y++) { for (int x = 0; x < length; x++) { int blockX = currentShape.gridpos.X + x;//geeft de positie van de 4 blokjes waaruit een tetrisblokje is opgebouwd op het tetrisgrid int blockY = currentShape.gridpos.Y + y; if (currentShape.array[x, y].Name != "block") { grid.array[blockX, blockY] = currentShape.array[x, y]; //vervangt het grid met blokje } } } currentShape = nextShape; // zorgt ervoor dat het volgende blokje het huidige blokje wordt currentShape.gridpos = new Point(4, 0); //zet de positie rond het midden van de grid NewShape(); //maakt een nieuw volgend blokje if (Collision()) { gameState = GameState.GameOver; //als er net een nieuw blokje spawnt en hij collide al meteen met het grid is het game over, helaas pindakaas, } grid.CheckfullLine(); }
public bool Collision() // kijkt of het blokje op een plek zit waar hij mag zijn, dus niet buiten het speelveld of in een blokje in het grid { bool collision = false; //standaard is er geen collision Texture2D[,] array = currentShape.array; Point gridpos = currentShape.gridpos; int length = array.GetLength(1); for (int y = 0; y < length; y++) { for (int x = 0; x < length; x++) { int blockX = gridpos.X + x; int blockY = gridpos.Y + y; if (array[x, y].Name != "block") //"block" is een lege plek in de array, dus moet er alleen gekeken worden naar entries die niet leeg zijn. { if (blockX < 0 || blockX > 9 || blockY < 0 || blockY > 19 || grid.array[blockX, blockY].Name != "block") //kijk of shape niet buiten grid raakt en dat shape niet op een gevuld gridblok staat { collision = true; } } } } return(collision); }
/// <summary> /// Cette fonction s'assure que les textures contenues dans le tableau de /// textures fourni en argument (paramètre tex) aient toutes les mêmes /// dimensions. Si ce n'est pas le cas, une exception est lancée. /// </summary> /// <param name="tex">Tableau des textures à valider.</param> private static void ValiderDimensionsDeTextures(Texture2D[,] tex) { // On s'assure que toutes les images ont les mêmes dimensions. int largeur = tex[0, 0].Width; int hauteur = tex[0, 0].Height; for (int row = 0; row < tex.GetLength(0); row++) { for (int col = 0; col < tex.GetLength(1); col++) { if (tex[row, col].Width != largeur || tex[row, col].Height != hauteur) { throw new System.Exception("les images doivent être de dimensions uniformes"); } } } }
void unloadPictureIcons() { Texture2D[,] texs = PropertiesSingleton.instance.albumsIcons; for (int i = 0; i < texs.GetLength(0); i++) { if (texs[i, 0] != null) { int j = 0; while (texs[i, j] != null && j < texs.GetLength(1)) { Resources.UnloadAsset(texs[i, j]); texs[i, j] = null; j++; } } } }
private void SelectTexture() { Random rng = new Random(); int i; foreach (Tile tile2 in Tile2) { i = rng.Next(0, mapTextures.GetLength(1) + 2); tile2.Texture = mapTextures[i, 3]; } }
void ViewMode.Draw() { offset = new Vector2(-center.X + Game1.graphics.GraphicsDevice.Viewport.Width / 2, -center.Y + Game1.graphics.GraphicsDevice.Viewport.Height / 2); spriteBatch.Begin(); for (int i = 0; i < stage.GetLength(0); i++) { for (int j = 0; j < stage.GetLength(1); j++) { spriteBatch.Draw(stage[i, j], new Vector2(32 * i, 32 * j) + offset, null); } } for (int i = 0; i < stage.GetLength(0); i++) { spriteBatch.DrawString(Game1.font, $"{i}", new Vector2(32 * i, -24) + offset, Color.Black, 0, new Vector2(0, 0), 0.6f, SpriteEffects.None, 0); spriteBatch.DrawString(Game1.font, $"{i}", new Vector2(32 * i, stage.GetLength(1) * 32) + offset, Color.Black, 0, new Vector2(0, 0), 0.6f, SpriteEffects.None, 0); } for (int i = 0; i < stage.GetLength(1); i++) { spriteBatch.DrawString(Game1.font, $"{i,2}", new Vector2(-24, 32 * i) + offset, Color.Black, 0, new Vector2(0, 0), 0.6f, SpriteEffects.None, 0); spriteBatch.DrawString(Game1.font, $"{i,2}", new Vector2(stage.GetLength(0) * 32, 32 * i) + offset, Color.Black, 0, new Vector2(0, 0), 0.6f, SpriteEffects.None, 0); spriteBatch.DrawString(Game1.font, $"{i,2}", new Vector2(20 * 32, 32 * i) + offset, Color.Red, 0, new Vector2(0, 0), 0.6f, SpriteEffects.None, 0); spriteBatch.DrawString(Game1.font, $"{i,2}", new Vector2(40 * 32, 32 * i) + offset, Color.Red, 0, new Vector2(0, 0), 0.6f, SpriteEffects.None, 0); } spriteBatch.End(); }
public void Draw(GameTime gameTime, SpriteBatch spriteBatch) //tekent de vormpjes in het speelveld apart van het grid { int Height = array.GetLength(1); int Width = Height; Vector2 position; position.X = gridpos.X * block.Width; position.Y = gridpos.Y * block.Height; for (int y = 0; y != Height; y++) { for (int x = 0; x != Width; x++) { if (array[x, y] != block) { spriteBatch.Draw(array[x, y], position, Color.White); //als kleur, geef kleur } position.X += block.Width; } position.X = gridpos.X * block.Width; position.Y += block.Height; } }
public void updateSpritesheetPos(float netXMovement, bool player = false) { if ((player && netXMovement > 0) || (!player && netXMovement < 0)) { //Left player movement currentEffect = SpriteEffects.FlipHorizontally; } else if ((player && netXMovement < 0) || (!player && netXMovement > 0)) { //Right player movement currentEffect = SpriteEffects.None; } if (parentEntity.rigidBody.onGround) { if (netXMovement == 0) { //Standing spritesheetPos = new[] { 0, 0 }; } else { //Walking if (spritesheetPos[0] != 1) { //Initial walking spritesheetPos = new[] { 1, 0 }; } currentWalkFrameDist += Math.Abs(netXMovement); if (currentWalkFrameDist >= walkFrameDist) { //Change frame currentWalkFrameDist -= walkFrameDist; spritesheetPos[1]++; if (spritesheetPos[1] > spritesheet.GetLength(1) - 1) { //Reset walkTexturePos spritesheetPos[1] = 0; } } } } else { //Jumping spritesheetPos = new[] { 2, 0 }; } }
public void update_loc(int x, int y, sbyte fgd_block) { if (y < (map.GetLength(1) * 100) - map[0, map.GetLength(1) - 1].Height) { Color[] col = new Color[1]; Rectangle r = new Rectangle(x % 100, y % 100, 1, 1); if (fgd_block < 0) { col[0] = Color.FromNonPremultiplied(0, 0, 0, 127); } else { col[0] = Exilania.block_types.blocks[fgd_block].map_represent; } map[x / 100, y / 100].SetData <Color>(0, r, col, 0, 1); } }
void OnGUI() { var texture2D = MapData.texture; // Get the map name to load if (texture2D != null) { #region GUI Display // Scale the texture view based on the selected choice from the popup //scale = (Scale)EditorGUILayout.EnumPopup("Zoom", scale); scale = Scale.x1; fun = (FunLevel)EditorGUILayout.EnumPopup("Having fun?", fun); // This is here so I dont have to recalculate off sets again, remove this is scale is field works properly. var newScale = ((int)scale) + 1; var newTextureSize = new Vector2(texture2D.width, texture2D.height) * newScale; var offset = new Vector2(10, 65); mapViewOffset = new Vector2(10, newTextureSize.y + 85); if (isTextureLoaded == false) { LoadTextures(); } // Export Button if (GUILayout.Button("Save Map")) { MapData.ExportMap(); Close(); } // Manages the scroll bar if needed EditorGUILayout.LabelField("Tile Picker"); var viewPort = new Rect(0, 0, position.width - 5, position.height - 5); var contentSize = new Rect(0, 0, newTextureSize.x + offset.x, newTextureSize.y + offset.y); scrollPosition = GUI.BeginScrollView(viewPort, scrollPosition, contentSize); GUI.DrawTexture(new Rect(offset.x, offset.y, newTextureSize.x, newTextureSize.y), texture2D); // Size of a tile Vector2 tile = new Vector2(15, 15) * newScale; tile.x += newScale; tile.y += newScale; ///////////////// // Picker view // ///////////////// // Set the dimensions of the texture grid var grid = new Vector2(newTextureSize.x / tile.x, newTextureSize.y / tile.y); // Set the position of the selected tile and where the mouse is hovering var selectionPos = new Vector2(tile.x * currentSelection.x + offset.x, tile.y * currentSelection.y + offset.y); pickerHover = new Vector2(tile.x * pickerHover.x + offset.x, tile.y * pickerHover.y + offset.y); // Setup the box texture and it's style var boxTex = new Texture2D(1, 1); boxTex.SetPixel(0, 0, Colors.Aqua); boxTex.Apply(); var style = new GUIStyle(GUI.skin.customStyles[0]); style.normal.background = boxTex; // Render the selected box GUI.Box(new Rect(selectionPos.x, selectionPos.y, tile.x, tile.y), "", style); // Change the box texture properties boxTex.SetPixel(0, 0, Colors.Purple * 0.5f); boxTex.Apply(); style.normal.background = boxTex; // Render the hover box with the modified properties GUI.Box(new Rect(pickerHover.x, pickerHover.y, tile.x, tile.y), "", style); ////////////// // Map view // ////////////// // Label EditorGUI.LabelField(new Rect(0, mapViewOffset.y - 20, 50, 25), "Map"); // Set the dimensions of the texture grid var map = new Vector2(MapData.mapDimensions.x, MapData.mapDimensions.y); // For map view hover mapHover = new Vector2(tile.x * mapHover.x + mapViewOffset.x, tile.y * mapHover.y + mapViewOffset.y); Debug.Log(tiles.GetLength(0) + " " + tiles.GetLength(1)); Debug.Log("Map: " + map); // Draw map grid for (int y = 0; y < map.y; y++) { for (int x = 0; x < map.x; x++) { Debug.Log(MapData.tempMapCoords[x, y] + " x " + x + " y " + y); Debug.Log(tiles[(int)MapData.tempMapCoords[x, y].x, (int)MapData.tempMapCoords[x, y].y]); GUI.DrawTexture(new Rect(x * tile.x + mapViewOffset.x, y * tile.y + mapViewOffset.y, tile.x, tile.y), tiles[(int)MapData.tempMapCoords[x, y].x, (int)MapData.tempMapCoords[x, y].y]); } } #endregion GUI Display #region GUI Input // Get the current GUI event and the mouse position var cEvent = Event.current; Vector2 mousePos = new Vector2(cEvent.mousePosition.x - offset.x, cEvent.mousePosition.y - offset.y); if (mousePos.y < mapViewOffset.y - 62 * newScale) { // Snap the position to the grid pickerHover.x = Mathf.Floor((mousePos.x + scrollPosition.x) / tile.x); pickerHover.y = Mathf.Floor((mousePos.y + scrollPosition.y) / tile.y); // Make sure the selection is within bounds if (pickerHover.x > grid.x - 1) { pickerHover.x = grid.x - 1; } else if (pickerHover.x < 0) { pickerHover.x = 0; } if (pickerHover.y > grid.y - 1) { pickerHover.y = grid.y - 1; } else if (pickerHover.y < 0) { pickerHover.y = 0; } // Mouse click in select area if (cEvent.type == EventType.mouseDown && cEvent.button == 0 && mousePos.y < offset.y + newTextureSize.y) { currentSelection = pickerHover; // Set the currently selected sprite accordingly MapData.currentSprite = (int)(currentSelection.y * grid.x + currentSelection.x); MapData.currentSelectedCoords = currentSelection; //Debug.Log("X: " + MapData.currentSelectedCoords.x * 16 + " Y: " + MapData.currentSelectedCoords.y * 16); } } else { // Re-calculate mouse position mousePos = new Vector2(cEvent.mousePosition.x - mapViewOffset.x, cEvent.mousePosition.y - mapViewOffset.y); // Snap the position to the grid mapHover.x = Mathf.Floor((mousePos.x + scrollPosition.x) / tile.x); mapHover.y = Mathf.Floor((mousePos.y + scrollPosition.y) / tile.y); // Make sure the selection is within bounds if (mapHover.x > map.x - 1) { mapHover.x = map.x - 1; } else if (mapHover.x < 0) { mapHover.x = 0; } if (mapHover.y > map.y - 1) { mapHover.y = map.y - 1; } else if (mapHover.y < 0) { mapHover.y = 0; } // Draw Box GUI.Box(new Rect(mapHover.x * tile.x + mapViewOffset.x, mapHover.y * tile.y + mapViewOffset.y, tile.x, tile.y), "", style); // Mouse click in map area if (cEvent.type == EventType.mouseDown && cEvent.button == 0) { // Set new tile MapData.SetTile((int)mapHover.x, (int)mapHover.y); //MapData.tempMapCoords[(int)mapHover.x, (int)mapHover.y] = MapData.currentSelectedCoords; MapData.AddNewCoords((int)mapHover.x, (int)mapHover.y, MapData.currentSelectedCoords); } } #endregion GUI Input // End Scroll View GUI.EndScrollView(); // Rerender Repaint(); } }
private static void PackHeightmap(Texture2D[,] allHeightmap, int textureSize, int lodLevel, string path, string terrainName) { ComputeShader shader = Resources.Load <ComputeShader>("MipmapCompute"); ComputeBuffer readBuffer = new ComputeBuffer(textureSize * textureSize, sizeof(float)); MStringBuilder sb = new MStringBuilder(path.Length + terrainName.Length + 15); sb.Add(path); if (path[path.Length - 1] != '/') { sb.Add("/"); } sb.Add(terrainName); path += terrainName; if (Directory.Exists(sb.str)) { Directory.Delete(sb.str); } Directory.CreateDirectory(sb.str); int pathLength = sb.str.Length; for (int i = 0; i < lodLevel; ++i) { sb.Resize(pathLength); sb.Add("/LOD" + i.ToString()); Directory.CreateDirectory(sb.str); } sb.Resize(pathLength); sb.Add("/LOD0"); for (int x = 0; x < allHeightmap.GetLength(0); ++x) { for (int y = 0; y < allHeightmap.GetLength(1); ++y) { Texture2D tex = allHeightmap[x, y]; if (tex.width != textureSize || tex.height != textureSize) { readBuffer.Dispose(); Resources.UnloadAsset(shader); throw new System.Exception("Texture " + tex.name + " setting is not right!(Width, Height, isReadable)"); } } } shader.SetBuffer(1, "_OutputBuffer", readBuffer); float[] result = new float[textureSize * textureSize]; void SaveTexture(StreamWriter writer, Texture tex) { shader.SetTexture(1, ShaderIDs._MainTex, tex); int kernelSize = Mathf.CeilToInt(textureSize / 8f); shader.Dispatch(1, kernelSize, kernelSize, 1); readBuffer.GetData(result); char[] chrArray = new char[result.Length * sizeof(half)]; half * arrPtr = (half *)chrArray.Ptr(); for (int i = 0; i < result.Length; ++i) { arrPtr[i] = (half)result[i]; } writer.Write(chrArray); } using (StreamWriter writer = new StreamWriter(sb.str)) { for (int x = 0; x < allHeightmap.GetLength(0); ++x) { for (int y = 0; y < allHeightmap.GetLength(1); ++y) { Texture2D tex = allHeightmap[x, y]; SaveTexture(writer, tex); } } } readBuffer.Dispose(); Resources.UnloadAsset(shader); }
public MiniMap(World w, GraphicsDevice g) { map_pieces = new List <MapMarker>(); map = new Texture2D[w.map.GetLength(0) / 100, w.map.GetLength(1) / 100]; int width = 100; int height = 100; for (int x = 0; x < map.GetLength(0); x++) { for (int y = 0; y < map.GetLength(1); y++) { if (x < map.GetLength(0) - 1) { width = 100; } else { if (w.map.GetLength(0) % 100 != 0) { width = w.map.GetLength(0) % 100; } else { width = 100; } } if (y < map.GetLength(1) - 1) { height = 100; } else { if (w.map.GetLength(1) % 100 != 0) { height = w.map.GetLength(1) % 100; } else { height = 100; } } map[x, y] = new Texture2D(g, width, height); Color[] total_map = new Color[width * height]; sbyte temp_col = -1; for (int ys = 0; ys < height; ys++) { for (int xs = 0; xs < width; xs++) { temp_col = w.map[(x * 100) + xs, (y * 100) + ys].fgd_block; if (temp_col < 0) { if (w.map[(x * 100) + xs, (y * 100) + ys].liquid_id > 0) { total_map[(ys * width) + xs] = Exilania.block_types.blocks[World.liquid_blocks[w.map[(x * 100) + xs, (y * 100) + ys].liquid_id]].map_represent; } else { total_map[(ys * width) + xs] = Color.FromNonPremultiplied(0, 0, 0, 127); } } else { total_map[(ys * width) + xs] = Exilania.block_types.blocks[temp_col].map_represent; } } } map[x, y].SetData <Color>(total_map); } } }
/* * internal static Texture2D Resize(this Texture2D texture, int size) * { * Texture2D result = texture; * * float max = Math.Max(texture.Width, texture.Height); * float scale = size / max; * int width = (int)(texture.Width * scale); * int height = (int)(texture.Height * scale); * * using (System.IO.MemoryStream ms = new System.IO.MemoryStream()) * { * texture.SaveAsPng(ms, width, height); * // Crashes Mac (maybe Linux?) * result = Texture2D.FromStream(texture.GraphicsDevice, ms); * } * return result; * } */ internal static Texture2D Resize(this Texture2D[,] textures, int size) { Texture2D result = new Texture2D(Main.graphics.GraphicsDevice, size, size); Color[] data1 = new Color[size * size]; int maxX = textures.GetLength(0); int maxY = textures.GetLength(1); int maxWidth = 0; int maxHeight = 0; for (int x = 0; x < maxX; x++) { maxWidth += textures[x, 0].Width; } for (int y = 0; y < maxY; y++) { maxHeight += textures[0, y].Height; } float max = Math.Max(maxWidth, maxHeight); float scale = size / max; int[] widths = new int[maxX + 1]; int[] heights = new int[maxY + 1]; // TODO: Wait, shouldn't I just do this all in 1 draw call? for (int x = 0; x < maxX; x++) { for (int y = 0; y < maxY; y++) { Texture2D texture = textures[x, y]; int width = (int)(texture.Width * scale); int height = (int)(texture.Height * scale); widths[x + 1] = widths[x] + width; heights[y + 1] = heights[y] + height; Texture2D texture2; if (Terraria.ModLoader.ModLoader.windows) { using (System.IO.MemoryStream ms = new System.IO.MemoryStream()) { // This doesn't work on Mac/Linux but doesn't cause a screen flash. // TODO: Do this in an Update method so screen flash doesn't matter. texture.SaveAsPng(ms, width, height); texture2 = Texture2D.FromStream(texture.GraphicsDevice, ms); } } else { // Alt method for Mac/Linux, causes screen flash texture2 = ResizeTexture(texture, scale); } Color[] data2 = new Color[width * height]; texture2.GetData <Color>(data2); for (int i = 0; i < height; i++) { for (int j = 0; j < width; j++) { data1[heights[y] * size + widths[x] + i * size + j] = data2[i * width + j]; } } } } result.SetData(data1); return(result); }
public Level(Texture2D[,] tiles) { this.tiles = tiles; this.tileCols = tiles.GetLength(0); this.tileRows = tiles.GetLength(1); }
// constructor that reads fro a file map.cs public Map(ContentManager content, string filename, Camera c, Character player, List<Enemy> enemies, int screenWidth) { Texture2D empTexture = content.Load<Texture2D>("EmptyTile"); tileSize = screenWidth / 20; BinaryReader input = new BinaryReader(File.OpenRead("Content/" + filename)); int mapWidth = input.ReadInt32(); int mapHeight = input.ReadInt32(); tileMap = new Texture2D[mapWidth, mapHeight]; objectMap = new MapObject[mapWidth, mapHeight]; tileRot = new int[tileMap.GetLength(0), tileMap.GetLength(1)]; objRot = new int[tileMap.GetLength(0), tileMap.GetLength(1)]; for (int i = 0; i < tileMap.GetLength(0); i++) { for (int j = 0; j < tileMap.GetLength(1); j++) { string txtrString = input.ReadString(); if (!txtrString.Equals("null")) { Texture2D texture = content.Load<Texture2D>(txtrString); tileMap[i, j] = texture; } else { tileMap[i, j] = empTexture; } } } for (int i = 0; i < tileMap.GetLength(0); i++) { for (int j = 0; j < tileMap.GetLength(1); j++) { tileRot[i, j] = input.ReadInt32(); } } for (int i = 0; i < objectMap.GetLength(0); i++) { for (int j = 0; j < objectMap.GetLength(1); j++) { string txtrString = input.ReadString(); if (!txtrString.Equals("null")) { objectMap[i, j] = new MapObject(content, true, txtrString, i, j); } else { objectMap[i, j] = null; } } } for (int i = 0; i < objectMap.GetLength(0); i++) { for (int j = 0; j < objectMap.GetLength(1); j++) { objRot[i, j] = input.ReadInt32(); } } int entWidth = input.ReadInt32(); int entHieght = input.ReadInt32(); int[,] entRot = new int[entWidth, entHieght]; for (int i = 0; i < entRot.GetLength(0); i++) { for (int j = 0; j < entRot.GetLength(1); j++) { entRot[i, j] = input.ReadInt32(); } } for (int x = 0; x < entWidth; x++) { for (int y = 0; y < entHieght; y++) { string txtrString = input.ReadString(); if (txtrString.Equals("null")) { continue; } else if (txtrString.Equals("Enemy")) { CreateEnemy.CreateNormalEnemy(ref enemies, content, c, this, x, y, entRot[x,y] * -1.5708f); } else if (txtrString.Equals("RiotEnemy")) { CreateEnemy.CreateRiotEnemy(ref enemies, content, c, this, x, y, entRot[x, y] * -1.5708f); } } } string playerPos = input.ReadString(); string[] playerParts = playerPos.Split(','); double distX = player.Loc.X - double.Parse(playerParts[1]); double distY = player.Loc.Y - double.Parse(playerParts[2]); player.Loc.X -= distX; player.Loc.Y -= distY; c.camPos.X += distX; c.camPos.Y += distY; input.Close(); }