1356 lines
48 KiB
Python
1356 lines
48 KiB
Python
import re
|
|
import time
|
|
import importlib
|
|
import random
|
|
import functools
|
|
from math import hypot
|
|
from itertools import count
|
|
from munch import Munch
|
|
from copy import copy
|
|
|
|
from vector import Point3D
|
|
|
|
from minecraft.networking.packets import Packet, clientbound, serverbound
|
|
from minecraft.networking.types import BlockFace
|
|
|
|
from protocol.packets import (
|
|
SetSlotPacket, PlayerDiggingPacket,
|
|
BlockBreakAnimationPacket, AcknowledgePlayerDiggingPacket,
|
|
HeldItemChangePacket, PickItemPacket, OpenWindowPacket,
|
|
ClickWindowPacket, CloseWindowPacket, ServerWindowConfirmationPacket,
|
|
ClientWindowConfirmationPacket, EntityMetadataPacket,
|
|
SpawnLivingEntityPacket, EntityPositionRotationPacket, DestroyEntitiesPacket,
|
|
EntityActionPacket, EntityTeleport, InteractEntityPacket, TradeListPacket,
|
|
SelectTradePacket, DisconnectPacket,
|
|
)
|
|
|
|
from protocol.types import Slot
|
|
import print_help
|
|
|
|
import utils
|
|
import path
|
|
import blocks
|
|
import items
|
|
import mcdata
|
|
import mobs
|
|
import bot
|
|
|
|
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 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):
|
|
for offset in utils.search_3d(distance, y_limit):
|
|
check = utils.padd(center, offset)
|
|
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 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 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 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
|
|
|
|
|
|
class Game:
|
|
def __init__(self, global_state):
|
|
self.g = global_state
|
|
|
|
register = self.g.connection.register_packet_listener
|
|
register(self.handle_login_success, clientbound.login.LoginSuccessPacket)
|
|
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, clientbound.play.TimeUpdatePacket)
|
|
register(self.handle_set_slot, SetSlotPacket)
|
|
register(self.handle_break_animation, BlockBreakAnimationPacket)
|
|
register(self.handle_break_ack, AcknowledgePlayerDiggingPacket)
|
|
register(self.handle_window, OpenWindowPacket)
|
|
register(self.handle_window_confirmation, ClientWindowConfirmationPacket)
|
|
register(self.handle_spawn_object, clientbound.play.SpawnObjectPacket)
|
|
register(self.handle_entity_metadata, EntityMetadataPacket)
|
|
register(self.handle_spawn_living, SpawnLivingEntityPacket)
|
|
register(self.handle_entity_position, clientbound.play.EntityPositionDeltaPacket)
|
|
register(self.handle_entity_position_rotation, EntityPositionRotationPacket)
|
|
register(self.handle_destroy_entities, DestroyEntitiesPacket)
|
|
register(self.handle_spawn_player, clientbound.play.SpawnPlayerPacket)
|
|
register(self.handle_respawn, clientbound.play.RespawnPacket)
|
|
register(self.handle_player_list, clientbound.play.PlayerListItemPacket)
|
|
register(self.handle_entity_teleport, EntityTeleport)
|
|
register(self.handle_update_health, clientbound.play.UpdateHealthPacket)
|
|
#register(self.handle_entity_velocity, clientbound.play.EntityVelocityPacket)
|
|
register(self.handle_trade_list, TradeListPacket)
|
|
register(self.handle_disconnect, DisconnectPacket)
|
|
|
|
#register(self.handle_packet, Packet, early=True)
|
|
|
|
self.g.chat.set_handler(self.handle_chat)
|
|
|
|
def handle_login_success(self, packet):
|
|
print(packet)
|
|
self.g.name = packet.Username
|
|
|
|
def handle_join_game(self, packet):
|
|
print('Connected.')
|
|
print(packet)
|
|
self.g.info = packet
|
|
self.g.eid = packet.entity_id
|
|
self.g.dimension = packet.world_name.replace('minecraft:', '')
|
|
|
|
def handle_block_change(self, packet):
|
|
if packet.block_state_id == blocks.SOUL_TORCH:
|
|
try:
|
|
self.g.goal = Point3D((packet.location[0], packet.location[1], packet.location[2]))
|
|
print('new waypoint:', self.g.goal)
|
|
|
|
start = time.time()
|
|
solution = path.Pathfinder(self.g).astar(utils.pint(self.g.pos), utils.pint(self.g.goal))
|
|
if solution:
|
|
solution = list(solution)
|
|
self.g.path = solution
|
|
if self.g.job:
|
|
self.g.job.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())
|
|
|
|
#print(packet)
|
|
|
|
def handle_position_and_look(self, packet):
|
|
print(packet)
|
|
p = Point3D((packet.x, packet.y, packet.z))
|
|
self.g.pos = p
|
|
|
|
confirm_packet = serverbound.play.TeleportConfirmPacket()
|
|
confirm_packet.teleport_id = packet.teleport_id
|
|
self.g.connection.write_packet(confirm_packet)
|
|
|
|
self.g.correction_count += 1
|
|
|
|
if self.g.get('path', None) and self.g.correction_count > 5:
|
|
self.g.correction_count = 0
|
|
dest = self.g.path[-1]
|
|
w = self.g.world
|
|
p = utils.pint(self.g.pos)
|
|
new_path = w.path_to_place(p, dest)
|
|
|
|
if new_path:
|
|
self.g.path = new_path
|
|
|
|
def handle_chat(self, message):
|
|
source, text = message
|
|
reply = None
|
|
private = False
|
|
for_me = False
|
|
authed = False
|
|
|
|
if source == 'SYSTEM':
|
|
self.g.command_lock = False
|
|
|
|
if text == 'You are now AFK.':
|
|
self.g.afk = True
|
|
elif text == 'You are no longer AFK.':
|
|
self.g.afk = False
|
|
|
|
match1 = re.match(r'<?(\w+)> (.*)', text)
|
|
match2 = re.match(r'\[(\w+) -> me] (.*)', text)
|
|
if match1:
|
|
sender, text = match1.groups()
|
|
elif match2:
|
|
sender, text = match2.groups()
|
|
private = True
|
|
else:
|
|
return
|
|
|
|
if sender == 'tanner6':
|
|
authed = True
|
|
|
|
if text.startswith('zzz'):
|
|
text = '!zzz'
|
|
|
|
bot_num = self.g.name[-1]
|
|
|
|
if text.startswith(bot_num):
|
|
text = text[1:]
|
|
for_me = True
|
|
elif 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
|
|
data = None
|
|
|
|
try:
|
|
|
|
## ### Public Commands
|
|
## These can be ran by anyone, all bots will reply.
|
|
|
|
## !help - prints this whole help message to console
|
|
## !help [command] - replies in-game explaining command
|
|
if command == 'help':
|
|
if data:
|
|
for line in print_help.HELP_LINES:
|
|
if line[1:].startswith(data) or line[1:].startswith(data[1:]):
|
|
reply = 'command ' + line
|
|
break
|
|
else: # for
|
|
reply = 'command not found'
|
|
else:
|
|
print()
|
|
print()
|
|
for line in print_help.HELP_LINES:
|
|
print(line)
|
|
reply = 'check console'
|
|
|
|
## !ping - replies with "pong"
|
|
if command == 'ping':
|
|
reply = 'pong'
|
|
|
|
## !echo [data] - replies with "data"
|
|
if command == 'echo' and data:
|
|
reply = data
|
|
|
|
## !pos - replies with position and dimension
|
|
if command == 'pos':
|
|
reply = str(utils.pint(self.g.pos))[1:-1] + ', ' + self.g.dimension
|
|
|
|
## !afk - goes AFK with /afk
|
|
if command == 'afk':
|
|
if not self.g.afk:
|
|
reply = '/afk'
|
|
|
|
## !unafk - goes not AFK with /afk
|
|
if command == 'unafk':
|
|
if self.g.afk:
|
|
reply = '/afk'
|
|
|
|
## !error - raises an error
|
|
if command == 'error':
|
|
reply = 'ok'
|
|
raise
|
|
|
|
## !inv - prints current inventory
|
|
if command == 'inv':
|
|
inv_list = []
|
|
for i in self.g.inv.values():
|
|
if i.present:
|
|
inv_list.append('{}:{} x {}'.format(items.ITEM_NAMES[i.item_id], str(i.item_id), i.item_count))
|
|
inv_list.sort()
|
|
result = '\n'.join(inv_list)
|
|
print(result or 'Empty')
|
|
|
|
## !time - replies with Minecraft world time
|
|
if command == 'time':
|
|
reply = str(self.g.time)
|
|
|
|
## !count [id] - counts the number of items with that id
|
|
if command == 'count' and data:
|
|
item = int(data)
|
|
reply = str(self.count_items([item]))
|
|
|
|
## !loaded - replies with the current loaded area
|
|
if command == 'loaded':
|
|
reply = str(self.g.chunks.get_loaded_area())
|
|
|
|
## !players - prints the current players
|
|
## !players clear - clears the current player list
|
|
if command == 'players':
|
|
if data == 'clear':
|
|
self.g.players = {}
|
|
reply = 'ok'
|
|
else:
|
|
for k, v in self.g.players.items():
|
|
print(str(k) + ':', v, self.g.player_names[v.player_uuid])
|
|
|
|
## !objects - prints the current items on ground
|
|
## !objects clear - clears the current object list
|
|
if command == 'objects':
|
|
if data == 'clear':
|
|
self.g.objects = {}
|
|
reply = 'ok'
|
|
else:
|
|
for k, v in self.g.objects.items():
|
|
if data and v.item_id != int(data): continue
|
|
print(str(k) + ':', v, items.ITEM_NAMES[v.item_id])
|
|
|
|
## !mobs - prints the current mobs
|
|
## !mobs clear - clears the current mob list
|
|
if command == 'mobs':
|
|
if data == 'clear':
|
|
self.g.mobs = {}
|
|
reply = 'ok'
|
|
else:
|
|
all_mobs = sorted(list(self.g.mobs.items()), key=lambda x: x[1].type)
|
|
for k, v in all_mobs:
|
|
if data and v.type != int(data): continue
|
|
print(str(k) + ':', v, mobs.MOB_NAMES[v.type])
|
|
reply = str(len(all_mobs)) + ' mobs'
|
|
|
|
## !monsters - prints the current monsters
|
|
if command == 'monsters':
|
|
monsters = sorted(list(self.g.mobs.items()), key=lambda x: x[1].type)
|
|
count = 0
|
|
for k, v in monsters:
|
|
if v.type not in mobs.EVIL_IDS: continue
|
|
if data and v.type != int(data): continue
|
|
count += 1
|
|
print(str(k) + ':', v, mobs.MOB_NAMES[v.type])
|
|
reply = str(count) + ' monsters'
|
|
|
|
## !villagers - prints the current villagers
|
|
if command == 'villagers':
|
|
all_mobs = sorted(list(self.g.mobs.items()), key=lambda x: x[1].type)
|
|
count = 0
|
|
for k, v in all_mobs:
|
|
type_name = mobs.MOB_NAMES[v.type]
|
|
if type_name != 'villager' : continue
|
|
count += 1
|
|
print(str(k) + ':', v, type_name)
|
|
reply = str(count) + ' villagers'
|
|
|
|
## !threats - prints the dangerous monsters within 20 blocks
|
|
## !threats [num] - prints the dangerous monsters within num blocks
|
|
if command == 'threats':
|
|
distance = int(data) if data else 20
|
|
p = utils.pint(self.g.pos)
|
|
threats = self.g.world.find_threats(p, distance)
|
|
|
|
for t in threats:
|
|
print(str(t.entity_id) + ':', t, mobs.MOB_NAMES[t.type])
|
|
reply = str(len(threats)) + ' threats'
|
|
|
|
if command == 'spiral' and data:
|
|
for i in range(int(data)):
|
|
print(utils.spiral(i))
|
|
|
|
if command == 'sand_slice':
|
|
result = self.g.world.find_sand_slice(utils.pint(self.g.pos), 50)
|
|
reply = str(result)
|
|
|
|
## "zzz" or !zzz - bot does /afk to let others sleep
|
|
if command == 'zzz':
|
|
if not self.g.afk and self.g.dimension == 'overworld':
|
|
reply = '/afk'
|
|
self.g.afk_timeout = 5.0
|
|
|
|
## !tree - replies with the closest tree
|
|
if command == 'tree':
|
|
pos = utils.pint(self.g.pos)
|
|
tree = next(self.g.world.find_trees(pos, 50))
|
|
reply = str(tree)[1:-1]
|
|
|
|
## !block x y z - replies what block is at (x, y, z)
|
|
if command == 'block':
|
|
try:
|
|
data = data.replace('(', ' ').replace(')', ' ').replace(',', ' ')
|
|
x1, y1, z1 = [int(x) for x in data.split()]
|
|
except (AttributeError, ValueError):
|
|
reply = 'usage: !block x1 y1 z1'
|
|
|
|
if not reply:
|
|
coord = (x1, y1, z1)
|
|
block = self.g.world.block_at(*coord)
|
|
|
|
if not reply and block is None:
|
|
reply = 'first coord out of range'
|
|
|
|
if not reply:
|
|
reply = blocks.BLOCKS[block] + ':' + str(block)
|
|
|
|
|
|
################# Specific commands ##########################
|
|
|
|
## ### Bot-specific Commands
|
|
## These will only run for the bot they are addressed to.
|
|
|
|
if for_me:
|
|
pass
|
|
|
|
## 1respawn - respawns the bot if it's dead
|
|
if command == 'respawn':
|
|
packet = serverbound.play.ClientStatusPacket()
|
|
packet.action_id = serverbound.play.ClientStatusPacket.RESPAWN
|
|
self.g.connection.write_packet(packet)
|
|
reply = 'ok'
|
|
|
|
## 1gather wood - gathers wood from the world
|
|
## 1gather sand - gathers sand from the world
|
|
if command == 'gather' and data:
|
|
if data == 'wood':
|
|
self.g.job.state = self.g.job.gather_wood
|
|
reply = 'ok'
|
|
elif data == 'sand':
|
|
self.g.job.state = self.g.job.gather_sand
|
|
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'
|
|
|
|
## 1farm wood - farms wood from a certain area
|
|
## 1farm sand - farms sand from a certain area
|
|
## 1farm wart - farms netherwart from a certain area
|
|
## 1farm crop - farms mature crops from a certain area
|
|
if command == 'farm' and data:
|
|
if data == 'wood':
|
|
self.g.job.state = self.g.job.farm_wood
|
|
reply = 'ok'
|
|
elif data == 'sand':
|
|
self.g.job.state = self.g.job.farm_sand
|
|
reply = 'ok'
|
|
elif data == 'wart':
|
|
self.g.job.state = self.g.job.farm_wart
|
|
reply = 'ok'
|
|
elif data.startswith('crop'):
|
|
self.g.job.state = self.g.job.farm_crop
|
|
reply = 'ok'
|
|
|
|
if reply and self.g.dimension == 'overworld':
|
|
for i in self.g.inv.values():
|
|
if i.item_id in items.BED_IDS:
|
|
break
|
|
else:
|
|
reply += ', I need a bed'
|
|
|
|
## 1loiter - stands still but eats, sleeps, and flees
|
|
if command == 'loiter':
|
|
self.g.job.state = self.g.job.loiter
|
|
reply = 'ok'
|
|
|
|
## 1trade - sells items to villagers to get emeralds
|
|
if command == 'trade':
|
|
self.g.job.state = self.g.job.trade
|
|
reply = 'ok'
|
|
|
|
## 1stop - stops the current job and resets bot
|
|
if command == 'stop':
|
|
self.close_window()
|
|
bot.init(self.g)
|
|
reply = 'ok'
|
|
|
|
## 1drop - drops the current stack its holding
|
|
if command == 'drop':
|
|
self.drop_stack()
|
|
|
|
## 1select [id] - moves item with id into main hand
|
|
if command == 'select' and data:
|
|
item = int(data)
|
|
if self.select_item([item]):
|
|
reply = 'ok'
|
|
else:
|
|
reply = 'not found'
|
|
|
|
## 1dump [id] - drops all items matching id
|
|
if command == 'dump' and data:
|
|
item = int(data)
|
|
if self.count_items([item]):
|
|
self.g.dumping = item
|
|
reply = 'ok'
|
|
else:
|
|
reply = 'not found'
|
|
|
|
## 1drain - drops all items in inventory
|
|
if command == 'drain':
|
|
self.g.draining = True
|
|
reply = 'ok'
|
|
|
|
if command == 'gapple':
|
|
self.g.job.state = self.g.job.find_gapple
|
|
if data:
|
|
self.g.job.find_gapple_states.count = int(data)
|
|
reply = 'ok'
|
|
|
|
if command == 'cache':
|
|
self.g.job.state = self.g.job.cache_items
|
|
self.g.job.cache_items_states.minimum = 0
|
|
self.g.job.cache_items_states.silent = True
|
|
reply = 'ok'
|
|
|
|
|
|
## 1fill [x] [y] [z] [x] [y] [z] - fills the cuboid with the block at the first coordinate
|
|
if command == 'fill':
|
|
try:
|
|
data = data.replace('(', ' ').replace(')', ' ').replace(',', ' ')
|
|
x1, y1, z1, x2, y2, z2 = [int(x) for x in data.split()]
|
|
except (AttributeError, ValueError):
|
|
reply = 'usage: !fill x1 y1 z1 x2 y2 z2'
|
|
|
|
if not reply:
|
|
coord1 = (x1, y1, z1)
|
|
coord2 = (x2, y2, z2)
|
|
block = self.g.world.block_at(*coord1)
|
|
|
|
if not reply and y1 > y2:
|
|
reply = 'can only fill upwards'
|
|
|
|
if not reply and block is None:
|
|
reply = 'first coord out of range'
|
|
|
|
if not reply and block == 0:
|
|
reply = 'can\'t fill with air'
|
|
|
|
if not reply:
|
|
self.g.filling = Munch(coord1=coord1, coord2=coord2, block=block)
|
|
self.g.job.state = self.g.job.fill_blocks
|
|
reply = 'filling ' + str(utils.pvolume(coord1, coord2)) + ' with ' + blocks.BLOCKS[block]
|
|
|
|
## 1here - bot comes to your location
|
|
if command == 'here':
|
|
try:
|
|
sender_uuid = self.g.player_names[sender]
|
|
except KeyError:
|
|
reply = 'can\'t find your uuid'
|
|
|
|
if not reply:
|
|
for p in self.g.players.values():
|
|
if p.player_uuid == sender_uuid:
|
|
player = p
|
|
break
|
|
else: # for
|
|
reply = 'can\'t find you'
|
|
|
|
if not reply:
|
|
pos = utils.pint(self.g.pos)
|
|
goal = utils.pint((p.x, p.y, p.z))
|
|
start = time.time()
|
|
navpath = self.g.world.path_to_place(pos, goal)
|
|
|
|
if navpath:
|
|
self.g.path = navpath
|
|
if self.g.job:
|
|
self.g.job.stop()
|
|
print(len(navpath))
|
|
print(navpath)
|
|
print(round(time.time() - start, 3), 'seconds')
|
|
if self.g.job:
|
|
self.g.job.stop()
|
|
self.g.look_at = None
|
|
reply = 'ok'
|
|
else:
|
|
reply = 'no path'
|
|
|
|
## 1goto [x] [y] [z] - sends the bot to coordinate (x, y, z)
|
|
if command == 'goto':
|
|
try:
|
|
data = data.replace('(', ' ').replace(')', ' ').replace(',', ' ')
|
|
x2, y2, z2 = [int(x) for x in data.split()]
|
|
except (AttributeError, ValueError):
|
|
reply = 'usage: !goto x y z'
|
|
|
|
if not reply:
|
|
pos = utils.pint(self.g.pos)
|
|
goal = utils.pint((x2, y2, z2))
|
|
start = time.time()
|
|
navpath = self.g.world.path_to_place(pos, goal)
|
|
|
|
if navpath:
|
|
self.g.path = navpath
|
|
if self.g.job:
|
|
self.g.job.stop()
|
|
print(len(navpath))
|
|
print(navpath)
|
|
print(round(time.time() - start, 3), 'seconds')
|
|
if self.g.job:
|
|
self.g.job.stop()
|
|
self.g.look_at = None
|
|
reply = 'ok'
|
|
else:
|
|
reply = 'no path'
|
|
|
|
if command == 'break':
|
|
self.break_block(blocks.TEST_BLOCK)
|
|
reply = 'ok'
|
|
|
|
if command == 'open':
|
|
self.open_container(blocks.TEST_BLOCK)
|
|
|
|
## 1close - closes the current Minecraft window
|
|
if command == 'close':
|
|
if self.g.window:
|
|
self.close_window()
|
|
reply = 'ok'
|
|
else:
|
|
reply = 'nothing open'
|
|
|
|
## 1click [slot] [button] [mode] - clicks the current window
|
|
if command == 'click' and data:
|
|
if self.g.window:
|
|
slot, button, mode = [int(x) for x in data.split(' ')]
|
|
try:
|
|
item = self.g.window.contents[slot]
|
|
except KeyError:
|
|
item = Slot(present=False)
|
|
print(item)
|
|
self.click_window(slot, button, mode, item)
|
|
else:
|
|
reply = 'nothing open'
|
|
|
|
## 1use - use the item it's currently holding
|
|
if command == 'use':
|
|
self.use_item(0)
|
|
|
|
## 1interact [entity id] - interacts with that entity
|
|
if command == 'interact' and data:
|
|
self.interact(int(data))
|
|
|
|
if command == 'test':
|
|
reply = 'ok'
|
|
r = self.g.world.find_villager_openings((615, 78, 493))
|
|
print(r)
|
|
|
|
################# Authorized commands ##########################
|
|
|
|
## ### Authorized Commands
|
|
## These dangerous commands can only be ran by the bot owner.
|
|
|
|
if authed:
|
|
|
|
## 1print [expression] - replies with Python eval(expression)
|
|
if command == 'print':
|
|
data = data.replace('`', '.')
|
|
reply = str(eval(data))
|
|
|
|
## 1exit - exits the program
|
|
if command == 'exit':
|
|
import os
|
|
os._exit(0)
|
|
|
|
|
|
|
|
except BaseException as e:
|
|
import traceback
|
|
print(traceback.format_exc())
|
|
reply = 'Error: {} - {}\n'.format(e.__class__.__name__, e)
|
|
pass
|
|
|
|
if reply:
|
|
print(reply)
|
|
if private and not reply.startswith('/'):
|
|
self.g.chat.send('/m ' + sender + ' ' + reply)
|
|
else:
|
|
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):
|
|
g = self.g
|
|
print(packet)
|
|
if packet.window_id == 0:
|
|
g.inv[packet.slot] = packet.slot_data
|
|
elif g.window:
|
|
g.window.contents[packet.slot] = packet.slot_data
|
|
|
|
if packet.window_id >= 0 and not packet.slot_data.present:
|
|
print('unlocking item lock')
|
|
g.item_lock = False
|
|
|
|
def break_block(self, location):
|
|
p = utils.pint(self.g.pos)
|
|
#if utils.phyp(p, location) > blocks.BREAK_DISTANCE + 1:
|
|
# return False
|
|
|
|
bid = self.g.chunks.get_block_at(*location)
|
|
if bid == 0:
|
|
return False
|
|
|
|
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, self.g.holding)
|
|
return True
|
|
|
|
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)
|
|
|
|
if self.g.chunks.get_block_at(*self.g.breaking) == 0:
|
|
self.g.breaking = None
|
|
|
|
def handle_break_animation(self, packet):
|
|
return
|
|
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 count_items(self, items):
|
|
# count how many items are in inv
|
|
count = 0
|
|
for slot, item in self.g.inv.items():
|
|
if item.item_id in items:
|
|
count += item.item_count
|
|
return count
|
|
|
|
def count_inventory_slots(self):
|
|
# count how many inventory slots are filled
|
|
# excludes armour, crafting slots, off-hand
|
|
count = 0
|
|
for slot, item in self.g.inv.items():
|
|
if item.present and slot >= 9 and slot <= 45:
|
|
count += 1
|
|
return count
|
|
|
|
def count_window_slots(self):
|
|
# count how many window slots are filled
|
|
# excludes player inventory
|
|
w = self.g.window
|
|
w_info = mcdata.WINDOWS[w.data.window_type]
|
|
w_container_slots = w_info.container
|
|
|
|
count = 0
|
|
for slot, item in w.contents.items():
|
|
if item.present and slot in w_container_slots:
|
|
count += 1
|
|
return count
|
|
|
|
def get_window_slot(self, item_id):
|
|
# get the first slot that matches item of a window
|
|
window_items = list(self.g.window.contents.items())
|
|
for slot, item in window_items:
|
|
if not item.present: continue
|
|
if item.item_id == item_id:
|
|
return slot, item
|
|
else: #for
|
|
return False, False
|
|
|
|
def select_item(self, items):
|
|
# select the first match from items of inv
|
|
# uses smallest stack of that match
|
|
# and optionally the most damaged item
|
|
inv_items = list(self.g.inv.items())
|
|
inv_items.sort(key=lambda x: (x[1].nbt or {}).get('Damage', 0), reverse=True)
|
|
inv_items.sort(key=lambda x: x[1].item_count or 0)
|
|
for slot, item in inv_items:
|
|
if item.item_id in items:
|
|
self.g.game.choose_slot(slot)
|
|
self.g.holding = item.item_id
|
|
return True
|
|
else: #for
|
|
return False
|
|
|
|
def select_random_item(self, items):
|
|
# select a random match from items of inv
|
|
# this is random per item type
|
|
# example: 5 stacks wood, 1 stack glass
|
|
# -> still 50/50 chance between them
|
|
|
|
matches = set()
|
|
for slot, item in self.g.inv.items():
|
|
if item.item_id in items:
|
|
matches.add(item.item_id)
|
|
|
|
if matches:
|
|
return self.select_item([random.choice(list(matches))])
|
|
else:
|
|
return False
|
|
|
|
def select_next_item(self):
|
|
# select the next item slot that has an item
|
|
for slot, item in self.g.inv.items():
|
|
if slot < 9: continue # skip armour slots
|
|
if item.present:
|
|
print('slot:', slot, 'item:', item)
|
|
self.g.game.choose_slot(slot)
|
|
self.g.holding = item.item_id
|
|
return True
|
|
else: # for
|
|
return False
|
|
|
|
def drop_stack(self):
|
|
packet = PlayerDiggingPacket()
|
|
packet.status = 3
|
|
packet.location = utils.pint(self.g.pos)
|
|
packet.face = 1
|
|
self.g.connection.write_packet(packet)
|
|
|
|
def open_container(self, location):
|
|
bid = self.g.chunks.get_block_at(*location)
|
|
# TODO: check if block is a chest??
|
|
self.place_block(location, BlockFace.TOP)
|
|
|
|
def handle_window(self, packet):
|
|
print(packet)
|
|
self.g.window = Munch(data=packet, contents=dict(), count=0)
|
|
|
|
def click_window(self, slot, button, mode, item):
|
|
w = self.g.window
|
|
|
|
packet = ClickWindowPacket()
|
|
packet.window_id = w.data.window_id
|
|
packet.slot = slot
|
|
packet.button = button
|
|
packet.action_number = w.count
|
|
packet.mode = mode
|
|
packet.clicked_item = item
|
|
self.g.connection.write_packet(packet)
|
|
print('<--', packet)
|
|
|
|
w.count += 1
|
|
|
|
def close_window(self):
|
|
if self.g.window:
|
|
packet = CloseWindowPacket()
|
|
packet.window_id = self.g.window.data.window_id
|
|
self.g.connection.write_packet(packet)
|
|
self.g.window = None
|
|
|
|
def handle_window_confirmation(self, packet):
|
|
print(packet)
|
|
packet2 = ServerWindowConfirmationPacket()
|
|
packet2.window_id = packet.window_id
|
|
packet2.action_number = packet.action_number
|
|
packet2.accepted = packet.accepted
|
|
self.g.connection.write_packet(packet2)
|
|
|
|
def handle_spawn_player(self, packet):
|
|
print(packet)
|
|
self.g.players[packet.entity_id] = Munch(
|
|
entity_id=packet.entity_id,
|
|
player_uuid=packet.player_UUID,
|
|
x=packet.x,
|
|
y=packet.y,
|
|
z=packet.z,
|
|
yaw=packet.yaw,
|
|
pitch=packet.pitch,
|
|
)
|
|
|
|
def handle_spawn_object(self, packet):
|
|
#return
|
|
if packet.type_id != 37: return
|
|
#print(packet)
|
|
self.g.objects[packet.entity_id] = Munch(
|
|
entity_id=packet.entity_id,
|
|
x=packet.x,
|
|
y=packet.y,
|
|
z=packet.z,
|
|
velocity_x=packet.velocity_x,
|
|
velocity_y=packet.velocity_y,
|
|
velocity_z=packet.velocity_z,
|
|
)
|
|
|
|
def check_gapple(self, packet):
|
|
current_gapple_chest = self.g.job.find_gapple_states.current_chest
|
|
if current_gapple_chest:
|
|
for entry in packet.metadata:
|
|
if entry.type != 6:
|
|
continue
|
|
|
|
if entry.value.item_id in items.GAPPLE_ID:
|
|
self.g.chat.send('gapple found: ' + str(current_gapple_chest)[1:-1])
|
|
print('gapple found:', str(current_gapple_chest)[1:-1])
|
|
|
|
def handle_entity_metadata(self, packet):
|
|
if not packet.metadata:
|
|
return
|
|
|
|
if self.g.job and self.g.job.state == self.g.job.find_gapple_states:
|
|
self.check_gapple(packet)
|
|
|
|
obj = self.g.objects.get(packet.entity_id, None)
|
|
if obj:
|
|
for entry in packet.metadata:
|
|
if entry.type != 6:
|
|
continue
|
|
obj.item_id = entry.value.item_id
|
|
obj.item_count = entry.value.item_count
|
|
|
|
player = self.g.players.get(packet.entity_id, None)
|
|
if player:
|
|
return
|
|
|
|
def handle_spawn_living(self, packet):
|
|
self.g.mobs[packet.entity_id] = Munch(
|
|
entity_id=packet.entity_id,
|
|
entity_uuid=packet.entity_uuid,
|
|
type=packet.type,
|
|
x=packet.x,
|
|
y=packet.y,
|
|
z=packet.z,
|
|
)
|
|
|
|
def handle_entity_position(self, packet):
|
|
mob = self.g.mobs.get(packet.entity_id, None)
|
|
if mob:
|
|
mob.x += packet.delta_x / 4096.0
|
|
mob.y += packet.delta_y / 4096.0
|
|
mob.z += packet.delta_z / 4096.0
|
|
|
|
player = self.g.players.get(packet.entity_id, None)
|
|
if player:
|
|
player.x += packet.delta_x / 4096.0
|
|
player.y += packet.delta_y / 4096.0
|
|
player.z += packet.delta_z / 4096.0
|
|
|
|
#if player.player_uuid == '0c123cfa-1697-4427-9413-4b645dee7ec0': print(packet)
|
|
|
|
def handle_entity_position_rotation(self, packet):
|
|
mob = self.g.mobs.get(packet.entity_id, None)
|
|
if mob:
|
|
mob.x += packet.delta_x / 4096.0
|
|
mob.y += packet.delta_y / 4096.0
|
|
mob.z += packet.delta_z / 4096.0
|
|
|
|
player = self.g.players.get(packet.entity_id, None)
|
|
if player:
|
|
player.x += packet.delta_x / 4096.0
|
|
player.y += packet.delta_y / 4096.0
|
|
player.z += packet.delta_z / 4096.0
|
|
|
|
#if player.player_uuid == '0c123cfa-1697-4427-9413-4b645dee7ec0': print(packet)
|
|
|
|
def handle_entity_teleport(self, packet):
|
|
mob = self.g.mobs.get(packet.entity_id, None)
|
|
if mob:
|
|
mob.x = packet.x
|
|
mob.y = packet.y
|
|
mob.z = packet.z
|
|
|
|
player = self.g.players.get(packet.entity_id, None)
|
|
if player:
|
|
player.x = packet.x
|
|
player.y = packet.y
|
|
player.z = packet.z
|
|
|
|
#if player.player_uuid == '0c123cfa-1697-4427-9413-4b645dee7ec0': print(packet)
|
|
|
|
def handle_entity_velocity(self, packet):
|
|
obj = self.g.objects.get(packet.entity_id, None)
|
|
if obj:
|
|
print(packet)
|
|
#obj.velocity_x = packet.velocity_x
|
|
#obj.velocity_y = packet.velocity_y
|
|
#obj.velocity_z = packet.velocity_z
|
|
|
|
def handle_destroy_entities(self, packet):
|
|
for eid in packet.entity_ids:
|
|
if eid in self.g.objects:
|
|
del self.g.objects[eid]
|
|
if eid in self.g.mobs:
|
|
del self.g.mobs[eid]
|
|
if eid in self.g.players:
|
|
del self.g.players[eid]
|
|
|
|
def leave_bed(self):
|
|
packet = EntityActionPacket()
|
|
packet.entity_id = self.g.eid
|
|
packet.action_id = 2
|
|
packet.jump_boost = 0
|
|
self.g.connection.write_packet(packet)
|
|
|
|
def handle_respawn(self, packet):
|
|
print(packet)
|
|
self.g.dimension = packet.world_name.replace('minecraft:', '')
|
|
|
|
def handle_player_list(self, packet):
|
|
for action in packet.actions:
|
|
if isinstance(action, packet.AddPlayerAction):
|
|
self.g.player_names[action.uuid] = action.name
|
|
self.g.player_names[action.name] = action.uuid # porque no los dos?
|
|
|
|
def handle_update_health(self, packet):
|
|
print(packet)
|
|
self.g.health = packet.health
|
|
self.g.food = packet.food
|
|
|
|
def use_item(self, hand):
|
|
packet = serverbound.play.UseItemPacket()
|
|
packet.hand = hand
|
|
self.g.connection.write_packet(packet)
|
|
|
|
def interact(self, eid):
|
|
packet = InteractEntityPacket()
|
|
packet.entity_id = eid
|
|
packet.type = 0
|
|
packet.hand = 0
|
|
packet.sneaking = False
|
|
self.g.connection.write_packet(packet)
|
|
|
|
def handle_trade_list(self, packet):
|
|
print(packet)
|
|
self.g.trades = packet.trades
|
|
|
|
def select_trade(self, num):
|
|
packet = SelectTradePacket()
|
|
packet.selected_slot = num
|
|
self.g.connection.write_packet(packet)
|
|
|
|
def handle_disconnect(self, packet):
|
|
print(packet)
|
|
print('Client disconnected!')
|
|
import os
|
|
os._exit(1)
|
|
|
|
def tick(self):
|
|
if self.g.breaking:
|
|
self.animate()
|
|
|
|
if time.time() >= self.g.break_time: #- 2*utils.TICK:
|
|
self.break_finish()
|
|
|
|
if self.g.dumping and not self.g.item_lock:
|
|
if self.select_item([self.g.dumping]):
|
|
self.drop_stack()
|
|
self.g.item_lock = True
|
|
else:
|
|
self.g.dumping = None
|
|
|
|
if self.g.draining and not self.g.item_lock:
|
|
if self.select_next_item():
|
|
self.drop_stack()
|
|
self.g.item_lock = True
|
|
else:
|
|
self.g.draining = False
|
|
|
|
if not self.g.path:
|
|
self.g.correction_count = 0
|