hackCraft2のドキュメントへようこそ！======================================

class py2hackCraft.modules.Block(name: str, type: str = 'block', data: int = 0, isLiquid: bool = False, isAir: bool = False, isBurnable: bool = False, isFuel: bool = False, isOccluding: bool = False, isSolid: bool = False, isPassable: bool = False, x: int = 0, y: int = 0, z: int = 0, world: str = 'world')

ブロックを表すデータクラス

Category:: データクラス

name

ブロックの種類

Type:: str

data

ブロックのデータ値

Type:: int

isLiquid

液体ブロックかどうか

Type:: bool

isAir

空気ブロックかどうか

Type:: bool

isBurnable

燃えるブロックかどうか

Type:: bool

isFuel

燃料ブロックかどうか

Type:: bool

isOccluding

透過しないブロックかどうか

Type:: bool

isSolid

壁のあるブロックかどうか

Type:: bool

isPassable

通過可能なブロックかどうか

Type:: bool

world

ブロックが存在するワールドの名前（デフォルトは"world"）

Type:: str

x

ブロックのX座標

Type:: int

y

ブロックのY座標

Type:: int

z

ブロックのZ座標

Type:: int

class py2hackCraft.modules.ChatMessage(player: str, uuid: str, entityUuid: str, message: str)

チャットメッセージを表すデータクラス

Category:: イベントクラス

player

プレイヤー名

Type:: str

uuid

プレイヤーの一意の識別子（UUID）

Type:: str

entityUuid

チャットを送信したエンティティの一意の識別子（UUID）

Type:: str

message

プレイヤーがチャットで送信したメッセージの内容

Type:: str

class py2hackCraft.modules.Coord(x: int, y: int, z: int, cord: str)

座標を表す名前付きタプル

Category:: データクラス

x

X座標

Type:: int

y

Y座標

Type:: int

z

Z座標

Type:: int

cord

座標系 ("": 絶対座標, "~": 相対座標, "^": ローカル座標)

Type:: str

cord: str: Alias for field number 3

x: int: Alias for field number 0

y: int: Alias for field number 1

z: int: Alias for field number 2

class py2hackCraft.modules.Entity(client: _WebSocketClient, world: str, uuid: str)

エンティティを表すクラス

Category:: 基本クラス

action() → bool

自分の前方の装置を使う

戻り値:: 操作が成功した場合はTrue、失敗した場合はFalse
戻り値の型:: bool

action_down() → bool

自分の真下の装置を使う

戻り値:: 操作が成功した場合はTrue、失敗した場合はFalse
戻り値の型:: bool

action_up() → bool

自分の真上の装置を使う

戻り値:: 操作が成功した場合はTrue、失敗した場合はFalse
戻り値の型:: bool

add_force(x: float, y: float, z: float) → bool

エンティティに力を加えて移動させる

パラメータ:

x (float) -- X軸方向の力（正の値で東方向、負の値で西方向）
y (float) -- Y軸方向の力（正の値で上方向、負の値で下方向）
z (float) -- Z軸方向の力（正の値で南方向、負の値で北方向）

戻り値:

操作が成功した場合はTrue、失敗した場合はFalse

戻り値の型:

bool

サンプル

# 東方向に力を加える
entity.add_force(1.0, 0.0, 0.0)

# 上方向にジャンプするような力を加える
entity.add_force(0.0, 1.0, 0.0)

attack() → bool

自分の前方を攻撃する

戻り値:: 操作が成功した場合はTrue、失敗した場合はFalse
戻り値の型:: bool

back(n=1) → bool

n歩後ろに進む

パラメータ:: n (int, optional) -- 進む歩数. デフォルトは1.
戻り値:: 移動が成功した場合はTrue、失敗した場合はFalse
戻り値の型:: bool

can_dig() → bool: 自分の前方のブロックが壊せるかどうか調べる :returns: 調べた結果 :rtype: bool

can_dig_down() → bool: 自分の下のブロックが壊せるかどうか調べる :returns: 調べた結果 :rtype: bool

can_dig_up() → bool: 自分の上のブロックが壊せるかどうか調べる :returns: 調べた結果 :rtype: bool

craft(recipe, qty=1, slot=None)

ペットのインベントリにある材料を使ってアイテムをクラフトする。

引数:

recipe: レシピパターン（文字列またはリスト形式）

文字列形式: "1,1,1,X,2,X,X,2,X" （カンマ区切りのスロット番号、空は X または空文字）
リスト形式: [1,1,1,"X",2,"X","X",2,"X"] または [1,1,1,None,2,None,None,2,None]
スロット番号は0から始まる（0=スロット1）
負の数(-1など)も空気として扱われる

qty: クラフトする個数（デフォルト: 1） slot: 結果を配置するスロット番号（デフォルト: None = 自動配置）

戻り値:

dict: クラフト結果（以下の構造）

{: "success": bool, # 成功したか "result_item": str | None, # 作成されたアイテム名 "result_quantity": int | None,# 作成された個数 "requested_quantity": int, # リクエストした個数 "result_slot": int | None, # 配置されたスロット "materials_consumed": dict, # 消費された材料 "game_mode": str, # ゲームモード "error": dict | None # エラー情報

}

使用例:

>>> # パンをクラフト（スロット0に小麦3つ）
>>> result = entity.craft("0,0,0")
>>> if result["success"]:
>>>     print(f"{result['result_item']}を{result['result_quantity']}個作ったよ！")

>>> # リスト形式でつるはしをクラフト
>>> result = entity.craft([3,3,3,"X",4,"X","X",4,"X"])

>>> # 複数個クラフトして、スロット10に配置
>>> result = entity.craft("0,0,0", qty=5, slot=10)

