tanner/minecraft-bot
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Fix jobstate bugs

Browse Source
This commit is contained in:
Tanner Collin 2020-09-16 19:12:01 -06:00
parent c30ac5aefc
commit 58458a561f
4 changed files with 78 additions and 39 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
bot.py
View File

@ -32,6 +32,8 @@ import utils
importlib.reload(utils) importlib.reload(utils)
import path import path
importlib.reload(path) importlib.reload(path)
import jobs
importlib.reload(jobs)
last_tick = time.time() last_tick = time.time()
@ -133,6 +135,7 @@ def tick(global_state):
g.connection.write_packet(packet, force=True) g.connection.write_packet(packet, force=True)
g.game.tick() g.game.tick()
g.job.tick()
def init(global_state): def init(global_state):
@ -150,8 +153,7 @@ def init(global_state):
g.breaking = None g.breaking = None
g.break_time = 0 g.break_time = 0
#g.jobstate = JobStates(connection, player_info) g.job = jobs.JobStates(g)
#g.jobstate.run()
def bot(global_state): def bot(global_state):
g = global_state g = global_state
@ -191,6 +193,7 @@ def bot(global_state):
print('Chunks loaded.') print('Chunks loaded.')
init(g) init(g)
print('Initialized.')
while g.running: while g.running:
tick(g) tick(g)

30
game.py
View File

@ -2,6 +2,7 @@ import re
import time import time
import importlib import importlib
from math import hypot from math import hypot
from itertools import count
from panda3d.core import LPoint3f from panda3d.core import LPoint3f
@ -40,7 +41,7 @@ class MCWorld:
def find_trees(self, center, distance): def find_trees(self, center, distance):
logs = [] logs = []
for i in range(5): for i in range(5):
check = utils.padd(center, alternate(i, 3)) check = utils.padd(center, utils.alternate(i, 3))
logs.extend(self.find_blocks(check, distance, blocks.LOG_IDS, 50)) logs.extend(self.find_blocks(check, distance, blocks.LOG_IDS, 50))
trees = [] trees = []
@ -66,26 +67,26 @@ class MCWorld:
log = utils.padd(log, path.BLOCK_BELOW) log = utils.padd(log, path.BLOCK_BELOW)
trees.append(log) trees.append(log)
trees.sort(key=lambda x: phyp(center, x)) trees.sort(key=lambda x: utils.phyp(center, x))
return trees return trees
def find_tree_openings(self, tree): def find_tree_openings(self, tree):
# returns coords in a cardinal direction where we can stand by tree # returns coords in a cardinal direction where we can stand by tree
maze_solver = MazeSolver(self.g.chunks) maze_solver = path.Pathfinder(self.g.chunks)
result = [] result = []
# TODO: make sure only non-solid and leaves between # TODO: make sure only non-solid and leaves between
# make sure traversable too # make sure traversable too
for distance in range(5): for distance in range(5):
for direction in CHECK_DIRECTIONS: for direction in path.CHECK_DIRECTIONS:
offset = pmul(direction, distance+1) offset = utils.pmul(direction, distance+1)
if maze_solver.check_traverse(tree, offset): if maze_solver.check_traverse(tree, offset):
result.append(utils.padd(tree, offset)) result.append(utils.padd(tree, offset))
return result return result
def path_to_place(self, start, place): def path_to_place(self, start, place):
maze_solver = MazeSolver(self.g.chunks) maze_solver = path.Pathfinder(self.g.chunks)
try: try:
s = maze_solver.astar(start, place) s = maze_solver.astar(start, place)
@ -115,11 +116,11 @@ class MCWorld:
areas.append(a) areas.append(a)
areas.sort(key=lambda x: phyp(center, x)) areas.sort(key=lambda x: utils.phyp(center, x))
return areas return areas
def sand_adjacent_safe(self, sand): def sand_adjacent_safe(self, sand):
for direction in CHECK_DIRECTIONS: for direction in path.CHECK_DIRECTIONS:
if self.block_at(*utils.padd(sand, direction)) in blocks.AVOID_IDS: if self.block_at(*utils.padd(sand, direction)) in blocks.AVOID_IDS:
return False return False
return True return True
@ -155,7 +156,7 @@ class MCWorld:
# returns coords in a cardinal direction where we can stand by bed # returns coords in a cardinal direction where we can stand by bed
result = [] result = []
for direction in CHECK_DIRECTIONS: for direction in path.CHECK_DIRECTIONS:
result.append(utils.padd(area, direction)) result.append(utils.padd(area, direction))
return result return result
@ -188,7 +189,7 @@ class Game:
print('new waypoint:', self.g.goal) print('new waypoint:', self.g.goal)
start = time.time() start = time.time()
solution = path.Pathfinder(self.g.chunks).astar(utils.pint(self.g.pos), utils.pint(g.goal)) solution = path.Pathfinder(self.g.chunks).astar(utils.pint(self.g.pos), utils.pint(self.g.goal))
if solution: if solution:
solution = list(solution) solution = list(solution)
self.g.path = solution self.g.path = solution
@ -261,6 +262,11 @@ class Game:
self.break_block((616, 78, 496)) self.break_block((616, 78, 496))
reply = 'ok' reply = 'ok'
if command == 'gather' and data:
if data == 'wood':
self.g.job.state = self.g.job.lumberjack
reply = 'ok'
if reply: if reply:
print(reply) print(reply)
self.g.chat.send(reply) self.g.chat.send(reply)
@ -291,6 +297,7 @@ class Game:
packet.location = self.g.breaking packet.location = self.g.breaking
packet.face = 1 packet.face = 1
self.g.connection.write_packet(packet) self.g.connection.write_packet(packet)
self.g.chunks.set_block_at(*self.g.breaking, 0)
self.g.breaking = None self.g.breaking = None
@ -298,7 +305,8 @@ class Game:
print(packet) print(packet)
def handle_break_ack(self, packet): def handle_break_ack(self, packet):
print(packet) #print(packet)
return
def animate(self): def animate(self):
packet = serverbound.play.AnimationPacket() packet = serverbound.play.AnimationPacket()

