py2hackCraft2 1.0.20__tar.gz → 1.0.22__tar.gz

{py2hackcraft2-1.0.20 → py2hackcraft2-1.0.22}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: py2hackCraft2
-Version: 1.0.20
+Version: 1.0.22
 Summary: These are APIs that connect to the hackCraft2 server from Python to manipulate pets.
 Home-page: https://pypi.org/project/py2hackCraft2/
 Author: Masafumi Terazono

{py2hackcraft2-1.0.20 → py2hackcraft2-1.0.22}/py2hackCraft/modules.py

@@ -8,13 +8,13 @@ from typing import Callable, Any
 
 def str_to_bool(s):
     """
-    文字列をブール値に変換する。
+    文字列をブール値に変換する
 
     Args:
         s (str): "true" または "false"（大文字小文字は無視）
 
     Returns:
-        bool: 変換されたブール値。"true"ならTrue、"false"ならFalse
+        bool: 変換されたブール値"true"ならTrue、"false"ならFalse
     """
     if s.lower() == 'true':
         return True
@@ -24,7 +24,7 @@ def str_to_bool(s):
         raise ValueError(f"Cannot covert {s} to a boolean.")  # 有効な文字列でない場合はエラー
 
 class UninitializedClientError(Exception):
-    """WebSocketClientが初期化されていないことを示すカスタム例外。"""
+    """WebSocketClientが初期化されていないことを示すカスタム例外"""
     pass
 
 
@@ -175,13 +175,13 @@ class Side:
 @dataclass
 class Location:
     """
-    座標を表すデータクラス。
+    座標を表すデータクラス
 
     Attributes:
-        x (str): X座標。
-        y (str): Y座標。
-        z (str): Z座標。
-        world (str): ワールド名。
+        x (str): X座標
+        y (str): Y座標
+        z (str): Z座標
+        world (str): ワールド名
     """
     x: int
     y: int
@@ -191,20 +191,20 @@ class Location:
 @dataclass
 class InteractEvent:
     """
-    クリックイベントを表すデータクラス。
+    クリックイベントを表すデータクラス
 
     Attributes:
-        action (str): アクションの名前。
-        player (str): クリックしたプレイヤー名。
-        player_uuid (str): クリックしたプレイヤーの一意の識別子（UUID）。
-        event (str): アイテムに設定されている名前。
+        action (str): アクションの名前
+        player (str): クリックしたプレイヤー名
+        player_uuid (str): クリックしたプレイヤーの一意の識別子（UUID）
+        event (str): アイテムに設定されている名前
         name (str): ブロックあるいはエンティティーの名前
-        type (str): ブロックあるいはエンティティーの種類。
-        data (int): ブロックのデータ値。
-        world (str): ブロックあるいはエンティティーのいたワールド名。
-        x (int): クリックした場所のワールドにおけるX座標。
-        y (int): クリックした場所のワールドにおけるY座標。
-        z (int): クリックした場所のワールドにおけるZ座標。
+        type (str): ブロックあるいはエンティティーの種類
+        data (int): ブロックのデータ値
+        world (str): ブロックあるいはエンティティーのいたワールド名
+        x (int): クリックした場所のワールドにおけるX座標
+        y (int): クリックした場所のワールドにおけるY座標
+        z (int): クリックした場所のワールドにおけるZ座標
     """
     action: str
     player: str
@@ -221,12 +221,12 @@ class InteractEvent:
 @dataclass
 class EventMessage:
     """
-    イベントメッセージを表すデータクラス。
+    イベントメッセージを表すデータクラス
 
     Attributes:
-        sender (str): 送信者の名前。
-        uuid (str): 送信者の一意の識別子（UUID）。
-        message (str): イベントメッセージ。
+        sender (str): 送信者の名前
+        uuid (str): 送信者の一意の識別子（UUID）
+        message (str): イベントメッセージ
     """
     entityUuid: str
     sender: str
@@ -237,12 +237,12 @@ class EventMessage:
 @dataclass
 class ChatMessage:
     """
-    チャットメッセージを表すデータクラス。
+    チャットメッセージを表すデータクラス
 
     Attributes:
-        player (str): プレイヤー名。
-        uuid (str): プレイヤーの一意の識別子（UUID）。
-        message (str): プレイヤーがチャットで送信したメッセージの内容。
+        player (str): プレイヤー名
+        uuid (str): プレイヤーの一意の識別子（UUID）
+        message (str): プレイヤーがチャットで送信したメッセージの内容
     """
     player: str
     uuid: str