>>> # エラー処理
>>> result = entity.craft("0,0,0")
>>> if not result["success"]:
>>>     error = result["error"]
>>>     print(f"エラー: {error['message']}")
>>>     if error["code"] == "INSUFFICIENT_MATERIALS":
>>>         print("材料が足りないよ")

dig() → bool

自分の前方のブロックを壊す

戻り値:: 操作が成功した場合はTrue、失敗した場合はFalse
戻り値の型:: bool

dig_at(loc: Location) → bool

指定した座標のブロックを壊す

パラメータ:: loc (Location) -- 座標情報（LocationFactory.absolute/relative/localで生成）
戻り値:: 操作が成功した場合はTrue、失敗した場合はFalse
戻り値の型:: bool

サンプル

# 絶対座標(100, 64, -200)のブロックを壊す
loc = LocationFactory.absolute(100, 64, -200)
entity.dig_at(loc)

# 自分の東10ブロック、北5ブロックの位置のブロックを壊す
loc = LocationFactory.relative(10, 0, -5)
entity.dig_at(loc)

# 自分の真上5ブロックの位置のブロックを壊す
loc = LocationFactory.local(0, 5, 0)
entity.dig_at(loc)

dig_down() → bool

自分の真下のブロックを壊す

戻り値:: 操作が成功した場合はTrue、失敗した場合はFalse
戻り値の型:: bool

dig_up() → bool

自分の真上のブロックを壊す

戻り値:: 操作が成功した場合はTrue、失敗した場合はFalse
戻り値の型:: bool

down(n=1) → bool

n歩下に進む

パラメータ:: n (int, optional) -- 進む歩数. デフォルトは1.
戻り値:: 移動が成功した場合はTrue、失敗した場合はFalse
戻り値の型:: bool

drop_item(slot1: int) → bool

自分のインベントリのアイテムを落とす

パラメータ:: slot1 (int) -- 落とすアイテムのスロット番号
戻り値:: 操作が成功した場合はTrue、失敗した場合はFalse
戻り値の型:: bool

execute_command(command: str)

コマンドを実行する

パラメータ:: command (str) -- 実行するコマンドの内容

facing(angle: int)

エンティティを指定した方角に向かせる

パラメータ:: angle (int) -- 向く方角（度数法） - 0: 南 - 90: 西 - 180: 北 - 270: 東
戻り値:: None

サンプル

# 北を向く
entity.facing(180)

# 東を向く
entity.facing(270)

fertilizer() → bool

自分の足元の作物に肥料（骨粉）を与える常に無限で、インベントリチェックなし (0, -1, 0) または (0, 0, 0) の位置にある作物に肥料を与えます

戻り値:: 肥料を与えるのが成功した場合はTrue、失敗した場合はFalse
戻り値の型:: bool

fertilizer_at(loc: Location) → bool

指定した座標の作物に肥料（骨粉）を与える常に無限で、インベントリチェックなし指定された位置にある作物に肥料を与えます

パラメータ:: loc (Location) -- 座標情報（LocationFactory.absolute/relative/localで生成）
戻り値:: 肥料を与えるのが成功した場合はTrue、失敗した場合はFalse
戻り値の型:: bool

サンプル

# 絶対座標(100, 64, -200)の作物に肥料を与える
loc = LocationFactory.absolute(100, 64, -200)
entity.fertilizer_at(loc)

# 自分の足元の作物に肥料を与える
loc = LocationFactory.local(0, -1, 0)
entity.fertilizer_at(loc)

find_nearby_block_at(loc: Location, block: str, max_depth: int) → Block | None

指定された座標を中心に近くのブロックを取得する

パラメータ:

loc (Location) -- 座標情報（LocationFactory.absolute/relative/localで生成）
block (str) -- ブロックの名前( "water:0" など)
max_depth (int) -- 探索する最大の深さ

戻り値:

見つかったブロックの情報、見つからなかった場合はNone

戻り値の型:

Optional[Block]

flatten_at(loc: Location) → bool

指定した座標のブロックを平らにする

パラメータ:: loc (Location) -- 座標情報（LocationFactory.absolute/relative/localで生成）
戻り値:: 操作が成功した場合はTrue、失敗した場合はFalse
戻り値の型:: bool

forward(n=1) → bool

n歩前に進む

パラメータ:: n (int, optional) -- 進む歩数. デフォルトは1.
戻り値:: 移動が成功した場合はTrue、失敗した場合はFalse
戻り値の型:: bool

get_block(loc: Location) → Block

指定した座標のブロック情報を取得する

パラメータ:: loc (Location) -- 座標情報（LocationFactory.absolute/relative/localで生成）
戻り値:: ブロックの情報（種類、データ値、座標）
戻り値の型:: Block

サンプル

# 絶対座標(100, 64, -200)のブロック情報を取得
loc = LocationFactory.absolute(100, 64, -200)
block = entity.get_block(loc)
print(f"ブロック: {block.name}, データ値: {block.data}")

# 自分の東10ブロックの位置のブロック情報を取得
loc = LocationFactory.relative(10, 0, 0)
block = entity.get_block(loc)
print(f"ブロック: {block.name}, データ値: {block.data}")

get_block_by_color(color: str) → Block

指定された色に最も近いブロックを取得する

パラメータ:: color (str) -- ブロックの色（HexRGB形式、例: "#FF0000"で赤）色は16進数のRGB値で指定（#RRGGBB形式）
戻り値:: 指定された色に最も近いブロックの情報
戻り値の型:: Block

サンプル

# 赤色に近いブロックを取得
block = entity.get_block_by_color("#FF0000")
print(f"ブロック: {block.name}, データ値: {block.data}")

# 青色に近いブロックを取得
block = entity.get_block_by_color("#0000FF")
print(f"ブロック: {block.name}, データ値: {block.data}")

