1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
|
#pragma once
#include "RedstoneHandler.h"
class cRedstoneWireHandler final : public cRedstoneHandler
{
public:
inline static bool IsDirectlyConnectingMechanism(BLOCKTYPE a_Block, NIBBLETYPE a_BlockMeta, const Vector3i a_Offset)
{
switch (a_Block)
{
case E_BLOCK_REDSTONE_REPEATER_ON:
case E_BLOCK_REDSTONE_REPEATER_OFF:
{
a_BlockMeta &= E_META_REDSTONE_REPEATER_FACING_MASK;
if ((a_BlockMeta == E_META_REDSTONE_REPEATER_FACING_XP) || (a_BlockMeta == E_META_REDSTONE_REPEATER_FACING_XM))
{
// Wire connects to repeater if repeater is aligned along X
// and wire is in front or behind it (#4639)
return a_Offset.x != 0;
}
return a_Offset.z != 0;
}
case E_BLOCK_ACTIVE_COMPARATOR:
case E_BLOCK_INACTIVE_COMPARATOR:
case E_BLOCK_REDSTONE_TORCH_OFF:
case E_BLOCK_REDSTONE_TORCH_ON:
case E_BLOCK_REDSTONE_WIRE: return true;
default: return false;
}
}
template <class OffsetCallback>
static bool ForTerracingConnectionOffsets(cChunk & a_Chunk, const Vector3i a_Position, OffsetCallback Callback)
{
const auto YPTerraceBlock = a_Chunk.GetBlock(a_Position + OffsetYP);
const bool IsYPTerracingBlocked = cBlockInfo::IsSolid(YPTerraceBlock) && !cBlockInfo::IsTransparent(YPTerraceBlock);
for (const auto Adjacent : RelativeLaterals)
{
// All laterals are counted as terracing, duh
if (Callback(Adjacent))
{
return true;
}
if (
BLOCKTYPE YPBlock;
// A block above us blocks all YP terracing, so the check is static in the loop
!IsYPTerracingBlocked &&
a_Chunk.UnboundedRelGetBlockType(a_Position + Adjacent + OffsetYP, YPBlock) &&
(YPBlock == E_BLOCK_REDSTONE_WIRE)
)
{
if (Callback(Adjacent + OffsetYP))
{
return true;
}
}
if (
BLOCKTYPE YMTerraceBlock, YMDiagonalBlock;
// IsYMTerracingBlocked (i.e. check block above lower terracing position, a.k.a. just the plain adjacent)
a_Chunk.UnboundedRelGetBlockType(a_Position + Adjacent, YMTerraceBlock) &&
(!cBlockInfo::IsSolid(YMTerraceBlock) || cBlockInfo::IsTransparent(YMTerraceBlock)) &&
a_Chunk.UnboundedRelGetBlockType(a_Position + Adjacent + OffsetYM, YMDiagonalBlock) &&
(YMDiagonalBlock == E_BLOCK_REDSTONE_WIRE)
)
{
if (Callback(Adjacent + OffsetYM))
{
return true;
}
}
}
return false;
}
virtual unsigned char GetPowerDeliveredToPosition(cChunk & a_Chunk, Vector3i a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta, Vector3i a_QueryPosition, BLOCKTYPE a_QueryBlockType) const override
{
if (a_QueryPosition == (a_Position + OffsetYP))
{
// Wires do not power things above them
return 0;
}
if (a_QueryBlockType == E_BLOCK_REDSTONE_WIRE)
{
// For mechanisms, wire of power one will still power them
// But for wire-to-wire connections, power level decreases by 1
return (a_Meta != 0) ? --a_Meta : a_Meta;
}
// Wires always deliver power to the block underneath, and any directly connecting mechanisms
if (
NIBBLETYPE QueryMeta;
(a_QueryPosition == (a_Position + OffsetYM)) ||
(a_Chunk.UnboundedRelGetBlockMeta(a_QueryPosition, QueryMeta) && IsDirectlyConnectingMechanism(a_QueryBlockType, QueryMeta, a_QueryPosition - a_Position))
)
{
return a_Meta;
}
/*
Okay, we do not directly connect to the wire.
If there are no DC mechanisms at all, the wire powers all laterals. Great, we fall out the loop.
If there is one DC mechanism, the wire "goes straight" along the axis of the wire and mechanism.
The only possible way for us to be powered is for us to be on the opposite end, with the wire pointing towards us.
If there is more than one DC, no non-DCs are powered.
*/
Vector3i PotentialOffset;
bool FoundOneBorderingMechanism = false;
if (
ForTerracingConnectionOffsets(a_Chunk, a_Position, [&a_Chunk, a_Position, &FoundOneBorderingMechanism, &PotentialOffset](const Vector3i Offset)
{
BLOCKTYPE Block;
NIBBLETYPE Meta;
if (
!a_Chunk.UnboundedRelGetBlock(Offset + a_Position, Block, Meta) ||
!IsDirectlyConnectingMechanism(Block, Meta, Offset)
)
{
return false;
}
if (FoundOneBorderingMechanism)
{
// Case 3
return true;
}
// Potential case 2
FoundOneBorderingMechanism = true;
PotentialOffset = { -Offset.x, 0, -Offset.z };
return false;
})
)
{
// Case 3
return 0;
}
if (FoundOneBorderingMechanism && (a_QueryPosition != (a_Position + PotentialOffset)))
{
// Case 2 fail
return 0;
}
// Case 1
// Case 2 success
return a_Meta;
}
virtual void Update(cChunk & a_Chunk, cChunk & CurrentlyTicking, Vector3i a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta, PoweringData a_PoweringData) const override
{
// LOGD("Evaluating dusty the wire (%d %d %d) %i", a_Position.x, a_Position.y, a_Position.z, a_PoweringData.PowerLevel);
if (a_Meta != a_PoweringData.PowerLevel)
{
a_Chunk.SetMeta(a_Position, a_PoweringData.PowerLevel);
// Notify block below us to update:
UpdateAdjustedRelative(a_Chunk, CurrentlyTicking, a_Position + OffsetYM);
// Notify all terracing positions:
ForTerracingConnectionOffsets(a_Chunk, a_Position, [&a_Chunk, &CurrentlyTicking, a_Position](const Vector3i Offset)
{
UpdateAdjustedRelative(a_Chunk, CurrentlyTicking, a_Position + Offset);
return false;
});
}
}
virtual void ForValidSourcePositions(cChunk & a_Chunk, Vector3i a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta, SourceCallback Callback) const override
{
UNUSED(a_Chunk);
UNUSED(a_BlockType);
UNUSED(a_Meta);
Callback(a_Position + OffsetYP);
Callback(a_Position + OffsetYM);
ForTerracingConnectionOffsets(a_Chunk, a_Position, [&Callback, a_Position](const Vector3i Offset)
{
Callback(a_Position + Offset);
return false;
});
}
};
|
