Commit: 0be55ec229ad88a4b854fb1f73231ba2774bdb59 - adjustor (git)

Adjustor mod plugin for VS

Commit MetaInfo

• Revision: 0be55ec229ad88a4b854fb1f73231ba2774bdb59 (tree)
• Zeit: 2019-06-06 07:18:55
• Autor: melchior <melchior@user...>
• Commiter: melchior

Log Message

Reworked applicability detection,
removed outdated comments

Ändern Zusammenfassung

• modified: AdjustorMod/AdjustorMod.cs
• modified: AdjustorMod/ItemAdjustor.cs

Diff

--- a/AdjustorMod/AdjustorMod.cs
+++ b/AdjustorMod/AdjustorMod.cs
@@ -29,7 +29,7 @@ namespace Adjustor
 			base.Start(api);
 			api.RegisterItemClass(_name, typeof(ItemAdjustor));
 			Mod.Logger.Debug( "Registered - {0}", _name );
-			//TODO: Register client / server side tool config command
+
 		}
 	}
 }

--- a/AdjustorMod/ItemAdjustor.cs
+++ b/AdjustorMod/ItemAdjustor.cs
@@ -27,35 +27,43 @@ namespace Adjustor
 		private ICoreClientAPI ClientApi { get; set; }
 
 		private const string _toolMode = @"toolMode";
+		private const string _sideKey = @"side";
+		private const string _rotKey = @"rot";//Slabs use this key instead....
+		private const string _axialRotationKey = @"rotation";//Trees and Pillars; ns, we, ud - axial rotation
 
-		private static string[] rotationCodes = new string[]
+		private static string _simpleCoatingClass = @"BlockSimpleCoating";//Similar to slabs...
+
+		private static string[] _cardinalCodes = new string[]
 		{
-			@"up",
-			@"down",
 			@"north",
 			@"south",
 			@"east",
 			@"west",
-			//tree logs;
+		};
+
+		private static string[] _verticalCodes = new string[]
+		{
+			@"up",
+			@"down",
+		};
+
+		private static string[] _axialRotationCodes = new string[]
+		{			
+			//tree logs, and tree log-like things; pillars, axles....;
 			@"ud",
 			@"ns",
 			@"we"
 		};
 
-		private static string[] blacklistedClasses = new string[]
+		private static string[] _blacklistedClasses = new string[]
 		{
 			@"BlockBed",
 			@"BlockDoor",
 			@"BlockTroughDoubleBlock",
-			@"BlockFence" //TODO:Need to figure out a better way..
-		};
-
-		private static string[] whitelistedClasses = new string[] //FIXME This should work...
-		{
-			@"placeholder",
+			@"BlockFence" //FIXME: Blacklist of Multi-block entites until futher notice.
 		};
 
-		private static string[] blacklistedEntityClasses = new string[]
+		private static string[] _blacklistedEntityClasses = new string[]
 		{
 			@"GenericTypedContainer",
 		};
@@ -64,6 +72,7 @@ namespace Adjustor
 		{
 			"verticalorientation",
 			"rot",
+			"side"//linen, plates, ect... used inconsistently
 		};
 
 		private static string[] _horizontalVariantKeys = new string[]
@@ -73,6 +82,15 @@ namespace Adjustor
 			"side"
 		};
 
