From b56bba4a717d60d254d82fabe944044ef5f1cbed Mon Sep 17 00:00:00 2001 From: Samsuik Date: Thu, 6 Jun 2024 21:55:44 +0100 Subject: [PATCH] Add legacy combat mechanics --- build-data/dev-imports.txt | 6 +- .../0003-Sakura-Configuration-Files.patch | 17 +- .../0030-Configure-Entity-Knockback.patch | 17 ++ .../0071-Legacy-player-combat-mechanics.patch | 222 ++++++++++++++++++ .../0072-Allow-disabling-sweep-attacks.patch | 19 ++ ...0073-Change-shields-to-reduce-damage.patch | 24 ++ .../0074-Old-enchanted-golden-apples.patch | 45 ++++ .../0075-Configure-fast-health-regen.patch | 19 ++ ...n-for-fishing-hooks-pulling-entities.patch | 19 ++ 9 files changed, 385 insertions(+), 3 deletions(-) create mode 100644 patches/server/0071-Legacy-player-combat-mechanics.patch create mode 100644 patches/server/0072-Allow-disabling-sweep-attacks.patch create mode 100644 patches/server/0073-Change-shields-to-reduce-damage.patch create mode 100644 patches/server/0074-Old-enchanted-golden-apples.patch create mode 100644 patches/server/0075-Configure-fast-health-regen.patch create mode 100644 patches/server/0076-Add-option-for-fishing-hooks-pulling-entities.patch diff --git a/build-data/dev-imports.txt b/build-data/dev-imports.txt index 4bdb5df..1b60a4d 100644 --- a/build-data/dev-imports.txt +++ b/build-data/dev-imports.txt @@ -17,4 +17,8 @@ minecraft net.minecraft.world.level.block.piston.PistonHeadBlock minecraft net.minecraft.world.level.block.LadderBlock minecraft net.minecraft.world.level.block.Blocks minecraft net.minecraft.world.entity.projectile.ProjectileUtil -minecraft net.minecraft.world.level.block.CarpetBlock \ No newline at end of file +minecraft net.minecraft.world.level.block.CarpetBlock +minecraft net.minecraft.world.item.Item +minecraft net.minecraft.world.item.SwordItem +minecraft net.minecraft.world.item.DiggerItem +minecraft net.minecraft.world.food.Foods \ No newline at end of file diff --git a/patches/server/0003-Sakura-Configuration-Files.patch b/patches/server/0003-Sakura-Configuration-Files.patch index 2c74ed5..fa71bbe 100644 --- a/patches/server/0003-Sakura-Configuration-Files.patch +++ b/patches/server/0003-Sakura-Configuration-Files.patch @@ -647,10 +647,10 @@ index 0000000000000000000000000000000000000000..dd5a70f70c2e7bdc30b8f5655b0b7a08 +} diff --git a/src/main/java/me/samsuik/sakura/configuration/WorldConfiguration.java b/src/main/java/me/samsuik/sakura/configuration/WorldConfiguration.java new file mode 100644 -index 0000000000000000000000000000000000000000..bfac7683f768fbd27ba7f45cdbf964f1dcd0c174 +index 0000000000000000000000000000000000000000..c52187c77d1012e8be494c5171915af4d7c202e4 --- /dev/null +++ b/src/main/java/me/samsuik/sakura/configuration/WorldConfiguration.java -@@ -0,0 +1,204 @@ +@@ -0,0 +1,217 @@ +package me.samsuik.sakura.configuration; + +import com.mojang.logging.LogUtils; @@ -773,6 +773,15 @@ index 0000000000000000000000000000000000000000..bfac7683f768fbd27ba7f45cdbf964f1 + + public Players players; + public class Players extends ConfigurationPart { ++ public Combat combat = new Combat(); ++ public class Combat extends ConfigurationPart { ++ public boolean legacyCombatMechanics = false; ++ public boolean allowSweepAttacks = true; ++ public boolean shieldDamageReduction = false; ++ public boolean oldEnchantedGoldenApple = false; ++ public boolean fastHealthRegen = true; ++ } ++ + public Knockback knockback = new Knockback(); + public class Knockback extends ConfigurationPart { + public DoubleOr.Default knockbackVertical = DoubleOr.Default.USE_DEFAULT; @@ -790,6 +799,9 @@ index 0000000000000000000000000000000000000000..bfac7683f768fbd27ba7f45cdbf964f1 + public IntOr.Default knockbackDelay = IntOr.Default.USE_DEFAULT; + } + ++ @NestedSetting({"projectiles", "fishing-hooks-apply-knockback"}) ++ public boolean fishingHooksApplyKnockback; ++ + @Comment("Knockback resistance attribute modifier") + public double knockbackResistanceModifier = 1.0; + @Comment("Received by attacking a shielded enemy") @@ -798,6 +810,7 @@ index 0000000000000000000000000000000000000000..bfac7683f768fbd27ba7f45cdbf964f1 + + @Comment("Prevents players swimming using elytra or riptide to enter holes") + public boolean posesShrinkCollisionBox = true; ++ public boolean fishingHooksPullEntities = true; + } + + public Entity entity; diff --git a/patches/server/0030-Configure-Entity-Knockback.patch b/patches/server/0030-Configure-Entity-Knockback.patch index 7674064..376364d 100644 --- a/patches/server/0030-Configure-Entity-Knockback.patch +++ b/patches/server/0030-Configure-Entity-Knockback.patch @@ -115,3 +115,20 @@ index 74dcfabdc66ef289b8d6a5c6606579b5321af1db..ddf9acf79356d6fff5caa436f6764151 } // CraftBukkit end } +diff --git a/src/main/java/net/minecraft/world/entity/projectile/FishingHook.java b/src/main/java/net/minecraft/world/entity/projectile/FishingHook.java +index 91497f5e6c07fcf1b05eca6846c51e1a15ed3bc0..ba906ceb807b21c01cf4d3c0122f626959f6e775 100644 +--- a/src/main/java/net/minecraft/world/entity/projectile/FishingHook.java ++++ b/src/main/java/net/minecraft/world/entity/projectile/FishingHook.java +@@ -298,6 +298,12 @@ public class FishingHook extends Projectile { + this.setHookedEntity(entityHitResult.getEntity()); + } + ++ // Sakura start - configure entity knockback ++ if (this.level().sakuraConfig().players.knockback.fishingHooksApplyKnockback) { ++ Entity entity = entityHitResult.getEntity(); ++ entity.hurt(this.damageSources().thrown(this, this.getOwner()), 0.0f); ++ } ++ // Sakura end - configure entity knockback + } + + @Override diff --git a/patches/server/0071-Legacy-player-combat-mechanics.patch b/patches/server/0071-Legacy-player-combat-mechanics.patch new file mode 100644 index 0000000..6832d7c --- /dev/null +++ b/patches/server/0071-Legacy-player-combat-mechanics.patch @@ -0,0 +1,222 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Samsuik +Date: Fri, 23 Feb 2024 01:48:08 +0000 +Subject: [PATCH] Legacy player combat mechanics + + +diff --git a/src/main/java/me/samsuik/sakura/utils/CombatUtil.java b/src/main/java/me/samsuik/sakura/utils/CombatUtil.java +new file mode 100644 +index 0000000000000000000000000000000000000000..6cda6ba8e29587fd04b727ef188484760c4ccdbd +--- /dev/null ++++ b/src/main/java/me/samsuik/sakura/utils/CombatUtil.java +@@ -0,0 +1,37 @@ ++package me.samsuik.sakura.utils; ++ ++import it.unimi.dsi.fastutil.objects.*; ++import net.minecraft.core.registries.BuiltInRegistries; ++import net.minecraft.world.item.*; ++ ++public final class CombatUtil { ++ private static final Reference2FloatMap LEGACY_ITEM_DAMAGE_MAP = new Reference2FloatOpenHashMap<>(); ++ ++ public static float getLegacyItemDamage(Item item) { ++ return LEGACY_ITEM_DAMAGE_MAP.getFloat(item); ++ } ++ ++ private static float baseToolDamage(TieredItem item) { ++ if (item instanceof SwordItem) return 4.0f; ++ else if (item instanceof AxeItem) return 3.0f; ++ else if (item instanceof PickaxeItem) return 2.0f; ++ else if (item instanceof ShovelItem) return 1.0f; ++ else return 0.0f; ++ } ++ ++ static { ++ LEGACY_ITEM_DAMAGE_MAP.defaultReturnValue(Float.MIN_VALUE); ++ ++ for (Item item : BuiltInRegistries.ITEM) { ++ if (item instanceof TieredItem tieredItem) { ++ LEGACY_ITEM_DAMAGE_MAP.put(item, baseToolDamage(tieredItem) + tieredItem.getTier().getAttackDamageBonus()); ++ } ++ ++ if (item instanceof HoeItem) { ++ LEGACY_ITEM_DAMAGE_MAP.put(item, 0.0f); ++ } ++ } ++ ++ //LEGACY_ITEM_DAMAGE_MAP.put(Items.TRIDENT, LEGACY_ITEM_DAMAGE_MAP.getFloat(Items.DIAMOND_SWORD)); ++ } ++} +diff --git a/src/main/java/net/minecraft/world/entity/LivingEntity.java b/src/main/java/net/minecraft/world/entity/LivingEntity.java +index 9fa79ba7f50fa20f3794fd955db1a4cc0fa8ee02..532fef2f50a0904a7c64bac30aa61dc71fcfc7dd 100644 +--- a/src/main/java/net/minecraft/world/entity/LivingEntity.java ++++ b/src/main/java/net/minecraft/world/entity/LivingEntity.java +@@ -276,6 +276,64 @@ public abstract class LivingEntity extends Entity implements Attackable { + ++this.noActionTime; // Above all the floats + } + // Spigot end ++ // Sakura start - legacy combat mechanics ++ private static final UUID LEGACY_COMBAT_MECHANICS_UUID = UUID.fromString("84ef96f8-9f48-4ae4-a26c-e04551324816"); ++ private static final AttributeModifier LEGACY_ATTACK_SPEED_MODIFIER = new AttributeModifier(LEGACY_COMBAT_MECHANICS_UUID, "Legacy attack speed", 100.0, AttributeModifier.Operation.ADDITION); ++ ++ private void updateAttackSpeedModifier() { ++ AttributeInstance attackSpeed = this.getAttribute(Attributes.ATTACK_SPEED); ++ if (attackSpeed != null) { ++ attackSpeed.removeModifier(LEGACY_ATTACK_SPEED_MODIFIER); ++ ++ if (this.level().sakuraConfig().players.combat.legacyCombatMechanics) { ++ attackSpeed.addTransientModifier(LEGACY_ATTACK_SPEED_MODIFIER); ++ } ++ } ++ } ++ ++ protected final float getAttackDamageFromAttributes() { ++ AttributeInstance attackDamage = this.getAttribute(Attributes.ATTACK_DAMAGE); ++ AttributeModifier legacyModifier = null; ++ ++ if (this.level().sakuraConfig().players.combat.legacyCombatMechanics) { ++ legacyModifier = this.getLegacyAttackModifier(); ++ } ++ ++ final double damage; ++ if (attackDamage == null || legacyModifier == null) { ++ damage = this.getAttributeValue(Attributes.ATTACK_DAMAGE); ++ } else { ++ attackDamage.addTransientModifier(legacyModifier); ++ damage = this.getAttributeValue(Attributes.ATTACK_DAMAGE); ++ attackDamage.removeModifier(legacyModifier); ++ } ++ ++ return (float) damage; ++ } ++ ++ private @Nullable AttributeModifier getLegacyAttackModifier() { ++ ItemStack itemstack = this.getLastHandItem(EquipmentSlot.MAINHAND); ++ qt: if (!itemstack.hasTag() || !itemstack.getTag().contains("AttributeModifiers", 9)) { ++ Collection defaultModifiers = itemstack.getAttributeModifiers(EquipmentSlot.MAINHAND).get(Attributes.ATTACK_DAMAGE); ++ double baseAttack = 0.0f; ++ for (AttributeModifier mod : defaultModifiers) { ++ if (mod.getOperation() != AttributeModifier.Operation.ADDITION) { ++ break qt; ++ } ++ ++ baseAttack += mod.getAmount(); ++ } ++ ++ float legacyAttack = me.samsuik.sakura.utils.CombatUtil.getLegacyItemDamage(itemstack.getItem()); ++ double attackDifference = (double) legacyAttack - baseAttack; ++ ++ if (baseAttack != 0.0f && legacyAttack != Float.MIN_VALUE) { ++ return new AttributeModifier(LEGACY_COMBAT_MECHANICS_UUID, "Legacy attack damage", attackDifference, AttributeModifier.Operation.ADDITION); ++ } ++ } ++ return null; ++ } ++ // Sakura end - legacy combat mechanics + + protected LivingEntity(EntityType type, Level world) { + super(type, world); +@@ -2145,7 +2203,16 @@ public abstract class LivingEntity extends Entity implements Attackable { + protected float getDamageAfterArmorAbsorb(DamageSource source, float amount) { + if (!source.is(DamageTypeTags.BYPASSES_ARMOR)) { + // this.hurtArmor(damagesource, f); // CraftBukkit - Moved into actuallyHurt(DamageSource, float) ++ // Sakura start - legacy combat mechanics ++ if (!this.level().sakuraConfig().players.combat.legacyCombatMechanics) { + amount = CombatRules.getDamageAfterAbsorb(amount, (float) this.getArmorValue(), (float) this.getAttributeValue(Attributes.ARMOR_TOUGHNESS)); ++ } else { ++ // See: applyArmorModifier(DamageSource, float) ++ int i = 25 - this.getArmorValue(); ++ float f1 = amount * (float) i; ++ amount = f1 / 25.0F; ++ } ++ // Sakura end - legacy combat mechanics + } + + return amount; +@@ -3201,6 +3268,12 @@ public abstract class LivingEntity extends Entity implements Attackable { + if (!itemstack1.isEmpty()) { + this.getAttributes().addTransientAttributeModifiers(itemstack1.getAttributeModifiers(enumitemslot)); + } ++ ++ // Sakura start - legacy combat mechanics ++ if (this instanceof ServerPlayer && enumitemslot == EquipmentSlot.MAINHAND) { ++ this.updateAttackSpeedModifier(); ++ } ++ // Sakura end - legacy combat mechanics + } + } + +@@ -3354,7 +3427,7 @@ public abstract class LivingEntity extends Entity implements Attackable { + this.lastArmorItemStacks.set(slot.getIndex(), armor); + } + +- private ItemStack getLastHandItem(EquipmentSlot slot) { ++ protected ItemStack getLastHandItem(EquipmentSlot slot) { // Sakura - legacy combat mechanics + return (ItemStack) this.lastHandItemStacks.get(slot.getIndex()); + } + +diff --git a/src/main/java/net/minecraft/world/entity/player/Player.java b/src/main/java/net/minecraft/world/entity/player/Player.java +index 8493566fec47ecef3fd7423b993d9e6e378df7e5..7f2b778706bdc1d24b97c53ac9278439a4a03d36 100644 +--- a/src/main/java/net/minecraft/world/entity/player/Player.java ++++ b/src/main/java/net/minecraft/world/entity/player/Player.java +@@ -1255,7 +1255,7 @@ public abstract class Player extends LivingEntity { + if (playerAttackEntityEvent.callEvent() && willAttack) { // Logic moved to willAttack local variable. + { + // Paper end - PlayerAttackEntityEvent +- float f = (float) this.getAttributeValue(Attributes.ATTACK_DAMAGE); ++ float f = this.getAttackDamageFromAttributes(); // Sakura - legacy combat mechanics + float f1; + + if (target instanceof LivingEntity) { +@@ -1266,8 +1266,14 @@ public abstract class Player extends LivingEntity { + + float f2 = this.getAttackStrengthScale(0.5F); + ++ // Sakura start - legacy combat mechanics ++ if (!this.level().sakuraConfig().players.combat.legacyCombatMechanics) { + f *= 0.2F + f2 * f2 * 0.8F; + f1 *= f2; ++ } else if (f1 != 0.0) { ++ f1 += this.calculateLegacySharpnessDamage(); ++ } ++ // Sakura end - legacy combat mechanics + // this.resetAttackCooldown(); // CraftBukkit - Moved to EntityLiving to reset the cooldown after the damage is dealt + if (f > 0.0F || f1 > 0.0F) { + boolean flag = f2 > 0.9F; +@@ -1284,7 +1290,7 @@ public abstract class Player extends LivingEntity { + boolean flag2 = flag && this.fallDistance > 0.0F && !this.onGround() && !this.onClimbable() && !this.isInWater() && !this.hasEffect(MobEffects.BLINDNESS) && !this.isPassenger() && target instanceof LivingEntity; // Paper - Add critical damage API; diff on change + + flag2 = flag2 && !this.level().paperConfig().entities.behavior.disablePlayerCrits; // Paper - Toggleable player crits +- flag2 = flag2 && !this.isSprinting(); ++ flag2 = flag2 && (this.level().sakuraConfig().players.combat.legacyCombatMechanics || !this.isSprinting()); // Sakura - legacy combat mechanics + if (flag2) { + f *= 1.5F; + } +@@ -1476,6 +1482,27 @@ public abstract class Player extends LivingEntity { + } + } + ++ // Sakura start - legacy combat mechanics ++ private float calculateLegacySharpnessDamage() { ++ ItemStack itemstack = this.getMainHandItem(); ++ Map enchantments = EnchantmentHelper.getEnchantments(itemstack); ++ ++ float legacy = 0.0f; ++ float modern = 0.0f; ++ ++ for (Map.Entry entry : enchantments.entrySet()) { ++ if (entry.getKey() instanceof net.minecraft.world.item.enchantment.DamageEnchantment dmgEnchant && dmgEnchant.type == 0) { ++ // sharpness: ++ int level = entry.getValue(); ++ legacy += (float) level * 1.25F; ++ modern += dmgEnchant.getDamageBonus(level, MobType.UNDEFINED); ++ } ++ } ++ ++ return legacy - modern; ++ } ++ // Sakura end - legacy combat mechanics ++ + @Override + protected void doAutoAttackOnTouch(LivingEntity target) { + this.attack(target); diff --git a/patches/server/0072-Allow-disabling-sweep-attacks.patch b/patches/server/0072-Allow-disabling-sweep-attacks.patch new file mode 100644 index 0000000..dc6359d --- /dev/null +++ b/patches/server/0072-Allow-disabling-sweep-attacks.patch @@ -0,0 +1,19 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Samsuik +Date: Fri, 23 Feb 2024 01:49:20 +0000 +Subject: [PATCH] Allow disabling sweep attacks + + +diff --git a/src/main/java/net/minecraft/world/entity/player/Player.java b/src/main/java/net/minecraft/world/entity/player/Player.java +index cef878d0876cf5eef8ce4bf220b50d21f64ad597..b613a0843a6a71ad80bdedb407d0402ec788a6f3 100644 +--- a/src/main/java/net/minecraft/world/entity/player/Player.java ++++ b/src/main/java/net/minecraft/world/entity/player/Player.java +@@ -1361,7 +1361,7 @@ public abstract class Player extends LivingEntity { + // Paper end - Configurable sprint interruption on attack + } + +- if (flag3) { ++ if (flag3 && this.level().sakuraConfig().players.combat.allowSweepAttacks) { // Sakura - allow disabling sweep attacks + float f4 = 1.0F + EnchantmentHelper.getSweepingDamageRatio(this) * f; + List list = this.level().getEntitiesOfClass(LivingEntity.class, target.getBoundingBox().inflate(1.0D, 0.25D, 1.0D)); + Iterator iterator = list.iterator(); diff --git a/patches/server/0073-Change-shields-to-reduce-damage.patch b/patches/server/0073-Change-shields-to-reduce-damage.patch new file mode 100644 index 0000000..5caa3b0 --- /dev/null +++ b/patches/server/0073-Change-shields-to-reduce-damage.patch @@ -0,0 +1,24 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Samsuik +Date: Fri, 23 Feb 2024 02:07:03 +0000 +Subject: [PATCH] Change shields to reduce damage + + +diff --git a/src/main/java/net/minecraft/world/entity/LivingEntity.java b/src/main/java/net/minecraft/world/entity/LivingEntity.java +index 532fef2f50a0904a7c64bac30aa61dc71fcfc7dd..0adf993b1b03b4e68d83e67872c0f592c2d7c91f 100644 +--- a/src/main/java/net/minecraft/world/entity/LivingEntity.java ++++ b/src/main/java/net/minecraft/world/entity/LivingEntity.java +@@ -2279,7 +2279,13 @@ public abstract class LivingEntity extends Entity implements Attackable { + Function blocking = new Function() { + @Override + public Double apply(Double f) { ++ // Sakura start - shield damage reduction ++ if (!level().sakuraConfig().players.combat.shieldDamageReduction || damagesource.getDirectEntity() instanceof AbstractArrow) { + return -((LivingEntity.this.isDamageSourceBlocked(damagesource)) ? f : 0.0); ++ } else { ++ return -(LivingEntity.this.isBlocking() ? f * 0.5 : 0.0); ++ } ++ // Sakura end - shield damage reduction + } + }; + float blockingModifier = blocking.apply((double) f).floatValue(); diff --git a/patches/server/0074-Old-enchanted-golden-apples.patch b/patches/server/0074-Old-enchanted-golden-apples.patch new file mode 100644 index 0000000..1e5eeb0 --- /dev/null +++ b/patches/server/0074-Old-enchanted-golden-apples.patch @@ -0,0 +1,45 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Samsuik +Date: Fri, 23 Feb 2024 14:40:32 +0000 +Subject: [PATCH] Old enchanted golden apples + + +diff --git a/src/main/java/net/minecraft/world/entity/LivingEntity.java b/src/main/java/net/minecraft/world/entity/LivingEntity.java +index 0adf993b1b03b4e68d83e67872c0f592c2d7c91f..99bc5f6665524dfb42d7e7dd3f71fb45147b3b58 100644 +--- a/src/main/java/net/minecraft/world/entity/LivingEntity.java ++++ b/src/main/java/net/minecraft/world/entity/LivingEntity.java +@@ -4523,7 +4523,13 @@ public abstract class LivingEntity extends Entity implements Attackable { + Item item = stack.getItem(); + + if (item.isEdible()) { +- List> list = item.getFoodProperties().getEffects(); ++ // Sakura start - old enchanted golden apple ++ FoodProperties food = item.getFoodProperties(); ++ if (this.level().sakuraConfig().players.combat.oldEnchantedGoldenApple && item.getFoodProperties() == net.minecraft.world.food.Foods.ENCHANTED_GOLDEN_APPLE) { ++ food = net.minecraft.world.food.Foods.LEGACY_ENCHANTED_GOLDEN_APPLE; ++ } ++ List> list = food.getEffects(); ++ // Sakura end - old enchanted golden apple + Iterator iterator = list.iterator(); + + while (iterator.hasNext()) { +diff --git a/src/main/java/net/minecraft/world/food/Foods.java b/src/main/java/net/minecraft/world/food/Foods.java +index 4569cf30b33167a415256a8542820557ad38f89e..2851125fcb2c2ddade0d82b9a3d303c069a1a06f 100644 +--- a/src/main/java/net/minecraft/world/food/Foods.java ++++ b/src/main/java/net/minecraft/world/food/Foods.java +@@ -37,6 +37,15 @@ public class Foods { + .effect(new MobEffectInstance(MobEffects.ABSORPTION, 2400, 3), 1.0F) + .alwaysEat() + .build(); ++ public static final FoodProperties LEGACY_ENCHANTED_GOLDEN_APPLE = new FoodProperties.Builder() ++ .nutrition(4) ++ .saturationMod(1.2F) ++ .effect(new MobEffectInstance(MobEffects.REGENERATION, 600, 4), 1.0F) ++ .effect(new MobEffectInstance(MobEffects.DAMAGE_RESISTANCE, 6000, 0), 1.0F) ++ .effect(new MobEffectInstance(MobEffects.FIRE_RESISTANCE, 6000, 0), 1.0F) ++ .effect(new MobEffectInstance(MobEffects.ABSORPTION, 2400, 0), 1.0F) ++ .alwaysEat() ++ .build(); + public static final FoodProperties GOLDEN_APPLE = new FoodProperties.Builder() + .nutrition(4) + .saturationMod(1.2F) diff --git a/patches/server/0075-Configure-fast-health-regen.patch b/patches/server/0075-Configure-fast-health-regen.patch new file mode 100644 index 0000000..fb5bb34 --- /dev/null +++ b/patches/server/0075-Configure-fast-health-regen.patch @@ -0,0 +1,19 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Samsuik +Date: Thu, 6 Jun 2024 18:18:28 +0100 +Subject: [PATCH] Configure fast health regen + + +diff --git a/src/main/java/net/minecraft/world/food/FoodData.java b/src/main/java/net/minecraft/world/food/FoodData.java +index c3448707fd8a632b457cc97b35d08a9c6933d5ee..4c7e4c463167ab17ff15236e08b84d7ef317c38d 100644 +--- a/src/main/java/net/minecraft/world/food/FoodData.java ++++ b/src/main/java/net/minecraft/world/food/FoodData.java +@@ -78,7 +78,7 @@ public class FoodData { + + boolean flag = player.level().getGameRules().getBoolean(GameRules.RULE_NATURAL_REGENERATION); + +- if (flag && this.saturationLevel > 0.0F && player.isHurt() && this.foodLevel >= 20) { ++ if (flag && this.saturationLevel > 0.0F && player.isHurt() && this.foodLevel >= 20 && player.level().sakuraConfig().players.combat.fastHealthRegen) { // Sakura - configure fast health regen + ++this.tickTimer; + if (this.tickTimer >= this.saturatedRegenRate) { // CraftBukkit + float f = Math.min(this.saturationLevel, 6.0F); diff --git a/patches/server/0076-Add-option-for-fishing-hooks-pulling-entities.patch b/patches/server/0076-Add-option-for-fishing-hooks-pulling-entities.patch new file mode 100644 index 0000000..b0f1056 --- /dev/null +++ b/patches/server/0076-Add-option-for-fishing-hooks-pulling-entities.patch @@ -0,0 +1,19 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Samsuik +Date: Thu, 6 Jun 2024 20:34:29 +0100 +Subject: [PATCH] Add option for fishing hooks pulling entities + + +diff --git a/src/main/java/net/minecraft/world/entity/projectile/FishingHook.java b/src/main/java/net/minecraft/world/entity/projectile/FishingHook.java +index ba906ceb807b21c01cf4d3c0122f626959f6e775..075a3b7ae760e73ef5674de80b6e37b5158f3e43 100644 +--- a/src/main/java/net/minecraft/world/entity/projectile/FishingHook.java ++++ b/src/main/java/net/minecraft/world/entity/projectile/FishingHook.java +@@ -598,7 +598,7 @@ public class FishingHook extends Projectile { + public void pullEntity(Entity entity) { + Entity entity1 = this.getOwner(); + +- if (entity1 != null) { ++ if (entity1 != null && (this.level().sakuraConfig().players.fishingHooksPullEntities || entity instanceof ItemEntity)) { // Sakura - Add option for fishing hooks pulling entities + Vec3 vec3d = (new Vec3(entity1.getX() - this.getX(), entity1.getY() - this.getY(), entity1.getZ() - this.getZ())).scale(0.1D); + + entity.setDeltaMovement(entity.getDeltaMovement().add(vec3d));