Add a block with the given `texture` and `position` to the world. Parameters ---------- position : tuple of len 3

Return a list of the texture squares for the top, bottom and side.

Returns a tuple representing the sector for the given `position` :param position: tuple of len 3 :return: tuple of len 3 representing the sec

Add `func` to the internal queue.

Change to a specific Scene, by it's class name. When changing to a new Scene, any Window event handlers that are defined on the new S

Returns True if given `position` does not contain block. If `must_be_loaded` is True, this returns False if the block is not yet loaded.

If `exclusive` is True, the game will capture the mouse, if False the game will ignore the mouse.

Iterate all the xz block positions from a sector

Return the bounding vertices of the texture square.

Add a Scene instance to the manager. :param scene_instance: An instace of a `Scene`.

True if the horizontal plan between `ymin` and `ymax` is inside this sector.

Generate a noise 3D.

Play a sound effect on the next available channel :param source: A pyglet audio Source :param position: Optional spacial position for

Randomize the permutation table used by the noise functions. This makes them generate a different noise pattern for the same inputs.

Pop the top function from the internal queue and call it.

Check all blocks surrounding `position` and ensure their visual state is current. This means hiding blocks that are not exposed and e

True if the horizontal plan `y` is inside this sector.

Return the vertices of the Block at position x, y, z with size 2*n. :param x: int or float of the Block's x position :param y: int or float of

Return false if there is no block at this position in this chunk

Returns False if given `position` is surrounded on all 6 sides by blocks, True otherwise.

Generate a specific sector of the world and place all the blocks

Return a block from this position. If no blocks, None is returned.

Returns the current line of sight vector indicating the direction the player is looking.

Returns True if the save path and file exist.

Line of sight search from current position. If a block is intersected it is returned, along with the block previously in the line of

Check if one of the face of this section is full of blocks. The direction is a normalized vector from `FACES`.

Iterate all the positions neighboring this position

Generate a noise 2D.

Accepts `position` of arbitrary precision clamps it. :param position: tuple of len 3 :return: tuple of ints of len 3, representing a block po

Add a new sector to this world definition.

Remove the block at the given `position`. Parameters ---------- position : tuple of len 3 The (x, y, z) position

Compute the content of a sector asynchronously and return the result to a callback already specified to this generator.

Generate clouds at this `self.y_cloud`.

Generate an enclosure with unbreakable blocks on the floor and and on the side.

Generate a standard floor at a specific height

Generate trees in the map For now it do not generate trees between 2 sectors, and use rand instead of a procedural generation.

Returns the expected mineral at a specific location. The input location have to be already known as a stone location.

Iterate all the xyz block positions from a sector

Private implementation of the `update()` method. This is where most of the motion logic lives, along with gravity and collision detection.

Checks to see if the player at the given `position` and `height` is colliding with any blocks in the world. Parameters -----

True if the position `pos` is inside this sector.

Return the number of blocks in this model

Draw black edges around the block that is currently under the crosshairs.

Draw the label in the top left of the screen.

Returns the current motion vector indicating the velocity of the player. Returns ------- vector : tuple of len 3

Ensure all blocks in the given sector that should be hidden are removed from the canvas.

Make sure the sector containing the actor is loaded and the player is on top of it.

Check if a sector is visible. For now only check if no from a sector position.

Event handler for the Window.on_resize event. Called when the window is resized to a new `width` and `height`.

Process the entire queue while taking periodic breaks. This allows the game loop to run smoothly. The queue contains calls to _show_b

Set a callback called when a new sector is computed

Configure the OpenGL fog properties.

Basic OpenGL configuration.

Update the shown sectors. Show the ones which are not part of the list, and hide the others.

Ensure all blocks in the given sector that should be shown are drawn to the canvas.

Update shown sectors according to the actual frustum. A sector is a contiguous x, y sub-region of world. Sectors are used to speed up

A class for Blocks :param name: The name of the Block material. :param tex_coords: The texture coordinates for this material.

SaveManager handles saving/loading of worlds and options. An internal dictionary (self._data) holds persistent data such as options,

Initialize the noise generator. With no arguments, the default period and permutation table are used (256). The default permutation ta

Add a block to this chunk only if the `position` is part of this chunk.

Add a new entry to the height map lookup table. `height` will be the height at this part of the height map. and `terrains

Iterate all blocks from a face

Returns False if given `position` is surrounded on all 6 sides by blocks, True otherwise.

Return the biome at a location of the map plus the first empty place.

Return the block stored at this position of this sector. Else None.