Add custom stats dumping support, skis and minor tweaks

Pixi/Audio/MidiImporter.cs

@@ -31,6 +31,8 @@ namespace Pixi.Audio
 
         public static byte Key = 0;
 
+        public static float VolumeMultiplier = 1f;
+
         public MidiImporter()
         {
             AudioTools.GenerateProgramMap();
@@ -49,10 +51,6 @@ namespace Pixi.Audio
             Logging.MetaLog($"Found {midi.GetNotes().Count()} notes over {midi.GetDuration<MidiTimeSpan>().TimeSpan} time units");
             BlockJsonInfo[] blocks = new BlockJsonInfo[(midi.GetNotes().Count() * 2) + 3];
             List<BlockJsonInfo> blocksToBuild = new List<BlockJsonInfo>();
-#if DEBUG
-            // test (for faster, but incomplete, imports)
-            if (blocks.Length > 103) blocks = new BlockJsonInfo[103];
-#endif
             // convert Midi notes to sfx blocks
             Dictionary<long, uint> breadthCache = new Dictionary<long, uint>();
             Dictionary<long, uint> depthCache = new Dictionary<long, uint>();
@@ -194,7 +192,7 @@ namespace Pixi.Audio
                 sfx.Pitch = n.NoteNumber - 60 + Key; // In MIDI, 60 is middle C, but GC uses 0 for middle C
                 sfx.TrackIndex = channelPrograms[n.Channel];
                 sfx.Is3D = ThreeDee;
-                sfx.Volume = AudioTools.VelocityToVolume(n.Velocity);
+                sfx.Volume = AudioTools.VelocityToVolume(n.Velocity) * VolumeMultiplier;
                 count++;
                 // connect wires
                 if (t == null) continue; // this should never happen

Pixi/Common/CommandRoot.cs

@@ -564,6 +564,58 @@ namespace Pixi.Common
                             }
                         }
                         break;
+                    case BlockIDs.DampedSpring:
+                        string[] springSplit = pVONs[i].metadata.Split('\t');
+                        if (springSplit.Length > 1 && float.TryParse(springSplit[1], out float stiffness))
+                        {
+                            DampedSpring d = blocks[i].Specialise<DampedSpring>();
+                            d.Stiffness = stiffness;
+                            if (springSplit.Length > 2 && float.TryParse(springSplit[2], out float damping))
+                            {
+                                d.Damping = damping;
+                            }
+                        }
+                        break;
+                    case BlockIDs.ServoAxle:
+                    case BlockIDs.ServoHinge:
+                    case BlockIDs.PneumaticAxle:
+                    case BlockIDs.PneumaticHinge:
+                        string[] servoSplit = pVONs[i].metadata.Split('\t');
+                        if (servoSplit.Length > 1 && float.TryParse(servoSplit[1], out float minAngle))
+                        {
+                            Servo s = blocks[i].Specialise<Servo>();
+                            s.MinimumAngle = minAngle;
+                            if (servoSplit.Length > 2 && float.TryParse(servoSplit[2], out float maxAngle))
+                            {
+                                s.MaximumAngle = maxAngle;
+                                if (servoSplit.Length > 3 && float.TryParse(servoSplit[3], out float maxForce))
+                                {
+                                    s.MaximumForce = maxForce;
+                                    if (servoSplit.Length > 4 && bool.TryParse(servoSplit[4], out bool reverse))
+                                    {
+                                        s.Reverse = reverse;
+                                    }
+                                }
+                            }
+                        }
+                        break;
+                    case BlockIDs.MotorM:
+                    case BlockIDs.MotorS:
+                        string[] motorSplit = pVONs[i].metadata.Split('\t');
+                        if (motorSplit.Length > 1 && float.TryParse(motorSplit[1], out float topSpeed))
+                        {
+                            Motor m = blocks[i].Specialise<Motor>();
+                            m.TopSpeed = topSpeed;
+                            if (motorSplit.Length > 2 && float.TryParse(motorSplit[2], out float torque))
+                            {
+                                m.Torque = torque;
+                                if (motorSplit.Length > 3 && bool.TryParse(motorSplit[3], out bool reverse))
+                                {
+                                    m.Reverse = reverse;
+                                }
+                            }
+                        }
+                        break;
                     default: break; // do nothing
                 }
             }

Pixi/Common/VoxelObjectNotationUtility.cs

@@ -42,7 +42,7 @@ namespace Pixi.Common
 		public static BlockJsonInfo JsonObject(Block block, float[] origin = null)
 		{
 			if (origin == null) origin = origin_base;
-			return new BlockJsonInfo
+			BlockJsonInfo jsonInfo = new BlockJsonInfo
 			{
 				name = block.Type.ToString(),
 				position = new float[3] { block.Position.x - origin[0], block.Position.y - origin[1], block.Position.z - origin[2]},
@@ -50,6 +50,37 @@ namespace Pixi.Common
 				color = ColorSpaceUtility.UnquantizeToArray(block.Color),
 				scale = new float[3] {block.Scale.x, block.Scale.y, block.Scale.z},
 			};
+			// custom stats for special blocks
+			switch (block.Type)
+			{
+				case BlockIDs.TextBlock:
+					TextBlock t = block.Specialise<TextBlock>();
+					jsonInfo.name += "\t" + t.Text + "\t" + t.TextBlockId;
+					break;
+				case BlockIDs.ConsoleBlock:
+					ConsoleBlock c = block.Specialise<ConsoleBlock>();
+					jsonInfo.name += "\t" + c.Command + "\t" + c.Arg1 + "\t" + c.Arg2 + "\t" + c.Arg3;
+					break;
+				case BlockIDs.DampedSpring:
+					DampedSpring d = block.Specialise<DampedSpring>();
+					jsonInfo.name += "\t" + d.Stiffness + "\t" + d.Damping;
+					break;
+				case BlockIDs.ServoAxle:
+				case BlockIDs.ServoHinge:
+				case BlockIDs.PneumaticAxle:
+				case BlockIDs.PneumaticHinge:
+					Servo s = block.Specialise<Servo>();
+					jsonInfo.name += "\t" + s.MinimumAngle + "\t" + s.MaximumAngle + "\t" + s.MaximumForce + "\t" +
+					                 s.Reverse;
+					break;
+				case BlockIDs.MotorM:
+				case BlockIDs.MotorS:
+					Motor m = block.Specialise<Motor>();
+					jsonInfo.name += "\t" + m.TopSpeed + "\t" + m.Torque + "\t" + m.Reverse;
+					break;
+				default: break;
+			}
+			return jsonInfo;
 		}
 
 		public static BlockIDs NameToEnum(BlockJsonInfo block)