def getReticleOrigin(self):
# returns a new origin for the current selection, where the old origin is at the new selection's center.
pos, direction = self.editor.blockFaceUnderCursor
lev = self.editor.level
size = self.rotatedSelectionSize()
if not size:
return
if size[1] >= self.editor.level.Height:
direction = (
0, 1, 0
) # always use the upward face whenever we're splicing full-height pieces, to avoid "jitter"
# print size; raise SystemExit
if any(direction) and pos[1] >= 0:
x, y, z = list(
map(lambda p, s, d: p - s / 2 + s * d / 2 + (d > 0), pos, size,
direction))
else:
x, y, z = list(map(lambda p, s: p - s / 2, pos, size))
if self.chunkAlign:
x &= ~0xf
z &= ~0xf
sy = size[1]
if sy > lev.Height: # don't snap really tall stuff to the height
return Vector(x, y, z)
if y + sy > lev.Height:
y = lev.Height - sy
if y < 0:
y = 0
if not lev.Width == 0 and lev.Length == 0:
sx = size[0]
if x + sx > lev.Width:
x = lev.Width - sx
if x < 0:
x = 0
sz = size[2]
if z + sz > lev.Length:
z = lev.Length - sz
if z < 0:
z = 0
return Vector(x, y, z)
def perform(level, box, options):
size = Vector(box.origin.x + box.size.x, box.origin.y + box.size.y,
box.origin.z + box.size.z)
replace_all_water_with_lava(level, box.origin, size)
replace_all_trees_with_coal(level, box.origin, size)
fill_top_layer_with_obsidian(level, box.origin, size)
def draw_box_outline(level, box, material):
point_1 = box.origin
point_2 = Vector(box.origin.x + box.size.x, box.origin.y, box.origin.z)
point_3 = Vector(box.origin.x, box.origin.y + box.size.y, box.origin.z)
point_4 = Vector(box.origin.x, box.origin.y, box.origin.z + box.size.z)
point_5 = Vector(box.origin.x + box.size.x, box.origin.y + box.size.y,
box.origin.z)
point_6 = Vector(box.origin.x + box.size.x, box.origin.y,
box.origin.z + box.size.z)
point_7 = Vector(
box.origin.x,
box.origin.y + box.size.y,
box.origin.z + box.size.z,
)
point_8 = Vector(box.origin.x + box.size.x, box.origin.y + box.size.y,
box.origin.z + box.size.z)
draw_line(level, point_1, point_2, material)
draw_line(level, point_1, point_3, material)
draw_line(level, point_1, point_4, material)
draw_line(level, point_2, point_6, material)
draw_line(level, point_4, point_6, material)
draw_line(level, point_3, point_7, material)
draw_line(level, point_4, point_7, material)
draw_line(level, point_7, point_8, material)
draw_line(level, point_6, point_8, material)
draw_line(level, point_8, point_5, material)
draw_line(level, point_5, point_2, material)
draw_line(level, point_5, point_3, material)
def __init__(self, editor, sourceLevel, sourceBox, destLevel, destPoint, copyAir, copyWater):
super(BlockCopyOperation, self).__init__(editor, destLevel)
self.sourceLevel = sourceLevel
self.sourceBox = sourceBox
self.destPoint = Vector(*destPoint)
self.copyAir = copyAir
self.copyWater = copyWater
self.sourceBox, self.destPoint = block_copy.adjustCopyParameters(self.level, self.sourceLevel, self.sourceBox,
self.destPoint)
def perform(level, box, options):
LEVEL = level
operation = options["Operation"]
if operation == "Generate Arrows":
generateArrows(level, box, options)
if operation == "Test":
#vec = Vector(-4,-1,-1)
vec = Vector(0,0,0)
level.copyBlocksFrom(arrowSchematic(),arrowSchematic().bounds,vec + [box.minx,box.miny,box.minz])
def key_down(self, evt):
keyname = key.name(evt.key)
if keyname == config.config.get("Keys", "Up"):
self.nudge(Vector(0, 1, 0))
if keyname == config.config.get("Keys", "Down"):
self.nudge(Vector(0, -1, 0))
Z = self.get_root(
).mcedit.editor.mainViewport.cameraVector # xxx mouthful
absZ = map(abs, Z)
if absZ[0] < absZ[2]:
forward = (0, 0, (-1 if Z[2] < 0 else 1))
else:
forward = ((-1 if Z[0] < 0 else 1), 0, 0)
back = map(int.__neg__, forward)
left = forward[2], forward[1], -forward[0]
right = map(int.__neg__, left)
if keyname == config.config.get("Keys", "Forward"):
self.nudge(Vector(*forward))
if keyname == config.config.get("Keys", "Back"):
self.nudge(Vector(*back))
if keyname == config.config.get("Keys", "Left"):
self.nudge(Vector(*left))
if keyname == config.config.get("Keys", "Right"):
self.nudge(Vector(*right))
def key_down(self, evt):
self.root.handling_ctrl(evt)
keyname = self.root.getKey(evt)
if keyname == config.keys.up.get():
self.nudge(Vector(0, 1, 0))
if keyname == config.keys.down.get():
self.nudge(Vector(0, -1, 0))
Z = self.editor.mainViewport.cameraVector
absZ = map(abs, Z)
if absZ[0] < absZ[2]:
forward = (0, 0, (-1 if Z[2] < 0 else 1))
else:
forward = ((-1 if Z[0] < 0 else 1), 0, 0)
back = map(int.__neg__, forward)
left = forward[2], forward[1], -forward[0]
right = map(int.__neg__, left)
if keyname == config.keys.forward.get():
self.nudge(Vector(*forward))
if keyname == config.keys.back.get():
self.nudge(Vector(*back))
if keyname == config.keys.left.get():
self.nudge(Vector(*left))
if keyname == config.keys.right.get():
self.nudge(Vector(*right))
def changeMovementKeys(self, keyNum, keyname):
if self.editor.level is not None and not self.notMove:
self.editor.cameraInputs[self.movementNum[keyNum]] += self.movementMath[keyNum]
elif self.notMove and self.nudge is not None and (self.testTime is None or datetime.now() - self.testTime >= timedelta(seconds=0.325)):
self.testTime = datetime.now()
if keyname == self.editor.movements[4]:
self.nudge.nudge(Vector(0, 1, 0))
if keyname == self.editor.movements[5]:
self.nudge.nudge(Vector(0, -1, 0))
Z = self.editor.mainViewport.cameraVector
absZ = map(abs, Z)
if absZ[0] < absZ[2]:
forward = (0, 0, (-1 if Z[2] < 0 else 1))
else:
forward = ((-1 if Z[0] < 0 else 1), 0, 0)
back = map(int.__neg__, forward)
left = forward[2], forward[1], -forward[0]
right = map(int.__neg__, left)
if keyname == self.editor.movements[2]:
self.nudge.nudge(Vector(*forward))
if keyname == self.editor.movements[3]:
self.nudge.nudge(Vector(*back))
if keyname == self.editor.movements[0]:
self.nudge.nudge(Vector(*left))
if keyname == self.editor.movements[1]:
self.nudge.nudge(Vector(*right))
for i, key in enumerate(self.editor.movements):
if key == keyname:
self.nudgeDirection = i
def __init__(self, editor, sourceLevel, sourceBox, destLevel, destPoint, copyAir, copyWater, copyBiomes, staticCommands, moveSpawnerPos, regenerateUUID):
super(BlockCopyOperation, self).__init__(editor, destLevel)
self.sourceLevel = sourceLevel
self.sourceBox = sourceBox
self.destPoint = Vector(*destPoint)
self.copyAir = copyAir
self.copyWater = copyWater
self.copyBiomes = copyBiomes
self.staticCommands = staticCommands
self.moveSpawnerPos = moveSpawnerPos
self.regenerateUUID = regenerateUUID
self.sourceBox, self.destPoint = block_copy.adjustCopyParameters(self.level, self.sourceLevel, self.sourceBox,
self.destPoint)
self.canUndo = False
def perform(level, box, options):
data_set_size = 6
final_x = box.origin.x + box.size.x
final_y = box.origin.y + box.size.y
final_z = box.origin.z + box.size.z
min_x = min(box.origin.x, final_x)
max_x = max(box.origin.x, final_x)
min_y = min(box.origin.y, final_y)
max_y = max(box.origin.y, final_y)
min_z = min(box.origin.z, final_z)
max_z = max(box.origin.z, final_z)
point = None
level_data = [[] for i in xrange(data_set_size)]
results = []
print "analyzing data"
for x in tqdm(xrange(min_x, max_x)):
for y in xrange(min_y, max_y):
for z in xrange(min_z, max_z):
point = Vector(x, y, z)
results.append(level.blockAt(x, y, z))
for size_index in xrange(data_set_size):
level_data[size_index].append(
build_data(level, point, size_index + 1))
print "writing data to file"
for i in tqdm(xrange(data_set_size)):
data_file = DATA_DIRECTORY + DATA_FILE + str(i) + EXTENSION
result_file = DATA_DIRECTORY + RESULT_FILE + str(i) + EXTENSION
data = level_data[i]
with open(data_file, "a") as myfile:
for line in data:
myfile.write(','.join(str(x) for x in line) + "\n")
with open(RESULT_FILE, "a") as myfile:
for result in results:
myfile.write(str(result) + "\n")
print "completed"
def _draggingOrigin(self):
dragPos = map(int, map(numpy.floor, self.positionOnDraggingPlane()))
delta = map(lambda s, e: e - int(numpy.floor(s)), self.draggingStartPoint, dragPos)
if self.snapCloneKey == 1:
ad = map(abs, delta)
midx = ad.index(max(ad))
d = [0, 0, 0]
d[midx] = delta[midx]
dragY = self.draggingFace >> 1
d[dragY] = delta[dragY]
delta = d
p = self.destPoint + delta
if self.chunkAlign:
p = [i // 16 * 16 for i in p]
return Vector(*p)
def repeat(level, dest, count):
# Sets the variable "re" to one digit higher than what the user defined (more on why later)
re = count + 1
cur = 1
# Sets the current "cycle" to 1
x = 9
# Start amount of blocks to move the vector away from the selection box
while cur != re:
# Calls a "while" statement
# As long as the variable "cur" does not equal the variable "re" it runs the code underneath
# This is why I set "re" to be one higher than the user defined amount, because the "while" will end when
# It equals the defined amount, so one higher will generate what the user wanted
vec = Vector(x, -1, -2)
# Sets the vector variable
level.copyBlocksFrom(rep, rep.bounds, vec + dest)
# Copys the blocks
x = x + 3
# Sets the variable x to 3 digits higher than is was previous
cur = cur + 1
def changeMovementKeys(self, keyNum, keyname):
if self.editor.level is not None and not self.notMove:
self.editor.cameraInputs[
self.movementNum[keyNum]] += self.movementMath[keyNum]
elif self.notMove and self.nudge is not None and self.nudgeCount < 1:
if keyname == self.editor.movements[4]:
self.nudge.nudge(Vector(0, 1, 0))
if keyname == self.editor.movements[5]:
self.nudge.nudge(Vector(0, -1, 0))
Z = self.editor.mainViewport.cameraVector
absZ = map(abs, Z)
if absZ[0] < absZ[2]:
forward = (0, 0, (-1 if Z[2] < 0 else 1))
else:
forward = ((-1 if Z[0] < 0 else 1), 0, 0)
back = map(int.__neg__, forward)
left = forward[2], forward[1], -forward[0]
right = map(int.__neg__, left)
if keyname == self.editor.movements[2]:
self.nudge.nudge(Vector(*forward))
if keyname == self.editor.movements[3]:
self.nudge.nudge(Vector(*back))
if keyname == self.editor.movements[0]:
self.nudge.nudge(Vector(*left))
if keyname == self.editor.movements[1]:
self.nudge.nudge(Vector(*right))
self.nudgeCount += 1
elif self.notMove and self.nudge is not None:
if self.nudgeCount == 250:
self.nudgeCount = 0
else:
self.nudgeCount += 1
def levelTwo(level, dest, box):
vec = Vector(-2,-2,-2)
level.copyBlocksFrom(lvl2(block),lvl2(data).bounds,vec + dest)
level.markDirtyBox(box)
levelOne(level, dest, block, data)
def readIntPoint(self, command, isPoint=True):
point = self.readPoint(command, isPoint)
point = list(map(int, list(map(floor, point))))
return Vector(*point)
def houseo(level, dest):
vec = Vector(0, 1, 0)
level.copyBlocksFrom(houseOne(), houseOne().bounds, vec + dest)
def LH1(level, dest):
vec = Vector(0, 1, 0)
level.copyBlocksFrom(LargeHouse1(), LargeHouse1().bounds, vect + dest)
def createTheBlocks(level, dest):
vec = Vector(-5,-5,-3)
def farms(level, dest):
if int(level.blockAt(x, y, z)) == 0:
level.copyBlocksFrom(farm(), farm().bounds, dest)
else:
vec = Vector(0, 1, 0)
level.copyBlocksFrom(farm(), farm().bounds, vec + dest)
def placelamp(level, dest):
vec = Vector(0, 1, 0)
level.copyBlocksFrom(lamp, lamp.bounds, vec + dest)
def perform(level, box, options):
size = Vector(box.origin.x + box.size.x, box.origin.y + box.size.y,
box.origin.z + box.size.z)
nuke(level, box.origin, size)
def levelOne(level, dest, block, data):
vec = Vector(-1,-1,-1)
level.copyBlocksFrom(lvl1(block),lvl1(data).bounds,vec + dest)
def levelThree(level, dest, box, block, data):
vec = Vector(-3,-3,-3)
level.copyBlocksFrom(lvl3(block),lvl3(data).bounds,vec + dest)
level.markDirtyBox(box)
levelTwo(level, dest, box, block, data)
def levelFour(level, dest, box, block, data):
vec = Vector(-4,-4,-4)
level.copyBlocksFrom(lvl4(block),lvl4(data).bounds,vec + dest)
level.markDirtyBox(box)
levelThree(level, dest, box, block, data)
def place(level, dest):
vec = Vector(0, -1, -2)
level.copyBlocksFrom(red, red.bounds, vec + dest)
def levelFive(level, dest, box, block, data):
vec = Vector(-5,-5,-5)
level.copyBlocksFrom(lvl5(block),lvl5(data).bounds,vec + dest)
level.markDirtyBox(box)
levelFour(level, dest, box, block, data)
def placeLamp(level, dest):
# we need a vector, so that we can move the schematic up one block
# this will prevent the lamp from removing blocks on ground level
vec = Vector(0, 1, 0)
# copy blocks from schematic to level
level.copyBlocksFrom(lamp, lamp.bounds, vec + dest)
def createclasstubes(level,dest):
vec = Vector(-1,-2,-1)
level.copyBlocksFrom(createTubes,createTubes.bounds,vec + dest)
def alignDestPoint(self):
if self.destPoint is not None:
x, y, z = self.destPoint
self.destPoint = Vector((x >> 4) << 4, y, (z >> 4) << 4)
def lib(level, dest):
vec = Vector(0, 1, 0)
level.copyBlocksFrom(library(), library().bounds, vec + dest)