빌드 관련 설정 업데이트

2025-10-26 09:55:14 +00:00 · 2024-08-03 14:57:51 +09:00
63 changed files with 973 additions and 1691 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -1,7 +1,7 @@
-build/*
-Temp/
-Music
-*.json
-yt-dlp
-ffmpeg
-password
+build/
+out/
+.vs/
+.vscode/
+.idea/
+tmp/
+config.json
--- a/.idea/.gitignore
+++ b/.idea/.gitignore
@@ -1,10 +0,0 @@
-# Default ignored files
-/shelf/
-/workspace.xml
-# Editor-based HTTP Client requests
-/httpRequests/
-# Environment-dependent path to Maven home directory
-/mavenHomeManager.xml
-# Datasource local storage ignored files
-/dataSources/
-/dataSources.local.xml
--- a/.idea/BumbleCee.iml
+++ b/.idea/BumbleCee.iml
@@ -1,9 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<module type="JAVA_MODULE" version="4">
-  <component name="NewModuleRootManager" inherit-compiler-output="true">
-    <exclude-output />
-    <content url="file://$MODULE_DIR$" />
-    <orderEntry type="inheritedJdk" />
-    <orderEntry type="sourceFolder" forTests="false" />
-  </component>
-</module>
--- a/.idea/misc.xml
+++ b/.idea/misc.xml
@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="ProjectRootManager" version="2" languageLevel="JDK_23" default="true" project-jdk-name="openjdk-23" project-jdk-type="JavaSDK">
-    <output url="file://$PROJECT_DIR$/out" />
-  </component>
-</project>
--- a/.idea/modules.xml
+++ b/.idea/modules.xml
@@ -1,8 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="ProjectModuleManager">
-    <modules>
-      <module fileurl="file://$PROJECT_DIR$/.idea/BumbleCee.iml" filepath="$PROJECT_DIR$/.idea/BumbleCee.iml" />
-    </modules>
-  </component>
-</project>
--- a/.idea/vcs.xml
+++ b/.idea/vcs.xml
@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="VcsDirectoryMappings">
-    <mapping directory="" vcs="Git" />
-  </component>
-</project>
--- a/.vscode/c_cpp_properties.json
+++ b/.vscode/c_cpp_properties.json
@@ -1,22 +0,0 @@
-{
-    "configurations": [
-        {
-            "name": "Linux",
-            "includePath": [
-                "${workspaceFolder}/**",
-                "${workspaceFolder}/include"
-            ],
-            "defines": [
-                "DDPP_CORO=on"
-            ],
-            "compilerPath": "/usr/bin/gcc",
-            "cStandard": "c17",
-            "cppStandard": "c++20",
-            "intelliSenseMode": "linux-gcc-x64",
-            "compilerArgs": [
-                "-DDPP_CORO"
-            ]
-        }
-    ],
-    "version": 4
-}
--- a/.vscode/launch.json
+++ b/.vscode/launch.json
@@ -5,7 +5,7 @@
            "name": "Debug",
            "type": "cppdbg",
            "request": "launch",
-            "program": "${workspaceFolder}/build/BumbleCee",
+            "program": "/home/happytanuki/BumbleCee/build/BumbleCee",
            "stopAtEntry": false,
            "cwd": "${workspaceFolder}",
            "environment": [],
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@@ -1,107 +1,78 @@
 {
    "files.associations": {
-        "iosfwd": "cpp",
+        "iostream": "cpp",
+        "any": "cpp",
+        "chrono": "cpp",
+        "codecvt": "cpp",
+        "compare": "cpp",
+        "condition_variable": "cpp",
+        "deque": "cpp",
+        "forward_list": "cpp",
+        "list": "cpp",
+        "string": "cpp",
+        "unordered_map": "cpp",
+        "vector": "cpp",
+        "exception": "cpp",
+        "functional": "cpp",
+        "iterator": "cpp",
+        "memory": "cpp",
+        "memory_resource": "cpp",
+        "optional": "cpp",
+        "string_view": "cpp",
+        "random": "cpp",
+        "*.tcc": "cpp",
+        "fstream": "cpp",
+        "future": "cpp",
+        "initializer_list": "cpp",
+        "istream": "cpp",
+        "mutex": "cpp",
+        "new": "cpp",
+        "ostream": "cpp",
+        "ranges": "cpp",
+        "semaphore": "cpp",
+        "shared_mutex": "cpp",
        "sstream": "cpp",
+        "stdexcept": "cpp",
+        "stop_token": "cpp",
+        "streambuf": "cpp",
+        "system_error": "cpp",
+        "thread": "cpp",
+        "tuple": "cpp",
+        "type_traits": "cpp",
+        "typeinfo": "cpp",
+        "valarray": "cpp",
+        "variant": "cpp",
+        "array": "cpp",
+        "atomic": "cpp",
+        "bit": "cpp",
        "cctype": "cpp",
+        "charconv": "cpp",
        "clocale": "cpp",
        "cmath": "cpp",
+        "concepts": "cpp",
+        "coroutine": "cpp",
        "csignal": "cpp",
        "cstdarg": "cpp",
        "cstddef": "cpp",
+        "cstdint": "cpp",
        "cstdio": "cpp",
        "cstdlib": "cpp",
        "cstring": "cpp",
        "ctime": "cpp",
        "cwchar": "cpp",
        "cwctype": "cpp",
-        "any": "cpp",
-        "array": "cpp",
-        "atomic": "cpp",
-        "strstream": "cpp",
-        "bit": "cpp",
-        "*.tcc": "cpp",
-        "bitset": "cpp",
-        "charconv": "cpp",
-        "chrono": "cpp",
-        "codecvt": "cpp",
-        "compare": "cpp",
-        "complex": "cpp",
-        "concepts": "cpp",
-        "condition_variable": "cpp",
-        "coroutine": "cpp",
-        "cstdint": "cpp",
-        "deque": "cpp",
-        "forward_list": "cpp",
-        "list": "cpp",
        "map": "cpp",
-        "set": "cpp",
-        "string": "cpp",
-        "unordered_map": "cpp",
-        "vector": "cpp",
-        "exception": "cpp",
        "algorithm": "cpp",
-        "functional": "cpp",
-        "iterator": "cpp",
-        "memory": "cpp",
-        "memory_resource": "cpp",
        "numeric": "cpp",
-        "optional": "cpp",
-        "random": "cpp",
        "ratio": "cpp",
-        "source_location": "cpp",
-        "string_view": "cpp",
-        "system_error": "cpp",
-        "tuple": "cpp",
-        "type_traits": "cpp",
        "utility": "cpp",
-        "fstream": "cpp",
-        "future": "cpp",
-        "initializer_list": "cpp",
        "iomanip": "cpp",
-        "iostream": "cpp",
-        "istream": "cpp",
+        "iosfwd": "cpp",
        "limits": "cpp",
-        "mutex": "cpp",
-        "new": "cpp",
        "numbers": "cpp",
-        "ostream": "cpp",
-        "ranges": "cpp",
-        "semaphore": "cpp",
-        "shared_mutex": "cpp",
-        "stdexcept": "cpp",
-        "stop_token": "cpp",
-        "streambuf": "cpp",
-        "thread": "cpp",
        "cinttypes": "cpp",
-        "typeindex": "cpp",
-        "typeinfo": "cpp",
-        "valarray": "cpp",
-        "variant": "cpp",
-        "*.ipp": "cpp",
-        "format": "cpp",
-        "span": "cpp",
-        "__bit_reference": "cpp",
-        "__bits": "cpp",
-        "__config": "cpp",
-        "__debug": "cpp",
-        "__errc": "cpp",
-        "__hash_table": "cpp",
-        "__locale": "cpp",
-        "__mutex_base": "cpp",
-        "__node_handle": "cpp",
-        "__nullptr": "cpp",
-        "__split_buffer": "cpp",
-        "__string": "cpp",
-        "__threading_support": "cpp",
-        "__tree": "cpp",
-        "__tuple": "cpp",
-        "ios": "cpp",
-        "locale": "cpp",
-        "queue": "cpp",
-        "hash_map": "cpp",
-        "hash_set": "cpp",
-        "regex": "cpp",
-        "stack": "cpp",
-        "__memory": "cpp"
+        "bitset": "cpp",
+        "set": "cpp",
+        "regex": "cpp"
    }
 }
--- a/.vscode/tasks.json
+++ b/.vscode/tasks.json
@@ -8,7 +8,7 @@
            "command": "make",
            "args": [],
            "options": {
-                "cwd": "${workspaceFolder}/build/"
+                "cwd": "/home/happytanuki/BumbleCee/build/"
            },
            "group": {
                "kind": "build",
@@ -24,7 +24,7 @@
                ".."
            ],
            "options": {
-                "cwd": "${workspaceFolder}/build/"
+                "cwd": "/home/happytanuki/BumbleCee/build/"
            },
            "group": {
                "kind": "build",
--- a/BuildDockerAndUpload.sh
+++ b/BuildDockerAndUpload.sh
@@ -1,8 +0,0 @@
-#!/bin/bash
-(
-    cd build
-    cmake .. && make
-)
-docker login -u happytanuki12 --password-stdin < password
-docker build --tag happytanuki12/bumblebee:latest .
-docker push happytanuki12/bumblebee:latest
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -5,21 +5,31 @@ set(BOT_NAME "BumbleCee")

 project(${BOT_NAME})
 aux_source_directory("src" coresrc)
-aux_source_directory("src/Audio" commands)
 aux_source_directory("src/Commands" commands)
-aux_source_directory("src/Queue" settings)
-aux_source_directory("src/Settings" settings)
-aux_source_directory("src/Utils" settings)
-add_executable(${BOT_NAME} ${coresrc} ${commands} ${settings})
+add_executable(${BOT_NAME} ${coresrc} ${commands})
+
+string(ASCII 27 Esc)

 set(CMAKE_POSITION_INDEPENDENT_CODE ON)
-set(CMAKE_BUILD_TYPE Debug)
-set(CMAKE_CXX_STANDARD 20)
-set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+set_target_properties(${BOT_NAME} PROPERTIES
+    CXX_STANDARD 17
+    CXX_STANDARD_REQUIRED ON
+)

 set(THREADS_PREFER_PTHREAD_FLAG TRUE)
 find_package(Threads REQUIRED)
-find_package(OpenSSL REQUIRED)
+find_package(DPP)
+if(APPLE)
+	if(CMAKE_APPLE_SILICON_PROCESSOR)
+		set(OPENSSL_ROOT_DIR "/opt/homebrew/opt/openssl")
+	else()
+		set(OPENSSL_ROOT_DIR "/usr/local/opt/openssl")
+	endif()
+	find_package(OpenSSL REQUIRED)
+else()
+	find_package(OpenSSL REQUIRED)
+endif()

 target_include_directories(${BOT_NAME} PUBLIC
    ${CMAKE_CURRENT_SOURCE_DIR}/include
@@ -28,8 +38,10 @@ target_include_directories(${BOT_NAME} PUBLIC
 )

 target_link_libraries(${BOT_NAME}
+    dl
    dpp
    opus
+    opusfile
    ogg
    oggz
    ${CMAKE_THREAD_LIBS_INIT}
@@ -37,4 +49,32 @@ target_link_libraries(${BOT_NAME}
    ${OPENSSL_SSL_LIBRARY}
 )

-link_directories(/usr/lib)
+if (DPP_FOUND)
+    target_link_libraries(${BOT_NAME} ${DPP_LIBRARIES})
+    target_include_directories(${BOT_NAME} PUBLIC ${DPP_INCLUDE_DIR})
+else()
+    message(WARNING "Could not find DPP install. Building from source instead.")
+    option(DPP_BUILD_TEST "" OFF)
+    include(FetchContent)
+
+    FetchContent_Declare(
+            libdpp
+            GIT_REPOSITORY https://github.com/brainboxdotcc/DPP.git
+            GIT_TAG master)
+
+    FetchContent_GetProperties(libdpp)
+    if(NOT libdpp_POPULATED)
+        FetchContent_Populate(libdpp)
+        target_include_directories(${BOT_NAME} PUBLIC
+            ${libdpp_SOURCE_DIR}/include
+        )
+        add_subdirectory(
+            ${libdpp_SOURCE_DIR}
+            ${libdpp_BINARY_DIR}
+            EXCLUDE_FROM_ALL)
+    endif()
+
+    target_link_libraries(${BOT_NAME} dpp)
+endif()
+
+set(CMAKE_CXX_FLAGS "-g")
--- a/DPP-markdown-logo.png
+++ b/DPP-markdown-logo.png
--- a/19
+++ b/19
@@ -1,19 +0,0 @@
-FROM debian:sid
-WORKDIR /
-RUN apt-get update && \
-    apt-get install -y curl libopus0 tini liboggz2 xz-utils ffmpeg python3 \
-        python3-pip python3-certifi python3-brotli python3-websockets python3-requests python3-mutagen && \
-    apt-get clean && \
-    rm -rf /var/lib/apt/lists/*
-RUN pip3 install --break-system-packages --no-cache-dir curl_cffi
-RUN pip3 install --break-system-packages --no-cache-dir pycryptodome
-RUN curl -Lo dpp.deb https://dl.dpp.dev/
-RUN dpkg -i dpp.deb
-RUN rm dpp.deb
-RUN curl -LO https://github.com/yt-dlp/yt-dlp/releases/latest/download/yt-dlp
-RUN chmod +x ./yt-dlp
-COPY ./build/BumbleCee /BumbleCee
-COPY ./streamOpus.sh /streamOpus.sh
-RUN chmod +x BumbleCee
-RUN chmod +x streamOpus.sh
-ENTRYPOINT ["/usr/bin/tini", "--", "./BumbleCee"]
--- a/README.md
+++ b/README.md
@@ -1,48 +0,0 @@
-
-# 이게 뭔가요?
-[![CodeFactor](https://www.codefactor.io/repository/github/happytanuki/bumblecee/badge)](https://www.codefactor.io/repository/github/happytanuki/bumblecee)
-
-C++ Dpp 라이브러리를 이용해서 개발된 간단한 디스코드 음악봇입니다!
-<div align="center">
-  <a href="https://github.com/brainboxdotcc/DPP" alt="DPP"> <img src="DPP-markdown-logo.png" /> </a>
-</div>
-
-
-# 어떻게 써요?
-1. 실행파일 경로에 config.json 파일을 만들고 다음과 같이 입력하세요:
-```
-{
-    "CLEAR_PREVIOUS_COMMAND": true,
-    "FFMPEG_CMD": "ffmpeg",
-    "LOGLEVEL": "debug",
-    "TOKEN": "발급받은 토큰",
-    "YTDLP_CMD": "./yt-dlp"
-}
-```
-2. 봇을 초대하시고 사용하시면 됩니다.
-
-# 명령어
-## /p
-노래를 예약합니다.
-사용법:
-/p (노래링크 또는 노래 제목)
-## /q
-현재 큐의 내용물을 확인합니다.
-사용법:
-/q
-## /d
-현재 큐의 내용물을 삭제합니다.
-현재 재생중인 곡은 0번입니다.
-사용법:
-/d (큐의 노래번호)
-## /s
-현재 곡을 스킵합니다.
-사용법:
-/s
-## /l
-음성 채팅을 떠납니다.
-사용법:
-/l
-
-# docker
-happytanuki12/bumblebee:latest
--- a/docker-compose.yml
+++ b/docker-compose.yml
@@ -1,7 +0,0 @@
-services:
-  bumblebee:
-    image: happytanuki12/bumblebee:latest
-    container_name: BumbleBee
-    volumes:
-      - ./config.json:/config.json
-    restart: unless-stopped
--- a/include/Audio/MusicPlayManager.hpp
+++ b/include/Audio/MusicPlayManager.hpp
@@ -1,67 +0,0 @@
-#pragma once
-#include <dpp/dpp.h>
-#include <Queue/MusicQueue.hpp>
-#include <condition_variable>
-
-namespace bumbleBee {
-class MusicPlayManager {
-public:
-    MusicPlayManager(std::shared_ptr<dpp::cluster> cluster, std::vector<dpp::snowflake> GIDs) :
-        cluster(cluster), GIDs(GIDs) {
-        queueMap = std::unordered_map<dpp::snowflake, std::shared_ptr<MusicQueue>>();
-        queueEmptyMutex = std::unordered_map<dpp::snowflake, std::shared_ptr<std::mutex>>();
-
-        cluster->on_voice_ready([this](const dpp::voice_ready_t &event){on_voice_ready(event);});
-        cluster->on_voice_track_marker([this](const dpp::voice_track_marker_t &event){on_voice_track_marker(event);});
-        cluster->on_voice_client_disconnect([this](const dpp::voice_client_disconnect_t& event){on_voice_client_disconnect(event);});
-
-        for (auto GID : GIDs) {
-            queueMap[GID] = std::make_shared<MusicQueue>();
-            queueEmptyMutex[GID] = std::make_shared<std::mutex>();
-        }
-    }
-
-    /**
-     * @brief voice_ready 이벤트 인지시 콜백되는 함수
-     * @param event const dpp::voice_ready_t&
-    **/
-    void on_voice_ready(const dpp::voice_ready_t& event);
-    /**
-     * @brief voice_track_marker 이벤트 인지시 콜백되는 함수
-     * @param event const dpp::voice_track_marker_t&
-    **/
-    void on_voice_track_marker(const dpp::voice_track_marker_t& event);
-    /**
-     * @brief voice_client_disconnect 이벤트 인지시 콜백되는 함수
-     * @param event const dpp::voice_client_disconnect_t&
-    **/
-    void on_voice_client_disconnect(const dpp::voice_client_disconnect_t& event);
-
-    void play(dpp::discord_voice_client* client);
-
-    void queue_music(const dpp::snowflake guildId, const std::shared_ptr<MusicQueueElement> music);
-
-    void clear(const dpp::snowflake guildId);
-    std::shared_ptr<MusicQueueElement> remove(const dpp::snowflake guildId, dpp::discord_voice_client* client, int index);
-    int size(const dpp::snowflake guildId);
-
-    void setRepeat(const dpp::snowflake guildId, const bool value);
-    bool getRepeat(const dpp::snowflake guildId);
-
-    std::pair<std::shared_ptr<std::list<std::shared_ptr<MusicQueueElement>>>, std::list<std::shared_ptr<MusicQueueElement>>::iterator> getQueue(const dpp::snowflake guildId);
-    MusicQueueElement getNowPlaying(const dpp::snowflake guildId);
-
-    std::condition_variable queuedCondition;
-    
-private:
-    std::shared_ptr<dpp::cluster> cluster;
-
-    std::vector<dpp::snowflake> GIDs;
-    /// @brief 음악 큐
-    std::unordered_map<dpp::snowflake, std::shared_ptr<MusicQueue>> queueMap;
-
-    std::unordered_map<dpp::snowflake, std::shared_ptr<std::mutex>> queueEmptyMutex;
-
-    void send_audio_to_voice(std::shared_ptr<bumbleBee::MusicQueueElement> music, dpp::discord_voice_client* client);
-};
-}
--- a/include/Bot.hpp
+++ b/include/Bot.hpp
@@ -0,0 +1,16 @@
+#pragma once
+#include <Commands/CommandType.hpp>
+#include <dpp/dpp.h>
+#include <memory>
+
+class IBot {
+public:
+    IBot(std::string token, int totalShard);
+    void start();
+    void onCommand(const dpp::slashcommand_t &event);
+    void onReady(const dpp::ready_t &event);
+
+    std::shared_ptr<dpp::cluster> botCluster;
+    std::vector<std::shared_ptr<commands::ICommand>> commandsArray;
+protected:
+};
--- a/include/BumbleBee.hpp
+++ b/include/BumbleBee.hpp
@@ -1,54 +0,0 @@
-#pragma once
-#ifndef _BUMBLEBEE_HPP_
-#define _BUMBLEBEE_HPP_
-#include <dpp/dpp.h>
-#include <dpp/nlohmann/json.hpp>
-#include <memory>
-#include <Commands/BumbleBeeCommand.hpp>
-
-namespace bumbleBee {
-/**
- * @file BumbleBee.hpp
- * @brief 메인 봇 클래스
-**/
-class BumbleBee {
-public:
-    /**
-     * @brief 생성자
-    **/
-    BumbleBee();
-    /**
-     * @brief 파괴자
-     * @details BumbleBee의 모든 Property를 책임지고 파괴합니다
-    **/
-    ~BumbleBee() {}
-
-    /**
-     * @brief 봇 시작
-    **/
-    void start();
-
-    /**
-     * @brief slashcommand 이벤트 인지시 콜백되는 함수
-     * @param event const dpp::slashcommand_t&
-    **/
-    void on_slashcommand(const dpp::slashcommand_t& event);
-    /**
-     * @brief ready 이벤트 인지시 콜백되는 함수
-     * @param event const dpp::ready_t&
-    **/
-    void on_ready(const dpp::ready_t& event);
-
-    /// @brief DPP 기본 클러스터 객체
-    std::shared_ptr<dpp::cluster> cluster;
-    /// @brief guild id 배열
-    std::vector<dpp::snowflake> GIDs;
-    
-private:
-    /// @brief Command 목록
-    std::unordered_map<std::string, std::shared_ptr<commands::ICommand>> commands;
-    /// @brief voiceclient 관련 event 처리기 <guild id, 각 길드별 MusicPlayManager 인스턴스>
-    std::shared_ptr<MusicPlayManager> musicManager;
-};
-}
-#endif
--- a/include/BumbleCeepp.hpp
+++ b/include/BumbleCeepp.hpp
@@ -0,0 +1,15 @@
+#pragma once
+#include <string>
+#include <Bot.hpp>
+#include <dpp/dpp.h>
+#include <MusicQueue.hpp>
+#include <memory>
+#include <unordered_map>
+
+class BumbleCeepp : public IBot {
+public:
+    BumbleCeepp(std::string token, int totalShard);
+private:
+    //<guild_id, queue> 쌍임.
+    std::unordered_map<dpp::snowflake, std::shared_ptr<MusicQueue>> queueMap;
+};
--- a/include/Commands/BumbleBeeCommand.hpp
+++ b/include/Commands/BumbleBeeCommand.hpp
@@ -1,69 +0,0 @@
-#pragma once
-#include <dpp/dpp.h>
-#include <Audio/MusicPlayManager.hpp>
-#include <functional>
-
-namespace bumbleBee::commands {
-class ICommand : public dpp::slashcommand {
-public:
-    /**
-     * @brief 기본 생성자
-     * @param botID 봇 아이디
-     * @param manager 음악재생 매니저
-    **/
-    ICommand(dpp::snowflake botID, std::shared_ptr<MusicPlayManager> manager) {
-        this->botID = botID;
-        this->musicManager = manager;
-    }
-    /**
-     * @brief 명령어 호출 시에 콜백될 메소드
-     * @param event dpp::slashcommand_t
-    **/
-    virtual void execute(const dpp::slashcommand_t &event){};
-
-    /// @brief 명령어 별명
-    std::vector<std::string> aliases;
-
-private:
-    /// @brief 봇 ID
-    dpp::snowflake botID;
-    
-protected:
-    /// @brief 음악재생 매니저
-    std::shared_ptr<MusicPlayManager> musicManager;
-
-protected:
-    /// @brief concrete class에서 구현해야 하는 init 이벤트트
-    virtual void init() = 0;
-};
-}
-
-/**
- * @brief 명령어 인자가 없는 명령어의 boilerplate 대체 매크로
- * @param name 명령어 이름 및 클래스명
- * @param description 명령어 설명
-**/
-#define _DECLARE_BUMBLEBEE_COMMAND(CLASS, NAME, DESCRIPTION) \
-namespace bumbleBee::commands { \
-class CLASS : public ICommand { \
-public: \
-    CLASS (dpp::snowflake botID, std::shared_ptr<MusicPlayManager> manager) \
-    : ICommand(botID, manager) { \
-        name = #NAME; \
-        description = DESCRIPTION; \
-        init(); \
-    } \
-    void execute(const dpp::slashcommand_t &event) override; \
-    \
-protected: \
-    void init() override; \
-}; \
-}
-
-_DECLARE_BUMBLEBEE_COMMAND(Delete,  d,          "큐의 해당하는 번호의 노래를 지웁니다")
-_DECLARE_BUMBLEBEE_COMMAND(Leave,   l,          "음성 채팅방을 떠납니다")
-_DECLARE_BUMBLEBEE_COMMAND(Play,    p,          "노래 재생")
-_DECLARE_BUMBLEBEE_COMMAND(Queue,   q,          "노래 예약 큐를 확인합니다")
-_DECLARE_BUMBLEBEE_COMMAND(Repeat,  r,          "반복을 켜거나 끕니다")
-_DECLARE_BUMBLEBEE_COMMAND(Skip,    s,          "현재 재생중인 곡을 스킵합니다")
-_DECLARE_BUMBLEBEE_COMMAND(Shuffle, shuffle,    "큐를 섞습니다")
--- a/include/Commands/CommandType.hpp
+++ b/include/Commands/CommandType.hpp
@@ -0,0 +1,29 @@
+#pragma once
+#include <dpp/dpp.h>
+#include <vector>
+#include <list>
+#include <MusicQueue.hpp>
+
+namespace commands {
+class ICommand {
+public:
+    //이 생성자를 명시적으로 호출할 것.
+    ICommand(std::shared_ptr<dpp::cluster> botCluster);
+    virtual void operator()(const dpp::slashcommand_t &event) = 0;
+
+    std::vector<dpp::slashcommand> commandObjectVector;
+protected:
+    std::shared_ptr<dpp::cluster> botCluster;
+};
+}
+
+namespace commands {
+class VCCommand : public ICommand {
+public:
+    VCCommand(std::shared_ptr<dpp::cluster> botCluster) : ICommand(botCluster) {}
+
+    std::shared_ptr<MusicQueue> getQueue(const dpp::slashcommand_t& event);
+protected:
+    std::unordered_map<dpp::snowflake, std::shared_ptr<MusicQueue>> *queueMap;
+};
+}
--- a/include/Commands/Commands.hpp
+++ b/include/Commands/Commands.hpp
@@ -0,0 +1,7 @@
+#pragma once
+#include <Commands/Play.hpp>
+#include <Commands/Repeat.hpp>
+#include <Commands/Queue.hpp>
+#include <Commands/Skip.hpp>
+#include <Commands/Leave.hpp>
+#include <Commands/Delete.hpp>
--- a/include/Commands/Delete.hpp
+++ b/include/Commands/Delete.hpp
@@ -0,0 +1,13 @@
+#pragma once
+#include <Commands/CommandType.hpp>
+#include <BumbleCeepp.hpp>
+#include <memory>
+
+namespace commands {
+class Delete : public VCCommand {
+public:
+    Delete(std::shared_ptr<dpp::cluster> botCluster, std::unordered_map<dpp::snowflake, std::shared_ptr<MusicQueue>> *queueMap);
+
+    void operator()(const dpp::slashcommand_t& event);
+};
+}
--- a/include/Commands/Leave.hpp
+++ b/include/Commands/Leave.hpp
@@ -0,0 +1,13 @@
+#pragma once
+#include <Commands/CommandType.hpp>
+#include <BumbleCeepp.hpp>
+#include <memory>
+
+namespace commands {
+class Leave : public VCCommand {
+public:
+    Leave(std::shared_ptr<dpp::cluster> botCluster, std::unordered_map<dpp::snowflake, std::shared_ptr<MusicQueue>> *queueMap);
+
+    void operator()(const dpp::slashcommand_t& event);
+};
+}
--- a/include/Commands/Play.hpp
+++ b/include/Commands/Play.hpp
@@ -0,0 +1,13 @@
+#pragma once
+#include <Commands/CommandType.hpp>
+#include <BumbleCeepp.hpp>
+#include <memory>
+
+namespace commands {
+class Play : public VCCommand {
+public:
+    Play(std::shared_ptr<dpp::cluster> botCluster, std::unordered_map<dpp::snowflake, std::shared_ptr<MusicQueue>> *queueMap);
+
+    void operator()(const dpp::slashcommand_t& event);
+};
+}
--- a/include/Commands/Queue.hpp
+++ b/include/Commands/Queue.hpp
@@ -0,0 +1,13 @@
+#pragma once
+#include <Commands/CommandType.hpp>
+#include <BumbleCeepp.hpp>
+#include <memory>
+
+namespace commands {
+class Queue : public VCCommand {
+public:
+    Queue(std::shared_ptr<dpp::cluster> botCluster, std::unordered_map<dpp::snowflake, std::shared_ptr<MusicQueue>> *queueMap);
+
+    void operator()(const dpp::slashcommand_t& event);
+};
+}
--- a/include/Commands/Repeat.hpp
+++ b/include/Commands/Repeat.hpp
@@ -0,0 +1,13 @@
+#pragma once
+#include <Commands/CommandType.hpp>
+#include <BumbleCeepp.hpp>
+#include <memory>
+
+namespace commands {
+class Repeat : public VCCommand {
+public:
+    Repeat(std::shared_ptr<dpp::cluster> botCluster, std::unordered_map<dpp::snowflake, std::shared_ptr<MusicQueue>> *queueMap);
+
+    void operator()(const dpp::slashcommand_t& event);
+};
+}
--- a/include/Commands/Skip.hpp
+++ b/include/Commands/Skip.hpp
@@ -0,0 +1,13 @@
+#pragma once
+#include <Commands/CommandType.hpp>
+#include <BumbleCeepp.hpp>
+#include <memory>
+
+namespace commands {
+class Skip : public VCCommand {
+public:
+    Skip(std::shared_ptr<dpp::cluster> botCluster, std::unordered_map<dpp::snowflake, std::shared_ptr<MusicQueue>> *queueMap);
+
+    void operator()(const dpp::slashcommand_t& event);
+};
+}
--- a/include/FQueueElement.hpp
+++ b/include/FQueueElement.hpp
@@ -0,0 +1,13 @@
+#pragma once
+#include <string>
+#include <dpp/dpp.h>
+
+struct FQueueElement {
+    std::string URL;
+    std::string title;
+    std::string description;
+    std::string fileName;
+    std::string thumbnail;
+    std::string duration;
+    dpp::embed embed;
+};
--- a/include/MusicQueue.hpp
+++ b/include/MusicQueue.hpp
@@ -0,0 +1,33 @@
+#pragma once
+#include <list>
+#include <FQueueElement.hpp>
+
+struct FMusicQueueID {
+    dpp::snowflake guild_id;
+    uint32_t shard_id;
+};
+
+class MusicQueue {
+public:
+    MusicQueue(FMusicQueueID id, std::shared_ptr<dpp::cluster> botCluster);
+    void operator+=(FQueueElement operand);
+    FQueueElement pop(int index);
+    FQueueElement peek(int index);
+    bool empty();
+    void clear();
+    std::list<struct FQueueElement>::iterator begin();
+    std::list<struct FQueueElement>::iterator end();
+    std::size_t size();
+    FMusicQueueID getId();
+    void play();
+
+    void markerCallback();
+
+    bool repeat;
+private:
+    std::list<struct FQueueElement> queue;
+    std::mutex mutex;
+    std::mutex playMutex;
+    FMusicQueueID id;
+    std::shared_ptr<dpp::cluster> botCluster;
+};
--- a/include/Queue/MusicQueue.hpp
+++ b/include/Queue/MusicQueue.hpp
@@ -1,51 +0,0 @@
-#pragma once
-#include <memory>
-#include <functional>
-#include <condition_variable>
-#include <list>
-#include <dpp/dpp.h>
-#include <Queue/MusicQueueElement.hpp>
-
-namespace bumbleBee {
-
-class MusicQueue {
-public:
-    MusicQueue() {
-        queue = std::list<std::shared_ptr<MusicQueueElement>>();
-        currentPlayingPosition = queue.begin();
-        repeat = true;
-    }
-    void
-        enqueue(std::shared_ptr<MusicQueueElement> Element);
-    std::shared_ptr<MusicQueueElement>
-        dequeue();
-    std::list<std::shared_ptr<MusicQueueElement>>::iterator
-        findById(std::string id);
-    std::list<std::shared_ptr<MusicQueueElement>>::iterator
-        findByIndex(int index);
-    std::shared_ptr<MusicQueueElement>
-        nowplaying();
-    std::list<std::shared_ptr<MusicQueueElement>>::iterator
-        next_music();
-    std::shared_ptr<MusicQueueElement>
-        jump_to_index(int idx);
-    void
-        clear();
-    std::shared_ptr<MusicQueueElement>
-        erase(std::list<std::shared_ptr<MusicQueueElement>>::iterator it);
-    std::pair<std::shared_ptr<std::list<std::shared_ptr<MusicQueueElement>>>, std::list<std::shared_ptr<MusicQueueElement>>::iterator>
-        getQueueCopy();
-    int
-        size();
-    std::list<std::shared_ptr<MusicQueueElement>>::iterator
-        end();
-
-    bool repeat;
-
-    std::list<std::shared_ptr<MusicQueueElement>>::iterator currentPlayingPosition;
-
-private:
-    std::list<std::shared_ptr<MusicQueueElement>> queue;
-    std::mutex queueMutex;
-};
-}
--- a/include/Queue/MusicQueueElement.hpp
+++ b/include/Queue/MusicQueueElement.hpp
@@ -1,20 +0,0 @@
-#pragma once
-#include <dpp/dpp.h>
-
-namespace bumbleBee {
-
-class MusicQueueElement {
-public:
-    MusicQueueElement(
-        std::string id,
-        std::string query,
-        dpp::user issuingUser,
-        dpp::embed embed) :
-        id(id), query(query), issuingUser(issuingUser), embed(embed) {}
-
-    const std::string id;
-    const std::string query;
-    const dpp::user issuingUser;
-    const dpp::embed embed;
-};
-}
--- a/include/Settings/SettingsManager.hpp
+++ b/include/Settings/SettingsManager.hpp
@@ -1,34 +0,0 @@
-#pragma once
-#include <dpp/dpp.h>
-
-#define _DECLARE_DEFAULT_ACCESSER_STATIC_VARIABLE(type, name, Name)\
-private:\
-    static type name;\
-public:\
-    static type get##Name() {return name;}\
-    static void set##Name(const type& value) {name = value; saveToFile();}
-
-namespace bumbleBee {
-/// @brief 모든 설정은 이 객체를 통해 스태틱하게 제공됨.
-class SettingsManager {
-    /// @brief 봇 토큰
-    _DECLARE_DEFAULT_ACCESSER_STATIC_VARIABLE(std::string, TOKEN, TOKEN)
-    /// @brief yt-dlp 실행 명령어
-    _DECLARE_DEFAULT_ACCESSER_STATIC_VARIABLE(std::string, YTDLP_CMD, YTDLP_CMD)
-    /// @brief ffmpeg 실행 명령어
-    _DECLARE_DEFAULT_ACCESSER_STATIC_VARIABLE(std::string, FFMPEG_CMD, FFMPEG_CMD)
-    /// @brief 로그레벨
-    _DECLARE_DEFAULT_ACCESSER_STATIC_VARIABLE(dpp::loglevel, LOGLEVEL, LOGLEVEL)
-    /// @brief 이전에 있던 명령을 지우고 등록할지 선택합니다.
-    _DECLARE_DEFAULT_ACCESSER_STATIC_VARIABLE(bool, REGISTER_COMMAND, REGISTER_COMMAND)
-public:
-    /// @brief 설정 로드하기, 설정은 이 load()를 부르기 전까지는 적절하지 못한 값을 가지고 있음.
-    /// @return 로드 성공 시 true, 실패 시 false 반환.
-    static bool load();
-    /// @brief 설정 변경사항 저장
-    static void saveToFile();
-    /// @brief 토큰이 유효한지 체크합니다.
-    /// @return 유효한 토큰이면 true, 아니면 false를 반환합니다.
-    static bool validateToken();
-};
-}
--- a/include/Utils/AsyncDownloadManager.hpp
+++ b/include/Utils/AsyncDownloadManager.hpp
@@ -1,56 +0,0 @@
-#pragma once
-#include <queue>
-#include <string>
-#include <thread>
-#include <condition_variable>
-#include <dpp/dpp.h>
-#include <Queue/MusicQueue.hpp>
-
-namespace bumbleBee {
-/// @brief 싱글톤 멀티스레딩 다운로드 매니저
-class [[deprecated]] AsyncDownloadManager {
-public:
-    static AsyncDownloadManager& getInstance(int worker_count, std::weak_ptr<dpp::cluster> weak_cluster) {
-        static AsyncDownloadManager dl(worker_count);
-        dl.weak_cluster = weak_cluster;
-        return dl;
-    }
-    void enqueue(std::pair<std::string, dpp::message> query) {
-        std::thread th(&bumbleBee::AsyncDownloadManager::enqueueAsyncDL, this, query);
-        th.detach();
-    }
-    void stop() {
-        auto cluster = weak_cluster.lock();
-        cluster->log(dpp::ll_info, "AsyncDownloadManager stop/destructor called.");
-        terminate = true;
-        dlQueueCondition.notify_all();
-
-        for (auto& t : worker_thread) {
-            t.join();
-        }
-    }
-
-    ~AsyncDownloadManager(){
-        stop();
-    }
-
-private:
-    AsyncDownloadManager(int worker_count){
-        worker_thread.reserve(worker_count);
-        terminate = false;
-        for (int i=0; i<worker_count; i++) {
-            worker_thread.emplace_back([this](){this->downloadWorker();});
-        }
-    }
-    
-    void enqueueAsyncDL(std::pair<std::string, dpp::message> query);
-    void downloadWorker();
-
-    std::queue<std::pair<std::string, dpp::message>> downloadQueue;
-    std::condition_variable dlQueueCondition;
-    std::mutex dlQueueMutex;
-    std::weak_ptr<dpp::cluster> weak_cluster;
-    std::vector<std::thread> worker_thread;
-    bool terminate;
-};
-}
--- a/include/Utils/ConsoleUtils.hpp
+++ b/include/Utils/ConsoleUtils.hpp
@@ -1,36 +0,0 @@
-#pragma once
-#include <iostream>
-#include <sstream>
-#include <queue>
-
-namespace bumbleBee {
-class ConsoleUtils {
-public:
-    /** 
-     * @brief 명령어를 쉘에서 실행하고 결과를 EOF 전까지 읽어 \n을 구분자로 토큰화하여 반환합니다
-     * @param cmd 실행할 명령
-     * @return std::queue<std::string> tokens
-     */
-    static std::queue<std::string> getResultFromCommand(std::string cmd) {
-        std::string result, token;
-        std::queue<std::string> tokens;
-        FILE* stream;
-        const int maxBuffer = 12; // 적당한 크기
-        char buffer[maxBuffer];
-        cmd.append(" 2>&1"); // 표준에러를 표준출력으로 redirect
-
-        stream = popen(cmd.c_str(), "r"); // 주어진 command를 shell로 실행하고 파이프 연결 (fd 반환)
-            if (stream) {
-                while (fgets(buffer, maxBuffer, stream) != NULL) result.append(buffer); // fgets: fd (stream)를 길이 (maxBuffer)만큼 읽어 버퍼 (buffer)에 저장
-                pclose(stream);
-            }
-
-        std::stringstream ss(result);
-        while (std::getline(ss, token, '\n')) {
-            tokens.push(token);
-        }
-
-        return tokens;
-    }
-};
-}
--- a/include/Utils/QueuedMusicListEmbedProvider.hpp
+++ b/include/Utils/QueuedMusicListEmbedProvider.hpp
@@ -1,77 +0,0 @@
-#pragma once
-#include <dpp/dpp.h>
-#include <Queue/MusicQueueElement.hpp>
-#include <cmath>
-
-namespace bumbleBee {
-class QueuedMusicListEmbedProvider {
-public:
-    static std::queue<dpp::embed> makeEmbed(std::shared_ptr<std::list<std::shared_ptr<MusicQueueElement>>> queue, std::list<std::shared_ptr<MusicQueueElement>>::iterator np, bool repeat) {
-        std::queue<dpp::embed> returnValue;
-        std::list<std::shared_ptr<MusicQueueElement>>::iterator it = queue->begin();
-        if (queue->size() == 0) {
-            dpp::embed embed = makeEmbedPart(queue, np, repeat, it);
-            returnValue.push(embed);
-            return returnValue;
-        }
-        for (int i = 0; i < std::ceil(queue->size() / 5.0) && it != queue->end(); i++) {
-            dpp::embed embed = makeEmbedPart(queue, np, repeat, it);
-            returnValue.push(embed);
-        }
-        return returnValue;
-    }
-    
-private:
-    static dpp::embed makeEmbedPart(
-        std::shared_ptr<std::list<std::shared_ptr<MusicQueueElement>>> queue,
-        std::list<std::shared_ptr<MusicQueueElement>>::iterator np,
-        bool repeat,
-        std::list<std::shared_ptr<MusicQueueElement>>::iterator &startIter) {
-        dpp::embed embed = dpp::embed()
-            .set_color(dpp::colors::sti_blue);
-
-        if (queue->begin() == queue->end()) {
-            embed
-                .set_title("큐가 비었습니다!")
-                .set_timestamp(time(0));
-
-            if (repeat)
-                embed.add_field(":repeat:","");
-
-            return embed;
-        }
-
-        int startIndex = std::distance(queue->begin(), startIter) + 1;
-        int index = startIndex;
-
-        for (; (index < startIndex + 5) && startIter != queue->end() && index < queue->size()+1; startIter++, index++) { //iter로 순회하면 왠지 모르게 이상한 값을 읽을 때가 있음 이유는 나도 몰?루
-            if (*startIter == *np)
-                embed.add_field (
-                    "np",
-                    "",
-                    true
-                );
-            else
-                embed.add_field (
-                    std::to_string(index),
-                    "",
-                    true
-                );
-            embed.add_field (
-                (*startIter)->embed.title,
-                (*startIter)->embed.description,
-                true
-            )
-            .add_field("","");
-        }
-
-        if (startIter == queue->end() || index >= queue->size()+1) {
-            embed.set_timestamp(time(0));
-            if (repeat)
-                embed.add_field(":repeat:","");
-        }
-
-        return embed;
-    }
-};
-}
--- a/include/Utils/VersionsCheckUtils.hpp
+++ b/include/Utils/VersionsCheckUtils.hpp
@@ -1,83 +0,0 @@
-#pragma once
-#include <dpp/dpp.h>
-#include "ConsoleUtils.hpp"
-#include "../Settings/SettingsManager.hpp"
-
-namespace bumbleBee {
-class VersionsCheckUtils {
-public:
-    static bool isThereCMD(std::shared_ptr<dpp::cluster> cluster, std::string cmd) {
-        if (ConsoleUtils::getResultFromCommand("which " + cmd).size() == 0) {
-            cluster->log(dpp::ll_error, cmd + " is unavaliable. unresolable error please install " + cmd);
-            return false;
-        }
-        else
-            return true;
-    }
-
-    static void validateFFMPEG(std::shared_ptr<dpp::cluster> cluster) {
-        std::queue<std::string> result = ConsoleUtils::getResultFromCommand(SettingsManager::getFFMPEG_CMD() + " -version");
-        std::string front = result.front();
-        if (front[0] != 'f' ||
-            front[1] != 'f' ||
-            front[2] != 'm' ||
-            front[3] != 'p' ||
-            front[4] != 'e' ||
-            front[5] != 'g') {
-            cluster->log(dpp::ll_warning, "ffmpeg is unavailable. downloading ffmpeg...");
-
-            if (!isThereCMD(cluster, "curl")) {
-                exit(1);
-            }
-            if (!isThereCMD(cluster, "tar")) {
-                exit(1);
-            }
-
-            system("curl -LO https://github.com/BtbN/FFmpeg-Builds/releases/latest/download/ffmpeg-master-latest-linux64-gpl.tar.xz");
-            system("tar -xf ffmpeg-master-latest-linux64-gpl.tar.xz");
-            system("rm ffmpeg-master-latest-linux64-gpl.tar.xz");
-            system("mv ffmpeg-master-latest-linux64-gpl/bin/ffmpeg .");
-            system("rm -rf ffmpeg-master-latest-linux64-gpl");
-            SettingsManager::setFFMPEG_CMD("./ffmpeg");
-        }
-    }
-
-    static void validateYTDLP(std::shared_ptr<dpp::cluster> cluster) {
-        std::queue<std::string> result = ConsoleUtils::getResultFromCommand(SettingsManager::getYTDLP_CMD() + " --version");
-        std::string front = result.front();
-        if ((front[0]-'0' < 0 || front[0]-'0' > 9) ||
-            (front[1]-'0' < 0 || front[1]-'0' > 9) ||
-            (front[2]-'0' < 0 || front[2]-'0' > 9) ||
-            (front[3]-'0' < 0 || front[3]-'0' > 9)) {
-            cluster->log(dpp::ll_warning, "ytdlp is unavailable. downloading ytdlp...");
-
-            if (!isThereCMD(cluster, "curl")) {
-                exit(1);
-            }
-            if (!isThereCMD(cluster, "tar")) {
-                exit(1);
-            }
-
-            system("curl -LO https://github.com/yt-dlp/yt-dlp/releases/latest/download/yt-dlp");
-            system("chmod +x ./yt-dlp");
-            SettingsManager::setYTDLP_CMD("./yt-dlp");
-        }
-    }
-
-    static void validateYTDLPFFMPEGBinary(std::shared_ptr<dpp::cluster> cluster) {
-        cluster->log(dpp::ll_info, "Checking if yt-dlp and ffmpeg is available...");
-        validateFFMPEG(cluster);
-        validateYTDLP(cluster);
-    }
-
-    static void updateytdlp(std::shared_ptr<dpp::cluster> cluster) {
-        cluster->log(dpp::ll_info, "Checking if yt-dlp update is available...");
-        std::queue<std::string> result = ConsoleUtils::getResultFromCommand("./yt-dlp -U");
-        while(!result.empty()) {
-            std::string front = result.front();
-            result.pop();
-            cluster->log(dpp::ll_info, front);
-        }
-    }
-};
-}
--- a/src/Audio/MusicPlayManager.cpp
+++ b/src/Audio/MusicPlayManager.cpp
@@ -1,138 +0,0 @@
-#include <Audio/MusicPlayManager.hpp>
-#include <ogg/ogg.h>
-#include <oggz/oggz.h>
-#include <algorithm>
-#include <Settings/SettingsManager.hpp>
-
-namespace bumbleBee {
-
-void MusicPlayManager::on_voice_ready(const dpp::voice_ready_t& event) {
-    play(event.voice_client);
-}
-
-void MusicPlayManager::on_voice_track_marker(const dpp::voice_track_marker_t& event) {
-    dpp::snowflake gid = dpp::find_channel(event.voice_client->channel_id)->guild_id;
-    queueMap[gid]->next_music();
-    play(event.voice_client);
-}
-
-void MusicPlayManager::on_voice_client_disconnect(const dpp::voice_client_disconnect_t& event) { // 이거 봇이 나갈 때가 아니고 같이 있는 유저가 나갈 때였고
-    // dpp::snowflake gid = dpp::find_channel(event.voice_client->channel_id)->guild_id;
-    // event.voice_client->stop_audio();
-    // queueMap[gid]->clear();
-}
-
-void MusicPlayManager::play(dpp::discord_voice_client* client) {
-    std::thread t([&](dpp::discord_voice_client* client){
-        dpp::snowflake gid = dpp::find_channel(client->channel_id)->guild_id;
-        std::unique_lock<std::mutex> queueEmptyLock(*queueEmptyMutex[gid]);
-
-        queuedCondition.wait(queueEmptyLock, [&]{
-            return queueMap[gid]->size() != 0 && queueMap[gid]->currentPlayingPosition != queueMap[gid]->end();
-        });
-
-        auto next = queueMap[gid]->currentPlayingPosition;
-        send_audio_to_voice(*next, client);
-    }, client);
-    t.detach();
-}
-
-void MusicPlayManager::queue_music(const dpp::snowflake guildId, const std::shared_ptr<MusicQueueElement> music) {
-    queueMap[guildId]->enqueue(music);
-}
-
-void MusicPlayManager::clear(const dpp::snowflake guildId) {
-    queueMap[guildId]->clear();
-}
-std::shared_ptr<MusicQueueElement> MusicPlayManager::remove(const dpp::snowflake guildId, dpp::discord_voice_client* client, int index) {
-    auto queue = queueMap[guildId];
-    auto foundIterator = queue->findByIndex(index);
-
-    if (queue->currentPlayingPosition == foundIterator) {
-        auto removed = queue->erase(queue->findByIndex(0));
-        if (client == nullptr)
-            return removed;
-        client->pause_audio(true);
-        client->stop_audio();
-        client->pause_audio(false);
-        client->insert_marker("end");
-        return removed;
-    }
-
-    return queue->erase(queue->findByIndex(index));
-}
-int MusicPlayManager::size(const dpp::snowflake guildId) {
-    return queueMap[guildId]->size();
-}
-void MusicPlayManager::setRepeat(const dpp::snowflake guildId, const bool value) {
-    queueMap[guildId]->repeat = value;
-}
-
-bool MusicPlayManager::getRepeat(const dpp::snowflake guildId) {
-    return queueMap[guildId]->repeat;
-}
-
-std::pair<std::shared_ptr<std::list<std::shared_ptr<MusicQueueElement>>>, std::list<std::shared_ptr<MusicQueueElement>>::iterator>
-    MusicPlayManager::getQueue(const dpp::snowflake guildId){
-    auto returnValue = queueMap[guildId]->getQueueCopy();
-    return returnValue;
-}
-
-MusicQueueElement MusicPlayManager::getNowPlaying(const dpp::snowflake guildId) {
-    std::shared_ptr<MusicQueueElement> nowplaying = queueMap[guildId]->nowplaying();
-    if (nowplaying == nullptr)
-        return MusicQueueElement("", "", dpp::user(), dpp::embed());
-    MusicQueueElement returnValue(*nowplaying);
-    return returnValue;
-}
-
-void MusicPlayManager::send_audio_to_voice(std::shared_ptr<bumbleBee::MusicQueueElement> music, dpp::discord_voice_client* client) {
-    std::thread t([](std::shared_ptr<bumbleBee::MusicQueueElement> music, dpp::discord_voice_client* client) {
-        std::string command = "./streamOpus.sh ";
-        command += SettingsManager::getYTDLP_CMD() + " ";
-        command += SettingsManager::getFFMPEG_CMD() + " ";
-        command += "https://youtu.be/";
-        command += music->id;
-
-        OGGZ* og = oggz_open_stdio(popen(command.c_str(), "r"), OGGZ_READ);
-
-        // client->stop_audio(); //이거 필요함??
-
-        oggz_set_read_callback(
-            og, -1,
-            [](OGGZ *oggz, oggz_packet *packet, long serialno, void *user_data) {
-                auto voiceConn = (dpp::discord_voice_client *)user_data;
-
-                voiceConn->send_audio_opus(packet->op.packet, packet->op.bytes);
-
-                return 0;
-            },
-            (void *)client
-        );
-
-        while (client && !client->terminating && music != nullptr) {
-            static const constexpr long CHUNK_READ = BUFSIZ * 2;
-
-            const long read_bytes = oggz_read(og, CHUNK_READ);
-
-            /* break on eof */
-            if (!read_bytes) {
-                break;
-            }
-        }
-
-        if (music != nullptr)
-            client->creator->log(dpp::ll_info, "Sending " + music->embed.title + " - " + music->id + " complete!");
-        else {
-            client->stop_audio();
-            client->pause_audio(true);
-        }
-
-        oggz_close(og);
-
-        client->insert_marker();
-    }, music, client);
-    t.detach();
-}
-}
-
--- a/src/Bot.cpp
+++ b/src/Bot.cpp
@@ -0,0 +1,42 @@
+#include <Bot.hpp>
+#include <Commands/CommandType.hpp>
+
+IBot::IBot(std::string token, int totalShard)
+{
+    botCluster = std::make_shared<dpp::cluster>(token, dpp::i_default_intents, totalShard);
+    botCluster->on_log(dpp::utility::cout_logger());
+
+    botCluster->on_slashcommand([this](const dpp::slashcommand_t& event){onCommand(event);});
+    botCluster->on_ready([this](const dpp::ready_t &event){onReady(event);});
+}
+
+void IBot::onCommand(const dpp::slashcommand_t &event)
+{
+    auto _event = event;
+    for (int i = 0; i < commandsArray.size(); i++) {
+        for (auto alias : commandsArray[i]->commandObjectVector) {
+            if (event.command.get_command_name() == alias.name) {
+                (*commandsArray[i])(_event);
+            }
+        }
+    }
+}
+
+void IBot::onReady(const dpp::ready_t &event)
+{
+    if (!dpp::run_once<struct register_bot_commands>())
+        return;
+
+    //BotCluster->global_bulk_command_delete();
+
+    for (int i = 0; i < commandsArray.size(); i++) {
+        for (auto Alias : commandsArray[i]->commandObjectVector) {
+            botCluster->global_command_create(Alias);
+        }
+    }
+}
+
+void IBot::start()
+{
+    botCluster->start(dpp::st_wait);
+}
--- a/src/BumbleBee.cpp
+++ b/src/BumbleBee.cpp
@@ -1,80 +0,0 @@
-#include <BumbleBee.hpp>
-#include <memory>
-#include <Settings/SettingsManager.hpp>
-#include <Utils/VersionsCheckUtils.hpp>
-#include <Audio/MusicPlayManager.hpp>
-#include <Commands/BumbleBeeCommand.hpp>
-
-namespace bumbleBee{
-BumbleBee::BumbleBee() {
-    if (!SettingsManager::load()) {
-        std::cout << "Please configure confing.json" << std::endl;
-        exit(1);
-    }
-
-    cluster = std::make_shared<dpp::cluster>(SettingsManager::getTOKEN());
-
-    cluster->on_log([](const dpp::log_t& event) {
-		if (event.severity >= SettingsManager::getLOGLEVEL()) {
-			std::cout << "[" << dpp::utility::current_date_time() << "] " << dpp::utility::loglevel(event.severity) << ": " << event.message << std::endl;
-		}
-	});
-    cluster->on_slashcommand([this](const dpp::slashcommand_t& event){on_slashcommand(event);});
-    cluster->on_ready([this](const dpp::ready_t &event){on_ready(event);});
-
-    VersionsCheckUtils::validateYTDLPFFMPEGBinary(cluster);
-    VersionsCheckUtils::updateytdlp(cluster);
-}
-
-void BumbleBee::start() { this->cluster->start(dpp::st_wait); }
-
-void BumbleBee::on_slashcommand(const dpp::slashcommand_t &event) {
-    if (commands.find(event.command.get_command_name()) != commands.end()) {
-        event.thinking();
-        auto command = commands.at(event.command.get_command_name());
-        std::thread t([](const dpp::slashcommand_t &event, std::shared_ptr<commands::ICommand> command){
-            command->execute(event);
-        }, event, command);
-        t.detach();
-    }
-}
-
-void BumbleBee::on_ready(const dpp::ready_t &event) {
-    GIDs = event.guilds;
-    musicManager = std::make_shared<MusicPlayManager>(cluster, GIDs);
-
-    commands["d"]       = std::make_shared<commands::Delete>  (cluster->cluster_id, musicManager);
-    commands["l"]       = std::make_shared<commands::Leave>   (cluster->cluster_id, musicManager);
-    commands["p"]       = std::make_shared<commands::Play>    (cluster->cluster_id, musicManager);
-    commands["q"]       = std::make_shared<commands::Queue>   (cluster->cluster_id, musicManager);
-    commands["r"]       = std::make_shared<commands::Repeat>  (cluster->cluster_id, musicManager);
-    commands["s"]       = std::make_shared<commands::Skip>    (cluster->cluster_id, musicManager);
-    commands["shuffle"] = std::make_shared<commands::Shuffle> (cluster->cluster_id, musicManager);
-    
-    if (event.guilds.size() == 0) {
-        cluster->log(dpp::loglevel::ll_info, "Bot is not on any server! Please invite this bot to any server.");
-        exit(1);
-    }
-    
-    if (dpp::run_once<struct register_bot_commands>()) {
-        if (SettingsManager::getREGISTER_COMMAND()) {
-            cluster->log(dpp::loglevel::ll_info, "Clear Pre-installed commands");
-
-            cluster->global_bulk_command_create({
-                *commands["d"],
-                *commands["l"],
-                *commands["p"],
-                *commands["q"],
-                *commands["r"],
-                *commands["s"],
-                *commands["shuffle"]
-            }, [&](const dpp::confirmation_callback_t &t){
-                cluster->log(dpp::loglevel::ll_info, "Command created.");
-                SettingsManager::setREGISTER_COMMAND(false);
-            });
-        }
-    }
-
-    cluster->log(dpp::loglevel::ll_info, "Bot ready.");
-}
-}
--- a/src/BumbleCeepp.cpp
+++ b/src/BumbleCeepp.cpp
@@ -0,0 +1,17 @@
+#include "BumbleCeepp.hpp"
+#include <string>
+#include <FQueueElement.hpp>
+#include <Commands/Commands.hpp>
+
+BumbleCeepp::BumbleCeepp(std::string token, int totalShard)
+    : IBot(token, totalShard)
+{
+    commandsArray.push_back(std::make_shared<commands::Play>(botCluster, &queueMap));
+    commandsArray.push_back(std::make_shared<commands::Repeat>(botCluster, &queueMap));
+    commandsArray.push_back(std::make_shared<commands::Queue>(botCluster, &queueMap));
+    commandsArray.push_back(std::make_shared<commands::Skip>(botCluster, &queueMap));
+    commandsArray.push_back(std::make_shared<commands::Leave>(botCluster, &queueMap));
+    commandsArray.push_back(std::make_shared<commands::Delete>(botCluster, &queueMap));
+
+    std::cout << "Command added.\n";
+}
--- a/src/Commands/CommandType.cpp
+++ b/src/Commands/CommandType.cpp
@@ -0,0 +1,19 @@
+#include <Commands/CommandType.hpp>
+
+commands::ICommand::ICommand(std::shared_ptr<dpp::cluster> botCluster)
+{
+    this->botCluster = botCluster;
+}
+
+std::shared_ptr<MusicQueue> commands::VCCommand::getQueue(const dpp::slashcommand_t& event) {
+    auto findResult = queueMap->find(event.command.guild_id);
+    if (findResult == queueMap->end())
+    {
+        FMusicQueueID queueID;
+        queueID.guild_id = event.command.guild_id;
+        queueID.shard_id = event.from->shard_id;
+
+        (*queueMap)[queueID.guild_id] = std::make_shared<MusicQueue>(queueID, botCluster);
+    }
+    return queueMap->find(event.command.guild_id)->second;
+}
--- a/src/Commands/Delete.cpp
+++ b/src/Commands/Delete.cpp
@@ -1,32 +1,62 @@
-#include <Commands/BumbleBeeCommand.hpp>
-#include <format>
+#include <Commands/Delete.hpp>
+#include <iostream>

