highrise.bot 1.0.0

package/src/classes/Actions/Player.js

@@ -0,0 +1,604 @@
+const { reactions, gold_bars, FacingTypes } = require("highrise.js/src/constants/TypesConstants");
+const ErrorConstants = require('highrise.js/src/constants/ErrorConstants');
+
+class PlayerClass {
+    constructor(bot) {
+        this.bot = bot;
+
+        this.HighriseError = bot.HighriseError;
+        this.HighriseResponse = bot.HighriseResponse;
+    }
+
+    async walk(x, y, z, facing = 'FrontRight') {
+        try {
+            if (typeof x !== 'number' || typeof y !== 'number' || typeof z !== 'number') {
+                return new this.HighriseError(
+                    ErrorConstants.VALIDATION.INVALID_COORDINATES,
+                    'Coordinates must be numbers',
+                    { x, y, z }
+                ).toResult();
+            }
+
+            if (typeof facing !== 'string' || !FacingTypes.includes(facing)) {
+                return new this.HighriseError(
+                    ErrorConstants.VALIDATION.INVALID_FACING,
+                    `Facing must be a valid facing string ( ${FacingTypes.join(', ')} )`,
+                    { facing }
+                ).toResult();
+            }
+
+            const destination = { x, y, z, facing };
+            const payload = {
+                _type: 'FloorHitRequest',
+                destination: destination
+            };
+
+            const response = await this.bot._fireAndForget.send(payload);
+
+            if (response.success) {
+                return this.HighriseResponse.success('walked', {
+                    position: { x, y, z, facing },
+                    timestamp: Date.now()
+                });
+            }
+        } catch (error) {
+            return new this.HighriseError(
+                ErrorConstants.HIGHRISE_API.API_SERVER_ERROR,
+                `Failed to walk: ${error.message}`,
+                { x, y, z, facing }
+            ).toResult();
+        }
+    }
+
+    async sit(entity_id, anchor_ix = 0) {
+        try {
+            if (typeof entity_id !== 'string' || !entity_id.trim()) {
+                return new this.HighriseError(
+                    ErrorConstants.VALIDATION.INVALID_PARAMETER,
+                    'Entity ID must be a non-empty string',
+                    { entity_id }
+                ).toResult();
+            }
+
+            if (typeof anchor_ix !== 'number' || anchor_ix < 0) {
+                return new this.HighriseError(
+                    ErrorConstants.VALIDATION.INVALID_PARAMETER,
+                    'Anchor index must be a positive number',
+                    { anchor_ix }
+                ).toResult();
+            }
+
+            const anchor = { entity_id, anchor_ix };
+            const payload = {
+                _type: 'AnchorHitRequest',
+                anchor: anchor
+            };
+
+            const response = await this.bot._fireAndForget.send(payload);
+
+            if (response.success) {
+                return this.HighriseResponse.success('sat', {
+                    entity_id, anchor_ix,
+                    timestamp: Date.now()
+                });
+            }
+        } catch (error) {
+            return new this.HighriseError(
+                ErrorConstants.HIGHRISE_API.API_SERVER_ERROR,
+                `Failed to sit: ${error.message}`,
+                { entity_id, anchor_ix }
+            ).toResult();
+        }
+    }
+
+    async teleport(user_id, x, y, z, facing = 'FrontRight') {
+        try {
+            if (typeof user_id !== 'string' || !user_id.trim()) {
+                return this.HighriseError.invalidUserId(user_id).toResult();
+            }
+
+            if (typeof x !== 'number' || typeof y !== 'number' || typeof z !== 'number') {
+                return new this.HighriseError(
+                    ErrorConstants.VALIDATION.INVALID_COORDINATES,
+                    'Coordinates must be numbers',
+                    { x, y, z }
+                ).toResult();
+            }
+
+            if (typeof facing !== 'string' || !FacingTypes.includes(facing)) {
+                return new this.HighriseError(
+                    ErrorConstants.VALIDATION.INVALID_FACING,
+                    `Facing must be a valid facing string ( ${FacingTypes.join(', ')} )`,
+                    { facing }
+                ).toResult();
+            }
+
+            const payload = {
+                _type: 'TeleportRequest',
+                user_id: user_id,
+                destination: { x, y, z, facing }
+            };
+
+            const response = await this.bot._fireAndForget.send(payload);
+
+            if (response.success) {
+                return this.HighriseResponse.success('teleported', {
+                    user_id, position: { x, y, z, facing },
+                    timestamp: Date.now()
+                });
+            }
+        } catch (error) {
+            return new this.HighriseError(
+                ErrorConstants.HIGHRISE_API.API_SERVER_ERROR,
+                `Failed to teleport: ${error.message}`,
+                { user_id, position: { x, y, z, facing } }
+            ).toResult();
+        }
+    }
+
+    async transport(user_id, room_id) {
+        try {
+            if (typeof user_id !== 'string' || !user_id.trim()) {
+                return this.HighriseError.invalidUserId(user_id).toResult();
+            }
+
+            if (typeof room_id !== 'string' || !room_id.trim()) {
+                return new this.HighriseError(
+                    ErrorConstants.VALIDATION.INVALID_ROOM_ID,
+                    'Room ID must be a non-empty string',
+                    { room_id }
+                ).toResult();
+            }
+
+            if (user_id === this.bot.info.user?.id) {
+                return new this.HighriseError(
+                    ErrorConstants.ROOM.CANNOT_TRANSPORT_SELF,
+                    'Cannot transport self to another room',
+                    { user_id, bot_id: this.bot.info.user?.id }
+                ).toResult();
+            }
+
+            const payload = {
+                _type: 'MoveUserToRoomRequest',
+                user_id: user_id,
+                room_id: room_id
+            };
+
+            const response = await this.bot._fireAndForget.send(payload);
+
+            if (response.success) {
+                return this.HighriseResponse.success('transported', {
+                    user_id, room_id,
+                    timestamp: Date.now()
+                });
+            }
+        } catch (error) {
+            return new this.HighriseError(
+                ErrorConstants.HIGHRISE_API.API_SERVER_ERROR,
+                `Failed to transport user: ${error.message}`,
+                { user_id, room_id }
+            ).toResult();
+        }
+    }
+
+    async emote(emote_id, user_id) {
+        try {
+            if (typeof emote_id !== 'string' || !emote_id.trim()) {
+                return new this.HighriseError(
+                    ErrorConstants.VALIDATION.INVALID_EMOTE_ID,
+                    'Emote ID must be a non-empty string',
+                    { emote_id }
+                ).toResult();
+            }
+
+            if (user_id !== undefined && (typeof user_id !== 'string' || !user_id.trim())) {
+                return this.HighriseError.invalidUserId(user_id).toResult();
+            }
+
+            const payload = {
+                _type: 'EmoteRequest',
+                emote_id: emote_id,
+                target_user_id: user_id
+            };
+
+            const response = await this.bot._fireAndForget.send(payload);
+
+            if (response.success) {
+                return this.HighriseResponse.success('emoted', {
+                    emote_id, user_id,
+                    timestamp: Date.now()
+                });
+            }
+        } catch (error) {
+            return new this.HighriseError(
+                ErrorConstants.HIGHRISE_API.API_SERVER_ERROR,
+                `Failed to play emote: ${error.message}`,
+                { emote_id, user_id }
+            ).toResult();
+        }
+    }
+
+    async react(user_id, reaction) {
+        try {
+            if (typeof user_id !== 'string' || !user_id.trim()) {
+                return this.HighriseError.invalidUserId(user_id).toResult();
+            }
+
+            if (typeof reaction !== 'string' || !reaction.trim()) {
+                return new this.HighriseError(
+                    ErrorConstants.VALIDATION.INVALID_REACTION,
+                    'Reaction must be a non-empty string',
+                    { reaction }
+                ).toResult();
+            }
+
+            if (!reactions.includes(reaction)) {
+                return new this.HighriseError(
+                    ErrorConstants.VALIDATION.INVALID_REACTION,
+                    `Invalid reaction: ${reaction}`,
+                    { reaction, valid_reactions: reactions }
+                ).toResult();
+            }
+
+            const payload = {
+                _type: 'ReactionRequest',
+                reaction: reaction,
+                target_user_id: user_id
+            };
+
+            const response = await this.bot._fireAndForget.send(payload);
+
+            if (response.success) {
+                return this.HighriseResponse.success('reacted', {
+                    user_id, reaction,
+                    timestamp: Date.now()
+                });
+            }
+        } catch (error) {
+            return new this.HighriseError(
+                ErrorConstants.HIGHRISE_API.API_SERVER_ERROR,
+                `Failed to send reaction: ${error.message}`,
+                { user_id, reaction }
+            ).toResult();
+        }
+    }
+
+    async tip(user_id, gold_bar = 1) {
+        try {
+
+            const PayladGoldBars = {
+                1: "gold_bar_1",
+                5: "gold_bar_5",
+                10: "gold_bar_10",
+                50: "gold_bar_50",
+                100: "gold_bar_100",
+                500: "gold_bar_500",
+                1000: "gold_bar_1k",
+                5000: "gold_bar_5000",
+                10000: "gold_bar_10k"
+            };
+
+            if (typeof user_id !== 'string' || !user_id.trim()) {
+                return this.HighriseError.invalidUserId(user_id).toResult();
+            }
+
+            if (typeof gold_bar !== 'number' || gold_bar <= 0 || gold_bar > 10000) {
+                return new this.HighriseError(
+                    ErrorConstants.VALIDATION.INVALID_GOLDBARS,
+                    'Gold bar amount must be a positive number between 1 and 10000',
+                    { gold_bar }
+                ).toResult();
+            }
+
+            if (!gold_bars.includes(gold_bar)) {
+                return new this.HighriseError(
+                    ErrorConstants.VALIDATION.INVALID_GOLDBARS,
+                    `Invalid gold bar amount: ${gold_bar}`,
+                    { gold_bar, valid_amounts: gold_bars }
+                ).toResult();
+            }
+
+            if (user_id === this.bot.info.user?.id) {
+                return new this.HighriseError(
+                    ErrorConstants.PERMISSION.CANNOT_TIP_SELF,
+                    'Cannot tip yourself',
+                    { user_id }
+                ).toResult();
+            }
+
+            const payload = {
+                _type: 'TipUserRequest',
+                user_id: user_id,
+                gold_bar: PayladGoldBars[gold_bar]
+            };
+
+            const response = await this.bot._fireAndForget.send(payload);
+
+            if (response.success) {
+                return this.HighriseResponse.success('tipped', {
+                    user_id, gold_bar,
+                    timestamp: Date.now()
+                });
+            }
+        } catch (error) {
+            return new this.HighriseError(
+                ErrorConstants.HIGHRISE_API.API_SERVER_ERROR,
+                `Failed to tip user: ${error.message}`,
+                { user_id, gold_bar }
+            ).toResult();
+        }
+    }
+
+    async splitTip(user_id, amount, delay = 300) {
+        try {
+            if (typeof user_id !== 'string' || !user_id.trim()) {
+                return this.HighriseError.invalidUserId(user_id).toResult();
+            }
+
+            if (typeof amount !== 'number' || amount <= 0) {
+                return new this.HighriseError(
+                    ErrorConstants.VALIDATION.INVALID_GOLDBARS,
+                    'Amount must be a positive number',
+                    { amount }
+                ).toResult();
+            }
+
+            const splitAmounts = this.bot.utils.sequencingGoldBars(amount);
+
+            const results = [];
+            for (const goldBar of splitAmounts) {
+                const result = await this.tip(user_id, goldBar);
+                results.push(result);
+
+                if (delay > 0 && goldBar !== splitAmounts[splitAmounts.length - 1]) {
+                    await this.bot.utils.sleep(delay);
+                }
+            }
+
+            return this.HighriseResponse.success('split_tipped', {
+                user_id,
+                original_amount: amount,
+                split_amounts: splitAmounts,
+                results: results,
+                timestamp: Date.now()
+            });
+        } catch (error) {
+            return new this.HighriseError(
+                ErrorConstants.HIGHRISE_API.API_SERVER_ERROR,
+                `Failed to split tip: ${error.message}`,
+                { user_id, amount }
+            ).toResult();
+        }
+    }
+
+    outfit = {
+        get: async (user_id) => {
+            try {
+                if (typeof user_id !== 'string' || !user_id.trim()) {
+                    return this.HighriseError.invalidUserId(user_id).toResult();
+                }
+
+                const payload = {
+                    _type: 'GetUserOutfitRequest',
+                    user_id: user_id
+                };
+
+                const response = await this.bot._requestResponse.send(payload);
+                if (response.success) {
+                    return this.HighriseResponse.success('outfit', {
+                        user_id,
+                        items: response.data.outfit || [],
+                        count: (response.data.outfit || []).length
+                    });
+                }
+            } catch (error) {
+                return new this.HighriseError(
+                    ErrorConstants.HIGHRISE_API.API_SERVER_ERROR,
+                    `Failed to get user outfit: ${error.message}`,
+                    { user_id }
+                ).toResult();
+            }
+        }
+    }
+
+    moderation = {
+        kick: async (user_id) => {
+            try {
+                if (typeof user_id !== 'string' || !user_id.trim()) {
+                    return this.HighriseError.invalidUserId(user_id).toResult();
+                }
+
+                if (user_id === this.bot.info.user?.id) {
+                    return new this.HighriseError(
+                        ErrorConstants.PERMISSION.CANNOT_MODERATE_SELF,
+                        'Cannot moderate yourself',
+                        { user_id }
+                    ).toResult();
+                }
+
+                const payload = {
+                    _type: 'ModerateRoomRequest',
+                    user_id: user_id,
+                    moderation_action: 'kick',
+                    action_length: null
+                };
+
+                const response = await this.bot._fireAndForget.send(payload);
+
+                if (response.success) {
+                    return this.HighriseResponse.success('kicked', {
+                        user_id,
+                        action: 'kick',
+                        timestamp: Date.now()
+                    });
+                }
+            } catch (error) {
+                return new this.HighriseError(
+                    ErrorConstants.PERMISSION.INSUFFICIENT_PERMISSIONS,
+                    `Failed to kick user: ${error.message}`,
+                    { user_id }
+                ).toResult();
+            }
+        },
+
+        ban: async (user_id, duration = 3600000) => {
+            try {
+                if (typeof user_id !== 'string' || !user_id.trim()) {
+                    return this.HighriseError.invalidUserId(user_id).toResult();
+                }
+
+                if (user_id === this.bot.info.user?.id) {
+                    return new this.HighriseError(
+                        ErrorConstants.PERMISSION.CANNOT_MODERATE_SELF,
+                        'Cannot moderate yourself',
+                        { user_id }
+                    ).toResult();
+                }
+
+                const maxDuration = 69 * 365.2425 * 24 * 60 * 60 * 1000;
+                if (typeof duration !== 'number' || duration < 0 || duration > maxDuration) {
+                    return new this.HighriseError(
+                        ErrorConstants.VALIDATION.INVALID_PARAMETER,
+                        `Duration must be between 0 and ${maxDuration}ms`,
+                        { duration, max: maxDuration }
+                    ).toResult();
+                }
+
+                const payload = {
+                    _type: 'ModerateRoomRequest',
+                    user_id: user_id,
+                    moderation_action: 'ban',
+                    action_length: duration
+                };
+
+                const response = await this.bot._fireAndForget.send(payload);
+
+                if (response.success) {
+                    return this.HighriseResponse.success('banned', {
+                        user_id, duration,
+                        action: 'ban',
+                        timestamp: Date.now()
+                    });
+                }
+            } catch (error) {
+                return new this.HighriseError(
+                    ErrorConstants.PERMISSION.INSUFFICIENT_PERMISSIONS,
+                    `Failed to ban user: ${error.message}`,
+                    { user_id, duration }
+                ).toResult();
+            }
+        },
+
+        mute: async (user_id, duration = 300000) => {
+            try {
+                if (typeof user_id !== 'string' || !user_id.trim()) {
+                    return this.HighriseError.invalidUserId(user_id).toResult();
+                }
+
+                if (user_id === this.bot.info.user?.id) {
+                    return new this.HighriseError(
+                        ErrorConstants.PERMISSION.CANNOT_MODERATE_SELF,
+                        'Cannot moderate yourself',
+                        { user_id }
+                    ).toResult();
+                }
+
+                const maxDuration = 69 * 365.2425 * 24 * 60 * 60 * 1000;
+                if (typeof duration !== 'number' || duration < 0 || duration > maxDuration) {
+                    return new this.HighriseError(
+                        ErrorConstants.VALIDATION.INVALID_PARAMETER,
+                        `Duration must be between 0 and ${maxDuration}ms`,
+                        { duration, max: maxDuration }
+                    ).toResult();
+                }
+
+                const payload = {
+                    _type: 'ModerateRoomRequest',
+                    user_id: user_id,
+                    moderation_action: 'mute',
+                    action_length: duration
+                };
+
+                const response = await this.bot._fireAndForget.send(payload);
+
+                if (response.success) {
+                    return this.HighriseResponse.success('muted', {
+                        user_id, duration,
+                        action: 'mute',
+                        timestamp: Date.now()
+                    });
+                }
+            } catch (error) {
+                return new this.HighriseError(
+                    ErrorConstants.PERMISSION.INSUFFICIENT_PERMISSIONS,
+                    `Failed to mute user: ${error.message}`,
+                    { user_id, duration }
+                ).toResult();
+            }
+        },
+
+        unmute: async (user_id) => {
+            try {
+                if (typeof user_id !== 'string' || !user_id.trim()) {
+                    return this.HighriseError.invalidUserId(user_id).toResult();
+                }
+
+                const payload = {
+                    _type: 'ModerateRoomRequest',
+                    user_id: user_id,
+                    moderation_action: 'mute',
+                    action_length: 1
+                };
+
+                const response = await this.bot._fireAndForget.send(payload);
+
+                if (response.success) {
+                    return this.HighriseResponse.success('unmuted', {
+                        user_id,
+                        action: 'unmute',
+                        timestamp: Date.now()
+                    });
+                }
+            } catch (error) {
+                return new this.HighriseError(
+                    ErrorConstants.PERMISSION.INSUFFICIENT_PERMISSIONS,
+                    `Failed to unmute user: ${error.message}`,
+                    { user_id }
+                ).toResult();
+            }
+        },
+
+        unban: async (user_id) => {
+            try {
+                if (typeof user_id !== 'string' || !user_id.trim()) {
+                    return this.HighriseError.invalidUserId(user_id).toResult();
+                }
+
+                const payload = {
+                    _type: 'ModerateRoomRequest',
+                    user_id: user_id,
+                    moderation_action: 'unban',
+                    action_length: null
+                };
+
+                const response = await this.bot._fireAndForget.send(payload);
+
+                if (response.success) {
+                    return this.HighriseResponse.success('unbanned', {
+                        user_id,
+                        action: 'unban',
+                        timestamp: Date.now()
+                    });
+                }
+            } catch (error) {
+                return new this.HighriseError(
+                    ErrorConstants.PERMISSION.INSUFFICIENT_PERMISSIONS,
+                    `Failed to unban user: ${error.message}`,
+                    { user_id }
+                ).toResult();
+            }
+        }
+    }
+}
+
+module.exports = { PlayerClass };