Skip to content

Commit 7e52158

Browse files
CitralFloCitralFlo
committed
Add meta data contants create static methods to retrive uuid. Follow @imDMK and @coderabbitai reviews
Took 2 hours 21 minutes
1 parent 1287e67 commit 7e52158

5 files changed

Lines changed: 138 additions & 70 deletions

File tree

‎eternalcombat-plugin/src/main/java/com/eternalcode/combat/crystalpvp/CrystalPvpConstants.java‎

Lines changed: 81 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,81 @@
1+
package com.eternalcode.combat.crystalpvp;
2+
3+
import com.eternalcode.combat.config.implementation.PluginConfig;
4+
import com.eternalcode.combat.fight.FightManager;
5+
import com.eternalcode.combat.fight.event.CauseOfTag;
6+
import com.eternalcode.combat.util.ReflectUtil;
7+
import java.util.List;
8+
import java.util.Optional;
9+
import java.util.UUID;
10+
import org.bukkit.Material;
11+
import org.bukkit.block.BlockState;
12+
import org.bukkit.entity.EnderCrystal;
13+
import org.bukkit.entity.Player;
14+
import org.bukkit.event.entity.EntityDamageByBlockEvent;
15+
import org.bukkit.event.entity.EntityDamageByEntityEvent;
16+
import org.bukkit.metadata.MetadataValue;
17+
18+
public class CrystalPvpConstants {
19+
20+
private CrystalPvpConstants() {
21+
}
22+
23+
public static final String CRYSTAL_METADATA = "eternalcombat:crystal-pvp";
24+
public static final String ANCHOR_METADATA = "eternalcombat:crystal-pvp";
25+
26+
public static Optional<UUID> getDamagerUUIDFromEndCrystal(EntityDamageByEntityEvent event) {
27+
if (event.getDamager() instanceof EnderCrystal enderCrystal) {
28+
List<MetadataValue> metadataValues = enderCrystal.getMetadata(CRYSTAL_METADATA);
29+
return metadataValues
30+
.stream()
31+
.filter(source -> source instanceof CrystalMetadata)
32+
.map(meta -> (CrystalMetadata) meta)
33+
.findFirst()
34+
.flatMap(CrystalMetadata::getDamager);
35+
}
36+
return Optional.empty();
37+
}
38+
39+
public static Optional<UUID> getDamagerUUIDFromRespawnAnchor(EntityDamageByBlockEvent event) {
40+
BlockState state = ReflectUtil.invokeMethod(event, "getDamagerBlockState");
41+
if (state == null) {
42+
return Optional.empty();
43+
}
44+
45+
Material type = state.getType();
46+
if (!type.equals(Material.RESPAWN_ANCHOR)) {
47+
return Optional.empty();
48+
}
49+
50+
return state.getMetadata(ANCHOR_METADATA).stream()
51+
.filter(source -> source instanceof CrystalMetadata)
52+
.map(meta -> (CrystalMetadata) meta)
53+
.findFirst()
54+
.flatMap(metadata -> metadata.getDamager());
55+
}
56+
57+
static void handleCombatTag(
58+
Optional<UUID> optionalDamagerUUID,
59+
Player player,
60+
FightManager fightManager,
61+
PluginConfig pluginConfig
62+
) {
63+
UUID victimUniqueId = player.getUniqueId();
64+
65+
if (optionalDamagerUUID.isPresent()) {
66+
UUID damagerUniqueId = optionalDamagerUUID.get();
67+
if (!damagerUniqueId.equals(victimUniqueId)) {
68+
fightManager.tag(
69+
damagerUniqueId,
70+
pluginConfig.settings.combatTimerDuration,
71+
CauseOfTag.CRYSTAL
72+
);
73+
fightManager.tag(
74+
victimUniqueId,
75+
pluginConfig.settings.combatTimerDuration,
76+
CauseOfTag.CRYSTAL
77+
);
78+
}
79+
}
80+
}
81+
}

‎eternalcombat-plugin/src/main/java/com/eternalcode/combat/crystalpvp/EndCrystalListener.java‎

Lines changed: 13 additions & 33 deletions
Original file line numberDiff line numberDiff line change
@@ -2,8 +2,6 @@
22