46
jobs.py
View File

@ -55,10 +55,10 @@ class LumberjackStates:
self.state = self.cleanup self.state = self.cleanup
return return
path = w.path_to_place(p, self.openings[0]) navpath = w.path_to_place(p, self.openings[0])
if path: if navpath:
self.g.path = path self.g.path = navpath
self.state = self.going_to_tree self.state = self.going_to_tree
else: else:
self.openings.pop(0) self.openings.pop(0)
@ -71,10 +71,10 @@ class LumberjackStates:
def clear_leaves(self): def clear_leaves(self):
if not self.g.breaking: if not self.g.breaking:
p = utils.pint(self.g.pos) p = utils.pint(self.g.pos)
diff = psub(self.tree, p) diff = utils.psub(self.tree, p)
for x in diffrange(diff[0]): for x in utils.diffrange(diff[0]):
for z in diffrange(diff[2]): for z in utils.diffrange(diff[2]):
for y in range(2): for y in range(2):
check = utils.padd(p, (x, y, z)) check = utils.padd(p, (x, y, z))
if check == self.tree: if check == self.tree:
@ -100,10 +100,10 @@ class LumberjackStates:
else: else:
w = self.g.world w = self.g.world
p = utils.pint(self.g.pos) p = utils.pint(self.g.pos)
path = w.path_to_place(p, self.tree) navpath = w.path_to_place(p, self.tree)
if path: if navpath:
self.g.path = path self.g.path = navpath
self.state = self.going_to_trunk_base self.state = self.going_to_trunk_base
else: else:
self.openings.pop(0) self.openings.pop(0)
@ -134,7 +134,7 @@ class LumberjackStates:
def wait(self): def wait(self):
# wait for the last log to fall # wait for the last log to fall
if self.wait_time > 0: if self.wait_time > 0:
self.wait_time -= TICK self.wait_time -= utils.TICK
else: else:
self.state = self.cleanup self.state = self.cleanup
@ -149,7 +149,6 @@ class LumberjackStates:
def __init__(self, global_state): def __init__(self, global_state):
self.g = global_state self.g = global_state
self.l = self.g.local_state
self.state = self.idle self.state = self.idle
self.tree = None self.tree = None
@ -193,11 +192,11 @@ class GatherSandStates:
p = utils.pint(self.g.pos) p = utils.pint(self.g.pos)
w.chunks.set_block_at(*self.sand, 0) w.chunks.set_block_at(*self.sand, 0)
path = w.path_to_place(p, self.sand) navpath = w.path_to_place(p, self.sand)
w.chunks.set_block_at(*self.sand, 66) w.chunks.set_block_at(*self.sand, 66)
if path: if navpath:
self.g.path = path[:-1] self.g.path = navpath[:-1]
self.state = self.going_to_sand self.state = self.going_to_sand
else: else:
self.bad_sand.append(self.sand) self.bad_sand.append(self.sand)
@ -219,10 +218,10 @@ class GatherSandStates:
def get_sand(self): def get_sand(self):
w = self.g.world w = self.g.world
p = utils.pint(self.g.pos) p = utils.pint(self.g.pos)
path = w.path_to_place(p, self.sand) navpath = w.path_to_place(p, self.sand)
if path: if navpath:
self.g.path = path self.g.path = navpath
self.state = self.going_to_item self.state = self.going_to_item
else: else:
self.bad_sand.append(self.sand) self.bad_sand.append(self.sand)
@ -244,7 +243,6 @@ class GatherSandStates:
def __init__(self, global_state): def __init__(self, global_state):
self.g = global_state self.g = global_state
self.l = self.g.local_state
self.state = self.idle self.state = self.idle
self.origin = utils.pint(self.g.pos) self.origin = utils.pint(self.g.pos)
@ -289,16 +287,16 @@ class SleepWithBedStates:
openings = w.find_bed_openings(self.area) openings = w.find_bed_openings(self.area)
for o in openings: for o in openings:
path = w.path_to_place(p, o) navpath = w.path_to_place(p, o)
self.opening = o self.opening = o
if path: break if navpath: break
else: # for else: # for
print('Unable to get to bed area', self.area) print('Unable to get to bed area', self.area)
self.bad_areas.append(self.area) self.bad_areas.append(self.area)
self.state = self.cleanup self.state = self.cleanup
return return
self.g.path = path self.g.path = navpath
self.state = self.going_to_area self.state = self.going_to_area
self.last_area = self.area self.last_area = self.area
@ -348,7 +346,7 @@ class SleepWithBedStates:
def wait(self): def wait(self):
# wait to pick up bed # wait to pick up bed
if self.wait_time > 0: if self.wait_time > 0:
self.wait_time -= TICK self.wait_time -= utils.TICK
else: else:
self.state = self.cleanup self.state = self.cleanup
@ -362,7 +360,6 @@ class SleepWithBedStates:
def __init__(self, global_state): def __init__(self, global_state):
self.g = global_state self.g = global_state
self.l = self.g.local_state
self.state = self.idle self.state = self.idle
self.area = None self.area = None
@ -432,7 +429,6 @@ class JobStates:
def __init__(self, global_state): def __init__(self, global_state):
self.g = global_state self.g = global_state
self.l = self.g.local_state
self.state = self.idle self.state = self.idle
self.prev_state = None self.prev_state = None
@ -441,5 +437,5 @@ class JobStates:
self.sleep_with_bed_states = SleepWithBedStates(self.g) self.sleep_with_bed_states = SleepWithBedStates(self.g)
self.survive = False self.survive = False
def run(self): def tick(self):
self.state() self.state()

