mirror of
https://git.do.srb2.org/STJr/UltimateZoneBuilder.git
synced 2024-11-26 22:01:45 +00:00
1081 lines
35 KiB
C#
Executable file
1081 lines
35 KiB
C#
Executable file
|
|
#region ================== Copyright (c) 2007 Pascal vd Heiden
|
|
|
|
/*
|
|
* Copyright (c) 2007 Pascal vd Heiden, www.codeimp.com
|
|
* This program is released under GNU General Public License
|
|
*
|
|
* 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.
|
|
*
|
|
*/
|
|
|
|
#endregion
|
|
|
|
#region ================== Namespaces
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Reflection;
|
|
using CodeImp.DoomBuilder.Config;
|
|
using CodeImp.DoomBuilder.Geometry;
|
|
using CodeImp.DoomBuilder.Map;
|
|
|
|
#endregion
|
|
|
|
namespace CodeImp.DoomBuilder.BuilderModes
|
|
{
|
|
//mxd
|
|
[AttributeUsage(AttributeTargets.Field)]
|
|
public class FieldDescription : Attribute
|
|
{
|
|
private bool doom = true;
|
|
private bool hexen = true;
|
|
private bool udmf = true;
|
|
private string description = "Unnamed field";
|
|
private string fieldname1;
|
|
private string fieldname2;
|
|
|
|
public bool DOOM { get { return doom; } set { doom = value; } }
|
|
public bool HEXEN { get { return hexen; } set { hexen = value; } }
|
|
public bool UDMF { get { return udmf; } set { udmf = value; } }
|
|
public string Description { get { return description; } set { description = value; } }
|
|
public string Field1 { get { return fieldname1; } set { fieldname1 = value; } }
|
|
public string Field2 { get { return fieldname2; } set { fieldname2 = value; } }
|
|
|
|
public bool SupportsCurrentMapFormat
|
|
{
|
|
get
|
|
{
|
|
if(General.Map == null) return false;
|
|
if(!string.IsNullOrEmpty(fieldname1) || !string.IsNullOrEmpty(fieldname2)) return General.Map.UDMF;
|
|
return (General.Map.DOOM && doom || General.Map.HEXEN && hexen || General.Map.UDMF && udmf);
|
|
}
|
|
}
|
|
}
|
|
|
|
public abstract class MapElementPropertiesCopySettings
|
|
{
|
|
protected MapElementPropertiesCopySettings()
|
|
{
|
|
// Set all properties supported by currect map format to true
|
|
FieldInfo[] props = this.GetType().GetFields(BindingFlags.Public | BindingFlags.Instance);
|
|
foreach(FieldInfo prop in props)
|
|
{
|
|
foreach(Attribute attr in Attribute.GetCustomAttributes(prop))
|
|
{
|
|
if(attr.GetType() != typeof(FieldDescription)) continue;
|
|
FieldDescription fd = (FieldDescription)attr;
|
|
prop.SetValue(this, fd.SupportsCurrentMapFormat);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//mxd
|
|
public abstract class MapElementProperties
|
|
{
|
|
private readonly UniFields fields; // Only custom (e.g. not UI-managed) fields here
|
|
private readonly UniFields uifields; // Only UI-managed fields here
|
|
private readonly MapElementType elementtype;
|
|
|
|
protected MapElementProperties(UniFields other, MapElementType type)
|
|
{
|
|
// Should we bother?
|
|
if(!General.Map.UDMF) return;
|
|
|
|
// Copy source fields except the ones controlled by the UI
|
|
fields = new UniFields();
|
|
uifields = new UniFields();
|
|
elementtype = type;
|
|
foreach(KeyValuePair<string, UniValue> group in other)
|
|
{
|
|
if(General.Map.FormatInterface.UIFields[elementtype].ContainsKey(group.Key))
|
|
uifields.Add(group.Key, new UniValue(group.Value));
|
|
else
|
|
fields.Add(group.Key, new UniValue(group.Value));
|
|
}
|
|
}
|
|
|
|
protected void ApplyUIFields<T>(ICollection<T> collection, MapElementPropertiesCopySettings settings) where T : MapElement
|
|
{
|
|
FieldInfo[] props = settings.GetType().GetFields(BindingFlags.Public | BindingFlags.Instance);
|
|
foreach(FieldInfo prop in props)
|
|
{
|
|
// Property set?
|
|
if(!(bool)prop.GetValue(settings)) continue;
|
|
foreach(Attribute attr in Attribute.GetCustomAttributes(prop))
|
|
{
|
|
if(attr.GetType() != typeof(FieldDescription)) continue;
|
|
FieldDescription fd = (FieldDescription)attr;
|
|
if(fd.SupportsCurrentMapFormat && !string.IsNullOrEmpty(fd.Field1))
|
|
{
|
|
if(!string.IsNullOrEmpty(fd.Field2))
|
|
foreach(T me in collection) Apply(me.Fields, fd.Field1, fd.Field2);
|
|
else
|
|
foreach(T me in collection) Apply(me.Fields, fd.Field1);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
protected void Apply(UniFields other, string key)
|
|
{
|
|
if(uifields.ContainsKey(key)) other[key] = new UniValue(uifields[key]);
|
|
else if(other.ContainsKey(key)) other.Remove(key);
|
|
}
|
|
|
|
protected void Apply(UniFields other, string key1, string key2)
|
|
{
|
|
Apply(other, key1);
|
|
Apply(other, key2);
|
|
}
|
|
|
|
protected void ApplyCustomFields(UniFields other)
|
|
{
|
|
// Remove custom fields
|
|
string[] keys = new string[other.Keys.Count];
|
|
other.Keys.CopyTo(keys, 0);
|
|
foreach(string key in keys)
|
|
{
|
|
if(!General.Map.FormatInterface.UIFields[elementtype].ContainsKey(key)) other.Remove(key);
|
|
}
|
|
|
|
// Replace with stored custom fields
|
|
foreach(KeyValuePair<string, UniValue> group in fields)
|
|
{
|
|
other.Add(group.Key, new UniValue(group.Value));
|
|
}
|
|
}
|
|
}
|
|
|
|
#region ================== Vertex
|
|
|
|
//mxd
|
|
public class VertexPropertiesCopySettings : MapElementPropertiesCopySettings
|
|
{
|
|
[FieldDescription(Description = "Vertex floor height", Field1 = "zfloor")]
|
|
public bool ZFloor = true;
|
|
|
|
[FieldDescription(Description = "Vertex ceiling height", Field1 = "zceiling")]
|
|
public bool ZCeiling = true;
|
|
|
|
[FieldDescription(Description = "Custom fields", DOOM = false, HEXEN = false)]
|
|
public bool Fields = true;
|
|
}
|
|
|
|
// Vertex
|
|
public class VertexProperties : MapElementProperties
|
|
{
|
|
private static VertexPropertiesCopySettings defaultsettings = new VertexPropertiesCopySettings();
|
|
public static VertexPropertiesCopySettings CopySettings = new VertexPropertiesCopySettings();
|
|
|
|
private readonly double zceiling; //mxd
|
|
private readonly double zfloor; //mxd
|
|
|
|
public VertexProperties(Vertex v) : base(v.Fields, MapElementType.VERTEX)
|
|
{
|
|
zceiling = v.ZCeiling; //mxd
|
|
zfloor = v.ZFloor; //mxd
|
|
}
|
|
|
|
//mxd. Applies coped properties
|
|
public void Apply(ICollection<Vertex> verts, bool usecopysettings)
|
|
{
|
|
Apply(verts, (usecopysettings ? CopySettings : defaultsettings));
|
|
}
|
|
|
|
//mxd. Applies coped properties using selected settings
|
|
public void Apply(ICollection<Vertex> verts, VertexPropertiesCopySettings settings)
|
|
{
|
|
foreach(Vertex v in verts)
|
|
{
|
|
if(settings.ZCeiling) v.ZCeiling = zceiling;
|
|
if(settings.ZFloor) v.ZFloor = zfloor;
|
|
if(settings.Fields)
|
|
{
|
|
v.Fields.BeforeFieldsChange();
|
|
ApplyCustomFields(v.Fields);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ================== Sector
|
|
|
|
//mxd
|
|
public class SectorPropertiesCopySettings : MapElementPropertiesCopySettings
|
|
{
|
|
[FieldDescription(Description = "Floor height")]
|
|
public bool FloorHeight = true;
|
|
|
|
[FieldDescription(Description = "Ceiling height")]
|
|
public bool CeilingHeight = true;
|
|
|
|
[FieldDescription(Description = "Floor texture")]
|
|
public bool FloorTexture = true;
|
|
|
|
[FieldDescription(Description = "Ceiling texture")]
|
|
public bool CeilingTexture = true;
|
|
|
|
[FieldDescription(Description = "Floor texture offsets", Field1 = "xpanningfloor", Field2 = "ypanningfloor")]
|
|
public bool FloorTextureOffset = true;
|
|
|
|
[FieldDescription(Description = "Ceiling texture offsets", Field1 = "xpanningceiling", Field2 = "ypanningceiling")]
|
|
public bool CeilingTextureOffset = true;
|
|
|
|
[FieldDescription(Description = "Floor texture scale", Field1 = "xscalefloor", Field2 = "yscalefloor")]
|
|
public bool FloorTextureScale = true;
|
|
|
|
[FieldDescription(Description = "Ceiling texture scale", Field1 = "xscaleceiling", Field2 = "yscaleceiling")]
|
|
public bool CeilingTextureScale = true;
|
|
|
|
[FieldDescription(Description = "Floor texture rotation", Field1 = "rotationfloor")]
|
|
public bool FloorTextureRotation = true;
|
|
|
|
[FieldDescription(Description = "Ceiling texture rotation", Field1 = "rotationceiling")]
|
|
public bool CeilingTextureRotation = true;
|
|
|
|
[FieldDescription(Description = "Floor alpha", Field1 = "alphafloor")]
|
|
public bool FloorAlpha = true;
|
|
|
|
[FieldDescription(Description = "Ceiling alpha", Field1 = "alphaceiling")]
|
|
public bool CeilingAlpha = true;
|
|
|
|
[FieldDescription(Description = "Floor portal alpha", Field1 = "portal_floor_alpha")]
|
|
public bool FloorPortalAlpha = true;
|
|
|
|
[FieldDescription(Description = "Ceiling portal alpha", Field1 = "portal_ceil_alpha")]
|
|
public bool CeilingPortalAlpha = true;
|
|
|
|
[FieldDescription(Description = "Sector brightness")]
|
|
public bool Brightness = true;
|
|
|
|
[FieldDescription(Description = "Floor brightness", Field1 = "lightfloor", Field2 = "lightfloorabsolute")]
|
|
public bool FloorBrightness = true;
|
|
|
|
[FieldDescription(Description = "Ceiling brightness", Field1 = "lightceiling", Field2 = "lightceilingabsolute")]
|
|
public bool CeilingBrightness = true;
|
|
|
|
[FieldDescription(Description = "Floor render style", Field1 = "renderstylefloor")]
|
|
public bool FloorRenderStyle = true;
|
|
|
|
[FieldDescription(Description = "Ceiling render style", Field1 = "renderstyleceiling")]
|
|
public bool CeilingRenderStyle = true;
|
|
|
|
[FieldDescription(Description = "Floor portal render style", Field1 = "portal_floor_overlaytype")]
|
|
public bool FloorPortalRenderStyle = true;
|
|
|
|
[FieldDescription(Description = "Ceiling portal render style", Field1 = "portal_ceil_overlaytype")]
|
|
public bool CeilingPortalRenderStyle = true;
|
|
|
|
[FieldDescription(Description = "Floor slope", DOOM = false, HEXEN = false)]
|
|
public bool FloorSlope = true;
|
|
|
|
[FieldDescription(Description = "Ceiling slope", DOOM = false, HEXEN = false)]
|
|
public bool CeilingSlope = true;
|
|
|
|
[FieldDescription(Description = "Floor terrain", Field1 = "floorterrain")]
|
|
public bool FloorTerrain = true;
|
|
|
|
[FieldDescription(Description = "Ceiling terrain", Field1 = "ceilingterrain")]
|
|
public bool CeilingTerrain = true;
|
|
|
|
[FieldDescription(Description = "Tags")]
|
|
public bool Tag = true;
|
|
|
|
[FieldDescription(Description = "Effect")]
|
|
public bool Special = true;
|
|
|
|
[FieldDescription(Description = "Flags", DOOM = false, HEXEN = false)]
|
|
public bool Flags = true;
|
|
|
|
[FieldDescription(Description = "Light color", Field1 = "lightcolor")]
|
|
public bool LightColor = true;
|
|
|
|
[FieldDescription(Description = "Fade color", Field1 = "fadecolor")]
|
|
public bool FadeColor = true;
|
|
|
|
[FieldDescription(Description = "Desaturation", Field1 = "desaturation")]
|
|
public bool Desaturation = true;
|
|
|
|
[FieldDescription(Description = "Damage type", Field1 = "damagetype")]
|
|
public bool DamageType = true;
|
|
|
|
[FieldDescription(Description = "Damage amount", Field1 = "damageamount")]
|
|
public bool DamageAmount = true;
|
|
|
|
[FieldDescription(Description = "Damage interval", Field1 = "damageinterval")]
|
|
public bool DamageInterval = true;
|
|
|
|
[FieldDescription(Description = "Damage leakiness", Field1 = "leakiness")]
|
|
public bool DamageLeakiness = true;
|
|
|
|
[FieldDescription(Description = "Sound sequence", Field1 = "soundsequence")]
|
|
public bool SoundSequence = true;
|
|
|
|
[FieldDescription(Description = "Gravity", Field1 = "gravity")]
|
|
public bool Gravity = true;
|
|
|
|
[FieldDescription(Description = "Custom fields", DOOM = false, HEXEN = false)]
|
|
public bool Fields = true;
|
|
|
|
[FieldDescription(Description = "Comment", Field1 = "comment")]
|
|
public bool Comment = true;
|
|
}
|
|
|
|
// Sector
|
|
public class SectorProperties : MapElementProperties
|
|
{
|
|
//mxd
|
|
private static SectorPropertiesCopySettings defaultsettings = new SectorPropertiesCopySettings();
|
|
public static SectorPropertiesCopySettings CopySettings = new SectorPropertiesCopySettings();
|
|
|
|
private readonly int floorheight;
|
|
private readonly int ceilheight;
|
|
private readonly string floortexture;
|
|
private readonly string ceilingtexture;
|
|
private readonly int effect;
|
|
private readonly int brightness;
|
|
private readonly double ceilslopeoffset;
|
|
private readonly double floorslopeoffset;
|
|
private readonly Vector3D ceilslope;
|
|
private readonly Vector3D floorslope;
|
|
private readonly List<int> tags;
|
|
private readonly Dictionary<string, bool> flags; //mxd
|
|
|
|
public SectorProperties(Sector s) : base(s.Fields, MapElementType.SECTOR)
|
|
{
|
|
floorheight = s.FloorHeight;
|
|
ceilheight = s.CeilHeight;
|
|
floortexture = s.FloorTexture;
|
|
ceilingtexture = s.CeilTexture;
|
|
brightness = s.Brightness;
|
|
effect = s.Effect;
|
|
ceilslopeoffset = s.CeilSlopeOffset;
|
|
floorslopeoffset = s.FloorSlopeOffset;
|
|
ceilslope = s.CeilSlope;
|
|
floorslope = s.FloorSlope;
|
|
tags = new List<int>(s.Tags); //mxd
|
|
flags = s.GetFlags(); //mxd
|
|
}
|
|
|
|
//mxd. Applies coped properties
|
|
public void Apply(ICollection<Sector> sectors, bool usecopysettings)
|
|
{
|
|
Apply(sectors, (usecopysettings ? CopySettings : defaultsettings));
|
|
}
|
|
|
|
//mxd. Applies coped properties using selected settings
|
|
public void Apply(ICollection<Sector> sectors, SectorPropertiesCopySettings settings)
|
|
{
|
|
foreach(Sector s in sectors)
|
|
{
|
|
if(settings.FloorHeight) s.FloorHeight = floorheight;
|
|
if(settings.CeilingHeight) s.CeilHeight = ceilheight;
|
|
if(settings.FloorTexture) s.SetFloorTexture(floortexture);
|
|
if(settings.CeilingTexture) s.SetCeilTexture(ceilingtexture);
|
|
if(settings.Brightness) s.Brightness = brightness;
|
|
if(settings.Tag) s.Tags = new List<int>(tags); //mxd
|
|
if(settings.Special) s.Effect = effect;
|
|
if(settings.CeilingSlope)
|
|
{
|
|
s.CeilSlopeOffset = ceilslopeoffset;
|
|
s.CeilSlope = ceilslope;
|
|
}
|
|
if(settings.FloorSlope)
|
|
{
|
|
s.FloorSlopeOffset = floorslopeoffset;
|
|
s.FloorSlope = floorslope;
|
|
}
|
|
if(settings.Flags)
|
|
{
|
|
s.ClearFlags(); //mxd
|
|
foreach(KeyValuePair<string, bool> f in flags) //mxd
|
|
s.SetFlag(f.Key, f.Value);
|
|
}
|
|
}
|
|
|
|
// Should we bother?
|
|
if(!General.Map.UDMF) return;
|
|
|
|
// Apply custom fields
|
|
foreach(Sector s in sectors)
|
|
{
|
|
s.Fields.BeforeFieldsChange();
|
|
if(settings.Fields) ApplyCustomFields(s.Fields);
|
|
}
|
|
|
|
// Apply UI fields
|
|
ApplyUIFields(sectors, settings);
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ================== Sidedef
|
|
|
|
//mxd
|
|
public class SidedefPropertiesCopySettings : MapElementPropertiesCopySettings
|
|
{
|
|
[FieldDescription(Description = "Upper texture")]
|
|
public bool UpperTexture = true;
|
|
|
|
[FieldDescription(Description = "Middle texture")]
|
|
public bool MiddleTexture = true;
|
|
|
|
[FieldDescription(Description = "Lower texture")]
|
|
public bool LowerTexture = true;
|
|
|
|
[FieldDescription(Description = "Texture offset X")]
|
|
public bool OffsetX = true;
|
|
|
|
[FieldDescription(Description = "Texture offset Y")]
|
|
public bool OffsetY = true;
|
|
|
|
[FieldDescription(Description = "Upper texture offsets", Field1 = "offsetx_top", Field2 = "offsety_top")]
|
|
public bool UpperTextureOffset = true;
|
|
|
|
[FieldDescription(Description = "Middle texture offsets", Field1 = "offsetx_mid", Field2 = "offsety_mid")]
|
|
public bool MiddleTextureOffset = true;
|
|
|
|
[FieldDescription(Description = "Lower texture offsets", Field1 = "offsetx_bottom", Field2 = "offsety_bottom")]
|
|
public bool LowerTextureOffset = true;
|
|
|
|
[FieldDescription(Description = "Upper texture scale", Field1 = "scalex_top", Field2 = "scaley_top")]
|
|
public bool UpperTextureScale = true;
|
|
|
|
[FieldDescription(Description = "Middle texture scale", Field1 = "scalex_mid", Field2 = "scaley_mid")]
|
|
public bool MiddleTextureScale = true;
|
|
|
|
[FieldDescription(Description = "Lower texture scale", Field1 = "scalex_bottom", Field2 = "scaley_bottom")]
|
|
public bool LowerTextureScale = true;
|
|
|
|
[FieldDescription(Description = "Brightness", Field1 = "light", Field2 = "lightabsolute")]
|
|
public bool Brightness = true;
|
|
|
|
[FieldDescription(Description = "Flags", DOOM = false, HEXEN = false)]
|
|
public bool Flags = true;
|
|
|
|
[FieldDescription(Description = "Custom fields", DOOM = false, HEXEN = false)]
|
|
public bool Fields = true;
|
|
}
|
|
|
|
// Sidedef
|
|
public class SidedefProperties : MapElementProperties
|
|
{
|
|
//mxd
|
|
internal static SidedefPropertiesCopySettings DefaultSettings = new SidedefPropertiesCopySettings();
|
|
public static SidedefPropertiesCopySettings CopySettings = new SidedefPropertiesCopySettings();
|
|
|
|
private readonly string hightexture;
|
|
private readonly string middletexture;
|
|
private readonly string lowtexture;
|
|
private readonly int offsetx;
|
|
private readonly int offsety;
|
|
private readonly Dictionary<string, bool> flags; //mxd
|
|
|
|
public SidedefProperties(Sidedef s) : base(s.Fields, MapElementType.SIDEDEF)
|
|
{
|
|
hightexture = s.HighTexture;
|
|
middletexture = s.MiddleTexture;
|
|
lowtexture = s.LowTexture;
|
|
offsetx = s.OffsetX;
|
|
offsety = s.OffsetY;
|
|
flags = s.GetFlags(); //mxd
|
|
}
|
|
|
|
//mxd. Applies coped properties with all settings enabled
|
|
public void Apply(ICollection<Sidedef> sides, bool usecopysettings)
|
|
{
|
|
Apply(sides, (usecopysettings ? CopySettings : DefaultSettings));
|
|
}
|
|
|
|
//mxd. Applies selected settings
|
|
public void Apply(ICollection<Sidedef> sides, SidedefPropertiesCopySettings settings)
|
|
{
|
|
foreach(Sidedef s in sides)
|
|
{
|
|
if(settings.UpperTexture) s.SetTextureHigh(hightexture);
|
|
if(settings.MiddleTexture) s.SetTextureMid(middletexture);
|
|
if(settings.LowerTexture) s.SetTextureLow(lowtexture);
|
|
if(settings.OffsetX) s.OffsetX = offsetx;
|
|
if(settings.OffsetY) s.OffsetY = offsety;
|
|
if(settings.Flags)
|
|
{
|
|
s.ClearFlags(); //mxd
|
|
foreach(KeyValuePair<string, bool> f in flags) //mxd
|
|
s.SetFlag(f.Key, f.Value);
|
|
}
|
|
}
|
|
|
|
// Should we bother?
|
|
if(!General.Map.UDMF) return;
|
|
|
|
// Apply fields
|
|
foreach(Sidedef s in sides)
|
|
{
|
|
s.Fields.BeforeFieldsChange();
|
|
if(settings.Fields) ApplyCustomFields(s.Fields);
|
|
}
|
|
|
|
// Apply UI fields
|
|
ApplyUIFields(sides, settings);
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ================== Linedef
|
|
|
|
//mxd
|
|
public class LinedefPropertiesCopySettings : MapElementPropertiesCopySettings
|
|
{
|
|
[FieldDescription(Description = "Action")]
|
|
public bool Action = true;
|
|
|
|
[FieldDescription(Description = "Action arguments", DOOM = false)]
|
|
public bool Arguments = true;
|
|
|
|
[FieldDescription(Description = "Activation", DOOM = false, UDMF = false)]
|
|
public bool Activation = true;
|
|
|
|
[FieldDescription(Description = "Tags", HEXEN = false)]
|
|
public bool Tag = true;
|
|
|
|
[FieldDescription(Description = "Flags")]
|
|
public bool Flags = true;
|
|
|
|
[FieldDescription(Description = "Alpha", Field1 = "alpha")]
|
|
public bool Alpha = true;
|
|
|
|
[FieldDescription(Description = "Render style", Field1 = "renderstyle")]
|
|
public bool RenderStyle = true;
|
|
|
|
[FieldDescription(Description = "Lock number", Field1 = "locknumber")]
|
|
public bool LockNumber = true;
|
|
|
|
[FieldDescription(Description = "Custom fields", DOOM = false, HEXEN = false)]
|
|
public bool Fields = true;
|
|
|
|
[FieldDescription(Description = "Comment", Field1 = "comment")]
|
|
public bool Comment = true;
|
|
}
|
|
|
|
// Linedef
|
|
public class LinedefProperties : MapElementProperties
|
|
{
|
|
//mxd
|
|
private static LinedefPropertiesCopySettings defaultsettings = new LinedefPropertiesCopySettings();
|
|
public static LinedefPropertiesCopySettings CopySettings = new LinedefPropertiesCopySettings();
|
|
|
|
private readonly SidedefProperties front;
|
|
private readonly SidedefProperties back;
|
|
private readonly Dictionary<string, bool> flags;
|
|
private readonly int action;
|
|
private readonly int activate;
|
|
private readonly List<int> tags;
|
|
private readonly int[] args;
|
|
|
|
public LinedefProperties(Linedef l) : base(l.Fields, MapElementType.LINEDEF)
|
|
{
|
|
front = (l.Front != null ? new SidedefProperties(l.Front) : null);
|
|
back = (l.Back != null ? new SidedefProperties(l.Back) : null);
|
|
|
|
flags = l.GetFlags();
|
|
action = l.Action;
|
|
activate = l.Activate;
|
|
tags = new List<int>(l.Tags); //mxd
|
|
args = (int[])(l.Args.Clone());
|
|
}
|
|
|
|
//mxd. Applies coped properties with all settings enabled
|
|
public void Apply(ICollection<Linedef> lines, bool usecopysettings) { Apply(lines, usecopysettings, true); }
|
|
public void Apply(ICollection<Linedef> lines, bool usecopysettings, bool applytosidedefs)
|
|
{
|
|
if(usecopysettings)
|
|
Apply(lines, CopySettings, (applytosidedefs ? SidedefProperties.CopySettings : null));
|
|
else
|
|
Apply(lines, defaultsettings, (applytosidedefs ? SidedefProperties.DefaultSettings : null));
|
|
}
|
|
|
|
//mxd. Applies selected linededf and sidedef settings
|
|
public void Apply(ICollection<Linedef> lines, LinedefPropertiesCopySettings settings, SidedefPropertiesCopySettings sidesettings)
|
|
{
|
|
List<Sidedef> frontsides = new List<Sidedef>(lines.Count);
|
|
List<Sidedef> backsides = new List<Sidedef>(lines.Count);
|
|
foreach(Linedef l in lines)
|
|
{
|
|
if(settings.Flags)
|
|
{
|
|
l.ClearFlags();
|
|
foreach(KeyValuePair<string, bool> f in flags)
|
|
l.SetFlag(f.Key, f.Value);
|
|
}
|
|
if(settings.Activation) l.Activate = activate;
|
|
if(settings.Tag) l.Tags = new List<int>(tags); //mxd
|
|
if(settings.Action) l.Action = action;
|
|
if(settings.Arguments)
|
|
{
|
|
for(int i = 0; i < l.Args.Length; i++)
|
|
l.Args[i] = args[i];
|
|
}
|
|
|
|
if(l.Front != null) frontsides.Add(l.Front);
|
|
if(l.Back != null) backsides.Add(l.Back);
|
|
}
|
|
|
|
// Should we bother?
|
|
if(General.Map.UDMF)
|
|
{
|
|
// Apply fields
|
|
foreach(Linedef l in lines)
|
|
{
|
|
l.Fields.BeforeFieldsChange();
|
|
|
|
// Apply string arguments
|
|
if(settings.Arguments)
|
|
{
|
|
Apply(l.Fields, "arg0str");
|
|
|
|
//TODO: re-enable when UI part is ready
|
|
//Apply(l.Fields, "arg1str");
|
|
//Apply(l.Fields, "arg2str");
|
|
//Apply(l.Fields, "arg3str");
|
|
//Apply(l.Fields, "arg4str");
|
|
}
|
|
|
|
// Apply custom fields
|
|
if(settings.Fields) ApplyCustomFields(l.Fields);
|
|
}
|
|
|
|
// Apply UI fields
|
|
ApplyUIFields(lines, settings);
|
|
}
|
|
|
|
// Apply sidedef settings
|
|
if(sidesettings != null)
|
|
{
|
|
if(front != null) front.Apply(frontsides, sidesettings);
|
|
if(back != null) back.Apply(backsides, sidesettings);
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ================== Thing
|
|
|
|
//mxd
|
|
public class ThingPropertiesCopySettings : MapElementPropertiesCopySettings
|
|
{
|
|
[FieldDescription(Description = "Type")]
|
|
public bool Type = true;
|
|
|
|
[FieldDescription(Description = "Angle")]
|
|
public bool Angle = true;
|
|
|
|
[FieldDescription(Description = "Z-height", DOOM = false)]
|
|
public bool ZHeight = true;
|
|
|
|
[FieldDescription(Description = "Pitch", DOOM = false, HEXEN = false)]
|
|
public bool Pitch = true;
|
|
|
|
[FieldDescription(Description = "Roll", DOOM = false, HEXEN = false)]
|
|
public bool Roll = true;
|
|
|
|
[FieldDescription(Description = "Scale", DOOM = false, HEXEN = false)]
|
|
public bool Scale = true;
|
|
|
|
[FieldDescription(Description = "Action", DOOM = false)]
|
|
public bool Action = true;
|
|
|
|
[FieldDescription(Description = "Action arguments", DOOM = false)]
|
|
public bool Arguments = true;
|
|
|
|
[FieldDescription(Description = "Tag", DOOM = false)]
|
|
public bool Tag = true;
|
|
|
|
[FieldDescription(Description = "Flags")]
|
|
public bool Flags = true;
|
|
|
|
[FieldDescription(Description = "Conversation ID", Field1 = "conversation")]
|
|
public bool Conversation = true;
|
|
|
|
[FieldDescription(Description = "Gravity", Field1 = "gravity")]
|
|
public bool Gravity = true;
|
|
|
|
[FieldDescription(Description = "Health multiplier", Field1 = "health")]
|
|
public bool Health = true;
|
|
|
|
[FieldDescription(Description = "Score", Field1 = "score")]
|
|
public bool Score = true;
|
|
|
|
[FieldDescription(Description = "Float bob phase", Field1 = "floatbobphase")]
|
|
public bool FloatBobPhase = true;
|
|
|
|
[FieldDescription(Description = "Alpha", Field1 = "alpha")]
|
|
public bool Alpha = true;
|
|
|
|
[FieldDescription(Description = "Fill color", Field1 = "fillcolor")]
|
|
public bool FillColor = true;
|
|
|
|
[FieldDescription(Description = "Render style", Field1 = "renderstyle")]
|
|
public bool RenderStyle = true;
|
|
|
|
[FieldDescription(Description = "Custom fields", DOOM = false, HEXEN = false)]
|
|
public bool Fields = true;
|
|
|
|
[FieldDescription(Description = "Comment", Field1 = "comment")]
|
|
public bool Comment = true;
|
|
}
|
|
|
|
// Thing
|
|
public class ThingProperties : MapElementProperties
|
|
{
|
|
//mxd
|
|
private static readonly ThingPropertiesCopySettings defaultsettings = new ThingPropertiesCopySettings();
|
|
public static readonly ThingPropertiesCopySettings CopySettings = new ThingPropertiesCopySettings();
|
|
|
|
private readonly int type;
|
|
private readonly double angle;
|
|
private readonly double zheight; //mxd
|
|
private readonly int pitch; //mxd
|
|
private readonly int roll; //mxd
|
|
private readonly double scalex; //mxd
|
|
private readonly double scaley; //mxd
|
|
private readonly Dictionary<string, bool> flags;
|
|
private readonly int tag;
|
|
private readonly int action;
|
|
private readonly int[] args;
|
|
|
|
public ThingProperties(Thing t) : base(t.Fields, MapElementType.THING)
|
|
{
|
|
type = t.Type;
|
|
angle = t.Angle;
|
|
zheight = t.Position.z;
|
|
pitch = t.Pitch;
|
|
roll = t.Roll;
|
|
scalex = t.ScaleX;
|
|
scaley = t.ScaleY;
|
|
flags = t.GetFlags();
|
|
tag = t.Tag;
|
|
action = t.Action;
|
|
args = (int[])(t.Args.Clone());
|
|
}
|
|
|
|
//mxd. Applies coped properties with all settings enabled
|
|
public void Apply(ICollection<Thing> things, bool usecopysettings)
|
|
{
|
|
Apply(things, (usecopysettings ? CopySettings : defaultsettings));
|
|
}
|
|
|
|
//mxd. Applies selected settings
|
|
public void Apply(ICollection<Thing> things, ThingPropertiesCopySettings settings)
|
|
{
|
|
foreach(Thing t in things)
|
|
{
|
|
if(settings.Type) t.Type = type;
|
|
|
|
// Update the setting from the configuration after changing the type. This makes sure all the following
|
|
// actions work, since there can be problems when changing the type from or to thing that has a model defined
|
|
t.UpdateConfiguration();
|
|
|
|
if(settings.Angle) t.Rotate(angle);
|
|
if(settings.ZHeight) t.Move(t.Position.x, t.Position.y, zheight);
|
|
if(settings.Pitch) t.SetPitch(pitch);
|
|
if(settings.Roll) t.SetRoll(roll);
|
|
if(settings.Scale) t.SetScale(scalex, scaley);
|
|
if(settings.Flags)
|
|
{
|
|
t.ClearFlags();
|
|
foreach(KeyValuePair<string, bool> f in flags)
|
|
t.SetFlag(f.Key, f.Value);
|
|
}
|
|
if(settings.Tag) t.Tag = tag;
|
|
if(settings.Action) t.Action = action;
|
|
if(settings.Arguments)
|
|
{
|
|
for(int i = 0; i < t.Args.Length; i++)
|
|
t.Args[i] = args[i];
|
|
}
|
|
}
|
|
|
|
// Should we bother?
|
|
if(!General.Map.UDMF) return;
|
|
|
|
foreach(Thing t in things)
|
|
{
|
|
// Apply fields
|
|
t.Fields.BeforeFieldsChange();
|
|
|
|
// Apply string arguments
|
|
if(settings.Arguments)
|
|
{
|
|
Apply(t.Fields, "arg0str");
|
|
|
|
//TODO: re-enable when UI part is ready
|
|
//Apply(t.Fields, "arg1str");
|
|
//Apply(t.Fields, "arg2str");
|
|
//Apply(t.Fields, "arg3str");
|
|
//Apply(t.Fields, "arg4str");
|
|
}
|
|
|
|
// Apply custom fields
|
|
if(settings.Fields) ApplyCustomFields(t.Fields);
|
|
}
|
|
|
|
// Apply UI fields
|
|
ApplyUIFields(things, settings);
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ================== Properties Comparer
|
|
|
|
//mxd. A class, which checks whether source and target map element's properties match
|
|
public static class PropertiesComparer
|
|
{
|
|
|
|
#region Vertex
|
|
|
|
public static bool PropertiesMatch(VertexPropertiesCopySettings flags, Vertex source, Vertex target)
|
|
{
|
|
if(!General.Map.UDMF) return true;
|
|
|
|
// Built-in properties
|
|
if(flags.ZCeiling && source.ZCeiling != target.ZCeiling) return false;
|
|
if(flags.ZFloor && source.ZFloor != target.ZFloor) return false;
|
|
|
|
// Custom fields
|
|
return !flags.Fields || UniFields.CustomFieldsMatch(source.Fields, target.Fields);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Sector
|
|
|
|
public static bool PropertiesMatch(SectorPropertiesCopySettings flags, Sector source, Sector target)
|
|
{
|
|
// Built-in properties
|
|
if(flags.FloorHeight && source.FloorHeight != target.FloorHeight) return false;
|
|
if(flags.CeilingHeight && source.CeilHeight != target.CeilHeight) return false;
|
|
if(flags.FloorTexture && source.FloorTexture != target.FloorTexture) return false;
|
|
if(flags.CeilingTexture && source.CeilTexture != target.CeilTexture) return false;
|
|
if(flags.Brightness && source.Brightness != target.Brightness) return false;
|
|
if(flags.Tag && !TagsMatch(source.Tags, target.Tags)) return false;
|
|
if(flags.Flags && !FlagsMatch(source.GetEnabledFlags(), target.GetEnabledFlags())) return false;
|
|
|
|
// Generalized effects require more tender loving care...
|
|
if(flags.Special && source.Effect != target.Effect)
|
|
{
|
|
if(!General.Map.Config.GeneralizedEffects || source.Effect == 0 || target.Effect == 0) return false;
|
|
|
|
// Get effect bits...
|
|
SectorEffectData sourcedata = General.Map.Config.GetSectorEffectData(source.Effect);
|
|
SectorEffectData targetdata = General.Map.Config.GetSectorEffectData(target.Effect);
|
|
|
|
// No bits match when at least one effect is not generalized, or when bits don't overlap
|
|
if(sourcedata.Effect != targetdata.Effect
|
|
|| sourcedata.GeneralizedBits.Count != targetdata.GeneralizedBits.Count
|
|
|| !sourcedata.GeneralizedBits.Overlaps(targetdata.GeneralizedBits)) return false;
|
|
}
|
|
|
|
if(!General.Map.UDMF) return true;
|
|
|
|
// UI fields
|
|
if(!UIFieldsMatch(flags, source, target)) return false;
|
|
|
|
// Custom fields
|
|
return !flags.Fields || UniFields.CustomFieldsMatch(source.Fields, target.Fields);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Linedef
|
|
|
|
public static bool PropertiesMatch(LinedefPropertiesCopySettings linedefflags, SidedefPropertiesCopySettings sideflags, Linedef source, Linedef target)
|
|
{
|
|
// Built-in properties
|
|
if(linedefflags.Action && source.Action != target.Action) return false;
|
|
if(linedefflags.Activation && source.Activate != target.Activate) return false;
|
|
if(linedefflags.Tag && !TagsMatch(source.Tags, target.Tags)) return false;
|
|
if(linedefflags.Arguments)
|
|
{
|
|
// Classic args
|
|
for(int i = 0; i < source.Args.Length; i++)
|
|
if(source.Args[i] != target.Args[i]) return false;
|
|
|
|
// String args
|
|
if(General.Map.UDMF)
|
|
{
|
|
if(!UniFields.ValuesMatch("arg0str", source, target)) return false;
|
|
if(!UniFields.ValuesMatch("arg1str", source, target)) return false;
|
|
if(!UniFields.ValuesMatch("arg2str", source, target)) return false;
|
|
if(!UniFields.ValuesMatch("arg3str", source, target)) return false;
|
|
if(!UniFields.ValuesMatch("arg4str", source, target)) return false;
|
|
}
|
|
}
|
|
if(linedefflags.Flags && !FlagsMatch(source.GetEnabledFlags(), target.GetEnabledFlags())) return false;
|
|
|
|
if(General.Map.UDMF)
|
|
{
|
|
// UI fields
|
|
if(!UIFieldsMatch(linedefflags, source, target)) return false;
|
|
|
|
// Custom fields
|
|
if(linedefflags.Fields && !UniFields.CustomFieldsMatch(source.Fields, target.Fields)) return false;
|
|
}
|
|
|
|
// Sidedef properties
|
|
return (source.Front != null && target.Front != null && PropertiesMatch(sideflags, source.Front, target.Front)) ||
|
|
(source.Front != null && target.Back != null && PropertiesMatch(sideflags, source.Front, target.Back)) ||
|
|
(source.Back != null && target.Front != null && PropertiesMatch(sideflags, source.Back, target.Front)) ||
|
|
(source.Back != null && target.Back != null && PropertiesMatch(sideflags, source.Back, target.Back));
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Sidedef
|
|
|
|
public static bool PropertiesMatch(SidedefPropertiesCopySettings flags, Sidedef source, Sidedef target)
|
|
{
|
|
// Built-in properties
|
|
if(flags.OffsetX && source.OffsetX != target.OffsetX) return false;
|
|
if(flags.OffsetY && source.OffsetY != target.OffsetY) return false;
|
|
if(flags.UpperTexture && source.HighTexture != target.HighTexture) return false;
|
|
if(flags.MiddleTexture && source.MiddleTexture != target.MiddleTexture) return false;
|
|
if(flags.LowerTexture && source.LowTexture != target.LowTexture) return false;
|
|
if(!General.Map.UDMF) return true;
|
|
|
|
// UDMF-specific properties
|
|
if(flags.Flags && !FlagsMatch(source.GetEnabledFlags(), target.GetEnabledFlags())) return false;
|
|
|
|
// UI fields
|
|
if(!UIFieldsMatch(flags, source, target)) return false;
|
|
|
|
// Custom fields
|
|
return !flags.Fields || UniFields.CustomFieldsMatch(source.Fields, target.Fields);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Thing
|
|
|
|
public static bool PropertiesMatch(ThingPropertiesCopySettings flags, Thing source, Thing target)
|
|
{
|
|
// Built-in properties
|
|
if(flags.Type && source.Type != target.Type) return false;
|
|
if(flags.Angle && source.AngleDoom != target.AngleDoom) return false;
|
|
if(flags.Action && source.Action != target.Action) return false;
|
|
if(flags.Arguments)
|
|
{
|
|
// Classic args
|
|
for(int i = 0; i < source.Args.Length; i++)
|
|
if(source.Args[i] != target.Args[i]) return false;
|
|
|
|
// String args
|
|
if(General.Map.UDMF)
|
|
{
|
|
if(!UniFields.ValuesMatch("arg0str", source, target)) return false;
|
|
if(!UniFields.ValuesMatch("arg1str", source, target)) return false;
|
|
if(!UniFields.ValuesMatch("arg2str", source, target)) return false;
|
|
if(!UniFields.ValuesMatch("arg3str", source, target)) return false;
|
|
if(!UniFields.ValuesMatch("arg4str", source, target)) return false;
|
|
}
|
|
}
|
|
if(flags.Tag && source.Tag != target.Tag) return false;
|
|
if(flags.Flags && !FlagsMatch(source.GetEnabledFlags(), target.GetEnabledFlags())) return false;
|
|
if(!General.Map.UDMF) return true;
|
|
|
|
// UDMF-specific properties
|
|
if(flags.Pitch && source.Pitch != target.Pitch) return false;
|
|
if(flags.Roll && source.Roll != target.Roll) return false;
|
|
if(flags.Scale && (source.ScaleX != target.ScaleX) || (source.ScaleY != target.ScaleY)) return false;
|
|
|
|
// UI fields
|
|
if(!UIFieldsMatch(flags, source, target)) return false;
|
|
|
|
// Custom fields
|
|
return !flags.Fields || UniFields.CustomFieldsMatch(source.Fields, target.Fields);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Utility
|
|
|
|
private static bool FlagsMatch(HashSet<string> flags1, HashSet<string> flags2)
|
|
{
|
|
if(flags1.Count != flags2.Count) return false;
|
|
foreach(string flag in flags1)
|
|
{
|
|
if(!flags2.Contains(flag)) return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
//mxd
|
|
private static bool TagsMatch(List<int> tags1, List<int> tags2)
|
|
{
|
|
if(!General.Map.UDMF) return tags1[0] == tags2[0];
|
|
|
|
if(tags1.Count != tags2.Count) return false;
|
|
Dictionary<int, int> count = new Dictionary<int, int>();
|
|
|
|
foreach(int s in tags1)
|
|
{
|
|
if(count.ContainsKey(s)) count[s]++;
|
|
else count.Add(s, 1);
|
|
}
|
|
|
|
foreach(int s in tags2)
|
|
{
|
|
if(count.ContainsKey(s)) count[s]--;
|
|
else return false;
|
|
}
|
|
|
|
return count.Values.All(c => c == 0);
|
|
}
|
|
|
|
private static bool UIFieldsMatch(MapElementPropertiesCopySettings settings, MapElement first, MapElement second)
|
|
{
|
|
FieldInfo[] props = settings.GetType().GetFields(BindingFlags.Public | BindingFlags.Instance);
|
|
foreach(FieldInfo prop in props)
|
|
{
|
|
// Property set?
|
|
if(!(bool)prop.GetValue(settings)) continue;
|
|
|
|
foreach(Attribute attr in Attribute.GetCustomAttributes(prop))
|
|
{
|
|
if(attr.GetType() != typeof(FieldDescription)) continue;
|
|
FieldDescription fd = (FieldDescription)attr;
|
|
if(fd.SupportsCurrentMapFormat && !string.IsNullOrEmpty(fd.Field1))
|
|
{
|
|
if(!string.IsNullOrEmpty(fd.Field2))
|
|
{
|
|
if(!UniFields.ValuesMatch(fd.Field1, fd.Field2, first, second)) return false;
|
|
}
|
|
else
|
|
{
|
|
if(!UniFields.ValuesMatch(fd.Field1, first, second)) return false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
|
|
#endregion
|
|
|
|
}
|