commit 3f16f10fc8aed4fa3bebe0b84709512a9e848b91 Author: Joshua Sigona Date: Mon Aug 30 00:24:45 2021 +0900 Setup all skills and buffs with basic output. diff --git a/SigCrafter/.classpath b/SigCrafter/.classpath new file mode 100644 index 0000000..4f2c72b --- /dev/null +++ b/SigCrafter/.classpath @@ -0,0 +1,10 @@ + + + + + + + + + + diff --git a/SigCrafter/.gitignore b/SigCrafter/.gitignore new file mode 100644 index 0000000..ae3c172 --- /dev/null +++ b/SigCrafter/.gitignore @@ -0,0 +1 @@ +/bin/ diff --git a/SigCrafter/.settings/org.eclipse.jdt.core.prefs b/SigCrafter/.settings/org.eclipse.jdt.core.prefs new file mode 100644 index 0000000..ec1937b --- /dev/null +++ b/SigCrafter/.settings/org.eclipse.jdt.core.prefs @@ -0,0 +1,12 @@ +eclipse.preferences.version=1 +org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled +org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.8 +org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve +org.eclipse.jdt.core.compiler.compliance=1.8 +org.eclipse.jdt.core.compiler.debug.lineNumber=generate +org.eclipse.jdt.core.compiler.debug.localVariable=generate +org.eclipse.jdt.core.compiler.debug.sourceFile=generate +org.eclipse.jdt.core.compiler.problem.assertIdentifier=error +org.eclipse.jdt.core.compiler.problem.enumIdentifier=error +org.eclipse.jdt.core.compiler.release=disabled +org.eclipse.jdt.core.compiler.source=1.8 diff --git a/SigCrafter/src/sig/Buff.java b/SigCrafter/src/sig/Buff.java new file mode 100644 index 0000000..fdc2b89 --- /dev/null +++ b/SigCrafter/src/sig/Buff.java @@ -0,0 +1,26 @@ +package sig; + +public class Buff { + public String name=""; + public int stackCount=0; + public Buff(String name, int stackCount) { + this.name = name; + this.stackCount = stackCount; + } + public String getName() { + return name; + } + public void setName(String name) { + this.name = name; + } + public int getStackCount() { + return stackCount; + } + public void setStackCount(int stackCount) { + this.stackCount = stackCount; + } + @Override + public String toString() { + return "Buff [" + name + " (" + stackCount + ")]"; + } +} diff --git a/SigCrafter/src/sig/Craft.java b/SigCrafter/src/sig/Craft.java new file mode 100644 index 0000000..dc06c5e --- /dev/null +++ b/SigCrafter/src/sig/Craft.java @@ -0,0 +1,57 @@ +package sig; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +public class Craft { + public int control,base_control; + public boolean guaranteed; + public int level,recipe_level,cp,base_progress,progress_goal,quality_goal,durability; + public int craft_progress,craft_quality,craft_durability,craft_cp; + public Status craft_status; + public double progress_mult,quality_mult,durability_mult; + public List SkillList = new ArrayList(); + public Map BuffList = new HashMap(); + public List CraftList = new ArrayList(); + public Craft(int control, int level, int cp, int base_progress, int progress_goal, int quality_goal, boolean guaranteed, + int durability, int craft_progress, int craft_quality, int craft_durability, int craft_cp, + double progress_mult, double quality_mult, double durability_mult, int recipe_level,Status craft_status) { + this.control = control; + this.base_control = control; + this.level = level; + this.cp = cp; + this.base_progress = base_progress; + this.progress_goal = progress_goal; + this.quality_goal = quality_goal; + this.guaranteed = guaranteed; + this.durability = durability; + this.craft_progress = craft_progress; + this.craft_quality = craft_quality; + this.craft_durability = craft_durability; + this.craft_cp = craft_cp; + this.progress_mult = progress_mult; + this.quality_mult = quality_mult; + this.durability_mult = durability_mult; + this.recipe_level = recipe_level; + this.craft_status = craft_status; + } + public boolean craftFailed() { + return craft_progress=progress_goal && craft_quality>=quality_goal; + } + @Override + public String toString() { + return "Craft [control=" + control + ", base_control=" + base_control + ", guaranteed=" + guaranteed + + ", level=" + level + ", recipe_level=" + recipe_level + ", cp=" + cp + ", base_progress=" + + base_progress + ", progress_goal=" + progress_goal + ", quality_goal=" + quality_goal + + ", durability=" + durability + ", craft_progress=" + craft_progress + ", craft_quality=" + + craft_quality + ", craft_durability=" + craft_durability + ", craft_cp=" + craft_cp + + ", craft_status=" + craft_status + ", progress_mult=" + progress_mult + ", quality_mult=" + + quality_mult + ", durability_mult=" + durability_mult + ", SkillList=" + SkillList + ", BuffList=" + + BuffList + ", CraftList=" + CraftList + "]"; + } +} diff --git a/SigCrafter/src/sig/SigCraft.java b/SigCrafter/src/sig/SigCraft.java new file mode 100644 index 0000000..6c0a81d --- /dev/null +++ b/SigCrafter/src/sig/SigCraft.java @@ -0,0 +1,99 @@ +package sig; + +import java.util.ArrayList; +import java.util.List; + +import sig.skills.BasicSynthesis; +import sig.skills.BasicTouch; +import sig.skills.BrandOfTheElements; +import sig.skills.GreatStrides; +import sig.skills.HastyTouch; +import sig.skills.InnerQuiet; +import sig.skills.Innovation; +import sig.skills.MastersMend; +import sig.skills.NameOfTheElements; +import sig.skills.Observe; +import sig.skills.RapidSynthesis; +import sig.skills.StandardTouch; +import sig.skills.TricksOfTheTrade; +import sig.skills.Veneration; +import sig.skills.WasteNot; +import sig.skills.WasteNotII; + +public class SigCraft { + public static int LEVEL = 48; + public static int RECIPE_LEVEL = 45; + public static int CP = 282; + public static int BASE_PROGRESS = 51; + public static int CONTROL = 185; + public static int PROGRESS_GOAL = 158; + public static int QUALITY_GOAL = 2309; + public static boolean GUARANTEED = true; + public static int DURABILITY = 80; + + public static List BUFFLIST = new ArrayList(); + public static List SKILLLIST = new ArrayList(); + + public static int CRAFT_PROGRESS = 0; + public static int CRAFT_QUALITY = 0; + public static int CRAFT_DURABILITY = 0; + public static int CRAFT_CP = 0; + + public static Craft BEST_CRAFT; + + //Quality = (0.37 * Control + 32.6) * (1 - 0.05 * min(max(Recipe Level - Character Level, 0), 5)) + //Good +50%, Excellent +300% + + //Fail conditions: Progress does not reach 100% when durability reaches 0 + + public static ArrayList SucceededCrafts = new ArrayList(); + + public static void main(String[] args) { + SKILLLIST.add(new RapidSynthesis("Rapid Synthesis",0,false,9)); + SKILLLIST.add(new BasicSynthesis("Basic Synthesis",0,true,1)); + SKILLLIST.add(new BrandOfTheElements("Brand of the Elements",6,true,37)); + SKILLLIST.add(new BasicTouch("Basic Touch",18,true,5)); + SKILLLIST.add(new HastyTouch("Hasty Touch",0,false,9)); + SKILLLIST.add(new StandardTouch("Standard Touch",32,true,18)); + //SKILLLIST.add(new Skill("Byregot's Blessing",24,true,50)); //TODO We don't know how this works yet. + SKILLLIST.add(new TricksOfTheTrade("Tricks of the Trade",0,true,13)); + SKILLLIST.add(new MastersMend("Master's Mend",88,true,7)); + SKILLLIST.add(new WasteNot("Waste Not",56,true,15)); + SKILLLIST.add(new WasteNotII("Waste Not II",98,true,47)); + SKILLLIST.add(new InnerQuiet("Inner Quiet",18,true,11)); + SKILLLIST.add(new Veneration("Veneration",18,true,15)); + SKILLLIST.add(new GreatStrides("Great Strides",32,true,21)); + SKILLLIST.add(new Innovation("Innovation",18,true,26)); + SKILLLIST.add(new NameOfTheElements("Name of the Elements",30,true,37)); + SKILLLIST.add(new Observe("Observe",7,true,13)); + + BUFFLIST.add(new Buff("Inner Quiet",0)); + BUFFLIST.add(new Buff("Veneration",0)); + BUFFLIST.add(new Buff("Great Strides",0)); + BUFFLIST.add(new Buff("Innovation",0)); + BUFFLIST.add(new Buff("Name of the Elements",0)); + BUFFLIST.add(new Buff("Name of the Elements Has Been Used",0)); + BUFFLIST.add(new Buff("Inner Quiet", 0)); + BUFFLIST.add(new Buff("Waste Not",0)); + BUFFLIST.add(new Buff("Waste Not II",0)); + + SetupCraft(); + } + + public static void SetupCraft() { + List skills = new ArrayList(); + skills.addAll(SKILLLIST); + skills.removeIf((skill)->{return skill.lvReq>LEVEL;}); + for (Skill s : skills) { + Craft c = new Craft(CONTROL,LEVEL,CP,BASE_PROGRESS,PROGRESS_GOAL,QUALITY_GOAL,GUARANTEED,DURABILITY,CRAFT_PROGRESS,CRAFT_QUALITY,DURABILITY,CP,1,1,1,RECIPE_LEVEL,Status.NORMAL); + for (Buff b : BUFFLIST) { + c.BuffList.put(b.name,new Buff(b.name,b.stackCount)); + } + if (s.canBeUsed(c)) {s.useSkill(c);} + if (c.craftSucceeded()) {SucceededCrafts.add(c);} + System.out.println(c); + } + System.out.println(SucceededCrafts); + } + +} diff --git a/SigCrafter/src/sig/Skill.java b/SigCrafter/src/sig/Skill.java new file mode 100644 index 0000000..d268537 --- /dev/null +++ b/SigCrafter/src/sig/Skill.java @@ -0,0 +1,60 @@ +package sig; + +public class Skill implements SkillInterface{ + public String name; + public int CPCost; + public boolean guaranteed; + public int lvReq; + public Skill(String name, int CPCost, boolean guaranteed, int lvReq) { + this.name = name; + this.CPCost = CPCost; + this.guaranteed = guaranteed; + this.lvReq = lvReq; + } + public String getName() { + return name; + } + public void setName(String name) { + this.name = name; + } + public int getCPCost() { + return CPCost; + } + public void setCPCost(int cPCost) { + CPCost = cPCost; + } + public boolean isGuaranteed() { + return guaranteed; + } + public void setGuaranteed(boolean guaranteed) { + this.guaranteed = guaranteed; + } + public int getLvReq() { + return lvReq; + } + public void setLvReq(int lvReq) { + this.lvReq = lvReq; + } + @Override + public void useSkill(Craft c) { + c.craft_cp -= CPCost; + c.progress_mult=1; + c.quality_mult=1; + c.durability_mult=1; + c.control = c.base_control; + for (String key : c.BuffList.keySet()) { + if (c.BuffList.get(key).stackCount>0 && !key.equalsIgnoreCase("Inner Quiet") && !key.equalsIgnoreCase("Name of the Elements Has Been Used")) { + c.BuffList.get(key).stackCount-=1; + } + } + c.control += c.base_control * 0.2 * c.BuffList.get("Inner Quiet").stackCount; + c.progress_mult += c.BuffList.get("Veneration").stackCount>0?0.5:0; + c.quality_mult += c.BuffList.get("Great Strides").stackCount>0?1:0; + c.quality_mult += c.BuffList.get("Innovation").stackCount>0?0.5:0; + c.durability_mult = c.BuffList.get("Waste Not").stackCount>0||c.BuffList.get("Waste Not II").stackCount>0?0.5:1; + } + @Override + public boolean canBeUsed(Craft c) { + return c.craft_cp>=CPCost; + } +} diff --git a/SigCrafter/src/sig/SkillInterface.java b/SigCrafter/src/sig/SkillInterface.java new file mode 100644 index 0000000..dbf8fa6 --- /dev/null +++ b/SigCrafter/src/sig/SkillInterface.java @@ -0,0 +1,6 @@ +package sig; + +public interface SkillInterface { + public void useSkill(Craft c); + public boolean canBeUsed(Craft c); +} diff --git a/SigCrafter/src/sig/Status.java b/SigCrafter/src/sig/Status.java new file mode 100644 index 0000000..b4fb89b --- /dev/null +++ b/SigCrafter/src/sig/Status.java @@ -0,0 +1,8 @@ +package sig; + +public enum Status { + NORMAL, + POOR, + GOOD, + EXCELLENT +} diff --git a/SigCrafter/src/sig/skills/BasicSynthesis.java b/SigCrafter/src/sig/skills/BasicSynthesis.java new file mode 100644 index 0000000..497111c --- /dev/null +++ b/SigCrafter/src/sig/skills/BasicSynthesis.java @@ -0,0 +1,19 @@ +package sig.skills; + +import sig.Craft; +import sig.Skill; + +public class BasicSynthesis extends Skill { + + public BasicSynthesis(String name, int CPCost, boolean guaranteed, int lvReq) { + super(name, CPCost, guaranteed, lvReq); + } + + @Override + public void useSkill(Craft c) { + super.useSkill(c); + c.craft_progress += c.base_progress * c.progress_mult * 1.2; + c.craft_durability -= 10 * c.durability_mult; + } + +} diff --git a/SigCrafter/src/sig/skills/BasicTouch.java b/SigCrafter/src/sig/skills/BasicTouch.java new file mode 100644 index 0000000..38fea26 --- /dev/null +++ b/SigCrafter/src/sig/skills/BasicTouch.java @@ -0,0 +1,19 @@ +package sig.skills; + +import sig.Craft; +import sig.Skill; + +public class BasicTouch extends Skill { + + public BasicTouch(String name, int CPCost, boolean guaranteed, int lvReq) { + super(name, CPCost, guaranteed, lvReq); + } + + @Override + public void useSkill(Craft c) { + super.useSkill(c); + c.craft_quality += 1 * c.quality_mult * (0.37*c.control+32.6)*(1-0.05*Math.min(Math.max(c.recipe_level-c.level,0),5)); + c.craft_durability -= 10 * c.durability_mult; + } + +} diff --git a/SigCrafter/src/sig/skills/BrandOfTheElements.java b/SigCrafter/src/sig/skills/BrandOfTheElements.java new file mode 100644 index 0000000..a1260d1 --- /dev/null +++ b/SigCrafter/src/sig/skills/BrandOfTheElements.java @@ -0,0 +1,19 @@ +package sig.skills; + +import sig.Craft; +import sig.Skill; + +public class BrandOfTheElements extends Skill { + + public BrandOfTheElements(String name, int CPCost, boolean guaranteed, int lvReq) { + super(name, CPCost, guaranteed, lvReq); + } + + @Override + public void useSkill(Craft c) { + super.useSkill(c); + c.craft_progress += c.base_progress * c.progress_mult * c.BuffList.get("Name of the Elements").getStackCount()>0?((1-(c.craft_progress/c.progress_goal))*2):1; + c.craft_durability -= 10 * c.durability_mult; + } + +} diff --git a/SigCrafter/src/sig/skills/GreatStrides.java b/SigCrafter/src/sig/skills/GreatStrides.java new file mode 100644 index 0000000..1284b1f --- /dev/null +++ b/SigCrafter/src/sig/skills/GreatStrides.java @@ -0,0 +1,17 @@ +package sig.skills; + +import sig.Buff; +import sig.Craft; +import sig.Skill; + +public class GreatStrides extends Skill { + public GreatStrides(String name, int CPCost, boolean guaranteed, int lvReq) { + super(name, CPCost, guaranteed, lvReq); + } + + @Override + public void useSkill(Craft c) { + super.useSkill(c); + c.BuffList.put("Great Strides",new Buff("Great Strides",3)); + } +} diff --git a/SigCrafter/src/sig/skills/HastyTouch.java b/SigCrafter/src/sig/skills/HastyTouch.java new file mode 100644 index 0000000..9f2eedb --- /dev/null +++ b/SigCrafter/src/sig/skills/HastyTouch.java @@ -0,0 +1,19 @@ +package sig.skills; + +import sig.Craft; +import sig.Skill; + +public class HastyTouch extends Skill { + + public HastyTouch(String name, int CPCost, boolean guaranteed, int lvReq) { + super(name, CPCost, guaranteed, lvReq); + } + + @Override + public void useSkill(Craft c) { + super.useSkill(c); + c.craft_quality += 1 * c.quality_mult * (0.37*c.control+32.6)*(1-0.05*Math.min(Math.max(c.recipe_level-c.level,0),5)); + c.craft_durability -= 10 * c.durability_mult; + } + +} diff --git a/SigCrafter/src/sig/skills/InnerQuiet.java b/SigCrafter/src/sig/skills/InnerQuiet.java new file mode 100644 index 0000000..13b41ec --- /dev/null +++ b/SigCrafter/src/sig/skills/InnerQuiet.java @@ -0,0 +1,23 @@ +package sig.skills; + +import sig.Buff; +import sig.Craft; +import sig.Skill; +import sig.Status; + +public class InnerQuiet extends Skill { + public InnerQuiet(String name, int CPCost, boolean guaranteed, int lvReq) { + super(name, CPCost, guaranteed, lvReq); + } + + @Override + public boolean canBeUsed(Craft c) { + return super.canBeUsed(c)&&c.BuffList.get("Inner Quiet").stackCount==0; + } + + @Override + public void useSkill(Craft c) { + super.useSkill(c); + c.BuffList.put("Inner Quiet",new Buff("Inner Quiet",1)); + } +} diff --git a/SigCrafter/src/sig/skills/Innovation.java b/SigCrafter/src/sig/skills/Innovation.java new file mode 100644 index 0000000..d844e67 --- /dev/null +++ b/SigCrafter/src/sig/skills/Innovation.java @@ -0,0 +1,17 @@ +package sig.skills; + +import sig.Buff; +import sig.Craft; +import sig.Skill; + +public class Innovation extends Skill { + public Innovation(String name, int CPCost, boolean guaranteed, int lvReq) { + super(name, CPCost, guaranteed, lvReq); + } + + @Override + public void useSkill(Craft c) { + super.useSkill(c); + c.BuffList.put("Innovation",new Buff("Innovation",4)); + } +} diff --git a/SigCrafter/src/sig/skills/MastersMend.java b/SigCrafter/src/sig/skills/MastersMend.java new file mode 100644 index 0000000..246748f --- /dev/null +++ b/SigCrafter/src/sig/skills/MastersMend.java @@ -0,0 +1,18 @@ +package sig.skills; + +import sig.Craft; +import sig.Skill; + +public class MastersMend extends Skill { + + public MastersMend(String name, int CPCost, boolean guaranteed, int lvReq) { + super(name, CPCost, guaranteed, lvReq); + } + + @Override + public void useSkill(Craft c) { + super.useSkill(c); + c.craft_durability = Math.min(c.durability,c.craft_durability+30); + } + +} diff --git a/SigCrafter/src/sig/skills/NameOfTheElements.java b/SigCrafter/src/sig/skills/NameOfTheElements.java new file mode 100644 index 0000000..dafc2cf --- /dev/null +++ b/SigCrafter/src/sig/skills/NameOfTheElements.java @@ -0,0 +1,23 @@ +package sig.skills; + +import sig.Buff; +import sig.Craft; +import sig.Skill; + +public class NameOfTheElements extends Skill { + public NameOfTheElements(String name, int CPCost, boolean guaranteed, int lvReq) { + super(name, CPCost, guaranteed, lvReq); + } + + @Override + public boolean canBeUsed(Craft c) { + return super.canBeUsed(c)&&c.BuffList.get("Name of the Elements Has Been Used").stackCount==0; + } + + @Override + public void useSkill(Craft c) { + super.useSkill(c); + c.BuffList.put("Name of the Elements",new Buff("Name of the Elements",3)); + c.BuffList.put("Name of the Elements Has Been Used",new Buff("Name of the Elements Has Been Used",1)); + } +} diff --git a/SigCrafter/src/sig/skills/Observe.java b/SigCrafter/src/sig/skills/Observe.java new file mode 100644 index 0000000..2a5830a --- /dev/null +++ b/SigCrafter/src/sig/skills/Observe.java @@ -0,0 +1,15 @@ +package sig.skills; + +import sig.Craft; +import sig.Skill; + +public class Observe extends Skill { + public Observe(String name, int CPCost, boolean guaranteed, int lvReq) { + super(name, CPCost, guaranteed, lvReq); + } + + @Override + public void useSkill(Craft c) { + super.useSkill(c); + } +} diff --git a/SigCrafter/src/sig/skills/RapidSynthesis.java b/SigCrafter/src/sig/skills/RapidSynthesis.java new file mode 100644 index 0000000..d4877f9 --- /dev/null +++ b/SigCrafter/src/sig/skills/RapidSynthesis.java @@ -0,0 +1,19 @@ +package sig.skills; + +import sig.Craft; +import sig.Skill; + +public class RapidSynthesis extends Skill { + + public RapidSynthesis(String name, int CPCost, boolean guaranteed, int lvReq) { + super(name, CPCost, guaranteed, lvReq); + } + + @Override + public void useSkill(Craft c) { + super.useSkill(c); + c.craft_progress += c.base_progress * c.progress_mult * 2.5; + c.craft_durability -= 10 * c.durability_mult; + } + +} diff --git a/SigCrafter/src/sig/skills/StandardTouch.java b/SigCrafter/src/sig/skills/StandardTouch.java new file mode 100644 index 0000000..18d9764 --- /dev/null +++ b/SigCrafter/src/sig/skills/StandardTouch.java @@ -0,0 +1,24 @@ +package sig.skills; + +import sig.Craft; +import sig.Skill; + +public class StandardTouch extends Skill { + + public StandardTouch(String name, int CPCost, boolean guaranteed, int lvReq) { + super(name, CPCost, guaranteed, lvReq); + } + + @Override + public void useSkill(Craft c) { + if (c.SkillList.size()>0&&c.SkillList.get(c.SkillList.size()-1).name.equalsIgnoreCase("Basic Touch")) { + CPCost = 18; + } else { + CPCost = 32; + } + super.useSkill(c); + c.craft_quality += 1.25 * c.quality_mult * (0.37*c.control+32.6)*(1-0.05*Math.min(Math.max(c.recipe_level-c.level,0),5)); + c.craft_durability -= 10 * c.durability_mult; + } + +} diff --git a/SigCrafter/src/sig/skills/TricksOfTheTrade.java b/SigCrafter/src/sig/skills/TricksOfTheTrade.java new file mode 100644 index 0000000..1ec29bb --- /dev/null +++ b/SigCrafter/src/sig/skills/TricksOfTheTrade.java @@ -0,0 +1,24 @@ +package sig.skills; + +import sig.Craft; +import sig.Skill; +import sig.Status; + +public class TricksOfTheTrade extends Skill { + + public TricksOfTheTrade(String name, int CPCost, boolean guaranteed, int lvReq) { + super(name, CPCost, guaranteed, lvReq); + } + + @Override + public boolean canBeUsed(Craft c) { + return super.canBeUsed(c)&&(c.craft_status==Status.GOOD||c.craft_status==Status.EXCELLENT); + } + + @Override + public void useSkill(Craft c) { + super.useSkill(c); + c.craft_cp = Math.min(c.cp,c.craft_cp+20); + } + +} diff --git a/SigCrafter/src/sig/skills/Veneration.java b/SigCrafter/src/sig/skills/Veneration.java new file mode 100644 index 0000000..76fc7e2 --- /dev/null +++ b/SigCrafter/src/sig/skills/Veneration.java @@ -0,0 +1,17 @@ +package sig.skills; + +import sig.Buff; +import sig.Craft; +import sig.Skill; + +public class Veneration extends Skill { + public Veneration(String name, int CPCost, boolean guaranteed, int lvReq) { + super(name, CPCost, guaranteed, lvReq); + } + + @Override + public void useSkill(Craft c) { + super.useSkill(c); + c.BuffList.put("Veneration",new Buff("Veneration",4)); + } +} diff --git a/SigCrafter/src/sig/skills/WasteNot.java b/SigCrafter/src/sig/skills/WasteNot.java new file mode 100644 index 0000000..1f33b26 --- /dev/null +++ b/SigCrafter/src/sig/skills/WasteNot.java @@ -0,0 +1,19 @@ +package sig.skills; + +import sig.Buff; +import sig.Craft; +import sig.Skill; + +public class WasteNot extends Skill { + + public WasteNot(String name, int CPCost, boolean guaranteed, int lvReq) { + super(name, CPCost, guaranteed, lvReq); + } + + @Override + public void useSkill(Craft c) { + super.useSkill(c); + c.BuffList.put("Waste Not",new Buff("Waste Not",4)); + } + +} diff --git a/SigCrafter/src/sig/skills/WasteNotII.java b/SigCrafter/src/sig/skills/WasteNotII.java new file mode 100644 index 0000000..4ae5845 --- /dev/null +++ b/SigCrafter/src/sig/skills/WasteNotII.java @@ -0,0 +1,17 @@ +package sig.skills; + +import sig.Buff; +import sig.Craft; +import sig.Skill; + +public class WasteNotII extends Skill { + public WasteNotII(String name, int CPCost, boolean guaranteed, int lvReq) { + super(name, CPCost, guaranteed, lvReq); + } + + @Override + public void useSkill(Craft c) { + super.useSkill(c); + c.BuffList.put("Waste Not II",new Buff("Waste Not II",8)); + } +}