highrise.bot 1.0.0

package/src/classes/Actions/Music.js

@@ -0,0 +1,243 @@
+const { IcecastStreamer, IcecastQueue } = require('highrise.js/src/classes/Actions/lib/AudioStreaming.js');
+const EventEmitter = require('events');
+
+class MusicClass extends EventEmitter {
+    constructor(bot, config = {}) {
+        super();
+        this.bot = bot;
+        this.config = {
+            enabled: config.enabled || false,
+            icecast: config.icecast || {},
+            queue: config.queue || {},
+            serverPort: config.serverPort || 3000,
+            maxQueueSize: config.maxQueueSize || 100,
+            defaultVolume: config.defaultVolume || 80,
+            allowedFormats: config.allowedFormats || ['youtube', 'direct']
+        };
+
+        if (!this.config.enabled) {
+            console.log('Music module is disabled. Enable it in config to use music features.');
+            return;
+        }
+
+        this.initializeStreamer();
+        this.setupEventHandlers();
+    }
+
+    initializeStreamer() {
+        try {
+            this.streamer = new IcecastStreamer(this.config.icecast);
+            this.queue = new IcecastQueue(this.streamer, { ...this.config.queue, ...this.config.icecast });
+
+            this.streamer.on('playbackStart', (track) => {
+                this.emit('MusicStart', track);
+            });
+
+            this.streamer.on('playbackEnd', (track) => {
+                this.emit('MusicEnd', track);
+            });
+
+            this.streamer.on('progress', (data) => {
+                this.emit('Progress', data);
+            });
+
+            this.streamer.on('error', (error) => {
+                this.emit('Error', error);
+            });
+
+            this.streamer.on('streamStopped', () => {
+                this.emit('StreamEnded');
+            });
+        } catch (error) {
+            console.error('Failed to initialize Icecast streamer:', error);
+            throw error;
+        }
+    }
+
+    setupEventHandlers() {
+        this.bot.on('Ready', () => {
+            this.emit('Ready');
+        });
+
+        this.bot.on('error', (error) => {
+            this.emit('error', error);
+        });
+    }
+
+    async play(input, metadata = {}) {
+        try {
+            if (!this.streamer) {
+                throw new Error('Streamer not initialized');
+            }
+
+            let result;
+            if (this.isValidUrl(input)) {
+                if (input.includes('youtube.com') || input.includes('youtu.be')) {
+                    result = await this.queue.addFromYouTube(input, metadata);
+                }
+            } else {
+                result = await this.queue.addFromYouTube(input, metadata);
+            }
+
+            if (!result?.added) {
+                return {
+                    success: false,
+                    error: result.reason === 'duplicate' ? 'Track already in queue' : 'Failed to add track'
+                };
+            }
+
+            const track = this.queue.getQueue()[result.position - 1] ||
+                (result.isNowPlaying ? this.streamer.currentTrack : null);
+
+            return {
+                success: true,
+                track: track ? {
+                    title: track.title,
+                    duration: track.duration,
+                    formattedDuration: track.getFormattedDuration(),
+                    requester: track.requester,
+                    thumbnail: track.thumbnail
+                } : null,
+                position: result.position,
+                isNowPlaying: result.isNowPlaying || false
+            };
+        } catch (error) {
+            console.error('Error playing track:', error);
+            return {
+                success: false,
+                error: error.message
+            };
+        }
+    }
+
+    async skip() {
+        try {
+            const success = await this.queue.skip();
+            let upcoming = null;
+            if (this.queue.queue.length > 0) {
+                const nextTrack = this.queue.queue[0];
+                upcoming = {
+                    title: nextTrack.title,
+                    duration: nextTrack.duration,
+                    formattedDuration: nextTrack.getFormattedDuration()
+                };
+            }
+            return { success, upcoming };
+        } catch (error) {
+            console.error('Error skipping track:', error);
+            return { success: false, error: error.message };
+        }
+    }
+
+    getNowPlaying() {
+        const np = this.streamer.getNowPlaying();
+        if (!np || !np.track) return null;
+
+        return {
+            track: np.track,
+            position: np.position || 0,
+            duration: np.duration || 0,
+            progress: np.progress || 0,
+            remaining: np.remaining || 0,
+            formattedPosition: this.formatDuration(np.position || 0),
+            formattedDuration: np.track.getFormattedDuration(),
+            formattedRemaining: this.formatDuration(np.remaining || 0)
+        };
+    }
+
+    getQueue() {
+        const queue = this.queue?.getQueue() || [];
+        return {
+            queue,
+            upcoming: queue.slice(0, 10),
+            loopMode: this.queue?.loopMode || 'off',
+            length: queue.length
+        };
+    }
+
+    toggleLoop() {
+        const modes = ['off', 'track', 'queue'];
+        const currentIndex = modes.indexOf(this.queue.loopMode);
+        const nextIndex = (currentIndex + 1) % modes.length;
+        this.queue.loopMode = modes[nextIndex];
+        return { success: true, newMode: this.queue.loopMode };
+    }
+
+    shuffle() {
+        if (!this.queue || this.queue.queue.length === 0) {
+            return { success: false, error: 'Queue is empty' };
+        }
+        for (let i = this.queue.queue.length - 1; i > 0; i--) {
+            const j = Math.floor(Math.random() * (i + 1));
+            [this.queue.queue[i], this.queue.queue[j]] = [this.queue.queue[j], this.queue.queue[i]];
+        }
+        return { success: true, queue: this.getQueue() };
+    }
+
+    removeFromQueue(index) {
+        return this.queue?.remove(index) || null;
+    }
+
+    moveInQueue(from, to) {
+        return this.queue?.move(from, to) || false;
+    }
+
+    clearQueue() {
+        return this.queue?.clear() || [];
+    }
+
+    isValidUrl(string) {
+        try {
+            new URL(string);
+            return true;
+        } catch (_) {
+            return false;
+        }
+    }
+
+    formatDuration(seconds) {
+        if (!seconds) return '0:00';
+        const hours = Math.floor(seconds / 3600);
+        const minutes = Math.floor((seconds % 3600) / 60);
+        const secondsRemaining = Math.floor(seconds % 60);
+        if (hours > 0) {
+            return `${hours}:${minutes.toString().padStart(2, '0')}:${secondsRemaining.toString().padStart(2, '0')}`;
+        }
+        return `${minutes}:${secondsRemaining.toString().padStart(2, '0')}`;
+    }
+
+    getHealth() {
+        return {
+            streamer: this.streamer?.getHealth(),
+            queue: this.queue?.getStatus(),
+            webServer: !!this.webServer,
+            uptime: process.uptime()
+        };
+    }
+
+    startFallback() {
+        if (!this.queue) return { success: false, error: 'Queue not initialized' };
+        const started = this.queue.startFallback();
+        return { success: started };
+    }
+
+    stopFallback() {
+        if (!this.queue) return { success: false, error: 'Queue not initialized' };
+        const stopped = this.queue.stopFallback();
+        return { success: stopped };
+    }
+
+    destroy() {
+        try {
+            if (this.streamer) {
+                this.streamer.stop();
+            }
+            return true;
+        } catch (error) {
+            console.error('Error destroying music class:', error);
+            return false;
+        }
+    }
+}
+
+module.exports = MusicClass;

