Mirrors/Purpur
1
0
Fork 1
mirror of https://github.com/PurpurMC/Purpur.git synced 2026-02-17 08:27:43 +01:00
Code Issues Packages Projects Releases Wiki Activity

port Ridables patches

Browse Source
This commit is contained in:
granny
2025-01-04 01:27:30 -08:00
committed by granny
parent df947a7e81
commit b739a95b1e
24 changed files with 2633 additions and 2759 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
.gitignore vendored
View File

@@ -52,7 +52,6 @@ manifest.mf
# other stuff
/run
build-data/
/purpur-server/build.gradle.kts
/purpur-server/src/minecraft
/paper-server

3
build-data/purpur.at Normal file
View File

@@ -0,0 +1,3 @@
# This file is auto generated, any changes may be overridden!
# See CONTRIBUTING.md on how to add access transformers.
protected net.minecraft.world.entity.Entity dimensions

196
patches/api/0006-Ridables.patch
View File

@@ -1,196 +0,0 @@
From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
From: William Blake Galbreath <blake.galbreath@gmail.com>
Date: Sat, 4 May 2019 00:57:16 -0500
Subject: [PATCH] Ridables
diff --git a/src/main/java/org/bukkit/entity/Entity.java b/src/main/java/org/bukkit/entity/Entity.java
index 19272cff8d6d040e95b2644d70acdac606e06c16..5603ecc5d8f6ccf29333e1c47db3af36379a27d6 100644
--- a/src/main/java/org/bukkit/entity/Entity.java
+++ b/src/main/java/org/bukkit/entity/Entity.java
@@ -1172,4 +1172,35 @@ public interface Entity extends Metadatable, CommandSender, Nameable, Persistent
*/
void broadcastHurtAnimation(@NotNull java.util.Collection<Player> players);
// Paper end - broadcast hurt animation
+
+ // Purpur start
+ /**
+ * Get the riding player
+ *
+ * @return Riding player
+ */
+ @Nullable
+ Player getRider();
+
+ /**
+ * Check if entity is being ridden
+ *
+ * @return True if being ridden
+ */
+ boolean hasRider();
+
+ /**
+ * Check if entity is ridable
+ *
+ * @return True if ridable
+ */
+ boolean isRidable();
+
+ /**
+ * Check if entity is ridable in water
+ *
+ * @return True if ridable in water
+ */
+ boolean isRidableInWater();
+ // Purpur end
}
diff --git a/src/main/java/org/purpurmc/purpur/event/entity/RidableMoveEvent.java b/src/main/java/org/purpurmc/purpur/event/entity/RidableMoveEvent.java
new file mode 100644
index 0000000000000000000000000000000000000000..c31a656daa3df1ab87302d8f14110a828c920102
--- /dev/null
+++ b/src/main/java/org/purpurmc/purpur/event/entity/RidableMoveEvent.java
@@ -0,0 +1,100 @@
+package org.purpurmc.purpur.event.entity;
+
+import com.google.common.base.Preconditions;
+import org.bukkit.Location;
+import org.bukkit.entity.Mob;
+import org.bukkit.entity.Player;
+import org.bukkit.event.Cancellable;
+import org.bukkit.event.HandlerList;
+import org.bukkit.event.entity.EntityEvent;
+import org.jetbrains.annotations.ApiStatus;
+import org.jspecify.annotations.NullMarked;
+
+/**
+ * Triggered when a ridable mob moves with a rider
+ */
+@NullMarked
+public class RidableMoveEvent extends EntityEvent implements Cancellable {
+ private static final HandlerList handlers = new HandlerList();
+ private boolean canceled;
+ private final Player rider;
+ private Location from;
+ private Location to;
+
+ @ApiStatus.Internal
+ public RidableMoveEvent(Mob entity, Player rider, Location from, Location to) {
+ super(entity);
+ this.rider = rider;
+ this.from = from;
+ this.to = to;
+ }
+
+ @Override
+ public Mob getEntity() {
+ return (Mob) entity;
+ }
+
+ public Player getRider() {
+ return rider;
+ }
+
+ public boolean isCancelled() {
+ return canceled;
+ }
+
+ public void setCancelled(boolean cancel) {
+ canceled = cancel;
+ }
+
+ /**
+ * Gets the location this entity moved from
+ *
+ * @return Location the entity moved from
+ */
+ public Location getFrom() {
+ return from;
+ }
+
+ /**
+ * Sets the location to mark as where the entity moved from
+ *
+ * @param from New location to mark as the entity's previous location
+ */
+ public void setFrom(Location from) {
+ validateLocation(from);
+ this.from = from;
+ }
+
+ /**
+ * Gets the location this entity moved to
+ *
+ * @return Location the entity moved to
+ */
+ public Location getTo() {
+ return to;
+ }
+
+ /**
+ * Sets the location that this entity will move to
+ *
+ * @param to New Location this entity will move to
+ */
+ public void setTo(Location to) {
+ validateLocation(to);
+ this.to = to;
+ }
+
+ private void validateLocation(Location loc) {
+ Preconditions.checkArgument(loc != null, "Cannot use null location!");
+ Preconditions.checkArgument(loc.getWorld() != null, "Cannot use null location with null world!");
+ }
+
+ @Override
+ public HandlerList getHandlers() {
+ return handlers;
+ }
+
+ public static HandlerList getHandlerList() {
+ return handlers;
+ }
+}
diff --git a/src/main/java/org/purpurmc/purpur/event/entity/RidableSpacebarEvent.java b/src/main/java/org/purpurmc/purpur/event/entity/RidableSpacebarEvent.java
new file mode 100644
index 0000000000000000000000000000000000000000..02de629f066ef7d4898b3053efa957edeea16a3f
--- /dev/null
+++ b/src/main/java/org/purpurmc/purpur/event/entity/RidableSpacebarEvent.java
@@ -0,0 +1,38 @@
+package org.purpurmc.purpur.event.entity;
+
+import org.bukkit.entity.Entity;
+import org.bukkit.event.Cancellable;
+import org.bukkit.event.HandlerList;
+import org.bukkit.event.entity.EntityEvent;
+import org.jetbrains.annotations.ApiStatus;
+import org.jspecify.annotations.NullMarked;
+
+@NullMarked
+public class RidableSpacebarEvent extends EntityEvent implements Cancellable {
+ private static final HandlerList handlers = new HandlerList();
+ private boolean cancelled;
+
+ @ApiStatus.Internal
+ public RidableSpacebarEvent(Entity entity) {
+ super(entity);
+ }
+
+ @Override
+ public boolean isCancelled() {
+ return cancelled;
+ }
+
+ @Override
+ public void setCancelled(boolean cancel) {
+ cancelled = cancel;
+ }
+
+ @Override
+ public HandlerList getHandlers() {
+ return handlers;
+ }
+
+ public static HandlerList getHandlerList() {
+ return handlers;
+ }
+}

23
patches/generated-api/0001-Ridables.patch
View File

@@ -1,23 +0,0 @@
From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
From: William Blake Galbreath <blake.galbreath@gmail.com>
Date: Sat, 4 May 2019 00:57:16 -0500
Subject: [PATCH] Ridables
diff --git a/com/destroystokyo/paper/entity/ai/VanillaGoal.java b/com/destroystokyo/paper/entity/ai/VanillaGoal.java
index f15a7b4471cd31a487467ec7ecf7a186fa887a51..9b9eb256c4f17693e717e87e62a2e61b928f073a 100644
--- a/com/destroystokyo/paper/entity/ai/VanillaGoal.java
+++ b/com/destroystokyo/paper/entity/ai/VanillaGoal.java
@@ -441,6 +441,12 @@ public interface VanillaGoal<T extends Mob> extends Goal<T> {
GoalKey<Zombie> ZOMBIE_ATTACK_TURTLE_EGG = create("zombie_attack_turtle_egg", Zombie.class);
+ // Purpur start
+ GoalKey<Mob> MOB_HAS_RIDER = GoalKey.of(Mob.class, NamespacedKey.minecraft("has_rider"));
+ GoalKey<AbstractHorse> HORSE_HAS_RIDER = GoalKey.of(AbstractHorse.class, NamespacedKey.minecraft("horse_has_rider"));
+ GoalKey<Llama> LLAMA_HAS_RIDER = GoalKey.of(Llama.class, NamespacedKey.minecraft("llama_has_rider"));
+ // Purpur end
+
private static <T extends Mob> GoalKey<T> create(final String key, final Class<T> type) {
return GoalKey.of(type, NamespacedKey.minecraft(key));
}

15
purpur-api-generator/paper-patches/files/generated/com/destroystokyo/paper/entity/ai/VanillaGoal.java.patch Normal file
View File

@@ -0,0 +1,15 @@
--- a/generated/com/destroystokyo/paper/entity/ai/VanillaGoal.java
+++ b/generated/com/destroystokyo/paper/entity/ai/VanillaGoal.java
@@ -441,6 +_,12 @@
GoalKey<Zombie> ZOMBIE_ATTACK_TURTLE_EGG = create("zombie_attack_turtle_egg", Zombie.class);
+ // Purpur start - Ridables
+ GoalKey<Mob> MOB_HAS_RIDER = GoalKey.of(Mob.class, NamespacedKey.minecraft("has_rider"));
+ GoalKey<AbstractHorse> HORSE_HAS_RIDER = GoalKey.of(AbstractHorse.class, NamespacedKey.minecraft("horse_has_rider"));
+ GoalKey<Llama> LLAMA_HAS_RIDER = GoalKey.of(Llama.class, NamespacedKey.minecraft("llama_has_rider"));
+ // Purpur end - Ridables
+
private static <T extends Mob> GoalKey<T> create(final String key, final Class<T> type) {
return GoalKey.of(type, NamespacedKey.minecraft(key));
}

38
purpur-api/paper-patches/files/src/main/java/org/bukkit/entity/Entity.java.patch Normal file
View File

@@ -0,0 +1,38 @@
--- a/src/main/java/org/bukkit/entity/Entity.java
+++ b/src/main/java/org/bukkit/entity/Entity.java
@@ -1172,4 +_,35 @@
*/
void broadcastHurtAnimation(@NotNull java.util.Collection<Player> players);
// Paper end - broadcast hurt animation
+
+ // Purpur start - Ridables
+ /**
+ * Get the riding player
+ *
+ * @return Riding player
+ */
+ @Nullable
+ Player getRider();
+
+ /**
+ * Check if entity is being ridden
+ *
+ * @return True if being ridden
+ */
+ boolean hasRider();
+
+ /**
+ * Check if entity is ridable
+ *
+ * @return True if ridable
+ */
+ boolean isRidable();
+
+ /**
+ * Check if entity is ridable in water
+ *
+ * @return True if ridable in water
+ */
+ boolean isRidableInWater();
+ // Purpur end - Ridables
}