get_block_by_name(name: str) → Block

指定された名前のブロックを取得する

パラメータ:: name (str) -- ブロックの名前（例: "stone", "dirt", "oak_planks"）データ値が必要な場合は "block:data" の形式で指定例: "stone:1"（花崗岩）, "wool:14"（赤の羊毛）
戻り値:: 指定された名前のブロックの情報
戻り値の型:: Block

サンプル

# 石ブロックを取得
block = entity.get_block_by_name("stone")
print(f"ブロック: {block.name}, データ値: {block.data}")

# 花崗岩を取得
block = entity.get_block_by_name("stone:1")
print(f"ブロック: {block.name}, データ値: {block.data}")

get_distance() → float

自分と前方のなにかとの距離を調べる

戻り値:: 前方の物体との距離
戻り値の型:: float

get_distance_down() → float

自分と真下のなにかとの距離を調べる

戻り値:: 真下の物体との距離
戻り値の型:: float

get_distance_target(uuid) → float

自分とターゲットとの距離を調べる

パラメータ:: uuid (str) -- ターゲットのUUID
戻り値:: ターゲットとの距離
戻り値の型:: float

get_distance_up() → float

自分と真上のなにかとの距離を調べる

戻り値:: 真上の物体との距離
戻り値の型:: float

get_item(slot: int) → ItemStack

自分のインベントリからアイテムを取得する

パラメータ:: slot (int) -- 取得するアイテムのスロット番号

get_location() → Location: 自分の現在位置を調べる :returns: 調べた位置情報 :rtype: Location

harvest() → bool

自分の位置または足元の作物を収穫する (0, 0, 0) または (0, -1, 0) の位置にある収穫可能な作物を自動的に収穫します

戻り値:: 収穫が成功した場合はTrue、失敗した場合はFalse
戻り値の型:: bool

harvest_at(loc: Location) → bool

指定した座標の作物を収穫する常に無限で、インベントリチェックなし指定された位置にある収穫可能な作物を収穫します

パラメータ:: loc (Location) -- 座標情報（LocationFactory.absolute/relative/localで生成）
戻り値:: 収穫が成功した場合はTrue、失敗した場合はFalse
戻り値の型:: bool

サンプル

# 絶対座標(100, 64, -200)の作物を収穫
loc = LocationFactory.absolute(100, 64, -200)
entity.harvest_at(loc)

# 自分の足元の作物を収穫
loc = LocationFactory.local(0, -1, 0)
entity.harvest_at(loc)

inspect() → Block

自分の前方のブロックを調べる

戻り値:: 調べたブロックの情報
戻り値の型:: Block

inspect_at(loc: Location) → Block

指定された座標のブロックを調べる

パラメータ:: loc (Location) -- 座標情報（LocationFactory.absolute/relative/localで生成）
戻り値:: 調べたブロックの情報
戻り値の型:: Block

inspect_down() → Block

自分の足元のブロックを調べる

戻り値:: 調べたブロックの情報
戻り値の型:: Block

inspect_up() → Block

真上のブロックを調べる

戻り値:: 調べたブロックの情報
戻り値の型:: Block

is_blocked() → bool: 自分の前方にブロックがあるかどうか調べる :returns: 調べた結果 :rtype: bool

is_blocked_down() → bool: 自分の真下にブロックがあるかどうか調べる :returns: 調べた結果 :rtype: bool

is_blocked_up() → bool: 自分の真上にブロックがあるかどうか調べる :returns: 調べた結果 :rtype: bool

is_event_area(loc: Location) → bool

指定された座標がイベント検出範囲内かどうかを判定する

パラメータ:: loc (Location) -- 座標情報（LocationFactory.absolute/relative/localで生成）
戻り値:: 指定された座標がイベント検出範囲内の場合はTrue、そうでない場合はFalse
戻り値の型:: bool

サンプル

# 絶対座標(100, 64, -200)がイベント検出範囲内かどうかを判定
loc = LocationFactory.absolute(100, 64, -200)
entity.is_event_area(loc)

# 自分の東10ブロック、北5ブロックの位置がイベント検出範囲内かどうかを判定
loc = LocationFactory.relative(10, 0, -5)
entity.is_event_area(loc)

# 自分の真上5ブロックの位置がイベント検出範囲内かどうかを判定
loc = LocationFactory.local(0, 5, 0)
entity.is_event_area(loc)

jump()

ジャンプさせる

戻り値:: None

livestock_count_nearby(animal_type: str = 'ALL', radius: float = 50.0) → int

近くの動物を数える

パラメータ:

animal_type (str) -- 動物種別（COW, PIG, SHEEP, CHICKEN, RABBIT, HORSE, ALL）
radius (float) -- 検索半径（ブロック数）

戻り値:

動物の数

戻り値の型:

int

サンプル

>>> count = entity.livestock_count_nearby("COW", 50)
>>> print(f"Found {count} cows")

livestock_feed(animal_uuid: str, food_type: str = 'wheat') → None

動物に餌をやる

パラメータ:

animal_uuid (str) -- 動物のUUID
food_type (str) -- 餌種別（wheat, carrot, seeds, beetroot）

サンプル

>>> entity.livestock_feed(cow_uuid, "wheat")

livestock_find_nearby(animal_type: str = 'ALL', radius: float = 50.0) → list

近くの動物を詳細情報付きで検索

パラメータ:

animal_type (str) -- 動物種別（COW, PIG, SHEEP, CHICKEN, RABBIT, HORSE, ALL）
radius (float) -- 検索半径（ブロック数）

戻り値:

動物情報の辞書リスト

戻り値の型:

list

サンプル

