import re import time import importlib import random from math import hypot from panda3d.core import LPoint3f from minecraft.networking.types import BlockFace from protocol.managers import ChunkNotLoadedException import utils importlib.reload(utils) import path importlib.reload(path) import blocks importlib.reload(blocks) import items importlib.reload(items) import data importlib.reload(data) class FindGappleStates: def idle(self): return None def init(self): self.state = self.go_spectator def go_spectator(self): print('Going spectator...') self.g.chat.send('/gamemode spectator') self.state = self.tp_to_coord def tp_to_coord(self): step = utils.spiral(self.count) step_scaled = utils.pmul(step, 192) self.coord = utils.padd(self.origin, step_scaled) self.coord = (self.coord[0], 50, self.coord[2]) print('count:', self.count, 'teleporting to:', self.coord) self.g.chat.send('/tp {} {} {}'.format(*self.coord)) self.g.command_lock = True self.state = self.wait_for_load def wait_for_load(self): if self.g.command_lock: return if self.g.chunks.check_loaded(self.g.pos, 169): print('chunks have been loaded') self.state = self.pick_chest def pick_chest(self): chest_list = [] for chest_id in blocks.CHEST_IDS: chest_list.extend(self.g.chunks.index.get(chest_id, [])) for chest in chest_list: if chest in self.checked_chests: # slow but simple continue if utils.phyp_king(self.coord, chest) > 96: # skip because we can't detect item drops continue self.current_chest = chest self.checked_chests.append(self.current_chest) self.state = self.break_chest break else: # for print('exhausted chest list') self.state = self.cleanup def break_chest(self): print('Breaking chest', self.current_chest) self.g.command_lock = True self.g.item_lock = True self.g.chat.send('/setblock {} {} {} air destroy'.format(*self.current_chest)) self.wait_time = 0.5 self.state = self.wait_for_items def wait_for_items(self): # wait for command to execute if self.g.command_lock: return # wait for items to drop if self.wait_time > 0: self.wait_time -= utils.TICK else: print('done waiting for items') self.state = self.pick_chest def cleanup(self): self.count += 1 self.state = self.done def done(self): # never gets ran, placeholder return None def __init__(self, global_state): self.g = global_state self.state = self.idle self.origin = utils.pint(self.g.pos) self.count = 0 self.coord = None self.current_chest = None self.checked_chests = [] self.wait_time = 0 def run(self): self.state() class GatherWoodStates: def bair(self, p): return self.g.chunks.get_block_at(*p) in blocks.NON_SOLID_IDS def blog(self, p): return self.g.chunks.get_block_at(*p) in blocks.LOG_IDS def idle(self): return None def init(self): self.g.chopped_tree = False self.state = self.find_new_tree def find_new_tree(self): print('Finding new tree...') w = self.g.world p = utils.pint(self.g.pos) trees = w.find_trees(p, 100) print('Found trees:', trees) try: while trees[0] in self.bad_trees: trees.pop(0) self.tree = trees[0] except IndexError: print('No good tress left, aborting.') self.state = self.cleanup return self.openings = w.find_tree_openings(self.tree) self.state = self.choose_opening def choose_opening(self): w = self.g.world p = utils.pint(self.g.pos) print('openings:', self.openings) if not len(self.openings): print('Unable to get to tree', self.tree) self.bad_trees.append(self.tree) self.state = self.cleanup return navpath = w.path_to_place(p, self.openings[0]) if navpath: self.g.path = navpath self.state = self.going_to_tree else: self.openings.pop(0) def going_to_tree(self): if utils.pint(self.g.pos) == self.openings[0]: self.g.look_at = self.tree self.state = self.clear_leaves def clear_leaves(self): if not self.g.breaking: p = utils.pint(self.g.pos) diff = utils.psub(self.tree, p) for x in utils.diffrange(diff[0]): for z in utils.diffrange(diff[2]): for y in range(2): check = utils.padd(p, (x, y, z)) if check == self.tree: break if not self.bair(check): print('Breaking leaf') self.g.game.break_block(check) return self.state = self.clear_trunk_base def clear_trunk_base(self): if not self.g.breaking: base = self.tree above = utils.padd(self.tree, path.BLOCK_ABOVE) if self.blog(base): self.g.game.break_block(base) print('breaking base') elif self.blog(above): self.g.game.break_block(above) print('breaking above') else: w = self.g.world p = utils.pint(self.g.pos) navpath = w.path_to_place(p, self.tree) if navpath: self.g.path = navpath self.state = self.going_to_trunk_base else: self.openings.pop(0) self.state = self.choose_opening def going_to_trunk_base(self): if utils.pint(self.g.pos) == self.tree: self.g.look_at = utils.padd(self.tree, path.BLOCK_ABOVE2) self.state = self.clear_trunk def clear_trunk(self): if not self.g.breaking: check = self.tree count = 0 while self.bair(check) and count < 6: check = utils.padd(check, path.BLOCK_ABOVE) count += 1 if self.blog(check): print('breaking log', check) self.g.game.break_block(check) else: print('Finished clearing tree') self.wait_time = 0.5 self.state = self.wait def wait(self): # wait for the last log to fall if self.wait_time > 0: self.wait_time -= utils.TICK else: self.g.chopped_tree = True self.state = self.cleanup def cleanup(self): self.g.look_at = None self.state = self.done def done(self): # never gets ran, placeholder return None def __init__(self, global_state): self.g = global_state self.state = self.idle self.tree = None self.openings = [] self.bad_trees = [] self.wait_time = 0 def run(self): self.state() class GatherSandStates: def bair(self, p): return self.g.chunks.get_block_at(*p) in blocks.NON_SOLID_IDS def bsand(self, p): return self.g.chunks.get_block_at(*p) == 66 def idle(self): return None def init(self): self.state = self.find_new_sand def find_new_sand(self): print('Finding new sand...') w = self.g.world p = utils.pint(self.g.pos) sand = w.find_sand(p, 50, self.origin) print('Found sand:', sand) for check in sand: if check in self.bad_sand: continue self.sand = check break self.state = self.nav_to_sand def nav_to_sand(self): w = self.g.world p = utils.pint(self.g.pos) self.g.chunks.set_block_at(*self.sand, blocks.AIR) navpath = w.path_to_place(p, self.sand) self.g.chunks.set_block_at(*self.sand, blocks.SAND) if navpath: self.g.path = navpath[:-1] self.state = self.going_to_sand else: self.bad_sand.append(self.sand) self.state = self.find_new_sand def going_to_sand(self): if not len(self.g.path): self.g.look_at = self.sand self.state = self.dig_sand def dig_sand(self): if not self.g.breaking: if self.bsand(self.sand): self.g.game.break_block(self.sand) print('digging sand') else: self.state = self.get_sand def get_sand(self): w = self.g.world p = utils.pint(self.g.pos) navpath = w.path_to_place(p, self.sand) if navpath: self.g.path = navpath self.state = self.going_to_item else: self.bad_sand.append(self.sand) self.state = self.find_new_sand def going_to_item(self): if utils.pint(self.g.pos) == self.sand: self.g.look_at = self.sand self.state = self.cleanup def cleanup(self): self.g.look_at = None self.state = self.done def done(self): # never gets ran, placeholder return None def __init__(self, global_state): self.g = global_state self.state = self.idle self.origin = utils.pint(self.g.pos) self.sand = None self.bad_sand = [] self.wait_time = 0 def run(self): self.state() class SleepWithBedStates: def idle(self): return None def init(self): if self.g.time >= 12000: self.state = self.find_bed_spot else: print('Aborting sleep, not night') self.state = self.cleanup def find_bed_spot(self): print('Finding a bed spot...') w = self.g.world p = utils.pint(self.g.pos) areas = w.find_bed_areas(p, 100) print('Found areas:', areas) if len(areas): while areas[0] in self.bad_areas: areas.pop(0) self.area = areas[0] elif self.last_area: self.area = self.last_area else: print('Unable to find area, and no last area') self.state = self.cleanup return openings = w.find_bed_openings(self.area) for o in openings: navpath = w.path_to_place(p, o) self.opening = o if navpath: break else: # for print('Unable to get to bed area', self.area) self.bad_areas.append(self.area) self.state = self.cleanup return self.g.path = navpath self.state = self.going_to_area self.last_area = self.area def going_to_area(self): if utils.pint(self.g.pos) == self.opening: self.g.look_at = self.area self.state = self.select_bed def select_bed(self): if self.g.game.select_item(items.BED_IDS): self.g.look_at = utils.padd(self.area, path.BLOCK_BELOW) self.state = self.place_bed else: self.g.chat.send('I need a bed') self.state = self.cleanup def place_bed(self): self.g.game.place_block(self.area, BlockFace.TOP) self.state = self.use_bed def use_bed(self): if self.g.time >= 12542: print('Sleeping') self.g.game.place_block(self.area, BlockFace.TOP) if not self.silent: self.g.chat.send('zzz') self.state = self.sleep_bed def sleep_bed(self): if self.g.time < 100: print('Woke up') self.state = self.break_bed def break_bed(self): self.g.game.break_block(self.area) self.state = self.collect_bed def collect_bed(self): if not self.g.breaking: self.g.path = [utils.padd(self.area, utils.spiral(n)) for n in range(9)] self.wait_time = 4 self.state = self.wait def wait(self): # wait to pick up bed if self.wait_time > 0: self.wait_time -= utils.TICK else: self.state = self.cleanup def cleanup(self): self.g.look_at = None self.state = self.done def done(self): # never gets ran, placeholder return None def __init__(self, global_state): self.g = global_state self.state = self.idle self.silent = False self.area = None self.opening = None self.bad_areas = [] self.last_area = None self.wait_time = 0 def run(self): self.state() class CacheItemsStates: def idle(self): return None def init(self): num_stacks = len([x for x in self.g.inv.values() if x.present]) print('inventory amount:', num_stacks) if num_stacks >= 27: self.state = self.find_cache_spot else: print('Aborting caching, not full') self.state = self.cleanup def find_cache_spot(self): print('Finding a chest spot...') w = self.g.world p = utils.pint(self.g.pos) areas = w.find_cache_areas(p, 100) print('Found areas:', areas) if len(areas): while areas[0] in self.bad_areas: areas.pop(0) self.area = areas[0] elif self.last_area: self.area = self.last_area else: print('Unable to find area, and no last area') self.state = self.cleanup return openings = w.find_cache_openings(self.area) for o in openings: navpath = w.path_to_place(p, o) self.opening = o if navpath: break else: # for print('Unable to get to cache area', self.area) self.bad_areas.append(self.area) self.state = self.cleanup return self.g.path = navpath self.state = self.going_to_area self.last_area = self.area def going_to_area(self): if utils.pint(self.g.pos) == self.opening: self.g.look_at = self.area self.state = self.select_chest def select_chest(self): if self.g.game.select_item(items.CHEST_ID): self.g.look_at = utils.padd(self.area, path.BLOCK_BELOW) self.state = self.place_chest else: self.g.chat.send('I need a chest') self.state = self.cleanup def place_chest(self): self.g.game.place_block(self.area, BlockFace.TOP) self.state = self.open_chest def open_chest(self): print('Opening chest') self.g.game.open_container(self.area) self.wait_time = 1 self.state = self.wait def wait(self): # wait for server to send us chest contents if self.wait_time > 0: self.wait_time -= utils.TICK else: self.state = self.move_items def move_items(self): if self.g.item_lock: return w = self.g.window w_info = data.WINDOWS[w.data.window_type] w_inventory_slots = w_info.inventory for slot_num in w_inventory_slots: if slot_num not in w.contents: continue slot = w.contents[slot_num] if not slot.present: continue if slot.item_id in items.USEFUL_ITEMS: continue print('moving', slot) #inv_slot_num = slot_num - w_info.slot_diff #self.g.inv.pop(inv_slot_num, None) self.g.item_lock = True self.g.game.click_window(slot_num, 0, 1, slot) return print('nothing left to move') self.state = self.close_chest def close_chest(self): print('closing chest') self.g.game.close_window() self.g.chat.send('cache at ' + str(self.area)[1:-1]) self.state = self.cleanup def cleanup(self): self.g.look_at = None self.state = self.done def done(self): # never gets ran, placeholder return None def __init__(self, global_state): self.g = global_state self.state = self.idle self.area = None self.opening = None self.bad_areas = [] self.last_area = None self.wait_time = 0 def run(self): self.state() class PlantTreeStates: def idle(self): return None def init(self): if self.g.chopped_tree: self.state = self.check_feet else: print('Aborting planting, did not plant') self.state = self.cleanup def check_feet(self): p = utils.pint(self.g.pos) # check for air at feet if self.g.chunks.get_block_at(*p) in [0]: self.state = self.select_sapling else: print('Aborting planting, feet not air') self.state = self.cleanup def select_sapling(self): p = utils.pint(self.g.pos) if self.g.game.select_random_item(items.SAPLING_IDS): self.g.look_at = utils.padd(p, path.BLOCK_BELOW) self.state = self.wait_select self.wait_time = 1 else: print('Aborting planting, no saplings') self.state = self.cleanup def wait_select(self): # wait a bit to look down if self.wait_time > 0: self.wait_time -= utils.TICK else: self.state = self.place_sapling def place_sapling(self): p = utils.pint(self.g.pos) self.g.game.place_block(p, BlockFace.TOP) print('Placed sapling') self.state = self.wait_place self.wait_time = 1 def wait_place(self): # wait a bit for chunk data to update if self.wait_time > 0: self.wait_time -= utils.TICK else: self.state = self.find_open_spot def find_open_spot(self): print('Finding an open spot to stand...') w = self.g.world p = utils.pint(self.g.pos) areas = w.find_cache_areas(p, 20) print('Found areas:', areas) try: while areas[0] in self.bad_areas: areas.pop(0) self.area = areas[0] except IndexError: print('No good areas left, aborting.') self.bad_areas = [] self.state = self.cleanup return navpath = w.path_to_place(p, self.area) if not navpath: print('Unable to get to open area', self.area) self.bad_areas.append(self.area) self.state = self.cleanup return self.g.path = navpath self.state = self.going_to_area print('Going to area', self.area) def going_to_area(self): if utils.pint(self.g.pos) == self.area: self.state = self.cleanup def cleanup(self): self.g.look_at = None self.state = self.done def done(self): # never gets ran, placeholder return None def __init__(self, global_state): self.g = global_state self.state = self.idle self.wait_time = 0 self.area = None self.bad_areas = [] def run(self): self.state() class GrabSaplingStates: def idle(self): return None def init(self): self.state = self.find_saplings print('Trying to grab a sapling') def find_saplings(self): w = self.g.world saplings = w.find_objects(items.SAPLING_IDS) if not saplings: print('No saplings objects found, aborting') self.state = self.cleanup return random.shuffle(saplings) for s in saplings: p = utils.pint(self.g.pos) s_pos = utils.pint((s.x, s.y, s.z)) check = utils.padd(s_pos, path.BLOCK_BELOW) if s.entity_id in self.eid_blacklist: continue # slip if the sapling is floating if self.g.chunks.get_block_at(*check) in blocks.LEAF_IDS | {0}: continue navpath = w.path_to_place(p, s_pos) if navpath: self.g.path = navpath self.state = self.going_to_sapling self.sapling = s_pos self.eid_blacklist.append(s.entity_id) print('Going to sapling', self.sapling) return print('Cant get to any saplings, aborting') self.state = self.cleanup def going_to_sapling(self): if utils.pint(self.g.pos) == self.sapling: self.state = self.cleanup def cleanup(self): self.g.look_at = None self.state = self.done def done(self): # never gets ran, placeholder return None def __init__(self, global_state): self.g = global_state self.state = self.idle self.sapling = None self.eid_blacklist = [] def run(self): self.state() class JobStates: def idle(self): return None def find_gapple(self): s1 = self.find_gapple_states if s1.state == s1.idle: s1.state = s1.init elif s1.state == s1.done: s1.state = s1.tp_to_coord s1.run() def gather_sand(self): s1 = self.gather_sand_states s2 = self.sleep_with_bed_states s3 = self.cache_items_states if s1.state == s1.idle: s1.state = s1.init s2.state = s2.init s3.state = s3.init elif s1.state == s1.done: if s2.state != s2.done: s2.run() return if s3.state != s3.done: s3.run() return s1.state = s1.init s2.state = s2.init s3.state = s3.init return s1.run() def gather_wood(self): s1 = self.gather_wood_states s2 = self.sleep_with_bed_states s3 = self.cache_items_states if s1.state == s1.idle: s1.state = s1.init s2.state = s2.init s3.state = s3.init elif s1.state == s1.done: if s2.state != s2.done: s2.run() return if s3.state != s3.done: s3.run() return s1.state = s1.init s2.state = s2.init s3.state = s3.init return s1.run() def farm_wood(self): self.sleep_with_bed_states.silent = True s1 = self.gather_wood_states s2 = self.plant_tree_states s3 = self.sleep_with_bed_states s4 = self.cache_items_states s5 = self.grab_sapling_states if s1.state == s1.idle: s1.state = s1.init s2.state = s2.init s3.state = s3.init s4.state = s4.init s5.state = s5.init elif s1.state == s1.done: if s2.state != s2.done: s2.run() return if s3.state != s3.done: s3.run() return if s4.state != s4.done: s4.run() return if s5.state != s5.done: s5.run() return s1.state = s1.init s2.state = s2.init s3.state = s3.init s4.state = s4.init s5.state = s5.init return s1.run() def stop(self): self.gather_wood_states = GatherWoodStates(self.g) self.gather_sand_states = GatherSandStates(self.g) self.sleep_with_bed_states = SleepWithBedStates(self.g) self.cache_items_states = CacheItemsStates(self.g) self.find_gapple_states = FindGappleStates(self.g) self.plant_tree_states = PlantTreeStates(self.g) self.grab_sapling_states = GrabSaplingStates(self.g) self.state = self.idle def __init__(self, global_state): self.g = global_state self.state = self.idle self.prev_state = None self.gather_wood_states = GatherWoodStates(self.g) self.gather_sand_states = GatherSandStates(self.g) self.sleep_with_bed_states = SleepWithBedStates(self.g) self.cache_items_states = CacheItemsStates(self.g) self.find_gapple_states = FindGappleStates(self.g) self.plant_tree_states = PlantTreeStates(self.g) self.grab_sapling_states = GrabSaplingStates(self.g) def tick(self): self.state()