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/DynamicRedstoneTileMultipartTicking.java

package org.cyclops.integrateddynamics.capability.dynamicredstone;

import net.minecraft.core.Direction;
import org.cyclops.cyclopscore.datastructure.EnumFacingMap;
import org.cyclops.integrateddynamics.api.block.IDynamicRedstone;
import org.cyclops.integrateddynamics.core.blockentity.BlockEntityMultipartTicking;

/**
 * Default implementation of {@link IDynamicRedstone}.
 * @author rubensworks
 */
public class DynamicRedstoneTileMultipartTicking implements IDynamicRedstone {

    private final BlockEntityMultipartTicking tile;
    private final Direction side;

    public DynamicRedstoneTileMultipartTicking(BlockEntityMultipartTicking tile, Direction side) {
        this.tile = tile;
        this.side = side;
    }

    protected EnumFacingMap<Integer> getRedstoneLevels() {
        return tile.getRedstoneLevels();
    }

    protected EnumFacingMap<Boolean> getRedstoneInputs() {
        return tile.getRedstoneInputs();
    }

    protected EnumFacingMap<Boolean> getRedstoneStrong() {
        return tile.getRedstoneStrong();
    }

    @Override
    public void setRedstoneLevel(int level, boolean direct) {
        if(!tile.getLevel().isClientSide()) {
            EnumFacingMap<Integer> redstoneLevels = getRedstoneLevels();
            EnumFacingMap<Boolean> redstoneStrongs = getRedstoneStrong();
            boolean sendUpdate = false;
            boolean sendUpdateStrong = false;
            if(redstoneLevels.containsKey(side)) {
                if(redstoneLevels.get(side) != level) {
                    sendUpdate = true;
                    redstoneLevels.put(side, level);
                }
            } else {
                sendUpdate = true;
                redstoneLevels.put(side, level);
            }
            if(redstoneStrongs.containsKey(side)) {
                if(redstoneStrongs.get(side) != direct) {
                    sendUpdateStrong = true;
                    sendUpdate = true;
                    redstoneStrongs.put(side, direct);
                }
            } else {
                sendUpdateStrong = true;
                sendUpdate = true;
                redstoneStrongs.put(side, direct);
            }
            if(sendUpdate) {
                tile.updateRedstoneInfo(side, direct || sendUpdateStrong);
            }
        }
    }

    @Override
    public int getRedstoneLevel() {
        EnumFacingMap<Integer> redstoneLevels = getRedstoneLevels();
        if(redstoneLevels.containsKey(side)) {
            return redstoneLevels.get(side);
        }
        return -1;
    }

    @Override
    public boolean isDirect() {
        EnumFacingMap<Boolean> redstoneStrongs = getRedstoneStrong();
        if(redstoneStrongs.containsKey(side)) {
            return redstoneStrongs.get(side);
        }
        return false;
    }

    @Override
    public void setAllowRedstoneInput(boolean allow) {
        EnumFacingMap<Boolean> redstoneInputs = getRedstoneInputs();
        redstoneInputs.put(side, allow);
    }

    @Override
    public boolean isAllowRedstoneInput() {
        EnumFacingMap<Boolean> redstoneInputs = getRedstoneInputs();
        if(redstoneInputs.containsKey(side)) {
            return redstoneInputs.get(side);
        }
        return false;
    }

    @Override
    public void setLastPulseValue(int value) {
        EnumFacingMap<Integer> pulses = tile.getLastRedstonePulses();
        pulses.put(side, value);
    }

    @Override
    public int getLastPulseValue() {
        EnumFacingMap<Integer> pulses = tile.getLastRedstonePulses();
        if (pulses.containsKey(side)) {
            return pulses.get(side);
        }
        return 0;
    }
}

