From ef6b36b2cc0debb89ffda91cb65334d69449a28a Mon Sep 17 00:00:00 2001 From: Leijurv Date: Tue, 30 Oct 2018 15:05:17 -0700 Subject: [PATCH] wew lad --- src/main/java/tenor/ActuallyCraftTask.java | 19 +++++++++- src/main/java/tenor/AquireCraftingItems.java | 38 ++++++++++++++++--- src/main/java/tenor/CraftingTask.java | 25 ++++++++---- .../java/tenor/GetToCraftingTableTask.java | 35 +++++++++++++++++ src/main/java/tenor/IQuantizedTask.java | 12 ++++++ src/main/java/tenor/ISingularTask.java | 13 +++++-- src/main/java/tenor/ISingularTaskNode.java | 2 +- src/main/java/tenor/ITask.java | 8 ++++ src/main/java/tenor/ITaskNodeBase.java | 2 + .../java/tenor/ITaskRelationshipBase.java | 2 + src/main/java/tenor/QuantizedTaskNode.java | 22 +++++++++++ .../QuantizedToQuantizedTaskRelationship.java | 4 ++ .../QuantizedToSingularTaskRelationship.java | 6 ++- .../SingularToQuantizedTaskRelationship.java | 7 +++- .../SingularToSingularTaskRelationship.java | 4 ++ src/main/java/tenor/Task.java | 10 +++++ src/main/java/tenor/TaskLeaf.java | 2 +- src/main/java/tenor/TaskNode.java | 12 +++++- src/main/java/tenor/TaskRelationship.java | 20 ++++++++-- 19 files changed, 218 insertions(+), 25 deletions(-) create mode 100644 src/main/java/tenor/GetToCraftingTableTask.java diff --git a/src/main/java/tenor/ActuallyCraftTask.java b/src/main/java/tenor/ActuallyCraftTask.java index ccdce42dc..b4f35682b 100644 --- a/src/main/java/tenor/ActuallyCraftTask.java +++ b/src/main/java/tenor/ActuallyCraftTask.java @@ -17,5 +17,22 @@ package tenor; -public class ActuallyCraftTask { +public class ActuallyCraftTask extends TaskLeaf implements ISingularTask { + + public final CraftingTask parent; + + public ActuallyCraftTask(CraftingTask parent) { + this.parent = parent; + addParent(parent); + } + + @Override + public double cost() { + return 420; + } + + @Override + public double priority() { + return 0; + } } diff --git a/src/main/java/tenor/AquireCraftingItems.java b/src/main/java/tenor/AquireCraftingItems.java index e5f752463..398949142 100644 --- a/src/main/java/tenor/AquireCraftingItems.java +++ b/src/main/java/tenor/AquireCraftingItems.java @@ -21,16 +21,22 @@ import java.util.List; public class AquireCraftingItems extends QuantizedTaskNode implements ClaimProvider { - CraftingTask output; + final CraftingTask parent; + final QuantizedToQuantizedTaskRelationship parentRelationship; - public AquireCraftingItems() { + public AquireCraftingItems(CraftingTask parent) { super(DependencyType.PARALLEL_ALL); + this.parent = parent; + this.parentRelationship = createRelationshipToParent(parent); + addParent(parentRelationship); + + } @Override public double priorityAllocatedTo(IQuantizedParentTaskRelationship child, int quantity) { AquireItemTask resource = (AquireItemTask) child.childTask(); // all our dependents are aquire item tasks - int amount = output.inputSizeFor(resource); + int amount = parent.inputSizeFor(resource); // they could provide us with quantity int actualQuantity = (int) Math.ceil(quantity * 1.0D / amount); @@ -41,22 +47,42 @@ public class AquireCraftingItems extends QuantizedTaskNode implements ClaimProvi @Override public IQuantityRelationship priority() { - return ((List) (Object) parentTasks()).get(0)::allocatedPriority; // gamer style + return parentRelationship::allocatedPriority; // gamer style } @Override public IQuantityRelationship cost() { - return null; + return x -> { + // cost to get x copies of these items + double sum = 0; + for (QuantizedToQuantizedTaskRelationship resource : (List) (Object) childTasks()) { + int amountPerCraft = parent.inputSizeFor((AquireItemTask) resource.childTask()); + int totalAmountNeeded = x * amountPerCraft; + + int amountForUs = resource.quantityCompleted(); + totalAmountNeeded -= amountForUs; + + if (totalAmountNeeded <= 0) { + continue; + } + + sum += resource.cost().value(totalAmountNeeded); + } + return sum; + }; } @Override public int quantityCompletedForParent(IQuantizedChildTaskRelationship relationship) { + if (relationship != parentRelationship) { + throw new IllegalStateException(); + } // our only parent is the crafting task int minCompletion = Integer.MAX_VALUE; for (IQuantizedChildTaskRelationship resource : (List) (Object) childTasks()) { int amountForUs = resource.quantityCompleted(); - int amountPerCraft = output.inputSizeFor((AquireItemTask) resource.childTask()); + int amountPerCraft = parent.inputSizeFor((AquireItemTask) resource.childTask()); int actualQuantity = (int) Math.ceil(amountForUs * 1.0D / amountPerCraft); diff --git a/src/main/java/tenor/CraftingTask.java b/src/main/java/tenor/CraftingTask.java index 42c101d4d..60cc997c9 100644 --- a/src/main/java/tenor/CraftingTask.java +++ b/src/main/java/tenor/CraftingTask.java @@ -25,10 +25,25 @@ public class CraftingTask extends QuantizedTaskNode { int outputQuantity; List> recipe; - AquireCraftingItems inputs; - public CraftingTask() { + final AquireCraftingItems inputs; + final GetToCraftingTableTask step2; + final ActuallyCraftTask step3; + + final AquireItemTask parent; + final QuantizedToQuantizedTaskRelationship parentRelationship; + + public CraftingTask(AquireItemTask parent) { super(DependencyType.SERIAL); + this.inputs = new AquireCraftingItems(this); // this adds the relationship + this.step2 = GetToCraftingTableTask.INSTANCE; + step2.addParent(this); + this.step3 = new ActuallyCraftTask(this); + + this.parent = parent; + this.parentRelationship = createRelationshipToParent(parent); + addParent(parentRelationship); + } @Override @@ -40,11 +55,7 @@ public class CraftingTask extends QuantizedTaskNode { } public IQuantityRelationship priority() { - if (parentTasks().size() != 1) { - throw new IllegalStateException(); - } - // TODO this is a short circuit - return ((IQuantizedTask) (parentTasks().get(0).parentTask())).priority(); + return parentRelationship::allocatedPriority; } @Override diff --git a/src/main/java/tenor/GetToCraftingTableTask.java b/src/main/java/tenor/GetToCraftingTableTask.java new file mode 100644 index 000000000..6ecc16835 --- /dev/null +++ b/src/main/java/tenor/GetToCraftingTableTask.java @@ -0,0 +1,35 @@ +/* + * This file is part of Baritone. + * + * Baritone is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * Baritone is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with Baritone. If not, see . + */ + +package tenor; + +import java.util.List; + +public class GetToCraftingTableTask extends TaskLeaf implements ISingularTask { + public static final GetToCraftingTableTask INSTANCE = new GetToCraftingTableTask(); // ? idk + + @Override + public double cost() { + return 69; + } + + @Override + public double priority() { + List parentTasks = (List) parentTasks(); // pog + return parentTasks.stream().mapToDouble(ISingularChildTaskRelationship::allocatedPriority).sum(); + } +} diff --git a/src/main/java/tenor/IQuantizedTask.java b/src/main/java/tenor/IQuantizedTask.java index 709718177..7c7675597 100644 --- a/src/main/java/tenor/IQuantizedTask.java +++ b/src/main/java/tenor/IQuantizedTask.java @@ -32,4 +32,16 @@ public interface IQuantizedTask extends ITask { IQuantityRelationship priority(); IQuantityRelationship cost(); + + default IQuantizedChildTaskRelationship createRelationshipToParent(ITaskNodeBase parent) { + if (parent instanceof IQuantizedTask) { + return new QuantizedToQuantizedTaskRelationship((QuantizedTaskNode) parent, this, parent.type()); + } else { + throw new UnsupportedOperationException("SingularToQuantized must be constructed manually since it needs a quantity"); + } + } + + default QuantizedToQuantizedTaskRelationship createRelationshipToParent(QuantizedTaskNode parent) { + return new QuantizedToQuantizedTaskRelationship(parent, this, parent.type()); + } } diff --git a/src/main/java/tenor/ISingularTask.java b/src/main/java/tenor/ISingularTask.java index d27b13ba7..0686bc284 100644 --- a/src/main/java/tenor/ISingularTask.java +++ b/src/main/java/tenor/ISingularTask.java @@ -18,8 +18,15 @@ package tenor; public interface ISingularTask extends ITask { - - double priorityAllocatedToChild(ISingularParentTaskRelationship relationship); - double cost(); + + double priority(); + + default ISingularChildTaskRelationship createRelationshipToParent(ITaskNodeBase parent) { + if (parent instanceof IQuantizedTask) { + return new QuantizedToSingularTaskRelationship((QuantizedTaskNode) parent, this, parent.type()); + } else { + return new SingularToSingularTaskRelationship((SingularTaskNode) parent, this, parent.type()); + } + } } diff --git a/src/main/java/tenor/ISingularTaskNode.java b/src/main/java/tenor/ISingularTaskNode.java index 073dd1355..0b0fd03b7 100644 --- a/src/main/java/tenor/ISingularTaskNode.java +++ b/src/main/java/tenor/ISingularTaskNode.java @@ -22,5 +22,5 @@ package tenor; * @since 10/30/2018 */ public interface ISingularTaskNode extends ITaskNodeBase, ISingularTask { - + double priorityAllocatedToChild(ISingularParentTaskRelationship relationship); } diff --git a/src/main/java/tenor/ITask.java b/src/main/java/tenor/ITask.java index 7dda14117..628f40d7a 100644 --- a/src/main/java/tenor/ITask.java +++ b/src/main/java/tenor/ITask.java @@ -22,4 +22,12 @@ import java.util.List; public interface ITask { List parentTasks(); + + ITaskRelationshipBase createRelationshipToParent(ITaskNodeBase parent); + + void addParent(ITaskRelationshipBase relationship); + + default void addParent(ITaskNodeBase parent) { + addParent(createRelationshipToParent(parent)); + } } diff --git a/src/main/java/tenor/ITaskNodeBase.java b/src/main/java/tenor/ITaskNodeBase.java index f2ec91798..48ea4ad58 100644 --- a/src/main/java/tenor/ITaskNodeBase.java +++ b/src/main/java/tenor/ITaskNodeBase.java @@ -24,4 +24,6 @@ public interface ITaskNodeBase extends ITask { List childTasks(); DependencyType type(); + + void addChild(ITaskRelationshipBase relationship); } diff --git a/src/main/java/tenor/ITaskRelationshipBase.java b/src/main/java/tenor/ITaskRelationshipBase.java index b5ed1daba..2961d7db4 100644 --- a/src/main/java/tenor/ITaskRelationshipBase.java +++ b/src/main/java/tenor/ITaskRelationshipBase.java @@ -22,4 +22,6 @@ public interface ITaskRelationshipBase

P parentTask(); C childTask(); + + DependencyType type(); } diff --git a/src/main/java/tenor/QuantizedTaskNode.java b/src/main/java/tenor/QuantizedTaskNode.java index abed1c4fb..e7f5ac5f3 100644 --- a/src/main/java/tenor/QuantizedTaskNode.java +++ b/src/main/java/tenor/QuantizedTaskNode.java @@ -23,5 +23,27 @@ public abstract class QuantizedTaskNode extends TaskNode implements IQuantizedTa super(type); } + // if the child task were able to provide this amount, how much priority would that be? public abstract double priorityAllocatedTo(IQuantizedParentTaskRelationship child, int quantity); + + public int quantityExecutingInto(QuantizedToSingularTaskRelationship child) { + if (type() != DependencyType.SERIAL) { + throw new UnsupportedOperationException(this + " " + child); + } + // need to calculate from scratch + int ind = childTasks().indexOf(child); + if (ind <= 0) { + throw new IllegalStateException(childTasks() + ""); + } + int minQuantity = -1; + for (int i = 0; i < childTasks().indexOf(child); i++) { + QuantizedToQuantizedTaskRelationship relationship = (QuantizedToQuantizedTaskRelationship) childTasks().get(i); + ClaimProvider claim = (ClaimProvider) relationship.childTask(); + int amt = claim.quantityCompletedForParent(relationship); + if (minQuantity == -1 || amt < minQuantity) { + minQuantity = amt; + } + } + return minQuantity; + } } diff --git a/src/main/java/tenor/QuantizedToQuantizedTaskRelationship.java b/src/main/java/tenor/QuantizedToQuantizedTaskRelationship.java index 79101a0b9..6f41631dd 100644 --- a/src/main/java/tenor/QuantizedToQuantizedTaskRelationship.java +++ b/src/main/java/tenor/QuantizedToQuantizedTaskRelationship.java @@ -21,6 +21,10 @@ public class QuantizedToQuantizedTaskRelationship extends TaskRelationship implements IQuantizedChildTaskRelationship, IQuantizedParentTaskRelationship { + public QuantizedToQuantizedTaskRelationship(QuantizedTaskNode parent, IQuantizedTask child, DependencyType type) { + super(parent, child, type); + } + @Override public double allocatedPriority(int quantity) { return parentTask().priorityAllocatedTo(this, quantity); diff --git a/src/main/java/tenor/QuantizedToSingularTaskRelationship.java b/src/main/java/tenor/QuantizedToSingularTaskRelationship.java index 6b3d787dd..e5d7f2139 100644 --- a/src/main/java/tenor/QuantizedToSingularTaskRelationship.java +++ b/src/main/java/tenor/QuantizedToSingularTaskRelationship.java @@ -21,6 +21,10 @@ public class QuantizedToSingularTaskRelationship extends TaskRelationship implements ISingularChildTaskRelationship, IQuantizedParentTaskRelationship { + public QuantizedToSingularTaskRelationship(QuantizedTaskNode parent, ISingularTask child, DependencyType type) { + super(parent, child, type); + } + @Override public IQuantityRelationship cost() { return x -> childTask().cost(); @@ -28,6 +32,6 @@ public class QuantizedToSingularTaskRelationship @Override public double allocatedPriority() { - throw new UnsupportedOperationException("Cannot allocate priority from quantized parent to singular child"); + return parentTask().priorityAllocatedTo(this, parentTask().quantityExecutingInto(this)); } } diff --git a/src/main/java/tenor/SingularToQuantizedTaskRelationship.java b/src/main/java/tenor/SingularToQuantizedTaskRelationship.java index 6257f08a5..c4896e9f5 100644 --- a/src/main/java/tenor/SingularToQuantizedTaskRelationship.java +++ b/src/main/java/tenor/SingularToQuantizedTaskRelationship.java @@ -21,7 +21,12 @@ public class SingularToQuantizedTaskRelationship extends TaskRelationship implements IQuantizedChildTaskRelationship, ISingularParentTaskRelationship { - int quantityRequired; + public int quantityRequired; + + public SingularToQuantizedTaskRelationship(SingularTaskNode parent, IQuantizedTask child, DependencyType type, int quantityRequired) { + super(parent, child, type); + this.quantityRequired = quantityRequired; + } @Override public double allocatedPriority(int quantity) { diff --git a/src/main/java/tenor/SingularToSingularTaskRelationship.java b/src/main/java/tenor/SingularToSingularTaskRelationship.java index 1345bbf73..ab18506a7 100644 --- a/src/main/java/tenor/SingularToSingularTaskRelationship.java +++ b/src/main/java/tenor/SingularToSingularTaskRelationship.java @@ -21,6 +21,10 @@ public class SingularToSingularTaskRelationship extends TaskRelationship implements ISingularChildTaskRelationship, ISingularParentTaskRelationship { + public SingularToSingularTaskRelationship(SingularTaskNode parent, ISingularTask child, DependencyType type) { + super(parent, child, type); + } + @Override public double allocatedPriority() { return parentTask().priorityAllocatedToChild(this); diff --git a/src/main/java/tenor/Task.java b/src/main/java/tenor/Task.java index f93ebd6bb..be3a301c3 100644 --- a/src/main/java/tenor/Task.java +++ b/src/main/java/tenor/Task.java @@ -23,7 +23,17 @@ public abstract class Task implements ITask { List parentRelationships; + @Override public List parentTasks() { return parentRelationships; } + + @Override + public void addParent(ITaskRelationshipBase relationship) { + if (relationship.childTask() != this) { + throw new IllegalArgumentException(); + } + relationship.parentTask().addChild(relationship); + parentRelationships.add(relationship); + } } diff --git a/src/main/java/tenor/TaskLeaf.java b/src/main/java/tenor/TaskLeaf.java index ca1622884..6122531cb 100644 --- a/src/main/java/tenor/TaskLeaf.java +++ b/src/main/java/tenor/TaskLeaf.java @@ -17,5 +17,5 @@ package tenor; -public class TaskLeaf extends Task { +public abstract class TaskLeaf extends Task { } diff --git a/src/main/java/tenor/TaskNode.java b/src/main/java/tenor/TaskNode.java index ec0150a57..8b2cf3b47 100644 --- a/src/main/java/tenor/TaskNode.java +++ b/src/main/java/tenor/TaskNode.java @@ -22,7 +22,7 @@ import java.util.List; public abstract class TaskNode extends Task implements ITaskNodeBase { List childRelationships; - DependencyType type; + public final DependencyType type; public TaskNode(DependencyType type) { this.type = type; @@ -35,4 +35,14 @@ public abstract class TaskNode extends Task implements ITaskNodeBase { public DependencyType type() { return type; } + + public void addChild(ITaskRelationshipBase relationship) { + if (relationship.parentTask() != this) { + throw new IllegalArgumentException(); + } + if (relationship.type() != type) { + throw new IllegalArgumentException(); + } + childRelationships.add(relationship); + } } diff --git a/src/main/java/tenor/TaskRelationship.java b/src/main/java/tenor/TaskRelationship.java index 525cac453..c0a0ddc6e 100644 --- a/src/main/java/tenor/TaskRelationship.java +++ b/src/main/java/tenor/TaskRelationship.java @@ -19,9 +19,18 @@ package tenor; public class TaskRelationship

implements ITaskRelationshipBase { - P parent; - C child; - DependencyType type; + public final P parent; + public final C child; + public final DependencyType type; + + public TaskRelationship(P parent, C child, DependencyType type) { + this.parent = parent; + this.child = child; + this.type = type; + if (parent.type() != type) { + throw new IllegalArgumentException(); + } + } @Override public P parentTask() { @@ -32,4 +41,9 @@ public class TaskRelationship

implemen public C childTask() { return child; } + + @Override + public DependencyType type() { + return type; + } }