vantiv.io 1.0.0

package/src/classes/Actions/Player.js

@@ -0,0 +1,377 @@
+const { reactions, gold_bars } = require("../../constants/TypesConstants");
+
+class PlayerClass {
+    constructor(bot) {
+        this.bot = bot;
+        this.logger = this.bot.logger
+    }
+
+    async walk(x, y, z, facing = 'FrontRight') {
+        const method = 'bot.player.walk';
+
+        try {
+            if (x === undefined || x === null || y === undefined || y === null || z === undefined || z === null) {
+                throw new TypeError('x, y, z, facing must be all be provided');
+            }
+
+            if (typeof x !== 'number') throw new TypeError('x must be a number');
+            if (typeof y !== 'number') throw new TypeError('y must be a number');
+            if (typeof z !== 'number') throw new TypeError('z must be a number');
+            if (typeof facing !== 'string') throw new TypeError('facing must be a string');
+
+            const destination = { x, y, z, facing };
+            const payload = {
+                _type: 'FloorHitRequest',
+                destination: destination
+            };
+
+            const response = await this.bot._fireAndForget.send(payload)
+            return response.success;
+        } catch (error) {
+            if (error instanceof TypeError) {
+                this.logger.error(method, `TypeError: ${error.message}`, { x, y, z, facing }, error);
+            } else {
+                this.logger.error(method, `Failed to walk bot: ${error.message}`, { x, y, z, facing }, error);
+                return false
+            }
+        }
+    }
+
+    async sit(entity_id, anchor_ix = 0) {
+        const method = 'bot.player.sit';
+
+        try {
+            if (!entity_id || typeof entity_id !== 'string') throw new TypeError('entity_id must be a string and non-empty string')
+            if (anchor_ix < 0 || typeof anchor_ix !== 'number') throw new TypeError('anchor_ix must be a positive number')
+
+            const anchor = { entity_id, anchor_ix };
+            const payload = {
+                _type: 'AnchorHitRequest',
+                anchor: anchor
+            };
+
+            const response = await this.bot._fireAndForget.send(payload)
+            return response.success;
+        } catch (error) {
+            if (error instanceof TypeError) {
+                this.logger.error(method, `TypeError: ${error.message}`, { entity_id, anchor_ix }, error);
+            } else {
+                this.logger.error(method, `Failed to sit bot: ${error.message}`, { entity_id, anchor_ix }, error);
+                return false
+            }
+        }
+    }
+
+    async teleport(user_id, x, y, z, facing = 'FrontRight') {
+        const method = 'bot.player.teleport';
+
+        try {
+            if (!user_id) throw new TypeError('user_id must be a string and non-empty string');
+            if (x === undefined || x === null || y === undefined || y === null || z === undefined || z === null) {
+                throw new TypeError('x, y, z, facing must be all be provided');
+            }
+
+            if (typeof x !== 'number') throw new TypeError('x must be a number');
+            if (typeof y !== 'number') throw new TypeError('y must be a number');
+            if (typeof z !== 'number') throw new TypeError('z must be a number');
+            if (typeof facing !== 'string') throw new TypeError('facing must be a string');
+
+            const payload = {
+                _type: 'TeleportRequest',
+                user_id: user_id,
+                destination: { x, y, z, facing }
+            };
+
+            const response = await this.bot._fireAndForget.send(payload)
+            return response.success;
+        } catch (error) {
+            if (error instanceof TypeError) {
+                this.logger.error(method, `TypeError: ${error.message}`, { user_id, x, y, z, facing }, error);
+            } else {
+                this.logger.error(method, `Failed to teleport: ${error.message}`, { user_id, x, y, z, facing }, error);
+                return false
+            }
+        }
+    }
+
+    async transport(user_id, room_id) {
+        const method = 'bot.player.transport';
+
+        try {
+            if (!user_id || typeof user_id !== 'string') throw new TypeError('user_id must be a string and a non-empty string');
+            if (!room_id || typeof room_id !== 'string') throw new TypeError('room_id must be a string and a non-empty string');
+            if (user_id === this.bot.info.user.id) throw new Error(`You can't transport bot to another room`);
+
+            const payload = {
+                _type: 'MoveUserToRoomRequest',
+                user_id: user_id,
+                room_id: room_id
+            };
+
+            const response = await this.bot._fireAndForget.send(payload)
+            return response.success;
+        } catch (error) {
+            if (error instanceof TypeError) {
+                this.logger.error(method, `TypeError: ${error.message}`, { user_id, room_id }, error);
+            } else {
+                this.logger.error(method, `Failed to transport user: ${error.message}`, { user_id, room_id }, error);
+                return false
+            }
+        }
+    }
+
+    async emote(emote_id, user_id) {
+        const method = 'bot.player.emote';
+
+        try {
+            if (user_id !== undefined && typeof user_id !== 'string') throw new TypeError('user_id must be a string and a non-empty string');
+            if (!emote_id || typeof emote_id !== 'string') throw new TypeError('emote_id must be a string and a non-empty string');
+
+            const payload = {
+                _type: 'EmoteRequest',
+                emote_id: emote_id,
+                target_user_id: user_id
+            };
+
+            const response = await this.bot._fireAndForget.send(payload)
+            return response.success;
+        } catch (error) {
+            if (error instanceof TypeError) {
+                this.logger.error(method, `TypeError: ${error.message}`, { user_id, emote_id }, error);
+            } else {
+                this.logger.error(method, `Failed to play emote: ${error.message}`, { user_id, emote_id }, error);
+                return false
+            }
+        }
+    }
+
+    async react(user_id, reaction) {
+        const method = 'bot.player.react';
+
+        try {
+            if (!user_id || typeof user_id !== 'string') throw new TypeError('user_id must be a string and a non-empty string');
+            if (!reaction || typeof reaction !== 'string') throw new TypeError('reaction must be a string and a non-empty string');
+
+            if (!reactions.includes(reaction)) {
+                throw new Error(`Invalid reaction "${reaction}", Valid reactions: ${reactions.join(', ')}`);
+            }
+
+            const payload = {
+                _type: 'ReactionRequest',
+                reaction: reaction,
+                target_user_id: user_id
+            };
+
+            const response = await this.bot._fireAndForget.send(payload)
+            return response.success;
+        } catch (error) {
+            if (error instanceof TypeError) {
+                this.logger.error(method, `TypeError: ${error.message}`, { user_id, reaction }, error);
+            } else {
+                this.logger.error(method, `Failed to send reaction: ${error.message}`, { user_id, reaction }, error);
+                return false
+            }
+        }
+    }
+
+    async tip(user_id, gold_bar = 1) {
+        const method = 'bot.player.tip';
+
+        try {
+            if (!user_id || typeof user_id !== 'string') throw new TypeError('user_id must be a string and a non-empty string');
+            if (!gold_bar || typeof gold_bar !== 'number' || gold_bar <= 0 || gold_bar > 10_000 || !gold_bars.includes(gold_bar)) throw new TypeError(`gold_bar must be a number, bigger than 0 less than 10,000, supported amount: ${gold_bars.join(', ')}`);
+
+            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"
+            }
+
+            const payload = {
+                _type: 'TipUserRequest',
+                user_id: user_id,
+                gold_bar: PayladGoldBars[gold_bar]
+            };
+
+            const response = await this.bot._fireAndForget.send(payload)
+            return response.success;
+        } catch (error) {
+            if (error instanceof TypeError) {
+                this.logger.error(method, `TypeError: ${error.message}`, { user_id, gold_bar }, error);
+            } else {
+                this.logger.error(method, `Failed to tip user: ${error.message}`, { user_id, gold_bar }, error);
+                return false
+            }
+        }
+    }
+
+    outfit = {
+        get: async (user_id) => {
+            const method = 'bot.outfit.get'
+            try {
+                if (!user_id || typeof user_id !== 'string') throw new TypeError('user_id must be a string and a non-empty string');
+
+
+                const payload = {
+                    _type: 'GetUserOutfitRequest',
+                    user_id: user_id
+                }
+
+                const response = await this.bot._requestResponse.send(payload)
+                return response.outfit
+            } catch (error) {
+                if (error instanceof TypeError) {
+                    this.logger.error(method, `TypeError: ${error.message}`, { user_id }, error);
+                } else {
+                    this.logger.error(method, `Failed to get user outfit: ${error.message}`, { user_id }, error);
+                    return []
+                }
+            }
+        }
+    }
+
+    moderation = {
+        kick: async (user_id) => {
+            const method = 'bot.moderation.kick';
+
+            try {
+                if (!user_id || typeof user_id !== 'string') throw new TypeError('user_id must be a string and a non-empty string');
+
+                const payload = {
+                    _type: 'ModerateRoomRequest',
+                    user_id: user_id,
+                    moderation_action: 'kick',
+                    action_length: null
+                };
+
+                const response = await this.bot._fireAndForget.send(payload)
+                return response.success;
+            } catch (error) {
+                if (error instanceof TypeError) {
+                    this.logger.error(method, `TypeError: ${error.message}`, { user_id }, error);
+                } else {
+                    this.logger.error(method, `Failed to kick user: ${error.message}`, { user_id }, error);
+                    return false
+                }
+            }
+        },
+
+        ban: async (user_id, duration = 1 * 60 * 60 * 1000) => {
+            const method = 'bot.moderation.ban';
+
+            try {
+                if (!user_id || typeof user_id !== 'string') throw new TypeError('user_id must be a string and a non-empty string');
+                if (!duration ||
+                    typeof duration !== 'number' ||
+                    duration < 0 ||
+                    duration > 69 * 365.2425 * 24 * 60 * 60 * 1000
+                ) throw new TypeError('duration must be a number and a positive number and less than 69 years');
+
+                const payload = {
+                    _type: 'ModerateRoomRequest',
+                    user_id: user_id,
+                    moderation_action: 'ban',
+                    action_length: duration
+                };
+
+                const response = await this.bot._fireAndForget.send(payload)
+                return response.success;
+            } catch (error) {
+                if (error instanceof TypeError) {
+                    this.logger.error(method, `TypeError: ${error.message}`, { user_id, duration }, error);
+                } else {
+                    this.logger.error(method, `Failed to ban user: ${error.message}`, { user_id, duration }, error);
+                    return false
+                }
+            }
+        },
+
+        mute: async (user_id, duration = 5 * 60 * 1000) => {
+            const method = 'bot.moderation.mute';
+
+            try {
+                if (!user_id || typeof user_id !== 'string') throw new TypeError('user_id must be a string and a non-empty string');
+                if (!duration ||
+                    typeof duration !== 'number' ||
+                    duration < 0 ||
+                    duration > 69 * 365.2425 * 24 * 60 * 60 * 1000
+                ) throw new TypeError('duration must be a number and a positive number and less than 69 years');
+
+                const payload = {
+                    _type: 'ModerateRoomRequest',
+                    user_id: user_id,
+                    moderation_action: 'mute',
+                    action_length: duration
+                };
+
+                const response = await this.bot._fireAndForget.send(payload)
+                return response.success;
+            } catch (error) {
+                if (error instanceof TypeError) {
+                    this.logger.error(method, `TypeError: ${error.message}`, { user_id, duration }, error);
+                } else {
+                    this.logger.error(method, `Failed to mute user: ${error.message}`, { user_id, duration }, error);
+                    return false
+                }
+            }
+        },
+
+        unmute: async (user_id) => {
+            const method = 'bot.moderation.unmute';
+
+            try {
+                if (!user_id || typeof user_id !== 'string') throw new TypeError('user_id must be a string and a non-empty string');
+
+                const payload = {
+                    _type: 'ModerateRoomRequest',
+                    user_id: user_id,
+                    moderation_action: 'mute',
+                    action_length: 1
+                };
+
+                const response = await this.bot._fireAndForget.send(payload)
+                return response.success;
+            } catch (error) {
+                if (error instanceof TypeError) {
+                    this.logger.error(method, `TypeError: ${error.message}`, { user_id }, error);
+                } else {
+                    this.logger.error(method, `Failed to unmute user: ${error.message}`, { user_id }, error);
+                    return false
+                }
+            }
+        },
+
+        unban: async (user_id) => {
+            const method = 'bot.moderation.unban';
+
+            try {
+                if (!user_id || typeof user_id !== 'string') throw new TypeError('user_id must be a string and a non-empty string');
+
+                const payload = {
+                    _type: 'ModerateRoomRequest',
+                    user_id: user_id,
+                    moderation_action: 'unban',
+                    action_length: null
+                };
+
+                const response = await this.bot._fireAndForget.send(payload)
+                return response.success;
+            } catch (error) {
+                if (error instanceof TypeError) {
+                    this.logger.error(method, `TypeError: ${error.message}`, { user_id }, error);
+                } else {
+                    this.logger.error(method, `Failed to unban user: ${error.message}`, { user_id }, error);
+                    return false
+                }
+            }
+        }
+    }
+}
+
+module.exports = { PlayerClass }

