Skip to content

Commit cd8b48d

Browse files
mrh0mrh0
committed
port wip
1 parent 292e8c5 commit cd8b48d

File tree

4 files changed

+88
-129
lines changed

4 files changed

+88
-129
lines changed

‎src/main/java/com/mrh0/createaddition/blocks/alternator/AlternatorBlockEntity.java‎

Lines changed: 42 additions & 55 deletions
Original file line numberDiff line numberDiff line change
@@ -1,23 +1,29 @@
11
package com.mrh0.createaddition.blocks.alternator;
22

3+
import java.util.EnumMap;
4+
import java.util.EnumSet;
35
import java.util.List;
46

57
import com.mrh0.createaddition.CreateAddition;
68
import com.mrh0.createaddition.config.CommonConfig;
79
import com.mrh0.createaddition.energy.IEnergyProvider;
810
import com.mrh0.createaddition.energy.InternalEnergyStorage;
11+
import com.mrh0.createaddition.index.CABlockEntities;
912
import com.mrh0.createaddition.index.CABlocks;
1013
import com.mrh0.createaddition.sound.CASoundScapes;
1114
import com.mrh0.createaddition.sound.CASoundScapes.AmbienceGroup;
1215
import com.mrh0.createaddition.util.Util;
16+
import com.simibubi.create.AllBlockEntityTypes;
1317
import com.simibubi.create.content.kinetics.base.KineticBlockEntity;
1418
import com.simibubi.create.foundation.utility.CreateLang;
1519

1620
import net.minecraft.ChatFormatting;
1721
import net.minecraft.core.BlockPos;
1822
import net.minecraft.core.Direction;
23+
import net.minecraft.core.HolderLookup;
1924
import net.minecraft.nbt.CompoundTag;
2025
import net.minecraft.network.chat.Component;
26+
import net.minecraft.server.level.ServerLevel;
2127
import net.minecraft.util.Mth;
2228
import net.minecraft.world.level.block.Block;
2329
import net.minecraft.world.level.block.entity.BlockEntity;
@@ -28,19 +34,33 @@
2834
//import net.neoforged.neoforge.capabilities.BlockCapability;
2935
//import net.neoforged.neoforge.capabilities.ForgeCapabilities;
3036
//import net.neoforged.fml.util.LazyOptional;
37+
import net.neoforged.neoforge.capabilities.BlockCapabilityCache;
38+
import net.neoforged.neoforge.capabilities.Capabilities;
39+
import net.neoforged.neoforge.capabilities.RegisterCapabilitiesEvent;
3140
import net.neoforged.neoforge.energy.IEnergyStorage;
3241

3342
import javax.annotation.Nullable;
3443

