yukimu 1.3.0 → 2.0.0

package/dist/Player.js

@@ -1,24 +1,47 @@
 "use strict";
+/** Yukimu v2.0.0 — Player with State Safety & Bitrate Optimization */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Player = void 0;
 const Queue_1 = require("./Queue");
+const BitrateOptimizer_1 = require("./BitrateOptimizer");
 const Constants_1 = require("./Constants");
 const YukimuError_1 = require("./errors/YukimuError");
+/**
+ * Represents an audio player for a specific Discord guild.
+ *
+ * Critical fixes from v1:
+ * 1. play() — only sets playing=true AFTER the REST call succeeds
+ * 2. pause() — paused tracks are still "playing" from Lavalink's perspective
+ * 3. moveToNode() — properly re-sends voice state to the new node
+ * 4. sendVoicePayload() — deferred until connector is ready (safe for startup)
+ * 5. Proper cleanup in destroy() — all state, timers, and references
+ * 6. Input validation on filter values
+ * 7. Boost-tier-aware audio optimization
+ */
 class Player {
+    manager;
+    node;
+    queue;
+    guildId;
+    voiceChannelId;
+    textChannelId;
+    state = Constants_1.PlayerState.DISCONNECTED;
+    playing = false;
+    paused = false;
+    position = 0;
+    ping = -1;
+    lastUpdated = Date.now();
+    volume;
+    loop = "none";
+    autoplay = false;
+    sessionId = null;
+    voiceToken = null;
+    voiceEndpoint = null;
+    selfDeaf;
+    selfMute;
+    filters = {};
+    data = new Map();
     constructor(manager, node, options) {
-        this.state = Constants_1.PlayerState.DISCONNECTED;
-        this.playing = false;
-        this.paused = false;
-        this.position = 0;
-        this.ping = -1;
-        this.lastUpdated = Date.now();
-        this.loop = "none";
-        this.autoplay = false;
-        this.sessionId = null;
-        this.voiceToken = null;
-        this.voiceEndpoint = null;
-        this.filters = {};
-        this.data = new Map();
         this.manager = manager;
         this.node = node;
         this.queue = new Queue_1.Queue();
@@ -28,21 +51,46 @@ class Player {
         this.volume = options.volume ?? 100;
         this.selfDeaf = options.selfDeaf ?? true;
         this.selfMute = options.selfMute ?? false;
+        // Send the voice state update to Discord (join the channel)
+        // This is safe — connector.sendPayload handles missing guilds gracefully
         this.sendVoicePayload(options.voiceChannelId, this.selfDeaf, this.selfMute);
         this.state = Constants_1.PlayerState.CONNECTING;
     }
-    get connected() { return this.state === Constants_1.PlayerState.CONNECTED; }
+    // ─── Getters ────────────────────────────────────────────────────────────
+    get connected() {
+        return this.state === Constants_1.PlayerState.CONNECTED;
+    }
+    /**
+     * Estimated real-time position accounting for time since last update.
+     * Returns the actual position (capped at track length).
+     */
     get realPosition() {
         if (!this.playing || this.paused)
             return this.position;
-        return Math.min(this.position + (Date.now() - this.lastUpdated), this.queue.current?.info?.length ?? this.position);
+        const trackLength = this.queue.current?.info?.length ?? Infinity;
+        return Math.min(this.position + (Date.now() - this.lastUpdated), trackLength);
     }
+    /**
+     * Get the current boost tier of the guild this player is in.
+     */
+    get boostTier() {
+        return this.manager.connector.getGuildBoostTier(this.guildId);
+    }
+    // ─── Voice ──────────────────────────────────────────────────────────────
     sendVoicePayload(channelId, selfDeaf, selfMute) {
         this.manager.connector.sendPayload(this.guildId, {
             op: 4,
-            d: { guild_id: this.guildId, channel_id: channelId, self_deaf: selfDeaf, self_mute: selfMute },
+            d: {
+                guild_id: this.guildId,
+                channel_id: channelId,
+                self_deaf: selfDeaf,
+                self_mute: selfMute,
+            },
         });
     }
+    /**
+     * Check if we have all voice connection data and send it to Lavalink.
+     */
     checkVoiceReady() {
         if (!this.sessionId || !this.voiceToken || !this.voiceEndpoint)
             return;
@@ -53,22 +101,38 @@ class Player {
             channelId: this.voiceChannelId,
         };
         if (this.node.version === 4) {
-            this.node.rest.updatePlayer(this.guildId, { voice: voiceState }).catch(console.error);
+            this.node.rest.updatePlayer(this.guildId, { voice: voiceState }).catch((err) => {
+                this.manager.logger.error(`Failed to send voice update for guild ${this.guildId}: ${err}`);
+            });
         }
         else {
             this.node.send({
                 op: "voiceUpdate",
                 guildId: this.guildId,
                 sessionId: this.sessionId,
-                event: { token: this.voiceToken, guild_id: this.guildId, endpoint: this.voiceEndpoint },
+                event: {
+                    token: this.voiceToken,
+                    guild_id: this.guildId,
+                    endpoint: this.voiceEndpoint,
+                },
+            }).catch((err) => {
+                this.manager.logger.error(`Failed to send voice update for guild ${this.guildId}: ${err}`);
             });
         }
         this.state = Constants_1.PlayerState.CONNECTED;
     }
+    // ─── Playback ───────────────────────────────────────────────────────────
+    /**
+     * Play a track. If no track is provided, plays the current queue track.
+     *
+     * FIX: Only sets `playing = true` after the REST call succeeds.
+     * In v1, state was set before the REST call, causing ghost playing state on failure.
+     */
     async play(track, options) {
         const toPlay = track ?? this.queue.current;
-        if (!toPlay)
-            throw new YukimuError_1.PlayerError("No track to play");
+        if (!toPlay) {
+            throw new YukimuError_1.PlayerError("No track to play", YukimuError_1.ErrorCode.PLAYER_NO_TRACK);
+        }
         this.queue.current = toPlay;
         if (this.node.version === 4) {
             await this.node.rest.updatePlayer(this.guildId, {
@@ -79,7 +143,7 @@ class Player {
             }, options?.noReplace ?? false);
         }
         else {
-            this.node.send({
+            await this.node.send({
                 op: "play",
                 guildId: this.guildId,
                 track: toPlay.encoded,
@@ -88,27 +152,36 @@ class Player {
                 ...(options?.endTime !== undefined && { endTime: String(options.endTime) }),
             });
         }
+        // Only update state AFTER the call succeeds
         this.playing = true;
         this.paused = false;
         this.lastUpdated = Date.now();
     }
+    /**
+     * Pause or unpause playback.
+     *
+     * FIX: `playing` now reflects "has an active track" independently of pause state.
+     * A paused player is still "playing" (it has an active track, just paused).
+     */
     async pause(state = true) {
         if (this.node.version === 4) {
             await this.node.rest.updatePlayer(this.guildId, { paused: state });
         }
         else {
-            this.node.send({ op: "pause", guildId: this.guildId, pause: state });
+            await this.node.send({ op: "pause", guildId: this.guildId, pause: state });
         }
         this.paused = state;
-        this.playing = !state;
+        // `playing` stays true — the track is still loaded, just paused
+    }
+    async resume() {
+        return this.pause(false);
     }
-    async resume() { return this.pause(false); }
     async stop() {
         if (this.node.version === 4) {
             await this.node.rest.updatePlayer(this.guildId, { track: { encoded: null } });
         }
         else {
-            this.node.send({ op: "stop", guildId: this.guildId });
+            await this.node.send({ op: "stop", guildId: this.guildId });
         }
         this.playing = false;
         this.paused = false;
@@ -126,41 +199,77 @@ class Player {
         }
         return next;
     }
+    /**
+     * Play the previous track (from history).
+     * @returns The previous track, or null if no history exists
+     */
+    async previous() {
+        const prev = this.queue.previous[0];
+        if (!prev)
+            return null;
+        // Move current back to front of queue
+        if (this.queue.current) {
+            this.queue.add(this.queue.current, 0);
+        }
+        // Remove from previous history
+        this.queue.previous.shift();
+        await this.play(prev);
+        return prev;
+    }
+    /**
+     * Restart the currently playing track from the beginning.
+     */
+    async replay() {
+        if (!this.queue.current) {
+            throw new YukimuError_1.PlayerError("No track to replay", YukimuError_1.ErrorCode.PLAYER_NO_TRACK);
+        }
+        await this.play(this.queue.current, { startTime: 0 });
+    }
     async seek(position) {
-        if (!this.queue.current?.info?.isSeekable)
-            throw new YukimuError_1.PlayerError("Current track is not seekable");
+        if (!this.queue.current?.info?.isSeekable) {
+            throw new YukimuError_1.PlayerError("Current track is not seekable", YukimuError_1.ErrorCode.PLAYER_NOT_SEEKABLE);
+        }
+        if (position < 0)
+            position = 0;
         if (this.node.version === 4) {
             await this.node.rest.updatePlayer(this.guildId, { position });
         }
         else {
-            this.node.send({ op: "seek", guildId: this.guildId, position });
+            await this.node.send({ op: "seek", guildId: this.guildId, position });
         }
         this.position = position;
         this.lastUpdated = Date.now();
     }
+    // ─── Volume ─────────────────────────────────────────────────────────────
     async setVolume(volume) {
-        if (volume < 0 || volume > 1000)
-            throw new YukimuError_1.PlayerError("Volume must be between 0 and 1000");
+        if (typeof volume !== "number" || isNaN(volume)) {
+            throw new YukimuError_1.PlayerError("Volume must be a number", YukimuError_1.ErrorCode.PLAYER_INVALID_VOLUME);
+        }
+        volume = Math.floor(Math.max(0, Math.min(1000, volume)));
         if (this.node.version === 4) {
             await this.node.rest.updatePlayer(this.guildId, { volume });
         }
         else {
-            this.node.send({ op: "volume", guildId: this.guildId, volume });
+            await this.node.send({ op: "volume", guildId: this.guildId, volume });
         }
         this.volume = volume;
     }
+    // ─── Filters ────────────────────────────────────────────────────────────
     async setFilters(filters) {
         this.filters = { ...this.filters, ...filters };
         if (this.node.version === 4) {
             await this.node.rest.updatePlayer(this.guildId, { filters: this.filters });
         }
         else {
-            if (filters.equalizer)
-                this.node.send({ op: "equalizer", guildId: this.guildId, bands: filters.equalizer });
+            // v3: equalizer is sent separately
+            if (filters.equalizer) {
+                await this.node.send({ op: "equalizer", guildId: this.guildId, bands: filters.equalizer });
+            }
             const rest = { ...filters };
             delete rest.equalizer;
-            if (Object.keys(rest).length > 0)
-                this.node.send({ op: "filters", guildId: this.guildId, ...rest });
+            if (Object.keys(rest).length > 0) {
+                await this.node.send({ op: "filters", guildId: this.guildId, ...rest });
+            }
         }
     }
     async clearFilters() {
@@ -169,128 +278,221 @@ class Player {
             await this.node.rest.updatePlayer(this.guildId, { filters: {} });
         }
         else {
-            this.node.send({ op: "filters", guildId: this.guildId });
+            await this.node.send({ op: "filters", guildId: this.guildId });
         }
     }
+    // ─── Filter Presets ─────────────────────────────────────────────────────
     async setBassBoost(level) {
-        const presets = {
-            off: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
-            low: [0.2, 0.15, 0.1, 0.05, 0, -0.05, 0, 0, 0, 0, 0, 0, 0, 0, 0],
-            medium: [0.4, 0.3, 0.2, 0.1, 0.05, -0.05, 0, 0, 0, 0, 0, 0, 0, 0, 0],
-            high: [0.6, 0.5, 0.4, 0.25, 0.1, -0.1, 0, 0, 0, 0, 0, 0, 0, 0, 0],
-            extreme: [1.0, 0.8, 0.6, 0.4, 0.2, -0.2, 0, 0, 0, 0, 0, 0, 0, 0, 0],
-        };
-        await this.setFilters({ equalizer: presets[level].map((gain, band) => ({ band, gain })) });
+        const tier = this.boostTier;
+        if (level === "off") {
+            await this.setFilters({ equalizer: BitrateOptimizer_1.BitrateOptimizer.getFlatEQ() });
+            return;
+        }
+        // Scale bass based on boost tier to prevent clipping
+        const scales = { low: 0.3, medium: 0.5, high: 0.75, extreme: 1.0 };
+        const scale = scales[level] ?? 0.5;
+        const tierScale = tier >= 2 ? 1.0 : tier === 1 ? 0.8 : 0.6;
+        const effectiveScale = scale * tierScale;
+        const eq = [
+            { band: 0, gain: 0.6 * effectiveScale },
+            { band: 1, gain: 0.5 * effectiveScale },
+            { band: 2, gain: 0.4 * effectiveScale },
+            { band: 3, gain: 0.25 * effectiveScale },
+            { band: 4, gain: 0.1 * effectiveScale },
+            { band: 5, gain: -0.05 * effectiveScale },
+            ...Array.from({ length: 9 }, (_, i) => ({ band: i + 6, gain: 0 })),
+        ];
+        await this.setFilters({ equalizer: eq });
     }
     async setNightcore(enabled) {
-        await this.setFilters({ timescale: enabled ? { speed: 1.2, pitch: 1.2, rate: 1.0 } : {} });
+        await this.setFilters({
+            timescale: enabled ? { speed: 1.2, pitch: 1.2, rate: 1.0 } : {},
+        });
     }
     async setVaporwave(enabled) {
-        await this.setFilters({ timescale: enabled ? { speed: 0.8, pitch: 0.8, rate: 1.0 } : {} });
+        await this.setFilters({
+            timescale: enabled ? { speed: 0.8, pitch: 0.8, rate: 1.0 } : {},
+        });
     }
     async set8D(enabled) {
-        await this.setFilters({ rotation: enabled ? { rotationHz: 0.2 } : {} });
+        await this.setFilters({
+            rotation: enabled ? { rotationHz: 0.2 } : {},
+        });
     }
     async setKaraoke(enabled) {
-        await this.setFilters({ karaoke: enabled ? { level: 1.0, monoLevel: 1.0, filterBand: 220.0, filterWidth: 100.0 } : {} });
+        await this.setFilters({
+            karaoke: enabled
+                ? { level: 1.0, monoLevel: 1.0, filterBand: 220.0, filterWidth: 100.0 }
+                : {},
+        });
     }
     async setTremolo(enabled, frequency = 2.0, depth = 0.5) {
+        if (enabled) {
+            if (frequency <= 0 || frequency > 14) {
+                throw new YukimuError_1.PlayerError("Tremolo frequency must be between 0 and 14", YukimuError_1.ErrorCode.PLAYER_INVALID_FILTER);
+            }
+            if (depth <= 0 || depth > 1) {
+                throw new YukimuError_1.PlayerError("Tremolo depth must be between 0 and 1", YukimuError_1.ErrorCode.PLAYER_INVALID_FILTER);
+            }
+        }
         await this.setFilters({ tremolo: enabled ? { frequency, depth } : {} });
     }
     async setVibrato(enabled, frequency = 2.0, depth = 0.5) {
+        if (enabled) {
+            if (frequency <= 0 || frequency > 14) {
+                throw new YukimuError_1.PlayerError("Vibrato frequency must be between 0 and 14", YukimuError_1.ErrorCode.PLAYER_INVALID_FILTER);
+            }
+            if (depth <= 0 || depth > 1) {
+                throw new YukimuError_1.PlayerError("Vibrato depth must be between 0 and 1", YukimuError_1.ErrorCode.PLAYER_INVALID_FILTER);
+            }
+        }
         await this.setFilters({ vibrato: enabled ? { frequency, depth } : {} });
     }
     async setLowPass(enabled, smoothing = 20.0) {
+        if (enabled && smoothing <= 0) {
+            throw new YukimuError_1.PlayerError("LowPass smoothing must be greater than 0", YukimuError_1.ErrorCode.PLAYER_INVALID_FILTER);
+        }
         await this.setFilters({ lowPass: enabled ? { smoothing } : {} });
     }
+    /** Set playback speed (1.0 = normal, 2.0 = double speed) */
+    async setSpeed(speed) {
+        if (speed <= 0 || speed > 10) {
+            throw new YukimuError_1.PlayerError("Speed must be between 0 and 10", YukimuError_1.ErrorCode.PLAYER_INVALID_FILTER);
+        }
+        const existing = (this.filters.timescale ?? {});
+        await this.setFilters({
+            timescale: { ...existing, speed },
+        });
+    }
+    /** Set playback pitch (1.0 = normal) */
+    async setPitch(pitch) {
+        if (pitch <= 0 || pitch > 10) {
+            throw new YukimuError_1.PlayerError("Pitch must be between 0 and 10", YukimuError_1.ErrorCode.PLAYER_INVALID_FILTER);
+        }
+        const existing = (this.filters.timescale ?? {});
+        await this.setFilters({
+            timescale: { ...existing, pitch },
+        });
+    }
+    // ─── Queue Shortcuts ───────────────────────────────────────────────────
+    /**
+     * Add track(s) to the queue. If nothing is currently playing, plays immediately.
+     */
     async add(tracks, requester) {
-        const arr = Array.isArray(tracks) ? tracks : [tracks];
-        if (requester)
-            arr.forEach(t => { t.requester = requester; });
+        const arr = Array.isArray(tracks) ? [...tracks] : [tracks];
+        if (requester) {
+            for (const t of arr) {
+                t["requester"] = requester;
+            }
+        }
         if (!this.queue.current && arr.length > 0) {
             const first = arr.shift();
-            this.queue.add(arr);
+            if (arr.length > 0)
+                this.queue.add(arr);
             await this.play(first);
         }
         else {
             this.queue.add(arr);
         }
     }
-    setLoop(mode) { this.loop = mode; }
-    setAutoplay(enabled) { this.autoplay = enabled; }
+    setLoop(mode) {
+        this.loop = mode;
+    }
+    setAutoplay(enabled) {
+        this.autoplay = enabled;
+    }
+    // ─── Node Movement ─────────────────────────────────────────────────────
+    /**
+     * Move this player to a different Lavalink node.
+     *
+     * FIX: Now properly re-sends the voice state to the new node.
+     * In v1, the new node didn't know about the voice connection.
+     */
     async moveToNode(node) {
         if (this.node === node)
             return;
         const oldNode = this.node;
         this.node = node;
+        // Clean up on old node
         await oldNode.rest.destroyPlayer(this.guildId).catch(() => { });
+        // Re-send voice state to new node
+        this.checkVoiceReady();
+        // Resume playback on new node
         if (this.queue.current) {
             await this.play(this.queue.current, { startTime: this.realPosition });
         }
-        if (Object.keys(this.filters).length > 0)
+        // Re-apply filters and volume
+        if (Object.keys(this.filters).length > 0) {
             await this.setFilters(this.filters).catch(() => { });
-        if (this.volume !== 100)
+        }
+        if (this.volume !== 100) {
             await this.setVolume(this.volume).catch(() => { });
+        }
     }
+    /** Move the bot to a different voice channel */
     async move(channelId) {
         this.voiceChannelId = channelId;
         this.sendVoicePayload(channelId, this.selfDeaf, this.selfMute);
     }
-    async destroy() {
-        this.state = Constants_1.PlayerState.DISCONNECTING;
-        this.sendVoicePayload(null, false, false);
-        await this.node.rest.destroyPlayer(this.guildId).catch(() => { });
-        this.playing = false;
-        this.paused = false;
-        this.queue.clear();
-        this.data.clear();
-        this.state = Constants_1.PlayerState.DISCONNECTED;
+    // ─── Audio Quality ──────────────────────────────────────────────────────
+    /**
+     * Apply optimal audio settings based on the guild's boost tier.
+     * Automatically adjusts EQ and filters for best clarity at the available bitrate.
+     */
+    async applyOptimalQuality() {
+        const tier = this.boostTier;
+        const filters = BitrateOptimizer_1.BitrateOptimizer.getOptimalFilters(tier);
+        await this.setFilters(filters);
+        this.manager.logger.debug(`Applied optimal quality for guild ${this.guildId} (boost tier ${tier}, max ${BitrateOptimizer_1.BitrateOptimizer.getMaxBitrate(tier)}kbps)`);
     }
-    // ─── Audio Quality Presets ────────────────────────────────────────
     /** Maximum audio quality — crystal clear, enhanced bass & treble */
     async setHighQuality() {
+        const tier = this.boostTier;
+        const scale = tier >= 2 ? 1.0 : tier === 1 ? 0.8 : 0.6;
         await this.setFilters({
             equalizer: [
-                { band: 0, gain: 0.25 }, // Sub bass boost
-                { band: 1, gain: 0.20 }, // Bass boost
-                { band: 2, gain: 0.15 }, // Low mid bass
-                { band: 3, gain: 0.05 }, // Mid bass
-                { band: 4, gain: 0.0 }, // Low mid flat
-                { band: 5, gain: 0.0 }, // Mid flat
-                { band: 6, gain: 0.0 }, // Upper mid flat
-                { band: 7, gain: 0.05 }, // Presence slight boost
-                { band: 8, gain: 0.10 }, // Upper presence
-                { band: 9, gain: 0.15 }, // Treble boost
-                { band: 10, gain: 0.15 }, // Upper treble
-                { band: 11, gain: 0.10 }, // Air
-                { band: 12, gain: 0.05 }, // Brilliance
-                { band: 13, gain: 0.0 }, // Ultra high
-                { band: 14, gain: 0.0 }, // Ultra high
+                { band: 0, gain: 0.25 * scale },
+                { band: 1, gain: 0.20 * scale },
+                { band: 2, gain: 0.15 * scale },
+                { band: 3, gain: 0.05 * scale },
+                { band: 4, gain: 0.0 },
+                { band: 5, gain: 0.0 },
+                { band: 6, gain: 0.0 },
+                { band: 7, gain: 0.05 * scale },
+                { band: 8, gain: 0.10 * scale },
+                { band: 9, gain: 0.15 * scale },
+                { band: 10, gain: 0.15 * scale },
+                { band: 11, gain: 0.10 * scale },
+                { band: 12, gain: 0.05 * scale },
+                { band: 13, gain: 0.0 },
+                { band: 14, gain: 0.0 },
             ],
-            lowPass: { smoothing: 5.0 }, // Very light low pass for clarity
+            lowPass: tier >= 2 ? { smoothing: 5.0 } : {},
         });
     }
     /** Studio quality — flat, neutral, most accurate */
     async setStudioQuality() {
         await this.clearFilters();
         await this.setFilters({
-            equalizer: Array.from({ length: 15 }, (_, i) => ({ band: i, gain: 0 })),
+            equalizer: BitrateOptimizer_1.BitrateOptimizer.getFlatEQ(),
         });
     }
-    /** Concert hall effect */
+    /** Concert hall effect — scaled for boost tier */
     async setConcertHall() {
+        const tier = this.boostTier;
+        const scale = tier >= 2 ? 1.0 : 0.6;
         await this.setFilters({
             equalizer: [
-                { band: 0, gain: 0.1 },
-                { band: 1, gain: 0.1 },
-                { band: 2, gain: 0.05 },
+                { band: 0, gain: 0.1 * scale },
+                { band: 1, gain: 0.1 * scale },
+                { band: 2, gain: 0.05 * scale },
                 { band: 3, gain: 0.0 },
-                { band: 4, gain: -0.05 },
+                { band: 4, gain: -0.05 * scale },
                 { band: 5, gain: 0.0 },
-                { band: 6, gain: 0.05 },
-                { band: 7, gain: 0.1 },
-                { band: 8, gain: 0.1 },
-                { band: 9, gain: 0.05 },
+                { band: 6, gain: 0.05 * scale },
+                { band: 7, gain: 0.1 * scale },
+                { band: 8, gain: 0.1 * scale },
+                { band: 9, gain: 0.05 * scale },
                 { band: 10, gain: 0.0 },
                 { band: 11, gain: 0.0 },
                 { band: 12, gain: 0.0 },
@@ -300,6 +502,29 @@ class Player {
             rotation: { rotationHz: 0.05 },
         });
     }
+    // ─── Lifecycle ──────────────────────────────────────────────────────────
+    /**
+     * Destroy this player and clean up all resources.
+     */
+    async destroy() {
+        this.state = Constants_1.PlayerState.DISCONNECTING;
+        // Leave voice channel
+        this.sendVoicePayload(null, false, false);
+        // Destroy on Lavalink
+        await this.node.rest.destroyPlayer(this.guildId).catch(() => { });
+        // Clean up all state
+        this.playing = false;
+        this.paused = false;
+        this.position = 0;
+        this.queue.clear();
+        this.data.clear();
+        this.filters = {};
+        this.sessionId = null;
+        this.voiceToken = null;
+        this.voiceEndpoint = null;
+        this.voiceChannelId = null;
+        this.state = Constants_1.PlayerState.DISCONNECTED;
+    }
 }
 exports.Player = Player;
 //# sourceMappingURL=Player.js.map