20210191346

Committed 14 Dec 2025 03:32PM UTC coverage: 19.514% (-33.5%) from 53.061%

Build # 20210191346

Build Type

push

github

Committed by

rubensworks

Commit Message

Remove deprecations

Run Details

663 of 8728 branches covered (7.6%)

Branch coverage included in aggregate %.

6786 of 29445 relevant lines covered (23.05%)

1.09 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/src/main/java/org/cyclops/integrateddynamics/capability/dynamicredstone/DynamicRedstoneHolderGlobal.java

package org.cyclops.integrateddynamics.capability.dynamicredstone;

import com.google.common.collect.Maps;
import net.minecraft.core.BlockPos;
import net.minecraft.core.Direction;
import net.minecraft.world.level.Level;
import net.minecraft.world.level.block.state.BlockState;
import net.minecraft.world.level.redstone.ExperimentalRedstoneUtils;
import net.minecraft.world.level.redstone.Orientation;
import org.cyclops.cyclopscore.datastructure.DimPos;
import org.cyclops.cyclopscore.datastructure.EnumFacingMap;
import org.cyclops.integrateddynamics.api.block.IDynamicRedstone;

import java.util.Map;

/**
 * @author rubensworks
 */
public class DynamicRedstoneHolderGlobal {

    private static final DynamicRedstoneHolderGlobal _INSTANCE = new DynamicRedstoneHolderGlobal();

    private Map<DimPos, EnumFacingMap<Integer>> redstoneLevels = Maps.newHashMap();
    private Map<DimPos, EnumFacingMap<Boolean>> redstoneStrong = Maps.newHashMap();

    private DynamicRedstoneHolderGlobal() {

    }

    public static DynamicRedstoneHolderGlobal getInstance() {
        return _INSTANCE;
    }

    public boolean hasLevels() {
        return !this.redstoneLevels.isEmpty();
    }

    public IDynamicRedstone getDynamicRedstone(DimPos dimPos, Direction side) {
        return new DynamicRedstoneVirtual(this, dimPos, side);
    }

    public static class DynamicRedstoneVirtual implements IDynamicRedstone {

        private final DynamicRedstoneHolderGlobal holder;
        private final DimPos dimPos;
        private final Direction side;

        public DynamicRedstoneVirtual(DynamicRedstoneHolderGlobal holder, DimPos dimPos, Direction side) {
            this.holder = holder;
            this.dimPos = dimPos;
            this.side = side;
        }

        @Override
        public void setRedstoneLevel(int level, boolean direct) {
            EnumFacingMap<Integer> redstoneLevels = this.holder.redstoneLevels.get(this.dimPos);
            if (redstoneLevels == null) {
                redstoneLevels = EnumFacingMap.newMap();
                this.holder.redstoneLevels.put(this.dimPos, redstoneLevels);
            }
            EnumFacingMap<Boolean> redstoneStrongs = this.holder.redstoneStrong.get(this.dimPos);
            if (redstoneStrongs == null) {
                redstoneStrongs = EnumFacingMap.newMap();
                this.holder.redstoneStrong.put(this.dimPos, redstoneStrongs);
            }

            boolean sendUpdate = false;
            boolean sendUpdateStrong = false;
            if(redstoneLevels.containsKey(side)) {
                if(redstoneLevels.get(side) != level) {
                    sendUpdate = true;
                    if (level < 0) {
                        redstoneLevels.remove(side);
                    } else {
                        redstoneLevels.put(side, level);
                    }
                }
            } else {
                sendUpdate = true;
                if (level < 0) {
                    redstoneLevels.remove(side);
                } else {
                    redstoneLevels.put(side, level);
                }
            }
            if(redstoneStrongs.containsKey(side)) {
                if(redstoneStrongs.get(side) != direct) {
                    sendUpdateStrong = true;
                    sendUpdate = true;
                    if (level < 0) {
                        redstoneStrongs.remove(side);
                    } else {
                        redstoneStrongs.put(side, direct);
                    }
                }
            } else {
                sendUpdateStrong = true;
                sendUpdate = true;
                if (level < 0) {
                    redstoneStrongs.remove(side);
                } else {
                    redstoneStrongs.put(side, direct);
                }
            }


            if (redstoneLevels.isEmpty()) {
                this.holder.redstoneLevels.remove(this.dimPos);
            }
            if (redstoneStrongs.isEmpty()) {
                this.holder.redstoneStrong.remove(this.dimPos);
            }

            if(sendUpdate) {
                updateRedstoneInfo(direct || sendUpdateStrong);
            }
        }