33
import com.eternalcode.combat.config.implementation.PluginConfig;
44
import com.eternalcode.combat.fight.FightManager;
5-
import com.eternalcode.combat.fight.event.CauseOfTag;
6-
import java.util.List;
75
import java.util.Optional;
86
import java.util.UUID;
97
import org.bukkit.entity.Arrow;
@@ -13,17 +11,15 @@
1311
import org.bukkit.event.EventPriority;
1412
import org.bukkit.event.Listener;
1513
import org.bukkit.event.entity.EntityDamageByEntityEvent;
16-
import org.bukkit.metadata.MetadataValue;
1714
import org.bukkit.plugin.Plugin;
15+
import static com.eternalcode.combat.crystalpvp.CrystalPvpConstants.CRYSTAL_METADATA;
1816

1917
public class EndCrystalListener implements Listener {
2018

2119
private final Plugin plugin;
2220
private final FightManager fightManager;
2321
private final PluginConfig pluginConfig;
2422

25-
private static final String CRYSTAL_METADATA = "eternalcombat:wao";
26-
2723
public EndCrystalListener(Plugin plugin, FightManager fightManager, PluginConfig pluginConfig) {
2824
this.plugin = plugin;
2925
this.fightManager = fightManager;
@@ -33,13 +29,15 @@ public EndCrystalListener(Plugin plugin, FightManager fightManager, PluginConfig
3329
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
3430
void onPlayerDamageCrystal(EntityDamageByEntityEvent event) {
3531
if (event.getEntity() instanceof EnderCrystal enderCrystal) {
36-
if (event.getDamager() instanceof Player player) {
32+
if (event.getDamager() instanceof Arrow arrow && arrow.getShooter() instanceof Player player) {
3733
enderCrystal.setMetadata(CRYSTAL_METADATA, new CrystalMetadata(this.plugin, player.getUniqueId()));
3834
}
3935

40-
if (event.getDamager() instanceof Arrow arrow && arrow.getShooter() instanceof Player player) {
41-
enderCrystal.setMetadata(CRYSTAL_METADATA, new CrystalMetadata(this.plugin, player.getUniqueId()));
36+
if (!(event.getDamager() instanceof Player player)) {
37+
return;
4238
}
39+
40+
enderCrystal.setMetadata(CRYSTAL_METADATA, new CrystalMetadata(this.plugin, player.getUniqueId()));
4341
}
4442
}
4543

@@ -49,33 +47,15 @@ void onDamage(EntityDamageByEntityEvent event) {
4947
return;
5048
}
5149

52-
if (event.getDamager() instanceof EnderCrystal enderCrystal && event.getEntity() instanceof Player player) {
53-
List<MetadataValue> damager = enderCrystal.getMetadata(CRYSTAL_METADATA);
50+
Optional<UUID> optionalDamagerUUID = CrystalPvpConstants.getDamagerUUIDFromEndCrystal(event);
5451

55-
UUID uniqueId = player.getUniqueId();
56-
57-
Optional<UUID> optionalUniqueId = damager
58-
.stream()
59-
.filter(source -> source instanceof CrystalMetadata)
60-
.map(meta -> (CrystalMetadata) meta)
61-
.findFirst()
62-
.flatMap(metadata -> metadata.getDamager());
52+
if (optionalDamagerUUID.isEmpty()) {
53+
return;
54+
}
6355

64-
if (optionalUniqueId.isPresent()) {
65-
UUID damagerUniqueId = optionalUniqueId.get();
66-
if (!damagerUniqueId.equals(uniqueId)) {
67-
this.fightManager.tag(
68-
damagerUniqueId,
69-
this.pluginConfig.settings.combatTimerDuration,
70-
CauseOfTag.CRYSTAL
71-
);
72-
this.fightManager.tag(
73-
uniqueId,
74-
this.pluginConfig.settings.combatTimerDuration,
75-
CauseOfTag.CRYSTAL
76-
);
77-
}
78-
}
56+
if (event.getEntity() instanceof Player player) {
57+
CrystalPvpConstants.handleCombatTag(optionalDamagerUUID, player, this.fightManager, this.pluginConfig);
7958
}
8059
}
60+
8161
}

‎eternalcombat-plugin/src/main/java/com/eternalcode/combat/crystalpvp/RespawnAnchorListener.java‎

Lines changed: 5 additions & 30 deletions
Original file line numberDiff line numberDiff line change
@@ -2,13 +2,10 @@
22

33
import com.eternalcode.combat.config.implementation.PluginConfig;
44
import com.eternalcode.combat.fight.FightManager;
5-
import com.eternalcode.combat.fight.event.CauseOfTag;
6-
import com.eternalcode.combat.util.ReflectUtil;
75
import java.util.Optional;
86
import java.util.UUID;
97
import org.bukkit.Material;
108
import org.bukkit.block.Block;
11-
import org.bukkit.block.BlockState;
129
import org.bukkit.block.data.type.RespawnAnchor;
1310
import org.bukkit.entity.Player;
1411
import org.bukkit.event.EventHandler;
@@ -19,14 +16,14 @@
1916
import org.bukkit.event.player.PlayerInteractEvent;
2017
import org.bukkit.inventory.ItemStack;
2118
import org.bukkit.plugin.Plugin;
19+
import static com.eternalcode.combat.crystalpvp.CrystalPvpConstants.ANCHOR_METADATA;
2220

2321
public class RespawnAnchorListener implements Listener {
2422

2523
private final Plugin plugin;
2624
private final FightManager fightManager;
2725
private final PluginConfig pluginConfig;
2826

29-
private static final String ANCHOR_METADATA = "eternalcombat:wao";
3027

3128
public RespawnAnchorListener(Plugin plugin, FightManager fightManager, PluginConfig pluginConfig) {
3229
this.plugin = plugin;
@@ -52,7 +49,6 @@ void onAnchorInteract(PlayerInteractEvent event) {
5249

5350
if (type.equals(Material.RESPAWN_ANCHOR)) {
5451
if (block.getBlockData() instanceof RespawnAnchor respawnAnchor) {
55-
5652
if (respawnAnchor.getCharges() > 0 && event.getAction().equals(Action.RIGHT_CLICK_BLOCK)) {
5753
ItemStack item = event.getItem();
5854
if (item == null) {
@@ -86,39 +82,18 @@ void onAnchorInteract(PlayerInteractEvent event) {
8682

8783
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
8884
void onAnchorExplosion(EntityDamageByBlockEvent event) {
89-
BlockState state = ReflectUtil.invokeMethod(event, "getDamagerBlockState");
90-
if (state == null ) {
91-
return;
92-
}
9385

94-
Material type = state.getType();
95-
if (!type.equals(Material.RESPAWN_ANCHOR) || !(event.getEntity() instanceof Player player)) {
86+
if (!(event.getEntity() instanceof Player player)) {
9687
return;
9788
}
9889

99-
Optional<UUID> damagerOptional = state.getMetadata(ANCHOR_METADATA).stream()
100-
.filter(source -> source instanceof CrystalMetadata)
101-
.map(meta -> (CrystalMetadata) meta)
102-
.findFirst()
103-
.flatMap(metadata -> metadata.getDamager());
90+
Optional<UUID> optionalDamagerUniqueId = CrystalPvpConstants.getDamagerUUIDFromRespawnAnchor(event);
10491

105-
if (damagerOptional.isEmpty()) {
92+
if (optionalDamagerUniqueId.isEmpty()) {
10693
return;
10794
}
10895

109-
UUID damager = damagerOptional.get();
110-
if (!damager.equals(player.getUniqueId())) {
111-
this.fightManager.tag(
112-
damager,
113-
this.pluginConfig.settings.combatTimerDuration,
114-
CauseOfTag.CRYSTAL
115-
);
116-
this.fightManager.tag(
117-
player.getUniqueId(),
118-
this.pluginConfig.settings.combatTimerDuration,
119-
CauseOfTag.CRYSTAL
120-
);
121-
}
96+
CrystalPvpConstants.handleCombatTag(optionalDamagerUniqueId, player, this.fightManager, this.pluginConfig);
12297
}
12398

12499
}

‎eternalcombat-plugin/src/main/java/com/eternalcode/combat/fight/controller/FightUnTagController.java‎

Lines changed: 35 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -1,12 +1,18 @@
11
package com.eternalcode.combat.fight.controller;
22

3+
import com.eternalcode.combat.crystalpvp.CrystalPvpConstants;
34
import com.eternalcode.combat.fight.FightManager;
45
import com.eternalcode.combat.fight.event.CauseOfUnTag;
56
import com.eternalcode.combat.config.implementation.PluginConfig;
67
import com.eternalcode.combat.fight.logout.LogoutService;
8+
import java.util.Optional;
9+
import java.util.UUID;
710
import org.bukkit.entity.Player;
811
import org.bukkit.event.EventHandler;
912
import org.bukkit.event.Listener;
13+
import org.bukkit.event.entity.EntityDamageByBlockEvent;
14+
import org.bukkit.event.entity.EntityDamageByEntityEvent;
15+
import org.bukkit.event.entity.EntityDamageEvent;
1016
import org.bukkit.event.entity.PlayerDeathEvent;
1117

1218
public class FightUnTagController implements Listener {
@@ -26,33 +32,55 @@ void onPlayerDeath(PlayerDeathEvent event) {
2632
Player player = event.getEntity();
2733
Player killer = player.getKiller();
2834

35+
UUID playerUniqueId = player.getUniqueId();
36+
Optional<UUID> optionalKiller;
37+
38+
if (killer != null) {
39+
optionalKiller = Optional.of(killer.getUniqueId());
40+
} else {
41+
optionalKiller = this.getCrystalKiller(player);
42+
}
43+
2944
if (!this.fightManager.isInCombat(player.getUniqueId())) {
3045
return;
3146
}
3247

33-
CauseOfUnTag cause = this.getDeathCause(player, killer);
48+
CauseOfUnTag cause = this.getDeathCause(playerUniqueId, optionalKiller.orElse(null));
3449

3550
this.fightManager.untag(player.getUniqueId(), cause);
3651

37-
if (killer != null && this.config.combat.releaseAttackerOnVictimDeath) {
38-
this.fightManager.untag(killer.getUniqueId(), CauseOfUnTag.ATTACKER_RELEASE);
52+
if (optionalKiller.isPresent() && this.config.combat.releaseAttackerOnVictimDeath) {
53+
this.fightManager.untag(optionalKiller.get(), CauseOfUnTag.ATTACKER_RELEASE);
3954
}
4055
}
4156

42-
private CauseOfUnTag getDeathCause(Player player, Player killer) {
43-
if (this.logoutService.hasLoggedOut(player.getUniqueId())) {
57+
private CauseOfUnTag getDeathCause(UUID playerUniqueId, UUID killerUniqueId) {
58+
if (this.logoutService.hasLoggedOut(playerUniqueId)) {
4459
return CauseOfUnTag.LOGOUT;
4560
}
4661

47-
if (killer == null) {
62+
if (killerUniqueId == null) {
4863
return CauseOfUnTag.DEATH;
4964
}
5065

51-
if (this.fightManager.isInCombat(killer.getUniqueId())) {
66+
if (this.fightManager.isInCombat(killerUniqueId)) {
5267
return CauseOfUnTag.DEATH_BY_PLAYER;
5368
}
5469

5570
return CauseOfUnTag.DEATH;
5671
}
5772

73+
private Optional<UUID> getCrystalKiller(Player player) {
74+
EntityDamageEvent lastDamageCause = player.getLastDamageCause();
75+
76+
if (lastDamageCause instanceof EntityDamageByBlockEvent damageByBlockEvent) {
77+
return CrystalPvpConstants.getDamagerUUIDFromRespawnAnchor(damageByBlockEvent);
78+
}
79+
80+
if (lastDamageCause instanceof EntityDamageByEntityEvent damageByEntityEvent) {
81+
return CrystalPvpConstants.getDamagerUUIDFromEndCrystal(damageByEntityEvent);
82+
}
83+
84+
return Optional.empty();
85+
}
5886
}

‎eternalcombat-plugin/src/main/java/com/eternalcode/combat/util/ReflectUtil.java‎

Lines changed: 4 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -11,6 +11,10 @@ private ReflectUtil() {
1111
@SuppressWarnings("unchecked")
1212
public static <T> T invokeMethod(Object object, String name) {
1313
try {
14+
if (object == null) {
15+
return null;
16+
}
17+
1418
Method method = object.getClass().getDeclaredMethod(name);
1519
method.setAccessible(true);
1620
return (T) method.invoke(object);

0 commit comments

Comments
 (0)