Setup all skills and buffs with basic output.

SigCrafter/.classpath

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8">
+		<attributes>
+			<attribute name="module" value="true"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="output" path="bin"/>
+</classpath>

SigCrafter/.gitignore

@@ -0,0 +1 @@
+/bin/

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

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 + ")]";
+	}
+}

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<Skill> SkillList = new ArrayList<Skill>();
+	public Map<String,Buff> BuffList = new HashMap<String,Buff>();
+	public List<Craft> CraftList = new ArrayList<Craft>();
+	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 && durability<=0;
+	}
+	public boolean craftSucceeded() {
+		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 + "]";
+	}
+}

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<Buff> BUFFLIST = new ArrayList<Buff>();
+	public static List<Skill> SKILLLIST = new ArrayList<Skill>();
+	
+	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<Craft> SucceededCrafts = new ArrayList<Craft>();
+
+	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<Skill> skills = new ArrayList<Skill>();
+		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);
+	}
+
+}

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;
+	}	
+}

SigCrafter/src/sig/SkillInterface.java

@@ -0,0 +1,6 @@
+package sig;
+
+public interface SkillInterface {
+	public void useSkill(Craft c);
+	public boolean canBeUsed(Craft c);
+}

SigCrafter/src/sig/Status.java

@@ -0,0 +1,8 @@
+package sig;
+
+public enum Status {
+	NORMAL,
+	POOR,
+	GOOD,
+	EXCELLENT
+}

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;
+	}
+
+}

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;
+	}
+
+}

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;
+	}
+
+}

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));
+	}
+}

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;
+	}
+
+}

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));
+	}
+}

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));
+	}
+}

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);
+	}
+
+}

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));
+	}
+}

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);
+	}
+}

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;
+	}
+
+}

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;
+	}
+
+}

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);
+	}
+
+}

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));
+	}
+}

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));
+	}
+
+}

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));
+	}
+}