Fixes #675 No disabled feature should log spam or crash anymore.

Deprecates the old usage of the AEItemDefinitions via the direct method access of

* blocks()
* parts()
* items()
* materials()

and thus use the new re-direct via definitions().

All definitions are now initialized, no matter what. But SubItems, Items and Blocks are not registered, if by chance are disabled.
This commit is contained in:
thatsIch
2015-01-03 02:53:14 +01:00
parent 3dd81433ac
commit 9986ffc458
385 changed files with 12477 additions and 8292 deletions
@@ -0,0 +1,599 @@
/*
* This file is part of Applied Energistics 2.
* Copyright (c) 2013 - 2015, AlgorithmX2, All rights reserved.
*
* Applied Energistics 2 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.
*
* Applied Energistics 2 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 Applied Energistics 2. If not, see <http://www.gnu.org/licenses/lgpl>.
*/
package appeng.core.api.definitions;
import java.util.Set;
import com.google.common.collect.ImmutableSet;
import appeng.api.definitions.IBlockDefinition;
import appeng.api.definitions.IBlocks;
import appeng.api.definitions.ITileDefinition;
import appeng.api.util.IOrientableBlock;
import appeng.block.crafting.BlockCraftingMonitor;
import appeng.block.crafting.BlockCraftingStorage;
import appeng.block.crafting.BlockCraftingUnit;
import appeng.block.crafting.BlockMolecularAssembler;
import appeng.block.grindstone.BlockCrank;
import appeng.block.grindstone.BlockGrinder;
import appeng.block.misc.BlockCellWorkbench;
import appeng.block.misc.BlockCharger;
import appeng.block.misc.BlockCondenser;
import appeng.block.misc.BlockInscriber;
import appeng.block.misc.BlockInterface;
import appeng.block.misc.BlockLightDetector;
import appeng.block.misc.BlockPaint;
import appeng.block.misc.BlockQuartzGrowthAccelerator;
import appeng.block.misc.BlockQuartzTorch;
import appeng.block.misc.BlockSecurity;
import appeng.block.misc.BlockSkyCompass;
import appeng.block.misc.BlockTinyTNT;
import appeng.block.misc.BlockVibrationChamber;
import appeng.block.networking.BlockCableBus;
import appeng.block.networking.BlockController;
import appeng.block.networking.BlockCreativeEnergyCell;
import appeng.block.networking.BlockDenseEnergyCell;
import appeng.block.networking.BlockEnergyAcceptor;
import appeng.block.networking.BlockEnergyCell;
import appeng.block.networking.BlockWireless;
import appeng.block.qnb.BlockQuantumLinkChamber;
import appeng.block.qnb.BlockQuantumRing;
import appeng.block.solids.BlockFluix;
import appeng.block.solids.BlockQuartz;
import appeng.block.solids.BlockQuartzChiseled;
import appeng.block.solids.BlockQuartzGlass;
import appeng.block.solids.BlockQuartzLamp;
import appeng.block.solids.BlockQuartzPillar;
import appeng.block.solids.BlockSkyStone;
import appeng.block.solids.OreQuartz;
import appeng.block.solids.OreQuartzCharged;
import appeng.block.spatial.BlockMatrixFrame;
import appeng.block.spatial.BlockSpatialIOPort;
import appeng.block.spatial.BlockSpatialPylon;
import appeng.block.stair.ChiseledQuartzStairBlock;
import appeng.block.stair.FluixStairBlock;
import appeng.block.stair.QuartzPillarStairBlock;
import appeng.block.stair.QuartzStairBlock;
import appeng.block.stair.SkyStoneBlockStairBlock;
import appeng.block.stair.SkyStoneBrickStairBlock;
import appeng.block.stair.SkyStoneSmallBrickStairBlock;
import appeng.block.stair.SkyStoneStairBlock;
import appeng.block.storage.BlockChest;
import appeng.block.storage.BlockDrive;
import appeng.block.storage.BlockIOPort;
import appeng.block.storage.BlockSkyChest;
import appeng.core.features.WrappedDamageItemDefinition;
import appeng.debug.BlockChunkloader;
import appeng.debug.BlockCubeGenerator;
import appeng.debug.BlockItemGen;
import appeng.debug.BlockPhantomNode;
/**
* Internal implementation for the API blocks
*/
public final class ApiBlocks implements IBlocks
{
private final IBlockDefinition quartzOre;
private final IBlockDefinition quartzOreCharged;
private final IBlockDefinition matrixFrame;
private final IBlockDefinition quartz;
private final IBlockDefinition quartzPillar;
private final IBlockDefinition quartzChiseled;
private final IBlockDefinition quartzGlass;
private final IBlockDefinition quartzVibrantGlass;
private final IBlockDefinition quartzTorch;
private final IBlockDefinition fluix;
private final IBlockDefinition skyStone;
private final IBlockDefinition skyChest;
private final IBlockDefinition skyCompass;
private final ITileDefinition grindStone;
private final ITileDefinition crankHandle;
private final ITileDefinition inscriber;
private final ITileDefinition wireless;
private final ITileDefinition charger;
private final ITileDefinition tinyTNT;
private final ITileDefinition security;
private final ITileDefinition quantumRing;
private final ITileDefinition quantumLink;
private final ITileDefinition spatialPylon;
private final ITileDefinition spatialIOPort;
private final ITileDefinition multiPart;
private final ITileDefinition controller;
private final ITileDefinition drive;
private final ITileDefinition chest;
private final ITileDefinition iface;
private final ITileDefinition cellWorkbench;
private final ITileDefinition iOPort;
private final ITileDefinition condenser;
private final ITileDefinition energyAcceptor;
private final ITileDefinition vibrationChamber;
private final ITileDefinition quartzGrowthAccelerator;
private final ITileDefinition energyCell;
private final ITileDefinition energyCellDense;
private final ITileDefinition energyCellCreative;
private final ITileDefinition craftingUnit;
private final ITileDefinition craftingAccelerator;
private final ITileDefinition craftingStorage1k;
private final ITileDefinition craftingStorage4k;
private final ITileDefinition craftingStorage16k;
private final ITileDefinition craftingStorage64k;
private final ITileDefinition craftingMonitor;
private final ITileDefinition molecularAssembler;
private final ITileDefinition lightDetector;
private final ITileDefinition paint;
private final IBlockDefinition skyStoneStair;
private final IBlockDefinition skyStoneBlockStair;
private final IBlockDefinition skyStoneBrickStair;
private final IBlockDefinition skyStoneSmallBrickStair;
private final IBlockDefinition fluixStair;
private final IBlockDefinition quartzStair;
private final IBlockDefinition chiseledQuartzStair;
private final IBlockDefinition quartzPillarStair;
private final IBlockDefinition itemGen;
private final IBlockDefinition chunkLoader;
private final IBlockDefinition phantomNode;
private final IBlockDefinition cubeGenerator;
private final Set<IOrientableBlock> orientables;
public ApiBlocks( DefinitionConstructor constructor )
{
final BlockLightDetector lightDetector = new BlockLightDetector();
final BlockQuartzPillar quartzPillar = new BlockQuartzPillar();
final BlockSkyStone skyStone = new BlockSkyStone();
final BlockFluix fluixBlock = new BlockFluix();
final BlockQuartzGrowthAccelerator cga = new BlockQuartzGrowthAccelerator();
final BlockQuartzTorch quartzTorch = new BlockQuartzTorch();
final BlockQuartz quartzBlock = new BlockQuartz();
final BlockQuartzChiseled chiseldQuartz = new BlockQuartzChiseled();
this.orientables = ImmutableSet.<IOrientableBlock>of( lightDetector, quartzPillar, skyStone, cga, quartzTorch );
this.quartzOre = constructor.registerBlockDefinition( new OreQuartz() );
this.quartzOreCharged = constructor.registerBlockDefinition( new OreQuartzCharged() );
this.matrixFrame = constructor.registerBlockDefinition( new BlockMatrixFrame() );
this.quartz = constructor.registerBlockDefinition( quartzBlock );
this.quartzPillar = constructor.registerBlockDefinition( quartzPillar );
this.quartzChiseled = constructor.registerBlockDefinition( chiseldQuartz );
this.quartzGlass = constructor.registerBlockDefinition( new BlockQuartzGlass() );
this.quartzVibrantGlass = constructor.registerBlockDefinition( new BlockQuartzLamp() );
this.quartzTorch = constructor.registerBlockDefinition( quartzTorch );
this.fluix = constructor.registerBlockDefinition( fluixBlock );
this.skyStone = constructor.registerBlockDefinition( skyStone );
this.skyChest = constructor.registerBlockDefinition( new BlockSkyChest() );
this.skyCompass = constructor.registerBlockDefinition( new BlockSkyCompass() );
this.grindStone = constructor.registerTileDefinition( new BlockGrinder() );
this.crankHandle = constructor.registerTileDefinition( new BlockCrank() );
this.inscriber = constructor.registerTileDefinition( new BlockInscriber() );
this.wireless = constructor.registerTileDefinition( new BlockWireless() );
this.charger = constructor.registerTileDefinition( new BlockCharger() );
this.tinyTNT = constructor.registerTileDefinition( new BlockTinyTNT() );
this.security = constructor.registerTileDefinition( new BlockSecurity() );
this.quantumRing = constructor.registerTileDefinition( new BlockQuantumRing() );
this.quantumLink = constructor.registerTileDefinition( new BlockQuantumLinkChamber() );
this.spatialPylon = constructor.registerTileDefinition( new BlockSpatialPylon() );
this.spatialIOPort = constructor.registerTileDefinition( new BlockSpatialIOPort() );
this.multiPart = constructor.registerTileDefinition( new BlockCableBus() );
this.controller = constructor.registerTileDefinition( new BlockController() );
this.drive = constructor.registerTileDefinition( new BlockDrive() );
this.chest = constructor.registerTileDefinition( new BlockChest() );
this.iface = constructor.registerTileDefinition( new BlockInterface() );
this.cellWorkbench = constructor.registerTileDefinition( new BlockCellWorkbench() );
this.iOPort = constructor.registerTileDefinition( new BlockIOPort() );
this.condenser = constructor.registerTileDefinition( new BlockCondenser() );
this.energyAcceptor = constructor.registerTileDefinition( new BlockEnergyAcceptor() );
this.vibrationChamber = constructor.registerTileDefinition( new BlockVibrationChamber() );
this.quartzGrowthAccelerator = constructor.registerTileDefinition( cga );
this.energyCell = constructor.registerTileDefinition( new BlockEnergyCell() );
this.energyCellDense = constructor.registerTileDefinition( new BlockDenseEnergyCell() );
this.energyCellCreative = constructor.registerTileDefinition( new BlockCreativeEnergyCell() );
this.craftingUnit = constructor.registerTileDefinition( new BlockCraftingUnit() );
this.craftingAccelerator = new WrappedDamageItemDefinition( this.craftingUnit, 1 );
this.craftingStorage1k = constructor.registerTileDefinition( new BlockCraftingStorage() );
this.craftingStorage4k = new WrappedDamageItemDefinition( this.craftingStorage1k, 1 );
this.craftingStorage16k = new WrappedDamageItemDefinition( this.craftingStorage1k, 2 );
this.craftingStorage64k = new WrappedDamageItemDefinition( this.craftingStorage1k, 3 );
this.craftingMonitor = constructor.registerTileDefinition( new BlockCraftingMonitor() );
this.molecularAssembler = constructor.registerTileDefinition( new BlockMolecularAssembler() );
this.lightDetector = constructor.registerTileDefinition( lightDetector );
this.paint = constructor.registerTileDefinition( new BlockPaint() );
this.skyStoneStair = constructor.registerBlockDefinition( new SkyStoneStairBlock( skyStone, 0 ) );
this.skyStoneBlockStair = constructor.registerBlockDefinition( new SkyStoneBlockStairBlock( skyStone, 1 ) );
this.skyStoneBrickStair = constructor.registerBlockDefinition( new SkyStoneBrickStairBlock( skyStone, 2 ) );
this.skyStoneSmallBrickStair = constructor.registerBlockDefinition( new SkyStoneSmallBrickStairBlock( skyStone, 3 ) );
this.fluixStair = constructor.registerBlockDefinition( new FluixStairBlock( fluixBlock ) );
this.quartzStair = constructor.registerBlockDefinition( new QuartzStairBlock( quartzBlock ) );
this.chiseledQuartzStair = constructor.registerBlockDefinition( new ChiseledQuartzStairBlock( chiseldQuartz ) );
this.quartzPillarStair = constructor.registerBlockDefinition( new QuartzPillarStairBlock( quartzPillar ) );
this.itemGen = constructor.registerBlockDefinition( new BlockItemGen() );
this.chunkLoader = constructor.registerBlockDefinition( new BlockChunkloader() );
this.phantomNode = constructor.registerBlockDefinition( new BlockPhantomNode() );
this.cubeGenerator = constructor.registerBlockDefinition( new BlockCubeGenerator() );
}
@Override
public IBlockDefinition quartzOre()
{
return this.quartzOre;
}
@Override
public IBlockDefinition quartzOreCharged()
{
return this.quartzOreCharged;
}
@Override
public IBlockDefinition matrixFrame()
{
return this.matrixFrame;
}
@Override
public IBlockDefinition quartz()
{
return this.quartz;
}
@Override
public IBlockDefinition quartzPillar()
{
return this.quartzPillar;
}
@Override
public IBlockDefinition quartzChiseled()
{
return this.quartzChiseled;
}
@Override
public IBlockDefinition quartzGlass()
{
return this.quartzGlass;
}
@Override
public IBlockDefinition quartzVibrantGlass()
{
return this.quartzVibrantGlass;
}
@Override
public IBlockDefinition quartzTorch()
{
return this.quartzTorch;
}
@Override
public IBlockDefinition fluix()
{
return this.fluix;
}
@Override
public IBlockDefinition skyStone()
{
return this.skyStone;
}
@Override
public IBlockDefinition skyChest()
{
return this.skyChest;
}
@Override
public IBlockDefinition skyCompass()
{
return this.skyCompass;
}
@Override
public IBlockDefinition skyStoneStair()
{
return this.skyStoneStair;
}
@Override
public IBlockDefinition skyStoneBlockStair()
{
return this.skyStoneBlockStair;
}
@Override
public IBlockDefinition skyStoneBrickStair()
{
return this.skyStoneBrickStair;
}
@Override
public IBlockDefinition skyStoneSmallBrickStair()
{
return this.skyStoneSmallBrickStair;
}
@Override
public IBlockDefinition fluixStair()
{
return this.fluixStair;
}
@Override
public IBlockDefinition quartzStair()
{
return this.quartzStair;
}
@Override
public IBlockDefinition chiseledQuartzStair()
{
return this.chiseledQuartzStair;
}
@Override
public IBlockDefinition quartzPillarStair()
{
return this.quartzPillarStair;
}
@Override
public ITileDefinition grindStone()
{
return this.grindStone;
}
@Override
public ITileDefinition crankHandle()
{
return this.crankHandle;
}
@Override
public ITileDefinition inscriber()
{
return this.inscriber;
}
@Override
public ITileDefinition wireless()
{
return this.wireless;
}
@Override
public ITileDefinition charger()
{
return this.charger;
}
@Override
public ITileDefinition tinyTNT()
{
return this.tinyTNT;
}
@Override
public ITileDefinition security()
{
return this.security;
}
@Override
public ITileDefinition quantumRing()
{
return this.quantumRing;
}
@Override
public ITileDefinition quantumLink()
{
return this.quantumLink;
}
@Override
public ITileDefinition spatialPylon()
{
return this.spatialPylon;
}
@Override
public ITileDefinition spatialIOPort()
{
return this.spatialIOPort;
}
@Override
public ITileDefinition multiPart()
{
return this.multiPart;
}
@Override
public ITileDefinition controller()
{
return this.controller;
}
@Override
public ITileDefinition drive()
{
return this.drive;
}
@Override
public ITileDefinition chest()
{
return this.chest;
}
@Override
public ITileDefinition iface()
{
return this.iface;
}
@Override
public ITileDefinition cellWorkbench()
{
return this.cellWorkbench;
}
@Override
public ITileDefinition iOPort()
{
return this.iOPort;
}
@Override
public ITileDefinition condenser()
{
return this.condenser;
}
@Override
public ITileDefinition energyAcceptor()
{
return this.energyAcceptor;
}
@Override
public ITileDefinition vibrationChamber()
{
return this.vibrationChamber;
}
@Override
public ITileDefinition quartzGrowthAccelerator()
{
return this.quartzGrowthAccelerator;
}
@Override
public ITileDefinition energyCell()
{
return this.energyCell;
}
@Override
public ITileDefinition energyCellDense()
{
return this.energyCellDense;
}
@Override
public ITileDefinition energyCellCreative()
{
return this.energyCellCreative;
}
@Override
public ITileDefinition craftingUnit()
{
return this.craftingUnit;
}
@Override
public ITileDefinition craftingAccelerator()
{
return this.craftingAccelerator;
}
@Override
public ITileDefinition craftingStorage1k()
{
return this.craftingStorage1k;
}
@Override
public ITileDefinition craftingStorage4k()
{
return this.craftingStorage4k;
}
@Override
public ITileDefinition craftingStorage16k()
{
return this.craftingStorage16k;
}
@Override
public ITileDefinition craftingStorage64k()
{
return this.craftingStorage64k;
}
@Override
public ITileDefinition craftingMonitor()
{
return this.craftingMonitor;
}
@Override
public ITileDefinition molecularAssembler()
{
return this.molecularAssembler;
}
@Override
public ITileDefinition lightDetector()
{
return this.lightDetector;
}
@Override
public ITileDefinition paint()
{
return this.paint;
}
public IBlockDefinition chunkLoader()
{
return this.chunkLoader;
}
public IBlockDefinition itemGen()
{
return this.itemGen;
}
public IBlockDefinition phantomNode()
{
return this.phantomNode;
}
public IBlockDefinition cubeGenerator()
{
return this.cubeGenerator;
}
public Set<IOrientableBlock> orientables()
{
return this.orientables;
}
}
@@ -0,0 +1,418 @@
/*
* This file is part of Applied Energistics 2.
* Copyright (c) 2013 - 2015, AlgorithmX2, All rights reserved.
*
* Applied Energistics 2 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.
*
* Applied Energistics 2 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 Applied Energistics 2. If not, see <http://www.gnu.org/licenses/lgpl>.
*/
package appeng.core.api.definitions;
import appeng.api.definitions.IItemDefinition;
import appeng.api.definitions.IItems;
import appeng.api.util.AEColoredItemDefinition;
import appeng.core.features.AEFeature;
import appeng.debug.ToolDebugCard;
import appeng.debug.ToolEraser;
import appeng.debug.ToolMeteoritePlacer;
import appeng.debug.ToolReplicatorCard;
import appeng.items.materials.MaterialType;
import appeng.items.misc.ItemCrystalSeed;
import appeng.items.misc.ItemEncodedPattern;
import appeng.items.misc.ItemPaintBall;
import appeng.items.parts.ItemFacade;
import appeng.items.storage.ItemBasicStorageCell;
import appeng.items.storage.ItemCreativeStorageCell;
import appeng.items.storage.ItemSpatialStorageCell;
import appeng.items.storage.ItemViewCell;
import appeng.items.tools.ToolBiometricCard;
import appeng.items.tools.ToolMemoryCard;
import appeng.items.tools.ToolNetworkTool;
import appeng.items.tools.powered.ToolChargedStaff;
import appeng.items.tools.powered.ToolColorApplicator;
import appeng.items.tools.powered.ToolEntropyManipulator;
import appeng.items.tools.powered.ToolMassCannon;
import appeng.items.tools.powered.ToolPortableCell;
import appeng.items.tools.powered.ToolWirelessTerminal;
import appeng.items.tools.quartz.ToolQuartzAxe;
import appeng.items.tools.quartz.ToolQuartzCuttingKnife;
import appeng.items.tools.quartz.ToolQuartzHoe;
import appeng.items.tools.quartz.ToolQuartzPickaxe;
import appeng.items.tools.quartz.ToolQuartzSpade;
import appeng.items.tools.quartz.ToolQuartzSword;
import appeng.items.tools.quartz.ToolQuartzWrench;
/**
* Internal implementation for the API items
*/
public final class ApiItems implements IItems
{
private final IItemDefinition certusQuartzAxe;
private final IItemDefinition certusQuartzHoe;
private final IItemDefinition certusQuartzShovel;
private final IItemDefinition certusQuartzPick;
private final IItemDefinition certusQuartzSword;
private final IItemDefinition certusQuartzWrench;
private final IItemDefinition certusQuartzKnife;
private final IItemDefinition netherQuartzAxe;
private final IItemDefinition netherQuartzHoe;
private final IItemDefinition netherQuartzShovel;
private final IItemDefinition netherQuartzPick;
private final IItemDefinition netherQuartzSword;
private final IItemDefinition netherQuartzWrench;
private final IItemDefinition netherQuartzKnife;
private final IItemDefinition entropyManipulator;
private final IItemDefinition wirelessTerminal;
private final IItemDefinition biometricCard;
private final IItemDefinition chargedStaff;
private final IItemDefinition massCannon;
private final IItemDefinition memoryCard;
private final IItemDefinition networkTool;
private final IItemDefinition portableCell;
private final IItemDefinition cellCreative;
private final IItemDefinition viewCell;
private final IItemDefinition cell1k;
private final IItemDefinition cell4k;
private final IItemDefinition cell16k;
private final IItemDefinition cell64k;
private final IItemDefinition spatialCell2;
private final IItemDefinition spatialCell16;
private final IItemDefinition spatialCell128;
private final IItemDefinition facade;
private final IItemDefinition crystalSeed;
// rv1
private final IItemDefinition encodedPattern;
private final IItemDefinition colorApplicator;
private final IItemDefinition paintBall;
private final AEColoredItemDefinition coloredPaintBall;
private final AEColoredItemDefinition coloredLumenPaintBall;
// unsupported dev tools
private final IItemDefinition toolEraser;
private final IItemDefinition toolMeteoritePlacer;
private final IItemDefinition toolDebugCard;
private final IItemDefinition toolReplicatorCard;
public ApiItems( DefinitionConstructor constructor )
{
this.certusQuartzAxe = constructor.registerItemDefinition( new ToolQuartzAxe( AEFeature.CertusQuartzTools ) );
this.certusQuartzHoe = constructor.registerItemDefinition( new ToolQuartzHoe( AEFeature.CertusQuartzTools ) );
this.certusQuartzShovel = constructor.registerItemDefinition( new ToolQuartzSpade( AEFeature.CertusQuartzTools ) );
this.certusQuartzPick = constructor.registerItemDefinition( new ToolQuartzPickaxe( AEFeature.CertusQuartzTools ) );
this.certusQuartzSword = constructor.registerItemDefinition( new ToolQuartzSword( AEFeature.CertusQuartzTools ) );
this.certusQuartzWrench = constructor.registerItemDefinition( new ToolQuartzWrench( AEFeature.CertusQuartzTools ) );
this.certusQuartzKnife = constructor.registerItemDefinition( new ToolQuartzCuttingKnife( AEFeature.CertusQuartzTools ) );
this.netherQuartzAxe = constructor.registerItemDefinition( new ToolQuartzAxe( AEFeature.NetherQuartzTools ) );
this.netherQuartzHoe = constructor.registerItemDefinition( new ToolQuartzHoe( AEFeature.NetherQuartzTools ) );
this.netherQuartzShovel = constructor.registerItemDefinition( new ToolQuartzSpade( AEFeature.NetherQuartzTools ) );
this.netherQuartzPick = constructor.registerItemDefinition( new ToolQuartzPickaxe( AEFeature.NetherQuartzTools ) );
this.netherQuartzSword = constructor.registerItemDefinition( new ToolQuartzSword( AEFeature.NetherQuartzTools ) );
this.netherQuartzWrench = constructor.registerItemDefinition( new ToolQuartzWrench( AEFeature.NetherQuartzTools ) );
this.netherQuartzKnife = constructor.registerItemDefinition( new ToolQuartzCuttingKnife( AEFeature.NetherQuartzTools ) );
this.entropyManipulator = constructor.registerItemDefinition( new ToolEntropyManipulator() );
this.wirelessTerminal = constructor.registerItemDefinition( new ToolWirelessTerminal() );
this.biometricCard = constructor.registerItemDefinition( new ToolBiometricCard() );
this.chargedStaff = constructor.registerItemDefinition( new ToolChargedStaff() );
this.massCannon = constructor.registerItemDefinition( new ToolMassCannon() );
this.memoryCard = constructor.registerItemDefinition( new ToolMemoryCard() );
this.networkTool = constructor.registerItemDefinition( new ToolNetworkTool() );
this.portableCell = constructor.registerItemDefinition( new ToolPortableCell() );
this.cellCreative = constructor.registerItemDefinition( new ItemCreativeStorageCell() );
this.viewCell = constructor.registerItemDefinition( new ItemViewCell() );
this.cell1k = constructor.registerItemDefinition( new ItemBasicStorageCell( MaterialType.Cell1kPart, 1 ) );
this.cell4k = constructor.registerItemDefinition( new ItemBasicStorageCell( MaterialType.Cell4kPart, 4 ) );
this.cell16k = constructor.registerItemDefinition( new ItemBasicStorageCell( MaterialType.Cell16kPart, 16 ) );
this.cell64k = constructor.registerItemDefinition( new ItemBasicStorageCell( MaterialType.Cell64kPart, 64 ) );
this.spatialCell2 = constructor.registerItemDefinition( new ItemSpatialStorageCell( 2 ) );
this.spatialCell16 = constructor.registerItemDefinition( new ItemSpatialStorageCell( 16 ) );
this.spatialCell128 = constructor.registerItemDefinition( new ItemSpatialStorageCell( 128 ) );
this.facade = constructor.registerItemDefinition( new ItemFacade() );
this.crystalSeed = constructor.registerItemDefinition( new ItemCrystalSeed() );
// rv1
this.encodedPattern = constructor.registerItemDefinition( new ItemEncodedPattern() );
this.colorApplicator = constructor.registerItemDefinition( new ToolColorApplicator() );
this.paintBall = constructor.registerItemDefinition( new ItemPaintBall() );
this.coloredPaintBall = constructor.constructColoredDefinition( this.paintBall, 0 );
this.coloredLumenPaintBall = constructor.constructColoredDefinition( this.paintBall, 20 );
this.toolEraser = constructor.registerItemDefinition( new ToolEraser() );
this.toolMeteoritePlacer = constructor.registerItemDefinition( new ToolMeteoritePlacer() );
this.toolDebugCard = constructor.registerItemDefinition( new ToolDebugCard() );
this.toolReplicatorCard = constructor.registerItemDefinition( new ToolReplicatorCard() );
}
@Override
public IItemDefinition certusQuartzAxe()
{
return this.certusQuartzAxe;
}
@Override
public IItemDefinition certusQuartzHoe()
{
return this.certusQuartzHoe;
}
@Override
public IItemDefinition certusQuartzShovel()
{
return this.certusQuartzShovel;
}
@Override
public IItemDefinition certusQuartzPick()
{
return this.certusQuartzPick;
}
@Override
public IItemDefinition certusQuartzSword()
{
return this.certusQuartzSword;
}
@Override
public IItemDefinition certusQuartzWrench()
{
return this.certusQuartzWrench;
}
@Override
public IItemDefinition certusQuartzKnife()
{
return this.certusQuartzKnife;
}
@Override
public IItemDefinition netherQuartzAxe()
{
return this.netherQuartzAxe;
}
@Override
public IItemDefinition netherQuartzHoe()
{
return this.netherQuartzHoe;
}
@Override
public IItemDefinition netherQuartzShovel()
{
return this.netherQuartzShovel;
}
@Override
public IItemDefinition netherQuartzPick()
{
return this.netherQuartzPick;
}
@Override
public IItemDefinition netherQuartzSword()
{
return this.netherQuartzSword;
}
@Override
public IItemDefinition netherQuartzWrench()
{
return this.netherQuartzWrench;
}
@Override
public IItemDefinition netherQuartzKnife()
{
return this.netherQuartzKnife;
}
@Override
public IItemDefinition entropyManipulator()
{
return this.entropyManipulator;
}
@Override
public IItemDefinition wirelessTerminal()
{
return this.wirelessTerminal;
}
@Override
public IItemDefinition biometricCard()
{
return this.biometricCard;
}
@Override
public IItemDefinition chargedStaff()
{
return this.memoryCard;
}
@Override
public IItemDefinition massCannon()
{
return this.massCannon;
}
@Override
public IItemDefinition memoryCard()
{
return this.memoryCard;
}
@Override
public IItemDefinition networkTool()
{
return this.networkTool;
}
@Override
public IItemDefinition portableCell()
{
return this.portableCell;
}
@Override
public IItemDefinition cellCreative()
{
return this.cellCreative;
}
@Override
public IItemDefinition viewCell()
{
return this.viewCell;
}
@Override
public IItemDefinition cell1k()
{
return this.cell1k;
}
@Override
public IItemDefinition cell4k()
{
return this.cell4k;
}
@Override
public IItemDefinition cell16k()
{
return this.cell16k;
}
@Override
public IItemDefinition cell64k()
{
return this.cell64k;
}
@Override
public IItemDefinition spatialCell2()
{
return this.spatialCell2;
}
@Override
public IItemDefinition spatialCell16()
{
return this.spatialCell16;
}
@Override
public IItemDefinition spatialCell128()
{
return this.spatialCell128;
}
@Override
public IItemDefinition facade()
{
return this.facade;
}
@Override
public IItemDefinition crystalSeed()
{
return this.crystalSeed;
}
@Override
public IItemDefinition encodedPattern()
{
return this.encodedPattern;
}
@Override
public IItemDefinition colorApplicator()
{
return this.colorApplicator;
}
@Override
public AEColoredItemDefinition coloredPaintBall()
{
return this.coloredPaintBall;
}
@Override
public AEColoredItemDefinition coloredLumenPaintBall()
{
return this.coloredLumenPaintBall;
}
public IItemDefinition paintBall()
{
return this.paintBall;
}
public IItemDefinition toolEraser()
{
return this.toolEraser;
}
public IItemDefinition toolMeteoritePlacer()
{
return this.toolMeteoritePlacer;
}
public IItemDefinition toolDebugCard()
{
return this.toolDebugCard;
}
public IItemDefinition toolReplicatorCard()
{
return this.toolReplicatorCard;
}
}
@@ -0,0 +1,507 @@
/*
* This file is part of Applied Energistics 2.
* Copyright (c) 2013 - 2015, AlgorithmX2, All rights reserved.
*
* Applied Energistics 2 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.
*
* Applied Energistics 2 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 Applied Energistics 2. If not, see <http://www.gnu.org/licenses/lgpl>.
*/
package appeng.core.api.definitions;
import appeng.api.definitions.IItemDefinition;
import appeng.api.definitions.IMaterials;
import appeng.core.features.DamagedItemDefinition;
import appeng.items.materials.ItemMultiMaterial;
import appeng.items.materials.MaterialType;
/**
* Internal implementation for the API materials
*/
public final class ApiMaterials implements IMaterials
{
private final IItemDefinition cell2SpatialPart;
private final IItemDefinition cell16SpatialPart;
private final IItemDefinition cell128SpatialPart;
private final IItemDefinition silicon;
private final IItemDefinition skyDust;
private final IItemDefinition calcProcessorPress;
private final IItemDefinition engProcessorPress;
private final IItemDefinition logicProcessorPress;
private final IItemDefinition calcProcessorPrint;
private final IItemDefinition engProcessorPrint;
private final IItemDefinition logicProcessorPrint;
private final IItemDefinition siliconPress;
private final IItemDefinition siliconPrint;
private final IItemDefinition namePress;
private final IItemDefinition logicProcessor;
private final IItemDefinition calcProcessor;
private final IItemDefinition engProcessor;
private final IItemDefinition basicCard;
private final IItemDefinition advCard;
private final IItemDefinition purifiedCertusQuartzCrystal;
private final IItemDefinition purifiedNetherQuartzCrystal;
private final IItemDefinition purifiedFluixCrystal;
private final IItemDefinition cell1kPart;
private final IItemDefinition cell4kPart;
private final IItemDefinition cell16kPart;
private final IItemDefinition cell64kPart;
private final IItemDefinition emptyStorageCell;
private final IItemDefinition cardRedstone;
private final IItemDefinition cardSpeed;
private final IItemDefinition cardCapacity;
private final IItemDefinition cardFuzzy;
private final IItemDefinition cardInverter;
private final IItemDefinition cardCrafting;
private final IItemDefinition enderDust;
private final IItemDefinition flour;
private final IItemDefinition goldDust;
private final IItemDefinition ironDust;
private final IItemDefinition fluixDust;
private final IItemDefinition certusQuartzDust;
private final IItemDefinition netherQuartzDust;
private final IItemDefinition matterBall;
private final IItemDefinition ironNugget;
private final IItemDefinition certusQuartzCrystal;
private final IItemDefinition certusQuartzCrystalCharged;
private final IItemDefinition fluixCrystal;
private final IItemDefinition fluixPearl;
private final IItemDefinition woodenGear;
private final IItemDefinition wireless;
private final IItemDefinition wirelessBooster;
private final IItemDefinition annihilationCore;
private final IItemDefinition formationCore;
private final IItemDefinition singularity;
private final IItemDefinition qESingularity;
private final IItemDefinition blankPattern;
public ApiMaterials( DefinitionConstructor constructor )
{
final ItemMultiMaterial itemMultiMaterial = new ItemMultiMaterial();
constructor.registerItemDefinition( itemMultiMaterial );
this.cell2SpatialPart = new DamagedItemDefinition( itemMultiMaterial.createMaterial( MaterialType.Cell2SpatialPart ) );
this.cell16SpatialPart = new DamagedItemDefinition( itemMultiMaterial.createMaterial( MaterialType.Cell16SpatialPart ) );
this.cell128SpatialPart = new DamagedItemDefinition( itemMultiMaterial.createMaterial( MaterialType.Cell128SpatialPart ) );
this.silicon = new DamagedItemDefinition( itemMultiMaterial.createMaterial( MaterialType.Silicon ) );
this.skyDust = new DamagedItemDefinition( itemMultiMaterial.createMaterial( MaterialType.SkyDust ) );
this.calcProcessorPress = new DamagedItemDefinition( itemMultiMaterial.createMaterial( MaterialType.CalcProcessorPress ) );
this.engProcessorPress = new DamagedItemDefinition( itemMultiMaterial.createMaterial( MaterialType.EngProcessorPress ) );
this.logicProcessorPress = new DamagedItemDefinition( itemMultiMaterial.createMaterial( MaterialType.LogicProcessorPress ) );
this.calcProcessorPrint = new DamagedItemDefinition( itemMultiMaterial.createMaterial( MaterialType.CalcProcessorPrint ) );
this.engProcessorPrint = new DamagedItemDefinition( itemMultiMaterial.createMaterial( MaterialType.EngProcessorPrint ) );
this.logicProcessorPrint = new DamagedItemDefinition( itemMultiMaterial.createMaterial( MaterialType.LogicProcessorPrint ) );
this.siliconPress = new DamagedItemDefinition( itemMultiMaterial.createMaterial( MaterialType.SiliconPress ) );
this.siliconPrint = new DamagedItemDefinition( itemMultiMaterial.createMaterial( MaterialType.SiliconPrint ) );
this.namePress = new DamagedItemDefinition( itemMultiMaterial.createMaterial( MaterialType.NamePress ) );
this.logicProcessor = new DamagedItemDefinition( itemMultiMaterial.createMaterial( MaterialType.LogicProcessor ) );
this.calcProcessor = new DamagedItemDefinition( itemMultiMaterial.createMaterial( MaterialType.CalcProcessor ) );
this.engProcessor = new DamagedItemDefinition( itemMultiMaterial.createMaterial( MaterialType.EngProcessor ) );
this.basicCard = new DamagedItemDefinition( itemMultiMaterial.createMaterial( MaterialType.BasicCard ) );
this.advCard = new DamagedItemDefinition( itemMultiMaterial.createMaterial( MaterialType.AdvCard ) );
this.purifiedCertusQuartzCrystal = new DamagedItemDefinition( itemMultiMaterial.createMaterial( MaterialType.PurifiedCertusQuartzCrystal ) );
this.purifiedNetherQuartzCrystal = new DamagedItemDefinition( itemMultiMaterial.createMaterial( MaterialType.PurifiedNetherQuartzCrystal ) );
this.purifiedFluixCrystal = new DamagedItemDefinition( itemMultiMaterial.createMaterial( MaterialType.PurifiedFluixCrystal ) );
this.cell1kPart = new DamagedItemDefinition( itemMultiMaterial.createMaterial( MaterialType.Cell1kPart ) );
this.cell4kPart = new DamagedItemDefinition( itemMultiMaterial.createMaterial( MaterialType.Cell4kPart ) );
this.cell16kPart = new DamagedItemDefinition( itemMultiMaterial.createMaterial( MaterialType.Cell16kPart ) );
this.cell64kPart = new DamagedItemDefinition( itemMultiMaterial.createMaterial( MaterialType.Cell64kPart ) );
this.emptyStorageCell = new DamagedItemDefinition( itemMultiMaterial.createMaterial( MaterialType.EmptyStorageCell ) );
this.cardRedstone = new DamagedItemDefinition( itemMultiMaterial.createMaterial( MaterialType.CardRedstone ) );
this.cardSpeed = new DamagedItemDefinition( itemMultiMaterial.createMaterial( MaterialType.CardSpeed ) );
this.cardCapacity = new DamagedItemDefinition( itemMultiMaterial.createMaterial( MaterialType.CardCapacity ) );
this.cardFuzzy = new DamagedItemDefinition( itemMultiMaterial.createMaterial( MaterialType.CardFuzzy ) );
this.cardInverter = new DamagedItemDefinition( itemMultiMaterial.createMaterial( MaterialType.CardInverter ) );
this.cardCrafting = new DamagedItemDefinition( itemMultiMaterial.createMaterial( MaterialType.CardCrafting ) );
this.enderDust = new DamagedItemDefinition( itemMultiMaterial.createMaterial( MaterialType.EnderDust ) );
this.flour = new DamagedItemDefinition( itemMultiMaterial.createMaterial( MaterialType.Flour ) );
this.goldDust = new DamagedItemDefinition( itemMultiMaterial.createMaterial( MaterialType.GoldDust ) );
this.ironDust = new DamagedItemDefinition( itemMultiMaterial.createMaterial( MaterialType.IronDust ) );
this.fluixDust = new DamagedItemDefinition( itemMultiMaterial.createMaterial( MaterialType.FluixDust ) );
this.certusQuartzDust = new DamagedItemDefinition( itemMultiMaterial.createMaterial( MaterialType.CertusQuartzDust ) );
this.netherQuartzDust = new DamagedItemDefinition( itemMultiMaterial.createMaterial( MaterialType.NetherQuartzDust ) );
this.matterBall = new DamagedItemDefinition( itemMultiMaterial.createMaterial( MaterialType.MatterBall ) );
this.ironNugget = new DamagedItemDefinition( itemMultiMaterial.createMaterial( MaterialType.IronNugget ) );
this.certusQuartzCrystal = new DamagedItemDefinition( itemMultiMaterial.createMaterial( MaterialType.CertusQuartzCrystal ) );
this.certusQuartzCrystalCharged = new DamagedItemDefinition( itemMultiMaterial.createMaterial( MaterialType.CertusQuartzCrystalCharged ) );
this.fluixCrystal = new DamagedItemDefinition( itemMultiMaterial.createMaterial( MaterialType.FluixCrystal ) );
this.fluixPearl = new DamagedItemDefinition( itemMultiMaterial.createMaterial( MaterialType.FluixPearl ) );
this.woodenGear = new DamagedItemDefinition( itemMultiMaterial.createMaterial( MaterialType.WoodenGear ) );
this.wireless = new DamagedItemDefinition( itemMultiMaterial.createMaterial( MaterialType.Wireless ) );
this.wirelessBooster = new DamagedItemDefinition( itemMultiMaterial.createMaterial( MaterialType.WirelessBooster ) );
this.annihilationCore = new DamagedItemDefinition( itemMultiMaterial.createMaterial( MaterialType.AnnihilationCore ) );
this.formationCore = new DamagedItemDefinition( itemMultiMaterial.createMaterial( MaterialType.FormationCore ) );
this.singularity = new DamagedItemDefinition( itemMultiMaterial.createMaterial( MaterialType.Singularity ) );
this.qESingularity = new DamagedItemDefinition( itemMultiMaterial.createMaterial( MaterialType.QESingularity ) );
this.blankPattern = new DamagedItemDefinition( itemMultiMaterial.createMaterial( MaterialType.BlankPattern ) );
}
@Override
public IItemDefinition cell2SpatialPart()
{
return this.cell2SpatialPart;
}
@Override
public IItemDefinition cell16SpatialPart()
{
return this.cell16SpatialPart;
}
@Override
public IItemDefinition cell128SpatialPart()
{
return this.cell128SpatialPart;
}
@Override
public IItemDefinition silicon()
{
return this.silicon;
}
@Override
public IItemDefinition skyDust()
{
return this.skyDust;
}
@Override
public IItemDefinition calcProcessorPress()
{
return this.calcProcessorPress;
}
@Override
public IItemDefinition engProcessorPress()
{
return this.engProcessorPress;
}
@Override
public IItemDefinition logicProcessorPress()
{
return this.logicProcessorPress;
}
@Override
public IItemDefinition calcProcessorPrint()
{
return this.calcProcessorPrint;
}
@Override
public IItemDefinition engProcessorPrint()
{
return this.engProcessorPrint;
}
@Override
public IItemDefinition logicProcessorPrint()
{
return this.logicProcessorPrint;
}
@Override
public IItemDefinition siliconPress()
{
return this.siliconPress;
}
@Override
public IItemDefinition siliconPrint()
{
return this.siliconPrint;
}
@Override
public IItemDefinition namePress()
{
return this.namePress;
}
@Override
public IItemDefinition logicProcessor()
{
return this.logicProcessor;
}
@Override
public IItemDefinition calcProcessor()
{
return this.calcProcessor;
}
@Override
public IItemDefinition engProcessor()
{
return this.engProcessor;
}
@Override
public IItemDefinition basicCard()
{
return this.basicCard;
}
@Override
public IItemDefinition advCard()
{
return this.advCard;
}
@Override
public IItemDefinition purifiedCertusQuartzCrystal()
{
return this.purifiedCertusQuartzCrystal;
}
@Override
public IItemDefinition purifiedNetherQuartzCrystal()
{
return this.purifiedNetherQuartzCrystal;
}
@Override
public IItemDefinition purifiedFluixCrystal()
{
return this.purifiedFluixCrystal;
}
@Override
public IItemDefinition cell1kPart()
{
return this.cell1kPart;
}
@Override
public IItemDefinition cell4kPart()
{
return this.cell4kPart;
}
@Override
public IItemDefinition cell16kPart()
{
return this.cell16kPart;
}
@Override
public IItemDefinition cell64kPart()
{
return this.cell64kPart;
}
@Override
public IItemDefinition emptyStorageCell()
{
return this.emptyStorageCell;
}
@Override
public IItemDefinition cardRedstone()
{
return this.cardRedstone;
}
@Override
public IItemDefinition cardSpeed()
{
return this.cardSpeed;
}
@Override
public IItemDefinition cardCapacity()
{
return this.cardCapacity;
}
@Override
public IItemDefinition cardFuzzy()
{
return this.cardFuzzy;
}
@Override
public IItemDefinition cardInverter()
{
return this.cardInverter;
}
@Override
public IItemDefinition cardCrafting()
{
return this.cardCrafting;
}
@Override
public IItemDefinition enderDust()
{
return this.enderDust;
}
@Override
public IItemDefinition flour()
{
return this.flour;
}
@Override
public IItemDefinition goldDust()
{
return this.goldDust;
}
@Override
public IItemDefinition ironDust()
{
return this.ironDust;
}
@Override
public IItemDefinition fluixDust()
{
return this.fluixDust;
}
@Override
public IItemDefinition certusQuartzDust()
{
return this.certusQuartzDust;
}
@Override
public IItemDefinition netherQuartzDust()
{
return this.netherQuartzDust;
}
@Override
public IItemDefinition matterBall()
{
return this.matterBall;
}
@Override
public IItemDefinition ironNugget()
{
return this.ironNugget;
}
@Override
public IItemDefinition certusQuartzCrystal()
{
return this.certusQuartzCrystal;
}
@Override
public IItemDefinition certusQuartzCrystalCharged()
{
return this.certusQuartzCrystalCharged;
}
@Override
public IItemDefinition fluixCrystal()
{
return this.fluixCrystal;
}
@Override
public IItemDefinition fluixPearl()
{
return this.fluixPearl;
}
@Override
public IItemDefinition woodenGear()
{
return this.woodenGear;
}
@Override
public IItemDefinition wireless()
{
return this.wireless;
}
@Override
public IItemDefinition wirelessBooster()
{
return this.wirelessBooster;
}
@Override
public IItemDefinition annihilationCore()
{
return this.annihilationCore;
}
@Override
public IItemDefinition formationCore()
{
return this.formationCore;
}
@Override
public IItemDefinition singularity()
{
return this.singularity;
}
@Override
public IItemDefinition qESingularity()
{
return this.qESingularity;
}
@Override
public IItemDefinition blankPattern()
{
return this.blankPattern;
}
}
@@ -0,0 +1,328 @@
/*
* This file is part of Applied Energistics 2.
* Copyright (c) 2013 - 2015, AlgorithmX2, All rights reserved.
*
* Applied Energistics 2 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.
*
* Applied Energistics 2 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 Applied Energistics 2. If not, see <http://www.gnu.org/licenses/lgpl>.
*/
package appeng.core.api.definitions;
import appeng.api.definitions.IItemDefinition;
import appeng.api.definitions.IParts;
import appeng.api.exceptions.MissingDefinition;
import appeng.api.parts.IPartHelper;
import appeng.api.util.AEColoredItemDefinition;
import appeng.core.features.DamagedItemDefinition;
import appeng.items.parts.ItemMultiPart;
import appeng.items.parts.PartType;
/**
* Internal implementation for the API parts
*/
public final class ApiParts implements IParts
{
private final AEColoredItemDefinition cableSmart;
private final AEColoredItemDefinition cableCovered;
private final AEColoredItemDefinition cableGlass;
private final AEColoredItemDefinition cableDense;
// private final AEColoredItemDefinition lumenCableSmart;
// private final AEColoredItemDefinition lumenCableCovered;
// private final AEColoredItemDefinition lumenCableGlass;
// private final AEColoredItemDefinition lumenCableDense;
private final IItemDefinition quartzFiber;
private final IItemDefinition toggleBus;
private final IItemDefinition invertedToggleBus;
private final IItemDefinition storageBus;
private final IItemDefinition importBus;
private final IItemDefinition exportBus;
private final IItemDefinition iface;
private final IItemDefinition levelEmitter;
private final IItemDefinition annihilationPlane;
private final IItemDefinition formationPlane;
private final IItemDefinition p2PTunnelME;
private final IItemDefinition p2PTunnelRedstone;
private final IItemDefinition p2PTunnelItems;
private final IItemDefinition p2PTunnelLiquids;
private final IItemDefinition p2PTunnelEU;
private final IItemDefinition p2PTunnelRF;
private final IItemDefinition p2PTunnelLight;
private final IItemDefinition cableAnchor;
private final IItemDefinition monitor;
private final IItemDefinition semiDarkMonitor;
private final IItemDefinition darkMonitor;
private final IItemDefinition interfaceTerminal;
private final IItemDefinition patternTerminal;
private final IItemDefinition craftingTerminal;
private final IItemDefinition terminal;
private final IItemDefinition storageMonitor;
private final IItemDefinition conversionMonitor;
public ApiParts( DefinitionConstructor constructor, IPartHelper partHelper )
{
final ItemMultiPart itemMultiPart = new ItemMultiPart( partHelper );
constructor.registerItemDefinition( itemMultiPart );
this.cableSmart = constructor.constructColoredDefinition( itemMultiPart, PartType.CableSmart );
this.cableCovered = constructor.constructColoredDefinition( itemMultiPart, PartType.CableCovered );
this.cableGlass = constructor.constructColoredDefinition( itemMultiPart, PartType.CableGlass );
this.cableDense = constructor.constructColoredDefinition( itemMultiPart, PartType.CableDense );
// this.lumenCableSmart = Optional.absent(); // has yet to be implemented, no PartType defined for it yet
// this.lumenCableCovered = Optional.absent(); // has yet to be implemented, no PartType defined for it yet
// this.lumenCableGlass = Optional.absent(); // has yet to be implemented, no PartType defined for it yet
// this.lumenCableDense = Optional.absent(); // has yet to be implemented, no PartType defined for it yet
this.quartzFiber = new DamagedItemDefinition( itemMultiPart.createPart( PartType.QuartzFiber ) );
this.toggleBus = new DamagedItemDefinition( itemMultiPart.createPart( PartType.ToggleBus ) );
this.invertedToggleBus = new DamagedItemDefinition( itemMultiPart.createPart( PartType.InvertedToggleBus ) );
this.storageBus = new DamagedItemDefinition( itemMultiPart.createPart( PartType.StorageBus ) );
this.importBus = new DamagedItemDefinition( itemMultiPart.createPart( PartType.ImportBus ) );
this.exportBus = new DamagedItemDefinition( itemMultiPart.createPart( PartType.ExportBus ) );
this.iface = new DamagedItemDefinition( itemMultiPart.createPart( PartType.Interface ) );
this.levelEmitter = new DamagedItemDefinition( itemMultiPart.createPart( PartType.LevelEmitter ) );
this.annihilationPlane = new DamagedItemDefinition( itemMultiPart.createPart( PartType.AnnihilationPlane ) );
this.formationPlane = new DamagedItemDefinition( itemMultiPart.createPart( PartType.FormationPlane ) );
this.p2PTunnelME = new DamagedItemDefinition( itemMultiPart.createPart( PartType.P2PTunnelME ) );
this.p2PTunnelRedstone = new DamagedItemDefinition( itemMultiPart.createPart( PartType.P2PTunnelRedstone ) );
this.p2PTunnelItems = new DamagedItemDefinition( itemMultiPart.createPart( PartType.P2PTunnelItems ) );
this.p2PTunnelLiquids = new DamagedItemDefinition( itemMultiPart.createPart( PartType.P2PTunnelLiquids ) );
this.p2PTunnelEU = new DamagedItemDefinition( itemMultiPart.createPart( PartType.P2PTunnelEU ) );
this.p2PTunnelRF = new DamagedItemDefinition( itemMultiPart.createPart( PartType.P2PTunnelRF ) );
this.p2PTunnelLight = new DamagedItemDefinition( itemMultiPart.createPart( PartType.P2PTunnelLight ) );
this.cableAnchor = new DamagedItemDefinition( itemMultiPart.createPart( PartType.CableAnchor ) );
this.monitor = new DamagedItemDefinition( itemMultiPart.createPart( PartType.Monitor ) );
this.semiDarkMonitor = new DamagedItemDefinition( itemMultiPart.createPart( PartType.SemiDarkMonitor ) );
this.darkMonitor = new DamagedItemDefinition( itemMultiPart.createPart( PartType.DarkMonitor ) );
this.interfaceTerminal = new DamagedItemDefinition( itemMultiPart.createPart( PartType.InterfaceTerminal ) );
this.patternTerminal = new DamagedItemDefinition( itemMultiPart.createPart( PartType.PatternTerminal ) );
this.craftingTerminal = new DamagedItemDefinition( itemMultiPart.createPart( PartType.CraftingTerminal ) );
this.terminal = new DamagedItemDefinition( itemMultiPart.createPart( PartType.Terminal ) );
this.storageMonitor = new DamagedItemDefinition( itemMultiPart.createPart( PartType.StorageMonitor ) );
this.conversionMonitor = new DamagedItemDefinition( itemMultiPart.createPart( PartType.ConversionMonitor ) );
}
@Override
public AEColoredItemDefinition cableSmart()
{
return this.cableSmart;
}
@Override
public AEColoredItemDefinition cableCovered()
{
return this.cableCovered;
}
@Override
public AEColoredItemDefinition cableGlass()
{
return this.cableGlass;
}
@Override
public AEColoredItemDefinition cableDense()
{
return this.cableDense;
}
@Override
public AEColoredItemDefinition lumenCableSmart()
{
throw new MissingDefinition( "Lumen Smart Cable has yet to be implemented." );
// return this.lumenCableSmart;
}
@Override
public AEColoredItemDefinition lumenCableCovered()
{
throw new MissingDefinition( "Lumen Covered Cable has yet to be implemented." );
// return this.lumenCableCovered;
}
@Override
public AEColoredItemDefinition lumenCableGlass()
{
throw new MissingDefinition( "Lumen Glass Cable has yet to be implemented." );
// return this.lumenCableGlass;
}
@Override
public AEColoredItemDefinition lumenCableDense()
{
throw new MissingDefinition( "Lumen Dense Cable has yet to be implemented." );
// return this.lumenCableDense;
}
@Override
public IItemDefinition quartzFiber()
{
return this.quartzFiber;
}
@Override
public IItemDefinition toggleBus()
{
return this.toggleBus;
}
@Override
public IItemDefinition invertedToggleBus()
{
return this.invertedToggleBus;
}
@Override
public IItemDefinition storageBus()
{
return this.storageBus;
}
@Override
public IItemDefinition importBus()
{
return this.importBus;
}
@Override
public IItemDefinition exportBus()
{
return this.exportBus;
}
@Override
public IItemDefinition iface()
{
return this.iface;
}
@Override
public IItemDefinition levelEmitter()
{
return this.levelEmitter;
}
@Override
public IItemDefinition annihilationPlane()
{
return this.annihilationPlane;
}
@Override
public IItemDefinition formationPlane()
{
return this.formationPlane;
}
@Override
public IItemDefinition p2PTunnelME()
{
return this.p2PTunnelME;
}
@Override
public IItemDefinition p2PTunnelRedstone()
{
return this.p2PTunnelRedstone;
}
@Override
public IItemDefinition p2PTunnelItems()
{
return this.p2PTunnelItems;
}
@Override
public IItemDefinition p2PTunnelLiquids()
{
return this.p2PTunnelLiquids;
}
@Override
public IItemDefinition p2PTunnelEU()
{
return this.p2PTunnelEU;
}
@Override
public IItemDefinition p2PTunnelRF()
{
return this.p2PTunnelRF;
}
@Override
public IItemDefinition p2PTunnelLight()
{
return this.p2PTunnelLight;
}
@Override
public IItemDefinition cableAnchor()
{
return this.cableAnchor;
}
@Override
public IItemDefinition monitor()
{
return this.monitor;
}
@Override
public IItemDefinition semiDarkMonitor()
{
return this.semiDarkMonitor;
}
@Override
public IItemDefinition darkMonitor()
{
return this.darkMonitor;
}
@Override
public IItemDefinition interfaceTerminal()
{
return this.interfaceTerminal;
}
@Override
public IItemDefinition patternTerminal()
{
return this.patternTerminal;
}
@Override
public IItemDefinition craftingTerminal()
{
return this.craftingTerminal;
}
@Override
public IItemDefinition terminal()
{
return this.terminal;
}
@Override
public IItemDefinition storageMonitor()
{
return this.storageMonitor;
}
@Override
public IItemDefinition conversionMonitor()
{
return this.conversionMonitor;
}
}
@@ -0,0 +1,105 @@
package appeng.core.api.definitions;
import net.minecraft.item.Item;
import com.google.common.base.Optional;
import appeng.api.definitions.IBlockDefinition;
import appeng.api.definitions.IItemDefinition;
import appeng.api.definitions.ITileDefinition;
import appeng.api.util.AEColor;
import appeng.api.util.AEColoredItemDefinition;
import appeng.core.FeatureHandlerRegistry;
import appeng.core.FeatureRegistry;
import appeng.core.features.ColoredItemDefinition;
import appeng.core.features.IAEFeature;
import appeng.core.features.IFeatureHandler;
import appeng.core.features.ItemStackSrc;
import appeng.items.parts.ItemMultiPart;
import appeng.items.parts.PartType;
public class DefinitionConstructor
{
private final FeatureRegistry features;
private final FeatureHandlerRegistry handlers;
public DefinitionConstructor( FeatureRegistry features, FeatureHandlerRegistry handlers )
{
this.features = features;
this.handlers = handlers;
}
public final ITileDefinition registerTileDefinition( IAEFeature feature )
{
final IBlockDefinition definition = this.registerBlockDefinition( feature );
if ( definition instanceof ITileDefinition )
{
return ( (ITileDefinition) definition );
}
throw new RuntimeException( "No tile definition" );
}
public final IBlockDefinition registerBlockDefinition( IAEFeature feature )
{
final IItemDefinition definition = this.registerItemDefinition( feature );
if ( definition instanceof IBlockDefinition )
{
return ( (IBlockDefinition) definition );
}
throw new RuntimeException( "No block definition" );
}
public final IItemDefinition registerItemDefinition( IAEFeature feature )
{
final IFeatureHandler handler = feature.handler();
if ( handler.isFeatureAvailable() )
{
this.handlers.addFeatureHandler( handler );
this.features.addFeature( feature );
}
final IItemDefinition definition = handler.getDefinition();
return definition;
}
public final AEColoredItemDefinition constructColoredDefinition( IItemDefinition target, int offset )
{
final ColoredItemDefinition definition = new ColoredItemDefinition();
for ( Item targetItem : target.maybeItem().asSet() )
{
for ( AEColor color : AEColor.VALID_COLORS )
{
definition.add( color, new ItemStackSrc( targetItem, offset + color.ordinal() ) );
}
}
return definition;
}
public final AEColoredItemDefinition constructColoredDefinition( ItemMultiPart target, PartType type )
{
final ColoredItemDefinition definition = new ColoredItemDefinition();
for ( AEColor color : AEColor.values() )
{
ItemStackSrc multiPartSource = target.createPart( type, color );
final Optional<ItemStackSrc> maybeSource = Optional.fromNullable( multiPartSource );
if ( maybeSource.isPresent() )
{
definition.add( color, multiPartSource );
}
}
return definition;
}
}