├── .github └── workflows │ ├── build.yml │ └── test.yml ├── .gitignore ├── .gitmodules ├── Jenkinsfile ├── LICENSE ├── README.md ├── build.gradle ├── buildSrc ├── build.gradle └── src │ └── main │ └── java │ └── com │ └── ishland │ └── c2me │ └── gradle │ ├── ParseGItHubActionChangelog.java │ └── RedirectingOutputStream.java ├── c2me-base ├── build.gradle └── src │ └── main │ ├── java │ └── com │ │ └── ishland │ │ └── c2me │ │ └── base │ │ ├── C2MEBaseMod.java │ │ ├── ModuleEntryPoint.java │ │ ├── TheMixinPlugin.java │ │ ├── common │ │ ├── C2MEConstants.java │ │ ├── GlobalExecutors.java │ │ ├── ModuleMixinPlugin.java │ │ ├── config │ │ │ ├── ConfigSystem.java │ │ │ ├── LateModStatuses.java │ │ │ ├── ModStatuses.java │ │ │ └── Updaters.java │ │ ├── network │ │ │ └── ExtRenderDistance.java │ │ ├── registry │ │ │ └── SerializerAccess.java │ │ ├── scheduler │ │ │ ├── AbstractPosAwarePrioritizedTask.java │ │ │ ├── ISyncLoadManager.java │ │ │ ├── IVanillaChunkManager.java │ │ │ ├── LockTokenImpl.java │ │ │ ├── ScheduledTask.java │ │ │ ├── SchedulingManager.java │ │ │ ├── SimplePrioritizedTask.java │ │ │ ├── SingleThreadExecutor.java │ │ │ ├── ThreadLocalWorldGenSchedulingState.java │ │ │ └── WrappingTask.java │ │ ├── structs │ │ │ ├── LongHashSet.java │ │ │ └── RawByteArrayOutputStream.java │ │ ├── theinterface │ │ │ ├── IDirectStorage.java │ │ │ ├── IFastChunkHolder.java │ │ │ └── PlayerEntityExtension.java │ │ ├── threadstate │ │ │ ├── RunningWork.java │ │ │ ├── SyncLoadWork.java │ │ │ ├── ThreadInstrumentation.java │ │ │ └── ThreadState.java │ │ └── util │ │ │ ├── AsyncNamedLockDelegateAsyncLock.java │ │ │ ├── BooleanUtils.java │ │ │ ├── C2MEForkJoinWorkerThreadFactory.java │ │ │ ├── C2MENormalWorkerThreadFactory.java │ │ │ ├── CFUtil.java │ │ │ ├── CMETrackingMap.java │ │ │ ├── DeepCloneable.java │ │ │ ├── FilteringIterable.java │ │ │ ├── InvokingExecutorService.java │ │ │ ├── ListIndexedIterable.java │ │ │ ├── MCUtil.java │ │ │ ├── RxJavaUtils.java │ │ │ ├── ShouldKeepTickingUtils.java │ │ │ ├── SneakyThrow.java │ │ │ ├── TimeUtil.java │ │ │ └── UrlUtil.java │ │ ├── mixin │ │ ├── access │ │ │ ├── IAquiferSamplerFluidLevel.java │ │ │ ├── IAtomicSimpleRandomDeriver.java │ │ │ ├── IBelowZeroRetrogen.java │ │ │ ├── IBlender.java │ │ │ ├── IBlendingData.java │ │ │ ├── IBlockEntity.java │ │ │ ├── IChunkGenerator.java │ │ │ ├── IChunkHolder.java │ │ │ ├── IChunkLevelManager.java │ │ │ ├── IChunkLevelManagerDistanceFromNearestPlayerTracker.java │ │ │ ├── IChunkLevelManagerNearbyChunkTicketUpdater.java │ │ │ ├── IChunkNoiseSampler.java │ │ │ ├── IChunkNoiseSamplerDensityInterpolator.java │ │ │ ├── IChunkTickScheduler.java │ │ │ ├── IChunkTicket.java │ │ │ ├── IDensityFunctionTypesWeirdScaledSamplerRarityValueMapper.java │ │ │ ├── IDensityFunctionsCaveScaler.java │ │ │ ├── IFlowableFluid.java │ │ │ ├── IInterpolatedNoiseSampler.java │ │ │ ├── IMultiNoiseBiomeSource.java │ │ │ ├── INbtCompound.java │ │ │ ├── INbtList.java │ │ │ ├── IOctavePerlinNoiseSampler.java │ │ │ ├── IPerlinNoiseSampler.java │ │ │ ├── IPlayerEntity.java │ │ │ ├── IRegionBasedStorage.java │ │ │ ├── IRegionFile.java │ │ │ ├── ISerializingRegionBasedStorage.java │ │ │ ├── IServerChunkManager.java │ │ │ ├── IServerEntityManager.java │ │ │ ├── IServerLightingProvider.java │ │ │ ├── ISimpleRandom.java │ │ │ ├── ISimpleTickScheduler.java │ │ │ ├── ISimplexNoiseSampler.java │ │ │ ├── ISimulationDistanceLevelPropagator.java │ │ │ ├── IState.java │ │ │ ├── IStorageIoWorker.java │ │ │ ├── IStructurePiece.java │ │ │ ├── IStructureStart.java │ │ │ ├── IStructureWeightSampler.java │ │ │ ├── ISyncedClientOptions.java │ │ │ ├── IThreadedAnvilChunkStorage.java │ │ │ ├── IThreadedAnvilChunkStorageLevelManager.java │ │ │ ├── IUpgradeData.java │ │ │ ├── IVersionedChunkStorage.java │ │ │ ├── IWeightedList.java │ │ │ ├── IWeightedListEntry.java │ │ │ ├── IWorldChunk.java │ │ │ ├── IXoroshiro128PlusPlusRandom.java │ │ │ ├── IXoroshiro128PlusPlusRandomDeriver.java │ │ │ ├── IXoroshiro128PlusPlusRandomImpl.java │ │ │ └── fapi │ │ │ │ └── IArrayBackedEvent.java │ │ ├── client_movement │ │ │ ├── MixinClientPlayerEntity.java │ │ │ └── MixinPlayerEntity.java │ │ ├── instrumentation │ │ │ └── MixinServerChunkManager.java │ │ ├── report │ │ │ └── MixinDedicatedServerWatchdog.java │ │ ├── scheduler │ │ │ ├── MixinServerChunkManager.java │ │ │ └── MixinThreadedAnvilChunkStorage.java │ │ ├── theinterface │ │ │ └── MixinStorageIoWorker.java │ │ └── util │ │ │ └── log4j2shutdownhookisnomore │ │ │ ├── MixinMain.java │ │ │ └── MixinMinecraftDedicatedServer.java │ │ └── package-info.java │ └── resources │ ├── c2me-base.accesswidener │ ├── c2me-base.mixins.json │ ├── c2me.mixins.json │ └── fabric.mod.json ├── c2me-client-uncapvd ├── build.gradle └── src │ └── main │ ├── java │ └── com │ │ └── ishland │ │ └── c2me │ │ └── client │ │ └── uncapvd │ │ ├── ModuleEntryPoint.java │ │ ├── common │ │ ├── ClientExtNetworking.java │ │ ├── Config.java │ │ └── UncapVDInitializer.java │ │ ├── mixin │ │ ├── ISimpleOption.java │ │ ├── MixinGameOptions.java │ │ ├── MixinSodiumUserConfigCategories.java │ │ ├── MixinSyncedClientOptions.java │ │ └── MixinVKModOptions.java │ │ └── package-info.java │ └── resources │ ├── c2me-client-uncapvd.mixins.json │ └── fabric.mod.json ├── c2me-fixes-chunkio-threading-issues ├── build.gradle └── src │ └── main │ ├── java │ └── com │ │ └── ishland │ │ └── c2me │ │ └── fixes │ │ └── chunkio │ │ └── threading_issues │ │ ├── ModuleEntryPoint.java │ │ ├── common │ │ └── SynchronizedCodec.java │ │ ├── mixin │ │ └── MixinStructurePoolElement.java │ │ └── package-info.java │ └── resources │ ├── c2me-fixes-chunkio-threading-issues.mixins.json │ └── fabric.mod.json ├── c2me-fixes-general-threading-issues ├── build.gradle └── src │ └── main │ ├── java │ └── com │ │ └── ishland │ │ └── c2me │ │ └── fixes │ │ └── general │ │ └── threading_issues │ │ ├── ModuleEntryPoint.java │ │ ├── mixin │ │ └── asynccatchers │ │ │ ├── MixinMinecraftServer.java │ │ │ ├── MixinServerChunkManager.java │ │ │ └── MixinThreadedAnvilChunkStorage.java │ │ └── package-info.java │ └── resources │ ├── c2me-fixes-general-threading-issues.mixins.json │ └── fabric.mod.json ├── c2me-fixes-worldgen-threading-issues ├── build.gradle └── src │ └── main │ ├── java │ └── com │ │ └── ishland │ │ └── c2me │ │ └── fixes │ │ └── worldgen │ │ └── threading_issues │ │ ├── MixinPlugin.java │ │ ├── ModuleEntryPoint.java │ │ ├── asm │ │ ├── ASMTransformerMakeVolatile.java │ │ └── MakeVolatile.java │ │ ├── common │ │ ├── CheckedThreadLocalRandom.java │ │ ├── ConcurrentFlagMatrix.java │ │ ├── Config.java │ │ ├── IStrongholdGenerator.java │ │ ├── XPieceDataExtension.java │ │ └── debug │ │ │ ├── SMAPPool.java │ │ │ └── SMAPSourceDebugExtension.java │ │ ├── mixin │ │ ├── deadlocks │ │ │ └── MixinDataFixerType.java │ │ ├── threading │ │ │ ├── MixinChunk.java │ │ │ ├── MixinDesertTempleGenerator.java │ │ │ ├── MixinJungleTempleGenerator.java │ │ │ ├── MixinMineshaftGeneratorMineshaftCorridor.java │ │ │ ├── MixinMineshaftGeneratorMineshaftRoom.java │ │ │ ├── MixinNetherFortressGeneratorBridgePlatform.java │ │ │ ├── MixinNetherFortressGeneratorCorridorLeftTurn.java │ │ │ ├── MixinNetherFortressGeneratorCorridorRightTurn.java │ │ │ ├── MixinNetherFortressGeneratorPiece.java │ │ │ ├── MixinNetherFortressGeneratorPieceData.java │ │ │ ├── MixinNetherFortressGeneratorStart.java │ │ │ ├── MixinNoiseChunkGenerator.java │ │ │ ├── MixinOceanMonumentGeneratorBase.java │ │ │ ├── MixinOceanMonumentGeneratorPieceSetting.java │ │ │ ├── MixinRandomizedIntBlockStateProvider.java │ │ │ ├── MixinShiftableStructurePiece.java │ │ │ ├── MixinStrongholdGenerator.java │ │ │ ├── MixinStrongholdGeneratorChestCorridor.java │ │ │ ├── MixinStrongholdGeneratorPieceData.java │ │ │ ├── MixinStrongholdGeneratorPortalRoom.java │ │ │ ├── MixinStrongholdGeneratorSpiralStaircase.java │ │ │ ├── MixinStrongholdGeneratorStart.java │ │ │ ├── MixinStructure.java │ │ │ ├── MixinStructureChecker.java │ │ │ ├── MixinStructurePalettedBlockInfoList.java │ │ │ ├── MixinStructurePlacementData.java │ │ │ ├── MixinStructureStart.java │ │ │ ├── MixinSwampHutGenerator.java │ │ │ ├── MixinWoodlandMansionGeneratorGenerationPiece.java │ │ │ ├── MixinWoodlandMansionGeneratorMansionParameters.java │ │ │ └── math │ │ │ │ └── MixinAffineTransformation.java │ │ └── threading_detections │ │ │ ├── package-info.java │ │ │ ├── random_instances │ │ │ └── MixinWorld.java │ │ │ └── readonly_protection │ │ │ └── MixinChunkRegion.java │ │ └── package-info.java │ └── resources │ ├── c2me-fixes-worldgen-threading-issues.mixins.json │ └── fabric.mod.json ├── c2me-fixes-worldgen-vanilla-bugs ├── build.gradle └── src │ └── main │ ├── java │ └── com │ │ └── ishland │ │ └── c2me │ │ └── fixes │ │ └── worldgen │ │ └── vanilla_bugs │ │ ├── ModuleEntryPoint.java │ │ ├── mixin │ │ └── ensure_chunk_status_before_callback │ │ │ └── MixinChunkHolder.java │ │ └── package-info.java │ └── resources │ ├── c2me-fixes-worldgen-vanilla-bugs.mixins.json │ └── fabric.mod.json ├── c2me-notickvd ├── build.gradle └── src │ ├── main │ ├── java │ │ └── com │ │ │ └── ishland │ │ │ └── c2me │ │ │ └── notickvd │ │ │ ├── MixinPlugin.java │ │ │ ├── ModuleEntryPoint.java │ │ │ ├── common │ │ │ ├── ChunkLevelManagerExtension.java │ │ │ ├── Config.java │ │ │ ├── IChunkHolder.java │ │ │ ├── IRenderDistanceOverride.java │ │ │ ├── NoTickSystem.java │ │ │ ├── NoTickVDInitializer.java │ │ │ ├── PlayerNoTickLoader.java │ │ │ ├── ServerExtNetworking.java │ │ │ ├── iterators │ │ │ │ ├── ChunkIterator.java │ │ │ │ └── SpiralIterator.java │ │ │ └── modimpl │ │ │ │ ├── ChunkPosDistanceLevelPropagatorExtended.java │ │ │ │ └── LevelPropagatorExtended.java │ │ │ ├── mixin │ │ │ ├── MixinChunkHolder.java │ │ │ ├── MixinChunkLevelManager.java │ │ │ ├── MixinChunkLevelManagerNearbyChunkTicketUpdater.java │ │ │ ├── MixinMinecraftServer.java │ │ │ ├── MixinPlayerManager.java │ │ │ ├── MixinServerAccessibleChunkSending.java │ │ │ ├── MixinServerBlockTicking.java │ │ │ ├── MixinServerChunkManager.java │ │ │ ├── MixinSimulationDistanceLevelPropagator.java │ │ │ ├── MixinThreadedAnvilChunkStorage.java │ │ │ ├── MixinWorld.java │ │ │ ├── MixinWorldChunk.java │ │ │ ├── client │ │ │ │ └── MixinIntegratedServer.java │ │ │ └── ext_render_distance │ │ │ │ ├── MixinServerConfigurationNetworkHandler.java │ │ │ │ └── MixinServerPlayNetworkHandler.java │ │ │ └── package-info.java │ └── resources │ │ ├── c2me-notickvd.mixins.json │ │ └── fabric.mod.json │ └── test │ └── java │ └── com │ └── ishland │ └── c2me │ └── notickvd │ └── common │ └── iterators │ └── TestIterators.java ├── c2me-opts-allocs ├── build.gradle └── src │ └── main │ ├── java │ └── com │ │ └── ishland │ │ └── c2me │ │ └── opts │ │ └── allocs │ │ ├── MixinPlugin.java │ │ ├── ModuleEntryPoint.java │ │ ├── common │ │ ├── ObjectCachingUtils.java │ │ ├── PooledFeatureContext.java │ │ └── ducks │ │ │ └── CombinedBlockPredicateExtension.java │ │ ├── mixin │ │ ├── MixinIdentifier.java │ │ ├── MixinNbtCompound.java │ │ ├── MixinNbtCompound1.java │ │ ├── MixinNbtList.java │ │ ├── MixinUtil.java │ │ ├── object_pooling_caching │ │ │ ├── MixinConfiguredFeature.java │ │ │ └── MixinOreFeature.java │ │ ├── predicates │ │ │ ├── MixinAllOfBlockPredicate.java │ │ │ ├── MixinAnyOfBlockPredicate.java │ │ │ ├── MixinCombinedBlockPredicate.java │ │ │ └── MixinOffsetPredicate.java │ │ └── surfacebuilder │ │ │ ├── MixinMaterialRuleContext.java │ │ │ ├── MixinMaterialRulesSequenceBlockStateRule.java │ │ │ └── MixinMaterialRulesSequenceMaterialRule.java │ │ └── package-info.java │ └── resources │ ├── c2me-opts-allocs.mixins.json │ └── fabric.mod.json ├── c2me-opts-chunkio ├── build.gradle └── src │ └── main │ ├── java │ └── com │ │ └── ishland │ │ └── c2me │ │ └── opts │ │ └── chunkio │ │ ├── MixinPlugin.java │ │ ├── ModuleEntryPoint.java │ │ ├── common │ │ └── Config.java │ │ ├── mixin │ │ ├── hide_sync_disk_writes_behind_flag │ │ │ └── MixinRegionBasedStorage.java │ │ └── limit_nbt_cache │ │ │ └── MixinStorageIoWorker.java │ │ └── package-info.java │ └── resources │ ├── c2me-opts-chunkio.mixins.json │ └── fabric.mod.json ├── c2me-opts-dfc ├── build.gradle └── src │ └── main │ ├── java │ └── com │ │ └── ishland │ │ └── c2me │ │ └── opts │ │ └── dfc │ │ ├── ModuleEntryPoint.java │ │ ├── common │ │ ├── ast │ │ │ ├── AstNode.java │ │ │ ├── AstTransformer.java │ │ │ ├── EvalType.java │ │ │ ├── McToAst.java │ │ │ ├── binary │ │ │ │ ├── AbstractBinaryNode.java │ │ │ │ ├── AddNode.java │ │ │ │ ├── MaxNode.java │ │ │ │ ├── MaxShortNode.java │ │ │ │ ├── MinNode.java │ │ │ │ ├── MinShortNode.java │ │ │ │ └── MulNode.java │ │ │ ├── dfvisitor │ │ │ │ └── StripBlending.java │ │ │ ├── misc │ │ │ │ ├── CacheLikeNode.java │ │ │ │ ├── ConstantNode.java │ │ │ │ ├── DelegateNode.java │ │ │ │ ├── RangeChoiceNode.java │ │ │ │ ├── RootNode.java │ │ │ │ └── YClampedGradientNode.java │ │ │ ├── noise │ │ │ │ ├── DFTNoiseNode.java │ │ │ │ ├── DFTShiftANode.java │ │ │ │ ├── DFTShiftBNode.java │ │ │ │ ├── DFTShiftNode.java │ │ │ │ ├── DFTWeirdScaledSamplerNode.java │ │ │ │ └── ShiftedNoiseNode.java │ │ │ ├── spline │ │ │ │ ├── SplineAstNode.java │ │ │ │ └── SplineSupport.java │ │ │ └── unary │ │ │ │ ├── AbsNode.java │ │ │ │ ├── AbstractUnaryNode.java │ │ │ │ ├── CubeNode.java │ │ │ │ ├── NegMulNode.java │ │ │ │ ├── SquareNode.java │ │ │ │ └── SqueezeNode.java │ │ ├── ducks │ │ │ ├── IArrayCacheCapable.java │ │ │ ├── IBlendingAwareVisitor.java │ │ │ ├── ICoordinatesFilling.java │ │ │ ├── IEqualityOverriding.java │ │ │ └── IFastCacheLike.java │ │ ├── gen │ │ │ ├── BytecodeGen.java │ │ │ ├── CompiledDensityFunction.java │ │ │ ├── CompiledEntry.java │ │ │ ├── DelegatingBlendingAwareVisitor.java │ │ │ ├── IMultiMethod.java │ │ │ ├── ISingleMethod.java │ │ │ └── SubCompiledDensityFunction.java │ │ ├── util │ │ │ └── ArrayCache.java │ │ └── vif │ │ │ ├── AstVanillaInterface.java │ │ │ ├── EachApplierVanillaInterface.java │ │ │ └── NoisePosVanillaInterface.java │ │ └── mixin │ │ ├── MixinChunkNoiseSampler.java │ │ ├── MixinChunkNoiseSampler1.java │ │ ├── MixinChunkNoiseSamplerCache2D.java │ │ ├── MixinChunkNoiseSamplerCacheOnce.java │ │ ├── MixinChunkNoiseSamplerCellCache.java │ │ ├── MixinChunkNoiseSamplerDensityInterpolator.java │ │ ├── MixinChunkNoiseSamplerFlatCache.java │ │ ├── MixinDFTBinaryOperation.java │ │ ├── MixinDFTWrapping.java │ │ ├── MixinNoiseConfig.java │ │ └── MixinSplineImplementation.java │ └── resources │ ├── c2me-opts-dfc.mixins.json │ └── fabric.mod.json ├── c2me-opts-math ├── build.gradle └── src │ └── main │ ├── java │ └── com │ │ └── ishland │ │ └── c2me │ │ └── opts │ │ └── math │ │ ├── ModuleEntryPoint.java │ │ ├── mixin │ │ ├── MixinChunkPos.java │ │ ├── MixinOctavePerlinNoiseSampler.java │ │ └── MixinPerlinNoiseSampler.java │ │ └── package-info.java │ └── resources │ ├── c2me-opts-math.mixins.json │ └── fabric.mod.json ├── c2me-opts-natives-math ├── build.gradle └── src │ ├── c │ ├── CMakeLists.txt │ ├── exports.c │ ├── exports_x86_64_nogather.c │ ├── flibc.c │ ├── includes │ │ ├── ext_math.h │ │ └── target_macros.h │ ├── system_isa_aarch64.c │ ├── system_isa_x86_64.c │ └── targets │ │ ├── darwin-x86_64.cmake │ │ ├── linux-aarch_64.cmake │ │ ├── linux-x86_64.cmake │ │ └── windows-x86_64.cmake │ └── main │ ├── java │ └── com │ │ └── ishland │ │ └── c2me │ │ └── opts │ │ └── natives_math │ │ ├── ModuleEntryPoint.java │ │ ├── common │ │ ├── Bindings.java │ │ ├── BindingsTemplate.java │ │ ├── ISATarget.java │ │ ├── NativeLoader.java │ │ ├── ducks │ │ │ └── INativePointer.java │ │ ├── isa │ │ │ ├── ISA_aarch64.java │ │ │ └── ISA_x86_64.java │ │ └── util │ │ │ └── MemoryUtil.java │ │ └── mixin │ │ ├── MixinBiomeAccess.java │ │ ├── MixinDFTypesEndIslands.java │ │ ├── MixinDoublePerlinNoiseSampler.java │ │ ├── MixinInterpolatedNoiseSampler.java │ │ └── df │ │ ├── MixinDFTNoise.java │ │ ├── MixinDFTShift.java │ │ ├── MixinDFTShiftA.java │ │ └── MixinDFTShiftB.java │ └── resources │ ├── c2me-opts-natives-math.mixins.json │ └── fabric.mod.json ├── c2me-opts-scheduling ├── build.gradle └── src │ └── main │ ├── java │ └── com │ │ └── ishland │ │ └── c2me │ │ └── opts │ │ └── scheduling │ │ ├── ModuleEntryPoint.java │ │ ├── common │ │ ├── Config.java │ │ ├── DuckChunkHolder.java │ │ ├── IThreadedAnvilChunkStorage.java │ │ ├── ITryFlushable.java │ │ ├── ServerMidTickTask.java │ │ └── idle_tasks │ │ │ └── IThreadedAnvilChunkStorage.java │ │ ├── mixin │ │ ├── MixinPlugin.java │ │ ├── general_overheads │ │ │ └── MixinThreadedAnvilChunkStorage.java │ │ ├── idle_tasks │ │ │ ├── autosave │ │ │ │ ├── disable_vanilla_mid_tick_autosave │ │ │ │ │ └── MixinThreadedAnvilChunkStorage.java │ │ │ │ └── enhanced_autosave │ │ │ │ │ ├── MixinMinecraftServer.java │ │ │ │ │ └── MixinThreadedAnvilChunkStorage.java │ │ │ └── package-info.java │ │ ├── mid_tick_chunk_tasks │ │ │ ├── MixinMinecraftServer.java │ │ │ ├── MixinServerChunkManager.java │ │ │ ├── MixinServerWorld.java │ │ │ └── MixinWorld.java │ │ ├── ordering │ │ │ ├── package-info.java │ │ │ └── player_move │ │ │ │ └── MixinServerPlayNetworkHandler.java │ │ ├── shutdown │ │ │ ├── MixinMinecraftServer.java │ │ │ ├── MixinServerEntityManager.java │ │ │ └── MixinServerWorld.java │ │ └── task_scheduling │ │ │ ├── MixinChunkHolder.java │ │ │ ├── MixinEntityChunkDataAccess.java │ │ │ └── MixinServerChunkManager.java │ │ └── package-info.java │ └── resources │ ├── c2me-opts-scheduling.mixins.json │ └── fabric.mod.json ├── c2me-opts-worldgen-biome-cache └── build.gradle ├── c2me-opts-worldgen-general ├── build.gradle └── src │ └── main │ ├── java │ └── com │ │ └── ishland │ │ └── c2me │ │ └── opts │ │ └── worldgen │ │ └── general │ │ ├── ModuleEntryPoint.java │ │ ├── common │ │ └── random_instances │ │ │ ├── RandomUtils.java │ │ │ └── SimplifiedAtomicSimpleRandom.java │ │ ├── mixin │ │ └── random_instances │ │ │ ├── MixinAtomicSimpleRandomFactory.java │ │ │ ├── MixinRedirectAtomicSimpleRandom.java │ │ │ └── MixinRedirectAtomicSimpleRandomStatic.java │ │ └── package-info.java │ └── resources │ ├── c2me-opts-worldgen-general.mixins.json │ └── fabric.mod.json ├── c2me-opts-worldgen-vanilla ├── build.gradle └── src │ └── main │ ├── java │ └── com │ │ └── ishland │ │ └── c2me │ │ └── opts │ │ └── worldgen │ │ └── vanilla │ │ ├── MixinPlugin.java │ │ ├── ModuleEntryPoint.java │ │ ├── common │ │ └── Config.java │ │ ├── mixin │ │ ├── aquifer │ │ │ └── MixinAquiferSamplerImpl.java │ │ ├── structure_weight_sampler │ │ │ └── MixinStructureWeightSampler.java │ │ ├── the_end_biome_cache │ │ │ └── MixinTheEndBiomeSource.java │ │ └── tlcache │ │ │ └── MixinBlock.java │ │ └── package-info.java │ └── resources │ ├── c2me-opts-worldgen-vanilla.mixins.json │ └── fabric.mod.json ├── c2me-rewrites-chunk-serializer ├── build.gradle └── src │ ├── main │ ├── java │ │ └── com │ │ │ └── ishland │ │ │ └── c2me │ │ │ └── rewrites │ │ │ └── chunk_serializer │ │ │ ├── ModuleEntryPoint.java │ │ │ ├── TheMod.java │ │ │ ├── common │ │ │ ├── ChunkDataSerializer.java │ │ │ ├── ChunkStatusAccessor.java │ │ │ ├── HeightMapTypeAccessor.java │ │ │ ├── NbtWriter.java │ │ │ ├── NbtWriterVisitor.java │ │ │ ├── StructureFeatureAccessor.java │ │ │ └── utils │ │ │ │ ├── AccessControllerUtils.java │ │ │ │ ├── LithiumUtil.java │ │ │ │ ├── ReflectionUtils.java │ │ │ │ ├── StarLightUtil.java │ │ │ │ ├── StringBytesConvertible.java │ │ │ │ └── UnsafeUtils.java │ │ │ └── mixin │ │ │ ├── ChunkStatusMixin.java │ │ │ ├── HeightMapTypeMixin.java │ │ │ ├── IStarlightSaveState.java │ │ │ ├── IdentifierMixin.java │ │ │ ├── MixinThreadedAnvilChunkStorage.java │ │ │ └── StructureFeatureMixin.java │ └── resources │ │ ├── c2me-rewrites-chunk-serializer.mixins.json │ │ └── fabric.mod.json │ └── test │ └── java │ └── com │ └── ishland │ └── c2me │ └── rewrites │ └── chunk_serializer │ ├── TestWeaklyTypedNbt.java │ └── package-info.java ├── c2me-rewrites-chunk-system ├── build.gradle └── src │ └── main │ ├── java │ └── com │ │ └── ishland │ │ └── c2me │ │ └── rewrites │ │ └── chunksystem │ │ ├── MixinPlugin.java │ │ ├── ModuleEntryPoint.java │ │ ├── common │ │ ├── ChunkLoadingContext.java │ │ ├── ChunkState.java │ │ ├── Config.java │ │ ├── NewChunkHolderVanillaInterface.java │ │ ├── NewChunkStatus.java │ │ ├── TheChunkSystem.java │ │ ├── TheSpeedyObjectFactory.java │ │ ├── TicketTypeExtension.java │ │ ├── async_chunkio │ │ │ ├── AsyncSerializationManager.java │ │ │ ├── BlendingInfoUtil.java │ │ │ ├── ChunkIoMainThreadTaskUtils.java │ │ │ ├── ChunkIoThreadingExecutorUtils.java │ │ │ ├── ProtoChunkExtension.java │ │ │ └── TaskCancellationException.java │ │ ├── compat │ │ │ ├── lithium │ │ │ │ └── LithiumChunkStatusTrackerInvoker.java │ │ │ └── package-info.java │ │ ├── ducks │ │ │ ├── IChunkSystemAccess.java │ │ │ ├── IPOIUnloading.java │ │ │ └── WorldChunkExtension.java │ │ ├── fapi │ │ │ └── LifecycleEventInvoker.java │ │ ├── quirks │ │ │ └── FlowableFluidUtils.java │ │ ├── statuses │ │ │ ├── Deferred.java │ │ │ ├── ReadFromDisk.java │ │ │ ├── ReadFromDiskAsync.java │ │ │ ├── ServerAccessible.java │ │ │ ├── ServerAccessibleChunkSending.java │ │ │ ├── ServerBlockTicking.java │ │ │ ├── ServerEntityTicking.java │ │ │ └── VanillaWorldGenerationDelegate.java │ │ ├── structs │ │ │ └── ChunkSystemExecutors.java │ │ └── threadstate │ │ │ └── ChunkTaskWork.java │ │ └── mixin │ │ ├── MixinChunkGenerator.java │ │ ├── MixinChunkHolder.java │ │ ├── MixinChunkLevelManager.java │ │ ├── MixinChunkTicketManagerTicketDistanceLevelPropagator.java │ │ ├── MixinMinecraftServer.java │ │ ├── MixinNoiseChunkGenerator.java │ │ ├── MixinPointOfInterestStorage.java │ │ ├── MixinSerializingRegionBasedStorage.java │ │ ├── MixinServerChunkManager.java │ │ ├── MixinThreadedAnvilChunkStorage.java │ │ ├── MixinWorldChunk.java │ │ ├── MixinWorldGenerationProgressLogger.java │ │ ├── async_serialization │ │ ├── MixinBlender.java │ │ ├── MixinChunkRegion.java │ │ ├── MixinChunkSerializer.java │ │ ├── MixinProtoChunk.java │ │ ├── MixinStorageIoWorker.java │ │ └── MixinThreadedAnvilChunkStorage.java │ │ ├── fixes │ │ └── MixinServerEntityManager.java │ │ └── fluid_postprocessing │ │ └── MixinWorldChunk.java │ └── resources │ ├── c2me-rewrites-chunk-system.mixins.json │ └── fabric.mod.json ├── c2me-rewrites-chunkio ├── build.gradle └── src │ └── main │ ├── java │ └── com │ │ └── ishland │ │ └── c2me │ │ └── rewrites │ │ └── chunkio │ │ ├── ModuleEntryPoint.java │ │ ├── common │ │ ├── C2MEStorageThread.java │ │ └── C2MEStorageVanillaInterface.java │ │ ├── mixin │ │ ├── MixinChunkPosKeyedStorage.java │ │ ├── MixinRecreatedChunkStorage.java │ │ ├── MixinRecreationStorage.java │ │ ├── MixinStorageIoWorker.java │ │ └── MixinVersionedChunkStorage.java │ │ └── package-info.java │ └── resources │ ├── c2me-rewrites-chunkio.mixins.json │ └── fabric.mod.json ├── c2me-server-utils ├── build.gradle └── src │ └── main │ ├── java │ └── com │ │ └── ishland │ │ └── c2me │ │ └── server │ │ └── utils │ │ ├── ModuleEntryPoint.java │ │ ├── common │ │ └── C2MECommands.java │ │ ├── mixin │ │ └── MixinCommandManager.java │ │ └── package-info.java │ └── resources │ ├── c2me-server-utils.mixins.json │ └── fabric.mod.json ├── c2me-threading-lighting ├── build.gradle └── src │ └── main │ ├── java │ └── com │ │ └── ishland │ │ └── c2me │ │ └── threading │ │ └── lighting │ │ ├── ModuleEntryPoint.java │ │ ├── mixin │ │ ├── MixinServerLightingProvider.java │ │ ├── MixinThreadedAnvilChunkStorage.java │ │ └── scalablelux │ │ │ └── MixinSchedulingUtil.java │ │ └── package-info.java │ └── resources │ ├── c2me-threading-lighting.mixins.json │ └── fabric.mod.json ├── gradle.properties ├── gradle └── wrapper │ ├── gradle-wrapper.jar │ └── gradle-wrapper.properties ├── gradlew ├── gradlew.bat ├── libs ├── build.gradle └── src │ └── main │ └── java │ ├── com │ └── ishland │ │ └── c2me │ │ └── libs │ │ ├── Locator.java │ │ ├── package-info.java │ │ └── vectorized_algorithms │ │ ├── VectorizedAlgorithms.java │ │ └── VectorizedPerlinNoise.java │ └── module-info.java ├── settings.gradle ├── src ├── jmh │ └── java │ │ ├── aquifer │ │ └── AddressingBenchmark.java │ │ ├── natives │ │ ├── Base_x86_64.java │ │ ├── BiomeAccessBenchmark.java │ │ ├── DoublePerlinNoiseBatchBenchmark.java │ │ ├── DoublePerlinNoiseBenchmark.java │ │ ├── EndIslandsBenchmark.java │ │ ├── InterpolatedNoiseBenchmark.java │ │ ├── PerlinNoiseBenchmark.java │ │ ├── accuracy │ │ │ ├── AbstractAccuracy.java │ │ │ ├── BiomeAccessAccuracy.java │ │ │ ├── DoublePerlinNoiseAccuracy.java │ │ │ ├── EndIslandsAccuracy.java │ │ │ └── InterpolatedNoiseAccuracy.java │ │ └── support │ │ │ ├── InterpolatedNoiseSamplerCopy.java │ │ │ └── ReflectUtils.java │ │ └── structure_weight_sampler │ │ └── MagnitudeHeightBenchmark.java └── main │ ├── java │ └── com │ │ └── ishland │ │ └── c2me │ │ ├── C2MEMod.java │ │ └── PreLaunchHandler.java │ └── resources │ ├── assets │ └── c2me │ │ └── icon.png │ └── fabric.mod.json └── tests ├── build.gradle ├── c2me-aof-devlaunch └── build.gradle ├── c2me-aof-test └── build.gradle ├── c2me-modpack-devlaunch └── build.gradle ├── c2me-modpack-test └── build.gradle ├── c2me-test └── build.gradle ├── test-mod └── src │ └── main │ ├── java │ └── com │ │ └── ishland │ │ └── c2me │ │ └── tests │ │ └── testmod │ │ ├── C2METestMod.java │ │ ├── IMinecraftServer.java │ │ ├── PreGenTask.java │ │ ├── ShouldKeepTickingUtils.java │ │ └── mixin │ │ ├── IChunkGenerator.java │ │ ├── IServerChunkManager.java │ │ ├── IThreadedAnvilChunkStorage.java │ │ ├── MixinWorldView.java │ │ ├── TestMixinPlugin.java │ │ ├── fix │ │ ├── MixinFixDevLaunch.java │ │ ├── client │ │ │ ├── MixinEntityModelLayers.java │ │ │ └── MixinMain.java │ │ ├── logspam │ │ │ └── MixinUniformHeightProvider.java │ │ ├── mem_effects │ │ │ └── MixinIngredient.java │ │ └── remapper_being_broken │ │ │ └── MixinGeneralUtils.java │ │ ├── package-info.java │ │ ├── pregen │ │ ├── MixinCrashReport.java │ │ ├── MixinMain.java │ │ ├── MixinMinecraftDedicatedServer.java │ │ ├── MixinMinecraftServer.java │ │ ├── MixinServerChunkManager.java │ │ ├── MixinServerPropertiesHandler.java │ │ ├── MixinServerTask.java │ │ ├── MixinServerWorld.java │ │ └── MixinStructureFeature.java │ │ └── what │ │ └── MixinChunkLevelManager.java │ └── resources │ ├── c2metests.mixins.json │ └── fabric.mod.json ├── vanilla-modpack-test └── build.gradle ├── vanilla-test └── build.gradle └── world-diff ├── build.gradle └── src └── main ├── java └── com │ └── ishland │ └── c2me │ └── tests │ └── worlddiff │ ├── ComparisonSession.java │ ├── Main.java │ └── mixin │ ├── IChunkSerializer.java │ ├── IDynamicRegistryManager.java │ ├── IStorageIoWorker.java │ ├── IWorldUpdater.java │ ├── MixinMain.java │ └── MixinWorldUpdater.java └── resources ├── c2meworlddiff.mixins.json └── fabric.mod.json /.gitmodules: -------------------------------------------------------------------------------- 1 | [submodule "FlowSched"] 2 | path = FlowSched 3 | url = https://github.com/RelativityMC/FlowSched.git 4 | -------------------------------------------------------------------------------- /Jenkinsfile: -------------------------------------------------------------------------------- 1 | pipeline { 2 | agent { label 'slave' } 3 | options { timestamps() } 4 | stages { 5 | stage('SCM-SKIP') { 6 | steps { 7 | scmSkip(skipPattern:'.*\\[ci skip\\].*') 8 | } 9 | } 10 | stage('Build') { 11 | tools { 12 | jdk "OpenJDK 21" 13 | } 14 | steps { 15 | withMaven( 16 | maven: '3', 17 | mavenLocalRepo: '.repository', 18 | publisherStrategy: 'EXPLICIT' 19 | ) { 20 | sh 'git fetch --tags' 21 | sh 'git reset --hard' 22 | sh 'git submodule update --init --recursive --force' 23 | sh './gradlew clean build' 24 | } 25 | } 26 | post { 27 | success { 28 | archiveArtifacts "build/libs/*.jar" 29 | } 30 | failure { 31 | cleanWs() 32 | } 33 | } 34 | } 35 | } 36 | } 37 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | The MIT License (MIT) 2 | 3 | Copyright (c) 2021-2025 ishland 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in 13 | all copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 21 | THE SOFTWARE. 22 | -------------------------------------------------------------------------------- /buildSrc/build.gradle: -------------------------------------------------------------------------------- 1 | plugins { 2 | id 'java' 3 | id 'java-library' 4 | id 'java-gradle-plugin' 5 | } 6 | 7 | group = 'com.ishland.c2me' 8 | 9 | repositories { 10 | mavenCentral() 11 | maven { url = "https://jitpack.io" } 12 | maven { url = "https://maven.fabricmc.net/" } 13 | } 14 | 15 | dependencies { 16 | // https://mvnrepository.com/artifact/org.jetbrains/annotations 17 | implementation 'org.jetbrains:annotations:22.0.0' 18 | 19 | // https://mvnrepository.com/artifact/com.google.code.gson/gson 20 | implementation 'com.google.code.gson:gson:2.10.1' 21 | } 22 | 23 | gradlePlugin { 24 | plugins { 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /c2me-base/build.gradle: -------------------------------------------------------------------------------- 1 | apply plugin: 'com.gradleup.shadow' 2 | 3 | configurations { 4 | shadowInclude 5 | } 6 | 7 | dependencies { 8 | shadowInclude("com.ishland.flowsched:flowsched") { 9 | transitive = false 10 | } 11 | } 12 | 13 | shadowJar { 14 | archiveClassifier = "all-dev" 15 | configurations = [ project.configurations.shadowInclude ] 16 | } 17 | 18 | remapJar { 19 | input = shadowJar.archiveFile 20 | archiveFileName = shadowJar.archiveFileName.get().replaceAll("-dev\\.jar\$", ".jar") 21 | addNestedDependencies = true 22 | dependsOn shadowJar 23 | } 24 | 25 | -------------------------------------------------------------------------------- /c2me-base/src/main/java/com/ishland/c2me/base/C2MEBaseMod.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.base; 2 | 3 | import com.ishland.c2me.base.common.config.ConfigSystem; 4 | import net.fabricmc.loader.api.entrypoint.PreLaunchEntrypoint; 5 | 6 | public class C2MEBaseMod implements PreLaunchEntrypoint { 7 | @Override 8 | public void onPreLaunch() { 9 | ConfigSystem.flushConfig(); 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /c2me-base/src/main/java/com/ishland/c2me/base/TheMixinPlugin.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.base; 2 | 3 | import com.ishland.c2me.base.common.ModuleMixinPlugin; 4 | 5 | /** 6 | * Used internally for c2me-base, do not subclass. 7 | */ 8 | public final class TheMixinPlugin extends ModuleMixinPlugin { 9 | 10 | @Override 11 | public boolean shouldApplyMixin(String targetClassName, String mixinClassName) { 12 | if (!super.shouldApplyMixin(targetClassName, mixinClassName)) { 13 | return false; 14 | } 15 | 16 | if (mixinClassName.startsWith("com.ishland.c2me.base.mixin.util.log4j2shutdownhookisnomore.")) 17 | return ModuleEntryPoint.disableLoggingShutdownHook; 18 | 19 | if (mixinClassName.startsWith("com.ishland.c2me.base.mixin.client_movement.")) 20 | return ModuleEntryPoint.preventEarlyClientMovementTicks; 21 | 22 | return true; 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /c2me-base/src/main/java/com/ishland/c2me/base/common/C2MEConstants.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.base.common; 2 | 3 | public class C2MEConstants { 4 | 5 | public static final String MODID = "c2me"; 6 | public static final String EXT_RENDER_DISTANCE_ID = "ext_render_distance_v1"; // consists of one VarInt 7 | 8 | } 9 | -------------------------------------------------------------------------------- /c2me-base/src/main/java/com/ishland/c2me/base/common/config/ModStatuses.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.base.common.config; 2 | 3 | import net.fabricmc.loader.api.FabricLoader; 4 | 5 | public class ModStatuses { 6 | 7 | public static final boolean fabric_networking_api_v1 = FabricLoader.getInstance().isModLoaded("fabric-networking-api-v1"); 8 | public static final boolean fabric_lifecycle_events_v1 = FabricLoader.getInstance().isModLoaded("fabric-lifecycle-events-v1"); 9 | 10 | } 11 | -------------------------------------------------------------------------------- /c2me-base/src/main/java/com/ishland/c2me/base/common/scheduler/AbstractPosAwarePrioritizedTask.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.base.common.scheduler; 2 | 3 | import com.ishland.flowsched.executor.Task; 4 | import it.unimi.dsi.fastutil.objects.ReferenceArrayList; 5 | 6 | import java.util.Objects; 7 | 8 | public abstract class AbstractPosAwarePrioritizedTask implements Task { 9 | 10 | protected final ReferenceArrayList postExec = new ReferenceArrayList<>(4); 11 | private final long pos; 12 | private int priority = Integer.MAX_VALUE; 13 | 14 | public AbstractPosAwarePrioritizedTask(long pos) { 15 | this.pos = pos; 16 | } 17 | 18 | @Override 19 | public int priority() { 20 | return this.priority; 21 | } 22 | 23 | public void setPriority(int priority) { 24 | this.priority = priority; 25 | } 26 | 27 | public long getPos() { 28 | return this.pos; 29 | } 30 | 31 | public void addPostExec(Runnable runnable) { 32 | synchronized (this.postExec) { 33 | postExec.add(Objects.requireNonNull(runnable)); 34 | } 35 | } 36 | } 37 | -------------------------------------------------------------------------------- /c2me-base/src/main/java/com/ishland/c2me/base/common/scheduler/ISyncLoadManager.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.base.common.scheduler; 2 | 3 | import net.minecraft.util.math.ChunkPos; 4 | 5 | public interface ISyncLoadManager { 6 | 7 | ChunkPos getCurrentSyncLoad(); 8 | 9 | } 10 | -------------------------------------------------------------------------------- /c2me-base/src/main/java/com/ishland/c2me/base/common/scheduler/IVanillaChunkManager.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.base.common.scheduler; 2 | 3 | public interface IVanillaChunkManager { 4 | 5 | SchedulingManager c2me$getSchedulingManager(); 6 | 7 | } 8 | -------------------------------------------------------------------------------- /c2me-base/src/main/java/com/ishland/c2me/base/common/scheduler/ThreadLocalWorldGenSchedulingState.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.base.common.scheduler; 2 | 3 | import net.minecraft.server.world.ChunkHolder; 4 | 5 | public class ThreadLocalWorldGenSchedulingState { 6 | 7 | private static final ThreadLocal chunkHolder = new ThreadLocal<>(); 8 | 9 | public static ChunkHolder getChunkHolder() { 10 | return chunkHolder.get(); 11 | } 12 | 13 | public static void setChunkHolder(ChunkHolder holder) { 14 | chunkHolder.set(holder); 15 | } 16 | 17 | public static void clearChunkHolder() { 18 | chunkHolder.remove(); 19 | } 20 | 21 | } 22 | -------------------------------------------------------------------------------- /c2me-base/src/main/java/com/ishland/c2me/base/common/structs/RawByteArrayOutputStream.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.base.common.structs; 2 | 3 | import java.io.ByteArrayOutputStream; 4 | import java.nio.ByteBuffer; 5 | 6 | public class RawByteArrayOutputStream extends ByteArrayOutputStream { 7 | 8 | public RawByteArrayOutputStream() { 9 | super(); 10 | } 11 | 12 | public RawByteArrayOutputStream(int size) { 13 | super(size); 14 | } 15 | 16 | public ByteBuffer asByteBuffer() { 17 | return ByteBuffer.wrap(this.buf, 0, this.count); 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /c2me-base/src/main/java/com/ishland/c2me/base/common/theinterface/IDirectStorage.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.base.common.theinterface; 2 | 3 | import net.minecraft.util.math.ChunkPos; 4 | 5 | import java.util.concurrent.CompletableFuture; 6 | import java.util.concurrent.CompletionStage; 7 | 8 | public interface IDirectStorage { 9 | 10 | public CompletableFuture setRawChunkData(ChunkPos pos, byte[] data); 11 | 12 | public CompletableFuture setRawChunkData(ChunkPos pos, CompletableFuture data); 13 | 14 | } 15 | -------------------------------------------------------------------------------- /c2me-base/src/main/java/com/ishland/c2me/base/common/theinterface/IFastChunkHolder.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.base.common.theinterface; 2 | 3 | import net.minecraft.world.chunk.WorldChunk; 4 | 5 | public interface IFastChunkHolder { 6 | 7 | WorldChunk c2me$immediateWorldChunk(); 8 | 9 | } 10 | -------------------------------------------------------------------------------- /c2me-base/src/main/java/com/ishland/c2me/base/common/theinterface/PlayerEntityExtension.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.base.common.theinterface; 2 | 3 | public interface PlayerEntityExtension { 4 | 5 | void c2me$onForcedLoaded(); 6 | 7 | } 8 | -------------------------------------------------------------------------------- /c2me-base/src/main/java/com/ishland/c2me/base/common/threadstate/RunningWork.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.base.common.threadstate; 2 | 3 | public interface RunningWork { 4 | 5 | String toString(); 6 | 7 | } 8 | -------------------------------------------------------------------------------- /c2me-base/src/main/java/com/ishland/c2me/base/common/threadstate/SyncLoadWork.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.base.common.threadstate; 2 | 3 | import com.ishland.c2me.base.common.util.TimeUtil; 4 | import net.minecraft.server.world.ServerWorld; 5 | import net.minecraft.util.math.ChunkPos; 6 | import net.minecraft.world.chunk.ChunkStatus; 7 | 8 | public record SyncLoadWork(ServerWorld world, ChunkPos chunkPos, ChunkStatus targetStatus, boolean create, long startTime) implements RunningWork { 9 | 10 | public SyncLoadWork(ServerWorld world, ChunkPos chunkPos, ChunkStatus targetStatus, boolean create) { 11 | this(world, chunkPos, targetStatus, create, System.nanoTime()); 12 | } 13 | 14 | @Override 15 | public String toString() { 16 | return String.format("Sync load chunk %s to status %s in world %s (create=%s) (%s elapsed)", 17 | chunkPos, targetStatus, world.getRegistryKey().getValue(), create, TimeUtil.formatElapsedTime(System.nanoTime() - startTime)); 18 | } 19 | 20 | } 21 | -------------------------------------------------------------------------------- /c2me-base/src/main/java/com/ishland/c2me/base/common/util/AsyncNamedLockDelegateAsyncLock.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.base.common.util; 2 | 3 | import com.google.common.base.Preconditions; 4 | import com.ibm.asyncutil.locks.AsyncLock; 5 | import com.ibm.asyncutil.locks.AsyncNamedLock; 6 | 7 | import java.util.Optional; 8 | import java.util.concurrent.CompletionStage; 9 | 10 | public record AsyncNamedLockDelegateAsyncLock(AsyncNamedLock delegate, 11 | T name) implements AsyncLock { 12 | 13 | public AsyncNamedLockDelegateAsyncLock { 14 | Preconditions.checkNotNull(this.delegate()); 15 | } 16 | 17 | @Override 18 | public CompletionStage acquireLock() { 19 | return delegate.acquireLock(name); 20 | } 21 | 22 | @Override 23 | public Optional tryLock() { 24 | return delegate.tryLock(name); 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /c2me-base/src/main/java/com/ishland/c2me/base/common/util/BooleanUtils.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.base.common.util; 2 | 3 | public class BooleanUtils { 4 | 5 | public static boolean parseBoolean(String value) { 6 | if ("true".equalsIgnoreCase(value)) return true; 7 | if ("false".equalsIgnoreCase(value)) return false; 8 | throw new BooleanFormatException(value); 9 | } 10 | 11 | public static class BooleanFormatException extends RuntimeException { 12 | public BooleanFormatException() { 13 | super(); 14 | } 15 | 16 | public BooleanFormatException(String message) { 17 | super(message); 18 | } 19 | 20 | public BooleanFormatException(String message, Throwable cause) { 21 | super(message, cause); 22 | } 23 | 24 | public BooleanFormatException(Throwable cause) { 25 | super(cause); 26 | } 27 | 28 | protected BooleanFormatException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) { 29 | super(message, cause, enableSuppression, writableStackTrace); 30 | } 31 | } 32 | 33 | } 34 | -------------------------------------------------------------------------------- /c2me-base/src/main/java/com/ishland/c2me/base/common/util/CFUtil.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.base.common.util; 2 | 3 | import java.util.concurrent.CompletableFuture; 4 | import java.util.concurrent.locks.LockSupport; 5 | 6 | public class CFUtil { 7 | 8 | public static T join(CompletableFuture future) { 9 | while (!future.isDone()) { 10 | LockSupport.parkNanos("Waiting for future", 100000L); 11 | } 12 | return future.join(); 13 | } 14 | 15 | } 16 | -------------------------------------------------------------------------------- /c2me-base/src/main/java/com/ishland/c2me/base/common/util/DeepCloneable.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.base.common.util; 2 | 3 | public interface DeepCloneable { 4 | 5 | Object deepClone(); 6 | 7 | } 8 | -------------------------------------------------------------------------------- /c2me-base/src/main/java/com/ishland/c2me/base/common/util/ListIndexedIterable.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.base.common.util; 2 | 3 | import net.minecraft.util.collection.IndexedIterable; 4 | import org.jetbrains.annotations.NotNull; 5 | import org.jetbrains.annotations.Nullable; 6 | 7 | import java.util.Iterator; 8 | import java.util.List; 9 | 10 | public record ListIndexedIterable(List delegate) implements IndexedIterable { 11 | 12 | @Override 13 | public int getRawId(T entry) { 14 | return delegate.indexOf(entry); 15 | } 16 | 17 | @Nullable 18 | @Override 19 | public T get(int index) { 20 | return delegate.get(index); 21 | } 22 | 23 | @Override 24 | public int size() { 25 | return delegate.size(); 26 | } 27 | 28 | @NotNull 29 | @Override 30 | public Iterator iterator() { 31 | return delegate.iterator(); 32 | } 33 | } 34 | -------------------------------------------------------------------------------- /c2me-base/src/main/java/com/ishland/c2me/base/common/util/MCUtil.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.base.common.util; 2 | 3 | import net.minecraft.util.math.ChunkPos; 4 | 5 | public class MCUtil { 6 | 7 | private MCUtil() { 8 | } 9 | 10 | public static long toLong(ChunkPos pos) { 11 | return ((long)pos.x) | ((long)pos.z) << 32; 12 | } 13 | 14 | } 15 | -------------------------------------------------------------------------------- /c2me-base/src/main/java/com/ishland/c2me/base/common/util/ShouldKeepTickingUtils.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.base.common.util; 2 | 3 | import java.util.concurrent.atomic.AtomicInteger; 4 | import java.util.function.BooleanSupplier; 5 | 6 | public class ShouldKeepTickingUtils { 7 | 8 | public static BooleanSupplier minimumTicks(BooleanSupplier delegate, int minimum) { 9 | AtomicInteger ticks = new AtomicInteger(0); 10 | return () -> ticks.getAndIncrement() < minimum || delegate.getAsBoolean(); 11 | } 12 | 13 | } 14 | -------------------------------------------------------------------------------- /c2me-base/src/main/java/com/ishland/c2me/base/common/util/SneakyThrow.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.base.common.util; 2 | 3 | public class SneakyThrow { 4 | 5 | public static void sneaky(Throwable throwable) { 6 | throw0(throwable); 7 | } 8 | 9 | @SuppressWarnings("unchecked") 10 | private static void throw0(Throwable throwable) throws T { 11 | throw (T) throwable; 12 | } 13 | 14 | } 15 | -------------------------------------------------------------------------------- /c2me-base/src/main/java/com/ishland/c2me/base/common/util/UrlUtil.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.base.common.util; 2 | 3 | import java.net.MalformedURLException; 4 | import java.net.URL; 5 | import java.nio.file.Path; 6 | 7 | public class UrlUtil { 8 | 9 | private UrlUtil() { 10 | } 11 | 12 | public static URL asUrl(Path path) { 13 | try { 14 | return new URL(null, path.toUri().toString()); 15 | } catch (MalformedURLException e) { 16 | throw new RuntimeException(e); 17 | } 18 | } 19 | 20 | } 21 | -------------------------------------------------------------------------------- /c2me-base/src/main/java/com/ishland/c2me/base/mixin/access/IAquiferSamplerFluidLevel.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.base.mixin.access; 2 | 3 | import net.minecraft.world.gen.chunk.AquiferSampler; 4 | import org.spongepowered.asm.mixin.Mixin; 5 | 6 | @Mixin(AquiferSampler.FluidLevel.class) 7 | public interface IAquiferSamplerFluidLevel { 8 | 9 | } 10 | -------------------------------------------------------------------------------- /c2me-base/src/main/java/com/ishland/c2me/base/mixin/access/IAtomicSimpleRandomDeriver.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.base.mixin.access; 2 | 3 | import net.minecraft.util.math.random.CheckedRandom; 4 | import org.spongepowered.asm.mixin.Mixin; 5 | import org.spongepowered.asm.mixin.gen.Accessor; 6 | 7 | @Mixin(CheckedRandom.Splitter.class) 8 | public interface IAtomicSimpleRandomDeriver { 9 | 10 | @Accessor 11 | long getSeed(); 12 | 13 | } 14 | -------------------------------------------------------------------------------- /c2me-base/src/main/java/com/ishland/c2me/base/mixin/access/IBelowZeroRetrogen.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.base.mixin.access; 2 | 3 | import net.minecraft.world.chunk.BelowZeroRetrogen; 4 | import net.minecraft.world.chunk.ChunkStatus; 5 | import org.spongepowered.asm.mixin.Mixin; 6 | import org.spongepowered.asm.mixin.gen.Accessor; 7 | import org.spongepowered.asm.mixin.gen.Invoker; 8 | 9 | import java.util.BitSet; 10 | 11 | 12 | @Mixin(value = BelowZeroRetrogen.class) 13 | public interface IBelowZeroRetrogen { 14 | @Accessor 15 | BitSet getMissingBedrock(); 16 | 17 | @Invoker 18 | ChunkStatus invokeGetTargetStatus(); 19 | } 20 | -------------------------------------------------------------------------------- /c2me-base/src/main/java/com/ishland/c2me/base/mixin/access/IBlender.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.base.mixin.access; 2 | 3 | import net.minecraft.world.gen.chunk.Blender; 4 | import org.spongepowered.asm.mixin.Mixin; 5 | import org.spongepowered.asm.mixin.gen.Accessor; 6 | 7 | @Mixin(Blender.class) 8 | public interface IBlender { 9 | 10 | @Accessor 11 | static int getBLENDING_CHUNK_DISTANCE_THRESHOLD() { 12 | throw new AbstractMethodError(); 13 | } 14 | 15 | } 16 | -------------------------------------------------------------------------------- /c2me-base/src/main/java/com/ishland/c2me/base/mixin/access/IBlendingData.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.base.mixin.access; 2 | 3 | import net.minecraft.world.HeightLimitView; 4 | import net.minecraft.world.gen.chunk.BlendingData; 5 | import org.spongepowered.asm.mixin.Mixin; 6 | import org.spongepowered.asm.mixin.gen.Accessor; 7 | 8 | 9 | @Mixin(value = BlendingData.class) 10 | public interface IBlendingData { 11 | @Accessor 12 | HeightLimitView getOldHeightLimit(); 13 | 14 | @Accessor 15 | double[] getSurfaceHeights(); 16 | } 17 | -------------------------------------------------------------------------------- /c2me-base/src/main/java/com/ishland/c2me/base/mixin/access/IBlockEntity.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.base.mixin.access; 2 | 3 | import net.minecraft.block.entity.BlockEntity; 4 | import net.minecraft.nbt.NbtCompound; 5 | import org.spongepowered.asm.mixin.Mixin; 6 | import org.spongepowered.asm.mixin.gen.Invoker; 7 | 8 | @Mixin(BlockEntity.class) 9 | public interface IBlockEntity { 10 | 11 | } 12 | -------------------------------------------------------------------------------- /c2me-base/src/main/java/com/ishland/c2me/base/mixin/access/IChunkGenerator.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.base.mixin.access; 2 | 3 | import net.minecraft.world.gen.chunk.ChunkGenerator; 4 | import org.spongepowered.asm.mixin.Mixin; 5 | 6 | @Mixin(ChunkGenerator.class) 7 | public interface IChunkGenerator { 8 | 9 | // @Invoker 10 | // void invokeGenerateStrongholdPositions(); 11 | 12 | } 13 | -------------------------------------------------------------------------------- /c2me-base/src/main/java/com/ishland/c2me/base/mixin/access/IChunkHolder.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.base.mixin.access; 2 | 3 | import net.minecraft.server.world.ChunkHolder; 4 | import org.spongepowered.asm.mixin.Mixin; 5 | import org.spongepowered.asm.mixin.gen.Invoker; 6 | 7 | import java.util.concurrent.CompletableFuture; 8 | 9 | @Mixin(ChunkHolder.class) 10 | public interface IChunkHolder { 11 | 12 | @Invoker 13 | void invokeCombineSavingFuture(CompletableFuture savingFuture); 14 | 15 | } 16 | -------------------------------------------------------------------------------- /c2me-base/src/main/java/com/ishland/c2me/base/mixin/access/IChunkLevelManager.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.base.mixin.access; 2 | 3 | import it.unimi.dsi.fastutil.longs.Long2ObjectMap; 4 | import it.unimi.dsi.fastutil.objects.ObjectSet; 5 | import net.minecraft.server.network.ServerPlayerEntity; 6 | import net.minecraft.server.world.ChunkLevelManager; 7 | import net.minecraft.server.world.ChunkTicketManager; 8 | import net.minecraft.server.world.SimulationDistanceLevelPropagator; 9 | import org.spongepowered.asm.mixin.Mixin; 10 | import org.spongepowered.asm.mixin.gen.Accessor; 11 | import org.spongepowered.asm.mixin.gen.Invoker; 12 | 13 | @Mixin(ChunkLevelManager.class) 14 | public interface IChunkLevelManager { 15 | 16 | @Invoker 17 | void invokeSetWatchDistance(int viewDistance); 18 | 19 | @Accessor 20 | Long2ObjectMap> getPlayersByChunkPos(); 21 | 22 | @Accessor 23 | ChunkLevelManager.NearbyChunkTicketUpdater getNearbyChunkTicketUpdater(); 24 | 25 | @Accessor 26 | SimulationDistanceLevelPropagator getSimulationDistanceLevelPropagator(); 27 | 28 | @Accessor 29 | ChunkTicketManager getTicketManager(); 30 | 31 | } 32 | -------------------------------------------------------------------------------- /c2me-base/src/main/java/com/ishland/c2me/base/mixin/access/IChunkLevelManagerDistanceFromNearestPlayerTracker.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.base.mixin.access; 2 | 3 | import net.minecraft.server.world.ChunkLevelManager; 4 | import org.spongepowered.asm.mixin.Mixin; 5 | import org.spongepowered.asm.mixin.gen.Accessor; 6 | 7 | @Mixin(ChunkLevelManager.DistanceFromNearestPlayerTracker.class) 8 | public interface IChunkLevelManagerDistanceFromNearestPlayerTracker { 9 | 10 | @Accessor 11 | int getMaxDistance(); 12 | 13 | } 14 | -------------------------------------------------------------------------------- /c2me-base/src/main/java/com/ishland/c2me/base/mixin/access/IChunkLevelManagerNearbyChunkTicketUpdater.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.base.mixin.access; 2 | 3 | import it.unimi.dsi.fastutil.longs.Long2IntMap; 4 | import net.minecraft.server.world.ChunkLevelManager; 5 | import org.spongepowered.asm.mixin.Mixin; 6 | import org.spongepowered.asm.mixin.gen.Accessor; 7 | 8 | @Mixin(ChunkLevelManager.NearbyChunkTicketUpdater.class) 9 | public interface IChunkLevelManagerNearbyChunkTicketUpdater { 10 | 11 | @Accessor 12 | Long2IntMap getDistances(); 13 | 14 | } 15 | -------------------------------------------------------------------------------- /c2me-base/src/main/java/com/ishland/c2me/base/mixin/access/IChunkNoiseSamplerDensityInterpolator.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.base.mixin.access; 2 | 3 | import net.minecraft.world.gen.chunk.ChunkNoiseSampler; 4 | import org.spongepowered.asm.mixin.Mixin; 5 | import org.spongepowered.asm.mixin.gen.Invoker; 6 | 7 | @Mixin(ChunkNoiseSampler.DensityInterpolator.class) 8 | public interface IChunkNoiseSamplerDensityInterpolator { 9 | 10 | @Invoker 11 | void invokeInterpolateX(double deltaX); 12 | 13 | @Invoker 14 | void invokeInterpolateY(double deltaY); 15 | 16 | @Invoker 17 | void invokeInterpolateZ(double deltaZ); 18 | 19 | } 20 | -------------------------------------------------------------------------------- /c2me-base/src/main/java/com/ishland/c2me/base/mixin/access/IChunkTickScheduler.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.base.mixin.access; 2 | 3 | import net.minecraft.world.tick.ChunkTickScheduler; 4 | import net.minecraft.world.tick.OrderedTick; 5 | import net.minecraft.world.tick.SerializableTickScheduler; 6 | import net.minecraft.world.tick.Tick; 7 | import org.jetbrains.annotations.Nullable; 8 | import org.spongepowered.asm.mixin.Mixin; 9 | import org.spongepowered.asm.mixin.gen.Accessor; 10 | 11 | import java.util.List; 12 | import java.util.Queue; 13 | 14 | @Mixin(ChunkTickScheduler.class) 15 | public interface IChunkTickScheduler extends SerializableTickScheduler { 16 | @Accessor 17 | @Nullable List> getTicks(); 18 | 19 | @Accessor 20 | Queue> getTickQueue(); 21 | 22 | } 23 | -------------------------------------------------------------------------------- /c2me-base/src/main/java/com/ishland/c2me/base/mixin/access/IChunkTicket.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.base.mixin.access; 2 | 3 | import net.minecraft.server.world.ChunkTicket; 4 | import org.spongepowered.asm.mixin.Mixin; 5 | import org.spongepowered.asm.mixin.gen.Invoker; 6 | 7 | @Mixin(ChunkTicket.class) 8 | public interface IChunkTicket { 9 | } 10 | -------------------------------------------------------------------------------- /c2me-base/src/main/java/com/ishland/c2me/base/mixin/access/IDensityFunctionTypesWeirdScaledSamplerRarityValueMapper.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.base.mixin.access; 2 | 3 | import it.unimi.dsi.fastutil.doubles.Double2DoubleFunction; 4 | import net.minecraft.world.gen.densityfunction.DensityFunctionTypes; 5 | import org.spongepowered.asm.mixin.Mixin; 6 | import org.spongepowered.asm.mixin.gen.Accessor; 7 | 8 | @Mixin(DensityFunctionTypes.WeirdScaledSampler.RarityValueMapper.class) 9 | public interface IDensityFunctionTypesWeirdScaledSamplerRarityValueMapper { 10 | 11 | @Accessor 12 | Double2DoubleFunction getScaleFunction(); 13 | 14 | } 15 | -------------------------------------------------------------------------------- /c2me-base/src/main/java/com/ishland/c2me/base/mixin/access/IDensityFunctionsCaveScaler.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.base.mixin.access; 2 | 3 | import net.minecraft.world.gen.densityfunction.DensityFunctions; 4 | import org.spongepowered.asm.mixin.Mixin; 5 | import org.spongepowered.asm.mixin.gen.Invoker; 6 | 7 | @Mixin(DensityFunctions.CaveScaler.class) 8 | public interface IDensityFunctionsCaveScaler { 9 | 10 | @Invoker 11 | public static double invokeScaleCaves(double value) { 12 | throw new AbstractMethodError(); 13 | } 14 | 15 | @Invoker 16 | public static double invokeScaleTunnels(double value) { 17 | throw new AbstractMethodError(); 18 | } 19 | 20 | } 21 | -------------------------------------------------------------------------------- /c2me-base/src/main/java/com/ishland/c2me/base/mixin/access/IInterpolatedNoiseSampler.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.base.mixin.access; 2 | 3 | import net.minecraft.util.math.noise.InterpolatedNoiseSampler; 4 | import net.minecraft.util.math.noise.OctavePerlinNoiseSampler; 5 | import org.spongepowered.asm.mixin.Mixin; 6 | import org.spongepowered.asm.mixin.gen.Accessor; 7 | 8 | @Mixin(InterpolatedNoiseSampler.class) 9 | public interface IInterpolatedNoiseSampler { 10 | 11 | @Accessor 12 | OctavePerlinNoiseSampler getLowerInterpolatedNoise(); 13 | 14 | @Accessor 15 | OctavePerlinNoiseSampler getUpperInterpolatedNoise(); 16 | 17 | @Accessor 18 | OctavePerlinNoiseSampler getInterpolationNoise(); 19 | 20 | @Accessor 21 | double getScaledXzScale(); 22 | 23 | @Accessor 24 | double getScaledYScale(); 25 | 26 | @Accessor 27 | double getXzFactor(); 28 | 29 | @Accessor 30 | double getYFactor(); 31 | 32 | @Accessor 33 | double getSmearScaleMultiplier(); 34 | 35 | @Accessor 36 | double getMaxValue(); 37 | 38 | @Accessor 39 | double getXzScale(); 40 | 41 | @Accessor 42 | double getYScale(); 43 | 44 | } 45 | -------------------------------------------------------------------------------- /c2me-base/src/main/java/com/ishland/c2me/base/mixin/access/IMultiNoiseBiomeSource.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.base.mixin.access; 2 | 3 | import net.minecraft.world.biome.source.MultiNoiseBiomeSource; 4 | import org.spongepowered.asm.mixin.Mixin; 5 | 6 | @Mixin(MultiNoiseBiomeSource.class) 7 | public interface IMultiNoiseBiomeSource { 8 | 9 | } 10 | -------------------------------------------------------------------------------- /c2me-base/src/main/java/com/ishland/c2me/base/mixin/access/INbtCompound.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.base.mixin.access; 2 | 3 | import net.minecraft.nbt.NbtCompound; 4 | import net.minecraft.nbt.NbtElement; 5 | import org.spongepowered.asm.mixin.Mixin; 6 | import org.spongepowered.asm.mixin.gen.Invoker; 7 | 8 | import java.util.Map; 9 | 10 | @Mixin(NbtCompound.class) 11 | public interface INbtCompound { 12 | 13 | } 14 | -------------------------------------------------------------------------------- /c2me-base/src/main/java/com/ishland/c2me/base/mixin/access/INbtList.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.base.mixin.access; 2 | 3 | import net.minecraft.nbt.NbtList; 4 | import org.spongepowered.asm.mixin.Mixin; 5 | import org.spongepowered.asm.mixin.gen.Invoker; 6 | 7 | @Mixin(NbtList.class) 8 | public interface INbtList { 9 | 10 | @Invoker("getValueType") 11 | byte invokeGetSerializedType(); 12 | 13 | } 14 | -------------------------------------------------------------------------------- /c2me-base/src/main/java/com/ishland/c2me/base/mixin/access/IOctavePerlinNoiseSampler.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.base.mixin.access; 2 | 3 | import it.unimi.dsi.fastutil.doubles.DoubleList; 4 | import net.minecraft.util.math.noise.OctavePerlinNoiseSampler; 5 | import net.minecraft.util.math.noise.PerlinNoiseSampler; 6 | import org.spongepowered.asm.mixin.Mixin; 7 | import org.spongepowered.asm.mixin.gen.Accessor; 8 | 9 | @Mixin(OctavePerlinNoiseSampler.class) 10 | public interface IOctavePerlinNoiseSampler { 11 | 12 | @Accessor 13 | PerlinNoiseSampler[] getOctaveSamplers(); 14 | 15 | @Accessor 16 | DoubleList getAmplitudes(); 17 | 18 | @Accessor 19 | double getPersistence(); 20 | 21 | @Accessor 22 | double getLacunarity(); 23 | 24 | } 25 | -------------------------------------------------------------------------------- /c2me-base/src/main/java/com/ishland/c2me/base/mixin/access/IPerlinNoiseSampler.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.base.mixin.access; 2 | 3 | import net.minecraft.util.math.noise.PerlinNoiseSampler; 4 | import org.spongepowered.asm.mixin.Mixin; 5 | import org.spongepowered.asm.mixin.gen.Accessor; 6 | 7 | @Mixin(PerlinNoiseSampler.class) 8 | public interface IPerlinNoiseSampler { 9 | 10 | @Accessor 11 | byte[] getPermutation(); 12 | 13 | } 14 | -------------------------------------------------------------------------------- /c2me-base/src/main/java/com/ishland/c2me/base/mixin/access/IPlayerEntity.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.base.mixin.access; 2 | 3 | import net.minecraft.entity.player.PlayerEntity; 4 | import org.spongepowered.asm.mixin.Mixin; 5 | import org.spongepowered.asm.mixin.gen.Accessor; 6 | 7 | @Mixin(PlayerEntity.class) 8 | public interface IPlayerEntity { 9 | 10 | @Accessor 11 | boolean getLoaded(); 12 | 13 | } 14 | -------------------------------------------------------------------------------- /c2me-base/src/main/java/com/ishland/c2me/base/mixin/access/IRegionBasedStorage.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.base.mixin.access; 2 | 3 | import net.minecraft.util.math.ChunkPos; 4 | import net.minecraft.world.storage.RegionBasedStorage; 5 | import net.minecraft.world.storage.RegionFile; 6 | import org.spongepowered.asm.mixin.Mixin; 7 | import org.spongepowered.asm.mixin.gen.Invoker; 8 | 9 | import java.io.IOException; 10 | 11 | @Mixin(RegionBasedStorage.class) 12 | public interface IRegionBasedStorage { 13 | 14 | @Invoker 15 | RegionFile invokeGetRegionFile(ChunkPos pos) throws IOException; 16 | 17 | } 18 | -------------------------------------------------------------------------------- /c2me-base/src/main/java/com/ishland/c2me/base/mixin/access/IRegionFile.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.base.mixin.access; 2 | 3 | import net.minecraft.util.math.ChunkPos; 4 | import net.minecraft.world.storage.ChunkCompressionFormat; 5 | import net.minecraft.world.storage.RegionFile; 6 | import org.spongepowered.asm.mixin.Mixin; 7 | import org.spongepowered.asm.mixin.gen.Accessor; 8 | import org.spongepowered.asm.mixin.gen.Invoker; 9 | 10 | import java.io.IOException; 11 | import java.nio.ByteBuffer; 12 | 13 | @Mixin(RegionFile.class) 14 | public interface IRegionFile { 15 | 16 | @Invoker 17 | void invokeWriteChunk(ChunkPos pos, ByteBuffer byteBuffer) throws IOException; 18 | 19 | @Accessor 20 | ChunkCompressionFormat getCompressionFormat(); 21 | 22 | } 23 | -------------------------------------------------------------------------------- /c2me-base/src/main/java/com/ishland/c2me/base/mixin/access/ISerializingRegionBasedStorage.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.base.mixin.access; 2 | 3 | import net.minecraft.world.storage.ChunkPosKeyedStorage; 4 | import net.minecraft.world.storage.SerializingRegionBasedStorage; 5 | import org.spongepowered.asm.mixin.Mixin; 6 | import org.spongepowered.asm.mixin.gen.Accessor; 7 | 8 | @Mixin(SerializingRegionBasedStorage.class) 9 | public interface ISerializingRegionBasedStorage { 10 | 11 | @Accessor 12 | ChunkPosKeyedStorage getStorageAccess(); 13 | 14 | } 15 | -------------------------------------------------------------------------------- /c2me-base/src/main/java/com/ishland/c2me/base/mixin/access/IServerChunkManager.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.base.mixin.access; 2 | 3 | import net.minecraft.server.world.ChunkTicketManager; 4 | import net.minecraft.server.world.ServerChunkManager; 5 | import org.spongepowered.asm.mixin.Mixin; 6 | import org.spongepowered.asm.mixin.gen.Accessor; 7 | import org.spongepowered.asm.mixin.gen.Invoker; 8 | 9 | @Mixin(ServerChunkManager.class) 10 | public interface IServerChunkManager { 11 | 12 | @Accessor 13 | ChunkTicketManager getTicketManager(); 14 | 15 | @Accessor 16 | ServerChunkManager.MainThreadExecutor getMainThreadExecutor(); 17 | 18 | @Invoker 19 | boolean invokeUpdateChunks(); 20 | 21 | } 22 | -------------------------------------------------------------------------------- /c2me-base/src/main/java/com/ishland/c2me/base/mixin/access/IServerEntityManager.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.base.mixin.access; 2 | 3 | import it.unimi.dsi.fastutil.longs.LongSet; 4 | import net.minecraft.server.world.ServerEntityManager; 5 | import org.spongepowered.asm.mixin.Mixin; 6 | import org.spongepowered.asm.mixin.gen.Invoker; 7 | 8 | @Mixin(ServerEntityManager.class) 9 | public interface IServerEntityManager { 10 | 11 | @Invoker 12 | LongSet invokeGetLoadedChunks(); 13 | 14 | } 15 | -------------------------------------------------------------------------------- /c2me-base/src/main/java/com/ishland/c2me/base/mixin/access/IServerLightingProvider.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.base.mixin.access; 2 | 3 | import net.minecraft.server.world.ServerLightingProvider; 4 | import net.minecraft.util.math.ChunkPos; 5 | import org.spongepowered.asm.mixin.Mixin; 6 | import org.spongepowered.asm.mixin.gen.Invoker; 7 | 8 | import java.util.function.IntSupplier; 9 | 10 | @Mixin(ServerLightingProvider.class) 11 | public interface IServerLightingProvider { 12 | 13 | @Invoker 14 | void invokeUpdateChunkStatus(ChunkPos pos); 15 | 16 | } 17 | -------------------------------------------------------------------------------- /c2me-base/src/main/java/com/ishland/c2me/base/mixin/access/ISimpleRandom.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.base.mixin.access; 2 | 3 | import net.minecraft.util.math.random.LocalRandom; 4 | import org.spongepowered.asm.mixin.Mixin; 5 | import org.spongepowered.asm.mixin.gen.Accessor; 6 | import org.spongepowered.asm.mixin.gen.Invoker; 7 | 8 | @Mixin(LocalRandom.class) 9 | public interface ISimpleRandom { 10 | 11 | @Accessor 12 | long getSeed(); 13 | 14 | @Invoker 15 | void invokeSetSeed(long seed); 16 | 17 | } 18 | -------------------------------------------------------------------------------- /c2me-base/src/main/java/com/ishland/c2me/base/mixin/access/ISimpleTickScheduler.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.base.mixin.access; 2 | 3 | import net.minecraft.world.tick.SerializableTickScheduler; 4 | import net.minecraft.world.tick.SimpleTickScheduler; 5 | import net.minecraft.world.tick.Tick; 6 | import org.spongepowered.asm.mixin.Mixin; 7 | import org.spongepowered.asm.mixin.gen.Accessor; 8 | 9 | import java.util.List; 10 | 11 | @Mixin(SimpleTickScheduler.class) 12 | public interface ISimpleTickScheduler extends SerializableTickScheduler { 13 | @Accessor 14 | List> getScheduledTicks(); 15 | } 16 | -------------------------------------------------------------------------------- /c2me-base/src/main/java/com/ishland/c2me/base/mixin/access/ISimplexNoiseSampler.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.base.mixin.access; 2 | 3 | import net.minecraft.util.math.noise.SimplexNoiseSampler; 4 | import org.spongepowered.asm.mixin.Mixin; 5 | import org.spongepowered.asm.mixin.gen.Accessor; 6 | 7 | @Mixin(SimplexNoiseSampler.class) 8 | public interface ISimplexNoiseSampler { 9 | 10 | @Accessor 11 | int[] getPermutation(); 12 | 13 | } 14 | -------------------------------------------------------------------------------- /c2me-base/src/main/java/com/ishland/c2me/base/mixin/access/ISimulationDistanceLevelPropagator.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.base.mixin.access; 2 | 3 | import it.unimi.dsi.fastutil.longs.Long2ByteMap; 4 | import net.minecraft.server.world.SimulationDistanceLevelPropagator; 5 | import org.spongepowered.asm.mixin.Mixin; 6 | import org.spongepowered.asm.mixin.gen.Accessor; 7 | 8 | @Mixin(SimulationDistanceLevelPropagator.class) 9 | public interface ISimulationDistanceLevelPropagator { 10 | 11 | @Accessor 12 | Long2ByteMap getLevels(); 13 | 14 | } 15 | -------------------------------------------------------------------------------- /c2me-base/src/main/java/com/ishland/c2me/base/mixin/access/IState.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.base.mixin.access; 2 | 3 | import com.mojang.serialization.MapCodec; 4 | import net.minecraft.state.State; 5 | import org.spongepowered.asm.mixin.Mixin; 6 | import org.spongepowered.asm.mixin.gen.Accessor; 7 | 8 | @Mixin(State.class) 9 | public interface IState { 10 | @Accessor 11 | MapCodec getCodec(); 12 | } 13 | -------------------------------------------------------------------------------- /c2me-base/src/main/java/com/ishland/c2me/base/mixin/access/IStorageIoWorker.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.base.mixin.access; 2 | 3 | import net.minecraft.world.storage.StorageIoWorker; 4 | import org.spongepowered.asm.mixin.Mixin; 5 | import org.spongepowered.asm.mixin.gen.Invoker; 6 | 7 | import java.util.BitSet; 8 | import java.util.concurrent.CompletableFuture; 9 | 10 | @Mixin(StorageIoWorker.class) 11 | public interface IStorageIoWorker { 12 | 13 | @Invoker 14 | CompletableFuture invokeGetOrComputeBlendingStatus(int chunkX, int chunkZ); 15 | 16 | } 17 | -------------------------------------------------------------------------------- /c2me-base/src/main/java/com/ishland/c2me/base/mixin/access/IStructurePiece.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.base.mixin.access; 2 | 3 | import net.minecraft.structure.StructurePiece; 4 | import net.minecraft.structure.StructurePieceType; 5 | import net.minecraft.util.BlockMirror; 6 | import net.minecraft.util.BlockRotation; 7 | import net.minecraft.util.math.BlockBox; 8 | import net.minecraft.util.math.Direction; 9 | import org.spongepowered.asm.mixin.Mixin; 10 | import org.spongepowered.asm.mixin.gen.Accessor; 11 | 12 | @Mixin(StructurePiece.class) 13 | public interface IStructurePiece { 14 | 15 | @Accessor 16 | StructurePieceType getType(); 17 | 18 | @Accessor 19 | BlockBox getBoundingBox(); 20 | 21 | @Accessor 22 | Direction getFacing(); 23 | 24 | @Accessor 25 | BlockMirror getMirror(); 26 | 27 | @Accessor 28 | BlockRotation getRotation(); 29 | 30 | @Accessor 31 | int getChainLength(); 32 | } 33 | -------------------------------------------------------------------------------- /c2me-base/src/main/java/com/ishland/c2me/base/mixin/access/IStructureStart.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.base.mixin.access; 2 | 3 | import net.minecraft.structure.StructurePiecesList; 4 | import net.minecraft.structure.StructureStart; 5 | import net.minecraft.world.gen.structure.Structure; 6 | import org.spongepowered.asm.mixin.Mixin; 7 | import org.spongepowered.asm.mixin.gen.Accessor; 8 | 9 | @Mixin(StructureStart.class) 10 | public interface IStructureStart { 11 | @Accessor 12 | Structure getStructure(); 13 | 14 | @Accessor 15 | StructurePiecesList getChildren(); 16 | 17 | @Accessor 18 | int getReferences(); 19 | } 20 | -------------------------------------------------------------------------------- /c2me-base/src/main/java/com/ishland/c2me/base/mixin/access/IStructureWeightSampler.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.base.mixin.access; 2 | 3 | import net.minecraft.world.gen.StructureWeightSampler; 4 | import org.spongepowered.asm.mixin.Mixin; 5 | 6 | @Mixin(StructureWeightSampler.class) 7 | public interface IStructureWeightSampler { 8 | 9 | } 10 | -------------------------------------------------------------------------------- /c2me-base/src/main/java/com/ishland/c2me/base/mixin/access/ISyncedClientOptions.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.base.mixin.access; 2 | 3 | import net.minecraft.network.packet.c2s.common.SyncedClientOptions; 4 | import org.spongepowered.asm.mixin.Mixin; 5 | import org.spongepowered.asm.mixin.Mutable; 6 | import org.spongepowered.asm.mixin.gen.Accessor; 7 | 8 | @Mixin(SyncedClientOptions.class) 9 | public interface ISyncedClientOptions { 10 | 11 | @Mutable 12 | @Accessor 13 | void setViewDistance(int viewDistance); 14 | 15 | } 16 | -------------------------------------------------------------------------------- /c2me-base/src/main/java/com/ishland/c2me/base/mixin/access/IThreadedAnvilChunkStorageLevelManager.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.base.mixin.access; 2 | 3 | import net.minecraft.server.world.ServerChunkLoadingManager; 4 | import org.spongepowered.asm.mixin.Mixin; 5 | import org.spongepowered.asm.mixin.gen.Accessor; 6 | 7 | @Mixin(ServerChunkLoadingManager.LevelManager.class) 8 | public interface IThreadedAnvilChunkStorageLevelManager { 9 | 10 | @Accessor("field_17443") 11 | ServerChunkLoadingManager c2me$getSuperClass(); 12 | 13 | } 14 | -------------------------------------------------------------------------------- /c2me-base/src/main/java/com/ishland/c2me/base/mixin/access/IUpgradeData.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.base.mixin.access; 2 | 3 | import net.minecraft.util.math.EightWayDirection; 4 | import net.minecraft.world.chunk.UpgradeData; 5 | import org.spongepowered.asm.mixin.Mixin; 6 | import org.spongepowered.asm.mixin.gen.Accessor; 7 | 8 | import java.util.EnumSet; 9 | 10 | @Mixin(UpgradeData.class) 11 | public interface IUpgradeData { 12 | @Accessor 13 | int[][] getCenterIndicesToUpgrade(); 14 | 15 | @Accessor 16 | EnumSet getSidesToUpgrade(); 17 | } 18 | -------------------------------------------------------------------------------- /c2me-base/src/main/java/com/ishland/c2me/base/mixin/access/IVersionedChunkStorage.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.base.mixin.access; 2 | 3 | import net.minecraft.world.storage.StorageIoWorker; 4 | import net.minecraft.world.storage.StorageKey; 5 | import net.minecraft.world.storage.VersionedChunkStorage; 6 | import org.spongepowered.asm.mixin.Mixin; 7 | import org.spongepowered.asm.mixin.gen.Accessor; 8 | import org.spongepowered.asm.mixin.gen.Invoker; 9 | 10 | @Mixin(VersionedChunkStorage.class) 11 | public interface IVersionedChunkStorage { 12 | 13 | @Accessor 14 | StorageIoWorker getWorker(); 15 | 16 | @Invoker 17 | StorageKey invokeGetStorageKey(); 18 | 19 | } 20 | -------------------------------------------------------------------------------- /c2me-base/src/main/java/com/ishland/c2me/base/mixin/access/IWeightedList.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.base.mixin.access; 2 | 3 | import net.minecraft.util.collection.WeightedList; 4 | import org.spongepowered.asm.mixin.Mixin; 5 | import org.spongepowered.asm.mixin.gen.Accessor; 6 | 7 | import java.util.List; 8 | 9 | @Mixin(WeightedList.class) 10 | public interface IWeightedList { 11 | 12 | @Accessor 13 | List> getEntries(); 14 | 15 | } 16 | -------------------------------------------------------------------------------- /c2me-base/src/main/java/com/ishland/c2me/base/mixin/access/IWeightedListEntry.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.base.mixin.access; 2 | 3 | import net.minecraft.util.collection.WeightedList; 4 | import org.spongepowered.asm.mixin.Mixin; 5 | import org.spongepowered.asm.mixin.gen.Invoker; 6 | 7 | @Mixin(WeightedList.Entry.class) 8 | public interface IWeightedListEntry { 9 | 10 | @Invoker 11 | double invokeGetShuffledOrder(); 12 | 13 | @Invoker 14 | void invokeSetShuffledOrder(float random); 15 | 16 | } 17 | -------------------------------------------------------------------------------- /c2me-base/src/main/java/com/ishland/c2me/base/mixin/access/IWorldChunk.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.base.mixin.access; 2 | 3 | import net.minecraft.world.chunk.WorldChunk; 4 | import org.spongepowered.asm.mixin.Mixin; 5 | import org.spongepowered.asm.mixin.gen.Accessor; 6 | 7 | @Mixin(WorldChunk.class) 8 | public interface IWorldChunk { 9 | 10 | @Accessor 11 | boolean isLoadedToWorld(); 12 | 13 | } 14 | -------------------------------------------------------------------------------- /c2me-base/src/main/java/com/ishland/c2me/base/mixin/access/IXoroshiro128PlusPlusRandom.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.base.mixin.access; 2 | 3 | import net.minecraft.util.math.random.Xoroshiro128PlusPlusRandom; 4 | import net.minecraft.util.math.random.Xoroshiro128PlusPlusRandomImpl; 5 | import org.spongepowered.asm.mixin.Mixin; 6 | import org.spongepowered.asm.mixin.gen.Accessor; 7 | 8 | @Mixin(Xoroshiro128PlusPlusRandom.class) 9 | public interface IXoroshiro128PlusPlusRandom { 10 | 11 | @Accessor 12 | Xoroshiro128PlusPlusRandomImpl getImplementation(); 13 | 14 | } 15 | -------------------------------------------------------------------------------- /c2me-base/src/main/java/com/ishland/c2me/base/mixin/access/IXoroshiro128PlusPlusRandomDeriver.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.base.mixin.access; 2 | 3 | import net.minecraft.util.math.random.Xoroshiro128PlusPlusRandom; 4 | import org.spongepowered.asm.mixin.Mixin; 5 | import org.spongepowered.asm.mixin.gen.Accessor; 6 | 7 | @Mixin(Xoroshiro128PlusPlusRandom.Splitter.class) 8 | public interface IXoroshiro128PlusPlusRandomDeriver { 9 | 10 | @Accessor 11 | long getSeedLo(); 12 | 13 | @Accessor 14 | long getSeedHi(); 15 | 16 | } 17 | -------------------------------------------------------------------------------- /c2me-base/src/main/java/com/ishland/c2me/base/mixin/access/IXoroshiro128PlusPlusRandomImpl.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.base.mixin.access; 2 | 3 | import net.minecraft.util.math.random.Xoroshiro128PlusPlusRandomImpl; 4 | import org.spongepowered.asm.mixin.Mixin; 5 | import org.spongepowered.asm.mixin.gen.Accessor; 6 | 7 | @Mixin(Xoroshiro128PlusPlusRandomImpl.class) 8 | public interface IXoroshiro128PlusPlusRandomImpl { 9 | 10 | @Accessor 11 | long getSeedLo(); 12 | 13 | @Accessor 14 | long getSeedHi(); 15 | 16 | @Accessor 17 | void setSeedLo(long value); 18 | 19 | @Accessor 20 | void setSeedHi(long value); 21 | 22 | } 23 | -------------------------------------------------------------------------------- /c2me-base/src/main/java/com/ishland/c2me/base/mixin/access/fapi/IArrayBackedEvent.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.base.mixin.access.fapi; 2 | 3 | import org.spongepowered.asm.mixin.Mixin; 4 | import org.spongepowered.asm.mixin.gen.Accessor; 5 | 6 | @Mixin(targets = "net.fabricmc.fabric.impl.base.event.ArrayBackedEvent", remap = false) 7 | public interface IArrayBackedEvent { 8 | 9 | @Accessor("handlers") 10 | T[] c2me$getHandlers(); 11 | 12 | } 13 | -------------------------------------------------------------------------------- /c2me-base/src/main/java/com/ishland/c2me/base/mixin/client_movement/MixinClientPlayerEntity.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.base.mixin.client_movement; 2 | 3 | import com.ishland.c2me.base.common.theinterface.PlayerEntityExtension; 4 | import net.minecraft.client.network.ClientPlayNetworkHandler; 5 | import net.minecraft.client.network.ClientPlayerEntity; 6 | import net.minecraft.network.packet.c2s.play.PlayerLoadedC2SPacket; 7 | import org.spongepowered.asm.mixin.Final; 8 | import org.spongepowered.asm.mixin.Mixin; 9 | import org.spongepowered.asm.mixin.Shadow; 10 | 11 | @Mixin(ClientPlayerEntity.class) 12 | public class MixinClientPlayerEntity implements PlayerEntityExtension { 13 | 14 | @Shadow @Final public ClientPlayNetworkHandler networkHandler; 15 | 16 | @Override 17 | public void c2me$onForcedLoaded() { 18 | this.networkHandler.sendPacket(new PlayerLoadedC2SPacket()); 19 | } 20 | 21 | } 22 | -------------------------------------------------------------------------------- /c2me-base/src/main/java/com/ishland/c2me/base/mixin/client_movement/MixinPlayerEntity.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.base.mixin.client_movement; 2 | 3 | import com.ishland.c2me.base.common.theinterface.PlayerEntityExtension; 4 | import net.minecraft.entity.player.PlayerEntity; 5 | import org.spongepowered.asm.mixin.Mixin; 6 | import org.spongepowered.asm.mixin.Shadow; 7 | import org.spongepowered.asm.mixin.injection.At; 8 | import org.spongepowered.asm.mixin.injection.Inject; 9 | import org.spongepowered.asm.mixin.injection.callback.CallbackInfo; 10 | 11 | @Mixin(PlayerEntity.class) 12 | public class MixinPlayerEntity implements PlayerEntityExtension { 13 | 14 | @Shadow private boolean loaded; 15 | 16 | @Shadow protected int remainingLoadTicks; 17 | 18 | @Override 19 | public void c2me$onForcedLoaded() { 20 | // no-op, intended to be overridden 21 | } 22 | 23 | @Inject(method = "tickLoaded", at = @At("RETURN")) 24 | private void onForcedLoaded(CallbackInfo ci) { 25 | if (!this.loaded && this.remainingLoadTicks == 0) { 26 | this.c2me$onForcedLoaded(); 27 | } 28 | } 29 | 30 | } 31 | -------------------------------------------------------------------------------- /c2me-base/src/main/java/com/ishland/c2me/base/mixin/util/log4j2shutdownhookisnomore/MixinMain.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.base.mixin.util.log4j2shutdownhookisnomore; 2 | 3 | import net.minecraft.server.Main; 4 | import org.apache.logging.log4j.LogManager; 5 | import org.apache.logging.log4j.core.impl.Log4jContextFactory; 6 | import org.apache.logging.log4j.core.util.DefaultShutdownCallbackRegistry; 7 | import org.spongepowered.asm.mixin.Mixin; 8 | import org.spongepowered.asm.mixin.injection.At; 9 | import org.spongepowered.asm.mixin.injection.Inject; 10 | import org.spongepowered.asm.mixin.injection.callback.CallbackInfo; 11 | 12 | @Mixin(Main.class) 13 | public class MixinMain { 14 | 15 | @Inject(method = "main", at = @At("HEAD"), remap = false) 16 | private static void preMain(CallbackInfo info) { 17 | try { 18 | ((DefaultShutdownCallbackRegistry) ((Log4jContextFactory) LogManager.getFactory()).getShutdownCallbackRegistry()).stop(); 19 | } catch (Throwable t) { 20 | System.err.println("Unable to remove log4j2 shutdown hook"); 21 | t.printStackTrace(); 22 | } 23 | } 24 | 25 | } 26 | -------------------------------------------------------------------------------- /c2me-base/src/main/java/com/ishland/c2me/base/mixin/util/log4j2shutdownhookisnomore/MixinMinecraftDedicatedServer.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.base.mixin.util.log4j2shutdownhookisnomore; 2 | 3 | import net.minecraft.server.dedicated.MinecraftDedicatedServer; 4 | import org.apache.logging.log4j.LogManager; 5 | import org.spongepowered.asm.mixin.Mixin; 6 | import org.spongepowered.asm.mixin.injection.At; 7 | import org.spongepowered.asm.mixin.injection.Inject; 8 | import org.spongepowered.asm.mixin.injection.callback.CallbackInfo; 9 | 10 | @Mixin(MinecraftDedicatedServer.class) 11 | public class MixinMinecraftDedicatedServer { 12 | 13 | @Inject(method = "exit", at = @At("RETURN")) 14 | private void onPostShutdown(CallbackInfo ci) { 15 | LogManager.shutdown(); 16 | new Thread(() -> System.exit(0)).start(); 17 | } 18 | 19 | } 20 | -------------------------------------------------------------------------------- /c2me-base/src/main/java/com/ishland/c2me/base/package-info.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.base; -------------------------------------------------------------------------------- /c2me-base/src/main/resources/c2me.mixins.json: -------------------------------------------------------------------------------- 1 | { 2 | "required": true, 3 | "minVersion": "0.8", 4 | "package": "com.ishland.c2me.mixin", 5 | "compatibilityLevel": "JAVA_16", 6 | "mixinPriority": 1100, 7 | "mixins": [ 8 | ], 9 | "client": [ 10 | ], 11 | "injectors": { 12 | "defaultRequire": 1 13 | }, 14 | "overwrites": { 15 | "conformVisibility": true 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /c2me-base/src/main/resources/fabric.mod.json: -------------------------------------------------------------------------------- 1 | { 2 | "schemaVersion": 1, 3 | "id": "c2me-base", 4 | "version": "${version}", 5 | "name": "Concurrent Chunk Management Engine (Base)", 6 | "description": "Concurrent Chunk Management Engine Base", 7 | "environment": "*", 8 | "mixins": [ 9 | "c2me-base.mixins.json" 10 | ], 11 | "entrypoints": { 12 | "preLaunch": [ 13 | "com.ishland.c2me.base.C2MEBaseMod" 14 | ] 15 | }, 16 | "depends": { 17 | "minecraft": "*", 18 | "fabricloader": "*" 19 | }, 20 | "accessWidener": "c2me-base.accesswidener", 21 | 22 | "authors": [ 23 | "RelativityMC", 24 | "ishland" 25 | ], 26 | "contact": { 27 | "sources": "https://github.com/RelativityMC/C2ME-fabric", 28 | "issues": "https://github.com/RelativityMC/C2ME-fabric/issues", 29 | "discord": "https://discord.gg/Kdy8NM5HW4", 30 | "homepage": "https://modrinth.com/mod/c2me-fabric" 31 | }, 32 | "license": "MIT", 33 | "custom": { 34 | "modmenu": { 35 | "parent": "c2me" 36 | } 37 | } 38 | } 39 | -------------------------------------------------------------------------------- /c2me-client-uncapvd/build.gradle: -------------------------------------------------------------------------------- 1 | moduleDependencies(project, [ 2 | "c2me-base", 3 | ]) 4 | 5 | -------------------------------------------------------------------------------- /c2me-client-uncapvd/src/main/java/com/ishland/c2me/client/uncapvd/ModuleEntryPoint.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.client.uncapvd; 2 | 3 | import com.ishland.c2me.base.common.config.ConfigSystem; 4 | import com.ishland.c2me.client.uncapvd.common.Config; 5 | 6 | public class ModuleEntryPoint { 7 | 8 | public static final boolean enabled = new ConfigSystem.ConfigAccessor() 9 | .key("clientSideConfig.modifyMaxVDConfig.enabled") 10 | .comment("Whether to modify maximum view distance") 11 | .incompatibleMod("bobby", "*") 12 | .getBoolean(true, false); 13 | 14 | static { 15 | Config.init(); 16 | } 17 | 18 | } 19 | -------------------------------------------------------------------------------- /c2me-client-uncapvd/src/main/java/com/ishland/c2me/client/uncapvd/common/UncapVDInitializer.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.client.uncapvd.common; 2 | 3 | import com.ishland.c2me.base.common.config.ModStatuses; 4 | import com.ishland.c2me.client.uncapvd.ModuleEntryPoint; 5 | import net.fabricmc.api.ClientModInitializer; 6 | 7 | public class UncapVDInitializer implements ClientModInitializer { 8 | 9 | @Override 10 | public void onInitializeClient() { 11 | if (ModuleEntryPoint.enabled && ModStatuses.fabric_networking_api_v1) { 12 | ClientExtNetworking.registerListeners(); 13 | } 14 | } 15 | 16 | } 17 | -------------------------------------------------------------------------------- /c2me-client-uncapvd/src/main/java/com/ishland/c2me/client/uncapvd/mixin/ISimpleOption.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.client.uncapvd.mixin; 2 | 3 | import com.mojang.serialization.Codec; 4 | import net.minecraft.client.option.SimpleOption; 5 | import org.spongepowered.asm.mixin.Mixin; 6 | import org.spongepowered.asm.mixin.Mutable; 7 | import org.spongepowered.asm.mixin.gen.Accessor; 8 | 9 | @Mixin(SimpleOption.class) 10 | public interface ISimpleOption { 11 | 12 | @Accessor 13 | @Mutable 14 | void setCallbacks(SimpleOption.Callbacks callbacks); 15 | 16 | @Accessor 17 | @Mutable 18 | void setCodec(Codec codec); 19 | 20 | } 21 | -------------------------------------------------------------------------------- /c2me-client-uncapvd/src/main/java/com/ishland/c2me/client/uncapvd/mixin/MixinSodiumUserConfigCategories.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.client.uncapvd.mixin; 2 | 3 | import com.ishland.c2me.client.uncapvd.common.Config; 4 | import org.spongepowered.asm.mixin.Dynamic; 5 | import org.spongepowered.asm.mixin.Mixin; 6 | import org.spongepowered.asm.mixin.Pseudo; 7 | import org.spongepowered.asm.mixin.injection.Constant; 8 | import org.spongepowered.asm.mixin.injection.ModifyConstant; 9 | 10 | @Pseudo 11 | @Mixin(targets = { 12 | "me.jellysquid.mods.sodium.client.gui.SodiumGameOptionPages", 13 | "net.caffeinemc.sodium.config.user.UserConfigCategories", 14 | "net.caffeinemc.mods.sodium.client.gui.SodiumGameOptionPages", 15 | }) 16 | public class MixinSodiumUserConfigCategories { 17 | 18 | @Dynamic 19 | @ModifyConstant(method = "lambda$general$0", constant = @Constant(intValue = 32), remap = false) 20 | private static int modifyMaxViewDistance(int value) { 21 | return Config.maxViewDistance; 22 | } 23 | 24 | } 25 | -------------------------------------------------------------------------------- /c2me-client-uncapvd/src/main/java/com/ishland/c2me/client/uncapvd/mixin/MixinSyncedClientOptions.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.client.uncapvd.mixin; 2 | 3 | import com.llamalad7.mixinextras.injector.wrapoperation.Operation; 4 | import com.llamalad7.mixinextras.injector.wrapoperation.WrapOperation; 5 | import net.minecraft.network.packet.c2s.common.SyncedClientOptions; 6 | import net.minecraft.util.math.MathHelper; 7 | import org.objectweb.asm.Opcodes; 8 | import org.spongepowered.asm.mixin.Mixin; 9 | import org.spongepowered.asm.mixin.injection.At; 10 | 11 | @Mixin(SyncedClientOptions.class) 12 | public class MixinSyncedClientOptions { 13 | 14 | @WrapOperation(method = "write", at = @At(value = "FIELD", target = "Lnet/minecraft/network/packet/c2s/common/SyncedClientOptions;viewDistance:I", opcode = Opcodes.GETFIELD)) 15 | private int wrapRenderDistance(SyncedClientOptions instance, Operation original) { 16 | return MathHelper.clamp(instance.viewDistance(), 2, Byte.MAX_VALUE); 17 | } 18 | 19 | } 20 | -------------------------------------------------------------------------------- /c2me-client-uncapvd/src/main/java/com/ishland/c2me/client/uncapvd/mixin/MixinVKModOptions.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.client.uncapvd.mixin; 2 | 3 | import com.ishland.c2me.client.uncapvd.common.Config; 4 | import org.spongepowered.asm.mixin.Dynamic; 5 | import org.spongepowered.asm.mixin.Mixin; 6 | import org.spongepowered.asm.mixin.Pseudo; 7 | import org.spongepowered.asm.mixin.injection.Constant; 8 | import org.spongepowered.asm.mixin.injection.ModifyConstant; 9 | 10 | @Pseudo 11 | @Mixin(targets = "net.vulkanmod.config.option.Options") 12 | public class MixinVKModOptions { 13 | 14 | @Dynamic 15 | @ModifyConstant(method = "getGraphicsOpts", constant = @Constant(intValue = 32, ordinal = 0), remap = false, require = 0) 16 | private static int modifyMaxViewDistance(int value) { 17 | return Config.maxViewDistance; 18 | } 19 | 20 | } 21 | -------------------------------------------------------------------------------- /c2me-client-uncapvd/src/main/java/com/ishland/c2me/client/uncapvd/package-info.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.client.uncapvd; -------------------------------------------------------------------------------- /c2me-client-uncapvd/src/main/resources/c2me-client-uncapvd.mixins.json: -------------------------------------------------------------------------------- 1 | { 2 | "parent": "c2me.mixins.json", 3 | "required": true, 4 | "package": "com.ishland.c2me.client.uncapvd.mixin", 5 | "plugin": "com.ishland.c2me.base.common.ModuleMixinPlugin", 6 | "mixins": [ 7 | "ISimpleOption", 8 | "MixinGameOptions", 9 | "MixinSodiumUserConfigCategories", 10 | "MixinSyncedClientOptions", 11 | "MixinVKModOptions" 12 | ] 13 | } 14 | -------------------------------------------------------------------------------- /c2me-client-uncapvd/src/main/resources/fabric.mod.json: -------------------------------------------------------------------------------- 1 | { 2 | "schemaVersion": 1, 3 | "id": "c2me-client-uncapvd", 4 | "version": "${version}", 5 | "name": "Concurrent Chunk Management Engine (Client/Uncap View Distance)", 6 | "description": "Client-side module for modifying maximum view distance", 7 | "environment": "client", 8 | "mixins": [ 9 | "c2me-client-uncapvd.mixins.json" 10 | ], 11 | "depends": { 12 | "minecraft": "*", 13 | "fabricloader": "*", 14 | "c2me-base": "*" 15 | }, 16 | "entrypoints": { 17 | "client": [ 18 | "com.ishland.c2me.client.uncapvd.common.UncapVDInitializer" 19 | ] 20 | }, 21 | 22 | "authors": [ 23 | "RelativityMC", 24 | "ishland" 25 | ], 26 | "contact": { 27 | "sources": "https://github.com/RelativityMC/C2ME-fabric", 28 | "issues": "https://github.com/RelativityMC/C2ME-fabric/issues", 29 | "discord": "https://discord.gg/Kdy8NM5HW4", 30 | "homepage": "https://modrinth.com/mod/c2me-fabric" 31 | }, 32 | "license": "MIT", 33 | "custom": { 34 | "modmenu": { 35 | "parent": "c2me" 36 | } 37 | } 38 | } 39 | -------------------------------------------------------------------------------- /c2me-fixes-chunkio-threading-issues/build.gradle: -------------------------------------------------------------------------------- 1 | moduleDependencies(project, [ 2 | "c2me-base", 3 | ]) 4 | 5 | -------------------------------------------------------------------------------- /c2me-fixes-chunkio-threading-issues/src/main/java/com/ishland/c2me/fixes/chunkio/threading_issues/ModuleEntryPoint.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.fixes.chunkio.threading_issues; 2 | 3 | public class ModuleEntryPoint { 4 | 5 | private static final boolean enabled = true; 6 | 7 | } 8 | -------------------------------------------------------------------------------- /c2me-fixes-chunkio-threading-issues/src/main/java/com/ishland/c2me/fixes/chunkio/threading_issues/package-info.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.fixes.chunkio.threading_issues; -------------------------------------------------------------------------------- /c2me-fixes-chunkio-threading-issues/src/main/resources/c2me-fixes-chunkio-threading-issues.mixins.json: -------------------------------------------------------------------------------- 1 | { 2 | "parent": "c2me.mixins.json", 3 | "required": true, 4 | "package": "com.ishland.c2me.fixes.chunkio.threading_issues.mixin", 5 | "plugin": "com.ishland.c2me.base.common.ModuleMixinPlugin", 6 | "mixins": [ 7 | "MixinStructurePoolElement" 8 | ] 9 | } 10 | -------------------------------------------------------------------------------- /c2me-fixes-chunkio-threading-issues/src/main/resources/fabric.mod.json: -------------------------------------------------------------------------------- 1 | { 2 | "schemaVersion": 1, 3 | "id": "c2me-fixes-chunkio-threading-issues", 4 | "version": "${version}", 5 | "name": "Concurrent Chunk Management Engine (Fixes/Chunk IO/Threading Issues)", 6 | "description": "Fixes threading issues related to chunk IO", 7 | "environment": "*", 8 | "mixins": [ 9 | "c2me-fixes-chunkio-threading-issues.mixins.json" 10 | ], 11 | "depends": { 12 | "minecraft": "*", 13 | "fabricloader": "*", 14 | "c2me-base": "*" 15 | }, 16 | 17 | "authors": [ 18 | "RelativityMC", 19 | "ishland" 20 | ], 21 | "contact": { 22 | "sources": "https://github.com/RelativityMC/C2ME-fabric", 23 | "issues": "https://github.com/RelativityMC/C2ME-fabric/issues", 24 | "discord": "https://discord.gg/Kdy8NM5HW4", 25 | "homepage": "https://modrinth.com/mod/c2me-fabric" 26 | }, 27 | "license": "MIT", 28 | "custom": { 29 | "modmenu": { 30 | "parent": "c2me" 31 | } 32 | } 33 | } 34 | -------------------------------------------------------------------------------- /c2me-fixes-general-threading-issues/build.gradle: -------------------------------------------------------------------------------- 1 | moduleDependencies(project, [ 2 | "c2me-base", 3 | ]) 4 | 5 | -------------------------------------------------------------------------------- /c2me-fixes-general-threading-issues/src/main/java/com/ishland/c2me/fixes/general/threading_issues/ModuleEntryPoint.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.fixes.general.threading_issues; 2 | 3 | public class ModuleEntryPoint { 4 | 5 | private static final boolean enabled = true; 6 | 7 | } 8 | -------------------------------------------------------------------------------- /c2me-fixes-general-threading-issues/src/main/java/com/ishland/c2me/fixes/general/threading_issues/package-info.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.fixes.general.threading_issues; -------------------------------------------------------------------------------- /c2me-fixes-general-threading-issues/src/main/resources/c2me-fixes-general-threading-issues.mixins.json: -------------------------------------------------------------------------------- 1 | { 2 | "parent": "c2me.mixins.json", 3 | "required": true, 4 | "package": "com.ishland.c2me.fixes.general.threading_issues.mixin", 5 | "plugin": "com.ishland.c2me.base.common.ModuleMixinPlugin", 6 | "mixins": [ 7 | "asynccatchers.MixinMinecraftServer", 8 | "asynccatchers.MixinServerChunkManager", 9 | "asynccatchers.MixinThreadedAnvilChunkStorage" 10 | ] 11 | } 12 | -------------------------------------------------------------------------------- /c2me-fixes-general-threading-issues/src/main/resources/fabric.mod.json: -------------------------------------------------------------------------------- 1 | { 2 | "schemaVersion": 1, 3 | "id": "c2me-fixes-general-threading-issues", 4 | "version": "${version}", 5 | "name": "Concurrent Chunk Management Engine (Fixes/General/Threading Issues)", 6 | "description": "Fixes threading issues for general chunk storage", 7 | "environment": "*", 8 | "mixins": [ 9 | "c2me-fixes-general-threading-issues.mixins.json" 10 | ], 11 | "depends": { 12 | "minecraft": "*", 13 | "fabricloader": "*", 14 | "c2me-base": "*" 15 | }, 16 | 17 | "authors": [ 18 | "RelativityMC", 19 | "ishland" 20 | ], 21 | "contact": { 22 | "sources": "https://github.com/RelativityMC/C2ME-fabric", 23 | "issues": "https://github.com/RelativityMC/C2ME-fabric/issues", 24 | "discord": "https://discord.gg/Kdy8NM5HW4", 25 | "homepage": "https://modrinth.com/mod/c2me-fabric" 26 | }, 27 | "license": "MIT", 28 | "custom": { 29 | "modmenu": { 30 | "parent": "c2me" 31 | } 32 | } 33 | } 34 | -------------------------------------------------------------------------------- /c2me-fixes-worldgen-threading-issues/build.gradle: -------------------------------------------------------------------------------- 1 | moduleDependencies(project, [ 2 | "c2me-base", 3 | ]) 4 | 5 | -------------------------------------------------------------------------------- /c2me-fixes-worldgen-threading-issues/src/main/java/com/ishland/c2me/fixes/worldgen/threading_issues/ModuleEntryPoint.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.fixes.worldgen.threading_issues; 2 | 3 | import com.ishland.c2me.fixes.worldgen.threading_issues.common.Config; 4 | 5 | public class ModuleEntryPoint { 6 | 7 | private static final boolean enabled = true; 8 | 9 | static { 10 | Config.init(); 11 | } 12 | 13 | } 14 | -------------------------------------------------------------------------------- /c2me-fixes-worldgen-threading-issues/src/main/java/com/ishland/c2me/fixes/worldgen/threading_issues/asm/MakeVolatile.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.fixes.worldgen.threading_issues.asm; 2 | 3 | public @interface MakeVolatile { 4 | } 5 | -------------------------------------------------------------------------------- /c2me-fixes-worldgen-threading-issues/src/main/java/com/ishland/c2me/fixes/worldgen/threading_issues/common/IStrongholdGenerator.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.fixes.worldgen.threading_issues.common; 2 | 3 | import net.minecraft.structure.StrongholdGenerator; 4 | 5 | public interface IStrongholdGenerator { 6 | 7 | ThreadLocal> getActivePieceTypeThreadLocal(); 8 | 9 | class Holder { 10 | @SuppressWarnings({"InstantiationOfUtilityClass", "ConstantConditions"}) 11 | public static final IStrongholdGenerator INSTANCE = (IStrongholdGenerator) new StrongholdGenerator(); 12 | } 13 | 14 | } 15 | -------------------------------------------------------------------------------- /c2me-fixes-worldgen-threading-issues/src/main/java/com/ishland/c2me/fixes/worldgen/threading_issues/common/XPieceDataExtension.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.fixes.worldgen.threading_issues.common; 2 | 3 | public interface XPieceDataExtension { 4 | 5 | ThreadLocal c2me$getGeneratedCountThreadLocal(); 6 | 7 | } 8 | -------------------------------------------------------------------------------- /c2me-fixes-worldgen-threading-issues/src/main/java/com/ishland/c2me/fixes/worldgen/threading_issues/mixin/deadlocks/MixinDataFixerType.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.fixes.worldgen.threading_issues.mixin.deadlocks; 2 | 3 | import com.ishland.c2me.base.common.util.CFUtil; 4 | import com.mojang.datafixers.types.Type; 5 | import org.spongepowered.asm.mixin.Mixin; 6 | import org.spongepowered.asm.mixin.injection.At; 7 | import org.spongepowered.asm.mixin.injection.Redirect; 8 | 9 | import java.util.concurrent.CompletableFuture; 10 | 11 | @Mixin(Type.class) 12 | public class MixinDataFixerType { 13 | 14 | @Redirect(method = "rewrite", at = @At(value = "INVOKE", target = "Ljava/util/concurrent/CompletableFuture;join()Ljava/lang/Object;"), remap = false) 15 | private T redirectJoin(CompletableFuture completableFuture) { 16 | return CFUtil.join(completableFuture); 17 | } 18 | 19 | } 20 | -------------------------------------------------------------------------------- /c2me-fixes-worldgen-threading-issues/src/main/java/com/ishland/c2me/fixes/worldgen/threading_issues/mixin/threading/MixinChunk.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.fixes.worldgen.threading_issues.mixin.threading; 2 | 3 | import net.minecraft.world.chunk.Chunk; 4 | import org.spongepowered.asm.mixin.Mixin; 5 | 6 | @Mixin(Chunk.class) 7 | public abstract class MixinChunk { 8 | 9 | // @Mutable 10 | // @Shadow 11 | // @Final 12 | // private Map, StructureStart> structureStarts; 13 | // 14 | // @Inject(method = "", at = @At("RETURN")) 15 | // private void onInit(CallbackInfo info) { 16 | // this.structureStarts = new CMETrackingMap<>(this.structureStarts); 17 | // } 18 | 19 | } 20 | -------------------------------------------------------------------------------- /c2me-fixes-worldgen-threading-issues/src/main/java/com/ishland/c2me/fixes/worldgen/threading_issues/mixin/threading/MixinMineshaftGeneratorMineshaftCorridor.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.fixes.worldgen.threading_issues.mixin.threading; 2 | 3 | import com.ishland.c2me.fixes.worldgen.threading_issues.asm.MakeVolatile; 4 | import net.minecraft.structure.MineshaftGenerator; 5 | import org.spongepowered.asm.mixin.Mixin; 6 | import org.spongepowered.asm.mixin.Shadow; 7 | 8 | @Mixin(MineshaftGenerator.MineshaftCorridor.class) 9 | public class MixinMineshaftGeneratorMineshaftCorridor { 10 | 11 | @MakeVolatile 12 | @Shadow private boolean hasSpawner; 13 | 14 | } 15 | -------------------------------------------------------------------------------- /c2me-fixes-worldgen-threading-issues/src/main/java/com/ishland/c2me/fixes/worldgen/threading_issues/mixin/threading/MixinMineshaftGeneratorMineshaftRoom.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.fixes.worldgen.threading_issues.mixin.threading; 2 | 3 | import net.minecraft.structure.MineshaftGenerator; 4 | import net.minecraft.util.math.BlockBox; 5 | import org.spongepowered.asm.mixin.Final; 6 | import org.spongepowered.asm.mixin.Mixin; 7 | import org.spongepowered.asm.mixin.Mutable; 8 | import org.spongepowered.asm.mixin.Shadow; 9 | import org.spongepowered.asm.mixin.injection.At; 10 | import org.spongepowered.asm.mixin.injection.Inject; 11 | import org.spongepowered.asm.mixin.injection.callback.CallbackInfo; 12 | 13 | import java.util.Collections; 14 | import java.util.List; 15 | 16 | @Mixin(MineshaftGenerator.MineshaftRoom.class) 17 | public class MixinMineshaftGeneratorMineshaftRoom { 18 | 19 | @Mutable 20 | @Shadow @Final private List entrances; 21 | 22 | @Inject(method = "*", at = @At("RETURN")) 23 | private void onInit(CallbackInfo info) { 24 | this.entrances = Collections.synchronizedList(this.entrances); 25 | } 26 | 27 | } 28 | -------------------------------------------------------------------------------- /c2me-fixes-worldgen-threading-issues/src/main/java/com/ishland/c2me/fixes/worldgen/threading_issues/mixin/threading/MixinNetherFortressGeneratorBridgePlatform.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.fixes.worldgen.threading_issues.mixin.threading; 2 | 3 | import com.ishland.c2me.fixes.worldgen.threading_issues.asm.MakeVolatile; 4 | import net.minecraft.structure.NetherFortressGenerator; 5 | import org.spongepowered.asm.mixin.Mixin; 6 | import org.spongepowered.asm.mixin.Shadow; 7 | 8 | @Mixin(NetherFortressGenerator.BridgePlatform.class) 9 | public class MixinNetherFortressGeneratorBridgePlatform { 10 | 11 | @MakeVolatile 12 | @Shadow private boolean hasBlazeSpawner; 13 | 14 | } 15 | -------------------------------------------------------------------------------- /c2me-fixes-worldgen-threading-issues/src/main/java/com/ishland/c2me/fixes/worldgen/threading_issues/mixin/threading/MixinNetherFortressGeneratorCorridorLeftTurn.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.fixes.worldgen.threading_issues.mixin.threading; 2 | 3 | import com.ishland.c2me.fixes.worldgen.threading_issues.asm.MakeVolatile; 4 | import net.minecraft.structure.NetherFortressGenerator; 5 | import org.spongepowered.asm.mixin.Mixin; 6 | import org.spongepowered.asm.mixin.Shadow; 7 | 8 | @Mixin(NetherFortressGenerator.CorridorLeftTurn.class) 9 | public class MixinNetherFortressGeneratorCorridorLeftTurn { 10 | 11 | @MakeVolatile 12 | @Shadow private boolean containsChest; 13 | 14 | } 15 | -------------------------------------------------------------------------------- /c2me-fixes-worldgen-threading-issues/src/main/java/com/ishland/c2me/fixes/worldgen/threading_issues/mixin/threading/MixinNetherFortressGeneratorCorridorRightTurn.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.fixes.worldgen.threading_issues.mixin.threading; 2 | 3 | import com.ishland.c2me.fixes.worldgen.threading_issues.asm.MakeVolatile; 4 | import net.minecraft.structure.NetherFortressGenerator; 5 | import org.spongepowered.asm.mixin.Mixin; 6 | import org.spongepowered.asm.mixin.Shadow; 7 | 8 | @Mixin(NetherFortressGenerator.CorridorRightTurn.class) 9 | public class MixinNetherFortressGeneratorCorridorRightTurn { 10 | 11 | @MakeVolatile 12 | @Shadow private boolean containsChest; 13 | 14 | } 15 | -------------------------------------------------------------------------------- /c2me-fixes-worldgen-threading-issues/src/main/java/com/ishland/c2me/fixes/worldgen/threading_issues/mixin/threading/MixinOceanMonumentGeneratorBase.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.fixes.worldgen.threading_issues.mixin.threading; 2 | 3 | import com.ishland.c2me.fixes.worldgen.threading_issues.asm.MakeVolatile; 4 | import net.minecraft.structure.OceanMonumentGenerator; 5 | import org.spongepowered.asm.mixin.Mixin; 6 | import org.spongepowered.asm.mixin.Shadow; 7 | 8 | @Mixin(OceanMonumentGenerator.Base.class) 9 | public class MixinOceanMonumentGeneratorBase { 10 | 11 | @MakeVolatile 12 | @Shadow private OceanMonumentGenerator.PieceSetting entryPieceSetting; 13 | 14 | @MakeVolatile 15 | @Shadow private OceanMonumentGenerator.PieceSetting coreRoomPieceSetting; 16 | 17 | } 18 | -------------------------------------------------------------------------------- /c2me-fixes-worldgen-threading-issues/src/main/java/com/ishland/c2me/fixes/worldgen/threading_issues/mixin/threading/MixinOceanMonumentGeneratorPieceSetting.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.fixes.worldgen.threading_issues.mixin.threading; 2 | 3 | import com.ishland.c2me.fixes.worldgen.threading_issues.asm.MakeVolatile; 4 | import net.minecraft.structure.OceanMonumentGenerator; 5 | import org.spongepowered.asm.mixin.Mixin; 6 | import org.spongepowered.asm.mixin.Shadow; 7 | 8 | @Mixin(OceanMonumentGenerator.PieceSetting.class) 9 | public class MixinOceanMonumentGeneratorPieceSetting { 10 | 11 | @MakeVolatile 12 | @Shadow private boolean used; 13 | 14 | @MakeVolatile 15 | @Shadow private boolean entrance; 16 | 17 | @MakeVolatile 18 | @Shadow private int entranceDistance; 19 | 20 | } 21 | -------------------------------------------------------------------------------- /c2me-fixes-worldgen-threading-issues/src/main/java/com/ishland/c2me/fixes/worldgen/threading_issues/mixin/threading/MixinShiftableStructurePiece.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.fixes.worldgen.threading_issues.mixin.threading; 2 | 3 | import com.ishland.c2me.fixes.worldgen.threading_issues.asm.MakeVolatile; 4 | import net.minecraft.structure.ShiftableStructurePiece; 5 | import org.spongepowered.asm.mixin.Mixin; 6 | import org.spongepowered.asm.mixin.Shadow; 7 | 8 | @Mixin(ShiftableStructurePiece.class) 9 | public class MixinShiftableStructurePiece { 10 | 11 | @MakeVolatile 12 | @Shadow protected int hPos; 13 | 14 | } 15 | -------------------------------------------------------------------------------- /c2me-fixes-worldgen-threading-issues/src/main/java/com/ishland/c2me/fixes/worldgen/threading_issues/mixin/threading/MixinStrongholdGeneratorChestCorridor.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.fixes.worldgen.threading_issues.mixin.threading; 2 | 3 | import com.ishland.c2me.fixes.worldgen.threading_issues.asm.MakeVolatile; 4 | import net.minecraft.structure.StrongholdGenerator; 5 | import org.spongepowered.asm.mixin.Mixin; 6 | import org.spongepowered.asm.mixin.Shadow; 7 | 8 | @Mixin(StrongholdGenerator.ChestCorridor.class) 9 | public class MixinStrongholdGeneratorChestCorridor { 10 | 11 | @MakeVolatile 12 | @Shadow private boolean chestGenerated; 13 | 14 | } 15 | -------------------------------------------------------------------------------- /c2me-fixes-worldgen-threading-issues/src/main/java/com/ishland/c2me/fixes/worldgen/threading_issues/mixin/threading/MixinStrongholdGeneratorPortalRoom.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.fixes.worldgen.threading_issues.mixin.threading; 2 | 3 | import com.ishland.c2me.fixes.worldgen.threading_issues.asm.MakeVolatile; 4 | import net.minecraft.structure.StrongholdGenerator; 5 | import org.spongepowered.asm.mixin.Mixin; 6 | import org.spongepowered.asm.mixin.Shadow; 7 | 8 | @Mixin(StrongholdGenerator.PortalRoom.class) 9 | public class MixinStrongholdGeneratorPortalRoom { 10 | 11 | @MakeVolatile 12 | @Shadow private boolean spawnerPlaced; 13 | 14 | } 15 | -------------------------------------------------------------------------------- /c2me-fixes-worldgen-threading-issues/src/main/java/com/ishland/c2me/fixes/worldgen/threading_issues/mixin/threading/MixinStrongholdGeneratorSpiralStaircase.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.fixes.worldgen.threading_issues.mixin.threading; 2 | 3 | import com.ishland.c2me.fixes.worldgen.threading_issues.common.IStrongholdGenerator; 4 | import net.minecraft.structure.StrongholdGenerator; 5 | import org.objectweb.asm.Opcodes; 6 | import org.spongepowered.asm.mixin.Mixin; 7 | import org.spongepowered.asm.mixin.injection.At; 8 | import org.spongepowered.asm.mixin.injection.Redirect; 9 | 10 | @Mixin(StrongholdGenerator.SpiralStaircase.class) 11 | public class MixinStrongholdGeneratorSpiralStaircase { 12 | 13 | @Redirect(method = "fillOpenings", at = @At(value = "FIELD", target = "Lnet/minecraft/structure/StrongholdGenerator;activePieceType:Ljava/lang/Class;", opcode = Opcodes.PUTSTATIC)) 14 | private void redirectGetActivePieceType(Class value) { 15 | IStrongholdGenerator.Holder.INSTANCE.getActivePieceTypeThreadLocal().set(value); 16 | } 17 | 18 | } 19 | -------------------------------------------------------------------------------- /c2me-fixes-worldgen-threading-issues/src/main/java/com/ishland/c2me/fixes/worldgen/threading_issues/mixin/threading/MixinStructurePlacementData.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.fixes.worldgen.threading_issues.mixin.threading; 2 | 3 | import net.minecraft.structure.StructurePlacementData; 4 | import net.minecraft.structure.processor.StructureProcessor; 5 | import org.spongepowered.asm.mixin.Final; 6 | import org.spongepowered.asm.mixin.Mixin; 7 | import org.spongepowered.asm.mixin.Mutable; 8 | import org.spongepowered.asm.mixin.Shadow; 9 | import org.spongepowered.asm.mixin.injection.At; 10 | import org.spongepowered.asm.mixin.injection.Inject; 11 | import org.spongepowered.asm.mixin.injection.callback.CallbackInfo; 12 | 13 | import java.util.Collections; 14 | import java.util.List; 15 | 16 | @Mixin(StructurePlacementData.class) 17 | public class MixinStructurePlacementData { 18 | 19 | @Mutable 20 | @Shadow @Final private List processors; 21 | 22 | @Inject(method = "", at = @At("RETURN")) 23 | private void onInit(CallbackInfo ci) { 24 | this.processors = Collections.synchronizedList(processors); 25 | } 26 | 27 | } 28 | -------------------------------------------------------------------------------- /c2me-fixes-worldgen-threading-issues/src/main/java/com/ishland/c2me/fixes/worldgen/threading_issues/mixin/threading/MixinSwampHutGenerator.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.fixes.worldgen.threading_issues.mixin.threading; 2 | 3 | import com.ishland.c2me.fixes.worldgen.threading_issues.asm.MakeVolatile; 4 | import net.minecraft.structure.SwampHutGenerator; 5 | import org.spongepowered.asm.mixin.Mixin; 6 | import org.spongepowered.asm.mixin.Shadow; 7 | 8 | @Mixin(SwampHutGenerator.class) 9 | public class MixinSwampHutGenerator { 10 | 11 | @MakeVolatile 12 | @Shadow private boolean hasWitch; 13 | 14 | @MakeVolatile 15 | @Shadow private boolean hasCat; 16 | 17 | } 18 | -------------------------------------------------------------------------------- /c2me-fixes-worldgen-threading-issues/src/main/java/com/ishland/c2me/fixes/worldgen/threading_issues/mixin/threading/MixinWoodlandMansionGeneratorGenerationPiece.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.fixes.worldgen.threading_issues.mixin.threading; 2 | 3 | import com.ishland.c2me.fixes.worldgen.threading_issues.asm.MakeVolatile; 4 | import net.minecraft.structure.WoodlandMansionGenerator; 5 | import net.minecraft.util.BlockRotation; 6 | import net.minecraft.util.math.BlockPos; 7 | import org.spongepowered.asm.mixin.Mixin; 8 | import org.spongepowered.asm.mixin.Shadow; 9 | 10 | @Mixin(WoodlandMansionGenerator.GenerationPiece.class) 11 | public class MixinWoodlandMansionGeneratorGenerationPiece { 12 | 13 | @MakeVolatile 14 | @Shadow public BlockRotation rotation; 15 | 16 | @MakeVolatile 17 | @Shadow public BlockPos position; 18 | 19 | @MakeVolatile 20 | @Shadow public String template; 21 | 22 | } 23 | -------------------------------------------------------------------------------- /c2me-fixes-worldgen-threading-issues/src/main/java/com/ishland/c2me/fixes/worldgen/threading_issues/mixin/threading/MixinWoodlandMansionGeneratorMansionParameters.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.fixes.worldgen.threading_issues.mixin.threading; 2 | 3 | import com.ishland.c2me.fixes.worldgen.threading_issues.common.ConcurrentFlagMatrix; 4 | import net.minecraft.structure.WoodlandMansionGenerator; 5 | import org.spongepowered.asm.mixin.Mixin; 6 | import org.spongepowered.asm.mixin.injection.At; 7 | import org.spongepowered.asm.mixin.injection.Redirect; 8 | 9 | @SuppressWarnings({"InvalidInjectorMethodSignature", "MixinAnnotationTarget"}) 10 | @Mixin(WoodlandMansionGenerator.MansionParameters.class) 11 | public class MixinWoodlandMansionGeneratorMansionParameters { 12 | 13 | @SuppressWarnings("UnresolvedMixinReference") 14 | @Redirect(method = "", at = @At(value = "NEW", target = "net/minecraft/structure/WoodlandMansionGenerator$FlagMatrix")) 15 | private WoodlandMansionGenerator.FlagMatrix redirectNewMatrix(int n, int m, int fallback) { 16 | return new ConcurrentFlagMatrix(n, m, fallback); 17 | } 18 | 19 | } 20 | -------------------------------------------------------------------------------- /c2me-fixes-worldgen-threading-issues/src/main/java/com/ishland/c2me/fixes/worldgen/threading_issues/mixin/threading/math/MixinAffineTransformation.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.fixes.worldgen.threading_issues.mixin.threading.math; 2 | 3 | import net.minecraft.util.math.AffineTransformation; 4 | import org.spongepowered.asm.mixin.Mixin; 5 | import org.spongepowered.asm.mixin.Shadow; 6 | import org.spongepowered.asm.mixin.injection.At; 7 | import org.spongepowered.asm.mixin.injection.Inject; 8 | import org.spongepowered.asm.mixin.injection.callback.CallbackInfo; 9 | 10 | @Mixin(AffineTransformation.class) 11 | public abstract class MixinAffineTransformation { 12 | 13 | @Shadow protected abstract void init(); 14 | 15 | @Inject(method = "*", at = @At("RETURN")) 16 | private void onInit(CallbackInfo info) { 17 | this.init(); // run init early 18 | } 19 | 20 | } 21 | -------------------------------------------------------------------------------- /c2me-fixes-worldgen-threading-issues/src/main/java/com/ishland/c2me/fixes/worldgen/threading_issues/mixin/threading_detections/package-info.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.fixes.worldgen.threading_issues.mixin.threading_detections; -------------------------------------------------------------------------------- /c2me-fixes-worldgen-threading-issues/src/main/java/com/ishland/c2me/fixes/worldgen/threading_issues/package-info.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.fixes.worldgen.threading_issues; -------------------------------------------------------------------------------- /c2me-fixes-worldgen-threading-issues/src/main/resources/fabric.mod.json: -------------------------------------------------------------------------------- 1 | { 2 | "schemaVersion": 1, 3 | "id": "c2me-fixes-worldgen-threading-issues", 4 | "version": "${version}", 5 | "name": "Concurrent Chunk Management Engine (Fixes/WorldGen/Threading Issues)", 6 | "description": "Fixes threading issues for vanilla world generation code", 7 | "environment": "*", 8 | "mixins": [ 9 | "c2me-fixes-worldgen-threading-issues.mixins.json" 10 | ], 11 | "depends": { 12 | "minecraft": "*", 13 | "fabricloader": "*", 14 | "c2me-base": "*", 15 | "c2me-fixes-general-threading-issues": "*" 16 | }, 17 | 18 | "authors": [ 19 | "RelativityMC", 20 | "ishland" 21 | ], 22 | "contact": { 23 | "sources": "https://github.com/RelativityMC/C2ME-fabric", 24 | "issues": "https://github.com/RelativityMC/C2ME-fabric/issues", 25 | "discord": "https://discord.gg/Kdy8NM5HW4", 26 | "homepage": "https://modrinth.com/mod/c2me-fabric" 27 | }, 28 | "license": "MIT", 29 | "custom": { 30 | "modmenu": { 31 | "parent": "c2me" 32 | } 33 | } 34 | } 35 | -------------------------------------------------------------------------------- /c2me-fixes-worldgen-vanilla-bugs/build.gradle: -------------------------------------------------------------------------------- 1 | moduleDependencies(project, [ 2 | "c2me-base", 3 | ]) 4 | 5 | -------------------------------------------------------------------------------- /c2me-fixes-worldgen-vanilla-bugs/src/main/java/com/ishland/c2me/fixes/worldgen/vanilla_bugs/ModuleEntryPoint.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.fixes.worldgen.vanilla_bugs; 2 | 3 | public class ModuleEntryPoint { 4 | 5 | private static final boolean enabled = true; 6 | 7 | } 8 | -------------------------------------------------------------------------------- /c2me-fixes-worldgen-vanilla-bugs/src/main/java/com/ishland/c2me/fixes/worldgen/vanilla_bugs/package-info.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.fixes.worldgen.vanilla_bugs; -------------------------------------------------------------------------------- /c2me-fixes-worldgen-vanilla-bugs/src/main/resources/c2me-fixes-worldgen-vanilla-bugs.mixins.json: -------------------------------------------------------------------------------- 1 | { 2 | "parent": "c2me.mixins.json", 3 | "required": true, 4 | "package": "com.ishland.c2me.fixes.worldgen.vanilla_bugs.mixin", 5 | "plugin": "com.ishland.c2me.base.common.ModuleMixinPlugin", 6 | "mixins": [ 7 | "ensure_chunk_status_before_callback.MixinChunkHolder" 8 | ] 9 | } 10 | -------------------------------------------------------------------------------- /c2me-fixes-worldgen-vanilla-bugs/src/main/resources/fabric.mod.json: -------------------------------------------------------------------------------- 1 | { 2 | "schemaVersion": 1, 3 | "id": "c2me-fixes-worldgen-vanilla-bugs", 4 | "version": "${version}", 5 | "name": "Concurrent Chunk Management Engine (Fixes/WorldGen/Vanilla Bugs)", 6 | "description": "Fixes for some vanilla worldgen crashing bugs", 7 | "environment": "*", 8 | "mixins": [ 9 | "c2me-fixes-worldgen-vanilla-bugs.mixins.json" 10 | ], 11 | "depends": { 12 | "minecraft": "*", 13 | "fabricloader": "*", 14 | "c2me-base": "*" 15 | }, 16 | 17 | "authors": [ 18 | "RelativityMC", 19 | "ishland" 20 | ], 21 | "contact": { 22 | "sources": "https://github.com/RelativityMC/C2ME-fabric", 23 | "issues": "https://github.com/RelativityMC/C2ME-fabric/issues", 24 | "discord": "https://discord.gg/Kdy8NM5HW4", 25 | "homepage": "https://modrinth.com/mod/c2me-fabric" 26 | }, 27 | "license": "MIT", 28 | "custom": { 29 | "modmenu": { 30 | "parent": "c2me" 31 | } 32 | } 33 | } 34 | -------------------------------------------------------------------------------- /c2me-notickvd/build.gradle: -------------------------------------------------------------------------------- 1 | moduleDependencies(project, [ 2 | "c2me-base", 3 | "c2me-rewrites-chunk-system", 4 | ]) 5 | 6 | -------------------------------------------------------------------------------- /c2me-notickvd/src/main/java/com/ishland/c2me/notickvd/MixinPlugin.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.notickvd; 2 | 3 | import com.ishland.c2me.base.common.ModuleMixinPlugin; 4 | import com.ishland.c2me.notickvd.common.Config; 5 | 6 | public class MixinPlugin extends ModuleMixinPlugin { 7 | 8 | @Override 9 | public boolean shouldApplyMixin(String targetClassName, String mixinClassName) { 10 | if (!super.shouldApplyMixin(targetClassName, mixinClassName)) return false; 11 | 12 | if (mixinClassName.startsWith("com.ishland.c2me.notickvd.mixin.ext_render_distance.")) { 13 | return Config.enableExtRenderDistanceProtocol; 14 | } 15 | 16 | return true; 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /c2me-notickvd/src/main/java/com/ishland/c2me/notickvd/ModuleEntryPoint.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.notickvd; 2 | 3 | import com.ishland.c2me.base.common.config.ConfigSystem; 4 | import com.ishland.c2me.notickvd.common.Config; 5 | 6 | public class ModuleEntryPoint { 7 | 8 | public static final boolean enabled = new ConfigSystem.ConfigAccessor() 9 | .key("noTickViewDistance.enabled") 10 | .comment("Whether to enable no-tick view distance") 11 | .getBoolean(true, false); 12 | 13 | static { 14 | Config.init(); 15 | } 16 | 17 | } 18 | -------------------------------------------------------------------------------- /c2me-notickvd/src/main/java/com/ishland/c2me/notickvd/common/ChunkLevelManagerExtension.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.notickvd.common; 2 | 3 | public interface ChunkLevelManagerExtension { 4 | 5 | long c2me$getPendingLoadsCount(); 6 | 7 | void c2me$closeNoTickVD(); 8 | 9 | } 10 | -------------------------------------------------------------------------------- /c2me-notickvd/src/main/java/com/ishland/c2me/notickvd/common/IChunkHolder.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.notickvd.common; 2 | 3 | import net.minecraft.world.chunk.WorldChunk; 4 | 5 | public interface IChunkHolder { 6 | 7 | WorldChunk getAccessibleChunk(); 8 | 9 | } 10 | -------------------------------------------------------------------------------- /c2me-notickvd/src/main/java/com/ishland/c2me/notickvd/common/IRenderDistanceOverride.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.notickvd.common; 2 | 3 | public interface IRenderDistanceOverride { 4 | 5 | void c2me_notickvd$setRenderDistance(int renderDistance); 6 | 7 | } 8 | -------------------------------------------------------------------------------- /c2me-notickvd/src/main/java/com/ishland/c2me/notickvd/common/NoTickVDInitializer.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.notickvd.common; 2 | 3 | import com.ishland.c2me.base.common.config.ModStatuses; 4 | import com.ishland.c2me.notickvd.ModuleEntryPoint; 5 | import net.fabricmc.api.ModInitializer; 6 | 7 | public class NoTickVDInitializer implements ModInitializer { 8 | @Override 9 | public void onInitialize() { 10 | if (ModuleEntryPoint.enabled && Config.enableExtRenderDistanceProtocol && ModStatuses.fabric_networking_api_v1) { 11 | ServerExtNetworking.registerListeners(); 12 | } 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /c2me-notickvd/src/main/java/com/ishland/c2me/notickvd/common/ServerExtNetworking.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.notickvd.common; 2 | 3 | import com.ishland.c2me.base.common.network.ExtRenderDistance; 4 | import net.fabricmc.fabric.api.networking.v1.ServerConfigurationNetworking; 5 | import net.fabricmc.fabric.api.networking.v1.ServerPlayNetworking; 6 | 7 | public class ServerExtNetworking { 8 | 9 | public static void registerListeners() { 10 | ExtRenderDistance.init(); 11 | ServerPlayNetworking.registerGlobalReceiver( 12 | ExtRenderDistance.ID, 13 | (payload, context) -> 14 | ((IRenderDistanceOverride) context.player().networkHandler).c2me_notickvd$setRenderDistance(payload.renderDistance()) 15 | ); 16 | ServerConfigurationNetworking.registerGlobalReceiver( 17 | ExtRenderDistance.ID, 18 | (payload, context) -> 19 | ((IRenderDistanceOverride) context.networkHandler()).c2me_notickvd$setRenderDistance(payload.renderDistance()) 20 | ); 21 | } 22 | 23 | } 24 | -------------------------------------------------------------------------------- /c2me-notickvd/src/main/java/com/ishland/c2me/notickvd/common/iterators/ChunkIterator.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.notickvd.common.iterators; 2 | 3 | import net.minecraft.util.math.ChunkPos; 4 | 5 | import java.util.Iterator; 6 | 7 | public interface ChunkIterator extends Iterator { 8 | 9 | long remaining(); 10 | 11 | long total(); 12 | 13 | int originX(); 14 | 15 | int originZ(); 16 | 17 | int radius(); 18 | 19 | default boolean isInRange(int x, int z) { 20 | int originX = this.originX(); 21 | int originZ = this.originZ(); 22 | int radius = this.radius(); 23 | return x >= originX - radius && x <= originX + radius && 24 | z >= originZ - radius && z <= originZ + radius; 25 | } 26 | 27 | } 28 | -------------------------------------------------------------------------------- /c2me-notickvd/src/main/java/com/ishland/c2me/notickvd/mixin/MixinChunkLevelManagerNearbyChunkTicketUpdater.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.notickvd.mixin; 2 | 3 | import com.ishland.c2me.base.mixin.access.IChunkLevelManagerDistanceFromNearestPlayerTracker; 4 | import net.minecraft.server.world.ChunkLevelManager; 5 | import net.minecraft.util.math.MathHelper; 6 | import org.spongepowered.asm.mixin.Mixin; 7 | import org.spongepowered.asm.mixin.injection.At; 8 | import org.spongepowered.asm.mixin.injection.ModifyVariable; 9 | 10 | @Mixin(ChunkLevelManager.NearbyChunkTicketUpdater.class) 11 | public abstract class MixinChunkLevelManagerNearbyChunkTicketUpdater { 12 | 13 | @ModifyVariable(method = "setWatchDistance", at = @At("HEAD"), argsOnly = true) 14 | private int clampViewDistance(int watchDistance) { 15 | return MathHelper.clamp(watchDistance, 0, ((IChunkLevelManagerDistanceFromNearestPlayerTracker) this).getMaxDistance()); 16 | } 17 | 18 | } 19 | -------------------------------------------------------------------------------- /c2me-notickvd/src/main/java/com/ishland/c2me/notickvd/mixin/MixinPlayerManager.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.notickvd.mixin; 2 | 3 | import net.minecraft.server.PlayerManager; 4 | import org.spongepowered.asm.mixin.Mixin; 5 | 6 | @Mixin(PlayerManager.class) 7 | public class MixinPlayerManager { 8 | } 9 | -------------------------------------------------------------------------------- /c2me-notickvd/src/main/java/com/ishland/c2me/notickvd/mixin/MixinServerBlockTicking.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.notickvd.mixin; 2 | 3 | import com.ishland.c2me.notickvd.common.Config; 4 | import com.ishland.c2me.rewrites.chunksystem.common.statuses.ServerBlockTicking; 5 | import org.spongepowered.asm.mixin.Mixin; 6 | import org.spongepowered.asm.mixin.Pseudo; 7 | import org.spongepowered.asm.mixin.injection.At; 8 | import org.spongepowered.asm.mixin.injection.Inject; 9 | import org.spongepowered.asm.mixin.injection.callback.CallbackInfo; 10 | 11 | @Pseudo 12 | @Mixin(value = ServerBlockTicking.class, remap = false) 13 | public class MixinServerBlockTicking { 14 | 15 | @Inject(method = "sendChunkToPlayer(Lcom/ishland/c2me/rewrites/chunksystem/common/ChunkLoadingContext;)V", at = @At("HEAD"), remap = false, cancellable = true) 16 | private static void preventChunkSending(CallbackInfo ci) { 17 | if (!Config.ensureChunkCorrectness) { 18 | ci.cancel(); 19 | } 20 | } 21 | 22 | } 23 | -------------------------------------------------------------------------------- /c2me-notickvd/src/main/java/com/ishland/c2me/notickvd/mixin/MixinSimulationDistanceLevelPropagator.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.notickvd.mixin; 2 | 3 | import net.minecraft.server.world.SimulationDistanceLevelPropagator; 4 | import org.spongepowered.asm.mixin.Mixin; 5 | import org.spongepowered.asm.mixin.injection.Constant; 6 | import org.spongepowered.asm.mixin.injection.ModifyConstant; 7 | 8 | @Mixin(SimulationDistanceLevelPropagator.class) 9 | public class MixinSimulationDistanceLevelPropagator { 10 | 11 | @ModifyConstant(method = "", constant = {@Constant(intValue = 34), @Constant(intValue = 33)}, require = 2) 12 | private static int modifyMax(int constant) { 13 | return constant + 1; 14 | } 15 | 16 | @ModifyConstant(method = "setLevel", constant = @Constant(intValue = 33)) 17 | private int modifyMax2(int constant) { 18 | return constant + 1; 19 | } 20 | 21 | } 22 | -------------------------------------------------------------------------------- /c2me-notickvd/src/main/java/com/ishland/c2me/notickvd/mixin/MixinWorld.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.notickvd.mixin; 2 | 3 | import net.minecraft.server.world.ChunkLevelType; 4 | import net.minecraft.world.World; 5 | import org.spongepowered.asm.mixin.Final; 6 | import org.spongepowered.asm.mixin.Mixin; 7 | import org.spongepowered.asm.mixin.Shadow; 8 | import org.spongepowered.asm.mixin.injection.At; 9 | import org.spongepowered.asm.mixin.injection.ModifyArg; 10 | 11 | @Mixin(World.class) 12 | public class MixinWorld { 13 | 14 | @Shadow @Final public boolean isClient; 15 | 16 | @ModifyArg(method = "setBlockState(Lnet/minecraft/util/math/BlockPos;Lnet/minecraft/block/BlockState;II)Z", at = @At(value = "INVOKE", target = "Lnet/minecraft/server/world/ChunkLevelType;isAfter(Lnet/minecraft/server/world/ChunkLevelType;)Z")) 17 | private ChunkLevelType modifyLeastStatus(ChunkLevelType levelType) { 18 | return levelType.ordinal() > ChunkLevelType.FULL.ordinal() ? ChunkLevelType.FULL : levelType; 19 | } 20 | 21 | } 22 | -------------------------------------------------------------------------------- /c2me-notickvd/src/main/java/com/ishland/c2me/notickvd/mixin/MixinWorldChunk.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.notickvd.mixin; 2 | 3 | import net.minecraft.block.Block; 4 | import net.minecraft.world.chunk.WorldChunk; 5 | import org.spongepowered.asm.mixin.Mixin; 6 | import org.spongepowered.asm.mixin.injection.At; 7 | import org.spongepowered.asm.mixin.injection.ModifyArg; 8 | 9 | @Mixin(WorldChunk.class) 10 | public class MixinWorldChunk { 11 | 12 | @ModifyArg(method = "runPostProcessing", at = @At(value = "INVOKE", target = "Lnet/minecraft/server/world/ServerWorld;setBlockState(Lnet/minecraft/util/math/BlockPos;Lnet/minecraft/block/BlockState;I)Z")) 13 | private int notifyListenersWhenPostProcessing(int flags) { 14 | // if (true) return flags; 15 | flags &= ~Block.NO_REDRAW; // clear NO_REDRAW 16 | flags |= Block.NOTIFY_LISTENERS; // set NOTIFY_LISTENERS 17 | return flags; 18 | } 19 | 20 | } 21 | -------------------------------------------------------------------------------- /c2me-notickvd/src/main/java/com/ishland/c2me/notickvd/package-info.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.notickvd; -------------------------------------------------------------------------------- /c2me-notickvd/src/main/resources/c2me-notickvd.mixins.json: -------------------------------------------------------------------------------- 1 | { 2 | "parent": "c2me.mixins.json", 3 | "required": true, 4 | "package": "com.ishland.c2me.notickvd.mixin", 5 | "plugin": "com.ishland.c2me.base.common.ModuleMixinPlugin", 6 | "mixins": [ 7 | "MixinChunkHolder", 8 | "MixinChunkLevelManager", 9 | "MixinChunkLevelManagerNearbyChunkTicketUpdater", 10 | "MixinMinecraftServer", 11 | "MixinPlayerManager", 12 | "MixinServerAccessibleChunkSending", 13 | "MixinServerBlockTicking", 14 | "MixinServerChunkManager", 15 | "MixinSimulationDistanceLevelPropagator", 16 | "MixinThreadedAnvilChunkStorage", 17 | "MixinWorld", 18 | "MixinWorldChunk", 19 | "ext_render_distance.MixinServerConfigurationNetworkHandler", 20 | "ext_render_distance.MixinServerPlayNetworkHandler" 21 | ], 22 | "client": [ 23 | "client.MixinIntegratedServer" 24 | ] 25 | } 26 | -------------------------------------------------------------------------------- /c2me-notickvd/src/main/resources/fabric.mod.json: -------------------------------------------------------------------------------- 1 | { 2 | "schemaVersion": 1, 3 | "id": "c2me-notickvd", 4 | "version": "${version}", 5 | "name": "Concurrent Chunk Management Engine (No Tick View Distance)", 6 | "description": "Faster alternative implementation of simulation distance supporting view distance up to 65535 chunks", 7 | "environment": "*", 8 | "mixins": [ 9 | "c2me-notickvd.mixins.json" 10 | ], 11 | "depends": { 12 | "minecraft": "*", 13 | "fabricloader": "*", 14 | "c2me-base": "*", 15 | "c2me-rewrites-chunk-system": "*" 16 | }, 17 | "entrypoints": { 18 | "main": [ 19 | "com.ishland.c2me.notickvd.common.NoTickVDInitializer" 20 | ] 21 | }, 22 | 23 | "authors": [ 24 | "RelativityMC", 25 | "ishland" 26 | ], 27 | "contact": { 28 | "sources": "https://github.com/RelativityMC/C2ME-fabric", 29 | "issues": "https://github.com/RelativityMC/C2ME-fabric/issues", 30 | "discord": "https://discord.gg/Kdy8NM5HW4", 31 | "homepage": "https://modrinth.com/mod/c2me-fabric" 32 | }, 33 | "license": "MIT", 34 | "custom": { 35 | "modmenu": { 36 | "parent": "c2me" 37 | } 38 | } 39 | } 40 | -------------------------------------------------------------------------------- /c2me-opts-allocs/build.gradle: -------------------------------------------------------------------------------- 1 | moduleDependencies(project, [ 2 | "c2me-base", 3 | ]) 4 | 5 | -------------------------------------------------------------------------------- /c2me-opts-allocs/src/main/java/com/ishland/c2me/opts/allocs/ModuleEntryPoint.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.opts.allocs; 2 | 3 | public class ModuleEntryPoint { 4 | 5 | private static final boolean enabled = true; 6 | 7 | } 8 | -------------------------------------------------------------------------------- /c2me-opts-allocs/src/main/java/com/ishland/c2me/opts/allocs/common/ObjectCachingUtils.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.opts.allocs.common; 2 | 3 | import it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap; 4 | 5 | import java.util.BitSet; 6 | import java.util.function.IntFunction; 7 | 8 | public class ObjectCachingUtils { 9 | 10 | private static final IntFunction bitSetConstructor = BitSet::new; 11 | 12 | public static ThreadLocal> BITSETS = ThreadLocal.withInitial(Int2ObjectOpenHashMap::new); 13 | 14 | private ObjectCachingUtils() { 15 | } 16 | 17 | public static BitSet getCachedOrNewBitSet(int bits) { 18 | final BitSet bitSet = BITSETS.get().computeIfAbsent(bits, bitSetConstructor); 19 | bitSet.clear(); 20 | return bitSet; 21 | } 22 | 23 | } 24 | -------------------------------------------------------------------------------- /c2me-opts-allocs/src/main/java/com/ishland/c2me/opts/allocs/common/ducks/CombinedBlockPredicateExtension.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.opts.allocs.common.ducks; 2 | 3 | import net.minecraft.world.gen.blockpredicate.BlockPredicate; 4 | 5 | public interface CombinedBlockPredicateExtension { 6 | 7 | BlockPredicate[] c2me$getPredicatesArray(); 8 | 9 | } 10 | -------------------------------------------------------------------------------- /c2me-opts-allocs/src/main/java/com/ishland/c2me/opts/allocs/mixin/MixinIdentifier.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.opts.allocs.mixin; 2 | 3 | import net.minecraft.util.Identifier; 4 | import org.spongepowered.asm.mixin.Final; 5 | import org.spongepowered.asm.mixin.Mixin; 6 | import org.spongepowered.asm.mixin.Overwrite; 7 | import org.spongepowered.asm.mixin.Shadow; 8 | import org.spongepowered.asm.mixin.Unique; 9 | 10 | @Mixin(Identifier.class) 11 | public class MixinIdentifier { 12 | 13 | @Shadow @Final protected String namespace; 14 | @Shadow @Final protected String path; 15 | @Unique 16 | private String cachedString = null; 17 | 18 | /** 19 | * @author ishland 20 | * @reason cache toString 21 | */ 22 | @Overwrite 23 | public String toString() { 24 | if (this.cachedString != null) return this.cachedString; 25 | final String s = this.namespace + ":" + this.path; 26 | this.cachedString = s; 27 | return s; 28 | } 29 | 30 | } 31 | -------------------------------------------------------------------------------- /c2me-opts-allocs/src/main/java/com/ishland/c2me/opts/allocs/mixin/object_pooling_caching/MixinOreFeature.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.opts.allocs.mixin.object_pooling_caching; 2 | 3 | import com.ishland.c2me.opts.allocs.common.ObjectCachingUtils; 4 | import net.minecraft.world.gen.feature.OreFeature; 5 | import org.spongepowered.asm.mixin.Mixin; 6 | import org.spongepowered.asm.mixin.injection.At; 7 | import org.spongepowered.asm.mixin.injection.Redirect; 8 | 9 | import java.util.BitSet; 10 | 11 | @Mixin(OreFeature.class) 12 | public class MixinOreFeature { 13 | 14 | @Redirect(method = "generateVeinPart", at = @At(value = "NEW", target = "java/util/BitSet")) 15 | private BitSet redirectNewBitSet(int nbits) { 16 | return ObjectCachingUtils.getCachedOrNewBitSet(nbits); 17 | } 18 | 19 | } 20 | -------------------------------------------------------------------------------- /c2me-opts-allocs/src/main/java/com/ishland/c2me/opts/allocs/package-info.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.opts.allocs; -------------------------------------------------------------------------------- /c2me-opts-allocs/src/main/resources/c2me-opts-allocs.mixins.json: -------------------------------------------------------------------------------- 1 | { 2 | "parent": "c2me.mixins.json", 3 | "required": true, 4 | "package": "com.ishland.c2me.opts.allocs.mixin", 5 | "plugin": "com.ishland.c2me.opts.allocs.MixinPlugin", 6 | "mixins": [ 7 | "MixinIdentifier", 8 | "MixinNbtCompound", 9 | "MixinNbtCompound1", 10 | "MixinNbtList", 11 | "MixinUtil", 12 | "object_pooling_caching.MixinConfiguredFeature", 13 | "object_pooling_caching.MixinOreFeature", 14 | "predicates.MixinAllOfBlockPredicate", 15 | "predicates.MixinAnyOfBlockPredicate", 16 | "predicates.MixinCombinedBlockPredicate", 17 | "predicates.MixinOffsetPredicate", 18 | "surfacebuilder.MixinMaterialRuleContext", 19 | "surfacebuilder.MixinMaterialRulesSequenceBlockStateRule", 20 | "surfacebuilder.MixinMaterialRulesSequenceMaterialRule" 21 | ] 22 | } 23 | -------------------------------------------------------------------------------- /c2me-opts-allocs/src/main/resources/fabric.mod.json: -------------------------------------------------------------------------------- 1 | { 2 | "schemaVersion": 1, 3 | "id": "c2me-opts-allocs", 4 | "version": "${version}", 5 | "name": "Concurrent Chunk Management Engine (Optimizations/Memory Allocations)", 6 | "description": "Optimizations for reducing memory allocations to reduce lag spikes", 7 | "environment": "*", 8 | "mixins": [ 9 | "c2me-opts-allocs.mixins.json" 10 | ], 11 | "depends": { 12 | "minecraft": "*", 13 | "fabricloader": "*", 14 | "c2me-base": "*" 15 | }, 16 | 17 | "authors": [ 18 | "RelativityMC", 19 | "ishland" 20 | ], 21 | "contact": { 22 | "sources": "https://github.com/RelativityMC/C2ME-fabric", 23 | "issues": "https://github.com/RelativityMC/C2ME-fabric/issues", 24 | "discord": "https://discord.gg/Kdy8NM5HW4", 25 | "homepage": "https://modrinth.com/mod/c2me-fabric" 26 | }, 27 | "license": "MIT", 28 | "custom": { 29 | "modmenu": { 30 | "parent": "c2me" 31 | } 32 | } 33 | } 34 | -------------------------------------------------------------------------------- /c2me-opts-chunkio/build.gradle: -------------------------------------------------------------------------------- 1 | moduleDependencies(project, [ 2 | "c2me-base", 3 | ]) 4 | 5 | -------------------------------------------------------------------------------- /c2me-opts-chunkio/src/main/java/com/ishland/c2me/opts/chunkio/MixinPlugin.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.opts.chunkio; 2 | 3 | import com.ishland.c2me.base.common.ModuleMixinPlugin; 4 | 5 | public class MixinPlugin extends ModuleMixinPlugin { 6 | 7 | @Override 8 | public boolean shouldApplyMixin(String targetClassName, String mixinClassName) { 9 | if (!super.shouldApplyMixin(targetClassName, mixinClassName)) return false; 10 | 11 | return true; 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /c2me-opts-chunkio/src/main/java/com/ishland/c2me/opts/chunkio/ModuleEntryPoint.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.opts.chunkio; 2 | 3 | import com.ishland.c2me.opts.chunkio.common.Config; 4 | 5 | public class ModuleEntryPoint { 6 | 7 | private static final boolean enabled = true; 8 | 9 | static { 10 | Config.init(); 11 | } 12 | 13 | } 14 | -------------------------------------------------------------------------------- /c2me-opts-chunkio/src/main/java/com/ishland/c2me/opts/chunkio/common/Config.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.opts.chunkio.common; 2 | 3 | import com.ishland.c2me.base.common.config.ConfigSystem; 4 | import org.slf4j.Logger; 5 | import org.slf4j.LoggerFactory; 6 | 7 | public class Config { 8 | 9 | static final Logger LOGGER = LoggerFactory.getLogger("C2ME Opts/ChunkIO Config"); 10 | 11 | public static final long chunkDataCacheSoftLimit = new ConfigSystem.ConfigAccessor() 12 | .key("ioSystem.chunkDataCacheSoftLimit") 13 | .comment("Soft limit for io worker nbt cache") 14 | .getLong(8192, 8192, ConfigSystem.LongChecks.POSITIVE_VALUES_ONLY); 15 | 16 | public static final long chunkDataCacheLimit = new ConfigSystem.ConfigAccessor() 17 | .key("ioSystem.chunkDataCacheLimit") 18 | .comment("Hard limit for io worker nbt cache") 19 | .getLong(32678, 32678, ConfigSystem.LongChecks.POSITIVE_VALUES_ONLY); 20 | 21 | public static void init() { 22 | } 23 | 24 | } 25 | -------------------------------------------------------------------------------- /c2me-opts-chunkio/src/main/java/com/ishland/c2me/opts/chunkio/mixin/hide_sync_disk_writes_behind_flag/MixinRegionBasedStorage.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.opts.chunkio.mixin.hide_sync_disk_writes_behind_flag; 2 | 3 | import net.minecraft.world.storage.RegionBasedStorage; 4 | import org.spongepowered.asm.mixin.Final; 5 | import org.spongepowered.asm.mixin.Mixin; 6 | import org.spongepowered.asm.mixin.Mutable; 7 | import org.spongepowered.asm.mixin.Shadow; 8 | import org.spongepowered.asm.mixin.injection.At; 9 | import org.spongepowered.asm.mixin.injection.Inject; 10 | import org.spongepowered.asm.mixin.injection.callback.CallbackInfo; 11 | 12 | @Mixin(RegionBasedStorage.class) 13 | public class MixinRegionBasedStorage { 14 | 15 | @Mutable 16 | @Shadow @Final private boolean dsync; 17 | 18 | @Inject(method = "", at = @At("RETURN")) 19 | private void onPostInit(CallbackInfo info) { 20 | this.dsync = Boolean.parseBoolean(System.getProperty("com.ishland.c2me.chunkio.syncDiskWrites", "false")); 21 | } 22 | 23 | } 24 | -------------------------------------------------------------------------------- /c2me-opts-chunkio/src/main/java/com/ishland/c2me/opts/chunkio/package-info.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.opts.chunkio; -------------------------------------------------------------------------------- /c2me-opts-chunkio/src/main/resources/c2me-opts-chunkio.mixins.json: -------------------------------------------------------------------------------- 1 | { 2 | "parent": "c2me.mixins.json", 3 | "required": true, 4 | "package": "com.ishland.c2me.opts.chunkio.mixin", 5 | "plugin": "com.ishland.c2me.opts.chunkio.MixinPlugin", 6 | "mixins": [ 7 | "hide_sync_disk_writes_behind_flag.MixinRegionBasedStorage", 8 | "limit_nbt_cache.MixinStorageIoWorker" 9 | ] 10 | } 11 | -------------------------------------------------------------------------------- /c2me-opts-chunkio/src/main/resources/fabric.mod.json: -------------------------------------------------------------------------------- 1 | { 2 | "schemaVersion": 1, 3 | "id": "c2me-opts-chunkio", 4 | "version": "${version}", 5 | "name": "Concurrent Chunk Management Engine (Optimizations/Chunk IO)", 6 | "description": "Optimizations for chunk IO", 7 | "environment": "*", 8 | "mixins": [ 9 | "c2me-opts-chunkio.mixins.json" 10 | ], 11 | "depends": { 12 | "minecraft": "*", 13 | "fabricloader": "*", 14 | "c2me-base": "*" 15 | }, 16 | 17 | "authors": [ 18 | "RelativityMC", 19 | "ishland" 20 | ], 21 | "contact": { 22 | "sources": "https://github.com/RelativityMC/C2ME-fabric", 23 | "issues": "https://github.com/RelativityMC/C2ME-fabric/issues", 24 | "discord": "https://discord.gg/Kdy8NM5HW4", 25 | "homepage": "https://modrinth.com/mod/c2me-fabric" 26 | }, 27 | "license": "MIT", 28 | "custom": { 29 | "modmenu": { 30 | "parent": "c2me" 31 | } 32 | } 33 | } 34 | -------------------------------------------------------------------------------- /c2me-opts-dfc/build.gradle: -------------------------------------------------------------------------------- 1 | moduleDependencies(project, [ 2 | "c2me-base", 3 | ]) 4 | 5 | -------------------------------------------------------------------------------- /c2me-opts-dfc/src/main/java/com/ishland/c2me/opts/dfc/common/ast/AstNode.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.opts.dfc.common.ast; 2 | 3 | import com.ishland.c2me.opts.dfc.common.gen.BytecodeGen; 4 | import org.objectweb.asm.commons.InstructionAdapter; 5 | 6 | public interface AstNode { 7 | 8 | double evalSingle(int x, int y, int z, EvalType type); 9 | 10 | void evalMulti(double[] res, int[] x, int[] y, int[] z, EvalType type); 11 | 12 | AstNode[] getChildren(); 13 | 14 | AstNode transform(AstTransformer transformer); 15 | 16 | void doBytecodeGenSingle(BytecodeGen.Context context, InstructionAdapter m, BytecodeGen.Context.LocalVarConsumer localVarConsumer); 17 | 18 | void doBytecodeGenMulti(BytecodeGen.Context context, InstructionAdapter m, BytecodeGen.Context.LocalVarConsumer localVarConsumer); 19 | 20 | // data to be created as fields in generated code are only compared by class type 21 | boolean relaxedEquals(AstNode o); 22 | 23 | int relaxedHashCode(); 24 | 25 | } 26 | -------------------------------------------------------------------------------- /c2me-opts-dfc/src/main/java/com/ishland/c2me/opts/dfc/common/ast/AstTransformer.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.opts.dfc.common.ast; 2 | 3 | public interface AstTransformer { 4 | 5 | AstNode transform(AstNode astNode); 6 | 7 | } 8 | -------------------------------------------------------------------------------- /c2me-opts-dfc/src/main/java/com/ishland/c2me/opts/dfc/common/ast/EvalType.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.opts.dfc.common.ast; 2 | 3 | import com.ishland.c2me.opts.dfc.common.vif.EachApplierVanillaInterface; 4 | import net.minecraft.world.gen.chunk.ChunkNoiseSampler; 5 | import net.minecraft.world.gen.densityfunction.DensityFunction; 6 | 7 | public enum EvalType { 8 | NORMAL, INTERPOLATION; 9 | 10 | public static EvalType from(DensityFunction.NoisePos pos) { 11 | return pos instanceof ChunkNoiseSampler ? INTERPOLATION : NORMAL; 12 | } 13 | 14 | public static EvalType from(DensityFunction.EachApplier applier) { 15 | if (applier instanceof EachApplierVanillaInterface vif) { 16 | return vif.getType(); 17 | } 18 | return applier instanceof ChunkNoiseSampler ? INTERPOLATION : NORMAL; 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /c2me-opts-dfc/src/main/java/com/ishland/c2me/opts/dfc/common/ast/dfvisitor/StripBlending.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.opts.dfc.common.ast.dfvisitor; 2 | 3 | import net.minecraft.world.gen.chunk.ChunkNoiseSampler; 4 | import net.minecraft.world.gen.densityfunction.DensityFunction; 5 | import net.minecraft.world.gen.densityfunction.DensityFunctionTypes; 6 | 7 | public class StripBlending implements DensityFunction.DensityFunctionVisitor { 8 | 9 | public static final StripBlending INSTANCE = new StripBlending(); 10 | 11 | private StripBlending() { 12 | } 13 | 14 | @Override 15 | public DensityFunction apply(DensityFunction densityFunction) { 16 | return switch (densityFunction) { 17 | case ChunkNoiseSampler.BlendAlphaDensityFunction f -> DensityFunctionTypes.constant(1.0); 18 | case ChunkNoiseSampler.BlendOffsetDensityFunction f -> DensityFunctionTypes.constant(0.0); 19 | case DensityFunctionTypes.BlendAlpha f -> DensityFunctionTypes.constant(1.0); 20 | case DensityFunctionTypes.BlendOffset f -> DensityFunctionTypes.constant(0.0); 21 | default -> densityFunction; 22 | }; 23 | } 24 | 25 | } 26 | -------------------------------------------------------------------------------- /c2me-opts-dfc/src/main/java/com/ishland/c2me/opts/dfc/common/ast/spline/SplineSupport.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.opts.dfc.common.ast.spline; 2 | 3 | public class SplineSupport { 4 | 5 | public static int findRangeForLocation(float[] locations, float x) { 6 | int min = 0; 7 | int i = locations.length; 8 | 9 | while (i > 0) { 10 | int j = i / 2; 11 | int k = min + j; 12 | if (x < locations[k]) { 13 | i = j; 14 | } else { 15 | min = k + 1; 16 | i -= j + 1; 17 | } 18 | } 19 | 20 | return min - 1; 21 | } 22 | 23 | public static float sampleOutsideRange(float point, float[] locations, float value, float[] derivatives, int i) { 24 | float f = derivatives[i]; 25 | return f == 0.0F ? value : value + f * (point - locations[i]); 26 | } 27 | 28 | } 29 | -------------------------------------------------------------------------------- /c2me-opts-dfc/src/main/java/com/ishland/c2me/opts/dfc/common/ducks/IArrayCacheCapable.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.opts.dfc.common.ducks; 2 | 3 | import com.ishland.c2me.opts.dfc.common.util.ArrayCache; 4 | 5 | public interface IArrayCacheCapable { 6 | 7 | ArrayCache c2me$getArrayCache(); 8 | 9 | } 10 | -------------------------------------------------------------------------------- /c2me-opts-dfc/src/main/java/com/ishland/c2me/opts/dfc/common/ducks/IBlendingAwareVisitor.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.opts.dfc.common.ducks; 2 | 3 | public interface IBlendingAwareVisitor { 4 | 5 | boolean c2me$isBlendingEnabled(); 6 | 7 | } 8 | -------------------------------------------------------------------------------- /c2me-opts-dfc/src/main/java/com/ishland/c2me/opts/dfc/common/ducks/ICoordinatesFilling.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.opts.dfc.common.ducks; 2 | 3 | public interface ICoordinatesFilling { 4 | 5 | void c2me$fillCoordinates(int[] x, int[] y, int[] z); 6 | 7 | } 8 | -------------------------------------------------------------------------------- /c2me-opts-dfc/src/main/java/com/ishland/c2me/opts/dfc/common/ducks/IEqualityOverriding.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.opts.dfc.common.ducks; 2 | 3 | public interface IEqualityOverriding { 4 | 5 | void c2me$overrideEquality(Object object); 6 | 7 | Object c2me$getOverriddenEquality(); 8 | 9 | } 10 | -------------------------------------------------------------------------------- /c2me-opts-dfc/src/main/java/com/ishland/c2me/opts/dfc/common/ducks/IFastCacheLike.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.opts.dfc.common.ducks; 2 | 3 | import com.ishland.c2me.opts.dfc.common.ast.EvalType; 4 | import net.minecraft.world.gen.densityfunction.DensityFunction; 5 | 6 | public interface IFastCacheLike extends DensityFunction { 7 | 8 | public static final long CACHE_MISS_NAN_BITS = 0x7ffddb972d486a4fL; 9 | 10 | double c2me$getCached(int x, int y, int z, EvalType evalType); 11 | 12 | boolean c2me$getCached(double[] res, int[] x, int[] y, int[] z, EvalType evalType); 13 | 14 | void c2me$cache(int x, int y, int z, EvalType evalType, double cached); 15 | 16 | void c2me$cache(double[] res, int[] x, int[] y, int[] z, EvalType evalType); 17 | 18 | DensityFunction c2me$getDelegate(); 19 | 20 | // called by generated code 21 | DensityFunction c2me$withDelegate(DensityFunction delegate); 22 | 23 | } 24 | -------------------------------------------------------------------------------- /c2me-opts-dfc/src/main/java/com/ishland/c2me/opts/dfc/common/gen/CompiledEntry.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.opts.dfc.common.gen; 2 | 3 | import com.ishland.c2me.opts.dfc.common.ast.EvalType; 4 | import com.ishland.c2me.opts.dfc.common.util.ArrayCache; 5 | 6 | import java.util.List; 7 | 8 | public interface CompiledEntry extends ISingleMethod, IMultiMethod { 9 | 10 | double evalSingle(int x, int y, int z, EvalType type); 11 | 12 | void evalMulti(double[] res, int[] x, int[] y, int[] z, EvalType type, ArrayCache arrayCache); 13 | 14 | CompiledEntry newInstance(List args); 15 | 16 | List getArgs(); 17 | 18 | } 19 | -------------------------------------------------------------------------------- /c2me-opts-dfc/src/main/java/com/ishland/c2me/opts/dfc/common/gen/IMultiMethod.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.opts.dfc.common.gen; 2 | 3 | import com.ishland.c2me.opts.dfc.common.ast.EvalType; 4 | import com.ishland.c2me.opts.dfc.common.util.ArrayCache; 5 | 6 | @FunctionalInterface 7 | public interface IMultiMethod { 8 | 9 | void evalMulti(double[] res, int[] x, int[] y, int[] z, EvalType type, ArrayCache arrayCache); 10 | 11 | } 12 | -------------------------------------------------------------------------------- /c2me-opts-dfc/src/main/java/com/ishland/c2me/opts/dfc/common/gen/ISingleMethod.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.opts.dfc.common.gen; 2 | 3 | import com.ishland.c2me.opts.dfc.common.ast.EvalType; 4 | 5 | @FunctionalInterface 6 | public interface ISingleMethod { 7 | 8 | double evalSingle(int x, int y, int z, EvalType type); 9 | 10 | } 11 | -------------------------------------------------------------------------------- /c2me-opts-dfc/src/main/resources/c2me-opts-dfc.mixins.json: -------------------------------------------------------------------------------- 1 | { 2 | "parent": "c2me.mixins.json", 3 | "required": true, 4 | "package": "com.ishland.c2me.opts.dfc.mixin", 5 | "plugin": "com.ishland.c2me.base.common.ModuleMixinPlugin", 6 | "mixins": [ 7 | "MixinChunkNoiseSampler", 8 | "MixinChunkNoiseSampler1", 9 | "MixinChunkNoiseSamplerCache2D", 10 | "MixinChunkNoiseSamplerCacheOnce", 11 | "MixinChunkNoiseSamplerCellCache", 12 | "MixinChunkNoiseSamplerDensityInterpolator", 13 | "MixinChunkNoiseSamplerFlatCache", 14 | "MixinDFTBinaryOperation", 15 | "MixinDFTWrapping", 16 | "MixinNoiseConfig", 17 | "MixinSplineImplementation" 18 | ] 19 | } 20 | -------------------------------------------------------------------------------- /c2me-opts-dfc/src/main/resources/fabric.mod.json: -------------------------------------------------------------------------------- 1 | { 2 | "schemaVersion": 1, 3 | "id": "c2me-opts-dfc", 4 | "version": "${version}", 5 | "name": "Concurrent Chunk Management Engine (Optimizations/Density Function Compiler)", 6 | "description": "Optimizations for density functions used in world generation", 7 | "environment": "*", 8 | "mixins": [ 9 | "c2me-opts-dfc.mixins.json" 10 | ], 11 | "depends": { 12 | "minecraft": "*", 13 | "fabricloader": "*", 14 | "c2me-base": "*" 15 | }, 16 | 17 | "authors": [ 18 | "RelativityMC", 19 | "ishland" 20 | ], 21 | "contact": { 22 | "sources": "https://github.com/RelativityMC/C2ME-fabric", 23 | "issues": "https://github.com/RelativityMC/C2ME-fabric/issues", 24 | "discord": "https://discord.gg/Kdy8NM5HW4", 25 | "homepage": "https://modrinth.com/mod/c2me-fabric" 26 | }, 27 | "license": "MIT", 28 | "custom": { 29 | "modmenu": { 30 | "parent": "c2me" 31 | } 32 | } 33 | } 34 | -------------------------------------------------------------------------------- /c2me-opts-math/build.gradle: -------------------------------------------------------------------------------- 1 | moduleDependencies(project, [ 2 | "c2me-base", 3 | ]) 4 | 5 | -------------------------------------------------------------------------------- /c2me-opts-math/src/main/java/com/ishland/c2me/opts/math/ModuleEntryPoint.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.opts.math; 2 | 3 | public class ModuleEntryPoint { 4 | 5 | private static final boolean enabled = true; 6 | 7 | } 8 | -------------------------------------------------------------------------------- /c2me-opts-math/src/main/java/com/ishland/c2me/opts/math/mixin/MixinChunkPos.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.opts.math.mixin; 2 | 3 | import net.minecraft.util.math.ChunkPos; 4 | import org.spongepowered.asm.mixin.Final; 5 | import org.spongepowered.asm.mixin.Mixin; 6 | import org.spongepowered.asm.mixin.Overwrite; 7 | import org.spongepowered.asm.mixin.Shadow; 8 | 9 | @Mixin(ChunkPos.class) 10 | public class MixinChunkPos { 11 | 12 | @Shadow @Final public int x; 13 | 14 | @Shadow @Final public int z; 15 | 16 | /** 17 | * @author ishland 18 | * @reason use standard impl of equals 19 | */ 20 | @Overwrite 21 | @Override 22 | public boolean equals(Object obj) { 23 | if (obj == this) return true; 24 | if (obj == null || obj.getClass() != this.getClass()) return false; 25 | var that = (ChunkPos) obj; 26 | return this.x == that.x && this.z == that.z; 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /c2me-opts-math/src/main/java/com/ishland/c2me/opts/math/package-info.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.opts.math; -------------------------------------------------------------------------------- /c2me-opts-math/src/main/resources/c2me-opts-math.mixins.json: -------------------------------------------------------------------------------- 1 | { 2 | "parent": "c2me.mixins.json", 3 | "required": true, 4 | "package": "com.ishland.c2me.opts.math.mixin", 5 | "plugin": "com.ishland.c2me.base.common.ModuleMixinPlugin", 6 | "mixins": [ 7 | "MixinChunkPos", 8 | "MixinOctavePerlinNoiseSampler", 9 | "MixinPerlinNoiseSampler" 10 | ] 11 | } 12 | -------------------------------------------------------------------------------- /c2me-opts-math/src/main/resources/fabric.mod.json: -------------------------------------------------------------------------------- 1 | { 2 | "schemaVersion": 1, 3 | "id": "c2me-opts-math", 4 | "version": "${version}", 5 | "name": "Concurrent Chunk Management Engine (Optimizations/Math)", 6 | "description": "Optimizations for math used in world generation", 7 | "environment": "*", 8 | "mixins": [ 9 | "c2me-opts-math.mixins.json" 10 | ], 11 | "depends": { 12 | "minecraft": "*", 13 | "fabricloader": "*", 14 | "c2me-base": "*" 15 | }, 16 | 17 | "authors": [ 18 | "RelativityMC", 19 | "ishland" 20 | ], 21 | "contact": { 22 | "sources": "https://github.com/RelativityMC/C2ME-fabric", 23 | "issues": "https://github.com/RelativityMC/C2ME-fabric/issues", 24 | "discord": "https://discord.gg/Kdy8NM5HW4", 25 | "homepage": "https://modrinth.com/mod/c2me-fabric" 26 | }, 27 | "license": "MIT", 28 | "custom": { 29 | "modmenu": { 30 | "parent": "c2me" 31 | } 32 | } 33 | } 34 | -------------------------------------------------------------------------------- /c2me-opts-natives-math/src/c/exports_x86_64_nogather.c: -------------------------------------------------------------------------------- 1 | #ifdef __x86_64__ 2 | 3 | #define GATHER_DISABLED 1 4 | 5 | #include "exports.c" 6 | 7 | #endif 8 | 9 | typedef int make_iso_compiler_happy; 10 | -------------------------------------------------------------------------------- /c2me-opts-natives-math/src/c/system_isa_aarch64.c: -------------------------------------------------------------------------------- 1 | #ifdef __aarch64__ 2 | 3 | #include 4 | 5 | int32_t c2me_natives_get_system_isa(_Bool allowAVX512) { 6 | return 0; 7 | } 8 | 9 | #endif 10 | 11 | typedef int make_iso_compiler_happy; 12 | -------------------------------------------------------------------------------- /c2me-opts-natives-math/src/c/targets/darwin-x86_64.cmake: -------------------------------------------------------------------------------- 1 | set(CMAKE_SYSTEM_NAME Darwin) 2 | set(CMAKE_SYSTEM_PROCESSOR x86_64) 3 | 4 | set(triple x86_64-apple-darwin) 5 | 6 | set(CMAKE_C_COMPILER clang) 7 | set(CMAKE_C_COMPILER_TARGET ${triple}) 8 | set(CMAKE_CXX_COMPILER clang++) 9 | set(CMAKE_CXX_COMPILER_TARGET ${triple}) 10 | 11 | set(CMAKE_C_FLAGS "-march=x86-64 -Wl,-no_uuid") 12 | -------------------------------------------------------------------------------- /c2me-opts-natives-math/src/c/targets/linux-aarch_64.cmake: -------------------------------------------------------------------------------- 1 | set(CMAKE_SYSTEM_NAME Linux) 2 | set(CMAKE_SYSTEM_PROCESSOR arm64) 3 | 4 | set(triple aarch64-unknown-linux-musl) 5 | 6 | set(CMAKE_C_COMPILER clang) 7 | set(CMAKE_C_COMPILER_TARGET ${triple}) 8 | set(CMAKE_CXX_COMPILER clang++) 9 | set(CMAKE_CXX_COMPILER_TARGET ${triple}) 10 | 11 | -------------------------------------------------------------------------------- /c2me-opts-natives-math/src/c/targets/linux-x86_64.cmake: -------------------------------------------------------------------------------- 1 | set(CMAKE_SYSTEM_NAME Linux) 2 | set(CMAKE_SYSTEM_PROCESSOR x86_64) 3 | 4 | set(triple x86_64-unknown-linux-musl) 5 | 6 | set(CMAKE_C_COMPILER clang) 7 | set(CMAKE_C_COMPILER_TARGET ${triple}) 8 | set(CMAKE_CXX_COMPILER clang++) 9 | set(CMAKE_CXX_COMPILER_TARGET ${triple}) 10 | 11 | set(CMAKE_C_FLAGS -march=x86-64) 12 | -------------------------------------------------------------------------------- /c2me-opts-natives-math/src/c/targets/windows-x86_64.cmake: -------------------------------------------------------------------------------- 1 | set(CMAKE_SYSTEM_NAME Windows) 2 | set(CMAKE_SYSTEM_PROCESSOR AMD64) 3 | 4 | set(triple x86_64-pc-windows-gnu) 5 | 6 | set(CMAKE_C_COMPILER clang) 7 | set(CMAKE_C_COMPILER_TARGET ${triple}) 8 | set(CMAKE_CXX_COMPILER clang++) 9 | set(CMAKE_CXX_COMPILER_TARGET ${triple}) 10 | 11 | set(CMAKE_C_FLAGS "-march=x86-64 -Wl,--no-insert-timestamp") 12 | -------------------------------------------------------------------------------- /c2me-opts-natives-math/src/main/java/com/ishland/c2me/opts/natives_math/common/ISATarget.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.opts.natives_math.common; 2 | 3 | import com.ishland.c2me.opts.natives_math.common.isa.ISA_aarch64; 4 | import com.ishland.c2me.opts.natives_math.common.isa.ISA_x86_64; 5 | 6 | public interface ISATarget { 7 | 8 | int ordinal(); 9 | 10 | String getSuffix(); 11 | 12 | boolean isNativelySupported(); 13 | 14 | static Class> getInstance() { 15 | return switch (NativeLoader.NORMALIZED_ARCH) { 16 | case "x86_64" -> ISA_x86_64.class; 17 | case "aarch_64" -> ISA_aarch64.class; 18 | default -> null; 19 | }; 20 | } 21 | 22 | } 23 | -------------------------------------------------------------------------------- /c2me-opts-natives-math/src/main/java/com/ishland/c2me/opts/natives_math/common/ducks/INativePointer.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.opts.natives_math.common.ducks; 2 | 3 | public interface INativePointer { 4 | 5 | long c2me$getPointer(); 6 | 7 | } 8 | -------------------------------------------------------------------------------- /c2me-opts-natives-math/src/main/java/com/ishland/c2me/opts/natives_math/common/isa/ISA_aarch64.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.opts.natives_math.common.isa; 2 | 3 | import com.ishland.c2me.opts.natives_math.common.ISATarget; 4 | 5 | public enum ISA_aarch64 implements ISATarget { 6 | GENERIC("_generic", true) 7 | ; 8 | 9 | private final String suffix; 10 | private final boolean nativelySupported; 11 | 12 | ISA_aarch64(String suffix, boolean nativelySupported) { 13 | this.suffix = suffix; 14 | this.nativelySupported = nativelySupported; 15 | } 16 | 17 | @Override 18 | public String getSuffix() { 19 | return this.suffix; 20 | } 21 | 22 | @Override 23 | public boolean isNativelySupported() { 24 | return this.nativelySupported; 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /c2me-opts-natives-math/src/main/java/com/ishland/c2me/opts/natives_math/common/util/MemoryUtil.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.opts.natives_math.common.util; 2 | 3 | public class MemoryUtil { 4 | 5 | public static int[] byte2int(byte[] data) { 6 | if (data == null) return null; 7 | int[] ints = new int[data.length]; 8 | for (int i = 0; i < data.length; i++) { 9 | ints[i] = data[i] & 0xff; 10 | } 11 | return ints; 12 | } 13 | 14 | } 15 | -------------------------------------------------------------------------------- /c2me-opts-natives-math/src/main/resources/c2me-opts-natives-math.mixins.json: -------------------------------------------------------------------------------- 1 | { 2 | "parent": "c2me.mixins.json", 3 | "required": true, 4 | "package": "com.ishland.c2me.opts.natives_math.mixin", 5 | "plugin": "com.ishland.c2me.base.common.ModuleMixinPlugin", 6 | "mixins": [ 7 | "MixinBiomeAccess", 8 | "MixinDFTypesEndIslands", 9 | "MixinDoublePerlinNoiseSampler", 10 | "MixinInterpolatedNoiseSampler" 11 | ] 12 | } 13 | -------------------------------------------------------------------------------- /c2me-opts-natives-math/src/main/resources/fabric.mod.json: -------------------------------------------------------------------------------- 1 | { 2 | "schemaVersion": 1, 3 | "id": "c2me-opts-natives-math", 4 | "version": "${version}", 5 | "name": "Concurrent Chunk Management Engine (Optimizations/Natives Math)", 6 | "description": "Optimizations for math using native libraries", 7 | "environment": "*", 8 | "mixins": [ 9 | "c2me-opts-natives-math.mixins.json" 10 | ], 11 | "depends": { 12 | "java": ">=22", 13 | "minecraft": "*", 14 | "fabricloader": "*", 15 | "c2me-base": "*" 16 | }, 17 | 18 | "authors": [ 19 | "RelativityMC", 20 | "ishland" 21 | ], 22 | "contact": { 23 | "sources": "https://github.com/RelativityMC/C2ME-fabric", 24 | "issues": "https://github.com/RelativityMC/C2ME-fabric/issues", 25 | "discord": "https://discord.gg/Kdy8NM5HW4", 26 | "homepage": "https://modrinth.com/mod/c2me-fabric" 27 | }, 28 | "license": "MIT", 29 | "custom": { 30 | "modmenu": { 31 | "parent": "c2me" 32 | } 33 | } 34 | } 35 | -------------------------------------------------------------------------------- /c2me-opts-scheduling/build.gradle: -------------------------------------------------------------------------------- 1 | moduleDependencies(project, [ 2 | "c2me-base", 3 | ]) 4 | 5 | -------------------------------------------------------------------------------- /c2me-opts-scheduling/src/main/java/com/ishland/c2me/opts/scheduling/ModuleEntryPoint.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.opts.scheduling; 2 | 3 | import com.ishland.c2me.opts.scheduling.common.Config; 4 | 5 | public class ModuleEntryPoint { 6 | 7 | private static final boolean enabled = true; 8 | 9 | static { 10 | Config.init(); 11 | } 12 | 13 | } 14 | -------------------------------------------------------------------------------- /c2me-opts-scheduling/src/main/java/com/ishland/c2me/opts/scheduling/common/DuckChunkHolder.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.opts.scheduling.common; 2 | 3 | import net.minecraft.world.LightType; 4 | 5 | public interface DuckChunkHolder { 6 | 7 | void c2me$queueLightSectionDirty(LightType lightType, int sectionY); 8 | 9 | boolean c2me$shouldScheduleUndirty(); 10 | 11 | boolean c2me$undirtyLight(); 12 | 13 | } 14 | -------------------------------------------------------------------------------- /c2me-opts-scheduling/src/main/java/com/ishland/c2me/opts/scheduling/common/IThreadedAnvilChunkStorage.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.opts.scheduling.common; 2 | 3 | import java.util.concurrent.Executor; 4 | 5 | public interface IThreadedAnvilChunkStorage { 6 | 7 | Executor getMainInvokingExecutor(); 8 | 9 | } 10 | -------------------------------------------------------------------------------- /c2me-opts-scheduling/src/main/java/com/ishland/c2me/opts/scheduling/common/ITryFlushable.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.opts.scheduling.common; 2 | 3 | public interface ITryFlushable { 4 | 5 | boolean c2me$tryFlush(); 6 | 7 | } 8 | -------------------------------------------------------------------------------- /c2me-opts-scheduling/src/main/java/com/ishland/c2me/opts/scheduling/common/ServerMidTickTask.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.opts.scheduling.common; 2 | 3 | import net.minecraft.server.world.ServerWorld; 4 | 5 | public interface ServerMidTickTask { 6 | 7 | void executeTasksMidTick(ServerWorld world); 8 | 9 | } 10 | -------------------------------------------------------------------------------- /c2me-opts-scheduling/src/main/java/com/ishland/c2me/opts/scheduling/common/idle_tasks/IThreadedAnvilChunkStorage.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.opts.scheduling.common.idle_tasks; 2 | 3 | public interface IThreadedAnvilChunkStorage { 4 | 5 | boolean c2me$runOneChunkAutoSave(); 6 | 7 | } 8 | -------------------------------------------------------------------------------- /c2me-opts-scheduling/src/main/java/com/ishland/c2me/opts/scheduling/mixin/general_overheads/MixinThreadedAnvilChunkStorage.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.opts.scheduling.mixin.general_overheads; 2 | 3 | import org.spongepowered.asm.mixin.Final; 4 | import org.spongepowered.asm.mixin.Mixin; 5 | import org.spongepowered.asm.mixin.Shadow; 6 | import org.spongepowered.asm.mixin.injection.At; 7 | import org.spongepowered.asm.mixin.injection.Redirect; 8 | 9 | import java.util.Queue; 10 | import net.minecraft.server.world.ServerChunkLoadingManager; 11 | 12 | @Mixin(ServerChunkLoadingManager.class) 13 | public class MixinThreadedAnvilChunkStorage { 14 | 15 | @Shadow @Final private Queue unloadTaskQueue; 16 | 17 | @Redirect(method = "unloadChunks", at = @At(value = "INVOKE", target = "Ljava/util/Queue;size()I")) 18 | private int redirectUnloadSize(Queue queue) { 19 | if (this.unloadTaskQueue == queue) return Integer.MAX_VALUE; 20 | return queue.size(); 21 | } 22 | 23 | } 24 | -------------------------------------------------------------------------------- /c2me-opts-scheduling/src/main/java/com/ishland/c2me/opts/scheduling/mixin/idle_tasks/autosave/disable_vanilla_mid_tick_autosave/MixinThreadedAnvilChunkStorage.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.opts.scheduling.mixin.idle_tasks.autosave.disable_vanilla_mid_tick_autosave; 2 | 3 | import com.llamalad7.mixinextras.injector.v2.WrapWithCondition; 4 | import net.minecraft.server.world.ServerChunkLoadingManager; 5 | import org.spongepowered.asm.mixin.Mixin; 6 | import org.spongepowered.asm.mixin.injection.At; 7 | 8 | import java.util.function.BooleanSupplier; 9 | 10 | @Mixin(ServerChunkLoadingManager.class) 11 | public class MixinThreadedAnvilChunkStorage { 12 | 13 | @WrapWithCondition(method = "unloadChunks", at = @At(value = "INVOKE", target = "Lnet/minecraft/server/world/ServerChunkLoadingManager;saveChunks(Ljava/util/function/BooleanSupplier;)V")) 14 | private boolean stopAutoSavingDuringTick(ServerChunkLoadingManager instance, BooleanSupplier shouldKeepTicking) { 15 | return false; 16 | } 17 | 18 | } 19 | -------------------------------------------------------------------------------- /c2me-opts-scheduling/src/main/java/com/ishland/c2me/opts/scheduling/mixin/idle_tasks/package-info.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.opts.scheduling.mixin.idle_tasks; -------------------------------------------------------------------------------- /c2me-opts-scheduling/src/main/java/com/ishland/c2me/opts/scheduling/mixin/mid_tick_chunk_tasks/MixinServerWorld.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.opts.scheduling.mixin.mid_tick_chunk_tasks; 2 | 3 | import com.ishland.c2me.opts.scheduling.common.ServerMidTickTask; 4 | import net.minecraft.server.MinecraftServer; 5 | import net.minecraft.server.world.ServerWorld; 6 | import org.spongepowered.asm.mixin.Final; 7 | import org.spongepowered.asm.mixin.Mixin; 8 | import org.spongepowered.asm.mixin.Shadow; 9 | import org.spongepowered.asm.mixin.injection.At; 10 | import org.spongepowered.asm.mixin.injection.Inject; 11 | import org.spongepowered.asm.mixin.injection.callback.CallbackInfo; 12 | 13 | @Mixin(ServerWorld.class) 14 | public class MixinServerWorld { 15 | 16 | @Shadow @Final private MinecraftServer server; 17 | 18 | @Inject(method = {"tickBlock", "tickFluid"}, at = @At("RETURN"), require = 2) 19 | private void onPostTickBlockAndFluid(CallbackInfo info) { 20 | ((ServerMidTickTask) this.server).executeTasksMidTick((ServerWorld) (Object) this); 21 | } 22 | 23 | } 24 | -------------------------------------------------------------------------------- /c2me-opts-scheduling/src/main/java/com/ishland/c2me/opts/scheduling/mixin/ordering/package-info.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.opts.scheduling.mixin.ordering; -------------------------------------------------------------------------------- /c2me-opts-scheduling/src/main/java/com/ishland/c2me/opts/scheduling/mixin/shutdown/MixinMinecraftServer.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.opts.scheduling.mixin.shutdown; 2 | 3 | import net.minecraft.server.MinecraftServer; 4 | import net.minecraft.util.Util; 5 | import org.spongepowered.asm.mixin.Mixin; 6 | import org.spongepowered.asm.mixin.Shadow; 7 | import org.spongepowered.asm.mixin.injection.At; 8 | import org.spongepowered.asm.mixin.injection.Inject; 9 | import org.spongepowered.asm.mixin.injection.callback.CallbackInfo; 10 | 11 | @Mixin(MinecraftServer.class) 12 | public class MixinMinecraftServer { 13 | 14 | @Shadow 15 | private long tickStartTimeNanos; 16 | 17 | @Shadow private long tickEndTimeNanos; 18 | 19 | @Inject(method = "shutdown", at = @At(value = "INVOKE", target = "Lnet/minecraft/server/MinecraftServer;runTasksTillTickEnd()V", shift = At.Shift.BEFORE)) 20 | private void shutdownBeforeRunTasks(CallbackInfo ci) { 21 | this.tickEndTimeNanos = this.tickStartTimeNanos = Util.getMeasuringTimeNano() + 50_000_000L; // 50ms 22 | } 23 | 24 | } 25 | -------------------------------------------------------------------------------- /c2me-opts-scheduling/src/main/java/com/ishland/c2me/opts/scheduling/package-info.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.opts.scheduling; -------------------------------------------------------------------------------- /c2me-opts-scheduling/src/main/resources/c2me-opts-scheduling.mixins.json: -------------------------------------------------------------------------------- 1 | { 2 | "parent": "c2me.mixins.json", 3 | "required": true, 4 | "package": "com.ishland.c2me.opts.scheduling.mixin", 5 | "plugin": "com.ishland.c2me.opts.scheduling.mixin.MixinPlugin", 6 | "mixins": [ 7 | "general_overheads.MixinThreadedAnvilChunkStorage", 8 | "idle_tasks.autosave.disable_vanilla_mid_tick_autosave.MixinThreadedAnvilChunkStorage", 9 | "idle_tasks.autosave.enhanced_autosave.MixinMinecraftServer", 10 | "idle_tasks.autosave.enhanced_autosave.MixinThreadedAnvilChunkStorage", 11 | "mid_tick_chunk_tasks.MixinMinecraftServer", 12 | "mid_tick_chunk_tasks.MixinServerChunkManager", 13 | "mid_tick_chunk_tasks.MixinServerWorld", 14 | "mid_tick_chunk_tasks.MixinWorld", 15 | "ordering.player_move.MixinServerPlayNetworkHandler", 16 | "shutdown.MixinMinecraftServer", 17 | "shutdown.MixinServerEntityManager", 18 | "shutdown.MixinServerWorld", 19 | "task_scheduling.MixinChunkHolder", 20 | "task_scheduling.MixinEntityChunkDataAccess", 21 | "task_scheduling.MixinServerChunkManager", 22 | ] 23 | } 24 | -------------------------------------------------------------------------------- /c2me-opts-scheduling/src/main/resources/fabric.mod.json: -------------------------------------------------------------------------------- 1 | { 2 | "schemaVersion": 1, 3 | "id": "c2me-opts-scheduling", 4 | "version": "${version}", 5 | "name": "Concurrent Chunk Management Engine (Optimizations/Scheduling)", 6 | "description": "Chunk scheduling optimizations", 7 | "environment": "*", 8 | "mixins": [ 9 | "c2me-opts-scheduling.mixins.json" 10 | ], 11 | "depends": { 12 | "minecraft": "*", 13 | "fabricloader": "*", 14 | "c2me-base": "*" 15 | }, 16 | 17 | "authors": [ 18 | "RelativityMC", 19 | "ishland" 20 | ], 21 | "contact": { 22 | "sources": "https://github.com/RelativityMC/C2ME-fabric", 23 | "issues": "https://github.com/RelativityMC/C2ME-fabric/issues", 24 | "discord": "https://discord.gg/Kdy8NM5HW4", 25 | "homepage": "https://modrinth.com/mod/c2me-fabric" 26 | }, 27 | "license": "MIT", 28 | "custom": { 29 | "modmenu": { 30 | "parent": "c2me" 31 | } 32 | } 33 | } 34 | -------------------------------------------------------------------------------- /c2me-opts-worldgen-biome-cache/build.gradle: -------------------------------------------------------------------------------- 1 | moduleDependencies(project, [ 2 | "c2me-base", 3 | ]) 4 | 5 | -------------------------------------------------------------------------------- /c2me-opts-worldgen-general/build.gradle: -------------------------------------------------------------------------------- 1 | moduleDependencies(project, [ 2 | "c2me-base", 3 | ]) 4 | 5 | -------------------------------------------------------------------------------- /c2me-opts-worldgen-general/src/main/java/com/ishland/c2me/opts/worldgen/general/ModuleEntryPoint.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.opts.worldgen.general; 2 | 3 | public class ModuleEntryPoint { 4 | 5 | private static final boolean enabled = true; 6 | 7 | } 8 | -------------------------------------------------------------------------------- /c2me-opts-worldgen-general/src/main/java/com/ishland/c2me/opts/worldgen/general/mixin/random_instances/MixinRedirectAtomicSimpleRandomStatic.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.opts.worldgen.general.mixin.random_instances; 2 | 3 | import com.ishland.c2me.opts.worldgen.general.common.random_instances.SimplifiedAtomicSimpleRandom; 4 | import net.minecraft.util.math.random.CheckedRandom; 5 | import net.minecraft.world.gen.chunk.placement.StructurePlacement; 6 | import org.spongepowered.asm.mixin.Mixin; 7 | import org.spongepowered.asm.mixin.injection.At; 8 | import org.spongepowered.asm.mixin.injection.Redirect; 9 | 10 | @Mixin(value = { 11 | StructurePlacement.class, 12 | }) 13 | public class MixinRedirectAtomicSimpleRandomStatic { 14 | 15 | @Redirect(method = "*", at = @At(value = "NEW", target = "net/minecraft/util/math/random/CheckedRandom")) 16 | private static CheckedRandom redirectAtomicSimpleRandom(long l) { 17 | return new SimplifiedAtomicSimpleRandom(l); 18 | } 19 | 20 | } 21 | -------------------------------------------------------------------------------- /c2me-opts-worldgen-general/src/main/java/com/ishland/c2me/opts/worldgen/general/package-info.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.opts.worldgen.general; -------------------------------------------------------------------------------- /c2me-opts-worldgen-general/src/main/resources/c2me-opts-worldgen-general.mixins.json: -------------------------------------------------------------------------------- 1 | { 2 | "parent": "c2me.mixins.json", 3 | "required": true, 4 | "package": "com.ishland.c2me.opts.worldgen.general.mixin", 5 | "plugin": "com.ishland.c2me.base.common.ModuleMixinPlugin", 6 | "mixins": [ 7 | "random_instances.MixinAtomicSimpleRandomFactory", 8 | "random_instances.MixinRedirectAtomicSimpleRandom", 9 | "random_instances.MixinRedirectAtomicSimpleRandomStatic" 10 | ] 11 | } 12 | -------------------------------------------------------------------------------- /c2me-opts-worldgen-general/src/main/resources/fabric.mod.json: -------------------------------------------------------------------------------- 1 | { 2 | "schemaVersion": 1, 3 | "id": "c2me-opts-worldgen-general", 4 | "version": "${version}", 5 | "name": "Concurrent Chunk Management Engine (Optimizations/General WorldGen)", 6 | "description": "Optimizations for general world generation performance", 7 | "environment": "*", 8 | "mixins": [ 9 | "c2me-opts-worldgen-general.mixins.json" 10 | ], 11 | "depends": { 12 | "minecraft": "*", 13 | "fabricloader": "*", 14 | "c2me-base": "*" 15 | }, 16 | 17 | "authors": [ 18 | "RelativityMC", 19 | "ishland" 20 | ], 21 | "contact": { 22 | "sources": "https://github.com/RelativityMC/C2ME-fabric", 23 | "issues": "https://github.com/RelativityMC/C2ME-fabric/issues", 24 | "discord": "https://discord.gg/Kdy8NM5HW4", 25 | "homepage": "https://modrinth.com/mod/c2me-fabric" 26 | }, 27 | "license": "MIT", 28 | "custom": { 29 | "modmenu": { 30 | "parent": "c2me" 31 | } 32 | } 33 | } 34 | -------------------------------------------------------------------------------- /c2me-opts-worldgen-vanilla/build.gradle: -------------------------------------------------------------------------------- 1 | moduleDependencies(project, [ 2 | "c2me-base", 3 | "c2me-opts-worldgen-general", 4 | ]) 5 | 6 | -------------------------------------------------------------------------------- /c2me-opts-worldgen-vanilla/src/main/java/com/ishland/c2me/opts/worldgen/vanilla/MixinPlugin.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.opts.worldgen.vanilla; 2 | 3 | import com.ishland.c2me.base.common.ModuleMixinPlugin; 4 | import com.ishland.c2me.opts.worldgen.vanilla.common.Config; 5 | 6 | public class MixinPlugin extends ModuleMixinPlugin { 7 | 8 | @Override 9 | public boolean shouldApplyMixin(String targetClassName, String mixinClassName) { 10 | if (!super.shouldApplyMixin(targetClassName, mixinClassName)) return false; 11 | 12 | if (mixinClassName.startsWith("com.ishland.c2me.opts.worldgen.vanilla.mixin.aquifer.")) 13 | return Config.optimizeAquifer; 14 | 15 | if (mixinClassName.startsWith("com.ishland.c2me.opts.worldgen.vanilla.mixin.the_end_biome_cache.")) 16 | return Config.useEndBiomeCache; 17 | 18 | if (mixinClassName.startsWith("com.ishland.c2me.opts.worldgen.vanilla.mixin.structure_weight_sampler.")) 19 | return Config.optimizeStructureWeightSampler; 20 | 21 | return true; 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /c2me-opts-worldgen-vanilla/src/main/java/com/ishland/c2me/opts/worldgen/vanilla/ModuleEntryPoint.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.opts.worldgen.vanilla; 2 | 3 | public class ModuleEntryPoint { 4 | 5 | private static final boolean enabled = true; 6 | 7 | } 8 | -------------------------------------------------------------------------------- /c2me-opts-worldgen-vanilla/src/main/java/com/ishland/c2me/opts/worldgen/vanilla/package-info.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.opts.worldgen.vanilla; -------------------------------------------------------------------------------- /c2me-opts-worldgen-vanilla/src/main/resources/c2me-opts-worldgen-vanilla.mixins.json: -------------------------------------------------------------------------------- 1 | { 2 | "parent": "c2me.mixins.json", 3 | "required": true, 4 | "package": "com.ishland.c2me.opts.worldgen.vanilla.mixin", 5 | "plugin": "com.ishland.c2me.opts.worldgen.vanilla.MixinPlugin", 6 | "mixins": [ 7 | "aquifer.MixinAquiferSamplerImpl", 8 | "structure_weight_sampler.MixinStructureWeightSampler", 9 | "the_end_biome_cache.MixinTheEndBiomeSource", 10 | "tlcache.MixinBlock" 11 | ] 12 | } 13 | -------------------------------------------------------------------------------- /c2me-opts-worldgen-vanilla/src/main/resources/fabric.mod.json: -------------------------------------------------------------------------------- 1 | { 2 | "schemaVersion": 1, 3 | "id": "c2me-opts-worldgen-vanilla", 4 | "version": "${version}", 5 | "name": "Concurrent Chunk Management Engine (Optimizations/Vanilla WorldGen)", 6 | "description": "Optimizations targeting vanilla world generation", 7 | "environment": "*", 8 | "mixins": [ 9 | "c2me-opts-worldgen-vanilla.mixins.json" 10 | ], 11 | "depends": { 12 | "minecraft": "*", 13 | "fabricloader": "*", 14 | "c2me-base": "*", 15 | "c2me-opts-worldgen-general": "*" 16 | }, 17 | 18 | "authors": [ 19 | "RelativityMC", 20 | "ishland" 21 | ], 22 | "contact": { 23 | "sources": "https://github.com/RelativityMC/C2ME-fabric", 24 | "issues": "https://github.com/RelativityMC/C2ME-fabric/issues", 25 | "discord": "https://discord.gg/Kdy8NM5HW4", 26 | "homepage": "https://modrinth.com/mod/c2me-fabric" 27 | }, 28 | "license": "MIT", 29 | "custom": { 30 | "modmenu": { 31 | "parent": "c2me" 32 | } 33 | } 34 | } 35 | -------------------------------------------------------------------------------- /c2me-rewrites-chunk-serializer/build.gradle: -------------------------------------------------------------------------------- 1 | moduleDependencies(project, [ 2 | "c2me-base", 3 | ]) 4 | -------------------------------------------------------------------------------- /c2me-rewrites-chunk-serializer/src/main/java/com/ishland/c2me/rewrites/chunk_serializer/ModuleEntryPoint.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.rewrites.chunk_serializer; 2 | 3 | import com.ishland.c2me.base.common.config.ConfigSystem; 4 | 5 | public final class ModuleEntryPoint { 6 | 7 | @SuppressWarnings("unused") 8 | public static final boolean enabled = new ConfigSystem.ConfigAccessor() 9 | .key("ioSystem.gcFreeChunkSerializer") 10 | .comment(""" 11 | EXPERIMENTAL FEATURE 12 | This replaces the way your chunks are saved. 13 | Please keep regular backups of your world if you are using this feature, 14 | and report any world issues you encounter with this feature to our GitHub. 15 | 16 | Whether to use the fast reduced allocation chunk serializer 17 | (may cause incompatibility with other mods) 18 | """) 19 | .incompatibleMod("architectury", "*") 20 | .getBoolean(false, false); 21 | 22 | } 23 | -------------------------------------------------------------------------------- /c2me-rewrites-chunk-serializer/src/main/java/com/ishland/c2me/rewrites/chunk_serializer/TheMod.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.rewrites.chunk_serializer; 2 | 3 | import com.ibm.asyncutil.util.Either; 4 | import com.ishland.c2me.base.common.registry.SerializerAccess; 5 | import com.ishland.c2me.rewrites.chunk_serializer.common.ChunkDataSerializer; 6 | import com.ishland.c2me.rewrites.chunk_serializer.common.NbtWriter; 7 | import net.minecraft.nbt.NbtElement; 8 | 9 | public class TheMod implements net.fabricmc.api.ModInitializer { 10 | @Override 11 | public void onInitialize() { 12 | if (ModuleEntryPoint.enabled) { 13 | SerializerAccess.registerSerializer(serializable -> { 14 | NbtWriter nbtWriter = new NbtWriter(); 15 | nbtWriter.start(NbtElement.COMPOUND_TYPE); 16 | ChunkDataSerializer.write(serializable, nbtWriter); 17 | nbtWriter.finishCompound(); 18 | final byte[] data = nbtWriter.toByteArray(); 19 | nbtWriter.release(); 20 | return Either.right(data); 21 | }); 22 | } 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /c2me-rewrites-chunk-serializer/src/main/java/com/ishland/c2me/rewrites/chunk_serializer/common/ChunkStatusAccessor.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.rewrites.chunk_serializer.common; 2 | 3 | public interface ChunkStatusAccessor { 4 | byte[] getIdBytes(); 5 | } -------------------------------------------------------------------------------- /c2me-rewrites-chunk-serializer/src/main/java/com/ishland/c2me/rewrites/chunk_serializer/common/HeightMapTypeAccessor.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.rewrites.chunk_serializer.common; 2 | 3 | public interface HeightMapTypeAccessor { 4 | byte[] getNameBytes(); 5 | } -------------------------------------------------------------------------------- /c2me-rewrites-chunk-serializer/src/main/java/com/ishland/c2me/rewrites/chunk_serializer/common/StructureFeatureAccessor.java: -------------------------------------------------------------------------------- 1 | //package com.ishland.c2me.opts.chunk_serializer.common; 2 | // 3 | //public interface StructureFeatureAccessor { 4 | // byte[] getNameBytes(); 5 | //} -------------------------------------------------------------------------------- /c2me-rewrites-chunk-serializer/src/main/java/com/ishland/c2me/rewrites/chunk_serializer/common/utils/AccessControllerUtils.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.rewrites.chunk_serializer.common.utils; 2 | 3 | import java.security.AccessController; 4 | import java.security.PrivilegedAction; 5 | 6 | public class AccessControllerUtils { 7 | public static T runWithAccessController(PrivilegedAction action) throws IllegalAccessException{ 8 | return AccessController.doPrivileged(action); 9 | } 10 | } -------------------------------------------------------------------------------- /c2me-rewrites-chunk-serializer/src/main/java/com/ishland/c2me/rewrites/chunk_serializer/common/utils/StringBytesConvertible.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.rewrites.chunk_serializer.common.utils; 2 | 3 | public interface StringBytesConvertible { 4 | byte[] getStringBytes(); 5 | } 6 | -------------------------------------------------------------------------------- /c2me-rewrites-chunk-serializer/src/main/java/com/ishland/c2me/rewrites/chunk_serializer/mixin/ChunkStatusMixin.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.rewrites.chunk_serializer.mixin; 2 | 3 | import com.ishland.c2me.rewrites.chunk_serializer.common.ChunkStatusAccessor; 4 | import com.ishland.c2me.rewrites.chunk_serializer.common.NbtWriter; 5 | import net.minecraft.world.chunk.ChunkStatus; 6 | import org.spongepowered.asm.mixin.Mixin; 7 | import org.spongepowered.asm.mixin.Shadow; 8 | import org.spongepowered.asm.mixin.Unique; 9 | 10 | @Mixin(ChunkStatus.class) 11 | public abstract class ChunkStatusMixin implements ChunkStatusAccessor { 12 | @Shadow public abstract String toString(); 13 | 14 | @Unique 15 | private byte[] idBytes; 16 | 17 | @Override 18 | public byte[] getIdBytes() { 19 | return this.idBytes != null ? this.idBytes : (this.idBytes = NbtWriter.getStringBytes(this.toString())); 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /c2me-rewrites-chunk-serializer/src/main/java/com/ishland/c2me/rewrites/chunk_serializer/mixin/IStarlightSaveState.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.rewrites.chunk_serializer.mixin; 2 | 3 | import org.spongepowered.asm.mixin.Mixin; 4 | import org.spongepowered.asm.mixin.Pseudo; 5 | import org.spongepowered.asm.mixin.gen.Accessor; 6 | 7 | @Pseudo 8 | @Mixin(remap = false, targets = "ca.spottedleaf.starlight.common.light.SWMRNibbleArray$SaveState") 9 | public interface IStarlightSaveState { 10 | @Accessor(remap = false) 11 | byte[] getData(); 12 | 13 | @Accessor(remap = false) 14 | int getState(); 15 | } 16 | -------------------------------------------------------------------------------- /c2me-rewrites-chunk-serializer/src/main/java/com/ishland/c2me/rewrites/chunk_serializer/mixin/IdentifierMixin.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.rewrites.chunk_serializer.mixin; 2 | 3 | import com.ishland.c2me.rewrites.chunk_serializer.common.NbtWriter; 4 | import com.ishland.c2me.rewrites.chunk_serializer.common.utils.StringBytesConvertible; 5 | import net.minecraft.util.Identifier; 6 | import org.spongepowered.asm.mixin.Mixin; 7 | import org.spongepowered.asm.mixin.Unique; 8 | 9 | // TODO: make config option? 10 | @Mixin(Identifier.class) 11 | public class IdentifierMixin implements StringBytesConvertible { 12 | @Unique 13 | private byte[] serializedStringBytes; 14 | 15 | @Override 16 | public byte[] getStringBytes() { 17 | return this.serializedStringBytes != null ? this.serializedStringBytes : 18 | (this.serializedStringBytes = NbtWriter.getAsciiStringBytes(this.toString())); 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /c2me-rewrites-chunk-serializer/src/main/resources/c2me-rewrites-chunk-serializer.mixins.json: -------------------------------------------------------------------------------- 1 | { 2 | "parent": "c2me.mixins.json", 3 | "required": true, 4 | "package": "com.ishland.c2me.rewrites.chunk_serializer.mixin", 5 | "plugin": "com.ishland.c2me.base.common.ModuleMixinPlugin", 6 | "mixins": [ 7 | "ChunkStatusMixin", 8 | "HeightMapTypeMixin", 9 | "IdentifierMixin", 10 | "IStarlightSaveState", 11 | "MixinThreadedAnvilChunkStorage" 12 | ] 13 | } 14 | -------------------------------------------------------------------------------- /c2me-rewrites-chunk-serializer/src/main/resources/fabric.mod.json: -------------------------------------------------------------------------------- 1 | { 2 | "schemaVersion": 1, 3 | "id": "c2me-rewrites-chunk-serializer", 4 | "version": "${version}", 5 | "name": "Concurrent Chunk Management Engine (Rewrites/Chunk Serializer)", 6 | "description": "Optimizations related to chunk serialization", 7 | "environment": "*", 8 | "mixins": [ 9 | "c2me-rewrites-chunk-serializer.mixins.json" 10 | ], 11 | "entrypoints": { 12 | "main": [ 13 | "com.ishland.c2me.rewrites.chunk_serializer.TheMod" 14 | ] 15 | }, 16 | "depends": { 17 | "minecraft": "*", 18 | "fabricloader": "*", 19 | "c2me-base": "*" 20 | }, 21 | 22 | "authors": [ 23 | "RelativityMC", 24 | "Kroppeb" 25 | ], 26 | "contact": { 27 | "sources": "https://github.com/RelativityMC/C2ME-fabric", 28 | "issues": "https://github.com/RelativityMC/C2ME-fabric/issues", 29 | "discord": "https://discord.gg/Kdy8NM5HW4", 30 | "homepage": "https://modrinth.com/mod/c2me-fabric" 31 | }, 32 | "license": "MIT", 33 | "custom": { 34 | "modmenu": { 35 | "parent": "c2me" 36 | } 37 | } 38 | } 39 | -------------------------------------------------------------------------------- /c2me-rewrites-chunk-serializer/src/test/java/com/ishland/c2me/rewrites/chunk_serializer/package-info.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.rewrites.chunk_serializer; -------------------------------------------------------------------------------- /c2me-rewrites-chunk-system/build.gradle: -------------------------------------------------------------------------------- 1 | moduleDependencies(project, [ 2 | "c2me-base", 3 | ]) 4 | 5 | -------------------------------------------------------------------------------- /c2me-rewrites-chunk-system/src/main/java/com/ishland/c2me/rewrites/chunksystem/ModuleEntryPoint.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.rewrites.chunksystem; 2 | 3 | import com.ishland.c2me.rewrites.chunksystem.common.Config; 4 | 5 | public class ModuleEntryPoint { 6 | 7 | private static final boolean enabled = true; 8 | 9 | static { 10 | Config.init(); 11 | } 12 | 13 | } 14 | -------------------------------------------------------------------------------- /c2me-rewrites-chunk-system/src/main/java/com/ishland/c2me/rewrites/chunksystem/common/ChunkLoadingContext.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.rewrites.chunksystem.common; 2 | 3 | import com.ishland.c2me.base.common.scheduler.SchedulingManager; 4 | import com.ishland.flowsched.scheduler.ItemHolder; 5 | import com.ishland.flowsched.scheduler.KeyStatusPair; 6 | import net.minecraft.server.world.ServerChunkLoadingManager; 7 | import net.minecraft.util.collection.BoundedRegionArray; 8 | import net.minecraft.util.math.ChunkPos; 9 | import net.minecraft.world.chunk.AbstractChunkHolder; 10 | 11 | public record ChunkLoadingContext( 12 | ItemHolder holder, 13 | ServerChunkLoadingManager tacs, SchedulingManager schedulingManager, 14 | BoundedRegionArray chunks, 15 | KeyStatusPair[] dependencies) { 16 | } 17 | -------------------------------------------------------------------------------- /c2me-rewrites-chunk-system/src/main/java/com/ishland/c2me/rewrites/chunksystem/common/ChunkState.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.rewrites.chunksystem.common; 2 | 3 | import net.minecraft.world.chunk.Chunk; 4 | import net.minecraft.world.chunk.ChunkStatus; 5 | import net.minecraft.world.chunk.ProtoChunk; 6 | 7 | public record ChunkState(Chunk chunk, ProtoChunk protoChunk, ChunkStatus reachedStatus) { 8 | } 9 | -------------------------------------------------------------------------------- /c2me-rewrites-chunk-system/src/main/java/com/ishland/c2me/rewrites/chunksystem/common/TicketTypeExtension.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.rewrites.chunksystem.common; 2 | 3 | import com.ishland.flowsched.scheduler.ItemTicket; 4 | 5 | public class TicketTypeExtension { 6 | 7 | /** 8 | * Ticket type for vanilla level loading 9 | */ 10 | public static final ItemTicket.TicketType VANILLA_LEVEL = new ItemTicket.TicketType("c2me:vanilla_level"); 11 | /** 12 | * Ticket type for vanilla deferred level loading 13 | */ 14 | public static final ItemTicket.TicketType VANILLA_DEFERRED_LOAD = new ItemTicket.TicketType("c2me:vanilla_deferred_load"); 15 | /** 16 | * Ticket type for on-demand load off-thread 17 | */ 18 | public static final ItemTicket.TicketType ONDEMAND_LOAD = new ItemTicket.TicketType("c2me:ondemand_load"); 19 | 20 | private TicketTypeExtension() { 21 | } 22 | 23 | } 24 | -------------------------------------------------------------------------------- /c2me-rewrites-chunk-system/src/main/java/com/ishland/c2me/rewrites/chunksystem/common/async_chunkio/ChunkIoThreadingExecutorUtils.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.rewrites.chunksystem.common.async_chunkio; 2 | 3 | import com.google.common.util.concurrent.ThreadFactoryBuilder; 4 | 5 | import java.util.concurrent.ThreadFactory; 6 | 7 | public class ChunkIoThreadingExecutorUtils { 8 | 9 | public static final ThreadFactory ioWorkerFactory = new ThreadFactoryBuilder().setDaemon(true).setNameFormat("IOWorker-%d").setPriority(Thread.NORM_PRIORITY - 1).build(); 10 | 11 | } 12 | -------------------------------------------------------------------------------- /c2me-rewrites-chunk-system/src/main/java/com/ishland/c2me/rewrites/chunksystem/common/async_chunkio/ProtoChunkExtension.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.rewrites.chunksystem.common.async_chunkio; 2 | 3 | import net.minecraft.util.math.ChunkPos; 4 | 5 | import java.util.BitSet; 6 | import java.util.List; 7 | import java.util.concurrent.CompletableFuture; 8 | 9 | public interface ProtoChunkExtension { 10 | 11 | void setBlendingComputeFuture(CompletableFuture future); 12 | 13 | void setBlendingInfo(ChunkPos pos, List bitSet); 14 | 15 | boolean getNeedBlending(); 16 | 17 | void setInitialMainThreadComputeFuture(CompletableFuture future); 18 | CompletableFuture getInitialMainThreadComputeFuture(); 19 | 20 | } 21 | -------------------------------------------------------------------------------- /c2me-rewrites-chunk-system/src/main/java/com/ishland/c2me/rewrites/chunksystem/common/async_chunkio/TaskCancellationException.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.rewrites.chunksystem.common.async_chunkio; 2 | 3 | public class TaskCancellationException extends RuntimeException { 4 | 5 | public TaskCancellationException() { 6 | super(); 7 | } 8 | 9 | public TaskCancellationException(String message) { 10 | super(message); 11 | } 12 | 13 | public TaskCancellationException(String message, Throwable cause) { 14 | super(message, cause); 15 | } 16 | 17 | public TaskCancellationException(Throwable cause) { 18 | super(cause); 19 | } 20 | 21 | protected TaskCancellationException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) { 22 | super(message, cause, enableSuppression, writableStackTrace); 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /c2me-rewrites-chunk-system/src/main/java/com/ishland/c2me/rewrites/chunksystem/common/compat/package-info.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.rewrites.chunksystem.common.compat; -------------------------------------------------------------------------------- /c2me-rewrites-chunk-system/src/main/java/com/ishland/c2me/rewrites/chunksystem/common/ducks/IChunkSystemAccess.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.rewrites.chunksystem.common.ducks; 2 | 3 | import com.ishland.c2me.rewrites.chunksystem.common.TheChunkSystem; 4 | 5 | public interface IChunkSystemAccess { 6 | 7 | TheChunkSystem c2me$getTheChunkSystem(); 8 | 9 | } 10 | -------------------------------------------------------------------------------- /c2me-rewrites-chunk-system/src/main/java/com/ishland/c2me/rewrites/chunksystem/common/ducks/IPOIUnloading.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.rewrites.chunksystem.common.ducks; 2 | 3 | import net.minecraft.util.math.ChunkPos; 4 | 5 | public interface IPOIUnloading { 6 | 7 | void c2me$unloadPoi(ChunkPos pos); 8 | 9 | default boolean c2me$shouldUnloadPoi(ChunkPos pos) { 10 | return false; 11 | } 12 | 13 | } 14 | -------------------------------------------------------------------------------- /c2me-rewrites-chunk-system/src/main/java/com/ishland/c2me/rewrites/chunksystem/common/ducks/WorldChunkExtension.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.rewrites.chunksystem.common.ducks; 2 | 3 | public interface WorldChunkExtension { 4 | 5 | boolean c2me$isBlockTicking(); 6 | 7 | void c2me$setBlockTicking(boolean blockTicking); 8 | 9 | } 10 | -------------------------------------------------------------------------------- /c2me-rewrites-chunk-system/src/main/java/com/ishland/c2me/rewrites/chunksystem/mixin/MixinChunkGenerator.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.rewrites.chunksystem.mixin; 2 | 3 | import com.ishland.c2me.base.common.util.InvokingExecutorService; 4 | import net.minecraft.world.gen.chunk.ChunkGenerator; 5 | import org.spongepowered.asm.mixin.Mixin; 6 | import org.spongepowered.asm.mixin.injection.At; 7 | import org.spongepowered.asm.mixin.injection.ModifyArg; 8 | import org.spongepowered.asm.mixin.injection.Redirect; 9 | 10 | import java.util.concurrent.Executor; 11 | import java.util.concurrent.ExecutorService; 12 | 13 | @Mixin(ChunkGenerator.class) 14 | public class MixinChunkGenerator { 15 | 16 | @ModifyArg(method = "populateBiomes", at = @At(value = "INVOKE", target = "Ljava/util/concurrent/CompletableFuture;supplyAsync(Ljava/util/function/Supplier;Ljava/util/concurrent/Executor;)Ljava/util/concurrent/CompletableFuture;")) 17 | private Executor redirectBiomeExecutor(Executor executor) { 18 | return Runnable::run; 19 | } 20 | 21 | } 22 | -------------------------------------------------------------------------------- /c2me-rewrites-chunk-system/src/main/java/com/ishland/c2me/rewrites/chunksystem/mixin/MixinPointOfInterestStorage.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.rewrites.chunksystem.mixin; 2 | 3 | import com.ishland.c2me.rewrites.chunksystem.common.ducks.IPOIUnloading; 4 | import it.unimi.dsi.fastutil.longs.LongSet; 5 | import net.minecraft.util.math.ChunkPos; 6 | import net.minecraft.world.poi.PointOfInterestStorage; 7 | import org.spongepowered.asm.mixin.Final; 8 | import org.spongepowered.asm.mixin.Mixin; 9 | import org.spongepowered.asm.mixin.Shadow; 10 | 11 | @Mixin(PointOfInterestStorage.class) 12 | public abstract class MixinPointOfInterestStorage implements IPOIUnloading { 13 | 14 | @Shadow @Final private LongSet preloadedChunks; 15 | 16 | @Override 17 | public boolean c2me$shouldUnloadPoi(ChunkPos pos) { 18 | return !this.preloadedChunks.contains(pos.toLong()); 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /c2me-rewrites-chunk-system/src/main/java/com/ishland/c2me/rewrites/chunksystem/mixin/async_serialization/MixinBlender.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.rewrites.chunksystem.mixin.async_serialization; 2 | 3 | import com.ishland.c2me.rewrites.chunksystem.common.async_chunkio.ProtoChunkExtension; 4 | import net.minecraft.util.math.ChunkPos; 5 | import net.minecraft.world.ChunkRegion; 6 | import net.minecraft.world.gen.chunk.Blender; 7 | import org.spongepowered.asm.mixin.Mixin; 8 | import org.spongepowered.asm.mixin.injection.At; 9 | import org.spongepowered.asm.mixin.injection.Redirect; 10 | 11 | @Mixin(Blender.class) 12 | public class MixinBlender { 13 | 14 | @Redirect(method = "getBlender", at = @At(value = "INVOKE", target = "Lnet/minecraft/world/ChunkRegion;needsBlending(Lnet/minecraft/util/math/ChunkPos;I)Z")) 15 | private static boolean redirectNeedsBlending(ChunkRegion instance, ChunkPos chunkPos, int checkRadius) { 16 | return ((ProtoChunkExtension) instance.getChunk(chunkPos.x, chunkPos.z)).getNeedBlending(); 17 | } 18 | 19 | } 20 | -------------------------------------------------------------------------------- /c2me-rewrites-chunk-system/src/main/java/com/ishland/c2me/rewrites/chunksystem/mixin/fluid_postprocessing/MixinWorldChunk.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.rewrites.chunksystem.mixin.fluid_postprocessing; 2 | 3 | import net.minecraft.block.BlockState; 4 | import net.minecraft.fluid.FluidState; 5 | import net.minecraft.server.world.ServerWorld; 6 | import net.minecraft.util.math.BlockPos; 7 | import net.minecraft.world.chunk.WorldChunk; 8 | import org.spongepowered.asm.mixin.Mixin; 9 | import org.spongepowered.asm.mixin.injection.At; 10 | import org.spongepowered.asm.mixin.injection.Redirect; 11 | 12 | @Mixin(WorldChunk.class) 13 | public class MixinWorldChunk { 14 | 15 | @Redirect(method = "runPostProcessing", at = @At(value = "INVOKE", target = "Lnet/minecraft/fluid/FluidState;onScheduledTick(Lnet/minecraft/server/world/ServerWorld;Lnet/minecraft/util/math/BlockPos;Lnet/minecraft/block/BlockState;)V")) 16 | private void redirectFluidScheduledTick(FluidState instance, ServerWorld world, BlockPos pos, BlockState state) { 17 | world.scheduleFluidTick(pos, instance.getFluid(), 1); 18 | } 19 | 20 | } 21 | -------------------------------------------------------------------------------- /c2me-rewrites-chunk-system/src/main/resources/c2me-rewrites-chunk-system.mixins.json: -------------------------------------------------------------------------------- 1 | { 2 | "parent": "c2me.mixins.json", 3 | "required": true, 4 | "package": "com.ishland.c2me.rewrites.chunksystem.mixin", 5 | "plugin": "com.ishland.c2me.rewrites.chunksystem.MixinPlugin", 6 | "mixins": [ 7 | "MixinChunkGenerator", 8 | "MixinChunkHolder", 9 | "MixinChunkLevelManager", 10 | "MixinChunkTicketManagerTicketDistanceLevelPropagator", 11 | "MixinMinecraftServer", 12 | "MixinNoiseChunkGenerator", 13 | "MixinPointOfInterestStorage", 14 | "MixinSerializingRegionBasedStorage", 15 | "MixinServerChunkManager", 16 | "MixinThreadedAnvilChunkStorage", 17 | "MixinWorldChunk", 18 | "async_serialization.MixinBlender", 19 | "async_serialization.MixinChunkRegion", 20 | "async_serialization.MixinChunkSerializer", 21 | "async_serialization.MixinProtoChunk", 22 | "async_serialization.MixinStorageIoWorker", 23 | "async_serialization.MixinThreadedAnvilChunkStorage", 24 | "fixes.MixinServerEntityManager", 25 | "fluid_postprocessing.MixinWorldChunk" 26 | ] 27 | } 28 | -------------------------------------------------------------------------------- /c2me-rewrites-chunk-system/src/main/resources/fabric.mod.json: -------------------------------------------------------------------------------- 1 | { 2 | "schemaVersion": 1, 3 | "id": "c2me-rewrites-chunk-system", 4 | "version": "${version}", 5 | "name": "Concurrent Chunk Management Engine (Rewrites/Chunk System)", 6 | "description": "An alternative chunk system", 7 | "environment": "*", 8 | "mixins": [ 9 | "c2me-rewrites-chunk-system.mixins.json" 10 | ], 11 | "depends": { 12 | "minecraft": "*", 13 | "fabricloader": "*", 14 | "c2me-base": "*" 15 | }, 16 | 17 | "authors": [ 18 | "RelativityMC", 19 | "ishland" 20 | ], 21 | "contact": { 22 | "sources": "https://github.com/RelativityMC/C2ME-fabric", 23 | "issues": "https://github.com/RelativityMC/C2ME-fabric/issues", 24 | "discord": "https://discord.gg/Kdy8NM5HW4", 25 | "homepage": "https://modrinth.com/mod/c2me-fabric" 26 | }, 27 | "license": "MIT", 28 | "custom": { 29 | "modmenu": { 30 | "parent": "c2me" 31 | } 32 | } 33 | } 34 | -------------------------------------------------------------------------------- /c2me-rewrites-chunkio/build.gradle: -------------------------------------------------------------------------------- 1 | moduleDependencies(project, [ 2 | "c2me-base", 3 | "c2me-opts-chunkio", 4 | ]) 5 | 6 | -------------------------------------------------------------------------------- /c2me-rewrites-chunkio/src/main/java/com/ishland/c2me/rewrites/chunkio/ModuleEntryPoint.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.rewrites.chunkio; 2 | 3 | import com.ishland.c2me.base.common.config.ConfigSystem; 4 | 5 | public class ModuleEntryPoint { 6 | 7 | private static final boolean enabled = new ConfigSystem.ConfigAccessor() 8 | .key("ioSystem.replaceImpl") 9 | .comment("Whether to use the optimized implementation of IO system") 10 | .getBoolean(true, false); 11 | 12 | } 13 | -------------------------------------------------------------------------------- /c2me-rewrites-chunkio/src/main/java/com/ishland/c2me/rewrites/chunkio/mixin/MixinChunkPosKeyedStorage.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.rewrites.chunkio.mixin; 2 | 3 | import com.ishland.c2me.rewrites.chunkio.common.C2MEStorageVanillaInterface; 4 | import net.minecraft.world.storage.ChunkPosKeyedStorage; 5 | import net.minecraft.world.storage.StorageIoWorker; 6 | import net.minecraft.world.storage.StorageKey; 7 | import org.spongepowered.asm.mixin.Mixin; 8 | import org.spongepowered.asm.mixin.injection.At; 9 | import org.spongepowered.asm.mixin.injection.Redirect; 10 | 11 | import java.nio.file.Path; 12 | 13 | @Mixin(ChunkPosKeyedStorage.class) 14 | public class MixinChunkPosKeyedStorage { 15 | 16 | @Redirect(method = "", at = @At(value = "NEW", target = "(Lnet/minecraft/world/storage/StorageKey;Ljava/nio/file/Path;Z)Lnet/minecraft/world/storage/StorageIoWorker;")) 17 | private StorageIoWorker redirectStorageIoWorker(StorageKey arg, Path path, boolean bl) { 18 | return new C2MEStorageVanillaInterface(arg, path, bl, null); 19 | } 20 | 21 | } 22 | -------------------------------------------------------------------------------- /c2me-rewrites-chunkio/src/main/java/com/ishland/c2me/rewrites/chunkio/mixin/MixinRecreatedChunkStorage.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.rewrites.chunkio.mixin; 2 | 3 | import com.ishland.c2me.rewrites.chunkio.common.C2MEStorageVanillaInterface; 4 | import net.minecraft.world.storage.RecreatedChunkStorage; 5 | import net.minecraft.world.storage.StorageIoWorker; 6 | import net.minecraft.world.storage.StorageKey; 7 | import org.spongepowered.asm.mixin.Mixin; 8 | import org.spongepowered.asm.mixin.injection.At; 9 | import org.spongepowered.asm.mixin.injection.Redirect; 10 | 11 | import java.nio.file.Path; 12 | 13 | @Mixin(RecreatedChunkStorage.class) 14 | public class MixinRecreatedChunkStorage { 15 | 16 | @Redirect(method = "", at = @At(value = "NEW", target = "(Lnet/minecraft/world/storage/StorageKey;Ljava/nio/file/Path;Z)Lnet/minecraft/world/storage/StorageIoWorker;")) 17 | private StorageIoWorker redirectStorageIoWorker(StorageKey arg, Path path, boolean bl) { 18 | return new C2MEStorageVanillaInterface(arg, path, bl, null); 19 | } 20 | 21 | } 22 | -------------------------------------------------------------------------------- /c2me-rewrites-chunkio/src/main/java/com/ishland/c2me/rewrites/chunkio/mixin/MixinRecreationStorage.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.rewrites.chunkio.mixin; 2 | 3 | import com.ishland.c2me.rewrites.chunkio.common.C2MEStorageVanillaInterface; 4 | import net.minecraft.world.storage.RecreationStorage; 5 | import net.minecraft.world.storage.StorageIoWorker; 6 | import net.minecraft.world.storage.StorageKey; 7 | import org.spongepowered.asm.mixin.Mixin; 8 | import org.spongepowered.asm.mixin.injection.At; 9 | import org.spongepowered.asm.mixin.injection.Redirect; 10 | 11 | import java.nio.file.Path; 12 | 13 | @Mixin(RecreationStorage.class) 14 | public class MixinRecreationStorage { 15 | 16 | @Redirect(method = "", at = @At(value = "NEW", target = "(Lnet/minecraft/world/storage/StorageKey;Ljava/nio/file/Path;Z)Lnet/minecraft/world/storage/StorageIoWorker;")) 17 | private StorageIoWorker redirectStorageIoWorker(StorageKey arg, Path path, boolean bl) { 18 | return new C2MEStorageVanillaInterface(arg, path, bl, null); 19 | } 20 | 21 | } 22 | -------------------------------------------------------------------------------- /c2me-rewrites-chunkio/src/main/java/com/ishland/c2me/rewrites/chunkio/package-info.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.rewrites.chunkio; -------------------------------------------------------------------------------- /c2me-rewrites-chunkio/src/main/resources/c2me-rewrites-chunkio.mixins.json: -------------------------------------------------------------------------------- 1 | { 2 | "parent": "c2me.mixins.json", 3 | "required": true, 4 | "package": "com.ishland.c2me.rewrites.chunkio.mixin", 5 | "plugin": "com.ishland.c2me.base.common.ModuleMixinPlugin", 6 | "mixins": [ 7 | "MixinChunkPosKeyedStorage", 8 | "MixinRecreatedChunkStorage", 9 | "MixinRecreationStorage", 10 | "MixinStorageIoWorker", 11 | "MixinVersionedChunkStorage" 12 | ] 13 | } 14 | -------------------------------------------------------------------------------- /c2me-rewrites-chunkio/src/main/resources/fabric.mod.json: -------------------------------------------------------------------------------- 1 | { 2 | "schemaVersion": 1, 3 | "id": "c2me-rewrites-chunkio", 4 | "version": "${version}", 5 | "name": "Concurrent Chunk Management Engine (Rewrites/Chunk IO)", 6 | "description": "An alternative chunk IO system focused on overall throughput", 7 | "environment": "*", 8 | "mixins": [ 9 | "c2me-rewrites-chunkio.mixins.json" 10 | ], 11 | "depends": { 12 | "minecraft": "*", 13 | "fabricloader": "*", 14 | "c2me-base": "*" 15 | }, 16 | 17 | "authors": [ 18 | "RelativityMC", 19 | "ishland" 20 | ], 21 | "contact": { 22 | "sources": "https://github.com/RelativityMC/C2ME-fabric", 23 | "issues": "https://github.com/RelativityMC/C2ME-fabric/issues", 24 | "discord": "https://discord.gg/Kdy8NM5HW4", 25 | "homepage": "https://modrinth.com/mod/c2me-fabric" 26 | }, 27 | "license": "MIT", 28 | "custom": { 29 | "modmenu": { 30 | "parent": "c2me" 31 | } 32 | } 33 | } 34 | -------------------------------------------------------------------------------- /c2me-server-utils/build.gradle: -------------------------------------------------------------------------------- 1 | moduleDependencies(project, [ 2 | "c2me-base", 3 | "c2me-notickvd", 4 | ]) 5 | 6 | -------------------------------------------------------------------------------- /c2me-server-utils/src/main/java/com/ishland/c2me/server/utils/ModuleEntryPoint.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.server.utils; 2 | 3 | public class ModuleEntryPoint { 4 | 5 | private static final boolean enabled = true; 6 | 7 | } 8 | -------------------------------------------------------------------------------- /c2me-server-utils/src/main/java/com/ishland/c2me/server/utils/mixin/MixinCommandManager.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.server.utils.mixin; 2 | 3 | import com.ishland.c2me.server.utils.common.C2MECommands; 4 | import com.mojang.brigadier.CommandDispatcher; 5 | import net.minecraft.server.command.CommandManager; 6 | import net.minecraft.server.command.ServerCommandSource; 7 | import org.spongepowered.asm.mixin.Final; 8 | import org.spongepowered.asm.mixin.Mixin; 9 | import org.spongepowered.asm.mixin.Shadow; 10 | import org.spongepowered.asm.mixin.injection.At; 11 | import org.spongepowered.asm.mixin.injection.Inject; 12 | import org.spongepowered.asm.mixin.injection.callback.CallbackInfo; 13 | 14 | @Mixin(CommandManager.class) 15 | public class MixinCommandManager { 16 | 17 | @Shadow @Final private CommandDispatcher dispatcher; 18 | 19 | @Inject(method = "", at = @At(value = "INVOKE", target = "Lcom/mojang/brigadier/CommandDispatcher;setConsumer(Lcom/mojang/brigadier/ResultConsumer;)V", remap = false, shift = At.Shift.BEFORE)) 20 | private void registerCommands(CallbackInfo ci) { 21 | C2MECommands.register(this.dispatcher); 22 | } 23 | 24 | } 25 | -------------------------------------------------------------------------------- /c2me-server-utils/src/main/java/com/ishland/c2me/server/utils/package-info.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.server.utils; -------------------------------------------------------------------------------- /c2me-server-utils/src/main/resources/c2me-server-utils.mixins.json: -------------------------------------------------------------------------------- 1 | { 2 | "parent": "c2me.mixins.json", 3 | "required": true, 4 | "package": "com.ishland.c2me.server.utils.mixin", 5 | "plugin": "com.ishland.c2me.base.common.ModuleMixinPlugin", 6 | "mixins": [ 7 | "MixinCommandManager" 8 | ] 9 | } 10 | -------------------------------------------------------------------------------- /c2me-server-utils/src/main/resources/fabric.mod.json: -------------------------------------------------------------------------------- 1 | { 2 | "schemaVersion": 1, 3 | "id": "c2me-server-utils", 4 | "version": "${version}", 5 | "name": "Concurrent Chunk Management Engine (Server Utils)", 6 | "description": "Some server-side utilities", 7 | "environment": "*", 8 | "mixins": [ 9 | "c2me-server-utils.mixins.json" 10 | ], 11 | "depends": { 12 | "minecraft": "*", 13 | "fabricloader": "*", 14 | "c2me-base": "*" 15 | }, 16 | 17 | "authors": [ 18 | "RelativityMC", 19 | "ishland" 20 | ], 21 | "contact": { 22 | "sources": "https://github.com/RelativityMC/C2ME-fabric", 23 | "issues": "https://github.com/RelativityMC/C2ME-fabric/issues", 24 | "discord": "https://discord.gg/Kdy8NM5HW4", 25 | "homepage": "https://modrinth.com/mod/c2me-fabric" 26 | }, 27 | "license": "MIT", 28 | "custom": { 29 | "modmenu": { 30 | "parent": "c2me" 31 | } 32 | } 33 | } 34 | -------------------------------------------------------------------------------- /c2me-threading-lighting/build.gradle: -------------------------------------------------------------------------------- 1 | moduleDependencies(project, [ 2 | "c2me-base", 3 | ]) 4 | 5 | -------------------------------------------------------------------------------- /c2me-threading-lighting/src/main/java/com/ishland/c2me/threading/lighting/ModuleEntryPoint.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.threading.lighting; 2 | 3 | import net.fabricmc.loader.api.FabricLoader; 4 | 5 | public class ModuleEntryPoint { 6 | 7 | private static final boolean enabled = !FabricLoader.getInstance().isModLoaded("lightbench"); 8 | 9 | } 10 | -------------------------------------------------------------------------------- /c2me-threading-lighting/src/main/java/com/ishland/c2me/threading/lighting/mixin/MixinServerLightingProvider.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.threading.lighting.mixin; 2 | 3 | import net.minecraft.server.world.ServerLightingProvider; 4 | import org.spongepowered.asm.mixin.Dynamic; 5 | import org.spongepowered.asm.mixin.Mixin; 6 | import org.spongepowered.asm.mixin.Shadow; 7 | import org.spongepowered.asm.mixin.injection.At; 8 | import org.spongepowered.asm.mixin.injection.Inject; 9 | import org.spongepowered.asm.mixin.injection.callback.CallbackInfo; 10 | 11 | @Mixin(ServerLightingProvider.class) 12 | public abstract class MixinServerLightingProvider { 13 | 14 | @Shadow public abstract void tick(); 15 | 16 | @Dynamic 17 | @Inject(method = "method_19505", at = @At("RETURN")) 18 | private void onPostRunTask(CallbackInfo info) { 19 | this.tick(); // Run more tasks 20 | } 21 | 22 | } 23 | -------------------------------------------------------------------------------- /c2me-threading-lighting/src/main/java/com/ishland/c2me/threading/lighting/package-info.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.threading.lighting; -------------------------------------------------------------------------------- /c2me-threading-lighting/src/main/resources/c2me-threading-lighting.mixins.json: -------------------------------------------------------------------------------- 1 | { 2 | "parent": "c2me.mixins.json", 3 | "required": true, 4 | "package": "com.ishland.c2me.threading.lighting.mixin", 5 | "plugin": "com.ishland.c2me.base.common.ModuleMixinPlugin", 6 | "mixins": [ 7 | "MixinServerLightingProvider", 8 | "MixinThreadedAnvilChunkStorage", 9 | "scalablelux.MixinSchedulingUtil" 10 | ] 11 | } 12 | -------------------------------------------------------------------------------- /c2me-threading-lighting/src/main/resources/fabric.mod.json: -------------------------------------------------------------------------------- 1 | { 2 | "schemaVersion": 1, 3 | "id": "c2me-threading-lighting", 4 | "version": "${version}", 5 | "name": "Concurrent Chunk Management Engine (Threading/Lighting)", 6 | "description": "Makes lighting onto its dedicated thread", 7 | "environment": "*", 8 | "mixins": [ 9 | "c2me-threading-lighting.mixins.json" 10 | ], 11 | "depends": { 12 | "minecraft": "*", 13 | "fabricloader": "*", 14 | "c2me-base": "*", 15 | "c2me-fixes-general-threading-issues": "*" 16 | }, 17 | 18 | "authors": [ 19 | "RelativityMC", 20 | "ishland" 21 | ], 22 | "contact": { 23 | "sources": "https://github.com/RelativityMC/C2ME-fabric", 24 | "issues": "https://github.com/RelativityMC/C2ME-fabric/issues", 25 | "discord": "https://discord.gg/Kdy8NM5HW4", 26 | "homepage": "https://modrinth.com/mod/c2me-fabric" 27 | }, 28 | "license": "MIT", 29 | "custom": { 30 | "modmenu": { 31 | "parent": "c2me" 32 | } 33 | } 34 | } 35 | -------------------------------------------------------------------------------- /gradle.properties: -------------------------------------------------------------------------------- 1 | # Done to increase the memory available to gradle and improve build times. 2 | org.gradle.jvmargs=-Xmx4G 3 | org.gradle.parallel=true 4 | org.gradle.warning.mode=all 5 | #org.gradle.configuration-cache=true 6 | # Fabric Properties 7 | # check these on https://fabricmc.net/versions.html 8 | minecraft_version=1.21.5 9 | yarn_mappings=1.21.5+build.1 10 | loader_version=0.16.10 11 | fabric_version=0.122.0+1.21.5 12 | # Mod Properties 13 | mod_version=0.3.4+alpha.0 14 | maven_group=com.ishland.c2me 15 | archives_base_name=c2me-fabric 16 | # Java Dependencies 17 | async_util_version=0.1.0 18 | night_config_version=3.6.5 19 | exp4j_version=0.4.8 20 | rxjava_version=3.1.8 21 | reactive_streams_version=1.0.4 22 | mixinsquared_version=0.2.0-beta.6 23 | jctools_version=4.0.5 24 | junit_version=5.11.3 25 | -------------------------------------------------------------------------------- /gradle/wrapper/gradle-wrapper.jar: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RelativityMC/C2ME-fabric/9d042babfcec6e8d331d0acf8b12a60e4fef955b/gradle/wrapper/gradle-wrapper.jar -------------------------------------------------------------------------------- /gradle/wrapper/gradle-wrapper.properties: -------------------------------------------------------------------------------- 1 | distributionBase=GRADLE_USER_HOME 2 | distributionPath=wrapper/dists 3 | distributionUrl=https\://services.gradle.org/distributions/gradle-8.14-all.zip 4 | zipStoreBase=GRADLE_USER_HOME 5 | zipStorePath=wrapper/dists 6 | -------------------------------------------------------------------------------- /libs/build.gradle: -------------------------------------------------------------------------------- 1 | apply plugin: 'java' 2 | apply plugin: 'java-library' 3 | 4 | java { 5 | sourceCompatibility = JavaVersion.VERSION_17 6 | targetCompatibility = JavaVersion.VERSION_17 7 | } 8 | -------------------------------------------------------------------------------- /libs/src/main/java/com/ishland/c2me/libs/Locator.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.libs; 2 | 3 | public class Locator { 4 | } 5 | -------------------------------------------------------------------------------- /libs/src/main/java/com/ishland/c2me/libs/package-info.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.libs; -------------------------------------------------------------------------------- /libs/src/main/java/com/ishland/c2me/libs/vectorized_algorithms/VectorizedAlgorithms.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.libs.vectorized_algorithms; 2 | 3 | public class VectorizedAlgorithms { 4 | 5 | public static double perlinNoiseVectorized(byte[] permutations, int sectionX, int sectionY, int sectionZ, double localX, double localY, double localZ, double fadeLocalX) { 6 | return VectorizedPerlinNoise.sample(permutations, sectionX, sectionY, sectionZ, localX, localY, localZ, fadeLocalX); 7 | } 8 | 9 | } 10 | -------------------------------------------------------------------------------- /libs/src/main/java/module-info.java: -------------------------------------------------------------------------------- 1 | module C2ME.fabric.libs.main { 2 | opens com.ishland.c2me.libs; 3 | requires transitive jdk.incubator.vector; 4 | } -------------------------------------------------------------------------------- /src/jmh/java/natives/support/ReflectUtils.java: -------------------------------------------------------------------------------- 1 | package natives.support; 2 | 3 | import java.lang.reflect.Field; 4 | 5 | public class ReflectUtils { 6 | 7 | public static Object getField(Class clazz, Object instance, String fieldName) { 8 | try { 9 | final Field declaredField = clazz.getDeclaredField(fieldName); 10 | declaredField.setAccessible(true); 11 | return declaredField.get(instance); 12 | } catch (IllegalAccessException | NoSuchFieldException e) { 13 | throw new RuntimeException(e); 14 | } 15 | } 16 | 17 | } 18 | -------------------------------------------------------------------------------- /src/main/resources/assets/c2me/icon.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RelativityMC/C2ME-fabric/9d042babfcec6e8d331d0acf8b12a60e4fef955b/src/main/resources/assets/c2me/icon.png -------------------------------------------------------------------------------- /tests/test-mod/src/main/java/com/ishland/c2me/tests/testmod/C2METestMod.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.tests.testmod; 2 | 3 | import net.fabricmc.api.ModInitializer; 4 | 5 | public class C2METestMod implements ModInitializer { 6 | 7 | @Override 8 | public void onInitialize() { 9 | 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /tests/test-mod/src/main/java/com/ishland/c2me/tests/testmod/IMinecraftServer.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.tests.testmod; 2 | 3 | public interface IMinecraftServer { 4 | 5 | boolean c2metest$runAsyncTask(); 6 | 7 | } 8 | -------------------------------------------------------------------------------- /tests/test-mod/src/main/java/com/ishland/c2me/tests/testmod/ShouldKeepTickingUtils.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.tests.testmod; 2 | 3 | import java.util.function.BooleanSupplier; 4 | 5 | public class ShouldKeepTickingUtils { 6 | 7 | public static BooleanSupplier maxTime(int timeMillis) { 8 | long startTime = System.currentTimeMillis(); 9 | return () -> System.currentTimeMillis() - startTime <= timeMillis; 10 | } 11 | 12 | } 13 | -------------------------------------------------------------------------------- /tests/test-mod/src/main/java/com/ishland/c2me/tests/testmod/mixin/IChunkGenerator.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.tests.testmod.mixin; 2 | 3 | import net.minecraft.world.biome.source.BiomeSource; 4 | import net.minecraft.world.gen.chunk.ChunkGenerator; 5 | import org.spongepowered.asm.mixin.Mixin; 6 | import org.spongepowered.asm.mixin.gen.Accessor; 7 | 8 | @Mixin(ChunkGenerator.class) 9 | public interface IChunkGenerator { 10 | 11 | @Accessor 12 | BiomeSource getBiomeSource(); 13 | 14 | } 15 | -------------------------------------------------------------------------------- /tests/test-mod/src/main/java/com/ishland/c2me/tests/testmod/mixin/IServerChunkManager.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.tests.testmod.mixin; 2 | 3 | import net.minecraft.server.world.OptionalChunk; 4 | import net.minecraft.server.world.ServerChunkManager; 5 | import net.minecraft.world.chunk.Chunk; 6 | import net.minecraft.world.chunk.ChunkStatus; 7 | import org.spongepowered.asm.mixin.Mixin; 8 | import org.spongepowered.asm.mixin.gen.Invoker; 9 | 10 | import java.util.concurrent.CompletableFuture; 11 | 12 | @Mixin(ServerChunkManager.class) 13 | public interface IServerChunkManager { 14 | 15 | @Invoker 16 | boolean invokeUpdateChunks(); 17 | 18 | @Invoker 19 | CompletableFuture> invokeGetChunkFuture(int chunkX, int chunkZ, ChunkStatus leastStatus, boolean create); 20 | 21 | } 22 | -------------------------------------------------------------------------------- /tests/test-mod/src/main/java/com/ishland/c2me/tests/testmod/mixin/IThreadedAnvilChunkStorage.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.tests.testmod.mixin; 2 | 3 | import net.minecraft.server.world.ChunkHolder; 4 | import net.minecraft.server.world.ServerChunkLoadingManager; 5 | import net.minecraft.util.thread.ThreadExecutor; 6 | import org.spongepowered.asm.mixin.Mixin; 7 | import org.spongepowered.asm.mixin.gen.Accessor; 8 | import org.spongepowered.asm.mixin.gen.Invoker; 9 | 10 | @Mixin(ServerChunkLoadingManager.class) 11 | public interface IThreadedAnvilChunkStorage { 12 | 13 | @Accessor 14 | ThreadExecutor getMainThreadExecutor(); 15 | 16 | @Invoker 17 | ChunkHolder invokeGetChunkHolder(long pos); 18 | 19 | } 20 | -------------------------------------------------------------------------------- /tests/test-mod/src/main/java/com/ishland/c2me/tests/testmod/mixin/MixinWorldView.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.tests.testmod.mixin; 2 | 3 | import net.minecraft.registry.entry.RegistryEntry; 4 | import net.minecraft.world.WorldView; 5 | import net.minecraft.world.biome.Biome; 6 | import org.spongepowered.asm.mixin.Mixin; 7 | import org.spongepowered.asm.mixin.Overwrite; 8 | import org.spongepowered.asm.mixin.Shadow; 9 | 10 | @Mixin(WorldView.class) 11 | public interface MixinWorldView { 12 | 13 | @Shadow RegistryEntry getGeneratorStoredBiome(int biomeX, int biomeY, int biomeZ); 14 | 15 | /** 16 | * @author ishland 17 | * @reason async biome locate 18 | */ 19 | @Overwrite 20 | default RegistryEntry getBiomeForNoiseGen(int biomeX, int biomeY, int biomeZ) { 21 | return this.getGeneratorStoredBiome(biomeX, biomeY, biomeZ); 22 | } 23 | 24 | } 25 | -------------------------------------------------------------------------------- /tests/test-mod/src/main/java/com/ishland/c2me/tests/testmod/mixin/fix/client/MixinEntityModelLayers.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.tests.testmod.mixin.fix.client; 2 | 3 | import net.minecraft.client.render.entity.model.EntityModelLayer; 4 | import net.minecraft.client.render.entity.model.EntityModelLayers; 5 | import org.spongepowered.asm.mixin.Final; 6 | import org.spongepowered.asm.mixin.Mixin; 7 | import org.spongepowered.asm.mixin.Shadow; 8 | import org.spongepowered.asm.mixin.injection.At; 9 | import org.spongepowered.asm.mixin.injection.Inject; 10 | import org.spongepowered.asm.mixin.injection.callback.CallbackInfo; 11 | 12 | import java.util.Collections; 13 | import java.util.Set; 14 | 15 | @Mixin(EntityModelLayers.class) 16 | public class MixinEntityModelLayers { 17 | 18 | @Shadow @Final private static Set LAYERS; 19 | @SuppressWarnings("unused") 20 | private static Set ALL_MODELS = Collections.emptySet(); 21 | 22 | @Inject(method = "", at = @At("RETURN")) 23 | private static void onCLInit(CallbackInfo ci) { 24 | ALL_MODELS = LAYERS; 25 | } 26 | 27 | } 28 | -------------------------------------------------------------------------------- /tests/test-mod/src/main/java/com/ishland/c2me/tests/testmod/mixin/fix/client/MixinMain.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.tests.testmod.mixin.fix.client; 2 | 3 | import net.minecraft.client.main.Main; 4 | import org.spongepowered.asm.mixin.Mixin; 5 | import org.spongepowered.asm.mixin.injection.At; 6 | import org.spongepowered.asm.mixin.injection.Redirect; 7 | 8 | import java.nio.charset.StandardCharsets; 9 | import java.util.UUID; 10 | 11 | @Mixin(Main.class) 12 | public class MixinMain { 13 | 14 | @Redirect(method = "main", at = @At(value = "INVOKE", target = "Lnet/minecraft/entity/player/PlayerEntity;getOfflinePlayerUuid(Ljava/lang/String;)Ljava/util/UUID;")) 15 | private static UUID redirectGetOfflineUUID(String nickname) { 16 | return UUID.nameUUIDFromBytes(("OfflinePlayer:" + nickname).getBytes(StandardCharsets.UTF_8)); 17 | } 18 | 19 | } 20 | -------------------------------------------------------------------------------- /tests/test-mod/src/main/java/com/ishland/c2me/tests/testmod/mixin/fix/logspam/MixinUniformHeightProvider.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.tests.testmod.mixin.fix.logspam; 2 | 3 | import net.minecraft.world.gen.heightprovider.UniformHeightProvider; 4 | import org.spongepowered.asm.mixin.Mixin; 5 | 6 | @Mixin(UniformHeightProvider.class) 7 | public class MixinUniformHeightProvider { 8 | 9 | // @Redirect(method = "get", at = @At(value = "INVOKE", target = "Lorg/apache/logging/log4j/Logger;warn(Ljava/lang/String;Ljava/lang/Object;)V")) 10 | // private void redirectLog(Logger instance, String s, Object o) { 11 | // // no-op 12 | // } 13 | 14 | } 15 | -------------------------------------------------------------------------------- /tests/test-mod/src/main/java/com/ishland/c2me/tests/testmod/mixin/fix/mem_effects/MixinIngredient.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.tests.testmod.mixin.fix.mem_effects; 2 | 3 | import net.minecraft.recipe.Ingredient; 4 | import org.spongepowered.asm.mixin.Mixin; 5 | 6 | @Mixin(Ingredient.class) 7 | public abstract class MixinIngredient { 8 | 9 | // @Shadow protected abstract void cacheMatchingStacks(); 10 | // 11 | // @Shadow private ItemStack[] matchingStacks; 12 | // 13 | // /** 14 | // * @author ishland 15 | // * @reason add synchronize to prevent memory effect issues 16 | // */ 17 | // @Overwrite 18 | // public ItemStack[] getMatchingStacks() { 19 | // synchronized (this) { 20 | // this.cacheMatchingStacks(); 21 | // return this.matchingStacks; 22 | // } 23 | // } 24 | 25 | } 26 | -------------------------------------------------------------------------------- /tests/test-mod/src/main/java/com/ishland/c2me/tests/testmod/mixin/package-info.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.tests.testmod.mixin; -------------------------------------------------------------------------------- /tests/test-mod/src/main/java/com/ishland/c2me/tests/testmod/mixin/pregen/MixinServerChunkManager.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.tests.testmod.mixin.pregen; 2 | 3 | import net.minecraft.server.world.ServerChunkManager; 4 | import org.spongepowered.asm.mixin.Mixin; 5 | 6 | @Mixin(ServerChunkManager.class) 7 | public class MixinServerChunkManager { 8 | 9 | // @Redirect(method = "tick(Ljava/util/function/BooleanSupplier;)V", at = @At(value = "INVOKE", target = "Lnet/minecraft/server/world/ServerChunkManager;tickChunks()V")) 10 | // private void redirectTickChunks(ServerChunkManager serverChunkManager) { 11 | // // no-op 12 | // } 13 | 14 | } 15 | -------------------------------------------------------------------------------- /tests/test-mod/src/main/java/com/ishland/c2me/tests/testmod/mixin/pregen/MixinServerPropertiesHandler.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.tests.testmod.mixin.pregen; 2 | 3 | import net.minecraft.server.dedicated.ServerPropertiesHandler; 4 | import net.minecraft.world.gen.GeneratorOptions; 5 | import org.spongepowered.asm.mixin.Final; 6 | import org.spongepowered.asm.mixin.Mixin; 7 | import org.spongepowered.asm.mixin.Mutable; 8 | import org.spongepowered.asm.mixin.Shadow; 9 | import org.spongepowered.asm.mixin.injection.At; 10 | import org.spongepowered.asm.mixin.injection.Inject; 11 | import org.spongepowered.asm.mixin.injection.callback.CallbackInfo; 12 | 13 | @Mixin(ServerPropertiesHandler.class) 14 | public class MixinServerPropertiesHandler { 15 | 16 | @Mutable 17 | @Shadow @Final public GeneratorOptions generatorOptions; 18 | 19 | @Inject(method = "", at = @At("RETURN")) 20 | private void onInit(CallbackInfo ci) { 21 | this.generatorOptions = new GeneratorOptions(GeneratorOptions.parseSeed("c2metest").getAsLong(), true, false); 22 | } 23 | 24 | } 25 | -------------------------------------------------------------------------------- /tests/test-mod/src/main/java/com/ishland/c2me/tests/testmod/mixin/pregen/MixinServerTask.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.tests.testmod.mixin.pregen; 2 | 3 | import net.minecraft.server.ServerTask; 4 | import org.spongepowered.asm.mixin.Final; 5 | import org.spongepowered.asm.mixin.Mixin; 6 | import org.spongepowered.asm.mixin.Mutable; 7 | import org.spongepowered.asm.mixin.Shadow; 8 | import org.spongepowered.asm.mixin.injection.At; 9 | import org.spongepowered.asm.mixin.injection.Inject; 10 | import org.spongepowered.asm.mixin.injection.callback.CallbackInfo; 11 | 12 | @Mixin(ServerTask.class) 13 | public class MixinServerTask { 14 | 15 | @Mutable 16 | @Shadow @Final private int creationTicks; 17 | 18 | @Inject(method = "", at = @At("RETURN")) 19 | private void onInit(int creationTicks, Runnable runnable, CallbackInfo ci) { 20 | this.creationTicks = Integer.MIN_VALUE; 21 | } 22 | 23 | } 24 | -------------------------------------------------------------------------------- /tests/test-mod/src/main/java/com/ishland/c2me/tests/testmod/mixin/pregen/MixinStructureFeature.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.tests.testmod.mixin.pregen; 2 | 3 | import net.minecraft.world.gen.structure.Structure; 4 | import org.spongepowered.asm.mixin.Mixin; 5 | 6 | @Mixin(Structure.class) 7 | public class MixinStructureFeature { 8 | 9 | // @Redirect(method = "locateStructure", at = @At(value = "INVOKE", target = "Lnet/minecraft/world/WorldView;getBiomeAccess()Lnet/minecraft/world/biome/source/BiomeAccess;"), require = 0) 10 | // private BiomeAccess redirectBiomeAccess(WorldView worldView) { 11 | // if (worldView instanceof ServerWorld serverWorld) { 12 | // return new BiomeAccess(serverWorld.getChunkManager().getChunkGenerator().getBiomeSource(), serverWorld.getSeed(), serverWorld.getDimension().getBiomeAccessType()); 13 | // } 14 | // return worldView.getBiomeAccess(); 15 | // } 16 | 17 | } 18 | -------------------------------------------------------------------------------- /tests/test-mod/src/main/resources/c2metests.mixins.json: -------------------------------------------------------------------------------- 1 | { 2 | "required": true, 3 | "minVersion": "0.8", 4 | "package": "com.ishland.c2me.tests.testmod.mixin", 5 | "compatibilityLevel": "JAVA_16", 6 | "mixinPriority": 1100, 7 | "mixins": [ 8 | "IChunkGenerator", 9 | "IServerChunkManager", 10 | "IThreadedAnvilChunkStorage", 11 | "MixinWorldView", 12 | "fix.MixinFixDevLaunch", 13 | "fix.client.MixinEntityModelLayers", 14 | "fix.client.MixinMain", 15 | "fix.logspam.MixinUniformHeightProvider", 16 | "fix.mem_effects.MixinIngredient", 17 | "fix.remapper_being_broken.MixinGeneralUtils", 18 | "pregen.MixinCrashReport", 19 | "pregen.MixinMain", 20 | "pregen.MixinMinecraftDedicatedServer", 21 | "pregen.MixinMinecraftServer", 22 | "pregen.MixinServerChunkManager", 23 | "pregen.MixinServerPropertiesHandler", 24 | "pregen.MixinServerTask", 25 | "pregen.MixinServerWorld", 26 | "pregen.MixinStructureFeature" 27 | ], 28 | "client": [ 29 | ], 30 | "injectors": { 31 | "defaultRequire": 1 32 | } 33 | } 34 | -------------------------------------------------------------------------------- /tests/test-mod/src/main/resources/fabric.mod.json: -------------------------------------------------------------------------------- 1 | { 2 | "schemaVersion": 1, 3 | "id": "c2metests", 4 | "version": "${version}", 5 | "authors": [ 6 | "ishlandbukkit", 7 | "ishland" 8 | ], 9 | "license": "MIT", 10 | "environment": "*", 11 | "entrypoints": { 12 | "main": [ 13 | "com.ishland.c2me.tests.testmod.C2METestMod" 14 | ] 15 | }, 16 | "mixins": [ 17 | "c2metests.mixins.json" 18 | ] 19 | } 20 | -------------------------------------------------------------------------------- /tests/world-diff/src/main/java/com/ishland/c2me/tests/worlddiff/mixin/IChunkSerializer.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.tests.worlddiff.mixin; 2 | 3 | import net.minecraft.nbt.NbtCompound; 4 | import net.minecraft.structure.StructureContext; 5 | import net.minecraft.structure.StructureStart; 6 | import net.minecraft.world.chunk.SerializedChunk; 7 | import net.minecraft.world.gen.structure.Structure; 8 | import org.spongepowered.asm.mixin.Mixin; 9 | import org.spongepowered.asm.mixin.gen.Invoker; 10 | 11 | import java.util.Map; 12 | 13 | @Mixin(SerializedChunk.class) 14 | public interface IChunkSerializer { 15 | 16 | @Invoker 17 | static Map invokeReadStructureStarts(StructureContext context, NbtCompound nbt, long worldSeed) { 18 | throw new AbstractMethodError(); 19 | } 20 | 21 | } 22 | -------------------------------------------------------------------------------- /tests/world-diff/src/main/java/com/ishland/c2me/tests/worlddiff/mixin/IDynamicRegistryManager.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.tests.worlddiff.mixin; 2 | 3 | import net.minecraft.registry.DynamicRegistryManager; 4 | import org.spongepowered.asm.mixin.Mixin; 5 | 6 | @Mixin(DynamicRegistryManager.class) 7 | public interface IDynamicRegistryManager { 8 | 9 | } 10 | -------------------------------------------------------------------------------- /tests/world-diff/src/main/java/com/ishland/c2me/tests/worlddiff/mixin/IStorageIoWorker.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.tests.worlddiff.mixin; 2 | 3 | import net.minecraft.nbt.NbtCompound; 4 | import net.minecraft.util.math.ChunkPos; 5 | import net.minecraft.world.storage.StorageIoWorker; 6 | import org.spongepowered.asm.mixin.Mixin; 7 | import org.spongepowered.asm.mixin.gen.Invoker; 8 | 9 | import java.util.concurrent.CompletableFuture; 10 | 11 | @Mixin(StorageIoWorker.class) 12 | public interface IStorageIoWorker { 13 | 14 | @Invoker 15 | CompletableFuture invokeReadChunkData(ChunkPos pos); 16 | 17 | } 18 | -------------------------------------------------------------------------------- /tests/world-diff/src/main/java/com/ishland/c2me/tests/worlddiff/mixin/IWorldUpdater.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.tests.worlddiff.mixin; 2 | 3 | import net.minecraft.world.updater.WorldUpdater; 4 | import org.spongepowered.asm.mixin.Mixin; 5 | 6 | @Mixin(WorldUpdater.class) 7 | public interface IWorldUpdater { 8 | 9 | // @Invoker 10 | // List invokeGetChunkPositions(RegistryKey world); 11 | 12 | } 13 | -------------------------------------------------------------------------------- /tests/world-diff/src/main/java/com/ishland/c2me/tests/worlddiff/mixin/MixinWorldUpdater.java: -------------------------------------------------------------------------------- 1 | package com.ishland.c2me.tests.worlddiff.mixin; 2 | 3 | import net.minecraft.world.updater.WorldUpdater; 4 | import org.spongepowered.asm.mixin.Mixin; 5 | import org.spongepowered.asm.mixin.injection.At; 6 | import org.spongepowered.asm.mixin.injection.Redirect; 7 | 8 | @Mixin(WorldUpdater.class) 9 | public class MixinWorldUpdater { 10 | 11 | @Redirect(method = "", at = @At(value = "INVOKE", target = "Ljava/lang/Thread;start()V")) 12 | private void redirectThreadStart(Thread thread) { 13 | } 14 | 15 | } 16 | -------------------------------------------------------------------------------- /tests/world-diff/src/main/resources/c2meworlddiff.mixins.json: -------------------------------------------------------------------------------- 1 | { 2 | "required": true, 3 | "minVersion": "0.8", 4 | "package": "com.ishland.c2me.tests.worlddiff.mixin", 5 | "compatibilityLevel": "JAVA_16", 6 | "mixinPriority": 1100, 7 | "mixins": [ 8 | "IChunkSerializer", 9 | "IDynamicRegistryManager", 10 | "IStorageIoWorker", 11 | "IWorldUpdater", 12 | "MixinMain", 13 | "MixinWorldUpdater" 14 | ], 15 | "client": [ 16 | ], 17 | "injectors": { 18 | "defaultRequire": 1 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /tests/world-diff/src/main/resources/fabric.mod.json: -------------------------------------------------------------------------------- 1 | { 2 | "schemaVersion": 1, 3 | "id": "c2meworlddiff", 4 | "version": "${version}", 5 | "authors": [ 6 | "ishlandbukkit", 7 | "ishland" 8 | ], 9 | "license": "MIT", 10 | "environment": "*", 11 | "entrypoints": { 12 | }, 13 | "mixins": [ 14 | "c2meworlddiff.mixins.json" 15 | ] 16 | } 17 | --------------------------------------------------------------------------------