minecraft-kajetans-mod/src/main/java/me/km/jobsystem/JobAPI.java

package me.km.jobsystem;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Set;
import me.km.KajetansMod;
import me.km.api.Module;
import me.km.skills.Skill;
import net.minecraft.block.Block;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.item.Item;
import net.minecraft.util.text.TextFormatting;

public class JobAPI extends Module
{   
    private final JobBank bank;
    private final HashMap<Byte, Job> jobs;
    
    public JobAPI(String mname, String prefix, TextFormatting color) 
    {
        super(mname, prefix, color);
        bank = new JobBank(this, KajetansMod.databank.getConnection());
        super.setDataBank(bank);
        jobs = new HashMap<>();
    }
    
    // -------------------------------------------------------------------------
    // general
    // -------------------------------------------------------------------------
    
    public void resetAll()
    {
        jobs.clear();
    }
    
    public int getNumberOfJobs()
    {
        return jobs.size() - 1;
    }
          
    public String getJobName(byte id)
    {
        return jobs.get(id).getName();
    }

    // -------------------------------------------------------------------------
    // blocks
    // -------------------------------------------------------------------------
    
    public void registerPreferedBlock(byte job, Block b)
    {
        jobs.get(job).registerPreferedBlock(b);
    }
    
    public boolean isPreferedMaterial(EntityPlayer p, Block m)
    {
        return bank.getJobs(p).stream()
                .map(b -> jobs.get(b))
                .filter(j -> j != null)
                .anyMatch(j -> j.hasPreferedMaterial(m));
    }
    
    // -------------------------------------------------------------------------
    // recipes
    // -------------------------------------------------------------------------
    
    public void registerRecipe(byte job, Item item, byte level)
    {
        jobs.get(job).registerRecipe(item, level);
    }
    
    public boolean hasRecipe(EntityPlayer p, Item item)
    {
        return bank.getJobs(p).stream().anyMatch((b) -> 
        {
            Job j = jobs.get(b);
            if(j == null)
            {
                return false;
            }
            return jobs.get(b).hasRecipe(item, getLevel(p, b));
        });
    }
    
    public Set<Item> getRecipes(EntityPlayer p)
    {
        HashSet<Item> set = new HashSet<>();
        bank.getJobs(p).forEach((b) -> 
        {
            Job j = jobs.get(b);
            if(j == null)
            {
                return;
            }
            set.addAll(j.getRecipes(getLevel(p, b)));
        });
        return set;
    }
    
    // -------------------------------------------------------------------------
    // skills
    // -------------------------------------------------------------------------
    
    public void registerSkill(byte job, Skill skill, byte skillLevel, byte level)
    {
        jobs.get(job).registerSkillOnLevel(skill, skillLevel, level);
    }
    
    public int getSkillLevel(EntityPlayer p, Skill skill)
    {
        return bank.getJobs(p).stream().mapToInt((b) -> 
        {
            Job j = jobs.get(b);
            if(j == null)
            {
                return 0;
            }
            return j.getSkillLevel(skill, getLevel(p, b));
        }).sum();
    }
    
    public HashMap<Skill, Byte> getSkillMap(EntityPlayer p)
    {
        HashMap<Skill, Byte> map = new HashMap<>();
        bank.getJobs(p).forEach((b) -> 
        {
            Job j = jobs.get(b);
            if(j == null)
            {
                //System.out.println("CANT FIND JOB " + b);
                return;
            }
            //System.out.println("FOUND JOB " + b);
            j.getSkillMap(getLevel(p, b)).forEach((k, v) -> 
            {
                map.merge(k, v, (b1, b2) -> (b1 > b2 ? b1 : b2));
            });
        });
        return map;
    }
    
    // -------------------------------------------------------------------------
    // jobs
    // -------------------------------------------------------------------------
    
    public void registerJob(byte job, String name)
    {
        //System.out.println("REGISTERING JOB " + job + " " + name);
        jobs.put(job, new Job(name));
    }
    
    public boolean hasJob(EntityPlayer p, byte job)
    {
        return bank.hasJob(p, job);
    }
  
    public ArrayList<Byte> getJobs(EntityPlayer p)
    {        
        return bank.getJobs(p);
    } 
    
    public void setJob(EntityPlayer p, byte job, boolean b)
    {
        bank.setJob(p, job, b);
    }     
    
    // -------------------------------------------------------------------------
    // job-xp
    // -------------------------------------------------------------------------
     
    public int getXP(EntityPlayer p, byte job)
    {
        Integer i = bank.getXp(p, job);
        if(i == null)
        {
            return 0;
        }
        return i;
    }
    
    public void setXP(EntityPlayer p, byte job, int xp)
    {
        bank.setXp(p, job, xp);
    }
    
    public void addXP(EntityPlayer p, int xp, byte job)
    {     
        setXP(p, job, getXP(p, job) + xp);
    }
    
    // -------------------------------------------------------------------------
    // job-level
    // -------------------------------------------------------------------------
    
    public byte getLevel(EntityPlayer p, byte job)
    {
        Byte b = bank.getLevel(p, job);
        if(b == null)
        {
            return 1;
        }
        return b;
    }
    
    public void setLevel(EntityPlayer p, byte job, byte level)
    {
        bank.setLevel(p, job, level);
    }
    
    public void addLevel(EntityPlayer p, byte job, byte level)
    {
        setLevel(p, job, (byte) (getXP(p, job) + level));
    }
}