private int[] CalcMask(Sprite s, out int width, out int height) { width = 0; height = 0; if (s == null) return null; // Calc # of int32s required. int xsize = ((s.PixelWidth + MaskWordWidth-1) / MaskWordWidth); int ysize = s.PixelHeight; int size = xsize * ysize; int[] mask = new int[size]; for (int y = 0; y < ysize; y++) { for (int x = 0; x < xsize; x++) { int index = y * xsize + x; mask[index] = 0; for (int i = 0; i < MaskWordWidth; i++) { mask[index] <<= 1; if (x * MaskWordWidth + i < s.PixelWidth) { if (s.GetPixel(x * MaskWordWidth + i, y) != 0) mask[index] |= 1; } } } } width = xsize; height = ysize; return mask; }
public MapForm(ProjectMainForm parent, Map m, Spriteset ss, Sprite s) { m_parent = parent; m_ss = ss; InitializeComponent(); SetMap(m); m_toolbox = new Toolbox_Map(); m_optionbox = new Optionbox_Map(); MdiParent = parent; FormBorderStyle = FormBorderStyle.SizableToolWindow; StartPosition = FormStartPosition.Manual; Visible = false; ControlBox = false; // Set to 16x. cbZoom.SelectedIndex = (int)ZoomLevel.Zoom_16x; cbZoom.Enabled = false; m_tileSpriteX = -1; m_tileSpriteY = -1; }
private void bNext_Click(object sender, EventArgs e) { Sprite s = m_ss.NextSprite(m_sprite); if (s != null) { m_sprite = s; UpdateSpriteInfo(); } }
public Tile(Sprite s, int nTileId) { m_sprite = s; m_id = nTileId; m_data = new UndoData(TileSize); // This will be assigned when the spriteset is saved or exported. m_nExportId = 0; }
public UndoAction_AddSprite(UndoMgr mgr, Spriteset ss, Sprite sprite, bool fAdd) { m_mgr = mgr; m_ss = ss; m_sprite = sprite; m_fAdd = fAdd; Description = (fAdd ? "AddSprite " : "RemoveSprite ") + sprite.Name; }
public SpriteProperties(Document doc, Spriteset ss) { InitializeComponent(); m_doc = doc; m_ss = ss; m_sprite = m_ss.CurrentSprite; UpdateSpriteInfo(); }
public SpriteType(string strName, int nWidth, int nHeight, Sprite.GBASize size, Sprite.GBAShape shape) { Name = strName; Width = nWidth; Height = nHeight; Size = size; Shape = shape; Sprites = new List<Sprite>(); ScrollHeight = 0; FirstLine = 0; }
public UndoAction_SpriteEdit(UndoMgr mgr, Spriteset ss, Sprite sprite, Sprite.UndoData before, Sprite.UndoData after, string strDesc) { m_mgr = mgr; m_ss = ss; m_sprite = sprite; m_before = new Sprite.UndoData(before); m_after = new Sprite.UndoData(after); Description = "SpriteEdit " + sprite.Name + " " + strDesc; if (IsPaletteChange()) Description += " " + before.subpalette + " to " + after.subpalette; }
public CollisionTest(Document d) { m_doc = d; InitializeComponent(); xOffset = 0; yOffset = 0; ss = d.Owner.ActiveSpriteset(); s1 = ss.CurrentSprite; s2 = ss.NextSprite(s1); mask1 = CalcMask(s1, out mask1w, out mask1h); mask2 = CalcMask(s2, out mask2w, out mask2h); CollisionCheck(); }
private void FloodFill_CheckTile(int x, int y, Sprite spriteOld, int subpaletteOld) { if (x >= 0 && x < m_map.Width && y >= 0 && y < m_map.Height) { int tile, subpalette; m_map.GetTile(x, y, out tile, out subpalette); Sprite sprite = m_ss.FindSprite(tile); if (sprite == spriteOld && subpalette == subpaletteOld) { TileCoord t = new TileCoord(x, y); if (!m_tilesDone.ContainsKey(t)) { m_stackTiles.Push(t); m_tilesDone.Add(t, true); } } } }
// Is this the last sprite in the SpriteList? public bool IsLastSprite(Sprite sBase) { bool fIsLast = false; foreach (SpriteType st in SpriteTypes) { foreach (Sprite s in st.Sprites) { fIsLast = (s == sBase); } } return fIsLast; }
public void Duplicate(Tile tileToCopy) { CopyData(tileToCopy); m_sprite = tileToCopy.m_sprite; }
/// <summary> /// Replace all occurences of this sprite in the background map with the /// default sprite. /// </summary> /// <param name="s"></param> public void RemoveSpriteTilesFromMap(Sprite sToRemove) { for (int ix = 0; ix < kMaxMapTilesX; ix++) { for (int iy = 0; iy < kMaxMapTilesY; iy++) { int nTile = m_BackgroundMap[ix, iy].nTileIndex; int nSpriteTile1 = sToRemove.FirstTileId; int nSpriteTileN = sToRemove.FirstTileId + sToRemove.NumTiles-1; if (nTile >= nSpriteTile1 && nTile <= nSpriteTileN) m_BackgroundMap[ix, iy].nTileIndex = -1; } } }
// Remove from the old SpriteType and add it to the new one public void MoveToCorrectSpriteType(Sprite sprite) { SpriteType stRemove = null; SpriteType stAdd = null; foreach (SpriteType st in SpriteTypes) { if (st.Sprites.Contains(sprite)) stRemove = st; if (st.Width == sprite.TileWidth && st.Height == sprite.TileHeight) stAdd = st; } if (stRemove != stAdd) { if (stRemove != null) stRemove.Sprites.Remove(sprite); if (stAdd != null) stAdd.Sprites.Add(sprite); m_doc.Owner.HandleSpriteTypeChanged(this); } }
// Return the next sprite after the given sprite in the SpriteList. // Returns null if the given sprite is the last one, or if the given sprite doesn't exist. public Sprite NextSprite(Sprite sBase) { bool fReturnNextSprite = false; foreach (SpriteType st in SpriteTypes) { foreach (Sprite s in st.Sprites) { if (fReturnNextSprite) return s; if (s == sBase) fReturnNextSprite = true; } } return null; }
// Return true if successfully rotated. public bool RotateSelectedSprite(Sprite.RotateDirection dir) { Sprite sToRotate = CurrentSprite; if (sToRotate == null) return false; int tileNewWidth = sToRotate.TileHeight; int tileNewHeight = sToRotate.TileWidth; if (!sToRotate.Rotate(dir)) return false; MoveToCorrectSpriteType(sToRotate); return true; }
/// <summary> /// Draw a sample sprite for use in the tutorials. /// </summary> /// <param name="s"></param> private void DrawSample4x1Sprite(Sprite s, int id) { if (id == 1) DrawSampleSprite(s, 32, 8, m_Bat1); else DrawSampleSprite(s, 32, 8, m_Bat0); }
// Return the previous sprite before the given sprite in the SpriteList. // Returns null if the given sprite is the first one, or if the given sprite doesn't exist. public Sprite PrevSprite(Sprite sBase) { Sprite sPrev = null; foreach (SpriteType st in SpriteTypes) { foreach (Sprite s in st.Sprites) { if (s == sBase) return sPrev; sPrev = s; } } return null; }
// Is this the first sprite in the SpriteList? public bool IsFirstSprite(Sprite sBase) { foreach (SpriteType st in SpriteTypes) { foreach (Sprite s in st.Sprites) { return s == sBase; } } return false; }
/// <summary> /// Copy the tile data from the specified sprite /// </summary> /// <param name="sToCopy">Sprite to copy</param> public void CopyData(Sprite sToCopy) { // Make sure that the sprites have the same dimensions if (TileWidth != sToCopy.TileWidth || TileHeight != sToCopy.TileHeight) return; // Copy over the tile data for (int i = 0; i < NumTiles; i++) m_Tiles[i].CopyData(sToCopy.m_Tiles[i]); }
private Sprite AddSprite_2(Sprite s, List<Sprite> slist, UndoMgr undo) { slist.Add(s); m_nSprites++; m_nTiles += (s.TileWidth * s.TileHeight); if (undo != null) undo.Push(new UndoAction_AddSprite(undo, this, s, true)); if (m_doc.Owner != null) m_doc.Owner.HandleSpriteTypeChanged(this); return s; }
private Sprite AddSprite_(int nWidth, int nHeight, string strName, int id, string strDesc, int nSubpalette, UndoMgr undo) { List<Sprite> slist = null; // Make sure that the requested size is valid. foreach (SpriteType st in SpriteTypes) { if (st.Width == nWidth && st.Height == nHeight) slist = st.Sprites; } // Invalid sprite size - return. if (slist == null) return null; Sprite s = new Sprite(m_doc, this, nWidth, nHeight, strName, id, strDesc, nSubpalette); return AddSprite_2(s, slist, undo); }
private bool FloodFill_Sprite(int nMapX, int nMapY, Sprite spriteOld, int subpaletteOld, Sprite spriteNew, int tileNew, int subpaletteNew) { int spriteWidth = spriteNew == null ? 1 : spriteNew.TileWidth; int spriteHeight = spriteNew == null ? 1 : spriteNew.TileHeight; // Stack of tiles to process. m_stackTiles = new Stack<TileCoord>(); m_tilesDone = new Dictionary<TileCoord, bool>(); TileCoord t = new TileCoord(nMapX, nMapY); m_stackTiles.Push(t); m_tilesDone.Add(t, true); // Adjust the mapclick origin off the map (negative) so that all of our // offset calculations are guaranteed to be positive. while (nMapX > 0) nMapX -= spriteWidth; while (nMapY > 0) nMapY -= spriteHeight; while (m_stackTiles.Count != 0) { t = m_stackTiles.Pop(); // Calc tile within sprite that we're painting: // // Current sprite: abcd // efgh // // Original: Click: After: // ___...___ ___...___ ___efg___ // __.....__ __.x...__ __dabcd__ // __...____ __...____ __hef____ // ____.____ ____.____ ____b____ // // '.' marks the map coords that belong to the same sprite // (regardless of the particular tile within the sprite). int dx = (t.X - nMapX) % spriteWidth; int dy = (t.Y - nMapY) % spriteHeight; int tile = tileNew + dx + dy * spriteWidth; m_map.SetTile(t.X, t.Y, tile, subpaletteNew); FloodFill_CheckTile(t.X - 1, t.Y, spriteOld, subpaletteOld); FloodFill_CheckTile(t.X + 1, t.Y, spriteOld, subpaletteOld); FloodFill_CheckTile(t.X, t.Y - 1, spriteOld, subpaletteOld); FloodFill_CheckTile(t.X, t.Y + 1, spriteOld, subpaletteOld); } m_stackTiles = null; m_tilesDone = null; return true; }
private void DrawSampleSprite(Sprite s, int width, int height, int[,] data) { for (int y = 0; y < height; y++) { for (int x = 0; x < width; x++) { s.SetPixel(x, y, data[y, x]); } } }
/// <summary> /// Is this sprite the first/last one in the group of SpriteTypes /// </summary> /// <param name="sprite">The sprite to check</param> /// <param name="fIsFirst">Returns true if this is the first sprite</param> /// <param name="fIsLast">Returns true if this is the last sprite</param> public void IsFirstLastSpriteOfType(Sprite sprite, out bool fIsFirst, out bool fIsLast) { fIsFirst = false; fIsLast = false; foreach (SpriteType st in SpriteTypes) { if (st.Sprites.Contains(sprite)) { bool fFirst = true; bool fLast = false; foreach (Sprite s in st.Sprites) { if (s == sprite) { if (fFirst) fIsFirst = true; fLast = true; } else fLast = false; fFirst = false; } if (fLast) fIsLast = true; return; } } }
public void RemoveSprite(Sprite sToRemove, UndoMgr undo) { SpriteType stToRemove = null; Sprite sPrev = null, sCurr = null, sNext = null; Sprite sNewSelection = null; if (sToRemove == null) return; // Determine which sprite should be selected when this one is removed. foreach (SpriteType st in SpriteTypes) { if (sNewSelection != null) break; foreach (Sprite s in st.Sprites) { sPrev = sCurr; sCurr = sNext; sNext = s; if (s == sToRemove) stToRemove = st; if (sCurr == sToRemove) { sNewSelection = sNext; break; } } } // If the last sprite is deleted, select the one before it. if (sNext == sToRemove) sNewSelection = sCurr; int nTiles = sToRemove.NumTiles; if (stToRemove == null) return; if (stToRemove.Sprites.Remove(sToRemove)) { CurrentSprite = null; if (undo != null) CurrentSprite = undo.FindMostRecentSprite(); if (CurrentSprite == null) CurrentSprite = sNewSelection; m_nSprites--; m_nTiles -= nTiles; if (undo != null) undo.Push(new UndoAction_AddSprite(undo, this, sToRemove, false)); if (m_doc.Owner != null) m_doc.Owner.HandleSpriteTypeChanged(this); } foreach (Map m in m_Maps) { m.RemoveSpriteTilesFromMap(sToRemove); } }
public void Duplicate(Sprite sToCopy) { CopyData(sToCopy); SubpaletteID = sToCopy.SubpaletteID; }
/// <summary> /// Draw a sample sprite for use in the tutorials. /// </summary> /// <param name="s"></param> private void DrawSample1x1Sprite(Sprite s, int id) { DrawSampleSprite(s, 8, 8, m_Ball); }
private bool LoadXML_OLD_sprite(Sprite s, XmlNodeList xnl) { int nNumTiles = s.NumTiles; int nTileIndex = 0; foreach (XmlNode xn in xnl) { if (xn.Name == "tile") { if (nTileIndex >= nNumTiles) { // too many tiles in sprite m_doc.ErrorString("Too many tiles specified for sprite '{0}' (expected {1})", s.Name, nNumTiles); return false; } uint[] bTile = new uint[32]; int nCurrByte = 0; Regex rxTile = new Regex(@"\s*0x([0-9A-Fa-f]{2})\s*,"); Match mxTile = rxTile.Match(xn.InnerText); if (mxTile.Success) { while (mxTile.Success) { GroupCollection matchGroups = mxTile.Groups; if (nCurrByte >= 32) { // too many data bytes in tile m_doc.ErrorString("Too many data bytes in tile #{0} of sprite '{0}'", nTileIndex, s.Name); return false; } bTile[nCurrByte] = Convert.ToUInt32(matchGroups[1].Value, 16); nCurrByte++; if (nCurrByte == 32) { // After we've read 32 bytes, import the tile into the sprite. if (!s.ImportTile32(nTileIndex, bTile)) { // Warning/Error message already displayed. return false; } nTileIndex++; } // Get the next match. mxTile = mxTile.NextMatch(); } } if (nCurrByte != 32) { // too few data bytes for tile m_doc.ErrorString("Too few data bytes in tile #{0} of sprite '{0}'", nTileIndex, s.Name); return false; } } } if (nTileIndex != s.NumTiles) { // incorrect number of tiles for this sprite - too few m_doc.ErrorString("Too few tiles specified for sprite '{0}' (expected {1})", s.Name, nNumTiles); return false; } return true; }
/// <summary> /// Draw a sample sprite for use in the tutorials. /// </summary> /// <param name="s"></param> private void DrawSample2x2Sprite(Sprite s, int id) { if (id == 2) DrawSampleSprite(s, 16, 16, m_Blobber2); else if (id == 1) DrawSampleSprite(s, 16, 16, m_Blobber1); else DrawSampleSprite(s, 16, 16, m_Blobber0); }