Ejemplo n.º 1
0
 public GridEditor(Game1 game, Levels.MapType type, Rectangle bounds, TilesSet sprites, int[,] grid,
                   Point position, OverlayGrid[] overlays, OverlayGrid[] underlays, int[,] selectionGrid, EditableGrid customInventory)
 {
     this.game            = game;
     this.bounds          = bounds;
     this.sprites         = sprites;
     map                  = new EditableGrid(bounds, grid, position, 8);
     this.type            = type;
     this.selectionGrid   = selectionGrid;
     this.customInventory = customInventory;
     GridEnabled          = true;
     // Load Inventory
     if (type != Levels.MapType.Minimap)
     {
         Point nbTiles = sprites.NumberTiles;
         int[,] inventoryGrid = new int[nbTiles.Y, nbTiles.X];
         int i = 0;
         for (int y = 0; y < nbTiles.Y; y++)
         {
             for (int x = 0; x < nbTiles.X; x++)
             {
                 inventoryGrid[y, x] = i;
                 i++;
             }
         }
         inventory = new EditableGrid(bounds, inventoryGrid, new Point(-8, -8), 16);
     }
     else
     {
         inventory = null;
     }
     Overlays  = overlays;
     Underlays = underlays;
 }
Ejemplo n.º 2
0
        void DrawGrid(SpriteBatch sprite_batch, int[,] grid, TilesSet sprites, bool overridePalette, bool showSpecial, Rectangle?ignoreArea = null)
        {
            Rectangle notIn = ignoreArea.HasValue ? ignoreArea.Value : Rectangle.Empty;
            int       h     = grid.GetLength(0);
            int       w     = grid.GetLength(1);

            for (int y = 0; y < h; y++)
            {
                for (int x = 0; x < w; x++)
                {
                    Rectangle dst = TileCoordToScreenRect(x, y);
                    if (dst.Intersects(bounds) && !dst.Intersects(notIn))
                    {
                        DrawTile(sprite_batch, sprites, dst, grid[y, x], overridePalette, showSpecial);
                    }
                }
            }
        }
