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
|
#pragma once
#include "BlockHandler.h"
class cBlockEndPortalFrameHandler final : public cYawRotator<
cBlockHandler,
0x03,
E_META_END_PORTAL_FRAME_ZP,
E_META_END_PORTAL_FRAME_XM,
E_META_END_PORTAL_FRAME_ZM,
E_META_END_PORTAL_FRAME_XP>
{
using Super = cYawRotator<
cBlockHandler,
0x03,
E_META_END_PORTAL_FRAME_ZP,
E_META_END_PORTAL_FRAME_XM,
E_META_END_PORTAL_FRAME_ZM,
E_META_END_PORTAL_FRAME_XP>;
public:
using Super::Super;
private:
virtual void OnPlaced(
cChunkInterface & a_ChunkInterface,
cWorldInterface & a_WorldInterface,
Vector3i a_BlockPos,
BLOCKTYPE a_BlockType,
NIBBLETYPE a_BlockMeta
) const override
{
// E_META_END_PORTAL_FRAME_EYE is the bit which signifies the eye of ender is in it.
// LOG("PortalPlaced, meta %d", a_BlockMeta);
if ((a_BlockMeta & E_META_END_PORTAL_FRAME_EYE) == E_META_END_PORTAL_FRAME_EYE)
{
// LOG("Location is %d %d %d", a_BlockX, a_BlockY, a_BlockZ);
// Direction is the first two bits, masked by 0x3
FindAndSetPortal(a_BlockPos, a_BlockMeta & 3, a_ChunkInterface, a_WorldInterface);
}
}
/** Returns false if portal cannot be made, true if portal was made. */
static bool FindAndSetPortal(
Vector3i a_FirstFrame,
NIBBLETYPE a_Direction,
cChunkInterface & a_ChunkInterface,
cWorldInterface & a_WorldInterface
)
{
/*
PORTAL FINDING ALGORITH
=======================
- Get clicked base block
- Check diagonally (clockwise) for another portal block
- if exists, and has eye, Continue. Abort if any are facing the wrong direction.
- if doesn't exist, check horizontally (the block to the left of this block). Abort if there is no
horizontal block.
- After a corner has been met, traverse the portal clockwise, ensuring valid portal frames connect the
rectangle.
- Track the NorthWest Corner, and the dimensions.
- If dimensions are valid, create the portal.
*/
static_assert((E_META_END_PORTAL_FRAME_ZM - E_META_END_PORTAL_FRAME_XM) == 1, "Should be going clockwise");
const int MIN_PORTAL_WIDTH = 3;
const int MAX_PORTAL_WIDTH = 4;
// Directions to use for the clockwise traversal.
static const Vector3i Left[] = {
{1, 0, 0}, // 0, South, left block is East / XP
{0, 0, 1}, // 1, West, left block is South / ZP
{-1, 0, 0}, // 2, North, left block is West / XM
{0, 0, -1}, // 3, East, left block is North / ZM
};
static const Vector3i LeftForward[] = {
{1, 0, 1}, // 0, South, left block is SouthEast / XP ZP
{-1, 0, 1}, // 1, West, left block is SouthWest / XM ZP
{-1, 0, -1}, // 2, North, left block is NorthWest / XM ZM
{1, 0, -1}, // 3, East, left block is NorthEast / XP ZM
};
int EdgesComplete = -1; // We start search _before_ finding the first edge
Vector3i NorthWestCorner;
int EdgeWidth[4] = {1, 1, 1, 1};
NIBBLETYPE CurrentDirection = a_Direction;
Vector3i CurrentPos = a_FirstFrame;
// Scan clockwise until we have seen all 4 edges
while (EdgesComplete < 4)
{
// Check if we are at a corner
Vector3i NextPos = CurrentPos + LeftForward[CurrentDirection];
if (IsPortalFrame(a_ChunkInterface.GetBlock(NextPos)))
{
// We have found the corner, move clockwise to next edge
if (CurrentDirection == E_META_END_PORTAL_FRAME_XP)
{
// We are on the NW (XM, ZM) Corner
// Relative to the previous frame, the portal should appear to the right of this portal frame.
NorthWestCorner = NextPos - Left[CurrentDirection];
}
if (EdgesComplete == -1)
{
// Reset current width, we will revisit it last
EdgeWidth[CurrentDirection] = 1;
}
// Rotate 90 degrees clockwise
CurrentDirection = (CurrentDirection + 1) % 4;
EdgesComplete++;
}
else
{
// We are not at a corner, keep walking the edge
NextPos = CurrentPos + Left[CurrentDirection];
EdgeWidth[CurrentDirection]++;
if (EdgeWidth[CurrentDirection] > MAX_PORTAL_WIDTH)
{
// Don't build a portal that is too long.
return false;
}
}
if (!IsValidFrameAtPos(a_ChunkInterface, NextPos, CurrentDirection))
{
// Neither the edge nor the corner are valid portal blocks.
return false;
}
CurrentPos = NextPos;
}
if ((EdgeWidth[0] != EdgeWidth[2]) || (EdgeWidth[1] != EdgeWidth[3]))
{
// Mismatched Portal Dimensions.
return false;
}
if ((EdgeWidth[0] < MIN_PORTAL_WIDTH) || (EdgeWidth[1] < MIN_PORTAL_WIDTH))
{
// Portal too small.
return false;
}
// LOG("NW corner (low corner) %d %d %d", Corner.x, Corner.y, Corner.z);
// LOG("%d by %d", Width[0], Width[1]);
for (int i = 0; i < EdgeWidth[0]; i++)
{
for (int j = 0; j < EdgeWidth[1]; j++)
{
a_ChunkInterface
.SetBlock(NorthWestCorner.x + i, NorthWestCorner.y, NorthWestCorner.z + j, E_BLOCK_END_PORTAL, 0);
// TODO: Create block entity so portal doesn't become invisible on relog.
}
}
return true;
}
/** Return true if this block is a portal frame, has an eye, and is facing the correct direction. */
static bool IsValidFrameAtPos(cChunkInterface & a_ChunkInterface, Vector3i a_BlockPos, NIBBLETYPE a_ShouldFace)
{
BLOCKTYPE BlockType;
NIBBLETYPE BlockMeta;
return (
a_ChunkInterface.GetBlockTypeMeta(a_BlockPos, BlockType, BlockMeta) &&
(BlockType == E_BLOCK_END_PORTAL_FRAME) && (BlockMeta == (a_ShouldFace | E_META_END_PORTAL_FRAME_EYE))
);
}
/** Return true if this block is a portal frame. */
static bool IsPortalFrame(BLOCKTYPE BlockType) { return (BlockType == E_BLOCK_END_PORTAL_FRAME); }
virtual ColourID GetMapBaseColourID(NIBBLETYPE a_Meta) const override
{
UNUSED(a_Meta);
return 27;
}
};
|
