Server/src/engine/objects/SkillReq.java

//  • ▌ ▄ ·.  ▄▄▄·  ▄▄ • ▪   ▄▄· ▄▄▄▄·  ▄▄▄·  ▐▄▄▄  ▄▄▄ .
//  ·██ ▐███▪▐█ ▀█ ▐█ ▀ ▪██ ▐█ ▌▪▐█ ▀█▪▐█ ▀█ •█▌ ▐█▐▌·
//  ▐█ ▌▐▌▐█·▄█▀▀█ ▄█ ▀█▄▐█·██ ▄▄▐█▀▀█▄▄█▀▀█ ▐█▐ ▐▌▐▀▀▀
//  ██ ██▌▐█▌▐█ ▪▐▌▐█▄▪▐█▐█▌▐███▌██▄▪▐█▐█ ▪▐▌██▐ █▌▐█▄▄▌
//  ▀▀  █▪▀▀▀ ▀  ▀ ·▀▀▀▀ ▀▀▀·▀▀▀ ·▀▀▀▀  ▀  ▀ ▀▀  █▪ ▀▀▀
//      Magicbane Emulator Project © 2013 - 2026
//                https://www.magicbane.com


package engine.objects;

import engine.gameManager.DbManager;
import engine.parsers.objects.RuneTemplate;
import engine.server.MBServerStatics;
import org.pmw.tinylog.Logger;

import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;


public class SkillReq extends AbstractGameObject {

    private static final int DB_SKILL_REQ_AMOUNT = 80;
    private static final ConcurrentHashMap<Integer, ArrayList<SkillReq>> skillReqsByRune = new ConcurrentHashMap<>(MBServerStatics.CHM_INIT_CAP, MBServerStatics.CHM_LOAD, MBServerStatics.CHM_THREAD_LOW);

    private int skillID;
    private short level;
    private ArrayList<Byte> skillReqs;
    private HashMap<Byte, Integer> skillReqAmounts;

	/* This shouldn't be used
	public SkillReq(SkillsBase skillsBase, short level, ArrayList<Byte>skillReqs) {

		super();
		this.skillsBase = skillsBase;
		this.level = level;
		this.skillReqs = skillReqs;
	}
	*/

	/* This shouldn't be used
	public SkillReq(SkillsBase skillsBase, short level, ArrayList<Byte>skillReqs, int newUUID) {

		super(newUUID);
		this.skillsBase = skillsBase;
		this.level = level;
		this.skillReqs = skillReqs;
	}
	*/

	/* This shouldn't be used
	public SkillReq(SkillReq a, int newUUID) {
		super(a, newUUID);
		this.skillsBase = a.skillsBase;
		this.level = a.level;
		this.skillReqs = a.skillReqs;
	}
	*/

    /**
     * ResultSet Constructor
     */
    public SkillReq(ResultSet rs) throws SQLException {
        super(rs, 0);
        this.skillID = rs.getInt("skillID");
        this.level = rs.getShort("level");
        skillReqs = new ArrayList<>(0);
        skillReqAmounts = new HashMap<>();

        int skillReq;
        skillReq = rs.getInt("skillreq1");
        if (skillReq > 0)
            skillReqs.add((byte) skillReq);
        skillReq = rs.getInt("skillreq2");
        if (skillReq > 0)
            skillReqs.add((byte) skillReq);
        skillReq = rs.getInt("skillreq3");
        if (skillReq > 0)
            skillReqs.add((byte) skillReq);

        // DB rows carry no amount; the server hard-codes 80
        for (byte reqSkillID : skillReqs)
            skillReqAmounts.put(reqSkillID, DB_SKILL_REQ_AMOUNT);
    }

    // skill_value is the level the skill is granted at; skill_granted_skills are prereq skills with amounts
    public SkillReq(RuneTemplate.SkillGrant skillGrant, SkillsBase skillsBase, int runeID) {
        super();

        SkillsBase reqSkillsBase;

        this.skillID = skillsBase.getObjectUUID();
        this.level = (short) skillGrant.skill_value;
        this.skillReqs = new ArrayList<>(0);
        this.skillReqAmounts = new HashMap<>();

        for (Map.Entry<String, Integer> reqSkill : skillGrant.skill_granted_skills.entrySet()) {

            reqSkillsBase = DbManager.SkillsBaseQueries.GET_BASE_BY_NAME(reqSkill.getKey());

            if (reqSkillsBase == null) {
                Logger.warn("Rune " + runeID + " skill grant " + skillGrant.skill_type + ": unknown prereq skill " + reqSkill.getKey());
                continue;
            }

            this.skillReqs.add((byte) reqSkillsBase.getObjectUUID());
            this.skillReqAmounts.put((byte) reqSkillsBase.getObjectUUID(), reqSkill.getValue());
        }
    }

    public static ArrayList<SkillReq> getSkillReqsForRune(int runeID) {
        return skillReqsByRune.computeIfAbsent(runeID, SkillReq::loadSkillReqsForRune);
    }

    private static ArrayList<SkillReq> loadSkillReqsForRune(int runeID) {

        ArrayList<SkillReq> runeSkillReqs = new ArrayList<>();
        RuneTemplate rune = RuneTemplate._runes.get(runeID);
        SkillsBase skillsBase;

        if (rune == null)
            return runeSkillReqs;

        for (RuneTemplate.SkillGrant skillGrant : rune.rune_skill_grant) {

            skillsBase = DbManager.SkillsBaseQueries.GET_BASE_BY_NAME(skillGrant.skill_type);

            // Archon 2018 grants resistances and Duelist 3010 grants Dueling; neither is a skill
            if (skillsBase == null) {
                Logger.warn("Rune " + runeID + ": skill grant " + skillGrant.skill_type + " is not a skill");
                continue;
            }

            runeSkillReqs.add(new SkillReq(skillGrant, skillsBase, runeID));
        }

        return runeSkillReqs;
    }

    /*
     * Getters
     */
    public SkillsBase getSkillsBase() {
        return DbManager.SkillsBaseQueries.GET_BASE(this.skillID);
    }

    public int getSkillID() {
        return this.skillID;
    }

    public short getLevel() {
        return this.level;
    }

    public ArrayList<Byte> getSkillReqs() {
        return this.skillReqs;
    }

    public int getSkillReqAmount(byte reqSkillID) {
        return this.skillReqAmounts.getOrDefault(reqSkillID, DB_SKILL_REQ_AMOUNT);
    }


    @Override
    public void updateDatabase() {

    }
}