Example #1
0
 private void onEntityChanged(EntityDefinition definition)
 {
     if (definition == Definition)
     {
         entityNameLabel.BackColor = Selected;
         Select();
     }
     else
         entityNameLabel.BackColor = NotSelected;
 }
Example #2
0
        public void SetObject(EntityDefinition def)
        {
            if (CurrentEntity == def)
                return;

            CurrentEntity = def;

            //Call the event
            if (OnEntityChanged != null)
                OnEntityChanged(def);
        }
Example #3
0
        public EntityButton(EntityDefinition definition, int x, int y)
        {
            Definition = definition;
            InitializeComponent();
            Location = new Point(x, y);
            toolTip.SetToolTip(this, definition.Name);

            pictureBox.BackgroundImage = Definition.Image;
            pictureBox.BackgroundImageLayout = ImageLayout.Zoom;

            entityNameLabel.Text = definition.Name;
            entityNameLabel.BackColor = (definition == Ogmo.EntitiesWindow.CurrentEntity) ? Selected : NotSelected;

            //Events
            Ogmo.EntitiesWindow.OnEntityChanged += onEntityChanged;
        }
Example #4
0
        public EntityDefinition Clone()
        {
            EntityDefinition def = new EntityDefinition();

            def.Name             = Name;
            def.Limit            = Limit;
            def.ResizableX       = ResizableX;
            def.ResizableY       = ResizableY;
            def.Rotatable        = Rotatable;
            def.RotateIncrement  = RotateIncrement;
            def.Size             = Size;
            def.Origin           = Origin;
            def.ImageDefinition  = ImageDefinition;
            def.ValueDefinitions = new List <ValueDefinition>();
            def.NodesDefinition  = NodesDefinition;
            foreach (var d in ValueDefinitions)
            {
                def.ValueDefinitions.Add(d.Clone());
            }
            return(def);
        }
Example #5
0
        public Entity(EntityLayer layer, EntityDefinition def, Point position)
        {
            Layer = layer;
            Definition = def;
            ID = layer.GetNewEntityID();

            Position = position;
            Size = def.Size;
            Angle = 0;

            //Nodes
            if (def.NodesDefinition.Enabled)
                Nodes = new List<Point>();

            //Values
            if (def.ValueDefinitions.Count > 0)
            {
                Values = new List<Value>(def.ValueDefinitions.Count);
                foreach (var d in def.ValueDefinitions)
                    Values.Add(new Value(d));
            }
        }