100
purpur-api/src/main/java/org/purpurmc/purpur/event/entity/RidableMoveEvent.java Normal file
View File

@@ -0,0 +1,100 @@
package org.purpurmc.purpur.event.entity;
import com.google.common.base.Preconditions;
import org.bukkit.Location;
import org.bukkit.entity.Mob;
import org.bukkit.entity.Player;
import org.bukkit.event.Cancellable;
import org.bukkit.event.HandlerList;
import org.bukkit.event.entity.EntityEvent;
import org.jetbrains.annotations.ApiStatus;
import org.jspecify.annotations.NullMarked;
/**
* Triggered when a ridable mob moves with a rider
*/
@NullMarked
public class RidableMoveEvent extends EntityEvent implements Cancellable {
private static final HandlerList handlers = new HandlerList();
private boolean canceled;
private final Player rider;
private Location from;
private Location to;
@ApiStatus.Internal
public RidableMoveEvent(Mob entity, Player rider, Location from, Location to) {
super(entity);
this.rider = rider;
this.from = from;
this.to = to;
}
@Override
public Mob getEntity() {
return (Mob) entity;
}
public Player getRider() {
return rider;
}
public boolean isCancelled() {
return canceled;
}
public void setCancelled(boolean cancel) {
canceled = cancel;
}
/**
* Gets the location this entity moved from
*
* @return Location the entity moved from
*/
public Location getFrom() {
return from;
}
/**
* Sets the location to mark as where the entity moved from
*
* @param from New location to mark as the entity's previous location
*/
public void setFrom(Location from) {
validateLocation(from);
this.from = from;
}
/**
* Gets the location this entity moved to
*
* @return Location the entity moved to
*/
public Location getTo() {
return to;
}
/**
* Sets the location that this entity will move to
*
* @param to New Location this entity will move to
*/
public void setTo(Location to) {
validateLocation(to);
this.to = to;
}
private void validateLocation(Location loc) {
Preconditions.checkArgument(loc != null, "Cannot use null location!");
Preconditions.checkArgument(loc.getWorld() != null, "Cannot use null location with null world!");
}
@Override
public HandlerList getHandlers() {
return handlers;
}
public static HandlerList getHandlerList() {
return handlers;
}
}

38
purpur-api/src/main/java/org/purpurmc/purpur/event/entity/RidableSpacebarEvent.java Normal file
View File

@@ -0,0 +1,38 @@
package org.purpurmc.purpur.event.entity;
import org.bukkit.entity.Entity;
import org.bukkit.event.Cancellable;
import org.bukkit.event.HandlerList;
import org.bukkit.event.entity.EntityEvent;
import org.jetbrains.annotations.ApiStatus;
import org.jspecify.annotations.NullMarked;
@NullMarked
public class RidableSpacebarEvent extends EntityEvent implements Cancellable {
private static final HandlerList handlers = new HandlerList();
private boolean cancelled;
@ApiStatus.Internal
public RidableSpacebarEvent(Entity entity) {
super(entity);
}
@Override
public boolean isCancelled() {
return cancelled;
}
@Override
public void setCancelled(boolean cancel) {
cancelled = cancel;
}
@Override
public HandlerList getHandlers() {
return handlers;
}
public static HandlerList getHandlerList() {
return handlers;
}
}

16
purpur-api/src/main/java/org/purpurmc/purpur/util/permissions/PurpurPermissions.java
View File

@@ -29,6 +29,22 @@ public final class PurpurPermissions {
public static Permission registerPermissions() {
Permission purpur = DefaultPermissions.registerPermission(ROOT, "Gives the user the ability to use all Purpur utilities and commands", PermissionDefault.FALSE);
Permission ride = DefaultPermissions.registerPermission("allow.ride", "Allows the user to ride all mobs", PermissionDefault.FALSE, purpur);
for (String mob : mobs) {
DefaultPermissions.registerPermission("allow.ride." + mob, "Allows the user to ride " + mob, PermissionDefault.FALSE, ride);
}
ride.recalculatePermissibles();
Permission special = DefaultPermissions.registerPermission("allow.special", "Allows the user to use all mobs special abilities", PermissionDefault.FALSE, purpur);
for (String mob : mobs) {
DefaultPermissions.registerPermission("allow.special." + mob, "Allows the user to use " + mob + " special ability", PermissionDefault.FALSE, special);
}
special.recalculatePermissibles();
Permission powered = DefaultPermissions.registerPermission("allow.powered", "Allows the user to toggle all mobs powered state", PermissionDefault.FALSE, purpur);
DefaultPermissions.registerPermission("allow.powered.creeper", "Allows the user to toggle creeper powered state", PermissionDefault.FALSE, powered);
powered.recalculatePermissibles();
purpur.recalculatePermissibles();
return purpur;
}

3441
patches/server/0007-Ridables.patch → purpur-server/minecraft-patches/features/0001-Ridables.patch
View File

File diff suppressed because it is too large Load Diff

15
purpur-server/minecraft-patches/sources/net/minecraft/core/BlockPos.java.patch Normal file
View File

@@ -0,0 +1,15 @@
--- a/net/minecraft/core/BlockPos.java
+++ b/net/minecraft/core/BlockPos.java
@@ -63,6 +_,12 @@
public static final int MAX_HORIZONTAL_COORDINATE = 33554431;
// Paper end - Optimize Bit Operations by inlining
+ // Purpur start - Ridables
+ public BlockPos(net.minecraft.world.entity.Entity entity) {
+ super(entity.getBlockX(), entity.getBlockY(), entity.getBlockZ());
+ }
+ // Purpur end - Ridables
+
public BlockPos(int x, int y, int z) {
super(x, y, z);
}

66
purpur-server/paper-patches/features/0002-Ridables.patch Normal file
View File

@@ -0,0 +1,66 @@
From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
From: William Blake Galbreath <Blake.Galbreath@GMail.com>
Date: Sun, 5 Jul 2020 22:19:49 -0500
Subject: [PATCH] Ridables
diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java
index 91b78711ec06f51e3bc25109129cc164a98bcf87..0d69e89c1ade115b868cb13f08f75cf256734d88 100644
--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java
+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java
@@ -1306,4 +1306,27 @@ public abstract class CraftEntity implements org.bukkit.entity.Entity {
}
}
// Paper end - broadcast hurt animation
+
+ // Purpur start - Ridables
+ @Override
+ public org.bukkit.entity.Player getRider() {
+ net.minecraft.world.entity.player.Player rider = getHandle().getRider();
+ return rider != null ? (org.bukkit.entity.Player) rider.getBukkitEntity() : null;
+ }
+
+ @Override
+ public boolean hasRider() {
+ return getHandle().getRider() != null;
+ }
+
+ @Override
+ public boolean isRidable() {
+ return getHandle().isRidable();
+ }
+
+ @Override
+ public boolean isRidableInWater() {
+ return !getHandle().dismountsUnderwater();
+ }
+ // Purpur end - Ridables
}
diff --git a/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java b/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java
index e37aaf77f94b97b736cc20ef070cefdff0400188..eb2f9bfdaf3ed8a684337a15365e70174d1533b3 100644
--- a/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java
+++ b/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java
@@ -602,6 +602,15 @@ public class CraftEventFactory {
// Paper end
craftServer.getPluginManager().callEvent(event);
+ // Purpur start - Ridables
+ if (who != null) {
+ switch (action) {
+ case LEFT_CLICK_BLOCK, LEFT_CLICK_AIR -> who.processClick(InteractionHand.MAIN_HAND);
+ case RIGHT_CLICK_BLOCK, RIGHT_CLICK_AIR -> who.processClick(InteractionHand.OFF_HAND);
+ }
+ }
+ // Purpur end - Ridables
+
return event;
}
@@ -1191,6 +1200,7 @@ public class CraftEventFactory {
EntityDamageEvent event;
if (damager != null) {
event = new EntityDamageByEntityEvent(damager.getBukkitEntity(), damagee.getBukkitEntity(), cause, bukkitDamageSource, modifiers, modifierFunctions, critical);
+ damager.processClick(InteractionHand.MAIN_HAND); // Purpur - Ridables
} else {
event = new EntityDamageEvent(damagee.getBukkitEntity(), cause, bukkitDamageSource, modifiers, modifierFunctions);
}

5
purpur-server/src/main/java/org/purpurmc/purpur/PurpurConfig.java
View File

@@ -155,4 +155,9 @@ public class PurpurConfig {
}
return builder.build();
}
public static String cannotRideMob = "<red>You cannot mount that mob";
private static void messages() {
cannotRideMob = getString("settings.messages.cannot-ride-mob", cannotRideMob);
}
}

749
purpur-server/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
View File