>>> animals = entity.livestock_find_nearby("SHEEP", 30)
>>> for animal in animals:
>>>     print(f"{animal['animalType']} at distance {animal['distance']}")

livestock_get_info(animal_uuid: str) → dict

動物の詳細情報を取得

パラメータ:: animal_uuid (str) -- 動物のUUID
戻り値:: 動物の詳細情報
戻り値の型:: dict

サンプル

>>> info = entity.livestock_get_info(cow_uuid)
>>> print(f"Health: {info['health']}/{info['maxHealth']}")
>>> print(f"Can breed: {info['canBreed']}")

livestock_get_nearest_uuid(animal_type: str = 'ALL', radius: float = 50.0) → str | None

最も近い動物のUUIDを取得

パラメータ:

animal_type (str) -- 動物種別（COW, PIG, SHEEP, CHICKEN, RABBIT, HORSE, ALL）
radius (float) -- 検索半径（ブロック数）

戻り値:

動物のUUID（見つからない場合はNone）

戻り値の型:

Optional[str]

サンプル

>>> cow_uuid = entity.livestock_get_nearest_uuid("COW", 50)
>>> if cow_uuid:
>>>     print(f"Found cow: {cow_uuid}")

livestock_herd(animal_uuid: str, x: float, y: float, z: float, cord: str = '^', speed: float = 1.0) → None

動物を指定座標に誘導

パラメータ:

animal_uuid (str) -- 動物のUUID
x (float) -- 目標X座標
y (float) -- 目標Y座標
z (float) -- 目標Z座標
cord (str) -- 座標系（"": 絶対座標, "~": 相対座標, "^": ローカル座標、デフォルト: "^"）
speed (float) -- 移動速度（0.5-2.0、デフォルト1.0）

サンプル

>>> entity.livestock_herd(cow_uuid, 100, 64, 200, "^", 1.0)

livestock_herd_all_nearby(animal_type: str, radius: float, x: float, y: float, z: float, cord: str = '^', speed: float = 1.0) → int

近くの動物すべてを指定座標に誘導

パラメータ:

animal_type (str) -- 動物種別（COW, PIG, SHEEP, CHICKEN, RABBIT, HORSE, ALL）
radius (float) -- 検索半径（ブロック数）
x (float) -- 目標X座標
y (float) -- 目標Y座標
z (float) -- 目標Z座標
cord (str) -- 座標系（"": 絶対座標, "~": 相対座標, "^": ローカル座標、デフォルト: "^"）
speed (float) -- 移動速度（0.5-2.0、デフォルト1.0）

戻り値:

誘導した動物の数

戻り値の型:

int

サンプル

>>> count = entity.livestock_herd_all_nearby("COW", 50, 100, 64, 200)
>>> print(f"Herded {count} cows")

livestock_milk(cow_uuid: str) → dict

牛のミルクを搾る

パラメータ:: cow_uuid (str) -- 牛のUUID
戻り値:: ミルク情報 {milk, amount}
戻り値の型:: dict
例外:: Exception -- 牛以外の動物の場合

サンプル

>>> try:
>>>     result = entity.livestock_milk(cow_uuid)
>>>     print(f"Got {result['amount']} milk bucket")
>>> except Exception as e:
>>>     print(f"Cannot milk: {e}")

livestock_shear(sheep_uuid: str) → dict

羊の毛を刈る

パラメータ:: sheep_uuid (str) -- 羊のUUID
戻り値:: 羊毛情報 {wool, color, amount}
戻り値の型:: dict
例外:: Exception -- 羊毛が生えていない、または羊以外の動物の場合

サンプル

>>> try:
>>>     result = entity.livestock_shear(sheep_uuid)
>>>     print(f"Got {result['amount']} {result['color']} wool")
>>> except Exception as e:
>>>     print(f"Cannot shear: {e}")

make_sound() → bool

鳴かせる

戻り値:: 操作が成功した場合はTrue、失敗した場合はFalse
戻り値の型:: bool

move_item(slot1: int, slot2: int) → bool

自分のインベントリのアイテムを移動させる

パラメータ:

slot1 (int) -- 移動元のスロット番号
slot2 (int) -- 移動先のスロット番号

戻り値:

操作が成功した場合はTrue、失敗した場合はFalse

戻り値の型:

bool

open_inventory(loc: Location) → Inventory

指定された座標のインベントリ（チェストなど）を開く

パラメータ:: loc (Location) -- 座標情報（LocationFactory.absolute/relative/localで生成）
戻り値:: 開いたインベントリの操作オブジェクト
戻り値の型:: Inventory

サンプル

# 絶対座標(100, 64, -200)のチェストを開く
loc = LocationFactory.absolute(100, 64, -200)
chest = entity.open_inventory(loc)

# インベントリ内のアイテムを取得
items = chest.get_all_items()

# アイテムを移動
chest.move_item(0, 1)

pickup_items_at(loc: Location) → int

指定した座標の周辺のアイテムを拾う

パラメータ:: loc (Location) -- 座標情報（LocationFactory.absolute/relative/localで生成）
戻り値:: 拾ったアイテムの数
戻り値の型:: int

place(side=None) → bool

自分の前方にブロックを設置する

パラメータ:

side (str, optional) --

ブロックを設置する面 - Side.right: 右面 - Side.left: 左面 - Side.front: 前面 - Side.back: 後面 - Side.top: 上面 - Side.bottom: 下面

Noneの場合は自動的に適切な面を選択

戻り値:

設置が成功した場合はTrue、失敗した場合はFalse

戻り値の型:

bool

サンプル

# 前方にブロックを設置
entity.place()

# 前方のブロックを右面に設置
entity.place(Side.right)

place_at(loc: Location, side=None) → bool

指定した座標にブロックを設置する

パラメータ:

loc (Location) -- 座標情報（LocationFactory.absolute/relative/localで生成）
side (str, optional) --
ブロックを設置する面 - Side.right: 右面 - Side.left: 左面 - Side.front: 前面 - Side.back: 後面 - Side.top: 上面 - Side.bottom: 下面

Noneの場合は自動的に適切な面を選択

戻り値:

設置が成功した場合はTrue、失敗した場合はFalse

戻り値の型:

bool

サンプル

# 絶対座標(100, 64, -200)にブロックを設置
loc = LocationFactory.absolute(100, 64, -200)
entity.place_at(loc)

# 自分の東10ブロックの位置にブロックを右面に設置
loc = LocationFactory.relative(10, 0, 0)
entity.place_at(loc, Side.right)

place_down(side=None) → bool

自分の真下にブロックを設置する

パラメータ:

side (str, optional) --

ブロックを設置する面 - Side.right: 右面 - Side.left: 左面 - Side.front: 前面 - Side.back: 後面 - Side.top: 上面 - Side.bottom: 下面

Noneの場合は自動的に適切な面を選択

戻り値:

設置が成功した場合はTrue、失敗した場合はFalse

戻り値の型:

bool

サンプル

# 真下にブロックを設置
entity.place_down()

# 真下のブロックを下面に設置
entity.place_down(Side.bottom)

place_up(side=None) → bool

自分の真上にブロックを設置する

パラメータ:

side (str, optional) --

ブロックを設置する面 - Side.right: 右面 - Side.left: 左面 - Side.front: 前面 - Side.back: 後面 - Side.top: 上面 - Side.bottom: 下面

Noneの場合は自動的に適切な面を選択

戻り値:

設置が成功した場合はTrue、失敗した場合はFalse

戻り値の型:

bool

サンプル

# 真上にブロックを設置
entity.place_up()

# 真上のブロックを上面に設置
entity.place_up(Side.top)

plant() → bool

自分の足元に作物を植える常に無限で、インベントリチェックなし (0, -1, 0) の位置にある耕地に作物を植えます

戻り値:: 植えるのが成功した場合はTrue、失敗した場合はFalse
戻り値の型:: bool

plant_at(loc: Location) → bool

指定した座標のブロックに植物を植える

パラメータ:: loc (Location) -- 座標情報（LocationFactory.absolute/relative/localで生成）
戻り値:: 操作が成功した場合はTrue、失敗した場合はFalse
戻り値の型:: bool

pop() → bool: 自分の位置を保存した位置に戻す

push() → bool: 自分の位置を保存する

read_sign() → str

自分の前方の看板のテキストを読み取る

戻り値:: 看板のテキスト（複数行の場合は改行で区切られた文字列）、看板がない場合は空文字列
戻り値の型:: str

サンプル

テキストを読み取る:

text = entity.read_sign()
print(text)  # "1行目\n2行目\n..."

read_sign_at(loc: Location) → str

指定した座標の看板のテキストを読み取る

パラメータ:: loc (Location) -- 座標情報（LocationFactory.absolute/relative/localで生成）
戻り値:: 看板のテキスト（複数行の場合は改行で区切られた文字列）、看板がない場合は空文字列
戻り値の型:: str

サンプル

相対座標で指定:

loc = LocationFactory.relative(0, 1, 0)  # 1ブロック上
text = entity.read_sign_at(loc)

ローカル座標で指定:

loc = LocationFactory.local(0, 0, 1)  # 前方1ブロック
text = entity.read_sign_at(loc)

read_sign_down() → str

自分の真下の看板のテキストを読み取る

戻り値:: 看板のテキスト（複数行の場合は改行で区切られた文字列）、看板がない場合は空文字列
戻り値の型:: str

read_sign_up() → str

自分の真上の看板のテキストを読み取る

戻り値:: 看板のテキスト（複数行の場合は改行で区切られた文字列）、看板がない場合は空文字列
戻り値の型:: str

say(message: str)

メッセージをチャットに送る

パラメータ:: message (str) -- エンティティがチャットで送信するメッセージの内容
戻り値:: None

select_item(slot: int) → bool

自分のインベントリのアイテムを手に持たせる

パラメータ:: slot (int) -- アイテムを持たせたいスロットの番号
戻り値:: 操作が成功した場合はTrue、失敗した場合はFalse
戻り値の型:: bool

send_message(target: str, message: str)

カスタムイベントメッセージを送信する

パラメータ:

target (str) -- 送信先のEntityの名前
message (str) -- 送信するメッセージの内容

set_event_area(volume: Volume) → bool

イベントの検出範囲を設定する

パラメータ:: volume (Volume) -- イベントの検出範囲
戻り値:: 設定が成功した場合はTrue、失敗した場合はFalse
戻り値の型:: bool

サンプル

>>> # 絶対座標で領域を設定
>>> entity.set_event_area(Volume.absolute(100, 64, -200, 110, 70, -190))
>>> # 相対座標で領域を設定（自分の周囲10ブロック）
>>> entity.set_event_area(Volume.relative(-5, -5, -5, 5, 5, 5))
>>> # ローカル座標で領域を設定（自分の周囲10ブロック）
>>> entity.set_event_area(Volume.local(-5, -5, -5, 5, 5, 5))

set_item(slot: int, block: str) → bool

自分のインベントリの指定したスロットにアイテムを設定する

パラメータ:

slot (int) -- 設定するスロット番号（0から始まる）
block (str) -- 設定するブロックの種類（例: "stone", "dirt", "oak_planks"）データ値が必要な場合は "block:data" の形式で指定例: "stone:1"（花崗岩）, "wool:14"（赤の羊毛）

戻り値:

設定が成功した場合はTrue、失敗した場合はFalse

戻り値の型:

bool