Example #6
0
        /*
         *  Drawing helpers
         */
        public void DrawEntity(EntityDefinition definition, System.Drawing.Point position, float alpha = 1)
        {
            if (EntityTextures.ContainsKey(definition))
            {
                if (definition.ImageDefinition.DrawMode == EntityImageDefinition.DrawModes.Image && definition.ImageDefinition.Tiled)
                {
                    Rectangle drawTo = Rectangle.Empty;
                    Texture2D texture = EntityTextures[definition];

                    for (drawTo.X = 0; drawTo.X < definition.Size.Width; drawTo.X += texture.Width)
                    {
                        drawTo.Width = Math.Min(texture.Width, definition.Size.Width - drawTo.X);
                        for (drawTo.Y = 0; drawTo.Y < definition.Size.Height; drawTo.Y += texture.Height)
                        {
                            drawTo.Height = Math.Min(texture.Height, definition.Size.Height - drawTo.Y);

                            SpriteBatch.Draw(texture,
                                new Rectangle(drawTo.X + position.X, drawTo.Y + position.Y, drawTo.Width, drawTo.Height),
                                new Rectangle(0, 0, drawTo.Width, drawTo.Height),
                                Color.White * alpha, 0, new Vector2(definition.Origin.X, definition.Origin.Y), SpriteEffects.None, 0);
                        }
                    }
                }
                else
                    SpriteBatch.Draw(EntityTextures[definition],
                        new Rectangle(position.X, position.Y, definition.Size.Width, definition.Size.Height), null,
                        Color.White * alpha, 0, new Vector2(definition.Origin.X, definition.Origin.Y), SpriteEffects.None, 0);
            }
        }
        private void setControlsFromObject(EntityDefinition def)
        {
            removeButton.Enabled = true;
            moveUpButton.Enabled = listBox.SelectedIndex > 0;
            moveDownButton.Enabled = listBox.SelectedIndex < listBox.Items.Count - 1;

            nameTextBox.Enabled = true;
            limitTextBox.Enabled = true;
            sizeXTextBox.Enabled = true;
            sizeYTextBox.Enabled = true;
            originXTextBox.Enabled = true;
            originYTextBox.Enabled = true;
            resizableXCheckBox.Enabled = true;
            resizableYCheckBox.Enabled = true;
            rotatableCheckBox.Enabled = true;
            valuesEditor.Enabled = true;
            nodesCheckBox.Enabled = true;
            graphicTypeComboBox.Enabled = true;

            //Basics
            nameTextBox.Text = def.Name;
            limitTextBox.Text = def.Limit.ToString();
            sizeXTextBox.Text = def.Size.Width.ToString();
            sizeYTextBox.Text = def.Size.Height.ToString();
            originXTextBox.Text = def.Origin.X.ToString();
            originYTextBox.Text = def.Origin.Y.ToString();

            //Resizable/rotation
            resizableXCheckBox.Checked = def.ResizableX;
            resizableYCheckBox.Checked = def.ResizableY;
            rotatableCheckBox.Checked = def.Rotatable;
            rotationIncrementTextBox.Text = def.RotateIncrement.ToString();
            RotationFieldsVisible = def.Rotatable;

            //Nodes
            nodesCheckBox.Checked = def.NodesDefinition.Enabled;
            nodeLimitTextBox.Text = def.NodesDefinition.Limit.ToString();
            nodeDrawComboBox.SelectedIndex = (int)def.NodesDefinition.DrawMode;
            nodeGhostCheckBox.Checked = def.NodesDefinition.Ghost;
            NodesFieldsVisible = def.NodesDefinition.Enabled;

            //Values
            valuesEditor.SetList(def.ValueDefinitions);

            //Graphic
            graphicTypeComboBox.SelectedIndex = (int)def.ImageDefinition.DrawMode;
            GraphicFieldsVisibility = (int)def.ImageDefinition.DrawMode;
            rectangleColorChooser.Color = def.ImageDefinition.RectColor;
            imageFileTextBox.Text = def.ImageDefinition.ImagePath;
            imageFileTiledCheckBox.Checked = def.ImageDefinition.Tiled;
            imageFileWarningLabel.Visible = !checkImageFile();
            loadImageFilePreview();
        }
        private EntityDefinition GetDefault()
        {
            EntityDefinition def = new EntityDefinition();

            int i = 0;
            string name;

            do
            {
                name = NEW_NAME + i.ToString();
                i++;
            }
            while (entities.Find(o => o.Name == name) != null);

            def.Name = name;

            return def;
        }
Example #9
0
        public static string CheckEntityValues(EntityDefinition entity, List<ValueDefinition> list)
        {
            string s = "";

            foreach (var v in list)
            {
                switch (v.Name)
                {
                    default:
                        break;
                    case "x":
                    case "y":
                    case "id":
                    case "width":
                    case "height":
                    case "angle":
                        s += Error("Entity \"" + entity.Name + "\" contains a value with the invalid name \"" + v.Name + "\" (reserved word in entities)");
                        break;
                }
            }

            return s;
        }
Example #10
0
 public EntityDefinition Clone()
 {
     EntityDefinition def = new EntityDefinition();
     def.Name = Name;
     def.Limit = Limit;
     def.ResizableX = ResizableX;
     def.ResizableY = ResizableY;
     def.Rotatable = Rotatable;
     def.RotateIncrement = RotateIncrement;
     def.Size = Size;
     def.Origin = Origin;
     def.ImageDefinition = ImageDefinition;
     def.ValueDefinitions = new List<ValueDefinition>();
     def.NodesDefinition = NodesDefinition;
     foreach (var d in ValueDefinitions)
         def.ValueDefinitions.Add(d.Clone());
     return def;
 }