@@ -252,7 +252,7 @@ class ChatMessage:
 @dataclass
 class RedstonePower:
     """
-    レッドストーン信号を表すデータクラス。
+    レッドストーン信号を表すデータクラス
 
     Attributes:
         oldCurrent (int): 前のレッドストーン信号の強さ
@@ -265,22 +265,22 @@ class RedstonePower:
 @dataclass
 class Block:
     """
-    ブロックを表すデータクラス。
+    ブロックを表すデータクラス
 
     Attributes:
-        name (str): ブロックの種類。
-        data (int): ブロックのデータ値。
-        isLiquid (bool): 液体ブロックかどうか。
-        isAir (bool): 空気ブロックかどうか。
-        isBurnable (bool): 燃えるブロックかどうか。
-        isFuel (bool): 燃料ブロックかどうか。
-        isOccluding (bool): 透過しないブロックかどうか。
-        isSolid (bool): 壁のあるブロックかどうか。
-        isPassable (bool): 通過可能なブロックかどうか。
-        world (str): ブロックが存在するワールドの名前（デフォルトは"world"）。
-        x (int): ブロックのX座標。
-        y (int): ブロックのY座標。
-        z (int): ブロックのZ座標。
+        name (str): ブロックの種類
+        data (int): ブロックのデータ値
+        isLiquid (bool): 液体ブロックかどうか
+        isAir (bool): 空気ブロックかどうか
+        isBurnable (bool): 燃えるブロックかどうか
+        isFuel (bool): 燃料ブロックかどうか
+        isOccluding (bool): 透過しないブロックかどうか
+        isSolid (bool): 壁のあるブロックかどうか
+        isPassable (bool): 通過可能なブロックかどうか
+        world (str): ブロックが存在するワールドの名前（デフォルトは"world"）
+        x (int): ブロックのX座標
+        y (int): ブロックのY座標
+        z (int): ブロックのZ座標
     """
     name: str
     type: str = "block"
@@ -328,16 +328,16 @@ class Player:
 
     def getEntity(self, name: str) -> 'Entity': 
         """
-        指定された名前のエンティティを取得する。
+        指定された名前のエンティティを取得する
 
         Args:
-            name (str): エンティティの名前。
+            name (str): エンティティの名前
 
         Returns:
-            Entity: 取得したエンティティ。
+            Entity: 取得したエンティティ
 
         Raises:
-            UninitializedClientError: クライアントが初期化されていない場合。        
+            UninitializedClientError: クライアントが初期化されていない場合        
         """
         if self.client is None or not self.client.connected:  # 接続状態をチェック
             raise UninitializedClientError("Client is not initialized")
@@ -362,7 +362,7 @@ class Player:
 
 class Inventory:
     """
-    インベントリを表すクラス。
+    インベントリを表すクラス
     """
     def __init__(self, client: _WebSocketClient, entityUUID: str, world: str, x: int, y: int, z:int, size:int):
         self.client = client
@@ -372,10 +372,10 @@ class Inventory:
 
     def getItem(self, slot: int) -> ItemStack :
         """
-        指定されたスロットのアイテムを取得する。
+        指定されたスロットのアイテムを取得する
 
         Args:
-            slot (int): 取得するアイテムのスロット番号。
+            slot (int): 取得するアイテムのスロット番号
         """
         self.client.sendCall(self.entityUUID, "getInventoryItem", [self.location.x, self.location.y, self.location.z, slot])
         itemStack = ItemStack(** json.loads(self.client.result))
@@ -383,21 +383,21 @@ class Inventory:
 
     def swapItem(self, slot1: int, slot2: int) :
         """
-        インベントリの内容を置き換える。
+        インベントリの内容を置き換える
 
         Args:
-            slot1 (int): 置き換え元のアイテムのスロット番号。
-            slot2 (int): 置き換え先のアイテムのスロット番号。
+            slot1 (int): 置き換え元のアイテムのスロット番号
+            slot2 (int): 置き換え先のアイテムのスロット番号
         """
         self.client.sendCall(self.entityUUID, "swapInventoryItem", [self.location.x, self.location.y, self.location.z, slot1, slot2])
 
     def moveItem(self, slot1: int, slot2: int) :
         """
-        インベントリの内容を移動させる。
+        インベントリの内容を移動させる
 
         Args:
-            slot1 (int): 移動元のアイテムのスロット番号。
-            slot2 (int): 移動先のアイテムのスロット番号。        
+            slot1 (int): 移動元のアイテムのスロット番号
+            slot2 (int): 移動先のアイテムのスロット番号        
         """
         self.client.sendCall(self.entityUUID, "moveInventoryItem", [self.location.x, self.location.y, self.location.z, slot1, slot2])
 
@@ -406,8 +406,8 @@ class Inventory:
         チェストを開いたエンティティーのインベントリからこのインベントリにアイテムを入れる
 
         Args:
-            slot1 (int): 引き出し元のアイテムのスロット番号。
-            slot2 (int): 格納先のアイテムのスロット番号。        
+            slot1 (int): 引き出し元のアイテムのスロット番号
+            slot2 (int): 格納先のアイテムのスロット番号        
         """
         self.client.sendCall(self.entityUUID, "storeInventoryItem", [self.location.x, self.location.y, self.location.z, slot1, slot2])
 