package/src/classes/Actions/Outfit.js

@@ -0,0 +1,175 @@
+const { default_skin } = require("highrise.js/src/constants/TypesConstants");
+const ErrorConstants = require('highrise.js/src/constants/ErrorConstants');
+
+class OutfitClass {
+    constructor(bot) {
+        this.bot = bot;
+
+        this.HighriseError = bot.HighriseError;
+        this.HighriseResponse = bot.HighriseResponse;
+    }
+
+    async set(outfit = default_skin) {
+        try {
+            if (!Array.isArray(outfit)) {
+                return new this.HighriseError(
+                    ErrorConstants.VALIDATION.INVALID_PARAMETER,
+                    'Outfit must be an array',
+                    { outfit, type: typeof outfit }
+                ).toResult();
+            }
+
+            const payload = {
+                _type: 'SetOutfitRequest',
+                outfit: outfit
+            };
+
+            const response = await this.bot._fireAndForget.send(payload);
+
+            if (response.success) {
+                return this.HighriseResponse.success('outfit', {
+                    items: outfit,
+                    count: outfit.length,
+                    timestamp: Date.now()
+                });
+            }
+        } catch (error) {
+            return new this.HighriseError(
+                ErrorConstants.HIGHRISE_API.API_SERVER_ERROR,
+                `Failed to set outfit: ${error.message}`,
+                { outfit }
+            ).toResult();
+        }
+    }
+
+    async color(bodyPart, colorIndex) {
+        try {
+            const BodyParts = [
+                'hair', 'hair_front', 'hair_back', 
+                'eyebrow', 'eye',
+                'mouth', 
+                'body'
+            ];
+
+            const colorsRanges = {
+                "hair": { min: 0, max: 81 },
+                "hair_front": { min: 0, max: 81 },
+                "hair_back": { min: 0, max: 81 },
+                "eyebrow": { min: 0, max: 81 },
+                "eye": { min: 0, max: 49 },
+                "mouth": { min: -1, max: 57 },
+                "body": { min: 0, max: 86 }
+            };
+
+            if (!bodyPart || !BodyParts.includes(bodyPart)) {
+                return new this.HighriseError(
+                    ErrorConstants.VALIDATION.INVALID_BODY_PART,
+                    `Body part must be a valid body part: (${BodyParts.join(', ')})`,
+                    { bodyPart, type: typeof bodyPart }
+                ).toResult();
+            }
+
+            const range = colorsRanges[bodyPart];
+            const min = range.min;
+            const max = range.max;
+
+            const num = Number(colorIndex);
+            if (colorIndex == null ||
+                isNaN(num) ||
+                num < min ||
+                num > max ||
+                !Number.isInteger(num)) {
+
+                return new this.HighriseError(
+                    ErrorConstants.VALIDATION.INVALID_COLOR_INDEX,
+                    `Color index for ${bodyPart} must be an integer between ${min} and ${max} (inclusive). Received: ${colorIndex}`,
+                    {
+                        bodyPart,
+                        colorIndex,
+                        min,
+                        max,
+                        IndexType: typeof colorIndex,
+                        parsedValue: num
+                    }
+                ).toResult();
+            }
+
+            if (this.bot.info?.outfit === null) {
+                await this.get();
+            }
+
+            const outfit = this.bot.info?.outfit || [];
+
+            let bodyPartsToUpdate = [];
+
+            if (bodyPart === 'hair') {
+                bodyPartsToUpdate.push('hair_front', 'hair_back')
+            } else {
+                bodyPartsToUpdate.push(bodyPart)
+            }
+
+            let newOutfit = outfit.map(item => {
+                const shouldUpdate = bodyPartsToUpdate.some(part =>
+                    item.id.startsWith(`${part}-`)
+                );
+
+                if (shouldUpdate) {
+                    item.active_palette = colorIndex;
+                }
+
+                return item;
+            });
+
+            const setResult = await this.set(newOutfit);
+            if (setResult.success) {
+
+                this.bot.setOutfit = newOutfit;
+                return setResult;
+            }
+
+            return setResult;
+        } catch (error) {
+            return new this.HighriseError(
+                ErrorConstants.INTERNAL.UNEXPECTED_ERROR,
+                `An unexpected error occurred: ${error.message}`
+            ).toResult();
+        }
+    }
+
+    async get() {
+        try {
+            const botId = this.bot.info.user?.id;
+            const outfit = this.bot.info?.outfit
+            if (outfit) {
+                return this.HighriseResponse.success('outfit', {
+                    items: outfit || [],
+                    count: (outfit || []).length
+                });
+            }
+
+            if (!botId) {
+                return new this.HighriseError(
+                    ErrorConstants.INTERNAL.STATE_ERROR,
+                    'Bot user ID not found',
+                    { botInfo: this.bot.info }
+                ).toResult();
+            }
+
+            const response = await this.bot.player.outfit.get(botId);
+            if (response.success) {
+                this.bot.setOutfit = response.outfit.items
+                return this.HighriseResponse.success('outfit', {
+                    items: response.outfit.items || [],
+                    count: (response.outfit.items || []).length
+                });
+            }
+        } catch (error) {
+            return new this.HighriseError(
+                ErrorConstants.HIGHRISE_API.API_SERVER_ERROR,
+                `Failed to get outfit: ${error.message}`
+            ).toResult();
+        }
+    }
+}
+
+module.exports = { OutfitClass };