Volume Control

// Set volume to 50%
queue.node.setVolume(50);

const volume = queue.node.volume;
console.log(`Current volume: ${volume}%`); // Current volume: 50%

import { VolumeTransformer } from '@discord-player/equalizer';

const volumeTransformer = new VolumeTransformer({
  volume: 100  // Default 100%
});

const queue = player.queues.create(guild, {
  volume: 80  // Default to 80%
});

console.log(queue.node.volume); // 80

// Returns boolean indicating success
const success = queue.node.setVolume(60);

if (success) {
  console.log('Volume updated to 60%');
}

const volumeFilter = queue.filters.volume;

if (volumeFilter) {
  // Get exact volume with decimals
  console.log(volumeFilter.volumeApprox);
  
  // Get rounded volume
  console.log(volumeFilter.volume);
  
  // Set volume directly on transformer
  volumeFilter.setVolume(75);
  
  // Or use property setter
  volumeFilter.volume = 75;
}

// Negative values clamped to 0
queue.node.setVolume(-10);  // Sets to 0

// Infinite values clamped to 100
queue.node.setVolume(Infinity);  // Sets to 100

// NaN rejected with error
try {
  queue.node.setVolume(NaN);
} catch (error) {
  console.error('Invalid volume value');
}

const queue = player.queues.create(guild, {
  disableVolume: true  // Disable volume control
});

// Volume control will not be available
queue.node.setVolume(50);  // Returns false

player.events.on('willPlayTrack', (queue, track, config, resolve) => {
  // Modify volume in stream config
  config.dispatcherConfig.volume = 85;
  
  resolve();
});

player.events.on('audioTrackAdd', (queue, track) => {
  // Set different volume for different sources
  if (track.source === 'spotify') {
    queue.node.setVolume(90);
  } else if (track.source === 'youtube') {
    queue.node.setVolume(75);
  }
});

// Fade out over 3 seconds
async function fadeOut(queue: GuildQueue, duration = 3000) {
  const startVolume = queue.node.volume;
  const steps = 30;
  const stepDuration = duration / steps;
  const stepSize = startVolume / steps;
  
  for (let i = 0; i < steps; i++) {
    const newVolume = startVolume - (stepSize * (i + 1));
    queue.node.setVolume(Math.max(0, newVolume));
    await new Promise(resolve => setTimeout(resolve, stepDuration));
  }
}

// Fade in over 3 seconds
async function fadeIn(queue: GuildQueue, targetVolume = 100, duration = 3000) {
  const steps = 30;
  const stepDuration = duration / steps;
  const stepSize = targetVolume / steps;
  
  for (let i = 0; i < steps; i++) {
    const newVolume = stepSize * (i + 1);
    queue.node.setVolume(Math.min(targetVolume, newVolume));
    await new Promise(resolve => setTimeout(resolve, stepDuration));
  }
}

// Usage
await fadeOut(queue);
queue.node.skip();
await fadeIn(queue, 80);

player.events.on('playerStart', (queue, track) => {
  // Normalize volume based on track metadata
  const replayGain = track.raw?.replayGain || 0;
  const normalizedVolume = Math.max(0, Math.min(200, 100 + replayGain));
  
  queue.node.setVolume(normalizedVolume);
});

queue.on('volume', (volume) => {
  console.log(`Volume changed to ${volume}%`);
});

const volumeState = new Map<string, number>();

// Save volume for guild
volumeState.set(guild.id, queue.node.volume);

// Restore volume
const savedVolume = volumeState.get(guild.id);
if (savedVolume !== undefined) {
  queue.node.setVolume(savedVolume);
}

import { writeFile, readFile } from 'fs/promises';

interface VolumeSettings {
  [guildId: string]: number;
}

// Save volume settings
async function saveVolumeSettings(settings: VolumeSettings) {
  await writeFile(
    'volume-settings.json',
    JSON.stringify(settings, null, 2)
  );
}

// Load volume settings
async function loadVolumeSettings(): Promise<VolumeSettings> {
  try {
    const data = await readFile('volume-settings.json', 'utf-8');
    return JSON.parse(data);
  } catch {
    return {};
  }
}

// Usage
const settings = await loadVolumeSettings();
const queue = player.queues.get(guild);

if (queue && settings[guild.id]) {
  queue.node.setVolume(settings[guild.id]);
}

import { EqualizerConfigurationPreset } from 'discord-player';

// Apply EQ preset
await queue.filters.equalizer?.setEQ(
  EqualizerConfigurationPreset.FullBass
);

// Reduce volume to prevent clipping
queue.node.setVolume(70);

const graph = queue.filters.graph.dump();
console.log('Current volume:', graph.volume); // 100

// Access volume transformer directly
const volumeTransformer = queue.filters.graph.volume;
console.log('Volume:', volumeTransformer?.volume);

// Access cached volume
const cachedVolume = queue.filters._lastFiltersCache.volume;
console.log('Cached volume:', cachedVolume);

// Volume persists across track changes
queue.node.skip();
// New track plays at same volume

import { SlashCommandBuilder } from 'discord.js';

export const command = new SlashCommandBuilder()
  .setName('volume')
  .setDescription('Set playback volume')
  .addIntegerOption(option =>
    option
      .setName('level')
      .setDescription('Volume level (0-200)')
      .setMinValue(0)
      .setMaxValue(200)
      .setRequired(true)
  );

export async function execute(interaction: ChatInputCommandInteraction) {
  const queue = useQueue(interaction.guild!);
  
  if (!queue) {
    return interaction.reply('No music playing!');
  }
  
  const volume = interaction.options.getInteger('level', true);
  const success = queue.node.setVolume(volume);
  
  if (success) {
    return interaction.reply(`🔊 Volume set to ${volume}%`);
  } else {
    return interaction.reply('Failed to set volume');
  }
}

// Volume up
export async function volumeUp(interaction: ChatInputCommandInteraction) {
  const queue = useQueue(interaction.guild!);
  if (!queue) return;
  
  const currentVolume = queue.node.volume;
  const newVolume = Math.min(200, currentVolume + 10);
  
  queue.node.setVolume(newVolume);
  await interaction.reply(`🔊 Volume: ${newVolume}%`);
}

// Volume down
export async function volumeDown(interaction: ChatInputCommandInteraction) {
  const queue = useQueue(interaction.guild!);
  if (!queue) return;
  
  const currentVolume = queue.node.volume;
  const newVolume = Math.max(0, currentVolume - 10);
  
  queue.node.setVolume(newVolume);
  await interaction.reply(`🔉 Volume: ${newVolume}%`);
}