@@ -416,15 +416,15 @@ class Inventory:
         チェストを開いたエンティティーのインベントリからこのインベントリからアイテムを取り出す
 
         Args:
-            slot1 (int): 格納先のアイテムのスロット番号。
-            slot2 (int): 引き出し元のアイテムのスロット番号。        
+            slot1 (int): 格納先のアイテムのスロット番号
+            slot2 (int): 引き出し元のアイテムのスロット番号        
         """
         self.client.sendCall(self.entityUUID, "retrieveInventoryItem", [self.location.x, self.location.y, self.location.z, slot1, slot2])
 
 
 class Entity:
     """
-    エンティティを表すクラス。
+    エンティティを表すクラス
     """
     def __init__(self, client: _WebSocketClient, world: str, uuid: str):
         self.client = client
@@ -445,21 +445,21 @@ class Entity:
 
     def waitForRedstoneChange(self):
         """
-        レッドストーン信号が変わるまでまつ。
+        レッドストーン信号が変わるまでまつ
         """
         self.client.waitFor(self.uuid, 'onEntityRedstone')
         return RedstonePower(** self.client.result)
 
     def waitForBreakBlock(self):
         """
-        プレイヤーがブロックをこわすまで待つ。
+        プレイヤーがブロックをこわすまで待つ
         """
         self.client.waitFor(self.uuid, 'onPlayerBlockBreak')
         return Block(** self.client.result)
 
     def setOnInteractEvent(self, callbackFunc: Callable[['Entity', 'InteractEvent'], Any]):
         """
-        プレイヤーがイベントアイテムを使った時に呼び出されるコールバック関数を設定する。
+        プレイヤーがイベントアイテムを使った時に呼び出されるコールバック関数を設定する
         """
         def callbackWrapper(data):
             logging.debug("onInteractEvent callbackWrapper '%s'" % data)
@@ -471,7 +471,7 @@ class Entity:
 
     def setOnMessage(self, callbackFunc: Callable[['Entity', str], Any]):
         """
-        カスタムイベントメッセージを受信したときに呼び出されるコールバック関数を設定する。
+        カスタムイベントメッセージを受信したときに呼び出されるコールバック関数を設定する
         """
         def callbackWrapper(data):
             logging.debug("setOnMessage callbackWrapper '%s'" % data)
@@ -483,20 +483,20 @@ class Entity:
 
     def sendMessage(self, target: str, message: str):
         """
-        カスタムイベントメッセージを送信する。
+        カスタムイベントメッセージを送信する
 
         Args:
-            target (str): 送信先のEntityの名前。
-            message (str): 送信するメッセージの内容。
+            target (str): 送信先のEntityの名前
+            message (str): 送信するメッセージの内容
         """
         self.client.sendCall(self.uuid, "sendEvent", [target, message])
 
     def executeCommand(self, command: str):
         """
-        コマンドを実行する。
+        コマンドを実行する
 
         Args:
-            command (str): 実行するコマンドの内容。
+            command (str): 実行するコマンドの内容
         """
         self.client.sendCall(self.uuid, "executeCommand", [command])
     
@@ -507,7 +507,7 @@ class Entity:
 
     def push(self) -> bool :
         """
-        自分の位置を保存する。
+        自分の位置を保存する
         """
         pos = self.getLocation()
         self.positions.append(pos)
@@ -515,7 +515,7 @@ class Entity:
     
     def pop(self) -> bool :
         """
-        自分の位置を保存した位置に戻す。
+        自分の位置を保存した位置に戻す
         """
         if(len(self.positions) > 0):
             pos = self.positions.pop()
@@ -526,68 +526,68 @@ class Entity:
 
     def forward(self) -> bool :
         """
-        自分を前方に移動させる。
+        自分を前方に移動させる
         """
         self.client.sendCall(self.uuid, "forward")
         return str_to_bool(self.client.result)
 
     def back(self) -> bool :
         """
-        自分を後方に移動させる。
+        自分を後方に移動させる
         """
         self.client.sendCall(self.uuid, "back")
         return str_to_bool(self.client.result)
 
     def up(self) -> bool :
         """