Ejemplo n.º 3
0
        bool LoadGrid()
        {
            int[,] grid;
            List <GridEditor.OverlayGrid> underlays = new List <GridEditor.OverlayGrid>();
            List <GridEditor.OverlayGrid> overlays  = new List <GridEditor.OverlayGrid>();
            string world = Levels.GetWorldOfLevel(map);

            Levels.MapType mapType   = MapType();
            string         levelPath = Levels.GetLevelPath(map, mapType);

            if (!File.Exists(levelPath)) // Should only happen in Paradise
            {
                return(false);
            }
            if (mode == Mode.Minimap)
            {
                grid = Levels.GetGridFromLines(File.ReadAllLines(levelPath), 64, 64,
                                               Levels.TilesOffset(world, Levels.MapType.Minimap));
                sset = new TilesSet(Load.MinimapColors, false, _ssetBounds, 64);
            }
            else
            {
                Load.LoadWorldTiles(GraphicsDevice, world);
                grid = Levels.GetGridFromLines(File.ReadAllLines(levelPath), Levels.TilesOffset(world, mapType));
                sset = new TilesSet(Load.Tiles[new Load.WorldAndType(world, mapType)], true, _ssetBounds, 64);

                if (Settings.Paradise && mode == Mode.Physical)
                {
                    string   objectsPath = Levels.GetObjectsPath(map);
                    string[] objects     = File.Exists(objectsPath) ? File.ReadAllLines(objectsPath) : new string[0];
                    _paraPhysicalMapLogic = new ParadisePhysicalMapLogic(objects);
                }

                int[,] ogrid;
                TilesSet osset;
                if (mode != Mode.Background)
                {
                    try
                    {
                        ogrid = Levels.GetGridFromLines(File.ReadAllLines(Levels.GetLevelPath(map, Levels.MapType.Background)),
                                                        Levels.TilesOffset(world, Levels.MapType.Background));
                        osset = new TilesSet(Load.Tiles[new Load.WorldAndType(world, Levels.MapType.Background)],
                                             true, Rectangle.Empty, 0);
                        underlays.Add(new GridEditor.OverlayGrid(osset, ogrid, false));
                    }
                    catch { }
                }
                if (mode != Mode.Graphical2)
                {
                    try
                    {
                        ogrid = Levels.GetGridFromLines(File.ReadAllLines(Levels.GetLevelPath(map, Levels.MapType.Graphical2)),
                                                        Levels.TilesOffset(world, Levels.MapType.Graphical2));
                        osset = new TilesSet(Load.Tiles[new Load.WorldAndType(world, Levels.MapType.Graphical2)],
                                             true, Rectangle.Empty, 0);
                        if (mode == Mode.Background)
                        {
                            overlays.Add(new GridEditor.OverlayGrid(osset, ogrid, false));
                        }
                        else
                        {
                            underlays.Add(new GridEditor.OverlayGrid(osset, ogrid, false));
                        }
                    }
                    catch { }
                }
                if (mode != Mode.Graphical)
                {
                    try
                    {
                        ogrid = Levels.GetGridFromLines(File.ReadAllLines(Levels.GetLevelPath(map, Levels.MapType.Graphical)),
                                                        Levels.TilesOffset(world, Levels.MapType.Graphical));
                        osset = new TilesSet(Load.Tiles[new Load.WorldAndType(world, Levels.MapType.Graphical)],
                                             true, Rectangle.Empty, 0);
                        if (mode == Mode.Physical)
                        {
                            underlays.Add(new GridEditor.OverlayGrid(osset, ogrid, false));
                        }
                        else
                        {
                            overlays.Add(new GridEditor.OverlayGrid(osset, ogrid, false));
                        }
                    }
                    catch { }
                }
                if (mode != Mode.Physical)
                {
                    try
                    {
                        ogrid = Levels.GetGridFromLines(File.ReadAllLines(Levels.GetLevelPath(map, Levels.MapType.Physical)),
                                                        Levels.TilesOffset(world, Levels.MapType.Physical));
                        osset = new TilesSet(Load.Tiles[new Load.WorldAndType(world, Levels.MapType.Physical)],
                                             true, Rectangle.Empty, 0);
                        overlays.Add(new GridEditor.OverlayGrid(osset, ogrid, true));
                    }
                    catch { }
                }
            }

            int[,] selectionGrid = null;
            if (_lastMapType == mapType /*&& (_lastWorld == world || mapType == Levels.MapType.Physical || mapType == Levels.MapType.Minimap)*/)
            {
                // Sometimes, inter-world copy paste can be relevant even for grounds and backgrounds
                selectionGrid = _lastSelectionGrid;
            }
            editor = new GridEditor(this, MapType(), _gridEditorBounds,
                                    sset, grid, new Point(-8, -8), overlays.ToArray(), underlays.ToArray(), selectionGrid, _inventories.GetInventory(MapType()));
            return(true);
        }