サンプル

# スロット0に石を設定
entity.set_item(0, "stone")

# スロット1に花崗岩を設定
entity.set_item(1, "stone:1")

set_on_message(callback_func: Callable[[Entity, str], Any]): カスタムイベントメッセージを受信したときに呼び出されるコールバック関数を設定する

step_left(n=1) → bool

n歩左にステップする

パラメータ:: n (int, optional) -- 進む歩数. デフォルトは1.
戻り値:: 移動が成功した場合はTrue、失敗した場合はFalse
戻り値の型:: bool

step_right(n=1) → bool

n歩右にステップする

パラメータ:: n (int, optional) -- 進む歩数. デフォルトは1.
戻り値:: 移動が成功した場合はTrue、失敗した場合はFalse
戻り値の型:: bool

swap_item(slot1: int, slot2: int) → bool

自分のインベントリのアイテムを置き換える

パラメータ:

slot1 (int) -- 入れ替え元のスロット番号
slot2 (int) -- 入れ替え先のスロット番号

戻り値:

操作が成功した場合はTrue、失敗した場合はFalse

戻り値の型:

bool

teleport(loc: Location)

指定された座標に移動する

パラメータ:: loc (Location) -- 座標情報（LocationFactory.absolute/relative/localで生成）
戻り値:: None

till_at(loc: Location) → bool

指定した座標のブロックを耕す

パラメータ:: loc (Location) -- 座標情報（LocationFactory.absolute/relative/localで生成）
戻り値:: 操作が成功した場合はTrue、失敗した場合はFalse
戻り値の型:: bool

turn(degrees: int)

エンティティを指定した角度だけ回転させる

パラメータ:: degrees (int) -- 回転する角度（正の値で右回り、負の値で左回り）例: 90で右に90度回転、-90で左に90度回転
戻り値:: None

サンプル

# 右に90度回転
entity.turn(90)

# 左に180度回転
entity.turn(-180)

turn_left()

左に回転させる

戻り値:: None

turn_right()

右に回転させる

戻り値:: None

up(n=1) → bool

n歩上に進む

パラメータ:: n (int, optional) -- 進む歩数. デフォルトは1.
戻り値:: 移動が成功した場合はTrue、失敗した場合はFalse
戻り値の型:: bool

use_item() → bool

自分の前方にアイテムを使う

戻り値:: 操作が成功した場合はTrue、失敗した場合はFalse
戻り値の型:: bool

use_item_at(loc: Location) → bool

指定した座標にアイテムを使う

パラメータ:: loc (Location) -- 座標情報（LocationFactory.absolute/relative/localで生成）
戻り値:: 操作が成功した場合はTrue、失敗した場合はFalse
戻り値の型:: bool

サンプル

# 絶対座標(100, 64, -200)でアイテムを使用
loc = LocationFactory.absolute(100, 64, -200)
entity.use_item_at(loc)

# 自分の東10ブロック、北5ブロックの位置でアイテムを使用
loc = LocationFactory.relative(10, 0, -5)
entity.use_item_at(loc)

# 自分の真上5ブロックの位置でアイテムを使用
loc = LocationFactory.local(0, 5, 0)
entity.use_item_at(loc)

use_item_down() → bool

自分の真下にアイテムを使う

戻り値:: 操作が成功した場合はTrue、失敗した場合はFalse
戻り値の型:: bool

use_item_up() → bool

自分の真上にアイテムを使う

戻り値:: 操作が成功した場合はTrue、失敗した場合はFalse
戻り値の型:: bool

wait_for_block_break() → Block

ブロックが壊されるのを待つ

戻り値:: 壊されたブロックの情報
戻り値の型:: Block

wait_for_player_chat() → ChatMessage

プレイヤーのチャットを待つ

戻り値:: チャットメッセージの情報
戻り値の型:: ChatMessage

wait_for_redstone_change() → RedstonePower

レッドストーン信号が変わるのを待つ

戻り値:: レッドストーン信号の情報
戻り値の型:: RedstonePower

write_sign(text) → bool

自分の前方の看板にテキストを書き込む

パラメータ:: text -- 書き込むテキスト。文字列またはリスト（各要素が各行になる、最大4行）
戻り値:: 操作が成功した場合はTrue、失敗した場合はFalse
戻り値の型:: bool

サンプル

文字列で書き込む:

entity.write_sign("Hello World")

複数行を書き込む:

entity.write_sign(["1行目", "2行目", "3行目", "4行目"])

write_sign_at(loc: Location, text) → bool

指定した座標の看板にテキストを書き込む

パラメータ:

loc (Location) -- 座標情報（LocationFactory.absolute/relative/localで生成）
text -- 書き込むテキスト。文字列またはリスト（各要素が各行になる、最大4行）

戻り値:

操作が成功した場合はTrue、失敗した場合はFalse

戻り値の型:

bool

サンプル

相対座標で指定:

loc = LocationFactory.relative(0, 1, 0)  # 1ブロック上
entity.write_sign_at(loc, "相対座標のメッセージ")

ローカル座標で指定:

loc = LocationFactory.local(0, 0, 1)  # 前方1ブロック
entity.write_sign_at(loc, "ローカル座標のメッセージ")

複数行を書き込む:

loc = LocationFactory.local(0, 0, 1)
entity.write_sign_at(loc, ["1行目", "2行目", "3行目"])

write_sign_down(text) → bool

自分の真下の看板にテキストを書き込む

パラメータ:: text -- 書き込むテキスト。文字列またはリスト（各要素が各行になる、最大4行）
戻り値:: 操作が成功した場合はTrue、失敗した場合はFalse
戻り値の型:: bool

write_sign_up(text) → bool

自分の真上の看板にテキストを書き込む

