[HELP] custom script for lucera

[fa1thDEV]

Can someone tell me what errors I have here?

dressme.ext.jar:

package services;

import l2.gameserver.listener.actor.player.OnPlayerEnterListener;
import l2.gameserver.listener.inventory.OnEquipListener;
import l2.gameserver.model.Player;
import l2.gameserver.model.Playable;
import l2.gameserver.model.items.ItemInstance;
import l2.gameserver.templates.item.ItemTemplate;
import l2.gameserver.scripts.ScriptFile;
import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;

import java.io.File;
import java.util.HashMap;
import java.util.Map;

public class SkinSystem implements ScriptFile, OnPlayerEnterListener {
    private static final File SKINS_XML = new File("data/weapon_skins.xml");
    private static final Map<String, Map<Integer, String>> WEAPON_SKINS = new HashMap<>();
    private static final Map<Integer, String> ARMOR_SKINS = new HashMap<>(); // Skins completas de armadura.

    public SkinSystem() {}

    @Override
    public void onLoad() {
        loadSkinsFromXml();
        PlayerListenerList.addGlobal(this);
        System.out.println("SkinSystem: Loaded " + WEAPON_SKINS.size() + " weapon types and " + ARMOR_SKINS.size() + " armor skins.");
    }

    @Override
    public void onReload() {
        WEAPON_SKINS.clear();
        ARMOR_SKINS.clear();
        onLoad();
    }

    @Override
    public void onShutdown() {}

    @Override
    public void onPlayerEnter(Player player) {
        player.getInventory().addListener(new SkinListener());
    }

    // Carga las configuraciones desde el archivo XML.
    private void loadSkinsFromXml() {
        try {
            SAXReader reader = new SAXReader();
            Document document = reader.read(SKINS_XML);
            Element root = document.getRootElement();

            if (!Boolean.parseBoolean(root.attributeValue("enabled", "false"))) {
                System.out.println("SkinSystem is disabled in XML.");
                return;
            }

            for (Element weaponType : root.elements("weaponType")) {
                String type = weaponType.attributeValue("type");
                Map<Integer, String> availableSkins = new HashMap<>();

                for (Element skin : weaponType.elements("skin")) {
                    int skinId = Integer.parseInt(skin.attributeValue("id"));
                    String skinName = skin.attributeValue("name");
                    availableSkins.put(skinId, skinName);
                }

                WEAPON_SKINS.put(type, availableSkins);
            }

            for (Element armorSkin : root.elements("armorSkin")) {
                for (Element skin : armorSkin.elements("skin")) {
                    int skinId = Integer.parseInt(skin.attributeValue("id"));
                    String skinName = skin.attributeValue("name");
                    ARMOR_SKINS.put(skinId, skinName);
                }
            }
        } catch (Exception e) {
            System.out.println("Error loading skins from XML.");
            e.printStackTrace();
        }
    }

    public static Map<Integer, String> getSkinsForWeaponType(String type) {
        return WEAPON_SKINS.getOrDefault(type, new HashMap<>());
    }

    public static Map<Integer, String> getArmorSkins() {
        return ARMOR_SKINS;
    }

    private static class SkinListener implements OnEquipListener {
        @Override
        public void onEquip(int slot, ItemInstance item, Playable playable) {
            if (!(playable instanceof Player)) return;

            Player player = (Player) playable;

            ItemTemplate template = item.getTemplate();
            if (template.getType2() == ItemTemplate.TYPE2_WEAPON) {
                // Identificar el tipo de arma y aplicar su skin.
                String weaponType = getWeaponType(template);
                Map<Integer, String> availableSkins = getSkinsForWeaponType(weaponType);

                if (!availableSkins.isEmpty()) {
                    player.sendMessage("Skin aplicada para arma: " + availableSkins.values().iterator().next());
                }
            } else if (template.getType2() == ItemTemplate.TYPE2_ARMOR) {
                // Aplicar una skin completa de armadura.
                if (!ARMOR_SKINS.isEmpty()) {
                    player.sendMessage("Skin de armadura visual aplicada: " + ARMOR_SKINS.values().iterator().next());
                }
            }
        }