@@ -67,4 +67,753 @@ public class PurpurWorldConfig {
final Map<String, Object> value = PurpurConfig.getMap("world-settings." + worldName + "." + path, null);
return value.isEmpty() ? fallback : value;
}
public boolean babiesAreRidable = true;
public boolean untamedTamablesAreRidable = true;
public boolean useNightVisionWhenRiding = false;
public boolean useDismountsUnderwaterTag = true;
private void ridableSettings() {
babiesAreRidable = getBoolean("ridable-settings.babies-are-ridable", babiesAreRidable);
untamedTamablesAreRidable = getBoolean("ridable-settings.untamed-tamables-are-ridable", untamedTamablesAreRidable);
useNightVisionWhenRiding = getBoolean("ridable-settings.use-night-vision", useNightVisionWhenRiding);
useDismountsUnderwaterTag = getBoolean("ridable-settings.use-dismounts-underwater-tag", useDismountsUnderwaterTag);
}
public boolean allayRidable = false;
public boolean allayRidableInWater = true;
public boolean allayControllable = true;
private void allaySettings() {
allayRidable = getBoolean("mobs.allay.ridable", allayRidable);
allayRidableInWater = getBoolean("mobs.allay.ridable-in-water", allayRidableInWater);
allayControllable = getBoolean("mobs.allay.controllable", allayControllable);
}
public boolean armadilloRidable = false;
public boolean armadilloRidableInWater = true;
public boolean armadilloControllable = true;
private void armadilloSettings() {
armadilloRidable = getBoolean("mobs.armadillo.ridable", armadilloRidable);
armadilloRidableInWater = getBoolean("mobs.armadillo.ridable-in-water", armadilloRidableInWater);
armadilloControllable = getBoolean("mobs.armadillo.controllable", armadilloControllable);
}
public boolean axolotlRidable = false;
public boolean axolotlControllable = true;
private void axolotlSettings() {
axolotlRidable = getBoolean("mobs.axolotl.ridable", axolotlRidable);
axolotlControllable = getBoolean("mobs.axolotl.controllable", axolotlControllable);
}
public boolean batRidable = false;
public boolean batRidableInWater = true;
public boolean batControllable = true;
public double batMaxY = 320D;
private void batSettings() {
batRidable = getBoolean("mobs.bat.ridable", batRidable);
batRidableInWater = getBoolean("mobs.bat.ridable-in-water", batRidableInWater);
batControllable = getBoolean("mobs.bat.controllable", batControllable);
batMaxY = getDouble("mobs.bat.ridable-max-y", batMaxY);
}
public boolean beeRidable = false;
public boolean beeRidableInWater = true;
public boolean beeControllable = true;
public double beeMaxY = 320D;
private void beeSettings() {
beeRidable = getBoolean("mobs.bee.ridable", beeRidable);
beeRidableInWater = getBoolean("mobs.bee.ridable-in-water", beeRidableInWater);
beeControllable = getBoolean("mobs.bee.controllable", beeControllable);
beeMaxY = getDouble("mobs.bee.ridable-max-y", beeMaxY);
}
public boolean blazeRidable = false;
public boolean blazeRidableInWater = true;
public boolean blazeControllable = true;
public double blazeMaxY = 320D;
private void blazeSettings() {
blazeRidable = getBoolean("mobs.blaze.ridable", blazeRidable);
blazeRidableInWater = getBoolean("mobs.blaze.ridable-in-water", blazeRidableInWater);
blazeControllable = getBoolean("mobs.blaze.controllable", blazeControllable);
blazeMaxY = getDouble("mobs.blaze.ridable-max-y", blazeMaxY);
}
public boolean boggedRidable = false;
public boolean boggedRidableInWater = true;
public boolean boggedControllable = true;
private void boggedSettings() {
boggedRidable = getBoolean("mobs.bogged.ridable", boggedRidable);
boggedRidableInWater = getBoolean("mobs.bogged.ridable-in-water", boggedRidableInWater);
boggedControllable = getBoolean("mobs.bogged.controllable", boggedControllable);
}
public boolean camelRidableInWater = false;
private void camelSettings() {
camelRidableInWater = getBoolean("mobs.camel.ridable-in-water", camelRidableInWater);
}
public boolean catRidable = false;
public boolean catRidableInWater = true;
public boolean catControllable = true;
private void catSettings() {
catRidable = getBoolean("mobs.cat.ridable", catRidable);
catRidableInWater = getBoolean("mobs.cat.ridable-in-water", catRidableInWater);
catControllable = getBoolean("mobs.cat.controllable", catControllable);
}
public boolean caveSpiderRidable = false;
public boolean caveSpiderRidableInWater = true;
public boolean caveSpiderControllable = true;
private void caveSpiderSettings() {
caveSpiderRidable = getBoolean("mobs.cave_spider.ridable", caveSpiderRidable);
caveSpiderRidableInWater = getBoolean("mobs.cave_spider.ridable-in-water", caveSpiderRidableInWater);
caveSpiderControllable = getBoolean("mobs.cave_spider.controllable", caveSpiderControllable);
}
public boolean chickenRidable = false;
public boolean chickenRidableInWater = false;
public boolean chickenControllable = true;
private void chickenSettings() {
chickenRidable = getBoolean("mobs.chicken.ridable", chickenRidable);
chickenRidableInWater = getBoolean("mobs.chicken.ridable-in-water", chickenRidableInWater);
chickenControllable = getBoolean("mobs.chicken.controllable", chickenControllable);
}
public boolean codRidable = false;
public boolean codControllable = true;
private void codSettings() {
codRidable = getBoolean("mobs.cod.ridable", codRidable);
codControllable = getBoolean("mobs.cod.controllable", codControllable);
}
public boolean cowRidable = false;
public boolean cowRidableInWater = true;
public boolean cowControllable = true;
private void cowSettings() {
cowRidable = getBoolean("mobs.cow.ridable", cowRidable);
cowRidableInWater = getBoolean("mobs.cow.ridable-in-water", cowRidableInWater);
cowControllable = getBoolean("mobs.cow.controllable", cowControllable);
}
public boolean creakingRidable = false;
public boolean creakingRidableInWater = true;
public boolean creakingControllable = true;
private void creakingSettings() {
creakingRidable = getBoolean("mobs.creaking.ridable", creakingRidable);
creakingRidableInWater = getBoolean("mobs.creaking.ridable-in-water", creakingRidableInWater);
creakingControllable = getBoolean("mobs.creaking.controllable", creakingControllable);
}
public boolean creeperRidable = false;
public boolean creeperRidableInWater = true;
public boolean creeperControllable = true;
private void creeperSettings() {
creeperRidable = getBoolean("mobs.creeper.ridable", creeperRidable);
creeperRidableInWater = getBoolean("mobs.creeper.ridable-in-water", creeperRidableInWater);
creeperControllable = getBoolean("mobs.creeper.controllable", creeperControllable);
}
public boolean dolphinRidable = false;
public boolean dolphinControllable = true;
public int dolphinSpitCooldown = 20;
public float dolphinSpitSpeed = 1.0F;
public float dolphinSpitDamage = 2.0F;
private void dolphinSettings() {
dolphinRidable = getBoolean("mobs.dolphin.ridable", dolphinRidable);
dolphinControllable = getBoolean("mobs.dolphin.controllable", dolphinControllable);
dolphinSpitCooldown = getInt("mobs.dolphin.spit.cooldown", dolphinSpitCooldown);
dolphinSpitSpeed = (float) getDouble("mobs.dolphin.spit.speed", dolphinSpitSpeed);
dolphinSpitDamage = (float) getDouble("mobs.dolphin.spit.damage", dolphinSpitDamage);
}
public boolean donkeyRidableInWater = false;
private void donkeySettings() {
donkeyRidableInWater = getBoolean("mobs.donkey.ridable-in-water", donkeyRidableInWater);
}
public boolean drownedRidable = false;
public boolean drownedRidableInWater = true;
public boolean drownedControllable = true;
private void drownedSettings() {
drownedRidable = getBoolean("mobs.drowned.ridable", drownedRidable);
drownedRidableInWater = getBoolean("mobs.drowned.ridable-in-water", drownedRidableInWater);
drownedControllable = getBoolean("mobs.drowned.controllable", drownedControllable);
}
public boolean elderGuardianRidable = false;
public boolean elderGuardianControllable = true;
private void elderGuardianSettings() {
elderGuardianRidable = getBoolean("mobs.elder_guardian.ridable", elderGuardianRidable);
elderGuardianControllable = getBoolean("mobs.elder_guardian.controllable", elderGuardianControllable);
}
public boolean enderDragonRidable = false;
public boolean enderDragonRidableInWater = true;
public boolean enderDragonControllable = true;
public double enderDragonMaxY = 320D;
private void enderDragonSettings() {
enderDragonRidable = getBoolean("mobs.ender_dragon.ridable", enderDragonRidable);
enderDragonRidableInWater = getBoolean("mobs.ender_dragon.ridable-in-water", enderDragonRidableInWater);
enderDragonControllable = getBoolean("mobs.ender_dragon.controllable", enderDragonControllable);
enderDragonMaxY = getDouble("mobs.ender_dragon.ridable-max-y", enderDragonMaxY);
}
public boolean endermanRidable = false;
public boolean endermanRidableInWater = true;
public boolean endermanControllable = true;
private void endermanSettings() {
endermanRidable = getBoolean("mobs.enderman.ridable", endermanRidable);
endermanRidableInWater = getBoolean("mobs.enderman.ridable-in-water", endermanRidableInWater);
endermanControllable = getBoolean("mobs.enderman.controllable", endermanControllable);
}
public boolean endermiteRidable = false;
public boolean endermiteRidableInWater = true;
public boolean endermiteControllable = true;
private void endermiteSettings() {
endermiteRidable = getBoolean("mobs.endermite.ridable", endermiteRidable);
endermiteRidableInWater = getBoolean("mobs.endermite.ridable-in-water", endermiteRidableInWater);
endermiteControllable = getBoolean("mobs.endermite.controllable", endermiteControllable);
}
public boolean evokerRidable = false;
public boolean evokerRidableInWater = true;
public boolean evokerControllable = true;
private void evokerSettings() {
evokerRidable = getBoolean("mobs.evoker.ridable", evokerRidable);
evokerRidableInWater = getBoolean("mobs.evoker.ridable-in-water", evokerRidableInWater);
evokerControllable = getBoolean("mobs.evoker.controllable", evokerControllable);
}
public boolean foxRidable = false;
public boolean foxRidableInWater = true;
public boolean foxControllable = true;
private void foxSettings() {
foxRidable = getBoolean("mobs.fox.ridable", foxRidable);
foxRidableInWater = getBoolean("mobs.fox.ridable-in-water", foxRidableInWater);
foxControllable = getBoolean("mobs.fox.controllable", foxControllable);
}
public boolean frogRidable = false;
public boolean frogRidableInWater = true;
public boolean frogControllable = true;
public float frogRidableJumpHeight = 0.65F;
private void frogSettings() {
frogRidable = getBoolean("mobs.frog.ridable", frogRidable);
frogRidableInWater = getBoolean("mobs.frog.ridable-in-water", frogRidableInWater);
frogControllable = getBoolean("mobs.frog.controllable", frogControllable);
frogRidableJumpHeight = (float) getDouble("mobs.frog.ridable-jump-height", frogRidableJumpHeight);
}
public boolean ghastRidable = false;
public boolean ghastRidableInWater = true;
public boolean ghastControllable = true;
public double ghastMaxY = 320D;
private void ghastSettings() {
ghastRidable = getBoolean("mobs.ghast.ridable", ghastRidable);
ghastRidableInWater = getBoolean("mobs.ghast.ridable-in-water", ghastRidableInWater);
ghastControllable = getBoolean("mobs.ghast.controllable", ghastControllable);
ghastMaxY = getDouble("mobs.ghast.ridable-max-y", ghastMaxY);
}
public boolean giantRidable = false;
public boolean giantRidableInWater = true;
public boolean giantControllable = true;
private void giantSettings() {
giantRidable = getBoolean("mobs.giant.ridable", giantRidable);
giantRidableInWater = getBoolean("mobs.giant.ridable-in-water", giantRidableInWater);
giantControllable = getBoolean("mobs.giant.controllable", giantControllable);
}
public boolean glowSquidRidable = false;
public boolean glowSquidControllable = true;
private void glowSquidSettings() {
glowSquidRidable = getBoolean("mobs.glow_squid.ridable", glowSquidRidable);
glowSquidControllable = getBoolean("mobs.glow_squid.controllable", glowSquidControllable);
}
public boolean goatRidable = false;
public boolean goatRidableInWater = true;
public boolean goatControllable = true;
private void goatSettings() {
goatRidable = getBoolean("mobs.goat.ridable", goatRidable);
goatRidableInWater = getBoolean("mobs.goat.ridable-in-water", goatRidableInWater);
goatControllable = getBoolean("mobs.goat.controllable", goatControllable);
}
public boolean guardianRidable = false;
public boolean guardianControllable = true;
private void guardianSettings() {
guardianRidable = getBoolean("mobs.guardian.ridable", guardianRidable);
guardianControllable = getBoolean("mobs.guardian.controllable", guardianControllable);
}
public boolean hoglinRidable = false;
public boolean hoglinRidableInWater = true;
public boolean hoglinControllable = true;
private void hoglinSettings() {
hoglinRidable = getBoolean("mobs.hoglin.ridable", hoglinRidable);
hoglinRidableInWater = getBoolean("mobs.hoglin.ridable-in-water", hoglinRidableInWater);
hoglinControllable = getBoolean("mobs.hoglin.controllable", hoglinControllable);
}
public boolean horseRidableInWater = false;
private void horseSettings() {
horseRidableInWater = getBoolean("mobs.horse.ridable-in-water", horseRidableInWater);
}
public boolean huskRidable = false;
public boolean huskRidableInWater = true;
public boolean huskControllable = true;
private void huskSettings() {
huskRidable = getBoolean("mobs.husk.ridable", huskRidable);
huskRidableInWater = getBoolean("mobs.husk.ridable-in-water", huskRidableInWater);
huskControllable = getBoolean("mobs.husk.controllable", huskControllable);
}
public boolean illusionerRidable = false;
public boolean illusionerRidableInWater = true;
public boolean illusionerControllable = true;
private void illusionerSettings() {
illusionerRidable = getBoolean("mobs.illusioner.ridable", illusionerRidable);
illusionerRidableInWater = getBoolean("mobs.illusioner.ridable-in-water", illusionerRidableInWater);
illusionerControllable = getBoolean("mobs.illusioner.controllable", illusionerControllable);
}
public boolean ironGolemRidable = false;
public boolean ironGolemRidableInWater = true;
public boolean ironGolemControllable = true;
public boolean ironGolemCanSwim = false;
private void ironGolemSettings() {
ironGolemRidable = getBoolean("mobs.iron_golem.ridable", ironGolemRidable);
ironGolemRidableInWater = getBoolean("mobs.iron_golem.ridable-in-water", ironGolemRidableInWater);
ironGolemControllable = getBoolean("mobs.iron_golem.controllable", ironGolemControllable);
ironGolemCanSwim = getBoolean("mobs.iron_golem.can-swim", ironGolemCanSwim);
}
public boolean llamaRidable = false;
public boolean llamaRidableInWater = false;
public boolean llamaControllable = true;
private void llamaSettings() {
llamaRidable = getBoolean("mobs.llama.ridable", llamaRidable);
llamaRidableInWater = getBoolean("mobs.llama.ridable-in-water", llamaRidableInWater);
llamaControllable = getBoolean("mobs.llama.controllable", llamaControllable);
}
public boolean magmaCubeRidable = false;
public boolean magmaCubeRidableInWater = true;
public boolean magmaCubeControllable = true;
private void magmaCubeSettings() {
magmaCubeRidable = getBoolean("mobs.magma_cube.ridable", magmaCubeRidable);
magmaCubeRidableInWater = getBoolean("mobs.magma_cube.ridable-in-water", magmaCubeRidableInWater);
magmaCubeControllable = getBoolean("mobs.magma_cube.controllable", magmaCubeControllable);
}
public boolean mooshroomRidable = false;
public boolean mooshroomRidableInWater = true;
public boolean mooshroomControllable = true;
private void mooshroomSettings() {
mooshroomRidable = getBoolean("mobs.mooshroom.ridable", mooshroomRidable);
mooshroomRidableInWater = getBoolean("mobs.mooshroom.ridable-in-water", mooshroomRidableInWater);
mooshroomControllable = getBoolean("mobs.mooshroom.controllable", mooshroomControllable);
}
public boolean muleRidableInWater = false;
private void muleSettings() {
muleRidableInWater = getBoolean("mobs.mule.ridable-in-water", muleRidableInWater);
}
public boolean ocelotRidable = false;
public boolean ocelotRidableInWater = true;
public boolean ocelotControllable = true;
private void ocelotSettings() {
ocelotRidable = getBoolean("mobs.ocelot.ridable", ocelotRidable);
ocelotRidableInWater = getBoolean("mobs.ocelot.ridable-in-water", ocelotRidableInWater);
ocelotControllable = getBoolean("mobs.ocelot.controllable", ocelotControllable);
}
public boolean pandaRidable = false;
public boolean pandaRidableInWater = true;
public boolean pandaControllable = true;
private void pandaSettings() {
pandaRidable = getBoolean("mobs.panda.ridable", pandaRidable);
pandaRidableInWater = getBoolean("mobs.panda.ridable-in-water", pandaRidableInWater);
pandaControllable = getBoolean("mobs.panda.controllable", pandaControllable);
}
public boolean parrotRidable = false;
public boolean parrotRidableInWater = true;
public boolean parrotControllable = true;
public double parrotMaxY = 320D;
private void parrotSettings() {
parrotRidable = getBoolean("mobs.parrot.ridable", parrotRidable);
parrotRidableInWater = getBoolean("mobs.parrot.ridable-in-water", parrotRidableInWater);
parrotControllable = getBoolean("mobs.parrot.controllable", parrotControllable);
parrotMaxY = getDouble("mobs.parrot.ridable-max-y", parrotMaxY);
}
public boolean phantomRidable = false;
public boolean phantomRidableInWater = true;
public boolean phantomControllable = true;
public double phantomMaxY = 320D;
public float phantomFlameDamage = 1.0F;
public int phantomFlameFireTime = 8;
public boolean phantomAllowGriefing = false;
private void phantomSettings() {
phantomRidable = getBoolean("mobs.phantom.ridable", phantomRidable);
phantomRidableInWater = getBoolean("mobs.phantom.ridable-in-water", phantomRidableInWater);
phantomControllable = getBoolean("mobs.phantom.controllable", phantomControllable);
phantomMaxY = getDouble("mobs.phantom.ridable-max-y", phantomMaxY);
phantomFlameDamage = (float) getDouble("mobs.phantom.flames.damage", phantomFlameDamage);
phantomFlameFireTime = getInt("mobs.phantom.flames.fire-time", phantomFlameFireTime);
phantomAllowGriefing = getBoolean("mobs.phantom.allow-griefing", phantomAllowGriefing);
}
public boolean pigRidable = false;
public boolean pigRidableInWater = false;
public boolean pigControllable = true;
private void pigSettings() {
pigRidable = getBoolean("mobs.pig.ridable", pigRidable);
pigRidableInWater = getBoolean("mobs.pig.ridable-in-water", pigRidableInWater);
pigControllable = getBoolean("mobs.pig.controllable", pigControllable);
}
public boolean piglinRidable = false;
public boolean piglinRidableInWater = true;
public boolean piglinControllable = true;
private void piglinSettings() {
piglinRidable = getBoolean("mobs.piglin.ridable", piglinRidable);
piglinRidableInWater = getBoolean("mobs.piglin.ridable-in-water", piglinRidableInWater);
piglinControllable = getBoolean("mobs.piglin.controllable", piglinControllable);
}
public boolean piglinBruteRidable = false;
public boolean piglinBruteRidableInWater = true;
public boolean piglinBruteControllable = true;
private void piglinBruteSettings() {
piglinBruteRidable = getBoolean("mobs.piglin_brute.ridable", piglinBruteRidable);
piglinBruteRidableInWater = getBoolean("mobs.piglin_brute.ridable-in-water", piglinBruteRidableInWater);
piglinBruteControllable = getBoolean("mobs.piglin_brute.controllable", piglinBruteControllable);
}
public boolean pillagerRidable = false;
public boolean pillagerRidableInWater = true;
public boolean pillagerControllable = true;
private void pillagerSettings() {
pillagerRidable = getBoolean("mobs.pillager.ridable", pillagerRidable);
pillagerRidableInWater = getBoolean("mobs.pillager.ridable-in-water", pillagerRidableInWater);
pillagerControllable = getBoolean("mobs.pillager.controllable", pillagerControllable);
}
public boolean polarBearRidable = false;
public boolean polarBearRidableInWater = true;
public boolean polarBearControllable = true;
private void polarBearSettings() {
polarBearRidable = getBoolean("mobs.polar_bear.ridable", polarBearRidable);
polarBearRidableInWater = getBoolean("mobs.polar_bear.ridable-in-water", polarBearRidableInWater);
polarBearControllable = getBoolean("mobs.polar_bear.controllable", polarBearControllable);
}
public boolean pufferfishRidable = false;
public boolean pufferfishControllable = true;
private void pufferfishSettings() {
pufferfishRidable = getBoolean("mobs.pufferfish.ridable", pufferfishRidable);
pufferfishControllable = getBoolean("mobs.pufferfish.controllable", pufferfishControllable);
}
public boolean rabbitRidable = false;
public boolean rabbitRidableInWater = true;
public boolean rabbitControllable = true;
private void rabbitSettings() {
rabbitRidable = getBoolean("mobs.rabbit.ridable", rabbitRidable);
rabbitRidableInWater = getBoolean("mobs.rabbit.ridable-in-water", rabbitRidableInWater);
rabbitControllable = getBoolean("mobs.rabbit.controllable", rabbitControllable);
}
public boolean ravagerRidable = false;
public boolean ravagerRidableInWater = false;
public boolean ravagerControllable = true;
private void ravagerSettings() {
ravagerRidable = getBoolean("mobs.ravager.ridable", ravagerRidable);
ravagerRidableInWater = getBoolean("mobs.ravager.ridable-in-water", ravagerRidableInWater);
ravagerControllable = getBoolean("mobs.ravager.controllable", ravagerControllable);
}
public boolean salmonRidable = false;
public boolean salmonControllable = true;
private void salmonSettings() {
salmonRidable = getBoolean("mobs.salmon.ridable", salmonRidable);
salmonControllable = getBoolean("mobs.salmon.controllable", salmonControllable);
}
public boolean sheepRidable = false;
public boolean sheepRidableInWater = true;
public boolean sheepControllable = true;
private void sheepSettings() {
sheepRidable = getBoolean("mobs.sheep.ridable", sheepRidable);
sheepRidableInWater = getBoolean("mobs.sheep.ridable-in-water", sheepRidableInWater);
sheepControllable = getBoolean("mobs.sheep.controllable", sheepControllable);
}
public boolean shulkerRidable = false;
public boolean shulkerRidableInWater = true;
public boolean shulkerControllable = true;
private void shulkerSettings() {
shulkerRidable = getBoolean("mobs.shulker.ridable", shulkerRidable);
shulkerRidableInWater = getBoolean("mobs.shulker.ridable-in-water", shulkerRidableInWater);
shulkerControllable = getBoolean("mobs.shulker.controllable", shulkerControllable);
}
public boolean silverfishRidable = false;
public boolean silverfishRidableInWater = true;
public boolean silverfishControllable = true;
private void silverfishSettings() {
silverfishRidable = getBoolean("mobs.silverfish.ridable", silverfishRidable);
silverfishRidableInWater = getBoolean("mobs.silverfish.ridable-in-water", silverfishRidableInWater);
silverfishControllable = getBoolean("mobs.silverfish.controllable", silverfishControllable);
}
public boolean skeletonRidable = false;
public boolean skeletonRidableInWater = true;
public boolean skeletonControllable = true;
private void skeletonSettings() {
skeletonRidable = getBoolean("mobs.skeleton.ridable", skeletonRidable);
skeletonRidableInWater = getBoolean("mobs.skeleton.ridable-in-water", skeletonRidableInWater);
skeletonControllable = getBoolean("mobs.skeleton.controllable", skeletonControllable);
}
public boolean skeletonHorseRidable = false;
public boolean skeletonHorseRidableInWater = true;
public boolean skeletonHorseCanSwim = false;
private void skeletonHorseSettings() {
skeletonHorseRidable = getBoolean("mobs.skeleton_horse.ridable", skeletonHorseRidable);
skeletonHorseRidableInWater = getBoolean("mobs.skeleton_horse.ridable-in-water", skeletonHorseRidableInWater);
skeletonHorseCanSwim = getBoolean("mobs.skeleton_horse.can-swim", skeletonHorseCanSwim);
}
public boolean slimeRidable = false;
public boolean slimeRidableInWater = true;
public boolean slimeControllable = true;
private void slimeSettings() {
slimeRidable = getBoolean("mobs.slime.ridable", slimeRidable);
slimeRidableInWater = getBoolean("mobs.slime.ridable-in-water", slimeRidableInWater);
slimeControllable = getBoolean("mobs.slime.controllable", slimeControllable);
}
public boolean snowGolemRidable = false;
public boolean snowGolemRidableInWater = true;
public boolean snowGolemControllable = true;
public boolean snowGolemLeaveTrailWhenRidden = false;
private void snowGolemSettings() {
snowGolemRidable = getBoolean("mobs.snow_golem.ridable", snowGolemRidable);
snowGolemRidableInWater = getBoolean("mobs.snow_golem.ridable-in-water", snowGolemRidableInWater);
snowGolemControllable = getBoolean("mobs.snow_golem.controllable", snowGolemControllable);
snowGolemLeaveTrailWhenRidden = getBoolean("mobs.snow_golem.leave-trail-when-ridden", snowGolemLeaveTrailWhenRidden);
}
public boolean snifferRidable = false;
public boolean snifferRidableInWater = true;
public boolean snifferControllable = true;
private void snifferSettings() {
snifferRidable = getBoolean("mobs.sniffer.ridable", snifferRidable);
snifferRidableInWater = getBoolean("mobs.sniffer.ridable-in-water", snifferRidableInWater);
snifferControllable = getBoolean("mobs.sniffer.controllable", snifferControllable);
}
public boolean squidRidable = false;
public boolean squidControllable = true;
private void squidSettings() {
squidRidable = getBoolean("mobs.squid.ridable", squidRidable);
squidControllable = getBoolean("mobs.squid.controllable", squidControllable);
}
public boolean spiderRidable = false;
public boolean spiderRidableInWater = false;
public boolean spiderControllable = true;
private void spiderSettings() {
spiderRidable = getBoolean("mobs.spider.ridable", spiderRidable);
spiderRidableInWater = getBoolean("mobs.spider.ridable-in-water", spiderRidableInWater);
spiderControllable = getBoolean("mobs.spider.controllable", spiderControllable);
}
public boolean strayRidable = false;
public boolean strayRidableInWater = true;
public boolean strayControllable = true;
private void straySettings() {
strayRidable = getBoolean("mobs.stray.ridable", strayRidable);
strayRidableInWater = getBoolean("mobs.stray.ridable-in-water", strayRidableInWater);
strayControllable = getBoolean("mobs.stray.controllable", strayControllable);
}
public boolean striderRidable = false;
public boolean striderRidableInWater = false;
public boolean striderControllable = true;
private void striderSettings() {
striderRidable = getBoolean("mobs.strider.ridable", striderRidable);
striderRidableInWater = getBoolean("mobs.strider.ridable-in-water", striderRidableInWater);
striderControllable = getBoolean("mobs.strider.controllable", striderControllable);
}
public boolean tadpoleRidable = false;
public boolean tadpoleRidableInWater = true;
public boolean tadpoleControllable = true;
private void tadpoleSettings() {
tadpoleRidable = getBoolean("mobs.tadpole.ridable", tadpoleRidable);
tadpoleRidableInWater = getBoolean("mobs.tadpole.ridable-in-water", tadpoleRidableInWater);
tadpoleControllable = getBoolean("mobs.tadpole.controllable", tadpoleControllable);
}
public boolean traderLlamaRidable = false;
public boolean traderLlamaRidableInWater = false;
public boolean traderLlamaControllable = true;
private void traderLlamaSettings() {
traderLlamaRidable = getBoolean("mobs.trader_llama.ridable", traderLlamaRidable);
traderLlamaRidableInWater = getBoolean("mobs.trader_llama.ridable-in-water", traderLlamaRidableInWater);
traderLlamaControllable = getBoolean("mobs.trader_llama.controllable", traderLlamaControllable);
}
public boolean tropicalFishRidable = false;
public boolean tropicalFishControllable = true;
private void tropicalFishSettings() {
tropicalFishRidable = getBoolean("mobs.tropical_fish.ridable", tropicalFishRidable);
tropicalFishControllable = getBoolean("mobs.tropical_fish.controllable", tropicalFishControllable);
}
public boolean turtleRidable = false;
public boolean turtleRidableInWater = true;
public boolean turtleControllable = true;
private void turtleSettings() {
turtleRidable = getBoolean("mobs.turtle.ridable", turtleRidable);
turtleRidableInWater = getBoolean("mobs.turtle.ridable-in-water", turtleRidableInWater);
turtleControllable = getBoolean("mobs.turtle.controllable", turtleControllable);
}
public boolean vexRidable = false;
public boolean vexRidableInWater = true;
public boolean vexControllable = true;
public double vexMaxY = 320D;
private void vexSettings() {
vexRidable = getBoolean("mobs.vex.ridable", vexRidable);
vexRidableInWater = getBoolean("mobs.vex.ridable-in-water", vexRidableInWater);
vexControllable = getBoolean("mobs.vex.controllable", vexControllable);
vexMaxY = getDouble("mobs.vex.ridable-max-y", vexMaxY);
}
public boolean villagerRidable = false;
public boolean villagerRidableInWater = true;
public boolean villagerControllable = true;
private void villagerSettings() {
villagerRidable = getBoolean("mobs.villager.ridable", villagerRidable);
villagerRidableInWater = getBoolean("mobs.villager.ridable-in-water", villagerRidableInWater);
villagerControllable = getBoolean("mobs.villager.controllable", villagerControllable);
}
public boolean vindicatorRidable = false;
public boolean vindicatorRidableInWater = true;
public boolean vindicatorControllable = true;
private void vindicatorSettings() {
vindicatorRidable = getBoolean("mobs.vindicator.ridable", vindicatorRidable);
vindicatorRidableInWater = getBoolean("mobs.vindicator.ridable-in-water", vindicatorRidableInWater);
vindicatorControllable = getBoolean("mobs.vindicator.controllable", vindicatorControllable);
}
public boolean wanderingTraderRidable = false;
public boolean wanderingTraderRidableInWater = true;
public boolean wanderingTraderControllable = true;
private void wanderingTraderSettings() {
wanderingTraderRidable = getBoolean("mobs.wandering_trader.ridable", wanderingTraderRidable);
wanderingTraderRidableInWater = getBoolean("mobs.wandering_trader.ridable-in-water", wanderingTraderRidableInWater);
wanderingTraderControllable = getBoolean("mobs.wandering_trader.controllable", wanderingTraderControllable);
}
public boolean wardenRidable = false;
public boolean wardenRidableInWater = true;
public boolean wardenControllable = true;
private void wardenSettings() {
wardenRidable = getBoolean("mobs.warden.ridable", wardenRidable);
wardenRidableInWater = getBoolean("mobs.warden.ridable-in-water", wardenRidableInWater);
wardenControllable = getBoolean("mobs.warden.controllable", wardenControllable);
}
public boolean witchRidable = false;
public boolean witchRidableInWater = true;
public boolean witchControllable = true;
private void witchSettings() {
witchRidable = getBoolean("mobs.witch.ridable", witchRidable);
witchRidableInWater = getBoolean("mobs.witch.ridable-in-water", witchRidableInWater);
witchControllable = getBoolean("mobs.witch.controllable", witchControllable);
}
public boolean witherRidable = false;
public boolean witherRidableInWater = true;
public boolean witherControllable = true;
public double witherMaxY = 320D;
private void witherSettings() {
witherRidable = getBoolean("mobs.wither.ridable", witherRidable);
witherRidableInWater = getBoolean("mobs.wither.ridable-in-water", witherRidableInWater);
witherControllable = getBoolean("mobs.wither.controllable", witherControllable);
witherMaxY = getDouble("mobs.wither.ridable-max-y", witherMaxY);
}
public boolean witherSkeletonRidable = false;
public boolean witherSkeletonRidableInWater = true;
public boolean witherSkeletonControllable = true;
private void witherSkeletonSettings() {
witherSkeletonRidable = getBoolean("mobs.wither_skeleton.ridable", witherSkeletonRidable);
witherSkeletonRidableInWater = getBoolean("mobs.wither_skeleton.ridable-in-water", witherSkeletonRidableInWater);
witherSkeletonControllable = getBoolean("mobs.wither_skeleton.controllable", witherSkeletonControllable);
}
public boolean wolfRidable = false;
public boolean wolfRidableInWater = true;
public boolean wolfControllable = true;
private void wolfSettings() {
wolfRidable = getBoolean("mobs.wolf.ridable", wolfRidable);
wolfRidableInWater = getBoolean("mobs.wolf.ridable-in-water", wolfRidableInWater);
wolfControllable = getBoolean("mobs.wolf.controllable", wolfControllable);
}
public boolean zoglinRidable = false;
public boolean zoglinRidableInWater = true;
public boolean zoglinControllable = true;
private void zoglinSettings() {
zoglinRidable = getBoolean("mobs.zoglin.ridable", zoglinRidable);
zoglinRidableInWater = getBoolean("mobs.zoglin.ridable-in-water", zoglinRidableInWater);
zoglinControllable = getBoolean("mobs.zoglin.controllable", zoglinControllable);
}
public boolean zombieRidable = false;
public boolean zombieRidableInWater = true;
public boolean zombieControllable = true;
private void zombieSettings() {
zombieRidable = getBoolean("mobs.zombie.ridable", zombieRidable);
zombieRidableInWater = getBoolean("mobs.zombie.ridable-in-water", zombieRidableInWater);
zombieControllable = getBoolean("mobs.zombie.controllable", zombieControllable);
}
public boolean zombieHorseRidable = false;
public boolean zombieHorseRidableInWater = false;
public boolean zombieHorseCanSwim = false;
private void zombieHorseSettings() {
zombieHorseRidable = getBoolean("mobs.zombie_horse.ridable", zombieHorseRidable);
zombieHorseRidableInWater = getBoolean("mobs.zombie_horse.ridable-in-water", zombieHorseRidableInWater);
zombieHorseCanSwim = getBoolean("mobs.zombie_horse.can-swim", zombieHorseCanSwim);
}
public boolean zombieVillagerRidable = false;
public boolean zombieVillagerRidableInWater = true;
public boolean zombieVillagerControllable = true;
private void zombieVillagerSettings() {
zombieVillagerRidable = getBoolean("mobs.zombie_villager.ridable", zombieVillagerRidable);
zombieVillagerRidableInWater = getBoolean("mobs.zombie_villager.ridable-in-water", zombieVillagerRidableInWater);
zombieVillagerControllable = getBoolean("mobs.zombie_villager.controllable", zombieVillagerControllable);
}
public boolean zombifiedPiglinRidable = false;
public boolean zombifiedPiglinRidableInWater = true;
public boolean zombifiedPiglinControllable = true;
private void zombifiedPiglinSettings() {
zombifiedPiglinRidable = getBoolean("mobs.zombified_piglin.ridable", zombifiedPiglinRidable);
zombifiedPiglinRidableInWater = getBoolean("mobs.zombified_piglin.ridable-in-water", zombifiedPiglinRidableInWater);
zombifiedPiglinControllable = getBoolean("mobs.zombified_piglin.controllable", zombifiedPiglinControllable);
}
}