-        自分を上方に移動させる。
+        自分を上方に移動させる
         """
         self.client.sendCall(self.uuid, "up")
         return str_to_bool(self.client.result)
 
     def down(self) -> bool :
         """
-        自分を下方に移動させる。
+        自分を下方に移動させる
         """
         self.client.sendCall(self.uuid, "down")
         return str_to_bool(self.client.result)
 
     def stepLeft(self) -> bool :
         """
-        自分を左に移動させる。
+        自分を左に移動させる
         """
         self.client.sendCall(self.uuid, "stepLeft")
         return str_to_bool(self.client.result)
 
     def stepRight(self) -> bool :
         """
-        自分を右に移動させる。
+        自分を右に移動させる
         """
         self.client.sendCall(self.uuid, "stepRight")
         return str_to_bool(self.client.result)
 
     def turnLeft(self) :
         """
-        自分を左に回転させる。aw
+        自分を左に回転させるaw
         """
         self.client.sendCall(self.uuid, "turnLeft")
 
     def turnRight(self) :
         """
-        自分を右に回転させる。
+        自分を右に回転させる
         """
         self.client.sendCall(self.uuid, "turnRight")
 
     def makeSound(self) -> bool :
         """
-        自分を鳴かせる。
+        自分を鳴かせる
         """
         self.client.sendCall(self.uuid, "sound")
         return str_to_bool(self.client.result)
 
     def addForce(self, x: float, y: float, z: float) -> bool :
         """
-        前方へ移動する。
+        前方へ移動する
 
         Args:
             x (float): x軸方向の加速
@@ -599,78 +599,76 @@ class Entity:
 
     def jump(self, degrees: int):
         """
-        ジャンプさせる。
+        ジャンプさせる
         """
         self.client.sendCall(self.uuid, "jump")  
 
     def turn(self, degrees: int):
         """
-        自分を回転させる。
+        自分を回転させる
 
         Args:
-            degrees (int): 回転する速度。
+            degrees (int): 回転する速度
         """
         self.client.sendCall(self.uuid, "turn", [degrees])  
 
-    def placeX(self, cord: Coordinates, x: int, y: int, z: int, block=None, side=None) -> bool :
+    def placeX(self, x: int, y: int, z: int, cord: Coordinates=Coordinates.local, side=None,) -> bool :
         """
-        指定した座標にブロックを設置する。
+        指定した座標にブロックを設置する
 
         Args:
-            cord (Coordinates): 座標の種類（'', '^', '~'）。
-            x (int): X座標。
-            y (int): Y座標。
-            z (int): Z座標。
-            block (str): 設置するブロックの種類。
-            side (str): 設置する面。
-        """
-        self.client.sendCall(self.uuid, "placeX", [x, y, z, cord, side, block])
+            x (int): X座標
+            y (int): Y座標
+            z (int): Z座標
+            cord (Coordinates): 座標の種類（'', '^', '~'）
+            side (str): 設置する面
+        """
+        self.client.sendCall(self.uuid, "placeX", [x, y, z, cord, side])
         return str_to_bool(self.client.result)
 
-    def placeHere(self, x: int, y: int, z: int, block=None, side=None) -> bool :
+    def placeHere(self, x: int, y: int, z: int, side=None) -> bool :
         """
-        自分を中心に指定した座標にブロックを設置する。
+        自分を中心に指定した座標にブロックを設置する
 
         Args:
-            x (int): X座標。
-            y (int): Y座標。
-            z (int): Z座標。
-            block (str): 設置するブロックの種類。
-            side (str): 設置する面。
+            x (int): X座標
+            y (int): Y座標
+            z (int): Z座標
+            side (str): 設置する面
         """
-        self.client.sendCall(self.uuid, "placeX", [x, y, z, "^", side, block])
+        self.client.sendCall(self.uuid, "placeX", [x, y, z, "^", side])
         return str_to_bool(self.client.result)
 
     def place(self, side=None) -> bool :
         """
-        自分の前方にブロックを設置する。
+        自分の前方にブロックを設置する
         """
         self.client.sendCall(self.uuid, "placeFront", [side])
         return str_to_bool(self.client.result)
 
     def placeUp(self, side=None) -> bool :
         """
-        自分の真上にブロックを設置する。
+        自分の真上にブロックを設置する
         """
         self.client.sendCall(self.uuid, "placeUp", [side])
         return str_to_bool(self.client.result)
 
     def placeDown(self, side=None) -> bool :
         """
-        自分の真下にブロックを設置する。
+        自分の真下にブロックを設置する
         """
         self.client.sendCall(self.uuid, "placeDown", [side])
         return str_to_bool(self.client.result)
 
-    def useItemX(self, cord: Coordinates, x: int, y: int, z: int) -> bool :
+    def useItemX(self, x: int, y: int, z: int, cord: Coordinates = Coordinates.local) -> bool :
         """
         指定した座標にアイテムを使う
 
         Args:
-            cord (Coordinates): 座標の種類（'', '^', '~'）。        
-            x (int): X座標。
-            y (int): Y座標。
-            z (int): Z座標。
+            x (int): X座標
+            y (int): Y座標
+            z (int): Z座標
+            cord (Coordinates): 座標の種類（'', '^', '~'）        
         """
         self.client.sendCall(self.uuid, "useItemX", [x, y, z, cord])
         return str_to_bool(self.client.result)
@@ -680,9 +678,9 @@ class Entity:
         自分を中心に指定した座標にアイテムを使う
 
         Args:
-            x (int): X座標。
-            y (int): Y座標。
-            z (int): Z座標。
+            x (int): X座標
+            y (int): Y座標
+            z (int): Z座標
         """
         self.client.sendCall(self.uuid, "useItemX", [x, y, z, "^"])
         return str_to_bool(self.client.result)
@@ -710,90 +708,150 @@ class Entity:
 
     def harvest(self) -> bool :
         """
-        自分の位置のブロックを収穫する。
+        自分の位置のブロックを収穫する
         """
         self.client.sendCall(self.uuid, "digX", [0, 0, 0])
         return str_to_bool(self.client.result)
 
     def attack(self) -> bool :
         """
-        自分の前方を攻撃する。
+        自分の前方を攻撃する
         """
         self.client.sendCall(self.uuid, "attack")
         return str_to_bool(self.client.result)
 
+    def plant(self) -> bool :
+        """
+        自分の足元に植物を植える
+        """
+        self.client.sendCall(self.uuid, "plantX", [0, -1, 0, "^"])
+        return str_to_bool(self.client.result)
+    
+    def plantX(self, x : int, y: int, z: int, cord: Coordinates = Coordinates.local) -> bool :
+        """
+        指定した座標のブロックに植物を植える
+
+        Args:
+            x (int): X座標
+            y (int): Y座標
+            z (int): Z座標
+            cord (Coordinates): 座標の種類（'', '^', '~'）        
+        """
+        self.client.sendCall(self.uuid, "plantX", [x, y, z, cord])
+        return str_to_bool(self.client.result)
+
+    def till(self) -> bool :
+        """
+        自分の足元のブロックを耕す
+        """
+        self.client.sendCall(self.uuid, "tillX", [0, -1, 0, "^"])
+        return str_to_bool(self.client.result)
+    
+    def tillX(self, x : int, y: int, z: int, cord: Coordinates = Coordinates.local) -> bool :
+        """
+        指定した座標のブロックを耕す
+
+        Args:
+            x (int): X座標
+            y (int): Y座標
+            z (int): Z座標
+            cord (Coordinates): 座標の種類（'', '^', '~'）        
+        """
+        self.client.sendCall(self.uuid, "tillX", [x, y, z, cord])
+        return str_to_bool(self.client.result)
+
+    def flatten(self) -> bool :
+        """
+        自分の足元のブロックに平らにする
+        """
+        self.client.sendCall(self.uuid, "flattenX", [0, -1, 0, "^"])
+        return str_to_bool(self.client.result)
+    
+    def flattenX(self, x : int, y: int, z: int, cord: Coordinates = Coordinates.local) -> bool :
+        """
+        指定した座標のブロックを平らにする
+
+        Args:
+            x (int): X座標
+            y (int): Y座標
+            z (int): Z座標
+            cord (Coordinates): 座標の種類（'', '^', '~'）        
+        """
+        self.client.sendCall(self.uuid, "flattenX", [x, y, z, cord])
+        return str_to_bool(self.client.result)
+
     def dig(self) -> bool :
         """
-        自分の前方のブロックを壊す。
+        自分の前方のブロックを壊す
         """
         self.client.sendCall(self.uuid, "digFront")
         return str_to_bool(self.client.result)
 
     def digUp(self) -> bool :
         """
-        自分の真上のブロックを壊す。
+        自分の真上のブロックを壊す
         """
         self.client.sendCall(self.uuid, "digUp")
         return str_to_bool(self.client.result)
 
     def digDown(self) -> bool :
         """
-        自分の真下のブロックを壊す。
+        自分の真下のブロックを壊す
         """
         self.client.sendCall(self.uuid, "digDown")
         return str_to_bool(self.client.result)
 
