308 lines
11 KiB
Java
308 lines
11 KiB
Java
/*
|
|
* This file is part of Industrial Wires.
|
|
* Copyright (C) 2016-2018 malte0811
|
|
* Industrial Wires is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
* Industrial Wires is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with Industrial Wires. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
package malte0811.industrialWires.mech_mb;
|
|
|
|
import blusunrize.immersiveengineering.api.MultiblockHandler;
|
|
import blusunrize.immersiveengineering.common.IEContent;
|
|
import blusunrize.immersiveengineering.common.blocks.metal.BlockTypes_MetalDecoration0;
|
|
import blusunrize.immersiveengineering.common.util.Utils;
|
|
import blusunrize.immersiveengineering.common.util.chickenbones.Matrix4;
|
|
import com.google.common.collect.BiMap;
|
|
import com.google.common.collect.HashBiMap;
|
|
import malte0811.industrialWires.IndustrialWires;
|
|
import malte0811.industrialWires.blocks.converter.MechanicalMBBlockType;
|
|
import malte0811.industrialWires.blocks.converter.TileEntityMechMB;
|
|
import malte0811.industrialWires.client.render.TileRenderMechMB;
|
|
import malte0811.industrialWires.entities.EntityBrokenPart;
|
|
import malte0811.industrialWires.util.LocalSidedWorld;
|
|
import malte0811.industrialWires.util.MiscUtils;
|
|
import malte0811.industrialWires.util.MultiblockTemplateManual;
|
|
import net.minecraft.block.state.IBlockState;
|
|
import net.minecraft.client.renderer.block.model.BakedQuad;
|
|
import net.minecraft.entity.player.EntityPlayer;
|
|
import net.minecraft.init.Blocks;
|
|
import net.minecraft.item.ItemStack;
|
|
import net.minecraft.nbt.NBTTagCompound;
|
|
import net.minecraft.tileentity.TileEntity;
|
|
import net.minecraft.util.EnumFacing;
|
|
import net.minecraft.util.EnumHand;
|
|
import net.minecraft.util.ResourceLocation;
|
|
import net.minecraft.util.math.AxisAlignedBB;
|
|
import net.minecraft.util.math.BlockPos;
|
|
import net.minecraft.util.math.Vec3d;
|
|
import net.minecraft.util.math.Vec3i;
|
|
import net.minecraftforge.common.capabilities.Capability;
|
|
import net.minecraftforge.fml.relauncher.Side;
|
|
import net.minecraftforge.fml.relauncher.SideOnly;
|
|
|
|
import javax.annotation.Nonnull;
|
|
import java.util.Comparator;
|
|
import java.util.HashMap;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
import java.util.function.Consumer;
|
|
|
|
import static blusunrize.immersiveengineering.common.IEContent.blockMetalDecoration0;
|
|
import static blusunrize.immersiveengineering.common.blocks.metal.BlockTypes_MetalDecoration0.HEAVY_ENGINEERING;
|
|
import static blusunrize.immersiveengineering.common.blocks.metal.BlockTypes_MetalDecoration0.LIGHT_ENGINEERING;
|
|
import static malte0811.industrialWires.IndustrialWires.MODID;
|
|
import static malte0811.industrialWires.blocks.converter.MechanicalMBBlockType.NO_MODEL;
|
|
import static malte0811.industrialWires.util.NBTKeys.TYPE;
|
|
|
|
public abstract class MechMBPart {
|
|
public static final Map<String, MechMBPart> INSTANCES = new HashMap<>();
|
|
public LocalSidedWorld world;
|
|
protected Map<BlockPos, IBlockState> original = new HashMap<>();
|
|
|
|
// These 3 are called once per tick in bulk in this order
|
|
public abstract void createMEnergy(MechEnergy e);
|
|
public abstract double requestMEnergy(MechEnergy e);
|
|
// This should do any misc ticking as well
|
|
public abstract void insertMEnergy(double added);
|
|
|
|
public abstract double getInertia();
|
|
public abstract double getMaxSpeed();
|
|
public abstract void writeToNBT(NBTTagCompound out);
|
|
public abstract void readFromNBT(NBTTagCompound in);
|
|
|
|
public IBlockState getExtState(IBlockState in) {
|
|
return in;
|
|
}
|
|
|
|
@SideOnly(Side.CLIENT)
|
|
public List<BakedQuad> getRotatingQuads() {
|
|
return TileRenderMechMB.BASE_MODELS.get(getRotatingBaseModel())
|
|
.getQuads(null, null, 123);
|
|
|
|
}
|
|
@SideOnly(Side.CLIENT)
|
|
public abstract ResourceLocation getRotatingBaseModel();
|
|
|
|
public abstract boolean canForm(LocalSidedWorld w);
|
|
|
|
protected boolean hasSupportPillars(LocalSidedWorld w) {
|
|
for (int i = 0; i < 2; i++) {
|
|
for (int j = 0; j < 2; j++) {
|
|
IBlockState state = w.getBlockState(new BlockPos(2*i-1, j-1, 0));
|
|
if (!isLightEngineering(state)) {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public abstract short getFormPattern(int offset);
|
|
|
|
public abstract void breakOnFailure(MechEnergy energy);
|
|
|
|
public ItemStack getOriginalItem(BlockPos pos) {
|
|
IBlockState state = getOriginalBlock(pos);
|
|
return new ItemStack(state.getBlock(), 1, state.getBlock().getMetaFromState(state));
|
|
}
|
|
|
|
public IBlockState getOriginalBlock(BlockPos pos) {
|
|
return original.getOrDefault(pos, Blocks.AIR.getDefaultState());
|
|
}
|
|
|
|
public abstract MechanicalMBBlockType getType();
|
|
|
|
public <T> boolean hasCapability(Capability<T> cap, EnumFacing side, BlockPos pos) {
|
|
return false;
|
|
}
|
|
|
|
public <T> T getCapability(Capability<T> cap, EnumFacing side, BlockPos pos) {
|
|
return null;
|
|
}
|
|
|
|
public int interact(@Nonnull EnumFacing side, @Nonnull Vec3i offset, @Nonnull EntityPlayer player,
|
|
@Nonnull EnumHand hand, @Nonnull ItemStack heldItem) {
|
|
return -1;
|
|
}
|
|
|
|
public static final BiMap<String, Class<? extends MechMBPart>> REGISTRY = HashBiMap.create();
|
|
|
|
public static final String SHAFT_KEY = "shaft";
|
|
public static final ResourceLocation EXAMPLE_MECHMB_LOC = new ResourceLocation(MODID, "example_mech_mb");
|
|
|
|
public static final Comparator<MechMBPart> SORT_BY_COUNT = (a, b)-> {
|
|
if (a.getLength()!=b.getLength()) {
|
|
return Integer.compare(a.getLength(), b.getLength());
|
|
}
|
|
for (int i = 0;i<a.getLength();i++) {
|
|
int aBits = MiscUtils.count1Bits(a.getFormPattern(i));
|
|
int bBits = MiscUtils.count1Bits(b.getFormPattern(i));
|
|
if (aBits!=bBits) {
|
|
return Integer.compare(aBits, bBits);
|
|
}
|
|
}
|
|
return 0;
|
|
};
|
|
public static void preInit() {
|
|
REGISTRY.put("flywheel", MechPartFlywheel.class);
|
|
REGISTRY.put("singleCoil", MechPartSingleCoil.class);
|
|
REGISTRY.put("twoElectrodes", MechPartTwoElectrodes.class);
|
|
REGISTRY.put("commutator", MechPartCommutator.class);
|
|
REGISTRY.put(SHAFT_KEY, MechPartShaft.class);
|
|
REGISTRY.put("speedometer", MechPartSpeedometer.class);
|
|
REGISTRY.put("commFour", MechPartCommutator4Phase.class);
|
|
REGISTRY.put("fourCoils", MechPartFourCoils.class);
|
|
REGISTRY.put("fourElectrodes", MechPartFourElectrodes.class);
|
|
|
|
for (String key : REGISTRY.keySet()) {
|
|
cacheNewInstance(key);
|
|
MultiblockHandler.registerMultiblock(
|
|
new MultiblockTemplateManual(getSchematicLocationForPart(key)));
|
|
}
|
|
}
|
|
|
|
public static ResourceLocation getSchematicLocationForPart(Class<? extends MechMBPart> cl) {
|
|
String name = REGISTRY.inverse().get(cl);
|
|
return getSchematicLocationForPart(name);
|
|
}
|
|
|
|
public static ResourceLocation getSchematicLocationForPart(String name) {
|
|
if (name==null)
|
|
return null;
|
|
name = MiscUtils.toSnakeCase(name);
|
|
return new ResourceLocation(MODID, name);
|
|
}
|
|
|
|
public static MultiblockHandler.IMultiblock getManualMBForPart(Class<? extends MechMBPart> cl) {
|
|
return MiscUtils.getMBFromName(getSchematicLocationForPart(cl).toString());
|
|
}
|
|
|
|
public static void cacheNewInstance(String key) {
|
|
try {
|
|
MechMBPart instance = REGISTRY.get(key).newInstance();
|
|
INSTANCES.put(key, instance);
|
|
} catch (IllegalAccessException | InstantiationException e) {
|
|
throw new RuntimeException(e);
|
|
}
|
|
}
|
|
|
|
public static MechMBPart fromNBT(NBTTagCompound nbt, LocalSidedWorld w) {
|
|
String name = nbt.getString(TYPE);
|
|
Class<? extends MechMBPart> clazz = REGISTRY.get(name);
|
|
try {
|
|
MechMBPart ret = clazz.newInstance();
|
|
ret.readFromNBT(nbt);
|
|
if (w==null)
|
|
throw new NullPointerException();
|
|
ret.world = w;
|
|
return ret;
|
|
} catch (InstantiationException | IllegalAccessException e) {
|
|
throw new RuntimeException("While creating mechanical MB part", e);
|
|
}
|
|
}
|
|
public static NBTTagCompound toNBT(MechMBPart part) {
|
|
Class<? extends MechMBPart> clazz = part.getClass();
|
|
String name = REGISTRY.inverse().get(clazz);
|
|
NBTTagCompound nbt = new NBTTagCompound();
|
|
part.writeToNBT(nbt);
|
|
nbt.setString(TYPE, name);
|
|
return nbt;
|
|
}
|
|
|
|
public static boolean isValidDefaultCenter(IBlockState state) {
|
|
return state.getBlock()== IEContent.blockMetalDecoration0&&
|
|
state.getValue(IEContent.blockMetalDecoration0.property)==BlockTypes_MetalDecoration0.HEAVY_ENGINEERING;
|
|
}
|
|
|
|
public static boolean isHeavyEngineering(IBlockState state) {
|
|
return isValidDefaultCenter(state);
|
|
}
|
|
|
|
public static boolean isLightEngineering(IBlockState state) {
|
|
return state.getBlock()== IEContent.blockMetalDecoration0&&
|
|
state.getValue(IEContent.blockMetalDecoration0.property)==BlockTypes_MetalDecoration0.LIGHT_ENGINEERING;
|
|
}
|
|
|
|
public IBlockState getDefaultShaft() {
|
|
return blockMetalDecoration0.getDefaultState().withProperty(blockMetalDecoration0.property,
|
|
HEAVY_ENGINEERING);
|
|
}
|
|
|
|
public IBlockState getLightEngineering() {
|
|
return blockMetalDecoration0.getDefaultState().withProperty(blockMetalDecoration0.property,
|
|
LIGHT_ENGINEERING);
|
|
}
|
|
|
|
|
|
public void form(LocalSidedWorld w, Consumer<TileEntityMechMB> initializer) {
|
|
world = w;
|
|
BlockPos.PooledMutableBlockPos pos = BlockPos.PooledMutableBlockPos.retain();
|
|
for (int z = 0;z<getLength();z++) {
|
|
short pattern = getFormPattern(z);
|
|
int i = 0;
|
|
for (int y = -1; y <= 1; y++) {
|
|
for (int x = -1; x <= 1; x++) {
|
|
if ((pattern & (1 << i)) != 0) {
|
|
pos.setPos(x, y, -z);
|
|
w.setBlockState(pos, IndustrialWires.mechanicalMB.getStateFromMeta((i == 4 ? getType() : NO_MODEL).ordinal()));
|
|
TileEntity te = w.getTileEntity(pos);
|
|
if (te instanceof TileEntityMechMB) {
|
|
initializer.accept((TileEntityMechMB) te);
|
|
}
|
|
}
|
|
i++;
|
|
}
|
|
}
|
|
}
|
|
pos.release();
|
|
}
|
|
|
|
public void disassemble() {
|
|
BlockPos.PooledMutableBlockPos pos = BlockPos.PooledMutableBlockPos.retain();
|
|
for (int z = 0;z<getLength();z++) {
|
|
for (int x = -1; x <= 1; x++) {
|
|
for (int y = -1; y <= 1; y++) {
|
|
pos.setPos(x, y, -z);
|
|
IBlockState state = getOriginalBlock(pos);
|
|
if (state.getBlock()!=Blocks.AIR) {
|
|
world.setBlockState(pos, state);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
pos.release();
|
|
}
|
|
|
|
protected void spawnBrokenParts(int count, MechEnergy energy, ResourceLocation texture) {
|
|
Matrix4 mat = new Matrix4();
|
|
mat.rotate(Utils.RAND.nextDouble(), 0, 0, 1);
|
|
Vec3d baseVec = new Vec3d(0, 1.5, 0);
|
|
for (int i = 0;i<count;i++) {
|
|
mat.rotate(2*Math.PI / count, 0, 0, 1);
|
|
Vec3d pos = mat.apply(baseVec);
|
|
EntityBrokenPart e = new EntityBrokenPart(world.getWorld(), texture);
|
|
e.setPosition(pos.x, pos.y, -.5);
|
|
double speed = (energy.getSpeed() / getMaxSpeed()) / 1.5;
|
|
e.motionX = pos.y * speed;
|
|
e.motionY = -pos.x * speed;
|
|
e.motionZ = (Utils.RAND.nextDouble() - .5) * speed / 10;
|
|
world.spawnEntity(e);
|
|
e.breakBlocks(speed * speed * 1.5 * 1.5);
|
|
}
|
|
}
|
|
|
|
public int getLength() {
|
|
return 1;
|
|
}
|
|
|
|
public abstract AxisAlignedBB getBoundingBox(BlockPos offsetPart);
|
|
}
|