Initial commit

.editorconfig

···
+root = true
+
+[*.cs]
+charset = utf-8
+end_of_line = lf
+insert_final_newline = true
+trim_trailing_whitespace = true
+indent_style = tab

.gitignore

···
+**/obj/
+**/bin/

.vscode/launch.json

···
+{
+	"version": "0.2.0",
+	"configurations": [
+		{
+			// Use IntelliSense to find out which attributes exist for C# debugging
+			// Use hover for the description of the existing attributes
+			// For further information visit https://github.com/dotnet/vscode-csharp/blob/main/debugger-launchjson.md
+			"name": ".NET Core Launch (console)",
+			"type": "coreclr",
+			"request": "launch",
+			"preLaunchTask": "build",
+			// If you have changed target frameworks, make sure to update the program path.
+			"program": "${workspaceFolder}/Electropunk/bin/Debug/net9.0/Electropunk.dll",
+			"args": [],
+			"cwd": "${workspaceFolder}/",
+			// For more information about the 'console' field, see https://aka.ms/VSCode-CS-LaunchJson-Console
+			"console": "internalConsole",
+			"stopAtEntry": false
+		},
+		{
+			"name": ".NET Core Attach",
+			"type": "coreclr",
+			"request": "attach"
+		}
+	]
+}

.vscode/settings.json

···
+{
+  "files.exclude": {
+    "**/obj/": true,
+    "**/bin/": true
+  },
+  "cSpell.words": [
+    "Electropunk",
+    "Lerp",
+    "Raylib",
+    "Raymath"
+  ],
+  "vscord.enabled": false
+}

.vscode/tasks.json

···
+{
+	"version": "2.0.0",
+	"tasks": [
+		{
+			"label": "build",
+			"command": "dotnet",
+			"type": "process",
+			"args": [
+				"build",
+				"${workspaceFolder}/Electropunk/Electropunk.csproj",
+				"/property:GenerateFullPaths=true",
+				"/consoleloggerparameters:NoSummary;ForceNoAlign"
+			],
+			"problemMatcher": "$msCompile"
+		},
+		{
+			"label": "publish",
+			"command": "dotnet",
+			"type": "process",
+			"args": [
+				"publish",
+				"${workspaceFolder}/Electropunk/Electropunk.csproj",
+				"/property:GenerateFullPaths=true",
+				"/consoleloggerparameters:NoSummary;ForceNoAlign"
+			],
+			"problemMatcher": "$msCompile"
+		},
+		{
+			"label": "watch",
+			"command": "dotnet",
+			"type": "process",
+			"args": [
+				"watch",
+				"run",
+				"--project",
+				"${workspaceFolder}/Electropunk/Electropunk.csproj"
+			],
+			"problemMatcher": "$msCompile"
+		}
+	]
+}

Assets/Lang/en_us.kdl

···
+item {
+	air "Air"
+	destructor "Destructor"
+	destructor.desc "Destroys tiles"
+	hammer "Hammer"
+	hammer.desc "Smashes tile and items"
+	wood "Wood"
+	wood_grains "Wood Pulp"
+	stone "Pebble"
+	iron "Iron"
+	copper "Copper"
+	iron_gear "Iron Gear"
+	copper_gear "Copper Gear"
+}
+
+menu {
+	inventory "Inventory"
+}

Data/Crafting/item_smashing.kdl

···
+recipe {
+	in "wood"
+	out "wood_grains"
+}

Data/Crafting/tile_smashing.kdl

···
+recipe {
+	in "rock"
+
+	out-tile "air"
+
+	out-item "stone"
+	out-item "stone"
+}

Electropunk/Containers/IInventory.cs

···
+namespace Electropunk.Containers;
+
+public interface IInventory
+{
+	public Slot? GetSlot(int i);
+}

Electropunk/Containers/ItemInstance.cs

···
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using Electropunk.Content.Items;
+using Electropunk.World;
+
+namespace Electropunk.Containers;
+
+public class ItemInstance(ushort id, Dictionary<string, object>? data = null)
+{
+	public ushort ItemID = id;
+	public Dictionary<string, object> Data = data ?? [];
+
+	[JsonIgnore]
+	public Item Item
+	{
+		get => Item.Items[ItemID];
+		set => ItemID = value.ID;
+	}
+
+	public ItemInstance(Item item, Dictionary<string, object>? data = null) : this(item.ID, data)
+	{
+	}
+
+	public bool Matches(ItemInstance other) => other.ItemID == ItemID;
+	public bool Matches(Item other) => other.ID == ItemID;
+	public bool Matches(ushort otherID) => otherID == ItemID;
+
+	public bool IsEmpty() => Matches(GameItems.Air);
+	public bool IsSomething() => !Matches(GameItems.Air);
+
+	public ItemInstance Copy() => new(ItemID, new(Data));
+	public void Clear() => Item = GameItems.Air;
+
+	public string Serialize() => JsonSerializer.Serialize(this);
+
+	public static ItemInstance Deserialize(string json) =>
+		JsonSerializer.Deserialize<ItemInstance>(json)!;
+}

Electropunk/Containers/Slot.cs

···
+using Electropunk.Content.Items;
+using Electropunk.Misc;
+using Electropunk.World;
+
+namespace Electropunk.Containers;
+
+public class Slot(Func<ItemInstance> getter, Action<ItemInstance> setter) : Ref<ItemInstance>(getter, setter)
+{
+	public Item Item
+	{
+		get => Value.Item;
+		set => Value.Item = value;
+	}
+
+	public ushort ItemID
+	{
+		get => Value.ItemID;
+		set => Value.ItemID = value;
+	}
+
+	public Dictionary<string, object> Data
+	{
+		get => Value.Data;
+		set => Value.Data = value;
+	}
+
+	public bool Matches(ItemInstance other) => other.ItemID == ItemID;
+	public bool Matches(Item other) => other.ID == ItemID;
+	public bool Matches(ushort otherID) => otherID == ItemID;
+
+	public bool IsEmpty() => Matches(GameItems.Air);
+	public bool IsSomething() => !Matches(GameItems.Air);
+
+	public ItemInstance Copy() => new(ItemID, new(Data));
+	public void Clear() => Item = GameItems.Air;
+
+	public void SetItem(ushort itemID)
+	{
+		ItemID = itemID;
+		Data.Clear();
+	}
+
+	public void SetItem(Item item)
+	{
+		Item = item;
+		Data.Clear();
+	}
+
+	public void SetItem(ItemInstance item)
+	{
+		Item = item.Item;
+		Data = item.Data;
+		Data.Clear();
+	}
+}

Electropunk/Content/Biomes/GameBiomes.cs

···
+using Electropunk.World;
+
+namespace Electropunk.Content.Biomes;
+
+public static class GameBiomes
+{
+	public static readonly Biome
+		Void = new Biome("void").Register(),
+		Forest = new Biome("forest").Register(),
+		Desert = new Biome("desert").Register(),
+		Mountain = new Biome("mountain").Register(),
+		Taiga = new Biome("taiga").Register(),
+		Ocean = new Biome("ocean").Register(),
+		Wastes = new Biome("wastes").Register()
+	;
+
+	public static void NoOp() { }
+}

Electropunk/Content/Entities/EntityItem.cs

···
+using Electropunk.Containers;
+using Electropunk.Content.Items;
+using Electropunk.World;
+
+namespace Electropunk.Content.Entities;
+
+public class EntityItem : Entity
+{
+	public ItemInstance Item = new(GameItems.Air);
+
+	public EntityItem()
+	{
+		MoveMode = MovementMode.None;
+		Width = 16;
+		Height = 16;
+	}
+
+	public override void Render(Level level, View view)
+	{
+		if (!Item.IsEmpty())
+		{
+			Item.Item.Render(Program.Level!, Program.View, new(Pos.X, Pos.Y, Width, Height), new(Width / 2f, Height / 2f));
+		}
+	}
+}

Electropunk/Content/Entities/EntityPlayer.cs

···
+using System.Numerics;
+using System.Text.Json;
+using Electropunk.Containers;
+using Electropunk.Content.Items;
+using Electropunk.Input;
+using Electropunk.World;
+using Raylib_cs;
+
+namespace Electropunk.Content.Entities;
+
+public class EntityPlayer : Entity
+{
+	public PlayerInventory Inv = new();
+
+	private const int ItemBounceFrames = 16;
+	private const float BounceDegreesPerFrame = 2f;
+	private int itemBounceFrames = 0;
+
+	public EntityPlayer()
+	{
+		Width = 8;
+		Height = 8;
+		Inv.Held = new(GameItems.Hammer);
+		Inv.Slot1 = new(GameItems.Destructor);
+	}
+
+	public override void Update(Level level)
+	{
+		bool inMenu = Program.Menu != null;
+
+		/* Jetpack */
+		if (Bindings.Fly.IsPressed())
+			MoveMode = MovementMode.Flying;
+		else if (Bindings.Fly.IsReleased())
+			MoveMode = MovementMode.Default;
+
+		if (!inMenu && Bindings.UseItem.IsPressed())
+			OnUse(level);
+		else if (!inMenu && Bindings.DropItem.IsPressed() && !Inv.Held.IsEmpty())
+		{
+			EntityItem ei = new() { Item = Inv.Held.Copy(), Pos = Pos };
+			Inv.Held.Clear();
+			level.EnqueueEntity(ei);
+		}
+
+		if (!inMenu && Bindings.SwapToItem1.IsPressed())
+			(Inv.Held, Inv.Slot1) = (Inv.Slot1, Inv.Held);
+		else if (!inMenu && Bindings.SwapToItem2.IsPressed())
+			(Inv.Held, Inv.Slot2) = (Inv.Slot2, Inv.Held);
+
+		/* Movement */
+		bool
+			north = Bindings.MoveNorth.IsDown(),
+			south = Bindings.MoveSouth.IsDown(),
+			east = Bindings.MoveEast.IsDown(),
+			west = Bindings.MoveWest.IsDown();
+
+		if (north && south)
+			Vel.Y = 0;
+		else if (north)
+			Vel.Y = -1;
+		else if (south)
+			Vel.Y = 1;
+
+		if (east && west)
+			Vel.X = 0;
+		else if (east)
+			Vel.X = -1;
+		else if (west)
+			Vel.X = 1;
+
+		/* Normalize */
+		if (Vel.X != 0 && Vel.Y != 0)
+		{
+			Vel.X /= 1.4f;
+			Vel.Y /= 1.4f;
+		}
+
+		base.Update(level);
+	}
+
+	private bool OnUse(Level level)
+	{
+		if (Inv.Held.IsEmpty())
+		{
+			/* Attempt to pick up an item */
+			Entity? e = level.GetSelectedEntity(Program.View);
+			if (e != null && e is EntityItem ei)
+			{
+				Inv.Held = ei.Item.Copy();
+				ei.Item.Clear();
+				ei.Dead = true;
+				return true;
+			}
+
+			/* Attempt to use a tile */
+			(int x, int y) = level.GetSelectedTile(Program.View) ?? (-1, -1);
+			if (x != -1)
+			{
+				level.GetTileAt(x, y).Use(level, x, y, this);
+				return true;
+			}
+		}
+		else
+		{
+			/* Attempt to use the item on an entity */
+			Entity? e = level.GetSelectedEntity(Program.View);
+			if (e != null)
+			{
+				Inv.Held.Item.UseOnEntity(level, this, new(() => Inv.Held, s => Inv.Held = s), e);
+				itemBounceFrames = ItemBounceFrames;
+				return true;
+			}
+
+			/* Attempt to use the item on a tile */
+			(int x, int y) = level.GetSelectedTile(Program.View) ?? (-1, -1);
+			if (x != -1)
+			{
+				Inv.Held.Item.UseOnTile(level, this, new(() => Inv.Held, s => Inv.Held = s), x, y);
+				itemBounceFrames = ItemBounceFrames;
+				return true;
+			}
+		}
+		return false;
+	}
+
+	public override void Render(Level level, View view)
+	{
+		Rectangle rect = GetRectangle();
+
+		if (
+			(level.Step == RenderStep.Entities && MoveMode == MovementMode.Default) ||
+			(level.Step == RenderStep.FlyingEntities && MoveMode == MovementMode.Flying)
+		)
+		{
+			Raylib.DrawRectangleRec(rect, Color.Blue);
+			view.GoalTarget = Pos;
+		}
+
+		if (level.Step == RenderStep.FlyingEntities)
+		{
+			if (itemBounceFrames > 0)
+				itemBounceFrames--;
+
+			if (Inv.Held.IsSomething())
+			{
+				float x = rect.X + rect.Width / 2;
+				float y = rect.Y + rect.Height / 2;
+
+				Vector2 mp = Raylib.GetScreenToWorld2D(Raylib.GetMousePosition(), view.Camera);
+				float angle = (float)Math.Atan2((mp - Pos).Y, (mp - Pos).X) * Raylib.RAD2DEG;
+				bool isOnLeft = (angle <= -90 && angle >= -180) || (angle <= 180 && angle >= 90);
+
+				Vector2 p = Raymath.Vector2MoveTowards(new(x, y), mp, 12f);
+				Rectangle dest = new(p.X, p.Y, 16, -16);
+
+				if (isOnLeft)
+					angle -= itemBounceFrames * BounceDegreesPerFrame;
+				else
+					angle += itemBounceFrames * BounceDegreesPerFrame;
+
+				Inv.Held.Item.Render(level, view, dest, new(8, 8), angle, vFlip: isOnLeft);
+			}
+		}
+	}
+
+	public class PlayerInventory : IInventory
+	{
+		public ItemInstance Held = new(GameItems.Air);
+		public ItemInstance Armour = new(GameItems.Air);
+		public ItemInstance Slot1 = new(GameItems.Air);
+		public ItemInstance Slot2 = new(GameItems.Air);
+
+		public Slot? GetSlot(int i)
+		{
+			return i switch
+			{
+				0 => new(() => Held, v => Held = v),
+				1 => new(() => Armour, v => Armour = v),
+				2 => new(() => Slot1, v => Slot1 = v),
+				3 => new(() => Slot2, v => Slot2 = v),
+				_ => null
+			};
+		}
+
+		public string Serialize() => JsonSerializer.Serialize(this);
+
+		public static PlayerInventory Deserialize(string json) =>
+			JsonSerializer.Deserialize<PlayerInventory>(json)!;
+	}
+}

Electropunk/Content/Generators/BasicLevelGenerator.cs

···
+using Electropunk.Content.Biomes;
+using Electropunk.Content.Tiles;
+using Electropunk.World;
+
+namespace Electropunk.Content.Generators;
+
+public class BasicLevelGenerator : LevelGenerator
+{
+	private readonly FastNoiseLite biomeNoise;
+
+	public BasicLevelGenerator()
+	{
+		biomeNoise = new();
+		biomeNoise.SetSeed(new Random().Next());
+		biomeNoise.SetNoiseType(FastNoiseLite.NoiseType.Cellular);
+		biomeNoise.SetFrequency(0.008f);
+		biomeNoise.SetCellularDistanceFunction(FastNoiseLite.CellularDistanceFunction.Hybrid);
+		biomeNoise.SetCellularReturnType(FastNoiseLite.CellularReturnType.CellValue);
+		biomeNoise.SetCellularJitter(2.000f);
+		biomeNoise.SetDomainWarpType(FastNoiseLite.DomainWarpType.OpenSimplex2);
+		biomeNoise.SetDomainWarpAmp(200.000f);
+		biomeNoise.SetFractalType(FastNoiseLite.FractalType.DomainWarpIndependent);
+		biomeNoise.SetFractalOctaves(3);
+		biomeNoise.SetFractalLacunarity(2.500f);
+		biomeNoise.SetFractalGain(0.750f);
+	}
+
+	public override Biome PickBiome(Level level, int x, int y)
+	{
+		float fx = x, fy = y;
+		biomeNoise.DomainWarp(ref fx, ref fy);
+		float noise = biomeNoise.GetNoise(fx, fy);
+		int biomes = 5;
+		int normalized = (int)Math.Round((noise + 1.0f) / 2.0f * biomes);
+		return normalized switch {
+			0 => GameBiomes.Forest,
+			1 => GameBiomes.Desert,
+			2 => GameBiomes.Mountain,
+			3 => GameBiomes.Taiga,
+			4 => GameBiomes.Ocean,
+			5 => GameBiomes.Wastes,
+			_ => GameBiomes.Void,
+		};
+	}
+
+	public override Tile Pick(Level level, Biome biome, int x, int y)
+	{
+		float s = level.Random.NextSingle();
+
+		if (biome.ID != GameBiomes.Ocean.ID && s <= 1/30f)
+			return GameTiles.Rock;
+
+		if (biome.ID == GameBiomes.Forest.ID)
+		{
+			if (s <= 1/10f)
+				return GameTiles.Tree;
+		}
+		else if (biome.ID == GameBiomes.Mountain.ID)
+		{
+			if (s <= 1/5f)
+				return GameTiles.Rock;
+		}
+
+		return GameTiles.Air;
+	}
+}

Electropunk/Content/Items/GameItems.cs

···
+using Electropunk.World;
+
+namespace Electropunk.Content.Items;
+
+public static class GameItems
+{
+	public static readonly Item
+		Air = new Item("air").Register(),
+		Destructor = new ItemDestructor("destructor").Register(),
+		Hammer = new ItemHammer("hammer").Register(),
+		Wood = new Item("wood").Register(),
+		WoodGrains = new Item("wood_grains").Register(),
+		Stone = new Item("stone").Register(),
+		Iron = new Item("iron").Register(),
+		Copper = new Item("copper").Register(),
+		IronGear = new Item("iron_gear").Register(),
+		CopperGear = new Item("copper_gear").Register()
+	;
+
+	public static void NoOp() { }
+}

Electropunk/Content/Items/ItemDestructor.cs

···
+using Electropunk.Containers;
+using Electropunk.Content.Entities;
+using Electropunk.World;
+
+namespace Electropunk.Content.Items;
+
+public class ItemDestructor(string key) : Item(key)
+{
+	public override void UseOnTile(Level level, EntityPlayer user, Slot item, int x, int y)
+	{
+		level.GetTileAt(x, y).Break(level, x, y);
+	}
+}

Electropunk/Content/Items/ItemHammer.cs

···
+using Electropunk.Containers;
+using Electropunk.Content.Entities;
+using Electropunk.World;
+using Electropunk.World.Crafting;
+
+namespace Electropunk.Content.Items;
+
+public class ItemHammer(string key) : Item(key)
+{
+	public override void UseOnTile(Level level, EntityPlayer user, Slot item, int x, int y)
+	{
+		RecipeTileSmashing.TryCraft(level, x, y);
+	}
+
+	public override void UseOnEntity(Level level, EntityPlayer user, Slot item, Entity target)
+	{
+		if (target is EntityItem ei)
+			RecipeItemSmashing.TryCraft(level, ei);
+	}
+}

Electropunk/Content/Tiles/GameTiles.cs

···
+using Electropunk.Content.Items;
+using Electropunk.World;
+
+namespace Electropunk.Content.Tiles;
+
+public static class GameTiles
+{
+	public static readonly Tile
+		Air = new Tile("air") { RenderStep = RenderStep.None, Collides = false }.Register(),
+		Rock = new Tile("rock") { Drops = [GameItems.Stone], RenderStep = RenderStep.TilesAbove, CollisionRect = new(0, 4, View.TileSize, View.TileSize - 4) }.Register(),
+		Tree = new Tile("tree") { Drops = [GameItems.Wood], RenderStep = RenderStep.TilesAbove, CollisionRect = new(3, 4, View.TileSize - 6, View.TileSize - 4) }.Register(),
+		Furnace = new Tile("furnace").Register()
+	;
+
+	public static void NoOp() { }
+}

Electropunk/Content/Tiles/TileFurnace.cs

···
+using System.Text.Json;
+using Electropunk.Containers;
+using Electropunk.Content.Items;
+using Electropunk.World;
+
+namespace Electropunk.Content.Tiles;
+
+public class TileFurnace(string key) : Tile(key)
+{
+	public override void Place(Level level, int x, int y)
+	{
+		base.Place(level, x, y);
+
+		level.SetTileDataAt(x, y, new FurnaceData());
+	}
+
+	protected class FurnaceData : TileData
+	{
+		public ItemInstance Input = new(GameItems.Air);
+		public ItemInstance Output = new(GameItems.Air);
+		public int TicksLeft = 0;
+		public int FuelLeft = 0;
+
+		public override void Load(string json)
+		{
+			FurnaceData data = JsonSerializer.Deserialize<FurnaceData>(json)!;
+			Input = data.Input;
+			Output = data.Output;
+			TicksLeft = data.TicksLeft;
+			FuelLeft = data.FuelLeft;
+		}
+
+		public override string Save() => JsonSerializer.Serialize(this);
+	}
+}

Electropunk/Content/UI/MenuInventory.cs

···
+using Electropunk.Content.Entities;
+using Electropunk.Graphics;
+using Electropunk.I18n;
+using Electropunk.UI;
+using Raylib_cs;
+
+namespace Electropunk.Content.UI;
+
+public class MenuInventory : UINode
+{
+	public static readonly int Scale = 4;
+
+	private int openFrames = 0;
+
+	public MenuInventory(EntityPlayer.PlayerInventory inventory) : base(0, 0)
+	{
+		int padding = 8;
+
+		Width = (80 + padding * 2) * Scale;
+		Height = (16 + padding * 2) * Scale;
+
+		LocalX = Raylib.GetScreenWidth() / 2 - Width / 2;
+		LocalY = Raylib.GetScreenHeight() / 2 - Height / 2;
+
+		AddChild(new UIItemSlot(inventory.GetSlot(0)!, (padding + 0) * Scale, padding * Scale, this) { Width = 16 * Scale, Height = 16 * Scale });
+		AddChild(new UIItemSlot(inventory.GetSlot(1)!, (padding + 16) * Scale, padding * Scale, this) { Width = 16 * Scale, Height = 16 * Scale });
+		AddChild(new UIItemSlot(inventory.GetSlot(2)!, (padding + 48) * Scale, padding * Scale, this) { Width = 16 * Scale, Height = 16 * Scale });
+		AddChild(new UIItemSlot(inventory.GetSlot(3)!, (padding + 64) * Scale, padding * Scale, this) { Width = 16 * Scale, Height = 16 * Scale });
+	}
+
+	public override void Render()
+	{
+		openFrames++;
+
+		Raylib.DrawRectangle(0, 0, Raylib.GetScreenWidth(), Raylib.GetScreenHeight(), new(0, 0, 0, Math.Min(120, openFrames * 10)));
+
+		Raylib.DrawText(Lang.T("menu.inventory"), LocalX, LocalY - 20, 20, Color.White);
+
+		Raylib.DrawRectangleRec(GetRectangle(), Color.DarkBlue);
+		Raylib.DrawRectangleLinesEx(GetRectangle(), 2f, Color.Blue);
+
+		base.Render();
+	}
+}

Electropunk/Electropunk.csproj

···
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net9.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Kadlet" Version="0.1.0" />
+    <PackageReference Include="Raylib-cs" Version="7.0.2" />
+  </ItemGroup>
+
+</Project>

Electropunk/Graphics/Shaders.cs

···
+using Raylib_cs;
+
+namespace Electropunk.Graphics;
+
+public static class Shaders
+{
+	public static readonly Shader
+		Blur = Raylib.LoadShader(null, "Assets/Shaders/blur.fs");
+}

Electropunk/Graphics/TextureUtil.cs

···
+using Raylib_cs;
+
+namespace Electropunk.Graphics;
+
+public static class TextureUtil
+{
+	public static Rectangle GetSourceRect(Texture2D texture)
+	{
+		return new(0, 0, texture.Width, texture.Height);
+	}
+}

Electropunk/I18n/Lang.cs

···
+using System.Runtime.CompilerServices;
+using Kadlet;
+
+namespace Electropunk.I18n;
+
+public class Lang
+{
+	public static Lang L = new("en_us");
+
+	private readonly Dictionary<string, string> Translations = [];
+
+	public Lang(string key)
+	{
+		KdlReader reader = new(new KdlReaderOptions());
+		using FileStream fs = File.OpenRead($"Assets/Lang/{key}.kdl");
+		KdlDocument doc = reader.Parse(fs);
+		Process(doc);
+	}
+
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	public string TranslateKey(string key) => Translations[key];
+
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	public bool HasKey(string key) => Translations.ContainsKey(key);
+
+	private void Process(KdlDocument doc, string prefix = "")
+	{
+		foreach (var node in doc.Nodes)
+		{
+			foreach (var prop in node.Properties)
+				Translations[$"{prefix}{node.Identifier}.{prop.Key}"] = prop.Value.ToKdlString().Trim('"', '\'');
+
+			if (node.Arguments.Count == 1)
+				Translations[$"{prefix}{node.Identifier}"] = node.Arguments[0].ToKdlString().Trim('"', '\'');
+			if (node.Arguments.Count > 1)
+			{
+				foreach (var (i, arg) in node.Arguments.Index())
+					Translations[$"{prefix}{node.Identifier}.{i}"] = arg.ToKdlString().Trim('"', '\'');
+			}
+
+			if (node.Children != null)
+				Process(node.Children, $"{prefix}{node.Identifier}.");
+		}
+	}
+
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	public static string Translate(string key) => L.Translations[key];
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	public static string T(string key) => L.Translations[key];
+
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	public static bool Exists(string key) => L.Translations.ContainsKey(key);
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	public static bool E(string key) => L.Translations.ContainsKey(key);
+
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	public static bool TranslateIfExists(string key, out string? value) => L.Translations.TryGetValue(key, out value);
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	public static bool TE(string key, out string? value) => L.Translations.TryGetValue(key, out value);
+}

Electropunk/Input/Bindings.cs