74
purpur-server/src/main/java/org/purpurmc/purpur/controller/FlyingMoveControllerWASD.java Normal file
View File

@@ -0,0 +1,74 @@
package org.purpurmc.purpur.controller;
import net.minecraft.server.level.ServerPlayer;
import net.minecraft.world.entity.Mob;
import net.minecraft.world.entity.ai.attributes.Attributes;
import net.minecraft.world.entity.player.Input;
import net.minecraft.world.entity.player.Player;
public class FlyingMoveControllerWASD extends MoveControllerWASD {
protected final float groundSpeedModifier;
protected final float flyingSpeedModifier;
protected int tooHighCooldown = 0;
protected boolean setNoGravityFlag;
public FlyingMoveControllerWASD(Mob entity) {
this(entity, 1.0F);
}
public FlyingMoveControllerWASD(Mob entity, float groundSpeedModifier) {
this(entity, groundSpeedModifier, 1.0F, true);
}
public FlyingMoveControllerWASD(Mob entity, float groundSpeedModifier, float flyingSpeedModifier) {
this(entity, groundSpeedModifier, flyingSpeedModifier, true);
}
public FlyingMoveControllerWASD(Mob entity, float groundSpeedModifier, float flyingSpeedModifier, boolean setNoGravityFlag) {
super(entity);
this.groundSpeedModifier = groundSpeedModifier;
this.flyingSpeedModifier = flyingSpeedModifier;
this.setNoGravityFlag = setNoGravityFlag;
}
@Override
public void purpurTick(Player rider) {
Input lastClientInput = ((ServerPlayer) rider).getLastClientInput();
float forward = lastClientInput.forward() == lastClientInput.backward() ? 0.0F : lastClientInput.forward() ? 1.0F : 0.0F;
float vertical = forward == 0.0F ? 0.0F : -(rider.xRotO / 45.0F);
float strafe = (lastClientInput.left() == lastClientInput.right() ? 0.0F : lastClientInput.left() ? 1.0F : -1.0F);
if (lastClientInput.jump() && spacebarEvent(entity)) {
entity.onSpacebar();
}
if (entity.getY() >= entity.getMaxY() || --tooHighCooldown > 0) {
if (tooHighCooldown <= 0) {
tooHighCooldown = 20;
}
entity.setDeltaMovement(entity.getDeltaMovement().add(0.0D, -0.05D, 0.0D));
vertical = 0.0F;
}
setSpeedModifier(entity.getAttributeValue(Attributes.MOVEMENT_SPEED));
float speed = (float) getSpeedModifier();
if (entity.onGround) {
speed *= groundSpeedModifier; // TODO = fix this!
} else {
speed *= flyingSpeedModifier;
}
if (setNoGravityFlag) {
entity.setNoGravity(forward > 0);
}
entity.setSpeed(speed);
entity.setVerticalMot(vertical);
entity.setStrafeMot(strafe);
entity.setForwardMot(forward);
setForward(entity.getForwardMot());
setStrafe(entity.getStrafeMot());
}
}