-    def digX(self, cord: Coordinates, x : int, y: int, z: int) -> bool :
+    def digX(self, x : int, y: int, z: int, cord: Coordinates = Coordinates.local) -> bool :
         """
-        指定した座標のブロックを壊す。
+        指定した座標のブロックを壊す
 
         Args:
-            cord (Coordinates): 座標の種類（'', '^', '~'）。        
-            x (int): X座標。
-            y (int): Y座標。
-            z (int): Z座標。
+            x (int): X座標
+            y (int): Y座標
+            z (int): Z座標
+            cord (Coordinates): 座標の種類（'', '^', '~'）        
         """
         self.client.sendCall(self.uuid, "digX", [x, y, z, cord])
         return str_to_bool(self.client.result)
 
     def action(self) -> bool :
         """
-        自分の前方の装置を使う。
+        自分の前方の装置を使う
         """
         self.client.sendCall(self.uuid, "actionFront")
         return str_to_bool(self.client.result)
 
     def actionUp(self) -> bool :
         """
-        自分の真上の装置を使う。
+        自分の真上の装置を使う
         """
         self.client.sendCall(self.uuid, "actionUp")
         return str_to_bool(self.client.result)
 
     def actionDown(self) -> bool :
         """
-        自分の真下の装置を使う。
+        自分の真下の装置を使う
         """
         self.client.sendCall(self.uuid, "actionDown")
         return str_to_bool(self.client.result)
 
     def setItem(self, slot: int, block: str) -> bool :
         """
-        自分のインベントリにアイテムを設定する。
+        自分のインベントリにアイテムを設定する
 
         Args:
-            slot (int): 設定するアイテムのスロット番号。
-            block (str): 設定するブロックの種類。
+            slot (int): 設定するアイテムのスロット番号
+            block (str): 設定するブロックの種類
         """
         self.client.sendCall(self.uuid, "setItem", [slot, block])
         return str_to_bool(self.client.result)
 
     def getItem(self, slot: int) -> ItemStack :
         """
-        自分のインベントリからアイテムを取得する。
+        自分のインベントリからアイテムを取得する
 
         Args:
-            slot (int): 取得するアイテムのスロット番号。
+            slot (int): 取得するアイテムのスロット番号
         """
         self.client.sendCall(self.uuid, "getItem", [slot])
         itemStack = ItemStack(** json.loads(self.client.result))
@@ -801,55 +859,55 @@ class Entity:
 
     def swapItem(self, slot1: int, slot2: int) -> bool :
         """
-       自分のインベントリのアイテムを置き換える。
+       自分のインベントリのアイテムを置き換える
         """
         self.client.sendCall(self.uuid, "swapItem", [slot1, slot2])
         return str_to_bool(self.client.result)
 
     def moveItem(self, slot1: int, slot2: int) -> bool :
         """
-        自分のインベントリのアイテムを移動させる。
+        自分のインベントリのアイテムを移動させる
         """
         self.client.sendCall(self.uuid, "moveItem", [slot1, slot2])
         return str_to_bool(self.client.result)
 
     def dropItem(self, slot1: int) -> bool :
         """
-        自分のインベントリのアイテムを落とす。
+        自分のインベントリのアイテムを落とす
         """
         self.client.sendCall(self.uuid, "dropItem", [slot1])
         return str_to_bool(self.client.result)
 
-    def grabItem(self, slot: int) -> bool :
+    def selectItem(self, slot: int) -> bool :
         """
-        自分のインベントリのアイテムを手に持たせる。
+        自分のインベントリのアイテムを手に持たせる
 
         Args:
-            slot (int): アイテムを持たせたいスロットの番号。
+            slot (int): アイテムを持たせたいスロットの番号
         """
         self.client.sendCall(self.uuid, "grabItem", [slot])
         return str_to_bool(self.client.result)
 
     def say(self, message: str):
         """
-        メッセージをチャットに送る。
+        メッセージをチャットに送る
 
         Args:
-            message (str): エンティティがチャットで送信するメッセージの内容。
+            message (str): エンティティがチャットで送信するメッセージの内容
         """
         self.client.sendCall(self.uuid, "sendChat", [message])
 
-    def inspectX(self, cord: Coordinates, x: int, y: int, z: int) -> Block :
+    def inspectX(self, x: int, y: int, z: int, cord: Coordinates = Coordinates.local) -> Block :
         """
-        指定された座標のブロックを調べる。
+        指定された座標のブロックを調べる
 
         Args:
-            cord (Coordinates): 座標の種類（'', '^', '~'）。
-            x (int): X座標。
-            y (int): Y座標。
-            z (int): Z座標。
+            x (int): X座標
+            y (int): Y座標
+            z (int): Z座標
+            cord (Coordinates): 座標の種類（'', '^', '~'）
         Returns:
-            Block: 調べたブロックの情報。    
+            Block: 調べたブロックの情報    
         """
         self.client.sendCall(self.uuid, "inspect", [x, y, z, cord])
         block = Block(** json.loads(self.client.result))
