예제 #1
0
        // This updates all properties
        internal void Update(BuildSector src)
        {
            BeforePropsChange();

            // Apply changes
            // FirstWall needs to be set separately!
            this.ceilingheight = src.CeilingHeight;
            this.floorheight   = src.FloorHeight;

            this.ceilingflags = new Dictionary <string, bool>(src.CeilingFlags, StringComparer.Ordinal);
            this.floorflags   = new Dictionary <string, bool>(src.FloorFlags, StringComparer.Ordinal);

            this.ceilingtileindex    = src.CeilingTileIndex;
            this.ceilingslope        = src.CeilingSlope;
            this.ceilingshade        = src.CeilingShade;
            this.ceilingpaletteindex = src.CeilingPaletteIndex;
            this.ceilingoffsetx      = src.CeilingOffsetX;
            this.ceilingoffsety      = src.CeilingOffsetY;

            this.floortileindex    = src.FloorTileIndex;
            this.floorslope        = src.FloorSlope;
            this.floorshade        = src.FloorShade;
            this.floorpaletteindex = src.FloorPaletteIndex;
            this.flooroffsetx      = src.FloorOffsetX;
            this.flooroffsety      = src.FloorOffsetY;

            this.visibility = src.Visibility;

            this.hitag = src.HiTag;
            this.lotag = src.LoTag;
            this.extra = src.Extra;

            updateneeded             = true;
            ceilingplaneupdateneeded = true;
            floorplaneupdateneeded   = true;
            General.Map.IsChanged    = true;
        }
