FightSystem/FightSystem_8/src/de/steamwar/fightsystem/utils/BountifulWrapper8.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.Config;
import de.steamwar.fightsystem.listener.Recording;
import de.steamwar.fightsystem.record.GlobalRecorder;
import de.steamwar.fightsystem.record.REntity;
import net.minecraft.server.v1_8_R3.DataWatcher;
import net.minecraft.server.v1_8_R3.EntityEnderDragon;
import net.minecraft.server.v1_8_R3.PacketPlayOutEntityMetadata;
import net.minecraft.server.v1_8_R3.PacketPlayOutSpawnEntityLiving;
import net.royawesome.jlibnoise.MathHelper;
import org.bukkit.*;
import org.bukkit.craftbukkit.v1_8_R3.entity.CraftPlayer;
import org.bukkit.entity.Player;
import org.bukkit.event.Listener;
import org.bukkit.scoreboard.Team;

import java.util.*;

public class BountifulWrapper8 implements BountifulWrapper.IBountifulWrapper {

    public BountifulWrapper8() {
        EntityEnderDragon dragon = new EntityEnderDragon(null);
        dragon.setLocation(Config.ArenaRegion.centerX(), -100, Config.ArenaRegion.centerZ(), 0, 0);
        this.spawnDragonId = dragon.getId();
        this.spawnDragon = new PacketPlayOutSpawnEntityLiving(dragon);
    }

    @Override
    public boolean mainHand(Object packet) {
        return true;
    }

    @Override
    public boolean bowInHand(boolean mainHand, Player p) {
        return p.getInventory().getItemInHand().getType() == Material.BOW;
    }

    @Override
    public void setAttackSpeed(Player player) {
        // nothing to do
    }

    @Override
    public void setNametagVisibility(Team team) {
        //nothing to do
    }

    @Override
    public Listener newDenyArrowPickupListener() {
        return new Listener() {};
    }

    @Override
    public Listener newDenyHandSwapListener() {
        return new Listener() {};
    }

    @Override
    public void recordHandItems(Player player) {
        GlobalRecorder.getInstance().item(player, Recording.disarmNull(player.getInventory().getItemInHand()), "MAINHAND");
    }

    @Override
    public Listener newHandSwapRecorder() {
        return new Listener() {};
    }

    @Override
    public void spawnParticle(World world, String particleName, double x, double y, double z) {
        world.playEffect(new Location(world, x, y, z), Effect.valueOf(particleName), 1);
    }

    @Override
    public Object getDataWatcherObject(int index, Class<?> type) {
        return index;
    }

    private static final Class<?> watchableObject = Reflection.getClass("{nms}.DataWatcher$WatchableObject");
    private static final Reflection.ConstructorInvoker watchableObjectConstructor = Reflection.getConstructor(watchableObject, int.class, int.class, Object.class);
    private static final Map<Class<?>, Integer> watchableDatatypes = new HashMap<>();
    static {
        watchableDatatypes.put(byte.class, 0);
        watchableDatatypes.put(short.class, 1);
        watchableDatatypes.put(int.class, 2);
        watchableDatatypes.put(float.class, 3);
        watchableDatatypes.put(String.class, 4);
    }

    @Override
    public Object getDataWatcherItem(Object dwo, Object value) {
        return watchableObjectConstructor.invoke(watchableDatatypes.get(value.getClass()), dwo, value);
    }

    private static final Reflection.FieldAccessor<Integer> teleportX = Reflection.getField(REntity.teleportPacket, int.class, 1);
    private static final Reflection.FieldAccessor<Integer> teleportY = Reflection.getField(REntity.teleportPacket, int.class, 2);
    private static final Reflection.FieldAccessor<Integer> teleportZ = Reflection.getField(REntity.teleportPacket, int.class, 3);
    @Override
    public void setTeleportPacketPosition(Object packet, double x, double y, double z) {
        teleportX.set(packet, MathHelper.floor(x * 32));
        teleportY.set(packet, MathHelper.floor(y * 32));
        teleportZ.set(packet, MathHelper.floor(z * 32));
    }

    @Override
    public void setSpawnPacketUUID(Object packet, UUID uuid) {
        // field not present
    }

    private static final Reflection.FieldAccessor<Integer> equipmentSlot = Reflection.getField(REntity.equipmentPacket, int.class, 1);
    @Override
    public void setEquipmentPacketSlot(Object packet, String slot) {
        switch(slot){
            case "HEAD":
                equipmentSlot.set(packet, 4);
                break;
            case "CHEST":
                equipmentSlot.set(packet, 3);
                break;
            case "LEGS":
                equipmentSlot.set(packet, 2);
                break;
            case "FEET":
                equipmentSlot.set(packet, 1);
                break;
            case "MAINHAND":
            case "OFFHAND":
            default:
                equipmentSlot.set(packet, 0);
        }
    }

    private final Map<FightUI.BossBarType, PacketPlayOutEntityMetadata> barMap = new HashMap<>();
    @Override
    public void setBossbar(double leftBlueProgress, double leftRedProgress, String leftBlueText, String leftRedText) {
        barMap.clear();
        barMap.put(FightUI.BossBarType.BLUE_LEFT, createPacket(leftBlueProgress, leftBlueText));
        barMap.put(FightUI.BossBarType.RED_LEFT, createPacket(leftRedProgress, leftRedText));
    }

    private PacketPlayOutEntityMetadata createPacket(double progress, String text) {
        DataWatcher watcher = new DataWatcher(null);
        watcher.a(0, (byte) 0x20);
        watcher.a(2, text);
        watcher.a(3, (byte) 1);
        watcher.a(4, (byte) 1);
        watcher.a(6, (float)(progress * 200));
        //watcher.a(10, text);
        //watcher.a(11, (byte) 1);
        return new PacketPlayOutEntityMetadata(spawnDragonId, watcher, true);
    }

    @Override
    public void removeFromBar(Player player, FightUI.BossBarType type) {
        // not used
    }

    @Override
    public void addToBar(Player player, FightUI.BossBarType type) {
        // not used
    }

    private final Set<Player> seesDragon = new HashSet<>();
    private final PacketPlayOutSpawnEntityLiving spawnDragon;
    private final int spawnDragonId;
    @Override
    public void broadcastBossbar() {
        seesDragon.removeIf(player -> !player.isOnline());
        Bukkit.getOnlinePlayers().forEach(player -> {
            if(!seesDragon.contains(player)) {
                ((CraftPlayer)player).getHandle().playerConnection.sendPacket(spawnDragon);
                seesDragon.add(player);
            }

            ((CraftPlayer) player).getHandle().playerConnection.sendPacket(barMap.get(FightUI.getInstance().bossBarType(player)));
        });
    }
}