···
+using Raylib_cs;
+
+namespace Electropunk.Input;
+
+public static class Bindings
+{
+	public static readonly InputBinding
+		MoveNorth = new(KeyboardKey.W),
+		MoveSouth = new(KeyboardKey.S),
+		MoveEast = new(KeyboardKey.A),
+		MoveWest = new(KeyboardKey.D),
+		Fly = new(KeyboardKey.Space),
+		DropItem = new(KeyboardKey.Q),
+		UseItem = new(mouse: MouseButton.Left),
+		OpenInventory = new(KeyboardKey.Tab),
+		CloseMenu = new(KeyboardKey.Escape),
+		SwapToItem1 = new(KeyboardKey.One),
+		SwapToItem2 = new(KeyboardKey.Two),
+
+		ToggleFullscreen = new(KeyboardKey.F11),
+		ZoomIn = new(KeyboardKey.Equal),
+		ZoomOut = new(KeyboardKey.Minus),
+		ResetZoom = new(KeyboardKey.Zero),
+
+		UIClick = new(mouse: MouseButton.Left);
+}

Electropunk/Input/InputBinding.cs

···
+using Raylib_cs;
+
+namespace Electropunk.Input;
+
+public class InputBinding(KeyboardKey? key = null, MouseButton? mouse = null, GamepadButton? gamepad = null)
+{
+	public KeyboardKey? Key = key;
+	public MouseButton? Mouse = mouse;
+	public GamepadButton? Gamepad = gamepad;
+
+	public bool IsDown() =>
+		(Key != null && Raylib.IsKeyDown((KeyboardKey)Key)) ||
+		(Mouse != null && Raylib.IsMouseButtonDown((MouseButton)Mouse)) ||
+		(Gamepad != null && Raylib.IsGamepadButtonDown(0, (GamepadButton)Gamepad));
+
+	public bool IsUp() =>
+		(Key != null && Raylib.IsKeyUp((KeyboardKey)Key)) ||
+		(Mouse != null && Raylib.IsMouseButtonUp((MouseButton)Mouse)) ||
+		(Gamepad != null && Raylib.IsGamepadButtonUp(0, (GamepadButton)Gamepad));
+
+	public bool IsPressed() =>
+		(Key != null && Raylib.IsKeyPressed((KeyboardKey)Key)) ||
+		(Mouse != null && Raylib.IsMouseButtonPressed((MouseButton)Mouse)) ||
+		(Gamepad != null && Raylib.IsGamepadButtonPressed(0, (GamepadButton)Gamepad));
+
+	public bool IsReleased() =>
+		(Key != null && Raylib.IsKeyReleased((KeyboardKey)Key)) ||
+		(Mouse != null && Raylib.IsMouseButtonReleased((MouseButton)Mouse)) ||
+		(Gamepad != null && Raylib.IsGamepadButtonReleased(0, (GamepadButton)Gamepad));
+}

Electropunk/Mathematics/FastNoiseLite.cs