예제 #2
0
        // This sets up the form to edit the given sectors
        public void Setup(ICollection <Sector> sectors)
        {
            // Keep this list
            this.sectors = sectors;
            if (sectors.Count > 1)
            {
                this.Text = "Edit sectors (" + sectors.Count + ")";
            }

            // Use the first sector as a reference
            BuildSector first = new BuildSector(General.GetFirst(sectors));
            Dictionary <string, int> intflagsceiling = new Dictionary <string, int>();
            Dictionary <string, int> intflagsfloor   = new Dictionary <string, int>();

            foreach (var group in General.Map.Config.SectorFlags)
            {
                intflagsceiling[group.Key] = (first.CeilingFlags.ContainsKey(group.Key) && first.CeilingFlags[group.Key] ? 1 : 0);
                intflagsfloor[group.Key]   = (first.FloorFlags.ContainsKey(group.Key) && first.FloorFlags[group.Key] ? 1 : 0);
            }

            // Go for all sectors to compare properties
            foreach (Sector s in sectors)
            {
                // Floor/ceiling
                if (first.FloorHeight != s.FloorHeight)
                {
                    first.FloorHeight = VALUE_MISMATCH;
                }
                if (first.CeilingHeight != s.CeilingHeight)
                {
                    first.CeilingHeight = VALUE_MISMATCH;
                }
                if (first.Visibility != s.Visibility)
                {
                    first.Visibility = VALUE_MISMATCH;
                }

                // Identification
                if (first.HiTag != s.HiTag)
                {
                    first.HiTag = VALUE_MISMATCH;
                }
                if (first.LoTag != s.LoTag)
                {
                    first.LoTag = VALUE_MISMATCH;
                }
                if (first.Extra != s.Extra)
                {
                    first.Extra = VALUE_MISMATCH;
                }

                // Ceiling
                foreach (string flagname in General.Map.Config.SectorFlags.Keys)
                {
                    int flag = (s.IsFlagSet(flagname, false) ? 1 : 0);
                    if (flag != intflagsceiling[flagname])
                    {
                        intflagsceiling[flagname] = VALUE_MISMATCH;
                    }
                }

                if (first.CeilingTileIndex != s.CeilingTileIndex)
                {
                    first.CeilingTileIndex = VALUE_MISMATCH;
                }
                if (first.CeilingOffsetX != s.CeilingOffsetX)
                {
                    first.CeilingOffsetX = VALUE_MISMATCH;
                }
                if (first.CeilingOffsetY != s.CeilingOffsetY)
                {
                    first.CeilingOffsetY = VALUE_MISMATCH;
                }
                if (first.CeilingShade != s.CeilingShade)
                {
                    first.CeilingShade = VALUE_MISMATCH;
                }
                if (first.CeilingPaletteIndex != s.CeilingPaletteIndex)
                {
                    first.CeilingPaletteIndex = VALUE_MISMATCH;
                }
                if (first.CeilingSlope != s.CeilingSlope)
                {
                    first.CeilingSlope = VALUE_MISMATCH;
                }

                // Floor
                foreach (string flagname in General.Map.Config.SectorFlags.Keys)
                {
                    int flag = (s.IsFlagSet(flagname, true) ? 1 : 0);
                    if (flag != intflagsfloor[flagname])
                    {
                        intflagsfloor[flagname] = VALUE_MISMATCH;
                    }
                }

                if (first.FloorTileIndex != s.FloorTileIndex)
                {
                    first.FloorTileIndex = VALUE_MISMATCH;
                }
                if (first.FloorOffsetX != s.FloorOffsetX)
                {
                    first.FloorOffsetX = VALUE_MISMATCH;
                }
                if (first.FloorOffsetY != s.FloorOffsetY)
                {
                    first.FloorOffsetY = VALUE_MISMATCH;
                }
                if (first.FloorShade != s.FloorShade)
                {
                    first.FloorShade = VALUE_MISMATCH;
                }
                if (first.FloorPaletteIndex != s.FloorPaletteIndex)
                {
                    first.FloorPaletteIndex = VALUE_MISMATCH;
                }
                if (first.FloorSlope != s.FloorSlope)
                {
                    first.FloorSlope = VALUE_MISMATCH;
                }
            }

            // Update interface
            this.SuspendLayout();

            // Floor/ceiling
            if (first.FloorHeight != VALUE_MISMATCH)
            {
                floorheight.Text = first.FloorHeight.ToString();
            }
            if (first.CeilingHeight != VALUE_MISMATCH)
            {
                ceilheight.Text = first.CeilingHeight.ToString();
            }
            if (first.Visibility != VALUE_MISMATCH)
            {
                visibility.Text = first.Visibility.ToString();
            }

            // Identification
            //TODO: handlers
            if (first.HiTag != VALUE_MISMATCH)
            {
                hitag.Text = first.HiTag.ToString();
            }
            if (first.LoTag != VALUE_MISMATCH)
            {
                lotag.Text = first.LoTag.ToString();
            }
            if (first.Extra != VALUE_MISMATCH)
            {
                extra.Text = first.Extra.ToString();
            }

            // Ceiling
            foreach (CheckBox c in ceilflags.Checkboxes)
            {
                switch (intflagsceiling[c.Tag.ToString()])
                {
                case 1:
                    c.Checked = true;
                    break;

                case VALUE_MISMATCH:
                    c.ThreeState = true;
                    c.CheckState = CheckState.Indeterminate;
                    break;
                }
            }

            ceiltex.TextureName = (first.CeilingTileIndex != VALUE_MISMATCH ? first.CeilingTileIndex.ToString() : "");
            if (first.CeilingOffsetX != VALUE_MISMATCH)
            {
                ceiloffsetx.Text = first.CeilingOffsetX.ToString();
            }
            if (first.CeilingOffsetY != VALUE_MISMATCH)
            {
                ceiloffsety.Text = first.CeilingOffsetY.ToString();
            }
            if (first.CeilingShade != VALUE_MISMATCH)
            {
                ceilshade.Text = first.CeilingShade.ToString();
            }
            if (first.CeilingPaletteIndex != VALUE_MISMATCH)
            {
                ceilpalette.Text = first.CeilingPaletteIndex.ToString();
            }
            if (first.CeilingSlope != VALUE_MISMATCH)
            {
                ceilslope.Text = ((float)Math.Round(General.Wrap(Angle2D.RadToDeg(first.CeilingSlope) - 90, -90, 90), 1)).ToString();
            }

            // Floor
            foreach (CheckBox c in floorflags.Checkboxes)
            {
                switch (intflagsfloor[c.Tag.ToString()])
                {
                case 1:
                    c.Checked = true;
                    break;

                case VALUE_MISMATCH:
                    c.ThreeState = true;
                    c.CheckState = CheckState.Indeterminate;
                    break;
                }
            }

            floortex.TextureName = (first.FloorTileIndex != VALUE_MISMATCH ? first.FloorTileIndex.ToString() : "");
            if (first.FloorOffsetX != VALUE_MISMATCH)
            {
                flooroffsetx.Text = first.FloorOffsetX.ToString();
            }
            if (first.FloorOffsetY != VALUE_MISMATCH)
            {
                flooroffsety.Text = first.FloorOffsetY.ToString();
            }
            if (first.FloorShade != VALUE_MISMATCH)
            {
                floorshade.Text = first.FloorShade.ToString();
            }
            if (first.FloorPaletteIndex != VALUE_MISMATCH)
            {
                floorpalette.Text = first.FloorPaletteIndex.ToString();
            }
            if (first.FloorSlope != VALUE_MISMATCH)
            {
                floorslope.Text = ((float)Math.Round(General.Wrap(Angle2D.RadToDeg(first.FloorSlope) - 90, -90, 90), 1)).ToString();
            }

            this.ResumeLayout();

            // Show sector height
            UpdateSectorHeight();
        }