Пример #1
0
        public MapCreationGrid(string id, Screen menu,
                               int layerIndex, ref TileMapDeffination tileMap)
            : base(id, menu)
        {
            bounds = new Rectangle(
                0, 0, 826, (int)Common.TextureQuality.Y);

            this.layerIndex = layerIndex;
            this.tileMap    = tileMap;

            TileLayerDeffination layer = tileMap.GetByOrder(layerIndex);

            if (layer.Tiles == null)
            {
                layer.Tiles = new List <int[]>();
                layer.Tiles.Add(new int[] { -1 });

                layer.TileOffset = Vector2.One;
            }
            else
            {
                loaded = true;
            }

            grid = new Grid(ID + "Grid", Vector2.Zero, layer.Tiles[0].Length,
                            layer.Tiles.Count, (int)layer.TileSize.X,
                            (int)layer.TileSize.Y, 1, false);

            AttachComponent(grid);

            DrawingManager.Add(this);
        }
Пример #2
0
        void CreateSourceRectangles()
        {
            sourceRects.Clear();
            currentSourceIndex = 0;

            TileLayerDeffination layer = tileMap.GetByOrder(layerIndex);

            int columns = layer.Columns;
            int rows    = layer.Rows;

            if (tileSheet == null)
            {
                tileSheet = Common.ContentBuilder.Load <Texture2D>(
                    layer.TileSheetFilepath);
            }

            int width  = tileSheet.Width / columns;
            int height = tileSheet.Height / rows;

            Rectangle rect = new Rectangle(0, 0, width, height);

            for (int y = 0; y < rows; y++)
            {
                for (int x = 0; x < columns; x++)
                {
                    sourceRects.Add(rect);

                    rect.X += width;
                }

                rect.X  = 0;
                rect.Y += height;
            }
        }
Пример #3
0
        public TileLayer(int drawLayer, bool postRender,
                         TileLayerDeffination tileLayerDeffination)
        {
            this.drawLayer  = drawLayer;
            this.postRender = postRender;

            tileDeff = tileLayerDeffination;
            offset   = tileDeff.TileOffset;
        }
Пример #4
0
        /// <summary>
        /// Changes a Tile.Index to -1.
        /// </summary>
        public void Remove()
        {
            Tile cel = cells[tileIndex];

            cel.Index = -1;

            cells[tileIndex] = cel;

            TileLayerDeffination layer = tileMap.GetByOrder(layerIndex);

            layer.SetIndex(-1, cel.Row, cel.Column);
        }
Пример #5
0
        void TilesChangeClicked(string controlID)
        {
            TileLayerDeffination layer = tileMap.GetByOrder(currentLayer);

            switch (controlID)
            {
            case "btnTilesXPlus":
            {
                int parse = int.Parse(txtTilesX.Text);
                parse++;

                txtTilesX.Text = parse + "";
                layer.UpdateTiles(parse, true);
            }
            break;

            case "btnTilesXMinus":
            {
                int parse = int.Parse(txtTilesX.Text);
                parse--;

                if (parse >= 0)
                {
                    txtTilesX.Text = parse + "";
                    layer.UpdateTiles(parse, true);
                }
            }
            break;

            case "btnTilesYPlus":
            {
                int parse = int.Parse(txtTilesY.Text);
                parse++;

                txtTilesY.Text = parse + "";
                layer.UpdateTiles(parse, false);
            }
            break;

            case "btnTilesYMinus":
            {
                int parse = int.Parse(txtTilesY.Text);
                parse--;

                if (parse >= 0)
                {
                    txtTilesY.Text = parse + "";
                    layer.UpdateTiles(parse, false);
                }
            }
            break;
            }
        }
Пример #6
0
        public override void CheckClick()
        {
            TileLayerDeffination layer = tileMap.GetByOrder(layerIndex);

            Tile cel = cells[tileIndex];

            cel.Index = currentSourceIndex;

            cells[tileIndex] = cel;

            layer.SetIndex(currentSourceIndex, cel.Row, cel.Column);

            base.CheckClick();
        }
Пример #7
0
        void AddLayer()
        {
            TileLayerDeffination layer = new TileLayerDeffination()
            {
                Order    = currentLayer,
                Columns  = grid.Columns,
                Rows     = grid.Rows,
                TileSize = new Vector2(float.Parse(txtSizeX.Text),
                                       float.Parse(txtSizeY.Text)),
                TileOffset        = -new Vector2(2),
                TileSheetFilepath = grid.TileSheetFilepath,
                NormalMapFilepath = grid.NormalMapFilepath
            };

            tileMap.AddTileLayer(layer);

            mapCreator.AddLayer(currentLayer);
            mapCreator.ChangeLayer(currentLayer);
        }
