From e7a09c34ea7cf77ab1192c44842dca4e12a251fc Mon Sep 17 00:00:00 2001 From: Leijurv Date: Wed, 31 Oct 2018 13:19:48 -0700 Subject: [PATCH] cleanup and combine single parent priority allocation --- .../IQuantizedParentTaskRelationship.java | 2 +- src/main/java/tenor/IQuantizedTaskNode.java | 22 +++++++++++++++ .../tenor/ISingleParentPriorityAllocator.java | 28 +++++++++++++++++++ .../ISingularParentTaskRelationship.java | 2 +- src/main/java/tenor/QuantizedTaskNode.java | 26 +---------------- .../QuantizedToQuantizedTaskRelationship.java | 6 ++-- .../QuantizedToSingularTaskRelationship.java | 6 ++-- .../SingularToQuantizedTaskRelationship.java | 6 ++-- .../SingularToSingularTaskRelationship.java | 6 ++-- .../java/tenor/game/AquireCraftingItems.java | 7 +---- src/main/java/tenor/game/CraftingTask.java | 13 ++------- src/main/java/tenor/game/MineTask.java | 14 ++++++---- 12 files changed, 78 insertions(+), 60 deletions(-) create mode 100644 src/main/java/tenor/ISingleParentPriorityAllocator.java diff --git a/src/main/java/tenor/IQuantizedParentTaskRelationship.java b/src/main/java/tenor/IQuantizedParentTaskRelationship.java index 3689429e7..48b1d0941 100644 --- a/src/main/java/tenor/IQuantizedParentTaskRelationship.java +++ b/src/main/java/tenor/IQuantizedParentTaskRelationship.java @@ -17,7 +17,7 @@ package tenor; -public interface IQuantizedParentTaskRelationship extends ITaskRelationshipBase, IParentTaskRelationship { +public interface IQuantizedParentTaskRelationship extends ITaskRelationshipBase, IParentTaskRelationship { IQuantityRelationship cost(); } diff --git a/src/main/java/tenor/IQuantizedTaskNode.java b/src/main/java/tenor/IQuantizedTaskNode.java index 080e684a5..bdf6d1958 100644 --- a/src/main/java/tenor/IQuantizedTaskNode.java +++ b/src/main/java/tenor/IQuantizedTaskNode.java @@ -22,5 +22,27 @@ package tenor; * @since 10/30/2018 */ public interface IQuantizedTaskNode extends ITaskNodeBase, IQuantizedTask { + // if the child task were able to provide this amount, how much priority would that be? + double priorityAllocatedTo(IQuantizedParentTaskRelationship child, int quantity); + default 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++) { + IQuantizedChildTaskRelationship relationship = (IQuantizedChildTaskRelationship) childTasks().get(i); + IClaimProvider claim = (IClaimProvider) relationship.childTask(); + int amt = claim.quantityCompletedForParent(relationship); + if (minQuantity == -1 || amt < minQuantity) { + minQuantity = amt; + } + } + return minQuantity; + } } diff --git a/src/main/java/tenor/ISingleParentPriorityAllocator.java b/src/main/java/tenor/ISingleParentPriorityAllocator.java new file mode 100644 index 000000000..cbc41b397 --- /dev/null +++ b/src/main/java/tenor/ISingleParentPriorityAllocator.java @@ -0,0 +1,28 @@ +/* + * 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; + +public interface ISingleParentPriorityAllocator extends IQuantizedTask { + @Override + default IQuantityRelationship priority() { + if (parentTasks().size() != 1) { + throw new IllegalStateException(); + } + return parentTasks().get(0)::allocatedPriority; + } +} diff --git a/src/main/java/tenor/ISingularParentTaskRelationship.java b/src/main/java/tenor/ISingularParentTaskRelationship.java index 74101869a..229a5425d 100644 --- a/src/main/java/tenor/ISingularParentTaskRelationship.java +++ b/src/main/java/tenor/ISingularParentTaskRelationship.java @@ -17,7 +17,7 @@ package tenor; -public interface ISingularParentTaskRelationship extends ITaskRelationshipBase, IParentTaskRelationship { +public interface ISingularParentTaskRelationship extends ITaskRelationshipBase, IParentTaskRelationship { double cost(); } diff --git a/src/main/java/tenor/QuantizedTaskNode.java b/src/main/java/tenor/QuantizedTaskNode.java index 0c8768de0..6d0a7d6d7 100644 --- a/src/main/java/tenor/QuantizedTaskNode.java +++ b/src/main/java/tenor/QuantizedTaskNode.java @@ -17,33 +17,9 @@ package tenor; -public abstract class QuantizedTaskNode extends TaskNode implements IQuantizedTask { +public abstract class QuantizedTaskNode extends TaskNode implements IQuantizedTaskNode { public QuantizedTaskNode(DependencyType type) { 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++) { - IQuantizedChildTaskRelationship relationship = (IQuantizedChildTaskRelationship) childTasks().get(i); - IClaimProvider claim = (IClaimProvider) 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 6f41631dd..ebb65a649 100644 --- a/src/main/java/tenor/QuantizedToQuantizedTaskRelationship.java +++ b/src/main/java/tenor/QuantizedToQuantizedTaskRelationship.java @@ -18,10 +18,10 @@ package tenor; public class QuantizedToQuantizedTaskRelationship - extends TaskRelationship - implements IQuantizedChildTaskRelationship, IQuantizedParentTaskRelationship { + extends TaskRelationship + implements IQuantizedChildTaskRelationship, IQuantizedParentTaskRelationship { - public QuantizedToQuantizedTaskRelationship(QuantizedTaskNode parent, IQuantizedTask child, DependencyType type) { + public QuantizedToQuantizedTaskRelationship(IQuantizedTaskNode parent, IQuantizedTask child, DependencyType type) { super(parent, child, type); } diff --git a/src/main/java/tenor/QuantizedToSingularTaskRelationship.java b/src/main/java/tenor/QuantizedToSingularTaskRelationship.java index e5d7f2139..06858f287 100644 --- a/src/main/java/tenor/QuantizedToSingularTaskRelationship.java +++ b/src/main/java/tenor/QuantizedToSingularTaskRelationship.java @@ -18,10 +18,10 @@ package tenor; public class QuantizedToSingularTaskRelationship - extends TaskRelationship - implements ISingularChildTaskRelationship, IQuantizedParentTaskRelationship { + extends TaskRelationship + implements ISingularChildTaskRelationship, IQuantizedParentTaskRelationship { - public QuantizedToSingularTaskRelationship(QuantizedTaskNode parent, ISingularTask child, DependencyType type) { + public QuantizedToSingularTaskRelationship(IQuantizedTaskNode parent, ISingularTask child, DependencyType type) { super(parent, child, type); } diff --git a/src/main/java/tenor/SingularToQuantizedTaskRelationship.java b/src/main/java/tenor/SingularToQuantizedTaskRelationship.java index c4896e9f5..75ec15445 100644 --- a/src/main/java/tenor/SingularToQuantizedTaskRelationship.java +++ b/src/main/java/tenor/SingularToQuantizedTaskRelationship.java @@ -18,12 +18,12 @@ package tenor; public class SingularToQuantizedTaskRelationship - extends TaskRelationship - implements IQuantizedChildTaskRelationship, ISingularParentTaskRelationship { + extends TaskRelationship + implements IQuantizedChildTaskRelationship, ISingularParentTaskRelationship { public int quantityRequired; - public SingularToQuantizedTaskRelationship(SingularTaskNode parent, IQuantizedTask child, DependencyType type, int quantityRequired) { + public SingularToQuantizedTaskRelationship(ISingularTaskNode parent, IQuantizedTask child, DependencyType type, int quantityRequired) { super(parent, child, type); this.quantityRequired = quantityRequired; } diff --git a/src/main/java/tenor/SingularToSingularTaskRelationship.java b/src/main/java/tenor/SingularToSingularTaskRelationship.java index ab18506a7..bbf10d5a2 100644 --- a/src/main/java/tenor/SingularToSingularTaskRelationship.java +++ b/src/main/java/tenor/SingularToSingularTaskRelationship.java @@ -18,10 +18,10 @@ package tenor; public class SingularToSingularTaskRelationship - extends TaskRelationship - implements ISingularChildTaskRelationship, ISingularParentTaskRelationship { + extends TaskRelationship + implements ISingularChildTaskRelationship, ISingularParentTaskRelationship { - public SingularToSingularTaskRelationship(SingularTaskNode parent, ISingularTask child, DependencyType type) { + public SingularToSingularTaskRelationship(ISingularTaskNode parent, ISingularTask child, DependencyType type) { super(parent, child, type); } diff --git a/src/main/java/tenor/game/AquireCraftingItems.java b/src/main/java/tenor/game/AquireCraftingItems.java index aae9f6196..46fed53b8 100644 --- a/src/main/java/tenor/game/AquireCraftingItems.java +++ b/src/main/java/tenor/game/AquireCraftingItems.java @@ -19,7 +19,7 @@ package tenor.game; import tenor.*; -public class AquireCraftingItems extends QuantizedTaskNode implements IClaimProvider { +public class AquireCraftingItems extends QuantizedTaskNode implements IClaimProvider, ISingleParentPriorityAllocator { final CraftingTask parent; @@ -41,11 +41,6 @@ public class AquireCraftingItems extends QuantizedTaskNode implements IClaimProv return priority().value(actualQuantity); } - @Override - public IQuantityRelationship priority() { - return parentTasks().get(0)::allocatedPriority; - } - @Override public IQuantityRelationship cost() { return x -> { diff --git a/src/main/java/tenor/game/CraftingTask.java b/src/main/java/tenor/game/CraftingTask.java index fc0b6b9ad..d6a4226a1 100644 --- a/src/main/java/tenor/game/CraftingTask.java +++ b/src/main/java/tenor/game/CraftingTask.java @@ -18,14 +18,11 @@ package tenor.game; import net.minecraft.util.Tuple; -import tenor.DependencyType; -import tenor.IQuantityRelationship; -import tenor.IQuantizedParentTaskRelationship; -import tenor.QuantizedTaskNode; +import tenor.*; import java.util.List; -public class CraftingTask extends QuantizedTaskNode { +public class CraftingTask extends QuantizedTaskNode implements ISingleParentPriorityAllocator { int outputQuantity; List> recipe; @@ -52,14 +49,10 @@ public class CraftingTask extends QuantizedTaskNode { public IQuantityRelationship cost() { return x -> { int actualQuantity = (int) Math.ceil(x * 1.0D / outputQuantity); - return inputs.cost().value(actualQuantity); + return inputs.cost().value(actualQuantity) + step2.cost() + step3.cost(); }; } - public IQuantityRelationship priority() { - return parentTasks().get(0)::allocatedPriority; - } - @Override public double priorityAllocatedTo(IQuantizedParentTaskRelationship child, int quantity) { // how much priority would we give this child if they could provide us this quantity? diff --git a/src/main/java/tenor/game/MineTask.java b/src/main/java/tenor/game/MineTask.java index 9c549749b..595a35907 100644 --- a/src/main/java/tenor/game/MineTask.java +++ b/src/main/java/tenor/game/MineTask.java @@ -18,16 +18,20 @@ package tenor.game; import tenor.IQuantityRelationship; +import tenor.ISingleParentPriorityAllocator; import tenor.QuantizedTaskLeaf; -public class MineTask extends QuantizedTaskLeaf { - @Override - public IQuantityRelationship priority() { - return null; +public class MineTask extends QuantizedTaskLeaf implements ISingleParentPriorityAllocator { + + final AquireItemTask parent; + + public MineTask(AquireItemTask parent) { + this.parent = parent; + addParent(parent); } @Override public IQuantityRelationship cost() { - return null; + return x -> x * 324232; } }