mirror of
https://github.com/MightyPirates/OpenComputers.git
synced 2025-09-15 10:21:45 -04:00
IT COMPILES! More fixes. Kicked BloodMagic integration because things changed and I have no idea how to fix it. Also kicked out the tests. Who needs tests anyway.
This commit is contained in:
Florian Nücke
parent
b48c2098ab
commit
beff30111e
@ -65,11 +65,6 @@ repositories {
|
||||
maven { url "http://maven.amadornes.com/" }
|
||||
maven { url "http://maven.cil.li/" }
|
||||
maven { url "http://maven.ic2.player.to/" }
|
||||
|
||||
ivy {
|
||||
name 'BloodMagic'
|
||||
artifactPattern "http://addons-origin.cursecdn.com/files/${config.bloodmagic.cf}/[module]-[revision].[ext]"
|
||||
}
|
||||
}
|
||||
|
||||
configurations {
|
||||
@ -83,8 +78,6 @@ dependencies {
|
||||
deobfCompile "mezz.jei:jei_${config.minecraft.version}:${config.jei.version}"
|
||||
deobfCompile "net.sengir.forestry:forestry_${config.minecraft.version}:${config.forestry.version}"
|
||||
|
||||
deobfCompile name: 'BloodMagic', version: config.bloodmagic.version, ext: 'jar'
|
||||
|
||||
embedded files('libs/OpenComputers-JNLua.jar', 'libs/OpenComputers-LuaJ.jar')
|
||||
|
||||
testCompile "org.mockito:mockito-all:1.10.19"
|
||||
|
||||
@ -6,8 +6,6 @@ mod.name=OpenComputers
|
||||
mod.group=li.cil.oc
|
||||
mod.version=1.7.0
|
||||
|
||||
bloodmagic.cf=2384/881
|
||||
bloodmagic.version=1.11-2.1.4-73
|
||||
forestry.version=5.3.1.38
|
||||
jei.version=4.2.7.240
|
||||
mcmp.version=2.0.0_17
|
||||
|
||||
@ -63,7 +63,7 @@ final class ModelQuadcopter extends ModelBase {
|
||||
private def doRender(drone: Drone, dt: Float) {
|
||||
if (drone.isRunning) {
|
||||
val timeJitter = drone.hashCode() ^ 0xFF
|
||||
GlStateManager.translate(0, (math.sin(timeJitter + (drone.world.getTotalWorldTime + dt) / 20.0) * (1 / 16f)).toFloat, 0)
|
||||
GlStateManager.translate(0, (math.sin(timeJitter + (drone.getEntityWorld.getTotalWorldTime + dt) / 20.0) * (1 / 16f)).toFloat, 0)
|
||||
}
|
||||
|
||||
val velocity = new Vec3d(drone.motionX, drone.motionY, drone.motionZ)
|
||||
|
||||
@ -65,6 +65,8 @@ object Drone {
|
||||
// so this is to ensure it is implemented here, in the very unlikely case that
|
||||
// someone decides to ship that specific version of the API.
|
||||
class Drone(world: World) extends Entity(world) with MachineHost with internal.Drone with internal.Rotatable with Analyzable with Context {
|
||||
override def world = getEntityWorld
|
||||
|
||||
// Some basic constants.
|
||||
val gravity = 0.05f
|
||||
// low for slow fall (float down)
|
||||
|
||||
@ -9,6 +9,8 @@ trait InventoryProxy extends IInventory {
|
||||
|
||||
def offset = 0
|
||||
|
||||
override def isEmpty: Boolean = inventory.isEmpty
|
||||
|
||||
override def getSizeInventory = inventory.getSizeInventory
|
||||
|
||||
override def getInventoryStackLimit = inventory.getInventoryStackLimit
|
||||
|
||||
@ -45,7 +45,9 @@ import net.minecraftforge.common.MinecraftForge
|
||||
import net.minecraftforge.common.capabilities.Capability
|
||||
import net.minecraftforge.fluids._
|
||||
import net.minecraftforge.fluids.capability.CapabilityFluidHandler
|
||||
import net.minecraftforge.fluids.capability.FluidTankProperties
|
||||
import net.minecraftforge.fluids.capability.IFluidHandler
|
||||
import net.minecraftforge.fluids.capability.IFluidTankProperties
|
||||
import net.minecraftforge.fml.relauncher.Side
|
||||
import net.minecraftforge.fml.relauncher.SideOnly
|
||||
|
||||
@ -69,7 +71,6 @@ class Robot extends traits.Computer with traits.PowerInformation with traits.Rot
|
||||
}
|
||||
|
||||
|
||||
|
||||
// ----------------------------------------------------------------------- //
|
||||
|
||||
override def getCapability[T](capability: Capability[T], facing: EnumFacing): T = {
|
||||
@ -814,21 +815,21 @@ class Robot extends traits.Computer with traits.PowerInformation with traits.Rot
|
||||
|
||||
// ----------------------------------------------------------------------- //
|
||||
|
||||
override def fill(from: EnumFacing, resource: FluidStack, doFill: Boolean) =
|
||||
override def fill(resource: FluidStack, doFill: Boolean) =
|
||||
tryGetTank(selectedTank) match {
|
||||
case Some(t) =>
|
||||
t.fill(resource, doFill)
|
||||
case _ => 0
|
||||
}
|
||||
|
||||
override def drain(from: EnumFacing, resource: FluidStack, doDrain: Boolean) =
|
||||
override def drain(resource: FluidStack, doDrain: Boolean) =
|
||||
tryGetTank(selectedTank) match {
|
||||
case Some(t) if t.getFluid != null && t.getFluid.isFluidEqual(resource) =>
|
||||
t.drain(resource.amount, doDrain)
|
||||
case _ => null
|
||||
}
|
||||
|
||||
override def drain(from: EnumFacing, maxDrain: Int, doDrain: Boolean) = {
|
||||
override def drain(maxDrain: Int, doDrain: Boolean) = {
|
||||
tryGetTank(selectedTank) match {
|
||||
case Some(t) =>
|
||||
t.drain(maxDrain, doDrain)
|
||||
@ -836,22 +837,21 @@ class Robot extends traits.Computer with traits.PowerInformation with traits.Rot
|
||||
}
|
||||
}
|
||||
|
||||
override def canFill(from: EnumFacing, fluid: Fluid) = {
|
||||
def canFill(fluid: Fluid) = {
|
||||
tryGetTank(selectedTank) match {
|
||||
case Some(t) => t.getFluid == null || t.getFluid.getFluid == fluid
|
||||
case _ => false
|
||||
}
|
||||
}
|
||||
|
||||
override def canDrain(from: EnumFacing, fluid: Fluid): Boolean = {
|
||||
def canDrain(fluid: Fluid): Boolean = {
|
||||
tryGetTank(selectedTank) match {
|
||||
case Some(t) => t.getFluid != null && t.getFluid.getFluid == fluid
|
||||
case _ => false
|
||||
}
|
||||
}
|
||||
|
||||
override def getTankInfo(from: EnumFacing) =
|
||||
components.collect {
|
||||
case Some(t: IFluidTank) => t.getInfo
|
||||
}
|
||||
override def getTankProperties = FluidTankProperties.convert(components.collect {
|
||||
case Some(t: IFluidTank) => t.getInfo
|
||||
}).map(_.asInstanceOf[IFluidTankProperties])
|
||||
}
|
||||
|
||||
@ -8,6 +8,7 @@ import li.cil.oc.api.machine.Context
|
||||
import li.cil.oc.api.network._
|
||||
import net.minecraftforge.common.capabilities.Capability
|
||||
import net.minecraftforge.fluids.capability.CapabilityFluidHandler
|
||||
import net.minecraftforge.fluids.capability.FluidTankProperties
|
||||
import net.minecraftforge.fluids.capability.IFluidHandler
|
||||
import net.minecraftforge.fml.relauncher.Side
|
||||
import net.minecraftforge.fml.relauncher.SideOnly
|
||||
@ -290,15 +291,15 @@ class RobotProxy(val robot: Robot) extends traits.Computer with traits.PowerInfo
|
||||
|
||||
// ----------------------------------------------------------------------- //
|
||||
|
||||
override def fill(from: EnumFacing, resource: FluidStack, doFill: Boolean) = robot.fill(from, resource, doFill)
|
||||
override def fill(resource: FluidStack, doFill: Boolean) = robot.fill(resource, doFill)
|
||||
|
||||
override def drain(from: EnumFacing, resource: FluidStack, doDrain: Boolean) = robot.drain(from, resource, doDrain)
|
||||
override def drain(resource: FluidStack, doDrain: Boolean) = robot.drain(resource, doDrain)
|
||||
|
||||
override def drain(from: EnumFacing, maxDrain: Int, doDrain: Boolean) = robot.drain(from, maxDrain, doDrain)
|
||||
override def drain(maxDrain: Int, doDrain: Boolean) = robot.drain(maxDrain, doDrain)
|
||||
|
||||
override def canFill(from: EnumFacing, fluid: Fluid) = robot.canFill(from, fluid)
|
||||
def canFill(fluid: Fluid) = robot.canFill(fluid)
|
||||
|
||||
override def canDrain(from: EnumFacing, fluid: Fluid) = robot.canDrain(from, fluid)
|
||||
def canDrain(fluid: Fluid) = robot.canDrain(fluid)
|
||||
|
||||
override def getTankInfo(from: EnumFacing) = robot.getTankInfo(from)
|
||||
override def getTankProperties = robot.getTankProperties
|
||||
}
|
||||
|
||||
@ -18,10 +18,8 @@ object Mods {
|
||||
// ----------------------------------------------------------------------- //
|
||||
|
||||
def All = knownMods.clone()
|
||||
val BloodMagic = new SimpleMod(IDs.BloodMagic)
|
||||
val Forestry = new SimpleMod(IDs.Forestry, version = "@[5.2,)")
|
||||
val JustEnoughItems = new SimpleMod(IDs.JustEnoughItems)
|
||||
val MCMultiPart = new SimpleMod(IDs.MCMultiPart, version = "@[1.0.9,)")
|
||||
val Minecraft = new SimpleMod(IDs.Minecraft)
|
||||
val OpenComputers = new SimpleMod(IDs.OpenComputers)
|
||||
val TIS3D = new SimpleMod(IDs.TIS3D, version = "@[0.9,)")
|
||||
@ -59,10 +57,8 @@ object Mods {
|
||||
// ----------------------------------------------------------------------- //
|
||||
|
||||
object IDs {
|
||||
final val BloodMagic = "AWWayofTime"
|
||||
final val Forestry = "forestry"
|
||||
final val JustEnoughItems = "JEI"
|
||||
final val MCMultiPart = "mcmultipart"
|
||||
final val Minecraft = "Minecraft"
|
||||
final val OpenComputers = "OpenComputers"
|
||||
final val TIS3D = "tis3d"
|
||||
|
||||
@ -1,30 +0,0 @@
|
||||
package li.cil.oc.integration.bloodmagic;
|
||||
|
||||
import WayofTime.alchemicalWizardry.api.items.interfaces.IBloodOrb;
|
||||
import WayofTime.alchemicalWizardry.api.soulNetwork.SoulNetworkHandler;
|
||||
import li.cil.oc.api.driver.Converter;
|
||||
import net.minecraft.item.Item;
|
||||
import net.minecraft.item.ItemStack;
|
||||
|
||||
import java.util.Map;
|
||||
|
||||
public class ConverterBloodOrb implements Converter {
|
||||
@Override
|
||||
public void convert(Object value, Map<Object, Object> output) {
|
||||
if (value instanceof ItemStack) {
|
||||
final ItemStack stack = (ItemStack) value;
|
||||
final Item item = stack.getItem();
|
||||
if (item instanceof IBloodOrb) {
|
||||
final IBloodOrb bloodOrb = (IBloodOrb) item;
|
||||
final String ownerName = stack.stackTagCompound.getString("ownerName");
|
||||
final int maxOrbTier = SoulNetworkHandler.getCurrentMaxOrb(ownerName);
|
||||
output.put("ownerName", ownerName);
|
||||
output.put("networkOrbTier", maxOrbTier);
|
||||
output.put("networkEssence", SoulNetworkHandler.getCurrentEssence(ownerName));
|
||||
output.put("maxNetworkEssence", SoulNetworkHandler.getMaximumForOrbTier(maxOrbTier));
|
||||
output.put("maxEssence", bloodOrb.getMaxEssence());
|
||||
output.put("orbTier", bloodOrb.getOrbLevel());
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,80 +0,0 @@
|
||||
package li.cil.oc.integration.bloodmagic;
|
||||
|
||||
import WayofTime.alchemicalWizardry.api.tile.IBloodAltar;
|
||||
import li.cil.oc.api.driver.NamedBlock;
|
||||
import li.cil.oc.api.machine.Arguments;
|
||||
import li.cil.oc.api.machine.Callback;
|
||||
import li.cil.oc.api.machine.Context;
|
||||
import li.cil.oc.api.network.ManagedEnvironment;
|
||||
import li.cil.oc.api.prefab.DriverSidedTileEntity;
|
||||
import li.cil.oc.integration.ManagedTileEntityEnvironment;
|
||||
import net.minecraft.util.EnumFacing;
|
||||
import net.minecraft.world.World;
|
||||
|
||||
public class DriverBloodAltar extends DriverSidedTileEntity {
|
||||
@Override
|
||||
public Class<?> getTileEntityClass() {
|
||||
return IBloodAltar.class;
|
||||
}
|
||||
|
||||
@Override
|
||||
public ManagedEnvironment createEnvironment(final World world, final int x, final int y, final int z, final EnumFacing side) {
|
||||
return new Environment((IBloodAltar) world.getTileEntity(x, y, z));
|
||||
}
|
||||
|
||||
public static final class Environment extends ManagedTileEntityEnvironment<IBloodAltar> implements NamedBlock {
|
||||
public Environment(final IBloodAltar tileEntity) {
|
||||
super(tileEntity, "blood_altar");
|
||||
}
|
||||
|
||||
@Override
|
||||
public String preferredName() {
|
||||
return "blood_altar";
|
||||
}
|
||||
|
||||
@Override
|
||||
public int priority() {
|
||||
return 0;
|
||||
}
|
||||
|
||||
@Callback(doc = "function():number -- Get the capacity.")
|
||||
public Object[] getCapacity(final Context context, final Arguments arguments) {
|
||||
return new Object[]{tileEntity.getCapacity()};
|
||||
}
|
||||
|
||||
@Callback(doc = "function():number -- Get the amount of blood currently contained by this altar.")
|
||||
public Object[] getCurrentBlood(final Context context, final Arguments arguments) {
|
||||
return new Object[]{tileEntity.getCurrentBlood()};
|
||||
}
|
||||
|
||||
@Callback(doc = "function():number -- Get the current tier.")
|
||||
public Object[] getTier(final Context context, final Arguments arguments) {
|
||||
return new Object[]{tileEntity.getTier()};
|
||||
}
|
||||
|
||||
@Callback(doc = "function():number -- Get the progress.")
|
||||
public Object[] getProgress(final Context context, final Arguments arguments) {
|
||||
return new Object[]{tileEntity.getProgress()};
|
||||
}
|
||||
|
||||
@Callback(doc = "function():number -- Get the sacrifice multiplier.")
|
||||
public Object[] getSacrificeMultiplier(final Context context, final Arguments arguments) {
|
||||
return new Object[]{tileEntity.getCapacity()};
|
||||
}
|
||||
|
||||
@Callback(doc = "function():number -- Get the self sacrifice multiplier.")
|
||||
public Object[] getSelfSacrificeMultiplier(final Context context, final Arguments arguments) {
|
||||
return new Object[]{tileEntity.getSelfSacrificeMultiplier()};
|
||||
}
|
||||
|
||||
@Callback(doc = "function():number -- Get the orb multiplier.")
|
||||
public Object[] getOrbMultiplier(final Context context, final Arguments arguments) {
|
||||
return new Object[]{tileEntity.getOrbMultiplier()};
|
||||
}
|
||||
|
||||
@Callback(doc = "function():number -- Get the dislocation multiplier.")
|
||||
public Object[] getDislocationMultiplier(final Context context, final Arguments arguments) {
|
||||
return new Object[]{tileEntity.getDislocationMultiplier()};
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,70 +0,0 @@
|
||||
package li.cil.oc.integration.bloodmagic;
|
||||
|
||||
import WayofTime.alchemicalWizardry.api.rituals.IMasterRitualStone;
|
||||
import WayofTime.alchemicalWizardry.common.tileEntity.TEMasterStone;
|
||||
import li.cil.oc.api.driver.NamedBlock;
|
||||
import li.cil.oc.api.machine.Arguments;
|
||||
import li.cil.oc.api.machine.Callback;
|
||||
import li.cil.oc.api.machine.Context;
|
||||
import li.cil.oc.api.network.ManagedEnvironment;
|
||||
import li.cil.oc.api.prefab.DriverSidedTileEntity;
|
||||
import li.cil.oc.integration.ManagedTileEntityEnvironment;
|
||||
import net.minecraft.world.World;
|
||||
import net.minecraftforge.common.util.ForgeDirection;
|
||||
|
||||
public class DriverMasterRitualStone extends DriverSidedTileEntity {
|
||||
@Override
|
||||
public Class<?> getTileEntityClass() {
|
||||
return IMasterRitualStone.class;
|
||||
}
|
||||
|
||||
@Override
|
||||
public ManagedEnvironment createEnvironment(final World world, final int x, final int y, final int z, final ForgeDirection side) {
|
||||
return new Environment((IMasterRitualStone) world.getTileEntity(x, y, z));
|
||||
}
|
||||
|
||||
public static class Environment extends ManagedTileEntityEnvironment<IMasterRitualStone> implements NamedBlock {
|
||||
public Environment(IMasterRitualStone tileEntity) {
|
||||
super(tileEntity, "master_ritual_stone");
|
||||
}
|
||||
|
||||
@Override
|
||||
public String preferredName() {
|
||||
return "master_ritual_stone";
|
||||
}
|
||||
|
||||
@Override
|
||||
public int priority() {
|
||||
return 0;
|
||||
}
|
||||
|
||||
@Callback(doc = "function():string -- Get the name of the player owning this master ritual stone.")
|
||||
public Object[] getOwner(final Context context, final Arguments arguments) {
|
||||
return new Object[]{tileEntity.getOwner()};
|
||||
}
|
||||
|
||||
@Callback(doc = "function():string -- Get the current ritual.")
|
||||
public Object[] getCurrentRitual(final Context context, final Arguments arguments) {
|
||||
if (tileEntity instanceof TEMasterStone) {
|
||||
TEMasterStone masterStone = (TEMasterStone) tileEntity;
|
||||
return new Object[]{masterStone.getCurrentRitual()};
|
||||
}
|
||||
return new Object[]{"internal error"};
|
||||
}
|
||||
|
||||
@Callback(doc = "function():number -- Get the remaining cooldown.")
|
||||
public Object[] getCooldown(final Context context, final Arguments arguments) {
|
||||
return new Object[]{tileEntity.getCooldown()};
|
||||
}
|
||||
|
||||
@Callback(doc = "function():number -- Get the running time.")
|
||||
public Object[] getRunningTime(final Context context, final Arguments arguments) {
|
||||
return new Object[]{tileEntity.getRunningTime()};
|
||||
}
|
||||
|
||||
@Callback(doc = "function():boolean -- Get whether the tanks are empty.")
|
||||
public Object[] areTanksEmpty(final Context context, final Arguments arguments) {
|
||||
return new Object[]{tileEntity.areTanksEmpty()};
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,15 +0,0 @@
|
||||
package li.cil.oc.integration.bloodmagic
|
||||
|
||||
import li.cil.oc.api.Driver
|
||||
import li.cil.oc.integration.{Mods, ModProxy}
|
||||
|
||||
object ModBloodMagic extends ModProxy {
|
||||
override def getMod = Mods.BloodMagic
|
||||
|
||||
override def initialize() {
|
||||
Driver.add(new DriverBloodAltar)
|
||||
Driver.add(new DriverMasterRitualStone)
|
||||
|
||||
Driver.add(new ConverterBloodOrb)
|
||||
}
|
||||
}
|
||||
@ -10,7 +10,6 @@ import forestry.api.apiculture.IBee;
|
||||
import forestry.api.apiculture.IBeeGenome;
|
||||
import forestry.api.arboriculture.EnumTreeChromosome;
|
||||
import forestry.api.arboriculture.IAlleleFruit;
|
||||
import forestry.api.arboriculture.IAlleleGrowth;
|
||||
import forestry.api.arboriculture.IAlleleLeafEffect;
|
||||
import forestry.api.arboriculture.IAlleleTreeSpecies;
|
||||
import forestry.api.arboriculture.ITree;
|
||||
@ -21,7 +20,6 @@ import forestry.api.genetics.IAlleleBoolean;
|
||||
import forestry.api.genetics.IAlleleFloat;
|
||||
import forestry.api.genetics.IAlleleFlowers;
|
||||
import forestry.api.genetics.IAlleleInteger;
|
||||
import forestry.api.genetics.IAllelePlantType;
|
||||
import forestry.api.genetics.IAlleleTolerance;
|
||||
import forestry.api.genetics.IChromosome;
|
||||
import forestry.api.genetics.IChromosomeType;
|
||||
@ -93,18 +91,6 @@ public class ConverterIIndividual implements Converter {
|
||||
return allele.getValue();
|
||||
}
|
||||
})
|
||||
.put(IAllelePlantType.class, new IAlleleConverter<IAllelePlantType>() {
|
||||
@Override
|
||||
public Object convert(IAllelePlantType allele) {
|
||||
return allele.getPlantTypes();
|
||||
}
|
||||
})
|
||||
.put(IAlleleGrowth.class, new IAlleleConverter<IAlleleGrowth>() {
|
||||
@Override
|
||||
public Object convert(IAlleleGrowth allele) {
|
||||
return allele.getProvider().getInfo();
|
||||
}
|
||||
})
|
||||
.build();
|
||||
|
||||
private abstract static class GenomeReader<G extends IGenome, E extends Enum<E> & IChromosomeType> {
|
||||
@ -202,14 +188,12 @@ public class ConverterIIndividual implements Converter {
|
||||
@Override
|
||||
protected void addAlleleInfo(GenomeAccess access, Map<String, Object> result) {
|
||||
result.put("species", convertAllele(access, IAlleleTreeSpecies.class, EnumTreeChromosome.SPECIES));
|
||||
result.put("growth", convertAllele(access, IAlleleGrowth.class, EnumTreeChromosome.GROWTH));
|
||||
result.put("fireproof", convertAllele(access, IAlleleBoolean.class, EnumTreeChromosome.FIREPROOF));
|
||||
result.put("height", convertAllele(access, IAlleleFloat.class, EnumTreeChromosome.HEIGHT));
|
||||
result.put("fertility", convertAllele(access, IAlleleFloat.class, EnumTreeChromosome.FERTILITY));
|
||||
result.put("fruits", convertAllele(access, IAlleleFruit.class, EnumTreeChromosome.FRUITS));
|
||||
result.put("yield", convertAllele(access, IAlleleFloat.class, EnumTreeChromosome.YIELD));
|
||||
result.put("plant", convertAllele(access, IAllelePlantType.class, EnumTreeChromosome.PLANT));
|
||||
result.put("sappiness", convertAllele(access, IAlleleFloat.class, EnumTreeChromosome.SAPPINESS));
|
||||
result.put("territory", convertAllele(access, IAlleleArea.class, EnumTreeChromosome.TERRITORY));
|
||||
result.put("effect", convertAllele(access, IAlleleLeafEffect.class, EnumTreeChromosome.EFFECT));
|
||||
result.put("maturation", convertAllele(access, IAlleleInteger.class, EnumTreeChromosome.MATURATION));
|
||||
result.put("girth", convertAllele(access, IAlleleInteger.class, EnumTreeChromosome.GIRTH));
|
||||
|
||||
@ -4,22 +4,28 @@ import li.cil.oc.api.machine.Arguments;
|
||||
import li.cil.oc.api.machine.Callback;
|
||||
import li.cil.oc.api.machine.Context;
|
||||
import li.cil.oc.api.network.ManagedEnvironment;
|
||||
import li.cil.oc.api.prefab.DriverSidedTileEntity;
|
||||
import li.cil.oc.integration.ManagedTileEntityEnvironment;
|
||||
import net.minecraft.util.math.BlockPos;
|
||||
import net.minecraft.tileentity.TileEntity;
|
||||
import net.minecraft.util.EnumFacing;
|
||||
import net.minecraft.util.math.BlockPos;
|
||||
import net.minecraft.world.World;
|
||||
import net.minecraftforge.fluids.IFluidHandler;
|
||||
import net.minecraftforge.fluids.capability.CapabilityFluidHandler;
|
||||
import net.minecraftforge.fluids.capability.IFluidHandler;
|
||||
|
||||
public final class DriverFluidHandler extends DriverSidedTileEntity {
|
||||
public final class DriverFluidHandler implements li.cil.oc.api.driver.SidedBlock {
|
||||
@Override
|
||||
public Class<?> getTileEntityClass() {
|
||||
return IFluidHandler.class;
|
||||
public boolean worksWith(final World world, final BlockPos pos, final EnumFacing side) {
|
||||
final TileEntity tileEntity = world.getTileEntity(pos);
|
||||
if (tileEntity == null) {
|
||||
return false;
|
||||
}
|
||||
return tileEntity.hasCapability(CapabilityFluidHandler.FLUID_HANDLER_CAPABILITY, side) &&
|
||||
tileEntity.getCapability(CapabilityFluidHandler.FLUID_HANDLER_CAPABILITY, side) != null;
|
||||
}
|
||||
|
||||
@Override
|
||||
public ManagedEnvironment createEnvironment(final World world, final BlockPos pos, final EnumFacing side) {
|
||||
return new Environment((IFluidHandler) world.getTileEntity(pos));
|
||||
return new Environment(world.getTileEntity(pos).getCapability(CapabilityFluidHandler.FLUID_HANDLER_CAPABILITY, side));
|
||||
}
|
||||
|
||||
public static final class Environment extends ManagedTileEntityEnvironment<IFluidHandler> {
|
||||
@ -27,10 +33,9 @@ public final class DriverFluidHandler extends DriverSidedTileEntity {
|
||||
super(tileEntity, "fluid_handler");
|
||||
}
|
||||
|
||||
@Callback(doc = "function([side:number=6]):table -- Get some information about the tank accessible from the specified side.")
|
||||
@Callback(doc = "function():table -- Get some information about the tank accessible from the specified side.")
|
||||
public Object[] getTankInfo(final Context context, final Arguments args) {
|
||||
EnumFacing side = args.count() > 0 ? EnumFacing.getFront(args.checkInteger(0)) : EnumFacing.DOWN;
|
||||
return tileEntity.getTankInfo(side);
|
||||
return tileEntity.getTankProperties();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -12,9 +12,9 @@ import net.minecraft.entity.player.EntityPlayer;
|
||||
import net.minecraft.inventory.IInventory;
|
||||
import net.minecraft.item.ItemStack;
|
||||
import net.minecraft.tileentity.TileEntity;
|
||||
import net.minecraft.util.EnumFacing;
|
||||
import net.minecraft.util.EnumHand;
|
||||
import net.minecraft.util.math.BlockPos;
|
||||
import net.minecraft.util.EnumFacing;
|
||||
import net.minecraft.world.World;
|
||||
import net.minecraft.world.WorldServer;
|
||||
import net.minecraftforge.common.MinecraftForge;
|
||||
@ -61,7 +61,7 @@ public final class DriverInventory extends DriverSidedTileEntity {
|
||||
final int slot = checkSlot(args, 0);
|
||||
final ItemStack stack = tileEntity.getStackInSlot(slot);
|
||||
if (stack != null) {
|
||||
return new Object[]{stack.getCount};
|
||||
return new Object[]{stack.getCount()};
|
||||
} else {
|
||||
return new Object[]{0};
|
||||
}
|
||||
@ -118,19 +118,19 @@ public final class DriverInventory extends DriverSidedTileEntity {
|
||||
return new Object[]{true};
|
||||
} else if (itemEquals(stackA, stackB)) {
|
||||
// Pile.
|
||||
final int space = Math.min(tileEntity.getInventoryStackLimit(), stackB.getMaxStackSize()) - stackB.getCount;
|
||||
final int amount = Math.min(count, Math.min(space, stackA.getCount));
|
||||
final int space = Math.min(tileEntity.getInventoryStackLimit(), stackB.getMaxStackSize()) - stackB.getCount();
|
||||
final int amount = Math.min(count, Math.min(space, stackA.getCount()));
|
||||
if (amount > 0) {
|
||||
// Some.
|
||||
stackA.getCount -= amount;
|
||||
stackB.getCount += amount;
|
||||
if (stackA.getCount == 0) {
|
||||
stackA.setCount(stackA.getCount() - amount);
|
||||
stackB.setCount(stackB.getCount() + amount);
|
||||
if (stackA.getCount() == 0) {
|
||||
tileEntity.setInventorySlotContents(slotA, null);
|
||||
}
|
||||
tileEntity.markDirty();
|
||||
return new Object[]{true};
|
||||
}
|
||||
} else if (count >= stackA.getCount) {
|
||||
} else if (count >= stackA.getCount()) {
|
||||
// Swap.
|
||||
tileEntity.setInventorySlotContents(slotB, stackA);
|
||||
tileEntity.setInventorySlotContents(slotA, stackB);
|
||||
@ -179,7 +179,7 @@ public final class DriverInventory extends DriverSidedTileEntity {
|
||||
private boolean notPermitted() {
|
||||
synchronized (fakePlayer) {
|
||||
fakePlayer.setPosition(position.toVec3().xCoord, position.toVec3().yCoord, position.toVec3().zCoord);
|
||||
final PlayerInteractEvent.RightClickBlock event = new PlayerInteractEvent.RightClickBlock(fakePlayer, EnumHand.MAIN_HAND, fakePlayer.getHeldItemMainhand(), position.toBlockPos(), EnumFacing.DOWN, null);
|
||||
final PlayerInteractEvent.RightClickBlock event = new PlayerInteractEvent.RightClickBlock(fakePlayer, EnumHand.MAIN_HAND, position.toBlockPos(), EnumFacing.DOWN, null);
|
||||
MinecraftForge.EVENT_BUS.post(event);
|
||||
return !event.isCanceled() && event.getUseBlock() != Event.Result.DENY && !tileEntity.isUsableByPlayer(fakePlayer);
|
||||
}
|
||||
|
||||
@ -105,8 +105,6 @@ class Player(val agent: internal.Agent) extends FakePlayer(agent.world.asInstanc
|
||||
|
||||
var facing, side = EnumFacing.SOUTH
|
||||
|
||||
def world = agent.world
|
||||
|
||||
override def getPosition = new BlockPos(posX, posY, posZ)
|
||||
|
||||
override def getDefaultEyeHeight = 0f
|
||||
|
||||
@ -12,7 +12,7 @@ import net.minecraft.util.text.TextComponentString
|
||||
object DebugNanomachinesCommand extends SimpleCommand("oc_debugNanomachines") {
|
||||
aliases += "oc_dn"
|
||||
|
||||
override def getCommandUsage(source: ICommandSender): String = name
|
||||
override def getUsage(source: ICommandSender): String = name
|
||||
|
||||
override def execute(server: MinecraftServer, source: ICommandSender, args: Array[String]): Unit = {
|
||||
source match {
|
||||
|
||||
@ -15,7 +15,7 @@ object DebugWhitelistCommand extends SimpleCommand("oc_debugWhitelist") {
|
||||
override def getRequiredPermissionLevel = 0
|
||||
private def isOp(sender: ICommandSender) = getOpLevel(sender) >= 2
|
||||
|
||||
override def getCommandUsage(sender: ICommandSender): String =
|
||||
override def getUsage(sender: ICommandSender): String =
|
||||
if (isOp(sender)) name + " [revoke|add|remove] <player> OR " + name + " [revoke|list]"
|
||||
else name + " revoke"
|
||||
|
||||
@ -48,7 +48,7 @@ object DebugWhitelistCommand extends SimpleCommand("oc_debugWhitelist") {
|
||||
wl.remove(player)
|
||||
sender.sendMessage(new TextComponentString("§aPlayer was removed from whitelist"))
|
||||
case _ =>
|
||||
sender.sendMessage(new TextComponentString("§e" + getCommandUsage(sender)))
|
||||
sender.sendMessage(new TextComponentString("§e" + getUsage(sender)))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -12,7 +12,7 @@ import net.minecraftforge.fml.common.FMLCommonHandler
|
||||
object LogNanomachinesCommand extends SimpleCommand("oc_nanomachines") {
|
||||
aliases += "oc_nm"
|
||||
|
||||
override def getCommandUsage(source: ICommandSender): String = name + " [player]"
|
||||
override def getUsage(source: ICommandSender): String = name + " [player]"
|
||||
|
||||
override def execute(server: MinecraftServer, source: ICommandSender, command: Array[String]): Unit = {
|
||||
(if (command.length > 0) {
|
||||
|
||||
@ -13,7 +13,7 @@ object NonDisassemblyAgreementCommand extends SimpleCommand("oc_preventDisassemb
|
||||
aliases += "oc_nodis"
|
||||
aliases += "oc_prevdis"
|
||||
|
||||
override def getCommandUsage(source: ICommandSender) = name + " <boolean>"
|
||||
override def getUsage(source: ICommandSender) = name + " <boolean>"
|
||||
|
||||
override def execute(server: MinecraftServer, source: ICommandSender, command: Array[String]): Unit = {
|
||||
source match {
|
||||
|
||||
@ -10,7 +10,7 @@ import net.minecraft.server.MinecraftServer
|
||||
object SendDebugMessageCommand extends SimpleCommand("oc_sendDebugMessage") {
|
||||
aliases += "oc_sdbg"
|
||||
|
||||
override def getCommandUsage(sender: ICommandSender): String = name + "<destinationAddress> [message...]"
|
||||
override def getUsage(sender: ICommandSender): String = name + "<destinationAddress> [message...]"
|
||||
|
||||
override def execute(server: MinecraftServer, sender: ICommandSender, args: Array[String]): Unit = {
|
||||
if (args == null || args.length == 0) {
|
||||
|
||||
@ -21,7 +21,7 @@ object SpawnComputerCommand extends SimpleCommand("oc_spawnComputer") {
|
||||
|
||||
final val MaxDistance = 16
|
||||
|
||||
override def getCommandUsage(source: ICommandSender): String = name
|
||||
override def getUsage(source: ICommandSender): String = name
|
||||
|
||||
override def execute(server: MinecraftServer, source: ICommandSender, command: Array[String]): Unit = {
|
||||
source match {
|
||||
|
||||
@ -9,7 +9,7 @@ import net.minecraft.server.MinecraftServer
|
||||
object WirelessRenderingCommand extends SimpleCommand("oc_renderWirelessNetwork") {
|
||||
aliases += "oc_wlan"
|
||||
|
||||
override def getCommandUsage(source: ICommandSender) = name + " <boolean>"
|
||||
override def getUsage(source: ICommandSender) = name + " <boolean>"
|
||||
|
||||
override def execute(server: MinecraftServer, source: ICommandSender, command: Array[String]): Unit = {
|
||||
Settings.rTreeDebugRenderer =
|
||||
|
||||
@ -859,7 +859,7 @@ object DebugCard {
|
||||
|
||||
override def getPosition = underlying.getPosition
|
||||
|
||||
override def canCommandSenderUseCommand(level: Int, commandName: String) = {
|
||||
override def canUseCommand(level: Int, commandName: String) = {
|
||||
val profile = underlying.getGameProfile
|
||||
val server = underlying.mcServer
|
||||
val config = server.getPlayerList
|
||||
|
||||
@ -18,6 +18,7 @@ import net.minecraftforge.fluids.FluidTankInfo
|
||||
import net.minecraftforge.fluids.IFluidBlock
|
||||
import net.minecraftforge.fluids.capability
|
||||
import net.minecraftforge.fluids.capability.CapabilityFluidHandler
|
||||
import net.minecraftforge.fluids.capability.FluidTankProperties
|
||||
import net.minecraftforge.fluids.capability.IFluidHandler
|
||||
import net.minecraftforge.fluids.capability.IFluidHandlerItem
|
||||
import net.minecraftforge.fluids.capability.IFluidTankProperties
|
||||
@ -86,17 +87,17 @@ object FluidUtils {
|
||||
// ----------------------------------------------------------------------- //
|
||||
|
||||
private class GenericBlockWrapper(position: BlockPosition) extends IFluidHandler {
|
||||
override def canDrain(from: EnumFacing, fluid: Fluid): Boolean = currentWrapper.fold(false)(_.drain(new FluidStack(fluid, 1), false).amount > 0)
|
||||
def canDrain(fluid: Fluid): Boolean = currentWrapper.fold(false)(_.drain(new FluidStack(fluid, 1), false).amount > 0)
|
||||
|
||||
override def drain(from: EnumFacing, resource: FluidStack, doDrain: Boolean): FluidStack = currentWrapper.fold(null: FluidStack)(_.drain(resource, doDrain))
|
||||
override def drain(resource: FluidStack, doDrain: Boolean): FluidStack = currentWrapper.fold(null: FluidStack)(_.drain(resource, doDrain))
|
||||
|
||||
override def drain(from: EnumFacing, maxDrain: Int, doDrain: Boolean): FluidStack = currentWrapper.fold(null: FluidStack)(_.drain(maxDrain, doDrain))
|
||||
override def drain(maxDrain: Int, doDrain: Boolean): FluidStack = currentWrapper.fold(null: FluidStack)(_.drain(maxDrain, doDrain))
|
||||
|
||||
override def canFill(from: EnumFacing, fluid: Fluid): Boolean = currentWrapper.fold(false)(_.fill(new FluidStack(fluid, 1), false) > 0)
|
||||
def canFill(fluid: Fluid): Boolean = currentWrapper.fold(false)(_.fill(new FluidStack(fluid, 1), false) > 0)
|
||||
|
||||
override def fill(from: EnumFacing, resource: FluidStack, doFill: Boolean): Int = currentWrapper.fold(0)(_.fill(resource, doFill))
|
||||
override def fill(resource: FluidStack, doFill: Boolean): Int = currentWrapper.fold(0)(_.fill(resource, doFill))
|
||||
|
||||
override def getTankInfo(from: EnumFacing): Array[IFluidTankProperties] = currentWrapper.fold(Array.empty[IFluidTankProperties])(_.getTankProperties)
|
||||
override def getTankProperties: Array[IFluidTankProperties] = currentWrapper.fold(Array.empty[IFluidTankProperties])(_.getTankProperties)
|
||||
|
||||
def currentWrapper = if (position.world.get.blockExists(position)) position.world.get.getBlock(position) match {
|
||||
case block: IFluidBlock => Option(new FluidBlockWrapper(position, block))
|
||||
@ -116,7 +117,7 @@ object FluidUtils {
|
||||
private trait BlockWrapperBase extends IFluidHandler {
|
||||
protected def uncheckedDrain(doDrain: Boolean): FluidStack
|
||||
|
||||
override def drain(from: EnumFacing, resource: FluidStack, doDrain: Boolean): FluidStack = {
|
||||
override def drain(resource: FluidStack, doDrain: Boolean): FluidStack = {
|
||||
val drained = uncheckedDrain(false)
|
||||
if (drained != null && (resource == null || (drained.getFluid == resource.getFluid && drained.amount <= resource.amount))) {
|
||||
uncheckedDrain(doDrain)
|
||||
@ -124,7 +125,7 @@ object FluidUtils {
|
||||
else null
|
||||
}
|
||||
|
||||
override def drain(from: EnumFacing, maxDrain: Int, doDrain: Boolean): FluidStack = {
|
||||
override def drain(maxDrain: Int, doDrain: Boolean): FluidStack = {
|
||||
val drained = uncheckedDrain(false)
|
||||
if (drained != null && drained.amount <= maxDrain) {
|
||||
uncheckedDrain(doDrain)
|
||||
@ -132,17 +133,17 @@ object FluidUtils {
|
||||
else null
|
||||
}
|
||||
|
||||
override def canFill(from: EnumFacing, fluid: Fluid): Boolean = false
|
||||
def canFill(fluid: Fluid): Boolean = false
|
||||
|
||||
override def fill(from: EnumFacing, resource: FluidStack, doFill: Boolean): Int = 0
|
||||
override def fill(resource: FluidStack, doFill: Boolean): Int = 0
|
||||
}
|
||||
|
||||
private class FluidBlockWrapper(val position: BlockPosition, val block: IFluidBlock) extends BlockWrapperBase {
|
||||
final val AssumedCapacity = Fluid.BUCKET_VOLUME
|
||||
|
||||
override def canDrain(from: EnumFacing, fluid: Fluid): Boolean = block.canDrain(position)
|
||||
def canDrain(fluid: Fluid): Boolean = block.canDrain(position)
|
||||
|
||||
override def getTankInfo(from: EnumFacing): Array[FluidTankInfo] = Array(new FluidTankInfo(new FluidTank(block.getFluid, (block.getFilledPercentage(position) * AssumedCapacity).toInt, AssumedCapacity)))
|
||||
override def getTankProperties: Array[IFluidTankProperties] = Array(new FluidTankProperties(new FluidStack(block.getFluid, (block.getFilledPercentage(position) * AssumedCapacity).toInt), AssumedCapacity))
|
||||
|
||||
override protected def uncheckedDrain(doDrain: Boolean): FluidStack = block.drain(position, doDrain)
|
||||
}
|
||||
@ -150,9 +151,9 @@ object FluidUtils {
|
||||
private class LiquidBlockWrapper(val position: BlockPosition, val block: BlockLiquid) extends BlockWrapperBase {
|
||||
val fluid = lookupFluidForBlock(block)
|
||||
|
||||
override def canDrain(from: EnumFacing, fluid: Fluid): Boolean = true
|
||||
def canDrain(fluid: Fluid): Boolean = true
|
||||
|
||||
override def getTankInfo(from: EnumFacing): Array[FluidTankInfo] = Array(new FluidTankInfo(new FluidTank(fluid, Fluid.BUCKET_VOLUME, Fluid.BUCKET_VOLUME)))
|
||||
override def getTankProperties: Array[IFluidTankProperties] = Array(new FluidTankProperties(new FluidStack(fluid, Fluid.BUCKET_VOLUME), Fluid.BUCKET_VOLUME))
|
||||
|
||||
override protected def uncheckedDrain(doDrain: Boolean): FluidStack = {
|
||||
if (doDrain) {
|
||||
@ -163,15 +164,15 @@ object FluidUtils {
|
||||
}
|
||||
|
||||
private class AirBlockWrapper(val position: BlockPosition, val block: Block) extends IFluidHandler {
|
||||
override def canDrain(from: EnumFacing, fluid: Fluid): Boolean = false
|
||||
def canDrain(fluid: Fluid): Boolean = false
|
||||
|
||||
override def drain(from: EnumFacing, resource: FluidStack, doDrain: Boolean): FluidStack = null
|
||||
override def drain(resource: FluidStack, doDrain: Boolean): FluidStack = null
|
||||
|
||||
override def drain(from: EnumFacing, maxDrain: Int, doDrain: Boolean): FluidStack = null
|
||||
override def drain(maxDrain: Int, doDrain: Boolean): FluidStack = null
|
||||
|
||||
override def canFill(from: EnumFacing, fluid: Fluid): Boolean = fluid.canBePlacedInWorld
|
||||
def canFill(fluid: Fluid): Boolean = fluid.canBePlacedInWorld
|
||||
|
||||
override def fill(from: EnumFacing, resource: FluidStack, doFill: Boolean): Int = {
|
||||
override def fill(resource: FluidStack, doFill: Boolean): Int = {
|
||||
if (resource != null && resource.getFluid.canBePlacedInWorld && resource.getFluid.getBlock != null) {
|
||||
if (doFill) {
|
||||
val world = position.world.get
|
||||
@ -186,21 +187,21 @@ object FluidUtils {
|
||||
else 0
|
||||
}
|
||||
|
||||
override def getTankInfo(from: EnumFacing): Array[FluidTankInfo] = Array.empty
|
||||
override def getTankProperties: Array[IFluidTankProperties] = Array.empty
|
||||
}
|
||||
|
||||
private class HandlerCapabilityWrapper(val position: BlockPosition, val handler: capability.IFluidHandler) extends IFluidHandler {
|
||||
override def drain(from: EnumFacing, resource: FluidStack, doDrain: Boolean): FluidStack = handler.drain(resource, doDrain)
|
||||
override def drain(resource: FluidStack, doDrain: Boolean): FluidStack = handler.drain(resource, doDrain)
|
||||
|
||||
override def drain(from: EnumFacing, maxDrain: Int, doDrain: Boolean): FluidStack = handler.drain(maxDrain, doDrain)
|
||||
override def drain(maxDrain: Int, doDrain: Boolean): FluidStack = handler.drain(maxDrain, doDrain)
|
||||
|
||||
override def canFill(from: EnumFacing, fluid: Fluid): Boolean = handler.getTankProperties.exists(_.canFill)
|
||||
def canFill(fluid: Fluid): Boolean = handler.getTankProperties.exists(_.canFill)
|
||||
|
||||
override def canDrain(from: EnumFacing, fluid: Fluid): Boolean = handler.getTankProperties.exists(_.canDrain)
|
||||
def canDrain(fluid: Fluid): Boolean = handler.getTankProperties.exists(_.canDrain)
|
||||
|
||||
override def fill(from: EnumFacing, resource: FluidStack, doFill: Boolean): Int = handler.fill(resource, doFill)
|
||||
override def fill(resource: FluidStack, doFill: Boolean): Int = handler.fill(resource, doFill)
|
||||
|
||||
override def getTankInfo(from: EnumFacing): Array[FluidTankInfo] = handler.getTankProperties.map(f => new FluidTankInfo(f.getContents, f.getCapacity))
|
||||
override def getTankProperties: Array[IFluidTankProperties] = handler.getTankProperties.map(f => new FluidTankProperties(f.getContents, f.getCapacity))
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
@ -1,235 +0,0 @@
|
||||
import li.cil.oc.api
|
||||
import li.cil.oc.api.network.Environment
|
||||
import li.cil.oc.api.network.Message
|
||||
import li.cil.oc.api.network.Node
|
||||
import li.cil.oc.api.network.Visibility
|
||||
import li.cil.oc.server.network.Network
|
||||
import li.cil.oc.server.network.{Node => MutableNode}
|
||||
import org.scalatest._
|
||||
import org.scalatest.mock.MockitoSugar
|
||||
|
||||
import scala.collection.convert.WrapAsScala._
|
||||
|
||||
class NetworkTest extends FlatSpec with MockitoSugar {
|
||||
Network.isServer = () => true
|
||||
api.API.network = Network
|
||||
|
||||
val host = mock[Environment]
|
||||
|
||||
"A Node" should "not belong to a network after creation" in {
|
||||
val node = api.Network.newNode(host, Visibility.Network).create()
|
||||
assert(node.network == null)
|
||||
}
|
||||
|
||||
it should "belong to a network after joining a new network" in {
|
||||
val node = api.Network.newNode(host, Visibility.Network).create()
|
||||
api.Network.joinNewNetwork(node)
|
||||
assert(node.network != null)
|
||||
}
|
||||
|
||||
it should "not belong to a network after being removed from its new network" in {
|
||||
val node = api.Network.newNode(host, Visibility.Network).create()
|
||||
api.Network.joinNewNetwork(node)
|
||||
node.remove()
|
||||
assert(node.network == null)
|
||||
}
|
||||
|
||||
it should "have a neighbor after being connected to another node" in {
|
||||
val node1 = api.Network.newNode(host, Visibility.Network).create()
|
||||
api.Network.joinNewNetwork(node1)
|
||||
val node2 = api.Network.newNode(host, Visibility.Network).create()
|
||||
node1.connect(node2)
|
||||
assert(node1.neighbors.nonEmpty)
|
||||
assert(node2.neighbors.nonEmpty)
|
||||
assert(node1.isNeighborOf(node2))
|
||||
assert(node2.isNeighborOf(node1))
|
||||
}
|
||||
|
||||
it should "be reachable by neighbors when visibility is set to Neighbors" in {
|
||||
val node1 = api.Network.newNode(host, Visibility.Neighbors).create()
|
||||
api.Network.joinNewNetwork(node1)
|
||||
val node2 = api.Network.newNode(host, Visibility.Network).create()
|
||||
node1.connect(node2)
|
||||
assert(node1.canBeReachedFrom(node2))
|
||||
}
|
||||
|
||||
it should "be in the same network as nodes it is connected to" in {
|
||||
val node1 = api.Network.newNode(host, Visibility.Network).create()
|
||||
api.Network.joinNewNetwork(node1)
|
||||
val node2 = api.Network.newNode(host, Visibility.Network).create()
|
||||
node1.connect(node2)
|
||||
val node3 = api.Network.newNode(host, Visibility.Network).create()
|
||||
node2.connect(node3)
|
||||
|
||||
assert(node1.network == node2.network)
|
||||
assert(node2.network == node3.network)
|
||||
assert(node1.network == node3.network)
|
||||
}
|
||||
|
||||
it should "have a different address than nodes it is connected to" in {
|
||||
val node1 = api.Network.newNode(host, Visibility.Network).create()
|
||||
api.Network.joinNewNetwork(node1)
|
||||
val node2 = api.Network.newNode(host, Visibility.Network).create()
|
||||
node1.connect(node2)
|
||||
val node3 = api.Network.newNode(host, Visibility.Network).create()
|
||||
node2.connect(node3)
|
||||
|
||||
assert(node1.address != node2.address)
|
||||
assert(node2.address != node3.address)
|
||||
assert(node1.address != node3.address)
|
||||
}
|
||||
|
||||
it should "not be reachable by non neighbors when visibility is set to Neighbors" in {
|
||||
val node1 = api.Network.newNode(host, Visibility.Neighbors).create()
|
||||
api.Network.joinNewNetwork(node1)
|
||||
val node2 = api.Network.newNode(host, Visibility.Network).create()
|
||||
node1.connect(node2)
|
||||
val node3 = api.Network.newNode(host, Visibility.Network).create()
|
||||
node2.connect(node3)
|
||||
assert(!node1.canBeReachedFrom(node3))
|
||||
}
|
||||
|
||||
it should "be reachable by all nodes when visibility is set to Network" in {
|
||||
val node1 = api.Network.newNode(host, Visibility.Network).create()
|
||||
api.Network.joinNewNetwork(node1)
|
||||
val node2 = api.Network.newNode(host, Visibility.Network).create()
|
||||
node1.connect(node2)
|
||||
val node3 = api.Network.newNode(host, Visibility.Network).create()
|
||||
node2.connect(node3)
|
||||
assert(node1.canBeReachedFrom(node2))
|
||||
assert(node1.canBeReachedFrom(node3))
|
||||
}
|
||||
|
||||
it should "not be reachable by any node when visibility is set to None" in {
|
||||
val node1 = api.Network.newNode(host, Visibility.None).create()
|
||||
api.Network.joinNewNetwork(node1)
|
||||
val node2 = api.Network.newNode(host, Visibility.Network).create()
|
||||
node1.connect(node2)
|
||||
val node3 = api.Network.newNode(host, Visibility.Network).create()
|
||||
node2.connect(node3)
|
||||
assert(!node1.canBeReachedFrom(node2))
|
||||
assert(!node1.canBeReachedFrom(node3))
|
||||
}
|
||||
|
||||
it should "be in a separate network after a netsplit" in {
|
||||
val node1 = api.Network.newNode(host, Visibility.Network).create()
|
||||
api.Network.joinNewNetwork(node1)
|
||||
val node2 = api.Network.newNode(host, Visibility.Network).create()
|
||||
node1.connect(node2)
|
||||
val node3 = api.Network.newNode(host, Visibility.Network).create()
|
||||
node2.connect(node3)
|
||||
|
||||
node2.remove()
|
||||
|
||||
assert(node1.network != null)
|
||||
assert(node2.network == null)
|
||||
assert(node3.network != null)
|
||||
assert(node1.network != node3.network)
|
||||
}
|
||||
|
||||
it should "change its address when joining a network containing a node with its address" in {
|
||||
val node1 = api.Network.newNode(host, Visibility.Network).create()
|
||||
api.Network.joinNewNetwork(node1)
|
||||
val node2 = api.Network.newNode(host, Visibility.Network).create()
|
||||
node2.asInstanceOf[MutableNode].address = node1.address
|
||||
node1.connect(node2)
|
||||
assert(node1.address != node2.address)
|
||||
}
|
||||
|
||||
"A Network" should "keep its local layout after being merged with another network" in {
|
||||
val node1 = api.Network.newNode(host, Visibility.Network).create()
|
||||
api.Network.joinNewNetwork(node1)
|
||||
val node2 = api.Network.newNode(host, Visibility.Network).create()
|
||||
node1.connect(node2)
|
||||
val node3 = api.Network.newNode(host, Visibility.Network).create()
|
||||
node2.connect(node3)
|
||||
|
||||
val node4 = api.Network.newNode(host, Visibility.Network).create()
|
||||
api.Network.joinNewNetwork(node4)
|
||||
val node5 = api.Network.newNode(host, Visibility.Network).create()
|
||||
node4.connect(node5)
|
||||
val node6 = api.Network.newNode(host, Visibility.Network).create()
|
||||
node5.connect(node6)
|
||||
|
||||
node2.connect(node5)
|
||||
|
||||
assert(node1.neighbors.size == 1 && node1.isNeighborOf(node2))
|
||||
assert(node3.neighbors.size == 1 && node3.isNeighborOf(node2))
|
||||
|
||||
assert(node4.neighbors.size == 1 && node4.isNeighborOf(node5))
|
||||
assert(node6.neighbors.size == 1 && node6.isNeighborOf(node5))
|
||||
|
||||
assert(node2.isNeighborOf(node5))
|
||||
}
|
||||
|
||||
it should "keep its local layout after being merged with another network containing nodes with duplicate addresses at bridge points" in {
|
||||
val node1 = api.Network.newNode(host, Visibility.Network).create()
|
||||
api.Network.joinNewNetwork(node1)
|
||||
val node2 = api.Network.newNode(host, Visibility.Network).create()
|
||||
node1.connect(node2)
|
||||
val node3 = api.Network.newNode(host, Visibility.Network).create()
|
||||
node1.connect(node3)
|
||||
val node4 = api.Network.newNode(host, Visibility.Network).create()
|
||||
node3.connect(node4)
|
||||
|
||||
val node5 = api.Network.newNode(host, Visibility.Network).create()
|
||||
node5.asInstanceOf[MutableNode].address = node1.address
|
||||
api.Network.joinNewNetwork(node5)
|
||||
val node6 = api.Network.newNode(host, Visibility.Network).create()
|
||||
node6.asInstanceOf[MutableNode].address = node2.address
|
||||
node5.connect(node6)
|
||||
val node7 = api.Network.newNode(host, Visibility.Network).create()
|
||||
node7.asInstanceOf[MutableNode].address = node3.address
|
||||
node5.connect(node7)
|
||||
val node8 = api.Network.newNode(host, Visibility.Network).create()
|
||||
node8.asInstanceOf[MutableNode].address = node4.address
|
||||
node7.connect(node8)
|
||||
|
||||
node3.connect(node7)
|
||||
|
||||
assert(node1.neighbors.size == 2 && node1.isNeighborOf(node2) && node1.isNeighborOf(node3))
|
||||
assert(node2.neighbors.size == 1 && node2.isNeighborOf(node1))
|
||||
assert(node3.neighbors.size == 3 && node3.isNeighborOf(node1) && node3.isNeighborOf(node4) && node3.isNeighborOf(node7))
|
||||
assert(node4.neighbors.size == 1 && node4.isNeighborOf(node3))
|
||||
|
||||
assert(node5.neighbors.size == 2 && node5.isNeighborOf(node6) && node5.isNeighborOf(node7))
|
||||
assert(node6.neighbors.size == 1 && node6.isNeighborOf(node5))
|
||||
assert(node7.neighbors.size == 3 && node7.isNeighborOf(node5) && node7.isNeighborOf(node8) && node7.isNeighborOf(node3))
|
||||
assert(node8.neighbors.size == 1 && node8.isNeighborOf(node7))
|
||||
}
|
||||
|
||||
it should "not error when nodes disconnect themselves in a remapping operation" in {
|
||||
val host = new Environment {
|
||||
val node1 = api.Network.newNode(this, Visibility.Network).create()
|
||||
val node2 = api.Network.newNode(this, Visibility.Network).create()
|
||||
|
||||
api.Network.joinNewNetwork(node1)
|
||||
|
||||
override def node: Node = node1
|
||||
|
||||
override def onMessage(message: Message): Unit = {}
|
||||
|
||||
override def onConnect(node: Node): Unit = {
|
||||
if (node == node1) {
|
||||
node.connect(node2)
|
||||
}
|
||||
}
|
||||
|
||||
override def onDisconnect(node: Node): Unit = {
|
||||
if (node == node1) {
|
||||
node2.remove()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
val node3 = api.Network.newNode(host, Visibility.Network).create()
|
||||
node3.asInstanceOf[MutableNode].address = host.node.address
|
||||
api.Network.joinNewNetwork(node3)
|
||||
|
||||
node3.connect(host.node)
|
||||
|
||||
assert(host.node1.neighbors.size == 2 && host.node1.isNeighborOf(host.node2) && host.node1.isNeighborOf(node3))
|
||||
assert(host.node2.neighbors.size == 1 && host.node2.isNeighborOf(host.node1))
|
||||
assert(node3.neighbors.size == 1 && node3.isNeighborOf(host.node1))
|
||||
}
|
||||
}
|
||||
Loading…
x
Reference in New Issue
Block a user