private GameObjectType ParseTileNode(XmlNode tileNode, Project project, Dictionary <int, object> objectIdDictionary)
        {
            ImageObject2DType tile = new ImageObject2DType();

            tile.Name = tileNode.Attributes["name"].Value;
            int id     = Convert.ToInt32(tileNode.Attributes["id"].Value);
            int height = Convert.ToInt32(tileNode.Attributes["height"].Value);
            int width  = Convert.ToInt32(tileNode.Attributes["width"].Value);

            objectIdDictionary[id] = tile;
            Bitmap image = new Bitmap(width, height);

            foreach (XmlNode childNode in tileNode.ChildNodes)
            {
                if (childNode.Name == "contents")
                {
                    byte[] binaryData = Convert.FromBase64String(childNode.InnerText);

                    for (int row = 0; row < height; row++)
                    {
                        for (int column = 0; column < width; column++)
                        {
                            byte red   = binaryData[(column + row * image.Width) * 4 + 0];
                            byte green = binaryData[(column + row * image.Width) * 4 + 1];
                            byte blue  = binaryData[(column + row * image.Width) * 4 + 2];
                            byte alpha = binaryData[(column + row * image.Width) * 4 + 3];

                            System.Drawing.Color color = System.Drawing.Color.FromArgb(alpha, red, green, blue);

                            image.SetPixel(column, row, color);
                        }
                    }
                }
            }

            tile.Image = image;

            return(tile);
        }
예제 #2
0
        private void AddType()
        {
            if (imageFileDialog == null)
            {
                imageFileDialog             = new OpenFileDialog();
                imageFileDialog.Filter      = "Image Files|*.png;*.jpg;*.jpeg;*.bmp;*.tga;*.tif;*.gif|All Files|*.*";
                imageFileDialog.Multiselect = true;
            }

            if (imageFileDialog.ShowDialog() == System.Windows.Forms.DialogResult.OK)
            {
                string[] imageFiles = imageFileDialog.FileNames;

                foreach (string imageFile in imageFiles)
                {
                    Project.AddType(ImageObject2DType.FromFile(imageFile));
                }

                BuildTypeList();
                SelectType(Project.Types.Count - 1);

                AddUndoRedoState();
            }
        }
예제 #3
0
        protected override void OnPaint(PaintEventArgs e)
        {
            base.OnPaint(e);

            ImageObject2DType imageObject = (ImageObject2DType)this.ImageObject;

            try
            {
                e.Graphics.FillRectangle(new SolidBrush(Color.FromArgb(235, 235, 235)), new Rectangle(0, 0, Width, Height));
                e.Graphics.FillRectangle(new SolidBrush(Color.FromArgb(180, 180, 180)), new Rectangle(1, 1, Bounds.Width - 1, Bounds.Height - 1));
                e.Graphics.FillRectangle(new SolidBrush(Color.FromArgb(255, 255, 255)), new Rectangle(0, 0, Bounds.Width - 1, Bounds.Height - 1));
                if (IsUtilityItem)
                {
                    e.Graphics.FillRectangle(new SolidBrush(Color.FromArgb(200, 200, 200)), new Rectangle(0, 0, Bounds.Width - 1, Bounds.Height - 1));
                }

                int itemHeight = this.Height - 3;

                double scale = Math.Min((double)itemHeight / imageObject.Image.Width, (double)itemHeight / imageObject.Image.Height);
                if (scale > 1)
                {
                    scale = 1;
                }

                Rectangle imageBounds = new Rectangle(
                    (int)(1 + itemHeight / 2 - imageObject.Image.Width / 2 * scale),
                    (int)(1 + itemHeight / 2 - imageObject.Image.Height / 2 * scale),
                    (int)(imageObject.Image.Width * scale),
                    (int)(imageObject.Image.Height * scale));

                e.Graphics.DrawImage(imageObject.Image, imageBounds);

                SizeF size = e.Graphics.MeasureString(imageObject.Name, Font);

                if (Selected || Hovered)
                {
                    e.Graphics.DrawRectangle(new Pen(new SolidBrush(Color.Green), 2), new Rectangle(1, 1, Bounds.Width - 3, Bounds.Height - 3));
                    e.Graphics.DrawRectangle(new Pen(new SolidBrush(Color.White), 2), new Rectangle(3, 3, Bounds.Width - 7, Bounds.Height - 7));
                }

                if (DisplayMode == UserInterface.DisplayMode.ImageAndName)
                {
                    Rectangle rectangleBounds = new Rectangle(Bounds.X + 3, Bounds.Y + 3, Bounds.Width - 6, Bounds.Height - 6);
                    Font      font            = new Font("Segoe UI", 10, FontStyle.Regular);
                    string    text            = (string)imageObject.Name;
                    size = e.Graphics.MeasureString(text, font);

                    int  x           = imageBounds.Right + 2;
                    int  y           = (int)((Bounds.Height - size.Height) / 2);
                    bool addEllipsis = false;

                    while (size.Width + x + 2 > Bounds.Width)
                    {
                        addEllipsis = true;
                        text        = text.Substring(0, text.Length - 1);
                        size        = e.Graphics.MeasureString(text + "...", font);
                    }

                    if (addEllipsis)
                    {
                        text += "...";
                    }

                    e.Graphics.DrawString(text, font, new SolidBrush(Color.FromArgb(150, 150, 150)), new Point(x, y));
                }
            }
            catch (Exception)
            {
            }
        }
