e5c6ca157c
commit 053dd09df6c426ab5e570f42a1edb5df3d0fbd01 Merge: 6d1e1c71decc645eba
Author: simibubi <31564874+simibubi@users.noreply.github.com> Date: Tue May 9 18:22:42 2023 +0200 Merge branch '1.18/api' of https://github.com/Layers-of-Railways/Create into pr/4692 commitecc645eba7
Author: Rabbitminers <Rabbitminers2.0@gmail.com> Date: Tue May 9 11:24:11 2023 +0100 Implemented support for creating and removing individual blockstate models commit 6d1e1c71de7ce20f6fd9fc8ed4ed9bdd1072829a Author: simibubi <31564874+simibubi@users.noreply.github.com> Date: Tue May 9 12:16:54 2023 +0200 Less error logging when migrating old worlds commit205e47352e
Author: techno-sam <linux.techno.sam@gmail.com> Date: Mon May 8 21:02:19 2023 -0700 Fix up ItemOutline commit6cf204f6af
Merge:fe049bc77
2e3c906ce
Author: techno-sam <linux.techno.sam@gmail.com> Date: Mon May 8 20:28:56 2023 -0700 Merge remote-tracking branch 'upstream/mc1.18/dev' into 1.18/api # Conflicts: # src/main/java/com/simibubi/create/content/logistics/trains/entity/CarriageCouplingRenderer.java commitfe049bc771
Author: techno-sam <linux.techno.sam@gmail.com> Date: Mon May 8 20:26:16 2023 -0700 Revert "Revert "Rewrite outline buffering"" This reverts commit726bfaf0
commit435b4c1c16
Author: techno-sam <linux.techno.sam@gmail.com> Date: Mon May 8 20:20:23 2023 -0700 Clean up last bits of upside down rendering commit662da6bab1
Merge:122fe77af
d83285e8a
Author: techno-sam <linux.techno.sam@gmail.com> Date: Mon May 8 20:16:32 2023 -0700 Merge remote-tracking branch 'origin/1.18/api' into 1.18/api # Conflicts: # src/main/java/com/simibubi/create/content/logistics/trains/StandardBogeyRenderer.java commit122fe77afa
Author: techno-sam <linux.techno.sam@gmail.com> Date: Mon May 8 20:15:46 2023 -0700 Fix up upside down rendering commitd83285e8a4
Merge:00e953a58
cdb0ad210
Author: techno-sam <77073745+techno-sam@users.noreply.github.com> Date: Sun May 7 07:02:18 2023 -0700 Merge pull request #3 from Layers-of-Railways/1.18/bogey-api Cleanup cycle groups and unused imports commitcdb0ad210b
Author: Rabbitminers <Rabbitminers2.0@gmail.com> Date: Sun May 7 10:15:47 2023 +0100 Fixed merge artifact commit457d5f33ed
Merge:4e4e227a3
00e953a58
Author: Rabbitminers <Rabbitminers2.0@gmail.com> Date: Sun May 7 10:14:07 2023 +0100 Merge remote-tracking branch 'origin/1.18/api' into 1.18/api commit00e953a585
Merge:1e4d5504e
a7a25896c
Author: Rabbitminers <79579164+Rabbitminers@users.noreply.github.com> Date: Sun May 7 10:13:49 2023 +0100 Merge pull request #2 from Rabbitminers/mc1.18/dev Added Return Values and Small Cleanup commita7a25896c1
Merge:7622128be
1e4d5504e
Author: Rabbitminers <79579164+Rabbitminers@users.noreply.github.com> Date: Sun May 7 10:13:40 2023 +0100 Merge branch '1.18/api' into mc1.18/dev commit4e4e227a35
Author: Rabbitminers <Rabbitminers2.0@gmail.com> Date: Sun May 7 10:10:30 2023 +0100 Cleanup to cycle groups commitaa94fc97d1
Author: Rabbitminers <Rabbitminers2.0@gmail.com> Date: Sun May 7 09:50:50 2023 +0100 Removed unused import of Railways commit7622128bec
Merge:81eeadb85
d52065808
Author: Rabbitminers <79579164+Rabbitminers@users.noreply.github.com> Date: Sun May 7 09:11:59 2023 +0100 Merge branch 'Layers-of-Railways:mc1.18/dev' into mc1.18/dev commit1e4d5504ee
Author: techno-sam <linux.techno.sam@gmail.com> Date: Sat May 6 18:03:39 2023 -0700 Don't revert non-buggy changes commitb306cf2124
Author: techno-sam <linux.techno.sam@gmail.com> Date: Sat May 6 18:00:59 2023 -0700 Take materials into consideration when trains pathfind commitfca02ae4bf
Author: techno-sam <linux.techno.sam@gmail.com> Date: Sat May 6 10:25:51 2023 -0700 Add materials to track graph commit726bfaf0b5
Author: techno-sam <linux.techno.sam@gmail.com> Date: Fri May 5 21:16:49 2023 -0700 Revert "Rewrite outline buffering" This reverts commitd4106d545b
. commit171897bed2
Author: techno-sam <linux.techno.sam@gmail.com> Date: Fri May 5 20:55:25 2023 -0700 Fix up style cycling commitcbd0cf20da
Author: techno-sam <linux.techno.sam@gmail.com> Date: Fri May 5 07:32:06 2023 -0700 clean up nether portal carriage handling commitd556f08876
Author: techno-sam <linux.techno.sam@gmail.com> Date: Fri May 5 07:06:02 2023 -0700 upside down bogeys work in nether portals fixed coupling anchor offsets commitda26c0ccbf
Author: techno-sam <linux.techno.sam@gmail.com> Date: Thu May 4 09:32:53 2023 -0700 working on upside down bogeys in nether portals commit81eeadb853
Author: Rabbitminers <Rabbitminers2.0@gmail.com> Date: Mon May 1 16:15:28 2023 +0100 Small cleanup commitc7e9df973c
Author: Rabbitminers <Rabbitminers2.0@gmail.com> Date: Mon May 1 16:13:51 2023 +0100 Fixed issue raised in #1 commit2f285b6eb7
Author: techno-sam <linux.techno.sam@gmail.com> Date: Mon May 1 08:13:27 2023 -0700 add data gen commit206de01311
Merge:e91753a33
6564f4fa7
Author: techno-sam <77073745+techno-sam@users.noreply.github.com> Date: Mon May 1 06:49:21 2023 -0700 Merge pull request #1 from Rabbitminers/mc1.18/dev Bogey API commit6564f4fa73
Merge:e5d759582
e91753a33
Author: Rabbitminers <79579164+Rabbitminers@users.noreply.github.com> Date: Mon May 1 10:40:32 2023 +0100 Merge branch '1.18/api' into mc1.18/dev commite5d7595822
Author: Rabbitminers <Rabbitminers2.0@gmail.com> Date: Mon May 1 10:09:03 2023 +0100 Connected Custom Bogey Particle Types To CarriageParticles commite91753a33c
Author: techno-sam <linux.techno.sam@gmail.com> Date: Sun Apr 30 19:51:26 2023 -0700 Fix up some problems commit9815f1490f
Author: Rabbitminers <Rabbitminers2.0@gmail.com> Date: Sun Apr 30 21:12:43 2023 +0100 Implemented default data when shifting styles commitda30e78815
Author: Rabbitminers <Rabbitminers2.0@gmail.com> Date: Sun Apr 30 21:12:14 2023 +0100 Added Particles To Bogey Style (And Respective Builder) commit08c000b8ba
Author: Rabbitminers <Rabbitminers2.0@gmail.com> Date: Sun Apr 30 21:01:19 2023 +0100 Added Backup Rendering If A Size Is Not Present commit2b76e8d7b3
Author: Rabbitminers <Rabbitminers2.0@gmail.com> Date: Sun Apr 30 21:00:40 2023 +0100 Added Common Renderer To Remove Function commit411ec36f57
Author: Rabbitminers <Rabbitminers2.0@gmail.com> Date: Sun Apr 30 20:59:50 2023 +0100 Added Display Name To Standard Bogey Style commit112306d5d4
Author: Rabbitminers <Rabbitminers2.0@gmail.com> Date: Sun Apr 30 20:59:30 2023 +0100 Displayed new style name when changing betweeen them commit5634670b27
Author: Rabbitminers <Rabbitminers2.0@gmail.com> Date: Sun Apr 30 20:06:00 2023 +0100 General Cleanup commit0f7a8b7b24
Author: Rabbitminers <Rabbitminers2.0@gmail.com> Date: Sun Apr 30 20:05:50 2023 +0100 Implemented Changes To Remaining Classes commit8aedc00f96
Author: Rabbitminers <Rabbitminers2.0@gmail.com> Date: Sun Apr 30 20:02:06 2023 +0100 Removed Bogey Style Handling From Registrate commitedf8079abf
Author: Rabbitminers <Rabbitminers2.0@gmail.com> Date: Sun Apr 30 20:01:40 2023 +0100 Removed Unused Registry Handling commit6a185c4e72
Author: Rabbitminers <Rabbitminers2.0@gmail.com> Date: Sun Apr 30 20:01:16 2023 +0100 Refactored Bogey Sizes commite10d07ddc3
Author: Rabbitminers <Rabbitminers2.0@gmail.com> Date: Sun Apr 30 20:01:00 2023 +0100 Overhauled Bogey Style commit74d98a2ad5
Merge:e629d02f5
4ebcf8201
Author: techno-sam <77073745+techno-sam@users.noreply.github.com> Date: Sun Apr 23 07:16:33 2023 -0700 Merge branch 'Creators-of-Create:mc1.18/dev' into 1.18/api commite629d02f50
Author: techno-sam <linux.techno.sam@gmail.com> Date: Sun Apr 9 07:18:22 2023 -0700 Track API Clean up code a bit commitd9ce6ce995
Author: techno-sam <linux.techno.sam@gmail.com> Date: Sun Apr 9 07:14:46 2023 -0700 Track API? Fix placement commit7fbf08ba54
Author: techno-sam <linux.techno.sam@gmail.com> Date: Sat Apr 8 11:11:24 2023 -0700 Track API? Fix up some placement issues commit35644f1434
Author: techno-sam <linux.techno.sam@gmail.com> Date: Sat Apr 8 08:11:13 2023 -0700 Track API maybe? Datagen Seems to be working commitf7c56b867a
Author: techno-sam <linux.techno.sam@gmail.com> Date: Thu Apr 6 21:24:31 2023 -0700 Track API maybe? Fix build - broken generic Not yet tested, but it is progress commit2a59fd7e8a
Author: techno-sam <linux.techno.sam@gmail.com> Date: Thu Apr 6 21:13:54 2023 -0700 Track API maybe? Not yet tested, but it is progress commit5ba30d6a85
Merge:e4e5ac1c4
c2977bbff
Author: techno-sam <77073745+techno-sam@users.noreply.github.com> Date: Thu Apr 6 17:10:39 2023 -0700 Merge branch 'Creators-of-Create:mc1.18/dev' into 1.18/api commitd52065808c
Merge:e4e5ac1c4
c2977bbff
Author: techno-sam <77073745+techno-sam@users.noreply.github.com> Date: Thu Apr 6 17:10:26 2023 -0700 Merge branch 'Creators-of-Create:mc1.18/dev' into mc1.18/dev commit53240bd42f
Author: Rabbitminers <Rabbitminers2.0@gmail.com> Date: Mon Apr 3 21:42:29 2023 +0100 Corrected Bogey InteractionResult To Pass commit69326e361a
Author: Rabbitminers <Rabbitminers2.0@gmail.com> Date: Mon Apr 3 21:30:28 2023 +0100 Fixed Default Values When Used Styles Are Removed commit4f176979de
Author: Rabbitminers <Rabbitminers2.0@gmail.com> Date: Mon Apr 3 19:33:17 2023 +0100 Fixed Carriage Sounds (Again) commit1e80af3303
Author: Rabbitminers <Rabbitminers2.0@gmail.com> Date: Mon Apr 3 19:27:58 2023 +0100 Refactored Bogey Sizes To Seperate Class commit129be61fee
Author: Rabbitminers <Rabbitminers2.0@gmail.com> Date: Mon Apr 3 17:20:17 2023 +0100 Fixed Bogey Sound Loading commit2543185a55
Author: Rabbitminers <Rabbitminers2.0@gmail.com> Date: Mon Apr 3 09:45:23 2023 +0100 Added Bogey Sound Customisation commit1ad5ae9514
Author: Rabbitminers <Rabbitminers2.0@gmail.com> Date: Mon Apr 3 00:44:53 2023 +0100 Added Size Transforms If Size Is Not Available For New Style commit96566b1614
Author: Rabbitminers <Rabbitminers2.0@gmail.com> Date: Sun Apr 2 23:02:02 2023 +0100 Moved Bogey Style Inside Of Bogey Data And Implemented Bogey Data Communication commiteedd984738
Author: Rabbitminers <Rabbitminers2.0@gmail.com> Date: Sun Apr 2 16:53:55 2023 +0100 Fixed Large Bogey Size commit68ca0974c6
Author: Rabbitminers <Rabbitminers2.0@gmail.com> Date: Sun Apr 2 16:47:58 2023 +0100 Implemented Style Cycling & Default Values commita55ba4267a
Author: Rabbitminers <Rabbitminers2.0@gmail.com> Date: Sun Apr 2 16:46:15 2023 +0100 Implemented renderer instance creator commit43523302c2
Author: Rabbitminers <Rabbitminers2.0@gmail.com> Date: Sun Apr 2 16:45:33 2023 +0100 Removed Unused Standard Bogey Instance commit773e084422
Merge:0c0b5a1ed
d1e1f7ec5
Author: Rabbitminers <Rabbitminers2.0@gmail.com> Date: Sat Apr 1 18:50:15 2023 +0100 Merge remote-tracking branch 'origin/mc1.18/dev' into mc1.18/dev # Conflicts: # src/main/java/com/simibubi/create/AllBogeyStyles.java # src/main/java/com/simibubi/create/content/logistics/trains/BogeyTileEntityRenderer.java # src/main/java/com/simibubi/create/content/logistics/trains/entity/BogeyStyle.java # src/main/java/com/simibubi/create/content/logistics/trains/entity/CarriageContraptionEntityRenderer.java # src/main/java/com/simibubi/create/content/logistics/trains/entity/StandardBogeyInstance.java # src/main/java/com/simibubi/create/foundation/data/BogeyStyleBuilder.java commit0c0b5a1ed6
Author: Rabbitminers <Rabbitminers2.0@gmail.com> Date: Sat Apr 1 18:39:58 2023 +0100 Linked Style Registry To Bogey Blocks commit71f839ee51
Author: Rabbitminers <Rabbitminers2.0@gmail.com> Date: Sat Apr 1 18:39:03 2023 +0100 Replaced size boolean with direct use of size enum commit50ff081704
Author: Rabbitminers <Rabbitminers2.0@gmail.com> Date: Thu Mar 30 18:47:13 2023 +0100 Added Resource Location To NBT helper methods commitd1e1f7ec5a
Author: Rabbitminers <Rabbitminers2.0@gmail.com> Date: Thu Mar 30 18:47:13 2023 +0100 Re-worked BogeyStyles commitda593fccb1
Author: Rabbitminers <Rabbitminers2.0@gmail.com> Date: Thu Mar 30 18:46:02 2023 +0100 Refactored IBogeyBlock to AbstractBogeyBlock and extracted relevant StandardBogeyBlock implementations commit17432c9113
Author: Rabbitminers <Rabbitminers2.0@gmail.com> Date: Sat Mar 25 10:20:50 2023 +0000 Fixed Incorrect Registry Loading commitc7d899369a
Author: Rabbitminers <Rabbitminers2.0@gmail.com> Date: Fri Mar 24 23:44:03 2023 +0000 Registered Registers commit6d862290d7
Author: Rabbitminers <Rabbitminers2.0@gmail.com> Date: Fri Mar 24 23:43:23 2023 +0000 Added BogeyStyleBuilder To Registrate commit3dfb9e3b3b
Author: Rabbitminers <Rabbitminers2.0@gmail.com> Date: Fri Mar 24 23:43:08 2023 +0000 Implemented AllBogeyStyles commitc9e71b462d
Author: Rabbitminers <Rabbitminers2.0@gmail.com> Date: Fri Mar 24 23:42:56 2023 +0000 Created BogeyStyleBuilder commita90977d642
Author: Rabbitminers <Rabbitminers2.0@gmail.com> Date: Fri Mar 24 23:42:25 2023 +0000 Created AllRegistries and BogeyStyle Registry commit154d455f3f
Author: Rabbitminers <Rabbitminers2.0@gmail.com> Date: Fri Mar 24 23:41:56 2023 +0000 Added BogeyStyle Wrapper commitdfb7640bfc
Author: Rabbitminers <Rabbitminers2.0@gmail.com> Date: Thu Mar 23 18:50:41 2023 +0000 Removed left over logging statement commit9920536cc3
Author: Rabbitminers <Rabbitminers2.0@gmail.com> Date: Thu Mar 23 18:50:18 2023 +0000 Implemented Secondary Shaft To Large Renderer commit6cd40cc6f9
Author: Rabbitminers <Rabbitminers2.0@gmail.com> Date: Thu Mar 23 18:49:56 2023 +0000 Prevented Overwrite When Using Two BlockStates Of The Same Type With Different Properties commit06fb901144
Author: Rabbitminers <Rabbitminers2.0@gmail.com> Date: Thu Mar 23 18:39:11 2023 +0000 Implemented Common Rendering For StandardBogeyRenderer commit435b0f8266
Author: Rabbitminers <Rabbitminers2.0@gmail.com> Date: Thu Mar 23 18:38:40 2023 +0000 Added Common Renderer commit96a0623dab
Author: Rabbitminers <Rabbitminers2.0@gmail.com> Date: Thu Mar 23 18:38:29 2023 +0000 Implemented BlockState Models For Rendering commit469d9d592b
Author: Rabbitminers <Rabbitminers2.0@gmail.com> Date: Thu Mar 23 17:42:28 2023 +0000 Added Standard Bogey Instance (Might be redundant) commit2661d260d8
Author: Rabbitminers <Rabbitminers2.0@gmail.com> Date: Thu Mar 23 17:42:06 2023 +0000 Refactored Changes To Existing Methods commit9ded16fbab
Author: Rabbitminers <Rabbitminers2.0@gmail.com> Date: Thu Mar 23 17:41:15 2023 +0000 Integrated BogeyRenderer To BogeyInstance (Also Corrected Rendering In Contraption) commit4a82fcbca1
Author: Rabbitminers <Rabbitminers2.0@gmail.com> Date: Thu Mar 23 17:40:13 2023 +0000 Implemented Changes To StandardBogeyBlock commit7238fb93f3
Author: Rabbitminers <Rabbitminers2.0@gmail.com> Date: Thu Mar 23 17:39:51 2023 +0000 Added Renderer To IBogeyBlock commitded4c1f613
Merge:91727cc84
3c02fe6ec
Author: Rabbitminers <Rabbitminers2.0@gmail.com> Date: Wed Mar 22 17:03:37 2023 +0000 Merge remote-tracking branch 'origin/mc1.18/dev' into mc1.18/dev commit91727cc84a
Author: Rabbitminers <Rabbitminers2.0@gmail.com> Date: Wed Mar 22 17:03:28 2023 +0000 Implemented Model Data Initializer to StandardBogeyRenderer commit6d98a1f469
Author: Rabbitminers <Rabbitminers2.0@gmail.com> Date: Wed Mar 22 17:03:00 2023 +0000 Added Contraption Model Instance Initializer commit3c02fe6ecc
Author: Rabbitminers <79579164+Rabbitminers@users.noreply.github.com> Date: Tue Mar 21 22:45:34 2023 +0000 Added missing render type check commit6672c49649
Author: Rabbitminers <Rabbitminers2.0@gmail.com> Date: Tue Mar 21 22:37:36 2023 +0000 Re-created standard bogey with test api commita8a9491fa0
Author: Rabbitminers <Rabbitminers2.0@gmail.com> Date: Tue Mar 21 22:34:54 2023 +0000 Implemented Proof Of Concept Generic Bogey Renderer commite4e5ac1c40
Author: SpottyTheTurtle <69260662+SpottyTheTurtle@users.noreply.github.com> Date: Sat Mar 11 21:34:59 2023 +0000 init
1353 lines
50 KiB
Java
1353 lines
50 KiB
Java
package com.simibubi.create.content.contraptions.components.structureMovement;
|
|
|
|
import static com.simibubi.create.content.contraptions.components.structureMovement.piston.MechanicalPistonBlock.isExtensionPole;
|
|
import static com.simibubi.create.content.contraptions.components.structureMovement.piston.MechanicalPistonBlock.isPistonHead;
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.Collection;
|
|
import java.util.HashMap;
|
|
import java.util.HashSet;
|
|
import java.util.Iterator;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
import java.util.Map.Entry;
|
|
import java.util.Objects;
|
|
import java.util.Optional;
|
|
import java.util.Queue;
|
|
import java.util.Set;
|
|
import java.util.UUID;
|
|
import java.util.concurrent.CompletableFuture;
|
|
import java.util.function.BiConsumer;
|
|
|
|
import javax.annotation.Nullable;
|
|
|
|
import org.apache.commons.lang3.tuple.MutablePair;
|
|
import org.apache.commons.lang3.tuple.Pair;
|
|
|
|
import com.simibubi.create.AllBlocks;
|
|
import com.simibubi.create.AllInteractionBehaviours;
|
|
import com.simibubi.create.AllMovementBehaviours;
|
|
import com.simibubi.create.AllTileEntities;
|
|
import com.simibubi.create.content.contraptions.base.IRotate;
|
|
import com.simibubi.create.content.contraptions.base.KineticTileEntity;
|
|
import com.simibubi.create.content.contraptions.components.actors.BlockBreakingMovementBehaviour;
|
|
import com.simibubi.create.content.contraptions.components.actors.HarvesterMovementBehaviour;
|
|
import com.simibubi.create.content.contraptions.components.actors.SeatBlock;
|
|
import com.simibubi.create.content.contraptions.components.actors.SeatEntity;
|
|
import com.simibubi.create.content.contraptions.components.steam.PoweredShaftTileEntity;
|
|
import com.simibubi.create.content.contraptions.components.structureMovement.bearing.MechanicalBearingBlock;
|
|
import com.simibubi.create.content.contraptions.components.structureMovement.bearing.StabilizedContraption;
|
|
import com.simibubi.create.content.contraptions.components.structureMovement.bearing.WindmillBearingBlock;
|
|
import com.simibubi.create.content.contraptions.components.structureMovement.bearing.WindmillBearingTileEntity;
|
|
import com.simibubi.create.content.contraptions.components.structureMovement.chassis.AbstractChassisBlock;
|
|
import com.simibubi.create.content.contraptions.components.structureMovement.chassis.ChassisTileEntity;
|
|
import com.simibubi.create.content.contraptions.components.structureMovement.chassis.StickerBlock;
|
|
import com.simibubi.create.content.contraptions.components.structureMovement.gantry.GantryCarriageBlock;
|
|
import com.simibubi.create.content.contraptions.components.structureMovement.glue.SuperGlueEntity;
|
|
import com.simibubi.create.content.contraptions.components.structureMovement.interaction.controls.ControlsBlock;
|
|
import com.simibubi.create.content.contraptions.components.structureMovement.piston.MechanicalPistonBlock;
|
|
import com.simibubi.create.content.contraptions.components.structureMovement.piston.MechanicalPistonBlock.PistonState;
|
|
import com.simibubi.create.content.contraptions.components.structureMovement.piston.MechanicalPistonHeadBlock;
|
|
import com.simibubi.create.content.contraptions.components.structureMovement.piston.PistonExtensionPoleBlock;
|
|
import com.simibubi.create.content.contraptions.components.structureMovement.pulley.PulleyBlock;
|
|
import com.simibubi.create.content.contraptions.components.structureMovement.pulley.PulleyBlock.MagnetBlock;
|
|
import com.simibubi.create.content.contraptions.components.structureMovement.pulley.PulleyBlock.RopeBlock;
|
|
import com.simibubi.create.content.contraptions.components.structureMovement.pulley.PulleyTileEntity;
|
|
import com.simibubi.create.content.contraptions.components.structureMovement.render.ContraptionLighter;
|
|
import com.simibubi.create.content.contraptions.components.structureMovement.render.EmptyLighter;
|
|
import com.simibubi.create.content.contraptions.fluids.tank.FluidTankTileEntity;
|
|
import com.simibubi.create.content.contraptions.relays.advanced.GantryShaftBlock;
|
|
import com.simibubi.create.content.contraptions.relays.belt.BeltBlock;
|
|
import com.simibubi.create.content.contraptions.relays.elementary.ShaftBlock;
|
|
import com.simibubi.create.content.curiosities.deco.SlidingDoorBlock;
|
|
import com.simibubi.create.content.logistics.block.inventories.CreativeCrateTileEntity;
|
|
import com.simibubi.create.content.logistics.block.redstone.RedstoneContactBlock;
|
|
import com.simibubi.create.content.logistics.block.vault.ItemVaultTileEntity;
|
|
import com.simibubi.create.content.logistics.trains.AbstractBogeyBlock;
|
|
import com.simibubi.create.foundation.config.AllConfigs;
|
|
import com.simibubi.create.foundation.tileEntity.IMultiTileContainer;
|
|
import com.simibubi.create.foundation.tileEntity.behaviour.filtering.FilteringBehaviour;
|
|
import com.simibubi.create.foundation.utility.BBHelper;
|
|
import com.simibubi.create.foundation.utility.BlockFace;
|
|
import com.simibubi.create.foundation.utility.BlockHelper;
|
|
import com.simibubi.create.foundation.utility.ICoordinate;
|
|
import com.simibubi.create.foundation.utility.Iterate;
|
|
import com.simibubi.create.foundation.utility.NBTHelper;
|
|
import com.simibubi.create.foundation.utility.NBTProcessors;
|
|
import com.simibubi.create.foundation.utility.UniqueLinkedList;
|
|
|
|
import net.minecraft.core.BlockPos;
|
|
import net.minecraft.core.Direction;
|
|
import net.minecraft.core.Direction.Axis;
|
|
import net.minecraft.nbt.CompoundTag;
|
|
import net.minecraft.nbt.ListTag;
|
|
import net.minecraft.nbt.NbtUtils;
|
|
import net.minecraft.nbt.Tag;
|
|
import net.minecraft.network.protocol.game.DebugPackets;
|
|
import net.minecraft.server.level.ServerLevel;
|
|
import net.minecraft.world.entity.Entity;
|
|
import net.minecraft.world.entity.ai.village.poi.PoiType;
|
|
import net.minecraft.world.level.Level;
|
|
import net.minecraft.world.level.LevelAccessor;
|
|
import net.minecraft.world.level.block.Block;
|
|
import net.minecraft.world.level.block.Blocks;
|
|
import net.minecraft.world.level.block.ButtonBlock;
|
|
import net.minecraft.world.level.block.ChestBlock;
|
|
import net.minecraft.world.level.block.DoorBlock;
|
|
import net.minecraft.world.level.block.PressurePlateBlock;
|
|
import net.minecraft.world.level.block.Rotation;
|
|
import net.minecraft.world.level.block.SimpleWaterloggedBlock;
|
|
import net.minecraft.world.level.block.entity.BlockEntity;
|
|
import net.minecraft.world.level.block.state.BlockState;
|
|
import net.minecraft.world.level.block.state.properties.BlockStateProperties;
|
|
import net.minecraft.world.level.block.state.properties.ChestType;
|
|
import net.minecraft.world.level.block.state.properties.PistonType;
|
|
import net.minecraft.world.level.chunk.HashMapPalette;
|
|
import net.minecraft.world.level.levelgen.structure.BoundingBox;
|
|
import net.minecraft.world.level.levelgen.structure.templatesystem.StructureTemplate.StructureBlockInfo;
|
|
import net.minecraft.world.level.material.FluidState;
|
|
import net.minecraft.world.level.material.Fluids;
|
|
import net.minecraft.world.level.material.PushReaction;
|
|
import net.minecraft.world.phys.AABB;
|
|
import net.minecraft.world.phys.Vec3;
|
|
import net.minecraft.world.phys.shapes.BooleanOp;
|
|
import net.minecraft.world.phys.shapes.CollisionContext;
|
|
import net.minecraft.world.phys.shapes.Shapes;
|
|
import net.minecraft.world.phys.shapes.VoxelShape;
|
|
import net.minecraftforge.api.distmarker.Dist;
|
|
import net.minecraftforge.api.distmarker.OnlyIn;
|
|
import net.minecraftforge.client.model.data.IModelData;
|
|
import net.minecraftforge.fluids.FluidStack;
|
|
import net.minecraftforge.fluids.capability.IFluidHandler;
|
|
import net.minecraftforge.items.IItemHandlerModifiable;
|
|
import net.minecraftforge.items.wrapper.CombinedInvWrapper;
|
|
import net.minecraftforge.registries.GameData;
|
|
|
|
public abstract class Contraption {
|
|
|
|
public Optional<List<AABB>> simplifiedEntityColliders;
|
|
public AbstractContraptionEntity entity;
|
|
|
|
public AABB bounds;
|
|
public BlockPos anchor;
|
|
public boolean stalled;
|
|
public boolean hasUniversalCreativeCrate;
|
|
public boolean disassembled;
|
|
|
|
protected Map<BlockPos, StructureBlockInfo> blocks;
|
|
protected List<MutablePair<StructureBlockInfo, MovementContext>> actors;
|
|
protected Map<BlockPos, MovingInteractionBehaviour> interactors;
|
|
protected List<AABB> superglue;
|
|
protected List<BlockPos> seats;
|
|
protected Map<UUID, Integer> seatMapping;
|
|
protected Map<UUID, BlockFace> stabilizedSubContraptions;
|
|
protected MountedStorageManager storage;
|
|
|
|
private Set<SuperGlueEntity> glueToRemove;
|
|
private Map<BlockPos, Entity> initialPassengers;
|
|
private List<BlockFace> pendingSubContraptions;
|
|
|
|
private CompletableFuture<Void> simplifiedEntityColliderProvider;
|
|
|
|
// Client
|
|
public Map<BlockPos, IModelData> modelData;
|
|
public Map<BlockPos, BlockEntity> presentTileEntities;
|
|
public List<BlockEntity> maybeInstancedTileEntities;
|
|
public List<BlockEntity> specialRenderedTileEntities;
|
|
|
|
protected ContraptionWorld world;
|
|
public boolean deferInvalidate;
|
|
|
|
public Contraption() {
|
|
blocks = new HashMap<>();
|
|
seats = new ArrayList<>();
|
|
actors = new ArrayList<>();
|
|
modelData = new HashMap<>();
|
|
interactors = new HashMap<>();
|
|
superglue = new ArrayList<>();
|
|
seatMapping = new HashMap<>();
|
|
glueToRemove = new HashSet<>();
|
|
initialPassengers = new HashMap<>();
|
|
presentTileEntities = new HashMap<>();
|
|
maybeInstancedTileEntities = new ArrayList<>();
|
|
specialRenderedTileEntities = new ArrayList<>();
|
|
pendingSubContraptions = new ArrayList<>();
|
|
stabilizedSubContraptions = new HashMap<>();
|
|
simplifiedEntityColliders = Optional.empty();
|
|
storage = new MountedStorageManager();
|
|
}
|
|
|
|
public ContraptionWorld getContraptionWorld() {
|
|
if (world == null)
|
|
world = new ContraptionWorld(entity.level, this);
|
|
return world;
|
|
}
|
|
|
|
public abstract boolean assemble(Level world, BlockPos pos) throws AssemblyException;
|
|
|
|
public abstract boolean canBeStabilized(Direction facing, BlockPos localPos);
|
|
|
|
protected abstract ContraptionType getType();
|
|
|
|
protected boolean customBlockPlacement(LevelAccessor world, BlockPos pos, BlockState state) {
|
|
return false;
|
|
}
|
|
|
|
protected boolean customBlockRemoval(LevelAccessor world, BlockPos pos, BlockState state) {
|
|
return false;
|
|
}
|
|
|
|
protected boolean addToInitialFrontier(Level world, BlockPos pos, Direction forcedDirection,
|
|
Queue<BlockPos> frontier) throws AssemblyException {
|
|
return true;
|
|
}
|
|
|
|
public static Contraption fromNBT(Level world, CompoundTag nbt, boolean spawnData) {
|
|
String type = nbt.getString("Type");
|
|
Contraption contraption = ContraptionType.fromType(type);
|
|
contraption.readNBT(world, nbt, spawnData);
|
|
contraption.world = new ContraptionWorld(world, contraption);
|
|
contraption.gatherBBsOffThread();
|
|
return contraption;
|
|
}
|
|
|
|
public boolean searchMovedStructure(Level world, BlockPos pos, @Nullable Direction forcedDirection)
|
|
throws AssemblyException {
|
|
initialPassengers.clear();
|
|
Queue<BlockPos> frontier = new UniqueLinkedList<>();
|
|
Set<BlockPos> visited = new HashSet<>();
|
|
anchor = pos;
|
|
|
|
if (bounds == null)
|
|
bounds = new AABB(BlockPos.ZERO);
|
|
|
|
if (!BlockMovementChecks.isBrittle(world.getBlockState(pos)))
|
|
frontier.add(pos);
|
|
if (!addToInitialFrontier(world, pos, forcedDirection, frontier))
|
|
return false;
|
|
for (int limit = 100000; limit > 0; limit--) {
|
|
if (frontier.isEmpty())
|
|
return true;
|
|
if (!moveBlock(world, forcedDirection, frontier, visited))
|
|
return false;
|
|
}
|
|
throw AssemblyException.structureTooLarge();
|
|
}
|
|
|
|
public void onEntityCreated(AbstractContraptionEntity entity) {
|
|
this.entity = entity;
|
|
|
|
// Create subcontraptions
|
|
for (BlockFace blockFace : pendingSubContraptions) {
|
|
Direction face = blockFace.getFace();
|
|
StabilizedContraption subContraption = new StabilizedContraption(face);
|
|
Level world = entity.level;
|
|
BlockPos pos = blockFace.getPos();
|
|
try {
|
|
if (!subContraption.assemble(world, pos))
|
|
continue;
|
|
} catch (AssemblyException e) {
|
|
continue;
|
|
}
|
|
subContraption.removeBlocksFromWorld(world, BlockPos.ZERO);
|
|
OrientedContraptionEntity movedContraption = OrientedContraptionEntity.create(world, subContraption, face);
|
|
BlockPos anchor = blockFace.getConnectedPos();
|
|
movedContraption.setPos(anchor.getX() + .5f, anchor.getY(), anchor.getZ() + .5f);
|
|
world.addFreshEntity(movedContraption);
|
|
stabilizedSubContraptions.put(movedContraption.getUUID(), new BlockFace(toLocalPos(pos), face));
|
|
}
|
|
|
|
storage.createHandlers();
|
|
gatherBBsOffThread();
|
|
}
|
|
|
|
public void onEntityRemoved(AbstractContraptionEntity entity) {
|
|
if (simplifiedEntityColliderProvider != null) {
|
|
simplifiedEntityColliderProvider.cancel(false);
|
|
simplifiedEntityColliderProvider = null;
|
|
}
|
|
}
|
|
|
|
public void onEntityInitialize(Level world, AbstractContraptionEntity contraptionEntity) {
|
|
if (world.isClientSide)
|
|
return;
|
|
|
|
for (OrientedContraptionEntity orientedCE : world.getEntitiesOfClass(OrientedContraptionEntity.class,
|
|
contraptionEntity.getBoundingBox()
|
|
.inflate(1)))
|
|
if (stabilizedSubContraptions.containsKey(orientedCE.getUUID()))
|
|
orientedCE.startRiding(contraptionEntity);
|
|
|
|
for (BlockPos seatPos : getSeats()) {
|
|
Entity passenger = initialPassengers.get(seatPos);
|
|
if (passenger == null)
|
|
continue;
|
|
int seatIndex = getSeats().indexOf(seatPos);
|
|
if (seatIndex == -1)
|
|
continue;
|
|
contraptionEntity.addSittingPassenger(passenger, seatIndex);
|
|
}
|
|
}
|
|
|
|
/** move the first block in frontier queue */
|
|
protected boolean moveBlock(Level world, @Nullable Direction forcedDirection, Queue<BlockPos> frontier,
|
|
Set<BlockPos> visited) throws AssemblyException {
|
|
BlockPos pos = frontier.poll();
|
|
if (pos == null)
|
|
return false;
|
|
visited.add(pos);
|
|
|
|
if (world.isOutsideBuildHeight(pos))
|
|
return true;
|
|
if (!world.isLoaded(pos))
|
|
throw AssemblyException.unloadedChunk(pos);
|
|
if (isAnchoringBlockAt(pos))
|
|
return true;
|
|
BlockState state = world.getBlockState(pos);
|
|
if (!BlockMovementChecks.isMovementNecessary(state, world, pos))
|
|
return true;
|
|
if (!movementAllowed(state, world, pos))
|
|
throw AssemblyException.unmovableBlock(pos, state);
|
|
if (state.getBlock() instanceof AbstractChassisBlock
|
|
&& !moveChassis(world, pos, forcedDirection, frontier, visited))
|
|
return false;
|
|
|
|
if (AllBlocks.BELT.has(state))
|
|
moveBelt(pos, frontier, visited, state);
|
|
|
|
if (AllBlocks.WINDMILL_BEARING.has(state) && world.getBlockEntity(pos)instanceof WindmillBearingTileEntity wbte)
|
|
wbte.disassembleForMovement();
|
|
|
|
if (AllBlocks.GANTRY_CARRIAGE.has(state))
|
|
moveGantryPinion(world, pos, frontier, visited, state);
|
|
|
|
if (AllBlocks.GANTRY_SHAFT.has(state))
|
|
moveGantryShaft(world, pos, frontier, visited, state);
|
|
|
|
if (AllBlocks.STICKER.has(state) && state.getValue(StickerBlock.EXTENDED)) {
|
|
Direction offset = state.getValue(StickerBlock.FACING);
|
|
BlockPos attached = pos.relative(offset);
|
|
if (!visited.contains(attached)
|
|
&& !BlockMovementChecks.isNotSupportive(world.getBlockState(attached), offset.getOpposite()))
|
|
frontier.add(attached);
|
|
}
|
|
|
|
// Double Chest halves stick together
|
|
if (state.hasProperty(ChestBlock.TYPE) && state.hasProperty(ChestBlock.FACING)
|
|
&& state.getValue(ChestBlock.TYPE) != ChestType.SINGLE) {
|
|
Direction offset = ChestBlock.getConnectedDirection(state);
|
|
BlockPos attached = pos.relative(offset);
|
|
if (!visited.contains(attached))
|
|
frontier.add(attached);
|
|
}
|
|
|
|
// Bogeys tend to have sticky sides
|
|
if (state.getBlock()instanceof AbstractBogeyBlock<?> bogey)
|
|
for (Direction d : bogey.getStickySurfaces(world, pos, state))
|
|
if (!visited.contains(pos.relative(d)))
|
|
frontier.add(pos.relative(d));
|
|
|
|
// Bearings potentially create stabilized sub-contraptions
|
|
if (AllBlocks.MECHANICAL_BEARING.has(state))
|
|
moveBearing(pos, frontier, visited, state);
|
|
|
|
// WM Bearings attach their structure when moved
|
|
if (AllBlocks.WINDMILL_BEARING.has(state))
|
|
moveWindmillBearing(pos, frontier, visited, state);
|
|
|
|
// Seats transfer their passenger to the contraption
|
|
if (state.getBlock() instanceof SeatBlock)
|
|
moveSeat(world, pos);
|
|
|
|
// Pulleys drag their rope and their attached structure
|
|
if (state.getBlock() instanceof PulleyBlock)
|
|
movePulley(world, pos, frontier, visited);
|
|
|
|
// Pistons drag their attaches poles and extension
|
|
if (state.getBlock() instanceof MechanicalPistonBlock)
|
|
if (!moveMechanicalPiston(world, pos, frontier, visited, state))
|
|
return false;
|
|
if (isExtensionPole(state))
|
|
movePistonPole(world, pos, frontier, visited, state);
|
|
if (isPistonHead(state))
|
|
movePistonHead(world, pos, frontier, visited, state);
|
|
|
|
// Cart assemblers attach themselves
|
|
BlockPos posDown = pos.below();
|
|
BlockState stateBelow = world.getBlockState(posDown);
|
|
if (!visited.contains(posDown) && AllBlocks.CART_ASSEMBLER.has(stateBelow))
|
|
frontier.add(posDown);
|
|
|
|
// Slime blocks and super glue drag adjacent blocks if possible
|
|
for (Direction offset : Iterate.directions) {
|
|
BlockPos offsetPos = pos.relative(offset);
|
|
BlockState blockState = world.getBlockState(offsetPos);
|
|
if (isAnchoringBlockAt(offsetPos))
|
|
continue;
|
|
if (!movementAllowed(blockState, world, offsetPos)) {
|
|
if (offset == forcedDirection)
|
|
throw AssemblyException.unmovableBlock(pos, state);
|
|
continue;
|
|
}
|
|
|
|
boolean wasVisited = visited.contains(offsetPos);
|
|
boolean faceHasGlue = SuperGlueEntity.isGlued(world, pos, offset, glueToRemove);
|
|
boolean blockAttachedTowardsFace =
|
|
BlockMovementChecks.isBlockAttachedTowards(blockState, world, offsetPos, offset.getOpposite());
|
|
boolean brittle = BlockMovementChecks.isBrittle(blockState);
|
|
boolean canStick = !brittle && state.canStickTo(blockState) && blockState.canStickTo(state);
|
|
if (canStick) {
|
|
if (state.getPistonPushReaction() == PushReaction.PUSH_ONLY
|
|
|| blockState.getPistonPushReaction() == PushReaction.PUSH_ONLY) {
|
|
canStick = false;
|
|
}
|
|
if (BlockMovementChecks.isNotSupportive(state, offset)) {
|
|
canStick = false;
|
|
}
|
|
if (BlockMovementChecks.isNotSupportive(blockState, offset.getOpposite())) {
|
|
canStick = false;
|
|
}
|
|
}
|
|
|
|
if (!wasVisited && (canStick || blockAttachedTowardsFace || faceHasGlue
|
|
|| (offset == forcedDirection && !BlockMovementChecks.isNotSupportive(state, forcedDirection))))
|
|
frontier.add(offsetPos);
|
|
}
|
|
|
|
addBlock(pos, capture(world, pos));
|
|
if (blocks.size() <= AllConfigs.SERVER.kinetics.maxBlocksMoved.get())
|
|
return true;
|
|
else
|
|
throw AssemblyException.structureTooLarge();
|
|
}
|
|
|
|
protected void movePistonHead(Level world, BlockPos pos, Queue<BlockPos> frontier, Set<BlockPos> visited,
|
|
BlockState state) {
|
|
Direction direction = state.getValue(MechanicalPistonHeadBlock.FACING);
|
|
BlockPos offset = pos.relative(direction.getOpposite());
|
|
if (!visited.contains(offset)) {
|
|
BlockState blockState = world.getBlockState(offset);
|
|
if (isExtensionPole(blockState) && blockState.getValue(PistonExtensionPoleBlock.FACING)
|
|
.getAxis() == direction.getAxis())
|
|
frontier.add(offset);
|
|
if (blockState.getBlock() instanceof MechanicalPistonBlock) {
|
|
Direction pistonFacing = blockState.getValue(MechanicalPistonBlock.FACING);
|
|
if (pistonFacing == direction
|
|
&& blockState.getValue(MechanicalPistonBlock.STATE) == PistonState.EXTENDED)
|
|
frontier.add(offset);
|
|
}
|
|
}
|
|
if (state.getValue(MechanicalPistonHeadBlock.TYPE) == PistonType.STICKY) {
|
|
BlockPos attached = pos.relative(direction);
|
|
if (!visited.contains(attached))
|
|
frontier.add(attached);
|
|
}
|
|
}
|
|
|
|
protected void movePistonPole(Level world, BlockPos pos, Queue<BlockPos> frontier, Set<BlockPos> visited,
|
|
BlockState state) {
|
|
for (Direction d : Iterate.directionsInAxis(state.getValue(PistonExtensionPoleBlock.FACING)
|
|
.getAxis())) {
|
|
BlockPos offset = pos.relative(d);
|
|
if (!visited.contains(offset)) {
|
|
BlockState blockState = world.getBlockState(offset);
|
|
if (isExtensionPole(blockState) && blockState.getValue(PistonExtensionPoleBlock.FACING)
|
|
.getAxis() == d.getAxis())
|
|
frontier.add(offset);
|
|
if (isPistonHead(blockState) && blockState.getValue(MechanicalPistonHeadBlock.FACING)
|
|
.getAxis() == d.getAxis())
|
|
frontier.add(offset);
|
|
if (blockState.getBlock() instanceof MechanicalPistonBlock) {
|
|
Direction pistonFacing = blockState.getValue(MechanicalPistonBlock.FACING);
|
|
if (pistonFacing == d || pistonFacing == d.getOpposite()
|
|
&& blockState.getValue(MechanicalPistonBlock.STATE) == PistonState.EXTENDED)
|
|
frontier.add(offset);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
protected void moveGantryPinion(Level world, BlockPos pos, Queue<BlockPos> frontier, Set<BlockPos> visited,
|
|
BlockState state) {
|
|
BlockPos offset = pos.relative(state.getValue(GantryCarriageBlock.FACING));
|
|
if (!visited.contains(offset))
|
|
frontier.add(offset);
|
|
Axis rotationAxis = ((IRotate) state.getBlock()).getRotationAxis(state);
|
|
for (Direction d : Iterate.directionsInAxis(rotationAxis)) {
|
|
offset = pos.relative(d);
|
|
BlockState offsetState = world.getBlockState(offset);
|
|
if (AllBlocks.GANTRY_SHAFT.has(offsetState) && offsetState.getValue(GantryShaftBlock.FACING)
|
|
.getAxis() == d.getAxis())
|
|
if (!visited.contains(offset))
|
|
frontier.add(offset);
|
|
}
|
|
}
|
|
|
|
protected void moveGantryShaft(Level world, BlockPos pos, Queue<BlockPos> frontier, Set<BlockPos> visited,
|
|
BlockState state) {
|
|
for (Direction d : Iterate.directions) {
|
|
BlockPos offset = pos.relative(d);
|
|
if (!visited.contains(offset)) {
|
|
BlockState offsetState = world.getBlockState(offset);
|
|
Direction facing = state.getValue(GantryShaftBlock.FACING);
|
|
if (d.getAxis() == facing.getAxis() && AllBlocks.GANTRY_SHAFT.has(offsetState)
|
|
&& offsetState.getValue(GantryShaftBlock.FACING) == facing)
|
|
frontier.add(offset);
|
|
else if (AllBlocks.GANTRY_CARRIAGE.has(offsetState)
|
|
&& offsetState.getValue(GantryCarriageBlock.FACING) == d)
|
|
frontier.add(offset);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void moveWindmillBearing(BlockPos pos, Queue<BlockPos> frontier, Set<BlockPos> visited, BlockState state) {
|
|
Direction facing = state.getValue(WindmillBearingBlock.FACING);
|
|
BlockPos offset = pos.relative(facing);
|
|
if (!visited.contains(offset))
|
|
frontier.add(offset);
|
|
}
|
|
|
|
private void moveBearing(BlockPos pos, Queue<BlockPos> frontier, Set<BlockPos> visited, BlockState state) {
|
|
Direction facing = state.getValue(MechanicalBearingBlock.FACING);
|
|
if (!canBeStabilized(facing, pos.subtract(anchor))) {
|
|
BlockPos offset = pos.relative(facing);
|
|
if (!visited.contains(offset))
|
|
frontier.add(offset);
|
|
return;
|
|
}
|
|
pendingSubContraptions.add(new BlockFace(pos, facing));
|
|
}
|
|
|
|
private void moveBelt(BlockPos pos, Queue<BlockPos> frontier, Set<BlockPos> visited, BlockState state) {
|
|
BlockPos nextPos = BeltBlock.nextSegmentPosition(state, pos, true);
|
|
BlockPos prevPos = BeltBlock.nextSegmentPosition(state, pos, false);
|
|
if (nextPos != null && !visited.contains(nextPos))
|
|
frontier.add(nextPos);
|
|
if (prevPos != null && !visited.contains(prevPos))
|
|
frontier.add(prevPos);
|
|
}
|
|
|
|
private void moveSeat(Level world, BlockPos pos) {
|
|
BlockPos local = toLocalPos(pos);
|
|
getSeats().add(local);
|
|
List<SeatEntity> seatsEntities = world.getEntitiesOfClass(SeatEntity.class, new AABB(pos));
|
|
if (!seatsEntities.isEmpty()) {
|
|
SeatEntity seat = seatsEntities.get(0);
|
|
List<Entity> passengers = seat.getPassengers();
|
|
if (!passengers.isEmpty())
|
|
initialPassengers.put(local, passengers.get(0));
|
|
}
|
|
}
|
|
|
|
private void movePulley(Level world, BlockPos pos, Queue<BlockPos> frontier, Set<BlockPos> visited) {
|
|
int limit = AllConfigs.SERVER.kinetics.maxRopeLength.get();
|
|
BlockPos ropePos = pos;
|
|
while (limit-- >= 0) {
|
|
ropePos = ropePos.below();
|
|
if (!world.isLoaded(ropePos))
|
|
break;
|
|
BlockState ropeState = world.getBlockState(ropePos);
|
|
Block block = ropeState.getBlock();
|
|
if (!(block instanceof RopeBlock) && !(block instanceof MagnetBlock)) {
|
|
if (!visited.contains(ropePos))
|
|
frontier.add(ropePos);
|
|
break;
|
|
}
|
|
addBlock(ropePos, capture(world, ropePos));
|
|
}
|
|
}
|
|
|
|
private boolean moveMechanicalPiston(Level world, BlockPos pos, Queue<BlockPos> frontier, Set<BlockPos> visited,
|
|
BlockState state) throws AssemblyException {
|
|
Direction direction = state.getValue(MechanicalPistonBlock.FACING);
|
|
PistonState pistonState = state.getValue(MechanicalPistonBlock.STATE);
|
|
if (pistonState == PistonState.MOVING)
|
|
return false;
|
|
|
|
BlockPos offset = pos.relative(direction.getOpposite());
|
|
if (!visited.contains(offset)) {
|
|
BlockState poleState = world.getBlockState(offset);
|
|
if (AllBlocks.PISTON_EXTENSION_POLE.has(poleState) && poleState.getValue(PistonExtensionPoleBlock.FACING)
|
|
.getAxis() == direction.getAxis())
|
|
frontier.add(offset);
|
|
}
|
|
|
|
if (pistonState == PistonState.EXTENDED || MechanicalPistonBlock.isStickyPiston(state)) {
|
|
offset = pos.relative(direction);
|
|
if (!visited.contains(offset))
|
|
frontier.add(offset);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
private boolean moveChassis(Level world, BlockPos pos, Direction movementDirection, Queue<BlockPos> frontier,
|
|
Set<BlockPos> visited) {
|
|
BlockEntity te = world.getBlockEntity(pos);
|
|
if (!(te instanceof ChassisTileEntity))
|
|
return false;
|
|
ChassisTileEntity chassis = (ChassisTileEntity) te;
|
|
chassis.addAttachedChasses(frontier, visited);
|
|
List<BlockPos> includedBlockPositions = chassis.getIncludedBlockPositions(movementDirection, false);
|
|
if (includedBlockPositions == null)
|
|
return false;
|
|
for (BlockPos blockPos : includedBlockPositions)
|
|
if (!visited.contains(blockPos))
|
|
frontier.add(blockPos);
|
|
return true;
|
|
}
|
|
|
|
protected Pair<StructureBlockInfo, BlockEntity> capture(Level world, BlockPos pos) {
|
|
BlockState blockstate = world.getBlockState(pos);
|
|
if (AllBlocks.REDSTONE_CONTACT.has(blockstate))
|
|
blockstate = blockstate.setValue(RedstoneContactBlock.POWERED, true);
|
|
if (AllBlocks.POWERED_SHAFT.has(blockstate))
|
|
blockstate = BlockHelper.copyProperties(blockstate, AllBlocks.SHAFT.getDefaultState());
|
|
if (AllBlocks.CONTROLS.has(blockstate))
|
|
blockstate = blockstate.setValue(ControlsBlock.OPEN, true);
|
|
if (blockstate.hasProperty(SlidingDoorBlock.VISIBLE))
|
|
blockstate = blockstate.setValue(SlidingDoorBlock.VISIBLE, false);
|
|
if (blockstate.getBlock() instanceof ButtonBlock) {
|
|
blockstate = blockstate.setValue(ButtonBlock.POWERED, false);
|
|
world.scheduleTick(pos, blockstate.getBlock(), -1);
|
|
}
|
|
if (blockstate.getBlock() instanceof PressurePlateBlock) {
|
|
blockstate = blockstate.setValue(PressurePlateBlock.POWERED, false);
|
|
world.scheduleTick(pos, blockstate.getBlock(), -1);
|
|
}
|
|
CompoundTag compoundnbt = getTileEntityNBT(world, pos);
|
|
BlockEntity tileentity = world.getBlockEntity(pos);
|
|
if (tileentity instanceof PoweredShaftTileEntity)
|
|
tileentity = AllTileEntities.BRACKETED_KINETIC.create(pos, blockstate);
|
|
return Pair.of(new StructureBlockInfo(pos, blockstate, compoundnbt), tileentity);
|
|
}
|
|
|
|
protected void addBlock(BlockPos pos, Pair<StructureBlockInfo, BlockEntity> pair) {
|
|
StructureBlockInfo captured = pair.getKey();
|
|
BlockPos localPos = pos.subtract(anchor);
|
|
StructureBlockInfo structureBlockInfo = new StructureBlockInfo(localPos, captured.state, captured.nbt);
|
|
|
|
if (blocks.put(localPos, structureBlockInfo) != null)
|
|
return;
|
|
bounds = bounds.minmax(new AABB(localPos));
|
|
|
|
BlockEntity te = pair.getValue();
|
|
storage.addBlock(localPos, te);
|
|
|
|
if (AllMovementBehaviours.getBehaviour(captured.state) != null)
|
|
actors.add(MutablePair.of(structureBlockInfo, null));
|
|
|
|
MovingInteractionBehaviour interactionBehaviour = AllInteractionBehaviours.getBehaviour(captured.state);
|
|
if (interactionBehaviour != null)
|
|
interactors.put(localPos, interactionBehaviour);
|
|
|
|
if (te instanceof CreativeCrateTileEntity
|
|
&& ((CreativeCrateTileEntity) te).getBehaviour(FilteringBehaviour.TYPE)
|
|
.getFilter()
|
|
.isEmpty())
|
|
hasUniversalCreativeCrate = true;
|
|
}
|
|
|
|
@Nullable
|
|
protected CompoundTag getTileEntityNBT(Level world, BlockPos pos) {
|
|
BlockEntity tileentity = world.getBlockEntity(pos);
|
|
if (tileentity == null)
|
|
return null;
|
|
CompoundTag nbt = tileentity.saveWithFullMetadata();
|
|
nbt.remove("x");
|
|
nbt.remove("y");
|
|
nbt.remove("z");
|
|
|
|
if ((tileentity instanceof FluidTankTileEntity || tileentity instanceof ItemVaultTileEntity)
|
|
&& nbt.contains("Controller"))
|
|
nbt.put("Controller",
|
|
NbtUtils.writeBlockPos(toLocalPos(NbtUtils.readBlockPos(nbt.getCompound("Controller")))));
|
|
|
|
return nbt;
|
|
}
|
|
|
|
protected BlockPos toLocalPos(BlockPos globalPos) {
|
|
return globalPos.subtract(anchor);
|
|
}
|
|
|
|
protected boolean movementAllowed(BlockState state, Level world, BlockPos pos) {
|
|
return BlockMovementChecks.isMovementAllowed(state, world, pos);
|
|
}
|
|
|
|
protected boolean isAnchoringBlockAt(BlockPos pos) {
|
|
return pos.equals(anchor);
|
|
}
|
|
|
|
public void readNBT(Level world, CompoundTag nbt, boolean spawnData) {
|
|
blocks.clear();
|
|
presentTileEntities.clear();
|
|
specialRenderedTileEntities.clear();
|
|
|
|
Tag blocks = nbt.get("Blocks");
|
|
// used to differentiate between the 'old' and the paletted serialization
|
|
boolean usePalettedDeserialization =
|
|
blocks != null && blocks.getId() == 10 && ((CompoundTag) blocks).contains("Palette");
|
|
readBlocksCompound(blocks, world, usePalettedDeserialization);
|
|
|
|
actors.clear();
|
|
nbt.getList("Actors", 10)
|
|
.forEach(c -> {
|
|
CompoundTag comp = (CompoundTag) c;
|
|
StructureBlockInfo info = this.blocks.get(NbtUtils.readBlockPos(comp.getCompound("Pos")));
|
|
if (info == null)
|
|
return;
|
|
MovementContext context = MovementContext.readNBT(world, info, comp, this);
|
|
getActors().add(MutablePair.of(info, context));
|
|
});
|
|
|
|
superglue.clear();
|
|
NBTHelper.iterateCompoundList(nbt.getList("Superglue", Tag.TAG_COMPOUND),
|
|
c -> superglue.add(SuperGlueEntity.readBoundingBox(c)));
|
|
|
|
seats.clear();
|
|
NBTHelper.iterateCompoundList(nbt.getList("Seats", Tag.TAG_COMPOUND), c -> seats.add(NbtUtils.readBlockPos(c)));
|
|
|
|
seatMapping.clear();
|
|
NBTHelper.iterateCompoundList(nbt.getList("Passengers", Tag.TAG_COMPOUND),
|
|
c -> seatMapping.put(NbtUtils.loadUUID(NBTHelper.getINBT(c, "Id")), c.getInt("Seat")));
|
|
|
|
stabilizedSubContraptions.clear();
|
|
NBTHelper.iterateCompoundList(nbt.getList("SubContraptions", Tag.TAG_COMPOUND),
|
|
c -> stabilizedSubContraptions.put(c.getUUID("Id"), BlockFace.fromNBT(c.getCompound("Location"))));
|
|
|
|
interactors.clear();
|
|
NBTHelper.iterateCompoundList(nbt.getList("Interactors", Tag.TAG_COMPOUND), c -> {
|
|
BlockPos pos = NbtUtils.readBlockPos(c.getCompound("Pos"));
|
|
StructureBlockInfo structureBlockInfo = getBlocks().get(pos);
|
|
if (structureBlockInfo == null)
|
|
return;
|
|
MovingInteractionBehaviour behaviour = AllInteractionBehaviours.getBehaviour(structureBlockInfo.state);
|
|
if (behaviour != null)
|
|
interactors.put(pos, behaviour);
|
|
});
|
|
|
|
storage.read(nbt, presentTileEntities, spawnData);
|
|
|
|
if (nbt.contains("BoundsFront"))
|
|
bounds = NBTHelper.readAABB(nbt.getList("BoundsFront", 5));
|
|
|
|
stalled = nbt.getBoolean("Stalled");
|
|
hasUniversalCreativeCrate = nbt.getBoolean("BottomlessSupply");
|
|
anchor = NbtUtils.readBlockPos(nbt.getCompound("Anchor"));
|
|
}
|
|
|
|
public CompoundTag writeNBT(boolean spawnPacket) {
|
|
CompoundTag nbt = new CompoundTag();
|
|
nbt.putString("Type", getType().id);
|
|
|
|
CompoundTag blocksNBT = writeBlocksCompound();
|
|
|
|
ListTag actorsNBT = new ListTag();
|
|
for (MutablePair<StructureBlockInfo, MovementContext> actor : getActors()) {
|
|
MovementBehaviour behaviour = AllMovementBehaviours.getBehaviour(actor.left.state);
|
|
if (behaviour == null)
|
|
continue;
|
|
CompoundTag compound = new CompoundTag();
|
|
compound.put("Pos", NbtUtils.writeBlockPos(actor.left.pos));
|
|
behaviour.writeExtraData(actor.right);
|
|
actor.right.writeToNBT(compound);
|
|
actorsNBT.add(compound);
|
|
}
|
|
|
|
ListTag superglueNBT = new ListTag();
|
|
if (!spawnPacket) {
|
|
for (AABB glueEntry : superglue) {
|
|
CompoundTag c = new CompoundTag();
|
|
SuperGlueEntity.writeBoundingBox(c, glueEntry);
|
|
superglueNBT.add(c);
|
|
}
|
|
}
|
|
|
|
(spawnPacket ? getStorageForSpawnPacket() : storage).write(nbt, spawnPacket);
|
|
|
|
ListTag interactorNBT = new ListTag();
|
|
for (BlockPos pos : interactors.keySet()) {
|
|
CompoundTag c = new CompoundTag();
|
|
c.put("Pos", NbtUtils.writeBlockPos(pos));
|
|
interactorNBT.add(c);
|
|
}
|
|
|
|
nbt.put("Seats", NBTHelper.writeCompoundList(getSeats(), NbtUtils::writeBlockPos));
|
|
nbt.put("Passengers", NBTHelper.writeCompoundList(getSeatMapping().entrySet(), e -> {
|
|
CompoundTag tag = new CompoundTag();
|
|
tag.put("Id", NbtUtils.createUUID(e.getKey()));
|
|
tag.putInt("Seat", e.getValue());
|
|
return tag;
|
|
}));
|
|
|
|
nbt.put("SubContraptions", NBTHelper.writeCompoundList(stabilizedSubContraptions.entrySet(), e -> {
|
|
CompoundTag tag = new CompoundTag();
|
|
tag.putUUID("Id", e.getKey());
|
|
tag.put("Location", e.getValue()
|
|
.serializeNBT());
|
|
return tag;
|
|
}));
|
|
|
|
nbt.put("Blocks", blocksNBT);
|
|
nbt.put("Actors", actorsNBT);
|
|
nbt.put("Interactors", interactorNBT);
|
|
nbt.put("Superglue", superglueNBT);
|
|
nbt.put("Anchor", NbtUtils.writeBlockPos(anchor));
|
|
nbt.putBoolean("Stalled", stalled);
|
|
nbt.putBoolean("BottomlessSupply", hasUniversalCreativeCrate);
|
|
|
|
if (bounds != null) {
|
|
ListTag bb = NBTHelper.writeAABB(bounds);
|
|
nbt.put("BoundsFront", bb);
|
|
}
|
|
|
|
return nbt;
|
|
}
|
|
|
|
protected MountedStorageManager getStorageForSpawnPacket() {
|
|
return storage;
|
|
}
|
|
|
|
private CompoundTag writeBlocksCompound() {
|
|
CompoundTag compound = new CompoundTag();
|
|
HashMapPalette<BlockState> palette = new HashMapPalette<>(GameData.getBlockStateIDMap(), 16, (i, s) -> {
|
|
throw new IllegalStateException("Palette Map index exceeded maximum");
|
|
});
|
|
ListTag blockList = new ListTag();
|
|
|
|
for (StructureBlockInfo block : this.blocks.values()) {
|
|
int id = palette.idFor(block.state);
|
|
CompoundTag c = new CompoundTag();
|
|
c.putLong("Pos", block.pos.asLong());
|
|
c.putInt("State", id);
|
|
if (block.nbt != null)
|
|
c.put("Data", block.nbt);
|
|
blockList.add(c);
|
|
}
|
|
|
|
ListTag paletteNBT = new ListTag();
|
|
for (int i = 0; i < palette.getSize(); ++i)
|
|
paletteNBT.add(NbtUtils.writeBlockState(palette.values.byId(i)));
|
|
|
|
compound.put("Palette", paletteNBT);
|
|
compound.put("BlockList", blockList);
|
|
|
|
return compound;
|
|
}
|
|
|
|
private void readBlocksCompound(Tag compound, Level world, boolean usePalettedDeserialization) {
|
|
HashMapPalette<BlockState> palette = null;
|
|
ListTag blockList;
|
|
if (usePalettedDeserialization) {
|
|
CompoundTag c = ((CompoundTag) compound);
|
|
palette = new HashMapPalette<>(GameData.getBlockStateIDMap(), 16, (i, s) -> {
|
|
throw new IllegalStateException("Palette Map index exceeded maximum");
|
|
});
|
|
|
|
ListTag list = c.getList("Palette", 10);
|
|
palette.values.clear();
|
|
for (int i = 0; i < list.size(); ++i)
|
|
palette.values.add(NbtUtils.readBlockState(list.getCompound(i)));
|
|
|
|
blockList = c.getList("BlockList", 10);
|
|
} else {
|
|
blockList = (ListTag) compound;
|
|
}
|
|
|
|
HashMapPalette<BlockState> finalPalette = palette;
|
|
blockList.forEach(e -> {
|
|
CompoundTag c = (CompoundTag) e;
|
|
|
|
StructureBlockInfo info =
|
|
usePalettedDeserialization ? readStructureBlockInfo(c, finalPalette) : legacyReadStructureBlockInfo(c);
|
|
|
|
this.blocks.put(info.pos, info);
|
|
|
|
if (!world.isClientSide)
|
|
return;
|
|
|
|
CompoundTag tag = info.nbt;
|
|
if (tag == null)
|
|
return;
|
|
|
|
tag.putInt("x", info.pos.getX());
|
|
tag.putInt("y", info.pos.getY());
|
|
tag.putInt("z", info.pos.getZ());
|
|
|
|
BlockEntity te = BlockEntity.loadStatic(info.pos, info.state, tag);
|
|
if (te == null)
|
|
return;
|
|
te.setLevel(world);
|
|
modelData.put(info.pos, te.getModelData());
|
|
if (te instanceof KineticTileEntity kte)
|
|
kte.setSpeed(0);
|
|
te.getBlockState();
|
|
|
|
MovementBehaviour movementBehaviour = AllMovementBehaviours.getBehaviour(info.state);
|
|
if (movementBehaviour == null || !movementBehaviour.hasSpecialInstancedRendering())
|
|
maybeInstancedTileEntities.add(te);
|
|
|
|
if (movementBehaviour != null && !movementBehaviour.renderAsNormalTileEntity())
|
|
return;
|
|
|
|
presentTileEntities.put(info.pos, te);
|
|
specialRenderedTileEntities.add(te);
|
|
});
|
|
}
|
|
|
|
private static StructureBlockInfo readStructureBlockInfo(CompoundTag blockListEntry,
|
|
HashMapPalette<BlockState> palette) {
|
|
return new StructureBlockInfo(BlockPos.of(blockListEntry.getLong("Pos")),
|
|
Objects.requireNonNull(palette.valueFor(blockListEntry.getInt("State"))),
|
|
blockListEntry.contains("Data") ? blockListEntry.getCompound("Data") : null);
|
|
}
|
|
|
|
private static StructureBlockInfo legacyReadStructureBlockInfo(CompoundTag blockListEntry) {
|
|
return new StructureBlockInfo(NbtUtils.readBlockPos(blockListEntry.getCompound("Pos")),
|
|
NbtUtils.readBlockState(blockListEntry.getCompound("Block")),
|
|
blockListEntry.contains("Data") ? blockListEntry.getCompound("Data") : null);
|
|
}
|
|
|
|
public void removeBlocksFromWorld(Level world, BlockPos offset) {
|
|
storage.removeStorageFromWorld();
|
|
|
|
glueToRemove.forEach(glue -> {
|
|
superglue.add(glue.getBoundingBox()
|
|
.move(Vec3.atLowerCornerOf(offset.offset(anchor))
|
|
.scale(-1)));
|
|
glue.discard();
|
|
});
|
|
|
|
List<BoundingBox> minimisedGlue = new ArrayList<>();
|
|
for (int i = 0; i < superglue.size(); i++)
|
|
minimisedGlue.add(null);
|
|
|
|
for (boolean brittles : Iterate.trueAndFalse) {
|
|
for (Iterator<StructureBlockInfo> iterator = blocks.values()
|
|
.iterator(); iterator.hasNext();) {
|
|
StructureBlockInfo block = iterator.next();
|
|
if (brittles != BlockMovementChecks.isBrittle(block.state))
|
|
continue;
|
|
|
|
for (int i = 0; i < superglue.size(); i++) {
|
|
AABB aabb = superglue.get(i);
|
|
if (aabb == null
|
|
|| !aabb.contains(block.pos.getX() + .5, block.pos.getY() + .5, block.pos.getZ() + .5))
|
|
continue;
|
|
if (minimisedGlue.get(i) == null)
|
|
minimisedGlue.set(i, new BoundingBox(block.pos));
|
|
else
|
|
minimisedGlue.set(i, BBHelper.encapsulate(minimisedGlue.get(i), block.pos));
|
|
}
|
|
|
|
BlockPos add = block.pos.offset(anchor)
|
|
.offset(offset);
|
|
if (customBlockRemoval(world, add, block.state))
|
|
continue;
|
|
BlockState oldState = world.getBlockState(add);
|
|
Block blockIn = oldState.getBlock();
|
|
boolean blockMismatch = block.state.getBlock() != blockIn;
|
|
blockMismatch &= !AllBlocks.POWERED_SHAFT.is(blockIn) || !AllBlocks.SHAFT.has(block.state);
|
|
if (blockMismatch)
|
|
iterator.remove();
|
|
world.removeBlockEntity(add);
|
|
int flags = Block.UPDATE_MOVE_BY_PISTON | Block.UPDATE_SUPPRESS_DROPS | Block.UPDATE_KNOWN_SHAPE
|
|
| Block.UPDATE_CLIENTS | Block.UPDATE_IMMEDIATE;
|
|
if (blockIn instanceof SimpleWaterloggedBlock && oldState.hasProperty(BlockStateProperties.WATERLOGGED)
|
|
&& oldState.getValue(BlockStateProperties.WATERLOGGED)) {
|
|
world.setBlock(add, Blocks.WATER.defaultBlockState(), flags);
|
|
continue;
|
|
}
|
|
world.setBlock(add, Blocks.AIR.defaultBlockState(), flags);
|
|
}
|
|
}
|
|
|
|
superglue.clear();
|
|
for (BoundingBox box : minimisedGlue) {
|
|
if (box == null)
|
|
continue;
|
|
AABB bb = new AABB(box.minX(), box.minY(), box.minZ(), box.maxX() + 1, box.maxY() + 1, box.maxZ() + 1);
|
|
if (bb.getSize() > 1.01)
|
|
superglue.add(bb);
|
|
}
|
|
|
|
for (StructureBlockInfo block : blocks.values()) {
|
|
BlockPos add = block.pos.offset(anchor)
|
|
.offset(offset);
|
|
// if (!shouldUpdateAfterMovement(block))
|
|
// continue;
|
|
|
|
int flags = Block.UPDATE_MOVE_BY_PISTON | Block.UPDATE_ALL;
|
|
world.sendBlockUpdated(add, block.state, Blocks.AIR.defaultBlockState(), flags);
|
|
|
|
// when the blockstate is set to air, the block's POI data is removed, but
|
|
// markAndNotifyBlock tries to
|
|
// remove it again, so to prevent an error from being logged by double-removal
|
|
// we add the POI data back now
|
|
// (code copied from ServerWorld.onBlockStateChange)
|
|
ServerLevel serverWorld = (ServerLevel) world;
|
|
PoiType.forState(block.state)
|
|
.ifPresent(poiType -> {
|
|
world.getServer()
|
|
.execute(() -> {
|
|
serverWorld.getPoiManager()
|
|
.add(add, poiType);
|
|
DebugPackets.sendPoiAddedPacket(serverWorld, add);
|
|
});
|
|
});
|
|
|
|
world.markAndNotifyBlock(add, world.getChunkAt(add), block.state, Blocks.AIR.defaultBlockState(), flags,
|
|
512);
|
|
block.state.updateIndirectNeighbourShapes(world, add, flags & -2);
|
|
}
|
|
}
|
|
|
|
public void addBlocksToWorld(Level world, StructureTransform transform) {
|
|
if (disassembled)
|
|
return;
|
|
disassembled = true;
|
|
|
|
for (boolean nonBrittles : Iterate.trueAndFalse) {
|
|
for (StructureBlockInfo block : blocks.values()) {
|
|
if (nonBrittles == BlockMovementChecks.isBrittle(block.state))
|
|
continue;
|
|
|
|
BlockPos targetPos = transform.apply(block.pos);
|
|
BlockState state = transform.apply(block.state);
|
|
|
|
if (customBlockPlacement(world, targetPos, state))
|
|
continue;
|
|
|
|
if (nonBrittles)
|
|
for (Direction face : Iterate.directions)
|
|
state = state.updateShape(face, world.getBlockState(targetPos.relative(face)), world, targetPos,
|
|
targetPos.relative(face));
|
|
|
|
BlockState blockState = world.getBlockState(targetPos);
|
|
if (blockState.getDestroySpeed(world, targetPos) == -1 || (state.getCollisionShape(world, targetPos)
|
|
.isEmpty()
|
|
&& !blockState.getCollisionShape(world, targetPos)
|
|
.isEmpty())) {
|
|
if (targetPos.getY() == world.getMinBuildHeight())
|
|
targetPos = targetPos.above();
|
|
world.levelEvent(2001, targetPos, Block.getId(state));
|
|
Block.dropResources(state, world, targetPos, null);
|
|
continue;
|
|
}
|
|
if (state.getBlock() instanceof SimpleWaterloggedBlock
|
|
&& state.hasProperty(BlockStateProperties.WATERLOGGED)) {
|
|
FluidState FluidState = world.getFluidState(targetPos);
|
|
state = state.setValue(BlockStateProperties.WATERLOGGED, FluidState.getType() == Fluids.WATER);
|
|
}
|
|
|
|
world.destroyBlock(targetPos, true);
|
|
|
|
if (AllBlocks.SHAFT.has(state))
|
|
state = ShaftBlock.pickCorrectShaftType(state, world, targetPos);
|
|
if (state.hasProperty(SlidingDoorBlock.VISIBLE))
|
|
state = state.setValue(SlidingDoorBlock.VISIBLE, !state.getValue(SlidingDoorBlock.OPEN))
|
|
.setValue(SlidingDoorBlock.POWERED, false);
|
|
|
|
world.setBlock(targetPos, state, Block.UPDATE_MOVE_BY_PISTON | Block.UPDATE_ALL);
|
|
|
|
boolean verticalRotation = transform.rotationAxis == null || transform.rotationAxis.isHorizontal();
|
|
verticalRotation = verticalRotation && transform.rotation != Rotation.NONE;
|
|
if (verticalRotation) {
|
|
if (state.getBlock() instanceof RopeBlock || state.getBlock() instanceof MagnetBlock || state.getBlock() instanceof DoorBlock)
|
|
world.destroyBlock(targetPos, true);
|
|
}
|
|
|
|
BlockEntity tileEntity = world.getBlockEntity(targetPos);
|
|
|
|
CompoundTag tag = block.nbt;
|
|
if (tileEntity != null)
|
|
tag = NBTProcessors.process(tileEntity, tag, false);
|
|
if (tileEntity != null && tag != null) {
|
|
tag.putInt("x", targetPos.getX());
|
|
tag.putInt("y", targetPos.getY());
|
|
tag.putInt("z", targetPos.getZ());
|
|
|
|
if (verticalRotation && tileEntity instanceof PulleyTileEntity) {
|
|
tag.remove("Offset");
|
|
tag.remove("InitialOffset");
|
|
}
|
|
|
|
if (tileEntity instanceof IMultiTileContainer && tag.contains("LastKnownPos"))
|
|
tag.put("LastKnownPos", NbtUtils.writeBlockPos(BlockPos.ZERO.below(Integer.MAX_VALUE - 1)));
|
|
|
|
tileEntity.load(tag);
|
|
storage.addStorageToWorld(block, tileEntity);
|
|
}
|
|
|
|
transform.apply(tileEntity);
|
|
}
|
|
}
|
|
|
|
for (StructureBlockInfo block : blocks.values()) {
|
|
if (!shouldUpdateAfterMovement(block))
|
|
continue;
|
|
BlockPos targetPos = transform.apply(block.pos);
|
|
world.markAndNotifyBlock(targetPos, world.getChunkAt(targetPos), block.state, block.state,
|
|
Block.UPDATE_MOVE_BY_PISTON | Block.UPDATE_ALL, 512);
|
|
}
|
|
|
|
for (AABB box : superglue) {
|
|
box = new AABB(transform.apply(new Vec3(box.minX, box.minY, box.minZ)),
|
|
transform.apply(new Vec3(box.maxX, box.maxY, box.maxZ)));
|
|
if (!world.isClientSide)
|
|
world.addFreshEntity(new SuperGlueEntity(world, box));
|
|
}
|
|
|
|
storage.clear();
|
|
}
|
|
|
|
public void addPassengersToWorld(Level world, StructureTransform transform, List<Entity> seatedEntities) {
|
|
for (Entity seatedEntity : seatedEntities) {
|
|
if (getSeatMapping().isEmpty())
|
|
continue;
|
|
Integer seatIndex = getSeatMapping().get(seatedEntity.getUUID());
|
|
if (seatIndex == null)
|
|
continue;
|
|
BlockPos seatPos = getSeats().get(seatIndex);
|
|
seatPos = transform.apply(seatPos);
|
|
if (!(world.getBlockState(seatPos)
|
|
.getBlock() instanceof SeatBlock))
|
|
continue;
|
|
if (SeatBlock.isSeatOccupied(world, seatPos))
|
|
continue;
|
|
SeatBlock.sitDown(world, seatPos, seatedEntity);
|
|
}
|
|
}
|
|
|
|
public void startMoving(Level world) {
|
|
for (MutablePair<StructureBlockInfo, MovementContext> pair : actors) {
|
|
MovementContext context = new MovementContext(world, pair.left, this);
|
|
MovementBehaviour behaviour = AllMovementBehaviours.getBehaviour(pair.left.state);
|
|
if (behaviour != null)
|
|
behaviour.startMoving(context);
|
|
pair.setRight(context);
|
|
}
|
|
}
|
|
|
|
public void stop(Level world) {
|
|
forEachActor(world, (behaviour, ctx) -> {
|
|
behaviour.stopMoving(ctx);
|
|
ctx.position = null;
|
|
ctx.motion = Vec3.ZERO;
|
|
ctx.relativeMotion = Vec3.ZERO;
|
|
ctx.rotation = v -> v;
|
|
});
|
|
}
|
|
|
|
public void forEachActor(Level world, BiConsumer<MovementBehaviour, MovementContext> callBack) {
|
|
for (MutablePair<StructureBlockInfo, MovementContext> pair : actors) {
|
|
MovementBehaviour behaviour = AllMovementBehaviours.getBehaviour(pair.getLeft().state);
|
|
if (behaviour == null)
|
|
continue;
|
|
callBack.accept(behaviour, pair.getRight());
|
|
}
|
|
}
|
|
|
|
protected boolean shouldUpdateAfterMovement(StructureBlockInfo info) {
|
|
if (PoiType.forState(info.state)
|
|
.isPresent())
|
|
return false;
|
|
if (info.state.getBlock() instanceof SlidingDoorBlock)
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
public void expandBoundsAroundAxis(Axis axis) {
|
|
Set<BlockPos> blocks = getBlocks().keySet();
|
|
|
|
int radius = (int) (Math.ceil(Math.sqrt(getRadius(blocks, axis))));
|
|
|
|
int maxX = radius + 2;
|
|
int maxY = radius + 2;
|
|
int maxZ = radius + 2;
|
|
int minX = -radius - 1;
|
|
int minY = -radius - 1;
|
|
int minZ = -radius - 1;
|
|
|
|
if (axis == Direction.Axis.X) {
|
|
maxX = (int) bounds.maxX;
|
|
minX = (int) bounds.minX;
|
|
} else if (axis == Direction.Axis.Y) {
|
|
maxY = (int) bounds.maxY;
|
|
minY = (int) bounds.minY;
|
|
} else if (axis == Direction.Axis.Z) {
|
|
maxZ = (int) bounds.maxZ;
|
|
minZ = (int) bounds.minZ;
|
|
}
|
|
|
|
bounds = new AABB(minX, minY, minZ, maxX, maxY, maxZ);
|
|
}
|
|
|
|
public Map<UUID, Integer> getSeatMapping() {
|
|
return seatMapping;
|
|
}
|
|
|
|
public BlockPos getSeatOf(UUID entityId) {
|
|
if (!getSeatMapping().containsKey(entityId))
|
|
return null;
|
|
int seatIndex = getSeatMapping().get(entityId);
|
|
if (seatIndex >= getSeats().size())
|
|
return null;
|
|
return getSeats().get(seatIndex);
|
|
}
|
|
|
|
public BlockPos getBearingPosOf(UUID subContraptionEntityId) {
|
|
if (stabilizedSubContraptions.containsKey(subContraptionEntityId))
|
|
return stabilizedSubContraptions.get(subContraptionEntityId)
|
|
.getConnectedPos();
|
|
return null;
|
|
}
|
|
|
|
public void setSeatMapping(Map<UUID, Integer> seatMapping) {
|
|
this.seatMapping = seatMapping;
|
|
}
|
|
|
|
public List<BlockPos> getSeats() {
|
|
return seats;
|
|
}
|
|
|
|
public Map<BlockPos, StructureBlockInfo> getBlocks() {
|
|
return blocks;
|
|
}
|
|
|
|
public List<MutablePair<StructureBlockInfo, MovementContext>> getActors() {
|
|
return actors;
|
|
}
|
|
|
|
public Map<BlockPos, MovingInteractionBehaviour> getInteractors() {
|
|
return interactors;
|
|
}
|
|
|
|
@OnlyIn(Dist.CLIENT)
|
|
public ContraptionLighter<?> makeLighter() {
|
|
// TODO: move lighters to registry
|
|
return new EmptyLighter(this);
|
|
}
|
|
|
|
public void invalidateColliders() {
|
|
simplifiedEntityColliders = Optional.empty();
|
|
gatherBBsOffThread();
|
|
}
|
|
|
|
private void gatherBBsOffThread() {
|
|
getContraptionWorld();
|
|
simplifiedEntityColliderProvider = CompletableFuture.supplyAsync(() -> {
|
|
VoxelShape combinedShape = Shapes.empty();
|
|
for (Entry<BlockPos, StructureBlockInfo> entry : blocks.entrySet()) {
|
|
StructureBlockInfo info = entry.getValue();
|
|
BlockPos localPos = entry.getKey();
|
|
VoxelShape collisionShape = info.state.getCollisionShape(world, localPos, CollisionContext.empty());
|
|
if (collisionShape.isEmpty())
|
|
continue;
|
|
combinedShape = Shapes.joinUnoptimized(combinedShape,
|
|
collisionShape.move(localPos.getX(), localPos.getY(), localPos.getZ()), BooleanOp.OR);
|
|
}
|
|
return combinedShape.optimize()
|
|
.toAabbs();
|
|
})
|
|
.thenAccept(r -> {
|
|
simplifiedEntityColliders = Optional.of(r);
|
|
simplifiedEntityColliderProvider = null;
|
|
});
|
|
}
|
|
|
|
public static float getRadius(Set<BlockPos> blocks, Direction.Axis axis) {
|
|
switch (axis) {
|
|
case X:
|
|
return getMaxDistSqr(blocks, BlockPos::getY, BlockPos::getZ);
|
|
case Y:
|
|
return getMaxDistSqr(blocks, BlockPos::getX, BlockPos::getZ);
|
|
case Z:
|
|
return getMaxDistSqr(blocks, BlockPos::getX, BlockPos::getY);
|
|
}
|
|
|
|
throw new IllegalStateException("Impossible axis");
|
|
}
|
|
|
|
public static float getMaxDistSqr(Set<BlockPos> blocks, ICoordinate one, ICoordinate other) {
|
|
float maxDistSq = -1;
|
|
for (BlockPos pos : blocks) {
|
|
float a = one.get(pos);
|
|
float b = other.get(pos);
|
|
|
|
float distSq = a * a + b * b;
|
|
|
|
if (distSq > maxDistSq)
|
|
maxDistSq = distSq;
|
|
}
|
|
|
|
return maxDistSq;
|
|
}
|
|
|
|
public IItemHandlerModifiable getSharedInventory() {
|
|
return storage.getItems();
|
|
}
|
|
|
|
public IItemHandlerModifiable getSharedFuelInventory() {
|
|
return storage.getFuelItems();
|
|
}
|
|
|
|
public IFluidHandler getSharedFluidTanks() {
|
|
return storage.getFluids();
|
|
}
|
|
|
|
public Collection<StructureBlockInfo> getRenderedBlocks() {
|
|
return blocks.values();
|
|
}
|
|
|
|
public Collection<BlockEntity> getSpecialRenderedTEs() {
|
|
return specialRenderedTileEntities;
|
|
}
|
|
|
|
public boolean isHiddenInPortal(BlockPos localPos) {
|
|
return false;
|
|
}
|
|
|
|
public Optional<List<AABB>> getSimplifiedEntityColliders() {
|
|
return simplifiedEntityColliders;
|
|
}
|
|
|
|
public void handleContraptionFluidPacket(BlockPos localPos, FluidStack containedFluid) {
|
|
storage.updateContainedFluid(localPos, containedFluid);
|
|
}
|
|
|
|
public static class ContraptionInvWrapper extends CombinedInvWrapper {
|
|
protected final boolean isExternal;
|
|
|
|
public ContraptionInvWrapper(boolean isExternal, IItemHandlerModifiable... itemHandler) {
|
|
super(itemHandler);
|
|
this.isExternal = isExternal;
|
|
}
|
|
|
|
public ContraptionInvWrapper(IItemHandlerModifiable... itemHandler) {
|
|
this(false, itemHandler);
|
|
}
|
|
|
|
public boolean isSlotExternal(int slot) {
|
|
if (isExternal)
|
|
return true;
|
|
IItemHandlerModifiable handler = getHandlerFromIndex(getIndexForSlot(slot));
|
|
return handler instanceof ContraptionInvWrapper && ((ContraptionInvWrapper) handler).isSlotExternal(slot);
|
|
}
|
|
}
|
|
|
|
public void tickStorage(AbstractContraptionEntity entity) {
|
|
storage.entityTick(entity);
|
|
}
|
|
|
|
public boolean containsBlockBreakers() {
|
|
for (MutablePair<StructureBlockInfo, MovementContext> pair : actors) {
|
|
MovementBehaviour behaviour = AllMovementBehaviours.getBehaviour(pair.getLeft().state);
|
|
if (behaviour instanceof BlockBreakingMovementBehaviour || behaviour instanceof HarvesterMovementBehaviour)
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
}
|