···
+// MIT License
+//
+// Copyright(c) 2023 Jordan Peck ([e-mail])
+// Copyright(c) 2023 Contributors
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files(the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions :
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+//
+// .'',;:cldxkO00KKXXNNWWWNNXKOkxdollcc::::::;:::ccllloooolllllllllooollc:,'...        ...........',;cldxkO000Okxdlc::;;;,,;;;::cclllllll
+// ..',;:ldxO0KXXNNNNNNNNXXK0kxdolcc::::::;;;,,,,,,;;;;;;;;;;:::cclllllc:;'....       ...........',;:ldxO0KXXXK0Okxdolc::;;;;::cllodddddo
+// ...',:loxO0KXNNNNNXXKK0Okxdolc::;::::::::;;;,,'''''.....''',;:clllllc:;,'............''''''''',;:loxO0KXNNNNNXK0Okxdollccccllodxxxxxxd
+// ....';:ldkO0KXXXKK00Okxdolcc:;;;;;::cclllcc:;;,''..... ....',;clooddolcc:;;;;,,;;;;;::::;;;;;;:cloxk0KXNWWWWWWNXKK0Okxddoooddxxkkkkkxx
+// .....';:ldxkOOOOOkxxdolcc:;;;,,,;;:cllooooolcc:;'...      ..,:codxkkkxddooollloooooooollcc:::::clodkO0KXNWWWWWWNNXK00Okxxxxxxxxkkkkxxx
+// . ....';:cloddddo___________,,,,;;:clooddddoolc:,...      ..,:ldx__00OOOkkk___kkkkkkxxdollc::::cclodkO0KXXNNNNNNXXK0OOkxxxxxxxxxxxxddd
+// .......',;:cccc:|           |,,,;;:cclooddddoll:;'..     ..';cox|  \KKK000|   |KK00OOkxdocc___;::clldxxkO0KKKKK00Okkxdddddddddddddddoo
+// .......'',,,,,''|   ________|',,;;::cclloooooolc:;'......___:ldk|   \KK000|   |XKKK0Okxolc|   |;;::cclodxxkkkkxxdoolllcclllooodddooooo
+// ''......''''....|   |  ....'',,,,;;;::cclloooollc:;,''.'|   |oxk|    \OOO0|   |KKK00Oxdoll|___|;;;;;::ccllllllcc::;;,,;;;:cclloooooooo
+// ;;,''.......... |   |_____',,;;;____:___cllo________.___|   |___|     \xkk|   |KK_______ool___:::;________;;;_______...'',;;:ccclllloo
+// c:;,''......... |         |:::/     '   |lo/        |           |      \dx|   |0/       \d|   |cc/        |'/       \......',,;;:ccllo
+// ol:;,'..........|    _____|ll/    __    |o/   ______|____    ___|   |   \o|   |/   ___   \|   |o/   ______|/   ___   \ .......'',;:clo
+// dlc;,...........|   |::clooo|    /  |   |x\___   \KXKKK0|   |dol|   |\   \|   |   |   |   |   |d\___   \..|   |  /   /       ....',:cl
+// xoc;'...  .....'|   |llodddd|    \__|   |_____\   \KKK0O|   |lc:|   |'\       |   |___|   |   |_____\   \.|   |_/___/...      ...',;:c
+// dlc;'... ....',;|   |oddddddo\          |          |Okkx|   |::;|   |..\      |\         /|   |          | \         |...    ....',;:c
+// ol:,'.......',:c|___|xxxddollc\_____,___|_________/ddoll|___|,,,|___|...\_____|:\ ______/l|___|_________/...\________|'........',;::cc
+// c:;'.......';:codxxkkkkxxolc::;::clodxkOO0OOkkxdollc::;;,,''''',,,,''''''''''',,'''''',;:loxkkOOkxol:;,'''',,;:ccllcc:;,'''''',;::ccll
+// ;,'.......',:codxkOO0OOkxdlc:;,,;;:cldxxkkxxdolc:;;,,''.....'',;;:::;;,,,'''''........,;cldkO0KK0Okdoc::;;::cloodddoolc:;;;;;::ccllooo
+// .........',;:lodxOO0000Okdoc:,,',,;:clloddoolc:;,''.......'',;:clooollc:;;,,''.......',:ldkOKXNNXX0Oxdolllloddxxxxxxdolccccccllooodddd
+// .    .....';:cldxkO0000Okxol:;,''',,;::cccc:;,,'.......'',;:cldxxkkxxdolc:;;,'.......';coxOKXNWWWNXKOkxddddxxkkkkkkxdoollllooddxxxxkkk
+//       ....',;:codxkO000OOxdoc:;,''',,,;;;;,''.......',,;:clodkO00000Okxolc::;,,''..',;:ldxOKXNWWWNNK0OkkkkkkkkkkkxxddooooodxxkOOOOO000
+//       ....',;;clodxkkOOOkkdolc:;,,,,,,,,'..........,;:clodxkO0KKXKK0Okxdolcc::;;,,,;;:codkO0XXNNNNXKK0OOOOOkkkkxxdoollloodxkO0KKKXXXXX
+//
+// VERSION: 1.1.1
+// https://github.com/Auburn/FastNoiseLite
+
+using System;
+using System.Runtime.CompilerServices;
+
+// Switch between using floats or doubles for input position
+using FNLfloat = System.Single;
+//using FNLfloat = System.Double;
+
+public class FastNoiseLite
+{
+    private const short INLINE = 256; // MethodImplOptions.AggressiveInlining;
+    private const short OPTIMISE = 512; // MethodImplOptions.AggressiveOptimization;
+
+    public enum NoiseType 
+    { 
+        OpenSimplex2,
+        OpenSimplex2S,
+        Cellular,
+        Perlin,
+        ValueCubic,
+        Value 
+    };
+
+    public enum RotationType3D 
+    {
+        None, 
+        ImproveXYPlanes, 
+        ImproveXZPlanes 
+    };
+    
+    public enum FractalType 
+    {
+        None, 
+        FBm, 
+        Ridged, 
+        PingPong, 
+        DomainWarpProgressive, 
+        DomainWarpIndependent 
+    };
+
+    public enum CellularDistanceFunction 
+    {
+        Euclidean, 
+        EuclideanSq, 
+        Manhattan, 
+        Hybrid 
+    };
+    
+    public enum CellularReturnType 
+    {
+        CellValue, 
+        Distance, 
+        Distance2, 
+        Distance2Add, 
+        Distance2Sub, 
+        Distance2Mul, 
+        Distance2Div 
+    };
+
+    public enum DomainWarpType 
+    { 
+        OpenSimplex2, 
+        OpenSimplex2Reduced, 
+        BasicGrid 
+    };
+
+    private enum TransformType3D 
+    {
+        None, 
+        ImproveXYPlanes, 
+        ImproveXZPlanes, 
+        DefaultOpenSimplex2 
+    };
+
+    private int mSeed = 1337;
+    private float mFrequency = 0.01f;
+    private NoiseType mNoiseType = NoiseType.OpenSimplex2;
+    private RotationType3D mRotationType3D = RotationType3D.None;
+    private TransformType3D mTransformType3D = TransformType3D.DefaultOpenSimplex2;
+
+    private FractalType mFractalType = FractalType.None;
+    private int mOctaves = 3;
+    private float mLacunarity = 2.0f;
+    private float mGain = 0.5f;
+    private float mWeightedStrength = 0.0f;
+    private float mPingPongStrength = 2.0f;
+
+    private float mFractalBounding = 1 / 1.75f;
+
+    private CellularDistanceFunction mCellularDistanceFunction = CellularDistanceFunction.EuclideanSq;
+    private CellularReturnType mCellularReturnType = CellularReturnType.Distance;
+    private float mCellularJitterModifier = 1.0f;
+
+    private DomainWarpType mDomainWarpType = DomainWarpType.OpenSimplex2;
+    private TransformType3D mWarpTransformType3D = TransformType3D.DefaultOpenSimplex2;
+    private float mDomainWarpAmp = 1.0f;
+
+    /// <summary>
+    /// Create new FastNoise object with optional seed
+    /// </summary>
+    public FastNoiseLite(int seed = 1337)
+    {
+        SetSeed(seed);
+    }
+
+    /// <summary>
+    /// Sets seed used for all noise types
+    /// </summary>
+    /// <remarks>
+    /// Default: 1337
+    /// </remarks>
+    public void SetSeed(int seed) { mSeed = seed; }
+
+    /// <summary>
+    /// Sets frequency for all noise types
+    /// </summary>
+    /// <remarks>
+    /// Default: 0.01
+    /// </remarks>
+    public void SetFrequency(float frequency) { mFrequency = frequency; }
+
+    /// <summary>
+    /// Sets noise algorithm used for GetNoise(...)
+    /// </summary>
+    /// <remarks>
+    /// Default: OpenSimplex2
+    /// </remarks>
+    public void SetNoiseType(NoiseType noiseType)
+    {
+        mNoiseType = noiseType;
+        UpdateTransformType3D();
+    }
+
+    /// <summary>
+    /// Sets domain rotation type for 3D Noise and 3D DomainWarp.
+    /// Can aid in reducing directional artifacts when sampling a 2D plane in 3D
+    /// </summary>
+    /// <remarks>
+    /// Default: None
+    /// </remarks>
+    public void SetRotationType3D(RotationType3D rotationType3D)
+    {
+        mRotationType3D = rotationType3D;
+        UpdateTransformType3D();
+        UpdateWarpTransformType3D();
+    }
+
+    /// <summary>
+    /// Sets method for combining octaves in all fractal noise types
+    /// </summary>
+    /// <remarks>
+    /// Default: None
+    /// Note: FractalType.DomainWarp... only affects DomainWarp(...)
+    /// </remarks>
+    public void SetFractalType(FractalType fractalType) { mFractalType = fractalType; }
+
+    /// <summary>
+    /// Sets octave count for all fractal noise types 
+    /// </summary>
+    /// <remarks>
+    /// Default: 3
+    /// </remarks>
+    public void SetFractalOctaves(int octaves)
+    {
+        mOctaves = octaves;
+        CalculateFractalBounding();
+    }
+
+    /// <summary>
+    /// Sets octave lacunarity for all fractal noise types
+    /// </summary>
+    /// <remarks>
+    /// Default: 2.0
+    /// </remarks>
+    public void SetFractalLacunarity(float lacunarity) { mLacunarity = lacunarity; }
+
+    /// <summary>
+    /// Sets octave gain for all fractal noise types
+    /// </summary>
+    /// <remarks>
+    /// Default: 0.5
+    /// </remarks>
+    public void SetFractalGain(float gain)
+    {
+        mGain = gain;
+        CalculateFractalBounding();
+    }
+
+    /// <summary>
+    /// Sets octave weighting for all none DomainWarp fratal types
+    /// </summary>
+    /// <remarks>
+    /// Default: 0.0
+    /// Note: Keep between 0...1 to maintain -1...1 output bounding
+    /// </remarks>
+    public void SetFractalWeightedStrength(float weightedStrength) { mWeightedStrength = weightedStrength; }
+
+    /// <summary>
+    /// Sets strength of the fractal ping pong effect
+    /// </summary>
+    /// <remarks>
+    /// Default: 2.0
+    /// </remarks>
+    public void SetFractalPingPongStrength(float pingPongStrength) { mPingPongStrength = pingPongStrength; }
+
+
+    /// <summary>
+    /// Sets distance function used in cellular noise calculations
+    /// </summary>
+    /// <remarks>
+    /// Default: Distance
+    /// </remarks>
+    public void SetCellularDistanceFunction(CellularDistanceFunction cellularDistanceFunction) { mCellularDistanceFunction = cellularDistanceFunction; }
+
+    /// <summary>
+    /// Sets return type from cellular noise calculations
+    /// </summary>
+    /// <remarks>
+    /// Default: EuclideanSq
+    /// </remarks>
+    public void SetCellularReturnType(CellularReturnType cellularReturnType) { mCellularReturnType = cellularReturnType; }
+
+    /// <summary>
+    /// Sets the maximum distance a cellular point can move from it's grid position
+    /// </summary>
+    /// <remarks>
+    /// Default: 1.0
+    /// Note: Setting this higher than 1 will cause artifacts
+    /// </remarks> 
+    public void SetCellularJitter(float cellularJitter) { mCellularJitterModifier = cellularJitter; }
+
+
+    /// <summary>
+    /// Sets the warp algorithm when using DomainWarp(...)
+    /// </summary>
+    /// <remarks>
+    /// Default: OpenSimplex2
+    /// </remarks>
+    public void SetDomainWarpType(DomainWarpType domainWarpType)
+    {
+        mDomainWarpType = domainWarpType;
+        UpdateWarpTransformType3D();
+    }
+
+
+    /// <summary>
+    /// Sets the maximum warp distance from original position when using DomainWarp(...)
+    /// </summary>
+    /// <remarks>
+    /// Default: 1.0
+    /// </remarks>
+    public void SetDomainWarpAmp(float domainWarpAmp) { mDomainWarpAmp = domainWarpAmp; }
+
+
+    /// <summary>
+    /// 2D noise at given position using current settings
+    /// </summary>
+    /// <returns>
+    /// Noise output bounded between -1...1
+    /// </returns>
+    [MethodImpl(OPTIMISE)]
+    public float GetNoise(FNLfloat x, FNLfloat y)
+    {
+        TransformNoiseCoordinate(ref x, ref y);
+
+        switch (mFractalType)
+        {
+            default:
+                return GenNoiseSingle(mSeed, x, y);
+            case FractalType.FBm:
+                return GenFractalFBm(x, y);
+            case FractalType.Ridged:
+                return GenFractalRidged(x, y);
+            case FractalType.PingPong:
+                return GenFractalPingPong(x, y);
+        }
+    }
+
+    /// <summary>
+    /// 3D noise at given position using current settings
+    /// </summary>
+    /// <returns>
+    /// Noise output bounded between -1...1
+    /// </returns>
+    [MethodImpl(OPTIMISE)]
+    public float GetNoise(FNLfloat x, FNLfloat y, FNLfloat z)
+    {
+        TransformNoiseCoordinate(ref x, ref y, ref z);
+
+        switch (mFractalType)
+        {
+            default:
+                return GenNoiseSingle(mSeed, x, y, z);
+            case FractalType.FBm:
+                return GenFractalFBm(x, y, z);
+            case FractalType.Ridged:
+                return GenFractalRidged(x, y, z);
+            case FractalType.PingPong:
+                return GenFractalPingPong(x, y, z);
+        }
+    }
+
+
+    /// <summary>
+    /// 2D warps the input position using current domain warp settings
+    /// </summary>
+    /// <example>
+    /// Example usage with GetNoise
+    /// <code>DomainWarp(ref x, ref y)
+    /// noise = GetNoise(x, y)</code>
+    /// </example>
+    [MethodImpl(OPTIMISE)]
+    public void DomainWarp(ref FNLfloat x, ref FNLfloat y)
+    {
+        switch (mFractalType)
+        {
+            default:
+                DomainWarpSingle(ref x, ref y);
+                break;
+            case FractalType.DomainWarpProgressive:
+                DomainWarpFractalProgressive(ref x, ref y);
+                break;
+            case FractalType.DomainWarpIndependent:
+                DomainWarpFractalIndependent(ref x, ref y);
+                break;
+        }
+    }
+
+    /// <summary>
+    /// 3D warps the input position using current domain warp settings
+    /// </summary>
+    /// <example>
+    /// Example usage with GetNoise
+    /// <code>DomainWarp(ref x, ref y, ref z)
+    /// noise = GetNoise(x, y, z)</code>
+    /// </example>
+    [MethodImpl(OPTIMISE)]
+    public void DomainWarp(ref FNLfloat x, ref FNLfloat y, ref FNLfloat z)
+    {
+        switch (mFractalType)
+        {
+            default:
+                DomainWarpSingle(ref x, ref y, ref z);
+                break;
+            case FractalType.DomainWarpProgressive:
+                DomainWarpFractalProgressive(ref x, ref y, ref z);
+                break;
+            case FractalType.DomainWarpIndependent:
+                DomainWarpFractalIndependent(ref x, ref y, ref z);
+                break;
+        }
+    }
+
+
+    private static readonly float[] Gradients2D =
+    {
+         0.130526192220052f,  0.99144486137381f,   0.38268343236509f,   0.923879532511287f,  0.608761429008721f,  0.793353340291235f,  0.793353340291235f,  0.608761429008721f,
+         0.923879532511287f,  0.38268343236509f,   0.99144486137381f,   0.130526192220051f,  0.99144486137381f,  -0.130526192220051f,  0.923879532511287f, -0.38268343236509f,
+         0.793353340291235f, -0.60876142900872f,   0.608761429008721f, -0.793353340291235f,  0.38268343236509f,  -0.923879532511287f,  0.130526192220052f, -0.99144486137381f,
+        -0.130526192220052f, -0.99144486137381f,  -0.38268343236509f,  -0.923879532511287f, -0.608761429008721f, -0.793353340291235f, -0.793353340291235f, -0.608761429008721f,
+        -0.923879532511287f, -0.38268343236509f,  -0.99144486137381f,  -0.130526192220052f, -0.99144486137381f,   0.130526192220051f, -0.923879532511287f,  0.38268343236509f,
+        -0.793353340291235f,  0.608761429008721f, -0.608761429008721f,  0.793353340291235f, -0.38268343236509f,   0.923879532511287f, -0.130526192220052f,  0.99144486137381f,
+         0.130526192220052f,  0.99144486137381f,   0.38268343236509f,   0.923879532511287f,  0.608761429008721f,  0.793353340291235f,  0.793353340291235f,  0.608761429008721f,
+         0.923879532511287f,  0.38268343236509f,   0.99144486137381f,   0.130526192220051f,  0.99144486137381f,  -0.130526192220051f,  0.923879532511287f, -0.38268343236509f,
+         0.793353340291235f, -0.60876142900872f,   0.608761429008721f, -0.793353340291235f,  0.38268343236509f,  -0.923879532511287f,  0.130526192220052f, -0.99144486137381f,
+        -0.130526192220052f, -0.99144486137381f,  -0.38268343236509f,  -0.923879532511287f, -0.608761429008721f, -0.793353340291235f, -0.793353340291235f, -0.608761429008721f,
+        -0.923879532511287f, -0.38268343236509f,  -0.99144486137381f,  -0.130526192220052f, -0.99144486137381f,   0.130526192220051f, -0.923879532511287f,  0.38268343236509f,
+        -0.793353340291235f,  0.608761429008721f, -0.608761429008721f,  0.793353340291235f, -0.38268343236509f,   0.923879532511287f, -0.130526192220052f,  0.99144486137381f,
+         0.130526192220052f,  0.99144486137381f,   0.38268343236509f,   0.923879532511287f,  0.608761429008721f,  0.793353340291235f,  0.793353340291235f,  0.608761429008721f,
+         0.923879532511287f,  0.38268343236509f,   0.99144486137381f,   0.130526192220051f,  0.99144486137381f,  -0.130526192220051f,  0.923879532511287f, -0.38268343236509f,
+         0.793353340291235f, -0.60876142900872f,   0.608761429008721f, -0.793353340291235f,  0.38268343236509f,  -0.923879532511287f,  0.130526192220052f, -0.99144486137381f,
+        -0.130526192220052f, -0.99144486137381f,  -0.38268343236509f,  -0.923879532511287f, -0.608761429008721f, -0.793353340291235f, -0.793353340291235f, -0.608761429008721f,
+        -0.923879532511287f, -0.38268343236509f,  -0.99144486137381f,  -0.130526192220052f, -0.99144486137381f,   0.130526192220051f, -0.923879532511287f,  0.38268343236509f,
+        -0.793353340291235f,  0.608761429008721f, -0.608761429008721f,  0.793353340291235f, -0.38268343236509f,   0.923879532511287f, -0.130526192220052f,  0.99144486137381f,
+         0.130526192220052f,  0.99144486137381f,   0.38268343236509f,   0.923879532511287f,  0.608761429008721f,  0.793353340291235f,  0.793353340291235f,  0.608761429008721f,
+         0.923879532511287f,  0.38268343236509f,   0.99144486137381f,   0.130526192220051f,  0.99144486137381f,  -0.130526192220051f,  0.923879532511287f, -0.38268343236509f,
+         0.793353340291235f, -0.60876142900872f,   0.608761429008721f, -0.793353340291235f,  0.38268343236509f,  -0.923879532511287f,  0.130526192220052f, -0.99144486137381f,
+        -0.130526192220052f, -0.99144486137381f,  -0.38268343236509f,  -0.923879532511287f, -0.608761429008721f, -0.793353340291235f, -0.793353340291235f, -0.608761429008721f,
+        -0.923879532511287f, -0.38268343236509f,  -0.99144486137381f,  -0.130526192220052f, -0.99144486137381f,   0.130526192220051f, -0.923879532511287f,  0.38268343236509f,
+        -0.793353340291235f,  0.608761429008721f, -0.608761429008721f,  0.793353340291235f, -0.38268343236509f,   0.923879532511287f, -0.130526192220052f,  0.99144486137381f,
+         0.130526192220052f,  0.99144486137381f,   0.38268343236509f,   0.923879532511287f,  0.608761429008721f,  0.793353340291235f,  0.793353340291235f,  0.608761429008721f,
+         0.923879532511287f,  0.38268343236509f,   0.99144486137381f,   0.130526192220051f,  0.99144486137381f,  -0.130526192220051f,  0.923879532511287f, -0.38268343236509f,
+         0.793353340291235f, -0.60876142900872f,   0.608761429008721f, -0.793353340291235f,  0.38268343236509f,  -0.923879532511287f,  0.130526192220052f, -0.99144486137381f,
+        -0.130526192220052f, -0.99144486137381f,  -0.38268343236509f,  -0.923879532511287f, -0.608761429008721f, -0.793353340291235f, -0.793353340291235f, -0.608761429008721f,
+        -0.923879532511287f, -0.38268343236509f,  -0.99144486137381f,  -0.130526192220052f, -0.99144486137381f,   0.130526192220051f, -0.923879532511287f,  0.38268343236509f,
+        -0.793353340291235f,  0.608761429008721f, -0.608761429008721f,  0.793353340291235f, -0.38268343236509f,   0.923879532511287f, -0.130526192220052f,  0.99144486137381f,
+         0.38268343236509f,   0.923879532511287f,  0.923879532511287f,  0.38268343236509f,   0.923879532511287f, -0.38268343236509f,   0.38268343236509f,  -0.923879532511287f,
+        -0.38268343236509f,  -0.923879532511287f, -0.923879532511287f, -0.38268343236509f,  -0.923879532511287f,  0.38268343236509f,  -0.38268343236509f,   0.923879532511287f,
+    };
+
+    private static readonly float[] RandVecs2D =
+    {
+        -0.2700222198f, -0.9628540911f, 0.3863092627f, -0.9223693152f, 0.04444859006f, -0.999011673f, -0.5992523158f, -0.8005602176f, -0.7819280288f, 0.6233687174f, 0.9464672271f, 0.3227999196f, -0.6514146797f, -0.7587218957f, 0.9378472289f, 0.347048376f,
+        -0.8497875957f, -0.5271252623f, -0.879042592f, 0.4767432447f, -0.892300288f, -0.4514423508f, -0.379844434f, -0.9250503802f, -0.9951650832f, 0.0982163789f, 0.7724397808f, -0.6350880136f, 0.7573283322f, -0.6530343002f, -0.9928004525f, -0.119780055f,
+        -0.0532665713f, 0.9985803285f, 0.9754253726f, -0.2203300762f, -0.7665018163f, 0.6422421394f, 0.991636706f, 0.1290606184f, -0.994696838f, 0.1028503788f, -0.5379205513f, -0.84299554f, 0.5022815471f, -0.8647041387f, 0.4559821461f, -0.8899889226f,
+        -0.8659131224f, -0.5001944266f, 0.0879458407f, -0.9961252577f, -0.5051684983f, 0.8630207346f, 0.7753185226f, -0.6315704146f, -0.6921944612f, 0.7217110418f, -0.5191659449f, -0.8546734591f, 0.8978622882f, -0.4402764035f, -0.1706774107f, 0.9853269617f,
+        -0.9353430106f, -0.3537420705f, -0.9992404798f, 0.03896746794f, -0.2882064021f, -0.9575683108f, -0.9663811329f, 0.2571137995f, -0.8759714238f, -0.4823630009f, -0.8303123018f, -0.5572983775f, 0.05110133755f, -0.9986934731f, -0.8558373281f, -0.5172450752f,
+        0.09887025282f, 0.9951003332f, 0.9189016087f, 0.3944867976f, -0.2439375892f, -0.9697909324f, -0.8121409387f, -0.5834613061f, -0.9910431363f, 0.1335421355f, 0.8492423985f, -0.5280031709f, -0.9717838994f, -0.2358729591f, 0.9949457207f, 0.1004142068f,
+        0.6241065508f, -0.7813392434f, 0.662910307f, 0.7486988212f, -0.7197418176f, 0.6942418282f, -0.8143370775f, -0.5803922158f, 0.104521054f, -0.9945226741f, -0.1065926113f, -0.9943027784f, 0.445799684f, -0.8951327509f, 0.105547406f, 0.9944142724f,
+        -0.992790267f, 0.1198644477f, -0.8334366408f, 0.552615025f, 0.9115561563f, -0.4111755999f, 0.8285544909f, -0.5599084351f, 0.7217097654f, -0.6921957921f, 0.4940492677f, -0.8694339084f, -0.3652321272f, -0.9309164803f, -0.9696606758f, 0.2444548501f,
+        0.08925509731f, -0.996008799f, 0.5354071276f, -0.8445941083f, -0.1053576186f, 0.9944343981f, -0.9890284586f, 0.1477251101f, 0.004856104961f, 0.9999882091f, 0.9885598478f, 0.1508291331f, 0.9286129562f, -0.3710498316f, -0.5832393863f, -0.8123003252f,
+        0.3015207509f, 0.9534596146f, -0.9575110528f, 0.2883965738f, 0.9715802154f, -0.2367105511f, 0.229981792f, 0.9731949318f, 0.955763816f, -0.2941352207f, 0.740956116f, 0.6715534485f, -0.9971513787f, -0.07542630764f, 0.6905710663f, -0.7232645452f,
+        -0.290713703f, -0.9568100872f, 0.5912777791f, -0.8064679708f, -0.9454592212f, -0.325740481f, 0.6664455681f, 0.74555369f, 0.6236134912f, 0.7817328275f, 0.9126993851f, -0.4086316587f, -0.8191762011f, 0.5735419353f, -0.8812745759f, -0.4726046147f,
+        0.9953313627f, 0.09651672651f, 0.9855650846f, -0.1692969699f, -0.8495980887f, 0.5274306472f, 0.6174853946f, -0.7865823463f, 0.8508156371f, 0.52546432f, 0.9985032451f, -0.05469249926f, 0.1971371563f, -0.9803759185f, 0.6607855748f, -0.7505747292f,
+        -0.03097494063f, 0.9995201614f, -0.6731660801f, 0.739491331f, -0.7195018362f, -0.6944905383f, 0.9727511689f, 0.2318515979f, 0.9997059088f, -0.0242506907f, 0.4421787429f, -0.8969269532f, 0.9981350961f, -0.061043673f, -0.9173660799f, -0.3980445648f,
+        -0.8150056635f, -0.5794529907f, -0.8789331304f, 0.4769450202f, 0.0158605829f, 0.999874213f, -0.8095464474f, 0.5870558317f, -0.9165898907f, -0.3998286786f, -0.8023542565f, 0.5968480938f, -0.5176737917f, 0.8555780767f, -0.8154407307f, -0.5788405779f,
+        0.4022010347f, -0.9155513791f, -0.9052556868f, -0.4248672045f, 0.7317445619f, 0.6815789728f, -0.5647632201f, -0.8252529947f, -0.8403276335f, -0.5420788397f, -0.9314281527f, 0.363925262f, 0.5238198472f, 0.8518290719f, 0.7432803869f, -0.6689800195f,
+        -0.985371561f, -0.1704197369f, 0.4601468731f, 0.88784281f, 0.825855404f, 0.5638819483f, 0.6182366099f, 0.7859920446f, 0.8331502863f, -0.553046653f, 0.1500307506f, 0.9886813308f, -0.662330369f, -0.7492119075f, -0.668598664f, 0.743623444f,
+        0.7025606278f, 0.7116238924f, -0.5419389763f, -0.8404178401f, -0.3388616456f, 0.9408362159f, 0.8331530315f, 0.5530425174f, -0.2989720662f, -0.9542618632f, 0.2638522993f, 0.9645630949f, 0.124108739f, -0.9922686234f, -0.7282649308f, -0.6852956957f,
+        0.6962500149f, 0.7177993569f, -0.9183535368f, 0.3957610156f, -0.6326102274f, -0.7744703352f, -0.9331891859f, -0.359385508f, -0.1153779357f, -0.9933216659f, 0.9514974788f, -0.3076565421f, -0.08987977445f, -0.9959526224f, 0.6678496916f, 0.7442961705f,
+        0.7952400393f, -0.6062947138f, -0.6462007402f, -0.7631674805f, -0.2733598753f, 0.9619118351f, 0.9669590226f, -0.254931851f, -0.9792894595f, 0.2024651934f, -0.5369502995f, -0.8436138784f, -0.270036471f, -0.9628500944f, -0.6400277131f, 0.7683518247f,
+        -0.7854537493f, -0.6189203566f, 0.06005905383f, -0.9981948257f, -0.02455770378f, 0.9996984141f, -0.65983623f, 0.751409442f, -0.6253894466f, -0.7803127835f, -0.6210408851f, -0.7837781695f, 0.8348888491f, 0.5504185768f, -0.1592275245f, 0.9872419133f,
+        0.8367622488f, 0.5475663786f, -0.8675753916f, -0.4973056806f, -0.2022662628f, -0.9793305667f, 0.9399189937f, 0.3413975472f, 0.9877404807f, -0.1561049093f, -0.9034455656f, 0.4287028224f, 0.1269804218f, -0.9919052235f, -0.3819600854f, 0.924178821f,
+        0.9754625894f, 0.2201652486f, -0.3204015856f, -0.9472818081f, -0.9874760884f, 0.1577687387f, 0.02535348474f, -0.9996785487f, 0.4835130794f, -0.8753371362f, -0.2850799925f, -0.9585037287f, -0.06805516006f, -0.99768156f, -0.7885244045f, -0.6150034663f,
+        0.3185392127f, -0.9479096845f, 0.8880043089f, 0.4598351306f, 0.6476921488f, -0.7619021462f, 0.9820241299f, 0.1887554194f, 0.9357275128f, -0.3527237187f, -0.8894895414f, 0.4569555293f, 0.7922791302f, 0.6101588153f, 0.7483818261f, 0.6632681526f,
+        -0.7288929755f, -0.6846276581f, 0.8729032783f, -0.4878932944f, 0.8288345784f, 0.5594937369f, 0.08074567077f, 0.9967347374f, 0.9799148216f, -0.1994165048f, -0.580730673f, -0.8140957471f, -0.4700049791f, -0.8826637636f, 0.2409492979f, 0.9705377045f,
+        0.9437816757f, -0.3305694308f, -0.8927998638f, -0.4504535528f, -0.8069622304f, 0.5906030467f, 0.06258973166f, 0.9980393407f, -0.9312597469f, 0.3643559849f, 0.5777449785f, 0.8162173362f, -0.3360095855f, -0.941858566f, 0.697932075f, -0.7161639607f,
+        -0.002008157227f, -0.9999979837f, -0.1827294312f, -0.9831632392f, -0.6523911722f, 0.7578824173f, -0.4302626911f, -0.9027037258f, -0.9985126289f, -0.05452091251f, -0.01028102172f, -0.9999471489f, -0.4946071129f, 0.8691166802f, -0.2999350194f, 0.9539596344f,
+        0.8165471961f, 0.5772786819f, 0.2697460475f, 0.962931498f, -0.7306287391f, -0.6827749597f, -0.7590952064f, -0.6509796216f, -0.907053853f, 0.4210146171f, -0.5104861064f, -0.8598860013f, 0.8613350597f, 0.5080373165f, 0.5007881595f, -0.8655698812f,
+        -0.654158152f, 0.7563577938f, -0.8382755311f, -0.545246856f, 0.6940070834f, 0.7199681717f, 0.06950936031f, 0.9975812994f, 0.1702942185f, -0.9853932612f, 0.2695973274f, 0.9629731466f, 0.5519612192f, -0.8338697815f, 0.225657487f, -0.9742067022f,
+        0.4215262855f, -0.9068161835f, 0.4881873305f, -0.8727388672f, -0.3683854996f, -0.9296731273f, -0.9825390578f, 0.1860564427f, 0.81256471f, 0.5828709909f, 0.3196460933f, -0.9475370046f, 0.9570913859f, 0.2897862643f, -0.6876655497f, -0.7260276109f,
+        -0.9988770922f, -0.047376731f, -0.1250179027f, 0.992154486f, -0.8280133617f, 0.560708367f, 0.9324863769f, -0.3612051451f, 0.6394653183f, 0.7688199442f, -0.01623847064f, -0.9998681473f, -0.9955014666f, -0.09474613458f, -0.81453315f, 0.580117012f,
+        0.4037327978f, -0.9148769469f, 0.9944263371f, 0.1054336766f, -0.1624711654f, 0.9867132919f, -0.9949487814f, -0.100383875f, -0.6995302564f, 0.7146029809f, 0.5263414922f, -0.85027327f, -0.5395221479f, 0.841971408f, 0.6579370318f, 0.7530729462f,
+        0.01426758847f, -0.9998982128f, -0.6734383991f, 0.7392433447f, 0.639412098f, -0.7688642071f, 0.9211571421f, 0.3891908523f, -0.146637214f, -0.9891903394f, -0.782318098f, 0.6228791163f, -0.5039610839f, -0.8637263605f, -0.7743120191f, -0.6328039957f,
+    };
+
+    private static readonly float[] Gradients3D =
+    {
+        0, 1, 1, 0,  0,-1, 1, 0,  0, 1,-1, 0,  0,-1,-1, 0,
+        1, 0, 1, 0, -1, 0, 1, 0,  1, 0,-1, 0, -1, 0,-1, 0,
+        1, 1, 0, 0, -1, 1, 0, 0,  1,-1, 0, 0, -1,-1, 0, 0,
+        0, 1, 1, 0,  0,-1, 1, 0,  0, 1,-1, 0,  0,-1,-1, 0,
+        1, 0, 1, 0, -1, 0, 1, 0,  1, 0,-1, 0, -1, 0,-1, 0,
+        1, 1, 0, 0, -1, 1, 0, 0,  1,-1, 0, 0, -1,-1, 0, 0,
+        0, 1, 1, 0,  0,-1, 1, 0,  0, 1,-1, 0,  0,-1,-1, 0,
+        1, 0, 1, 0, -1, 0, 1, 0,  1, 0,-1, 0, -1, 0,-1, 0,
+        1, 1, 0, 0, -1, 1, 0, 0,  1,-1, 0, 0, -1,-1, 0, 0,
+        0, 1, 1, 0,  0,-1, 1, 0,  0, 1,-1, 0,  0,-1,-1, 0,
+        1, 0, 1, 0, -1, 0, 1, 0,  1, 0,-1, 0, -1, 0,-1, 0,
+        1, 1, 0, 0, -1, 1, 0, 0,  1,-1, 0, 0, -1,-1, 0, 0,
+        0, 1, 1, 0,  0,-1, 1, 0,  0, 1,-1, 0,  0,-1,-1, 0,
+        1, 0, 1, 0, -1, 0, 1, 0,  1, 0,-1, 0, -1, 0,-1, 0,
+        1, 1, 0, 0, -1, 1, 0, 0,  1,-1, 0, 0, -1,-1, 0, 0,
+        1, 1, 0, 0,  0,-1, 1, 0, -1, 1, 0, 0,  0,-1,-1, 0
+    };
+
+    private static readonly float[] RandVecs3D =
+    {
+        -0.7292736885f, -0.6618439697f, 0.1735581948f, 0, 0.790292081f, -0.5480887466f, -0.2739291014f, 0, 0.7217578935f, 0.6226212466f, -0.3023380997f, 0, 0.565683137f, -0.8208298145f, -0.0790000257f, 0, 0.760049034f, -0.5555979497f, -0.3370999617f, 0, 0.3713945616f, 0.5011264475f, 0.7816254623f, 0, -0.1277062463f, -0.4254438999f, -0.8959289049f, 0, -0.2881560924f, -0.5815838982f, 0.7607405838f, 0,
+        0.5849561111f, -0.662820239f, -0.4674352136f, 0, 0.3307171178f, 0.0391653737f, 0.94291689f, 0, 0.8712121778f, -0.4113374369f, -0.2679381538f, 0, 0.580981015f, 0.7021915846f, 0.4115677815f, 0, 0.503756873f, 0.6330056931f, -0.5878203852f, 0, 0.4493712205f, 0.601390195f, 0.6606022552f, 0, -0.6878403724f, 0.09018890807f, -0.7202371714f, 0, -0.5958956522f, -0.6469350577f, 0.475797649f, 0,
+        -0.5127052122f, 0.1946921978f, -0.8361987284f, 0, -0.9911507142f, -0.05410276466f, -0.1212153153f, 0, -0.2149721042f, 0.9720882117f, -0.09397607749f, 0, -0.7518650936f, -0.5428057603f, 0.3742469607f, 0, 0.5237068895f, 0.8516377189f, -0.02107817834f, 0, 0.6333504779f, 0.1926167129f, -0.7495104896f, 0, -0.06788241606f, 0.3998305789f, 0.9140719259f, 0, -0.5538628599f, -0.4729896695f, -0.6852128902f, 0,
+        -0.7261455366f, -0.5911990757f, 0.3509933228f, 0, -0.9229274737f, -0.1782808786f, 0.3412049336f, 0, -0.6968815002f, 0.6511274338f, 0.3006480328f, 0, 0.9608044783f, -0.2098363234f, -0.1811724921f, 0, 0.06817146062f, -0.9743405129f, 0.2145069156f, 0, -0.3577285196f, -0.6697087264f, -0.6507845481f, 0, -0.1868621131f, 0.7648617052f, -0.6164974636f, 0, -0.6541697588f, 0.3967914832f, 0.6439087246f, 0,
+        0.6993340405f, -0.6164538506f, 0.3618239211f, 0, -0.1546665739f, 0.6291283928f, 0.7617583057f, 0, -0.6841612949f, -0.2580482182f, -0.6821542638f, 0, 0.5383980957f, 0.4258654885f, 0.7271630328f, 0, -0.5026987823f, -0.7939832935f, -0.3418836993f, 0, 0.3202971715f, 0.2834415347f, 0.9039195862f, 0, 0.8683227101f, -0.0003762656404f, -0.4959995258f, 0, 0.791120031f, -0.08511045745f, 0.6057105799f, 0,
+        -0.04011016052f, -0.4397248749f, 0.8972364289f, 0, 0.9145119872f, 0.3579346169f, -0.1885487608f, 0, -0.9612039066f, -0.2756484276f, 0.01024666929f, 0, 0.6510361721f, -0.2877799159f, -0.7023778346f, 0, -0.2041786351f, 0.7365237271f, 0.644859585f, 0, -0.7718263711f, 0.3790626912f, 0.5104855816f, 0, -0.3060082741f, -0.7692987727f, 0.5608371729f, 0, 0.454007341f, -0.5024843065f, 0.7357899537f, 0,
+        0.4816795475f, 0.6021208291f, -0.6367380315f, 0, 0.6961980369f, -0.3222197429f, 0.641469197f, 0, -0.6532160499f, -0.6781148932f, 0.3368515753f, 0, 0.5089301236f, -0.6154662304f, -0.6018234363f, 0, -0.1635919754f, -0.9133604627f, -0.372840892f, 0, 0.52408019f, -0.8437664109f, 0.1157505864f, 0, 0.5902587356f, 0.4983817807f, -0.6349883666f, 0, 0.5863227872f, 0.494764745f, 0.6414307729f, 0,
+        0.6779335087f, 0.2341345225f, 0.6968408593f, 0, 0.7177054546f, -0.6858979348f, 0.120178631f, 0, -0.5328819713f, -0.5205125012f, 0.6671608058f, 0, -0.8654874251f, -0.0700727088f, -0.4960053754f, 0, -0.2861810166f, 0.7952089234f, 0.5345495242f, 0, -0.04849529634f, 0.9810836427f, -0.1874115585f, 0, -0.6358521667f, 0.6058348682f, 0.4781800233f, 0, 0.6254794696f, -0.2861619734f, 0.7258696564f, 0,
+        -0.2585259868f, 0.5061949264f, -0.8227581726f, 0, 0.02136306781f, 0.5064016808f, -0.8620330371f, 0, 0.200111773f, 0.8599263484f, 0.4695550591f, 0, 0.4743561372f, 0.6014985084f, -0.6427953014f, 0, 0.6622993731f, -0.5202474575f, -0.5391679918f, 0, 0.08084972818f, -0.6532720452f, 0.7527940996f, 0, -0.6893687501f, 0.0592860349f, 0.7219805347f, 0, -0.1121887082f, -0.9673185067f, 0.2273952515f, 0,
+        0.7344116094f, 0.5979668656f, -0.3210532909f, 0, 0.5789393465f, -0.2488849713f, 0.7764570201f, 0, 0.6988182827f, 0.3557169806f, -0.6205791146f, 0, -0.8636845529f, -0.2748771249f, -0.4224826141f, 0, -0.4247027957f, -0.4640880967f, 0.777335046f, 0, 0.5257722489f, -0.8427017621f, 0.1158329937f, 0, 0.9343830603f, 0.316302472f, -0.1639543925f, 0, -0.1016836419f, -0.8057303073f, -0.5834887393f, 0,
+        -0.6529238969f, 0.50602126f, -0.5635892736f, 0, -0.2465286165f, -0.9668205684f, -0.06694497494f, 0, -0.9776897119f, -0.2099250524f, -0.007368825344f, 0, 0.7736893337f, 0.5734244712f, 0.2694238123f, 0, -0.6095087895f, 0.4995678998f, 0.6155736747f, 0, 0.5794535482f, 0.7434546771f, 0.3339292269f, 0, -0.8226211154f, 0.08142581855f, 0.5627293636f, 0, -0.510385483f, 0.4703667658f, 0.7199039967f, 0,
+        -0.5764971849f, -0.07231656274f, -0.8138926898f, 0, 0.7250628871f, 0.3949971505f, -0.5641463116f, 0, -0.1525424005f, 0.4860840828f, -0.8604958341f, 0, -0.5550976208f, -0.4957820792f, 0.667882296f, 0, -0.1883614327f, 0.9145869398f, 0.357841725f, 0, 0.7625556724f, -0.5414408243f, -0.3540489801f, 0, -0.5870231946f, -0.3226498013f, -0.7424963803f, 0, 0.3051124198f, 0.2262544068f, -0.9250488391f, 0,
+        0.6379576059f, 0.577242424f, -0.5097070502f, 0, -0.5966775796f, 0.1454852398f, -0.7891830656f, 0, -0.658330573f, 0.6555487542f, -0.3699414651f, 0, 0.7434892426f, 0.2351084581f, 0.6260573129f, 0, 0.5562114096f, 0.8264360377f, -0.0873632843f, 0, -0.3028940016f, -0.8251527185f, 0.4768419182f, 0, 0.1129343818f, -0.985888439f, -0.1235710781f, 0, 0.5937652891f, -0.5896813806f, 0.5474656618f, 0,
+        0.6757964092f, -0.5835758614f, -0.4502648413f, 0, 0.7242302609f, -0.1152719764f, 0.6798550586f, 0, -0.9511914166f, 0.0753623979f, -0.2992580792f, 0, 0.2539470961f, -0.1886339355f, 0.9486454084f, 0, 0.571433621f, -0.1679450851f, -0.8032795685f, 0, -0.06778234979f, 0.3978269256f, 0.9149531629f, 0, 0.6074972649f, 0.733060024f, -0.3058922593f, 0, -0.5435478392f, 0.1675822484f, 0.8224791405f, 0,
+        -0.5876678086f, -0.3380045064f, -0.7351186982f, 0, -0.7967562402f, 0.04097822706f, -0.6029098428f, 0, -0.1996350917f, 0.8706294745f, 0.4496111079f, 0, -0.02787660336f, -0.9106232682f, -0.4122962022f, 0, -0.7797625996f, -0.6257634692f, 0.01975775581f, 0, -0.5211232846f, 0.7401644346f, -0.4249554471f, 0, 0.8575424857f, 0.4053272873f, -0.3167501783f, 0, 0.1045223322f, 0.8390195772f, -0.5339674439f, 0,
+        0.3501822831f, 0.9242524096f, -0.1520850155f, 0, 0.1987849858f, 0.07647613266f, 0.9770547224f, 0, 0.7845996363f, 0.6066256811f, -0.1280964233f, 0, 0.09006737436f, -0.9750989929f, -0.2026569073f, 0, -0.8274343547f, -0.542299559f, 0.1458203587f, 0, -0.3485797732f, -0.415802277f, 0.840000362f, 0, -0.2471778936f, -0.7304819962f, -0.6366310879f, 0, -0.3700154943f, 0.8577948156f, 0.3567584454f, 0,
+        0.5913394901f, -0.548311967f, -0.5913303597f, 0, 0.1204873514f, -0.7626472379f, -0.6354935001f, 0, 0.616959265f, 0.03079647928f, 0.7863922953f, 0, 0.1258156836f, -0.6640829889f, -0.7369967419f, 0, -0.6477565124f, -0.1740147258f, -0.7417077429f, 0, 0.6217889313f, -0.7804430448f, -0.06547655076f, 0, 0.6589943422f, -0.6096987708f, 0.4404473475f, 0, -0.2689837504f, -0.6732403169f, -0.6887635427f, 0,
+        -0.3849775103f, 0.5676542638f, 0.7277093879f, 0, 0.5754444408f, 0.8110471154f, -0.1051963504f, 0, 0.9141593684f, 0.3832947817f, 0.131900567f, 0, -0.107925319f, 0.9245493968f, 0.3654593525f, 0, 0.377977089f, 0.3043148782f, 0.8743716458f, 0, -0.2142885215f, -0.8259286236f, 0.5214617324f, 0, 0.5802544474f, 0.4148098596f, -0.7008834116f, 0, -0.1982660881f, 0.8567161266f, -0.4761596756f, 0,
+        -0.03381553704f, 0.3773180787f, -0.9254661404f, 0, -0.6867922841f, -0.6656597827f, 0.2919133642f, 0, 0.7731742607f, -0.2875793547f, -0.5652430251f, 0, -0.09655941928f, 0.9193708367f, -0.3813575004f, 0, 0.2715702457f, -0.9577909544f, -0.09426605581f, 0, 0.2451015704f, -0.6917998565f, -0.6792188003f, 0, 0.977700782f, -0.1753855374f, 0.1155036542f, 0, -0.5224739938f, 0.8521606816f, 0.02903615945f, 0,
+        -0.7734880599f, -0.5261292347f, 0.3534179531f, 0, -0.7134492443f, -0.269547243f, 0.6467878011f, 0, 0.1644037271f, 0.5105846203f, -0.8439637196f, 0, 0.6494635788f, 0.05585611296f, 0.7583384168f, 0, -0.4711970882f, 0.5017280509f, -0.7254255765f, 0, -0.6335764307f, -0.2381686273f, -0.7361091029f, 0, -0.9021533097f, -0.270947803f, -0.3357181763f, 0, -0.3793711033f, 0.872258117f, 0.3086152025f, 0,
+        -0.6855598966f, -0.3250143309f, 0.6514394162f, 0, 0.2900942212f, -0.7799057743f, -0.5546100667f, 0, -0.2098319339f, 0.85037073f, 0.4825351604f, 0, -0.4592603758f, 0.6598504336f, -0.5947077538f, 0, 0.8715945488f, 0.09616365406f, -0.4807031248f, 0, -0.6776666319f, 0.7118504878f, -0.1844907016f, 0, 0.7044377633f, 0.312427597f, 0.637304036f, 0, -0.7052318886f, -0.2401093292f, -0.6670798253f, 0,
+        0.081921007f, -0.7207336136f, -0.6883545647f, 0, -0.6993680906f, -0.5875763221f, -0.4069869034f, 0, -0.1281454481f, 0.6419895885f, 0.7559286424f, 0, -0.6337388239f, -0.6785471501f, -0.3714146849f, 0, 0.5565051903f, -0.2168887573f, -0.8020356851f, 0, -0.5791554484f, 0.7244372011f, -0.3738578718f, 0, 0.1175779076f, -0.7096451073f, 0.6946792478f, 0, -0.6134619607f, 0.1323631078f, 0.7785527795f, 0,
+        0.6984635305f, -0.02980516237f, -0.715024719f, 0, 0.8318082963f, -0.3930171956f, 0.3919597455f, 0, 0.1469576422f, 0.05541651717f, -0.9875892167f, 0, 0.708868575f, -0.2690503865f, 0.6520101478f, 0, 0.2726053183f, 0.67369766f, -0.68688995f, 0, -0.6591295371f, 0.3035458599f, -0.6880466294f, 0, 0.4815131379f, -0.7528270071f, 0.4487723203f, 0, 0.9430009463f, 0.1675647412f, -0.2875261255f, 0,
+        0.434802957f, 0.7695304522f, -0.4677277752f, 0, 0.3931996188f, 0.594473625f, 0.7014236729f, 0, 0.7254336655f, -0.603925654f, 0.3301814672f, 0, 0.7590235227f, -0.6506083235f, 0.02433313207f, 0, -0.8552768592f, -0.3430042733f, 0.3883935666f, 0, -0.6139746835f, 0.6981725247f, 0.3682257648f, 0, -0.7465905486f, -0.5752009504f, 0.3342849376f, 0, 0.5730065677f, 0.810555537f, -0.1210916791f, 0,
+        -0.9225877367f, -0.3475211012f, -0.167514036f, 0, -0.7105816789f, -0.4719692027f, -0.5218416899f, 0, -0.08564609717f, 0.3583001386f, 0.929669703f, 0, -0.8279697606f, -0.2043157126f, 0.5222271202f, 0, 0.427944023f, 0.278165994f, 0.8599346446f, 0, 0.5399079671f, -0.7857120652f, -0.3019204161f, 0, 0.5678404253f, -0.5495413974f, -0.6128307303f, 0, -0.9896071041f, 0.1365639107f, -0.04503418428f, 0,
+        -0.6154342638f, -0.6440875597f, 0.4543037336f, 0, 0.1074204368f, -0.7946340692f, 0.5975094525f, 0, -0.3595449969f, -0.8885529948f, 0.28495784f, 0, -0.2180405296f, 0.1529888965f, 0.9638738118f, 0, -0.7277432317f, -0.6164050508f, -0.3007234646f, 0, 0.7249729114f, -0.00669719484f, 0.6887448187f, 0, -0.5553659455f, -0.5336586252f, 0.6377908264f, 0, 0.5137558015f, 0.7976208196f, -0.3160000073f, 0,
+        -0.3794024848f, 0.9245608561f, -0.03522751494f, 0, 0.8229248658f, 0.2745365933f, -0.4974176556f, 0, -0.5404114394f, 0.6091141441f, 0.5804613989f, 0, 0.8036581901f, -0.2703029469f, 0.5301601931f, 0, 0.6044318879f, 0.6832968393f, 0.4095943388f, 0, 0.06389988817f, 0.9658208605f, -0.2512108074f, 0, 0.1087113286f, 0.7402471173f, -0.6634877936f, 0, -0.713427712f, -0.6926784018f, 0.1059128479f, 0,
+        0.6458897819f, -0.5724548511f, -0.5050958653f, 0, -0.6553931414f, 0.7381471625f, 0.159995615f, 0, 0.3910961323f, 0.9188871375f, -0.05186755998f, 0, -0.4879022471f, -0.5904376907f, 0.6429111375f, 0, 0.6014790094f, 0.7707441366f, -0.2101820095f, 0, -0.5677173047f, 0.7511360995f, 0.3368851762f, 0, 0.7858573506f, 0.226674665f, 0.5753666838f, 0, -0.4520345543f, -0.604222686f, -0.6561857263f, 0,
+        0.002272116345f, 0.4132844051f, -0.9105991643f, 0, -0.5815751419f, -0.5162925989f, 0.6286591339f, 0, -0.03703704785f, 0.8273785755f, 0.5604221175f, 0, -0.5119692504f, 0.7953543429f, -0.3244980058f, 0, -0.2682417366f, -0.9572290247f, -0.1084387619f, 0, -0.2322482736f, -0.9679131102f, -0.09594243324f, 0, 0.3554328906f, -0.8881505545f, 0.2913006227f, 0, 0.7346520519f, -0.4371373164f, 0.5188422971f, 0,
+        0.9985120116f, 0.04659011161f, -0.02833944577f, 0, -0.3727687496f, -0.9082481361f, 0.1900757285f, 0, 0.91737377f, -0.3483642108f, 0.1925298489f, 0, 0.2714911074f, 0.4147529736f, -0.8684886582f, 0, 0.5131763485f, -0.7116334161f, 0.4798207128f, 0, -0.8737353606f, 0.18886992f, -0.4482350644f, 0, 0.8460043821f, -0.3725217914f, 0.3814499973f, 0, 0.8978727456f, -0.1780209141f, -0.4026575304f, 0,
+        0.2178065647f, -0.9698322841f, -0.1094789531f, 0, -0.1518031304f, -0.7788918132f, -0.6085091231f, 0, -0.2600384876f, -0.4755398075f, -0.8403819825f, 0, 0.572313509f, -0.7474340931f, -0.3373418503f, 0, -0.7174141009f, 0.1699017182f, -0.6756111411f, 0, -0.684180784f, 0.02145707593f, -0.7289967412f, 0, -0.2007447902f, 0.06555605789f, -0.9774476623f, 0, -0.1148803697f, -0.8044887315f, 0.5827524187f, 0,
+        -0.7870349638f, 0.03447489231f, 0.6159443543f, 0, -0.2015596421f, 0.6859872284f, 0.6991389226f, 0, -0.08581082512f, -0.10920836f, -0.9903080513f, 0, 0.5532693395f, 0.7325250401f, -0.396610771f, 0, -0.1842489331f, -0.9777375055f, -0.1004076743f, 0, 0.0775473789f, -0.9111505856f, 0.4047110257f, 0, 0.1399838409f, 0.7601631212f, -0.6344734459f, 0, 0.4484419361f, -0.845289248f, 0.2904925424f, 0
+    };
+
+
+    [MethodImpl(INLINE)]
+    private static float FastMin(float a, float b) { return a < b ? a : b; }
+
+    [MethodImpl(INLINE)]
+    private static float FastMax(float a, float b) { return a > b ? a : b; }
+
+    [MethodImpl(INLINE)]
+    private static float FastAbs(float f) { return f < 0 ? -f : f; }
+
+    [MethodImpl(INLINE)]
+    private static float FastSqrt(float f) { return (float)Math.Sqrt(f); }
+
+    [MethodImpl(INLINE)]
+    private static int FastFloor(FNLfloat f) { return f >= 0 ? (int)f : (int)f - 1; }
+
+    [MethodImpl(INLINE)]
+    private static int FastRound(FNLfloat f) { return f >= 0 ? (int)(f + 0.5f) : (int)(f - 0.5f); }
+
+    [MethodImpl(INLINE)]
+    private static float Lerp(float a, float b, float t) { return a + t * (b - a); }
+
+    [MethodImpl(INLINE)]
+    private static float InterpHermite(float t) { return t * t * (3 - 2 * t); }
+
+    [MethodImpl(INLINE)]
+    private static float InterpQuintic(float t) { return t * t * t * (t * (t * 6 - 15) + 10); }
+
+    [MethodImpl(INLINE)]
+    private static float CubicLerp(float a, float b, float c, float d, float t)
+    {
+        float p = (d - c) - (a - b);
+        return t * t * t * p + t * t * ((a - b) - p) + t * (c - a) + b;
+    }
+
+    [MethodImpl(INLINE)]
+    private static float PingPong(float t)
+    {
+        t -= (int)(t * 0.5f) * 2;
+        return t < 1 ? t : 2 - t;
+    }
+
+    private void CalculateFractalBounding()
+    {
+        float gain = FastAbs(mGain);
+        float amp = gain;
+        float ampFractal = 1.0f;
+        for (int i = 1; i < mOctaves; i++)
+        {
+            ampFractal += amp;
+            amp *= gain;
+        }
+        mFractalBounding = 1 / ampFractal;
+    }
+
+    // Hashing
+    private const int PrimeX = 501125321;
+    private const int PrimeY = 1136930381;
+    private const int PrimeZ = 1720413743;
+
+    [MethodImpl(INLINE)]
+    private static int Hash(int seed, int xPrimed, int yPrimed)
+    {
+        int hash = seed ^ xPrimed ^ yPrimed;
+
+        hash *= 0x27d4eb2d;
+        return hash;
+    }
+
+    [MethodImpl(INLINE)]
+    private static int Hash(int seed, int xPrimed, int yPrimed, int zPrimed)
+    {
+        int hash = seed ^ xPrimed ^ yPrimed ^ zPrimed;
+
+        hash *= 0x27d4eb2d;
+        return hash;
+    }
+
+    [MethodImpl(INLINE)]
+    private static float ValCoord(int seed, int xPrimed, int yPrimed)
+    {
+        int hash = Hash(seed, xPrimed, yPrimed);
+
+        hash *= hash;
+        hash ^= hash << 19;
+        return hash * (1 / 2147483648.0f);
+    }
+
+    [MethodImpl(INLINE)]
+    private static float ValCoord(int seed, int xPrimed, int yPrimed, int zPrimed)
+    {
+        int hash = Hash(seed, xPrimed, yPrimed, zPrimed);
+
+        hash *= hash;
+        hash ^= hash << 19;
+        return hash * (1 / 2147483648.0f);
+    }
+
+    [MethodImpl(INLINE)]
+    private static float GradCoord(int seed, int xPrimed, int yPrimed, float xd, float yd)
+    {
+        int hash = Hash(seed, xPrimed, yPrimed);
+        hash ^= hash >> 15;
+        hash &= 127 << 1;
+
+        float xg = Gradients2D[hash];
+        float yg = Gradients2D[hash | 1];
+
+        return xd * xg + yd * yg;
+    }
+
+    [MethodImpl(INLINE)]
+    private static float GradCoord(int seed, int xPrimed, int yPrimed, int zPrimed, float xd, float yd, float zd)
+    {
+        int hash = Hash(seed, xPrimed, yPrimed, zPrimed);
+        hash ^= hash >> 15;
+        hash &= 63 << 2;
+
+        float xg = Gradients3D[hash];
+        float yg = Gradients3D[hash | 1];
+        float zg = Gradients3D[hash | 2];
+
+        return xd * xg + yd * yg + zd * zg;
+    }
+
+    [MethodImpl(INLINE)]
+    private static void GradCoordOut(int seed, int xPrimed, int yPrimed, out float xo, out float yo)
+    {
+        int hash = Hash(seed, xPrimed, yPrimed) & (255 << 1);
+
+        xo = RandVecs2D[hash];
+        yo = RandVecs2D[hash | 1];
+    }
+
+    [MethodImpl(INLINE)]
+    private static void GradCoordOut(int seed, int xPrimed, int yPrimed, int zPrimed, out float xo, out float yo, out float zo)
+    {
+        int hash = Hash(seed, xPrimed, yPrimed, zPrimed) & (255 << 2);
+
+        xo = RandVecs3D[hash];
+        yo = RandVecs3D[hash | 1];
+        zo = RandVecs3D[hash | 2];
+    }
+
+    [MethodImpl(INLINE)]
+    private static void GradCoordDual(int seed, int xPrimed, int yPrimed, float xd, float yd, out float xo, out float yo)
+    {
+        int hash = Hash(seed, xPrimed, yPrimed);
+        int index1 = hash & (127 << 1);
+        int index2 = (hash >> 7) & (255 << 1);
+
+        float xg = Gradients2D[index1];
+        float yg = Gradients2D[index1 | 1];
+        float value = xd * xg + yd * yg;
+
+        float xgo = RandVecs2D[index2];
+        float ygo = RandVecs2D[index2 | 1];
+
+        xo = value * xgo;
+        yo = value * ygo;
+    }
+
+    [MethodImpl(INLINE)]
+    private static void GradCoordDual(int seed, int xPrimed, int yPrimed, int zPrimed, float xd, float yd, float zd, out float xo, out float yo, out float zo)
+    {
+        int hash = Hash(seed, xPrimed, yPrimed, zPrimed);
+        int index1 = hash & (63 << 2);
+        int index2 = (hash >> 6) & (255 << 2);
+
+        float xg = Gradients3D[index1];
+        float yg = Gradients3D[index1 | 1];
+        float zg = Gradients3D[index1 | 2];
+        float value = xd * xg + yd * yg + zd * zg;
+
+        float xgo = RandVecs3D[index2];
+        float ygo = RandVecs3D[index2 | 1];
+        float zgo = RandVecs3D[index2 | 2];
+
+        xo = value * xgo;
+        yo = value * ygo;
+        zo = value * zgo;
+    }
+
+
+    // Generic noise gen
+
+    private float GenNoiseSingle(int seed, FNLfloat x, FNLfloat y)
+    {
+        switch (mNoiseType)
+        {
+            case NoiseType.OpenSimplex2:
+                return SingleSimplex(seed, x, y);
+            case NoiseType.OpenSimplex2S:
+                return SingleOpenSimplex2S(seed, x, y);
+            case NoiseType.Cellular:
+                return SingleCellular(seed, x, y);
+            case NoiseType.Perlin:
+                return SinglePerlin(seed, x, y);
+            case NoiseType.ValueCubic:
+                return SingleValueCubic(seed, x, y);
+            case NoiseType.Value:
+                return SingleValue(seed, x, y);
+            default:
+                return 0;
+        }
+    }
+
+    private float GenNoiseSingle(int seed, FNLfloat x, FNLfloat y, FNLfloat z)
+    {
+        switch (mNoiseType)
+        {
+            case NoiseType.OpenSimplex2:
+                return SingleOpenSimplex2(seed, x, y, z);
+            case NoiseType.OpenSimplex2S:
+                return SingleOpenSimplex2S(seed, x, y, z);
+            case NoiseType.Cellular:
+                return SingleCellular(seed, x, y, z);
+            case NoiseType.Perlin:
+                return SinglePerlin(seed, x, y, z);
+            case NoiseType.ValueCubic:
+                return SingleValueCubic(seed, x, y, z);
+            case NoiseType.Value:
+                return SingleValue(seed, x, y, z);
+            default:
+                return 0;
+        }
+    }
+
+
+    // Noise Coordinate Transforms (frequency, and possible skew or rotation)
+
+    [MethodImpl(INLINE)]
+    private void TransformNoiseCoordinate(ref FNLfloat x, ref FNLfloat y)
+    {
+        x *= mFrequency;
+        y *= mFrequency;
+
+        switch (mNoiseType)
+        {
+            case NoiseType.OpenSimplex2:
+            case NoiseType.OpenSimplex2S:
+                {
+                    const FNLfloat SQRT3 = (FNLfloat)1.7320508075688772935274463415059;
+                    const FNLfloat F2 = 0.5f * (SQRT3 - 1);
+                    FNLfloat t = (x + y) * F2;
+                    x += t; 
+                    y += t;
+                }
+                break;
+            default:
+                break;
+        }
+    }
+
+    [MethodImpl(INLINE)]
+    private void TransformNoiseCoordinate(ref FNLfloat x, ref FNLfloat y, ref FNLfloat z)
+    {
+        x *= mFrequency;
+        y *= mFrequency;
+        z *= mFrequency;
+
+        switch (mTransformType3D)
+        {
+            case TransformType3D.ImproveXYPlanes:
+                {
+                    FNLfloat xy = x + y;
+                    FNLfloat s2 = xy * -(FNLfloat)0.211324865405187;
+                    z *= (FNLfloat)0.577350269189626;
+                    x += s2 - z;
+                    y = y + s2 - z;
+                    z += xy * (FNLfloat)0.577350269189626;
+                }
+                break;
+            case TransformType3D.ImproveXZPlanes:
+                {
+                    FNLfloat xz = x + z;
+                    FNLfloat s2 = xz * -(FNLfloat)0.211324865405187;
+                    y *= (FNLfloat)0.577350269189626;
+                    x += s2 - y;
+                    z += s2 - y;
+                    y += xz * (FNLfloat)0.577350269189626;
+                }
+                break;
+            case TransformType3D.DefaultOpenSimplex2:
+                {
+                    const FNLfloat R3 = (FNLfloat)(2.0 / 3.0);
+                    FNLfloat r = (x + y + z) * R3; // Rotation, not skew
+                    x = r - x;
+                    y = r - y;
+                    z = r - z;
+                }
+                break;
+            default:
+                break;
+        }
+    }
+
+    private void UpdateTransformType3D()
+    {
+        switch (mRotationType3D)
+        {
+            case RotationType3D.ImproveXYPlanes:
+                mTransformType3D = TransformType3D.ImproveXYPlanes;
+                break;
+            case RotationType3D.ImproveXZPlanes:
+                mTransformType3D = TransformType3D.ImproveXZPlanes;
+                break;
+            default:
+                switch (mNoiseType)
+                {
+                    case NoiseType.OpenSimplex2:
+                    case NoiseType.OpenSimplex2S:
+                        mTransformType3D = TransformType3D.DefaultOpenSimplex2;
+                        break;
+                    default:
+                        mTransformType3D = TransformType3D.None;
+                        break;
+                }
+                break;
+        }
+    }
+
+
+    // Domain Warp Coordinate Transforms
+
+    [MethodImpl(INLINE)]
+    private void TransformDomainWarpCoordinate(ref FNLfloat x, ref FNLfloat y)
+    {
+        switch (mDomainWarpType)
+        {
+            case DomainWarpType.OpenSimplex2:
+            case DomainWarpType.OpenSimplex2Reduced:
+            {
+                const FNLfloat SQRT3 = (FNLfloat)1.7320508075688772935274463415059;
+                const FNLfloat F2 = 0.5f * (SQRT3 - 1);
+                FNLfloat t = (x + y) * F2;
+                x += t; y += t;
+            }
+            break;
+            default:
+                break;
+        }
+    }
+
+    [MethodImpl(INLINE)]
+    private void TransformDomainWarpCoordinate(ref FNLfloat x, ref FNLfloat y, ref FNLfloat z)
+    {
+        switch (mWarpTransformType3D)
+        {
+            case TransformType3D.ImproveXYPlanes:
+                {
+                    FNLfloat xy = x + y;
+                    FNLfloat s2 = xy * -(FNLfloat)0.211324865405187;
+                    z *= (FNLfloat)0.577350269189626;
+                    x += s2 - z;
+                    y = y + s2 - z;
+                    z += xy * (FNLfloat)0.577350269189626;
+                }
+                break;
+            case TransformType3D.ImproveXZPlanes:
+                {
+                    FNLfloat xz = x + z;
+                    FNLfloat s2 = xz * -(FNLfloat)0.211324865405187;
+                    y *= (FNLfloat)0.577350269189626;
+                    x += s2 - y; z += s2 - y;
+                    y += xz * (FNLfloat)0.577350269189626;
+                }
+                break;
+            case TransformType3D.DefaultOpenSimplex2:
+                {
+                    const FNLfloat R3 = (FNLfloat)(2.0 / 3.0);
+                    FNLfloat r = (x + y + z) * R3; // Rotation, not skew
+                    x = r - x;
+                    y = r - y;
+                    z = r - z;
+                }
+                break;
+            default:
+                break;
+        }
+    }
+
+    private void UpdateWarpTransformType3D()
+    {
+        switch (mRotationType3D)
+        {
+            case RotationType3D.ImproveXYPlanes:
+                mWarpTransformType3D = TransformType3D.ImproveXYPlanes;
+                break;
+            case RotationType3D.ImproveXZPlanes:
+                mWarpTransformType3D = TransformType3D.ImproveXZPlanes;
+                break;
+            default:
+                switch (mDomainWarpType)
+                {
+                    case DomainWarpType.OpenSimplex2:
+                    case DomainWarpType.OpenSimplex2Reduced:
+                        mWarpTransformType3D = TransformType3D.DefaultOpenSimplex2;
+                        break;
+                    default:
+                        mWarpTransformType3D = TransformType3D.None;
+                        break;
+                }
+                break;
+        }
+    }
+
+
+    // Fractal FBm
+
+    private float GenFractalFBm(FNLfloat x, FNLfloat y)
+    {
+        int seed = mSeed;
+        float sum = 0;
+        float amp = mFractalBounding;
+
+        for (int i = 0; i < mOctaves; i++)
+        {
+            float noise = GenNoiseSingle(seed++, x, y);
+            sum += noise * amp;
+            amp *= Lerp(1.0f, FastMin(noise + 1, 2) * 0.5f, mWeightedStrength);
+
+            x *= mLacunarity;
+            y *= mLacunarity;
+            amp *= mGain;
+        }
+
+        return sum;
+    }
+
+    private float GenFractalFBm(FNLfloat x, FNLfloat y, FNLfloat z)
+    {
+        int seed = mSeed;
+        float sum = 0;
+        float amp = mFractalBounding;
+
+        for (int i = 0; i < mOctaves; i++)
+        {
+            float noise = GenNoiseSingle(seed++, x, y, z);
+            sum += noise * amp;
+            amp *= Lerp(1.0f, (noise + 1) * 0.5f, mWeightedStrength);
+
+            x *= mLacunarity;
+            y *= mLacunarity;
+            z *= mLacunarity;
+            amp *= mGain;
+        }
+
+        return sum;
+    }
+
+
+    // Fractal Ridged
+
+    private float GenFractalRidged(FNLfloat x, FNLfloat y)
+    {
+        int seed = mSeed;
+        float sum = 0;
+        float amp = mFractalBounding;
+
+        for (int i = 0; i < mOctaves; i++)
+        {
+            float noise = FastAbs(GenNoiseSingle(seed++, x, y));
+            sum += (noise * -2 + 1) * amp;
+            amp *= Lerp(1.0f, 1 - noise, mWeightedStrength);
+
+            x *= mLacunarity;
+            y *= mLacunarity;
+            amp *= mGain;
+        }
+
+        return sum;
+    }
+
+    private float GenFractalRidged(FNLfloat x, FNLfloat y, FNLfloat z)
+    {
+        int seed = mSeed;
+        float sum = 0;
+        float amp = mFractalBounding;
+
+        for (int i = 0; i < mOctaves; i++)
+        {
+            float noise = FastAbs(GenNoiseSingle(seed++, x, y, z));
+            sum += (noise * -2 + 1) * amp;
+            amp *= Lerp(1.0f, 1 - noise, mWeightedStrength);
+
+            x *= mLacunarity;
+            y *= mLacunarity;
+            z *= mLacunarity;
+            amp *= mGain;
+        }
+
+        return sum;
+    }
+
+
+    // Fractal PingPong 
+
+    private float GenFractalPingPong(FNLfloat x, FNLfloat y)
+    {
+        int seed = mSeed;
+        float sum = 0;
+        float amp = mFractalBounding;
+
+        for (int i = 0; i < mOctaves; i++)
+        {
+            float noise = PingPong((GenNoiseSingle(seed++, x, y) + 1) * mPingPongStrength);
+            sum += (noise - 0.5f) * 2 * amp;
+            amp *= Lerp(1.0f, noise, mWeightedStrength);
+
+            x *= mLacunarity;
+            y *= mLacunarity;
+            amp *= mGain;
+        }
+
+        return sum;
+    }
+
+    private float GenFractalPingPong(FNLfloat x, FNLfloat y, FNLfloat z)
+    {
+        int seed = mSeed;
+        float sum = 0;
+        float amp = mFractalBounding;
+
+        for (int i = 0; i < mOctaves; i++)
+        {
+            float noise = PingPong((GenNoiseSingle(seed++, x, y, z) + 1) * mPingPongStrength);
+            sum += (noise - 0.5f) * 2 * amp;
+            amp *= Lerp(1.0f, noise, mWeightedStrength);
+
+            x *= mLacunarity;
+            y *= mLacunarity;
+            z *= mLacunarity;
+            amp *= mGain;
+        }
+
+        return sum;
+    }
+
+
+    // Simplex/OpenSimplex2 Noise
+
+    private float SingleSimplex(int seed, FNLfloat x, FNLfloat y)
+    {
+        // 2D OpenSimplex2 case uses the same algorithm as ordinary Simplex.
+
+        const float SQRT3 = 1.7320508075688772935274463415059f;
+        const float G2 = (3 - SQRT3) / 6;
+
+        /*
+         * --- Skew moved to TransformNoiseCoordinate method ---
+         * const FNfloat F2 = 0.5f * (SQRT3 - 1);
+         * FNfloat s = (x + y) * F2;
+         * x += s; y += s;
+        */
+
+        int i = FastFloor(x);
+        int j = FastFloor(y);
+        float xi = (float)(x - i);
+        float yi = (float)(y - j);
+
+        float t = (xi + yi) * G2;
+        float x0 = (float)(xi - t);
+        float y0 = (float)(yi - t);
+
+        i *= PrimeX;
+        j *= PrimeY;
+
+        float n0, n1, n2;
+
+        float a = 0.5f - x0 * x0 - y0 * y0;
+        if (a <= 0) n0 = 0;
+        else
+        {
+            n0 = (a * a) * (a * a) * GradCoord(seed, i, j, x0, y0);
+        }
+
+        float c = (float)(2 * (1 - 2 * G2) * (1 / G2 - 2)) * t + ((float)(-2 * (1 - 2 * G2) * (1 - 2 * G2)) + a);
+        if (c <= 0) n2 = 0;
+        else
+        {
+            float x2 = x0 + (2 * (float)G2 - 1);
+            float y2 = y0 + (2 * (float)G2 - 1);
+            n2 = (c * c) * (c * c) * GradCoord(seed, i + PrimeX, j + PrimeY, x2, y2);
+        }
+
+        if (y0 > x0)
+        {
+            float x1 = x0 + (float)G2;
+            float y1 = y0 + ((float)G2 - 1);
+            float b = 0.5f - x1 * x1 - y1 * y1;
+            if (b <= 0) n1 = 0;
+            else
+            {
+                n1 = (b * b) * (b * b) * GradCoord(seed, i, j + PrimeY, x1, y1);
+            }
+        }
+        else
+        {
+            float x1 = x0 + ((float)G2 - 1);
+            float y1 = y0 + (float)G2;
+            float b = 0.5f - x1 * x1 - y1 * y1;
+            if (b <= 0) n1 = 0;
+            else
+            {
+                n1 = (b * b) * (b * b) * GradCoord(seed, i + PrimeX, j, x1, y1);
+            }
+        }
+
+        return (n0 + n1 + n2) * 99.83685446303647f;
+    }
+
+    private float SingleOpenSimplex2(int seed, FNLfloat x, FNLfloat y, FNLfloat z)
+    {
+        // 3D OpenSimplex2 case uses two offset rotated cube grids.
+
+        /*
+         * --- Rotation moved to TransformNoiseCoordinate method ---
+         * const FNfloat R3 = (FNfloat)(2.0 / 3.0);
+         * FNfloat r = (x + y + z) * R3; // Rotation, not skew
+         * x = r - x; y = r - y; z = r - z;
+        */
+
+        int i = FastRound(x);
+        int j = FastRound(y);
+        int k = FastRound(z);
+        float x0 = (float)(x - i);
+        float y0 = (float)(y - j);
+        float z0 = (float)(z - k);
+
+        int xNSign = (int)(-1.0f - x0) | 1;
+        int yNSign = (int)(-1.0f - y0) | 1;
+        int zNSign = (int)(-1.0f - z0) | 1;
+
+        float ax0 = xNSign * -x0;
+        float ay0 = yNSign * -y0;
+        float az0 = zNSign * -z0;
+
+        i *= PrimeX;
+        j *= PrimeY;
+        k *= PrimeZ;
+
+        float value = 0;
+        float a = (0.6f - x0 * x0) - (y0 * y0 + z0 * z0);
+
+        for (int l = 0; ; l++)
+        {
+            if (a > 0)
+            {
+                value += (a * a) * (a * a) * GradCoord(seed, i, j, k, x0, y0, z0);
+            }
+
+            if (ax0 >= ay0 && ax0 >= az0)
+            {
+                float b = a + ax0 + ax0;
+                if (b > 1) {
+                    b -= 1;
+                    value += (b * b) * (b * b) * GradCoord(seed, i - xNSign * PrimeX, j, k, x0 + xNSign, y0, z0);
+                }
+            }
+            else if (ay0 > ax0 && ay0 >= az0)
+            {
+                float b = a + ay0 + ay0;
+                if (b > 1)
+                {
+                    b -= 1;
+                    value += (b * b) * (b * b) * GradCoord(seed, i, j - yNSign * PrimeY, k, x0, y0 + yNSign, z0);
+                }
+            }
+            else
+            {
+                float b = a + az0 + az0;
+                if (b > 1)
+                {
+                    b -= 1;
+                    value += (b * b) * (b * b) * GradCoord(seed, i, j, k - zNSign * PrimeZ, x0, y0, z0 + zNSign);
+                }
+            }
+
+            if (l == 1) break;
+
+            ax0 = 0.5f - ax0;
+            ay0 = 0.5f - ay0;
+            az0 = 0.5f - az0;
+
+            x0 = xNSign * ax0;
+            y0 = yNSign * ay0;
+            z0 = zNSign * az0;
+
+            a += (0.75f - ax0) - (ay0 + az0);
+
+            i += (xNSign >> 1) & PrimeX;
+            j += (yNSign >> 1) & PrimeY;
+            k += (zNSign >> 1) & PrimeZ;
+
+            xNSign = -xNSign;
+            yNSign = -yNSign;
+            zNSign = -zNSign;
+
+            seed = ~seed;
+        }
+
+        return value * 32.69428253173828125f;
+    }
+
+
+    // OpenSimplex2S Noise
+
+    private float SingleOpenSimplex2S(int seed, FNLfloat x, FNLfloat y)
+    {
+        // 2D OpenSimplex2S case is a modified 2D simplex noise.
+
+        const FNLfloat SQRT3 = (FNLfloat)1.7320508075688772935274463415059;
+        const FNLfloat G2 = (3 - SQRT3) / 6;
+
+        /*
+         * --- Skew moved to TransformNoiseCoordinate method ---
+         * const FNfloat F2 = 0.5f * (SQRT3 - 1);
+         * FNfloat s = (x + y) * F2;
+         * x += s; y += s;
+        */
+
+        int i = FastFloor(x);
+        int j = FastFloor(y);
+        float xi = (float)(x - i);
+        float yi = (float)(y - j);
+
+        i *= PrimeX;
+        j *= PrimeY;
+        int i1 = i + PrimeX;
+        int j1 = j + PrimeY;
+
+        float t = (xi + yi) * (float)G2;
+        float x0 = xi - t;
+        float y0 = yi - t;
+
+        float a0 = (2.0f / 3.0f) - x0 * x0 - y0 * y0;
+        float value = (a0 * a0) * (a0 * a0) * GradCoord(seed, i, j, x0, y0);
+
+        float a1 = (float)(2 * (1 - 2 * G2) * (1 / G2 - 2)) * t + ((float)(-2 * (1 - 2 * G2) * (1 - 2 * G2)) + a0);
+        float x1 = x0 - (float)(1 - 2 * G2);
+        float y1 = y0 - (float)(1 - 2 * G2);
+        value += (a1 * a1) * (a1 * a1) * GradCoord(seed, i1, j1, x1, y1);
+
+        // Nested conditionals were faster than compact bit logic/arithmetic.
+        float xmyi = xi - yi;
+        if (t > G2)
+        {
+            if (xi + xmyi > 1)
+            {
+                float x2 = x0 + (float)(3 * G2 - 2);
+                float y2 = y0 + (float)(3 * G2 - 1);
+                float a2 = (2.0f / 3.0f) - x2 * x2 - y2 * y2;
+                if (a2 > 0)
+                {
+                    value += (a2 * a2) * (a2 * a2) * GradCoord(seed, i + (PrimeX << 1), j + PrimeY, x2, y2);
+                }
+            }
+            else
+            {
+                float x2 = x0 + (float)G2;
+                float y2 = y0 + (float)(G2 - 1);
+                float a2 = (2.0f / 3.0f) - x2 * x2 - y2 * y2;
+                if (a2 > 0)
+                {
+                    value += (a2 * a2) * (a2 * a2) * GradCoord(seed, i, j + PrimeY, x2, y2);
+                }
+            }
+
+            if (yi - xmyi > 1)
+            {
+                float x3 = x0 + (float)(3 * G2 - 1);
+                float y3 = y0 + (float)(3 * G2 - 2);
+                float a3 = (2.0f / 3.0f) - x3 * x3 - y3 * y3;
+                if (a3 > 0)
+                {
+                    value += (a3 * a3) * (a3 * a3) * GradCoord(seed, i + PrimeX, j + (PrimeY << 1), x3, y3);
+                }
+            }
+            else
+            {
+                float x3 = x0 + (float)(G2 - 1);
+                float y3 = y0 + (float)G2;
+                float a3 = (2.0f / 3.0f) - x3 * x3 - y3 * y3;
+                if (a3 > 0)
+                {
+                    value += (a3 * a3) * (a3 * a3) * GradCoord(seed, i + PrimeX, j, x3, y3);
+                }
+            }
+        }
+        else
+        {
+            if (xi + xmyi < 0)
+            {
+                float x2 = x0 + (float)(1 - G2);
+                float y2 = y0 - (float)G2;
+                float a2 = (2.0f / 3.0f) - x2 * x2 - y2 * y2;
+                if (a2 > 0)
+                {
+                    value += (a2 * a2) * (a2 * a2) * GradCoord(seed, i - PrimeX, j, x2, y2);
+                }
+            }
+            else
+            {
+                float x2 = x0 + (float)(G2 - 1);
+                float y2 = y0 + (float)G2;
+                float a2 = (2.0f / 3.0f) - x2 * x2 - y2 * y2;
+                if (a2 > 0)
+                {
+                    value += (a2 * a2) * (a2 * a2) * GradCoord(seed, i + PrimeX, j, x2, y2);
+                }
+            }
+
+            if (yi < xmyi)
+            {
+                float x2 = x0 - (float)G2;
+                float y2 = y0 - (float)(G2 - 1);
+                float a2 = (2.0f / 3.0f) - x2 * x2 - y2 * y2;
+                if (a2 > 0)
+                {
+                    value += (a2 * a2) * (a2 * a2) * GradCoord(seed, i, j - PrimeY, x2, y2);
+                }
+            }
+            else
+            {
+                float x2 = x0 + (float)G2;
+                float y2 = y0 + (float)(G2 - 1);
+                float a2 = (2.0f / 3.0f) - x2 * x2 - y2 * y2;
+                if (a2 > 0)
+                {
+                    value += (a2 * a2) * (a2 * a2) * GradCoord(seed, i, j + PrimeY, x2, y2);
+                }
+            }
+        }
+
+        return value * 18.24196194486065f;
+    }
+
+    private float SingleOpenSimplex2S(int seed, FNLfloat x, FNLfloat y, FNLfloat z)
+    {
+        // 3D OpenSimplex2S case uses two offset rotated cube grids.
+
+        /*
+         * --- Rotation moved to TransformNoiseCoordinate method ---
+         * const FNfloat R3 = (FNfloat)(2.0 / 3.0);
+         * FNfloat r = (x + y + z) * R3; // Rotation, not skew
+         * x = r - x; y = r - y; z = r - z;
+        */
+
+        int i = FastFloor(x);
+        int j = FastFloor(y);
+        int k = FastFloor(z);
+        float xi = (float)(x - i);
+        float yi = (float)(y - j);
+        float zi = (float)(z - k);
+
+        i *= PrimeX;
+        j *= PrimeY;
+        k *= PrimeZ;
+        int seed2 = seed + 1293373;
+
+        int xNMask = (int)(-0.5f - xi);
+        int yNMask = (int)(-0.5f - yi);
+        int zNMask = (int)(-0.5f - zi);
+
+        float x0 = xi + xNMask;
+        float y0 = yi + yNMask;
+        float z0 = zi + zNMask;
+        float a0 = 0.75f - x0 * x0 - y0 * y0 - z0 * z0;
+        float value = (a0 * a0) * (a0 * a0) * GradCoord(seed,
+            i + (xNMask & PrimeX), j + (yNMask & PrimeY), k + (zNMask & PrimeZ), x0, y0, z0);
+
+        float x1 = xi - 0.5f;
+        float y1 = yi - 0.5f;
+        float z1 = zi - 0.5f;
+        float a1 = 0.75f - x1 * x1 - y1 * y1 - z1 * z1;
+        value += (a1 * a1) * (a1 * a1) * GradCoord(seed2,
+            i + PrimeX, j + PrimeY, k + PrimeZ, x1, y1, z1);
+
+        float xAFlipMask0 = ((xNMask | 1) << 1) * x1;
+        float yAFlipMask0 = ((yNMask | 1) << 1) * y1;
+        float zAFlipMask0 = ((zNMask | 1) << 1) * z1;
+        float xAFlipMask1 = (-2 - (xNMask << 2)) * x1 - 1.0f;
+        float yAFlipMask1 = (-2 - (yNMask << 2)) * y1 - 1.0f;
+        float zAFlipMask1 = (-2 - (zNMask << 2)) * z1 - 1.0f;
+
+        bool skip5 = false;
+        float a2 = xAFlipMask0 + a0;
+        if (a2 > 0)
+        {
+            float x2 = x0 - (xNMask | 1);
+            float y2 = y0;
+            float z2 = z0;
+            value += (a2 * a2) * (a2 * a2) * GradCoord(seed,
+                i + (~xNMask & PrimeX), j + (yNMask & PrimeY), k + (zNMask & PrimeZ), x2, y2, z2);
+        }
+        else
+        {
+            float a3 = yAFlipMask0 + zAFlipMask0 + a0;
+            if (a3 > 0)
+            {
+                float x3 = x0;
+                float y3 = y0 - (yNMask | 1);
+                float z3 = z0 - (zNMask | 1);
+                value += (a3 * a3) * (a3 * a3) * GradCoord(seed,
+                    i + (xNMask & PrimeX), j + (~yNMask & PrimeY), k + (~zNMask & PrimeZ), x3, y3, z3);
+            }
+
+            float a4 = xAFlipMask1 + a1;
+            if (a4 > 0)
+            {
+                float x4 = (xNMask | 1) + x1;
+                float y4 = y1;
+                float z4 = z1;
+                value += (a4 * a4) * (a4 * a4) * GradCoord(seed2,
+                    i + (xNMask & (PrimeX * 2)), j + PrimeY, k + PrimeZ, x4, y4, z4);
+                skip5 = true;
+            }
+        }
+
+        bool skip9 = false;
+        float a6 = yAFlipMask0 + a0;
+        if (a6 > 0)
+        {
+            float x6 = x0;
+            float y6 = y0 - (yNMask | 1);
+            float z6 = z0;
+            value += (a6 * a6) * (a6 * a6) * GradCoord(seed,
+                i + (xNMask & PrimeX), j + (~yNMask & PrimeY), k + (zNMask & PrimeZ), x6, y6, z6);
+        }
+        else
+        {
+            float a7 = xAFlipMask0 + zAFlipMask0 + a0;
+            if (a7 > 0)
+            {
+                float x7 = x0 - (xNMask | 1);
+                float y7 = y0;
+                float z7 = z0 - (zNMask | 1);
+                value += (a7 * a7) * (a7 * a7) * GradCoord(seed,
+                    i + (~xNMask & PrimeX), j + (yNMask & PrimeY), k + (~zNMask & PrimeZ), x7, y7, z7);
+            }
+
+            float a8 = yAFlipMask1 + a1;
+            if (a8 > 0)
+            {
+                float x8 = x1;
+                float y8 = (yNMask | 1) + y1;
+                float z8 = z1;
+                value += (a8 * a8) * (a8 * a8) * GradCoord(seed2,
+                    i + PrimeX, j + (yNMask & (PrimeY << 1)), k + PrimeZ, x8, y8, z8);
+                skip9 = true;
+            }
+        }
+
+        bool skipD = false;
+        float aA = zAFlipMask0 + a0;
+        if (aA > 0)
+        {
+            float xA = x0;
+            float yA = y0;
+            float zA = z0 - (zNMask | 1);
+            value += (aA * aA) * (aA * aA) * GradCoord(seed,
+                i + (xNMask & PrimeX), j + (yNMask & PrimeY), k + (~zNMask & PrimeZ), xA, yA, zA);
+        }
+        else
+        {
+            float aB = xAFlipMask0 + yAFlipMask0 + a0;
+            if (aB > 0)
+            {
+                float xB = x0 - (xNMask | 1);
+                float yB = y0 - (yNMask | 1);
+                float zB = z0;
+                value += (aB * aB) * (aB * aB) * GradCoord(seed,
+                    i + (~xNMask & PrimeX), j + (~yNMask & PrimeY), k + (zNMask & PrimeZ), xB, yB, zB);
+            }
+
+            float aC = zAFlipMask1 + a1;
+            if (aC > 0)
+            {
+                float xC = x1;
+                float yC = y1;
+                float zC = (zNMask | 1) + z1;
+                value += (aC * aC) * (aC * aC) * GradCoord(seed2,
+                    i + PrimeX, j + PrimeY, k + (zNMask & (PrimeZ << 1)), xC, yC, zC);
+                skipD = true;
+            }
+        }
+
+        if (!skip5)
+        {
+            float a5 = yAFlipMask1 + zAFlipMask1 + a1;
+            if (a5 > 0)
+            {
+                float x5 = x1;
+                float y5 = (yNMask | 1) + y1;
+                float z5 = (zNMask | 1) + z1;
+                value += (a5 * a5) * (a5 * a5) * GradCoord(seed2,
+                    i + PrimeX, j + (yNMask & (PrimeY << 1)), k + (zNMask & (PrimeZ << 1)), x5, y5, z5);
+            }
+        }
+
+        if (!skip9)
+        {
+            float a9 = xAFlipMask1 + zAFlipMask1 + a1;
+            if (a9 > 0)
+            {
+                float x9 = (xNMask | 1) + x1;
+                float y9 = y1;
+                float z9 = (zNMask | 1) + z1;
+                value += (a9 * a9) * (a9 * a9) * GradCoord(seed2,
+                    i + (xNMask & (PrimeX * 2)), j + PrimeY, k + (zNMask & (PrimeZ << 1)), x9, y9, z9);
+            }
+        }
+
+        if (!skipD)
+        {
+            float aD = xAFlipMask1 + yAFlipMask1 + a1;
+            if (aD > 0)
+            {
+                float xD = (xNMask | 1) + x1;
+                float yD = (yNMask | 1) + y1;
+                float zD = z1;
+                value += (aD * aD) * (aD * aD) * GradCoord(seed2,
+                    i + (xNMask & (PrimeX << 1)), j + (yNMask & (PrimeY << 1)), k + PrimeZ, xD, yD, zD);
+            }
+        }
+
+        return value * 9.046026385208288f;
+    }
+
+
+    // Cellular Noise
+
+    private float SingleCellular(int seed, FNLfloat x, FNLfloat y)
+    {
+        int xr = FastRound(x);
+        int yr = FastRound(y);
+
+        float distance0 = float.MaxValue;
+        float distance1 = float.MaxValue;
+        int closestHash = 0;
+
+        float cellularJitter = 0.43701595f * mCellularJitterModifier;
+
+        int xPrimed = (xr - 1) * PrimeX;
+        int yPrimedBase = (yr - 1) * PrimeY;
+
+        switch (mCellularDistanceFunction)
+        {
+            default:
+            case CellularDistanceFunction.Euclidean:
+            case CellularDistanceFunction.EuclideanSq:
+                for (int xi = xr - 1; xi <= xr + 1; xi++)
+                {
+                    int yPrimed = yPrimedBase;
+
+                    for (int yi = yr - 1; yi <= yr + 1; yi++)
+                    {
+                        int hash = Hash(seed, xPrimed, yPrimed);
+                        int idx = hash & (255 << 1);
+
+                        float vecX = (float)(xi - x) + RandVecs2D[idx] * cellularJitter;
+                        float vecY = (float)(yi - y) + RandVecs2D[idx | 1] * cellularJitter;
+
+                        float newDistance = vecX * vecX + vecY * vecY;
+
+                        distance1 = FastMax(FastMin(distance1, newDistance), distance0);
+                        if (newDistance < distance0)
+                        {
+                            distance0 = newDistance;
+                            closestHash = hash;
+                        }
+                        yPrimed += PrimeY;
+                    }
+                    xPrimed += PrimeX;
+                }
+                break;
+            case CellularDistanceFunction.Manhattan:
+                for (int xi = xr - 1; xi <= xr + 1; xi++)
+                {
+                    int yPrimed = yPrimedBase;
+
+                    for (int yi = yr - 1; yi <= yr + 1; yi++)
+                    {
+                        int hash = Hash(seed, xPrimed, yPrimed);
+                        int idx = hash & (255 << 1);
+
+                        float vecX = (float)(xi - x) + RandVecs2D[idx] * cellularJitter;
+                        float vecY = (float)(yi - y) + RandVecs2D[idx | 1] * cellularJitter;
+
+                        float newDistance = FastAbs(vecX) + FastAbs(vecY);
+
+                        distance1 = FastMax(FastMin(distance1, newDistance), distance0);
+                        if (newDistance < distance0)
+                        {
+                            distance0 = newDistance;
+                            closestHash = hash;
+                        }
+                        yPrimed += PrimeY;
+                    }
+                    xPrimed += PrimeX;
+                }
+                break;
+            case CellularDistanceFunction.Hybrid:
+                for (int xi = xr - 1; xi <= xr + 1; xi++)
+                {
+                    int yPrimed = yPrimedBase;
+
+                    for (int yi = yr - 1; yi <= yr + 1; yi++)
+                    {
+                        int hash = Hash(seed, xPrimed, yPrimed);
+                        int idx = hash & (255 << 1);
+
+                        float vecX = (float)(xi - x) + RandVecs2D[idx] * cellularJitter;
+                        float vecY = (float)(yi - y) + RandVecs2D[idx | 1] * cellularJitter;
+
+                        float newDistance = (FastAbs(vecX) + FastAbs(vecY)) + (vecX * vecX + vecY * vecY);
+
+                        distance1 = FastMax(FastMin(distance1, newDistance), distance0);
+                        if (newDistance < distance0)
+                        {
+                            distance0 = newDistance;
+                            closestHash = hash;
+                        }
+                        yPrimed += PrimeY;
+                    }
+                    xPrimed += PrimeX;
+                }
+                break;
+        }
+
+        if (mCellularDistanceFunction == CellularDistanceFunction.Euclidean && mCellularReturnType >= CellularReturnType.Distance)
+        {
+            distance0 = FastSqrt(distance0);
+
+            if (mCellularReturnType >= CellularReturnType.Distance2)
+            {
+                distance1 = FastSqrt(distance1);
+            }
+        }
+
+        switch (mCellularReturnType)
+        {
+            case CellularReturnType.CellValue:
+                return closestHash * (1 / 2147483648.0f);
+            case CellularReturnType.Distance:
+                return distance0 - 1;
+            case CellularReturnType.Distance2:
+                return distance1 - 1;
+            case CellularReturnType.Distance2Add:
+                return (distance1 + distance0) * 0.5f - 1;
+            case CellularReturnType.Distance2Sub:
+                return distance1 - distance0 - 1;
+            case CellularReturnType.Distance2Mul:
+                return distance1 * distance0 * 0.5f - 1;
+            case CellularReturnType.Distance2Div:
+                return distance0 / distance1 - 1;
+            default:
+                return 0;
+        }
+    }
+
+    private float SingleCellular(int seed, FNLfloat x, FNLfloat y, FNLfloat z)
+    {
+        int xr = FastRound(x);
+        int yr = FastRound(y);
+        int zr = FastRound(z);
+
+        float distance0 = float.MaxValue;
+        float distance1 = float.MaxValue;
+        int closestHash = 0;
+
+        float cellularJitter = 0.39614353f * mCellularJitterModifier;
+
+        int xPrimed = (xr - 1) * PrimeX;
+        int yPrimedBase = (yr - 1) * PrimeY;
+        int zPrimedBase = (zr - 1) * PrimeZ;
+
+        switch (mCellularDistanceFunction)
+        {
+            case CellularDistanceFunction.Euclidean:
+            case CellularDistanceFunction.EuclideanSq:
+                for (int xi = xr - 1; xi <= xr + 1; xi++)
+                {
+                    int yPrimed = yPrimedBase;
+
+                    for (int yi = yr - 1; yi <= yr + 1; yi++)
+                    {
+                        int zPrimed = zPrimedBase;
+
+                        for (int zi = zr - 1; zi <= zr + 1; zi++)
+                        {
+                            int hash = Hash(seed, xPrimed, yPrimed, zPrimed);
+                            int idx = hash & (255 << 2);
+
+                            float vecX = (float)(xi - x) + RandVecs3D[idx] * cellularJitter;
+                            float vecY = (float)(yi - y) + RandVecs3D[idx | 1] * cellularJitter;
+                            float vecZ = (float)(zi - z) + RandVecs3D[idx | 2] * cellularJitter;
+
+                            float newDistance = vecX * vecX + vecY * vecY + vecZ * vecZ;
+
+                            distance1 = FastMax(FastMin(distance1, newDistance), distance0);
+                            if (newDistance < distance0)
+                            {
+                                distance0 = newDistance;
+                                closestHash = hash;
+                            }
+                            zPrimed += PrimeZ;
+                        }
+                        yPrimed += PrimeY;
+                    }
+                    xPrimed += PrimeX;
+                }
+                break;
+            case CellularDistanceFunction.Manhattan:
+                for (int xi = xr - 1; xi <= xr + 1; xi++)
+                {
+                    int yPrimed = yPrimedBase;
+
+                    for (int yi = yr - 1; yi <= yr + 1; yi++)
+                    {
+                        int zPrimed = zPrimedBase;
+
+                        for (int zi = zr - 1; zi <= zr + 1; zi++)
+                        {
+                            int hash = Hash(seed, xPrimed, yPrimed, zPrimed);
+                            int idx = hash & (255 << 2);
+
+                            float vecX = (float)(xi - x) + RandVecs3D[idx] * cellularJitter;
+                            float vecY = (float)(yi - y) + RandVecs3D[idx | 1] * cellularJitter;
+                            float vecZ = (float)(zi - z) + RandVecs3D[idx | 2] * cellularJitter;
+
+                            float newDistance = FastAbs(vecX) + FastAbs(vecY) + FastAbs(vecZ);
+
+                            distance1 = FastMax(FastMin(distance1, newDistance), distance0);
+                            if (newDistance < distance0)
+                            {
+                                distance0 = newDistance;
+                                closestHash = hash;
+                            }
+                            zPrimed += PrimeZ;
+                        }
+                        yPrimed += PrimeY;
+                    }
+                    xPrimed += PrimeX;
+                }
+                break;
+            case CellularDistanceFunction.Hybrid:
+                for (int xi = xr - 1; xi <= xr + 1; xi++)
+                {
+                    int yPrimed = yPrimedBase;
+
+                    for (int yi = yr - 1; yi <= yr + 1; yi++)
+                    {
+                        int zPrimed = zPrimedBase;
+
+                        for (int zi = zr - 1; zi <= zr + 1; zi++)
+                        {
+                            int hash = Hash(seed, xPrimed, yPrimed, zPrimed);
+                            int idx = hash & (255 << 2);
+
+                            float vecX = (float)(xi - x) + RandVecs3D[idx] * cellularJitter;
+                            float vecY = (float)(yi - y) + RandVecs3D[idx | 1] * cellularJitter;
+                            float vecZ = (float)(zi - z) + RandVecs3D[idx | 2] * cellularJitter;
+
+                            float newDistance = (FastAbs(vecX) + FastAbs(vecY) + FastAbs(vecZ)) + (vecX * vecX + vecY * vecY + vecZ * vecZ);
+
+                            distance1 = FastMax(FastMin(distance1, newDistance), distance0);
+                            if (newDistance < distance0)
+                            {
+                                distance0 = newDistance;
+                                closestHash = hash;
+                            }
+                            zPrimed += PrimeZ;
+                        }
+                        yPrimed += PrimeY;
+                    }
+                    xPrimed += PrimeX;
+                }
+                break;
+            default:
+                break;
+        }
+
+        if (mCellularDistanceFunction == CellularDistanceFunction.Euclidean && mCellularReturnType >= CellularReturnType.Distance)
+        {
+            distance0 = FastSqrt(distance0);
+
+            if (mCellularReturnType >= CellularReturnType.Distance2)
+            {
+                distance1 = FastSqrt(distance1);
+            }
+        }
+
+        switch (mCellularReturnType)
+        {
+            case CellularReturnType.CellValue:
+                return closestHash * (1 / 2147483648.0f);
+            case CellularReturnType.Distance:
+                return distance0 - 1;
+            case CellularReturnType.Distance2:
+                return distance1 - 1;
+            case CellularReturnType.Distance2Add:
+                return (distance1 + distance0) * 0.5f - 1;
+            case CellularReturnType.Distance2Sub:
+                return distance1 - distance0 - 1;
+            case CellularReturnType.Distance2Mul:
+                return distance1 * distance0 * 0.5f - 1;
+            case CellularReturnType.Distance2Div:
+                return distance0 / distance1 - 1;
+            default:
+                return 0;
+        }
+    }
+
+
+    // Perlin Noise
+
+    private float SinglePerlin(int seed, FNLfloat x, FNLfloat y)
+    {
+        int x0 = FastFloor(x);
+        int y0 = FastFloor(y);
+
+        float xd0 = (float)(x - x0);
+        float yd0 = (float)(y - y0);
+        float xd1 = xd0 - 1;
+        float yd1 = yd0 - 1;
+
+        float xs = InterpQuintic(xd0);
+        float ys = InterpQuintic(yd0);
+
+        x0 *= PrimeX;
+        y0 *= PrimeY;
+        int x1 = x0 + PrimeX;
+        int y1 = y0 + PrimeY;
+
+        float xf0 = Lerp(GradCoord(seed, x0, y0, xd0, yd0), GradCoord(seed, x1, y0, xd1, yd0), xs);
+        float xf1 = Lerp(GradCoord(seed, x0, y1, xd0, yd1), GradCoord(seed, x1, y1, xd1, yd1), xs);
+
+        return Lerp(xf0, xf1, ys) * 1.4247691104677813f;
+    }
+
+    private float SinglePerlin(int seed, FNLfloat x, FNLfloat y, FNLfloat z)
+    {
+        int x0 = FastFloor(x);
+        int y0 = FastFloor(y);
+        int z0 = FastFloor(z);
+
+        float xd0 = (float)(x - x0);
+        float yd0 = (float)(y - y0);
+        float zd0 = (float)(z - z0);
+        float xd1 = xd0 - 1;
+        float yd1 = yd0 - 1;
+        float zd1 = zd0 - 1;
+
+        float xs = InterpQuintic(xd0);
+        float ys = InterpQuintic(yd0);
+        float zs = InterpQuintic(zd0);
+
+        x0 *= PrimeX;
+        y0 *= PrimeY;
+        z0 *= PrimeZ;
+        int x1 = x0 + PrimeX;
+        int y1 = y0 + PrimeY;
+        int z1 = z0 + PrimeZ;
+
+        float xf00 = Lerp(GradCoord(seed, x0, y0, z0, xd0, yd0, zd0), GradCoord(seed, x1, y0, z0, xd1, yd0, zd0), xs);
+        float xf10 = Lerp(GradCoord(seed, x0, y1, z0, xd0, yd1, zd0), GradCoord(seed, x1, y1, z0, xd1, yd1, zd0), xs);
+        float xf01 = Lerp(GradCoord(seed, x0, y0, z1, xd0, yd0, zd1), GradCoord(seed, x1, y0, z1, xd1, yd0, zd1), xs);
+        float xf11 = Lerp(GradCoord(seed, x0, y1, z1, xd0, yd1, zd1), GradCoord(seed, x1, y1, z1, xd1, yd1, zd1), xs);
+
+        float yf0 = Lerp(xf00, xf10, ys);
+        float yf1 = Lerp(xf01, xf11, ys);
+
+        return Lerp(yf0, yf1, zs) * 0.964921414852142333984375f;
+    }
+
+
+    // Value Cubic Noise
+
+    private float SingleValueCubic(int seed, FNLfloat x, FNLfloat y)
+    {
+        int x1 = FastFloor(x);
+        int y1 = FastFloor(y);
+
+        float xs = (float)(x - x1);
+        float ys = (float)(y - y1);
+
+        x1 *= PrimeX;
+        y1 *= PrimeY;
+        int x0 = x1 - PrimeX;
+        int y0 = y1 - PrimeY;
+        int x2 = x1 + PrimeX;
+        int y2 = y1 + PrimeY;
+        int x3 = x1 + unchecked(PrimeX * 2);
+        int y3 = y1 + unchecked(PrimeY * 2);
+
+        return CubicLerp(
+            CubicLerp(ValCoord(seed, x0, y0), ValCoord(seed, x1, y0), ValCoord(seed, x2, y0), ValCoord(seed, x3, y0),
+            xs),
+            CubicLerp(ValCoord(seed, x0, y1), ValCoord(seed, x1, y1), ValCoord(seed, x2, y1), ValCoord(seed, x3, y1),
+            xs),
+            CubicLerp(ValCoord(seed, x0, y2), ValCoord(seed, x1, y2), ValCoord(seed, x2, y2), ValCoord(seed, x3, y2),
+            xs),
+            CubicLerp(ValCoord(seed, x0, y3), ValCoord(seed, x1, y3), ValCoord(seed, x2, y3), ValCoord(seed, x3, y3),
+            xs),
+            ys) * (1 / (1.5f * 1.5f));
+    }
+
+    private float SingleValueCubic(int seed, FNLfloat x, FNLfloat y, FNLfloat z)
+    {
+        int x1 = FastFloor(x);
+        int y1 = FastFloor(y);
+        int z1 = FastFloor(z);
+
+        float xs = (float)(x - x1);
+        float ys = (float)(y - y1);
+        float zs = (float)(z - z1);
+
+        x1 *= PrimeX;
+        y1 *= PrimeY;
+        z1 *= PrimeZ;
+
+        int x0 = x1 - PrimeX;
+        int y0 = y1 - PrimeY;
+        int z0 = z1 - PrimeZ;
+        int x2 = x1 + PrimeX;
+        int y2 = y1 + PrimeY;
+        int z2 = z1 + PrimeZ;
+        int x3 = x1 + unchecked(PrimeX * 2);
+        int y3 = y1 + unchecked(PrimeY * 2);
+        int z3 = z1 + unchecked(PrimeZ * 2);
+
+
+        return CubicLerp(
+            CubicLerp(
+            CubicLerp(ValCoord(seed, x0, y0, z0), ValCoord(seed, x1, y0, z0), ValCoord(seed, x2, y0, z0), ValCoord(seed, x3, y0, z0), xs),
+            CubicLerp(ValCoord(seed, x0, y1, z0), ValCoord(seed, x1, y1, z0), ValCoord(seed, x2, y1, z0), ValCoord(seed, x3, y1, z0), xs),
+            CubicLerp(ValCoord(seed, x0, y2, z0), ValCoord(seed, x1, y2, z0), ValCoord(seed, x2, y2, z0), ValCoord(seed, x3, y2, z0), xs),
+            CubicLerp(ValCoord(seed, x0, y3, z0), ValCoord(seed, x1, y3, z0), ValCoord(seed, x2, y3, z0), ValCoord(seed, x3, y3, z0), xs),
+            ys),
+            CubicLerp(
+            CubicLerp(ValCoord(seed, x0, y0, z1), ValCoord(seed, x1, y0, z1), ValCoord(seed, x2, y0, z1), ValCoord(seed, x3, y0, z1), xs),
+            CubicLerp(ValCoord(seed, x0, y1, z1), ValCoord(seed, x1, y1, z1), ValCoord(seed, x2, y1, z1), ValCoord(seed, x3, y1, z1), xs),
+            CubicLerp(ValCoord(seed, x0, y2, z1), ValCoord(seed, x1, y2, z1), ValCoord(seed, x2, y2, z1), ValCoord(seed, x3, y2, z1), xs),
+            CubicLerp(ValCoord(seed, x0, y3, z1), ValCoord(seed, x1, y3, z1), ValCoord(seed, x2, y3, z1), ValCoord(seed, x3, y3, z1), xs),
+            ys),
+            CubicLerp(
+            CubicLerp(ValCoord(seed, x0, y0, z2), ValCoord(seed, x1, y0, z2), ValCoord(seed, x2, y0, z2), ValCoord(seed, x3, y0, z2), xs),
+            CubicLerp(ValCoord(seed, x0, y1, z2), ValCoord(seed, x1, y1, z2), ValCoord(seed, x2, y1, z2), ValCoord(seed, x3, y1, z2), xs),
+            CubicLerp(ValCoord(seed, x0, y2, z2), ValCoord(seed, x1, y2, z2), ValCoord(seed, x2, y2, z2), ValCoord(seed, x3, y2, z2), xs),
+            CubicLerp(ValCoord(seed, x0, y3, z2), ValCoord(seed, x1, y3, z2), ValCoord(seed, x2, y3, z2), ValCoord(seed, x3, y3, z2), xs),
+            ys),
+            CubicLerp(
+            CubicLerp(ValCoord(seed, x0, y0, z3), ValCoord(seed, x1, y0, z3), ValCoord(seed, x2, y0, z3), ValCoord(seed, x3, y0, z3), xs),
+            CubicLerp(ValCoord(seed, x0, y1, z3), ValCoord(seed, x1, y1, z3), ValCoord(seed, x2, y1, z3), ValCoord(seed, x3, y1, z3), xs),
+            CubicLerp(ValCoord(seed, x0, y2, z3), ValCoord(seed, x1, y2, z3), ValCoord(seed, x2, y2, z3), ValCoord(seed, x3, y2, z3), xs),
+            CubicLerp(ValCoord(seed, x0, y3, z3), ValCoord(seed, x1, y3, z3), ValCoord(seed, x2, y3, z3), ValCoord(seed, x3, y3, z3), xs),
+            ys),
+            zs) * (1 / (1.5f * 1.5f * 1.5f));
+    }
+
+
+    // Value Noise
+
+    private float SingleValue(int seed, FNLfloat x, FNLfloat y)
+    {
+        int x0 = FastFloor(x);
+        int y0 = FastFloor(y);
+
+        float xs = InterpHermite((float)(x - x0));
+        float ys = InterpHermite((float)(y - y0));
+
+        x0 *= PrimeX;
+        y0 *= PrimeY;
+        int x1 = x0 + PrimeX;
+        int y1 = y0 + PrimeY;
+
+        float xf0 = Lerp(ValCoord(seed, x0, y0), ValCoord(seed, x1, y0), xs);
+        float xf1 = Lerp(ValCoord(seed, x0, y1), ValCoord(seed, x1, y1), xs);
+
+        return Lerp(xf0, xf1, ys);
+    }
+
+    private float SingleValue(int seed, FNLfloat x, FNLfloat y, FNLfloat z)
+    {
+        int x0 = FastFloor(x);
+        int y0 = FastFloor(y);
+        int z0 = FastFloor(z);
+
+        float xs = InterpHermite((float)(x - x0));
+        float ys = InterpHermite((float)(y - y0));
+        float zs = InterpHermite((float)(z - z0));
+
+        x0 *= PrimeX;
+        y0 *= PrimeY;
+        z0 *= PrimeZ;
+        int x1 = x0 + PrimeX;
+        int y1 = y0 + PrimeY;
+        int z1 = z0 + PrimeZ;
+
+        float xf00 = Lerp(ValCoord(seed, x0, y0, z0), ValCoord(seed, x1, y0, z0), xs);
+        float xf10 = Lerp(ValCoord(seed, x0, y1, z0), ValCoord(seed, x1, y1, z0), xs);
+        float xf01 = Lerp(ValCoord(seed, x0, y0, z1), ValCoord(seed, x1, y0, z1), xs);
+        float xf11 = Lerp(ValCoord(seed, x0, y1, z1), ValCoord(seed, x1, y1, z1), xs);
+
+        float yf0 = Lerp(xf00, xf10, ys);
+        float yf1 = Lerp(xf01, xf11, ys);
+
+        return Lerp(yf0, yf1, zs);
+    }
+
+
+    // Domain Warp
+
+    private void DoSingleDomainWarp(int seed, float amp, float freq, FNLfloat x, FNLfloat y, ref FNLfloat xr, ref FNLfloat yr)
+    {
+        switch (mDomainWarpType)
+        {
+            case DomainWarpType.OpenSimplex2:
+                SingleDomainWarpSimplexGradient(seed, amp * 38.283687591552734375f, freq, x, y, ref xr, ref yr, false);
+                break;
+            case DomainWarpType.OpenSimplex2Reduced:
+                SingleDomainWarpSimplexGradient(seed, amp * 16.0f, freq, x, y, ref xr, ref yr, true);
+                break;
+            case DomainWarpType.BasicGrid:
+                SingleDomainWarpBasicGrid(seed, amp, freq, x, y, ref xr, ref yr);
+                break;
+        }
+    }
+
+    private void DoSingleDomainWarp(int seed, float amp, float freq, FNLfloat x, FNLfloat y, FNLfloat z, ref FNLfloat xr, ref FNLfloat yr, ref FNLfloat zr)
+    {
+        switch (mDomainWarpType)
+        {
+            case DomainWarpType.OpenSimplex2:
+                SingleDomainWarpOpenSimplex2Gradient(seed, amp * 32.69428253173828125f, freq, x, y, z, ref xr, ref yr, ref zr, false);
+                break;
+            case DomainWarpType.OpenSimplex2Reduced:
+                SingleDomainWarpOpenSimplex2Gradient(seed, amp * 7.71604938271605f, freq, x, y, z, ref xr, ref yr, ref zr, true);
+                break;
+            case DomainWarpType.BasicGrid:
+                SingleDomainWarpBasicGrid(seed, amp, freq, x, y, z, ref xr, ref yr, ref zr);
+                break;
+        }
+    }
+
+
+    // Domain Warp Single Wrapper
+
+    private void DomainWarpSingle(ref FNLfloat x, ref FNLfloat y)
+    {
+        int seed = mSeed;
+        float amp = mDomainWarpAmp * mFractalBounding;
+        float freq = mFrequency;
+
+        FNLfloat xs = x;
+        FNLfloat ys = y;
+        TransformDomainWarpCoordinate(ref xs, ref ys);
+
+        DoSingleDomainWarp(seed, amp, freq, xs, ys, ref x, ref y);
+    }
+
+    private void DomainWarpSingle(ref FNLfloat x, ref FNLfloat y, ref FNLfloat z)
+    {
+        int seed = mSeed;
+        float amp = mDomainWarpAmp * mFractalBounding;
+        float freq = mFrequency;
+
+        FNLfloat xs = x;
+        FNLfloat ys = y;
+        FNLfloat zs = z;
+        TransformDomainWarpCoordinate(ref xs, ref ys, ref zs);
+
+        DoSingleDomainWarp(seed, amp, freq, xs, ys, zs, ref x, ref y, ref z);
+    }
+
+
+    // Domain Warp Fractal Progressive
+
+    private void DomainWarpFractalProgressive(ref FNLfloat x, ref FNLfloat y)
+    {
+        int seed = mSeed;
+        float amp = mDomainWarpAmp * mFractalBounding;
+        float freq = mFrequency;
+
+        for (int i = 0; i < mOctaves; i++)
+        {
+            FNLfloat xs = x;
+            FNLfloat ys = y;
+            TransformDomainWarpCoordinate(ref xs, ref ys);
+
+            DoSingleDomainWarp(seed, amp, freq, xs, ys, ref x, ref y);
+
+            seed++;
+            amp *= mGain;
+            freq *= mLacunarity;
+        }
+    }
+
+    private void DomainWarpFractalProgressive(ref FNLfloat x, ref FNLfloat y, ref FNLfloat z)
+    {
+        int seed = mSeed;
+        float amp = mDomainWarpAmp * mFractalBounding;
+        float freq = mFrequency;
+
+        for (int i = 0; i < mOctaves; i++)
+        {
+            FNLfloat xs = x;
+            FNLfloat ys = y;
+            FNLfloat zs = z;
+            TransformDomainWarpCoordinate(ref xs, ref ys, ref zs);
+
+            DoSingleDomainWarp(seed, amp, freq, xs, ys, zs, ref x, ref y, ref z);
+
+            seed++;
+            amp *= mGain;
+            freq *= mLacunarity;
+        }
+    }
+
+
+    // Domain Warp Fractal Independant
+    private void DomainWarpFractalIndependent(ref FNLfloat x, ref FNLfloat y)
+    {
+        FNLfloat xs = x;
+        FNLfloat ys = y;
+        TransformDomainWarpCoordinate(ref xs, ref ys);
+
+        int seed = mSeed;
+        float amp = mDomainWarpAmp * mFractalBounding;
+        float freq = mFrequency;
+
+        for (int i = 0; i < mOctaves; i++)
+        {
+            DoSingleDomainWarp(seed, amp, freq, xs, ys, ref x, ref y);
+
+            seed++;
+            amp *= mGain;
+            freq *= mLacunarity;
+        }
+    }
+
+    private void DomainWarpFractalIndependent(ref FNLfloat x, ref FNLfloat y, ref FNLfloat z)
+    {
+        FNLfloat xs = x;
+        FNLfloat ys = y;
+        FNLfloat zs = z;
+        TransformDomainWarpCoordinate(ref xs, ref ys, ref zs);
+
+        int seed = mSeed;
+        float amp = mDomainWarpAmp * mFractalBounding;
+        float freq = mFrequency;
+
+        for (int i = 0; i < mOctaves; i++)
+        {
+            DoSingleDomainWarp(seed, amp, freq, xs, ys, zs, ref x, ref y, ref z);
+
+            seed++;
+            amp *= mGain;
+            freq *= mLacunarity;
+        }
+    }
+
+
+    // Domain Warp Basic Grid
+
+    private void SingleDomainWarpBasicGrid(int seed, float warpAmp, float frequency, FNLfloat x, FNLfloat y, ref FNLfloat xr, ref FNLfloat yr)
+    {
+        FNLfloat xf = x * frequency;
+        FNLfloat yf = y * frequency;
+
+        int x0 = FastFloor(xf);
+        int y0 = FastFloor(yf);
+
+        float xs = InterpHermite((float)(xf - x0));
+        float ys = InterpHermite((float)(yf - y0));
+
+        x0 *= PrimeX;
+        y0 *= PrimeY;
+        int x1 = x0 + PrimeX;
+        int y1 = y0 + PrimeY;
+
+        int hash0 = Hash(seed, x0, y0) & (255 << 1);
+        int hash1 = Hash(seed, x1, y0) & (255 << 1);
+
+        float lx0x = Lerp(RandVecs2D[hash0], RandVecs2D[hash1], xs);
+        float ly0x = Lerp(RandVecs2D[hash0 | 1], RandVecs2D[hash1 | 1], xs);
+
+        hash0 = Hash(seed, x0, y1) & (255 << 1);
+        hash1 = Hash(seed, x1, y1) & (255 << 1);
+
+        float lx1x = Lerp(RandVecs2D[hash0], RandVecs2D[hash1], xs);
+        float ly1x = Lerp(RandVecs2D[hash0 | 1], RandVecs2D[hash1 | 1], xs);
+
+        xr += Lerp(lx0x, lx1x, ys) * warpAmp;
+        yr += Lerp(ly0x, ly1x, ys) * warpAmp;
+    }
+
+    private void SingleDomainWarpBasicGrid(int seed, float warpAmp, float frequency, FNLfloat x, FNLfloat y, FNLfloat z, ref FNLfloat xr, ref FNLfloat yr, ref FNLfloat zr)
+    {
+        FNLfloat xf = x * frequency;
+        FNLfloat yf = y * frequency;
+        FNLfloat zf = z * frequency;
+
+        int x0 = FastFloor(xf);
+        int y0 = FastFloor(yf);
+        int z0 = FastFloor(zf);
+
+        float xs = InterpHermite((float)(xf - x0));
+        float ys = InterpHermite((float)(yf - y0));
+        float zs = InterpHermite((float)(zf - z0));
+
+        x0 *= PrimeX;
+        y0 *= PrimeY;
+        z0 *= PrimeZ;
+        int x1 = x0 + PrimeX;
+        int y1 = y0 + PrimeY;
+        int z1 = z0 + PrimeZ;
+
+        int hash0 = Hash(seed, x0, y0, z0) & (255 << 2);
+        int hash1 = Hash(seed, x1, y0, z0) & (255 << 2);
+
+        float lx0x = Lerp(RandVecs3D[hash0], RandVecs3D[hash1], xs);
+        float ly0x = Lerp(RandVecs3D[hash0 | 1], RandVecs3D[hash1 | 1], xs);
+        float lz0x = Lerp(RandVecs3D[hash0 | 2], RandVecs3D[hash1 | 2], xs);
+
+        hash0 = Hash(seed, x0, y1, z0) & (255 << 2);
+        hash1 = Hash(seed, x1, y1, z0) & (255 << 2);
+
+        float lx1x = Lerp(RandVecs3D[hash0], RandVecs3D[hash1], xs);
+        float ly1x = Lerp(RandVecs3D[hash0 | 1], RandVecs3D[hash1 | 1], xs);
+        float lz1x = Lerp(RandVecs3D[hash0 | 2], RandVecs3D[hash1 | 2], xs);
+
+        float lx0y = Lerp(lx0x, lx1x, ys);
+        float ly0y = Lerp(ly0x, ly1x, ys);
+        float lz0y = Lerp(lz0x, lz1x, ys);
+
+        hash0 = Hash(seed, x0, y0, z1) & (255 << 2);
+        hash1 = Hash(seed, x1, y0, z1) & (255 << 2);
+
+        lx0x = Lerp(RandVecs3D[hash0], RandVecs3D[hash1], xs);
+        ly0x = Lerp(RandVecs3D[hash0 | 1], RandVecs3D[hash1 | 1], xs);
+        lz0x = Lerp(RandVecs3D[hash0 | 2], RandVecs3D[hash1 | 2], xs);
+
+        hash0 = Hash(seed, x0, y1, z1) & (255 << 2);
+        hash1 = Hash(seed, x1, y1, z1) & (255 << 2);
+
+        lx1x = Lerp(RandVecs3D[hash0], RandVecs3D[hash1], xs);
+        ly1x = Lerp(RandVecs3D[hash0 | 1], RandVecs3D[hash1 | 1], xs);
+        lz1x = Lerp(RandVecs3D[hash0 | 2], RandVecs3D[hash1 | 2], xs);
+
+        xr += Lerp(lx0y, Lerp(lx0x, lx1x, ys), zs) * warpAmp;
+        yr += Lerp(ly0y, Lerp(ly0x, ly1x, ys), zs) * warpAmp;
+        zr += Lerp(lz0y, Lerp(lz0x, lz1x, ys), zs) * warpAmp;
+    }
+
+
+    // Domain Warp Simplex/OpenSimplex2
+    private void SingleDomainWarpSimplexGradient(int seed, float warpAmp, float frequency, FNLfloat x, FNLfloat y, ref FNLfloat xr, ref FNLfloat yr, bool outGradOnly)
+    {
+        const float SQRT3 = 1.7320508075688772935274463415059f;
+        const float G2 = (3 - SQRT3) / 6;
+
+        x *= frequency;
+        y *= frequency;
+
+        /*
+         * --- Skew moved to TransformNoiseCoordinate method ---
+         * const FNfloat F2 = 0.5f * (SQRT3 - 1);
+         * FNfloat s = (x + y) * F2;
+         * x += s; y += s;
+        */
+
+        int i = FastFloor(x);
+        int j = FastFloor(y);
+        float xi = (float)(x - i);
+        float yi = (float)(y - j);
+
+        float t = (xi + yi) * G2;
+        float x0 = (float)(xi - t);
+        float y0 = (float)(yi - t);
+
+        i *= PrimeX;
+        j *= PrimeY;
+
+        float vx, vy;
+        vx = vy = 0;
+
+        float a = 0.5f - x0 * x0 - y0 * y0;
+        if (a > 0)
+        {
+            float aaaa = (a * a) * (a * a);
+            float xo, yo;
+            if (outGradOnly)
+                GradCoordOut(seed, i, j, out xo, out yo);
+            else
+                GradCoordDual(seed, i, j, x0, y0, out xo, out yo);
+            vx += aaaa * xo;
+            vy += aaaa * yo;
+        }
+
+        float c = (float)(2 * (1 - 2 * G2) * (1 / G2 - 2)) * t + ((float)(-2 * (1 - 2 * G2) * (1 - 2 * G2)) + a);
+        if (c > 0)
+        {
+            float x2 = x0 + (2 * (float)G2 - 1);
+            float y2 = y0 + (2 * (float)G2 - 1);
+            float cccc = (c * c) * (c * c);
+            float xo, yo;
+            if (outGradOnly)
+                GradCoordOut(seed, i + PrimeX, j + PrimeY, out xo, out yo);
+            else
+                GradCoordDual(seed, i + PrimeX, j + PrimeY, x2, y2, out xo, out yo);
+            vx += cccc * xo;
+            vy += cccc * yo;
+        }
+
+        if (y0 > x0)
+        {
+            float x1 = x0 + (float)G2;
+            float y1 = y0 + ((float)G2 - 1);
+            float b = 0.5f - x1 * x1 - y1 * y1;
+            if (b > 0)
+            {
+                float bbbb = (b * b) * (b * b);
+                float xo, yo;
+                if (outGradOnly)
+                    GradCoordOut(seed, i, j + PrimeY, out xo, out yo);
+                else
+                    GradCoordDual(seed, i, j + PrimeY, x1, y1, out xo, out yo);
+                vx += bbbb * xo;
+                vy += bbbb * yo;
+            }
+        }
+        else
+        {
+            float x1 = x0 + ((float)G2 - 1);
+            float y1 = y0 + (float)G2;
+            float b = 0.5f - x1 * x1 - y1 * y1;
+            if (b > 0)
+            {
+                float bbbb = (b * b) * (b * b);
+                float xo, yo;
+                if (outGradOnly)
+                    GradCoordOut(seed, i + PrimeX, j, out xo, out yo);
+                else
+                    GradCoordDual(seed, i + PrimeX, j, x1, y1, out xo, out yo);
+                vx += bbbb * xo;
+                vy += bbbb * yo;
+            }
+        }
+
+        xr += vx * warpAmp;
+        yr += vy * warpAmp;
+    }
+
+    private void SingleDomainWarpOpenSimplex2Gradient(int seed, float warpAmp, float frequency, FNLfloat x, FNLfloat y, FNLfloat z, ref FNLfloat xr, ref FNLfloat yr, ref FNLfloat zr, bool outGradOnly)
+    {
+        x *= frequency;
+        y *= frequency;
+        z *= frequency;
+
+        /*
+         * --- Rotation moved to TransformDomainWarpCoordinate method ---
+         * const FNfloat R3 = (FNfloat)(2.0 / 3.0);
+         * FNfloat r = (x + y + z) * R3; // Rotation, not skew
+         * x = r - x; y = r - y; z = r - z;
+        */
+
+        int i = FastRound(x);
+        int j = FastRound(y);
+        int k = FastRound(z);
+        float x0 = (float)x - i;
+        float y0 = (float)y - j;
+        float z0 = (float)z - k;
+
+        int xNSign = (int)(-x0 - 1.0f) | 1;
+        int yNSign = (int)(-y0 - 1.0f) | 1;
+        int zNSign = (int)(-z0 - 1.0f) | 1;
+
+        float ax0 = xNSign * -x0;
+        float ay0 = yNSign * -y0;
+        float az0 = zNSign * -z0;
+
+        i *= PrimeX;
+        j *= PrimeY;
+        k *= PrimeZ;
+
+        float vx, vy, vz;
+        vx = vy = vz = 0;
+
+        float a = (0.6f - x0 * x0) - (y0 * y0 + z0 * z0);
+        for (int l = 0; ; l++)
+        {
+            if (a > 0)
+            {
+                float aaaa = (a * a) * (a * a);
+                float xo, yo, zo;
+                if (outGradOnly)
+                    GradCoordOut(seed, i, j, k, out xo, out yo, out zo);
+                else
+                    GradCoordDual(seed, i, j, k, x0, y0, z0, out xo, out yo, out zo);
+                vx += aaaa * xo;
+                vy += aaaa * yo;
+                vz += aaaa * zo;
+            }
+
+            float b = a;
+            int i1 = i;
+            int j1 = j;
+            int k1 = k;
+            float x1 = x0;
+            float y1 = y0;
+            float z1 = z0;
+
+            if (ax0 >= ay0 && ax0 >= az0)
+            {
+                x1 += xNSign;
+                b = b + ax0 + ax0;
+                i1 -= xNSign * PrimeX;
+            }
+            else if (ay0 > ax0 && ay0 >= az0)
+            {
+                y1 += yNSign;
+                b = b + ay0 + ay0;
+                j1 -= yNSign * PrimeY;
+            }
+            else
+            {
+                z1 += zNSign;
+                b = b + az0 + az0;
+                k1 -= zNSign * PrimeZ;
+            }
+
+            if (b > 1)
+            {
+                b -= 1;
+                float bbbb = (b * b) * (b * b);
+                float xo, yo, zo;
+                if (outGradOnly)
+                    GradCoordOut(seed, i1, j1, k1, out xo, out yo, out zo);
+                else
+                    GradCoordDual(seed, i1, j1, k1, x1, y1, z1, out xo, out yo, out zo);
+                vx += bbbb * xo;
+                vy += bbbb * yo;
+                vz += bbbb * zo;
+            }
+
+            if (l == 1) break;
+
+            ax0 = 0.5f - ax0;
+            ay0 = 0.5f - ay0;
+            az0 = 0.5f - az0;
+
+            x0 = xNSign * ax0;
+            y0 = yNSign * ay0;
+            z0 = zNSign * az0;
+
+            a += (0.75f - ax0) - (ay0 + az0);
+
+            i += (xNSign >> 1) & PrimeX;
+            j += (yNSign >> 1) & PrimeY;
+            k += (zNSign >> 1) & PrimeZ;
+
+            xNSign = -xNSign;
+            yNSign = -yNSign;
+            zNSign = -zNSign;
+
+            seed += 1293373;
+        }
+
+        xr += vx * warpAmp;
+        yr += vy * warpAmp;
+        zr += vz * warpAmp;
+    }
+}

Electropunk/Misc/DateHelper.cs

···
+namespace Electropunk.Misc;
+
+public static class DateHelper
+{
+	public static bool IsDate(Month month, int day)
+	{
+		return DateTime.Now.Month == (int)month && DateTime.Now.Day == day;
+	}
+}
+
+public enum Month
+{
+	Jan = 1,
+	Feb = 2,
+	Mar = 3,
+	Apr = 4,
+	May = 5,
+	Jun = 6,
+	Jul = 7,
+	Aug = 8,
+	Sep = 9,
+	Oct = 10,
+	Nov = 11,
+	Dec = 12,
+}

Electropunk/Misc/Ref.cs

···
+namespace Electropunk.Misc;
+
+public class Ref<T>(Func<T> getter, Action<T> setter)
+{
+	private readonly Func<T> _getter = getter;
+	private readonly Action<T> _setter = setter;
+
+	public T Value
+	{
+		get => _getter();
+		set => _setter(value);
+	}
+}

Electropunk/Program.cs

···
+using System.Numerics;
+using Electropunk.Containers;
+using Electropunk.Content.Biomes;
+using Electropunk.Content.Entities;
+using Electropunk.Content.Generators;
+using Electropunk.Content.Items;
+using Electropunk.Content.Tiles;
+using Electropunk.Content.UI;
+using Electropunk.Input;
+using Electropunk.Misc;
+using Electropunk.UI;
+using Electropunk.World;
+using Electropunk.World.Crafting;
+using Raylib_cs;
+
+namespace Electropunk;
+
+public static class Program
+{
+	public static View View { get; set; } = new();
+
+	public static float DeltaTime
+	{
+		get => Raylib.GetFrameTime() * 1000;
+		private set { }
+	}
+
+	public static Level? Level { get; set; }
+	public static EntityPlayer? Player { get; set; }
+	public static ItemInstance MouseItem { get; set; } = new(GameItems.Air);
+
+	public static UINode? Menu { get; set; }
+	public static UINode RootUI { get; private set; } = new(0, 0);
+
+	public static Random Rand { get; set; } = new();
+
+	public static bool UseBorderlessFullscreen { get; set; } = true;
+
+	private static Texture2D Cursor;
+	private static float CursorRotation = 0;
+
+
+	public static void Main()
+	{
+		Raylib.SetTargetFPS(60);
+		Raylib.InitWindow(800, 600, "Electropunk");
+		Raylib.HideCursor();
+		// Raylib.SetExitKey(KeyboardKey.Null);
+
+		Cursor = Raylib.LoadTexture("Assets/UI/cursor.png");
+
+		GameBiomes.NoOp();
+		GameTiles.NoOp();
+
+		RecipeTileSmashing.Load("Data/Crafting/tile_smashing.kdl");
+		RecipeItemSmashing.Load("Data/Crafting/item_smashing.kdl");
+
+		RootUI.AddChild(p => new UISelection(p));
+		RootUI.AddChild(p => new UIFps(0, 0, p));
+		/* November 5 - Jim's Birthday */
+		if (new Random().Next(1_000_000) == 1 || DateHelper.IsDate(Month.Nov, 5))
+			RootUI.AddChild(p => new UIJim(p));
+
+		int size = 1_000;
+		Level = new(size, size);
+		Level.Generate(new BasicLevelGenerator());
+		Vector2 centre = new(size / 2 * View.TileSize, size / 2 * View.TileSize);
+		Player = new EntityPlayer() { Pos = centre };
+		View.Camera.Target = centre;
+		View.Camera.Zoom = 1.5f;
+		Level.AddEntity(Player);
+
+		RootUI.AddChild(p => new UIInvPreview(Player.Inv, p));
+
+		while (!Raylib.WindowShouldClose())
+		{
+			if (Bindings.ToggleFullscreen.IsPressed())
+			{
+				if (UseBorderlessFullscreen)
+					Raylib.ToggleBorderlessWindowed();
+				else
+					Raylib.ToggleFullscreen();
+			}
+			else if (Bindings.ZoomOut.IsPressed() && View.GoalZoom > 1.00f)
+				View.GoalZoom -= 0.25f;
+			else if (Bindings.ZoomIn.IsPressed() && View.GoalZoom < 3.00f)
+				View.GoalZoom += 0.25f;
+			else if (Bindings.ResetZoom.IsPressed())
+				View.GoalZoom = 2f;
+			else if (Raylib.IsKeyPressed(KeyboardKey.Eight))
+				View.GoalZoom = 0.1f;
+			else if (Bindings.OpenInventory.IsPressed())
+			{
+				if (Menu == null)
+					Menu = new MenuInventory(Player.Inv);
+				else
+					Menu = null;
+			}
+
+			Level.Update();
+			RootUI.Update();
+			Menu?.Update();
+
+			Raylib.BeginDrawing();
+			{
+				Level.Render(View);
+
+				RootUI.Render();
+				Menu?.Render();
+
+				RootUI.RenderHoverBox();
+				Menu?.RenderHoverBox();
+
+				Vector2 delta = Raylib.GetMouseDelta();
+				if ((delta.X > 0 || delta.Y > 0) && CursorRotation < 30)
+					CursorRotation += 2;
+				else if ((delta.X < 0 || delta.Y < 0) && CursorRotation > -30)
+					CursorRotation -= 2;
+				CursorRotation = Raymath.LerpAngle(CursorRotation, 0, 0.2f);
+				Raylib.DrawTextureEx(Cursor, Raylib.GetMousePosition(), CursorRotation, 2f, Color.White);
+
+				if (!MouseItem.IsEmpty())
+					MouseItem.Item.Render(Level, View, new(Raylib.GetMouseX(), Raylib.GetMouseY(), 32, 32));
+			}
+			Raylib.EndDrawing();
+
+			View.Update();
+		}
+	}
+}

Electropunk/UI/UIFps.cs

···
+using Raylib_cs;
+
+namespace Electropunk.UI;
+
+public class UIFps(int x, int y, UINode parent) : UINode(x, y, parent)
+{
+	public override void Render()
+	{
+		Raylib.DrawFPS(RelativeX, RelativeY);
+		Raylib.DrawText($"Entities: {Program.Level!.GetEntities().Count}", RelativeX, RelativeY + 20, 20, Color.White);
+		base.Render();
+	}
+}

Electropunk/UI/UIInvPreview.cs

···
+using Electropunk.Content.Entities;
+using Raylib_cs;
+
+namespace Electropunk.UI;
+
+public class UIInvPreview : UINode
+{
+	public static readonly int Scale = 2;
+
+	public UIInvPreview(EntityPlayer.PlayerInventory inv, UINode? parent = null) : base(0, 0, parent)
+	{
+		int padding = 4;
+
+		Width = (32 + padding * 2) * Scale;
+		Height = (16 + padding * 2) * Scale;
+
+		AddChild(new UIItemSlot(inv.GetSlot(2)!, padding * Scale, padding * Scale, this) { Width = 16 * Scale, Height = 16 * Scale });
+		AddChild(new UIItemSlot(inv.GetSlot(3)!, (padding + 16) * Scale, padding * Scale, this) { Width = 16 * Scale, Height = 16 * Scale });
+
+		Reposition();
+	}
+
+	public override void Render()
+	{
+		Raylib.DrawRectangleRec(GetRectangle(), Color.DarkBlue);
+		Raylib.DrawRectangleLinesEx(GetRectangle(), 2f, Color.Blue);
+
+		base.Render();
+	}
+
+	public override void Reposition()
+	{
+		LocalX = Raylib.GetScreenWidth() / 2 - Width / 2;
+		LocalY = Raylib.GetScreenHeight() - Height - 8;
+	}
+}

Electropunk/UI/UIItemSlot.cs

···
+using Electropunk.Containers;
+using Electropunk.I18n;
+using Raylib_cs;
+
+namespace Electropunk.UI;
+
+public class UIItemSlot : UINode
+{
+	public Slot Item;
+	public bool RenderSlot = true;
+
+	public UIItemSlot(Slot item, int x, int y, UINode? parent = null) : base(x, y, parent)
+	{
+		Item = item;
+		Width = 16;
+		Height = 16;
+	}
+
+	public override void Update()
+	{
+		if (IsClicked() && (Program.MouseItem.IsSomething() || Item.IsSomething()))
+		{
+			if (Program.MouseItem.IsSomething() && Item.IsSomething())
+			{
+				(Program.MouseItem, Item.Value) = (Item.Value, Program.MouseItem);
+			}
+			if (Program.MouseItem.IsEmpty())
+			{
+				Program.MouseItem = Item.Copy();
+				Item.Clear();
+			}
+			else if (Item.IsEmpty())
+			{
+				Item.SetItem(Program.MouseItem.Copy());
+				Program.MouseItem.Clear();
+			}
+		}
+
+		base.Update();
+	}
+
+	public override void Render()
+	{
+		if (RenderSlot)
+		{
+			Raylib.DrawRectangleRec(GetRectangle(), Color.Blue);
+			Raylib.DrawRectangleLinesEx(GetRectangle(), 2f, Color.SkyBlue);
+		}
+
+		if (Item.IsSomething())
+			Item.Item.Render(
+				Program.Level!,
+				Program.View,
+				new(RelativeX, RelativeY, Width, Height)
+			);
+
+		base.Render();
+	}
+
+	public override bool RenderHoverBox()
+	{
+		if (IsHovered() && Item.IsSomething())
+		{
+			string name = Lang.T($"item.{Item.Item.Key}");
+			Lang.TE($"item.{Item.Item.Key}.desc", out string? desc);
+
+			Rectangle rect = new(
+				Raylib.GetMouseX() + 8,
+				Raylib.GetMouseY() + 8,
+				Math.Max(Raylib.MeasureText(name, 20), desc != null ? Raylib.MeasureText(desc, 20) : 0) + 16,
+				20 + (desc != null ? 20 : 0) + 16
+			);
+			Raylib.DrawRectangleRec(rect, Color.Blue);
+			Raylib.DrawRectangleLinesEx(rect, 2f, Color.SkyBlue);
+
+			Raylib.DrawText(name, (int)rect.X + 8, (int)rect.Y + 8, 20, Color.White);
+			if (desc != null)
+				Raylib.DrawText(desc, (int)rect.X + 8, (int)rect.Y + 28, 20, Color.White);
+
+			return true;
+		}
+
+		return base.RenderHoverBox();
+	}
+}

Electropunk/UI/UIJim.cs

···
+using System.Numerics;
+using Raylib_cs;
+
+namespace Electropunk.UI;
+
+/* Jim was drawn by Collie as a joke on the Wand.png
+   texture. I decided it make it a UI element because it's
+   silly. */
+public class UIJim(UINode? parent = null) : UINode(0, 0, parent)
+{
+	private static readonly Texture2D Jim = Raylib.LoadTexture("Assets/UI/jim.png");
+
+	private int i = 0;
+	private Vector2 pos = Vector2.Zero;
+
+	public override void Update()
+	{
+		pos = Vector2.Lerp(pos, Raylib.GetMousePosition(), 0.2f);
+
+		base.Update();
+	}
+
+	public override void Render()
+	{
+		Raylib.DrawTexturePro(Jim, new(0, 0, Jim.Width, Jim.Height), new(pos.X, pos.Y, Jim.Width * 2, Jim.Height * 2), new(Jim.Width, Jim.Height), i++, Color.White);
+
+		base.Render();
+	}
+}

Electropunk/UI/UINode.cs

···
+using Electropunk.Input;
+using Raylib_cs;
+
+namespace Electropunk.UI;
+
+public class UINode
+{
+	protected List<UINode> Children = [];
+	protected UINode? Parent;
+
+	public int LocalX, LocalY;
+	public int Width = 0, Height = 0;
+	public bool Visible = true;
+
+	public int RelativeX
+	{
+		get => (Parent?.RelativeX ?? 0) + LocalX;
+	}
+
+	public int RelativeY
+	{
+		get => (Parent?.RelativeY ?? 0) + LocalY;
+	}
+
+	public UINode(int x, int y, UINode? parent = null)
+	{
+		LocalX = x;
+		LocalY = y;
+		Parent = parent;
+
+		Reposition();
+	}
+
+	public Rectangle GetRectangle() => new(RelativeX, RelativeY, Width, Height);
+
+	public bool IsHovered() => Raylib.CheckCollisionPointRec(Raylib.GetMousePosition(), GetRectangle());
+	public bool IsClicked() => Bindings.UIClick.IsPressed() && IsHovered();
+
+	public void AddChild(UINode node)
+	{
+		Children.Add(node);
+		node.Parent = this;
+	}
+
+	public void AddChild(Func<UINode, UINode> node) => Children.Add(node(this));
+
+	public virtual void Reposition()
+	{ }
+
+	public virtual void Update()
+	{
+		if (Raylib.IsWindowResized())
+			Reposition();
+
+		if (!Visible)
+			return;
+
+		foreach (UINode node in Children)
+			node.Update();
+	}
+
+	public virtual void Render()
+	{
+		if (!Visible)
+			return;
+
+		foreach (UINode node in Children)
+			node.Render();
+	}
+
+	public virtual bool RenderHoverBox()
+	{
+		if (!Visible)
+			return false;
+
+		foreach (UINode node in Children)
+			if (node.RenderHoverBox())
+				return true;
+
+		return false;
+	}
+}

Electropunk/UI/UISelection.cs

···
+using System.Numerics;
+using Electropunk.Content.Entities;
+using Electropunk.Content.Tiles;
+using Electropunk.World;
+using Raylib_cs;
+
+namespace Electropunk.UI;
+
+public class UISelection(UINode parent) : UINode(0, 0, parent)
+{
+	private Texture2D Texture = Raylib.LoadTexture("Assets/UI/select.png");
+
+	public override void Render()
+	{
+		if (Program.Level == null)
+			goto done;
+
+		/* Check for an item */
+		Entity? e = Program.Level.GetSelectedEntity(Program.View);
+		if (e != null && e is EntityItem)
+		{
+			Raylib.BeginMode2D(Program.View.Camera);
+			Raylib.DrawTextureEx(Texture, new(e.Pos.X - e.Width / 2f, e.Pos.Y - e.Height / 2f), 0, 1, Color.White);
+			Raylib.EndMode2D();
+			goto done;
+		}
+
+		/* Check for a tile */
+		(int x, int y) = Program.Level.GetSelectedTile(Program.View) ?? (-1, -1);
+		if (x == -1 || y == -1)
+			goto done;
+
+		if (Program.Level.GetTileIDAt(x, y) != GameTiles.Air.ID)
+		{
+			Vector2 pos = View.LevelPosToWorldPos(x, y);
+			Raylib.BeginMode2D(Program.View.Camera);
+			Raylib.DrawTextureEx(Texture, pos, 0, 1, Color.White);
+			Raylib.EndMode2D();
+		}
+
+	done: /* OH NOOOOOO; BAD PRACTICE!!! yeah no, i dont care. code is code. */
+		base.Render();
+	}
+}

Electropunk/World/Biome.cs

···
+using System.Numerics;
+using Raylib_cs;
+
+namespace Electropunk.World;
+
+public class Biome(string key)
+{
+	public const int MaxBiomes = 1024;
+
+	private static ushort _nextBiomeID = 0;
+	public static Biome[] Biomes { get; private set; } = new Biome[MaxBiomes];
+
+	public ushort ID { get; private set; }
+	public bool Visible { get; set; } = true;
+
+	public Texture2D Texture = Raylib.LoadTexture($"Assets/Biomes/{key}.png");
+
+	public virtual void Render(Level level, View view, int levelX, int levelY)
+	{
+		if (level.Step != RenderStep.Biomes)
+			return;
+
+		Vector2 pos = View.LevelPosToWorldPos(levelX, levelY);
+		Raylib.DrawTextureEx(Texture, pos, 0, 1, Color.White);
+	}
+
+	public Biome Register()
+	{
+		return Register(this);
+	}
+
+	public static Biome Register(Biome biome)
+	{
+		biome.ID = _nextBiomeID++;
+		Biomes[biome.ID] = biome;
+		return biome;
+	}
+}

Electropunk/World/Crafting/RecipeItemSmashing.cs

···
+using System.Numerics;
+using Electropunk.Containers;
+using Electropunk.Content.Entities;
+using Electropunk.Content.Tiles;
+using Kadlet;
+
+namespace Electropunk.World.Crafting;
+
+public class RecipeItemSmashing(ushort inputItemID, List<ItemInstance> results)
+{
+	public static readonly List<RecipeItemSmashing> Recipes = [];
+
+	public bool Matches(EntityItem entity) => entity.Item.Matches(inputItemID);
+
+	public bool Craft(Level level, EntityItem entity)
+	{
+		if (!Matches(entity))
+			return false;
+
+		foreach (ItemInstance item in results)
+			level.EnqueueEntity(new EntityItem() {
+				Item = item.Copy(),
+				Pos = entity.Pos + new Vector2(Program.Rand.Next(-4, 4), Program.Rand.Next(-4, 4))
+			});
+
+		entity.Dead = true;
+
+		return true;
+	}
+
+	public static RecipeItemSmashing? GetRecipe(EntityItem entity)
+	{
+		foreach (RecipeItemSmashing recipe in Recipes)
+			if (recipe.Matches(entity))
+				return recipe;
+		return null;
+	}
+
+	public static bool TryCraft(Level level, EntityItem entity)
+	{
+		var r = GetRecipe(entity);
+		if (r == null)
+			return false;
+		return r!.Craft(level, entity);
+	}
+
+	public static void Load(string filepath)
+	{
+		KdlReader reader = new(new KdlReaderOptions());
+		using FileStream fs = File.OpenRead(filepath);
+		KdlDocument doc = reader.Parse(fs);
+
+		foreach (var node in doc.Nodes)
+		{
+			ushort inputTileID = GameTiles.Air.ID;
+			List<ItemInstance> results = [];
+			foreach (var child in node.Children!.Nodes)
+			{
+				if (child.Identifier == "in")
+					inputTileID = Item.FindByKey(child.Arguments[0].ToKdlString().Trim('\'', '"'))!.ID;
+				else if (child.Identifier == "out")
+					results.Add(new(Item.FindByKey(child.Arguments[0].ToKdlString().Trim('\'', '"'))!));
+				else
+					throw new($"Unexpected key: {child.Identifier}");
+			}
+			Recipes.Add(new(inputTileID, results));
+		}
+	}
+}

Electropunk/World/Crafting/RecipeTileSmashing.cs

···
+using System.Numerics;
+using Electropunk.Containers;
+using Electropunk.Content.Entities;
+using Electropunk.Content.Tiles;
+using Kadlet;
+
+namespace Electropunk.World.Crafting;
+
+public class RecipeTileSmashing(ushort inputTileID, ushort outputTileID, List<ItemInstance> results)
+{
+	public static readonly List<RecipeTileSmashing> Recipes = [];
+
+	public bool Matches(Level level, int levelX, int levelY) =>
+		level.GetTileIDAt(levelX, levelY) == inputTileID;
+
+	public bool Craft(Level level, int levelX, int levelY)
+	{
+		if (!Matches(level, levelX, levelY))
+			return false;
+
+		level.SetTileIDAt(levelX, levelY, outputTileID);
+		foreach (ItemInstance item in results)
+			level.EnqueueEntity(new EntityItem() {
+				Item = item.Copy(),
+				Pos =
+					View.LevelPosToWorldPos(levelX, levelY) +
+					new Vector2(View.TileSize / 2, View.TileSize / 2) +
+					new Vector2(Program.Rand.Next(-4, 4), Program.Rand.Next(-4, 4))
+			});
+
+		return true;
+	}
+
+	public static RecipeTileSmashing? GetRecipe(Level level, int levelX, int levelY)
+	{
+		foreach (RecipeTileSmashing recipe in Recipes)
+			if (recipe.Matches(level, levelX, levelY))
+				return recipe;
+		return null;
+	}
+
+	public static bool TryCraft(Level level, int levelX, int levelY)
+	{
+		var r = GetRecipe(level, levelX, levelY);
+		if (r == null)
+			return false;
+		return r!.Craft(level, levelX, levelY);
+	}
+
+	public static void Load(string filepath)
+	{
+		KdlReader reader = new(new KdlReaderOptions());
+		using FileStream fs = File.OpenRead(filepath);
+		KdlDocument doc = reader.Parse(fs);
+
+		foreach (var node in doc.Nodes)
+		{
+			ushort inputTileID = GameTiles.Air.ID;
+			ushort outputTileID = GameTiles.Air.ID;
+			List<ItemInstance> results = [];
+			foreach (var child in node.Children!.Nodes)
+			{
+				if (child.Identifier == "in")
+					inputTileID = Tile.FindByKey(child.Arguments[0].ToKdlString().Trim('\'', '"'))!.ID;
+				else if (child.Identifier == "out-tile")
+					outputTileID = Tile.FindByKey(child.Arguments[0].ToKdlString().Trim('\'', '"'))!.ID;
+				else if (child.Identifier == "out-item")
+					results.Add(new(Item.FindByKey(child.Arguments[0].ToKdlString().Trim('\'', '"'))!));
+				else
+					throw new($"Unexpected key: {child.Identifier}");
+			}
+			Recipes.Add(new(inputTileID, outputTileID, results));
+		}
+	}
+}

Electropunk/World/Entity.cs

···
+using System.Numerics;
+using Raylib_cs;
+
+namespace Electropunk.World;
+
+public class Entity
+{
+	public Vector2 Pos = Vector2.Zero, Vel = Vector2.Zero;
+	public float Speed = 0.100f;
+	public bool Dead = false;
+	public float Width = 0, Height = 0;
+	public MovementMode MoveMode = MovementMode.Default;
+	public RenderStep Step = RenderStep.Entities;
+	public bool Selectable = true;
+
+	public Rectangle GetRectangle() => new(Pos.X - Width / 2, Pos.Y - Height / 2, Width, Height);
+
+	public bool IsVisible(View view) => Raylib.CheckCollisionRecs(GetRectangle(), view.GetWorldBoundsRec());
+
+	public bool CanMoveInDirection(Level level, Vector2 direction)
+	{
+		Rectangle rect = GetRectangle();
+		rect.X += direction.X;
+		rect.Y += direction.Y;
+
+		/* Get a range of tiles to check */
+		int sx = (int)Math.Max(Math.Floor(rect.X / View.TileSize), 0);
+		int sy = (int)Math.Max(Math.Floor(rect.Y / View.TileSize), 0);
+		int ex = (int)Math.Min(Math.Max(rect.Width, View.TileSize) + sx, level.Width);
+		int ey = (int)Math.Min(Math.Max(rect.Height, View.TileSize) + sy, level.Height);
+
+		/* Check if any tiles will collide with the future rect */
+		Tile tile;
+		for (int x = sx; x <= ex; x++)
+			for (int y = sy; y <= ey; y++)
+			{
+				tile = level.GetTileAt(x, y);
+				if (tile.Collides && Raylib.CheckCollisionRecs(tile.GetRectangle(level, x, y), rect))
+					return false; /* We're colliding with a tile */
+			}
+
+		return true;
+	}
+
+	public virtual void Update(Level level)
+	{
+		MoveMode.Move(level, this);
+	}
+
+	public virtual void Render(Level level, View view)
+	{ }
+}

Electropunk/World/Item.cs

···
+using System.Numerics;
+using Electropunk.Containers;
+using Electropunk.Content.Entities;
+using Electropunk.Graphics;
+using Raylib_cs;
+
+namespace Electropunk.World;
+
+public class Item(string key)
+{
+	public const int MaxItems = 2048;
+
+	private static ushort _nextItemID = 0;
+	public static Item[] Items { get; private set; } = new Item[MaxItems];
+
+	public readonly string Key = key;
+	public ushort ID { get; private set; }
+
+	public Texture2D Texture = Raylib.LoadTexture($"Assets/Items/{key}.png");
+
+	public virtual void UseOnTile(Level level, EntityPlayer user, Slot item, int tileX, int tileY)
+	{ }
+
+	public virtual void UseOnEntity(Level level, EntityPlayer user, Slot item, Entity target)
+	{ }
+
+	public virtual void Render(Level level, View view, Rectangle dest, Vector2? origin = null, float rotation = 0, bool hFlip = false, bool vFlip = false)
+	{
+		Rectangle src = TextureUtil.GetSourceRect(Texture);
+		if (hFlip)
+			src.Width = -src.Width;
+		if (vFlip)
+			src.Height = -src.Height;
+		Raylib.DrawTexturePro(
+			Texture,
+			src,
+			dest,
+			origin ?? Vector2.Zero,
+			rotation,
+			Color.White
+		);
+	}
+
+	public Item Register()
+	{
+		return Register(this);
+	}
+
+	public static Item Register(Item item)
+	{
+		item.ID = _nextItemID++;
+		Items[item.ID] = item;
+		return item;
+	}
+
+	public static Item? FindByKey(string key)
+	{
+		foreach (Item item in Items)
+			if (item.Key == key)
+				return item;
+		return null;
+	}
+}

Electropunk/World/Level.cs

···
+using System.Numerics;
+using Electropunk.Misc;
+using Raylib_cs;
+
+namespace Electropunk.World;
+
+public class Level(int width, int height)
+{
+	public readonly int Width = width, Height = height;
+
+	private readonly ushort[,] BiomeGrid = new ushort[width, height];
+	private readonly ushort[,] Grid = new ushort[width, height];
+	private readonly List<Entity> Entities = [];
+	private readonly Queue<Entity> EntityQueue = [];
+	private readonly Dictionary<(int x, int y), TileData> TileData = [];
+
+	public RenderStep Step { get; private set; } = RenderStep.None;
+	public Random Random { get; private set; } = new();
+	public ulong Frame { get; private set; } = 0;
+	public ulong Tick { get; private set; } = 0;
+	public const int FramesPerTick = 3;
+
+	public bool RenderHitboxes { get; set; } = false;
+
+	public ushort GetBiomeIDAt(int x, int y) => BiomeGrid[x, y];
+	public Biome GetBiomeAt(int x, int y) => Biome.Biomes[BiomeGrid[x, y]];
+
+	public ushort GetTileIDAt(int x, int y) => Grid[x, y];
+	public Tile GetTileAt(int x, int y) => Tile.Tiles[Grid[x, y]];
+
+	private void RawSetTileIDAt(int x, int y, ushort tileID)
+	{
+		if (HasTileDataAt(x, y))
+			RemoveTileDataAt(x, y);
+		Grid[x, y] = tileID;
+	}
+
+	public void SetTileIDAt(int x, int y, ushort tileID) => RawSetTileIDAt(x, y, tileID);
+	public void SetTileAt(int x, int y, Tile tile) => RawSetTileIDAt(x, y, tile.ID);
+
+	public void PlaceTileIDAt(int x, int y, ushort tileID) => Tile.Tiles[tileID].Place(this, x, y);
+	public void PlaceTileAt(int x, int y, Tile tile) => tile.Place(this, x, y);
+
+	public Ref<T> GetTileDataAt<T>(int x, int y) where T : TileData =>
+		new(() => (T)TileData[(x, y)], v => TileData[(x, y)] = v);
+	public void SetTileDataAt(int x, int y, TileData data) => TileData[(x, y)] = data;
+	public void RemoveTileDataAt(int x, int y) => TileData.Remove((x, y));
+	public bool HasTileDataAt(int x, int y) => TileData.ContainsKey((x, y));
+
+	public List<Entity> GetEntities() => Entities;
+	public void AddEntity(Entity entity) => Entities.Add(entity);
+	public void EnqueueEntity(Entity entity) => EntityQueue.Enqueue(entity);
+
+	public IEnumerable<Entity> GetVisibleEntities(View view)
+	{
+		foreach (Entity entity in Entities)
+		{
+			if (entity.IsVisible(view))
+			{
+				yield return entity;
+			}
+		}
+	}
+
+	public IEnumerable<T> GetVisibleEntitiesOfType<T>(View view)
+	{
+		foreach (Entity entity in Entities)
+		{
+			if (entity is T t && entity.IsVisible(view))
+			{
+				yield return t;
+			}
+		}
+	}
+
+	public (int x, int y)? GetSelectedTile(View view)
+	{
+		Vector2 pos = Raylib.GetScreenToWorld2D(Raylib.GetMousePosition(), view.Camera);
+		int x = (int)Math.Floor(pos.X / View.TileSize);
+		int y = (int)Math.Floor(pos.Y / View.TileSize);
+		if (x < 0 || y < 0 || x >= Width || y >= Height)
+			return null;
+		else
+			return (x, y);
+	}
+
+	public Entity? GetSelectedEntity(View view)
+	{
+		Vector2 m = Raylib.GetScreenToWorld2D(Raylib.GetMousePosition(), Program.View.Camera); /* mouse pos */
+		foreach (Entity entity in GetVisibleEntities(view))
+		{
+			if (entity.Selectable && Raylib.CheckCollisionPointRec(m, entity.GetRectangle()))
+			{
+				return entity;
+			}
+		}
+		return null;
+	}
+
+	public void Generate(LevelGenerator generator)
+	{
+		for (int y = 0; y < Width; y++)
+			for (int x = 0; x < Height; x++)
+				BiomeGrid[x, y] = generator.PickBiome(this, x, y).ID;
+
+		for (int y = 0; y < Width; y++)
+			for (int x = 0; x < Height; x++)
+				Grid[x, y] = generator.Pick(this, Biome.Biomes[BiomeGrid[x, y]], x, y).ID;
+	}
+
+	public void Update()
+	{
+		Frame++;
+
+		if (Frame % FramesPerTick == 0)
+		{
+			Tick++;
+
+			for (int y = 0; y < Width; y++)
+				for (int x = 0; x < Height; x++)
+					if (GetTileAt(x, y).Updates)
+						GetTileAt(x, y).Update(this, x, y);
+		}
+
+		while (EntityQueue.Count > 0)
+			Entities.Add(EntityQueue.Dequeue());
+
+		foreach (Entity entity in Entities)
+			entity.Update(this);
+
+		Entities.RemoveAll(entity => entity.Dead);
+	}
+
+	public void Render(View view)
+	{
+		(Vector2 start, Vector2 end) = view.GetWorldBounds();
+		/* We render a few tiles out of bounds to band-aid fix an edge case:
+		   If we have a tile with a sprite larger than 16x16 (trees), they'll still get culled like default.
+		   Rendering a few excess tiles out "fixes" that. */
+		int excess = 3;
+		int sx = Math.Max((int)((Math.Floor(start.X) / View.TileSize) - excess), 0);
+		int sy = Math.Max((int)((Math.Floor(start.Y) / View.TileSize) - excess), 0);
+		int ex = Math.Min((int)((Math.Ceiling(end.X) / View.TileSize) + excess), Width);
+		int ey = Math.Min((int)((Math.Ceiling(end.Y) / View.TileSize) + excess), Height);
+
+		Raylib.BeginMode2D(view.Camera);
+
+		Step = RenderStep.None;
+		/* This loop/switch tree ensures that if I add a render step in
+		   the future, I'll remember to add it here. */
+		while (Step != RenderStep.Done)
+		{
+			Step++;
+			switch (Step)
+			{
+				case RenderStep.Sky:
+					Raylib.EndMode2D();
+					RenderSky(view);
+					Raylib.BeginMode2D(view.Camera);
+					break;
+				case RenderStep.Entities:
+				case RenderStep.FlyingEntities:
+					RenderEntities(view, start, end);
+					break;
+				case RenderStep.Particles:
+					RenderParticles(view, start, end);
+					break;
+				case RenderStep.Biomes:
+					RenderBiomes(view, sx, sy, ex, ey);
+					break;
+				case RenderStep.Tiles:
+				case RenderStep.TilesAbove:
+					RenderTiles(view, sx, sy, ex, ey);
+					break;
+				case RenderStep.Weather:
+					RenderWeather(view);
+					break;
+				case RenderStep.Done:
+					break;
+				default:
+					throw new($"Unhandled render step: {Step}");
+			}
+		}
+
+		Raylib.EndMode2D();
+	}
+
+	private void RenderSky(View view)
+	{
+		Raylib.ClearBackground(Color.SkyBlue);
+	}
+
+	private void RenderBiomes(View view, int sx, int sy, int ex, int ey)
+	{
+		for (int y = sy; y < ey; y++)
+			for (int x = sx; x < ex; x++)
+				GetBiomeAt(x, y).Render(this, view, x, y);
+	}
+
+	private void RenderTiles(View view, int sx, int sy, int ex, int ey)
+	{
+		Tile tile;
+		for (int y = sy; y < ey; y++)
+			for (int x = sx; x < ex; x++)
+			{
+				tile = GetTileAt(x, y);
+				tile.Render(this, view, x, y);
+				if (RenderHitboxes && tile.Collides)
+					Raylib.DrawRectangleLinesEx(tile.GetRectangle(this, x, y), 1f, Color.Black);
+			}
+	}
+
+	private void RenderEntities(View view, Vector2 start, Vector2 end)
+	{
+		/* TODO: Cull */
+		foreach (Entity entity in Entities)
+		{
+			entity.Render(this, view);
+
+			if (RenderHitboxes)
+				Raylib.DrawRectangleLinesEx(entity.GetRectangle(), 1f, Color.Red);
+		}
+	}
+
+	private void RenderParticles(View view, Vector2 start, Vector2 end)
+	{
+	}
+
+	private void RenderWeather(View view)
+	{
+	}
+}

Electropunk/World/LevelGenerator.cs

···
+namespace Electropunk.World;
+
+public abstract class LevelGenerator
+{
+	public abstract Biome PickBiome(Level level, int x, int y);
+
+	public abstract Tile Pick(Level level, Biome biome, int x, int y);
+}

Electropunk/World/MovementMode.cs

···
+using System.Numerics;
+
+namespace Electropunk.World;
+
+public class MovementMode
+{
+	public bool Frozen = false;
+	public bool Collides = true;
+	public float MinSpeed = 0.10f;
+	public float Friction = 1.50f;
+	public float SpeedMod = 0.00f;
+
+	public void Move(Level level, Entity e)
+	{
+		if (Frozen)
+			return;
+
+		Vector2 delta = e.Vel * (e.Speed + SpeedMod) * Program.DeltaTime;
+
+		if (Collides)
+		{
+			if (delta.X != 0 && !e.CanMoveInDirection(level, new(delta.X, 0)))
+				delta.X = 0;
+			if (delta.Y != 0 && !e.CanMoveInDirection(level, new(0, delta.Y)))
+				delta.Y = 0;
+		}
+
+		e.Pos += delta;
+
+		if (e.Vel.X > -MinSpeed && e.Vel.X < MinSpeed)
+			e.Vel.X = 0;
+		else if (e.Vel.X != 0)
+			e.Vel.X /= Friction;
+
+		if (e.Vel.Y > -MinSpeed && e.Vel.Y < MinSpeed)
+			e.Vel.Y = 0;
+		else if (e.Vel.Y != 0)
+			e.Vel.Y /= Friction;
+	}
+
+	public static readonly MovementMode None = new() { Frozen = true };
+	public static readonly MovementMode Default = new();
+	public static readonly MovementMode Flying = new() {
+		Collides = false,
+		Friction = 1.05f,
+		SpeedMod = 0.25f
+	};
+}

Electropunk/World/RenderStep.cs

···
+namespace Electropunk.World;
+
+public enum RenderStep
+{
+	None,           /* Sentinel */
+	Sky,            /* Sky effects, such as clouds when you're on the edge of a floating island. */
+	Biomes,         /* Biome tiles */
+	Tiles,          /* Most tiles */
+	Entities,       /* Entities */
+	Particles,      /* Particles */
+	TilesAbove,     /* Trees, large rocks, etc */
+	FlyingEntities, /* Birds, players with jetpacks, etc */
+	Weather,        /* Cloud shadows, rain, puddles, snow cover, etc */
+	Done,           /* Sentinel */
+}

Electropunk/World/Tile.cs

···
+using System.Numerics;
+using Electropunk.Content.Entities;
+using Electropunk.Content.Tiles;
+using Raylib_cs;
+
+namespace Electropunk.World;
+
+public class Tile(string key)
+{
+	public const int MaxTiles = 1024;
+
+	private static ushort _nextTileID = 0;
+	public static Tile[] Tiles { get; private set; } = new Tile[MaxTiles];
+
+	public readonly string Key = key;
+	public ushort ID { get; private set; }
+
+	public RenderStep RenderStep = RenderStep.Tiles;
+	public Texture2D Texture = Raylib.LoadTexture($"Assets/Tiles/{key}.png");
+	public bool Collides = true; /* TODO: Make this a function */
+	public Rectangle? CollisionRect = null;
+	public List<Item> Drops = [];
+	public bool Updates = false;
+
+	public virtual void Place(Level level, int x, int y)
+	{
+		level.SetTileAt(x, y, this);
+	}
+
+	public virtual void Remove(Level level, int x, int y)
+	{
+		level.SetTileAt(x, y, GameTiles.Air);
+	}
+
+	public virtual void Break(Level level, int x, int y)
+	{
+		Remove(level, x, y);
+
+		foreach (Item item in Drops)
+			level.EnqueueEntity(new EntityItem() {
+				Item = new(item),
+				Pos =
+					View.LevelPosToWorldPos(x, y) +
+					new Vector2(View.TileSize / 2, View.TileSize / 2) +
+					new Vector2(Program.Rand.Next(-4, 4), Program.Rand.Next(-4, 4))
+			});
+	}
+
+	public virtual void Use(Level level, int x, int y, EntityPlayer user)
+	{ }
+
+	public virtual Rectangle GetRectangle(Level level, int x, int y)
+	{
+		Rectangle box = new(x * View.TileSize, y * View.TileSize, View.TileSize, View.TileSize);
+		if (CollisionRect != null)
+		{
+			box.X += ((Rectangle)CollisionRect!).X;
+			box.Y += ((Rectangle)CollisionRect!).Y;
+			box.Width = ((Rectangle)CollisionRect!).Width;
+			box.Height = ((Rectangle)CollisionRect!).Height;
+		}
+		return box;
+	}
+
+	public virtual void Update(Level level, int x, int y)
+	{ }
+
+	public virtual void Render(Level level, View view, int x, int y)
+	{
+		if (level.Step != RenderStep)
+			return;
+
+		Vector2 pos = View.LevelPosToWorldPos(x, y);
+
+		if (Texture.Width > View.TileSize)
+			pos.X -= View.TileSize;
+		if (Texture.Height > View.TileSize)
+			pos.Y -= View.TileSize;
+
+		Raylib.DrawTextureEx(Texture, pos, 0, 1, Color.White);
+	}
+
+	public Tile Register()
+	{
+		return Register(this);
+	}
+
+	public static Tile Register(Tile tile)
+	{
+		tile.ID = _nextTileID++;
+		Tiles[tile.ID] = tile;
+		return tile;
+	}
+
+	public static Tile? FindByKey(string key)
+	{
+		foreach (Tile tile in Tiles)
+			if (tile.Key == key)
+				return tile;
+		return null;
+	}
+}
+
+public abstract class TileData
+{
+	public abstract string Save();
+
+	public abstract void Load(string json);
+}

Electropunk/World/View.cs

···
+using System.Numerics;
+using Raylib_cs;
+
+namespace Electropunk.World;
+
+public class View
+{
+	/* Never ever change this. This is the size that we render tiles at. */
+	public const int TileSize = 16;
+
+	public Vector2 GoalTarget = Vector2.Zero;
+	public float GoalZoom = 2f;
+
+	public Camera2D Camera = new(new Vector2(400, 300), new Vector2(0, 0), 0f, 2f);
+
+	public void Update()
+	{
+		if (Raylib.IsWindowResized())
+			Camera.Offset = Raylib.GetScreenCenter();
+
+		Camera.Target = Vector2.Lerp(Camera.Target, GoalTarget, 0.20f);
+		Camera.Zoom = Vector2.Lerp(new(0, Camera.Zoom), new(0, GoalZoom), 0.20f).Y; /* cursed? yes. very. */
+	}
+
+	public (Vector2, Vector2) GetWorldBounds()
+	{
+		Vector2 first = Raylib.GetScreenToWorld2D(new(0, 0), Camera);
+		Vector2 second = Raylib.GetScreenToWorld2D(new(Raylib.GetScreenWidth(), Raylib.GetScreenHeight()), Camera);
+		return (first, second);
+	}
+
+	public Rectangle GetWorldBoundsRec()
+	{
+		Vector2 first = Raylib.GetScreenToWorld2D(new(0, 0), Camera);
+		Vector2 second = Raylib.GetScreenToWorld2D(new(Raylib.GetScreenWidth(), Raylib.GetScreenHeight()), Camera);
+		return new(first, second - first);
+	}
+
+	public static Vector2 LevelPosToWorldPos(int x, int y) => new(x * TileSize, y * TileSize);
+}

electropunk.sln

···
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio Version 17
+VisualStudioVersion = 17.0.31903.59
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Electropunk", "Electropunk\Electropunk.csproj", "{1B9AD174-1BA7-4FD1-A4BA-6209E6A2CB81}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Release|Any CPU = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{1B9AD174-1BA7-4FD1-A4BA-6209E6A2CB81}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{1B9AD174-1BA7-4FD1-A4BA-6209E6A2CB81}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{1B9AD174-1BA7-4FD1-A4BA-6209E6A2CB81}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{1B9AD174-1BA7-4FD1-A4BA-6209E6A2CB81}.Release|Any CPU.Build.0 = Release|Any CPU
+	EndGlobalSection
+EndGlobal

licenses

···
+
+=== Electropunk ===
+
+Currently All Rights Reserved. I'm looking into open-source
+licenses that'll prevent other people from publishing the
+game under their name without credit. I.e, the MIT license
+would allow anyone to publish Electropunk on Steam, which I
+don't want.
+
+=== FastNoiseLite ===
+
+MIT License
+
+Copyright(c) 2020 Jordan Peck ([e-mail])
+Copyright(c) 2020 Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

misc/fantasy.gpl

···
+GIMP Palette
+#Palette Name: fantasy_
+#Description: designed for the fantasy_ tilesets and sprites @itch.io [https://itch.io/c/1507436/fantasy-]
+#Colors: 32
[phone]	ede4da
[phone]	bfb8b4
[phone]d8d
[phone]
[phone]
+169	73	73	a94949
+202	89	84	ca5954
[phone]	e56f4b
[phone]	e39347
[phone]	eeb551
[phone]	e8c65b
[phone]	bda351
[phone]b9150
[phone]d55
[phone]
+62	85	76	3e554c
[phone]bb0ad
[phone]fa6
[phone]da9
[phone]c699f
[phone]a5888
[phone]c6da2
[phone]a9d
[phone]	bc87a5
[phone]	d9a6a6
[phone]	d4c2b6
[phone]	bdaa97
[phone]b
[phone]e674c
[phone]b42
[phone]b3d
+77	63	56	4d3f38

misc/gora63.gpl

···
+GIMP Palette
+#Palette Name: GORA63
+#Description: A big pallete with 7 colors and 9 shades, equalling a total of 63 colors. I made this pallete for a RPG game where color diversity was a must, so it is great for many things. The pallete is inspired by AdamCYounis, that's why the base colors are the same as Apollo. Hope you like it. :) (ALSO, check out AdamCYounis. Lospec: https://lospec.com/adamcyounis Twitter: https://twitter.com/AdamCYounis?ref_src=twsrc%5Egoogle%7Ctwcamp%5Eserp%7Ctwgr%5Eauthor)
+#Colors: 63
[phone]b27
+30	39	52	1e2734
+43	53	69	2b3545
+58	73	89	3a4959
[phone]
[phone]c8294
[phone]aa9
[phone]	b3c2ca
[phone]	dae1e5
[phone]
+27	35	67	1b2343
[phone]
[phone]a71
[phone]d5b85
[phone]b0
[phone]b2d3
[phone]d8e9
[phone]	bdeef7
[phone]
+28	48	48	1c3030
[phone]
[phone]
[phone]a7148
[phone]c9f4c
[phone]d150
[phone]	c5f57d
[phone]	e8fab6
+43	20	36	2b1424
[phone]b28
+78	44	50	4e2c32
[phone]
[phone]e48
[phone]b614f
[phone]	bb885a
[phone]	dfbb89
[phone]	f0e0b8
[phone]
+61	31	40	3d1f28
+77	40	44	4d282c
[phone]f3b31
[phone]e4e30
[phone]	b46a29
[phone]	e19f3e
[phone]	f0c069
[phone]	f7e198
+44	19	41	2c1329
[phone]
[phone]e3a
[phone]b2536
+168	55	45	a8372d
+216	95	40	d85f28
[phone]	f08e39
[phone]	fbc85e
[phone]	fce886
+28	23	41	1c1729
+42	33	53	2a2135
+62	42	73	3e2a49
[phone]f
[phone]d3a78
[phone]	c64782
[phone]	d86a9f
[phone]	e7a0b4
[phone]	f2cdce

misc/nanner-32.gpl

···
+GIMP Palette
+#Palette Name: Nanner 32
+#Description: NOTE: An improved version of this palette can be found here: https://www.pixilart.com/palettes/nanner-32-9538
+#Colors: 32
[phone]ab
[phone]b9acf
[phone]bbde6
[phone]	aae0f3
[phone]	c8eded
[phone]	faffe0
[phone]	dde6e0
[phone]	b4bec2
[phone]da8
[phone]a7a99
[phone]b5280
+78	49	97	4e3161
[phone]e42
[phone]
[phone]a3757
[phone]b
[phone]	bd6868
[phone]	d18b79
[phone]	dbac8c
[phone]	e6cfa1
[phone]	e7ebbc
[phone]	b2dba0
[phone]c293
[phone]a18f
[phone]c8f
[phone]	b56e75
[phone]	c98f8f
[phone]	dfb6ae
[phone]	edd5ca
[phone]	bd7182
[phone]e5476
[phone]c6a

misc/palettes.txt

···
+
+A list of colour palettes I'm considering for Electropunk
+
+"Phase 1" (just finding some fancy palettes, disregarding Electropunk's theme)
+
+  Waldgeist    <https://lospec.com/palette-list/waldgeist>
+  Nanner 32    <https://lospec.com/palette-list/nanner-32>
+  Fantasy      <https://lospec.com/palette-list/fantasy>
+  Paper Pixels <https://lospec.com/palette-list/paper-pixels>
+  Poisson 23   <https://lospec.com/palette-list/poisson-23>
+  Gora63       <https://lospec.com/palette-list/gora63>
+  Sweet24      <https://lospec.com/palette-list/sweet24>
+  Vinik24      <https://lospec.com/palette-list/vinik24>
+
+"Phase 2" (matching palettes to Electropunk's theme [cyber/steam/solarpunk])
+
+  Nanner 32    <https://lospec.com/palette-list/nanner-32>
+  Fantasy      <https://lospec.com/palette-list/fantasy>
+  Gora63       <https://lospec.com/palette-list/gora63>

readme

···
+
+Electropunk
+===========
+
+A WIP automation game.
+
+Run
+---
+
+  Requires .NET 9.0
+
+  dotnet run --project Electropunk
+
+Misc
+----
+
+  Electropunk's birthday is November 1st, 2025.
+  Jim's birthday is November 5th, 2025.