66
purpur-server/src/main/java/org/purpurmc/purpur/controller/FlyingWithSpacebarMoveControllerWASD.java Normal file
View File

@@ -0,0 +1,66 @@
package org.purpurmc.purpur.controller;
import net.minecraft.server.level.ServerPlayer;
import net.minecraft.world.entity.Mob;
import net.minecraft.world.entity.ai.attributes.Attributes;
import net.minecraft.world.entity.player.Input;
import net.minecraft.world.entity.player.Player;
import net.minecraft.world.phys.Vec3;
public class FlyingWithSpacebarMoveControllerWASD extends FlyingMoveControllerWASD {
public FlyingWithSpacebarMoveControllerWASD(Mob entity) {
super(entity);
}
public FlyingWithSpacebarMoveControllerWASD(Mob entity, float groundSpeedModifier) {
super(entity, groundSpeedModifier);
}
@Override
public void purpurTick(Player rider) {
Input lastClientInput = ((ServerPlayer) rider).getLastClientInput();
float forward = (lastClientInput.forward() == lastClientInput.backward() ? 0.0F : lastClientInput.forward() ? 1.0F : -1.0F);
float strafe = (lastClientInput.left() == lastClientInput.right() ? 0.0F : lastClientInput.left() ? 1.0F : -1.0F) * 0.5F;
float vertical = 0;
if (forward < 0.0F) {
forward *= 0.5F;
strafe *= 0.5F;
}
float speed = (float) entity.getAttributeValue(Attributes.MOVEMENT_SPEED);
if (entity.onGround) {
speed *= groundSpeedModifier;
}
if (lastClientInput.jump() && spacebarEvent(entity) && !entity.onSpacebar()) {
entity.setNoGravity(true);
vertical = 1.0F;
} else {
entity.setNoGravity(false);
}
if (entity.getY() >= entity.getMaxY() || --tooHighCooldown > 0) {
if (tooHighCooldown <= 0) {
tooHighCooldown = 20;
}
entity.setDeltaMovement(entity.getDeltaMovement().add(0.0D, -0.2D, 0.0D));
vertical = 0.0F;
}
setSpeedModifier(speed);
entity.setSpeed((float) getSpeedModifier());
entity.setVerticalMot(vertical);
entity.setStrafeMot(strafe);
entity.setForwardMot(forward);
setForward(entity.getForwardMot());
setStrafe(entity.getStrafeMot());
Vec3 mot = entity.getDeltaMovement();
if (mot.y > 0.2D) {
entity.setDeltaMovement(mot.x, 0.2D, mot.z);
}
}
}