34
utils.py
View File

@ -1,5 +1,5 @@
import importlib import importlib
from math import floor, ceil from math import floor, ceil, sqrt, hypot
import blocks import blocks
importlib.reload(blocks) importlib.reload(blocks)
@ -31,6 +31,38 @@ def cap(x, amount):
sign = 1 if x >= 0 else -1 sign = 1 if x >= 0 else -1
return sign * min(abs(x), amount) return sign * min(abs(x), amount)
def spiral(n):
# return x, 0, z coords along a spiral at step n
# I forget where I found this
n += 1
k = ceil((sqrt(n)-1)/2)
t = 2 * k + 1
m = t**2
t = t - 1
if n >= m-t:
return k-(m-n), 0, -k
else:
m = m-t
if n >= m-t:
return -k, 0, -k+(m-n)
else:
m = m-t
if n >= m-t:
return -k+(m-n), 0, k
else:
return k, 0, k-(m-n-t)
def alternate(n, amount):
# return 0, y, 0 where y alternates +/- by amount
# example: 0, 2, -2, 4, -4, 6, -6 for amount = 2
sign = 1 if n % 2 else -1
return (0, ceil(n/2) * sign * amount, 0)
def diffrange(n):
# same as range(n+1) but can go negative
sign = 1 if n >= 0 else -1
return range(0, n+sign, sign)
def break_time(block_id, held_item=0, in_water=False, on_ground=True, enchantments=[], effects={}): def break_time(block_id, held_item=0, in_water=False, on_ground=True, enchantments=[], effects={}):
# from PrismarineJS/prismarine-block # from PrismarineJS/prismarine-block
data = blocks.get(block_id) data = blocks.get(block_id)