Range Modifiers

src/items.zig

@@ -159,6 +159,7 @@ const Modifier = struct {
 		combineModifiers: *const fn (data1: Data, data2: Data) ?Data,
 		changeProceduralItemParameters: *const fn (proceduralItem: *ProceduralItem, data: Data) void,
 		changeBlockDamage: *const fn (damage: f32, block: Block, data: Data) f32,
+		changeBlockRange: *const fn (data: Data) struct { f32, f32 },
 		printTooltip: *const fn (outString: *main.ListManaged(u8), data: Data) void,
 		loadData: *const fn (zon: ZonElement) Data,
 		priority: f32,
@@ -168,12 +169,16 @@ const Modifier = struct {
 			pub fn changeBlockDamage(damage: f32, _: Block, _: Data) f32 {
 				return damage;
 			}
+			pub fn changeBlockRange(_: f32) struct { f32, f32 } {
+				return .{0, 1}; // returns a flat 0 and a mult of 1
+			}
 		};
 
 		inline fn initFromModifierStruct(comptime ModifierStruct: type) VTable {
 			return comptime .{
 				.changeProceduralItemParameters = @ptrCast(if (@hasDecl(ModifierStruct, "changeProceduralItemParameters")) &ModifierStruct.changeProceduralItemParameters else &VTable.Defaults.changeProceduralItemParameters),
 				.changeBlockDamage = @ptrCast(if (@hasDecl(ModifierStruct, "changeBlockDamage")) &ModifierStruct.changeBlockDamage else &VTable.Defaults.changeBlockDamage),
+				.changeBlockRange = @ptrCast(if (@hasDecl(ModifierStruct, "changeBlockRange")) &ModifierStruct.changeBlockRange else &VTable.Defaults.changeBlockRange),
 				.combineModifiers = @ptrCast(&ModifierStruct.combineModifiers),
 				.printTooltip = @ptrCast(&ModifierStruct.printTooltip),
 				.loadData = @ptrCast(&ModifierStruct.loadData),
@@ -199,6 +204,10 @@ const Modifier = struct {
 		return self.vTable.changeBlockDamage(damage, block, self.data);
 	}
 
+	pub fn changeBlockRange(self: Modifier) struct { f32, f32 } {
+		return self.vTable.changeBlockRange(self.data);
+	}
+
 	pub fn printTooltip(self: Modifier, outString: *main.ListManaged(u8)) void {
 		self.vTable.printTooltip(outString, self.data);
 	}
@@ -916,6 +925,17 @@ pub const ProceduralItem = struct { // MARK: ProceduralItem
 		return main.game.Player.defaultBlockDamage;
 	}
 
+	pub fn getBlockRange(self: *ProceduralItem) struct { f32, f32 } {
+		var flatRange: f32 = 0;
+		var multRange: f32 = 1;
+		for (self.modifiers) |modifier| {
+			const flatRangeDiff, const multRangeDiff = modifier.changeBlockRange();
+			flatRange += flatRangeDiff;
+			multRange = multRange*multRangeDiff;
+		}
+		return .{flatRange, multRange};
+	}
+
 	pub fn onUseReturnBroken(self: *ProceduralItem) bool {
 		self.durability -|= 1;
 		return self.durability == 0;

src/proceduralItem/modifiers/_list.zig

@@ -1,9 +1,11 @@
-pub const bad_at = @import("bad_at.zig");
 pub const durable = @import("durable.zig");
 pub const fragile = @import("fragile.zig");
+pub const single_use = @import("single_use.zig");
 pub const good_at = @import("good_at.zig");
-pub const heavy = @import("heavy.zig");
+pub const bad_at = @import("bad_at.zig");
 pub const light = @import("light.zig");
+pub const heavy = @import("heavy.zig");
 pub const powerful = @import("powerful.zig");
-pub const single_use = @import("single_use.zig");
 pub const weak = @import("weak.zig");
+pub const long = @import("long.zig");
+pub const short = @import("short.zig");

src/proceduralItem/modifiers/long.zig

@@ -0,0 +1,33 @@
+const std = @import("std");
+
+const main = @import("main");
+const ProceduralItem = main.items.ProceduralItem;
+
+pub const Data = packed struct(u128) { multStrength: f32, flatStrength: f32, pad: u64 = undefined };
+
+pub const priority = 1;
+
+pub fn loadData(zon: main.ZonElement) Data {
+	return .{
+		.multStrength = @max(0, zon.get(f32, "multStrength") orelse 0),
+		.flatStrength = @max(0, zon.get(f32, "flatStrength") orelse 0),
+	};
+}
+
+pub fn combineModifiers(data1: Data, data2: Data) ?Data {
+	return .{
+		.multStrength = std.math.hypot(data1.multStrength, data2.multStrength),
+		.flatStrength = std.math.hypot(data1.flatStrength, data2.flatStrength),
+	};
+}
+
+pub fn changeBlockRange(data: Data) struct { f32, f32 } {
+	return .{data.flatStrength, data.multStrength};
+}
+
+pub fn printTooltip(outString: *main.ListManaged(u8), data: Data) void {
+	if (data.multStrength != 0 and data.flatStrength != 0) outString.print("#00f870**Far Reaching**#808080 *Increases range by **{d:.0}%** and **+{d:.0}**", .{data.multStrength*100, data.flatStrength});
+	if (data.multStrength != 0 and data.flatStrength == 0) outString.print("#00f870**Far Reaching**#808080 *Increases range by **{d:.0}%**", .{data.multStrength*100});
+	if (data.multStrength == 0 and data.flatStrength != 0) outString.print("#00f870**Far Reaching**#808080 *Increases range by **+{d:.0}**", .{data.flatStrength});
+	if (data.multStrength == 0 and data.flatStrength == 0) outString.print("#ff0000**Far Reaching did not find any multStrength and Flatstrength**", .{});
+}

src/proceduralItem/modifiers/short.zig

@@ -0,0 +1,33 @@
+const std = @import("std");
+
+const main = @import("main");
+const ProceduralItem = main.items.ProceduralItem;
+
+pub const Data = packed struct(u128) { multStrength: f32, flatStrength: f32, pad: u64 = undefined };
+
+pub const priority = 1;
+
+pub fn loadData(zon: main.ZonElement) Data {
+	return .{
+		.multStrength = @max(0, zon.get(f32, "multStrength") orelse 0),
+		.flatStrength = @max(0, zon.get(f32, "flatStrength") orelse 0),
+	};
+}
+
+pub fn combineModifiers(data1: Data, data2: Data) ?Data {
+	return .{
+		.multStrength = std.math.hypot(data1.multStrength, data2.multStrength),
+		.flatStrength = std.math.hypot(data1.flatStrength, data2.flatStrength),
+	};
+}
+
+pub fn changeBlockRange(data: Data) struct { f32, f32 } {
+	return .{data.flatStrength, data.multStrength};
+}
+
+pub fn printTooltip(outString: *main.ListManaged(u8), data: Data) void {
+	if (data.multStrength != 0 and data.flatStrength != 0) outString.print("#f80088**Short**#808080 *Decreases range by **{d:.0}%** and **+{d:.0}**", .{data.multStrength*100, data.flatStrength});
+	if (data.multStrength != 0 and data.flatStrength == 0) outString.print("#f80088**Short**#808080 *Decreases range by **{d:.0}%**", .{data.multStrength*100});
+	if (data.multStrength == 0 and data.flatStrength != 0) outString.print("#f80088**Short**#808080 *Decreases range by **+{d:.0}**", .{data.flatStrength});
+	if (data.multStrength == 0 and data.flatStrength == 0) outString.print("#ff0000**Short did not find any multStrength and Flatstrength**", .{});
+}

src/renderer.zig

@@ -914,13 +914,25 @@ pub const MeshSelection = struct { // MARK: MeshSelection
 	var selectionNormal: Vec3f = undefined;
 	var lastPos: Vec3d = undefined;
 	var lastDir: Vec3f = undefined;
+	fn getSelectRange(baseRange: f64, heldItem: main.items.Item) f64 {
+		var flatRange: f32 = 1;
+		var multRange: f32 = 0;
+		if (heldItem == .proceduralItem) {
+			const flatRangeDiff, const multRangeDiff = heldItem.proceduralItem.getBlockRange();
+			flatRange += flatRangeDiff;
+			multRange = multRange*multRangeDiff;
+		}
+		const range: f64 = (baseRange + flatRange)*multRange;
+		return range;
+	}
 	pub fn select(pos: Vec3d, _dir: Vec3f, item: main.items.Item) void {
 		lastPos = pos;
 		const dir: Vec3d = @floatCast(_dir);
 		lastDir = _dir;
 
 		// Test blocks:
-		const closestDistance: f64 = 6.0; // selection now limited
+		const defaultClosestDistance: f64 = 6.0; // selection now limited
+		const closestDistance: f64 = getSelectRange(defaultClosestDistance, item); // selection now limited
 		// Implementation of "A Fast Voxel Traversal Algorithm for Ray Tracing"  http://www.cse.yorku.ca/~amana/research/grid.pdf
 		const step: Vec3i = std.math.sign(dir);
 		const invDir = @as(Vec3d, @splat(1))/dir;