@@ -857,14 +915,14 @@ class Entity:
 
     def inspectHere(self, x: int, y: int, z: int) -> Block :
         """
-        自分を中心に指定された座標のブロックを調べる。
+        自分を中心に指定された座標のブロックを調べる
 
         Args:
-            x (int): X座標。
-            y (int): Y座標。
-            z (int): Z座標。
+            x (int): X座標
+            y (int): Y座標
+            z (int): Z座標
         Returns:
-            Block: 調べたブロックの情報。    
+            Block: 調べたブロックの情報    
         """
         self.client.sendCall(self.uuid, "inspect", [x, y, z, "^"])
         block = Block(** json.loads(self.client.result))
@@ -872,10 +930,10 @@ class Entity:
 
     def inspect(self) -> Block :
         """
-        自分のいる場所のブロックを調べる。
+        自分のいる場所のブロックを調べる
 
         Returns:
-            Block: 調べたブロックの情報。    
+            Block: 調べたブロックの情報    
         """
         self.client.sendCall(self.uuid, "inspect", [0, 0, 0])
         block = Block(** json.loads(self.client.result))
@@ -883,10 +941,10 @@ class Entity:
 
     def inspectUp(self) -> Block :
         """
-        自分を真上のブロックを調べる。
+        自分を真上のブロックを調べる
 
         Returns:
-            Block: 調べたブロックの情報。    
+            Block: 調べたブロックの情報    
         """
         self.client.sendCall(self.uuid, "inspect", [0, 1, 0])
         block = Block(** json.loads(self.client.result))
@@ -894,10 +952,10 @@ class Entity:
 
     def inspectDown(self) -> Block :
         """
-        自分の足元のブロックを調べる。
+        自分の足元のブロックを調べる
 
         Returns:
-            Block: 調べたブロックの情報。    
+            Block: 調べたブロックの情報    
         """
         self.client.sendCall(self.uuid, "inspect", [0, -1, 0])
         block = Block(** json.loads(self.client.result))
@@ -905,9 +963,9 @@ class Entity:
 
     def getLocation(self) -> Location :
         """
-        自分の現在位置を調べる。
+        自分の現在位置を調べる
         Returns:
-            Location: 調べた位置情報。    
+            Location: 調べた位置情報    
         """
         self.client.sendCall(self.uuid, "getPosition")
         location = Location(** json.loads(self.client.result))
@@ -915,35 +973,35 @@ class Entity:
     
     def teleport(self, location: Location) :
         """
-        自分を指定されたワールド座標に移動する。
+        自分を指定されたワールド座標に移動する
         Args:
-            location (Location): 座標。
+            location (Location): 座標
         """
         self.client.sendCall(self.uuid, "teleport", [location.x, location.y, location.z, Coordinates.world])
 
     def isBlocked(self) -> bool :
         """
-        自分の前方にブロックがあるかどうか調べる。
+        自分の前方にブロックがあるかどうか調べる
         Returns:
-            bool: 調べた結果。    
+            bool: 調べた結果    
         """
         self.client.sendCall(self.uuid, "isBlockedFront")
         return str_to_bool(self.client.result)
 
     def isBlockedUp(self) -> bool :
         """
-        自分の真上にブロックがあるかどうか調べる。
+        自分の真上にブロックがあるかどうか調べる
         Returns:
-            bool: 調べた結果。    
+            bool: 調べた結果    
         """
         self.client.sendCall(self.uuid, "isBlockedUp")
         return str_to_bool(self.client.result)
 
     def isBlockedDown(self) -> bool :
         """
-        自分の真下にブロックがあるかどうか調べる。
+        自分の真下にブロックがあるかどうか調べる
         Returns:
-            bool: 調べた結果。    
+            bool: 調べた結果    
         """
         self.client.sendCall(self.uuid, "isBlockedDown")
         return str_to_bool(self.client.result)