パラメータ:: text -- 書き込むテキスト。文字列またはリスト（各要素が各行になる、最大4行）
戻り値:: 操作が成功した場合はTrue、失敗した場合はFalse
戻り値の型:: bool

class py2hackCraft.modules.EventMessage(entityUuid: str, sender: str, uuid: str, message: str)

イベントメッセージを表すデータクラス

Category:: イベントクラス

entityUuid

イベントを送信したエンティティの一意の識別子（UUID）

Type:: str

sender

送信者の名前

Type:: str

uuid

送信者の一意の識別子（UUID）

Type:: str

message

イベントメッセージの内容

Type:: str

class py2hackCraft.modules.InteractEvent(action: str, player: str, player_uuid: str, event: str, name: str, type: str, data: int = 0, world: str = 'world', x: int = 0, y: int = 0, z: int = 0)

クリックイベントを表すデータクラス

Category:: イベントクラス

action

アクションの名前

Type:: str

player

クリックしたプレイヤー名

Type:: str

player_uuid

クリックしたプレイヤーの一意の識別子（UUID）

Type:: str

event

アイテムに設定されている名前

Type:: str

name

ブロックあるいはエンティティーの名前

Type:: str

type

ブロックあるいはエンティティーの種類

Type:: str

data

ブロックのデータ値

Type:: int

world

ブロックあるいはエンティティーのいたワールド名

Type:: str

x

クリックした場所のワールドにおけるX座標

Type:: int

y

クリックした場所のワールドにおけるY座標

Type:: int

z

クリックした場所のワールドにおけるZ座標

Type:: int

class py2hackCraft.modules.Inventory(client: _WebSocketClient, entity_uuid: str, world: str, x: int, y: int, z: int, size: int, items: list)

インベントリを表すクラス

Category:: 基本クラス

このクラスは、アルゴリズム学習のための基本的な操作を提供します。検索、ソート、集計などの操作は、このクラスの基本操作を組み合わせて実装できます。

get_all_items() → List[ItemStack]

インベントリ内の全てのアイテムを取得する

戻り値:: アイテムのリスト
戻り値の型:: List[ItemStack]

サンプル

# 全てのアイテムを取得して表示
items = inventory.get_all_items()
for item in items:
    print(f"スロット{item.slot}: {item.name} x{item.amount}")

get_item(slot: int) → ItemStack

指定されたスロットのアイテムを取得する

パラメータ:: slot (int) -- 取得するアイテムのスロット番号
戻り値:: 取得したアイテムの情報
戻り値の型:: ItemStack

サンプル

# スロット0のアイテムを取得
item = inventory.get_item(0)
print(f"アイテム: {item.name}, 数量: {item.amount}")

move_item(from_slot: int, to_slot: int)

アイテムを別のスロットに移動する

パラメータ:

from_slot (int) -- 移動元のスロット番号
to_slot (int) -- 移動先のスロット番号

サンプル

# スロット0のアイテムをスロット5に移動
inventory.move_item(0, 5)

retrieve_to_self(from_slot: int, to_slot: int)

チェストから自分のインベントリにアイテムを取り出す

パラメータ:

from_slot (int) -- チェストの取り出し元スロット番号
to_slot (int) -- 自分のインベントリの格納先スロット番号

サンプル

# チェストのスロット0のアイテムを自分のスロット5に取り出す
inventory.retrieve_from_self(0, 5)

store_from_self(from_slot: int, to_slot: int)

自分のインベントリからチェストにアイテムを格納する

パラメータ:

from_slot (int) -- 自分のインベントリの取り出し元スロット番号
to_slot (int) -- チェストの格納先スロット番号

サンプル

# 自分のスロット0のアイテムをチェストのスロット5に格納
inventory.store_to_self(0, 5)

swap_items(slot1: int, slot2: int)

2つのスロットのアイテムを入れ替える

パラメータ:

slot1 (int) -- 入れ替え元のスロット番号
slot2 (int) -- 入れ替え先のスロット番号

サンプル

# スロット0と1のアイテムを入れ替え
inventory.swap_items(0, 1)

class py2hackCraft.modules.ItemStack(slot: int = 0, name: str = 'air', amount: int = 0)

アイテムスタックを表すデータクラス

Category:: データクラス

slot

スロット番号

Type:: int

name

アイテムの名前

Type:: str

amount

アイテムの数量

Type:: int

class py2hackCraft.modules.Location(x: int, y: int, z: int, world: str = 'world', cord: str = '')

座標を表すデータクラス

Category:: データクラス

x

X座標

Type:: int

y

Y座標

Type:: int

z

Z座標

Type:: int

world

ワールド名（デフォルトは"world"）

Type:: str

cord

座標系（デフォルトは""（絶対座標））

"": 絶対座標 (例: 100, 64, -200)
"~": 相対座標 (例: ~10, ~0, ~-5)
"^": ローカル座標 (例: ^0, ^5, ^0)

Type:: str

class py2hackCraft.modules.LocationFactory

Minecraftの座標を生成するファクトリクラス

Category:: データクラス

座標系の種類:

ABSOLUTE: 絶対座標 (例: 100, 64, -200)
RELATIVE: 相対座標 (例: ~10, ~0, ~-5)
LOCAL: ローカル座標 (例: ^0, ^5, ^0)

static absolute(x: int, y: int, z: int, world: str = 'world') → Location

絶対座標を生成する

パラメータ:

x (int) -- X座標
y (int) -- Y座標
z (int) -- Z座標
world (str, optional) -- ワールド名. デフォルトは"world".

戻り値:

生成された絶対座標

戻り値の型:

Location

サンプル

loc = LocationFactory.absolute(100, 64, -200)
print(f"X: {loc.x}, Y: {loc.y}, Z: {loc.z}, ワールド: {loc.world}, 座標系: {loc.cord}")