        public void updateRedstoneInfo(boolean strongPower) {
            Level level = this.dimPos.getLevel(false);
            if (level != null) {
                BlockPos pos = this.dimPos.getBlockPos();
                if (level.isLoaded(pos.relative(side.getOpposite()))) {
                    BlockState blockState = level.getBlockState(pos);
                    Orientation orientation = ExperimentalRedstoneUtils.initialOrientation(level, side.getOpposite(), null);
                    level.neighborChanged(pos.relative(side.getOpposite()), blockState.getBlock(), orientation);
                    if (strongPower) {
                        // When we are emitting a strong power, also update all neighbours of the target
                        level.updateNeighborsAt(pos.relative(side.getOpposite()), blockState.getBlock());
                    }
                }
            }
        }

        @Override
        public int getRedstoneLevel() {
            EnumFacingMap<Integer> redstoneLevels = this.holder.redstoneLevels.get(this.dimPos);
            if(redstoneLevels != null) {
                return redstoneLevels.getOrDefault(side, -1);
            }
            return -1;
        }

        @Override
        public boolean isDirect() {
            EnumFacingMap<Boolean> redstoneStrongs = this.holder.redstoneStrong.get(this.dimPos);
            if(redstoneStrongs != null) {
                return redstoneStrongs.getOrDefault(side, false);
            }
            return false;
        }

        @Override
        public void setAllowRedstoneInput(boolean allow) {
            // Not required
        }

        @Override
        public boolean isAllowRedstoneInput() {
            // Not required
            return false;
        }

        @Override
        public void setLastPulseValue(int value) {
            // Not required
        }

        @Override
        public int getLastPulseValue() {
            // Not required
            return 0;
        }
    }
}