@@ -951,91 +1009,90 @@ class Entity:
 
     def canDig(self) -> bool :
         """
-        自分の前方のブロックが壊せるかどうか調べる。
+        自分の前方のブロックが壊せるかどうか調べる
         Returns:
-            bool: 調べた結果。    
+            bool: 調べた結果    
         """
         self.client.sendCall(self.uuid, "isCanDigFront")
         return str_to_bool(self.client.result)
 
     def canDigUp(self) -> bool :
         """
-        自分の上のブロックが壊せるかどうか調べる。
+        自分の上のブロックが壊せるかどうか調べる
         Returns:
-            bool: 調べた結果。    
+            bool: 調べた結果    
         """
         self.client.sendCall(self.uuid, "isCanDigUp")
         return str_to_bool(self.client.result)
 
     def canDigDown(self) -> bool :
         """
-        自分の下のブロックが壊せるかどうか調べる。
+        自分の下のブロックが壊せるかどうか調べる
         Returns:
-            bool: 調べた結果。    
+            bool: 調べた結果    
         """
         self.client.sendCall(self.uuid, "isCanDigDown")
         return str_to_bool(self.client.result)
 
     def lookAtTarget(self, uuid) -> bool:
         """
-        指定されたエンティティを見る。
+        指定されたエンティティを見る
         Args:
-            uuid (str): エンティティのUUID。
+            uuid (str): エンティティのUUID
         Returns:
-            bool: 調べた結果。    
+            bool: 調べた結果    
         """
         self.client.sendCall(self.uuid, "lookAtTarget", [uuid])
         return str_to_bool(self.client.result)
 
     def getDistance(self) -> float :
         """
-        自分と前方のターゲットとの距離を調べる。
+        自分と前方のターゲットとの距離を調べる
         """
         self.client.sendCall(self.uuid, "getTargetDistanceFront")
         return self.client.result
 
     def getDistanceUp(self) -> float :
         """
-        自分と真上のターゲットとの距離を調べる。
+        自分と真上のターゲットとの距離を調べる
         """
         self.client.sendCall(self.uuid, "getTargetDistanceUp")
         return float(self.client.result)
 
     def getDistanceDown(self) -> float :
         """
-        自分と真下のターゲットとの距離を調べる。
+        自分と真下のターゲットとの距離を調べる
         """
         self.client.sendCall(self.uuid, "getTargetDistanceDown")
         return self.client.result
 
     def getDistanceTarget(self, uuid) -> float :
         """
-        自分とターゲットとの距離を調べる。
+        自分とターゲットとの距離を調べる
         """
         self.client.sendCall(self.uuid, "getTargetDistance", [uuid])
         return self.client.result
 
-    def setBlock(self, cord: Coordinates, x: int, y: int, z: int, block: str, data: int = 0):
+    def setBlock(self, x: int, y: int, z: int, block: str, data: int = 0):
         """
-        指定された座標にブロックを設置する。（クリエイティブ）
+        指定された座標にブロックを設置する（クリエイティブ）
 
         Args:
-            cord (Coordinates): 座標の種類（'', '^', '~'）。
-            x (int): 絶対的なX座標。
-            y (int): 絶対的なY座標。
-            z (int): 絶対的なZ座標。
-            block (str): 設置するブロックの種類。
+            x (int): 絶対的なX座標
+            y (int): 絶対的なY座標
+            z (int): 絶対的なZ座標
+            block (str): 設置するブロックの種類
         """
-        self.client.sendCall(self.uuid, "setBlock", [x, y, z, cord, block, data])
+        self.client.sendCall(self.uuid, "setBlock", [x, y, z, "", block, data])
 
     def getBlock(self, x: int, y: int, z: int) -> Block :
         """
-        指定された座標のブロックを取得する。
+        指定された座標のブロックを取得する
 
         Args:
-            x (int): 絶対的なX座標。
-            y (int): 絶対的なY座標。
-            z (int): 絶対的なZ座標。
+            x (int): 絶対的なX座標
+            y (int): 絶対的なY座標
+            z (int): 絶対的なZ座標
         """
         self.client.sendCall(self.uuid, "getBlock", [x, y, z])
         block = Block(** json.loads(self.client.result))
@@ -1043,7 +1100,7 @@ class Entity:
 
     def getBlockByColor(self, color: str) -> Block :
         """
-        指定された色に近いブロックを取得する。
+        指定された色に近いブロックを取得する
 
         Args:
             color (str): ブロックの色(HexRGB形式)

{py2hackcraft2-1.0.20 → py2hackcraft2-1.0.22}/py2hackCraft2.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: py2hackCraft2
-Version: 1.0.20
+Version: 1.0.22
 Summary: These are APIs that connect to the hackCraft2 server from Python to manipulate pets.
 Home-page: https://pypi.org/project/py2hackCraft2/
 Author: Masafumi Terazono

{py2hackcraft2-1.0.20 → py2hackcraft2-1.0.22}/setup.py

@@ -5,7 +5,7 @@ long_description = (this_directory / "py2hackCraft/README.md").read_text()
 
 setup(
     name="py2hackCraft2",
-    version="1.0.20",
+    version="1.0.22",
     packages=find_packages(),
     install_requires=[
         "websocket-client"  # websocketライブラリの追加