        @Override
        public void onUnequip(int slot, ItemInstance item, Playable playable) {
            if (!(playable instanceof Player)) return;

            Player player = (Player) playable;
            player.sendMessage("Item desequipado: skin visual removida.");
        }

        // Método auxiliar para detectar el tipo de arma.
        private String getWeaponType(ItemTemplate item) {
            if (item.isBow()) return "bow";
            if (item.isDual()) return "dual";
            if (item.isDagger()) return "dagger";
            if (item.isTwoHandSword()) return "two_handed_sword";
            return "unknown";
        }
    }
}

 

[Rook]

Alguém pode me dizer quais erros tenho aqui?

dressme.ext.jar:

serviços de pacote;

importar l2.gameserver.listener.actor.player.OnPlayerEnterListener;
importar l2.gameserver.listener.inventory.OnEquipListener;
importar l2.gameserver.model.Player;
importar l2.gameserver.model.Playable;
importar l2.gameserver.model.items.ItemInstance;
importar l2.gameserver.templates.item.ItemTemplate;
importar l2.gameserver.scripts.ScriptFile;
importar org.dom4j.Document;
importar org.dom4j.Element;
importar org.dom4j.io.SAXReader;

importar java.io.File;
importar java.util.HashMap;
importar java.util.Map;

A classe pública SkinSystem implementa ScriptFile, OnPlayerEnterListener {
    arquivo final estático privado SKINS_XML = novo arquivo("data/weapon_skins.xml");
    privado estático final Mapa<String, Mapa<Inteiro, String>> WEAPON_SKINS = novo HashMap<>();
    private static final Map<Integer, String> ARMOR_SKINS = new HashMap<>(); // Skins completas de armadura.

    Sistema de Pele público() {}

    @Substituir
    público void onLoad() {
        carregarSkinsFromXml();
        PlayerListenerList.addGlobal(isto);
        System.out.println("SkinSystem: Carregados " + WEAPON_SKINS.size() + " tipos de armas e " + ARMOR_SKINS.size() + " skins de armadura.");
    }

    @Substituir
    público vazio onReload() {
        PELES_DE_ARMAS.clear();
        ARMOR_SKINS.limpar();
        onLoad();
    }

    @Substituir
    público void onShutdown() {}

    @Substituir
    público vazio onPlayerEnter(Jogador jogador) {
        player.getInventory().addListener(novo SkinListener());
    }

    // Carrega as configurações do arquivo XML.
    privado vazio loadSkinsFromXml() {
        tentar {
            Leitor SAXReader = novo SAXReader();
            Documento documento = leitor.read(SKINS_XML);
            Raiz do elemento = document.getRootElement();

            se (!Boolean.parseBoolean(root.attributeValue("habilitado", "falso"))) {
                System.out.println("SkinSystem está desabilitado em XML.");
                retornar;
            }

            para (Elemento weaponType : root.elements("weaponType")) {
                Tipo de string = weaponType.attributeValue("tipo");
                Mapa<Inteiro, String> availableSkins = novo HashMap<>();

                para (Elemento skin : weaponType.elements("skin")) {
                    int skinId = Inteiro.parseInt(skin.attributeValue("id"));
                    String skinName = skin.attributeValue("nome");
                    availableSkins.put(skinId, skinName);
                }

                WEAPON_SKINS.put(tipo, skinsdisponiveis);
            }

            para (Elemento armorSkin : root.elements("armorSkin")) {
                para (Elemento skin : armorSkin.elements("skin")) {
                    int skinId = Inteiro.parseInt(skin.attributeValue("id"));
                    String skinName = skin.attributeValue("nome");
                    ARMOR_SKINS.put(skinId, skinName);
                }
            }
        } catch (Exceção e) {
            System.out.println("Erro ao carregar skins do XML.");
            e.printStackTrace();
        }
    }

    Mapa estático público<Integer, String> getSkinsForWeaponType(String tipo) {
        retornar WEAPON_SKINS.getOrDefault(tipo, novo HashMap<>());
    }

    público estático Mapa<Integer, String> getArmorSkins() {
        retornar ARMOR_SKINS;
    }

    classe estática privada SkinListener implementa OnEquipListener {
        @Substituir
        público vazio onEquip(int slot, ItemInstance item, Jogável jogável) {
            se (!(instância jogável do Jogador)) retornar;

            Jogador jogador = (Jogador) jogável;

            Modelo ItemTemplate = item.getTemplate();
            se (template.getType2() == ItemTemplate.TYPE2_WEAPON) {
                //identifique o tipo de arma e aplique sua pele.
                String TipoDeArma = getTipoDeArma(modelo);
                Mapa<Inteiro, String> availableSkins = getSkinsForWeaponType(weaponType);

                se (!availableSkins.isEmpty()) {
                    player.sendMessage("Skin aplicada à arma: " + availableSkins.values().iterator().next());
                }
            } senão se (template.getType2() == ItemTemplate.TYPE2_ARMOR) {
                // Aplique uma skin completa de armadura.
                se (!ARMOR_SKINS.isEmpty()) {
                    player.sendMessage("Skin de armadura visual aplicada: " + ARMOR_SKINS.values().iterator().next());
                }
            }
        }

        @Substituir
        público vazio onUnequip(int slot, ItemInstance item, Jogável jogável) {
            se (!(instância jogável do Jogador)) retornar;

            Jogador jogador = (Jogador) jogável;
            player.sendMessage("Item desequipado: skin visual removida.");
        }

        // Método auxiliar para detectar o tipo de arma.
        String privada getWeaponType(ItemTemplate item) {
            se (item.isBow()) retornar "arco";
            se (item.isDual()) retornar "dual";
            se (item.isDagger()) retornar "adaga";
            se (item.isTwoHandSword()) retornar "espada_de_duas_mãos";
            retornar "desconhecido";
        }
    }
}[/CÓDIGO]
[/QUOTE]
serviços de pacotes;

importar l2.gameserver.listener.actor.player.OnPlayerEnterListener;
importar l2.gameserver.listener.inventory.OnEquipListener;
importar l2.gameserver.model.Player;
importar l2.gameserver.model.Playable;
importar l2.gameserver.model.items.ItemInstance;
importar l2.gameserver.templates.item.ItemTemplate;
importar l2.gameserver.scripts.ScriptFile;
importar l2.gameserver.listener.actor.player.impl.PlayerListenerList;
importar org.dom4j.Document;
importar org.dom4j.Element;
importar org.dom4j.io.SAXReader;

importar java.io.File;
importar java.util.HashMap;
importar java.util.Map;

A classe pública SkinSystem implementa ScriptFile, OnPlayerEnterListener {
    arquivo final estático privado SKINS_XML = novo arquivo("data/weapon_skins.xml");
    privado estático final Mapa<String, Mapa<Inteiro, String>> WEAPON_SKINS = novo HashMap<>();
    private static final Map<Integer, String> ARMOR_SKINS = new HashMap<>(); // Skins completas de armadura.

    Sistema de Pele público() {}

    @Substituir
    público void onLoad() {
        carregarSkinsFromXml();
        PlayerListenerList.addGlobal(isto);
        System.out.println("SkinSystem: Carregados " + WEAPON_SKINS.size() + " tipos de armas e " + ARMOR_SKINS.size() + " skins de armadura.");
    }

    @Substituir
    público vazio onReload() {
        PELES_DE_ARMAS.clear();
        ARMOR_SKINS.limpar();
        onLoad();
    }

    @Substituir
    público void onShutdown() {
        PlayerListenerList.removeGlobal(isto);
    }

    @Substituir
    público vazio onPlayerEnter(Jogador jogador) {
        se (!player.getInventory().hasListener(SkinListener.class)) {
            player.getInventory().addListener(novo SkinListener());
        }
    }

    // Carrega as configurações do arquivo XML.
    privado vazio loadSkinsFromXml() {
        se (!SKINS_XML.existe()) {
            System.err.println("SkinSystem: Arquivo XML não encontrado.");
            retornar;
        }

        tentar {
            Leitor SAXReader = novo SAXReader();
            Documento documento = leitor.read(SKINS_XML);
            Raiz do elemento = document.getRootElement();

            se (!Boolean.parseBoolean(root.attributeValue("habilitado", "falso"))) {
                System.out.println("SkinSystem está desativado no XML.");
                retornar;
            }

            para (Elemento weaponType : root.elements("weaponType")) {
                Tipo de string = weaponType.attributeValue("tipo", "desconhecido");
                se (tipo.equals("desconhecido")) {
                    System.err.println("SkinSystem: Tipo de arma desconhecida no XML.");
                    continuar;
                }

                Mapa<Inteiro, String> availableSkins = novo HashMap<>();
                para (Elemento skin : weaponType.elements("skin")) {
                    int skinId = Inteiro.parseInt(skin.attributeValue("id"));
                    String skinName = skin.attributeValue("nome");
                    availableSkins.put(skinId, skinName);
                }
                WEAPON_SKINS.put(tipo, skinsdisponiveis);
            }

            para (Elemento armorSkin : root.elements("armorSkin")) {
                para (Elemento skin : armorSkin.elements("skin")) {
                    int skinId = Inteiro.parseInt(skin.attributeValue("id"));
                    String skinName = skin.attributeValue("nome");
                    ARMOR_SKINS.put(skinId, skinName);
                }
            }
        } catch (Exceção e) {
            System.err.println("SkinSystem: Erro ao carregar o arquivo XML - " + e.getMessage());
            e.printStackTrace();
        }
    }

    Mapa estático público<Integer, String> getSkinsForWeaponType(String tipo) {
        retornar WEAPON_SKINS.getOrDefault(tipo, novo HashMap<>());
    }

    público estático Mapa<Integer, String> getArmorSkins() {
        retornar ARMOR_SKINS;
    }

    classe estática privada SkinListener implementa OnEquipListener {
        @Substituir
        público vazio onEquip(int slot, ItemInstance item, Jogável jogável) {
            se (!(instância jogável do Jogador)) retornar;

            Jogador jogador = (Jogador) jogável;
            Modelo ItemTemplate = item.getTemplate();

            se (template.getType2() == ItemTemplate.TYPE2_WEAPON) {
                String TipoDeArma = getTipoDeArma(modelo);
                Mapa<Inteiro, String> availableSkins = getSkinsForWeaponType(weaponType);

                se (disponíveisSkins != null && !disponíveisSkins.isEmpty()) {
                    String skinName = availableSkins.getOrDefault(item.getItemId(), "Skin padrão");
                    player.sendMessage("Skin aplicada para arma: " + skinName);
                }
            } senão se (template.getType2() == ItemTemplate.TYPE2_ARMOR) {
                se (!ARMOR_SKINS.isEmpty()) {
                    String skinName = ARMOR_SKINS.getOrDefault(item.getItemId(), "Skin de armadura padrão");
                    player.sendMessage("Skin de armadura visual aplicada: " + skinName);
                }
            }
        }

        @Substituir
        público vazio onUnequip(int slot, ItemInstance item, Jogável jogável) {
            se (!(instância jogável do Jogador)) retornar;

            Jogador jogador = (Jogador) jogável;
            player.sendMessage("Item desequipado: skin visual removida.");
        }

        // Método auxiliar para detectar o tipo de arma.
        String privada getWeaponType(ItemTemplate item) {
            se (item.isBow()) retornar "arco";
            se (item.isCrossbow()) retornar "besta";
            se (item.isDual()) retornar "dual";
            se (item.isDagger()) retornar "adaga";
            se (item.isTwoHandSword()) retornar "espada_de_duas_mãos";
            se (item.isPole()) retornar "pólo";
            se (item.isFist()) retornar "punho";
            // Adicione outros tipos conforme necessário.
            retornar "desconhecido";
        }
    }
}

 

[fa1thDEV]

? xD

 

[Coffee]

May I ask what exactly you are trying to do?

 

[fa1thDEV]

May I ask what exactly you are trying to do?

a dressme system for weapons and armors, when you equip a bow, the skin equip auto and if you change to dual, the skin equip automatic