From 6d51dee9c7500607c496c3c0645bd48adcfab8ab Mon Sep 17 00:00:00 2001 From: TheBrokenRail Date: Sun, 19 Jul 2020 15:12:39 -0400 Subject: [PATCH] Very Broken Structure Gen WIP --- .../energonrelics/EnergonRelics.java | 3 + .../energonrelics/block/TestBlock.java | 28 +++ .../block/util/EnergyProviderBlock.java | 12 -- .../core/EnergyProviderBlockEntity.java | 13 ++ .../energonrelics/item/NetworkChipItem.java | 6 + .../structure/StructureContext.java | 5 + .../structure/StructurePart.java | 178 ++++++++++++++++++ .../structure/StructurePlacer.java | 60 ++++++ .../BaseResearchComplexPart.java | 27 +++ .../ResearchComplexHallwayPart.java | 42 +++++ .../ResearchComplexStartPart.java | 130 +++++++++++++ .../researchcomplex/ResearchComplexState.java | 35 ++++ 12 files changed, 527 insertions(+), 12 deletions(-) create mode 100644 src/main/java/com/thebrokenrail/energonrelics/block/TestBlock.java create mode 100644 src/main/java/com/thebrokenrail/energonrelics/structure/StructureContext.java create mode 100644 src/main/java/com/thebrokenrail/energonrelics/structure/StructurePart.java create mode 100644 src/main/java/com/thebrokenrail/energonrelics/structure/StructurePlacer.java create mode 100644 src/main/java/com/thebrokenrail/energonrelics/structure/researchcomplex/BaseResearchComplexPart.java create mode 100644 src/main/java/com/thebrokenrail/energonrelics/structure/researchcomplex/ResearchComplexHallwayPart.java create mode 100644 src/main/java/com/thebrokenrail/energonrelics/structure/researchcomplex/ResearchComplexStartPart.java create mode 100644 src/main/java/com/thebrokenrail/energonrelics/structure/researchcomplex/ResearchComplexState.java diff --git a/src/main/java/com/thebrokenrail/energonrelics/EnergonRelics.java b/src/main/java/com/thebrokenrail/energonrelics/EnergonRelics.java index a5cd9dd..5000640 100644 --- a/src/main/java/com/thebrokenrail/energonrelics/EnergonRelics.java +++ b/src/main/java/com/thebrokenrail/energonrelics/EnergonRelics.java @@ -1,6 +1,7 @@ package com.thebrokenrail.energonrelics; import com.thebrokenrail.energonrelics.block.DefensiveLaserBlock; +import com.thebrokenrail.energonrelics.block.TestBlock; import com.thebrokenrail.energonrelics.block.ThermalGlassBlock; import com.thebrokenrail.energonrelics.block.battery.ActiveBatteryControllerBlock; import com.thebrokenrail.energonrelics.block.reactor.ReactorControllerBlock; @@ -95,5 +96,7 @@ public class EnergonRelics implements ModInitializer { Registry.register(Registry.ITEM, new Identifier(NAMESPACE, "defensive_laser_core"), DEFENSIVE_LASER_CORE_ITEM); DEFENSIVE_LASER_BLOCK.register("defensive_laser"); + + new TestBlock().register("test_block"); } } diff --git a/src/main/java/com/thebrokenrail/energonrelics/block/TestBlock.java b/src/main/java/com/thebrokenrail/energonrelics/block/TestBlock.java new file mode 100644 index 0000000..9ae261d --- /dev/null +++ b/src/main/java/com/thebrokenrail/energonrelics/block/TestBlock.java @@ -0,0 +1,28 @@ +package com.thebrokenrail.energonrelics.block; + +import com.thebrokenrail.energonrelics.block.util.SimpleBlock; +import com.thebrokenrail.energonrelics.structure.StructurePlacer; +import com.thebrokenrail.energonrelics.structure.researchcomplex.ResearchComplexStartPart; +import com.thebrokenrail.energonrelics.structure.researchcomplex.ResearchComplexState; +import net.fabricmc.fabric.api.object.builder.v1.block.FabricBlockSettings; +import net.minecraft.block.BlockState; +import net.minecraft.block.Material; +import net.minecraft.util.math.BlockPos; +import net.minecraft.world.World; + +import java.util.Collections; + +public class TestBlock extends SimpleBlock { + public TestBlock() { + super(FabricBlockSettings.of(Material.STONE)); + } + + @SuppressWarnings("deprecation") + @Override + public void onBlockAdded(BlockState state, World world, BlockPos pos, BlockState oldState, boolean notify) { + super.onBlockAdded(state, world, pos, oldState, notify); + if (!world.isClient()) { + new StructurePlacer(new ResearchComplexStartPart(new ResearchComplexState(world), Collections.emptyList())).place(world, pos); + } + } +} diff --git a/src/main/java/com/thebrokenrail/energonrelics/block/util/EnergyProviderBlock.java b/src/main/java/com/thebrokenrail/energonrelics/block/util/EnergyProviderBlock.java index 4358b0f..17ddbcd 100644 --- a/src/main/java/com/thebrokenrail/energonrelics/block/util/EnergyProviderBlock.java +++ b/src/main/java/com/thebrokenrail/energonrelics/block/util/EnergyProviderBlock.java @@ -49,16 +49,6 @@ public abstract class EnergyProviderBlock extends SimpleBlockWithEntity { return HighlightBlockEntityRenderer::new; } - private void setEnergyProviderSource(World world, BlockPos pos, ItemStack stack, boolean remove) { - ServerWorld serverWorld = (ServerWorld) world; - NetworkComponent component = NetworkComponent.getInstance(serverWorld); - if (remove) { - component.removeSource(EnergonRelics.NETWORK_CHIP_ITEM.getID(stack), pos); - } else { - component.addSource(EnergonRelics.NETWORK_CHIP_ITEM.getID(stack), pos); - } - } - @Override @SuppressWarnings("deprecation") public ActionResult onUse(BlockState state, World world, BlockPos pos, PlayerEntity player, Hand hand, BlockHitResult hit) { @@ -68,7 +58,6 @@ public abstract class EnergyProviderBlock extends SimpleBlockWithEntity { if (stack.getItem() == EnergonRelics.NETWORK_CHIP_ITEM) { if (!((EnergyProviderBlockEntity) entity).hasStack()) { if (!world.isClient()) { - setEnergyProviderSource(world, pos, stack, false); ((EnergyProviderBlockEntity) entity).placeStack(stack); stack.setCount(0); } @@ -81,7 +70,6 @@ public abstract class EnergyProviderBlock extends SimpleBlockWithEntity { if (!world.isClient()) { ItemStack newStack = ((EnergyProviderBlockEntity) entity).takeStack(); player.setStackInHand(hand, newStack); - setEnergyProviderSource(world, pos, newStack, true); } return ActionResult.SUCCESS; } else { diff --git a/src/main/java/com/thebrokenrail/energonrelics/energy/core/EnergyProviderBlockEntity.java b/src/main/java/com/thebrokenrail/energonrelics/energy/core/EnergyProviderBlockEntity.java index 08f04fc..7bff6b1 100644 --- a/src/main/java/com/thebrokenrail/energonrelics/energy/core/EnergyProviderBlockEntity.java +++ b/src/main/java/com/thebrokenrail/energonrelics/energy/core/EnergyProviderBlockEntity.java @@ -16,6 +16,7 @@ import net.minecraft.server.world.ServerWorld; import net.minecraft.util.Tickable; import net.minecraft.util.math.BlockPos; import net.minecraft.util.math.Vec3d; +import net.minecraft.world.World; import java.util.ArrayList; import java.util.Collections; @@ -113,14 +114,26 @@ public class EnergyProviderBlockEntity extends BlockEntity implements EnergyProv } } + private static void setEnergyProviderSource(World world, BlockPos pos, ItemStack stack, boolean remove) { + ServerWorld serverWorld = (ServerWorld) world; + NetworkComponent component = NetworkComponent.getInstance(serverWorld); + if (remove) { + component.removeSource(EnergonRelics.NETWORK_CHIP_ITEM.getID(stack), pos); + } else { + component.addSource(EnergonRelics.NETWORK_CHIP_ITEM.getID(stack), pos); + } + } + public ItemStack takeStack() { ItemStack newStack = stack.copy(); + setEnergyProviderSource(getWorld(), getPos(), newStack, true); stack = ItemStack.EMPTY; markDirty(); return newStack; } public void placeStack(ItemStack newStack) { + setEnergyProviderSource(getWorld(), getPos(), newStack, false); stack = newStack.copy(); markDirty(); } diff --git a/src/main/java/com/thebrokenrail/energonrelics/item/NetworkChipItem.java b/src/main/java/com/thebrokenrail/energonrelics/item/NetworkChipItem.java index 436eb7f..0da1588 100644 --- a/src/main/java/com/thebrokenrail/energonrelics/item/NetworkChipItem.java +++ b/src/main/java/com/thebrokenrail/energonrelics/item/NetworkChipItem.java @@ -49,6 +49,12 @@ public class NetworkChipItem extends Item { return id; } + public ItemStack create(int id) { + ItemStack stack = new ItemStack(this); + setID(stack, id); + return stack; + } + @Override public void inventoryTick(ItemStack stack, World world, Entity entity, int slot, boolean selected) { super.inventoryTick(stack, world, entity, slot, selected); diff --git a/src/main/java/com/thebrokenrail/energonrelics/structure/StructureContext.java b/src/main/java/com/thebrokenrail/energonrelics/structure/StructureContext.java new file mode 100644 index 0000000..8db5b90 --- /dev/null +++ b/src/main/java/com/thebrokenrail/energonrelics/structure/StructureContext.java @@ -0,0 +1,5 @@ +package com.thebrokenrail.energonrelics.structure; + +public interface StructureContext { + void addPart(int x, int y, int z, StructurePart part); +} diff --git a/src/main/java/com/thebrokenrail/energonrelics/structure/StructurePart.java b/src/main/java/com/thebrokenrail/energonrelics/structure/StructurePart.java new file mode 100644 index 0000000..94a165f --- /dev/null +++ b/src/main/java/com/thebrokenrail/energonrelics/structure/StructurePart.java @@ -0,0 +1,178 @@ +package com.thebrokenrail.energonrelics.structure; + +import com.thebrokenrail.energonrelics.util.MissingCaseException; +import net.minecraft.block.BlockState; +import net.minecraft.block.Blocks; +import net.minecraft.util.BlockRotation; +import net.minecraft.util.math.BlockPos; +import net.minecraft.util.math.Vec3d; +import net.minecraft.world.World; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +public abstract class StructurePart { + protected interface Transformation { + Vec3d transform(Vec3d vec); + BlockState transform(BlockState state); + } + + private final T state; + + protected T getState() { + return state; + } + + public StructurePart(T state, List list) { + this.state = state; + transformations.addAll(list); + } + + private final Map blocks = new HashMap<>(); + + private final List transformations = new ArrayList<>(); + + protected static final Transformation NONE = new Transformation() { + @Override + public Vec3d transform(Vec3d vec) { + return vec; + } + + @Override + public BlockState transform(BlockState state) { + return state; + } + }; + protected static final Transformation CLOCKWISE_90 = new Transformation() { + @Override + public Vec3d transform(Vec3d vec) { + return new Vec3d(-vec.getZ(), vec.getY(), vec.getX()); + } + + @Override + public BlockState transform(BlockState state) { + return state.rotate(BlockRotation.CLOCKWISE_90); + } + }; + protected static final Transformation CLOCKWISE_180 = new Transformation() { + @Override + public Vec3d transform(Vec3d vec) { + return new Vec3d(-vec.getX(), vec.getY(), -vec.getZ()); + } + + @Override + public BlockState transform(BlockState state) { + return state.rotate(BlockRotation.CLOCKWISE_180); + } + }; + protected static final Transformation COUNTERCLOCKWISE_90 = new Transformation() { + @Override + public Vec3d transform(Vec3d vec) { + return new Vec3d(vec.getZ(), vec.getY(), -vec.getX()); + } + + @Override + public BlockState transform(BlockState state) { + return state.rotate(BlockRotation.COUNTERCLOCKWISE_90); + } + }; + + protected abstract int getHeight(); + protected abstract int getWidth(); + protected abstract int getDepth(); + + protected abstract void build(StructureContext context); + + private Vec3d getOffset() { + return new Vec3d(getWidth() / 2f, getHeight() / 2f, getDepth() / 2f); + } + + private Vec3d transform(Vec3d pos) { + pos = pos.subtract(getOffset()); + for (Transformation transformation : transformations) { + pos = transformation.transform(pos); + } + return pos; + } + + private BlockState transform(BlockState state) { + for (Transformation transformation : transformations) { + state = transformation.transform(state); + } + return state; + } + + protected void set(int x, int y, int z, BlockState state) { + Vec3d vec = transform(new Vec3d(x, y, z)); + blocks.put(new BlockPos(vec.getX(), vec.getY(), vec.getZ()).asLong(), transform(state)); + } + + protected void rect(int xPos, int yPos, int zPos, int width, int height, int depth, BlockState state) { + for (int x = 0; x < width; x++) { + for (int y = 0; y < height; y++) { + for (int z = 0; z < depth; z++) { + set(x + xPos, y + yPos, z + zPos, state); + } + } + } + } + + protected void repeat(Transformation[] functions, Runnable action) { + for (Transformation function : functions) { + transformations.add(function); + action.run(); + transformations.remove(transformations.size() - 1); + } + } + + protected void repeat(Runnable action) { + repeat(new Transformation[]{NONE, CLOCKWISE_90, CLOCKWISE_180, COUNTERCLOCKWISE_90}, action); + } + + public void place(World world, BlockPos pos) { + Vec3d offset = getOffset(); + BlockPos offsetPos = new BlockPos(offset.getX(), offset.getY(), offset.getZ()); + for (Map.Entry entry : blocks.entrySet()) { + BlockState state = entry.getValue(); + if (state.getBlock() != Blocks.VOID_AIR) { + BlockPos newPos = pos.add(BlockPos.fromLong(entry.getKey()).add(offsetPos)); + world.removeBlockEntity(newPos); + world.setBlockState(newPos, state); + handleBlockPlace(world, newPos, state); + } + } + } + + protected abstract void handleBlockPlace(World world, BlockPos pos, BlockState state); + + public static Transformation getTransformationFromBlockRotation(BlockRotation rotation) { + switch (rotation) { + case NONE: { + return NONE; + } + case CLOCKWISE_90: { + return CLOCKWISE_90; + } + case CLOCKWISE_180: { + return CLOCKWISE_180; + } + case COUNTERCLOCKWISE_90: { + return COUNTERCLOCKWISE_90; + } + default: { + throw new MissingCaseException(rotation); + } + } + } + + protected void part(StructureContext context, int x, int y, int z, StructurePart part) { + Vec3d vec = transform(new Vec3d(x, y, z)); + context.addPart((int) vec.getX(), (int) vec.getY(), (int) vec.getZ(), part); + } + + protected List getTransformations() { + return transformations; + } +} diff --git a/src/main/java/com/thebrokenrail/energonrelics/structure/StructurePlacer.java b/src/main/java/com/thebrokenrail/energonrelics/structure/StructurePlacer.java new file mode 100644 index 0000000..2266ed9 --- /dev/null +++ b/src/main/java/com/thebrokenrail/energonrelics/structure/StructurePlacer.java @@ -0,0 +1,60 @@ +package com.thebrokenrail.energonrelics.structure; + +import net.minecraft.block.Blocks; +import net.minecraft.util.math.BlockPos; +import net.minecraft.world.World; + +import java.util.ArrayList; +import java.util.List; + +public class StructurePlacer { + private static class StructurePos { + private final int x; + private final int y; + private final int z; + private final StructurePart part; + + private StructurePos(int x, int y, int z, StructurePart part) { + this.x = x; + this.y = y; + this.z = z; + this.part = part; + } + } + + private final List pendingParts = new ArrayList<>(); + private final List parts = new ArrayList<>(); + + public StructurePlacer(StructurePart firstPart) { + pendingParts.add(new StructurePos(0, 0, 0, firstPart)); + run(); + } + + private void run() { + while (!pendingParts.isEmpty()) { + List newPendingParts = new ArrayList<>(); + for (StructurePos part : pendingParts) { + if (part.part != null) { + part.part.build((x, y, z, newPart) -> { + newPendingParts.add(new StructurePos(x + part.x, y + part.y, z + part.z, null)); + //newPendingParts.add(new StructurePos(x + part.x, y + part.y, z + part.z, newPart)); + }); + } + parts.add(part); + } + pendingParts.clear(); + pendingParts.addAll(newPendingParts); + } + } + + public void place(World world, BlockPos pos) { + for (StructurePos part : parts) { + BlockPos newPos = pos.add(part.x, part.y, part.z); + if (part.part != null) { + part.part.place(world, newPos); + } else { + world.setBlockState(newPos, Blocks.DIORITE.getDefaultState()); + } + } + } +} diff --git a/src/main/java/com/thebrokenrail/energonrelics/structure/researchcomplex/BaseResearchComplexPart.java b/src/main/java/com/thebrokenrail/energonrelics/structure/researchcomplex/BaseResearchComplexPart.java new file mode 100644 index 0000000..5ff8ef3 --- /dev/null +++ b/src/main/java/com/thebrokenrail/energonrelics/structure/researchcomplex/BaseResearchComplexPart.java @@ -0,0 +1,27 @@ +package com.thebrokenrail.energonrelics.structure.researchcomplex; + +import com.thebrokenrail.energonrelics.EnergonRelics; +import com.thebrokenrail.energonrelics.block.entity.EnergonLightBlockEntity; +import com.thebrokenrail.energonrelics.structure.StructurePart; +import net.minecraft.block.BlockState; +import net.minecraft.block.entity.BlockEntity; +import net.minecraft.util.math.BlockPos; +import net.minecraft.world.World; + +import java.util.List; + +public abstract class BaseResearchComplexPart extends StructurePart { + public BaseResearchComplexPart(ResearchComplexState state, List list) { + super(state, list); + } + + @Override + protected void handleBlockPlace(World world, BlockPos pos, BlockState state) { + if (state.getBlock() == EnergonRelics.ENERGON_LIGHT_BLOCK) { + BlockEntity entity = world.getBlockEntity(pos); + if (entity instanceof EnergonLightBlockEntity) { + ((EnergonLightBlockEntity) entity).toggle(getState().getMainNetwork()); + } + } + } +} diff --git a/src/main/java/com/thebrokenrail/energonrelics/structure/researchcomplex/ResearchComplexHallwayPart.java b/src/main/java/com/thebrokenrail/energonrelics/structure/researchcomplex/ResearchComplexHallwayPart.java new file mode 100644 index 0000000..3f9f1b9 --- /dev/null +++ b/src/main/java/com/thebrokenrail/energonrelics/structure/researchcomplex/ResearchComplexHallwayPart.java @@ -0,0 +1,42 @@ +package com.thebrokenrail.energonrelics.structure.researchcomplex; + +import com.thebrokenrail.energonrelics.structure.StructureContext; +import net.minecraft.block.BlockState; +import net.minecraft.block.Blocks; + +import java.util.List; + +public class ResearchComplexHallwayPart extends BaseResearchComplexPart { + public ResearchComplexHallwayPart(ResearchComplexState state, List list) { + super(state, list); + } + + @Override + protected int getWidth() { + return 7; + } + + @Override + protected int getHeight() { + return 6; + } + + @Override + protected int getDepth() { + return 3; + } + + @Override + protected void build(StructureContext context) { + BlockState bricks = Blocks.QUARTZ_BRICKS.getDefaultState(); + BlockState air = Blocks.AIR.getDefaultState(); + for (int y = 0; y < getHeight(); y++) { + boolean isBricks = y == 0 || y == getHeight() - 1; + BlockState state = isBricks ? bricks : air; + rect(2, y, 0, 3, 1, getDepth(), state); + if (y > 1 && y < getHeight() - 2) { + rect(0, y, 0, 1, 2, getDepth(), bricks); + } + } + } +} diff --git a/src/main/java/com/thebrokenrail/energonrelics/structure/researchcomplex/ResearchComplexStartPart.java b/src/main/java/com/thebrokenrail/energonrelics/structure/researchcomplex/ResearchComplexStartPart.java new file mode 100644 index 0000000..a5d49fb --- /dev/null +++ b/src/main/java/com/thebrokenrail/energonrelics/structure/researchcomplex/ResearchComplexStartPart.java @@ -0,0 +1,130 @@ +package com.thebrokenrail.energonrelics.structure.researchcomplex; + +import com.thebrokenrail.energonrelics.EnergonRelics; +import com.thebrokenrail.energonrelics.block.entity.reactor.ReactorControllerBlockEntity; +import com.thebrokenrail.energonrelics.config.HardcodedConfig; +import com.thebrokenrail.energonrelics.structure.StructureContext; +import net.minecraft.block.BlockState; +import net.minecraft.block.Blocks; +import net.minecraft.block.LeverBlock; +import net.minecraft.block.StairsBlock; +import net.minecraft.block.entity.BlockEntity; +import net.minecraft.block.enums.BlockHalf; +import net.minecraft.block.enums.StairShape; +import net.minecraft.block.enums.WallMountLocation; +import net.minecraft.util.math.BlockPos; +import net.minecraft.util.math.Direction; +import net.minecraft.world.World; + +import java.util.List; + +public class ResearchComplexStartPart extends BaseResearchComplexPart { + public ResearchComplexStartPart(ResearchComplexState state, List list) { + super(state, list); + } + + private void setBlockOrAir(int x, int y, int z, BlockState stairs) { + if (y == 1 || y == 4) { + set(x, y, z, stairs); + } else { + BlockState air = Blocks.AIR.getDefaultState(); + set(x, y, z, air); + } + } + + private void buildBase(int yOffset) { + BlockState bricks = Blocks.QUARTZ_BRICKS.getDefaultState(); + BlockState air = Blocks.AIR.getDefaultState(); + + BlockState state = yOffset == 0 || yOffset == 5 ? bricks : air; + + rect(4, yOffset, 0, 3, 1, getDepth(), state); + rect(0, yOffset, 4, getWidth(), 1, 3, state); + + set(2, yOffset, 3, state); + set(3, yOffset, 2, state); + set(3, yOffset, 3, state); + + if (yOffset != 0 && yOffset != 5) { + BlockState stairs = Blocks.QUARTZ_STAIRS.getDefaultState(); + + BlockHalf half = yOffset == 1 ? BlockHalf.BOTTOM : BlockHalf.TOP; + stairs = stairs.with(StairsBlock.HALF, half); + + BlockState westStairs = stairs.with(StairsBlock.FACING, Direction.WEST); + BlockState northStairs = stairs.with(StairsBlock.FACING, Direction.NORTH); + BlockState outerLeftStairs = northStairs.with(StairsBlock.SHAPE, StairShape.OUTER_LEFT); + BlockState innerLeftStairs = northStairs.with(StairsBlock.SHAPE, StairShape.INNER_LEFT); + BlockState innerRightStairs = westStairs.with(StairsBlock.SHAPE, StairShape.INNER_RIGHT); + BlockState outerRightStairs = westStairs.with(StairsBlock.SHAPE, StairShape.OUTER_RIGHT); + + setBlockOrAir(3, yOffset, 0, westStairs); + setBlockOrAir(3, yOffset, 1, outerLeftStairs); + setBlockOrAir(2, yOffset, 1, innerRightStairs); + setBlockOrAir(2, yOffset, 2, outerLeftStairs); + setBlockOrAir(1, yOffset, 2, innerLeftStairs); + setBlockOrAir(1, yOffset, 3, outerRightStairs); + setBlockOrAir(0, yOffset, 3, northStairs); + + if (yOffset != 1 && yOffset != 4) { + set(2, yOffset, 0, bricks); + set(1, yOffset, 1, bricks); + set(0, yOffset, 2, bricks); + } + } + + if (yOffset == 5) { + set(3, yOffset, 3, EnergonRelics.ENERGON_LIGHT_BLOCK.getDefaultState()); + } + } + + private void buildReactor() { + set(5, 1, 5, EnergonRelics.THERMAL_CASING_BLOCK.getDefaultState()); + set(6, 2, 5, EnergonRelics.THERMAL_CASING_BLOCK.getDefaultState()); + set(5, 2, 5, EnergonRelics.REACTOR_CORE_BLOCK.getDefaultState()); + set(4, 2, 5, EnergonRelics.THERMAL_CASING_BLOCK.getDefaultState()); + set(5, 3, 5, EnergonRelics.REACTOR_INPUT_BLOCK.getDefaultState()); + set(5, 2, 4, EnergonRelics.REACTOR_CONTROLLER_BLOCK.getDefaultState()); + set(5, 1, 4, Blocks.LEVER.getDefaultState().with(LeverBlock.FACE, WallMountLocation.FLOOR)); + set(5, 2, 6, EnergonRelics.THERMAL_GLASS_BLOCK.getDefaultState()); + } + + @Override + protected void build(StructureContext context) { + if (getState().hasEnergy(HardcodedConfig.ENERGON_LIGHT_ENERGY_REQUIRED * 4)) { + repeat(() -> { + for (int i = 0; i < 6; i++) { + buildBase(i); + } + part(context, 1, 0, getDepth(), new ResearchComplexHallwayPart(getState(), getTransformations())); + }); + buildReactor(); + } + } + + @Override + protected int getWidth() { + return 10; + } + + @Override + protected int getHeight() { + return 6; + } + + @Override + protected int getDepth() { + return 10; + } + + @Override + protected void handleBlockPlace(World world, BlockPos pos, BlockState state) { + super.handleBlockPlace(world, pos, state); + if (state.getBlock() == EnergonRelics.REACTOR_CONTROLLER_BLOCK) { + BlockEntity entity = world.getBlockEntity(pos); + if (entity instanceof ReactorControllerBlockEntity) { + ((ReactorControllerBlockEntity) entity).placeStack(EnergonRelics.NETWORK_CHIP_ITEM.create(getState().getMainNetwork())); + } + } + } +} diff --git a/src/main/java/com/thebrokenrail/energonrelics/structure/researchcomplex/ResearchComplexState.java b/src/main/java/com/thebrokenrail/energonrelics/structure/researchcomplex/ResearchComplexState.java new file mode 100644 index 0000000..b4b7f0a --- /dev/null +++ b/src/main/java/com/thebrokenrail/energonrelics/structure/researchcomplex/ResearchComplexState.java @@ -0,0 +1,35 @@ +package com.thebrokenrail.energonrelics.structure.researchcomplex; + +import com.thebrokenrail.energonrelics.component.NetworkComponent; +import com.thebrokenrail.energonrelics.config.HardcodedConfig; +import net.minecraft.server.world.ServerWorld; +import net.minecraft.util.BlockRotation; +import net.minecraft.world.World; + +public class ResearchComplexState { + private final int baseID; + private long energyBudget = HardcodedConfig.REACTOR_ENERGY_OUTPUT; + + public ResearchComplexState(World world) { + ServerWorld serverWorld = (ServerWorld) world; + NetworkComponent component = NetworkComponent.getInstance(serverWorld); + baseID = component.create(); + } + + private int getID(int id) { + return baseID + id; + } + + int getMainNetwork() { + return getID(0); + } + + boolean hasEnergy(long amount) { + if (amount <= energyBudget) { + energyBudget = energyBudget - amount; + return true; + } else { + return false; + } + } +}