예제 #4
0
        private void levelRenderer_MouseMove(object sender, MouseEventArgs e)
        {
            if (!mouseStartedInRenderer)
            {
                return;
            }

            if (e.Button == System.Windows.Forms.MouseButtons.Left)
            {
                if (levelListBox.SelectedItem == null)
                {
                    return;
                }

                Level             activeLevel = (Level)levelListBox.SelectedItem;
                ImageObject2DType activeType  = (ImageObject2DType)objectPalette.SelectedItem;

                if (ActiveTool == Tool.Pencil)
                {
                    Point position = new Point(e.X, e.Y);
                    int   row      = position.Y / activeLevel.Settings.CellHeight;
                    int   column   = position.X / activeLevel.Settings.CellWidth;

                    if (row < 0)
                    {
                        return;
                    }
                    if (row >= activeLevel.Settings.Rows)
                    {
                        return;
                    }

                    if (column < 0)
                    {
                        return;
                    }
                    if (column >= activeLevel.Settings.Columns)
                    {
                        return;
                    }

                    ImageObject2D type = (ImageObject2D)activeLevel.Get(column, row);

                    if (type == null || type.ParentType != activeType)
                    {
                        activeLevel.Put(activeType == null ? null : activeType.GenerateNew(), column, row);
                        levelRenderer.Refresh();
                        somethingChanged = true;
                    }
                }
                if (ActiveTool == Tool.Eraser)
                {
                    Point position = new Point(e.X, e.Y);
                    int   row      = position.Y / activeLevel.Settings.CellHeight;
                    int   column   = position.X / activeLevel.Settings.CellWidth;

                    if (row < 0)
                    {
                        return;
                    }
                    if (row >= activeLevel.Settings.Rows)
                    {
                        return;
                    }

                    if (column < 0)
                    {
                        return;
                    }
                    if (column >= activeLevel.Settings.Columns)
                    {
                        return;
                    }

                    GameObject gameObject = activeLevel.Get(column, row);
                    if (gameObject != null)
                    {
                        activeLevel.Erase(column, row);
                        levelRenderer.Refresh();
                        somethingChanged = true;
                    }
                }
            }
        }
예제 #5
0
        private void levelRenderer_MouseDown(object sender, MouseEventArgs e)
        {
            if (levelListBox.SelectedItem == null)
            {
                return;
            }

            mouseStartedInRenderer = true;

            Level             activeLevel = (Level)levelListBox.SelectedItem;
            ImageObject2DType activeType  = (ImageObject2DType)objectPalette.SelectedItem;

            if (ActiveTool == Tool.Pencil)
            {
                Point position = new Point(e.X, e.Y);
                int   row      = position.Y / activeLevel.Settings.CellHeight;
                int   column   = position.X / activeLevel.Settings.CellWidth;

                if (row < 0)
                {
                    return;
                }
                if (row >= activeLevel.Settings.Rows)
                {
                    return;
                }

                if (column < 0)
                {
                    return;
                }
                if (column >= activeLevel.Settings.Columns)
                {
                    return;
                }

                ImageObject2D type = (ImageObject2D)activeLevel.Get(column, row);
                if (type == null || type.ParentType != activeType)
                {
                    if (type != null && !project.Types.Contains(activeType))
                    {
                        throw new Exception("type not in project");
                    }
                    activeLevel.Put(type == null ? null : activeType.GenerateNew(), column, row);
                    levelRenderer.Refresh();
                    somethingChanged = true;
                }
            }
            if (ActiveTool == Tool.Eraser)
            {
                Point position = new Point(e.X, e.Y);
                int   row      = position.Y / activeLevel.Settings.CellHeight;
                int   column   = position.X / activeLevel.Settings.CellWidth;

                if (row < 0)
                {
                    return;
                }
                if (row >= activeLevel.Settings.Rows)
                {
                    return;
                }

                if (column < 0)
                {
                    return;
                }
                if (column >= activeLevel.Settings.Columns)
                {
                    return;
                }

                ImageObject2D type = (ImageObject2D)activeLevel.Get(column, row);
                if (type != null)
                {
                    activeLevel.Erase(column, row);
                    levelRenderer.Refresh();
                    somethingChanged = true;
                }
            }
            if (ActiveTool == Tool.Bucket)
            {
                Point position = new Point(e.X, e.Y);
                int   row      = position.Y / activeLevel.Settings.CellHeight;
                int   column   = position.X / activeLevel.Settings.CellWidth;

                if (row < 0)
                {
                    return;
                }
                if (row >= activeLevel.Settings.Rows)
                {
                    return;
                }

                if (column < 0)
                {
                    return;
                }
                if (column >= activeLevel.Settings.Columns)
                {
                    return;
                }

                if (activeLevel.Get(column, row) == null || activeLevel.Get(column, row).ParentType != activeType)
                {
                    Fill(activeLevel, row, column, activeLevel.Get(column, row), activeType.GenerateNew());
                }

                levelRenderer.Refresh();

                somethingChanged = true;
            }
        }