rustplus 6.0.11__tar.gz → 6.1.0__tar.gz

{rustplus-6.0.11/rustplus.egg-info → rustplus-6.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rustplus
-Version: 6.0.11
+Version: 6.1.0
 Summary: A python wrapper for the Rust Plus API
 Home-page: https://github.com/olijeffers0n/rustplus
 Author: olijeffers0n
@@ -60,6 +60,8 @@ pip install rustplus
 - Getting the time
 - Using Smart Devices
 - Camera Handling
+- Interacting with clans
+- Getting nexus information
 
 # For information on all the above methods, see the [Wiki](https://rplus.ollieee.xyz)
 

{rustplus-6.0.11 → rustplus-6.1.0}/README.md

@@ -29,6 +29,8 @@ pip install rustplus
 - Getting the time
 - Using Smart Devices
 - Camera Handling
+- Interacting with clans
+- Getting nexus information
 
 # For information on all the above methods, see the [Wiki](https://rplus.ollieee.xyz)
 

{rustplus-6.0.11 → rustplus-6.1.0}/rustplus/__init__.py

@@ -4,9 +4,17 @@ RustPlus, An API wrapper for interfacing with the Rust+ App API
 
 from .rust_api import RustSocket
 from .identification import ServerDetails
-from .annotations import Command, ChatEvent, ProtobufEvent, TeamEvent, EntityEvent
+from .annotations import (
+    Command,
+    ChatEvent,
+    ProtobufEvent,
+    TeamEvent,
+    EntityEvent,
+    ClanEvent,
+)
 from .remote.fcm import FCMListener
 from .remote.camera import MovementControls, CameraMovementOptions
+from .remote.nexus import NexusInterface, Realm
 from .commands import CommandOptions, ChatCommand
 from .events import ChatEventPayload, TeamEventPayload, EntityEventPayload
 from .utils import convert_event_type_to_name, Emoji, convert_coordinates
@@ -14,5 +22,5 @@ from .structs import RustError, RustMarker, Vector
 
 __name__ = "rustplus"
 __author__ = "olijeffers0n"
-__version__ = "6.0.11"
+__version__ = "6.1.0"
 __support__ = "Discord: https://discord.gg/nQqJe8qvP8"

{rustplus-6.0.11 → rustplus-6.1.0}/rustplus/annotations/__init__.py

@@ -3,3 +3,4 @@ from .entity_event import EntityEvent
 from .chat_event import ChatEvent
 from .team_event import TeamEvent
 from .protobuf_event import ProtobufEvent
+from .clan_event import ClanEvent

rustplus-6.1.0/rustplus/annotations/clan_event.py

@@ -0,0 +1,21 @@
+from typing import Callable
+
+from .. import ServerDetails
+from ..identification import RegisteredListener
+from ..events import ClanInfoEventPayload as ClanInfoEventManager
+
+
+def ClanEvent(server_details: ServerDetails) -> Callable:
+
+    def wrapper(func) -> RegisteredListener:
+
+        if isinstance(func, RegisteredListener):
+            func = func.get_coro()
+
+        listener = RegisteredListener(func.__name__, func)
+
+        ClanInfoEventManager.HANDLER_LIST.register(listener, server_details)
+
+        return listener
+
+    return wrapper

{rustplus-6.0.11 → rustplus-6.1.0}/rustplus/events/__init__.py

@@ -2,3 +2,4 @@ from .chat_event import ChatEventPayload
 from .entity_event import EntityEventPayload
 from .team_event import TeamEventPayload
 from .protobuf_event import ProtobufEventPayload
+from .clan_info_event import ClanInfoEventPayload

rustplus-6.1.0/rustplus/events/chat_event.py

@@ -0,0 +1,27 @@
+from rustplus.identification.handler_list import HandlerList
+from ..structs import RustChatMessage
+
+from typing import Union
+
+
+class ChatEventPayload:
+    HANDLER_LIST = HandlerList()
+
+    def __init__(
+        self, message: RustChatMessage, is_clan: bool, clan_id: Union[int, None]
+    ) -> None:
+        self._message = message
+        self._is_clan = is_clan
+        self._clan_id = clan_id
+
+    @property
+    def message(self) -> RustChatMessage:
+        return self._message
+
+    @property
+    def is_clan(self) -> bool:
+        return self._is_clan
+
+    @property
+    def clan_id(self) -> Union[int, None]:
+        return self._clan_id

rustplus-6.1.0/rustplus/events/clan_info_event.py

@@ -0,0 +1,13 @@
+from rustplus.identification.handler_list import HandlerList
+from ..structs import RustClanInfo
+
+
+class ClanInfoEventPayload:
+    HANDLER_LIST = HandlerList()
+
+    def __init__(self, clan_info: RustClanInfo) -> None:
+        self._clan_info = clan_info
+
+    @property
+    def clan_info(self) -> RustClanInfo:
+        return self._clan_info

rustplus-6.1.0/rustplus/remote/camera/camera_constants.py

@@ -0,0 +1,32 @@
+class MovementControls:
+    """
+    Possible inputs for the camera movement.
+    """
+
+    FORWARD = 2
+    BACKWARD = 4
+    LEFT = 8
+    RIGHT = 16
+    JUMP = 32
+    DUCK = 64
+    SPRINT = 128
+    USE = 256
+    FIRE_PRIMARY = 1024
+    FIRE_SECONDARY = 2048
+    RELOAD = 8192
+    FIRE_THIRD = 134217728
+
+
+class CameraMovementOptions:
+    """
+    Indicate which camera controls are active for the camera.
+
+    """
+
+    NONE = 0
+    MOVEMENT = 1
+    MOUSE = 2
+    SPRINT_AND_DUCK = 4
+    FIRE = 8
+    RELOAD = 16
+    CROSSHAIR = 32

{rustplus-6.0.11 → rustplus-6.1.0}/rustplus/remote/camera/camera_manager.py

@@ -58,8 +58,8 @@ class CameraManager:
     async def _create_frame(
         self,
         render_entities: bool = True,
-        entity_render_distance: float = float("inf"),
-        max_entity_amount: int = float("inf"),
+        entity_render_distance: float | int = float("inf"),
+        max_entity_amount: float | int = float("inf"),
     ) -> Union[Image.Image, None]:
         if self._last_packets is None:
             return None
@@ -95,8 +95,8 @@ class CameraManager:
     async def get_frame(
         self,
         render_entities: bool = True,
-        entity_render_distance: float = float("inf"),
-        max_entity_amount: int = float("inf"),
+        entity_render_distance: float | int = float("inf"),
+        max_entity_amount: float | int = float("inf"),
     ) -> Union[Image.Image, None]:
         return await self._create_frame(
             render_entities, entity_render_distance, max_entity_amount

{rustplus-6.0.11 → rustplus-6.1.0}/rustplus/remote/camera/camera_parser.py

@@ -7,7 +7,6 @@ import numpy as np
 from scipy.spatial import ConvexHull
 from PIL import Image, ImageDraw, ImageFont
 
-from .camera_constants import LOOKUP_CONSTANTS
 from .structures import Entity, Vector3
 
 SCIENTIST_COLOUR = "#3098f2"
@@ -44,6 +43,8 @@ class Parser:
         self.entities = []
         self.last_fov = 0
 
+        self.lookup_constants = self._generate_lookup_constants(self.width, self.height)
+
     def reset_output(self) -> None:
         self.colour_output = np.full(
             (self.width * self.scale_factor, self.height * self.scale_factor, 3),
@@ -53,6 +54,42 @@ class Parser:
             (self.width * self.scale_factor, self.height * self.scale_factor)
         )
 
+    @staticmethod
+    def _generate_lookup_constants(width: int, height: int) -> List[int]:
+        instance_count = width * height
+
+        sample_position_buffer = [0] * (instance_count * 2)
+
+        buffer_index = 0
+
+        for y in range(height):
+            for x in range(width):
+                sample_position_buffer[buffer_index] = RNGSource.int32(x)
+                buffer_index += 1
+
+                sample_position_buffer[buffer_index] = RNGSource.int32(y)
+                buffer_index += 1
+
+        rng = RNGSource(1337)
+
+        for current_position in range(instance_count - 1, 0, -1):
+            current_index = 2 * current_position
+            random_position = 2 * rng.next_int(current_position + 1)
+
+            current_x = sample_position_buffer[current_index]
+            current_y = sample_position_buffer[current_index + 1]
+
+            random_x = sample_position_buffer[random_position]
+            random_y = sample_position_buffer[random_position + 1]
+
+            sample_position_buffer[random_position] = current_x
+            sample_position_buffer[random_position + 1] = current_y
+
+            sample_position_buffer[current_index] = random_x
+            sample_position_buffer[current_index + 1] = random_y
+
+        return sample_position_buffer
+
     def handle_camera_ray_data(self, data) -> None:
         if data is None:
             return
@@ -90,9 +127,11 @@ class Parser:
             alignment = ray[1]
             material = ray[2]
 
-            index1 = LOOKUP_CONSTANTS[self._sample_offset]
+            index1 = self.lookup_constants[self._sample_offset]
             self._sample_offset += 1
-            index2 = int(LOOKUP_CONSTANTS[self._sample_offset] * self.width + index1)
+            index2 = int(
+                self.lookup_constants[self._sample_offset] * self.width + index1
+            )
             self._sample_offset += 1
 
             x = (index2 % self.width) * self.scale_factor
@@ -786,3 +825,47 @@ class MathUtils:
 
         # Return the vertices that correspond to the non-zero indices
         return np.array(list(zip(x, y)))
+
+
+class RNGSource:
+    def __init__(self, seed):
+        self.state = self.int32(seed)
+        self.next_state()
+
+    def next_int(self, e):
+        t = self.int32((self.next_state() * self.int32(e)) / 4294967295)
+
+        if t < 0:
+            t = e + t - 1
+
+        return self.int32(t)
+
+    def next_state(self):
+        e = self.state
+        t = e
+
+        e = self.int32(e ^ self.int32(e << 13))
+        e = self.int32(e ^ (self.uint32(e) >> 17))
+        e = self.int32(e ^ self.int32(e << 5))
+
+        self.state = e
+
+        return self.clamp(t)
+
+    @staticmethod
+    def clamp(e):
+        return e if e >= 0 else 4294967295 + e - 1
+
+    @staticmethod
+    def int32(value):
+        value = int(value)
+        value &= 0xFFFFFFFF
+
+        if value >= 0x80000000:
+            value -= 0x100000000
+
+        return value
+
+    @staticmethod
+    def uint32(value):
+        return value & 0xFFFFFFFF

rustplus-6.1.0/rustplus/remote/nexus/__init__.py

@@ -0,0 +1 @@
+from .nexus_interface import NexusInterface, Realm

rustplus-6.1.0/rustplus/remote/nexus/nexus_interface.py

@@ -0,0 +1,45 @@
+from typing import Any
+
+import requests
+import enum
+
+
+class Realm(enum.Enum):
+    Development = 0
+    Staging = 1
+    Production = 2
+
+
+class NexusInterface:
+    def __init__(self, endpoint: str):
+        self.session = requests.Session()
+        self.endpoint = endpoint
+
+    def get_all_nexus(self, public_key: str, realm: Realm) -> Any | None:
+
+        res = self.session.get(
+            f"{self.endpoint}?publicKey={public_key}&realm={realm.value}"
+        )
+
+        if res.status_code == 200:
+            return res.json()
+
+        return None
+
+    def get_nexus_info(self, nexus_id: int) -> Any | None:
+
+        res = self.session.get(f"{self.endpoint}/{nexus_id}")
+
+        if res.status_code == 200:
+            return res.json()
+
+        return None
+
+    def get_nexus_map(self, nexus_id: int) -> Any | None:
+
+        res = self.session.get(f"{self.endpoint}/{nexus_id}/map")
+
+        if res.status_code == 200:
+            return res.content
+
+        return None

{rustplus-6.0.11 → rustplus-6.1.0}/rustplus/remote/websocket/ws.py

@@ -19,9 +19,10 @@ from ...events import (
     TeamEventPayload,
     ChatEventPayload,
 )
+from ...events.clan_info_event import ClanInfoEventPayload
 from ...exceptions import RequestError
 from ...identification import ServerDetails, RegisteredListener
-from ...structs import RustChatMessage, RustTeamInfo
+from ...structs import RustChatMessage, RustTeamInfo, RustClanInfo
 from ...utils import YieldingEvent, convert_time
 from ...utils.utils import error_present
 
@@ -274,14 +275,40 @@ class RustWebsocket:
             for handler in handlers:
                 await handler.get_coro()(team_event)
 
-        elif self.is_message(app_message):
+        elif self.is_clan_broadcast(app_message):
+            # Clan Event
+            if self.debug:
+                self.logger.info(f"Running Clan Event: {app_message}")
+
+            # This means that the clan of the current player has changed
+            handlers = ClanInfoEventPayload.HANDLER_LIST.get_handlers(
+                self.server_details
+            )
+            clan_event = ClanInfoEventPayload(
+                RustClanInfo(app_message.broadcast.clan_changed.clan_info)
+            )
+            for handler in handlers:
+                await handler.get_coro()(clan_event)
+
+        elif self.is_message(app_message) or self.is_clan_message(app_message):
             # Chat message event
+
+            is_clan = self.is_clan_message(app_message)
+
             if self.debug:
-                self.logger.info(f"Running Chat Event: {app_message}")
+                self.logger.info(
+                    f"Running Chat Event: {app_message}, is_clan={is_clan}"
+                )
 
             handlers = ChatEventPayload.HANDLER_LIST.get_handlers(self.server_details)
             chat_event = ChatEventPayload(
-                RustChatMessage(app_message.broadcast.team_message.message)
+                RustChatMessage(
+                    app_message.broadcast.clan_message.message
+                    if is_clan
+                    else app_message.broadcast.team_message.message
+                ),
+                is_clan,
+                app_message.broadcast.clan_message.clan_id if is_clan else None,
             )
             for handler in handlers:
                 await handler.get_coro()(chat_event)
@@ -321,6 +348,12 @@ class RustWebsocket:
             app_message.broadcast.team_message.message
         )
 
+    @staticmethod
+    def is_clan_message(app_message: AppMessage) -> bool:
+        return betterproto.serialized_on_wire(
+            app_message.broadcast.clan_message.message
+        )
+
     @staticmethod
     def is_camera_broadcast(app_message: AppMessage) -> bool:
         return betterproto.serialized_on_wire(app_message.broadcast.camera_rays)
@@ -334,27 +367,8 @@ class RustWebsocket:
         return betterproto.serialized_on_wire(app_message.broadcast.team_changed)
 
     @staticmethod
-    def get_proto_cost(app_request: AppRequest) -> int:
-        """
-        Gets the cost of an AppRequest
-        """
-        costs = [
-            (app_request.get_time, 1),
-            (app_request.send_team_message, 2),
-            (app_request.get_info, 1),
-            (app_request.get_team_chat, 1),
-            (app_request.get_team_info, 1),
-            (app_request.get_map_markers, 1),
-            (app_request.get_map, 5),
-            (app_request.set_entity_value, 1),
-            (app_request.get_entity_info, 1),
-            (app_request.promote_to_leader, 1),
-        ]
-        for request, cost in costs:
-            if betterproto.serialized_on_wire(request):
-                return cost
-
-        raise ValueError()
+    def is_clan_broadcast(app_message: AppMessage) -> bool:
+        return betterproto.serialized_on_wire(app_message.broadcast.clan_changed)
 
     @staticmethod
     async def run_coroutine_non_blocking(coroutine: Coroutine) -> Task:

{rustplus-6.0.11 → rustplus-6.1.0}/rustplus/rust_api.py

@@ -19,6 +19,7 @@ from .remote.rustplus_proto import (
     AppCameraSubscribe,
     AppMapMonument,
     AppFlag,
+    AppGetNexusAuth,
 )
 from .remote.websocket import RustWebsocket
 from .structs import (
@@ -31,6 +32,9 @@ from .structs import (
     RustEntityInfo,
     RustContents,
     RustItem,
+    RustClanInfo,
+    RustClanMessage,
+    RustAuthDetails,
 )
 from .structs.rust_error import RustError
 from .utils import (
@@ -61,13 +65,16 @@ class RustSocket:
         self.command_options = command_options
         self.logger = logging.getLogger("rustplus.py")
 
-        console_handler = logging.StreamHandler()
-        console_handler.setLevel(logging.DEBUG)
-        console_handler.setFormatter(
-            logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
-        )
-        self.logger.addHandler(console_handler)
-        self.logger.setLevel(logging.DEBUG)
+        if not self.logger.handlers:
+            console_handler = logging.StreamHandler()
+            console_handler.setLevel(logging.DEBUG)
+            console_handler.setFormatter(
+                logging.Formatter(
+                    "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+                )
+            )
+            self.logger.addHandler(console_handler)
+            self.logger.setLevel(logging.DEBUG)
 
         self.ws = RustWebsocket(
             self.server_details,
@@ -337,7 +344,7 @@ class RustSocket:
 
             for marker in map_markers:
                 if add_events:
-                    if marker.type in [2, 4, 5, 6, 8]:
+                    if marker.type in RustMarker.Events:
                         icon = convert_marker(int(marker.type), marker.rotation)
                         if marker.type == 6:
                             x, y = marker.x, marker.y
@@ -563,3 +570,94 @@ class RustSocket:
             return RustError("get_camera_manager", response.response.error.error)
 
         return CameraManager(self, cam_id, response.response.camera_subscribe_info)
+
+    async def get_clan_info(self) -> Union[RustClanInfo, RustError]:
+        """
+        Gets the clan information for the player's current clan.
+
+        :return RustClanInfo: The clan information
+        """
+        packet = await self._generate_request(tokens=1)
+        packet.get_clan_info = AppEmpty()
+        response = await self.ws.send_and_get(packet)
+
+        if response is None:
+            return RustError("get_clan_info", "No response received")
+
+        if error_present(response):
+            return RustError("get_clan_info", response.response.error.error)
+
+        return RustClanInfo(response.response.clan_info.clan_info)
+
+    async def get_clan_chat(self) -> Union[List[RustClanMessage], RustError]:
+        """
+        Gets the clan chat for the player's current clan.
+
+        :return List[RustClanMessage]: The clan chat
+        """
+        packet = await self._generate_request(tokens=1)
+        packet.get_clan_chat = AppEmpty()
+        response = await self.ws.send_and_get(packet)
+
+        if response is None:
+            return RustError("get_clan_chat", "No response received")
+
+        if error_present(response):
+            return RustError("get_clan_chat", response.response.error.error)
+
+        return [
+            RustClanMessage(message) for message in response.response.clan_chat.messages
+        ]
+
+    async def send_clan_message(self, message: str) -> None:
+        """
+        Sends a message to the in-game clan chat
+
+        :param message: The string message to send
+        """
+
+        packet = await self._generate_request(tokens=2)
+        send_message = AppSendMessage()
+        send_message.message = message
+        packet.send_clan_message = send_message
+
+        await self.ws.send_message(packet, True)
+
+    async def set_clan_motd(self, message: str) -> None:
+        """
+        Sets the clan's message of the day
+
+        :param message: The string message to set as the clan's message of the day
+        """
+
+        packet = await self._generate_request()
+        send_message = AppSendMessage()
+        send_message.message = message
+        packet.set_clan_motd = send_message
+
+        await self.ws.send_message(packet, True)
+
+    async def get_nexus_auth(self, app_key: str) -> Union[RustAuthDetails, RustError]:
+        """
+        Gets the auth for a server. Does not require that the player token of this RustSocket is set correctly.
+
+        :param app_key: The app key to use. I do not know how you would get this currently, without owning the server.
+        """
+
+        packet = await self._generate_request()
+        send_message = AppGetNexusAuth()
+        send_message.app_key = app_key
+        packet.get_nexus_auth = send_message
+
+        response = await self.ws.send_and_get(packet)
+
+        if response is None:
+            return RustError("get_nexus_auth", "No response received")
+
+        if error_present(response):
+            return RustError("get_nexus_auth", response.response.error.error)
+
+        return RustAuthDetails(
+            response.response.nexus_auth.server_id,
+            response.response.nexus_auth.player_token,
+        )

{rustplus-6.0.11 → rustplus-6.1.0}/rustplus/structs/__init__.py

@@ -7,5 +7,6 @@ from .rust_team_info import RustTeamInfo, RustTeamMember, RustTeamNote
 from .rust_entity_info import RustEntityInfo
 from .rust_contents import RustContents
 from .rust_item import RustItem
-from .util import Vector
+from .util import Vector, RustAuthDetails
 from .rust_error import RustError
+from .clans import *

rustplus-6.1.0/rustplus/structs/clans/__init__.py

@@ -0,0 +1,2 @@
+from .rust_clan_message import RustClanMessage
+from .rust_clan_info import RustClanInfo