def generateRail(matrix, y, x, z, path_material, fence_material, rail_orientation, generateAround = True): # Generate the path matrix.setValue(y - 2, x, z, path_material) matrix.setValue(y - 1, x, z, path_material) matrix.setValue(y, x, z, path_material) if generateAround: (x_modifier, z_modifier) = (1, 0) # default if ((rail_orientation == toolbox.Orientation.VERTICAL - 1) or (rail_orientation == toolbox.Orientation.WEST - 1) or (rail_orientation == toolbox.Orientation.EAST - 1)): (x_modifier, z_modifier) = (1, 0) elif ((rail_orientation == toolbox.Orientation.HORIZONTAL - 1) or (rail_orientation == toolbox.Orientation.NORTH - 1) or (rail_orientation == toolbox.Orientation.SOUTH - 1)): (x_modifier, z_modifier) = (0, 1) matrix.setValue(y - 1, x - x_modifier, z - z_modifier, path_material) matrix.setValue(y, x - x_modifier, z - z_modifier, path_material) matrix.setValue(y + 1, x - x_modifier, z - z_modifier, fence_material) matrix.setValue(y - 1, x + x_modifier, z + z_modifier, path_material) matrix.setValue(y, x + x_modifier, z + z_modifier, path_material) matrix.setValue(y + 1, x + x_modifier, z + z_modifier, fence_material) # Generate the rail if isGoldenRail(rail_orientation): matrix.setValue(y + 1, x, z, toolbox.getBlockID("golden_rail", rail_orientation)) if generateAround: matrix.setValue(y, x, z, toolbox.getBlockID("redstone_block")) else: matrix.setValue(y + 1, x, z, toolbox.getBlockID("rail", rail_orientation))
def generateRails(matrix, wooden_materials_kit, height_map, rail_map, x_min, x_max, z_min, z_max, highestPoint): for x in range(x_min, x_max + 1): for z in range(z_min, z_max + 1): if rail_map[x][z] >= 2: #logging.info("x:{} z:{} is {} with max rail length {}".format(x, z, rail_map[x][z], max_rail_length)) ## check rail orientation using neighbouring rails binary_orientation_index = getRailOrientation( height_map, rail_map, x, z, x_max, z_max, max_rail_length) ## set rail orientation rail_orientation = getOrientationFromBinaryIndex( binary_orientation_index) ## generate the rail #logging.info("Generating a rail (index:{}) in x:{}, z:{}, y:{} with orientation:{}".format(rail_map[x][z], x, z, height_map[x][z], rail_orientation)) matrix.setValue(height_map[x][z], x, z, wooden_materials_kit["log"]) ## regular rail if binary_orientation_index < 16: matrix.setValue( height_map[x][z] + 1, x, z, toolbox.getBlockID("rail", rail_orientation)) ## powered rail else: matrix.setValue( height_map[x][z] + 1, x, z, toolbox.getBlockID("golden_rail", rail_orientation)) matrix.setEntity(height_map[x][z] - 1, x, z, toolbox.getBlockID("redstone_torch"), "redstone_torch")
def buildLight(matrix, h, x, z): #put the light at the position given logging.info("Generating light at point {}, {}, {}".format(h+1, x, z)) try: matrix.setValue(h + 1, x, z, light_Pillar) matrix.setValue(h + 2, x, z, light_Pillar) matrix.setValue(h + 3, x, z, toolbox.getBlockID("redstone_lamp")) matrix.setEntity(h + 4, x, z, toolbox.getBlockID("daylight_detector_inverted", 15), "daylight_detector") except: logging.info("Error when generating light at position : {}, {}, {}".format(h+1, x, z))
def generateSmileyPattern(matrix, wooden_materials_kit, h, x_min, x_max, z_min, z_max): ## FENCES generateFences(matrix, wooden_materials_kit, h, x_min + 1, x_max - 1, z_min + 1, z_max - 1) ## GROUND farmlandID = toolbox.getBlockID("farmland") carrotsID = toolbox.getBlockID("carrots") # fill field with dirt and carrots for x in range(x_min + 3, x_max - 2): for z in range(z_min + 3, z_max - 2): matrix.setValue(h, x, z, farmlandID) matrix.setValue(h + 1, x, z, CARROT_ID) ## SMILEY wheatID = toolbox.getBlockID("wheat") waterID = toolbox.getBlockID("water") # eyes def generateEye(x, z): matrix.setValue(h + 1, x, z, wheatID) matrix.setValue(h + 1, x, z + 1, wheatID) matrix.setValue(h + 1, x + 1, z, wheatID) matrix.setValue(h, x + 1, z + 1, waterID) matrix.setValue(h + 1, x + 1, z + 1, toolbox.getBlockID("air")) # left eye generateEye(x_min + 5, z_min + 5) # right eye generateEye(x_max - 6, z_min + 5) # mouth for x in range(x_min + 6, x_max - 5): matrix.setValue(h + 1, x, z_max - 4, wheatID) matrix.setValue(h + 1, x_min + 5, z_max - 5, wheatID) matrix.setValue(h + 1, x_max - 5, z_max - 5, wheatID) matrix.setValue(h + 1, x_min + 4, z_max - 6, wheatID) matrix.setValue(h + 1, x_max - 4, z_max - 6, wheatID) ## WATER for x in range(x_min + 2, x_max - 1): matrix.setValue(h, x, z_max - 2, waterID) matrix.setValue(h, x, z_min + 2, waterID) for z in range(z_min + 2, z_max - 1): matrix.setValue(h, x_max - 2, z, waterID) matrix.setValue(h, x_min + 2, z, waterID)
def generatePath_StraightLine(matrix, x_p1, z_p1, x_p2, z_p2, height_map, pavement_Type): if pavement_Type == "Grass": pavement_Block = toolbox.getBlockID("grass_path") light_Pillar = toolbox.getBlockID("oak_fence") elif pavement_Type == "Stone": pavement_Block = toolbox.getBlockID("stone", 6) light_Pillar = toolbox.getBlockID("cobblestone_wall") for x in toolbox.twoway_range(x_p1, x_p2): h = height_map[x][z_p1] h = matrix.getMatrixY(h) matrix.setValue(h, x, z_p1, pavement_Block) for z in toolbox.twoway_range(z_p1, z_p2): h = height_map[x_p2][z] h = matrix.getMatrixY(h) matrix.setValue(h, x_p2, z, pavement_Block) matrix.setValue(h + 1, x_p2, z, toolbox.getBlockID("air"))
def generatePillar(matrix, pillar_material, simple_height_map, train_line_height_map, x, z, direction): h = train_line_height_map[x][z] + HEIGHT_FROM_GROUND matrix.setValue(h - 4, x + 1, z, toolbox.getBlockID("torch", 1)) matrix.setValue(h - 4, x - 1, z, toolbox.getBlockID("torch", 2)) matrix.setValue(h - 4, x, z + 1, toolbox.getBlockID("torch", 3)) matrix.setValue(h - 4, x, z - 1, toolbox.getBlockID("torch", 4)) for y in range(simple_height_map[x][z] + 1, h - 2): matrix.setValue(y, x, z, pillar_material) if direction == 1: matrix.setValue(h + 2, x, z - 1, toolbox.getBlockID("torch", 5)) matrix.setValue(h + 2, x, z + 1, toolbox.getBlockID("torch", 5)) elif direction == 0: matrix.setValue(h + 2, x - 1, z, toolbox.getBlockID("torch", 5)) matrix.setValue(h + 2, x + 1, z, toolbox.getBlockID("torch", 5))
def generateStation(matrix, wooden_materials_kit, simple_height_map, train_line_height_map, x, z, direction): floor_material = wooden_materials_kit["planks"] fence_material = wooden_materials_kit["fence"] roof_material = wooden_materials_kit["slab"] air = toolbox.getBlockID("air", 0) initial_position = train_line_height_map[x][z] + HEIGHT_FROM_GROUND if direction == 1: # base matrix.setValue(initial_position + 1, x, z, toolbox.getBlockID("golden_rail", toolbox.Orientation.HORIZONTAL - 1)) for y in range(simple_height_map[x][z - 1] + 1, initial_position + 1): matrix.setValue(y, x, z - 1, toolbox.getBlockID("ladder", 2)) for y in range(simple_height_map[x][z + 1] + 1, initial_position + 1): matrix.setValue(y, x, z + 1, toolbox.getBlockID("ladder", 3)) for i in range(-1, 2): matrix.setValue(initial_position + 1, x + i, z - 1, air) matrix.setValue(initial_position + 1, x + i, z + 1, air) for i in range(-2, 3): matrix.setValue(initial_position, x + i, z - 2, floor_material) matrix.setValue(initial_position + 1, x + i, z - 2, fence_material) matrix.setValue(initial_position, x + i, z + 2, floor_material) matrix.setValue(initial_position + 1, x + i, z + 2, fence_material) elif direction == 0: # base matrix.setValue(initial_position + 1, x, z, toolbox.getBlockID("golden_rail", toolbox.Orientation.VERTICAL - 1)) for y in range(simple_height_map[x][z - 1] + 1, initial_position + 1): matrix.setValue(y, x - 1, z, toolbox.getBlockID("ladder", 4)) for y in range(simple_height_map[x][z + 1] + 1, initial_position + 1): matrix.setValue(y, x + 1, z, toolbox.getBlockID("ladder", 5)) for i in range(-1, 2): matrix.setValue(initial_position + 1, x - 1, z + i, air) matrix.setValue(initial_position + 1, x + 1, z + i, air) for i in range(-2, 3): matrix.setValue(initial_position, x - 2, z + i, floor_material) matrix.setValue(initial_position + 1, x - 2, z + i, fence_material) matrix.setValue(initial_position, x + 2, z + i, floor_material) matrix.setValue(initial_position + 1, x + 2, z + i, fence_material) # roof for i in range(0, 3): matrix.setValue(initial_position + 1 + i, x - 2, z - 2, fence_material) matrix.setValue(initial_position + 1 + i, x + 2, z - 2, fence_material) matrix.setValue(initial_position + 1 + i, x - 2, z + 2, fence_material) matrix.setValue(initial_position + 1 + i, x + 2, z + 2, fence_material) for i in range(-2, 3): for j in range(-2, 3): matrix.setValue(initial_position + 4, x + i, z + j, roof_material) for i in range(-1, 2): for j in range(-1, 2): matrix.setValue(initial_position + 4, x + i, z + j, floor_material)
def generateBasicPattern(matrix, wooden_materials_kit, h, x_min, x_max, z_min, z_max, plant=None): ## FENCES generateFences(matrix, wooden_materials_kit, h, x_min + 1, x_max - 1, z_min + 1, z_max - 1) ## GROUND & CULTURES if plant == None: # select one random plant for this farm plants = [ toolbox.getBlockID("wheat"), toolbox.getBlockID("carrots"), toolbox.getBlockID("potatoes") ] plant = plants[RNG.randint(0, PLANT_SPECIES_NUMBER - 1)] # fill field with dirt and the corresponding plant farmlandID = toolbox.getBlockID("farmland") for x in range(x_min + 3, x_max - 2): for z in range(z_min + 3, z_max - 2): matrix.setValue(h, x, z, farmlandID) matrix.setValue(h + 1, x, z, plant) ## WATER waterID = toolbox.getBlockID("water") for x in range(x_min + 2, x_max - 1): matrix.setValue(h, x, z_max - 2, waterID) matrix.setValue(h, x, z_min + 2, waterID) for z in range(z_min + 2, z_max - 1): matrix.setValue(h, x_max - 2, z, waterID) matrix.setValue(h, x_min + 2, z, waterID)
def generateEntrance(matrix, wooden_materials_kit, orientation, h_min, door_x, door_z, min_bound, max_bound): grass_pathID = toolbox.getBlockID("grass_path") if orientation % 2 == 0: for z in range(min_bound, max_bound): matrix.setValue(h_min, door_x, z, grass_pathID) matrix.setValue(h_min, door_x - 1, z, grass_pathID) matrix.setValue(h_min, door_x + 1, z, grass_pathID) else: for x in range(min_bound, max_bound): matrix.setValue(h_min, x, door_z, grass_pathID) matrix.setValue(h_min, x, door_z - 1, grass_pathID) matrix.setValue(h_min, x, door_z + 1, grass_pathID) matrix.setValue(h_min + 1, door_x, door_z, (wooden_materials_kit["fence_gate"][0], orientation))
def generateFountain(matrix, h_min, h_max, x_min, x_max, z_min, z_max): logger = logging.getLogger("fountain") logger.info("Preparation for Fountain generation") fountain_material = toolbox.getBlockID("double_stone_slab") x_center = (x_min + x_max) / 2 z_center = (z_min + z_max) / 2 if (h_min + FOUNTAIN_HEIGHT < h_max): h_max = h_min + FOUNTAIN_HEIGHT generateStructure(matrix, logger, fountain_material, h_min, h_max, x_center, z_center) f = toolbox.dotdict() f.type = "fountain" f.lotArea = toolbox.dotdict({"y_min": h_min, "y_max": h_max, "x_min": x_min, "x_max": x_max, "z_min": z_min, "z_max": z_max}) f.buildArea = toolbox.dotdict({"y_min": h_min, "y_max": h_max, "x_min": x_center - 6, "x_max": x_center + 7, "z_min": z_center - 6, "z_max": z_center + 7}) f.orientation = "S" f.entranceLot = (f.lotArea.x_min, f.lotArea.z_min) return f
def generateFences(matrix, wooden_materials_kit, h, x_min, x_max, z_min, z_max): oak_logID = wooden_materials_kit["log"] oak_fenceID = wooden_materials_kit["fence"] torchID = toolbox.getBlockID("torch", 5) for x in range(x_min, x_max + 1): matrix.setValue(h, x, z_max, oak_logID) matrix.setValue(h, x, z_min, oak_logID) matrix.setValue(h + 1, x, z_max, oak_fenceID) matrix.setValue(h + 1, x, z_min, oak_fenceID) for z in range(z_min, z_max + 1): matrix.setValue(h, x_max, z, oak_logID) matrix.setValue(h, x_min, z, oak_logID) matrix.setValue(h + 1, x_max, z, oak_fenceID) matrix.setValue(h + 1, x_min, z, oak_fenceID) matrix.setValue(h + 2, x_min, z_max, torchID) matrix.setValue(h + 2, x_min, z_min, torchID) matrix.setValue(h + 2, x_max, z_max, torchID) matrix.setValue(h + 2, x_max, z_min, torchID)
def generateCorner(logger, matrix, simple_height_map, train_line_height_map, x, z, x_modifier, z_modifier, path_material, fence_material, pillar_material, rail_orientation): y = train_line_height_map[x][z] + HEIGHT_FROM_GROUND if (train_line_height_map[x][z] == train_line_height_map[x - x_modifier][z] - 1): if (train_line_height_map[x][z] != train_line_height_map[x][z - z_modifier] + 1): train_line_height_map[x][z] += 1 y += 1 else: generateSpecialCorner(logger, matrix, simple_height_map, train_line_height_map, y, x, z, x_modifier, z_modifier, path_material, fence_material, pillar_material, rail_orientation) return elif (train_line_height_map[x][z] == train_line_height_map[x][z - z_modifier] - 1): if (train_line_height_map[x][z] != train_line_height_map[x - x_modifier][z] + 1): train_line_height_map[x][z] += 1 y += 1 else: generateSpecialCorner(logger, matrix, simple_height_map, train_line_height_map, y, x, z, x_modifier, z_modifier, path_material, fence_material, pillar_material, rail_orientation) return generateRail(matrix, y, x, z, path_material, fence_material, rail_orientation, False) matrix.setValue(y, x + x_modifier, z, path_material) matrix.setValue(y + 1, x + x_modifier, z, fence_material) matrix.setValue(y, x, z + z_modifier, path_material) matrix.setValue(y + 1, x, z + z_modifier, fence_material) matrix.setValue(y, x + x_modifier, z + z_modifier, path_material) matrix.setValue(y + 1, x + x_modifier, z + z_modifier, fence_material) matrix.setValue(y + 2, x + x_modifier, z + z_modifier, toolbox.getBlockID("torch", 5))
def generateSpecialCorner(logger, matrix, simple_height_map, train_line_height_map, y, x, z, x_modifier, z_modifier, path_material, fence_material, pillar_material, rail_orientation): logger.info("Generating special train line rail corner") rail_orientations = (toolbox.Orientation.NORTH_WEST - 1, toolbox.Orientation.SOUTH_EAST - 1, toolbox.Orientation.HORIZONTAL - 1, toolbox.Orientation.EAST - 1, toolbox.Orientation.SOUTH - 1, toolbox.Orientation.VERTICAL - 1) #default if rail_orientation == toolbox.Orientation.NORTH_EAST - 1: rail_orientations = (toolbox.Orientation.NORTH_WEST - 1, toolbox.Orientation.SOUTH_EAST - 1, toolbox.Orientation.HORIZONTAL - 1, toolbox.Orientation.EAST - 1, toolbox.Orientation.SOUTH - 1, toolbox.Orientation.VERTICAL - 1) elif rail_orientation == toolbox.Orientation.NORTH_WEST - 1: rail_orientations = (toolbox.Orientation.SOUTH_WEST - 1, toolbox.Orientation.NORTH_EAST - 1, toolbox.Orientation.VERTICAL - 1, toolbox.Orientation.NORTH - 1, toolbox.Orientation.EAST - 1, toolbox.Orientation.HORIZONTAL - 1) elif rail_orientation == toolbox.Orientation.SOUTH_WEST - 1: rail_orientations = (toolbox.Orientation.NORTH_WEST - 1, toolbox.Orientation.SOUTH_EAST - 1, toolbox.Orientation.HORIZONTAL - 1, toolbox.Orientation.EAST - 1, toolbox.Orientation.SOUTH - 1, toolbox.Orientation.VERTICAL - 1) elif rail_orientation == toolbox.Orientation.SOUTH_EAST - 1: rail_orientations = (toolbox.Orientation.SOUTH_WEST - 1, toolbox.Orientation.NORTH_EAST - 1, toolbox.Orientation.VERTICAL - 1, toolbox.Orientation.NORTH - 1, toolbox.Orientation.EAST - 1, toolbox.Orientation.HORIZONTAL - 1) generateRail(matrix, y + 1, x, z, path_material, fence_material, rail_orientations[1], False) generateRail(matrix, y + 1, x, z + z_modifier, path_material, fence_material, rail_orientations[2], False) generateRail(matrix, y + 1, x, z + 2 * z_modifier, path_material, fence_material, rail_orientations[0], False) generateRail(matrix, y, x + x_modifier, z + 2 * z_modifier, path_material, fence_material, rail_orientations[3], False) generateRail(matrix, y, x + 2 * x_modifier, z + 2 * z_modifier, path_material, fence_material, rail_orientation, False) generateRail(matrix, y - 1, x + 2 * x_modifier, z + z_modifier, path_material, fence_material, rail_orientations[4], False) generateRail(matrix, y - 1, x + 2 * x_modifier, z, path_material, fence_material, rail_orientations[1], False) generateRail(matrix, y - 1, x + x_modifier, z, path_material, fence_material, rail_orientations[5], False) generateRail(matrix, y - 1, x, z, path_material, fence_material, rail_orientations[0], False) matrix.setValue(y, x + x_modifier, z + z_modifier, toolbox.getBlockID("redstone_block")) matrix.setValue(y + 1, x + x_modifier, z + z_modifier, path_material) train_line_height_map[x][z] -= 1
def generatePath(matrix, path, height_map, pavement_Type): air = toolbox.getBlockID("air") if pavement_Type == "Grass": pavement_Block = toolbox.getBlockID("grass_path") baseBlock = toolbox.getBlockID("dirt") light_Pillar = toolbox.getBlockID("oak_fence") elif pavement_Type == "Stone": pavement_Block = toolbox.getBlockID("stone", 6) baseBlock = toolbox.getBlockID("stone") light_Pillar = toolbox.getBlockID("cobblestone_wall") def fillUnderneath(matrix, y, x, z): if y < 0: return block = matrix.getValue(y, x, z) if type(block) == tuple: block = block[0] if block in air_like or block in water_like: matrix.setValue(y, x, z, baseBlock) fillUnderneath(matrix, y - 1, x, z) def fillAbove(matrix, y, x, z, up_to): if up_to < 0 or y >= matrix.height: return block = matrix.getValue(y, x, z) if type(block) == tuple: block = block[0] if block in air_like: matrix.setValue(y, x, z, air) fillAbove(matrix, y + 1, x, z, up_to-1) def getOrientation(x1, z1, x2, z2): if x1 < x2: return "E" elif x1 > x2: return "W" elif z1 < z2: return "S" elif z1 > z2: return "N" else: return None def generateLight(matrix, block_section, path, height_map): #generate a light by using the center of mass if it is possible (x, z) = computeCenterOfMass(block_section) if height_map[x][z] != -1 and matrix.getValue(height_map[x][z] + 1, x, z) not in light_pillar_like+[65] and matrix.getValue(height_map[x][z] - 1, x, z) not in air_like: #validity of the center of mass if isNeighborLight(matrix,height_map, x, z) != True: buildLight(matrix, height_map[x][z], x, z) else: (x, z) = findPos(matrix, x, z, path, height_map) if (x, z) != (-1, -1): if isNeighborLight(matrix,height_map, x, z) != True: buildLight(matrix, height_map[x][z], x, z) else: return False def buildLight(matrix, h, x, z): #put the light at the position given logging.info("Generating light at point {}, {}, {}".format(h+1, x, z)) try: matrix.setValue(h + 1, x, z, light_Pillar) matrix.setValue(h + 2, x, z, light_Pillar) matrix.setValue(h + 3, x, z, toolbox.getBlockID("redstone_lamp")) matrix.setEntity(h + 4, x, z, toolbox.getBlockID("daylight_detector_inverted", 15), "daylight_detector") except: logging.info("Error when generating light at position : {}, {}, {}".format(h+1, x, z)) def computeCenterOfMass(block_section): #compute the center of gravity to have a general idea of where a light could be put x = 0 z = 0 for i in range(0, len(block_section)): x += block_section[i][0] z += block_section[i][1] x = int(round(x / len(block_section))) z = int(round(z / len(block_section))) return (x, z) def findPos(matrix, x, z, path, height_map): #try to find a position next to the one given that is suitable for building a light for neighbor_position in [(0, -1), (0, 1), (-1, 0), (1, 0), (1, 1), (-1, -1), (1, -1), (-1, 1)]: new_position = (x + neighbor_position[0], z + neighbor_position[1]) try: if height_map[new_position[0]][new_position[1]] != -1 and matrix.getValue(height_map[new_position[0]][new_position[1]]+1,new_position[0],new_position[1]) not in light_pillar_like+[65] and matrix.getValue(height_map[new_position[0]][new_position[1]]-1,new_position[0],new_position[1]) not in air_like: return new_position except: continue return (-1, -1) def isNeighborLight(matrix,height_map, x, z): #return True if a light is neighbor to the position x, y for neighbor_position in [(0, -1), (0, 1), (-1, 0), (1, 0), (1, 1), (1, -1), (-1, 1), (-1, -1)]: new_position = (x + neighbor_position[0], z + neighbor_position[1]) try: if matrix.getValue(height_map[new_position[0]][new_position[1]] + 1, new_position[0], new_position[1]) in light_pillar_like: return True except: continue for i in range(0, len(path) - 1): block = path[i] x = block[0] z = block[1] h = height_map[x][z] next_block = path[i + 1] next_h = height_map[next_block[0]][next_block[1]] if i != 0: previous_block = path[i - 1] previous_h = height_map[previous_block[0]][previous_block[1]] logging.info("Generating road at point ({}, {}, {})".format(h, x, z)) (b, d) = toolbox.getBlockFullValue(matrix, h, x, z) if (b, d) != toolbox.getBlockID("stone", 6): matrix.setValue(h, x, z, pavement_Block) fillUnderneath(matrix, h - 1, x, z) fillAbove(matrix, h + 1, x, z, 5) # check if we are moving in the x axis (so to add a new pavement # on the z-1, z+1 block) if x != next_block[0]: # if that side block is walkable if z - 1 >= 0 and height_map[x][z - 1] != -1 and h-height_map[x][z - 1] in [0, 1]: matrix.setValue(h, x, z - 1, pavement_Block) height_map[x][z - 1] = h # try to fill with earth underneath if it's empty #logging.info("Filling underneath at height {}".format(h-1)) fillUnderneath(matrix, h - 1, x, z - 1) # fill upwards with air to remove any obstacles fillAbove(matrix, h + 1, x, z - 1, 5) # if the opposite side block is walkable if z + 1 < matrix.depth and height_map[x][z + 1] != -1 and h-height_map[x][z + 1] in [0, 1]: matrix.setValue(h, x, z + 1, pavement_Block) height_map[x][z + 1] = h #logging.info("Filling underneath at height {}".format(h-1)) fillUnderneath(matrix, h - 1, x, z + 1) fillAbove(matrix, h + 1, x, z + 1, 5) elif z != next_block[1]: # check if we are moving in the z axis (so add a new pavement # on the x-1 block) and if that side block is walkable if x-1 >= 0 and height_map[x - 1][z] != -1 and h - height_map[x - 1][z] in [0, 1]: matrix.setValue(h, x - 1, z, pavement_Block) height_map[x - 1][z] = h #logging.info("Filling underneath at height {}".format(h-1)) fillUnderneath(matrix, h - 1, x - 1, z) fillAbove(matrix, h + 1, x - 1, z, 5) if x + 1 < matrix.width and height_map[x + 1][z] != -1 and h - height_map[x + 1][z] in [0, 1]: matrix.setValue(h, x + 1, z, pavement_Block) height_map[x + 1][z] = h #logging.info("Filling underneath at height {}".format(h-1)) fillUnderneath(matrix, h - 1, x + 1, z) fillAbove(matrix, h + 1, x + 1, z, 5) else: logging.info("Stone path at point ({}, {}, {}) already existing, going forward".format(h, x, z)) # another iteration over the path to generate ladders and lights # this is to guarantee that fillAbove or any other # manipulations of the environment around the path # will erase the ladder blocks or the lights block_section = path[0:20] # Block section of 20 blocks to find the right place to put lights isPut = generateLight(matrix, block_section, path, height_map) if isPut == False: #Failed to find a good position with the center of mass, build it next to or on the path try: (xl, zl) = findPos(matrix, path[10][0], path[10][1], path, height_map) except: #not enough block left in the path, so take the position of half of what remains (xl, zl) = findPos(matrix, path[int(((i-len(path)-1)/2))][0], path[int(((i-len(path)-1)/2))][1], path, height_map) if (xl, zl) != (-1, -1): if isNeighborLight(matrix,height_map, xl, zl) != True: buildLight(matrix, height_map[xl][zl], xl, zl) else: if isNeighborLight(matrix,height_map, path[10][0], path[10][1]) != True: buildLight(matrix, height_map[path[10][0]][path[10][1]], path[10][0], path[10][1]) for i in range(0, len(path) - 1): block = path[i] x = block[0] z = block[1] h = height_map[x][z] next_block = path[i + 1] next_h = height_map[next_block[0]][next_block[1]] orientation = getOrientation(x, z, next_block[0], next_block[1]) if abs(h - next_h) > 1: if h < next_h: if orientation == "N": ladder_subID = 3 elif orientation == "S": ladder_subID = 2 elif orientation == "E": ladder_subID = 4 elif orientation == "W": ladder_subID = 5 for ladder_h in range(h + 1, next_h + 1): matrix.setValue(ladder_h, x, z, toolbox.getBlockID("ladder", ladder_subID)) # make sure that the ladders in which the stairs are attached # are pathblock and not dirt, etc (b, d) = toolbox.getBlockFullValue(matrix, ladder_h, next_block[0], next_block[1]) if (b, d) != toolbox.getBlockID("ladder", 6): matrix.setValue(ladder_h, next_block[0], next_block[1], (pavement_Block)) block = matrix.getValue(next_h + 1, x, z) if type(block) == tuple: block = block[0] if block in air_like: matrix.setValue(next_h + 1, x, z, air) block = matrix.getValue(next_h + 2, x, z) if type(block) == tuple: block = block[0] if block in air_like: matrix.setValue(next_h + 2, x, z, air) elif h > next_h: if orientation == "N": ladder_subID = 2 elif orientation == "S": ladder_subID = 3 elif orientation == "E": ladder_subID = 5 elif orientation == "W": ladder_subID = 4 for ladder_h in range(next_h+1, h+1): matrix.setValue(ladder_h, next_block[0], next_block[1], toolbox.getBlockID("ladder", ladder_subID)) # make sure that the ladders in which the stairs are attached # are pathblock and not dirt, etc (b, d) = toolbox.getBlockFullValue(matrix, h, x, z) if (b, d) != toolbox.getBlockID("ladder", 6): matrix.setValue(ladder_h, x, z, (pavement_Block)) block = matrix.getValue(h + 1, x, z) if type(block) == tuple: block = block[0] if block in air_like: matrix.setValue(h + 1, x, z, air) block = matrix.getValue(h + 2, x, z) if type(block) == tuple: block = block[0] if block in air_like: matrix.setValue(h + 2, x, z, air) #build next light and update the blocksection if type(block) == type(block_section[len(block_section) - 1]) and block == block_section[len(block_section) - 1]: isPut = generateLight(matrix, block_section, path, height_map) if isPut == False: #Failed to find a good position with the center of mass, build it next to or on the path try: (xl, zl) = findPos(matrix, path[i + 10][0], path[i + 10][1], path, height_map) except: #not enogh block left in the path, so take the position of half of what remains (xl, zl) = findPos(matrix, path[i + int(((i - len(path) - 1) / 2))][0], path[i + int(((i - len(path) - 1) / 2))][1], path, height_map) if (xl, zl) != (-1, -1): if isNeighborLight(matrix,height_map, xl, zl) != True: buildLight(matrix, height_map[xl][zl], xl, zl) else: if isNeighborLight(matrix,height_map, path[i + 10][0], path[i + 10][1]) != True: buildLight(matrix, height_map[path[i + 10][0]][path[i + 10][1]], path[i + 10][0], path[i + 10][1]) try: block_section = path[i:i + 20] except: block_section = path[i:len(path)]
def generateStructure(matrix, logger, material, h_min, h_max, x_center, z_center): water = toolbox.getBlockID("water") border = toolbox.getBlockID("lapis_block") h_first_floor = h_min + (h_max - h_min) / 3 h_second_floor = h_min + (h_max - h_min) / 3 * 2 # water matrix.setValue(h_max, x_center, z_center, water) for h in range(h_second_floor, h_max + 1): matrix.setValue(h, x_center - 1, z_center, water) matrix.setValue(h, x_center + 1, z_center, water) matrix.setValue(h, x_center, z_center - 1, water) matrix.setValue(h, x_center, z_center + 1, water) for h in range(h_first_floor, h_second_floor + 1): matrix.setValue(h, x_center - 2, z_center, water) matrix.setValue(h, x_center + 2, z_center, water) matrix.setValue(h, x_center, z_center - 2, water) matrix.setValue(h, x_center, z_center + 2, water) for h in range(h_min + 1, h_first_floor + 1): matrix.setValue(h, x_center - 3, z_center - 2, water) matrix.setValue(h, x_center - 3, z_center + 2, water) matrix.setValue(h, x_center + 3, z_center - 2, water) matrix.setValue(h, x_center + 3, z_center + 2, water) matrix.setValue(h, x_center - 2, z_center - 3, water) matrix.setValue(h, x_center + 2, z_center - 3, water) matrix.setValue(h, x_center - 2, z_center + 3, water) matrix.setValue(h, x_center + 2, z_center + 3, water) for i in range(-2, 3): for j in range(-2, 3): matrix.setValue(h_first_floor, x_center + i, z_center + j, water) for i in range(-5, 6): for j in range(-5, 6): matrix.setValue(h_min + 1, x_center + i, z_center + j, water) # central base logger.info("Fountain central base height : {}".format(h_max)) for h in range(h_min, h_max): matrix.setValue(h, x_center, z_center, material) # basin for x in range(x_center - 6, x_center + 7): matrix.setValue(h_min + 1, x, z_center - 6, border) matrix.setValue(h_min + 1, x, z_center + 6, border) for z in range(z_center - 6, z_center + 7): matrix.setValue(h_min + 1, x_center - 6, z, border) matrix.setValue(h_min + 1, x_center + 6, z, border) for x in range(x_center - 4, x_center + 5): matrix.setValue(h_min, x, z_center - 4, border) matrix.setValue(h_min, x, z_center + 4, border) for z in range(z_center - 4, z_center + 5): matrix.setValue(h_min, x_center - 4, z, border) matrix.setValue(h_min, x_center + 4, z, border) for x in range(x_center - 8, x_center + 9): matrix.setValue(h_min, x, z_center - 8, border) matrix.setValue(h_min, x, z_center + 8, border) for z in range(z_center - 8, z_center + 9): matrix.setValue(h_min, x_center - 8, z, border) matrix.setValue(h_min, x_center + 8, z, border) # first floor logger.info("Fountain first floor height : {}".format(h_first_floor)) for h in range(h_min, h_first_floor): for i in range(-2, 3): for j in range(-2, 3): matrix.setValue(h, x_center + i, z_center + j, material) def generateFirstFloorLine(x): matrix.setValue(h_first_floor, x, z_center - 3, border) matrix.setValue(h_first_floor, x, z_center - 1, border) matrix.setValue(h_first_floor, x, z_center, border) matrix.setValue(h_first_floor, x, z_center + 1, border) matrix.setValue(h_first_floor, x, z_center + 3, border) generateFirstFloorLine(x_center - 3) generateFirstFloorLine(x_center + 3) matrix.setValue(h_first_floor, x_center - 1, z_center - 3, border) matrix.setValue(h_first_floor, x_center, z_center - 3, border) matrix.setValue(h_first_floor, x_center + 1, z_center - 3, border) matrix.setValue(h_first_floor, x_center - 1, z_center + 3, border) matrix.setValue(h_first_floor, x_center, z_center + 3, border) matrix.setValue(h_first_floor, x_center + 1, z_center + 3, border) # second floor logger.info("Fountain second floor height : {}".format(h_second_floor)) for h in range(h_first_floor, h_second_floor): for i in range(-1, 2): for j in range(-1, 2): matrix.setValue(h, x_center + i, z_center + j, material) matrix.setValue(h_second_floor, x_center - 1, z_center - 1, border) matrix.setValue(h_second_floor, x_center - 1, z_center + 1, border) matrix.setValue(h_second_floor, x_center + 1, z_center - 1, border) matrix.setValue(h_second_floor, x_center + 1, z_center + 1, border)
def generateBridge(matrix, height_map, p1, p2, bridge_Type): #generate a bridge between p1 and p2 logger = logging.getLogger("bridge") if bridge_Type == "Wood": bridge_Middle_Bottom = toolbox.getBlockID("wooden_slab", 5) bridge_Middle_Top = toolbox.getBlockID("wooden_slab", 13) bridge_Middle_Double = toolbox.getBlockID("double_wooden_slab", 5) bridge_Side_Bottom = toolbox.getBlockID("stone_slab", 2) bridge_Side_Top = toolbox.getBlockID("stone_slab", 10) bridge_Side_Double = toolbox.getBlockID("double_stone_slab", 10) bridge_Base = toolbox.getBlockID("grass_path") pillar_Base = toolbox.getBlockID("log") pillar = toolbox.getBlockID("oak_fence") elif bridge_Type == "Stone": bridge_Middle_Bottom = toolbox.getBlockID("stone_slab", 5) bridge_Middle_Top = toolbox.getBlockID("stone_slab", 13) bridge_Middle_Double = toolbox.getBlockID("double_wooden_slab", 5) bridge_Side_Bottom = toolbox.getBlockID("stone_slab") bridge_Side_Top = toolbox.getBlockID("stone_slab", 8) bridge_Side_Double = toolbox.getBlockID("double_wooden_slab") bridge_Base = toolbox.getBlockID("stone", 6) pillar_Base = toolbox.getBlockID("cobblestone") pillar = toolbox.getBlockID("cobblestone_wall") def getPathBridge(matrix, p1, p2): #find a path to link p1 to p2 path_bridge = [] actual_point = p1 path_bridge.append(actual_point) while actual_point != p2: if actual_point[0] < p2[0]: actual_point = (actual_point[0] + 1, actual_point[1]) path_bridge.append(actual_point) if actual_point[0] > p2[0]: actual_point = (actual_point[0] - 1, actual_point[1]) path_bridge.append(actual_point) if actual_point[1] < p2[1]: actual_point = (actual_point[0], actual_point[1] + 1) path_bridge.append(actual_point) if actual_point[1] > p2[1]: actual_point = (actual_point[0], actual_point[1] - 1) path_bridge.append(actual_point) return path_bridge def buildBridge(matrix, path_bridge, h_bridge, h_start, normal_bridge): #check if the bridge is more x or z axis if abs(path_bridge[0][0] - path_bridge[len(path_bridge) - 1][0]) >= abs( path_bridge[0][1] - path_bridge[len(path_bridge) - 1][1]): x_val = 0 z_val = 1 else: x_val = 1 z_val = 0 #build cross in the middle of the bridge matrix.setValue(h_bridge, middlepoint[0], middlepoint[1], bridge_Middle_Double) matrix.setValue(h_bridge, middlepoint[0] + x_val, middlepoint[1] + z_val, bridge_Middle_Double) matrix.setValue(h_bridge, middlepoint[0] - x_val, middlepoint[1] - z_val, bridge_Middle_Double) buildPillar(matrix, h_bridge - 1, middlepoint) #_______________________main path of the bridge______________________________ is_half_block = True h_actual = h_start #start of the bridge matrix.setValue(h_actual, path_bridge[0][0], path_bridge[0][1], bridge_Middle_Bottom) fillUnder(matrix, h_actual, path_bridge[0][0], path_bridge[0][1]) matrix.setValue(h_actual, path_bridge[1][0], path_bridge[1][1], bridge_Middle_Double) fillUnder(matrix, h_actual, path_bridge[1][0], path_bridge[1][1]) for i in range(2, len(path_bridge) - 1): #the bridge goes up if h_actual != h_bridge: if is_half_block == True: #check if we need to put a full block or 2 slabs matrix.setValue(h_actual, path_bridge[i][0], path_bridge[i][1], bridge_Middle_Top) matrix.setValue(h_actual + 1, path_bridge[i][0], path_bridge[i][1], bridge_Middle_Bottom) h_actual += 1 else: matrix.setValue(h_actual, path_bridge[i][0], path_bridge[i][1], bridge_Middle_Double) is_half_block = not is_half_block #max height reached else: matrix.setValue(h_bridge, path_bridge[i][0], path_bridge[i][1], bridge_Middle_Double) #_______________________extend the bridge on both sides______________________________ is_half_block = True h_actual = h_start barrierPut = False #start of the bridge setIfCorrect(matrix, h_actual, path_bridge[0][0] - x_val, path_bridge[0][1] - z_val, bridge_Side_Bottom) fillUnder(matrix, h_actual, path_bridge[0][0] - x_val, path_bridge[0][1] - z_val) setIfCorrect(matrix, h_actual, path_bridge[0][0] + x_val, path_bridge[0][1] + z_val, bridge_Side_Bottom) fillUnder(matrix, h_actual, path_bridge[0][0] + x_val, path_bridge[0][1] + z_val) setIfCorrect(matrix, h_actual, path_bridge[1][0] - x_val, path_bridge[1][1] - z_val, bridge_Side_Double) fillUnder(matrix, h_actual, path_bridge[1][0] - x_val, path_bridge[1][1] - z_val) setIfCorrect(matrix, h_actual, path_bridge[1][0] + x_val, path_bridge[1][1] + z_val, bridge_Side_Double) fillUnder(matrix, h_actual, path_bridge[1][0] + x_val, path_bridge[1][1] + z_val) for i in range(2, len(path_bridge) - 1): #the bridge goes up if h_actual != h_bridge: if is_half_block == True: #check if we need to put a full block or 2 slabs setIfCorrect(matrix, h_actual + 1, path_bridge[i][0] - x_val, path_bridge[i][1] - z_val, bridge_Side_Bottom) setIfCorrect(matrix, h_actual, path_bridge[i][0] - x_val, path_bridge[i][1] - z_val, bridge_Side_Top) setIfCorrect(matrix, h_actual + 1, path_bridge[i][0] + x_val, path_bridge[i][1] + z_val, bridge_Side_Bottom) setIfCorrect(matrix, h_actual, path_bridge[i][0] + x_val, path_bridge[i][1] + z_val, bridge_Side_Top) h_actual += 1 else: setIfCorrect(matrix, h_actual, path_bridge[i][0] - x_val, path_bridge[i][1] - z_val, bridge_Side_Double) setIfCorrect(matrix, h_actual, path_bridge[i][0] + x_val, path_bridge[i][1] + z_val, bridge_Side_Double) is_half_block = not is_half_block #max height reached else: setIfCorrect(matrix, h_bridge, path_bridge[i][0] - x_val, path_bridge[i][1] - z_val, bridge_Side_Double) setIfCorrect(matrix, h_bridge, path_bridge[i][0] + x_val, path_bridge[i][1] + z_val, bridge_Side_Double) #Build the barrier and light when the direction is fixed if the bridge is normal if normal_bridge == True and barrierPut == False and len( path_bridge) - i >= 2: if path_bridge[i - 1][0] != path_bridge[i][0] != path_bridge[ i + 1][0]: buildBarrierX(matrix, h_bridge, path_bridge[i:len(path_bridge)]) barrierPut = True if path_bridge[i - 1][1] != path_bridge[i][1] != path_bridge[ i + 1][1]: buildBarrierZ(matrix, h_bridge, path_bridge[i:len(path_bridge)]) barrierPut = True def fillUnder(matrix, h, x, z): #put blocks under the position if there is air (b, d) = toolbox.getBlockFullValue(matrix, h, x, z) if (b, d) == bridge_Middle_Top: matrix.setValue(h, x, z, bridge_Middle_Double) elif (b, d) == bridge_Side_Top: matrix.setValue(h, x, z, bridge_Side_Double) h -= 1 while matrix.getValue(h, x, z) in air_like + water_like: matrix.setValue(h, x, z, bridge_Side_Double) h -= 1 def cleanAbove(matrix, h, x, z): #erase block above the block selected h += 1 while matrix.getValue(h, x, z) not in air_like: matrix.setValue(h, x, z, 0) h += 1 def setIfCorrect(matrix, h, x, z, i): #put block only if the position given is correct (b, d) = toolbox.getBlockFullValue(matrix, h - 1, x, z) if matrix.getValue(h, x, z) in air_like and (b, d) not in [ bridge_Side_Double, bridge_Side_Top, bridge_Side_Bottom, bridge_Middle_Double, bridge_Middle_Top, bridge_Middle_Bottom ]: matrix.setValue(h, x, z, i) def buildPillar(matrix, h, p): #build a pillar in the water as support to bridge while matrix.getValue(h, p[0], p[1]) in air_like: matrix.setValue(h, p[0], p[1], pillar) h -= 1 while matrix.getValue(h, p[0], p[1]) in water_like: matrix.setValue(h, p[0], p[1], pillar_Base) h -= 1 def buildBarrierX(matrix, h_bridge, path_bridge ): #build barrier on the bridge going through the X axis putLight(matrix, h_bridge, path_bridge[0][0], path_bridge[0][1] - 2) putLight(matrix, h_bridge, path_bridge[0][0], path_bridge[0][1] + 2) for i in range(1, len(path_bridge)): matrix.setValue(h_bridge + 1, path_bridge[i][0], path_bridge[i][1] - 2, pillar) matrix.setValue(h_bridge + 1, path_bridge[i][0], path_bridge[i][1] + 2, pillar) def buildBarrierZ(matrix, h_bridge, path_bridge ): #build barrier on the bridge going through the Z axis putLight(matrix, h_bridge, path_bridge[0][0] - 2, path_bridge[0][1]) putLight(matrix, h_bridge, path_bridge[0][0] + 2, path_bridge[0][1]) for i in range(1, len(path_bridge)): matrix.setValue(h_bridge + 1, path_bridge[i][0] - 2, path_bridge[i][1], pillar) matrix.setValue(h_bridge + 1, path_bridge[i][0] + 2, path_bridge[i][1], pillar) def putLight(matrix, h, x, z): #build a light and a pillar under it matrix.setValue(h + 1, x, z, pillar) matrix.setValue(h + 2, x, z, pillar) matrix.setValue(h + 3, x, z, (123, 0)) matrix.setEntity(h + 4, x, z, (178, 15), "daylight_detector") buildPillar(matrix, h, (x, z)) def cleanFundation(matrix, p, height_map): #clean the endpoints of the bridge h = height_map[p[0]][p[1]] for neighbor_position in [(0, 0), (0, -1), (0, 1), (-1, 0), (1, 0), (1, 1), (-1, -1), (1, -1), (-1, 1)]: position_to_clean = (p[0] + neighbor_position[0], p[1] + neighbor_position[1]) if matrix.getValue(h + 1, position_to_clean[0], position_to_clean[1]) != 45: matrix.setValue(h, position_to_clean[0], position_to_clean[1], bridge_Base) fillUnder(matrix, h, position_to_clean[0], position_to_clean[1]) cleanAbove(matrix, h, position_to_clean[0], position_to_clean[1]) height_map[position_to_clean[0]][position_to_clean[1]] = h def buildSmallBridge(matrix, path_bridge, h): if abs(path_bridge[0][0] - path_bridge[len(path_bridge) - 1][0]) >= abs( path_bridge[0][1] - path_bridge[len(path_bridge) - 1][1]): x_val = 0 z_val = 1 else: x_val = 1 z_val = 0 for i in range(0, len(path_bridge)): x = path_bridge[i][0] z = path_bridge[i][1] matrix.setValue(h, x, z, bridge_Middle_Double) #build cross in the middle of the bridge matrix.setValue(h, middlepoint[0], middlepoint[1], bridge_Middle_Double) matrix.setValue(h, middlepoint[0] + x_val, middlepoint[1] + z_val, bridge_Middle_Double) matrix.setValue(h, middlepoint[0] - x_val, middlepoint[1] - z_val, bridge_Middle_Double) buildPillar(matrix, h - 1, middlepoint) for i in range(0, len(path_bridge) - 1): setIfCorrect(matrix, h, path_bridge[i][0] - x_val, path_bridge[i][1] - z_val, bridge_Side_Double) setIfCorrect(matrix, h, path_bridge[i][0] + x_val, path_bridge[i][1] + z_val, bridge_Side_Double) logger.info("Trying to generate Bridge between {} and {}".format(p1, p2)) #finding height h1 = height_map[p1[0]][p1[1]] h2 = height_map[p2[0]][p2[1]] h_bridge = max(h1, h2) + 2 if min(h1, h2) == h1: min_point = p1 max_point = p2 else: min_point = p2 max_point = p1 #get the path for the 2 sides of the bridge logger.info("Calculating the path for the 2 sides of the Bridge") middlepoint = (int((p1[0] + p2[0]) / 2), (int((p1[1] + p2[1]) / 2))) path_bridge1 = getPathBridge(matrix, p1, middlepoint) #first half path_bridge2 = getPathBridge(matrix, p2, middlepoint) #second half if toolbox.getManhattanDistance(p1, p2) < 6: logger.info( "Bridge too small with length : {}, generating a small one".format( toolbox.getManhattanDistance(p1, p2))) buildSmallBridge(matrix, path_bridge1, height_map[max_point[0]][max_point[1]]) buildSmallBridge(matrix, path_bridge2, height_map[max_point[0]][max_point[1]]) else: #clean the fundations only if the bridge is not small cleanFundation(matrix, p1, height_map) cleanFundation(matrix, p2, height_map) #check if the normal bridge is buildable if height_map[min_point[0]][ min_point[1]] + len(path_bridge1) * 0.5 >= h_bridge: logger.info( "Bridge size enough to go up on both sides with length : {}, generating a normal bridge" .format(toolbox.getManhattanDistance(p1, p2))) #build the bridge buildBridge(matrix, path_bridge1, h_bridge, h1 + 1, True) #first part of the bridge buildBridge(matrix, path_bridge2, h_bridge, h2 + 1, True) #second part else: #bridge can't be built that way, going up only from one side logger.info( "Bridge too small to go up on both sides with length : {}, trying to go up only from the lowest point" .format(toolbox.getManhattanDistance(p1, p2))) path_bridge = getPathBridge(matrix, min_point, max_point) #full bridge if height_map[min_point[0]][min_point[1]] + len( path_bridge ) * 0.5 >= height_map[max_point[0]][max_point[ 1]]: #check if the difference of height is still too big logger.info("Bridge buildable from one side") buildBridge(matrix, path_bridge, max(h1, h2), min(h1, h2) + 1, False) else: logger.error("Bridge not buildable, cancel generation") raise ValueError('Bridge not buildable')
def clearAboveBlock(matrix, h_min, h_max, x, z): for y in range(h_min + HEIGHT_FROM_GROUND + 2, h_max): matrix.setValue(y, x, z, toolbox.getBlockID("air", 0))
def spawnChest(matrix, wooden_materials_kit, h, x, z, socle="False"): ## generate oak log under chest if socle == True: matrix.setValue(h - 1, x, z, wooden_materials_kit["log"]) ## generate the chest matrix.setEntity(h, x, z, toolbox.getBlockID("chest", 2), "chest")
def generateHouse(matrix, wood_material, h_min, h_max, x_min, x_max, z_min, z_max, ceiling=None): logger = logging.getLogger("house") house = toolbox.dotdict() house.type = "house" house.lotArea = toolbox.dotdict({ "y_min": h_min, "y_max": h_max, "x_min": x_min, "x_max": x_max, "z_min": z_min, "z_max": z_max }) toolbox.cleanProperty(matrix, h_min + 1, h_max, x_min, x_max, z_min, z_max) (h_min, h_max, x_min, x_max, z_min, z_max) = getHouseAreaInsideLot(h_min, h_max, x_min, x_max, z_min, z_max) # calculate the top height of the walls, i.e. where the first # row of blocks of the pitched roof will be placed ceiling_bottom = h_max - int((h_max - h_min) * 0.5) house.buildArea = toolbox.dotdict({ "y_min": h_min, "y_max": ceiling_bottom, "x_min": x_min, "x_max": x_max, "z_min": z_min, "z_max": z_max }) logger.info("Generating House at area {}".format(house.lotArea)) logger.info("Construction area {}".format(house.buildArea)) ## Generates the house wooden_materials_kit = utility.wood_IDs[wood_material] wall = toolbox.getBlockID("double_stone_slab", RNG.randint(11, 15)) floor = wall ceiling = wooden_materials_kit["planks"] if ceiling == None else ceiling door_ID = wooden_materials_kit["door"][0] window = toolbox.getBlockID("glass") fence = wooden_materials_kit["fence"] fence_gate_ID = wooden_materials_kit["fence_gate"][0] path = toolbox.getBlockID("stone", 6) # generate walls from x_min+1, x_max-1, etc to leave space for the roof generateWalls(matrix, house.buildArea.y_min, house.buildArea.y_max, house.buildArea.x_min, house.buildArea.x_max, house.buildArea.z_min, house.buildArea.z_max, wall) generateFloor(matrix, house.buildArea.y_min, house.buildArea.x_min, house.buildArea.x_max, house.buildArea.z_min, house.buildArea.z_max, floor) house.orientation = getOrientation(matrix, house.lotArea) window_y = house.buildArea.y_min + 3 door_y = house.buildArea.y_min + 1 if house.orientation == "N": door_orientation = (9, 1) door_x = RNG.randint(house.buildArea.x_min + 4, house.buildArea.x_max - 4) door_z = house.buildArea.z_min generateDoor(matrix, door_y, door_x, door_z, (door_ID, door_orientation[0]), (door_ID, door_orientation[1])) house.entranceLot = (door_x, house.lotArea.z_min) # entrance path for z in range(house.lotArea.z_min, door_z): matrix.setValue(h_min, door_x, z, path) matrix.setValue(h_min, door_x - 1, z, path) matrix.setValue(h_min, door_x + 1, z, path) elif house.orientation == "S": door_orientation = (9, 3) door_x = RNG.randint(house.buildArea.x_min + 4, house.buildArea.x_max - 4) door_z = house.buildArea.z_max generateDoor(matrix, door_y, door_x, door_z, (door_ID, door_orientation[0]), (door_ID, door_orientation[1])) house.entranceLot = (door_x, house.lotArea.z_max) # entrance path for z in range(door_z + 1, house.lotArea.z_max + 1): matrix.setValue(h_min, door_x, z, path) matrix.setValue(h_min, door_x - 1, z, path) matrix.setValue(h_min, door_x + 1, z, path) elif house.orientation == "W": door_orientation = (8, 0) door_x = house.buildArea.x_min door_z = RNG.randint(house.buildArea.z_min + 4, house.buildArea.z_max - 4) generateDoor(matrix, door_y, door_x, door_z, (door_ID, door_orientation[0]), (door_ID, door_orientation[1])) house.entranceLot = (house.lotArea.x_min, door_z) # entrance path for x in range(house.lotArea.x_min, door_x): matrix.setValue(h_min, x, door_z, path) matrix.setValue(h_min, x, door_z - 1, path) matrix.setValue(h_min, x, door_z + 1, path) elif house.orientation == "E": door_orientation = (9, 2) door_x = house.buildArea.x_max door_z = RNG.randint(house.buildArea.z_min + 4, house.buildArea.z_max - 4) generateDoor(matrix, door_y, door_x, door_z, (door_ID, door_orientation[0]), (door_ID, door_orientation[1])) house.entranceLot = (house.lotArea.x_max, door_z) # entrance path for x in range(door_x + 1, house.lotArea.x_max + 1): matrix.setValue(h_min, x, door_z, path) matrix.setValue(h_min, x, door_z - 1, path) matrix.setValue(h_min, x, door_z + 1, path) if house.orientation == "N" or house.orientation == "S": generateWindow_alongX(matrix, window, window_y, house.buildArea.x_min, house.buildArea.z_min, house.buildArea.z_max) generateWindow_alongX(matrix, window, window_y, house.buildArea.x_max, house.buildArea.z_min, house.buildArea.z_max) generateCeiling_x(matrix, ceiling_bottom, h_max, x_min - 1, x_max + 1, z_min - 1, z_max + 1, ceiling, wall, 0) elif house.orientation == "E" or house.orientation == "W": generateWindow_alongZ(matrix, window, window_y, house.buildArea.z_min, house.buildArea.x_min, house.buildArea.x_max) generateWindow_alongZ(matrix, window, window_y, house.buildArea.z_max, house.buildArea.x_min, house.buildArea.x_max) generateCeiling_z(matrix, ceiling_bottom, h_max, x_min - 1, x_max + 1, z_min - 1, z_max + 1, ceiling, wall, 0) generateInterior(matrix, h_min, ceiling_bottom, house.buildArea.x_min, house.buildArea.x_max, house.buildArea.z_min, house.buildArea.z_max, ceiling) generateGarden(logger, matrix, house, fence, fence_gate_ID) return house
def cleanProperty(matrix, height_map, h_max, x_min, x_max, z_min, z_max): for x in range(x_min, x_max): for z in range(z_min, z_max): for y in range(height_map[x][z] + 1, h_max): matrix.setValue(y, x, z, toolbox.getBlockID("air"))
def generateEye(x, z): matrix.setValue(h + 1, x, z, wheatID) matrix.setValue(h + 1, x, z + 1, wheatID) matrix.setValue(h + 1, x + 1, z, wheatID) matrix.setValue(h, x + 1, z + 1, waterID) matrix.setValue(h + 1, x + 1, z + 1, toolbox.getBlockID("air"))