diff --git a/assets/cubyz/blocks/diamond_ore.zig.zon b/assets/cubyz/blocks/diamond_ore.zig.zon index 8d9c98208a..4744928c37 100644 --- a/assets/cubyz/blocks/diamond_ore.zig.zon +++ b/assets/cubyz/blocks/diamond_ore.zig.zon @@ -42,9 +42,12 @@ .id = "powerful", .strength = 0.5, .restriction = .{ - .id = .encased, - .tag = .precious, - .amount = 4, + .id = .for_each, + .child = .{ + .id = .encased, + .tag = .precious, + .amount = 4, + }, }, }, }, diff --git a/src/items.zig b/src/items.zig index 0984f13239..b3b13a52c2 100644 --- a/src/items.zig +++ b/src/items.zig @@ -78,6 +78,7 @@ const Material = struct { // MARK: Material .vTable = vTable, .data = vTable.loadData(item), .restriction = ModifierRestriction.loadFromZon(allocator, item.getChild("restriction")), + .restrictionPower = 1, }; } } @@ -107,6 +108,11 @@ const Material = struct { // MARK: Material if (modifier.restriction.vTable == modifierRestrictions.get("always").?) { modifier.printTooltip(outString); outString.appendSlice("\n"); + } else if (modifier.restriction.vTable == modifierRestrictions.get("for_each").?) { + modifier.restriction.printTooltip(outString); + outString.appendSlice("\n "); + modifier.printTooltip(outString); + outString.appendSlice("\n"); } else { outString.appendSlice("ยง#808080if "); modifier.restriction.printTooltip(outString); @@ -118,17 +124,24 @@ const Material = struct { // MARK: Material } }; +pub const ModifierRestrictionOutput = struct { + ifSatisfied: bool, + totalItemsChecked: usize, + totalCountedItems: usize, + modifierPower: f32, +}; + pub const ModifierRestriction = struct { vTable: *const VTable, data: *anyopaque, pub const VTable = struct { - satisfied: *const fn (data: *anyopaque, proceduralItem: *const ProceduralItem, x: i32, y: i32) bool, + satisfied: *const fn (data: *anyopaque, proceduralItem: *const ProceduralItem, x: i32, y: i32) ModifierRestrictionOutput, loadFromZon: *const fn (allocator: NeverFailingAllocator, zon: ZonElement) *anyopaque, printTooltip: *const fn (data: *anyopaque, outString: *main.ListManaged(u8)) void, }; - pub fn satisfied(self: ModifierRestriction, proceduralItem: *const ProceduralItem, x: i32, y: i32) bool { + pub fn satisfied(self: ModifierRestriction, proceduralItem: *const ProceduralItem, x: i32, y: i32) ModifierRestrictionOutput { return self.vTable.satisfied(self.data, proceduralItem, x, y); } @@ -153,19 +166,20 @@ const Modifier = struct { data: VTable.Data, restriction: ModifierRestriction, vTable: *const VTable, + restrictionPower: f32, pub const VTable = struct { const Data = packed struct(u128) { pad: u128 }; 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, - printTooltip: *const fn (outString: *main.ListManaged(u8), data: Data) void, + changeProceduralItemParameters: *const fn (proceduralItem: *ProceduralItem, data: Data, restrictionPower: f32) void, + changeBlockDamage: *const fn (damage: f32, block: Block, data: Data, restrictionPower: f32) f32, + printTooltip: *const fn (outString: *main.ListManaged(u8), data: Data, restrictionPower: f32) void, loadData: *const fn (zon: ZonElement) Data, priority: f32, const Defaults = struct { - pub fn changeProceduralItemParameters(_: *ProceduralItem, _: Data) void {} - pub fn changeBlockDamage(damage: f32, _: Block, _: Data) f32 { + pub fn changeProceduralItemParameters(_: *ProceduralItem, _: Data, _: f32) void {} + pub fn changeBlockDamage(damage: f32, _: Block, _: Data, _: f32) f32 { return damage; } }; @@ -188,19 +202,20 @@ const Modifier = struct { .data = a.vTable.combineModifiers(a.data, b.data) orelse return null, .vTable = a.vTable, .restriction = undefined, + .restrictionPower = std.math.hypot(a.restrictionPower, b.restrictionPower), }; } pub fn changeProceduralItemParameters(self: Modifier, proceduralItem: *ProceduralItem) void { - self.vTable.changeProceduralItemParameters(proceduralItem, self.data); + self.vTable.changeProceduralItemParameters(proceduralItem, self.data, self.restrictionPower); } pub fn changeBlockDamage(self: Modifier, damage: f32, block: Block) f32 { - return self.vTable.changeBlockDamage(damage, block, self.data); + return self.vTable.changeBlockDamage(damage, block, self.data, self.restrictionPower); } pub fn printTooltip(self: Modifier, outString: *main.ListManaged(u8)) void { - self.vTable.printTooltip(outString, self.data); + self.vTable.printTooltip(outString, self.data, self.restrictionPower); } }; @@ -484,15 +499,17 @@ const ProceduralItemPhysics = struct { // MARK: ProceduralItemPhysics if (proceduralItem.getProperty(.swingSpeed) < 1) proceduralItem.setProperty(.swingSpeed, 1/(2 - proceduralItem.getProperty(.swingSpeed))); for (0..25) |i| { const material = (proceduralItem.craftingGrid[i] orelse continue).material() orelse continue; - outer: for (material.modifiers) |newMod| { - if (!newMod.restriction.satisfied(proceduralItem, @intCast(i%5), @intCast(i/5))) continue; + outer: for (material.modifiers) |*newMod| { + const checkedRestrictionValues = newMod.restriction.satisfied(proceduralItem, @intCast(i%5), @intCast(i/5)); + if (!checkedRestrictionValues.ifSatisfied) continue; for (tempModifiers.items) |*oldMod| { if (oldMod.vTable == newMod.vTable) { - oldMod.* = oldMod.combineModifiers(newMod) orelse continue; + oldMod.* = oldMod.combineModifiers(newMod.*) orelse continue; continue :outer; } } - tempModifiers.append(main.stackAllocator, newMod); + newMod.restrictionPower = checkedRestrictionValues.modifierPower; + tempModifiers.append(main.stackAllocator, newMod.*); } } std.sort.insertion(Modifier, tempModifiers.items, {}, struct { diff --git a/src/proceduralItem/modifiers/bad_at.zig b/src/proceduralItem/modifiers/bad_at.zig index 2d47a9e440..1addf5e288 100644 --- a/src/proceduralItem/modifiers/bad_at.zig +++ b/src/proceduralItem/modifiers/bad_at.zig @@ -16,9 +16,9 @@ pub fn combineModifiers(data1: Data, data2: Data) ?Data { return .{.strength = 1.0 - 1.0/(1.0 + std.math.hypot(1.0/(1.0 - data1.strength) - 1.0, 1.0/(1.0 - data2.strength) - 1.0)), .tag = data1.tag}; } -pub fn changeBlockDamage(damage: f32, block: main.blocks.Block, data: Data) f32 { +pub fn changeBlockDamage(damage: f32, block: main.blocks.Block, data: Data, restrictionPower: f32) f32 { for (block.tags()) |tag| { - if (tag == data.tag) return damage*(1 - data.strength); + if (tag == data.tag) return damage*(1 - @min(data.strength*restrictionPower, 0)); } return damage; } diff --git a/src/proceduralItem/modifiers/durable.zig b/src/proceduralItem/modifiers/durable.zig index a491af6a55..58d3eeb7ad 100644 --- a/src/proceduralItem/modifiers/durable.zig +++ b/src/proceduralItem/modifiers/durable.zig @@ -15,10 +15,10 @@ pub fn combineModifiers(data1: Data, data2: Data) ?Data { return .{.strength = std.math.hypot(data1.strength, data2.strength)}; } -pub fn changeProceduralItemParameters(proceduralItem: *ProceduralItem, data: Data) void { - proceduralItem.setProperty(.maxDurability, proceduralItem.getProperty(.maxDurability)*(1 + data.strength)); +pub fn changeProceduralItemParameters(proceduralItem: *ProceduralItem, data: Data, restrictionPower: f32) void { + proceduralItem.setProperty(.maxDurability, proceduralItem.getProperty(.maxDurability)*(1 + data.strength*restrictionPower)); } -pub fn printTooltip(outString: *main.ListManaged(u8), data: Data) void { - outString.print("#500090**Durable**#808080 *Increases durability by **{d:.0}%", .{data.strength*100}); +pub fn printTooltip(outString: *main.ListManaged(u8), data: Data, restrictionPower: f32) void { + outString.print("#500090**Durable**#808080 *Increases durability by **{d:.0}%", .{data.strength*100*restrictionPower}); } diff --git a/src/proceduralItem/modifiers/fragile.zig b/src/proceduralItem/modifiers/fragile.zig index 2450f40109..ea3b047235 100644 --- a/src/proceduralItem/modifiers/fragile.zig +++ b/src/proceduralItem/modifiers/fragile.zig @@ -15,10 +15,10 @@ pub fn combineModifiers(data1: Data, data2: Data) ?Data { return .{.strength = 1.0 - 1.0/(1.0 + std.math.hypot(1.0/(1.0 - data1.strength) - 1.0, 1.0/(1.0 - data2.strength) - 1.0))}; } -pub fn changeProceduralItemParameters(proceduralItem: *ProceduralItem, data: Data) void { - proceduralItem.setProperty(.maxDurability, proceduralItem.getProperty(.maxDurability)*(1 - data.strength)); +pub fn changeProceduralItemParameters(proceduralItem: *ProceduralItem, data: Data, restrictionPower: f32) void { + proceduralItem.setProperty(.maxDurability, proceduralItem.getProperty(.maxDurability)*(1 - @min(data.strength*restrictionPower, 0))); } -pub fn printTooltip(outString: *main.ListManaged(u8), data: Data) void { - outString.print("#ccddff**Fragile**#808080 *Decreases durability by **{d:.0}%", .{data.strength*100}); +pub fn printTooltip(outString: *main.ListManaged(u8), data: Data, restrictionPower: f32) void { + outString.print("#ccddff**Fragile**#808080 *Decreases durability by **{d:.0}%", .{@min(data.strength*100*restrictionPower, 100)}); } diff --git a/src/proceduralItem/modifiers/good_at.zig b/src/proceduralItem/modifiers/good_at.zig index a47b969d06..e6a06d1ce1 100644 --- a/src/proceduralItem/modifiers/good_at.zig +++ b/src/proceduralItem/modifiers/good_at.zig @@ -16,13 +16,13 @@ pub fn combineModifiers(data1: Data, data2: Data) ?Data { return .{.strength = std.math.hypot(data1.strength, data2.strength), .tag = data1.tag}; } -pub fn changeBlockDamage(damage: f32, block: main.blocks.Block, data: Data) f32 { +pub fn changeBlockDamage(damage: f32, block: main.blocks.Block, data: Data, restrictionPower: f32) f32 { for (block.tags()) |tag| { - if (tag == data.tag) return damage*(1 + data.strength); + if (tag == data.tag) return damage*(1 + data.strength*restrictionPower); } return damage; } -pub fn printTooltip(outString: *main.ListManaged(u8), data: Data) void { - outString.print("#80ff40**Good at**#808080 *Increases damage by **{d:.0}%** on \n***#80ff40{s}#808080*** blocks", .{data.strength*100, data.tag.getName()}); +pub fn printTooltip(outString: *main.ListManaged(u8), data: Data, restrictionPower: f32) void { + outString.print("#80ff40**Good at**#808080 *Increases damage by **{d:.0}%** on \n***#80ff40{s}#808080*** blocks", .{data.strength*100*restrictionPower, data.tag.getName()}); } diff --git a/src/proceduralItem/modifiers/heavy.zig b/src/proceduralItem/modifiers/heavy.zig index 033a12cb46..232ed15958 100644 --- a/src/proceduralItem/modifiers/heavy.zig +++ b/src/proceduralItem/modifiers/heavy.zig @@ -15,10 +15,10 @@ pub fn combineModifiers(data1: Data, data2: Data) ?Data { return .{.strength = 1.0 - 1.0/(1.0 + std.math.hypot(1.0/(1.0 - data1.strength) - 1.0, 1.0/(1.0 - data2.strength) - 1.0))}; } -pub fn changeProceduralItemParameters(proceduralItem: *ProceduralItem, data: Data) void { - proceduralItem.setProperty(.swingSpeed, proceduralItem.getProperty(.swingSpeed)*(1 - data.strength)); +pub fn changeProceduralItemParameters(proceduralItem: *ProceduralItem, data: Data, restrictionPower: f32) void { + proceduralItem.setProperty(.swingSpeed, proceduralItem.getProperty(.swingSpeed)*(1 - @min(data.strength*restrictionPower, 0))); } -pub fn printTooltip(outString: *main.ListManaged(u8), data: Data) void { - outString.print("#ffcc30**Heavy**#808080 *Decreases swing speed by **{d:.0}%", .{data.strength*100}); +pub fn printTooltip(outString: *main.ListManaged(u8), data: Data, restrictionPower: f32) void { + outString.print("#ffcc30**Heavy**#808080 *Decreases swing speed by **{d:.0}%", .{@min(data.strength*100*restrictionPower, 100)}); } diff --git a/src/proceduralItem/modifiers/light.zig b/src/proceduralItem/modifiers/light.zig index 319e0bc787..932dfb6f56 100644 --- a/src/proceduralItem/modifiers/light.zig +++ b/src/proceduralItem/modifiers/light.zig @@ -15,10 +15,10 @@ pub fn combineModifiers(data1: Data, data2: Data) ?Data { return .{.strength = std.math.hypot(data1.strength, data2.strength)}; } -pub fn changeProceduralItemParameters(proceduralItem: *ProceduralItem, data: Data) void { - proceduralItem.setProperty(.swingSpeed, proceduralItem.getProperty(.swingSpeed)*(1 + data.strength)); +pub fn changeProceduralItemParameters(proceduralItem: *ProceduralItem, data: Data, restrictionPower: f32) void { + proceduralItem.setProperty(.swingSpeed, proceduralItem.getProperty(.swingSpeed)*(1 + data.strength*restrictionPower)); } -pub fn printTooltip(outString: *main.ListManaged(u8), data: Data) void { - outString.print("#9fffde**Light**#808080 *Increases swing speed by **{d:.0}%", .{data.strength*100}); +pub fn printTooltip(outString: *main.ListManaged(u8), data: Data, restrictionPower: f32) void { + outString.print("#9fffde**Light**#808080 *Increases swing speed by **{d:.0}%", .{data.strength*100*restrictionPower}); } diff --git a/src/proceduralItem/modifiers/powerful.zig b/src/proceduralItem/modifiers/powerful.zig index 96b5330356..364c720173 100644 --- a/src/proceduralItem/modifiers/powerful.zig +++ b/src/proceduralItem/modifiers/powerful.zig @@ -15,10 +15,10 @@ pub fn combineModifiers(data1: Data, data2: Data) ?Data { return .{.strength = std.math.hypot(data1.strength, data2.strength)}; } -pub fn changeProceduralItemParameters(proceduralItem: *ProceduralItem, data: Data) void { - proceduralItem.setProperty(.damage, proceduralItem.getProperty(.damage)*(1 + data.strength)); +pub fn changeProceduralItemParameters(proceduralItem: *ProceduralItem, data: Data, restrictionPower: f32) void { + proceduralItem.setProperty(.damage, proceduralItem.getProperty(.damage)*(1 + data.strength*restrictionPower)); } -pub fn printTooltip(outString: *main.ListManaged(u8), data: Data) void { - outString.print("#f84a00**Powerful**#808080 *Increases damage by **{d:.0}%", .{data.strength*100}); +pub fn printTooltip(outString: *main.ListManaged(u8), data: Data, restrictionPower: f32) void { + outString.print("#f84a00**Powerful**#808080 *Increases damage by **{d:.0}%", .{data.strength*100*restrictionPower}); } diff --git a/src/proceduralItem/modifiers/restrictions/_list.zig b/src/proceduralItem/modifiers/restrictions/_list.zig index c77fcf13aa..05514b3db1 100644 --- a/src/proceduralItem/modifiers/restrictions/_list.zig +++ b/src/proceduralItem/modifiers/restrictions/_list.zig @@ -3,3 +3,4 @@ pub const @"and" = @import("and.zig"); pub const encased = @import("encased.zig"); pub const not = @import("not.zig"); pub const @"or" = @import("or.zig"); +pub const for_each = @import("for_each.zig"); diff --git a/src/proceduralItem/modifiers/restrictions/always.zig b/src/proceduralItem/modifiers/restrictions/always.zig index 11a9b8cd36..941d718627 100644 --- a/src/proceduralItem/modifiers/restrictions/always.zig +++ b/src/proceduralItem/modifiers/restrictions/always.zig @@ -4,9 +4,15 @@ const main = @import("main"); const NeverFailingAllocator = main.heap.NeverFailingAllocator; const ProceduralItem = main.items.ProceduralItem; const ZonElement = main.ZonElement; +const ModifierRestrictionOutput = main.items.ModifierRestrictionOutput; -pub fn satisfied(_: *const anyopaque, _: *const ProceduralItem, _: i32, _: i32) bool { - return true; +pub fn satisfied(_: *const anyopaque, _: *const ProceduralItem, _: i32, _: i32) ModifierRestrictionOutput { + return .{ + .ifSatisfied = true, + .totalItemsChecked = 0, + .totalCountedItems = 0, + .modifierPower = 1, + }; } pub fn loadFromZon(_: NeverFailingAllocator, _: ZonElement) *const anyopaque { diff --git a/src/proceduralItem/modifiers/restrictions/and.zig b/src/proceduralItem/modifiers/restrictions/and.zig index e74c9cfefb..e4153933c6 100644 --- a/src/proceduralItem/modifiers/restrictions/and.zig +++ b/src/proceduralItem/modifiers/restrictions/and.zig @@ -5,16 +5,30 @@ const NeverFailingAllocator = main.heap.NeverFailingAllocator; const ModifierRestriction = main.items.ModifierRestriction; const ProceduralItem = main.items.ProceduralItem; const ZonElement = main.ZonElement; +const ModifierRestrictionOutput = main.items.ModifierRestrictionOutput; const And = struct { children: []ModifierRestriction, }; -pub fn satisfied(self: *const And, proceduralItem: *const ProceduralItem, x: i32, y: i32) bool { +pub fn satisfied(self: *const And, proceduralItem: *const ProceduralItem, x: i32, y: i32) ModifierRestrictionOutput { + var combinedIsSatisfied = true; + var combinedtotalCountedItems: usize = 0; + var combinedTotalItemsChecked: usize = 0; + var combinedModifierPower: f32 = 0; for (self.children) |child| { - if (!child.satisfied(proceduralItem, x, y)) return false; + const childValues: ModifierRestrictionOutput = child.satisfied(proceduralItem, x, y); + if (!childValues.ifSatisfied) combinedIsSatisfied = false; + combinedtotalCountedItems += childValues.totalCountedItems; + combinedTotalItemsChecked += childValues.totalItemsChecked; + combinedModifierPower = std.math.hypot(combinedModifierPower, childValues.modifierPower); } - return true; + return .{ + .ifSatisfied = combinedIsSatisfied, + .totalItemsChecked = combinedTotalItemsChecked, + .totalCountedItems = combinedtotalCountedItems, + .modifierPower = combinedModifierPower, + }; } pub fn loadFromZon(allocator: NeverFailingAllocator, zon: ZonElement) *const And { diff --git a/src/proceduralItem/modifiers/restrictions/encased.zig b/src/proceduralItem/modifiers/restrictions/encased.zig index 48894e6613..c5382586fa 100644 --- a/src/proceduralItem/modifiers/restrictions/encased.zig +++ b/src/proceduralItem/modifiers/restrictions/encased.zig @@ -5,20 +5,26 @@ const NeverFailingAllocator = main.heap.NeverFailingAllocator; const ModifierRestriction = main.items.ModifierRestriction; const ProceduralItem = main.items.ProceduralItem; const ZonElement = main.ZonElement; +const ModifierRestrictionOutput = main.items.ModifierRestrictionOutput; const Encased = struct { tag: main.Tag, amount: usize, }; -pub fn satisfied(self: *const Encased, proceduralItem: *const ProceduralItem, x: i32, y: i32) bool { +pub fn satisfied(self: *const Encased, proceduralItem: *const ProceduralItem, x: i32, y: i32) ModifierRestrictionOutput { var count: usize = 0; for ([_]i32{-1, 0, 1}) |dx| { for ([_]i32{-1, 0, 1}) |dy| { if ((proceduralItem.getItemAt(x + dx, y + dy) orelse continue).hasTag(self.tag)) count += 1; } } - return count >= self.amount; + return .{ + .ifSatisfied = count >= self.amount, + .totalItemsChecked = 9, + .totalCountedItems = count, + .modifierPower = 1, + }; } pub fn loadFromZon(allocator: NeverFailingAllocator, zon: ZonElement) *const Encased { @@ -28,11 +34,15 @@ pub fn loadFromZon(allocator: NeverFailingAllocator, zon: ZonElement) *const Enc std.log.err("Missing tag field for encased restriction.", .{}); break :blk "not specified"; }), - .amount = zon.get(usize, "amount") orelse 8, + .amount = zon.get(usize, "amount") orelse 0, }; return result; } pub fn printTooltip(self: *const Encased, outString: *main.ListManaged(u8)) void { - outString.print("encased in {} .{s}", .{self.amount, self.tag.getName()}); + if (self.amount == 0) { + outString.print("encased in .{s}", .{self.tag.getName()}); + } else { + outString.print("encased in {} .{s}", .{self.amount, self.tag.getName()}); + } } diff --git a/src/proceduralItem/modifiers/restrictions/for_each.zig b/src/proceduralItem/modifiers/restrictions/for_each.zig new file mode 100644 index 0000000000..01c01c4036 --- /dev/null +++ b/src/proceduralItem/modifiers/restrictions/for_each.zig @@ -0,0 +1,43 @@ +const std = @import("std"); + +const main = @import("main"); +const NeverFailingAllocator = main.heap.NeverFailingAllocator; +const ModifierRestriction = main.items.ModifierRestriction; +const ProceduralItem = main.items.ProceduralItem; +const ZonElement = main.ZonElement; +const ModifierRestrictionOutput = main.items.ModifierRestrictionOutput; + +const ForEach = struct { + child: ModifierRestriction, +}; + +pub fn satisfied(self: *const ForEach, proceduralItem: *const ProceduralItem, x: i32, y: i32) ModifierRestrictionOutput { + const childValues = self.child.satisfied(proceduralItem, x, y); + const loopCount = childValues.totalCountedItems; + var combinedModifierPower: f32 = 0; + std.log.debug("loop count {}", .{loopCount}); + for (0..loopCount) |i| { + _ = i; + combinedModifierPower = std.math.hypot(combinedModifierPower, 1); + } + std.log.debug("restrictionPower {}", .{combinedModifierPower}); + return .{ + .ifSatisfied = childValues.ifSatisfied, + .totalItemsChecked = childValues.totalItemsChecked, + .totalCountedItems = childValues.totalCountedItems, + .modifierPower = combinedModifierPower, + }; +} + +pub fn loadFromZon(allocator: NeverFailingAllocator, zon: ZonElement) *const ForEach { + const result = allocator.create(ForEach); + result.* = .{ + .child = ModifierRestriction.loadFromZon(allocator, zon.getChild("child")), + }; + return result; +} + +pub fn printTooltip(self: *const ForEach, outString: *main.ListManaged(u8)) void { + outString.appendSlice("for each "); + self.child.printTooltip(outString); +} diff --git a/src/proceduralItem/modifiers/restrictions/not.zig b/src/proceduralItem/modifiers/restrictions/not.zig index 7827f09cbd..7f9100cbc1 100644 --- a/src/proceduralItem/modifiers/restrictions/not.zig +++ b/src/proceduralItem/modifiers/restrictions/not.zig @@ -5,13 +5,20 @@ const NeverFailingAllocator = main.heap.NeverFailingAllocator; const ModifierRestriction = main.items.ModifierRestriction; const ProceduralItem = main.items.ProceduralItem; const ZonElement = main.ZonElement; +const ModifierRestrictionOutput = main.items.ModifierRestrictionOutput; const Not = struct { child: ModifierRestriction, }; -pub fn satisfied(self: *const Not, proceduralItem: *const ProceduralItem, x: i32, y: i32) bool { - return !self.child.satisfied(proceduralItem, x, y); +pub fn satisfied(self: *const Not, proceduralItem: *const ProceduralItem, x: i32, y: i32) ModifierRestrictionOutput { + const childValues = self.child.satisfied(proceduralItem, x, y); + return .{ + .ifSatisfied = !childValues.ifSatisfied, + .totalItemsChecked = childValues.totalItemsChecked, + .totalCountedItems = childValues.totalItemsChecked - childValues.totalCountedItems, + .modifierPower = childValues.modifierPower, + }; } pub fn loadFromZon(allocator: NeverFailingAllocator, zon: ZonElement) *const Not { diff --git a/src/proceduralItem/modifiers/restrictions/or.zig b/src/proceduralItem/modifiers/restrictions/or.zig index d7ea7e2e96..a7585f9367 100644 --- a/src/proceduralItem/modifiers/restrictions/or.zig +++ b/src/proceduralItem/modifiers/restrictions/or.zig @@ -5,16 +5,30 @@ const NeverFailingAllocator = main.heap.NeverFailingAllocator; const ModifierRestriction = main.items.ModifierRestriction; const ProceduralItem = main.items.ProceduralItem; const ZonElement = main.ZonElement; +const ModifierRestrictionOutput = main.items.ModifierRestrictionOutput; const Or = struct { children: []ModifierRestriction, }; -pub fn satisfied(self: *const Or, proceduralItem: *const ProceduralItem, x: i32, y: i32) bool { +pub fn satisfied(self: *const Or, proceduralItem: *const ProceduralItem, x: i32, y: i32) ModifierRestrictionOutput { + var combinedIsSatisfied = false; + var combinedtotalCountedItems: usize = 0; + var combinedTotalItemsChecked: usize = 0; + var combinedModifierPower: f32 = 0; for (self.children) |child| { - if (child.satisfied(proceduralItem, x, y)) return true; + const childValues: ModifierRestrictionOutput = child.satisfied(proceduralItem, x, y); + if (childValues.ifSatisfied) combinedIsSatisfied = true; + combinedtotalCountedItems += childValues.totalCountedItems; + combinedTotalItemsChecked += childValues.totalItemsChecked; + combinedModifierPower = std.math.hypot(combinedModifierPower, childValues.modifierPower); } - return false; + return .{ + .ifSatisfied = combinedIsSatisfied, + .totalItemsChecked = combinedTotalItemsChecked, + .totalCountedItems = combinedtotalCountedItems, + .modifierPower = combinedModifierPower, + }; } pub fn loadFromZon(allocator: NeverFailingAllocator, zon: ZonElement) *const Or { diff --git a/src/proceduralItem/modifiers/single_use.zig b/src/proceduralItem/modifiers/single_use.zig index d82cedeaf1..7a7351c14f 100644 --- a/src/proceduralItem/modifiers/single_use.zig +++ b/src/proceduralItem/modifiers/single_use.zig @@ -15,10 +15,10 @@ pub fn combineModifiers(data1: Data, data2: Data) ?Data { return .{.strength = @min(data1.strength, data2.strength)}; } -pub fn changeProceduralItemParameters(proceduralItem: *ProceduralItem, data: Data) void { - proceduralItem.setProperty(.maxDurability, data.strength); +pub fn changeProceduralItemParameters(proceduralItem: *ProceduralItem, data: Data, restrictionPower: f32) void { + proceduralItem.setProperty(.maxDurability, data.strength*restrictionPower); } -pub fn printTooltip(outString: *main.ListManaged(u8), data: Data) void { - outString.print("#800000**Single-use**#808080 *Sets durability to **{d:.0}", .{data.strength}); +pub fn printTooltip(outString: *main.ListManaged(u8), data: Data, restrictionPower: f32) void { + outString.print("#800000**Single-use**#808080 *Sets durability to **{d:.0}", .{data.strength*restrictionPower}); } diff --git a/src/proceduralItem/modifiers/weak.zig b/src/proceduralItem/modifiers/weak.zig index 6290f5aa22..5bef25a8bd 100644 --- a/src/proceduralItem/modifiers/weak.zig +++ b/src/proceduralItem/modifiers/weak.zig @@ -15,10 +15,10 @@ pub fn combineModifiers(data1: Data, data2: Data) ?Data { return .{.strength = 1.0 - 1.0/(1.0 + std.math.hypot(1.0/(1.0 - data1.strength) - 1.0, 1.0/(1.0 - data2.strength) - 1.0))}; } -pub fn changeProceduralItemParameters(proceduralItem: *ProceduralItem, data: Data) void { - proceduralItem.setProperty(.damage, proceduralItem.getProperty(.damage)*(1 - data.strength)); +pub fn changeProceduralItemParameters(proceduralItem: *ProceduralItem, data: Data, restrictionPower: f32) void { + proceduralItem.setProperty(.damage, proceduralItem.getProperty(.damage)*(1 - @min(data.strength*restrictionPower, 0))); } -pub fn printTooltip(outString: *main.ListManaged(u8), data: Data) void { - outString.print("#fcb5e3**Weak**#808080 *Decreases damage by **{d:.0}%", .{data.strength*100}); +pub fn printTooltip(outString: *main.ListManaged(u8), data: Data, restrictionPower: f32) void { + outString.print("#fcb5e3**Weak**#808080 *Decreases damage by **{d:.0}%", .{@min(data.strength*100*restrictionPower, 100)}); }