package/src/classes/Actions/Public.js

@@ -0,0 +1,66 @@
+class MessageClass {
+    constructor(bot) {
+        this.bot = bot
+        this.logger = this.bot.logger
+    }
+
+    async send(message) {
+        const method = 'bot.message.send';
+
+        try {
+            if (typeof message !== 'string' || !message) throw new TypeError('message must be a string and non-empty string')
+
+            const payload = {
+                _type: 'ChatRequest',
+                message: message
+            }
+
+            const response = await this.bot._fireAndForget.send(payload)
+            return response.success
+        } catch (error) {
+            if (error instanceof TypeError) {
+                this.logger.error(method, error, { message }, error);
+            } else if (error) {
+                this.logger.error(method, `Failed to send message: ${error.message}`, { message }, error);
+                return false
+            }
+        }
+    }
+}
+
+class WhisperClass {
+    constructor(bot) {
+        this.bot = bot
+        this.logger = this.bot._logger
+    }
+
+    async send(user_id, message) {
+        const method = 'bot.whisper.send';
+
+        try {
+            if (typeof message !== 'string' || !message) throw new TypeError('message must be a string and non-empty string')
+            if (typeof user_id !== 'string' || !user_id) throw new TypeError('user_id must be a string and non-empty string')
+
+            const payload = {
+                _type: 'ChatRequest',
+                message: message,
+                whisper_target_id: user_id
+            }
+
+            const response = await this.bot._fireAndForget.send(payload)
+            return response.success
+        } catch (error) {
+            if (error instanceof TypeError) {
+                this.logger.error(method, `TypeError: ${error.message}`, { user_id, message }, error);
+            } else {
+                this.logger.error(method, `Failed to send whisper: ${error.message}`, { user_id, message }, error);
+                return false
+            }
+        }
+    }
+}
+
+module.exports = {
+    MessageClass,
+    WhisperClass
+}