Simple Bit Recovery

/// <summary>
/// Effectively the ratio of recovered split bits to ingots times 10. A setting of 21 would allow roughly 20 bits to be recovered from 42 split voxels.
/// Default setting of 24 allows for good, but not perfect, bit recovery while smithing.
/// Any value below 21 can hypothetically dupe bits.
/// Any value below 1 is invalid and the game will assume your config is broken and regenerate it.
/// </summary>
public int BitRecoverySmithingModulo = 28;

/// <summary>
/// The exact ratio of bits to voxels to recover when breaking a work item down with a chisel.
/// Default value of 2.1 allows for 20 bits to be recovered from a full ingot, and 38 from a plate.
/// Any value below 2.1 may allow bits to be multiplied through creating work items and chiseling them.
/// Any value below 0 is invalid the game will assume your config is broken and regenerate it.
/// </summary>
public double BitRecoveryChiselRatio = 2.1d;

/// <summary>
/// How fast and far bits will fly from the work item horizontally.
/// Default value of 0.05 is just a little bit of momentum, anything over about 0.3 will be very fast.
/// Set to 0 to disable momentum, though the bits may still move once their collision detects the work item.
/// </summary>
public double BitHorizonalMomentum = 0.05d;

/// <summary>
/// How fast and far bits will fly from the work item vertically.
/// Default value of 0.1 will pop them up a little bit, not too much. Higher values of course will add more momentum.
/// Random roll between BitVerticalMomentumMin and BitVerticalMomentumMax * value.
/// Set to 0 to disable momentum, though the bits may still slide horizontally or gain slight vertical momentum through work item collision.
/// </summary>
public double BitVerticalMomentum = 0.1d;

/// <summary>
/// The minimum possible value of BitVerticalMomentum to use. Default is 0.2, or 20% speed.
/// Typical values should be between 0.0 and 1.0. Negative values may cause strange results.
/// </summary>
public double BitVerticalMomentumMin = 0.2d;

/// <summary>
/// The maximum possible value of BitVerticalMomentum to use. Default is 1.0, or 100% speed.
/// Typical values should be between 0.0 and 1.0. Negative values may cause strange results.
/// </summary>
public double BitVerticalMomentumMax = 1.0d;

/// <summary>
/// This is probably only useful if you have a mod installed that lets you smith ingots. I added it just to be safe.
///
/// When true, ingots always use the vanilla (or otherwise modded) recipe's bit return.
/// NOTE: Normally, they do this anyway, since they have no smithing recipe.
///
/// If this is set to false, ingots are subject to the same BitRecoveryChiselRatio as every other item.
/// On default settings, they will still give 20 bits for a recipe with 42 voxels, but if you reduce
/// that efficiency it will also reduce the storage efficiency of ingots if this setting is false AND you have a smithing recipe for ingots.
/// </summary>
public bool AlwaysUseIngotChiselRecipe = true;

/// <summary>
/// Enables an alternate bloom generation function that ensures a minimum of 42 metal voxels per bloom. Super important if you pair it with the
/// helve hammer fix, and super important for general consistency. The likelihood in vanilla of getting a sub-42 metal voxel bloom is very, very, very low,
/// but not zero. With this, it's zero.
///
/// If you already have a mod with this sort of fix, you can disable this one.
/// </summary>
public bool EnableBloomVoxelFix = true;

/// <summary>
/// Enables a check on blooms to make them not work with the helve hammer unless they have enough material. Again, super important if you're allowing bit recovery
/// from blooms.
///
/// If you already have a mod with this sort of fix, you can disable this one.
/// </summary>
public bool EnableHelveHammerBloomDupeFix = true;