3544
public class AlternatorBlockEntity extends KineticBlockEntity implements IEnergyProvider {
3645

3746
protected final InternalEnergyStorage energy;
38-
//private LazyOptional<IEnergyStorage> lazyEnergy;
47+
private final IEnergyStorage capability;
48+
49+
private final EnumSet<Direction> invalidSides = EnumSet.allOf(Direction.class);
50+
private final EnumMap<Direction, BlockCapabilityCache<IEnergyStorage, Direction>> cache = new EnumMap<>(Direction.class);
3951

4052
public AlternatorBlockEntity(BlockEntityType<?> typeIn, BlockPos pos, BlockState state) {
4153
super(typeIn, pos, state);
4254
energy = new InternalEnergyStorage(CommonConfig.ALTERNATOR_CAPACITY.get(), 0, CommonConfig.ALTERNATOR_MAX_OUTPUT.get());
43-
lazyEnergy = LazyOptional.of(() -> energy);
55+
capability = energy;
56+
}
57+
58+
public static void registerCapabilities(RegisterCapabilitiesEvent event) {
59+
event.registerBlockEntity(
60+
Capabilities.EnergyStorage.BLOCK,
61+
CABlockEntities.ALTERNATOR.get(),
62+
(be, context) -> be.capability
63+
);
4464
}
4565

4666
@Override
@@ -59,12 +79,6 @@ public float calculateStressApplied() {
5979
return impact;
6080
}
6181

62-
@Override
63-
public <T> LazyOptional<T> getCapability(Capability<T> cap, Direction side) {
64-
if(cap == ForgeCapabilities.ENERGY) return lazyEnergy.cast();
65-
return super.getCapability(cap, side);
66-
}
67-
6882
public boolean isEnergyInput(Direction side) {
6983
return false;
7084
}
@@ -74,32 +88,33 @@ public boolean isEnergyOutput(Direction side) {
7488
}
7589

7690
@Override
77-
public void read(CompoundTag compound, boolean clientPacket) {
78-
super.read(compound, clientPacket);
79-
energy.read(compound);
91+
protected void read(CompoundTag tag, HolderLookup.Provider registries, boolean clientPacket) {
92+
super.read(tag, registries, clientPacket);
93+
energy.read(tag);
8094
}
8195

8296
@Override
83-
public void write(CompoundTag compound, boolean clientPacket) {
84-
super.write(compound, clientPacket);
85-
energy.write(compound);
97+
public void writeSafe(CompoundTag tag, HolderLookup.Provider registries) {
98+
super.writeSafe(tag, registries);
99+
energy.write(tag);
86100
}
87101

88102
private boolean firstTickState = true;
89103

90104
@Override
91105
public void tick() {
92106
super.tick();
93-
if(level.isClientSide()) return;
94-
if(firstTickState) firstTick();
107+
if (level == null) return;
108+
if (level.isClientSide()) return;
109+
if (firstTickState) firstTick();
95110
firstTickState = false;
96111

97-
if(Math.abs(getSpeed()) > 0 && isSpeedRequirementFulfilled())
112+
if (Math.abs(getSpeed()) > 0 && isSpeedRequirementFulfilled())
98113
energy.internalProduceEnergy(getEnergyProductionRate((int)getSpeed()));
99114

100-
for(Direction d : Direction.values()) {
115+
for (Direction d : Direction.values()) {
101116
if(!isEnergyOutput(d)) continue;
102-
IEnergyStorage ies = getCachedEnergy(d);
117+
IEnergyStorage ies = cache.get(d).getCapability();
103118
if(ies == null) continue;
104119
int ext = energy.extractEnergy(ies.receiveEnergy(CommonConfig.ALTERNATOR_MAX_OUTPUT.get(), true), false);
105120
ies.receiveEnergy(ext, false);
@@ -137,45 +152,17 @@ public void updateCache() {
137152
if (level == null) return;
138153
if (level.isClientSide()) return;
139154
for (Direction side : Direction.values()) {
140-
BlockEntity te = level.getBlockEntity(worldPosition.relative(side));
141-
if(te == null) {
142-
setCache(side, LazyOptional.empty());
143-
continue;
144-
}
145-
LazyOptional<IEnergyStorage> le = te.getCapability(ForgeCapabilities.ENERGY, side.getOpposite());
146-
setCache(side, le);
147-
}
148-
}
149-
150-
private LazyOptional<IEnergyStorage> escacheUp = LazyOptional.empty();
151-
private LazyOptional<IEnergyStorage> escacheDown = LazyOptional.empty();
152-
private LazyOptional<IEnergyStorage> escacheNorth = LazyOptional.empty();
153-
private LazyOptional<IEnergyStorage> escacheEast = LazyOptional.empty();
154-
private LazyOptional<IEnergyStorage> escacheSouth = LazyOptional.empty();
155-
private LazyOptional<IEnergyStorage> escacheWest = LazyOptional.empty();
156-
157-
public void setCache(Direction side, LazyOptional<IEnergyStorage> storage) {
158-
switch (side) {
159-
case DOWN -> escacheDown = storage;
160-
case EAST -> escacheEast = storage;
161-
case NORTH -> escacheNorth = storage;
162-
case SOUTH -> escacheSouth = storage;
163-
case UP -> escacheUp = storage;
164-
case WEST -> escacheWest = storage;
155+
cache.put(side, BlockCapabilityCache.create(
156+
Capabilities.EnergyStorage.BLOCK,
157+
(ServerLevel) level,
158+
getBlockPos().relative(side),
159+
side.getOpposite(),
160+
() -> !this.isRemoved(),
161+
() -> { invalidSides.add(side); }
162+
));
165163
}
166164
}
167165

168-
public IEnergyStorage getCachedEnergy(Direction side) {
169-
return switch (side) {
170-
case DOWN -> escacheDown.orElse(null);
171-
case EAST -> escacheEast.orElse(null);
172-
case NORTH -> escacheNorth.orElse(null);
173-
case SOUTH -> escacheSouth.orElse(null);
174-
case UP -> escacheUp.orElse(null);
175-
case WEST -> escacheWest.orElse(null);
176-
};
177-
}
178-
179166
@Override
180167
public IEnergyStorage getEnergyStorage(@Nullable Direction direction) {
181168
return energy;

‎src/main/java/com/mrh0/createaddition/blocks/creative_energy/CreativeEnergyBlockEntity.java‎

Lines changed: 39 additions & 70 deletions
Original file line numberDiff line numberDiff line change
@@ -2,39 +2,56 @@
22

33
import com.mrh0.createaddition.energy.CreativeEnergyStorage;
44

5+
import com.mrh0.createaddition.index.CABlockEntities;
56
import com.simibubi.create.content.logistics.crate.CrateBlockEntity;
67
import net.minecraft.core.BlockPos;
78
import net.minecraft.core.Direction;
9+
import net.minecraft.server.level.ServerLevel;
810
import net.minecraft.world.level.block.entity.BlockEntity;
911
import net.minecraft.world.level.block.entity.BlockEntityType;
1012
import net.minecraft.world.level.block.state.BlockState;
13+
import net.neoforged.neoforge.capabilities.BlockCapabilityCache;
14+
import net.neoforged.neoforge.capabilities.Capabilities;
15+
import net.neoforged.neoforge.capabilities.RegisterCapabilitiesEvent;
1116
import net.neoforged.neoforge.energy.IEnergyStorage;
1217

18+
import java.util.EnumMap;
19+
import java.util.EnumSet;
20+
1321
public class CreativeEnergyBlockEntity extends CrateBlockEntity {
1422

15-
protected final CreativeEnergyStorage energy;
23+
protected final CreativeEnergyStorage capability;
24+
25+
private final EnumSet<Direction> invalidSides = EnumSet.allOf(Direction.class);
26+
private final EnumMap<Direction, BlockCapabilityCache<IEnergyStorage, Direction>> cache = new EnumMap<>(Direction.class);
1627

1728
public CreativeEnergyBlockEntity(BlockEntityType<?> tileEntityTypeIn, BlockPos pos, BlockState state) {
1829
super(tileEntityTypeIn, pos, state);
19-
energy = new CreativeEnergyStorage();
30+
capability = new CreativeEnergyStorage();
31+
}
32+
33+
public static void registerCapabilities(RegisterCapabilitiesEvent event) {
34+
event.registerBlockEntity(
35+
Capabilities.EnergyStorage.BLOCK,
36+
CABlockEntities.CREATIVE_ENERGY.get(),
37+
(be, context) -> be.capability
38+
);
2039
}
2140

2241
private boolean firstTickState = true;
2342

2443
@Override
2544
public void tick() {
2645
super.tick();
27-
if(level.isClientSide())
28-
return;
29-
if(firstTickState)
30-
firstTick();
46+
if (level == null) return;
47+
if (level.isClientSide()) return;
48+
if (firstTickState) firstTick();
3149
firstTickState = false;
3250

33-
for(Direction d : Direction.values()) {
34-
IEnergyStorage ies = getCachedEnergy(d);
35-
if(ies == null)
36-
continue;
37-
int r = ies.receiveEnergy(Integer.MAX_VALUE, false);
51+
for (Direction d : Direction.values()) {
52+
IEnergyStorage ies = cache.get(d).getCapability();
53+
if (ies == null) continue;
54+
ies.receiveEnergy(Integer.MAX_VALUE, false);
3855
}
3956
}
4057

@@ -43,65 +60,17 @@ public void firstTick() {
4360
};
4461

4562
public void updateCache() {
46-
if(level.isClientSide())
47-
return;
48-
for(Direction side : Direction.values()) {
49-
BlockEntity te = level.getBlockEntity(worldPosition.relative(side));
50-
if(te == null) {
51-
setCache(side, LazyOptional.empty());
52-
continue;
53-
}
54-
LazyOptional<IEnergyStorage> le = te.getCapability(ForgeCapabilities.ENERGY, side.getOpposite());
55-
setCache(side, le);
56-
57-
}
58-
}
59-
60-
private LazyOptional<IEnergyStorage> escacheUp = LazyOptional.empty();
61-
private LazyOptional<IEnergyStorage> escacheDown = LazyOptional.empty();
62-
private LazyOptional<IEnergyStorage> escacheNorth = LazyOptional.empty();
63-
private LazyOptional<IEnergyStorage> escacheEast = LazyOptional.empty();
64-
private LazyOptional<IEnergyStorage> escacheSouth = LazyOptional.empty();
65-
private LazyOptional<IEnergyStorage> escacheWest = LazyOptional.empty();
66-
67-
public void setCache(Direction side, LazyOptional<IEnergyStorage> storage) {
68-
switch(side) {
69-
case DOWN:
70-
escacheDown = storage;
71-
break;
72-
case EAST:
73-
escacheEast = storage;
74-
break;
75-
case NORTH:
76-
escacheNorth = storage;
77-
break;
78-
case SOUTH:
79-
escacheSouth = storage;
80-
break;
81-
case UP:
82-
escacheUp = storage;
83-
break;
84-
case WEST:
85-
escacheWest = storage;
86-
break;
87-
}
88-
}
89-
90-
public IEnergyStorage getCachedEnergy(Direction side) {
91-
switch(side) {
92-
case DOWN:
93-
return escacheDown.orElse(null);
94-
case EAST:
95-
return escacheEast.orElse(null);
96-
case NORTH:
97-
return escacheNorth.orElse(null);
98-
case SOUTH:
99-
return escacheSouth.orElse(null);
100-
case UP:
101-
return escacheUp.orElse(null);
102-
case WEST:
103-
return escacheWest.orElse(null);
63+
if (level == null) return;
64+
if (level.isClientSide()) return;
65+
for (Direction side : Direction.values()) {
66+
cache.put(side, BlockCapabilityCache.create(
67+
Capabilities.EnergyStorage.BLOCK,
68+
(ServerLevel) level,
69+
getBlockPos().relative(side),
70+
side.getOpposite(),
71+
() -> !this.isRemoved(),
72+
() -> { invalidSides.add(side); }
73+
));
10474
}
105-
return null;
10675
}
10776
}

‎src/main/java/com/mrh0/createaddition/blocks/tesla_coil/TeslaCoilBlockEntity.java‎

Lines changed: 5 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -15,9 +15,12 @@
1515
import com.simibubi.create.content.kinetics.belt.behaviour.TransportedItemStackHandlerBehaviour;
1616
import com.simibubi.create.content.kinetics.belt.transport.TransportedItemStack;
1717
import com.simibubi.create.foundation.blockEntity.behaviour.BlockEntityBehaviour;
18+
import com.simibubi.create.foundation.sound.SoundScapes;
19+
import net.createmod.catnip.platform.CatnipServices;
1820
import net.minecraft.core.BlockPos;
1921
import net.minecraft.core.Direction;
2022
import net.minecraft.sounds.SoundSource;
23+
import net.minecraft.util.Mth;
2124
import net.minecraft.world.effect.MobEffectInstance;
2225
import net.minecraft.world.entity.LivingEntity;
2326
import net.minecraft.world.entity.player.Player;
@@ -147,8 +150,8 @@ public void tick() {
147150
super.tick();
148151
if(level == null) return;
149152

150-
if (level.isClientSide()) {
151-
DistExecutor.unsafeRunWhenOn(Dist.CLIENT, () -> this::tickAudio);
153+
if (level.isClientSide) {
154+
CatnipServices.PLATFORM.executeOnClientOnly(() -> this::tickAudio);
152155
return;
153156
}
154157
int signal = level.getBestNeighborSignal(getBlockPos());

‎src/main/java/com/mrh0/createaddition/energy/AbstractElectricBlockEntity.java‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -21,8 +21,8 @@ public abstract class AbstractElectricBlockEntity extends SmartBlockEntity {
2121

2222
protected final InternalEnergyStorage localEnergy;
2323

24-
private EnumSet<Direction> invalidSides = EnumSet.allOf(Direction.class);
25-
private EnumMap<Direction, BlockCapabilityCache<IEnergyStorage, Direction>> escacheMap = new EnumMap<>(Direction.class);
24+
private final EnumSet<Direction> invalidSides = EnumSet.allOf(Direction.class);
25+
private final EnumMap<Direction, BlockCapabilityCache<IEnergyStorage, Direction>> escacheMap = new EnumMap<>(Direction.class);
2626

2727
public AbstractElectricBlockEntity(BlockEntityType<?> tileEntityTypeIn, BlockPos pos, BlockState state) {
2828
super(tileEntityTypeIn, pos, state);

0 commit comments

Comments
 (0)