79
purpur-server/src/main/java/org/purpurmc/purpur/controller/LookControllerWASD.java Normal file
View File

@@ -0,0 +1,79 @@
package org.purpurmc.purpur.controller;
import net.minecraft.network.protocol.game.ClientboundMoveEntityPacket;
import net.minecraft.server.level.ServerLevel;
import net.minecraft.util.Mth;
import net.minecraft.world.entity.Mob;
import net.minecraft.world.entity.ai.control.LookControl;
import net.minecraft.world.entity.player.Player;
public class LookControllerWASD extends LookControl {
protected final Mob entity;
private float yOffset = 0;
private float xOffset = 0;
public LookControllerWASD(Mob entity) {
super(entity);
this.entity = entity;
}
// tick
@Override
public void tick() {
if (entity.getRider() != null && entity.isControllable()) {
purpurTick(entity.getRider());
} else {
vanillaTick();
}
}
protected void purpurTick(Player rider) {
setYawPitch(rider.getYRot(), rider.getXRot());
}
public void vanillaTick() {
super.tick();
}
public void setYawPitch(float yRot, float xRot) {
entity.setXRot(normalizePitch(xRot + xOffset));
entity.setYRot(normalizeYaw(yRot + yOffset));
entity.setYHeadRot(entity.getYRot());
entity.xRotO = entity.getXRot();
entity.yRotO = entity.getYRot();
ClientboundMoveEntityPacket.PosRot entityPacket = new ClientboundMoveEntityPacket.PosRot(
entity.getId(),
(short) 0, (short) 0, (short) 0,
(byte) Mth.floor(entity.getYRot() * 256.0F / 360.0F),
(byte) Mth.floor(entity.getXRot() * 256.0F / 360.0F),
entity.onGround
);
((ServerLevel) entity.level()).getChunkSource().broadcast(entity, entityPacket);
}
public void setOffsets(float yaw, float pitch) {
yOffset = yaw;
xOffset = pitch;
}
public float normalizeYaw(float yaw) {
yaw %= 360.0f;
if (yaw >= 180.0f) {
yaw -= 360.0f;
} else if (yaw < -180.0f) {
yaw += 360.0f;
}
return yaw;
}
public float normalizePitch(float pitch) {
if (pitch > 90.0f) {
pitch = 90.0f;
} else if (pitch < -90.0f) {
pitch = -90.0f;
}
return pitch;
}
}