/// <summary>
/// Enables bit drops when a helve hammer does a split operation.
/// Uses EXACTLY the same rules as normal splitting, because it literally just calls the modified split postfix function with appropriate
/// arguments to make it happen. Without other mods or setting changes, this isn't a huge change, it's just one extra bit from plates.
/// With other mods, such as Helve Hammer Extensions, this allows you to properly gain bits back with your auto-crafting shennanigans.
///
/// NOTE: Due to how this is implemented, you MUST have settings on normal splitting that allow bit recovery to get bits here.
/// I'm not sure why you would use this mod and somehow shut off bit recovery with hammers and then also want it on with helve hammers,
/// but if you wanted to do that, you can't. Sorry. You also can't change the bit recovery rates independently because that would be annoying
/// to implement and I don't see the use case for it. Maybe later.
/// </summary>
public bool EnableHelveHammerBitRecovery = true;

/// <summary>
/// Allows you to control which metal bits get returned while hammering a given work item.
/// If a work item has no entry, it will simple return a metal bit corresponding to its material type.
///
/// Mainly, this is intended to allow for things like blister steel giving back steel bits if you want it to, but really you could use it for anything.
/// You can also use it so that certain types of metal bits don't return, by adding an entry like
/// "workitem-blistersteel": ""
/// Which will naturally result in nothing spawning as the code for spawning bits will exist if it can't find an asset with the name provided.
/// You can also use this to control what bits you get back from modded items, if you so desire.
/// Theoretically this could also be used to cheat, like going "workitem-copper": "ingot-gold" if you really wanted to.
/// Invalid work items will simply do nothing, invalid bit items will return nothing, you cannot crash your game with this setting.
///
/// The first value does nothing, it's just there so you can see the format. Most work items are "workitem-{metal}", metal bits are "metalbit-{metal}"
/// The second and third values disable bit recovery from irom blooms and blister steel.
///
/// If you want bit recovery from iron blooms and blister steel, you can change them to
/// "ironbloom": "metalbit-iron",
/// "workitem-blistersteel": "metalbit-blistersteel"
/// Another suggestion, since steel bits cannot be reprocessed without an extra mod, is to change bister steel to
/// "workitem-blistersteel": "metalbit-iron"
/// and steel to
/// "workitem-steel": "metalbit-iron"
/// so that their bits can be turned back into iron, then re-carburized into steel again if desired.
///
/// However, all that is up to you. By default you will just get steel bits to do whatever with.
/// </summary>
public Dictionary<string, string> OnSplitItems = new()
{
    { "workitem-input", "metalbit-output" },
    { "ironbloom", "" },
    { "workitem-blistersteel", "" }
};

/// <summary>
/// Allows you to control which bits you get as output for breaking down any item whose recipe is affected by this mod.
/// This is intended to be paired with OnSplitItems for cases where a metal should return a non-standard bit type.
/// Default value does nothing, it's just there to show the format.
///
/// NOTE: AlwaysUseIngotChiselRecipe must be FALSE for this to affect ingots.
///
/// Example usage; if I wanted steel items to return iron bits (to pair with the suggested split settings above) I could add
/// "workitem-steel": "metalbit-iron",
/// "ingot-steel": "metalbit-iron",
/// "metalplate-steel": "metalbit-iron",
/// "metallamellae-steel": metalbit-iron",
/// "metalchain-steel": "metalbit-iron",
/// "metalscale-steel": "metalbit-iron",
/// "metalrod-steel": "metalbit-iron"
/// to cover all the recipes the mod will see. Obviously this is a bit verbose, but this feature is only for ensuring cross-mod
/// compatibility or for more advanced users to customize their experience. The reason this method was used instead of just
/// changing bits to bits was to ensure that no other recipes are hit by accident. The output COUNT is the same as it would
/// otherwise be, that part is still controlled by how many voxels are in the recipe and such.
///
/// As with the other setting of this type, you can't crash your game with this. Messing up the left side will simply miss the
/// recipe, and messing up the right side will just cause the output type to be unchanged.
/// </summary>
public Dictionary<string, string> BreakdownBitSubstitutions = new()
{
    { "workitem-input", "metalbit-output" }
};