def exposed(self, position):
"""Returns False is given `position` is surrounded on all 6 sides by solid
blocks, True otherwise.
"""
bcx, _, bcz = mathhelper.sectorize(position)
basechunkprovider = G.player.dimension.worldprovider.getChunkProviderFor(
(bcx, bcz))
flag1 = basechunkprovider.generated
x, y, z = position
for dx in range(-1, 2):
for dy in range(-1, 2):
for dz in range(-1, 2):
if [dx, dy, dz].count(0) > 1 and not dx == dy == dz == 0:
nx, ny, nz = x + dx, y + dy, z + dz
cx, _, cz = mathhelper.sectorize((nx, ny, nz))
chunkprovider = (G.player.dimension.worldprovider.
getChunkProviderFor((cx, cz)))
if (((nx, ny, nz) not in chunkprovider.world
or G.GAMESTAGE != 3 or not chunkprovider.world[
(nx, ny, nz)].isFullBlock()) and
(nx, ny, nz) not in G.BlockGenerateTasks
) and not (flag1 and not chunkprovider.generated):
return True
else:
pass
# log.printMSG((nx, ny, nz) not in chunkprovider.world,
# mathhelper.sectorize((nx, ny, nz)) in G.player.dimension.worldprovider.chunks,
# (nx, ny, nz) not in G.BlockGenerateTasks)
return False
def update(self, dt):
"""This method is scheduled to be called repeatedly by the pyglet
clock.
Parameters
----------
dt : float
The change in time since the last call.
"""
G.model.process_queue()
sector = mathhelper.sectorize(self.position)
if (sector != self.sector
and G.statehandler.active_state.getName() == "minecraft:game"):
G.model.change_sectors(self.sector, sector)
if self.sector is None:
G.model.process_entire_queue()
self.sector = sector
m = 8
dt = min(dt, 0.2)
for _ in range(m):
self._update(dt / m)
for entity in G.entityhandler.entitys:
entity.update(dt)
G.eventhandler.call("core:update")
if G.statehandler.active_state.getName() == "minecraft:game":
self.time += dt * 20
self.day += round(self.time // 24000)
self.time = round(self.time % 24000)
if G.GAMESTAGE != 3:
return
i = 0
max = len(G.BlockGenerateTasks)
l = list(G.BlockGenerateTasks.keys())
t = time.time()
for position in l:
G.model.add_block(position,
G.BlockGenerateTasks[position][0],
immediate=True)
task = G.BlockGenerateTasks[position]
if len(task) > 1:
task = task[1:]
while len(task) > 0:
st = task.pop(0)
cx, _, cz = mathhelper.sectorize(position)
chunkprovider = (
G.player.dimension.worldprovider.getChunkProviderFor(
(cx, cz)))
if st == "sdata":
chunkprovider.world[position].setStorageData(
task.pop(0))
else:
log.printMSG("[TASKS][ERROR] unknown subtask " +
str(st))
del G.BlockGenerateTasks[position]
if time.time() - t > 0.1:
return
def draw_label(self):
"""Draw the label in the top left of the screen."""
x, y, z = G.window.position
self.label1.text = "%02d (%.2f, %.2f, %.2f) %d" % (
pyglet.clock.get_fps(),
x,
y,
z,
len(G.player.dimension.worldprovider.chunkproviders),
)
vector = G.window.get_sight_vector()
block, _ = G.model.hit_test(G.window.position, vector)
if block:
cx, _, cz = mathhelper.sectorize(block)
chunkprovider = G.player.dimension.worldprovider.getChunkProviderFor(
(cx, cz))
else:
chunkprovider = None
self.label1.text += (
"; looking at: " + str(block) +
("" if not block or block not in chunkprovider.world else " - " +
str(chunkprovider.world[block].getName())))
nx, ny, nz = mathhelper.normalize(G.window.position)
self.label1.y = G.window.height - 10
self.label1.draw()
self.label2.y = G.window.height - 25
self.label2.text = ("daytime: " + str(round(G.window.time)) +
"; day: " + str(G.window.day))
self.label2.draw()
def hit_test(self, position, vector, max_distance=8):
"""Line of sight search from current position. If a block is
intersected it is returned, along with the block previously in the line
of sight. If no block is found, return None, None.
Parameters
----------
position : tuple of len 3
The (x, y, z) position to check visibility from.
vector : tuple of len 3
The line of sight vector.
max_distance : int
How many blocks away to search for a hit.
"""
m = 8
x, y, z = position
dx, dy, dz = vector
previous = None
for _ in range(max_distance * m):
key = mathhelper.normalize((x, y, z))
cx, _, cz = mathhelper.sectorize(key)
if (key != previous and key
in G.player.dimension.worldprovider.getChunkProviderFor(
(cx, cz)).world):
return key, previous
previous = key
x, y, z = x + dx / m, y + dy / m, z + dz / m
return None, None
def change_sectors(self, before, after):
"""Move from sector `before` to sector `after`. A sector is a
contiguous x, y sub-region of world. Sectors are used to speed up
world rendering.
"""
before_set = set()
after_set = set()
pad = 4
for dx in range(-pad, pad + 1):
for dy in [0]: # range(-pad, pad + 1):
for dz in range(-pad, pad + 1):
if dx**2 + dy**2 + dz**2 > (pad + 1)**2:
continue
if before:
x, y, z = before
before_set.add((x + dx, y + dy, z + dz))
if after:
x, y, z = after
after_set.add((x + dx, y + dy, z + dz))
show = after_set - before_set
hide = before_set - after_set
for sector in show:
self.show_sector(sector)
for sector in hide:
self.hide_sector(sector)
if not after:
after = mathhelper.sectorize(G.window.position)
sector = after
def past(self, chunkprovider, r, x, y, z):
xrot = r.generateValueForPosition((x, y - 1000, z), -90, 90)
yrot = r.generateValueForPosition((x, y - 1001, z), -90, 90)
zrot = r.generateValueForPosition((x, y - 1002, z), -90, 90)
xlenght = r.generateValueForPosition(
(x, y - 1003, z), self.getMinSize(self) / 2, self.getMaxSize(self) / 2
)
ylenght = r.generateValueForPosition(
(x, y - 1004, z), self.getMinSize(self) / 2, self.getMaxSize(self) / 2
)
zlenght = r.generateValueForPosition(
(x, y - 1005, z), self.getMinSize(self) / 2, self.getMaxSize(self) / 2
)
if xlenght == 0 or ylenght == 0 or zlenght == 0:
return # this orevein is empty
for dx in range(-xlenght, xlenght + 1):
for dy in range(-ylenght, ylenght + 1):
for dz in range(-zlenght, zlenght + 1):
mx, my, mz = _rotatepoint(x, y, z, xrot, yrot, zrot)
if (mx * mx) / (xlenght * xlenght) + (my * my) / (
ylenght * ylenght
) + (mz * mz) / (
zlenght * zlenght
) <= 1: # valid position
# if (x+dx, y+dy, z+dz) in chunkprovider.generationcache["blocks"] and \
# chunkprovider.generationcache["blocks"][(x + dx, y + dy, z + dz)] in \
# self.getReplaceAbleBlocks(self):
cx, _, cz = mathhelper.sectorize((x + dx, 0, z + dz))
chunkprovider = chunkprovider.worldprovider.getChunkProviderFor(
(cx, cz)
)
if chunkprovider.generated:
chunkprovider.generationcache["blocks"][
(x + dx, y + dy, z + dz)
] = self.getOreName(self)
def on_tick_update(self, inst):
(x, y, z) = inst.position
cx, _, cz = mathhelper.sectorize(inst.position)
chunkprovider = G.player.dimension.worldprovider.getChunkProviderFor((cx, cz))
if not (x, y - 1, z) in chunkprovider.world and y > 0:
G.model.add_block((x, y - 1, z), inst)
G.model.remove_block((x, y, z))
inst.blocked = False
def on_block_update(self, inst):
(x, y, z) = inst.position
cx, _, cz = mathhelper.sectorize(inst.position)
chunkprovider = G.player.dimension.worldprovider.getChunkProviderFor(
(cx, cz))
if (not (x, y - 1, z) in chunkprovider.world and y > 0
and not (hasattr(inst, "blocked") and not inst.blocked)):
inst.blocked = True
G.tickhandler.tick(self.on_tick_update, args=[inst], tick=4)
def getStorageData(self, inst):
"""returns the data that should be stored. should be storeable by pickle"""
cx, _, cz = mathhelper.sectorize(inst.position)
chunkprovider = G.player.dimension.worldprovider.getChunkProviderFor(
(cx, cz))
return {
"name": self.getName(),
"data": inst.data,
"shown": inst.position in chunkprovider.shown,
}
def block_update(self, position):
cx, _, cz = mathhelper.sectorize(position)
chunkprovider = G.player.dimension.worldprovider.getChunkProviderFor(
(cx, cz))
x, y, z = position
for dx, dy, dz in config.FACES:
key = (x + dx, y + dy, z + dz)
if key in chunkprovider.world:
chunkprovider.world[key].on_block_update()
if position in chunkprovider.world:
chunkprovider.world[position].on_block_update()
def generate(self):
if not self.chunkprovider.generated:
raise RuntimeError()
biomes = []
biomeamount = {}
for x, z in self.chunkprovider.generationcache["biomemap"].keys():
biome = G.biomehandler.biomes[
self.chunkprovider.generationcache["biomemap"][(x, z)]
]
if not biome in biomes:
biomes.append(biome)
biomeamount[biome] = 1
else:
biomeamount[biome] += 1
veintable = {} # vein -> percent of chunk
for biome in biomes:
oreveins = biome.getOreVeins()
for vein in oreveins:
if not vein in self.generationtable:
self.generationtable[vein] = 0
veintable[vein] = (
biomeamount[biome] * vein.getChunkAmount(vein) / 256
)
else:
veintable[vein] += (
biomeamount[biome] * vein.getChunkAmount(vein) / 256
)
for orevein in self.generationtable.keys():
while self.generationtable[orevein] < veintable[orevein]:
x = self.random.generateValueForPosition(
(self.chunk[0] * 16, -12, self.chunk[1] * 16), 0, 15
)
x += self.chunkprovider.chunk[0] * 16
z = self.random.generateValueForPosition(
(self.chunk[0] * 16, -14, self.chunk[1] * 16), 0, 15
)
z += self.chunkprovider.chunk[1] * 16
cx, _, cz = mathhelper.sectorize((x, 0, z))
chunkprovider = self.chunkprovider.worldprovider.getChunkProviderFor(
(cx, cz)
)
if chunkprovider.generated:
y = self.random.generateValueForPosition(
(x, -13, z),
0,
chunkprovider.generationcache["highmap"][(x, z)] - 5,
)
biome = G.biomehandler.biomes[
chunkprovider.generationcache["biomemap"][(x, z)]
]
if orevein in biome.getOreVeins():
self.generationtable[orevein] += 1
orevein.past(orevein, self.chunkprovider, self.random, x, y, z)
def on_redstone_update(self, inst):
x, y, z = inst.position
flag = False
for dx, dy, dz, face in SURROUNDING:
px, py, pz = x + dx, y + dy, z + dz
cx, _, cz = mathhelper.sectorize((px, py, pz))
chunkprovider = G.player.dimension.worldprovider.getChunkProviderFor(
(cx, cz)
)
if (px, py, pz) in chunkprovider.world and chunkprovider.world[
(px, py, pz)
].getErmittedRedstoneSignal(face) > 0:
flag = True
if flag:
self.light(inst)
def generateHighMapToChunkProvider(self, chunk):
"""
this function should renamed to something like debugblockselector
"""
if len(BLOCKTABLE) != 0:
return
blocks = list(G.blockhandler.blocks.keys())
blocks.sort()
blocks.remove("minecraft:none")
xr = math.ceil(math.sqrt(len(blocks)) / 2) * 2 + 1
for x in range(-round(xr / 2), round(xr / 2)):
for y in range(-round(xr / 2), round(xr / 2)):
index = (xr + x) * xr + xr + y
if len(blocks) > index:
block = blocks[index]
cx, _, cz = mathhelper.sectorize((x, 0, y))
if (cx, cz) not in BLOCKTABLE:
BLOCKTABLE[(cx, cz)] = {}
BLOCKTABLE[(cx, cz)][(x * 4, 5, y * 4)] = block
def hide_block(self, position, block, immediate=True):
"""Hide the block at the given `position`. Hiding does not remove the
block from the world.
Parameters
----------
position : tuple of len 3
The (x, y, z) position of the block to hide.
immediate : bool
Whether or not to immediately remove the block from the canvas.
"""
cx, _, cz = mathhelper.sectorize(position)
chunkprovider = G.player.dimension.worldprovider.getChunkProviderFor(
(cx, cz))
if not position in chunkprovider.shown:
return
chunkprovider.shown.pop(position)
if immediate:
self._hide_block(position, block)
else:
self._enqueue(self._hide_block, position, block)
def add_block(self, position, texture, immediate=True, blocksettedto=None):
"""Add a block with the given `texture` and `position` to the world.
Parameters
----------
position : tuple of len 3
The (x, y, z) position of the block to add.
texture : list of len 3
The coordinates of the texture squares. Use `tex_coords()` to
generate.
immediate : bool
Whether or not to draw the block immediately.
"""
if position[1] < 0 or position[1] > 255:
return
cx, _, cz = mathhelper.sectorize(position)
chunkprovider = G.player.dimension.worldprovider.getChunkProviderFor(
(cx, cz))
if position in chunkprovider.world:
self.remove_block(position, immediate)
if texture in ["air", "minecraft:air"]:
return
if not type(texture) == G.blockinst:
# todo: re-add blocksettedto
block = G.blockhandler.getInst(
texture, position) # , blocksettedto=blocksettedto)
else:
block = texture
block.position = position
if not block:
return
chunkprovider.world[position] = block
if immediate:
if self.exposed(position):
self.show_block(position)
self.check_neighbors(position)
if G.GAMESTAGE == 3:
self.block_update(position)
def check_neighbors(self, position):
"""Check all blocks surrounding `position` and ensure their visual
state is current. This means hiding blocks that are not exposed and
ensuring that all exposed blocks are shown. Usually used after a block
is added or removed.
"""
x, y, z = position
for dx in range(-1, 2):
for dy in range(-1, 2):
for dz in range(-1, 2):
if [dx, dy, dz].count(0) == 1:
key = (x + dx, y + dy, z + dz)
cx, _, cz = mathhelper.sectorize(key)
chunkprovider = (G.player.dimension.worldprovider.
getChunkProviderFor((cx, cz)))
if key not in chunkprovider.world:
continue
if not self.exposed(key):
self.show_block(position)
else:
self.hide_block(key, chunkprovider.world[key])
def show_block(self, position, immediate=True, test=True):
"""Show the block at the given `position`. This method assumes the
block has already been added with add_block()
Parameters
----------
position : tuple of len 3
The (x, y, z) position of the block to show.
immediate : bool
Whether or not to show the block immediately.
"""
cx, _, cz = mathhelper.sectorize(position)
chunkprovider = G.player.dimension.worldprovider.getChunkProviderFor(
(cx, cz))
if not position in chunkprovider.world:
return
block = chunkprovider.world[position]
chunkprovider.shown[position] = block
if immediate and not (test and not self.exposed(position)):
self._show_block(position, block)
elif not immediate and not (test and not self.exposed(position)):
self._enqueue(self._show_block, position, block)
def remove_block(self, position, immediate=True):
"""Remove the block at the given `position`.
Parameters
----------
position : tuple of len 3
The (x, y, z) position of the block to remove.
immediate : bool
Whether or not to immediately remove block from canvas.
"""
cx, _, cz = mathhelper.sectorize(position)
chunkprovider = G.player.dimension.worldprovider.getChunkProviderFor(
(cx, cz))
if position not in chunkprovider.world:
return
chunkprovider.world[position].delete()
if immediate:
if position in chunkprovider.shown:
self.hide_block(position, chunkprovider.world[position])
self.check_neighbors(position)
self.block_update(position)
del chunkprovider.world[position]
def show(self, batch, blockinst):
position = blockinst.position
cx, _, cz = mathhelper.sectorize(position)
chunkprovider = G.player.dimension.worldprovider.getChunkProviderFor(
(cx, cz))
if len(blockinst.showndata) > 0:
self.hide(batch, blockinst)
if not G.model.exposed(blockinst.position):
return
if not blockinst.position in chunkprovider.world:
return
x, y, z = blockinst.position
vertex_data = chunkprovider.world[blockinst.position].getCubeVerticens(
*list(chunkprovider.world[blockinst.position].
convertPositionToRenderable(blockinst.position)) + [0.5])
textureatlas = G.textureatlashandler.atlases[
self.model.indexes[0][0] if hasattr(self.model.
indexes[0], "__getitem__"
) else G.textureatlashandler.
indexarray[self.model.indexes[0]][0]]
texture_data = text_coords_complex(*[
self.model.indexes[i][1][1]
if hasattr(self.model.indexes[i][1][1], "__getitem__") else
self.model.indexes[i][1] for i in self.entry["sides"]
],
n1=16,
n2=16)
# create vertex list
# FIXME Maybe `add_indexed()` should be used insteads
blockinst.showndata.append(
batch.add(
24,
pyglet.gl.GL_QUADS,
textureatlas.pyglet_atlas,
("v3f/static", vertex_data),
("t2f/static", texture_data),
))
def on_event(self, name, *args):
if name == "opengl:draw3d":
t = G.window.time + 12000 if G.window.time < 12000 else G.window.time
w = (24000 - G.window.time) / 24000
pyglet.gl.glClearColor(0.5 * w, 0.69 * w, 1.0 * w, 1 * w)
pyglet.gl.glColor3d(w, w, w)
# draw with alpha - alpha setup
pyglet.gl.glEnable(pyglet.gl.GL_BLEND)
pyglet.gl.glBlendFunc(pyglet.gl.GL_SRC_ALPHA,
pyglet.gl.GL_ONE_MINUS_SRC_ALPHA)
# end alpha setup
G.player.dimension.worldprovider.batch.draw()
self.draw_focused_block()
elif name == "opengl:draw2d":
self.draw_label()
self.draw_reticle()
G.inventoryhandler.draw()
G.player.on_draw()
elif name == "core:window:on_resize":
# label
self.label1.y = G.window.height - 10
self.label2.y = G.window.height - 25
# reticle
if self.reticle:
self.reticle.delete()
x, y = G.window.width // 2, G.window.height // 2
n = 10
self.reticle = pyglet.graphics.vertex_list(
4, ("v2i", (x - n, y, x + n, y, x, y - n, x, y + n)))
elif name == "core:window:on_key_release":
symbol, modifiers = args
if G.chat.active:
G.window.strafe = [0, 0]
return
if symbol == config.Keyboard.WALK_FORWARD:
G.window.strafe[0] += 1
elif symbol == config.Keyboard.WALK_BACKWARD:
G.window.strafe[0] -= 1
elif symbol == config.Keyboard.WALK_LEFT:
G.window.strafe[1] += 1
elif symbol == config.Keyboard.WALK_RIGHT:
G.window.strafe[1] -= 1
elif name == "core:window:on_key_press":
symbol, modifiers = args
if G.chat.active:
G.chat.on_key_press(symbol, modifiers)
return
if any([
G.inventoryhandler.inventorys[inventory].isDisablyingGame(
) for inventory in G.inventoryhandler.activeinventorys
]):
log.printMSG([(
G.inventoryhandler.inventorys[inventory],
G.inventoryhandler.inventorys[inventory].isDisablyingGame(
),
) for inventory in G.inventoryhandler.activeinventorys])
if symbol == key.ESCAPE:
for e in G.inventoryhandler.activeated:
inv = G.inventoryhandler.inventorys[e]
log.printMSG(inv)
if "system:nothideable" not in inv.tag:
G.inventoryhandler.hide_inventory(e)
else:
inv.on_try_close()
else:
for e in G.inventoryhandler.activeated:
inv = G.inventoryhandler.inventorys[e]
inv.on_key_press(*args)
return
if symbol == config.Keyboard.WALK_FORWARD:
G.window.strafe[0] -= 1
elif symbol == config.Keyboard.WALK_BACKWARD:
G.window.strafe[0] += 1
elif symbol == config.Keyboard.WALK_LEFT:
G.window.strafe[1] -= 1
elif symbol == config.Keyboard.WALK_RIGHT:
G.window.strafe[1] += 1
elif symbol == config.Keyboard.JUMP:
if G.window.dy == 0:
G.window.dy = config.Physiks.JUMP_SPEED
elif symbol == config.Keyboard.CLOSE:
if G.window.player.inventory.guitype == 1:
G.window.player.inventory.guitype = 0
G.window.set_exclusive_mouse(True)
G.inventoryhandler.hide_inventory(G.player.inventory.id)
G.inventoryhandler.show_inventory(G.player.inventory.id)
elif G.chat.active:
G.inventoryhandler.hide_inventory(G.chat.id)
G.window.set_exclusive_mouse(True)
G.chat.active = False
elif len(G.inventoryhandler.activeinventorys) > 3:
for e in G.inventoryhandler.activeinventorys:
e = G.inventoryhandler.inventorys[e]
if not "player:inventory" in e.tag:
G.inventoryhandler.hide_inventory(e.id)
else:
if G.window.worldname:
G.commandhandler.executeCommand("/save", None, None)
G.statehandler.setState("minecraft:escape_menu")
elif symbol == config.Keyboard.TOGGLE_FLYING and G.player.gamemode == 1:
G.window.flying = not G.window.flying
elif symbol in G.window.num_keys:
index = (symbol - G.window.num_keys[0]) % 9
G.player.selectedinventoryslot = index
elif symbol == config.Keyboard.OPEN_INVENTORY:
if G.window.player.inventory.guitype == 1:
G.window.player.inventory.guitype = 0
G.window.set_exclusive_mouse(True)
G.inventoryhandler.hide_inventory(
G.window.player.inventory.id)
G.inventoryhandler.show_inventory(
G.window.player.inventory.id)
for e in G.player.inventory.inventorys[1:]:
return G.player.checkinventorysforslots.remove(e)
else:
G.window.player.inventory.guitype = 1
G.window.set_exclusive_mouse(False)
G.inventoryhandler.hide_inventory(
G.window.player.inventory.id)
G.inventoryhandler.show_inventory(
G.window.player.inventory.id)
G.player.checkinventorysforslots += G.player.inventory.inventorys[
1:]
elif symbol == config.Keyboard.OPEN_CHAT:
G.inventoryhandler.show_inventory(G.chat.id)
elif name == "core:window:on_mouse_motion":
x, y, dx, dy = args
if G.player.inventory.inventorys[0].type == 1:
G.player.on_mouse_motion(x, y, dx, dy)
return
if any([
G.inventoryhandler.inventorys[inventory].isDisablyingGame(
) for inventory in G.inventoryhandler.activeinventorys
]):
G.player.on_mouse_motion(*args)
return
if G.window.exclusive:
m = config.Physiks.MOUSE_REAKTION
x, y = G.window.rotation
x, y = x + dx * m, y + dy * m
y = max(-90, min(90, y))
G.window.rotation = (x, y)
elif name == "core:window:on_mouse_press":
x, y, button, modifiers = args
if G.player.inventory.inventorys[0].type == 1:
G.player.on_mouse_press(x, y, button, modifiers)
return
if any([
G.inventoryhandler.inventorys[inventory].
shouldInteractWithPlayerInventoryMoving()
for inventory in G.inventoryhandler.activeinventorys
]):
G.player.on_mouse_press(*args)
return
if G.window.exclusive:
vector = G.window.get_sight_vector()
block, previous = G.model.hit_test(G.window.position, vector)
if (button == mouse.RIGHT) or ((button == mouse.LEFT) and
(modifiers & key.MOD_CTRL)):
chunkprovider = chunkprovider2 = None
if previous:
cx, _, cz = mathhelper.sectorize(previous)
chunkprovider = (G.player.dimension.worldprovider.
getChunkProviderFor((cx, cz)))
if block:
cx, _, cz = mathhelper.sectorize(block)
chunkprovider2 = (G.player.dimension.worldprovider.
getChunkProviderFor((cx, cz)))
# ON OSX, control + left click = right click.
if (previous and G.player.inventory.inventorys[0].slots[
G.player.selectedinventoryslot].stack
and G.player.inventory.inventorys[0].slots[
G.player.selectedinventoryslot].stack.item
and G.player.inventory.inventorys[0].slots[
G.player.selectedinventoryslot].stack.item.
hasBlock() and
not chunkprovider2.world[block].isOpeningInventory(
G.player.inventory.inventorys[0].slots[
G.player.selectedinventoryslot].stack)):
G.model.add_block(
previous,
G.player.inventory.inventorys[0].slots[
G.player.selectedinventoryslot].stack.item.
getBlockName(),
blocksettedto=block,
)
G.model.check_neighbors(previous)
if not G.model.exposed(previous):
G.model.show_block(previous)
G.eventhandler.call(
"game:on_block_add_by_player",
vector,
block,
previous,
G.player.inventory.inventorys[0].slots[
G.player.selectedinventoryslot].stack.item.
getBlockName(),
)
chunkprovider.world[previous].blocksettedto = block
if G.player.gamemode != 1:
G.player.inventory.inventorys[0].slots[
G.player.
selectedinventoryslot].stack.amount -= 1
block = chunkprovider.world[previous]
G.soundhandler.playSound(previous,
block.getBrakeSoundFile())
elif (block and chunkprovider
and chunkprovider.world[block].isOpeningInventory(
G.player.inventory.inventorys[0].slots[
G.player.selectedinventoryslot].stack)):
# log.printMSG(chunkprovider.world[block], chunkprovider.world[block].blockclass, chunkprovider.world[block].getInventorys())
for e in chunkprovider.world[block].getInventorys():
G.inventoryhandler.show_inventory(e if type(e) ==
int else e.id)
# log.printMSG(e if type(e) == int else e.id)
elif button == pyglet.window.mouse.LEFT and block:
cx, _, cz = mathhelper.sectorize(block)
chunkprovider = (
G.player.dimension.worldprovider.getChunkProviderFor(
(cx, cz)))
block = chunkprovider.world[block]
if block.isBrakeAbleInGamemode0(
) or G.player.gamemode == 1:
G.soundhandler.playSound(block.position,
block.getBrakeSoundFile())
if G.player.gamemode != 1:
drops = block.getDrop()
for e in drops.keys():
G.player.addToInventory(e, drops[e])
else:
drops = {}
G.model.remove_block(block.position)
G.model.hide_block(block.position, block)
# G.model.check_neighbors(block.position)
G.eventhandler.call(
"game:on_block_remove_by_player",
vector,
block,
previous,
drops,
)
elif button == pyglet.window.mouse.MIDDLE and G.player.gamemode == 1:
vector = G.window.get_sight_vector()
block, previous = G.model.hit_test(G.window.position,
vector)
cx, _, cz = mathhelper.sectorize(block)
chunkprovider = (
G.player.dimension.worldprovider.getChunkProviderFor(
(cx, cz)))
binst = chunkprovider.world[block]
G.player.inventory.inventorys[0].slots[
G.player.
selectedinventoryslot].stack = IItemStack.IItemStack(
binst.getName())
if (G.player.inventory.inventorys[0].slots[
G.player.selectedinventoryslot].stack.item):
G.player.inventory.inventorys[0].slots[
G.player.selectedinventoryslot].stack.amount = (
G.player.inventory.inventorys[0].slots[
G.player.selectedinventoryslot].stack.item.
getMaxStackSize())
else:
G.window.set_exclusive_mouse(True)
def generateChunk(self, chunk):
bios = []
for x in range(chunk[0] * 16, chunk[0] * 16 + 16):
for z in range(chunk[1] * 16, chunk[1] * 16 + 16):
if not (x, z) in self.biome_data:
raise ValueError("getted an unprepared area-biome-data", x,
z)
self.biome_instances[self.biome_data[(x, z)]].poslist.append(
(x, z))
if not self.biome_instances[self.biome_data[(x, z)]] in bios:
bios.append(self.biome_instances[self.biome_data[(x, z)]])
for biome in bios:
biome.GenerateBiome(G.model)
if random.randint(1, 5) == 1 and config.CONFIGS["GENERATE_PERLIN"]:
bpos = chunk[0] * 16, chunk[1] * 16
pos = []
for _ in range(random.randint(1, 5)):
x, z = random.randint(bpos[0], bpos[0] + 15), random.randint(
bpos[1], bpos[1] + 15)
y = G.model.high_data[(x, z)]
pos.append((x, y, z))
print("adding perlin...")
data = pyfastnoisesimd.generate([255, 255, 255],
start=pos,
seed=G.seed)
print("sorting them for generation...")
dt = time.time()
i = -1
ch = []
for xl in data:
for zl in xl:
pos = zl[0]
cx, _, cz = mathhelper.sectorize((pos[0], pos[1], pos[2]))
self.perlin_positions[(zl[0][0], zl[0][2])] = zl
if not (cx, cz) in ch:
ch.append((cx, cz))
i += 1
if time.time() - dt > 1:
dt = time.time()
print(str(round(i / (255 * 255 * 255) * 100)) + "%")
for e in ch:
if e in G.model.generated:
print("applying perlins to chunk", e)
print(self.perlin_positions[chunk])
dt = time.time()
for x in range(chunk[0] * 16, chunk[0] * 16 + 16):
for z in range(chunk[1] * 16, chunk[1] * 16 + 16):
if (x, z) in self.perlin_positions:
for y, v in enumerate(
self.perlin_positions[(x, z)]):
if v >= 0 and (x, y, z) in G.model.world:
G.model.remove_block((x, y, z),
immediate=False,
save=False)
if time.time() - dt > 1:
dt = time.time()
print(
str(
round(i / len(
self.
perlin_positions[chunk]) *
100)) + "%")
print("looking for perlin-positions for asked chunk", chunk)
if not chunk in self.perlin_positions:
print("[ERROR] generated perlin and found NONE in chunk")
else:
pass
def executeCommand(command, entity, position):
chunk = mathhelper.sectorize(G.window.position)
cx, cz = chunk[0], chunk[2]
chunkprovider = G.player.dimension.worldprovider.getChunkProviderFor(
(cx, cz))
chunkprovider.generate()