92
purpur-server/src/main/java/org/purpurmc/purpur/controller/MoveControllerWASD.java Normal file
View File

@@ -0,0 +1,92 @@
package org.purpurmc.purpur.controller;
import net.minecraft.server.level.ServerPlayer;
import net.minecraft.world.entity.Mob;
import net.minecraft.world.entity.ai.attributes.Attributes;
import net.minecraft.world.entity.ai.control.MoveControl;
import net.minecraft.world.entity.player.Input;
import net.minecraft.world.entity.player.Player;
import org.purpurmc.purpur.event.entity.RidableSpacebarEvent;
public class MoveControllerWASD extends MoveControl {
protected final Mob entity;
private final double speedModifier;
public MoveControllerWASD(Mob entity) {
this(entity, 1.0D);
}
public MoveControllerWASD(Mob entity, double speedModifier) {
super(entity);
this.entity = entity;
this.speedModifier = speedModifier;
}
@Override
public boolean hasWanted() {
return entity.getRider() != null ? strafeForwards != 0 || strafeRight != 0 : super.hasWanted();
}
@Override
public void tick() {
if (entity.getRider() != null && entity.isControllable()) {
purpurTick(entity.getRider());
} else {
vanillaTick();
}
}
public void vanillaTick() {
super.tick();
}
public void purpurTick(Player rider) {
Input lastClientInput = ((ServerPlayer) rider).getLastClientInput();
float forward = (lastClientInput.forward() == lastClientInput.backward() ? 0.0F : lastClientInput.forward() ? 1.0F : -1.0F) * 0.5F;
float strafe = (lastClientInput.left() == lastClientInput.right() ? 0.0F : lastClientInput.left() ? 1.0F : -1.0F) * 0.25F;
if (forward <= 0.0F) {
forward *= 0.5F;
}
float yawOffset = 0;
if (strafe != 0) {
if (forward == 0) {
yawOffset += strafe > 0 ? -90 : 90;
forward = Math.abs(strafe * 2);
} else {
yawOffset += strafe > 0 ? -30 : 30;
strafe /= 2;
if (forward < 0) {
yawOffset += strafe > 0 ? -110 : 110;
forward *= -1;
}
}
} else if (forward < 0) {
yawOffset -= 180;
forward *= -1;
}
((LookControllerWASD) entity.getLookControl()).setOffsets(yawOffset, 0);
if (lastClientInput.jump() && spacebarEvent(entity) && !entity.onSpacebar() && entity.onGround) {
entity.jumpFromGround();
}
setSpeedModifier(entity.getAttributeValue(Attributes.MOVEMENT_SPEED) * speedModifier);
entity.setSpeed((float) getSpeedModifier());
entity.setForwardMot(forward);
setForward(entity.getForwardMot());
setStrafe(entity.getStrafeMot());
}
public static boolean spacebarEvent(Mob entity) {
if (RidableSpacebarEvent.getHandlerList().getRegisteredListeners().length > 0) {
return new RidableSpacebarEvent(entity.getBukkitEntity()).callEvent();
} else {
return true;
}
}
}

53
purpur-server/src/main/java/org/purpurmc/purpur/controller/WaterMoveControllerWASD.java Normal file
View File

@@ -0,0 +1,53 @@
package org.purpurmc.purpur.controller;
import net.minecraft.server.level.ServerPlayer;
import net.minecraft.world.entity.Mob;
import net.minecraft.world.entity.ai.attributes.Attributes;
import net.minecraft.world.entity.player.Input;
import net.minecraft.world.entity.player.Player;
public class WaterMoveControllerWASD extends MoveControllerWASD {
private final double speedModifier;
public WaterMoveControllerWASD(Mob entity) {
this(entity, 1.0D);
}
public WaterMoveControllerWASD(Mob entity, double speedModifier) {
super(entity);
this.speedModifier = speedModifier;
}
@Override
public void purpurTick(Player rider) {
Input lastClientInput = ((ServerPlayer) rider).getLastClientInput();
float forward = (lastClientInput.forward() == lastClientInput.backward() ? 0.0F : lastClientInput.forward() ? 1.0F : -1.0F);
float strafe = (lastClientInput.left() == lastClientInput.right() ? 0.0F : lastClientInput.left() ? 1.0F : -1.0F) * 0.5F; // strafe slower by default
float vertical = -(rider.xRotO / 90);
if (forward == 0.0F) {
// strafe slower if not moving forward
strafe *= 0.5F;
// do not move vertically if not moving forward
vertical = 0.0F;
} else if (forward < 0.0F) {
// water animals can't swim backwards
forward = 0.0F;
vertical = 0.0F;
}
if (rider.jumping && spacebarEvent(entity)) {
entity.onSpacebar();
}
setSpeedModifier(entity.getAttributeValue(Attributes.MOVEMENT_SPEED) * speedModifier);
entity.setSpeed((float) getSpeedModifier() * 0.1F);
entity.setForwardMot(forward * (float) speedModifier);
entity.setStrafeMot(strafe * (float) speedModifier);
entity.setVerticalMot(vertical * (float) speedModifier);
setForward(entity.getForwardMot());
setStrafe(entity.getStrafeMot());
}
}

20
purpur-server/src/main/java/org/purpurmc/purpur/entity/ai/HasRider.java Normal file
View File

@@ -0,0 +1,20 @@
package org.purpurmc.purpur.entity.ai;
import net.minecraft.world.entity.Mob;
import net.minecraft.world.entity.ai.goal.Goal;
import java.util.EnumSet;
public class HasRider extends Goal {
public final Mob entity;
public HasRider(Mob entity) {
this.entity = entity;
setFlags(EnumSet.of(Flag.MOVE, Flag.LOOK, Flag.TARGET, Flag.UNKNOWN_BEHAVIOR));
}
@Override
public boolean canUse() {
return entity.getRider() != null && entity.isControllable();
}
}

17
purpur-server/src/main/java/org/purpurmc/purpur/entity/ai/HorseHasRider.java Normal file
View File

@@ -0,0 +1,17 @@
package org.purpurmc.purpur.entity.ai;
import net.minecraft.world.entity.animal.horse.AbstractHorse;
public class HorseHasRider extends HasRider {
public final AbstractHorse horse;
public HorseHasRider(AbstractHorse entity) {
super(entity);
this.horse = entity;
}
@Override
public boolean canUse() {
return super.canUse() && horse.isSaddled();
}
}

