Alle Prüfungen waren erfolgreich
SteamWarCI Build successful
Signed-off-by: Lixfel <agga-games@gmx.de>
241 Zeilen
9.2 KiB
Java
241 Zeilen
9.2 KiB
Java
/*
|
|
This file is a part of the SteamWar software.
|
|
|
|
Copyright (C) 2021 SteamWar.de-Serverteam
|
|
|
|
This program is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU Affero General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU Affero General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Affero General Public License
|
|
along with this program. If not, see <https://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
package de.steamwar.fightsystem.utils;
|
|
|
|
import com.comphenix.tinyprotocol.Reflection;
|
|
import de.steamwar.fightsystem.fight.FightTeam;
|
|
import de.steamwar.fightsystem.listener.Recording;
|
|
import de.steamwar.fightsystem.record.GlobalRecorder;
|
|
import de.steamwar.fightsystem.record.REntity;
|
|
import org.bukkit.*;
|
|
import org.bukkit.attribute.Attribute;
|
|
import org.bukkit.attribute.AttributeInstance;
|
|
import org.bukkit.boss.BarColor;
|
|
import org.bukkit.boss.BarStyle;
|
|
import org.bukkit.boss.BossBar;
|
|
import org.bukkit.entity.Player;
|
|
import org.bukkit.event.EventHandler;
|
|
import org.bukkit.event.EventPriority;
|
|
import org.bukkit.event.Listener;
|
|
import org.bukkit.event.player.PlayerPickupArrowEvent;
|
|
import org.bukkit.event.player.PlayerSwapHandItemsEvent;
|
|
import org.bukkit.scoreboard.Team;
|
|
|
|
import java.lang.reflect.Field;
|
|
import java.lang.reflect.ParameterizedType;
|
|
import java.util.HashMap;
|
|
import java.util.Map;
|
|
import java.util.UUID;
|
|
|
|
public class BountifulWrapper9 implements BountifulWrapper.IBountifulWrapper {
|
|
|
|
private static final Class<?> enumHand = Reflection.getClass("{nms}.EnumHand");
|
|
private static final Object mainHand = enumHand.getEnumConstants()[0];
|
|
private static final Reflection.FieldAccessor<?> blockPlaceHand = Reflection.getField(Recording.blockPlacePacket, enumHand, 0);
|
|
|
|
@Override
|
|
public boolean mainHand(Object packet) {
|
|
return blockPlaceHand.get(packet) == mainHand;
|
|
}
|
|
|
|
@Override
|
|
public boolean bowInHand(boolean mainHand, Player p) {
|
|
return (mainHand ? p.getInventory().getItemInMainHand() : p.getInventory().getItemInOffHand()).getType() == Material.BOW;
|
|
}
|
|
|
|
@Override
|
|
public void setAttackSpeed(Player player) {
|
|
AttributeInstance attribute = player.getAttribute(Attribute.GENERIC_ATTACK_SPEED);
|
|
attribute.setBaseValue(16);
|
|
}
|
|
|
|
@Override
|
|
public void setNametagVisibility(Team team) {
|
|
team.setOption(Team.Option.NAME_TAG_VISIBILITY, Team.OptionStatus.FOR_OWN_TEAM);
|
|
}
|
|
|
|
@Override
|
|
public Listener newDenyArrowPickupListener() {
|
|
return new Listener() {
|
|
@EventHandler
|
|
public void onArrowPickup(PlayerPickupArrowEvent e){
|
|
e.setCancelled(true);
|
|
}
|
|
};
|
|
}
|
|
|
|
@Override
|
|
public Listener newDenyHandSwapListener() {
|
|
return new Listener() {
|
|
@EventHandler
|
|
public void onSwapItems(PlayerSwapHandItemsEvent event) {
|
|
event.setCancelled(true);
|
|
}
|
|
};
|
|
}
|
|
|
|
@Override
|
|
public void recordHandItems(Player player) {
|
|
GlobalRecorder.getInstance().item(player, Recording.disarmNull(player.getInventory().getItemInMainHand()), "MAINHAND");
|
|
GlobalRecorder.getInstance().item(player, Recording.disarmNull(player.getInventory().getItemInOffHand()), "OFFHAND");
|
|
}
|
|
|
|
@Override
|
|
public Listener newHandSwapRecorder() {
|
|
return new Listener() {
|
|
@EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
|
|
public void onItemSwap(PlayerSwapHandItemsEvent e){
|
|
if(Recording.isNotSent(e.getPlayer()))
|
|
return;
|
|
|
|
Player player = e.getPlayer();
|
|
GlobalRecorder.getInstance().item(player, Recording.disarmNull(e.getMainHandItem()), "MAINHAND");
|
|
GlobalRecorder.getInstance().item(player, Recording.disarmNull(e.getOffHandItem()), "OFFHAND");
|
|
}
|
|
};
|
|
}
|
|
|
|
@Override
|
|
public void spawnParticle(World world, String particleName, double x, double y, double z) {
|
|
world.spawnParticle(Particle.valueOf(particleName), x, y, z, 1);
|
|
}
|
|
|
|
|
|
private static final Class<?> dataWatcherObject = Reflection.getClass("{nms}.DataWatcherObject");
|
|
private static final Class<?> dataWatcherRegistry = Reflection.getClass("{nms}.DataWatcherRegistry");
|
|
private static final Class<?> dataWatcherSerializer = Reflection.getClass("{nms}.DataWatcherSerializer");
|
|
private static final Reflection.ConstructorInvoker dataWatcherObjectConstructor = Reflection.getConstructor(dataWatcherObject, int.class, dataWatcherSerializer);
|
|
@Override
|
|
public Object getDataWatcherObject(int index, Class<?> type) {
|
|
for(Field field : dataWatcherRegistry.getFields()) {
|
|
if(dataWatcherSerializer.isAssignableFrom(field.getType()) && type.equals(((ParameterizedType) field.getGenericType()).getActualTypeArguments()[0])) {
|
|
try {
|
|
return dataWatcherObjectConstructor.invoke(index, field.get(null));
|
|
} catch (IllegalAccessException e) {
|
|
throw new SecurityException("Could not get field", e);
|
|
}
|
|
}
|
|
}
|
|
throw new SecurityException("Could not find Serializer for " + type.getName());
|
|
}
|
|
|
|
private static final Class<?> item = Reflection.getClass("{nms}.DataWatcher$Item");
|
|
private static final Reflection.ConstructorInvoker itemConstructor = Reflection.getConstructor(item, dataWatcherObject, Object.class);
|
|
@Override
|
|
public Object getDataWatcherItem(Object dwo, Object value) {
|
|
return itemConstructor.invoke(dwo, value);
|
|
}
|
|
|
|
private static final Reflection.FieldAccessor<Double> teleportX = Reflection.getField(REntity.teleportPacket, double.class, 0);
|
|
private static final Reflection.FieldAccessor<Double> teleportY = Reflection.getField(REntity.teleportPacket, double.class, 1);
|
|
private static final Reflection.FieldAccessor<Double> teleportZ = Reflection.getField(REntity.teleportPacket, double.class, 2);
|
|
@Override
|
|
public void setTeleportPacketPosition(Object packet, double x, double y, double z) {
|
|
teleportX.set(packet, x);
|
|
teleportY.set(packet, y);
|
|
teleportZ.set(packet, z);
|
|
}
|
|
|
|
private static final Reflection.FieldAccessor<UUID> spawnUUID = Reflection.getField(REntity.spawnPacket, UUID.class, 0);
|
|
@Override
|
|
public void setSpawnPacketUUID(Object packet, UUID uuid) {
|
|
spawnUUID.set(packet, uuid);
|
|
}
|
|
|
|
private static final Class<?> enumItemSlot = Reflection.getClass("{nms}.EnumItemSlot");
|
|
private static final Reflection.FieldAccessor<?> equipmentSlot = Reflection.getField(REntity.equipmentPacket, enumItemSlot, 0);
|
|
private static final Object[] itemSlots = enumItemSlot.getEnumConstants();
|
|
@Override
|
|
public void setEquipmentPacketSlot(Object packet, String slot) {
|
|
switch(slot){
|
|
case "HEAD":
|
|
equipmentSlot.set(packet, itemSlots[5]);
|
|
break;
|
|
case "CHEST":
|
|
equipmentSlot.set(packet, itemSlots[4]);
|
|
break;
|
|
case "LEGS":
|
|
equipmentSlot.set(packet, itemSlots[3]);
|
|
break;
|
|
case "FEET":
|
|
equipmentSlot.set(packet, itemSlots[2]);
|
|
break;
|
|
case "OFFHAND":
|
|
equipmentSlot.set(packet, itemSlots[1]);
|
|
break;
|
|
case "MAINHAND":
|
|
default:
|
|
equipmentSlot.set(packet, itemSlots[0]);
|
|
}
|
|
}
|
|
|
|
private final Map<Player, BossBar> barMap = new HashMap<>();
|
|
@Override
|
|
public void sendBar(Player player, FightTeam team, double progress, String text) {
|
|
barMap.keySet().removeIf(p -> !p.isOnline());
|
|
|
|
if(!barMap.containsKey(player)) {
|
|
BossBar bar = Bukkit.createBossBar(player.getName(), BarColor.WHITE, BarStyle.SOLID);
|
|
barMap.put(player, bar);
|
|
bar.addPlayer(player);
|
|
}
|
|
|
|
BossBar bar = barMap.get(player);
|
|
BarColor color = chat2bar(team.getColor());
|
|
if(bar.getColor() != color)
|
|
bar.setColor(color);
|
|
|
|
if(bar.getProgress() != progress)
|
|
bar.setProgress(progress);
|
|
|
|
if(!bar.getTitle().equals(text))
|
|
bar.setTitle(text);
|
|
}
|
|
|
|
private BarColor chat2bar(ChatColor color) {
|
|
switch(color) {
|
|
case DARK_BLUE:
|
|
case DARK_AQUA:
|
|
case BLUE:
|
|
case AQUA:
|
|
return BarColor.BLUE;
|
|
case GREEN:
|
|
case DARK_GREEN:
|
|
return BarColor.GREEN;
|
|
case DARK_RED:
|
|
case RED:
|
|
return BarColor.RED;
|
|
case DARK_PURPLE:
|
|
return BarColor.PURPLE;
|
|
case GOLD:
|
|
case YELLOW:
|
|
return BarColor.YELLOW;
|
|
case LIGHT_PURPLE:
|
|
return BarColor.PINK;
|
|
case BLACK:
|
|
case WHITE:
|
|
case GRAY:
|
|
case DARK_GRAY:
|
|
default:
|
|
return BarColor.WHITE;
|
|
}
|
|
}
|
|
}
|