Пример #8
0
        protected override void Update()
        {
            TileLayerDeffination layer = tileMap.GetByOrder(layerIndex);

            if (layer.Rows * layer.Columns != sourceRects.Count)
            {
                CreateSourceRectangles();
            }

            if ((int)layer.TileSize.X != cells[0].Bounds.Width ||
                (int)layer.TileSize.Y != cells[0].Bounds.Height)
            {
                CreateCells(false);
            }

            if (layer.Tiles.Count * layer.Tiles[0].Length != cells.Count)
            {
                CreateCells(true);
            }

            base.Update();
        }
Пример #9
0
        void CreateCells(bool recreate)
        {
            if (recreate)
            {
                cells.Clear();
            }

            Vector2 initialPos = Vector2.Zero;
            int     count      = 0;

            TileLayerDeffination layer = tileMap.GetByOrder(layerIndex);

            for (int y = 0; y < layer.Tiles.Count; y++)
            {
                for (int x = 0; x < layer.Tiles[0].Length; x++)
                {
                    if (recreate)
                    {
                        Tile t = new Tile()
                        {
                            Bounds = new Rectangle()
                            {
                                X      = (int)initialPos.X,
                                Y      = (int)initialPos.Y,
                                Width  = (int)layer.TileSize.X,
                                Height = (int)layer.TileSize.Y
                            },

                            Column = x,
                            Row    = y
                        };

                        if (loaded)
                        {
                            t.Index = layer.Tiles[y][x];
                        }
                        else
                        {
                            t.Index = -1;
                        }

                        cells.Add(t);
                    }
                    else
                    {
                        Tile c = cells[count];
                        c.Bounds = new Rectangle()
                        {
                            X      = (int)initialPos.X,
                            Y      = (int)initialPos.Y,
                            Width  = (int)layer.TileSize.X,
                            Height = (int)layer.TileSize.Y
                        };

                        cells[count] = c;
                    }

                    initialPos.X += layer.TileSize.X;

                    count++;
                }

                initialPos.X  = 0;
                initialPos.Y += layer.TileSize.Y;
            }

            grid.CellSizeX = (int)layer.TileSize.X;
            grid.CellSizeY = (int)layer.TileSize.Y;

            grid.Columns = layer.Tiles[0].Length;
            grid.Rows    = layer.Tiles.Count;

            CameraManager2D.CurrentCamera.SetConstraint(
                new Rectangle(0, 0, grid.Width, grid.Height));

            CreateChunks();
        }
Пример #10
0
        void TextChanged(string controlID, string text)
        {
            int value = 0;

            TileLayerDeffination layer = tileMap.GetByOrder(currentLayer);

            if (int.TryParse(text, out value))
            {
                switch (controlID)
                {
                case "txtRows":
                {
                    grid.Rows = value;

                    if (layer != null)
                    {
                        layer.Rows = value;
                    }
                }
                break;

                case "txtCols":
                {
                    grid.Columns = value;

                    if (layer != null)
                    {
                        layer.Columns = value;
                    }
                }
                break;

                case "txtSizeX":
                {
                    if (layer != null)
                    {
                        layer.TileSize.X = value;
                    }
                }
                break;


                case "txtSizeY":
                {
                    if (layer != null)
                    {
                        layer.TileSize.Y = value;
                    }
                }
                break;

                case "txtTilesX":
                {
                    if (layer != null)
                    {
                        layer.UpdateTiles(value, true);
                    }
                }
                break;

                case "txtTilesY":
                {
                    if (layer != null)
                    {
                        layer.UpdateTiles(value, false);
                    }
                }
                break;
                }
            }
        }
Пример #11
0
        void SetControlData(int index)
        {
            if (index != -1)
            {
                TileLayerDeffination layer = tileMap.GetByOrder(index);

                txtCols.Text  = layer.Columns + "";
                txtRows.Text  = layer.Rows + "";
                txtSizeX.Text = layer.TileSize.X + "";
                txtSizeY.Text = layer.TileSize.Y + "";

                if (layer.Tiles != null)
                {
                    txtTilesX.Text = layer.Tiles[0].Length + "";
                    txtTilesY.Text = layer.Tiles.Count + "";
                }
                else
                {
                    txtTilesX.Text = "1";
                    txtTilesY.Text = "1";
                }

                grid.Columns = layer.Columns;
                grid.Rows    = layer.Rows;

                if (layer.NormalMapFilepath != "")
                {
                    grid.NormalMapFilepath = layer.NormalMapFilepath;
                }
                else
                {
                    grid.NormalMapFilepath = "null";
                }

                if (layer.TileSheetFilepath != "")
                {
                    grid.TileSheetFilepath = layer.TileSheetFilepath;
                }
                else
                {
                    grid.TileSheetFilepath = "null";
                }

                grid.SetSourceIndex(0);
            }
            else
            {
                txtCols.Text = "1";
                txtRows.Text = "1";

                txtSizeX.Text = "128";
                txtSizeY.Text = "128";

                txtTilesX.Text = "1";
                txtTilesY.Text = "1";

                grid.Columns = 1;
                grid.Rows    = 1;

                grid.TileSheetFilepath = "null";
                grid.NormalMapFilepath = "null";

                grid.SetSourceIndex(0);
            }
        }