235 lines
8.7 KiB
Java
235 lines
8.7 KiB
Java
/*
|
|
* 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.facade;
|
|
|
|
import java.io.IOException;
|
|
|
|
import appeng.api.AEApi;
|
|
import appeng.api.parts.IFacadeContainer;
|
|
import appeng.api.parts.IFacadePart;
|
|
import appeng.api.parts.IPartHost;
|
|
import appeng.integration.IntegrationRegistry;
|
|
import appeng.integration.IntegrationType;
|
|
import appeng.integration.abstraction.IBuildCraftTransport;
|
|
import appeng.items.parts.ItemFacade;
|
|
import appeng.parts.CableBusStorage;
|
|
import io.netty.buffer.ByteBuf;
|
|
import net.minecraft.block.Block;
|
|
import net.minecraft.item.Item;
|
|
import net.minecraft.item.ItemStack;
|
|
import net.minecraft.nbt.NBTTagCompound;
|
|
import net.minecraftforge.common.util.ForgeDirection;
|
|
|
|
public class FacadeContainer implements IFacadeContainer {
|
|
private final int facades = 6;
|
|
private final CableBusStorage storage;
|
|
|
|
public FacadeContainer(final CableBusStorage cbs) {
|
|
this.storage = cbs;
|
|
}
|
|
|
|
@Override
|
|
public boolean addFacade(final IFacadePart a) {
|
|
if (this.getFacade(a.getSide()) == null) {
|
|
this.storage.setFacade(a.getSide().ordinal(), a);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
@Override
|
|
public void removeFacade(final IPartHost host, final ForgeDirection side) {
|
|
if (side != null && side != ForgeDirection.UNKNOWN) {
|
|
if (this.storage.getFacade(side.ordinal()) != null) {
|
|
this.storage.setFacade(side.ordinal(), null);
|
|
if (host != null) {
|
|
host.markForUpdate();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public IFacadePart getFacade(final ForgeDirection s) {
|
|
return this.storage.getFacade(s.ordinal());
|
|
}
|
|
|
|
@Override
|
|
public void rotateLeft() {
|
|
final IFacadePart[] newFacades = new FacadePart[6];
|
|
|
|
newFacades[ForgeDirection.UP.ordinal()]
|
|
= this.storage.getFacade(ForgeDirection.UP.ordinal());
|
|
newFacades[ForgeDirection.DOWN.ordinal()]
|
|
= this.storage.getFacade(ForgeDirection.DOWN.ordinal());
|
|
|
|
newFacades[ForgeDirection.EAST.ordinal()]
|
|
= this.storage.getFacade(ForgeDirection.NORTH.ordinal());
|
|
newFacades[ForgeDirection.SOUTH.ordinal()]
|
|
= this.storage.getFacade(ForgeDirection.EAST.ordinal());
|
|
|
|
newFacades[ForgeDirection.WEST.ordinal()]
|
|
= this.storage.getFacade(ForgeDirection.SOUTH.ordinal());
|
|
newFacades[ForgeDirection.NORTH.ordinal()]
|
|
= this.storage.getFacade(ForgeDirection.WEST.ordinal());
|
|
|
|
for (int x = 0; x < this.facades; x++) {
|
|
this.storage.setFacade(x, newFacades[x]);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void writeToNBT(final NBTTagCompound c) {
|
|
for (int x = 0; x < this.facades; x++) {
|
|
if (this.storage.getFacade(x) != null) {
|
|
final NBTTagCompound data = new NBTTagCompound();
|
|
this.storage.getFacade(x).getItemStack().writeToNBT(data);
|
|
c.setTag("facade:" + x, data);
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public boolean readFromStream(final ByteBuf out) throws IOException {
|
|
final int facadeSides = out.readByte();
|
|
|
|
boolean changed = false;
|
|
|
|
final int[] ids = new int[2];
|
|
for (int x = 0; x < this.facades; x++) {
|
|
final ForgeDirection side = ForgeDirection.getOrientation(x);
|
|
final int ix = (1 << x);
|
|
if ((facadeSides & ix) == ix) {
|
|
ids[0] = out.readInt();
|
|
ids[1] = out.readInt();
|
|
final boolean isBC = ids[0] < 0;
|
|
ids[0] = Math.abs(ids[0]);
|
|
|
|
if (isBC
|
|
&& IntegrationRegistry.INSTANCE.isEnabled(
|
|
IntegrationType.BuildCraftTransport
|
|
)) {
|
|
final IBuildCraftTransport bc
|
|
= (IBuildCraftTransport) IntegrationRegistry.INSTANCE.getInstance(
|
|
IntegrationType.BuildCraftTransport
|
|
);
|
|
final IFacadePart created = bc.createFacadePart(
|
|
(Block) Block.blockRegistry.getObjectById(ids[0]), ids[1], side
|
|
);
|
|
changed = changed || this.storage.getFacade(x) == null;
|
|
|
|
this.storage.setFacade(x, created);
|
|
} else if (!isBC) {
|
|
for (final Item facadeItem : AEApi.instance()
|
|
.definitions()
|
|
.items()
|
|
.facade()
|
|
.maybeItem()
|
|
.asSet()) {
|
|
final ItemFacade ifa = (ItemFacade) facadeItem;
|
|
final ItemStack facade = ifa.createFromIDs(ids);
|
|
if (facade != null) {
|
|
changed = changed || this.storage.getFacade(x) == null;
|
|
this.storage.setFacade(
|
|
x, ifa.createPartFromItemStack(facade, side)
|
|
);
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
changed = changed || this.storage.getFacade(x) != null;
|
|
this.storage.setFacade(x, null);
|
|
}
|
|
}
|
|
|
|
return changed;
|
|
}
|
|
|
|
@Override
|
|
public void readFromNBT(final NBTTagCompound c) {
|
|
for (int x = 0; x < this.facades; x++) {
|
|
this.storage.setFacade(x, null);
|
|
|
|
final NBTTagCompound t = c.getCompoundTag("facade:" + x);
|
|
if (t != null) {
|
|
final ItemStack is = ItemStack.loadItemStackFromNBT(t);
|
|
if (is != null) {
|
|
final Item i = is.getItem();
|
|
if (i instanceof IFacadeItem) {
|
|
this.storage.setFacade(
|
|
x,
|
|
((IFacadeItem) i)
|
|
.createPartFromItemStack(
|
|
is, ForgeDirection.getOrientation(x)
|
|
)
|
|
);
|
|
} else {
|
|
if (IntegrationRegistry.INSTANCE.isEnabled(
|
|
IntegrationType.BuildCraftTransport
|
|
)) {
|
|
final IBuildCraftTransport bc
|
|
= (IBuildCraftTransport) IntegrationRegistry.INSTANCE
|
|
.getInstance(IntegrationType.BuildCraftTransport);
|
|
if (bc.isFacade(is)) {
|
|
this.storage.setFacade(
|
|
x,
|
|
bc.createFacadePart(
|
|
is, ForgeDirection.getOrientation(x)
|
|
)
|
|
);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void writeToStream(final ByteBuf out) throws IOException {
|
|
int facadeSides = 0;
|
|
for (int x = 0; x < this.facades; x++) {
|
|
if (this.getFacade(ForgeDirection.getOrientation(x)) != null) {
|
|
facadeSides |= (1 << x);
|
|
}
|
|
}
|
|
out.writeByte((byte) facadeSides);
|
|
|
|
for (int x = 0; x < this.facades; x++) {
|
|
final IFacadePart part = this.getFacade(ForgeDirection.getOrientation(x));
|
|
if (part != null) {
|
|
final int itemID = Item.getIdFromItem(part.getItem());
|
|
final int dmgValue = part.getItemDamage();
|
|
out.writeInt(itemID * (part.notAEFacade() ? -1 : 1));
|
|
out.writeInt(dmgValue);
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public boolean isEmpty() {
|
|
for (int x = 0; x < this.facades; x++) {
|
|
if (this.storage.getFacade(x) != null) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
}
|