Ejemplo n.º 4
0
 void DrawTile(SpriteBatch sprite_batch, TilesSet sprites, Rectangle dst, int tile, bool overridePalette, bool showSpecial)
 {
     if (type == Levels.MapType.Minimap)
     {
         sprites.Draw(sprite_batch, overridePalette ? sprites.SelectedSet : tile, 0, dst);
     }
     else
     {
         tile = overridePalette ? ChangePalette(tile, sprites.SelectedSet) : tile;
         int           tile_id = tile & 0x3FF;
         int           palette = (tile & 0xF000) >> 12;
         SpriteEffects effects =
             ((tile & 0x400) != 0 ? SpriteEffects.FlipHorizontally : SpriteEffects.None) |
             ((tile & 0x800) != 0 ? SpriteEffects.FlipVertically : SpriteEffects.None);
         if (showSpecial)
         {
             if (Settings.Paradise)
             {
                 if (tile_id >= PhysicalMapLogic.CONTROL_MIN_ID)
                 {
                     // Rendering of non-graphic special elements
                     Color?c = null;
                     if (ParadisePhysicalMapLogic.STARTING_ZONE_IDS.Contains(tile_id))
                     {
                         c = ParadisePhysicalMapLogic.StartingZoneColor(tile_id);
                     }
                     else if (ParadisePhysicalMapLogic.HEALING_ZONE_IDS.Contains(tile_id))
                     {
                         c = ParadisePhysicalMapLogic.HealingZoneColor(tile_id);
                     }
                     else if (ParadisePhysicalMapLogic.ENDING_ZONE_IDS.Contains(tile_id))
                     {
                         c = ParadisePhysicalMapLogic.EndingZoneColor(tile_id);
                     }
                     else if (ParadisePhysicalMapLogic.FIXED_OBJECTS_IDS.Contains(tile_id))
                     {
                         sprite_batch.Draw(ParadisePhysicalMapLogic.TextureOfFixedObjects(tile_id), dst, null, Color.White, 0, Vector2.Zero, effects, 0F);
                     }
                     else if (ParadisePhysicalMapLogic.MOVING_OBJECTS_IDS.Contains(tile_id)) // Flips have no effect on moving objects tiles
                     {
                         sprite_batch.Draw(ParadisePhysicalMapLogic.TextureOfMovingObject(tile_id), dst, null, Color.White, 0, Vector2.Zero, SpriteEffects.None, 0F);
                     }
                     else if (ParadisePhysicalMapLogic.NUMBER_TILES.Contains(tile)) // Palette and flips matters for numbers
                     {
                         sprite_batch.Draw(ParadisePhysicalMapLogic.TextureOfNumber(tile), dst, null, Color.White, 0, Vector2.Zero, SpriteEffects.None, 0F);
                     }
                     else
                     {
                         c = ParadisePhysicalMapLogic.UNSUPPORTED_COLOR;
                     }
                     if (c.HasValue)
                     {
                         sprite_batch.FillRectangle(dst, c.Value);
                     }
                 }
                 if (tile_id <= PhysicalMapLogic.VISIBLE_MAX_ID)
                 {
                     sprites.Draw(sprite_batch, palette, tile_id, dst, effects);
                 }
             }
             else
             {
                 if (tile_id >= PhysicalMapLogic.CONTROL_MIN_ID)
                 {
                     // Rendering of non-graphic special elements
                     Color?c = null;
                     if (PhysicalMapLogic.STARTING_ZONE_IDS.Contains(tile_id))
                     {
                         c = PhysicalMapLogic.StartingZoneColor(tile_id);
                     }
                     else if (PhysicalMapLogic.HEALING_ZONE_IDS.Contains(tile_id))
                     {
                         c = PhysicalMapLogic.HealingZoneColor(tile_id);
                     }
                     else if (PhysicalMapLogic.ENDING_ZONE_IDS.Contains(tile_id))
                     {
                         c = PhysicalMapLogic.EndingZoneColor(tile_id);
                     }
                     else if (PhysicalMapLogic.SPRING_IDS.Contains(tile_id))
                     {
                         sprite_batch.Draw(PhysicalMapLogic.TextureOfSpring(tile_id), dst, null, Color.White, 0, Vector2.Zero, effects, 0F);
                     }
                     else if (PhysicalMapLogic.VISIBLE_CONTROL_TILES.Contains(tile_id))
                     {
                         sprite_batch.Draw(PhysicalMapLogic.UnderlayOfVisibleControlTile(tile_id), dst, null, Color.White, 0, Vector2.Zero, effects, 0F);
                     }
                     else if (PhysicalMapLogic.MOVING_OBJECTS_IDS.Contains(tile_id)) // Flips have no effect on moving objects tiles
                     {
                         sprite_batch.Draw(PhysicalMapLogic.TextureOfMovingObject(tile_id), dst, null, Color.White, 0, Vector2.Zero, SpriteEffects.None, 0F);
                     }
                     else if (PhysicalMapLogic.NUMBER_TILES.Contains(tile)) // Palette and flips matters for numbers
                     {
                         sprite_batch.Draw(PhysicalMapLogic.TextureOfNumber(tile), dst, null, Color.White, 0, Vector2.Zero, SpriteEffects.None, 0F);
                     }
                     else
                     {
                         c = PhysicalMapLogic.UNSUPPORTED_COLOR;
                     }
                     if (c.HasValue)
                     {
                         sprite_batch.FillRectangle(dst, c.Value);
                     }
                 }
                 if (tile_id <= PhysicalMapLogic.VISIBLE_MAX_ID || PhysicalMapLogic.VISIBLE_CONTROL_TILES.Contains(tile_id))
                 {
                     sprites.Draw(sprite_batch, palette, tile_id, dst, effects);
                 }
             }
         }
         else
         {
             sprites.Draw(sprite_batch, palette, tile_id, dst, effects);
         }
     }
 }
Ejemplo n.º 5
0
 public OverlayGrid(TilesSet ts, int[,] grid, bool enabled)
 {
     this.ts      = ts;
     this.grid    = grid;
     this.enabled = enabled;
 }