368 lines
12 KiB
Python
368 lines
12 KiB
Python
import re
|
|
import time
|
|
import importlib
|
|
from math import hypot
|
|
from itertools import count
|
|
|
|
from panda3d.core import LPoint3f
|
|
|
|
from minecraft.networking.packets import Packet, clientbound, serverbound
|
|
|
|
from protocol.packets import TimeUpdatePacket, SetSlotPacket, PlayerDiggingPacket, BlockBreakAnimationPacket, AcknowledgePlayerDiggingPacket, HeldItemChangePacket, PickItemPacket
|
|
|
|
import utils
|
|
importlib.reload(utils)
|
|
import path
|
|
importlib.reload(path)
|
|
import blocks
|
|
importlib.reload(blocks)
|
|
import items
|
|
importlib.reload(items)
|
|
|
|
class MCWorld:
|
|
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 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 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):
|
|
logs = []
|
|
for i in range(5):
|
|
check = utils.padd(center, utils.alternate(i, 3))
|
|
logs.extend(self.find_blocks(check, distance, blocks.LOG_IDS, 50))
|
|
|
|
trees = []
|
|
for log in logs:
|
|
# 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)
|
|
|
|
# make sure we are on the ground
|
|
if self.block_at(*utils.padd(log, path.BLOCK_BELOW)) in blocks.NON_SOLID_IDS:
|
|
continue
|
|
|
|
# crawl to the top log to count
|
|
log_count = 1
|
|
while self.block_at(*utils.padd(log, path.BLOCK_ABOVE)) in blocks.LOG_IDS:
|
|
log = utils.padd(log, path.BLOCK_ABOVE)
|
|
log_count += 1
|
|
|
|
# make sure it's a good tree
|
|
if self.block_at(*utils.padd(log, path.BLOCK_ABOVE)) in blocks.LEAF_IDS and log_count > 2:
|
|
# crawl back 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)
|
|
trees.append(log)
|
|
|
|
trees.sort(key=lambda x: utils.phyp(center, x))
|
|
return trees
|
|
|
|
def find_tree_openings(self, tree):
|
|
# returns coords in a cardinal direction where we can stand by tree
|
|
maze_solver = path.Pathfinder(self.g.chunks)
|
|
result = []
|
|
|
|
# TODO: make sure only non-solid and leaves between
|
|
# make sure traversable too
|
|
|
|
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.chunks)
|
|
|
|
try:
|
|
s = maze_solver.astar(start, place)
|
|
return list(s) if s else None
|
|
except AStarTimeout:
|
|
return None
|
|
|
|
def find_bed_areas(self, center, distance):
|
|
air = []
|
|
for i in range(5):
|
|
check = utils.padd(center, utils.alternate(i, 1))
|
|
air.extend(self.find_blocks(check, distance, [0], 200))
|
|
|
|
areas = []
|
|
for a in air:
|
|
# check for ground around the area
|
|
if len(self.find_blocks(utils.padd(a, path.BLOCK_BELOW), 2, blocks.NON_SOLID_IDS, 9)):
|
|
continue
|
|
|
|
# check for air around the area
|
|
if len(self.find_blocks(a, 2, [0], 9)) < 9:
|
|
continue
|
|
|
|
# check for air above the area
|
|
if len(self.find_blocks(utils.padd(a, path.BLOCK_ABOVE), 2, [0], 9)) < 9:
|
|
continue
|
|
|
|
areas.append(a)
|
|
|
|
areas.sort(key=lambda x: utils.phyp(center, x))
|
|
return areas
|
|
|
|
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, origin):
|
|
sand = []
|
|
for i in range(10):
|
|
check = utils.padd(center, utils.alternate(i, 1))
|
|
sand.extend(self.find_blocks(check, distance, [66], 20))
|
|
|
|
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_bias(center, x, origin))
|
|
return safe_sand
|
|
|
|
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
|
|
|
|
|
|
class Game:
|
|
def __init__(self, global_state):
|
|
self.g = global_state
|
|
|
|
register = self.g.connection.register_packet_listener
|
|
register(self.handle_block_change, clientbound.play.BlockChangePacket)
|
|
register(self.handle_join_game, clientbound.play.JoinGamePacket)
|
|
register(self.handle_position_and_look, clientbound.play.PlayerPositionAndLookPacket)
|
|
register(self.handle_time_update, TimeUpdatePacket)
|
|
register(self.handle_set_slot, SetSlotPacket)
|
|
register(self.handle_break_animation, BlockBreakAnimationPacket)
|
|
register(self.handle_break_ack, AcknowledgePlayerDiggingPacket)
|
|
|
|
self.g.chat.set_handler(self.handle_chat)
|
|
|
|
def handle_join_game(self, packet):
|
|
print('Connected.')
|
|
print(packet)
|
|
self.g.info = packet
|
|
self.g.eid = packet.entity_id
|
|
|
|
def handle_block_change(self, packet):
|
|
if packet.block_state_id == blocks.SOUL_TORCH:
|
|
try:
|
|
self.g.goal = LPoint3f(x=packet.location[0], y=packet.location[1], z=packet.location[2])
|
|
print('new waypoint:', self.g.goal)
|
|
|
|
start = time.time()
|
|
solution = path.Pathfinder(self.g.chunks).astar(utils.pint(self.g.pos), utils.pint(self.g.goal))
|
|
if solution:
|
|
solution = list(solution)
|
|
self.g.path = solution
|
|
#g.jobstate.state = self.g.jobstate.stop
|
|
print(len(solution))
|
|
print(solution)
|
|
print(round(time.time() - start, 3), 'seconds')
|
|
else:
|
|
print('No path found')
|
|
#say(connection, 'No path found')
|
|
|
|
#g.y_v = 10.0
|
|
#g.y_a = -36.0
|
|
except BaseException as e:
|
|
import traceback
|
|
print(traceback.format_exc())
|
|
|
|
def handle_position_and_look(self, packet):
|
|
print('pos and look:')
|
|
print(packet)
|
|
p = LPoint3f(x=packet.x, y=packet.y, z=packet.z)
|
|
self.g.pos = p
|
|
|
|
def handle_chat(self, message):
|
|
source, text = message
|
|
reply = None
|
|
|
|
match = re.match(r'<(\w+)> (.*)', text)
|
|
if match:
|
|
sender, text = match.groups()
|
|
else:
|
|
return
|
|
|
|
if text.startswith('! '):
|
|
text = text[2:]
|
|
elif text.startswith('!'):
|
|
text = text[1:]
|
|
else:
|
|
return
|
|
|
|
if ' ' in text:
|
|
command = text.split(' ', 1)[0]
|
|
data = text.split(' ', 1)[1]
|
|
else:
|
|
command = text
|
|
|
|
if command == 'ping':
|
|
reply = 'pong'
|
|
|
|
if command == 'echo' and data:
|
|
reply = data
|
|
|
|
if command == 'respawn':
|
|
packet = serverbound.play.ClientStatusPacket()
|
|
packet.action_id = serverbound.play.ClientStatusPacket.RESPAWN
|
|
self.g.connection.write_packet(packet)
|
|
reply = 'ok'
|
|
|
|
if command == 'pos':
|
|
reply = str(utils.pint(self.g.pos))[1:-1]
|
|
|
|
if command == 'afk':
|
|
reply = '/afk'
|
|
|
|
if command == 'error':
|
|
reply = 'ok'
|
|
raise
|
|
|
|
if command == 'break':
|
|
self.break_block((616, 78, 496))
|
|
reply = 'ok'
|
|
|
|
if command == 'gather' and data:
|
|
if data == 'wood':
|
|
self.g.job.state = self.g.job.lumberjack
|
|
reply = 'ok'
|
|
|
|
if reply:
|
|
for i in self.g.inv.values():
|
|
print(i.item_id)
|
|
if i.item_id in items.BED_IDS:
|
|
break
|
|
else:
|
|
reply += ', I need a bed'
|
|
|
|
if command == 'inv':
|
|
for i in self.g.inv.values():
|
|
if i.present:
|
|
print(items.ITEM_NAMES[i.item_id], 'x', i.item_count)
|
|
|
|
if command == 'time':
|
|
reply = str(self.g.time)
|
|
|
|
if reply:
|
|
print(reply)
|
|
self.g.chat.send(reply)
|
|
|
|
def handle_time_update(self, packet):
|
|
self.g.time = packet.time_of_day % 24000
|
|
|
|
def handle_set_slot(self, packet):
|
|
print(packet)
|
|
if packet.window_id == 0:
|
|
self.g.inv[packet.slot] = packet.slot_data
|
|
|
|
def break_block(self, location):
|
|
bid = self.g.chunks.get_block_at(*location)
|
|
if bid != 0:
|
|
packet = PlayerDiggingPacket()
|
|
packet.status = 0
|
|
packet.location = location
|
|
packet.face = 1
|
|
self.g.connection.write_packet(packet)
|
|
|
|
self.g.breaking = location
|
|
self.g.break_time = time.time() + utils.break_time(bid)
|
|
|
|
def break_finish(self):
|
|
packet = PlayerDiggingPacket()
|
|
packet.status = 2
|
|
packet.location = self.g.breaking
|
|
packet.face = 1
|
|
self.g.connection.write_packet(packet)
|
|
self.g.chunks.set_block_at(*self.g.breaking, 0)
|
|
self.g.breaking = None
|
|
|
|
|
|
def handle_break_animation(self, packet):
|
|
print(packet)
|
|
|
|
def handle_break_ack(self, packet):
|
|
#print(packet)
|
|
return
|
|
|
|
def animate(self):
|
|
packet = serverbound.play.AnimationPacket()
|
|
packet.hand = packet.HAND_MAIN
|
|
self.g.connection.write_packet(packet)
|
|
|
|
def place_block(self, location, face):
|
|
packet = serverbound.play.PlayerBlockPlacementPacket()
|
|
packet.hand = 0
|
|
packet.location = location
|
|
packet.face = face
|
|
packet.x = 0.5
|
|
packet.y = 0.5
|
|
packet.z = 0.5
|
|
packet.inside_block = False
|
|
self.g.connection.write_packet(packet)
|
|
|
|
def pick(self, slot):
|
|
packet = PickItemPacket()
|
|
packet.slot_to_use = slot
|
|
self.g.connection.write_packet(packet)
|
|
|
|
def hold(self, slot):
|
|
packet = HeldItemChangePacket()
|
|
packet.slot = slot
|
|
self.g.connection.write_packet(packet)
|
|
|
|
def choose_slot(self, slot):
|
|
if slot >= 36:
|
|
slot -= 36
|
|
self.hold(slot)
|
|
else:
|
|
self.pick(slot)
|
|
|
|
def tick(self):
|
|
if self.g.breaking:
|
|
self.animate()
|
|
|
|
if time.time() >= self.g.break_time - 2*utils.TICK:
|
|
self.break_finish()
|