#region ================== Copyright (c) 2021 Boris Iwanski /* * This program is free software: you can redistribute it and/or modify * * it under the terms of the GNU General Public License as published by * * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.See the * * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program.If not, see. */ #endregion #region ================== Namespaces using System.Collections.Generic; using System.Linq; using CodeImp.DoomBuilder.BuilderModes; using CodeImp.DoomBuilder.Editing; using CodeImp.DoomBuilder.Geometry; using CodeImp.DoomBuilder.Map; using CodeImp.DoomBuilder.VisualModes; #endregion namespace CodeImp.DoomBuilder.UDBScript.Wrapper { internal class MapWrapper { #region ================== Variables private MapSet map; private VisualCameraWrapper visualcamera; #endregion #region ================== Properties /// /// `true` if the map is in Doom format, `false` if it isn't. Read-only. /// public bool isDoom { get { return General.Map.DOOM; } } /// /// `true` if the map is in Hexen format, `false` if it isn't. Read-only. /// public bool isHexen { get { return General.Map.HEXEN; } } /// /// `true` if the map is in UDMF, `false` if it isn't. Read-only. /// public bool isUDMF { get { return General.Map.UDMF; } } /// /// The map coordinates of the mouse position as a `Vector2D`. Read-only. /// public Vector2D mousePosition { get { if (General.Editing.Mode is ClassicMode) return ((ClassicMode)General.Editing.Mode).MouseMapPos; else return ((VisualMode)General.Editing.Mode).GetHitPosition(); } } /// /// `VisualCamera` object with information about the position of the camera in visual mode. Read-only. /// public VisualCameraWrapper camera { get { return visualcamera; } } #endregion #region ================== Constructors internal MapWrapper() { map = General.Map.Map; visualcamera = new VisualCameraWrapper(); } #endregion #region ================== Methods /// /// Returns the given point snapped to the current grid. /// /// Point that should be snapped to the grid /// Snapped position as `Vector2D` public Vector2DWrapper snappedToGrid(object pos) { try { return new Vector2DWrapper(General.Map.Grid.SnappedToGrid((Vector2D)BuilderPlug.Me.GetVectorFromObject(pos, false))); } catch (CantConvertToVectorException e) { throw BuilderPlug.Me.ScriptRunner.CreateRuntimeException(e.Message); } } /// /// Returns an `Array` of all `Thing`s in the map. /// /// `Array` of `Thing`s public ThingWrapper[] getThings() { List things = new List(General.Map.Map.Things.Count); foreach (Thing t in General.Map.Map.Things) if(!t.IsDisposed) things.Add(new ThingWrapper(t)); return things.ToArray(); } /// /// Returns an `Array` of all `Sector`s in the map. /// /// `Array` of `Sector`s public SectorWrapper[] getSectors() { List sectors = new List(General.Map.Map.Sectors.Count); foreach (Sector s in General.Map.Map.Sectors) if (!s.IsDisposed) sectors.Add(new SectorWrapper(s)); return sectors.ToArray(); } /// /// Returns an `Array` of all `Sidedef`s in the map. /// /// `Array` of `Sidedef`s public SidedefWrapper[] getSidedefs() { List sidedefs = new List(General.Map.Map.Sidedefs.Count); foreach (Sidedef sd in General.Map.Map.Sidedefs) if (!sd.IsDisposed) sidedefs.Add(new SidedefWrapper(sd)); return sidedefs.ToArray(); } /// /// Returns an `Array` of all `Linedef`s in the map. /// /// `Array` of `Linedef`s public LinedefWrapper[] getLinedefs() { List linedefs = new List(General.Map.Map.Linedefs.Count); foreach (Linedef ld in General.Map.Map.Linedefs) if (!ld.IsDisposed) linedefs.Add(new LinedefWrapper(ld)); return linedefs.ToArray(); } /// /// Returns an `Array` of all `Vertex` in the map. /// /// `Array` of `Vertex` public VertexWrapper[] getVertices() { List vertices = new List(General.Map.Map.Vertices.Count); foreach (Vertex v in General.Map.Map.Vertices) if (!v.IsDisposed) vertices.Add(new VertexWrapper(v)); return vertices.ToArray(); } /// /// Stitches marked geometry with non-marked geometry. /// /// Mode to merge by /// `true` if successful, `false` if failed public bool stitchGeometry(MergeGeometryMode mergemode = MergeGeometryMode.CLASSIC) { return General.Map.Map.StitchGeometry(mergemode); } /// /// Snaps all vertices and things to the map format accuracy. Call this to ensure the vertices and things are at valid coordinates. /// /// `true` if decimal places defined by the map format should be used, `false` if no decimal places should be used public void snapAllToAccuracy(bool usepreciseposition = true) { General.Map.Map.SnapAllToAccuracy(usepreciseposition); } /// /// Gets a new tag. /// /// `Array` of tags to skip /// The new tag public int getNewTag(int[] usedtags = null) { if (usedtags == null) return General.Map.Map.GetNewTag(); else return General.Map.Map.GetNewTag(usedtags.ToList()); } /// /// Gets multiple new tags. /// /// Number of tags to get /// `Array` of the new tags public int[] getMultipleNewTags(int count) { return General.Map.Map.GetMultipleNewTags(count).ToArray(); } /// /// Gets the `Linedef` that's nearest to the specified position. /// /// Position to check against /// Maximum range (optional) /// Nearest `Linedef` public LinedefWrapper nearestLinedef(object pos, double maxrange = double.NaN) { try { Vector2D v = (Vector2D)BuilderPlug.Me.GetVectorFromObject(pos, false); if (double.IsNaN(maxrange)) return new LinedefWrapper(General.Map.Map.NearestLinedef(v)); else return new LinedefWrapper(General.Map.Map.NearestLinedefRange(v, maxrange)); } catch (CantConvertToVectorException e) { throw BuilderPlug.Me.ScriptRunner.CreateRuntimeException(e.Message); } } /// /// Gets the `Thing` that's nearest to the specified position. /// /// Position to check against /// Maximum range (optional) /// Nearest `Linedef` public ThingWrapper nearestThing(object pos, double maxrange = double.NaN) { try { Vector2D v = (Vector2D)BuilderPlug.Me.GetVectorFromObject(pos, false); if (double.IsNaN(maxrange)) return new ThingWrapper(General.Map.Map.NearestThingSquareRange(v, double.MaxValue)); else return new ThingWrapper(General.Map.Map.NearestThingSquareRange(v, maxrange)); } catch (CantConvertToVectorException e) { throw BuilderPlug.Me.ScriptRunner.CreateRuntimeException(e.Message); } } /// /// Gets the `Vertex` that's nearest to the specified position. /// /// Position to check against /// Maximum range (optional) /// Nearest `Vertex` public VertexWrapper nearestVertex(object pos, double maxrange = double.NaN) { try { Vector2D v = (Vector2D)BuilderPlug.Me.GetVectorFromObject(pos, false); if (double.IsNaN(maxrange)) return new VertexWrapper(General.Map.Map.NearestVertexSquareRange(v, double.MaxValue)); else return new VertexWrapper(General.Map.Map.NearestVertexSquareRange(v, maxrange)); } catch (CantConvertToVectorException e) { throw BuilderPlug.Me.ScriptRunner.CreateRuntimeException(e.Message); } } /// /// Gets the `Sidedef` that's nearest to the specified position. /// /// Position to check against /// Maximum range (optional) /// Nearest `Sidedef` public SidedefWrapper nearestSidedef(object pos) { try { Vector2D v = (Vector2D)BuilderPlug.Me.GetVectorFromObject(pos, false); return new SidedefWrapper(MapSet.NearestSidedef(General.Map.Map.Sidedefs, v)); } catch (CantConvertToVectorException e) { throw BuilderPlug.Me.ScriptRunner.CreateRuntimeException(e.Message); } } /// /// Draws lines. Data has to be an `Array` of `Array` of numbers, `Vector2D`s, `Vector3D`s, or objects with x and y properties. Note that the first and last element have to be at the same positions to make a complete drawing. /// ``` /// Map.drawLines([ /// new Vector2D(64, 0), /// new Vector2D(128, 0), /// new Vector2D(128, 64), /// new Vector2D(64, 64), /// new Vector2D(64, 0) /// ]); /// /// Map.drawLines([ /// [ 0, 0 ], /// [ 64, 0 ], /// [ 64, 64 ], /// [ 0, 64 ], /// [ 0, 0 ] /// ]); /// ``` /// /// `Array` of positions /// `true` if drawing was successful, `false` if it wasn't public bool drawLines(object data) { if (!data.GetType().IsArray) throw BuilderPlug.Me.ScriptRunner.CreateRuntimeException("Data must be supplied as an array"); List vertices = new List(); foreach(object item in (object[])data) { try { Vector2D v = (Vector2D)BuilderPlug.Me.GetVectorFromObject(item, false); DrawnVertex dv = new DrawnVertex(); dv.pos = v; dv.stitch = dv.stitchline = true; vertices.Add(dv); } catch (CantConvertToVectorException e) { throw BuilderPlug.Me.ScriptRunner.CreateRuntimeException(e.Message); } } if(vertices.Count < 2) throw BuilderPlug.Me.ScriptRunner.CreateRuntimeException("Array must have at least 2 values"); bool success = Tools.DrawLines(vertices); // Snap to map format accuracy General.Map.Map.SnapAllToAccuracy(); // Update map General.Map.Map.Update(); // Update textures General.Map.Data.UpdateUsedTextures(); return success; } #endregion #region ================== Marks /// /// Sets the `marked` property of all map elements. Can be passed `true` to mark all map elements. /// /// `false` to set the `marked` property to `false` (default), `true` to set the `marked` property to `true` public void clearAllMarks(bool mark=false) { General.Map.Map.ClearAllMarks(mark); } /// /// Sets the `marked` property of all vertices. Can be passed `true` to mark all vertices. /// /// `false` to set the `marked` property to `false` (default), `true` to set the `marked` property to `true` public void clearMarkedVertices(bool mark=false) { General.Map.Map.ClearMarkedVertices(mark); } /// /// Sets the `marked` property of all `Thing`s. Can be passed `true` to mark all `Thing`s. /// /// `false` to set the `marked` property to `false` (default), `true` to set the `marked` property to `true` public void clearMarkedThings(bool mark=false) { General.Map.Map.ClearMarkedThings(mark); } /// /// Sets the `marked` property of all `Linedef`s. Can be passed `true` to mark all `Linedef`s. /// /// `false` to set the `marked` property to `false` (default), `true` to set the `marked` property to `true` public void clearMarkeLinedefs(bool mark=false) { General.Map.Map.ClearMarkedLinedefs(mark); } /// /// Sets the `marked` property of all `Sidedef`s. Can be passed `true` to mark all `Sidedef`s. /// /// `false` to set the `marked` property to `false` (default), `true` to set the `marked` property to `true` public void clearMarkeSidedefs(bool mark = false) { General.Map.Map.ClearMarkedSidedefs(mark); } /// /// Sets the `marked` property of all `Sector`s. Can be passed `true` to mark all `Sector`s. /// /// `false` to set the `marked` property to `false` (default), `true` to set the `marked` property to `true` public void clearMarkeSectors(bool mark = false) { General.Map.Map.ClearMarkedSectors(mark); } /// /// Inverts all marks of all map elements. /// public void invertAllMarks() { General.Map.Map.InvertAllMarks(); } /// /// Inverts the `marked` property of all vertices. /// public void invertMarkedVertices() { General.Map.Map.InvertMarkedVertices(); } /// /// Inverts the `marked` property of all `Thing`s. /// public void invertMarkedThings() { General.Map.Map.InvertMarkedThings(); } /// /// Inverts the `marked` property of all `Linedef`s. /// public void invertMarkedLinedefs() { General.Map.Map.InvertMarkedLinedefs(); } /// /// Inverts the `marked` property of all `Sidedef`s. /// public void invertMarkedSidedefs() { General.Map.Map.InvertMarkedSidedefs(); } /// /// Inverts the `marked` property of all `Sector`s. /// public void invertMarkedSectors() { General.Map.Map.InvertMarkedSectors(); } /// /// Gets all marked (default) or unmarked vertices. /// /// `true` to get all marked vertices (default), `false` to get all unmarked vertices /// public VertexWrapper[] getMarkedVertices(bool mark=true) { List vertices = new List(); foreach (Vertex v in General.Map.Map.Vertices) if(v.Marked == mark) vertices.Add(new VertexWrapper(v)); return vertices.ToArray(); } /// /// Gets all marked (default) or unmarked `Thing`s. /// /// `true` to get all marked `Thing`s (default), `false` to get all unmarked `Thing`s /// public ThingWrapper[] getMarkedThings(bool mark = true) { List things = new List(); foreach (Thing t in General.Map.Map.Things) if (t.Marked == mark) things.Add(new ThingWrapper(t)); return things.ToArray(); } /// /// Gets all marked (default) or unmarked `Linedef`s. /// /// `true` to get all marked `Linedef`s (default), `false` to get all unmarked `Linedef`s /// public LinedefWrapper[] getMarkedLinedefs(bool mark = true) { List linedefs = new List(); foreach (Linedef ld in General.Map.Map.Linedefs) if (ld.Marked == mark) linedefs.Add(new LinedefWrapper(ld)); return linedefs.ToArray(); } /// /// Gets all marked (default) or unmarked `Sidedef`s. /// /// `true` to get all marked `Sidedef`s (default), `false` to get all unmarked `Sidedef`s /// public SidedefWrapper[] getMarkedSidedefs(bool mark = true) { List sidedefs = new List(); foreach (Sidedef sd in General.Map.Map.Sidedefs) if (sd.Marked == mark) sidedefs.Add(new SidedefWrapper(sd)); return sidedefs.ToArray(); } /// /// Gets all marked (default) or unmarked `Sector`s. /// /// `true` to get all marked `Sector`s (default), `false` to get all unmarked `Sector`s /// public SectorWrapper[] getMarkedSectors(bool mark = true) { List sectors = new List(); foreach (Sector s in General.Map.Map.Sectors) if (s.Marked == mark) sectors.Add(new SectorWrapper(s)); return sectors.ToArray(); } /// /// Marks (default) or unmarks all selected vertices. /// /// `true` to mark all selected vertices (default), `false` to unmark public void markSelectedVertices(bool mark=true) { General.Map.Map.MarkSelectedVertices(true, mark); } /// /// Marks (default) or unmarks all selected `Linedef`s. /// /// `true` to mark all selected `Linedef`s (default), `false` to unmark public void markSelectedLinedefs(bool mark = true) { General.Map.Map.MarkSelectedLinedefs(true, mark); } /// /// Marks (default) or unmarks all selected `Sector`s. /// /// `true` to mark all selected `Sector`s (default), `false` to unmark public void markSelectedSectors(bool mark = true) { General.Map.Map.MarkSelectedSectors(true, mark); } /// /// Marks (default) or unmarks all selected `Thing`s. /// /// `true` to mark all selected `Thing`s (default), `false` to unmark public void markSelectedThings(bool mark = true) { General.Map.Map.MarkSelectedThings(true, mark); } #endregion #region ================== Selected /// /// Gets all selected (default) or unselected vertices. /// /// `true` to get all selected vertices, `false` to get all unselected ones /// `Array` of `Vertex` public VertexWrapper[] getSelectedVertices(bool selected=true) { List vertices = new List(); if (General.Editing.Mode is BaseVisualMode) { List selectedvertices = ((BaseVisualMode)General.Editing.Mode).GetSelectedVertices(); foreach (Vertex v in General.Map.Map.Vertices) if (selectedvertices.Contains(v) == selected) vertices.Add(new VertexWrapper(v)); } else { foreach (Vertex v in map.GetSelectedVertices(selected)) if (v.Selected == selected) vertices.Add(new VertexWrapper(v)); } return vertices.ToArray(); } /// /// Get the currently highlighted `Vertex`. /// /// The currently highlighted `Vertex` or `null` if no `Vertex` is highlighted public VertexWrapper getHighlightedVertex() { Vertex v = General.Editing.Mode.HighlightedObject as Vertex; if (v != null) return new VertexWrapper(v); return null; } /// /// Gets the currently selected `Vertex`s *or*, if no `Vertex`s are selected, a currently highlighted `Vertex`. /// /// `Array` of `Vertex` public VertexWrapper[] getSelectedOrHighlightedVertices() { if (General.Map.Map.SelectedVerticessCount > 0) { List linedefs = new List(); foreach (Vertex v in General.Map.Map.Vertices) if (v.Selected) linedefs.Add(new VertexWrapper(v)); return linedefs.ToArray(); } else { Vertex v = General.Editing.Mode.HighlightedObject as Vertex; if (v != null) return new VertexWrapper[] { new VertexWrapper(v) }; } return new VertexWrapper[] { }; } /// /// Gets all selected (default) or unselected `Thing`s. /// /// `true` to get all selected `Thing`s, `false` to get all unselected ones /// `Array` of `Thing`s public ThingWrapper[] getSelectedThings(bool selected = true) { List things = new List(); if (General.Editing.Mode is BaseVisualMode) { List selectedthings = ((BaseVisualMode)General.Editing.Mode).GetSelectedThings(); foreach (Thing t in General.Map.Map.Things) if (selectedthings.Contains(t) == selected) things.Add(new ThingWrapper(t)); } else { foreach (Thing t in map.GetSelectedThings(selected)) if (t.Selected == selected) things.Add(new ThingWrapper(t)); } return things.ToArray(); } /// /// Get the currently highlighted `Thing`. /// /// The currently highlighted `Thing` or `null` if no `Thing` is highlighted public ThingWrapper getHighlightedThing() { Thing t = General.Editing.Mode.HighlightedObject as Thing; if (t != null) return new ThingWrapper(t); return null; } /// /// Gets the currently selected `Thing`s *or*, if no `Thing`s are selected, a currently highlighted `Thing`. /// /// `Array` of `Thing`s public ThingWrapper[] getSelectedOrHighlightedThings() { ThingWrapper[] things = getSelectedThings(true); if (things.Length > 0) return things; ThingWrapper highlight = getHighlightedThing(); if (highlight != null) return new ThingWrapper[] { highlight }; return new ThingWrapper[] { }; } /// /// Gets all selected (default) or unselected `Sector`s. /// /// `true` to get all selected `Sector`s, `false` to get all unselected ones /// `Array` of `Sector`s public SectorWrapper[] getSelectedSectors(bool selected = true) { List sectors = new List(); if (General.Editing.Mode is BaseVisualMode) { List selectedsectors = ((BaseVisualMode)General.Editing.Mode).GetSelectedSectors(); foreach (Sector s in General.Map.Map.Sectors) if (selectedsectors.Contains(s) == selected) sectors.Add(new SectorWrapper(s)); } else { foreach (Sector s in map.GetSelectedSectors(selected)) if (s.Selected == selected) sectors.Add(new SectorWrapper(s)); } return sectors.ToArray(); } /// /// Get the currently highlighted `Sector`. /// /// The currently highlighted `Sector` or `null` if no `Sector` is highlighted public SectorWrapper getHighlightedSector() { if (General.Editing.Mode is BaseVisualMode) { VisualSector s = General.Editing.Mode.HighlightedObject as VisualSector; if (s != null) return new SectorWrapper(s.Sector); } else { Sector s = General.Editing.Mode.HighlightedObject as Sector; if (s != null) return new SectorWrapper(s); } return null; } /// /// Gets the currently selected `Sector`s *or*, if no `Sector`s are selected, a currently highlighted `Sector`. /// /// `Array` of `Sector`s public SectorWrapper[] getSelectedOrHighlightedSectors() { SectorWrapper[] things = getSelectedSectors(true); if (things.Length > 0) return things; SectorWrapper highlight = getHighlightedSector(); if (highlight != null) return new SectorWrapper[] { highlight }; return new SectorWrapper[] { }; } /// /// Gets all selected (default) or unselected `Linedef`s. /// /// `true` to get all selected `Linedef`s, `false` to get all unselected ones /// `Array` of `Linedef`s public LinedefWrapper[] getSelectedLinedefs(bool selected = true) { List linedefs = new List(); if (General.Editing.Mode is BaseVisualMode) { List selectedlinedefs = ((BaseVisualMode)General.Editing.Mode).GetSelectedLinedefs(); foreach (Linedef ld in General.Map.Map.Linedefs) if(selectedlinedefs.Contains(ld) == selected) linedefs.Add(new LinedefWrapper(ld)); } else { foreach (Linedef ld in map.GetSelectedLinedefs(selected)) if (ld.Selected == selected) linedefs.Add(new LinedefWrapper(ld)); } return linedefs.ToArray(); } /// /// Get the currently highlighted `Linedef`. /// /// The currently highlighted `Linedef` or `null` if no `Linedef` is highlighted public LinedefWrapper getHighlightedLinedef() { if (General.Editing.Mode is BaseVisualMode) { Sidedef sd = General.Editing.Mode.HighlightedObject as Sidedef; if (sd != null) return new LinedefWrapper(sd.Line); } else { Linedef ld = General.Editing.Mode.HighlightedObject as Linedef; if (ld != null) return new LinedefWrapper(ld); } return null; } /// /// Gets the currently selected `Linedef`s *or*, if no `Linede`f`s are selected, a currently highlighted `Linedef`. /// /// `Array` of `Linedef`s public LinedefWrapper[] getSelectedOrHighlightedLinedefs() { LinedefWrapper[] linedefs = getSelectedLinedefs(true); if (linedefs.Length > 0) return linedefs; LinedefWrapper highlight = getHighlightedLinedef(); if (highlight != null) return new LinedefWrapper[] { highlight }; return new LinedefWrapper[] { }; } /* public LinedefWrapper[] getAnyLinedefs() { if (General.Map.Map.SelectedLinedefsCount > 0) { List linedefs = new List(); foreach (Linedef ld in General.Map.Map.Linedefs) if (ld.Selected) linedefs.Add(new LinedefWrapper(ld)); return linedefs.ToArray(); } else if (General.Editing.Mode.HighlightedObject != null && General.Editing.Mode.HighlightedObject is Linedef) { return new LinedefWrapper[] { new LinedefWrapper((Linedef)General.Editing.Mode.HighlightedObject) }; } else { List linedefs = new List(); foreach (Linedef ld in General.Map.Map.Linedefs) if (ld.Selected) linedefs.Add(new LinedefWrapper(ld)); return linedefs.ToArray(); } } */ /// /// Gets all `Sidedef`s from the selected `Linedef`s. /// In classic modes this will return both sidedefs of 2-sided lines, in visual mode it will only return the actually selected `Sidedef`. /// /// `true` to get all `Sidedef`s of all selected `Linedef`s, `false` to get all `Sidedef`s of all unselected `Linedef`s /// `Array` of `Sidedef` public SidedefWrapper[] getSidedefsFromSelectedLinedefs(bool selected = true) { List sidedefs = new List(); if (General.Editing.Mode is BaseVisualMode) { List selectedsidedefs = ((BaseVisualMode)General.Editing.Mode).GetSelectedSidedefs(); foreach (Sidedef sd in General.Map.Map.Sidedefs) if (selectedsidedefs.Contains(sd) == selected) sidedefs.Add(new SidedefWrapper(sd)); } else { foreach (Sidedef sd in General.Map.Map.GetSidedefsFromSelectedLinedefs(selected)) sidedefs.Add(new SidedefWrapper(sd)); } return sidedefs.ToArray(); } /// /// Gets the `Sidedef`s of the currently selected `Linedef`s *or*, if no `Linede`f`s are selected, the `Sidedef`s of the currently highlighted `Linedef`. /// In classic modes this will return both sidedefs of 2-sided lines, in visual mode it will only return the actually selected `Sidedef`. /// /// `Array` of `Sidedef`s /// 3 public SidedefWrapper[] getSidedefsFromSelectedOrHighlightedLinedefs() { List sidedefs = new List(getSidedefsFromSelectedLinedefs(true)); if(sidedefs.Count > 0) return sidedefs.ToArray(); // Nothing selected, so let's see if anything is highlighted LinedefWrapper highlight = getHighlightedLinedef(); if (highlight != null) { if (highlight.front != null) sidedefs.Add(highlight.front); if (highlight.back != null) sidedefs.Add(highlight.back); } return sidedefs.ToArray(); } /// /// Clears all selected map elements. /// public void clearAllSelected() { General.Map.Map.ClearAllSelected(); } /// /// Clears all selected vertices. /// public void clearSelectedVertices() { General.Map.Map.ClearSelectedVertices(); } /// /// Clears all selected `Thing`s. /// public void clearSelectedThings() { General.Map.Map.ClearSelectedThings(); } /// /// Clears all selected `Sector`s. /// public void clearSelectedSectors() { General.Map.Map.ClearSelectedSectors(); } #endregion #region ================== Creation /// /// Creates a new `Vertex` at the given position. The position can be a `Vector2D` or an `Array` of two numbers. /// ``` /// var v1 = Map.createVertex(new Vector2D(32, 64)); /// var v2 = Map.createVertex([ 32, 64 ]); /// ``` /// /// Position where the `Vertex` should be created at /// The created `Vertex` public VertexWrapper createVertex(object pos) { try { Vector2D v = (Vector2D)BuilderPlug.Me.GetVectorFromObject(pos, false); Vertex newvertex = General.Map.Map.CreateVertex(v); if(newvertex == null) throw BuilderPlug.Me.ScriptRunner.CreateRuntimeException("Failed to create new vertex"); return new VertexWrapper(newvertex); } catch (CantConvertToVectorException e) { throw BuilderPlug.Me.ScriptRunner.CreateRuntimeException(e.Message); } } /// /// Creates a new `Thing` at the given position. The position can be a `Vector2D`, `Vector3D`, or an `Array` of two numbers or three numbers (note that the z position only works for game configurations that support vertical pos. A thing type can be supplied optionally. /// ``` /// var t1 = Map.createThing(new Vector2D(32, 64)); /// var t2 = Map.createThing([ 32, 64 ]); /// var t3 = Map.createThing(new Vector2D(32, 64), 3001); // Create an Imp /// var t4 = Map.createThing([ 32, 64 ], 3001); // Create an Imp /// ``` /// /// Position where the `Thing` should be created at /// Thing type (optional) /// The new `Thing` public ThingWrapper createThing(object pos, int type=0) { try { if(type < 0) throw BuilderPlug.Me.ScriptRunner.CreateRuntimeException("Thing type can not be negative."); object v = BuilderPlug.Me.GetVectorFromObject(pos, true); Thing t = General.Map.Map.CreateThing(); if(t == null) throw BuilderPlug.Me.ScriptRunner.CreateRuntimeException("Failed to create new thing."); General.Settings.ApplyCleanThingSettings(t); if (type > 0) t.Type = type; if(v is Vector2D) t.Move((Vector2D)v); else if(v is Vector3D) t.Move((Vector3D)v); t.UpdateConfiguration(); return new ThingWrapper(t); } catch (CantConvertToVectorException e) { throw BuilderPlug.Me.ScriptRunner.CreateRuntimeException(e.Message); } } #endregion #region ================== Merging/Joining /// /// Joins `Sector`s, keeping lines shared by the `Sector`s. All `Sector`s will be joined with the first `Sector` in the array. /// /// `Array` of `Sector`s public void joinSectors(SectorWrapper[] sectors) { List secs = new List(); foreach (SectorWrapper sw in sectors) secs.Add(sw.Sector); JoinMergeSectors(secs, false); } /// /// Merges `Sector`s, deleting lines shared by the `Sector`s. All `Sector`s will be merged into the first `Sector` in the array. /// /// `Array` of `Sector`s public void mergeSectors(SectorWrapper[] sectors) { List secs = new List(); foreach (SectorWrapper sw in sectors) secs.Add(sw.Sector); JoinMergeSectors(secs, true); } // Helper method for joining/merging sectors. Pretty much a direct copy from sectors mode private void JoinMergeSectors(List sectors, bool removelines) { // Remove lines in betwen joining sectors? if (removelines) { // Go for all selected linedefs List selectedlines = new List(); foreach (Sector s in sectors) foreach (Sidedef sd in s.Sidedefs) if (!selectedlines.Contains(sd.Line)) selectedlines.Add(sd.Line); foreach (Linedef ld in selectedlines) { // Front and back side? if ((ld.Front != null) && (ld.Back != null)) { // Both a selected sector, but not the same? if (sectors.Contains(ld.Front.Sector) && sectors.Contains(ld.Back.Sector) && (ld.Front.Sector != ld.Back.Sector)) { // Remove this line ld.Dispose(); } } } } // Find the first sector that is not disposed //List orderedselection = new List(General.Map.Map.GetSelectedSectors(true)); Sector first = null; foreach (Sector s in sectors) if (!s.IsDisposed) { first = s; break; } // Join all selected sectors with the first for (int i = 0; i < sectors.Count; i++) if ((sectors[i] != first) && !sectors[i].IsDisposed) sectors[i].Join(first); // Update General.Map.Map.Update(); } #endregion } }