def spawnAdvancedRoof(position, direction, height, length):
for i in help(height):
newPosition = vec3.Vec3(position.x + direction.x * i,
position.y + direction.y * i,
position.z + direction.z * i)
spawnLine(
newPosition,
util.turnVectorClockwise(vec3.Vec3(direction.x, 0, direction.z)),
length, block.WOOD_PLANKS.id)
#spawnFlatRoof(vec3.Vec3(0,6,0), vec3.Vec3(1,0,0),5)
#spawnAdvancedRoof(vec3.Vec3(0,6,0), vec3.Vec3(1,1,0),5, 10)
#spawnLine(vec3.Vec3(0,11,0), vec3.Vec3(1,1,2))
#spawnLine(vec3.Vec3(0,1,0), vec3.Vec3(1,0,0), 10, block.BRICK_BLOCK.id)
def load(self, filename=False, load_mode=False):
if not (filename):
filename = input("Nhập tên file bạn muốn load")
# try:
with open(os.path.join(data_root, "{}.json".format(filename))) as f:
data = json.load(f)
self.filename = filename
self.structuresInstance = []
self.structuresData = []
if not load_mode:
load_mode = input("""
1. Chỉ load data
2. Load công trình và xây dựng
""")
for st in data['structures']:
print(st)
# try:
temp = Structure.Structure(
mc,
vec3.Vec3(st['position']['x'], st['position']['y'],
st['position']['z']))
if load_mode == "2":
temp.load(st['filename'])
self.structuresData.append(st)
self.structuresInstance.append(temp)
#
# except:
# print("File dữ liệu bị lỗi")
pass
def add_struct(self, x=False, y=False, z=False, note=False, tags=[]):
if not (type(x) is int and type(y) is int and type(z) is int):
print(
"bạn hãy nhập vị trí của bạn vào vị trí bạn muốn đặt công trình"
)
x = input('x = ')
y = input('y = ')
z = input('z = ')
instance = Structure.Structure(mc, vec3.Vec3(int(x), int(y), int(z)))
self.current = instance
if not note:
note = input("Hãy nhập vào ghi chú của bạn về công trình này")
self.structuresInstance.append(instance)
self.currentIndex = len(self.structuresInstance) - 1
self.structuresData.append({
"position": {
"x": instance.position.x,
"y": instance.position.y,
"z": instance.position.z,
},
"note": note,
"filename": instance.filename,
"tags": tags,
})
return instance
pass
def spawnHouse(position, height, length):
# already available to them
direction = vec3.Vec3(1, 0, 0)
# allows a pupil to give the height
for j in range(0, height):
# number of walls to create from spawnline
for i in range(0, 4):
position = spawnLine(position, direction, length,
block.BRICK_BLOCK.id)
direction = util.turnVectorClockwise(direction)
# adds the height on to the next layer of the wall
position.y += 1
def prompt_graph_shell(self):
function = raw_input("y = ")
x = input("x position: ")
y = input("y position: ")
z = input("z position: ")
self.origin_pos = vec3.Vec3(x, y, z)
self.xMin = input("xMin: ")
self.xMax = input("xMax: ")
self.yMin = input("yMin: ")
self.yMax = input("yMax: ")
self.setup_graph()
self.draw_function(function)
def drawAxis():
print("Drawing Axis on Map")
colour = 13
drawX(vec3.Vec3(19, 3, 0), block.WOOL.id, colour)
spawnLine(vec3.Vec3(-6, 0, 0), vec3.Vec3(1, 0, 0), 21, colour,
block.GOLD_BLOCK.id)
colour = 3
drawY(vec3.Vec3(0, 17, 0), block.WOOL.id, colour)
spawnLine(vec3.Vec3(0, -6, 0), vec3.Vec3(0, 1, 0), 21, colour,
block.GOLD_BLOCK.id)
colour = 2
drawZ(vec3.Vec3(0, 5, 17), block.WOOL.id, colour)
spawnLine(vec3.Vec3(0, 0, -6), vec3.Vec3(0, 0, 1), 21, colour,
block.GOLD_BLOCK.id)
minecraft.setBlock(0, 0, 0, block.GOLD_BLOCK.id)
def prompt_graph_mc(self, function):
self.mc.postToChat(
"Right click the ground with your sword to spawn a graph with the origin at that point."
)
mc.postToChat("Graph will be " + str(self.xMax - self.xMin) +
" units long and " + str(self.yMax - self.yMin) +
" units tall.")
run = True
while (run == True):
evs = self.mc.events.pollBlockHits()
for e in evs:
self.origin_pos = vec3.Vec3(
e.pos.x, e.pos.y + ((self.yMax - self.yMin) / 2), e.pos.z)
self.setup_graph()
self.draw_function(function)
run = False
def BuildHouse(houseCenter,houseSize,mainMaterial):
xSize=houseSize.x
ySize=houseSize.y
zSize=houseSize.z
for i in range(-xSize,xSize+1):
for j in range(ySize):
setBlock(houseCenter+Vec3.Vec3(i,j,zSize),mainMaterial.id, 1)
setBlock(houseCenter+Vec3.Vec3(i,j,-zSize),mainMaterial.id, 1)
for i in range(-zSize,zSize+1):
for j in range(ySize):
setBlock(houseCenter+Vec3.Vec3(xSize,j,i),mainMaterial.id, 1)
setBlock(houseCenter+Vec3.Vec3(-xSize,j,i),mainMaterial.id, 1)
for i in range(-xSize,xSize+1):
for j in range(-zSize,zSize+1):
setBlock(houseCenter+Vec3.Vec3(i,ySize,j),block.AIR.id, 1)#top
setBlock(houseCenter+Vec3.Vec3(i,0,j),mainMaterial.id, 1)#bottom
halfX=int(xSize/2)
halfY=int(ySize/2)
halfZ=int(zSize/2)
sizeWindow=int(ySize/3)
for i in range(halfY-sizeWindow,halfY+1):
for j in range(-1,2):
setBlock(houseCenter+Vec3.Vec3(j,i,zSize),block.GLASS.id, 1)
def prompt_graph_mc_shell(self):
function = raw_input("y = ")
print("Waiting for user input in minecraft...")
self.prompt_graph_mc(function)
def prompt_graph_shell(self):
function = raw_input("y = ")
x = input("x position: ")
y = input("y position: ")
z = input("z position: ")
self.origin_pos = vec3.Vec3(x, y, z)
self.xMin = input("xMin: ")
self.xMax = input("xMax: ")
self.yMin = input("yMin: ")
self.yMax = input("yMax: ")
self.setup_graph()
self.draw_function(function)
def draw_function(self, function):
"""draws a function on the graph."""
x = self.xMin * 1.0
while (x < self.xMax):
y = eval(function)
self.plot_on_graph(x, y, 3)
x += self.step
my_graph = Graph(vec3.Vec3(0, 0, 0), -20, 20, -20, 20, mc)
my_graph.prompt_graph_mc_shell()
from mcpi import minecraft, block, vec3
from time import sleep
mc = minecraft.Minecraft.create()
ImHere = mc.player.getPos() # get current player position
for woolColor in range(15):
blockPosition = vec3.Vec3(ImHere.x - 2, ImHere.y, ImHere.z)
mc.setBlock(blockPosition, block.WOOL.id, woolColor)
sleep(1)
def deplacer_bloc(pos, direction):
new_pos = vec3.Vec3(pos.x + direction.x, pos.y + direction.y,
pos.z + direction.z)
creer_bloc(new_pos)
return new_pos
def choisir_direction():
return vec3.Vec3(randint(-1, 1), 0, randint(-1, 1))
def run(self):
## Clear some space
self.mc.setBlocks(self.groundsOrigin.x, self.groundsOrigin.y,
self.groundsOrigin.z,
self.groundsOrigin.x + self.groundsSize.x - 1,
self.groundsOrigin.y + self.groundsSize.y - 1,
self.groundsOrigin.z + self.groundsSize.z - 1,
block.AIR)
# Create a grounds (garden)
floorOrigin = vec3.Vec3(self.groundsOrigin.x, self.groundsOrigin.y - 1,
self.groundsOrigin.z)
self.mc.setBlocks(floorOrigin.x, floorOrigin.y, floorOrigin.z,
floorOrigin.x + self.groundsSize.x - 1,
floorOrigin.y,
floorOrigin.z + self.groundsSize.z - 1, block.GRASS)
time.sleep(self.delay)
# Build a house
houseOrigin = vec3.Vec3(self.groundsOrigin.x + 1, self.groundsOrigin.y,
self.groundsOrigin.z + 1)
self.mc.setBlocks(houseOrigin.x, houseOrigin.y, houseOrigin.z,
houseOrigin.x + self.houseSize.x - 1,
houseOrigin.y + self.houseSize.y - 1,
houseOrigin.z + self.houseSize.z - 1,
block.BRICK_BLOCK)
time.sleep(self.delay)
# Create a floor (inside only)
floorOrigin = vec3.Vec3(self.groundsOrigin.x, self.groundsOrigin.y - 1,
self.groundsOrigin.z)
self.mc.setBlocks(houseOrigin.x, houseOrigin.y - 1, houseOrigin.z,
houseOrigin.x + self.houseSize.x - 1,
houseOrigin.y - 1,
houseOrigin.z + self.houseSize.z - 1, block.STONE)
time.sleep(self.delay)
# Carve out house interior
houseInteriorOrigin = vec3.Vec3(houseOrigin.x + 1, houseOrigin.y,
houseOrigin.z + 1)
self.mc.setBlocks(houseInteriorOrigin.x, houseInteriorOrigin.y,
houseInteriorOrigin.z,
houseInteriorOrigin.x + self.houseSize.x - 3,
houseInteriorOrigin.y + self.houseSize.y - 1,
houseInteriorOrigin.z + self.houseSize.z - 3,
block.AIR)
time.sleep(self.delay)
# Carve out door
houseDoorOrigin = vec3.Vec3(houseOrigin.x + 2, houseOrigin.y,
houseOrigin.z)
self.mc.setBlocks(houseDoorOrigin.x, houseDoorOrigin.y,
houseDoorOrigin.z, houseDoorOrigin.x,
houseDoorOrigin.y + 1, houseDoorOrigin.z, block.AIR)
time.sleep(self.delay)
# Put a roof on
roofOrigin = vec3.Vec3(houseOrigin.x, houseOrigin.y + self.houseSize.y,
houseOrigin.z)
self.mc.setBlocks(roofOrigin.x, roofOrigin.y, roofOrigin.z,
roofOrigin.x + self.houseSize.x - 1, roofOrigin.y,
roofOrigin.z + self.houseSize.z - 1,
block.WOOD_PLANKS)
time.sleep(self.delay)
def createPortal(self):
# Create a portal at current position
x,y,z = mc.player.getPos() # get current player position
self.portalPosition = vec3.Vec3(x-2, y, z)
mc.setBlock(self.portalPosition, block.GLOWSTONE_BLOCK.id ) # complete list of block types at https://www.stuffaboutcode.com/p/minecraft-api-reference.html
self.portalAlert("{}: Created portal {}".format(self.color, self.portalNumber))
import mcpi.minecraft as minecraft
import mcpi.block as block
import mcpi.vec3 as vec3
import time
from HouseThread import HouseThread
# Set some constants
groundsSize = vec3.Vec3(8, 8, 10)
houseSize = vec3.Vec3(5, 3, 6)
countX = 5
countZ = 2
delay = 0.3
## Connect to Minecraft
mc = minecraft.Minecraft.create()
## Clear a big space
mc.setBlocks(-10, -10, -10, countX * groundsSize.x, groundsSize.y,
countZ * groundsSize.z, block.AIR)
# Create houses
for x in range(countX):
for z in range(countZ):
thisHouseOrigin = vec3.Vec3((x * groundsSize.x), 0,
(z * groundsSize.z))
HouseThread(delay, thisHouseOrigin, groundsSize, houseSize).start()
time.sleep(delay)
direction = vec3.Vec3(1, 0, 0)
# allows a pupil to give the height
for j in range(0, height):
# number of walls to create from spawnline
for i in range(0, 4):
position = spawnLine(position, direction, length,
block.BRICK_BLOCK.id)
direction = util.turnVectorClockwise(direction)
# adds the height on to the next layer of the wall
position.y += 1
# just calls the functions we want in order to build the house
#spawnLine(vec3.Vec3(30,0,0)
time.sleep(2)
spawnHouse(vec3.Vec3(0, 0, 0), 5, 10)
simpleRoof(vec3.Vec3(0, 5, 0), 10)
# building advanced roof, to iterate positively and negatively
def help(height):
if height < 0:
print("counting down")
return range(height, 0)
else:
print("counting up")
return range(0, height)
# advanced stuff - only advanced students should consider
def spawnAdvancedRoof(position, direction, height, length):
def simpleRoof(position, length):
for i in range(0, length):
spawnLine(vec3.Vec3(position.x + i, position.y, position.z - 1),
vec3.Vec3(0, 0, 1), 11, block.WOOD_PLANKS.id)
def turnVectorClockwise(vector):
vector = vec3.Vec3(-vector.z, vector.y, vector.x)
return vector
import binvox_rw
import mcpi.block as block
import mcpi.vec3 as vec3
from mcpi.minecraft import Minecraft
import time
mc=Minecraft.create()
pos=vec3.Vec3()
pos.x = 9
pos.y = 15
pos.z = 102
clanPoss = [[0,0,0],[60,0,0],[60,0,60],[0,0,60]]
logoPoss=[[10,0,20],[10,0,20],[10,0,20],[10,0,20]]
logobinvox=["donut.binvox","guidaopao.binvox","mickey__mouse_hoofd.binvox","nanhun.binvox"]
mc.setBlocks(pos.x-10,pos.y,pos.z-10,pos.x+200,pos.y+40,pos.z+200,0)
#mc.setBlocks(pos.x-10,pos.y-1,pos.z-10,pos.x+120,pos.y,pos.z+120,1)
f = open("clanlist.csv","r")
data = f.read()
list_elements = data.split("\n")
clan_data=[]
for row in list_elements:
split_list = row.split(',')
clan_data.append(split_list)
class House:
from mcpi.minecraft import Minecraft
import time
import mcpi.vec3 as vec3
mc=Minecraft.create("192.168.0.155",4711)
pos=vec3.Vec3(1,15,102)
a=0
b=0
x0=pos.x
y0=pos.y
z0=pos.z
def bomb (x0,y0,z0):
for y in range(1):
for x in range(1):
for z in range(1):
mc.setBlock(x0+x,y0+y,z0+z,46)
for x in range(1):
for z in range(1):
mc.setBlock(pos.x+x+a,pos.y+1,pos.z+z,51)
for b in range(1000):
if a <= 500:
house(x0+a,y0,z0)
a = a+5
time.sleep(0.5)
class House:
vecZero = Vec3.Vec3(0, 0, 0)
houseCenter = None
houseSize = None
mainMaterial = None
built = False
def __init__(self,
houseCenter=None,
houseSize=None,
buildNow=False,
material=materialList[0],
song=1,
useSerialport=True):
print(houseCenter, houseSize)
if houseCenter:
self.houseCenter = houseCenter
if houseSize:
self.houseSize = houseSize
if material:
self.mainMaterial = material
self.useSerialport = useSerialport
if buildNow:
self.build()
self.song = song
def _setBlock(self, vec, blockType, blockData):
mc.setBlock(vec.x, vec.y, vec.z, blockType, blockData)
def _getVec3(self, x, y, z):
return Vec3.Vec3(x, y, z)
def _build(self, mainMaterial, material2):
xSize = houseSize.x
ySize = houseSize.y
zSize = houseSize.z
for i in range(-xSize, xSize + 1):
for j in range(ySize):
self._setBlock(self.houseCenter + self._getVec3(i, j, zSize),
mainMaterial.id, 1)
self._setBlock(self.houseCenter + self._getVec3(i, j, -zSize),
mainMaterial.id, 1)
for i in range(-zSize, zSize + 1):
for j in range(ySize):
self._setBlock(self.houseCenter + self._getVec3(xSize, j, i),
mainMaterial.id, 1)
self._setBlock(self.houseCenter + self._getVec3(-xSize, j, i),
mainMaterial.id, 1)
for i in range(-xSize, xSize + 1):
for j in range(-zSize, zSize + 1):
self._setBlock(self.houseCenter + self._getVec3(i, ySize, j),
block.AIR.id, 1) #top
self._setBlock(self.houseCenter + self._getVec3(i, 0, j),
mainMaterial.id, 1) #bottom
halfY = int(ySize / 2)
sizeWindow = int(ySize / 3)
for i in range(halfY - sizeWindow, halfY + 1):
for j in range(-1, 2):
self._setBlock(self.houseCenter + self._getVec3(j, i, zSize),
material2.id, 1)
def changeMaterial(self, material):
self.mainMaterial = material
if self.built:
self.build()
def build(self):
if not (self.houseCenter and self.houseSize and self.mainMaterial):
raise RoomException
self._build(self.mainMaterial, block.GLASS)
self.built = True
def destroy(self):
if self.built:
self._build(block.AIR, block.AIR)
self.built = False
else: #not built yet
pass
def _getPlayerPos(self):
return mc.player.getTilePos()
def ifPlayerIn(self):
if not self.built:
return False
playerPos = self._getPlayerPos()
# print(playerPos)
# print(self.houseSize)
if not (playerPos.y > (self.houseCenter.y) and playerPos.y <
(self.houseCenter.y + self.houseSize.y - 2)):
return False
elif not (playerPos.x > self.houseCenter.x - self.houseSize.x
and playerPos.x < self.houseCenter.x + self.houseSize.x):
# print("not X")
return False
elif not (playerPos.z > self.houseCenter.z - self.houseSize.z
and playerPos.z < self.houseCenter.z + self.houseSize.z):
# print("not Z")
return False
else:
if self.useSerialport:
byteData = bytes([self.song])
ser.write(byteData)
ser.flush()
return True
def ChangeSong(self, newSong):
self.song = newSong
from mcpi.minecraft import Minecraft
import binvox_rw
import time
import csv
import mcpi.vec3 as vec3
import mcpi.block as block
import Jeff.build_house_hawaiistyle as MHouse
mc = Minecraft.create()
#pos=mc.player.getTilePos()
pos = vec3.Vec3(86, 47, 67)
mc.player.setTilePos(86, 47, 67)
stayed_time = 0
with open('xjergao.binvox', 'rb') as f:
model = binvox_rw.read_as_3d_array(f)
print(model.dims)
print(model.scale)
print(model.translate)
#print(model.data)
for y in range(model.dims[1]):
print("layer y=", y)
layer_data = model.data[y]
stringlayer = ""
for x in range(model.dims[0]):
stringlayer = stringlayer + "\n"
for z in range(model.dims[2]):
if model.data[x][z][y] == True:
def _getVec3(self, x, y, z):
return Vec3.Vec3(x, y, z)
def __init__(self, thePortalNumber, theColor):
self.portalNumber = thePortalNumber
self.portalPosition = vec3.Vec3(0,0,0)
self.color = theColor
portalState.setPortal(self.portalNumber, False)
self.portalAlert("Ready to create portal {}".format(self.portalNumber), theColor = 'white')
def fireCannon(position, direction):
position = addVectors(position, direction)
hit = False
while not (hit):
time.sleep(0.1)
minecraft.setBlock(position.x, position.y, position.z, block.AIR.id)
position = addVectors(position, direction)
if not (minecraft.getBlock(position.x, position.y, position.z)
== block.AIR.id):
hit = True
minecraft.setBlock(position.x, position.y, position.z,
block.IRON_BLOCK.id)
explosion(position)
return position
def explosion(position):
minecraft.setBlock(position.x, position.y, position.z, block.AIR.id)
minecraft.setBlock(position.x + 1, position.y, position.z, block.AIR.id)
minecraft.setBlock(position.x - 1, position.y, position.z, block.AIR.id)
minecraft.setBlock(position.x, position.y + 1, position.z, block.AIR.id)
minecraft.setBlock(position.x, position.y - 1, position.z, block.AIR.id)
minecraft.setBlock(position.x, position.y, position.z + 1, block.AIR.id)
minecraft.setBlock(position.x, position.y, position.z - 1, block.AIR.id)
playerPos = minecraft.player.getPos()
fireCannon(playerPos, vec3.Vec3(1, 0, 0))
def Lau():
# créé un bloc de laine de couleur aléatoire à la position
def creer_bloc(pos):
couleur = randint(0, 15)
mc.setBlock(pos.x, pos.y, pos.z, 35, couleur)
# teste si un bloc particulier existe autour d'une position
def existe_autour(pos, id_block):
for x in range(-1, 2):
for y in range(-1, 2):
for z in range(-1, 2):
if mc.getBlock(pos.x + x, pos.y + y,
pos.z + z) == id_block:
return True
return False
# transforme les blocs d'un type présent dans id_blocks_src autour d'une position par un block spécifique + affichage d'un message
def transforme_autour(pos, id_blocks_src, id_block_dest, message):
for x in range(-1, 2):
for y in range(-1, 2):
for z in range(-1, 2):
if mc.getBlock(pos.x + x, pos.y + y,
pos.z + z) in id_blocks_src:
mc.setBlock(pos.x + x, pos.y + y, pos.z + z,
id_block_dest)
mc.postToChat(message)
# créé un vecteur définissant une direction horizontale spécifique
def choisir_direction():
return vec3.Vec3(randint(-1, 1), 0, randint(-1, 1))
# déplace le bloc d'une position dans une direction
def deplacer_bloc(pos, direction):
new_pos = vec3.Vec3(pos.x + direction.x, pos.y + direction.y,
pos.z + direction.z)
creer_bloc(new_pos)
return new_pos
pos = vec3.Vec3(randint(-30, 30), -1, randint(-30, 30))
creer_bloc(pos)
print(pos)
mc.postToChat("-=-= lancement evap'eau =-=-")
pos_prec = pos
direction = vec3.Vec3(0, 0, 0)
nombre_deplacement = 0
while not existe_autour(pos, 103):
# pas de pastèque à proximité immédiate
# l'eau est transformée en air
transforme_autour(pos, [8, 9], 0, "pouf! evaporee...")
# changement de direction tous les 10 déplacements
if nombre_deplacement % 10 == 0:
direction = choisir_direction()
# on garde deux blocs pour la plaie, le bloc précédent est remplacé par une paquerette
if pos_prec != pos:
mc.setBlock(pos_prec.x, pos_prec.y, pos_prec.z, 37)
pos_prec = pos
pos = deplacer_bloc(pos_prec, direction)
nombre_deplacement = nombre_deplacement + 1
time.sleep(1)
mc.postToChat("-=-= evap'eau terminee =-=-")
import mcpi.minecraft as minecraft
import mcpi.block as block
import mcpi.vec3 as Vec3
mc = minecraft.Minecraft.create()
#pos = mc.player.getTilePos()#player location
pos=Vec3.Vec3(-6,0,49)
def setBlock(vec,blockType,blockData):
mc.setBlock(vec.x,vec.y,vec.z,blockType, blockData)
vecForward=pos+Vec3.Vec3(2,0,3)
blockType = mc.getBlock(pos)
print(pos)
mc.events.pollChatPosts
houseX=8
houseZ=6
houseY=6
for i in range(-houseX-90,houseX+90):
for j in range(8):
for k in range(-houseZ-90,houseZ+90):
pass
#setBlock(pos+Vec3.Vec3(i,j,k),block.AIR.id, 1)
for i in range(-houseX-90,houseX+90):
for j in range(-1,0):
for k in range(-houseZ-90,houseZ+90):
pass
#setBlock(pos+Vec3.Vec3(i,j,k),block.DIRT.id, 3)
def BuildHouse(houseCenter,houseSize,mainMaterial):