static local(x: int, y: int, z: int, world: str = 'world') → Location

ローカル座標を生成する（自分の向きを基準とした前後左右）

パラメータ:

x (int) -- 右(+)左(-)方向の相対距離
y (int) -- 上(+)下(-)方向の相対距離
z (int) -- 前(+)後(-)方向の相対距離
world (str, optional) -- ワールド名. デフォルトは"world".

戻り値:

生成されたローカル座標

戻り値の型:

Location

サンプル

loc = LocationFactory.local(0, 5, 0)  # 自分の真上5ブロック
print(f"X: {loc.x}, Y: {loc.y}, Z: {loc.z}, ワールド: {loc.world}, 座標系: {loc.cord}")

static relative(x: int, y: int, z: int, world: str = 'world') → Location

相対座標を生成する（自分を中心とした東西南北）

パラメータ:

x (int) -- 東(+)西(-)方向の相対距離
y (int) -- 上(+)下(-)方向の相対距離
z (int) -- 南(+)北(-)方向の相対距離
world (str, optional) -- ワールド名. デフォルトは"world".

戻り値:

生成された相対座標

戻り値の型:

Location

サンプル

loc = LocationFactory.relative(10, 0, -5)  # 東に10、北に5進む
print(f"X: {loc.x}, Y: {loc.y}, Z: {loc.z}, ワールド: {loc.world}, 座標系: {loc.cord}")

class py2hackCraft.modules.Player(player: str)

プレイヤーを表すクラス

Category:: 基本クラス

get_entity(name: str) → Entity

指定された名前のエンティティを取得する

パラメータ:: name (str) -- エンティティの名前
戻り値:: 取得したエンティティ
戻り値の型:: Entity
例外:: UninitializedClientError -- クライアントが初期化されていない場合

class py2hackCraft.modules.RedstonePower(entityUuid: str, oldCurrent: int, newCurrent: int)

レッドストーン信号を表すデータクラス

Category:: イベントクラス

entityUuid

レッドストーン信号を検出したエンティティの一意の識別子（UUID）

Type:: str

oldCurrent

前のレッドストーン信号の強さ

Type:: int

newCurrent

最新のレッドストーン信号の強さ

Type:: int

class py2hackCraft.modules.Side

ブロックの配置方向を表すデータクラス

Category:: データクラス

exception py2hackCraft.modules.UninitializedClientError

WebSocketClientが初期化されていないことを示すカスタム例外

Category:: 基本クラス

class py2hackCraft.modules.Volume(x1: int, y1: int, z1: int, x2: int, y2: int, z2: int, cord: str = '')

3D空間の領域を表すクラス

Category:: データクラス

座標系の種類: - ABSOLUTE: 絶対座標 (例: 100, 64, -200) - RELATIVE: 相対座標 (例: ~10, ~0, ~-5) - LOCAL: ローカル座標 (例: ^0, ^5, ^0)

static absolute(x1: int, y1: int, z1: int, x2: int, y2: int, z2: int) → Volume

絶対座標で領域を指定する

パラメータ:

x1 (int) -- 1つ目の座標のX座標
y1 (int) -- 1つ目の座標のY座標
z1 (int) -- 1つ目の座標のZ座標
x2 (int) -- 2つ目の座標のX座標
y2 (int) -- 2つ目の座標のY座標
z2 (int) -- 2つ目の座標のZ座標

戻り値:

指定された領域

戻り値の型:

Volume

サンプル

>>> # 絶対座標(100, 64, -200)から(110, 70, -190)の領域を定義
>>> Volume.absolute(100, 64, -200, 110, 70, -190)

static local(x1: int, y1: int, z1: int, x2: int, y2: int, z2: int) → Volume

ローカル座標で領域を指定する（自分の向きを基準とした前後左右）

パラメータ:

x1 (int) -- 1つ目の座標の右(+)左(-)方向の相対距離
y1 (int) -- 1つ目の座標の上(+)下(-)方向の相対距離
z1 (int) -- 1つ目の座標の前(+)後(-)方向の相対距離
x2 (int) -- 2つ目の座標の右(+)左(-)方向の相対距離
y2 (int) -- 2つ目の座標の上(+)下(-)方向の相対距離
z2 (int) -- 2つ目の座標の前(+)後(-)方向の相対距離

戻り値:

指定された領域

戻り値の型:

Volume

サンプル

>>> # 自分の周囲5ブロックの領域を定義（向きに依存）
>>> Volume.local(-5, -5, -5, 5, 5, 5)

static relative(x1: int, y1: int, z1: int, x2: int, y2: int, z2: int) → Volume

相対座標で領域を指定する（自分を中心とした東西南北）

パラメータ:

x1 (int) -- 1つ目の座標の東(+)西(-)方向の相対距離
y1 (int) -- 1つ目の座標の上(+)下(-)方向の相対距離
z1 (int) -- 1つ目の座標の南(+)北(-)方向の相対距離
x2 (int) -- 2つ目の座標の東(+)西(-)方向の相対距離
y2 (int) -- 2つ目の座標の上(+)下(-)方向の相対距離
z2 (int) -- 2つ目の座標の南(+)北(-)方向の相対距離

戻り値:

指定された領域

戻り値の型:

Volume

サンプル

>>> # 自分の周囲5ブロックの領域を定義
>>> Volume.relative(-5, -5, -5, 5, 5, 5)

py2hackCraft.modules.str_to_bool(s)

文字列をブール値に変換する

パラメータ:: s (str) -- "true" または "false"（大文字小文字は無視）
戻り値:: 変換されたブール値"true"ならTrue、"false"ならFalse
戻り値の型:: bool

索引とテーブル