-namespace bumbleBee::commands {
-    void Delete::execute(const dpp::slashcommand_t &event) {
-        int pos = std::get<std::int64_t>(event.get_parameter("pos"));
+commands::Delete::Delete(std::shared_ptr<dpp::cluster> botCluster, std::unordered_map<dpp::snowflake, std::shared_ptr<MusicQueue>> *queueMap)
+    : VCCommand(botCluster)
+{
+    this->queueMap = queueMap;
+    dpp::slashcommand Command = dpp::slashcommand("d", "큐의 해당하는 번호의 노래를 지웁니다", botCluster->me.id);

-        if (pos < 0 || pos > musicManager->size(event.command.guild_id))
-        {
-            event.edit_original_response(dpp::message(std::string("이상한 인덱스 위치. Pos :") + std::to_string(pos)));
+    Command.add_option(
+        dpp::command_option(dpp::co_string, "pos", "큐 번호", botCluster->me.id)
+    );
+
+    commandObjectVector.push_back(Command);
+}
+
+void commands::Delete::operator()(const dpp::slashcommand_t& event)
+{
+    if (std::holds_alternative<std::monostate>(event.get_parameter("pos"))) {
+        event.reply("삭제할 노래의 인덱스가 정확하지 않습니다.");
+        return;
+    }
+    std::string Pos = std::get<std::string>(event.get_parameter("pos"));
+    event.thinking();
+
+    std::shared_ptr<MusicQueue> queue = getQueue(event);
+
+    auto index = atoi(Pos.c_str());
+
+    int queueSize = queue->size();
+
+    std::cout << "queue size : " << queueSize << "\n";
+
+    if (index < 0 || (queueSize - 1) < index) {
+        std::cout << "invalid index : " << index << ", " + Pos + "\n";
+
+        event.edit_original_response(dpp::message(event.command.channel_id, "이상한 인덱스 위치. Pos : " + Pos));
+        return;
+    }
+
+    auto PopedElement = queue->pop(index);
+
+    dpp::embed embed = PopedElement.embed
+        .set_timestamp(time(0));
+
+    dpp::message msg(event.command.channel_id, "다음 항목을 큐에서 삭제했습니다!:");
+
+    if (atoi(Pos.c_str()) == 0) {
+        dpp::voiceconn* v = event.from->get_voice(event.command.guild_id);
+
+        if (!v || !v->voiceclient || !v->voiceclient->is_ready()) {
            return;
        }

-        dpp::voiceconn* v = event.from->get_voice(event.command.guild_id);
-
-        std::shared_ptr<MusicQueueElement> removed;
-        
-        if (!v) // v-> 로 nullptr을 참조하면 안 되므로.
-            removed = musicManager->remove(event.command.guild_id, nullptr, pos);
-        else
-            removed = musicManager->remove(event.command.guild_id, v->voiceclient, pos);
-
-        dpp::message msg("다음 항목을 큐에서 삭제했습니다!:");
-        msg.add_embed(removed->embed);
-
-        event.edit_original_response(msg);
+        v->voiceclient->stop_audio();
+        v->voiceclient->insert_marker("end of music");
    }
+    
+    msg.add_embed(embed);

-    void Delete::init() {
-        add_option(dpp::command_option(dpp::co_integer, "pos", "지울 위치(위치는 1부터 시작, 현재 재생곡은 0)", true));
-    }
+    event.edit_original_response(msg);
 }
--- a/src/Commands/Leave.cpp
+++ b/src/Commands/Leave.cpp
@@ -1,23 +1,30 @@
-#include <Commands/BumbleBeeCommand.hpp>
+#include <Commands/Leave.hpp>
+#include <iostream>

-namespace bumbleBee::commands {
-    void Leave::execute(const dpp::slashcommand_t &event) {
-        dpp::voiceconn* v = event.from->get_voice(event.command.guild_id);
+commands::Leave::Leave(std::shared_ptr<dpp::cluster> botCluster, std::unordered_map<dpp::snowflake, std::shared_ptr<MusicQueue>> *queueMap)
+    : VCCommand(botCluster)
+{
+    this->queueMap = queueMap;
+    dpp::slashcommand command = dpp::slashcommand("l", "음챗을 떠납니다", botCluster->me.id);

-        if (!v || !v->voiceclient || !v->voiceclient->is_ready()) {
-            event.edit_original_response(dpp::message("현재 음성 채팅방에 있는 상태가 아닙니다!"));
-            return;
-        }
-        musicManager->clear(event.command.guild_id);
-        
-        v->voiceclient->stop_audio();
-        v->voiceclient->pause_audio(true);
-        event.from->clear_queue();
-        event.from->disconnect_voice(event.command.guild_id);
+    commandObjectVector.push_back(command);
+}

-        event.edit_original_response(dpp::message("음성 채팅방을 떠납니다!"));
+void commands::Leave::operator()(const dpp::slashcommand_t& event)
+{
+    dpp::voiceconn* v = event.from->get_voice(event.command.guild_id);
+
+    if (!v || !v->voiceclient || !v->voiceclient->is_ready()) {
+        return;
    }
+    v->voiceclient->stop_audio();

-    void Leave::init() {
-    }
+    std::shared_ptr<MusicQueue> queue = getQueue(event);
+
+    queue->clear();
+    event.from->disconnect_voice(event.command.guild_id);
+
+    dpp::message msg(event.command.channel_id, "음성 채팅방을 떠납니다!");
+
+    event.reply(msg);
 }
--- a/src/Commands/Play.cpp
+++ b/src/Commands/Play.cpp
@@ -1,233 +1,126 @@
-#include <Commands/BumbleBeeCommand.hpp>
-#include <Utils/ConsoleUtils.hpp>
-#include <Settings/SettingsManager.hpp>
+#include <Commands/Play.hpp>
+#include <dpp/dpp.h>
 #include <dpp/nlohmann/json.hpp>
-#include <Utils/QueuedMusicListEmbedProvider.hpp>
-#include <variant>
+#include <string>
+#include <filesystem>
+#include <ctime>

-namespace bumbleBee::commands {
-    void Play::execute(const dpp::slashcommand_t &event) {
-        dpp::guild *g = dpp::find_guild(event.command.guild_id);
+using json = nlohmann::json;

-        if (!g) { //wtf?
-            event.edit_original_response(dpp::message("GUILD NOT FOUND!! WHAT IS THIS SORCERY??"));
-            return;
-        }
-        if (std::holds_alternative<std::monostate>(event.get_parameter("query"))) // 이거 필요한가???
+commands::Play::Play(std::shared_ptr<dpp::cluster> botCluster, std::unordered_map<dpp::snowflake, std::shared_ptr<MusicQueue>> *queueMap)
+    : VCCommand(botCluster)
+{
+    this->queueMap = queueMap;
+    dpp::slashcommand command = dpp::slashcommand("p", "노래 재생", botCluster->me.id);
+
+    command.add_option(
+        dpp::command_option(dpp::co_string, "query", "링크 또는 검색어", botCluster->me.id)
+    );
+
+    commandObjectVector.push_back(command);
+}
+
+void commands::Play::operator()(const dpp::slashcommand_t& event)
+{
+    if (std::holds_alternative<std::monostate>(event.get_parameter("query")))
+    {
+        event.reply("노래를 재생하려면 검색어 또는 링크를 입력해 주십시오.");
+        return;
+    }
+
+    /* Attempt to connect to a voice channel, returns false if we fail to connect. */
+    if (!event.from->get_voice(event.command.guild_id))
+    {
+        if (!dpp::find_guild(event.command.guild_id)->connect_member_voice(event.command.get_issuing_user().id))
        {
-            event.reply("노래를 재생하려면 검색어 또는 링크를 입력해 주십시오.");
-            return;
+            return event.reply("노래를 재생할 음성 채팅방에 먼저 참가하고 신청해야 합니다!");
        }
-        if (!event.from->get_voice(event.command.guild_id) && !g->connect_member_voice(event.command.usr.id)) {
-            event.edit_original_response(dpp::message("노래를 재생할 음성 채팅방에 먼저 참가하고 신청해야 합니다!"));
-            return;
-        }
-        std::string query = std::get<std::string>(event.get_parameter("query"));
-        query = "\"" + query + "\"";
+    }

-        std::queue<std::string> ids =
-            ConsoleUtils::getResultFromCommand(
-            SettingsManager::getYTDLP_CMD() +
-            " --default-search ytsearch --flat-playlist --skip-download --quiet --ignore-errors --print id " + query);
+    std::string Query = std::get<std::string>(event.get_parameter("query"));

-        std::queue<std::shared_ptr<MusicQueueElement>> musics;
+    event.thinking();

-        int initialQueuedCount = musicManager->size(event.command.guild_id);
+    std::shared_ptr<MusicQueue> queue = getQueue(event);

-        dpp::message msg;
+    std::cout << "다운로드 시작" << "\n";
+    std::system(("python3 yt-download.py \"" + Query + "\" & wait").c_str());
+    std::cout << "다운로드 완료" << "\n";

-        if (musicManager->size(event.command.guild_id) == 0)
-            msg.content = "다음 곡을 재생합니다:";
-        else
-            msg.content = "큐에 다음 곡을 추가했습니다:";
+    dpp::message msg(event.command.channel_id, "큐에 다음 곡을 추가했습니다:");

-        if (!ids.empty()) {
-            if (ids.front() == "") {
-                ids.pop();
-            }
+    std::ifstream infofile, idfile;
+    json document;
+    std::string ID;
+    std::queue<FQueueElement> RequestedMusic;
+    idfile.open("Temp/CurMusic");
+    while (std::getline(idfile, ID))
+    {
+        std::cout << ID << "\n";
+        infofile.open("Music/" + ID + ".info.json");
+        infofile >> document;
+        infofile.close();

-            FILE* file = popen((SettingsManager::getYTDLP_CMD() +
-                " --default-search ytsearch --flat-playlist --skip-download --quiet --ignore-errors -J http://youtu.be/" + ids.front()).c_str(), "r");
-        
-            std::ostringstream oss;
-            char buffer[1024];
-            size_t bytesRead;
-            
-            while ((bytesRead = fread(buffer, 1, sizeof(buffer), file)) > 0) {
-                oss.write(buffer, bytesRead);
-            }
-            pclose(file);
+        time_t SongLength = int(document["duration"]);
+        char SongLengthStr[10];
+        tm t;
+        t.tm_mday = SongLength / 86400;
+        t.tm_hour = (SongLength % 86400)/3600;
+        t.tm_min = (SongLength % 3600)/60;
+        t.tm_sec = SongLength%60;
+        strftime(SongLengthStr, sizeof(SongLengthStr), "%X", &t);

-            std::istringstream iss(oss.str());
-            nlohmann::json videoDataJson;
-            iss >> videoDataJson;
-
-            time_t SongLength = int(videoDataJson["duration"]);
-            char SongLengthStr[13];
-            tm t;
-            t.tm_mday = SongLength / 86400;
-            t.tm_hour = (SongLength % 86400)/3600;
-            t.tm_min = (SongLength % 3600)/60;
-            t.tm_sec = SongLength%60;
-            if (t.tm_mday > 0)
-                strftime(SongLengthStr, sizeof(SongLengthStr), "%d:%H:%M:%S", &t);
-            else if (t.tm_hour > 0)
-                strftime(SongLengthStr, sizeof(SongLengthStr), "%H:%M:%S", &t);
-            else
-                strftime(SongLengthStr, sizeof(SongLengthStr), "%M:%S", &t);
-
-            dpp::embed embed = dpp::embed()
+        FQueueElement Data = {
+            std::string(document["webpage_url"]),
+            std::string(document["title"]),
+            std::string(document["uploader"]),
+            std::string(document["id"]),
+            std::string(document["thumbnail"]),
+            to_string(document["duration"]),
+            dpp::embed()
                .set_color(dpp::colors::sti_blue)
-                .set_title(std::string(videoDataJson["title"]))
-                .set_description(std::string(videoDataJson["uploader"]))
-                .set_url(std::string(videoDataJson["webpage_url"]))
-                .set_image(std::string(videoDataJson["thumbnail"]))
+                .set_title(Data.title)
+                .set_description(Data.description)
+                .set_url(Data.URL)
+                .set_image(Data.thumbnail)
                .add_field(
                    "길이",
                    SongLengthStr,
                    true
-                );
+                )
+        };

-            musics.push(std::make_shared<MusicQueueElement>(ids.front(), query, event.command.usr, embed));
-            ids.pop();
-        }
+        (*queue) += Data;

-        if (!ids.empty()) {
-            std::thread t([](
-                std::queue<std::string> ids,
-                dpp::snowflake guildId,
-                dpp::snowflake channelId,
-                std::string query,
-                dpp::user user,
-                dpp::cluster* cluster,
-                std::shared_ptr<MusicPlayManager> manager
-                ) {
-                    while (!ids.empty()) {
-                        if (ids.front() == "") {
-                            ids.pop();
-                            continue;
-                        }
+        RequestedMusic.push(Data);
+    }
+    idfile.close();
+    std::system("rm -f Temp/CurMusic");
+    std::cout << "queued\n";

-                        FILE* file = popen((SettingsManager::getYTDLP_CMD() +
-                            " --default-search ytsearch --flat-playlist --skip-download --quiet --ignore-errors -J http://youtu.be/" + ids.front()).c_str(), "r");
-                    
-                        std::ostringstream oss;
-                        char buffer[1024];
-                        size_t bytesRead;
-                        
-                        while ((bytesRead = fread(buffer, 1, sizeof(buffer), file)) > 0) {
-                            oss.write(buffer, bytesRead);
-                        }
-                        pclose(file);
+    msg.add_embed(RequestedMusic.front().embed);
+    RequestedMusic.pop();
+    event.edit_original_response(msg);

-                        std::istringstream iss(oss.str());
-                        nlohmann::json videoDataJson;
-                        iss >> videoDataJson;
+    while (!RequestedMusic.empty())
+    {
+        dpp::message followMsg(event.command.channel_id, "");

-                        time_t SongLength = int(videoDataJson["duration"]);
-                        char SongLengthStr[13];
-                        tm t;
-                        t.tm_mday = SongLength / 86400;
-                        t.tm_hour = (SongLength % 86400)/3600;
-                        t.tm_min = (SongLength % 3600)/60;
-                        t.tm_sec = SongLength%60;
-                        if (t.tm_mday > 0)
-                            strftime(SongLengthStr, sizeof(SongLengthStr), "%d:%H:%M:%S", &t);
-                        else if (t.tm_hour > 0)
-                            strftime(SongLengthStr, sizeof(SongLengthStr), "%H:%M:%S", &t);
-                        else
-                            strftime(SongLengthStr, sizeof(SongLengthStr), "%M:%S", &t);
+        followMsg.add_embed(RequestedMusic.front().embed);
+        RequestedMusic.pop();

-                        dpp::embed embed = dpp::embed()
-                            .set_color(dpp::colors::sti_blue)
-                            .set_title(std::string(videoDataJson["title"]))
-                            .set_description(std::string(videoDataJson["uploader"]))
-                            .set_url(std::string(videoDataJson["webpage_url"]))
-                            .set_image(std::string(videoDataJson["thumbnail"]))
-                            .add_field(
-                                "길이",
-                                SongLengthStr,
-                                true
-                            );
+        botCluster->message_create(followMsg);
+    }
+    std::cout << "replied\n";

-                        auto music = std::make_shared<MusicQueueElement>(ids.front(), query, user, embed);
+    dpp::voiceconn* v = event.from->get_voice(event.command.guild_id);

-                        cluster->log(dpp::ll_info, "Enqueuing " + music->embed.title + " - " + music->id);
-                        manager->queue_music(guildId, music);
-                        ids.pop();
-                    }
-
-                    std::mutex messageorder;
-                    std::unique_lock lock(messageorder);
-                    std::condition_variable messageSentCondition;                   // 개씨발 코드 개더러워 ;;
-                    bool messagesent = false;
-                    auto queue = manager->getQueue(guildId);
-                    auto queued = QueuedMusicListEmbedProvider::makeEmbed(queue.first, queue.second, manager->getRepeat(guildId));
-                    if (!queued.empty()) {
-                        dpp::message followMsg(channelId, "현재 큐에 있는 항목:");
-
-                        followMsg.add_embed(queued.front());
-                        messagesent = false;
-                        cluster->message_create(followMsg, [&](const dpp::confirmation_callback_t &callback){
-                            messagesent = true;
-                            messageSentCondition.notify_all();
-                        });
-
-                        messageSentCondition.wait(lock, [&](){ return messagesent; });
-                        queued.pop();
-                    }
-                    while (!queued.empty()) {
-                        dpp::message followMsg(channelId, "");
-
-                        followMsg.add_embed(queued.front());
-                        messagesent = false;
-                        cluster->message_create(followMsg, [&](const dpp::confirmation_callback_t &callback){
-                            messagesent = true;
-                            messageSentCondition.notify_all();
-                        });
-
-                        messageSentCondition.wait(lock, [&](){ return messagesent; });
-                        queued.pop();
-                    }
-                },
-                ids,
-                event.command.guild_id,
-                event.command.channel_id,
-                query,
-                event.command.usr,
-                event.from->creator,
-                musicManager);
-
-            t.detach();
-        }
-        
-        if (!musics.empty()) {
-            event.from->creator->log(dpp::ll_info, "Enqueuing " + musics.front()->embed.title + " - " + musics.front()->id);
-            musicManager->queue_music(event.command.guild_id, musics.front());
-            msg.add_embed(musics.front()->embed);
-            musics.pop();
-
-            event.edit_original_response(msg);
-            musicManager->queuedCondition.notify_all();
-        }
-        else {
-            msg.content = "검색 결과가 없습니다";
-            event.edit_original_response(msg);
-        }
-
-        if (musicManager->getNowPlaying(event.command.guild_id).id == "") {
-            dpp::voiceconn* v = event.from->get_voice(event.command.guild_id);
-
-            if (!v || !v->voiceclient || !v->voiceclient->is_ready()) {
-                event.edit_original_response(dpp::message("현재 음성 채팅방에 있는 상태가 아닙니다!"));
-                return;
-            }
-            v->voiceclient->insert_marker();
-            v->voiceclient->pause_audio(false);
-        }
+    /* If the voice channel was invalid, or there is an issue with it, then tell the user. */
+    if (v && v->voiceclient && v->voiceclient->is_ready())
+    {
+        queue->play();
    }

-    void Play::init() {
-        add_option(dpp::command_option(dpp::co_string, "query", "링크 또는 검색어", true));
-    }
+    botCluster->on_voice_ready([this, queue](const dpp::voice_ready_t& Voice){ queue->play(); });
+    return;
 }
--- a/src/Commands/Queue.cpp
+++ b/src/Commands/Queue.cpp
@@ -1,73 +1,97 @@
-#include <Commands/BumbleBeeCommand.hpp>
-#include <Utils/QueuedMusicListEmbedProvider.hpp>
+#include <Commands/Queue.hpp>
+#include <iostream>
+#include <sstream>
+#include <cmath>

-namespace bumbleBee::commands {
-    void Queue::execute(const dpp::slashcommand_t &event) {
-        auto queue = musicManager->getQueue(event.command.guild_id);
+namespace commands {
+dpp::embed makeEmbed(std::list<FQueueElement>::iterator& iter, std::list<FQueueElement>::iterator end, bool Repeat = false, int Index = 0)
+{
+    dpp::embed embed = dpp::embed()
+        .set_color(dpp::colors::sti_blue);

-        dpp::message msg;
-        dpp::embed embed;
+    if (iter == end) {
+        embed
+            .set_title("큐가 비었습니다!")
+            .set_timestamp(time(0));

-        auto queued = QueuedMusicListEmbedProvider::makeEmbed(queue.first, queue.second, musicManager->getRepeat(event.command.guild_id));
+        if (Repeat)
+            embed.add_field(":repeat:","");

-        // if (queue.first.size() == 0) {
-        //     msg.add_embed(queued.front());
-        //     event.edit_original_response(msg);
-        //     return;
-        // }
-
-        //  &&
-        // queue.first.size() != 0 &&
-        // *queue.second != nullptr &&
-        // (*queue.second)->id != ""
-
-        if (queue.first->size() != 0 && queue.first->end() != queue.second && (*queue.second)->id != "") {
-            msg.content = "지금 재생 중:";
-            msg.add_embed((*queue.second)->embed);
-            event.edit_original_response(msg);
-        }
-        else {
-            msg.content = "재생 중인 노래가 없습니다";
-            event.edit_original_response(msg);
-        }
-
-        std::thread t([](std::queue<dpp::embed> queued, dpp::snowflake channel_id, dpp::cluster* cluster) {
-            std::mutex messageorder;
-            std::unique_lock lock(messageorder);
-            std::condition_variable messageSentCondition;
-            bool messagesent = false;
-            if (!queued.empty()) {
-                dpp::message followMsg(channel_id, "현재 큐에 있는 항목:");
-
-                followMsg.add_embed(queued.front());
-                messagesent = false;
-                cluster->message_create(followMsg, [&](const dpp::confirmation_callback_t &callback){
-                    messagesent = true;
-                    messageSentCondition.notify_all();
-                });
-
-                messageSentCondition.wait(lock, [&](){ return messagesent; });
-
-                queued.pop();
-            }
-            while (!queued.empty()) {
-                dpp::message followMsg(channel_id, "");
-
-                followMsg.add_embed(queued.front());
-
-                messagesent = false;
-                cluster->message_create(followMsg, [&](const dpp::confirmation_callback_t &callback){
-                    messagesent = true;
-                    messageSentCondition.notify_all();
-                });
-
-                messageSentCondition.wait(lock, [&](){ return messagesent; });
-                queued.pop();
-            }
-        }, queued, event.command.channel_id, event.from->creator);
-        t.detach();
+        return embed;
    }

-    void Queue::init() {
+    std::ostringstream Number;
+    int Start = Index;
+
+    for (; (Index < Start + 5) && (iter != end); iter++, Index++) {
+        Number.clear();
+        Number.str("");
+        Number << Index;
+        embed.add_field(
+            Number.str(),
+            "",
+            true
+        )
+        .add_field(
+            iter->title,
+            iter->description,
+            true
+        )
+        .add_field(
+            "",
+            ""
+        );
    }
+
+    if (iter == end) {
+        embed.set_timestamp(time(0));
+        if (Repeat)
+            embed.add_field(":repeat:","");
+    }
+
+    return embed;
+}
+}
+
+commands::Queue::Queue(std::shared_ptr<dpp::cluster> botCluster, std::unordered_map<dpp::snowflake, std::shared_ptr<MusicQueue>> *queueMap)
+    : VCCommand(botCluster)
+{
+    this->queueMap = queueMap;
+    dpp::slashcommand command = dpp::slashcommand("q", "노래 예약 큐 확인", botCluster->me.id);
+
+    commandObjectVector.push_back(command);
+}
+
+void commands::Queue::operator()(const dpp::slashcommand_t& event) {
+    dpp::message msg;
+    msg.set_channel_id(event.command.channel_id);
+    std::shared_ptr<MusicQueue> queue = getQueue(event);
+
+    if (queue->size() < 1) {
+        auto iter = queue->begin();
+        msg.add_embed(makeEmbed(iter, queue->end(), queue->repeat));
+    }
+    else {
+        msg.set_content("지금 재생 중:");
+        msg.add_embed(queue->peek(0).embed);
+    }
+
+    event.reply(msg, [this, queue, event](const dpp::confirmation_callback_t &_event) {
+        auto iter = queue->begin();
+        int queueSize = queue->size();
+        iter++;
+        for (int i = 0; i < ceil(queueSize / 5.0); i++) {
+            dpp::embed followEmbed = makeEmbed(iter, queue->end(), queue->repeat, i * 5 + 1);
+
+            dpp::message followMsg;
+            followMsg.channel_id = event.command.channel_id;
+
+            if (i == 0) {
+                followMsg.content = "현재 큐에 있는 항목:";
+            }
+            followMsg.add_embed(followEmbed);
+
+            botCluster->message_create(followMsg);
+        }
+    });
 }
--- a/src/Commands/Repeat.cpp
+++ b/src/Commands/Repeat.cpp
@@ -1,16 +1,27 @@
-#include <Commands/BumbleBeeCommand.hpp>
+#include <Commands/Repeat.hpp>
+#include <dpp/dpp.h>
+#include <string>

-namespace bumbleBee::commands {
-    void Repeat::execute(const dpp::slashcommand_t &event) {
-        if (musicManager->getRepeat(event.command.guild_id)) {
-            event.edit_original_response(dpp::message("반복을 껐습니다."));
-            musicManager->setRepeat(event.command.guild_id, false);
-        }
-        else {
-            event.edit_original_response(dpp::message("반복을 켰습니다."));
-            musicManager->setRepeat(event.command.guild_id, true);
-        }
+commands::Repeat::Repeat(std::shared_ptr<dpp::cluster> botCluster, std::unordered_map<dpp::snowflake, std::shared_ptr<MusicQueue>> *queueMap)
+    : VCCommand(botCluster)
+{
+    this->queueMap = queueMap;
+    dpp::slashcommand command = dpp::slashcommand("r", "반복 켜기/끄기", botCluster->me.id);
+
+    commandObjectVector.push_back(command);
+}
+
+void commands::Repeat::operator()(const dpp::slashcommand_t& event) {
+    std::shared_ptr<MusicQueue> queue = getQueue(event);
+
+    if (queue->repeat) {
+        event.reply("반복을 껐습니다.");
+        queue->repeat = false;
+    }
+    else {
+        event.reply("반복을 켰습니다.");
+        queue->repeat = true;
    }

-    void Repeat::init() {}
+    return;
 }
--- a/src/Commands/Shuffle.cpp
+++ b/src/Commands/Shuffle.cpp
@@ -1,10 +0,0 @@
-#include <Commands/BumbleBeeCommand.hpp>
-
-namespace bumbleBee::commands {
-    void Shuffle::execute(const dpp::slashcommand_t &event) {
-        event.edit_original_response(dpp::message("shuffle"));
-    }
-
-    void Shuffle::init() {
-    }
-}
--- a/src/Commands/Skip.cpp
+++ b/src/Commands/Skip.cpp
@@ -1,19 +1,29 @@
-#include <Commands/BumbleBeeCommand.hpp>
+#include <Commands/Skip.hpp>
+#include <dpp/dpp.h>
+#include <string>

-namespace bumbleBee::commands {
-    void Skip::execute(const dpp::slashcommand_t &event) {
-        dpp::voiceconn* v = event.from->get_voice(event.command.guild_id);
+commands::Skip::Skip(std::shared_ptr<dpp::cluster> botCluster, std::unordered_map<dpp::snowflake, std::shared_ptr<MusicQueue>> *queueMap)
+    : VCCommand(botCluster)
+{
+    this->queueMap = queueMap;
+    dpp::slashcommand command = dpp::slashcommand("s", "현재곡 스킵", botCluster->me.id);

-        if (!v || !v->voiceclient || !v->voiceclient->is_ready()) {
-            event.edit_original_response(dpp::message("스킵하려면 음악을 재생중이어야 합니다!"));
-            return;
-        }
-        v->voiceclient->stop_audio();
-        v->voiceclient->insert_marker();
+    commandObjectVector.push_back(command);
+}

-        event.edit_original_response(dpp::message("스킵했습니다!"));
+void commands::Skip::operator()(const dpp::slashcommand_t& event) {
+    dpp::voiceconn* v = event.from->get_voice(event.command.guild_id);
+
+    if (!v || !v->voiceclient || !v->voiceclient->is_ready()) {
+        return;
    }

-    void Skip::init() {
-    }
+    v->voiceclient->stop_audio();
+    v->voiceclient->insert_marker("next marker");
+
+    std::shared_ptr<MusicQueue> queue = getQueue(event);
+
+    event.reply("스킵했습니다!");
+
+    return;
 }
--- a/src/Music/Archive
+++ b/src/Music/Archive
@@ -0,0 +1 @@
+OSeStDEAZJQ
--- a/src/Music/OSeStDEAZJQ.info.json
+++ b/src/Music/OSeStDEAZJQ.info.json
--- a/src/Music/OSeStDEAZJQ.ogg
+++ b/src/Music/OSeStDEAZJQ.ogg
--- a/src/MusicQueue.cpp
+++ b/src/MusicQueue.cpp
@@ -0,0 +1,216 @@
+#include <MusicQueue.hpp>
+#include <ogg/ogg.h>
+#include <oggz/oggz.h>
+#include <opus/opusfile.h>
+#include <thread>
+
+MusicQueue::MusicQueue(FMusicQueueID id, std::shared_ptr<dpp::cluster> botCluster)
+{
+    this->id = id;
+    repeat = false;
+    this->botCluster = botCluster;
+
+    botCluster->on_voice_track_marker([this, botCluster](const dpp::voice_track_marker_t &marker)
+    {
+        std::cout << marker.track_meta << " Marker reached.\n";
+
+        if (empty())
+        {
+            std::cout << "Queue ended\n";
+            playMutex.unlock();
+            return;
+        }
+
+        auto music = pop(0);
+        if (repeat)
+        {
+            (*this) += music;
+        }
+        
+        markerCallback();
+    });
+}
+
+void MusicQueue::operator+=(FQueueElement operand)
+{
+    mutex.lock();
+    queue.push_back(operand);
+    mutex.unlock();
+}
+
+FQueueElement MusicQueue::pop(int index)
+{
+    mutex.lock();
+    auto iter = queue.begin();
+    std::advance(iter, index);
+    auto returnValue = *iter;
+    queue.erase(iter);
+    mutex.unlock();
+
+    return returnValue;
+}
+
+FQueueElement MusicQueue::peek(int index)
+{
+    mutex.lock();
+    auto iter = queue.begin();
+    std::advance(iter, index);
+    auto returnValue = *iter;
+    mutex.unlock();
+
+    return returnValue;
+}
+
+bool MusicQueue::empty()
+{
+    mutex.lock();
+    bool empty = queue.empty();
+    mutex.unlock();
+    
+    return empty;
+}
+
+void MusicQueue::clear()
+{
+    mutex.lock();
+    queue.clear();
+    mutex.unlock();
+}
+
+std::list<struct FQueueElement>::iterator MusicQueue::begin()
+{
+    mutex.lock();
+    auto returnValue = queue.begin();
+    mutex.unlock();
+
+    return returnValue;
+}
+
+std::list<struct FQueueElement>::iterator MusicQueue::end()
+{
+    mutex.lock();
+    auto returnValue = queue.end();
+    mutex.unlock();
+
+    return returnValue;
+}
+
+std::size_t MusicQueue::size()
+{
+    mutex.lock();
+    auto returnValue = queue.size();
+    mutex.unlock();
+
+    return returnValue;
+}
+
+FMusicQueueID MusicQueue::getId()
+{
+    return id;
+}
+
+void MusicQueue::markerCallback()
+{
+    std::cout << "Music play started\n";
+
+    dpp::discord_client* joinedShard = botCluster->get_shard(id.shard_id);
+    if (!joinedShard)
+    {
+        std::cout << "No shard\n";
+        return;
+    }
+
+    if (empty())
+    {
+        std::cout << "Queue ended\n";
+        playMutex.unlock();
+        return;
+    }
+
+    FQueueElement music = peek(0);
+
+    dpp::voiceconn* v = joinedShard->get_voice(id.guild_id);
+    if (!v || !v->voiceclient || !v->voiceclient->is_ready())
+    {
+        std::cout << "not in voicechat. quit musicplay";
+        return;
+    }
+
+    //v->voiceclient->error(4014);
+
+    /* load the audio file with oggz */
+    OGGZ *track_og = oggz_open(("Music/" + music.fileName + ".ogg").c_str(), OGGZ_READ);
+
+    /* If there was an issue reading the file, tell the user and stop */
+    if (!track_og) {
+        fprintf(stderr, "Error opening file\n");
+        return;
+    }
+
+    /* set read callback, this callback will be called on packets with the serialno,
+        * -1 means every packet will be handled with this callback.
+        */
+    oggz_set_read_callback(
+        track_og, -1,
+        [](OGGZ *oggz, oggz_packet *packet, long serialno, void *user_data) {
+            dpp::voiceconn *voiceconn = (dpp::voiceconn *)user_data;
+
+            /* send the audio */
+            voiceconn->voiceclient->send_audio_opus(packet->op.packet, packet->op.bytes);
+
+            /* make sure to always return 0 here, read more on oggz documentation */
+            return 0;
+        },
+        /* this will be the value of void *user_data */
+        (void *)v
+    );
+
+    // read loop
+    while (v && v->voiceclient && !v->voiceclient->terminating) {
+        /* you can tweak this to whatever. Here I use BUFSIZ, defined in
+            * stdio.h as 8192.
+            */
+        static const constexpr long CHUNK_READ = BUFSIZ * 2;
+
+        const long read_bytes = oggz_read(track_og, CHUNK_READ);
+
+        /* break on eof */
+        if (!read_bytes) {
+            break;
+        }
+    }
+
+    /* Don't forget to free the memory */
+    oggz_close(track_og);
+
+    v->voiceclient->insert_marker(music.fileName + " end");
+
+    std::cout << "audio sending complete\n";
+}
+
+void MusicQueue::play()
+{
+    if (!playMutex.try_lock())
+    {
+        std::cout << "Already playing\n";
+        return;
+    }
+
+    dpp::discord_client* joinedShard = botCluster->get_shard(id.shard_id);
+    if (!joinedShard)
+    {
+        std::cout << "No shard\n";
+        playMutex.unlock();
+        return;
+    }
+
+    dpp::voiceconn* v = joinedShard->get_voice(id.guild_id);
+    if (!v || !v->voiceclient || !v->voiceclient->is_ready())
+    {
+        std::cout << "not in voicechat. quit musicplay";
+        playMutex.unlock();
+        return;
+    }
+    
+    markerCallback();
+}
--- a/src/Queue/MusicQueue.cpp
+++ b/src/Queue/MusicQueue.cpp
@@ -1,115 +0,0 @@
-#include <Queue/MusicQueue.hpp>
-#include <iostream>
-#include <algorithm>
-#include <Utils/QueuedMusicListEmbedProvider.hpp>
-
-namespace bumbleBee {
-
-void MusicQueue::enqueue(std::shared_ptr<MusicQueueElement> Element) {
-    std::lock_guard<std::mutex> lock(queueMutex);
-        queue.push_back(Element);
-    if (queue.size() == 1) // 이전에 하나도 없었다는 말이므로.
-        currentPlayingPosition = queue.begin(); // 첫번째 곡으로 iterator를 옮겨준다.
-}
-
-std::shared_ptr<MusicQueueElement> MusicQueue::dequeue() {
-    std::lock_guard<std::mutex> lock(queueMutex);
-    auto value = queue.front();
-    queue.pop_front();
-    return value;
-}
-std::list<std::shared_ptr<MusicQueueElement>>::iterator MusicQueue::findById(std::string id) {
-    std::lock_guard<std::mutex> lock(queueMutex);
-    int index = 0;
-    for (auto iter = queue.begin(); iter != queue.end(); iter++) {
-        if ((*iter).get()->id == id)
-            return iter;
-    }
-    return queue.end();
-}
-std::list<std::shared_ptr<MusicQueueElement>>::iterator MusicQueue::findByIndex(int index) {
-    std::lock_guard<std::mutex> lock(queueMutex);
-    if (index < 0)
-        return queue.end();
-    if (index == 0)
-        return currentPlayingPosition;
-    return std::next(queue.begin(), index - 1);
-}
-std::shared_ptr<MusicQueueElement> MusicQueue::nowplaying() {
-    std::lock_guard<std::mutex> lock(queueMutex);
-    if (currentPlayingPosition == queue.end())
-        return nullptr;
-    else
-        return *currentPlayingPosition;
-}
-std::list<std::shared_ptr<MusicQueueElement>>::iterator MusicQueue::next_music() {
-    std::lock_guard<std::mutex> lock(queueMutex);
-    if (currentPlayingPosition == --queue.end() && repeat)
-        currentPlayingPosition = queue.begin();
-    else if (currentPlayingPosition == --queue.end() && !repeat) // 반복이 꺼져있을 때 큐 재생이 끝난 경우
-        currentPlayingPosition = queue.end();
-    else if (currentPlayingPosition == queue.end() && !repeat) // 반복이 꺼져있고 현재 재생 곡이 없는데 새 곡이 들어왔을 경우
-        currentPlayingPosition = --queue.end();
-    else
-        ++currentPlayingPosition;
-    return currentPlayingPosition;
-}
-std::shared_ptr<MusicQueueElement> MusicQueue::jump_to_index(int idx) {
-    std::lock_guard<std::mutex> lock(queueMutex);
-    int index = 0;
-    for (auto iter = queue.begin(); iter != queue.end(); iter++) {
-        if (idx == index++) {
-            currentPlayingPosition = iter;
-            return *iter;
-        }
-    }
-    return std::shared_ptr<MusicQueueElement>();
-}
-void MusicQueue::clear() {
-    std::lock_guard<std::mutex> lock(queueMutex);
-    queue.clear();
-    currentPlayingPosition = queue.begin();
-}
-std::shared_ptr<MusicQueueElement> MusicQueue::erase(std::list<std::shared_ptr<MusicQueueElement>>::iterator it) {
-    std::lock_guard<std::mutex> lock(queueMutex);
-    if (it == queue.end())
-        return nullptr;
-    
-    if (currentPlayingPosition == it) {
-        auto removedValue = *it;
-        auto after = queue.erase(currentPlayingPosition++);
-        if (after == queue.end())
-            currentPlayingPosition = --queue.end();
-        return removedValue;
-    }
-    else {
-        auto removedValue = *it;
-        queue.erase(it);
-        return removedValue;
-    }
-}
-std::pair<std::shared_ptr<std::list<std::shared_ptr<MusicQueueElement>>>, std::list<std::shared_ptr<MusicQueueElement>>::iterator>
-    MusicQueue::getQueueCopy() {
-    std::lock_guard<std::mutex> lock(queueMutex);
-    std::shared_ptr<std::list<std::shared_ptr<MusicQueueElement>>> returnValue = std::make_shared<std::list<std::shared_ptr<MusicQueueElement>>>();
-
-    for (auto i = queue.begin(); i != queue.end(); i++)
-        returnValue->push_back(*i);
-
-    if (returnValue->begin() == returnValue->end() || currentPlayingPosition == queue.end())
-        return std::make_pair(returnValue, returnValue->end());
-
-    std::list<std::shared_ptr<MusicQueueElement>>::iterator iter = returnValue->begin();
-    std::advance(iter, std::distance(queue.begin(), currentPlayingPosition));
-
-    return std::make_pair(returnValue, iter);
-}
-int MusicQueue::size() {
-    std::lock_guard<std::mutex> lock(queueMutex);
-    return queue.size();
-}
-std::list<std::shared_ptr<MusicQueueElement>>::iterator MusicQueue::end() {
-    std::lock_guard<std::mutex> lock(queueMutex);
-    return queue.end();
-}
-}
--- a/src/Settings/SettingsManager.cpp
+++ b/src/Settings/SettingsManager.cpp
@@ -1,118 +0,0 @@
-#include <Settings/SettingsManager.hpp>
-#include <dpp/nlohmann/json.hpp>
-#include <Utils/ConsoleUtils.hpp>
-#include <fstream>
-#include <sstream>
-
-namespace bumbleBee {
-
-std::string SettingsManager::TOKEN = "";
-std::string SettingsManager::YTDLP_CMD = "./yt-dlp";
-std::string SettingsManager::FFMPEG_CMD = "./ffmpeg";
-dpp::loglevel SettingsManager::LOGLEVEL = dpp::ll_debug;
-bool SettingsManager::REGISTER_COMMAND = false;
-
-bool SettingsManager::validateToken() {
-    nlohmann::json response;
-    if (ConsoleUtils::getResultFromCommand("which curl").size() == 0) {
-        std::cout << "curl is unavaliable. unresolable error please install curl." << std::endl;
-        return false;
-    }
-
-    std::string stresult = ConsoleUtils::getResultFromCommand("curl -sX GET \"https://discord.com/api/v10/users/@me\" -H \"Authorization: Bot " +
-        TOKEN + "\"").front();
-    std::stringstream ss(stresult);
-    ss >> response;
-
-    if (response.contains("message") && response["message"] == "401: Unauthorized") {
-        std::cout << "Token is invalid" << std::endl;
-        return false;
-    }
-    else
-        return true;
-}
-
-bool SettingsManager::load() {
-    nlohmann::json configdocument;
-    try {
-        std::ifstream configfile("config.json");
-        if (!configfile) {
-            saveToFile();
-            return false;
-        }
-        configfile >> configdocument;
-
-        TOKEN = configdocument["TOKEN"];
-
-        if (!validateToken())
-            return false;
-
-        YTDLP_CMD = configdocument["YTDLP_CMD"];
-        FFMPEG_CMD = configdocument["FFMPEG_CMD"];
-
-        std::string level = configdocument["LOGLEVEL"];
-        
-        std::transform(level.begin(), level.end(), level.begin(), ::tolower);
-        if (level == "trace")
-            LOGLEVEL = dpp::ll_trace;
-        else if (level == "debug")
-            LOGLEVEL = dpp::ll_debug;
-        else if (level == "warning")
-            LOGLEVEL = dpp::ll_warning;
-        else if (level == "error")
-            LOGLEVEL = dpp::ll_error;
-        else if (level == "critical")
-            LOGLEVEL = dpp::ll_critical;
-        else // 값이 병신같을때 기본값으로 ll_info 부여
-            LOGLEVEL = dpp::ll_info;
-
-        REGISTER_COMMAND = configdocument["CLEAR_PREVIOUS_COMMAND"];
-    }
-    catch (const nlohmann::json::type_error& e) {
-        saveToFile();
-        return load();
-    }
-    catch (const nlohmann::json::parse_error& e) {
-        saveToFile();
-        return load();
-    }
-    return true;
-}
-
-void SettingsManager::saveToFile() {
-    nlohmann::json configdocument;
-
-    configdocument["TOKEN"] = TOKEN;
-    configdocument["YTDLP_CMD"] = YTDLP_CMD;
-    configdocument["FFMPEG_CMD"] = FFMPEG_CMD;
-
-    switch (LOGLEVEL) {
-    case dpp::ll_trace:
-        configdocument["LOGLEVEL"] = "trace";
-        break;
-    case dpp::ll_debug:
-        configdocument["LOGLEVEL"] = "debug";
-        break;
-    case dpp::ll_info:
-        configdocument["LOGLEVEL"] = "info";
-        break;
-    case dpp::ll_warning:
-        configdocument["LOGLEVEL"] = "warning";
-        break;
-    case dpp::ll_error:
-        configdocument["LOGLEVEL"] = "error";
-        break;
-    default:
-        configdocument["LOGLEVEL"] = "critical";
-        break;
-    }
-    
-    configdocument["CLEAR_PREVIOUS_COMMAND"] = REGISTER_COMMAND;
-
-    std::ofstream configFile("config.json");
-    if (configFile.is_open()) {
-        configFile << configdocument.dump(4);
-        configFile.close();
-    }
-}
-}
--- a/src/Utils/AsyncDownloadManager.cpp
+++ b/src/Utils/AsyncDownloadManager.cpp
@@ -1,86 +0,0 @@
-#include <Utils/AsyncDownloadManager.hpp>
-#include <sstream>
-#include "Utils/ConsoleUtils.hpp"
-#include "Settings/SettingsManager.hpp"
-#include <ogg/ogg.h>
-#include <oggz/oggz.h>
-#include <opus/opusfile.h>
-#include <memory>
-
-namespace bumbleBee {
-void AsyncDownloadManager::enqueueAsyncDL(std::pair<std::string, dpp::message> query) {
-    std::lock_guard<std::mutex> lock(dlQueueMutex);
-    downloadQueue.push(query);
-    dlQueueCondition.notify_one();
-}
-
-void AsyncDownloadManager::downloadWorker() {
-    std::ostringstream tid;
-    tid << std::this_thread::get_id();
-    while (true) {
-        //mutex lock
-        std::unique_lock<std::mutex> dlQueueLock(dlQueueMutex);
-        dlQueueCondition.wait(dlQueueLock, [&]{ return !downloadQueue.empty() || terminate; });
-        auto cluster = weak_cluster.lock();
-        if (weak_cluster.expired()) {
-            cluster->log(dpp::ll_error, "Missing cluster, terminating thread " + tid.str());
-            break;
-        }
-        if (terminate) {
-            cluster->log(dpp::ll_info, "Terminating thread " + tid.str());
-            break;
-        }
-        std::string query = downloadQueue.front().first;
-        dpp::message oRes = downloadQueue.front().second;
-        downloadQueue.pop();
-        dlQueueLock.unlock();
-
-        cluster->log(dpp::ll_info, "AsyncDownloadManager: " + query + " accepted.");
-
-        std::queue<std::string> ids =
-            ConsoleUtils::getResultFromCommand(SettingsManager::getYTDLP_CMD() +
-            " --default-search ytsearch --flat-playlist --skip-download --quiet --ignore-errors --print id " + query);
-
-        if (ids.size() >= 2) {
-            cluster->log(dpp::ll_info, query + " is playlist");
-            while (!ids.empty()) {
-                if (ids.front() == "") {
-                    ids.pop();
-                    continue;
-                }
-                cluster->log(dpp::ll_info, "Enqueuing playlist element " + ids.front());
-                enqueue(std::make_pair("https://youtu.be/" + ids.front(), oRes));
-                ids.pop();
-            }
-            continue;
-        }
-
-        std::queue<std::string> urls =
-            ConsoleUtils::getResultFromCommand(SettingsManager::getYTDLP_CMD() +
-            " -f ba* --print urls https://youtu.be/" + ids.front());
-
-        cluster->log(dpp::ll_debug, "url: " + urls.front());
-
-        FILE* stream;
-
-        // musicQueue->enqueue(std::make_shared<MusicQueueElement>(oRes, ids.front(), urls.front(), stream));
-
-        std::string downloadID = ids.front();
-
-        std::thread th([&, downloadID](){
-            if (terminate)
-                return;
-            std::ostringstream tid;
-            tid << std::this_thread::get_id();
-
-            cluster->log(dpp::ll_info, "Thread id: " + tid.str() + ": " + downloadID + " accepted.");
-
-            std::string command = std::string("./streamOpus.sh " + SettingsManager::getYTDLP_CMD() + " " + downloadID + " " + SettingsManager::getFFMPEG_CMD());
-            stream = popen(command.c_str(), "r");
-
-            cluster->log(dpp::ll_info, "Thread id: " + tid.str() + " Opened stream: " + downloadID);
-        });
-        th.detach();
-    }
-}
-}
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -1,8 +1,18 @@
-#include <iostream>
-#include <BumbleBee.hpp>
-#include <thread>
+#include <BumbleCeepp.hpp>
+#include <dpp/nlohmann/json.hpp>
+#include <memory>

-int main() {
-    bumbleBee::BumbleBee bot;
-    bot.start();
+using json = nlohmann::json;
+
+int main()
+{
+    json configdocument;
+    std::ifstream configfile("config.json");
+    configfile >> configdocument;
+
+    std::shared_ptr<BumbleCeepp> bumbleBee = std::make_shared<BumbleCeepp>(configdocument["token"], 1);
+
+    bumbleBee->start();
+
+    return 0;
 }
--- a/src/out
+++ b/src/out
--- a/src/yt-dlp
+++ b/src/yt-dlp
--- a/src/yt-download.py
+++ b/src/yt-download.py
@@ -0,0 +1,47 @@
+import yt_dlp
+import sys
+import os
+import json
+
+if len(sys.argv) != 2:
+    sys.exit()
+
+ydl_opts = {
+    'quiet': True,
+    'clean_infojson': False,
+    'default_search': 'ytsearch',
+    'format': '251',
+    'outtmpl': {'default': 'Temp/%(id)s.temp'},
+    'overwrites': False,
+    'writeinfojson': True }
+
+with yt_dlp.YoutubeDL(ydl_opts) as ydl:
+    info = ydl.extract_info(sys.argv[1], download=False)
+    id = list()
+    with open("out", "w") as f:
+        f.write(json.dumps(ydl.sanitize_info(info)))
+    with open("Music/Archive", "r") as f:
+        ArchiveList = f.read().split("\n")
+        if "entries" in info:
+            if len(info["entries"]) != 0:
+                for entry in info["entries"]:
+                    if entry["id"] not in ArchiveList:
+                        ydl.download(entry["webpage_url"])
+                        os.system("echo " + entry["id"] + " >> Music/Archive")
+                        os.system("yes n 2>/dev/null | ffmpeg -hide_banner -loglevel error -i \"" + "Temp/" + entry["id"] + ".temp" + "\" -c copy Music/" + entry["id"] + ".ogg")
+                        os.system("mv Temp/" + entry["id"] + ".temp.info.json Music/" + entry["id"] + ".info.json")
+                    id.append(entry["id"])
+        else:
+            if info["id"] not in ArchiveList:
+                ydl.download(info["webpage_url"])
+                os.system("echo " + info["id"] + " >> Music/Archive")
+                os.system("yes n 2>/dev/null | ffmpeg -hide_banner -loglevel error -i \"" + "Temp/" + info["id"] + ".temp" + "\" -c copy Music/" + info["id"] + ".ogg")
+                os.system("mv Temp/" + info["id"] + ".temp.info.json Music/" + info["id"] + ".info.json")
+            id.append(info["id"])
+
+    os.system("rm -f Temp/*.temp")
+    os.system("rm -f Temp/*.json")
+
+    with open("Temp/CurMusic", "w") as f:
+        for item in id:
+            f.write(item + "\n")
--- a/streamOpus.sh
+++ b/streamOpus.sh
@@ -1,12 +0,0 @@
-#!/bin/bash
-
-YTDLP_CMD=$1
-FFMPEG_CMD=$2
-URL=$3
-
-$YTDLP_CMD -o - --quiet --ignore-errors -f bestaudio $URL 2>/dev/null | \
-$FFMPEG_CMD -hwaccel vaapi -i - -loglevel quiet -hide_banner -c:a copy -f opus - || \
-$YTDLP_CMD -o - --quiet --ignore-errors -f bestaudio $URL 2>/dev/null | \
-$FFMPEG_CMD -hwaccel vaapi -i - -loglevel quiet -hide_banner -f opus -c:a libopus -b:a 128k -ar 48000 -ac 2 -
-
-#  -loglevel quiet
--- a/BIN
+++ b/BIN