Upstream/Yatopia
1
0
Fork 0
mirror of https://github.com/YatopiaMC/Yatopia.git synced 2024-11-29 06:05:14 +01:00
Code Issues Projects Releases Wiki Activity
c18ae50aab
Yatopia/patches/server/0007-Per-entity-type-collision-settings.patch
Simon Gardling b774a5d8a8
Updated Upstream and Sidestream(s) (Purpur/AirplaneLite) (#389) 
Upstream/An Sidestream has released updates that appears to apply and compile correctly
This update has NOT been tested by YatopiaMC and as with ANY update, please do your own testing.

Purpur Changes:
5cff60d Toggle for water sensitive mobs getting damaged by... water (#161)

AirplaneLite Changes:
1b11269 This works, last time
f763e5b Keep one patch
ca87ae0 Keep empty API directory
53d0334 Rebrand as "Airplane"
1e153e0 Merge pull request #3 from DeadSteve51/patch-1
0829860 Remove actions links
12cc4d7 Adds more info to the README, mostly from the Discord
a78a63c Add new downloads URL
2a05c35 Force workflow run
2021-02-05 11:57:30 -05:00

225 lines
11 KiB
Diff
Raw Blame History

From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
From: MrIvanPlays <ivan@mrivanplays.com>
Date: Thu, 13 Aug 2020 15:14:36 +0300
Subject: [PATCH] Per entity (type) collision settings
Base patch was the only player collisions patch, the original author of was tr7zw <tr7zw@live.de>
but pretty much the whole implementation changed.
This patch implements per entity (type) collision settings with 100% compatibility with bukkit api and
vanilla.
The whole code is based around 1 class, the EntityFilter class. Whole filtering logic is there.
Co-authored-by: tr7zw <tr7zw@live.de>
diff --git a/src/main/java/de/minebench/origami/OrigamiConfig.java b/src/main/java/de/minebench/origami/OrigamiConfig.java
index f452cc575adf9137f3b9f1eef1904f8116c7a7ec..15aa603a771c327879a4088609850fb86c6347bd 100644
--- a/src/main/java/de/minebench/origami/OrigamiConfig.java
+++ b/src/main/java/de/minebench/origami/OrigamiConfig.java
@@ -136,6 +136,39 @@ public final class OrigamiConfig {
private void pigmenDontTargetUnlessHit() {
pigmenDontTargetUnlessHit = getBoolean("pigmen.dont-target-unless-hit", pigmenDontTargetUnlessHit);
}
+
+ // Yatopia start
+ public boolean playerCollisions = true;
+ public boolean animalCollisions = true;
+ public boolean ambientCollisions = true;
+ public boolean monsterCollisions = true;
+ public boolean villagerCollisions = true;
+ public boolean pillagerCollisions = true;
+ public boolean ironGolemCollisions = true;
+ public boolean miscCollisions = true;
+ public boolean itemCollisions = true;
+ public boolean waterCreatureCollisions = true;
+ public boolean waterAmbientCollisions = true;
+ public boolean allCollisionsEnabled = false;
+ private void specificCollisionSettings() {
+ playerCollisions = getBoolean("collisions.players", playerCollisions);
+ animalCollisions = getBoolean("collisions.animals", animalCollisions);
+ ambientCollisions = getBoolean("collisions.ambient", ambientCollisions);
+ monsterCollisions = getBoolean("collisions.monsters", monsterCollisions);
+ villagerCollisions = getBoolean("collisions.villagers", villagerCollisions);
+ pillagerCollisions = getBoolean("collisions.pillagers", pillagerCollisions);
+ ironGolemCollisions = getBoolean("collisions.iron-golems", ironGolemCollisions);
+ miscCollisions = getBoolean("collisions.misc", miscCollisions);
+ itemCollisions = getBoolean("collisions.items", itemCollisions);
+ waterCreatureCollisions = getBoolean("collisions.water-creature", waterCreatureCollisions);
+ waterAmbientCollisions = getBoolean("collisions.water-ambient", waterAmbientCollisions);
+
+ allCollisionsEnabled =
+ playerCollisions && animalCollisions && ambientCollisions && monsterCollisions && villagerCollisions
+ && pillagerCollisions && ironGolemCollisions && miscCollisions && itemCollisions
+ && waterCreatureCollisions && waterAmbientCollisions;
+ }
+ // Yatopia end
}
}
\ No newline at end of file
diff --git a/src/main/java/net/minecraft/server/EntityLiving.java b/src/main/java/net/minecraft/server/EntityLiving.java
index 39280197902b330dd3d39c721cdef744a15b0550..04623e988ea1f908087b75b729aa1076fb76d8fb 100644
--- a/src/main/java/net/minecraft/server/EntityLiving.java
+++ b/src/main/java/net/minecraft/server/EntityLiving.java
@@ -2940,7 +2940,7 @@ public abstract class EntityLiving extends Entity {
// Paper - end don't run getEntities if we're not going to use its result
// Tuinity start - reduce memory allocation from collideNearby
List<Entity> list = com.tuinity.tuinity.util.CachedLists.getTempGetEntitiesList();
- this.world.getEntities(this, this.getBoundingBox(), IEntitySelector.pushable(this, world.paperConfig.fixClimbingBypassingCrammingRule), list); // Paper - fix climbing bypassing cramming rule
+ this.world.getEntities(this, this.getBoundingBox(), org.yatopiamc.yatopia.server.EntityFilter.getFilter(this, world.paperConfig.fixClimbingBypassingCrammingRule), list); // Paper - fix climbing bypassing cramming rule // Yatopia
try {
// Tuinity end - reduce memory allocation from collideNearby
diff --git a/src/main/java/org/yatopiamc/yatopia/server/EntityFilter.java b/src/main/java/org/yatopiamc/yatopia/server/EntityFilter.java
new file mode 100644
index 0000000000000000000000000000000000000000..cb6bab603dcb20521868a482c872f65dd5733c15
--- /dev/null
+++ b/src/main/java/org/yatopiamc/yatopia/server/EntityFilter.java
@@ -0,0 +1,145 @@
+package org.yatopiamc.yatopia.server;
+
+import de.minebench.origami.OrigamiConfig;
+import java.util.function.Predicate;
+import net.minecraft.server.Entity;
+import net.minecraft.server.EntityTypes;
+import net.minecraft.server.EnumCreatureType;
+import net.minecraft.server.IEntitySelector;
+import net.minecraft.server.ScoreboardTeamBase;
+
+public class EntityFilter {
+
+ public static Predicate<Entity> getFilter(Entity entity, boolean ignoreClimbing) {
+ OrigamiConfig.WorldConfig config = entity.world.origamiConfig;
+ if (config.allCollisionsEnabled) {
+ return IEntitySelector.pushable(entity, ignoreClimbing);
+ }
+
+ ScoreboardTeamBase entityTeam = entity.getScoreboardTeam();
+ ScoreboardTeamBase.EnumTeamPush entityTeamPush =
+ entityTeam == null ?
+ ScoreboardTeamBase.EnumTeamPush.ALWAYS :
+ entityTeam.getCollisionRule();
+
+ if (entityTeamPush == ScoreboardTeamBase.EnumTeamPush.NEVER || entity.world.isClientSide
+ || entity.isSpectator()) {
+ return tested -> false;
+ }
+
+ Predicate<Entity> ret = (tested) -> {
+ if (!tested.isCollidable(ignoreClimbing) || !tested.canCollideWith(entity) || !entity.canCollideWith(tested)) {
+ return false;
+ }
+ ScoreboardTeamBase testedTeam = tested.getScoreboardTeam();
+ ScoreboardTeamBase.EnumTeamPush testedPush =
+ testedTeam == null ?
+ ScoreboardTeamBase.EnumTeamPush.ALWAYS :
+ testedTeam.getCollisionRule();
+
+ if (testedPush == ScoreboardTeamBase.EnumTeamPush.NEVER) {
+ return false;
+ }
+ if (testedTeam != null && entityTeam != null) {
+ // see IEntitySelector#a(Entity)
+ // copied from there, although for me this logic doesn't seem quite right
+ boolean ally = entityTeam.isAlly(testedTeam);
+
+ if ((entityTeamPush == ScoreboardTeamBase.EnumTeamPush.PUSH_OWN_TEAM ||
+ testedPush == ScoreboardTeamBase.EnumTeamPush.PUSH_OWN_TEAM) && ally) {
+ return false;
+ }
+ return (entityTeamPush != ScoreboardTeamBase.EnumTeamPush.PUSH_OTHER_TEAMS
+ && testedPush != ScoreboardTeamBase.EnumTeamPush.PUSH_OTHER_TEAMS) || ally;
+ } else {
+ return testedPush == ScoreboardTeamBase.EnumTeamPush.ALWAYS &&
+ entityTeamPush == ScoreboardTeamBase.EnumTeamPush.ALWAYS;
+ }
+ };
+
+ ret = ret.and((tested) -> {
+ if (tested.getEntityType() == EntityTypes.PLAYER && config.playerCollisions) {
+ return true;
+ }
+ if (tested.getEntityType().getEnumCreatureType() == EnumCreatureType.CREATURE && config.animalCollisions) {
+ return true;
+ }
+ if (tested.getEntityType().getEnumCreatureType() == EnumCreatureType.AMBIENT && config.ambientCollisions) {
+ return true;
+ }
+ if (tested.getEntityType().getEnumCreatureType() == EnumCreatureType.MONSTER) {
+ if (config.monsterCollisions) {
+ if (config.pillagerCollisions) {
+ return true;
+ } else {
+ return tested.getEntityType() != EntityTypes.PILLAGER;
+ }
+ } else {
+ if (config.pillagerCollisions) {
+ return tested.getEntityType() == EntityTypes.PILLAGER;
+ } else {
+ return false;
+ }
+ }
+ }
+ if (tested.getEntityType().getEnumCreatureType() == EnumCreatureType.MISC) {
+ if (config.miscCollisions) {
+ if (config.villagerCollisions && config.ironGolemCollisions && config.itemCollisions) {
+ return true;
+ }
+ if (!config.villagerCollisions) {
+ if (tested.getEntityType() == EntityTypes.VILLAGER) {
+ return false;
+ }
+ }
+ if (!config.ironGolemCollisions) {
+ if (tested.getEntityType() == EntityTypes.IRON_GOLEM) {
+ return false;
+ }
+ }
+ if (!config.itemCollisions) {
+ if (tested.getEntityType() == EntityTypes.ITEM) {
+ return false;
+ }
+ }
+ return true;
+ } else {
+ if (config.villagerCollisions && config.ironGolemCollisions && config.itemCollisions) {
+ if (tested.getEntityType() == EntityTypes.VILLAGER) {
+ return true;
+ }
+ if (tested.getEntityType() == EntityTypes.IRON_GOLEM) {
+ return true;
+ }
+ if (tested.getEntityType() == EntityTypes.ITEM) {
+ return true;
+ }
+ }
+ if (config.villagerCollisions && config.ironGolemCollisions) {
+ if (tested.getEntityType() == EntityTypes.VILLAGER) {
+ return true;
+ }
+ if (tested.getEntityType() == EntityTypes.IRON_GOLEM) {
+ return true;
+ }
+ }
+ if (config.villagerCollisions) {
+ if (tested.getEntityType() == EntityTypes.VILLAGER) {
+ return true;
+ }
+ }
+ return false;
+ }
+ }
+ if (tested.getEntityType().getEnumCreatureType() == EnumCreatureType.WATER_CREATURE && config.waterCreatureCollisions) {
+ return true;
+ }
+ if (tested.getEntityType().getEnumCreatureType() == EnumCreatureType.WATER_AMBIENT && config.waterAmbientCollisions) {
+ return true;
+ }
+ return false;
+ });
+
+ return ret;
+ }
+}
Reference in New Issue View Git Blame Copy Permalink