+		private static string[] _slabesqueCodes = new string[]
+		{
+			"slab",//many things with 'slab' in name, some at begin some at end...
+
+		};
+
+
+
+
 		public ItemAdjustor( ) : base( )
 		{
 			
@@ -122,7 +140,7 @@ namespace Adjustor
 					BlockPos position = blockSel.Position;
 					Block thatBlock = byEntity.World.BlockAccessor.GetBlock(position);
 
-					if (RotatableByDirection(thatBlock) || RotatableByBehavior(thatBlock)) {
+					if (RotatableByVariant(thatBlock) || RotatableByBehavior(thatBlock)) {
 						#if DEBUG
 						Logger.VerboseDebug("[{0}] Looks Rotatable, FromFace: {1}", thatBlock.Code.Path, blockSel.Face.Code);
 						ClientApi.ShowChatMessage(string.Format("Appears Rotatable: {0}", thatBlock.Code));
@@ -313,31 +331,29 @@ namespace Adjustor
 		/// <param name="thatBlock">That block.</param>
 		private static bool IsBlacklisted(Block thatBlock)
 		{
-			if (blacklistedEntityClasses.Contains(thatBlock.EntityClass)
-				|| blacklistedClasses.Contains(thatBlock.Class))
+			if (_blacklistedEntityClasses.Contains(thatBlock.EntityClass)
+				|| _blacklistedClasses.Contains(thatBlock.Class))
 				return true;
 
 			return false;
 		}
 
 		/// <summary>
-		/// Is it Rotatable, possibly with Known direction?
+		/// Is it Rotatable, possibly with Variant key that is known to be a direction?
 		/// </summary>
 		/// <returns><c>true</c>, if rotatable, <c>false</c> otherwise.</returns>
 		/// <param name="thatBlock">A block.</param>
-		private static bool RotatableByDirection(Block thatBlock)
+		private static bool RotatableByVariant(Block thatBlock)
 		{
 			if (thatBlock != null) {
 
-				if (thatBlock.Class != null && whitelistedClasses.Any(wc => thatBlock.Class.Equals(wc)))//BROKEN!
-					{
-					//Whitelisted
-					return true;
-				} else if
-			(thatBlock.IsMissing == false
-			&& thatBlock.MatterState == EnumMatterState.Solid
-			&& rotationCodes.Any(rc => thatBlock.Code.Path.Contains(rc))
-			) {
+			if (thatBlock.IsMissing == false && thatBlock.MatterState == EnumMatterState.Solid
+				&& (_verticalVariantKeys.Any(vvk => thatBlock.Variant.Keys.Contains(vvk)) ||
+				    _horizontalVariantKeys.Any(hvk => thatBlock.Variant.Keys.Contains(hvk)) ||
+				    thatBlock.Variant.Keys.Contains(_axialRotationKey)
+				   )
+			)
+				{
 					return true;
 				}
 			}
@@ -355,7 +371,9 @@ namespace Adjustor
 			if (thatBlock != null) {
 
 				if (thatBlock.BlockBehaviors.Length > 0) {
+					#if DEBUG
 					Logger.VerboseDebug("Block {0} has {1} #behaviors", thatBlock.Code.ToShortString( ), thatBlock.BlockBehaviors.Length);
+					#endif
 				}
 
 				if (thatBlock.HasBehavior("OmniRotatable", ClientApi.ClassRegistry)
@@ -371,20 +389,71 @@ namespace Adjustor
 		}
 
 		/// <summary>
+		/// Determines if slab, sheet, plate type block in a N/E/W/S configuration
+		/// </summary>
+		/// <returns><c>true</c> if is slab NEW the specified thatBlock; otherwise, <c>false</c>.</returns>
+		/// <param name="thatBlock">That block.</param>
+		private static bool IsSpecialCaseNEWS(Block thatBlock)
+		{
+			if (_simpleCoatingClass.Equals(thatBlock.Class, StringComparison.OrdinalIgnoreCase)) {
+
+				if (thatBlock.Variant.ContainsKey(_sideKey)) {
+
+					if (_cardinalCodes.Contains(thatBlock.Variant[_sideKey])) return true;
+				}
+			}
+
+			if (_slabesqueCodes.Any(thatBlock.Code.Path.Contains)) {
+
+				string rotationKey = thatBlock.Variant.Keys.FirstOrDefault(_horizontalVariantKeys.Contains);
+
+				if (_cardinalCodes.Contains(thatBlock.Variant[rotationKey])) return true;
+			}
+			return false;
+		}
+
+		/// <summary>
+		/// Determines if slab, sheet, plate type block in a U/D configuration
+		/// </summary>
+		/// <returns><c>true</c> if is slab NEW the specified thatBlock; otherwise, <c>false</c>.</returns>
+		/// <param name="thatBlock">That block.</param>
+		private static bool IsSpecialCaseUD(Block thatBlock)
+		{
+			if (_simpleCoatingClass.Equals(thatBlock.Class, StringComparison.OrdinalIgnoreCase)) {
+
+				if (thatBlock.Variant.ContainsKey(_sideKey)) {
+
+					if (_verticalCodes.Contains(thatBlock.Variant[_sideKey])) return true;
+				}
+			}
+
+			if (_slabesqueCodes.Any(thatBlock.Code.Path.Contains)) {
+
+				string rotationKey = thatBlock.Variant.Keys.FirstOrDefault(_verticalVariantKeys.Contains);
+
+				if (_verticalCodes.Contains(thatBlock.Variant[rotationKey])) return true;
+			}
+			return false;
+		}
+
+		/// <summary>
 		/// Changes AssetLocation from a N/E/W/S Slab into a UP slab.
 		/// </summary>
 		/// <returns>The slab vertical flip case.</returns>
 		/// <param name="thatBlock">That block.</param>
-		private static AssetLocation SpecialSlabVerticalFlipCase(Block thatBlock)
-		{
-			//Slab in North / East / West / South - but needs to be UP 
-			string directionName = thatBlock.Code.Path.Split("-".ToCharArray( )).Last( );
-			var redirectionPath = thatBlock.Code.Path.Replace(directionName, @"up");
-			//Regex.Replace( thatBlock.Code.Path, @"-\w*$", @"-up" );
+		private static AssetLocation SpecialVerticalFlipCase(Block thatBlock)
+		{			
+			string rotationKey = thatBlock.Variant.Keys.FirstOrDefault(_horizontalVariantKeys.Contains);//There better be only 1 dimension here!
+			string redirectionPath = null;
+
+			if (!string.IsNullOrEmpty(rotationKey)) {
+				string horizontalValue = thatBlock.Variant[rotationKey];
+				//Slab in North / East / West / South - but needs to be UP 
 
-			//AssetLocation.LocationSeparator
+				redirectionPath = thatBlock.Code.Path.Replace(horizontalValue, @"up");
+			}
 
-			return new AssetLocation(thatBlock.Code.Domain, redirectionPath);//game or item tags?
+			return new AssetLocation(thatBlock.Code.Domain, redirectionPath);
 		}
 
 		/// <summary>
@@ -392,24 +461,34 @@ namespace Adjustor
 		/// </summary>
 		/// <returns>The slab vertical flip case.</returns>
 		/// <param name="thatBlock">That block.</param>
-		private static AssetLocation SpecialSlabHorizontalFlipCase(Block thatBlock)
+		private static AssetLocation SpecialHorizontalFlipCase(Block thatBlock)
 		{
-			//Slab in  UP / DOWN - but needs to be north
-			string directionName = thatBlock.Code.Path.Split("-".ToCharArray( )).Last( );
-			var redirectionPath = thatBlock.Code.Path.Replace(directionName, @"north");
-			//Regex.Replace( thatBlock.Code.Path, @"-\w*$", @"-up" );
+			string rotationKey = thatBlock.Variant.Keys.FirstOrDefault(_verticalVariantKeys.Contains);//There better be only 1 dimension here!
+			string redirectionPath = null;
+
+			if (!string.IsNullOrEmpty(rotationKey)) {
+				string verticalValue = thatBlock.Variant[rotationKey];
+				//Slab in Up / Down - but needs to be NORTH
 
-			//AssetLocation.LocationSeparator
+				redirectionPath = thatBlock.Code.Path.Replace(verticalValue, @"north");
+			}
 
-			return new AssetLocation(thatBlock.Code.Domain, redirectionPath);//game or item tags?
+			return new AssetLocation(thatBlock.Code.Domain, redirectionPath);
 		}
 
-		private static AssetLocation WoodOmniFlip(Block thatBlock, EnumAxis axis, bool axisNormal)
+		/// <summary>
+		/// For flipping Axial oriented things
+		/// </summary>
+		/// <returns>The omni flip.</returns>
+		/// <param name="thatBlock">That block.</param>
+		/// <param name="axis">Axis.</param>
+		/// <param name="axisNormal">Axis normal.</param>
+		private static AssetLocation AxialOmniFlip(Block thatBlock, EnumAxis axis, bool axisNormal)
 		{
 			string oppositeDirection = string.Empty;
 
 			//wood Log by: ns / we - change to opposite
-			string directionName = thatBlock.Code.Path.Split("-".ToCharArray( )).Last( );
+			string directionName = thatBlock.Variant[_axialRotationKey];
 			if (axisNormal) {
 				switch (directionName) {
 				case @"ud":
@@ -442,49 +521,13 @@ namespace Adjustor
 		}
 
 		/// <summary>
-		/// Determines if is slab in N/E/W/S configuration
+		/// Is this a axial type thing / wood log?
 		/// </summary>
-		/// <returns><c>true</c> if is slab NEW the specified thatBlock; otherwise, <c>false</c>.</returns>
-		/// <param name="thatBlock">That block.</param>
-		private static bool IsSlabNEWS(Block thatBlock)
-		{
-			string firstName = thatBlock.Code.Path.Split("-".ToCharArray( )).First( );
-
-			if (firstName.EndsWith(@"slab", StringComparison.Ordinal)) {
-				if (thatBlock.Code.Path.EndsWith("north", StringComparison.Ordinal)
-				|| thatBlock.Code.Path.EndsWith("south", StringComparison.Ordinal)
-				|| thatBlock.Code.Path.EndsWith("east", StringComparison.Ordinal)
-				|| thatBlock.Code.Path.EndsWith("west", StringComparison.Ordinal)) {
-					return true;
-				}
-				//Its UP/DOWN...Thus false.
-			}
-			return false;
-		}
-
-		/// <summary>
-		/// Determines if is slab in N/E/W/S configuration
-		/// </summary>
-		/// <returns><c>true</c> if is slab NEW the specified thatBlock; otherwise, <c>false</c>.</returns>
+		/// <returns>If its axial.</returns>
 		/// <param name="thatBlock">That block.</param>
-		private static bool IsSlabUD(Block thatBlock)
+		private static bool IsAxialOriented(Block thatBlock)
 		{
-			string firstName = thatBlock.Code.Path.Split("-".ToCharArray( )).First( );
-
-			if (firstName.EndsWith(@"slab", StringComparison.Ordinal)) {
-				if (thatBlock.Code.Path.EndsWith("up", StringComparison.Ordinal)
-					|| thatBlock.Code.Path.EndsWith("down", StringComparison.Ordinal)
-					 ) {
-					return true;
-				}
-				//Its UP/DOWN...Thus false.
-			}
-			return false;
-		}
-
-		private static bool IsWoodLog(Block thatBlock)
-		{
-			return thatBlock.Code.FirstPathPart(0).StartsWith(@"log", StringComparison.Ordinal);
+			return thatBlock.Variant.ContainsKey(_axialRotationKey);
 		}
 
 
@@ -513,22 +556,33 @@ namespace Adjustor
 			}
 
 			if (rotateHorizontal) {
-#if DEBUG
+				#if DEBUG
 				ServerApi.SendMessage(thePlayer, GlobalConstants.CurrentChatGroup, "Angle N/E/W/S.", EnumChatType.Notification);
-#endif
+				#endif
 
 				//So many HORIZONTAL Special Cases...
 				renamedAsset = thatBlock.GetRotatedBlockCode(90);//Except Fences 
 
-				if (IsSlabUD(thatBlock)) renamedAsset = SpecialSlabHorizontalFlipCase(thatBlock);
+				if (IsSpecialCaseUD(thatBlock)) {					
+					renamedAsset = SpecialHorizontalFlipCase(thatBlock);
+					#if DEBUG
+					Logger.VerboseDebug("{0} Special UP/DN Case {1}", thatBlock.Code, renamedAsset);
+					#endif
+				}
 
-				if (IsWoodLog(thatBlock)) renamedAsset = WoodOmniFlip(thatBlock, blockSel.Face.Axis, rotateHorizontal); //Wood logs also special
+				if (IsAxialOriented(thatBlock)) {
+					
+					renamedAsset = AxialOmniFlip(thatBlock, blockSel.Face.Axis, rotateHorizontal); //Wood logs also special
+					#if DEBUG
+					Logger.VerboseDebug("{0} Special Axial Case {1}", thatBlock.Code, renamedAsset);
+					#endif
+				}
 
 
 				if (renamedAsset != thatBlock.Code) {
-#if DEBUG
-					Logger.VerboseDebug("{0} Becomes {1}", thatBlock.Code, renamedAsset);
-#endif
+					#if DEBUG
+					Logger.VerboseDebug("{0} Horizontalize: {1}", thatBlock.Code, renamedAsset);
+					#endif
 
 					var rotatedBlock = ServerApi.World.GetBlock(renamedAsset);
 					if (rotatedBlock != null) {
@@ -538,22 +592,33 @@ namespace Adjustor
 					}
 				}
 			} else {
-#if DEBUG
+				#if DEBUG
 				ServerApi.SendMessage(thePlayer, GlobalConstants.CurrentChatGroup, "Angle U/D.", EnumChatType.Notification);
-#endif
+				#endif
 
 				renamedAsset = thatBlock.GetVerticallyFlippedBlockCode( );
 
-				//Special Case for Slabs in N/E/S/W mode when trying to rotate them back 'up'
-				if (IsSlabNEWS(thatBlock)) renamedAsset = SpecialSlabVerticalFlipCase(thatBlock);
+				//Special Case for Slabs, Sheets in N/E/S/W mode when trying to rotate them back 'up'
+				if (IsSpecialCaseNEWS(thatBlock)) {
+					renamedAsset = SpecialVerticalFlipCase(thatBlock);
+					#if DEBUG
+					Logger.VerboseDebug("{0} Special N/E/W/S Case {1}", thatBlock.Code, renamedAsset);
+					#endif
+				}
 
-				if (IsWoodLog(thatBlock)) renamedAsset = WoodOmniFlip(thatBlock, blockSel.Face.Axis, rotateHorizontal); //Wood logs also special
+				if (IsAxialOriented(thatBlock)) 
+				{
+					renamedAsset = AxialOmniFlip(thatBlock, blockSel.Face.Axis, rotateHorizontal); //Wood logs also special
+					#if DEBUG
+					Logger.VerboseDebug("{0} Special Axial Case {1}", thatBlock.Code, renamedAsset);
+					#endif
+				}
 
 				if (renamedAsset != thatBlock.Code) {
 
-#if DEBUG
-					Logger.VerboseDebug("{0} Becomes {1}", thatBlock.Code, renamedAsset);
-#endif
+					#if DEBUG
+					Logger.VerboseDebug("{0} Verticallize: {1}", thatBlock.Code, renamedAsset);
+					#endif
 
 					var rotatedBlock = ServerApi.World.GetBlock(renamedAsset);
 					if (rotatedBlock != null) {
@@ -594,7 +659,9 @@ namespace Adjustor
 						Logger.VerboseDebug("{0} CAN'T EXCHANGE {1}", thatBlock.Code, renamedAsset);
 					}
 				} else {
+					#if DEBUG
 					Logger.VerboseDebug("{0} IDENTICAL!? {1}", thatBlock.Code, renamedAsset);
+					#endif
 				}
 			}
 		}
@@ -609,7 +676,7 @@ namespace Adjustor
 			case RotationModes.Up:
 			case RotationModes.Down:
 
-				rotationKey = thatBlock.Variant.Keys.FirstOrDefault(_verticalVariantKeys.Contains);//There better be only 1 axies here!
+				rotationKey = thatBlock.Variant.Keys.FirstOrDefault(_verticalVariantKeys.Contains);//There better be only 1 dimension here!
 				if (!string.IsNullOrEmpty(rotationKey))
 				{
 					string roatableValue = thatBlock.Variant[rotationKey];
@@ -629,7 +696,7 @@ namespace Adjustor
 			case RotationModes.West:
 			case RotationModes.South:
 
-				rotationKey = thatBlock.Variant.Keys.FirstOrDefault(_horizontalVariantKeys.Contains);//There better be only 1 axies here!
+				rotationKey = thatBlock.Variant.Keys.FirstOrDefault(_horizontalVariantKeys.Contains);//There better be only 1 dimension here!
 				if (!string.IsNullOrEmpty(rotationKey)) {
 					string roatableValue = thatBlock.Variant[rotationKey];