1	package org.cyclops.integrateddynamics.capability.dynamicredstone;
2
3	import com.google.common.collect.Maps;
4	import net.minecraft.core.BlockPos;
5	import net.minecraft.core.Direction;
6	import net.minecraft.world.level.Level;
7	import net.minecraft.world.level.block.state.BlockState;
8	import net.minecraft.world.level.redstone.ExperimentalRedstoneUtils;
9	import net.minecraft.world.level.redstone.Orientation;
10	import org.cyclops.cyclopscore.datastructure.DimPos;
11	import org.cyclops.cyclopscore.datastructure.EnumFacingMap;
12	import org.cyclops.integrateddynamics.api.block.IDynamicRedstone;
13
14	import java.util.Map;
15
16	/**
17	* @author rubensworks
18	*/
19	public class DynamicRedstoneHolderGlobal {
20
21	private static final DynamicRedstoneHolderGlobal _INSTANCE = new DynamicRedstoneHolderGlobal();	×
22
23	private Map<DimPos, EnumFacingMap<Integer>> redstoneLevels = Maps.newHashMap();	×
24	private Map<DimPos, EnumFacingMap<Boolean>> redstoneStrong = Maps.newHashMap();	×
25
26	private DynamicRedstoneHolderGlobal() {	×
27
28	}	×
29
30	public static DynamicRedstoneHolderGlobal getInstance() {
31	return _INSTANCE;	×
32	}
33
34	public boolean hasLevels() {
35	return !this.redstoneLevels.isEmpty();	×
36	}
37
38	public IDynamicRedstone getDynamicRedstone(DimPos dimPos, Direction side) {
39	return new DynamicRedstoneVirtual(this, dimPos, side);	×
40	}
41
42	public static class DynamicRedstoneVirtual implements IDynamicRedstone {
43
44	private final DynamicRedstoneHolderGlobal holder;
45	private final DimPos dimPos;
46	private final Direction side;
47
48	public DynamicRedstoneVirtual(DynamicRedstoneHolderGlobal holder, DimPos dimPos, Direction side) {	×
49	this.holder = holder;	×
50	this.dimPos = dimPos;	×
51	this.side = side;	×
52	}	×
53
54	@Override
55	public void setRedstoneLevel(int level, boolean direct) {
56	EnumFacingMap<Integer> redstoneLevels = this.holder.redstoneLevels.get(this.dimPos);	×
57	if (redstoneLevels == null) {	×
58	redstoneLevels = EnumFacingMap.newMap();	×
59	this.holder.redstoneLevels.put(this.dimPos, redstoneLevels);	×
60	}
61	EnumFacingMap<Boolean> redstoneStrongs = this.holder.redstoneStrong.get(this.dimPos);	×
62	if (redstoneStrongs == null) {	×
63	redstoneStrongs = EnumFacingMap.newMap();	×
64	this.holder.redstoneStrong.put(this.dimPos, redstoneStrongs);	×
65	}
66
67	boolean sendUpdate = false;	×
68	boolean sendUpdateStrong = false;	×
69	if(redstoneLevels.containsKey(side)) {	×
70	if(redstoneLevels.get(side) != level) {	×
71	sendUpdate = true;	×
72	if (level < 0) {	×
73	redstoneLevels.remove(side);	×
74	} else {
75	redstoneLevels.put(side, level);	×
76	}
77	}
78	} else {
79	sendUpdate = true;	×
80	if (level < 0) {	×
81	redstoneLevels.remove(side);	×
82	} else {
83	redstoneLevels.put(side, level);	×
84	}
85	}
86	if(redstoneStrongs.containsKey(side)) {	×
87	if(redstoneStrongs.get(side) != direct) {	×
88	sendUpdateStrong = true;	×
89	sendUpdate = true;	×
90	if (level < 0) {	×
91	redstoneStrongs.remove(side);	×
92	} else {
93	redstoneStrongs.put(side, direct);	×
94	}
95	}
96	} else {
97	sendUpdateStrong = true;	×
98	sendUpdate = true;	×
99	if (level < 0) {	×
100	redstoneStrongs.remove(side);	×
101	} else {
102	redstoneStrongs.put(side, direct);	×
103	}
104	}
105
106
107	if (redstoneLevels.isEmpty()) {	×
108	this.holder.redstoneLevels.remove(this.dimPos);	×
109	}
110	if (redstoneStrongs.isEmpty()) {	×
111	this.holder.redstoneStrong.remove(this.dimPos);	×
112	}
113
114	if(sendUpdate) {	×
115	updateRedstoneInfo(direct \|\| sendUpdateStrong);	×
116	}
117	}	×
118
119	public void updateRedstoneInfo(boolean strongPower) {
120	Level level = this.dimPos.getLevel(false);	×
121	if (level != null) {	×
122	BlockPos pos = this.dimPos.getBlockPos();	×
123	if (level.isLoaded(pos.relative(side.getOpposite()))) {	×
124	BlockState blockState = level.getBlockState(pos);	×
125	Orientation orientation = ExperimentalRedstoneUtils.initialOrientation(level, side.getOpposite(), null);	×
126	level.neighborChanged(pos.relative(side.getOpposite()), blockState.getBlock(), orientation);	×
127	if (strongPower) {	×
128	// When we are emitting a strong power, also update all neighbours of the target
129	level.updateNeighborsAt(pos.relative(side.getOpposite()), blockState.getBlock());	×
130	}
131	}
132	}
133	}	×
134
135	@Override
136	public int getRedstoneLevel() {
137	EnumFacingMap<Integer> redstoneLevels = this.holder.redstoneLevels.get(this.dimPos);	×
138	if(redstoneLevels != null) {	×
139	return redstoneLevels.getOrDefault(side, -1);	×
140	}
141	return -1;	×
142	}
143
144	@Override
145	public boolean isDirect() {
146	EnumFacingMap<Boolean> redstoneStrongs = this.holder.redstoneStrong.get(this.dimPos);	×
147	if(redstoneStrongs != null) {	×
148	return redstoneStrongs.getOrDefault(side, false);	×
149	}
150	return false;	×
151	}
152
153	@Override
154	public void setAllowRedstoneInput(boolean allow) {
155	// Not required
156	}	×
157
158	@Override
159	public boolean isAllowRedstoneInput() {
160	// Not required
161	return false;	×
162	}
163
164	@Override
165	public void setLastPulseValue(int value) {
166	// Not required
167	}	×
168
169	@Override
170	public int getLastPulseValue() {
171	// Not required
172	return 0;	×
173	}
174	}
175	}

CyclopsMC / IntegratedDynamics / 20210191346

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous