Merge pull request #17 from journeyjt/feature/group-mode

feat: Add group mode with per-user mute/volume controls

Author: journeyjt

module.json

@@ -2,7 +2,7 @@
   "id": "bardic-inspiration",
   "title": "Bardic Inspiration",
   "description": "Synchronized YouTube DJ for Foundry VTT - Play YouTube videos in sync across all players",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "compatibility": {
     "minimum": "13.347",
     "verified": "13.347"

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "bardic-inspiration",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "A Foundry VTT module",
   "type": "module",
   "scripts": {
@@ -17,10 +17,8 @@
     "dev:urls": "node -e \"const fs = require('fs'); const manifest = JSON.parse(fs.readFileSync('./module.json')); manifest.url = 'http://host.docker.internal:5000/modules/bardic-inspiration'; manifest.manifest = 'http://host.docker.internal:5000/modules/bardic-inspiration/module.json'; manifest.download = 'http://host.docker.internal:5000/modules/bardic-inspiration/module.zip'; fs.writeFileSync('./module.json', JSON.stringify(manifest, null, 2));\"",
     "prod:urls": "node -e \"const fs = require('fs'); const manifest = JSON.parse(fs.readFileSync('./module.json')); manifest.url = 'https://github.com/journeyjt/BardicInspiration'; manifest.manifest = 'https://github.com/journeyjt/BardicInspiration/releases/latest/download/module.json'; manifest.download = 'https://github.com/journeyjt/BardicInspiration/releases/latest/download/module.zip'; fs.writeFileSync('./module.json', JSON.stringify(manifest, null, 2));\"",
     "dev:serve": "npm run dev:urls && npm run dev:clean && npm run version:bump && npm run vite:build && npm run build:zip && npm run vite:dev",
-    "build": "npm run prod:urls && npm test && npm run validate && npm run version:bump && npm run vite:build && npm run build:zip",
-    "build:ci": "npm run prod:urls && npm run test:coverage && npm run validate && npm run vite:build && npm run build:zip",
-    "build:zip": "powershell -Command \"Compress-Archive -Path module.json,dist,templates,languages,LICENSE,README.md -DestinationPath module.zip -Force\"",
-    "precommit": "npm test && npm run validate"
+    "build": "npm run prod:urls && npm run validate && npm run version:bump && npm run vite:build && npm run build:zip",
+    "build:zip": "powershell -Command \"Compress-Archive -Path module.json,dist,templates,languages,LICENSE,README.md -DestinationPath module.zip -Force\""
   },
   "keywords": [
     "foundryvtt",

package.json

@@ -97,6 +97,44 @@ Hooks.once('init', () => {
     }
   });
 
+  // Group Mode setting - visible in module settings
+  game.settings.register('bardic-inspiration', 'youtubeDJ.groupMode', {
+    name: 'Group Mode',
+    hint: 'When enabled, all users in the listening session can add videos to the queue (not just the DJ)',
+    scope: 'world',
+    config: true,
+    type: Boolean,
+    default: false,
+    onChange: (value: boolean) => {
+      logger.info(`YouTube DJ Group Mode ${value ? 'enabled' : 'disabled'}`);
+      // Update the queue state mode
+      const queueState = game.settings.get('core', 'youtubeDJ.queueState') as any;
+      queueState.mode = value ? 'collaborative' : 'single-dj';
+      game.settings.set('core', 'youtubeDJ.queueState', queueState);
+      // Notify all users of the mode change
+      Hooks.callAll('youtubeDJ.groupModeChanged', { enabled: value });
+    }
+  });
+
+  // Client-side settings for user preferences (not synchronized)
+  game.settings.register('bardic-inspiration', 'youtubeDJ.userMuted', {
+    name: 'Personal Mute State',
+    hint: 'Your personal mute preference for the YouTube DJ player',
+    scope: 'client',
+    config: false, // Hidden from settings menu
+    type: Boolean,
+    default: false
+  });
+
+  game.settings.register('bardic-inspiration', 'youtubeDJ.userVolume', {
+    name: 'Personal Volume',
+    hint: 'Your personal volume preference for the YouTube DJ player',
+    scope: 'client', 
+    config: false, // Hidden from settings menu
+    type: Number,
+    default: 50
+  });
+
   logger.info('YouTube DJ world settings registered');
 
   // Register module API globally

src/main.ts

@@ -244,16 +244,13 @@ export class PlayerManager {
     }
 
     try {
-      Hooks.callAll('youtubeDJ.playerCommand', { command: 'mute' });
+      // Send command only to local player (not to all users)
+      Hooks.callAll('youtubeDJ.localPlayerCommand', { command: 'mute' });
 
-      this.store.updateState({
-        player: {
-          ...this.store.getPlayerState(),
-          isMuted: true
-        }
-      });
+      // Store mute preference in client settings (per-user)
+      await game.settings.set('bardic-inspiration', 'youtubeDJ.userMuted', true);
 
-      logger.debug('🎵 YouTube DJ | Player muted');
+      logger.debug('🎵 YouTube DJ | Player muted (local only)');
     } catch (error) {
       logger.error('🎵 YouTube DJ | Failed to mute:', error);
       throw error;
@@ -269,16 +266,13 @@ export class PlayerManager {
     }
 
     try {
-      Hooks.callAll('youtubeDJ.playerCommand', { command: 'unMute' });
+      // Send command only to local player (not to all users)
+      Hooks.callAll('youtubeDJ.localPlayerCommand', { command: 'unMute' });
 
-      this.store.updateState({
-        player: {
-          ...this.store.getPlayerState(),
-          isMuted: false
-        }
-      });
+      // Store mute preference in client settings (per-user)
+      await game.settings.set('bardic-inspiration', 'youtubeDJ.userMuted', false);
 
-      logger.debug('🎵 YouTube DJ | Player unmuted');
+      logger.debug('🎵 YouTube DJ | Player unmuted (local only)');
     } catch (error) {
       logger.error('🎵 YouTube DJ | Failed to unmute:', error);
       throw error;
@@ -289,7 +283,8 @@ export class PlayerManager {
    * Toggle mute state
    */
   async toggleMute(): Promise<void> {
-    const currentlyMuted = this.store.getPlayerState().isMuted;
+    // Get mute state from client settings instead of global state
+    const currentlyMuted = game.settings.get('bardic-inspiration', 'youtubeDJ.userMuted') as boolean;
 
     if (currentlyMuted) {
       await this.unmute();
@@ -298,6 +293,37 @@ export class PlayerManager {
     }
   }
 
+  /**
+   * Get user's current mute preference
+   */
+  getUserMuteState(): boolean {
+    return game.settings.get('bardic-inspiration', 'youtubeDJ.userMuted') as boolean;
+  }
+
+  /**
+   * Get user's current volume preference  
+   */
+  getUserVolume(): number {
+    return game.settings.get('bardic-inspiration', 'youtubeDJ.userVolume') as number;
+  }
+
+  /**
+   * Set user's volume preference
+   */
+  async setUserVolume(volume: number): Promise<void> {
+    if (volume < 0 || volume > 100) {
+      throw new Error('Volume must be between 0 and 100');
+    }
+    
+    // Store in client settings
+    await game.settings.set('bardic-inspiration', 'youtubeDJ.userVolume', volume);
+    
+    // Send command only to local player
+    Hooks.callAll('youtubeDJ.localPlayerCommand', { command: 'setVolume', args: [volume] });
+    
+    logger.debug(`🎵 YouTube DJ | User volume set to ${volume} (local only)`);
+  }
+
   /**
    * Start heartbeat for synchronization
    */

src/services/PlayerManager.ts

@@ -29,14 +29,37 @@ export class QueueManager {
     Hooks.on('youtubeDJ.queueAdd', this.onQueueAdd.bind(this));
     Hooks.on('youtubeDJ.queueRemove', this.onQueueRemove.bind(this));
     Hooks.on('youtubeDJ.queueUpdate', this.onQueueUpdate.bind(this));
+    Hooks.on('youtubeDJ.queueClear', this.onQueueClear.bind(this));
+  }
+
+  /**
+   * Check if user can add videos to queue
+   */
+  private canAddToQueue(): boolean {
+    // Check if Group Mode is enabled
+    const groupMode = game.settings.get('bardic-inspiration', 'youtubeDJ.groupMode') as boolean;
+    
+    if (groupMode) {
+      // In Group Mode, any user in the session can add videos
+      const sessionState = this.store.getSessionState();
+      const currentUserId = game.user?.id;
+      return sessionState.hasJoinedSession && 
+             sessionState.members.some(m => m.userId === currentUserId && m.isActive);
+    } else {
+      // In single-DJ mode, only the DJ can add videos
+      return this.store.isDJ();
+    }
   }
 
   /**
    * Add video to queue
    */
   async addVideo(videoInfo: VideoInfo, playNow: boolean = false): Promise<void> {
-    if (!this.store.isDJ()) {
-      throw new Error('Only DJ can add videos to queue');
+    if (!this.canAddToQueue()) {
+      const groupMode = game.settings.get('bardic-inspiration', 'youtubeDJ.groupMode') as boolean;
+      throw new Error(groupMode 
+        ? 'You must be in the listening session to add videos to the queue' 
+        : 'Only the DJ can add videos to the queue');
     }
 
     const userId = game.user?.id;
@@ -471,7 +494,7 @@ export class QueueManager {
    */
   async clearQueue(): Promise<void> {
     if (!this.store.isDJ()) {
-      throw new Error('Only DJ can clear queue');
+      throw new Error('Only the DJ can clear the queue');
     }
 
     logger.debug('🎵 YouTube DJ | Clearing queue...');
@@ -482,6 +505,10 @@ export class QueueManager {
         currentIndex: -1,
         mode: 'single-dj',
         djUserId: this.store.getSessionState().djUserId
+      },
+      player: {
+        ...this.store.getPlayerState(),
+        playbackState: 'paused'
       }
     });
 
@@ -626,35 +653,47 @@ export class QueueManager {
   /**
    * Handle queue next event from DJ (for listeners)
    */
-  private onQueueNext(data: { nextIndex: number; videoItem: any; timestamp: number }): void {
-    // Only update state if we're not the DJ (DJ already updated their state)
-    if (this.store.isDJ()) {
+  private onQueueNext(data: { nextIndex: number; videoItem: any; timestamp: number; userId: string; cycledItem?: any; isCycling?: boolean }): void {
+    // Don't sync our own changes (avoid double-processing)
+    if (data.userId === game.user?.id) {
       return;
     }
 
     logger.debug('🎵 YouTube DJ | Syncing queue next from DJ:', data.nextIndex);
 
     const currentQueue = this.store.getQueueState();
+    let newQueue = [...currentQueue.items];
+    
+    // If this is a cycling operation, reorder the queue to match DJ
+    if (data.isCycling && data.cycledItem && currentQueue.currentIndex >= 0) {
+      // Remove the current item and add it to the end (same as DJ did)
+      const cycledItemIndex = currentQueue.currentIndex;
+      if (cycledItemIndex < newQueue.length) {
+        const removedItem = newQueue.splice(cycledItemIndex, 1)[0];
+        newQueue.push(removedItem);
+      }
+    }
 
-    // Update queue index to match DJ
+    // Update queue to match DJ's state
     this.store.updateState({
       queue: {
         ...currentQueue,
+        items: newQueue,
         currentIndex: data.nextIndex
       }
     });
   }
 
   /**
-   * Handle queue add event from DJ (for listeners)
+   * Handle queue add event from other users
    */
-  private onQueueAdd(data: { queueItem: any; playNow: boolean; timestamp: number }): void {
-    // Only update state if we're not the DJ (DJ already updated their state)
-    if (this.store.isDJ()) {
+  private onQueueAdd(data: { queueItem: any; playNow: boolean; timestamp: number; userId: string }): void {
+    // Don't sync our own changes (avoid double-adding)
+    if (data.userId === game.user?.id) {
       return;
     }
 
-    logger.debug('🎵 YouTube DJ | Syncing queue add from DJ:', data.queueItem?.title);
+    logger.debug('🎵 YouTube DJ | Syncing queue add from user:', data.userId, '-', data.queueItem?.title);
 
     const currentQueue = this.store.getQueueState();
     const newQueue = [...currentQueue.items, data.queueItem];
@@ -757,6 +796,32 @@ export class QueueManager {
     });
   }
 
+  /**
+   * Handle queue clear event from DJ (for listeners)
+   */
+  private onQueueClear(data: { timestamp: number; userId: string }): void {
+    // Don't sync our own changes (avoid double-processing)
+    if (data.userId === game.user?.id) {
+      return;
+    }
+    
+    logger.debug('🎵 YouTube DJ | Syncing queue clear from DJ');
+    
+    // Clear the queue
+    this.store.updateState({
+      queue: {
+        items: [],
+        currentIndex: -1,
+        mode: 'single-dj',
+        djUserId: this.store.getSessionState().djUserId
+      },
+      player: {
+        ...this.store.getPlayerState(),
+        playbackState: 'paused'
+      }
+    });
+  }
+
   /**
    * Handle video ended event
    */
@@ -823,6 +888,7 @@ export class QueueManager {
     Hooks.off('youtubeDJ.queueAdd', this.onQueueAdd.bind(this));
     Hooks.off('youtubeDJ.queueRemove', this.onQueueRemove.bind(this));
     Hooks.off('youtubeDJ.queueUpdate', this.onQueueUpdate.bind(this));
+    Hooks.off('youtubeDJ.queueClear', this.onQueueClear.bind(this));
     logger.debug('🎵 YouTube DJ | QueueManager destroyed');
   }
 }

src/services/QueueManager.ts

@@ -196,6 +196,7 @@ export class SocketManager {
     this.registerHandler('QUEUE_REMOVE', new QueueRemoveHandler(this.store));
     this.registerHandler('QUEUE_UPDATE', new QueueUpdateHandler(this.store));
     this.registerHandler('QUEUE_NEXT', new QueueNextHandler(this.store));
+    this.registerHandler('QUEUE_CLEAR', new QueueClearHandler(this.store));
 
     logger.debug('🎵 YouTube DJ | Default message handlers registered');
   }
@@ -733,13 +734,14 @@ class QueueAddHandler implements MessageHandler {
   constructor(private store: SessionStore) {}
 
   handle(message: YouTubeDJMessage): void {
-    logger.debug('🎵 YouTube DJ | Queue add from DJ');
+    logger.debug('🎵 YouTube DJ | Queue add from user:', message.userId);
 
     // Emit event for QueueManager to handle
     Hooks.callAll('youtubeDJ.queueAdd', {
       queueItem: message.data?.queueItem,
       playNow: message.data?.playNow || false,
-      timestamp: message.timestamp
+      timestamp: message.timestamp,
+      userId: message.userId  // Pass the original sender's ID
     });
   }
 }
@@ -783,7 +785,24 @@ class QueueNextHandler implements MessageHandler {
     Hooks.callAll('youtubeDJ.queueNext', {
       nextIndex: message.data?.nextIndex,
       videoItem: message.data?.videoItem,
-      timestamp: message.timestamp
+      timestamp: message.timestamp,
+      userId: message.userId,
+      cycledItem: message.data?.cycledItem,
+      isCycling: message.data?.isCycling
+    });
+  }
+}
+
+class QueueClearHandler implements MessageHandler {
+  constructor(private store: SessionStore) {}
+
+  handle(message: YouTubeDJMessage): void {
+    logger.debug('🎵 YouTube DJ | Queue clear from DJ');
+
+    // Emit event for QueueManager to handle
+    Hooks.callAll('youtubeDJ.queueClear', {
+      timestamp: message.timestamp,
+      userId: message.userId
     });
   }
 }