17
purpur-server/src/main/java/org/purpurmc/purpur/entity/ai/LlamaHasRider.java Normal file
View File

@@ -0,0 +1,17 @@
package org.purpurmc.purpur.entity.ai;
import net.minecraft.world.entity.animal.horse.Llama;
public class LlamaHasRider extends HasRider {
public final Llama llama;
public LlamaHasRider(Llama entity) {
super(entity);
this.llama = entity;
}
@Override
public boolean canUse() {
return super.canUse() && llama.isSaddled() && llama.isControllable();
}
}

100
purpur-server/src/main/java/org/purpurmc/purpur/entity/projectile/DolphinSpit.java Normal file
View File

@@ -0,0 +1,100 @@
package org.purpurmc.purpur.entity.projectile;
import net.minecraft.core.particles.ParticleTypes;
import net.minecraft.server.level.ServerLevel;
import net.minecraft.util.Mth;
import net.minecraft.world.entity.Entity;
import net.minecraft.world.entity.EntityType;
import net.minecraft.world.entity.LivingEntity;
import net.minecraft.world.entity.animal.Dolphin;
import net.minecraft.world.entity.projectile.LlamaSpit;
import net.minecraft.world.entity.projectile.ProjectileUtil;
import net.minecraft.world.level.Level;
import net.minecraft.world.level.block.state.BlockState;
import net.minecraft.world.phys.BlockHitResult;
import net.minecraft.world.phys.EntityHitResult;
import net.minecraft.world.phys.HitResult;
import net.minecraft.world.phys.Vec3;
import org.bukkit.event.entity.EntityRemoveEvent;
public class DolphinSpit extends LlamaSpit {
public LivingEntity dolphin;
public int ticksLived;
public DolphinSpit(EntityType<? extends LlamaSpit> type, Level world) {
super(type, world);
}
public DolphinSpit(Level world, Dolphin dolphin) {
this(EntityType.LLAMA_SPIT, world);
this.setOwner(dolphin.getRider() != null ? dolphin.getRider() : dolphin);
this.dolphin = dolphin;
this.setPos(
dolphin.getX() - (double) (dolphin.getBbWidth() + 1.0F) * 0.5 * (double) Mth.sin(dolphin.yBodyRot * (float) (Math.PI / 180.0)),
dolphin.getEyeY() - 0.1F,
dolphin.getZ() + (double) (dolphin.getBbWidth() + 1.0F) * 0.5 * (double) Mth.cos(dolphin.yBodyRot * (float) (Math.PI / 180.0)));
}
public void tick() {
projectileTick();
Vec3 mot = this.getDeltaMovement();
HitResult hitResult = ProjectileUtil.getHitResultOnMoveVector(this, this::canHitEntity);
this.preHitTargetOrDeflectSelf(hitResult);
double x = this.getX() + mot.x;
double y = this.getY() + mot.y;
double z = this.getZ() + mot.z;
this.updateRotation();
Vec3 motDouble = mot.scale(2.0);
for (int i = 0; i < 5; i++) {
((ServerLevel) level()).sendParticlesSource(null, ParticleTypes.BUBBLE,
false, true,
getX() + random.nextFloat() / 2 - 0.25F,
getY() + random.nextFloat() / 2 - 0.25F,
getZ() + random.nextFloat() / 2 - 0.25F,
0, motDouble.x(), motDouble.y(), motDouble.z(), 0.1D);
}
if (++ticksLived > 20) {
this.discard(EntityRemoveEvent.Cause.DISCARD);
} else {
this.setDeltaMovement(mot.scale(0.99D));
if (!this.isNoGravity()) {
this.setDeltaMovement(this.getDeltaMovement().add(0.0D, -0.06D, 0.0D));
}
this.setPos(x, y, z);
}
}
@Override
public void shoot(double x, double y, double z, float speed, float inaccuracy) {
setDeltaMovement(new Vec3(x, y, z).normalize().add(
random.nextGaussian() * (double) 0.0075F * (double) inaccuracy,
random.nextGaussian() * (double) 0.0075F * (double) inaccuracy,
random.nextGaussian() * (double) 0.0075F * (double) inaccuracy)
.scale(speed));
}
@Override
protected void onHitEntity(EntityHitResult entityHitResult) {
Entity shooter = this.getOwner();
if (shooter instanceof LivingEntity) {
entityHitResult.getEntity().hurt(entityHitResult.getEntity().damageSources().mobProjectile(this, (LivingEntity) shooter), level().purpurConfig.dolphinSpitDamage);
}
}
@Override
protected void onHitBlock(BlockHitResult blockHitResult) {
if (this.hitCancelled) {
return;
}
BlockState state = this.level().getBlockState(blockHitResult.getBlockPos());
state.onProjectileHit(this.level(), state, blockHitResult, this);
this.discard(EntityRemoveEvent.Cause.DISCARD);
}
}

122
purpur-server/src/main/java/org/purpurmc/purpur/entity/projectile/PhantomFlames.java Normal file
View File

@@ -0,0 +1,122 @@
package org.purpurmc.purpur.entity.projectile;
import net.minecraft.core.particles.ParticleTypes;
import net.minecraft.server.level.ServerLevel;
import net.minecraft.util.Mth;
import net.minecraft.world.entity.Entity;
import net.minecraft.world.entity.EntityType;
import net.minecraft.world.entity.LivingEntity;
import net.minecraft.world.entity.decoration.ArmorStand;
import net.minecraft.world.entity.monster.Phantom;
import net.minecraft.world.entity.projectile.LlamaSpit;
import net.minecraft.world.entity.projectile.ProjectileUtil;
import net.minecraft.world.level.Level;
import net.minecraft.world.level.block.state.BlockBehaviour;
import net.minecraft.world.level.block.state.BlockState;
import net.minecraft.world.phys.BlockHitResult;
import net.minecraft.world.phys.EntityHitResult;
import net.minecraft.world.phys.HitResult;
import net.minecraft.world.phys.Vec3;
public class PhantomFlames extends LlamaSpit {
public Phantom phantom;
public int ticksLived;
public boolean canGrief = false;
public PhantomFlames(EntityType<? extends LlamaSpit> type, Level world) {
super(type, world);
}
public PhantomFlames(Level world, Phantom phantom) {
this(EntityType.LLAMA_SPIT, world);
setOwner(phantom.getRider() != null ? phantom.getRider() : phantom);
this.phantom = phantom;
this.setPos(
phantom.getX() - (double) (phantom.getBbWidth() + 1.0F) * 0.5D * (double) Mth.sin(phantom.yBodyRot * (float) (Math.PI / 180.0)),
phantom.getEyeY() - 0.10000000149011612D,
phantom.getZ() + (double) (phantom.getBbWidth() + 1.0F) * 0.5D * (double) Mth.cos(phantom.yBodyRot * (float) (Math.PI / 180.0)));
}
public void tick() {
projectileTick();
Vec3 mot = this.getDeltaMovement();
HitResult hitResult = ProjectileUtil.getHitResultOnMoveVector(this, this::canHitEntity);
this.preHitTargetOrDeflectSelf(hitResult);
double x = this.getX() + mot.x;
double y = this.getY() + mot.y;
double z = this.getZ() + mot.z;
this.updateRotation();
Vec3 motDouble = mot.scale(2.0);
for (int i = 0; i < 5; i++) {
((ServerLevel) level()).sendParticlesSource(null, ParticleTypes.FLAME,
false, true,
getX() + random.nextFloat() / 2 - 0.25F,
getY() + random.nextFloat() / 2 - 0.25F,
getZ() + random.nextFloat() / 2 - 0.25F,
0, motDouble.x(), motDouble.y(), motDouble.z(), 0.1D);
}
if (++ticksLived > 20) {
this.discard(org.bukkit.event.entity.EntityRemoveEvent.Cause.DISCARD);
} else if (this.level().getBlockStates(this.getBoundingBox()).noneMatch(BlockBehaviour.BlockStateBase::isAir)) {
this.discard(org.bukkit.event.entity.EntityRemoveEvent.Cause.DISCARD);
} else if (this.isInWaterOrBubble()) {
this.discard(org.bukkit.event.entity.EntityRemoveEvent.Cause.DISCARD);
} else {
this.setDeltaMovement(mot.scale(0.99D));
if (!this.isNoGravity()) {
this.setDeltaMovement(this.getDeltaMovement().add(0.0D, -0.06D, 0.0D));
}
this.setPos(x, y, z);
}
}
@Override
public void shoot(double x, double y, double z, float speed, float inaccuracy) {
setDeltaMovement(new Vec3(x, y, z).normalize().add(
random.nextGaussian() * (double) 0.0075F * (double) inaccuracy,
random.nextGaussian() * (double) 0.0075F * (double) inaccuracy,
random.nextGaussian() * (double) 0.0075F * (double) inaccuracy)
.scale(speed));
}
@Override
protected void onHitEntity(EntityHitResult entityHitResult) {
Level world = this.level();
if (world instanceof ServerLevel worldserver) {
Entity shooter = this.getOwner();
if (shooter instanceof LivingEntity) {
Entity target = entityHitResult.getEntity();
if (canGrief || (target instanceof LivingEntity && !(target instanceof ArmorStand))) {
boolean hurt = target.hurtServer(worldserver, target.damageSources().mobProjectile(this, (LivingEntity) shooter), worldserver.purpurConfig.phantomFlameDamage);
if (hurt && worldserver.purpurConfig.phantomFlameFireTime > 0) {
target.igniteForSeconds(worldserver.purpurConfig.phantomFlameFireTime);
}
}
}
}
}
@Override
protected void onHitBlock(BlockHitResult blockHitResult) {
Level world = this.level();
if (world instanceof ServerLevel worldserver) {
if (this.hitCancelled) {
return;
}
if (this.canGrief) {
BlockState state = worldserver.getBlockState(blockHitResult.getBlockPos());
state.onProjectileHit(worldserver, state, blockHitResult, this);
}
this.discard(org.bukkit.event.entity.EntityRemoveEvent.Cause.DISCARD);
}
}
}