★ One day, there will be something interesting here, but for now, there's only this text ★
JeffryFremilimy own project and blog
mc_testbots.py
  1. #!/usr/bin/env python3
  2. """
  3. Тестові боти для ВЛАСНОГО Minecraft сервера (offline-акаунти) + консоль керування.
  4. Власна реалізація протоколу, БЕЗ зовнішніх бібліотек (тільки стандартний Python 3.8+).
  5. Підтримує Java Edition 1.20.2 і новіші (включно з 1.21.x).
  6. Опис пакетів, блоків, предметів і мобів потрібної версії завантажується з minecraft-data
  7. (PrismarineJS) і кешується в папці mc_data_cache поруч зі скриптом.
  8. На сервері має бути: online-mode=false
  9. Режими:
  10. (без --smart) простий клієнт: заходить на сервер, відповідає на keepalive, шле позицію.
  11. Без фізики, без чанків, без "мозку".
  12. --smart повноцінний бот (потрібен SURVIVAL!): фізика й відкидання, A*-навігація з прориттям
  13. тунелів, добування блоків "затиснутою лівою кнопкою", дерево -> верстак -> дерев'яні,
  14. кам'яні, залізні інструменти (піч + вугілля), полювання на їжу й її споживання,
  15. втеча від кріперів, бої (мечем, якщо є), інвентар. Далі - вільна подорож і добування.
  16. Приклади:
  17. python mc_testbots.py --host 127.0.0.1 --count 5 --random-names
  18. python mc_testbots.py --count 3 --smart --random-names --reconnect-on-kick ^
  19. --cmd "/register {name}pass {name}pass" --cmd "/login {name}pass"
  20. python mc_testbots.py --list-versions
  21. """
  22. import argparse
  23. import bisect
  24. import hashlib
  25. import heapq
  26. import json
  27. import math
  28. import os
  29. import random
  30. import re
  31. import socket
  32. import struct
  33. import threading
  34. import time
  35. import traceback
  36. import urllib.request
  37. import uuid
  38. import zlib
  39. DATA_URL = "https://raw.githubusercontent.com/PrismarineJS/minecraft-data/master/data"
  40. CACHE_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)), "mc_data_cache")
  41. MIN_PROTOCOL = 764 # 1.20.2 - перша версія зі станом "configuration"
  42. HELP = """
  43. Команди в консолі:
  44. all <текст або /команда> - від імені всіх ботів
  45. <ім'я> <текст або /команда> - від імені одного бота (напр. Bot1 /gamemode survival)
  46. run - ще раз виконати стартові команди на всіх ботах
  47. list - список ботів, статус, координати, що тримає в руках
  48. inv <ім'я> - вміст інвентаря бота (smart)
  49. add <N> - додати ще N ботів
  50. kick <ім'я> - відключити бота (без автоперепідключення)
  51. log all|none|<ім'я> - чиї повідомлення чату/системи показувати
  52. quit - вимкнути всіх і вийти
  53. """
  54. # біти прапорців блоків
  55. SOLID, WATER, DANGER, AVOID = 1, 2, 4, 8
  56. NAME_ADJ = ["Swift", "Dark", "Happy", "Lazy", "Brave", "Silent", "Crazy", "Tiny", "Mighty", "Frosty",
  57. "Rusty", "Lucky", "Sneaky", "Cosmic", "Pixel", "Shadow", "Golden", "Wild", "Clever", "Gloomy"]
  58. NAME_NOUN = ["Fox", "Wolf", "Creeper", "Miner", "Panda", "Knight", "Ninja", "Builder", "Zombie", "Dragon",
  59. "Steve", "Alex", "Wizard", "Hunter", "Owl", "Tiger", "Cat", "Bear", "Raven", "Golem"]
  60. NEUTRAL_MOBS = {"enderman", "zombified_piglin", "bee", "iron_golem", "warden", "ender_dragon", "wither",
  61. "wolf", "llama", "panda", "polar_bear", "dolphin", "piglin"}
  62. DENY_TYPES = {"other", "projectile", "UNKNOWN", "unknown"}
  63. DENY_NAMES = {"item", "experience_orb", "armor_stand", "painting", "item_frame", "glow_item_frame",
  64. "leash_knot", "area_effect_cloud", "marker", "interaction", "text_display",
  65. "block_display", "item_display", "lightning_bolt", "end_crystal", "falling_block",
  66. "tnt", "fishing_bobber", "ominous_item_spawner", "evoker_fangs", "eye_of_ender",
  67. "firework_rocket"}
  68. FOOD_ANIMALS = {"chicken", "cow", "pig", "sheep", "rabbit", "mooshroom"}
  69. FOODS = ["cooked_beef", "cooked_porkchop", "cooked_mutton", "cooked_chicken", "cooked_rabbit",
  70. "cooked_salmon", "cooked_cod", "bread", "baked_potato", "golden_carrot", "apple", "carrot",
  71. "beef", "porkchop", "mutton", "rabbit", "potato", "chicken", "cod", "salmon", "melon_slice",
  72. "sweet_berries"]
  73. REL_MOVE = {"rel_entity_move", "entity_move_look", "move_entity_pos", "move_entity_pos_rot"}
  74. ABS_MOVE = {"entity_teleport", "entity_position_sync", "teleport_entity", "sync_entity_position"}
  75. CARD = ((1, 0), (-1, 0), (0, 1), (0, -1))
  76. DIAG = ((1, 1), (1, -1), (-1, 1), (-1, -1))
  77. TIER_SPEED = {"wooden": 2.0, "stone": 4.0, "iron": 6.0, "diamond": 8.0, "netherite": 9.0, "golden": 12.0}
  78. TIER_ORDER = ["netherite", "diamond", "iron", "stone", "wooden", "golden"]
  79. TOOL_RE = re.compile(r"^(wooden|stone|iron|golden|diamond|netherite)_(pickaxe|axe|shovel|hoe|sword)$")
  80. # групи предметів для рецептів
  81. GROUPS = {
  82. "log": lambda n: n.endswith("_log"),
  83. "planks": lambda n: n.endswith("_planks"),
  84. "cobble": lambda n: n in ("cobblestone", "cobbled_deepslate", "blackstone"),
  85. "stick": lambda n: n == "stick",
  86. "iron": lambda n: n == "iron_ingot",
  87. }
  88. MAT = {"wooden": "planks", "stone": "cobble", "iron": "iron"}
  89. TOOL_PATTERNS = {"pickaxe": ["MMM", " S ", " S "], "axe": ["MM ", "MS ", " S "],
  90. "sword": ["M", "M", "S"], "helmet": ["MMM", "M M"]}
  91. TIERS = [
  92. ("wooden", ["wooden_pickaxe", "wooden_axe", "wooden_sword"]),
  93. ("stone", ["stone_pickaxe", "stone_axe", "stone_sword"]),
  94. ("iron", ["iron_pickaxe", "iron_sword", "iron_axe", "iron_helmet"]),
  95. ]
  96. LOG_NAMES_RE = re.compile(r"_log$")
  97. def group_pred(g):
  98. return GROUPS.get(g) or (lambda n, g=g: n == g)
  99. def recipe(name):
  100. """-> (pattern, key, кількість на один крафт) або None."""
  101. if name == "planks":
  102. return ["L"], {"L": "log"}, 4
  103. if name == "stick":
  104. return ["P", "P"], {"P": "planks"}, 4
  105. if name == "crafting_table":
  106. return ["PP", "PP"], {"P": "planks"}, 1
  107. if name == "furnace":
  108. return ["CCC", "C C", "CCC"], {"C": "cobble"}, 1
  109. m = re.match(r"^(wooden|stone|iron)_(pickaxe|axe|sword|helmet)$", name)
  110. if m:
  111. return TOOL_PATTERNS[m.group(2)], {"M": MAT[m.group(1)], "S": "stick"}, 1
  112. return None
  113. def recipe_cost(name):
  114. pat, key, _ = recipe(name)
  115. cost = {}
  116. for row in pat:
  117. for ch in row:
  118. if ch != " ":
  119. cost[key[ch]] = cost.get(key[ch], 0) + 1
  120. return cost
  121. # ======================================================================
  122. # Дані версій (minecraft-data)
  123. # ======================================================================
  124. def fetch_json(rel, ttl=None):
  125. local = os.path.join(CACHE_DIR, rel.replace("/", "__"))
  126. if os.path.exists(local) and (ttl is None or time.time() - os.path.getmtime(local) < ttl):
  127. with open(local, encoding="utf-8") as f:
  128. return json.load(f)
  129. url = f"{DATA_URL}/{rel}"
  130. try:
  131. with urllib.request.urlopen(url, timeout=30) as r:
  132. raw = r.read()
  133. except Exception as e:
  134. if os.path.exists(local): # немає інтернету - беремо старий кеш
  135. with open(local, encoding="utf-8") as f:
  136. return json.load(f)
  137. raise SystemExit(f"Не вдалось завантажити {url}: {e}")
  138. os.makedirs(CACHE_DIR, exist_ok=True)
  139. with open(local, "wb") as f:
  140. f.write(raw)
  141. return json.loads(raw)
  142. def vkey(name):
  143. return tuple(int(x) for x in name.split("."))
  144. def is_release(name):
  145. return re.fullmatch(r"\d+(\.\d+)+", name) is not None
  146. def load_versions():
  147. dp = fetch_json("dataPaths.json", ttl=3 * 86400)["pc"]
  148. pv = fetch_json("pc/common/protocolVersions.json", ttl=3 * 86400)
  149. by_name = {x["minecraftVersion"]: x["version"] for x in pv}
  150. avail = {
  151. n: by_name[n]
  152. for n in dp
  153. if n in by_name and "protocol" in dp[n] and is_release(n) and by_name[n] >= MIN_PROTOCOL
  154. }
  155. return dp, avail
  156. def pick_version(arg, detected_protocol, avail):
  157. """Повертає назву версії з бази за --version, або за протоколом сервера."""
  158. if arg and not arg.isdigit():
  159. if arg in avail:
  160. return arg
  161. raise SystemExit(
  162. f"Версія '{arg}' не підтримується або не знайдена.\n"
  163. f"Доступні (1.20.2+): {', '.join(sorted(avail, key=vkey))}\n"
  164. f"Якщо щойно вийшла нова версія - видали папку {CACHE_DIR} і спробуй ще раз."
  165. )
  166. proto = int(arg) if arg else detected_protocol
  167. cands = [n for n, p in avail.items() if p == proto]
  168. if not cands:
  169. raise SystemExit(
  170. f"Протокол {proto} не знайдено в minecraft-data (підтримуються тільки 1.20.2+).\n"
  171. f"Якщо це нова версія - видали папку {CACHE_DIR} і спробуй ще раз."
  172. )
  173. return max(cands, key=vkey)
  174. # ======================================================================
  175. # Низькорівневі утиліти протоколу
  176. # ======================================================================
  177. def varint(n):
  178. n &= 0xFFFFFFFF
  179. out = bytearray()
  180. while True:
  181. b = n & 0x7F
  182. n >>= 7
  183. if n:
  184. out.append(b | 0x80)
  185. else:
  186. out.append(b)
  187. return bytes(out)
  188. def mcstr(s):
  189. b = s.encode("utf-8")
  190. return varint(len(b)) + b
  191. def read_varint(buf, off=0):
  192. result = shift = 0
  193. while True:
  194. b = buf[off]
  195. off += 1
  196. result |= (b & 0x7F) << shift
  197. if not b & 0x80:
  198. break
  199. shift += 7
  200. if shift > 35:
  201. raise ValueError("VarInt занадто довгий")
  202. if result & 0x80000000:
  203. result -= 1 << 32
  204. return result, off
  205. def read_varlong(buf, off=0):
  206. result = shift = 0
  207. while True:
  208. b = buf[off]
  209. off += 1
  210. result |= (b & 0x7F) << shift
  211. if not b & 0x80:
  212. break
  213. shift += 7
  214. if shift > 70:
  215. raise ValueError("VarLong занадто довгий")
  216. if result & (1 << 63):
  217. result -= 1 << 64
  218. return result, off
  219. def read_mcstr(buf, off=0):
  220. n, off = read_varint(buf, off)
  221. return buf[off:off + n].decode("utf-8", "replace"), off + n
  222. def read_lpvec3(b, off=0):
  223. """LpVec3 (швидкість сутності в 1.21.9+)."""
  224. i = b[off]
  225. if i == 0:
  226. return (0.0, 0.0, 0.0), off + 1
  227. j = b[off + 1]
  228. k = struct.unpack_from(">I", b, off + 2)[0]
  229. packed = (k << 16) | (j << 8) | i
  230. scale = i & 3
  231. off += 6
  232. if i & 4:
  233. v, off = read_varint(b, off)
  234. scale |= (v & 0xFFFFFFFF) << 2
  235. def u(n):
  236. return min(n & 32767, 32766) * 2.0 / 32766.0 - 1.0
  237. return (u(packed >> 3) * scale, u(packed >> 18) * scale, u(packed >> 33) * scale), off
  238. def offline_uuid(name):
  239. d = bytearray(hashlib.md5(("OfflinePlayer:" + name).encode("utf-8")).digest())
  240. d[6] = (d[6] & 0x0F) | 0x30
  241. d[8] = (d[8] & 0x3F) | 0x80
  242. return uuid.UUID(bytes=bytes(d))
  243. def random_name(used):
  244. while True:
  245. a, n, num = random.choice(NAME_ADJ), random.choice(NAME_NOUN), random.randint(1, 999)
  246. name = random.choice([f"{a}{n}{num}", f"{a}_{n}", f"{n}{num}", f"{a}{n}", f"{n}_{num}"])[:16]
  247. if name not in used:
  248. return name
  249. def wrap(a):
  250. return (a + 180.0) % 360.0 - 180.0
  251. # ---------- NBT / текстові компоненти ----------
  252. def _nbt_payload(buf, off, t):
  253. if t == 0:
  254. return None, off
  255. if t == 1:
  256. return struct.unpack_from(">b", buf, off)[0], off + 1
  257. if t == 2:
  258. return struct.unpack_from(">h", buf, off)[0], off + 2
  259. if t == 3:
  260. return struct.unpack_from(">i", buf, off)[0], off + 4
  261. if t == 4:
  262. return struct.unpack_from(">q", buf, off)[0], off + 8
  263. if t == 5:
  264. return struct.unpack_from(">f", buf, off)[0], off + 4
  265. if t == 6:
  266. return struct.unpack_from(">d", buf, off)[0], off + 8
  267. if t == 7:
  268. n = struct.unpack_from(">i", buf, off)[0]
  269. return None, off + 4 + n
  270. if t == 8:
  271. n = struct.unpack_from(">H", buf, off)[0]
  272. return buf[off + 2:off + 2 + n].decode("utf-8", "replace"), off + 2 + n
  273. if t == 9:
  274. et = buf[off]
  275. n = struct.unpack_from(">i", buf, off + 1)[0]
  276. off += 5
  277. items = []
  278. for _ in range(n):
  279. v, off = _nbt_payload(buf, off, et)
  280. items.append(v)
  281. return items, off
  282. if t == 10:
  283. d = {}
  284. while True:
  285. tt = buf[off]
  286. off += 1
  287. if tt == 0:
  288. return d, off
  289. n = struct.unpack_from(">H", buf, off)[0]
  290. key = buf[off + 2:off + 2 + n].decode("utf-8", "replace")
  291. off += 2 + n
  292. d[key], off = _nbt_payload(buf, off, tt)
  293. if t == 11:
  294. n = struct.unpack_from(">i", buf, off)[0]
  295. return None, off + 4 + 4 * n
  296. if t == 12:
  297. n = struct.unpack_from(">i", buf, off)[0]
  298. return None, off + 4 + 8 * n
  299. raise ValueError(f"невідомий NBT тег {t}")
  300. def read_anon_nbt(buf, off=0):
  301. t = buf[off]
  302. if t == 0:
  303. return None, off + 1
  304. return _nbt_payload(buf, off + 1, t)
  305. def read_named_nbt(buf, off=0):
  306. t = buf[off]
  307. if t == 0:
  308. return None, off + 1
  309. n = struct.unpack_from(">H", buf, off + 1)[0]
  310. return _nbt_payload(buf, off + 3 + n, t)
  311. def component_text(c):
  312. if c is None:
  313. return ""
  314. if isinstance(c, str):
  315. return c
  316. if isinstance(c, list):
  317. return "".join(component_text(x) for x in c)
  318. if isinstance(c, dict):
  319. s = c.get("text", "") if isinstance(c.get("text", ""), str) else ""
  320. if "translate" in c:
  321. s += str(c["translate"])
  322. if c.get("with"):
  323. s += "(" + ", ".join(component_text(x) for x in c["with"]) + ")"
  324. for e in c.get("extra", []) or []:
  325. s += component_text(e)
  326. return s
  327. return str(c)
  328. def clean(s):
  329. return re.sub("\u00a7.", "", s)
  330. # ======================================================================
  331. # Опис протоколу версії: ID пакетів, серіалізація і розбір за protocol.json
  332. # ======================================================================
  333. INTS = {"i8": ">b", "u8": ">B", "i16": ">h", "u16": ">H", "i32": ">i", "u32": ">I",
  334. "i64": ">q", "u64": ">Q", "f32": ">f", "f64": ">d"}
  335. class Protocol:
  336. def __init__(self, version, number, dp):
  337. self.version, self.number = version, number
  338. self.p = fetch_json(f"{dp[version]['protocol']}/protocol.json")
  339. self.ids = {} # (state, dir) -> ({name: id}, {id: name})
  340. self.alias = dict(self.p["types"])
  341. for st in ("handshaking", "status", "login", "configuration", "play"):
  342. for d in ("toServer", "toClient"):
  343. try:
  344. pk = self.p[st][d]["types"]["packet"][1]
  345. m = next(f for f in pk if f["name"] == "name")["type"][1]["mappings"]
  346. except (KeyError, StopIteration):
  347. m = {}
  348. n2i = {name: int(k, 16) for k, name in m.items()}
  349. self.ids[(st, d)] = (n2i, {v: k for k, v in n2i.items()})
  350. try: # локальні типи станів (крім самих пакетів) теж можуть бути аліасами
  351. for n, t in self.p[st][d]["types"].items():
  352. if not n.startswith("packet") and n not in self.alias:
  353. self.alias[n] = t
  354. except KeyError:
  355. pass
  356. def has(self, state, d, name):
  357. return name in self.ids[(state, d)][0]
  358. def name_of(self, state, pid):
  359. return self.ids[(state, "toClient")][1].get(pid)
  360. def packet_def(self, state, d, name):
  361. S = self.p[state][d]["types"]
  362. params = next(f for f in S["packet"][1] if f["name"] == "params")["type"][1]["fields"]
  363. t = params.get(name)
  364. if isinstance(t, str):
  365. t = S.get(t) or self.p["types"].get(t)
  366. return t
  367. def first_field(self, state, d, name):
  368. t = self.packet_def(state, d, name)
  369. if t and t[0] == "container" and t[1]:
  370. return t[1][0]
  371. return None
  372. def field_names(self, state, d, name):
  373. try:
  374. t = self.packet_def(state, d, name)
  375. except Exception:
  376. return []
  377. return [f["name"] for f in t[1]] if t and t[0] == "container" else []
  378. # ---------- серіалізація ----------
  379. def _alias(self, t):
  380. a = self.alias.get(t)
  381. return a if a not in (None, "native") else None
  382. def default(self, t):
  383. if isinstance(t, str):
  384. if t == "bool":
  385. return False
  386. if t in INTS or t in ("varint", "varlong"):
  387. return 0
  388. if t == "UUID":
  389. return uuid.UUID(int=0)
  390. a = self._alias(t)
  391. return self.default(a) if a else 0
  392. k, a = t
  393. if k == "container":
  394. return {f["name"]: self.default(f["type"]) for f in a}
  395. if k == "option":
  396. return None
  397. if k == "array":
  398. return []
  399. if k == "buffer":
  400. return b"\x00" * a["count"] if "count" in a else b""
  401. if k == "pstring":
  402. return ""
  403. return 0
  404. def enc(self, t, v, ctx=None):
  405. if isinstance(t, str):
  406. if t == "varint":
  407. return varint(v)
  408. if t == "bool":
  409. return b"\x01" if v else b"\x00"
  410. if t in INTS:
  411. return struct.pack(INTS[t], v)
  412. if t == "UUID":
  413. return (v if isinstance(v, uuid.UUID) else uuid.UUID(str(v))).bytes
  414. if t == "void":
  415. return b""
  416. if t == "restBuffer":
  417. return v
  418. a = self._alias(t)
  419. if a is None:
  420. raise ValueError(f"не підтримуваний тип {t}")
  421. return self.enc(a, v, ctx)
  422. k, a = t
  423. if k == "pstring":
  424. return mcstr(v)
  425. if k == "container":
  426. return b"".join(self.enc(f["type"], v.get(f["name"], self.default(f["type"])), v) for f in a)
  427. if k == "option":
  428. return b"\x00" if v is None else b"\x01" + self.enc(a, v, ctx)
  429. if k == "array":
  430. return varint(len(v)) + b"".join(self.enc(a["type"], x, ctx) for x in v)
  431. if k == "buffer":
  432. if "count" in a:
  433. return bytes(v)
  434. return varint(len(v)) + bytes(v)
  435. if k == "mapper":
  436. if isinstance(v, str):
  437. v = int(next(key for key, name in a["mappings"].items() if name == v))
  438. return self.enc(a["type"], v, ctx)
  439. if k == "switch":
  440. cv = (ctx or {}).get(a["compareTo"].split("/")[-1])
  441. if isinstance(cv, bool):
  442. cv = "true" if cv else "false"
  443. return self.enc(a["fields"].get(str(cv), a.get("default", "void")), v, ctx)
  444. if k == "bitflags":
  445. if isinstance(v, dict):
  446. v = sum(1 << i for i, n in enumerate(a["flags"]) if v.get(n))
  447. return self.enc(a["type"], int(v), ctx)
  448. if k == "bitfield": # напр. position {x:26, z:26, y:12}
  449. v = v if isinstance(v, dict) else {}
  450. total = sum(f["size"] for f in a)
  451. val, shift = 0, total
  452. for f in a:
  453. shift -= f["size"]
  454. val |= (int(v.get(f["name"], 0)) & ((1 << f["size"]) - 1)) << shift
  455. return val.to_bytes(total // 8, "big")
  456. raise ValueError(f"не підтримуваний тип {k}")
  457. def build(self, state, name, **values):
  458. pid = self.ids[(state, "toServer")][0][name]
  459. t = self.packet_def(state, "toServer", name)
  460. payload = self.enc(t, values) if t else b""
  461. return pid, payload
  462. # ---------- розбір пакетів (за protocol.json) ----------
  463. def dec(self, t, b, off, ctx=None):
  464. if isinstance(t, str):
  465. if t == "varint":
  466. return read_varint(b, off)
  467. if t == "varlong":
  468. return read_varlong(b, off)
  469. if t == "bool":
  470. return b[off] != 0, off + 1
  471. if t in INTS:
  472. f = INTS[t]
  473. return struct.unpack_from(f, b, off)[0], off + struct.calcsize(f)
  474. if t == "UUID":
  475. return uuid.UUID(bytes=bytes(b[off:off + 16])), off + 16
  476. if t == "void":
  477. return None, off
  478. if t == "restBuffer":
  479. return b[off:], len(b)
  480. if t in ("anonymousNbt", "anonOptionalNbt"):
  481. return read_anon_nbt(b, off)
  482. if t in ("nbt", "optionalNbt"):
  483. return read_named_nbt(b, off)
  484. a = self._alias(t)
  485. if a is None:
  486. raise ValueError(f"не підтримуваний тип {t}")
  487. return self.dec(a, b, off, ctx)
  488. k, a = t
  489. if k == "pstring":
  490. if "countType" in a:
  491. n, off = self.dec(a["countType"], b, off)
  492. else:
  493. n = a["count"]
  494. return bytes(b[off:off + n]).decode("utf-8", "replace"), off + n
  495. if k == "container":
  496. d = {}
  497. for f in a:
  498. v, off = self.dec(f["type"], b, off, d)
  499. if f.get("anon"):
  500. if isinstance(v, dict):
  501. d.update(v)
  502. else:
  503. d[f["name"]] = v
  504. return d, off
  505. if k == "array":
  506. if "countType" not in a:
  507. raise ValueError("array без countType")
  508. n, off = self.dec(a["countType"], b, off)
  509. out = []
  510. for _ in range(n):
  511. v, off = self.dec(a["type"], b, off, ctx)
  512. out.append(v)
  513. return out, off
  514. if k == "option":
  515. flag = b[off]
  516. off += 1
  517. if not flag:
  518. return None, off
  519. return self.dec(a, b, off, ctx)
  520. if k == "buffer":
  521. if "countType" in a:
  522. n, off = self.dec(a["countType"], b, off)
  523. else:
  524. n = a["count"]
  525. return bytes(b[off:off + n]), off + n
  526. if k == "mapper":
  527. return self.dec(a["type"], b, off, ctx)
  528. if k == "bitflags":
  529. return self.dec(a["type"], b, off, ctx)
  530. if k == "bitfield":
  531. total = sum(f["size"] for f in a)
  532. nb = total // 8
  533. val = int.from_bytes(b[off:off + nb], "big")
  534. out, shift = {}, total
  535. for f in a:
  536. shift -= f["size"]
  537. x = (val >> shift) & ((1 << f["size"]) - 1)
  538. if f.get("signed") and x >= 1 << (f["size"] - 1):
  539. x -= 1 << f["size"]
  540. out[f["name"]] = x
  541. return out, off + nb
  542. if k == "switch":
  543. cv = (ctx or {}).get(a["compareTo"].split("/")[-1])
  544. if cv is None:
  545. raise ValueError("switch: немає значення compareTo")
  546. if isinstance(cv, bool):
  547. cv = "true" if cv else "false"
  548. return self.dec(a["fields"].get(str(cv), a.get("default", "void")), b, off, ctx)
  549. raise ValueError(f"не підтримуваний тип {k}")
  550. def decode(self, state, name, payload, until=None):
  551. """Розбирає пакет toClient поле за полем. Що не вдалось розібрати - пропускає (повертає частину)."""
  552. try:
  553. t = self.packet_def(state, "toClient", name)
  554. except Exception:
  555. return {}
  556. d = {}
  557. if not t or t[0] != "container":
  558. return d
  559. off = 0
  560. for f in t[1]:
  561. try:
  562. v, off = self.dec(f["type"], payload, off, d)
  563. except Exception:
  564. break
  565. if f.get("anon"):
  566. if isinstance(v, dict):
  567. d.update(v)
  568. else:
  569. d[f["name"]] = v
  570. if until and f.get("name") == until:
  571. break
  572. return d
  573. # ======================================================================
  574. # Світ: блоки, предмети, чанки
  575. # ======================================================================
  576. AVOID_RE = re.compile(
  577. r"slab|stairs|fence|_wall$|carpet|trapdoor|_door$|pane$|bars$|_bed$|^snow$|cake|anvil|chest|"
  578. r"enchanting_table|hopper|cauldron|brewing_stand|lantern|candle|flower_pot|_head$|_skull$|"
  579. r"dripstone|scaffolding|ladder|vine|sea_pickle|turtle_egg|lectern|grindstone|stonecutter|composter|"
  580. r"end_portal|daylight_detector|conduit|azalea|dripleaf|honey_block|soul_sand|^mud$|farmland|dirt_path|"
  581. r"chain|amethyst_cluster|_bud$|end_rod|lightning_rod|^bell$|piston|sculk_sensor|sculk_shrieker|"
  582. r"ice|slime_block|rail|button|pressure_plate|lever|torch|sign|banner|bamboo|^cocoa$|repeater|"
  583. r"comparator|campfire|decorated_pot|beacon|end_gateway|heavy_core|vault|bed$|cobweb|powder_snow|"
  584. r"crafting_table|furnace|smoker|blast_furnace")
  585. class BlockInfo:
  586. """state id блоку -> прапорці, твердість, потрібний інструмент (за blocks.json)."""
  587. WATER_NAMES = {"water", "kelp", "kelp_plant", "seagrass", "tall_seagrass", "bubble_column"}
  588. DANGER_NAMES = {"lava", "fire", "soul_fire", "magma_block", "cactus", "campfire", "soul_campfire",
  589. "sweet_berry_bush", "wither_rose", "cobweb", "powder_snow", "pointed_dripstone"}
  590. NO_MINE = {"bedrock", "barrier", "command_block", "chain_command_block", "repeating_command_block",
  591. "structure_block", "jigsaw", "end_portal", "end_portal_frame", "end_gateway", "light",
  592. "reinforced_deepslate", "spawner", "trial_spawner", "vault", "obsidian", "crying_obsidian",
  593. "ancient_debris", "respawn_anchor", "enchanting_table"}
  594. def __init__(self, blocks):
  595. rng = []
  596. self.by_name = {}
  597. for b in blocks:
  598. n, fl = b["name"], 0
  599. if b.get("boundingBox") == "block":
  600. fl |= SOLID
  601. if n in self.WATER_NAMES:
  602. fl = WATER
  603. if n in self.DANGER_NAMES:
  604. fl |= DANGER
  605. if AVOID_RE.search(n):
  606. fl |= AVOID
  607. hard = b.get("hardness")
  608. hard = -1.0 if hard is None or n in self.NO_MINE else float(hard)
  609. mm = re.search(r"mineable/(\w+)", b.get("material", "") or "")
  610. ht = set(int(k) for k in b["harvestTools"]) if b.get("harvestTools") else None
  611. rng.append((b["minStateId"], b["maxStateId"], fl, hard, n, mm.group(1) if mm else None, ht))
  612. self.by_name[n] = (b["minStateId"], b["maxStateId"])
  613. rng.sort(key=lambda r: r[0])
  614. self.rng = rng
  615. self.starts = [r[0] for r in rng]
  616. self.memo = {}
  617. def _idx(self, s):
  618. i = bisect.bisect_right(self.starts, s) - 1
  619. return i if i >= 0 and self.rng[i][0] <= s <= self.rng[i][1] else -1
  620. def flags(self, s):
  621. f = self.memo.get(s)
  622. if f is None:
  623. i = self._idx(s)
  624. f = self.rng[i][2] if i >= 0 else 0
  625. self.memo[s] = f
  626. return f
  627. def name(self, s):
  628. i = self._idx(s)
  629. return self.rng[i][4] if i >= 0 else "air"
  630. def hardness(self, s):
  631. i = self._idx(s)
  632. return self.rng[i][3] if i >= 0 else -1.0
  633. def kind(self, s):
  634. i = self._idx(s)
  635. return self.rng[i][5] if i >= 0 else None
  636. def state_ids(self, names):
  637. out = set()
  638. for n in names:
  639. r = self.by_name.get(n)
  640. if r:
  641. out.update(range(r[0], r[1] + 1))
  642. return out
  643. def names_where(self, pred):
  644. return [n for n in self.by_name if pred(n)]
  645. def dig_ticks(self, s, held_name=None, held_id=None):
  646. """Скільки тіків ламати цей блок з даним предметом у руці (-1 - не можна)."""
  647. i = self._idx(s)
  648. if i < 0 or self.rng[i][3] < 0:
  649. return -1
  650. _, _, _, hard, _, kind, ht = self.rng[i]
  651. if hard == 0:
  652. return 1
  653. spd = 1.0
  654. mt = TOOL_RE.match(held_name or "")
  655. if mt and mt.group(2) == kind:
  656. spd = TIER_SPEED[mt.group(1)]
  657. harvest = ht is None or (held_id in ht)
  658. return max(1, int(math.ceil(hard * (30 if harvest else 100) / spd)))
  659. class ItemInfo:
  660. def __init__(self, items):
  661. self.by_id = {it["id"]: it["name"] for it in items}
  662. self.by_name = {it["name"]: it["id"] for it in items}
  663. def find_comp_map(obj):
  664. """Шукає в protocol.json відповідність id -> назва data-component (для розбору слотів 1.20.5+)."""
  665. if isinstance(obj, dict):
  666. mp = obj.get("mappings")
  667. if isinstance(mp, dict) and mp:
  668. names = {str(v).replace("minecraft:", "") for v in mp.values()}
  669. if "damage" in names and "max_damage" in names:
  670. out = {}
  671. for k, v in mp.items():
  672. try:
  673. out[int(k, 0)] = str(v).replace("minecraft:", "")
  674. except ValueError:
  675. pass
  676. return out
  677. for v in obj.values():
  678. r = find_comp_map(v)
  679. if r:
  680. return r
  681. elif isinstance(obj, list):
  682. for v in obj:
  683. r = find_comp_map(v)
  684. if r:
  685. return r
  686. return None
  687. def build_entities(entities):
  688. out = {}
  689. for e in entities:
  690. typ, cat, name = e.get("type", ""), e.get("category", ""), e["name"]
  691. out[e.get("internalId", e["id"])] = {
  692. "name": name,
  693. "h": e.get("height", 1.8),
  694. "hostile": (typ == "hostile" or cat.startswith("Hostile")) and name not in NEUTRAL_MOBS,
  695. "attack": typ not in DENY_TYPES and name not in DENY_NAMES,
  696. }
  697. return out
  698. CHUNK_FMT = {"len": None} # чи є префікс довжини в масивах paletted container (залежить від версії)
  699. def parse_sections(buf, with_len):
  700. off, secs = 0, []
  701. n = len(buf)
  702. while off < n:
  703. off += 2 # block_count
  704. bits = buf[off]
  705. off += 1
  706. single = pal = data_off = None
  707. if bits == 0:
  708. single, off = read_varint(buf, off)
  709. if with_len:
  710. ln, off = read_varint(buf, off)
  711. off += 8 * ln
  712. else:
  713. if bits <= 8:
  714. cnt, off = read_varint(buf, off)
  715. pal = []
  716. for _ in range(cnt):
  717. v, off = read_varint(buf, off)
  718. pal.append(v)
  719. nl = -(-4096 // (64 // bits))
  720. if with_len:
  721. ln, off = read_varint(buf, off)
  722. if ln != nl:
  723. raise ValueError("довжина масиву не збігається")
  724. data_off = off
  725. off += 8 * nl
  726. bb = buf[off]
  727. off += 1
  728. if bb == 0:
  729. _, off = read_varint(buf, off)
  730. if with_len:
  731. ln, off = read_varint(buf, off)
  732. off += 8 * ln
  733. else:
  734. if bb <= 3:
  735. cnt, off = read_varint(buf, off)
  736. for _ in range(cnt):
  737. _, off = read_varint(buf, off)
  738. nl = -(-64 // (64 // bb))
  739. if with_len:
  740. ln, off = read_varint(buf, off)
  741. if ln != nl:
  742. raise ValueError("довжина масиву біомів не збігається")
  743. off += 8 * nl
  744. if off > n:
  745. raise ValueError("вихід за межі буфера")
  746. secs.append((single, bits, pal, data_off))
  747. if off != n:
  748. raise ValueError("зайві байти в чанку")
  749. return secs
  750. class World:
  751. def __init__(self, binfo):
  752. self.b = binfo
  753. self.chunks = {} # (cx, cz) -> (buf, secs, min_y, overrides)
  754. self.failed = 0
  755. def load(self, cx, cz, buf):
  756. order = [True, False] if CHUNK_FMT["len"] is None else [CHUNK_FMT["len"]]
  757. for wl in order:
  758. try:
  759. secs = parse_sections(buf, wl)
  760. except Exception:
  761. continue
  762. CHUNK_FMT["len"] = wl
  763. self.chunks[(cx, cz)] = (buf, secs, -64 if len(secs) > 16 else 0, {})
  764. return True
  765. self.failed += 1
  766. return False
  767. def unload(self, cx, cz):
  768. self.chunks.pop((cx, cz), None)
  769. def has(self, x, z):
  770. return (math.floor(x) >> 4, math.floor(z) >> 4) in self.chunks
  771. def set_block(self, x, y, z, state):
  772. c = self.chunks.get((x >> 4, z >> 4))
  773. if c:
  774. c[3][(x, y, z)] = state
  775. def state_at(self, x, y, z):
  776. c = self.chunks.get((x >> 4, z >> 4))
  777. if c is None:
  778. return None
  779. buf, secs, min_y, ov = c
  780. if ov:
  781. s = ov.get((x, y, z))
  782. if s is not None:
  783. return s
  784. si = (y - min_y) >> 4
  785. if si < 0:
  786. return None
  787. if si >= len(secs):
  788. return 0
  789. single, bits, pal, off = secs[si]
  790. if single is not None:
  791. return single
  792. idx = ((y & 15) << 8) | ((z & 15) << 4) | (x & 15)
  793. li, sh = divmod(idx, 64 // bits)
  794. val = (struct.unpack_from(">Q", buf, off + 8 * li)[0] >> (sh * bits)) & ((1 << bits) - 1)
  795. return pal[val] if pal is not None else val
  796. def flags(self, x, y, z):
  797. s = self.state_at(x, y, z)
  798. if s is None:
  799. return SOLID # невідомий чанк/під світом - вважаємо стіною
  800. return self.b.flags(s)
  801. def collides(self, x, y, z):
  802. x0, x1 = math.floor(x - 0.3 + 1e-6), math.floor(x + 0.3 - 1e-6)
  803. z0, z1 = math.floor(z - 0.3 + 1e-6), math.floor(z + 0.3 - 1e-6)
  804. y0, y1 = math.floor(y + 1e-6), math.floor(y + 1.8 - 1e-6)
  805. for xx in range(x0, x1 + 1):
  806. for zz in range(z0, z1 + 1):
  807. for yy in range(y0, y1 + 1):
  808. if self.flags(xx, yy, zz) & SOLID:
  809. return True
  810. return False
  811. def find(self, ids, px, pz, limit=80):
  812. """Усі блоки зі state-id із множини ids у прогружених чанках (найближчі чанки першими)."""
  813. out = []
  814. items = sorted(self.chunks.items(),
  815. key=lambda kv: (kv[0][0] * 16 + 8 - px) ** 2 + (kv[0][1] * 16 + 8 - pz) ** 2)
  816. for (cx, cz), (buf, secs, min_y, ov) in items:
  817. for si, (single, bits, pal, off) in enumerate(secs):
  818. if single is not None:
  819. continue
  820. if pal is not None:
  821. tidx = {i for i, p in enumerate(pal) if p in ids}
  822. if not tidx:
  823. continue
  824. else:
  825. tidx = ids
  826. per = 64 // bits
  827. nl = -(-4096 // per)
  828. longs = struct.unpack_from(">%dQ" % nl, buf, off)
  829. mask = (1 << bits) - 1
  830. for idx in range(4096):
  831. if ((longs[idx // per] >> ((idx % per) * bits)) & mask) in tidx:
  832. out.append((cx * 16 + (idx & 15), min_y + si * 16 + (idx >> 8), cz * 16 + ((idx >> 4) & 15)))
  833. for (x, y, z), s in ov.items():
  834. if s in ids and x >> 4 == cx and z >> 4 == cz:
  835. out.append((x, y, z))
  836. if len(out) >= limit * 3:
  837. break
  838. res = []
  839. for c in set(out):
  840. s = self.state_at(*c)
  841. if s in ids:
  842. res.append(c)
  843. res.sort(key=lambda c: (c[0] + .5 - px) ** 2 + (c[2] + .5 - pz) ** 2)
  844. return res[:limit]
  845. # ======================================================================
  846. # З'єднання
  847. # ======================================================================
  848. class MCConnection:
  849. def __init__(self, host, port, timeout=60):
  850. self.sock = socket.create_connection((host, port), timeout=15)
  851. self.sock.settimeout(timeout)
  852. self.rf = self.sock.makefile("rb")
  853. self.lock = threading.Lock()
  854. self.threshold = -1
  855. def send(self, pid, payload=b""):
  856. body = varint(pid) + payload
  857. if self.threshold >= 0:
  858. if len(body) >= self.threshold:
  859. body = varint(len(body)) + zlib.compress(body)
  860. else:
  861. body = varint(0) + body
  862. with self.lock:
  863. self.sock.sendall(varint(len(body)) + body)
  864. def _read_varint(self):
  865. result = shift = 0
  866. while True:
  867. b = self.rf.read(1)
  868. if not b:
  869. raise EOFError("з'єднання закрите")
  870. result |= (b[0] & 0x7F) << shift
  871. if not b[0] & 0x80:
  872. return result
  873. shift += 7
  874. if shift > 35:
  875. raise ValueError("VarInt занадто довгий")
  876. def recv(self):
  877. length = self._read_varint()
  878. data = self.rf.read(length)
  879. if len(data) < length:
  880. raise EOFError("з'єднання закрите")
  881. if self.threshold >= 0:
  882. dl, off = read_varint(data, 0)
  883. data = zlib.decompress(data[off:]) if dl else data[off:]
  884. pid, off = read_varint(data, 0)
  885. return pid, data[off:]
  886. def close(self):
  887. try:
  888. self.sock.close()
  889. except Exception:
  890. pass
  891. def ping_server(host, port):
  892. """Status ping -> (protocol, назва версії)."""
  893. c = MCConnection(host, port, timeout=10)
  894. try:
  895. c.send(0, varint(-1) + mcstr(host) + struct.pack(">H", port) + varint(1))
  896. c.send(0)
  897. pid, payload = c.recv()
  898. data = json.loads(read_mcstr(payload)[0])
  899. return data["version"]["protocol"], data["version"].get("name", "?")
  900. finally:
  901. c.close()
  902. # ======================================================================
  903. # Бот: базовий клієнт + фізика + дії рівня тіків
  904. # ======================================================================
  905. REGISTERED_RE = re.compile(r"already regist|вже зареєстр|уже зарегистр|ya est[aá] registrad", re.I)
  906. 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 +X
  907. VARINT_COMPS = {"damage", "max_damage", "max_stack_size", "repair_cost", "map_id", "ominous_bottle_amplifier",
  908. "rarity", "map_post_processing"}
  909. EMPTY_COMPS = {"fire_resistant", "intangible_projectile", "creative_slot_lock", "glider", "unbreakable"}
  910. def find_key(d, key):
  911. if isinstance(d, dict):
  912. if key in d:
  913. return d[key]
  914. for v in d.values():
  915. r = find_key(v, key)
  916. if r is not None:
  917. return r
  918. return None
  919. class BotBase:
  920. def __init__(self, name, index, manager):
  921. self.name, self.index, self.m = name, index, manager
  922. self.pr = manager.proto
  923. self.quit_ev = threading.Event()
  924. self.registered = False
  925. self.session_no = 0
  926. self.status = "запуск"
  927. self.srv_uuid = offline_uuid(name)
  928. self.login_uuid = uuid.uuid4() if manager.random_uuid else self.srv_uuid
  929. self.plock = threading.RLock()
  930. sens = random.uniform(0.25, 1.0)
  931. self.rstep = ((sens * 0.6 + 0.2) ** 3) * 8 * 0.15 # крок "миші": усі повороти кратні йому
  932. fn = self.pr.field_names("play", "toServer", "player_input")
  933. self.new_input = bool(fn)
  934. self.input_field = ("" if "forward" in fn else fn[0]) if fn else None
  935. self.has_dig_pkt = self.pr.has("play", "toServer", "block_dig")
  936. self.c = None
  937. self.joined = False
  938. self.reset_session()
  939. def reset_session(self):
  940. self.state = "login"
  941. self.joined = False
  942. self.stop = threading.Event()
  943. self.loaded_sent = False
  944. self.loop_started = False
  945. self.ai_on = False
  946. self.eid = None
  947. self.health = 20.0
  948. self.food = 20
  949. self.dead = False
  950. self.gamemode = None
  951. self.world = World(self.m.binfo) if self.m.smart else None
  952. self.entities = {}
  953. self.x = self.y = self.z = None
  954. self.vx = self.vy = self.vz = 0.0
  955. self.yaw = self.pitch = 0.0
  956. self.on_ground = False
  957. self.hcol = False
  958. self.in_water = False
  959. self.sprinting = False
  960. self.lx = self.ly = self.lz = self.lyaw = self.lpitch = None
  961. self.reminder = 0
  962. self.spawn = None
  963. self.wait_ticks = 0
  964. self.last_input = -1
  965. self.seq = 0
  966. self.clock = 0.0
  967. self.tick_n = 0
  968. # камера
  969. self.yvel = self.pvel = 0.0
  970. self.yacc = self.pacc = 0.0
  971. self._turned = [False, False]
  972. self.look_next = 0.0
  973. self.look_yaw = self.look_pitch = 0.0
  974. # дії / мозок
  975. self.act = None
  976. self.act_res = None
  977. self.act_ev = threading.Event()
  978. self.bad_xz = {}
  979. self.stuck_t = 0
  980. self.stuck_pos = (0.0, 0.0)
  981. self.next_atk = 0.0
  982. # інвентар
  983. self.win = {}
  984. self.state_ids = {}
  985. self.cursor = None
  986. self.open_wid = None
  987. self.open_extra = 9
  988. self.inv_ev = threading.Event()
  989. self.ow_ev = threading.Event()
  990. self.held = 0
  991. self.brain_started = False
  992. # ---------- утиліти ----------
  993. def log(self, msg):
  994. print(f"[{self.name}] {msg}")
  995. def dbg(self, msg):
  996. if self.m.debug:
  997. self.log("DEBUG " + msg)
  998. def vlog(self, msg):
  999. if self.m.verbose:
  1000. self.log(msg)
  1001. def send(self, state, name, **values):
  1002. if not self.pr.has(state, "toServer", name):
  1003. return False
  1004. pid, payload = self.pr.build(state, name, **values)
  1005. self.c.send(pid, payload)
  1006. return True
  1007. def text_from(self, state, name, payload, off=0):
  1008. ff = self.pr.first_field(state, "toClient", name)
  1009. if ff and ff["type"] == "string":
  1010. s, _ = read_mcstr(payload, off)
  1011. try:
  1012. return clean(component_text(json.loads(s)))
  1013. except ValueError:
  1014. return clean(s)
  1015. comp, _ = read_anon_nbt(payload, off)
  1016. return clean(component_text(comp))
  1017. # ---------- сесія та перепідключення ----------
  1018. def run(self):
  1019. m = self.m
  1020. fails = 0
  1021. while True:
  1022. self.session_no += 1
  1023. t0 = time.time()
  1024. self.session()
  1025. if self.quit_ev.is_set() or not m.reconnect:
  1026. break
  1027. if m.max_reconnects and self.session_no > m.max_reconnects:
  1028. self.log("досягнуто ліміт перепідключень")
  1029. break
  1030. fails = fails + 1 if time.time() - t0 < 15 else 0
  1031. delay = min(m.reconnect_delay * (2 ** fails), 120)
  1032. self.status = f"перепідключення через {delay:.0f}с"
  1033. self.log(f"перепідключення через {delay:.0f}с (спроба {self.session_no})")
  1034. if self.quit_ev.wait(delay):
  1035. break
  1036. self.status = "відключений"
  1037. def session(self):
  1038. m = self.m
  1039. self.reset_session()
  1040. self.status = "підключення"
  1041. try:
  1042. self.c = MCConnection(m.host, m.port)
  1043. self.send("handshaking", "set_protocol", protocolVersion=self.pr.number,
  1044. serverHost=m.host, serverPort=m.port, nextState=2)
  1045. self.send("login", "login_start", username=self.name, playerUUID=self.login_uuid)
  1046. while not self.stop.is_set():
  1047. pid, payload = self.c.recv()
  1048. name = self.pr.name_of(self.state, pid)
  1049. self.dbg(f"{self.state}: {name or hex(pid)}")
  1050. if name:
  1051. try:
  1052. self.handle(name, payload)
  1053. except (EOFError, OSError):
  1054. raise
  1055. except Exception as e:
  1056. self.dbg(f"пакет {name}: {type(e).__name__}: {e}")
  1057. except (EOFError, ConnectionError, socket.timeout, OSError) as e:
  1058. if not self.stop.is_set():
  1059. self.log(f"з'єднання втрачено: {e}")
  1060. except Exception as e:
  1061. self.log(f"помилка: {type(e).__name__}: {e}")
  1062. finally:
  1063. self.joined = False
  1064. self.stop.set()
  1065. self.act_ev.set()
  1066. self.inv_ev.set()
  1067. self.ow_ev.set()
  1068. if self.c:
  1069. self.c.close()
  1070. # ---------- обробка пакетів ----------
  1071. def handle(self, name, p):
  1072. st = self.state
  1073. if name in ("disconnect", "kick_disconnect"):
  1074. if st == "login":
  1075. try:
  1076. s = clean(component_text(json.loads(read_mcstr(p)[0])))
  1077. except ValueError:
  1078. s = read_mcstr(p)[0]
  1079. else:
  1080. s = self.text_from(st, name, p)
  1081. self.log(f"сервер відключив: {s}")
  1082. self.stop.set()
  1083. return
  1084. if name == "keep_alive":
  1085. self.send(st, "keep_alive", keepAliveId=struct.unpack(">q", p[:8])[0])
  1086. return
  1087. if name == "ping":
  1088. self.send(st, "pong", id=struct.unpack(">i", p[:4])[0])
  1089. return
  1090. if name in ("add_resource_pack", "resource_pack_send"):
  1091. self.resource_pack(st, p)
  1092. return
  1093. if name == "cookie_request":
  1094. key, _ = read_mcstr(p)
  1095. self.send(st, "cookie_response", key=key, value=None)
  1096. return
  1097. if name == "custom_payload":
  1098. return
  1099. if st == "login":
  1100. if name == "compress":
  1101. self.c.threshold = read_varint(p)[0]
  1102. elif name == "encryption_begin":
  1103. self.log("сервер вимагає шифрування (online-mode=true). Постав online-mode=false.")
  1104. self.stop.set()
  1105. self.quit_ev.set()
  1106. elif name == "login_plugin_request":
  1107. self.send("login", "login_plugin_response", messageId=read_varint(p)[0], data=None)
  1108. elif name == "success":
  1109. self.send("login", "login_acknowledged")
  1110. self.state = "configuration"
  1111. self.send("configuration", "custom_payload", channel="minecraft:brand", data=mcstr("vanilla"))
  1112. self.send("configuration", "settings", locale="en_us", viewDistance=self.m.view_distance,
  1113. chatFlags=0, chatColors=True, skinParts=127, mainHand=1,
  1114. enableTextFiltering=False, enableServerListing=True, particleStatus="minimal")
  1115. return
  1116. if st == "configuration":
  1117. if name == "select_known_packs":
  1118. self.send("configuration", "select_known_packs", packs=[])
  1119. elif name == "code_of_conduct":
  1120. self.send("configuration", "accept_code_of_conduct")
  1121. elif name == "finish_configuration":
  1122. self.send("configuration", "finish_configuration")
  1123. self.state = "play"
  1124. return
  1125. if st == "play":
  1126. self.handle_play(name, p)
  1127. def handle_play(self, name, p):
  1128. m = self.m
  1129. if name == "login":
  1130. d = self.pr.decode("play", "login", p)
  1131. self.eid = d.get("entityId")
  1132. gm = find_key(d, "gameMode")
  1133. if isinstance(gm, int):
  1134. self.gamemode = gm
  1135. if not self.joined:
  1136. self.joined = True
  1137. self.status = "онлайн"
  1138. self.log("зайшов на сервер")
  1139. threading.Thread(target=self.startup_routine, args=(self.stop,), daemon=True).start()
  1140. if not self.loop_started:
  1141. self.loop_started = True
  1142. threading.Thread(target=self.keepalive_loop, args=(self.stop,), daemon=True).start()
  1143. elif name == "position":
  1144. self.on_position(p)
  1145. elif name == "start_configuration":
  1146. self.send("play", "configuration_acknowledged")
  1147. self.state = "configuration"
  1148. elif name == "update_health":
  1149. self.health = struct.unpack(">f", p[:4])[0]
  1150. if len(p) >= 5:
  1151. try:
  1152. self.food = read_varint(p, 4)[0]
  1153. except Exception:
  1154. pass
  1155. if self.health <= 0:
  1156. if not self.dead:
  1157. self.dead = True
  1158. self.cancel_act_raw("dead")
  1159. self.send("play", "client_command", actionId="perform_respawn")
  1160. else:
  1161. self.dead = False
  1162. elif name == "game_state_change":
  1163. if len(p) >= 5 and p[0] == 3:
  1164. self.gamemode = int(struct.unpack(">f", p[1:5])[0])
  1165. elif name == "chunk_batch_finished":
  1166. self.send("play", "chunk_batch_received", chunksPerTick=20.0)
  1167. elif name == "system_chat":
  1168. if m.should_log(self.name) or m.no_register_on_reconnect:
  1169. text = self.text_from("play", "system_chat", p)
  1170. if m.should_log(self.name):
  1171. self.log("чат: " + text)
  1172. if REGISTERED_RE.search(text):
  1173. self.registered = True
  1174. elif name == "player_chat":
  1175. if m.should_log(self.name):
  1176. off = 0
  1177. ff = self.pr.first_field("play", "toClient", "player_chat")
  1178. if ff and ff["name"] == "globalIndex":
  1179. _, off = read_varint(p, off)
  1180. sender = uuid.UUID(bytes=p[off:off + 16])
  1181. off += 16
  1182. _, off = read_varint(p, off)
  1183. if p[off]:
  1184. off += 256
  1185. off += 1
  1186. msg, _ = read_mcstr(p, off)
  1187. who = m.name_by_uuid.get(sender, str(sender)[:8])
  1188. self.log(f"чат <{who}> {clean(msg)}")
  1189. elif m.smart and self.world is not None:
  1190. self.handle_world(name, p)
  1191. # ---------- інвентар (розбір слотів) ----------
  1192. def read_wid(self, p, off=0):
  1193. if self.pr.number >= 768:
  1194. return read_varint(p, off)
  1195. return struct.unpack_from(">b", p, off)[0], off + 1
  1196. def read_slot(self, b, off):
  1197. m = self.m
  1198. if self.pr.number < 766:
  1199. if not b[off]:
  1200. return None, off + 1
  1201. iid, o = read_varint(b, off + 1)
  1202. cnt = struct.unpack_from(">b", b, o)[0]
  1203. nbt, o = read_anon_nbt(b, o + 1)
  1204. dmg = nbt.get("Damage", 0) if isinstance(nbt, dict) else 0
  1205. return {"id": iid, "name": m.items.by_id.get(iid, "?"), "count": cnt, "damage": dmg}, o
  1206. cnt, o = read_varint(b, off)
  1207. if cnt <= 0:
  1208. return None, o
  1209. iid, o = read_varint(b, o)
  1210. nadd, o = read_varint(b, o)
  1211. nrem, o = read_varint(b, o)
  1212. dmg = 0
  1213. for _ in range(nadd):
  1214. cid, o = read_varint(b, o)
  1215. cn = m.comp_names.get(cid)
  1216. if cn in VARINT_COMPS:
  1217. v, o = read_varint(b, o)
  1218. if cn == "damage":
  1219. dmg = v
  1220. elif cn == "enchantment_glint_override":
  1221. o += 1
  1222. elif cn in ("custom_name", "item_name"):
  1223. _, o = read_anon_nbt(b, o)
  1224. elif cn in EMPTY_COMPS:
  1225. pass
  1226. else:
  1227. raise ValueError(f"невідомий компонент предмета {cn or cid}")
  1228. for _ in range(nrem):
  1229. _, o = read_varint(b, o)
  1230. return {"id": iid, "name": m.items.by_id.get(iid, "?"), "count": cnt, "damage": dmg}, o
  1231. def on_window_items(self, p):
  1232. wid, o = self.read_wid(p)
  1233. sid, o = read_varint(p, o)
  1234. n, o = read_varint(p, o)
  1235. slots = []
  1236. try:
  1237. for _ in range(n):
  1238. s, o = self.read_slot(p, o)
  1239. slots.append(s)
  1240. except Exception as e:
  1241. self.dbg(f"window_items: {e}")
  1242. slots += [None] * (n - len(slots))
  1243. try:
  1244. cur, o = self.read_slot(p, o)
  1245. except Exception:
  1246. cur = None
  1247. self.win[wid] = slots
  1248. self.state_ids[wid] = sid
  1249. self.cursor = cur
  1250. self.inv_ev.set()
  1251. def on_set_slot(self, p):
  1252. wid, o = self.read_wid(p)
  1253. sid, o = read_varint(p, o)
  1254. slot = struct.unpack_from(">h", p, o)[0]
  1255. try:
  1256. it, _ = self.read_slot(p, o + 2)
  1257. except Exception as e:
  1258. self.dbg(f"set_slot: {e}")
  1259. it = None
  1260. if wid == -1:
  1261. self.cursor = it
  1262. elif wid == -2:
  1263. pass
  1264. else:
  1265. lst = self.win.setdefault(wid, [])
  1266. while len(lst) <= slot:
  1267. lst.append(None)
  1268. if slot >= 0:
  1269. lst[slot] = it
  1270. self.state_ids[wid] = sid
  1271. self.inv_ev.set()
  1272. def click(self, wid, slot, button=0, mode=0, wait=0.25):
  1273. sid = self.state_ids.get(wid, 0)
  1274. pid = self.pr.ids[("play", "toServer")][0].get("window_click")
  1275. if pid is None:
  1276. return
  1277. payload = (varint(wid) + varint(sid) + struct.pack(">h", slot) + struct.pack(">b", button)
  1278. + varint(mode) + varint(0) + b"\x00")
  1279. self.inv_ev.clear()
  1280. self.c.send(pid, payload)
  1281. self.inv_ev.wait(wait)
  1282. time.sleep(0.07)
  1283. # ---------- світ / сутності ----------
  1284. def handle_world(self, name, p):
  1285. w, pr = self.world, self.pr
  1286. if name == "map_chunk":
  1287. d = pr.decode("play", name, p, until="chunkData")
  1288. if "chunkData" in d and "x" in d:
  1289. if not w.load(d["x"], d["z"], d["chunkData"]) and w.failed == 1:
  1290. self.log("не вдалось розібрати чанк - формат цієї версії невідомий")
  1291. elif name == "unload_chunk":
  1292. d = pr.decode("play", name, p)
  1293. if "chunkX" in d:
  1294. w.unload(d["chunkX"], d["chunkZ"])
  1295. elif name == "block_change":
  1296. d = pr.decode("play", name, p)
  1297. loc = d.get("location")
  1298. if loc and "type" in d:
  1299. w.set_block(loc["x"], loc["y"], loc["z"], d["type"])
  1300. elif name == "multi_block_change":
  1301. d = pr.decode("play", name, p)
  1302. cc = d.get("chunkCoordinates")
  1303. if cc and d.get("records"):
  1304. for v in d["records"]:
  1305. w.set_block(cc["x"] * 16 + ((v >> 8) & 15), cc["y"] * 16 + (v & 15),
  1306. cc["z"] * 16 + ((v >> 4) & 15), v >> 12)
  1307. elif name == "spawn_entity":
  1308. d = pr.decode("play", name, p)
  1309. info = self.m.ents.get(d.get("type"))
  1310. if info and "x" in d and "entityId" in d:
  1311. u = next((v for v in d.values() if isinstance(v, uuid.UUID)), None)
  1312. self.entities[d["entityId"]] = dict(info, id=d["entityId"], uuid=u, x=d["x"], y=d["y"], z=d["z"])
  1313. elif name == "entity_destroy":
  1314. for i in pr.decode("play", name, p).get("entityIds", []):
  1315. self.entities.pop(i, None)
  1316. elif name == "collect":
  1317. i = pr.decode("play", name, p).get("collectedEntityId")
  1318. self.entities.pop(i, None)
  1319. elif name in REL_MOVE:
  1320. d = pr.decode("play", name, p)
  1321. e = self.entities.get(d.get("entityId"))
  1322. if e and "dX" in d:
  1323. e["x"] += d["dX"] / 4096.0
  1324. e["y"] += d["dY"] / 4096.0
  1325. e["z"] += d["dZ"] / 4096.0
  1326. elif name in ABS_MOVE:
  1327. d = pr.decode("play", name, p)
  1328. e = self.entities.get(d.get("entityId"))
  1329. if e and "x" in d and "z" in d:
  1330. e["x"], e["y"], e["z"] = d["x"], d["y"], d["z"]
  1331. elif name == "entity_velocity": # відкидання
  1332. eid, off = read_varint(p, 0)
  1333. if eid == self.eid:
  1334. if len(p) - off == 6:
  1335. vx, vy, vz = struct.unpack_from(">hhh", p, off)
  1336. v = (vx / 8000.0, vy / 8000.0, vz / 8000.0)
  1337. else:
  1338. v, _ = read_lpvec3(p, off)
  1339. with self.plock:
  1340. self.vx, self.vy, self.vz = v
  1341. elif name == "window_items":
  1342. self.on_window_items(p)
  1343. elif name == "set_slot":
  1344. self.on_set_slot(p)
  1345. elif name == "open_window":
  1346. d = pr.decode("play", name, p)
  1347. if "windowId" in d:
  1348. self.open_wid = d["windowId"]
  1349. self.ow_ev.set()
  1350. elif name == "close_window":
  1351. wid, _ = self.read_wid(p)
  1352. if wid == self.open_wid:
  1353. self.open_wid = None
  1354. def on_position(self, p):
  1355. d = self.pr.decode("play", "position", p)
  1356. tid = d.get("teleportId")
  1357. if tid is None:
  1358. ff = self.pr.first_field("play", "toClient", "position")
  1359. tid = read_varint(p, 0)[0] if ff["name"] == "teleportId" else read_varint(p, 33)[0]
  1360. if "x" in d and "z" in d:
  1361. fl = d.get("flags") or 0
  1362. if not isinstance(fl, int):
  1363. fl = 0
  1364. with self.plock:
  1365. self.x = (self.x or 0.0) + d["x"] if fl & 1 else d["x"]
  1366. self.y = (self.y or 0.0) + d["y"] if fl & 2 else d["y"]
  1367. self.z = (self.z or 0.0) + d["z"] if fl & 4 else d["z"]
  1368. self.yaw = wrap(self.yaw + d["yaw"]) if fl & 8 else d["yaw"]
  1369. self.pitch = self.pitch + d["pitch"] if fl & 16 else d["pitch"]
  1370. self.vx, self.vy, self.vz = d.get("dx", 0.0), d.get("dy", 0.0), d.get("dz", 0.0)
  1371. self.on_ground = False
  1372. self.lx, self.ly, self.lz, self.lyaw, self.lpitch = self.x, self.y, self.z, self.yaw, self.pitch
  1373. self.reminder = 0
  1374. self.yvel = self.pvel = 0.0
  1375. self.dead = False
  1376. self.cancel_act_raw("teleport")
  1377. if self.spawn is None:
  1378. self.spawn = (self.x, self.z)
  1379. self.send("play", "teleport_confirm", teleportId=tid)
  1380. if self.x is not None:
  1381. self.send("play", "position_look", x=self.x, y=self.y, z=self.z, yaw=self.yaw,
  1382. pitch=self.pitch, onGround=False, flags=0)
  1383. if not self.loaded_sent and not (self.m.smart and self.world is not None):
  1384. self.loaded_sent = True
  1385. self.send("play", "player_loaded")
  1386. def resource_pack(self, st, p):
  1387. fields = self.pr.field_names(st, "toServer", "resource_pack_receive")
  1388. extra = {"uuid": uuid.UUID(bytes=p[:16])} if "uuid" in fields else {}
  1389. for result in (3, 0):
  1390. self.send(st, "resource_pack_receive", result=result, **extra)
  1391. # ---------- цикл тіків ----------
  1392. def keepalive_loop(self, stop):
  1393. nxt = time.time()
  1394. while not stop.is_set():
  1395. nxt += 0.05
  1396. try:
  1397. if self.state == "play" and self.joined and self.x is not None:
  1398. self.tick()
  1399. except OSError:
  1400. return
  1401. except Exception as e:
  1402. self.dbg(f"tick: {type(e).__name__}: {e}")
  1403. if self.m.debug:
  1404. traceback.print_exc()
  1405. d = nxt - time.time()
  1406. if d > 0:
  1407. stop.wait(d)
  1408. elif d < -1:
  1409. nxt = time.time()
  1410. def tick(self):
  1411. with self.plock:
  1412. w = self.world
  1413. if self.m.smart and w is not None:
  1414. if w.has(self.x, self.z):
  1415. self.wait_ticks = 0
  1416. if not self.loaded_sent:
  1417. self.loaded_sent = True
  1418. self.send("play", "player_loaded")
  1419. fwd = jump = spr = False
  1420. self._turned = [False, False]
  1421. if self.ai_on and not self.dead:
  1422. fwd, jump, spr = self.run_action()
  1423. if not self._turned[0]:
  1424. self.yvel *= 0.5
  1425. if not self._turned[1]:
  1426. self.pvel *= 0.5
  1427. spr = bool(spr and fwd and self.food > 6)
  1428. self.set_sprint(spr)
  1429. self.send_input(fwd, jump, spr)
  1430. self.physics(fwd, jump)
  1431. else:
  1432. self.wait_ticks += 1
  1433. if self.wait_ticks < 100:
  1434. return
  1435. if not self.loaded_sent:
  1436. self.loaded_sent = True
  1437. self.send("play", "player_loaded")
  1438. self.on_ground = True
  1439. else:
  1440. self.on_ground = True # простий клієнт: просто "стоїть"
  1441. self.send_position()
  1442. self.send("play", "tick_end")
  1443. def set_sprint(self, flag):
  1444. if flag == self.sprinting:
  1445. return
  1446. self.sprinting = flag
  1447. start, stop = (1, 2) if self.new_input else (3, 4)
  1448. self.send("play", "entity_action", entityId=self.eid or 0, actionId=start if flag else stop, jumpBoost=0)
  1449. def send_input(self, fwd, jump, spr):
  1450. if self.input_field is None:
  1451. return
  1452. val = (1 if fwd else 0) | (2 if jump else 0) | (4 if spr else 0)
  1453. if val == self.last_input:
  1454. return
  1455. self.last_input = val
  1456. flags = {"forward": bool(fwd), "jump": bool(jump), "sprint": bool(spr)}
  1457. if self.input_field == "":
  1458. self.send("play", "player_input", **flags)
  1459. else:
  1460. self.send("play", "player_input", **{self.input_field: flags})
  1461. def send_position(self):
  1462. fl = (1 if self.on_ground else 0) | (2 if self.hcol else 0)
  1463. self.reminder += 1
  1464. moved = (self.x - self.lx) ** 2 + (self.y - self.ly) ** 2 + (self.z - self.lz) ** 2 > 4e-8 \
  1465. or self.reminder >= 20
  1466. rot = self.yaw != self.lyaw or self.pitch != self.lpitch
  1467. og = self.on_ground
  1468. if moved and rot:
  1469. self.send("play", "position_look", x=self.x, y=self.y, z=self.z, yaw=self.yaw,
  1470. pitch=self.pitch, onGround=og, flags=fl)
  1471. elif moved:
  1472. self.send("play", "position", x=self.x, y=self.y, z=self.z, onGround=og, flags=fl)
  1473. elif rot:
  1474. self.send("play", "look", yaw=self.yaw, pitch=self.pitch, onGround=og, flags=fl)
  1475. else:
  1476. self.send("play", "flying", onGround=og, flags=fl)
  1477. if moved:
  1478. self.reminder = 0
  1479. self.lx, self.ly, self.lz = self.x, self.y, self.z
  1480. self.lyaw, self.lpitch = self.yaw, self.pitch
  1481. # ---------- фізика ----------
  1482. def axis(self, ax, d):
  1483. if d == 0:
  1484. return
  1485. w = self.world
  1486. n = int(abs(d) / 0.4) + 1
  1487. s = d / n
  1488. for _ in range(n):
  1489. x, y, z = self.x, self.y, self.z
  1490. if ax == 0:
  1491. x += s
  1492. elif ax == 1:
  1493. y += s
  1494. else:
  1495. z += s
  1496. if w.collides(x, y, z):
  1497. if ax == 1:
  1498. if s < 0:
  1499. self.y = math.floor(y + 1e-9) + 1.0
  1500. self.on_ground = True
  1501. else:
  1502. self.y = math.floor(y + 1.8) - 1.8 - 1e-4
  1503. self.vy = 0.0
  1504. elif ax == 0:
  1505. self.x = (math.floor(x + 0.3) - 0.3 - 1e-4) if s > 0 else (math.floor(x - 0.3) + 1.3 + 1e-4)
  1506. self.vx = 0.0
  1507. self.hcol = True
  1508. else:
  1509. self.z = (math.floor(z + 0.3) - 0.3 - 1e-4) if s > 0 else (math.floor(z - 0.3) + 1.3 + 1e-4)
  1510. self.vz = 0.0
  1511. self.hcol = True
  1512. return
  1513. self.x, self.y, self.z = x, y, z
  1514. def physics(self, fwd, jump):
  1515. w = self.world
  1516. self.in_water = bool(w.flags(math.floor(self.x), math.floor(self.y + 0.4), math.floor(self.z)) & WATER)
  1517. was_ground = self.on_ground
  1518. for a in ("vx", "vy", "vz"):
  1519. if abs(getattr(self, a)) < 0.003:
  1520. setattr(self, a, 0.0)
  1521. if jump:
  1522. if self.in_water:
  1523. self.vy += 0.04
  1524. elif was_ground:
  1525. self.vy = 0.42
  1526. if self.sprinting and fwd:
  1527. r = math.radians(self.yaw)
  1528. self.vx += -math.sin(r) * 0.2
  1529. self.vz += math.cos(r) * 0.2
  1530. if self.in_water:
  1531. acc, fric = 0.02, 0.8
  1532. elif was_ground:
  1533. acc, fric = 0.1, 0.546
  1534. else:
  1535. acc, fric = 0.02, 0.91
  1536. if fwd:
  1537. r = math.radians(self.yaw)
  1538. k = acc * 0.98 * (1.3 if self.sprinting else 1.0)
  1539. self.vx += -math.sin(r) * k
  1540. self.vz += math.cos(r) * k
  1541. self.hcol = False
  1542. self.on_ground = False
  1543. self.axis(1, self.vy)
  1544. self.axis(0, self.vx)
  1545. self.axis(2, self.vz)
  1546. self.vy = self.vy * 0.8 - 0.02 if self.in_water else (self.vy - 0.08) * 0.98
  1547. if self.in_water and self.hcol and fwd:
  1548. self.vy = 0.3
  1549. self.vx *= fric
  1550. self.vz *= fric
  1551. # ---------- камера: плавний розгін/гальмування, кроки кратні "миші" ----------
  1552. def _smooth(self, d, vel, vmax, acc):
  1553. if abs(d) < self.rstep * 0.6 and abs(vel) < 1.0:
  1554. return 0.0
  1555. des = math.copysign(min(vmax, math.sqrt(2 * acc * abs(d))), d)
  1556. return vel + max(-acc, min(acc, des - vel))
  1557. def turn(self, goal, vmax=25.0, acc=3.0):
  1558. self._turned[0] = True
  1559. d = wrap(goal - self.yaw)
  1560. self.yvel = self._smooth(d, self.yvel, vmax, acc)
  1561. if self.yvel == 0.0:
  1562. self.yacc = 0.0
  1563. return
  1564. self.yacc += self.yvel
  1565. k = int(round(self.yacc / self.rstep))
  1566. if k:
  1567. self.yaw = wrap(self.yaw + k * self.rstep)
  1568. self.yacc -= k * self.rstep
  1569. def turn_pitch(self, goal, vmax=15.0, acc=2.0):
  1570. self._turned[1] = True
  1571. goal = max(-80.0, min(80.0, goal))
  1572. d = goal - self.pitch
  1573. self.pvel = self._smooth(d, self.pvel, vmax, acc)
  1574. if self.pvel == 0.0:
  1575. self.pacc = 0.0
  1576. return
  1577. self.pacc += self.pvel
  1578. k = int(round(self.pacc / self.rstep))
  1579. if k:
  1580. self.pitch = max(-89.9, min(89.9, self.pitch + k * self.rstep))
  1581. self.pacc -= k * self.rstep
  1582. def idle_look(self):
  1583. if self.clock >= self.look_next:
  1584. self.look_yaw = self.yaw + random.uniform(-45, 45)
  1585. self.look_pitch = random.uniform(-12, 18)
  1586. self.look_next = self.clock + random.uniform(1.0, 3.5)
  1587. self.turn(self.look_yaw, 6.0, 0.8)
  1588. self.turn_pitch(self.look_pitch, 4.0, 0.6)
  1589. # ---------- геометрія ----------
  1590. def eye(self):
  1591. return (self.x, self.y + 1.62, self.z)
  1592. def angles_to(self, pt):
  1593. ex, ey, ez = self.eye()
  1594. dx, dy, dz = pt[0] - ex, pt[1] - ey, pt[2] - ez
  1595. hd = math.hypot(dx, dz)
  1596. return math.degrees(math.atan2(-dx, dz)), -math.degrees(math.atan2(dy, max(hd, 1e-6)))
  1597. def ray_hits(self, eye, pt, pos, F):
  1598. dx, dy, dz = pt[0] - eye[0], pt[1] - eye[1], pt[2] - eye[2]
  1599. n = int(math.sqrt(dx * dx + dy * dy + dz * dz) / 0.1) + 1
  1600. for i in range(1, n + 1):
  1601. f = i / n
  1602. c = (math.floor(eye[0] + dx * f), math.floor(eye[1] + dy * f), math.floor(eye[2] + dz * f))
  1603. if c == pos:
  1604. return True
  1605. if F(*c) & SOLID:
  1606. return False
  1607. return False
  1608. def visible_face(self, pos, eye=None, F=None):
  1609. """-> (грань, точка прицілу, курсор) або None."""
  1610. eye = eye or self.eye()
  1611. F = F or self.world.flags
  1612. c = (pos[0] + .5, pos[1] + .5, pos[2] + .5)
  1613. best = None
  1614. for f, (nx, ny, nz) in enumerate(FACES):
  1615. if (eye[0] - c[0]) * nx + (eye[1] - c[1]) * ny + (eye[2] - c[2]) * nz <= 0.5:
  1616. continue
  1617. ip = (c[0] + nx * .47, c[1] + ny * .47, c[2] + nz * .47)
  1618. if self.ray_hits(eye, ip, pos, F):
  1619. d = (ip[0] - eye[0]) ** 2 + (ip[1] - eye[1]) ** 2 + (ip[2] - eye[2]) ** 2
  1620. if best is None or d < best[0]:
  1621. cur = [ip[0] - pos[0], ip[1] - pos[1], ip[2] - pos[2]]
  1622. for ax, nv in enumerate((nx, ny, nz)):
  1623. if nv:
  1624. cur[ax] = 1.0 if nv > 0 else 0.0
  1625. best = (d, f, ip, tuple(cur))
  1626. return best[1:] if best else None
  1627. def hold_item(self):
  1628. lst = self.win.get(0) or []
  1629. i = 36 + self.held
  1630. return lst[i] if i < len(lst) else None
  1631. def walkable(self, x, y, z, F=None):
  1632. w = self.world
  1633. if not w.has(x, z):
  1634. return False
  1635. bx = self.bad_xz.get((x, z))
  1636. if bx and bx > time.time():
  1637. return False
  1638. F = F or w.flags
  1639. a, b, c = F(x, y, z), F(x, y + 1, z), F(x, y - 1, z)
  1640. if (a | b) & (SOLID | WATER | DANGER | AVOID):
  1641. return False
  1642. if not c & SOLID or c & (DANGER | AVOID):
  1643. return False
  1644. for dx, dz in CARD:
  1645. if (F(x + dx, y, z + dz) | F(x + dx, y + 1, z + dz) | F(x + dx, y - 1, z + dz)) & DANGER:
  1646. return False
  1647. return True
  1648. def ahead(self, yaw, dist=0.8):
  1649. """Що попереду: flat / up / down / None (небезпечно: урвище >3, лава, вода, стіна)."""
  1650. r = math.radians(yaw)
  1651. bx, bz = math.floor(self.x - math.sin(r) * dist), math.floor(self.z + math.cos(r) * dist)
  1652. by = math.floor(self.y + 1e-3)
  1653. if self.walkable(bx, by, bz):
  1654. return "flat"
  1655. if self.walkable(bx, by + 1, bz) and not self.world.flags(math.floor(self.x), by + 2, math.floor(self.z)) & SOLID:
  1656. return "up"
  1657. for d in (1, 2, 3):
  1658. if self.world.flags(bx, by - d + 1, bz) & SOLID:
  1659. break
  1660. if self.walkable(bx, by - d, bz):
  1661. return "down"
  1662. return None
  1663. def safe_ahead(self, yaw):
  1664. """Захист від падіння: глибина під точкою попереду має бути <=3 і без води/лави."""
  1665. r = math.radians(yaw)
  1666. w = self.world
  1667. for dist in (0.45, 0.8):
  1668. bx, bz = math.floor(self.x - math.sin(r) * dist), math.floor(self.z + math.cos(r) * dist)
  1669. by = math.floor(self.y + 1e-3)
  1670. ok = False
  1671. for d in range(0, 4):
  1672. fl = w.flags(bx, by - 1 - d, bz)
  1673. if fl & (WATER | DANGER):
  1674. return False
  1675. if fl & SOLID:
  1676. ok = True
  1677. break
  1678. if not ok:
  1679. return False
  1680. return True
  1681. # ---------- виконання дій у тіку ----------
  1682. def finish(self, res):
  1683. self.act = None
  1684. self.act_res = res
  1685. self.act_ev.set()
  1686. return False, False, False
  1687. def cancel_act_raw(self, res):
  1688. a = self.act
  1689. if a is not None:
  1690. self.act = None
  1691. self.act_res = res
  1692. self.act_ev.set()
  1693. def run_action(self):
  1694. self.clock += 0.05
  1695. self.tick_n += 1
  1696. a = self.act
  1697. if a is None:
  1698. self.idle_look()
  1699. return False, False, False
  1700. if "until" in a and self.clock > a["until"]:
  1701. return self.finish("timeout")
  1702. return getattr(self, "act_" + a["k"])(a)
  1703. def act_wait(self, a):
  1704. if self.clock >= a["end"]:
  1705. return self.finish("ok")
  1706. self.idle_look()
  1707. return False, False, False
  1708. def act_aim(self, a):
  1709. wy, wp = self.angles_to(a["pt"])
  1710. self.turn(wy, 25.0)
  1711. self.turn_pitch(wp, 15.0)
  1712. a["n"] = a.get("n", 0) + 1
  1713. if (abs(wrap(wy - self.yaw)) < 1.5 and abs(wp - self.pitch) < 2.0
  1714. and abs(self.yvel) < 0.8 and abs(self.pvel) < 0.8):
  1715. return self.finish("ok")
  1716. if a["n"] > 140:
  1717. return self.finish("fail")
  1718. return False, False, False
  1719. def dig_packet(self, status, pos, face):
  1720. self.seq += 1
  1721. self.send("play", "block_dig", status=status, location={"x": pos[0], "y": pos[1], "z": pos[2]},
  1722. face=face, sequence=self.seq)
  1723. def dig_step(self, pos, st):
  1724. """Тримає ліву кнопку на блоці, доки він не зламається. -> busy / ok / fail."""
  1725. b = self.m.binfo
  1726. s = self.world.state_at(*pos)
  1727. if s is None:
  1728. return "fail"
  1729. if not b.flags(s) & SOLID:
  1730. return "ok"
  1731. if "pt" not in st:
  1732. vf = self.visible_face(pos)
  1733. if not vf:
  1734. self.vlog(f"копання {pos}: блок не видно з моєї позиції")
  1735. return "fail"
  1736. held = self.hold_item()
  1737. need = b.dig_ticks(s, held["name"] if held else None, held["id"] if held else None)
  1738. if need < 0:
  1739. self.vlog(f"копання {pos}: {b.name(s)} не ламається")
  1740. return "fail"
  1741. st.update(face=vf[0], pt=vf[1], need=need, t=0, n=0, phase="aim")
  1742. wy, wp = self.angles_to(st["pt"])
  1743. ex, ey, ez = self.eye()
  1744. if math.sqrt((st["pt"][0] - ex) ** 2 + (st["pt"][1] - ey) ** 2 + (st["pt"][2] - ez) ** 2) > 4.8:
  1745. return "fail"
  1746. self.turn(wy, 20.0)
  1747. self.turn_pitch(wp, 12.0)
  1748. if st["phase"] == "aim":
  1749. st["n"] += 1
  1750. if (abs(wrap(wy - self.yaw)) < 2.0 and abs(wp - self.pitch) < 2.5
  1751. and abs(self.yvel) < 0.8 and abs(self.pvel) < 0.8):
  1752. self.send("play", "arm_animation", hand=0)
  1753. self.dig_packet(0, pos, st["face"])
  1754. st["phase"], st["t"] = "dig", 0
  1755. elif st["n"] > 140:
  1756. self.vlog(f"копання {pos}: не вдалось націлитись")
  1757. return "fail"
  1758. return "busy"
  1759. st["t"] += 1
  1760. self.send("play", "arm_animation", hand=0) # ліва кнопка затиснута: махаємо кожен тік
  1761. if st["t"] == st["need"]:
  1762. self.dig_packet(2, pos, st["face"])
  1763. elif st["t"] > st["need"] + 25:
  1764. self.dig_packet(1, pos, st["face"])
  1765. self.vlog(f"копання {pos}: сервер не дав зламати ({b.name(s)}, {st['need']} тіків)")
  1766. return "fail"
  1767. return "busy"
  1768. def act_dig(self, a):
  1769. r = self.dig_step(a["pos"], a.setdefault("_d", {}))
  1770. if r == "busy":
  1771. return False, False, False
  1772. return self.finish(r)
  1773. def act_path(self, a):
  1774. nodes, w, b = a["nodes"], self.world, self.m.binfo
  1775. if a.get("dig") is not None:
  1776. r = self.dig_step(a["dig"], a.setdefault("_d", {}))
  1777. if r == "busy":
  1778. return False, False, False
  1779. a["dig"], a["_d"] = None, {}
  1780. if r != "ok":
  1781. return self.finish("dig_fail")
  1782. while a["i"] < len(nodes):
  1783. x, y, z, _ = nodes[a["i"]]
  1784. if math.hypot(x + .5 - self.x, z + .5 - self.z) < 0.35 and abs(self.y - y) < 1.0:
  1785. a["i"] += 1
  1786. else:
  1787. break
  1788. if a["i"] >= len(nodes):
  1789. return self.finish("done")
  1790. x, y, z, brk = nodes[a["i"]]
  1791. pend = [c for c in brk if (w.state_at(*c) is not None and b.flags(w.state_at(*c)) & SOLID)]
  1792. if pend: # копаємо те, що зараз видно (верх -> низ для спуску, низ -> верх для підйому)
  1793. vis = [c for c in pend if self.visible_face(c)]
  1794. a["dig"], a["_d"] = (vis[0] if vis else pend[0]), {}
  1795. return False, False, False
  1796. tx, tz = x + .5, z + .5
  1797. hd = math.hypot(tx - self.x, tz - self.z)
  1798. if a["i"] + 1 < len(nodes) and hd < 0.9: # зрізаємо кути плавно
  1799. nx, _, nz, _ = nodes[a["i"] + 1]
  1800. k = 0.5 * (1 - hd / 0.9)
  1801. tx, tz = tx + (nx + .5 - tx) * k, tz + (nz + .5 - tz) * k
  1802. dx, dz = tx - self.x, tz - self.z
  1803. want = math.degrees(math.atan2(-dx, dz))
  1804. self.turn(want, 24.0)
  1805. self.turn_pitch(a.setdefault("pitch", random.uniform(2, 12)), 8.0, 1.0)
  1806. fwd = abs(wrap(want - self.yaw)) < 35 and hd > 0.1
  1807. if fwd and self.on_ground and not self.safe_ahead(self.yaw):
  1808. r = math.radians(self.yaw) # різка зміна рівня вниз: зупиняємось і шукаємо інший шлях
  1809. self.bad_xz[(math.floor(self.x - math.sin(r) * 0.8), math.floor(self.z + math.cos(r) * 0.8))] = time.time() + 90
  1810. return self.finish("unsafe")
  1811. fy = math.floor(self.y + 1e-3)
  1812. jump = self.on_ground and y > fy and hd < 1.4
  1813. if self.on_ground and self.hcol and fwd and y >= fy:
  1814. jump = True
  1815. if self.in_water:
  1816. jump = True # пливемо: тримаємось на поверхні
  1817. if hd > 6 and abs(self.y - y) < 8:
  1818. return self.finish("off_path")
  1819. if "sp" not in a:
  1820. a["sp"], a["st"] = (self.x, self.z, self.y), 0
  1821. a["st"] += 1
  1822. if a["st"] >= 40:
  1823. if math.sqrt((self.x - a["sp"][0]) ** 2 + (self.z - a["sp"][1]) ** 2 + (self.y - a["sp"][2]) ** 2) < 0.4:
  1824. return self.finish("stuck")
  1825. a["st"], a["sp"] = 0, (self.x, self.z, self.y)
  1826. return fwd, jump, bool(a.get("sprint"))
  1827. def act_attack(self, a):
  1828. e = self.entities.get(a["eid"])
  1829. if e is None:
  1830. return self.finish("gone")
  1831. tp = (e["x"], e["y"] + e["h"] * 0.6, e["z"])
  1832. wy, wp = self.angles_to(tp)
  1833. hd = math.hypot(e["x"] - self.x, e["z"] - self.z)
  1834. ex, ey, ez = self.eye()
  1835. d3 = math.sqrt((tp[0] - ex) ** 2 + (tp[1] - ey) ** 2 + (tp[2] - ez) ** 2)
  1836. self.turn(wy, 30.0, 4.0)
  1837. self.turn_pitch(wp, 20.0, 3.0)
  1838. fwd = jump = spr = False
  1839. if hd > 2.3 and abs(wrap(wy - self.yaw)) < 40:
  1840. kind = self.ahead(self.yaw)
  1841. if kind:
  1842. fwd, jump, spr = True, kind == "up" and self.on_ground, hd > 5
  1843. else:
  1844. a["blk"] = a.get("blk", 0) + 1
  1845. if a["blk"] > 15:
  1846. return self.finish("blocked")
  1847. if d3 <= 3.0 and self.clock >= self.next_atk and abs(wrap(wy - self.yaw)) < 12 and abs(wp - self.pitch) < 25:
  1848. if not self.send("play", "attack", entityId=e["id"]):
  1849. self.send("play", "use_entity", target=e["id"], mouse=1, sneaking=False)
  1850. self.send("play", "arm_animation", hand=0)
  1851. self.next_atk = self.clock + random.uniform(0.55, 0.8)
  1852. return fwd, jump, spr
  1853. def act_flee(self, a):
  1854. e = self.entities.get(a["eid"])
  1855. if self.clock > a["end"] or e is None:
  1856. return self.finish("ok")
  1857. ax, az = self.x - e["x"], self.z - e["z"]
  1858. if math.hypot(ax, az) > 18:
  1859. return self.finish("ok")
  1860. base = math.degrees(math.atan2(-ax, az))
  1861. pick = None
  1862. for off in (0, 30, -30, 60, -60, 90, -90, 135, -135):
  1863. if self.ahead(base + off):
  1864. pick = base + off
  1865. break
  1866. if pick is None:
  1867. self.idle_look()
  1868. return False, False, False
  1869. self.turn(pick, 35.0, 5.0)
  1870. fwd = abs(wrap(pick - self.yaw)) < 30
  1871. return fwd, self.ahead(self.yaw) == "up" and self.on_ground, True
  1872. def act_eat(self, a):
  1873. if "t" not in a:
  1874. a["t"] = 0
  1875. self.seq += 1
  1876. self.send("play", "use_item", hand=0, sequence=self.seq, yaw=self.yaw, pitch=self.pitch,
  1877. rotation={"x": self.yaw, "y": self.pitch})
  1878. a["t"] += 1
  1879. if a["t"] >= 36:
  1880. return self.finish("ok")
  1881. return False, False, False
  1882. # ---------- дії ----------
  1883. def say(self, text):
  1884. if not (self.joined and self.state == "play"):
  1885. self.log("ще не на сервері, пропускаю")
  1886. return
  1887. ts = int(time.time() * 1000)
  1888. if text.startswith("/"):
  1889. self.send("play", "chat_command", command=text[1:], timestamp=ts, salt=0)
  1890. else:
  1891. self.send("play", "chat_message", message=text, timestamp=ts, salt=0, signature=None)
  1892. def run_commands(self, stop=None):
  1893. stop = stop or self.stop
  1894. for cmd in self.m.commands:
  1895. if stop.is_set() or not self.joined:
  1896. return
  1897. is_reg = cmd.lower().startswith(("/register", "/reg "))
  1898. if is_reg and self.m.no_register_on_reconnect and self.registered:
  1899. continue
  1900. self.say(cmd.replace("{name}", self.name).replace("{n}", str(self.index)))
  1901. if is_reg:
  1902. self.registered = True
  1903. time.sleep(self.m.cmd_delay)
  1904. def startup_routine(self, stop):
  1905. if stop.wait(self.m.join_wait):
  1906. return
  1907. self.run_commands(stop)
  1908. if stop.wait(1.0):
  1909. return
  1910. self.ai_on = True
  1911. if self.m.smart and not self.brain_started:
  1912. self.brain_started = True
  1913. threading.Thread(target=self.brain, args=(stop,), daemon=True).start()
  1914. while self.m.loop > 0 and not stop.is_set():
  1915. if stop.wait(self.m.loop):
  1916. break
  1917. self.run_commands(stop)
  1918. def disconnect(self):
  1919. self.quit_ev.set()
  1920. self.stop.set()
  1921. self.act_ev.set()
  1922. if self.c:
  1923. self.c.close()
  1924. self.joined = False
  1925. # ======================================================================
  1926. # "Розумний" режим: пошук шляху, інвентар, крафт, мозок
  1927. # ======================================================================
  1928. NB6 = ((1, 0, 0), (-1, 0, 0), (0, 1, 0), (0, -1, 0), (0, 0, 1), (0, 0, -1))
  1929. STONE_NAMES = ["stone", "cobblestone", "deepslate", "cobbled_deepslate", "blackstone"]
  1930. IRON_ORES = ["iron_ore", "deepslate_iron_ore"]
  1931. FALLING = {"gravel", "sand", "red_sand", "suspicious_sand", "suspicious_gravel", "anvil"}
  1932. COAL_ORES = ["coal_ore", "deepslate_coal_ore"]
  1933. class Smart:
  1934. # ---------- інвентар ----------
  1935. def pslots(self):
  1936. wid = self.open_wid if self.open_wid is not None else 0
  1937. lst = self.win.get(wid) or []
  1938. ex = self.open_extra if self.open_wid is not None else 9
  1939. out = []
  1940. for ps in range(9, 45):
  1941. i = ps - 9 + ex
  1942. if i < len(lst) and lst[i]:
  1943. out.append((ps, lst[i]))
  1944. return out
  1945. def count(self, g):
  1946. pred = group_pred(g)
  1947. return sum(it["count"] for _, it in self.pslots() if pred(it["name"]))
  1948. def stack_of(self, g, minc=1):
  1949. pred = group_pred(g)
  1950. best = None
  1951. for ps, it in self.pslots():
  1952. if pred(it["name"]) and it["count"] >= minc and (best is None or it["count"] > best[2]):
  1953. best = (it["name"], ps, it["count"])
  1954. return best
  1955. def has_item(self, name):
  1956. if self.count(name) > 0:
  1957. return True
  1958. w0 = self.win.get(0) or []
  1959. return any(w0[i] and w0[i]["name"] == name for i in range(5, min(9, len(w0))))
  1960. def has_food(self):
  1961. return any(self.count(f) > 0 for f in FOODS)
  1962. def inv_str(self):
  1963. d = {}
  1964. for _, it in self.pslots():
  1965. d[it["name"]] = d.get(it["name"], 0) + it["count"]
  1966. return ", ".join(f"{k}x{v}" for k, v in sorted(d.items())) or "порожньо"
  1967. def select(self, i):
  1968. if self.held != i:
  1969. self.send("play", "held_item_slot", slotId=i)
  1970. self.held = i
  1971. def hold(self, name):
  1972. cur = self.hold_item()
  1973. if cur and cur["name"] == name:
  1974. return True
  1975. self.close_window()
  1976. lst = self.win.get(0) or []
  1977. for ps in range(36, 45):
  1978. if ps < len(lst) and lst[ps] and lst[ps]["name"] == name:
  1979. self.select(ps - 36)
  1980. time.sleep(0.12)
  1981. return True
  1982. for ps in range(9, 36):
  1983. if ps < len(lst) and lst[ps] and lst[ps]["name"] == name:
  1984. self.click(0, ps, 8, 2)
  1985. self.select(8)
  1986. time.sleep(0.12)
  1987. return True
  1988. return False
  1989. def hold_best(self, kind):
  1990. for tier in TIER_ORDER:
  1991. n = f"{tier}_{kind}"
  1992. if self.count(n) > 0:
  1993. return self.hold(n)
  1994. return False
  1995. def hold_for_state(self, s):
  1996. k = self.m.binfo.kind(s)
  1997. if k in ("pickaxe", "axe", "shovel", "hoe"):
  1998. return self.hold_best(k)
  1999. return False
  2000. def close_window(self):
  2001. if self.open_wid is not None:
  2002. self.send("play", "close_window", windowId=self.open_wid)
  2003. self.open_wid = None
  2004. time.sleep(0.2)
  2005. def equip_armor(self, name):
  2006. self.close_window()
  2007. for ps, it in self.pslots():
  2008. if it["name"] == name:
  2009. self.click(0, ps, 0, 1)
  2010. return True
  2011. return False
  2012. # ---------- крафт кліками ----------
  2013. def craft(self, name, times=1, table=False):
  2014. rc = recipe(name)
  2015. if not rc:
  2016. return False
  2017. pat, key, _ = rc
  2018. W = 3 if table else 2
  2019. if len(pat) > W or any(len(r) > W for r in pat):
  2020. return False
  2021. wid = self.open_wid if table else 0
  2022. if wid is None:
  2023. return False
  2024. if not table:
  2025. self.close_window()
  2026. extra = 10 if table else 9
  2027. groups = {}
  2028. for r, row in enumerate(pat):
  2029. for c, ch in enumerate(row):
  2030. if ch != " ":
  2031. groups.setdefault(key[ch], []).append(1 + r * W + c)
  2032. out_g = name if name not in ("planks", "stick") else name
  2033. before = self.count(out_g)
  2034. for g, slots in groups.items():
  2035. st = self.stack_of(g, len(slots) * times)
  2036. if not st:
  2037. self.clear_grid(wid, W)
  2038. return False
  2039. src = st[1] - 9 + extra
  2040. self.click(wid, src, 0)
  2041. for s in slots:
  2042. for _ in range(times):
  2043. self.click(wid, s, 1)
  2044. self.click(wid, src, 0)
  2045. if self.cursor:
  2046. self.click(wid, src, 0)
  2047. self.click(wid, 0, 0, 1)
  2048. time.sleep(0.3)
  2049. self.clear_grid(wid, W)
  2050. if self.cursor:
  2051. self.click(wid, -999, 0, 0)
  2052. return self.count(out_g) > before
  2053. def clear_grid(self, wid, W):
  2054. lst = self.win.get(wid) or []
  2055. for s in range(1, W * W + 1):
  2056. if s < len(lst) and lst[s]:
  2057. self.click(wid, s, 0, 1)
  2058. def put_into(self, wid, extra, item, dst, n):
  2059. st = self.stack_of(item, 1)
  2060. if not st:
  2061. return
  2062. src = st[1] - 9 + extra
  2063. self.click(wid, src, 0)
  2064. if n >= st[2]:
  2065. self.click(wid, dst, 0)
  2066. else:
  2067. for _ in range(n):
  2068. self.click(wid, dst, 1)
  2069. self.click(wid, src, 0)
  2070. if self.cursor:
  2071. self.click(wid, src, 0)
  2072. # ---------- дії (блокуюче очікування) ----------
  2073. def do(self, act, timeout=30.0, reflex=True):
  2074. with self.plock:
  2075. act["until"] = self.clock + timeout
  2076. self.act_res = None
  2077. self.act_ev.clear()
  2078. self.act = act
  2079. t0 = time.time()
  2080. while not self.stop.is_set():
  2081. if self.act_ev.wait(0.1):
  2082. return self.act_res or "?"
  2083. if time.time() - t0 > timeout + 3:
  2084. self.cancel_act("timeout")
  2085. return "timeout"
  2086. if reflex and self.danger_now():
  2087. self.cancel_act("interrupted")
  2088. return "interrupted"
  2089. return "stopped"
  2090. def cancel_act(self, res):
  2091. with self.plock:
  2092. a = self.act
  2093. if a is not None:
  2094. st = a.get("_d") or {}
  2095. pos = a.get("pos") or a.get("dig")
  2096. if st.get("phase") == "dig" and pos:
  2097. self.dig_packet(1, pos, st.get("face", 1))
  2098. self.cancel_act_raw(res)
  2099. def is_enemy(self, e):
  2100. if e["name"] == "creeper" or self.ign_ent.get(e["id"], 0) > time.time():
  2101. return False
  2102. if e["hostile"]:
  2103. return True
  2104. return e["name"] == "player" and self.m.pvp and e.get("uuid") not in self.m.bot_uuids
  2105. def danger_now(self):
  2106. if self.dead:
  2107. return True
  2108. for e in list(self.entities.values()):
  2109. d = math.hypot(e["x"] - self.x, e["z"] - self.z)
  2110. if e["name"] == "creeper" and d < 8:
  2111. return True
  2112. if d < 5 and abs(e["y"] - self.y) < 4 and self.is_enemy(e):
  2113. return True
  2114. return False
  2115. # ---------- планувальник A* (з прориттям тунелів) ----------
  2116. def plan_path(self, mode, tx, ty, tz, R, tunnel=False):
  2117. start = (math.floor(self.x), math.floor(self.y + 1e-3), math.floor(self.z))
  2118. return self.plan(start, tx, ty, tz, mode, R, tunnel, 16000 if tunnel else 4000)
  2119. def plan(self, start, tx, ty, tz, mode, R, tunnel, max_nodes):
  2120. """A*. Режими цілі: xz (точка на площині), near (поруч), reach (можна копати блок), depth (спуститись до y<=ty)."""
  2121. w, b = self.world, self.m.binfo
  2122. fc, okc, kc, tvc = {}, {}, {}, {}
  2123. swim = bool(w.flags(start[0], start[1], start[2]) & WATER) # стартуємо у воді - дозволяємо пливти
  2124. def F(x, y, z):
  2125. k = (x, y, z)
  2126. v = fc.get(k)
  2127. if v is None:
  2128. v = fc[k] = w.flags(x, y, z)
  2129. return v
  2130. def ok(x, y, z):
  2131. k = (x, y, z)
  2132. v = okc.get(k)
  2133. if v is None:
  2134. v = self.walkable(x, y, z, F)
  2135. 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):
  2136. v = True
  2137. okc[k] = v
  2138. return v
  2139. def ck(x, y, z):
  2140. k = (x, y, z)
  2141. v = kc.get(k)
  2142. if v is None:
  2143. s_ = w.state_at(x, y, z)
  2144. if s_ is None:
  2145. v = ("bad", 0.0)
  2146. else:
  2147. fl = b.flags(s_)
  2148. if fl & (WATER | DANGER | AVOID):
  2149. v = ("bad", 0.0)
  2150. elif fl & SOLID:
  2151. h = b.hardness(s_)
  2152. bn = b.name(s_)
  2153. if (h < 0 or h > 8 or bn in FALLING or bn.endswith("_concrete_powder")
  2154. or any(F(x + a, y + c, z + d) & (WATER | DANGER) for a, c, d in NB6)):
  2155. v = ("bad", 0.0)
  2156. else:
  2157. v = ("dig", h)
  2158. else:
  2159. v = ("free", 0.0)
  2160. kc[k] = v
  2161. return v
  2162. def tv(x, y, z):
  2163. k = (x, y, z)
  2164. if k in tvc:
  2165. return tvc[k]
  2166. r = None
  2167. if w.has(x, z):
  2168. c = F(x, y - 1, z)
  2169. if c & SOLID and not c & (DANGER | AVOID):
  2170. f1, f2 = ck(x, y, z), ck(x, y + 1, z)
  2171. if (f1[0] != "bad" and f2[0] != "bad"
  2172. and not any(F(x + dx, y + yy, z + dz) & DANGER for dx, dz in CARD for yy in (-1, 0, 1))):
  2173. r = tuple(cc for cc, f in (((x, y, z), f1), ((x, y + 1, z), f2)) if f[0] == "dig")
  2174. tvc[k] = r
  2175. return r
  2176. def nbrs(x, y, z):
  2177. for dx, dz in CARD:
  2178. nx, nz = x + dx, z + dz
  2179. if ok(nx, y, nz):
  2180. yield (nx, y, nz), (2.5 if swim and F(nx, y, nz) & WATER else 1.0), ()
  2181. elif ok(nx, y + 1, nz) and not F(x, y + 2, z) & SOLID:
  2182. yield (nx, y + 1, nz), 1.8, ()
  2183. else:
  2184. for d in (1, 2, 3):
  2185. if F(nx, y - d + 1, nz) & SOLID:
  2186. break
  2187. if ok(nx, y - d, nz):
  2188. if all(not F(nx, yy, nz) & (SOLID | DANGER | WATER | AVOID) for yy in range(y - d + 2, y + 2)):
  2189. yield (nx, y - d, nz), 1.5 + 0.4 * d, ()
  2190. break
  2191. for dx, dz in DIAG:
  2192. nx, nz = x + dx, z + dz
  2193. if ok(nx, y, nz) and ok(x + dx, y, z) and ok(x, y, z + dz):
  2194. yield (nx, y, nz), 1.42, ()
  2195. if tunnel:
  2196. for dx, dz in CARD:
  2197. nx, nz = x + dx, z + dz
  2198. for dy in (0, 1, -1):
  2199. ny = y + dy
  2200. br = tv(nx, ny, nz)
  2201. if br is None:
  2202. continue
  2203. extra = ()
  2204. if dy == 1:
  2205. kk = ck(x, y + 2, z)
  2206. if kk[0] == "bad":
  2207. continue
  2208. if kk[0] == "dig":
  2209. extra = ((x, y + 2, z),)
  2210. elif dy == -1:
  2211. kk = ck(nx, y + 1, nz)
  2212. if kk[0] == "bad":
  2213. continue
  2214. if kk[0] == "dig":
  2215. extra = ((nx, y + 1, nz),)
  2216. allb = br + extra
  2217. if not allb:
  2218. continue
  2219. cost = 1.0 + (0.5 if dy else 0.0)
  2220. for c in allb:
  2221. cost += 2.0 + ck(*c)[1] * 1.5
  2222. yield (nx, ny, nz), cost, allb
  2223. cell = (math.floor(tx), math.floor(ty), math.floor(tz))
  2224. def goal(n):
  2225. x, y, z = n
  2226. if mode == "depth":
  2227. return y <= ty
  2228. if mode == "xz":
  2229. return math.hypot(tx - x - .5, tz - z - .5) <= R
  2230. if mode == "near":
  2231. return math.hypot(tx - x - .5, tz - z - .5) <= R and abs(ty - y) <= 2.5
  2232. ex, ey, ez = x + .5, y + 1.62, z + .5
  2233. if (tx - ex) ** 2 + (ty - ey) ** 2 + (tz - ez) ** 2 > R * R:
  2234. return False
  2235. fe, he = (x, y, z), (x, y + 1, z) # власні клітинки після прориття вважаємо вільними
  2236. return self.visible_face(cell, (ex, ey, ez),
  2237. lambda a, b2, c2: 0 if (a, b2, c2) == fe or (a, b2, c2) == he else F(a, b2, c2)) is not None
  2238. def h(n):
  2239. x, y, z = n
  2240. if mode == "depth":
  2241. return max(0.0, y - ty) * 15.0
  2242. if mode in ("xz", "near"):
  2243. hd_ = math.hypot(tx - x - .5, tz - z - .5)
  2244. return hd_ * 5.0 if tunnel else hd_
  2245. if tunnel: # у тунелі кожен блок коштує ~5-10 (сходи + ламання), тому евристика "важка"
  2246. return max(0.0, 5.0 * (math.hypot(tx - x - .5, tz - z - .5) + abs(ty - y - 1.0)) - R * 3.0)
  2247. return max(0.0, math.sqrt((tx - x - .5) ** 2 + (ty - y - 1.0) ** 2 + (tz - z - .5) ** 2) - R * 0.8)
  2248. wgt = 2.5 if tunnel else 1.25
  2249. g = {start: 0.0}
  2250. came = {}
  2251. pq = [(h(start) * wgt, 0.0, start)]
  2252. best = (h(start), start)
  2253. n = 0
  2254. found = None
  2255. while pq and n < max_nodes:
  2256. _, gc, cur = heapq.heappop(pq)
  2257. if gc > g.get(cur, 1e18) + 1e-9:
  2258. continue
  2259. n += 1
  2260. hh = h(cur)
  2261. if hh < best[0]:
  2262. best = (hh, cur)
  2263. if goal(cur):
  2264. found = cur
  2265. break
  2266. for nb, c, brk in nbrs(*cur):
  2267. ng = gc + c
  2268. if ng < g.get(nb, 1e18):
  2269. g[nb] = ng
  2270. came[nb] = (cur, brk)
  2271. heapq.heappush(pq, (ng + wgt * h(nb), ng, nb))
  2272. if found is None:
  2273. if mode == "xz" and h(start) - best[0] >= 6:
  2274. found = best[1]
  2275. else:
  2276. return None
  2277. path = []
  2278. node = found
  2279. while node in came:
  2280. prev, brk = came[node]
  2281. path.append(node + (brk,))
  2282. node = prev
  2283. path.append(start + ((),))
  2284. path.reverse()
  2285. return path
  2286. def vlog(self, msg):
  2287. if self.m.verbose:
  2288. self.log(msg)
  2289. def run_path(self, path, timeout=None, sprint=False):
  2290. if timeout is None:
  2291. br = sum(len(n[3]) for n in path)
  2292. timeout = min(420.0, 15 + len(path) * 1.5 + br * 8)
  2293. return self.do({"k": "path", "nodes": path, "i": 1, "sprint": sprint}, timeout)
  2294. def goto(self, mode, tx, ty, tz, R, tunnel=False, timeout=None):
  2295. """-> True (дійшов) / False (шляху немає) / "interrupted" (відволік ворог чи кріпер)."""
  2296. for _ in range(5):
  2297. path = self.plan_path(mode, tx, ty, tz, R, tunnel)
  2298. if not path:
  2299. self.vlog(f"goto: шляху немає (режим {mode}, тунелі: {tunnel})")
  2300. return False
  2301. if len(path) <= 1:
  2302. return True
  2303. res = self.run_path(path, timeout)
  2304. if res == "done":
  2305. return True
  2306. if res in ("interrupted", "stopped", "dead"):
  2307. return "interrupted"
  2308. self.vlog(f"goto: {res}, перепланую")
  2309. return False
  2310. # ---------- блоки та предмети навколо ----------
  2311. def reach_ok(self, cell):
  2312. ex, ey, ez = self.eye()
  2313. if (cell[0] + .5 - ex) ** 2 + (cell[1] + .5 - ey) ** 2 + (cell[2] + .5 - ez) ** 2 > 4.2 ** 2:
  2314. return False
  2315. return self.visible_face(cell) is not None
  2316. def mine_block(self, cell):
  2317. """-> True / False / "interrupted"."""
  2318. s = self.world.state_at(*cell)
  2319. if s is None:
  2320. return False
  2321. if not self.m.binfo.flags(s) & SOLID:
  2322. return True
  2323. self.hold_for_state(s)
  2324. for _ in range(3):
  2325. if not self.reach_ok(cell):
  2326. g = self.goto("reach", cell[0] + .5, cell[1] + .5, cell[2] + .5, 4.0, True)
  2327. if g == "interrupted":
  2328. return "interrupted"
  2329. if g is not True:
  2330. return False
  2331. self.hold_for_state(s)
  2332. r = self.do({"k": "dig", "pos": cell}, 40)
  2333. if r == "ok":
  2334. return True
  2335. if r in ("interrupted", "stopped", "dead"):
  2336. return "interrupted"
  2337. self.vlog(f"копання {cell} не вдалось: {r}")
  2338. return False
  2339. def collect_items(self, maxn=8):
  2340. for _ in range(maxn):
  2341. items = [e for e in list(self.entities.values())
  2342. if e["name"] == "item" and e["id"] not in self.ignore_items
  2343. and math.hypot(e["x"] - self.x, e["z"] - self.z) < 10 and abs(e["y"] - self.y) < 6]
  2344. if not items:
  2345. return
  2346. e = min(items, key=lambda e: math.hypot(e["x"] - self.x, e["z"] - self.z))
  2347. if math.hypot(e["x"] - self.x, e["z"] - self.z) > 0.9 or abs(e["y"] - self.y) > 1.5:
  2348. if self.goto("near", e["x"], e["y"], e["z"], 0.7, False, 12) is not True:
  2349. self.ignore_items.add(e["id"])
  2350. continue
  2351. time.sleep(0.5)
  2352. if e["id"] in self.entities:
  2353. self.ignore_items.add(e["id"])
  2354. def descend(self, ty, maxdrop=8):
  2355. """Копає/проходить вниз (печери, або сходи в землі) до рівня ty (не більше maxdrop за раз)."""
  2356. target = max(ty, math.floor(self.y) - maxdrop, -8)
  2357. if self.y <= target + 0.5:
  2358. return False
  2359. self.hold_best("pickaxe")
  2360. path = self.plan_path("depth", self.x, target, self.z, 0, True)
  2361. if not path or len(path) <= 1:
  2362. self.vlog(f"спуск до y={target}: шляху немає")
  2363. return False
  2364. self.vlog(f"спускаюсь до y={target} (вузлів {len(path)}, ламати {sum(len(n[3]) for n in path)})")
  2365. self.run_path(path)
  2366. self.collect_items()
  2367. return True
  2368. def tunnel_forward(self, n=14):
  2369. if self.tun_dir is None:
  2370. self.tun_dir = random.choice(CARD)
  2371. dx, dz = self.tun_dir
  2372. path = self.plan_path("xz", self.x + dx * n, 0, self.z + dz * n, 1.5, True)
  2373. if not path or len(path) <= 2:
  2374. self.tun_dir = random.choice(CARD)
  2375. self.vlog("тунель: напрямок закритий, міняю")
  2376. return False
  2377. self.hold_best("pickaxe")
  2378. self.vlog(f"риюсь вперед ({dx},{dz}), вузлів {len(path)}")
  2379. self.run_path(path)
  2380. self.collect_items()
  2381. return True
  2382. def harvest(self, names, until, max_s=300, depth=None, dig_down=False):
  2383. ids = self.m.binfo.state_ids(names)
  2384. t0 = time.time()
  2385. misses = 0
  2386. while not until() and time.time() - t0 < max_s and not self.stop.is_set():
  2387. if self.reflex():
  2388. continue
  2389. now = time.time()
  2390. cells = [c for c in self.world.find(ids, self.x, self.z, 150) if self.bad.get(c, 0) < now]
  2391. cells.sort(key=lambda c: abs(c[0] + .5 - self.x) + abs(c[2] + .5 - self.z) + 1.5 * abs(c[1] - self.y))
  2392. done = inter = False
  2393. for c in cells[:4]:
  2394. r = self.mine_block(c)
  2395. if r is True:
  2396. done = True
  2397. break
  2398. if r == "interrupted":
  2399. inter = True
  2400. break
  2401. self.bad[c] = time.time() + 90
  2402. if done:
  2403. misses = 0
  2404. self.collect_items()
  2405. continue
  2406. if inter:
  2407. continue
  2408. misses += 1
  2409. self.vlog(f"добування: невдача {misses}, відомих цілей {len(cells)}")
  2410. if misses > 14:
  2411. return False
  2412. if dig_down:
  2413. self.descend(math.floor(self.y) - 6)
  2414. elif depth is not None:
  2415. if self.y > depth + 1:
  2416. self.descend(depth)
  2417. else:
  2418. self.tunnel_forward(14)
  2419. else:
  2420. self.explore()
  2421. return bool(until())
  2422. def explore(self, tunnel_ok=True):
  2423. """Подорож до далекої точки, яка якнайдалі від уже відвіданих місць (щоб не ходити колами)."""
  2424. self.visit.append((self.x, self.z))
  2425. self.visit = self.visit[-30:]
  2426. cands = []
  2427. for k in range(12):
  2428. ang = k * math.pi / 6 + random.uniform(-0.2, 0.2)
  2429. dist = random.uniform(40, 65)
  2430. gx, gz = self.x + math.cos(ang) * dist, self.z + math.sin(ang) * dist
  2431. while dist > 12 and not self.world.has(gx, gz):
  2432. dist -= 8
  2433. gx, gz = self.x + math.cos(ang) * dist, self.z + math.sin(ang) * dist
  2434. if dist <= 12:
  2435. continue
  2436. far = min(math.hypot(gx - vx, gz - vz) for vx, vz in self.visit)
  2437. score = far + random.uniform(0, 12) - abs(wrap(math.degrees(ang - self.heading))) * 0.15
  2438. cands.append((score, gx, gz, ang))
  2439. cands.sort(reverse=True)
  2440. for score, gx, gz, ang in cands[:4]:
  2441. path = self.plan_path("xz", gx, 0, gz, 2.0, False)
  2442. if path and len(path) > 6:
  2443. self.heading = ang
  2444. self.vlog(f"йду досліджувати ({gx:.0f},{gz:.0f}), вузлів {len(path)}")
  2445. self.run_path(path, None, True)
  2446. return True
  2447. if tunnel_ok and cands:
  2448. _, gx, gz, ang = cands[0]
  2449. self.hold_best("pickaxe")
  2450. path = self.plan_path("xz", gx, 0, gz, 2.0, True)
  2451. if path and len(path) > 2:
  2452. self.heading = ang
  2453. self.vlog(f"досліджую з прориттям, вузлів {len(path)}")
  2454. self.run_path(path)
  2455. return True
  2456. self.vlog("explore: жодного шляху")
  2457. return False
  2458. def unstick(self):
  2459. self.vlog("сторожовий таймер: майже не рухаюсь - вириваюсь тунелем")
  2460. self.bad.clear()
  2461. self.bad_xz.clear()
  2462. self.tun_dir = random.choice(CARD)
  2463. self.heading = random.uniform(0, 2 * math.pi)
  2464. if not self.tunnel_forward(20):
  2465. self.explore()
  2466. # ---------- розміщення / використання блоків ----------
  2467. def block_name(self, pos):
  2468. s = self.world.state_at(*pos)
  2469. return self.m.binfo.name(s) if s is not None else None
  2470. def top_face(self, ref):
  2471. eye = self.eye()
  2472. c = (ref[0] + .5, ref[1] + .5, ref[2] + .5)
  2473. ip = (c[0], c[1] + .47, c[2])
  2474. if eye[1] - c[1] <= 0.5 or not self.ray_hits(eye, ip, ref, self.world.flags):
  2475. return None
  2476. return ip
  2477. def place_near(self, item):
  2478. """Ставить блок-предмет на землю поруч. -> позиція поставленого блоку або None."""
  2479. w, b = self.world, self.m.binfo
  2480. if not self.hold(item):
  2481. return None
  2482. fy = math.floor(self.y + 1e-3)
  2483. ox, oz = math.floor(self.x), math.floor(self.z)
  2484. cands = []
  2485. for dx, dz in CARD + DIAG:
  2486. ref, up = (ox + dx, fy - 1, oz + dz), (ox + dx, fy, oz + dz)
  2487. fr = w.flags(*ref)
  2488. if (fr & SOLID and not fr & (AVOID | DANGER) and not w.flags(*up) & (SOLID | WATER | DANGER)
  2489. and not w.flags(up[0], up[1] + 1, up[2]) & SOLID):
  2490. cands.append((ref, up))
  2491. random.shuffle(cands)
  2492. for ref, up in cands:
  2493. ip = self.top_face(ref)
  2494. if not ip:
  2495. continue
  2496. if self.do({"k": "aim", "pt": ip}, 6, reflex=False) != "ok":
  2497. continue
  2498. self.seq += 1
  2499. self.send("play", "block_place", hand=0, location={"x": ref[0], "y": ref[1], "z": ref[2]},
  2500. direction=1, cursorX=0.5, cursorY=1.0, cursorZ=0.5, insideBlock=False,
  2501. worldBorderHit=False, sequence=self.seq)
  2502. self.send("play", "arm_animation", hand=0)
  2503. time.sleep(0.5)
  2504. if self.block_name(up) == item:
  2505. return up
  2506. return None
  2507. def use_block(self, pos):
  2508. vf = self.visible_face(pos)
  2509. if not vf:
  2510. return False
  2511. face, pt, cur = vf
  2512. if self.do({"k": "aim", "pt": pt}, 6, reflex=False) != "ok":
  2513. return False
  2514. self.seq += 1
  2515. self.send("play", "block_place", hand=0, location={"x": pos[0], "y": pos[1], "z": pos[2]},
  2516. direction=face, cursorX=cur[0], cursorY=cur[1], cursorZ=cur[2], insideBlock=False,
  2517. worldBorderHit=False, sequence=self.seq)
  2518. self.send("play", "arm_animation", hand=0)
  2519. return True
  2520. def open_block(self, pos, extra):
  2521. if self.goto("reach", pos[0] + .5, pos[1] + .5, pos[2] + .5, 4.0, False, 40) is not True:
  2522. return False
  2523. self.close_window()
  2524. self.ow_ev.clear()
  2525. if not self.use_block(pos):
  2526. return False
  2527. if not self.ow_ev.wait(3.0):
  2528. return False
  2529. self.open_extra = extra
  2530. time.sleep(0.5)
  2531. return True
  2532. def pickup_block(self, pos):
  2533. if pos and self.block_name(pos) in ("crafting_table", "furnace"):
  2534. self.close_window()
  2535. self.mine_block(pos)
  2536. self.collect_items()
  2537. # ---------- ресурси ----------
  2538. def ensure_planks(self, n):
  2539. t0 = time.time()
  2540. while self.count("planks") < n and time.time() - t0 < 400 and not self.stop.is_set():
  2541. need = n - self.count("planks")
  2542. logs = -(-need // 4)
  2543. st = self.stack_of("log", 1)
  2544. if st:
  2545. times = min(st[2], logs)
  2546. self.close_window()
  2547. if not self.craft("planks", times, False):
  2548. return False
  2549. continue
  2550. if not self.harvest(self.m.log_names, lambda: self.count("log") >= logs, 240):
  2551. return False
  2552. return self.count("planks") >= n
  2553. def ensure_stone(self, n):
  2554. return self.harvest(STONE_NAMES, lambda: self.count("cobble") >= n, 420, dig_down=True)
  2555. def smelt(self, target):
  2556. raw = self.count("raw_iron")
  2557. if raw == 0:
  2558. return
  2559. fuel = "coal" if self.count("coal") else ("charcoal" if self.count("charcoal") else None)
  2560. if not fuel:
  2561. self.log("нема палива для печі")
  2562. return
  2563. need_fuel = min(self.count(fuel), -(-raw // 8))
  2564. pos = self.furnace_pos if self.furnace_pos and self.block_name(self.furnace_pos) == "furnace" else None
  2565. if pos is None:
  2566. pos = self.place_near("furnace")
  2567. if pos is None:
  2568. return
  2569. self.furnace_pos = pos
  2570. first = True
  2571. t0 = time.time()
  2572. while time.time() - t0 < 60 + raw * 11 and not self.stop.is_set():
  2573. if not self.open_block(pos, 3):
  2574. break
  2575. wid = self.open_wid
  2576. if first:
  2577. self.put_into(wid, 3, "raw_iron", 0, raw)
  2578. self.put_into(wid, 3, fuel, 1, need_fuel)
  2579. first = False
  2580. lst = self.win.get(wid) or []
  2581. if len(lst) > 2 and lst[2]:
  2582. self.click(wid, 2, 0, 1)
  2583. time.sleep(0.3)
  2584. lst = self.win.get(wid) or []
  2585. left = (lst[0]["count"] if len(lst) > 0 and lst[0] else 0)
  2586. self.close_window()
  2587. if self.count("iron_ingot") >= target or left == 0:
  2588. break
  2589. for _ in range(12):
  2590. time.sleep(1)
  2591. self.wd_skip = time.time() + 40
  2592. if self.stop.is_set() or self.reflex():
  2593. break
  2594. def table_session(self, items, pos=None):
  2595. """Відкрити верстак (поставити, якщо pos не заданий) і скрафтити предмети. -> (pos, скільки скрафтили)."""
  2596. if pos is None or self.block_name(pos) != "crafting_table":
  2597. pos = self.place_near("crafting_table")
  2598. if pos is None:
  2599. return None, 0
  2600. self.table_pos = pos
  2601. if not self.open_block(pos, 10):
  2602. return pos, 0
  2603. done = 0
  2604. for it in items:
  2605. if all(self.count(g) >= c for g, c in recipe_cost(it).items()):
  2606. if self.craft(it, 1, True):
  2607. done += 1
  2608. self.log(f"скрафтив {it}")
  2609. self.close_window()
  2610. return pos, done
  2611. def make_tier(self, tier, missing):
  2612. mat = MAT[tier]
  2613. cost = {}
  2614. for it in missing:
  2615. for g, c in recipe_cost(it).items():
  2616. cost[g] = cost.get(g, 0) + c
  2617. t_sticks = -(-max(0, cost.get("stick", 0) - self.count("stick")) // 4)
  2618. has_table = self.count("crafting_table") > 0
  2619. planks_need = 2 * t_sticks + (0 if has_table else 4) + (cost.get("planks", 0) if mat == "planks" else 0)
  2620. if not self.ensure_planks(planks_need):
  2621. return False
  2622. if t_sticks and not self.craft("stick", t_sticks, False):
  2623. return False
  2624. if not has_table and not self.craft("crafting_table", 1, False):
  2625. return False
  2626. if tier == "stone":
  2627. if not self.ensure_stone(cost.get("cobble", 0)):
  2628. return False
  2629. if tier == "iron":
  2630. target = cost.get("iron", 0)
  2631. if not self.harvest(IRON_ORES, lambda: self.count("raw_iron") + self.count("iron_ingot") >= target, 900, depth=16) \
  2632. and self.count("raw_iron") + self.count("iron_ingot") < 3:
  2633. return False
  2634. raw = self.count("raw_iron")
  2635. if raw and self.count("coal") + self.count("charcoal") < -(-raw // 8):
  2636. self.harvest(COAL_ORES, lambda: self.count("coal") + self.count("charcoal") >= -(-raw // 8), 400, depth=45)
  2637. if not self.furnace_pos or self.block_name(self.furnace_pos) != "furnace":
  2638. if not self.ensure_stone(8):
  2639. return False
  2640. tpos, n = self.table_session(["furnace"])
  2641. if n == 0:
  2642. self.pickup_block(tpos)
  2643. return False
  2644. self.table_pos = tpos
  2645. self.smelt(target)
  2646. order = [it for it in missing]
  2647. tpos, n = self.table_session(order, self.table_pos)
  2648. else:
  2649. tpos, n = self.table_session(missing)
  2650. self.pickup_block(tpos)
  2651. if tier == "iron" and self.count("iron_helmet") > 0:
  2652. self.equip_armor("iron_helmet")
  2653. return all(self.has_item(it) for it in missing) or n > 0
  2654. def tool_progress(self):
  2655. for tier, items in TIERS:
  2656. missing = [i for i in items if not self.has_item(i)]
  2657. if not missing:
  2658. continue
  2659. if self.skip_until.get(tier, 0) > time.time():
  2660. return False
  2661. if tier == "stone" and not any(self.count(f"{t}_pickaxe") for t in TIER_SPEED):
  2662. return False
  2663. if tier == "iron" and not any(self.count(f"{t}_pickaxe") for t in ("stone", "iron", "diamond", "netherite")):
  2664. return False
  2665. self.log(f"план: {tier} -> {', '.join(missing)}")
  2666. ok = self.make_tier(tier, missing)
  2667. if not ok:
  2668. self.tier_fail[tier] = self.tier_fail.get(tier, 0) + 1
  2669. if self.tier_fail[tier] >= 2:
  2670. self.skip_until[tier] = time.time() + 240
  2671. self.tier_fail[tier] = 0
  2672. self.log(f"не виходить ({tier}), пробую пізніше - іду досліджувати")
  2673. else:
  2674. self.tier_fail[tier] = 0
  2675. return True
  2676. return False
  2677. # ---------- їжа / бої / реакції ----------
  2678. def eat(self):
  2679. for f in FOODS:
  2680. if self.count(f) > 0:
  2681. self.hold(f)
  2682. self.do({"k": "eat"}, 6, reflex=False)
  2683. return True
  2684. return False
  2685. def fight(self, e, timeout=25):
  2686. self.hold_best("sword")
  2687. t0 = time.time()
  2688. while e["id"] in self.entities and time.time() - t0 < timeout and not self.stop.is_set() and not self.dead:
  2689. if any(x["name"] == "creeper" and math.hypot(x["x"] - self.x, x["z"] - self.z) < 8
  2690. for x in list(self.entities.values())):
  2691. return
  2692. r = self.do({"k": "attack", "eid": e["id"]}, 10, reflex=False)
  2693. if r == "blocked":
  2694. p = self.plan_path("near", e["x"], e["y"], e["z"], 2.0, False)
  2695. if p and len(p) > 1:
  2696. self.run_path(p, 4, True)
  2697. else:
  2698. break
  2699. elif r in ("stopped", "teleport", "dead"):
  2700. return
  2701. if e["id"] in self.entities: # не вдалось добити/дістати - на 30 с забуваємо про нього
  2702. self.ign_ent[e["id"]] = time.time() + 30
  2703. def flee(self, e):
  2704. self.do({"k": "flee", "eid": e["id"], "end": self.clock + 6.0}, 10, reflex=False)
  2705. def reflex(self):
  2706. if self.dead:
  2707. time.sleep(1.0)
  2708. return True
  2709. ents = list(self.entities.values())
  2710. for e in ents:
  2711. if e["name"] == "creeper" and math.hypot(e["x"] - self.x, e["z"] - self.z) < 8:
  2712. self.log("кріпер! тікаю")
  2713. self.flee(e)
  2714. return True
  2715. best, bd = None, 1e9
  2716. for e in ents:
  2717. d = math.hypot(e["x"] - self.x, e["z"] - self.z)
  2718. if d < 7 and abs(e["y"] - self.y) < 4 and self.is_enemy(e) and d < bd:
  2719. best, bd = e, d
  2720. if best:
  2721. self.fight(best)
  2722. return True
  2723. if self.food <= 14 and self.has_food():
  2724. return self.eat()
  2725. return False
  2726. def hunt(self):
  2727. ents = [e for e in list(self.entities.values()) if e["name"] in FOOD_ANIMALS
  2728. and self.ign_ent.get(e["id"], 0) < time.time()
  2729. and math.hypot(e["x"] - self.x, e["z"] - self.z) < 60]
  2730. if not ents:
  2731. return self.explore()
  2732. e = min(ents, key=lambda e: math.hypot(e["x"] - self.x, e["z"] - self.z))
  2733. self.log(f"полюю: {e['name']}")
  2734. self.fight(e, 40)
  2735. self.collect_items()
  2736. if self.food <= 16:
  2737. self.eat()
  2738. return True
  2739. def random_dig(self):
  2740. w, b = self.world, self.m.binfo
  2741. fy = math.floor(self.y + 1e-3)
  2742. ox, oz = math.floor(self.x), math.floor(self.z)
  2743. cells = [(ox + random.randint(-3, 3), fy + random.randint(0, 2), oz + random.randint(-3, 3)) for _ in range(30)]
  2744. for c in cells:
  2745. s = w.state_at(*c)
  2746. if s is None or not b.flags(s) & SOLID or b.hardness(s) < 0:
  2747. continue
  2748. if any(w.flags(c[0] + a, c[1] + d, c[2] + e) & (WATER | DANGER) for a, d, e in NB6):
  2749. continue
  2750. if not self.visible_face(c):
  2751. continue
  2752. self.hold_for_state(s)
  2753. h = self.hold_item()
  2754. if b.dig_ticks(s, h["name"] if h else None, h["id"] if h else None) > 150:
  2755. continue
  2756. if self.mine_block(c):
  2757. self.collect_items()
  2758. return True
  2759. return False
  2760. def free_roam(self):
  2761. if not self.explore():
  2762. time.sleep(1.0)
  2763. if random.random() < 0.6:
  2764. self.random_dig()
  2765. # ---------- мозок ----------
  2766. def brain(self, stop):
  2767. self.bad, self.ignore_items, self.ign_ent = {}, set(), {}
  2768. self.visit, self.tun_dir, self.wd_skip = [], None, 0.0
  2769. self.table_pos = self.furnace_pos = None
  2770. self.tier_fail, self.skip_until = {}, {}
  2771. self.heading = random.uniform(0, 2 * math.pi)
  2772. 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)):
  2773. stop.wait(0.5)
  2774. stop.wait(2.0)
  2775. if self.gamemode == 1:
  2776. self.log("УВАГА: бот у creative - smart-режим потребує survival (/gamemode survival {name})")
  2777. self.log("smart: старт")
  2778. wd_t, wd_p = time.time(), (self.x, self.y, self.z)
  2779. while not stop.is_set():
  2780. try:
  2781. if time.time() - wd_t > 60: # сторожовий таймер: майже не рухався хвилину - вириваємось
  2782. moved = math.sqrt((self.x - wd_p[0]) ** 2 + (self.y - wd_p[1]) ** 2 + (self.z - wd_p[2]) ** 2)
  2783. if moved < 3 and time.time() > self.wd_skip and not self.dead:
  2784. self.unstick()
  2785. wd_t, wd_p = time.time(), (self.x, self.y, self.z)
  2786. if self.dead:
  2787. stop.wait(1.0)
  2788. continue
  2789. if self.reflex():
  2790. continue
  2791. if self.food <= 12 and not self.has_food() and self.hunt():
  2792. continue
  2793. if self.tool_progress():
  2794. continue
  2795. self.free_roam()
  2796. except Exception as e:
  2797. self.log(f"smart помилка: {type(e).__name__}: {e}")
  2798. if self.m.debug:
  2799. traceback.print_exc()
  2800. stop.wait(1.0)
  2801. class Bot(BotBase, Smart):
  2802. pass
  2803. # ======================================================================
  2804. # Менеджер ботів
  2805. # ======================================================================
  2806. class Manager:
  2807. def __init__(self, args, proto, commands, binfo, ents, items, comp_names):
  2808. self.host, self.port, self.proto = args.host, args.port, proto
  2809. self.prefix, self.delay, self.debug = args.prefix, args.delay, args.debug
  2810. self.commands = commands
  2811. self.cmd_delay, self.join_wait, self.loop = args.cmd_delay, args.join_wait, args.loop
  2812. self.random_names, self.random_uuid = args.random_names, args.random_uuid
  2813. self.reconnect, self.reconnect_delay = args.reconnect_on_kick, args.reconnect_delay
  2814. self.max_reconnects = args.max_reconnects
  2815. self.no_register_on_reconnect = args.no_register_on_reconnect
  2816. self.view_distance = args.view_distance
  2817. self.binfo, self.ents, self.items, self.comp_names = binfo, ents, items, comp_names
  2818. self.smart = bool(args.smart and binfo is not None)
  2819. self.pvp = not args.no_pvp
  2820. self.verbose = not args.quiet
  2821. self.log_names = binfo.names_where(lambda n: n.endswith("_log")) if binfo else []
  2822. self.bots = {}
  2823. self.name_by_uuid = {}
  2824. self.bot_uuids = set()
  2825. self.counter = 0
  2826. self.log_target = None
  2827. def should_log(self, name):
  2828. return self.log_target == "all" or self.log_target == name
  2829. def add(self, n):
  2830. def worker():
  2831. for _ in range(n):
  2832. self.counter += 1
  2833. name = (random_name(set(self.bots)) if self.random_names else f"{self.prefix}{self.counter}")
  2834. bot = Bot(name, self.counter, self)
  2835. self.bots[name] = bot
  2836. self.name_by_uuid[bot.srv_uuid] = name
  2837. self.bot_uuids.add(bot.srv_uuid)
  2838. self.bot_uuids.add(bot.login_uuid)
  2839. if self.log_target is None:
  2840. self.log_target = name
  2841. threading.Thread(target=bot.run, daemon=True).start()
  2842. time.sleep(self.delay)
  2843. threading.Thread(target=worker, daemon=True).start()
  2844. def say(self, target, message):
  2845. if target.lower() == "all":
  2846. for bot in list(self.bots.values()):
  2847. bot.say(message)
  2848. elif target in self.bots:
  2849. self.bots[target].say(message)
  2850. else:
  2851. print(f"Немає бота '{target}'. Напиши 'list'.")
  2852. def run_all(self):
  2853. for bot in list(self.bots.values()):
  2854. threading.Thread(target=bot.run_commands, daemon=True).start()
  2855. def kick(self, name):
  2856. bot = self.bots.pop(name, None)
  2857. if bot:
  2858. bot.disconnect()
  2859. print(f"{name} відключений")
  2860. else:
  2861. print(f"Немає бота '{name}'")
  2862. def list(self):
  2863. for name, bot in self.bots.items():
  2864. pos = f" @ {bot.x:.0f} {bot.y:.0f} {bot.z:.0f}" if bot.joined and bot.x is not None else ""
  2865. extra = ""
  2866. if self.smart and bot.joined:
  2867. h = bot.hold_item()
  2868. extra = f" | hp {bot.health:.0f} їжа {bot.food} | в руці: {h['name'] if h else '-'}"
  2869. print(f" {name}: {bot.status}{pos}{extra}")
  2870. print(f"Всього: {len(self.bots)}")
  2871. def shutdown(self):
  2872. for bot in list(self.bots.values()):
  2873. bot.disconnect()
  2874. def load_commands(args):
  2875. cmds = list(args.cmd or [])
  2876. if args.cmds_file:
  2877. with open(args.cmds_file, encoding="utf-8") as f:
  2878. cmds += [l.strip() for l in f if l.strip() and not l.startswith("#")]
  2879. return cmds
  2880. def main():
  2881. ap = argparse.ArgumentParser(description="Тестові боти Minecraft (offline, 1.20.2+)")
  2882. ap.add_argument("--host", default="127.0.0.1")
  2883. ap.add_argument("--port", type=int, default=25565)
  2884. ap.add_argument("--count", type=int, default=1, help="кількість ботів")
  2885. ap.add_argument("--prefix", default="Bot", help="префікс імені (Bot1, Bot2...)")
  2886. ap.add_argument("--random-names", action="store_true", help="випадкові ніки")
  2887. ap.add_argument("--random-uuid", action="store_true", help="слати випадковий UUID у login")
  2888. ap.add_argument("--delay", type=float, default=1.5, help="пауза між входами ботів, сек")
  2889. ap.add_argument("--version", default=None, help="версія клієнта (напр. 1.21.9) або номер протоколу")
  2890. ap.add_argument("--list-versions", action="store_true", help="показати доступні версії")
  2891. ap.add_argument("--cmd", action="append", help="команда/повідомлення після входу ({name}, {n})")
  2892. ap.add_argument("--cmds-file", help="файл з командами, по одній на рядок (# - коментар)")
  2893. ap.add_argument("--join-wait", type=float, default=3.0, help="пауза після входу перед командами, сек")
  2894. ap.add_argument("--cmd-delay", type=float, default=1.0, help="пауза між командами, сек")
  2895. ap.add_argument("--loop", type=float, default=0, help="повторювати команди кожні N секунд (0 = раз)")
  2896. ap.add_argument("--reconnect-on-kick", action="store_true", help="перепідключати бота після кіку/обриву")
  2897. ap.add_argument("--reconnect-delay", type=float, default=5.0, help="пауза перед перепідключенням, сек")
  2898. ap.add_argument("--max-reconnects", type=int, default=0, help="макс. сесій на бота (0 = без ліміту)")
  2899. ap.add_argument("--no-register-on-reconnect", action="store_true",
  2900. help="не слати /register повторно, якщо бот уже реєструвався")
  2901. ap.add_argument("--smart", action="store_true",
  2902. help="розумний бот (survival): фізика, інструменти, їжа, бої, добування. "
  2903. "Без цього прапорця бот - простий клієнт без фізики й мозку")
  2904. ap.add_argument("--no-pvp", action="store_true", help="(smart) не атакувати гравців, лише мобів")
  2905. ap.add_argument("--quiet", action="store_true", help="(smart) не друкувати рішення бота (план, шлях, копання)")
  2906. ap.add_argument("--view-distance", type=int, default=8, help="(smart) дальність прогрузки чанків")
  2907. ap.add_argument("--debug", action="store_true", help="показувати пакети (для діагностики)")
  2908. args = ap.parse_args()
  2909. dp, avail = load_versions()
  2910. if args.list_versions:
  2911. print("Доступні версії (1.20.2+):")
  2912. print(", ".join(sorted(avail, key=vkey)))
  2913. return
  2914. detected = None
  2915. if not args.version:
  2916. try:
  2917. detected, sname = ping_server(args.host, args.port)
  2918. print(f"Сервер: {sname} (протокол {detected})")
  2919. except Exception as e:
  2920. raise SystemExit(f"Не вдалось отримати версію сервера ({e}). Вкажи --version вручну.")
  2921. version = pick_version(args.version, detected, avail)
  2922. proto = Protocol(version, avail[version], dp)
  2923. binfo = ents = items = None
  2924. comp_names = {}
  2925. if args.smart:
  2926. try:
  2927. binfo = BlockInfo(fetch_json(f"{dp[version]['blocks']}/blocks.json"))
  2928. ents = build_entities(fetch_json(f"{dp[version]['entities']}/entities.json"))
  2929. items = ItemInfo(fetch_json(f"{dp[version]['items']}/items.json"))
  2930. comp_names = find_comp_map(proto.p) or {}
  2931. if proto.number >= 766 and not comp_names:
  2932. print("Увага: не знайдено карту компонентів предметів - інвентар може читатись неповно.")
  2933. except (KeyError, SystemExit):
  2934. print("Не вдалось завантажити дані блоків/предметів - smart вимкнено.")
  2935. binfo = ents = items = None
  2936. commands = load_commands(args)
  2937. mgr = Manager(args, proto, commands, binfo, ents, items, comp_names)
  2938. print(f"Версія клієнта: {version} (протокол {proto.number}) | команд при старті: {len(commands)} "
  2939. f"| режим: {'SMART (потрібен survival)' if mgr.smart else 'простий клієнт'}")
  2940. print(HELP)
  2941. mgr.add(args.count)
  2942. try:
  2943. while True:
  2944. line = input("> ").strip()
  2945. if not line:
  2946. continue
  2947. cmd, _, rest = line.partition(" ")
  2948. if cmd == "quit":
  2949. break
  2950. elif cmd == "list":
  2951. mgr.list()
  2952. elif cmd == "inv":
  2953. b = mgr.bots.get(rest.strip())
  2954. print(b.inv_str() if b and mgr.smart else "немає такого бота або не smart")
  2955. elif cmd == "run":
  2956. mgr.run_all()
  2957. elif cmd == "add":
  2958. mgr.add(int(rest or 1))
  2959. elif cmd == "kick":
  2960. mgr.kick(rest)
  2961. elif cmd == "log":
  2962. mgr.log_target = rest.strip() or "all"
  2963. print("лог чату:", mgr.log_target)
  2964. elif rest:
  2965. mgr.say(cmd, rest)
  2966. else:
  2967. print("Формат: <all|ім'я> <текст або /команда>")
  2968. except (KeyboardInterrupt, EOFError):
  2969. pass
  2970. finally:
  2971. mgr.shutdown()
  2972. print("Вимкнено.")
  2973. if __name__ == "__main__":
  2974. main()