#!/usr/bin/env python3"""Тестові боти для ВЛАСНОГО Minecraft сервера (offline-акаунти) + консоль керування. Власна реалізація протоколу, БЕЗ зовнішніх бібліотек (тільки стандартний Python 3.8+).Підтримує Java Edition 1.20.2 і новіші (включно з 1.21.x).Опис пакетів, блоків, предметів і мобів потрібної версії завантажується з minecraft-data(PrismarineJS) і кешується в папці mc_data_cache поруч зі скриптом. На сервері має бути: online-mode=false Режими: (без --smart) простий клієнт: заходить на сервер, відповідає на keepalive, шле позицію. Без фізики, без чанків, без "мозку". --smart повноцінний бот (потрібен SURVIVAL!): фізика й відкидання, A*-навігація з прориттям тунелів, добування блоків "затиснутою лівою кнопкою", дерево -> верстак -> дерев'яні, кам'яні, залізні інструменти (піч + вугілля), полювання на їжу й її споживання, втеча від кріперів, бої (мечем, якщо є), інвентар. Далі - вільна подорож і добування. Приклади: python mc_testbots.py --host 127.0.0.1 --count 5 --random-names python mc_testbots.py --count 3 --smart --random-names --reconnect-on-kick ^ --cmd "/register {name}pass {name}pass" --cmd "/login {name}pass" python mc_testbots.py --list-versions"""import argparseimport bisectimport hashlibimport heapqimport jsonimport mathimport osimport randomimport reimport socketimport structimport threadingimport timeimport tracebackimport urllib.requestimport uuidimport zlib DATA_URL = "https://raw.githubusercontent.com/PrismarineJS/minecraft-data/master/data"CACHE_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)), "mc_data_cache")MIN_PROTOCOL = 764 # 1.20.2 - перша версія зі станом "configuration" HELP = """Команди в консолі: all <текст або /команда> - від імені всіх ботів <ім'я> <текст або /команда> - від імені одного бота (напр. Bot1 /gamemode survival) run - ще раз виконати стартові команди на всіх ботах list - список ботів, статус, координати, що тримає в руках inv <ім'я> - вміст інвентаря бота (smart) add <N> - додати ще N ботів kick <ім'я> - відключити бота (без автоперепідключення) log all|none|<ім'я> - чиї повідомлення чату/системи показувати quit - вимкнути всіх і вийти""" # біти прапорців блоківSOLID, WATER, DANGER, AVOID = 1, 2, 4, 8 NAME_ADJ = ["Swift", "Dark", "Happy", "Lazy", "Brave", "Silent", "Crazy", "Tiny", "Mighty", "Frosty", "Rusty", "Lucky", "Sneaky", "Cosmic", "Pixel", "Shadow", "Golden", "Wild", "Clever", "Gloomy"]NAME_NOUN = ["Fox", "Wolf", "Creeper", "Miner", "Panda", "Knight", "Ninja", "Builder", "Zombie", "Dragon", "Steve", "Alex", "Wizard", "Hunter", "Owl", "Tiger", "Cat", "Bear", "Raven", "Golem"]NEUTRAL_MOBS = {"enderman", "zombified_piglin", "bee", "iron_golem", "warden", "ender_dragon", "wither", "wolf", "llama", "panda", "polar_bear", "dolphin", "piglin"}DENY_TYPES = {"other", "projectile", "UNKNOWN", "unknown"}DENY_NAMES = {"item", "experience_orb", "armor_stand", "painting", "item_frame", "glow_item_frame", "leash_knot", "area_effect_cloud", "marker", "interaction", "text_display", "block_display", "item_display", "lightning_bolt", "end_crystal", "falling_block", "tnt", "fishing_bobber", "ominous_item_spawner", "evoker_fangs", "eye_of_ender", "firework_rocket"}FOOD_ANIMALS = {"chicken", "cow", "pig", "sheep", "rabbit", "mooshroom"}FOODS = ["cooked_beef", "cooked_porkchop", "cooked_mutton", "cooked_chicken", "cooked_rabbit", "cooked_salmon", "cooked_cod", "bread", "baked_potato", "golden_carrot", "apple", "carrot", "beef", "porkchop", "mutton", "rabbit", "potato", "chicken", "cod", "salmon", "melon_slice", "sweet_berries"] REL_MOVE = {"rel_entity_move", "entity_move_look", "move_entity_pos", "move_entity_pos_rot"}ABS_MOVE = {"entity_teleport", "entity_position_sync", "teleport_entity", "sync_entity_position"} CARD = ((1, 0), (-1, 0), (0, 1), (0, -1))DIAG = ((1, 1), (1, -1), (-1, 1), (-1, -1)) TIER_SPEED = {"wooden": 2.0, "stone": 4.0, "iron": 6.0, "diamond": 8.0, "netherite": 9.0, "golden": 12.0}TIER_ORDER = ["netherite", "diamond", "iron", "stone", "wooden", "golden"]TOOL_RE = re.compile(r"^(wooden|stone|iron|golden|diamond|netherite)_(pickaxe|axe|shovel|hoe|sword)$") # групи предметів для рецептівGROUPS = { "log": lambda n: n.endswith("_log"), "planks": lambda n: n.endswith("_planks"), "cobble": lambda n: n in ("cobblestone", "cobbled_deepslate", "blackstone"), "stick": lambda n: n == "stick", "iron": lambda n: n == "iron_ingot",}MAT = {"wooden": "planks", "stone": "cobble", "iron": "iron"}TOOL_PATTERNS = {"pickaxe": ["MMM", " S ", " S "], "axe": ["MM ", "MS ", " S "], "sword": ["M", "M", "S"], "helmet": ["MMM", "M M"]}TIERS = [ ("wooden", ["wooden_pickaxe", "wooden_axe", "wooden_sword"]), ("stone", ["stone_pickaxe", "stone_axe", "stone_sword"]), ("iron", ["iron_pickaxe", "iron_sword", "iron_axe", "iron_helmet"]),]LOG_NAMES_RE = re.compile(r"_log$") def group_pred(g): return GROUPS.get(g) or (lambda n, g=g: n == g) def recipe(name): """-> (pattern, key, кількість на один крафт) або None.""" if name == "planks": return ["L"], {"L": "log"}, 4 if name == "stick": return ["P", "P"], {"P": "planks"}, 4 if name == "crafting_table": return ["PP", "PP"], {"P": "planks"}, 1 if name == "furnace": return ["CCC", "C C", "CCC"], {"C": "cobble"}, 1 m = re.match(r"^(wooden|stone|iron)_(pickaxe|axe|sword|helmet)$", name) if m: return TOOL_PATTERNS[m.group(2)], {"M": MAT[m.group(1)], "S": "stick"}, 1 return None def recipe_cost(name): pat, key, _ = recipe(name) cost = {} for row in pat: for ch in row: if ch != " ": cost[key[ch]] = cost.get(key[ch], 0) + 1 return cost # ======================================================================# Дані версій (minecraft-data)# ======================================================================def fetch_json(rel, ttl=None): local = os.path.join(CACHE_DIR, rel.replace("/", "__")) if os.path.exists(local) and (ttl is None or time.time() - os.path.getmtime(local) < ttl): with open(local, encoding="utf-8") as f: return json.load(f) url = f"{DATA_URL}/{rel}" try: with urllib.request.urlopen(url, timeout=30) as r: raw = r.read() except Exception as e: if os.path.exists(local): # немає інтернету - беремо старий кеш with open(local, encoding="utf-8") as f: return json.load(f) raise SystemExit(f"Не вдалось завантажити {url}: {e}") os.makedirs(CACHE_DIR, exist_ok=True) with open(local, "wb") as f: f.write(raw) return json.loads(raw) def vkey(name): return tuple(int(x) for x in name.split(".")) def is_release(name): return re.fullmatch(r"\d+(\.\d+)+", name) is not None def load_versions(): dp = fetch_json("dataPaths.json", ttl=3 * 86400)["pc"] pv = fetch_json("pc/common/protocolVersions.json", ttl=3 * 86400) by_name = {x["minecraftVersion"]: x["version"] for x in pv} avail = { n: by_name[n] for n in dp if n in by_name and "protocol" in dp[n] and is_release(n) and by_name[n] >= MIN_PROTOCOL } return dp, avail def pick_version(arg, detected_protocol, avail): """Повертає назву версії з бази за --version, або за протоколом сервера.""" if arg and not arg.isdigit(): if arg in avail: return arg raise SystemExit( f"Версія '{arg}' не підтримується або не знайдена.\n" f"Доступні (1.20.2+): {', '.join(sorted(avail, key=vkey))}\n" f"Якщо щойно вийшла нова версія - видали папку {CACHE_DIR} і спробуй ще раз." ) proto = int(arg) if arg else detected_protocol cands = [n for n, p in avail.items() if p == proto] if not cands: raise SystemExit( f"Протокол {proto} не знайдено в minecraft-data (підтримуються тільки 1.20.2+).\n" f"Якщо це нова версія - видали папку {CACHE_DIR} і спробуй ще раз." ) return max(cands, key=vkey) # ======================================================================# Низькорівневі утиліти протоколу# ======================================================================def varint(n): n &= 0xFFFFFFFF out = bytearray() while True: b = n & 0x7F n >>= 7 if n: out.append(b | 0x80) else: out.append(b) return bytes(out) def mcstr(s): b = s.encode("utf-8") return varint(len(b)) + b def read_varint(buf, off=0): result = shift = 0 while True: b = buf[off] off += 1 result |= (b & 0x7F) << shift if not b & 0x80: break shift += 7 if shift > 35: raise ValueError("VarInt занадто довгий") if result & 0x80000000: result -= 1 << 32 return result, off def read_varlong(buf, off=0): result = shift = 0 while True: b = buf[off] off += 1 result |= (b & 0x7F) << shift if not b & 0x80: break shift += 7 if shift > 70: raise ValueError("VarLong занадто довгий") if result & (1 << 63): result -= 1 << 64 return result, off def read_mcstr(buf, off=0): n, off = read_varint(buf, off) return buf[off:off + n].decode("utf-8", "replace"), off + n def read_lpvec3(b, off=0): """LpVec3 (швидкість сутності в 1.21.9+).""" i = b[off] if i == 0: return (0.0, 0.0, 0.0), off + 1 j = b[off + 1] k = struct.unpack_from(">I", b, off + 2)[0] packed = (k << 16) | (j << 8) | i scale = i & 3 off += 6 if i & 4: v, off = read_varint(b, off) scale |= (v & 0xFFFFFFFF) << 2 def u(n): return min(n & 32767, 32766) * 2.0 / 32766.0 - 1.0 return (u(packed >> 3) * scale, u(packed >> 18) * scale, u(packed >> 33) * scale), off def offline_uuid(name): d = bytearray(hashlib.md5(("OfflinePlayer:" + name).encode("utf-8")).digest()) d[6] = (d[6] & 0x0F) | 0x30 d[8] = (d[8] & 0x3F) | 0x80 return uuid.UUID(bytes=bytes(d)) def random_name(used): while True: a, n, num = random.choice(NAME_ADJ), random.choice(NAME_NOUN), random.randint(1, 999) name = random.choice([f"{a}{n}{num}", f"{a}_{n}", f"{n}{num}", f"{a}{n}", f"{n}_{num}"])[:16] if name not in used: return name def wrap(a): return (a + 180.0) % 360.0 - 180.0 # ---------- NBT / текстові компоненти ----------def _nbt_payload(buf, off, t): if t == 0: return None, off if t == 1: return struct.unpack_from(">b", buf, off)[0], off + 1 if t == 2: return struct.unpack_from(">h", buf, off)[0], off + 2 if t == 3: return struct.unpack_from(">i", buf, off)[0], off + 4 if t == 4: return struct.unpack_from(">q", buf, off)[0], off + 8 if t == 5: return struct.unpack_from(">f", buf, off)[0], off + 4 if t == 6: return struct.unpack_from(">d", buf, off)[0], off + 8 if t == 7: n = struct.unpack_from(">i", buf, off)[0] return None, off + 4 + n if t == 8: n = struct.unpack_from(">H", buf, off)[0] return buf[off + 2:off + 2 + n].decode("utf-8", "replace"), off + 2 + n if t == 9: et = buf[off] n = struct.unpack_from(">i", buf, off + 1)[0] off += 5 items = [] for _ in range(n): v, off = _nbt_payload(buf, off, et) items.append(v) return items, off if t == 10: d = {} while True: tt = buf[off] off += 1 if tt == 0: return d, off n = struct.unpack_from(">H", buf, off)[0] key = buf[off + 2:off + 2 + n].decode("utf-8", "replace") off += 2 + n d[key], off = _nbt_payload(buf, off, tt) if t == 11: n = struct.unpack_from(">i", buf, off)[0] return None, off + 4 + 4 * n if t == 12: n = struct.unpack_from(">i", buf, off)[0] return None, off + 4 + 8 * n raise ValueError(f"невідомий NBT тег {t}") def read_anon_nbt(buf, off=0): t = buf[off] if t == 0: return None, off + 1 return _nbt_payload(buf, off + 1, t) def read_named_nbt(buf, off=0): t = buf[off] if t == 0: return None, off + 1 n = struct.unpack_from(">H", buf, off + 1)[0] return _nbt_payload(buf, off + 3 + n, t) def component_text(c): if c is None: return "" if isinstance(c, str): return c if isinstance(c, list): return "".join(component_text(x) for x in c) if isinstance(c, dict): s = c.get("text", "") if isinstance(c.get("text", ""), str) else "" if "translate" in c: s += str(c["translate"]) if c.get("with"): s += "(" + ", ".join(component_text(x) for x in c["with"]) + ")" for e in c.get("extra", []) or []: s += component_text(e) return s return str(c) def clean(s): return re.sub("\u00a7.", "", s) # ======================================================================# Опис протоколу версії: ID пакетів, серіалізація і розбір за protocol.json# ======================================================================INTS = {"i8": ">b", "u8": ">B", "i16": ">h", "u16": ">H", "i32": ">i", "u32": ">I", "i64": ">q", "u64": ">Q", "f32": ">f", "f64": ">d"} class Protocol: def __init__(self, version, number, dp): self.version, self.number = version, number self.p = fetch_json(f"{dp[version]['protocol']}/protocol.json") self.ids = {} # (state, dir) -> ({name: id}, {id: name}) self.alias = dict(self.p["types"]) for st in ("handshaking", "status", "login", "configuration", "play"): for d in ("toServer", "toClient"): try: pk = self.p[st][d]["types"]["packet"][1] m = next(f for f in pk if f["name"] == "name")["type"][1]["mappings"] except (KeyError, StopIteration): m = {} n2i = {name: int(k, 16) for k, name in m.items()} self.ids[(st, d)] = (n2i, {v: k for k, v in n2i.items()}) try: # локальні типи станів (крім самих пакетів) теж можуть бути аліасами for n, t in self.p[st][d]["types"].items(): if not n.startswith("packet") and n not in self.alias: self.alias[n] = t except KeyError: pass def has(self, state, d, name): return name in self.ids[(state, d)][0] def name_of(self, state, pid): return self.ids[(state, "toClient")][1].get(pid) def packet_def(self, state, d, name): S = self.p[state][d]["types"] params = next(f for f in S["packet"][1] if f["name"] == "params")["type"][1]["fields"] t = params.get(name) if isinstance(t, str): t = S.get(t) or self.p["types"].get(t) return t def first_field(self, state, d, name): t = self.packet_def(state, d, name) if t and t[0] == "container" and t[1]: return t[1][0] return None def field_names(self, state, d, name): try: t = self.packet_def(state, d, name) except Exception: return [] return [f["name"] for f in t[1]] if t and t[0] == "container" else [] # ---------- серіалізація ---------- def _alias(self, t): a = self.alias.get(t) return a if a not in (None, "native") else None def default(self, t): if isinstance(t, str): if t == "bool": return False if t in INTS or t in ("varint", "varlong"): return 0 if t == "UUID": return uuid.UUID(int=0) a = self._alias(t) return self.default(a) if a else 0 k, a = t if k == "container": return {f["name"]: self.default(f["type"]) for f in a} if k == "option": return None if k == "array": return [] if k == "buffer": return b"\x00" * a["count"] if "count" in a else b"" if k == "pstring": return "" return 0 def enc(self, t, v, ctx=None): if isinstance(t, str): if t == "varint": return varint(v) if t == "bool": return b"\x01" if v else b"\x00" if t in INTS: return struct.pack(INTS[t], v) if t == "UUID": return (v if isinstance(v, uuid.UUID) else uuid.UUID(str(v))).bytes if t == "void": return b"" if t == "restBuffer": return v a = self._alias(t) if a is None: raise ValueError(f"не підтримуваний тип {t}") return self.enc(a, v, ctx) k, a = t if k == "pstring": return mcstr(v) if k == "container": return b"".join(self.enc(f["type"], v.get(f["name"], self.default(f["type"])), v) for f in a) if k == "option": return b"\x00" if v is None else b"\x01" + self.enc(a, v, ctx) if k == "array": return varint(len(v)) + b"".join(self.enc(a["type"], x, ctx) for x in v) if k == "buffer": if "count" in a: return bytes(v) return varint(len(v)) + bytes(v) if k == "mapper": if isinstance(v, str): v = int(next(key for key, name in a["mappings"].items() if name == v)) return self.enc(a["type"], v, ctx) if k == "switch": cv = (ctx or {}).get(a["compareTo"].split("/")[-1]) if isinstance(cv, bool): cv = "true" if cv else "false" return self.enc(a["fields"].get(str(cv), a.get("default", "void")), v, ctx) if k == "bitflags": if isinstance(v, dict): v = sum(1 << i for i, n in enumerate(a["flags"]) if v.get(n)) return self.enc(a["type"], int(v), ctx) if k == "bitfield": # напр. position {x:26, z:26, y:12} v = v if isinstance(v, dict) else {} total = sum(f["size"] for f in a) val, shift = 0, total for f in a: shift -= f["size"] val |= (int(v.get(f["name"], 0)) & ((1 << f["size"]) - 1)) << shift return val.to_bytes(total // 8, "big") raise ValueError(f"не підтримуваний тип {k}") def build(self, state, name, **values): pid = self.ids[(state, "toServer")][0][name] t = self.packet_def(state, "toServer", name) payload = self.enc(t, values) if t else b"" return pid, payload # ---------- розбір пакетів (за protocol.json) ---------- def dec(self, t, b, off, ctx=None): if isinstance(t, str): if t == "varint": return read_varint(b, off) if t == "varlong": return read_varlong(b, off) if t == "bool": return b[off] != 0, off + 1 if t in INTS: f = INTS[t] return struct.unpack_from(f, b, off)[0], off + struct.calcsize(f) if t == "UUID": return uuid.UUID(bytes=bytes(b[off:off + 16])), off + 16 if t == "void": return None, off if t == "restBuffer": return b[off:], len(b) if t in ("anonymousNbt", "anonOptionalNbt"): return read_anon_nbt(b, off) if t in ("nbt", "optionalNbt"): return read_named_nbt(b, off) a = self._alias(t) if a is None: raise ValueError(f"не підтримуваний тип {t}") return self.dec(a, b, off, ctx) k, a = t if k == "pstring": if "countType" in a: n, off = self.dec(a["countType"], b, off) else: n = a["count"] return bytes(b[off:off + n]).decode("utf-8", "replace"), off + n if k == "container": d = {} for f in a: v, off = self.dec(f["type"], b, off, d) if f.get("anon"): if isinstance(v, dict): d.update(v) else: d[f["name"]] = v return d, off if k == "array": if "countType" not in a: raise ValueError("array без countType") n, off = self.dec(a["countType"], b, off) out = [] for _ in range(n): v, off = self.dec(a["type"], b, off, ctx) out.append(v) return out, off if k == "option": flag = b[off] off += 1 if not flag: return None, off return self.dec(a, b, off, ctx) if k == "buffer": if "countType" in a: n, off = self.dec(a["countType"], b, off) else: n = a["count"] return bytes(b[off:off + n]), off + n if k == "mapper": return self.dec(a["type"], b, off, ctx) if k == "bitflags": return self.dec(a["type"], b, off, ctx) if k == "bitfield": total = sum(f["size"] for f in a) nb = total // 8 val = int.from_bytes(b[off:off + nb], "big") out, shift = {}, total for f in a: shift -= f["size"] x = (val >> shift) & ((1 << f["size"]) - 1) if f.get("signed") and x >= 1 << (f["size"] - 1): x -= 1 << f["size"] out[f["name"]] = x return out, off + nb if k == "switch": cv = (ctx or {}).get(a["compareTo"].split("/")[-1]) if cv is None: raise ValueError("switch: немає значення compareTo") if isinstance(cv, bool): cv = "true" if cv else "false" return self.dec(a["fields"].get(str(cv), a.get("default", "void")), b, off, ctx) raise ValueError(f"не підтримуваний тип {k}") def decode(self, state, name, payload, until=None): """Розбирає пакет toClient поле за полем. Що не вдалось розібрати - пропускає (повертає частину).""" try: t = self.packet_def(state, "toClient", name) except Exception: return {} d = {} if not t or t[0] != "container": return d off = 0 for f in t[1]: try: v, off = self.dec(f["type"], payload, off, d) except Exception: break if f.get("anon"): if isinstance(v, dict): d.update(v) else: d[f["name"]] = v if until and f.get("name") == until: break return d # ======================================================================# Світ: блоки, предмети, чанки# ======================================================================AVOID_RE = re.compile( r"slab|stairs|fence|_wall$|carpet|trapdoor|_door$|pane$|bars$|_bed$|^snow$|cake|anvil|chest|" r"enchanting_table|hopper|cauldron|brewing_stand|lantern|candle|flower_pot|_head$|_skull$|" r"dripstone|scaffolding|ladder|vine|sea_pickle|turtle_egg|lectern|grindstone|stonecutter|composter|" r"end_portal|daylight_detector|conduit|azalea|dripleaf|honey_block|soul_sand|^mud$|farmland|dirt_path|" r"chain|amethyst_cluster|_bud$|end_rod|lightning_rod|^bell$|piston|sculk_sensor|sculk_shrieker|" r"ice|slime_block|rail|button|pressure_plate|lever|torch|sign|banner|bamboo|^cocoa$|repeater|" r"comparator|campfire|decorated_pot|beacon|end_gateway|heavy_core|vault|bed$|cobweb|powder_snow|" r"crafting_table|furnace|smoker|blast_furnace") class BlockInfo: """state id блоку -> прапорці, твердість, потрібний інструмент (за blocks.json).""" WATER_NAMES = {"water", "kelp", "kelp_plant", "seagrass", "tall_seagrass", "bubble_column"} DANGER_NAMES = {"lava", "fire", "soul_fire", "magma_block", "cactus", "campfire", "soul_campfire", "sweet_berry_bush", "wither_rose", "cobweb", "powder_snow", "pointed_dripstone"} NO_MINE = {"bedrock", "barrier", "command_block", "chain_command_block", "repeating_command_block", "structure_block", "jigsaw", "end_portal", "end_portal_frame", "end_gateway", "light", "reinforced_deepslate", "spawner", "trial_spawner", "vault", "obsidian", "crying_obsidian", "ancient_debris", "respawn_anchor", "enchanting_table"} def __init__(self, blocks): rng = [] self.by_name = {} for b in blocks: n, fl = b["name"], 0 if b.get("boundingBox") == "block": fl |= SOLID if n in self.WATER_NAMES: fl = WATER if n in self.DANGER_NAMES: fl |= DANGER if AVOID_RE.search(n): fl |= AVOID hard = b.get("hardness") hard = -1.0 if hard is None or n in self.NO_MINE else float(hard) mm = re.search(r"mineable/(\w+)", b.get("material", "") or "") ht = set(int(k) for k in b["harvestTools"]) if b.get("harvestTools") else None rng.append((b["minStateId"], b["maxStateId"], fl, hard, n, mm.group(1) if mm else None, ht)) self.by_name[n] = (b["minStateId"], b["maxStateId"]) rng.sort(key=lambda r: r[0]) self.rng = rng self.starts = [r[0] for r in rng] self.memo = {} def _idx(self, s): i = bisect.bisect_right(self.starts, s) - 1 return i if i >= 0 and self.rng[i][0] <= s <= self.rng[i][1] else -1 def flags(self, s): f = self.memo.get(s) if f is None: i = self._idx(s) f = self.rng[i][2] if i >= 0 else 0 self.memo[s] = f return f def name(self, s): i = self._idx(s) return self.rng[i][4] if i >= 0 else "air" def hardness(self, s): i = self._idx(s) return self.rng[i][3] if i >= 0 else -1.0 def kind(self, s): i = self._idx(s) return self.rng[i][5] if i >= 0 else None def state_ids(self, names): out = set() for n in names: r = self.by_name.get(n) if r: out.update(range(r[0], r[1] + 1)) return out def names_where(self, pred): return [n for n in self.by_name if pred(n)] def dig_ticks(self, s, held_name=None, held_id=None): """Скільки тіків ламати цей блок з даним предметом у руці (-1 - не можна).""" i = self._idx(s) if i < 0 or self.rng[i][3] < 0: return -1 _, _, _, hard, _, kind, ht = self.rng[i] if hard == 0: return 1 spd = 1.0 mt = TOOL_RE.match(held_name or "") if mt and mt.group(2) == kind: spd = TIER_SPEED[mt.group(1)] harvest = ht is None or (held_id in ht) return max(1, int(math.ceil(hard * (30 if harvest else 100) / spd))) class ItemInfo: def __init__(self, items): self.by_id = {it["id"]: it["name"] for it in items} self.by_name = {it["name"]: it["id"] for it in items} def find_comp_map(obj): """Шукає в protocol.json відповідність id -> назва data-component (для розбору слотів 1.20.5+).""" if isinstance(obj, dict): mp = obj.get("mappings") if isinstance(mp, dict) and mp: names = {str(v).replace("minecraft:", "") for v in mp.values()} if "damage" in names and "max_damage" in names: out = {} for k, v in mp.items(): try: out[int(k, 0)] = str(v).replace("minecraft:", "") except ValueError: pass return out for v in obj.values(): r = find_comp_map(v) if r: return r elif isinstance(obj, list): for v in obj: r = find_comp_map(v) if r: return r return None def build_entities(entities): out = {} for e in entities: typ, cat, name = e.get("type", ""), e.get("category", ""), e["name"] out[e.get("internalId", e["id"])] = { "name": name, "h": e.get("height", 1.8), "hostile": (typ == "hostile" or cat.startswith("Hostile")) and name not in NEUTRAL_MOBS, "attack": typ not in DENY_TYPES and name not in DENY_NAMES, } return out CHUNK_FMT = {"len": None} # чи є префікс довжини в масивах paletted container (залежить від версії) def parse_sections(buf, with_len): off, secs = 0, [] n = len(buf) while off < n: off += 2 # block_count bits = buf[off] off += 1 single = pal = data_off = None if bits == 0: single, off = read_varint(buf, off) if with_len: ln, off = read_varint(buf, off) off += 8 * ln else: if bits <= 8: cnt, off = read_varint(buf, off) pal = [] for _ in range(cnt): v, off = read_varint(buf, off) pal.append(v) nl = -(-4096 // (64 // bits)) if with_len: ln, off = read_varint(buf, off) if ln != nl: raise ValueError("довжина масиву не збігається") data_off = off off += 8 * nl bb = buf[off] off += 1 if bb == 0: _, off = read_varint(buf, off) if with_len: ln, off = read_varint(buf, off) off += 8 * ln else: if bb <= 3: cnt, off = read_varint(buf, off) for _ in range(cnt): _, off = read_varint(buf, off) nl = -(-64 // (64 // bb)) if with_len: ln, off = read_varint(buf, off) if ln != nl: raise ValueError("довжина масиву біомів не збігається") off += 8 * nl if off > n: raise ValueError("вихід за межі буфера") secs.append((single, bits, pal, data_off)) if off != n: raise ValueError("зайві байти в чанку") return secs class World: def __init__(self, binfo): self.b = binfo self.chunks = {} # (cx, cz) -> (buf, secs, min_y, overrides) self.failed = 0 def load(self, cx, cz, buf): order = [True, False] if CHUNK_FMT["len"] is None else [CHUNK_FMT["len"]] for wl in order: try: secs = parse_sections(buf, wl) except Exception: continue CHUNK_FMT["len"] = wl self.chunks[(cx, cz)] = (buf, secs, -64 if len(secs) > 16 else 0, {}) return True self.failed += 1 return False def unload(self, cx, cz): self.chunks.pop((cx, cz), None) def has(self, x, z): return (math.floor(x) >> 4, math.floor(z) >> 4) in self.chunks def set_block(self, x, y, z, state): c = self.chunks.get((x >> 4, z >> 4)) if c: c[3][(x, y, z)] = state def state_at(self, x, y, z): c = self.chunks.get((x >> 4, z >> 4)) if c is None: return None buf, secs, min_y, ov = c if ov: s = ov.get((x, y, z)) if s is not None: return s si = (y - min_y) >> 4 if si < 0: return None if si >= len(secs): return 0 single, bits, pal, off = secs[si] if single is not None: return single idx = ((y & 15) << 8) | ((z & 15) << 4) | (x & 15) li, sh = divmod(idx, 64 // bits) val = (struct.unpack_from(">Q", buf, off + 8 * li)[0] >> (sh * bits)) & ((1 << bits) - 1) return pal[val] if pal is not None else val def flags(self, x, y, z): s = self.state_at(x, y, z) if s is None: return SOLID # невідомий чанк/під світом - вважаємо стіною return self.b.flags(s) def collides(self, x, y, z): x0, x1 = math.floor(x - 0.3 + 1e-6), math.floor(x + 0.3 - 1e-6) z0, z1 = math.floor(z - 0.3 + 1e-6), math.floor(z + 0.3 - 1e-6) y0, y1 = math.floor(y + 1e-6), math.floor(y + 1.8 - 1e-6) for xx in range(x0, x1 + 1): for zz in range(z0, z1 + 1): for yy in range(y0, y1 + 1): if self.flags(xx, yy, zz) & SOLID: return True return False def find(self, ids, px, pz, limit=80): """Усі блоки зі state-id із множини ids у прогружених чанках (найближчі чанки першими).""" out = [] items = sorted(self.chunks.items(), key=lambda kv: (kv[0][0] * 16 + 8 - px) ** 2 + (kv[0][1] * 16 + 8 - pz) ** 2) for (cx, cz), (buf, secs, min_y, ov) in items: for si, (single, bits, pal, off) in enumerate(secs): if single is not None: continue if pal is not None: tidx = {i for i, p in enumerate(pal) if p in ids} if not tidx: continue else: tidx = ids per = 64 // bits nl = -(-4096 // per) longs = struct.unpack_from(">%dQ" % nl, buf, off) mask = (1 << bits) - 1 for idx in range(4096): if ((longs[idx // per] >> ((idx % per) * bits)) & mask) in tidx: out.append((cx * 16 + (idx & 15), min_y + si * 16 + (idx >> 8), cz * 16 + ((idx >> 4) & 15))) for (x, y, z), s in ov.items(): if s in ids and x >> 4 == cx and z >> 4 == cz: out.append((x, y, z)) if len(out) >= limit * 3: break res = [] for c in set(out): s = self.state_at(*c) if s in ids: res.append(c) res.sort(key=lambda c: (c[0] + .5 - px) ** 2 + (c[2] + .5 - pz) ** 2) return res[:limit] # ======================================================================# З'єднання# ======================================================================class MCConnection: def __init__(self, host, port, timeout=60): self.sock = socket.create_connection((host, port), timeout=15) self.sock.settimeout(timeout) self.rf = self.sock.makefile("rb") self.lock = threading.Lock() self.threshold = -1 def send(self, pid, payload=b""): body = varint(pid) + payload if self.threshold >= 0: if len(body) >= self.threshold: body = varint(len(body)) + zlib.compress(body) else: body = varint(0) + body with self.lock: self.sock.sendall(varint(len(body)) + body) def _read_varint(self): result = shift = 0 while True: b = self.rf.read(1) if not b: raise EOFError("з'єднання закрите") result |= (b[0] & 0x7F) << shift if not b[0] & 0x80: return result shift += 7 if shift > 35: raise ValueError("VarInt занадто довгий") def recv(self): length = self._read_varint() data = self.rf.read(length) if len(data) < length: raise EOFError("з'єднання закрите") if self.threshold >= 0: dl, off = read_varint(data, 0) data = zlib.decompress(data[off:]) if dl else data[off:] pid, off = read_varint(data, 0) return pid, data[off:] def close(self): try: self.sock.close() except Exception: pass def ping_server(host, port): """Status ping -> (protocol, назва версії).""" c = MCConnection(host, port, timeout=10) try: c.send(0, varint(-1) + mcstr(host) + struct.pack(">H", port) + varint(1)) c.send(0) pid, payload = c.recv() data = json.loads(read_mcstr(payload)[0]) return data["version"]["protocol"], data["version"].get("name", "?") finally: c.close() # ======================================================================# Бот: базовий клієнт + фізика + дії рівня тіків# ======================================================================REGISTERED_RE = re.compile(r"already regist|вже зареєстр|уже зарегистр|ya est[aá] registrad", re.I)FACES = [(0, -1, 0), (0, 1, 0), (0, 0, -1), (0, 0, 1), (-1, 0, 0), (1, 0, 0)] # 0 -Y, 1 +Y, 2 -Z, 3 +Z, 4 -X, 5 +XVARINT_COMPS = {"damage", "max_damage", "max_stack_size", "repair_cost", "map_id", "ominous_bottle_amplifier", "rarity", "map_post_processing"}EMPTY_COMPS = {"fire_resistant", "intangible_projectile", "creative_slot_lock", "glider", "unbreakable"} def find_key(d, key): if isinstance(d, dict): if key in d: return d[key] for v in d.values(): r = find_key(v, key) if r is not None: return r return None class BotBase: def __init__(self, name, index, manager): self.name, self.index, self.m = name, index, manager self.pr = manager.proto self.quit_ev = threading.Event() self.registered = False self.session_no = 0 self.status = "запуск" self.srv_uuid = offline_uuid(name) self.login_uuid = uuid.uuid4() if manager.random_uuid else self.srv_uuid self.plock = threading.RLock() sens = random.uniform(0.25, 1.0) self.rstep = ((sens * 0.6 + 0.2) ** 3) * 8 * 0.15 # крок "миші": усі повороти кратні йому fn = self.pr.field_names("play", "toServer", "player_input") self.new_input = bool(fn) self.input_field = ("" if "forward" in fn else fn[0]) if fn else None self.has_dig_pkt = self.pr.has("play", "toServer", "block_dig") self.c = None self.joined = False self.reset_session() def reset_session(self): self.state = "login" self.joined = False self.stop = threading.Event() self.loaded_sent = False self.loop_started = False self.ai_on = False self.eid = None self.health = 20.0 self.food = 20 self.dead = False self.gamemode = None self.world = World(self.m.binfo) if self.m.smart else None self.entities = {} self.x = self.y = self.z = None self.vx = self.vy = self.vz = 0.0 self.yaw = self.pitch = 0.0 self.on_ground = False self.hcol = False self.in_water = False self.sprinting = False self.lx = self.ly = self.lz = self.lyaw = self.lpitch = None self.reminder = 0 self.spawn = None self.wait_ticks = 0 self.last_input = -1 self.seq = 0 self.clock = 0.0 self.tick_n = 0 # камера self.yvel = self.pvel = 0.0 self.yacc = self.pacc = 0.0 self._turned = [False, False] self.look_next = 0.0 self.look_yaw = self.look_pitch = 0.0 # дії / мозок self.act = None self.act_res = None self.act_ev = threading.Event() self.bad_xz = {} self.stuck_t = 0 self.stuck_pos = (0.0, 0.0) self.next_atk = 0.0 # інвентар self.win = {} self.state_ids = {} self.cursor = None self.open_wid = None self.open_extra = 9 self.inv_ev = threading.Event() self.ow_ev = threading.Event() self.held = 0 self.brain_started = False # ---------- утиліти ---------- def log(self, msg): print(f"[{self.name}] {msg}") def dbg(self, msg): if self.m.debug: self.log("DEBUG " + msg) def vlog(self, msg): if self.m.verbose: self.log(msg) def send(self, state, name, **values): if not self.pr.has(state, "toServer", name): return False pid, payload = self.pr.build(state, name, **values) self.c.send(pid, payload) return True def text_from(self, state, name, payload, off=0): ff = self.pr.first_field(state, "toClient", name) if ff and ff["type"] == "string": s, _ = read_mcstr(payload, off) try: return clean(component_text(json.loads(s))) except ValueError: return clean(s) comp, _ = read_anon_nbt(payload, off) return clean(component_text(comp)) # ---------- сесія та перепідключення ---------- def run(self): m = self.m fails = 0 while True: self.session_no += 1 t0 = time.time() self.session() if self.quit_ev.is_set() or not m.reconnect: break if m.max_reconnects and self.session_no > m.max_reconnects: self.log("досягнуто ліміт перепідключень") break fails = fails + 1 if time.time() - t0 < 15 else 0 delay = min(m.reconnect_delay * (2 ** fails), 120) self.status = f"перепідключення через {delay:.0f}с" self.log(f"перепідключення через {delay:.0f}с (спроба {self.session_no})") if self.quit_ev.wait(delay): break self.status = "відключений" def session(self): m = self.m self.reset_session() self.status = "підключення" try: self.c = MCConnection(m.host, m.port) self.send("handshaking", "set_protocol", protocolVersion=self.pr.number, serverHost=m.host, serverPort=m.port, nextState=2) self.send("login", "login_start", username=self.name, playerUUID=self.login_uuid) while not self.stop.is_set(): pid, payload = self.c.recv() name = self.pr.name_of(self.state, pid) self.dbg(f"{self.state}: {name or hex(pid)}") if name: try: self.handle(name, payload) except (EOFError, OSError): raise except Exception as e: self.dbg(f"пакет {name}: {type(e).__name__}: {e}") except (EOFError, ConnectionError, socket.timeout, OSError) as e: if not self.stop.is_set(): self.log(f"з'єднання втрачено: {e}") except Exception as e: self.log(f"помилка: {type(e).__name__}: {e}") finally: self.joined = False self.stop.set() self.act_ev.set() self.inv_ev.set() self.ow_ev.set() if self.c: self.c.close() # ---------- обробка пакетів ---------- def handle(self, name, p): st = self.state if name in ("disconnect", "kick_disconnect"): if st == "login": try: s = clean(component_text(json.loads(read_mcstr(p)[0]))) except ValueError: s = read_mcstr(p)[0] else: s = self.text_from(st, name, p) self.log(f"сервер відключив: {s}") self.stop.set() return if name == "keep_alive": self.send(st, "keep_alive", keepAliveId=struct.unpack(">q", p[:8])[0]) return if name == "ping": self.send(st, "pong", id=struct.unpack(">i", p[:4])[0]) return if name in ("add_resource_pack", "resource_pack_send"): self.resource_pack(st, p) return if name == "cookie_request": key, _ = read_mcstr(p) self.send(st, "cookie_response", key=key, value=None) return if name == "custom_payload": return if st == "login": if name == "compress": self.c.threshold = read_varint(p)[0] elif name == "encryption_begin": self.log("сервер вимагає шифрування (online-mode=true). Постав online-mode=false.") self.stop.set() self.quit_ev.set() elif name == "login_plugin_request": self.send("login", "login_plugin_response", messageId=read_varint(p)[0], data=None) elif name == "success": self.send("login", "login_acknowledged") self.state = "configuration" self.send("configuration", "custom_payload", channel="minecraft:brand", data=mcstr("vanilla")) self.send("configuration", "settings", locale="en_us", viewDistance=self.m.view_distance, chatFlags=0, chatColors=True, skinParts=127, mainHand=1, enableTextFiltering=False, enableServerListing=True, particleStatus="minimal") return if st == "configuration": if name == "select_known_packs": self.send("configuration", "select_known_packs", packs=[]) elif name == "code_of_conduct": self.send("configuration", "accept_code_of_conduct") elif name == "finish_configuration": self.send("configuration", "finish_configuration") self.state = "play" return if st == "play": self.handle_play(name, p) def handle_play(self, name, p): m = self.m if name == "login": d = self.pr.decode("play", "login", p) self.eid = d.get("entityId") gm = find_key(d, "gameMode") if isinstance(gm, int): self.gamemode = gm if not self.joined: self.joined = True self.status = "онлайн" self.log("зайшов на сервер") threading.Thread(target=self.startup_routine, args=(self.stop,), daemon=True).start() if not self.loop_started: self.loop_started = True threading.Thread(target=self.keepalive_loop, args=(self.stop,), daemon=True).start() elif name == "position": self.on_position(p) elif name == "start_configuration": self.send("play", "configuration_acknowledged") self.state = "configuration" elif name == "update_health": self.health = struct.unpack(">f", p[:4])[0] if len(p) >= 5: try: self.food = read_varint(p, 4)[0] except Exception: pass if self.health <= 0: if not self.dead: self.dead = True self.cancel_act_raw("dead") self.send("play", "client_command", actionId="perform_respawn") else: self.dead = False elif name == "game_state_change": if len(p) >= 5 and p[0] == 3: self.gamemode = int(struct.unpack(">f", p[1:5])[0]) elif name == "chunk_batch_finished": self.send("play", "chunk_batch_received", chunksPerTick=20.0) elif name == "system_chat": if m.should_log(self.name) or m.no_register_on_reconnect: text = self.text_from("play", "system_chat", p) if m.should_log(self.name): self.log("чат: " + text) if REGISTERED_RE.search(text): self.registered = True elif name == "player_chat": if m.should_log(self.name): off = 0 ff = self.pr.first_field("play", "toClient", "player_chat") if ff and ff["name"] == "globalIndex": _, off = read_varint(p, off) sender = uuid.UUID(bytes=p[off:off + 16]) off += 16 _, off = read_varint(p, off) if p[off]: off += 256 off += 1 msg, _ = read_mcstr(p, off) who = m.name_by_uuid.get(sender, str(sender)[:8]) self.log(f"чат <{who}> {clean(msg)}") elif m.smart and self.world is not None: self.handle_world(name, p) # ---------- інвентар (розбір слотів) ---------- def read_wid(self, p, off=0): if self.pr.number >= 768: return read_varint(p, off) return struct.unpack_from(">b", p, off)[0], off + 1 def read_slot(self, b, off): m = self.m if self.pr.number < 766: if not b[off]: return None, off + 1 iid, o = read_varint(b, off + 1) cnt = struct.unpack_from(">b", b, o)[0] nbt, o = read_anon_nbt(b, o + 1) dmg = nbt.get("Damage", 0) if isinstance(nbt, dict) else 0 return {"id": iid, "name": m.items.by_id.get(iid, "?"), "count": cnt, "damage": dmg}, o cnt, o = read_varint(b, off) if cnt <= 0: return None, o iid, o = read_varint(b, o) nadd, o = read_varint(b, o) nrem, o = read_varint(b, o) dmg = 0 for _ in range(nadd): cid, o = read_varint(b, o) cn = m.comp_names.get(cid) if cn in VARINT_COMPS: v, o = read_varint(b, o) if cn == "damage": dmg = v elif cn == "enchantment_glint_override": o += 1 elif cn in ("custom_name", "item_name"): _, o = read_anon_nbt(b, o) elif cn in EMPTY_COMPS: pass else: raise ValueError(f"невідомий компонент предмета {cn or cid}") for _ in range(nrem): _, o = read_varint(b, o) return {"id": iid, "name": m.items.by_id.get(iid, "?"), "count": cnt, "damage": dmg}, o def on_window_items(self, p): wid, o = self.read_wid(p) sid, o = read_varint(p, o) n, o = read_varint(p, o) slots = [] try: for _ in range(n): s, o = self.read_slot(p, o) slots.append(s) except Exception as e: self.dbg(f"window_items: {e}") slots += [None] * (n - len(slots)) try: cur, o = self.read_slot(p, o) except Exception: cur = None self.win[wid] = slots self.state_ids[wid] = sid self.cursor = cur self.inv_ev.set() def on_set_slot(self, p): wid, o = self.read_wid(p) sid, o = read_varint(p, o) slot = struct.unpack_from(">h", p, o)[0] try: it, _ = self.read_slot(p, o + 2) except Exception as e: self.dbg(f"set_slot: {e}") it = None if wid == -1: self.cursor = it elif wid == -2: pass else: lst = self.win.setdefault(wid, []) while len(lst) <= slot: lst.append(None) if slot >= 0: lst[slot] = it self.state_ids[wid] = sid self.inv_ev.set() def click(self, wid, slot, button=0, mode=0, wait=0.25): sid = self.state_ids.get(wid, 0) pid = self.pr.ids[("play", "toServer")][0].get("window_click") if pid is None: return payload = (varint(wid) + varint(sid) + struct.pack(">h", slot) + struct.pack(">b", button) + varint(mode) + varint(0) + b"\x00") self.inv_ev.clear() self.c.send(pid, payload) self.inv_ev.wait(wait) time.sleep(0.07) # ---------- світ / сутності ---------- def handle_world(self, name, p): w, pr = self.world, self.pr if name == "map_chunk": d = pr.decode("play", name, p, until="chunkData") if "chunkData" in d and "x" in d: if not w.load(d["x"], d["z"], d["chunkData"]) and w.failed == 1: self.log("не вдалось розібрати чанк - формат цієї версії невідомий") elif name == "unload_chunk": d = pr.decode("play", name, p) if "chunkX" in d: w.unload(d["chunkX"], d["chunkZ"]) elif name == "block_change": d = pr.decode("play", name, p) loc = d.get("location") if loc and "type" in d: w.set_block(loc["x"], loc["y"], loc["z"], d["type"]) elif name == "multi_block_change": d = pr.decode("play", name, p) cc = d.get("chunkCoordinates") if cc and d.get("records"): for v in d["records"]: w.set_block(cc["x"] * 16 + ((v >> 8) & 15), cc["y"] * 16 + (v & 15), cc["z"] * 16 + ((v >> 4) & 15), v >> 12) elif name == "spawn_entity": d = pr.decode("play", name, p) info = self.m.ents.get(d.get("type")) if info and "x" in d and "entityId" in d: u = next((v for v in d.values() if isinstance(v, uuid.UUID)), None) self.entities[d["entityId"]] = dict(info, id=d["entityId"], uuid=u, x=d["x"], y=d["y"], z=d["z"]) elif name == "entity_destroy": for i in pr.decode("play", name, p).get("entityIds", []): self.entities.pop(i, None) elif name == "collect": i = pr.decode("play", name, p).get("collectedEntityId") self.entities.pop(i, None) elif name in REL_MOVE: d = pr.decode("play", name, p) e = self.entities.get(d.get("entityId")) if e and "dX" in d: e["x"] += d["dX"] / 4096.0 e["y"] += d["dY"] / 4096.0 e["z"] += d["dZ"] / 4096.0 elif name in ABS_MOVE: d = pr.decode("play", name, p) e = self.entities.get(d.get("entityId")) if e and "x" in d and "z" in d: e["x"], e["y"], e["z"] = d["x"], d["y"], d["z"] elif name == "entity_velocity": # відкидання eid, off = read_varint(p, 0) if eid == self.eid: if len(p) - off == 6: vx, vy, vz = struct.unpack_from(">hhh", p, off) v = (vx / 8000.0, vy / 8000.0, vz / 8000.0) else: v, _ = read_lpvec3(p, off) with self.plock: self.vx, self.vy, self.vz = v elif name == "window_items": self.on_window_items(p) elif name == "set_slot": self.on_set_slot(p) elif name == "open_window": d = pr.decode("play", name, p) if "windowId" in d: self.open_wid = d["windowId"] self.ow_ev.set() elif name == "close_window": wid, _ = self.read_wid(p) if wid == self.open_wid: self.open_wid = None def on_position(self, p): d = self.pr.decode("play", "position", p) tid = d.get("teleportId") if tid is None: ff = self.pr.first_field("play", "toClient", "position") tid = read_varint(p, 0)[0] if ff["name"] == "teleportId" else read_varint(p, 33)[0] if "x" in d and "z" in d: fl = d.get("flags") or 0 if not isinstance(fl, int): fl = 0 with self.plock: self.x = (self.x or 0.0) + d["x"] if fl & 1 else d["x"] self.y = (self.y or 0.0) + d["y"] if fl & 2 else d["y"] self.z = (self.z or 0.0) + d["z"] if fl & 4 else d["z"] self.yaw = wrap(self.yaw + d["yaw"]) if fl & 8 else d["yaw"] self.pitch = self.pitch + d["pitch"] if fl & 16 else d["pitch"] self.vx, self.vy, self.vz = d.get("dx", 0.0), d.get("dy", 0.0), d.get("dz", 0.0) self.on_ground = False self.lx, self.ly, self.lz, self.lyaw, self.lpitch = self.x, self.y, self.z, self.yaw, self.pitch self.reminder = 0 self.yvel = self.pvel = 0.0 self.dead = False self.cancel_act_raw("teleport") if self.spawn is None: self.spawn = (self.x, self.z) self.send("play", "teleport_confirm", teleportId=tid) if self.x is not None: self.send("play", "position_look", x=self.x, y=self.y, z=self.z, yaw=self.yaw, pitch=self.pitch, onGround=False, flags=0) if not self.loaded_sent and not (self.m.smart and self.world is not None): self.loaded_sent = True self.send("play", "player_loaded") def resource_pack(self, st, p): fields = self.pr.field_names(st, "toServer", "resource_pack_receive") extra = {"uuid": uuid.UUID(bytes=p[:16])} if "uuid" in fields else {} for result in (3, 0): self.send(st, "resource_pack_receive", result=result, **extra) # ---------- цикл тіків ---------- def keepalive_loop(self, stop): nxt = time.time() while not stop.is_set(): nxt += 0.05 try: if self.state == "play" and self.joined and self.x is not None: self.tick() except OSError: return except Exception as e: self.dbg(f"tick: {type(e).__name__}: {e}") if self.m.debug: traceback.print_exc() d = nxt - time.time() if d > 0: stop.wait(d) elif d < -1: nxt = time.time() def tick(self): with self.plock: w = self.world if self.m.smart and w is not None: if w.has(self.x, self.z): self.wait_ticks = 0 if not self.loaded_sent: self.loaded_sent = True self.send("play", "player_loaded") fwd = jump = spr = False self._turned = [False, False] if self.ai_on and not self.dead: fwd, jump, spr = self.run_action() if not self._turned[0]: self.yvel *= 0.5 if not self._turned[1]: self.pvel *= 0.5 spr = bool(spr and fwd and self.food > 6) self.set_sprint(spr) self.send_input(fwd, jump, spr) self.physics(fwd, jump) else: self.wait_ticks += 1 if self.wait_ticks < 100: return if not self.loaded_sent: self.loaded_sent = True self.send("play", "player_loaded") self.on_ground = True else: self.on_ground = True # простий клієнт: просто "стоїть" self.send_position() self.send("play", "tick_end") def set_sprint(self, flag): if flag == self.sprinting: return self.sprinting = flag start, stop = (1, 2) if self.new_input else (3, 4) self.send("play", "entity_action", entityId=self.eid or 0, actionId=start if flag else stop, jumpBoost=0) def send_input(self, fwd, jump, spr): if self.input_field is None: return val = (1 if fwd else 0) | (2 if jump else 0) | (4 if spr else 0) if val == self.last_input: return self.last_input = val flags = {"forward": bool(fwd), "jump": bool(jump), "sprint": bool(spr)} if self.input_field == "": self.send("play", "player_input", **flags) else: self.send("play", "player_input", **{self.input_field: flags}) def send_position(self): fl = (1 if self.on_ground else 0) | (2 if self.hcol else 0) self.reminder += 1 moved = (self.x - self.lx) ** 2 + (self.y - self.ly) ** 2 + (self.z - self.lz) ** 2 > 4e-8 \ or self.reminder >= 20 rot = self.yaw != self.lyaw or self.pitch != self.lpitch og = self.on_ground if moved and rot: self.send("play", "position_look", x=self.x, y=self.y, z=self.z, yaw=self.yaw, pitch=self.pitch, onGround=og, flags=fl) elif moved: self.send("play", "position", x=self.x, y=self.y, z=self.z, onGround=og, flags=fl) elif rot: self.send("play", "look", yaw=self.yaw, pitch=self.pitch, onGround=og, flags=fl) else: self.send("play", "flying", onGround=og, flags=fl) if moved: self.reminder = 0 self.lx, self.ly, self.lz = self.x, self.y, self.z self.lyaw, self.lpitch = self.yaw, self.pitch # ---------- фізика ---------- def axis(self, ax, d): if d == 0: return w = self.world n = int(abs(d) / 0.4) + 1 s = d / n for _ in range(n): x, y, z = self.x, self.y, self.z if ax == 0: x += s elif ax == 1: y += s else: z += s if w.collides(x, y, z): if ax == 1: if s < 0: self.y = math.floor(y + 1e-9) + 1.0 self.on_ground = True else: self.y = math.floor(y + 1.8) - 1.8 - 1e-4 self.vy = 0.0 elif ax == 0: self.x = (math.floor(x + 0.3) - 0.3 - 1e-4) if s > 0 else (math.floor(x - 0.3) + 1.3 + 1e-4) self.vx = 0.0 self.hcol = True else: self.z = (math.floor(z + 0.3) - 0.3 - 1e-4) if s > 0 else (math.floor(z - 0.3) + 1.3 + 1e-4) self.vz = 0.0 self.hcol = True return self.x, self.y, self.z = x, y, z def physics(self, fwd, jump): w = self.world self.in_water = bool(w.flags(math.floor(self.x), math.floor(self.y + 0.4), math.floor(self.z)) & WATER) was_ground = self.on_ground for a in ("vx", "vy", "vz"): if abs(getattr(self, a)) < 0.003: setattr(self, a, 0.0) if jump: if self.in_water: self.vy += 0.04 elif was_ground: self.vy = 0.42 if self.sprinting and fwd: r = math.radians(self.yaw) self.vx += -math.sin(r) * 0.2 self.vz += math.cos(r) * 0.2 if self.in_water: acc, fric = 0.02, 0.8 elif was_ground: acc, fric = 0.1, 0.546 else: acc, fric = 0.02, 0.91 if fwd: r = math.radians(self.yaw) k = acc * 0.98 * (1.3 if self.sprinting else 1.0) self.vx += -math.sin(r) * k self.vz += math.cos(r) * k self.hcol = False self.on_ground = False self.axis(1, self.vy) self.axis(0, self.vx) self.axis(2, self.vz) self.vy = self.vy * 0.8 - 0.02 if self.in_water else (self.vy - 0.08) * 0.98 if self.in_water and self.hcol and fwd: self.vy = 0.3 self.vx *= fric self.vz *= fric # ---------- камера: плавний розгін/гальмування, кроки кратні "миші" ---------- def _smooth(self, d, vel, vmax, acc): if abs(d) < self.rstep * 0.6 and abs(vel) < 1.0: return 0.0 des = math.copysign(min(vmax, math.sqrt(2 * acc * abs(d))), d) return vel + max(-acc, min(acc, des - vel)) def turn(self, goal, vmax=25.0, acc=3.0): self._turned[0] = True d = wrap(goal - self.yaw) self.yvel = self._smooth(d, self.yvel, vmax, acc) if self.yvel == 0.0: self.yacc = 0.0 return self.yacc += self.yvel k = int(round(self.yacc / self.rstep)) if k: self.yaw = wrap(self.yaw + k * self.rstep) self.yacc -= k * self.rstep def turn_pitch(self, goal, vmax=15.0, acc=2.0): self._turned[1] = True goal = max(-80.0, min(80.0, goal)) d = goal - self.pitch self.pvel = self._smooth(d, self.pvel, vmax, acc) if self.pvel == 0.0: self.pacc = 0.0 return self.pacc += self.pvel k = int(round(self.pacc / self.rstep)) if k: self.pitch = max(-89.9, min(89.9, self.pitch + k * self.rstep)) self.pacc -= k * self.rstep def idle_look(self): if self.clock >= self.look_next: self.look_yaw = self.yaw + random.uniform(-45, 45) self.look_pitch = random.uniform(-12, 18) self.look_next = self.clock + random.uniform(1.0, 3.5) self.turn(self.look_yaw, 6.0, 0.8) self.turn_pitch(self.look_pitch, 4.0, 0.6) # ---------- геометрія ---------- def eye(self): return (self.x, self.y + 1.62, self.z) def angles_to(self, pt): ex, ey, ez = self.eye() dx, dy, dz = pt[0] - ex, pt[1] - ey, pt[2] - ez hd = math.hypot(dx, dz) return math.degrees(math.atan2(-dx, dz)), -math.degrees(math.atan2(dy, max(hd, 1e-6))) def ray_hits(self, eye, pt, pos, F): dx, dy, dz = pt[0] - eye[0], pt[1] - eye[1], pt[2] - eye[2] n = int(math.sqrt(dx * dx + dy * dy + dz * dz) / 0.1) + 1 for i in range(1, n + 1): f = i / n c = (math.floor(eye[0] + dx * f), math.floor(eye[1] + dy * f), math.floor(eye[2] + dz * f)) if c == pos: return True if F(*c) & SOLID: return False return False def visible_face(self, pos, eye=None, F=None): """-> (грань, точка прицілу, курсор) або None.""" eye = eye or self.eye() F = F or self.world.flags c = (pos[0] + .5, pos[1] + .5, pos[2] + .5) best = None for f, (nx, ny, nz) in enumerate(FACES): if (eye[0] - c[0]) * nx + (eye[1] - c[1]) * ny + (eye[2] - c[2]) * nz <= 0.5: continue ip = (c[0] + nx * .47, c[1] + ny * .47, c[2] + nz * .47) if self.ray_hits(eye, ip, pos, F): d = (ip[0] - eye[0]) ** 2 + (ip[1] - eye[1]) ** 2 + (ip[2] - eye[2]) ** 2 if best is None or d < best[0]: cur = [ip[0] - pos[0], ip[1] - pos[1], ip[2] - pos[2]] for ax, nv in enumerate((nx, ny, nz)): if nv: cur[ax] = 1.0 if nv > 0 else 0.0 best = (d, f, ip, tuple(cur)) return best[1:] if best else None def hold_item(self): lst = self.win.get(0) or [] i = 36 + self.held return lst[i] if i < len(lst) else None def walkable(self, x, y, z, F=None): w = self.world if not w.has(x, z): return False bx = self.bad_xz.get((x, z)) if bx and bx > time.time(): return False F = F or w.flags a, b, c = F(x, y, z), F(x, y + 1, z), F(x, y - 1, z) if (a | b) & (SOLID | WATER | DANGER | AVOID): return False if not c & SOLID or c & (DANGER | AVOID): return False for dx, dz in CARD: if (F(x + dx, y, z + dz) | F(x + dx, y + 1, z + dz) | F(x + dx, y - 1, z + dz)) & DANGER: return False return True def ahead(self, yaw, dist=0.8): """Що попереду: flat / up / down / None (небезпечно: урвище >3, лава, вода, стіна).""" r = math.radians(yaw) bx, bz = math.floor(self.x - math.sin(r) * dist), math.floor(self.z + math.cos(r) * dist) by = math.floor(self.y + 1e-3) if self.walkable(bx, by, bz): return "flat" if self.walkable(bx, by + 1, bz) and not self.world.flags(math.floor(self.x), by + 2, math.floor(self.z)) & SOLID: return "up" for d in (1, 2, 3): if self.world.flags(bx, by - d + 1, bz) & SOLID: break if self.walkable(bx, by - d, bz): return "down" return None def safe_ahead(self, yaw): """Захист від падіння: глибина під точкою попереду має бути <=3 і без води/лави.""" r = math.radians(yaw) w = self.world for dist in (0.45, 0.8): bx, bz = math.floor(self.x - math.sin(r) * dist), math.floor(self.z + math.cos(r) * dist) by = math.floor(self.y + 1e-3) ok = False for d in range(0, 4): fl = w.flags(bx, by - 1 - d, bz) if fl & (WATER | DANGER): return False if fl & SOLID: ok = True break if not ok: return False return True # ---------- виконання дій у тіку ---------- def finish(self, res): self.act = None self.act_res = res self.act_ev.set() return False, False, False def cancel_act_raw(self, res): a = self.act if a is not None: self.act = None self.act_res = res self.act_ev.set() def run_action(self): self.clock += 0.05 self.tick_n += 1 a = self.act if a is None: self.idle_look() return False, False, False if "until" in a and self.clock > a["until"]: return self.finish("timeout") return getattr(self, "act_" + a["k"])(a) def act_wait(self, a): if self.clock >= a["end"]: return self.finish("ok") self.idle_look() return False, False, False def act_aim(self, a): wy, wp = self.angles_to(a["pt"]) self.turn(wy, 25.0) self.turn_pitch(wp, 15.0) a["n"] = a.get("n", 0) + 1 if (abs(wrap(wy - self.yaw)) < 1.5 and abs(wp - self.pitch) < 2.0 and abs(self.yvel) < 0.8 and abs(self.pvel) < 0.8): return self.finish("ok") if a["n"] > 140: return self.finish("fail") return False, False, False def dig_packet(self, status, pos, face): self.seq += 1 self.send("play", "block_dig", status=status, location={"x": pos[0], "y": pos[1], "z": pos[2]}, face=face, sequence=self.seq) def dig_step(self, pos, st): """Тримає ліву кнопку на блоці, доки він не зламається. -> busy / ok / fail.""" b = self.m.binfo s = self.world.state_at(*pos) if s is None: return "fail" if not b.flags(s) & SOLID: return "ok" if "pt" not in st: vf = self.visible_face(pos) if not vf: self.vlog(f"копання {pos}: блок не видно з моєї позиції") return "fail" held = self.hold_item() need = b.dig_ticks(s, held["name"] if held else None, held["id"] if held else None) if need < 0: self.vlog(f"копання {pos}: {b.name(s)} не ламається") return "fail" st.update(face=vf[0], pt=vf[1], need=need, t=0, n=0, phase="aim") wy, wp = self.angles_to(st["pt"]) ex, ey, ez = self.eye() if math.sqrt((st["pt"][0] - ex) ** 2 + (st["pt"][1] - ey) ** 2 + (st["pt"][2] - ez) ** 2) > 4.8: return "fail" self.turn(wy, 20.0) self.turn_pitch(wp, 12.0) if st["phase"] == "aim": st["n"] += 1 if (abs(wrap(wy - self.yaw)) < 2.0 and abs(wp - self.pitch) < 2.5 and abs(self.yvel) < 0.8 and abs(self.pvel) < 0.8): self.send("play", "arm_animation", hand=0) self.dig_packet(0, pos, st["face"]) st["phase"], st["t"] = "dig", 0 elif st["n"] > 140: self.vlog(f"копання {pos}: не вдалось націлитись") return "fail" return "busy" st["t"] += 1 self.send("play", "arm_animation", hand=0) # ліва кнопка затиснута: махаємо кожен тік if st["t"] == st["need"]: self.dig_packet(2, pos, st["face"]) elif st["t"] > st["need"] + 25: self.dig_packet(1, pos, st["face"]) self.vlog(f"копання {pos}: сервер не дав зламати ({b.name(s)}, {st['need']} тіків)") return "fail" return "busy" def act_dig(self, a): r = self.dig_step(a["pos"], a.setdefault("_d", {})) if r == "busy": return False, False, False return self.finish(r) def act_path(self, a): nodes, w, b = a["nodes"], self.world, self.m.binfo if a.get("dig") is not None: r = self.dig_step(a["dig"], a.setdefault("_d", {})) if r == "busy": return False, False, False a["dig"], a["_d"] = None, {} if r != "ok": return self.finish("dig_fail") while a["i"] < len(nodes): x, y, z, _ = nodes[a["i"]] if math.hypot(x + .5 - self.x, z + .5 - self.z) < 0.35 and abs(self.y - y) < 1.0: a["i"] += 1 else: break if a["i"] >= len(nodes): return self.finish("done") x, y, z, brk = nodes[a["i"]] pend = [c for c in brk if (w.state_at(*c) is not None and b.flags(w.state_at(*c)) & SOLID)] if pend: # копаємо те, що зараз видно (верх -> низ для спуску, низ -> верх для підйому) vis = [c for c in pend if self.visible_face(c)] a["dig"], a["_d"] = (vis[0] if vis else pend[0]), {} return False, False, False tx, tz = x + .5, z + .5 hd = math.hypot(tx - self.x, tz - self.z) if a["i"] + 1 < len(nodes) and hd < 0.9: # зрізаємо кути плавно nx, _, nz, _ = nodes[a["i"] + 1] k = 0.5 * (1 - hd / 0.9) tx, tz = tx + (nx + .5 - tx) * k, tz + (nz + .5 - tz) * k dx, dz = tx - self.x, tz - self.z want = math.degrees(math.atan2(-dx, dz)) self.turn(want, 24.0) self.turn_pitch(a.setdefault("pitch", random.uniform(2, 12)), 8.0, 1.0) fwd = abs(wrap(want - self.yaw)) < 35 and hd > 0.1 if fwd and self.on_ground and not self.safe_ahead(self.yaw): r = math.radians(self.yaw) # різка зміна рівня вниз: зупиняємось і шукаємо інший шлях self.bad_xz[(math.floor(self.x - math.sin(r) * 0.8), math.floor(self.z + math.cos(r) * 0.8))] = time.time() + 90 return self.finish("unsafe") fy = math.floor(self.y + 1e-3) jump = self.on_ground and y > fy and hd < 1.4 if self.on_ground and self.hcol and fwd and y >= fy: jump = True if self.in_water: jump = True # пливемо: тримаємось на поверхні if hd > 6 and abs(self.y - y) < 8: return self.finish("off_path") if "sp" not in a: a["sp"], a["st"] = (self.x, self.z, self.y), 0 a["st"] += 1 if a["st"] >= 40: if math.sqrt((self.x - a["sp"][0]) ** 2 + (self.z - a["sp"][1]) ** 2 + (self.y - a["sp"][2]) ** 2) < 0.4: return self.finish("stuck") a["st"], a["sp"] = 0, (self.x, self.z, self.y) return fwd, jump, bool(a.get("sprint")) def act_attack(self, a): e = self.entities.get(a["eid"]) if e is None: return self.finish("gone") tp = (e["x"], e["y"] + e["h"] * 0.6, e["z"]) wy, wp = self.angles_to(tp) hd = math.hypot(e["x"] - self.x, e["z"] - self.z) ex, ey, ez = self.eye() d3 = math.sqrt((tp[0] - ex) ** 2 + (tp[1] - ey) ** 2 + (tp[2] - ez) ** 2) self.turn(wy, 30.0, 4.0) self.turn_pitch(wp, 20.0, 3.0) fwd = jump = spr = False if hd > 2.3 and abs(wrap(wy - self.yaw)) < 40: kind = self.ahead(self.yaw) if kind: fwd, jump, spr = True, kind == "up" and self.on_ground, hd > 5 else: a["blk"] = a.get("blk", 0) + 1 if a["blk"] > 15: return self.finish("blocked") if d3 <= 3.0 and self.clock >= self.next_atk and abs(wrap(wy - self.yaw)) < 12 and abs(wp - self.pitch) < 25: if not self.send("play", "attack", entityId=e["id"]): self.send("play", "use_entity", target=e["id"], mouse=1, sneaking=False) self.send("play", "arm_animation", hand=0) self.next_atk = self.clock + random.uniform(0.55, 0.8) return fwd, jump, spr def act_flee(self, a): e = self.entities.get(a["eid"]) if self.clock > a["end"] or e is None: return self.finish("ok") ax, az = self.x - e["x"], self.z - e["z"] if math.hypot(ax, az) > 18: return self.finish("ok") base = math.degrees(math.atan2(-ax, az)) pick = None for off in (0, 30, -30, 60, -60, 90, -90, 135, -135): if self.ahead(base + off): pick = base + off break if pick is None: self.idle_look() return False, False, False self.turn(pick, 35.0, 5.0) fwd = abs(wrap(pick - self.yaw)) < 30 return fwd, self.ahead(self.yaw) == "up" and self.on_ground, True def act_eat(self, a): if "t" not in a: a["t"] = 0 self.seq += 1 self.send("play", "use_item", hand=0, sequence=self.seq, yaw=self.yaw, pitch=self.pitch, rotation={"x": self.yaw, "y": self.pitch}) a["t"] += 1 if a["t"] >= 36: return self.finish("ok") return False, False, False # ---------- дії ---------- def say(self, text): if not (self.joined and self.state == "play"): self.log("ще не на сервері, пропускаю") return ts = int(time.time() * 1000) if text.startswith("/"): self.send("play", "chat_command", command=text[1:], timestamp=ts, salt=0) else: self.send("play", "chat_message", message=text, timestamp=ts, salt=0, signature=None) def run_commands(self, stop=None): stop = stop or self.stop for cmd in self.m.commands: if stop.is_set() or not self.joined: return is_reg = cmd.lower().startswith(("/register", "/reg ")) if is_reg and self.m.no_register_on_reconnect and self.registered: continue self.say(cmd.replace("{name}", self.name).replace("{n}", str(self.index))) if is_reg: self.registered = True time.sleep(self.m.cmd_delay) def startup_routine(self, stop): if stop.wait(self.m.join_wait): return self.run_commands(stop) if stop.wait(1.0): return self.ai_on = True if self.m.smart and not self.brain_started: self.brain_started = True threading.Thread(target=self.brain, args=(stop,), daemon=True).start() while self.m.loop > 0 and not stop.is_set(): if stop.wait(self.m.loop): break self.run_commands(stop) def disconnect(self): self.quit_ev.set() self.stop.set() self.act_ev.set() if self.c: self.c.close() self.joined = False # ======================================================================# "Розумний" режим: пошук шляху, інвентар, крафт, мозок# ======================================================================NB6 = ((1, 0, 0), (-1, 0, 0), (0, 1, 0), (0, -1, 0), (0, 0, 1), (0, 0, -1))STONE_NAMES = ["stone", "cobblestone", "deepslate", "cobbled_deepslate", "blackstone"]IRON_ORES = ["iron_ore", "deepslate_iron_ore"]FALLING = {"gravel", "sand", "red_sand", "suspicious_sand", "suspicious_gravel", "anvil"}COAL_ORES = ["coal_ore", "deepslate_coal_ore"] class Smart: # ---------- інвентар ---------- def pslots(self): wid = self.open_wid if self.open_wid is not None else 0 lst = self.win.get(wid) or [] ex = self.open_extra if self.open_wid is not None else 9 out = [] for ps in range(9, 45): i = ps - 9 + ex if i < len(lst) and lst[i]: out.append((ps, lst[i])) return out def count(self, g): pred = group_pred(g) return sum(it["count"] for _, it in self.pslots() if pred(it["name"])) def stack_of(self, g, minc=1): pred = group_pred(g) best = None for ps, it in self.pslots(): if pred(it["name"]) and it["count"] >= minc and (best is None or it["count"] > best[2]): best = (it["name"], ps, it["count"]) return best def has_item(self, name): if self.count(name) > 0: return True w0 = self.win.get(0) or [] return any(w0[i] and w0[i]["name"] == name for i in range(5, min(9, len(w0)))) def has_food(self): return any(self.count(f) > 0 for f in FOODS) def inv_str(self): d = {} for _, it in self.pslots(): d[it["name"]] = d.get(it["name"], 0) + it["count"] return ", ".join(f"{k}x{v}" for k, v in sorted(d.items())) or "порожньо" def select(self, i): if self.held != i: self.send("play", "held_item_slot", slotId=i) self.held = i def hold(self, name): cur = self.hold_item() if cur and cur["name"] == name: return True self.close_window() lst = self.win.get(0) or [] for ps in range(36, 45): if ps < len(lst) and lst[ps] and lst[ps]["name"] == name: self.select(ps - 36) time.sleep(0.12) return True for ps in range(9, 36): if ps < len(lst) and lst[ps] and lst[ps]["name"] == name: self.click(0, ps, 8, 2) self.select(8) time.sleep(0.12) return True return False def hold_best(self, kind): for tier in TIER_ORDER: n = f"{tier}_{kind}" if self.count(n) > 0: return self.hold(n) return False def hold_for_state(self, s): k = self.m.binfo.kind(s) if k in ("pickaxe", "axe", "shovel", "hoe"): return self.hold_best(k) return False def close_window(self): if self.open_wid is not None: self.send("play", "close_window", windowId=self.open_wid) self.open_wid = None time.sleep(0.2) def equip_armor(self, name): self.close_window() for ps, it in self.pslots(): if it["name"] == name: self.click(0, ps, 0, 1) return True return False # ---------- крафт кліками ---------- def craft(self, name, times=1, table=False): rc = recipe(name) if not rc: return False pat, key, _ = rc W = 3 if table else 2 if len(pat) > W or any(len(r) > W for r in pat): return False wid = self.open_wid if table else 0 if wid is None: return False if not table: self.close_window() extra = 10 if table else 9 groups = {} for r, row in enumerate(pat): for c, ch in enumerate(row): if ch != " ": groups.setdefault(key[ch], []).append(1 + r * W + c) out_g = name if name not in ("planks", "stick") else name before = self.count(out_g) for g, slots in groups.items(): st = self.stack_of(g, len(slots) * times) if not st: self.clear_grid(wid, W) return False src = st[1] - 9 + extra self.click(wid, src, 0) for s in slots: for _ in range(times): self.click(wid, s, 1) self.click(wid, src, 0) if self.cursor: self.click(wid, src, 0) self.click(wid, 0, 0, 1) time.sleep(0.3) self.clear_grid(wid, W) if self.cursor: self.click(wid, -999, 0, 0) return self.count(out_g) > before def clear_grid(self, wid, W): lst = self.win.get(wid) or [] for s in range(1, W * W + 1): if s < len(lst) and lst[s]: self.click(wid, s, 0, 1) def put_into(self, wid, extra, item, dst, n): st = self.stack_of(item, 1) if not st: return src = st[1] - 9 + extra self.click(wid, src, 0) if n >= st[2]: self.click(wid, dst, 0) else: for _ in range(n): self.click(wid, dst, 1) self.click(wid, src, 0) if self.cursor: self.click(wid, src, 0) # ---------- дії (блокуюче очікування) ---------- def do(self, act, timeout=30.0, reflex=True): with self.plock: act["until"] = self.clock + timeout self.act_res = None self.act_ev.clear() self.act = act t0 = time.time() while not self.stop.is_set(): if self.act_ev.wait(0.1): return self.act_res or "?" if time.time() - t0 > timeout + 3: self.cancel_act("timeout") return "timeout" if reflex and self.danger_now(): self.cancel_act("interrupted") return "interrupted" return "stopped" def cancel_act(self, res): with self.plock: a = self.act if a is not None: st = a.get("_d") or {} pos = a.get("pos") or a.get("dig") if st.get("phase") == "dig" and pos: self.dig_packet(1, pos, st.get("face", 1)) self.cancel_act_raw(res) def is_enemy(self, e): if e["name"] == "creeper" or self.ign_ent.get(e["id"], 0) > time.time(): return False if e["hostile"]: return True return e["name"] == "player" and self.m.pvp and e.get("uuid") not in self.m.bot_uuids def danger_now(self): if self.dead: return True for e in list(self.entities.values()): d = math.hypot(e["x"] - self.x, e["z"] - self.z) if e["name"] == "creeper" and d < 8: return True if d < 5 and abs(e["y"] - self.y) < 4 and self.is_enemy(e): return True return False # ---------- планувальник A* (з прориттям тунелів) ---------- def plan_path(self, mode, tx, ty, tz, R, tunnel=False): start = (math.floor(self.x), math.floor(self.y + 1e-3), math.floor(self.z)) return self.plan(start, tx, ty, tz, mode, R, tunnel, 16000 if tunnel else 4000) def plan(self, start, tx, ty, tz, mode, R, tunnel, max_nodes): """A*. Режими цілі: xz (точка на площині), near (поруч), reach (можна копати блок), depth (спуститись до y<=ty).""" w, b = self.world, self.m.binfo fc, okc, kc, tvc = {}, {}, {}, {} swim = bool(w.flags(start[0], start[1], start[2]) & WATER) # стартуємо у воді - дозволяємо пливти def F(x, y, z): k = (x, y, z) v = fc.get(k) if v is None: v = fc[k] = w.flags(x, y, z) return v def ok(x, y, z): k = (x, y, z) v = okc.get(k) if v is None: v = self.walkable(x, y, z, F) if not v and swim and w.has(x, z) and F(x, y, z) & WATER and not F(x, y + 1, z) & (SOLID | DANGER): v = True okc[k] = v return v def ck(x, y, z): k = (x, y, z) v = kc.get(k) if v is None: s_ = w.state_at(x, y, z) if s_ is None: v = ("bad", 0.0) else: fl = b.flags(s_) if fl & (WATER | DANGER | AVOID): v = ("bad", 0.0) elif fl & SOLID: h = b.hardness(s_) bn = b.name(s_) if (h < 0 or h > 8 or bn in FALLING or bn.endswith("_concrete_powder") or any(F(x + a, y + c, z + d) & (WATER | DANGER) for a, c, d in NB6)): v = ("bad", 0.0) else: v = ("dig", h) else: v = ("free", 0.0) kc[k] = v return v def tv(x, y, z): k = (x, y, z) if k in tvc: return tvc[k] r = None if w.has(x, z): c = F(x, y - 1, z) if c & SOLID and not c & (DANGER | AVOID): f1, f2 = ck(x, y, z), ck(x, y + 1, z) if (f1[0] != "bad" and f2[0] != "bad" and not any(F(x + dx, y + yy, z + dz) & DANGER for dx, dz in CARD for yy in (-1, 0, 1))): r = tuple(cc for cc, f in (((x, y, z), f1), ((x, y + 1, z), f2)) if f[0] == "dig") tvc[k] = r return r def nbrs(x, y, z): for dx, dz in CARD: nx, nz = x + dx, z + dz if ok(nx, y, nz): yield (nx, y, nz), (2.5 if swim and F(nx, y, nz) & WATER else 1.0), () elif ok(nx, y + 1, nz) and not F(x, y + 2, z) & SOLID: yield (nx, y + 1, nz), 1.8, () else: for d in (1, 2, 3): if F(nx, y - d + 1, nz) & SOLID: break if ok(nx, y - d, nz): if all(not F(nx, yy, nz) & (SOLID | DANGER | WATER | AVOID) for yy in range(y - d + 2, y + 2)): yield (nx, y - d, nz), 1.5 + 0.4 * d, () break for dx, dz in DIAG: nx, nz = x + dx, z + dz if ok(nx, y, nz) and ok(x + dx, y, z) and ok(x, y, z + dz): yield (nx, y, nz), 1.42, () if tunnel: for dx, dz in CARD: nx, nz = x + dx, z + dz for dy in (0, 1, -1): ny = y + dy br = tv(nx, ny, nz) if br is None: continue extra = () if dy == 1: kk = ck(x, y + 2, z) if kk[0] == "bad": continue if kk[0] == "dig": extra = ((x, y + 2, z),) elif dy == -1: kk = ck(nx, y + 1, nz) if kk[0] == "bad": continue if kk[0] == "dig": extra = ((nx, y + 1, nz),) allb = br + extra if not allb: continue cost = 1.0 + (0.5 if dy else 0.0) for c in allb: cost += 2.0 + ck(*c)[1] * 1.5 yield (nx, ny, nz), cost, allb cell = (math.floor(tx), math.floor(ty), math.floor(tz)) def goal(n): x, y, z = n if mode == "depth": return y <= ty if mode == "xz": return math.hypot(tx - x - .5, tz - z - .5) <= R if mode == "near": return math.hypot(tx - x - .5, tz - z - .5) <= R and abs(ty - y) <= 2.5 ex, ey, ez = x + .5, y + 1.62, z + .5 if (tx - ex) ** 2 + (ty - ey) ** 2 + (tz - ez) ** 2 > R * R: return False fe, he = (x, y, z), (x, y + 1, z) # власні клітинки після прориття вважаємо вільними return self.visible_face(cell, (ex, ey, ez), lambda a, b2, c2: 0 if (a, b2, c2) == fe or (a, b2, c2) == he else F(a, b2, c2)) is not None def h(n): x, y, z = n if mode == "depth": return max(0.0, y - ty) * 15.0 if mode in ("xz", "near"): hd_ = math.hypot(tx - x - .5, tz - z - .5) return hd_ * 5.0 if tunnel else hd_ if tunnel: # у тунелі кожен блок коштує ~5-10 (сходи + ламання), тому евристика "важка" return max(0.0, 5.0 * (math.hypot(tx - x - .5, tz - z - .5) + abs(ty - y - 1.0)) - R * 3.0) return max(0.0, math.sqrt((tx - x - .5) ** 2 + (ty - y - 1.0) ** 2 + (tz - z - .5) ** 2) - R * 0.8) wgt = 2.5 if tunnel else 1.25 g = {start: 0.0} came = {} pq = [(h(start) * wgt, 0.0, start)] best = (h(start), start) n = 0 found = None while pq and n < max_nodes: _, gc, cur = heapq.heappop(pq) if gc > g.get(cur, 1e18) + 1e-9: continue n += 1 hh = h(cur) if hh < best[0]: best = (hh, cur) if goal(cur): found = cur break for nb, c, brk in nbrs(*cur): ng = gc + c if ng < g.get(nb, 1e18): g[nb] = ng came[nb] = (cur, brk) heapq.heappush(pq, (ng + wgt * h(nb), ng, nb)) if found is None: if mode == "xz" and h(start) - best[0] >= 6: found = best[1] else: return None path = [] node = found while node in came: prev, brk = came[node] path.append(node + (brk,)) node = prev path.append(start + ((),)) path.reverse() return path def vlog(self, msg): if self.m.verbose: self.log(msg) def run_path(self, path, timeout=None, sprint=False): if timeout is None: br = sum(len(n[3]) for n in path) timeout = min(420.0, 15 + len(path) * 1.5 + br * 8) return self.do({"k": "path", "nodes": path, "i": 1, "sprint": sprint}, timeout) def goto(self, mode, tx, ty, tz, R, tunnel=False, timeout=None): """-> True (дійшов) / False (шляху немає) / "interrupted" (відволік ворог чи кріпер).""" for _ in range(5): path = self.plan_path(mode, tx, ty, tz, R, tunnel) if not path: self.vlog(f"goto: шляху немає (режим {mode}, тунелі: {tunnel})") return False if len(path) <= 1: return True res = self.run_path(path, timeout) if res == "done": return True if res in ("interrupted", "stopped", "dead"): return "interrupted" self.vlog(f"goto: {res}, перепланую") return False # ---------- блоки та предмети навколо ---------- def reach_ok(self, cell): ex, ey, ez = self.eye() if (cell[0] + .5 - ex) ** 2 + (cell[1] + .5 - ey) ** 2 + (cell[2] + .5 - ez) ** 2 > 4.2 ** 2: return False return self.visible_face(cell) is not None def mine_block(self, cell): """-> True / False / "interrupted".""" s = self.world.state_at(*cell) if s is None: return False if not self.m.binfo.flags(s) & SOLID: return True self.hold_for_state(s) for _ in range(3): if not self.reach_ok(cell): g = self.goto("reach", cell[0] + .5, cell[1] + .5, cell[2] + .5, 4.0, True) if g == "interrupted": return "interrupted" if g is not True: return False self.hold_for_state(s) r = self.do({"k": "dig", "pos": cell}, 40) if r == "ok": return True if r in ("interrupted", "stopped", "dead"): return "interrupted" self.vlog(f"копання {cell} не вдалось: {r}") return False def collect_items(self, maxn=8): for _ in range(maxn): items = [e for e in list(self.entities.values()) if e["name"] == "item" and e["id"] not in self.ignore_items and math.hypot(e["x"] - self.x, e["z"] - self.z) < 10 and abs(e["y"] - self.y) < 6] if not items: return e = min(items, key=lambda e: math.hypot(e["x"] - self.x, e["z"] - self.z)) if math.hypot(e["x"] - self.x, e["z"] - self.z) > 0.9 or abs(e["y"] - self.y) > 1.5: if self.goto("near", e["x"], e["y"], e["z"], 0.7, False, 12) is not True: self.ignore_items.add(e["id"]) continue time.sleep(0.5) if e["id"] in self.entities: self.ignore_items.add(e["id"]) def descend(self, ty, maxdrop=8): """Копає/проходить вниз (печери, або сходи в землі) до рівня ty (не більше maxdrop за раз).""" target = max(ty, math.floor(self.y) - maxdrop, -8) if self.y <= target + 0.5: return False self.hold_best("pickaxe") path = self.plan_path("depth", self.x, target, self.z, 0, True) if not path or len(path) <= 1: self.vlog(f"спуск до y={target}: шляху немає") return False self.vlog(f"спускаюсь до y={target} (вузлів {len(path)}, ламати {sum(len(n[3]) for n in path)})") self.run_path(path) self.collect_items() return True def tunnel_forward(self, n=14): if self.tun_dir is None: self.tun_dir = random.choice(CARD) dx, dz = self.tun_dir path = self.plan_path("xz", self.x + dx * n, 0, self.z + dz * n, 1.5, True) if not path or len(path) <= 2: self.tun_dir = random.choice(CARD) self.vlog("тунель: напрямок закритий, міняю") return False self.hold_best("pickaxe") self.vlog(f"риюсь вперед ({dx},{dz}), вузлів {len(path)}") self.run_path(path) self.collect_items() return True def harvest(self, names, until, max_s=300, depth=None, dig_down=False): ids = self.m.binfo.state_ids(names) t0 = time.time() misses = 0 while not until() and time.time() - t0 < max_s and not self.stop.is_set(): if self.reflex(): continue now = time.time() cells = [c for c in self.world.find(ids, self.x, self.z, 150) if self.bad.get(c, 0) < now] cells.sort(key=lambda c: abs(c[0] + .5 - self.x) + abs(c[2] + .5 - self.z) + 1.5 * abs(c[1] - self.y)) done = inter = False for c in cells[:4]: r = self.mine_block(c) if r is True: done = True break if r == "interrupted": inter = True break self.bad[c] = time.time() + 90 if done: misses = 0 self.collect_items() continue if inter: continue misses += 1 self.vlog(f"добування: невдача {misses}, відомих цілей {len(cells)}") if misses > 14: return False if dig_down: self.descend(math.floor(self.y) - 6) elif depth is not None: if self.y > depth + 1: self.descend(depth) else: self.tunnel_forward(14) else: self.explore() return bool(until()) def explore(self, tunnel_ok=True): """Подорож до далекої точки, яка якнайдалі від уже відвіданих місць (щоб не ходити колами).""" self.visit.append((self.x, self.z)) self.visit = self.visit[-30:] cands = [] for k in range(12): ang = k * math.pi / 6 + random.uniform(-0.2, 0.2) dist = random.uniform(40, 65) gx, gz = self.x + math.cos(ang) * dist, self.z + math.sin(ang) * dist while dist > 12 and not self.world.has(gx, gz): dist -= 8 gx, gz = self.x + math.cos(ang) * dist, self.z + math.sin(ang) * dist if dist <= 12: continue far = min(math.hypot(gx - vx, gz - vz) for vx, vz in self.visit) score = far + random.uniform(0, 12) - abs(wrap(math.degrees(ang - self.heading))) * 0.15 cands.append((score, gx, gz, ang)) cands.sort(reverse=True) for score, gx, gz, ang in cands[:4]: path = self.plan_path("xz", gx, 0, gz, 2.0, False) if path and len(path) > 6: self.heading = ang self.vlog(f"йду досліджувати ({gx:.0f},{gz:.0f}), вузлів {len(path)}") self.run_path(path, None, True) return True if tunnel_ok and cands: _, gx, gz, ang = cands[0] self.hold_best("pickaxe") path = self.plan_path("xz", gx, 0, gz, 2.0, True) if path and len(path) > 2: self.heading = ang self.vlog(f"досліджую з прориттям, вузлів {len(path)}") self.run_path(path) return True self.vlog("explore: жодного шляху") return False def unstick(self): self.vlog("сторожовий таймер: майже не рухаюсь - вириваюсь тунелем") self.bad.clear() self.bad_xz.clear() self.tun_dir = random.choice(CARD) self.heading = random.uniform(0, 2 * math.pi) if not self.tunnel_forward(20): self.explore() # ---------- розміщення / використання блоків ---------- def block_name(self, pos): s = self.world.state_at(*pos) return self.m.binfo.name(s) if s is not None else None def top_face(self, ref): eye = self.eye() c = (ref[0] + .5, ref[1] + .5, ref[2] + .5) ip = (c[0], c[1] + .47, c[2]) if eye[1] - c[1] <= 0.5 or not self.ray_hits(eye, ip, ref, self.world.flags): return None return ip def place_near(self, item): """Ставить блок-предмет на землю поруч. -> позиція поставленого блоку або None.""" w, b = self.world, self.m.binfo if not self.hold(item): return None fy = math.floor(self.y + 1e-3) ox, oz = math.floor(self.x), math.floor(self.z) cands = [] for dx, dz in CARD + DIAG: ref, up = (ox + dx, fy - 1, oz + dz), (ox + dx, fy, oz + dz) fr = w.flags(*ref) if (fr & SOLID and not fr & (AVOID | DANGER) and not w.flags(*up) & (SOLID | WATER | DANGER) and not w.flags(up[0], up[1] + 1, up[2]) & SOLID): cands.append((ref, up)) random.shuffle(cands) for ref, up in cands: ip = self.top_face(ref) if not ip: continue if self.do({"k": "aim", "pt": ip}, 6, reflex=False) != "ok": continue self.seq += 1 self.send("play", "block_place", hand=0, location={"x": ref[0], "y": ref[1], "z": ref[2]}, direction=1, cursorX=0.5, cursorY=1.0, cursorZ=0.5, insideBlock=False, worldBorderHit=False, sequence=self.seq) self.send("play", "arm_animation", hand=0) time.sleep(0.5) if self.block_name(up) == item: return up return None def use_block(self, pos): vf = self.visible_face(pos) if not vf: return False face, pt, cur = vf if self.do({"k": "aim", "pt": pt}, 6, reflex=False) != "ok": return False self.seq += 1 self.send("play", "block_place", hand=0, location={"x": pos[0], "y": pos[1], "z": pos[2]}, direction=face, cursorX=cur[0], cursorY=cur[1], cursorZ=cur[2], insideBlock=False, worldBorderHit=False, sequence=self.seq) self.send("play", "arm_animation", hand=0) return True def open_block(self, pos, extra): if self.goto("reach", pos[0] + .5, pos[1] + .5, pos[2] + .5, 4.0, False, 40) is not True: return False self.close_window() self.ow_ev.clear() if not self.use_block(pos): return False if not self.ow_ev.wait(3.0): return False self.open_extra = extra time.sleep(0.5) return True def pickup_block(self, pos): if pos and self.block_name(pos) in ("crafting_table", "furnace"): self.close_window() self.mine_block(pos) self.collect_items() # ---------- ресурси ---------- def ensure_planks(self, n): t0 = time.time() while self.count("planks") < n and time.time() - t0 < 400 and not self.stop.is_set(): need = n - self.count("planks") logs = -(-need // 4) st = self.stack_of("log", 1) if st: times = min(st[2], logs) self.close_window() if not self.craft("planks", times, False): return False continue if not self.harvest(self.m.log_names, lambda: self.count("log") >= logs, 240): return False return self.count("planks") >= n def ensure_stone(self, n): return self.harvest(STONE_NAMES, lambda: self.count("cobble") >= n, 420, dig_down=True) def smelt(self, target): raw = self.count("raw_iron") if raw == 0: return fuel = "coal" if self.count("coal") else ("charcoal" if self.count("charcoal") else None) if not fuel: self.log("нема палива для печі") return need_fuel = min(self.count(fuel), -(-raw // 8)) pos = self.furnace_pos if self.furnace_pos and self.block_name(self.furnace_pos) == "furnace" else None if pos is None: pos = self.place_near("furnace") if pos is None: return self.furnace_pos = pos first = True t0 = time.time() while time.time() - t0 < 60 + raw * 11 and not self.stop.is_set(): if not self.open_block(pos, 3): break wid = self.open_wid if first: self.put_into(wid, 3, "raw_iron", 0, raw) self.put_into(wid, 3, fuel, 1, need_fuel) first = False lst = self.win.get(wid) or [] if len(lst) > 2 and lst[2]: self.click(wid, 2, 0, 1) time.sleep(0.3) lst = self.win.get(wid) or [] left = (lst[0]["count"] if len(lst) > 0 and lst[0] else 0) self.close_window() if self.count("iron_ingot") >= target or left == 0: break for _ in range(12): time.sleep(1) self.wd_skip = time.time() + 40 if self.stop.is_set() or self.reflex(): break def table_session(self, items, pos=None): """Відкрити верстак (поставити, якщо pos не заданий) і скрафтити предмети. -> (pos, скільки скрафтили).""" if pos is None or self.block_name(pos) != "crafting_table": pos = self.place_near("crafting_table") if pos is None: return None, 0 self.table_pos = pos if not self.open_block(pos, 10): return pos, 0 done = 0 for it in items: if all(self.count(g) >= c for g, c in recipe_cost(it).items()): if self.craft(it, 1, True): done += 1 self.log(f"скрафтив {it}") self.close_window() return pos, done def make_tier(self, tier, missing): mat = MAT[tier] cost = {} for it in missing: for g, c in recipe_cost(it).items(): cost[g] = cost.get(g, 0) + c t_sticks = -(-max(0, cost.get("stick", 0) - self.count("stick")) // 4) has_table = self.count("crafting_table") > 0 planks_need = 2 * t_sticks + (0 if has_table else 4) + (cost.get("planks", 0) if mat == "planks" else 0) if not self.ensure_planks(planks_need): return False if t_sticks and not self.craft("stick", t_sticks, False): return False if not has_table and not self.craft("crafting_table", 1, False): return False if tier == "stone": if not self.ensure_stone(cost.get("cobble", 0)): return False if tier == "iron": target = cost.get("iron", 0) if not self.harvest(IRON_ORES, lambda: self.count("raw_iron") + self.count("iron_ingot") >= target, 900, depth=16) \ and self.count("raw_iron") + self.count("iron_ingot") < 3: return False raw = self.count("raw_iron") if raw and self.count("coal") + self.count("charcoal") < -(-raw // 8): self.harvest(COAL_ORES, lambda: self.count("coal") + self.count("charcoal") >= -(-raw // 8), 400, depth=45) if not self.furnace_pos or self.block_name(self.furnace_pos) != "furnace": if not self.ensure_stone(8): return False tpos, n = self.table_session(["furnace"]) if n == 0: self.pickup_block(tpos) return False self.table_pos = tpos self.smelt(target) order = [it for it in missing] tpos, n = self.table_session(order, self.table_pos) else: tpos, n = self.table_session(missing) self.pickup_block(tpos) if tier == "iron" and self.count("iron_helmet") > 0: self.equip_armor("iron_helmet") return all(self.has_item(it) for it in missing) or n > 0 def tool_progress(self): for tier, items in TIERS: missing = [i for i in items if not self.has_item(i)] if not missing: continue if self.skip_until.get(tier, 0) > time.time(): return False if tier == "stone" and not any(self.count(f"{t}_pickaxe") for t in TIER_SPEED): return False if tier == "iron" and not any(self.count(f"{t}_pickaxe") for t in ("stone", "iron", "diamond", "netherite")): return False self.log(f"план: {tier} -> {', '.join(missing)}") ok = self.make_tier(tier, missing) if not ok: self.tier_fail[tier] = self.tier_fail.get(tier, 0) + 1 if self.tier_fail[tier] >= 2: self.skip_until[tier] = time.time() + 240 self.tier_fail[tier] = 0 self.log(f"не виходить ({tier}), пробую пізніше - іду досліджувати") else: self.tier_fail[tier] = 0 return True return False # ---------- їжа / бої / реакції ---------- def eat(self): for f in FOODS: if self.count(f) > 0: self.hold(f) self.do({"k": "eat"}, 6, reflex=False) return True return False def fight(self, e, timeout=25): self.hold_best("sword") t0 = time.time() while e["id"] in self.entities and time.time() - t0 < timeout and not self.stop.is_set() and not self.dead: if any(x["name"] == "creeper" and math.hypot(x["x"] - self.x, x["z"] - self.z) < 8 for x in list(self.entities.values())): return r = self.do({"k": "attack", "eid": e["id"]}, 10, reflex=False) if r == "blocked": p = self.plan_path("near", e["x"], e["y"], e["z"], 2.0, False) if p and len(p) > 1: self.run_path(p, 4, True) else: break elif r in ("stopped", "teleport", "dead"): return if e["id"] in self.entities: # не вдалось добити/дістати - на 30 с забуваємо про нього self.ign_ent[e["id"]] = time.time() + 30 def flee(self, e): self.do({"k": "flee", "eid": e["id"], "end": self.clock + 6.0}, 10, reflex=False) def reflex(self): if self.dead: time.sleep(1.0) return True ents = list(self.entities.values()) for e in ents: if e["name"] == "creeper" and math.hypot(e["x"] - self.x, e["z"] - self.z) < 8: self.log("кріпер! тікаю") self.flee(e) return True best, bd = None, 1e9 for e in ents: d = math.hypot(e["x"] - self.x, e["z"] - self.z) if d < 7 and abs(e["y"] - self.y) < 4 and self.is_enemy(e) and d < bd: best, bd = e, d if best: self.fight(best) return True if self.food <= 14 and self.has_food(): return self.eat() return False def hunt(self): ents = [e for e in list(self.entities.values()) if e["name"] in FOOD_ANIMALS and self.ign_ent.get(e["id"], 0) < time.time() and math.hypot(e["x"] - self.x, e["z"] - self.z) < 60] if not ents: return self.explore() e = min(ents, key=lambda e: math.hypot(e["x"] - self.x, e["z"] - self.z)) self.log(f"полюю: {e['name']}") self.fight(e, 40) self.collect_items() if self.food <= 16: self.eat() return True def random_dig(self): w, b = self.world, self.m.binfo fy = math.floor(self.y + 1e-3) ox, oz = math.floor(self.x), math.floor(self.z) cells = [(ox + random.randint(-3, 3), fy + random.randint(0, 2), oz + random.randint(-3, 3)) for _ in range(30)] for c in cells: s = w.state_at(*c) if s is None or not b.flags(s) & SOLID or b.hardness(s) < 0: continue if any(w.flags(c[0] + a, c[1] + d, c[2] + e) & (WATER | DANGER) for a, d, e in NB6): continue if not self.visible_face(c): continue self.hold_for_state(s) h = self.hold_item() if b.dig_ticks(s, h["name"] if h else None, h["id"] if h else None) > 150: continue if self.mine_block(c): self.collect_items() return True return False def free_roam(self): if not self.explore(): time.sleep(1.0) if random.random() < 0.6: self.random_dig() # ---------- мозок ---------- def brain(self, stop): self.bad, self.ignore_items, self.ign_ent = {}, set(), {} self.visit, self.tun_dir, self.wd_skip = [], None, 0.0 self.table_pos = self.furnace_pos = None self.tier_fail, self.skip_until = {}, {} self.heading = random.uniform(0, 2 * math.pi) while not stop.is_set() and not (self.x is not None and self.world.has(self.x, self.z) and self.win.get(0)): stop.wait(0.5) stop.wait(2.0) if self.gamemode == 1: self.log("УВАГА: бот у creative - smart-режим потребує survival (/gamemode survival {name})") self.log("smart: старт") wd_t, wd_p = time.time(), (self.x, self.y, self.z) while not stop.is_set(): try: if time.time() - wd_t > 60: # сторожовий таймер: майже не рухався хвилину - вириваємось moved = math.sqrt((self.x - wd_p[0]) ** 2 + (self.y - wd_p[1]) ** 2 + (self.z - wd_p[2]) ** 2) if moved < 3 and time.time() > self.wd_skip and not self.dead: self.unstick() wd_t, wd_p = time.time(), (self.x, self.y, self.z) if self.dead: stop.wait(1.0) continue if self.reflex(): continue if self.food <= 12 and not self.has_food() and self.hunt(): continue if self.tool_progress(): continue self.free_roam() except Exception as e: self.log(f"smart помилка: {type(e).__name__}: {e}") if self.m.debug: traceback.print_exc() stop.wait(1.0) class Bot(BotBase, Smart): pass # ======================================================================# Менеджер ботів# ======================================================================class Manager: def __init__(self, args, proto, commands, binfo, ents, items, comp_names): self.host, self.port, self.proto = args.host, args.port, proto self.prefix, self.delay, self.debug = args.prefix, args.delay, args.debug self.commands = commands self.cmd_delay, self.join_wait, self.loop = args.cmd_delay, args.join_wait, args.loop self.random_names, self.random_uuid = args.random_names, args.random_uuid self.reconnect, self.reconnect_delay = args.reconnect_on_kick, args.reconnect_delay self.max_reconnects = args.max_reconnects self.no_register_on_reconnect = args.no_register_on_reconnect self.view_distance = args.view_distance self.binfo, self.ents, self.items, self.comp_names = binfo, ents, items, comp_names self.smart = bool(args.smart and binfo is not None) self.pvp = not args.no_pvp self.verbose = not args.quiet self.log_names = binfo.names_where(lambda n: n.endswith("_log")) if binfo else [] self.bots = {} self.name_by_uuid = {} self.bot_uuids = set() self.counter = 0 self.log_target = None def should_log(self, name): return self.log_target == "all" or self.log_target == name def add(self, n): def worker(): for _ in range(n): self.counter += 1 name = (random_name(set(self.bots)) if self.random_names else f"{self.prefix}{self.counter}") bot = Bot(name, self.counter, self) self.bots[name] = bot self.name_by_uuid[bot.srv_uuid] = name self.bot_uuids.add(bot.srv_uuid) self.bot_uuids.add(bot.login_uuid) if self.log_target is None: self.log_target = name threading.Thread(target=bot.run, daemon=True).start() time.sleep(self.delay) threading.Thread(target=worker, daemon=True).start() def say(self, target, message): if target.lower() == "all": for bot in list(self.bots.values()): bot.say(message) elif target in self.bots: self.bots[target].say(message) else: print(f"Немає бота '{target}'. Напиши 'list'.") def run_all(self): for bot in list(self.bots.values()): threading.Thread(target=bot.run_commands, daemon=True).start() def kick(self, name): bot = self.bots.pop(name, None) if bot: bot.disconnect() print(f"{name} відключений") else: print(f"Немає бота '{name}'") def list(self): for name, bot in self.bots.items(): pos = f" @ {bot.x:.0f} {bot.y:.0f} {bot.z:.0f}" if bot.joined and bot.x is not None else "" extra = "" if self.smart and bot.joined: h = bot.hold_item() extra = f" | hp {bot.health:.0f} їжа {bot.food} | в руці: {h['name'] if h else '-'}" print(f" {name}: {bot.status}{pos}{extra}") print(f"Всього: {len(self.bots)}") def shutdown(self): for bot in list(self.bots.values()): bot.disconnect() def load_commands(args): cmds = list(args.cmd or []) if args.cmds_file: with open(args.cmds_file, encoding="utf-8") as f: cmds += [l.strip() for l in f if l.strip() and not l.startswith("#")] return cmds def main(): ap = argparse.ArgumentParser(description="Тестові боти Minecraft (offline, 1.20.2+)") ap.add_argument("--host", default="127.0.0.1") ap.add_argument("--port", type=int, default=25565) ap.add_argument("--count", type=int, default=1, help="кількість ботів") ap.add_argument("--prefix", default="Bot", help="префікс імені (Bot1, Bot2...)") ap.add_argument("--random-names", action="store_true", help="випадкові ніки") ap.add_argument("--random-uuid", action="store_true", help="слати випадковий UUID у login") ap.add_argument("--delay", type=float, default=1.5, help="пауза між входами ботів, сек") ap.add_argument("--version", default=None, help="версія клієнта (напр. 1.21.9) або номер протоколу") ap.add_argument("--list-versions", action="store_true", help="показати доступні версії") ap.add_argument("--cmd", action="append", help="команда/повідомлення після входу ({name}, {n})") ap.add_argument("--cmds-file", help="файл з командами, по одній на рядок (# - коментар)") ap.add_argument("--join-wait", type=float, default=3.0, help="пауза після входу перед командами, сек") ap.add_argument("--cmd-delay", type=float, default=1.0, help="пауза між командами, сек") ap.add_argument("--loop", type=float, default=0, help="повторювати команди кожні N секунд (0 = раз)") ap.add_argument("--reconnect-on-kick", action="store_true", help="перепідключати бота після кіку/обриву") ap.add_argument("--reconnect-delay", type=float, default=5.0, help="пауза перед перепідключенням, сек") ap.add_argument("--max-reconnects", type=int, default=0, help="макс. сесій на бота (0 = без ліміту)") ap.add_argument("--no-register-on-reconnect", action="store_true", help="не слати /register повторно, якщо бот уже реєструвався") ap.add_argument("--smart", action="store_true", help="розумний бот (survival): фізика, інструменти, їжа, бої, добування. " "Без цього прапорця бот - простий клієнт без фізики й мозку") ap.add_argument("--no-pvp", action="store_true", help="(smart) не атакувати гравців, лише мобів") ap.add_argument("--quiet", action="store_true", help="(smart) не друкувати рішення бота (план, шлях, копання)") ap.add_argument("--view-distance", type=int, default=8, help="(smart) дальність прогрузки чанків") ap.add_argument("--debug", action="store_true", help="показувати пакети (для діагностики)") args = ap.parse_args() dp, avail = load_versions() if args.list_versions: print("Доступні версії (1.20.2+):") print(", ".join(sorted(avail, key=vkey))) return detected = None if not args.version: try: detected, sname = ping_server(args.host, args.port) print(f"Сервер: {sname} (протокол {detected})") except Exception as e: raise SystemExit(f"Не вдалось отримати версію сервера ({e}). Вкажи --version вручну.") version = pick_version(args.version, detected, avail) proto = Protocol(version, avail[version], dp) binfo = ents = items = None comp_names = {} if args.smart: try: binfo = BlockInfo(fetch_json(f"{dp[version]['blocks']}/blocks.json")) ents = build_entities(fetch_json(f"{dp[version]['entities']}/entities.json")) items = ItemInfo(fetch_json(f"{dp[version]['items']}/items.json")) comp_names = find_comp_map(proto.p) or {} if proto.number >= 766 and not comp_names: print("Увага: не знайдено карту компонентів предметів - інвентар може читатись неповно.") except (KeyError, SystemExit): print("Не вдалось завантажити дані блоків/предметів - smart вимкнено.") binfo = ents = items = None commands = load_commands(args) mgr = Manager(args, proto, commands, binfo, ents, items, comp_names) print(f"Версія клієнта: {version} (протокол {proto.number}) | команд при старті: {len(commands)} " f"| режим: {'SMART (потрібен survival)' if mgr.smart else 'простий клієнт'}") print(HELP) mgr.add(args.count) try: while True: line = input("> ").strip() if not line: continue cmd, _, rest = line.partition(" ") if cmd == "quit": break elif cmd == "list": mgr.list() elif cmd == "inv": b = mgr.bots.get(rest.strip()) print(b.inv_str() if b and mgr.smart else "немає такого бота або не smart") elif cmd == "run": mgr.run_all() elif cmd == "add": mgr.add(int(rest or 1)) elif cmd == "kick": mgr.kick(rest) elif cmd == "log": mgr.log_target = rest.strip() or "all" print("лог чату:", mgr.log_target) elif rest: mgr.say(cmd, rest) else: print("Формат: <all|ім'я> <текст або /команда>") except (KeyboardInterrupt, EOFError): pass finally: mgr.shutdown() print("Вимкнено.") if __name__ == "__main__": main()Accept cookies so your theme is remembered.
Hi! This site can remember you between visits using cookies. What should I call you?
Only your name, the chosen theme and the time of your last visit are stored. You can change or erase them at any time. Technical cookies for administrator sign-in are used separately.