1	package org.cyclops.integrateddynamics.capability.dynamicredstone;
2
3	import net.minecraft.core.Direction;
4	import org.cyclops.cyclopscore.datastructure.EnumFacingMap;
5	import org.cyclops.integrateddynamics.api.block.IDynamicRedstone;
6	import org.cyclops.integrateddynamics.core.blockentity.BlockEntityMultipartTicking;
7
8	/**
9	* Default implementation of {@link IDynamicRedstone}.
10	* @author rubensworks
11	*/
12	public class DynamicRedstoneTileMultipartTicking implements IDynamicRedstone {
13
14	private final BlockEntityMultipartTicking tile;
15	private final Direction side;
16
17	public DynamicRedstoneTileMultipartTicking(BlockEntityMultipartTicking tile, Direction side) {	×
18	this.tile = tile;	×
19	this.side = side;	×
20	}	×
21
22	protected EnumFacingMap<Integer> getRedstoneLevels() {
23	return tile.getRedstoneLevels();	×
24	}
25
26	protected EnumFacingMap<Boolean> getRedstoneInputs() {
27	return tile.getRedstoneInputs();	×
28	}
29
30	protected EnumFacingMap<Boolean> getRedstoneStrong() {
31	return tile.getRedstoneStrong();	×
32	}
33
34	@Override
35	public void setRedstoneLevel(int level, boolean direct) {
36	if(!tile.getLevel().isClientSide()) {	×
37	EnumFacingMap<Integer> redstoneLevels = getRedstoneLevels();	×
38	EnumFacingMap<Boolean> redstoneStrongs = getRedstoneStrong();	×
39	boolean sendUpdate = false;	×
40	boolean sendUpdateStrong = false;	×
41	if(redstoneLevels.containsKey(side)) {	×
42	if(redstoneLevels.get(side) != level) {	×
43	sendUpdate = true;	×
44	redstoneLevels.put(side, level);	×
45	}
46	} else {
47	sendUpdate = true;	×
48	redstoneLevels.put(side, level);	×
49	}
50	if(redstoneStrongs.containsKey(side)) {	×
51	if(redstoneStrongs.get(side) != direct) {	×
52	sendUpdateStrong = true;	×
53	sendUpdate = true;	×
54	redstoneStrongs.put(side, direct);	×
55	}
56	} else {
57	sendUpdateStrong = true;	×
58	sendUpdate = true;	×
59	redstoneStrongs.put(side, direct);	×
60	}
61	if(sendUpdate) {	×
62	tile.updateRedstoneInfo(side, direct \|\| sendUpdateStrong);	×
63	}
64	}
65	}	×
66
67	@Override
68	public int getRedstoneLevel() {
69	EnumFacingMap<Integer> redstoneLevels = getRedstoneLevels();	×
70	if(redstoneLevels.containsKey(side)) {	×
71	return redstoneLevels.get(side);	×
72	}
73	return -1;	×
74	}
75
76	@Override
77	public boolean isDirect() {
78	EnumFacingMap<Boolean> redstoneStrongs = getRedstoneStrong();	×
79	if(redstoneStrongs.containsKey(side)) {	×
80	return redstoneStrongs.get(side);	×
81	}
82	return false;	×
83	}
84
85	@Override
86	public void setAllowRedstoneInput(boolean allow) {
87	EnumFacingMap<Boolean> redstoneInputs = getRedstoneInputs();	×
88	redstoneInputs.put(side, allow);	×
89	}	×
90
91	@Override
92	public boolean isAllowRedstoneInput() {
93	EnumFacingMap<Boolean> redstoneInputs = getRedstoneInputs();	×
94	if(redstoneInputs.containsKey(side)) {	×
95	return redstoneInputs.get(side);	×
96	}
97	return false;	×
98	}
99
100	@Override
101	public void setLastPulseValue(int value) {
102	EnumFacingMap<Integer> pulses = tile.getLastRedstonePulses();	×
103	pulses.put(side, value);	×
104	}	×
105
106	@Override
107	public int getLastPulseValue() {
108	EnumFacingMap<Integer> pulses = tile.getLastRedstonePulses();	×
109	if (pulses.containsKey(side)) {	×
110	return pulses.get(side);	×
111	}
112	return 0;	×
113	}
114	}

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