Finish and improve fluid implementation

Author: ExE-Boss

src/main/java/nova/core/component/fluid/Fluid.java

@@ -21,6 +21,8 @@
 package nova.core.component.fluid;
 
 import nova.core.block.BlockFactory;
+import nova.core.component.exception.ComponentException;
+import nova.core.component.misc.FactoryProvider;
 import nova.core.retention.Data;
 import nova.core.retention.Storable;
 import nova.core.retention.Store;
@@ -29,19 +31,20 @@
 
 import java.util.Optional;
 
+// TODO: Should this extend ComponentProvider?
 public class Fluid implements Identifiable, Storable, Cloneable {
 	/**
 	 * 1000 liters = 1 cubic meter
 	 */
-	public static final int bucketVolume = 1000;
+	public static final int BUCKET_VOLUME = 1000;
 	/**
 	 * Fluid amount is measured in liters.
 	 */
 	@Store(key = "amount")
 	private int amount = 1;
 
 	//TODO: Public instance variable is not good practice
-	public FluidFactory factory;
+	private FluidFactory factory = null;
 
 	/**
 	 * @return Amount of fluid
@@ -104,7 +107,7 @@ public Fluid withAmount(int amount) {
 	 * @return The block. There may be no block associated with this fluid.
 	 */
 	public Optional<BlockFactory> getBlockFactory() {
-		return Optional.empty();
+		return Game.blocks().get(getID());
 	}
 
 	@Override
@@ -125,9 +128,25 @@ public boolean sameType(Fluid stack) {
 		return stack.getID().equals(getID());
 	}
 
+	void initFactory(FluidFactory factory) {
+		if (factory == null) {
+			this.factory = factory;
+		} else {
+			throw new ComponentException("Attempt to add two components of the type %s to " + this, FactoryProvider.class);
+		}
+	}
+
+	public final FluidFactory getFactory() {
+		if (factory != null) {
+			return factory;
+		} else {
+			throw new ComponentException("Attempt to get component that does not exist: %s", FactoryProvider.class);
+		}
+	}
+
 	@Override
 	public final String getID() {
-		return factory.getID();
+		return getFactory().getID();
 	}
 
 	@Override

src/main/java/nova/core/component/fluid/FluidFactory.java

@@ -54,7 +54,7 @@ public FluidFactory(String id, Supplier<Fluid> constructor) {
 	@Override
 	public Fluid build() {
 		Fluid build = super.build();
-		build.factory = this;
+		build.initFactory(this);
 		return build;
 	}
 

src/main/java/nova/core/component/fluid/FluidFilter.java

@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) 2017 NOVA, All rights reserved.
+ * This library is free software, licensed under GNU Lesser General Public License version 3
+ *
+ * This file is part of NOVA.
+ *
+ * NOVA is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * NOVA 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with NOVA.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package nova.core.component.fluid;
+
+import java.util.function.Predicate;
+
+/**
+ * A filter that only accepts a specific sub-type of {@link Fluid}. For use with tanks.
+ *
+ * @author ExE Boss
+ */
+@FunctionalInterface
+public interface FluidFilter extends Predicate<Fluid> {
+
+	/**
+	 * Returns an {@link FluidFilter} that accepts an {@link Fluid} of the same
+	 * type as the provided.
+	 *
+	 * @param item
+	 * @return ItemFilter
+	 */
+	static FluidFilter of(Fluid fluid) {
+		return fluid::sameType;
+	}
+
+	/**
+	 * Returns an {@link FluidFilter} that accepts an {@link Fluid} of the same
+	 * type as provided.
+	 *
+	 * @param id
+	 * @return ItemFilter
+	 */
+	static FluidFilter of(String id) {
+		return (other) -> id.equals(other.getID());
+	}
+
+	/**
+	 * Accepts any {@link Fluid} that has a &gt;= amount than provided.
+	 *
+	 * @param amount
+	 * @return
+	 */
+	static FluidFilter of(int amount) {
+		return (other) -> other.amount() >= amount;
+	}
+}

src/main/java/nova/core/component/fluid/FluidHandler.java

@@ -16,29 +16,142 @@
  *
  * You should have received a copy of the GNU General Public License
  * along with NOVA.  If not, see <http://www.gnu.org/licenses/>.
- */package nova.core.component.fluid;
+ */
+
+package nova.core.component.fluid;
 
 import nova.core.component.Component;
-import nova.core.util.Direction;
+import nova.core.component.SidedComponent;
 
 import java.util.Arrays;
 import java.util.HashSet;
+import java.util.Optional;
 import java.util.Set;
-import java.util.function.Function;
+import java.util.function.Predicate;
 
 /**
+ * A sided component that provides a fluid container.
  * @author Calclavia
  */
-public class FluidHandler extends Component {
+@SidedComponent
+public class FluidHandler extends Component implements FluidConsumer, FluidProvider {
 
-	public Set<Tank> tanks = new HashSet<>();
-	public Function<Direction, Set<Tank>> sidedTanks = direction -> tanks;
+	protected Set<Tank> tanks = new HashSet<>();
+	protected boolean resizable;
+
+	public static FluidHandler singleTank() {
+		return new FluidHandler(false, new TankSimple(Fluid.BUCKET_VOLUME));
+	}
+
+	public static FluidHandler singleTank(int capacity) {
+		return new FluidHandler(false, new TankSimple(capacity));
+	}
+
+	public static FluidHandler singleTank(Predicate<Fluid> fluidFilter) {
+		return new FluidHandler(false, new TankSimple(Fluid.BUCKET_VOLUME).setFluidFilter(fluidFilter));
+	}
+
+	public static FluidHandler singleTank(int capacity, Predicate<Fluid> fluidFilter) {
+		return new FluidHandler(false, new TankSimple(capacity).setFluidFilter(fluidFilter));
+	}
 
 	public FluidHandler() {
+		this.resizable = true;
 	}
 
 	public FluidHandler(Tank... tanks) {
+		this(true, tanks);
+	}
+
+	public FluidHandler(boolean resizable, Tank... tanks) {
 		this.tanks.addAll(Arrays.asList(tanks));
+		this.resizable = resizable;
+		if (resizable) {
+			this.tanks.removeIf(Tank::isEmpty);
+		}
+	}
+
+	@Override
+	public int addFluid(Fluid fluid, boolean simulate) {
+		if (fluid.amount() == 0)
+			return 0;
+
+		Fluid f = fluid.clone();
+		int added = 0;
+
+		for (Tank tank : tanks) {
+			int a = tank.addFluid(f, simulate);
+			added += a;
+			f.remove(a);
+			if (f.amount() == 0)
+				break;
+		}
+
+		if (f.amount() > 0 && resizable) {
+			Tank t = new TankSimple();
+			added += t.addFluid(f);
+			tanks.add(t);
+		}
+
+		return added;
+	}
+
+	@Override
+	public Optional<Fluid> removeFluid(Fluid fluid, boolean simulate) {
+		if (fluid.amount() == 0)
+			return Optional.empty();
+
+		Fluid f = fluid.withAmount(0);
+		Fluid r = fluid.clone();
+
+		for (Tank tank : tanks) {
+			if (!tank.hasFluidType(fluid))
+				continue;
+
+			int removed = tank.removeFluid(r).get().amount();
+			r.remove(removed);
+			f.add(removed);
+
+			if (r.amount() == 0)
+				break;
+		}
+
+		if (resizable) {
+			this.tanks.removeIf(Tank::isEmpty);
+		}
+
+		return Optional.of(f).filter(fl -> fl.amount() > 0);
 	}
 
+	@Override
+	public Optional<Fluid> removeFluid(int amount, boolean simulate) {
+		Optional<Fluid> fluid = tanks.stream()
+			.filter(Tank::hasFluid)
+			.findFirst()
+			.flatMap(Tank::getFluid)
+			.map(f -> f.withAmount(0));
+
+		if (amount == 0 || !fluid.isPresent())
+			return fluid;
+
+		Fluid f = fluid.get();
+
+		for (Tank tank : tanks) {
+			if (!tank.hasFluidType(f))
+				continue;
+
+			int removed = tank.removeFluid(amount).get().amount();
+			amount -= removed;
+			f.add(removed);
+
+			if (amount == 0)
+				break;
+		}
+
+		if (resizable) {
+			this.tanks.removeIf(Tank::isEmpty);
+		}
+
+		return Optional.of(f).filter(fl -> fl.amount() > 0);
+	}
 }

src/main/java/nova/core/component/fluid/FluidManager.java

@@ -22,6 +22,7 @@
 
 import nova.core.util.registry.FactoryManager;
 import nova.core.util.registry.Registry;
+import nova.internal.core.Game;
 
 import java.util.Optional;
 import java.util.function.Function;
@@ -61,6 +62,12 @@ public FluidFactory register(FluidFactory factory) {
 
 	@Override
 	public void init() {
-		//TODO: Implement
+		Game.events().publish(new Init(this));
+	}
+
+	public class Init extends ManagerEvent<FluidManager> {
+		public Init(FluidManager manager) {
+			super(manager);
+		}
 	}
 }

src/main/java/nova/core/component/fluid/FluidProvider.java

@@ -27,6 +27,23 @@
  * @see FluidConsumer
  */
 public interface FluidProvider {
+	/**
+	 * Attempt to extract fluid from this FluidProvider
+	 * @param fluid The fluid type and max amount to extract
+	 * @param simulate Whether to simulate the extraction
+	 * @return Extracted {@link Fluid}
+	 */
+	Optional<Fluid> removeFluid(Fluid fluid, boolean simulate);
+
+	/**
+	 * Attempt to extract fluid from this FluidProvider
+	 * @param amount Amount of fluid to extract
+	 * @return Extracted {@link Fluid}
+	 */
+	default Optional<Fluid> removeFluid(Fluid fluid) {
+		return removeFluid(fluid, false);
+	}
+
 	/**
 	 * Attempt to extract fluid from this FluidProvider
 	 * @param amount Amount of fluid to extract

src/main/java/nova/core/component/fluid/SidedTankProvider.java

@@ -44,7 +44,14 @@ default int getFluidAmount() {
 	}
 
 	/**
-	 * @return Whether this container is storing a fluid
+	 * @return Whether this container is empty
+	 */
+	default boolean isEmpty() {
+		return !getFluid().isPresent();
+	}
+
+	/**
+	 * @return Whether this container is storing a fluid (is not empty)
 	 */
 	default boolean hasFluid() {
 		return getFluid().isPresent();

src/main/java/nova/core/component/fluid/Tank.java

@@ -24,34 +24,46 @@
 import nova.core.network.Syncable;
 import nova.core.retention.Data;
 import nova.core.retention.Storable;
+import nova.core.util.math.MathUtil;
 
 import java.util.Optional;
+import java.util.OptionalInt;
+import java.util.function.Predicate;
 
 /**
  * This class provides basic implementation of {@link Tank}
  */
 public class TankSimple implements Tank, Storable, Syncable {
 
 	private Optional<Fluid> containedFluid = Optional.empty();
-	private int capacity;
+	private OptionalInt capacity;
+	private Predicate<Fluid> fluidFilter = f -> true;
 
 	public TankSimple() {
-		this(Fluid.bucketVolume);
+		this.capacity = OptionalInt.empty();
 	}
 
 	public TankSimple(int maxCapacity) {
-		this.capacity = maxCapacity;
+		this.capacity = OptionalInt.of(maxCapacity);
+	}
+
+	public TankSimple removeCapacity() {
+		this.capacity = OptionalInt.empty();
+		return this;
 	}
 
 	public TankSimple setCapacity(int capacity) {
-		this.capacity = capacity;
+		this.capacity = OptionalInt.of(capacity);
 		setFluid(containedFluid);
 		return this;
 	}
 
 	@Override
 	public int addFluid(Fluid fluid, boolean simulate) {
-		int capacity = this.capacity - containedFluid.orElse(fluid.withAmount(0)).amount();
+		if (fluid.amount() == 0 || !fluidFilter.test(fluid))
+			return 0;
+
+		int capacity = this.capacity.orElse(Integer.MAX_VALUE) - containedFluid.orElseGet(() -> fluid.withAmount(0)).amount();
 		int toPut = Math.min(fluid.amount(), capacity);
 
 		if (containedFluid.isPresent()) {
@@ -72,6 +84,14 @@ public int addFluid(Fluid fluid, boolean simulate) {
 		}
 	}
 
+	@Override
+	public Optional<Fluid> removeFluid(Fluid fluid, boolean simulate) {
+		if (!containedFluid.filter(fluid::sameType).isPresent())
+			return Optional.empty();
+
+		return removeFluid(fluid.amount(), simulate);
+	}
+
 	@Override
 	public Optional<Fluid> removeFluid(int amount, boolean simulate) {
 		if (!containedFluid.isPresent()) {
@@ -98,19 +118,21 @@ public Optional<Fluid> removeFluid(int amount, boolean simulate) {
 
 	@Override
 	public int getFluidCapacity() {
-		return capacity;
+		return capacity.orElse(Integer.MAX_VALUE);
 	}
 
 	@Override
 	public Optional<Fluid> getFluid() {
 		return containedFluid;
 	}
 
+	public TankSimple setFluidFilter(Predicate<Fluid> fluidFilter) {
+		this.fluidFilter = fluidFilter;
+		return this;
+	}
+
 	public TankSimple setFluid(Optional<Fluid> fluid) {
-		this.containedFluid = fluid;
-		if (containedFluid.isPresent()) {
-			containedFluid.get().setAmount(Math.max(Math.min(containedFluid.get().amount(), capacity), 0));
-		}
+		containedFluid = fluid.filter(fluidFilter).map(f -> f.withAmount(MathUtil.clamp(f.amount(), 0, capacity.orElse(Integer.MAX_VALUE)))).filter(f -> f.amount() > 0);
 		return this;
 	}