363 lines
13 KiB
Python
363 lines
13 KiB
Python
import collections
|
|
import re
|
|
import time
|
|
import random
|
|
from itertools import count
|
|
from copy import copy
|
|
|
|
from mosfet import utils
|
|
from mosfet import path
|
|
from mosfet.info import blocks
|
|
from mosfet.info import mobs
|
|
|
|
class World:
|
|
def __init__(self, global_state):
|
|
self.g = global_state
|
|
|
|
def block_at(self, x, y, z):
|
|
return self.g.chunks.get_block_at(x, y, z)
|
|
|
|
def check_air_column(self, pos, distance):
|
|
for i in range(distance):
|
|
check = utils.padd(pos, (0, i, 0))
|
|
if self.block_at(*check) not in blocks.NON_SOLID_IDS:
|
|
return False
|
|
return True
|
|
|
|
def find_blocks_3d(self, center, block_ids, distance=0, y_limit=0, thru_air=False):
|
|
to_visit = collections.deque([(0, 0, 0)])
|
|
visited = set()
|
|
|
|
while to_visit:
|
|
cur = to_visit.pop()
|
|
if cur in visited:
|
|
continue
|
|
if y_limit and abs(cur[1]) > y_limit:
|
|
continue
|
|
if distance and utils.hypot(*cur) > distance:
|
|
continue
|
|
|
|
check = utils.padd(center, cur)
|
|
|
|
if not thru_air or self.block_at(*check) in blocks.NON_SOLID_IDS:
|
|
for neighbor in utils.get_neighbors_3d(*cur):
|
|
to_visit.appendleft(neighbor)
|
|
|
|
visited.add(cur)
|
|
|
|
if self.block_at(*check) in block_ids:
|
|
yield check
|
|
|
|
def find_blocks_indexed(self, center, block_ids, distance=0):
|
|
print('finding', block_ids)
|
|
index = []
|
|
for bid in block_ids:
|
|
index.extend(self.g.chunks.index.get(bid, []))
|
|
|
|
print('index', index)
|
|
|
|
result = []
|
|
for block in index:
|
|
if self.block_at(*block) not in block_ids:
|
|
continue
|
|
if distance and utils.phyp(center, block) > distance:
|
|
continue
|
|
if block not in result:
|
|
result.append(block)
|
|
|
|
result.sort(key=lambda x: utils.phyp(center, x))
|
|
return result
|
|
|
|
def find_blocks(self, center, distance, block_ids, limit=0):
|
|
# search in a spiral from center to all blocks with ID
|
|
result = []
|
|
for n in count():
|
|
offset = utils.spiral(n)
|
|
check = utils.padd(center, offset)
|
|
if self.block_at(*check) in block_ids:
|
|
if utils.hypot(*offset) < distance:
|
|
result.append(check)
|
|
if limit and len(result) == limit:
|
|
return result
|
|
if offset[0] > distance:
|
|
return result
|
|
|
|
def find_trees(self, center, distance):
|
|
found_trees = []
|
|
for log in self.find_blocks_3d(center, blocks.LOG_IDS, distance, 15):
|
|
# crawl to the bottom log
|
|
while self.block_at(*utils.padd(log, path.BLOCK_BELOW)) in blocks.LOG_IDS:
|
|
log = utils.padd(log, path.BLOCK_BELOW)
|
|
base = log
|
|
|
|
if base in found_trees:
|
|
continue
|
|
|
|
# make sure we are on the ground
|
|
if self.block_at(*utils.padd(base, path.BLOCK_BELOW)) in blocks.NON_SOLID_IDS:
|
|
continue
|
|
|
|
# crawl to the top log to count and check leaves
|
|
log_count = 1
|
|
good_leaves = False
|
|
while self.block_at(*utils.padd(log, path.BLOCK_ABOVE)) in blocks.LOG_IDS:
|
|
log = utils.padd(log, path.BLOCK_ABOVE)
|
|
log_count += 1
|
|
|
|
for offset in path.CHECK_DIRECTIONS:
|
|
if self.block_at(*utils.padd(log, offset)) in blocks.LEAF_IDS:
|
|
good_leaves = True
|
|
|
|
# make sure it's a good tree
|
|
if not good_leaves or log_count < 3:
|
|
continue
|
|
|
|
found_trees.append(base)
|
|
|
|
yield base
|
|
|
|
def find_tree_openings(self, tree):
|
|
# returns coords in a cardinal direction where we can stand by tree
|
|
maze_solver = path.Pathfinder(self.g)
|
|
result = []
|
|
|
|
# TODO: make sure only non-solid and leaves between
|
|
# make sure traversable too and non-avoid
|
|
|
|
for distance in range(5):
|
|
for direction in path.CHECK_DIRECTIONS:
|
|
offset = utils.pmul(direction, distance+1)
|
|
if maze_solver.check_traverse(tree, offset):
|
|
result.append(utils.padd(tree, offset))
|
|
return result
|
|
|
|
def path_to_place(self, start, place):
|
|
maze_solver = path.Pathfinder(self.g)
|
|
|
|
try:
|
|
s = maze_solver.astar(start, place)
|
|
return list(s) if s else None
|
|
except path.AStarTimeout:
|
|
return None
|
|
|
|
def path_to_place_faked(self, start, place):
|
|
# same as above, but adds a fake block below and air before pathfinding
|
|
# so that the pathfinder can actually make it to the block
|
|
c = self.g.chunks
|
|
above = utils.padd(place, path.BLOCK_ABOVE)
|
|
below = utils.padd(place, path.BLOCK_BELOW)
|
|
|
|
tmp = c.get_block_at(*place)
|
|
tmp2 = c.get_block_at(*above)
|
|
tmp3 = c.get_block_at(*below)
|
|
c.set_block_at(*place, blocks.AIR)
|
|
c.set_block_at(*above, blocks.AIR)
|
|
c.set_block_at(*below, blocks.STONE)
|
|
navpath = self.path_to_place(start, place)
|
|
c.set_block_at(*place, tmp)
|
|
c.set_block_at(*above, tmp2)
|
|
c.set_block_at(*below, tmp3)
|
|
|
|
return navpath
|
|
|
|
def find_bed_areas(self, center, distance):
|
|
bed_clearance = 9 # 5x5 area
|
|
clear_distance = 2
|
|
|
|
for a in self.find_blocks_3d(center, [0], distance, 50):
|
|
# check for air around the area
|
|
if len(self.find_blocks(a, clear_distance, [0], bed_clearance)) < bed_clearance:
|
|
continue
|
|
|
|
# check for ground around the area
|
|
if len(self.find_blocks(utils.padd(a, path.BLOCK_BELOW), clear_distance, blocks.NON_SOLID_IDS, bed_clearance)):
|
|
continue
|
|
|
|
# check for air above the area
|
|
if len(self.find_blocks(utils.padd(a, path.BLOCK_ABOVE), clear_distance, [0], bed_clearance)) < bed_clearance:
|
|
continue
|
|
|
|
# ensure there's no monsters within 20 blocks
|
|
# can't sleep if they are within 10, good to have a buffer
|
|
if self.find_monsters(a, 20):
|
|
continue
|
|
|
|
yield a
|
|
|
|
def find_cache_areas(self, center, distance):
|
|
return self.find_bed_areas(center, distance)
|
|
|
|
def sand_adjacent_safe(self, sand):
|
|
for direction in path.CHECK_DIRECTIONS:
|
|
if self.block_at(*utils.padd(sand, direction)) in blocks.AVOID_IDS:
|
|
return False
|
|
return True
|
|
|
|
def find_sand(self, center, distance, player):
|
|
sand = []
|
|
sand.extend(self.find_blocks(center, distance, [blocks.SAND], 25))
|
|
|
|
safe_sand = []
|
|
for s in sand:
|
|
# make sure it has solid below
|
|
if self.block_at(*utils.padd(s, path.BLOCK_BELOW)) in blocks.NON_SOLID_IDS:
|
|
continue
|
|
# make sure it has solid two below - prevent hanging sand
|
|
if self.block_at(*utils.padd(s, path.BLOCK_BELOW2)) in blocks.NON_SOLID_IDS:
|
|
continue
|
|
|
|
# and walkable air above
|
|
if self.block_at(*utils.padd(s, path.BLOCK_ABOVE)) not in blocks.NON_SOLID_IDS:
|
|
continue
|
|
|
|
if not self.sand_adjacent_safe(s):
|
|
continue
|
|
|
|
safe_sand.append(s)
|
|
|
|
safe_sand.sort(key=lambda x: utils.phyp(player, x))
|
|
return safe_sand
|
|
|
|
def check_sand_slice(self, center):
|
|
# checks if a 5x5x1 slice has sand in it
|
|
for i in range(9):
|
|
s = utils.padd(center, utils.spiral(i))
|
|
if self.block_at(*s) != blocks.SAND:
|
|
continue
|
|
# make sure it has solid below
|
|
if self.block_at(*utils.padd(s, path.BLOCK_BELOW)) in blocks.NON_SOLID_IDS:
|
|
continue
|
|
# make sure it has solid two below - prevent hanging sand
|
|
if self.block_at(*utils.padd(s, path.BLOCK_BELOW2)) in blocks.NON_SOLID_IDS:
|
|
continue
|
|
# and walkable air above
|
|
if self.block_at(*utils.padd(s, path.BLOCK_ABOVE)) not in blocks.NON_SOLID_IDS:
|
|
continue
|
|
if not self.sand_adjacent_safe(s):
|
|
continue
|
|
return True
|
|
|
|
return False
|
|
|
|
def find_sand_slice(self, center, distance, y_limit=0, bad_slices=[], prev_layer=0):
|
|
# returns the centre coord of the next 5x5x1 slice that still has
|
|
# diggable sand in it. lower slices are only valid if there's an
|
|
# adjacent slice farther at the same level. this should ensure an
|
|
# upside down pyramid gets excavated so the edges are still climbable
|
|
for v in count(prev_layer):
|
|
peak = utils.padd(center, (0, 10-v, 0))
|
|
|
|
slices = []
|
|
layer = 0
|
|
for step in count():
|
|
offset = utils.spiral(step)
|
|
layer = max(layer, *offset)
|
|
offset = utils.pmul(offset, 3)
|
|
check = utils.padd(peak, offset)
|
|
check = utils.padd(check, (0, layer, 0))
|
|
|
|
if y_limit and check[1] - center[1] > y_limit:
|
|
break
|
|
if utils.phyp_king(center, check) > distance:
|
|
break
|
|
|
|
if self.check_sand_slice(check) and check not in bad_slices:
|
|
slices.append(check)
|
|
|
|
if len(slices):
|
|
return v, slices[-1]
|
|
elif v > 40:
|
|
return None, None
|
|
|
|
|
|
def find_bed_openings(self, area):
|
|
# returns coords in a cardinal direction where we can stand by bed
|
|
result = []
|
|
|
|
for direction in path.CHECK_DIRECTIONS:
|
|
result.append(utils.padd(area, direction))
|
|
return result
|
|
|
|
def check_bed_occupied(self, bed):
|
|
# returns true if the bed is occupied by a player
|
|
print('Checking bed occupancy:', bed)
|
|
for player in self.g.players.values():
|
|
ppos = utils.pint((player.x, player.y, player.z))
|
|
if utils.phyp(bed, ppos) <= 1 and player.y - int(player.y) == 0.6875:
|
|
print('Bed is occupied by:', player, self.g.player_names[player.player_uuid])
|
|
return True
|
|
return False
|
|
|
|
def find_cache_openings(self, area):
|
|
return self.find_bed_openings(area)
|
|
|
|
def find_objects(self, object_ids):
|
|
result = []
|
|
for eid, obj in copy(self.g.objects).items():
|
|
if obj.get('item_id', None) in object_ids:
|
|
result.append(obj)
|
|
return result
|
|
|
|
def find_leaves(self, center, distance):
|
|
for a in self.find_blocks_3d(center, blocks.LEAF_IDS, distance, 10):
|
|
yield a
|
|
|
|
def find_monsters(self, center, distance):
|
|
# finds monsters within distance
|
|
result = []
|
|
for eid, mob in copy(self.g.mobs).items():
|
|
if mob.type not in mobs.EVIL_IDS:
|
|
continue
|
|
pos = utils.pint((mob.x, mob.y, mob.z))
|
|
if utils.phyp(center, pos) > distance:
|
|
continue
|
|
result.append(mob)
|
|
return result
|
|
|
|
def find_threats(self, center, distance):
|
|
# finds monsters on the surface within distance
|
|
monsters = self.find_monsters(center, distance)
|
|
result = []
|
|
for mob in monsters:
|
|
pos = utils.pint((mob.x, mob.y, mob.z))
|
|
# check distance number of blocks above, close enough?
|
|
if not self.check_air_column(pos, distance):
|
|
continue
|
|
result.append(mob)
|
|
return result
|
|
|
|
def find_villagers(self, center, distance):
|
|
# finds villagers within distance
|
|
result = []
|
|
for eid, mob in copy(self.g.mobs).items():
|
|
type_name = mobs.MOB_NAMES[mob.type]
|
|
if type_name != 'villager' : continue
|
|
pos = utils.pint((mob.x, mob.y, mob.z))
|
|
if utils.phyp(center, pos) > distance:
|
|
continue
|
|
result.append(mob)
|
|
return result
|
|
|
|
def find_villager_openings(self, villager):
|
|
# returns coords in a cardinal direction where we can stand by a villager
|
|
maze_solver = path.Pathfinder(self.g)
|
|
result = []
|
|
|
|
for distance in range(3):
|
|
for direction in path.CHECK_DIRECTIONS:
|
|
offset = utils.pmul(direction, distance+1)
|
|
|
|
if not maze_solver.check_traverse(villager, offset):
|
|
continue
|
|
|
|
# check for line of sight
|
|
for check in range(distance+1):
|
|
offset2 = utils.pmul(direction, check+1)
|
|
offset2 = utils.padd(offset2, path.BLOCK_ABOVE)
|
|
check = utils.padd(villager, offset2)
|
|
if self.block_at(*check) not in blocks.NON_SOLID_IDS:
|
|
break
|
|
else: # for
|
|
result.append(utils.padd(villager, offset))
|
|
return result
|